reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

References

tools/lldb/source/API/SBAddress.cpp

  292   LLDB_REGISTER_CONSTRUCTOR(SBAddress, ());
  293   LLDB_REGISTER_CONSTRUCTOR(SBAddress, (const lldb::SBAddress &));
  294   LLDB_REGISTER_CONSTRUCTOR(SBAddress, (lldb::SBSection, lldb::addr_t));
  295   LLDB_REGISTER_CONSTRUCTOR(SBAddress, (lldb::addr_t, lldb::SBTarget &));
  296   LLDB_REGISTER_METHOD(const lldb::SBAddress &,
  298   LLDB_REGISTER_METHOD_CONST(bool,
  300   LLDB_REGISTER_METHOD_CONST(bool, SBAddress, IsValid, ());
  301   LLDB_REGISTER_METHOD_CONST(bool, SBAddress, operator bool, ());
  302   LLDB_REGISTER_METHOD(void, SBAddress, Clear, ());
  303   LLDB_REGISTER_METHOD(void, SBAddress, SetAddress,
  305   LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBAddress, GetFileAddress, ());
  306   LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBAddress, GetLoadAddress,
  308   LLDB_REGISTER_METHOD(void, SBAddress, SetLoadAddress,
  310   LLDB_REGISTER_METHOD(bool, SBAddress, OffsetAddress, (lldb::addr_t));
  311   LLDB_REGISTER_METHOD(lldb::SBSection, SBAddress, GetSection, ());
  312   LLDB_REGISTER_METHOD(lldb::addr_t, SBAddress, GetOffset, ());
  313   LLDB_REGISTER_METHOD(bool, SBAddress, GetDescription, (lldb::SBStream &));
  314   LLDB_REGISTER_METHOD(lldb::SBModule, SBAddress, GetModule, ());
  315   LLDB_REGISTER_METHOD(lldb::SBSymbolContext, SBAddress, GetSymbolContext,
  317   LLDB_REGISTER_METHOD(lldb::SBCompileUnit, SBAddress, GetCompileUnit, ());
  318   LLDB_REGISTER_METHOD(lldb::SBFunction, SBAddress, GetFunction, ());
  319   LLDB_REGISTER_METHOD(lldb::SBBlock, SBAddress, GetBlock, ());
  320   LLDB_REGISTER_METHOD(lldb::SBSymbol, SBAddress, GetSymbol, ());
  321   LLDB_REGISTER_METHOD(lldb::SBLineEntry, SBAddress, GetLineEntry, ());

tools/lldb/source/API/SBAttachInfo.cpp

  267   LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, ());
  268   LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, (lldb::pid_t));
  269   LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, (const char *, bool));
  270   LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, (const char *, bool, bool));
  271   LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, (const lldb::SBAttachInfo &));
  272   LLDB_REGISTER_METHOD(lldb::SBAttachInfo &,
  274   LLDB_REGISTER_METHOD(lldb::pid_t, SBAttachInfo, GetProcessID, ());
  275   LLDB_REGISTER_METHOD(void, SBAttachInfo, SetProcessID, (lldb::pid_t));
  276   LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetResumeCount, ());
  277   LLDB_REGISTER_METHOD(void, SBAttachInfo, SetResumeCount, (uint32_t));
  278   LLDB_REGISTER_METHOD(const char *, SBAttachInfo, GetProcessPluginName, ());
  279   LLDB_REGISTER_METHOD(void, SBAttachInfo, SetProcessPluginName,
  281   LLDB_REGISTER_METHOD(void, SBAttachInfo, SetExecutable, (const char *));
  282   LLDB_REGISTER_METHOD(void, SBAttachInfo, SetExecutable, (lldb::SBFileSpec));
  283   LLDB_REGISTER_METHOD(bool, SBAttachInfo, GetWaitForLaunch, ());
  284   LLDB_REGISTER_METHOD(void, SBAttachInfo, SetWaitForLaunch, (bool));
  285   LLDB_REGISTER_METHOD(void, SBAttachInfo, SetWaitForLaunch, (bool, bool));
  286   LLDB_REGISTER_METHOD(bool, SBAttachInfo, GetIgnoreExisting, ());
  287   LLDB_REGISTER_METHOD(void, SBAttachInfo, SetIgnoreExisting, (bool));
  288   LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetUserID, ());
  289   LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetGroupID, ());
  290   LLDB_REGISTER_METHOD(bool, SBAttachInfo, UserIDIsValid, ());
  291   LLDB_REGISTER_METHOD(bool, SBAttachInfo, GroupIDIsValid, ());
  292   LLDB_REGISTER_METHOD(void, SBAttachInfo, SetUserID, (uint32_t));
  293   LLDB_REGISTER_METHOD(void, SBAttachInfo, SetGroupID, (uint32_t));
  294   LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetEffectiveUserID, ());
  295   LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetEffectiveGroupID, ());
  296   LLDB_REGISTER_METHOD(bool, SBAttachInfo, EffectiveUserIDIsValid, ());
  297   LLDB_REGISTER_METHOD(bool, SBAttachInfo, EffectiveGroupIDIsValid, ());
  298   LLDB_REGISTER_METHOD(void, SBAttachInfo, SetEffectiveUserID, (uint32_t));
  299   LLDB_REGISTER_METHOD(void, SBAttachInfo, SetEffectiveGroupID, (uint32_t));
  300   LLDB_REGISTER_METHOD(lldb::pid_t, SBAttachInfo, GetParentProcessID, ());
  301   LLDB_REGISTER_METHOD(void, SBAttachInfo, SetParentProcessID, (lldb::pid_t));
  302   LLDB_REGISTER_METHOD(bool, SBAttachInfo, ParentProcessIDIsValid, ());
  303   LLDB_REGISTER_METHOD(lldb::SBListener, SBAttachInfo, GetListener, ());
  304   LLDB_REGISTER_METHOD(void, SBAttachInfo, SetListener, (lldb::SBListener &));

tools/lldb/source/API/SBBlock.cpp

  360   LLDB_REGISTER_CONSTRUCTOR(SBBlock, ());
  361   LLDB_REGISTER_CONSTRUCTOR(SBBlock, (const lldb::SBBlock &));
  362   LLDB_REGISTER_METHOD(const lldb::SBBlock &,
  364   LLDB_REGISTER_METHOD_CONST(bool, SBBlock, IsValid, ());
  365   LLDB_REGISTER_METHOD_CONST(bool, SBBlock, operator bool, ());
  366   LLDB_REGISTER_METHOD_CONST(bool, SBBlock, IsInlined, ());
  367   LLDB_REGISTER_METHOD_CONST(const char *, SBBlock, GetInlinedName, ());
  368   LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBBlock,
  370   LLDB_REGISTER_METHOD_CONST(uint32_t, SBBlock, GetInlinedCallSiteLine, ());
  371   LLDB_REGISTER_METHOD_CONST(uint32_t, SBBlock, GetInlinedCallSiteColumn, ());
  372   LLDB_REGISTER_METHOD(lldb::SBBlock, SBBlock, GetParent, ());
  373   LLDB_REGISTER_METHOD(lldb::SBBlock, SBBlock, GetContainingInlinedBlock, ());
  374   LLDB_REGISTER_METHOD(lldb::SBBlock, SBBlock, GetSibling, ());
  375   LLDB_REGISTER_METHOD(lldb::SBBlock, SBBlock, GetFirstChild, ());
  376   LLDB_REGISTER_METHOD(bool, SBBlock, GetDescription, (lldb::SBStream &));
  377   LLDB_REGISTER_METHOD(uint32_t, SBBlock, GetNumRanges, ());
  378   LLDB_REGISTER_METHOD(lldb::SBAddress, SBBlock, GetRangeStartAddress,
  380   LLDB_REGISTER_METHOD(lldb::SBAddress, SBBlock, GetRangeEndAddress,
  382   LLDB_REGISTER_METHOD(uint32_t, SBBlock, GetRangeIndexForBlockAddress,
  384   LLDB_REGISTER_METHOD(
  387   LLDB_REGISTER_METHOD(lldb::SBValueList, SBBlock, GetVariables,

tools/lldb/source/API/SBBreakpoint.cpp

  957   LLDB_REGISTER_CONSTRUCTOR(SBBreakpoint, ());
  958   LLDB_REGISTER_CONSTRUCTOR(SBBreakpoint, (const lldb::SBBreakpoint &));
  959   LLDB_REGISTER_CONSTRUCTOR(SBBreakpoint, (const lldb::BreakpointSP &));
  960   LLDB_REGISTER_METHOD(const lldb::SBBreakpoint &,
  962   LLDB_REGISTER_METHOD(bool,
  964   LLDB_REGISTER_METHOD(bool,
  966   LLDB_REGISTER_METHOD_CONST(lldb::break_id_t, SBBreakpoint, GetID, ());
  967   LLDB_REGISTER_METHOD_CONST(bool, SBBreakpoint, IsValid, ());
  968   LLDB_REGISTER_METHOD_CONST(bool, SBBreakpoint, operator bool, ());
  969   LLDB_REGISTER_METHOD(void, SBBreakpoint, ClearAllBreakpointSites, ());
  970   LLDB_REGISTER_METHOD(lldb::SBBreakpointLocation, SBBreakpoint,
  972   LLDB_REGISTER_METHOD(lldb::break_id_t, SBBreakpoint,
  974   LLDB_REGISTER_METHOD(lldb::SBBreakpointLocation, SBBreakpoint,
  976   LLDB_REGISTER_METHOD(lldb::SBBreakpointLocation, SBBreakpoint,
  978   LLDB_REGISTER_METHOD(void, SBBreakpoint, SetEnabled, (bool));
  979   LLDB_REGISTER_METHOD(bool, SBBreakpoint, IsEnabled, ());
  980   LLDB_REGISTER_METHOD(void, SBBreakpoint, SetOneShot, (bool));
  981   LLDB_REGISTER_METHOD_CONST(bool, SBBreakpoint, IsOneShot, ());
  982   LLDB_REGISTER_METHOD(bool, SBBreakpoint, IsInternal, ());
  983   LLDB_REGISTER_METHOD(void, SBBreakpoint, SetIgnoreCount, (uint32_t));
  984   LLDB_REGISTER_METHOD(void, SBBreakpoint, SetCondition, (const char *));
  985   LLDB_REGISTER_METHOD(const char *, SBBreakpoint, GetCondition, ());
  986   LLDB_REGISTER_METHOD(void, SBBreakpoint, SetAutoContinue, (bool));
  987   LLDB_REGISTER_METHOD(bool, SBBreakpoint, GetAutoContinue, ());
  988   LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpoint, GetHitCount, ());
  989   LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpoint, GetIgnoreCount, ());
  990   LLDB_REGISTER_METHOD(void, SBBreakpoint, SetThreadID, (lldb::tid_t));
  991   LLDB_REGISTER_METHOD(lldb::tid_t, SBBreakpoint, GetThreadID, ());
  992   LLDB_REGISTER_METHOD(void, SBBreakpoint, SetThreadIndex, (uint32_t));
  993   LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpoint, GetThreadIndex, ());
  994   LLDB_REGISTER_METHOD(void, SBBreakpoint, SetThreadName, (const char *));
  995   LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpoint, GetThreadName, ());
  996   LLDB_REGISTER_METHOD(void, SBBreakpoint, SetQueueName, (const char *));
  997   LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpoint, GetQueueName, ());
  998   LLDB_REGISTER_METHOD_CONST(size_t, SBBreakpoint, GetNumResolvedLocations,
 1000   LLDB_REGISTER_METHOD_CONST(size_t, SBBreakpoint, GetNumLocations, ());
 1001   LLDB_REGISTER_METHOD(void, SBBreakpoint, SetCommandLineCommands,
 1003   LLDB_REGISTER_METHOD(bool, SBBreakpoint, GetCommandLineCommands,
 1005   LLDB_REGISTER_METHOD(bool, SBBreakpoint, GetDescription,
 1007   LLDB_REGISTER_METHOD(bool, SBBreakpoint, GetDescription,
 1009   LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpoint, AddLocation,
 1011   LLDB_REGISTER_METHOD(void, SBBreakpoint, SetScriptCallbackFunction,
 1013   LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpoint, SetScriptCallbackFunction,
 1015   LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpoint, SetScriptCallbackBody,
 1017   LLDB_REGISTER_METHOD(bool, SBBreakpoint, AddName, (const char *));
 1018   LLDB_REGISTER_METHOD(void, SBBreakpoint, RemoveName, (const char *));
 1019   LLDB_REGISTER_METHOD(bool, SBBreakpoint, MatchesName, (const char *));
 1020   LLDB_REGISTER_METHOD(void, SBBreakpoint, GetNames, (lldb::SBStringList &));
 1021   LLDB_REGISTER_STATIC_METHOD(bool, SBBreakpoint, EventIsBreakpointEvent,
 1023   LLDB_REGISTER_STATIC_METHOD(lldb::BreakpointEventType, SBBreakpoint,
 1026   LLDB_REGISTER_STATIC_METHOD(lldb::SBBreakpoint, SBBreakpoint,
 1029   LLDB_REGISTER_STATIC_METHOD(lldb::SBBreakpointLocation, SBBreakpoint,
 1032   LLDB_REGISTER_STATIC_METHOD(uint32_t, SBBreakpoint,
 1035   LLDB_REGISTER_METHOD_CONST(bool, SBBreakpoint, IsHardware, ());
 1040   LLDB_REGISTER_CONSTRUCTOR(SBBreakpointList, (lldb::SBTarget &));
 1041   LLDB_REGISTER_METHOD_CONST(size_t, SBBreakpointList, GetSize, ());
 1042   LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBBreakpointList,
 1044   LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBBreakpointList,
 1046   LLDB_REGISTER_METHOD(void, SBBreakpointList, Append,
 1048   LLDB_REGISTER_METHOD(void, SBBreakpointList, AppendByID,
 1050   LLDB_REGISTER_METHOD(bool, SBBreakpointList, AppendIfUnique,
 1052   LLDB_REGISTER_METHOD(void, SBBreakpointList, Clear, ());

tools/lldb/source/API/SBBreakpointLocation.cpp

  476   LLDB_REGISTER_CONSTRUCTOR(SBBreakpointLocation, ());
  477   LLDB_REGISTER_CONSTRUCTOR(SBBreakpointLocation,
  479   LLDB_REGISTER_CONSTRUCTOR(SBBreakpointLocation,
  481   LLDB_REGISTER_METHOD(
  484   LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointLocation, IsValid, ());
  485   LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointLocation, operator bool, ());
  486   LLDB_REGISTER_METHOD(lldb::SBAddress, SBBreakpointLocation, GetAddress, ());
  487   LLDB_REGISTER_METHOD(lldb::addr_t, SBBreakpointLocation, GetLoadAddress,
  489   LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetEnabled, (bool));
  490   LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, IsEnabled, ());
  491   LLDB_REGISTER_METHOD(uint32_t, SBBreakpointLocation, GetHitCount, ());
  492   LLDB_REGISTER_METHOD(uint32_t, SBBreakpointLocation, GetIgnoreCount, ());
  493   LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetIgnoreCount,
  495   LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetCondition,
  497   LLDB_REGISTER_METHOD(const char *, SBBreakpointLocation, GetCondition, ());
  498   LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetAutoContinue, (bool));
  499   LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, GetAutoContinue, ());
  500   LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetScriptCallbackFunction,
  502   LLDB_REGISTER_METHOD(SBError, SBBreakpointLocation, SetScriptCallbackFunction,
  504   LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpointLocation,
  506   LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetCommandLineCommands,
  508   LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, GetCommandLineCommands,
  510   LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetThreadID,
  512   LLDB_REGISTER_METHOD(lldb::tid_t, SBBreakpointLocation, GetThreadID, ());
  513   LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetThreadIndex,
  515   LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpointLocation, GetThreadIndex,
  517   LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetThreadName,
  519   LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointLocation,
  521   LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetQueueName,
  523   LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointLocation, GetQueueName,
  525   LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, IsResolved, ());
  526   LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, GetDescription,
  528   LLDB_REGISTER_METHOD(lldb::break_id_t, SBBreakpointLocation, GetID, ());
  529   LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBBreakpointLocation,

tools/lldb/source/API/SBBreakpointName.cpp

  702   LLDB_REGISTER_CONSTRUCTOR(SBBreakpointName, ());
  703   LLDB_REGISTER_CONSTRUCTOR(SBBreakpointName,
  705   LLDB_REGISTER_CONSTRUCTOR(SBBreakpointName,
  707   LLDB_REGISTER_CONSTRUCTOR(SBBreakpointName,
  709   LLDB_REGISTER_METHOD(
  712   LLDB_REGISTER_METHOD(
  714   LLDB_REGISTER_METHOD(
  716   LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointName, IsValid, ());
  717   LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointName, operator bool, ());
  718   LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointName, GetName, ());
  719   LLDB_REGISTER_METHOD(void, SBBreakpointName, SetEnabled, (bool));
  720   LLDB_REGISTER_METHOD(bool, SBBreakpointName, IsEnabled, ());
  721   LLDB_REGISTER_METHOD(void, SBBreakpointName, SetOneShot, (bool));
  722   LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointName, IsOneShot, ());
  723   LLDB_REGISTER_METHOD(void, SBBreakpointName, SetIgnoreCount, (uint32_t));
  724   LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpointName, GetIgnoreCount, ());
  725   LLDB_REGISTER_METHOD(void, SBBreakpointName, SetCondition, (const char *));
  726   LLDB_REGISTER_METHOD(const char *, SBBreakpointName, GetCondition, ());
  727   LLDB_REGISTER_METHOD(void, SBBreakpointName, SetAutoContinue, (bool));
  728   LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetAutoContinue, ());
  729   LLDB_REGISTER_METHOD(void, SBBreakpointName, SetThreadID, (lldb::tid_t));
  730   LLDB_REGISTER_METHOD(lldb::tid_t, SBBreakpointName, GetThreadID, ());
  731   LLDB_REGISTER_METHOD(void, SBBreakpointName, SetThreadIndex, (uint32_t));
  732   LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpointName, GetThreadIndex, ());
  733   LLDB_REGISTER_METHOD(void, SBBreakpointName, SetThreadName, (const char *));
  734   LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointName, GetThreadName,
  736   LLDB_REGISTER_METHOD(void, SBBreakpointName, SetQueueName, (const char *));
  737   LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointName, GetQueueName,
  739   LLDB_REGISTER_METHOD(void, SBBreakpointName, SetCommandLineCommands,
  741   LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetCommandLineCommands,
  743   LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointName, GetHelpString,
  745   LLDB_REGISTER_METHOD(void, SBBreakpointName, SetHelpString, (const char *));
  746   LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetDescription,
  748   LLDB_REGISTER_METHOD(void, SBBreakpointName, SetScriptCallbackFunction,
  750   LLDB_REGISTER_METHOD(SBError, SBBreakpointName, SetScriptCallbackFunction,
  752   LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpointName, SetScriptCallbackBody,
  754   LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointName, GetAllowList, ());
  755   LLDB_REGISTER_METHOD(void, SBBreakpointName, SetAllowList, (bool));
  756   LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetAllowDelete, ());
  757   LLDB_REGISTER_METHOD(void, SBBreakpointName, SetAllowDelete, (bool));
  758   LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetAllowDisable, ());
  759   LLDB_REGISTER_METHOD(void, SBBreakpointName, SetAllowDisable, (bool));

tools/lldb/source/API/SBBroadcaster.cpp

  182   LLDB_REGISTER_CONSTRUCTOR(SBBroadcaster, ());
  183   LLDB_REGISTER_CONSTRUCTOR(SBBroadcaster, (const char *));
  184   LLDB_REGISTER_CONSTRUCTOR(SBBroadcaster, (const lldb::SBBroadcaster &));
  185   LLDB_REGISTER_METHOD(
  188   LLDB_REGISTER_METHOD(void, SBBroadcaster, BroadcastEventByType,
  190   LLDB_REGISTER_METHOD(void, SBBroadcaster, BroadcastEvent,
  192   LLDB_REGISTER_METHOD(void, SBBroadcaster, AddInitialEventsToListener,
  194   LLDB_REGISTER_METHOD(uint32_t, SBBroadcaster, AddListener,
  196   LLDB_REGISTER_METHOD_CONST(const char *, SBBroadcaster, GetName, ());
  197   LLDB_REGISTER_METHOD(bool, SBBroadcaster, EventTypeHasListeners,
  199   LLDB_REGISTER_METHOD(bool, SBBroadcaster, RemoveListener,
  201   LLDB_REGISTER_METHOD_CONST(bool, SBBroadcaster, IsValid, ());
  202   LLDB_REGISTER_METHOD_CONST(bool, SBBroadcaster, operator bool, ());
  203   LLDB_REGISTER_METHOD(void, SBBroadcaster, Clear, ());
  204   LLDB_REGISTER_METHOD_CONST(
  206   LLDB_REGISTER_METHOD_CONST(
  208   LLDB_REGISTER_METHOD_CONST(

tools/lldb/source/API/SBCommandInterpreter.cpp

  837   LLDB_REGISTER_CONSTRUCTOR(SBCommandInterpreterRunOptions, ());
  838   LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
  840   LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions,
  842   LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
  844   LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnError,
  846   LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
  848   LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnCrash,
  850   LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
  852   LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetEchoCommands,
  854   LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
  856   LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions,
  858   LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
  860   LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetPrintResults,
  862   LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
  864   LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetAddToHistory,
  866   LLDB_REGISTER_CONSTRUCTOR(SBCommandInterpreter,
  868   LLDB_REGISTER_CONSTRUCTOR(SBCommandInterpreter,
  870   LLDB_REGISTER_METHOD(
  873   LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreter, IsValid, ());
  874   LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreter, operator bool, ());
  875   LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, CommandExists,
  877   LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, AliasExists,
  879   LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, IsActive, ());
  880   LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreter, WasInterrupted, ());
  881   LLDB_REGISTER_METHOD(const char *, SBCommandInterpreter,
  883   LLDB_REGISTER_METHOD(lldb::ReturnStatus, SBCommandInterpreter,
  886   LLDB_REGISTER_METHOD(lldb::ReturnStatus, SBCommandInterpreter,
  890   LLDB_REGISTER_METHOD(void, SBCommandInterpreter, HandleCommandsFromFile,
  894   LLDB_REGISTER_METHOD(int, SBCommandInterpreter, HandleCompletion,
  897   LLDB_REGISTER_METHOD(int, SBCommandInterpreter,
  901   LLDB_REGISTER_METHOD(int, SBCommandInterpreter,
  905   LLDB_REGISTER_METHOD(
  908   LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasCommands, ());
  909   LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasAliases, ());
  910   LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasAliasOptions, ());
  911   LLDB_REGISTER_METHOD(lldb::SBProcess, SBCommandInterpreter, GetProcess, ());
  912   LLDB_REGISTER_METHOD(lldb::SBDebugger, SBCommandInterpreter, GetDebugger,
  914   LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, GetPromptOnQuit, ());
  915   LLDB_REGISTER_METHOD(void, SBCommandInterpreter, SetPromptOnQuit, (bool));
  916   LLDB_REGISTER_METHOD(void, SBCommandInterpreter, AllowExitCodeOnQuit,
  918   LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasCustomQuitExitCode, ());
  919   LLDB_REGISTER_METHOD(int, SBCommandInterpreter, GetQuitStatus, ());
  920   LLDB_REGISTER_METHOD(void, SBCommandInterpreter, ResolveCommand,
  922   LLDB_REGISTER_METHOD(void, SBCommandInterpreter,
  925   LLDB_REGISTER_METHOD(void, SBCommandInterpreter,
  928   LLDB_REGISTER_METHOD(lldb::SBBroadcaster, SBCommandInterpreter,
  930   LLDB_REGISTER_STATIC_METHOD(const char *, SBCommandInterpreter,
  932   LLDB_REGISTER_STATIC_METHOD(const char *, SBCommandInterpreter,
  935   LLDB_REGISTER_STATIC_METHOD(const char *, SBCommandInterpreter,
  938   LLDB_REGISTER_STATIC_METHOD(bool, SBCommandInterpreter,
  941   LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommandInterpreter,
  943   LLDB_REGISTER_METHOD(
  946   LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommandInterpreter, AddCommand,
  949   LLDB_REGISTER_CONSTRUCTOR(SBCommand, ());
  950   LLDB_REGISTER_METHOD(bool, SBCommand, IsValid, ());
  951   LLDB_REGISTER_METHOD_CONST(bool, SBCommand, operator bool, ());
  952   LLDB_REGISTER_METHOD(const char *, SBCommand, GetName, ());
  953   LLDB_REGISTER_METHOD(const char *, SBCommand, GetHelp, ());
  954   LLDB_REGISTER_METHOD(const char *, SBCommand, GetHelpLong, ());
  955   LLDB_REGISTER_METHOD(void, SBCommand, SetHelp, (const char *));
  956   LLDB_REGISTER_METHOD(void, SBCommand, SetHelpLong, (const char *));
  957   LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommand, AddMultiwordCommand,
  959   LLDB_REGISTER_METHOD(
  962   LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommand, AddCommand,
  965   LLDB_REGISTER_METHOD(uint32_t, SBCommand, GetFlags, ());
  966   LLDB_REGISTER_METHOD(void, SBCommand, SetFlags, (uint32_t));

tools/lldb/source/API/SBCommandReturnObject.cpp

  375   LLDB_REGISTER_CONSTRUCTOR(SBCommandReturnObject, ());
  376   LLDB_REGISTER_CONSTRUCTOR(SBCommandReturnObject,
  378   LLDB_REGISTER_CONSTRUCTOR(SBCommandReturnObject,
  380   LLDB_REGISTER_METHOD(
  383   LLDB_REGISTER_METHOD_CONST(bool, SBCommandReturnObject, IsValid, ());
  384   LLDB_REGISTER_METHOD_CONST(bool, SBCommandReturnObject, operator bool, ());
  385   LLDB_REGISTER_METHOD(const char *, SBCommandReturnObject, GetOutput, ());
  386   LLDB_REGISTER_METHOD(const char *, SBCommandReturnObject, GetError, ());
  387   LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, GetOutputSize, ());
  388   LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, GetErrorSize, ());
  389   LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, PutOutput, (FILE *));
  390   LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, PutError, (FILE *));
  391   LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, PutOutput, (SBFile));
  392   LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, PutError, (SBFile));
  393   LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, PutOutput, (FileSP));
  394   LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, PutError, (FileSP));
  395   LLDB_REGISTER_METHOD(void, SBCommandReturnObject, Clear, ());
  396   LLDB_REGISTER_METHOD(lldb::ReturnStatus, SBCommandReturnObject, GetStatus,
  398   LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetStatus,
  400   LLDB_REGISTER_METHOD(bool, SBCommandReturnObject, Succeeded, ());
  401   LLDB_REGISTER_METHOD(bool, SBCommandReturnObject, HasResult, ());
  402   LLDB_REGISTER_METHOD(void, SBCommandReturnObject, AppendMessage,
  404   LLDB_REGISTER_METHOD(void, SBCommandReturnObject, AppendWarning,
  406   LLDB_REGISTER_METHOD(bool, SBCommandReturnObject, GetDescription,
  408   LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
  410   LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
  412   LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
  414   LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
  416   LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
  418   LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
  420   LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
  422   LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
  424   LLDB_REGISTER_METHOD(void, SBCommandReturnObject, PutCString,
  426   LLDB_REGISTER_METHOD(const char *, SBCommandReturnObject, GetOutput,
  428   LLDB_REGISTER_METHOD(const char *, SBCommandReturnObject, GetError, (bool));
  429   LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetError,
  431   LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetError, (const char *));

tools/lldb/source/API/SBCommunication.cpp

  192   LLDB_REGISTER_CONSTRUCTOR(SBCommunication, ());
  193   LLDB_REGISTER_CONSTRUCTOR(SBCommunication, (const char *));
  194   LLDB_REGISTER_METHOD_CONST(bool, SBCommunication, IsValid, ());
  195   LLDB_REGISTER_METHOD_CONST(bool, SBCommunication, operator bool, ());
  196   LLDB_REGISTER_METHOD(bool, SBCommunication, GetCloseOnEOF, ());
  197   LLDB_REGISTER_METHOD(void, SBCommunication, SetCloseOnEOF, (bool));
  198   LLDB_REGISTER_METHOD(lldb::ConnectionStatus, SBCommunication, Connect,
  200   LLDB_REGISTER_METHOD(lldb::ConnectionStatus, SBCommunication,
  202   LLDB_REGISTER_METHOD(lldb::ConnectionStatus, SBCommunication, Disconnect,
  204   LLDB_REGISTER_METHOD_CONST(bool, SBCommunication, IsConnected, ());
  205   LLDB_REGISTER_METHOD(bool, SBCommunication, ReadThreadStart, ());
  206   LLDB_REGISTER_METHOD(bool, SBCommunication, ReadThreadStop, ());
  207   LLDB_REGISTER_METHOD(bool, SBCommunication, ReadThreadIsRunning, ());
  208   LLDB_REGISTER_METHOD(lldb::SBBroadcaster, SBCommunication, GetBroadcaster,
  210   LLDB_REGISTER_STATIC_METHOD(const char *, SBCommunication,

tools/lldb/source/API/SBCompileUnit.cpp

  245   LLDB_REGISTER_CONSTRUCTOR(SBCompileUnit, ());
  246   LLDB_REGISTER_CONSTRUCTOR(SBCompileUnit, (const lldb::SBCompileUnit &));
  247   LLDB_REGISTER_METHOD(
  250   LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBCompileUnit, GetFileSpec,
  252   LLDB_REGISTER_METHOD_CONST(uint32_t, SBCompileUnit, GetNumLineEntries, ());
  253   LLDB_REGISTER_METHOD_CONST(lldb::SBLineEntry, SBCompileUnit,
  255   LLDB_REGISTER_METHOD_CONST(uint32_t, SBCompileUnit, FindLineEntryIndex,
  257   LLDB_REGISTER_METHOD_CONST(uint32_t, SBCompileUnit, FindLineEntryIndex,
  259   LLDB_REGISTER_METHOD_CONST(uint32_t, SBCompileUnit, GetNumSupportFiles, ());
  260   LLDB_REGISTER_METHOD(lldb::SBTypeList, SBCompileUnit, GetTypes, (uint32_t));
  261   LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBCompileUnit,
  263   LLDB_REGISTER_METHOD(uint32_t, SBCompileUnit, FindSupportFileIndex,
  265   LLDB_REGISTER_METHOD(lldb::LanguageType, SBCompileUnit, GetLanguage, ());
  266   LLDB_REGISTER_METHOD_CONST(bool, SBCompileUnit, IsValid, ());
  267   LLDB_REGISTER_METHOD_CONST(bool, SBCompileUnit, operator bool, ());
  268   LLDB_REGISTER_METHOD_CONST(
  270   LLDB_REGISTER_METHOD_CONST(
  272   LLDB_REGISTER_METHOD(bool, SBCompileUnit, GetDescription,

tools/lldb/source/API/SBData.cpp

  655   LLDB_REGISTER_CONSTRUCTOR(SBData, ());
  656   LLDB_REGISTER_CONSTRUCTOR(SBData, (const lldb::SBData &));
  657   LLDB_REGISTER_METHOD(const lldb::SBData &,
  659   LLDB_REGISTER_METHOD(bool, SBData, IsValid, ());
  660   LLDB_REGISTER_METHOD_CONST(bool, SBData, operator bool, ());
  661   LLDB_REGISTER_METHOD(uint8_t, SBData, GetAddressByteSize, ());
  662   LLDB_REGISTER_METHOD(void, SBData, SetAddressByteSize, (uint8_t));
  663   LLDB_REGISTER_METHOD(void, SBData, Clear, ());
  664   LLDB_REGISTER_METHOD(size_t, SBData, GetByteSize, ());
  665   LLDB_REGISTER_METHOD(lldb::ByteOrder, SBData, GetByteOrder, ());
  666   LLDB_REGISTER_METHOD(void, SBData, SetByteOrder, (lldb::ByteOrder));
  667   LLDB_REGISTER_METHOD(float, SBData, GetFloat,
  669   LLDB_REGISTER_METHOD(double, SBData, GetDouble,
  671   LLDB_REGISTER_METHOD(long double, SBData, GetLongDouble,
  673   LLDB_REGISTER_METHOD(lldb::addr_t, SBData, GetAddress,
  675   LLDB_REGISTER_METHOD(uint8_t, SBData, GetUnsignedInt8,
  677   LLDB_REGISTER_METHOD(uint16_t, SBData, GetUnsignedInt16,
  679   LLDB_REGISTER_METHOD(uint32_t, SBData, GetUnsignedInt32,
  681   LLDB_REGISTER_METHOD(uint64_t, SBData, GetUnsignedInt64,
  683   LLDB_REGISTER_METHOD(int8_t, SBData, GetSignedInt8,
  685   LLDB_REGISTER_METHOD(int16_t, SBData, GetSignedInt16,
  687   LLDB_REGISTER_METHOD(int32_t, SBData, GetSignedInt32,
  689   LLDB_REGISTER_METHOD(int64_t, SBData, GetSignedInt64,
  691   LLDB_REGISTER_METHOD(const char *, SBData, GetString,
  693   LLDB_REGISTER_METHOD(bool, SBData, GetDescription,
  695   LLDB_REGISTER_METHOD(bool, SBData, Append, (const lldb::SBData &));
  696   LLDB_REGISTER_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromCString,
  698   LLDB_REGISTER_STATIC_METHOD(
  701   LLDB_REGISTER_STATIC_METHOD(
  704   LLDB_REGISTER_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromSInt64Array,
  706   LLDB_REGISTER_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromSInt32Array,
  708   LLDB_REGISTER_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromDoubleArray,
  710   LLDB_REGISTER_METHOD(bool, SBData, SetDataFromCString, (const char *));
  711   LLDB_REGISTER_METHOD(bool, SBData, SetDataFromUInt64Array,
  713   LLDB_REGISTER_METHOD(bool, SBData, SetDataFromUInt32Array,
  715   LLDB_REGISTER_METHOD(bool, SBData, SetDataFromSInt64Array,
  717   LLDB_REGISTER_METHOD(bool, SBData, SetDataFromSInt32Array,
  719   LLDB_REGISTER_METHOD(bool, SBData, SetDataFromDoubleArray,

tools/lldb/source/API/SBDebugger.cpp

 1608   LLDB_REGISTER_METHOD(void, SBInputReader, SetIsDone, (bool));
 1609   LLDB_REGISTER_METHOD_CONST(bool, SBInputReader, IsActive, ());
 1660   LLDB_REGISTER_CONSTRUCTOR(SBDebugger, ());
 1661   LLDB_REGISTER_CONSTRUCTOR(SBDebugger, (const lldb::DebuggerSP &));
 1662   LLDB_REGISTER_CONSTRUCTOR(SBDebugger, (const lldb::SBDebugger &));
 1663   LLDB_REGISTER_METHOD(lldb::SBDebugger &,
 1665   LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, Initialize, ());
 1666   LLDB_REGISTER_STATIC_METHOD(lldb::SBError, SBDebugger,
 1668   LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, Terminate, ());
 1669   LLDB_REGISTER_METHOD(void, SBDebugger, Clear, ());
 1670   LLDB_REGISTER_STATIC_METHOD(lldb::SBDebugger, SBDebugger, Create, ());
 1671   LLDB_REGISTER_STATIC_METHOD(lldb::SBDebugger, SBDebugger, Create, (bool));
 1672   LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, Destroy, (lldb::SBDebugger &));
 1673   LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, MemoryPressureDetected, ());
 1674   LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, IsValid, ());
 1675   LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, operator bool,());
 1676   LLDB_REGISTER_METHOD(void, SBDebugger, SetAsync, (bool));
 1677   LLDB_REGISTER_METHOD(bool, SBDebugger, GetAsync, ());
 1678   LLDB_REGISTER_METHOD(void, SBDebugger, SkipLLDBInitFiles, (bool));
 1679   LLDB_REGISTER_METHOD(void, SBDebugger, SkipAppInitFiles, (bool));
 1680   LLDB_REGISTER_METHOD(void, SBDebugger, SetInputFileHandle, (FILE *, bool));
 1681   LLDB_REGISTER_METHOD(FILE *, SBDebugger, GetInputFileHandle, ());
 1682   LLDB_REGISTER_METHOD(FILE *, SBDebugger, GetOutputFileHandle, ());
 1683   LLDB_REGISTER_METHOD(FILE *, SBDebugger, GetErrorFileHandle, ());
 1684   LLDB_REGISTER_METHOD(SBFile, SBDebugger, GetInputFile, ());
 1685   LLDB_REGISTER_METHOD(SBFile, SBDebugger, GetOutputFile, ());
 1686   LLDB_REGISTER_METHOD(SBFile, SBDebugger, GetErrorFile, ());
 1687   LLDB_REGISTER_METHOD(void, SBDebugger, SaveInputTerminalState, ());
 1688   LLDB_REGISTER_METHOD(void, SBDebugger, RestoreInputTerminalState, ());
 1689   LLDB_REGISTER_METHOD(lldb::SBCommandInterpreter, SBDebugger,
 1691   LLDB_REGISTER_METHOD(void, SBDebugger, HandleCommand, (const char *));
 1692   LLDB_REGISTER_METHOD(lldb::SBListener, SBDebugger, GetListener, ());
 1693   LLDB_REGISTER_METHOD(
 1696   LLDB_REGISTER_METHOD(
 1699   LLDB_REGISTER_METHOD(
 1702   LLDB_REGISTER_METHOD(lldb::SBSourceManager, SBDebugger, GetSourceManager, ());
 1703   LLDB_REGISTER_STATIC_METHOD(bool, SBDebugger, SetDefaultArchitecture,
 1705   LLDB_REGISTER_METHOD(lldb::ScriptLanguage, SBDebugger, GetScriptingLanguage,
 1707   LLDB_REGISTER_STATIC_METHOD(const char *, SBDebugger, GetVersionString, ());
 1708   LLDB_REGISTER_STATIC_METHOD(const char *, SBDebugger, StateAsCString,
 1710   LLDB_REGISTER_STATIC_METHOD(lldb::SBStructuredData, SBDebugger,
 1712   LLDB_REGISTER_STATIC_METHOD(bool, SBDebugger, StateIsRunningState,
 1714   LLDB_REGISTER_STATIC_METHOD(bool, SBDebugger, StateIsStoppedState,
 1716   LLDB_REGISTER_METHOD(
 1719   LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger,
 1722   LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, CreateTargetWithFileAndArch,
 1724   LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, CreateTarget,
 1726   LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, GetDummyTarget, ());
 1727   LLDB_REGISTER_METHOD(bool, SBDebugger, DeleteTarget, (lldb::SBTarget &));
 1728   LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, GetTargetAtIndex,
 1730   LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetIndexOfTarget,
 1732   LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithProcessID,
 1734   LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithFileAndArch,
 1736   LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumTargets, ());
 1737   LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, GetSelectedTarget, ());
 1738   LLDB_REGISTER_METHOD(void, SBDebugger, SetSelectedTarget, (lldb::SBTarget &));
 1739   LLDB_REGISTER_METHOD(lldb::SBPlatform, SBDebugger, GetSelectedPlatform, ());
 1740   LLDB_REGISTER_METHOD(void, SBDebugger, SetSelectedPlatform,
 1742   LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumPlatforms, ());
 1743   LLDB_REGISTER_METHOD(lldb::SBPlatform, SBDebugger, GetPlatformAtIndex,
 1745   LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumAvailablePlatforms, ());
 1746   LLDB_REGISTER_METHOD(lldb::SBStructuredData, SBDebugger,
 1748   LLDB_REGISTER_METHOD(void, SBDebugger, DispatchInputInterrupt, ());
 1749   LLDB_REGISTER_METHOD(void, SBDebugger, DispatchInputEndOfFile, ());
 1750   LLDB_REGISTER_METHOD(void, SBDebugger, PushInputReader,
 1752   LLDB_REGISTER_METHOD(void, SBDebugger, RunCommandInterpreter, (bool, bool));
 1753   LLDB_REGISTER_METHOD(void, SBDebugger, RunCommandInterpreter,
 1756   LLDB_REGISTER_METHOD(lldb::SBError, SBDebugger, RunREPL,
 1758   LLDB_REGISTER_STATIC_METHOD(lldb::SBDebugger, SBDebugger, FindDebuggerWithID,
 1760   LLDB_REGISTER_METHOD(const char *, SBDebugger, GetInstanceName, ());
 1761   LLDB_REGISTER_STATIC_METHOD(lldb::SBError, SBDebugger, SetInternalVariable,
 1763   LLDB_REGISTER_STATIC_METHOD(lldb::SBStringList, SBDebugger,
 1766   LLDB_REGISTER_METHOD_CONST(uint32_t, SBDebugger, GetTerminalWidth, ());
 1767   LLDB_REGISTER_METHOD(void, SBDebugger, SetTerminalWidth, (uint32_t));
 1768   LLDB_REGISTER_METHOD_CONST(const char *, SBDebugger, GetPrompt, ());
 1769   LLDB_REGISTER_METHOD(void, SBDebugger, SetPrompt, (const char *));
 1770   LLDB_REGISTER_METHOD_CONST(const char *, SBDebugger, GetReproducerPath, ());
 1771   LLDB_REGISTER_METHOD_CONST(lldb::ScriptLanguage, SBDebugger,
 1773   LLDB_REGISTER_METHOD(void, SBDebugger, SetScriptLanguage,
 1775   LLDB_REGISTER_METHOD(bool, SBDebugger, SetUseExternalEditor, (bool));
 1776   LLDB_REGISTER_METHOD(bool, SBDebugger, GetUseExternalEditor, ());
 1777   LLDB_REGISTER_METHOD(bool, SBDebugger, SetUseColor, (bool));
 1778   LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, GetUseColor, ());
 1779   LLDB_REGISTER_METHOD(bool, SBDebugger, GetDescription, (lldb::SBStream &));
 1780   LLDB_REGISTER_METHOD(lldb::user_id_t, SBDebugger, GetID, ());
 1781   LLDB_REGISTER_METHOD(lldb::SBError, SBDebugger, SetCurrentPlatform,
 1783   LLDB_REGISTER_METHOD(bool, SBDebugger, SetCurrentPlatformSDKRoot,
 1785   LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, GetCloseInputOnEOF, ());
 1786   LLDB_REGISTER_METHOD(void, SBDebugger, SetCloseInputOnEOF, (bool));
 1787   LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory,
 1789   LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory,
 1791   LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, CreateCategory,
 1793   LLDB_REGISTER_METHOD(bool, SBDebugger, DeleteCategory, (const char *));
 1794   LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumCategories, ());
 1795   LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategoryAtIndex,
 1797   LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetDefaultCategory,
 1799   LLDB_REGISTER_METHOD(lldb::SBTypeFormat, SBDebugger, GetFormatForType,
 1801   LLDB_REGISTER_METHOD(lldb::SBTypeSummary, SBDebugger, GetSummaryForType,
 1803   LLDB_REGISTER_METHOD(lldb::SBTypeSynthetic, SBDebugger, GetSyntheticForType,
 1805   LLDB_REGISTER_METHOD(lldb::SBTypeFilter, SBDebugger, GetFilterForType,
 1807   LLDB_REGISTER_METHOD(bool, SBDebugger, EnableLog,

tools/lldb/source/API/SBDeclaration.cpp

  184   LLDB_REGISTER_CONSTRUCTOR(SBDeclaration, ());
  185   LLDB_REGISTER_CONSTRUCTOR(SBDeclaration, (const lldb::SBDeclaration &));
  186   LLDB_REGISTER_METHOD(
  189   LLDB_REGISTER_METHOD_CONST(bool, SBDeclaration, IsValid, ());
  190   LLDB_REGISTER_METHOD_CONST(bool, SBDeclaration, operator bool, ());
  191   LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBDeclaration, GetFileSpec,
  193   LLDB_REGISTER_METHOD_CONST(uint32_t, SBDeclaration, GetLine, ());
  194   LLDB_REGISTER_METHOD_CONST(uint32_t, SBDeclaration, GetColumn, ());
  195   LLDB_REGISTER_METHOD(void, SBDeclaration, SetFileSpec, (lldb::SBFileSpec));
  196   LLDB_REGISTER_METHOD(void, SBDeclaration, SetLine, (uint32_t));
  197   LLDB_REGISTER_METHOD(void, SBDeclaration, SetColumn, (uint32_t));
  198   LLDB_REGISTER_METHOD_CONST(
  200   LLDB_REGISTER_METHOD_CONST(
  202   LLDB_REGISTER_METHOD(bool, SBDeclaration, GetDescription,

tools/lldb/source/API/SBError.cpp

  192   LLDB_REGISTER_CONSTRUCTOR(SBError, ());
  193   LLDB_REGISTER_CONSTRUCTOR(SBError, (const lldb::SBError &));
  194   LLDB_REGISTER_METHOD(const lldb::SBError &,
  196   LLDB_REGISTER_METHOD_CONST(const char *, SBError, GetCString, ());
  197   LLDB_REGISTER_METHOD(void, SBError, Clear, ());
  198   LLDB_REGISTER_METHOD_CONST(bool, SBError, Fail, ());
  199   LLDB_REGISTER_METHOD_CONST(bool, SBError, Success, ());
  200   LLDB_REGISTER_METHOD_CONST(uint32_t, SBError, GetError, ());
  201   LLDB_REGISTER_METHOD_CONST(lldb::ErrorType, SBError, GetType, ());
  202   LLDB_REGISTER_METHOD(void, SBError, SetError, (uint32_t, lldb::ErrorType));
  203   LLDB_REGISTER_METHOD(void, SBError, SetErrorToErrno, ());
  204   LLDB_REGISTER_METHOD(void, SBError, SetErrorToGenericError, ());
  205   LLDB_REGISTER_METHOD(void, SBError, SetErrorString, (const char *));
  206   LLDB_REGISTER_METHOD_CONST(bool, SBError, IsValid, ());
  207   LLDB_REGISTER_METHOD_CONST(bool, SBError, operator bool, ());
  208   LLDB_REGISTER_METHOD(bool, SBError, GetDescription, (lldb::SBStream &));

tools/lldb/source/API/SBEvent.cpp

  215   LLDB_REGISTER_CONSTRUCTOR(SBEvent, ());
  216   LLDB_REGISTER_CONSTRUCTOR(SBEvent, (uint32_t, const char *, uint32_t));
  217   LLDB_REGISTER_CONSTRUCTOR(SBEvent, (lldb::EventSP &));
  218   LLDB_REGISTER_CONSTRUCTOR(SBEvent, (lldb_private::Event *));
  219   LLDB_REGISTER_CONSTRUCTOR(SBEvent, (const lldb::SBEvent &));
  220   LLDB_REGISTER_METHOD(const lldb::SBEvent &,
  222   LLDB_REGISTER_METHOD(const char *, SBEvent, GetDataFlavor, ());
  223   LLDB_REGISTER_METHOD_CONST(uint32_t, SBEvent, GetType, ());
  224   LLDB_REGISTER_METHOD_CONST(lldb::SBBroadcaster, SBEvent, GetBroadcaster,
  226   LLDB_REGISTER_METHOD_CONST(const char *, SBEvent, GetBroadcasterClass, ());
  227   LLDB_REGISTER_METHOD(bool, SBEvent, BroadcasterMatchesPtr,
  229   LLDB_REGISTER_METHOD(bool, SBEvent, BroadcasterMatchesRef,
  231   LLDB_REGISTER_METHOD(void, SBEvent, Clear, ());
  232   LLDB_REGISTER_METHOD_CONST(bool, SBEvent, IsValid, ());
  233   LLDB_REGISTER_METHOD_CONST(bool, SBEvent, operator bool, ());
  234   LLDB_REGISTER_STATIC_METHOD(const char *, SBEvent, GetCStringFromEvent,
  236   LLDB_REGISTER_METHOD(bool, SBEvent, GetDescription, (lldb::SBStream &));
  237   LLDB_REGISTER_METHOD_CONST(bool, SBEvent, GetDescription,

tools/lldb/source/API/SBExecutionContext.cpp

  141   LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext, ());
  142   LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext,
  144   LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext,
  146   LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext, (const lldb::SBTarget &));
  147   LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext, (const lldb::SBProcess &));
  148   LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext, (lldb::SBThread));
  149   LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext, (const lldb::SBFrame &));
  150   LLDB_REGISTER_METHOD(
  153   LLDB_REGISTER_METHOD_CONST(lldb::SBTarget, SBExecutionContext, GetTarget,
  155   LLDB_REGISTER_METHOD_CONST(lldb::SBProcess, SBExecutionContext, GetProcess,
  157   LLDB_REGISTER_METHOD_CONST(lldb::SBThread, SBExecutionContext, GetThread,
  159   LLDB_REGISTER_METHOD_CONST(lldb::SBFrame, SBExecutionContext, GetFrame, ());

tools/lldb/source/API/SBExpressionOptions.cpp

  280   LLDB_REGISTER_CONSTRUCTOR(SBExpressionOptions, ());
  281   LLDB_REGISTER_CONSTRUCTOR(SBExpressionOptions,
  283   LLDB_REGISTER_METHOD(
  286   LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetCoerceResultToId,
  288   LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetCoerceResultToId,
  290   LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetUnwindOnError, ());
  291   LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetUnwindOnError, (bool));
  292   LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetIgnoreBreakpoints,
  294   LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetIgnoreBreakpoints,
  296   LLDB_REGISTER_METHOD_CONST(lldb::DynamicValueType, SBExpressionOptions,
  298   LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetFetchDynamicValue,
  300   LLDB_REGISTER_METHOD_CONST(uint32_t, SBExpressionOptions,
  302   LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetTimeoutInMicroSeconds,
  304   LLDB_REGISTER_METHOD_CONST(uint32_t, SBExpressionOptions,
  306   LLDB_REGISTER_METHOD(void, SBExpressionOptions,
  308   LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetTryAllThreads, ());
  309   LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetTryAllThreads, (bool));
  310   LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetStopOthers, ());
  311   LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetStopOthers, (bool));
  312   LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetTrapExceptions,
  314   LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetTrapExceptions, (bool));
  315   LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetLanguage,
  317   LLDB_REGISTER_METHOD(bool, SBExpressionOptions, GetGenerateDebugInfo, ());
  318   LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetGenerateDebugInfo,
  320   LLDB_REGISTER_METHOD(bool, SBExpressionOptions, GetSuppressPersistentResult,
  322   LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetSuppressPersistentResult,
  324   LLDB_REGISTER_METHOD_CONST(const char *, SBExpressionOptions, GetPrefix,
  326   LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetPrefix, (const char *));
  327   LLDB_REGISTER_METHOD(bool, SBExpressionOptions, GetAutoApplyFixIts, ());
  328   LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetAutoApplyFixIts, (bool));
  329   LLDB_REGISTER_METHOD(bool, SBExpressionOptions, GetTopLevel, ());
  330   LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetTopLevel, (bool));
  331   LLDB_REGISTER_METHOD(bool, SBExpressionOptions, GetAllowJIT, ());
  332   LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetAllowJIT, (bool));

tools/lldb/source/API/SBFile.cpp

  121   LLDB_REGISTER_METHOD(lldb::SBError, SBFile, Flush, ());
  122   LLDB_REGISTER_METHOD_CONST(bool, SBFile, IsValid, ());
  123   LLDB_REGISTER_METHOD_CONST(bool, SBFile, operator bool,());
  124   LLDB_REGISTER_METHOD_CONST(bool, SBFile, operator!,());
  125   LLDB_REGISTER_METHOD_CONST(FileSP, SBFile, GetFile, ());
  126   LLDB_REGISTER_METHOD(lldb::SBError, SBFile, Close, ());

tools/lldb/source/API/SBFileSpec.cpp

  196   LLDB_REGISTER_CONSTRUCTOR(SBFileSpec, ());
  197   LLDB_REGISTER_CONSTRUCTOR(SBFileSpec, (const lldb::SBFileSpec &));
  198   LLDB_REGISTER_CONSTRUCTOR(SBFileSpec, (const char *));
  199   LLDB_REGISTER_CONSTRUCTOR(SBFileSpec, (const char *, bool));
  200   LLDB_REGISTER_METHOD(const lldb::SBFileSpec &,
  202   LLDB_REGISTER_METHOD_CONST(bool,
  204   LLDB_REGISTER_METHOD_CONST(bool,
  206   LLDB_REGISTER_METHOD_CONST(bool, SBFileSpec, IsValid, ());
  207   LLDB_REGISTER_METHOD_CONST(bool, SBFileSpec, operator bool, ());
  208   LLDB_REGISTER_METHOD_CONST(bool, SBFileSpec, Exists, ());
  209   LLDB_REGISTER_METHOD(bool, SBFileSpec, ResolveExecutableLocation, ());
  210   LLDB_REGISTER_STATIC_METHOD(int, SBFileSpec, ResolvePath,
  212   LLDB_REGISTER_METHOD_CONST(const char *, SBFileSpec, GetFilename, ());
  213   LLDB_REGISTER_METHOD_CONST(const char *, SBFileSpec, GetDirectory, ());
  214   LLDB_REGISTER_METHOD(void, SBFileSpec, SetFilename, (const char *));
  215   LLDB_REGISTER_METHOD(void, SBFileSpec, SetDirectory, (const char *));
  216   LLDB_REGISTER_METHOD_CONST(uint32_t, SBFileSpec, GetPath, (char *, size_t));
  217   LLDB_REGISTER_METHOD_CONST(bool, SBFileSpec, GetDescription,
  219   LLDB_REGISTER_METHOD(void, SBFileSpec, AppendPathComponent, (const char *));

tools/lldb/source/API/SBFileSpecList.cpp

  132   LLDB_REGISTER_CONSTRUCTOR(SBFileSpecList, ());
  133   LLDB_REGISTER_CONSTRUCTOR(SBFileSpecList, (const lldb::SBFileSpecList &));
  134   LLDB_REGISTER_METHOD(
  137   LLDB_REGISTER_METHOD_CONST(uint32_t, SBFileSpecList, GetSize, ());
  138   LLDB_REGISTER_METHOD(void, SBFileSpecList, Append,
  140   LLDB_REGISTER_METHOD(bool, SBFileSpecList, AppendIfUnique,
  142   LLDB_REGISTER_METHOD(void, SBFileSpecList, Clear, ());
  143   LLDB_REGISTER_METHOD(uint32_t, SBFileSpecList, FindFileIndex,
  145   LLDB_REGISTER_METHOD_CONST(const lldb::SBFileSpec, SBFileSpecList,
  147   LLDB_REGISTER_METHOD_CONST(bool, SBFileSpecList, GetDescription,

tools/lldb/source/API/SBFrame.cpp

 1299   LLDB_REGISTER_CONSTRUCTOR(SBFrame, ());
 1300   LLDB_REGISTER_CONSTRUCTOR(SBFrame, (const lldb::StackFrameSP &));
 1301   LLDB_REGISTER_CONSTRUCTOR(SBFrame, (const lldb::SBFrame &));
 1302   LLDB_REGISTER_METHOD(const lldb::SBFrame &,
 1304   LLDB_REGISTER_METHOD_CONST(bool, SBFrame, IsValid, ());
 1305   LLDB_REGISTER_METHOD_CONST(bool, SBFrame, operator bool, ());
 1306   LLDB_REGISTER_METHOD_CONST(lldb::SBSymbolContext, SBFrame, GetSymbolContext,
 1308   LLDB_REGISTER_METHOD_CONST(lldb::SBModule, SBFrame, GetModule, ());
 1309   LLDB_REGISTER_METHOD_CONST(lldb::SBCompileUnit, SBFrame, GetCompileUnit,
 1311   LLDB_REGISTER_METHOD_CONST(lldb::SBFunction, SBFrame, GetFunction, ());
 1312   LLDB_REGISTER_METHOD_CONST(lldb::SBSymbol, SBFrame, GetSymbol, ());
 1313   LLDB_REGISTER_METHOD_CONST(lldb::SBBlock, SBFrame, GetBlock, ());
 1314   LLDB_REGISTER_METHOD_CONST(lldb::SBBlock, SBFrame, GetFrameBlock, ());
 1315   LLDB_REGISTER_METHOD_CONST(lldb::SBLineEntry, SBFrame, GetLineEntry, ());
 1316   LLDB_REGISTER_METHOD_CONST(uint32_t, SBFrame, GetFrameID, ());
 1317   LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBFrame, GetCFA, ());
 1318   LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBFrame, GetPC, ());
 1319   LLDB_REGISTER_METHOD(bool, SBFrame, SetPC, (lldb::addr_t));
 1320   LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBFrame, GetSP, ());
 1321   LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBFrame, GetFP, ());
 1322   LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBFrame, GetPCAddress, ());
 1323   LLDB_REGISTER_METHOD(void, SBFrame, Clear, ());
 1324   LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, GetValueForVariablePath,
 1326   LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, GetValueForVariablePath,
 1328   LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, FindVariable, (const char *));
 1329   LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, FindVariable,
 1331   LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, FindValue,
 1333   LLDB_REGISTER_METHOD(
 1336   LLDB_REGISTER_METHOD_CONST(bool, SBFrame, IsEqual, (const lldb::SBFrame &));
 1337   LLDB_REGISTER_METHOD_CONST(bool,
 1339   LLDB_REGISTER_METHOD_CONST(bool,
 1341   LLDB_REGISTER_METHOD_CONST(lldb::SBThread, SBFrame, GetThread, ());
 1342   LLDB_REGISTER_METHOD_CONST(const char *, SBFrame, Disassemble, ());
 1343   LLDB_REGISTER_METHOD(lldb::SBValueList, SBFrame, GetVariables,
 1345   LLDB_REGISTER_METHOD(lldb::SBValueList, SBFrame, GetVariables,
 1347   LLDB_REGISTER_METHOD(lldb::SBValueList, SBFrame, GetVariables,
 1349   LLDB_REGISTER_METHOD(lldb::SBValueList, SBFrame, GetRegisters, ());
 1350   LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, FindRegister, (const char *));
 1351   LLDB_REGISTER_METHOD(bool, SBFrame, GetDescription, (lldb::SBStream &));
 1352   LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
 1354   LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
 1356   LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
 1358   LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
 1360   LLDB_REGISTER_METHOD(bool, SBFrame, IsInlined, ());
 1361   LLDB_REGISTER_METHOD_CONST(bool, SBFrame, IsInlined, ());
 1362   LLDB_REGISTER_METHOD(bool, SBFrame, IsArtificial, ());
 1363   LLDB_REGISTER_METHOD_CONST(bool, SBFrame, IsArtificial, ());
 1364   LLDB_REGISTER_METHOD(const char *, SBFrame, GetFunctionName, ());
 1365   LLDB_REGISTER_METHOD_CONST(lldb::LanguageType, SBFrame, GuessLanguage, ());
 1366   LLDB_REGISTER_METHOD_CONST(const char *, SBFrame, GetFunctionName, ());
 1367   LLDB_REGISTER_METHOD(const char *, SBFrame, GetDisplayFunctionName, ());

tools/lldb/source/API/SBFunction.cpp

  253   LLDB_REGISTER_CONSTRUCTOR(SBFunction, ());
  254   LLDB_REGISTER_CONSTRUCTOR(SBFunction, (const lldb::SBFunction &));
  255   LLDB_REGISTER_METHOD(const lldb::SBFunction &,
  257   LLDB_REGISTER_METHOD_CONST(bool, SBFunction, IsValid, ());
  258   LLDB_REGISTER_METHOD_CONST(bool, SBFunction, operator bool, ());
  259   LLDB_REGISTER_METHOD_CONST(const char *, SBFunction, GetName, ());
  260   LLDB_REGISTER_METHOD_CONST(const char *, SBFunction, GetDisplayName, ());
  261   LLDB_REGISTER_METHOD_CONST(const char *, SBFunction, GetMangledName, ());
  262   LLDB_REGISTER_METHOD_CONST(
  264   LLDB_REGISTER_METHOD_CONST(
  266   LLDB_REGISTER_METHOD(bool, SBFunction, GetDescription, (lldb::SBStream &));
  267   LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBFunction, GetInstructions,
  269   LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBFunction, GetInstructions,
  271   LLDB_REGISTER_METHOD(lldb::SBAddress, SBFunction, GetStartAddress, ());
  272   LLDB_REGISTER_METHOD(lldb::SBAddress, SBFunction, GetEndAddress, ());
  273   LLDB_REGISTER_METHOD(const char *, SBFunction, GetArgumentName, (uint32_t));
  274   LLDB_REGISTER_METHOD(uint32_t, SBFunction, GetPrologueByteSize, ());
  275   LLDB_REGISTER_METHOD(lldb::SBType, SBFunction, GetType, ());
  276   LLDB_REGISTER_METHOD(lldb::SBBlock, SBFunction, GetBlock, ());
  277   LLDB_REGISTER_METHOD(lldb::LanguageType, SBFunction, GetLanguage, ());
  278   LLDB_REGISTER_METHOD(bool, SBFunction, GetIsOptimized, ());

tools/lldb/source/API/SBHostOS.cpp

  182   LLDB_REGISTER_STATIC_METHOD(lldb::SBFileSpec, SBHostOS, GetProgramFileSpec,
  184   LLDB_REGISTER_STATIC_METHOD(lldb::SBFileSpec, SBHostOS, GetLLDBPythonPath,
  186   LLDB_REGISTER_STATIC_METHOD(lldb::SBFileSpec, SBHostOS, GetLLDBPath,
  188   LLDB_REGISTER_STATIC_METHOD(lldb::SBFileSpec, SBHostOS,
  190   LLDB_REGISTER_STATIC_METHOD(void, SBHostOS, ThreadCreated, (const char *));

tools/lldb/source/API/SBInstruction.cpp

  350   LLDB_REGISTER_CONSTRUCTOR(SBInstruction, ());
  351   LLDB_REGISTER_CONSTRUCTOR(SBInstruction, (const lldb::SBInstruction &));
  352   LLDB_REGISTER_METHOD(
  355   LLDB_REGISTER_METHOD(bool, SBInstruction, IsValid, ());
  356   LLDB_REGISTER_METHOD_CONST(bool, SBInstruction, operator bool, ());
  357   LLDB_REGISTER_METHOD(lldb::SBAddress, SBInstruction, GetAddress, ());
  358   LLDB_REGISTER_METHOD(const char *, SBInstruction, GetMnemonic,
  360   LLDB_REGISTER_METHOD(const char *, SBInstruction, GetOperands,
  362   LLDB_REGISTER_METHOD(const char *, SBInstruction, GetComment,
  364   LLDB_REGISTER_METHOD(size_t, SBInstruction, GetByteSize, ());
  365   LLDB_REGISTER_METHOD(lldb::SBData, SBInstruction, GetData,
  367   LLDB_REGISTER_METHOD(bool, SBInstruction, DoesBranch, ());
  368   LLDB_REGISTER_METHOD(bool, SBInstruction, HasDelaySlot, ());
  369   LLDB_REGISTER_METHOD(bool, SBInstruction, CanSetBreakpoint, ());
  370   LLDB_REGISTER_METHOD(bool, SBInstruction, GetDescription,
  372   LLDB_REGISTER_METHOD(void, SBInstruction, Print, (FILE *));
  373   LLDB_REGISTER_METHOD(void, SBInstruction, Print, (SBFile));
  374   LLDB_REGISTER_METHOD(void, SBInstruction, Print, (FileSP));
  375   LLDB_REGISTER_METHOD(bool, SBInstruction, EmulateWithFrame,
  377   LLDB_REGISTER_METHOD(bool, SBInstruction, DumpEmulation, (const char *));
  378   LLDB_REGISTER_METHOD(bool, SBInstruction, TestEmulation,

tools/lldb/source/API/SBInstructionList.cpp

  207   LLDB_REGISTER_CONSTRUCTOR(SBInstructionList, ());
  208   LLDB_REGISTER_CONSTRUCTOR(SBInstructionList,
  210   LLDB_REGISTER_METHOD(
  213   LLDB_REGISTER_METHOD_CONST(bool, SBInstructionList, IsValid, ());
  214   LLDB_REGISTER_METHOD_CONST(bool, SBInstructionList, operator bool, ());
  215   LLDB_REGISTER_METHOD(size_t, SBInstructionList, GetSize, ());
  216   LLDB_REGISTER_METHOD(lldb::SBInstruction, SBInstructionList,
  218   LLDB_REGISTER_METHOD(
  221   LLDB_REGISTER_METHOD(void, SBInstructionList, Clear, ());
  222   LLDB_REGISTER_METHOD(void, SBInstructionList, AppendInstruction,
  224   LLDB_REGISTER_METHOD(void, SBInstructionList, Print, (FILE *));
  225   LLDB_REGISTER_METHOD(void, SBInstructionList, Print, (SBFile));
  226   LLDB_REGISTER_METHOD(void, SBInstructionList, Print, (FileSP));
  227   LLDB_REGISTER_METHOD(bool, SBInstructionList, GetDescription,
  229   LLDB_REGISTER_METHOD(bool, SBInstructionList,

tools/lldb/source/API/SBLanguageRuntime.cpp

   39   LLDB_REGISTER_STATIC_METHOD(lldb::LanguageType, SBLanguageRuntime,
   41   LLDB_REGISTER_STATIC_METHOD(const char *, SBLanguageRuntime,

tools/lldb/source/API/SBLaunchInfo.cpp

  324   LLDB_REGISTER_CONSTRUCTOR(SBLaunchInfo, (const char **));
  325   LLDB_REGISTER_METHOD(lldb::pid_t, SBLaunchInfo, GetProcessID, ());
  326   LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetUserID, ());
  327   LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetGroupID, ());
  328   LLDB_REGISTER_METHOD(bool, SBLaunchInfo, UserIDIsValid, ());
  329   LLDB_REGISTER_METHOD(bool, SBLaunchInfo, GroupIDIsValid, ());
  330   LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetUserID, (uint32_t));
  331   LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetGroupID, (uint32_t));
  332   LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBLaunchInfo, GetExecutableFile, ());
  333   LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetExecutableFile,
  335   LLDB_REGISTER_METHOD(lldb::SBListener, SBLaunchInfo, GetListener, ());
  336   LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetListener, (lldb::SBListener &));
  337   LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetNumArguments, ());
  338   LLDB_REGISTER_METHOD(const char *, SBLaunchInfo, GetArgumentAtIndex,
  340   LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetArguments,
  342   LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetNumEnvironmentEntries, ());
  343   LLDB_REGISTER_METHOD(const char *, SBLaunchInfo, GetEnvironmentEntryAtIndex,
  345   LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetEnvironmentEntries,
  347   LLDB_REGISTER_METHOD(void, SBLaunchInfo, Clear, ());
  348   LLDB_REGISTER_METHOD_CONST(const char *, SBLaunchInfo, GetWorkingDirectory,
  350   LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetWorkingDirectory,
  352   LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetLaunchFlags, ());
  353   LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetLaunchFlags, (uint32_t));
  354   LLDB_REGISTER_METHOD(const char *, SBLaunchInfo, GetProcessPluginName, ());
  355   LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetProcessPluginName,
  357   LLDB_REGISTER_METHOD(const char *, SBLaunchInfo, GetShell, ());
  358   LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetShell, (const char *));
  359   LLDB_REGISTER_METHOD(bool, SBLaunchInfo, GetShellExpandArguments, ());
  360   LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetShellExpandArguments, (bool));
  361   LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetResumeCount, ());
  362   LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetResumeCount, (uint32_t));
  363   LLDB_REGISTER_METHOD(bool, SBLaunchInfo, AddCloseFileAction, (int));
  364   LLDB_REGISTER_METHOD(bool, SBLaunchInfo, AddDuplicateFileAction,
  366   LLDB_REGISTER_METHOD(bool, SBLaunchInfo, AddOpenFileAction,
  368   LLDB_REGISTER_METHOD(bool, SBLaunchInfo, AddSuppressFileAction,
  370   LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetLaunchEventData,
  372   LLDB_REGISTER_METHOD_CONST(const char *, SBLaunchInfo, GetLaunchEventData,
  374   LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetDetachOnError, (bool));
  375   LLDB_REGISTER_METHOD_CONST(bool, SBLaunchInfo, GetDetachOnError, ());

tools/lldb/source/API/SBLineEntry.cpp

  197   LLDB_REGISTER_CONSTRUCTOR(SBLineEntry, ());
  198   LLDB_REGISTER_CONSTRUCTOR(SBLineEntry, (const lldb::SBLineEntry &));
  199   LLDB_REGISTER_METHOD(const lldb::SBLineEntry &,
  201   LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBLineEntry, GetStartAddress,
  203   LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBLineEntry, GetEndAddress, ());
  204   LLDB_REGISTER_METHOD_CONST(bool, SBLineEntry, IsValid, ());
  205   LLDB_REGISTER_METHOD_CONST(bool, SBLineEntry, operator bool, ());
  206   LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBLineEntry, GetFileSpec, ());
  207   LLDB_REGISTER_METHOD_CONST(uint32_t, SBLineEntry, GetLine, ());
  208   LLDB_REGISTER_METHOD_CONST(uint32_t, SBLineEntry, GetColumn, ());
  209   LLDB_REGISTER_METHOD(void, SBLineEntry, SetFileSpec, (lldb::SBFileSpec));
  210   LLDB_REGISTER_METHOD(void, SBLineEntry, SetLine, (uint32_t));
  211   LLDB_REGISTER_METHOD(void, SBLineEntry, SetColumn, (uint32_t));
  212   LLDB_REGISTER_METHOD_CONST(
  214   LLDB_REGISTER_METHOD_CONST(
  216   LLDB_REGISTER_METHOD(bool, SBLineEntry, GetDescription, (lldb::SBStream &));

tools/lldb/source/API/SBListener.cpp

  331   LLDB_REGISTER_CONSTRUCTOR(SBListener, ());
  332   LLDB_REGISTER_CONSTRUCTOR(SBListener, (const char *));
  333   LLDB_REGISTER_CONSTRUCTOR(SBListener, (const lldb::SBListener &));
  334   LLDB_REGISTER_METHOD(const lldb::SBListener &,
  336   LLDB_REGISTER_METHOD_CONST(bool, SBListener, IsValid, ());
  337   LLDB_REGISTER_METHOD_CONST(bool, SBListener, operator bool, ());
  338   LLDB_REGISTER_METHOD(void, SBListener, AddEvent, (const lldb::SBEvent &));
  339   LLDB_REGISTER_METHOD(void, SBListener, Clear, ());
  340   LLDB_REGISTER_METHOD(uint32_t, SBListener, StartListeningForEventClass,
  342   LLDB_REGISTER_METHOD(bool, SBListener, StopListeningForEventClass,
  344   LLDB_REGISTER_METHOD(uint32_t, SBListener, StartListeningForEvents,
  346   LLDB_REGISTER_METHOD(bool, SBListener, StopListeningForEvents,
  348   LLDB_REGISTER_METHOD(bool, SBListener, WaitForEvent,
  350   LLDB_REGISTER_METHOD(
  353   LLDB_REGISTER_METHOD(
  356   LLDB_REGISTER_METHOD(bool, SBListener, PeekAtNextEvent, (lldb::SBEvent &));
  357   LLDB_REGISTER_METHOD(bool, SBListener, PeekAtNextEventForBroadcaster,
  359   LLDB_REGISTER_METHOD(
  362   LLDB_REGISTER_METHOD(bool, SBListener, GetNextEvent, (lldb::SBEvent &));
  363   LLDB_REGISTER_METHOD(bool, SBListener, GetNextEventForBroadcaster,
  365   LLDB_REGISTER_METHOD(
  368   LLDB_REGISTER_METHOD(bool, SBListener, HandleBroadcastEvent,

tools/lldb/source/API/SBMemoryRegionInfo.cpp

  141   LLDB_REGISTER_CONSTRUCTOR(SBMemoryRegionInfo, ());
  142   LLDB_REGISTER_CONSTRUCTOR(SBMemoryRegionInfo,
  144   LLDB_REGISTER_METHOD(
  147   LLDB_REGISTER_METHOD(void, SBMemoryRegionInfo, Clear, ());
  148   LLDB_REGISTER_METHOD_CONST(
  151   LLDB_REGISTER_METHOD_CONST(
  154   LLDB_REGISTER_METHOD(lldb::addr_t, SBMemoryRegionInfo, GetRegionBase, ());
  155   LLDB_REGISTER_METHOD(lldb::addr_t, SBMemoryRegionInfo, GetRegionEnd, ());
  156   LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, IsReadable, ());
  157   LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, IsWritable, ());
  158   LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, IsExecutable, ());
  159   LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, IsMapped, ());
  160   LLDB_REGISTER_METHOD(const char *, SBMemoryRegionInfo, GetName, ());
  161   LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, GetDescription,

tools/lldb/source/API/SBMemoryRegionInfoList.cpp

  148   LLDB_REGISTER_CONSTRUCTOR(SBMemoryRegionInfoList, ());
  149   LLDB_REGISTER_CONSTRUCTOR(SBMemoryRegionInfoList,
  151   LLDB_REGISTER_METHOD(
  155   LLDB_REGISTER_METHOD_CONST(uint32_t, SBMemoryRegionInfoList, GetSize, ());
  156   LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfoList, GetMemoryRegionAtIndex,
  158   LLDB_REGISTER_METHOD(void, SBMemoryRegionInfoList, Clear, ());
  159   LLDB_REGISTER_METHOD(void, SBMemoryRegionInfoList, Append,
  161   LLDB_REGISTER_METHOD(void, SBMemoryRegionInfoList, Append,

tools/lldb/source/API/SBModule.cpp

  695   LLDB_REGISTER_CONSTRUCTOR(SBModule, ());
  696   LLDB_REGISTER_CONSTRUCTOR(SBModule, (const lldb::SBModuleSpec &));
  697   LLDB_REGISTER_CONSTRUCTOR(SBModule, (const lldb::SBModule &));
  698   LLDB_REGISTER_CONSTRUCTOR(SBModule, (lldb::SBProcess &, lldb::addr_t));
  699   LLDB_REGISTER_METHOD(const lldb::SBModule &,
  701   LLDB_REGISTER_METHOD_CONST(bool, SBModule, IsValid, ());
  702   LLDB_REGISTER_METHOD_CONST(bool, SBModule, operator bool, ());
  703   LLDB_REGISTER_METHOD(void, SBModule, Clear, ());
  704   LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBModule, GetFileSpec, ());
  705   LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBModule, GetPlatformFileSpec,
  707   LLDB_REGISTER_METHOD(bool, SBModule, SetPlatformFileSpec,
  709   LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBModule, GetRemoteInstallFileSpec,
  711   LLDB_REGISTER_METHOD(bool, SBModule, SetRemoteInstallFileSpec,
  713   LLDB_REGISTER_METHOD_CONST(const char *, SBModule, GetUUIDString, ());
  714   LLDB_REGISTER_METHOD_CONST(bool,
  716   LLDB_REGISTER_METHOD_CONST(bool,
  718   LLDB_REGISTER_METHOD(lldb::SBAddress, SBModule, ResolveFileAddress,
  720   LLDB_REGISTER_METHOD(lldb::SBSymbolContext, SBModule,
  723   LLDB_REGISTER_METHOD(bool, SBModule, GetDescription, (lldb::SBStream &));
  724   LLDB_REGISTER_METHOD(uint32_t, SBModule, GetNumCompileUnits, ());
  725   LLDB_REGISTER_METHOD(lldb::SBCompileUnit, SBModule, GetCompileUnitAtIndex,
  727   LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBModule, FindCompileUnits,
  729   LLDB_REGISTER_METHOD(size_t, SBModule, GetNumSymbols, ());
  730   LLDB_REGISTER_METHOD(lldb::SBSymbol, SBModule, GetSymbolAtIndex, (size_t));
  731   LLDB_REGISTER_METHOD(lldb::SBSymbol, SBModule, FindSymbol,
  733   LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBModule, FindSymbols,
  735   LLDB_REGISTER_METHOD(size_t, SBModule, GetNumSections, ());
  736   LLDB_REGISTER_METHOD(lldb::SBSection, SBModule, GetSectionAtIndex,
  738   LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBModule, FindFunctions,
  740   LLDB_REGISTER_METHOD(lldb::SBValueList, SBModule, FindGlobalVariables,
  742   LLDB_REGISTER_METHOD(lldb::SBValue, SBModule, FindFirstGlobalVariable,
  744   LLDB_REGISTER_METHOD(lldb::SBType, SBModule, FindFirstType, (const char *));
  745   LLDB_REGISTER_METHOD(lldb::SBType, SBModule, GetBasicType,
  747   LLDB_REGISTER_METHOD(lldb::SBTypeList, SBModule, FindTypes, (const char *));
  748   LLDB_REGISTER_METHOD(lldb::SBType, SBModule, GetTypeByID,
  750   LLDB_REGISTER_METHOD(lldb::SBTypeList, SBModule, GetTypes, (uint32_t));
  751   LLDB_REGISTER_METHOD(lldb::SBSection, SBModule, FindSection,
  753   LLDB_REGISTER_METHOD(lldb::ByteOrder, SBModule, GetByteOrder, ());
  754   LLDB_REGISTER_METHOD(const char *, SBModule, GetTriple, ());
  755   LLDB_REGISTER_METHOD(uint32_t, SBModule, GetAddressByteSize, ());
  756   LLDB_REGISTER_METHOD(uint32_t, SBModule, GetVersion,
  758   LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBModule, GetSymbolFileSpec,
  760   LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBModule,
  762   LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBModule,

tools/lldb/source/API/SBModuleSpec.cpp

  252   LLDB_REGISTER_CONSTRUCTOR(SBModuleSpec, ());
  253   LLDB_REGISTER_CONSTRUCTOR(SBModuleSpec, (const lldb::SBModuleSpec &));
  254   LLDB_REGISTER_METHOD(const lldb::SBModuleSpec &,
  256   LLDB_REGISTER_METHOD_CONST(bool, SBModuleSpec, IsValid, ());
  257   LLDB_REGISTER_METHOD_CONST(bool, SBModuleSpec, operator bool, ());
  258   LLDB_REGISTER_METHOD(void, SBModuleSpec, Clear, ());
  259   LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBModuleSpec, GetFileSpec, ());
  260   LLDB_REGISTER_METHOD(void, SBModuleSpec, SetFileSpec,
  262   LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBModuleSpec, GetPlatformFileSpec,
  264   LLDB_REGISTER_METHOD(void, SBModuleSpec, SetPlatformFileSpec,
  266   LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBModuleSpec, GetSymbolFileSpec, ());
  267   LLDB_REGISTER_METHOD(void, SBModuleSpec, SetSymbolFileSpec,
  269   LLDB_REGISTER_METHOD(const char *, SBModuleSpec, GetObjectName, ());
  270   LLDB_REGISTER_METHOD(void, SBModuleSpec, SetObjectName, (const char *));
  271   LLDB_REGISTER_METHOD(const char *, SBModuleSpec, GetTriple, ());
  272   LLDB_REGISTER_METHOD(void, SBModuleSpec, SetTriple, (const char *));
  273   LLDB_REGISTER_METHOD(size_t, SBModuleSpec, GetUUIDLength, ());
  274   LLDB_REGISTER_METHOD(bool, SBModuleSpec, GetDescription,
  276   LLDB_REGISTER_CONSTRUCTOR(SBModuleSpecList, ());
  277   LLDB_REGISTER_CONSTRUCTOR(SBModuleSpecList,
  279   LLDB_REGISTER_METHOD(
  282   LLDB_REGISTER_STATIC_METHOD(lldb::SBModuleSpecList, SBModuleSpecList,
  284   LLDB_REGISTER_METHOD(void, SBModuleSpecList, Append,
  286   LLDB_REGISTER_METHOD(void, SBModuleSpecList, Append,
  288   LLDB_REGISTER_METHOD(size_t, SBModuleSpecList, GetSize, ());
  289   LLDB_REGISTER_METHOD(lldb::SBModuleSpec, SBModuleSpecList, GetSpecAtIndex,
  291   LLDB_REGISTER_METHOD(lldb::SBModuleSpec, SBModuleSpecList,
  293   LLDB_REGISTER_METHOD(lldb::SBModuleSpecList, SBModuleSpecList,
  295   LLDB_REGISTER_METHOD(bool, SBModuleSpecList, GetDescription,

tools/lldb/source/API/SBPlatform.cpp

  623   LLDB_REGISTER_CONSTRUCTOR(SBPlatformConnectOptions, (const char *));
  624   LLDB_REGISTER_CONSTRUCTOR(SBPlatformConnectOptions,
  626   LLDB_REGISTER_METHOD(
  630   LLDB_REGISTER_METHOD(const char *, SBPlatformConnectOptions, GetURL, ());
  631   LLDB_REGISTER_METHOD(void, SBPlatformConnectOptions, SetURL,
  633   LLDB_REGISTER_METHOD(bool, SBPlatformConnectOptions, GetRsyncEnabled, ());
  634   LLDB_REGISTER_METHOD(void, SBPlatformConnectOptions, EnableRsync,
  636   LLDB_REGISTER_METHOD(void, SBPlatformConnectOptions, DisableRsync, ());
  637   LLDB_REGISTER_METHOD(const char *, SBPlatformConnectOptions,
  639   LLDB_REGISTER_METHOD(void, SBPlatformConnectOptions, SetLocalCacheDirectory,
  645   LLDB_REGISTER_CONSTRUCTOR(SBPlatformShellCommand, (const char *));
  646   LLDB_REGISTER_CONSTRUCTOR(SBPlatformShellCommand,
  648   LLDB_REGISTER_METHOD(void, SBPlatformShellCommand, Clear, ());
  649   LLDB_REGISTER_METHOD(const char *, SBPlatformShellCommand, GetCommand, ());
  650   LLDB_REGISTER_METHOD(void, SBPlatformShellCommand, SetCommand,
  652   LLDB_REGISTER_METHOD(const char *, SBPlatformShellCommand,
  654   LLDB_REGISTER_METHOD(void, SBPlatformShellCommand, SetWorkingDirectory,
  656   LLDB_REGISTER_METHOD(uint32_t, SBPlatformShellCommand, GetTimeoutSeconds,
  658   LLDB_REGISTER_METHOD(void, SBPlatformShellCommand, SetTimeoutSeconds,
  660   LLDB_REGISTER_METHOD(int, SBPlatformShellCommand, GetSignal, ());
  661   LLDB_REGISTER_METHOD(int, SBPlatformShellCommand, GetStatus, ());
  662   LLDB_REGISTER_METHOD(const char *, SBPlatformShellCommand, GetOutput, ());
  667   LLDB_REGISTER_CONSTRUCTOR(SBPlatform, ());
  668   LLDB_REGISTER_CONSTRUCTOR(SBPlatform, (const char *));
  669   LLDB_REGISTER_METHOD_CONST(bool, SBPlatform, IsValid, ());
  670   LLDB_REGISTER_METHOD_CONST(bool, SBPlatform, operator bool, ());
  671   LLDB_REGISTER_METHOD(void, SBPlatform, Clear, ());
  672   LLDB_REGISTER_METHOD(const char *, SBPlatform, GetName, ());
  673   LLDB_REGISTER_METHOD(const char *, SBPlatform, GetWorkingDirectory, ());
  674   LLDB_REGISTER_METHOD(bool, SBPlatform, SetWorkingDirectory, (const char *));
  675   LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, ConnectRemote,
  677   LLDB_REGISTER_METHOD(void, SBPlatform, DisconnectRemote, ());
  678   LLDB_REGISTER_METHOD(bool, SBPlatform, IsConnected, ());
  679   LLDB_REGISTER_METHOD(const char *, SBPlatform, GetTriple, ());
  680   LLDB_REGISTER_METHOD(const char *, SBPlatform, GetOSBuild, ());
  681   LLDB_REGISTER_METHOD(const char *, SBPlatform, GetOSDescription, ());
  682   LLDB_REGISTER_METHOD(const char *, SBPlatform, GetHostname, ());
  683   LLDB_REGISTER_METHOD(uint32_t, SBPlatform, GetOSMajorVersion, ());
  684   LLDB_REGISTER_METHOD(uint32_t, SBPlatform, GetOSMinorVersion, ());
  685   LLDB_REGISTER_METHOD(uint32_t, SBPlatform, GetOSUpdateVersion, ());
  686   LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Get,
  688   LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Put,
  690   LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Install,
  692   LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Run,
  694   LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Launch,
  696   LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Kill, (const lldb::pid_t));
  697   LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, MakeDirectory,
  699   LLDB_REGISTER_METHOD(uint32_t, SBPlatform, GetFilePermissions,
  701   LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, SetFilePermissions,
  703   LLDB_REGISTER_METHOD_CONST(lldb::SBUnixSignals, SBPlatform, GetUnixSignals,

tools/lldb/source/API/SBProcess.cpp

 1291   LLDB_REGISTER_CONSTRUCTOR(SBProcess, ());
 1292   LLDB_REGISTER_CONSTRUCTOR(SBProcess, (const lldb::SBProcess &));
 1293   LLDB_REGISTER_CONSTRUCTOR(SBProcess, (const lldb::ProcessSP &));
 1294   LLDB_REGISTER_METHOD(const lldb::SBProcess &,
 1296   LLDB_REGISTER_STATIC_METHOD(const char *, SBProcess,
 1298   LLDB_REGISTER_METHOD(const char *, SBProcess, GetPluginName, ());
 1299   LLDB_REGISTER_METHOD(const char *, SBProcess, GetShortPluginName, ());
 1300   LLDB_REGISTER_METHOD(void, SBProcess, Clear, ());
 1301   LLDB_REGISTER_METHOD_CONST(bool, SBProcess, IsValid, ());
 1302   LLDB_REGISTER_METHOD_CONST(bool, SBProcess, operator bool, ());
 1303   LLDB_REGISTER_METHOD(bool, SBProcess, RemoteLaunch,
 1307   LLDB_REGISTER_METHOD(bool, SBProcess, RemoteAttachToProcessWithID,
 1309   LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetNumThreads, ());
 1310   LLDB_REGISTER_METHOD_CONST(lldb::SBThread, SBProcess, GetSelectedThread,
 1312   LLDB_REGISTER_METHOD(lldb::SBThread, SBProcess, CreateOSPluginThread,
 1314   LLDB_REGISTER_METHOD_CONST(lldb::SBTarget, SBProcess, GetTarget, ());
 1315   LLDB_REGISTER_METHOD(size_t, SBProcess, PutSTDIN, (const char *, size_t));
 1316   LLDB_REGISTER_METHOD_CONST(size_t, SBProcess, GetSTDOUT, (char *, size_t));
 1317   LLDB_REGISTER_METHOD_CONST(size_t, SBProcess, GetSTDERR, (char *, size_t));
 1318   LLDB_REGISTER_METHOD_CONST(size_t, SBProcess, GetAsyncProfileData,
 1320   LLDB_REGISTER_METHOD(lldb::SBTrace, SBProcess, StartTrace,
 1322   LLDB_REGISTER_METHOD_CONST(void, SBProcess, ReportEventState,
 1324   LLDB_REGISTER_METHOD_CONST(void, SBProcess, ReportEventState,
 1326   LLDB_REGISTER_METHOD_CONST(void, SBProcess, ReportEventState,
 1328   LLDB_REGISTER_METHOD(
 1331   LLDB_REGISTER_METHOD(bool, SBProcess, SetSelectedThread,
 1333   LLDB_REGISTER_METHOD(bool, SBProcess, SetSelectedThreadByID, (lldb::tid_t));
 1334   LLDB_REGISTER_METHOD(bool, SBProcess, SetSelectedThreadByIndexID,
 1336   LLDB_REGISTER_METHOD(lldb::SBThread, SBProcess, GetThreadAtIndex, (size_t));
 1337   LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetNumQueues, ());
 1338   LLDB_REGISTER_METHOD(lldb::SBQueue, SBProcess, GetQueueAtIndex, (size_t));
 1339   LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetStopID, (bool));
 1340   LLDB_REGISTER_METHOD(lldb::SBEvent, SBProcess, GetStopEventForStopID,
 1342   LLDB_REGISTER_METHOD(lldb::StateType, SBProcess, GetState, ());
 1343   LLDB_REGISTER_METHOD(int, SBProcess, GetExitStatus, ());
 1344   LLDB_REGISTER_METHOD(const char *, SBProcess, GetExitDescription, ());
 1345   LLDB_REGISTER_METHOD(lldb::pid_t, SBProcess, GetProcessID, ());
 1346   LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetUniqueID, ());
 1347   LLDB_REGISTER_METHOD_CONST(lldb::ByteOrder, SBProcess, GetByteOrder, ());
 1348   LLDB_REGISTER_METHOD_CONST(uint32_t, SBProcess, GetAddressByteSize, ());
 1349   LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Continue, ());
 1350   LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Destroy, ());
 1351   LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Stop, ());
 1352   LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Kill, ());
 1353   LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Detach, ());
 1354   LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Detach, (bool));
 1355   LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Signal, (int));
 1356   LLDB_REGISTER_METHOD(lldb::SBUnixSignals, SBProcess, GetUnixSignals, ());
 1357   LLDB_REGISTER_METHOD(void, SBProcess, SendAsyncInterrupt, ());
 1358   LLDB_REGISTER_METHOD(lldb::SBThread, SBProcess, GetThreadByID,
 1360   LLDB_REGISTER_METHOD(lldb::SBThread, SBProcess, GetThreadByIndexID,
 1362   LLDB_REGISTER_STATIC_METHOD(lldb::StateType, SBProcess, GetStateFromEvent,
 1364   LLDB_REGISTER_STATIC_METHOD(bool, SBProcess, GetRestartedFromEvent,
 1366   LLDB_REGISTER_STATIC_METHOD(size_t, SBProcess,
 1369   LLDB_REGISTER_STATIC_METHOD(const char *, SBProcess,
 1372   LLDB_REGISTER_STATIC_METHOD(lldb::SBProcess, SBProcess, GetProcessFromEvent,
 1374   LLDB_REGISTER_STATIC_METHOD(bool, SBProcess, GetInterruptedFromEvent,
 1376   LLDB_REGISTER_STATIC_METHOD(lldb::SBStructuredData, SBProcess,
 1379   LLDB_REGISTER_STATIC_METHOD(bool, SBProcess, EventIsProcessEvent,
 1381   LLDB_REGISTER_STATIC_METHOD(bool, SBProcess, EventIsStructuredDataEvent,
 1383   LLDB_REGISTER_METHOD_CONST(lldb::SBBroadcaster, SBProcess, GetBroadcaster,
 1385   LLDB_REGISTER_STATIC_METHOD(const char *, SBProcess, GetBroadcasterClass,
 1387   LLDB_REGISTER_METHOD(uint64_t, SBProcess, ReadUnsignedFromMemory,
 1389   LLDB_REGISTER_METHOD(lldb::addr_t, SBProcess, ReadPointerFromMemory,
 1391   LLDB_REGISTER_METHOD(bool, SBProcess, GetDescription, (lldb::SBStream &));
 1392   LLDB_REGISTER_METHOD_CONST(uint32_t, SBProcess,
 1395   LLDB_REGISTER_METHOD(uint32_t, SBProcess, LoadImage,
 1397   LLDB_REGISTER_METHOD(
 1400   LLDB_REGISTER_METHOD(uint32_t, SBProcess, LoadImageUsingPaths,
 1403   LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, UnloadImage, (uint32_t));
 1404   LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, SendEventData,
 1406   LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetNumExtendedBacktraceTypes, ());
 1407   LLDB_REGISTER_METHOD(const char *, SBProcess,
 1409   LLDB_REGISTER_METHOD(lldb::SBThreadCollection, SBProcess, GetHistoryThreads,
 1411   LLDB_REGISTER_METHOD(bool, SBProcess, IsInstrumentationRuntimePresent,
 1413   LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, SaveCore, (const char *));
 1414   LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, GetMemoryRegionInfo,
 1416   LLDB_REGISTER_METHOD(lldb::SBMemoryRegionInfoList, SBProcess,
 1418   LLDB_REGISTER_METHOD(lldb::SBProcessInfo, SBProcess, GetProcessInfo, ());

tools/lldb/source/API/SBProcessInfo.cpp

  187   LLDB_REGISTER_CONSTRUCTOR(SBProcessInfo, ());
  188   LLDB_REGISTER_CONSTRUCTOR(SBProcessInfo, (const lldb::SBProcessInfo &));
  189   LLDB_REGISTER_METHOD(
  192   LLDB_REGISTER_METHOD_CONST(bool, SBProcessInfo, IsValid, ());
  193   LLDB_REGISTER_METHOD_CONST(bool, SBProcessInfo, operator bool, ());
  194   LLDB_REGISTER_METHOD(const char *, SBProcessInfo, GetName, ());
  195   LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBProcessInfo, GetExecutableFile,
  197   LLDB_REGISTER_METHOD(lldb::pid_t, SBProcessInfo, GetProcessID, ());
  198   LLDB_REGISTER_METHOD(uint32_t, SBProcessInfo, GetUserID, ());
  199   LLDB_REGISTER_METHOD(uint32_t, SBProcessInfo, GetGroupID, ());
  200   LLDB_REGISTER_METHOD(bool, SBProcessInfo, UserIDIsValid, ());
  201   LLDB_REGISTER_METHOD(bool, SBProcessInfo, GroupIDIsValid, ());
  202   LLDB_REGISTER_METHOD(uint32_t, SBProcessInfo, GetEffectiveUserID, ());
  203   LLDB_REGISTER_METHOD(uint32_t, SBProcessInfo, GetEffectiveGroupID, ());
  204   LLDB_REGISTER_METHOD(bool, SBProcessInfo, EffectiveUserIDIsValid, ());
  205   LLDB_REGISTER_METHOD(bool, SBProcessInfo, EffectiveGroupIDIsValid, ());
  206   LLDB_REGISTER_METHOD(lldb::pid_t, SBProcessInfo, GetParentProcessID, ());

tools/lldb/source/API/SBQueue.cpp

  337   LLDB_REGISTER_CONSTRUCTOR(SBQueue, ());
  338   LLDB_REGISTER_CONSTRUCTOR(SBQueue, (const lldb::QueueSP &));
  339   LLDB_REGISTER_CONSTRUCTOR(SBQueue, (const lldb::SBQueue &));
  340   LLDB_REGISTER_METHOD(const lldb::SBQueue &,
  342   LLDB_REGISTER_METHOD_CONST(bool, SBQueue, IsValid, ());
  343   LLDB_REGISTER_METHOD_CONST(bool, SBQueue, operator bool, ());
  344   LLDB_REGISTER_METHOD(void, SBQueue, Clear, ());
  345   LLDB_REGISTER_METHOD_CONST(lldb::queue_id_t, SBQueue, GetQueueID, ());
  346   LLDB_REGISTER_METHOD_CONST(uint32_t, SBQueue, GetIndexID, ());
  347   LLDB_REGISTER_METHOD_CONST(const char *, SBQueue, GetName, ());
  348   LLDB_REGISTER_METHOD(uint32_t, SBQueue, GetNumThreads, ());
  349   LLDB_REGISTER_METHOD(lldb::SBThread, SBQueue, GetThreadAtIndex, (uint32_t));
  350   LLDB_REGISTER_METHOD(uint32_t, SBQueue, GetNumPendingItems, ());
  351   LLDB_REGISTER_METHOD(lldb::SBQueueItem, SBQueue, GetPendingItemAtIndex,
  353   LLDB_REGISTER_METHOD(uint32_t, SBQueue, GetNumRunningItems, ());
  354   LLDB_REGISTER_METHOD(lldb::SBProcess, SBQueue, GetProcess, ());
  355   LLDB_REGISTER_METHOD(lldb::QueueKind, SBQueue, GetKind, ());

tools/lldb/source/API/SBQueueItem.cpp

  124   LLDB_REGISTER_CONSTRUCTOR(SBQueueItem, ());
  125   LLDB_REGISTER_CONSTRUCTOR(SBQueueItem, (const lldb::QueueItemSP &));
  126   LLDB_REGISTER_METHOD_CONST(bool, SBQueueItem, IsValid, ());
  127   LLDB_REGISTER_METHOD_CONST(bool, SBQueueItem, operator bool, ());
  128   LLDB_REGISTER_METHOD(void, SBQueueItem, Clear, ());
  129   LLDB_REGISTER_METHOD(void, SBQueueItem, SetQueueItem,
  131   LLDB_REGISTER_METHOD_CONST(lldb::QueueItemKind, SBQueueItem, GetKind, ());
  132   LLDB_REGISTER_METHOD(void, SBQueueItem, SetKind, (lldb::QueueItemKind));
  133   LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBQueueItem, GetAddress, ());
  134   LLDB_REGISTER_METHOD(void, SBQueueItem, SetAddress, (lldb::SBAddress));
  135   LLDB_REGISTER_METHOD(lldb::SBThread, SBQueueItem,

tools/lldb/source/API/SBSection.cpp

  297   LLDB_REGISTER_CONSTRUCTOR(SBSection, ());
  298   LLDB_REGISTER_CONSTRUCTOR(SBSection, (const lldb::SBSection &));
  299   LLDB_REGISTER_METHOD(const lldb::SBSection &,
  301   LLDB_REGISTER_METHOD_CONST(bool, SBSection, IsValid, ());
  302   LLDB_REGISTER_METHOD_CONST(bool, SBSection, operator bool, ());
  303   LLDB_REGISTER_METHOD(const char *, SBSection, GetName, ());
  304   LLDB_REGISTER_METHOD(lldb::SBSection, SBSection, GetParent, ());
  305   LLDB_REGISTER_METHOD(lldb::SBSection, SBSection, FindSubSection,
  307   LLDB_REGISTER_METHOD(size_t, SBSection, GetNumSubSections, ());
  308   LLDB_REGISTER_METHOD(lldb::SBSection, SBSection, GetSubSectionAtIndex,
  310   LLDB_REGISTER_METHOD(lldb::addr_t, SBSection, GetFileAddress, ());
  311   LLDB_REGISTER_METHOD(lldb::addr_t, SBSection, GetLoadAddress,
  313   LLDB_REGISTER_METHOD(lldb::addr_t, SBSection, GetByteSize, ());
  314   LLDB_REGISTER_METHOD(uint64_t, SBSection, GetFileOffset, ());
  315   LLDB_REGISTER_METHOD(uint64_t, SBSection, GetFileByteSize, ());
  316   LLDB_REGISTER_METHOD(lldb::SBData, SBSection, GetSectionData, ());
  317   LLDB_REGISTER_METHOD(lldb::SBData, SBSection, GetSectionData,
  319   LLDB_REGISTER_METHOD(lldb::SectionType, SBSection, GetSectionType, ());
  320   LLDB_REGISTER_METHOD_CONST(uint32_t, SBSection, GetPermissions, ());
  321   LLDB_REGISTER_METHOD(uint32_t, SBSection, GetTargetByteSize, ());
  322   LLDB_REGISTER_METHOD(bool, SBSection, operator==,(const lldb::SBSection &));
  323   LLDB_REGISTER_METHOD(bool, SBSection, operator!=,(const lldb::SBSection &));
  324   LLDB_REGISTER_METHOD(bool, SBSection, GetDescription, (lldb::SBStream &));

tools/lldb/source/API/SBSourceManager.cpp

  147   LLDB_REGISTER_CONSTRUCTOR(SBSourceManager, (const lldb::SBDebugger &));
  148   LLDB_REGISTER_CONSTRUCTOR(SBSourceManager, (const lldb::SBTarget &));
  149   LLDB_REGISTER_CONSTRUCTOR(SBSourceManager, (const lldb::SBSourceManager &));
  150   LLDB_REGISTER_METHOD(
  153   LLDB_REGISTER_METHOD(size_t, SBSourceManager,
  157   LLDB_REGISTER_METHOD(size_t, SBSourceManager,

tools/lldb/source/API/SBStream.cpp

  193   LLDB_REGISTER_CONSTRUCTOR(SBStream, ());
  194   LLDB_REGISTER_METHOD_CONST(bool, SBStream, IsValid, ());
  195   LLDB_REGISTER_METHOD_CONST(bool, SBStream, operator bool, ());
  196   LLDB_REGISTER_METHOD(const char *, SBStream, GetData, ());
  197   LLDB_REGISTER_METHOD(size_t, SBStream, GetSize, ());
  198   LLDB_REGISTER_METHOD(void, SBStream, RedirectToFile, (const char *, bool));
  199   LLDB_REGISTER_METHOD(void, SBStream, RedirectToFile, (FileSP));
  200   LLDB_REGISTER_METHOD(void, SBStream, RedirectToFile, (SBFile));
  201   LLDB_REGISTER_METHOD(void, SBStream, RedirectToFileHandle, (FILE *, bool));
  202   LLDB_REGISTER_METHOD(void, SBStream, RedirectToFileDescriptor, (int, bool));
  203   LLDB_REGISTER_METHOD(void, SBStream, Clear, ());

tools/lldb/source/API/SBStringList.cpp

  144   LLDB_REGISTER_CONSTRUCTOR(SBStringList, ());
  145   LLDB_REGISTER_CONSTRUCTOR(SBStringList, (const lldb::SBStringList &));
  146   LLDB_REGISTER_METHOD(const lldb::SBStringList &,
  148   LLDB_REGISTER_METHOD_CONST(bool, SBStringList, IsValid, ());
  149   LLDB_REGISTER_METHOD_CONST(bool, SBStringList, operator bool, ());
  150   LLDB_REGISTER_METHOD(void, SBStringList, AppendString, (const char *));
  151   LLDB_REGISTER_METHOD(void, SBStringList, AppendList, (const char **, int));
  152   LLDB_REGISTER_METHOD(void, SBStringList, AppendList,
  154   LLDB_REGISTER_METHOD_CONST(uint32_t, SBStringList, GetSize, ());
  155   LLDB_REGISTER_METHOD(const char *, SBStringList, GetStringAtIndex,
  157   LLDB_REGISTER_METHOD_CONST(const char *, SBStringList, GetStringAtIndex,
  159   LLDB_REGISTER_METHOD(void, SBStringList, Clear, ());

tools/lldb/source/API/SBStructuredData.cpp

  210   LLDB_REGISTER_CONSTRUCTOR(SBStructuredData, ());
  211   LLDB_REGISTER_CONSTRUCTOR(SBStructuredData,
  213   LLDB_REGISTER_CONSTRUCTOR(SBStructuredData, (const lldb::EventSP &));
  214   LLDB_REGISTER_CONSTRUCTOR(SBStructuredData,
  216   LLDB_REGISTER_METHOD(
  219   LLDB_REGISTER_METHOD(lldb::SBError, SBStructuredData, SetFromJSON,
  221   LLDB_REGISTER_METHOD_CONST(bool, SBStructuredData, IsValid, ());
  222   LLDB_REGISTER_METHOD_CONST(bool, SBStructuredData, operator bool, ());
  223   LLDB_REGISTER_METHOD(void, SBStructuredData, Clear, ());
  224   LLDB_REGISTER_METHOD_CONST(lldb::SBError, SBStructuredData, GetAsJSON,
  226   LLDB_REGISTER_METHOD_CONST(lldb::SBError, SBStructuredData, GetDescription,
  228   LLDB_REGISTER_METHOD_CONST(lldb::StructuredDataType, SBStructuredData,
  230   LLDB_REGISTER_METHOD_CONST(size_t, SBStructuredData, GetSize, ());
  231   LLDB_REGISTER_METHOD_CONST(bool, SBStructuredData, GetKeys,
  233   LLDB_REGISTER_METHOD_CONST(lldb::SBStructuredData, SBStructuredData,
  235   LLDB_REGISTER_METHOD_CONST(lldb::SBStructuredData, SBStructuredData,
  237   LLDB_REGISTER_METHOD_CONST(uint64_t, SBStructuredData, GetIntegerValue,
  239   LLDB_REGISTER_METHOD_CONST(double, SBStructuredData, GetFloatValue,
  241   LLDB_REGISTER_METHOD_CONST(bool, SBStructuredData, GetBooleanValue, (bool));
  242   LLDB_REGISTER_METHOD_CONST(size_t, SBStructuredData, GetStringValue,

tools/lldb/source/API/SBSymbol.cpp

  217   LLDB_REGISTER_CONSTRUCTOR(SBSymbol, ());
  218   LLDB_REGISTER_CONSTRUCTOR(SBSymbol, (const lldb::SBSymbol &));
  219   LLDB_REGISTER_METHOD(const lldb::SBSymbol &,
  221   LLDB_REGISTER_METHOD_CONST(bool, SBSymbol, IsValid, ());
  222   LLDB_REGISTER_METHOD_CONST(bool, SBSymbol, operator bool, ());
  223   LLDB_REGISTER_METHOD_CONST(const char *, SBSymbol, GetName, ());
  224   LLDB_REGISTER_METHOD_CONST(const char *, SBSymbol, GetDisplayName, ());
  225   LLDB_REGISTER_METHOD_CONST(const char *, SBSymbol, GetMangledName, ());
  226   LLDB_REGISTER_METHOD_CONST(bool,
  228   LLDB_REGISTER_METHOD_CONST(bool,
  230   LLDB_REGISTER_METHOD(bool, SBSymbol, GetDescription, (lldb::SBStream &));
  231   LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBSymbol, GetInstructions,
  233   LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBSymbol, GetInstructions,
  235   LLDB_REGISTER_METHOD(lldb::SBAddress, SBSymbol, GetStartAddress, ());
  236   LLDB_REGISTER_METHOD(lldb::SBAddress, SBSymbol, GetEndAddress, ());
  237   LLDB_REGISTER_METHOD(uint32_t, SBSymbol, GetPrologueByteSize, ());
  238   LLDB_REGISTER_METHOD(lldb::SymbolType, SBSymbol, GetType, ());
  239   LLDB_REGISTER_METHOD(bool, SBSymbol, IsExternal, ());
  240   LLDB_REGISTER_METHOD(bool, SBSymbol, IsSynthetic, ());

tools/lldb/source/API/SBSymbolContext.cpp

  238   LLDB_REGISTER_CONSTRUCTOR(SBSymbolContext, ());
  239   LLDB_REGISTER_CONSTRUCTOR(SBSymbolContext,
  241   LLDB_REGISTER_CONSTRUCTOR(SBSymbolContext, (const lldb::SBSymbolContext &));
  242   LLDB_REGISTER_METHOD(
  245   LLDB_REGISTER_METHOD_CONST(bool, SBSymbolContext, IsValid, ());
  246   LLDB_REGISTER_METHOD_CONST(bool, SBSymbolContext, operator bool, ());
  247   LLDB_REGISTER_METHOD(lldb::SBModule, SBSymbolContext, GetModule, ());
  248   LLDB_REGISTER_METHOD(lldb::SBCompileUnit, SBSymbolContext, GetCompileUnit,
  250   LLDB_REGISTER_METHOD(lldb::SBFunction, SBSymbolContext, GetFunction, ());
  251   LLDB_REGISTER_METHOD(lldb::SBBlock, SBSymbolContext, GetBlock, ());
  252   LLDB_REGISTER_METHOD(lldb::SBLineEntry, SBSymbolContext, GetLineEntry, ());
  253   LLDB_REGISTER_METHOD(lldb::SBSymbol, SBSymbolContext, GetSymbol, ());
  254   LLDB_REGISTER_METHOD(void, SBSymbolContext, SetModule, (lldb::SBModule));
  255   LLDB_REGISTER_METHOD(void, SBSymbolContext, SetCompileUnit,
  257   LLDB_REGISTER_METHOD(void, SBSymbolContext, SetFunction,
  259   LLDB_REGISTER_METHOD(void, SBSymbolContext, SetBlock, (lldb::SBBlock));
  260   LLDB_REGISTER_METHOD(void, SBSymbolContext, SetLineEntry,
  262   LLDB_REGISTER_METHOD(void, SBSymbolContext, SetSymbol, (lldb::SBSymbol));
  263   LLDB_REGISTER_METHOD(bool, SBSymbolContext, GetDescription,
  265   LLDB_REGISTER_METHOD_CONST(lldb::SBSymbolContext, SBSymbolContext,

tools/lldb/source/API/SBSymbolContextList.cpp

  123   LLDB_REGISTER_CONSTRUCTOR(SBSymbolContextList, ());
  124   LLDB_REGISTER_CONSTRUCTOR(SBSymbolContextList,
  126   LLDB_REGISTER_METHOD(
  129   LLDB_REGISTER_METHOD_CONST(uint32_t, SBSymbolContextList, GetSize, ());
  130   LLDB_REGISTER_METHOD(lldb::SBSymbolContext, SBSymbolContextList,
  132   LLDB_REGISTER_METHOD(void, SBSymbolContextList, Clear, ());
  133   LLDB_REGISTER_METHOD(void, SBSymbolContextList, Append,
  135   LLDB_REGISTER_METHOD(void, SBSymbolContextList, Append,
  137   LLDB_REGISTER_METHOD_CONST(bool, SBSymbolContextList, IsValid, ());
  138   LLDB_REGISTER_METHOD_CONST(bool, SBSymbolContextList, operator bool, ());
  139   LLDB_REGISTER_METHOD(bool, SBSymbolContextList, GetDescription,

tools/lldb/source/API/SBTarget.cpp

 2395   LLDB_REGISTER_CONSTRUCTOR(SBTarget, ());
 2396   LLDB_REGISTER_CONSTRUCTOR(SBTarget, (const lldb::SBTarget &));
 2397   LLDB_REGISTER_CONSTRUCTOR(SBTarget, (const lldb::TargetSP &));
 2398   LLDB_REGISTER_METHOD(const lldb::SBTarget &,
 2400   LLDB_REGISTER_STATIC_METHOD(bool, SBTarget, EventIsTargetEvent,
 2402   LLDB_REGISTER_STATIC_METHOD(lldb::SBTarget, SBTarget, GetTargetFromEvent,
 2404   LLDB_REGISTER_STATIC_METHOD(uint32_t, SBTarget, GetNumModulesFromEvent,
 2406   LLDB_REGISTER_STATIC_METHOD(lldb::SBModule, SBTarget,
 2409   LLDB_REGISTER_STATIC_METHOD(const char *, SBTarget, GetBroadcasterClassName,
 2411   LLDB_REGISTER_METHOD_CONST(bool, SBTarget, IsValid, ());
 2412   LLDB_REGISTER_METHOD_CONST(bool, SBTarget, operator bool, ());
 2413   LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, GetProcess, ());
 2414   LLDB_REGISTER_METHOD(lldb::SBPlatform, SBTarget, GetPlatform, ());
 2415   LLDB_REGISTER_METHOD_CONST(lldb::SBDebugger, SBTarget, GetDebugger, ());
 2416   LLDB_REGISTER_METHOD(lldb::SBStructuredData, SBTarget, GetStatistics, ());
 2417   LLDB_REGISTER_METHOD(void, SBTarget, SetCollectingStats, (bool));
 2418   LLDB_REGISTER_METHOD(bool, SBTarget, GetCollectingStats, ());
 2419   LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, LoadCore, (const char *));
 2420   LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, LoadCore,
 2422   LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, LaunchSimple,
 2424   LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, Install, ());
 2425   LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, Launch,
 2429   LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, Launch,
 2431   LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, Attach,
 2433   LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, AttachToProcessWithID,
 2435   LLDB_REGISTER_METHOD(
 2438   LLDB_REGISTER_METHOD(
 2441   LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBTarget, GetExecutable, ());
 2442   LLDB_REGISTER_METHOD_CONST(bool,
 2444   LLDB_REGISTER_METHOD_CONST(bool,
 2446   LLDB_REGISTER_METHOD(lldb::SBAddress, SBTarget, ResolveLoadAddress,
 2448   LLDB_REGISTER_METHOD(lldb::SBAddress, SBTarget, ResolveFileAddress,
 2450   LLDB_REGISTER_METHOD(lldb::SBAddress, SBTarget, ResolvePastLoadAddress,
 2452   LLDB_REGISTER_METHOD(lldb::SBSymbolContext, SBTarget,
 2455   LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
 2457   LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
 2460   LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
 2463   LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
 2467   LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
 2471   LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
 2473   LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
 2476   LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
 2479   LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
 2483   LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames,
 2487   LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames,
 2491   LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames,
 2495   LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex,
 2497   LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex,
 2500   LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex,
 2504   LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
 2506   LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
 2508   LLDB_REGISTER_METHOD(
 2511   LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
 2515   LLDB_REGISTER_METHOD(
 2519   LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
 2522   LLDB_REGISTER_METHOD(
 2526   LLDB_REGISTER_METHOD_CONST(uint32_t, SBTarget, GetNumBreakpoints, ());
 2527   LLDB_REGISTER_METHOD_CONST(lldb::SBBreakpoint, SBTarget,
 2529   LLDB_REGISTER_METHOD(bool, SBTarget, BreakpointDelete, (lldb::break_id_t));
 2530   LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, FindBreakpointByID,
 2532   LLDB_REGISTER_METHOD(bool, SBTarget, FindBreakpointsByName,
 2534   LLDB_REGISTER_METHOD(void, SBTarget, GetBreakpointNames,
 2536   LLDB_REGISTER_METHOD(void, SBTarget, DeleteBreakpointName, (const char *));
 2537   LLDB_REGISTER_METHOD(bool, SBTarget, EnableAllBreakpoints, ());
 2538   LLDB_REGISTER_METHOD(bool, SBTarget, DisableAllBreakpoints, ());
 2539   LLDB_REGISTER_METHOD(bool, SBTarget, DeleteAllBreakpoints, ());
 2540   LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, BreakpointsCreateFromFile,
 2542   LLDB_REGISTER_METHOD(
 2545   LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, BreakpointsWriteToFile,
 2547   LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, BreakpointsWriteToFile,
 2549   LLDB_REGISTER_METHOD_CONST(uint32_t, SBTarget, GetNumWatchpoints, ());
 2550   LLDB_REGISTER_METHOD_CONST(lldb::SBWatchpoint, SBTarget,
 2552   LLDB_REGISTER_METHOD(bool, SBTarget, DeleteWatchpoint, (lldb::watch_id_t));
 2553   LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBTarget, FindWatchpointByID,
 2555   LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBTarget, WatchAddress,
 2557   LLDB_REGISTER_METHOD(bool, SBTarget, EnableAllWatchpoints, ());
 2558   LLDB_REGISTER_METHOD(bool, SBTarget, DisableAllWatchpoints, ());
 2559   LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, CreateValueFromAddress,
 2561   LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, CreateValueFromData,
 2563   LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, CreateValueFromExpression,
 2565   LLDB_REGISTER_METHOD(bool, SBTarget, DeleteAllWatchpoints, ());
 2566   LLDB_REGISTER_METHOD(void, SBTarget, AppendImageSearchPath,
 2568   LLDB_REGISTER_METHOD(lldb::SBModule, SBTarget, AddModule,
 2570   LLDB_REGISTER_METHOD(
 2573   LLDB_REGISTER_METHOD(lldb::SBModule, SBTarget, AddModule,
 2575   LLDB_REGISTER_METHOD(bool, SBTarget, AddModule, (lldb::SBModule &));
 2576   LLDB_REGISTER_METHOD_CONST(uint32_t, SBTarget, GetNumModules, ());
 2577   LLDB_REGISTER_METHOD(void, SBTarget, Clear, ());
 2578   LLDB_REGISTER_METHOD(lldb::SBModule, SBTarget, FindModule,
 2580   LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBTarget, FindCompileUnits,
 2582   LLDB_REGISTER_METHOD(lldb::ByteOrder, SBTarget, GetByteOrder, ());
 2583   LLDB_REGISTER_METHOD(const char *, SBTarget, GetTriple, ());
 2584   LLDB_REGISTER_METHOD(uint32_t, SBTarget, GetDataByteSize, ());
 2585   LLDB_REGISTER_METHOD(uint32_t, SBTarget, GetCodeByteSize, ());
 2586   LLDB_REGISTER_METHOD(uint32_t, SBTarget, GetAddressByteSize, ());
 2587   LLDB_REGISTER_METHOD(lldb::SBModule, SBTarget, GetModuleAtIndex,
 2589   LLDB_REGISTER_METHOD(bool, SBTarget, RemoveModule, (lldb::SBModule));
 2590   LLDB_REGISTER_METHOD_CONST(lldb::SBBroadcaster, SBTarget, GetBroadcaster,
 2592   LLDB_REGISTER_METHOD(bool, SBTarget, GetDescription,
 2594   LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBTarget, FindFunctions,
 2596   LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBTarget,
 2599   LLDB_REGISTER_METHOD(lldb::SBType, SBTarget, FindFirstType, (const char *));
 2600   LLDB_REGISTER_METHOD(lldb::SBType, SBTarget, GetBasicType,
 2602   LLDB_REGISTER_METHOD(lldb::SBTypeList, SBTarget, FindTypes, (const char *));
 2603   LLDB_REGISTER_METHOD(lldb::SBValueList, SBTarget, FindGlobalVariables,
 2605   LLDB_REGISTER_METHOD(lldb::SBValueList, SBTarget, FindGlobalVariables,
 2607   LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, FindFirstGlobalVariable,
 2609   LLDB_REGISTER_METHOD(lldb::SBSourceManager, SBTarget, GetSourceManager, ());
 2610   LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBTarget, ReadInstructions,
 2612   LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBTarget, ReadInstructions,
 2614   LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, SetSectionLoadAddress,
 2616   LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, ClearSectionLoadAddress,
 2618   LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, SetModuleLoadAddress,
 2620   LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, ClearModuleLoadAddress,
 2622   LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBTarget, FindSymbols,
 2624   LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, EvaluateExpression,
 2626   LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, EvaluateExpression,
 2628   LLDB_REGISTER_METHOD(lldb::addr_t, SBTarget, GetStackRedZoneSize, ());
 2629   LLDB_REGISTER_METHOD_CONST(lldb::SBLaunchInfo, SBTarget, GetLaunchInfo, ());
 2630   LLDB_REGISTER_METHOD(void, SBTarget, SetLaunchInfo,

tools/lldb/source/API/SBThread.cpp

 1426   LLDB_REGISTER_STATIC_METHOD(const char *, SBThread, GetBroadcasterClassName,
 1428   LLDB_REGISTER_CONSTRUCTOR(SBThread, ());
 1429   LLDB_REGISTER_CONSTRUCTOR(SBThread, (const lldb::ThreadSP &));
 1430   LLDB_REGISTER_CONSTRUCTOR(SBThread, (const lldb::SBThread &));
 1431   LLDB_REGISTER_METHOD(const lldb::SBThread &,
 1433   LLDB_REGISTER_METHOD_CONST(lldb::SBQueue, SBThread, GetQueue, ());
 1434   LLDB_REGISTER_METHOD_CONST(bool, SBThread, IsValid, ());
 1435   LLDB_REGISTER_METHOD_CONST(bool, SBThread, operator bool, ());
 1436   LLDB_REGISTER_METHOD(void, SBThread, Clear, ());
 1437   LLDB_REGISTER_METHOD(lldb::StopReason, SBThread, GetStopReason, ());
 1438   LLDB_REGISTER_METHOD(size_t, SBThread, GetStopReasonDataCount, ());
 1439   LLDB_REGISTER_METHOD(uint64_t, SBThread, GetStopReasonDataAtIndex,
 1441   LLDB_REGISTER_METHOD(bool, SBThread, GetStopReasonExtendedInfoAsJSON,
 1443   LLDB_REGISTER_METHOD(lldb::SBThreadCollection, SBThread,
 1446   LLDB_REGISTER_METHOD(size_t, SBThread, GetStopDescription,
 1448   LLDB_REGISTER_METHOD(lldb::SBValue, SBThread, GetStopReturnValue, ());
 1449   LLDB_REGISTER_METHOD_CONST(lldb::tid_t, SBThread, GetThreadID, ());
 1450   LLDB_REGISTER_METHOD_CONST(uint32_t, SBThread, GetIndexID, ());
 1451   LLDB_REGISTER_METHOD_CONST(const char *, SBThread, GetName, ());
 1452   LLDB_REGISTER_METHOD_CONST(const char *, SBThread, GetQueueName, ());
 1453   LLDB_REGISTER_METHOD_CONST(lldb::queue_id_t, SBThread, GetQueueID, ());
 1454   LLDB_REGISTER_METHOD(bool, SBThread, GetInfoItemByPathAsString,
 1456   LLDB_REGISTER_METHOD(void, SBThread, StepOver, (lldb::RunMode));
 1457   LLDB_REGISTER_METHOD(void, SBThread, StepOver,
 1459   LLDB_REGISTER_METHOD(void, SBThread, StepInto, (lldb::RunMode));
 1460   LLDB_REGISTER_METHOD(void, SBThread, StepInto,
 1462   LLDB_REGISTER_METHOD(
 1465   LLDB_REGISTER_METHOD(void, SBThread, StepOut, ());
 1466   LLDB_REGISTER_METHOD(void, SBThread, StepOut, (lldb::SBError &));
 1467   LLDB_REGISTER_METHOD(void, SBThread, StepOutOfFrame, (lldb::SBFrame &));
 1468   LLDB_REGISTER_METHOD(void, SBThread, StepOutOfFrame,
 1470   LLDB_REGISTER_METHOD(void, SBThread, StepInstruction, (bool));
 1471   LLDB_REGISTER_METHOD(void, SBThread, StepInstruction,
 1473   LLDB_REGISTER_METHOD(void, SBThread, RunToAddress, (lldb::addr_t));
 1474   LLDB_REGISTER_METHOD(void, SBThread, RunToAddress,
 1476   LLDB_REGISTER_METHOD(lldb::SBError, SBThread, StepOverUntil,
 1478   LLDB_REGISTER_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan,
 1480   LLDB_REGISTER_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan,
 1482   LLDB_REGISTER_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan,
 1484   LLDB_REGISTER_METHOD(lldb::SBError, SBThread, JumpToLine,
 1486   LLDB_REGISTER_METHOD(lldb::SBError, SBThread, ReturnFromFrame,
 1488   LLDB_REGISTER_METHOD(lldb::SBError, SBThread, UnwindInnermostExpression,
 1490   LLDB_REGISTER_METHOD(bool, SBThread, Suspend, ());
 1491   LLDB_REGISTER_METHOD(bool, SBThread, Suspend, (lldb::SBError &));
 1492   LLDB_REGISTER_METHOD(bool, SBThread, Resume, ());
 1493   LLDB_REGISTER_METHOD(bool, SBThread, Resume, (lldb::SBError &));
 1494   LLDB_REGISTER_METHOD(bool, SBThread, IsSuspended, ());
 1495   LLDB_REGISTER_METHOD(bool, SBThread, IsStopped, ());
 1496   LLDB_REGISTER_METHOD(lldb::SBProcess, SBThread, GetProcess, ());
 1497   LLDB_REGISTER_METHOD(uint32_t, SBThread, GetNumFrames, ());
 1498   LLDB_REGISTER_METHOD(lldb::SBFrame, SBThread, GetFrameAtIndex, (uint32_t));
 1499   LLDB_REGISTER_METHOD(lldb::SBFrame, SBThread, GetSelectedFrame, ());
 1500   LLDB_REGISTER_METHOD(lldb::SBFrame, SBThread, SetSelectedFrame, (uint32_t));
 1501   LLDB_REGISTER_STATIC_METHOD(bool, SBThread, EventIsThreadEvent,
 1503   LLDB_REGISTER_STATIC_METHOD(lldb::SBFrame, SBThread, GetStackFrameFromEvent,
 1505   LLDB_REGISTER_STATIC_METHOD(lldb::SBThread, SBThread, GetThreadFromEvent,
 1507   LLDB_REGISTER_METHOD_CONST(bool,
 1509   LLDB_REGISTER_METHOD_CONST(bool,
 1511   LLDB_REGISTER_METHOD_CONST(bool, SBThread, GetStatus, (lldb::SBStream &));
 1512   LLDB_REGISTER_METHOD_CONST(bool, SBThread, GetDescription,
 1514   LLDB_REGISTER_METHOD_CONST(bool, SBThread, GetDescription,
 1516   LLDB_REGISTER_METHOD(lldb::SBThread, SBThread, GetExtendedBacktraceThread,
 1518   LLDB_REGISTER_METHOD(uint32_t, SBThread,
 1520   LLDB_REGISTER_METHOD(lldb::SBValue, SBThread, GetCurrentException, ());
 1521   LLDB_REGISTER_METHOD(lldb::SBThread, SBThread, GetCurrentExceptionBacktrace,
 1523   LLDB_REGISTER_METHOD(bool, SBThread, SafeToCallFunctions, ());

tools/lldb/source/API/SBThreadCollection.cpp

   96   LLDB_REGISTER_CONSTRUCTOR(SBThreadCollection, ());
   97   LLDB_REGISTER_CONSTRUCTOR(SBThreadCollection,
   99   LLDB_REGISTER_METHOD(
  102   LLDB_REGISTER_METHOD_CONST(bool, SBThreadCollection, IsValid, ());
  103   LLDB_REGISTER_METHOD_CONST(bool, SBThreadCollection, operator bool, ());
  104   LLDB_REGISTER_METHOD(size_t, SBThreadCollection, GetSize, ());
  105   LLDB_REGISTER_METHOD(lldb::SBThread, SBThreadCollection, GetThreadAtIndex,

tools/lldb/source/API/SBThreadPlan.cpp

  430   LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, ());
  431   LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, (const lldb::ThreadPlanSP &));
  432   LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, (const lldb::SBThreadPlan &));
  433   LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, (lldb::SBThread &, const char *));
  434   LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, (lldb::SBThread &, const char *,
  436   LLDB_REGISTER_METHOD(const lldb::SBThreadPlan &,
  438   LLDB_REGISTER_METHOD_CONST(bool, SBThreadPlan, IsValid, ());
  439   LLDB_REGISTER_METHOD_CONST(bool, SBThreadPlan, operator bool, ());
  440   LLDB_REGISTER_METHOD(void, SBThreadPlan, Clear, ());
  441   LLDB_REGISTER_METHOD(lldb::StopReason, SBThreadPlan, GetStopReason, ());
  442   LLDB_REGISTER_METHOD(size_t, SBThreadPlan, GetStopReasonDataCount, ());
  443   LLDB_REGISTER_METHOD(uint64_t, SBThreadPlan, GetStopReasonDataAtIndex,
  445   LLDB_REGISTER_METHOD_CONST(lldb::SBThread, SBThreadPlan, GetThread, ());
  446   LLDB_REGISTER_METHOD_CONST(bool, SBThreadPlan, GetDescription,
  448   LLDB_REGISTER_METHOD(void, SBThreadPlan, SetPlanComplete, (bool));
  449   LLDB_REGISTER_METHOD(bool, SBThreadPlan, IsPlanComplete, ());
  450   LLDB_REGISTER_METHOD(bool, SBThreadPlan, IsPlanStale, ());
  451   LLDB_REGISTER_METHOD(bool, SBThreadPlan, IsValid, ());
  452   LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
  455   LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
  458   LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
  461   LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
  464   LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
  466   LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
  469   LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
  471   LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
  474   LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
  476   LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
  479   LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,

tools/lldb/source/API/SBTrace.cpp

  136   LLDB_REGISTER_METHOD(void, SBTrace, StopTrace,
  138   LLDB_REGISTER_METHOD(void, SBTrace, GetTraceConfig,
  140   LLDB_REGISTER_METHOD(lldb::user_id_t, SBTrace, GetTraceUID, ());
  141   LLDB_REGISTER_CONSTRUCTOR(SBTrace, ());
  142   LLDB_REGISTER_METHOD(bool, SBTrace, IsValid, ());
  143   LLDB_REGISTER_METHOD_CONST(bool, SBTrace, operator bool, ());

tools/lldb/source/API/SBTraceOptions.cpp

  138   LLDB_REGISTER_CONSTRUCTOR(SBTraceOptions, ());
  139   LLDB_REGISTER_METHOD_CONST(lldb::TraceType, SBTraceOptions, getType, ());
  140   LLDB_REGISTER_METHOD_CONST(uint64_t, SBTraceOptions, getTraceBufferSize,
  142   LLDB_REGISTER_METHOD(lldb::SBStructuredData, SBTraceOptions, getTraceParams,
  144   LLDB_REGISTER_METHOD_CONST(uint64_t, SBTraceOptions, getMetaDataBufferSize,
  146   LLDB_REGISTER_METHOD(void, SBTraceOptions, setTraceParams,
  148   LLDB_REGISTER_METHOD(void, SBTraceOptions, setType, (lldb::TraceType));
  149   LLDB_REGISTER_METHOD(void, SBTraceOptions, setTraceBufferSize, (uint64_t));
  150   LLDB_REGISTER_METHOD(void, SBTraceOptions, setMetaDataBufferSize,
  152   LLDB_REGISTER_METHOD(bool, SBTraceOptions, IsValid, ());
  153   LLDB_REGISTER_METHOD_CONST(bool, SBTraceOptions, operator bool, ());
  154   LLDB_REGISTER_METHOD(void, SBTraceOptions, setThreadID, (lldb::tid_t));
  155   LLDB_REGISTER_METHOD(lldb::tid_t, SBTraceOptions, getThreadID, ());

tools/lldb/source/API/SBType.cpp

  901   LLDB_REGISTER_CONSTRUCTOR(SBType, ());
  902   LLDB_REGISTER_CONSTRUCTOR(SBType, (const lldb::SBType &));
  903   LLDB_REGISTER_METHOD(bool, SBType, operator==,(lldb::SBType &));
  904   LLDB_REGISTER_METHOD(bool, SBType, operator!=,(lldb::SBType &));
  905   LLDB_REGISTER_METHOD(lldb::SBType &,
  907   LLDB_REGISTER_METHOD_CONST(bool, SBType, IsValid, ());
  908   LLDB_REGISTER_METHOD_CONST(bool, SBType, operator bool, ());
  909   LLDB_REGISTER_METHOD(uint64_t, SBType, GetByteSize, ());
  910   LLDB_REGISTER_METHOD(bool, SBType, IsPointerType, ());
  911   LLDB_REGISTER_METHOD(bool, SBType, IsArrayType, ());
  912   LLDB_REGISTER_METHOD(bool, SBType, IsVectorType, ());
  913   LLDB_REGISTER_METHOD(bool, SBType, IsReferenceType, ());
  914   LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetPointerType, ());
  915   LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetPointeeType, ());
  916   LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetReferenceType, ());
  917   LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetTypedefedType, ());
  918   LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetDereferencedType, ());
  919   LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetArrayElementType, ());
  920   LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetArrayType, (uint64_t));
  921   LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetVectorElementType, ());
  922   LLDB_REGISTER_METHOD(bool, SBType, IsFunctionType, ());
  923   LLDB_REGISTER_METHOD(bool, SBType, IsPolymorphicClass, ());
  924   LLDB_REGISTER_METHOD(bool, SBType, IsTypedefType, ());
  925   LLDB_REGISTER_METHOD(bool, SBType, IsAnonymousType, ());
  926   LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetFunctionReturnType, ());
  927   LLDB_REGISTER_METHOD(lldb::SBTypeList, SBType, GetFunctionArgumentTypes,
  929   LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfMemberFunctions, ());
  930   LLDB_REGISTER_METHOD(lldb::SBTypeMemberFunction, SBType,
  932   LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetUnqualifiedType, ());
  933   LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetCanonicalType, ());
  934   LLDB_REGISTER_METHOD(lldb::BasicType, SBType, GetBasicType, ());
  935   LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetBasicType, (lldb::BasicType));
  936   LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfDirectBaseClasses, ());
  937   LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfVirtualBaseClasses, ());
  938   LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfFields, ());
  939   LLDB_REGISTER_METHOD(bool, SBType, GetDescription,
  941   LLDB_REGISTER_METHOD(lldb::SBTypeMember, SBType, GetDirectBaseClassAtIndex,
  943   LLDB_REGISTER_METHOD(lldb::SBTypeMember, SBType, GetVirtualBaseClassAtIndex,
  945   LLDB_REGISTER_METHOD(lldb::SBTypeEnumMemberList, SBType, GetEnumMembers,
  947   LLDB_REGISTER_METHOD(lldb::SBTypeMember, SBType, GetFieldAtIndex,
  949   LLDB_REGISTER_METHOD(bool, SBType, IsTypeComplete, ());
  950   LLDB_REGISTER_METHOD(uint32_t, SBType, GetTypeFlags, ());
  951   LLDB_REGISTER_METHOD(const char *, SBType, GetName, ());
  952   LLDB_REGISTER_METHOD(const char *, SBType, GetDisplayTypeName, ());
  953   LLDB_REGISTER_METHOD(lldb::TypeClass, SBType, GetTypeClass, ());
  954   LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfTemplateArguments, ());
  955   LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetTemplateArgumentType,
  957   LLDB_REGISTER_METHOD(lldb::TemplateArgumentKind, SBType,
  959   LLDB_REGISTER_CONSTRUCTOR(SBTypeList, ());
  960   LLDB_REGISTER_CONSTRUCTOR(SBTypeList, (const lldb::SBTypeList &));
  961   LLDB_REGISTER_METHOD(bool, SBTypeList, IsValid, ());
  962   LLDB_REGISTER_METHOD_CONST(bool, SBTypeList, operator bool, ());
  963   LLDB_REGISTER_METHOD(lldb::SBTypeList &,
  965   LLDB_REGISTER_METHOD(void, SBTypeList, Append, (lldb::SBType));
  966   LLDB_REGISTER_METHOD(lldb::SBType, SBTypeList, GetTypeAtIndex, (uint32_t));
  967   LLDB_REGISTER_METHOD(uint32_t, SBTypeList, GetSize, ());
  968   LLDB_REGISTER_CONSTRUCTOR(SBTypeMember, ());
  969   LLDB_REGISTER_CONSTRUCTOR(SBTypeMember, (const lldb::SBTypeMember &));
  970   LLDB_REGISTER_METHOD(lldb::SBTypeMember &,
  972   LLDB_REGISTER_METHOD_CONST(bool, SBTypeMember, IsValid, ());
  973   LLDB_REGISTER_METHOD_CONST(bool, SBTypeMember, operator bool, ());
  974   LLDB_REGISTER_METHOD(const char *, SBTypeMember, GetName, ());
  975   LLDB_REGISTER_METHOD(lldb::SBType, SBTypeMember, GetType, ());
  976   LLDB_REGISTER_METHOD(uint64_t, SBTypeMember, GetOffsetInBytes, ());
  977   LLDB_REGISTER_METHOD(uint64_t, SBTypeMember, GetOffsetInBits, ());
  978   LLDB_REGISTER_METHOD(bool, SBTypeMember, IsBitfield, ());
  979   LLDB_REGISTER_METHOD(uint32_t, SBTypeMember, GetBitfieldSizeInBits, ());
  980   LLDB_REGISTER_METHOD(bool, SBTypeMember, GetDescription,
  982   LLDB_REGISTER_CONSTRUCTOR(SBTypeMemberFunction, ());
  983   LLDB_REGISTER_CONSTRUCTOR(SBTypeMemberFunction,
  985   LLDB_REGISTER_METHOD(
  988   LLDB_REGISTER_METHOD_CONST(bool, SBTypeMemberFunction, IsValid, ());
  989   LLDB_REGISTER_METHOD_CONST(bool, SBTypeMemberFunction, operator bool, ());
  990   LLDB_REGISTER_METHOD(const char *, SBTypeMemberFunction, GetName, ());
  991   LLDB_REGISTER_METHOD(const char *, SBTypeMemberFunction, GetDemangledName,
  993   LLDB_REGISTER_METHOD(const char *, SBTypeMemberFunction, GetMangledName,
  995   LLDB_REGISTER_METHOD(lldb::SBType, SBTypeMemberFunction, GetType, ());
  996   LLDB_REGISTER_METHOD(lldb::SBType, SBTypeMemberFunction, GetReturnType, ());
  997   LLDB_REGISTER_METHOD(uint32_t, SBTypeMemberFunction, GetNumberOfArguments,
  999   LLDB_REGISTER_METHOD(lldb::SBType, SBTypeMemberFunction,
 1001   LLDB_REGISTER_METHOD(lldb::MemberFunctionKind, SBTypeMemberFunction,
 1003   LLDB_REGISTER_METHOD(bool, SBTypeMemberFunction, GetDescription,

tools/lldb/source/API/SBTypeCategory.cpp

  669   LLDB_REGISTER_CONSTRUCTOR(SBTypeCategory, ());
  670   LLDB_REGISTER_CONSTRUCTOR(SBTypeCategory, (const lldb::SBTypeCategory &));
  671   LLDB_REGISTER_METHOD_CONST(bool, SBTypeCategory, IsValid, ());
  672   LLDB_REGISTER_METHOD_CONST(bool, SBTypeCategory, operator bool, ());
  673   LLDB_REGISTER_METHOD(bool, SBTypeCategory, GetEnabled, ());
  674   LLDB_REGISTER_METHOD(void, SBTypeCategory, SetEnabled, (bool));
  675   LLDB_REGISTER_METHOD(const char *, SBTypeCategory, GetName, ());
  676   LLDB_REGISTER_METHOD(lldb::LanguageType, SBTypeCategory, GetLanguageAtIndex,
  678   LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumLanguages, ());
  679   LLDB_REGISTER_METHOD(void, SBTypeCategory, AddLanguage,
  681   LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumFormats, ());
  682   LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumSummaries, ());
  683   LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumFilters, ());
  684   LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumSynthetics, ());
  685   LLDB_REGISTER_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
  687   LLDB_REGISTER_METHOD(lldb::SBTypeSummary, SBTypeCategory, GetSummaryForType,
  689   LLDB_REGISTER_METHOD(lldb::SBTypeSynthetic, SBTypeCategory,
  691   LLDB_REGISTER_METHOD(lldb::SBTypeFilter, SBTypeCategory, GetFilterAtIndex,
  693   LLDB_REGISTER_METHOD(lldb::SBTypeSummary, SBTypeCategory, GetSummaryAtIndex,
  695   LLDB_REGISTER_METHOD(lldb::SBTypeSynthetic, SBTypeCategory,
  697   LLDB_REGISTER_METHOD(bool, SBTypeCategory, AddTypeSummary,
  699   LLDB_REGISTER_METHOD(bool, SBTypeCategory, AddTypeSynthetic,
  701   LLDB_REGISTER_METHOD(bool, SBTypeCategory, DeleteTypeSynthetic,
  703   LLDB_REGISTER_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
  705   LLDB_REGISTER_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
  707   LLDB_REGISTER_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
  709   LLDB_REGISTER_METHOD(lldb::SBTypeFilter, SBTypeCategory, GetFilterForType,
  711   LLDB_REGISTER_METHOD(lldb::SBTypeFormat, SBTypeCategory, GetFormatForType,
  713   LLDB_REGISTER_METHOD(lldb::SBTypeFormat, SBTypeCategory, GetFormatAtIndex,
  715   LLDB_REGISTER_METHOD(bool, SBTypeCategory, AddTypeFormat,
  717   LLDB_REGISTER_METHOD(bool, SBTypeCategory, DeleteTypeFormat,
  719   LLDB_REGISTER_METHOD(bool, SBTypeCategory, DeleteTypeSummary,
  721   LLDB_REGISTER_METHOD(bool, SBTypeCategory, AddTypeFilter,
  723   LLDB_REGISTER_METHOD(bool, SBTypeCategory, DeleteTypeFilter,
  725   LLDB_REGISTER_METHOD(bool, SBTypeCategory, GetDescription,
  727   LLDB_REGISTER_METHOD(
  730   LLDB_REGISTER_METHOD(bool,
  732   LLDB_REGISTER_METHOD(bool,

tools/lldb/source/API/SBTypeEnumMember.cpp

  205   LLDB_REGISTER_CONSTRUCTOR(SBTypeEnumMember, ());
  206   LLDB_REGISTER_CONSTRUCTOR(SBTypeEnumMember,
  208   LLDB_REGISTER_METHOD(
  211   LLDB_REGISTER_METHOD_CONST(bool, SBTypeEnumMember, IsValid, ());
  212   LLDB_REGISTER_METHOD_CONST(bool, SBTypeEnumMember, operator bool, ());
  213   LLDB_REGISTER_METHOD(const char *, SBTypeEnumMember, GetName, ());
  214   LLDB_REGISTER_METHOD(int64_t, SBTypeEnumMember, GetValueAsSigned, ());
  215   LLDB_REGISTER_METHOD(uint64_t, SBTypeEnumMember, GetValueAsUnsigned, ());
  216   LLDB_REGISTER_METHOD(lldb::SBType, SBTypeEnumMember, GetType, ());
  217   LLDB_REGISTER_CONSTRUCTOR(SBTypeEnumMemberList, ());
  218   LLDB_REGISTER_CONSTRUCTOR(SBTypeEnumMemberList,
  220   LLDB_REGISTER_METHOD(bool, SBTypeEnumMemberList, IsValid, ());
  221   LLDB_REGISTER_METHOD_CONST(bool, SBTypeEnumMemberList, operator bool, ());
  222   LLDB_REGISTER_METHOD(
  225   LLDB_REGISTER_METHOD(void, SBTypeEnumMemberList, Append,
  227   LLDB_REGISTER_METHOD(lldb::SBTypeEnumMember, SBTypeEnumMemberList,
  229   LLDB_REGISTER_METHOD(uint32_t, SBTypeEnumMemberList, GetSize, ());
  230   LLDB_REGISTER_METHOD(bool, SBTypeEnumMember, GetDescription,

tools/lldb/source/API/SBTypeFilter.cpp

  200   LLDB_REGISTER_CONSTRUCTOR(SBTypeFilter, ());
  201   LLDB_REGISTER_CONSTRUCTOR(SBTypeFilter, (uint32_t));
  202   LLDB_REGISTER_CONSTRUCTOR(SBTypeFilter, (const lldb::SBTypeFilter &));
  203   LLDB_REGISTER_METHOD_CONST(bool, SBTypeFilter, IsValid, ());
  204   LLDB_REGISTER_METHOD_CONST(bool, SBTypeFilter, operator bool, ());
  205   LLDB_REGISTER_METHOD(uint32_t, SBTypeFilter, GetOptions, ());
  206   LLDB_REGISTER_METHOD(void, SBTypeFilter, SetOptions, (uint32_t));
  207   LLDB_REGISTER_METHOD(bool, SBTypeFilter, GetDescription,
  209   LLDB_REGISTER_METHOD(void, SBTypeFilter, Clear, ());
  210   LLDB_REGISTER_METHOD(uint32_t, SBTypeFilter, GetNumberOfExpressionPaths,
  212   LLDB_REGISTER_METHOD(const char *, SBTypeFilter, GetExpressionPathAtIndex,
  214   LLDB_REGISTER_METHOD(bool, SBTypeFilter, ReplaceExpressionPathAtIndex,
  216   LLDB_REGISTER_METHOD(void, SBTypeFilter, AppendExpressionPath,
  218   LLDB_REGISTER_METHOD(lldb::SBTypeFilter &,
  220   LLDB_REGISTER_METHOD(bool, SBTypeFilter, operator==,(lldb::SBTypeFilter &));
  221   LLDB_REGISTER_METHOD(bool, SBTypeFilter, IsEqualTo, (lldb::SBTypeFilter &));
  222   LLDB_REGISTER_METHOD(bool, SBTypeFilter, operator!=,(lldb::SBTypeFilter &));

tools/lldb/source/API/SBTypeFormat.cpp

  201   LLDB_REGISTER_CONSTRUCTOR(SBTypeFormat, ());
  202   LLDB_REGISTER_CONSTRUCTOR(SBTypeFormat, (lldb::Format, uint32_t));
  203   LLDB_REGISTER_CONSTRUCTOR(SBTypeFormat, (const char *, uint32_t));
  204   LLDB_REGISTER_CONSTRUCTOR(SBTypeFormat, (const lldb::SBTypeFormat &));
  205   LLDB_REGISTER_METHOD_CONST(bool, SBTypeFormat, IsValid, ());
  206   LLDB_REGISTER_METHOD_CONST(bool, SBTypeFormat, operator bool, ());
  207   LLDB_REGISTER_METHOD(lldb::Format, SBTypeFormat, GetFormat, ());
  208   LLDB_REGISTER_METHOD(const char *, SBTypeFormat, GetTypeName, ());
  209   LLDB_REGISTER_METHOD(uint32_t, SBTypeFormat, GetOptions, ());
  210   LLDB_REGISTER_METHOD(void, SBTypeFormat, SetFormat, (lldb::Format));
  211   LLDB_REGISTER_METHOD(void, SBTypeFormat, SetTypeName, (const char *));
  212   LLDB_REGISTER_METHOD(void, SBTypeFormat, SetOptions, (uint32_t));
  213   LLDB_REGISTER_METHOD(bool, SBTypeFormat, GetDescription,
  215   LLDB_REGISTER_METHOD(lldb::SBTypeFormat &,
  217   LLDB_REGISTER_METHOD(bool, SBTypeFormat, operator==,(lldb::SBTypeFormat &));
  218   LLDB_REGISTER_METHOD(bool, SBTypeFormat, IsEqualTo, (lldb::SBTypeFormat &));
  219   LLDB_REGISTER_METHOD(bool, SBTypeFormat, operator!=,(lldb::SBTypeFormat &));

tools/lldb/source/API/SBTypeNameSpecifier.cpp

  165   LLDB_REGISTER_CONSTRUCTOR(SBTypeNameSpecifier, ());
  166   LLDB_REGISTER_CONSTRUCTOR(SBTypeNameSpecifier, (const char *, bool));
  167   LLDB_REGISTER_CONSTRUCTOR(SBTypeNameSpecifier, (lldb::SBType));
  168   LLDB_REGISTER_CONSTRUCTOR(SBTypeNameSpecifier,
  170   LLDB_REGISTER_METHOD_CONST(bool, SBTypeNameSpecifier, IsValid, ());
  171   LLDB_REGISTER_METHOD_CONST(bool, SBTypeNameSpecifier, operator bool, ());
  172   LLDB_REGISTER_METHOD(const char *, SBTypeNameSpecifier, GetName, ());
  173   LLDB_REGISTER_METHOD(lldb::SBType, SBTypeNameSpecifier, GetType, ());
  174   LLDB_REGISTER_METHOD(bool, SBTypeNameSpecifier, IsRegex, ());
  175   LLDB_REGISTER_METHOD(bool, SBTypeNameSpecifier, GetDescription,
  177   LLDB_REGISTER_METHOD(
  180   LLDB_REGISTER_METHOD(
  182   LLDB_REGISTER_METHOD(bool, SBTypeNameSpecifier, IsEqualTo,
  184   LLDB_REGISTER_METHOD(

tools/lldb/source/API/SBTypeSummary.cpp

  482   LLDB_REGISTER_CONSTRUCTOR(SBTypeSummaryOptions, ());
  483   LLDB_REGISTER_CONSTRUCTOR(SBTypeSummaryOptions,
  485   LLDB_REGISTER_METHOD(bool, SBTypeSummaryOptions, IsValid, ());
  486   LLDB_REGISTER_METHOD_CONST(bool, SBTypeSummaryOptions, operator bool, ());
  487   LLDB_REGISTER_METHOD(lldb::LanguageType, SBTypeSummaryOptions, GetLanguage,
  489   LLDB_REGISTER_METHOD(lldb::TypeSummaryCapping, SBTypeSummaryOptions,
  491   LLDB_REGISTER_METHOD(void, SBTypeSummaryOptions, SetLanguage,
  493   LLDB_REGISTER_METHOD(void, SBTypeSummaryOptions, SetCapping,
  495   LLDB_REGISTER_CONSTRUCTOR(SBTypeSummaryOptions,
  501   LLDB_REGISTER_CONSTRUCTOR(SBTypeSummary, ());
  502   LLDB_REGISTER_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary,
  505   LLDB_REGISTER_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary,
  508   LLDB_REGISTER_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary,
  510   LLDB_REGISTER_CONSTRUCTOR(SBTypeSummary, (const lldb::SBTypeSummary &));
  511   LLDB_REGISTER_METHOD_CONST(bool, SBTypeSummary, IsValid, ());
  512   LLDB_REGISTER_METHOD_CONST(bool, SBTypeSummary, operator bool, ());
  513   LLDB_REGISTER_METHOD(bool, SBTypeSummary, IsFunctionCode, ());
  514   LLDB_REGISTER_METHOD(bool, SBTypeSummary, IsFunctionName, ());
  515   LLDB_REGISTER_METHOD(bool, SBTypeSummary, IsSummaryString, ());
  516   LLDB_REGISTER_METHOD(const char *, SBTypeSummary, GetData, ());
  517   LLDB_REGISTER_METHOD(uint32_t, SBTypeSummary, GetOptions, ());
  518   LLDB_REGISTER_METHOD(void, SBTypeSummary, SetOptions, (uint32_t));
  519   LLDB_REGISTER_METHOD(void, SBTypeSummary, SetSummaryString, (const char *));
  520   LLDB_REGISTER_METHOD(void, SBTypeSummary, SetFunctionName, (const char *));
  521   LLDB_REGISTER_METHOD(void, SBTypeSummary, SetFunctionCode, (const char *));
  522   LLDB_REGISTER_METHOD(bool, SBTypeSummary, GetDescription,
  524   LLDB_REGISTER_METHOD(bool, SBTypeSummary, DoesPrintValue, (lldb::SBValue));
  525   LLDB_REGISTER_METHOD(
  528   LLDB_REGISTER_METHOD(bool,
  530   LLDB_REGISTER_METHOD(bool, SBTypeSummary, IsEqualTo,
  532   LLDB_REGISTER_METHOD(bool,

tools/lldb/source/API/SBTypeSynthetic.cpp

  219   LLDB_REGISTER_CONSTRUCTOR(SBTypeSynthetic, ());
  220   LLDB_REGISTER_STATIC_METHOD(lldb::SBTypeSynthetic, SBTypeSynthetic,
  222   LLDB_REGISTER_STATIC_METHOD(lldb::SBTypeSynthetic, SBTypeSynthetic,
  224   LLDB_REGISTER_CONSTRUCTOR(SBTypeSynthetic, (const lldb::SBTypeSynthetic &));
  225   LLDB_REGISTER_METHOD_CONST(bool, SBTypeSynthetic, IsValid, ());
  226   LLDB_REGISTER_METHOD_CONST(bool, SBTypeSynthetic, operator bool, ());
  227   LLDB_REGISTER_METHOD(bool, SBTypeSynthetic, IsClassCode, ());
  228   LLDB_REGISTER_METHOD(bool, SBTypeSynthetic, IsClassName, ());
  229   LLDB_REGISTER_METHOD(const char *, SBTypeSynthetic, GetData, ());
  230   LLDB_REGISTER_METHOD(void, SBTypeSynthetic, SetClassName, (const char *));
  231   LLDB_REGISTER_METHOD(void, SBTypeSynthetic, SetClassCode, (const char *));
  232   LLDB_REGISTER_METHOD(uint32_t, SBTypeSynthetic, GetOptions, ());
  233   LLDB_REGISTER_METHOD(void, SBTypeSynthetic, SetOptions, (uint32_t));
  234   LLDB_REGISTER_METHOD(bool, SBTypeSynthetic, GetDescription,
  236   LLDB_REGISTER_METHOD(
  239   LLDB_REGISTER_METHOD(bool,
  241   LLDB_REGISTER_METHOD(bool, SBTypeSynthetic, IsEqualTo,
  243   LLDB_REGISTER_METHOD(bool,

tools/lldb/source/API/SBUnixSignals.cpp

  180   LLDB_REGISTER_CONSTRUCTOR(SBUnixSignals, ());
  181   LLDB_REGISTER_CONSTRUCTOR(SBUnixSignals, (const lldb::SBUnixSignals &));
  182   LLDB_REGISTER_METHOD(
  185   LLDB_REGISTER_METHOD(void, SBUnixSignals, Clear, ());
  186   LLDB_REGISTER_METHOD_CONST(bool, SBUnixSignals, IsValid, ());
  187   LLDB_REGISTER_METHOD_CONST(bool, SBUnixSignals, operator bool, ());
  188   LLDB_REGISTER_METHOD_CONST(const char *, SBUnixSignals, GetSignalAsCString,
  190   LLDB_REGISTER_METHOD_CONST(int32_t, SBUnixSignals, GetSignalNumberFromName,
  192   LLDB_REGISTER_METHOD_CONST(bool, SBUnixSignals, GetShouldSuppress,
  194   LLDB_REGISTER_METHOD(bool, SBUnixSignals, SetShouldSuppress,
  196   LLDB_REGISTER_METHOD_CONST(bool, SBUnixSignals, GetShouldStop, (int32_t));
  197   LLDB_REGISTER_METHOD(bool, SBUnixSignals, SetShouldStop, (int32_t, bool));
  198   LLDB_REGISTER_METHOD_CONST(bool, SBUnixSignals, GetShouldNotify, (int32_t));
  199   LLDB_REGISTER_METHOD(bool, SBUnixSignals, SetShouldNotify, (int32_t, bool));
  200   LLDB_REGISTER_METHOD_CONST(int32_t, SBUnixSignals, GetNumSignals, ());
  201   LLDB_REGISTER_METHOD_CONST(int32_t, SBUnixSignals, GetSignalAtIndex,

tools/lldb/source/API/SBValue.cpp

 1570   LLDB_REGISTER_CONSTRUCTOR(SBValue, ());
 1571   LLDB_REGISTER_CONSTRUCTOR(SBValue, (const lldb::ValueObjectSP &));
 1572   LLDB_REGISTER_CONSTRUCTOR(SBValue, (const lldb::SBValue &));
 1573   LLDB_REGISTER_METHOD(lldb::SBValue &,
 1575   LLDB_REGISTER_METHOD(bool, SBValue, IsValid, ());
 1576   LLDB_REGISTER_METHOD_CONST(bool, SBValue, operator bool, ());
 1577   LLDB_REGISTER_METHOD(void, SBValue, Clear, ());
 1578   LLDB_REGISTER_METHOD(lldb::SBError, SBValue, GetError, ());
 1579   LLDB_REGISTER_METHOD(lldb::user_id_t, SBValue, GetID, ());
 1580   LLDB_REGISTER_METHOD(const char *, SBValue, GetName, ());
 1581   LLDB_REGISTER_METHOD(const char *, SBValue, GetTypeName, ());
 1582   LLDB_REGISTER_METHOD(const char *, SBValue, GetDisplayTypeName, ());
 1583   LLDB_REGISTER_METHOD(size_t, SBValue, GetByteSize, ());
 1584   LLDB_REGISTER_METHOD(bool, SBValue, IsInScope, ());
 1585   LLDB_REGISTER_METHOD(const char *, SBValue, GetValue, ());
 1586   LLDB_REGISTER_METHOD(lldb::ValueType, SBValue, GetValueType, ());
 1587   LLDB_REGISTER_METHOD(const char *, SBValue, GetObjectDescription, ());
 1588   LLDB_REGISTER_METHOD(const char *, SBValue, GetTypeValidatorResult, ());
 1589   LLDB_REGISTER_METHOD(lldb::SBType, SBValue, GetType, ());
 1590   LLDB_REGISTER_METHOD(bool, SBValue, GetValueDidChange, ());
 1591   LLDB_REGISTER_METHOD(const char *, SBValue, GetSummary, ());
 1592   LLDB_REGISTER_METHOD(const char *, SBValue, GetSummary,
 1594   LLDB_REGISTER_METHOD(const char *, SBValue, GetLocation, ());
 1595   LLDB_REGISTER_METHOD(bool, SBValue, SetValueFromCString, (const char *));
 1596   LLDB_REGISTER_METHOD(bool, SBValue, SetValueFromCString,
 1598   LLDB_REGISTER_METHOD(lldb::SBTypeFormat, SBValue, GetTypeFormat, ());
 1599   LLDB_REGISTER_METHOD(lldb::SBTypeSummary, SBValue, GetTypeSummary, ());
 1600   LLDB_REGISTER_METHOD(lldb::SBTypeFilter, SBValue, GetTypeFilter, ());
 1601   LLDB_REGISTER_METHOD(lldb::SBTypeSynthetic, SBValue, GetTypeSynthetic, ());
 1602   LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, CreateChildAtOffset,
 1604   LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, Cast, (lldb::SBType));
 1605   LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, CreateValueFromExpression,
 1607   LLDB_REGISTER_METHOD(
 1610   LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, CreateValueFromAddress,
 1612   LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, CreateValueFromData,
 1614   LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetChildAtIndex, (uint32_t));
 1615   LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetChildAtIndex,
 1617   LLDB_REGISTER_METHOD(uint32_t, SBValue, GetIndexOfChildWithName,
 1619   LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetChildMemberWithName,
 1621   LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetChildMemberWithName,
 1623   LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetDynamicValue,
 1625   LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetStaticValue, ());
 1626   LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetNonSyntheticValue, ());
 1627   LLDB_REGISTER_METHOD(lldb::DynamicValueType, SBValue, GetPreferDynamicValue,
 1629   LLDB_REGISTER_METHOD(void, SBValue, SetPreferDynamicValue,
 1631   LLDB_REGISTER_METHOD(bool, SBValue, GetPreferSyntheticValue, ());
 1632   LLDB_REGISTER_METHOD(void, SBValue, SetPreferSyntheticValue, (bool));
 1633   LLDB_REGISTER_METHOD(bool, SBValue, IsDynamic, ());
 1634   LLDB_REGISTER_METHOD(bool, SBValue, IsSynthetic, ());
 1635   LLDB_REGISTER_METHOD(bool, SBValue, IsSyntheticChildrenGenerated, ());
 1636   LLDB_REGISTER_METHOD(void, SBValue, SetSyntheticChildrenGenerated, (bool));
 1637   LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetValueForExpressionPath,
 1639   LLDB_REGISTER_METHOD(int64_t, SBValue, GetValueAsSigned,
 1641   LLDB_REGISTER_METHOD(uint64_t, SBValue, GetValueAsUnsigned,
 1643   LLDB_REGISTER_METHOD(int64_t, SBValue, GetValueAsSigned, (int64_t));
 1644   LLDB_REGISTER_METHOD(uint64_t, SBValue, GetValueAsUnsigned, (uint64_t));
 1645   LLDB_REGISTER_METHOD(bool, SBValue, MightHaveChildren, ());
 1646   LLDB_REGISTER_METHOD(bool, SBValue, IsRuntimeSupportValue, ());
 1647   LLDB_REGISTER_METHOD(uint32_t, SBValue, GetNumChildren, ());
 1648   LLDB_REGISTER_METHOD(uint32_t, SBValue, GetNumChildren, (uint32_t));
 1649   LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, Dereference, ());
 1650   LLDB_REGISTER_METHOD(bool, SBValue, TypeIsPointerType, ());
 1651   LLDB_REGISTER_METHOD(void *, SBValue, GetOpaqueType, ());
 1652   LLDB_REGISTER_METHOD(lldb::SBTarget, SBValue, GetTarget, ());
 1653   LLDB_REGISTER_METHOD(lldb::SBProcess, SBValue, GetProcess, ());
 1654   LLDB_REGISTER_METHOD(lldb::SBThread, SBValue, GetThread, ());
 1655   LLDB_REGISTER_METHOD(lldb::SBFrame, SBValue, GetFrame, ());
 1656   LLDB_REGISTER_METHOD_CONST(lldb::ValueObjectSP, SBValue, GetSP, ());
 1657   LLDB_REGISTER_METHOD(bool, SBValue, GetExpressionPath, (lldb::SBStream &));
 1658   LLDB_REGISTER_METHOD(bool, SBValue, GetExpressionPath,
 1660   LLDB_REGISTER_METHOD_CONST(lldb::SBValue, SBValue, EvaluateExpression,
 1662   LLDB_REGISTER_METHOD_CONST(
 1665   LLDB_REGISTER_METHOD_CONST(
 1668   LLDB_REGISTER_METHOD(bool, SBValue, GetDescription, (lldb::SBStream &));
 1669   LLDB_REGISTER_METHOD(lldb::Format, SBValue, GetFormat, ());
 1670   LLDB_REGISTER_METHOD(void, SBValue, SetFormat, (lldb::Format));
 1671   LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, AddressOf, ());
 1672   LLDB_REGISTER_METHOD(lldb::addr_t, SBValue, GetLoadAddress, ());
 1673   LLDB_REGISTER_METHOD(lldb::SBAddress, SBValue, GetAddress, ());
 1674   LLDB_REGISTER_METHOD(lldb::SBData, SBValue, GetPointeeData,
 1676   LLDB_REGISTER_METHOD(lldb::SBData, SBValue, GetData, ());
 1677   LLDB_REGISTER_METHOD(bool, SBValue, SetData,
 1679   LLDB_REGISTER_METHOD(lldb::SBDeclaration, SBValue, GetDeclaration, ());
 1680   LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBValue, Watch,
 1682   LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBValue, Watch,
 1684   LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBValue, WatchPointee,
 1686   LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, Persist, ());

tools/lldb/source/API/SBValueList.cpp

  211   LLDB_REGISTER_CONSTRUCTOR(SBValueList, ());
  212   LLDB_REGISTER_CONSTRUCTOR(SBValueList, (const lldb::SBValueList &));
  213   LLDB_REGISTER_METHOD_CONST(bool, SBValueList, IsValid, ());
  214   LLDB_REGISTER_METHOD_CONST(bool, SBValueList, operator bool, ());
  215   LLDB_REGISTER_METHOD(void, SBValueList, Clear, ());
  216   LLDB_REGISTER_METHOD(const lldb::SBValueList &,
  218   LLDB_REGISTER_METHOD(void, SBValueList, Append, (const lldb::SBValue &));
  219   LLDB_REGISTER_METHOD(void, SBValueList, Append,
  221   LLDB_REGISTER_METHOD_CONST(lldb::SBValue, SBValueList, GetValueAtIndex,
  223   LLDB_REGISTER_METHOD_CONST(uint32_t, SBValueList, GetSize, ());
  224   LLDB_REGISTER_METHOD(lldb::SBValue, SBValueList, FindValueObjectByUID,
  226   LLDB_REGISTER_METHOD_CONST(lldb::SBValue, SBValueList, GetFirstValueByName,

tools/lldb/source/API/SBVariablesOptions.cpp

  243   LLDB_REGISTER_CONSTRUCTOR(SBVariablesOptions, ());
  244   LLDB_REGISTER_CONSTRUCTOR(SBVariablesOptions,
  246   LLDB_REGISTER_METHOD(
  249   LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, IsValid, ());
  250   LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, operator bool, ());
  251   LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, GetIncludeArguments,
  253   LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetIncludeArguments, (bool));
  254   LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions,
  257   LLDB_REGISTER_METHOD(void, SBVariablesOptions,
  259   LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, GetIncludeLocals, ());
  260   LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetIncludeLocals, (bool));
  261   LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, GetIncludeStatics, ());
  262   LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetIncludeStatics, (bool));
  263   LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, GetInScopeOnly, ());
  264   LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetInScopeOnly, (bool));
  265   LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions,
  267   LLDB_REGISTER_METHOD(void, SBVariablesOptions,
  269   LLDB_REGISTER_METHOD_CONST(lldb::DynamicValueType, SBVariablesOptions,
  271   LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetUseDynamic,

tools/lldb/source/API/SBWatchpoint.cpp

  312   LLDB_REGISTER_CONSTRUCTOR(SBWatchpoint, ());
  313   LLDB_REGISTER_CONSTRUCTOR(SBWatchpoint, (const lldb::WatchpointSP &));
  314   LLDB_REGISTER_CONSTRUCTOR(SBWatchpoint, (const lldb::SBWatchpoint &));
  315   LLDB_REGISTER_METHOD(const lldb::SBWatchpoint &,
  317   LLDB_REGISTER_METHOD(lldb::watch_id_t, SBWatchpoint, GetID, ());
  318   LLDB_REGISTER_METHOD_CONST(bool, SBWatchpoint, IsValid, ());
  319   LLDB_REGISTER_METHOD_CONST(bool, SBWatchpoint, operator bool, ());
  320   LLDB_REGISTER_METHOD_CONST(
  322   LLDB_REGISTER_METHOD_CONST(
  324   LLDB_REGISTER_METHOD(lldb::SBError, SBWatchpoint, GetError, ());
  325   LLDB_REGISTER_METHOD(int32_t, SBWatchpoint, GetHardwareIndex, ());
  326   LLDB_REGISTER_METHOD(lldb::addr_t, SBWatchpoint, GetWatchAddress, ());
  327   LLDB_REGISTER_METHOD(size_t, SBWatchpoint, GetWatchSize, ());
  328   LLDB_REGISTER_METHOD(void, SBWatchpoint, SetEnabled, (bool));
  329   LLDB_REGISTER_METHOD(bool, SBWatchpoint, IsEnabled, ());
  330   LLDB_REGISTER_METHOD(uint32_t, SBWatchpoint, GetHitCount, ());
  331   LLDB_REGISTER_METHOD(uint32_t, SBWatchpoint, GetIgnoreCount, ());
  332   LLDB_REGISTER_METHOD(void, SBWatchpoint, SetIgnoreCount, (uint32_t));
  333   LLDB_REGISTER_METHOD(const char *, SBWatchpoint, GetCondition, ());
  334   LLDB_REGISTER_METHOD(void, SBWatchpoint, SetCondition, (const char *));
  335   LLDB_REGISTER_METHOD(bool, SBWatchpoint, GetDescription,
  337   LLDB_REGISTER_METHOD(void, SBWatchpoint, Clear, ());
  338   LLDB_REGISTER_METHOD_CONST(lldb::WatchpointSP, SBWatchpoint, GetSP, ());
  339   LLDB_REGISTER_METHOD(void, SBWatchpoint, SetSP,
  341   LLDB_REGISTER_STATIC_METHOD(bool, SBWatchpoint, EventIsWatchpointEvent,
  343   LLDB_REGISTER_STATIC_METHOD(lldb::WatchpointEventType, SBWatchpoint,
  346   LLDB_REGISTER_STATIC_METHOD(lldb::SBWatchpoint, SBWatchpoint,

tools/lldb/unittests/Utility/ReproducerInstrumentationTest.cpp

  247   LLDB_REGISTER_CONSTRUCTOR(InstrumentedFoo, (int i));
  248   LLDB_REGISTER_CONSTRUCTOR(InstrumentedFoo, (const InstrumentedFoo &));
  249   LLDB_REGISTER_METHOD(InstrumentedFoo &,
  251   LLDB_REGISTER_METHOD(void, InstrumentedFoo, A, (int));
  252   LLDB_REGISTER_METHOD_CONST(void, InstrumentedFoo, B, (int &));
  253   LLDB_REGISTER_METHOD(int, InstrumentedFoo, C, (float *));
  254   LLDB_REGISTER_METHOD_CONST(int, InstrumentedFoo, D, (const char *));
  255   LLDB_REGISTER_STATIC_METHOD(void, InstrumentedFoo, E, (double));
  256   LLDB_REGISTER_STATIC_METHOD(int, InstrumentedFoo, F, ());
  257   LLDB_REGISTER_METHOD(void, InstrumentedFoo, Validate, ());
  259   LLDB_REGISTER_CONSTRUCTOR(InstrumentedBar, ());
  260   LLDB_REGISTER_METHOD(InstrumentedFoo, InstrumentedBar, GetInstrumentedFoo,
  262   LLDB_REGISTER_METHOD(InstrumentedFoo &, InstrumentedBar,
  264   LLDB_REGISTER_METHOD(InstrumentedFoo *, InstrumentedBar,
  266   LLDB_REGISTER_METHOD(void, InstrumentedBar, SetInstrumentedFoo,
  268   LLDB_REGISTER_METHOD(void, InstrumentedBar, SetInstrumentedFoo,
  270   LLDB_REGISTER_METHOD(void, InstrumentedBar, Validate, ());