1 //===-- SBReproducer.cpp ----------------------------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "SBReproducerPrivate.h"
10 
11 #include "SBReproducerPrivate.h"
12 #include "lldb/API/LLDB.h"
13 #include "lldb/API/SBAddress.h"
14 #include "lldb/API/SBAttachInfo.h"
15 #include "lldb/API/SBBlock.h"
16 #include "lldb/API/SBBreakpoint.h"
17 #include "lldb/API/SBCommandInterpreter.h"
18 #include "lldb/API/SBData.h"
19 #include "lldb/API/SBDebugger.h"
20 #include "lldb/API/SBDeclaration.h"
21 #include "lldb/API/SBError.h"
22 #include "lldb/API/SBFileSpec.h"
23 #include "lldb/API/SBHostOS.h"
24 #include "lldb/API/SBReproducer.h"
25 
26 #include "lldb/Host/FileSystem.h"
27 
28 using namespace lldb;
29 using namespace lldb_private;
30 using namespace lldb_private::repro;
31 
32 static void SetFileHandleRedirect(SBDebugger *, FILE *, bool) {
33   // Do nothing.
34 }
35 
36 static bool GetDefaultArchitectureRedirect(char *arch_name,
37                                            size_t arch_name_len) {
38   // The function is writing to its argument. Without the redirect it would
39   // write into the replay buffer.
40   char buffer[1024];
41   return SBDebugger::GetDefaultArchitecture(buffer, arch_name_len);
42 }
43 
44 SBRegistry::SBRegistry() {
45 
46   // Custom implementation.
47   Register(&invoke<void (SBDebugger::*)(
48                FILE *, bool)>::method<&SBDebugger::SetErrorFileHandle>::doit,
49            &SetFileHandleRedirect);
50   Register(&invoke<void (SBDebugger::*)(
51                FILE *, bool)>::method<&SBDebugger::SetOutputFileHandle>::doit,
52            &SetFileHandleRedirect);
53   Register<bool(char *, size_t)>(static_cast<bool (*)(char *, size_t)>(
54                                      &SBDebugger::GetDefaultArchitecture),
55                                  &GetDefaultArchitectureRedirect);
56 
57   {
58     LLDB_REGISTER_CONSTRUCTOR(SBAddress, ());
59     LLDB_REGISTER_CONSTRUCTOR(SBAddress, (const lldb::SBAddress &));
60     LLDB_REGISTER_CONSTRUCTOR(SBAddress, (lldb::SBSection, lldb::addr_t));
61     LLDB_REGISTER_CONSTRUCTOR(SBAddress, (lldb::addr_t, lldb::SBTarget &));
62     LLDB_REGISTER_METHOD(const lldb::SBAddress &,
63                          SBAddress, operator=,(const lldb::SBAddress &));
64     LLDB_REGISTER_METHOD_CONST(bool, SBAddress, IsValid, ());
65     LLDB_REGISTER_METHOD_CONST(bool, SBAddress, operator bool, ());
66     LLDB_REGISTER_METHOD(void, SBAddress, Clear, ());
67     LLDB_REGISTER_METHOD(void, SBAddress, SetAddress,
68                          (lldb::SBSection, lldb::addr_t));
69     LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBAddress, GetFileAddress, ());
70     LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBAddress, GetLoadAddress,
71                                (const lldb::SBTarget &));
72     LLDB_REGISTER_METHOD(void, SBAddress, SetLoadAddress,
73                          (lldb::addr_t, lldb::SBTarget &));
74     LLDB_REGISTER_METHOD(bool, SBAddress, OffsetAddress, (lldb::addr_t));
75     LLDB_REGISTER_METHOD(lldb::SBSection, SBAddress, GetSection, ());
76     LLDB_REGISTER_METHOD(lldb::addr_t, SBAddress, GetOffset, ());
77     LLDB_REGISTER_METHOD(bool, SBAddress, GetDescription, (lldb::SBStream &));
78     LLDB_REGISTER_METHOD(lldb::SBModule, SBAddress, GetModule, ());
79     LLDB_REGISTER_METHOD(lldb::SBSymbolContext, SBAddress, GetSymbolContext,
80                          (uint32_t));
81     LLDB_REGISTER_METHOD(lldb::SBCompileUnit, SBAddress, GetCompileUnit, ());
82     LLDB_REGISTER_METHOD(lldb::SBFunction, SBAddress, GetFunction, ());
83     LLDB_REGISTER_METHOD(lldb::SBBlock, SBAddress, GetBlock, ());
84     LLDB_REGISTER_METHOD(lldb::SBSymbol, SBAddress, GetSymbol, ());
85     LLDB_REGISTER_METHOD(lldb::SBLineEntry, SBAddress, GetLineEntry, ());
86   }
87   {
88     LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, ());
89     LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, (lldb::pid_t));
90     LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, (const char *, bool));
91     LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, (const char *, bool, bool));
92     LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, (const lldb::SBAttachInfo &));
93     LLDB_REGISTER_METHOD(lldb::SBAttachInfo &,
94                          SBAttachInfo, operator=,(const lldb::SBAttachInfo &));
95     LLDB_REGISTER_METHOD(lldb::pid_t, SBAttachInfo, GetProcessID, ());
96     LLDB_REGISTER_METHOD(void, SBAttachInfo, SetProcessID, (lldb::pid_t));
97     LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetResumeCount, ());
98     LLDB_REGISTER_METHOD(void, SBAttachInfo, SetResumeCount, (uint32_t));
99     LLDB_REGISTER_METHOD(const char *, SBAttachInfo, GetProcessPluginName, ());
100     LLDB_REGISTER_METHOD(void, SBAttachInfo, SetProcessPluginName,
101                          (const char *));
102     LLDB_REGISTER_METHOD(void, SBAttachInfo, SetExecutable, (const char *));
103     LLDB_REGISTER_METHOD(void, SBAttachInfo, SetExecutable, (lldb::SBFileSpec));
104     LLDB_REGISTER_METHOD(bool, SBAttachInfo, GetWaitForLaunch, ());
105     LLDB_REGISTER_METHOD(void, SBAttachInfo, SetWaitForLaunch, (bool));
106     LLDB_REGISTER_METHOD(void, SBAttachInfo, SetWaitForLaunch, (bool, bool));
107     LLDB_REGISTER_METHOD(bool, SBAttachInfo, GetIgnoreExisting, ());
108     LLDB_REGISTER_METHOD(void, SBAttachInfo, SetIgnoreExisting, (bool));
109     LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetUserID, ());
110     LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetGroupID, ());
111     LLDB_REGISTER_METHOD(bool, SBAttachInfo, UserIDIsValid, ());
112     LLDB_REGISTER_METHOD(bool, SBAttachInfo, GroupIDIsValid, ());
113     LLDB_REGISTER_METHOD(void, SBAttachInfo, SetUserID, (uint32_t));
114     LLDB_REGISTER_METHOD(void, SBAttachInfo, SetGroupID, (uint32_t));
115     LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetEffectiveUserID, ());
116     LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetEffectiveGroupID, ());
117     LLDB_REGISTER_METHOD(bool, SBAttachInfo, EffectiveUserIDIsValid, ());
118     LLDB_REGISTER_METHOD(bool, SBAttachInfo, EffectiveGroupIDIsValid, ());
119     LLDB_REGISTER_METHOD(void, SBAttachInfo, SetEffectiveUserID, (uint32_t));
120     LLDB_REGISTER_METHOD(void, SBAttachInfo, SetEffectiveGroupID, (uint32_t));
121     LLDB_REGISTER_METHOD(lldb::pid_t, SBAttachInfo, GetParentProcessID, ());
122     LLDB_REGISTER_METHOD(void, SBAttachInfo, SetParentProcessID, (lldb::pid_t));
123     LLDB_REGISTER_METHOD(bool, SBAttachInfo, ParentProcessIDIsValid, ());
124     LLDB_REGISTER_METHOD(lldb::SBListener, SBAttachInfo, GetListener, ());
125     LLDB_REGISTER_METHOD(void, SBAttachInfo, SetListener, (lldb::SBListener &));
126   }
127   {
128     LLDB_REGISTER_CONSTRUCTOR(SBBlock, ());
129     LLDB_REGISTER_CONSTRUCTOR(SBBlock, (const lldb::SBBlock &));
130     LLDB_REGISTER_METHOD(const lldb::SBBlock &,
131                          SBBlock, operator=,(const lldb::SBBlock &));
132     LLDB_REGISTER_METHOD_CONST(bool, SBBlock, IsValid, ());
133     LLDB_REGISTER_METHOD_CONST(bool, SBBlock, operator bool, ());
134     LLDB_REGISTER_METHOD_CONST(bool, SBBlock, IsInlined, ());
135     LLDB_REGISTER_METHOD_CONST(const char *, SBBlock, GetInlinedName, ());
136     LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBBlock,
137                                GetInlinedCallSiteFile, ());
138     LLDB_REGISTER_METHOD_CONST(uint32_t, SBBlock, GetInlinedCallSiteLine, ());
139     LLDB_REGISTER_METHOD_CONST(uint32_t, SBBlock, GetInlinedCallSiteColumn, ());
140     LLDB_REGISTER_METHOD(lldb::SBBlock, SBBlock, GetParent, ());
141     LLDB_REGISTER_METHOD(lldb::SBBlock, SBBlock, GetContainingInlinedBlock, ());
142     LLDB_REGISTER_METHOD(lldb::SBBlock, SBBlock, GetSibling, ());
143     LLDB_REGISTER_METHOD(lldb::SBBlock, SBBlock, GetFirstChild, ());
144     LLDB_REGISTER_METHOD(bool, SBBlock, GetDescription, (lldb::SBStream &));
145     LLDB_REGISTER_METHOD(uint32_t, SBBlock, GetNumRanges, ());
146     LLDB_REGISTER_METHOD(lldb::SBAddress, SBBlock, GetRangeStartAddress,
147                          (uint32_t));
148     LLDB_REGISTER_METHOD(lldb::SBAddress, SBBlock, GetRangeEndAddress,
149                          (uint32_t));
150     LLDB_REGISTER_METHOD(uint32_t, SBBlock, GetRangeIndexForBlockAddress,
151                          (lldb::SBAddress));
152     LLDB_REGISTER_METHOD(
153         lldb::SBValueList, SBBlock, GetVariables,
154         (lldb::SBFrame &, bool, bool, bool, lldb::DynamicValueType));
155     LLDB_REGISTER_METHOD(lldb::SBValueList, SBBlock, GetVariables,
156                          (lldb::SBTarget &, bool, bool, bool));
157   }
158   {
159     LLDB_REGISTER_CONSTRUCTOR(SBBreakpoint, ());
160     LLDB_REGISTER_CONSTRUCTOR(SBBreakpoint, (const lldb::SBBreakpoint &));
161     LLDB_REGISTER_CONSTRUCTOR(SBBreakpoint, (const lldb::BreakpointSP &));
162     LLDB_REGISTER_METHOD(const lldb::SBBreakpoint &,
163                          SBBreakpoint, operator=,(const lldb::SBBreakpoint &));
164     LLDB_REGISTER_METHOD(bool,
165                          SBBreakpoint, operator==,(const lldb::SBBreakpoint &));
166     LLDB_REGISTER_METHOD(bool,
167                          SBBreakpoint, operator!=,(const lldb::SBBreakpoint &));
168     LLDB_REGISTER_METHOD_CONST(lldb::break_id_t, SBBreakpoint, GetID, ());
169     LLDB_REGISTER_METHOD_CONST(bool, SBBreakpoint, IsValid, ());
170     LLDB_REGISTER_METHOD_CONST(bool, SBBreakpoint, operator bool, ());
171     LLDB_REGISTER_METHOD(void, SBBreakpoint, ClearAllBreakpointSites, ());
172     LLDB_REGISTER_METHOD(lldb::SBBreakpointLocation, SBBreakpoint,
173                          FindLocationByAddress, (lldb::addr_t));
174     LLDB_REGISTER_METHOD(lldb::break_id_t, SBBreakpoint,
175                          FindLocationIDByAddress, (lldb::addr_t));
176     LLDB_REGISTER_METHOD(lldb::SBBreakpointLocation, SBBreakpoint,
177                          FindLocationByID, (lldb::break_id_t));
178     LLDB_REGISTER_METHOD(lldb::SBBreakpointLocation, SBBreakpoint,
179                          GetLocationAtIndex, (uint32_t));
180     LLDB_REGISTER_METHOD(void, SBBreakpoint, SetEnabled, (bool));
181     LLDB_REGISTER_METHOD(bool, SBBreakpoint, IsEnabled, ());
182     LLDB_REGISTER_METHOD(void, SBBreakpoint, SetOneShot, (bool));
183     LLDB_REGISTER_METHOD_CONST(bool, SBBreakpoint, IsOneShot, ());
184     LLDB_REGISTER_METHOD(bool, SBBreakpoint, IsInternal, ());
185     LLDB_REGISTER_METHOD(void, SBBreakpoint, SetIgnoreCount, (uint32_t));
186     LLDB_REGISTER_METHOD(void, SBBreakpoint, SetCondition, (const char *));
187     LLDB_REGISTER_METHOD(const char *, SBBreakpoint, GetCondition, ());
188     LLDB_REGISTER_METHOD(void, SBBreakpoint, SetAutoContinue, (bool));
189     LLDB_REGISTER_METHOD(bool, SBBreakpoint, GetAutoContinue, ());
190     LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpoint, GetHitCount, ());
191     LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpoint, GetIgnoreCount, ());
192     LLDB_REGISTER_METHOD(void, SBBreakpoint, SetThreadID, (lldb::tid_t));
193     LLDB_REGISTER_METHOD(lldb::tid_t, SBBreakpoint, GetThreadID, ());
194     LLDB_REGISTER_METHOD(void, SBBreakpoint, SetThreadIndex, (uint32_t));
195     LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpoint, GetThreadIndex, ());
196     LLDB_REGISTER_METHOD(void, SBBreakpoint, SetThreadName, (const char *));
197     LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpoint, GetThreadName, ());
198     LLDB_REGISTER_METHOD(void, SBBreakpoint, SetQueueName, (const char *));
199     LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpoint, GetQueueName, ());
200     LLDB_REGISTER_METHOD_CONST(size_t, SBBreakpoint, GetNumResolvedLocations,
201                                ());
202     LLDB_REGISTER_METHOD_CONST(size_t, SBBreakpoint, GetNumLocations, ());
203     LLDB_REGISTER_METHOD(void, SBBreakpoint, SetCommandLineCommands,
204                          (lldb::SBStringList &));
205     LLDB_REGISTER_METHOD(bool, SBBreakpoint, GetCommandLineCommands,
206                          (lldb::SBStringList &));
207     LLDB_REGISTER_METHOD(bool, SBBreakpoint, GetDescription,
208                          (lldb::SBStream &));
209     LLDB_REGISTER_METHOD(bool, SBBreakpoint, GetDescription,
210                          (lldb::SBStream &, bool));
211     LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpoint, AddLocation,
212                          (lldb::SBAddress &));
213     LLDB_REGISTER_METHOD(void, SBBreakpoint, SetScriptCallbackFunction,
214                          (const char *));
215     LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpoint, SetScriptCallbackBody,
216                          (const char *));
217     LLDB_REGISTER_METHOD(bool, SBBreakpoint, AddName, (const char *));
218     LLDB_REGISTER_METHOD(void, SBBreakpoint, RemoveName, (const char *));
219     LLDB_REGISTER_METHOD(bool, SBBreakpoint, MatchesName, (const char *));
220     LLDB_REGISTER_METHOD(void, SBBreakpoint, GetNames, (lldb::SBStringList &));
221     LLDB_REGISTER_STATIC_METHOD(bool, SBBreakpoint, EventIsBreakpointEvent,
222                                 (const lldb::SBEvent &));
223     LLDB_REGISTER_STATIC_METHOD(lldb::BreakpointEventType, SBBreakpoint,
224                                 GetBreakpointEventTypeFromEvent,
225                                 (const lldb::SBEvent &));
226     LLDB_REGISTER_STATIC_METHOD(lldb::SBBreakpoint, SBBreakpoint,
227                                 GetBreakpointFromEvent,
228                                 (const lldb::SBEvent &));
229     LLDB_REGISTER_STATIC_METHOD(lldb::SBBreakpointLocation, SBBreakpoint,
230                                 GetBreakpointLocationAtIndexFromEvent,
231                                 (const lldb::SBEvent &, uint32_t));
232     LLDB_REGISTER_STATIC_METHOD(uint32_t, SBBreakpoint,
233                                 GetNumBreakpointLocationsFromEvent,
234                                 (const lldb::SBEvent &));
235     LLDB_REGISTER_METHOD_CONST(bool, SBBreakpoint, IsHardware, ());
236     LLDB_REGISTER_CONSTRUCTOR(SBBreakpointList, (lldb::SBTarget &));
237     LLDB_REGISTER_METHOD_CONST(size_t, SBBreakpointList, GetSize, ());
238     LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBBreakpointList,
239                          GetBreakpointAtIndex, (size_t));
240     LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBBreakpointList,
241                          FindBreakpointByID, (lldb::break_id_t));
242     LLDB_REGISTER_METHOD(void, SBBreakpointList, Append,
243                          (const lldb::SBBreakpoint &));
244     LLDB_REGISTER_METHOD(void, SBBreakpointList, AppendByID,
245                          (lldb::break_id_t));
246     LLDB_REGISTER_METHOD(bool, SBBreakpointList, AppendIfUnique,
247                          (const lldb::SBBreakpoint &));
248     LLDB_REGISTER_METHOD(void, SBBreakpointList, Clear, ());
249   }
250   {
251     LLDB_REGISTER_CONSTRUCTOR(SBBreakpointLocation, ());
252     LLDB_REGISTER_CONSTRUCTOR(SBBreakpointLocation,
253                               (const lldb::BreakpointLocationSP &));
254     LLDB_REGISTER_CONSTRUCTOR(SBBreakpointLocation,
255                               (const lldb::SBBreakpointLocation &));
256     LLDB_REGISTER_METHOD(
257         const lldb::SBBreakpointLocation &,
258         SBBreakpointLocation, operator=,(const lldb::SBBreakpointLocation &));
259     LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointLocation, IsValid, ());
260     LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointLocation, operator bool, ());
261     LLDB_REGISTER_METHOD(lldb::SBAddress, SBBreakpointLocation, GetAddress, ());
262     LLDB_REGISTER_METHOD(lldb::addr_t, SBBreakpointLocation, GetLoadAddress,
263                          ());
264     LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetEnabled, (bool));
265     LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, IsEnabled, ());
266     LLDB_REGISTER_METHOD(uint32_t, SBBreakpointLocation, GetHitCount, ());
267     LLDB_REGISTER_METHOD(uint32_t, SBBreakpointLocation, GetIgnoreCount, ());
268     LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetIgnoreCount,
269                          (uint32_t));
270     LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetCondition,
271                          (const char *));
272     LLDB_REGISTER_METHOD(const char *, SBBreakpointLocation, GetCondition, ());
273     LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetAutoContinue, (bool));
274     LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, GetAutoContinue, ());
275     LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetScriptCallbackFunction,
276                          (const char *));
277     LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpointLocation,
278                          SetScriptCallbackBody, (const char *));
279     LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetCommandLineCommands,
280                          (lldb::SBStringList &));
281     LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, GetCommandLineCommands,
282                          (lldb::SBStringList &));
283     LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetThreadID,
284                          (lldb::tid_t));
285     LLDB_REGISTER_METHOD(lldb::tid_t, SBBreakpointLocation, GetThreadID, ());
286     LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetThreadIndex,
287                          (uint32_t));
288     LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpointLocation, GetThreadIndex,
289                                ());
290     LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetThreadName,
291                          (const char *));
292     LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointLocation,
293                                GetThreadName, ());
294     LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetQueueName,
295                          (const char *));
296     LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointLocation, GetQueueName,
297                                ());
298     LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, IsResolved, ());
299     LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, GetDescription,
300                          (lldb::SBStream &, lldb::DescriptionLevel));
301     LLDB_REGISTER_METHOD(lldb::break_id_t, SBBreakpointLocation, GetID, ());
302     LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBBreakpointLocation,
303                          GetBreakpoint, ());
304   }
305   {
306     LLDB_REGISTER_CONSTRUCTOR(SBBreakpointName, ());
307     LLDB_REGISTER_CONSTRUCTOR(SBBreakpointName,
308                               (lldb::SBTarget &, const char *));
309     LLDB_REGISTER_CONSTRUCTOR(SBBreakpointName,
310                               (lldb::SBBreakpoint &, const char *));
311     LLDB_REGISTER_CONSTRUCTOR(SBBreakpointName,
312                               (const lldb::SBBreakpointName &));
313     LLDB_REGISTER_METHOD(
314         const lldb::SBBreakpointName &,
315         SBBreakpointName, operator=,(const lldb::SBBreakpointName &));
316     LLDB_REGISTER_METHOD(
317         bool, SBBreakpointName, operator==,(const lldb::SBBreakpointName &));
318     LLDB_REGISTER_METHOD(
319         bool, SBBreakpointName, operator!=,(const lldb::SBBreakpointName &));
320     LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointName, IsValid, ());
321     LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointName, operator bool, ());
322     LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointName, GetName, ());
323     LLDB_REGISTER_METHOD(void, SBBreakpointName, SetEnabled, (bool));
324     LLDB_REGISTER_METHOD(bool, SBBreakpointName, IsEnabled, ());
325     LLDB_REGISTER_METHOD(void, SBBreakpointName, SetOneShot, (bool));
326     LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointName, IsOneShot, ());
327     LLDB_REGISTER_METHOD(void, SBBreakpointName, SetIgnoreCount, (uint32_t));
328     LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpointName, GetIgnoreCount, ());
329     LLDB_REGISTER_METHOD(void, SBBreakpointName, SetCondition, (const char *));
330     LLDB_REGISTER_METHOD(const char *, SBBreakpointName, GetCondition, ());
331     LLDB_REGISTER_METHOD(void, SBBreakpointName, SetAutoContinue, (bool));
332     LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetAutoContinue, ());
333     LLDB_REGISTER_METHOD(void, SBBreakpointName, SetThreadID, (lldb::tid_t));
334     LLDB_REGISTER_METHOD(lldb::tid_t, SBBreakpointName, GetThreadID, ());
335     LLDB_REGISTER_METHOD(void, SBBreakpointName, SetThreadIndex, (uint32_t));
336     LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpointName, GetThreadIndex, ());
337     LLDB_REGISTER_METHOD(void, SBBreakpointName, SetThreadName, (const char *));
338     LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointName, GetThreadName,
339                                ());
340     LLDB_REGISTER_METHOD(void, SBBreakpointName, SetQueueName, (const char *));
341     LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointName, GetQueueName,
342                                ());
343     LLDB_REGISTER_METHOD(void, SBBreakpointName, SetCommandLineCommands,
344                          (lldb::SBStringList &));
345     LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetCommandLineCommands,
346                          (lldb::SBStringList &));
347     LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointName, GetHelpString,
348                                ());
349     LLDB_REGISTER_METHOD(void, SBBreakpointName, SetHelpString, (const char *));
350     LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetDescription,
351                          (lldb::SBStream &));
352     LLDB_REGISTER_METHOD(void, SBBreakpointName, SetScriptCallbackFunction,
353                          (const char *));
354     LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpointName, SetScriptCallbackBody,
355                          (const char *));
356     LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointName, GetAllowList, ());
357     LLDB_REGISTER_METHOD(void, SBBreakpointName, SetAllowList, (bool));
358     LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetAllowDelete, ());
359     LLDB_REGISTER_METHOD(void, SBBreakpointName, SetAllowDelete, (bool));
360     LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetAllowDisable, ());
361     LLDB_REGISTER_METHOD(void, SBBreakpointName, SetAllowDisable, (bool));
362   }
363   {} {
364     LLDB_REGISTER_CONSTRUCTOR(SBBroadcaster, ());
365     LLDB_REGISTER_CONSTRUCTOR(SBBroadcaster, (const char *));
366     LLDB_REGISTER_CONSTRUCTOR(SBBroadcaster, (const lldb::SBBroadcaster &));
367     LLDB_REGISTER_METHOD(
368         const lldb::SBBroadcaster &,
369         SBBroadcaster, operator=,(const lldb::SBBroadcaster &));
370     LLDB_REGISTER_METHOD(void, SBBroadcaster, BroadcastEventByType,
371                          (uint32_t, bool));
372     LLDB_REGISTER_METHOD(void, SBBroadcaster, BroadcastEvent,
373                          (const lldb::SBEvent &, bool));
374     LLDB_REGISTER_METHOD(void, SBBroadcaster, AddInitialEventsToListener,
375                          (const lldb::SBListener &, uint32_t));
376     LLDB_REGISTER_METHOD(uint32_t, SBBroadcaster, AddListener,
377                          (const lldb::SBListener &, uint32_t));
378     LLDB_REGISTER_METHOD_CONST(const char *, SBBroadcaster, GetName, ());
379     LLDB_REGISTER_METHOD(bool, SBBroadcaster, EventTypeHasListeners,
380                          (uint32_t));
381     LLDB_REGISTER_METHOD(bool, SBBroadcaster, RemoveListener,
382                          (const lldb::SBListener &, uint32_t));
383     LLDB_REGISTER_METHOD_CONST(bool, SBBroadcaster, IsValid, ());
384     LLDB_REGISTER_METHOD_CONST(bool, SBBroadcaster, operator bool, ());
385     LLDB_REGISTER_METHOD(void, SBBroadcaster, Clear, ());
386     LLDB_REGISTER_METHOD_CONST(
387         bool, SBBroadcaster, operator==,(const lldb::SBBroadcaster &));
388     LLDB_REGISTER_METHOD_CONST(
389         bool, SBBroadcaster, operator!=,(const lldb::SBBroadcaster &));
390     LLDB_REGISTER_METHOD_CONST(
391         bool, SBBroadcaster, operator<,(const lldb::SBBroadcaster &));
392   }
393   {
394     LLDB_REGISTER_CONSTRUCTOR(SBCommandInterpreterRunOptions, ());
395     LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
396                                GetStopOnContinue, ());
397     LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions,
398                          SetStopOnContinue, (bool));
399     LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
400                                GetStopOnError, ());
401     LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnError,
402                          (bool));
403     LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
404                                GetStopOnCrash, ());
405     LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnCrash,
406                          (bool));
407     LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
408                                GetEchoCommands, ());
409     LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetEchoCommands,
410                          (bool));
411     LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
412                                GetEchoCommentCommands, ());
413     LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions,
414                          SetEchoCommentCommands, (bool));
415     LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
416                                GetPrintResults, ());
417     LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetPrintResults,
418                          (bool));
419     LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
420                                GetAddToHistory, ());
421     LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetAddToHistory,
422                          (bool));
423     LLDB_REGISTER_CONSTRUCTOR(SBCommandInterpreter,
424                               (lldb_private::CommandInterpreter *));
425     LLDB_REGISTER_CONSTRUCTOR(SBCommandInterpreter,
426                               (const lldb::SBCommandInterpreter &));
427     LLDB_REGISTER_METHOD(
428         const lldb::SBCommandInterpreter &,
429         SBCommandInterpreter, operator=,(const lldb::SBCommandInterpreter &));
430     LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreter, IsValid, ());
431     LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreter, operator bool, ());
432     LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, CommandExists,
433                          (const char *));
434     LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, AliasExists,
435                          (const char *));
436     LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, IsActive, ());
437     LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreter, WasInterrupted, ());
438     LLDB_REGISTER_METHOD(const char *, SBCommandInterpreter,
439                          GetIOHandlerControlSequence, (char));
440     LLDB_REGISTER_METHOD(lldb::ReturnStatus, SBCommandInterpreter,
441                          HandleCommand,
442                          (const char *, lldb::SBCommandReturnObject &, bool));
443     LLDB_REGISTER_METHOD(lldb::ReturnStatus, SBCommandInterpreter,
444                          HandleCommand,
445                          (const char *, lldb::SBExecutionContext &,
446                           lldb::SBCommandReturnObject &, bool));
447     LLDB_REGISTER_METHOD(void, SBCommandInterpreter, HandleCommandsFromFile,
448                          (lldb::SBFileSpec &, lldb::SBExecutionContext &,
449                           lldb::SBCommandInterpreterRunOptions &,
450                           lldb::SBCommandReturnObject));
451     LLDB_REGISTER_METHOD(int, SBCommandInterpreter, HandleCompletion,
452                          (const char *, const char *, const char *, int, int,
453                           lldb::SBStringList &));
454     LLDB_REGISTER_METHOD(int, SBCommandInterpreter,
455                          HandleCompletionWithDescriptions,
456                          (const char *, const char *, const char *, int, int,
457                           lldb::SBStringList &, lldb::SBStringList &));
458     LLDB_REGISTER_METHOD(int, SBCommandInterpreter,
459                          HandleCompletionWithDescriptions,
460                          (const char *, uint32_t, int, int,
461                           lldb::SBStringList &, lldb::SBStringList &));
462     LLDB_REGISTER_METHOD(
463         int, SBCommandInterpreter, HandleCompletion,
464         (const char *, uint32_t, int, int, lldb::SBStringList &));
465     LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasCommands, ());
466     LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasAliases, ());
467     LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasAliasOptions, ());
468     LLDB_REGISTER_METHOD(lldb::SBProcess, SBCommandInterpreter, GetProcess, ());
469     LLDB_REGISTER_METHOD(lldb::SBDebugger, SBCommandInterpreter, GetDebugger,
470                          ());
471     LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, GetPromptOnQuit, ());
472     LLDB_REGISTER_METHOD(void, SBCommandInterpreter, SetPromptOnQuit, (bool));
473     LLDB_REGISTER_METHOD(void, SBCommandInterpreter, AllowExitCodeOnQuit,
474                          (bool));
475     LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasCustomQuitExitCode, ());
476     LLDB_REGISTER_METHOD(int, SBCommandInterpreter, GetQuitStatus, ());
477     LLDB_REGISTER_METHOD(void, SBCommandInterpreter, ResolveCommand,
478                          (const char *, lldb::SBCommandReturnObject &));
479     LLDB_REGISTER_METHOD(void, SBCommandInterpreter,
480                          SourceInitFileInHomeDirectory,
481                          (lldb::SBCommandReturnObject &));
482     LLDB_REGISTER_METHOD(void, SBCommandInterpreter,
483                          SourceInitFileInCurrentWorkingDirectory,
484                          (lldb::SBCommandReturnObject &));
485     LLDB_REGISTER_METHOD(lldb::SBBroadcaster, SBCommandInterpreter,
486                          GetBroadcaster, ());
487     LLDB_REGISTER_STATIC_METHOD(const char *, SBCommandInterpreter,
488                                 GetBroadcasterClass, ());
489     LLDB_REGISTER_STATIC_METHOD(const char *, SBCommandInterpreter,
490                                 GetArgumentTypeAsCString,
491                                 (const lldb::CommandArgumentType));
492     LLDB_REGISTER_STATIC_METHOD(const char *, SBCommandInterpreter,
493                                 GetArgumentDescriptionAsCString,
494                                 (const lldb::CommandArgumentType));
495     LLDB_REGISTER_STATIC_METHOD(bool, SBCommandInterpreter,
496                                 EventIsCommandInterpreterEvent,
497                                 (const lldb::SBEvent &));
498     LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommandInterpreter,
499                          AddMultiwordCommand, (const char *, const char *));
500     LLDB_REGISTER_METHOD(
501         lldb::SBCommand, SBCommandInterpreter, AddCommand,
502         (const char *, lldb::SBCommandPluginInterface *, const char *));
503     LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommandInterpreter, AddCommand,
504                          (const char *, lldb::SBCommandPluginInterface *,
505                           const char *, const char *));
506     LLDB_REGISTER_CONSTRUCTOR(SBCommand, ());
507     LLDB_REGISTER_METHOD(bool, SBCommand, IsValid, ());
508     LLDB_REGISTER_METHOD_CONST(bool, SBCommand, operator bool, ());
509     LLDB_REGISTER_METHOD(const char *, SBCommand, GetName, ());
510     LLDB_REGISTER_METHOD(const char *, SBCommand, GetHelp, ());
511     LLDB_REGISTER_METHOD(const char *, SBCommand, GetHelpLong, ());
512     LLDB_REGISTER_METHOD(void, SBCommand, SetHelp, (const char *));
513     LLDB_REGISTER_METHOD(void, SBCommand, SetHelpLong, (const char *));
514     LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommand, AddMultiwordCommand,
515                          (const char *, const char *));
516     LLDB_REGISTER_METHOD(
517         lldb::SBCommand, SBCommand, AddCommand,
518         (const char *, lldb::SBCommandPluginInterface *, const char *));
519     LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommand, AddCommand,
520                          (const char *, lldb::SBCommandPluginInterface *,
521                           const char *, const char *));
522     LLDB_REGISTER_METHOD(uint32_t, SBCommand, GetFlags, ());
523     LLDB_REGISTER_METHOD(void, SBCommand, SetFlags, (uint32_t));
524   }
525   {
526     LLDB_REGISTER_CONSTRUCTOR(SBCommandReturnObject, ());
527     LLDB_REGISTER_CONSTRUCTOR(SBCommandReturnObject,
528                               (const lldb::SBCommandReturnObject &));
529     LLDB_REGISTER_CONSTRUCTOR(SBCommandReturnObject,
530                               (lldb_private::CommandReturnObject *));
531     LLDB_REGISTER_METHOD(lldb_private::CommandReturnObject *,
532                          SBCommandReturnObject, Release, ());
533     LLDB_REGISTER_METHOD(
534         const lldb::SBCommandReturnObject &,
535         SBCommandReturnObject, operator=,(const lldb::SBCommandReturnObject &));
536     LLDB_REGISTER_METHOD_CONST(bool, SBCommandReturnObject, IsValid, ());
537     LLDB_REGISTER_METHOD_CONST(bool, SBCommandReturnObject, operator bool, ());
538     LLDB_REGISTER_METHOD(const char *, SBCommandReturnObject, GetOutput, ());
539     LLDB_REGISTER_METHOD(const char *, SBCommandReturnObject, GetError, ());
540     LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, GetOutputSize, ());
541     LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, GetErrorSize, ());
542     LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, PutOutput, (FILE *));
543     LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, PutError, (FILE *));
544     LLDB_REGISTER_METHOD(void, SBCommandReturnObject, Clear, ());
545     LLDB_REGISTER_METHOD(lldb::ReturnStatus, SBCommandReturnObject, GetStatus,
546                          ());
547     LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetStatus,
548                          (lldb::ReturnStatus));
549     LLDB_REGISTER_METHOD(bool, SBCommandReturnObject, Succeeded, ());
550     LLDB_REGISTER_METHOD(bool, SBCommandReturnObject, HasResult, ());
551     LLDB_REGISTER_METHOD(void, SBCommandReturnObject, AppendMessage,
552                          (const char *));
553     LLDB_REGISTER_METHOD(void, SBCommandReturnObject, AppendWarning,
554                          (const char *));
555     LLDB_REGISTER_METHOD(bool, SBCommandReturnObject, GetDescription,
556                          (lldb::SBStream &));
557     LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
558                          (FILE *));
559     LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
560                          (FILE *));
561     LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
562                          (FILE *, bool));
563     LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
564                          (FILE *, bool));
565     LLDB_REGISTER_METHOD(void, SBCommandReturnObject, PutCString,
566                          (const char *, int));
567     LLDB_REGISTER_METHOD(const char *, SBCommandReturnObject, GetOutput,
568                          (bool));
569     LLDB_REGISTER_METHOD(const char *, SBCommandReturnObject, GetError, (bool));
570     LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetError,
571                          (lldb::SBError &, const char *));
572     LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetError, (const char *));
573   }
574   {
575     LLDB_REGISTER_CONSTRUCTOR(SBCommunication, ());
576     LLDB_REGISTER_CONSTRUCTOR(SBCommunication, (const char *));
577     LLDB_REGISTER_METHOD_CONST(bool, SBCommunication, IsValid, ());
578     LLDB_REGISTER_METHOD_CONST(bool, SBCommunication, operator bool, ());
579     LLDB_REGISTER_METHOD(bool, SBCommunication, GetCloseOnEOF, ());
580     LLDB_REGISTER_METHOD(void, SBCommunication, SetCloseOnEOF, (bool));
581     LLDB_REGISTER_METHOD(lldb::ConnectionStatus, SBCommunication, Connect,
582                          (const char *));
583     LLDB_REGISTER_METHOD(lldb::ConnectionStatus, SBCommunication,
584                          AdoptFileDesriptor, (int, bool));
585     LLDB_REGISTER_METHOD(lldb::ConnectionStatus, SBCommunication, Disconnect,
586                          ());
587     LLDB_REGISTER_METHOD_CONST(bool, SBCommunication, IsConnected, ());
588     LLDB_REGISTER_METHOD(bool, SBCommunication, ReadThreadStart, ());
589     LLDB_REGISTER_METHOD(bool, SBCommunication, ReadThreadStop, ());
590     LLDB_REGISTER_METHOD(bool, SBCommunication, ReadThreadIsRunning, ());
591     LLDB_REGISTER_METHOD(lldb::SBBroadcaster, SBCommunication, GetBroadcaster,
592                          ());
593     LLDB_REGISTER_STATIC_METHOD(const char *, SBCommunication,
594                                 GetBroadcasterClass, ());
595   }
596   {
597     LLDB_REGISTER_CONSTRUCTOR(SBCompileUnit, ());
598     LLDB_REGISTER_CONSTRUCTOR(SBCompileUnit, (const lldb::SBCompileUnit &));
599     LLDB_REGISTER_METHOD(
600         const lldb::SBCompileUnit &,
601         SBCompileUnit, operator=,(const lldb::SBCompileUnit &));
602     LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBCompileUnit, GetFileSpec,
603                                ());
604     LLDB_REGISTER_METHOD_CONST(uint32_t, SBCompileUnit, GetNumLineEntries, ());
605     LLDB_REGISTER_METHOD_CONST(lldb::SBLineEntry, SBCompileUnit,
606                                GetLineEntryAtIndex, (uint32_t));
607     LLDB_REGISTER_METHOD_CONST(uint32_t, SBCompileUnit, FindLineEntryIndex,
608                                (uint32_t, uint32_t, lldb::SBFileSpec *));
609     LLDB_REGISTER_METHOD_CONST(uint32_t, SBCompileUnit, FindLineEntryIndex,
610                                (uint32_t, uint32_t, lldb::SBFileSpec *, bool));
611     LLDB_REGISTER_METHOD_CONST(uint32_t, SBCompileUnit, GetNumSupportFiles, ());
612     LLDB_REGISTER_METHOD(lldb::SBTypeList, SBCompileUnit, GetTypes, (uint32_t));
613     LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBCompileUnit,
614                                GetSupportFileAtIndex, (uint32_t));
615     LLDB_REGISTER_METHOD(uint32_t, SBCompileUnit, FindSupportFileIndex,
616                          (uint32_t, const lldb::SBFileSpec &, bool));
617     LLDB_REGISTER_METHOD(lldb::LanguageType, SBCompileUnit, GetLanguage, ());
618     LLDB_REGISTER_METHOD_CONST(bool, SBCompileUnit, IsValid, ());
619     LLDB_REGISTER_METHOD_CONST(bool, SBCompileUnit, operator bool, ());
620     LLDB_REGISTER_METHOD_CONST(
621         bool, SBCompileUnit, operator==,(const lldb::SBCompileUnit &));
622     LLDB_REGISTER_METHOD_CONST(
623         bool, SBCompileUnit, operator!=,(const lldb::SBCompileUnit &));
624     LLDB_REGISTER_METHOD(bool, SBCompileUnit, GetDescription,
625                          (lldb::SBStream &));
626   }
627   {
628     LLDB_REGISTER_CONSTRUCTOR(SBData, ());
629     LLDB_REGISTER_CONSTRUCTOR(SBData, (const lldb::SBData &));
630     LLDB_REGISTER_METHOD(const lldb::SBData &,
631                          SBData, operator=,(const lldb::SBData &));
632     LLDB_REGISTER_METHOD(bool, SBData, IsValid, ());
633     LLDB_REGISTER_METHOD_CONST(bool, SBData, operator bool, ());
634     LLDB_REGISTER_METHOD(uint8_t, SBData, GetAddressByteSize, ());
635     LLDB_REGISTER_METHOD(void, SBData, SetAddressByteSize, (uint8_t));
636     LLDB_REGISTER_METHOD(void, SBData, Clear, ());
637     LLDB_REGISTER_METHOD(size_t, SBData, GetByteSize, ());
638     LLDB_REGISTER_METHOD(lldb::ByteOrder, SBData, GetByteOrder, ());
639     LLDB_REGISTER_METHOD(void, SBData, SetByteOrder, (lldb::ByteOrder));
640     LLDB_REGISTER_METHOD(float, SBData, GetFloat,
641                          (lldb::SBError &, lldb::offset_t));
642     LLDB_REGISTER_METHOD(double, SBData, GetDouble,
643                          (lldb::SBError &, lldb::offset_t));
644     LLDB_REGISTER_METHOD(long double, SBData, GetLongDouble,
645                          (lldb::SBError &, lldb::offset_t));
646     LLDB_REGISTER_METHOD(lldb::addr_t, SBData, GetAddress,
647                          (lldb::SBError &, lldb::offset_t));
648     LLDB_REGISTER_METHOD(uint8_t, SBData, GetUnsignedInt8,
649                          (lldb::SBError &, lldb::offset_t));
650     LLDB_REGISTER_METHOD(uint16_t, SBData, GetUnsignedInt16,
651                          (lldb::SBError &, lldb::offset_t));
652     LLDB_REGISTER_METHOD(uint32_t, SBData, GetUnsignedInt32,
653                          (lldb::SBError &, lldb::offset_t));
654     LLDB_REGISTER_METHOD(uint64_t, SBData, GetUnsignedInt64,
655                          (lldb::SBError &, lldb::offset_t));
656     LLDB_REGISTER_METHOD(int8_t, SBData, GetSignedInt8,
657                          (lldb::SBError &, lldb::offset_t));
658     LLDB_REGISTER_METHOD(int16_t, SBData, GetSignedInt16,
659                          (lldb::SBError &, lldb::offset_t));
660     LLDB_REGISTER_METHOD(int32_t, SBData, GetSignedInt32,
661                          (lldb::SBError &, lldb::offset_t));
662     LLDB_REGISTER_METHOD(int64_t, SBData, GetSignedInt64,
663                          (lldb::SBError &, lldb::offset_t));
664     LLDB_REGISTER_METHOD(const char *, SBData, GetString,
665                          (lldb::SBError &, lldb::offset_t));
666     LLDB_REGISTER_METHOD(bool, SBData, GetDescription,
667                          (lldb::SBStream &, lldb::addr_t));
668     LLDB_REGISTER_METHOD(bool, SBData, Append, (const lldb::SBData &));
669     LLDB_REGISTER_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromCString,
670                                 (lldb::ByteOrder, uint32_t, const char *));
671     LLDB_REGISTER_STATIC_METHOD(
672         lldb::SBData, SBData, CreateDataFromUInt64Array,
673         (lldb::ByteOrder, uint32_t, uint64_t *, size_t));
674     LLDB_REGISTER_STATIC_METHOD(
675         lldb::SBData, SBData, CreateDataFromUInt32Array,
676         (lldb::ByteOrder, uint32_t, uint32_t *, size_t));
677     LLDB_REGISTER_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromSInt64Array,
678                                 (lldb::ByteOrder, uint32_t, int64_t *, size_t));
679     LLDB_REGISTER_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromSInt32Array,
680                                 (lldb::ByteOrder, uint32_t, int32_t *, size_t));
681     LLDB_REGISTER_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromDoubleArray,
682                                 (lldb::ByteOrder, uint32_t, double *, size_t));
683     LLDB_REGISTER_METHOD(bool, SBData, SetDataFromCString, (const char *));
684     LLDB_REGISTER_METHOD(bool, SBData, SetDataFromUInt64Array,
685                          (uint64_t *, size_t));
686     LLDB_REGISTER_METHOD(bool, SBData, SetDataFromUInt32Array,
687                          (uint32_t *, size_t));
688     LLDB_REGISTER_METHOD(bool, SBData, SetDataFromSInt64Array,
689                          (int64_t *, size_t));
690     LLDB_REGISTER_METHOD(bool, SBData, SetDataFromSInt32Array,
691                          (int32_t *, size_t));
692     LLDB_REGISTER_METHOD(bool, SBData, SetDataFromDoubleArray,
693                          (double *, size_t));
694   }
695   {
696     LLDB_REGISTER_METHOD(void, SBInputReader, SetIsDone, (bool));
697     LLDB_REGISTER_METHOD_CONST(bool, SBInputReader, IsActive, ());
698     LLDB_REGISTER_CONSTRUCTOR(SBDebugger, ());
699     LLDB_REGISTER_CONSTRUCTOR(SBDebugger, (const lldb::DebuggerSP &));
700     LLDB_REGISTER_CONSTRUCTOR(SBDebugger, (const lldb::SBDebugger &));
701     LLDB_REGISTER_METHOD(lldb::SBDebugger &,
702                          SBDebugger, operator=,(const lldb::SBDebugger &));
703     LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, Initialize, ());
704     LLDB_REGISTER_STATIC_METHOD(lldb::SBError, SBDebugger,
705                                 InitializeWithErrorHandling, ());
706     LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, Terminate, ());
707     LLDB_REGISTER_METHOD(void, SBDebugger, Clear, ());
708     LLDB_REGISTER_STATIC_METHOD(lldb::SBDebugger, SBDebugger, Create, ());
709     LLDB_REGISTER_STATIC_METHOD(lldb::SBDebugger, SBDebugger, Create, (bool));
710     LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, Destroy,
711                                 (lldb::SBDebugger &));
712     LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, MemoryPressureDetected, ());
713     LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, IsValid, ());
714     LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, operator bool, ());
715     LLDB_REGISTER_METHOD(void, SBDebugger, SetAsync, (bool));
716     LLDB_REGISTER_METHOD(bool, SBDebugger, GetAsync, ());
717     LLDB_REGISTER_METHOD(void, SBDebugger, SkipLLDBInitFiles, (bool));
718     LLDB_REGISTER_METHOD(void, SBDebugger, SkipAppInitFiles, (bool));
719     LLDB_REGISTER_METHOD(void, SBDebugger, SetInputFileHandle, (FILE *, bool));
720     LLDB_REGISTER_METHOD(FILE *, SBDebugger, GetInputFileHandle, ());
721     LLDB_REGISTER_METHOD(FILE *, SBDebugger, GetOutputFileHandle, ());
722     LLDB_REGISTER_METHOD(FILE *, SBDebugger, GetErrorFileHandle, ());
723     LLDB_REGISTER_METHOD(void, SBDebugger, SaveInputTerminalState, ());
724     LLDB_REGISTER_METHOD(void, SBDebugger, RestoreInputTerminalState, ());
725     LLDB_REGISTER_METHOD(lldb::SBCommandInterpreter, SBDebugger,
726                          GetCommandInterpreter, ());
727     LLDB_REGISTER_METHOD(void, SBDebugger, HandleCommand, (const char *));
728     LLDB_REGISTER_METHOD(lldb::SBListener, SBDebugger, GetListener, ());
729     LLDB_REGISTER_METHOD(
730         void, SBDebugger, HandleProcessEvent,
731         (const lldb::SBProcess &, const lldb::SBEvent &, FILE *, FILE *));
732     LLDB_REGISTER_METHOD(lldb::SBSourceManager, SBDebugger, GetSourceManager,
733                          ());
734     LLDB_REGISTER_STATIC_METHOD(bool, SBDebugger, SetDefaultArchitecture,
735                                 (const char *));
736     LLDB_REGISTER_METHOD(lldb::ScriptLanguage, SBDebugger, GetScriptingLanguage,
737                          (const char *));
738     LLDB_REGISTER_STATIC_METHOD(const char *, SBDebugger, GetVersionString, ());
739     LLDB_REGISTER_STATIC_METHOD(const char *, SBDebugger, StateAsCString,
740                                 (lldb::StateType));
741     LLDB_REGISTER_STATIC_METHOD(lldb::SBStructuredData, SBDebugger,
742                                 GetBuildConfiguration, ());
743     LLDB_REGISTER_STATIC_METHOD(bool, SBDebugger, StateIsRunningState,
744                                 (lldb::StateType));
745     LLDB_REGISTER_STATIC_METHOD(bool, SBDebugger, StateIsStoppedState,
746                                 (lldb::StateType));
747     LLDB_REGISTER_METHOD(
748         lldb::SBTarget, SBDebugger, CreateTarget,
749         (const char *, const char *, const char *, bool, lldb::SBError &));
750     LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger,
751                          CreateTargetWithFileAndTargetTriple,
752                          (const char *, const char *));
753     LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger,
754                          CreateTargetWithFileAndArch,
755                          (const char *, const char *));
756     LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, CreateTarget,
757                          (const char *));
758     LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, GetDummyTarget, ());
759     LLDB_REGISTER_METHOD(bool, SBDebugger, DeleteTarget, (lldb::SBTarget &));
760     LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, GetTargetAtIndex,
761                          (uint32_t));
762     LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetIndexOfTarget,
763                          (lldb::SBTarget));
764     LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithProcessID,
765                          (lldb::pid_t));
766     LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithFileAndArch,
767                          (const char *, const char *));
768     LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumTargets, ());
769     LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, GetSelectedTarget, ());
770     LLDB_REGISTER_METHOD(void, SBDebugger, SetSelectedTarget,
771                          (lldb::SBTarget &));
772     LLDB_REGISTER_METHOD(lldb::SBPlatform, SBDebugger, GetSelectedPlatform, ());
773     LLDB_REGISTER_METHOD(void, SBDebugger, SetSelectedPlatform,
774                          (lldb::SBPlatform &));
775     LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumPlatforms, ());
776     LLDB_REGISTER_METHOD(lldb::SBPlatform, SBDebugger, GetPlatformAtIndex,
777                          (uint32_t));
778     LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumAvailablePlatforms, ());
779     LLDB_REGISTER_METHOD(lldb::SBStructuredData, SBDebugger,
780                          GetAvailablePlatformInfoAtIndex, (uint32_t));
781     LLDB_REGISTER_METHOD(void, SBDebugger, DispatchInputInterrupt, ());
782     LLDB_REGISTER_METHOD(void, SBDebugger, DispatchInputEndOfFile, ());
783     LLDB_REGISTER_METHOD(void, SBDebugger, PushInputReader,
784                          (lldb::SBInputReader &));
785     LLDB_REGISTER_METHOD(void, SBDebugger, RunCommandInterpreter, (bool, bool));
786     LLDB_REGISTER_METHOD(void, SBDebugger, RunCommandInterpreter,
787                          (bool, bool, lldb::SBCommandInterpreterRunOptions &,
788                           int &, bool &, bool &));
789     LLDB_REGISTER_METHOD(lldb::SBError, SBDebugger, RunREPL,
790                          (lldb::LanguageType, const char *));
791     LLDB_REGISTER_STATIC_METHOD(lldb::SBDebugger, SBDebugger,
792                                 FindDebuggerWithID, (int));
793     LLDB_REGISTER_METHOD(const char *, SBDebugger, GetInstanceName, ());
794     LLDB_REGISTER_STATIC_METHOD(lldb::SBError, SBDebugger, SetInternalVariable,
795                                 (const char *, const char *, const char *));
796     LLDB_REGISTER_STATIC_METHOD(lldb::SBStringList, SBDebugger,
797                                 GetInternalVariableValue,
798                                 (const char *, const char *));
799     LLDB_REGISTER_METHOD_CONST(uint32_t, SBDebugger, GetTerminalWidth, ());
800     LLDB_REGISTER_METHOD(void, SBDebugger, SetTerminalWidth, (uint32_t));
801     LLDB_REGISTER_METHOD_CONST(const char *, SBDebugger, GetPrompt, ());
802     LLDB_REGISTER_METHOD(void, SBDebugger, SetPrompt, (const char *));
803     LLDB_REGISTER_METHOD_CONST(const char *, SBDebugger, GetReproducerPath, ());
804     LLDB_REGISTER_METHOD_CONST(lldb::ScriptLanguage, SBDebugger,
805                                GetScriptLanguage, ());
806     LLDB_REGISTER_METHOD(void, SBDebugger, SetScriptLanguage,
807                          (lldb::ScriptLanguage));
808     LLDB_REGISTER_METHOD(bool, SBDebugger, SetUseExternalEditor, (bool));
809     LLDB_REGISTER_METHOD(bool, SBDebugger, GetUseExternalEditor, ());
810     LLDB_REGISTER_METHOD(bool, SBDebugger, SetUseColor, (bool));
811     LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, GetUseColor, ());
812     LLDB_REGISTER_METHOD(bool, SBDebugger, GetDescription, (lldb::SBStream &));
813     LLDB_REGISTER_METHOD(lldb::user_id_t, SBDebugger, GetID, ());
814     LLDB_REGISTER_METHOD(lldb::SBError, SBDebugger, SetCurrentPlatform,
815                          (const char *));
816     LLDB_REGISTER_METHOD(bool, SBDebugger, SetCurrentPlatformSDKRoot,
817                          (const char *));
818     LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, GetCloseInputOnEOF, ());
819     LLDB_REGISTER_METHOD(void, SBDebugger, SetCloseInputOnEOF, (bool));
820     LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory,
821                          (const char *));
822     LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory,
823                          (lldb::LanguageType));
824     LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, CreateCategory,
825                          (const char *));
826     LLDB_REGISTER_METHOD(bool, SBDebugger, DeleteCategory, (const char *));
827     LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumCategories, ());
828     LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategoryAtIndex,
829                          (uint32_t));
830     LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetDefaultCategory,
831                          ());
832     LLDB_REGISTER_METHOD(lldb::SBTypeFormat, SBDebugger, GetFormatForType,
833                          (lldb::SBTypeNameSpecifier));
834 #ifndef LLDB_DISABLE_PYTHON
835     LLDB_REGISTER_METHOD(lldb::SBTypeSummary, SBDebugger, GetSummaryForType,
836                          (lldb::SBTypeNameSpecifier));
837     LLDB_REGISTER_METHOD(lldb::SBTypeSynthetic, SBDebugger, GetSyntheticForType,
838                          (lldb::SBTypeNameSpecifier));
839 #endif
840     LLDB_REGISTER_METHOD(lldb::SBTypeFilter, SBDebugger, GetFilterForType,
841                          (lldb::SBTypeNameSpecifier));
842     LLDB_REGISTER_METHOD(bool, SBDebugger, EnableLog,
843                          (const char *, const char **));
844   }
845   {
846     LLDB_REGISTER_CONSTRUCTOR(SBDeclaration, ());
847     LLDB_REGISTER_CONSTRUCTOR(SBDeclaration, (const lldb::SBDeclaration &));
848     LLDB_REGISTER_METHOD(
849         const lldb::SBDeclaration &,
850         SBDeclaration, operator=,(const lldb::SBDeclaration &));
851     LLDB_REGISTER_METHOD_CONST(bool, SBDeclaration, IsValid, ());
852     LLDB_REGISTER_METHOD_CONST(bool, SBDeclaration, operator bool, ());
853     LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBDeclaration, GetFileSpec,
854                                ());
855     LLDB_REGISTER_METHOD_CONST(uint32_t, SBDeclaration, GetLine, ());
856     LLDB_REGISTER_METHOD_CONST(uint32_t, SBDeclaration, GetColumn, ());
857     LLDB_REGISTER_METHOD(void, SBDeclaration, SetFileSpec, (lldb::SBFileSpec));
858     LLDB_REGISTER_METHOD(void, SBDeclaration, SetLine, (uint32_t));
859     LLDB_REGISTER_METHOD(void, SBDeclaration, SetColumn, (uint32_t));
860     LLDB_REGISTER_METHOD_CONST(
861         bool, SBDeclaration, operator==,(const lldb::SBDeclaration &));
862     LLDB_REGISTER_METHOD_CONST(
863         bool, SBDeclaration, operator!=,(const lldb::SBDeclaration &));
864     LLDB_REGISTER_METHOD(bool, SBDeclaration, GetDescription,
865                          (lldb::SBStream &));
866   }
867   {
868     LLDB_REGISTER_CONSTRUCTOR(SBError, ());
869     LLDB_REGISTER_CONSTRUCTOR(SBError, (const lldb::SBError &));
870     LLDB_REGISTER_METHOD(const lldb::SBError &,
871                          SBError, operator=,(const lldb::SBError &));
872     LLDB_REGISTER_METHOD_CONST(const char *, SBError, GetCString, ());
873     LLDB_REGISTER_METHOD(void, SBError, Clear, ());
874     LLDB_REGISTER_METHOD_CONST(bool, SBError, Fail, ());
875     LLDB_REGISTER_METHOD_CONST(bool, SBError, Success, ());
876     LLDB_REGISTER_METHOD_CONST(uint32_t, SBError, GetError, ());
877     LLDB_REGISTER_METHOD_CONST(lldb::ErrorType, SBError, GetType, ());
878     LLDB_REGISTER_METHOD(void, SBError, SetError, (uint32_t, lldb::ErrorType));
879     LLDB_REGISTER_METHOD(void, SBError, SetErrorToErrno, ());
880     LLDB_REGISTER_METHOD(void, SBError, SetErrorToGenericError, ());
881     LLDB_REGISTER_METHOD(void, SBError, SetErrorString, (const char *));
882     LLDB_REGISTER_METHOD_CONST(bool, SBError, IsValid, ());
883     LLDB_REGISTER_METHOD_CONST(bool, SBError, operator bool, ());
884     LLDB_REGISTER_METHOD(bool, SBError, GetDescription, (lldb::SBStream &));
885   }
886   {
887     LLDB_REGISTER_CONSTRUCTOR(SBEvent, ());
888     LLDB_REGISTER_CONSTRUCTOR(SBEvent, (uint32_t, const char *, uint32_t));
889     LLDB_REGISTER_CONSTRUCTOR(SBEvent, (lldb::EventSP &));
890     LLDB_REGISTER_CONSTRUCTOR(SBEvent, (lldb_private::Event *));
891     LLDB_REGISTER_CONSTRUCTOR(SBEvent, (const lldb::SBEvent &));
892     LLDB_REGISTER_METHOD(const lldb::SBEvent &,
893                          SBEvent, operator=,(const lldb::SBEvent &));
894     LLDB_REGISTER_METHOD(const char *, SBEvent, GetDataFlavor, ());
895     LLDB_REGISTER_METHOD_CONST(uint32_t, SBEvent, GetType, ());
896     LLDB_REGISTER_METHOD_CONST(lldb::SBBroadcaster, SBEvent, GetBroadcaster,
897                                ());
898     LLDB_REGISTER_METHOD_CONST(const char *, SBEvent, GetBroadcasterClass, ());
899     LLDB_REGISTER_METHOD(bool, SBEvent, BroadcasterMatchesPtr,
900                          (const lldb::SBBroadcaster *));
901     LLDB_REGISTER_METHOD(bool, SBEvent, BroadcasterMatchesRef,
902                          (const lldb::SBBroadcaster &));
903     LLDB_REGISTER_METHOD(void, SBEvent, Clear, ());
904     LLDB_REGISTER_METHOD_CONST(bool, SBEvent, IsValid, ());
905     LLDB_REGISTER_METHOD_CONST(bool, SBEvent, operator bool, ());
906     LLDB_REGISTER_STATIC_METHOD(const char *, SBEvent, GetCStringFromEvent,
907                                 (const lldb::SBEvent &));
908     LLDB_REGISTER_METHOD(bool, SBEvent, GetDescription, (lldb::SBStream &));
909     LLDB_REGISTER_METHOD_CONST(bool, SBEvent, GetDescription,
910                                (lldb::SBStream &));
911   }
912   {
913     LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext, ());
914     LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext,
915                               (const lldb::SBExecutionContext &));
916     LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext,
917                               (lldb::ExecutionContextRefSP));
918     LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext, (const lldb::SBTarget &));
919     LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext, (const lldb::SBProcess &));
920     LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext, (lldb::SBThread));
921     LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext, (const lldb::SBFrame &));
922     LLDB_REGISTER_METHOD(
923         const lldb::SBExecutionContext &,
924         SBExecutionContext, operator=,(const lldb::SBExecutionContext &));
925     LLDB_REGISTER_METHOD_CONST(lldb::SBTarget, SBExecutionContext, GetTarget,
926                                ());
927     LLDB_REGISTER_METHOD_CONST(lldb::SBProcess, SBExecutionContext, GetProcess,
928                                ());
929     LLDB_REGISTER_METHOD_CONST(lldb::SBThread, SBExecutionContext, GetThread,
930                                ());
931     LLDB_REGISTER_METHOD_CONST(lldb::SBFrame, SBExecutionContext, GetFrame, ());
932   }
933   {
934     LLDB_REGISTER_CONSTRUCTOR(SBExpressionOptions, ());
935     LLDB_REGISTER_CONSTRUCTOR(SBExpressionOptions,
936                               (const lldb::SBExpressionOptions &));
937     LLDB_REGISTER_METHOD(
938         const lldb::SBExpressionOptions &,
939         SBExpressionOptions, operator=,(const lldb::SBExpressionOptions &));
940     LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetCoerceResultToId,
941                                ());
942     LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetCoerceResultToId,
943                          (bool));
944     LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetUnwindOnError, ());
945     LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetUnwindOnError, (bool));
946     LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetIgnoreBreakpoints,
947                                ());
948     LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetIgnoreBreakpoints,
949                          (bool));
950     LLDB_REGISTER_METHOD_CONST(lldb::DynamicValueType, SBExpressionOptions,
951                                GetFetchDynamicValue, ());
952     LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetFetchDynamicValue,
953                          (lldb::DynamicValueType));
954     LLDB_REGISTER_METHOD_CONST(uint32_t, SBExpressionOptions,
955                                GetTimeoutInMicroSeconds, ());
956     LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetTimeoutInMicroSeconds,
957                          (uint32_t));
958     LLDB_REGISTER_METHOD_CONST(uint32_t, SBExpressionOptions,
959                                GetOneThreadTimeoutInMicroSeconds, ());
960     LLDB_REGISTER_METHOD(void, SBExpressionOptions,
961                          SetOneThreadTimeoutInMicroSeconds, (uint32_t));
962     LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetTryAllThreads, ());
963     LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetTryAllThreads, (bool));
964     LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetStopOthers, ());
965     LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetStopOthers, (bool));
966     LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetTrapExceptions,
967                                ());
968     LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetTrapExceptions, (bool));
969     LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetLanguage,
970                          (lldb::LanguageType));
971     LLDB_REGISTER_METHOD(bool, SBExpressionOptions, GetGenerateDebugInfo, ());
972     LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetGenerateDebugInfo,
973                          (bool));
974     LLDB_REGISTER_METHOD(bool, SBExpressionOptions, GetSuppressPersistentResult,
975                          ());
976     LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetSuppressPersistentResult,
977                          (bool));
978     LLDB_REGISTER_METHOD_CONST(const char *, SBExpressionOptions, GetPrefix,
979                                ());
980     LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetPrefix, (const char *));
981     LLDB_REGISTER_METHOD(bool, SBExpressionOptions, GetAutoApplyFixIts, ());
982     LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetAutoApplyFixIts, (bool));
983     LLDB_REGISTER_METHOD(bool, SBExpressionOptions, GetTopLevel, ());
984     LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetTopLevel, (bool));
985     LLDB_REGISTER_METHOD(bool, SBExpressionOptions, GetAllowJIT, ());
986     LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetAllowJIT, (bool));
987   }
988   {
989     LLDB_REGISTER_CONSTRUCTOR(SBFileSpec, ());
990     LLDB_REGISTER_CONSTRUCTOR(SBFileSpec, (const lldb::SBFileSpec &));
991     LLDB_REGISTER_CONSTRUCTOR(SBFileSpec, (const char *));
992     LLDB_REGISTER_CONSTRUCTOR(SBFileSpec, (const char *, bool));
993     LLDB_REGISTER_METHOD(const lldb::SBFileSpec &,
994                          SBFileSpec, operator=,(const lldb::SBFileSpec &));
995     LLDB_REGISTER_METHOD_CONST(bool, SBFileSpec, IsValid, ());
996     LLDB_REGISTER_METHOD_CONST(bool, SBFileSpec, operator bool, ());
997     LLDB_REGISTER_METHOD_CONST(bool, SBFileSpec, Exists, ());
998     LLDB_REGISTER_METHOD(bool, SBFileSpec, ResolveExecutableLocation, ());
999     LLDB_REGISTER_STATIC_METHOD(int, SBFileSpec, ResolvePath,
1000                                 (const char *, char *, size_t));
1001     LLDB_REGISTER_METHOD_CONST(const char *, SBFileSpec, GetFilename, ());
1002     LLDB_REGISTER_METHOD_CONST(const char *, SBFileSpec, GetDirectory, ());
1003     LLDB_REGISTER_METHOD(void, SBFileSpec, SetFilename, (const char *));
1004     LLDB_REGISTER_METHOD(void, SBFileSpec, SetDirectory, (const char *));
1005     LLDB_REGISTER_METHOD_CONST(uint32_t, SBFileSpec, GetPath, (char *, size_t));
1006     LLDB_REGISTER_METHOD_CONST(bool, SBFileSpec, GetDescription,
1007                                (lldb::SBStream &));
1008     LLDB_REGISTER_METHOD(void, SBFileSpec, AppendPathComponent, (const char *));
1009   }
1010   {
1011     LLDB_REGISTER_CONSTRUCTOR(SBFileSpecList, ());
1012     LLDB_REGISTER_CONSTRUCTOR(SBFileSpecList, (const lldb::SBFileSpecList &));
1013     LLDB_REGISTER_METHOD(
1014         const lldb::SBFileSpecList &,
1015         SBFileSpecList, operator=,(const lldb::SBFileSpecList &));
1016     LLDB_REGISTER_METHOD_CONST(uint32_t, SBFileSpecList, GetSize, ());
1017     LLDB_REGISTER_METHOD(void, SBFileSpecList, Append,
1018                          (const lldb::SBFileSpec &));
1019     LLDB_REGISTER_METHOD(bool, SBFileSpecList, AppendIfUnique,
1020                          (const lldb::SBFileSpec &));
1021     LLDB_REGISTER_METHOD(void, SBFileSpecList, Clear, ());
1022     LLDB_REGISTER_METHOD(uint32_t, SBFileSpecList, FindFileIndex,
1023                          (uint32_t, const lldb::SBFileSpec &, bool));
1024     LLDB_REGISTER_METHOD_CONST(const lldb::SBFileSpec, SBFileSpecList,
1025                                GetFileSpecAtIndex, (uint32_t));
1026     LLDB_REGISTER_METHOD_CONST(bool, SBFileSpecList, GetDescription,
1027                                (lldb::SBStream &));
1028   }
1029   {
1030     LLDB_REGISTER_CONSTRUCTOR(SBFrame, ());
1031     LLDB_REGISTER_CONSTRUCTOR(SBFrame, (const lldb::StackFrameSP &));
1032     LLDB_REGISTER_CONSTRUCTOR(SBFrame, (const lldb::SBFrame &));
1033     LLDB_REGISTER_METHOD(const lldb::SBFrame &,
1034                          SBFrame, operator=,(const lldb::SBFrame &));
1035     LLDB_REGISTER_METHOD_CONST(bool, SBFrame, IsValid, ());
1036     LLDB_REGISTER_METHOD_CONST(bool, SBFrame, operator bool, ());
1037     LLDB_REGISTER_METHOD_CONST(lldb::SBSymbolContext, SBFrame, GetSymbolContext,
1038                                (uint32_t));
1039     LLDB_REGISTER_METHOD_CONST(lldb::SBModule, SBFrame, GetModule, ());
1040     LLDB_REGISTER_METHOD_CONST(lldb::SBCompileUnit, SBFrame, GetCompileUnit,
1041                                ());
1042     LLDB_REGISTER_METHOD_CONST(lldb::SBFunction, SBFrame, GetFunction, ());
1043     LLDB_REGISTER_METHOD_CONST(lldb::SBSymbol, SBFrame, GetSymbol, ());
1044     LLDB_REGISTER_METHOD_CONST(lldb::SBBlock, SBFrame, GetBlock, ());
1045     LLDB_REGISTER_METHOD_CONST(lldb::SBBlock, SBFrame, GetFrameBlock, ());
1046     LLDB_REGISTER_METHOD_CONST(lldb::SBLineEntry, SBFrame, GetLineEntry, ());
1047     LLDB_REGISTER_METHOD_CONST(uint32_t, SBFrame, GetFrameID, ());
1048     LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBFrame, GetCFA, ());
1049     LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBFrame, GetPC, ());
1050     LLDB_REGISTER_METHOD(bool, SBFrame, SetPC, (lldb::addr_t));
1051     LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBFrame, GetSP, ());
1052     LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBFrame, GetFP, ());
1053     LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBFrame, GetPCAddress, ());
1054     LLDB_REGISTER_METHOD(void, SBFrame, Clear, ());
1055     LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, GetValueForVariablePath,
1056                          (const char *));
1057     LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, GetValueForVariablePath,
1058                          (const char *, lldb::DynamicValueType));
1059     LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, FindVariable, (const char *));
1060     LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, FindVariable,
1061                          (const char *, lldb::DynamicValueType));
1062     LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, FindValue,
1063                          (const char *, lldb::ValueType));
1064     LLDB_REGISTER_METHOD(
1065         lldb::SBValue, SBFrame, FindValue,
1066         (const char *, lldb::ValueType, lldb::DynamicValueType));
1067     LLDB_REGISTER_METHOD_CONST(bool, SBFrame, IsEqual, (const lldb::SBFrame &));
1068     LLDB_REGISTER_METHOD_CONST(bool,
1069                                SBFrame, operator==,(const lldb::SBFrame &));
1070     LLDB_REGISTER_METHOD_CONST(bool,
1071                                SBFrame, operator!=,(const lldb::SBFrame &));
1072     LLDB_REGISTER_METHOD_CONST(lldb::SBThread, SBFrame, GetThread, ());
1073     LLDB_REGISTER_METHOD_CONST(const char *, SBFrame, Disassemble, ());
1074     LLDB_REGISTER_METHOD(lldb::SBValueList, SBFrame, GetVariables,
1075                          (bool, bool, bool, bool));
1076     LLDB_REGISTER_METHOD(lldb::SBValueList, SBFrame, GetVariables,
1077                          (bool, bool, bool, bool, lldb::DynamicValueType));
1078     LLDB_REGISTER_METHOD(lldb::SBValueList, SBFrame, GetVariables,
1079                          (const lldb::SBVariablesOptions &));
1080     LLDB_REGISTER_METHOD(lldb::SBValueList, SBFrame, GetRegisters, ());
1081     LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, FindRegister, (const char *));
1082     LLDB_REGISTER_METHOD(bool, SBFrame, GetDescription, (lldb::SBStream &));
1083     LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
1084                          (const char *));
1085     LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
1086                          (const char *, lldb::DynamicValueType));
1087     LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
1088                          (const char *, lldb::DynamicValueType, bool));
1089     LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
1090                          (const char *, const lldb::SBExpressionOptions &));
1091     LLDB_REGISTER_METHOD(bool, SBFrame, IsInlined, ());
1092     LLDB_REGISTER_METHOD_CONST(bool, SBFrame, IsInlined, ());
1093     LLDB_REGISTER_METHOD(bool, SBFrame, IsArtificial, ());
1094     LLDB_REGISTER_METHOD_CONST(bool, SBFrame, IsArtificial, ());
1095     LLDB_REGISTER_METHOD(const char *, SBFrame, GetFunctionName, ());
1096     LLDB_REGISTER_METHOD_CONST(lldb::LanguageType, SBFrame, GuessLanguage, ());
1097     LLDB_REGISTER_METHOD_CONST(const char *, SBFrame, GetFunctionName, ());
1098     LLDB_REGISTER_METHOD(const char *, SBFrame, GetDisplayFunctionName, ());
1099   }
1100   {
1101     LLDB_REGISTER_CONSTRUCTOR(SBFunction, ());
1102     LLDB_REGISTER_CONSTRUCTOR(SBFunction, (const lldb::SBFunction &));
1103     LLDB_REGISTER_METHOD(const lldb::SBFunction &,
1104                          SBFunction, operator=,(const lldb::SBFunction &));
1105     LLDB_REGISTER_METHOD_CONST(bool, SBFunction, IsValid, ());
1106     LLDB_REGISTER_METHOD_CONST(bool, SBFunction, operator bool, ());
1107     LLDB_REGISTER_METHOD_CONST(const char *, SBFunction, GetName, ());
1108     LLDB_REGISTER_METHOD_CONST(const char *, SBFunction, GetDisplayName, ());
1109     LLDB_REGISTER_METHOD_CONST(const char *, SBFunction, GetMangledName, ());
1110     LLDB_REGISTER_METHOD_CONST(
1111         bool, SBFunction, operator==,(const lldb::SBFunction &));
1112     LLDB_REGISTER_METHOD_CONST(
1113         bool, SBFunction, operator!=,(const lldb::SBFunction &));
1114     LLDB_REGISTER_METHOD(bool, SBFunction, GetDescription, (lldb::SBStream &));
1115     LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBFunction, GetInstructions,
1116                          (lldb::SBTarget));
1117     LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBFunction, GetInstructions,
1118                          (lldb::SBTarget, const char *));
1119     LLDB_REGISTER_METHOD(lldb::SBAddress, SBFunction, GetStartAddress, ());
1120     LLDB_REGISTER_METHOD(lldb::SBAddress, SBFunction, GetEndAddress, ());
1121     LLDB_REGISTER_METHOD(const char *, SBFunction, GetArgumentName, (uint32_t));
1122     LLDB_REGISTER_METHOD(uint32_t, SBFunction, GetPrologueByteSize, ());
1123     LLDB_REGISTER_METHOD(lldb::SBType, SBFunction, GetType, ());
1124     LLDB_REGISTER_METHOD(lldb::SBBlock, SBFunction, GetBlock, ());
1125     LLDB_REGISTER_METHOD(lldb::LanguageType, SBFunction, GetLanguage, ());
1126     LLDB_REGISTER_METHOD(bool, SBFunction, GetIsOptimized, ());
1127   }
1128   {
1129     LLDB_REGISTER_STATIC_METHOD(lldb::SBFileSpec, SBHostOS, GetProgramFileSpec,
1130                                 ());
1131     LLDB_REGISTER_STATIC_METHOD(lldb::SBFileSpec, SBHostOS, GetLLDBPythonPath,
1132                                 ());
1133     LLDB_REGISTER_STATIC_METHOD(lldb::SBFileSpec, SBHostOS, GetLLDBPath,
1134                                 (lldb::PathType));
1135     LLDB_REGISTER_STATIC_METHOD(lldb::SBFileSpec, SBHostOS,
1136                                 GetUserHomeDirectory, ());
1137     LLDB_REGISTER_STATIC_METHOD(void, SBHostOS, ThreadCreated, (const char *));
1138   }
1139   {
1140     LLDB_REGISTER_CONSTRUCTOR(SBInstruction, ());
1141     LLDB_REGISTER_CONSTRUCTOR(SBInstruction, (const lldb::SBInstruction &));
1142     LLDB_REGISTER_METHOD(
1143         const lldb::SBInstruction &,
1144         SBInstruction, operator=,(const lldb::SBInstruction &));
1145     LLDB_REGISTER_METHOD(bool, SBInstruction, IsValid, ());
1146     LLDB_REGISTER_METHOD_CONST(bool, SBInstruction, operator bool, ());
1147     LLDB_REGISTER_METHOD(lldb::SBAddress, SBInstruction, GetAddress, ());
1148     LLDB_REGISTER_METHOD(const char *, SBInstruction, GetMnemonic,
1149                          (lldb::SBTarget));
1150     LLDB_REGISTER_METHOD(const char *, SBInstruction, GetOperands,
1151                          (lldb::SBTarget));
1152     LLDB_REGISTER_METHOD(const char *, SBInstruction, GetComment,
1153                          (lldb::SBTarget));
1154     LLDB_REGISTER_METHOD(size_t, SBInstruction, GetByteSize, ());
1155     LLDB_REGISTER_METHOD(lldb::SBData, SBInstruction, GetData,
1156                          (lldb::SBTarget));
1157     LLDB_REGISTER_METHOD(bool, SBInstruction, DoesBranch, ());
1158     LLDB_REGISTER_METHOD(bool, SBInstruction, HasDelaySlot, ());
1159     LLDB_REGISTER_METHOD(bool, SBInstruction, CanSetBreakpoint, ());
1160     LLDB_REGISTER_METHOD(bool, SBInstruction, GetDescription,
1161                          (lldb::SBStream &));
1162     LLDB_REGISTER_METHOD(void, SBInstruction, Print, (FILE *));
1163     LLDB_REGISTER_METHOD(bool, SBInstruction, EmulateWithFrame,
1164                          (lldb::SBFrame &, uint32_t));
1165     LLDB_REGISTER_METHOD(bool, SBInstruction, DumpEmulation, (const char *));
1166     LLDB_REGISTER_METHOD(bool, SBInstruction, TestEmulation,
1167                          (lldb::SBStream &, const char *));
1168   }
1169   {
1170     LLDB_REGISTER_CONSTRUCTOR(SBInstructionList, ());
1171     LLDB_REGISTER_CONSTRUCTOR(SBInstructionList,
1172                               (const lldb::SBInstructionList &));
1173     LLDB_REGISTER_METHOD(
1174         const lldb::SBInstructionList &,
1175         SBInstructionList, operator=,(const lldb::SBInstructionList &));
1176     LLDB_REGISTER_METHOD_CONST(bool, SBInstructionList, IsValid, ());
1177     LLDB_REGISTER_METHOD_CONST(bool, SBInstructionList, operator bool, ());
1178     LLDB_REGISTER_METHOD(size_t, SBInstructionList, GetSize, ());
1179     LLDB_REGISTER_METHOD(lldb::SBInstruction, SBInstructionList,
1180                          GetInstructionAtIndex, (uint32_t));
1181     LLDB_REGISTER_METHOD(
1182         size_t, SBInstructionList, GetInstructionsCount,
1183         (const lldb::SBAddress &, const lldb::SBAddress &, bool));
1184     LLDB_REGISTER_METHOD(void, SBInstructionList, Clear, ());
1185     LLDB_REGISTER_METHOD(void, SBInstructionList, AppendInstruction,
1186                          (lldb::SBInstruction));
1187     LLDB_REGISTER_METHOD(void, SBInstructionList, Print, (FILE *));
1188     LLDB_REGISTER_METHOD(bool, SBInstructionList, GetDescription,
1189                          (lldb::SBStream &));
1190     LLDB_REGISTER_METHOD(bool, SBInstructionList,
1191                          DumpEmulationForAllInstructions, (const char *));
1192   }
1193   {
1194     LLDB_REGISTER_STATIC_METHOD(lldb::LanguageType, SBLanguageRuntime,
1195                                 GetLanguageTypeFromString, (const char *));
1196     LLDB_REGISTER_STATIC_METHOD(const char *, SBLanguageRuntime,
1197                                 GetNameForLanguageType, (lldb::LanguageType));
1198   }
1199   {
1200     LLDB_REGISTER_CONSTRUCTOR(SBLaunchInfo, (const char **));
1201     LLDB_REGISTER_METHOD(lldb::pid_t, SBLaunchInfo, GetProcessID, ());
1202     LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetUserID, ());
1203     LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetGroupID, ());
1204     LLDB_REGISTER_METHOD(bool, SBLaunchInfo, UserIDIsValid, ());
1205     LLDB_REGISTER_METHOD(bool, SBLaunchInfo, GroupIDIsValid, ());
1206     LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetUserID, (uint32_t));
1207     LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetGroupID, (uint32_t));
1208     LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBLaunchInfo, GetExecutableFile, ());
1209     LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetExecutableFile,
1210                          (lldb::SBFileSpec, bool));
1211     LLDB_REGISTER_METHOD(lldb::SBListener, SBLaunchInfo, GetListener, ());
1212     LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetListener, (lldb::SBListener &));
1213     LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetNumArguments, ());
1214     LLDB_REGISTER_METHOD(const char *, SBLaunchInfo, GetArgumentAtIndex,
1215                          (uint32_t));
1216     LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetArguments,
1217                          (const char **, bool));
1218     LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetNumEnvironmentEntries, ());
1219     LLDB_REGISTER_METHOD(const char *, SBLaunchInfo, GetEnvironmentEntryAtIndex,
1220                          (uint32_t));
1221     LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetEnvironmentEntries,
1222                          (const char **, bool));
1223     LLDB_REGISTER_METHOD(void, SBLaunchInfo, Clear, ());
1224     LLDB_REGISTER_METHOD_CONST(const char *, SBLaunchInfo, GetWorkingDirectory,
1225                                ());
1226     LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetWorkingDirectory,
1227                          (const char *));
1228     LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetLaunchFlags, ());
1229     LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetLaunchFlags, (uint32_t));
1230     LLDB_REGISTER_METHOD(const char *, SBLaunchInfo, GetProcessPluginName, ());
1231     LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetProcessPluginName,
1232                          (const char *));
1233     LLDB_REGISTER_METHOD(const char *, SBLaunchInfo, GetShell, ());
1234     LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetShell, (const char *));
1235     LLDB_REGISTER_METHOD(bool, SBLaunchInfo, GetShellExpandArguments, ());
1236     LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetShellExpandArguments, (bool));
1237     LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetResumeCount, ());
1238     LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetResumeCount, (uint32_t));
1239     LLDB_REGISTER_METHOD(bool, SBLaunchInfo, AddCloseFileAction, (int));
1240     LLDB_REGISTER_METHOD(bool, SBLaunchInfo, AddDuplicateFileAction,
1241                          (int, int));
1242     LLDB_REGISTER_METHOD(bool, SBLaunchInfo, AddOpenFileAction,
1243                          (int, const char *, bool, bool));
1244     LLDB_REGISTER_METHOD(bool, SBLaunchInfo, AddSuppressFileAction,
1245                          (int, bool, bool));
1246     LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetLaunchEventData,
1247                          (const char *));
1248     LLDB_REGISTER_METHOD_CONST(const char *, SBLaunchInfo, GetLaunchEventData,
1249                                ());
1250     LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetDetachOnError, (bool));
1251     LLDB_REGISTER_METHOD_CONST(bool, SBLaunchInfo, GetDetachOnError, ());
1252   }
1253   {
1254     LLDB_REGISTER_CONSTRUCTOR(SBLineEntry, ());
1255     LLDB_REGISTER_CONSTRUCTOR(SBLineEntry, (const lldb::SBLineEntry &));
1256     LLDB_REGISTER_METHOD(const lldb::SBLineEntry &,
1257                          SBLineEntry, operator=,(const lldb::SBLineEntry &));
1258     LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBLineEntry, GetStartAddress,
1259                                ());
1260     LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBLineEntry, GetEndAddress, ());
1261     LLDB_REGISTER_METHOD_CONST(bool, SBLineEntry, IsValid, ());
1262     LLDB_REGISTER_METHOD_CONST(bool, SBLineEntry, operator bool, ());
1263     LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBLineEntry, GetFileSpec, ());
1264     LLDB_REGISTER_METHOD_CONST(uint32_t, SBLineEntry, GetLine, ());
1265     LLDB_REGISTER_METHOD_CONST(uint32_t, SBLineEntry, GetColumn, ());
1266     LLDB_REGISTER_METHOD(void, SBLineEntry, SetFileSpec, (lldb::SBFileSpec));
1267     LLDB_REGISTER_METHOD(void, SBLineEntry, SetLine, (uint32_t));
1268     LLDB_REGISTER_METHOD(void, SBLineEntry, SetColumn, (uint32_t));
1269     LLDB_REGISTER_METHOD_CONST(
1270         bool, SBLineEntry, operator==,(const lldb::SBLineEntry &));
1271     LLDB_REGISTER_METHOD_CONST(
1272         bool, SBLineEntry, operator!=,(const lldb::SBLineEntry &));
1273     LLDB_REGISTER_METHOD(bool, SBLineEntry, GetDescription, (lldb::SBStream &));
1274   }
1275   {
1276     LLDB_REGISTER_CONSTRUCTOR(SBListener, ());
1277     LLDB_REGISTER_CONSTRUCTOR(SBListener, (const char *));
1278     LLDB_REGISTER_CONSTRUCTOR(SBListener, (const lldb::SBListener &));
1279     LLDB_REGISTER_METHOD(const lldb::SBListener &,
1280                          SBListener, operator=,(const lldb::SBListener &));
1281     LLDB_REGISTER_METHOD_CONST(bool, SBListener, IsValid, ());
1282     LLDB_REGISTER_METHOD_CONST(bool, SBListener, operator bool, ());
1283     LLDB_REGISTER_METHOD(void, SBListener, AddEvent, (const lldb::SBEvent &));
1284     LLDB_REGISTER_METHOD(void, SBListener, Clear, ());
1285     LLDB_REGISTER_METHOD(uint32_t, SBListener, StartListeningForEventClass,
1286                          (lldb::SBDebugger &, const char *, uint32_t));
1287     LLDB_REGISTER_METHOD(bool, SBListener, StopListeningForEventClass,
1288                          (lldb::SBDebugger &, const char *, uint32_t));
1289     LLDB_REGISTER_METHOD(uint32_t, SBListener, StartListeningForEvents,
1290                          (const lldb::SBBroadcaster &, uint32_t));
1291     LLDB_REGISTER_METHOD(bool, SBListener, StopListeningForEvents,
1292                          (const lldb::SBBroadcaster &, uint32_t));
1293     LLDB_REGISTER_METHOD(bool, SBListener, WaitForEvent,
1294                          (uint32_t, lldb::SBEvent &));
1295     LLDB_REGISTER_METHOD(
1296         bool, SBListener, WaitForEventForBroadcaster,
1297         (uint32_t, const lldb::SBBroadcaster &, lldb::SBEvent &));
1298     LLDB_REGISTER_METHOD(
1299         bool, SBListener, WaitForEventForBroadcasterWithType,
1300         (uint32_t, const lldb::SBBroadcaster &, uint32_t, lldb::SBEvent &));
1301     LLDB_REGISTER_METHOD(bool, SBListener, PeekAtNextEvent, (lldb::SBEvent &));
1302     LLDB_REGISTER_METHOD(bool, SBListener, PeekAtNextEventForBroadcaster,
1303                          (const lldb::SBBroadcaster &, lldb::SBEvent &));
1304     LLDB_REGISTER_METHOD(
1305         bool, SBListener, PeekAtNextEventForBroadcasterWithType,
1306         (const lldb::SBBroadcaster &, uint32_t, lldb::SBEvent &));
1307     LLDB_REGISTER_METHOD(bool, SBListener, GetNextEvent, (lldb::SBEvent &));
1308     LLDB_REGISTER_METHOD(bool, SBListener, GetNextEventForBroadcaster,
1309                          (const lldb::SBBroadcaster &, lldb::SBEvent &));
1310     LLDB_REGISTER_METHOD(
1311         bool, SBListener, GetNextEventForBroadcasterWithType,
1312         (const lldb::SBBroadcaster &, uint32_t, lldb::SBEvent &));
1313     LLDB_REGISTER_METHOD(bool, SBListener, HandleBroadcastEvent,
1314                          (const lldb::SBEvent &));
1315   }
1316   {
1317     LLDB_REGISTER_CONSTRUCTOR(SBMemoryRegionInfo, ());
1318     LLDB_REGISTER_CONSTRUCTOR(SBMemoryRegionInfo,
1319                               (const lldb::SBMemoryRegionInfo &));
1320     LLDB_REGISTER_METHOD(
1321         const lldb::SBMemoryRegionInfo &,
1322         SBMemoryRegionInfo, operator=,(const lldb::SBMemoryRegionInfo &));
1323     LLDB_REGISTER_METHOD(void, SBMemoryRegionInfo, Clear, ());
1324     LLDB_REGISTER_METHOD_CONST(
1325         bool,
1326         SBMemoryRegionInfo, operator==,(const lldb::SBMemoryRegionInfo &));
1327     LLDB_REGISTER_METHOD_CONST(
1328         bool,
1329         SBMemoryRegionInfo, operator!=,(const lldb::SBMemoryRegionInfo &));
1330     LLDB_REGISTER_METHOD(lldb::addr_t, SBMemoryRegionInfo, GetRegionBase, ());
1331     LLDB_REGISTER_METHOD(lldb::addr_t, SBMemoryRegionInfo, GetRegionEnd, ());
1332     LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, IsReadable, ());
1333     LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, IsWritable, ());
1334     LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, IsExecutable, ());
1335     LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, IsMapped, ());
1336     LLDB_REGISTER_METHOD(const char *, SBMemoryRegionInfo, GetName, ());
1337     LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, GetDescription,
1338                          (lldb::SBStream &));
1339   }
1340   {
1341     LLDB_REGISTER_CONSTRUCTOR(SBMemoryRegionInfoList, ());
1342     LLDB_REGISTER_CONSTRUCTOR(SBMemoryRegionInfoList,
1343                               (const lldb::SBMemoryRegionInfoList &));
1344     LLDB_REGISTER_METHOD(
1345         const lldb::SBMemoryRegionInfoList &,
1346         SBMemoryRegionInfoList, operator=,(
1347                                     const lldb::SBMemoryRegionInfoList &));
1348     LLDB_REGISTER_METHOD_CONST(uint32_t, SBMemoryRegionInfoList, GetSize, ());
1349     LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfoList, GetMemoryRegionAtIndex,
1350                          (uint32_t, lldb::SBMemoryRegionInfo &));
1351     LLDB_REGISTER_METHOD(void, SBMemoryRegionInfoList, Clear, ());
1352     LLDB_REGISTER_METHOD(void, SBMemoryRegionInfoList, Append,
1353                          (lldb::SBMemoryRegionInfo &));
1354     LLDB_REGISTER_METHOD(void, SBMemoryRegionInfoList, Append,
1355                          (lldb::SBMemoryRegionInfoList &));
1356   }
1357   {
1358     LLDB_REGISTER_CONSTRUCTOR(SBModule, ());
1359     LLDB_REGISTER_CONSTRUCTOR(SBModule, (const lldb::SBModuleSpec &));
1360     LLDB_REGISTER_CONSTRUCTOR(SBModule, (const lldb::SBModule &));
1361     LLDB_REGISTER_CONSTRUCTOR(SBModule, (lldb::SBProcess &, lldb::addr_t));
1362     LLDB_REGISTER_METHOD(const lldb::SBModule &,
1363                          SBModule, operator=,(const lldb::SBModule &));
1364     LLDB_REGISTER_METHOD_CONST(bool, SBModule, IsValid, ());
1365     LLDB_REGISTER_METHOD_CONST(bool, SBModule, operator bool, ());
1366     LLDB_REGISTER_METHOD(void, SBModule, Clear, ());
1367     LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBModule, GetFileSpec, ());
1368     LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBModule, GetPlatformFileSpec,
1369                                ());
1370     LLDB_REGISTER_METHOD(bool, SBModule, SetPlatformFileSpec,
1371                          (const lldb::SBFileSpec &));
1372     LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBModule, GetRemoteInstallFileSpec,
1373                          ());
1374     LLDB_REGISTER_METHOD(bool, SBModule, SetRemoteInstallFileSpec,
1375                          (lldb::SBFileSpec &));
1376     LLDB_REGISTER_METHOD_CONST(const char *, SBModule, GetUUIDString, ());
1377     LLDB_REGISTER_METHOD_CONST(bool,
1378                                SBModule, operator==,(const lldb::SBModule &));
1379     LLDB_REGISTER_METHOD_CONST(bool,
1380                                SBModule, operator!=,(const lldb::SBModule &));
1381     LLDB_REGISTER_METHOD(lldb::SBAddress, SBModule, ResolveFileAddress,
1382                          (lldb::addr_t));
1383     LLDB_REGISTER_METHOD(lldb::SBSymbolContext, SBModule,
1384                          ResolveSymbolContextForAddress,
1385                          (const lldb::SBAddress &, uint32_t));
1386     LLDB_REGISTER_METHOD(bool, SBModule, GetDescription, (lldb::SBStream &));
1387     LLDB_REGISTER_METHOD(uint32_t, SBModule, GetNumCompileUnits, ());
1388     LLDB_REGISTER_METHOD(lldb::SBCompileUnit, SBModule, GetCompileUnitAtIndex,
1389                          (uint32_t));
1390     LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBModule, FindCompileUnits,
1391                          (const lldb::SBFileSpec &));
1392     LLDB_REGISTER_METHOD(size_t, SBModule, GetNumSymbols, ());
1393     LLDB_REGISTER_METHOD(lldb::SBSymbol, SBModule, GetSymbolAtIndex, (size_t));
1394     LLDB_REGISTER_METHOD(lldb::SBSymbol, SBModule, FindSymbol,
1395                          (const char *, lldb::SymbolType));
1396     LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBModule, FindSymbols,
1397                          (const char *, lldb::SymbolType));
1398     LLDB_REGISTER_METHOD(size_t, SBModule, GetNumSections, ());
1399     LLDB_REGISTER_METHOD(lldb::SBSection, SBModule, GetSectionAtIndex,
1400                          (size_t));
1401     LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBModule, FindFunctions,
1402                          (const char *, uint32_t));
1403     LLDB_REGISTER_METHOD(lldb::SBValueList, SBModule, FindGlobalVariables,
1404                          (lldb::SBTarget &, const char *, uint32_t));
1405     LLDB_REGISTER_METHOD(lldb::SBValue, SBModule, FindFirstGlobalVariable,
1406                          (lldb::SBTarget &, const char *));
1407     LLDB_REGISTER_METHOD(lldb::SBType, SBModule, FindFirstType, (const char *));
1408     LLDB_REGISTER_METHOD(lldb::SBType, SBModule, GetBasicType,
1409                          (lldb::BasicType));
1410     LLDB_REGISTER_METHOD(lldb::SBTypeList, SBModule, FindTypes, (const char *));
1411     LLDB_REGISTER_METHOD(lldb::SBType, SBModule, GetTypeByID,
1412                          (lldb::user_id_t));
1413     LLDB_REGISTER_METHOD(lldb::SBTypeList, SBModule, GetTypes, (uint32_t));
1414     LLDB_REGISTER_METHOD(lldb::SBSection, SBModule, FindSection,
1415                          (const char *));
1416     LLDB_REGISTER_METHOD(lldb::ByteOrder, SBModule, GetByteOrder, ());
1417     LLDB_REGISTER_METHOD(const char *, SBModule, GetTriple, ());
1418     LLDB_REGISTER_METHOD(uint32_t, SBModule, GetAddressByteSize, ());
1419     LLDB_REGISTER_METHOD(uint32_t, SBModule, GetVersion,
1420                          (uint32_t *, uint32_t));
1421     LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBModule, GetSymbolFileSpec,
1422                                ());
1423     LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBModule,
1424                                GetObjectFileHeaderAddress, ());
1425     LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBModule,
1426                                GetObjectFileEntryPointAddress, ());
1427   }
1428   {
1429     LLDB_REGISTER_CONSTRUCTOR(SBModuleSpec, ());
1430     LLDB_REGISTER_CONSTRUCTOR(SBModuleSpec, (const lldb::SBModuleSpec &));
1431     LLDB_REGISTER_METHOD(const lldb::SBModuleSpec &,
1432                          SBModuleSpec, operator=,(const lldb::SBModuleSpec &));
1433     LLDB_REGISTER_METHOD_CONST(bool, SBModuleSpec, IsValid, ());
1434     LLDB_REGISTER_METHOD_CONST(bool, SBModuleSpec, operator bool, ());
1435     LLDB_REGISTER_METHOD(void, SBModuleSpec, Clear, ());
1436     LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBModuleSpec, GetFileSpec, ());
1437     LLDB_REGISTER_METHOD(void, SBModuleSpec, SetFileSpec,
1438                          (const lldb::SBFileSpec &));
1439     LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBModuleSpec, GetPlatformFileSpec,
1440                          ());
1441     LLDB_REGISTER_METHOD(void, SBModuleSpec, SetPlatformFileSpec,
1442                          (const lldb::SBFileSpec &));
1443     LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBModuleSpec, GetSymbolFileSpec, ());
1444     LLDB_REGISTER_METHOD(void, SBModuleSpec, SetSymbolFileSpec,
1445                          (const lldb::SBFileSpec &));
1446     LLDB_REGISTER_METHOD(const char *, SBModuleSpec, GetObjectName, ());
1447     LLDB_REGISTER_METHOD(void, SBModuleSpec, SetObjectName, (const char *));
1448     LLDB_REGISTER_METHOD(const char *, SBModuleSpec, GetTriple, ());
1449     LLDB_REGISTER_METHOD(void, SBModuleSpec, SetTriple, (const char *));
1450     LLDB_REGISTER_METHOD(size_t, SBModuleSpec, GetUUIDLength, ());
1451     LLDB_REGISTER_METHOD(bool, SBModuleSpec, GetDescription,
1452                          (lldb::SBStream &));
1453     LLDB_REGISTER_CONSTRUCTOR(SBModuleSpecList, ());
1454     LLDB_REGISTER_CONSTRUCTOR(SBModuleSpecList,
1455                               (const lldb::SBModuleSpecList &));
1456     LLDB_REGISTER_METHOD(
1457         lldb::SBModuleSpecList &,
1458         SBModuleSpecList, operator=,(const lldb::SBModuleSpecList &));
1459     LLDB_REGISTER_STATIC_METHOD(lldb::SBModuleSpecList, SBModuleSpecList,
1460                                 GetModuleSpecifications, (const char *));
1461     LLDB_REGISTER_METHOD(void, SBModuleSpecList, Append,
1462                          (const lldb::SBModuleSpec &));
1463     LLDB_REGISTER_METHOD(void, SBModuleSpecList, Append,
1464                          (const lldb::SBModuleSpecList &));
1465     LLDB_REGISTER_METHOD(size_t, SBModuleSpecList, GetSize, ());
1466     LLDB_REGISTER_METHOD(lldb::SBModuleSpec, SBModuleSpecList, GetSpecAtIndex,
1467                          (size_t));
1468     LLDB_REGISTER_METHOD(lldb::SBModuleSpec, SBModuleSpecList,
1469                          FindFirstMatchingSpec, (const lldb::SBModuleSpec &));
1470     LLDB_REGISTER_METHOD(lldb::SBModuleSpecList, SBModuleSpecList,
1471                          FindMatchingSpecs, (const lldb::SBModuleSpec &));
1472     LLDB_REGISTER_METHOD(bool, SBModuleSpecList, GetDescription,
1473                          (lldb::SBStream &));
1474   }
1475   {
1476     LLDB_REGISTER_CONSTRUCTOR(SBPlatformConnectOptions, (const char *));
1477     LLDB_REGISTER_CONSTRUCTOR(SBPlatformConnectOptions,
1478                               (const lldb::SBPlatformConnectOptions &));
1479     LLDB_REGISTER_METHOD(
1480         void,
1481         SBPlatformConnectOptions, operator=,(
1482                                       const lldb::SBPlatformConnectOptions &));
1483     LLDB_REGISTER_METHOD(const char *, SBPlatformConnectOptions, GetURL, ());
1484     LLDB_REGISTER_METHOD(void, SBPlatformConnectOptions, SetURL,
1485                          (const char *));
1486     LLDB_REGISTER_METHOD(bool, SBPlatformConnectOptions, GetRsyncEnabled, ());
1487     LLDB_REGISTER_METHOD(void, SBPlatformConnectOptions, EnableRsync,
1488                          (const char *, const char *, bool));
1489     LLDB_REGISTER_METHOD(void, SBPlatformConnectOptions, DisableRsync, ());
1490     LLDB_REGISTER_METHOD(const char *, SBPlatformConnectOptions,
1491                          GetLocalCacheDirectory, ());
1492     LLDB_REGISTER_METHOD(void, SBPlatformConnectOptions, SetLocalCacheDirectory,
1493                          (const char *));
1494     LLDB_REGISTER_CONSTRUCTOR(SBPlatformShellCommand, (const char *));
1495     LLDB_REGISTER_CONSTRUCTOR(SBPlatformShellCommand,
1496                               (const lldb::SBPlatformShellCommand &));
1497     LLDB_REGISTER_METHOD(void, SBPlatformShellCommand, Clear, ());
1498     LLDB_REGISTER_METHOD(const char *, SBPlatformShellCommand, GetCommand, ());
1499     LLDB_REGISTER_METHOD(void, SBPlatformShellCommand, SetCommand,
1500                          (const char *));
1501     LLDB_REGISTER_METHOD(const char *, SBPlatformShellCommand,
1502                          GetWorkingDirectory, ());
1503     LLDB_REGISTER_METHOD(void, SBPlatformShellCommand, SetWorkingDirectory,
1504                          (const char *));
1505     LLDB_REGISTER_METHOD(uint32_t, SBPlatformShellCommand, GetTimeoutSeconds,
1506                          ());
1507     LLDB_REGISTER_METHOD(void, SBPlatformShellCommand, SetTimeoutSeconds,
1508                          (uint32_t));
1509     LLDB_REGISTER_METHOD(int, SBPlatformShellCommand, GetSignal, ());
1510     LLDB_REGISTER_METHOD(int, SBPlatformShellCommand, GetStatus, ());
1511     LLDB_REGISTER_METHOD(const char *, SBPlatformShellCommand, GetOutput, ());
1512     LLDB_REGISTER_CONSTRUCTOR(SBPlatform, ());
1513     LLDB_REGISTER_CONSTRUCTOR(SBPlatform, (const char *));
1514     LLDB_REGISTER_METHOD_CONST(bool, SBPlatform, IsValid, ());
1515     LLDB_REGISTER_METHOD_CONST(bool, SBPlatform, operator bool, ());
1516     LLDB_REGISTER_METHOD(void, SBPlatform, Clear, ());
1517     LLDB_REGISTER_METHOD(const char *, SBPlatform, GetName, ());
1518     LLDB_REGISTER_METHOD(const char *, SBPlatform, GetWorkingDirectory, ());
1519     LLDB_REGISTER_METHOD(bool, SBPlatform, SetWorkingDirectory, (const char *));
1520     LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, ConnectRemote,
1521                          (lldb::SBPlatformConnectOptions &));
1522     LLDB_REGISTER_METHOD(void, SBPlatform, DisconnectRemote, ());
1523     LLDB_REGISTER_METHOD(bool, SBPlatform, IsConnected, ());
1524     LLDB_REGISTER_METHOD(const char *, SBPlatform, GetTriple, ());
1525     LLDB_REGISTER_METHOD(const char *, SBPlatform, GetOSBuild, ());
1526     LLDB_REGISTER_METHOD(const char *, SBPlatform, GetOSDescription, ());
1527     LLDB_REGISTER_METHOD(const char *, SBPlatform, GetHostname, ());
1528     LLDB_REGISTER_METHOD(uint32_t, SBPlatform, GetOSMajorVersion, ());
1529     LLDB_REGISTER_METHOD(uint32_t, SBPlatform, GetOSMinorVersion, ());
1530     LLDB_REGISTER_METHOD(uint32_t, SBPlatform, GetOSUpdateVersion, ());
1531     LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Get,
1532                          (lldb::SBFileSpec &, lldb::SBFileSpec &));
1533     LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Put,
1534                          (lldb::SBFileSpec &, lldb::SBFileSpec &));
1535     LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Install,
1536                          (lldb::SBFileSpec &, lldb::SBFileSpec &));
1537     LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Run,
1538                          (lldb::SBPlatformShellCommand &));
1539     LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Launch,
1540                          (lldb::SBLaunchInfo &));
1541     LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Kill, (const lldb::pid_t));
1542     LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, MakeDirectory,
1543                          (const char *, uint32_t));
1544     LLDB_REGISTER_METHOD(uint32_t, SBPlatform, GetFilePermissions,
1545                          (const char *));
1546     LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, SetFilePermissions,
1547                          (const char *, uint32_t));
1548     LLDB_REGISTER_METHOD_CONST(lldb::SBUnixSignals, SBPlatform, GetUnixSignals,
1549                                ());
1550   }
1551   {
1552     LLDB_REGISTER_CONSTRUCTOR(SBProcess, ());
1553     LLDB_REGISTER_CONSTRUCTOR(SBProcess, (const lldb::SBProcess &));
1554     LLDB_REGISTER_CONSTRUCTOR(SBProcess, (const lldb::ProcessSP &));
1555     LLDB_REGISTER_METHOD(const lldb::SBProcess &,
1556                          SBProcess, operator=,(const lldb::SBProcess &));
1557     LLDB_REGISTER_STATIC_METHOD(const char *, SBProcess,
1558                                 GetBroadcasterClassName, ());
1559     LLDB_REGISTER_METHOD(const char *, SBProcess, GetPluginName, ());
1560     LLDB_REGISTER_METHOD(const char *, SBProcess, GetShortPluginName, ());
1561     LLDB_REGISTER_METHOD(void, SBProcess, Clear, ());
1562     LLDB_REGISTER_METHOD_CONST(bool, SBProcess, IsValid, ());
1563     LLDB_REGISTER_METHOD_CONST(bool, SBProcess, operator bool, ());
1564     LLDB_REGISTER_METHOD(bool, SBProcess, RemoteLaunch,
1565                          (const char **, const char **, const char *,
1566                           const char *, const char *, const char *, uint32_t,
1567                           bool, lldb::SBError &));
1568     LLDB_REGISTER_METHOD(bool, SBProcess, RemoteAttachToProcessWithID,
1569                          (lldb::pid_t, lldb::SBError &));
1570     LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetNumThreads, ());
1571     LLDB_REGISTER_METHOD_CONST(lldb::SBThread, SBProcess, GetSelectedThread,
1572                                ());
1573     LLDB_REGISTER_METHOD(lldb::SBThread, SBProcess, CreateOSPluginThread,
1574                          (lldb::tid_t, lldb::addr_t));
1575     LLDB_REGISTER_METHOD_CONST(lldb::SBTarget, SBProcess, GetTarget, ());
1576     LLDB_REGISTER_METHOD(size_t, SBProcess, PutSTDIN, (const char *, size_t));
1577     LLDB_REGISTER_METHOD_CONST(size_t, SBProcess, GetSTDOUT, (char *, size_t));
1578     LLDB_REGISTER_METHOD_CONST(size_t, SBProcess, GetSTDERR, (char *, size_t));
1579     LLDB_REGISTER_METHOD_CONST(size_t, SBProcess, GetAsyncProfileData,
1580                                (char *, size_t));
1581     LLDB_REGISTER_METHOD(lldb::SBTrace, SBProcess, StartTrace,
1582                          (lldb::SBTraceOptions &, lldb::SBError &));
1583     LLDB_REGISTER_METHOD_CONST(void, SBProcess, ReportEventState,
1584                                (const lldb::SBEvent &, FILE *));
1585     LLDB_REGISTER_METHOD(
1586         void, SBProcess, AppendEventStateReport,
1587         (const lldb::SBEvent &, lldb::SBCommandReturnObject &));
1588     LLDB_REGISTER_METHOD(bool, SBProcess, SetSelectedThread,
1589                          (const lldb::SBThread &));
1590     LLDB_REGISTER_METHOD(bool, SBProcess, SetSelectedThreadByID, (lldb::tid_t));
1591     LLDB_REGISTER_METHOD(bool, SBProcess, SetSelectedThreadByIndexID,
1592                          (uint32_t));
1593     LLDB_REGISTER_METHOD(lldb::SBThread, SBProcess, GetThreadAtIndex, (size_t));
1594     LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetNumQueues, ());
1595     LLDB_REGISTER_METHOD(lldb::SBQueue, SBProcess, GetQueueAtIndex, (size_t));
1596     LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetStopID, (bool));
1597     LLDB_REGISTER_METHOD(lldb::SBEvent, SBProcess, GetStopEventForStopID,
1598                          (uint32_t));
1599     LLDB_REGISTER_METHOD(lldb::StateType, SBProcess, GetState, ());
1600     LLDB_REGISTER_METHOD(int, SBProcess, GetExitStatus, ());
1601     LLDB_REGISTER_METHOD(const char *, SBProcess, GetExitDescription, ());
1602     LLDB_REGISTER_METHOD(lldb::pid_t, SBProcess, GetProcessID, ());
1603     LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetUniqueID, ());
1604     LLDB_REGISTER_METHOD_CONST(lldb::ByteOrder, SBProcess, GetByteOrder, ());
1605     LLDB_REGISTER_METHOD_CONST(uint32_t, SBProcess, GetAddressByteSize, ());
1606     LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Continue, ());
1607     LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Destroy, ());
1608     LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Stop, ());
1609     LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Kill, ());
1610     LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Detach, ());
1611     LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Detach, (bool));
1612     LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Signal, (int));
1613     LLDB_REGISTER_METHOD(lldb::SBUnixSignals, SBProcess, GetUnixSignals, ());
1614     LLDB_REGISTER_METHOD(void, SBProcess, SendAsyncInterrupt, ());
1615     LLDB_REGISTER_METHOD(lldb::SBThread, SBProcess, GetThreadByID,
1616                          (lldb::tid_t));
1617     LLDB_REGISTER_METHOD(lldb::SBThread, SBProcess, GetThreadByIndexID,
1618                          (uint32_t));
1619     LLDB_REGISTER_STATIC_METHOD(lldb::StateType, SBProcess, GetStateFromEvent,
1620                                 (const lldb::SBEvent &));
1621     LLDB_REGISTER_STATIC_METHOD(bool, SBProcess, GetRestartedFromEvent,
1622                                 (const lldb::SBEvent &));
1623     LLDB_REGISTER_STATIC_METHOD(size_t, SBProcess,
1624                                 GetNumRestartedReasonsFromEvent,
1625                                 (const lldb::SBEvent &));
1626     LLDB_REGISTER_STATIC_METHOD(const char *, SBProcess,
1627                                 GetRestartedReasonAtIndexFromEvent,
1628                                 (const lldb::SBEvent &, size_t));
1629     LLDB_REGISTER_STATIC_METHOD(lldb::SBProcess, SBProcess, GetProcessFromEvent,
1630                                 (const lldb::SBEvent &));
1631     LLDB_REGISTER_STATIC_METHOD(bool, SBProcess, GetInterruptedFromEvent,
1632                                 (const lldb::SBEvent &));
1633     LLDB_REGISTER_STATIC_METHOD(lldb::SBStructuredData, SBProcess,
1634                                 GetStructuredDataFromEvent,
1635                                 (const lldb::SBEvent &));
1636     LLDB_REGISTER_STATIC_METHOD(bool, SBProcess, EventIsProcessEvent,
1637                                 (const lldb::SBEvent &));
1638     LLDB_REGISTER_STATIC_METHOD(bool, SBProcess, EventIsStructuredDataEvent,
1639                                 (const lldb::SBEvent &));
1640     LLDB_REGISTER_METHOD_CONST(lldb::SBBroadcaster, SBProcess, GetBroadcaster,
1641                                ());
1642     LLDB_REGISTER_STATIC_METHOD(const char *, SBProcess, GetBroadcasterClass,
1643                                 ());
1644     LLDB_REGISTER_METHOD(uint64_t, SBProcess, ReadUnsignedFromMemory,
1645                          (lldb::addr_t, uint32_t, lldb::SBError &));
1646     LLDB_REGISTER_METHOD(lldb::addr_t, SBProcess, ReadPointerFromMemory,
1647                          (lldb::addr_t, lldb::SBError &));
1648     LLDB_REGISTER_METHOD(bool, SBProcess, GetDescription, (lldb::SBStream &));
1649     LLDB_REGISTER_METHOD_CONST(uint32_t, SBProcess,
1650                                GetNumSupportedHardwareWatchpoints,
1651                                (lldb::SBError &));
1652     LLDB_REGISTER_METHOD(uint32_t, SBProcess, LoadImage,
1653                          (lldb::SBFileSpec &, lldb::SBError &));
1654     LLDB_REGISTER_METHOD(
1655         uint32_t, SBProcess, LoadImage,
1656         (const lldb::SBFileSpec &, const lldb::SBFileSpec &, lldb::SBError &));
1657     LLDB_REGISTER_METHOD(uint32_t, SBProcess, LoadImageUsingPaths,
1658                          (const lldb::SBFileSpec &, lldb::SBStringList &,
1659                           lldb::SBFileSpec &, lldb::SBError &));
1660     LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, UnloadImage, (uint32_t));
1661     LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, SendEventData,
1662                          (const char *));
1663     LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetNumExtendedBacktraceTypes, ());
1664     LLDB_REGISTER_METHOD(const char *, SBProcess,
1665                          GetExtendedBacktraceTypeAtIndex, (uint32_t));
1666     LLDB_REGISTER_METHOD(lldb::SBThreadCollection, SBProcess, GetHistoryThreads,
1667                          (lldb::addr_t));
1668     LLDB_REGISTER_METHOD(bool, SBProcess, IsInstrumentationRuntimePresent,
1669                          (lldb::InstrumentationRuntimeType));
1670     LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, SaveCore, (const char *));
1671     LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, GetMemoryRegionInfo,
1672                          (lldb::addr_t, lldb::SBMemoryRegionInfo &));
1673     LLDB_REGISTER_METHOD(lldb::SBMemoryRegionInfoList, SBProcess,
1674                          GetMemoryRegions, ());
1675     LLDB_REGISTER_METHOD(lldb::SBProcessInfo, SBProcess, GetProcessInfo, ());
1676   }
1677   {
1678     LLDB_REGISTER_CONSTRUCTOR(SBProcessInfo, ());
1679     LLDB_REGISTER_CONSTRUCTOR(SBProcessInfo, (const lldb::SBProcessInfo &));
1680     LLDB_REGISTER_METHOD(
1681         lldb::SBProcessInfo &,
1682         SBProcessInfo, operator=,(const lldb::SBProcessInfo &));
1683     LLDB_REGISTER_METHOD_CONST(bool, SBProcessInfo, IsValid, ());
1684     LLDB_REGISTER_METHOD_CONST(bool, SBProcessInfo, operator bool, ());
1685     LLDB_REGISTER_METHOD(const char *, SBProcessInfo, GetName, ());
1686     LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBProcessInfo, GetExecutableFile,
1687                          ());
1688     LLDB_REGISTER_METHOD(lldb::pid_t, SBProcessInfo, GetProcessID, ());
1689     LLDB_REGISTER_METHOD(uint32_t, SBProcessInfo, GetUserID, ());
1690     LLDB_REGISTER_METHOD(uint32_t, SBProcessInfo, GetGroupID, ());
1691     LLDB_REGISTER_METHOD(bool, SBProcessInfo, UserIDIsValid, ());
1692     LLDB_REGISTER_METHOD(bool, SBProcessInfo, GroupIDIsValid, ());
1693     LLDB_REGISTER_METHOD(uint32_t, SBProcessInfo, GetEffectiveUserID, ());
1694     LLDB_REGISTER_METHOD(uint32_t, SBProcessInfo, GetEffectiveGroupID, ());
1695     LLDB_REGISTER_METHOD(bool, SBProcessInfo, EffectiveUserIDIsValid, ());
1696     LLDB_REGISTER_METHOD(bool, SBProcessInfo, EffectiveGroupIDIsValid, ());
1697     LLDB_REGISTER_METHOD(lldb::pid_t, SBProcessInfo, GetParentProcessID, ());
1698   }
1699   {
1700     LLDB_REGISTER_CONSTRUCTOR(SBQueue, ());
1701     LLDB_REGISTER_CONSTRUCTOR(SBQueue, (const lldb::QueueSP &));
1702     LLDB_REGISTER_CONSTRUCTOR(SBQueue, (const lldb::SBQueue &));
1703     LLDB_REGISTER_METHOD(const lldb::SBQueue &,
1704                          SBQueue, operator=,(const lldb::SBQueue &));
1705     LLDB_REGISTER_METHOD_CONST(bool, SBQueue, IsValid, ());
1706     LLDB_REGISTER_METHOD_CONST(bool, SBQueue, operator bool, ());
1707     LLDB_REGISTER_METHOD(void, SBQueue, Clear, ());
1708     LLDB_REGISTER_METHOD_CONST(lldb::queue_id_t, SBQueue, GetQueueID, ());
1709     LLDB_REGISTER_METHOD_CONST(uint32_t, SBQueue, GetIndexID, ());
1710     LLDB_REGISTER_METHOD_CONST(const char *, SBQueue, GetName, ());
1711     LLDB_REGISTER_METHOD(uint32_t, SBQueue, GetNumThreads, ());
1712     LLDB_REGISTER_METHOD(lldb::SBThread, SBQueue, GetThreadAtIndex, (uint32_t));
1713     LLDB_REGISTER_METHOD(uint32_t, SBQueue, GetNumPendingItems, ());
1714     LLDB_REGISTER_METHOD(lldb::SBQueueItem, SBQueue, GetPendingItemAtIndex,
1715                          (uint32_t));
1716     LLDB_REGISTER_METHOD(uint32_t, SBQueue, GetNumRunningItems, ());
1717     LLDB_REGISTER_METHOD(lldb::SBProcess, SBQueue, GetProcess, ());
1718     LLDB_REGISTER_METHOD(lldb::QueueKind, SBQueue, GetKind, ());
1719   }
1720   {
1721     LLDB_REGISTER_CONSTRUCTOR(SBQueueItem, ());
1722     LLDB_REGISTER_CONSTRUCTOR(SBQueueItem, (const lldb::QueueItemSP &));
1723     LLDB_REGISTER_METHOD_CONST(bool, SBQueueItem, IsValid, ());
1724     LLDB_REGISTER_METHOD_CONST(bool, SBQueueItem, operator bool, ());
1725     LLDB_REGISTER_METHOD(void, SBQueueItem, Clear, ());
1726     LLDB_REGISTER_METHOD(void, SBQueueItem, SetQueueItem,
1727                          (const lldb::QueueItemSP &));
1728     LLDB_REGISTER_METHOD_CONST(lldb::QueueItemKind, SBQueueItem, GetKind, ());
1729     LLDB_REGISTER_METHOD(void, SBQueueItem, SetKind, (lldb::QueueItemKind));
1730     LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBQueueItem, GetAddress, ());
1731     LLDB_REGISTER_METHOD(void, SBQueueItem, SetAddress, (lldb::SBAddress));
1732     LLDB_REGISTER_METHOD(lldb::SBThread, SBQueueItem,
1733                          GetExtendedBacktraceThread, (const char *));
1734   }
1735   {
1736     LLDB_REGISTER_CONSTRUCTOR(SBSection, ());
1737     LLDB_REGISTER_CONSTRUCTOR(SBSection, (const lldb::SBSection &));
1738     LLDB_REGISTER_METHOD(const lldb::SBSection &,
1739                          SBSection, operator=,(const lldb::SBSection &));
1740     LLDB_REGISTER_METHOD_CONST(bool, SBSection, IsValid, ());
1741     LLDB_REGISTER_METHOD_CONST(bool, SBSection, operator bool, ());
1742     LLDB_REGISTER_METHOD(const char *, SBSection, GetName, ());
1743     LLDB_REGISTER_METHOD(lldb::SBSection, SBSection, GetParent, ());
1744     LLDB_REGISTER_METHOD(lldb::SBSection, SBSection, FindSubSection,
1745                          (const char *));
1746     LLDB_REGISTER_METHOD(size_t, SBSection, GetNumSubSections, ());
1747     LLDB_REGISTER_METHOD(lldb::SBSection, SBSection, GetSubSectionAtIndex,
1748                          (size_t));
1749     LLDB_REGISTER_METHOD(lldb::addr_t, SBSection, GetFileAddress, ());
1750     LLDB_REGISTER_METHOD(lldb::addr_t, SBSection, GetLoadAddress,
1751                          (lldb::SBTarget &));
1752     LLDB_REGISTER_METHOD(lldb::addr_t, SBSection, GetByteSize, ());
1753     LLDB_REGISTER_METHOD(uint64_t, SBSection, GetFileOffset, ());
1754     LLDB_REGISTER_METHOD(uint64_t, SBSection, GetFileByteSize, ());
1755     LLDB_REGISTER_METHOD(lldb::SBData, SBSection, GetSectionData, ());
1756     LLDB_REGISTER_METHOD(lldb::SBData, SBSection, GetSectionData,
1757                          (uint64_t, uint64_t));
1758     LLDB_REGISTER_METHOD(lldb::SectionType, SBSection, GetSectionType, ());
1759     LLDB_REGISTER_METHOD_CONST(uint32_t, SBSection, GetPermissions, ());
1760     LLDB_REGISTER_METHOD(uint32_t, SBSection, GetTargetByteSize, ());
1761     LLDB_REGISTER_METHOD(bool, SBSection, operator==,(const lldb::SBSection &));
1762     LLDB_REGISTER_METHOD(bool, SBSection, operator!=,(const lldb::SBSection &));
1763     LLDB_REGISTER_METHOD(bool, SBSection, GetDescription, (lldb::SBStream &));
1764   }
1765   {
1766     LLDB_REGISTER_CONSTRUCTOR(SBSourceManager, (const lldb::SBDebugger &));
1767     LLDB_REGISTER_CONSTRUCTOR(SBSourceManager, (const lldb::SBTarget &));
1768     LLDB_REGISTER_CONSTRUCTOR(SBSourceManager, (const lldb::SBSourceManager &));
1769     LLDB_REGISTER_METHOD(
1770         const lldb::SBSourceManager &,
1771         SBSourceManager, operator=,(const lldb::SBSourceManager &));
1772     LLDB_REGISTER_METHOD(size_t, SBSourceManager,
1773                          DisplaySourceLinesWithLineNumbers,
1774                          (const lldb::SBFileSpec &, uint32_t, uint32_t,
1775                           uint32_t, const char *, lldb::SBStream &));
1776     LLDB_REGISTER_METHOD(size_t, SBSourceManager,
1777                          DisplaySourceLinesWithLineNumbersAndColumn,
1778                          (const lldb::SBFileSpec &, uint32_t, uint32_t,
1779                           uint32_t, uint32_t, const char *, lldb::SBStream &));
1780   }
1781   {
1782     LLDB_REGISTER_CONSTRUCTOR(SBStream, ());
1783     LLDB_REGISTER_METHOD_CONST(bool, SBStream, IsValid, ());
1784     LLDB_REGISTER_METHOD_CONST(bool, SBStream, operator bool, ());
1785     LLDB_REGISTER_METHOD(const char *, SBStream, GetData, ());
1786     LLDB_REGISTER_METHOD(size_t, SBStream, GetSize, ());
1787     LLDB_REGISTER_METHOD(void, SBStream, RedirectToFile, (const char *, bool));
1788     LLDB_REGISTER_METHOD(void, SBStream, RedirectToFileHandle, (FILE *, bool));
1789     LLDB_REGISTER_METHOD(void, SBStream, RedirectToFileDescriptor, (int, bool));
1790     LLDB_REGISTER_METHOD(void, SBStream, Clear, ());
1791   }
1792   {
1793     LLDB_REGISTER_CONSTRUCTOR(SBStringList, ());
1794     LLDB_REGISTER_CONSTRUCTOR(SBStringList, (const lldb::SBStringList &));
1795     LLDB_REGISTER_METHOD(const lldb::SBStringList &,
1796                          SBStringList, operator=,(const lldb::SBStringList &));
1797     LLDB_REGISTER_METHOD_CONST(bool, SBStringList, IsValid, ());
1798     LLDB_REGISTER_METHOD_CONST(bool, SBStringList, operator bool, ());
1799     LLDB_REGISTER_METHOD(void, SBStringList, AppendString, (const char *));
1800     LLDB_REGISTER_METHOD(void, SBStringList, AppendList, (const char **, int));
1801     LLDB_REGISTER_METHOD(void, SBStringList, AppendList,
1802                          (const lldb::SBStringList &));
1803     LLDB_REGISTER_METHOD_CONST(uint32_t, SBStringList, GetSize, ());
1804     LLDB_REGISTER_METHOD(const char *, SBStringList, GetStringAtIndex,
1805                          (size_t));
1806     LLDB_REGISTER_METHOD_CONST(const char *, SBStringList, GetStringAtIndex,
1807                                (size_t));
1808     LLDB_REGISTER_METHOD(void, SBStringList, Clear, ());
1809   }
1810   {
1811     LLDB_REGISTER_CONSTRUCTOR(SBStructuredData, ());
1812     LLDB_REGISTER_CONSTRUCTOR(SBStructuredData,
1813                               (const lldb::SBStructuredData &));
1814     LLDB_REGISTER_CONSTRUCTOR(SBStructuredData, (const lldb::EventSP &));
1815     LLDB_REGISTER_CONSTRUCTOR(SBStructuredData,
1816                               (lldb_private::StructuredDataImpl *));
1817     LLDB_REGISTER_METHOD(
1818         lldb::SBStructuredData &,
1819         SBStructuredData, operator=,(const lldb::SBStructuredData &));
1820     LLDB_REGISTER_METHOD(lldb::SBError, SBStructuredData, SetFromJSON,
1821                          (lldb::SBStream &));
1822     LLDB_REGISTER_METHOD_CONST(bool, SBStructuredData, IsValid, ());
1823     LLDB_REGISTER_METHOD_CONST(bool, SBStructuredData, operator bool, ());
1824     LLDB_REGISTER_METHOD(void, SBStructuredData, Clear, ());
1825     LLDB_REGISTER_METHOD_CONST(lldb::SBError, SBStructuredData, GetAsJSON,
1826                                (lldb::SBStream &));
1827     LLDB_REGISTER_METHOD_CONST(lldb::SBError, SBStructuredData, GetDescription,
1828                                (lldb::SBStream &));
1829     LLDB_REGISTER_METHOD_CONST(lldb::StructuredDataType, SBStructuredData,
1830                                GetType, ());
1831     LLDB_REGISTER_METHOD_CONST(size_t, SBStructuredData, GetSize, ());
1832     LLDB_REGISTER_METHOD_CONST(bool, SBStructuredData, GetKeys,
1833                                (lldb::SBStringList &));
1834     LLDB_REGISTER_METHOD_CONST(lldb::SBStructuredData, SBStructuredData,
1835                                GetValueForKey, (const char *));
1836     LLDB_REGISTER_METHOD_CONST(lldb::SBStructuredData, SBStructuredData,
1837                                GetItemAtIndex, (size_t));
1838     LLDB_REGISTER_METHOD_CONST(uint64_t, SBStructuredData, GetIntegerValue,
1839                                (uint64_t));
1840     LLDB_REGISTER_METHOD_CONST(double, SBStructuredData, GetFloatValue,
1841                                (double));
1842     LLDB_REGISTER_METHOD_CONST(bool, SBStructuredData, GetBooleanValue, (bool));
1843     LLDB_REGISTER_METHOD_CONST(size_t, SBStructuredData, GetStringValue,
1844                                (char *, size_t));
1845   }
1846   {
1847     LLDB_REGISTER_CONSTRUCTOR(SBSymbol, ());
1848     LLDB_REGISTER_CONSTRUCTOR(SBSymbol, (const lldb::SBSymbol &));
1849     LLDB_REGISTER_METHOD(const lldb::SBSymbol &,
1850                          SBSymbol, operator=,(const lldb::SBSymbol &));
1851     LLDB_REGISTER_METHOD_CONST(bool, SBSymbol, IsValid, ());
1852     LLDB_REGISTER_METHOD_CONST(bool, SBSymbol, operator bool, ());
1853     LLDB_REGISTER_METHOD_CONST(const char *, SBSymbol, GetName, ());
1854     LLDB_REGISTER_METHOD_CONST(const char *, SBSymbol, GetDisplayName, ());
1855     LLDB_REGISTER_METHOD_CONST(const char *, SBSymbol, GetMangledName, ());
1856     LLDB_REGISTER_METHOD_CONST(bool,
1857                                SBSymbol, operator==,(const lldb::SBSymbol &));
1858     LLDB_REGISTER_METHOD_CONST(bool,
1859                                SBSymbol, operator!=,(const lldb::SBSymbol &));
1860     LLDB_REGISTER_METHOD(bool, SBSymbol, GetDescription, (lldb::SBStream &));
1861     LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBSymbol, GetInstructions,
1862                          (lldb::SBTarget));
1863     LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBSymbol, GetInstructions,
1864                          (lldb::SBTarget, const char *));
1865     LLDB_REGISTER_METHOD(lldb::SBAddress, SBSymbol, GetStartAddress, ());
1866     LLDB_REGISTER_METHOD(lldb::SBAddress, SBSymbol, GetEndAddress, ());
1867     LLDB_REGISTER_METHOD(uint32_t, SBSymbol, GetPrologueByteSize, ());
1868     LLDB_REGISTER_METHOD(lldb::SymbolType, SBSymbol, GetType, ());
1869     LLDB_REGISTER_METHOD(bool, SBSymbol, IsExternal, ());
1870     LLDB_REGISTER_METHOD(bool, SBSymbol, IsSynthetic, ());
1871   }
1872   {
1873     LLDB_REGISTER_CONSTRUCTOR(SBSymbolContext, ());
1874     LLDB_REGISTER_CONSTRUCTOR(SBSymbolContext,
1875                               (const lldb_private::SymbolContext *));
1876     LLDB_REGISTER_CONSTRUCTOR(SBSymbolContext, (const lldb::SBSymbolContext &));
1877     LLDB_REGISTER_METHOD(
1878         const lldb::SBSymbolContext &,
1879         SBSymbolContext, operator=,(const lldb::SBSymbolContext &));
1880     LLDB_REGISTER_METHOD_CONST(bool, SBSymbolContext, IsValid, ());
1881     LLDB_REGISTER_METHOD_CONST(bool, SBSymbolContext, operator bool, ());
1882     LLDB_REGISTER_METHOD(lldb::SBModule, SBSymbolContext, GetModule, ());
1883     LLDB_REGISTER_METHOD(lldb::SBCompileUnit, SBSymbolContext, GetCompileUnit,
1884                          ());
1885     LLDB_REGISTER_METHOD(lldb::SBFunction, SBSymbolContext, GetFunction, ());
1886     LLDB_REGISTER_METHOD(lldb::SBBlock, SBSymbolContext, GetBlock, ());
1887     LLDB_REGISTER_METHOD(lldb::SBLineEntry, SBSymbolContext, GetLineEntry, ());
1888     LLDB_REGISTER_METHOD(lldb::SBSymbol, SBSymbolContext, GetSymbol, ());
1889     LLDB_REGISTER_METHOD(void, SBSymbolContext, SetModule, (lldb::SBModule));
1890     LLDB_REGISTER_METHOD(void, SBSymbolContext, SetCompileUnit,
1891                          (lldb::SBCompileUnit));
1892     LLDB_REGISTER_METHOD(void, SBSymbolContext, SetFunction,
1893                          (lldb::SBFunction));
1894     LLDB_REGISTER_METHOD(void, SBSymbolContext, SetBlock, (lldb::SBBlock));
1895     LLDB_REGISTER_METHOD(void, SBSymbolContext, SetLineEntry,
1896                          (lldb::SBLineEntry));
1897     LLDB_REGISTER_METHOD(void, SBSymbolContext, SetSymbol, (lldb::SBSymbol));
1898     LLDB_REGISTER_METHOD(bool, SBSymbolContext, GetDescription,
1899                          (lldb::SBStream &));
1900     LLDB_REGISTER_METHOD_CONST(lldb::SBSymbolContext, SBSymbolContext,
1901                                GetParentOfInlinedScope,
1902                                (const lldb::SBAddress &, lldb::SBAddress &));
1903   }
1904   {
1905     LLDB_REGISTER_CONSTRUCTOR(SBSymbolContextList, ());
1906     LLDB_REGISTER_CONSTRUCTOR(SBSymbolContextList,
1907                               (const lldb::SBSymbolContextList &));
1908     LLDB_REGISTER_METHOD(
1909         const lldb::SBSymbolContextList &,
1910         SBSymbolContextList, operator=,(const lldb::SBSymbolContextList &));
1911     LLDB_REGISTER_METHOD_CONST(uint32_t, SBSymbolContextList, GetSize, ());
1912     LLDB_REGISTER_METHOD(lldb::SBSymbolContext, SBSymbolContextList,
1913                          GetContextAtIndex, (uint32_t));
1914     LLDB_REGISTER_METHOD(void, SBSymbolContextList, Clear, ());
1915     LLDB_REGISTER_METHOD(void, SBSymbolContextList, Append,
1916                          (lldb::SBSymbolContext &));
1917     LLDB_REGISTER_METHOD(void, SBSymbolContextList, Append,
1918                          (lldb::SBSymbolContextList &));
1919     LLDB_REGISTER_METHOD_CONST(bool, SBSymbolContextList, IsValid, ());
1920     LLDB_REGISTER_METHOD_CONST(bool, SBSymbolContextList, operator bool, ());
1921     LLDB_REGISTER_METHOD(bool, SBSymbolContextList, GetDescription,
1922                          (lldb::SBStream &));
1923   }
1924   {
1925     LLDB_REGISTER_CONSTRUCTOR(SBTarget, ());
1926     LLDB_REGISTER_CONSTRUCTOR(SBTarget, (const lldb::SBTarget &));
1927     LLDB_REGISTER_CONSTRUCTOR(SBTarget, (const lldb::TargetSP &));
1928     LLDB_REGISTER_METHOD(const lldb::SBTarget &,
1929                          SBTarget, operator=,(const lldb::SBTarget &));
1930     LLDB_REGISTER_STATIC_METHOD(bool, SBTarget, EventIsTargetEvent,
1931                                 (const lldb::SBEvent &));
1932     LLDB_REGISTER_STATIC_METHOD(lldb::SBTarget, SBTarget, GetTargetFromEvent,
1933                                 (const lldb::SBEvent &));
1934     LLDB_REGISTER_STATIC_METHOD(uint32_t, SBTarget, GetNumModulesFromEvent,
1935                                 (const lldb::SBEvent &));
1936     LLDB_REGISTER_STATIC_METHOD(lldb::SBModule, SBTarget,
1937                                 GetModuleAtIndexFromEvent,
1938                                 (const uint32_t, const lldb::SBEvent &));
1939     LLDB_REGISTER_STATIC_METHOD(const char *, SBTarget, GetBroadcasterClassName,
1940                                 ());
1941     LLDB_REGISTER_METHOD_CONST(bool, SBTarget, IsValid, ());
1942     LLDB_REGISTER_METHOD_CONST(bool, SBTarget, operator bool, ());
1943     LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, GetProcess, ());
1944     LLDB_REGISTER_METHOD(lldb::SBPlatform, SBTarget, GetPlatform, ());
1945     LLDB_REGISTER_METHOD_CONST(lldb::SBDebugger, SBTarget, GetDebugger, ());
1946     LLDB_REGISTER_METHOD(lldb::SBStructuredData, SBTarget, GetStatistics, ());
1947     LLDB_REGISTER_METHOD(void, SBTarget, SetCollectingStats, (bool));
1948     LLDB_REGISTER_METHOD(bool, SBTarget, GetCollectingStats, ());
1949     LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, LoadCore, (const char *));
1950     LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, LoadCore,
1951                          (const char *, lldb::SBError &));
1952     LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, LaunchSimple,
1953                          (const char **, const char **, const char *));
1954     LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, Install, ());
1955     LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, Launch,
1956                          (lldb::SBListener &, const char **, const char **,
1957                           const char *, const char *, const char *,
1958                           const char *, uint32_t, bool, lldb::SBError &));
1959     LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, Launch,
1960                          (lldb::SBLaunchInfo &, lldb::SBError &));
1961     LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, Attach,
1962                          (lldb::SBAttachInfo &, lldb::SBError &));
1963     LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, AttachToProcessWithID,
1964                          (lldb::SBListener &, lldb::pid_t, lldb::SBError &));
1965     LLDB_REGISTER_METHOD(
1966         lldb::SBProcess, SBTarget, AttachToProcessWithName,
1967         (lldb::SBListener &, const char *, bool, lldb::SBError &));
1968     LLDB_REGISTER_METHOD(
1969         lldb::SBProcess, SBTarget, ConnectRemote,
1970         (lldb::SBListener &, const char *, const char *, lldb::SBError &));
1971     LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBTarget, GetExecutable, ());
1972     LLDB_REGISTER_METHOD_CONST(bool,
1973                                SBTarget, operator==,(const lldb::SBTarget &));
1974     LLDB_REGISTER_METHOD_CONST(bool,
1975                                SBTarget, operator!=,(const lldb::SBTarget &));
1976     LLDB_REGISTER_METHOD(lldb::SBAddress, SBTarget, ResolveLoadAddress,
1977                          (lldb::addr_t));
1978     LLDB_REGISTER_METHOD(lldb::SBAddress, SBTarget, ResolveFileAddress,
1979                          (lldb::addr_t));
1980     LLDB_REGISTER_METHOD(lldb::SBAddress, SBTarget, ResolvePastLoadAddress,
1981                          (uint32_t, lldb::addr_t));
1982     LLDB_REGISTER_METHOD(lldb::SBSymbolContext, SBTarget,
1983                          ResolveSymbolContextForAddress,
1984                          (const lldb::SBAddress &, uint32_t));
1985     LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
1986                          BreakpointCreateByLocation, (const char *, uint32_t));
1987     LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
1988                          BreakpointCreateByLocation,
1989                          (const lldb::SBFileSpec &, uint32_t));
1990     LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
1991                          BreakpointCreateByLocation,
1992                          (const lldb::SBFileSpec &, uint32_t, lldb::addr_t));
1993     LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
1994                          BreakpointCreateByLocation,
1995                          (const lldb::SBFileSpec &, uint32_t, lldb::addr_t,
1996                           lldb::SBFileSpecList &));
1997     LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
1998                          BreakpointCreateByLocation,
1999                          (const lldb::SBFileSpec &, uint32_t, uint32_t,
2000                           lldb::addr_t, lldb::SBFileSpecList &));
2001     LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
2002                          (const char *, const char *));
2003     LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
2004                          (const char *, const lldb::SBFileSpecList &,
2005                           const lldb::SBFileSpecList &));
2006     LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
2007                          (const char *, uint32_t, const lldb::SBFileSpecList &,
2008                           const lldb::SBFileSpecList &));
2009     LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
2010                          (const char *, uint32_t, lldb::LanguageType,
2011                           const lldb::SBFileSpecList &,
2012                           const lldb::SBFileSpecList &));
2013     LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames,
2014                          (const char **, uint32_t, uint32_t,
2015                           const lldb::SBFileSpecList &,
2016                           const lldb::SBFileSpecList &));
2017     LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames,
2018                          (const char **, uint32_t, uint32_t, lldb::LanguageType,
2019                           const lldb::SBFileSpecList &,
2020                           const lldb::SBFileSpecList &));
2021     LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames,
2022                          (const char **, uint32_t, uint32_t, lldb::LanguageType,
2023                           lldb::addr_t, const lldb::SBFileSpecList &,
2024                           const lldb::SBFileSpecList &));
2025     LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex,
2026                          (const char *, const char *));
2027     LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex,
2028                          (const char *, const lldb::SBFileSpecList &,
2029                           const lldb::SBFileSpecList &));
2030     LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex,
2031                          (const char *, lldb::LanguageType,
2032                           const lldb::SBFileSpecList &,
2033                           const lldb::SBFileSpecList &));
2034     LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
2035                          BreakpointCreateByAddress, (lldb::addr_t));
2036     LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
2037                          BreakpointCreateBySBAddress, (lldb::SBAddress &));
2038     LLDB_REGISTER_METHOD(
2039         lldb::SBBreakpoint, SBTarget, BreakpointCreateBySourceRegex,
2040         (const char *, const lldb::SBFileSpec &, const char *));
2041     LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
2042                          BreakpointCreateBySourceRegex,
2043                          (const char *, const lldb::SBFileSpecList &,
2044                           const lldb::SBFileSpecList &));
2045     LLDB_REGISTER_METHOD(
2046         lldb::SBBreakpoint, SBTarget, BreakpointCreateBySourceRegex,
2047         (const char *, const lldb::SBFileSpecList &,
2048          const lldb::SBFileSpecList &, const lldb::SBStringList &));
2049     LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
2050                          BreakpointCreateForException,
2051                          (lldb::LanguageType, bool, bool));
2052     LLDB_REGISTER_METHOD(
2053         lldb::SBBreakpoint, SBTarget, BreakpointCreateFromScript,
2054         (const char *, lldb::SBStructuredData &, const lldb::SBFileSpecList &,
2055          const lldb::SBFileSpecList &, bool));
2056     LLDB_REGISTER_METHOD_CONST(uint32_t, SBTarget, GetNumBreakpoints, ());
2057     LLDB_REGISTER_METHOD_CONST(lldb::SBBreakpoint, SBTarget,
2058                                GetBreakpointAtIndex, (uint32_t));
2059     LLDB_REGISTER_METHOD(bool, SBTarget, BreakpointDelete, (lldb::break_id_t));
2060     LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, FindBreakpointByID,
2061                          (lldb::break_id_t));
2062     LLDB_REGISTER_METHOD(bool, SBTarget, FindBreakpointsByName,
2063                          (const char *, lldb::SBBreakpointList &));
2064     LLDB_REGISTER_METHOD(void, SBTarget, GetBreakpointNames,
2065                          (lldb::SBStringList &));
2066     LLDB_REGISTER_METHOD(void, SBTarget, DeleteBreakpointName, (const char *));
2067     LLDB_REGISTER_METHOD(bool, SBTarget, EnableAllBreakpoints, ());
2068     LLDB_REGISTER_METHOD(bool, SBTarget, DisableAllBreakpoints, ());
2069     LLDB_REGISTER_METHOD(bool, SBTarget, DeleteAllBreakpoints, ());
2070     LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, BreakpointsCreateFromFile,
2071                          (lldb::SBFileSpec &, lldb::SBBreakpointList &));
2072     LLDB_REGISTER_METHOD(
2073         lldb::SBError, SBTarget, BreakpointsCreateFromFile,
2074         (lldb::SBFileSpec &, lldb::SBStringList &, lldb::SBBreakpointList &));
2075     LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, BreakpointsWriteToFile,
2076                          (lldb::SBFileSpec &));
2077     LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, BreakpointsWriteToFile,
2078                          (lldb::SBFileSpec &, lldb::SBBreakpointList &, bool));
2079     LLDB_REGISTER_METHOD_CONST(uint32_t, SBTarget, GetNumWatchpoints, ());
2080     LLDB_REGISTER_METHOD_CONST(lldb::SBWatchpoint, SBTarget,
2081                                GetWatchpointAtIndex, (uint32_t));
2082     LLDB_REGISTER_METHOD(bool, SBTarget, DeleteWatchpoint, (lldb::watch_id_t));
2083     LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBTarget, FindWatchpointByID,
2084                          (lldb::watch_id_t));
2085     LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBTarget, WatchAddress,
2086                          (lldb::addr_t, size_t, bool, bool, lldb::SBError &));
2087     LLDB_REGISTER_METHOD(bool, SBTarget, EnableAllWatchpoints, ());
2088     LLDB_REGISTER_METHOD(bool, SBTarget, DisableAllWatchpoints, ());
2089     LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, CreateValueFromAddress,
2090                          (const char *, lldb::SBAddress, lldb::SBType));
2091     LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, CreateValueFromData,
2092                          (const char *, lldb::SBData, lldb::SBType));
2093     LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, CreateValueFromExpression,
2094                          (const char *, const char *));
2095     LLDB_REGISTER_METHOD(bool, SBTarget, DeleteAllWatchpoints, ());
2096     LLDB_REGISTER_METHOD(void, SBTarget, AppendImageSearchPath,
2097                          (const char *, const char *, lldb::SBError &));
2098     LLDB_REGISTER_METHOD(lldb::SBModule, SBTarget, AddModule,
2099                          (const char *, const char *, const char *));
2100     LLDB_REGISTER_METHOD(
2101         lldb::SBModule, SBTarget, AddModule,
2102         (const char *, const char *, const char *, const char *));
2103     LLDB_REGISTER_METHOD(lldb::SBModule, SBTarget, AddModule,
2104                          (const lldb::SBModuleSpec &));
2105     LLDB_REGISTER_METHOD(bool, SBTarget, AddModule, (lldb::SBModule &));
2106     LLDB_REGISTER_METHOD_CONST(uint32_t, SBTarget, GetNumModules, ());
2107     LLDB_REGISTER_METHOD(void, SBTarget, Clear, ());
2108     LLDB_REGISTER_METHOD(lldb::SBModule, SBTarget, FindModule,
2109                          (const lldb::SBFileSpec &));
2110     LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBTarget, FindCompileUnits,
2111                          (const lldb::SBFileSpec &));
2112     LLDB_REGISTER_METHOD(lldb::ByteOrder, SBTarget, GetByteOrder, ());
2113     LLDB_REGISTER_METHOD(const char *, SBTarget, GetTriple, ());
2114     LLDB_REGISTER_METHOD(uint32_t, SBTarget, GetDataByteSize, ());
2115     LLDB_REGISTER_METHOD(uint32_t, SBTarget, GetCodeByteSize, ());
2116     LLDB_REGISTER_METHOD(uint32_t, SBTarget, GetAddressByteSize, ());
2117     LLDB_REGISTER_METHOD(lldb::SBModule, SBTarget, GetModuleAtIndex,
2118                          (uint32_t));
2119     LLDB_REGISTER_METHOD(bool, SBTarget, RemoveModule, (lldb::SBModule));
2120     LLDB_REGISTER_METHOD_CONST(lldb::SBBroadcaster, SBTarget, GetBroadcaster,
2121                                ());
2122     LLDB_REGISTER_METHOD(bool, SBTarget, GetDescription,
2123                          (lldb::SBStream &, lldb::DescriptionLevel));
2124     LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBTarget, FindFunctions,
2125                          (const char *, uint32_t));
2126     LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBTarget,
2127                          FindGlobalFunctions,
2128                          (const char *, uint32_t, lldb::MatchType));
2129     LLDB_REGISTER_METHOD(lldb::SBType, SBTarget, FindFirstType, (const char *));
2130     LLDB_REGISTER_METHOD(lldb::SBType, SBTarget, GetBasicType,
2131                          (lldb::BasicType));
2132     LLDB_REGISTER_METHOD(lldb::SBTypeList, SBTarget, FindTypes, (const char *));
2133     LLDB_REGISTER_METHOD(lldb::SBValueList, SBTarget, FindGlobalVariables,
2134                          (const char *, uint32_t));
2135     LLDB_REGISTER_METHOD(lldb::SBValueList, SBTarget, FindGlobalVariables,
2136                          (const char *, uint32_t, lldb::MatchType));
2137     LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, FindFirstGlobalVariable,
2138                          (const char *));
2139     LLDB_REGISTER_METHOD(lldb::SBSourceManager, SBTarget, GetSourceManager, ());
2140     LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBTarget, ReadInstructions,
2141                          (lldb::SBAddress, uint32_t));
2142     LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBTarget, ReadInstructions,
2143                          (lldb::SBAddress, uint32_t, const char *));
2144     LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, SetSectionLoadAddress,
2145                          (lldb::SBSection, lldb::addr_t));
2146     LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, ClearSectionLoadAddress,
2147                          (lldb::SBSection));
2148     LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, SetModuleLoadAddress,
2149                          (lldb::SBModule, int64_t));
2150     LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, ClearModuleLoadAddress,
2151                          (lldb::SBModule));
2152     LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBTarget, FindSymbols,
2153                          (const char *, lldb::SymbolType));
2154     LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, EvaluateExpression,
2155                          (const char *));
2156     LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, EvaluateExpression,
2157                          (const char *, const lldb::SBExpressionOptions &));
2158     LLDB_REGISTER_METHOD(lldb::addr_t, SBTarget, GetStackRedZoneSize, ());
2159     LLDB_REGISTER_METHOD_CONST(lldb::SBLaunchInfo, SBTarget, GetLaunchInfo, ());
2160     LLDB_REGISTER_METHOD(void, SBTarget, SetLaunchInfo,
2161                          (const lldb::SBLaunchInfo &));
2162   }
2163   {
2164     LLDB_REGISTER_STATIC_METHOD(const char *, SBThread, GetBroadcasterClassName,
2165                                 ());
2166     LLDB_REGISTER_CONSTRUCTOR(SBThread, ());
2167     LLDB_REGISTER_CONSTRUCTOR(SBThread, (const lldb::ThreadSP &));
2168     LLDB_REGISTER_CONSTRUCTOR(SBThread, (const lldb::SBThread &));
2169     LLDB_REGISTER_METHOD(const lldb::SBThread &,
2170                          SBThread, operator=,(const lldb::SBThread &));
2171     LLDB_REGISTER_METHOD_CONST(lldb::SBQueue, SBThread, GetQueue, ());
2172     LLDB_REGISTER_METHOD_CONST(bool, SBThread, IsValid, ());
2173     LLDB_REGISTER_METHOD_CONST(bool, SBThread, operator bool, ());
2174     LLDB_REGISTER_METHOD(void, SBThread, Clear, ());
2175     LLDB_REGISTER_METHOD(lldb::StopReason, SBThread, GetStopReason, ());
2176     LLDB_REGISTER_METHOD(size_t, SBThread, GetStopReasonDataCount, ());
2177     LLDB_REGISTER_METHOD(uint64_t, SBThread, GetStopReasonDataAtIndex,
2178                          (uint32_t));
2179     LLDB_REGISTER_METHOD(bool, SBThread, GetStopReasonExtendedInfoAsJSON,
2180                          (lldb::SBStream &));
2181     LLDB_REGISTER_METHOD(lldb::SBThreadCollection, SBThread,
2182                          GetStopReasonExtendedBacktraces,
2183                          (lldb::InstrumentationRuntimeType));
2184     LLDB_REGISTER_METHOD(size_t, SBThread, GetStopDescription,
2185                          (char *, size_t));
2186     LLDB_REGISTER_METHOD(lldb::SBValue, SBThread, GetStopReturnValue, ());
2187     LLDB_REGISTER_METHOD_CONST(lldb::tid_t, SBThread, GetThreadID, ());
2188     LLDB_REGISTER_METHOD_CONST(uint32_t, SBThread, GetIndexID, ());
2189     LLDB_REGISTER_METHOD_CONST(const char *, SBThread, GetName, ());
2190     LLDB_REGISTER_METHOD_CONST(const char *, SBThread, GetQueueName, ());
2191     LLDB_REGISTER_METHOD_CONST(lldb::queue_id_t, SBThread, GetQueueID, ());
2192     LLDB_REGISTER_METHOD(bool, SBThread, GetInfoItemByPathAsString,
2193                          (const char *, lldb::SBStream &));
2194     LLDB_REGISTER_METHOD(void, SBThread, StepOver, (lldb::RunMode));
2195     LLDB_REGISTER_METHOD(void, SBThread, StepOver,
2196                          (lldb::RunMode, lldb::SBError &));
2197     LLDB_REGISTER_METHOD(void, SBThread, StepInto, (lldb::RunMode));
2198     LLDB_REGISTER_METHOD(void, SBThread, StepInto,
2199                          (const char *, lldb::RunMode));
2200     LLDB_REGISTER_METHOD(
2201         void, SBThread, StepInto,
2202         (const char *, uint32_t, lldb::SBError &, lldb::RunMode));
2203     LLDB_REGISTER_METHOD(void, SBThread, StepOut, ());
2204     LLDB_REGISTER_METHOD(void, SBThread, StepOut, (lldb::SBError &));
2205     LLDB_REGISTER_METHOD(void, SBThread, StepOutOfFrame, (lldb::SBFrame &));
2206     LLDB_REGISTER_METHOD(void, SBThread, StepOutOfFrame,
2207                          (lldb::SBFrame &, lldb::SBError &));
2208     LLDB_REGISTER_METHOD(void, SBThread, StepInstruction, (bool));
2209     LLDB_REGISTER_METHOD(void, SBThread, StepInstruction,
2210                          (bool, lldb::SBError &));
2211     LLDB_REGISTER_METHOD(void, SBThread, RunToAddress, (lldb::addr_t));
2212     LLDB_REGISTER_METHOD(void, SBThread, RunToAddress,
2213                          (lldb::addr_t, lldb::SBError &));
2214     LLDB_REGISTER_METHOD(lldb::SBError, SBThread, StepOverUntil,
2215                          (lldb::SBFrame &, lldb::SBFileSpec &, uint32_t));
2216     LLDB_REGISTER_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan,
2217                          (const char *));
2218     LLDB_REGISTER_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan,
2219                          (const char *, bool));
2220     LLDB_REGISTER_METHOD(lldb::SBError, SBThread, JumpToLine,
2221                          (lldb::SBFileSpec &, uint32_t));
2222     LLDB_REGISTER_METHOD(lldb::SBError, SBThread, ReturnFromFrame,
2223                          (lldb::SBFrame &, lldb::SBValue &));
2224     LLDB_REGISTER_METHOD(lldb::SBError, SBThread, UnwindInnermostExpression,
2225                          ());
2226     LLDB_REGISTER_METHOD(bool, SBThread, Suspend, ());
2227     LLDB_REGISTER_METHOD(bool, SBThread, Suspend, (lldb::SBError &));
2228     LLDB_REGISTER_METHOD(bool, SBThread, Resume, ());
2229     LLDB_REGISTER_METHOD(bool, SBThread, Resume, (lldb::SBError &));
2230     LLDB_REGISTER_METHOD(bool, SBThread, IsSuspended, ());
2231     LLDB_REGISTER_METHOD(bool, SBThread, IsStopped, ());
2232     LLDB_REGISTER_METHOD(lldb::SBProcess, SBThread, GetProcess, ());
2233     LLDB_REGISTER_METHOD(uint32_t, SBThread, GetNumFrames, ());
2234     LLDB_REGISTER_METHOD(lldb::SBFrame, SBThread, GetFrameAtIndex, (uint32_t));
2235     LLDB_REGISTER_METHOD(lldb::SBFrame, SBThread, GetSelectedFrame, ());
2236     LLDB_REGISTER_METHOD(lldb::SBFrame, SBThread, SetSelectedFrame, (uint32_t));
2237     LLDB_REGISTER_STATIC_METHOD(bool, SBThread, EventIsThreadEvent,
2238                                 (const lldb::SBEvent &));
2239     LLDB_REGISTER_STATIC_METHOD(lldb::SBFrame, SBThread, GetStackFrameFromEvent,
2240                                 (const lldb::SBEvent &));
2241     LLDB_REGISTER_STATIC_METHOD(lldb::SBThread, SBThread, GetThreadFromEvent,
2242                                 (const lldb::SBEvent &));
2243     LLDB_REGISTER_METHOD_CONST(bool,
2244                                SBThread, operator==,(const lldb::SBThread &));
2245     LLDB_REGISTER_METHOD_CONST(bool,
2246                                SBThread, operator!=,(const lldb::SBThread &));
2247     LLDB_REGISTER_METHOD_CONST(bool, SBThread, GetStatus, (lldb::SBStream &));
2248     LLDB_REGISTER_METHOD_CONST(bool, SBThread, GetDescription,
2249                                (lldb::SBStream &));
2250     LLDB_REGISTER_METHOD_CONST(bool, SBThread, GetDescription,
2251                                (lldb::SBStream &, bool));
2252     LLDB_REGISTER_METHOD(lldb::SBThread, SBThread, GetExtendedBacktraceThread,
2253                          (const char *));
2254     LLDB_REGISTER_METHOD(uint32_t, SBThread,
2255                          GetExtendedBacktraceOriginatingIndexID, ());
2256     LLDB_REGISTER_METHOD(lldb::SBValue, SBThread, GetCurrentException, ());
2257     LLDB_REGISTER_METHOD(lldb::SBThread, SBThread, GetCurrentExceptionBacktrace,
2258                          ());
2259     LLDB_REGISTER_METHOD(bool, SBThread, SafeToCallFunctions, ());
2260     LLDB_REGISTER_METHOD(lldb_private::Thread *, SBThread, operator->,());
2261     LLDB_REGISTER_METHOD(lldb_private::Thread *, SBThread, get, ());
2262   }
2263   {
2264     LLDB_REGISTER_CONSTRUCTOR(SBThreadCollection, ());
2265     LLDB_REGISTER_CONSTRUCTOR(SBThreadCollection,
2266                               (const lldb::SBThreadCollection &));
2267     LLDB_REGISTER_METHOD(
2268         const lldb::SBThreadCollection &,
2269         SBThreadCollection, operator=,(const lldb::SBThreadCollection &));
2270     LLDB_REGISTER_METHOD_CONST(bool, SBThreadCollection, IsValid, ());
2271     LLDB_REGISTER_METHOD_CONST(bool, SBThreadCollection, operator bool, ());
2272     LLDB_REGISTER_METHOD(size_t, SBThreadCollection, GetSize, ());
2273     LLDB_REGISTER_METHOD(lldb::SBThread, SBThreadCollection, GetThreadAtIndex,
2274                          (size_t));
2275   }
2276   {
2277     LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, ());
2278     LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, (const lldb::ThreadPlanSP &));
2279     LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, (const lldb::SBThreadPlan &));
2280     LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, (lldb::SBThread &, const char *));
2281     LLDB_REGISTER_METHOD(const lldb::SBThreadPlan &,
2282                          SBThreadPlan, operator=,(const lldb::SBThreadPlan &));
2283     LLDB_REGISTER_METHOD(lldb_private::ThreadPlan *, SBThreadPlan, get, ());
2284     LLDB_REGISTER_METHOD_CONST(bool, SBThreadPlan, IsValid, ());
2285     LLDB_REGISTER_METHOD_CONST(bool, SBThreadPlan, operator bool, ());
2286     LLDB_REGISTER_METHOD(void, SBThreadPlan, Clear, ());
2287     LLDB_REGISTER_METHOD(lldb::StopReason, SBThreadPlan, GetStopReason, ());
2288     LLDB_REGISTER_METHOD(size_t, SBThreadPlan, GetStopReasonDataCount, ());
2289     LLDB_REGISTER_METHOD(uint64_t, SBThreadPlan, GetStopReasonDataAtIndex,
2290                          (uint32_t));
2291     LLDB_REGISTER_METHOD_CONST(lldb::SBThread, SBThreadPlan, GetThread, ());
2292     LLDB_REGISTER_METHOD_CONST(bool, SBThreadPlan, GetDescription,
2293                                (lldb::SBStream &));
2294     LLDB_REGISTER_METHOD(void, SBThreadPlan, SetPlanComplete, (bool));
2295     LLDB_REGISTER_METHOD(bool, SBThreadPlan, IsPlanComplete, ());
2296     LLDB_REGISTER_METHOD(bool, SBThreadPlan, IsPlanStale, ());
2297     LLDB_REGISTER_METHOD(bool, SBThreadPlan, IsValid, ());
2298     LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
2299                          QueueThreadPlanForStepOverRange,
2300                          (lldb::SBAddress &, lldb::addr_t));
2301     LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
2302                          QueueThreadPlanForStepOverRange,
2303                          (lldb::SBAddress &, lldb::addr_t, lldb::SBError &));
2304     LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
2305                          QueueThreadPlanForStepInRange,
2306                          (lldb::SBAddress &, lldb::addr_t));
2307     LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
2308                          QueueThreadPlanForStepInRange,
2309                          (lldb::SBAddress &, lldb::addr_t, lldb::SBError &));
2310     LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
2311                          QueueThreadPlanForStepOut, (uint32_t, bool));
2312     LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
2313                          QueueThreadPlanForStepOut,
2314                          (uint32_t, bool, lldb::SBError &));
2315     LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
2316                          QueueThreadPlanForRunToAddress, (lldb::SBAddress));
2317     LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
2318                          QueueThreadPlanForRunToAddress,
2319                          (lldb::SBAddress, lldb::SBError &));
2320     LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
2321                          QueueThreadPlanForStepScripted, (const char *));
2322     LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
2323                          QueueThreadPlanForStepScripted,
2324                          (const char *, lldb::SBError &));
2325   }
2326   {
2327     LLDB_REGISTER_METHOD(void, SBTrace, StopTrace,
2328                          (lldb::SBError &, lldb::tid_t));
2329     LLDB_REGISTER_METHOD(void, SBTrace, GetTraceConfig,
2330                          (lldb::SBTraceOptions &, lldb::SBError &));
2331     LLDB_REGISTER_METHOD(lldb::user_id_t, SBTrace, GetTraceUID, ());
2332     LLDB_REGISTER_CONSTRUCTOR(SBTrace, ());
2333     LLDB_REGISTER_METHOD(bool, SBTrace, IsValid, ());
2334     LLDB_REGISTER_METHOD_CONST(bool, SBTrace, operator bool, ());
2335   }
2336   {
2337     LLDB_REGISTER_CONSTRUCTOR(SBTraceOptions, ());
2338     LLDB_REGISTER_METHOD_CONST(lldb::TraceType, SBTraceOptions, getType, ());
2339     LLDB_REGISTER_METHOD_CONST(uint64_t, SBTraceOptions, getTraceBufferSize,
2340                                ());
2341     LLDB_REGISTER_METHOD(lldb::SBStructuredData, SBTraceOptions, getTraceParams,
2342                          (lldb::SBError &));
2343     LLDB_REGISTER_METHOD_CONST(uint64_t, SBTraceOptions, getMetaDataBufferSize,
2344                                ());
2345     LLDB_REGISTER_METHOD(void, SBTraceOptions, setTraceParams,
2346                          (lldb::SBStructuredData &));
2347     LLDB_REGISTER_METHOD(void, SBTraceOptions, setType, (lldb::TraceType));
2348     LLDB_REGISTER_METHOD(void, SBTraceOptions, setTraceBufferSize, (uint64_t));
2349     LLDB_REGISTER_METHOD(void, SBTraceOptions, setMetaDataBufferSize,
2350                          (uint64_t));
2351     LLDB_REGISTER_METHOD(bool, SBTraceOptions, IsValid, ());
2352     LLDB_REGISTER_METHOD_CONST(bool, SBTraceOptions, operator bool, ());
2353     LLDB_REGISTER_METHOD(void, SBTraceOptions, setThreadID, (lldb::tid_t));
2354     LLDB_REGISTER_METHOD(lldb::tid_t, SBTraceOptions, getThreadID, ());
2355   }
2356   {
2357     LLDB_REGISTER_CONSTRUCTOR(SBType, ());
2358     LLDB_REGISTER_CONSTRUCTOR(SBType, (const lldb::SBType &));
2359     LLDB_REGISTER_METHOD(bool, SBType, operator==,(lldb::SBType &));
2360     LLDB_REGISTER_METHOD(bool, SBType, operator!=,(lldb::SBType &));
2361     LLDB_REGISTER_METHOD(lldb::SBType &,
2362                          SBType, operator=,(const lldb::SBType &));
2363     LLDB_REGISTER_METHOD_CONST(bool, SBType, IsValid, ());
2364     LLDB_REGISTER_METHOD_CONST(bool, SBType, operator bool, ());
2365     LLDB_REGISTER_METHOD(uint64_t, SBType, GetByteSize, ());
2366     LLDB_REGISTER_METHOD(bool, SBType, IsPointerType, ());
2367     LLDB_REGISTER_METHOD(bool, SBType, IsArrayType, ());
2368     LLDB_REGISTER_METHOD(bool, SBType, IsVectorType, ());
2369     LLDB_REGISTER_METHOD(bool, SBType, IsReferenceType, ());
2370     LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetPointerType, ());
2371     LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetPointeeType, ());
2372     LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetReferenceType, ());
2373     LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetTypedefedType, ());
2374     LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetDereferencedType, ());
2375     LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetArrayElementType, ());
2376     LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetArrayType, (uint64_t));
2377     LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetVectorElementType, ());
2378     LLDB_REGISTER_METHOD(bool, SBType, IsFunctionType, ());
2379     LLDB_REGISTER_METHOD(bool, SBType, IsPolymorphicClass, ());
2380     LLDB_REGISTER_METHOD(bool, SBType, IsTypedefType, ());
2381     LLDB_REGISTER_METHOD(bool, SBType, IsAnonymousType, ());
2382     LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetFunctionReturnType, ());
2383     LLDB_REGISTER_METHOD(lldb::SBTypeList, SBType, GetFunctionArgumentTypes,
2384                          ());
2385     LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfMemberFunctions, ());
2386     LLDB_REGISTER_METHOD(lldb::SBTypeMemberFunction, SBType,
2387                          GetMemberFunctionAtIndex, (uint32_t));
2388     LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetUnqualifiedType, ());
2389     LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetCanonicalType, ());
2390     LLDB_REGISTER_METHOD(lldb::BasicType, SBType, GetBasicType, ());
2391     LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetBasicType, (lldb::BasicType));
2392     LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfDirectBaseClasses, ());
2393     LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfVirtualBaseClasses, ());
2394     LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfFields, ());
2395     LLDB_REGISTER_METHOD(bool, SBType, GetDescription,
2396                          (lldb::SBStream &, lldb::DescriptionLevel));
2397     LLDB_REGISTER_METHOD(lldb::SBTypeMember, SBType, GetDirectBaseClassAtIndex,
2398                          (uint32_t));
2399     LLDB_REGISTER_METHOD(lldb::SBTypeMember, SBType, GetVirtualBaseClassAtIndex,
2400                          (uint32_t));
2401     LLDB_REGISTER_METHOD(lldb::SBTypeEnumMemberList, SBType, GetEnumMembers,
2402                          ());
2403     LLDB_REGISTER_METHOD(lldb::SBTypeMember, SBType, GetFieldAtIndex,
2404                          (uint32_t));
2405     LLDB_REGISTER_METHOD(bool, SBType, IsTypeComplete, ());
2406     LLDB_REGISTER_METHOD(uint32_t, SBType, GetTypeFlags, ());
2407     LLDB_REGISTER_METHOD(const char *, SBType, GetName, ());
2408     LLDB_REGISTER_METHOD(const char *, SBType, GetDisplayTypeName, ());
2409     LLDB_REGISTER_METHOD(lldb::TypeClass, SBType, GetTypeClass, ());
2410     LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfTemplateArguments, ());
2411     LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetTemplateArgumentType,
2412                          (uint32_t));
2413     LLDB_REGISTER_METHOD(lldb::TemplateArgumentKind, SBType,
2414                          GetTemplateArgumentKind, (uint32_t));
2415     LLDB_REGISTER_CONSTRUCTOR(SBTypeList, ());
2416     LLDB_REGISTER_CONSTRUCTOR(SBTypeList, (const lldb::SBTypeList &));
2417     LLDB_REGISTER_METHOD(bool, SBTypeList, IsValid, ());
2418     LLDB_REGISTER_METHOD_CONST(bool, SBTypeList, operator bool, ());
2419     LLDB_REGISTER_METHOD(lldb::SBTypeList &,
2420                          SBTypeList, operator=,(const lldb::SBTypeList &));
2421     LLDB_REGISTER_METHOD(void, SBTypeList, Append, (lldb::SBType));
2422     LLDB_REGISTER_METHOD(lldb::SBType, SBTypeList, GetTypeAtIndex, (uint32_t));
2423     LLDB_REGISTER_METHOD(uint32_t, SBTypeList, GetSize, ());
2424     LLDB_REGISTER_CONSTRUCTOR(SBTypeMember, ());
2425     LLDB_REGISTER_CONSTRUCTOR(SBTypeMember, (const lldb::SBTypeMember &));
2426     LLDB_REGISTER_METHOD(lldb::SBTypeMember &,
2427                          SBTypeMember, operator=,(const lldb::SBTypeMember &));
2428     LLDB_REGISTER_METHOD_CONST(bool, SBTypeMember, IsValid, ());
2429     LLDB_REGISTER_METHOD_CONST(bool, SBTypeMember, operator bool, ());
2430     LLDB_REGISTER_METHOD(const char *, SBTypeMember, GetName, ());
2431     LLDB_REGISTER_METHOD(lldb::SBType, SBTypeMember, GetType, ());
2432     LLDB_REGISTER_METHOD(uint64_t, SBTypeMember, GetOffsetInBytes, ());
2433     LLDB_REGISTER_METHOD(uint64_t, SBTypeMember, GetOffsetInBits, ());
2434     LLDB_REGISTER_METHOD(bool, SBTypeMember, IsBitfield, ());
2435     LLDB_REGISTER_METHOD(uint32_t, SBTypeMember, GetBitfieldSizeInBits, ());
2436     LLDB_REGISTER_METHOD(bool, SBTypeMember, GetDescription,
2437                          (lldb::SBStream &, lldb::DescriptionLevel));
2438     LLDB_REGISTER_CONSTRUCTOR(SBTypeMemberFunction, ());
2439     LLDB_REGISTER_CONSTRUCTOR(SBTypeMemberFunction,
2440                               (const lldb::SBTypeMemberFunction &));
2441     LLDB_REGISTER_METHOD(
2442         lldb::SBTypeMemberFunction &,
2443         SBTypeMemberFunction, operator=,(const lldb::SBTypeMemberFunction &));
2444     LLDB_REGISTER_METHOD_CONST(bool, SBTypeMemberFunction, IsValid, ());
2445     LLDB_REGISTER_METHOD_CONST(bool, SBTypeMemberFunction, operator bool, ());
2446     LLDB_REGISTER_METHOD(const char *, SBTypeMemberFunction, GetName, ());
2447     LLDB_REGISTER_METHOD(const char *, SBTypeMemberFunction, GetDemangledName,
2448                          ());
2449     LLDB_REGISTER_METHOD(const char *, SBTypeMemberFunction, GetMangledName,
2450                          ());
2451     LLDB_REGISTER_METHOD(lldb::SBType, SBTypeMemberFunction, GetType, ());
2452     LLDB_REGISTER_METHOD(lldb::SBType, SBTypeMemberFunction, GetReturnType, ());
2453     LLDB_REGISTER_METHOD(uint32_t, SBTypeMemberFunction, GetNumberOfArguments,
2454                          ());
2455     LLDB_REGISTER_METHOD(lldb::SBType, SBTypeMemberFunction,
2456                          GetArgumentTypeAtIndex, (uint32_t));
2457     LLDB_REGISTER_METHOD(lldb::MemberFunctionKind, SBTypeMemberFunction,
2458                          GetKind, ());
2459     LLDB_REGISTER_METHOD(bool, SBTypeMemberFunction, GetDescription,
2460                          (lldb::SBStream &, lldb::DescriptionLevel));
2461   }
2462   {
2463     LLDB_REGISTER_CONSTRUCTOR(SBTypeCategory, ());
2464     LLDB_REGISTER_CONSTRUCTOR(SBTypeCategory, (const lldb::SBTypeCategory &));
2465     LLDB_REGISTER_METHOD_CONST(bool, SBTypeCategory, IsValid, ());
2466     LLDB_REGISTER_METHOD_CONST(bool, SBTypeCategory, operator bool, ());
2467     LLDB_REGISTER_METHOD(bool, SBTypeCategory, GetEnabled, ());
2468     LLDB_REGISTER_METHOD(void, SBTypeCategory, SetEnabled, (bool));
2469     LLDB_REGISTER_METHOD(const char *, SBTypeCategory, GetName, ());
2470     LLDB_REGISTER_METHOD(lldb::LanguageType, SBTypeCategory, GetLanguageAtIndex,
2471                          (uint32_t));
2472     LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumLanguages, ());
2473     LLDB_REGISTER_METHOD(void, SBTypeCategory, AddLanguage,
2474                          (lldb::LanguageType));
2475     LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumFormats, ());
2476     LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumSummaries, ());
2477     LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumFilters, ());
2478 #ifndef LLDB_DISABLE_PYTHON
2479     LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumSynthetics, ());
2480     LLDB_REGISTER_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
2481                          GetTypeNameSpecifierForSyntheticAtIndex, (uint32_t));
2482     LLDB_REGISTER_METHOD(lldb::SBTypeSummary, SBTypeCategory, GetSummaryForType,
2483                          (lldb::SBTypeNameSpecifier));
2484     LLDB_REGISTER_METHOD(lldb::SBTypeSynthetic, SBTypeCategory,
2485                          GetSyntheticForType, (lldb::SBTypeNameSpecifier));
2486     LLDB_REGISTER_METHOD(lldb::SBTypeFilter, SBTypeCategory, GetFilterAtIndex,
2487                          (uint32_t));
2488     LLDB_REGISTER_METHOD(lldb::SBTypeSummary, SBTypeCategory, GetSummaryAtIndex,
2489                          (uint32_t));
2490     LLDB_REGISTER_METHOD(lldb::SBTypeSynthetic, SBTypeCategory,
2491                          GetSyntheticAtIndex, (uint32_t));
2492     LLDB_REGISTER_METHOD(bool, SBTypeCategory, AddTypeSummary,
2493                          (lldb::SBTypeNameSpecifier, lldb::SBTypeSummary));
2494     LLDB_REGISTER_METHOD(bool, SBTypeCategory, AddTypeSynthetic,
2495                          (lldb::SBTypeNameSpecifier, lldb::SBTypeSynthetic));
2496     LLDB_REGISTER_METHOD(bool, SBTypeCategory, DeleteTypeSynthetic,
2497                          (lldb::SBTypeNameSpecifier));
2498 #endif
2499     LLDB_REGISTER_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
2500                          GetTypeNameSpecifierForFilterAtIndex, (uint32_t));
2501     LLDB_REGISTER_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
2502                          GetTypeNameSpecifierForFormatAtIndex, (uint32_t));
2503     LLDB_REGISTER_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
2504                          GetTypeNameSpecifierForSummaryAtIndex, (uint32_t));
2505     LLDB_REGISTER_METHOD(lldb::SBTypeFilter, SBTypeCategory, GetFilterForType,
2506                          (lldb::SBTypeNameSpecifier));
2507     LLDB_REGISTER_METHOD(lldb::SBTypeFormat, SBTypeCategory, GetFormatForType,
2508                          (lldb::SBTypeNameSpecifier));
2509     LLDB_REGISTER_METHOD(lldb::SBTypeFormat, SBTypeCategory, GetFormatAtIndex,
2510                          (uint32_t));
2511     LLDB_REGISTER_METHOD(bool, SBTypeCategory, AddTypeFormat,
2512                          (lldb::SBTypeNameSpecifier, lldb::SBTypeFormat));
2513     LLDB_REGISTER_METHOD(bool, SBTypeCategory, DeleteTypeFormat,
2514                          (lldb::SBTypeNameSpecifier));
2515     LLDB_REGISTER_METHOD(bool, SBTypeCategory, DeleteTypeSummary,
2516                          (lldb::SBTypeNameSpecifier));
2517     LLDB_REGISTER_METHOD(bool, SBTypeCategory, AddTypeFilter,
2518                          (lldb::SBTypeNameSpecifier, lldb::SBTypeFilter));
2519     LLDB_REGISTER_METHOD(bool, SBTypeCategory, DeleteTypeFilter,
2520                          (lldb::SBTypeNameSpecifier));
2521     LLDB_REGISTER_METHOD(bool, SBTypeCategory, GetDescription,
2522                          (lldb::SBStream &, lldb::DescriptionLevel));
2523     LLDB_REGISTER_METHOD(
2524         lldb::SBTypeCategory &,
2525         SBTypeCategory, operator=,(const lldb::SBTypeCategory &));
2526     LLDB_REGISTER_METHOD(bool,
2527                          SBTypeCategory, operator==,(lldb::SBTypeCategory &));
2528     LLDB_REGISTER_METHOD(bool,
2529                          SBTypeCategory, operator!=,(lldb::SBTypeCategory &));
2530   }
2531   {
2532     LLDB_REGISTER_CONSTRUCTOR(SBTypeEnumMember, ());
2533     LLDB_REGISTER_CONSTRUCTOR(SBTypeEnumMember,
2534                               (const lldb::SBTypeEnumMember &));
2535     LLDB_REGISTER_METHOD(
2536         lldb::SBTypeEnumMember &,
2537         SBTypeEnumMember, operator=,(const lldb::SBTypeEnumMember &));
2538     LLDB_REGISTER_METHOD_CONST(bool, SBTypeEnumMember, IsValid, ());
2539     LLDB_REGISTER_METHOD_CONST(bool, SBTypeEnumMember, operator bool, ());
2540     LLDB_REGISTER_METHOD(const char *, SBTypeEnumMember, GetName, ());
2541     LLDB_REGISTER_METHOD(int64_t, SBTypeEnumMember, GetValueAsSigned, ());
2542     LLDB_REGISTER_METHOD(uint64_t, SBTypeEnumMember, GetValueAsUnsigned, ());
2543     LLDB_REGISTER_METHOD(lldb::SBType, SBTypeEnumMember, GetType, ());
2544     LLDB_REGISTER_CONSTRUCTOR(SBTypeEnumMemberList, ());
2545     LLDB_REGISTER_CONSTRUCTOR(SBTypeEnumMemberList,
2546                               (const lldb::SBTypeEnumMemberList &));
2547     LLDB_REGISTER_METHOD(bool, SBTypeEnumMemberList, IsValid, ());
2548     LLDB_REGISTER_METHOD_CONST(bool, SBTypeEnumMemberList, operator bool, ());
2549     LLDB_REGISTER_METHOD(
2550         lldb::SBTypeEnumMemberList &,
2551         SBTypeEnumMemberList, operator=,(const lldb::SBTypeEnumMemberList &));
2552     LLDB_REGISTER_METHOD(void, SBTypeEnumMemberList, Append,
2553                          (lldb::SBTypeEnumMember));
2554     LLDB_REGISTER_METHOD(lldb::SBTypeEnumMember, SBTypeEnumMemberList,
2555                          GetTypeEnumMemberAtIndex, (uint32_t));
2556     LLDB_REGISTER_METHOD(uint32_t, SBTypeEnumMemberList, GetSize, ());
2557     LLDB_REGISTER_METHOD(bool, SBTypeEnumMember, GetDescription,
2558                          (lldb::SBStream &, lldb::DescriptionLevel));
2559   }
2560   {
2561     LLDB_REGISTER_CONSTRUCTOR(SBTypeFilter, ());
2562     LLDB_REGISTER_CONSTRUCTOR(SBTypeFilter, (uint32_t));
2563     LLDB_REGISTER_CONSTRUCTOR(SBTypeFilter, (const lldb::SBTypeFilter &));
2564     LLDB_REGISTER_METHOD_CONST(bool, SBTypeFilter, IsValid, ());
2565     LLDB_REGISTER_METHOD_CONST(bool, SBTypeFilter, operator bool, ());
2566     LLDB_REGISTER_METHOD(uint32_t, SBTypeFilter, GetOptions, ());
2567     LLDB_REGISTER_METHOD(void, SBTypeFilter, SetOptions, (uint32_t));
2568     LLDB_REGISTER_METHOD(bool, SBTypeFilter, GetDescription,
2569                          (lldb::SBStream &, lldb::DescriptionLevel));
2570     LLDB_REGISTER_METHOD(void, SBTypeFilter, Clear, ());
2571     LLDB_REGISTER_METHOD(uint32_t, SBTypeFilter, GetNumberOfExpressionPaths,
2572                          ());
2573     LLDB_REGISTER_METHOD(const char *, SBTypeFilter, GetExpressionPathAtIndex,
2574                          (uint32_t));
2575     LLDB_REGISTER_METHOD(bool, SBTypeFilter, ReplaceExpressionPathAtIndex,
2576                          (uint32_t, const char *));
2577     LLDB_REGISTER_METHOD(void, SBTypeFilter, AppendExpressionPath,
2578                          (const char *));
2579     LLDB_REGISTER_METHOD(lldb::SBTypeFilter &,
2580                          SBTypeFilter, operator=,(const lldb::SBTypeFilter &));
2581     LLDB_REGISTER_METHOD(bool, SBTypeFilter, operator==,(lldb::SBTypeFilter &));
2582     LLDB_REGISTER_METHOD(bool, SBTypeFilter, IsEqualTo, (lldb::SBTypeFilter &));
2583     LLDB_REGISTER_METHOD(bool, SBTypeFilter, operator!=,(lldb::SBTypeFilter &));
2584   }
2585   {
2586     LLDB_REGISTER_CONSTRUCTOR(SBTypeFormat, ());
2587     LLDB_REGISTER_CONSTRUCTOR(SBTypeFormat, (lldb::Format, uint32_t));
2588     LLDB_REGISTER_CONSTRUCTOR(SBTypeFormat, (const char *, uint32_t));
2589     LLDB_REGISTER_CONSTRUCTOR(SBTypeFormat, (const lldb::SBTypeFormat &));
2590     LLDB_REGISTER_METHOD_CONST(bool, SBTypeFormat, IsValid, ());
2591     LLDB_REGISTER_METHOD_CONST(bool, SBTypeFormat, operator bool, ());
2592     LLDB_REGISTER_METHOD(lldb::Format, SBTypeFormat, GetFormat, ());
2593     LLDB_REGISTER_METHOD(const char *, SBTypeFormat, GetTypeName, ());
2594     LLDB_REGISTER_METHOD(uint32_t, SBTypeFormat, GetOptions, ());
2595     LLDB_REGISTER_METHOD(void, SBTypeFormat, SetFormat, (lldb::Format));
2596     LLDB_REGISTER_METHOD(void, SBTypeFormat, SetTypeName, (const char *));
2597     LLDB_REGISTER_METHOD(void, SBTypeFormat, SetOptions, (uint32_t));
2598     LLDB_REGISTER_METHOD(bool, SBTypeFormat, GetDescription,
2599                          (lldb::SBStream &, lldb::DescriptionLevel));
2600     LLDB_REGISTER_METHOD(lldb::SBTypeFormat &,
2601                          SBTypeFormat, operator=,(const lldb::SBTypeFormat &));
2602     LLDB_REGISTER_METHOD(bool, SBTypeFormat, operator==,(lldb::SBTypeFormat &));
2603     LLDB_REGISTER_METHOD(bool, SBTypeFormat, IsEqualTo, (lldb::SBTypeFormat &));
2604     LLDB_REGISTER_METHOD(bool, SBTypeFormat, operator!=,(lldb::SBTypeFormat &));
2605   }
2606   {
2607     LLDB_REGISTER_CONSTRUCTOR(SBTypeNameSpecifier, ());
2608     LLDB_REGISTER_CONSTRUCTOR(SBTypeNameSpecifier, (const char *, bool));
2609     LLDB_REGISTER_CONSTRUCTOR(SBTypeNameSpecifier, (lldb::SBType));
2610     LLDB_REGISTER_CONSTRUCTOR(SBTypeNameSpecifier,
2611                               (const lldb::SBTypeNameSpecifier &));
2612     LLDB_REGISTER_METHOD_CONST(bool, SBTypeNameSpecifier, IsValid, ());
2613     LLDB_REGISTER_METHOD_CONST(bool, SBTypeNameSpecifier, operator bool, ());
2614     LLDB_REGISTER_METHOD(const char *, SBTypeNameSpecifier, GetName, ());
2615     LLDB_REGISTER_METHOD(lldb::SBType, SBTypeNameSpecifier, GetType, ());
2616     LLDB_REGISTER_METHOD(bool, SBTypeNameSpecifier, IsRegex, ());
2617     LLDB_REGISTER_METHOD(bool, SBTypeNameSpecifier, GetDescription,
2618                          (lldb::SBStream &, lldb::DescriptionLevel));
2619     LLDB_REGISTER_METHOD(
2620         lldb::SBTypeNameSpecifier &,
2621         SBTypeNameSpecifier, operator=,(const lldb::SBTypeNameSpecifier &));
2622     LLDB_REGISTER_METHOD(
2623         bool, SBTypeNameSpecifier, operator==,(lldb::SBTypeNameSpecifier &));
2624     LLDB_REGISTER_METHOD(bool, SBTypeNameSpecifier, IsEqualTo,
2625                          (lldb::SBTypeNameSpecifier &));
2626     LLDB_REGISTER_METHOD(
2627         bool, SBTypeNameSpecifier, operator!=,(lldb::SBTypeNameSpecifier &));
2628   }
2629   {
2630     LLDB_REGISTER_CONSTRUCTOR(SBTypeSummaryOptions, ());
2631     LLDB_REGISTER_CONSTRUCTOR(SBTypeSummaryOptions,
2632                               (const lldb::SBTypeSummaryOptions &));
2633     LLDB_REGISTER_METHOD(bool, SBTypeSummaryOptions, IsValid, ());
2634     LLDB_REGISTER_METHOD_CONST(bool, SBTypeSummaryOptions, operator bool, ());
2635     LLDB_REGISTER_METHOD(lldb::LanguageType, SBTypeSummaryOptions, GetLanguage,
2636                          ());
2637     LLDB_REGISTER_METHOD(lldb::TypeSummaryCapping, SBTypeSummaryOptions,
2638                          GetCapping, ());
2639     LLDB_REGISTER_METHOD(void, SBTypeSummaryOptions, SetLanguage,
2640                          (lldb::LanguageType));
2641     LLDB_REGISTER_METHOD(void, SBTypeSummaryOptions, SetCapping,
2642                          (lldb::TypeSummaryCapping));
2643     LLDB_REGISTER_CONSTRUCTOR(SBTypeSummaryOptions,
2644                               (const lldb_private::TypeSummaryOptions *));
2645     LLDB_REGISTER_CONSTRUCTOR(SBTypeSummary, ());
2646     LLDB_REGISTER_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary,
2647                                 CreateWithSummaryString,
2648                                 (const char *, uint32_t));
2649     LLDB_REGISTER_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary,
2650                                 CreateWithFunctionName,
2651                                 (const char *, uint32_t));
2652     LLDB_REGISTER_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary,
2653                                 CreateWithScriptCode, (const char *, uint32_t));
2654     LLDB_REGISTER_CONSTRUCTOR(SBTypeSummary, (const lldb::SBTypeSummary &));
2655     LLDB_REGISTER_METHOD_CONST(bool, SBTypeSummary, IsValid, ());
2656     LLDB_REGISTER_METHOD_CONST(bool, SBTypeSummary, operator bool, ());
2657     LLDB_REGISTER_METHOD(bool, SBTypeSummary, IsFunctionCode, ());
2658     LLDB_REGISTER_METHOD(bool, SBTypeSummary, IsFunctionName, ());
2659     LLDB_REGISTER_METHOD(bool, SBTypeSummary, IsSummaryString, ());
2660     LLDB_REGISTER_METHOD(const char *, SBTypeSummary, GetData, ());
2661     LLDB_REGISTER_METHOD(uint32_t, SBTypeSummary, GetOptions, ());
2662     LLDB_REGISTER_METHOD(void, SBTypeSummary, SetOptions, (uint32_t));
2663     LLDB_REGISTER_METHOD(void, SBTypeSummary, SetSummaryString, (const char *));
2664     LLDB_REGISTER_METHOD(void, SBTypeSummary, SetFunctionName, (const char *));
2665     LLDB_REGISTER_METHOD(void, SBTypeSummary, SetFunctionCode, (const char *));
2666     LLDB_REGISTER_METHOD(bool, SBTypeSummary, GetDescription,
2667                          (lldb::SBStream &, lldb::DescriptionLevel));
2668     LLDB_REGISTER_METHOD(bool, SBTypeSummary, DoesPrintValue, (lldb::SBValue));
2669     LLDB_REGISTER_METHOD(
2670         lldb::SBTypeSummary &,
2671         SBTypeSummary, operator=,(const lldb::SBTypeSummary &));
2672     LLDB_REGISTER_METHOD(bool,
2673                          SBTypeSummary, operator==,(lldb::SBTypeSummary &));
2674     LLDB_REGISTER_METHOD(bool, SBTypeSummary, IsEqualTo,
2675                          (lldb::SBTypeSummary &));
2676     LLDB_REGISTER_METHOD(bool,
2677                          SBTypeSummary, operator!=,(lldb::SBTypeSummary &));
2678   }
2679 #ifndef LLDB_DISABLE_PYTHON
2680   {
2681     LLDB_REGISTER_CONSTRUCTOR(SBTypeSynthetic, ());
2682     LLDB_REGISTER_STATIC_METHOD(lldb::SBTypeSynthetic, SBTypeSynthetic,
2683                                 CreateWithClassName, (const char *, uint32_t));
2684     LLDB_REGISTER_STATIC_METHOD(lldb::SBTypeSynthetic, SBTypeSynthetic,
2685                                 CreateWithScriptCode, (const char *, uint32_t));
2686     LLDB_REGISTER_CONSTRUCTOR(SBTypeSynthetic, (const lldb::SBTypeSynthetic &));
2687     LLDB_REGISTER_METHOD_CONST(bool, SBTypeSynthetic, IsValid, ());
2688     LLDB_REGISTER_METHOD_CONST(bool, SBTypeSynthetic, operator bool, ());
2689     LLDB_REGISTER_METHOD(bool, SBTypeSynthetic, IsClassCode, ());
2690     LLDB_REGISTER_METHOD(bool, SBTypeSynthetic, IsClassName, ());
2691     LLDB_REGISTER_METHOD(const char *, SBTypeSynthetic, GetData, ());
2692     LLDB_REGISTER_METHOD(void, SBTypeSynthetic, SetClassName, (const char *));
2693     LLDB_REGISTER_METHOD(void, SBTypeSynthetic, SetClassCode, (const char *));
2694     LLDB_REGISTER_METHOD(uint32_t, SBTypeSynthetic, GetOptions, ());
2695     LLDB_REGISTER_METHOD(void, SBTypeSynthetic, SetOptions, (uint32_t));
2696     LLDB_REGISTER_METHOD(bool, SBTypeSynthetic, GetDescription,
2697                          (lldb::SBStream &, lldb::DescriptionLevel));
2698     LLDB_REGISTER_METHOD(
2699         lldb::SBTypeSynthetic &,
2700         SBTypeSynthetic, operator=,(const lldb::SBTypeSynthetic &));
2701     LLDB_REGISTER_METHOD(bool,
2702                          SBTypeSynthetic, operator==,(lldb::SBTypeSynthetic &));
2703     LLDB_REGISTER_METHOD(bool, SBTypeSynthetic, IsEqualTo,
2704                          (lldb::SBTypeSynthetic &));
2705     LLDB_REGISTER_METHOD(bool,
2706                          SBTypeSynthetic, operator!=,(lldb::SBTypeSynthetic &));
2707   }
2708 #endif
2709   {
2710     LLDB_REGISTER_CONSTRUCTOR(SBUnixSignals, ());
2711     LLDB_REGISTER_CONSTRUCTOR(SBUnixSignals, (const lldb::SBUnixSignals &));
2712     LLDB_REGISTER_METHOD(
2713         const lldb::SBUnixSignals &,
2714         SBUnixSignals, operator=,(const lldb::SBUnixSignals &));
2715     LLDB_REGISTER_METHOD(void, SBUnixSignals, Clear, ());
2716     LLDB_REGISTER_METHOD_CONST(bool, SBUnixSignals, IsValid, ());
2717     LLDB_REGISTER_METHOD_CONST(bool, SBUnixSignals, operator bool, ());
2718     LLDB_REGISTER_METHOD_CONST(const char *, SBUnixSignals, GetSignalAsCString,
2719                                (int32_t));
2720     LLDB_REGISTER_METHOD_CONST(int32_t, SBUnixSignals, GetSignalNumberFromName,
2721                                (const char *));
2722     LLDB_REGISTER_METHOD_CONST(bool, SBUnixSignals, GetShouldSuppress,
2723                                (int32_t));
2724     LLDB_REGISTER_METHOD(bool, SBUnixSignals, SetShouldSuppress,
2725                          (int32_t, bool));
2726     LLDB_REGISTER_METHOD_CONST(bool, SBUnixSignals, GetShouldStop, (int32_t));
2727     LLDB_REGISTER_METHOD(bool, SBUnixSignals, SetShouldStop, (int32_t, bool));
2728     LLDB_REGISTER_METHOD_CONST(bool, SBUnixSignals, GetShouldNotify, (int32_t));
2729     LLDB_REGISTER_METHOD(bool, SBUnixSignals, SetShouldNotify, (int32_t, bool));
2730     LLDB_REGISTER_METHOD_CONST(int32_t, SBUnixSignals, GetNumSignals, ());
2731     LLDB_REGISTER_METHOD_CONST(int32_t, SBUnixSignals, GetSignalAtIndex,
2732                                (int32_t));
2733   }
2734   {
2735     LLDB_REGISTER_CONSTRUCTOR(SBValue, ());
2736     LLDB_REGISTER_CONSTRUCTOR(SBValue, (const lldb::ValueObjectSP &));
2737     LLDB_REGISTER_CONSTRUCTOR(SBValue, (const lldb::SBValue &));
2738     LLDB_REGISTER_METHOD(lldb::SBValue &,
2739                          SBValue, operator=,(const lldb::SBValue &));
2740     LLDB_REGISTER_METHOD(bool, SBValue, IsValid, ());
2741     LLDB_REGISTER_METHOD_CONST(bool, SBValue, operator bool, ());
2742     LLDB_REGISTER_METHOD(void, SBValue, Clear, ());
2743     LLDB_REGISTER_METHOD(lldb::SBError, SBValue, GetError, ());
2744     LLDB_REGISTER_METHOD(lldb::user_id_t, SBValue, GetID, ());
2745     LLDB_REGISTER_METHOD(const char *, SBValue, GetName, ());
2746     LLDB_REGISTER_METHOD(const char *, SBValue, GetTypeName, ());
2747     LLDB_REGISTER_METHOD(const char *, SBValue, GetDisplayTypeName, ());
2748     LLDB_REGISTER_METHOD(size_t, SBValue, GetByteSize, ());
2749     LLDB_REGISTER_METHOD(bool, SBValue, IsInScope, ());
2750     LLDB_REGISTER_METHOD(const char *, SBValue, GetValue, ());
2751     LLDB_REGISTER_METHOD(lldb::ValueType, SBValue, GetValueType, ());
2752     LLDB_REGISTER_METHOD(const char *, SBValue, GetObjectDescription, ());
2753     LLDB_REGISTER_METHOD(const char *, SBValue, GetTypeValidatorResult, ());
2754     LLDB_REGISTER_METHOD(lldb::SBType, SBValue, GetType, ());
2755     LLDB_REGISTER_METHOD(bool, SBValue, GetValueDidChange, ());
2756     LLDB_REGISTER_METHOD(const char *, SBValue, GetSummary, ());
2757     LLDB_REGISTER_METHOD(const char *, SBValue, GetSummary,
2758                          (lldb::SBStream &, lldb::SBTypeSummaryOptions &));
2759     LLDB_REGISTER_METHOD(const char *, SBValue, GetLocation, ());
2760     LLDB_REGISTER_METHOD(bool, SBValue, SetValueFromCString, (const char *));
2761     LLDB_REGISTER_METHOD(bool, SBValue, SetValueFromCString,
2762                          (const char *, lldb::SBError &));
2763     LLDB_REGISTER_METHOD(lldb::SBTypeFormat, SBValue, GetTypeFormat, ());
2764     LLDB_REGISTER_METHOD(lldb::SBTypeSummary, SBValue, GetTypeSummary, ());
2765     LLDB_REGISTER_METHOD(lldb::SBTypeFilter, SBValue, GetTypeFilter, ());
2766 #ifndef LLDB_DISABLE_PYTHON
2767     LLDB_REGISTER_METHOD(lldb::SBTypeSynthetic, SBValue, GetTypeSynthetic, ());
2768 #endif
2769     LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, CreateChildAtOffset,
2770                          (const char *, uint32_t, lldb::SBType));
2771     LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, Cast, (lldb::SBType));
2772     LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, CreateValueFromExpression,
2773                          (const char *, const char *));
2774     LLDB_REGISTER_METHOD(
2775         lldb::SBValue, SBValue, CreateValueFromExpression,
2776         (const char *, const char *, lldb::SBExpressionOptions &));
2777     LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, CreateValueFromAddress,
2778                          (const char *, lldb::addr_t, lldb::SBType));
2779     LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, CreateValueFromData,
2780                          (const char *, lldb::SBData, lldb::SBType));
2781     LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetChildAtIndex, (uint32_t));
2782     LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetChildAtIndex,
2783                          (uint32_t, lldb::DynamicValueType, bool));
2784     LLDB_REGISTER_METHOD(uint32_t, SBValue, GetIndexOfChildWithName,
2785                          (const char *));
2786     LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetChildMemberWithName,
2787                          (const char *));
2788     LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetChildMemberWithName,
2789                          (const char *, lldb::DynamicValueType));
2790     LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetDynamicValue,
2791                          (lldb::DynamicValueType));
2792     LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetStaticValue, ());
2793     LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetNonSyntheticValue, ());
2794     LLDB_REGISTER_METHOD(lldb::DynamicValueType, SBValue, GetPreferDynamicValue,
2795                          ());
2796     LLDB_REGISTER_METHOD(void, SBValue, SetPreferDynamicValue,
2797                          (lldb::DynamicValueType));
2798     LLDB_REGISTER_METHOD(bool, SBValue, GetPreferSyntheticValue, ());
2799     LLDB_REGISTER_METHOD(void, SBValue, SetPreferSyntheticValue, (bool));
2800     LLDB_REGISTER_METHOD(bool, SBValue, IsDynamic, ());
2801     LLDB_REGISTER_METHOD(bool, SBValue, IsSynthetic, ());
2802     LLDB_REGISTER_METHOD(bool, SBValue, IsSyntheticChildrenGenerated, ());
2803     LLDB_REGISTER_METHOD(void, SBValue, SetSyntheticChildrenGenerated, (bool));
2804     LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetValueForExpressionPath,
2805                          (const char *));
2806     LLDB_REGISTER_METHOD(int64_t, SBValue, GetValueAsSigned,
2807                          (lldb::SBError &, int64_t));
2808     LLDB_REGISTER_METHOD(uint64_t, SBValue, GetValueAsUnsigned,
2809                          (lldb::SBError &, uint64_t));
2810     LLDB_REGISTER_METHOD(int64_t, SBValue, GetValueAsSigned, (int64_t));
2811     LLDB_REGISTER_METHOD(uint64_t, SBValue, GetValueAsUnsigned, (uint64_t));
2812     LLDB_REGISTER_METHOD(bool, SBValue, MightHaveChildren, ());
2813     LLDB_REGISTER_METHOD(bool, SBValue, IsRuntimeSupportValue, ());
2814     LLDB_REGISTER_METHOD(uint32_t, SBValue, GetNumChildren, ());
2815     LLDB_REGISTER_METHOD(uint32_t, SBValue, GetNumChildren, (uint32_t));
2816     LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, Dereference, ());
2817     LLDB_REGISTER_METHOD(bool, SBValue, TypeIsPointerType, ());
2818     LLDB_REGISTER_METHOD(void *, SBValue, GetOpaqueType, ());
2819     LLDB_REGISTER_METHOD(lldb::SBTarget, SBValue, GetTarget, ());
2820     LLDB_REGISTER_METHOD(lldb::SBProcess, SBValue, GetProcess, ());
2821     LLDB_REGISTER_METHOD(lldb::SBThread, SBValue, GetThread, ());
2822     LLDB_REGISTER_METHOD(lldb::SBFrame, SBValue, GetFrame, ());
2823     LLDB_REGISTER_METHOD_CONST(lldb::ValueObjectSP, SBValue, GetSP, ());
2824     LLDB_REGISTER_METHOD(bool, SBValue, GetExpressionPath, (lldb::SBStream &));
2825     LLDB_REGISTER_METHOD(bool, SBValue, GetExpressionPath,
2826                          (lldb::SBStream &, bool));
2827     LLDB_REGISTER_METHOD_CONST(lldb::SBValue, SBValue, EvaluateExpression,
2828                                (const char *));
2829     LLDB_REGISTER_METHOD_CONST(
2830         lldb::SBValue, SBValue, EvaluateExpression,
2831         (const char *, const lldb::SBExpressionOptions &));
2832     LLDB_REGISTER_METHOD_CONST(
2833         lldb::SBValue, SBValue, EvaluateExpression,
2834         (const char *, const lldb::SBExpressionOptions &, const char *));
2835     LLDB_REGISTER_METHOD(bool, SBValue, GetDescription, (lldb::SBStream &));
2836     LLDB_REGISTER_METHOD(lldb::Format, SBValue, GetFormat, ());
2837     LLDB_REGISTER_METHOD(void, SBValue, SetFormat, (lldb::Format));
2838     LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, AddressOf, ());
2839     LLDB_REGISTER_METHOD(lldb::addr_t, SBValue, GetLoadAddress, ());
2840     LLDB_REGISTER_METHOD(lldb::SBAddress, SBValue, GetAddress, ());
2841     LLDB_REGISTER_METHOD(lldb::SBData, SBValue, GetPointeeData,
2842                          (uint32_t, uint32_t));
2843     LLDB_REGISTER_METHOD(lldb::SBData, SBValue, GetData, ());
2844     LLDB_REGISTER_METHOD(bool, SBValue, SetData,
2845                          (lldb::SBData &, lldb::SBError &));
2846     LLDB_REGISTER_METHOD(lldb::SBDeclaration, SBValue, GetDeclaration, ());
2847     LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBValue, Watch,
2848                          (bool, bool, bool, lldb::SBError &));
2849     LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBValue, Watch,
2850                          (bool, bool, bool));
2851     LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBValue, WatchPointee,
2852                          (bool, bool, bool, lldb::SBError &));
2853     LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, Persist, ());
2854   }
2855   {
2856     LLDB_REGISTER_CONSTRUCTOR(SBValueList, ());
2857     LLDB_REGISTER_CONSTRUCTOR(SBValueList, (const lldb::SBValueList &));
2858     LLDB_REGISTER_METHOD_CONST(bool, SBValueList, IsValid, ());
2859     LLDB_REGISTER_METHOD_CONST(bool, SBValueList, operator bool, ());
2860     LLDB_REGISTER_METHOD(void, SBValueList, Clear, ());
2861     LLDB_REGISTER_METHOD(const lldb::SBValueList &,
2862                          SBValueList, operator=,(const lldb::SBValueList &));
2863     LLDB_REGISTER_METHOD(void, SBValueList, Append, (const lldb::SBValue &));
2864     LLDB_REGISTER_METHOD(void, SBValueList, Append,
2865                          (const lldb::SBValueList &));
2866     LLDB_REGISTER_METHOD_CONST(lldb::SBValue, SBValueList, GetValueAtIndex,
2867                                (uint32_t));
2868     LLDB_REGISTER_METHOD_CONST(uint32_t, SBValueList, GetSize, ());
2869     LLDB_REGISTER_METHOD(lldb::SBValue, SBValueList, FindValueObjectByUID,
2870                          (lldb::user_id_t));
2871     LLDB_REGISTER_METHOD_CONST(lldb::SBValue, SBValueList, GetFirstValueByName,
2872                                (const char *));
2873   }
2874   {
2875     LLDB_REGISTER_CONSTRUCTOR(SBVariablesOptions, ());
2876     LLDB_REGISTER_CONSTRUCTOR(SBVariablesOptions,
2877                               (const lldb::SBVariablesOptions &));
2878     LLDB_REGISTER_METHOD(
2879         lldb::SBVariablesOptions &,
2880         SBVariablesOptions, operator=,(const lldb::SBVariablesOptions &));
2881     LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, IsValid, ());
2882     LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, operator bool, ());
2883     LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, GetIncludeArguments,
2884                                ());
2885     LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetIncludeArguments, (bool));
2886     LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions,
2887                                GetIncludeRecognizedArguments,
2888                                (const lldb::SBTarget &));
2889     LLDB_REGISTER_METHOD(void, SBVariablesOptions,
2890                          SetIncludeRecognizedArguments, (bool));
2891     LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, GetIncludeLocals, ());
2892     LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetIncludeLocals, (bool));
2893     LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, GetIncludeStatics, ());
2894     LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetIncludeStatics, (bool));
2895     LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, GetInScopeOnly, ());
2896     LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetInScopeOnly, (bool));
2897     LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions,
2898                                GetIncludeRuntimeSupportValues, ());
2899     LLDB_REGISTER_METHOD(void, SBVariablesOptions,
2900                          SetIncludeRuntimeSupportValues, (bool));
2901     LLDB_REGISTER_METHOD_CONST(lldb::DynamicValueType, SBVariablesOptions,
2902                                GetUseDynamic, ());
2903     LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetUseDynamic,
2904                          (lldb::DynamicValueType));
2905   }
2906   {
2907     LLDB_REGISTER_CONSTRUCTOR(SBWatchpoint, ());
2908     LLDB_REGISTER_CONSTRUCTOR(SBWatchpoint, (const lldb::WatchpointSP &));
2909     LLDB_REGISTER_CONSTRUCTOR(SBWatchpoint, (const lldb::SBWatchpoint &));
2910     LLDB_REGISTER_METHOD(const lldb::SBWatchpoint &,
2911                          SBWatchpoint, operator=,(const lldb::SBWatchpoint &));
2912     LLDB_REGISTER_METHOD(lldb::watch_id_t, SBWatchpoint, GetID, ());
2913     LLDB_REGISTER_METHOD_CONST(bool, SBWatchpoint, IsValid, ());
2914     LLDB_REGISTER_METHOD_CONST(bool, SBWatchpoint, operator bool, ());
2915     LLDB_REGISTER_METHOD(lldb::SBError, SBWatchpoint, GetError, ());
2916     LLDB_REGISTER_METHOD(int32_t, SBWatchpoint, GetHardwareIndex, ());
2917     LLDB_REGISTER_METHOD(lldb::addr_t, SBWatchpoint, GetWatchAddress, ());
2918     LLDB_REGISTER_METHOD(size_t, SBWatchpoint, GetWatchSize, ());
2919     LLDB_REGISTER_METHOD(void, SBWatchpoint, SetEnabled, (bool));
2920     LLDB_REGISTER_METHOD(bool, SBWatchpoint, IsEnabled, ());
2921     LLDB_REGISTER_METHOD(uint32_t, SBWatchpoint, GetHitCount, ());
2922     LLDB_REGISTER_METHOD(uint32_t, SBWatchpoint, GetIgnoreCount, ());
2923     LLDB_REGISTER_METHOD(void, SBWatchpoint, SetIgnoreCount, (uint32_t));
2924     LLDB_REGISTER_METHOD(const char *, SBWatchpoint, GetCondition, ());
2925     LLDB_REGISTER_METHOD(void, SBWatchpoint, SetCondition, (const char *));
2926     LLDB_REGISTER_METHOD(bool, SBWatchpoint, GetDescription,
2927                          (lldb::SBStream &, lldb::DescriptionLevel));
2928     LLDB_REGISTER_METHOD(void, SBWatchpoint, Clear, ());
2929     LLDB_REGISTER_METHOD_CONST(lldb::WatchpointSP, SBWatchpoint, GetSP, ());
2930     LLDB_REGISTER_METHOD(void, SBWatchpoint, SetSP,
2931                          (const lldb::WatchpointSP &));
2932     LLDB_REGISTER_STATIC_METHOD(bool, SBWatchpoint, EventIsWatchpointEvent,
2933                                 (const lldb::SBEvent &));
2934     LLDB_REGISTER_STATIC_METHOD(lldb::WatchpointEventType, SBWatchpoint,
2935                                 GetWatchpointEventTypeFromEvent,
2936                                 (const lldb::SBEvent &));
2937     LLDB_REGISTER_STATIC_METHOD(lldb::SBWatchpoint, SBWatchpoint,
2938                                 GetWatchpointFromEvent,
2939                                 (const lldb::SBEvent &));
2940   }
2941 }
2942 
2943 const char *SBReproducer::Capture() {
2944   static std::string error;
2945   if (auto e = Reproducer::Initialize(ReproducerMode::Capture, llvm::None)) {
2946     error = llvm::toString(std::move(e));
2947     return error.c_str();
2948   }
2949   return nullptr;
2950 }
2951 
2952 const char *SBReproducer::Capture(const char *path) {
2953   static std::string error;
2954   if (auto e =
2955           Reproducer::Initialize(ReproducerMode::Capture, FileSpec(path))) {
2956     error = llvm::toString(std::move(e));
2957     return error.c_str();
2958   }
2959   return nullptr;
2960 }
2961 
2962 const char *SBReproducer::Replay(const char *path) {
2963   static std::string error;
2964   if (auto e = Reproducer::Initialize(ReproducerMode::Replay, FileSpec(path))) {
2965     error = llvm::toString(std::move(e));
2966     return error.c_str();
2967   }
2968 
2969   repro::Loader *loader = repro::Reproducer::Instance().GetLoader();
2970   if (!loader) {
2971     error = "unable to get replay loader.";
2972     return error.c_str();
2973   }
2974 
2975   FileSpec file = loader->GetFile<SBInfo>();
2976   if (!file) {
2977     error = "unable to get replay data from reproducer.";
2978     return error.c_str();
2979   }
2980 
2981   SBRegistry registry;
2982   registry.Replay(file);
2983 
2984   return nullptr;
2985 }
2986 
2987 char lldb_private::repro::SBProvider::ID = 0;
2988 const char *SBInfo::name = "sbapi";
2989 const char *SBInfo::file = "sbapi.bin";
2990