[Lldb-commits] [lldb] r356481 - [lldb] [Reproducer] Move SBRegistry registration into declaring files
Michal Gorny via lldb-commits
lldb-commits at lists.llvm.org
Tue Mar 19 10:13:14 PDT 2019
Author: mgorny
Date: Tue Mar 19 10:13:13 2019
New Revision: 356481
URL: http://llvm.org/viewvc/llvm-project?rev=356481&view=rev
Log:
[lldb] [Reproducer] Move SBRegistry registration into declaring files
Move SBRegistry method registrations from SBReproducer.cpp into files
declaring the individual APIs, in order to reduce the memory consumption
during build and improve maintainability. The current humongous
SBRegistry constructor exhausts all memory on a NetBSD system with 4G
RAM + 4G swap, therefore making it impossible to build LLDB.
Differential Revision: https://reviews.llvm.org/D59427
Modified:
lldb/trunk/include/lldb/Utility/ReproducerInstrumentation.h
lldb/trunk/source/API/SBAddress.cpp
lldb/trunk/source/API/SBAttachInfo.cpp
lldb/trunk/source/API/SBBlock.cpp
lldb/trunk/source/API/SBBreakpoint.cpp
lldb/trunk/source/API/SBBreakpointLocation.cpp
lldb/trunk/source/API/SBBreakpointName.cpp
lldb/trunk/source/API/SBBroadcaster.cpp
lldb/trunk/source/API/SBCommandInterpreter.cpp
lldb/trunk/source/API/SBCommandReturnObject.cpp
lldb/trunk/source/API/SBCommunication.cpp
lldb/trunk/source/API/SBCompileUnit.cpp
lldb/trunk/source/API/SBData.cpp
lldb/trunk/source/API/SBDebugger.cpp
lldb/trunk/source/API/SBDeclaration.cpp
lldb/trunk/source/API/SBError.cpp
lldb/trunk/source/API/SBEvent.cpp
lldb/trunk/source/API/SBExecutionContext.cpp
lldb/trunk/source/API/SBExpressionOptions.cpp
lldb/trunk/source/API/SBFileSpec.cpp
lldb/trunk/source/API/SBFileSpecList.cpp
lldb/trunk/source/API/SBFrame.cpp
lldb/trunk/source/API/SBFunction.cpp
lldb/trunk/source/API/SBHostOS.cpp
lldb/trunk/source/API/SBInstruction.cpp
lldb/trunk/source/API/SBInstructionList.cpp
lldb/trunk/source/API/SBLanguageRuntime.cpp
lldb/trunk/source/API/SBLaunchInfo.cpp
lldb/trunk/source/API/SBLineEntry.cpp
lldb/trunk/source/API/SBListener.cpp
lldb/trunk/source/API/SBMemoryRegionInfo.cpp
lldb/trunk/source/API/SBMemoryRegionInfoList.cpp
lldb/trunk/source/API/SBModule.cpp
lldb/trunk/source/API/SBModuleSpec.cpp
lldb/trunk/source/API/SBPlatform.cpp
lldb/trunk/source/API/SBProcess.cpp
lldb/trunk/source/API/SBProcessInfo.cpp
lldb/trunk/source/API/SBQueue.cpp
lldb/trunk/source/API/SBQueueItem.cpp
lldb/trunk/source/API/SBReproducer.cpp
lldb/trunk/source/API/SBReproducerPrivate.h
lldb/trunk/source/API/SBSection.cpp
lldb/trunk/source/API/SBSourceManager.cpp
lldb/trunk/source/API/SBStream.cpp
lldb/trunk/source/API/SBStringList.cpp
lldb/trunk/source/API/SBStructuredData.cpp
lldb/trunk/source/API/SBSymbol.cpp
lldb/trunk/source/API/SBSymbolContext.cpp
lldb/trunk/source/API/SBSymbolContextList.cpp
lldb/trunk/source/API/SBTarget.cpp
lldb/trunk/source/API/SBThread.cpp
lldb/trunk/source/API/SBThreadCollection.cpp
lldb/trunk/source/API/SBThreadPlan.cpp
lldb/trunk/source/API/SBTrace.cpp
lldb/trunk/source/API/SBTraceOptions.cpp
lldb/trunk/source/API/SBType.cpp
lldb/trunk/source/API/SBTypeCategory.cpp
lldb/trunk/source/API/SBTypeEnumMember.cpp
lldb/trunk/source/API/SBTypeFilter.cpp
lldb/trunk/source/API/SBTypeFormat.cpp
lldb/trunk/source/API/SBTypeNameSpecifier.cpp
lldb/trunk/source/API/SBTypeSummary.cpp
lldb/trunk/source/API/SBTypeSynthetic.cpp
lldb/trunk/source/API/SBUnixSignals.cpp
lldb/trunk/source/API/SBValue.cpp
lldb/trunk/source/API/SBValueList.cpp
lldb/trunk/source/API/SBVariablesOptions.cpp
lldb/trunk/source/API/SBWatchpoint.cpp
lldb/trunk/unittests/Utility/ReproducerInstrumentationTest.cpp
Modified: lldb/trunk/include/lldb/Utility/ReproducerInstrumentation.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Utility/ReproducerInstrumentation.h?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/include/lldb/Utility/ReproducerInstrumentation.h (original)
+++ lldb/trunk/include/lldb/Utility/ReproducerInstrumentation.h Tue Mar 19 10:13:13 2019
@@ -68,19 +68,20 @@ template <typename... Ts> inline std::st
// #define LLDB_REPRO_INSTR_TRACE
#define LLDB_REGISTER_CONSTRUCTOR(Class, Signature) \
- Register<Class * Signature>(&construct<Class Signature>::doit, "", #Class, \
+ R.Register<Class * Signature>(&construct<Class Signature>::doit, "", #Class, \
#Class, #Signature)
#define LLDB_REGISTER_METHOD(Result, Class, Method, Signature) \
- Register( \
+ R.Register( \
&invoke<Result(Class::*) Signature>::method<(&Class::Method)>::doit, \
#Result, #Class, #Method, #Signature)
#define LLDB_REGISTER_METHOD_CONST(Result, Class, Method, Signature) \
- Register(&invoke<Result(Class::*) \
+ R.Register(&invoke<Result(Class::*) \
Signature const>::method_const<(&Class::Method)>::doit, \
#Result, #Class, #Method, #Signature)
#define LLDB_REGISTER_STATIC_METHOD(Result, Class, Method, Signature) \
- Register<Result Signature>(static_cast<Result(*) Signature>(&Class::Method), \
- #Result, #Class, #Method, #Signature)
+ R.Register<Result Signature>( \
+ static_cast<Result(*) Signature>(&Class::Method), #Result, #Class, \
+ #Method, #Signature)
#define LLDB_RECORD_CONSTRUCTOR(Class, Signature, ...) \
LLDB_LOG(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API), "{0} ({1})", \
Modified: lldb/trunk/source/API/SBAddress.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBAddress.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBAddress.cpp (original)
+++ lldb/trunk/source/API/SBAddress.cpp Tue Mar 19 10:13:13 2019
@@ -282,3 +282,41 @@ SBLineEntry SBAddress::GetLineEntry() {
}
return LLDB_RECORD_RESULT(sb_line_entry);
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBAddress>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBAddress, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBAddress, (const lldb::SBAddress &));
+ LLDB_REGISTER_CONSTRUCTOR(SBAddress, (lldb::SBSection, lldb::addr_t));
+ LLDB_REGISTER_CONSTRUCTOR(SBAddress, (lldb::addr_t, lldb::SBTarget &));
+ LLDB_REGISTER_METHOD(const lldb::SBAddress &,
+ SBAddress, operator=,(const lldb::SBAddress &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBAddress, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBAddress, operator bool, ());
+ LLDB_REGISTER_METHOD(void, SBAddress, Clear, ());
+ LLDB_REGISTER_METHOD(void, SBAddress, SetAddress,
+ (lldb::SBSection, lldb::addr_t));
+ LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBAddress, GetFileAddress, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBAddress, GetLoadAddress,
+ (const lldb::SBTarget &));
+ LLDB_REGISTER_METHOD(void, SBAddress, SetLoadAddress,
+ (lldb::addr_t, lldb::SBTarget &));
+ LLDB_REGISTER_METHOD(bool, SBAddress, OffsetAddress, (lldb::addr_t));
+ LLDB_REGISTER_METHOD(lldb::SBSection, SBAddress, GetSection, ());
+ LLDB_REGISTER_METHOD(lldb::addr_t, SBAddress, GetOffset, ());
+ LLDB_REGISTER_METHOD(bool, SBAddress, GetDescription, (lldb::SBStream &));
+ LLDB_REGISTER_METHOD(lldb::SBModule, SBAddress, GetModule, ());
+ LLDB_REGISTER_METHOD(lldb::SBSymbolContext, SBAddress, GetSymbolContext,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBCompileUnit, SBAddress, GetCompileUnit, ());
+ LLDB_REGISTER_METHOD(lldb::SBFunction, SBAddress, GetFunction, ());
+ LLDB_REGISTER_METHOD(lldb::SBBlock, SBAddress, GetBlock, ());
+ LLDB_REGISTER_METHOD(lldb::SBSymbol, SBAddress, GetSymbol, ());
+ LLDB_REGISTER_METHOD(lldb::SBLineEntry, SBAddress, GetLineEntry, ());
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBAttachInfo.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBAttachInfo.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBAttachInfo.cpp (original)
+++ lldb/trunk/source/API/SBAttachInfo.cpp Tue Mar 19 10:13:13 2019
@@ -258,3 +258,51 @@ void SBAttachInfo::SetListener(SBListene
m_opaque_sp->SetListener(listener.GetSP());
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBAttachInfo>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, (lldb::pid_t));
+ LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, (const char *, bool));
+ LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, (const char *, bool, bool));
+ LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, (const lldb::SBAttachInfo &));
+ LLDB_REGISTER_METHOD(lldb::SBAttachInfo &,
+ SBAttachInfo, operator=,(const lldb::SBAttachInfo &));
+ LLDB_REGISTER_METHOD(lldb::pid_t, SBAttachInfo, GetProcessID, ());
+ LLDB_REGISTER_METHOD(void, SBAttachInfo, SetProcessID, (lldb::pid_t));
+ LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetResumeCount, ());
+ LLDB_REGISTER_METHOD(void, SBAttachInfo, SetResumeCount, (uint32_t));
+ LLDB_REGISTER_METHOD(const char *, SBAttachInfo, GetProcessPluginName, ());
+ LLDB_REGISTER_METHOD(void, SBAttachInfo, SetProcessPluginName,
+ (const char *));
+ LLDB_REGISTER_METHOD(void, SBAttachInfo, SetExecutable, (const char *));
+ LLDB_REGISTER_METHOD(void, SBAttachInfo, SetExecutable, (lldb::SBFileSpec));
+ LLDB_REGISTER_METHOD(bool, SBAttachInfo, GetWaitForLaunch, ());
+ LLDB_REGISTER_METHOD(void, SBAttachInfo, SetWaitForLaunch, (bool));
+ LLDB_REGISTER_METHOD(void, SBAttachInfo, SetWaitForLaunch, (bool, bool));
+ LLDB_REGISTER_METHOD(bool, SBAttachInfo, GetIgnoreExisting, ());
+ LLDB_REGISTER_METHOD(void, SBAttachInfo, SetIgnoreExisting, (bool));
+ LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetUserID, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetGroupID, ());
+ LLDB_REGISTER_METHOD(bool, SBAttachInfo, UserIDIsValid, ());
+ LLDB_REGISTER_METHOD(bool, SBAttachInfo, GroupIDIsValid, ());
+ LLDB_REGISTER_METHOD(void, SBAttachInfo, SetUserID, (uint32_t));
+ LLDB_REGISTER_METHOD(void, SBAttachInfo, SetGroupID, (uint32_t));
+ LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetEffectiveUserID, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetEffectiveGroupID, ());
+ LLDB_REGISTER_METHOD(bool, SBAttachInfo, EffectiveUserIDIsValid, ());
+ LLDB_REGISTER_METHOD(bool, SBAttachInfo, EffectiveGroupIDIsValid, ());
+ LLDB_REGISTER_METHOD(void, SBAttachInfo, SetEffectiveUserID, (uint32_t));
+ LLDB_REGISTER_METHOD(void, SBAttachInfo, SetEffectiveGroupID, (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::pid_t, SBAttachInfo, GetParentProcessID, ());
+ LLDB_REGISTER_METHOD(void, SBAttachInfo, SetParentProcessID, (lldb::pid_t));
+ LLDB_REGISTER_METHOD(bool, SBAttachInfo, ParentProcessIDIsValid, ());
+ LLDB_REGISTER_METHOD(lldb::SBListener, SBAttachInfo, GetListener, ());
+ LLDB_REGISTER_METHOD(void, SBAttachInfo, SetListener, (lldb::SBListener &));
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBBlock.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBBlock.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBBlock.cpp (original)
+++ lldb/trunk/source/API/SBBlock.cpp Tue Mar 19 10:13:13 2019
@@ -351,3 +351,42 @@ lldb::SBValueList SBBlock::GetVariables(
}
return LLDB_RECORD_RESULT(value_list);
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBBlock>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBBlock, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBBlock, (const lldb::SBBlock &));
+ LLDB_REGISTER_METHOD(const lldb::SBBlock &,
+ SBBlock, operator=,(const lldb::SBBlock &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBBlock, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBBlock, operator bool, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBBlock, IsInlined, ());
+ LLDB_REGISTER_METHOD_CONST(const char *, SBBlock, GetInlinedName, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBBlock,
+ GetInlinedCallSiteFile, ());
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBBlock, GetInlinedCallSiteLine, ());
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBBlock, GetInlinedCallSiteColumn, ());
+ LLDB_REGISTER_METHOD(lldb::SBBlock, SBBlock, GetParent, ());
+ LLDB_REGISTER_METHOD(lldb::SBBlock, SBBlock, GetContainingInlinedBlock, ());
+ LLDB_REGISTER_METHOD(lldb::SBBlock, SBBlock, GetSibling, ());
+ LLDB_REGISTER_METHOD(lldb::SBBlock, SBBlock, GetFirstChild, ());
+ LLDB_REGISTER_METHOD(bool, SBBlock, GetDescription, (lldb::SBStream &));
+ LLDB_REGISTER_METHOD(uint32_t, SBBlock, GetNumRanges, ());
+ LLDB_REGISTER_METHOD(lldb::SBAddress, SBBlock, GetRangeStartAddress,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBAddress, SBBlock, GetRangeEndAddress,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(uint32_t, SBBlock, GetRangeIndexForBlockAddress,
+ (lldb::SBAddress));
+ LLDB_REGISTER_METHOD(
+ lldb::SBValueList, SBBlock, GetVariables,
+ (lldb::SBFrame &, bool, bool, bool, lldb::DynamicValueType));
+ LLDB_REGISTER_METHOD(lldb::SBValueList, SBBlock, GetVariables,
+ (lldb::SBTarget &, bool, bool, bool));
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBBreakpoint.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBBreakpoint.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBBreakpoint.cpp (original)
+++ lldb/trunk/source/API/SBBreakpoint.cpp Tue Mar 19 10:13:13 2019
@@ -932,3 +932,107 @@ void SBBreakpointList::CopyToBreakpointI
if (m_opaque_sp)
m_opaque_sp->CopyToBreakpointIDList(bp_id_list);
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBBreakpoint>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBBreakpoint, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBBreakpoint, (const lldb::SBBreakpoint &));
+ LLDB_REGISTER_CONSTRUCTOR(SBBreakpoint, (const lldb::BreakpointSP &));
+ LLDB_REGISTER_METHOD(const lldb::SBBreakpoint &,
+ SBBreakpoint, operator=,(const lldb::SBBreakpoint &));
+ LLDB_REGISTER_METHOD(bool,
+ SBBreakpoint, operator==,(const lldb::SBBreakpoint &));
+ LLDB_REGISTER_METHOD(bool,
+ SBBreakpoint, operator!=,(const lldb::SBBreakpoint &));
+ LLDB_REGISTER_METHOD_CONST(lldb::break_id_t, SBBreakpoint, GetID, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBBreakpoint, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBBreakpoint, operator bool, ());
+ LLDB_REGISTER_METHOD(void, SBBreakpoint, ClearAllBreakpointSites, ());
+ LLDB_REGISTER_METHOD(lldb::SBBreakpointLocation, SBBreakpoint,
+ FindLocationByAddress, (lldb::addr_t));
+ LLDB_REGISTER_METHOD(lldb::break_id_t, SBBreakpoint,
+ FindLocationIDByAddress, (lldb::addr_t));
+ LLDB_REGISTER_METHOD(lldb::SBBreakpointLocation, SBBreakpoint,
+ FindLocationByID, (lldb::break_id_t));
+ LLDB_REGISTER_METHOD(lldb::SBBreakpointLocation, SBBreakpoint,
+ GetLocationAtIndex, (uint32_t));
+ LLDB_REGISTER_METHOD(void, SBBreakpoint, SetEnabled, (bool));
+ LLDB_REGISTER_METHOD(bool, SBBreakpoint, IsEnabled, ());
+ LLDB_REGISTER_METHOD(void, SBBreakpoint, SetOneShot, (bool));
+ LLDB_REGISTER_METHOD_CONST(bool, SBBreakpoint, IsOneShot, ());
+ LLDB_REGISTER_METHOD(bool, SBBreakpoint, IsInternal, ());
+ LLDB_REGISTER_METHOD(void, SBBreakpoint, SetIgnoreCount, (uint32_t));
+ LLDB_REGISTER_METHOD(void, SBBreakpoint, SetCondition, (const char *));
+ LLDB_REGISTER_METHOD(const char *, SBBreakpoint, GetCondition, ());
+ LLDB_REGISTER_METHOD(void, SBBreakpoint, SetAutoContinue, (bool));
+ LLDB_REGISTER_METHOD(bool, SBBreakpoint, GetAutoContinue, ());
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpoint, GetHitCount, ());
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpoint, GetIgnoreCount, ());
+ LLDB_REGISTER_METHOD(void, SBBreakpoint, SetThreadID, (lldb::tid_t));
+ LLDB_REGISTER_METHOD(lldb::tid_t, SBBreakpoint, GetThreadID, ());
+ LLDB_REGISTER_METHOD(void, SBBreakpoint, SetThreadIndex, (uint32_t));
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpoint, GetThreadIndex, ());
+ LLDB_REGISTER_METHOD(void, SBBreakpoint, SetThreadName, (const char *));
+ LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpoint, GetThreadName, ());
+ LLDB_REGISTER_METHOD(void, SBBreakpoint, SetQueueName, (const char *));
+ LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpoint, GetQueueName, ());
+ LLDB_REGISTER_METHOD_CONST(size_t, SBBreakpoint, GetNumResolvedLocations,
+ ());
+ LLDB_REGISTER_METHOD_CONST(size_t, SBBreakpoint, GetNumLocations, ());
+ LLDB_REGISTER_METHOD(void, SBBreakpoint, SetCommandLineCommands,
+ (lldb::SBStringList &));
+ LLDB_REGISTER_METHOD(bool, SBBreakpoint, GetCommandLineCommands,
+ (lldb::SBStringList &));
+ LLDB_REGISTER_METHOD(bool, SBBreakpoint, GetDescription,
+ (lldb::SBStream &));
+ LLDB_REGISTER_METHOD(bool, SBBreakpoint, GetDescription,
+ (lldb::SBStream &, bool));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpoint, AddLocation,
+ (lldb::SBAddress &));
+ LLDB_REGISTER_METHOD(void, SBBreakpoint, SetScriptCallbackFunction,
+ (const char *));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpoint, SetScriptCallbackBody,
+ (const char *));
+ LLDB_REGISTER_METHOD(bool, SBBreakpoint, AddName, (const char *));
+ LLDB_REGISTER_METHOD(void, SBBreakpoint, RemoveName, (const char *));
+ LLDB_REGISTER_METHOD(bool, SBBreakpoint, MatchesName, (const char *));
+ LLDB_REGISTER_METHOD(void, SBBreakpoint, GetNames, (lldb::SBStringList &));
+ LLDB_REGISTER_STATIC_METHOD(bool, SBBreakpoint, EventIsBreakpointEvent,
+ (const lldb::SBEvent &));
+ LLDB_REGISTER_STATIC_METHOD(lldb::BreakpointEventType, SBBreakpoint,
+ GetBreakpointEventTypeFromEvent,
+ (const lldb::SBEvent &));
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBBreakpoint, SBBreakpoint,
+ GetBreakpointFromEvent,
+ (const lldb::SBEvent &));
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBBreakpointLocation, SBBreakpoint,
+ GetBreakpointLocationAtIndexFromEvent,
+ (const lldb::SBEvent &, uint32_t));
+ LLDB_REGISTER_STATIC_METHOD(uint32_t, SBBreakpoint,
+ GetNumBreakpointLocationsFromEvent,
+ (const lldb::SBEvent &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBBreakpoint, IsHardware, ());
+}
+
+template <>
+void RegisterMethods<SBBreakpointList>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBBreakpointList, (lldb::SBTarget &));
+ LLDB_REGISTER_METHOD_CONST(size_t, SBBreakpointList, GetSize, ());
+ LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBBreakpointList,
+ GetBreakpointAtIndex, (size_t));
+ LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBBreakpointList,
+ FindBreakpointByID, (lldb::break_id_t));
+ LLDB_REGISTER_METHOD(void, SBBreakpointList, Append,
+ (const lldb::SBBreakpoint &));
+ LLDB_REGISTER_METHOD(void, SBBreakpointList, AppendByID,
+ (lldb::break_id_t));
+ LLDB_REGISTER_METHOD(bool, SBBreakpointList, AppendIfUnique,
+ (const lldb::SBBreakpoint &));
+ LLDB_REGISTER_METHOD(void, SBBreakpointList, Clear, ());
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBBreakpointLocation.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBBreakpointLocation.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBBreakpointLocation.cpp (original)
+++ lldb/trunk/source/API/SBBreakpointLocation.cpp Tue Mar 19 10:13:13 2019
@@ -452,3 +452,66 @@ SBBreakpoint SBBreakpointLocation::GetBr
return LLDB_RECORD_RESULT(sb_bp);
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBBreakpointLocation>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBBreakpointLocation, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBBreakpointLocation,
+ (const lldb::BreakpointLocationSP &));
+ LLDB_REGISTER_CONSTRUCTOR(SBBreakpointLocation,
+ (const lldb::SBBreakpointLocation &));
+ LLDB_REGISTER_METHOD(
+ const lldb::SBBreakpointLocation &,
+ SBBreakpointLocation, operator=,(const lldb::SBBreakpointLocation &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointLocation, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointLocation, operator bool, ());
+ LLDB_REGISTER_METHOD(lldb::SBAddress, SBBreakpointLocation, GetAddress, ());
+ LLDB_REGISTER_METHOD(lldb::addr_t, SBBreakpointLocation, GetLoadAddress,
+ ());
+ LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetEnabled, (bool));
+ LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, IsEnabled, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBBreakpointLocation, GetHitCount, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBBreakpointLocation, GetIgnoreCount, ());
+ LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetIgnoreCount,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetCondition,
+ (const char *));
+ LLDB_REGISTER_METHOD(const char *, SBBreakpointLocation, GetCondition, ());
+ LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetAutoContinue, (bool));
+ LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, GetAutoContinue, ());
+ LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetScriptCallbackFunction,
+ (const char *));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpointLocation,
+ SetScriptCallbackBody, (const char *));
+ LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetCommandLineCommands,
+ (lldb::SBStringList &));
+ LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, GetCommandLineCommands,
+ (lldb::SBStringList &));
+ LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetThreadID,
+ (lldb::tid_t));
+ LLDB_REGISTER_METHOD(lldb::tid_t, SBBreakpointLocation, GetThreadID, ());
+ LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetThreadIndex,
+ (uint32_t));
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpointLocation, GetThreadIndex,
+ ());
+ LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetThreadName,
+ (const char *));
+ LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointLocation,
+ GetThreadName, ());
+ LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetQueueName,
+ (const char *));
+ LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointLocation, GetQueueName,
+ ());
+ LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, IsResolved, ());
+ LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, GetDescription,
+ (lldb::SBStream &, lldb::DescriptionLevel));
+ LLDB_REGISTER_METHOD(lldb::break_id_t, SBBreakpointLocation, GetID, ());
+ LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBBreakpointLocation,
+ GetBreakpoint, ());
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBBreakpointName.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBBreakpointName.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBBreakpointName.cpp (original)
+++ lldb/trunk/source/API/SBBreakpointName.cpp Tue Mar 19 10:13:13 2019
@@ -676,3 +676,69 @@ lldb_private::BreakpointName *SBBreakpoi
return m_impl_up->GetBreakpointName();
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBBreakpointName>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBBreakpointName, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBBreakpointName,
+ (lldb::SBTarget &, const char *));
+ LLDB_REGISTER_CONSTRUCTOR(SBBreakpointName,
+ (lldb::SBBreakpoint &, const char *));
+ LLDB_REGISTER_CONSTRUCTOR(SBBreakpointName,
+ (const lldb::SBBreakpointName &));
+ LLDB_REGISTER_METHOD(
+ const lldb::SBBreakpointName &,
+ SBBreakpointName, operator=,(const lldb::SBBreakpointName &));
+ LLDB_REGISTER_METHOD(
+ bool, SBBreakpointName, operator==,(const lldb::SBBreakpointName &));
+ LLDB_REGISTER_METHOD(
+ bool, SBBreakpointName, operator!=,(const lldb::SBBreakpointName &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointName, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointName, operator bool, ());
+ LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointName, GetName, ());
+ LLDB_REGISTER_METHOD(void, SBBreakpointName, SetEnabled, (bool));
+ LLDB_REGISTER_METHOD(bool, SBBreakpointName, IsEnabled, ());
+ LLDB_REGISTER_METHOD(void, SBBreakpointName, SetOneShot, (bool));
+ LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointName, IsOneShot, ());
+ LLDB_REGISTER_METHOD(void, SBBreakpointName, SetIgnoreCount, (uint32_t));
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpointName, GetIgnoreCount, ());
+ LLDB_REGISTER_METHOD(void, SBBreakpointName, SetCondition, (const char *));
+ LLDB_REGISTER_METHOD(const char *, SBBreakpointName, GetCondition, ());
+ LLDB_REGISTER_METHOD(void, SBBreakpointName, SetAutoContinue, (bool));
+ LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetAutoContinue, ());
+ LLDB_REGISTER_METHOD(void, SBBreakpointName, SetThreadID, (lldb::tid_t));
+ LLDB_REGISTER_METHOD(lldb::tid_t, SBBreakpointName, GetThreadID, ());
+ LLDB_REGISTER_METHOD(void, SBBreakpointName, SetThreadIndex, (uint32_t));
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpointName, GetThreadIndex, ());
+ LLDB_REGISTER_METHOD(void, SBBreakpointName, SetThreadName, (const char *));
+ LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointName, GetThreadName,
+ ());
+ LLDB_REGISTER_METHOD(void, SBBreakpointName, SetQueueName, (const char *));
+ LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointName, GetQueueName,
+ ());
+ LLDB_REGISTER_METHOD(void, SBBreakpointName, SetCommandLineCommands,
+ (lldb::SBStringList &));
+ LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetCommandLineCommands,
+ (lldb::SBStringList &));
+ LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointName, GetHelpString,
+ ());
+ LLDB_REGISTER_METHOD(void, SBBreakpointName, SetHelpString, (const char *));
+ LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetDescription,
+ (lldb::SBStream &));
+ LLDB_REGISTER_METHOD(void, SBBreakpointName, SetScriptCallbackFunction,
+ (const char *));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpointName, SetScriptCallbackBody,
+ (const char *));
+ LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointName, GetAllowList, ());
+ LLDB_REGISTER_METHOD(void, SBBreakpointName, SetAllowList, (bool));
+ LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetAllowDelete, ());
+ LLDB_REGISTER_METHOD(void, SBBreakpointName, SetAllowDelete, (bool));
+ LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetAllowDisable, ());
+ LLDB_REGISTER_METHOD(void, SBBreakpointName, SetAllowDisable, (bool));
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBBroadcaster.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBBroadcaster.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBBroadcaster.cpp (original)
+++ lldb/trunk/source/API/SBBroadcaster.cpp Tue Mar 19 10:13:13 2019
@@ -174,3 +174,41 @@ bool SBBroadcaster::operator<(const SBBr
return m_opaque_ptr < rhs.m_opaque_ptr;
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBBroadcaster>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBBroadcaster, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBBroadcaster, (const char *));
+ LLDB_REGISTER_CONSTRUCTOR(SBBroadcaster, (const lldb::SBBroadcaster &));
+ LLDB_REGISTER_METHOD(
+ const lldb::SBBroadcaster &,
+ SBBroadcaster, operator=,(const lldb::SBBroadcaster &));
+ LLDB_REGISTER_METHOD(void, SBBroadcaster, BroadcastEventByType,
+ (uint32_t, bool));
+ LLDB_REGISTER_METHOD(void, SBBroadcaster, BroadcastEvent,
+ (const lldb::SBEvent &, bool));
+ LLDB_REGISTER_METHOD(void, SBBroadcaster, AddInitialEventsToListener,
+ (const lldb::SBListener &, uint32_t));
+ LLDB_REGISTER_METHOD(uint32_t, SBBroadcaster, AddListener,
+ (const lldb::SBListener &, uint32_t));
+ LLDB_REGISTER_METHOD_CONST(const char *, SBBroadcaster, GetName, ());
+ LLDB_REGISTER_METHOD(bool, SBBroadcaster, EventTypeHasListeners,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(bool, SBBroadcaster, RemoveListener,
+ (const lldb::SBListener &, uint32_t));
+ LLDB_REGISTER_METHOD_CONST(bool, SBBroadcaster, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBBroadcaster, operator bool, ());
+ LLDB_REGISTER_METHOD(void, SBBroadcaster, Clear, ());
+ LLDB_REGISTER_METHOD_CONST(
+ bool, SBBroadcaster, operator==,(const lldb::SBBroadcaster &));
+ LLDB_REGISTER_METHOD_CONST(
+ bool, SBBroadcaster, operator!=,(const lldb::SBBroadcaster &));
+ LLDB_REGISTER_METHOD_CONST(
+ bool, SBBroadcaster, operator<,(const lldb::SBBroadcaster &));
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBCommandInterpreter.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBCommandInterpreter.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBCommandInterpreter.cpp (original)
+++ lldb/trunk/source/API/SBCommandInterpreter.cpp Tue Mar 19 10:13:13 2019
@@ -801,3 +801,143 @@ void SBCommand::SetFlags(uint32_t flags)
if (IsValid())
m_opaque_sp->GetFlags().Set(flags);
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBCommandInterpreterRunOptions>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBCommandInterpreterRunOptions, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
+ GetStopOnContinue, ());
+ LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions,
+ SetStopOnContinue, (bool));
+ LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
+ GetStopOnError, ());
+ LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnError,
+ (bool));
+ LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
+ GetStopOnCrash, ());
+ LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnCrash,
+ (bool));
+ LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
+ GetEchoCommands, ());
+ LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetEchoCommands,
+ (bool));
+ LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
+ GetEchoCommentCommands, ());
+ LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions,
+ SetEchoCommentCommands, (bool));
+ LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
+ GetPrintResults, ());
+ LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetPrintResults,
+ (bool));
+ LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
+ GetAddToHistory, ());
+ LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetAddToHistory,
+ (bool));
+ LLDB_REGISTER_CONSTRUCTOR(SBCommandInterpreter,
+ (lldb_private::CommandInterpreter *));
+ LLDB_REGISTER_CONSTRUCTOR(SBCommandInterpreter,
+ (const lldb::SBCommandInterpreter &));
+ LLDB_REGISTER_METHOD(
+ const lldb::SBCommandInterpreter &,
+ SBCommandInterpreter, operator=,(const lldb::SBCommandInterpreter &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreter, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreter, operator bool, ());
+ LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, CommandExists,
+ (const char *));
+ LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, AliasExists,
+ (const char *));
+ LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, IsActive, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreter, WasInterrupted, ());
+ LLDB_REGISTER_METHOD(const char *, SBCommandInterpreter,
+ GetIOHandlerControlSequence, (char));
+ LLDB_REGISTER_METHOD(lldb::ReturnStatus, SBCommandInterpreter,
+ HandleCommand,
+ (const char *, lldb::SBCommandReturnObject &, bool));
+ LLDB_REGISTER_METHOD(lldb::ReturnStatus, SBCommandInterpreter,
+ HandleCommand,
+ (const char *, lldb::SBExecutionContext &,
+ lldb::SBCommandReturnObject &, bool));
+ LLDB_REGISTER_METHOD(void, SBCommandInterpreter, HandleCommandsFromFile,
+ (lldb::SBFileSpec &, lldb::SBExecutionContext &,
+ lldb::SBCommandInterpreterRunOptions &,
+ lldb::SBCommandReturnObject));
+ LLDB_REGISTER_METHOD(int, SBCommandInterpreter, HandleCompletion,
+ (const char *, const char *, const char *, int, int,
+ lldb::SBStringList &));
+ LLDB_REGISTER_METHOD(int, SBCommandInterpreter,
+ HandleCompletionWithDescriptions,
+ (const char *, const char *, const char *, int, int,
+ lldb::SBStringList &, lldb::SBStringList &));
+ LLDB_REGISTER_METHOD(int, SBCommandInterpreter,
+ HandleCompletionWithDescriptions,
+ (const char *, uint32_t, int, int,
+ lldb::SBStringList &, lldb::SBStringList &));
+ LLDB_REGISTER_METHOD(
+ int, SBCommandInterpreter, HandleCompletion,
+ (const char *, uint32_t, int, int, lldb::SBStringList &));
+ LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasCommands, ());
+ LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasAliases, ());
+ LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasAliasOptions, ());
+ LLDB_REGISTER_METHOD(lldb::SBProcess, SBCommandInterpreter, GetProcess, ());
+ LLDB_REGISTER_METHOD(lldb::SBDebugger, SBCommandInterpreter, GetDebugger,
+ ());
+ LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, GetPromptOnQuit, ());
+ LLDB_REGISTER_METHOD(void, SBCommandInterpreter, SetPromptOnQuit, (bool));
+ LLDB_REGISTER_METHOD(void, SBCommandInterpreter, AllowExitCodeOnQuit,
+ (bool));
+ LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasCustomQuitExitCode, ());
+ LLDB_REGISTER_METHOD(int, SBCommandInterpreter, GetQuitStatus, ());
+ LLDB_REGISTER_METHOD(void, SBCommandInterpreter, ResolveCommand,
+ (const char *, lldb::SBCommandReturnObject &));
+ LLDB_REGISTER_METHOD(void, SBCommandInterpreter,
+ SourceInitFileInHomeDirectory,
+ (lldb::SBCommandReturnObject &));
+ LLDB_REGISTER_METHOD(void, SBCommandInterpreter,
+ SourceInitFileInCurrentWorkingDirectory,
+ (lldb::SBCommandReturnObject &));
+ LLDB_REGISTER_METHOD(lldb::SBBroadcaster, SBCommandInterpreter,
+ GetBroadcaster, ());
+ LLDB_REGISTER_STATIC_METHOD(const char *, SBCommandInterpreter,
+ GetBroadcasterClass, ());
+ LLDB_REGISTER_STATIC_METHOD(const char *, SBCommandInterpreter,
+ GetArgumentTypeAsCString,
+ (const lldb::CommandArgumentType));
+ LLDB_REGISTER_STATIC_METHOD(const char *, SBCommandInterpreter,
+ GetArgumentDescriptionAsCString,
+ (const lldb::CommandArgumentType));
+ LLDB_REGISTER_STATIC_METHOD(bool, SBCommandInterpreter,
+ EventIsCommandInterpreterEvent,
+ (const lldb::SBEvent &));
+ LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommandInterpreter,
+ AddMultiwordCommand, (const char *, const char *));
+ LLDB_REGISTER_METHOD(
+ lldb::SBCommand, SBCommandInterpreter, AddCommand,
+ (const char *, lldb::SBCommandPluginInterface *, const char *));
+ LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommandInterpreter, AddCommand,
+ (const char *, lldb::SBCommandPluginInterface *,
+ const char *, const char *));
+ LLDB_REGISTER_CONSTRUCTOR(SBCommand, ());
+ LLDB_REGISTER_METHOD(bool, SBCommand, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBCommand, operator bool, ());
+ LLDB_REGISTER_METHOD(const char *, SBCommand, GetName, ());
+ LLDB_REGISTER_METHOD(const char *, SBCommand, GetHelp, ());
+ LLDB_REGISTER_METHOD(const char *, SBCommand, GetHelpLong, ());
+ LLDB_REGISTER_METHOD(void, SBCommand, SetHelp, (const char *));
+ LLDB_REGISTER_METHOD(void, SBCommand, SetHelpLong, (const char *));
+ LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommand, AddMultiwordCommand,
+ (const char *, const char *));
+ LLDB_REGISTER_METHOD(
+ lldb::SBCommand, SBCommand, AddCommand,
+ (const char *, lldb::SBCommandPluginInterface *, const char *));
+ LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommand, AddCommand,
+ (const char *, lldb::SBCommandPluginInterface *,
+ const char *, const char *));
+ LLDB_REGISTER_METHOD(uint32_t, SBCommand, GetFlags, ());
+ LLDB_REGISTER_METHOD(void, SBCommand, SetFlags, (uint32_t));
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBCommandReturnObject.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBCommandReturnObject.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBCommandReturnObject.cpp (original)
+++ lldb/trunk/source/API/SBCommandReturnObject.cpp Tue Mar 19 10:13:13 2019
@@ -332,3 +332,60 @@ void SBCommandReturnObject::SetError(con
if (m_opaque_up && error_cstr)
m_opaque_up->SetError(error_cstr);
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBCommandReturnObject>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBCommandReturnObject, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBCommandReturnObject,
+ (const lldb::SBCommandReturnObject &));
+ LLDB_REGISTER_CONSTRUCTOR(SBCommandReturnObject,
+ (lldb_private::CommandReturnObject *));
+ LLDB_REGISTER_METHOD(lldb_private::CommandReturnObject *,
+ SBCommandReturnObject, Release, ());
+ LLDB_REGISTER_METHOD(
+ const lldb::SBCommandReturnObject &,
+ SBCommandReturnObject, operator=,(const lldb::SBCommandReturnObject &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBCommandReturnObject, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBCommandReturnObject, operator bool, ());
+ LLDB_REGISTER_METHOD(const char *, SBCommandReturnObject, GetOutput, ());
+ LLDB_REGISTER_METHOD(const char *, SBCommandReturnObject, GetError, ());
+ LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, GetOutputSize, ());
+ LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, GetErrorSize, ());
+ LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, PutOutput, (FILE *));
+ LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, PutError, (FILE *));
+ LLDB_REGISTER_METHOD(void, SBCommandReturnObject, Clear, ());
+ LLDB_REGISTER_METHOD(lldb::ReturnStatus, SBCommandReturnObject, GetStatus,
+ ());
+ LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetStatus,
+ (lldb::ReturnStatus));
+ LLDB_REGISTER_METHOD(bool, SBCommandReturnObject, Succeeded, ());
+ LLDB_REGISTER_METHOD(bool, SBCommandReturnObject, HasResult, ());
+ LLDB_REGISTER_METHOD(void, SBCommandReturnObject, AppendMessage,
+ (const char *));
+ LLDB_REGISTER_METHOD(void, SBCommandReturnObject, AppendWarning,
+ (const char *));
+ LLDB_REGISTER_METHOD(bool, SBCommandReturnObject, GetDescription,
+ (lldb::SBStream &));
+ LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
+ (FILE *));
+ LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
+ (FILE *));
+ LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
+ (FILE *, bool));
+ LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
+ (FILE *, bool));
+ LLDB_REGISTER_METHOD(void, SBCommandReturnObject, PutCString,
+ (const char *, int));
+ LLDB_REGISTER_METHOD(const char *, SBCommandReturnObject, GetOutput,
+ (bool));
+ LLDB_REGISTER_METHOD(const char *, SBCommandReturnObject, GetError, (bool));
+ LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetError,
+ (lldb::SBError &, const char *));
+ LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetError, (const char *));
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBCommunication.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBCommunication.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBCommunication.cpp (original)
+++ lldb/trunk/source/API/SBCommunication.cpp Tue Mar 19 10:13:13 2019
@@ -183,3 +183,33 @@ const char *SBCommunication::GetBroadcas
return Communication::GetStaticBroadcasterClass().AsCString();
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBCommunication>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBCommunication, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBCommunication, (const char *));
+ LLDB_REGISTER_METHOD_CONST(bool, SBCommunication, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBCommunication, operator bool, ());
+ LLDB_REGISTER_METHOD(bool, SBCommunication, GetCloseOnEOF, ());
+ LLDB_REGISTER_METHOD(void, SBCommunication, SetCloseOnEOF, (bool));
+ LLDB_REGISTER_METHOD(lldb::ConnectionStatus, SBCommunication, Connect,
+ (const char *));
+ LLDB_REGISTER_METHOD(lldb::ConnectionStatus, SBCommunication,
+ AdoptFileDesriptor, (int, bool));
+ LLDB_REGISTER_METHOD(lldb::ConnectionStatus, SBCommunication, Disconnect,
+ ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBCommunication, IsConnected, ());
+ LLDB_REGISTER_METHOD(bool, SBCommunication, ReadThreadStart, ());
+ LLDB_REGISTER_METHOD(bool, SBCommunication, ReadThreadStop, ());
+ LLDB_REGISTER_METHOD(bool, SBCommunication, ReadThreadIsRunning, ());
+ LLDB_REGISTER_METHOD(lldb::SBBroadcaster, SBCommunication, GetBroadcaster,
+ ());
+ LLDB_REGISTER_STATIC_METHOD(const char *, SBCommunication,
+ GetBroadcasterClass, ());
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBCompileUnit.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBCompileUnit.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBCompileUnit.cpp (original)
+++ lldb/trunk/source/API/SBCompileUnit.cpp Tue Mar 19 10:13:13 2019
@@ -237,3 +237,42 @@ bool SBCompileUnit::GetDescription(SBStr
return true;
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBCompileUnit>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBCompileUnit, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBCompileUnit, (const lldb::SBCompileUnit &));
+ LLDB_REGISTER_METHOD(
+ const lldb::SBCompileUnit &,
+ SBCompileUnit, operator=,(const lldb::SBCompileUnit &));
+ LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBCompileUnit, GetFileSpec,
+ ());
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBCompileUnit, GetNumLineEntries, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBLineEntry, SBCompileUnit,
+ GetLineEntryAtIndex, (uint32_t));
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBCompileUnit, FindLineEntryIndex,
+ (uint32_t, uint32_t, lldb::SBFileSpec *));
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBCompileUnit, FindLineEntryIndex,
+ (uint32_t, uint32_t, lldb::SBFileSpec *, bool));
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBCompileUnit, GetNumSupportFiles, ());
+ LLDB_REGISTER_METHOD(lldb::SBTypeList, SBCompileUnit, GetTypes, (uint32_t));
+ LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBCompileUnit,
+ GetSupportFileAtIndex, (uint32_t));
+ LLDB_REGISTER_METHOD(uint32_t, SBCompileUnit, FindSupportFileIndex,
+ (uint32_t, const lldb::SBFileSpec &, bool));
+ LLDB_REGISTER_METHOD(lldb::LanguageType, SBCompileUnit, GetLanguage, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBCompileUnit, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBCompileUnit, operator bool, ());
+ LLDB_REGISTER_METHOD_CONST(
+ bool, SBCompileUnit, operator==,(const lldb::SBCompileUnit &));
+ LLDB_REGISTER_METHOD_CONST(
+ bool, SBCompileUnit, operator!=,(const lldb::SBCompileUnit &));
+ LLDB_REGISTER_METHOD(bool, SBCompileUnit, GetDescription,
+ (lldb::SBStream &));
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBData.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBData.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBData.cpp (original)
+++ lldb/trunk/source/API/SBData.cpp Tue Mar 19 10:13:13 2019
@@ -646,3 +646,79 @@ bool SBData::SetDataFromDoubleArray(doub
return true;
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBData>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBData, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBData, (const lldb::SBData &));
+ LLDB_REGISTER_METHOD(const lldb::SBData &,
+ SBData, operator=,(const lldb::SBData &));
+ LLDB_REGISTER_METHOD(bool, SBData, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBData, operator bool, ());
+ LLDB_REGISTER_METHOD(uint8_t, SBData, GetAddressByteSize, ());
+ LLDB_REGISTER_METHOD(void, SBData, SetAddressByteSize, (uint8_t));
+ LLDB_REGISTER_METHOD(void, SBData, Clear, ());
+ LLDB_REGISTER_METHOD(size_t, SBData, GetByteSize, ());
+ LLDB_REGISTER_METHOD(lldb::ByteOrder, SBData, GetByteOrder, ());
+ LLDB_REGISTER_METHOD(void, SBData, SetByteOrder, (lldb::ByteOrder));
+ LLDB_REGISTER_METHOD(float, SBData, GetFloat,
+ (lldb::SBError &, lldb::offset_t));
+ LLDB_REGISTER_METHOD(double, SBData, GetDouble,
+ (lldb::SBError &, lldb::offset_t));
+ LLDB_REGISTER_METHOD(long double, SBData, GetLongDouble,
+ (lldb::SBError &, lldb::offset_t));
+ LLDB_REGISTER_METHOD(lldb::addr_t, SBData, GetAddress,
+ (lldb::SBError &, lldb::offset_t));
+ LLDB_REGISTER_METHOD(uint8_t, SBData, GetUnsignedInt8,
+ (lldb::SBError &, lldb::offset_t));
+ LLDB_REGISTER_METHOD(uint16_t, SBData, GetUnsignedInt16,
+ (lldb::SBError &, lldb::offset_t));
+ LLDB_REGISTER_METHOD(uint32_t, SBData, GetUnsignedInt32,
+ (lldb::SBError &, lldb::offset_t));
+ LLDB_REGISTER_METHOD(uint64_t, SBData, GetUnsignedInt64,
+ (lldb::SBError &, lldb::offset_t));
+ LLDB_REGISTER_METHOD(int8_t, SBData, GetSignedInt8,
+ (lldb::SBError &, lldb::offset_t));
+ LLDB_REGISTER_METHOD(int16_t, SBData, GetSignedInt16,
+ (lldb::SBError &, lldb::offset_t));
+ LLDB_REGISTER_METHOD(int32_t, SBData, GetSignedInt32,
+ (lldb::SBError &, lldb::offset_t));
+ LLDB_REGISTER_METHOD(int64_t, SBData, GetSignedInt64,
+ (lldb::SBError &, lldb::offset_t));
+ LLDB_REGISTER_METHOD(const char *, SBData, GetString,
+ (lldb::SBError &, lldb::offset_t));
+ LLDB_REGISTER_METHOD(bool, SBData, GetDescription,
+ (lldb::SBStream &, lldb::addr_t));
+ LLDB_REGISTER_METHOD(bool, SBData, Append, (const lldb::SBData &));
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromCString,
+ (lldb::ByteOrder, uint32_t, const char *));
+ LLDB_REGISTER_STATIC_METHOD(
+ lldb::SBData, SBData, CreateDataFromUInt64Array,
+ (lldb::ByteOrder, uint32_t, uint64_t *, size_t));
+ LLDB_REGISTER_STATIC_METHOD(
+ lldb::SBData, SBData, CreateDataFromUInt32Array,
+ (lldb::ByteOrder, uint32_t, uint32_t *, size_t));
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromSInt64Array,
+ (lldb::ByteOrder, uint32_t, int64_t *, size_t));
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromSInt32Array,
+ (lldb::ByteOrder, uint32_t, int32_t *, size_t));
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromDoubleArray,
+ (lldb::ByteOrder, uint32_t, double *, size_t));
+ LLDB_REGISTER_METHOD(bool, SBData, SetDataFromCString, (const char *));
+ LLDB_REGISTER_METHOD(bool, SBData, SetDataFromUInt64Array,
+ (uint64_t *, size_t));
+ LLDB_REGISTER_METHOD(bool, SBData, SetDataFromUInt32Array,
+ (uint32_t *, size_t));
+ LLDB_REGISTER_METHOD(bool, SBData, SetDataFromSInt64Array,
+ (int64_t *, size_t));
+ LLDB_REGISTER_METHOD(bool, SBData, SetDataFromSInt32Array,
+ (int32_t *, size_t));
+ LLDB_REGISTER_METHOD(bool, SBData, SetDataFromDoubleArray,
+ (double *, size_t));
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBDebugger.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBDebugger.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBDebugger.cpp (original)
+++ lldb/trunk/source/API/SBDebugger.cpp Tue Mar 19 10:13:13 2019
@@ -1539,3 +1539,186 @@ void SBDebugger::SetLoggingCallback(lldb
return m_opaque_sp->SetLoggingCallback(log_callback, baton);
}
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBInputReader>(Registry &R) {
+ LLDB_REGISTER_METHOD(void, SBInputReader, SetIsDone, (bool));
+ LLDB_REGISTER_METHOD_CONST(bool, SBInputReader, IsActive, ());
+}
+
+static void SetFileHandleRedirect(SBDebugger *, FILE *, bool) {
+ // Do nothing.
+}
+
+static bool GetDefaultArchitectureRedirect(char *arch_name,
+ size_t arch_name_len) {
+ // The function is writing to its argument. Without the redirect it would
+ // write into the replay buffer.
+ char buffer[1024];
+ return SBDebugger::GetDefaultArchitecture(buffer, arch_name_len);
+}
+
+template <>
+void RegisterMethods<SBDebugger>(Registry &R) {
+ // Custom implementation.
+ R.Register(&invoke<void (SBDebugger::*)(
+ FILE *, bool)>::method<&SBDebugger::SetErrorFileHandle>::doit,
+ &SetFileHandleRedirect);
+ R.Register(&invoke<void (SBDebugger::*)(
+ FILE *, bool)>::method<&SBDebugger::SetOutputFileHandle>::doit,
+ &SetFileHandleRedirect);
+ R.Register<bool(char *, size_t)>(static_cast<bool (*)(char *, size_t)>(
+ &SBDebugger::GetDefaultArchitecture),
+ &GetDefaultArchitectureRedirect);
+
+ LLDB_REGISTER_CONSTRUCTOR(SBDebugger, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBDebugger, (const lldb::DebuggerSP &));
+ LLDB_REGISTER_CONSTRUCTOR(SBDebugger, (const lldb::SBDebugger &));
+ LLDB_REGISTER_METHOD(lldb::SBDebugger &,
+ SBDebugger, operator=,(const lldb::SBDebugger &));
+ LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, Initialize, ());
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBError, SBDebugger,
+ InitializeWithErrorHandling, ());
+ LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, Terminate, ());
+ LLDB_REGISTER_METHOD(void, SBDebugger, Clear, ());
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBDebugger, SBDebugger, Create, ());
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBDebugger, SBDebugger, Create, (bool));
+ LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, Destroy,
+ (lldb::SBDebugger &));
+ LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, MemoryPressureDetected, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, operator bool, ());
+ LLDB_REGISTER_METHOD(void, SBDebugger, SetAsync, (bool));
+ LLDB_REGISTER_METHOD(bool, SBDebugger, GetAsync, ());
+ LLDB_REGISTER_METHOD(void, SBDebugger, SkipLLDBInitFiles, (bool));
+ LLDB_REGISTER_METHOD(void, SBDebugger, SkipAppInitFiles, (bool));
+ LLDB_REGISTER_METHOD(void, SBDebugger, SetInputFileHandle, (FILE *, bool));
+ LLDB_REGISTER_METHOD(FILE *, SBDebugger, GetInputFileHandle, ());
+ LLDB_REGISTER_METHOD(FILE *, SBDebugger, GetOutputFileHandle, ());
+ LLDB_REGISTER_METHOD(FILE *, SBDebugger, GetErrorFileHandle, ());
+ LLDB_REGISTER_METHOD(void, SBDebugger, SaveInputTerminalState, ());
+ LLDB_REGISTER_METHOD(void, SBDebugger, RestoreInputTerminalState, ());
+ LLDB_REGISTER_METHOD(lldb::SBCommandInterpreter, SBDebugger,
+ GetCommandInterpreter, ());
+ LLDB_REGISTER_METHOD(void, SBDebugger, HandleCommand, (const char *));
+ LLDB_REGISTER_METHOD(lldb::SBListener, SBDebugger, GetListener, ());
+ LLDB_REGISTER_METHOD(
+ void, SBDebugger, HandleProcessEvent,
+ (const lldb::SBProcess &, const lldb::SBEvent &, FILE *, FILE *));
+ LLDB_REGISTER_METHOD(lldb::SBSourceManager, SBDebugger, GetSourceManager,
+ ());
+ LLDB_REGISTER_STATIC_METHOD(bool, SBDebugger, SetDefaultArchitecture,
+ (const char *));
+ LLDB_REGISTER_METHOD(lldb::ScriptLanguage, SBDebugger, GetScriptingLanguage,
+ (const char *));
+ LLDB_REGISTER_STATIC_METHOD(const char *, SBDebugger, GetVersionString, ());
+ LLDB_REGISTER_STATIC_METHOD(const char *, SBDebugger, StateAsCString,
+ (lldb::StateType));
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBStructuredData, SBDebugger,
+ GetBuildConfiguration, ());
+ LLDB_REGISTER_STATIC_METHOD(bool, SBDebugger, StateIsRunningState,
+ (lldb::StateType));
+ LLDB_REGISTER_STATIC_METHOD(bool, SBDebugger, StateIsStoppedState,
+ (lldb::StateType));
+ LLDB_REGISTER_METHOD(
+ lldb::SBTarget, SBDebugger, CreateTarget,
+ (const char *, const char *, const char *, bool, lldb::SBError &));
+ LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger,
+ CreateTargetWithFileAndTargetTriple,
+ (const char *, const char *));
+ LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger,
+ CreateTargetWithFileAndArch,
+ (const char *, const char *));
+ LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, CreateTarget,
+ (const char *));
+ LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, GetDummyTarget, ());
+ LLDB_REGISTER_METHOD(bool, SBDebugger, DeleteTarget, (lldb::SBTarget &));
+ LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, GetTargetAtIndex,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetIndexOfTarget,
+ (lldb::SBTarget));
+ LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithProcessID,
+ (lldb::pid_t));
+ LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithFileAndArch,
+ (const char *, const char *));
+ LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumTargets, ());
+ LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, GetSelectedTarget, ());
+ LLDB_REGISTER_METHOD(void, SBDebugger, SetSelectedTarget,
+ (lldb::SBTarget &));
+ LLDB_REGISTER_METHOD(lldb::SBPlatform, SBDebugger, GetSelectedPlatform, ());
+ LLDB_REGISTER_METHOD(void, SBDebugger, SetSelectedPlatform,
+ (lldb::SBPlatform &));
+ LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumPlatforms, ());
+ LLDB_REGISTER_METHOD(lldb::SBPlatform, SBDebugger, GetPlatformAtIndex,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumAvailablePlatforms, ());
+ LLDB_REGISTER_METHOD(lldb::SBStructuredData, SBDebugger,
+ GetAvailablePlatformInfoAtIndex, (uint32_t));
+ LLDB_REGISTER_METHOD(void, SBDebugger, DispatchInputInterrupt, ());
+ LLDB_REGISTER_METHOD(void, SBDebugger, DispatchInputEndOfFile, ());
+ LLDB_REGISTER_METHOD(void, SBDebugger, PushInputReader,
+ (lldb::SBInputReader &));
+ LLDB_REGISTER_METHOD(void, SBDebugger, RunCommandInterpreter, (bool, bool));
+ LLDB_REGISTER_METHOD(void, SBDebugger, RunCommandInterpreter,
+ (bool, bool, lldb::SBCommandInterpreterRunOptions &,
+ int &, bool &, bool &));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBDebugger, RunREPL,
+ (lldb::LanguageType, const char *));
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBDebugger, SBDebugger,
+ FindDebuggerWithID, (int));
+ LLDB_REGISTER_METHOD(const char *, SBDebugger, GetInstanceName, ());
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBError, SBDebugger, SetInternalVariable,
+ (const char *, const char *, const char *));
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBStringList, SBDebugger,
+ GetInternalVariableValue,
+ (const char *, const char *));
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBDebugger, GetTerminalWidth, ());
+ LLDB_REGISTER_METHOD(void, SBDebugger, SetTerminalWidth, (uint32_t));
+ LLDB_REGISTER_METHOD_CONST(const char *, SBDebugger, GetPrompt, ());
+ LLDB_REGISTER_METHOD(void, SBDebugger, SetPrompt, (const char *));
+ LLDB_REGISTER_METHOD_CONST(const char *, SBDebugger, GetReproducerPath, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::ScriptLanguage, SBDebugger,
+ GetScriptLanguage, ());
+ LLDB_REGISTER_METHOD(void, SBDebugger, SetScriptLanguage,
+ (lldb::ScriptLanguage));
+ LLDB_REGISTER_METHOD(bool, SBDebugger, SetUseExternalEditor, (bool));
+ LLDB_REGISTER_METHOD(bool, SBDebugger, GetUseExternalEditor, ());
+ LLDB_REGISTER_METHOD(bool, SBDebugger, SetUseColor, (bool));
+ LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, GetUseColor, ());
+ LLDB_REGISTER_METHOD(bool, SBDebugger, GetDescription, (lldb::SBStream &));
+ LLDB_REGISTER_METHOD(lldb::user_id_t, SBDebugger, GetID, ());
+ LLDB_REGISTER_METHOD(lldb::SBError, SBDebugger, SetCurrentPlatform,
+ (const char *));
+ LLDB_REGISTER_METHOD(bool, SBDebugger, SetCurrentPlatformSDKRoot,
+ (const char *));
+ LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, GetCloseInputOnEOF, ());
+ LLDB_REGISTER_METHOD(void, SBDebugger, SetCloseInputOnEOF, (bool));
+ LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory,
+ (const char *));
+ LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory,
+ (lldb::LanguageType));
+ LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, CreateCategory,
+ (const char *));
+ LLDB_REGISTER_METHOD(bool, SBDebugger, DeleteCategory, (const char *));
+ LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumCategories, ());
+ LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategoryAtIndex,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetDefaultCategory,
+ ());
+ LLDB_REGISTER_METHOD(lldb::SBTypeFormat, SBDebugger, GetFormatForType,
+ (lldb::SBTypeNameSpecifier));
+ LLDB_REGISTER_METHOD(lldb::SBTypeSummary, SBDebugger, GetSummaryForType,
+ (lldb::SBTypeNameSpecifier));
+ LLDB_REGISTER_METHOD(lldb::SBTypeSynthetic, SBDebugger, GetSyntheticForType,
+ (lldb::SBTypeNameSpecifier));
+ LLDB_REGISTER_METHOD(lldb::SBTypeFilter, SBDebugger, GetFilterForType,
+ (lldb::SBTypeNameSpecifier));
+ LLDB_REGISTER_METHOD(bool, SBDebugger, EnableLog,
+ (const char *, const char **));
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBDeclaration.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBDeclaration.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBDeclaration.cpp (original)
+++ lldb/trunk/source/API/SBDeclaration.cpp Tue Mar 19 10:13:13 2019
@@ -175,3 +175,33 @@ bool SBDeclaration::GetDescription(SBStr
}
lldb_private::Declaration *SBDeclaration::get() { return m_opaque_up.get(); }
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBDeclaration>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBDeclaration, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBDeclaration, (const lldb::SBDeclaration &));
+ LLDB_REGISTER_METHOD(
+ const lldb::SBDeclaration &,
+ SBDeclaration, operator=,(const lldb::SBDeclaration &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBDeclaration, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBDeclaration, operator bool, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBDeclaration, GetFileSpec,
+ ());
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBDeclaration, GetLine, ());
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBDeclaration, GetColumn, ());
+ LLDB_REGISTER_METHOD(void, SBDeclaration, SetFileSpec, (lldb::SBFileSpec));
+ LLDB_REGISTER_METHOD(void, SBDeclaration, SetLine, (uint32_t));
+ LLDB_REGISTER_METHOD(void, SBDeclaration, SetColumn, (uint32_t));
+ LLDB_REGISTER_METHOD_CONST(
+ bool, SBDeclaration, operator==,(const lldb::SBDeclaration &));
+ LLDB_REGISTER_METHOD_CONST(
+ bool, SBDeclaration, operator!=,(const lldb::SBDeclaration &));
+ LLDB_REGISTER_METHOD(bool, SBDeclaration, GetDescription,
+ (lldb::SBStream &));
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBError.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBError.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBError.cpp (original)
+++ lldb/trunk/source/API/SBError.cpp Tue Mar 19 10:13:13 2019
@@ -182,3 +182,30 @@ bool SBError::GetDescription(SBStream &d
return true;
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBError>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBError, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBError, (const lldb::SBError &));
+ LLDB_REGISTER_METHOD(const lldb::SBError &,
+ SBError, operator=,(const lldb::SBError &));
+ LLDB_REGISTER_METHOD_CONST(const char *, SBError, GetCString, ());
+ LLDB_REGISTER_METHOD(void, SBError, Clear, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBError, Fail, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBError, Success, ());
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBError, GetError, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::ErrorType, SBError, GetType, ());
+ LLDB_REGISTER_METHOD(void, SBError, SetError, (uint32_t, lldb::ErrorType));
+ LLDB_REGISTER_METHOD(void, SBError, SetErrorToErrno, ());
+ LLDB_REGISTER_METHOD(void, SBError, SetErrorToGenericError, ());
+ LLDB_REGISTER_METHOD(void, SBError, SetErrorString, (const char *));
+ LLDB_REGISTER_METHOD_CONST(bool, SBError, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBError, operator bool, ());
+ LLDB_REGISTER_METHOD(bool, SBError, GetDescription, (lldb::SBStream &));
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBEvent.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBEvent.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBEvent.cpp (original)
+++ lldb/trunk/source/API/SBEvent.cpp Tue Mar 19 10:13:13 2019
@@ -206,3 +206,37 @@ bool SBEvent::GetDescription(SBStream &d
return true;
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBEvent>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBEvent, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBEvent, (uint32_t, const char *, uint32_t));
+ LLDB_REGISTER_CONSTRUCTOR(SBEvent, (lldb::EventSP &));
+ LLDB_REGISTER_CONSTRUCTOR(SBEvent, (lldb_private::Event *));
+ LLDB_REGISTER_CONSTRUCTOR(SBEvent, (const lldb::SBEvent &));
+ LLDB_REGISTER_METHOD(const lldb::SBEvent &,
+ SBEvent, operator=,(const lldb::SBEvent &));
+ LLDB_REGISTER_METHOD(const char *, SBEvent, GetDataFlavor, ());
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBEvent, GetType, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBBroadcaster, SBEvent, GetBroadcaster,
+ ());
+ LLDB_REGISTER_METHOD_CONST(const char *, SBEvent, GetBroadcasterClass, ());
+ LLDB_REGISTER_METHOD(bool, SBEvent, BroadcasterMatchesPtr,
+ (const lldb::SBBroadcaster *));
+ LLDB_REGISTER_METHOD(bool, SBEvent, BroadcasterMatchesRef,
+ (const lldb::SBBroadcaster &));
+ LLDB_REGISTER_METHOD(void, SBEvent, Clear, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBEvent, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBEvent, operator bool, ());
+ LLDB_REGISTER_STATIC_METHOD(const char *, SBEvent, GetCStringFromEvent,
+ (const lldb::SBEvent &));
+ LLDB_REGISTER_METHOD(bool, SBEvent, GetDescription, (lldb::SBStream &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBEvent, GetDescription,
+ (lldb::SBStream &));
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBExecutionContext.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBExecutionContext.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBExecutionContext.cpp (original)
+++ lldb/trunk/source/API/SBExecutionContext.cpp Tue Mar 19 10:13:13 2019
@@ -132,3 +132,32 @@ SBFrame SBExecutionContext::GetFrame() c
}
return LLDB_RECORD_RESULT(sb_frame);
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBExecutionContext>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext,
+ (const lldb::SBExecutionContext &));
+ LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext,
+ (lldb::ExecutionContextRefSP));
+ LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext, (const lldb::SBTarget &));
+ LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext, (const lldb::SBProcess &));
+ LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext, (lldb::SBThread));
+ LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext, (const lldb::SBFrame &));
+ LLDB_REGISTER_METHOD(
+ const lldb::SBExecutionContext &,
+ SBExecutionContext, operator=,(const lldb::SBExecutionContext &));
+ LLDB_REGISTER_METHOD_CONST(lldb::SBTarget, SBExecutionContext, GetTarget,
+ ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBProcess, SBExecutionContext, GetProcess,
+ ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBThread, SBExecutionContext, GetThread,
+ ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBFrame, SBExecutionContext, GetFrame, ());
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBExpressionOptions.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBExpressionOptions.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBExpressionOptions.cpp (original)
+++ lldb/trunk/source/API/SBExpressionOptions.cpp Tue Mar 19 10:13:13 2019
@@ -271,3 +271,66 @@ EvaluateExpressionOptions *SBExpressionO
EvaluateExpressionOptions &SBExpressionOptions::ref() const {
return *(m_opaque_up.get());
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBExpressionOptions>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBExpressionOptions, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBExpressionOptions,
+ (const lldb::SBExpressionOptions &));
+ LLDB_REGISTER_METHOD(
+ const lldb::SBExpressionOptions &,
+ SBExpressionOptions, operator=,(const lldb::SBExpressionOptions &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetCoerceResultToId,
+ ());
+ LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetCoerceResultToId,
+ (bool));
+ LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetUnwindOnError, ());
+ LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetUnwindOnError, (bool));
+ LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetIgnoreBreakpoints,
+ ());
+ LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetIgnoreBreakpoints,
+ (bool));
+ LLDB_REGISTER_METHOD_CONST(lldb::DynamicValueType, SBExpressionOptions,
+ GetFetchDynamicValue, ());
+ LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetFetchDynamicValue,
+ (lldb::DynamicValueType));
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBExpressionOptions,
+ GetTimeoutInMicroSeconds, ());
+ LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetTimeoutInMicroSeconds,
+ (uint32_t));
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBExpressionOptions,
+ GetOneThreadTimeoutInMicroSeconds, ());
+ LLDB_REGISTER_METHOD(void, SBExpressionOptions,
+ SetOneThreadTimeoutInMicroSeconds, (uint32_t));
+ LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetTryAllThreads, ());
+ LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetTryAllThreads, (bool));
+ LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetStopOthers, ());
+ LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetStopOthers, (bool));
+ LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetTrapExceptions,
+ ());
+ LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetTrapExceptions, (bool));
+ LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetLanguage,
+ (lldb::LanguageType));
+ LLDB_REGISTER_METHOD(bool, SBExpressionOptions, GetGenerateDebugInfo, ());
+ LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetGenerateDebugInfo,
+ (bool));
+ LLDB_REGISTER_METHOD(bool, SBExpressionOptions, GetSuppressPersistentResult,
+ ());
+ LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetSuppressPersistentResult,
+ (bool));
+ LLDB_REGISTER_METHOD_CONST(const char *, SBExpressionOptions, GetPrefix,
+ ());
+ LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetPrefix, (const char *));
+ LLDB_REGISTER_METHOD(bool, SBExpressionOptions, GetAutoApplyFixIts, ());
+ LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetAutoApplyFixIts, (bool));
+ LLDB_REGISTER_METHOD(bool, SBExpressionOptions, GetTopLevel, ());
+ LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetTopLevel, (bool));
+ LLDB_REGISTER_METHOD(bool, SBExpressionOptions, GetAllowJIT, ());
+ LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetAllowJIT, (bool));
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBFileSpec.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBFileSpec.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBFileSpec.cpp (original)
+++ lldb/trunk/source/API/SBFileSpec.cpp Tue Mar 19 10:13:13 2019
@@ -173,3 +173,33 @@ void SBFileSpec::AppendPathComponent(con
m_opaque_up->AppendPathComponent(fn);
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBFileSpec>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBFileSpec, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBFileSpec, (const lldb::SBFileSpec &));
+ LLDB_REGISTER_CONSTRUCTOR(SBFileSpec, (const char *));
+ LLDB_REGISTER_CONSTRUCTOR(SBFileSpec, (const char *, bool));
+ LLDB_REGISTER_METHOD(const lldb::SBFileSpec &,
+ SBFileSpec, operator=,(const lldb::SBFileSpec &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBFileSpec, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBFileSpec, operator bool, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBFileSpec, Exists, ());
+ LLDB_REGISTER_METHOD(bool, SBFileSpec, ResolveExecutableLocation, ());
+ LLDB_REGISTER_STATIC_METHOD(int, SBFileSpec, ResolvePath,
+ (const char *, char *, size_t));
+ LLDB_REGISTER_METHOD_CONST(const char *, SBFileSpec, GetFilename, ());
+ LLDB_REGISTER_METHOD_CONST(const char *, SBFileSpec, GetDirectory, ());
+ LLDB_REGISTER_METHOD(void, SBFileSpec, SetFilename, (const char *));
+ LLDB_REGISTER_METHOD(void, SBFileSpec, SetDirectory, (const char *));
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBFileSpec, GetPath, (char *, size_t));
+ LLDB_REGISTER_METHOD_CONST(bool, SBFileSpec, GetDescription,
+ (lldb::SBStream &));
+ LLDB_REGISTER_METHOD(void, SBFileSpec, AppendPathComponent, (const char *));
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBFileSpecList.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBFileSpecList.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBFileSpecList.cpp (original)
+++ lldb/trunk/source/API/SBFileSpecList.cpp Tue Mar 19 10:13:13 2019
@@ -123,3 +123,30 @@ bool SBFileSpecList::GetDescription(SBSt
return true;
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBFileSpecList>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBFileSpecList, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBFileSpecList, (const lldb::SBFileSpecList &));
+ LLDB_REGISTER_METHOD(
+ const lldb::SBFileSpecList &,
+ SBFileSpecList, operator=,(const lldb::SBFileSpecList &));
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBFileSpecList, GetSize, ());
+ LLDB_REGISTER_METHOD(void, SBFileSpecList, Append,
+ (const lldb::SBFileSpec &));
+ LLDB_REGISTER_METHOD(bool, SBFileSpecList, AppendIfUnique,
+ (const lldb::SBFileSpec &));
+ LLDB_REGISTER_METHOD(void, SBFileSpecList, Clear, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBFileSpecList, FindFileIndex,
+ (uint32_t, const lldb::SBFileSpec &, bool));
+ LLDB_REGISTER_METHOD_CONST(const lldb::SBFileSpec, SBFileSpecList,
+ GetFileSpecAtIndex, (uint32_t));
+ LLDB_REGISTER_METHOD_CONST(bool, SBFileSpecList, GetDescription,
+ (lldb::SBStream &));
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBFrame.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBFrame.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBFrame.cpp (original)
+++ lldb/trunk/source/API/SBFrame.cpp Tue Mar 19 10:13:13 2019
@@ -1290,3 +1290,82 @@ const char *SBFrame::GetDisplayFunctionN
}
return name;
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBFrame>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBFrame, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBFrame, (const lldb::StackFrameSP &));
+ LLDB_REGISTER_CONSTRUCTOR(SBFrame, (const lldb::SBFrame &));
+ LLDB_REGISTER_METHOD(const lldb::SBFrame &,
+ SBFrame, operator=,(const lldb::SBFrame &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBFrame, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBFrame, operator bool, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBSymbolContext, SBFrame, GetSymbolContext,
+ (uint32_t));
+ LLDB_REGISTER_METHOD_CONST(lldb::SBModule, SBFrame, GetModule, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBCompileUnit, SBFrame, GetCompileUnit,
+ ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBFunction, SBFrame, GetFunction, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBSymbol, SBFrame, GetSymbol, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBBlock, SBFrame, GetBlock, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBBlock, SBFrame, GetFrameBlock, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBLineEntry, SBFrame, GetLineEntry, ());
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBFrame, GetFrameID, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBFrame, GetCFA, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBFrame, GetPC, ());
+ LLDB_REGISTER_METHOD(bool, SBFrame, SetPC, (lldb::addr_t));
+ LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBFrame, GetSP, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBFrame, GetFP, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBFrame, GetPCAddress, ());
+ LLDB_REGISTER_METHOD(void, SBFrame, Clear, ());
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, GetValueForVariablePath,
+ (const char *));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, GetValueForVariablePath,
+ (const char *, lldb::DynamicValueType));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, FindVariable, (const char *));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, FindVariable,
+ (const char *, lldb::DynamicValueType));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, FindValue,
+ (const char *, lldb::ValueType));
+ LLDB_REGISTER_METHOD(
+ lldb::SBValue, SBFrame, FindValue,
+ (const char *, lldb::ValueType, lldb::DynamicValueType));
+ LLDB_REGISTER_METHOD_CONST(bool, SBFrame, IsEqual, (const lldb::SBFrame &));
+ LLDB_REGISTER_METHOD_CONST(bool,
+ SBFrame, operator==,(const lldb::SBFrame &));
+ LLDB_REGISTER_METHOD_CONST(bool,
+ SBFrame, operator!=,(const lldb::SBFrame &));
+ LLDB_REGISTER_METHOD_CONST(lldb::SBThread, SBFrame, GetThread, ());
+ LLDB_REGISTER_METHOD_CONST(const char *, SBFrame, Disassemble, ());
+ LLDB_REGISTER_METHOD(lldb::SBValueList, SBFrame, GetVariables,
+ (bool, bool, bool, bool));
+ LLDB_REGISTER_METHOD(lldb::SBValueList, SBFrame, GetVariables,
+ (bool, bool, bool, bool, lldb::DynamicValueType));
+ LLDB_REGISTER_METHOD(lldb::SBValueList, SBFrame, GetVariables,
+ (const lldb::SBVariablesOptions &));
+ LLDB_REGISTER_METHOD(lldb::SBValueList, SBFrame, GetRegisters, ());
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, FindRegister, (const char *));
+ LLDB_REGISTER_METHOD(bool, SBFrame, GetDescription, (lldb::SBStream &));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
+ (const char *));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
+ (const char *, lldb::DynamicValueType));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
+ (const char *, lldb::DynamicValueType, bool));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
+ (const char *, const lldb::SBExpressionOptions &));
+ LLDB_REGISTER_METHOD(bool, SBFrame, IsInlined, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBFrame, IsInlined, ());
+ LLDB_REGISTER_METHOD(bool, SBFrame, IsArtificial, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBFrame, IsArtificial, ());
+ LLDB_REGISTER_METHOD(const char *, SBFrame, GetFunctionName, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::LanguageType, SBFrame, GuessLanguage, ());
+ LLDB_REGISTER_METHOD_CONST(const char *, SBFrame, GetFunctionName, ());
+ LLDB_REGISTER_METHOD(const char *, SBFrame, GetDisplayFunctionName, ());
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBFunction.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBFunction.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBFunction.cpp (original)
+++ lldb/trunk/source/API/SBFunction.cpp Tue Mar 19 10:13:13 2019
@@ -244,3 +244,39 @@ bool SBFunction::GetIsOptimized() {
}
return false;
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBFunction>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBFunction, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBFunction, (const lldb::SBFunction &));
+ LLDB_REGISTER_METHOD(const lldb::SBFunction &,
+ SBFunction, operator=,(const lldb::SBFunction &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBFunction, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBFunction, operator bool, ());
+ LLDB_REGISTER_METHOD_CONST(const char *, SBFunction, GetName, ());
+ LLDB_REGISTER_METHOD_CONST(const char *, SBFunction, GetDisplayName, ());
+ LLDB_REGISTER_METHOD_CONST(const char *, SBFunction, GetMangledName, ());
+ LLDB_REGISTER_METHOD_CONST(
+ bool, SBFunction, operator==,(const lldb::SBFunction &));
+ LLDB_REGISTER_METHOD_CONST(
+ bool, SBFunction, operator!=,(const lldb::SBFunction &));
+ LLDB_REGISTER_METHOD(bool, SBFunction, GetDescription, (lldb::SBStream &));
+ LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBFunction, GetInstructions,
+ (lldb::SBTarget));
+ LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBFunction, GetInstructions,
+ (lldb::SBTarget, const char *));
+ LLDB_REGISTER_METHOD(lldb::SBAddress, SBFunction, GetStartAddress, ());
+ LLDB_REGISTER_METHOD(lldb::SBAddress, SBFunction, GetEndAddress, ());
+ LLDB_REGISTER_METHOD(const char *, SBFunction, GetArgumentName, (uint32_t));
+ LLDB_REGISTER_METHOD(uint32_t, SBFunction, GetPrologueByteSize, ());
+ LLDB_REGISTER_METHOD(lldb::SBType, SBFunction, GetType, ());
+ LLDB_REGISTER_METHOD(lldb::SBBlock, SBFunction, GetBlock, ());
+ LLDB_REGISTER_METHOD(lldb::LanguageType, SBFunction, GetLanguage, ());
+ LLDB_REGISTER_METHOD(bool, SBFunction, GetIsOptimized, ());
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBHostOS.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBHostOS.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBHostOS.cpp (original)
+++ lldb/trunk/source/API/SBHostOS.cpp Tue Mar 19 10:13:13 2019
@@ -169,3 +169,22 @@ bool SBHostOS::ThreadJoin(lldb::thread_t
host_thread.Release();
return error.Success();
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBHostOS>(Registry &R) {
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBFileSpec, SBHostOS, GetProgramFileSpec,
+ ());
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBFileSpec, SBHostOS, GetLLDBPythonPath,
+ ());
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBFileSpec, SBHostOS, GetLLDBPath,
+ (lldb::PathType));
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBFileSpec, SBHostOS,
+ GetUserHomeDirectory, ());
+ LLDB_REGISTER_STATIC_METHOD(void, SBHostOS, ThreadCreated, (const char *));
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBInstruction.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBInstruction.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBInstruction.cpp (original)
+++ lldb/trunk/source/API/SBInstruction.cpp Tue Mar 19 10:13:13 2019
@@ -330,3 +330,41 @@ bool SBInstruction::TestEmulation(lldb::
return inst_sp->TestEmulation(output_stream.get(), test_file);
return false;
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBInstruction>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBInstruction, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBInstruction, (const lldb::SBInstruction &));
+ LLDB_REGISTER_METHOD(
+ const lldb::SBInstruction &,
+ SBInstruction, operator=,(const lldb::SBInstruction &));
+ LLDB_REGISTER_METHOD(bool, SBInstruction, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBInstruction, operator bool, ());
+ LLDB_REGISTER_METHOD(lldb::SBAddress, SBInstruction, GetAddress, ());
+ LLDB_REGISTER_METHOD(const char *, SBInstruction, GetMnemonic,
+ (lldb::SBTarget));
+ LLDB_REGISTER_METHOD(const char *, SBInstruction, GetOperands,
+ (lldb::SBTarget));
+ LLDB_REGISTER_METHOD(const char *, SBInstruction, GetComment,
+ (lldb::SBTarget));
+ LLDB_REGISTER_METHOD(size_t, SBInstruction, GetByteSize, ());
+ LLDB_REGISTER_METHOD(lldb::SBData, SBInstruction, GetData,
+ (lldb::SBTarget));
+ LLDB_REGISTER_METHOD(bool, SBInstruction, DoesBranch, ());
+ LLDB_REGISTER_METHOD(bool, SBInstruction, HasDelaySlot, ());
+ LLDB_REGISTER_METHOD(bool, SBInstruction, CanSetBreakpoint, ());
+ LLDB_REGISTER_METHOD(bool, SBInstruction, GetDescription,
+ (lldb::SBStream &));
+ LLDB_REGISTER_METHOD(void, SBInstruction, Print, (FILE *));
+ LLDB_REGISTER_METHOD(bool, SBInstruction, EmulateWithFrame,
+ (lldb::SBFrame &, uint32_t));
+ LLDB_REGISTER_METHOD(bool, SBInstruction, DumpEmulation, (const char *));
+ LLDB_REGISTER_METHOD(bool, SBInstruction, TestEmulation,
+ (lldb::SBStream &, const char *));
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBInstructionList.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBInstructionList.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBInstructionList.cpp (original)
+++ lldb/trunk/source/API/SBInstructionList.cpp Tue Mar 19 10:13:13 2019
@@ -176,3 +176,35 @@ bool SBInstructionList::DumpEmulationFor
}
return true;
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBInstructionList>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBInstructionList, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBInstructionList,
+ (const lldb::SBInstructionList &));
+ LLDB_REGISTER_METHOD(
+ const lldb::SBInstructionList &,
+ SBInstructionList, operator=,(const lldb::SBInstructionList &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBInstructionList, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBInstructionList, operator bool, ());
+ LLDB_REGISTER_METHOD(size_t, SBInstructionList, GetSize, ());
+ LLDB_REGISTER_METHOD(lldb::SBInstruction, SBInstructionList,
+ GetInstructionAtIndex, (uint32_t));
+ LLDB_REGISTER_METHOD(
+ size_t, SBInstructionList, GetInstructionsCount,
+ (const lldb::SBAddress &, const lldb::SBAddress &, bool));
+ LLDB_REGISTER_METHOD(void, SBInstructionList, Clear, ());
+ LLDB_REGISTER_METHOD(void, SBInstructionList, AppendInstruction,
+ (lldb::SBInstruction));
+ LLDB_REGISTER_METHOD(void, SBInstructionList, Print, (FILE *));
+ LLDB_REGISTER_METHOD(bool, SBInstructionList, GetDescription,
+ (lldb::SBStream &));
+ LLDB_REGISTER_METHOD(bool, SBInstructionList,
+ DumpEmulationForAllInstructions, (const char *));
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBLanguageRuntime.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBLanguageRuntime.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBLanguageRuntime.cpp (original)
+++ lldb/trunk/source/API/SBLanguageRuntime.cpp Tue Mar 19 10:13:13 2019
@@ -30,3 +30,17 @@ SBLanguageRuntime::GetNameForLanguageTyp
return Language::GetNameForLanguageType(language);
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBLanguageRuntime>(Registry &R) {
+ LLDB_REGISTER_STATIC_METHOD(lldb::LanguageType, SBLanguageRuntime,
+ GetLanguageTypeFromString, (const char *));
+ LLDB_REGISTER_STATIC_METHOD(const char *, SBLanguageRuntime,
+ GetNameForLanguageType, (lldb::LanguageType));
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBLaunchInfo.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBLaunchInfo.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBLaunchInfo.cpp (original)
+++ lldb/trunk/source/API/SBLaunchInfo.cpp Tue Mar 19 10:13:13 2019
@@ -315,3 +315,65 @@ bool SBLaunchInfo::GetDetachOnError() co
return m_opaque_sp->GetDetachOnError();
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBLaunchInfo>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBLaunchInfo, (const char **));
+ LLDB_REGISTER_METHOD(lldb::pid_t, SBLaunchInfo, GetProcessID, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetUserID, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetGroupID, ());
+ LLDB_REGISTER_METHOD(bool, SBLaunchInfo, UserIDIsValid, ());
+ LLDB_REGISTER_METHOD(bool, SBLaunchInfo, GroupIDIsValid, ());
+ LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetUserID, (uint32_t));
+ LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetGroupID, (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBLaunchInfo, GetExecutableFile, ());
+ LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetExecutableFile,
+ (lldb::SBFileSpec, bool));
+ LLDB_REGISTER_METHOD(lldb::SBListener, SBLaunchInfo, GetListener, ());
+ LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetListener, (lldb::SBListener &));
+ LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetNumArguments, ());
+ LLDB_REGISTER_METHOD(const char *, SBLaunchInfo, GetArgumentAtIndex,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetArguments,
+ (const char **, bool));
+ LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetNumEnvironmentEntries, ());
+ LLDB_REGISTER_METHOD(const char *, SBLaunchInfo, GetEnvironmentEntryAtIndex,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetEnvironmentEntries,
+ (const char **, bool));
+ LLDB_REGISTER_METHOD(void, SBLaunchInfo, Clear, ());
+ LLDB_REGISTER_METHOD_CONST(const char *, SBLaunchInfo, GetWorkingDirectory,
+ ());
+ LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetWorkingDirectory,
+ (const char *));
+ LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetLaunchFlags, ());
+ LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetLaunchFlags, (uint32_t));
+ LLDB_REGISTER_METHOD(const char *, SBLaunchInfo, GetProcessPluginName, ());
+ LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetProcessPluginName,
+ (const char *));
+ LLDB_REGISTER_METHOD(const char *, SBLaunchInfo, GetShell, ());
+ LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetShell, (const char *));
+ LLDB_REGISTER_METHOD(bool, SBLaunchInfo, GetShellExpandArguments, ());
+ LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetShellExpandArguments, (bool));
+ LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetResumeCount, ());
+ LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetResumeCount, (uint32_t));
+ LLDB_REGISTER_METHOD(bool, SBLaunchInfo, AddCloseFileAction, (int));
+ LLDB_REGISTER_METHOD(bool, SBLaunchInfo, AddDuplicateFileAction,
+ (int, int));
+ LLDB_REGISTER_METHOD(bool, SBLaunchInfo, AddOpenFileAction,
+ (int, const char *, bool, bool));
+ LLDB_REGISTER_METHOD(bool, SBLaunchInfo, AddSuppressFileAction,
+ (int, bool, bool));
+ LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetLaunchEventData,
+ (const char *));
+ LLDB_REGISTER_METHOD_CONST(const char *, SBLaunchInfo, GetLaunchEventData,
+ ());
+ LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetDetachOnError, (bool));
+ LLDB_REGISTER_METHOD_CONST(bool, SBLaunchInfo, GetDetachOnError, ());
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBLineEntry.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBLineEntry.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBLineEntry.cpp (original)
+++ lldb/trunk/source/API/SBLineEntry.cpp Tue Mar 19 10:13:13 2019
@@ -188,3 +188,33 @@ bool SBLineEntry::GetDescription(SBStrea
}
lldb_private::LineEntry *SBLineEntry::get() { return m_opaque_up.get(); }
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBLineEntry>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBLineEntry, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBLineEntry, (const lldb::SBLineEntry &));
+ LLDB_REGISTER_METHOD(const lldb::SBLineEntry &,
+ SBLineEntry, operator=,(const lldb::SBLineEntry &));
+ LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBLineEntry, GetStartAddress,
+ ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBLineEntry, GetEndAddress, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBLineEntry, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBLineEntry, operator bool, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBLineEntry, GetFileSpec, ());
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBLineEntry, GetLine, ());
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBLineEntry, GetColumn, ());
+ LLDB_REGISTER_METHOD(void, SBLineEntry, SetFileSpec, (lldb::SBFileSpec));
+ LLDB_REGISTER_METHOD(void, SBLineEntry, SetLine, (uint32_t));
+ LLDB_REGISTER_METHOD(void, SBLineEntry, SetColumn, (uint32_t));
+ LLDB_REGISTER_METHOD_CONST(
+ bool, SBLineEntry, operator==,(const lldb::SBLineEntry &));
+ LLDB_REGISTER_METHOD_CONST(
+ bool, SBLineEntry, operator!=,(const lldb::SBLineEntry &));
+ LLDB_REGISTER_METHOD(bool, SBLineEntry, GetDescription, (lldb::SBStream &));
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBListener.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBListener.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBListener.cpp (original)
+++ lldb/trunk/source/API/SBListener.cpp Tue Mar 19 10:13:13 2019
@@ -322,3 +322,52 @@ void SBListener::reset(ListenerSP listen
m_opaque_sp = listener_sp;
m_unused_ptr = nullptr;
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBListener>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBListener, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBListener, (const char *));
+ LLDB_REGISTER_CONSTRUCTOR(SBListener, (const lldb::SBListener &));
+ LLDB_REGISTER_METHOD(const lldb::SBListener &,
+ SBListener, operator=,(const lldb::SBListener &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBListener, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBListener, operator bool, ());
+ LLDB_REGISTER_METHOD(void, SBListener, AddEvent, (const lldb::SBEvent &));
+ LLDB_REGISTER_METHOD(void, SBListener, Clear, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBListener, StartListeningForEventClass,
+ (lldb::SBDebugger &, const char *, uint32_t));
+ LLDB_REGISTER_METHOD(bool, SBListener, StopListeningForEventClass,
+ (lldb::SBDebugger &, const char *, uint32_t));
+ LLDB_REGISTER_METHOD(uint32_t, SBListener, StartListeningForEvents,
+ (const lldb::SBBroadcaster &, uint32_t));
+ LLDB_REGISTER_METHOD(bool, SBListener, StopListeningForEvents,
+ (const lldb::SBBroadcaster &, uint32_t));
+ LLDB_REGISTER_METHOD(bool, SBListener, WaitForEvent,
+ (uint32_t, lldb::SBEvent &));
+ LLDB_REGISTER_METHOD(
+ bool, SBListener, WaitForEventForBroadcaster,
+ (uint32_t, const lldb::SBBroadcaster &, lldb::SBEvent &));
+ LLDB_REGISTER_METHOD(
+ bool, SBListener, WaitForEventForBroadcasterWithType,
+ (uint32_t, const lldb::SBBroadcaster &, uint32_t, lldb::SBEvent &));
+ LLDB_REGISTER_METHOD(bool, SBListener, PeekAtNextEvent, (lldb::SBEvent &));
+ LLDB_REGISTER_METHOD(bool, SBListener, PeekAtNextEventForBroadcaster,
+ (const lldb::SBBroadcaster &, lldb::SBEvent &));
+ LLDB_REGISTER_METHOD(
+ bool, SBListener, PeekAtNextEventForBroadcasterWithType,
+ (const lldb::SBBroadcaster &, uint32_t, lldb::SBEvent &));
+ LLDB_REGISTER_METHOD(bool, SBListener, GetNextEvent, (lldb::SBEvent &));
+ LLDB_REGISTER_METHOD(bool, SBListener, GetNextEventForBroadcaster,
+ (const lldb::SBBroadcaster &, lldb::SBEvent &));
+ LLDB_REGISTER_METHOD(
+ bool, SBListener, GetNextEventForBroadcasterWithType,
+ (const lldb::SBBroadcaster &, uint32_t, lldb::SBEvent &));
+ LLDB_REGISTER_METHOD(bool, SBListener, HandleBroadcastEvent,
+ (const lldb::SBEvent &));
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBMemoryRegionInfo.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBMemoryRegionInfo.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBMemoryRegionInfo.cpp (original)
+++ lldb/trunk/source/API/SBMemoryRegionInfo.cpp Tue Mar 19 10:13:13 2019
@@ -132,3 +132,35 @@ bool SBMemoryRegionInfo::GetDescription(
return true;
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBMemoryRegionInfo>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBMemoryRegionInfo, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBMemoryRegionInfo,
+ (const lldb::SBMemoryRegionInfo &));
+ LLDB_REGISTER_METHOD(
+ const lldb::SBMemoryRegionInfo &,
+ SBMemoryRegionInfo, operator=,(const lldb::SBMemoryRegionInfo &));
+ LLDB_REGISTER_METHOD(void, SBMemoryRegionInfo, Clear, ());
+ LLDB_REGISTER_METHOD_CONST(
+ bool,
+ SBMemoryRegionInfo, operator==,(const lldb::SBMemoryRegionInfo &));
+ LLDB_REGISTER_METHOD_CONST(
+ bool,
+ SBMemoryRegionInfo, operator!=,(const lldb::SBMemoryRegionInfo &));
+ LLDB_REGISTER_METHOD(lldb::addr_t, SBMemoryRegionInfo, GetRegionBase, ());
+ LLDB_REGISTER_METHOD(lldb::addr_t, SBMemoryRegionInfo, GetRegionEnd, ());
+ LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, IsReadable, ());
+ LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, IsWritable, ());
+ LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, IsExecutable, ());
+ LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, IsMapped, ());
+ LLDB_REGISTER_METHOD(const char *, SBMemoryRegionInfo, GetName, ());
+ LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, GetDescription,
+ (lldb::SBStream &));
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBMemoryRegionInfoList.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBMemoryRegionInfoList.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBMemoryRegionInfoList.cpp (original)
+++ lldb/trunk/source/API/SBMemoryRegionInfoList.cpp Tue Mar 19 10:13:13 2019
@@ -139,3 +139,28 @@ const MemoryRegionInfoListImpl &SBMemory
assert(m_opaque_up.get());
return *m_opaque_up;
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBMemoryRegionInfoList>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBMemoryRegionInfoList, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBMemoryRegionInfoList,
+ (const lldb::SBMemoryRegionInfoList &));
+ LLDB_REGISTER_METHOD(
+ const lldb::SBMemoryRegionInfoList &,
+ SBMemoryRegionInfoList, operator=,(
+ const lldb::SBMemoryRegionInfoList &));
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBMemoryRegionInfoList, GetSize, ());
+ LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfoList, GetMemoryRegionAtIndex,
+ (uint32_t, lldb::SBMemoryRegionInfo &));
+ LLDB_REGISTER_METHOD(void, SBMemoryRegionInfoList, Clear, ());
+ LLDB_REGISTER_METHOD(void, SBMemoryRegionInfoList, Append,
+ (lldb::SBMemoryRegionInfo &));
+ LLDB_REGISTER_METHOD(void, SBMemoryRegionInfoList, Append,
+ (lldb::SBMemoryRegionInfoList &));
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBModule.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBModule.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBModule.cpp (original)
+++ lldb/trunk/source/API/SBModule.cpp Tue Mar 19 10:13:13 2019
@@ -688,3 +688,82 @@ lldb::SBAddress SBModule::GetObjectFileE
}
return LLDB_RECORD_RESULT(sb_addr);
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBModule>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBModule, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBModule, (const lldb::SBModuleSpec &));
+ LLDB_REGISTER_CONSTRUCTOR(SBModule, (const lldb::SBModule &));
+ LLDB_REGISTER_CONSTRUCTOR(SBModule, (lldb::SBProcess &, lldb::addr_t));
+ LLDB_REGISTER_METHOD(const lldb::SBModule &,
+ SBModule, operator=,(const lldb::SBModule &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBModule, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBModule, operator bool, ());
+ LLDB_REGISTER_METHOD(void, SBModule, Clear, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBModule, GetFileSpec, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBModule, GetPlatformFileSpec,
+ ());
+ LLDB_REGISTER_METHOD(bool, SBModule, SetPlatformFileSpec,
+ (const lldb::SBFileSpec &));
+ LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBModule, GetRemoteInstallFileSpec,
+ ());
+ LLDB_REGISTER_METHOD(bool, SBModule, SetRemoteInstallFileSpec,
+ (lldb::SBFileSpec &));
+ LLDB_REGISTER_METHOD_CONST(const char *, SBModule, GetUUIDString, ());
+ LLDB_REGISTER_METHOD_CONST(bool,
+ SBModule, operator==,(const lldb::SBModule &));
+ LLDB_REGISTER_METHOD_CONST(bool,
+ SBModule, operator!=,(const lldb::SBModule &));
+ LLDB_REGISTER_METHOD(lldb::SBAddress, SBModule, ResolveFileAddress,
+ (lldb::addr_t));
+ LLDB_REGISTER_METHOD(lldb::SBSymbolContext, SBModule,
+ ResolveSymbolContextForAddress,
+ (const lldb::SBAddress &, uint32_t));
+ LLDB_REGISTER_METHOD(bool, SBModule, GetDescription, (lldb::SBStream &));
+ LLDB_REGISTER_METHOD(uint32_t, SBModule, GetNumCompileUnits, ());
+ LLDB_REGISTER_METHOD(lldb::SBCompileUnit, SBModule, GetCompileUnitAtIndex,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBModule, FindCompileUnits,
+ (const lldb::SBFileSpec &));
+ LLDB_REGISTER_METHOD(size_t, SBModule, GetNumSymbols, ());
+ LLDB_REGISTER_METHOD(lldb::SBSymbol, SBModule, GetSymbolAtIndex, (size_t));
+ LLDB_REGISTER_METHOD(lldb::SBSymbol, SBModule, FindSymbol,
+ (const char *, lldb::SymbolType));
+ LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBModule, FindSymbols,
+ (const char *, lldb::SymbolType));
+ LLDB_REGISTER_METHOD(size_t, SBModule, GetNumSections, ());
+ LLDB_REGISTER_METHOD(lldb::SBSection, SBModule, GetSectionAtIndex,
+ (size_t));
+ LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBModule, FindFunctions,
+ (const char *, uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBValueList, SBModule, FindGlobalVariables,
+ (lldb::SBTarget &, const char *, uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBModule, FindFirstGlobalVariable,
+ (lldb::SBTarget &, const char *));
+ LLDB_REGISTER_METHOD(lldb::SBType, SBModule, FindFirstType, (const char *));
+ LLDB_REGISTER_METHOD(lldb::SBType, SBModule, GetBasicType,
+ (lldb::BasicType));
+ LLDB_REGISTER_METHOD(lldb::SBTypeList, SBModule, FindTypes, (const char *));
+ LLDB_REGISTER_METHOD(lldb::SBType, SBModule, GetTypeByID,
+ (lldb::user_id_t));
+ LLDB_REGISTER_METHOD(lldb::SBTypeList, SBModule, GetTypes, (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBSection, SBModule, FindSection,
+ (const char *));
+ LLDB_REGISTER_METHOD(lldb::ByteOrder, SBModule, GetByteOrder, ());
+ LLDB_REGISTER_METHOD(const char *, SBModule, GetTriple, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBModule, GetAddressByteSize, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBModule, GetVersion,
+ (uint32_t *, uint32_t));
+ LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBModule, GetSymbolFileSpec,
+ ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBModule,
+ GetObjectFileHeaderAddress, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBModule,
+ GetObjectFileEntryPointAddress, ());
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBModuleSpec.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBModuleSpec.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBModuleSpec.cpp (original)
+++ lldb/trunk/source/API/SBModuleSpec.cpp Tue Mar 19 10:13:13 2019
@@ -243,3 +243,58 @@ bool SBModuleSpecList::GetDescription(ll
m_opaque_up->Dump(description.ref());
return true;
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBModuleSpec>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBModuleSpec, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBModuleSpec, (const lldb::SBModuleSpec &));
+ LLDB_REGISTER_METHOD(const lldb::SBModuleSpec &,
+ SBModuleSpec, operator=,(const lldb::SBModuleSpec &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBModuleSpec, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBModuleSpec, operator bool, ());
+ LLDB_REGISTER_METHOD(void, SBModuleSpec, Clear, ());
+ LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBModuleSpec, GetFileSpec, ());
+ LLDB_REGISTER_METHOD(void, SBModuleSpec, SetFileSpec,
+ (const lldb::SBFileSpec &));
+ LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBModuleSpec, GetPlatformFileSpec,
+ ());
+ LLDB_REGISTER_METHOD(void, SBModuleSpec, SetPlatformFileSpec,
+ (const lldb::SBFileSpec &));
+ LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBModuleSpec, GetSymbolFileSpec, ());
+ LLDB_REGISTER_METHOD(void, SBModuleSpec, SetSymbolFileSpec,
+ (const lldb::SBFileSpec &));
+ LLDB_REGISTER_METHOD(const char *, SBModuleSpec, GetObjectName, ());
+ LLDB_REGISTER_METHOD(void, SBModuleSpec, SetObjectName, (const char *));
+ LLDB_REGISTER_METHOD(const char *, SBModuleSpec, GetTriple, ());
+ LLDB_REGISTER_METHOD(void, SBModuleSpec, SetTriple, (const char *));
+ LLDB_REGISTER_METHOD(size_t, SBModuleSpec, GetUUIDLength, ());
+ LLDB_REGISTER_METHOD(bool, SBModuleSpec, GetDescription,
+ (lldb::SBStream &));
+ LLDB_REGISTER_CONSTRUCTOR(SBModuleSpecList, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBModuleSpecList,
+ (const lldb::SBModuleSpecList &));
+ LLDB_REGISTER_METHOD(
+ lldb::SBModuleSpecList &,
+ SBModuleSpecList, operator=,(const lldb::SBModuleSpecList &));
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBModuleSpecList, SBModuleSpecList,
+ GetModuleSpecifications, (const char *));
+ LLDB_REGISTER_METHOD(void, SBModuleSpecList, Append,
+ (const lldb::SBModuleSpec &));
+ LLDB_REGISTER_METHOD(void, SBModuleSpecList, Append,
+ (const lldb::SBModuleSpecList &));
+ LLDB_REGISTER_METHOD(size_t, SBModuleSpecList, GetSize, ());
+ LLDB_REGISTER_METHOD(lldb::SBModuleSpec, SBModuleSpecList, GetSpecAtIndex,
+ (size_t));
+ LLDB_REGISTER_METHOD(lldb::SBModuleSpec, SBModuleSpecList,
+ FindFirstMatchingSpec, (const lldb::SBModuleSpec &));
+ LLDB_REGISTER_METHOD(lldb::SBModuleSpecList, SBModuleSpecList,
+ FindMatchingSpecs, (const lldb::SBModuleSpec &));
+ LLDB_REGISTER_METHOD(bool, SBModuleSpecList, GetDescription,
+ (lldb::SBStream &));
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBPlatform.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBPlatform.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBPlatform.cpp (original)
+++ lldb/trunk/source/API/SBPlatform.cpp Tue Mar 19 10:13:13 2019
@@ -624,3 +624,95 @@ SBUnixSignals SBPlatform::GetUnixSignals
return LLDB_RECORD_RESULT(SBUnixSignals());
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBPlatformConnectOptions>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBPlatformConnectOptions, (const char *));
+ LLDB_REGISTER_CONSTRUCTOR(SBPlatformConnectOptions,
+ (const lldb::SBPlatformConnectOptions &));
+ LLDB_REGISTER_METHOD(
+ void,
+ SBPlatformConnectOptions, operator=,(
+ const lldb::SBPlatformConnectOptions &));
+ LLDB_REGISTER_METHOD(const char *, SBPlatformConnectOptions, GetURL, ());
+ LLDB_REGISTER_METHOD(void, SBPlatformConnectOptions, SetURL,
+ (const char *));
+ LLDB_REGISTER_METHOD(bool, SBPlatformConnectOptions, GetRsyncEnabled, ());
+ LLDB_REGISTER_METHOD(void, SBPlatformConnectOptions, EnableRsync,
+ (const char *, const char *, bool));
+ LLDB_REGISTER_METHOD(void, SBPlatformConnectOptions, DisableRsync, ());
+ LLDB_REGISTER_METHOD(const char *, SBPlatformConnectOptions,
+ GetLocalCacheDirectory, ());
+ LLDB_REGISTER_METHOD(void, SBPlatformConnectOptions, SetLocalCacheDirectory,
+ (const char *));
+}
+
+template <>
+void RegisterMethods<SBPlatformShellCommand>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBPlatformShellCommand, (const char *));
+ LLDB_REGISTER_CONSTRUCTOR(SBPlatformShellCommand,
+ (const lldb::SBPlatformShellCommand &));
+ LLDB_REGISTER_METHOD(void, SBPlatformShellCommand, Clear, ());
+ LLDB_REGISTER_METHOD(const char *, SBPlatformShellCommand, GetCommand, ());
+ LLDB_REGISTER_METHOD(void, SBPlatformShellCommand, SetCommand,
+ (const char *));
+ LLDB_REGISTER_METHOD(const char *, SBPlatformShellCommand,
+ GetWorkingDirectory, ());
+ LLDB_REGISTER_METHOD(void, SBPlatformShellCommand, SetWorkingDirectory,
+ (const char *));
+ LLDB_REGISTER_METHOD(uint32_t, SBPlatformShellCommand, GetTimeoutSeconds,
+ ());
+ LLDB_REGISTER_METHOD(void, SBPlatformShellCommand, SetTimeoutSeconds,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(int, SBPlatformShellCommand, GetSignal, ());
+ LLDB_REGISTER_METHOD(int, SBPlatformShellCommand, GetStatus, ());
+ LLDB_REGISTER_METHOD(const char *, SBPlatformShellCommand, GetOutput, ());
+}
+
+template <>
+void RegisterMethods<SBPlatform>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBPlatform, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBPlatform, (const char *));
+ LLDB_REGISTER_METHOD_CONST(bool, SBPlatform, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBPlatform, operator bool, ());
+ LLDB_REGISTER_METHOD(void, SBPlatform, Clear, ());
+ LLDB_REGISTER_METHOD(const char *, SBPlatform, GetName, ());
+ LLDB_REGISTER_METHOD(const char *, SBPlatform, GetWorkingDirectory, ());
+ LLDB_REGISTER_METHOD(bool, SBPlatform, SetWorkingDirectory, (const char *));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, ConnectRemote,
+ (lldb::SBPlatformConnectOptions &));
+ LLDB_REGISTER_METHOD(void, SBPlatform, DisconnectRemote, ());
+ LLDB_REGISTER_METHOD(bool, SBPlatform, IsConnected, ());
+ LLDB_REGISTER_METHOD(const char *, SBPlatform, GetTriple, ());
+ LLDB_REGISTER_METHOD(const char *, SBPlatform, GetOSBuild, ());
+ LLDB_REGISTER_METHOD(const char *, SBPlatform, GetOSDescription, ());
+ LLDB_REGISTER_METHOD(const char *, SBPlatform, GetHostname, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBPlatform, GetOSMajorVersion, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBPlatform, GetOSMinorVersion, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBPlatform, GetOSUpdateVersion, ());
+ LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Get,
+ (lldb::SBFileSpec &, lldb::SBFileSpec &));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Put,
+ (lldb::SBFileSpec &, lldb::SBFileSpec &));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Install,
+ (lldb::SBFileSpec &, lldb::SBFileSpec &));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Run,
+ (lldb::SBPlatformShellCommand &));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Launch,
+ (lldb::SBLaunchInfo &));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Kill, (const lldb::pid_t));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, MakeDirectory,
+ (const char *, uint32_t));
+ LLDB_REGISTER_METHOD(uint32_t, SBPlatform, GetFilePermissions,
+ (const char *));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, SetFilePermissions,
+ (const char *, uint32_t));
+ LLDB_REGISTER_METHOD_CONST(lldb::SBUnixSignals, SBPlatform, GetUnixSignals,
+ ());
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBProcess.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBProcess.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBProcess.cpp (original)
+++ lldb/trunk/source/API/SBProcess.cpp Tue Mar 19 10:13:13 2019
@@ -1272,3 +1272,137 @@ lldb::SBProcessInfo SBProcess::GetProces
}
return LLDB_RECORD_RESULT(sb_proc_info);
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBProcess>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBProcess, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBProcess, (const lldb::SBProcess &));
+ LLDB_REGISTER_CONSTRUCTOR(SBProcess, (const lldb::ProcessSP &));
+ LLDB_REGISTER_METHOD(const lldb::SBProcess &,
+ SBProcess, operator=,(const lldb::SBProcess &));
+ LLDB_REGISTER_STATIC_METHOD(const char *, SBProcess,
+ GetBroadcasterClassName, ());
+ LLDB_REGISTER_METHOD(const char *, SBProcess, GetPluginName, ());
+ LLDB_REGISTER_METHOD(const char *, SBProcess, GetShortPluginName, ());
+ LLDB_REGISTER_METHOD(void, SBProcess, Clear, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBProcess, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBProcess, operator bool, ());
+ LLDB_REGISTER_METHOD(bool, SBProcess, RemoteLaunch,
+ (const char **, const char **, const char *,
+ const char *, const char *, const char *, uint32_t,
+ bool, lldb::SBError &));
+ LLDB_REGISTER_METHOD(bool, SBProcess, RemoteAttachToProcessWithID,
+ (lldb::pid_t, lldb::SBError &));
+ LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetNumThreads, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBThread, SBProcess, GetSelectedThread,
+ ());
+ LLDB_REGISTER_METHOD(lldb::SBThread, SBProcess, CreateOSPluginThread,
+ (lldb::tid_t, lldb::addr_t));
+ LLDB_REGISTER_METHOD_CONST(lldb::SBTarget, SBProcess, GetTarget, ());
+ LLDB_REGISTER_METHOD(size_t, SBProcess, PutSTDIN, (const char *, size_t));
+ LLDB_REGISTER_METHOD_CONST(size_t, SBProcess, GetSTDOUT, (char *, size_t));
+ LLDB_REGISTER_METHOD_CONST(size_t, SBProcess, GetSTDERR, (char *, size_t));
+ LLDB_REGISTER_METHOD_CONST(size_t, SBProcess, GetAsyncProfileData,
+ (char *, size_t));
+ LLDB_REGISTER_METHOD(lldb::SBTrace, SBProcess, StartTrace,
+ (lldb::SBTraceOptions &, lldb::SBError &));
+ LLDB_REGISTER_METHOD_CONST(void, SBProcess, ReportEventState,
+ (const lldb::SBEvent &, FILE *));
+ LLDB_REGISTER_METHOD(
+ void, SBProcess, AppendEventStateReport,
+ (const lldb::SBEvent &, lldb::SBCommandReturnObject &));
+ LLDB_REGISTER_METHOD(bool, SBProcess, SetSelectedThread,
+ (const lldb::SBThread &));
+ LLDB_REGISTER_METHOD(bool, SBProcess, SetSelectedThreadByID, (lldb::tid_t));
+ LLDB_REGISTER_METHOD(bool, SBProcess, SetSelectedThreadByIndexID,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBThread, SBProcess, GetThreadAtIndex, (size_t));
+ LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetNumQueues, ());
+ LLDB_REGISTER_METHOD(lldb::SBQueue, SBProcess, GetQueueAtIndex, (size_t));
+ LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetStopID, (bool));
+ LLDB_REGISTER_METHOD(lldb::SBEvent, SBProcess, GetStopEventForStopID,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::StateType, SBProcess, GetState, ());
+ LLDB_REGISTER_METHOD(int, SBProcess, GetExitStatus, ());
+ LLDB_REGISTER_METHOD(const char *, SBProcess, GetExitDescription, ());
+ LLDB_REGISTER_METHOD(lldb::pid_t, SBProcess, GetProcessID, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetUniqueID, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::ByteOrder, SBProcess, GetByteOrder, ());
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBProcess, GetAddressByteSize, ());
+ LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Continue, ());
+ LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Destroy, ());
+ LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Stop, ());
+ LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Kill, ());
+ LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Detach, ());
+ LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Detach, (bool));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Signal, (int));
+ LLDB_REGISTER_METHOD(lldb::SBUnixSignals, SBProcess, GetUnixSignals, ());
+ LLDB_REGISTER_METHOD(void, SBProcess, SendAsyncInterrupt, ());
+ LLDB_REGISTER_METHOD(lldb::SBThread, SBProcess, GetThreadByID,
+ (lldb::tid_t));
+ LLDB_REGISTER_METHOD(lldb::SBThread, SBProcess, GetThreadByIndexID,
+ (uint32_t));
+ LLDB_REGISTER_STATIC_METHOD(lldb::StateType, SBProcess, GetStateFromEvent,
+ (const lldb::SBEvent &));
+ LLDB_REGISTER_STATIC_METHOD(bool, SBProcess, GetRestartedFromEvent,
+ (const lldb::SBEvent &));
+ LLDB_REGISTER_STATIC_METHOD(size_t, SBProcess,
+ GetNumRestartedReasonsFromEvent,
+ (const lldb::SBEvent &));
+ LLDB_REGISTER_STATIC_METHOD(const char *, SBProcess,
+ GetRestartedReasonAtIndexFromEvent,
+ (const lldb::SBEvent &, size_t));
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBProcess, SBProcess, GetProcessFromEvent,
+ (const lldb::SBEvent &));
+ LLDB_REGISTER_STATIC_METHOD(bool, SBProcess, GetInterruptedFromEvent,
+ (const lldb::SBEvent &));
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBStructuredData, SBProcess,
+ GetStructuredDataFromEvent,
+ (const lldb::SBEvent &));
+ LLDB_REGISTER_STATIC_METHOD(bool, SBProcess, EventIsProcessEvent,
+ (const lldb::SBEvent &));
+ LLDB_REGISTER_STATIC_METHOD(bool, SBProcess, EventIsStructuredDataEvent,
+ (const lldb::SBEvent &));
+ LLDB_REGISTER_METHOD_CONST(lldb::SBBroadcaster, SBProcess, GetBroadcaster,
+ ());
+ LLDB_REGISTER_STATIC_METHOD(const char *, SBProcess, GetBroadcasterClass,
+ ());
+ LLDB_REGISTER_METHOD(uint64_t, SBProcess, ReadUnsignedFromMemory,
+ (lldb::addr_t, uint32_t, lldb::SBError &));
+ LLDB_REGISTER_METHOD(lldb::addr_t, SBProcess, ReadPointerFromMemory,
+ (lldb::addr_t, lldb::SBError &));
+ LLDB_REGISTER_METHOD(bool, SBProcess, GetDescription, (lldb::SBStream &));
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBProcess,
+ GetNumSupportedHardwareWatchpoints,
+ (lldb::SBError &));
+ LLDB_REGISTER_METHOD(uint32_t, SBProcess, LoadImage,
+ (lldb::SBFileSpec &, lldb::SBError &));
+ LLDB_REGISTER_METHOD(
+ uint32_t, SBProcess, LoadImage,
+ (const lldb::SBFileSpec &, const lldb::SBFileSpec &, lldb::SBError &));
+ LLDB_REGISTER_METHOD(uint32_t, SBProcess, LoadImageUsingPaths,
+ (const lldb::SBFileSpec &, lldb::SBStringList &,
+ lldb::SBFileSpec &, lldb::SBError &));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, UnloadImage, (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, SendEventData,
+ (const char *));
+ LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetNumExtendedBacktraceTypes, ());
+ LLDB_REGISTER_METHOD(const char *, SBProcess,
+ GetExtendedBacktraceTypeAtIndex, (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBThreadCollection, SBProcess, GetHistoryThreads,
+ (lldb::addr_t));
+ LLDB_REGISTER_METHOD(bool, SBProcess, IsInstrumentationRuntimePresent,
+ (lldb::InstrumentationRuntimeType));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, SaveCore, (const char *));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, GetMemoryRegionInfo,
+ (lldb::addr_t, lldb::SBMemoryRegionInfo &));
+ LLDB_REGISTER_METHOD(lldb::SBMemoryRegionInfoList, SBProcess,
+ GetMemoryRegions, ());
+ LLDB_REGISTER_METHOD(lldb::SBProcessInfo, SBProcess, GetProcessInfo, ());
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBProcessInfo.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBProcessInfo.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBProcessInfo.cpp (original)
+++ lldb/trunk/source/API/SBProcessInfo.cpp Tue Mar 19 10:13:13 2019
@@ -178,3 +178,33 @@ lldb::pid_t SBProcessInfo::GetParentProc
}
return proc_id;
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBProcessInfo>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBProcessInfo, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBProcessInfo, (const lldb::SBProcessInfo &));
+ LLDB_REGISTER_METHOD(
+ lldb::SBProcessInfo &,
+ SBProcessInfo, operator=,(const lldb::SBProcessInfo &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBProcessInfo, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBProcessInfo, operator bool, ());
+ LLDB_REGISTER_METHOD(const char *, SBProcessInfo, GetName, ());
+ LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBProcessInfo, GetExecutableFile,
+ ());
+ LLDB_REGISTER_METHOD(lldb::pid_t, SBProcessInfo, GetProcessID, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBProcessInfo, GetUserID, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBProcessInfo, GetGroupID, ());
+ LLDB_REGISTER_METHOD(bool, SBProcessInfo, UserIDIsValid, ());
+ LLDB_REGISTER_METHOD(bool, SBProcessInfo, GroupIDIsValid, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBProcessInfo, GetEffectiveUserID, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBProcessInfo, GetEffectiveGroupID, ());
+ LLDB_REGISTER_METHOD(bool, SBProcessInfo, EffectiveUserIDIsValid, ());
+ LLDB_REGISTER_METHOD(bool, SBProcessInfo, EffectiveGroupIDIsValid, ());
+ LLDB_REGISTER_METHOD(lldb::pid_t, SBProcessInfo, GetParentProcessID, ());
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBQueue.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBQueue.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBQueue.cpp (original)
+++ lldb/trunk/source/API/SBQueue.cpp Tue Mar 19 10:13:13 2019
@@ -328,3 +328,32 @@ lldb::QueueKind SBQueue::GetKind() {
return m_opaque_sp->GetKind();
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBQueue>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBQueue, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBQueue, (const lldb::QueueSP &));
+ LLDB_REGISTER_CONSTRUCTOR(SBQueue, (const lldb::SBQueue &));
+ LLDB_REGISTER_METHOD(const lldb::SBQueue &,
+ SBQueue, operator=,(const lldb::SBQueue &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBQueue, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBQueue, operator bool, ());
+ LLDB_REGISTER_METHOD(void, SBQueue, Clear, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::queue_id_t, SBQueue, GetQueueID, ());
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBQueue, GetIndexID, ());
+ LLDB_REGISTER_METHOD_CONST(const char *, SBQueue, GetName, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBQueue, GetNumThreads, ());
+ LLDB_REGISTER_METHOD(lldb::SBThread, SBQueue, GetThreadAtIndex, (uint32_t));
+ LLDB_REGISTER_METHOD(uint32_t, SBQueue, GetNumPendingItems, ());
+ LLDB_REGISTER_METHOD(lldb::SBQueueItem, SBQueue, GetPendingItemAtIndex,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(uint32_t, SBQueue, GetNumRunningItems, ());
+ LLDB_REGISTER_METHOD(lldb::SBProcess, SBQueue, GetProcess, ());
+ LLDB_REGISTER_METHOD(lldb::QueueKind, SBQueue, GetKind, ());
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBQueueItem.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBQueueItem.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBQueueItem.cpp (original)
+++ lldb/trunk/source/API/SBQueueItem.cpp Tue Mar 19 10:13:13 2019
@@ -119,3 +119,26 @@ SBThread SBQueueItem::GetExtendedBacktra
}
return LLDB_RECORD_RESULT(result);
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBQueueItem>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBQueueItem, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBQueueItem, (const lldb::QueueItemSP &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBQueueItem, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBQueueItem, operator bool, ());
+ LLDB_REGISTER_METHOD(void, SBQueueItem, Clear, ());
+ LLDB_REGISTER_METHOD(void, SBQueueItem, SetQueueItem,
+ (const lldb::QueueItemSP &));
+ LLDB_REGISTER_METHOD_CONST(lldb::QueueItemKind, SBQueueItem, GetKind, ());
+ LLDB_REGISTER_METHOD(void, SBQueueItem, SetKind, (lldb::QueueItemKind));
+ LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBQueueItem, GetAddress, ());
+ LLDB_REGISTER_METHOD(void, SBQueueItem, SetAddress, (lldb::SBAddress));
+ LLDB_REGISTER_METHOD(lldb::SBThread, SBQueueItem,
+ GetExtendedBacktraceThread, (const char *));
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBReproducer.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBReproducer.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBReproducer.cpp (original)
+++ lldb/trunk/source/API/SBReproducer.cpp Tue Mar 19 10:13:13 2019
@@ -29,2907 +29,79 @@ using namespace lldb;
using namespace lldb_private;
using namespace lldb_private::repro;
-static void SetFileHandleRedirect(SBDebugger *, FILE *, bool) {
- // Do nothing.
-}
-
-static bool GetDefaultArchitectureRedirect(char *arch_name,
- size_t arch_name_len) {
- // The function is writing to its argument. Without the redirect it would
- // write into the replay buffer.
- char buffer[1024];
- return SBDebugger::GetDefaultArchitecture(buffer, arch_name_len);
-}
-
SBRegistry::SBRegistry() {
+ Registry& R = *this;
- // Custom implementation.
- Register(&invoke<void (SBDebugger::*)(
- FILE *, bool)>::method<&SBDebugger::SetErrorFileHandle>::doit,
- &SetFileHandleRedirect);
- Register(&invoke<void (SBDebugger::*)(
- FILE *, bool)>::method<&SBDebugger::SetOutputFileHandle>::doit,
- &SetFileHandleRedirect);
- Register<bool(char *, size_t)>(static_cast<bool (*)(char *, size_t)>(
- &SBDebugger::GetDefaultArchitecture),
- &GetDefaultArchitectureRedirect);
-
- {
- LLDB_REGISTER_CONSTRUCTOR(SBAddress, ());
- LLDB_REGISTER_CONSTRUCTOR(SBAddress, (const lldb::SBAddress &));
- LLDB_REGISTER_CONSTRUCTOR(SBAddress, (lldb::SBSection, lldb::addr_t));
- LLDB_REGISTER_CONSTRUCTOR(SBAddress, (lldb::addr_t, lldb::SBTarget &));
- LLDB_REGISTER_METHOD(const lldb::SBAddress &,
- SBAddress, operator=,(const lldb::SBAddress &));
- LLDB_REGISTER_METHOD_CONST(bool, SBAddress, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBAddress, operator bool, ());
- LLDB_REGISTER_METHOD(void, SBAddress, Clear, ());
- LLDB_REGISTER_METHOD(void, SBAddress, SetAddress,
- (lldb::SBSection, lldb::addr_t));
- LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBAddress, GetFileAddress, ());
- LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBAddress, GetLoadAddress,
- (const lldb::SBTarget &));
- LLDB_REGISTER_METHOD(void, SBAddress, SetLoadAddress,
- (lldb::addr_t, lldb::SBTarget &));
- LLDB_REGISTER_METHOD(bool, SBAddress, OffsetAddress, (lldb::addr_t));
- LLDB_REGISTER_METHOD(lldb::SBSection, SBAddress, GetSection, ());
- LLDB_REGISTER_METHOD(lldb::addr_t, SBAddress, GetOffset, ());
- LLDB_REGISTER_METHOD(bool, SBAddress, GetDescription, (lldb::SBStream &));
- LLDB_REGISTER_METHOD(lldb::SBModule, SBAddress, GetModule, ());
- LLDB_REGISTER_METHOD(lldb::SBSymbolContext, SBAddress, GetSymbolContext,
- (uint32_t));
- LLDB_REGISTER_METHOD(lldb::SBCompileUnit, SBAddress, GetCompileUnit, ());
- LLDB_REGISTER_METHOD(lldb::SBFunction, SBAddress, GetFunction, ());
- LLDB_REGISTER_METHOD(lldb::SBBlock, SBAddress, GetBlock, ());
- LLDB_REGISTER_METHOD(lldb::SBSymbol, SBAddress, GetSymbol, ());
- LLDB_REGISTER_METHOD(lldb::SBLineEntry, SBAddress, GetLineEntry, ());
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, ());
- LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, (lldb::pid_t));
- LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, (const char *, bool));
- LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, (const char *, bool, bool));
- LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, (const lldb::SBAttachInfo &));
- LLDB_REGISTER_METHOD(lldb::SBAttachInfo &,
- SBAttachInfo, operator=,(const lldb::SBAttachInfo &));
- LLDB_REGISTER_METHOD(lldb::pid_t, SBAttachInfo, GetProcessID, ());
- LLDB_REGISTER_METHOD(void, SBAttachInfo, SetProcessID, (lldb::pid_t));
- LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetResumeCount, ());
- LLDB_REGISTER_METHOD(void, SBAttachInfo, SetResumeCount, (uint32_t));
- LLDB_REGISTER_METHOD(const char *, SBAttachInfo, GetProcessPluginName, ());
- LLDB_REGISTER_METHOD(void, SBAttachInfo, SetProcessPluginName,
- (const char *));
- LLDB_REGISTER_METHOD(void, SBAttachInfo, SetExecutable, (const char *));
- LLDB_REGISTER_METHOD(void, SBAttachInfo, SetExecutable, (lldb::SBFileSpec));
- LLDB_REGISTER_METHOD(bool, SBAttachInfo, GetWaitForLaunch, ());
- LLDB_REGISTER_METHOD(void, SBAttachInfo, SetWaitForLaunch, (bool));
- LLDB_REGISTER_METHOD(void, SBAttachInfo, SetWaitForLaunch, (bool, bool));
- LLDB_REGISTER_METHOD(bool, SBAttachInfo, GetIgnoreExisting, ());
- LLDB_REGISTER_METHOD(void, SBAttachInfo, SetIgnoreExisting, (bool));
- LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetUserID, ());
- LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetGroupID, ());
- LLDB_REGISTER_METHOD(bool, SBAttachInfo, UserIDIsValid, ());
- LLDB_REGISTER_METHOD(bool, SBAttachInfo, GroupIDIsValid, ());
- LLDB_REGISTER_METHOD(void, SBAttachInfo, SetUserID, (uint32_t));
- LLDB_REGISTER_METHOD(void, SBAttachInfo, SetGroupID, (uint32_t));
- LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetEffectiveUserID, ());
- LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetEffectiveGroupID, ());
- LLDB_REGISTER_METHOD(bool, SBAttachInfo, EffectiveUserIDIsValid, ());
- LLDB_REGISTER_METHOD(bool, SBAttachInfo, EffectiveGroupIDIsValid, ());
- LLDB_REGISTER_METHOD(void, SBAttachInfo, SetEffectiveUserID, (uint32_t));
- LLDB_REGISTER_METHOD(void, SBAttachInfo, SetEffectiveGroupID, (uint32_t));
- LLDB_REGISTER_METHOD(lldb::pid_t, SBAttachInfo, GetParentProcessID, ());
- LLDB_REGISTER_METHOD(void, SBAttachInfo, SetParentProcessID, (lldb::pid_t));
- LLDB_REGISTER_METHOD(bool, SBAttachInfo, ParentProcessIDIsValid, ());
- LLDB_REGISTER_METHOD(lldb::SBListener, SBAttachInfo, GetListener, ());
- LLDB_REGISTER_METHOD(void, SBAttachInfo, SetListener, (lldb::SBListener &));
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBBlock, ());
- LLDB_REGISTER_CONSTRUCTOR(SBBlock, (const lldb::SBBlock &));
- LLDB_REGISTER_METHOD(const lldb::SBBlock &,
- SBBlock, operator=,(const lldb::SBBlock &));
- LLDB_REGISTER_METHOD_CONST(bool, SBBlock, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBBlock, operator bool, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBBlock, IsInlined, ());
- LLDB_REGISTER_METHOD_CONST(const char *, SBBlock, GetInlinedName, ());
- LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBBlock,
- GetInlinedCallSiteFile, ());
- LLDB_REGISTER_METHOD_CONST(uint32_t, SBBlock, GetInlinedCallSiteLine, ());
- LLDB_REGISTER_METHOD_CONST(uint32_t, SBBlock, GetInlinedCallSiteColumn, ());
- LLDB_REGISTER_METHOD(lldb::SBBlock, SBBlock, GetParent, ());
- LLDB_REGISTER_METHOD(lldb::SBBlock, SBBlock, GetContainingInlinedBlock, ());
- LLDB_REGISTER_METHOD(lldb::SBBlock, SBBlock, GetSibling, ());
- LLDB_REGISTER_METHOD(lldb::SBBlock, SBBlock, GetFirstChild, ());
- LLDB_REGISTER_METHOD(bool, SBBlock, GetDescription, (lldb::SBStream &));
- LLDB_REGISTER_METHOD(uint32_t, SBBlock, GetNumRanges, ());
- LLDB_REGISTER_METHOD(lldb::SBAddress, SBBlock, GetRangeStartAddress,
- (uint32_t));
- LLDB_REGISTER_METHOD(lldb::SBAddress, SBBlock, GetRangeEndAddress,
- (uint32_t));
- LLDB_REGISTER_METHOD(uint32_t, SBBlock, GetRangeIndexForBlockAddress,
- (lldb::SBAddress));
- LLDB_REGISTER_METHOD(
- lldb::SBValueList, SBBlock, GetVariables,
- (lldb::SBFrame &, bool, bool, bool, lldb::DynamicValueType));
- LLDB_REGISTER_METHOD(lldb::SBValueList, SBBlock, GetVariables,
- (lldb::SBTarget &, bool, bool, bool));
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBBreakpoint, ());
- LLDB_REGISTER_CONSTRUCTOR(SBBreakpoint, (const lldb::SBBreakpoint &));
- LLDB_REGISTER_CONSTRUCTOR(SBBreakpoint, (const lldb::BreakpointSP &));
- LLDB_REGISTER_METHOD(const lldb::SBBreakpoint &,
- SBBreakpoint, operator=,(const lldb::SBBreakpoint &));
- LLDB_REGISTER_METHOD(bool,
- SBBreakpoint, operator==,(const lldb::SBBreakpoint &));
- LLDB_REGISTER_METHOD(bool,
- SBBreakpoint, operator!=,(const lldb::SBBreakpoint &));
- LLDB_REGISTER_METHOD_CONST(lldb::break_id_t, SBBreakpoint, GetID, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBBreakpoint, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBBreakpoint, operator bool, ());
- LLDB_REGISTER_METHOD(void, SBBreakpoint, ClearAllBreakpointSites, ());
- LLDB_REGISTER_METHOD(lldb::SBBreakpointLocation, SBBreakpoint,
- FindLocationByAddress, (lldb::addr_t));
- LLDB_REGISTER_METHOD(lldb::break_id_t, SBBreakpoint,
- FindLocationIDByAddress, (lldb::addr_t));
- LLDB_REGISTER_METHOD(lldb::SBBreakpointLocation, SBBreakpoint,
- FindLocationByID, (lldb::break_id_t));
- LLDB_REGISTER_METHOD(lldb::SBBreakpointLocation, SBBreakpoint,
- GetLocationAtIndex, (uint32_t));
- LLDB_REGISTER_METHOD(void, SBBreakpoint, SetEnabled, (bool));
- LLDB_REGISTER_METHOD(bool, SBBreakpoint, IsEnabled, ());
- LLDB_REGISTER_METHOD(void, SBBreakpoint, SetOneShot, (bool));
- LLDB_REGISTER_METHOD_CONST(bool, SBBreakpoint, IsOneShot, ());
- LLDB_REGISTER_METHOD(bool, SBBreakpoint, IsInternal, ());
- LLDB_REGISTER_METHOD(void, SBBreakpoint, SetIgnoreCount, (uint32_t));
- LLDB_REGISTER_METHOD(void, SBBreakpoint, SetCondition, (const char *));
- LLDB_REGISTER_METHOD(const char *, SBBreakpoint, GetCondition, ());
- LLDB_REGISTER_METHOD(void, SBBreakpoint, SetAutoContinue, (bool));
- LLDB_REGISTER_METHOD(bool, SBBreakpoint, GetAutoContinue, ());
- LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpoint, GetHitCount, ());
- LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpoint, GetIgnoreCount, ());
- LLDB_REGISTER_METHOD(void, SBBreakpoint, SetThreadID, (lldb::tid_t));
- LLDB_REGISTER_METHOD(lldb::tid_t, SBBreakpoint, GetThreadID, ());
- LLDB_REGISTER_METHOD(void, SBBreakpoint, SetThreadIndex, (uint32_t));
- LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpoint, GetThreadIndex, ());
- LLDB_REGISTER_METHOD(void, SBBreakpoint, SetThreadName, (const char *));
- LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpoint, GetThreadName, ());
- LLDB_REGISTER_METHOD(void, SBBreakpoint, SetQueueName, (const char *));
- LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpoint, GetQueueName, ());
- LLDB_REGISTER_METHOD_CONST(size_t, SBBreakpoint, GetNumResolvedLocations,
- ());
- LLDB_REGISTER_METHOD_CONST(size_t, SBBreakpoint, GetNumLocations, ());
- LLDB_REGISTER_METHOD(void, SBBreakpoint, SetCommandLineCommands,
- (lldb::SBStringList &));
- LLDB_REGISTER_METHOD(bool, SBBreakpoint, GetCommandLineCommands,
- (lldb::SBStringList &));
- LLDB_REGISTER_METHOD(bool, SBBreakpoint, GetDescription,
- (lldb::SBStream &));
- LLDB_REGISTER_METHOD(bool, SBBreakpoint, GetDescription,
- (lldb::SBStream &, bool));
- LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpoint, AddLocation,
- (lldb::SBAddress &));
- LLDB_REGISTER_METHOD(void, SBBreakpoint, SetScriptCallbackFunction,
- (const char *));
- LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpoint, SetScriptCallbackBody,
- (const char *));
- LLDB_REGISTER_METHOD(bool, SBBreakpoint, AddName, (const char *));
- LLDB_REGISTER_METHOD(void, SBBreakpoint, RemoveName, (const char *));
- LLDB_REGISTER_METHOD(bool, SBBreakpoint, MatchesName, (const char *));
- LLDB_REGISTER_METHOD(void, SBBreakpoint, GetNames, (lldb::SBStringList &));
- LLDB_REGISTER_STATIC_METHOD(bool, SBBreakpoint, EventIsBreakpointEvent,
- (const lldb::SBEvent &));
- LLDB_REGISTER_STATIC_METHOD(lldb::BreakpointEventType, SBBreakpoint,
- GetBreakpointEventTypeFromEvent,
- (const lldb::SBEvent &));
- LLDB_REGISTER_STATIC_METHOD(lldb::SBBreakpoint, SBBreakpoint,
- GetBreakpointFromEvent,
- (const lldb::SBEvent &));
- LLDB_REGISTER_STATIC_METHOD(lldb::SBBreakpointLocation, SBBreakpoint,
- GetBreakpointLocationAtIndexFromEvent,
- (const lldb::SBEvent &, uint32_t));
- LLDB_REGISTER_STATIC_METHOD(uint32_t, SBBreakpoint,
- GetNumBreakpointLocationsFromEvent,
- (const lldb::SBEvent &));
- LLDB_REGISTER_METHOD_CONST(bool, SBBreakpoint, IsHardware, ());
- LLDB_REGISTER_CONSTRUCTOR(SBBreakpointList, (lldb::SBTarget &));
- LLDB_REGISTER_METHOD_CONST(size_t, SBBreakpointList, GetSize, ());
- LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBBreakpointList,
- GetBreakpointAtIndex, (size_t));
- LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBBreakpointList,
- FindBreakpointByID, (lldb::break_id_t));
- LLDB_REGISTER_METHOD(void, SBBreakpointList, Append,
- (const lldb::SBBreakpoint &));
- LLDB_REGISTER_METHOD(void, SBBreakpointList, AppendByID,
- (lldb::break_id_t));
- LLDB_REGISTER_METHOD(bool, SBBreakpointList, AppendIfUnique,
- (const lldb::SBBreakpoint &));
- LLDB_REGISTER_METHOD(void, SBBreakpointList, Clear, ());
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBBreakpointLocation, ());
- LLDB_REGISTER_CONSTRUCTOR(SBBreakpointLocation,
- (const lldb::BreakpointLocationSP &));
- LLDB_REGISTER_CONSTRUCTOR(SBBreakpointLocation,
- (const lldb::SBBreakpointLocation &));
- LLDB_REGISTER_METHOD(
- const lldb::SBBreakpointLocation &,
- SBBreakpointLocation, operator=,(const lldb::SBBreakpointLocation &));
- LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointLocation, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointLocation, operator bool, ());
- LLDB_REGISTER_METHOD(lldb::SBAddress, SBBreakpointLocation, GetAddress, ());
- LLDB_REGISTER_METHOD(lldb::addr_t, SBBreakpointLocation, GetLoadAddress,
- ());
- LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetEnabled, (bool));
- LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, IsEnabled, ());
- LLDB_REGISTER_METHOD(uint32_t, SBBreakpointLocation, GetHitCount, ());
- LLDB_REGISTER_METHOD(uint32_t, SBBreakpointLocation, GetIgnoreCount, ());
- LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetIgnoreCount,
- (uint32_t));
- LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetCondition,
- (const char *));
- LLDB_REGISTER_METHOD(const char *, SBBreakpointLocation, GetCondition, ());
- LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetAutoContinue, (bool));
- LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, GetAutoContinue, ());
- LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetScriptCallbackFunction,
- (const char *));
- LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpointLocation,
- SetScriptCallbackBody, (const char *));
- LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetCommandLineCommands,
- (lldb::SBStringList &));
- LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, GetCommandLineCommands,
- (lldb::SBStringList &));
- LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetThreadID,
- (lldb::tid_t));
- LLDB_REGISTER_METHOD(lldb::tid_t, SBBreakpointLocation, GetThreadID, ());
- LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetThreadIndex,
- (uint32_t));
- LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpointLocation, GetThreadIndex,
- ());
- LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetThreadName,
- (const char *));
- LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointLocation,
- GetThreadName, ());
- LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetQueueName,
- (const char *));
- LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointLocation, GetQueueName,
- ());
- LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, IsResolved, ());
- LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, GetDescription,
- (lldb::SBStream &, lldb::DescriptionLevel));
- LLDB_REGISTER_METHOD(lldb::break_id_t, SBBreakpointLocation, GetID, ());
- LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBBreakpointLocation,
- GetBreakpoint, ());
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBBreakpointName, ());
- LLDB_REGISTER_CONSTRUCTOR(SBBreakpointName,
- (lldb::SBTarget &, const char *));
- LLDB_REGISTER_CONSTRUCTOR(SBBreakpointName,
- (lldb::SBBreakpoint &, const char *));
- LLDB_REGISTER_CONSTRUCTOR(SBBreakpointName,
- (const lldb::SBBreakpointName &));
- LLDB_REGISTER_METHOD(
- const lldb::SBBreakpointName &,
- SBBreakpointName, operator=,(const lldb::SBBreakpointName &));
- LLDB_REGISTER_METHOD(
- bool, SBBreakpointName, operator==,(const lldb::SBBreakpointName &));
- LLDB_REGISTER_METHOD(
- bool, SBBreakpointName, operator!=,(const lldb::SBBreakpointName &));
- LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointName, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointName, operator bool, ());
- LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointName, GetName, ());
- LLDB_REGISTER_METHOD(void, SBBreakpointName, SetEnabled, (bool));
- LLDB_REGISTER_METHOD(bool, SBBreakpointName, IsEnabled, ());
- LLDB_REGISTER_METHOD(void, SBBreakpointName, SetOneShot, (bool));
- LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointName, IsOneShot, ());
- LLDB_REGISTER_METHOD(void, SBBreakpointName, SetIgnoreCount, (uint32_t));
- LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpointName, GetIgnoreCount, ());
- LLDB_REGISTER_METHOD(void, SBBreakpointName, SetCondition, (const char *));
- LLDB_REGISTER_METHOD(const char *, SBBreakpointName, GetCondition, ());
- LLDB_REGISTER_METHOD(void, SBBreakpointName, SetAutoContinue, (bool));
- LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetAutoContinue, ());
- LLDB_REGISTER_METHOD(void, SBBreakpointName, SetThreadID, (lldb::tid_t));
- LLDB_REGISTER_METHOD(lldb::tid_t, SBBreakpointName, GetThreadID, ());
- LLDB_REGISTER_METHOD(void, SBBreakpointName, SetThreadIndex, (uint32_t));
- LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpointName, GetThreadIndex, ());
- LLDB_REGISTER_METHOD(void, SBBreakpointName, SetThreadName, (const char *));
- LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointName, GetThreadName,
- ());
- LLDB_REGISTER_METHOD(void, SBBreakpointName, SetQueueName, (const char *));
- LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointName, GetQueueName,
- ());
- LLDB_REGISTER_METHOD(void, SBBreakpointName, SetCommandLineCommands,
- (lldb::SBStringList &));
- LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetCommandLineCommands,
- (lldb::SBStringList &));
- LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointName, GetHelpString,
- ());
- LLDB_REGISTER_METHOD(void, SBBreakpointName, SetHelpString, (const char *));
- LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetDescription,
- (lldb::SBStream &));
- LLDB_REGISTER_METHOD(void, SBBreakpointName, SetScriptCallbackFunction,
- (const char *));
- LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpointName, SetScriptCallbackBody,
- (const char *));
- LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointName, GetAllowList, ());
- LLDB_REGISTER_METHOD(void, SBBreakpointName, SetAllowList, (bool));
- LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetAllowDelete, ());
- LLDB_REGISTER_METHOD(void, SBBreakpointName, SetAllowDelete, (bool));
- LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetAllowDisable, ());
- LLDB_REGISTER_METHOD(void, SBBreakpointName, SetAllowDisable, (bool));
- }
- {} {
- LLDB_REGISTER_CONSTRUCTOR(SBBroadcaster, ());
- LLDB_REGISTER_CONSTRUCTOR(SBBroadcaster, (const char *));
- LLDB_REGISTER_CONSTRUCTOR(SBBroadcaster, (const lldb::SBBroadcaster &));
- LLDB_REGISTER_METHOD(
- const lldb::SBBroadcaster &,
- SBBroadcaster, operator=,(const lldb::SBBroadcaster &));
- LLDB_REGISTER_METHOD(void, SBBroadcaster, BroadcastEventByType,
- (uint32_t, bool));
- LLDB_REGISTER_METHOD(void, SBBroadcaster, BroadcastEvent,
- (const lldb::SBEvent &, bool));
- LLDB_REGISTER_METHOD(void, SBBroadcaster, AddInitialEventsToListener,
- (const lldb::SBListener &, uint32_t));
- LLDB_REGISTER_METHOD(uint32_t, SBBroadcaster, AddListener,
- (const lldb::SBListener &, uint32_t));
- LLDB_REGISTER_METHOD_CONST(const char *, SBBroadcaster, GetName, ());
- LLDB_REGISTER_METHOD(bool, SBBroadcaster, EventTypeHasListeners,
- (uint32_t));
- LLDB_REGISTER_METHOD(bool, SBBroadcaster, RemoveListener,
- (const lldb::SBListener &, uint32_t));
- LLDB_REGISTER_METHOD_CONST(bool, SBBroadcaster, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBBroadcaster, operator bool, ());
- LLDB_REGISTER_METHOD(void, SBBroadcaster, Clear, ());
- LLDB_REGISTER_METHOD_CONST(
- bool, SBBroadcaster, operator==,(const lldb::SBBroadcaster &));
- LLDB_REGISTER_METHOD_CONST(
- bool, SBBroadcaster, operator!=,(const lldb::SBBroadcaster &));
- LLDB_REGISTER_METHOD_CONST(
- bool, SBBroadcaster, operator<,(const lldb::SBBroadcaster &));
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBCommandInterpreterRunOptions, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
- GetStopOnContinue, ());
- LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions,
- SetStopOnContinue, (bool));
- LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
- GetStopOnError, ());
- LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnError,
- (bool));
- LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
- GetStopOnCrash, ());
- LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnCrash,
- (bool));
- LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
- GetEchoCommands, ());
- LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetEchoCommands,
- (bool));
- LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
- GetEchoCommentCommands, ());
- LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions,
- SetEchoCommentCommands, (bool));
- LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
- GetPrintResults, ());
- LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetPrintResults,
- (bool));
- LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
- GetAddToHistory, ());
- LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetAddToHistory,
- (bool));
- LLDB_REGISTER_CONSTRUCTOR(SBCommandInterpreter,
- (lldb_private::CommandInterpreter *));
- LLDB_REGISTER_CONSTRUCTOR(SBCommandInterpreter,
- (const lldb::SBCommandInterpreter &));
- LLDB_REGISTER_METHOD(
- const lldb::SBCommandInterpreter &,
- SBCommandInterpreter, operator=,(const lldb::SBCommandInterpreter &));
- LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreter, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreter, operator bool, ());
- LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, CommandExists,
- (const char *));
- LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, AliasExists,
- (const char *));
- LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, IsActive, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreter, WasInterrupted, ());
- LLDB_REGISTER_METHOD(const char *, SBCommandInterpreter,
- GetIOHandlerControlSequence, (char));
- LLDB_REGISTER_METHOD(lldb::ReturnStatus, SBCommandInterpreter,
- HandleCommand,
- (const char *, lldb::SBCommandReturnObject &, bool));
- LLDB_REGISTER_METHOD(lldb::ReturnStatus, SBCommandInterpreter,
- HandleCommand,
- (const char *, lldb::SBExecutionContext &,
- lldb::SBCommandReturnObject &, bool));
- LLDB_REGISTER_METHOD(void, SBCommandInterpreter, HandleCommandsFromFile,
- (lldb::SBFileSpec &, lldb::SBExecutionContext &,
- lldb::SBCommandInterpreterRunOptions &,
- lldb::SBCommandReturnObject));
- LLDB_REGISTER_METHOD(int, SBCommandInterpreter, HandleCompletion,
- (const char *, const char *, const char *, int, int,
- lldb::SBStringList &));
- LLDB_REGISTER_METHOD(int, SBCommandInterpreter,
- HandleCompletionWithDescriptions,
- (const char *, const char *, const char *, int, int,
- lldb::SBStringList &, lldb::SBStringList &));
- LLDB_REGISTER_METHOD(int, SBCommandInterpreter,
- HandleCompletionWithDescriptions,
- (const char *, uint32_t, int, int,
- lldb::SBStringList &, lldb::SBStringList &));
- LLDB_REGISTER_METHOD(
- int, SBCommandInterpreter, HandleCompletion,
- (const char *, uint32_t, int, int, lldb::SBStringList &));
- LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasCommands, ());
- LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasAliases, ());
- LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasAliasOptions, ());
- LLDB_REGISTER_METHOD(lldb::SBProcess, SBCommandInterpreter, GetProcess, ());
- LLDB_REGISTER_METHOD(lldb::SBDebugger, SBCommandInterpreter, GetDebugger,
- ());
- LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, GetPromptOnQuit, ());
- LLDB_REGISTER_METHOD(void, SBCommandInterpreter, SetPromptOnQuit, (bool));
- LLDB_REGISTER_METHOD(void, SBCommandInterpreter, AllowExitCodeOnQuit,
- (bool));
- LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasCustomQuitExitCode, ());
- LLDB_REGISTER_METHOD(int, SBCommandInterpreter, GetQuitStatus, ());
- LLDB_REGISTER_METHOD(void, SBCommandInterpreter, ResolveCommand,
- (const char *, lldb::SBCommandReturnObject &));
- LLDB_REGISTER_METHOD(void, SBCommandInterpreter,
- SourceInitFileInHomeDirectory,
- (lldb::SBCommandReturnObject &));
- LLDB_REGISTER_METHOD(void, SBCommandInterpreter,
- SourceInitFileInCurrentWorkingDirectory,
- (lldb::SBCommandReturnObject &));
- LLDB_REGISTER_METHOD(lldb::SBBroadcaster, SBCommandInterpreter,
- GetBroadcaster, ());
- LLDB_REGISTER_STATIC_METHOD(const char *, SBCommandInterpreter,
- GetBroadcasterClass, ());
- LLDB_REGISTER_STATIC_METHOD(const char *, SBCommandInterpreter,
- GetArgumentTypeAsCString,
- (const lldb::CommandArgumentType));
- LLDB_REGISTER_STATIC_METHOD(const char *, SBCommandInterpreter,
- GetArgumentDescriptionAsCString,
- (const lldb::CommandArgumentType));
- LLDB_REGISTER_STATIC_METHOD(bool, SBCommandInterpreter,
- EventIsCommandInterpreterEvent,
- (const lldb::SBEvent &));
- LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommandInterpreter,
- AddMultiwordCommand, (const char *, const char *));
- LLDB_REGISTER_METHOD(
- lldb::SBCommand, SBCommandInterpreter, AddCommand,
- (const char *, lldb::SBCommandPluginInterface *, const char *));
- LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommandInterpreter, AddCommand,
- (const char *, lldb::SBCommandPluginInterface *,
- const char *, const char *));
- LLDB_REGISTER_CONSTRUCTOR(SBCommand, ());
- LLDB_REGISTER_METHOD(bool, SBCommand, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBCommand, operator bool, ());
- LLDB_REGISTER_METHOD(const char *, SBCommand, GetName, ());
- LLDB_REGISTER_METHOD(const char *, SBCommand, GetHelp, ());
- LLDB_REGISTER_METHOD(const char *, SBCommand, GetHelpLong, ());
- LLDB_REGISTER_METHOD(void, SBCommand, SetHelp, (const char *));
- LLDB_REGISTER_METHOD(void, SBCommand, SetHelpLong, (const char *));
- LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommand, AddMultiwordCommand,
- (const char *, const char *));
- LLDB_REGISTER_METHOD(
- lldb::SBCommand, SBCommand, AddCommand,
- (const char *, lldb::SBCommandPluginInterface *, const char *));
- LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommand, AddCommand,
- (const char *, lldb::SBCommandPluginInterface *,
- const char *, const char *));
- LLDB_REGISTER_METHOD(uint32_t, SBCommand, GetFlags, ());
- LLDB_REGISTER_METHOD(void, SBCommand, SetFlags, (uint32_t));
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBCommandReturnObject, ());
- LLDB_REGISTER_CONSTRUCTOR(SBCommandReturnObject,
- (const lldb::SBCommandReturnObject &));
- LLDB_REGISTER_CONSTRUCTOR(SBCommandReturnObject,
- (lldb_private::CommandReturnObject *));
- LLDB_REGISTER_METHOD(lldb_private::CommandReturnObject *,
- SBCommandReturnObject, Release, ());
- LLDB_REGISTER_METHOD(
- const lldb::SBCommandReturnObject &,
- SBCommandReturnObject, operator=,(const lldb::SBCommandReturnObject &));
- LLDB_REGISTER_METHOD_CONST(bool, SBCommandReturnObject, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBCommandReturnObject, operator bool, ());
- LLDB_REGISTER_METHOD(const char *, SBCommandReturnObject, GetOutput, ());
- LLDB_REGISTER_METHOD(const char *, SBCommandReturnObject, GetError, ());
- LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, GetOutputSize, ());
- LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, GetErrorSize, ());
- LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, PutOutput, (FILE *));
- LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, PutError, (FILE *));
- LLDB_REGISTER_METHOD(void, SBCommandReturnObject, Clear, ());
- LLDB_REGISTER_METHOD(lldb::ReturnStatus, SBCommandReturnObject, GetStatus,
- ());
- LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetStatus,
- (lldb::ReturnStatus));
- LLDB_REGISTER_METHOD(bool, SBCommandReturnObject, Succeeded, ());
- LLDB_REGISTER_METHOD(bool, SBCommandReturnObject, HasResult, ());
- LLDB_REGISTER_METHOD(void, SBCommandReturnObject, AppendMessage,
- (const char *));
- LLDB_REGISTER_METHOD(void, SBCommandReturnObject, AppendWarning,
- (const char *));
- LLDB_REGISTER_METHOD(bool, SBCommandReturnObject, GetDescription,
- (lldb::SBStream &));
- LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
- (FILE *));
- LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
- (FILE *));
- LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
- (FILE *, bool));
- LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
- (FILE *, bool));
- LLDB_REGISTER_METHOD(void, SBCommandReturnObject, PutCString,
- (const char *, int));
- LLDB_REGISTER_METHOD(const char *, SBCommandReturnObject, GetOutput,
- (bool));
- LLDB_REGISTER_METHOD(const char *, SBCommandReturnObject, GetError, (bool));
- LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetError,
- (lldb::SBError &, const char *));
- LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetError, (const char *));
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBCommunication, ());
- LLDB_REGISTER_CONSTRUCTOR(SBCommunication, (const char *));
- LLDB_REGISTER_METHOD_CONST(bool, SBCommunication, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBCommunication, operator bool, ());
- LLDB_REGISTER_METHOD(bool, SBCommunication, GetCloseOnEOF, ());
- LLDB_REGISTER_METHOD(void, SBCommunication, SetCloseOnEOF, (bool));
- LLDB_REGISTER_METHOD(lldb::ConnectionStatus, SBCommunication, Connect,
- (const char *));
- LLDB_REGISTER_METHOD(lldb::ConnectionStatus, SBCommunication,
- AdoptFileDesriptor, (int, bool));
- LLDB_REGISTER_METHOD(lldb::ConnectionStatus, SBCommunication, Disconnect,
- ());
- LLDB_REGISTER_METHOD_CONST(bool, SBCommunication, IsConnected, ());
- LLDB_REGISTER_METHOD(bool, SBCommunication, ReadThreadStart, ());
- LLDB_REGISTER_METHOD(bool, SBCommunication, ReadThreadStop, ());
- LLDB_REGISTER_METHOD(bool, SBCommunication, ReadThreadIsRunning, ());
- LLDB_REGISTER_METHOD(lldb::SBBroadcaster, SBCommunication, GetBroadcaster,
- ());
- LLDB_REGISTER_STATIC_METHOD(const char *, SBCommunication,
- GetBroadcasterClass, ());
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBCompileUnit, ());
- LLDB_REGISTER_CONSTRUCTOR(SBCompileUnit, (const lldb::SBCompileUnit &));
- LLDB_REGISTER_METHOD(
- const lldb::SBCompileUnit &,
- SBCompileUnit, operator=,(const lldb::SBCompileUnit &));
- LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBCompileUnit, GetFileSpec,
- ());
- LLDB_REGISTER_METHOD_CONST(uint32_t, SBCompileUnit, GetNumLineEntries, ());
- LLDB_REGISTER_METHOD_CONST(lldb::SBLineEntry, SBCompileUnit,
- GetLineEntryAtIndex, (uint32_t));
- LLDB_REGISTER_METHOD_CONST(uint32_t, SBCompileUnit, FindLineEntryIndex,
- (uint32_t, uint32_t, lldb::SBFileSpec *));
- LLDB_REGISTER_METHOD_CONST(uint32_t, SBCompileUnit, FindLineEntryIndex,
- (uint32_t, uint32_t, lldb::SBFileSpec *, bool));
- LLDB_REGISTER_METHOD_CONST(uint32_t, SBCompileUnit, GetNumSupportFiles, ());
- LLDB_REGISTER_METHOD(lldb::SBTypeList, SBCompileUnit, GetTypes, (uint32_t));
- LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBCompileUnit,
- GetSupportFileAtIndex, (uint32_t));
- LLDB_REGISTER_METHOD(uint32_t, SBCompileUnit, FindSupportFileIndex,
- (uint32_t, const lldb::SBFileSpec &, bool));
- LLDB_REGISTER_METHOD(lldb::LanguageType, SBCompileUnit, GetLanguage, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBCompileUnit, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBCompileUnit, operator bool, ());
- LLDB_REGISTER_METHOD_CONST(
- bool, SBCompileUnit, operator==,(const lldb::SBCompileUnit &));
- LLDB_REGISTER_METHOD_CONST(
- bool, SBCompileUnit, operator!=,(const lldb::SBCompileUnit &));
- LLDB_REGISTER_METHOD(bool, SBCompileUnit, GetDescription,
- (lldb::SBStream &));
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBData, ());
- LLDB_REGISTER_CONSTRUCTOR(SBData, (const lldb::SBData &));
- LLDB_REGISTER_METHOD(const lldb::SBData &,
- SBData, operator=,(const lldb::SBData &));
- LLDB_REGISTER_METHOD(bool, SBData, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBData, operator bool, ());
- LLDB_REGISTER_METHOD(uint8_t, SBData, GetAddressByteSize, ());
- LLDB_REGISTER_METHOD(void, SBData, SetAddressByteSize, (uint8_t));
- LLDB_REGISTER_METHOD(void, SBData, Clear, ());
- LLDB_REGISTER_METHOD(size_t, SBData, GetByteSize, ());
- LLDB_REGISTER_METHOD(lldb::ByteOrder, SBData, GetByteOrder, ());
- LLDB_REGISTER_METHOD(void, SBData, SetByteOrder, (lldb::ByteOrder));
- LLDB_REGISTER_METHOD(float, SBData, GetFloat,
- (lldb::SBError &, lldb::offset_t));
- LLDB_REGISTER_METHOD(double, SBData, GetDouble,
- (lldb::SBError &, lldb::offset_t));
- LLDB_REGISTER_METHOD(long double, SBData, GetLongDouble,
- (lldb::SBError &, lldb::offset_t));
- LLDB_REGISTER_METHOD(lldb::addr_t, SBData, GetAddress,
- (lldb::SBError &, lldb::offset_t));
- LLDB_REGISTER_METHOD(uint8_t, SBData, GetUnsignedInt8,
- (lldb::SBError &, lldb::offset_t));
- LLDB_REGISTER_METHOD(uint16_t, SBData, GetUnsignedInt16,
- (lldb::SBError &, lldb::offset_t));
- LLDB_REGISTER_METHOD(uint32_t, SBData, GetUnsignedInt32,
- (lldb::SBError &, lldb::offset_t));
- LLDB_REGISTER_METHOD(uint64_t, SBData, GetUnsignedInt64,
- (lldb::SBError &, lldb::offset_t));
- LLDB_REGISTER_METHOD(int8_t, SBData, GetSignedInt8,
- (lldb::SBError &, lldb::offset_t));
- LLDB_REGISTER_METHOD(int16_t, SBData, GetSignedInt16,
- (lldb::SBError &, lldb::offset_t));
- LLDB_REGISTER_METHOD(int32_t, SBData, GetSignedInt32,
- (lldb::SBError &, lldb::offset_t));
- LLDB_REGISTER_METHOD(int64_t, SBData, GetSignedInt64,
- (lldb::SBError &, lldb::offset_t));
- LLDB_REGISTER_METHOD(const char *, SBData, GetString,
- (lldb::SBError &, lldb::offset_t));
- LLDB_REGISTER_METHOD(bool, SBData, GetDescription,
- (lldb::SBStream &, lldb::addr_t));
- LLDB_REGISTER_METHOD(bool, SBData, Append, (const lldb::SBData &));
- LLDB_REGISTER_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromCString,
- (lldb::ByteOrder, uint32_t, const char *));
- LLDB_REGISTER_STATIC_METHOD(
- lldb::SBData, SBData, CreateDataFromUInt64Array,
- (lldb::ByteOrder, uint32_t, uint64_t *, size_t));
- LLDB_REGISTER_STATIC_METHOD(
- lldb::SBData, SBData, CreateDataFromUInt32Array,
- (lldb::ByteOrder, uint32_t, uint32_t *, size_t));
- LLDB_REGISTER_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromSInt64Array,
- (lldb::ByteOrder, uint32_t, int64_t *, size_t));
- LLDB_REGISTER_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromSInt32Array,
- (lldb::ByteOrder, uint32_t, int32_t *, size_t));
- LLDB_REGISTER_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromDoubleArray,
- (lldb::ByteOrder, uint32_t, double *, size_t));
- LLDB_REGISTER_METHOD(bool, SBData, SetDataFromCString, (const char *));
- LLDB_REGISTER_METHOD(bool, SBData, SetDataFromUInt64Array,
- (uint64_t *, size_t));
- LLDB_REGISTER_METHOD(bool, SBData, SetDataFromUInt32Array,
- (uint32_t *, size_t));
- LLDB_REGISTER_METHOD(bool, SBData, SetDataFromSInt64Array,
- (int64_t *, size_t));
- LLDB_REGISTER_METHOD(bool, SBData, SetDataFromSInt32Array,
- (int32_t *, size_t));
- LLDB_REGISTER_METHOD(bool, SBData, SetDataFromDoubleArray,
- (double *, size_t));
- }
- {
- LLDB_REGISTER_METHOD(void, SBInputReader, SetIsDone, (bool));
- LLDB_REGISTER_METHOD_CONST(bool, SBInputReader, IsActive, ());
- LLDB_REGISTER_CONSTRUCTOR(SBDebugger, ());
- LLDB_REGISTER_CONSTRUCTOR(SBDebugger, (const lldb::DebuggerSP &));
- LLDB_REGISTER_CONSTRUCTOR(SBDebugger, (const lldb::SBDebugger &));
- LLDB_REGISTER_METHOD(lldb::SBDebugger &,
- SBDebugger, operator=,(const lldb::SBDebugger &));
- LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, Initialize, ());
- LLDB_REGISTER_STATIC_METHOD(lldb::SBError, SBDebugger,
- InitializeWithErrorHandling, ());
- LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, Terminate, ());
- LLDB_REGISTER_METHOD(void, SBDebugger, Clear, ());
- LLDB_REGISTER_STATIC_METHOD(lldb::SBDebugger, SBDebugger, Create, ());
- LLDB_REGISTER_STATIC_METHOD(lldb::SBDebugger, SBDebugger, Create, (bool));
- LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, Destroy,
- (lldb::SBDebugger &));
- LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, MemoryPressureDetected, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, operator bool, ());
- LLDB_REGISTER_METHOD(void, SBDebugger, SetAsync, (bool));
- LLDB_REGISTER_METHOD(bool, SBDebugger, GetAsync, ());
- LLDB_REGISTER_METHOD(void, SBDebugger, SkipLLDBInitFiles, (bool));
- LLDB_REGISTER_METHOD(void, SBDebugger, SkipAppInitFiles, (bool));
- LLDB_REGISTER_METHOD(void, SBDebugger, SetInputFileHandle, (FILE *, bool));
- LLDB_REGISTER_METHOD(FILE *, SBDebugger, GetInputFileHandle, ());
- LLDB_REGISTER_METHOD(FILE *, SBDebugger, GetOutputFileHandle, ());
- LLDB_REGISTER_METHOD(FILE *, SBDebugger, GetErrorFileHandle, ());
- LLDB_REGISTER_METHOD(void, SBDebugger, SaveInputTerminalState, ());
- LLDB_REGISTER_METHOD(void, SBDebugger, RestoreInputTerminalState, ());
- LLDB_REGISTER_METHOD(lldb::SBCommandInterpreter, SBDebugger,
- GetCommandInterpreter, ());
- LLDB_REGISTER_METHOD(void, SBDebugger, HandleCommand, (const char *));
- LLDB_REGISTER_METHOD(lldb::SBListener, SBDebugger, GetListener, ());
- LLDB_REGISTER_METHOD(
- void, SBDebugger, HandleProcessEvent,
- (const lldb::SBProcess &, const lldb::SBEvent &, FILE *, FILE *));
- LLDB_REGISTER_METHOD(lldb::SBSourceManager, SBDebugger, GetSourceManager,
- ());
- LLDB_REGISTER_STATIC_METHOD(bool, SBDebugger, SetDefaultArchitecture,
- (const char *));
- LLDB_REGISTER_METHOD(lldb::ScriptLanguage, SBDebugger, GetScriptingLanguage,
- (const char *));
- LLDB_REGISTER_STATIC_METHOD(const char *, SBDebugger, GetVersionString, ());
- LLDB_REGISTER_STATIC_METHOD(const char *, SBDebugger, StateAsCString,
- (lldb::StateType));
- LLDB_REGISTER_STATIC_METHOD(lldb::SBStructuredData, SBDebugger,
- GetBuildConfiguration, ());
- LLDB_REGISTER_STATIC_METHOD(bool, SBDebugger, StateIsRunningState,
- (lldb::StateType));
- LLDB_REGISTER_STATIC_METHOD(bool, SBDebugger, StateIsStoppedState,
- (lldb::StateType));
- LLDB_REGISTER_METHOD(
- lldb::SBTarget, SBDebugger, CreateTarget,
- (const char *, const char *, const char *, bool, lldb::SBError &));
- LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger,
- CreateTargetWithFileAndTargetTriple,
- (const char *, const char *));
- LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger,
- CreateTargetWithFileAndArch,
- (const char *, const char *));
- LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, CreateTarget,
- (const char *));
- LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, GetDummyTarget, ());
- LLDB_REGISTER_METHOD(bool, SBDebugger, DeleteTarget, (lldb::SBTarget &));
- LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, GetTargetAtIndex,
- (uint32_t));
- LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetIndexOfTarget,
- (lldb::SBTarget));
- LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithProcessID,
- (lldb::pid_t));
- LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithFileAndArch,
- (const char *, const char *));
- LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumTargets, ());
- LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, GetSelectedTarget, ());
- LLDB_REGISTER_METHOD(void, SBDebugger, SetSelectedTarget,
- (lldb::SBTarget &));
- LLDB_REGISTER_METHOD(lldb::SBPlatform, SBDebugger, GetSelectedPlatform, ());
- LLDB_REGISTER_METHOD(void, SBDebugger, SetSelectedPlatform,
- (lldb::SBPlatform &));
- LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumPlatforms, ());
- LLDB_REGISTER_METHOD(lldb::SBPlatform, SBDebugger, GetPlatformAtIndex,
- (uint32_t));
- LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumAvailablePlatforms, ());
- LLDB_REGISTER_METHOD(lldb::SBStructuredData, SBDebugger,
- GetAvailablePlatformInfoAtIndex, (uint32_t));
- LLDB_REGISTER_METHOD(void, SBDebugger, DispatchInputInterrupt, ());
- LLDB_REGISTER_METHOD(void, SBDebugger, DispatchInputEndOfFile, ());
- LLDB_REGISTER_METHOD(void, SBDebugger, PushInputReader,
- (lldb::SBInputReader &));
- LLDB_REGISTER_METHOD(void, SBDebugger, RunCommandInterpreter, (bool, bool));
- LLDB_REGISTER_METHOD(void, SBDebugger, RunCommandInterpreter,
- (bool, bool, lldb::SBCommandInterpreterRunOptions &,
- int &, bool &, bool &));
- LLDB_REGISTER_METHOD(lldb::SBError, SBDebugger, RunREPL,
- (lldb::LanguageType, const char *));
- LLDB_REGISTER_STATIC_METHOD(lldb::SBDebugger, SBDebugger,
- FindDebuggerWithID, (int));
- LLDB_REGISTER_METHOD(const char *, SBDebugger, GetInstanceName, ());
- LLDB_REGISTER_STATIC_METHOD(lldb::SBError, SBDebugger, SetInternalVariable,
- (const char *, const char *, const char *));
- LLDB_REGISTER_STATIC_METHOD(lldb::SBStringList, SBDebugger,
- GetInternalVariableValue,
- (const char *, const char *));
- LLDB_REGISTER_METHOD_CONST(uint32_t, SBDebugger, GetTerminalWidth, ());
- LLDB_REGISTER_METHOD(void, SBDebugger, SetTerminalWidth, (uint32_t));
- LLDB_REGISTER_METHOD_CONST(const char *, SBDebugger, GetPrompt, ());
- LLDB_REGISTER_METHOD(void, SBDebugger, SetPrompt, (const char *));
- LLDB_REGISTER_METHOD_CONST(const char *, SBDebugger, GetReproducerPath, ());
- LLDB_REGISTER_METHOD_CONST(lldb::ScriptLanguage, SBDebugger,
- GetScriptLanguage, ());
- LLDB_REGISTER_METHOD(void, SBDebugger, SetScriptLanguage,
- (lldb::ScriptLanguage));
- LLDB_REGISTER_METHOD(bool, SBDebugger, SetUseExternalEditor, (bool));
- LLDB_REGISTER_METHOD(bool, SBDebugger, GetUseExternalEditor, ());
- LLDB_REGISTER_METHOD(bool, SBDebugger, SetUseColor, (bool));
- LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, GetUseColor, ());
- LLDB_REGISTER_METHOD(bool, SBDebugger, GetDescription, (lldb::SBStream &));
- LLDB_REGISTER_METHOD(lldb::user_id_t, SBDebugger, GetID, ());
- LLDB_REGISTER_METHOD(lldb::SBError, SBDebugger, SetCurrentPlatform,
- (const char *));
- LLDB_REGISTER_METHOD(bool, SBDebugger, SetCurrentPlatformSDKRoot,
- (const char *));
- LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, GetCloseInputOnEOF, ());
- LLDB_REGISTER_METHOD(void, SBDebugger, SetCloseInputOnEOF, (bool));
- LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory,
- (const char *));
- LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory,
- (lldb::LanguageType));
- LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, CreateCategory,
- (const char *));
- LLDB_REGISTER_METHOD(bool, SBDebugger, DeleteCategory, (const char *));
- LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumCategories, ());
- LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategoryAtIndex,
- (uint32_t));
- LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetDefaultCategory,
- ());
- LLDB_REGISTER_METHOD(lldb::SBTypeFormat, SBDebugger, GetFormatForType,
- (lldb::SBTypeNameSpecifier));
- LLDB_REGISTER_METHOD(lldb::SBTypeSummary, SBDebugger, GetSummaryForType,
- (lldb::SBTypeNameSpecifier));
- LLDB_REGISTER_METHOD(lldb::SBTypeSynthetic, SBDebugger, GetSyntheticForType,
- (lldb::SBTypeNameSpecifier));
- LLDB_REGISTER_METHOD(lldb::SBTypeFilter, SBDebugger, GetFilterForType,
- (lldb::SBTypeNameSpecifier));
- LLDB_REGISTER_METHOD(bool, SBDebugger, EnableLog,
- (const char *, const char **));
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBDeclaration, ());
- LLDB_REGISTER_CONSTRUCTOR(SBDeclaration, (const lldb::SBDeclaration &));
- LLDB_REGISTER_METHOD(
- const lldb::SBDeclaration &,
- SBDeclaration, operator=,(const lldb::SBDeclaration &));
- LLDB_REGISTER_METHOD_CONST(bool, SBDeclaration, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBDeclaration, operator bool, ());
- LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBDeclaration, GetFileSpec,
- ());
- LLDB_REGISTER_METHOD_CONST(uint32_t, SBDeclaration, GetLine, ());
- LLDB_REGISTER_METHOD_CONST(uint32_t, SBDeclaration, GetColumn, ());
- LLDB_REGISTER_METHOD(void, SBDeclaration, SetFileSpec, (lldb::SBFileSpec));
- LLDB_REGISTER_METHOD(void, SBDeclaration, SetLine, (uint32_t));
- LLDB_REGISTER_METHOD(void, SBDeclaration, SetColumn, (uint32_t));
- LLDB_REGISTER_METHOD_CONST(
- bool, SBDeclaration, operator==,(const lldb::SBDeclaration &));
- LLDB_REGISTER_METHOD_CONST(
- bool, SBDeclaration, operator!=,(const lldb::SBDeclaration &));
- LLDB_REGISTER_METHOD(bool, SBDeclaration, GetDescription,
- (lldb::SBStream &));
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBError, ());
- LLDB_REGISTER_CONSTRUCTOR(SBError, (const lldb::SBError &));
- LLDB_REGISTER_METHOD(const lldb::SBError &,
- SBError, operator=,(const lldb::SBError &));
- LLDB_REGISTER_METHOD_CONST(const char *, SBError, GetCString, ());
- LLDB_REGISTER_METHOD(void, SBError, Clear, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBError, Fail, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBError, Success, ());
- LLDB_REGISTER_METHOD_CONST(uint32_t, SBError, GetError, ());
- LLDB_REGISTER_METHOD_CONST(lldb::ErrorType, SBError, GetType, ());
- LLDB_REGISTER_METHOD(void, SBError, SetError, (uint32_t, lldb::ErrorType));
- LLDB_REGISTER_METHOD(void, SBError, SetErrorToErrno, ());
- LLDB_REGISTER_METHOD(void, SBError, SetErrorToGenericError, ());
- LLDB_REGISTER_METHOD(void, SBError, SetErrorString, (const char *));
- LLDB_REGISTER_METHOD_CONST(bool, SBError, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBError, operator bool, ());
- LLDB_REGISTER_METHOD(bool, SBError, GetDescription, (lldb::SBStream &));
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBEvent, ());
- LLDB_REGISTER_CONSTRUCTOR(SBEvent, (uint32_t, const char *, uint32_t));
- LLDB_REGISTER_CONSTRUCTOR(SBEvent, (lldb::EventSP &));
- LLDB_REGISTER_CONSTRUCTOR(SBEvent, (lldb_private::Event *));
- LLDB_REGISTER_CONSTRUCTOR(SBEvent, (const lldb::SBEvent &));
- LLDB_REGISTER_METHOD(const lldb::SBEvent &,
- SBEvent, operator=,(const lldb::SBEvent &));
- LLDB_REGISTER_METHOD(const char *, SBEvent, GetDataFlavor, ());
- LLDB_REGISTER_METHOD_CONST(uint32_t, SBEvent, GetType, ());
- LLDB_REGISTER_METHOD_CONST(lldb::SBBroadcaster, SBEvent, GetBroadcaster,
- ());
- LLDB_REGISTER_METHOD_CONST(const char *, SBEvent, GetBroadcasterClass, ());
- LLDB_REGISTER_METHOD(bool, SBEvent, BroadcasterMatchesPtr,
- (const lldb::SBBroadcaster *));
- LLDB_REGISTER_METHOD(bool, SBEvent, BroadcasterMatchesRef,
- (const lldb::SBBroadcaster &));
- LLDB_REGISTER_METHOD(void, SBEvent, Clear, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBEvent, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBEvent, operator bool, ());
- LLDB_REGISTER_STATIC_METHOD(const char *, SBEvent, GetCStringFromEvent,
- (const lldb::SBEvent &));
- LLDB_REGISTER_METHOD(bool, SBEvent, GetDescription, (lldb::SBStream &));
- LLDB_REGISTER_METHOD_CONST(bool, SBEvent, GetDescription,
- (lldb::SBStream &));
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext, ());
- LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext,
- (const lldb::SBExecutionContext &));
- LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext,
- (lldb::ExecutionContextRefSP));
- LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext, (const lldb::SBTarget &));
- LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext, (const lldb::SBProcess &));
- LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext, (lldb::SBThread));
- LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext, (const lldb::SBFrame &));
- LLDB_REGISTER_METHOD(
- const lldb::SBExecutionContext &,
- SBExecutionContext, operator=,(const lldb::SBExecutionContext &));
- LLDB_REGISTER_METHOD_CONST(lldb::SBTarget, SBExecutionContext, GetTarget,
- ());
- LLDB_REGISTER_METHOD_CONST(lldb::SBProcess, SBExecutionContext, GetProcess,
- ());
- LLDB_REGISTER_METHOD_CONST(lldb::SBThread, SBExecutionContext, GetThread,
- ());
- LLDB_REGISTER_METHOD_CONST(lldb::SBFrame, SBExecutionContext, GetFrame, ());
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBExpressionOptions, ());
- LLDB_REGISTER_CONSTRUCTOR(SBExpressionOptions,
- (const lldb::SBExpressionOptions &));
- LLDB_REGISTER_METHOD(
- const lldb::SBExpressionOptions &,
- SBExpressionOptions, operator=,(const lldb::SBExpressionOptions &));
- LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetCoerceResultToId,
- ());
- LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetCoerceResultToId,
- (bool));
- LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetUnwindOnError, ());
- LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetUnwindOnError, (bool));
- LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetIgnoreBreakpoints,
- ());
- LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetIgnoreBreakpoints,
- (bool));
- LLDB_REGISTER_METHOD_CONST(lldb::DynamicValueType, SBExpressionOptions,
- GetFetchDynamicValue, ());
- LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetFetchDynamicValue,
- (lldb::DynamicValueType));
- LLDB_REGISTER_METHOD_CONST(uint32_t, SBExpressionOptions,
- GetTimeoutInMicroSeconds, ());
- LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetTimeoutInMicroSeconds,
- (uint32_t));
- LLDB_REGISTER_METHOD_CONST(uint32_t, SBExpressionOptions,
- GetOneThreadTimeoutInMicroSeconds, ());
- LLDB_REGISTER_METHOD(void, SBExpressionOptions,
- SetOneThreadTimeoutInMicroSeconds, (uint32_t));
- LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetTryAllThreads, ());
- LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetTryAllThreads, (bool));
- LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetStopOthers, ());
- LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetStopOthers, (bool));
- LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetTrapExceptions,
- ());
- LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetTrapExceptions, (bool));
- LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetLanguage,
- (lldb::LanguageType));
- LLDB_REGISTER_METHOD(bool, SBExpressionOptions, GetGenerateDebugInfo, ());
- LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetGenerateDebugInfo,
- (bool));
- LLDB_REGISTER_METHOD(bool, SBExpressionOptions, GetSuppressPersistentResult,
- ());
- LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetSuppressPersistentResult,
- (bool));
- LLDB_REGISTER_METHOD_CONST(const char *, SBExpressionOptions, GetPrefix,
- ());
- LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetPrefix, (const char *));
- LLDB_REGISTER_METHOD(bool, SBExpressionOptions, GetAutoApplyFixIts, ());
- LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetAutoApplyFixIts, (bool));
- LLDB_REGISTER_METHOD(bool, SBExpressionOptions, GetTopLevel, ());
- LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetTopLevel, (bool));
- LLDB_REGISTER_METHOD(bool, SBExpressionOptions, GetAllowJIT, ());
- LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetAllowJIT, (bool));
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBFileSpec, ());
- LLDB_REGISTER_CONSTRUCTOR(SBFileSpec, (const lldb::SBFileSpec &));
- LLDB_REGISTER_CONSTRUCTOR(SBFileSpec, (const char *));
- LLDB_REGISTER_CONSTRUCTOR(SBFileSpec, (const char *, bool));
- LLDB_REGISTER_METHOD(const lldb::SBFileSpec &,
- SBFileSpec, operator=,(const lldb::SBFileSpec &));
- LLDB_REGISTER_METHOD_CONST(bool, SBFileSpec, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBFileSpec, operator bool, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBFileSpec, Exists, ());
- LLDB_REGISTER_METHOD(bool, SBFileSpec, ResolveExecutableLocation, ());
- LLDB_REGISTER_STATIC_METHOD(int, SBFileSpec, ResolvePath,
- (const char *, char *, size_t));
- LLDB_REGISTER_METHOD_CONST(const char *, SBFileSpec, GetFilename, ());
- LLDB_REGISTER_METHOD_CONST(const char *, SBFileSpec, GetDirectory, ());
- LLDB_REGISTER_METHOD(void, SBFileSpec, SetFilename, (const char *));
- LLDB_REGISTER_METHOD(void, SBFileSpec, SetDirectory, (const char *));
- LLDB_REGISTER_METHOD_CONST(uint32_t, SBFileSpec, GetPath, (char *, size_t));
- LLDB_REGISTER_METHOD_CONST(bool, SBFileSpec, GetDescription,
- (lldb::SBStream &));
- LLDB_REGISTER_METHOD(void, SBFileSpec, AppendPathComponent, (const char *));
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBFileSpecList, ());
- LLDB_REGISTER_CONSTRUCTOR(SBFileSpecList, (const lldb::SBFileSpecList &));
- LLDB_REGISTER_METHOD(
- const lldb::SBFileSpecList &,
- SBFileSpecList, operator=,(const lldb::SBFileSpecList &));
- LLDB_REGISTER_METHOD_CONST(uint32_t, SBFileSpecList, GetSize, ());
- LLDB_REGISTER_METHOD(void, SBFileSpecList, Append,
- (const lldb::SBFileSpec &));
- LLDB_REGISTER_METHOD(bool, SBFileSpecList, AppendIfUnique,
- (const lldb::SBFileSpec &));
- LLDB_REGISTER_METHOD(void, SBFileSpecList, Clear, ());
- LLDB_REGISTER_METHOD(uint32_t, SBFileSpecList, FindFileIndex,
- (uint32_t, const lldb::SBFileSpec &, bool));
- LLDB_REGISTER_METHOD_CONST(const lldb::SBFileSpec, SBFileSpecList,
- GetFileSpecAtIndex, (uint32_t));
- LLDB_REGISTER_METHOD_CONST(bool, SBFileSpecList, GetDescription,
- (lldb::SBStream &));
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBFrame, ());
- LLDB_REGISTER_CONSTRUCTOR(SBFrame, (const lldb::StackFrameSP &));
- LLDB_REGISTER_CONSTRUCTOR(SBFrame, (const lldb::SBFrame &));
- LLDB_REGISTER_METHOD(const lldb::SBFrame &,
- SBFrame, operator=,(const lldb::SBFrame &));
- LLDB_REGISTER_METHOD_CONST(bool, SBFrame, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBFrame, operator bool, ());
- LLDB_REGISTER_METHOD_CONST(lldb::SBSymbolContext, SBFrame, GetSymbolContext,
- (uint32_t));
- LLDB_REGISTER_METHOD_CONST(lldb::SBModule, SBFrame, GetModule, ());
- LLDB_REGISTER_METHOD_CONST(lldb::SBCompileUnit, SBFrame, GetCompileUnit,
- ());
- LLDB_REGISTER_METHOD_CONST(lldb::SBFunction, SBFrame, GetFunction, ());
- LLDB_REGISTER_METHOD_CONST(lldb::SBSymbol, SBFrame, GetSymbol, ());
- LLDB_REGISTER_METHOD_CONST(lldb::SBBlock, SBFrame, GetBlock, ());
- LLDB_REGISTER_METHOD_CONST(lldb::SBBlock, SBFrame, GetFrameBlock, ());
- LLDB_REGISTER_METHOD_CONST(lldb::SBLineEntry, SBFrame, GetLineEntry, ());
- LLDB_REGISTER_METHOD_CONST(uint32_t, SBFrame, GetFrameID, ());
- LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBFrame, GetCFA, ());
- LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBFrame, GetPC, ());
- LLDB_REGISTER_METHOD(bool, SBFrame, SetPC, (lldb::addr_t));
- LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBFrame, GetSP, ());
- LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBFrame, GetFP, ());
- LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBFrame, GetPCAddress, ());
- LLDB_REGISTER_METHOD(void, SBFrame, Clear, ());
- LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, GetValueForVariablePath,
- (const char *));
- LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, GetValueForVariablePath,
- (const char *, lldb::DynamicValueType));
- LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, FindVariable, (const char *));
- LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, FindVariable,
- (const char *, lldb::DynamicValueType));
- LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, FindValue,
- (const char *, lldb::ValueType));
- LLDB_REGISTER_METHOD(
- lldb::SBValue, SBFrame, FindValue,
- (const char *, lldb::ValueType, lldb::DynamicValueType));
- LLDB_REGISTER_METHOD_CONST(bool, SBFrame, IsEqual, (const lldb::SBFrame &));
- LLDB_REGISTER_METHOD_CONST(bool,
- SBFrame, operator==,(const lldb::SBFrame &));
- LLDB_REGISTER_METHOD_CONST(bool,
- SBFrame, operator!=,(const lldb::SBFrame &));
- LLDB_REGISTER_METHOD_CONST(lldb::SBThread, SBFrame, GetThread, ());
- LLDB_REGISTER_METHOD_CONST(const char *, SBFrame, Disassemble, ());
- LLDB_REGISTER_METHOD(lldb::SBValueList, SBFrame, GetVariables,
- (bool, bool, bool, bool));
- LLDB_REGISTER_METHOD(lldb::SBValueList, SBFrame, GetVariables,
- (bool, bool, bool, bool, lldb::DynamicValueType));
- LLDB_REGISTER_METHOD(lldb::SBValueList, SBFrame, GetVariables,
- (const lldb::SBVariablesOptions &));
- LLDB_REGISTER_METHOD(lldb::SBValueList, SBFrame, GetRegisters, ());
- LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, FindRegister, (const char *));
- LLDB_REGISTER_METHOD(bool, SBFrame, GetDescription, (lldb::SBStream &));
- LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
- (const char *));
- LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
- (const char *, lldb::DynamicValueType));
- LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
- (const char *, lldb::DynamicValueType, bool));
- LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
- (const char *, const lldb::SBExpressionOptions &));
- LLDB_REGISTER_METHOD(bool, SBFrame, IsInlined, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBFrame, IsInlined, ());
- LLDB_REGISTER_METHOD(bool, SBFrame, IsArtificial, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBFrame, IsArtificial, ());
- LLDB_REGISTER_METHOD(const char *, SBFrame, GetFunctionName, ());
- LLDB_REGISTER_METHOD_CONST(lldb::LanguageType, SBFrame, GuessLanguage, ());
- LLDB_REGISTER_METHOD_CONST(const char *, SBFrame, GetFunctionName, ());
- LLDB_REGISTER_METHOD(const char *, SBFrame, GetDisplayFunctionName, ());
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBFunction, ());
- LLDB_REGISTER_CONSTRUCTOR(SBFunction, (const lldb::SBFunction &));
- LLDB_REGISTER_METHOD(const lldb::SBFunction &,
- SBFunction, operator=,(const lldb::SBFunction &));
- LLDB_REGISTER_METHOD_CONST(bool, SBFunction, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBFunction, operator bool, ());
- LLDB_REGISTER_METHOD_CONST(const char *, SBFunction, GetName, ());
- LLDB_REGISTER_METHOD_CONST(const char *, SBFunction, GetDisplayName, ());
- LLDB_REGISTER_METHOD_CONST(const char *, SBFunction, GetMangledName, ());
- LLDB_REGISTER_METHOD_CONST(
- bool, SBFunction, operator==,(const lldb::SBFunction &));
- LLDB_REGISTER_METHOD_CONST(
- bool, SBFunction, operator!=,(const lldb::SBFunction &));
- LLDB_REGISTER_METHOD(bool, SBFunction, GetDescription, (lldb::SBStream &));
- LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBFunction, GetInstructions,
- (lldb::SBTarget));
- LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBFunction, GetInstructions,
- (lldb::SBTarget, const char *));
- LLDB_REGISTER_METHOD(lldb::SBAddress, SBFunction, GetStartAddress, ());
- LLDB_REGISTER_METHOD(lldb::SBAddress, SBFunction, GetEndAddress, ());
- LLDB_REGISTER_METHOD(const char *, SBFunction, GetArgumentName, (uint32_t));
- LLDB_REGISTER_METHOD(uint32_t, SBFunction, GetPrologueByteSize, ());
- LLDB_REGISTER_METHOD(lldb::SBType, SBFunction, GetType, ());
- LLDB_REGISTER_METHOD(lldb::SBBlock, SBFunction, GetBlock, ());
- LLDB_REGISTER_METHOD(lldb::LanguageType, SBFunction, GetLanguage, ());
- LLDB_REGISTER_METHOD(bool, SBFunction, GetIsOptimized, ());
- }
- {
- LLDB_REGISTER_STATIC_METHOD(lldb::SBFileSpec, SBHostOS, GetProgramFileSpec,
- ());
- LLDB_REGISTER_STATIC_METHOD(lldb::SBFileSpec, SBHostOS, GetLLDBPythonPath,
- ());
- LLDB_REGISTER_STATIC_METHOD(lldb::SBFileSpec, SBHostOS, GetLLDBPath,
- (lldb::PathType));
- LLDB_REGISTER_STATIC_METHOD(lldb::SBFileSpec, SBHostOS,
- GetUserHomeDirectory, ());
- LLDB_REGISTER_STATIC_METHOD(void, SBHostOS, ThreadCreated, (const char *));
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBInstruction, ());
- LLDB_REGISTER_CONSTRUCTOR(SBInstruction, (const lldb::SBInstruction &));
- LLDB_REGISTER_METHOD(
- const lldb::SBInstruction &,
- SBInstruction, operator=,(const lldb::SBInstruction &));
- LLDB_REGISTER_METHOD(bool, SBInstruction, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBInstruction, operator bool, ());
- LLDB_REGISTER_METHOD(lldb::SBAddress, SBInstruction, GetAddress, ());
- LLDB_REGISTER_METHOD(const char *, SBInstruction, GetMnemonic,
- (lldb::SBTarget));
- LLDB_REGISTER_METHOD(const char *, SBInstruction, GetOperands,
- (lldb::SBTarget));
- LLDB_REGISTER_METHOD(const char *, SBInstruction, GetComment,
- (lldb::SBTarget));
- LLDB_REGISTER_METHOD(size_t, SBInstruction, GetByteSize, ());
- LLDB_REGISTER_METHOD(lldb::SBData, SBInstruction, GetData,
- (lldb::SBTarget));
- LLDB_REGISTER_METHOD(bool, SBInstruction, DoesBranch, ());
- LLDB_REGISTER_METHOD(bool, SBInstruction, HasDelaySlot, ());
- LLDB_REGISTER_METHOD(bool, SBInstruction, CanSetBreakpoint, ());
- LLDB_REGISTER_METHOD(bool, SBInstruction, GetDescription,
- (lldb::SBStream &));
- LLDB_REGISTER_METHOD(void, SBInstruction, Print, (FILE *));
- LLDB_REGISTER_METHOD(bool, SBInstruction, EmulateWithFrame,
- (lldb::SBFrame &, uint32_t));
- LLDB_REGISTER_METHOD(bool, SBInstruction, DumpEmulation, (const char *));
- LLDB_REGISTER_METHOD(bool, SBInstruction, TestEmulation,
- (lldb::SBStream &, const char *));
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBInstructionList, ());
- LLDB_REGISTER_CONSTRUCTOR(SBInstructionList,
- (const lldb::SBInstructionList &));
- LLDB_REGISTER_METHOD(
- const lldb::SBInstructionList &,
- SBInstructionList, operator=,(const lldb::SBInstructionList &));
- LLDB_REGISTER_METHOD_CONST(bool, SBInstructionList, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBInstructionList, operator bool, ());
- LLDB_REGISTER_METHOD(size_t, SBInstructionList, GetSize, ());
- LLDB_REGISTER_METHOD(lldb::SBInstruction, SBInstructionList,
- GetInstructionAtIndex, (uint32_t));
- LLDB_REGISTER_METHOD(
- size_t, SBInstructionList, GetInstructionsCount,
- (const lldb::SBAddress &, const lldb::SBAddress &, bool));
- LLDB_REGISTER_METHOD(void, SBInstructionList, Clear, ());
- LLDB_REGISTER_METHOD(void, SBInstructionList, AppendInstruction,
- (lldb::SBInstruction));
- LLDB_REGISTER_METHOD(void, SBInstructionList, Print, (FILE *));
- LLDB_REGISTER_METHOD(bool, SBInstructionList, GetDescription,
- (lldb::SBStream &));
- LLDB_REGISTER_METHOD(bool, SBInstructionList,
- DumpEmulationForAllInstructions, (const char *));
- }
- {
- LLDB_REGISTER_STATIC_METHOD(lldb::LanguageType, SBLanguageRuntime,
- GetLanguageTypeFromString, (const char *));
- LLDB_REGISTER_STATIC_METHOD(const char *, SBLanguageRuntime,
- GetNameForLanguageType, (lldb::LanguageType));
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBLaunchInfo, (const char **));
- LLDB_REGISTER_METHOD(lldb::pid_t, SBLaunchInfo, GetProcessID, ());
- LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetUserID, ());
- LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetGroupID, ());
- LLDB_REGISTER_METHOD(bool, SBLaunchInfo, UserIDIsValid, ());
- LLDB_REGISTER_METHOD(bool, SBLaunchInfo, GroupIDIsValid, ());
- LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetUserID, (uint32_t));
- LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetGroupID, (uint32_t));
- LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBLaunchInfo, GetExecutableFile, ());
- LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetExecutableFile,
- (lldb::SBFileSpec, bool));
- LLDB_REGISTER_METHOD(lldb::SBListener, SBLaunchInfo, GetListener, ());
- LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetListener, (lldb::SBListener &));
- LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetNumArguments, ());
- LLDB_REGISTER_METHOD(const char *, SBLaunchInfo, GetArgumentAtIndex,
- (uint32_t));
- LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetArguments,
- (const char **, bool));
- LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetNumEnvironmentEntries, ());
- LLDB_REGISTER_METHOD(const char *, SBLaunchInfo, GetEnvironmentEntryAtIndex,
- (uint32_t));
- LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetEnvironmentEntries,
- (const char **, bool));
- LLDB_REGISTER_METHOD(void, SBLaunchInfo, Clear, ());
- LLDB_REGISTER_METHOD_CONST(const char *, SBLaunchInfo, GetWorkingDirectory,
- ());
- LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetWorkingDirectory,
- (const char *));
- LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetLaunchFlags, ());
- LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetLaunchFlags, (uint32_t));
- LLDB_REGISTER_METHOD(const char *, SBLaunchInfo, GetProcessPluginName, ());
- LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetProcessPluginName,
- (const char *));
- LLDB_REGISTER_METHOD(const char *, SBLaunchInfo, GetShell, ());
- LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetShell, (const char *));
- LLDB_REGISTER_METHOD(bool, SBLaunchInfo, GetShellExpandArguments, ());
- LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetShellExpandArguments, (bool));
- LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetResumeCount, ());
- LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetResumeCount, (uint32_t));
- LLDB_REGISTER_METHOD(bool, SBLaunchInfo, AddCloseFileAction, (int));
- LLDB_REGISTER_METHOD(bool, SBLaunchInfo, AddDuplicateFileAction,
- (int, int));
- LLDB_REGISTER_METHOD(bool, SBLaunchInfo, AddOpenFileAction,
- (int, const char *, bool, bool));
- LLDB_REGISTER_METHOD(bool, SBLaunchInfo, AddSuppressFileAction,
- (int, bool, bool));
- LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetLaunchEventData,
- (const char *));
- LLDB_REGISTER_METHOD_CONST(const char *, SBLaunchInfo, GetLaunchEventData,
- ());
- LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetDetachOnError, (bool));
- LLDB_REGISTER_METHOD_CONST(bool, SBLaunchInfo, GetDetachOnError, ());
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBLineEntry, ());
- LLDB_REGISTER_CONSTRUCTOR(SBLineEntry, (const lldb::SBLineEntry &));
- LLDB_REGISTER_METHOD(const lldb::SBLineEntry &,
- SBLineEntry, operator=,(const lldb::SBLineEntry &));
- LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBLineEntry, GetStartAddress,
- ());
- LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBLineEntry, GetEndAddress, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBLineEntry, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBLineEntry, operator bool, ());
- LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBLineEntry, GetFileSpec, ());
- LLDB_REGISTER_METHOD_CONST(uint32_t, SBLineEntry, GetLine, ());
- LLDB_REGISTER_METHOD_CONST(uint32_t, SBLineEntry, GetColumn, ());
- LLDB_REGISTER_METHOD(void, SBLineEntry, SetFileSpec, (lldb::SBFileSpec));
- LLDB_REGISTER_METHOD(void, SBLineEntry, SetLine, (uint32_t));
- LLDB_REGISTER_METHOD(void, SBLineEntry, SetColumn, (uint32_t));
- LLDB_REGISTER_METHOD_CONST(
- bool, SBLineEntry, operator==,(const lldb::SBLineEntry &));
- LLDB_REGISTER_METHOD_CONST(
- bool, SBLineEntry, operator!=,(const lldb::SBLineEntry &));
- LLDB_REGISTER_METHOD(bool, SBLineEntry, GetDescription, (lldb::SBStream &));
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBListener, ());
- LLDB_REGISTER_CONSTRUCTOR(SBListener, (const char *));
- LLDB_REGISTER_CONSTRUCTOR(SBListener, (const lldb::SBListener &));
- LLDB_REGISTER_METHOD(const lldb::SBListener &,
- SBListener, operator=,(const lldb::SBListener &));
- LLDB_REGISTER_METHOD_CONST(bool, SBListener, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBListener, operator bool, ());
- LLDB_REGISTER_METHOD(void, SBListener, AddEvent, (const lldb::SBEvent &));
- LLDB_REGISTER_METHOD(void, SBListener, Clear, ());
- LLDB_REGISTER_METHOD(uint32_t, SBListener, StartListeningForEventClass,
- (lldb::SBDebugger &, const char *, uint32_t));
- LLDB_REGISTER_METHOD(bool, SBListener, StopListeningForEventClass,
- (lldb::SBDebugger &, const char *, uint32_t));
- LLDB_REGISTER_METHOD(uint32_t, SBListener, StartListeningForEvents,
- (const lldb::SBBroadcaster &, uint32_t));
- LLDB_REGISTER_METHOD(bool, SBListener, StopListeningForEvents,
- (const lldb::SBBroadcaster &, uint32_t));
- LLDB_REGISTER_METHOD(bool, SBListener, WaitForEvent,
- (uint32_t, lldb::SBEvent &));
- LLDB_REGISTER_METHOD(
- bool, SBListener, WaitForEventForBroadcaster,
- (uint32_t, const lldb::SBBroadcaster &, lldb::SBEvent &));
- LLDB_REGISTER_METHOD(
- bool, SBListener, WaitForEventForBroadcasterWithType,
- (uint32_t, const lldb::SBBroadcaster &, uint32_t, lldb::SBEvent &));
- LLDB_REGISTER_METHOD(bool, SBListener, PeekAtNextEvent, (lldb::SBEvent &));
- LLDB_REGISTER_METHOD(bool, SBListener, PeekAtNextEventForBroadcaster,
- (const lldb::SBBroadcaster &, lldb::SBEvent &));
- LLDB_REGISTER_METHOD(
- bool, SBListener, PeekAtNextEventForBroadcasterWithType,
- (const lldb::SBBroadcaster &, uint32_t, lldb::SBEvent &));
- LLDB_REGISTER_METHOD(bool, SBListener, GetNextEvent, (lldb::SBEvent &));
- LLDB_REGISTER_METHOD(bool, SBListener, GetNextEventForBroadcaster,
- (const lldb::SBBroadcaster &, lldb::SBEvent &));
- LLDB_REGISTER_METHOD(
- bool, SBListener, GetNextEventForBroadcasterWithType,
- (const lldb::SBBroadcaster &, uint32_t, lldb::SBEvent &));
- LLDB_REGISTER_METHOD(bool, SBListener, HandleBroadcastEvent,
- (const lldb::SBEvent &));
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBMemoryRegionInfo, ());
- LLDB_REGISTER_CONSTRUCTOR(SBMemoryRegionInfo,
- (const lldb::SBMemoryRegionInfo &));
- LLDB_REGISTER_METHOD(
- const lldb::SBMemoryRegionInfo &,
- SBMemoryRegionInfo, operator=,(const lldb::SBMemoryRegionInfo &));
- LLDB_REGISTER_METHOD(void, SBMemoryRegionInfo, Clear, ());
- LLDB_REGISTER_METHOD_CONST(
- bool,
- SBMemoryRegionInfo, operator==,(const lldb::SBMemoryRegionInfo &));
- LLDB_REGISTER_METHOD_CONST(
- bool,
- SBMemoryRegionInfo, operator!=,(const lldb::SBMemoryRegionInfo &));
- LLDB_REGISTER_METHOD(lldb::addr_t, SBMemoryRegionInfo, GetRegionBase, ());
- LLDB_REGISTER_METHOD(lldb::addr_t, SBMemoryRegionInfo, GetRegionEnd, ());
- LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, IsReadable, ());
- LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, IsWritable, ());
- LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, IsExecutable, ());
- LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, IsMapped, ());
- LLDB_REGISTER_METHOD(const char *, SBMemoryRegionInfo, GetName, ());
- LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, GetDescription,
- (lldb::SBStream &));
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBMemoryRegionInfoList, ());
- LLDB_REGISTER_CONSTRUCTOR(SBMemoryRegionInfoList,
- (const lldb::SBMemoryRegionInfoList &));
- LLDB_REGISTER_METHOD(
- const lldb::SBMemoryRegionInfoList &,
- SBMemoryRegionInfoList, operator=,(
- const lldb::SBMemoryRegionInfoList &));
- LLDB_REGISTER_METHOD_CONST(uint32_t, SBMemoryRegionInfoList, GetSize, ());
- LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfoList, GetMemoryRegionAtIndex,
- (uint32_t, lldb::SBMemoryRegionInfo &));
- LLDB_REGISTER_METHOD(void, SBMemoryRegionInfoList, Clear, ());
- LLDB_REGISTER_METHOD(void, SBMemoryRegionInfoList, Append,
- (lldb::SBMemoryRegionInfo &));
- LLDB_REGISTER_METHOD(void, SBMemoryRegionInfoList, Append,
- (lldb::SBMemoryRegionInfoList &));
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBModule, ());
- LLDB_REGISTER_CONSTRUCTOR(SBModule, (const lldb::SBModuleSpec &));
- LLDB_REGISTER_CONSTRUCTOR(SBModule, (const lldb::SBModule &));
- LLDB_REGISTER_CONSTRUCTOR(SBModule, (lldb::SBProcess &, lldb::addr_t));
- LLDB_REGISTER_METHOD(const lldb::SBModule &,
- SBModule, operator=,(const lldb::SBModule &));
- LLDB_REGISTER_METHOD_CONST(bool, SBModule, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBModule, operator bool, ());
- LLDB_REGISTER_METHOD(void, SBModule, Clear, ());
- LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBModule, GetFileSpec, ());
- LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBModule, GetPlatformFileSpec,
- ());
- LLDB_REGISTER_METHOD(bool, SBModule, SetPlatformFileSpec,
- (const lldb::SBFileSpec &));
- LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBModule, GetRemoteInstallFileSpec,
- ());
- LLDB_REGISTER_METHOD(bool, SBModule, SetRemoteInstallFileSpec,
- (lldb::SBFileSpec &));
- LLDB_REGISTER_METHOD_CONST(const char *, SBModule, GetUUIDString, ());
- LLDB_REGISTER_METHOD_CONST(bool,
- SBModule, operator==,(const lldb::SBModule &));
- LLDB_REGISTER_METHOD_CONST(bool,
- SBModule, operator!=,(const lldb::SBModule &));
- LLDB_REGISTER_METHOD(lldb::SBAddress, SBModule, ResolveFileAddress,
- (lldb::addr_t));
- LLDB_REGISTER_METHOD(lldb::SBSymbolContext, SBModule,
- ResolveSymbolContextForAddress,
- (const lldb::SBAddress &, uint32_t));
- LLDB_REGISTER_METHOD(bool, SBModule, GetDescription, (lldb::SBStream &));
- LLDB_REGISTER_METHOD(uint32_t, SBModule, GetNumCompileUnits, ());
- LLDB_REGISTER_METHOD(lldb::SBCompileUnit, SBModule, GetCompileUnitAtIndex,
- (uint32_t));
- LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBModule, FindCompileUnits,
- (const lldb::SBFileSpec &));
- LLDB_REGISTER_METHOD(size_t, SBModule, GetNumSymbols, ());
- LLDB_REGISTER_METHOD(lldb::SBSymbol, SBModule, GetSymbolAtIndex, (size_t));
- LLDB_REGISTER_METHOD(lldb::SBSymbol, SBModule, FindSymbol,
- (const char *, lldb::SymbolType));
- LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBModule, FindSymbols,
- (const char *, lldb::SymbolType));
- LLDB_REGISTER_METHOD(size_t, SBModule, GetNumSections, ());
- LLDB_REGISTER_METHOD(lldb::SBSection, SBModule, GetSectionAtIndex,
- (size_t));
- LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBModule, FindFunctions,
- (const char *, uint32_t));
- LLDB_REGISTER_METHOD(lldb::SBValueList, SBModule, FindGlobalVariables,
- (lldb::SBTarget &, const char *, uint32_t));
- LLDB_REGISTER_METHOD(lldb::SBValue, SBModule, FindFirstGlobalVariable,
- (lldb::SBTarget &, const char *));
- LLDB_REGISTER_METHOD(lldb::SBType, SBModule, FindFirstType, (const char *));
- LLDB_REGISTER_METHOD(lldb::SBType, SBModule, GetBasicType,
- (lldb::BasicType));
- LLDB_REGISTER_METHOD(lldb::SBTypeList, SBModule, FindTypes, (const char *));
- LLDB_REGISTER_METHOD(lldb::SBType, SBModule, GetTypeByID,
- (lldb::user_id_t));
- LLDB_REGISTER_METHOD(lldb::SBTypeList, SBModule, GetTypes, (uint32_t));
- LLDB_REGISTER_METHOD(lldb::SBSection, SBModule, FindSection,
- (const char *));
- LLDB_REGISTER_METHOD(lldb::ByteOrder, SBModule, GetByteOrder, ());
- LLDB_REGISTER_METHOD(const char *, SBModule, GetTriple, ());
- LLDB_REGISTER_METHOD(uint32_t, SBModule, GetAddressByteSize, ());
- LLDB_REGISTER_METHOD(uint32_t, SBModule, GetVersion,
- (uint32_t *, uint32_t));
- LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBModule, GetSymbolFileSpec,
- ());
- LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBModule,
- GetObjectFileHeaderAddress, ());
- LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBModule,
- GetObjectFileEntryPointAddress, ());
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBModuleSpec, ());
- LLDB_REGISTER_CONSTRUCTOR(SBModuleSpec, (const lldb::SBModuleSpec &));
- LLDB_REGISTER_METHOD(const lldb::SBModuleSpec &,
- SBModuleSpec, operator=,(const lldb::SBModuleSpec &));
- LLDB_REGISTER_METHOD_CONST(bool, SBModuleSpec, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBModuleSpec, operator bool, ());
- LLDB_REGISTER_METHOD(void, SBModuleSpec, Clear, ());
- LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBModuleSpec, GetFileSpec, ());
- LLDB_REGISTER_METHOD(void, SBModuleSpec, SetFileSpec,
- (const lldb::SBFileSpec &));
- LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBModuleSpec, GetPlatformFileSpec,
- ());
- LLDB_REGISTER_METHOD(void, SBModuleSpec, SetPlatformFileSpec,
- (const lldb::SBFileSpec &));
- LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBModuleSpec, GetSymbolFileSpec, ());
- LLDB_REGISTER_METHOD(void, SBModuleSpec, SetSymbolFileSpec,
- (const lldb::SBFileSpec &));
- LLDB_REGISTER_METHOD(const char *, SBModuleSpec, GetObjectName, ());
- LLDB_REGISTER_METHOD(void, SBModuleSpec, SetObjectName, (const char *));
- LLDB_REGISTER_METHOD(const char *, SBModuleSpec, GetTriple, ());
- LLDB_REGISTER_METHOD(void, SBModuleSpec, SetTriple, (const char *));
- LLDB_REGISTER_METHOD(size_t, SBModuleSpec, GetUUIDLength, ());
- LLDB_REGISTER_METHOD(bool, SBModuleSpec, GetDescription,
- (lldb::SBStream &));
- LLDB_REGISTER_CONSTRUCTOR(SBModuleSpecList, ());
- LLDB_REGISTER_CONSTRUCTOR(SBModuleSpecList,
- (const lldb::SBModuleSpecList &));
- LLDB_REGISTER_METHOD(
- lldb::SBModuleSpecList &,
- SBModuleSpecList, operator=,(const lldb::SBModuleSpecList &));
- LLDB_REGISTER_STATIC_METHOD(lldb::SBModuleSpecList, SBModuleSpecList,
- GetModuleSpecifications, (const char *));
- LLDB_REGISTER_METHOD(void, SBModuleSpecList, Append,
- (const lldb::SBModuleSpec &));
- LLDB_REGISTER_METHOD(void, SBModuleSpecList, Append,
- (const lldb::SBModuleSpecList &));
- LLDB_REGISTER_METHOD(size_t, SBModuleSpecList, GetSize, ());
- LLDB_REGISTER_METHOD(lldb::SBModuleSpec, SBModuleSpecList, GetSpecAtIndex,
- (size_t));
- LLDB_REGISTER_METHOD(lldb::SBModuleSpec, SBModuleSpecList,
- FindFirstMatchingSpec, (const lldb::SBModuleSpec &));
- LLDB_REGISTER_METHOD(lldb::SBModuleSpecList, SBModuleSpecList,
- FindMatchingSpecs, (const lldb::SBModuleSpec &));
- LLDB_REGISTER_METHOD(bool, SBModuleSpecList, GetDescription,
- (lldb::SBStream &));
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBPlatformConnectOptions, (const char *));
- LLDB_REGISTER_CONSTRUCTOR(SBPlatformConnectOptions,
- (const lldb::SBPlatformConnectOptions &));
- LLDB_REGISTER_METHOD(
- void,
- SBPlatformConnectOptions, operator=,(
- const lldb::SBPlatformConnectOptions &));
- LLDB_REGISTER_METHOD(const char *, SBPlatformConnectOptions, GetURL, ());
- LLDB_REGISTER_METHOD(void, SBPlatformConnectOptions, SetURL,
- (const char *));
- LLDB_REGISTER_METHOD(bool, SBPlatformConnectOptions, GetRsyncEnabled, ());
- LLDB_REGISTER_METHOD(void, SBPlatformConnectOptions, EnableRsync,
- (const char *, const char *, bool));
- LLDB_REGISTER_METHOD(void, SBPlatformConnectOptions, DisableRsync, ());
- LLDB_REGISTER_METHOD(const char *, SBPlatformConnectOptions,
- GetLocalCacheDirectory, ());
- LLDB_REGISTER_METHOD(void, SBPlatformConnectOptions, SetLocalCacheDirectory,
- (const char *));
- LLDB_REGISTER_CONSTRUCTOR(SBPlatformShellCommand, (const char *));
- LLDB_REGISTER_CONSTRUCTOR(SBPlatformShellCommand,
- (const lldb::SBPlatformShellCommand &));
- LLDB_REGISTER_METHOD(void, SBPlatformShellCommand, Clear, ());
- LLDB_REGISTER_METHOD(const char *, SBPlatformShellCommand, GetCommand, ());
- LLDB_REGISTER_METHOD(void, SBPlatformShellCommand, SetCommand,
- (const char *));
- LLDB_REGISTER_METHOD(const char *, SBPlatformShellCommand,
- GetWorkingDirectory, ());
- LLDB_REGISTER_METHOD(void, SBPlatformShellCommand, SetWorkingDirectory,
- (const char *));
- LLDB_REGISTER_METHOD(uint32_t, SBPlatformShellCommand, GetTimeoutSeconds,
- ());
- LLDB_REGISTER_METHOD(void, SBPlatformShellCommand, SetTimeoutSeconds,
- (uint32_t));
- LLDB_REGISTER_METHOD(int, SBPlatformShellCommand, GetSignal, ());
- LLDB_REGISTER_METHOD(int, SBPlatformShellCommand, GetStatus, ());
- LLDB_REGISTER_METHOD(const char *, SBPlatformShellCommand, GetOutput, ());
- LLDB_REGISTER_CONSTRUCTOR(SBPlatform, ());
- LLDB_REGISTER_CONSTRUCTOR(SBPlatform, (const char *));
- LLDB_REGISTER_METHOD_CONST(bool, SBPlatform, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBPlatform, operator bool, ());
- LLDB_REGISTER_METHOD(void, SBPlatform, Clear, ());
- LLDB_REGISTER_METHOD(const char *, SBPlatform, GetName, ());
- LLDB_REGISTER_METHOD(const char *, SBPlatform, GetWorkingDirectory, ());
- LLDB_REGISTER_METHOD(bool, SBPlatform, SetWorkingDirectory, (const char *));
- LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, ConnectRemote,
- (lldb::SBPlatformConnectOptions &));
- LLDB_REGISTER_METHOD(void, SBPlatform, DisconnectRemote, ());
- LLDB_REGISTER_METHOD(bool, SBPlatform, IsConnected, ());
- LLDB_REGISTER_METHOD(const char *, SBPlatform, GetTriple, ());
- LLDB_REGISTER_METHOD(const char *, SBPlatform, GetOSBuild, ());
- LLDB_REGISTER_METHOD(const char *, SBPlatform, GetOSDescription, ());
- LLDB_REGISTER_METHOD(const char *, SBPlatform, GetHostname, ());
- LLDB_REGISTER_METHOD(uint32_t, SBPlatform, GetOSMajorVersion, ());
- LLDB_REGISTER_METHOD(uint32_t, SBPlatform, GetOSMinorVersion, ());
- LLDB_REGISTER_METHOD(uint32_t, SBPlatform, GetOSUpdateVersion, ());
- LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Get,
- (lldb::SBFileSpec &, lldb::SBFileSpec &));
- LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Put,
- (lldb::SBFileSpec &, lldb::SBFileSpec &));
- LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Install,
- (lldb::SBFileSpec &, lldb::SBFileSpec &));
- LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Run,
- (lldb::SBPlatformShellCommand &));
- LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Launch,
- (lldb::SBLaunchInfo &));
- LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Kill, (const lldb::pid_t));
- LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, MakeDirectory,
- (const char *, uint32_t));
- LLDB_REGISTER_METHOD(uint32_t, SBPlatform, GetFilePermissions,
- (const char *));
- LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, SetFilePermissions,
- (const char *, uint32_t));
- LLDB_REGISTER_METHOD_CONST(lldb::SBUnixSignals, SBPlatform, GetUnixSignals,
- ());
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBProcess, ());
- LLDB_REGISTER_CONSTRUCTOR(SBProcess, (const lldb::SBProcess &));
- LLDB_REGISTER_CONSTRUCTOR(SBProcess, (const lldb::ProcessSP &));
- LLDB_REGISTER_METHOD(const lldb::SBProcess &,
- SBProcess, operator=,(const lldb::SBProcess &));
- LLDB_REGISTER_STATIC_METHOD(const char *, SBProcess,
- GetBroadcasterClassName, ());
- LLDB_REGISTER_METHOD(const char *, SBProcess, GetPluginName, ());
- LLDB_REGISTER_METHOD(const char *, SBProcess, GetShortPluginName, ());
- LLDB_REGISTER_METHOD(void, SBProcess, Clear, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBProcess, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBProcess, operator bool, ());
- LLDB_REGISTER_METHOD(bool, SBProcess, RemoteLaunch,
- (const char **, const char **, const char *,
- const char *, const char *, const char *, uint32_t,
- bool, lldb::SBError &));
- LLDB_REGISTER_METHOD(bool, SBProcess, RemoteAttachToProcessWithID,
- (lldb::pid_t, lldb::SBError &));
- LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetNumThreads, ());
- LLDB_REGISTER_METHOD_CONST(lldb::SBThread, SBProcess, GetSelectedThread,
- ());
- LLDB_REGISTER_METHOD(lldb::SBThread, SBProcess, CreateOSPluginThread,
- (lldb::tid_t, lldb::addr_t));
- LLDB_REGISTER_METHOD_CONST(lldb::SBTarget, SBProcess, GetTarget, ());
- LLDB_REGISTER_METHOD(size_t, SBProcess, PutSTDIN, (const char *, size_t));
- LLDB_REGISTER_METHOD_CONST(size_t, SBProcess, GetSTDOUT, (char *, size_t));
- LLDB_REGISTER_METHOD_CONST(size_t, SBProcess, GetSTDERR, (char *, size_t));
- LLDB_REGISTER_METHOD_CONST(size_t, SBProcess, GetAsyncProfileData,
- (char *, size_t));
- LLDB_REGISTER_METHOD(lldb::SBTrace, SBProcess, StartTrace,
- (lldb::SBTraceOptions &, lldb::SBError &));
- LLDB_REGISTER_METHOD_CONST(void, SBProcess, ReportEventState,
- (const lldb::SBEvent &, FILE *));
- LLDB_REGISTER_METHOD(
- void, SBProcess, AppendEventStateReport,
- (const lldb::SBEvent &, lldb::SBCommandReturnObject &));
- LLDB_REGISTER_METHOD(bool, SBProcess, SetSelectedThread,
- (const lldb::SBThread &));
- LLDB_REGISTER_METHOD(bool, SBProcess, SetSelectedThreadByID, (lldb::tid_t));
- LLDB_REGISTER_METHOD(bool, SBProcess, SetSelectedThreadByIndexID,
- (uint32_t));
- LLDB_REGISTER_METHOD(lldb::SBThread, SBProcess, GetThreadAtIndex, (size_t));
- LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetNumQueues, ());
- LLDB_REGISTER_METHOD(lldb::SBQueue, SBProcess, GetQueueAtIndex, (size_t));
- LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetStopID, (bool));
- LLDB_REGISTER_METHOD(lldb::SBEvent, SBProcess, GetStopEventForStopID,
- (uint32_t));
- LLDB_REGISTER_METHOD(lldb::StateType, SBProcess, GetState, ());
- LLDB_REGISTER_METHOD(int, SBProcess, GetExitStatus, ());
- LLDB_REGISTER_METHOD(const char *, SBProcess, GetExitDescription, ());
- LLDB_REGISTER_METHOD(lldb::pid_t, SBProcess, GetProcessID, ());
- LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetUniqueID, ());
- LLDB_REGISTER_METHOD_CONST(lldb::ByteOrder, SBProcess, GetByteOrder, ());
- LLDB_REGISTER_METHOD_CONST(uint32_t, SBProcess, GetAddressByteSize, ());
- LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Continue, ());
- LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Destroy, ());
- LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Stop, ());
- LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Kill, ());
- LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Detach, ());
- LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Detach, (bool));
- LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Signal, (int));
- LLDB_REGISTER_METHOD(lldb::SBUnixSignals, SBProcess, GetUnixSignals, ());
- LLDB_REGISTER_METHOD(void, SBProcess, SendAsyncInterrupt, ());
- LLDB_REGISTER_METHOD(lldb::SBThread, SBProcess, GetThreadByID,
- (lldb::tid_t));
- LLDB_REGISTER_METHOD(lldb::SBThread, SBProcess, GetThreadByIndexID,
- (uint32_t));
- LLDB_REGISTER_STATIC_METHOD(lldb::StateType, SBProcess, GetStateFromEvent,
- (const lldb::SBEvent &));
- LLDB_REGISTER_STATIC_METHOD(bool, SBProcess, GetRestartedFromEvent,
- (const lldb::SBEvent &));
- LLDB_REGISTER_STATIC_METHOD(size_t, SBProcess,
- GetNumRestartedReasonsFromEvent,
- (const lldb::SBEvent &));
- LLDB_REGISTER_STATIC_METHOD(const char *, SBProcess,
- GetRestartedReasonAtIndexFromEvent,
- (const lldb::SBEvent &, size_t));
- LLDB_REGISTER_STATIC_METHOD(lldb::SBProcess, SBProcess, GetProcessFromEvent,
- (const lldb::SBEvent &));
- LLDB_REGISTER_STATIC_METHOD(bool, SBProcess, GetInterruptedFromEvent,
- (const lldb::SBEvent &));
- LLDB_REGISTER_STATIC_METHOD(lldb::SBStructuredData, SBProcess,
- GetStructuredDataFromEvent,
- (const lldb::SBEvent &));
- LLDB_REGISTER_STATIC_METHOD(bool, SBProcess, EventIsProcessEvent,
- (const lldb::SBEvent &));
- LLDB_REGISTER_STATIC_METHOD(bool, SBProcess, EventIsStructuredDataEvent,
- (const lldb::SBEvent &));
- LLDB_REGISTER_METHOD_CONST(lldb::SBBroadcaster, SBProcess, GetBroadcaster,
- ());
- LLDB_REGISTER_STATIC_METHOD(const char *, SBProcess, GetBroadcasterClass,
- ());
- LLDB_REGISTER_METHOD(uint64_t, SBProcess, ReadUnsignedFromMemory,
- (lldb::addr_t, uint32_t, lldb::SBError &));
- LLDB_REGISTER_METHOD(lldb::addr_t, SBProcess, ReadPointerFromMemory,
- (lldb::addr_t, lldb::SBError &));
- LLDB_REGISTER_METHOD(bool, SBProcess, GetDescription, (lldb::SBStream &));
- LLDB_REGISTER_METHOD_CONST(uint32_t, SBProcess,
- GetNumSupportedHardwareWatchpoints,
- (lldb::SBError &));
- LLDB_REGISTER_METHOD(uint32_t, SBProcess, LoadImage,
- (lldb::SBFileSpec &, lldb::SBError &));
- LLDB_REGISTER_METHOD(
- uint32_t, SBProcess, LoadImage,
- (const lldb::SBFileSpec &, const lldb::SBFileSpec &, lldb::SBError &));
- LLDB_REGISTER_METHOD(uint32_t, SBProcess, LoadImageUsingPaths,
- (const lldb::SBFileSpec &, lldb::SBStringList &,
- lldb::SBFileSpec &, lldb::SBError &));
- LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, UnloadImage, (uint32_t));
- LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, SendEventData,
- (const char *));
- LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetNumExtendedBacktraceTypes, ());
- LLDB_REGISTER_METHOD(const char *, SBProcess,
- GetExtendedBacktraceTypeAtIndex, (uint32_t));
- LLDB_REGISTER_METHOD(lldb::SBThreadCollection, SBProcess, GetHistoryThreads,
- (lldb::addr_t));
- LLDB_REGISTER_METHOD(bool, SBProcess, IsInstrumentationRuntimePresent,
- (lldb::InstrumentationRuntimeType));
- LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, SaveCore, (const char *));
- LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, GetMemoryRegionInfo,
- (lldb::addr_t, lldb::SBMemoryRegionInfo &));
- LLDB_REGISTER_METHOD(lldb::SBMemoryRegionInfoList, SBProcess,
- GetMemoryRegions, ());
- LLDB_REGISTER_METHOD(lldb::SBProcessInfo, SBProcess, GetProcessInfo, ());
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBProcessInfo, ());
- LLDB_REGISTER_CONSTRUCTOR(SBProcessInfo, (const lldb::SBProcessInfo &));
- LLDB_REGISTER_METHOD(
- lldb::SBProcessInfo &,
- SBProcessInfo, operator=,(const lldb::SBProcessInfo &));
- LLDB_REGISTER_METHOD_CONST(bool, SBProcessInfo, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBProcessInfo, operator bool, ());
- LLDB_REGISTER_METHOD(const char *, SBProcessInfo, GetName, ());
- LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBProcessInfo, GetExecutableFile,
- ());
- LLDB_REGISTER_METHOD(lldb::pid_t, SBProcessInfo, GetProcessID, ());
- LLDB_REGISTER_METHOD(uint32_t, SBProcessInfo, GetUserID, ());
- LLDB_REGISTER_METHOD(uint32_t, SBProcessInfo, GetGroupID, ());
- LLDB_REGISTER_METHOD(bool, SBProcessInfo, UserIDIsValid, ());
- LLDB_REGISTER_METHOD(bool, SBProcessInfo, GroupIDIsValid, ());
- LLDB_REGISTER_METHOD(uint32_t, SBProcessInfo, GetEffectiveUserID, ());
- LLDB_REGISTER_METHOD(uint32_t, SBProcessInfo, GetEffectiveGroupID, ());
- LLDB_REGISTER_METHOD(bool, SBProcessInfo, EffectiveUserIDIsValid, ());
- LLDB_REGISTER_METHOD(bool, SBProcessInfo, EffectiveGroupIDIsValid, ());
- LLDB_REGISTER_METHOD(lldb::pid_t, SBProcessInfo, GetParentProcessID, ());
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBQueue, ());
- LLDB_REGISTER_CONSTRUCTOR(SBQueue, (const lldb::QueueSP &));
- LLDB_REGISTER_CONSTRUCTOR(SBQueue, (const lldb::SBQueue &));
- LLDB_REGISTER_METHOD(const lldb::SBQueue &,
- SBQueue, operator=,(const lldb::SBQueue &));
- LLDB_REGISTER_METHOD_CONST(bool, SBQueue, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBQueue, operator bool, ());
- LLDB_REGISTER_METHOD(void, SBQueue, Clear, ());
- LLDB_REGISTER_METHOD_CONST(lldb::queue_id_t, SBQueue, GetQueueID, ());
- LLDB_REGISTER_METHOD_CONST(uint32_t, SBQueue, GetIndexID, ());
- LLDB_REGISTER_METHOD_CONST(const char *, SBQueue, GetName, ());
- LLDB_REGISTER_METHOD(uint32_t, SBQueue, GetNumThreads, ());
- LLDB_REGISTER_METHOD(lldb::SBThread, SBQueue, GetThreadAtIndex, (uint32_t));
- LLDB_REGISTER_METHOD(uint32_t, SBQueue, GetNumPendingItems, ());
- LLDB_REGISTER_METHOD(lldb::SBQueueItem, SBQueue, GetPendingItemAtIndex,
- (uint32_t));
- LLDB_REGISTER_METHOD(uint32_t, SBQueue, GetNumRunningItems, ());
- LLDB_REGISTER_METHOD(lldb::SBProcess, SBQueue, GetProcess, ());
- LLDB_REGISTER_METHOD(lldb::QueueKind, SBQueue, GetKind, ());
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBQueueItem, ());
- LLDB_REGISTER_CONSTRUCTOR(SBQueueItem, (const lldb::QueueItemSP &));
- LLDB_REGISTER_METHOD_CONST(bool, SBQueueItem, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBQueueItem, operator bool, ());
- LLDB_REGISTER_METHOD(void, SBQueueItem, Clear, ());
- LLDB_REGISTER_METHOD(void, SBQueueItem, SetQueueItem,
- (const lldb::QueueItemSP &));
- LLDB_REGISTER_METHOD_CONST(lldb::QueueItemKind, SBQueueItem, GetKind, ());
- LLDB_REGISTER_METHOD(void, SBQueueItem, SetKind, (lldb::QueueItemKind));
- LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBQueueItem, GetAddress, ());
- LLDB_REGISTER_METHOD(void, SBQueueItem, SetAddress, (lldb::SBAddress));
- LLDB_REGISTER_METHOD(lldb::SBThread, SBQueueItem,
- GetExtendedBacktraceThread, (const char *));
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBSection, ());
- LLDB_REGISTER_CONSTRUCTOR(SBSection, (const lldb::SBSection &));
- LLDB_REGISTER_METHOD(const lldb::SBSection &,
- SBSection, operator=,(const lldb::SBSection &));
- LLDB_REGISTER_METHOD_CONST(bool, SBSection, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBSection, operator bool, ());
- LLDB_REGISTER_METHOD(const char *, SBSection, GetName, ());
- LLDB_REGISTER_METHOD(lldb::SBSection, SBSection, GetParent, ());
- LLDB_REGISTER_METHOD(lldb::SBSection, SBSection, FindSubSection,
- (const char *));
- LLDB_REGISTER_METHOD(size_t, SBSection, GetNumSubSections, ());
- LLDB_REGISTER_METHOD(lldb::SBSection, SBSection, GetSubSectionAtIndex,
- (size_t));
- LLDB_REGISTER_METHOD(lldb::addr_t, SBSection, GetFileAddress, ());
- LLDB_REGISTER_METHOD(lldb::addr_t, SBSection, GetLoadAddress,
- (lldb::SBTarget &));
- LLDB_REGISTER_METHOD(lldb::addr_t, SBSection, GetByteSize, ());
- LLDB_REGISTER_METHOD(uint64_t, SBSection, GetFileOffset, ());
- LLDB_REGISTER_METHOD(uint64_t, SBSection, GetFileByteSize, ());
- LLDB_REGISTER_METHOD(lldb::SBData, SBSection, GetSectionData, ());
- LLDB_REGISTER_METHOD(lldb::SBData, SBSection, GetSectionData,
- (uint64_t, uint64_t));
- LLDB_REGISTER_METHOD(lldb::SectionType, SBSection, GetSectionType, ());
- LLDB_REGISTER_METHOD_CONST(uint32_t, SBSection, GetPermissions, ());
- LLDB_REGISTER_METHOD(uint32_t, SBSection, GetTargetByteSize, ());
- LLDB_REGISTER_METHOD(bool, SBSection, operator==,(const lldb::SBSection &));
- LLDB_REGISTER_METHOD(bool, SBSection, operator!=,(const lldb::SBSection &));
- LLDB_REGISTER_METHOD(bool, SBSection, GetDescription, (lldb::SBStream &));
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBSourceManager, (const lldb::SBDebugger &));
- LLDB_REGISTER_CONSTRUCTOR(SBSourceManager, (const lldb::SBTarget &));
- LLDB_REGISTER_CONSTRUCTOR(SBSourceManager, (const lldb::SBSourceManager &));
- LLDB_REGISTER_METHOD(
- const lldb::SBSourceManager &,
- SBSourceManager, operator=,(const lldb::SBSourceManager &));
- LLDB_REGISTER_METHOD(size_t, SBSourceManager,
- DisplaySourceLinesWithLineNumbers,
- (const lldb::SBFileSpec &, uint32_t, uint32_t,
- uint32_t, const char *, lldb::SBStream &));
- LLDB_REGISTER_METHOD(size_t, SBSourceManager,
- DisplaySourceLinesWithLineNumbersAndColumn,
- (const lldb::SBFileSpec &, uint32_t, uint32_t,
- uint32_t, uint32_t, const char *, lldb::SBStream &));
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBStream, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBStream, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBStream, operator bool, ());
- LLDB_REGISTER_METHOD(const char *, SBStream, GetData, ());
- LLDB_REGISTER_METHOD(size_t, SBStream, GetSize, ());
- LLDB_REGISTER_METHOD(void, SBStream, RedirectToFile, (const char *, bool));
- LLDB_REGISTER_METHOD(void, SBStream, RedirectToFileHandle, (FILE *, bool));
- LLDB_REGISTER_METHOD(void, SBStream, RedirectToFileDescriptor, (int, bool));
- LLDB_REGISTER_METHOD(void, SBStream, Clear, ());
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBStringList, ());
- LLDB_REGISTER_CONSTRUCTOR(SBStringList, (const lldb::SBStringList &));
- LLDB_REGISTER_METHOD(const lldb::SBStringList &,
- SBStringList, operator=,(const lldb::SBStringList &));
- LLDB_REGISTER_METHOD_CONST(bool, SBStringList, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBStringList, operator bool, ());
- LLDB_REGISTER_METHOD(void, SBStringList, AppendString, (const char *));
- LLDB_REGISTER_METHOD(void, SBStringList, AppendList, (const char **, int));
- LLDB_REGISTER_METHOD(void, SBStringList, AppendList,
- (const lldb::SBStringList &));
- LLDB_REGISTER_METHOD_CONST(uint32_t, SBStringList, GetSize, ());
- LLDB_REGISTER_METHOD(const char *, SBStringList, GetStringAtIndex,
- (size_t));
- LLDB_REGISTER_METHOD_CONST(const char *, SBStringList, GetStringAtIndex,
- (size_t));
- LLDB_REGISTER_METHOD(void, SBStringList, Clear, ());
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBStructuredData, ());
- LLDB_REGISTER_CONSTRUCTOR(SBStructuredData,
- (const lldb::SBStructuredData &));
- LLDB_REGISTER_CONSTRUCTOR(SBStructuredData, (const lldb::EventSP &));
- LLDB_REGISTER_CONSTRUCTOR(SBStructuredData,
- (lldb_private::StructuredDataImpl *));
- LLDB_REGISTER_METHOD(
- lldb::SBStructuredData &,
- SBStructuredData, operator=,(const lldb::SBStructuredData &));
- LLDB_REGISTER_METHOD(lldb::SBError, SBStructuredData, SetFromJSON,
- (lldb::SBStream &));
- LLDB_REGISTER_METHOD_CONST(bool, SBStructuredData, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBStructuredData, operator bool, ());
- LLDB_REGISTER_METHOD(void, SBStructuredData, Clear, ());
- LLDB_REGISTER_METHOD_CONST(lldb::SBError, SBStructuredData, GetAsJSON,
- (lldb::SBStream &));
- LLDB_REGISTER_METHOD_CONST(lldb::SBError, SBStructuredData, GetDescription,
- (lldb::SBStream &));
- LLDB_REGISTER_METHOD_CONST(lldb::StructuredDataType, SBStructuredData,
- GetType, ());
- LLDB_REGISTER_METHOD_CONST(size_t, SBStructuredData, GetSize, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBStructuredData, GetKeys,
- (lldb::SBStringList &));
- LLDB_REGISTER_METHOD_CONST(lldb::SBStructuredData, SBStructuredData,
- GetValueForKey, (const char *));
- LLDB_REGISTER_METHOD_CONST(lldb::SBStructuredData, SBStructuredData,
- GetItemAtIndex, (size_t));
- LLDB_REGISTER_METHOD_CONST(uint64_t, SBStructuredData, GetIntegerValue,
- (uint64_t));
- LLDB_REGISTER_METHOD_CONST(double, SBStructuredData, GetFloatValue,
- (double));
- LLDB_REGISTER_METHOD_CONST(bool, SBStructuredData, GetBooleanValue, (bool));
- LLDB_REGISTER_METHOD_CONST(size_t, SBStructuredData, GetStringValue,
- (char *, size_t));
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBSymbol, ());
- LLDB_REGISTER_CONSTRUCTOR(SBSymbol, (const lldb::SBSymbol &));
- LLDB_REGISTER_METHOD(const lldb::SBSymbol &,
- SBSymbol, operator=,(const lldb::SBSymbol &));
- LLDB_REGISTER_METHOD_CONST(bool, SBSymbol, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBSymbol, operator bool, ());
- LLDB_REGISTER_METHOD_CONST(const char *, SBSymbol, GetName, ());
- LLDB_REGISTER_METHOD_CONST(const char *, SBSymbol, GetDisplayName, ());
- LLDB_REGISTER_METHOD_CONST(const char *, SBSymbol, GetMangledName, ());
- LLDB_REGISTER_METHOD_CONST(bool,
- SBSymbol, operator==,(const lldb::SBSymbol &));
- LLDB_REGISTER_METHOD_CONST(bool,
- SBSymbol, operator!=,(const lldb::SBSymbol &));
- LLDB_REGISTER_METHOD(bool, SBSymbol, GetDescription, (lldb::SBStream &));
- LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBSymbol, GetInstructions,
- (lldb::SBTarget));
- LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBSymbol, GetInstructions,
- (lldb::SBTarget, const char *));
- LLDB_REGISTER_METHOD(lldb::SBAddress, SBSymbol, GetStartAddress, ());
- LLDB_REGISTER_METHOD(lldb::SBAddress, SBSymbol, GetEndAddress, ());
- LLDB_REGISTER_METHOD(uint32_t, SBSymbol, GetPrologueByteSize, ());
- LLDB_REGISTER_METHOD(lldb::SymbolType, SBSymbol, GetType, ());
- LLDB_REGISTER_METHOD(bool, SBSymbol, IsExternal, ());
- LLDB_REGISTER_METHOD(bool, SBSymbol, IsSynthetic, ());
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBSymbolContext, ());
- LLDB_REGISTER_CONSTRUCTOR(SBSymbolContext,
- (const lldb_private::SymbolContext *));
- LLDB_REGISTER_CONSTRUCTOR(SBSymbolContext, (const lldb::SBSymbolContext &));
- LLDB_REGISTER_METHOD(
- const lldb::SBSymbolContext &,
- SBSymbolContext, operator=,(const lldb::SBSymbolContext &));
- LLDB_REGISTER_METHOD_CONST(bool, SBSymbolContext, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBSymbolContext, operator bool, ());
- LLDB_REGISTER_METHOD(lldb::SBModule, SBSymbolContext, GetModule, ());
- LLDB_REGISTER_METHOD(lldb::SBCompileUnit, SBSymbolContext, GetCompileUnit,
- ());
- LLDB_REGISTER_METHOD(lldb::SBFunction, SBSymbolContext, GetFunction, ());
- LLDB_REGISTER_METHOD(lldb::SBBlock, SBSymbolContext, GetBlock, ());
- LLDB_REGISTER_METHOD(lldb::SBLineEntry, SBSymbolContext, GetLineEntry, ());
- LLDB_REGISTER_METHOD(lldb::SBSymbol, SBSymbolContext, GetSymbol, ());
- LLDB_REGISTER_METHOD(void, SBSymbolContext, SetModule, (lldb::SBModule));
- LLDB_REGISTER_METHOD(void, SBSymbolContext, SetCompileUnit,
- (lldb::SBCompileUnit));
- LLDB_REGISTER_METHOD(void, SBSymbolContext, SetFunction,
- (lldb::SBFunction));
- LLDB_REGISTER_METHOD(void, SBSymbolContext, SetBlock, (lldb::SBBlock));
- LLDB_REGISTER_METHOD(void, SBSymbolContext, SetLineEntry,
- (lldb::SBLineEntry));
- LLDB_REGISTER_METHOD(void, SBSymbolContext, SetSymbol, (lldb::SBSymbol));
- LLDB_REGISTER_METHOD(bool, SBSymbolContext, GetDescription,
- (lldb::SBStream &));
- LLDB_REGISTER_METHOD_CONST(lldb::SBSymbolContext, SBSymbolContext,
- GetParentOfInlinedScope,
- (const lldb::SBAddress &, lldb::SBAddress &));
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBSymbolContextList, ());
- LLDB_REGISTER_CONSTRUCTOR(SBSymbolContextList,
- (const lldb::SBSymbolContextList &));
- LLDB_REGISTER_METHOD(
- const lldb::SBSymbolContextList &,
- SBSymbolContextList, operator=,(const lldb::SBSymbolContextList &));
- LLDB_REGISTER_METHOD_CONST(uint32_t, SBSymbolContextList, GetSize, ());
- LLDB_REGISTER_METHOD(lldb::SBSymbolContext, SBSymbolContextList,
- GetContextAtIndex, (uint32_t));
- LLDB_REGISTER_METHOD(void, SBSymbolContextList, Clear, ());
- LLDB_REGISTER_METHOD(void, SBSymbolContextList, Append,
- (lldb::SBSymbolContext &));
- LLDB_REGISTER_METHOD(void, SBSymbolContextList, Append,
- (lldb::SBSymbolContextList &));
- LLDB_REGISTER_METHOD_CONST(bool, SBSymbolContextList, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBSymbolContextList, operator bool, ());
- LLDB_REGISTER_METHOD(bool, SBSymbolContextList, GetDescription,
- (lldb::SBStream &));
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBTarget, ());
- LLDB_REGISTER_CONSTRUCTOR(SBTarget, (const lldb::SBTarget &));
- LLDB_REGISTER_CONSTRUCTOR(SBTarget, (const lldb::TargetSP &));
- LLDB_REGISTER_METHOD(const lldb::SBTarget &,
- SBTarget, operator=,(const lldb::SBTarget &));
- LLDB_REGISTER_STATIC_METHOD(bool, SBTarget, EventIsTargetEvent,
- (const lldb::SBEvent &));
- LLDB_REGISTER_STATIC_METHOD(lldb::SBTarget, SBTarget, GetTargetFromEvent,
- (const lldb::SBEvent &));
- LLDB_REGISTER_STATIC_METHOD(uint32_t, SBTarget, GetNumModulesFromEvent,
- (const lldb::SBEvent &));
- LLDB_REGISTER_STATIC_METHOD(lldb::SBModule, SBTarget,
- GetModuleAtIndexFromEvent,
- (const uint32_t, const lldb::SBEvent &));
- LLDB_REGISTER_STATIC_METHOD(const char *, SBTarget, GetBroadcasterClassName,
- ());
- LLDB_REGISTER_METHOD_CONST(bool, SBTarget, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBTarget, operator bool, ());
- LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, GetProcess, ());
- LLDB_REGISTER_METHOD(lldb::SBPlatform, SBTarget, GetPlatform, ());
- LLDB_REGISTER_METHOD_CONST(lldb::SBDebugger, SBTarget, GetDebugger, ());
- LLDB_REGISTER_METHOD(lldb::SBStructuredData, SBTarget, GetStatistics, ());
- LLDB_REGISTER_METHOD(void, SBTarget, SetCollectingStats, (bool));
- LLDB_REGISTER_METHOD(bool, SBTarget, GetCollectingStats, ());
- LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, LoadCore, (const char *));
- LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, LoadCore,
- (const char *, lldb::SBError &));
- LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, LaunchSimple,
- (const char **, const char **, const char *));
- LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, Install, ());
- LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, Launch,
- (lldb::SBListener &, const char **, const char **,
- const char *, const char *, const char *,
- const char *, uint32_t, bool, lldb::SBError &));
- LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, Launch,
- (lldb::SBLaunchInfo &, lldb::SBError &));
- LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, Attach,
- (lldb::SBAttachInfo &, lldb::SBError &));
- LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, AttachToProcessWithID,
- (lldb::SBListener &, lldb::pid_t, lldb::SBError &));
- LLDB_REGISTER_METHOD(
- lldb::SBProcess, SBTarget, AttachToProcessWithName,
- (lldb::SBListener &, const char *, bool, lldb::SBError &));
- LLDB_REGISTER_METHOD(
- lldb::SBProcess, SBTarget, ConnectRemote,
- (lldb::SBListener &, const char *, const char *, lldb::SBError &));
- LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBTarget, GetExecutable, ());
- LLDB_REGISTER_METHOD_CONST(bool,
- SBTarget, operator==,(const lldb::SBTarget &));
- LLDB_REGISTER_METHOD_CONST(bool,
- SBTarget, operator!=,(const lldb::SBTarget &));
- LLDB_REGISTER_METHOD(lldb::SBAddress, SBTarget, ResolveLoadAddress,
- (lldb::addr_t));
- LLDB_REGISTER_METHOD(lldb::SBAddress, SBTarget, ResolveFileAddress,
- (lldb::addr_t));
- LLDB_REGISTER_METHOD(lldb::SBAddress, SBTarget, ResolvePastLoadAddress,
- (uint32_t, lldb::addr_t));
- LLDB_REGISTER_METHOD(lldb::SBSymbolContext, SBTarget,
- ResolveSymbolContextForAddress,
- (const lldb::SBAddress &, uint32_t));
- LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
- BreakpointCreateByLocation, (const char *, uint32_t));
- LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
- BreakpointCreateByLocation,
- (const lldb::SBFileSpec &, uint32_t));
- LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
- BreakpointCreateByLocation,
- (const lldb::SBFileSpec &, uint32_t, lldb::addr_t));
- LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
- BreakpointCreateByLocation,
- (const lldb::SBFileSpec &, uint32_t, lldb::addr_t,
- lldb::SBFileSpecList &));
- LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
- BreakpointCreateByLocation,
- (const lldb::SBFileSpec &, uint32_t, uint32_t,
- lldb::addr_t, lldb::SBFileSpecList &));
- LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
- (const char *, const char *));
- LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
- (const char *, const lldb::SBFileSpecList &,
- const lldb::SBFileSpecList &));
- LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
- (const char *, uint32_t, const lldb::SBFileSpecList &,
- const lldb::SBFileSpecList &));
- LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
- (const char *, uint32_t, lldb::LanguageType,
- const lldb::SBFileSpecList &,
- const lldb::SBFileSpecList &));
- LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames,
- (const char **, uint32_t, uint32_t,
- const lldb::SBFileSpecList &,
- const lldb::SBFileSpecList &));
- LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames,
- (const char **, uint32_t, uint32_t, lldb::LanguageType,
- const lldb::SBFileSpecList &,
- const lldb::SBFileSpecList &));
- LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames,
- (const char **, uint32_t, uint32_t, lldb::LanguageType,
- lldb::addr_t, const lldb::SBFileSpecList &,
- const lldb::SBFileSpecList &));
- LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex,
- (const char *, const char *));
- LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex,
- (const char *, const lldb::SBFileSpecList &,
- const lldb::SBFileSpecList &));
- LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex,
- (const char *, lldb::LanguageType,
- const lldb::SBFileSpecList &,
- const lldb::SBFileSpecList &));
- LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
- BreakpointCreateByAddress, (lldb::addr_t));
- LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
- BreakpointCreateBySBAddress, (lldb::SBAddress &));
- LLDB_REGISTER_METHOD(
- lldb::SBBreakpoint, SBTarget, BreakpointCreateBySourceRegex,
- (const char *, const lldb::SBFileSpec &, const char *));
- LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
- BreakpointCreateBySourceRegex,
- (const char *, const lldb::SBFileSpecList &,
- const lldb::SBFileSpecList &));
- LLDB_REGISTER_METHOD(
- lldb::SBBreakpoint, SBTarget, BreakpointCreateBySourceRegex,
- (const char *, const lldb::SBFileSpecList &,
- const lldb::SBFileSpecList &, const lldb::SBStringList &));
- LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
- BreakpointCreateForException,
- (lldb::LanguageType, bool, bool));
- LLDB_REGISTER_METHOD(
- lldb::SBBreakpoint, SBTarget, BreakpointCreateFromScript,
- (const char *, lldb::SBStructuredData &, const lldb::SBFileSpecList &,
- const lldb::SBFileSpecList &, bool));
- LLDB_REGISTER_METHOD_CONST(uint32_t, SBTarget, GetNumBreakpoints, ());
- LLDB_REGISTER_METHOD_CONST(lldb::SBBreakpoint, SBTarget,
- GetBreakpointAtIndex, (uint32_t));
- LLDB_REGISTER_METHOD(bool, SBTarget, BreakpointDelete, (lldb::break_id_t));
- LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, FindBreakpointByID,
- (lldb::break_id_t));
- LLDB_REGISTER_METHOD(bool, SBTarget, FindBreakpointsByName,
- (const char *, lldb::SBBreakpointList &));
- LLDB_REGISTER_METHOD(void, SBTarget, GetBreakpointNames,
- (lldb::SBStringList &));
- LLDB_REGISTER_METHOD(void, SBTarget, DeleteBreakpointName, (const char *));
- LLDB_REGISTER_METHOD(bool, SBTarget, EnableAllBreakpoints, ());
- LLDB_REGISTER_METHOD(bool, SBTarget, DisableAllBreakpoints, ());
- LLDB_REGISTER_METHOD(bool, SBTarget, DeleteAllBreakpoints, ());
- LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, BreakpointsCreateFromFile,
- (lldb::SBFileSpec &, lldb::SBBreakpointList &));
- LLDB_REGISTER_METHOD(
- lldb::SBError, SBTarget, BreakpointsCreateFromFile,
- (lldb::SBFileSpec &, lldb::SBStringList &, lldb::SBBreakpointList &));
- LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, BreakpointsWriteToFile,
- (lldb::SBFileSpec &));
- LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, BreakpointsWriteToFile,
- (lldb::SBFileSpec &, lldb::SBBreakpointList &, bool));
- LLDB_REGISTER_METHOD_CONST(uint32_t, SBTarget, GetNumWatchpoints, ());
- LLDB_REGISTER_METHOD_CONST(lldb::SBWatchpoint, SBTarget,
- GetWatchpointAtIndex, (uint32_t));
- LLDB_REGISTER_METHOD(bool, SBTarget, DeleteWatchpoint, (lldb::watch_id_t));
- LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBTarget, FindWatchpointByID,
- (lldb::watch_id_t));
- LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBTarget, WatchAddress,
- (lldb::addr_t, size_t, bool, bool, lldb::SBError &));
- LLDB_REGISTER_METHOD(bool, SBTarget, EnableAllWatchpoints, ());
- LLDB_REGISTER_METHOD(bool, SBTarget, DisableAllWatchpoints, ());
- LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, CreateValueFromAddress,
- (const char *, lldb::SBAddress, lldb::SBType));
- LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, CreateValueFromData,
- (const char *, lldb::SBData, lldb::SBType));
- LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, CreateValueFromExpression,
- (const char *, const char *));
- LLDB_REGISTER_METHOD(bool, SBTarget, DeleteAllWatchpoints, ());
- LLDB_REGISTER_METHOD(void, SBTarget, AppendImageSearchPath,
- (const char *, const char *, lldb::SBError &));
- LLDB_REGISTER_METHOD(lldb::SBModule, SBTarget, AddModule,
- (const char *, const char *, const char *));
- LLDB_REGISTER_METHOD(
- lldb::SBModule, SBTarget, AddModule,
- (const char *, const char *, const char *, const char *));
- LLDB_REGISTER_METHOD(lldb::SBModule, SBTarget, AddModule,
- (const lldb::SBModuleSpec &));
- LLDB_REGISTER_METHOD(bool, SBTarget, AddModule, (lldb::SBModule &));
- LLDB_REGISTER_METHOD_CONST(uint32_t, SBTarget, GetNumModules, ());
- LLDB_REGISTER_METHOD(void, SBTarget, Clear, ());
- LLDB_REGISTER_METHOD(lldb::SBModule, SBTarget, FindModule,
- (const lldb::SBFileSpec &));
- LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBTarget, FindCompileUnits,
- (const lldb::SBFileSpec &));
- LLDB_REGISTER_METHOD(lldb::ByteOrder, SBTarget, GetByteOrder, ());
- LLDB_REGISTER_METHOD(const char *, SBTarget, GetTriple, ());
- LLDB_REGISTER_METHOD(uint32_t, SBTarget, GetDataByteSize, ());
- LLDB_REGISTER_METHOD(uint32_t, SBTarget, GetCodeByteSize, ());
- LLDB_REGISTER_METHOD(uint32_t, SBTarget, GetAddressByteSize, ());
- LLDB_REGISTER_METHOD(lldb::SBModule, SBTarget, GetModuleAtIndex,
- (uint32_t));
- LLDB_REGISTER_METHOD(bool, SBTarget, RemoveModule, (lldb::SBModule));
- LLDB_REGISTER_METHOD_CONST(lldb::SBBroadcaster, SBTarget, GetBroadcaster,
- ());
- LLDB_REGISTER_METHOD(bool, SBTarget, GetDescription,
- (lldb::SBStream &, lldb::DescriptionLevel));
- LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBTarget, FindFunctions,
- (const char *, uint32_t));
- LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBTarget,
- FindGlobalFunctions,
- (const char *, uint32_t, lldb::MatchType));
- LLDB_REGISTER_METHOD(lldb::SBType, SBTarget, FindFirstType, (const char *));
- LLDB_REGISTER_METHOD(lldb::SBType, SBTarget, GetBasicType,
- (lldb::BasicType));
- LLDB_REGISTER_METHOD(lldb::SBTypeList, SBTarget, FindTypes, (const char *));
- LLDB_REGISTER_METHOD(lldb::SBValueList, SBTarget, FindGlobalVariables,
- (const char *, uint32_t));
- LLDB_REGISTER_METHOD(lldb::SBValueList, SBTarget, FindGlobalVariables,
- (const char *, uint32_t, lldb::MatchType));
- LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, FindFirstGlobalVariable,
- (const char *));
- LLDB_REGISTER_METHOD(lldb::SBSourceManager, SBTarget, GetSourceManager, ());
- LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBTarget, ReadInstructions,
- (lldb::SBAddress, uint32_t));
- LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBTarget, ReadInstructions,
- (lldb::SBAddress, uint32_t, const char *));
- LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, SetSectionLoadAddress,
- (lldb::SBSection, lldb::addr_t));
- LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, ClearSectionLoadAddress,
- (lldb::SBSection));
- LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, SetModuleLoadAddress,
- (lldb::SBModule, int64_t));
- LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, ClearModuleLoadAddress,
- (lldb::SBModule));
- LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBTarget, FindSymbols,
- (const char *, lldb::SymbolType));
- LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, EvaluateExpression,
- (const char *));
- LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, EvaluateExpression,
- (const char *, const lldb::SBExpressionOptions &));
- LLDB_REGISTER_METHOD(lldb::addr_t, SBTarget, GetStackRedZoneSize, ());
- LLDB_REGISTER_METHOD_CONST(lldb::SBLaunchInfo, SBTarget, GetLaunchInfo, ());
- LLDB_REGISTER_METHOD(void, SBTarget, SetLaunchInfo,
- (const lldb::SBLaunchInfo &));
- }
- {
- LLDB_REGISTER_STATIC_METHOD(const char *, SBThread, GetBroadcasterClassName,
- ());
- LLDB_REGISTER_CONSTRUCTOR(SBThread, ());
- LLDB_REGISTER_CONSTRUCTOR(SBThread, (const lldb::ThreadSP &));
- LLDB_REGISTER_CONSTRUCTOR(SBThread, (const lldb::SBThread &));
- LLDB_REGISTER_METHOD(const lldb::SBThread &,
- SBThread, operator=,(const lldb::SBThread &));
- LLDB_REGISTER_METHOD_CONST(lldb::SBQueue, SBThread, GetQueue, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBThread, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBThread, operator bool, ());
- LLDB_REGISTER_METHOD(void, SBThread, Clear, ());
- LLDB_REGISTER_METHOD(lldb::StopReason, SBThread, GetStopReason, ());
- LLDB_REGISTER_METHOD(size_t, SBThread, GetStopReasonDataCount, ());
- LLDB_REGISTER_METHOD(uint64_t, SBThread, GetStopReasonDataAtIndex,
- (uint32_t));
- LLDB_REGISTER_METHOD(bool, SBThread, GetStopReasonExtendedInfoAsJSON,
- (lldb::SBStream &));
- LLDB_REGISTER_METHOD(lldb::SBThreadCollection, SBThread,
- GetStopReasonExtendedBacktraces,
- (lldb::InstrumentationRuntimeType));
- LLDB_REGISTER_METHOD(size_t, SBThread, GetStopDescription,
- (char *, size_t));
- LLDB_REGISTER_METHOD(lldb::SBValue, SBThread, GetStopReturnValue, ());
- LLDB_REGISTER_METHOD_CONST(lldb::tid_t, SBThread, GetThreadID, ());
- LLDB_REGISTER_METHOD_CONST(uint32_t, SBThread, GetIndexID, ());
- LLDB_REGISTER_METHOD_CONST(const char *, SBThread, GetName, ());
- LLDB_REGISTER_METHOD_CONST(const char *, SBThread, GetQueueName, ());
- LLDB_REGISTER_METHOD_CONST(lldb::queue_id_t, SBThread, GetQueueID, ());
- LLDB_REGISTER_METHOD(bool, SBThread, GetInfoItemByPathAsString,
- (const char *, lldb::SBStream &));
- LLDB_REGISTER_METHOD(void, SBThread, StepOver, (lldb::RunMode));
- LLDB_REGISTER_METHOD(void, SBThread, StepOver,
- (lldb::RunMode, lldb::SBError &));
- LLDB_REGISTER_METHOD(void, SBThread, StepInto, (lldb::RunMode));
- LLDB_REGISTER_METHOD(void, SBThread, StepInto,
- (const char *, lldb::RunMode));
- LLDB_REGISTER_METHOD(
- void, SBThread, StepInto,
- (const char *, uint32_t, lldb::SBError &, lldb::RunMode));
- LLDB_REGISTER_METHOD(void, SBThread, StepOut, ());
- LLDB_REGISTER_METHOD(void, SBThread, StepOut, (lldb::SBError &));
- LLDB_REGISTER_METHOD(void, SBThread, StepOutOfFrame, (lldb::SBFrame &));
- LLDB_REGISTER_METHOD(void, SBThread, StepOutOfFrame,
- (lldb::SBFrame &, lldb::SBError &));
- LLDB_REGISTER_METHOD(void, SBThread, StepInstruction, (bool));
- LLDB_REGISTER_METHOD(void, SBThread, StepInstruction,
- (bool, lldb::SBError &));
- LLDB_REGISTER_METHOD(void, SBThread, RunToAddress, (lldb::addr_t));
- LLDB_REGISTER_METHOD(void, SBThread, RunToAddress,
- (lldb::addr_t, lldb::SBError &));
- LLDB_REGISTER_METHOD(lldb::SBError, SBThread, StepOverUntil,
- (lldb::SBFrame &, lldb::SBFileSpec &, uint32_t));
- LLDB_REGISTER_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan,
- (const char *));
- LLDB_REGISTER_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan,
- (const char *, bool));
- LLDB_REGISTER_METHOD(lldb::SBError, SBThread, JumpToLine,
- (lldb::SBFileSpec &, uint32_t));
- LLDB_REGISTER_METHOD(lldb::SBError, SBThread, ReturnFromFrame,
- (lldb::SBFrame &, lldb::SBValue &));
- LLDB_REGISTER_METHOD(lldb::SBError, SBThread, UnwindInnermostExpression,
- ());
- LLDB_REGISTER_METHOD(bool, SBThread, Suspend, ());
- LLDB_REGISTER_METHOD(bool, SBThread, Suspend, (lldb::SBError &));
- LLDB_REGISTER_METHOD(bool, SBThread, Resume, ());
- LLDB_REGISTER_METHOD(bool, SBThread, Resume, (lldb::SBError &));
- LLDB_REGISTER_METHOD(bool, SBThread, IsSuspended, ());
- LLDB_REGISTER_METHOD(bool, SBThread, IsStopped, ());
- LLDB_REGISTER_METHOD(lldb::SBProcess, SBThread, GetProcess, ());
- LLDB_REGISTER_METHOD(uint32_t, SBThread, GetNumFrames, ());
- LLDB_REGISTER_METHOD(lldb::SBFrame, SBThread, GetFrameAtIndex, (uint32_t));
- LLDB_REGISTER_METHOD(lldb::SBFrame, SBThread, GetSelectedFrame, ());
- LLDB_REGISTER_METHOD(lldb::SBFrame, SBThread, SetSelectedFrame, (uint32_t));
- LLDB_REGISTER_STATIC_METHOD(bool, SBThread, EventIsThreadEvent,
- (const lldb::SBEvent &));
- LLDB_REGISTER_STATIC_METHOD(lldb::SBFrame, SBThread, GetStackFrameFromEvent,
- (const lldb::SBEvent &));
- LLDB_REGISTER_STATIC_METHOD(lldb::SBThread, SBThread, GetThreadFromEvent,
- (const lldb::SBEvent &));
- LLDB_REGISTER_METHOD_CONST(bool,
- SBThread, operator==,(const lldb::SBThread &));
- LLDB_REGISTER_METHOD_CONST(bool,
- SBThread, operator!=,(const lldb::SBThread &));
- LLDB_REGISTER_METHOD_CONST(bool, SBThread, GetStatus, (lldb::SBStream &));
- LLDB_REGISTER_METHOD_CONST(bool, SBThread, GetDescription,
- (lldb::SBStream &));
- LLDB_REGISTER_METHOD_CONST(bool, SBThread, GetDescription,
- (lldb::SBStream &, bool));
- LLDB_REGISTER_METHOD(lldb::SBThread, SBThread, GetExtendedBacktraceThread,
- (const char *));
- LLDB_REGISTER_METHOD(uint32_t, SBThread,
- GetExtendedBacktraceOriginatingIndexID, ());
- LLDB_REGISTER_METHOD(lldb::SBValue, SBThread, GetCurrentException, ());
- LLDB_REGISTER_METHOD(lldb::SBThread, SBThread, GetCurrentExceptionBacktrace,
- ());
- LLDB_REGISTER_METHOD(bool, SBThread, SafeToCallFunctions, ());
- LLDB_REGISTER_METHOD(lldb_private::Thread *, SBThread, operator->,());
- LLDB_REGISTER_METHOD(lldb_private::Thread *, SBThread, get, ());
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBThreadCollection, ());
- LLDB_REGISTER_CONSTRUCTOR(SBThreadCollection,
- (const lldb::SBThreadCollection &));
- LLDB_REGISTER_METHOD(
- const lldb::SBThreadCollection &,
- SBThreadCollection, operator=,(const lldb::SBThreadCollection &));
- LLDB_REGISTER_METHOD_CONST(bool, SBThreadCollection, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBThreadCollection, operator bool, ());
- LLDB_REGISTER_METHOD(size_t, SBThreadCollection, GetSize, ());
- LLDB_REGISTER_METHOD(lldb::SBThread, SBThreadCollection, GetThreadAtIndex,
- (size_t));
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, ());
- LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, (const lldb::ThreadPlanSP &));
- LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, (const lldb::SBThreadPlan &));
- LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, (lldb::SBThread &, const char *));
- LLDB_REGISTER_METHOD(const lldb::SBThreadPlan &,
- SBThreadPlan, operator=,(const lldb::SBThreadPlan &));
- LLDB_REGISTER_METHOD(lldb_private::ThreadPlan *, SBThreadPlan, get, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBThreadPlan, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBThreadPlan, operator bool, ());
- LLDB_REGISTER_METHOD(void, SBThreadPlan, Clear, ());
- LLDB_REGISTER_METHOD(lldb::StopReason, SBThreadPlan, GetStopReason, ());
- LLDB_REGISTER_METHOD(size_t, SBThreadPlan, GetStopReasonDataCount, ());
- LLDB_REGISTER_METHOD(uint64_t, SBThreadPlan, GetStopReasonDataAtIndex,
- (uint32_t));
- LLDB_REGISTER_METHOD_CONST(lldb::SBThread, SBThreadPlan, GetThread, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBThreadPlan, GetDescription,
- (lldb::SBStream &));
- LLDB_REGISTER_METHOD(void, SBThreadPlan, SetPlanComplete, (bool));
- LLDB_REGISTER_METHOD(bool, SBThreadPlan, IsPlanComplete, ());
- LLDB_REGISTER_METHOD(bool, SBThreadPlan, IsPlanStale, ());
- LLDB_REGISTER_METHOD(bool, SBThreadPlan, IsValid, ());
- LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
- QueueThreadPlanForStepOverRange,
- (lldb::SBAddress &, lldb::addr_t));
- LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
- QueueThreadPlanForStepOverRange,
- (lldb::SBAddress &, lldb::addr_t, lldb::SBError &));
- LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
- QueueThreadPlanForStepInRange,
- (lldb::SBAddress &, lldb::addr_t));
- LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
- QueueThreadPlanForStepInRange,
- (lldb::SBAddress &, lldb::addr_t, lldb::SBError &));
- LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
- QueueThreadPlanForStepOut, (uint32_t, bool));
- LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
- QueueThreadPlanForStepOut,
- (uint32_t, bool, lldb::SBError &));
- LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
- QueueThreadPlanForRunToAddress, (lldb::SBAddress));
- LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
- QueueThreadPlanForRunToAddress,
- (lldb::SBAddress, lldb::SBError &));
- LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
- QueueThreadPlanForStepScripted, (const char *));
- LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
- QueueThreadPlanForStepScripted,
- (const char *, lldb::SBError &));
- }
- {
- LLDB_REGISTER_METHOD(void, SBTrace, StopTrace,
- (lldb::SBError &, lldb::tid_t));
- LLDB_REGISTER_METHOD(void, SBTrace, GetTraceConfig,
- (lldb::SBTraceOptions &, lldb::SBError &));
- LLDB_REGISTER_METHOD(lldb::user_id_t, SBTrace, GetTraceUID, ());
- LLDB_REGISTER_CONSTRUCTOR(SBTrace, ());
- LLDB_REGISTER_METHOD(bool, SBTrace, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBTrace, operator bool, ());
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBTraceOptions, ());
- LLDB_REGISTER_METHOD_CONST(lldb::TraceType, SBTraceOptions, getType, ());
- LLDB_REGISTER_METHOD_CONST(uint64_t, SBTraceOptions, getTraceBufferSize,
- ());
- LLDB_REGISTER_METHOD(lldb::SBStructuredData, SBTraceOptions, getTraceParams,
- (lldb::SBError &));
- LLDB_REGISTER_METHOD_CONST(uint64_t, SBTraceOptions, getMetaDataBufferSize,
- ());
- LLDB_REGISTER_METHOD(void, SBTraceOptions, setTraceParams,
- (lldb::SBStructuredData &));
- LLDB_REGISTER_METHOD(void, SBTraceOptions, setType, (lldb::TraceType));
- LLDB_REGISTER_METHOD(void, SBTraceOptions, setTraceBufferSize, (uint64_t));
- LLDB_REGISTER_METHOD(void, SBTraceOptions, setMetaDataBufferSize,
- (uint64_t));
- LLDB_REGISTER_METHOD(bool, SBTraceOptions, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBTraceOptions, operator bool, ());
- LLDB_REGISTER_METHOD(void, SBTraceOptions, setThreadID, (lldb::tid_t));
- LLDB_REGISTER_METHOD(lldb::tid_t, SBTraceOptions, getThreadID, ());
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBType, ());
- LLDB_REGISTER_CONSTRUCTOR(SBType, (const lldb::SBType &));
- LLDB_REGISTER_METHOD(bool, SBType, operator==,(lldb::SBType &));
- LLDB_REGISTER_METHOD(bool, SBType, operator!=,(lldb::SBType &));
- LLDB_REGISTER_METHOD(lldb::SBType &,
- SBType, operator=,(const lldb::SBType &));
- LLDB_REGISTER_METHOD_CONST(bool, SBType, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBType, operator bool, ());
- LLDB_REGISTER_METHOD(uint64_t, SBType, GetByteSize, ());
- LLDB_REGISTER_METHOD(bool, SBType, IsPointerType, ());
- LLDB_REGISTER_METHOD(bool, SBType, IsArrayType, ());
- LLDB_REGISTER_METHOD(bool, SBType, IsVectorType, ());
- LLDB_REGISTER_METHOD(bool, SBType, IsReferenceType, ());
- LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetPointerType, ());
- LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetPointeeType, ());
- LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetReferenceType, ());
- LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetTypedefedType, ());
- LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetDereferencedType, ());
- LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetArrayElementType, ());
- LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetArrayType, (uint64_t));
- LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetVectorElementType, ());
- LLDB_REGISTER_METHOD(bool, SBType, IsFunctionType, ());
- LLDB_REGISTER_METHOD(bool, SBType, IsPolymorphicClass, ());
- LLDB_REGISTER_METHOD(bool, SBType, IsTypedefType, ());
- LLDB_REGISTER_METHOD(bool, SBType, IsAnonymousType, ());
- LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetFunctionReturnType, ());
- LLDB_REGISTER_METHOD(lldb::SBTypeList, SBType, GetFunctionArgumentTypes,
- ());
- LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfMemberFunctions, ());
- LLDB_REGISTER_METHOD(lldb::SBTypeMemberFunction, SBType,
- GetMemberFunctionAtIndex, (uint32_t));
- LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetUnqualifiedType, ());
- LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetCanonicalType, ());
- LLDB_REGISTER_METHOD(lldb::BasicType, SBType, GetBasicType, ());
- LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetBasicType, (lldb::BasicType));
- LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfDirectBaseClasses, ());
- LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfVirtualBaseClasses, ());
- LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfFields, ());
- LLDB_REGISTER_METHOD(bool, SBType, GetDescription,
- (lldb::SBStream &, lldb::DescriptionLevel));
- LLDB_REGISTER_METHOD(lldb::SBTypeMember, SBType, GetDirectBaseClassAtIndex,
- (uint32_t));
- LLDB_REGISTER_METHOD(lldb::SBTypeMember, SBType, GetVirtualBaseClassAtIndex,
- (uint32_t));
- LLDB_REGISTER_METHOD(lldb::SBTypeEnumMemberList, SBType, GetEnumMembers,
- ());
- LLDB_REGISTER_METHOD(lldb::SBTypeMember, SBType, GetFieldAtIndex,
- (uint32_t));
- LLDB_REGISTER_METHOD(bool, SBType, IsTypeComplete, ());
- LLDB_REGISTER_METHOD(uint32_t, SBType, GetTypeFlags, ());
- LLDB_REGISTER_METHOD(const char *, SBType, GetName, ());
- LLDB_REGISTER_METHOD(const char *, SBType, GetDisplayTypeName, ());
- LLDB_REGISTER_METHOD(lldb::TypeClass, SBType, GetTypeClass, ());
- LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfTemplateArguments, ());
- LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetTemplateArgumentType,
- (uint32_t));
- LLDB_REGISTER_METHOD(lldb::TemplateArgumentKind, SBType,
- GetTemplateArgumentKind, (uint32_t));
- LLDB_REGISTER_CONSTRUCTOR(SBTypeList, ());
- LLDB_REGISTER_CONSTRUCTOR(SBTypeList, (const lldb::SBTypeList &));
- LLDB_REGISTER_METHOD(bool, SBTypeList, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBTypeList, operator bool, ());
- LLDB_REGISTER_METHOD(lldb::SBTypeList &,
- SBTypeList, operator=,(const lldb::SBTypeList &));
- LLDB_REGISTER_METHOD(void, SBTypeList, Append, (lldb::SBType));
- LLDB_REGISTER_METHOD(lldb::SBType, SBTypeList, GetTypeAtIndex, (uint32_t));
- LLDB_REGISTER_METHOD(uint32_t, SBTypeList, GetSize, ());
- LLDB_REGISTER_CONSTRUCTOR(SBTypeMember, ());
- LLDB_REGISTER_CONSTRUCTOR(SBTypeMember, (const lldb::SBTypeMember &));
- LLDB_REGISTER_METHOD(lldb::SBTypeMember &,
- SBTypeMember, operator=,(const lldb::SBTypeMember &));
- LLDB_REGISTER_METHOD_CONST(bool, SBTypeMember, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBTypeMember, operator bool, ());
- LLDB_REGISTER_METHOD(const char *, SBTypeMember, GetName, ());
- LLDB_REGISTER_METHOD(lldb::SBType, SBTypeMember, GetType, ());
- LLDB_REGISTER_METHOD(uint64_t, SBTypeMember, GetOffsetInBytes, ());
- LLDB_REGISTER_METHOD(uint64_t, SBTypeMember, GetOffsetInBits, ());
- LLDB_REGISTER_METHOD(bool, SBTypeMember, IsBitfield, ());
- LLDB_REGISTER_METHOD(uint32_t, SBTypeMember, GetBitfieldSizeInBits, ());
- LLDB_REGISTER_METHOD(bool, SBTypeMember, GetDescription,
- (lldb::SBStream &, lldb::DescriptionLevel));
- LLDB_REGISTER_CONSTRUCTOR(SBTypeMemberFunction, ());
- LLDB_REGISTER_CONSTRUCTOR(SBTypeMemberFunction,
- (const lldb::SBTypeMemberFunction &));
- LLDB_REGISTER_METHOD(
- lldb::SBTypeMemberFunction &,
- SBTypeMemberFunction, operator=,(const lldb::SBTypeMemberFunction &));
- LLDB_REGISTER_METHOD_CONST(bool, SBTypeMemberFunction, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBTypeMemberFunction, operator bool, ());
- LLDB_REGISTER_METHOD(const char *, SBTypeMemberFunction, GetName, ());
- LLDB_REGISTER_METHOD(const char *, SBTypeMemberFunction, GetDemangledName,
- ());
- LLDB_REGISTER_METHOD(const char *, SBTypeMemberFunction, GetMangledName,
- ());
- LLDB_REGISTER_METHOD(lldb::SBType, SBTypeMemberFunction, GetType, ());
- LLDB_REGISTER_METHOD(lldb::SBType, SBTypeMemberFunction, GetReturnType, ());
- LLDB_REGISTER_METHOD(uint32_t, SBTypeMemberFunction, GetNumberOfArguments,
- ());
- LLDB_REGISTER_METHOD(lldb::SBType, SBTypeMemberFunction,
- GetArgumentTypeAtIndex, (uint32_t));
- LLDB_REGISTER_METHOD(lldb::MemberFunctionKind, SBTypeMemberFunction,
- GetKind, ());
- LLDB_REGISTER_METHOD(bool, SBTypeMemberFunction, GetDescription,
- (lldb::SBStream &, lldb::DescriptionLevel));
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBTypeCategory, ());
- LLDB_REGISTER_CONSTRUCTOR(SBTypeCategory, (const lldb::SBTypeCategory &));
- LLDB_REGISTER_METHOD_CONST(bool, SBTypeCategory, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBTypeCategory, operator bool, ());
- LLDB_REGISTER_METHOD(bool, SBTypeCategory, GetEnabled, ());
- LLDB_REGISTER_METHOD(void, SBTypeCategory, SetEnabled, (bool));
- LLDB_REGISTER_METHOD(const char *, SBTypeCategory, GetName, ());
- LLDB_REGISTER_METHOD(lldb::LanguageType, SBTypeCategory, GetLanguageAtIndex,
- (uint32_t));
- LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumLanguages, ());
- LLDB_REGISTER_METHOD(void, SBTypeCategory, AddLanguage,
- (lldb::LanguageType));
- LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumFormats, ());
- LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumSummaries, ());
- LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumFilters, ());
- LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumSynthetics, ());
- LLDB_REGISTER_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
- GetTypeNameSpecifierForSyntheticAtIndex, (uint32_t));
- LLDB_REGISTER_METHOD(lldb::SBTypeSummary, SBTypeCategory, GetSummaryForType,
- (lldb::SBTypeNameSpecifier));
- LLDB_REGISTER_METHOD(lldb::SBTypeSynthetic, SBTypeCategory,
- GetSyntheticForType, (lldb::SBTypeNameSpecifier));
- LLDB_REGISTER_METHOD(lldb::SBTypeFilter, SBTypeCategory, GetFilterAtIndex,
- (uint32_t));
- LLDB_REGISTER_METHOD(lldb::SBTypeSummary, SBTypeCategory, GetSummaryAtIndex,
- (uint32_t));
- LLDB_REGISTER_METHOD(lldb::SBTypeSynthetic, SBTypeCategory,
- GetSyntheticAtIndex, (uint32_t));
- LLDB_REGISTER_METHOD(bool, SBTypeCategory, AddTypeSummary,
- (lldb::SBTypeNameSpecifier, lldb::SBTypeSummary));
- LLDB_REGISTER_METHOD(bool, SBTypeCategory, AddTypeSynthetic,
- (lldb::SBTypeNameSpecifier, lldb::SBTypeSynthetic));
- LLDB_REGISTER_METHOD(bool, SBTypeCategory, DeleteTypeSynthetic,
- (lldb::SBTypeNameSpecifier));
- LLDB_REGISTER_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
- GetTypeNameSpecifierForFilterAtIndex, (uint32_t));
- LLDB_REGISTER_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
- GetTypeNameSpecifierForFormatAtIndex, (uint32_t));
- LLDB_REGISTER_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
- GetTypeNameSpecifierForSummaryAtIndex, (uint32_t));
- LLDB_REGISTER_METHOD(lldb::SBTypeFilter, SBTypeCategory, GetFilterForType,
- (lldb::SBTypeNameSpecifier));
- LLDB_REGISTER_METHOD(lldb::SBTypeFormat, SBTypeCategory, GetFormatForType,
- (lldb::SBTypeNameSpecifier));
- LLDB_REGISTER_METHOD(lldb::SBTypeFormat, SBTypeCategory, GetFormatAtIndex,
- (uint32_t));
- LLDB_REGISTER_METHOD(bool, SBTypeCategory, AddTypeFormat,
- (lldb::SBTypeNameSpecifier, lldb::SBTypeFormat));
- LLDB_REGISTER_METHOD(bool, SBTypeCategory, DeleteTypeFormat,
- (lldb::SBTypeNameSpecifier));
- LLDB_REGISTER_METHOD(bool, SBTypeCategory, DeleteTypeSummary,
- (lldb::SBTypeNameSpecifier));
- LLDB_REGISTER_METHOD(bool, SBTypeCategory, AddTypeFilter,
- (lldb::SBTypeNameSpecifier, lldb::SBTypeFilter));
- LLDB_REGISTER_METHOD(bool, SBTypeCategory, DeleteTypeFilter,
- (lldb::SBTypeNameSpecifier));
- LLDB_REGISTER_METHOD(bool, SBTypeCategory, GetDescription,
- (lldb::SBStream &, lldb::DescriptionLevel));
- LLDB_REGISTER_METHOD(
- lldb::SBTypeCategory &,
- SBTypeCategory, operator=,(const lldb::SBTypeCategory &));
- LLDB_REGISTER_METHOD(bool,
- SBTypeCategory, operator==,(lldb::SBTypeCategory &));
- LLDB_REGISTER_METHOD(bool,
- SBTypeCategory, operator!=,(lldb::SBTypeCategory &));
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBTypeEnumMember, ());
- LLDB_REGISTER_CONSTRUCTOR(SBTypeEnumMember,
- (const lldb::SBTypeEnumMember &));
- LLDB_REGISTER_METHOD(
- lldb::SBTypeEnumMember &,
- SBTypeEnumMember, operator=,(const lldb::SBTypeEnumMember &));
- LLDB_REGISTER_METHOD_CONST(bool, SBTypeEnumMember, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBTypeEnumMember, operator bool, ());
- LLDB_REGISTER_METHOD(const char *, SBTypeEnumMember, GetName, ());
- LLDB_REGISTER_METHOD(int64_t, SBTypeEnumMember, GetValueAsSigned, ());
- LLDB_REGISTER_METHOD(uint64_t, SBTypeEnumMember, GetValueAsUnsigned, ());
- LLDB_REGISTER_METHOD(lldb::SBType, SBTypeEnumMember, GetType, ());
- LLDB_REGISTER_CONSTRUCTOR(SBTypeEnumMemberList, ());
- LLDB_REGISTER_CONSTRUCTOR(SBTypeEnumMemberList,
- (const lldb::SBTypeEnumMemberList &));
- LLDB_REGISTER_METHOD(bool, SBTypeEnumMemberList, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBTypeEnumMemberList, operator bool, ());
- LLDB_REGISTER_METHOD(
- lldb::SBTypeEnumMemberList &,
- SBTypeEnumMemberList, operator=,(const lldb::SBTypeEnumMemberList &));
- LLDB_REGISTER_METHOD(void, SBTypeEnumMemberList, Append,
- (lldb::SBTypeEnumMember));
- LLDB_REGISTER_METHOD(lldb::SBTypeEnumMember, SBTypeEnumMemberList,
- GetTypeEnumMemberAtIndex, (uint32_t));
- LLDB_REGISTER_METHOD(uint32_t, SBTypeEnumMemberList, GetSize, ());
- LLDB_REGISTER_METHOD(bool, SBTypeEnumMember, GetDescription,
- (lldb::SBStream &, lldb::DescriptionLevel));
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBTypeFilter, ());
- LLDB_REGISTER_CONSTRUCTOR(SBTypeFilter, (uint32_t));
- LLDB_REGISTER_CONSTRUCTOR(SBTypeFilter, (const lldb::SBTypeFilter &));
- LLDB_REGISTER_METHOD_CONST(bool, SBTypeFilter, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBTypeFilter, operator bool, ());
- LLDB_REGISTER_METHOD(uint32_t, SBTypeFilter, GetOptions, ());
- LLDB_REGISTER_METHOD(void, SBTypeFilter, SetOptions, (uint32_t));
- LLDB_REGISTER_METHOD(bool, SBTypeFilter, GetDescription,
- (lldb::SBStream &, lldb::DescriptionLevel));
- LLDB_REGISTER_METHOD(void, SBTypeFilter, Clear, ());
- LLDB_REGISTER_METHOD(uint32_t, SBTypeFilter, GetNumberOfExpressionPaths,
- ());
- LLDB_REGISTER_METHOD(const char *, SBTypeFilter, GetExpressionPathAtIndex,
- (uint32_t));
- LLDB_REGISTER_METHOD(bool, SBTypeFilter, ReplaceExpressionPathAtIndex,
- (uint32_t, const char *));
- LLDB_REGISTER_METHOD(void, SBTypeFilter, AppendExpressionPath,
- (const char *));
- LLDB_REGISTER_METHOD(lldb::SBTypeFilter &,
- SBTypeFilter, operator=,(const lldb::SBTypeFilter &));
- LLDB_REGISTER_METHOD(bool, SBTypeFilter, operator==,(lldb::SBTypeFilter &));
- LLDB_REGISTER_METHOD(bool, SBTypeFilter, IsEqualTo, (lldb::SBTypeFilter &));
- LLDB_REGISTER_METHOD(bool, SBTypeFilter, operator!=,(lldb::SBTypeFilter &));
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBTypeFormat, ());
- LLDB_REGISTER_CONSTRUCTOR(SBTypeFormat, (lldb::Format, uint32_t));
- LLDB_REGISTER_CONSTRUCTOR(SBTypeFormat, (const char *, uint32_t));
- LLDB_REGISTER_CONSTRUCTOR(SBTypeFormat, (const lldb::SBTypeFormat &));
- LLDB_REGISTER_METHOD_CONST(bool, SBTypeFormat, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBTypeFormat, operator bool, ());
- LLDB_REGISTER_METHOD(lldb::Format, SBTypeFormat, GetFormat, ());
- LLDB_REGISTER_METHOD(const char *, SBTypeFormat, GetTypeName, ());
- LLDB_REGISTER_METHOD(uint32_t, SBTypeFormat, GetOptions, ());
- LLDB_REGISTER_METHOD(void, SBTypeFormat, SetFormat, (lldb::Format));
- LLDB_REGISTER_METHOD(void, SBTypeFormat, SetTypeName, (const char *));
- LLDB_REGISTER_METHOD(void, SBTypeFormat, SetOptions, (uint32_t));
- LLDB_REGISTER_METHOD(bool, SBTypeFormat, GetDescription,
- (lldb::SBStream &, lldb::DescriptionLevel));
- LLDB_REGISTER_METHOD(lldb::SBTypeFormat &,
- SBTypeFormat, operator=,(const lldb::SBTypeFormat &));
- LLDB_REGISTER_METHOD(bool, SBTypeFormat, operator==,(lldb::SBTypeFormat &));
- LLDB_REGISTER_METHOD(bool, SBTypeFormat, IsEqualTo, (lldb::SBTypeFormat &));
- LLDB_REGISTER_METHOD(bool, SBTypeFormat, operator!=,(lldb::SBTypeFormat &));
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBTypeNameSpecifier, ());
- LLDB_REGISTER_CONSTRUCTOR(SBTypeNameSpecifier, (const char *, bool));
- LLDB_REGISTER_CONSTRUCTOR(SBTypeNameSpecifier, (lldb::SBType));
- LLDB_REGISTER_CONSTRUCTOR(SBTypeNameSpecifier,
- (const lldb::SBTypeNameSpecifier &));
- LLDB_REGISTER_METHOD_CONST(bool, SBTypeNameSpecifier, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBTypeNameSpecifier, operator bool, ());
- LLDB_REGISTER_METHOD(const char *, SBTypeNameSpecifier, GetName, ());
- LLDB_REGISTER_METHOD(lldb::SBType, SBTypeNameSpecifier, GetType, ());
- LLDB_REGISTER_METHOD(bool, SBTypeNameSpecifier, IsRegex, ());
- LLDB_REGISTER_METHOD(bool, SBTypeNameSpecifier, GetDescription,
- (lldb::SBStream &, lldb::DescriptionLevel));
- LLDB_REGISTER_METHOD(
- lldb::SBTypeNameSpecifier &,
- SBTypeNameSpecifier, operator=,(const lldb::SBTypeNameSpecifier &));
- LLDB_REGISTER_METHOD(
- bool, SBTypeNameSpecifier, operator==,(lldb::SBTypeNameSpecifier &));
- LLDB_REGISTER_METHOD(bool, SBTypeNameSpecifier, IsEqualTo,
- (lldb::SBTypeNameSpecifier &));
- LLDB_REGISTER_METHOD(
- bool, SBTypeNameSpecifier, operator!=,(lldb::SBTypeNameSpecifier &));
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBTypeSummaryOptions, ());
- LLDB_REGISTER_CONSTRUCTOR(SBTypeSummaryOptions,
- (const lldb::SBTypeSummaryOptions &));
- LLDB_REGISTER_METHOD(bool, SBTypeSummaryOptions, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBTypeSummaryOptions, operator bool, ());
- LLDB_REGISTER_METHOD(lldb::LanguageType, SBTypeSummaryOptions, GetLanguage,
- ());
- LLDB_REGISTER_METHOD(lldb::TypeSummaryCapping, SBTypeSummaryOptions,
- GetCapping, ());
- LLDB_REGISTER_METHOD(void, SBTypeSummaryOptions, SetLanguage,
- (lldb::LanguageType));
- LLDB_REGISTER_METHOD(void, SBTypeSummaryOptions, SetCapping,
- (lldb::TypeSummaryCapping));
- LLDB_REGISTER_CONSTRUCTOR(SBTypeSummaryOptions,
- (const lldb_private::TypeSummaryOptions *));
- LLDB_REGISTER_CONSTRUCTOR(SBTypeSummary, ());
- LLDB_REGISTER_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary,
- CreateWithSummaryString,
- (const char *, uint32_t));
- LLDB_REGISTER_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary,
- CreateWithFunctionName,
- (const char *, uint32_t));
- LLDB_REGISTER_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary,
- CreateWithScriptCode, (const char *, uint32_t));
- LLDB_REGISTER_CONSTRUCTOR(SBTypeSummary, (const lldb::SBTypeSummary &));
- LLDB_REGISTER_METHOD_CONST(bool, SBTypeSummary, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBTypeSummary, operator bool, ());
- LLDB_REGISTER_METHOD(bool, SBTypeSummary, IsFunctionCode, ());
- LLDB_REGISTER_METHOD(bool, SBTypeSummary, IsFunctionName, ());
- LLDB_REGISTER_METHOD(bool, SBTypeSummary, IsSummaryString, ());
- LLDB_REGISTER_METHOD(const char *, SBTypeSummary, GetData, ());
- LLDB_REGISTER_METHOD(uint32_t, SBTypeSummary, GetOptions, ());
- LLDB_REGISTER_METHOD(void, SBTypeSummary, SetOptions, (uint32_t));
- LLDB_REGISTER_METHOD(void, SBTypeSummary, SetSummaryString, (const char *));
- LLDB_REGISTER_METHOD(void, SBTypeSummary, SetFunctionName, (const char *));
- LLDB_REGISTER_METHOD(void, SBTypeSummary, SetFunctionCode, (const char *));
- LLDB_REGISTER_METHOD(bool, SBTypeSummary, GetDescription,
- (lldb::SBStream &, lldb::DescriptionLevel));
- LLDB_REGISTER_METHOD(bool, SBTypeSummary, DoesPrintValue, (lldb::SBValue));
- LLDB_REGISTER_METHOD(
- lldb::SBTypeSummary &,
- SBTypeSummary, operator=,(const lldb::SBTypeSummary &));
- LLDB_REGISTER_METHOD(bool,
- SBTypeSummary, operator==,(lldb::SBTypeSummary &));
- LLDB_REGISTER_METHOD(bool, SBTypeSummary, IsEqualTo,
- (lldb::SBTypeSummary &));
- LLDB_REGISTER_METHOD(bool,
- SBTypeSummary, operator!=,(lldb::SBTypeSummary &));
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBTypeSynthetic, ());
- LLDB_REGISTER_STATIC_METHOD(lldb::SBTypeSynthetic, SBTypeSynthetic,
- CreateWithClassName, (const char *, uint32_t));
- LLDB_REGISTER_STATIC_METHOD(lldb::SBTypeSynthetic, SBTypeSynthetic,
- CreateWithScriptCode, (const char *, uint32_t));
- LLDB_REGISTER_CONSTRUCTOR(SBTypeSynthetic, (const lldb::SBTypeSynthetic &));
- LLDB_REGISTER_METHOD_CONST(bool, SBTypeSynthetic, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBTypeSynthetic, operator bool, ());
- LLDB_REGISTER_METHOD(bool, SBTypeSynthetic, IsClassCode, ());
- LLDB_REGISTER_METHOD(bool, SBTypeSynthetic, IsClassName, ());
- LLDB_REGISTER_METHOD(const char *, SBTypeSynthetic, GetData, ());
- LLDB_REGISTER_METHOD(void, SBTypeSynthetic, SetClassName, (const char *));
- LLDB_REGISTER_METHOD(void, SBTypeSynthetic, SetClassCode, (const char *));
- LLDB_REGISTER_METHOD(uint32_t, SBTypeSynthetic, GetOptions, ());
- LLDB_REGISTER_METHOD(void, SBTypeSynthetic, SetOptions, (uint32_t));
- LLDB_REGISTER_METHOD(bool, SBTypeSynthetic, GetDescription,
- (lldb::SBStream &, lldb::DescriptionLevel));
- LLDB_REGISTER_METHOD(
- lldb::SBTypeSynthetic &,
- SBTypeSynthetic, operator=,(const lldb::SBTypeSynthetic &));
- LLDB_REGISTER_METHOD(bool,
- SBTypeSynthetic, operator==,(lldb::SBTypeSynthetic &));
- LLDB_REGISTER_METHOD(bool, SBTypeSynthetic, IsEqualTo,
- (lldb::SBTypeSynthetic &));
- LLDB_REGISTER_METHOD(bool,
- SBTypeSynthetic, operator!=,(lldb::SBTypeSynthetic &));
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBUnixSignals, ());
- LLDB_REGISTER_CONSTRUCTOR(SBUnixSignals, (const lldb::SBUnixSignals &));
- LLDB_REGISTER_METHOD(
- const lldb::SBUnixSignals &,
- SBUnixSignals, operator=,(const lldb::SBUnixSignals &));
- LLDB_REGISTER_METHOD(void, SBUnixSignals, Clear, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBUnixSignals, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBUnixSignals, operator bool, ());
- LLDB_REGISTER_METHOD_CONST(const char *, SBUnixSignals, GetSignalAsCString,
- (int32_t));
- LLDB_REGISTER_METHOD_CONST(int32_t, SBUnixSignals, GetSignalNumberFromName,
- (const char *));
- LLDB_REGISTER_METHOD_CONST(bool, SBUnixSignals, GetShouldSuppress,
- (int32_t));
- LLDB_REGISTER_METHOD(bool, SBUnixSignals, SetShouldSuppress,
- (int32_t, bool));
- LLDB_REGISTER_METHOD_CONST(bool, SBUnixSignals, GetShouldStop, (int32_t));
- LLDB_REGISTER_METHOD(bool, SBUnixSignals, SetShouldStop, (int32_t, bool));
- LLDB_REGISTER_METHOD_CONST(bool, SBUnixSignals, GetShouldNotify, (int32_t));
- LLDB_REGISTER_METHOD(bool, SBUnixSignals, SetShouldNotify, (int32_t, bool));
- LLDB_REGISTER_METHOD_CONST(int32_t, SBUnixSignals, GetNumSignals, ());
- LLDB_REGISTER_METHOD_CONST(int32_t, SBUnixSignals, GetSignalAtIndex,
- (int32_t));
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBValue, ());
- LLDB_REGISTER_CONSTRUCTOR(SBValue, (const lldb::ValueObjectSP &));
- LLDB_REGISTER_CONSTRUCTOR(SBValue, (const lldb::SBValue &));
- LLDB_REGISTER_METHOD(lldb::SBValue &,
- SBValue, operator=,(const lldb::SBValue &));
- LLDB_REGISTER_METHOD(bool, SBValue, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBValue, operator bool, ());
- LLDB_REGISTER_METHOD(void, SBValue, Clear, ());
- LLDB_REGISTER_METHOD(lldb::SBError, SBValue, GetError, ());
- LLDB_REGISTER_METHOD(lldb::user_id_t, SBValue, GetID, ());
- LLDB_REGISTER_METHOD(const char *, SBValue, GetName, ());
- LLDB_REGISTER_METHOD(const char *, SBValue, GetTypeName, ());
- LLDB_REGISTER_METHOD(const char *, SBValue, GetDisplayTypeName, ());
- LLDB_REGISTER_METHOD(size_t, SBValue, GetByteSize, ());
- LLDB_REGISTER_METHOD(bool, SBValue, IsInScope, ());
- LLDB_REGISTER_METHOD(const char *, SBValue, GetValue, ());
- LLDB_REGISTER_METHOD(lldb::ValueType, SBValue, GetValueType, ());
- LLDB_REGISTER_METHOD(const char *, SBValue, GetObjectDescription, ());
- LLDB_REGISTER_METHOD(const char *, SBValue, GetTypeValidatorResult, ());
- LLDB_REGISTER_METHOD(lldb::SBType, SBValue, GetType, ());
- LLDB_REGISTER_METHOD(bool, SBValue, GetValueDidChange, ());
- LLDB_REGISTER_METHOD(const char *, SBValue, GetSummary, ());
- LLDB_REGISTER_METHOD(const char *, SBValue, GetSummary,
- (lldb::SBStream &, lldb::SBTypeSummaryOptions &));
- LLDB_REGISTER_METHOD(const char *, SBValue, GetLocation, ());
- LLDB_REGISTER_METHOD(bool, SBValue, SetValueFromCString, (const char *));
- LLDB_REGISTER_METHOD(bool, SBValue, SetValueFromCString,
- (const char *, lldb::SBError &));
- LLDB_REGISTER_METHOD(lldb::SBTypeFormat, SBValue, GetTypeFormat, ());
- LLDB_REGISTER_METHOD(lldb::SBTypeSummary, SBValue, GetTypeSummary, ());
- LLDB_REGISTER_METHOD(lldb::SBTypeFilter, SBValue, GetTypeFilter, ());
- LLDB_REGISTER_METHOD(lldb::SBTypeSynthetic, SBValue, GetTypeSynthetic, ());
- LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, CreateChildAtOffset,
- (const char *, uint32_t, lldb::SBType));
- LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, Cast, (lldb::SBType));
- LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, CreateValueFromExpression,
- (const char *, const char *));
- LLDB_REGISTER_METHOD(
- lldb::SBValue, SBValue, CreateValueFromExpression,
- (const char *, const char *, lldb::SBExpressionOptions &));
- LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, CreateValueFromAddress,
- (const char *, lldb::addr_t, lldb::SBType));
- LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, CreateValueFromData,
- (const char *, lldb::SBData, lldb::SBType));
- LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetChildAtIndex, (uint32_t));
- LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetChildAtIndex,
- (uint32_t, lldb::DynamicValueType, bool));
- LLDB_REGISTER_METHOD(uint32_t, SBValue, GetIndexOfChildWithName,
- (const char *));
- LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetChildMemberWithName,
- (const char *));
- LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetChildMemberWithName,
- (const char *, lldb::DynamicValueType));
- LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetDynamicValue,
- (lldb::DynamicValueType));
- LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetStaticValue, ());
- LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetNonSyntheticValue, ());
- LLDB_REGISTER_METHOD(lldb::DynamicValueType, SBValue, GetPreferDynamicValue,
- ());
- LLDB_REGISTER_METHOD(void, SBValue, SetPreferDynamicValue,
- (lldb::DynamicValueType));
- LLDB_REGISTER_METHOD(bool, SBValue, GetPreferSyntheticValue, ());
- LLDB_REGISTER_METHOD(void, SBValue, SetPreferSyntheticValue, (bool));
- LLDB_REGISTER_METHOD(bool, SBValue, IsDynamic, ());
- LLDB_REGISTER_METHOD(bool, SBValue, IsSynthetic, ());
- LLDB_REGISTER_METHOD(bool, SBValue, IsSyntheticChildrenGenerated, ());
- LLDB_REGISTER_METHOD(void, SBValue, SetSyntheticChildrenGenerated, (bool));
- LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetValueForExpressionPath,
- (const char *));
- LLDB_REGISTER_METHOD(int64_t, SBValue, GetValueAsSigned,
- (lldb::SBError &, int64_t));
- LLDB_REGISTER_METHOD(uint64_t, SBValue, GetValueAsUnsigned,
- (lldb::SBError &, uint64_t));
- LLDB_REGISTER_METHOD(int64_t, SBValue, GetValueAsSigned, (int64_t));
- LLDB_REGISTER_METHOD(uint64_t, SBValue, GetValueAsUnsigned, (uint64_t));
- LLDB_REGISTER_METHOD(bool, SBValue, MightHaveChildren, ());
- LLDB_REGISTER_METHOD(bool, SBValue, IsRuntimeSupportValue, ());
- LLDB_REGISTER_METHOD(uint32_t, SBValue, GetNumChildren, ());
- LLDB_REGISTER_METHOD(uint32_t, SBValue, GetNumChildren, (uint32_t));
- LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, Dereference, ());
- LLDB_REGISTER_METHOD(bool, SBValue, TypeIsPointerType, ());
- LLDB_REGISTER_METHOD(void *, SBValue, GetOpaqueType, ());
- LLDB_REGISTER_METHOD(lldb::SBTarget, SBValue, GetTarget, ());
- LLDB_REGISTER_METHOD(lldb::SBProcess, SBValue, GetProcess, ());
- LLDB_REGISTER_METHOD(lldb::SBThread, SBValue, GetThread, ());
- LLDB_REGISTER_METHOD(lldb::SBFrame, SBValue, GetFrame, ());
- LLDB_REGISTER_METHOD_CONST(lldb::ValueObjectSP, SBValue, GetSP, ());
- LLDB_REGISTER_METHOD(bool, SBValue, GetExpressionPath, (lldb::SBStream &));
- LLDB_REGISTER_METHOD(bool, SBValue, GetExpressionPath,
- (lldb::SBStream &, bool));
- LLDB_REGISTER_METHOD_CONST(lldb::SBValue, SBValue, EvaluateExpression,
- (const char *));
- LLDB_REGISTER_METHOD_CONST(
- lldb::SBValue, SBValue, EvaluateExpression,
- (const char *, const lldb::SBExpressionOptions &));
- LLDB_REGISTER_METHOD_CONST(
- lldb::SBValue, SBValue, EvaluateExpression,
- (const char *, const lldb::SBExpressionOptions &, const char *));
- LLDB_REGISTER_METHOD(bool, SBValue, GetDescription, (lldb::SBStream &));
- LLDB_REGISTER_METHOD(lldb::Format, SBValue, GetFormat, ());
- LLDB_REGISTER_METHOD(void, SBValue, SetFormat, (lldb::Format));
- LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, AddressOf, ());
- LLDB_REGISTER_METHOD(lldb::addr_t, SBValue, GetLoadAddress, ());
- LLDB_REGISTER_METHOD(lldb::SBAddress, SBValue, GetAddress, ());
- LLDB_REGISTER_METHOD(lldb::SBData, SBValue, GetPointeeData,
- (uint32_t, uint32_t));
- LLDB_REGISTER_METHOD(lldb::SBData, SBValue, GetData, ());
- LLDB_REGISTER_METHOD(bool, SBValue, SetData,
- (lldb::SBData &, lldb::SBError &));
- LLDB_REGISTER_METHOD(lldb::SBDeclaration, SBValue, GetDeclaration, ());
- LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBValue, Watch,
- (bool, bool, bool, lldb::SBError &));
- LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBValue, Watch,
- (bool, bool, bool));
- LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBValue, WatchPointee,
- (bool, bool, bool, lldb::SBError &));
- LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, Persist, ());
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBValueList, ());
- LLDB_REGISTER_CONSTRUCTOR(SBValueList, (const lldb::SBValueList &));
- LLDB_REGISTER_METHOD_CONST(bool, SBValueList, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBValueList, operator bool, ());
- LLDB_REGISTER_METHOD(void, SBValueList, Clear, ());
- LLDB_REGISTER_METHOD(const lldb::SBValueList &,
- SBValueList, operator=,(const lldb::SBValueList &));
- LLDB_REGISTER_METHOD(void, SBValueList, Append, (const lldb::SBValue &));
- LLDB_REGISTER_METHOD(void, SBValueList, Append,
- (const lldb::SBValueList &));
- LLDB_REGISTER_METHOD_CONST(lldb::SBValue, SBValueList, GetValueAtIndex,
- (uint32_t));
- LLDB_REGISTER_METHOD_CONST(uint32_t, SBValueList, GetSize, ());
- LLDB_REGISTER_METHOD(lldb::SBValue, SBValueList, FindValueObjectByUID,
- (lldb::user_id_t));
- LLDB_REGISTER_METHOD_CONST(lldb::SBValue, SBValueList, GetFirstValueByName,
- (const char *));
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBVariablesOptions, ());
- LLDB_REGISTER_CONSTRUCTOR(SBVariablesOptions,
- (const lldb::SBVariablesOptions &));
- LLDB_REGISTER_METHOD(
- lldb::SBVariablesOptions &,
- SBVariablesOptions, operator=,(const lldb::SBVariablesOptions &));
- LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, operator bool, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, GetIncludeArguments,
- ());
- LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetIncludeArguments, (bool));
- LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions,
- GetIncludeRecognizedArguments,
- (const lldb::SBTarget &));
- LLDB_REGISTER_METHOD(void, SBVariablesOptions,
- SetIncludeRecognizedArguments, (bool));
- LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, GetIncludeLocals, ());
- LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetIncludeLocals, (bool));
- LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, GetIncludeStatics, ());
- LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetIncludeStatics, (bool));
- LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, GetInScopeOnly, ());
- LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetInScopeOnly, (bool));
- LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions,
- GetIncludeRuntimeSupportValues, ());
- LLDB_REGISTER_METHOD(void, SBVariablesOptions,
- SetIncludeRuntimeSupportValues, (bool));
- LLDB_REGISTER_METHOD_CONST(lldb::DynamicValueType, SBVariablesOptions,
- GetUseDynamic, ());
- LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetUseDynamic,
- (lldb::DynamicValueType));
- }
- {
- LLDB_REGISTER_CONSTRUCTOR(SBWatchpoint, ());
- LLDB_REGISTER_CONSTRUCTOR(SBWatchpoint, (const lldb::WatchpointSP &));
- LLDB_REGISTER_CONSTRUCTOR(SBWatchpoint, (const lldb::SBWatchpoint &));
- LLDB_REGISTER_METHOD(const lldb::SBWatchpoint &,
- SBWatchpoint, operator=,(const lldb::SBWatchpoint &));
- LLDB_REGISTER_METHOD(lldb::watch_id_t, SBWatchpoint, GetID, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBWatchpoint, IsValid, ());
- LLDB_REGISTER_METHOD_CONST(bool, SBWatchpoint, operator bool, ());
- LLDB_REGISTER_METHOD(lldb::SBError, SBWatchpoint, GetError, ());
- LLDB_REGISTER_METHOD(int32_t, SBWatchpoint, GetHardwareIndex, ());
- LLDB_REGISTER_METHOD(lldb::addr_t, SBWatchpoint, GetWatchAddress, ());
- LLDB_REGISTER_METHOD(size_t, SBWatchpoint, GetWatchSize, ());
- LLDB_REGISTER_METHOD(void, SBWatchpoint, SetEnabled, (bool));
- LLDB_REGISTER_METHOD(bool, SBWatchpoint, IsEnabled, ());
- LLDB_REGISTER_METHOD(uint32_t, SBWatchpoint, GetHitCount, ());
- LLDB_REGISTER_METHOD(uint32_t, SBWatchpoint, GetIgnoreCount, ());
- LLDB_REGISTER_METHOD(void, SBWatchpoint, SetIgnoreCount, (uint32_t));
- LLDB_REGISTER_METHOD(const char *, SBWatchpoint, GetCondition, ());
- LLDB_REGISTER_METHOD(void, SBWatchpoint, SetCondition, (const char *));
- LLDB_REGISTER_METHOD(bool, SBWatchpoint, GetDescription,
- (lldb::SBStream &, lldb::DescriptionLevel));
- LLDB_REGISTER_METHOD(void, SBWatchpoint, Clear, ());
- LLDB_REGISTER_METHOD_CONST(lldb::WatchpointSP, SBWatchpoint, GetSP, ());
- LLDB_REGISTER_METHOD(void, SBWatchpoint, SetSP,
- (const lldb::WatchpointSP &));
- LLDB_REGISTER_STATIC_METHOD(bool, SBWatchpoint, EventIsWatchpointEvent,
- (const lldb::SBEvent &));
- LLDB_REGISTER_STATIC_METHOD(lldb::WatchpointEventType, SBWatchpoint,
- GetWatchpointEventTypeFromEvent,
- (const lldb::SBEvent &));
- LLDB_REGISTER_STATIC_METHOD(lldb::SBWatchpoint, SBWatchpoint,
- GetWatchpointFromEvent,
- (const lldb::SBEvent &));
- }
+ RegisterMethods<SBAddress>(R);
+ RegisterMethods<SBAttachInfo>(R);
+ RegisterMethods<SBBlock>(R);
+ RegisterMethods<SBBreakpoint>(R);
+ RegisterMethods<SBBreakpointList>(R);
+ RegisterMethods<SBBreakpointLocation>(R);
+ RegisterMethods<SBBreakpointName>(R);
+ RegisterMethods<SBBroadcaster>(R);
+ RegisterMethods<SBCommandInterpreterRunOptions>(R);
+ RegisterMethods<SBCommandReturnObject>(R);
+ RegisterMethods<SBCommunication>(R);
+ RegisterMethods<SBCompileUnit>(R);
+ RegisterMethods<SBData>(R);
+ RegisterMethods<SBInputReader>(R);
+ RegisterMethods<SBDebugger>(R);
+ RegisterMethods<SBDeclaration>(R);
+ RegisterMethods<SBError>(R);
+ RegisterMethods<SBEvent>(R);
+ RegisterMethods<SBExecutionContext>(R);
+ RegisterMethods<SBExpressionOptions>(R);
+ RegisterMethods<SBFileSpec>(R);
+ RegisterMethods<SBFileSpecList>(R);
+ RegisterMethods<SBFrame>(R);
+ RegisterMethods<SBFunction>(R);
+ RegisterMethods<SBHostOS>(R);
+ RegisterMethods<SBInstruction>(R);
+ RegisterMethods<SBInstructionList>(R);
+ RegisterMethods<SBLanguageRuntime>(R);
+ RegisterMethods<SBLaunchInfo>(R);
+ RegisterMethods<SBLineEntry>(R);
+ RegisterMethods<SBListener>(R);
+ RegisterMethods<SBMemoryRegionInfo>(R);
+ RegisterMethods<SBMemoryRegionInfoList>(R);
+ RegisterMethods<SBModule>(R);
+ RegisterMethods<SBModuleSpec>(R);
+ RegisterMethods<SBPlatformConnectOptions>(R);
+ RegisterMethods<SBPlatformShellCommand>(R);
+ RegisterMethods<SBPlatform>(R);
+ RegisterMethods<SBProcess>(R);
+ RegisterMethods<SBProcessInfo>(R);
+ RegisterMethods<SBQueue>(R);
+ RegisterMethods<SBQueueItem>(R);
+ RegisterMethods<SBSection>(R);
+ RegisterMethods<SBSourceManager>(R);
+ RegisterMethods<SBStream>(R);
+ RegisterMethods<SBStringList>(R);
+ RegisterMethods<SBStructuredData>(R);
+ RegisterMethods<SBSymbol>(R);
+ RegisterMethods<SBSymbolContext>(R);
+ RegisterMethods<SBSymbolContextList>(R);
+ RegisterMethods<SBTarget>(R);
+ RegisterMethods<SBThread>(R);
+ RegisterMethods<SBThreadCollection>(R);
+ RegisterMethods<SBThreadPlan>(R);
+ RegisterMethods<SBTrace>(R);
+ RegisterMethods<SBTraceOptions>(R);
+ RegisterMethods<SBType>(R);
+ RegisterMethods<SBTypeCategory>(R);
+ RegisterMethods<SBTypeEnumMember>(R);
+ RegisterMethods<SBTypeFilter>(R);
+ RegisterMethods<SBTypeFormat>(R);
+ RegisterMethods<SBTypeNameSpecifier>(R);
+ RegisterMethods<SBTypeSummaryOptions>(R);
+ RegisterMethods<SBTypeSummary>(R);
+ RegisterMethods<SBTypeSynthetic>(R);
+ RegisterMethods<SBUnixSignals>(R);
+ RegisterMethods<SBValue>(R);
+ RegisterMethods<SBValueList>(R);
+ RegisterMethods<SBVariablesOptions>(R);
+ RegisterMethods<SBWatchpoint>(R);
}
const char *SBReproducer::Capture() {
Modified: lldb/trunk/source/API/SBReproducerPrivate.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBReproducerPrivate.h?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBReproducerPrivate.h (original)
+++ lldb/trunk/source/API/SBReproducerPrivate.h Tue Mar 19 10:13:13 2019
@@ -69,6 +69,8 @@ inline InstrumentationData GetInstrument
return {};
}
+template <typename T> void RegisterMethods(Registry &R);
+
} // namespace repro
} // namespace lldb_private
Modified: lldb/trunk/source/API/SBSection.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBSection.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBSection.cpp (original)
+++ lldb/trunk/source/API/SBSection.cpp Tue Mar 19 10:13:13 2019
@@ -288,3 +288,41 @@ bool SBSection::GetDescription(SBStream
return true;
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBSection>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBSection, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBSection, (const lldb::SBSection &));
+ LLDB_REGISTER_METHOD(const lldb::SBSection &,
+ SBSection, operator=,(const lldb::SBSection &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBSection, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBSection, operator bool, ());
+ LLDB_REGISTER_METHOD(const char *, SBSection, GetName, ());
+ LLDB_REGISTER_METHOD(lldb::SBSection, SBSection, GetParent, ());
+ LLDB_REGISTER_METHOD(lldb::SBSection, SBSection, FindSubSection,
+ (const char *));
+ LLDB_REGISTER_METHOD(size_t, SBSection, GetNumSubSections, ());
+ LLDB_REGISTER_METHOD(lldb::SBSection, SBSection, GetSubSectionAtIndex,
+ (size_t));
+ LLDB_REGISTER_METHOD(lldb::addr_t, SBSection, GetFileAddress, ());
+ LLDB_REGISTER_METHOD(lldb::addr_t, SBSection, GetLoadAddress,
+ (lldb::SBTarget &));
+ LLDB_REGISTER_METHOD(lldb::addr_t, SBSection, GetByteSize, ());
+ LLDB_REGISTER_METHOD(uint64_t, SBSection, GetFileOffset, ());
+ LLDB_REGISTER_METHOD(uint64_t, SBSection, GetFileByteSize, ());
+ LLDB_REGISTER_METHOD(lldb::SBData, SBSection, GetSectionData, ());
+ LLDB_REGISTER_METHOD(lldb::SBData, SBSection, GetSectionData,
+ (uint64_t, uint64_t));
+ LLDB_REGISTER_METHOD(lldb::SectionType, SBSection, GetSectionType, ());
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBSection, GetPermissions, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBSection, GetTargetByteSize, ());
+ LLDB_REGISTER_METHOD(bool, SBSection, operator==,(const lldb::SBSection &));
+ LLDB_REGISTER_METHOD(bool, SBSection, operator!=,(const lldb::SBSection &));
+ LLDB_REGISTER_METHOD(bool, SBSection, GetDescription, (lldb::SBStream &));
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBSourceManager.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBSourceManager.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBSourceManager.cpp (original)
+++ lldb/trunk/source/API/SBSourceManager.cpp Tue Mar 19 10:13:13 2019
@@ -138,3 +138,27 @@ size_t SBSourceManager::DisplaySourceLin
file.ref(), line, column, context_before, context_after,
current_line_cstr, s.get());
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBSourceManager>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBSourceManager, (const lldb::SBDebugger &));
+ LLDB_REGISTER_CONSTRUCTOR(SBSourceManager, (const lldb::SBTarget &));
+ LLDB_REGISTER_CONSTRUCTOR(SBSourceManager, (const lldb::SBSourceManager &));
+ LLDB_REGISTER_METHOD(
+ const lldb::SBSourceManager &,
+ SBSourceManager, operator=,(const lldb::SBSourceManager &));
+ LLDB_REGISTER_METHOD(size_t, SBSourceManager,
+ DisplaySourceLinesWithLineNumbers,
+ (const lldb::SBFileSpec &, uint32_t, uint32_t,
+ uint32_t, const char *, lldb::SBStream &));
+ LLDB_REGISTER_METHOD(size_t, SBSourceManager,
+ DisplaySourceLinesWithLineNumbersAndColumn,
+ (const lldb::SBFileSpec &, uint32_t, uint32_t,
+ uint32_t, uint32_t, const char *, lldb::SBStream &));
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBStream.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBStream.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBStream.cpp (original)
+++ lldb/trunk/source/API/SBStream.cpp Tue Mar 19 10:13:13 2019
@@ -177,3 +177,22 @@ void SBStream::Clear() {
static_cast<StreamString *>(m_opaque_up.get())->Clear();
}
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBStream>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBStream, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBStream, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBStream, operator bool, ());
+ LLDB_REGISTER_METHOD(const char *, SBStream, GetData, ());
+ LLDB_REGISTER_METHOD(size_t, SBStream, GetSize, ());
+ LLDB_REGISTER_METHOD(void, SBStream, RedirectToFile, (const char *, bool));
+ LLDB_REGISTER_METHOD(void, SBStream, RedirectToFileHandle, (FILE *, bool));
+ LLDB_REGISTER_METHOD(void, SBStream, RedirectToFileDescriptor, (int, bool));
+ LLDB_REGISTER_METHOD(void, SBStream, Clear, ());
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBStringList.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBStringList.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBStringList.cpp (original)
+++ lldb/trunk/source/API/SBStringList.cpp Tue Mar 19 10:13:13 2019
@@ -135,3 +135,29 @@ void SBStringList::Clear() {
m_opaque_up->Clear();
}
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBStringList>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBStringList, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBStringList, (const lldb::SBStringList &));
+ LLDB_REGISTER_METHOD(const lldb::SBStringList &,
+ SBStringList, operator=,(const lldb::SBStringList &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBStringList, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBStringList, operator bool, ());
+ LLDB_REGISTER_METHOD(void, SBStringList, AppendString, (const char *));
+ LLDB_REGISTER_METHOD(void, SBStringList, AppendList, (const char **, int));
+ LLDB_REGISTER_METHOD(void, SBStringList, AppendList,
+ (const lldb::SBStringList &));
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBStringList, GetSize, ());
+ LLDB_REGISTER_METHOD(const char *, SBStringList, GetStringAtIndex,
+ (size_t));
+ LLDB_REGISTER_METHOD_CONST(const char *, SBStringList, GetStringAtIndex,
+ (size_t));
+ LLDB_REGISTER_METHOD(void, SBStringList, Clear, ());
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBStructuredData.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBStructuredData.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBStructuredData.cpp (original)
+++ lldb/trunk/source/API/SBStructuredData.cpp Tue Mar 19 10:13:13 2019
@@ -201,3 +201,47 @@ size_t SBStructuredData::GetStringValue(
return (m_impl_up ? m_impl_up->GetStringValue(dst, dst_len) : 0);
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBStructuredData>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBStructuredData, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBStructuredData,
+ (const lldb::SBStructuredData &));
+ LLDB_REGISTER_CONSTRUCTOR(SBStructuredData, (const lldb::EventSP &));
+ LLDB_REGISTER_CONSTRUCTOR(SBStructuredData,
+ (lldb_private::StructuredDataImpl *));
+ LLDB_REGISTER_METHOD(
+ lldb::SBStructuredData &,
+ SBStructuredData, operator=,(const lldb::SBStructuredData &));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBStructuredData, SetFromJSON,
+ (lldb::SBStream &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBStructuredData, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBStructuredData, operator bool, ());
+ LLDB_REGISTER_METHOD(void, SBStructuredData, Clear, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBError, SBStructuredData, GetAsJSON,
+ (lldb::SBStream &));
+ LLDB_REGISTER_METHOD_CONST(lldb::SBError, SBStructuredData, GetDescription,
+ (lldb::SBStream &));
+ LLDB_REGISTER_METHOD_CONST(lldb::StructuredDataType, SBStructuredData,
+ GetType, ());
+ LLDB_REGISTER_METHOD_CONST(size_t, SBStructuredData, GetSize, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBStructuredData, GetKeys,
+ (lldb::SBStringList &));
+ LLDB_REGISTER_METHOD_CONST(lldb::SBStructuredData, SBStructuredData,
+ GetValueForKey, (const char *));
+ LLDB_REGISTER_METHOD_CONST(lldb::SBStructuredData, SBStructuredData,
+ GetItemAtIndex, (size_t));
+ LLDB_REGISTER_METHOD_CONST(uint64_t, SBStructuredData, GetIntegerValue,
+ (uint64_t));
+ LLDB_REGISTER_METHOD_CONST(double, SBStructuredData, GetFloatValue,
+ (double));
+ LLDB_REGISTER_METHOD_CONST(bool, SBStructuredData, GetBooleanValue, (bool));
+ LLDB_REGISTER_METHOD_CONST(size_t, SBStructuredData, GetStringValue,
+ (char *, size_t));
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBSymbol.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBSymbol.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBSymbol.cpp (original)
+++ lldb/trunk/source/API/SBSymbol.cpp Tue Mar 19 10:13:13 2019
@@ -208,3 +208,37 @@ bool SBSymbol::IsSynthetic() {
return m_opaque_ptr->IsSynthetic();
return false;
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBSymbol>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBSymbol, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBSymbol, (const lldb::SBSymbol &));
+ LLDB_REGISTER_METHOD(const lldb::SBSymbol &,
+ SBSymbol, operator=,(const lldb::SBSymbol &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBSymbol, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBSymbol, operator bool, ());
+ LLDB_REGISTER_METHOD_CONST(const char *, SBSymbol, GetName, ());
+ LLDB_REGISTER_METHOD_CONST(const char *, SBSymbol, GetDisplayName, ());
+ LLDB_REGISTER_METHOD_CONST(const char *, SBSymbol, GetMangledName, ());
+ LLDB_REGISTER_METHOD_CONST(bool,
+ SBSymbol, operator==,(const lldb::SBSymbol &));
+ LLDB_REGISTER_METHOD_CONST(bool,
+ SBSymbol, operator!=,(const lldb::SBSymbol &));
+ LLDB_REGISTER_METHOD(bool, SBSymbol, GetDescription, (lldb::SBStream &));
+ LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBSymbol, GetInstructions,
+ (lldb::SBTarget));
+ LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBSymbol, GetInstructions,
+ (lldb::SBTarget, const char *));
+ LLDB_REGISTER_METHOD(lldb::SBAddress, SBSymbol, GetStartAddress, ());
+ LLDB_REGISTER_METHOD(lldb::SBAddress, SBSymbol, GetEndAddress, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBSymbol, GetPrologueByteSize, ());
+ LLDB_REGISTER_METHOD(lldb::SymbolType, SBSymbol, GetType, ());
+ LLDB_REGISTER_METHOD(bool, SBSymbol, IsExternal, ());
+ LLDB_REGISTER_METHOD(bool, SBSymbol, IsSynthetic, ());
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBSymbolContext.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBSymbolContext.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBSymbolContext.cpp (original)
+++ lldb/trunk/source/API/SBSymbolContext.cpp Tue Mar 19 10:13:13 2019
@@ -228,3 +228,43 @@ SBSymbolContext::GetParentOfInlinedScope
}
return LLDB_RECORD_RESULT(SBSymbolContext());
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBSymbolContext>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBSymbolContext, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBSymbolContext,
+ (const lldb_private::SymbolContext *));
+ LLDB_REGISTER_CONSTRUCTOR(SBSymbolContext, (const lldb::SBSymbolContext &));
+ LLDB_REGISTER_METHOD(
+ const lldb::SBSymbolContext &,
+ SBSymbolContext, operator=,(const lldb::SBSymbolContext &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBSymbolContext, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBSymbolContext, operator bool, ());
+ LLDB_REGISTER_METHOD(lldb::SBModule, SBSymbolContext, GetModule, ());
+ LLDB_REGISTER_METHOD(lldb::SBCompileUnit, SBSymbolContext, GetCompileUnit,
+ ());
+ LLDB_REGISTER_METHOD(lldb::SBFunction, SBSymbolContext, GetFunction, ());
+ LLDB_REGISTER_METHOD(lldb::SBBlock, SBSymbolContext, GetBlock, ());
+ LLDB_REGISTER_METHOD(lldb::SBLineEntry, SBSymbolContext, GetLineEntry, ());
+ LLDB_REGISTER_METHOD(lldb::SBSymbol, SBSymbolContext, GetSymbol, ());
+ LLDB_REGISTER_METHOD(void, SBSymbolContext, SetModule, (lldb::SBModule));
+ LLDB_REGISTER_METHOD(void, SBSymbolContext, SetCompileUnit,
+ (lldb::SBCompileUnit));
+ LLDB_REGISTER_METHOD(void, SBSymbolContext, SetFunction,
+ (lldb::SBFunction));
+ LLDB_REGISTER_METHOD(void, SBSymbolContext, SetBlock, (lldb::SBBlock));
+ LLDB_REGISTER_METHOD(void, SBSymbolContext, SetLineEntry,
+ (lldb::SBLineEntry));
+ LLDB_REGISTER_METHOD(void, SBSymbolContext, SetSymbol, (lldb::SBSymbol));
+ LLDB_REGISTER_METHOD(bool, SBSymbolContext, GetDescription,
+ (lldb::SBStream &));
+ LLDB_REGISTER_METHOD_CONST(lldb::SBSymbolContext, SBSymbolContext,
+ GetParentOfInlinedScope,
+ (const lldb::SBAddress &, lldb::SBAddress &));
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBSymbolContextList.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBSymbolContextList.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBSymbolContextList.cpp (original)
+++ lldb/trunk/source/API/SBSymbolContextList.cpp Tue Mar 19 10:13:13 2019
@@ -114,3 +114,31 @@ bool SBSymbolContextList::GetDescription
m_opaque_up->GetDescription(&strm, lldb::eDescriptionLevelFull, NULL);
return true;
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBSymbolContextList>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBSymbolContextList, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBSymbolContextList,
+ (const lldb::SBSymbolContextList &));
+ LLDB_REGISTER_METHOD(
+ const lldb::SBSymbolContextList &,
+ SBSymbolContextList, operator=,(const lldb::SBSymbolContextList &));
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBSymbolContextList, GetSize, ());
+ LLDB_REGISTER_METHOD(lldb::SBSymbolContext, SBSymbolContextList,
+ GetContextAtIndex, (uint32_t));
+ LLDB_REGISTER_METHOD(void, SBSymbolContextList, Clear, ());
+ LLDB_REGISTER_METHOD(void, SBSymbolContextList, Append,
+ (lldb::SBSymbolContext &));
+ LLDB_REGISTER_METHOD(void, SBSymbolContextList, Append,
+ (lldb::SBSymbolContextList &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBSymbolContextList, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBSymbolContextList, operator bool, ());
+ LLDB_REGISTER_METHOD(bool, SBSymbolContextList, GetDescription,
+ (lldb::SBStream &));
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBTarget.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBTarget.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBTarget.cpp (original)
+++ lldb/trunk/source/API/SBTarget.cpp Tue Mar 19 10:13:13 2019
@@ -2427,3 +2427,250 @@ void SBTarget::SetLaunchInfo(const lldb:
if (target_sp)
m_opaque_sp->SetProcessLaunchInfo(launch_info.ref());
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBTarget>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBTarget, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBTarget, (const lldb::SBTarget &));
+ LLDB_REGISTER_CONSTRUCTOR(SBTarget, (const lldb::TargetSP &));
+ LLDB_REGISTER_METHOD(const lldb::SBTarget &,
+ SBTarget, operator=,(const lldb::SBTarget &));
+ LLDB_REGISTER_STATIC_METHOD(bool, SBTarget, EventIsTargetEvent,
+ (const lldb::SBEvent &));
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBTarget, SBTarget, GetTargetFromEvent,
+ (const lldb::SBEvent &));
+ LLDB_REGISTER_STATIC_METHOD(uint32_t, SBTarget, GetNumModulesFromEvent,
+ (const lldb::SBEvent &));
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBModule, SBTarget,
+ GetModuleAtIndexFromEvent,
+ (const uint32_t, const lldb::SBEvent &));
+ LLDB_REGISTER_STATIC_METHOD(const char *, SBTarget, GetBroadcasterClassName,
+ ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBTarget, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBTarget, operator bool, ());
+ LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, GetProcess, ());
+ LLDB_REGISTER_METHOD(lldb::SBPlatform, SBTarget, GetPlatform, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBDebugger, SBTarget, GetDebugger, ());
+ LLDB_REGISTER_METHOD(lldb::SBStructuredData, SBTarget, GetStatistics, ());
+ LLDB_REGISTER_METHOD(void, SBTarget, SetCollectingStats, (bool));
+ LLDB_REGISTER_METHOD(bool, SBTarget, GetCollectingStats, ());
+ LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, LoadCore, (const char *));
+ LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, LoadCore,
+ (const char *, lldb::SBError &));
+ LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, LaunchSimple,
+ (const char **, const char **, const char *));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, Install, ());
+ LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, Launch,
+ (lldb::SBListener &, const char **, const char **,
+ const char *, const char *, const char *,
+ const char *, uint32_t, bool, lldb::SBError &));
+ LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, Launch,
+ (lldb::SBLaunchInfo &, lldb::SBError &));
+ LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, Attach,
+ (lldb::SBAttachInfo &, lldb::SBError &));
+ LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, AttachToProcessWithID,
+ (lldb::SBListener &, lldb::pid_t, lldb::SBError &));
+ LLDB_REGISTER_METHOD(
+ lldb::SBProcess, SBTarget, AttachToProcessWithName,
+ (lldb::SBListener &, const char *, bool, lldb::SBError &));
+ LLDB_REGISTER_METHOD(
+ lldb::SBProcess, SBTarget, ConnectRemote,
+ (lldb::SBListener &, const char *, const char *, lldb::SBError &));
+ LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBTarget, GetExecutable, ());
+ LLDB_REGISTER_METHOD_CONST(bool,
+ SBTarget, operator==,(const lldb::SBTarget &));
+ LLDB_REGISTER_METHOD_CONST(bool,
+ SBTarget, operator!=,(const lldb::SBTarget &));
+ LLDB_REGISTER_METHOD(lldb::SBAddress, SBTarget, ResolveLoadAddress,
+ (lldb::addr_t));
+ LLDB_REGISTER_METHOD(lldb::SBAddress, SBTarget, ResolveFileAddress,
+ (lldb::addr_t));
+ LLDB_REGISTER_METHOD(lldb::SBAddress, SBTarget, ResolvePastLoadAddress,
+ (uint32_t, lldb::addr_t));
+ LLDB_REGISTER_METHOD(lldb::SBSymbolContext, SBTarget,
+ ResolveSymbolContextForAddress,
+ (const lldb::SBAddress &, uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
+ BreakpointCreateByLocation, (const char *, uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
+ BreakpointCreateByLocation,
+ (const lldb::SBFileSpec &, uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
+ BreakpointCreateByLocation,
+ (const lldb::SBFileSpec &, uint32_t, lldb::addr_t));
+ LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
+ BreakpointCreateByLocation,
+ (const lldb::SBFileSpec &, uint32_t, lldb::addr_t,
+ lldb::SBFileSpecList &));
+ LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
+ BreakpointCreateByLocation,
+ (const lldb::SBFileSpec &, uint32_t, uint32_t,
+ lldb::addr_t, lldb::SBFileSpecList &));
+ LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
+ (const char *, const char *));
+ LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
+ (const char *, const lldb::SBFileSpecList &,
+ const lldb::SBFileSpecList &));
+ LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
+ (const char *, uint32_t, const lldb::SBFileSpecList &,
+ const lldb::SBFileSpecList &));
+ LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
+ (const char *, uint32_t, lldb::LanguageType,
+ const lldb::SBFileSpecList &,
+ const lldb::SBFileSpecList &));
+ LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames,
+ (const char **, uint32_t, uint32_t,
+ const lldb::SBFileSpecList &,
+ const lldb::SBFileSpecList &));
+ LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames,
+ (const char **, uint32_t, uint32_t, lldb::LanguageType,
+ const lldb::SBFileSpecList &,
+ const lldb::SBFileSpecList &));
+ LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames,
+ (const char **, uint32_t, uint32_t, lldb::LanguageType,
+ lldb::addr_t, const lldb::SBFileSpecList &,
+ const lldb::SBFileSpecList &));
+ LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex,
+ (const char *, const char *));
+ LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex,
+ (const char *, const lldb::SBFileSpecList &,
+ const lldb::SBFileSpecList &));
+ LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex,
+ (const char *, lldb::LanguageType,
+ const lldb::SBFileSpecList &,
+ const lldb::SBFileSpecList &));
+ LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
+ BreakpointCreateByAddress, (lldb::addr_t));
+ LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
+ BreakpointCreateBySBAddress, (lldb::SBAddress &));
+ LLDB_REGISTER_METHOD(
+ lldb::SBBreakpoint, SBTarget, BreakpointCreateBySourceRegex,
+ (const char *, const lldb::SBFileSpec &, const char *));
+ LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
+ BreakpointCreateBySourceRegex,
+ (const char *, const lldb::SBFileSpecList &,
+ const lldb::SBFileSpecList &));
+ LLDB_REGISTER_METHOD(
+ lldb::SBBreakpoint, SBTarget, BreakpointCreateBySourceRegex,
+ (const char *, const lldb::SBFileSpecList &,
+ const lldb::SBFileSpecList &, const lldb::SBStringList &));
+ LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
+ BreakpointCreateForException,
+ (lldb::LanguageType, bool, bool));
+ LLDB_REGISTER_METHOD(
+ lldb::SBBreakpoint, SBTarget, BreakpointCreateFromScript,
+ (const char *, lldb::SBStructuredData &, const lldb::SBFileSpecList &,
+ const lldb::SBFileSpecList &, bool));
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBTarget, GetNumBreakpoints, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBBreakpoint, SBTarget,
+ GetBreakpointAtIndex, (uint32_t));
+ LLDB_REGISTER_METHOD(bool, SBTarget, BreakpointDelete, (lldb::break_id_t));
+ LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, FindBreakpointByID,
+ (lldb::break_id_t));
+ LLDB_REGISTER_METHOD(bool, SBTarget, FindBreakpointsByName,
+ (const char *, lldb::SBBreakpointList &));
+ LLDB_REGISTER_METHOD(void, SBTarget, GetBreakpointNames,
+ (lldb::SBStringList &));
+ LLDB_REGISTER_METHOD(void, SBTarget, DeleteBreakpointName, (const char *));
+ LLDB_REGISTER_METHOD(bool, SBTarget, EnableAllBreakpoints, ());
+ LLDB_REGISTER_METHOD(bool, SBTarget, DisableAllBreakpoints, ());
+ LLDB_REGISTER_METHOD(bool, SBTarget, DeleteAllBreakpoints, ());
+ LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, BreakpointsCreateFromFile,
+ (lldb::SBFileSpec &, lldb::SBBreakpointList &));
+ LLDB_REGISTER_METHOD(
+ lldb::SBError, SBTarget, BreakpointsCreateFromFile,
+ (lldb::SBFileSpec &, lldb::SBStringList &, lldb::SBBreakpointList &));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, BreakpointsWriteToFile,
+ (lldb::SBFileSpec &));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, BreakpointsWriteToFile,
+ (lldb::SBFileSpec &, lldb::SBBreakpointList &, bool));
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBTarget, GetNumWatchpoints, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBWatchpoint, SBTarget,
+ GetWatchpointAtIndex, (uint32_t));
+ LLDB_REGISTER_METHOD(bool, SBTarget, DeleteWatchpoint, (lldb::watch_id_t));
+ LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBTarget, FindWatchpointByID,
+ (lldb::watch_id_t));
+ LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBTarget, WatchAddress,
+ (lldb::addr_t, size_t, bool, bool, lldb::SBError &));
+ LLDB_REGISTER_METHOD(bool, SBTarget, EnableAllWatchpoints, ());
+ LLDB_REGISTER_METHOD(bool, SBTarget, DisableAllWatchpoints, ());
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, CreateValueFromAddress,
+ (const char *, lldb::SBAddress, lldb::SBType));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, CreateValueFromData,
+ (const char *, lldb::SBData, lldb::SBType));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, CreateValueFromExpression,
+ (const char *, const char *));
+ LLDB_REGISTER_METHOD(bool, SBTarget, DeleteAllWatchpoints, ());
+ LLDB_REGISTER_METHOD(void, SBTarget, AppendImageSearchPath,
+ (const char *, const char *, lldb::SBError &));
+ LLDB_REGISTER_METHOD(lldb::SBModule, SBTarget, AddModule,
+ (const char *, const char *, const char *));
+ LLDB_REGISTER_METHOD(
+ lldb::SBModule, SBTarget, AddModule,
+ (const char *, const char *, const char *, const char *));
+ LLDB_REGISTER_METHOD(lldb::SBModule, SBTarget, AddModule,
+ (const lldb::SBModuleSpec &));
+ LLDB_REGISTER_METHOD(bool, SBTarget, AddModule, (lldb::SBModule &));
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBTarget, GetNumModules, ());
+ LLDB_REGISTER_METHOD(void, SBTarget, Clear, ());
+ LLDB_REGISTER_METHOD(lldb::SBModule, SBTarget, FindModule,
+ (const lldb::SBFileSpec &));
+ LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBTarget, FindCompileUnits,
+ (const lldb::SBFileSpec &));
+ LLDB_REGISTER_METHOD(lldb::ByteOrder, SBTarget, GetByteOrder, ());
+ LLDB_REGISTER_METHOD(const char *, SBTarget, GetTriple, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBTarget, GetDataByteSize, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBTarget, GetCodeByteSize, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBTarget, GetAddressByteSize, ());
+ LLDB_REGISTER_METHOD(lldb::SBModule, SBTarget, GetModuleAtIndex,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(bool, SBTarget, RemoveModule, (lldb::SBModule));
+ LLDB_REGISTER_METHOD_CONST(lldb::SBBroadcaster, SBTarget, GetBroadcaster,
+ ());
+ LLDB_REGISTER_METHOD(bool, SBTarget, GetDescription,
+ (lldb::SBStream &, lldb::DescriptionLevel));
+ LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBTarget, FindFunctions,
+ (const char *, uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBTarget,
+ FindGlobalFunctions,
+ (const char *, uint32_t, lldb::MatchType));
+ LLDB_REGISTER_METHOD(lldb::SBType, SBTarget, FindFirstType, (const char *));
+ LLDB_REGISTER_METHOD(lldb::SBType, SBTarget, GetBasicType,
+ (lldb::BasicType));
+ LLDB_REGISTER_METHOD(lldb::SBTypeList, SBTarget, FindTypes, (const char *));
+ LLDB_REGISTER_METHOD(lldb::SBValueList, SBTarget, FindGlobalVariables,
+ (const char *, uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBValueList, SBTarget, FindGlobalVariables,
+ (const char *, uint32_t, lldb::MatchType));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, FindFirstGlobalVariable,
+ (const char *));
+ LLDB_REGISTER_METHOD(lldb::SBSourceManager, SBTarget, GetSourceManager, ());
+ LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBTarget, ReadInstructions,
+ (lldb::SBAddress, uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBTarget, ReadInstructions,
+ (lldb::SBAddress, uint32_t, const char *));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, SetSectionLoadAddress,
+ (lldb::SBSection, lldb::addr_t));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, ClearSectionLoadAddress,
+ (lldb::SBSection));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, SetModuleLoadAddress,
+ (lldb::SBModule, int64_t));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, ClearModuleLoadAddress,
+ (lldb::SBModule));
+ LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBTarget, FindSymbols,
+ (const char *, lldb::SymbolType));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, EvaluateExpression,
+ (const char *));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, EvaluateExpression,
+ (const char *, const lldb::SBExpressionOptions &));
+ LLDB_REGISTER_METHOD(lldb::addr_t, SBTarget, GetStackRedZoneSize, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBLaunchInfo, SBTarget, GetLaunchInfo, ());
+ LLDB_REGISTER_METHOD(void, SBTarget, SetLaunchInfo,
+ (const lldb::SBLaunchInfo &));
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBThread.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBThread.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBThread.cpp (original)
+++ lldb/trunk/source/API/SBThread.cpp Tue Mar 19 10:13:13 2019
@@ -1416,3 +1416,111 @@ lldb_private::Thread *SBThread::get() {
else
return NULL;
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBThread>(Registry &R) {
+ LLDB_REGISTER_STATIC_METHOD(const char *, SBThread, GetBroadcasterClassName,
+ ());
+ LLDB_REGISTER_CONSTRUCTOR(SBThread, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBThread, (const lldb::ThreadSP &));
+ LLDB_REGISTER_CONSTRUCTOR(SBThread, (const lldb::SBThread &));
+ LLDB_REGISTER_METHOD(const lldb::SBThread &,
+ SBThread, operator=,(const lldb::SBThread &));
+ LLDB_REGISTER_METHOD_CONST(lldb::SBQueue, SBThread, GetQueue, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBThread, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBThread, operator bool, ());
+ LLDB_REGISTER_METHOD(void, SBThread, Clear, ());
+ LLDB_REGISTER_METHOD(lldb::StopReason, SBThread, GetStopReason, ());
+ LLDB_REGISTER_METHOD(size_t, SBThread, GetStopReasonDataCount, ());
+ LLDB_REGISTER_METHOD(uint64_t, SBThread, GetStopReasonDataAtIndex,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(bool, SBThread, GetStopReasonExtendedInfoAsJSON,
+ (lldb::SBStream &));
+ LLDB_REGISTER_METHOD(lldb::SBThreadCollection, SBThread,
+ GetStopReasonExtendedBacktraces,
+ (lldb::InstrumentationRuntimeType));
+ LLDB_REGISTER_METHOD(size_t, SBThread, GetStopDescription,
+ (char *, size_t));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBThread, GetStopReturnValue, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::tid_t, SBThread, GetThreadID, ());
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBThread, GetIndexID, ());
+ LLDB_REGISTER_METHOD_CONST(const char *, SBThread, GetName, ());
+ LLDB_REGISTER_METHOD_CONST(const char *, SBThread, GetQueueName, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::queue_id_t, SBThread, GetQueueID, ());
+ LLDB_REGISTER_METHOD(bool, SBThread, GetInfoItemByPathAsString,
+ (const char *, lldb::SBStream &));
+ LLDB_REGISTER_METHOD(void, SBThread, StepOver, (lldb::RunMode));
+ LLDB_REGISTER_METHOD(void, SBThread, StepOver,
+ (lldb::RunMode, lldb::SBError &));
+ LLDB_REGISTER_METHOD(void, SBThread, StepInto, (lldb::RunMode));
+ LLDB_REGISTER_METHOD(void, SBThread, StepInto,
+ (const char *, lldb::RunMode));
+ LLDB_REGISTER_METHOD(
+ void, SBThread, StepInto,
+ (const char *, uint32_t, lldb::SBError &, lldb::RunMode));
+ LLDB_REGISTER_METHOD(void, SBThread, StepOut, ());
+ LLDB_REGISTER_METHOD(void, SBThread, StepOut, (lldb::SBError &));
+ LLDB_REGISTER_METHOD(void, SBThread, StepOutOfFrame, (lldb::SBFrame &));
+ LLDB_REGISTER_METHOD(void, SBThread, StepOutOfFrame,
+ (lldb::SBFrame &, lldb::SBError &));
+ LLDB_REGISTER_METHOD(void, SBThread, StepInstruction, (bool));
+ LLDB_REGISTER_METHOD(void, SBThread, StepInstruction,
+ (bool, lldb::SBError &));
+ LLDB_REGISTER_METHOD(void, SBThread, RunToAddress, (lldb::addr_t));
+ LLDB_REGISTER_METHOD(void, SBThread, RunToAddress,
+ (lldb::addr_t, lldb::SBError &));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBThread, StepOverUntil,
+ (lldb::SBFrame &, lldb::SBFileSpec &, uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan,
+ (const char *));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan,
+ (const char *, bool));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBThread, JumpToLine,
+ (lldb::SBFileSpec &, uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBThread, ReturnFromFrame,
+ (lldb::SBFrame &, lldb::SBValue &));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBThread, UnwindInnermostExpression,
+ ());
+ LLDB_REGISTER_METHOD(bool, SBThread, Suspend, ());
+ LLDB_REGISTER_METHOD(bool, SBThread, Suspend, (lldb::SBError &));
+ LLDB_REGISTER_METHOD(bool, SBThread, Resume, ());
+ LLDB_REGISTER_METHOD(bool, SBThread, Resume, (lldb::SBError &));
+ LLDB_REGISTER_METHOD(bool, SBThread, IsSuspended, ());
+ LLDB_REGISTER_METHOD(bool, SBThread, IsStopped, ());
+ LLDB_REGISTER_METHOD(lldb::SBProcess, SBThread, GetProcess, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBThread, GetNumFrames, ());
+ LLDB_REGISTER_METHOD(lldb::SBFrame, SBThread, GetFrameAtIndex, (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBFrame, SBThread, GetSelectedFrame, ());
+ LLDB_REGISTER_METHOD(lldb::SBFrame, SBThread, SetSelectedFrame, (uint32_t));
+ LLDB_REGISTER_STATIC_METHOD(bool, SBThread, EventIsThreadEvent,
+ (const lldb::SBEvent &));
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBFrame, SBThread, GetStackFrameFromEvent,
+ (const lldb::SBEvent &));
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBThread, SBThread, GetThreadFromEvent,
+ (const lldb::SBEvent &));
+ LLDB_REGISTER_METHOD_CONST(bool,
+ SBThread, operator==,(const lldb::SBThread &));
+ LLDB_REGISTER_METHOD_CONST(bool,
+ SBThread, operator!=,(const lldb::SBThread &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBThread, GetStatus, (lldb::SBStream &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBThread, GetDescription,
+ (lldb::SBStream &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBThread, GetDescription,
+ (lldb::SBStream &, bool));
+ LLDB_REGISTER_METHOD(lldb::SBThread, SBThread, GetExtendedBacktraceThread,
+ (const char *));
+ LLDB_REGISTER_METHOD(uint32_t, SBThread,
+ GetExtendedBacktraceOriginatingIndexID, ());
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBThread, GetCurrentException, ());
+ LLDB_REGISTER_METHOD(lldb::SBThread, SBThread, GetCurrentExceptionBacktrace,
+ ());
+ LLDB_REGISTER_METHOD(bool, SBThread, SafeToCallFunctions, ());
+ LLDB_REGISTER_METHOD(lldb_private::Thread *, SBThread, operator->,());
+ LLDB_REGISTER_METHOD(lldb_private::Thread *, SBThread, get, ());
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBThreadCollection.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBThreadCollection.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBThreadCollection.cpp (original)
+++ lldb/trunk/source/API/SBThreadCollection.cpp Tue Mar 19 10:13:13 2019
@@ -87,3 +87,24 @@ SBThread SBThreadCollection::GetThreadAt
thread = m_opaque_sp->GetThreadAtIndex(idx);
return LLDB_RECORD_RESULT(thread);
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBThreadCollection>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBThreadCollection, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBThreadCollection,
+ (const lldb::SBThreadCollection &));
+ LLDB_REGISTER_METHOD(
+ const lldb::SBThreadCollection &,
+ SBThreadCollection, operator=,(const lldb::SBThreadCollection &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBThreadCollection, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBThreadCollection, operator bool, ());
+ LLDB_REGISTER_METHOD(size_t, SBThreadCollection, GetSize, ());
+ LLDB_REGISTER_METHOD(lldb::SBThread, SBThreadCollection, GetThreadAtIndex,
+ (size_t));
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBThreadPlan.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBThreadPlan.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBThreadPlan.cpp (original)
+++ lldb/trunk/source/API/SBThreadPlan.cpp Tue Mar 19 10:13:13 2019
@@ -390,3 +390,61 @@ SBThreadPlan::QueueThreadPlanForStepScri
return LLDB_RECORD_RESULT(SBThreadPlan());
}
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBThreadPlan>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, (const lldb::ThreadPlanSP &));
+ LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, (const lldb::SBThreadPlan &));
+ LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, (lldb::SBThread &, const char *));
+ LLDB_REGISTER_METHOD(const lldb::SBThreadPlan &,
+ SBThreadPlan, operator=,(const lldb::SBThreadPlan &));
+ LLDB_REGISTER_METHOD(lldb_private::ThreadPlan *, SBThreadPlan, get, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBThreadPlan, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBThreadPlan, operator bool, ());
+ LLDB_REGISTER_METHOD(void, SBThreadPlan, Clear, ());
+ LLDB_REGISTER_METHOD(lldb::StopReason, SBThreadPlan, GetStopReason, ());
+ LLDB_REGISTER_METHOD(size_t, SBThreadPlan, GetStopReasonDataCount, ());
+ LLDB_REGISTER_METHOD(uint64_t, SBThreadPlan, GetStopReasonDataAtIndex,
+ (uint32_t));
+ LLDB_REGISTER_METHOD_CONST(lldb::SBThread, SBThreadPlan, GetThread, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBThreadPlan, GetDescription,
+ (lldb::SBStream &));
+ LLDB_REGISTER_METHOD(void, SBThreadPlan, SetPlanComplete, (bool));
+ LLDB_REGISTER_METHOD(bool, SBThreadPlan, IsPlanComplete, ());
+ LLDB_REGISTER_METHOD(bool, SBThreadPlan, IsPlanStale, ());
+ LLDB_REGISTER_METHOD(bool, SBThreadPlan, IsValid, ());
+ LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
+ QueueThreadPlanForStepOverRange,
+ (lldb::SBAddress &, lldb::addr_t));
+ LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
+ QueueThreadPlanForStepOverRange,
+ (lldb::SBAddress &, lldb::addr_t, lldb::SBError &));
+ LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
+ QueueThreadPlanForStepInRange,
+ (lldb::SBAddress &, lldb::addr_t));
+ LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
+ QueueThreadPlanForStepInRange,
+ (lldb::SBAddress &, lldb::addr_t, lldb::SBError &));
+ LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
+ QueueThreadPlanForStepOut, (uint32_t, bool));
+ LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
+ QueueThreadPlanForStepOut,
+ (uint32_t, bool, lldb::SBError &));
+ LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
+ QueueThreadPlanForRunToAddress, (lldb::SBAddress));
+ LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
+ QueueThreadPlanForRunToAddress,
+ (lldb::SBAddress, lldb::SBError &));
+ LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
+ QueueThreadPlanForStepScripted, (const char *));
+ LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
+ QueueThreadPlanForStepScripted,
+ (const char *, lldb::SBError &));
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBTrace.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBTrace.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBTrace.cpp (original)
+++ lldb/trunk/source/API/SBTrace.cpp Tue Mar 19 10:13:13 2019
@@ -127,3 +127,21 @@ SBTrace::operator bool() const {
return false;
return true;
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBTrace>(Registry &R) {
+ LLDB_REGISTER_METHOD(void, SBTrace, StopTrace,
+ (lldb::SBError &, lldb::tid_t));
+ LLDB_REGISTER_METHOD(void, SBTrace, GetTraceConfig,
+ (lldb::SBTraceOptions &, lldb::SBError &));
+ LLDB_REGISTER_METHOD(lldb::user_id_t, SBTrace, GetTraceUID, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBTrace, ());
+ LLDB_REGISTER_METHOD(bool, SBTrace, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBTrace, operator bool, ());
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBTraceOptions.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBTraceOptions.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBTraceOptions.cpp (original)
+++ lldb/trunk/source/API/SBTraceOptions.cpp Tue Mar 19 10:13:13 2019
@@ -129,3 +129,31 @@ lldb::tid_t SBTraceOptions::getThreadID(
return m_traceoptions_sp->getThreadID();
return LLDB_INVALID_THREAD_ID;
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBTraceOptions>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBTraceOptions, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::TraceType, SBTraceOptions, getType, ());
+ LLDB_REGISTER_METHOD_CONST(uint64_t, SBTraceOptions, getTraceBufferSize,
+ ());
+ LLDB_REGISTER_METHOD(lldb::SBStructuredData, SBTraceOptions, getTraceParams,
+ (lldb::SBError &));
+ LLDB_REGISTER_METHOD_CONST(uint64_t, SBTraceOptions, getMetaDataBufferSize,
+ ());
+ LLDB_REGISTER_METHOD(void, SBTraceOptions, setTraceParams,
+ (lldb::SBStructuredData &));
+ LLDB_REGISTER_METHOD(void, SBTraceOptions, setType, (lldb::TraceType));
+ LLDB_REGISTER_METHOD(void, SBTraceOptions, setTraceBufferSize, (uint64_t));
+ LLDB_REGISTER_METHOD(void, SBTraceOptions, setMetaDataBufferSize,
+ (uint64_t));
+ LLDB_REGISTER_METHOD(bool, SBTraceOptions, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBTraceOptions, operator bool, ());
+ LLDB_REGISTER_METHOD(void, SBTraceOptions, setThreadID, (lldb::tid_t));
+ LLDB_REGISTER_METHOD(lldb::tid_t, SBTraceOptions, getThreadID, ());
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBType.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBType.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBType.cpp (original)
+++ lldb/trunk/source/API/SBType.cpp Tue Mar 19 10:13:13 2019
@@ -892,3 +892,117 @@ TypeMemberFunctionImpl &SBTypeMemberFunc
const TypeMemberFunctionImpl &SBTypeMemberFunction::ref() const {
return *m_opaque_sp.get();
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBType>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBType, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBType, (const lldb::SBType &));
+ LLDB_REGISTER_METHOD(bool, SBType, operator==,(lldb::SBType &));
+ LLDB_REGISTER_METHOD(bool, SBType, operator!=,(lldb::SBType &));
+ LLDB_REGISTER_METHOD(lldb::SBType &,
+ SBType, operator=,(const lldb::SBType &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBType, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBType, operator bool, ());
+ LLDB_REGISTER_METHOD(uint64_t, SBType, GetByteSize, ());
+ LLDB_REGISTER_METHOD(bool, SBType, IsPointerType, ());
+ LLDB_REGISTER_METHOD(bool, SBType, IsArrayType, ());
+ LLDB_REGISTER_METHOD(bool, SBType, IsVectorType, ());
+ LLDB_REGISTER_METHOD(bool, SBType, IsReferenceType, ());
+ LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetPointerType, ());
+ LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetPointeeType, ());
+ LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetReferenceType, ());
+ LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetTypedefedType, ());
+ LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetDereferencedType, ());
+ LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetArrayElementType, ());
+ LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetArrayType, (uint64_t));
+ LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetVectorElementType, ());
+ LLDB_REGISTER_METHOD(bool, SBType, IsFunctionType, ());
+ LLDB_REGISTER_METHOD(bool, SBType, IsPolymorphicClass, ());
+ LLDB_REGISTER_METHOD(bool, SBType, IsTypedefType, ());
+ LLDB_REGISTER_METHOD(bool, SBType, IsAnonymousType, ());
+ LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetFunctionReturnType, ());
+ LLDB_REGISTER_METHOD(lldb::SBTypeList, SBType, GetFunctionArgumentTypes,
+ ());
+ LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfMemberFunctions, ());
+ LLDB_REGISTER_METHOD(lldb::SBTypeMemberFunction, SBType,
+ GetMemberFunctionAtIndex, (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetUnqualifiedType, ());
+ LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetCanonicalType, ());
+ LLDB_REGISTER_METHOD(lldb::BasicType, SBType, GetBasicType, ());
+ LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetBasicType, (lldb::BasicType));
+ LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfDirectBaseClasses, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfVirtualBaseClasses, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfFields, ());
+ LLDB_REGISTER_METHOD(bool, SBType, GetDescription,
+ (lldb::SBStream &, lldb::DescriptionLevel));
+ LLDB_REGISTER_METHOD(lldb::SBTypeMember, SBType, GetDirectBaseClassAtIndex,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBTypeMember, SBType, GetVirtualBaseClassAtIndex,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBTypeEnumMemberList, SBType, GetEnumMembers,
+ ());
+ LLDB_REGISTER_METHOD(lldb::SBTypeMember, SBType, GetFieldAtIndex,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(bool, SBType, IsTypeComplete, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBType, GetTypeFlags, ());
+ LLDB_REGISTER_METHOD(const char *, SBType, GetName, ());
+ LLDB_REGISTER_METHOD(const char *, SBType, GetDisplayTypeName, ());
+ LLDB_REGISTER_METHOD(lldb::TypeClass, SBType, GetTypeClass, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfTemplateArguments, ());
+ LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetTemplateArgumentType,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::TemplateArgumentKind, SBType,
+ GetTemplateArgumentKind, (uint32_t));
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeList, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeList, (const lldb::SBTypeList &));
+ LLDB_REGISTER_METHOD(bool, SBTypeList, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBTypeList, operator bool, ());
+ LLDB_REGISTER_METHOD(lldb::SBTypeList &,
+ SBTypeList, operator=,(const lldb::SBTypeList &));
+ LLDB_REGISTER_METHOD(void, SBTypeList, Append, (lldb::SBType));
+ LLDB_REGISTER_METHOD(lldb::SBType, SBTypeList, GetTypeAtIndex, (uint32_t));
+ LLDB_REGISTER_METHOD(uint32_t, SBTypeList, GetSize, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeMember, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeMember, (const lldb::SBTypeMember &));
+ LLDB_REGISTER_METHOD(lldb::SBTypeMember &,
+ SBTypeMember, operator=,(const lldb::SBTypeMember &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBTypeMember, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBTypeMember, operator bool, ());
+ LLDB_REGISTER_METHOD(const char *, SBTypeMember, GetName, ());
+ LLDB_REGISTER_METHOD(lldb::SBType, SBTypeMember, GetType, ());
+ LLDB_REGISTER_METHOD(uint64_t, SBTypeMember, GetOffsetInBytes, ());
+ LLDB_REGISTER_METHOD(uint64_t, SBTypeMember, GetOffsetInBits, ());
+ LLDB_REGISTER_METHOD(bool, SBTypeMember, IsBitfield, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBTypeMember, GetBitfieldSizeInBits, ());
+ LLDB_REGISTER_METHOD(bool, SBTypeMember, GetDescription,
+ (lldb::SBStream &, lldb::DescriptionLevel));
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeMemberFunction, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeMemberFunction,
+ (const lldb::SBTypeMemberFunction &));
+ LLDB_REGISTER_METHOD(
+ lldb::SBTypeMemberFunction &,
+ SBTypeMemberFunction, operator=,(const lldb::SBTypeMemberFunction &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBTypeMemberFunction, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBTypeMemberFunction, operator bool, ());
+ LLDB_REGISTER_METHOD(const char *, SBTypeMemberFunction, GetName, ());
+ LLDB_REGISTER_METHOD(const char *, SBTypeMemberFunction, GetDemangledName,
+ ());
+ LLDB_REGISTER_METHOD(const char *, SBTypeMemberFunction, GetMangledName,
+ ());
+ LLDB_REGISTER_METHOD(lldb::SBType, SBTypeMemberFunction, GetType, ());
+ LLDB_REGISTER_METHOD(lldb::SBType, SBTypeMemberFunction, GetReturnType, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBTypeMemberFunction, GetNumberOfArguments,
+ ());
+ LLDB_REGISTER_METHOD(lldb::SBType, SBTypeMemberFunction,
+ GetArgumentTypeAtIndex, (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::MemberFunctionKind, SBTypeMemberFunction,
+ GetKind, ());
+ LLDB_REGISTER_METHOD(bool, SBTypeMemberFunction, GetDescription,
+ (lldb::SBStream &, lldb::DescriptionLevel));
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBTypeCategory.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBTypeCategory.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBTypeCategory.cpp (original)
+++ lldb/trunk/source/API/SBTypeCategory.cpp Tue Mar 19 10:13:13 2019
@@ -660,3 +660,78 @@ bool SBTypeCategory::IsDefaultCategory()
return (strcmp(m_opaque_sp->GetName(), "default") == 0);
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBTypeCategory>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeCategory, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeCategory, (const lldb::SBTypeCategory &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBTypeCategory, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBTypeCategory, operator bool, ());
+ LLDB_REGISTER_METHOD(bool, SBTypeCategory, GetEnabled, ());
+ LLDB_REGISTER_METHOD(void, SBTypeCategory, SetEnabled, (bool));
+ LLDB_REGISTER_METHOD(const char *, SBTypeCategory, GetName, ());
+ LLDB_REGISTER_METHOD(lldb::LanguageType, SBTypeCategory, GetLanguageAtIndex,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumLanguages, ());
+ LLDB_REGISTER_METHOD(void, SBTypeCategory, AddLanguage,
+ (lldb::LanguageType));
+ LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumFormats, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumSummaries, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumFilters, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumSynthetics, ());
+ LLDB_REGISTER_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
+ GetTypeNameSpecifierForSyntheticAtIndex, (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBTypeSummary, SBTypeCategory, GetSummaryForType,
+ (lldb::SBTypeNameSpecifier));
+ LLDB_REGISTER_METHOD(lldb::SBTypeSynthetic, SBTypeCategory,
+ GetSyntheticForType, (lldb::SBTypeNameSpecifier));
+ LLDB_REGISTER_METHOD(lldb::SBTypeFilter, SBTypeCategory, GetFilterAtIndex,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBTypeSummary, SBTypeCategory, GetSummaryAtIndex,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBTypeSynthetic, SBTypeCategory,
+ GetSyntheticAtIndex, (uint32_t));
+ LLDB_REGISTER_METHOD(bool, SBTypeCategory, AddTypeSummary,
+ (lldb::SBTypeNameSpecifier, lldb::SBTypeSummary));
+ LLDB_REGISTER_METHOD(bool, SBTypeCategory, AddTypeSynthetic,
+ (lldb::SBTypeNameSpecifier, lldb::SBTypeSynthetic));
+ LLDB_REGISTER_METHOD(bool, SBTypeCategory, DeleteTypeSynthetic,
+ (lldb::SBTypeNameSpecifier));
+ LLDB_REGISTER_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
+ GetTypeNameSpecifierForFilterAtIndex, (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
+ GetTypeNameSpecifierForFormatAtIndex, (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
+ GetTypeNameSpecifierForSummaryAtIndex, (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBTypeFilter, SBTypeCategory, GetFilterForType,
+ (lldb::SBTypeNameSpecifier));
+ LLDB_REGISTER_METHOD(lldb::SBTypeFormat, SBTypeCategory, GetFormatForType,
+ (lldb::SBTypeNameSpecifier));
+ LLDB_REGISTER_METHOD(lldb::SBTypeFormat, SBTypeCategory, GetFormatAtIndex,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(bool, SBTypeCategory, AddTypeFormat,
+ (lldb::SBTypeNameSpecifier, lldb::SBTypeFormat));
+ LLDB_REGISTER_METHOD(bool, SBTypeCategory, DeleteTypeFormat,
+ (lldb::SBTypeNameSpecifier));
+ LLDB_REGISTER_METHOD(bool, SBTypeCategory, DeleteTypeSummary,
+ (lldb::SBTypeNameSpecifier));
+ LLDB_REGISTER_METHOD(bool, SBTypeCategory, AddTypeFilter,
+ (lldb::SBTypeNameSpecifier, lldb::SBTypeFilter));
+ LLDB_REGISTER_METHOD(bool, SBTypeCategory, DeleteTypeFilter,
+ (lldb::SBTypeNameSpecifier));
+ LLDB_REGISTER_METHOD(bool, SBTypeCategory, GetDescription,
+ (lldb::SBStream &, lldb::DescriptionLevel));
+ LLDB_REGISTER_METHOD(
+ lldb::SBTypeCategory &,
+ SBTypeCategory, operator=,(const lldb::SBTypeCategory &));
+ LLDB_REGISTER_METHOD(bool,
+ SBTypeCategory, operator==,(lldb::SBTypeCategory &));
+ LLDB_REGISTER_METHOD(bool,
+ SBTypeCategory, operator!=,(lldb::SBTypeCategory &));
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBTypeEnumMember.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBTypeEnumMember.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBTypeEnumMember.cpp (original)
+++ lldb/trunk/source/API/SBTypeEnumMember.cpp Tue Mar 19 10:13:13 2019
@@ -195,3 +195,40 @@ bool SBTypeEnumMember::GetDescription(
}
return true;
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBTypeEnumMember>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeEnumMember, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeEnumMember,
+ (const lldb::SBTypeEnumMember &));
+ LLDB_REGISTER_METHOD(
+ lldb::SBTypeEnumMember &,
+ SBTypeEnumMember, operator=,(const lldb::SBTypeEnumMember &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBTypeEnumMember, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBTypeEnumMember, operator bool, ());
+ LLDB_REGISTER_METHOD(const char *, SBTypeEnumMember, GetName, ());
+ LLDB_REGISTER_METHOD(int64_t, SBTypeEnumMember, GetValueAsSigned, ());
+ LLDB_REGISTER_METHOD(uint64_t, SBTypeEnumMember, GetValueAsUnsigned, ());
+ LLDB_REGISTER_METHOD(lldb::SBType, SBTypeEnumMember, GetType, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeEnumMemberList, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeEnumMemberList,
+ (const lldb::SBTypeEnumMemberList &));
+ LLDB_REGISTER_METHOD(bool, SBTypeEnumMemberList, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBTypeEnumMemberList, operator bool, ());
+ LLDB_REGISTER_METHOD(
+ lldb::SBTypeEnumMemberList &,
+ SBTypeEnumMemberList, operator=,(const lldb::SBTypeEnumMemberList &));
+ LLDB_REGISTER_METHOD(void, SBTypeEnumMemberList, Append,
+ (lldb::SBTypeEnumMember));
+ LLDB_REGISTER_METHOD(lldb::SBTypeEnumMember, SBTypeEnumMemberList,
+ GetTypeEnumMemberAtIndex, (uint32_t));
+ LLDB_REGISTER_METHOD(uint32_t, SBTypeEnumMemberList, GetSize, ());
+ LLDB_REGISTER_METHOD(bool, SBTypeEnumMember, GetDescription,
+ (lldb::SBStream &, lldb::DescriptionLevel));
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBTypeFilter.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBTypeFilter.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBTypeFilter.cpp (original)
+++ lldb/trunk/source/API/SBTypeFilter.cpp Tue Mar 19 10:13:13 2019
@@ -191,3 +191,36 @@ bool SBTypeFilter::CopyOnWrite_Impl() {
return true;
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBTypeFilter>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeFilter, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeFilter, (uint32_t));
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeFilter, (const lldb::SBTypeFilter &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBTypeFilter, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBTypeFilter, operator bool, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBTypeFilter, GetOptions, ());
+ LLDB_REGISTER_METHOD(void, SBTypeFilter, SetOptions, (uint32_t));
+ LLDB_REGISTER_METHOD(bool, SBTypeFilter, GetDescription,
+ (lldb::SBStream &, lldb::DescriptionLevel));
+ LLDB_REGISTER_METHOD(void, SBTypeFilter, Clear, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBTypeFilter, GetNumberOfExpressionPaths,
+ ());
+ LLDB_REGISTER_METHOD(const char *, SBTypeFilter, GetExpressionPathAtIndex,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(bool, SBTypeFilter, ReplaceExpressionPathAtIndex,
+ (uint32_t, const char *));
+ LLDB_REGISTER_METHOD(void, SBTypeFilter, AppendExpressionPath,
+ (const char *));
+ LLDB_REGISTER_METHOD(lldb::SBTypeFilter &,
+ SBTypeFilter, operator=,(const lldb::SBTypeFilter &));
+ LLDB_REGISTER_METHOD(bool, SBTypeFilter, operator==,(lldb::SBTypeFilter &));
+ LLDB_REGISTER_METHOD(bool, SBTypeFilter, IsEqualTo, (lldb::SBTypeFilter &));
+ LLDB_REGISTER_METHOD(bool, SBTypeFilter, operator!=,(lldb::SBTypeFilter &));
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBTypeFormat.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBTypeFormat.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBTypeFormat.cpp (original)
+++ lldb/trunk/source/API/SBTypeFormat.cpp Tue Mar 19 10:13:13 2019
@@ -192,3 +192,32 @@ bool SBTypeFormat::CopyOnWrite_Impl(Type
return true;
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBTypeFormat>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeFormat, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeFormat, (lldb::Format, uint32_t));
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeFormat, (const char *, uint32_t));
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeFormat, (const lldb::SBTypeFormat &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBTypeFormat, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBTypeFormat, operator bool, ());
+ LLDB_REGISTER_METHOD(lldb::Format, SBTypeFormat, GetFormat, ());
+ LLDB_REGISTER_METHOD(const char *, SBTypeFormat, GetTypeName, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBTypeFormat, GetOptions, ());
+ LLDB_REGISTER_METHOD(void, SBTypeFormat, SetFormat, (lldb::Format));
+ LLDB_REGISTER_METHOD(void, SBTypeFormat, SetTypeName, (const char *));
+ LLDB_REGISTER_METHOD(void, SBTypeFormat, SetOptions, (uint32_t));
+ LLDB_REGISTER_METHOD(bool, SBTypeFormat, GetDescription,
+ (lldb::SBStream &, lldb::DescriptionLevel));
+ LLDB_REGISTER_METHOD(lldb::SBTypeFormat &,
+ SBTypeFormat, operator=,(const lldb::SBTypeFormat &));
+ LLDB_REGISTER_METHOD(bool, SBTypeFormat, operator==,(lldb::SBTypeFormat &));
+ LLDB_REGISTER_METHOD(bool, SBTypeFormat, IsEqualTo, (lldb::SBTypeFormat &));
+ LLDB_REGISTER_METHOD(bool, SBTypeFormat, operator!=,(lldb::SBTypeFormat &));
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBTypeNameSpecifier.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBTypeNameSpecifier.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBTypeNameSpecifier.cpp (original)
+++ lldb/trunk/source/API/SBTypeNameSpecifier.cpp Tue Mar 19 10:13:13 2019
@@ -156,3 +156,34 @@ void SBTypeNameSpecifier::SetSP(
SBTypeNameSpecifier::SBTypeNameSpecifier(
const lldb::TypeNameSpecifierImplSP &type_namespec_sp)
: m_opaque_sp(type_namespec_sp) {}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBTypeNameSpecifier>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeNameSpecifier, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeNameSpecifier, (const char *, bool));
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeNameSpecifier, (lldb::SBType));
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeNameSpecifier,
+ (const lldb::SBTypeNameSpecifier &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBTypeNameSpecifier, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBTypeNameSpecifier, operator bool, ());
+ LLDB_REGISTER_METHOD(const char *, SBTypeNameSpecifier, GetName, ());
+ LLDB_REGISTER_METHOD(lldb::SBType, SBTypeNameSpecifier, GetType, ());
+ LLDB_REGISTER_METHOD(bool, SBTypeNameSpecifier, IsRegex, ());
+ LLDB_REGISTER_METHOD(bool, SBTypeNameSpecifier, GetDescription,
+ (lldb::SBStream &, lldb::DescriptionLevel));
+ LLDB_REGISTER_METHOD(
+ lldb::SBTypeNameSpecifier &,
+ SBTypeNameSpecifier, operator=,(const lldb::SBTypeNameSpecifier &));
+ LLDB_REGISTER_METHOD(
+ bool, SBTypeNameSpecifier, operator==,(lldb::SBTypeNameSpecifier &));
+ LLDB_REGISTER_METHOD(bool, SBTypeNameSpecifier, IsEqualTo,
+ (lldb::SBTypeNameSpecifier &));
+ LLDB_REGISTER_METHOD(
+ bool, SBTypeNameSpecifier, operator!=,(lldb::SBTypeNameSpecifier &));
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBTypeSummary.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBTypeSummary.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBTypeSummary.cpp (original)
+++ lldb/trunk/source/API/SBTypeSummary.cpp Tue Mar 19 10:13:13 2019
@@ -473,3 +473,65 @@ bool SBTypeSummary::ChangeSummaryType(bo
return true;
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBTypeSummaryOptions>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeSummaryOptions, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeSummaryOptions,
+ (const lldb::SBTypeSummaryOptions &));
+ LLDB_REGISTER_METHOD(bool, SBTypeSummaryOptions, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBTypeSummaryOptions, operator bool, ());
+ LLDB_REGISTER_METHOD(lldb::LanguageType, SBTypeSummaryOptions, GetLanguage,
+ ());
+ LLDB_REGISTER_METHOD(lldb::TypeSummaryCapping, SBTypeSummaryOptions,
+ GetCapping, ());
+ LLDB_REGISTER_METHOD(void, SBTypeSummaryOptions, SetLanguage,
+ (lldb::LanguageType));
+ LLDB_REGISTER_METHOD(void, SBTypeSummaryOptions, SetCapping,
+ (lldb::TypeSummaryCapping));
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeSummaryOptions,
+ (const lldb_private::TypeSummaryOptions *));
+}
+
+template <>
+void RegisterMethods<SBTypeSummary>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeSummary, ());
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary,
+ CreateWithSummaryString,
+ (const char *, uint32_t));
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary,
+ CreateWithFunctionName,
+ (const char *, uint32_t));
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary,
+ CreateWithScriptCode, (const char *, uint32_t));
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeSummary, (const lldb::SBTypeSummary &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBTypeSummary, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBTypeSummary, operator bool, ());
+ LLDB_REGISTER_METHOD(bool, SBTypeSummary, IsFunctionCode, ());
+ LLDB_REGISTER_METHOD(bool, SBTypeSummary, IsFunctionName, ());
+ LLDB_REGISTER_METHOD(bool, SBTypeSummary, IsSummaryString, ());
+ LLDB_REGISTER_METHOD(const char *, SBTypeSummary, GetData, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBTypeSummary, GetOptions, ());
+ LLDB_REGISTER_METHOD(void, SBTypeSummary, SetOptions, (uint32_t));
+ LLDB_REGISTER_METHOD(void, SBTypeSummary, SetSummaryString, (const char *));
+ LLDB_REGISTER_METHOD(void, SBTypeSummary, SetFunctionName, (const char *));
+ LLDB_REGISTER_METHOD(void, SBTypeSummary, SetFunctionCode, (const char *));
+ LLDB_REGISTER_METHOD(bool, SBTypeSummary, GetDescription,
+ (lldb::SBStream &, lldb::DescriptionLevel));
+ LLDB_REGISTER_METHOD(bool, SBTypeSummary, DoesPrintValue, (lldb::SBValue));
+ LLDB_REGISTER_METHOD(
+ lldb::SBTypeSummary &,
+ SBTypeSummary, operator=,(const lldb::SBTypeSummary &));
+ LLDB_REGISTER_METHOD(bool,
+ SBTypeSummary, operator==,(lldb::SBTypeSummary &));
+ LLDB_REGISTER_METHOD(bool, SBTypeSummary, IsEqualTo,
+ (lldb::SBTypeSummary &));
+ LLDB_REGISTER_METHOD(bool,
+ SBTypeSummary, operator!=,(lldb::SBTypeSummary &));
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBTypeSynthetic.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBTypeSynthetic.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBTypeSynthetic.cpp (original)
+++ lldb/trunk/source/API/SBTypeSynthetic.cpp Tue Mar 19 10:13:13 2019
@@ -210,3 +210,39 @@ bool SBTypeSynthetic::CopyOnWrite_Impl()
return true;
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBTypeSynthetic>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeSynthetic, ());
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBTypeSynthetic, SBTypeSynthetic,
+ CreateWithClassName, (const char *, uint32_t));
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBTypeSynthetic, SBTypeSynthetic,
+ CreateWithScriptCode, (const char *, uint32_t));
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeSynthetic, (const lldb::SBTypeSynthetic &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBTypeSynthetic, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBTypeSynthetic, operator bool, ());
+ LLDB_REGISTER_METHOD(bool, SBTypeSynthetic, IsClassCode, ());
+ LLDB_REGISTER_METHOD(bool, SBTypeSynthetic, IsClassName, ());
+ LLDB_REGISTER_METHOD(const char *, SBTypeSynthetic, GetData, ());
+ LLDB_REGISTER_METHOD(void, SBTypeSynthetic, SetClassName, (const char *));
+ LLDB_REGISTER_METHOD(void, SBTypeSynthetic, SetClassCode, (const char *));
+ LLDB_REGISTER_METHOD(uint32_t, SBTypeSynthetic, GetOptions, ());
+ LLDB_REGISTER_METHOD(void, SBTypeSynthetic, SetOptions, (uint32_t));
+ LLDB_REGISTER_METHOD(bool, SBTypeSynthetic, GetDescription,
+ (lldb::SBStream &, lldb::DescriptionLevel));
+ LLDB_REGISTER_METHOD(
+ lldb::SBTypeSynthetic &,
+ SBTypeSynthetic, operator=,(const lldb::SBTypeSynthetic &));
+ LLDB_REGISTER_METHOD(bool,
+ SBTypeSynthetic, operator==,(lldb::SBTypeSynthetic &));
+ LLDB_REGISTER_METHOD(bool, SBTypeSynthetic, IsEqualTo,
+ (lldb::SBTypeSynthetic &));
+ LLDB_REGISTER_METHOD(bool,
+ SBTypeSynthetic, operator!=,(lldb::SBTypeSynthetic &));
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBUnixSignals.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBUnixSignals.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBUnixSignals.cpp (original)
+++ lldb/trunk/source/API/SBUnixSignals.cpp Tue Mar 19 10:13:13 2019
@@ -171,3 +171,36 @@ int32_t SBUnixSignals::GetSignalAtIndex(
return LLDB_INVALID_SIGNAL_NUMBER;
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBUnixSignals>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBUnixSignals, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBUnixSignals, (const lldb::SBUnixSignals &));
+ LLDB_REGISTER_METHOD(
+ const lldb::SBUnixSignals &,
+ SBUnixSignals, operator=,(const lldb::SBUnixSignals &));
+ LLDB_REGISTER_METHOD(void, SBUnixSignals, Clear, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBUnixSignals, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBUnixSignals, operator bool, ());
+ LLDB_REGISTER_METHOD_CONST(const char *, SBUnixSignals, GetSignalAsCString,
+ (int32_t));
+ LLDB_REGISTER_METHOD_CONST(int32_t, SBUnixSignals, GetSignalNumberFromName,
+ (const char *));
+ LLDB_REGISTER_METHOD_CONST(bool, SBUnixSignals, GetShouldSuppress,
+ (int32_t));
+ LLDB_REGISTER_METHOD(bool, SBUnixSignals, SetShouldSuppress,
+ (int32_t, bool));
+ LLDB_REGISTER_METHOD_CONST(bool, SBUnixSignals, GetShouldStop, (int32_t));
+ LLDB_REGISTER_METHOD(bool, SBUnixSignals, SetShouldStop, (int32_t, bool));
+ LLDB_REGISTER_METHOD_CONST(bool, SBUnixSignals, GetShouldNotify, (int32_t));
+ LLDB_REGISTER_METHOD(bool, SBUnixSignals, SetShouldNotify, (int32_t, bool));
+ LLDB_REGISTER_METHOD_CONST(int32_t, SBUnixSignals, GetNumSignals, ());
+ LLDB_REGISTER_METHOD_CONST(int32_t, SBUnixSignals, GetSignalAtIndex,
+ (int32_t));
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBValue.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBValue.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBValue.cpp (original)
+++ lldb/trunk/source/API/SBValue.cpp Tue Mar 19 10:13:13 2019
@@ -1561,3 +1561,130 @@ lldb::SBValue SBValue::Persist() {
}
return LLDB_RECORD_RESULT(persisted_sb);
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBValue>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBValue, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBValue, (const lldb::ValueObjectSP &));
+ LLDB_REGISTER_CONSTRUCTOR(SBValue, (const lldb::SBValue &));
+ LLDB_REGISTER_METHOD(lldb::SBValue &,
+ SBValue, operator=,(const lldb::SBValue &));
+ LLDB_REGISTER_METHOD(bool, SBValue, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBValue, operator bool, ());
+ LLDB_REGISTER_METHOD(void, SBValue, Clear, ());
+ LLDB_REGISTER_METHOD(lldb::SBError, SBValue, GetError, ());
+ LLDB_REGISTER_METHOD(lldb::user_id_t, SBValue, GetID, ());
+ LLDB_REGISTER_METHOD(const char *, SBValue, GetName, ());
+ LLDB_REGISTER_METHOD(const char *, SBValue, GetTypeName, ());
+ LLDB_REGISTER_METHOD(const char *, SBValue, GetDisplayTypeName, ());
+ LLDB_REGISTER_METHOD(size_t, SBValue, GetByteSize, ());
+ LLDB_REGISTER_METHOD(bool, SBValue, IsInScope, ());
+ LLDB_REGISTER_METHOD(const char *, SBValue, GetValue, ());
+ LLDB_REGISTER_METHOD(lldb::ValueType, SBValue, GetValueType, ());
+ LLDB_REGISTER_METHOD(const char *, SBValue, GetObjectDescription, ());
+ LLDB_REGISTER_METHOD(const char *, SBValue, GetTypeValidatorResult, ());
+ LLDB_REGISTER_METHOD(lldb::SBType, SBValue, GetType, ());
+ LLDB_REGISTER_METHOD(bool, SBValue, GetValueDidChange, ());
+ LLDB_REGISTER_METHOD(const char *, SBValue, GetSummary, ());
+ LLDB_REGISTER_METHOD(const char *, SBValue, GetSummary,
+ (lldb::SBStream &, lldb::SBTypeSummaryOptions &));
+ LLDB_REGISTER_METHOD(const char *, SBValue, GetLocation, ());
+ LLDB_REGISTER_METHOD(bool, SBValue, SetValueFromCString, (const char *));
+ LLDB_REGISTER_METHOD(bool, SBValue, SetValueFromCString,
+ (const char *, lldb::SBError &));
+ LLDB_REGISTER_METHOD(lldb::SBTypeFormat, SBValue, GetTypeFormat, ());
+ LLDB_REGISTER_METHOD(lldb::SBTypeSummary, SBValue, GetTypeSummary, ());
+ LLDB_REGISTER_METHOD(lldb::SBTypeFilter, SBValue, GetTypeFilter, ());
+ LLDB_REGISTER_METHOD(lldb::SBTypeSynthetic, SBValue, GetTypeSynthetic, ());
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, CreateChildAtOffset,
+ (const char *, uint32_t, lldb::SBType));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, Cast, (lldb::SBType));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, CreateValueFromExpression,
+ (const char *, const char *));
+ LLDB_REGISTER_METHOD(
+ lldb::SBValue, SBValue, CreateValueFromExpression,
+ (const char *, const char *, lldb::SBExpressionOptions &));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, CreateValueFromAddress,
+ (const char *, lldb::addr_t, lldb::SBType));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, CreateValueFromData,
+ (const char *, lldb::SBData, lldb::SBType));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetChildAtIndex, (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetChildAtIndex,
+ (uint32_t, lldb::DynamicValueType, bool));
+ LLDB_REGISTER_METHOD(uint32_t, SBValue, GetIndexOfChildWithName,
+ (const char *));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetChildMemberWithName,
+ (const char *));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetChildMemberWithName,
+ (const char *, lldb::DynamicValueType));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetDynamicValue,
+ (lldb::DynamicValueType));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetStaticValue, ());
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetNonSyntheticValue, ());
+ LLDB_REGISTER_METHOD(lldb::DynamicValueType, SBValue, GetPreferDynamicValue,
+ ());
+ LLDB_REGISTER_METHOD(void, SBValue, SetPreferDynamicValue,
+ (lldb::DynamicValueType));
+ LLDB_REGISTER_METHOD(bool, SBValue, GetPreferSyntheticValue, ());
+ LLDB_REGISTER_METHOD(void, SBValue, SetPreferSyntheticValue, (bool));
+ LLDB_REGISTER_METHOD(bool, SBValue, IsDynamic, ());
+ LLDB_REGISTER_METHOD(bool, SBValue, IsSynthetic, ());
+ LLDB_REGISTER_METHOD(bool, SBValue, IsSyntheticChildrenGenerated, ());
+ LLDB_REGISTER_METHOD(void, SBValue, SetSyntheticChildrenGenerated, (bool));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetValueForExpressionPath,
+ (const char *));
+ LLDB_REGISTER_METHOD(int64_t, SBValue, GetValueAsSigned,
+ (lldb::SBError &, int64_t));
+ LLDB_REGISTER_METHOD(uint64_t, SBValue, GetValueAsUnsigned,
+ (lldb::SBError &, uint64_t));
+ LLDB_REGISTER_METHOD(int64_t, SBValue, GetValueAsSigned, (int64_t));
+ LLDB_REGISTER_METHOD(uint64_t, SBValue, GetValueAsUnsigned, (uint64_t));
+ LLDB_REGISTER_METHOD(bool, SBValue, MightHaveChildren, ());
+ LLDB_REGISTER_METHOD(bool, SBValue, IsRuntimeSupportValue, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBValue, GetNumChildren, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBValue, GetNumChildren, (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, Dereference, ());
+ LLDB_REGISTER_METHOD(bool, SBValue, TypeIsPointerType, ());
+ LLDB_REGISTER_METHOD(void *, SBValue, GetOpaqueType, ());
+ LLDB_REGISTER_METHOD(lldb::SBTarget, SBValue, GetTarget, ());
+ LLDB_REGISTER_METHOD(lldb::SBProcess, SBValue, GetProcess, ());
+ LLDB_REGISTER_METHOD(lldb::SBThread, SBValue, GetThread, ());
+ LLDB_REGISTER_METHOD(lldb::SBFrame, SBValue, GetFrame, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::ValueObjectSP, SBValue, GetSP, ());
+ LLDB_REGISTER_METHOD(bool, SBValue, GetExpressionPath, (lldb::SBStream &));
+ LLDB_REGISTER_METHOD(bool, SBValue, GetExpressionPath,
+ (lldb::SBStream &, bool));
+ LLDB_REGISTER_METHOD_CONST(lldb::SBValue, SBValue, EvaluateExpression,
+ (const char *));
+ LLDB_REGISTER_METHOD_CONST(
+ lldb::SBValue, SBValue, EvaluateExpression,
+ (const char *, const lldb::SBExpressionOptions &));
+ LLDB_REGISTER_METHOD_CONST(
+ lldb::SBValue, SBValue, EvaluateExpression,
+ (const char *, const lldb::SBExpressionOptions &, const char *));
+ LLDB_REGISTER_METHOD(bool, SBValue, GetDescription, (lldb::SBStream &));
+ LLDB_REGISTER_METHOD(lldb::Format, SBValue, GetFormat, ());
+ LLDB_REGISTER_METHOD(void, SBValue, SetFormat, (lldb::Format));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, AddressOf, ());
+ LLDB_REGISTER_METHOD(lldb::addr_t, SBValue, GetLoadAddress, ());
+ LLDB_REGISTER_METHOD(lldb::SBAddress, SBValue, GetAddress, ());
+ LLDB_REGISTER_METHOD(lldb::SBData, SBValue, GetPointeeData,
+ (uint32_t, uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBData, SBValue, GetData, ());
+ LLDB_REGISTER_METHOD(bool, SBValue, SetData,
+ (lldb::SBData &, lldb::SBError &));
+ LLDB_REGISTER_METHOD(lldb::SBDeclaration, SBValue, GetDeclaration, ());
+ LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBValue, Watch,
+ (bool, bool, bool, lldb::SBError &));
+ LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBValue, Watch,
+ (bool, bool, bool));
+ LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBValue, WatchPointee,
+ (bool, bool, bool, lldb::SBError &));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, Persist, ());
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBValueList.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBValueList.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBValueList.cpp (original)
+++ lldb/trunk/source/API/SBValueList.cpp Tue Mar 19 10:13:13 2019
@@ -202,3 +202,30 @@ ValueListImpl &SBValueList::ref() {
CreateIfNeeded();
return *m_opaque_up;
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBValueList>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBValueList, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBValueList, (const lldb::SBValueList &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBValueList, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBValueList, operator bool, ());
+ LLDB_REGISTER_METHOD(void, SBValueList, Clear, ());
+ LLDB_REGISTER_METHOD(const lldb::SBValueList &,
+ SBValueList, operator=,(const lldb::SBValueList &));
+ LLDB_REGISTER_METHOD(void, SBValueList, Append, (const lldb::SBValue &));
+ LLDB_REGISTER_METHOD(void, SBValueList, Append,
+ (const lldb::SBValueList &));
+ LLDB_REGISTER_METHOD_CONST(lldb::SBValue, SBValueList, GetValueAtIndex,
+ (uint32_t));
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBValueList, GetSize, ());
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBValueList, FindValueObjectByUID,
+ (lldb::user_id_t));
+ LLDB_REGISTER_METHOD_CONST(lldb::SBValue, SBValueList, GetFirstValueByName,
+ (const char *));
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBVariablesOptions.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBVariablesOptions.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBVariablesOptions.cpp (original)
+++ lldb/trunk/source/API/SBVariablesOptions.cpp Tue Mar 19 10:13:13 2019
@@ -234,3 +234,43 @@ SBVariablesOptions::SBVariablesOptions(V
void SBVariablesOptions::SetOptions(VariablesOptionsImpl *lldb_object_ptr) {
m_opaque_up.reset(std::move(lldb_object_ptr));
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBVariablesOptions>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBVariablesOptions, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBVariablesOptions,
+ (const lldb::SBVariablesOptions &));
+ LLDB_REGISTER_METHOD(
+ lldb::SBVariablesOptions &,
+ SBVariablesOptions, operator=,(const lldb::SBVariablesOptions &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, operator bool, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, GetIncludeArguments,
+ ());
+ LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetIncludeArguments, (bool));
+ LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions,
+ GetIncludeRecognizedArguments,
+ (const lldb::SBTarget &));
+ LLDB_REGISTER_METHOD(void, SBVariablesOptions,
+ SetIncludeRecognizedArguments, (bool));
+ LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, GetIncludeLocals, ());
+ LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetIncludeLocals, (bool));
+ LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, GetIncludeStatics, ());
+ LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetIncludeStatics, (bool));
+ LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, GetInScopeOnly, ());
+ LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetInScopeOnly, (bool));
+ LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions,
+ GetIncludeRuntimeSupportValues, ());
+ LLDB_REGISTER_METHOD(void, SBVariablesOptions,
+ SetIncludeRuntimeSupportValues, (bool));
+ LLDB_REGISTER_METHOD_CONST(lldb::DynamicValueType, SBVariablesOptions,
+ GetUseDynamic, ());
+ LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetUseDynamic,
+ (lldb::DynamicValueType));
+}
+
+}
+}
Modified: lldb/trunk/source/API/SBWatchpoint.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBWatchpoint.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/source/API/SBWatchpoint.cpp (original)
+++ lldb/trunk/source/API/SBWatchpoint.cpp Tue Mar 19 10:13:13 2019
@@ -289,3 +289,46 @@ SBWatchpoint SBWatchpoint::GetWatchpoint
Watchpoint::WatchpointEventData::GetWatchpointFromEvent(event.GetSP());
return LLDB_RECORD_RESULT(sb_watchpoint);
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBWatchpoint>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBWatchpoint, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBWatchpoint, (const lldb::WatchpointSP &));
+ LLDB_REGISTER_CONSTRUCTOR(SBWatchpoint, (const lldb::SBWatchpoint &));
+ LLDB_REGISTER_METHOD(const lldb::SBWatchpoint &,
+ SBWatchpoint, operator=,(const lldb::SBWatchpoint &));
+ LLDB_REGISTER_METHOD(lldb::watch_id_t, SBWatchpoint, GetID, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBWatchpoint, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBWatchpoint, operator bool, ());
+ LLDB_REGISTER_METHOD(lldb::SBError, SBWatchpoint, GetError, ());
+ LLDB_REGISTER_METHOD(int32_t, SBWatchpoint, GetHardwareIndex, ());
+ LLDB_REGISTER_METHOD(lldb::addr_t, SBWatchpoint, GetWatchAddress, ());
+ LLDB_REGISTER_METHOD(size_t, SBWatchpoint, GetWatchSize, ());
+ LLDB_REGISTER_METHOD(void, SBWatchpoint, SetEnabled, (bool));
+ LLDB_REGISTER_METHOD(bool, SBWatchpoint, IsEnabled, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBWatchpoint, GetHitCount, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBWatchpoint, GetIgnoreCount, ());
+ LLDB_REGISTER_METHOD(void, SBWatchpoint, SetIgnoreCount, (uint32_t));
+ LLDB_REGISTER_METHOD(const char *, SBWatchpoint, GetCondition, ());
+ LLDB_REGISTER_METHOD(void, SBWatchpoint, SetCondition, (const char *));
+ LLDB_REGISTER_METHOD(bool, SBWatchpoint, GetDescription,
+ (lldb::SBStream &, lldb::DescriptionLevel));
+ LLDB_REGISTER_METHOD(void, SBWatchpoint, Clear, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::WatchpointSP, SBWatchpoint, GetSP, ());
+ LLDB_REGISTER_METHOD(void, SBWatchpoint, SetSP,
+ (const lldb::WatchpointSP &));
+ LLDB_REGISTER_STATIC_METHOD(bool, SBWatchpoint, EventIsWatchpointEvent,
+ (const lldb::SBEvent &));
+ LLDB_REGISTER_STATIC_METHOD(lldb::WatchpointEventType, SBWatchpoint,
+ GetWatchpointEventTypeFromEvent,
+ (const lldb::SBEvent &));
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBWatchpoint, SBWatchpoint,
+ GetWatchpointFromEvent,
+ (const lldb::SBEvent &));
+}
+
+}
+}
Modified: lldb/trunk/unittests/Utility/ReproducerInstrumentationTest.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/unittests/Utility/ReproducerInstrumentationTest.cpp?rev=356481&r1=356480&r2=356481&view=diff
==============================================================================
--- lldb/trunk/unittests/Utility/ReproducerInstrumentationTest.cpp (original)
+++ lldb/trunk/unittests/Utility/ReproducerInstrumentationTest.cpp Tue Mar 19 10:13:13 2019
@@ -222,6 +222,8 @@ void InstrumentedBar::Validate() {
}
TestingRegistry::TestingRegistry() {
+ Registry& R = *this;
+
LLDB_REGISTER_CONSTRUCTOR(InstrumentedFoo, (int i));
LLDB_REGISTER_CONSTRUCTOR(InstrumentedFoo, (const InstrumentedFoo &));
LLDB_REGISTER_METHOD(InstrumentedFoo &,
More information about the lldb-commits
mailing list