API documentation for debugger_v2.types package.
Classes
Breakpoint
Represents the breakpoint specification, status and results.
Debuggee
Represents the debugged application. The application may include one or more replicated processes executing the same code. Each of these processes is attached with a debugger agent, carrying out the debugging commands. Agents attached to the same debuggee identify themselves as such by using exactly the same Debuggee message value when registering.
DeleteBreakpointRequest
Request to delete a breakpoint.
FormatMessage
Represents a message with parameters.
GetBreakpointRequest
Request to get breakpoint information.
GetBreakpointResponse
Response for getting breakpoint information.
ListActiveBreakpointsRequest
Request to list active breakpoints.
ListActiveBreakpointsResponse
Response for listing active breakpoints.
ListBreakpointsRequest
Request to list breakpoints.
ListBreakpointsResponse
Response for listing breakpoints.
ListDebuggeesRequest
Request to list debuggees.
ListDebuggeesResponse
Response for listing debuggees.
RegisterDebuggeeRequest
Request to register a debuggee.
RegisterDebuggeeResponse
Response for registering a debuggee.
SetBreakpointRequest
Request to set a breakpoint
SetBreakpointResponse
Response for setting a breakpoint.
SourceLocation
Represents a location in the source code.
StackFrame
Represents a stack frame context.
StatusMessage
Represents a contextual status message. The message can indicate an
error or informational status, and refer to specific parts of the
containing object. For example, the Breakpoint.status field can
indicate an error referring to the BREAKPOINT_SOURCE_LOCATION
with the message Location not found.
UpdateActiveBreakpointRequest
Request to update an active breakpoint.
UpdateActiveBreakpointResponse
Response for updating an active breakpoint. The message is defined to allow future extensions.
Variable
Represents a variable or an argument possibly of a compound object type. Note how the following variables are represented:
1) A simple variable:
int x = 5
{ name: "x", value: "5", type: "int" } // Captured variable
2) A compound object:
struct T { int m1; int m2; }; T x = { 3, 7 };
{ // Captured variable name: "x", type: "T", members { name: "m1", value: "3", type: "int" }, members { name: "m2", value: "7", type: "int" } }
3) A pointer where the pointee was captured:
T x = { 3, 7 }; T* p = &x;
{ // Captured variable name: "p", type: "T*", value: "0x00500500", members { name: "m1", value: "3", type: "int" }, members { name: "m2", value: "7", type: "int" } }
4) A pointer where the pointee was not captured:
T* p = new T;
{ // Captured variable name: "p", type: "T*", value: "0x00400400" status { is_error: true, description { format: "unavailable" } } }
The status should describe the reason for the missing value, such as
<optimized out>, <inaccessible>,
<pointers limit reached>.
Note that a null pointer should not have members.
5) An unnamed value:
int* p = new int(7);
{ // Captured variable name: "p", value: "0x00500500", type: "int*", members { value: "7", type: "int" } }
6) An unnamed pointer where the pointee was not captured:
int* p = new int(7); int** pp = &p;
{ // Captured variable name: "pp", value: "0x00500500", type: "int*", members { value: "0x00400400", type: "int" status { is_error: true, description: { format: "unavailable" } } } } }
To optimize computation, memory and network traffic, variables that
repeat in the output multiple times can be stored once in a shared
variable table and be referenced using the var_table_index
field. The variables stored in the shared table are nameless and are
essentially a partition of the complete variable. To reconstruct the
complete variable, merge the referencing variable with the
referenced variable.
When using the shared variable table, the following variables:
::
T x = { 3, 7 };
T* p = &x;
T& r = x;
{ name: "x", var_table_index: 3, type: "T" } // Captured variables
{ name: "p", value "0x00500500", type="T*", var_table_index: 3 }
{ name: "r", type="T&", var_table_index: 3 }
{ // Shared variable table entry #3:
members { name: "m1", value: "3", type: "int" },
members { name: "m2", value: "7", type: "int" }
}
Note that the pointer address is stored with the referencing variable and not with the referenced variable. This allows the referenced variable to be shared between pointers and references.
The type field is optional. The debugger agent may or may not support it.