Skip to content

Commit d51402a

Browse files
JDevlieghereJDevlieghere
committed
[lldb] Remove reproducer instrumentation
This patch removes most of the reproducer instrumentation. It keeps around the LLDB_RECORD_* macros for logging. See [1] for more details. [1] https://lists.llvm.org/pipermail/lldb-dev/2021-September/017045.html Differential revision: https://reviews.llvm.org/D116847
1 parent 4a85493 commit d51402a

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

74 files changed

+77
-6208
lines changed

‎lldb/include/lldb/Utility/ReproducerInstrumentation.h

Lines changed: 4 additions & 937 deletions
Large diffs are not rendered by default.

‎lldb/source/API/SBAddress.cpp

Lines changed: 1 addition & 41 deletions
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,7 @@
77
//===----------------------------------------------------------------------===//
88

99
#include "lldb/API/SBAddress.h"
10-
#include "SBReproducerPrivate.h"
10+
#include "lldb/Utility/ReproducerInstrumentation.h"
1111
#include "Utils.h"
1212
#include "lldb/API/SBProcess.h"
1313
#include "lldb/API/SBSection.h"
@@ -275,43 +275,3 @@ SBLineEntry SBAddress::GetLineEntry() {
275275
}
276276
return LLDB_RECORD_RESULT(sb_line_entry);
277277
}
278-
279-
namespace lldb_private {
280-
namespace repro {
281-
282-
template <>
283-
void RegisterMethods<SBAddress>(Registry &R) {
284-
LLDB_REGISTER_CONSTRUCTOR(SBAddress, ());
285-
LLDB_REGISTER_CONSTRUCTOR(SBAddress, (const lldb::SBAddress &));
286-
LLDB_REGISTER_CONSTRUCTOR(SBAddress, (lldb::SBSection, lldb::addr_t));
287-
LLDB_REGISTER_CONSTRUCTOR(SBAddress, (lldb::addr_t, lldb::SBTarget &));
288-
LLDB_REGISTER_METHOD(const lldb::SBAddress &,
289-
SBAddress, operator=,(const lldb::SBAddress &));
290-
LLDB_REGISTER_METHOD_CONST(bool,
291-
SBAddress, operator!=,(const lldb::SBAddress &));
292-
LLDB_REGISTER_METHOD_CONST(bool, SBAddress, IsValid, ());
293-
LLDB_REGISTER_METHOD_CONST(bool, SBAddress, operator bool, ());
294-
LLDB_REGISTER_METHOD(void, SBAddress, Clear, ());
295-
LLDB_REGISTER_METHOD(void, SBAddress, SetAddress,
296-
(lldb::SBSection, lldb::addr_t));
297-
LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBAddress, GetFileAddress, ());
298-
LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBAddress, GetLoadAddress,
299-
(const lldb::SBTarget &));
300-
LLDB_REGISTER_METHOD(void, SBAddress, SetLoadAddress,
301-
(lldb::addr_t, lldb::SBTarget &));
302-
LLDB_REGISTER_METHOD(bool, SBAddress, OffsetAddress, (lldb::addr_t));
303-
LLDB_REGISTER_METHOD(lldb::SBSection, SBAddress, GetSection, ());
304-
LLDB_REGISTER_METHOD(lldb::addr_t, SBAddress, GetOffset, ());
305-
LLDB_REGISTER_METHOD(bool, SBAddress, GetDescription, (lldb::SBStream &));
306-
LLDB_REGISTER_METHOD(lldb::SBModule, SBAddress, GetModule, ());
307-
LLDB_REGISTER_METHOD(lldb::SBSymbolContext, SBAddress, GetSymbolContext,
308-
(uint32_t));
309-
LLDB_REGISTER_METHOD(lldb::SBCompileUnit, SBAddress, GetCompileUnit, ());
310-
LLDB_REGISTER_METHOD(lldb::SBFunction, SBAddress, GetFunction, ());
311-
LLDB_REGISTER_METHOD(lldb::SBBlock, SBAddress, GetBlock, ());
312-
LLDB_REGISTER_METHOD(lldb::SBSymbol, SBAddress, GetSymbol, ());
313-
LLDB_REGISTER_METHOD(lldb::SBLineEntry, SBAddress, GetLineEntry, ());
314-
}
315-
316-
}
317-
}

‎lldb/source/API/SBAttachInfo.cpp

Lines changed: 1 addition & 49 deletions
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,7 @@
77
//===----------------------------------------------------------------------===//
88

99
#include "lldb/API/SBAttachInfo.h"
10-
#include "SBReproducerPrivate.h"
10+
#include "lldb/Utility/ReproducerInstrumentation.h"
1111
#include "Utils.h"
1212
#include "lldb/API/SBFileSpec.h"
1313
#include "lldb/API/SBListener.h"
@@ -258,51 +258,3 @@ void SBAttachInfo::SetListener(SBListener &listener) {
258258

259259
m_opaque_sp->SetListener(listener.GetSP());
260260
}
261-
262-
namespace lldb_private {
263-
namespace repro {
264-
265-
template <>
266-
void RegisterMethods<SBAttachInfo>(Registry &R) {
267-
LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, ());
268-
LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, (lldb::pid_t));
269-
LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, (const char *, bool));
270-
LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, (const char *, bool, bool));
271-
LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, (const lldb::SBAttachInfo &));
272-
LLDB_REGISTER_METHOD(lldb::SBAttachInfo &,
273-
SBAttachInfo, operator=,(const lldb::SBAttachInfo &));
274-
LLDB_REGISTER_METHOD(lldb::pid_t, SBAttachInfo, GetProcessID, ());
275-
LLDB_REGISTER_METHOD(void, SBAttachInfo, SetProcessID, (lldb::pid_t));
276-
LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetResumeCount, ());
277-
LLDB_REGISTER_METHOD(void, SBAttachInfo, SetResumeCount, (uint32_t));
278-
LLDB_REGISTER_METHOD(const char *, SBAttachInfo, GetProcessPluginName, ());
279-
LLDB_REGISTER_METHOD(void, SBAttachInfo, SetProcessPluginName,
280-
(const char *));
281-
LLDB_REGISTER_METHOD(void, SBAttachInfo, SetExecutable, (const char *));
282-
LLDB_REGISTER_METHOD(void, SBAttachInfo, SetExecutable, (lldb::SBFileSpec));
283-
LLDB_REGISTER_METHOD(bool, SBAttachInfo, GetWaitForLaunch, ());
284-
LLDB_REGISTER_METHOD(void, SBAttachInfo, SetWaitForLaunch, (bool));
285-
LLDB_REGISTER_METHOD(void, SBAttachInfo, SetWaitForLaunch, (bool, bool));
286-
LLDB_REGISTER_METHOD(bool, SBAttachInfo, GetIgnoreExisting, ());
287-
LLDB_REGISTER_METHOD(void, SBAttachInfo, SetIgnoreExisting, (bool));
288-
LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetUserID, ());
289-
LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetGroupID, ());
290-
LLDB_REGISTER_METHOD(bool, SBAttachInfo, UserIDIsValid, ());
291-
LLDB_REGISTER_METHOD(bool, SBAttachInfo, GroupIDIsValid, ());
292-
LLDB_REGISTER_METHOD(void, SBAttachInfo, SetUserID, (uint32_t));
293-
LLDB_REGISTER_METHOD(void, SBAttachInfo, SetGroupID, (uint32_t));
294-
LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetEffectiveUserID, ());
295-
LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetEffectiveGroupID, ());
296-
LLDB_REGISTER_METHOD(bool, SBAttachInfo, EffectiveUserIDIsValid, ());
297-
LLDB_REGISTER_METHOD(bool, SBAttachInfo, EffectiveGroupIDIsValid, ());
298-
LLDB_REGISTER_METHOD(void, SBAttachInfo, SetEffectiveUserID, (uint32_t));
299-
LLDB_REGISTER_METHOD(void, SBAttachInfo, SetEffectiveGroupID, (uint32_t));
300-
LLDB_REGISTER_METHOD(lldb::pid_t, SBAttachInfo, GetParentProcessID, ());
301-
LLDB_REGISTER_METHOD(void, SBAttachInfo, SetParentProcessID, (lldb::pid_t));
302-
LLDB_REGISTER_METHOD(bool, SBAttachInfo, ParentProcessIDIsValid, ());
303-
LLDB_REGISTER_METHOD(lldb::SBListener, SBAttachInfo, GetListener, ());
304-
LLDB_REGISTER_METHOD(void, SBAttachInfo, SetListener, (lldb::SBListener &));
305-
}
306-
307-
}
308-
}

‎lldb/source/API/SBBlock.cpp

Lines changed: 1 addition & 40 deletions
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,7 @@
77
//===----------------------------------------------------------------------===//
88

99
#include "lldb/API/SBBlock.h"
10-
#include "SBReproducerPrivate.h"
10+
#include "lldb/Utility/ReproducerInstrumentation.h"
1111
#include "lldb/API/SBAddress.h"
1212
#include "lldb/API/SBFileSpec.h"
1313
#include "lldb/API/SBFrame.h"
@@ -343,42 +343,3 @@ lldb::SBValueList SBBlock::GetVariables(lldb::SBTarget &target, bool arguments,
343343
}
344344
return LLDB_RECORD_RESULT(value_list);
345345
}
346-
347-
namespace lldb_private {
348-
namespace repro {
349-
350-
template <>
351-
void RegisterMethods<SBBlock>(Registry &R) {
352-
LLDB_REGISTER_CONSTRUCTOR(SBBlock, ());
353-
LLDB_REGISTER_CONSTRUCTOR(SBBlock, (const lldb::SBBlock &));
354-
LLDB_REGISTER_METHOD(const lldb::SBBlock &,
355-
SBBlock, operator=,(const lldb::SBBlock &));
356-
LLDB_REGISTER_METHOD_CONST(bool, SBBlock, IsValid, ());
357-
LLDB_REGISTER_METHOD_CONST(bool, SBBlock, operator bool, ());
358-
LLDB_REGISTER_METHOD_CONST(bool, SBBlock, IsInlined, ());
359-
LLDB_REGISTER_METHOD_CONST(const char *, SBBlock, GetInlinedName, ());
360-
LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBBlock,
361-
GetInlinedCallSiteFile, ());
362-
LLDB_REGISTER_METHOD_CONST(uint32_t, SBBlock, GetInlinedCallSiteLine, ());
363-
LLDB_REGISTER_METHOD_CONST(uint32_t, SBBlock, GetInlinedCallSiteColumn, ());
364-
LLDB_REGISTER_METHOD(lldb::SBBlock, SBBlock, GetParent, ());
365-
LLDB_REGISTER_METHOD(lldb::SBBlock, SBBlock, GetContainingInlinedBlock, ());
366-
LLDB_REGISTER_METHOD(lldb::SBBlock, SBBlock, GetSibling, ());
367-
LLDB_REGISTER_METHOD(lldb::SBBlock, SBBlock, GetFirstChild, ());
368-
LLDB_REGISTER_METHOD(bool, SBBlock, GetDescription, (lldb::SBStream &));
369-
LLDB_REGISTER_METHOD(uint32_t, SBBlock, GetNumRanges, ());
370-
LLDB_REGISTER_METHOD(lldb::SBAddress, SBBlock, GetRangeStartAddress,
371-
(uint32_t));
372-
LLDB_REGISTER_METHOD(lldb::SBAddress, SBBlock, GetRangeEndAddress,
373-
(uint32_t));
374-
LLDB_REGISTER_METHOD(uint32_t, SBBlock, GetRangeIndexForBlockAddress,
375-
(lldb::SBAddress));
376-
LLDB_REGISTER_METHOD(
377-
lldb::SBValueList, SBBlock, GetVariables,
378-
(lldb::SBFrame &, bool, bool, bool, lldb::DynamicValueType));
379-
LLDB_REGISTER_METHOD(lldb::SBValueList, SBBlock, GetVariables,
380-
(lldb::SBTarget &, bool, bool, bool));
381-
}
382-
383-
}
384-
}

‎lldb/source/API/SBBreakpoint.cpp

Lines changed: 1 addition & 112 deletions
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,7 @@
77
//===----------------------------------------------------------------------===//
88

99
#include "lldb/API/SBBreakpoint.h"
10-
#include "SBReproducerPrivate.h"
10+
#include "lldb/Utility/ReproducerInstrumentation.h"
1111
#include "lldb/API/SBBreakpointLocation.h"
1212
#include "lldb/API/SBDebugger.h"
1313
#include "lldb/API/SBEvent.h"
@@ -982,114 +982,3 @@ void SBBreakpointList::CopyToBreakpointIDList(
982982
if (m_opaque_sp)
983983
m_opaque_sp->CopyToBreakpointIDList(bp_id_list);
984984
}
985-
986-
namespace lldb_private {
987-
namespace repro {
988-
989-
template <>
990-
void RegisterMethods<SBBreakpoint>(Registry &R) {
991-
LLDB_REGISTER_CONSTRUCTOR(SBBreakpoint, ());
992-
LLDB_REGISTER_CONSTRUCTOR(SBBreakpoint, (const lldb::SBBreakpoint &));
993-
LLDB_REGISTER_CONSTRUCTOR(SBBreakpoint, (const lldb::BreakpointSP &));
994-
LLDB_REGISTER_METHOD(const lldb::SBBreakpoint &,
995-
SBBreakpoint, operator=,(const lldb::SBBreakpoint &));
996-
LLDB_REGISTER_METHOD(bool,
997-
SBBreakpoint, operator==,(const lldb::SBBreakpoint &));
998-
LLDB_REGISTER_METHOD(bool,
999-
SBBreakpoint, operator!=,(const lldb::SBBreakpoint &));
1000-
LLDB_REGISTER_METHOD_CONST(lldb::SBTarget, SBBreakpoint, GetTarget, ());
1001-
LLDB_REGISTER_METHOD_CONST(lldb::break_id_t, SBBreakpoint, GetID, ());
1002-
LLDB_REGISTER_METHOD_CONST(bool, SBBreakpoint, IsValid, ());
1003-
LLDB_REGISTER_METHOD_CONST(bool, SBBreakpoint, operator bool, ());
1004-
LLDB_REGISTER_METHOD(void, SBBreakpoint, ClearAllBreakpointSites, ());
1005-
LLDB_REGISTER_METHOD(lldb::SBBreakpointLocation, SBBreakpoint,
1006-
FindLocationByAddress, (lldb::addr_t));
1007-
LLDB_REGISTER_METHOD(lldb::break_id_t, SBBreakpoint,
1008-
FindLocationIDByAddress, (lldb::addr_t));
1009-
LLDB_REGISTER_METHOD(lldb::SBBreakpointLocation, SBBreakpoint,
1010-
FindLocationByID, (lldb::break_id_t));
1011-
LLDB_REGISTER_METHOD(lldb::SBBreakpointLocation, SBBreakpoint,
1012-
GetLocationAtIndex, (uint32_t));
1013-
LLDB_REGISTER_METHOD(void, SBBreakpoint, SetEnabled, (bool));
1014-
LLDB_REGISTER_METHOD(bool, SBBreakpoint, IsEnabled, ());
1015-
LLDB_REGISTER_METHOD(void, SBBreakpoint, SetOneShot, (bool));
1016-
LLDB_REGISTER_METHOD_CONST(bool, SBBreakpoint, IsOneShot, ());
1017-
LLDB_REGISTER_METHOD(bool, SBBreakpoint, IsInternal, ());
1018-
LLDB_REGISTER_METHOD(void, SBBreakpoint, SetIgnoreCount, (uint32_t));
1019-
LLDB_REGISTER_METHOD(void, SBBreakpoint, SetCondition, (const char *));
1020-
LLDB_REGISTER_METHOD(const char *, SBBreakpoint, GetCondition, ());
1021-
LLDB_REGISTER_METHOD(void, SBBreakpoint, SetAutoContinue, (bool));
1022-
LLDB_REGISTER_METHOD(bool, SBBreakpoint, GetAutoContinue, ());
1023-
LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpoint, GetHitCount, ());
1024-
LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpoint, GetIgnoreCount, ());
1025-
LLDB_REGISTER_METHOD(void, SBBreakpoint, SetThreadID, (lldb::tid_t));
1026-
LLDB_REGISTER_METHOD(lldb::tid_t, SBBreakpoint, GetThreadID, ());
1027-
LLDB_REGISTER_METHOD(void, SBBreakpoint, SetThreadIndex, (uint32_t));
1028-
LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpoint, GetThreadIndex, ());
1029-
LLDB_REGISTER_METHOD(void, SBBreakpoint, SetThreadName, (const char *));
1030-
LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpoint, GetThreadName, ());
1031-
LLDB_REGISTER_METHOD(void, SBBreakpoint, SetQueueName, (const char *));
1032-
LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpoint, GetQueueName, ());
1033-
LLDB_REGISTER_METHOD_CONST(size_t, SBBreakpoint, GetNumResolvedLocations,
1034-
());
1035-
LLDB_REGISTER_METHOD_CONST(size_t, SBBreakpoint, GetNumLocations, ());
1036-
LLDB_REGISTER_METHOD(void, SBBreakpoint, SetCommandLineCommands,
1037-
(lldb::SBStringList &));
1038-
LLDB_REGISTER_METHOD(bool, SBBreakpoint, GetCommandLineCommands,
1039-
(lldb::SBStringList &));
1040-
LLDB_REGISTER_METHOD(bool, SBBreakpoint, GetDescription,
1041-
(lldb::SBStream &));
1042-
LLDB_REGISTER_METHOD(bool, SBBreakpoint, GetDescription,
1043-
(lldb::SBStream &, bool));
1044-
LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpoint, AddLocation,
1045-
(lldb::SBAddress &));
1046-
LLDB_REGISTER_METHOD(lldb::SBStructuredData, SBBreakpoint,
1047-
SerializeToStructuredData, ());
1048-
LLDB_REGISTER_METHOD(void, SBBreakpoint, SetScriptCallbackFunction,
1049-
(const char *));
1050-
LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpoint, SetScriptCallbackFunction,
1051-
(const char *, SBStructuredData &));
1052-
LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpoint, SetScriptCallbackBody,
1053-
(const char *));
1054-
LLDB_REGISTER_METHOD(bool, SBBreakpoint, AddName, (const char *));
1055-
LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpoint, AddNameWithErrorHandling,
1056-
(const char *));
1057-
LLDB_REGISTER_METHOD(void, SBBreakpoint, RemoveName, (const char *));
1058-
LLDB_REGISTER_METHOD(bool, SBBreakpoint, MatchesName, (const char *));
1059-
LLDB_REGISTER_METHOD(void, SBBreakpoint, GetNames, (lldb::SBStringList &));
1060-
LLDB_REGISTER_STATIC_METHOD(bool, SBBreakpoint, EventIsBreakpointEvent,
1061-
(const lldb::SBEvent &));
1062-
LLDB_REGISTER_STATIC_METHOD(lldb::BreakpointEventType, SBBreakpoint,
1063-
GetBreakpointEventTypeFromEvent,
1064-
(const lldb::SBEvent &));
1065-
LLDB_REGISTER_STATIC_METHOD(lldb::SBBreakpoint, SBBreakpoint,
1066-
GetBreakpointFromEvent,
1067-
(const lldb::SBEvent &));
1068-
LLDB_REGISTER_STATIC_METHOD(lldb::SBBreakpointLocation, SBBreakpoint,
1069-
GetBreakpointLocationAtIndexFromEvent,
1070-
(const lldb::SBEvent &, uint32_t));
1071-
LLDB_REGISTER_STATIC_METHOD(uint32_t, SBBreakpoint,
1072-
GetNumBreakpointLocationsFromEvent,
1073-
(const lldb::SBEvent &));
1074-
LLDB_REGISTER_METHOD_CONST(bool, SBBreakpoint, IsHardware, ());
1075-
}
1076-
1077-
template <>
1078-
void RegisterMethods<SBBreakpointList>(Registry &R) {
1079-
LLDB_REGISTER_CONSTRUCTOR(SBBreakpointList, (lldb::SBTarget &));
1080-
LLDB_REGISTER_METHOD_CONST(size_t, SBBreakpointList, GetSize, ());
1081-
LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBBreakpointList,
1082-
GetBreakpointAtIndex, (size_t));
1083-
LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBBreakpointList,
1084-
FindBreakpointByID, (lldb::break_id_t));
1085-
LLDB_REGISTER_METHOD(void, SBBreakpointList, Append,
1086-
(const lldb::SBBreakpoint &));
1087-
LLDB_REGISTER_METHOD(void, SBBreakpointList, AppendByID,
1088-
(lldb::break_id_t));
1089-
LLDB_REGISTER_METHOD(bool, SBBreakpointList, AppendIfUnique,
1090-
(const lldb::SBBreakpoint &));
1091-
LLDB_REGISTER_METHOD(void, SBBreakpointList, Clear, ());
1092-
}
1093-
1094-
}
1095-
}

‎lldb/source/API/SBBreakpointLocation.cpp

Lines changed: 1 addition & 66 deletions
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,7 @@
77
//===----------------------------------------------------------------------===//
88

99
#include "lldb/API/SBBreakpointLocation.h"
10-
#include "SBReproducerPrivate.h"
10+
#include "lldb/Utility/ReproducerInstrumentation.h"
1111
#include "lldb/API/SBAddress.h"
1212
#include "lldb/API/SBDebugger.h"
1313
#include "lldb/API/SBDefines.h"
@@ -467,68 +467,3 @@ SBBreakpoint SBBreakpointLocation::GetBreakpoint() {
467467

468468
return LLDB_RECORD_RESULT(sb_bp);
469469
}
470-
471-
namespace lldb_private {
472-
namespace repro {
473-
474-
template <>
475-
void RegisterMethods<SBBreakpointLocation>(Registry &R) {
476-
LLDB_REGISTER_CONSTRUCTOR(SBBreakpointLocation, ());
477-
LLDB_REGISTER_CONSTRUCTOR(SBBreakpointLocation,
478-
(const lldb::BreakpointLocationSP &));
479-
LLDB_REGISTER_CONSTRUCTOR(SBBreakpointLocation,
480-
(const lldb::SBBreakpointLocation &));
481-
LLDB_REGISTER_METHOD(
482-
const lldb::SBBreakpointLocation &,
483-
SBBreakpointLocation, operator=,(const lldb::SBBreakpointLocation &));
484-
LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointLocation, IsValid, ());
485-
LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointLocation, operator bool, ());
486-
LLDB_REGISTER_METHOD(lldb::SBAddress, SBBreakpointLocation, GetAddress, ());
487-
LLDB_REGISTER_METHOD(lldb::addr_t, SBBreakpointLocation, GetLoadAddress,
488-
());
489-
LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetEnabled, (bool));
490-
LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, IsEnabled, ());
491-
LLDB_REGISTER_METHOD(uint32_t, SBBreakpointLocation, GetHitCount, ());
492-
LLDB_REGISTER_METHOD(uint32_t, SBBreakpointLocation, GetIgnoreCount, ());
493-
LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetIgnoreCount,
494-
(uint32_t));
495-
LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetCondition,
496-
(const char *));
497-
LLDB_REGISTER_METHOD(const char *, SBBreakpointLocation, GetCondition, ());
498-
LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetAutoContinue, (bool));
499-
LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, GetAutoContinue, ());
500-
LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetScriptCallbackFunction,
501-
(const char *));
502-
LLDB_REGISTER_METHOD(SBError, SBBreakpointLocation, SetScriptCallbackFunction,
503-
(const char *, SBStructuredData &));
504-
LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpointLocation,
505-
SetScriptCallbackBody, (const char *));
506-
LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetCommandLineCommands,
507-
(lldb::SBStringList &));
508-
LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, GetCommandLineCommands,
509-
(lldb::SBStringList &));
510-
LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetThreadID,
511-
(lldb::tid_t));
512-
LLDB_REGISTER_METHOD(lldb::tid_t, SBBreakpointLocation, GetThreadID, ());
513-
LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetThreadIndex,
514-
(uint32_t));
515-
LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpointLocation, GetThreadIndex,
516-
());
517-
LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetThreadName,
518-
(const char *));
519-
LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointLocation,
520-
GetThreadName, ());
521-
LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetQueueName,
522-
(const char *));
523-
LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointLocation, GetQueueName,
524-
());
525-
LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, IsResolved, ());
526-
LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, GetDescription,
527-
(lldb::SBStream &, lldb::DescriptionLevel));
528-
LLDB_REGISTER_METHOD(lldb::break_id_t, SBBreakpointLocation, GetID, ());
529-
LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBBreakpointLocation,
530-
GetBreakpoint, ());
531-
}
532-
533-
}
534-
}

0 commit comments

Comments
 (0)