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

References

tools/lldb/source/API/SBAddress.cpp

   58   LLDB_RECORD_METHOD(const lldb::SBAddress &,
   96   LLDB_RECORD_METHOD(void, SBAddress, SetAddress,
  137   LLDB_RECORD_METHOD(void, SBAddress, SetLoadAddress,
  155   LLDB_RECORD_METHOD(bool, SBAddress, OffsetAddress, (lldb::addr_t), offset);
  204   LLDB_RECORD_METHOD(bool, SBAddress, GetDescription, (lldb::SBStream &),
  229   LLDB_RECORD_METHOD(lldb::SBSymbolContext, SBAddress, GetSymbolContext,

tools/lldb/source/API/SBAttachInfo.cpp

   62   LLDB_RECORD_METHOD(lldb::SBAttachInfo &,
   77   LLDB_RECORD_METHOD(void, SBAttachInfo, SetProcessID, (lldb::pid_t), pid);
   89   LLDB_RECORD_METHOD(void, SBAttachInfo, SetResumeCount, (uint32_t), c);
  101   LLDB_RECORD_METHOD(void, SBAttachInfo, SetProcessPluginName, (const char *),
  108   LLDB_RECORD_METHOD(void, SBAttachInfo, SetExecutable, (const char *), path);
  117   LLDB_RECORD_METHOD(void, SBAttachInfo, SetExecutable, (lldb::SBFileSpec),
  133   LLDB_RECORD_METHOD(void, SBAttachInfo, SetWaitForLaunch, (bool), b);
  139   LLDB_RECORD_METHOD(void, SBAttachInfo, SetWaitForLaunch, (bool, bool), b,
  153   LLDB_RECORD_METHOD(void, SBAttachInfo, SetIgnoreExisting, (bool), b);
  183   LLDB_RECORD_METHOD(void, SBAttachInfo, SetUserID, (uint32_t), uid);
  189   LLDB_RECORD_METHOD(void, SBAttachInfo, SetGroupID, (uint32_t), gid);
  219   LLDB_RECORD_METHOD(void, SBAttachInfo, SetEffectiveUserID, (uint32_t), uid);
  225   LLDB_RECORD_METHOD(void, SBAttachInfo, SetEffectiveGroupID, (uint32_t), gid);
  237   LLDB_RECORD_METHOD(void, SBAttachInfo, SetParentProcessID, (lldb::pid_t),
  256   LLDB_RECORD_METHOD(void, SBAttachInfo, SetListener, (lldb::SBListener &),

tools/lldb/source/API/SBBlock.cpp

   40   LLDB_RECORD_METHOD(const lldb::SBBlock &,
  174   LLDB_RECORD_METHOD(bool, SBBlock, GetDescription, (lldb::SBStream &),
  207   LLDB_RECORD_METHOD(lldb::SBAddress, SBBlock, GetRangeStartAddress, (uint32_t),
  221   LLDB_RECORD_METHOD(lldb::SBAddress, SBBlock, GetRangeEndAddress, (uint32_t),
  236   LLDB_RECORD_METHOD(uint32_t, SBBlock, GetRangeIndexForBlockAddress,
  249   LLDB_RECORD_METHOD(
  305   LLDB_RECORD_METHOD(lldb::SBValueList, SBBlock, GetVariables,

tools/lldb/source/API/SBBreakpoint.cpp

   63   LLDB_RECORD_METHOD(const lldb::SBBreakpoint &,
   71   LLDB_RECORD_METHOD(
   78   LLDB_RECORD_METHOD(
  123   LLDB_RECORD_METHOD(lldb::SBBreakpointLocation, SBBreakpoint,
  145   LLDB_RECORD_METHOD(lldb::break_id_t, SBBreakpoint, FindLocationIDByAddress,
  166   LLDB_RECORD_METHOD(lldb::SBBreakpointLocation, SBBreakpoint, FindLocationByID,
  182   LLDB_RECORD_METHOD(lldb::SBBreakpointLocation, SBBreakpoint,
  198   LLDB_RECORD_METHOD(void, SBBreakpoint, SetEnabled, (bool), enable);
  222   LLDB_RECORD_METHOD(void, SBBreakpoint, SetOneShot, (bool), one_shot);
  258   LLDB_RECORD_METHOD(void, SBBreakpoint, SetIgnoreCount, (uint32_t), count);
  270   LLDB_RECORD_METHOD(void, SBBreakpoint, SetCondition, (const char *),
  294   LLDB_RECORD_METHOD(void, SBBreakpoint, SetAutoContinue, (bool),
  346   LLDB_RECORD_METHOD(void, SBBreakpoint, SetThreadID, (lldb::tid_t), tid);
  371   LLDB_RECORD_METHOD(void, SBBreakpoint, SetThreadIndex, (uint32_t), index);
  399   LLDB_RECORD_METHOD(void, SBBreakpoint, SetThreadName, (const char *),
  429   LLDB_RECORD_METHOD(void, SBBreakpoint, SetQueueName, (const char *),
  485   LLDB_RECORD_METHOD(void, SBBreakpoint, SetCommandLineCommands,
  503   LLDB_RECORD_METHOD(bool, SBBreakpoint, GetCommandLineCommands,
  518   LLDB_RECORD_METHOD(bool, SBBreakpoint, GetDescription, (lldb::SBStream &), s);
  524   LLDB_RECORD_METHOD(bool, SBBreakpoint, GetDescription,
  545   LLDB_RECORD_METHOD(lldb::SBError, SBBreakpoint, AddLocation,
  596 LLDB_RECORD_METHOD(void, SBBreakpoint, SetScriptCallbackFunction,
  605   LLDB_RECORD_METHOD(SBError, SBBreakpoint, SetScriptCallbackFunction,
  630   LLDB_RECORD_METHOD(lldb::SBError, SBBreakpoint, SetScriptCallbackBody,
  653   LLDB_RECORD_METHOD(bool, SBBreakpoint, AddName, (const char *), new_name);
  671   LLDB_RECORD_METHOD(void, SBBreakpoint, RemoveName, (const char *),
  685   LLDB_RECORD_METHOD(bool, SBBreakpoint, MatchesName, (const char *), name);
  699   LLDB_RECORD_METHOD(void, SBBreakpoint, GetNames, (lldb::SBStringList &),
  888   LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBBreakpointList, GetBreakpointAtIndex,
  899   LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBBreakpointList, FindBreakpointByID,
  909   LLDB_RECORD_METHOD(void, SBBreakpointList, Append,
  920   LLDB_RECORD_METHOD(void, SBBreakpointList, AppendByID, (lldb::break_id_t),
  929   LLDB_RECORD_METHOD(bool, SBBreakpointList, AppendIfUnique,

tools/lldb/source/API/SBBreakpointLocation.cpp

   53   LLDB_RECORD_METHOD(
  106   LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetEnabled, (bool), enabled);
  153   LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetIgnoreCount, (uint32_t), n);
  164   LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetCondition, (const char *),
  188   LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetAutoContinue, (bool),
  213 LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetScriptCallbackFunction,
  220   LLDB_RECORD_METHOD(SBError, SBBreakpointLocation, SetScriptCallbackFunction,
  248   LLDB_RECORD_METHOD(lldb::SBError, SBBreakpointLocation, SetScriptCallbackBody,
  272   LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetCommandLineCommands,
  290   LLDB_RECORD_METHOD(bool, SBBreakpointLocation, GetCommandLineCommands,
  305   LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetThreadID, (lldb::tid_t),
  330   LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetThreadIndex, (uint32_t),
  356   LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetThreadName, (const char *),
  381   LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetQueueName, (const char *),
  425   LLDB_RECORD_METHOD(bool, SBBreakpointLocation, GetDescription,

tools/lldb/source/API/SBBreakpointName.cpp

  165   LLDB_RECORD_METHOD(
  180   LLDB_RECORD_METHOD(
  187   LLDB_RECORD_METHOD(
  214   LLDB_RECORD_METHOD(void, SBBreakpointName, SetEnabled, (bool), enable);
  251   LLDB_RECORD_METHOD(void, SBBreakpointName, SetOneShot, (bool), one_shot);
  278   LLDB_RECORD_METHOD(void, SBBreakpointName, SetIgnoreCount, (uint32_t), count);
  305   LLDB_RECORD_METHOD(void, SBBreakpointName, SetCondition, (const char *),
  333   LLDB_RECORD_METHOD(void, SBBreakpointName, SetAutoContinue, (bool),
  361   LLDB_RECORD_METHOD(void, SBBreakpointName, SetThreadID, (lldb::tid_t), tid);
  388   LLDB_RECORD_METHOD(void, SBBreakpointName, SetThreadIndex, (uint32_t), index);
  415   LLDB_RECORD_METHOD(void, SBBreakpointName, SetThreadName, (const char *),
  444   LLDB_RECORD_METHOD(void, SBBreakpointName, SetQueueName, (const char *),
  473   LLDB_RECORD_METHOD(void, SBBreakpointName, SetCommandLineCommands,
  493   LLDB_RECORD_METHOD(bool, SBBreakpointName, GetCommandLineCommands,
  520   LLDB_RECORD_METHOD(void, SBBreakpointName, SetHelpString, (const char *),
  534   LLDB_RECORD_METHOD(bool, SBBreakpointName, GetDescription, (lldb::SBStream &),
  571 LLDB_RECORD_METHOD(void, SBBreakpointName, SetScriptCallbackFunction,
  580   LLDB_RECORD_METHOD(SBError, SBBreakpointName, SetScriptCallbackFunction,
  609   LLDB_RECORD_METHOD(lldb::SBError, SBBreakpointName, SetScriptCallbackBody,
  643   LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowList, (bool), value);
  662   LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowDelete, (bool), value);
  681   LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowDisable, (bool), value);

tools/lldb/source/API/SBBroadcaster.cpp

   39   LLDB_RECORD_METHOD(const lldb::SBBroadcaster &,
   53   LLDB_RECORD_METHOD(void, SBBroadcaster, BroadcastEventByType,
   66   LLDB_RECORD_METHOD(void, SBBroadcaster, BroadcastEvent,
   81   LLDB_RECORD_METHOD(void, SBBroadcaster, AddInitialEventsToListener,
   92   LLDB_RECORD_METHOD(uint32_t, SBBroadcaster, AddListener,
  110   LLDB_RECORD_METHOD(bool, SBBroadcaster, EventTypeHasListeners, (uint32_t),
  120   LLDB_RECORD_METHOD(bool, SBBroadcaster, RemoveListener,

tools/lldb/source/API/SBCommandInterpreter.cpp

   50   LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnContinue,
   64   LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnError,
   78   LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnCrash,
   92   LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetEchoCommands,
  106   LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions,
  120   LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetPrintResults,
  134   LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetAddToHistory,
  192   LLDB_RECORD_METHOD(
  212   LLDB_RECORD_METHOD(bool, SBCommandInterpreter, CommandExists, (const char *),
  220   LLDB_RECORD_METHOD(bool, SBCommandInterpreter, AliasExists, (const char *),
  240   LLDB_RECORD_METHOD(const char *, SBCommandInterpreter,
  254   LLDB_RECORD_METHOD(lldb::ReturnStatus, SBCommandInterpreter, HandleCommand,
  265   LLDB_RECORD_METHOD(lldb::ReturnStatus, SBCommandInterpreter, HandleCommand,
  298   LLDB_RECORD_METHOD(void, SBCommandInterpreter, HandleCommandsFromFile,
  332   LLDB_RECORD_METHOD(int, SBCommandInterpreter, HandleCompletion,
  348   LLDB_RECORD_METHOD(int, SBCommandInterpreter,
  418   LLDB_RECORD_METHOD(int, SBCommandInterpreter,
  437   LLDB_RECORD_METHOD(int, SBCommandInterpreter, HandleCompletion,
  501   LLDB_RECORD_METHOD(void, SBCommandInterpreter, SetPromptOnQuit, (bool), b);
  508   LLDB_RECORD_METHOD(void, SBCommandInterpreter, AllowExitCodeOnQuit, (bool),
  533   LLDB_RECORD_METHOD(void, SBCommandInterpreter, ResolveCommand,
  561   LLDB_RECORD_METHOD(void, SBCommandInterpreter, SourceInitFileInHomeDirectory,
  579   LLDB_RECORD_METHOD(void, SBCommandInterpreter,
  664   LLDB_RECORD_METHOD(lldb::SBCommand, SBCommandInterpreter, AddMultiwordCommand,
  679   LLDB_RECORD_METHOD(
  698   LLDB_RECORD_METHOD(lldb::SBCommand, SBCommandInterpreter, AddCommand,
  748   LLDB_RECORD_METHOD(void, SBCommand, SetHelp, (const char *), help);
  755   LLDB_RECORD_METHOD(void, SBCommand, SetHelpLong, (const char *), help);
  763   LLDB_RECORD_METHOD(lldb::SBCommand, SBCommand, AddMultiwordCommand,
  782   LLDB_RECORD_METHOD(
  802   LLDB_RECORD_METHOD(lldb::SBCommand, SBCommand, AddCommand,
  826   LLDB_RECORD_METHOD(void, SBCommand, SetFlags, (uint32_t), flags);

tools/lldb/source/API/SBCommandReturnObject.cpp

   69   LLDB_RECORD_METHOD(
  129   LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutOutput, (FileSP),
  137   LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutOutput, (SBFile), file);
  154   LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutError, (FileSP),
  162   LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutError, (SBFile), file);
  182   LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetStatus,
  201   LLDB_RECORD_METHOD(void, SBCommandReturnObject, AppendMessage, (const char *),
  208   LLDB_RECORD_METHOD(void, SBCommandReturnObject, AppendWarning, (const char *),
  231   LLDB_RECORD_METHOD(bool, SBCommandReturnObject, GetDescription,
  287   LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
  293   LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
  299   LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
  305   LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
  311   LLDB_RECORD_METHOD(void, SBCommandReturnObject, PutCString,
  324   LLDB_RECORD_METHOD(const char *, SBCommandReturnObject, GetOutput, (bool),
  334   LLDB_RECORD_METHOD(const char *, SBCommandReturnObject, GetError, (bool),
  352   LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetError,
  363   LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetError, (const char *),

tools/lldb/source/API/SBCommunication.cpp

   54   LLDB_RECORD_METHOD(void, SBCommunication, SetCloseOnEOF, (bool), b);
   61   LLDB_RECORD_METHOD(lldb::ConnectionStatus, SBCommunication, Connect,
   73   LLDB_RECORD_METHOD(lldb::ConnectionStatus, SBCommunication,

tools/lldb/source/API/SBCompileUnit.cpp

   37   LLDB_RECORD_METHOD(const lldb::SBCompileUnit &,
  129   LLDB_RECORD_METHOD(lldb::SBTypeList, SBCompileUnit, GetTypes, (uint32_t),
  169   LLDB_RECORD_METHOD(uint32_t, SBCompileUnit, FindSupportFileIndex,
  227   LLDB_RECORD_METHOD(bool, SBCompileUnit, GetDescription, (lldb::SBStream &),

tools/lldb/source/API/SBData.cpp

   36   LLDB_RECORD_METHOD(const lldb::SBData &,
   80   LLDB_RECORD_METHOD(void, SBData, SetAddressByteSize, (uint8_t),
  113   LLDB_RECORD_METHOD(void, SBData, SetByteOrder, (lldb::ByteOrder), endian);
  120   LLDB_RECORD_METHOD(float, SBData, GetFloat, (lldb::SBError &, lldb::offset_t),
  136   LLDB_RECORD_METHOD(double, SBData, GetDouble,
  152   LLDB_RECORD_METHOD(long double, SBData, GetLongDouble,
  168   LLDB_RECORD_METHOD(lldb::addr_t, SBData, GetAddress,
  184   LLDB_RECORD_METHOD(uint8_t, SBData, GetUnsignedInt8,
  200   LLDB_RECORD_METHOD(uint16_t, SBData, GetUnsignedInt16,
  216   LLDB_RECORD_METHOD(uint32_t, SBData, GetUnsignedInt32,
  232   LLDB_RECORD_METHOD(uint64_t, SBData, GetUnsignedInt64,
  248   LLDB_RECORD_METHOD(int8_t, SBData, GetSignedInt8,
  264   LLDB_RECORD_METHOD(int16_t, SBData, GetSignedInt16,
  280   LLDB_RECORD_METHOD(int32_t, SBData, GetSignedInt32,
  296   LLDB_RECORD_METHOD(int64_t, SBData, GetSignedInt64,
  312   LLDB_RECORD_METHOD(const char *, SBData, GetString,
  329   LLDB_RECORD_METHOD(bool, SBData, GetDescription,
  378   LLDB_RECORD_METHOD(bool, SBData, Append, (const lldb::SBData &), rhs);
  518   LLDB_RECORD_METHOD(bool, SBData, SetDataFromCString, (const char *), data);
  540   LLDB_RECORD_METHOD(bool, SBData, SetDataFromUInt64Array, (uint64_t *, size_t),
  563   LLDB_RECORD_METHOD(bool, SBData, SetDataFromUInt32Array, (uint32_t *, size_t),
  585   LLDB_RECORD_METHOD(bool, SBData, SetDataFromSInt64Array, (int64_t *, size_t),
  607   LLDB_RECORD_METHOD(bool, SBData, SetDataFromSInt32Array, (int32_t *, size_t),
  629   LLDB_RECORD_METHOD(bool, SBData, SetDataFromDoubleArray, (double *, size_t),

tools/lldb/source/API/SBDebugger.cpp

  118   LLDB_RECORD_METHOD(void, SBInputReader, SetIsDone, (bool), b);
  141   LLDB_RECORD_METHOD(lldb::SBDebugger &,
  263   LLDB_RECORD_METHOD(void, SBDebugger, SetAsync, (bool), b);
  276   LLDB_RECORD_METHOD(void, SBDebugger, SkipLLDBInitFiles, (bool), b);
  283   LLDB_RECORD_METHOD(void, SBDebugger, SkipAppInitFiles, (bool), b);
  290   LLDB_RECORD_METHOD(void, SBDebugger, SetInputFileHandle, (FILE *, bool), fh,
  296   LLDB_RECORD_METHOD(SBError, SBDebugger, SetInputFile, (FileSP), file_sp);
  304   LLDB_RECORD_METHOD(SBError, SBDebugger, SetInputFile, (SBFile), file);
  341   LLDB_RECORD_METHOD(SBError, SBDebugger, SetOutputFile, (FileSP), file_sp);
  346   LLDB_RECORD_METHOD(void, SBDebugger, SetOutputFileHandle, (FILE *, bool), fh,
  352   LLDB_RECORD_METHOD(SBError, SBDebugger, SetOutputFile, (SBFile file), file);
  367   LLDB_RECORD_METHOD(void, SBDebugger, SetErrorFileHandle, (FILE *, bool), fh,
  373   LLDB_RECORD_METHOD(SBError, SBDebugger, SetErrorFile, (FileSP), file_sp);
  378   LLDB_RECORD_METHOD(SBError, SBDebugger, SetErrorFile, (SBFile file), file);
  472   LLDB_RECORD_METHOD(void, SBDebugger, HandleCommand, (const char *), command);
  517   LLDB_RECORD_METHOD(
  528   LLDB_RECORD_METHOD(
  542   LLDB_RECORD_METHOD(
  634   LLDB_RECORD_METHOD(lldb::ScriptLanguage, SBDebugger, GetScriptingLanguage,
  721   LLDB_RECORD_METHOD(
  759   LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger,
  786   LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, CreateTargetWithFileAndArch,
  818   LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, CreateTarget, (const char *),
  859   LLDB_RECORD_METHOD(bool, SBDebugger, DeleteTarget, (lldb::SBTarget &),
  884   LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, GetTargetAtIndex, (uint32_t),
  896   LLDB_RECORD_METHOD(uint32_t, SBDebugger, GetIndexOfTarget, (lldb::SBTarget),
  910   LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithProcessID,
  923   LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithFileAndArch,
  984   LLDB_RECORD_METHOD(void, SBDebugger, SetSelectedTarget, (lldb::SBTarget &),
 1020   LLDB_RECORD_METHOD(void, SBDebugger, SetSelectedPlatform,
 1047   LLDB_RECORD_METHOD(lldb::SBPlatform, SBDebugger, GetPlatformAtIndex,
 1073   LLDB_RECORD_METHOD(lldb::SBStructuredData, SBDebugger,
 1147   LLDB_RECORD_METHOD(void, SBDebugger, PushInputReader, (lldb::SBInputReader &),
 1153   LLDB_RECORD_METHOD(void, SBDebugger, RunCommandInterpreter, (bool, bool),
 1171   LLDB_RECORD_METHOD(void, SBDebugger, RunCommandInterpreter,
 1189   LLDB_RECORD_METHOD(lldb::SBError, SBDebugger, RunREPL,
 1313   LLDB_RECORD_METHOD(void, SBDebugger, SetPrompt, (const char *), prompt);
 1335   LLDB_RECORD_METHOD(void, SBDebugger, SetScriptLanguage,
 1344   LLDB_RECORD_METHOD(bool, SBDebugger, SetUseExternalEditor, (bool), value);
 1356   LLDB_RECORD_METHOD(bool, SBDebugger, SetUseColor, (bool), value);
 1368   LLDB_RECORD_METHOD(bool, SBDebugger, GetDescription, (lldb::SBStream &),
 1390   LLDB_RECORD_METHOD(lldb::SBError, SBDebugger, SetCurrentPlatform,
 1421   LLDB_RECORD_METHOD(bool, SBDebugger, SetCurrentPlatformSDKRoot,
 1447   LLDB_RECORD_METHOD(void, SBDebugger, SetCloseInputOnEOF, (bool), b);
 1454   LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory,
 1471   LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory,
 1483   LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, CreateCategory,
 1500   LLDB_RECORD_METHOD(bool, SBDebugger, DeleteCategory, (const char *),
 1516   LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategoryAtIndex,
 1531   LLDB_RECORD_METHOD(lldb::SBTypeFormat, SBDebugger, GetFormatForType,
 1541   LLDB_RECORD_METHOD(lldb::SBTypeSummary, SBDebugger, GetSummaryForType,
 1551   LLDB_RECORD_METHOD(lldb::SBTypeFilter, SBDebugger, GetFilterForType,
 1561   LLDB_RECORD_METHOD(lldb::SBTypeSynthetic, SBDebugger, GetSyntheticForType,
 1580   LLDB_RECORD_METHOD(bool, SBDebugger, EnableLog, (const char *, const char **),

tools/lldb/source/API/SBDeclaration.cpp

   39   LLDB_RECORD_METHOD(const lldb::SBDeclaration &,
   99   LLDB_RECORD_METHOD(void, SBDeclaration, SetFileSpec, (lldb::SBFileSpec),
  108   LLDB_RECORD_METHOD(void, SBDeclaration, SetLine, (uint32_t), line);
  114   LLDB_RECORD_METHOD(void, SBDeclaration, SetColumn, (uint32_t), column);
  160   LLDB_RECORD_METHOD(bool, SBDeclaration, GetDescription, (lldb::SBStream &),

tools/lldb/source/API/SBError.cpp

   31   LLDB_RECORD_METHOD(const lldb::SBError &,
   98   LLDB_RECORD_METHOD(void, SBError, SetError, (uint32_t, lldb::ErrorType), err,
  125   LLDB_RECORD_METHOD(void, SBError, SetErrorString, (const char *), err_str);
  170   LLDB_RECORD_METHOD(bool, SBError, GetDescription, (lldb::SBStream &),

tools/lldb/source/API/SBEvent.cpp

   51   LLDB_RECORD_METHOD(const lldb::SBEvent &,
  110   LLDB_RECORD_METHOD(bool, SBEvent, BroadcasterMatchesPtr,
  119   LLDB_RECORD_METHOD(bool, SBEvent, BroadcasterMatchesRef,
  183   LLDB_RECORD_METHOD(bool, SBEvent, GetDescription, (lldb::SBStream &),

tools/lldb/source/API/SBExecutionContext.cpp

   73   LLDB_RECORD_METHOD(

tools/lldb/source/API/SBExpressionOptions.cpp

   34   LLDB_RECORD_METHOD(
   53   LLDB_RECORD_METHOD(void, SBExpressionOptions, SetCoerceResultToId, (bool),
   66   LLDB_RECORD_METHOD(void, SBExpressionOptions, SetUnwindOnError, (bool),
   80   LLDB_RECORD_METHOD(void, SBExpressionOptions, SetIgnoreBreakpoints, (bool),
   94   LLDB_RECORD_METHOD(void, SBExpressionOptions, SetFetchDynamicValue,
  108   LLDB_RECORD_METHOD(void, SBExpressionOptions, SetTimeoutInMicroSeconds,
  125   LLDB_RECORD_METHOD(void, SBExpressionOptions,
  140   LLDB_RECORD_METHOD(void, SBExpressionOptions, SetTryAllThreads, (bool),
  153   LLDB_RECORD_METHOD(void, SBExpressionOptions, SetStopOthers, (bool),
  167   LLDB_RECORD_METHOD(void, SBExpressionOptions, SetTrapExceptions, (bool),
  174   LLDB_RECORD_METHOD(void, SBExpressionOptions, SetLanguage,
  195   LLDB_RECORD_METHOD(void, SBExpressionOptions, SetGenerateDebugInfo, (bool),
  209   LLDB_RECORD_METHOD(void, SBExpressionOptions, SetSuppressPersistentResult,
  223   LLDB_RECORD_METHOD(void, SBExpressionOptions, SetPrefix, (const char *),
  236   LLDB_RECORD_METHOD(void, SBExpressionOptions, SetAutoApplyFixIts, (bool), b);
  248   LLDB_RECORD_METHOD(void, SBExpressionOptions, SetTopLevel, (bool), b);
  261   LLDB_RECORD_METHOD(void, SBExpressionOptions, SetAllowJIT, (bool), allow);

tools/lldb/source/API/SBFileSpec.cpp

   57   LLDB_RECORD_METHOD(const lldb::SBFileSpec &,
  128   LLDB_RECORD_METHOD(void, SBFileSpec, SetFilename, (const char *), filename);
  137   LLDB_RECORD_METHOD(void, SBFileSpec, SetDirectory, (const char *), directory);
  186   LLDB_RECORD_METHOD(void, SBFileSpec, AppendPathComponent, (const char *), fn);

tools/lldb/source/API/SBFileSpecList.cpp

   38   LLDB_RECORD_METHOD(const lldb::SBFileSpecList &,
   54   LLDB_RECORD_METHOD(void, SBFileSpecList, Append, (const lldb::SBFileSpec &),
   61   LLDB_RECORD_METHOD(bool, SBFileSpecList, AppendIfUnique,
   75   LLDB_RECORD_METHOD(uint32_t, SBFileSpecList, FindFileIndex,

tools/lldb/source/API/SBFrame.cpp

   76   LLDB_RECORD_METHOD(const lldb::SBFrame &,
  351   LLDB_RECORD_METHOD(bool, SBFrame, SetPC, (lldb::addr_t), new_pc);
  446   LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, GetValueForVariablePath,
  465   LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, GetValueForVariablePath,
  500   LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindVariable, (const char *),
  519   LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindVariable,
  553   LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindValue,
  572   LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindValue,
  753   LLDB_RECORD_METHOD(lldb::SBValueList, SBFrame, GetVariables,
  785   LLDB_RECORD_METHOD(lldb::SBValueList, SBFrame, GetVariables,
  806   LLDB_RECORD_METHOD(lldb::SBValueList, SBFrame, GetVariables,
  939   LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindRegister, (const char *),
  979   LLDB_RECORD_METHOD(bool, SBFrame, GetDescription, (lldb::SBStream &),
 1006   LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression, (const char *),
 1034   LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
 1057   LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
 1079   LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,

tools/lldb/source/API/SBFunction.cpp

   38   LLDB_RECORD_METHOD(const lldb::SBFunction &,
  103   LLDB_RECORD_METHOD(bool, SBFunction, GetDescription, (lldb::SBStream &), s);
  118   LLDB_RECORD_METHOD(lldb::SBInstructionList, SBFunction, GetInstructions,
  126   LLDB_RECORD_METHOD(lldb::SBInstructionList, SBFunction, GetInstructions,
  181   LLDB_RECORD_METHOD(const char *, SBFunction, GetArgumentName, (uint32_t),

tools/lldb/source/API/SBInstruction.cpp

   83   LLDB_RECORD_METHOD(const lldb::SBInstruction &,
  115   LLDB_RECORD_METHOD(const char *, SBInstruction, GetMnemonic, (lldb::SBTarget),
  135   LLDB_RECORD_METHOD(const char *, SBInstruction, GetOperands, (lldb::SBTarget),
  155   LLDB_RECORD_METHOD(const char *, SBInstruction, GetComment, (lldb::SBTarget),
  184   LLDB_RECORD_METHOD(lldb::SBData, SBInstruction, GetData, (lldb::SBTarget),
  238   LLDB_RECORD_METHOD(bool, SBInstruction, GetDescription, (lldb::SBStream &),
  260   LLDB_RECORD_METHOD(void, SBInstruction, Print, (FILE *), outp);
  266   LLDB_RECORD_METHOD(void, SBInstruction, Print, (SBFile), out);
  271   LLDB_RECORD_METHOD(void, SBInstruction, Print, (FileSP), out_sp);
  294   LLDB_RECORD_METHOD(bool, SBInstruction, EmulateWithFrame,
  319   LLDB_RECORD_METHOD(bool, SBInstruction, DumpEmulation, (const char *),
  331   LLDB_RECORD_METHOD(bool, SBInstruction, TestEmulation,

tools/lldb/source/API/SBInstructionList.cpp

   36   LLDB_RECORD_METHOD(
   66   LLDB_RECORD_METHOD(lldb::SBInstruction, SBInstructionList,
   80   LLDB_RECORD_METHOD(size_t, SBInstructionList, GetInstructionsCount,
  113   LLDB_RECORD_METHOD(void, SBInstructionList, AppendInstruction,
  122   LLDB_RECORD_METHOD(void, SBInstructionList, Print, (FILE *), out);
  130   LLDB_RECORD_METHOD(void, SBInstructionList, Print, (SBFile), out);
  138   LLDB_RECORD_METHOD(void, SBInstructionList, Print, (FileSP), out_sp);
  146   LLDB_RECORD_METHOD(bool, SBInstructionList, GetDescription,
  189   LLDB_RECORD_METHOD(bool, SBInstructionList, DumpEmulationForAllInstructions,

tools/lldb/source/API/SBLaunchInfo.cpp

   87   LLDB_RECORD_METHOD(void, SBLaunchInfo, SetUserID, (uint32_t), uid);
   93   LLDB_RECORD_METHOD(void, SBLaunchInfo, SetGroupID, (uint32_t), gid);
  106   LLDB_RECORD_METHOD(void, SBLaunchInfo, SetExecutableFile,
  119   LLDB_RECORD_METHOD(void, SBLaunchInfo, SetListener, (lldb::SBListener &),
  132   LLDB_RECORD_METHOD(const char *, SBLaunchInfo, GetArgumentAtIndex, (uint32_t),
  139   LLDB_RECORD_METHOD(void, SBLaunchInfo, SetArguments, (const char **, bool),
  160   LLDB_RECORD_METHOD(const char *, SBLaunchInfo, GetEnvironmentEntryAtIndex,
  169   LLDB_RECORD_METHOD(void, SBLaunchInfo, SetEnvironmentEntries,
  194   LLDB_RECORD_METHOD(void, SBLaunchInfo, SetWorkingDirectory, (const char *),
  207   LLDB_RECORD_METHOD(void, SBLaunchInfo, SetLaunchFlags, (uint32_t), flags);
  219   LLDB_RECORD_METHOD(void, SBLaunchInfo, SetProcessPluginName, (const char *),
  235   LLDB_RECORD_METHOD(void, SBLaunchInfo, SetShell, (const char *), path);
  247   LLDB_RECORD_METHOD(void, SBLaunchInfo, SetShellExpandArguments, (bool),
  260   LLDB_RECORD_METHOD(void, SBLaunchInfo, SetResumeCount, (uint32_t), c);
  266   LLDB_RECORD_METHOD(bool, SBLaunchInfo, AddCloseFileAction, (int), fd);
  272   LLDB_RECORD_METHOD(bool, SBLaunchInfo, AddDuplicateFileAction, (int, int), fd,
  280   LLDB_RECORD_METHOD(bool, SBLaunchInfo, AddOpenFileAction,
  287   LLDB_RECORD_METHOD(bool, SBLaunchInfo, AddSuppressFileAction,
  294   LLDB_RECORD_METHOD(void, SBLaunchInfo, SetLaunchEventData, (const char *),
  308   LLDB_RECORD_METHOD(void, SBLaunchInfo, SetDetachOnError, (bool), enable);

tools/lldb/source/API/SBLineEntry.cpp

   39   LLDB_RECORD_METHOD(const lldb::SBLineEntry &,
  114   LLDB_RECORD_METHOD(void, SBLineEntry, SetFileSpec, (lldb::SBFileSpec),
  123   LLDB_RECORD_METHOD(void, SBLineEntry, SetLine, (uint32_t), line);
  129   LLDB_RECORD_METHOD(void, SBLineEntry, SetColumn, (uint32_t), column);
  173   LLDB_RECORD_METHOD(bool, SBLineEntry, GetDescription, (lldb::SBStream &),

tools/lldb/source/API/SBListener.cpp

   38   LLDB_RECORD_METHOD(const lldb::SBListener &,
   64   LLDB_RECORD_METHOD(void, SBListener, AddEvent, (const lldb::SBEvent &),
   82   LLDB_RECORD_METHOD(uint32_t, SBListener, StartListeningForEventClass,
  100   LLDB_RECORD_METHOD(bool, SBListener, StopListeningForEventClass,
  117   LLDB_RECORD_METHOD(uint32_t, SBListener, StartListeningForEvents,
  132   LLDB_RECORD_METHOD(bool, SBListener, StopListeningForEvents,
  143   LLDB_RECORD_METHOD(bool, SBListener, WaitForEvent,
  170   LLDB_RECORD_METHOD(bool, SBListener, WaitForEventForBroadcaster,
  192   LLDB_RECORD_METHOD(
  213   LLDB_RECORD_METHOD(bool, SBListener, PeekAtNextEvent, (lldb::SBEvent &),
  226   LLDB_RECORD_METHOD(bool, SBListener, PeekAtNextEventForBroadcaster,
  241   LLDB_RECORD_METHOD(bool, SBListener, PeekAtNextEventForBroadcasterWithType,
  255   LLDB_RECORD_METHOD(bool, SBListener, GetNextEvent, (lldb::SBEvent &), event);
  270   LLDB_RECORD_METHOD(bool, SBListener, GetNextEventForBroadcaster,
  289   LLDB_RECORD_METHOD(bool, SBListener, GetNextEventForBroadcasterWithType,
  307   LLDB_RECORD_METHOD(bool, SBListener, HandleBroadcastEvent,

tools/lldb/source/API/SBMemoryRegionInfo.cpp

   40   LLDB_RECORD_METHOD(
  120   LLDB_RECORD_METHOD(bool, SBMemoryRegionInfo, GetDescription,

tools/lldb/source/API/SBMemoryRegionInfoList.cpp

   89   LLDB_RECORD_METHOD(
  108   LLDB_RECORD_METHOD(bool, SBMemoryRegionInfoList, GetMemoryRegionAtIndex,
  121   LLDB_RECORD_METHOD(void, SBMemoryRegionInfoList, Append,
  128   LLDB_RECORD_METHOD(void, SBMemoryRegionInfoList, Append,

tools/lldb/source/API/SBModule.cpp

   70   LLDB_RECORD_METHOD(const lldb::SBModule &,
  121   LLDB_RECORD_METHOD(bool, SBModule, SetPlatformFileSpec,
  147   LLDB_RECORD_METHOD(bool, SBModule, SetRemoteInstallFileSpec,
  212   LLDB_RECORD_METHOD(lldb::SBAddress, SBModule, ResolveFileAddress,
  228   LLDB_RECORD_METHOD(lldb::SBSymbolContext, SBModule,
  241   LLDB_RECORD_METHOD(bool, SBModule, GetDescription, (lldb::SBStream &),
  266   LLDB_RECORD_METHOD(lldb::SBCompileUnit, SBModule, GetCompileUnitAtIndex,
  279   LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBModule, FindCompileUnits,
  306   LLDB_RECORD_METHOD(lldb::SBSymbol, SBModule, GetSymbolAtIndex, (size_t), idx);
  318   LLDB_RECORD_METHOD(lldb::SBSymbol, SBModule, FindSymbol,
  335   LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBModule, FindSymbols,
  377   LLDB_RECORD_METHOD(lldb::SBSection, SBModule, GetSectionAtIndex, (size_t),
  395   LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBModule, FindFunctions,
  412   LLDB_RECORD_METHOD(lldb::SBValueList, SBModule, FindGlobalVariables,
  440   LLDB_RECORD_METHOD(lldb::SBValue, SBModule, FindFirstGlobalVariable,
  450   LLDB_RECORD_METHOD(lldb::SBType, SBModule, FindFirstType, (const char *),
  476   LLDB_RECORD_METHOD(lldb::SBType, SBModule, GetBasicType, (lldb::BasicType),
  494   LLDB_RECORD_METHOD(lldb::SBTypeList, SBModule, FindTypes, (const char *),
  531   LLDB_RECORD_METHOD(lldb::SBType, SBModule, GetTypeByID, (lldb::user_id_t),
  546   LLDB_RECORD_METHOD(lldb::SBTypeList, SBModule, GetTypes, (uint32_t),
  566   LLDB_RECORD_METHOD(lldb::SBSection, SBModule, FindSection, (const char *),
  621   LLDB_RECORD_METHOD(uint32_t, SBModule, GetVersion, (uint32_t *, uint32_t),

tools/lldb/source/API/SBModuleSpec.cpp

   33   LLDB_RECORD_METHOD(const lldb::SBModuleSpec &,
   67   LLDB_RECORD_METHOD(void, SBModuleSpec, SetFileSpec,
   81   LLDB_RECORD_METHOD(void, SBModuleSpec, SetPlatformFileSpec,
   94   LLDB_RECORD_METHOD(void, SBModuleSpec, SetSymbolFileSpec,
  107   LLDB_RECORD_METHOD(void, SBModuleSpec, SetObjectName, (const char *), name);
  124   LLDB_RECORD_METHOD(void, SBModuleSpec, SetTriple, (const char *), triple);
  145   LLDB_RECORD_METHOD(bool, SBModuleSpec, GetDescription, (lldb::SBStream &),
  163   LLDB_RECORD_METHOD(
  187   LLDB_RECORD_METHOD(void, SBModuleSpecList, Append,
  194   LLDB_RECORD_METHOD(void, SBModuleSpecList, Append,
  207   LLDB_RECORD_METHOD(lldb::SBModuleSpec, SBModuleSpecList, GetSpecAtIndex,
  217   LLDB_RECORD_METHOD(lldb::SBModuleSpec, SBModuleSpecList,
  229   LLDB_RECORD_METHOD(lldb::SBModuleSpecList, SBModuleSpecList,
  240   LLDB_RECORD_METHOD(bool, SBModuleSpecList, GetDescription, (lldb::SBStream &),

tools/lldb/source/API/SBPlatform.cpp

   84   LLDB_RECORD_METHOD(
  102   LLDB_RECORD_METHOD(void, SBPlatformConnectOptions, SetURL, (const char *),
  120   LLDB_RECORD_METHOD(void, SBPlatformConnectOptions, EnableRsync,
  152   LLDB_RECORD_METHOD(void, SBPlatformConnectOptions, SetLocalCacheDirectory,
  196   LLDB_RECORD_METHOD(void, SBPlatformShellCommand, SetCommand, (const char *),
  215   LLDB_RECORD_METHOD(void, SBPlatformShellCommand, SetWorkingDirectory,
  234   LLDB_RECORD_METHOD(void, SBPlatformShellCommand, SetTimeoutSeconds,
  319   LLDB_RECORD_METHOD(bool, SBPlatform, SetWorkingDirectory, (const char *),
  334   LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, ConnectRemote,
  453   LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Get,
  467   LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Put,
  492   LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Install,
  507   LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Run,
  530   LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Launch, (lldb::SBLaunchInfo &),
  542   LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Kill, (const lldb::pid_t), pid);
  565   LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, MakeDirectory,
  580   LLDB_RECORD_METHOD(uint32_t, SBPlatform, GetFilePermissions, (const char *),
  594   LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, SetFilePermissions,

tools/lldb/source/API/SBProcess.cpp

   68   LLDB_RECORD_METHOD(const lldb::SBProcess &,
  133   LLDB_RECORD_METHOD(bool, SBProcess, RemoteLaunch,
  170   LLDB_RECORD_METHOD(bool, SBProcess, RemoteAttachToProcessWithID,
  228   LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, CreateOSPluginThread,
  259   LLDB_RECORD_METHOD(size_t, SBProcess, PutSTDIN, (const char *, size_t), src,
  316   LLDB_RECORD_METHOD(lldb::SBTrace, SBProcess, StartTrace,
  367   LLDB_RECORD_METHOD(void, SBProcess, AppendEventStateReport,
  383   LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThread,
  397   LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThreadByID, (lldb::tid_t),
  413   LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThreadByIndexID, (uint32_t),
  429   LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, GetThreadAtIndex, (size_t),
  465   LLDB_RECORD_METHOD(lldb::SBQueue, SBProcess, GetQueueAtIndex, (size_t),
  485   LLDB_RECORD_METHOD(uint32_t, SBProcess, GetStopID, (bool),
  501   LLDB_RECORD_METHOD(lldb::SBEvent, SBProcess, GetStopEventForStopID,
  677   LLDB_RECORD_METHOD(lldb::SBError, SBProcess, Detach, (bool), keep_stopped);
  692   LLDB_RECORD_METHOD(lldb::SBError, SBProcess, Signal, (int), signo);
  725   LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, GetThreadByID, (lldb::tid_t),
  744   LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, GetThreadByIndexID, (uint32_t),
  919   LLDB_RECORD_METHOD(uint64_t, SBProcess, ReadUnsignedFromMemory,
  943   LLDB_RECORD_METHOD(lldb::addr_t, SBProcess, ReadPointerFromMemory,
  989   LLDB_RECORD_METHOD(bool, SBProcess, GetDescription, (lldb::SBStream &),
 1033   LLDB_RECORD_METHOD(uint32_t, SBProcess, LoadImage,
 1043   LLDB_RECORD_METHOD(
 1070   LLDB_RECORD_METHOD(uint32_t, SBProcess, LoadImageUsingPaths,
 1105   LLDB_RECORD_METHOD(lldb::SBError, SBProcess, UnloadImage, (uint32_t),
 1127   LLDB_RECORD_METHOD(lldb::SBError, SBProcess, SendEventData, (const char *),
 1158   LLDB_RECORD_METHOD(const char *, SBProcess, GetExtendedBacktraceTypeAtIndex,
 1174   LLDB_RECORD_METHOD(lldb::SBThreadCollection, SBProcess, GetHistoryThreads,
 1187   LLDB_RECORD_METHOD(bool, SBProcess, IsInstrumentationRuntimePresent,
 1207   LLDB_RECORD_METHOD(lldb::SBError, SBProcess, SaveCore, (const char *),
 1233   LLDB_RECORD_METHOD(lldb::SBError, SBProcess, GetMemoryRegionInfo,

tools/lldb/source/API/SBProcessInfo.cpp

   31   LLDB_RECORD_METHOD(lldb::SBProcessInfo &,

tools/lldb/source/API/SBQueue.cpp

  239   LLDB_RECORD_METHOD(const lldb::SBQueue &,
  294   LLDB_RECORD_METHOD(lldb::SBThread, SBQueue, GetThreadAtIndex, (uint32_t),
  308   LLDB_RECORD_METHOD(lldb::SBQueueItem, SBQueue, GetPendingItemAtIndex,

tools/lldb/source/API/SBQueueItem.cpp

   54   LLDB_RECORD_METHOD(void, SBQueueItem, SetQueueItem,
   71   LLDB_RECORD_METHOD(void, SBQueueItem, SetKind, (lldb::QueueItemKind), kind);
   89   LLDB_RECORD_METHOD(void, SBQueueItem, SetAddress, (lldb::SBAddress), addr);
   97   LLDB_RECORD_METHOD(lldb::SBThread, SBQueueItem, GetExtendedBacktraceThread,

tools/lldb/source/API/SBSection.cpp

   40   LLDB_RECORD_METHOD(const lldb::SBSection &,
   83   LLDB_RECORD_METHOD(lldb::SBSection, SBSection, FindSubSection, (const char *),
  108   LLDB_RECORD_METHOD(lldb::SBSection, SBSection, GetSubSectionAtIndex, (size_t),
  135   LLDB_RECORD_METHOD(lldb::addr_t, SBSection, GetLoadAddress,
  187   LLDB_RECORD_METHOD(lldb::SBData, SBSection, GetSectionData,
  254   LLDB_RECORD_METHOD(bool, SBSection, operator==,(const lldb::SBSection &),
  265   LLDB_RECORD_METHOD(bool, SBSection, operator!=,(const lldb::SBSection &),
  274   LLDB_RECORD_METHOD(bool, SBSection, GetDescription, (lldb::SBStream &),

tools/lldb/source/API/SBSourceManager.cpp

   99   LLDB_RECORD_METHOD(const lldb::SBSourceManager &,
  112   LLDB_RECORD_METHOD(size_t, SBSourceManager, DisplaySourceLinesWithLineNumbers,
  128   LLDB_RECORD_METHOD(

tools/lldb/source/API/SBStream.cpp

   73   LLDB_RECORD_METHOD(void, SBStream, RedirectToFile, (const char *, bool), path,
  110   LLDB_RECORD_METHOD(void, SBStream, RedirectToFileHandle, (FILE *, bool), fh,
  117   LLDB_RECORD_METHOD(void, SBStream, RedirectToFile, (SBFile), file)
  122   LLDB_RECORD_METHOD(void, SBStream, RedirectToFile, (FileSP), file_sp);
  145   LLDB_RECORD_METHOD(void, SBStream, RedirectToFileDescriptor, (int, bool), fd,

tools/lldb/source/API/SBStringList.cpp

   34   LLDB_RECORD_METHOD(const lldb::SBStringList &,
   63   LLDB_RECORD_METHOD(void, SBStringList, AppendString, (const char *), str);
   74   LLDB_RECORD_METHOD(void, SBStringList, AppendList, (const char **, int), strv,
   86   LLDB_RECORD_METHOD(void, SBStringList, AppendList,
  112   LLDB_RECORD_METHOD(const char *, SBStringList, GetStringAtIndex, (size_t),

tools/lldb/source/API/SBStructuredData.cpp

   52   LLDB_RECORD_METHOD(
   61   LLDB_RECORD_METHOD(lldb::SBError, SBStructuredData, SetFromJSON,

tools/lldb/source/API/SBSymbol.cpp

   33   LLDB_RECORD_METHOD(const lldb::SBSymbol &,
  102   LLDB_RECORD_METHOD(bool, SBSymbol, GetDescription, (lldb::SBStream &),
  116   LLDB_RECORD_METHOD(lldb::SBInstructionList, SBSymbol, GetInstructions,
  124   LLDB_RECORD_METHOD(lldb::SBInstructionList, SBSymbol, GetInstructions,

tools/lldb/source/API/SBSymbolContext.cpp

   43   LLDB_RECORD_METHOD(const lldb::SBSymbolContext &,
  134   LLDB_RECORD_METHOD(void, SBSymbolContext, SetModule, (lldb::SBModule),
  141   LLDB_RECORD_METHOD(void, SBSymbolContext, SetCompileUnit,
  148   LLDB_RECORD_METHOD(void, SBSymbolContext, SetFunction, (lldb::SBFunction),
  155   LLDB_RECORD_METHOD(void, SBSymbolContext, SetBlock, (lldb::SBBlock), block);
  161   LLDB_RECORD_METHOD(void, SBSymbolContext, SetLineEntry, (lldb::SBLineEntry),
  171   LLDB_RECORD_METHOD(void, SBSymbolContext, SetSymbol, (lldb::SBSymbol),
  203   LLDB_RECORD_METHOD(bool, SBSymbolContext, GetDescription, (lldb::SBStream &),

tools/lldb/source/API/SBSymbolContextList.cpp

   35   LLDB_RECORD_METHOD(
   53   LLDB_RECORD_METHOD(lldb::SBSymbolContext, SBSymbolContextList,
   74   LLDB_RECORD_METHOD(void, SBSymbolContextList, Append,
   82   LLDB_RECORD_METHOD(void, SBSymbolContextList, Append,
  109   LLDB_RECORD_METHOD(bool, SBSymbolContextList, GetDescription,

tools/lldb/source/API/SBTarget.cpp

  113   LLDB_RECORD_METHOD(const lldb::SBTarget &,
  235   LLDB_RECORD_METHOD(void, SBTarget, SetCollectingStats, (bool), v);
  253   LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, LoadCore, (const char *),
  261   LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, LoadCore,
  286   LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, LaunchSimple,
  320   LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, Launch,
  394   LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, Launch,
  443   LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, Attach,
  482   LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, AttachToProcessWithID,
  514   LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, AttachToProcessWithName,
  540   LLDB_RECORD_METHOD(
  606   LLDB_RECORD_METHOD(lldb::SBAddress, SBTarget, ResolveLoadAddress,
  625   LLDB_RECORD_METHOD(lldb::SBAddress, SBTarget, ResolveFileAddress,
  643   LLDB_RECORD_METHOD(lldb::SBAddress, SBTarget, ResolvePastLoadAddress,
  664   LLDB_RECORD_METHOD(lldb::SBSymbolContext, SBTarget,
  701   LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation,
  711   LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation,
  720   LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation,
  733   LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation,
  745   LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation,
  774   LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
  806   LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
  820   LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
  834   LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
  860   LLDB_RECORD_METHOD(
  875   LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames,
  891   LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames,
  916   LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex,
  934   LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex,
  946   LLDB_RECORD_METHOD(
  971   LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByAddress,
  986   LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateBySBAddress,
 1008   LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget,
 1031   LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget,
 1045   LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget,
 1074   LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateForException,
 1094   LLDB_RECORD_METHOD(
 1145   LLDB_RECORD_METHOD(bool, SBTarget, BreakpointDelete, (lldb::break_id_t),
 1159   LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, FindBreakpointByID,
 1174   LLDB_RECORD_METHOD(bool, SBTarget, FindBreakpointsByName,
 1193   LLDB_RECORD_METHOD(void, SBTarget, GetBreakpointNames, (lldb::SBStringList &),
 1210   LLDB_RECORD_METHOD(void, SBTarget, DeleteBreakpointName, (const char *),
 1258   LLDB_RECORD_METHOD(lldb::SBError, SBTarget, BreakpointsCreateFromFile,
 1270   LLDB_RECORD_METHOD(
 1305   LLDB_RECORD_METHOD(lldb::SBError, SBTarget, BreakpointsWriteToFile,
 1321   LLDB_RECORD_METHOD(lldb::SBError, SBTarget, BreakpointsWriteToFile,
 1365   LLDB_RECORD_METHOD(bool, SBTarget, DeleteWatchpoint, (lldb::watch_id_t),
 1382   LLDB_RECORD_METHOD(lldb::SBWatchpoint, SBTarget, FindWatchpointByID,
 1403   LLDB_RECORD_METHOD(lldb::SBWatchpoint, SBTarget, WatchAddress,
 1467   LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, CreateValueFromAddress,
 1487   LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, CreateValueFromData,
 1507   LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, CreateValueFromExpression,
 1538   LLDB_RECORD_METHOD(void, SBTarget, AppendImageSearchPath,
 1557   LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, AddModule,
 1566   LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, AddModule,
 1595   LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, AddModule,
 1607   LLDB_RECORD_METHOD(bool, SBTarget, AddModule, (lldb::SBModule &), module);
 1637   LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, FindModule,
 1651   LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBTarget, FindCompileUnits,
 1715   LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, GetModuleAtIndex, (uint32_t),
 1731   LLDB_RECORD_METHOD(bool, SBTarget, RemoveModule, (lldb::SBModule), module);
 1753   LLDB_RECORD_METHOD(bool, SBTarget, GetDescription,
 1770   LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBTarget, FindFunctions,
 1792   LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBTarget, FindGlobalFunctions,
 1823   LLDB_RECORD_METHOD(lldb::SBType, SBTarget, FindFirstType, (const char *),
 1865   LLDB_RECORD_METHOD(lldb::SBType, SBTarget, GetBasicType, (lldb::BasicType),
 1878   LLDB_RECORD_METHOD(lldb::SBTypeList, SBTarget, FindTypes, (const char *),
 1923   LLDB_RECORD_METHOD(lldb::SBValueList, SBTarget, FindGlobalVariables,
 1953   LLDB_RECORD_METHOD(lldb::SBValueList, SBTarget, FindGlobalVariables,
 1999   LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, FindFirstGlobalVariable,
 2017   LLDB_RECORD_METHOD(lldb::SBInstructionList, SBTarget, ReadInstructions,
 2026   LLDB_RECORD_METHOD(lldb::SBInstructionList, SBTarget, ReadInstructions,
 2118   LLDB_RECORD_METHOD(lldb::SBError, SBTarget, SetSectionLoadAddress,
 2156   LLDB_RECORD_METHOD(lldb::SBError, SBTarget, ClearSectionLoadAddress,
 2192   LLDB_RECORD_METHOD(lldb::SBError, SBTarget, SetModuleLoadAddress,
 2226   LLDB_RECORD_METHOD(lldb::SBError, SBTarget, ClearModuleLoadAddress,
 2279   LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBTarget, FindSymbols,
 2293   LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, EvaluateExpression,
 2310   LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, EvaluateExpression,
 2382   LLDB_RECORD_METHOD(void, SBTarget, SetLaunchInfo,

tools/lldb/source/API/SBThread.cpp

   80   LLDB_RECORD_METHOD(const lldb::SBThread &,
  206   LLDB_RECORD_METHOD(uint64_t, SBThread, GetStopReasonDataAtIndex, (uint32_t),
  268   LLDB_RECORD_METHOD(bool, SBThread, GetStopReasonExtendedInfoAsJSON,
  291   LLDB_RECORD_METHOD(lldb::SBThreadCollection, SBThread,
  316   LLDB_RECORD_METHOD(size_t, SBThread, GetStopDescription, (char *, size_t),
  506   LLDB_RECORD_METHOD(bool, SBThread, GetInfoItemByPathAsString,
  588   LLDB_RECORD_METHOD(void, SBThread, StepOver, (lldb::RunMode),
  596   LLDB_RECORD_METHOD(void, SBThread, StepOver, (lldb::RunMode, lldb::SBError &),
  629   LLDB_RECORD_METHOD(void, SBThread, StepInto, (lldb::RunMode),
  637   LLDB_RECORD_METHOD(void, SBThread, StepInto, (const char *, lldb::RunMode),
  646   LLDB_RECORD_METHOD(void, SBThread, StepInto,
  703   LLDB_RECORD_METHOD(void, SBThread, StepOut, (lldb::SBError &), error);
  731   LLDB_RECORD_METHOD(void, SBThread, StepOutOfFrame, (lldb::SBFrame &),
  739   LLDB_RECORD_METHOD(void, SBThread, StepOutOfFrame,
  778   LLDB_RECORD_METHOD(void, SBThread, StepInstruction, (bool), step_over);
  785   LLDB_RECORD_METHOD(void, SBThread, StepInstruction, (bool, lldb::SBError &),
  808   LLDB_RECORD_METHOD(void, SBThread, RunToAddress, (lldb::addr_t), addr);
  815   LLDB_RECORD_METHOD(void, SBThread, RunToAddress,
  845   LLDB_RECORD_METHOD(lldb::SBError, SBThread, StepOverUntil,
  962   LLDB_RECORD_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan,
  971   LLDB_RECORD_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan,
  985   LLDB_RECORD_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan,
 1024   LLDB_RECORD_METHOD(lldb::SBError, SBThread, JumpToLine,
 1045   LLDB_RECORD_METHOD(lldb::SBError, SBThread, ReturnFromFrame,
 1089   LLDB_RECORD_METHOD(bool, SBThread, Suspend, (lldb::SBError &), error);
 1116   LLDB_RECORD_METHOD(bool, SBThread, Resume, (lldb::SBError &), error);
 1192   LLDB_RECORD_METHOD(lldb::SBFrame, SBThread, GetFrameAtIndex, (uint32_t), idx);
 1230   LLDB_RECORD_METHOD(lldb::SBFrame, SBThread, SetSelectedFrame, (uint32_t),
 1338   LLDB_RECORD_METHOD(lldb::SBThread, SBThread, GetExtendedBacktraceThread,

tools/lldb/source/API/SBThreadCollection.cpp

   29   LLDB_RECORD_METHOD(
   82   LLDB_RECORD_METHOD(lldb::SBThread, SBThreadCollection, GetThreadAtIndex,

tools/lldb/source/API/SBThreadPlan.cpp

   91   LLDB_RECORD_METHOD(const lldb::SBThreadPlan &,
  132   LLDB_RECORD_METHOD(uint64_t, SBThreadPlan, GetStopReasonDataAtIndex,
  165   LLDB_RECORD_METHOD(void, SBThreadPlan, SetPlanComplete, (bool), success);
  207   LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
  218   LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
  250   LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
  262   LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
  294   LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
  306   LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
  333   LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
  343   LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
  368   LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
  380   LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
  404   LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,

tools/lldb/source/API/SBTrace.cpp

   66   LLDB_RECORD_METHOD(void, SBTrace, StopTrace, (lldb::SBError &, lldb::tid_t),
   80   LLDB_RECORD_METHOD(void, SBTrace, GetTraceConfig,

tools/lldb/source/API/SBTraceOptions.cpp

   46   LLDB_RECORD_METHOD(lldb::SBStructuredData, SBTraceOptions, getTraceParams,
   70   LLDB_RECORD_METHOD(void, SBTraceOptions, setTraceParams,
   83   LLDB_RECORD_METHOD(void, SBTraceOptions, setType, (lldb::TraceType), type);
   90   LLDB_RECORD_METHOD(void, SBTraceOptions, setTraceBufferSize, (uint64_t),
   98   LLDB_RECORD_METHOD(void, SBTraceOptions, setMetaDataBufferSize, (uint64_t),
  118   LLDB_RECORD_METHOD(void, SBTraceOptions, setThreadID, (lldb::tid_t),

tools/lldb/source/API/SBType.cpp

   53   LLDB_RECORD_METHOD(bool, SBType, operator==,(lldb::SBType &), rhs);
   65   LLDB_RECORD_METHOD(bool, SBType, operator!=,(lldb::SBType &), rhs);
   83   LLDB_RECORD_METHOD(lldb::SBType &, SBType, operator=,(const lldb::SBType &),
  220   LLDB_RECORD_METHOD(lldb::SBType, SBType, GetArrayType, (uint64_t), size);
  310   LLDB_RECORD_METHOD(lldb::SBTypeMemberFunction, SBType,
  347   LLDB_RECORD_METHOD(lldb::SBType, SBType, GetBasicType, (lldb::BasicType),
  382   LLDB_RECORD_METHOD(bool, SBType, GetDescription,
  397   LLDB_RECORD_METHOD(lldb::SBTypeMember, SBType, GetDirectBaseClassAtIndex,
  414   LLDB_RECORD_METHOD(lldb::SBTypeMember, SBType, GetVirtualBaseClassAtIndex,
  454   LLDB_RECORD_METHOD(lldb::SBTypeMember, SBType, GetFieldAtIndex, (uint32_t),
  529   LLDB_RECORD_METHOD(lldb::SBType, SBType, GetTemplateArgumentType, (uint32_t),
  554   LLDB_RECORD_METHOD(lldb::TemplateArgumentKind, SBType,
  586   LLDB_RECORD_METHOD(lldb::SBTypeList &,
  599   LLDB_RECORD_METHOD(void, SBTypeList, Append, (lldb::SBType), type);
  606   LLDB_RECORD_METHOD(lldb::SBType, SBTypeList, GetTypeAtIndex, (uint32_t),
  638   LLDB_RECORD_METHOD(lldb::SBTypeMember &,
  710   LLDB_RECORD_METHOD(bool, SBTypeMember, GetDescription,
  767   LLDB_RECORD_METHOD(
  848   LLDB_RECORD_METHOD(lldb::SBType, SBTypeMemberFunction, GetArgumentTypeAtIndex,
  870   LLDB_RECORD_METHOD(bool, SBTypeMemberFunction, GetDescription,

tools/lldb/source/API/SBTypeCategory.cpp

   64   LLDB_RECORD_METHOD(void, SBTypeCategory, SetEnabled, (bool), enabled);
   83   LLDB_RECORD_METHOD(lldb::LanguageType, SBTypeCategory, GetLanguageAtIndex,
  100   LLDB_RECORD_METHOD(void, SBTypeCategory, AddLanguage, (lldb::LanguageType),
  146   LLDB_RECORD_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
  157   LLDB_RECORD_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
  168   LLDB_RECORD_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
  179   LLDB_RECORD_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
  190   LLDB_RECORD_METHOD(lldb::SBTypeFilter, SBTypeCategory, GetFilterForType,
  217   LLDB_RECORD_METHOD(lldb::SBTypeFormat, SBTypeCategory, GetFormatForType,
  242   LLDB_RECORD_METHOD(lldb::SBTypeSummary, SBTypeCategory, GetSummaryForType,
  267   LLDB_RECORD_METHOD(lldb::SBTypeSynthetic, SBTypeCategory, GetSyntheticForType,
  295   LLDB_RECORD_METHOD(lldb::SBTypeFilter, SBTypeCategory, GetFilterAtIndex,
  313   LLDB_RECORD_METHOD(lldb::SBTypeFormat, SBTypeCategory, GetFormatAtIndex,
  323   LLDB_RECORD_METHOD(lldb::SBTypeSummary, SBTypeCategory, GetSummaryAtIndex,
  333   LLDB_RECORD_METHOD(lldb::SBTypeSynthetic, SBTypeCategory, GetSyntheticAtIndex,
  352   LLDB_RECORD_METHOD(bool, SBTypeCategory, AddTypeFormat,
  378   LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeFormat,
  397   LLDB_RECORD_METHOD(bool, SBTypeCategory, AddTypeSummary,
  457   LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeSummary,
  476   LLDB_RECORD_METHOD(bool, SBTypeCategory, AddTypeFilter,
  502   LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeFilter,
  521   LLDB_RECORD_METHOD(bool, SBTypeCategory, AddTypeSynthetic,
  581   LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeSynthetic,
  600   LLDB_RECORD_METHOD(bool, SBTypeCategory, GetDescription,
  612   LLDB_RECORD_METHOD(lldb::SBTypeCategory &,
  623   LLDB_RECORD_METHOD(bool, SBTypeCategory, operator==,(lldb::SBTypeCategory &),
  633   LLDB_RECORD_METHOD(bool, SBTypeCategory, operator!=,(lldb::SBTypeCategory &),

tools/lldb/source/API/SBTypeEnumMember.cpp

   43   LLDB_RECORD_METHOD(
  138   LLDB_RECORD_METHOD(
  155   LLDB_RECORD_METHOD(void, SBTypeEnumMemberList, Append,
  164   LLDB_RECORD_METHOD(lldb::SBTypeEnumMember, SBTypeEnumMemberList,
  183   LLDB_RECORD_METHOD(bool, SBTypeEnumMember, GetDescription,

tools/lldb/source/API/SBTypeFilter.cpp

   55   LLDB_RECORD_METHOD(void, SBTypeFilter, SetOptions, (uint32_t), value);
   63   LLDB_RECORD_METHOD(bool, SBTypeFilter, GetDescription,
   92   LLDB_RECORD_METHOD(const char *, SBTypeFilter, GetExpressionPathAtIndex,
  105   LLDB_RECORD_METHOD(bool, SBTypeFilter, ReplaceExpressionPathAtIndex,
  115   LLDB_RECORD_METHOD(void, SBTypeFilter, AppendExpressionPath, (const char *),
  123   LLDB_RECORD_METHOD(lldb::SBTypeFilter &,
  133   LLDB_RECORD_METHOD(bool, SBTypeFilter, operator==,(lldb::SBTypeFilter &),
  143   LLDB_RECORD_METHOD(bool, SBTypeFilter, IsEqualTo, (lldb::SBTypeFilter &),
  161   LLDB_RECORD_METHOD(bool, SBTypeFilter, operator!=,(lldb::SBTypeFilter &),

tools/lldb/source/API/SBTypeFormat.cpp

   82   LLDB_RECORD_METHOD(void, SBTypeFormat, SetFormat, (lldb::Format), fmt);
   89   LLDB_RECORD_METHOD(void, SBTypeFormat, SetTypeName, (const char *), type);
   97   LLDB_RECORD_METHOD(void, SBTypeFormat, SetOptions, (uint32_t), value);
  105   LLDB_RECORD_METHOD(bool, SBTypeFormat, GetDescription,
  118   LLDB_RECORD_METHOD(lldb::SBTypeFormat &,
  128   LLDB_RECORD_METHOD(bool, SBTypeFormat, operator==,(lldb::SBTypeFormat &),
  137   LLDB_RECORD_METHOD(bool, SBTypeFormat, IsEqualTo, (lldb::SBTypeFormat &),
  150   LLDB_RECORD_METHOD(bool, SBTypeFormat, operator!=,(lldb::SBTypeFormat &),

tools/lldb/source/API/SBTypeNameSpecifier.cpp

   91   LLDB_RECORD_METHOD(bool, SBTypeNameSpecifier, GetDescription,
  104   LLDB_RECORD_METHOD(
  115   LLDB_RECORD_METHOD(
  124   LLDB_RECORD_METHOD(bool, SBTypeNameSpecifier, IsEqualTo,
  139   LLDB_RECORD_METHOD(

tools/lldb/source/API/SBTypeSummary.cpp

   67   LLDB_RECORD_METHOD(void, SBTypeSummaryOptions, SetLanguage,
   75   LLDB_RECORD_METHOD(void, SBTypeSummaryOptions, SetCapping,
  270   LLDB_RECORD_METHOD(void, SBTypeSummary, SetOptions, (uint32_t), value);
  278   LLDB_RECORD_METHOD(void, SBTypeSummary, SetSummaryString, (const char *),
  291   LLDB_RECORD_METHOD(void, SBTypeSummary, SetFunctionName, (const char *),
  304   LLDB_RECORD_METHOD(void, SBTypeSummary, SetFunctionCode, (const char *),
  318   LLDB_RECORD_METHOD(bool, SBTypeSummary, GetDescription,
  331   LLDB_RECORD_METHOD(bool, SBTypeSummary, DoesPrintValue, (lldb::SBValue),
  341   LLDB_RECORD_METHOD(lldb::SBTypeSummary &,
  352   LLDB_RECORD_METHOD(bool, SBTypeSummary, operator==,(lldb::SBTypeSummary &),
  361   LLDB_RECORD_METHOD(bool, SBTypeSummary, IsEqualTo, (lldb::SBTypeSummary &),
  402   LLDB_RECORD_METHOD(bool, SBTypeSummary, operator!=,(lldb::SBTypeSummary &),

tools/lldb/source/API/SBTypeSynthetic.cpp

   95   LLDB_RECORD_METHOD(void, SBTypeSynthetic, SetClassName, (const char *), data);
  102   LLDB_RECORD_METHOD(void, SBTypeSynthetic, SetClassCode, (const char *), data);
  117   LLDB_RECORD_METHOD(void, SBTypeSynthetic, SetOptions, (uint32_t), value);
  126   LLDB_RECORD_METHOD(bool, SBTypeSynthetic, GetDescription,
  139   LLDB_RECORD_METHOD(lldb::SBTypeSynthetic &,
  150   LLDB_RECORD_METHOD(
  159   LLDB_RECORD_METHOD(bool, SBTypeSynthetic, IsEqualTo,
  178   LLDB_RECORD_METHOD(

tools/lldb/source/API/SBUnixSignals.cpp

   37   LLDB_RECORD_METHOD(const lldb::SBUnixSignals &,
  101   LLDB_RECORD_METHOD(bool, SBUnixSignals, SetShouldSuppress, (int32_t, bool),
  123   LLDB_RECORD_METHOD(bool, SBUnixSignals, SetShouldStop, (int32_t, bool), signo,
  145   LLDB_RECORD_METHOD(bool, SBUnixSignals, SetShouldNotify, (int32_t, bool),

tools/lldb/source/API/SBValue.cpp

  233   LLDB_RECORD_METHOD(lldb::SBValue &,
  457   LLDB_RECORD_METHOD(const char *, SBValue, GetSummary,
  486   LLDB_RECORD_METHOD(bool, SBValue, SetValueFromCString, (const char *),
  494   LLDB_RECORD_METHOD(bool, SBValue, SetValueFromCString,
  583   LLDB_RECORD_METHOD(lldb::SBValue, SBValue, CreateChildAtOffset,
  603   LLDB_RECORD_METHOD(lldb::SBValue, SBValue, Cast, (lldb::SBType), type);
  617   LLDB_RECORD_METHOD(lldb::SBValue, SBValue, CreateValueFromExpression,
  629   LLDB_RECORD_METHOD(lldb::SBValue, SBValue, CreateValueFromExpression,
  651   LLDB_RECORD_METHOD(lldb::SBValue, SBValue, CreateValueFromAddress,
  672   LLDB_RECORD_METHOD(lldb::SBValue, SBValue, CreateValueFromData,
  692   LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetChildAtIndex, (uint32_t), idx);
  710   LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetChildAtIndex,
  733   LLDB_RECORD_METHOD(uint32_t, SBValue, GetIndexOfChildWithName, (const char *),
  746   LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetChildMemberWithName,
  762   LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetChildMemberWithName,
  782   LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetDynamicValue,
  829   LLDB_RECORD_METHOD(void, SBValue, SetPreferDynamicValue,
  845   LLDB_RECORD_METHOD(void, SBValue, SetPreferSyntheticValue, (bool),
  883   LLDB_RECORD_METHOD(void, SBValue, SetSyntheticChildrenGenerated, (bool), is);
  892   LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetValueForExpressionPath,
  910   LLDB_RECORD_METHOD(int64_t, SBValue, GetValueAsSigned,
  931   LLDB_RECORD_METHOD(uint64_t, SBValue, GetValueAsUnsigned,
  952   LLDB_RECORD_METHOD(int64_t, SBValue, GetValueAsSigned, (int64_t), fail_value);
  963   LLDB_RECORD_METHOD(uint64_t, SBValue, GetValueAsUnsigned, (uint64_t),
 1005   LLDB_RECORD_METHOD(uint32_t, SBValue, GetNumChildren, (uint32_t), max);
 1170   LLDB_RECORD_METHOD(bool, SBValue, GetExpressionPath, (lldb::SBStream &),
 1184   LLDB_RECORD_METHOD(bool, SBValue, GetExpressionPath, (lldb::SBStream &, bool),
 1273   LLDB_RECORD_METHOD(bool, SBValue, GetDescription, (lldb::SBStream &),
 1299   LLDB_RECORD_METHOD(void, SBValue, SetFormat, (lldb::Format), format);
 1382   LLDB_RECORD_METHOD(lldb::SBData, SBValue, GetPointeeData,
 1419   LLDB_RECORD_METHOD(bool, SBValue, SetData, (lldb::SBData &, lldb::SBError &),
 1469   LLDB_RECORD_METHOD(lldb::SBWatchpoint, SBValue, Watch,
 1534   LLDB_RECORD_METHOD(lldb::SBWatchpoint, SBValue, Watch, (bool, bool, bool),
 1543   LLDB_RECORD_METHOD(lldb::SBWatchpoint, SBValue, WatchPointee,

tools/lldb/source/API/SBValueList.cpp

  105   LLDB_RECORD_METHOD(const lldb::SBValueList &,
  128   LLDB_RECORD_METHOD(void, SBValueList, Append, (const lldb::SBValue &),
  143   LLDB_RECORD_METHOD(void, SBValueList, Append, (const lldb::SBValueList &),
  180   LLDB_RECORD_METHOD(lldb::SBValue, SBValueList, FindValueObjectByUID,

tools/lldb/source/API/SBVariablesOptions.cpp

   96   LLDB_RECORD_METHOD(
  125   LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeArguments, (bool),
  141   LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeRecognizedArguments,
  154   LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeLocals, (bool),
  167   LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeStatics, (bool),
  180   LLDB_RECORD_METHOD(void, SBVariablesOptions, SetInScopeOnly, (bool),
  195   LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeRuntimeSupportValues,
  209   LLDB_RECORD_METHOD(void, SBVariablesOptions, SetUseDynamic,

tools/lldb/source/API/SBWatchpoint.cpp

   42   LLDB_RECORD_METHOD(const lldb::SBWatchpoint &,
  144   LLDB_RECORD_METHOD(void, SBWatchpoint, SetEnabled, (bool), enabled);
  202   LLDB_RECORD_METHOD(void, SBWatchpoint, SetIgnoreCount, (uint32_t), n);
  225   LLDB_RECORD_METHOD(void, SBWatchpoint, SetCondition, (const char *),
  238   LLDB_RECORD_METHOD(bool, SBWatchpoint, GetDescription,
  269   LLDB_RECORD_METHOD(void, SBWatchpoint, SetSP, (const lldb::WatchpointSP &),

tools/lldb/unittests/Utility/ReproducerInstrumentationTest.cpp

  143   LLDB_RECORD_METHOD(InstrumentedFoo &,
  151   LLDB_RECORD_METHOD(void, InstrumentedFoo, A, (int), a);
  163   LLDB_RECORD_METHOD(int, InstrumentedFoo, C, (float *), c);
  225   LLDB_RECORD_METHOD(void, InstrumentedBar, SetInstrumentedFoo,
  231   LLDB_RECORD_METHOD(void, InstrumentedBar, SetInstrumentedFoo,