ladybird/Userland/Libraries/LibCpp/Tests/strace.ast

TranslationUnit[0:0->144:0]
  VariableDeclaration[0:0->2:0]
    NamedType[0:0->0:11]
      [static] int
    g_pid
    UnaryExpression[0:19->0:20]
      -
      NumericLiteral[0:20->0:20]
      1
  FunctionDeclaration[2:0->10:0]
    [static]
    NamedType[2:7->2:12]
      void
    handle_sigint
    (
    Parameter[2:26->2:29]
      NamedType[2:26->2:29]
        int
    )
    FunctionDefinition[3:0->10:0]
    {
      IfStatement[4:4->5:14]
        Predicate:
        BinaryExpression[4:8->4:18]
          Name[4:8->4:14]
          g_pid
          ==
          UnaryExpression[4:17->4:18]
            -
            NumericLiteral[4:18->4:18]
            1
        Then:
        ReturnStatement[5:8->5:14]
      IfStatement[7:4->10:0]
        Predicate:
        BinaryExpression[7:8->7:43]
          FunctionCall[7:8->7:39]
            Name[7:8->7:14]
            ptrace
            Name[7:15->7:24]
            PT_DETACH
            Name[7:26->7:31]
            g_pid
            NumericLiteral[7:33->7:33]
            0
            NumericLiteral[7:36->7:36]
            0
          ==
          UnaryExpression[7:42->7:43]
            -
            NumericLiteral[7:43->7:43]
            1
        Then:
        BlockStatement[7:46->10:0]
          FunctionCall[8:8->8:24]
            Name[8:8->8:14]
            perror
            StringLiteral[8:15->8:22]
              "detach"
    }
  FunctionDeclaration[12:0->144:0]
    NamedType[12:0->12:4]
      int
    main
    (
    Parameter[12:9->12:16]
    argc
      NamedType[12:9->12:13]
        int
    Parameter[12:19->12:29]
    argv
      Pointer[12:19->12:26]
        Pointer[12:19->12:24]
          NamedType[12:19->12:23]
            char
    )
    FunctionDefinition[13:0->144:0]
    {
      IfStatement[14:4->19:4]
        Predicate:
        BinaryExpression[14:8->14:74]
          FunctionCall[14:8->14:72]
            Name[14:8->14:14]
            pledge
            StringLiteral[14:15->14:60]
              "stdio wpath cpath proc exec ptrace sigaction"
            NullPointerLiteral[14:63->14:69]
          <
          NumericLiteral[14:74->14:74]
          0
        Then:
        BlockStatement[14:77->19:4]
          FunctionCall[15:8->15:24]
            Name[15:8->15:14]
            perror
            StringLiteral[15:15->15:22]
              "pledge"
          ReturnStatement[16:8->16:16]
            NumericLiteral[16:15->16:15]
            1
      VariableDeclaration[19:4->19:34]
        NamedType[19:4->19:24]
          Vector<[const] char*>
        child_argv
      VariableDeclaration[21:4->21:41]
        Pointer[21:4->21:16]
          NamedType[21:4->21:14]
            [const] char
        output_filename
        NullPointerLiteral[21:34->21:40]
      VariableDeclaration[22:4->22:50]
        NamedType[22:4->22:9]
          auto
        trace_file
        FunctionCall[22:22->22:50]
          Name[22:22->22:48]
          Core::File::standard_error
      VariableDeclaration[24:4->24:27]
        NamedType[24:4->24:21]
          Core::ArgsParser
        parser
      FunctionCall[25:4->26:47]
        MemberExpression[25:4->25:27]
          Name[25:4->25:10]
          parser
          Identifier[25:11->25:26]
          set_general_help
        StringLiteral[26:8->26:45]
          "Trace all syscalls and their result."
      FunctionCall[27:4->27:70]
        MemberExpression[27:4->27:21]
          Name[27:4->27:10]
          parser
          Identifier[27:11->27:20]
          add_option
        Name[27:22->27:27]
        g_pid
        StringLiteral[27:29->27:49]
          "Trace the given PID"
        StringLiteral[27:52->27:56]
          "pid"
        StringLiteral[27:59->27:61]
          'p'
        StringLiteral[27:64->27:68]
          "pid"
      FunctionCall[28:4->28:94]
        MemberExpression[28:4->28:21]
          Name[28:4->28:10]
          parser
          Identifier[28:11->28:20]
          add_option
        Name[28:22->28:37]
        output_filename
        StringLiteral[28:39->28:67]
          "Filename to write output to"
        StringLiteral[28:70->28:77]
          "output"
        StringLiteral[28:80->28:82]
          'o'
        StringLiteral[28:85->28:92]
          "output"
      FunctionCall[29:4->29:111]
        MemberExpression[29:4->29:34]
          Name[29:4->29:10]
          parser
          Identifier[29:11->29:33]
          add_positional_argument
        Name[29:35->29:45]
        child_argv
        StringLiteral[29:47->29:65]
          "Arguments to exec"
        StringLiteral[29:68->29:77]
          "argument"
        Name[29:80->29:110]
        Core::ArgsParser::Required::No
      FunctionCall[31:4->31:28]
        MemberExpression[31:4->31:16]
          Name[31:4->31:10]
          parser
          Identifier[31:11->31:15]
          parse
        Name[31:17->31:21]
        argc
        Name[31:23->31:27]
        argv
      IfStatement[33:4->42:4]
        Predicate:
        BinaryExpression[33:8->33:33]
          Name[33:8->33:24]
          output_filename
          !=
          NullPointerLiteral[33:27->33:33]
        Then:
        BlockStatement[33:36->42:4]
          VariableDeclaration[34:8->34:87]
            NamedType[34:8->34:13]
              auto
            open_result
            FunctionCall[34:27->34:87]
              Name[34:27->34:43]
              Core::File::open
              Name[34:44->34:59]
              output_filename
              Name[34:61->34:86]
              Core::OpenMode::WriteOnly
          IfStatement[35:8->39:8]
            Predicate:
            FunctionCall[35:12->35:34]
              MemberExpression[35:12->35:32]
                Name[35:12->35:23]
                open_result
                Identifier[35:24->35:31]
                is_error
            Then:
            BlockStatement[35:36->39:8]
              FunctionCall[36:12->36:80]
                Name[36:12->36:17]
                outln
                Name[36:18->36:24]
                stderr
                StringLiteral[36:26->36:57]
                  "Failed to open output file: {}"
                FunctionCall[36:60->36:79]
                  MemberExpression[36:60->36:77]
                    Name[36:60->36:71]
                    open_result
                    Identifier[36:72->36:76]
                    error
              ReturnStatement[37:12->37:20]
                NumericLiteral[37:19->37:19]
                1
          AssignmentExpression[39:8->39:40]
            Name[39:8->39:19]
            trace_file
            =
            FunctionCall[39:21->39:40]
              MemberExpression[39:21->39:38]
                Name[39:21->39:32]
                open_result
                Identifier[39:33->39:37]
                value
      IfStatement[42:4->47:4]
        Predicate:
        BinaryExpression[42:8->42:62]
          FunctionCall[42:8->42:60]
            Name[42:8->42:14]
            pledge
            StringLiteral[42:15->42:48]
              "stdio proc exec ptrace sigaction"
            NullPointerLiteral[42:51->42:57]
          <
          NumericLiteral[42:62->42:62]
          0
        Then:
        BlockStatement[42:65->47:4]
          FunctionCall[43:8->43:24]
            Name[43:8->43:14]
            perror
            StringLiteral[43:15->43:22]
              "pledge"
          ReturnStatement[44:8->44:16]
            NumericLiteral[44:15->44:15]
            1
      VariableDeclaration[47:4->47:14]
        NamedType[47:4->47:8]
          int
        status
      IfStatement[48:4->81:4]
        Predicate:
        BinaryExpression[48:8->48:18]
          Name[48:8->48:14]
          g_pid
          ==
          UnaryExpression[48:17->48:18]
            -
            NumericLiteral[48:18->48:18]
            1
        Then:
        BlockStatement[48:21->81:4]
          IfStatement[49:8->54:8]
            Predicate:
            FunctionCall[49:12->49:33]
              MemberExpression[49:12->49:31]
                Name[49:12->49:22]
                child_argv
                Identifier[49:23->49:30]
                is_empty
            Then:
            BlockStatement[49:35->54:8]
              FunctionCall[50:12->50:78]
                Name[50:12->50:17]
                outln
                Name[50:18->50:24]
                stderr
                StringLiteral[50:26->50:76]
                  "strace: Expected either a pid or some arguments\n"
              ReturnStatement[51:12->51:20]
                NumericLiteral[51:19->51:19]
                1
          FunctionCall[54:8->54:34]
            MemberExpression[54:8->54:25]
              Name[54:8->54:18]
              child_argv
              Identifier[54:19->54:24]
              append
            NullPointerLiteral[54:26->54:32]
          VariableDeclaration[55:8->55:24]
            NamedType[55:8->55:12]
              int
            pid
            FunctionCall[55:18->55:24]
              Name[55:18->55:22]
              fork
          IfStatement[56:8->61:8]
            Predicate:
            BinaryExpression[56:12->56:18]
              Name[56:12->56:16]
              pid
              <
              NumericLiteral[56:18->56:18]
              0
            Then:
            BlockStatement[56:21->61:8]
              FunctionCall[57:12->57:26]
                Name[57:12->57:18]
                perror
                StringLiteral[57:19->57:24]
                  "fork"
              ReturnStatement[58:12->58:20]
                NumericLiteral[58:19->58:19]
                1
          IfStatement[61:8->74:8]
            Predicate:
            UnaryExpression[61:12->61:16]
              !
              Name[61:13->61:16]
              pid
            Then:
            BlockStatement[61:18->74:8]
              IfStatement[62:12->66:12]
                Predicate:
                BinaryExpression[62:16->62:49]
                  FunctionCall[62:16->62:45]
                    Name[62:16->62:22]
                    ptrace
                    Name[62:23->62:34]
                    PT_TRACE_ME
                    NumericLiteral[62:36->62:36]
                    0
                    NumericLiteral[62:39->62:39]
                    0
                    NumericLiteral[62:42->62:42]
                    0
                  ==
                  UnaryExpression[62:48->62:49]
                    -
                    NumericLiteral[62:49->62:49]
                    1
                Then:
                BlockStatement[62:52->66:12]
                  FunctionCall[63:16->63:33]
                    Name[63:16->63:22]
                    perror
                    StringLiteral[63:23->63:31]
                      "traceme"
                  ReturnStatement[64:16->64:24]
                    NumericLiteral[64:23->64:23]
                    1
              VariableDeclaration[66:12->66:86]
                NamedType[66:12->66:16]
                  int
                rc
                FunctionCall[66:21->66:86]
                  Name[66:21->66:27]
                  execvp
                  FunctionCall[66:28->66:46]
                    MemberExpression[66:28->66:44]
                      Name[66:28->66:38]
                      child_argv
                      Identifier[66:39->66:43]
                      first
                  CppCastExpression[66:48->66:85]
                  const_cast
                    <
                    Pointer[66:59->66:65]
                      Pointer[66:59->66:64]
                        NamedType[66:59->66:63]
                          char
                    >
                    FunctionCall[66:67->66:84]
                      MemberExpression[66:67->66:82]
                        Name[66:67->66:77]
                        child_argv
                        Identifier[66:78->66:81]
                        data
              IfStatement[67:12->71:12]
                Predicate:
                BinaryExpression[67:16->67:21]
                  Name[67:16->67:19]
                  rc
                  <
                  NumericLiteral[67:21->67:21]
                  0
                Then:
                BlockStatement[67:24->71:12]
                  FunctionCall[68:16->68:32]
                    Name[68:16->68:22]
                    perror
                    StringLiteral[68:23->68:30]
                      "execvp"
                  FunctionCall[69:16->69:23]
                    Name[69:16->69:20]
                    exit
                    NumericLiteral[69:21->69:21]
                    1
              FunctionCall[71:12->71:32]
                Name[71:12->71:30]
                VERIFY_NOT_REACHED
          AssignmentExpression[74:8->74:19]
            Name[74:8->74:14]
            g_pid
            =
            Name[74:16->74:19]
            pid
          IfStatement[75:8->79:4]
            Predicate:
            BinaryExpression[75:12->75:83]
              FunctionCall[75:12->75:54]
                Name[75:12->75:19]
                waitpid
                Name[75:20->75:23]
                pid
                UnaryExpression[75:25->75:32]
                  &
                  Name[75:26->75:32]
                  status
                BinaryExpression[75:34->75:52]
                  Name[75:34->75:43]
                  WSTOPPED
                  |
                  Name[75:45->75:52]
                  WEXITED
              !=
              BinaryExpression[75:57->75:83]
                Name[75:57->75:61]
                pid
                ||
                UnaryExpression[75:64->75:83]
                  !
                  FunctionCall[75:65->75:83]
                    Name[75:65->75:75]
                    WIFSTOPPED
                    Name[75:76->75:82]
                    status
            Then:
            BlockStatement[75:85->79:4]
              FunctionCall[76:12->76:29]
                Name[76:12->76:18]
                perror
                StringLiteral[76:19->76:27]
                  "waitpid"
              ReturnStatement[77:12->77:20]
                NumericLiteral[77:19->77:19]
                1
      VariableDeclaration[81:4->81:23]
        NamedType[81:4->81:21]
          sigaction
        sa
      FunctionCall[82:4->82:44]
        Name[82:4->82:10]
        memset
        UnaryExpression[82:11->82:14]
          &
          Name[82:12->82:14]
          sa
        NumericLiteral[82:16->82:16]
        0
        SizeofExpression[82:19->82:43]
          NamedType[82:26->82:42]
            sigaction
      AssignmentExpression[83:4->83:33]
        MemberExpression[83:4->83:18]
          Name[83:4->83:6]
          sa
          Identifier[83:7->83:16]
          sa_handler
        =
        Name[83:20->83:33]
        handle_sigint
      FunctionCall[84:4->84:35]
        Name[84:4->84:13]
        sigaction
        Name[84:14->84:20]
        SIGINT
        UnaryExpression[84:22->84:25]
          &
          Name[84:23->84:25]
          sa
        NullPointerLiteral[84:27->84:33]
      IfStatement[86:4->90:4]
        Predicate:
        BinaryExpression[86:8->86:43]
          FunctionCall[86:8->86:39]
            Name[86:8->86:14]
            ptrace
            Name[86:15->86:24]
            PT_ATTACH
            Name[86:26->86:31]
            g_pid
            NumericLiteral[86:33->86:33]
            0
            NumericLiteral[86:36->86:36]
            0
          ==
          UnaryExpression[86:42->86:43]
            -
            NumericLiteral[86:43->86:43]
            1
        Then:
        BlockStatement[86:46->90:4]
          FunctionCall[87:8->87:24]
            Name[87:8->87:14]
            perror
            StringLiteral[87:15->87:22]
              "attach"
          ReturnStatement[88:8->88:16]
            NumericLiteral[88:15->88:15]
            1
      IfStatement[90:4->95:4]
        Predicate:
        BinaryExpression[90:8->90:83]
          FunctionCall[90:8->90:52]
            Name[90:8->90:15]
            waitpid
            Name[90:16->90:21]
            g_pid
            UnaryExpression[90:23->90:30]
              &
              Name[90:24->90:30]
              status
            BinaryExpression[90:32->90:50]
              Name[90:32->90:41]
              WSTOPPED
              |
              Name[90:43->90:50]
              WEXITED
          !=
          BinaryExpression[90:55->90:83]
            Name[90:55->90:61]
            g_pid
            ||
            UnaryExpression[90:64->90:83]
              !
              FunctionCall[90:65->90:83]
                Name[90:65->90:75]
                WIFSTOPPED
                Name[90:76->90:82]
                status
        Then:
        BlockStatement[90:85->95:4]
          FunctionCall[91:8->91:25]
            Name[91:8->91:14]
            perror
            StringLiteral[91:15->91:23]
              "waitpid"
          ReturnStatement[92:8->92:16]
            NumericLiteral[92:15->92:15]
            1
      ForStatement[95:4->143:4]
        BlockStatement[95:13->143:4]
          IfStatement[96:8->100:8]
            Predicate:
            BinaryExpression[96:12->96:48]
              FunctionCall[96:12->96:44]
                Name[96:12->96:18]
                ptrace
                Name[96:19->96:29]
                PT_SYSCALL
                Name[96:31->96:36]
                g_pid
                NumericLiteral[96:38->96:38]
                0
                NumericLiteral[96:41->96:41]
                0
              ==
              UnaryExpression[96:47->96:48]
                -
                NumericLiteral[96:48->96:48]
                1
            Then:
            BlockStatement[96:51->100:8]
              FunctionCall[97:12->97:29]
                Name[97:12->97:18]
                perror
                StringLiteral[97:19->97:27]
                  "syscall"
              ReturnStatement[98:12->98:20]
                NumericLiteral[98:19->98:19]
                1
          IfStatement[100:8->104:8]
            Predicate:
            BinaryExpression[100:12->100:87]
              FunctionCall[100:12->100:56]
                Name[100:12->100:19]
                waitpid
                Name[100:20->100:25]
                g_pid
                UnaryExpression[100:27->100:34]
                  &
                  Name[100:28->100:34]
                  status
                BinaryExpression[100:36->100:54]
                  Name[100:36->100:45]
                  WSTOPPED
                  |
                  Name[100:47->100:54]
                  WEXITED
              !=
              BinaryExpression[100:59->100:87]
                Name[100:59->100:65]
                g_pid
                ||
                UnaryExpression[100:68->100:87]
                  !
                  FunctionCall[100:69->100:87]
                    Name[100:69->100:79]
                    WIFSTOPPED
                    Name[100:80->100:86]
                    status
            Then:
            BlockStatement[100:89->104:8]
              FunctionCall[101:12->101:30]
                Name[101:12->101:18]
                perror
                StringLiteral[101:19->101:28]
                  "wait_pid"
              ReturnStatement[102:12->102:20]
                NumericLiteral[102:19->102:19]
                1
          VariableDeclaration[104:8->104:33]
            NamedType[104:8->104:24]
              PtraceRegisters
            regs
            BracedInitList[104:31->104:33]
          IfStatement[105:8->109:8]
            Predicate:
            BinaryExpression[105:12->105:52]
              FunctionCall[105:12->105:48]
                Name[105:12->105:18]
                ptrace
                Name[105:19->105:29]
                PT_GETREGS
                Name[105:31->105:36]
                g_pid
                UnaryExpression[105:38->105:43]
                  &
                  Name[105:39->105:43]
                  regs
                NumericLiteral[105:45->105:45]
                0
              ==
              UnaryExpression[105:51->105:52]
                -
                NumericLiteral[105:52->105:52]
                1
            Then:
            BlockStatement[105:55->109:8]
              FunctionCall[106:12->106:29]
                Name[106:12->106:18]
                perror
                StringLiteral[106:19->106:27]
                  "getregs"
              ReturnStatement[107:12->107:20]
                NumericLiteral[107:19->107:19]
                1
          VariableDeclaration[109:8->109:36]
            NamedType[109:8->109:12]
              u32
            syscall_index
            MemberExpression[109:28->109:36]
              Name[109:28->109:32]
              regs
              Identifier[109:33->109:35]
              eax
          VariableDeclaration[110:8->110:27]
            NamedType[110:8->110:12]
              u32
            arg1
            MemberExpression[110:19->110:27]
              Name[110:19->110:23]
              regs
              Identifier[110:24->110:26]
              edx
          VariableDeclaration[111:8->111:27]
            NamedType[111:8->111:12]
              u32
            arg2
            MemberExpression[111:19->111:27]
              Name[111:19->111:23]
              regs
              Identifier[111:24->111:26]
              ecx
          VariableDeclaration[112:8->112:27]
            NamedType[112:8->112:12]
              u32
            arg3
            MemberExpression[112:19->112:27]
              Name[112:19->112:23]
              regs
              Identifier[112:24->112:26]
              ebx
          IfStatement[114:8->118:8]
            Predicate:
            BinaryExpression[114:12->114:48]
              FunctionCall[114:12->114:44]
                Name[114:12->114:18]
                ptrace
                Name[114:19->114:29]
                PT_SYSCALL
                Name[114:31->114:36]
                g_pid
                NumericLiteral[114:38->114:38]
                0
                NumericLiteral[114:41->114:41]
                0
              ==
              UnaryExpression[114:47->114:48]
                -
                NumericLiteral[114:48->114:48]
                1
            Then:
            BlockStatement[114:51->118:8]
              FunctionCall[115:12->115:29]
                Name[115:12->115:18]
                perror
                StringLiteral[115:19->115:27]
                  "syscall"
              ReturnStatement[116:12->116:20]
                NumericLiteral[116:19->116:19]
                1
          IfStatement[118:8->123:8]
            Predicate:
            BinaryExpression[118:12->118:87]
              FunctionCall[118:12->118:56]
                Name[118:12->118:19]
                waitpid
                Name[118:20->118:25]
                g_pid
                UnaryExpression[118:27->118:34]
                  &
                  Name[118:28->118:34]
                  status
                BinaryExpression[118:36->118:54]
                  Name[118:36->118:45]
                  WSTOPPED
                  |
                  Name[118:47->118:54]
                  WEXITED
              !=
              BinaryExpression[118:59->118:87]
                Name[118:59->118:65]
                g_pid
                ||
                UnaryExpression[118:68->118:87]
                  !
                  FunctionCall[118:69->118:87]
                    Name[118:69->118:79]
                    WIFSTOPPED
                    Name[118:80->118:86]
                    status
            Then:
            BlockStatement[118:89->123:8]
              FunctionCall[119:12->119:30]
                Name[119:12->119:18]
                perror
                StringLiteral[119:19->119:28]
                  "wait_pid"
              ReturnStatement[120:12->120:20]
                NumericLiteral[120:19->120:19]
                1
          IfStatement[123:8->128:8]
            Predicate:
            BinaryExpression[123:12->123:52]
              FunctionCall[123:12->123:48]
                Name[123:12->123:18]
                ptrace
                Name[123:19->123:29]
                PT_GETREGS
                Name[123:31->123:36]
                g_pid
                UnaryExpression[123:38->123:43]
                  &
                  Name[123:39->123:43]
                  regs
                NumericLiteral[123:45->123:45]
                0
              ==
              UnaryExpression[123:51->123:52]
                -
                NumericLiteral[123:52->123:52]
                1
            Then:
            BlockStatement[123:55->128:8]
              FunctionCall[124:12->124:29]
                Name[124:12->124:18]
                perror
                StringLiteral[124:19->124:27]
                  "getregs"
              ReturnStatement[125:12->125:20]
                NumericLiteral[125:19->125:19]
                1
          VariableDeclaration[128:8->128:26]
            NamedType[128:8->128:12]
              u32
            res
            MemberExpression[128:18->128:26]
              Name[128:18->128:22]
              regs
              Identifier[128:23->128:25]
              eax
          VariableDeclaration[130:8->135:16]
            NamedType[130:8->130:13]
              auto
            string
            FunctionCall[130:22->135:16]
              Name[130:22->130:39]
              String::formatted
              StringLiteral[130:40->130:77]
                "{}({:#08x}, {:#08x}, {:#08x})\t={}\n"
              FunctionCall[131:12->131:64]
                Name[131:12->131:30]
                Syscall::to_string
                CStyleCastExpression[131:31->131:63]
                  NamedType[131:32->131:49]
                    Syscall::Function
                  Name[131:50->131:63]
                  syscall_index
              Name[132:12->132:16]
              arg1
              Name[133:12->133:16]
              arg2
              Name[134:12->134:16]
              arg3
              Name[135:12->135:15]
              res
          IfStatement[137:8->141:4]
            Predicate:
            UnaryExpression[137:12->137:38]
              !
              BinaryExpression[137:13->137:38]
                Name[137:13->137:23]
                trace_file
                ->
                FunctionCall[137:25->137:38]
                  Name[137:25->137:30]
                  write
                  Name[137:31->137:37]
                  string
            Then:
            BlockStatement[137:40->141:4]
              FunctionCall[138:12->138:59]
                Name[138:12->138:18]
                warnln
                StringLiteral[138:19->138:29]
                  "write: {}"
                BinaryExpression[138:32->138:58]
                  Name[138:32->138:42]
                  trace_file
                  ->
                  FunctionCall[138:44->138:58]
                    Name[138:44->138:56]
                    error_string
              ReturnStatement[139:12->139:20]
                NumericLiteral[139:19->139:19]
                1
      ReturnStatement[143:4->143:12]
        NumericLiteral[143:11->143:11]
        0
    }