[lldb] Replace SB swig interfaces with API headers

[bulbazord]

Summary

Instead of maintaining separate swig interface files, we can use the API
headers directly. They implement the exact same C++ APIs and we can
conditionally include the python extensions as needed. To remove the
swig extensions from the API headers when building the LLDB
framework, we can use the unifdef tool when it is available. Otherwise
we just copy them as-is.

[mib]

I'm very excited about this :) ! We've already discussed that offline but it would be nice if we could use Doxygen comments in the header files to generate the python Docstrings (I'm pretty sure SWIG supports it).

Then, for python specific comments, we would have a separate documentation file. Also, naming-wise, since the file extension doesn't really matter for SWIG, I'd just match the header file name and change the extension (what about .i for the code specific to the target language and .rst for the documentation).

lldb/bindings/macros.swig

50–51

Pretty cool!

lldb/cmake/modules/LLDBFramework.cmake

99–100

May be we should add a cmake check to make sure unidef is available on the system.

[clayborg]

lldb/include/lldb/API/SBAddress.h

14–16

Do we want two different .i files? Right now we have both"interface/SB*Docstrings.i" and "interface/SB*Extensions.i". Can those be combined into just one "interface/SBAddress.i" and only included if we have anything in the .i file that isn't just a copy of the API itself? Or does the doc string stuff have to come first?

30

Do we need all assignment operators left out for Swig? If so it might be good to add a comment explaining so it is clear to people. I can't remember if this is true or not in all cases?

128

Do we need all == operators left out of Swig stuff? Comment if so? Can't remember if this applies to all API objects or just to SBAddress?

[bulbazord]

lldb/cmake/modules/LLDBFramework.cmake

99–100

Yeah for the purposes of this diff I just used it without checking. If we go ahead with this patch I'll add some safety checks.

lldb/include/lldb/API/SBAddress.h

14–16

What I discovered when working this patch is that the docstring information needs to come before the declaration of what it wants to document. So SB*Docstrings.i should come first. The SB*Extensions.i are there to extend an existing class, so they should come after the class itself. I'm not sure there's a good way to do this.

Alternatively, we could changes the interfaces.swig file to include ./interface/SBAddressDocstrings.i, then lldb/API/SBAddress.h, then ./interface/SBAddressExtensions.i. That way we don't need to have these 2 #ifdef blocks in the API headers themselves.

30

Yeah I can add a comment. When generating python bindings, swig will ignore assignment operators as it doesn't map cleanly into python, which is why I left this out. It may be more accurate to do something like #ifndef SWIGPYTHON but seeing as the SBAddress.i class doesn't have an operator= in it, I decided to leave it out for swig generation entirely.

128

I don't think that all instances of operator== need to be left out. There are some classes that have it in the interface files, e.g. SBBreakpoint. I intentionally left this one out because it wasn't in SBAddress.i and I wanted this to leave the python bindings roughly the same (no new functions/methods, re-ordering them in the lldb.py should be ok though).

[clayborg]

lldb/include/lldb/API/SBAddress.h

14–16

Anything we can do to keep the headers clean would be great. I know that was the original reason we started using them.

30

Will it just ignore these if they are left in, or will it end up doing the wrong thing? Anything we can do to keep the header files clean is good. No worries if we have to keep the #ifndef stuff

128

Again, cleaner headers would be nice if we can get away with removing the #ifndef stuff

[bulbazord]

lldb/include/lldb/API/SBAddress.h

14–16

I'll try to minimize the noise in the API headers when I do the complete thing.

30

It ignores them and emits a warning. I suppose we don't care about these specific warnings and swig has a way of disabling specified warnings so I'll just do that instead.

128

I'm going to keep this one for now. This change is supposed to be relatively NFC and I don't want to introduce extra functionality in the python bindings at the same time we do this. We can re-evaluate adding this to the python bindings at a later time.

[kastiglione]

lldb/include/lldb/API/SBAddress.h

14–16

Alternatively, we could changes the interfaces.swig file to include ./interface/SBAddressDocstrings.i, then lldb/API/SBAddress.h, then ./interface/SBAddressExtensions.i. That way we don't need to have these 2 #ifdef blocks in the API headers themselves.

I was going to make this suggestion. I think it's better to do that.

[labath]

I like this.

I'm not sure what it would take, but I think it'd be nice if the de-swig-ification was not specific to the framework build. Ideally, I'd make it controlled by a separate cmake variable, (autodetected to on if the relevant tool is found, but also overridable by the user).

[kastiglione]

lldb/bindings/interface/SBAddressDocstrings.i

2–3

How much of these header docs are specific to the API, but not specific to Swig bindings? Should/can we move these to the SB headers and have Swig make use of those? In other words, can/should files like SBAddressDocstrings.I contain only docs that are specific to bindings?

[mib]

lldb/bindings/interface/SBAddressDocstrings.i

2–3

IIUC, @bulbazord feel free to correct me on this, most doc will be generate from doxygen in the header file and only things that are specific to the bindings will be in the interface.

[bulbazord]

In D142926#4102287, @labath wrote:

I like this.

I'm not sure what it would take, but I think it'd be nice if the de-swig-ification was not specific to the framework build. Ideally, I'd make it controlled by a separate cmake variable, (autodetected to on if the relevant tool is found, but also overridable by the user).

Yeah we could search for unified earlier in the process and use it when we distribute headers. The de-swig-ification of the headers is primarily for distribution, do any other platforms distribute the headers? I'm sure that happens, but I'm unsure if they do anything other than just copying the headers outright.

lldb/bindings/interface/SBAddressDocstrings.i

2–3

What Ismail is saying is what I'd like us to move to. Some of the docstrings are not specific to python at all and can be moved to the header files and generated from doxygen. I think that would best be done in a follow-up change in order to make this one more manageable as there is quite a lot to change already.

[JDevlieghere]

lldb/bindings/interface/SBAddressDocstrings.i

2–3

+1 for breaking this up into separate patches. Does SWIG automatically pick up Doxygen comments? That seems like a good thing to do regardless, so maybe something we can do while we're ironing out some of the other details in this review.

[bulbazord]

First pass at a complete implementation. Actions taken:

• Added swig flags to ignore swig warnings indicating that swig is ignoring certain operator overloads (e.g. operator=)
• Broke SB${Class}.i files into SB${Class}Docstrings.i (containing the docstrings) and SB${Class}Extensions.i (containing additional python functionality)
• Deleted all SB${Class}.i files.
• Moved necessary typemaps into python-typemaps.swig.
• Audited all SB class headers and add preprocessor macros to ignore any functions and methods that were not implemented in the SB${Class}.i files.
  • This is just to make this change more "atomic" (i.e. not adding any new functionality)

I can imagine that folks will have some opinions about this patch. It is pretty large, contains a few
"warts" (some of the swig header guards aren't very pretty), and there are probably better ways to do some things.
I'd therefore like to start getting feedback on this patch now that it works on my machine.
I've run the test suite on my macOS machine which I'm sure won't run every single test in every single configuration that
get run on the bots so I expect there to be some amount of churn even if this is approved and lands.

[bulbazord]

In addition to what I wrote above, I also fixed several documentation bugs (putting docstrings on the wrong method).

I manually audited the generated code before and after this change. Here are my notes:

Not too interesting:

• Some parameter names changed
• Fixed lots of documentation bugs
• Some documentation changed because of a re-ordering of function declarations

Potentially interesting:

• SBData::GetDescription base_addr parameter has default value now
• SBInstructionList::GetInstructionsCount canSetBreakpoint has default value now
• SBMemoryRegionInfo::SBMemoryRegionInfo 3rd constructor parameter stack_memory has default value now

Certainly interesting:

• SBListener::StopListeningForEventClass return type conflicts (ABI break?)
• SBProcess::GetQueueAtIndex parameter types conflict (ABI break?)
• SBTarget::BreakpointCreateByNames first parameter is different: const char **symbol_name vs const char *symbol_name[]. I'm not sure if this is going to be an issue.

[JDevlieghere]

I can see how having parity between the signatures that were exposed in the interface files makes the verification easier, but do we actually want to land the patch like that? Does anyone care that we expose more?

[clayborg]

In D142926#4111717, @bulbazord wrote:

In addition to what I wrote above, I also fixed several documentation bugs (putting docstrings on the wrong method).

I manually audited the generated code before and after this change. Here are my notes:

Not too interesting:

• Some parameter names changed
• Fixed lots of documentation bugs
• Some documentation changed because of a re-ordering of function declarations

Potentially interesting:

• SBData::GetDescription base_addr parameter has default value now
• SBInstructionList::GetInstructionsCount canSetBreakpoint has default value now
• SBMemoryRegionInfo::SBMemoryRegionInfo 3rd constructor parameter stack_memory has default value now

Certainly interesting:

• SBListener::StopListeningForEventClass return type conflicts (ABI break?)

No, probably a copy paste error when originally checked into .i file?

• SBProcess::GetQueueAtIndex parameter types conflict (ABI break?)

No, probably a copy paste error when originally checked into .i file?

• SBTarget::BreakpointCreateByNames first parameter is different: const char **symbol_name vs const char *symbol_name[]. I'm not sure if this is going to be an issue.

Maybe SWIG didn't like the "const char **" or it didn't do the right thing? Test and verify if we switch to using the header file we have no issues please?

[clayborg]

In D142926#4111717, @bulbazord wrote:

Potentially interesting:

• SBData::GetDescription base_addr parameter has default value now
• SBInstructionList::GetInstructionsCount canSetBreakpoint has default value now
• SBMemoryRegionInfo::SBMemoryRegionInfo 3rd constructor parameter stack_memory has default value now

Make sure it does work. I seem to remember people sometimes making two functions in the .i file for default parameters. Can't remember if SWIG does the right thing with default params or not, but please test to ensure both work (with and without).

[bulbazord]

• Removed a bunch of header guards effectively adding methods to the python bindings.

[bulbazord]

In D142926#4113600, @clayborg wrote:

In D142926#4111717, @bulbazord wrote:

Certainly interesting:

• SBListener::StopListeningForEventClass return type conflicts (ABI break?)

No, probably a copy paste error when originally checked into .i file?

Likely. This method is already tested in TestListener.py. Previously it returns an uint32_t (which turns into a python integer), now it returns a bool.

• SBProcess::GetQueueAtIndex parameter types conflict (ABI break?)

No, probably a copy paste error when originally checked into .i file?

Almost certainly. This method is well tested, I don't have many concerns here.

• SBTarget::BreakpointCreateByNames first parameter is different: const char **symbol_name vs const char *symbol_name[]. I'm not sure if this is going to be an issue.

Maybe SWIG didn't like the "const char **" or it didn't do the right thing? Test and verify if we switch to using the header file we have no issues please?

I'm not 100% sure why there was some divergence. For now I've done some ifdef/else/endif to separate this. I don't think there's a problem if we pick one over the other but this method is completely untested so I am punting it a bit. :)

In D142926#4113615, @clayborg wrote:

In D142926#4111717, @bulbazord wrote:

Potentially interesting:

• SBData::GetDescription base_addr parameter has default value now
• SBInstructionList::GetInstructionsCount canSetBreakpoint has default value now
• SBMemoryRegionInfo::SBMemoryRegionInfo 3rd constructor parameter stack_memory has default value now

Make sure it does work. I seem to remember people sometimes making two functions in the .i file for default parameters. Can't remember if SWIG does the right thing with default params or not, but please test to ensure both work (with and without).

I went through all 3 of them myself. Their result of having a default argument now is that there is a version of the function exposed that has 1 less argument. For example, SBInstructionList::GetInstructionsCount has 3 arguments where the last one now has a default value. You can still do GetInstructionsCount(arg1, arg2, arg3) where arg3 can be True or False. This is the same behavior as before. The new thing that got added was GetInstructionsCount(arg1, arg2) where arg3 will default to False without you specifying it. This is true for SBData::GetDescription and SBMemoryRegionInfo's 3rd constructor.

[bulbazord]

Not sure how useful it would be but I recorded the full list of methods get added with this change. Take a look and let me know if there are any that you think shouldn't be added.

SBAttachInfo::~SBAttachInfo()
SBBroadcaster::operator<(const lldb::SBBroadcaster &) const;
SBCommandInterpreter::SourceInitFileInHomeDirectory(lldb::SBCommandReturnObject &, bool);
SBCommandInterpreterRunOptions::SBCommandInterpreterRunOptions(const SBCommandInterpreterRunOptions &);
SBCommandInterpreterRunOptions::GetEchoCOmmentCommands() const;
SBCommandInterpreterRunOptions::SetEchoCommentCommands(bool);
SBCommandInterpreterRunOptions::GetAutoHandleEvents() const;
SBCommandInterpreterRunOptions::SetAutoHandleEvents(bool);
SBCommandInterpreterRunOptions::GetSpawnThread() const;
SBCommandInterpreterRunOptions::SetSpawnThread(bool);
SBDebugger::GetBroadcasterClass();
SBDebugger::PrintDiagnosticsOnError();
SBDebugger::SkipAppInitFiles(bool);
SBDebugger::SaveInputTerminalState();
SBDebugger::RestoreInputTerminalState();
SBDebugger::SetUseSourceCache(bool);
SBDebugger::GetUseSourceCache() const;
SBDebugger::GetREPLLanguage() const;
SBDebugger::SetREPLLanguage(lldb::LanguageType);
SBEvent::GetDescription)(lldb::SBStream &);
SBLaunchInfo::~SBLaunchInfo();
SBLaunchInfo::SBLaunchInfo(const SBLaunchInfo &);
SBModule::GetUUIDBytes() const;
SBPlatform::SBPlatform(const SBPlatform &);
SBProcess::Detach(bool);
SBProcess::GetStopEventForStopID(uint32_t);
SBProcess::GetBroadcasterClass();
SBProcess::LoadImage(const lldb::SBFileSpec &, const lldb::SBFileSpec &, lldb::SBError &);
SBQueue::SBQueue(const SBQueue &);
SBReproducer::Capture();
SBReproducer::Replay(const char *);
SBReproducer::Replay(const char *, bool);
SBReproducer::Finalize(const char *);
SBReproducer::GetPath();
SBReproducer::Generate();
SBSourceManager::SBSourceManager(const SBDebugger &);
SBSourceManager::SBSourceManager(const SBTarget &);
SBStringList::GetStringAtIndex(size_t) const;
SBTarget::BreakpointCreateByName(const char *, const SBFileSpecList &, const SBFileSpecList &);
SBTarget::BreakpointCreateByRegex(const char *, const SBFileSpecList &, const SBFileSpecList &);
SBThreadPlan::SBThreadPlan(lldb::SBThread &, const char *, lldb::SBStructuredData &);
SBThreadPlan::QueueThreadPlanForStepOverRange(SBAddress &, lldb::addr_t, SBError &);
SBThreadPlan::QueueThreadPlanForStepInRange(SBAddress &, lldb::addr_t, SBError &);
SBThreadPlan::QueueThreadPlanForStepOut(uint32_t, bool, SBError &);
SBThreadPlan::QueueThreadPlanForRunToAddress(SBAddress, SBError &);
SBTrace::LoadTraceFromFile(SBError &, SBDebugger &, const SBFileSpec &);
SBTypeMember::GetDescription(lldb::SBStream &, lldb::DescriptionLevel);
SBType::GetDescription(lldb::SBStream &, lldb::DescriptionLevel);
SBTypeList::SBTypeList(const lldb::SBTypeList &);
SBTypeCategory::operator==(lldb::SBTypeCategory &);
SBTypeCategory::operator!=(lldb::SBTypeCategory &);
SBTypeSummary::DoesPrintValue(lldb::SBValue);
SBTypeSynthetic::IsClassName();
SBValue::Watch(bool, bool, bool);
SBWatchpoint::Clear();

[JDevlieghere]

In D142926#4114215, @bulbazord wrote:

Not sure how useful it would be but I recorded the full list of methods get added with this change. Take a look and let me know if there are any that you think shouldn't be added.

Thanks for generating that list. Given that the reproducers are not functional, let's not add these to the Python API:

SBReproducer::Capture();
SBReproducer::Replay(const char *);
SBReproducer::Replay(const char *, bool);
SBReproducer::Finalize(const char *);
SBReproducer::GetPath();
SBReproducer::Generate();

[clayborg]

In D142926#4115875, @JDevlieghere wrote:

In D142926#4114215, @bulbazord wrote:

Not sure how useful it would be but I recorded the full list of methods get added with this change. Take a look and let me know if there are any that you think shouldn't be added.

Thanks for generating that list. Given that the reproducers are not functional, let's not add these to the Python API:

SBReproducer::Capture();
SBReproducer::Replay(const char *);
SBReproducer::Replay(const char *, bool);
SBReproducer::Finalize(const char *);
SBReproducer::GetPath();
SBReproducer::Generate();

Are they not functional from native code? or just not functional from Python?

[JDevlieghere]

In D142926#4115980, @clayborg wrote:

In D142926#4115875, @JDevlieghere wrote:

In D142926#4114215, @bulbazord wrote:

Not sure how useful it would be but I recorded the full list of methods get added with this change. Take a look and let me know if there are any that you think shouldn't be added.

Thanks for generating that list. Given that the reproducers are not functional, let's not add these to the Python API:

SBReproducer::Capture();
SBReproducer::Replay(const char *);
SBReproducer::Replay(const char *, bool);
SBReproducer::Finalize(const char *);
SBReproducer::GetPath();
SBReproducer::Generate();

Are they not functional from native code? or just not functional from Python?

The feature was removed but for ABI stability reasons we can't remove them from the SB API. Most/all of them return an error saying the feature has been removed.

[clayborg]

In D142926#4116417, @JDevlieghere wrote:

In D142926#4115980, @clayborg wrote:

In D142926#4115875, @JDevlieghere wrote:

In D142926#4114215, @bulbazord wrote:

Not sure how useful it would be but I recorded the full list of methods get added with this change. Take a look and let me know if there are any that you think shouldn't be added.

Thanks for generating that list. Given that the reproducers are not functional, let's not add these to the Python API:

SBReproducer::Capture();
SBReproducer::Replay(const char *);
SBReproducer::Replay(const char *, bool);
SBReproducer::Finalize(const char *);
SBReproducer::GetPath();
SBReproducer::Generate();

Are they not functional from native code? or just not functional from Python?

The feature was removed but for ABI stability reasons we can't remove them from the SB API. Most/all of them return an error saying the feature has been removed.

Does this mean we could submit a patch that removes all of the "LLDB_INSTRUMENT*" stuff that is in all of the SB*.cpp files? That would be great to clean that up if they are not needed.

[JDevlieghere]

In D142926#4116427, @clayborg wrote:

Does this mean we could submit a patch that removes all of the "LLDB_INSTRUMENT*" stuff that is in all of the SB*.cpp files? That would be great to clean that up if they are not needed.

No, they are still needed. They still track API boundaries, just like they did for the reproducers. The API boundaries are used for the API log and for timers/os_signposts. What they do is make sure that when you call into the SB API and the implementation of that SB API method calls another SB API, only the outer one will show up in the log. The macros also ensure that every function is correctly logged. Before the macros, half of the methods didn't log to the API log and the ones that did were riddled with inconsistencies (typos, copy-paste errors, etc).

[bulbazord]

Stop exposing unsupported SBReproducer functions

[bulbazord]

Does anybody have any further concerns or objections? I'd like to get this change in early next week if possible.

[labath]

In D142926#4103185, @bulbazord wrote:

In D142926#4102287, @labath wrote:

I like this.

I'm not sure what it would take, but I think it'd be nice if the de-swig-ification was not specific to the framework build. Ideally, I'd make it controlled by a separate cmake variable, (autodetected to on if the relevant tool is found, but also overridable by the user).

Yeah we could search for unified earlier in the process and use it when we distribute headers. The de-swig-ification of the headers is primarily for distribution, do any other platforms distribute the headers?

Some certainly do. I haven't found them in debian, but they are present on gentoo for instance. The would be necessary if someone wanted to build a tool linking to liblldb, so I would consider the fact that they are missing a bug.

I'm sure that happens, but I'm unsure if they do anything other than just copying the headers outright.

Well... right now, there isn't anything else to do there.

Anyway, I don't think this is particularly important. I don't know even if the distros would like to do this or whether to they'd prefer to ship unchanged headers. However, to me, it seems like the choice of the distribution method (framework vs. "traditional" unix layout) should be orthogonal to the choice of deswig-ifying the headers.

[bulbazord]

In D142926#4123492, @labath wrote:

Well... right now, there isn't anything else to do there.

Anyway, I don't think this is particularly important. I don't know even if the distros would like to do this or whether to they'd prefer to ship unchanged headers. However, to me, it seems like the choice of the distribution method (framework vs. "traditional" unix layout) should be orthogonal to the choice of deswig-ifying the headers.

I think I agree with you about the choice of distribution method being orthogonal to choice of removing the swig ifdefs from the headers. That being said, I don't know if any other distributors would care for this and I'm not sure who I would ask. I added support for using unifdef in the LLDB.framework case because I can ensure it is used and tested. I am hesitant to add support without somebody to test/use this.

Sort of tangential to this, the only other target where I think this would be used would be the lldb-headers target. That seems to install all the lldb headers, including all the private lldb headers. I could use unifdef there (assuming it's available). Is it intended that it installs all the private lldb headers though?

[bulbazord]

Rebasing against top of tree

[mib]

LGTM!

[saugustine]

I don't think this necessarily matters or is a reason to revert, but we are seeing issues with this patch and swig 3.0.2, that disappear with swig 4.0.

The docs claim that versions past 3.0 are supported (except for some odd corner cases).

The failure is:

Traceback (most recent call last):
  File "/build/work/37f17038e9cfbfbee7db556850bc7314bdb1/google3/runfiles/google3/third_party/llvm/llvm-project/lldb/test/API/functionalities/breakpoint/address_breakpoints/TestAddressBreakpoints.py", line 19, in test_address_breakpoints
    self.address_breakpoints()
  File "/build/work/37f17038e9cfbfbee7db556850bc7314bdb1/google3/runfiles/google3/third_party/llvm/llvm-project/lldb/test/API/functionalities/breakpoint/address_breakpoints/TestAddressBreakpoints.py", line 50, in address_breakpoints
    launch_info = lldb.SBLaunchInfo(None)
  File "/build/work/37f17038e9cfbfbee7db556850bc7314bdb1/google3/runfiles/google3/third_party/py/lldb/dotest_wrapper.par/google3/third_party/llvm/llvm-project/lldb/lib/python/site-packages/lldb/__init__.py", line 6239, in __init__
    this = _lldb.new_SBLaunchInfo(*args)
ValueError: invalid null reference in method 'new_SBLaunchInfo', argument 1 of type 'lldb::SBLaunchInfo const &'
Config=x86_64-/build/work/37f17038e9cfbfbee7db556850bc7314bdb1/google3/runfiles/google3/devtools/c/lldb/testing/clang

If I modify the line

launch_info = lldb.SBLaunchInfo(None)

to

launch_info = lldb.SBLaunchInfo("")

I get this error, which gives a clue to the fix:

NotImplementedError: Wrong number or type of arguments for overloaded function 'new_SBLaunchInfo'.
  Possible C/C++ prototypes are:
    lldb::SBLaunchInfo::SBLaunchInfo(char const **)
    lldb::SBLaunchInfo::SBLaunchInfo(lldb::SBLaunchInfo const &)

So if I use a vector of strings to match the first overload, the error disappears and the tests pass:

launch_info = lldb.SBLaunchInfo(["", ""])

Not sure the best way forward here. Either to abandon old versions of swig, or to clean up the launch command.

[bulbazord]

In D142926#4133356, @saugustine wrote:

I don't think this necessarily matters or is a reason to revert, but we are seeing issues with this patch and swig 3.0.2, that disappear with swig 4.0.

The docs claim that versions past 3.0 are supported (except for some odd corner cases).

The failure is:

Traceback (most recent call last):
  File "/build/work/37f17038e9cfbfbee7db556850bc7314bdb1/google3/runfiles/google3/third_party/llvm/llvm-project/lldb/test/API/functionalities/breakpoint/address_breakpoints/TestAddressBreakpoints.py", line 19, in test_address_breakpoints
    self.address_breakpoints()
  File "/build/work/37f17038e9cfbfbee7db556850bc7314bdb1/google3/runfiles/google3/third_party/llvm/llvm-project/lldb/test/API/functionalities/breakpoint/address_breakpoints/TestAddressBreakpoints.py", line 50, in address_breakpoints
    launch_info = lldb.SBLaunchInfo(None)
  File "/build/work/37f17038e9cfbfbee7db556850bc7314bdb1/google3/runfiles/google3/third_party/py/lldb/dotest_wrapper.par/google3/third_party/llvm/llvm-project/lldb/lib/python/site-packages/lldb/__init__.py", line 6239, in __init__
    this = _lldb.new_SBLaunchInfo(*args)
ValueError: invalid null reference in method 'new_SBLaunchInfo', argument 1 of type 'lldb::SBLaunchInfo const &'
Config=x86_64-/build/work/37f17038e9cfbfbee7db556850bc7314bdb1/google3/runfiles/google3/devtools/c/lldb/testing/clang

If I modify the line

launch_info = lldb.SBLaunchInfo(None)

to

launch_info = lldb.SBLaunchInfo("")

I get this error, which gives a clue to the fix:

NotImplementedError: Wrong number or type of arguments for overloaded function 'new_SBLaunchInfo'.
  Possible C/C++ prototypes are:
    lldb::SBLaunchInfo::SBLaunchInfo(char const **)
    lldb::SBLaunchInfo::SBLaunchInfo(lldb::SBLaunchInfo const &)

So if I use a vector of strings to match the first overload, the error disappears and the tests pass:

launch_info = lldb.SBLaunchInfo(["", ""])

Not sure the best way forward here. Either to abandon old versions of swig, or to clean up the launch command.

I'm not sure we're going to be able to drop support for older versions of swig at this time. Prior to this change, SBLaunchInfo only had one constructor exposed to python (the one that takes a const char **). This change exposes the SBLaunchInfo copy constructor.
The way I see it there are two options: (1) Stop exposing the copy constructor, or (2) Modify all the uses of SBLaunchInfo to take a list of empty strings.
Considering that this worked fine before, I'm inclined to stop exposing the SBLaunchInfo copy constructor. I'll upload a patch to handle that.

[bulbazord]

In D142926#4133440, @bulbazord wrote:

I'll upload a patch to handle that.

D144228

[labath]

In D142926#4124297, @bulbazord wrote:

In D142926#4123492, @labath wrote:

Well... right now, there isn't anything else to do there.

Anyway, I don't think this is particularly important. I don't know even if the distros would like to do this or whether to they'd prefer to ship unchanged headers. However, to me, it seems like the choice of the distribution method (framework vs. "traditional" unix layout) should be orthogonal to the choice of deswig-ifying the headers.

I think I agree with you about the choice of distribution method being orthogonal to choice of removing the swig ifdefs from the headers. That being said, I don't know if any other distributors would care for this and I'm not sure who I would ask. I added support for using unifdef in the LLDB.framework case because I can ensure it is used and tested. I am hesitant to add support without somebody to test/use this.

Sort of tangential to this, the only other target where I think this would be used would be the lldb-headers target. That seems to install all the lldb headers, including all the private lldb headers. I could use unifdef there (assuming it's available). Is it intended that it installs all the private lldb headers though?

I don't know... maybe it isn't? I guess this isn't particularly important and people can and deswigification steps there if they want to.

I really like the rest of the patch though.

lldb/bindings/CMakeLists.txt

 if(APPLE)
   set(DARWIN_EXTRAS "-D__APPLE__")
 else()
   set(DARWIN_EXTRAS "")
 endif()
 
 set(SWIG_COMMON_FLAGS
   -c++
+  -w361,362 # Ignore warnings about ignored operator overloads
   -features autodoc
   -I${LLDB_SOURCE_DIR}/include
   -I${CMAKE_CURRENT_SOURCE_DIR}
   ${DARWIN_EXTRAS}
 )
 
 function(create_relative_symlink swig_target dest_file output_dir output_name)
   get_filename_component(dest_file ${dest_file} ABSOLUTE)

lldb/bindings/interface/SBAddressDocstrings.i

+%feature("docstring",
+"A section + offset based address class.
+
+The SBAddress class allows addresses to be relative to a section
+that can move during runtime due to images (executables, shared
+libraries, bundles, frameworks) being loaded at different
+addresses than the addresses found in the object file that
+represents them on disk. There are currently two types of addresses
+for a section:
+
+* file addresses
+* load addresses
+
+File addresses represents the virtual addresses that are in the 'on
+disk' object files. These virtual addresses are converted to be
+relative to unique sections scoped to the object file so that
+when/if the addresses slide when the images are loaded/unloaded
+in memory, we can easily track these changes without having to
+update every object (compile unit ranges, line tables, function
+address ranges, lexical block and inlined subroutine address
+ranges, global and static variables) each time an image is loaded or
+unloaded.
+
+Load addresses represents the virtual addresses where each section
+ends up getting loaded at runtime. Before executing a program, it
+is common for all of the load addresses to be unresolved. When a
+DynamicLoader plug-in receives notification that shared libraries
+have been loaded/unloaded, the load addresses of the main executable
+and any images (shared libraries) will be  resolved/unresolved. When
+this happens, breakpoints that are in one of these sections can be
+set/cleared.
+
+See docstring of SBFunction for example usage of SBAddress."
+) lldb::SBAddress;
+
+%feature("docstring", "
+    Create an address by resolving a load address using the supplied target.")
+lldb::SBAddress::SBAddress;
+
+%feature("docstring", "
+    GetSymbolContext() and the following can lookup symbol information for a given address.
+    An address might refer to code or data from an existing module, or it
+    might refer to something on the stack or heap. The following functions
+    will only return valid values if the address has been resolved to a code
+    or data address using :py:class:`SBAddress.SetLoadAddress' or
+    :py:class:`SBTarget.ResolveLoadAddress`.") lldb::SBAddress::GetSymbolContext;
+
+%feature("docstring", "
+    GetModule() and the following grab individual objects for a given address and
+    are less efficient if you want more than one symbol related objects.
+    Use :py:class:`SBAddress.GetSymbolContext` or
+    :py:class:`SBTarget.ResolveSymbolContextForAddress` when you want multiple
+    debug symbol related objects for an address.
+    One or more bits from the SymbolContextItem enumerations can be logically
+    OR'ed together to more efficiently retrieve multiple symbol objects.")
+lldb::SBAddress::GetModule;

lldb/bindings/interface/SBAddressExtensions.i

-//===-- SWIG Interface for SBAddress ----------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-%feature("docstring",
-"A section + offset based address class.
-
-The SBAddress class allows addresses to be relative to a section
-that can move during runtime due to images (executables, shared
-libraries, bundles, frameworks) being loaded at different
-addresses than the addresses found in the object file that
-represents them on disk. There are currently two types of addresses
-for a section:
-
-* file addresses
-* load addresses
-
-File addresses represents the virtual addresses that are in the 'on
-disk' object files. These virtual addresses are converted to be
-relative to unique sections scoped to the object file so that
-when/if the addresses slide when the images are loaded/unloaded
-in memory, we can easily track these changes without having to
-update every object (compile unit ranges, line tables, function
-address ranges, lexical block and inlined subroutine address
-ranges, global and static variables) each time an image is loaded or
-unloaded.
-
-Load addresses represents the virtual addresses where each section
-ends up getting loaded at runtime. Before executing a program, it
-is common for all of the load addresses to be unresolved. When a
-DynamicLoader plug-in receives notification that shared libraries
-have been loaded/unloaded, the load addresses of the main executable
-and any images (shared libraries) will be  resolved/unresolved. When
-this happens, breakpoints that are in one of these sections can be
-set/cleared.
-
-See docstring of SBFunction for example usage of SBAddress."
-) SBAddress;
-class SBAddress
-{
-public:
-
-    SBAddress ();
-
-    SBAddress (const lldb::SBAddress &rhs);
-
-    SBAddress (lldb::SBSection section,
-               lldb::addr_t offset);
-
-    %feature("docstring", "
-    Create an address by resolving a load address using the supplied target.") SBAddress;
-    SBAddress (lldb::addr_t load_addr, lldb::SBTarget &target);
-
-    ~SBAddress ();
-
-    bool
-    IsValid () const;
-
-    explicit operator bool() const;
+STRING_EXTENSION_OUTSIDE(SBAddress)
 
+%extend lldb::SBAddress {
 #ifdef SWIGPYTHON
     // operator== is a free function, which swig does not handle, so we inject
     // our own equality operator here
     %pythoncode%{
     def __eq__(self, other):
       return not self.__ne__(other)
     %}
-#endif
-
-    bool operator!=(const SBAddress &rhs) const;
-
-    void
-    Clear ();
-
-    addr_t
-    GetFileAddress () const;
 
-    addr_t
-    GetLoadAddress (const lldb::SBTarget &target) const;
-
-    void
-    SetLoadAddress (lldb::addr_t load_addr,
-                    lldb::SBTarget &target);
-
-    bool
-    OffsetAddress (addr_t offset);
-
-    bool
-    GetDescription (lldb::SBStream &description);
-
-    lldb::SBSection
-    GetSection ();
-
-    lldb::addr_t
-    SBAddress::GetOffset ();
-
-    void
-    SetAddress (lldb::SBSection section,
-                lldb::addr_t offset);
-
-    %feature("docstring", "
-    GetSymbolContext() and the following can lookup symbol information for a given address.
-    An address might refer to code or data from an existing module, or it
-    might refer to something on the stack or heap. The following functions
-    will only return valid values if the address has been resolved to a code
-    or data address using :py:class:`SBAddress.SetLoadAddress' or
-    :py:class:`SBTarget.ResolveLoadAddress`.") GetSymbolContext;
-    lldb::SBSymbolContext
-    GetSymbolContext (uint32_t resolve_scope);
-
-    %feature("docstring", "
-    GetModule() and the following grab individual objects for a given address and
-    are less efficient if you want more than one symbol related objects.
-    Use :py:class:`SBAddress.GetSymbolContext` or
-    :py:class:`SBTarget.ResolveSymbolContextForAddress` when you want multiple
-    debug symbol related objects for an address.
-    One or more bits from the SymbolContextItem enumerations can be logically
-    OR'ed together to more efficiently retrieve multiple symbol objects.") GetModule;
-    lldb::SBModule
-    GetModule ();
-
-    lldb::SBCompileUnit
-    GetCompileUnit ();
-
-    lldb::SBFunction
-    GetFunction ();
-
-    lldb::SBBlock
-    GetBlock ();
-
-    lldb::SBSymbol
-    GetSymbol ();
-
-    lldb::SBLineEntry
-    GetLineEntry ();
-
-    STRING_EXTENSION(SBAddress)
-
-#ifdef SWIGPYTHON
     %pythoncode %{
         __runtime_error_str = 'This resolves the SBAddress using the SBTarget from lldb.target so this property can ONLY be used in the interactive script interpreter (i.e. under the lldb script command). For things like Python based commands and breakpoint callbacks use GetLoadAddress instead.'
 
         def __get_load_addr_property__ (self):
             '''Get the load address for a lldb.SBAddress using the current target. This resolves the SBAddress using the SBTarget from lldb.target so this property can ONLY be used in the interactive script interpreter (i.e. under the lldb script command). For things like Python based commands and breakpoint callbacks use GetLoadAddress instead.'''
             if not target:
                 raise RuntimeError(self.__runtime_error_str)
             return self.GetLoadAddress (target)
%pythoncode %{
         block = property(GetBlock, None, doc='''A read only property that returns an lldb object that represents the block (lldb.SBBlock) that this address resides within.''')
         symbol = property(GetSymbol, None, doc='''A read only property that returns an lldb object that represents the symbol (lldb.SBSymbol) that this address resides within.''')
         offset = property(GetOffset, None, doc='''A read only property that returns the section offset in bytes as an integer.''')
         section = property(GetSection, None, doc='''A read only property that returns an lldb object that represents the section (lldb.SBSection) that this address resides within.''')
         file_addr = property(GetFileAddress, None, doc='''A read only property that returns file address for the section as an integer. This is the address that represents the address as it is found in the object file that defines it.''')
         load_addr = property(__get_load_addr_property__, __set_load_addr_property__, doc='''A read/write property that gets/sets the SBAddress using load address. This resolves the SBAddress using the SBTarget from lldb.target so this property can ONLY be used in the interactive script interpreter (i.e. under the lldb script command). For things like Python based commands and breakpoint callbacks use GetLoadAddress instead.''')
     %}
 #endif
-
-};
-
-} // namespace lldb
+}

lldb/bindings/interface/SBAttachInfo.i

-//===-- SWIG Interface for SBAttachInfo--------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-%feature("docstring",
-"Describes how to attach when calling :py:class:`SBTarget.Attach`."
-) SBAttachInfo;
-class SBAttachInfo
-{
-public:
-    SBAttachInfo ();
-
-    SBAttachInfo (lldb::pid_t pid);
-
-    SBAttachInfo (const char *path, bool wait_for);
-
-    SBAttachInfo (const char *path, bool wait_for, bool async);
-
-    SBAttachInfo (const lldb::SBAttachInfo &rhs);
-
-    lldb::pid_t
-    GetProcessID ();
-
-    void
-    SetProcessID (lldb::pid_t pid);
-
-    void
-    SetExecutable (const char *path);
-
-    void
-    SetExecutable (lldb::SBFileSpec exe_file);
-
-    bool
-    GetWaitForLaunch ();
-
-    void
-    SetWaitForLaunch (bool b);
-
-    void
-    SetWaitForLaunch (bool b, bool async);
-
-    bool
-    GetIgnoreExisting ();
-
-    void
-    SetIgnoreExisting (bool b);
-
-    uint32_t
-    GetResumeCount ();
-
-    void
-    SetResumeCount (uint32_t c);
-
-    const char *
-    GetProcessPluginName ();
-
-    void
-    SetProcessPluginName (const char *plugin_name);
-
-    uint32_t
-    GetUserID();
-
-    uint32_t
-    GetGroupID();
-
-    bool
-    UserIDIsValid ();
-
-    bool
-    GroupIDIsValid ();
-
-    void
-    SetUserID (uint32_t uid);
-
-    void
-    SetGroupID (uint32_t gid);
-
-    uint32_t
-    GetEffectiveUserID();
-
-    uint32_t
-    GetEffectiveGroupID();
-
-    bool
-    EffectiveUserIDIsValid ();
-
-    bool
-    EffectiveGroupIDIsValid ();
-
-    void
-    SetEffectiveUserID (uint32_t uid);
-
-    void
-    SetEffectiveGroupID (uint32_t gid);
-
-    lldb::pid_t
-    GetParentProcessID ();
-
-    void
-    SetParentProcessID (lldb::pid_t pid);
-
-    bool
-    ParentProcessIDIsValid();
-
-    lldb::SBListener
-    GetListener ();
-
-    void
-    SetListener (lldb::SBListener &listener);
-};
-
-} // namespace lldb

lldb/bindings/interface/SBAttachInfoDocstrings.i

+%feature("docstring",
+"Describes how to attach when calling :py:class:`SBTarget.Attach`."
+) lldb::SBAttachInfo;

lldb/bindings/interface/SBBlockDocstrings.i

+%feature("docstring",
+"Represents a lexical block. SBFunction contains SBBlock(s)."
+) lldb::SBBlock;
+
+%feature("docstring",
+"Is this block contained within an inlined function?"
+) lldb::SBBlock::IsInlined;
+
+%feature("docstring", "
+    Get the function name if this block represents an inlined function;
+    otherwise, return None.") lldb::SBBlock::GetInlinedName;
+
+%feature("docstring", "
+    Get the call site file if this block represents an inlined function;
+    otherwise, return an invalid file spec.") lldb::SBBlock::GetInlinedCallSiteFile;
+
+%feature("docstring", "
+    Get the call site line if this block represents an inlined function;
+    otherwise, return 0.") lldb::SBBlock::GetInlinedCallSiteLine;
+
+%feature("docstring", "
+    Get the call site column if this block represents an inlined function;
+    otherwise, return 0.") lldb::SBBlock::GetInlinedCallSiteColumn;
+
+%feature("docstring", "Get the parent block.") lldb::SBBlock::GetParent;
+
+%feature("docstring", "Get the inlined block that is or contains this block."
+) lldb::SBBlock::GetContainingInlinedBlock;
+
+%feature("docstring", "Get the sibling block for this block.") lldb::SBBlock::GetSibling;
+
+%feature("docstring", "Get the first child block.") lldb::SBBlock::GetFirstChild;

lldb/bindings/interface/SBBlockExtensions.i

-//===-- SWIG Interface for SBBlock ------------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-%feature("docstring",
-"Represents a lexical block. SBFunction contains SBBlock(s)."
-) SBBlock;
-class SBBlock
-{
-public:
-
-    SBBlock ();
-
-    SBBlock (const lldb::SBBlock &rhs);
-
-    ~SBBlock ();
-
-    %feature("docstring",
-    "Is this block contained within an inlined function?"
-    ) IsInlined;
-    bool
-    IsInlined () const;
-
-    bool
-    IsValid () const;
-
-    explicit operator bool() const;
-
-    %feature("docstring", "
-    Get the function name if this block represents an inlined function;
-    otherwise, return None.") GetInlinedName;
-    const char *
-    GetInlinedName () const;
-
-    %feature("docstring", "
-    Get the call site file if this block represents an inlined function;
-    otherwise, return an invalid file spec.") GetInlinedCallSiteFile;
-    lldb::SBFileSpec
-    GetInlinedCallSiteFile () const;
-
-    %feature("docstring", "
-    Get the call site line if this block represents an inlined function;
-    otherwise, return 0.") GetInlinedCallSiteLine;
-    uint32_t
-    GetInlinedCallSiteLine () const;
-
-    %feature("docstring", "
-    Get the call site column if this block represents an inlined function;
-    otherwise, return 0.") GetInlinedCallSiteColumn;
-    uint32_t
-    GetInlinedCallSiteColumn () const;
-
-    %feature("docstring", "Get the parent block.") GetParent;
-    lldb::SBBlock
-    GetParent ();
-
-    %feature("docstring", "Get the inlined block that is or contains this block.") GetContainingInlinedBlock;
-    lldb::SBBlock
-    GetContainingInlinedBlock ();
-
-    %feature("docstring", "Get the sibling block for this block.") GetSibling;
-    lldb::SBBlock
-    GetSibling ();
-
-    %feature("docstring", "Get the first child block.") GetFirstChild;
-    lldb::SBBlock
-    GetFirstChild ();
-
-    uint32_t
-    GetNumRanges ();
-
-    lldb::SBAddress
-    GetRangeStartAddress (uint32_t idx);
-
-    lldb::SBAddress
-    GetRangeEndAddress (uint32_t idx);
-
-    uint32_t
-    GetRangeIndexForBlockAddress (lldb::SBAddress block_addr);
-
-    bool
-    GetDescription (lldb::SBStream &description);
-
-    lldb::SBValueList
-    GetVariables (lldb::SBFrame& frame,
-                  bool arguments,
-                  bool locals,
-                  bool statics,
-                  lldb::DynamicValueType use_dynamic);
-
-     lldb::SBValueList
-     GetVariables (lldb::SBTarget& target,
-                   bool arguments,
-                   bool locals,
-                   bool statics);
-
-    STRING_EXTENSION(SBBlock)
+STRING_EXTENSION_OUTSIDE(SBBlock)
 
+%extend lldb::SBBlock {
 #ifdef SWIGPYTHON
     %pythoncode %{
         def get_range_at_index(self, idx):
             if idx < self.GetNumRanges():
                 return [self.GetRangeStartAddress(idx), self.GetRangeEndAddress(idx)]
             return []
 
         class ranges_access(object):
%pythoncode %{
         sibling = property(GetSibling, None, doc='''A read only property that returns the same result as GetSibling().''')
         name = property(GetInlinedName, None, doc='''A read only property that returns the same result as GetInlinedName().''')
         inlined_block = property(GetContainingInlinedBlock, None, doc='''A read only property that returns the same result as GetContainingInlinedBlock().''')
         range = property(get_ranges_access_object, None, doc='''A read only property that allows item access to the address ranges for a block by integer (range = block.range[0]) and by lldb.SBAddress (find the range that contains the specified lldb.SBAddress like "pc_range = lldb.frame.block.range[frame.addr]").''')
         ranges = property(get_ranges_array, None, doc='''A read only property that returns a list() object that contains all of the address ranges for the block.''')
         num_ranges = property(GetNumRanges, None, doc='''A read only property that returns the same result as GetNumRanges().''')
     %}
 #endif
-
-};
-
-} // namespace lldb
+}

lldb/bindings/interface/SBBreakpoint.i

-//===-- SWIG Interface for SBBreakpoint -------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-namespace lldb {
-
-%feature("docstring",
-"Represents a logical breakpoint and its associated settings.
-
-For example (from test/functionalities/breakpoint/breakpoint_ignore_count/
-TestBreakpointIgnoreCount.py),::
-
-    def breakpoint_ignore_count_python(self):
-        '''Use Python APIs to set breakpoint ignore count.'''
-        exe = os.path.join(os.getcwd(), 'a.out')
-
-        # Create a target by the debugger.
-        target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target, VALID_TARGET)
-
-        # Now create a breakpoint on main.c by name 'c'.
-        breakpoint = target.BreakpointCreateByName('c', 'a.out')
-        self.assertTrue(breakpoint and
-                        breakpoint.GetNumLocations() == 1,
-                        VALID_BREAKPOINT)
-
-        # Get the breakpoint location from breakpoint after we verified that,
-        # indeed, it has one location.
-        location = breakpoint.GetLocationAtIndex(0)
-        self.assertTrue(location and
-                        location.IsEnabled(),
-                        VALID_BREAKPOINT_LOCATION)
-
-        # Set the ignore count on the breakpoint location.
-        location.SetIgnoreCount(2)
-        self.assertTrue(location.GetIgnoreCount() == 2,
-                        'SetIgnoreCount() works correctly')
-
-        # Now launch the process, and do not stop at entry point.
-        process = target.LaunchSimple(None, None, os.getcwd())
-        self.assertTrue(process, PROCESS_IS_VALID)
-
-        # Frame#0 should be on main.c:37, frame#1 should be on main.c:25, and
-        # frame#2 should be on main.c:48.
-        #lldbutil.print_stacktraces(process)
-        from lldbutil import get_stopped_thread
-        thread = get_stopped_thread(process, lldb.eStopReasonBreakpoint)
-        self.assertTrue(thread != None, 'There should be a thread stopped due to breakpoint')
-        frame0 = thread.GetFrameAtIndex(0)
-        frame1 = thread.GetFrameAtIndex(1)
-        frame2 = thread.GetFrameAtIndex(2)
-        self.assertTrue(frame0.GetLineEntry().GetLine() == self.line1 and
-                        frame1.GetLineEntry().GetLine() == self.line3 and
-                        frame2.GetLineEntry().GetLine() == self.line4,
-                        STOPPED_DUE_TO_BREAKPOINT_IGNORE_COUNT)
-
-        # The hit count for the breakpoint should be 3.
-        self.assertTrue(breakpoint.GetHitCount() == 3)
-
-        process.Continue()
-
-SBBreakpoint supports breakpoint location iteration, for example,::
-
-    for bl in breakpoint:
-        print('breakpoint location load addr: %s' % hex(bl.GetLoadAddress()))
-        print('breakpoint location condition: %s' % hex(bl.GetCondition()))
-
-and rich comparison methods which allow the API program to use,::
-
-    if aBreakpoint == bBreakpoint:
-        ...
-
-to compare two breakpoints for equality."
-) SBBreakpoint;
-class SBBreakpoint
-{
-public:
-
-    SBBreakpoint ();
-
-    SBBreakpoint (const lldb::SBBreakpoint& rhs);
-
-    ~SBBreakpoint();
-
-    bool operator==(const lldb::SBBreakpoint &rhs);
-
-    bool operator!=(const lldb::SBBreakpoint &rhs);
-
-    break_id_t
-    GetID () const;
-
-    bool
-    IsValid() const;
-
-    explicit operator bool() const;
-
-    void
-    ClearAllBreakpointSites ();
-
-    lldb::SBTarget
-    GetTarget() const;
-
-    lldb::SBBreakpointLocation
-    FindLocationByAddress (lldb::addr_t vm_addr);
-
-    lldb::break_id_t
-    FindLocationIDByAddress (lldb::addr_t vm_addr);
-
-    lldb::SBBreakpointLocation
-    FindLocationByID (lldb::break_id_t bp_loc_id);
-
-    lldb::SBBreakpointLocation
-    GetLocationAtIndex (uint32_t index);
-
-    void
-    SetEnabled (bool enable);
-
-    bool
-    IsEnabled ();
-
-    void
-    SetOneShot (bool one_shot);
-
-    bool
-    IsOneShot ();
-
-    bool
-    IsInternal ();
-
-    uint32_t
-    GetHitCount () const;
-
-    void
-    SetIgnoreCount (uint32_t count);
-
-    uint32_t
-    GetIgnoreCount () const;
-
-    %feature("docstring", "
-    The breakpoint stops only if the condition expression evaluates to true.") SetCondition;
-    void
-    SetCondition (const char *condition);
-
-    %feature("docstring", "
-    Get the condition expression for the breakpoint.") GetCondition;
-    const char *
-    GetCondition ();
-
-    void SetAutoContinue(bool auto_continue);
-
-    bool GetAutoContinue();
-
-    void
-    SetThreadID (lldb::tid_t sb_thread_id);
-
-    lldb::tid_t
-    GetThreadID ();
-
-    void
-    SetThreadIndex (uint32_t index);
-
-    uint32_t
-    GetThreadIndex() const;
-
-    void
-    SetThreadName (const char *thread_name);
-
-    const char *
-    GetThreadName () const;
-
-    void
-    SetQueueName (const char *queue_name);
-
-    const char *
-    GetQueueName () const;
-
-    %feature("docstring", "
-    Set the name of the script function to be called when the breakpoint is hit.") SetScriptCallbackFunction;
-    void
-    SetScriptCallbackFunction (const char *callback_function_name);
-
-    %feature("docstring", "
-    Set the name of the script function to be called when the breakpoint is hit.
-    To use this variant, the function should take (frame, bp_loc, extra_args, internal_dict) and
-    when the breakpoint is hit the extra_args will be passed to the callback function.") SetScriptCallbackFunction;
-    SBError
-    SetScriptCallbackFunction (const char *callback_function_name,
-                               SBStructuredData &extra_args);
-
-    %feature("docstring", "
-    Provide the body for the script function to be called when the breakpoint is hit.
-    The body will be wrapped in a function, which be passed two arguments:
-    'frame' - which holds the bottom-most SBFrame of the thread that hit the breakpoint
-    'bpno'  - which is the SBBreakpointLocation to which the callback was attached.
-
-    The error parameter is currently ignored, but will at some point hold the Python
-    compilation diagnostics.
-    Returns true if the body compiles successfully, false if not.") SetScriptCallbackBody;
-    SBError
-    SetScriptCallbackBody (const char *script_body_text);
-
-    void SetCommandLineCommands(SBStringList &commands);
-
-    bool GetCommandLineCommands(SBStringList &commands);
-
-    bool
-    AddName (const char *new_name);
-
-    SBError
-    AddNameWithErrorHandling (const char *new_name);
-
-    void
-    RemoveName (const char *name_to_remove);
-
-    bool
-    MatchesName (const char *name);
-
-    void
-    GetNames (SBStringList &names);
-
-    size_t
-    GetNumResolvedLocations() const;
-
-    size_t
-    GetNumLocations() const;
-
-    bool
-    GetDescription (lldb::SBStream &description);
-
-    bool
-    GetDescription(lldb::SBStream &description, bool include_locations);
-
-    // Can only be called from a ScriptedBreakpointResolver...
-    SBError
-    AddLocation(SBAddress &address);
-
-    SBStructuredData SBBreakpoint::SerializeToStructuredData();
-
-    static bool
-    EventIsBreakpointEvent (const lldb::SBEvent &event);
-
-    static lldb::BreakpointEventType
-    GetBreakpointEventTypeFromEvent (const lldb::SBEvent& event);
-
-    static lldb::SBBreakpoint
-    GetBreakpointFromEvent (const lldb::SBEvent& event);
-
-    static lldb::SBBreakpointLocation
-    GetBreakpointLocationAtIndexFromEvent (const lldb::SBEvent& event, uint32_t loc_idx);
-
-    static uint32_t
-    GetNumBreakpointLocationsFromEvent (const lldb::SBEvent &event_sp);
-
-    bool
-    IsHardware ();
-
-    STRING_EXTENSION(SBBreakpoint)
-
-#ifdef SWIGPYTHON
-    %pythoncode %{
-
-        class locations_access(object):
-            '''A helper object that will lazily hand out locations for a breakpoint when supplied an index.'''
-            def __init__(self, sbbreakpoint):
-                self.sbbreakpoint = sbbreakpoint
-
-            def __len__(self):
-                if self.sbbreakpoint:
-                    return int(self.sbbreakpoint.GetNumLocations())
-                return 0
-
-            def __getitem__(self, key):
-                if isinstance(key, int):
-                    count = len(self)
-                    if -count <= key < count:
-                        key %= count
-                        return self.sbbreakpoint.GetLocationAtIndex(key)
-                return None
-
-        def get_locations_access_object(self):
-            '''An accessor function that returns a locations_access() object which allows lazy location access from a lldb.SBBreakpoint object.'''
-            return self.locations_access (self)
-
-        def get_breakpoint_location_list(self):
-            '''An accessor function that returns a list() that contains all locations in a lldb.SBBreakpoint object.'''
-            locations = []
-            accessor = self.get_locations_access_object()
-            for idx in range(len(accessor)):
-                locations.append(accessor[idx])
-            return locations
-
-        def __iter__(self):
-            '''Iterate over all breakpoint locations in a lldb.SBBreakpoint
-            object.'''
-            return lldb_iter(self, 'GetNumLocations', 'GetLocationAtIndex')
-
-        def __len__(self):
-            '''Return the number of breakpoint locations in a lldb.SBBreakpoint
-            object.'''
-            return self.GetNumLocations()
-
-        locations = property(get_breakpoint_location_list, None, doc='''A read only property that returns a list() of lldb.SBBreakpointLocation objects for this breakpoint.''')
-        location = property(get_locations_access_object, None, doc='''A read only property that returns an object that can access locations by index (not location ID) (location = bkpt.location[12]).''')
-        id = property(GetID, None, doc='''A read only property that returns the ID of this breakpoint.''')
-        enabled = property(IsEnabled, SetEnabled, doc='''A read/write property that configures whether this breakpoint is enabled or not.''')
-        one_shot = property(IsOneShot, SetOneShot, doc='''A read/write property that configures whether this breakpoint is one-shot (deleted when hit) or not.''')
-        num_locations = property(GetNumLocations, None, doc='''A read only property that returns the count of locations of this breakpoint.''')
-    %}
-#endif
-
-
-};
-
-class SBBreakpointListImpl;
-
-
-%feature("docstring",
-"Represents a list of :py:class:`SBBreakpoint`."
-) SBBreakpointList;
-class LLDB_API SBBreakpointList
-{
-public:
-  SBBreakpointList(SBTarget &target);
-
-  ~SBBreakpointList();
-
-  size_t GetSize() const;
-
-  SBBreakpoint
-  GetBreakpointAtIndex(size_t idx);
-
-  SBBreakpoint
-  FindBreakpointByID(lldb::break_id_t);
-
-  void Append(const SBBreakpoint &sb_bkpt);
-
-  bool AppendIfUnique(const SBBreakpoint &sb_bkpt);
-
-  void AppendByID (lldb::break_id_t id);
-
-  void Clear();
-private:
-  std::shared_ptr<SBBreakpointListImpl> m_opaque_sp;
-};
-
-} // namespace lldb

lldb/bindings/interface/SBBreakpointDocstrings.i

+%feature("docstring",
+"Represents a logical breakpoint and its associated settings.
+
+For example (from test/functionalities/breakpoint/breakpoint_ignore_count/
+TestBreakpointIgnoreCount.py),::
+
+    def breakpoint_ignore_count_python(self):
+        '''Use Python APIs to set breakpoint ignore count.'''
+        exe = os.path.join(os.getcwd(), 'a.out')
+
+        # Create a target by the debugger.
+        target = self.dbg.CreateTarget(exe)
+        self.assertTrue(target, VALID_TARGET)
+
+        # Now create a breakpoint on main.c by name 'c'.
+        breakpoint = target.BreakpointCreateByName('c', 'a.out')
+        self.assertTrue(breakpoint and
+                        breakpoint.GetNumLocations() == 1,
+                        VALID_BREAKPOINT)
+
+        # Get the breakpoint location from breakpoint after we verified that,
+        # indeed, it has one location.
+        location = breakpoint.GetLocationAtIndex(0)
+        self.assertTrue(location and
+                        location.IsEnabled(),
+                        VALID_BREAKPOINT_LOCATION)
+
+        # Set the ignore count on the breakpoint location.
+        location.SetIgnoreCount(2)
+        self.assertTrue(location.GetIgnoreCount() == 2,
+                        'SetIgnoreCount() works correctly')
+
+        # Now launch the process, and do not stop at entry point.
+        process = target.LaunchSimple(None, None, os.getcwd())
+        self.assertTrue(process, PROCESS_IS_VALID)
+
+        # Frame#0 should be on main.c:37, frame#1 should be on main.c:25, and
+        # frame#2 should be on main.c:48.
+        #lldbutil.print_stacktraces(process)
+        from lldbutil import get_stopped_thread
+        thread = get_stopped_thread(process, lldb.eStopReasonBreakpoint)
+        self.assertTrue(thread != None, 'There should be a thread stopped due to breakpoint')
+        frame0 = thread.GetFrameAtIndex(0)
+        frame1 = thread.GetFrameAtIndex(1)
+        frame2 = thread.GetFrameAtIndex(2)
+        self.assertTrue(frame0.GetLineEntry().GetLine() == self.line1 and
+                        frame1.GetLineEntry().GetLine() == self.line3 and
+                        frame2.GetLineEntry().GetLine() == self.line4,
+                        STOPPED_DUE_TO_BREAKPOINT_IGNORE_COUNT)
+
+        # The hit count for the breakpoint should be 3.
+        self.assertTrue(breakpoint.GetHitCount() == 3)
+
+        process.Continue()
+
+SBBreakpoint supports breakpoint location iteration, for example,::
+
+    for bl in breakpoint:
+        print('breakpoint location load addr: %s' % hex(bl.GetLoadAddress()))
+        print('breakpoint location condition: %s' % hex(bl.GetCondition()))
+
+and rich comparison methods which allow the API program to use,::
+
+    if aBreakpoint == bBreakpoint:
+        ...
+
+to compare two breakpoints for equality."
+) lldb::SBBreakpoint;
+
+%feature("docstring", "
+    The breakpoint stops only if the condition expression evaluates to true."
+) lldb::SBBreakpoint::SetCondition;
+
+%feature("docstring", "
+    Get the condition expression for the breakpoint."
+) lldb::SBBreakpoint::GetCondition;
+
+%feature("docstring", "
+    Set the name of the script function to be called when the breakpoint is hit."
+) lldb::SBBreakpoint::SetScriptCallbackFunction;
+
+%feature("docstring", "
+    Set the name of the script function to be called when the breakpoint is hit.
+    To use this variant, the function should take (frame, bp_loc, extra_args, internal_dict) and
+    when the breakpoint is hit the extra_args will be passed to the callback function."
+) lldb::SBBreakpoint::SetScriptCallbackFunction;
+
+%feature("docstring", "
+    Provide the body for the script function to be called when the breakpoint is hit.
+    The body will be wrapped in a function, which be passed two arguments:
+    'frame' - which holds the bottom-most SBFrame of the thread that hit the breakpoint
+    'bpno'  - which is the SBBreakpointLocation to which the callback was attached.
+
+    The error parameter is currently ignored, but will at some point hold the Python
+    compilation diagnostics.
+    Returns true if the body compiles successfully, false if not."
+) lldb::SBBreakpoint::SetScriptCallbackBody;
+
+
+%feature("docstring",
+"Represents a list of :py:class:`SBBreakpoint`."
+) lldb::SBBreakpointList;

lldb/bindings/interface/SBBreakpointExtensions.i

+STRING_EXTENSION_OUTSIDE(SBBreakpoint)
+
+%extend lldb::SBBreakpoint {
+#ifdef SWIGPYTHON
+    %pythoncode %{
+
+        class locations_access(object):
+            '''A helper object that will lazily hand out locations for a breakpoint when supplied an index.'''
+            def __init__(self, sbbreakpoint):
+                self.sbbreakpoint = sbbreakpoint
+
+            def __len__(self):
+                if self.sbbreakpoint:
+                    return int(self.sbbreakpoint.GetNumLocations())
+                return 0
+
+            def __getitem__(self, key):
+                if isinstance(key, int):
+                    count = len(self)
+                    if -count <= key < count:
+                        key %= count
+                        return self.sbbreakpoint.GetLocationAtIndex(key)
+                return None
+
+        def get_locations_access_object(self):
+            '''An accessor function that returns a locations_access() object which allows lazy location access from a lldb.SBBreakpoint object.'''
+            return self.locations_access (self)
+
+        def get_breakpoint_location_list(self):
+            '''An accessor function that returns a list() that contains all locations in a lldb.SBBreakpoint object.'''
+            locations = []
+            accessor = self.get_locations_access_object()
+            for idx in range(len(accessor)):
+                locations.append(accessor[idx])
+            return locations
+
+        def __iter__(self):
+            '''Iterate over all breakpoint locations in a lldb.SBBreakpoint
+            object.'''
+            return lldb_iter(self, 'GetNumLocations', 'GetLocationAtIndex')
+
+        def __len__(self):
+            '''Return the number of breakpoint locations in a lldb.SBBreakpoint
+            object.'''
+            return self.GetNumLocations()
+
+        locations = property(get_breakpoint_location_list, None, doc='''A read only property that returns a list() of lldb.SBBreakpointLocation objects for this breakpoint.''')
+        location = property(get_locations_access_object, None, doc='''A read only property that returns an object that can access locations by index (not location ID) (location = bkpt.location[12]).''')
+        id = property(GetID, None, doc='''A read only property that returns the ID of this breakpoint.''')
+        enabled = property(IsEnabled, SetEnabled, doc='''A read/write property that configures whether this breakpoint is enabled or not.''')
+        one_shot = property(IsOneShot, SetOneShot, doc='''A read/write property that configures whether this breakpoint is one-shot (deleted when hit) or not.''')
+        num_locations = property(GetNumLocations, None, doc='''A read only property that returns the count of locations of this breakpoint.''')
+    %}
+#endif
+}

lldb/bindings/interface/SBBreakpointLocation.i

-//===-- SWIG Interface for SBBreakpointLocation -----------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-%feature("docstring",
-"Represents one unique instance (by address) of a logical breakpoint.
-
-A breakpoint location is defined by the breakpoint that produces it,
-and the address that resulted in this particular instantiation.
-Each breakpoint location has its settable options.
-
-:py:class:`SBBreakpoint` contains SBBreakpointLocation(s). See docstring of SBBreakpoint
-for retrieval of an SBBreakpointLocation from an SBBreakpoint."
-) SBBreakpointLocation;
-class SBBreakpointLocation
-{
-public:
-
-    SBBreakpointLocation ();
-
-    SBBreakpointLocation (const lldb::SBBreakpointLocation &rhs);
-
-    ~SBBreakpointLocation ();
-
-    break_id_t
-    GetID ();
-
-    bool
-    IsValid() const;
-
-    explicit operator bool() const;
-
-    lldb::SBAddress
-    GetAddress();
-
-    lldb::addr_t
-    GetLoadAddress ();
-
-    void
-    SetEnabled(bool enabled);
-
-    bool
-    IsEnabled ();
-
-    uint32_t
-    GetHitCount ();
-
-    uint32_t
-    GetIgnoreCount ();
-
-    void
-    SetIgnoreCount (uint32_t n);
-
-    %feature("docstring", "
-    The breakpoint location stops only if the condition expression evaluates
-    to true.") SetCondition;
-    void
-    SetCondition (const char *condition);
-
-    %feature("docstring", "
-    Get the condition expression for the breakpoint location.") GetCondition;
-    const char *
-    GetCondition ();
-
-    bool GetAutoContinue();
-
-    void SetAutoContinue(bool auto_continue);
-
-    %feature("docstring", "
-    Set the callback to the given Python function name.
-    The function takes three arguments (frame, bp_loc, internal_dict).") SetScriptCallbackFunction;
-    void
-    SetScriptCallbackFunction (const char *callback_function_name);
-
-    %feature("docstring", "
-    Set the name of the script function to be called when the breakpoint is hit.
-    To use this variant, the function should take (frame, bp_loc, extra_args, internal_dict) and
-    when the breakpoint is hit the extra_args will be passed to the callback function.") SetScriptCallbackFunction;
-    SBError
-    SetScriptCallbackFunction (const char *callback_function_name,
-                               SBStructuredData &extra_args);
-
-    %feature("docstring", "
-    Provide the body for the script function to be called when the breakpoint location is hit.
-    The body will be wrapped in a function, which be passed two arguments:
-    'frame' - which holds the bottom-most SBFrame of the thread that hit the breakpoint
-    'bpno'  - which is the SBBreakpointLocation to which the callback was attached.
-
-    The error parameter is currently ignored, but will at some point hold the Python
-    compilation diagnostics.
-    Returns true if the body compiles successfully, false if not.") SetScriptCallbackBody;
-    SBError
-    SetScriptCallbackBody (const char *script_body_text);
-
-    void SetCommandLineCommands(SBStringList &commands);
-
-    bool GetCommandLineCommands(SBStringList &commands);
-
-    void
-    SetThreadID (lldb::tid_t sb_thread_id);
-
-    lldb::tid_t
-    GetThreadID ();
-
-    void
-    SetThreadIndex (uint32_t index);
-
-    uint32_t
-    GetThreadIndex() const;
-
-    void
-    SetThreadName (const char *thread_name);
-
-    const char *
-    GetThreadName () const;
-
-    void
-    SetQueueName (const char *queue_name);
-
-    const char *
-    GetQueueName () const;
-
-    bool
-    IsResolved ();
-
-    bool
-    GetDescription (lldb::SBStream &description, DescriptionLevel level);
-
-    SBBreakpoint
-    GetBreakpoint ();
-
-    STRING_EXTENSION_LEVEL(SBBreakpointLocation, lldb::eDescriptionLevelFull)
-};
-
-} // namespace lldb

lldb/bindings/interface/SBBreakpointLocationDocstrings.i

+%feature("docstring",
+"Represents one unique instance (by address) of a logical breakpoint.
+
+A breakpoint location is defined by the breakpoint that produces it,
+and the address that resulted in this particular instantiation.
+Each breakpoint location has its settable options.
+
+:py:class:`SBBreakpoint` contains SBBreakpointLocation(s). See docstring of SBBreakpoint
+for retrieval of an SBBreakpointLocation from an SBBreakpoint."
+) lldb::SBBreakpointLocation;
+
+%feature("docstring", "
+    The breakpoint location stops only if the condition expression evaluates
+    to true.") lldb::SBBreakpointLocation::SetCondition;
+
+%feature("docstring", "
+    Get the condition expression for the breakpoint location."
+) lldb::SBBreakpointLocation::GetCondition;
+
+%feature("docstring", "
+    Set the callback to the given Python function name.
+    The function takes three arguments (frame, bp_loc, internal_dict)."
+) lldb::SBBreakpointLocation::SetScriptCallbackFunction;
+
+%feature("docstring", "
+    Set the name of the script function to be called when the breakpoint is hit.
+    To use this variant, the function should take (frame, bp_loc, extra_args, internal_dict) and
+    when the breakpoint is hit the extra_args will be passed to the callback function."
+) lldb::SBBreakpointLocation::SetScriptCallbackFunction;
+
+%feature("docstring", "
+    Provide the body for the script function to be called when the breakpoint location is hit.
+    The body will be wrapped in a function, which be passed two arguments:
+    'frame' - which holds the bottom-most SBFrame of the thread that hit the breakpoint
+    'bpno'  - which is the SBBreakpointLocation to which the callback was attached.
+
+    The error parameter is currently ignored, but will at some point hold the Python
+    compilation diagnostics.
+    Returns true if the body compiles successfully, false if not."
+) lldb::SBBreakpointLocation::SetScriptCallbackBody;

lldb/bindings/interface/SBBreakpointLocationExtensions.i

+STRING_EXTENSION_LEVEL_OUTSIDE(SBBreakpointLocation, lldb::eDescriptionLevelFull)

lldb/bindings/interface/SBBreakpointName.i

-//===-- SWIG interface for SBBreakpointName.h -------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-%feature("docstring",
-"Represents a breakpoint name registered in a given :py:class:`SBTarget`.
-
-Breakpoint names provide a way to act on groups of breakpoints.  When you add a
-name to a group of breakpoints, you can then use the name in all the command
-line lldb commands for that name.  You can also configure the SBBreakpointName
-options and those options will be propagated to any :py:class:`SBBreakpoint` s currently
-using that name.  Adding a name to a breakpoint will also apply any of the
-set options to that breakpoint.
-
-You can also set permissions on a breakpoint name to disable listing, deleting
-and disabling breakpoints.  That will disallow the given operation for breakpoints
-except when the breakpoint is mentioned by ID.  So for instance deleting all the
-breakpoints won't delete breakpoints so marked."
-) SBBreakpointName;
-class LLDB_API SBBreakpointName {
-public:
-  SBBreakpointName();
-
-  SBBreakpointName(SBTarget &target, const char *name);
-
-  SBBreakpointName(SBBreakpoint &bkpt, const char *name);
-
-  SBBreakpointName(const lldb::SBBreakpointName &rhs);
-
-  ~SBBreakpointName();
-
-  // Tests to see if the opaque breakpoint object in this object matches the
-  // opaque breakpoint object in "rhs".
-  bool operator==(const lldb::SBBreakpointName &rhs);
-
-  bool operator!=(const lldb::SBBreakpointName &rhs);
-
-  explicit operator bool() const;
-
-  bool IsValid() const;
-
-  const char *GetName() const;
-
-  void SetEnabled(bool enable);
-
-  bool IsEnabled();
-
-  void SetOneShot(bool one_shot);
-
-  bool IsOneShot() const;
-
-  void SetIgnoreCount(uint32_t count);
-
-  uint32_t GetIgnoreCount() const;
-
-  void SetCondition(const char *condition);
-
-  const char *GetCondition();
-
-  void SetAutoContinue(bool auto_continue);
-
-  bool GetAutoContinue();
-
-  void SetThreadID(lldb::tid_t sb_thread_id);
-
-  lldb::tid_t GetThreadID();
-
-  void SetThreadIndex(uint32_t index);
-
-  uint32_t GetThreadIndex() const;
-
-  void SetThreadName(const char *thread_name);
-
-  const char *GetThreadName() const;
-
-  void SetQueueName(const char *queue_name);
-
-  const char *GetQueueName() const;
-
-  void SetScriptCallbackFunction(const char *callback_function_name);
-
-  SBError
-  SetScriptCallbackFunction (const char *callback_function_name,
-                             SBStructuredData &extra_args);
-
-  void SetCommandLineCommands(SBStringList &commands);
-
-  bool GetCommandLineCommands(SBStringList &commands);
-
-  SBError SetScriptCallbackBody(const char *script_body_text);
-
-  const char *GetHelpString() const;
-  void SetHelpString(const char *help_string);
-
-  bool GetAllowList() const;
-  void SetAllowList(bool value);
-
-  bool GetAllowDelete();
-  void SetAllowDelete(bool value);
-
-  bool GetAllowDisable();
-  void SetAllowDisable(bool value);
-
-  bool GetDescription(lldb::SBStream &description);
-
-  STRING_EXTENSION(SBBreakpointName)
-};
-
-} // namespace lldb
-

lldb/bindings/interface/SBBreakpointNameDocstrings.i

+%feature("docstring",
+"Represents a breakpoint name registered in a given :py:class:`SBTarget`.
+
+Breakpoint names provide a way to act on groups of breakpoints.  When you add a
+name to a group of breakpoints, you can then use the name in all the command
+line lldb commands for that name.  You can also configure the SBBreakpointName
+options and those options will be propagated to any :py:class:`SBBreakpoint` s currently
+using that name.  Adding a name to a breakpoint will also apply any of the
+set options to that breakpoint.
+
+You can also set permissions on a breakpoint name to disable listing, deleting
+and disabling breakpoints.  That will disallow the given operation for breakpoints
+except when the breakpoint is mentioned by ID.  So for instance deleting all the
+breakpoints won't delete breakpoints so marked."
+) lldb::SBBreakpointName;

lldb/bindings/interface/SBBreakpointNameExtensions.i

+STRING_EXTENSION_OUTSIDE(SBBreakpointName)

lldb/bindings/interface/SBBroadcaster.i

-//===-- SWIG Interface for SBBroadcaster ------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-%feature("docstring",
-"Represents an entity which can broadcast events.
-
-A default broadcaster is
-associated with an SBCommandInterpreter, SBProcess, and SBTarget.  For
-example, use ::
-
-    broadcaster = process.GetBroadcaster()
-
-to retrieve the process's broadcaster.
-
-See also SBEvent for example usage of interacting with a broadcaster."
-) SBBroadcaster;
-class SBBroadcaster
-{
-public:
-    SBBroadcaster ();
-
-    SBBroadcaster (const char *name);
-
-    SBBroadcaster (const SBBroadcaster &rhs);
-
-    ~SBBroadcaster();
-
-    bool
-    IsValid () const;
-
-    explicit operator bool() const;
-
-    void
-    Clear ();
-
-    void
-    BroadcastEventByType (uint32_t event_type, bool unique = false);
-
-    void
-    BroadcastEvent (const lldb::SBEvent &event, bool unique = false);
-
-    void
-    AddInitialEventsToListener (const lldb::SBListener &listener, uint32_t requested_events);
-
-    uint32_t
-    AddListener (const lldb::SBListener &listener, uint32_t event_mask);
-
-    const char *
-    GetName () const;
-
-    bool
-    EventTypeHasListeners (uint32_t event_type);
-
-    bool
-    RemoveListener (const lldb::SBListener &listener, uint32_t event_mask = UINT32_MAX);
-
-    bool
-    operator == (const lldb::SBBroadcaster &rhs) const;
-
-    bool
-    operator != (const lldb::SBBroadcaster &rhs) const;
-};
-
-} // namespace lldb

lldb/bindings/interface/SBBroadcasterDocstrings.i

+%feature("docstring",
+"Represents an entity which can broadcast events.
+
+A default broadcaster is
+associated with an SBCommandInterpreter, SBProcess, and SBTarget.  For
+example, use ::
+
+    broadcaster = process.GetBroadcaster()
+
+to retrieve the process's broadcaster.
+
+See also SBEvent for example usage of interacting with a broadcaster."
+) lldb::SBBroadcaster;

lldb/bindings/interface/SBCommandInterpreter.i

-//===-- SWIG Interface for SBCommandInterpreter -----------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-%feature("docstring",
-"SBCommandInterpreter handles/interprets commands for lldb.
-
-You get the command interpreter from the :py:class:`SBDebugger` instance.
-
-For example (from test/ python_api/interpreter/TestCommandInterpreterAPI.py),::
-
-    def command_interpreter_api(self):
-        '''Test the SBCommandInterpreter APIs.'''
-        exe = os.path.join(os.getcwd(), 'a.out')
-
-        # Create a target by the debugger.
-        target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target, VALID_TARGET)
-
-        # Retrieve the associated command interpreter from our debugger.
-        ci = self.dbg.GetCommandInterpreter()
-        self.assertTrue(ci, VALID_COMMAND_INTERPRETER)
-
-        # Exercise some APIs....
-
-        self.assertTrue(ci.HasCommands())
-        self.assertTrue(ci.HasAliases())
-        self.assertTrue(ci.HasAliasOptions())
-        self.assertTrue(ci.CommandExists('breakpoint'))
-        self.assertTrue(ci.CommandExists('target'))
-        self.assertTrue(ci.CommandExists('platform'))
-        self.assertTrue(ci.AliasExists('file'))
-        self.assertTrue(ci.AliasExists('run'))
-        self.assertTrue(ci.AliasExists('bt'))
-
-        res = lldb.SBCommandReturnObject()
-        ci.HandleCommand('breakpoint set -f main.c -l %d' % self.line, res)
-        self.assertTrue(res.Succeeded())
-        ci.HandleCommand('process launch', res)
-        self.assertTrue(res.Succeeded())
-
-        process = ci.GetProcess()
-        self.assertTrue(process)
-
-        ...
-
-The HandleCommand() instance method takes two args: the command string and
-an SBCommandReturnObject instance which encapsulates the result of command
-execution.") SBCommandInterpreter;
-class SBCommandInterpreter
-{
-public:
-    enum
-    {
-        eBroadcastBitThreadShouldExit       = (1 << 0),
-        eBroadcastBitResetPrompt            = (1 << 1),
-        eBroadcastBitQuitCommandReceived    = (1 << 2),           // User entered quit
-        eBroadcastBitAsynchronousOutputData = (1 << 3),
-        eBroadcastBitAsynchronousErrorData  = (1 << 4)
-    };
-
-    SBCommandInterpreter (const lldb::SBCommandInterpreter &rhs);
-
-    ~SBCommandInterpreter ();
-
-    static const char *
-    GetArgumentTypeAsCString (const lldb::CommandArgumentType arg_type);
-
-    static const char *
-    GetArgumentDescriptionAsCString (const lldb::CommandArgumentType arg_type);
-
-    static bool
-    EventIsCommandInterpreterEvent (const lldb::SBEvent &event);
-
-    bool
-    IsValid() const;
-
-    explicit operator bool() const;
-
-    const char *
-    GetIOHandlerControlSequence(char ch);
-
-    bool
-    GetPromptOnQuit();
-
-    void
-    SetPromptOnQuit(bool b);
-
-    void
-    AllowExitCodeOnQuit(bool b);
-
-    bool
-    HasCustomQuitExitCode();
-
-    int
-    GetQuitStatus();
-
-    void
-    ResolveCommand(const char *command_line, SBCommandReturnObject &result);
-
-    bool
-    CommandExists (const char *cmd);
-
-    bool
-    AliasExists (const char *cmd);
-
-    lldb::SBBroadcaster
-    GetBroadcaster ();
-
-    static const char *
-    GetBroadcasterClass ();
-
-    bool
-    HasCommands ();
-
-    bool
-    HasAliases ();
-
-    bool
-    HasAliasOptions ();
-
-    bool
-    IsInteractive ();
-
-    lldb::SBProcess
-    GetProcess ();
-
-    lldb::SBDebugger
-    GetDebugger ();
-
-    void
-    SourceInitFileInHomeDirectory (lldb::SBCommandReturnObject &result);
-
-    void
-    SourceInitFileInCurrentWorkingDirectory (lldb::SBCommandReturnObject &result);
-
-    lldb::ReturnStatus
-    HandleCommand (const char *command_line, lldb::SBCommandReturnObject &result, bool add_to_history = false);
-
-    lldb::ReturnStatus
-    HandleCommand (const char *command_line, SBExecutionContext &exe_ctx, SBCommandReturnObject &result, bool add_to_history = false);
-
-    void
-    HandleCommandsFromFile (lldb::SBFileSpec &file,
-                            lldb::SBExecutionContext &override_context,
-                            lldb::SBCommandInterpreterRunOptions &options,
-                            lldb::SBCommandReturnObject result);
-
-    int
-    HandleCompletion (const char *current_line,
-                      uint32_t cursor_pos,
-                      int match_start_point,
-                      int max_return_elements,
-                      lldb::SBStringList &matches);
-
-    int
-    HandleCompletionWithDescriptions (const char *current_line,
-                                      uint32_t cursor_pos,
-                                      int match_start_point,
-                                      int max_return_elements,
-                                      lldb::SBStringList &matches,
-                                      lldb::SBStringList &descriptions);
-    bool
-    IsActive ();
-
-    bool
-    WasInterrupted () const;
-};
-
-} // namespace lldb

lldb/bindings/interface/SBCommandInterpreterDocstrings.i

+%feature("docstring",
+"SBCommandInterpreter handles/interprets commands for lldb.
+
+You get the command interpreter from the :py:class:`SBDebugger` instance.
+
+For example (from test/ python_api/interpreter/TestCommandInterpreterAPI.py),::
+
+    def command_interpreter_api(self):
+        '''Test the SBCommandInterpreter APIs.'''
+        exe = os.path.join(os.getcwd(), 'a.out')
+
+        # Create a target by the debugger.
+        target = self.dbg.CreateTarget(exe)
+        self.assertTrue(target, VALID_TARGET)
+
+        # Retrieve the associated command interpreter from our debugger.
+        ci = self.dbg.GetCommandInterpreter()
+        self.assertTrue(ci, VALID_COMMAND_INTERPRETER)
+
+        # Exercise some APIs....
+
+        self.assertTrue(ci.HasCommands())
+        self.assertTrue(ci.HasAliases())
+        self.assertTrue(ci.HasAliasOptions())
+        self.assertTrue(ci.CommandExists('breakpoint'))
+        self.assertTrue(ci.CommandExists('target'))
+        self.assertTrue(ci.CommandExists('platform'))
+        self.assertTrue(ci.AliasExists('file'))
+        self.assertTrue(ci.AliasExists('run'))
+        self.assertTrue(ci.AliasExists('bt'))
+
+        res = lldb.SBCommandReturnObject()
+        ci.HandleCommand('breakpoint set -f main.c -l %d' % self.line, res)
+        self.assertTrue(res.Succeeded())
+        ci.HandleCommand('process launch', res)
+        self.assertTrue(res.Succeeded())
+
+        process = ci.GetProcess()
+        self.assertTrue(process)
+
+        ...
+
+The HandleCommand() instance method takes two args: the command string and
+an SBCommandReturnObject instance which encapsulates the result of command
+execution.") lldb::SBCommandInterpreter;

lldb/bindings/interface/SBCommandInterpreterRunOptions.i

-//===-- SWIG Interface for SBCommandInterpreter -----------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-%feature("docstring",
-"SBCommandInterpreterRunOptions controls how the RunCommandInterpreter runs the code it is fed.
-
-A default SBCommandInterpreterRunOptions object has:
-
-* StopOnContinue: false
-* StopOnError:    false
-* StopOnCrash:    false
-* EchoCommands:   true
-* PrintResults:   true
-* PrintErrors:    true
-* AddToHistory:   true
-
-") SBCommandInterpreterRunOptions;
-class SBCommandInterpreterRunOptions
-{
-friend class SBDebugger;
-public:
-    SBCommandInterpreterRunOptions();
-    ~SBCommandInterpreterRunOptions();
-
-    bool
-    GetStopOnContinue () const;
-
-    void
-    SetStopOnContinue (bool);
-
-    bool
-    GetStopOnError () const;
-
-    void
-    SetStopOnError (bool);
-
-    bool
-    GetStopOnCrash () const;
-
-    void
-    SetStopOnCrash (bool);
-
-    bool
-    GetEchoCommands () const;
-
-    void
-    SetEchoCommands (bool);
-
-    bool
-    GetPrintResults () const;
-
-    void
-    SetPrintResults (bool);
-
-    bool
-    GetPrintErrors () const;
-
-    void
-    SetPrintErrors (bool);
-
-    bool
-    GetAddToHistory () const;
-
-    void
-    SetAddToHistory (bool);
-private:
-    lldb_private::CommandInterpreterRunOptions *
-    get () const;
-
-    lldb_private::CommandInterpreterRunOptions &
-    ref () const;
-
-    // This is set in the constructor and will always be valid.
-    mutable std::unique_ptr<lldb_private::CommandInterpreterRunOptions> m_opaque_up;
-};
-
-} // namespace lldb

lldb/bindings/interface/SBCommandInterpreterRunOptionsDocstrings.i

+%feature("docstring",
+"SBCommandInterpreterRunOptions controls how the RunCommandInterpreter runs the code it is fed.
+
+A default SBCommandInterpreterRunOptions object has:
+
+* StopOnContinue: false
+* StopOnError:    false
+* StopOnCrash:    false
+* EchoCommands:   true
+* PrintResults:   true
+* PrintErrors:    true
+* AddToHistory:   true
+
+") lldb::SBCommandInterpreterRunOptions;

lldb/bindings/interface/SBCommandReturnObject.i

-//===-- SWIG Interface for SBCommandReturnObject ----------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-%feature("docstring",
-"Represents a container which holds the result from command execution.
-It works with :py:class:`SBCommandInterpreter.HandleCommand()` to encapsulate the result
-of command execution.
-
-See :py:class:`SBCommandInterpreter` for example usage of SBCommandReturnObject."
-) SBCommandReturnObject;
-class SBCommandReturnObject
-{
-public:
-
-    SBCommandReturnObject ();
-
-    SBCommandReturnObject (const lldb::SBCommandReturnObject &rhs);
-
-    ~SBCommandReturnObject ();
-
-    bool
-    IsValid() const;
-
-    explicit operator bool() const;
-
-    const char *
-    GetOutput ();
-
-    const char *
-    GetError ();
-
-    size_t
-    GetOutputSize ();
-
-    size_t
-    GetErrorSize ();
-
-    const char *
-    GetOutput (bool only_if_no_immediate);
-
-    const char *
-    GetError (bool if_no_immediate);
-
-    size_t
-    PutOutput (lldb::SBFile file);
-
-    size_t
-    PutError (lldb::SBFile file);
-
-    size_t
-    PutOutput (lldb::FileSP BORROWED);
-
-    size_t
-    PutError (lldb::FileSP BORROWED);
-
-    void
-    Clear();
-
-    void
-    SetStatus (lldb::ReturnStatus status);
-
-    void
-    SetError (lldb::SBError &error,
-              const char *fallback_error_cstr = NULL);
-
-    void
-    SetError (const char *error_cstr);
-
-    lldb::ReturnStatus
-    GetStatus();
-
-    bool
-    Succeeded ();
-
-    bool
-    HasResult ();
-
-    void
-    AppendMessage (const char *message);
-
-    void
-    AppendWarning (const char *message);
-
-    bool
-    GetDescription (lldb::SBStream &description);
-
-    void SetImmediateOutputFile(lldb::SBFile file);
-    void SetImmediateErrorFile(lldb::SBFile file);
-    void SetImmediateOutputFile(lldb::FileSP BORROWED);
-    void SetImmediateErrorFile(lldb::FileSP BORROWED);
-
-    STRING_EXTENSION(SBCommandReturnObject)
-
-    %extend {
-        // transfer_ownership does nothing, and is here for compatibility with
-        // old scripts.  Ownership is tracked by reference count in the ordinary way.
-
-        void SetImmediateOutputFile(lldb::FileSP BORROWED, bool transfer_ownership) {
-            self->SetImmediateOutputFile(BORROWED);
-        }
-        void SetImmediateErrorFile(lldb::FileSP BORROWED, bool transfer_ownership) {
-            self->SetImmediateErrorFile(BORROWED);
-        }
-    }
-
-  void
-  PutCString(const char* string, int len);
-
-    // wrapping the variadic Printf() with a plain Print()
-    // because it is hard to support varargs in SWIG bridgings
-    %extend {
-        void Print (const char* str)
-        {
-            self->Printf("%s", str);
-        }
-    }
-
-};
-
-} // namespace lldb

lldb/bindings/interface/SBCommandReturnObjectDocstrings.i

+%feature("docstring",
+"Represents a container which holds the result from command execution.
+It works with :py:class:`SBCommandInterpreter.HandleCommand()` to encapsulate the result
+of command execution.
+
+See :py:class:`SBCommandInterpreter` for example usage of SBCommandReturnObject."
+) lldb::SBCommandReturnObject;

lldb/bindings/interface/SBCommandReturnObjectExtensions.i

+STRING_EXTENSION_OUTSIDE(SBCommandReturnObject)
+
+%extend lldb::SBCommandReturnObject {
+    // transfer_ownership does nothing, and is here for compatibility with
+    // old scripts.  Ownership is tracked by reference count in the ordinary way.
+
+    void SetImmediateOutputFile(lldb::FileSP BORROWED, bool transfer_ownership) {
+        self->SetImmediateOutputFile(BORROWED);
+    }
+    void SetImmediateErrorFile(lldb::FileSP BORROWED, bool transfer_ownership) {
+        self->SetImmediateErrorFile(BORROWED);
+    }
+
+    // wrapping the variadic Printf() with a plain Print()
+    // because it is hard to support varargs in SWIG bridgings
+    void Print (const char* str)
+    {
+        self->Printf("%s", str);
+    }
+}

lldb/bindings/interface/SBCommunication.i

-//===-- SWIG Interface for SBCommunication ----------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-%feature("docstring",
-"Allows sending/receiving data."
-) SBCommunication;
-class SBCommunication
-{
-public:
-    enum {
-        eBroadcastBitDisconnected           = (1 << 0), ///< Sent when the communications connection is lost.
-        eBroadcastBitReadThreadGotBytes     = (1 << 1), ///< Sent by the read thread when bytes become available.
-        eBroadcastBitReadThreadDidExit      = (1 << 2), ///< Sent by the read thread when it exits to inform clients.
-        eBroadcastBitReadThreadShouldExit   = (1 << 3), ///< Sent by clients that need to cancel the read thread.
-        eBroadcastBitPacketAvailable        = (1 << 4), ///< Sent when data received makes a complete packet.
-        eAllEventBits                       = 0xffffffff
-    };
-
-    typedef void (*ReadThreadBytesReceived) (void *baton, const void *src, size_t src_len);
-
-    SBCommunication ();
-    SBCommunication (const char * broadcaster_name);
-   ~SBCommunication ();
-
-
-    bool
-    IsValid () const;
-
-    explicit operator bool() const;
-
-    lldb::SBBroadcaster
-    GetBroadcaster ();
-
-    static const char *GetBroadcasterClass();
-
-    lldb::ConnectionStatus
-    AdoptFileDesriptor (int fd, bool owns_fd);
-
-    lldb::ConnectionStatus
-    Connect (const char *url);
-
-    lldb::ConnectionStatus
-    Disconnect ();
-
-    bool
-    IsConnected () const;
-
-    bool
-    GetCloseOnEOF ();
-
-    void
-    SetCloseOnEOF (bool b);
-
-    size_t
-    Read (void *dst,
-          size_t dst_len,
-          uint32_t timeout_usec,
-          lldb::ConnectionStatus &status);
-
-    size_t
-    Write (const void *src,
-           size_t src_len,
-           lldb::ConnectionStatus &status);
-
-    bool
-    ReadThreadStart ();
-
-    bool
-    ReadThreadStop ();
-
-    bool
-    ReadThreadIsRunning ();
-
-    bool
-    SetReadThreadBytesReceivedCallback (ReadThreadBytesReceived callback,
-                                        void *callback_baton);
-};
-
-} // namespace lldb

lldb/bindings/interface/SBCommunicationDocstrings.i

+%feature("docstring",
+"Allows sending/receiving data."
+) lldb::SBCommunication;

lldb/bindings/interface/SBCompileUnit.i

-//===-- SWIG Interface for SBCompileUnit ------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-%feature("docstring",
-"Represents a compilation unit, or compiled source file.
-
-SBCompileUnit supports line entry iteration. For example,::
-
-    # Now get the SBSymbolContext from this frame.  We want everything. :-)
-    context = frame0.GetSymbolContext(lldb.eSymbolContextEverything)
-    ...
-
-    compileUnit = context.GetCompileUnit()
-
-    for lineEntry in compileUnit:
-        print('line entry: %s:%d' % (str(lineEntry.GetFileSpec()),
-                                    lineEntry.GetLine()))
-        print('start addr: %s' % str(lineEntry.GetStartAddress()))
-        print('end   addr: %s' % str(lineEntry.GetEndAddress()))
-
-produces: ::
-
-  line entry: /Volumes/data/lldb/svn/trunk/test/python_api/symbol-context/main.c:20
-  start addr: a.out[0x100000d98]
-  end   addr: a.out[0x100000da3]
-  line entry: /Volumes/data/lldb/svn/trunk/test/python_api/symbol-context/main.c:21
-  start addr: a.out[0x100000da3]
-  end   addr: a.out[0x100000da9]
-  line entry: /Volumes/data/lldb/svn/trunk/test/python_api/symbol-context/main.c:22
-  start addr: a.out[0x100000da9]
-  end   addr: a.out[0x100000db6]
-  line entry: /Volumes/data/lldb/svn/trunk/test/python_api/symbol-context/main.c:23
-  start addr: a.out[0x100000db6]
-  end   addr: a.out[0x100000dbc]
-  ...
-
-See also :py:class:`SBSymbolContext` and :py:class:`SBLineEntry`"
-) SBCompileUnit;
-class SBCompileUnit
-{
-public:
-
-    SBCompileUnit ();
-
-    SBCompileUnit (const lldb::SBCompileUnit &rhs);
-
-    ~SBCompileUnit ();
-
-    bool
-    IsValid () const;
-
-    explicit operator bool() const;
-
-    lldb::SBFileSpec
-    GetFileSpec () const;
-
-    uint32_t
-    GetNumLineEntries () const;
-
-    lldb::SBLineEntry
-    GetLineEntryAtIndex (uint32_t idx) const;
-
-    %feature("docstring", "
-     Get the index for a provided line entry in this compile unit.
-
-     @param[in] line_entry
-        The SBLineEntry object for which we are looking for the index.
-
-     @param[in] exact
-        An optional boolean defaulting to false that ensures that the provided
-        line entry has a perfect match in the compile unit.
-
-     @return
-        The index of the user-provided line entry. UINT32_MAX if the line entry
-        was not found in the compile unit.") FindLineEntryIndex;
-    uint32_t
-    FindLineEntryIndex (lldb::SBLineEntry &line_entry, bool exact = false) const;
-
-    uint32_t
-    FindLineEntryIndex (uint32_t start_idx,
-                        uint32_t line,
-                        lldb::SBFileSpec *inline_file_spec) const;
-
-    uint32_t
-    FindLineEntryIndex (uint32_t start_idx,
-                        uint32_t line,
-                        lldb::SBFileSpec *inline_file_spec,
-      bool exact) const;
-
-    SBFileSpec
-    GetSupportFileAtIndex (uint32_t idx) const;
-
-    uint32_t
-    GetNumSupportFiles () const;
-
-    uint32_t
-    FindSupportFileIndex (uint32_t start_idx, const SBFileSpec &sb_file, bool full);
-
-    %feature("docstring", "
-     Get all types matching type_mask from debug info in this
-     compile unit.
-
-     @param[in] type_mask
-        A bitfield that consists of one or more bits logically OR'ed
-        together from the lldb::TypeClass enumeration. This allows
-        you to request only structure types, or only class, struct
-        and union types. Passing in lldb::eTypeClassAny will return
-        all types found in the debug information for this compile
-        unit.
-
-     @return
-        A list of types in this compile unit that match type_mask") GetTypes;
-    lldb::SBTypeList
-    GetTypes (uint32_t type_mask = lldb::eTypeClassAny);
-
-     lldb::LanguageType
-     GetLanguage ();
-
-    bool
-    GetDescription (lldb::SBStream &description);
-
-    bool
-    operator == (const lldb::SBCompileUnit &rhs) const;
-
-    bool
-    operator != (const lldb::SBCompileUnit &rhs) const;
-
-    STRING_EXTENSION(SBCompileUnit)
-
-#ifdef SWIGPYTHON
-    %pythoncode %{
-        def __iter__(self):
-            '''Iterate over all line entries in a lldb.SBCompileUnit object.'''
-            return lldb_iter(self, 'GetNumLineEntries', 'GetLineEntryAtIndex')
-
-        def __len__(self):
-            '''Return the number of line entries in a lldb.SBCompileUnit
-            object.'''
-            return self.GetNumLineEntries()
-
-        file = property(GetFileSpec, None, doc='''A read only property that returns the same result an lldb object that represents the source file (lldb.SBFileSpec) for the compile unit.''')
-        num_line_entries = property(GetNumLineEntries, None, doc='''A read only property that returns the number of line entries in a compile unit as an integer.''')
-    %}
-#endif
-};
-
-} // namespace lldb

lldb/bindings/interface/SBCompileUnitDocstrings.i

+%feature("docstring",
+"Represents a compilation unit, or compiled source file.
+
+SBCompileUnit supports line entry iteration. For example,::
+
+    # Now get the SBSymbolContext from this frame.  We want everything. :-)
+    context = frame0.GetSymbolContext(lldb.eSymbolContextEverything)
+    ...
+
+    compileUnit = context.GetCompileUnit()
+
+    for lineEntry in compileUnit:
+        print('line entry: %s:%d' % (str(lineEntry.GetFileSpec()),
+                                    lineEntry.GetLine()))
+        print('start addr: %s' % str(lineEntry.GetStartAddress()))
+        print('end   addr: %s' % str(lineEntry.GetEndAddress()))
+
+produces: ::
+
+  line entry: /Volumes/data/lldb/svn/trunk/test/python_api/symbol-context/main.c:20
+  start addr: a.out[0x100000d98]
+  end   addr: a.out[0x100000da3]
+  line entry: /Volumes/data/lldb/svn/trunk/test/python_api/symbol-context/main.c:21
+  start addr: a.out[0x100000da3]
+  end   addr: a.out[0x100000da9]
+  line entry: /Volumes/data/lldb/svn/trunk/test/python_api/symbol-context/main.c:22
+  start addr: a.out[0x100000da9]
+  end   addr: a.out[0x100000db6]
+  line entry: /Volumes/data/lldb/svn/trunk/test/python_api/symbol-context/main.c:23
+  start addr: a.out[0x100000db6]
+  end   addr: a.out[0x100000dbc]
+  ...
+
+See also :py:class:`SBSymbolContext` and :py:class:`SBLineEntry`"
+) lldb::SBCompileUnit;
+
+%feature("docstring", "
+     Get the index for a provided line entry in this compile unit.
+
+     @param[in] line_entry
+        The SBLineEntry object for which we are looking for the index.
+
+     @param[in] exact
+        An optional boolean defaulting to false that ensures that the provided
+        line entry has a perfect match in the compile unit.
+
+     @return
+        The index of the user-provided line entry. UINT32_MAX if the line entry
+        was not found in the compile unit.") lldb::SBCompileUnit::FindLineEntryIndex;
+
+%feature("docstring", "
+     Get all types matching type_mask from debug info in this
+     compile unit.
+
+     @param[in] type_mask
+        A bitfield that consists of one or more bits logically OR'ed
+        together from the lldb::TypeClass enumeration. This allows
+        you to request only structure types, or only class, struct
+        and union types. Passing in lldb::eTypeClassAny will return
+        all types found in the debug information for this compile
+        unit.
+
+     @return
+        A list of types in this compile unit that match type_mask"
+) lldb::SBCompileUnit::GetTypes;

lldb/bindings/interface/SBCompileUnitExtensions.i

+STRING_EXTENSION_OUTSIDE(SBCompileUnit)
+
+%extend lldb::SBCompileUnit {
+#ifdef SWIGPYTHON
+    %pythoncode %{
+        def __iter__(self):
+            '''Iterate over all line entries in a lldb.SBCompileUnit object.'''
+            return lldb_iter(self, 'GetNumLineEntries', 'GetLineEntryAtIndex')
+
+        def __len__(self):
+            '''Return the number of line entries in a lldb.SBCompileUnit
+            object.'''
+            return self.GetNumLineEntries()
+
+        file = property(GetFileSpec, None, doc='''A read only property that returns the same result an lldb object that represents the source file (lldb.SBFileSpec) for the compile unit.''')
+        num_line_entries = property(GetNumLineEntries, None, doc='''A read only property that returns the number of line entries in a compile unit as an integer.''')
+    %}
+#endif
+}

lldb/bindings/interface/SBDataDocstrings.i

+%feature("docstring",
+"Represents a data buffer."
+) lldb::SBData;

lldb/bindings/interface/SBDataExtensions.i

-//===-- SWIG Interface for SBData -------------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-
-namespace lldb {
-
-%feature("docstring",
-"Represents a data buffer."
-) SBData;
-class SBData
-{
-public:
-
-    SBData ();
-
-    SBData (const SBData &rhs);
-
-    ~SBData ();
-
-    uint8_t
-    GetAddressByteSize ();
-
-    void
-    SetAddressByteSize (uint8_t addr_byte_size);
-
-    void
-    Clear ();
-
-    bool
-    IsValid();
-
-    explicit operator bool() const;
-
-    size_t
-    GetByteSize ();
-
-    lldb::ByteOrder
-    GetByteOrder();
-
-    void
-    SetByteOrder (lldb::ByteOrder endian);
-
-    float
-    GetFloat (lldb::SBError& error, lldb::offset_t offset);
-
-    double
-    GetDouble (lldb::SBError& error, lldb::offset_t offset);
-
-    long double
-    GetLongDouble (lldb::SBError& error, lldb::offset_t offset);
-
-    lldb::addr_t
-    GetAddress (lldb::SBError& error, lldb::offset_t offset);
-
-    uint8_t
-    GetUnsignedInt8 (lldb::SBError& error, lldb::offset_t offset);
-
-    uint16_t
-    GetUnsignedInt16 (lldb::SBError& error, lldb::offset_t offset);
-
-    uint32_t
-    GetUnsignedInt32 (lldb::SBError& error, lldb::offset_t offset);
-
-    uint64_t
-    GetUnsignedInt64 (lldb::SBError& error, lldb::offset_t offset);
-
-    int8_t
-    GetSignedInt8 (lldb::SBError& error, lldb::offset_t offset);
-
-    int16_t
-    GetSignedInt16 (lldb::SBError& error, lldb::offset_t offset);
-
-    int32_t
-    GetSignedInt32 (lldb::SBError& error, lldb::offset_t offset);
-
-    int64_t
-    GetSignedInt64 (lldb::SBError& error, lldb::offset_t offset);
-
-    const char*
-    GetString (lldb::SBError& error, lldb::offset_t offset);
-
-    bool
-    GetDescription (lldb::SBStream &description, lldb::addr_t base_addr);
-
-    size_t
-    ReadRawData (lldb::SBError& error,
-                 lldb::offset_t offset,
-                 void *buf,
-                 size_t size);
-
-    void
-    SetData (lldb::SBError& error, const void *buf, size_t size, lldb::ByteOrder endian, uint8_t addr_size);
-
-    void
-    SetDataWithOwnership (lldb::SBError& error, const void *buf, size_t size,
-                          lldb::ByteOrder endian, uint8_t addr_size);
-
-    bool
-    Append (const SBData& rhs);
-
-    static lldb::SBData
-    CreateDataFromCString (lldb::ByteOrder endian, uint32_t addr_byte_size, const char* data);
-
-    // in the following CreateData*() and SetData*() prototypes, the two parameters array and array_len
-    // should not be renamed or rearranged, because doing so will break the SWIG typemap
-    static lldb::SBData
-    CreateDataFromUInt64Array (lldb::ByteOrder endian, uint32_t addr_byte_size, uint64_t* array, size_t array_len);
-
-    static lldb::SBData
-    CreateDataFromUInt32Array (lldb::ByteOrder endian, uint32_t addr_byte_size, uint32_t* array, size_t array_len);
-
-    static lldb::SBData
-    CreateDataFromSInt64Array (lldb::ByteOrder endian, uint32_t addr_byte_size, int64_t* array, size_t array_len);
-
-    static lldb::SBData
-    CreateDataFromSInt32Array (lldb::ByteOrder endian, uint32_t addr_byte_size, int32_t* array, size_t array_len);
-
-    static lldb::SBData
-    CreateDataFromDoubleArray (lldb::ByteOrder endian, uint32_t addr_byte_size, double* array, size_t array_len);
-
-    bool
-    SetDataFromCString (const char* data);
-
-    bool
-    SetDataFromUInt64Array (uint64_t* array, size_t array_len);
-
-    bool
-    SetDataFromUInt32Array (uint32_t* array, size_t array_len);
-
-    bool
-    SetDataFromSInt64Array (int64_t* array, size_t array_len);
-
-    bool
-    SetDataFromSInt32Array (int32_t* array, size_t array_len);
-
-    bool
-    SetDataFromDoubleArray (double* array, size_t array_len);
-
-    STRING_EXTENSION(SBData)
+STRING_EXTENSION_OUTSIDE(SBData)
 
+%extend lldb::SBData {
 #ifdef SWIGPYTHON
     %pythoncode %{
 
         class read_data_helper:
             def __init__(self, sbdata, readerfunc, item_size):
                 self.sbdata = sbdata
                 self.readerfunc = readerfunc
                 self.item_size = item_size
%pythoncode %{
         sint32s = property(_read_all_sint32, None, doc='''A read only property that returns an array with all the contents of this SBData represented as sint32 values.''')
         sint64s = property(_read_all_sint64, None, doc='''A read only property that returns an array with all the contents of this SBData represented as sint64 values.''')
         floats = property(_read_all_float, None, doc='''A read only property that returns an array with all the contents of this SBData represented as float values.''')
         doubles = property(_read_all_double, None, doc='''A read only property that returns an array with all the contents of this SBData represented as double values.''')
         byte_order = property(GetByteOrder, SetByteOrder, doc='''A read/write property getting and setting the endianness of this SBData (data.byte_order = lldb.eByteOrderLittle).''')
         size = property(GetByteSize, None, doc='''A read only property that returns the size the same result as GetByteSize().''')
     %}
 #endif
-
-};
-
-} // namespace lldb
+}

lldb/bindings/interface/SBDebugger.i

-//===-- SWIG Interface for SBDebugger ---------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-%feature("docstring",
-"SBDebugger is the primordial object that creates SBTargets and provides
-access to them.  It also manages the overall debugging experiences.
-
-For example (from example/disasm.py),::
-
-    import lldb
-    import os
-    import sys
-
-    def disassemble_instructions (insts):
-        for i in insts:
-            print i
-
-    ...
-
-    # Create a new debugger instance
-    debugger = lldb.SBDebugger.Create()
-
-    # When we step or continue, don't return from the function until the process
-    # stops. We do this by setting the async mode to false.
-    debugger.SetAsync (False)
-
-    # Create a target from a file and arch
-    print('Creating a target for \'%s\'' % exe)
-
-    target = debugger.CreateTargetWithFileAndArch (exe, lldb.LLDB_ARCH_DEFAULT)
-
-    if target:
-        # If the target is valid set a breakpoint at main
-        main_bp = target.BreakpointCreateByName (fname, target.GetExecutable().GetFilename());
-
-        print main_bp
-
-        # Launch the process. Since we specified synchronous mode, we won't return
-        # from this function until we hit the breakpoint at main
-        process = target.LaunchSimple (None, None, os.getcwd())
-
-        # Make sure the launch went ok
-        if process:
-            # Print some simple process info
-            state = process.GetState ()
-            print process
-            if state == lldb.eStateStopped:
-                # Get the first thread
-                thread = process.GetThreadAtIndex (0)
-                if thread:
-                    # Print some simple thread info
-                    print thread
-                    # Get the first frame
-                    frame = thread.GetFrameAtIndex (0)
-                    if frame:
-                        # Print some simple frame info
-                        print frame
-                        function = frame.GetFunction()
-                        # See if we have debug info (a function)
-                        if function:
-                            # We do have a function, print some info for the function
-                            print function
-                            # Now get all instructions for this function and print them
-                            insts = function.GetInstructions(target)
-                            disassemble_instructions (insts)
-                        else:
-                            # See if we have a symbol in the symbol table for where we stopped
-                            symbol = frame.GetSymbol();
-                            if symbol:
-                                # We do have a symbol, print some info for the symbol
-                                print symbol
-                                # Now get all instructions for this symbol and print them
-                                insts = symbol.GetInstructions(target)
-                                disassemble_instructions (insts)
-
-                        registerList = frame.GetRegisters()
-                        print('Frame registers (size of register set = %d):' % registerList.GetSize())
-                        for value in registerList:
-                            #print value
-                            print('%s (number of children = %d):' % (value.GetName(), value.GetNumChildren()))
-                            for child in value:
-                                print('Name: ', child.GetName(), ' Value: ', child.GetValue())
-
-                print('Hit the breakpoint at main, enter to continue and wait for program to exit or \'Ctrl-D\'/\'quit\' to terminate the program')
-                next = sys.stdin.readline()
-                if not next or next.rstrip('\\n') == 'quit':
-                    print('Terminating the inferior process...')
-                    process.Kill()
-                else:
-                    # Now continue to the program exit
-                    process.Continue()
-                    # When we return from the above function we will hopefully be at the
-                    # program exit. Print out some process info
-                    print process
-            elif state == lldb.eStateExited:
-                print('Didn\'t hit the breakpoint at main, program has exited...')
-            else:
-                print('Unexpected process state: %s, killing process...' % debugger.StateAsCString (state))
-                process.Kill()
-
-Sometimes you need to create an empty target that will get filled in later.  The most common use for this
-is to attach to a process by name or pid where you don't know the executable up front.  The most convenient way
-to do this is: ::
-
-    target = debugger.CreateTarget('')
-    error = lldb.SBError()
-    process = target.AttachToProcessWithName(debugger.GetListener(), 'PROCESS_NAME', False, error)
-
-or the equivalent arguments for :py:class:`SBTarget.AttachToProcessWithID` .") SBDebugger;
-class SBDebugger
-{
-public:
-    enum
-    {
-        eBroadcastBitProgress = (1 << 0),
-        eBroadcastBitWarning = (1 << 1),
-        eBroadcastBitError = (1 << 2),
-    };
-
-
-    static const char *GetProgressFromEvent(const lldb::SBEvent &event,
-                                        uint64_t &OUTPUT,
-                                        uint64_t &OUTPUT,
-                                        uint64_t &OUTPUT,
-                                        bool &OUTPUT);
-
-    static lldb::SBStructuredData GetProgressDataFromEvent(const lldb::SBEvent &event);
-
-    static lldb::SBStructuredData GetDiagnosticFromEvent(const lldb::SBEvent &event);
-
-    SBBroadcaster GetBroadcaster();
-
-    static void
-    Initialize();
-
-    static SBError
-    InitializeWithErrorHandling();
-
-    static void PrintStackTraceOnError();
-
-    static void
-    Terminate();
-
-    static lldb::SBDebugger
-    Create();
-
-    static lldb::SBDebugger
-    Create(bool source_init_files);
-
-    static lldb::SBDebugger
-    Create(bool source_init_files, lldb::LogOutputCallback log_callback, void *baton);
-
-    static void
-    Destroy (lldb::SBDebugger &debugger);
-
-    static void
-    MemoryPressureDetected();
-
-    SBDebugger();
-
-    SBDebugger(const lldb::SBDebugger &rhs);
-
-    ~SBDebugger();
-
-    bool
-    IsValid() const;
-
-    explicit operator bool() const;
-
-    void
-    Clear ();
-
-    void
-    SetAsync (bool b);
-
-    bool
-    GetAsync ();
-
-    void
-    SkipLLDBInitFiles (bool b);
-
-#ifdef SWIGPYTHON
-    %pythoncode %{
-        def SetOutputFileHandle(self, file, transfer_ownership):
-            "DEPRECATED, use SetOutputFile"
-            if file is None:
-                import sys
-                file = sys.stdout
-            self.SetOutputFile(SBFile.Create(file, borrow=True))
-
-        def SetInputFileHandle(self, file, transfer_ownership):
-            "DEPRECATED, use SetInputFile"
-            if file is None:
-                import sys
-                file = sys.stdin
-            self.SetInputFile(SBFile.Create(file, borrow=True))
-
-        def SetErrorFileHandle(self, file, transfer_ownership):
-            "DEPRECATED, use SetErrorFile"
-            if file is None:
-                import sys
-                file = sys.stderr
-            self.SetErrorFile(SBFile.Create(file, borrow=True))
-    %}
-#endif
-
-
-    %extend {
-
-        lldb::FileSP GetInputFileHandle() {
-            return self->GetInputFile().GetFile();
-        }
-
-        lldb::FileSP GetOutputFileHandle() {
-            return self->GetOutputFile().GetFile();
-        }
-
-        lldb::FileSP GetErrorFileHandle() {
-            return self->GetErrorFile().GetFile();
-        }
-    }
-
-    lldb::SBStructuredData GetSetting(const char *setting = nullptr);
-
-    SBError
-    SetInputString (const char* data);
-
-    SBError
-    SetInputFile (SBFile file);
-
-    SBError
-    SetOutputFile (SBFile file);
-
-    SBError
-    SetErrorFile (SBFile file);
-
-    SBError
-    SetInputFile (FileSP file);
-
-    SBError
-    SetOutputFile (FileSP file);
-
-    SBError
-    SetErrorFile (FileSP file);
-
-    SBFile
-    GetInputFile ();
-
-    SBFile
-    GetOutputFile ();
-
-    SBFile
-    GetErrorFile ();
-
-    lldb::SBCommandInterpreter
-    GetCommandInterpreter ();
-
-    void
-    HandleCommand (const char *command);
-
-    lldb::SBListener
-    GetListener ();
-
-    void
-    HandleProcessEvent (const lldb::SBProcess &process,
-                        const lldb::SBEvent &event,
-                        SBFile out,
-                        SBFile err);
-
-    void
-    HandleProcessEvent (const lldb::SBProcess &process,
-                        const lldb::SBEvent &event,
-                        FileSP BORROWED,
-                        FileSP BORROWED);
-
-    lldb::SBTarget
-    CreateTarget (const char *filename,
-                  const char *target_triple,
-                  const char *platform_name,
-                  bool add_dependent_modules,
-                  lldb::SBError& sb_error);
-
-    lldb::SBTarget
-    CreateTargetWithFileAndTargetTriple (const char *filename,
-                                         const char *target_triple);
-
-    lldb::SBTarget
-    CreateTargetWithFileAndArch (const char *filename,
-                                 const char *archname);
-
-    lldb::SBTarget
-    CreateTarget (const char *filename);
-
-    %feature("docstring",
-    "The dummy target holds breakpoints and breakpoint names that will prime newly created targets."
-    ) GetDummyTarget;
-    lldb::SBTarget GetDummyTarget();
-
-    %feature("docstring",
-    "Return true if target is deleted from the target list of the debugger."
-    ) DeleteTarget;
-    bool
-    DeleteTarget (lldb::SBTarget &target);
-
-    lldb::SBTarget
-    GetTargetAtIndex (uint32_t idx);
-
-    uint32_t
-    GetIndexOfTarget (lldb::SBTarget target);
-
-    lldb::SBTarget
-    FindTargetWithProcessID (pid_t pid);
-
-    lldb::SBTarget
-    FindTargetWithFileAndArch (const char *filename,
-                               const char *arch);
-
-    uint32_t
-    GetNumTargets ();
-
-    lldb::SBTarget
-    GetSelectedTarget ();
-
-    void
-    SetSelectedTarget (lldb::SBTarget &target);
-
-    lldb::SBPlatform
-    GetSelectedPlatform();
-
-    void
-    SetSelectedPlatform(lldb::SBPlatform &platform);
-
-    %feature("docstring",
-    "Get the number of currently active platforms."
-    ) GetNumPlatforms;
-    uint32_t
-    GetNumPlatforms ();
-
-    %feature("docstring",
-    "Get one of the currently active platforms."
-    ) GetPlatformAtIndex;
-    lldb::SBPlatform
-    GetPlatformAtIndex (uint32_t idx);
-
-    %feature("docstring",
-    "Get the number of available platforms."
-    ) GetNumAvailablePlatforms;
-    uint32_t
-    GetNumAvailablePlatforms ();
-
-    %feature("docstring", "
-    Get the name and description of one of the available platforms.
-
-    @param idx Zero-based index of the platform for which info should be
-               retrieved, must be less than the value returned by
-               GetNumAvailablePlatforms().") GetAvailablePlatformInfoAtIndex;
-    lldb::SBStructuredData
-    GetAvailablePlatformInfoAtIndex (uint32_t idx);
-
-    lldb::SBSourceManager
-    GetSourceManager ();
-
-    // REMOVE: just for a quick fix, need to expose platforms through
-    // SBPlatform from this class.
-    lldb::SBError
-    SetCurrentPlatform (const char *platform_name);
-
-    bool
-    SetCurrentPlatformSDKRoot (const char *sysroot);
-
-    // FIXME: Once we get the set show stuff in place, the driver won't need
-    // an interface to the Set/Get UseExternalEditor.
-    bool
-    SetUseExternalEditor (bool input);
-
-    bool
-    GetUseExternalEditor ();
-
-    bool
-    SetUseColor (bool use_color);
-
-    bool
-    GetUseColor () const;
-
-    static bool
-    GetDefaultArchitecture (char *arch_name, size_t arch_name_len);
-
-    static bool
-    SetDefaultArchitecture (const char *arch_name);
-
-    lldb::ScriptLanguage
-    GetScriptingLanguage (const char *script_language_name);
-
-    static const char *
-    GetVersionString ();
-
-    static const char *
-    StateAsCString (lldb::StateType state);
-
-    static SBStructuredData GetBuildConfiguration();
-
-    static bool
-    StateIsRunningState (lldb::StateType state);
-
-    static bool
-    StateIsStoppedState (lldb::StateType state);
-
-    bool
-    EnableLog (const char *channel, const char ** types);
-
-    void
-    SetLoggingCallback (lldb::LogOutputCallback log_callback, void *baton);
-
-    void
-    DispatchInput (const void *data, size_t data_len);
-
-    void
-    DispatchInputInterrupt ();
-
-    void
-    DispatchInputEndOfFile ();
-
-    const char *
-    GetInstanceName  ();
-
-    static SBDebugger
-    FindDebuggerWithID (int id);
-
-    static lldb::SBError
-    SetInternalVariable (const char *var_name, const char *value, const char *debugger_instance_name);
-
-    static lldb::SBStringList
-    GetInternalVariableValue (const char *var_name, const char *debugger_instance_name);
-
-    bool
-    GetDescription (lldb::SBStream &description);
-
-    uint32_t
-    GetTerminalWidth () const;
-
-    void
-    SetTerminalWidth (uint32_t term_width);
-
-    lldb::user_id_t
-    GetID ();
-
-    const char *
-    GetPrompt() const;
-
-    void
-    SetPrompt (const char *prompt);
-
-    const char *
-    GetReproducerPath() const;
-
-    lldb::ScriptLanguage
-    GetScriptLanguage() const;
-
-    void
-    SetScriptLanguage (lldb::ScriptLanguage script_lang);
-
-    bool
-    GetCloseInputOnEOF () const;
-
-    void
-    SetCloseInputOnEOF (bool b);
-
-    lldb::SBTypeCategory
-    GetCategory (const char* category_name);
-
-    SBTypeCategory
-    GetCategory (lldb::LanguageType lang_type);
-
-    lldb::SBTypeCategory
-    CreateCategory (const char* category_name);
-
-    bool
-    DeleteCategory (const char* category_name);
-
-    uint32_t
-    GetNumCategories ();
-
-    lldb::SBTypeCategory
-    GetCategoryAtIndex (uint32_t);
-
-    lldb::SBTypeCategory
-    GetDefaultCategory();
-
-    lldb::SBTypeFormat
-    GetFormatForType (lldb::SBTypeNameSpecifier);
-
-    lldb::SBTypeSummary
-    GetSummaryForType (lldb::SBTypeNameSpecifier);
-
-    lldb::SBTypeFilter
-    GetFilterForType (lldb::SBTypeNameSpecifier);
-
-    lldb::SBTypeSynthetic
-    GetSyntheticForType (lldb::SBTypeNameSpecifier);
-
-    SBStructuredData GetScriptInterpreterInfo(ScriptLanguage);
-
-    STRING_EXTENSION(SBDebugger)
-
-    %feature("docstring",
-"Launch a command interpreter session. Commands are read from standard input or
-from the input handle specified for the debugger object. Output/errors are
-similarly redirected to standard output/error or the configured handles.
-
-@param[in] auto_handle_events If true, automatically handle resulting events.
-@param[in] spawn_thread If true, start a new thread for IO handling.
-@param[in] options Parameter collection of type SBCommandInterpreterRunOptions.
-@param[in] num_errors Initial error counter.
-@param[in] quit_requested Initial quit request flag.
-@param[in] stopped_for_crash Initial crash flag.
-
-@return
-A tuple with the number of errors encountered by the interpreter, a boolean
-indicating whether quitting the interpreter was requested and another boolean
-set to True in case of a crash.
-
-Example: ::
-
-    # Start an interactive lldb session from a script (with a valid debugger object
-    # created beforehand):
-    n_errors, quit_requested, has_crashed = debugger.RunCommandInterpreter(True,
-        False, lldb.SBCommandInterpreterRunOptions(), 0, False, False)") RunCommandInterpreter;
-    %apply int& INOUT { int& num_errors };
-    %apply bool& INOUT { bool& quit_requested };
-    %apply bool& INOUT { bool& stopped_for_crash };
-    void
-    RunCommandInterpreter (bool auto_handle_events,
-                           bool spawn_thread,
-                           SBCommandInterpreterRunOptions &options,
-                           int  &num_errors,
-                           bool &quit_requested,
-                           bool &stopped_for_crash);
-
-    lldb::SBError
-    RunREPL (lldb::LanguageType language, const char *repl_options);
-
-    SBTrace LoadTraceFromFile(SBError &error, const SBFileSpec &trace_description_file);
-
-#ifdef SWIGPYTHON
-    %pythoncode%{
-    def __iter__(self):
-        '''Iterate over all targets in a lldb.SBDebugger object.'''
-        return lldb_iter(self, 'GetNumTargets', 'GetTargetAtIndex')
-
-    def __len__(self):
-        '''Return the number of targets in a lldb.SBDebugger object.'''
-        return self.GetNumTargets()
-    %}
-#endif
-
-}; // class SBDebugger
-
-} // namespace lldb

lldb/bindings/interface/SBDebuggerDocstrings.i

+%feature("docstring",
+"SBDebugger is the primordial object that creates SBTargets and provides
+access to them.  It also manages the overall debugging experiences.
+
+For example (from example/disasm.py),::
+
+    import lldb
+    import os
+    import sys
+
+    def disassemble_instructions (insts):
+        for i in insts:
+            print i
+
+    ...
+
+    # Create a new debugger instance
+    debugger = lldb.SBDebugger.Create()
+
+    # When we step or continue, don't return from the function until the process
+    # stops. We do this by setting the async mode to false.
+    debugger.SetAsync (False)
+
+    # Create a target from a file and arch
+    print('Creating a target for \'%s\'' % exe)
+
+    target = debugger.CreateTargetWithFileAndArch (exe, lldb.LLDB_ARCH_DEFAULT)
+
+    if target:
+        # If the target is valid set a breakpoint at main
+        main_bp = target.BreakpointCreateByName (fname, target.GetExecutable().GetFilename());
+
+        print main_bp
+
+        # Launch the process. Since we specified synchronous mode, we won't return
+        # from this function until we hit the breakpoint at main
+        process = target.LaunchSimple (None, None, os.getcwd())
+
+        # Make sure the launch went ok
+        if process:
+            # Print some simple process info
+            state = process.GetState ()
+            print process
+            if state == lldb.eStateStopped:
+                # Get the first thread
+                thread = process.GetThreadAtIndex (0)
+                if thread:
+                    # Print some simple thread info
+                    print thread
+                    # Get the first frame
+                    frame = thread.GetFrameAtIndex (0)
+                    if frame:
+                        # Print some simple frame info
+                        print frame
+                        function = frame.GetFunction()
+                        # See if we have debug info (a function)
+                        if function:
+                            # We do have a function, print some info for the function
+                            print function
+                            # Now get all instructions for this function and print them
+                            insts = function.GetInstructions(target)
+                            disassemble_instructions (insts)
+                        else:
+                            # See if we have a symbol in the symbol table for where we stopped
+                            symbol = frame.GetSymbol();
+                            if symbol:
+                                # We do have a symbol, print some info for the symbol
+                                print symbol
+                                # Now get all instructions for this symbol and print them
+                                insts = symbol.GetInstructions(target)
+                                disassemble_instructions (insts)
+
+                        registerList = frame.GetRegisters()
+                        print('Frame registers (size of register set = %d):' % registerList.GetSize())
+                        for value in registerList:
+                            #print value
+                            print('%s (number of children = %d):' % (value.GetName(), value.GetNumChildren()))
+                            for child in value:
+                                print('Name: ', child.GetName(), ' Value: ', child.GetValue())
+
+                print('Hit the breakpoint at main, enter to continue and wait for program to exit or \'Ctrl-D\'/\'quit\' to terminate the program')
+                next = sys.stdin.readline()
+                if not next or next.rstrip('\\n') == 'quit':
+                    print('Terminating the inferior process...')
+                    process.Kill()
+                else:
+                    # Now continue to the program exit
+                    process.Continue()
+                    # When we return from the above function we will hopefully be at the
+                    # program exit. Print out some process info
+                    print process
+            elif state == lldb.eStateExited:
+                print('Didn\'t hit the breakpoint at main, program has exited...')
+            else:
+                print('Unexpected process state: %s, killing process...' % debugger.StateAsCString (state))
+                process.Kill()
+
+Sometimes you need to create an empty target that will get filled in later.  The most common use for this
+is to attach to a process by name or pid where you don't know the executable up front.  The most convenient way
+to do this is: ::
+
+    target = debugger.CreateTarget('')
+    error = lldb.SBError()
+    process = target.AttachToProcessWithName(debugger.GetListener(), 'PROCESS_NAME', False, error)
+
+or the equivalent arguments for :py:class:`SBTarget.AttachToProcessWithID` ."
+) lldb::SBDebugger;
+
+%feature("docstring",
+    "The dummy target holds breakpoints and breakpoint names that will prime newly created targets."
+) lldb::SBDebugger::GetDummyTarget;
+
+%feature("docstring",
+    "Return true if target is deleted from the target list of the debugger."
+) lldb::SBDebugger::DeleteTarget;
+
+%feature("docstring",
+    "Get the number of currently active platforms."
+) lldb::SBDebugger::GetNumPlatforms;
+
+%feature("docstring",
+    "Get one of the currently active platforms."
+) lldb::SBDebugger::GetPlatformAtIndex;
+
+%feature("docstring",
+    "Get the number of available platforms."
+) lldb::SBDebugger::GetNumAvailablePlatforms;
+
+%feature("docstring", "
+    Get the name and description of one of the available platforms.
+
+    @param idx Zero-based index of the platform for which info should be
+               retrieved, must be less than the value returned by
+               GetNumAvailablePlatforms()."
+) lldb::SBDebugger::GetAvailablePlatformInfoAtIndex;
+
+%feature("docstring",
+"Launch a command interpreter session. Commands are read from standard input or
+from the input handle specified for the debugger object. Output/errors are
+similarly redirected to standard output/error or the configured handles.
+
+@param[in] auto_handle_events If true, automatically handle resulting events.
+@param[in] spawn_thread If true, start a new thread for IO handling.
+@param[in] options Parameter collection of type SBCommandInterpreterRunOptions.
+@param[in] num_errors Initial error counter.
+@param[in] quit_requested Initial quit request flag.
+@param[in] stopped_for_crash Initial crash flag.
+
+@return
+A tuple with the number of errors encountered by the interpreter, a boolean
+indicating whether quitting the interpreter was requested and another boolean
+set to True in case of a crash.
+
+Example: ::
+
+    # Start an interactive lldb session from a script (with a valid debugger object
+    # created beforehand):
+    n_errors, quit_requested, has_crashed = debugger.RunCommandInterpreter(True,
+        False, lldb.SBCommandInterpreterRunOptions(), 0, False, False)"
+) lldb::SBDebugger::RunCommandInterpreter;

lldb/bindings/interface/SBDebuggerExtensions.i

+STRING_EXTENSION_OUTSIDE(SBDebugger)
+
+%extend lldb::SBDebugger {
+#ifdef SWIGPYTHON
+    %pythoncode %{
+        def SetOutputFileHandle(self, file, transfer_ownership):
+            "DEPRECATED, use SetOutputFile"
+            if file is None:
+                import sys
+                file = sys.stdout
+            self.SetOutputFile(SBFile.Create(file, borrow=True))
+
+        def SetInputFileHandle(self, file, transfer_ownership):
+            "DEPRECATED, use SetInputFile"
+            if file is None:
+                import sys
+                file = sys.stdin
+            self.SetInputFile(SBFile.Create(file, borrow=True))
+
+        def SetErrorFileHandle(self, file, transfer_ownership):
+            "DEPRECATED, use SetErrorFile"
+            if file is None:
+                import sys
+                file = sys.stderr
+            self.SetErrorFile(SBFile.Create(file, borrow=True))
+
+        def __iter__(self):
+            '''Iterate over all targets in a lldb.SBDebugger object.'''
+            return lldb_iter(self, 'GetNumTargets', 'GetTargetAtIndex')
+
+        def __len__(self):
+            '''Return the number of targets in a lldb.SBDebugger object.'''
+            return self.GetNumTargets()
+    %}
+#endif
+
+    lldb::FileSP GetInputFileHandle() {
+        return self->GetInputFile().GetFile();
+    }
+
+    lldb::FileSP GetOutputFileHandle() {
+        return self->GetOutputFile().GetFile();
+    }
+
+    lldb::FileSP GetErrorFileHandle() {
+        return self->GetErrorFile().GetFile();
+    }
+}

lldb/bindings/interface/SBDeclaration.i

-//===-- SWIG Interface for SBDeclaration --------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-    %feature("docstring",
-    "Specifies an association with a line and column for a variable."
-    ) SBDeclaration;
-    class SBDeclaration
-    {
-        public:
-
-        SBDeclaration ();
-
-        SBDeclaration (const lldb::SBDeclaration &rhs);
-
-        ~SBDeclaration ();
-
-        bool
-        IsValid () const;
-
-        explicit operator bool() const;
-
-        lldb::SBFileSpec
-        GetFileSpec () const;
-
-        uint32_t
-        GetLine () const;
-
-        uint32_t
-        GetColumn () const;
-
-        bool
-        GetDescription (lldb::SBStream &description);
-
-        void
-        SetFileSpec (lldb::SBFileSpec filespec);
-
-        void
-        SetLine (uint32_t line);
-
-        void
-        SetColumn (uint32_t column);
-
-        bool
-        operator == (const lldb::SBDeclaration &rhs) const;
-
-        bool
-        operator != (const lldb::SBDeclaration &rhs) const;
-
-        STRING_EXTENSION(SBDeclaration)
-
-#ifdef SWIGPYTHON
-        %pythoncode %{
-            file = property(GetFileSpec, None, doc='''A read only property that returns an lldb object that represents the file (lldb.SBFileSpec) for this line entry.''')
-            line = property(GetLine, None, doc='''A read only property that returns the 1 based line number for this line entry, a return value of zero indicates that no line information is available.''')
-            column = property(GetColumn, None, doc='''A read only property that returns the 1 based column number for this line entry, a return value of zero indicates that no column information is available.''')
-        %}
-#endif
-    };
-
-} // namespace lldb

lldb/bindings/interface/SBDeclarationDocstrings.i

+%feature("docstring",
+"Specifies an association with a line and column for a variable."
+) lldb::SBDeclaration;

lldb/bindings/interface/SBDeclarationExtensions.i

+STRING_EXTENSION_OUTSIDE(SBDeclaration)
+
+%extend lldb::SBDeclaration {
+#ifdef SWIGPYTHON
+        %pythoncode %{
+            file = property(GetFileSpec, None, doc='''A read only property that returns an lldb object that represents the file (lldb.SBFileSpec) for this line entry.''')
+            line = property(GetLine, None, doc='''A read only property that returns the 1 based line number for this line entry, a return value of zero indicates that no line information is available.''')
+            column = property(GetColumn, None, doc='''A read only property that returns the 1 based column number for this line entry, a return value of zero indicates that no column information is available.''')
+        %}
+#endif
+}

lldb/bindings/interface/SBEnvironment.i

-//===-- SWIG Interface for SBEnvironment-------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-%feature("docstring",
-"Represents the environment of a certain process.
-
-Example: ::
-
-  for entry in lldb.debugger.GetSelectedTarget().GetEnvironment().GetEntries():
-    print(entry)
-
-") SBEnvironment;
-class SBEnvironment {
-public:
-    SBEnvironment ();
-
-    SBEnvironment (const lldb::SBEnvironment &rhs);
-
-    ~SBEnvironment();
-
-    size_t GetNumValues();
-
-    const char *Get(const char *name);
-
-    const char *GetNameAtIndex(size_t index);
-
-    const char *GetValueAtIndex(size_t index);
-
-    SBStringList GetEntries();
-
-    void PutEntry(const char *name_and_value);
-
-    void SetEntries(const SBStringList &entries, bool append);
-
-    bool Set(const char *name, const char *value, bool overwrite);
-
-    bool Unset(const char *name);
-
-    void Clear();
-};
-
-} // namespace lldb

lldb/bindings/interface/SBEnvironmentDocstrings.i

+%feature("docstring",
+"Represents the environment of a certain process.
+
+Example: ::
+
+  for entry in lldb.debugger.GetSelectedTarget().GetEnvironment().GetEntries():
+    print(entry)
+
+") lldb::SBEnvironment;

lldb/bindings/interface/SBError.i

-//===-- SWIG Interface for SBError ------------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-%feature("docstring",
-"Represents a container for holding any error code.
-
-For example (from test/python_api/hello_world/TestHelloWorld.py), ::
-
-    def hello_world_attach_with_id_api(self):
-        '''Create target, spawn a process, and attach to it by id.'''
-
-        target = self.dbg.CreateTarget(self.exe)
-
-        # Spawn a new process and don't display the stdout if not in TraceOn() mode.
-        import subprocess
-        popen = subprocess.Popen([self.exe, 'abc', 'xyz'],
-                                 stdout = open(os.devnull, 'w') if not self.TraceOn() else None)
-
-        listener = lldb.SBListener('my.attach.listener')
-        error = lldb.SBError()
-        process = target.AttachToProcessWithID(listener, popen.pid, error)
-
-        self.assertTrue(error.Success() and process, PROCESS_IS_VALID)
-
-        # Let's check the stack traces of the attached process.
-        import lldbutil
-        stacktraces = lldbutil.print_stacktraces(process, string_buffer=True)
-        self.expect(stacktraces, exe=False,
-            substrs = ['main.c:%d' % self.line2,
-                       '(int)argc=3'])
-
-        listener = lldb.SBListener('my.attach.listener')
-        error = lldb.SBError()
-        process = target.AttachToProcessWithID(listener, popen.pid, error)
-
-        self.assertTrue(error.Success() and process, PROCESS_IS_VALID)
-
-checks that after the attach, there is no error condition by asserting
-that error.Success() is True and we get back a valid process object.
-
-And (from test/python_api/event/TestEvent.py), ::
-
-        # Now launch the process, and do not stop at entry point.
-        error = lldb.SBError()
-        process = target.Launch(listener, None, None, None, None, None, None, 0, False, error)
-        self.assertTrue(error.Success() and process, PROCESS_IS_VALID)
-
-checks that after calling the target.Launch() method there's no error
-condition and we get back a void process object.") SBError;
-
-class SBError {
-public:
-    SBError ();
-
-    SBError (const lldb::SBError &rhs);
-
-    ~SBError();
-
-    const char *
-    GetCString () const;
-
-    void
-    Clear ();
-
-    bool
-    Fail () const;
-
-    bool
-    Success () const;
-
-    uint32_t
-    GetError () const;
-
-    lldb::ErrorType
-    GetType () const;
-
-    void
-    SetError (uint32_t err, lldb::ErrorType type);
-
-    void
-    SetErrorToErrno ();
-
-    void
-    SetErrorToGenericError ();
-
-    void
-    SetErrorString (const char *err_str);
-
-    %varargs(3, char *str = NULL) SetErrorStringWithFormat;
-    int
-    SetErrorStringWithFormat (const char *format, ...);
-
-    bool
-    IsValid () const;
-
-    explicit operator bool() const;
-
-    bool
-    GetDescription (lldb::SBStream &description);
-
-    STRING_EXTENSION(SBError)
-
-#ifdef SWIGPYTHON
-    %pythoncode %{
-        value = property(GetError, None, doc='''A read only property that returns the same result as GetError().''')
-        fail = property(Fail, None, doc='''A read only property that returns the same result as Fail().''')
-        success = property(Success, None, doc='''A read only property that returns the same result as Success().''')
-        description = property(GetCString, None, doc='''A read only property that returns the same result as GetCString().''')
-        type = property(GetType, None, doc='''A read only property that returns the same result as GetType().''')
-    %}
-#endif
-
-};
-
-} // namespace lldb

lldb/bindings/interface/SBErrorDocstrings.i

+%feature("docstring",
+"Represents a container for holding any error code.
+
+For example (from test/python_api/hello_world/TestHelloWorld.py), ::
+
+    def hello_world_attach_with_id_api(self):
+        '''Create target, spawn a process, and attach to it by id.'''
+
+        target = self.dbg.CreateTarget(self.exe)
+
+        # Spawn a new process and don't display the stdout if not in TraceOn() mode.
+        import subprocess
+        popen = subprocess.Popen([self.exe, 'abc', 'xyz'],
+                                 stdout = open(os.devnull, 'w') if not self.TraceOn() else None)
+
+        listener = lldb.SBListener('my.attach.listener')
+        error = lldb.SBError()
+        process = target.AttachToProcessWithID(listener, popen.pid, error)
+
+        self.assertTrue(error.Success() and process, PROCESS_IS_VALID)
+
+        # Let's check the stack traces of the attached process.
+        import lldbutil
+        stacktraces = lldbutil.print_stacktraces(process, string_buffer=True)
+        self.expect(stacktraces, exe=False,
+            substrs = ['main.c:%d' % self.line2,
+                       '(int)argc=3'])
+
+        listener = lldb.SBListener('my.attach.listener')
+        error = lldb.SBError()
+        process = target.AttachToProcessWithID(listener, popen.pid, error)
+
+        self.assertTrue(error.Success() and process, PROCESS_IS_VALID)
+
+checks that after the attach, there is no error condition by asserting
+that error.Success() is True and we get back a valid process object.
+
+And (from test/python_api/event/TestEvent.py), ::
+
+        # Now launch the process, and do not stop at entry point.
+        error = lldb.SBError()
+        process = target.Launch(listener, None, None, None, None, None, None, 0, False, error)
+        self.assertTrue(error.Success() and process, PROCESS_IS_VALID)
+
+checks that after calling the target.Launch() method there's no error
+condition and we get back a void process object.") lldb::SBError;

lldb/bindings/interface/SBErrorExtensions.i

+STRING_EXTENSION_OUTSIDE(SBError)
+
+%extend lldb::SBError {
+#ifdef SWIGPYTHON
+    %pythoncode %{
+        value = property(GetError, None, doc='''A read only property that returns the same result as GetError().''')
+        fail = property(Fail, None, doc='''A read only property that returns the same result as Fail().''')
+        success = property(Success, None, doc='''A read only property that returns the same result as Success().''')
+        description = property(GetCString, None, doc='''A read only property that returns the same result as GetCString().''')
+        type = property(GetType, None, doc='''A read only property that returns the same result as GetType().''')
+    %}
+#endif
+}

lldb/bindings/interface/SBEventDocstrings.i

-//===-- SWIG Interface for SBEvent ------------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-class SBBroadcaster;
-
 %feature("docstring",
 "API clients can register to receive events.
 
 For example, check out the following output: ::
 
     Try wait for event...
     Event description: 0x103d0bb70 Event: broadcaster = 0x1009c8410, type = 0x00000001, data = { process = 0x1009c8400 (pid = 21528), state = running}
     Event data flavor: Process::ProcessEventData
def do_listen_for_and_print_event(self):
         # able to receive the state changed events.
         process.Continue()
 
         # Use Python API to kill the process.  The listening thread should be
         # able to receive the state changed event, too.
         process.Kill()
 
         # Wait until the 'MyListeningThread' terminates.
-        my_thread.join()") SBEvent;
-class SBEvent
-{
-public:
-    SBEvent();
-
-    SBEvent (const lldb::SBEvent &rhs);
+        my_thread.join()"
+) lldb::SBEvent;
 
-    %feature("autodoc",
-    "__init__(self, int type, str data) -> SBEvent (make an event that contains a C string)"
-    ) SBEvent;
-    SBEvent (uint32_t event, const char *cstr, uint32_t cstr_len);
-
-    ~SBEvent();
-
-    bool
-    IsValid() const;
-
-    explicit operator bool() const;
-
-    const char *
-    GetDataFlavor ();
-
-    uint32_t
-    GetType () const;
-
-    lldb::SBBroadcaster
-    GetBroadcaster () const;
-
-    const char *
-    GetBroadcasterClass () const;
-
-    bool
-    BroadcasterMatchesRef (const lldb::SBBroadcaster &broadcaster);
-
-    void
-    Clear();
-
-    static const char *
-    GetCStringFromEvent (const lldb::SBEvent &event);
-
-    bool
-    GetDescription (lldb::SBStream &description) const;
-};
-
-} // namespace lldb
+) lldb::SBEvent::SBEvent;

lldb/bindings/interface/SBExecutionContext.i

-//===-- SWIG Interface for SBExecutionContext ---------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-%feature("docstring",
-"Describes the program context in which a command should be executed."
-) SBExecutionContext;
-class SBExecutionContext
-{
-public:
-    SBExecutionContext();
-
-    SBExecutionContext (const lldb::SBExecutionContext &rhs);
-
-    SBExecutionContext (const lldb::SBTarget &target);
-
-    SBExecutionContext (const lldb::SBProcess &process);
-
-    SBExecutionContext (lldb::SBThread thread); // can't be a const& because SBThread::get() isn't itself a const function
-
-    SBExecutionContext (const lldb::SBFrame &frame);
-
-    ~SBExecutionContext();
-
-    SBTarget
-    GetTarget () const;
-
-    SBProcess
-    GetProcess () const;
-
-    SBThread
-    GetThread () const;
-
-    SBFrame
-    GetFrame () const;
-
-#ifdef SWIGPYTHON
-    %pythoncode %{
-        target = property(GetTarget, None, doc='''A read only property that returns the same result as GetTarget().''')
-        process = property(GetProcess, None, doc='''A read only property that returns the same result as GetProcess().''')
-        thread = property(GetThread, None, doc='''A read only property that returns the same result as GetThread().''')
-        frame = property(GetFrame, None, doc='''A read only property that returns the same result as GetFrame().''')
-    %}
-#endif
-
-};
-
-} // namespace lldb

lldb/bindings/interface/SBExecutionContextDocstrings.i

+%feature("docstring",
+"Describes the program context in which a command should be executed."
+) lldb::SBExecutionContext;

lldb/bindings/interface/SBExecutionContextExtensions.i

+%extend lldb::SBExecutionContext {
+#ifdef SWIGPYTHON
+    %pythoncode %{
+        target = property(GetTarget, None, doc='''A read only property that returns the same result as GetTarget().''')
+        process = property(GetProcess, None, doc='''A read only property that returns the same result as GetProcess().''')
+        thread = property(GetThread, None, doc='''A read only property that returns the same result as GetThread().''')
+        frame = property(GetFrame, None, doc='''A read only property that returns the same result as GetFrame().''')
+    %}
+#endif
+}

lldb/bindings/interface/SBExpressionOptions.i

-//===-- SWIG interface for SBExpressionOptions -----------------------------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-%feature("docstring",
-"A container for options to use when evaluating expressions."
-) SBExpressionOptions;
-
-class SBExpressionOptions
-{
-friend class SBFrame;
-friend class SBValue;
-
-public:
-    SBExpressionOptions();
-
-    SBExpressionOptions (const lldb::SBExpressionOptions &rhs);
-
-    ~SBExpressionOptions();
-
-    bool
-    GetCoerceResultToId () const;
-
-    %feature("docstring", "Sets whether to coerce the expression result to ObjC id type after evaluation.") SetCoerceResultToId;
-
-    void
-    SetCoerceResultToId (bool coerce = true);
-
-    bool
-    GetUnwindOnError () const;
-
-    %feature("docstring", "Sets whether to unwind the expression stack on error.") SetUnwindOnError;
-
-    void
-    SetUnwindOnError (bool unwind = true);
-
-    bool
-    GetIgnoreBreakpoints () const;
-
-    %feature("docstring", "Sets whether to ignore breakpoint hits while running expressions.") SetUnwindOnError;
-
-    void
-    SetIgnoreBreakpoints (bool ignore = true);
-
-    lldb::DynamicValueType
-    GetFetchDynamicValue () const;
-
-    %feature("docstring", "Sets whether to cast the expression result to its dynamic type.") SetFetchDynamicValue;
-
-    void
-    SetFetchDynamicValue (lldb::DynamicValueType dynamic = lldb::eDynamicCanRunTarget);
-
-    uint32_t
-    GetTimeoutInMicroSeconds () const;
-
-    %feature("docstring", "Sets the timeout in microseconds to run the expression for. If try all threads is set to true and the expression doesn't complete within the specified timeout, all threads will be resumed for the same timeout to see if the expression will finish.") SetTimeoutInMicroSeconds;
-    void
-    SetTimeoutInMicroSeconds (uint32_t timeout = 0);
-
-    uint32_t
-    GetOneThreadTimeoutInMicroSeconds () const;
-
-    %feature("docstring", "Sets the timeout in microseconds to run the expression on one thread before either timing out or trying all threads.") SetTimeoutInMicroSeconds;
-    void
-    SetOneThreadTimeoutInMicroSeconds (uint32_t timeout = 0);
-
-    bool
-    GetTryAllThreads () const;
-
-    %feature("docstring", "Sets whether to run all threads if the expression does not complete on one thread.") SetTryAllThreads;
-    void
-    SetTryAllThreads (bool run_others = true);
-
-    bool
-    GetStopOthers () const;
-
-    %feature("docstring", "Sets whether to stop other threads at all while running expressions.  If false, TryAllThreads does nothing.") SetTryAllThreads;
-    void
-    SetStopOthers (bool stop_others = true);
-
-    bool
-    GetTrapExceptions () const;
-
-    %feature("docstring", "Sets whether to abort expression evaluation if an exception is thrown while executing.  Don't set this to false unless you know the function you are calling traps all exceptions itself.") SetTryAllThreads;
-    void
-    SetTrapExceptions (bool trap_exceptions = true);
-
-    %feature ("docstring", "Sets the language that LLDB should assume the expression is written in") SetLanguage;
-    void
-    SetLanguage (lldb::LanguageType language);
-
-    bool
-    GetGenerateDebugInfo ();
-
-    %feature("docstring", "Sets whether to generate debug information for the expression and also controls if a SBModule is generated.") SetGenerateDebugInfo;
-    void
-    SetGenerateDebugInfo (bool b = true);
-
-    bool
-    GetSuppressPersistentResult ();
-
-    %feature("docstring", "Sets whether to produce a persistent result that can be used in future expressions.") SetSuppressPersistentResult;
-    void
-    SetSuppressPersistentResult (bool b = false);
-
-
-    %feature("docstring", "Gets the prefix to use for this expression.") GetPrefix;
-    const char *
-    GetPrefix () const;
-
-    %feature("docstring", "Sets the prefix to use for this expression. This prefix gets inserted after the 'target.expr-prefix' prefix contents, but before the wrapped expression function body.") SetPrefix;
-    void
-    SetPrefix (const char *prefix);
-
-    %feature("docstring", "Sets whether to auto-apply fix-it hints to the expression being evaluated.") SetAutoApplyFixIts;
-    void
-    SetAutoApplyFixIts(bool b = true);
-
-    %feature("docstring", "Gets whether to auto-apply fix-it hints to an expression.") GetAutoApplyFixIts;
-    bool
-    GetAutoApplyFixIts();
-
-    %feature("docstring", "Sets how often LLDB should retry applying fix-its to an expression.") SetRetriesWithFixIts;
-    void
-    SetRetriesWithFixIts(uint64_t retries);
-
-    %feature("docstring", "Gets how often LLDB will retry applying fix-its to an expression.") GetRetriesWithFixIts;
-    uint64_t
-    GetRetriesWithFixIts();
-
-    bool
-    GetTopLevel();
-
-    void
-    SetTopLevel(bool b = true);
-
-    %feature("docstring", "Gets whether to JIT an expression if it cannot be interpreted.") GetAllowJIT;
-    bool
-    GetAllowJIT();
-
-    %feature("docstring", "Sets whether to JIT an expression if it cannot be interpreted.") SetAllowJIT;
-    void
-    SetAllowJIT(bool allow);
-
-protected:
-
-    SBExpressionOptions (lldb_private::EvaluateExpressionOptions &expression_options);
-
-    lldb_private::EvaluateExpressionOptions *
-    get () const;
-
-    lldb_private::EvaluateExpressionOptions &
-    ref () const;
-
-private:
-    // This auto_pointer is made in the constructor and is always valid.
-    mutable std::unique_ptr<lldb_private::EvaluateExpressionOptions> m_opaque_ap;
-};
-
-} // namespace lldb

lldb/bindings/interface/SBExpressionOptionsDocstrings.i

+%feature("docstring",
+"A container for options to use when evaluating expressions."
+) lldb::SBExpressionOptions;
+
+%feature("docstring", "Sets whether to coerce the expression result to ObjC id type after evaluation."
+) lldb::SBExpressionOptions::SetCoerceResultToId;
+
+%feature("docstring", "Sets whether to unwind the expression stack on error."
+) lldb::SBExpressionOptions::SetUnwindOnError;
+
+%feature("docstring", "Sets whether to ignore breakpoint hits while running expressions."
+) lldb::SBExpressionOptions::SetIgnoreBreakpoints;
+
+%feature("docstring", "Sets whether to cast the expression result to its dynamic type."
+) lldb::SBExpressionOptions::SetFetchDynamicValue;
+
+%feature("docstring", "Sets the timeout in microseconds to run the expression for. If try all threads is set to true and the expression doesn't complete within the specified timeout, all threads will be resumed for the same timeout to see if the expression will finish."
+) lldb::SBExpressionOptions::SetTimeoutInMicroSeconds;
+
+%feature("docstring", "Sets the timeout in microseconds to run the expression on one thread before either timing out or trying all threads."
+) lldb::SBExpressionOptions::SetOneThreadTimeoutInMicroSeconds;
+
+%feature("docstring", "Sets whether to run all threads if the expression does not complete on one thread."
+) lldb::SBExpressionOptions::SetTryAllThreads;
+
+%feature("docstring", "Sets whether to stop other threads at all while running expressions.  If false, TryAllThreads does nothing."
+) lldb::SBExpressionOptions::SetStopOthers;
+
+%feature("docstring", "Sets whether to abort expression evaluation if an exception is thrown while executing.  Don't set this to false unless you know the function you are calling traps all exceptions itself."
+) lldb::SBExpressionOptions::SetTrapExceptions;
+
+%feature ("docstring", "Sets the language that LLDB should assume the expression is written in"
+) lldb::SBExpressionOptions::SetLanguage;
+
+%feature("docstring", "Sets whether to generate debug information for the expression and also controls if a SBModule is generated."
+) lldb::SBExpressionOptions::SetGenerateDebugInfo;
+
+%feature("docstring", "Sets whether to produce a persistent result that can be used in future expressions."
+) lldb::SBExpressionOptions::SetSuppressPersistentResult;
+
+%feature("docstring", "Gets the prefix to use for this expression."
+) lldb::SBExpressionOptions::GetPrefix;
+
+%feature("docstring", "Sets the prefix to use for this expression. This prefix gets inserted after the 'target.expr-prefix' prefix contents, but before the wrapped expression function body."
+) lldb::SBExpressionOptions::SetPrefix;
+
+%feature("docstring", "Sets whether to auto-apply fix-it hints to the expression being evaluated."
+) lldb::SBExpressionOptions::SetAutoApplyFixIts;
+
+%feature("docstring", "Gets whether to auto-apply fix-it hints to an expression."
+) lldb::SBExpressionOptions::GetAutoApplyFixIts;
+
+%feature("docstring", "Sets how often LLDB should retry applying fix-its to an expression."
+) lldb::SBExpressionOptions::SetRetriesWithFixIts;
+
+%feature("docstring", "Gets how often LLDB will retry applying fix-its to an expression."
+) lldb::SBExpressionOptions::GetRetriesWithFixIts;
+
+%feature("docstring", "Gets whether to JIT an expression if it cannot be interpreted."
+) lldb::SBExpressionOptions::GetAllowJIT;
+
+%feature("docstring", "Sets whether to JIT an expression if it cannot be interpreted."
+) lldb::SBExpressionOptions::SetAllowJIT;

lldb/bindings/interface/SBFile.i

-//===-- SWIG Interface for SBFile -----------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-%feature("docstring",
-"Represents a file."
-) SBFile;
-
-class SBFile
-{
-public:
-
-    SBFile();
-
-    %feature("docstring", "
-    Initialize a SBFile from a file descriptor.  mode is
-    'r', 'r+', or 'w', like fdopen.");
-    SBFile(int fd, const char *mode, bool transfer_ownership);
-
-    %feature("docstring", "initialize a SBFile from a python file object");
-    SBFile(FileSP file);
-
-    %extend {
-        static lldb::SBFile MakeBorrowed(lldb::FileSP BORROWED) {
-            return lldb::SBFile(BORROWED);
-        }
-        static lldb::SBFile MakeForcingIOMethods(lldb::FileSP FORCE_IO_METHODS) {
-            return lldb::SBFile(FORCE_IO_METHODS);
-        }
-        static lldb::SBFile MakeBorrowedForcingIOMethods(lldb::FileSP BORROWED_FORCE_IO_METHODS) {
-            return lldb::SBFile(BORROWED_FORCE_IO_METHODS);
-        }
-    }
-
-#ifdef SWIGPYTHON
-    %pythoncode {
-        @classmethod
-        def Create(cls, file, borrow=False, force_io_methods=False):
-            """
-            Create a SBFile from a python file object, with options.
-
-            If borrow is set then the underlying file will
-            not be closed when the SBFile is closed or destroyed.
-
-            If force_scripting_io is set then the python read/write
-            methods will be called even if a file descriptor is available.
-            """
-            if borrow:
-                if force_io_methods:
-                    return cls.MakeBorrowedForcingIOMethods(file)
-                else:
-                    return cls.MakeBorrowed(file)
-            else:
-                if force_io_methods:
-                    return cls.MakeForcingIOMethods(file)
-                else:
-                    return cls(file)
-    }
-#endif
-
-    ~SBFile ();
-
-    %feature("autodoc", "Read(buffer) -> SBError, bytes_read") Read;
-    SBError Read(uint8_t *buf, size_t num_bytes, size_t *OUTPUT);
-
-    %feature("autodoc", "Write(buffer) -> SBError, written_read") Write;
-    SBError Write(const uint8_t *buf, size_t num_bytes, size_t *OUTPUT);
-
-    void Flush();
-
-    bool IsValid() const;
-
-    operator bool() const;
-
-    SBError Close();
-
-    %feature("docstring", "
-    Convert this SBFile into a python io.IOBase file object.
-
-    If the SBFile is itself a wrapper around a python file object,
-    this will return that original object.
-
-    The file returned from here should be considered borrowed,
-    in the sense that you may read and write to it, and flush it,
-    etc, but you should not close it.   If you want to close the
-    SBFile, call SBFile.Close().
-
-    If there is no underlying python file to unwrap, GetFile will
-    use the file descriptor, if available to create a new python
-    file object using ``open(fd, mode=..., closefd=False)``
-    ");
-    FileSP GetFile();
-};
-
-} // namespace lldb

lldb/bindings/interface/SBFileDocstrings.i

+%feature("docstring",
+"Represents a file."
+) lldb::SBFile;
+
+%feature("docstring", "
+Initialize a SBFile from a file descriptor.  mode is
+'r', 'r+', or 'w', like fdopen.") lldb::SBFile::SBFile;
+
+%feature("docstring", "initialize a SBFile from a python file object") lldb::SBFile::SBFile;
+
+%feature("autodoc", "Read(buffer) -> SBError, bytes_read") lldb::SBFile::Read;
+%feature("autodoc", "Write(buffer) -> SBError, written_read") lldb::SBFile::Write;
+
+%feature("docstring", "
+    Convert this SBFile into a python io.IOBase file object.
+
+    If the SBFile is itself a wrapper around a python file object,
+    this will return that original object.
+
+    The file returned from here should be considered borrowed,
+    in the sense that you may read and write to it, and flush it,
+    etc, but you should not close it.   If you want to close the
+    SBFile, call SBFile.Close().
+
+    If there is no underlying python file to unwrap, GetFile will
+    use the file descriptor, if available to create a new python
+    file object using ``open(fd, mode=..., closefd=False)``
+") lldb::SBFile::GetFile;

lldb/bindings/interface/SBFileExtensions.i

+%extend lldb::SBFile {
+    static lldb::SBFile MakeBorrowed(lldb::FileSP BORROWED) {
+        return lldb::SBFile(BORROWED);
+    }
+    static lldb::SBFile MakeForcingIOMethods(lldb::FileSP FORCE_IO_METHODS) {
+        return lldb::SBFile(FORCE_IO_METHODS);
+    }
+    static lldb::SBFile MakeBorrowedForcingIOMethods(lldb::FileSP BORROWED_FORCE_IO_METHODS) {
+        return lldb::SBFile(BORROWED_FORCE_IO_METHODS);
+    }
+
+#ifdef SWIGPYTHON
+    %pythoncode {
+        @classmethod
+        def Create(cls, file, borrow=False, force_io_methods=False):
+            """
+            Create a SBFile from a python file object, with options.
+
+            If borrow is set then the underlying file will
+            not be closed when the SBFile is closed or destroyed.
+
+            If force_scripting_io is set then the python read/write
+            methods will be called even if a file descriptor is available.
+            """
+            if borrow:
+                if force_io_methods:
+                    return cls.MakeBorrowedForcingIOMethods(file)
+                else:
+                    return cls.MakeBorrowed(file)
+            else:
+                if force_io_methods:
+                    return cls.MakeForcingIOMethods(file)
+                else:
+                    return cls(file)
+    }
+#endif
+}

lldb/bindings/interface/SBFileSpec.i

-//===-- SWIG Interface for SBFileSpec ---------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-%feature("docstring",
-"Represents a file specification that divides the path into a directory and
-basename.  The string values of the paths are put into uniqued string pools
-for fast comparisons and efficient memory usage.
-
-For example, the following code ::
-
-        lineEntry = context.GetLineEntry()
-        self.expect(lineEntry.GetFileSpec().GetDirectory(), 'The line entry should have the correct directory',
-                    exe=False,
-            substrs = [self.mydir])
-        self.expect(lineEntry.GetFileSpec().GetFilename(), 'The line entry should have the correct filename',
-                    exe=False,
-            substrs = ['main.c'])
-        self.assertTrue(lineEntry.GetLine() == self.line,
-                        'The line entry's line number should match ')
-
-gets the line entry from the symbol context when a thread is stopped.
-It gets the file spec corresponding to the line entry and checks that
-the filename and the directory matches what we expect.") SBFileSpec;
-class SBFileSpec
-{
-public:
-    SBFileSpec ();
-
-    SBFileSpec (const lldb::SBFileSpec &rhs);
-
-    SBFileSpec (const char *path);// Deprecated, use SBFileSpec (const char *path, bool resolve)
-
-    SBFileSpec (const char *path, bool resolve);
-
-    ~SBFileSpec ();
-
-    bool operator==(const SBFileSpec &rhs) const;
-
-    bool operator!=(const SBFileSpec &rhs) const;
-
-    bool
-    IsValid() const;
-
-    explicit operator bool() const;
-
-    bool
-    Exists () const;
-
-    bool
-    ResolveExecutableLocation ();
-
-    const char *
-    GetFilename() const;
-
-    const char *
-    GetDirectory() const;
-
-    void
-    SetFilename(const char *filename);
-
-    void
-    SetDirectory(const char *directory);
-
-    uint32_t
-    GetPath (char *dst_path, size_t dst_len) const;
-
-    static int
-    ResolvePath (const char *src_path, char *dst_path, size_t dst_len);
-
-    bool
-    GetDescription (lldb::SBStream &description) const;
-
-    void
-    AppendPathComponent (const char *file_or_directory);
-
-    STRING_EXTENSION(SBFileSpec)
-
-#ifdef SWIGPYTHON
-    %pythoncode %{
-        fullpath = property(str, None, doc='''A read only property that returns the fullpath as a python string.''')
-        basename = property(GetFilename, None, doc='''A read only property that returns the path basename as a python string.''')
-        dirname = property(GetDirectory, None, doc='''A read only property that returns the path directory name as a python string.''')
-        exists = property(Exists, None, doc='''A read only property that returns a boolean value that indicates if the file exists.''')
-    %}
-#endif
-
-};
-
-} // namespace lldb

lldb/bindings/interface/SBFileSpecDocstrings.i

+%feature("docstring",
+"Represents a file specification that divides the path into a directory and
+basename.  The string values of the paths are put into uniqued string pools
+for fast comparisons and efficient memory usage.
+
+For example, the following code ::
+
+        lineEntry = context.GetLineEntry()
+        self.expect(lineEntry.GetFileSpec().GetDirectory(), 'The line entry should have the correct directory',
+                    exe=False,
+            substrs = [self.mydir])
+        self.expect(lineEntry.GetFileSpec().GetFilename(), 'The line entry should have the correct filename',
+                    exe=False,
+            substrs = ['main.c'])
+        self.assertTrue(lineEntry.GetLine() == self.line,
+                        'The line entry's line number should match ')
+
+gets the line entry from the symbol context when a thread is stopped.
+It gets the file spec corresponding to the line entry and checks that
+the filename and the directory matches what we expect.") lldb::SBFileSpec;

lldb/bindings/interface/SBFileSpecExtensions.i

+STRING_EXTENSION_OUTSIDE(SBFileSpec)
+
+%extend lldb::SBFileSpec {
+#ifdef SWIGPYTHON
+    %pythoncode %{
+        fullpath = property(str, None, doc='''A read only property that returns the fullpath as a python string.''')
+        basename = property(GetFilename, None, doc='''A read only property that returns the path basename as a python string.''')
+        dirname = property(GetDirectory, None, doc='''A read only property that returns the path directory name as a python string.''')
+        exists = property(Exists, None, doc='''A read only property that returns a boolean value that indicates if the file exists.''')
+    %}
+#endif
+}

lldb/bindings/interface/SBFileSpecList.i

-//===-- SWIG Interface for SBFileSpecList -----------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-%feature("docstring",
-"Represents a list of :py:class:`SBFileSpec`."
-) SBFileSpecList;
-class SBFileSpecList
-{
-public:
-    SBFileSpecList ();
-
-    SBFileSpecList (const lldb::SBFileSpecList &rhs);
-
-    ~SBFileSpecList ();
-
-    uint32_t
-    GetSize () const;
-
-    bool
-    GetDescription (SBStream &description) const;
-
-    void
-    Append (const SBFileSpec &sb_file);
-
-    bool
-    AppendIfUnique (const SBFileSpec &sb_file);
-
-    void
-    Clear();
-
-    uint32_t
-    FindFileIndex (uint32_t idx, const SBFileSpec &sb_file, bool full);
-
-    const SBFileSpec
-    GetFileSpecAtIndex (uint32_t idx) const;
-
-};
-
-
-} // namespace lldb

lldb/bindings/interface/SBFileSpecListDocstrings.i

+%feature("docstring",
+"Represents a list of :py:class:`SBFileSpec`."
+) lldb::SBFileSpecList;

lldb/bindings/interface/SBFrame.i

-//===-- SWIG Interface for SBFrame ------------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-%feature("docstring",
-"Represents one of the stack frames associated with a thread.
-
-SBThread contains SBFrame(s). For example (from test/lldbutil.py), ::
-
-    def print_stacktrace(thread, string_buffer = False):
-        '''Prints a simple stack trace of this thread.'''
-
-        ...
-
-        for i in range(depth):
-            frame = thread.GetFrameAtIndex(i)
-            function = frame.GetFunction()
-
-            load_addr = addrs[i].GetLoadAddress(target)
-            if not function:
-                file_addr = addrs[i].GetFileAddress()
-                start_addr = frame.GetSymbol().GetStartAddress().GetFileAddress()
-                symbol_offset = file_addr - start_addr
-                print >> output, '  frame #{num}: {addr:#016x} {mod}`{symbol} + {offset}'.format(
-                    num=i, addr=load_addr, mod=mods[i], symbol=symbols[i], offset=symbol_offset)
-            else:
-                print >> output, '  frame #{num}: {addr:#016x} {mod}`{func} at {file}:{line} {args}'.format(
-                    num=i, addr=load_addr, mod=mods[i],
-                    func='%s [inlined]' % funcs[i] if frame.IsInlined() else funcs[i],
-                    file=files[i], line=lines[i],
-                    args=get_args_as_string(frame, showFuncName=False) if not frame.IsInlined() else '()')
-
-        ...
-
-And, ::
-
-    for frame in thread:
-        print frame
-
-See also SBThread."
-) SBFrame;
-class SBFrame
-{
-public:
-    SBFrame ();
-
-    SBFrame (const lldb::SBFrame &rhs);
-
-   ~SBFrame();
-
-    bool
-    IsEqual (const lldb::SBFrame &rhs) const;
-
-    bool
-    IsValid() const;
-
-    explicit operator bool() const;
-
-    uint32_t
-    GetFrameID () const;
-
-    %feature("docstring", "
-    Get the Canonical Frame Address for this stack frame.
-    This is the DWARF standard's definition of a CFA, a stack address
-    that remains constant throughout the lifetime of the function.
-    Returns an lldb::addr_t stack address, or LLDB_INVALID_ADDRESS if
-    the CFA cannot be determined.") GetCFA;
-    lldb::addr_t
-    GetCFA () const;
-
-    lldb::addr_t
-    GetPC () const;
-
-    bool
-    SetPC (lldb::addr_t new_pc);
-
-    lldb::addr_t
-    GetSP () const;
-
-    lldb::addr_t
-    GetFP () const;
-
-    lldb::SBAddress
-    GetPCAddress () const;
-
-    lldb::SBSymbolContext
-    GetSymbolContext (uint32_t resolve_scope) const;
-
-    lldb::SBModule
-    GetModule () const;
-
-    lldb::SBCompileUnit
-    GetCompileUnit () const;
-
-    lldb::SBFunction
-    GetFunction () const;
-
-    lldb::SBSymbol
-    GetSymbol () const;
-
-    %feature("docstring", "
-    Gets the deepest block that contains the frame PC.
-
-    See also GetFrameBlock().") GetBlock;
-    lldb::SBBlock
-    GetBlock () const;
-
-    %feature("docstring", "
-    Get the appropriate function name for this frame. Inlined functions in
-    LLDB are represented by Blocks that have inlined function information, so
-    just looking at the SBFunction or SBSymbol for a frame isn't enough.
-    This function will return the appropriate function, symbol or inlined
-    function name for the frame.
-
-    This function returns:
-    - the name of the inlined function (if there is one)
-    - the name of the concrete function (if there is one)
-    - the name of the symbol (if there is one)
-    - NULL
-
-    See also IsInlined().") GetFunctionName;
-    const char *
-    GetFunctionName();
-
-     const char *
-     GetDisplayFunctionName ();
-
-    const char *
-    GetFunctionName() const;
-
-    %feature("docstring", "
-    Returns the language of the frame's SBFunction, or if there.
-    is no SBFunction, guess the language from the mangled name.
-    .") GuessLanguage;
-    lldb::LanguageType
-    GuessLanguage() const;
-
-    %feature("docstring", "
-    Return true if this frame represents an inlined function.
-
-    See also GetFunctionName().") IsInlined;
-    bool
-    IsInlined();
-
-    bool
-    IsInlined() const;
-
-    %feature("docstring", "
-    Return true if this frame is artificial (e.g a frame synthesized to
-    capture a tail call). Local variables may not be available in an artificial
-    frame.") IsArtificial;
-    bool
-    IsArtificial();
-
-    bool
-    IsArtificial() const;
-
-    %feature("docstring", "
-    The version that doesn't supply a 'use_dynamic' value will use the
-    target's default.") EvaluateExpression;
-    lldb::SBValue
-    EvaluateExpression (const char *expr);
-
-    lldb::SBValue
-    EvaluateExpression (const char *expr, lldb::DynamicValueType use_dynamic);
-
-    lldb::SBValue
-    EvaluateExpression (const char *expr, lldb::DynamicValueType use_dynamic, bool unwind_on_error);
-
-    lldb::SBValue
-    EvaluateExpression (const char *expr, SBExpressionOptions &options);
-
-    %feature("docstring", "
-    Gets the lexical block that defines the stack frame. Another way to think
-    of this is it will return the block that contains all of the variables
-    for a stack frame. Inlined functions are represented as SBBlock objects
-    that have inlined function information: the name of the inlined function,
-    where it was called from. The block that is returned will be the first
-    block at or above the block for the PC (SBFrame::GetBlock()) that defines
-    the scope of the frame. When a function contains no inlined functions,
-    this will be the top most lexical block that defines the function.
-    When a function has inlined functions and the PC is currently
-    in one of those inlined functions, this method will return the inlined
-    block that defines this frame. If the PC isn't currently in an inlined
-    function, the lexical block that defines the function is returned.") GetFrameBlock;
-    lldb::SBBlock
-    GetFrameBlock () const;
-
-    lldb::SBLineEntry
-    GetLineEntry () const;
-
-    lldb::SBThread
-    GetThread () const;
-
-    const char *
-    Disassemble () const;
-
-    void
-    Clear();
-
-    bool
-    operator == (const lldb::SBFrame &rhs) const;
-
-    bool
-    operator != (const lldb::SBFrame &rhs) const;
-
-    %feature("docstring", "
-    The version that doesn't supply a 'use_dynamic' value will use the
-    target's default.") GetVariables;
-    lldb::SBValueList
-    GetVariables (bool arguments,
-                  bool locals,
-                  bool statics,
-                  bool in_scope_only);
-
-    lldb::SBValueList
-    GetVariables (bool arguments,
-                  bool locals,
-                  bool statics,
-                  bool in_scope_only,
-                  lldb::DynamicValueType  use_dynamic);
-
-    lldb::SBValueList
-    GetVariables (const lldb::SBVariablesOptions& options);
-
-    lldb::SBValueList
-    GetRegisters ();
-
-    %feature("docstring", "
-    The version that doesn't supply a 'use_dynamic' value will use the
-    target's default.") FindVariable;
-    lldb::SBValue
-    FindVariable (const char *var_name);
-
-    lldb::SBValue
-    FindVariable (const char *var_name, lldb::DynamicValueType use_dynamic);
-
-    lldb::SBValue
-    FindRegister (const char *name);
-
-    %feature("docstring", "
-    Get a lldb.SBValue for a variable path.
-
-    Variable paths can include access to pointer or instance members: ::
-
-        rect_ptr->origin.y
-        pt.x
-
-    Pointer dereferences: ::
-
-        *this->foo_ptr
-        **argv
-
-    Address of: ::
-
-        &pt
-        &my_array[3].x
-
-    Array accesses and treating pointers as arrays: ::
-
-        int_array[1]
-        pt_ptr[22].x
-
-    Unlike `EvaluateExpression()` which returns :py:class:`SBValue` objects
-    with constant copies of the values at the time of evaluation,
-    the result of this function is a value that will continue to
-    track the current value of the value as execution progresses
-    in the current frame.") GetValueForVariablePath;
-    lldb::SBValue
-    GetValueForVariablePath (const char *var_path);
-
-    lldb::SBValue
-    GetValueForVariablePath (const char *var_path, lldb::DynamicValueType use_dynamic);
-
-    %feature("docstring", "
-    Find variables, register sets, registers, or persistent variables using
-    the frame as the scope.
-
-    The version that doesn't supply a ``use_dynamic`` value will use the
-    target's default.") FindValue;
-    lldb::SBValue
-    FindValue (const char *name, ValueType value_type);
-
-    lldb::SBValue
-    FindValue (const char *name, ValueType value_type, lldb::DynamicValueType use_dynamic);
-
-    bool
-    GetDescription (lldb::SBStream &description);
-
-    STRING_EXTENSION(SBFrame)
-
-#ifdef SWIGPYTHON
-    %pythoncode %{
-        def get_all_variables(self):
-            return self.GetVariables(True,True,True,True)
-
-        def get_parent_frame(self):
-            parent_idx = self.idx + 1
-            if parent_idx >= 0 and parent_idx < len(self.thread.frame):
-                return self.thread.frame[parent_idx]
-            else:
-                return SBFrame()
-
-        def get_arguments(self):
-            return self.GetVariables(True,False,False,False)
-
-        def get_locals(self):
-            return self.GetVariables(False,True,False,False)
-
-        def get_statics(self):
-            return self.GetVariables(False,False,True,False)
-
-        def var(self, var_expr_path):
-            '''Calls through to lldb.SBFrame.GetValueForVariablePath() and returns
-            a value that represents the variable expression path'''
-            return self.GetValueForVariablePath(var_expr_path)
-
-        def get_registers_access(self):
-            class registers_access(object):
-                '''A helper object that exposes a flattened view of registers, masking away the notion of register sets for easy scripting.'''
-                def __init__(self, regs):
-                    self.regs = regs
-
-                def __getitem__(self, key):
-                    if type(key) is str:
-                        for i in range(0,len(self.regs)):
-                            rs = self.regs[i]
-                            for j in range (0,rs.num_children):
-                                reg = rs.GetChildAtIndex(j)
-                                if reg.name == key: return reg
-                    else:
-                        return lldb.SBValue()
-
-            return registers_access(self.registers)
-
-        pc = property(GetPC, SetPC)
-        addr = property(GetPCAddress, None, doc='''A read only property that returns the program counter (PC) as a section offset address (lldb.SBAddress).''')
-        fp = property(GetFP, None, doc='''A read only property that returns the frame pointer (FP) as an unsigned integer.''')
-        sp = property(GetSP, None, doc='''A read only property that returns the stack pointer (SP) as an unsigned integer.''')
-        module = property(GetModule, None, doc='''A read only property that returns an lldb object that represents the module (lldb.SBModule) for this stack frame.''')
-        compile_unit = property(GetCompileUnit, None, doc='''A read only property that returns an lldb object that represents the compile unit (lldb.SBCompileUnit) for this stack frame.''')
-        function = property(GetFunction, None, doc='''A read only property that returns an lldb object that represents the function (lldb.SBFunction) for this stack frame.''')
-        symbol = property(GetSymbol, None, doc='''A read only property that returns an lldb object that represents the symbol (lldb.SBSymbol) for this stack frame.''')
-        block = property(GetBlock, None, doc='''A read only property that returns an lldb object that represents the block (lldb.SBBlock) for this stack frame.''')
-        is_inlined = property(IsInlined, None, doc='''A read only property that returns an boolean that indicates if the block frame is an inlined function.''')
-        name = property(GetFunctionName, None, doc='''A read only property that retuns the name for the function that this frame represents. Inlined stack frame might have a concrete function that differs from the name of the inlined function (a named lldb.SBBlock).''')
-        line_entry = property(GetLineEntry, None, doc='''A read only property that returns an lldb object that represents the line table entry (lldb.SBLineEntry) for this stack frame.''')
-        thread = property(GetThread, None, doc='''A read only property that returns an lldb object that represents the thread (lldb.SBThread) for this stack frame.''')
-        disassembly = property(Disassemble, None, doc='''A read only property that returns the disassembly for this stack frame as a python string.''')
-        idx = property(GetFrameID, None, doc='''A read only property that returns the zero based stack frame index.''')
-        variables = property(get_all_variables, None, doc='''A read only property that returns a list() that contains a collection of lldb.SBValue objects that represent the variables in this stack frame.''')
-        vars = property(get_all_variables, None, doc='''A read only property that returns a list() that contains a collection of lldb.SBValue objects that represent the variables in this stack frame.''')
-        locals = property(get_locals, None, doc='''A read only property that returns a list() that contains a collection of lldb.SBValue objects that represent the local variables in this stack frame.''')
-        args = property(get_arguments, None, doc='''A read only property that returns a list() that contains a collection of lldb.SBValue objects that represent the argument variables in this stack frame.''')
-        arguments = property(get_arguments, None, doc='''A read only property that returns a list() that contains a collection of lldb.SBValue objects that represent the argument variables in this stack frame.''')
-        statics = property(get_statics, None, doc='''A read only property that returns a list() that contains a collection of lldb.SBValue objects that represent the static variables in this stack frame.''')
-        registers = property(GetRegisters, None, doc='''A read only property that returns a list() that contains a collection of lldb.SBValue objects that represent the CPU registers for this stack frame.''')
-        regs = property(GetRegisters, None, doc='''A read only property that returns a list() that contains a collection of lldb.SBValue objects that represent the CPU registers for this stack frame.''')
-        register = property(get_registers_access, None, doc='''A read only property that returns an helper object providing a flattened indexable view of the CPU registers for this stack frame.''')
-        reg = property(get_registers_access, None, doc='''A read only property that returns an helper object providing a flattened indexable view of the CPU registers for this stack frame''')
-        parent = property(get_parent_frame, None, doc='''A read only property that returns the parent (caller) frame of the current frame.''')
-    %}
-#endif
-};
-
-} // namespace lldb

lldb/bindings/interface/SBFrameDocstrings.i

+%feature("docstring",
+"Represents one of the stack frames associated with a thread.
+
+SBThread contains SBFrame(s). For example (from test/lldbutil.py), ::
+
+    def print_stacktrace(thread, string_buffer = False):
+        '''Prints a simple stack trace of this thread.'''
+
+        ...
+
+        for i in range(depth):
+            frame = thread.GetFrameAtIndex(i)
+            function = frame.GetFunction()
+
+            load_addr = addrs[i].GetLoadAddress(target)
+            if not function:
+                file_addr = addrs[i].GetFileAddress()
+                start_addr = frame.GetSymbol().GetStartAddress().GetFileAddress()
+                symbol_offset = file_addr - start_addr
+                print >> output, '  frame #{num}: {addr:#016x} {mod}`{symbol} + {offset}'.format(
+                    num=i, addr=load_addr, mod=mods[i], symbol=symbols[i], offset=symbol_offset)
+            else:
+                print >> output, '  frame #{num}: {addr:#016x} {mod}`{func} at {file}:{line} {args}'.format(
+                    num=i, addr=load_addr, mod=mods[i],
+                    func='%s [inlined]' % funcs[i] if frame.IsInlined() else funcs[i],
+                    file=files[i], line=lines[i],
+                    args=get_args_as_string(frame, showFuncName=False) if not frame.IsInlined() else '()')
+
+        ...
+
+And, ::
+
+    for frame in thread:
+        print frame
+
+See also SBThread."
+) lldb::SBFrame;
+
+%feature("docstring", "
+    Get the Canonical Frame Address for this stack frame.
+    This is the DWARF standard's definition of a CFA, a stack address
+    that remains constant throughout the lifetime of the function.
+    Returns an lldb::addr_t stack address, or LLDB_INVALID_ADDRESS if
+    the CFA cannot be determined."
+) lldb::SBFrame::GetCFA;
+
+%feature("docstring", "
+    Gets the deepest block that contains the frame PC.
+
+    See also GetFrameBlock()."
+) lldb::SBFrame::GetBlock;
+
+    %feature("docstring", "
+    Get the appropriate function name for this frame. Inlined functions in
+    LLDB are represented by Blocks that have inlined function information, so
+    just looking at the SBFunction or SBSymbol for a frame isn't enough.
+    This function will return the appropriate function, symbol or inlined
+    function name for the frame.
+
+    This function returns:
+    - the name of the inlined function (if there is one)
+    - the name of the concrete function (if there is one)
+    - the name of the symbol (if there is one)
+    - NULL
+
+    See also IsInlined()."
+) lldb::SBFrame::GetFunctionName;
+
+%feature("docstring", "
+    Returns the language of the frame's SBFunction, or if there.
+    is no SBFunction, guess the language from the mangled name.
+    ."
+) lldb::SBFrame::GuessLanguage;
+
+%feature("docstring", "
+    Return true if this frame represents an inlined function.
+
+    See also GetFunctionName()."
+) lldb::SBFrame::IsInlined;
+
+%feature("docstring", "
+    Return true if this frame is artificial (e.g a frame synthesized to
+    capture a tail call). Local variables may not be available in an artificial
+    frame."
+) lldb::SBFrame::IsArtificial;
+
+%feature("docstring", "
+    The version that doesn't supply a 'use_dynamic' value will use the
+    target's default."
+) lldb::SBFrame::EvaluateExpression;
+
+%feature("docstring", "
+    Gets the lexical block that defines the stack frame. Another way to think
+    of this is it will return the block that contains all of the variables
+    for a stack frame. Inlined functions are represented as SBBlock objects
+    that have inlined function information: the name of the inlined function,
+    where it was called from. The block that is returned will be the first
+    block at or above the block for the PC (SBFrame::GetBlock()) that defines
+    the scope of the frame. When a function contains no inlined functions,
+    this will be the top most lexical block that defines the function.
+    When a function has inlined functions and the PC is currently
+    in one of those inlined functions, this method will return the inlined
+    block that defines this frame. If the PC isn't currently in an inlined
+    function, the lexical block that defines the function is returned."
+) lldb::SBFrame::GetFrameBlock;
+
+%feature("docstring", "
+    The version that doesn't supply a 'use_dynamic' value will use the
+    target's default."
+) lldb::SBFrame::GetVariables;
+
+%feature("docstring", "
+    The version that doesn't supply a 'use_dynamic' value will use the
+    target's default."
+) lldb::SBFrame::FindVariable;
+
+%feature("docstring", "
+    Get a lldb.SBValue for a variable path.
+
+    Variable paths can include access to pointer or instance members: ::
+
+        rect_ptr->origin.y
+        pt.x
+
+    Pointer dereferences: ::
+
+        *this->foo_ptr
+        **argv
+
+    Address of: ::
+
+        &pt
+        &my_array[3].x
+
+    Array accesses and treating pointers as arrays: ::
+
+        int_array[1]
+        pt_ptr[22].x
+
+    Unlike `EvaluateExpression()` which returns :py:class:`SBValue` objects
+    with constant copies of the values at the time of evaluation,
+    the result of this function is a value that will continue to
+    track the current value of the value as execution progresses
+    in the current frame."
+) lldb::SBFrame::GetValueForVariablePath;
+
+%feature("docstring", "
+    Find variables, register sets, registers, or persistent variables using
+    the frame as the scope.
+
+    The version that doesn't supply a ``use_dynamic`` value will use the
+    target's default."
+) lldb::SBFrame::FindValue;

lldb/bindings/interface/SBFrameExtensions.i

+STRING_EXTENSION_OUTSIDE(SBFrame)
+
+%extend lldb::SBFrame {
+#ifdef SWIGPYTHON
+    %pythoncode %{
+        def get_all_variables(self):
+            return self.GetVariables(True,True,True,True)
+
+        def get_parent_frame(self):
+            parent_idx = self.idx + 1
+            if parent_idx >= 0 and parent_idx < len(self.thread.frame):
+                return self.thread.frame[parent_idx]
+            else:
+                return SBFrame()
+
+        def get_arguments(self):
+            return self.GetVariables(True,False,False,False)
+
+        def get_locals(self):
+            return self.GetVariables(False,True,False,False)
+
+        def get_statics(self):
+            return self.GetVariables(False,False,True,False)
+
+        def var(self, var_expr_path):
+            '''Calls through to lldb.SBFrame.GetValueForVariablePath() and returns
+            a value that represents the variable expression path'''
+            return self.GetValueForVariablePath(var_expr_path)
+
+        def get_registers_access(self):
+            class registers_access(object):
+                '''A helper object that exposes a flattened view of registers, masking away the notion of register sets for easy scripting.'''
+                def __init__(self, regs):
+                    self.regs = regs
+
+                def __getitem__(self, key):
+                    if type(key) is str:
+                        for i in range(0,len(self.regs)):
+                            rs = self.regs[i]
+                            for j in range (0,rs.num_children):
+                                reg = rs.GetChildAtIndex(j)
+                                if reg.name == key: return reg
+                    else:
+                        return lldb.SBValue()
+
+            return registers_access(self.registers)
+
+        pc = property(GetPC, SetPC)
+        addr = property(GetPCAddress, None, doc='''A read only property that returns the program counter (PC) as a section offset address (lldb.SBAddress).''')
+        fp = property(GetFP, None, doc='''A read only property that returns the frame pointer (FP) as an unsigned integer.''')
+        sp = property(GetSP, None, doc='''A read only property that returns the stack pointer (SP) as an unsigned integer.''')
+        module = property(GetModule, None, doc='''A read only property that returns an lldb object that represents the module (lldb.SBModule) for this stack frame.''')
+        compile_unit = property(GetCompileUnit, None, doc='''A read only property that returns an lldb object that represents the compile unit (lldb.SBCompileUnit) for this stack frame.''')
+        function = property(GetFunction, None, doc='''A read only property that returns an lldb object that represents the function (lldb.SBFunction) for this stack frame.''')
+        symbol = property(GetSymbol, None, doc='''A read only property that returns an lldb object that represents the symbol (lldb.SBSymbol) for this stack frame.''')
+        block = property(GetBlock, None, doc='''A read only property that returns an lldb object that represents the block (lldb.SBBlock) for this stack frame.''')
+        is_inlined = property(IsInlined, None, doc='''A read only property that returns an boolean that indicates if the block frame is an inlined function.''')
+        name = property(GetFunctionName, None, doc='''A read only property that retuns the name for the function that this frame represents. Inlined stack frame might have a concrete function that differs from the name of the inlined function (a named lldb.SBBlock).''')
+        line_entry = property(GetLineEntry, None, doc='''A read only property that returns an lldb object that represents the line table entry (lldb.SBLineEntry) for this stack frame.''')
+        thread = property(GetThread, None, doc='''A read only property that returns an lldb object that represents the thread (lldb.SBThread) for this stack frame.''')
+        disassembly = property(Disassemble, None, doc='''A read only property that returns the disassembly for this stack frame as a python string.''')
+        idx = property(GetFrameID, None, doc='''A read only property that returns the zero based stack frame index.''')
+        variables = property(get_all_variables, None, doc='''A read only property that returns a list() that contains a collection of lldb.SBValue objects that represent the variables in this stack frame.''')
+        vars = property(get_all_variables, None, doc='''A read only property that returns a list() that contains a collection of lldb.SBValue objects that represent the variables in this stack frame.''')
+        locals = property(get_locals, None, doc='''A read only property that returns a list() that contains a collection of lldb.SBValue objects that represent the local variables in this stack frame.''')
+        args = property(get_arguments, None, doc='''A read only property that returns a list() that contains a collection of lldb.SBValue objects that represent the argument variables in this stack frame.''')
+        arguments = property(get_arguments, None, doc='''A read only property that returns a list() that contains a collection of lldb.SBValue objects that represent the argument variables in this stack frame.''')
+        statics = property(get_statics, None, doc='''A read only property that returns a list() that contains a collection of lldb.SBValue objects that represent the static variables in this stack frame.''')
+        registers = property(GetRegisters, None, doc='''A read only property that returns a list() that contains a collection of lldb.SBValue objects that represent the CPU registers for this stack frame.''')
+        regs = property(GetRegisters, None, doc='''A read only property that returns a list() that contains a collection of lldb.SBValue objects that represent the CPU registers for this stack frame.''')
+        register = property(get_registers_access, None, doc='''A read only property that returns an helper object providing a flattened indexable view of the CPU registers for this stack frame.''')
+        reg = property(get_registers_access, None, doc='''A read only property that returns an helper object providing a flattened indexable view of the CPU registers for this stack frame''')
+        parent = property(get_parent_frame, None, doc='''A read only property that returns the parent (caller) frame of the current frame.''')
+    %}
+#endif
+}

lldb/bindings/interface/SBFunction.i

-//===-- SWIG Interface for SBFunction ---------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-%feature("docstring",
-"Represents a generic function, which can be inlined or not.
-
-For example (from test/lldbutil.py, but slightly modified for doc purpose),::
-
-        ...
-
-        frame = thread.GetFrameAtIndex(i)
-        addr = frame.GetPCAddress()
-        load_addr = addr.GetLoadAddress(target)
-        function = frame.GetFunction()
-        mod_name = frame.GetModule().GetFileSpec().GetFilename()
-
-        if not function:
-            # No debug info for 'function'.
-            symbol = frame.GetSymbol()
-            file_addr = addr.GetFileAddress()
-            start_addr = symbol.GetStartAddress().GetFileAddress()
-            symbol_name = symbol.GetName()
-            symbol_offset = file_addr - start_addr
-            print >> output, '  frame #{num}: {addr:#016x} {mod}`{symbol} + {offset}'.format(
-                num=i, addr=load_addr, mod=mod_name, symbol=symbol_name, offset=symbol_offset)
-        else:
-            # Debug info is available for 'function'.
-            func_name = frame.GetFunctionName()
-            file_name = frame.GetLineEntry().GetFileSpec().GetFilename()
-            line_num = frame.GetLineEntry().GetLine()
-            print >> output, '  frame #{num}: {addr:#016x} {mod}`{func} at {file}:{line} {args}'.format(
-                num=i, addr=load_addr, mod=mod_name,
-                func='%s [inlined]' % func_name] if frame.IsInlined() else func_name,
-                file=file_name, line=line_num, args=get_args_as_string(frame, showFuncName=False))
-
-        ...") SBFunction;
-class SBFunction
-{
-public:
-
-    SBFunction ();
-
-    SBFunction (const lldb::SBFunction &rhs);
-
-    ~SBFunction ();
-
-    bool
-    IsValid () const;
-
-    explicit operator bool() const;
-
-    const char *
-    GetName() const;
-
-    const char *
-    GetDisplayName() const;
-
-    const char *
-    GetMangledName () const;
-
-    lldb::SBInstructionList
-    GetInstructions (lldb::SBTarget target);
-
-    lldb::SBInstructionList
-    GetInstructions (lldb::SBTarget target, const char *flavor);
-
-    lldb::SBAddress
-    GetStartAddress ();
-
-    lldb::SBAddress
-    GetEndAddress ();
-
-    const char *
-    GetArgumentName (uint32_t arg_idx);
-
-    uint32_t
-    GetPrologueByteSize ();
-
-    lldb::SBType
-    GetType ();
-
-    lldb::SBBlock
-    GetBlock ();
-
-    lldb::LanguageType
-    GetLanguage ();
-
-    %feature("docstring", "
-    Returns true if the function was compiled with optimization.
-    Optimization, in this case, is meant to indicate that the debugger
-    experience may be confusing for the user -- variables optimized away,
-    stepping jumping between source lines -- and the driver may want to
-    provide some guidance to the user about this.
-    Returns false if unoptimized, or unknown.") GetIsOptimized;
-    bool
-    GetIsOptimized();
-
-    bool
-    GetDescription (lldb::SBStream &description);
-
-    bool
-    operator == (const lldb::SBFunction &rhs) const;
-
-    bool
-    operator != (const lldb::SBFunction &rhs) const;
-
-    STRING_EXTENSION(SBFunction)
-
-#ifdef SWIGPYTHON
-    %pythoncode %{
-        def get_instructions_from_current_target (self):
-            return self.GetInstructions (target)
-
-        addr = property(GetStartAddress, None, doc='''A read only property that returns an lldb object that represents the start address (lldb.SBAddress) for this function.''')
-        end_addr = property(GetEndAddress, None, doc='''A read only property that returns an lldb object that represents the end address (lldb.SBAddress) for this function.''')
-        block = property(GetBlock, None, doc='''A read only property that returns an lldb object that represents the top level lexical block (lldb.SBBlock) for this function.''')
-        instructions = property(get_instructions_from_current_target, None, doc='''A read only property that returns an lldb object that represents the instructions (lldb.SBInstructionList) for this function.''')
-        mangled = property(GetMangledName, None, doc='''A read only property that returns the mangled (linkage) name for this function as a string.''')
-        name = property(GetName, None, doc='''A read only property that returns the name for this function as a string.''')
-        prologue_size = property(GetPrologueByteSize, None, doc='''A read only property that returns the size in bytes of the prologue instructions as an unsigned integer.''')
-        type = property(GetType, None, doc='''A read only property that returns an lldb object that represents the return type (lldb.SBType) for this function.''')
-    %}
-#endif
-
-};
-
-} // namespace lldb

lldb/bindings/interface/SBFunctionDocstrings.i

+%feature("docstring",
+"Represents a generic function, which can be inlined or not.
+
+For example (from test/lldbutil.py, but slightly modified for doc purpose),::
+
+        ...
+
+        frame = thread.GetFrameAtIndex(i)
+        addr = frame.GetPCAddress()
+        load_addr = addr.GetLoadAddress(target)
+        function = frame.GetFunction()
+        mod_name = frame.GetModule().GetFileSpec().GetFilename()
+
+        if not function:
+            # No debug info for 'function'.
+            symbol = frame.GetSymbol()
+            file_addr = addr.GetFileAddress()
+            start_addr = symbol.GetStartAddress().GetFileAddress()
+            symbol_name = symbol.GetName()
+            symbol_offset = file_addr - start_addr
+            print >> output, '  frame #{num}: {addr:#016x} {mod}`{symbol} + {offset}'.format(
+                num=i, addr=load_addr, mod=mod_name, symbol=symbol_name, offset=symbol_offset)
+        else:
+            # Debug info is available for 'function'.
+            func_name = frame.GetFunctionName()
+            file_name = frame.GetLineEntry().GetFileSpec().GetFilename()
+            line_num = frame.GetLineEntry().GetLine()
+            print >> output, '  frame #{num}: {addr:#016x} {mod}`{func} at {file}:{line} {args}'.format(
+                num=i, addr=load_addr, mod=mod_name,
+                func='%s [inlined]' % func_name] if frame.IsInlined() else func_name,
+                file=file_name, line=line_num, args=get_args_as_string(frame, showFuncName=False))
+
+        ..."
+) lldb::SBFunction;
+
+%feature("docstring", "
+    Returns true if the function was compiled with optimization.
+    Optimization, in this case, is meant to indicate that the debugger
+    experience may be confusing for the user -- variables optimized away,
+    stepping jumping between source lines -- and the driver may want to
+    provide some guidance to the user about this.
+    Returns false if unoptimized, or unknown."
+) lldb::SBFunction::GetIsOptimized;

lldb/bindings/interface/SBFunctionExtensions.i

+STRING_EXTENSION_OUTSIDE(SBFunction)
+
+%extend lldb::SBFunction {
+#ifdef SWIGPYTHON
+    %pythoncode %{
+        def get_instructions_from_current_target (self):
+            return self.GetInstructions (target)
+
+        addr = property(GetStartAddress, None, doc='''A read only property that returns an lldb object that represents the start address (lldb.SBAddress) for this function.''')
+        end_addr = property(GetEndAddress, None, doc='''A read only property that returns an lldb object that represents the end address (lldb.SBAddress) for this function.''')
+        block = property(GetBlock, None, doc='''A read only property that returns an lldb object that represents the top level lexical block (lldb.SBBlock) for this function.''')
+        instructions = property(get_instructions_from_current_target, None, doc='''A read only property that returns an lldb object that represents the instructions (lldb.SBInstructionList) for this function.''')
+        mangled = property(GetMangledName, None, doc='''A read only property that returns the mangled (linkage) name for this function as a string.''')
+        name = property(GetName, None, doc='''A read only property that returns the name for this function as a string.''')
+        prologue_size = property(GetPrologueByteSize, None, doc='''A read only property that returns the size in bytes of the prologue instructions as an unsigned integer.''')
+        type = property(GetType, None, doc='''A read only property that returns an lldb object that represents the return type (lldb.SBType) for this function.''')
+    %}
+#endif
+}

lldb/bindings/interface/SBHostOS.i

-//===-- SWIG Interface for SBHostOS -----------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-%feature("docstring",
-"Provides information about the host system."
-) SBHostOS;
-class SBHostOS
-{
-public:
-
-    static lldb::SBFileSpec
-    GetProgramFileSpec ();
-
-    static lldb::SBFileSpec
-    GetLLDBPythonPath ();
-
-    static lldb::SBFileSpec
-    GetLLDBPath (lldb::PathType path_type);
-
-    static lldb::SBFileSpec
-    GetUserHomeDirectory ();
-
-    static void
-    ThreadCreated (const char *name);
-
-    static lldb::thread_t
-    ThreadCreate (const char *name,
-                  lldb::thread_func_t,
-                  void *thread_arg,
-                  lldb::SBError *err);
-
-    static bool
-    ThreadCancel (lldb::thread_t thread,
-                  lldb::SBError *err);
-
-    static bool
-    ThreadDetach (lldb::thread_t thread,
-                  lldb::SBError *err);
-    static bool
-    ThreadJoin (lldb::thread_t thread,
-                lldb::thread_result_t *result,
-                lldb::SBError *err);
-};
-
-} // namespace lldb

lldb/bindings/interface/SBHostOSDocstrings.i

+%feature("docstring",
+"Provides information about the host system."
+) lldb::SBHostOS;

lldb/bindings/interface/SBInstruction.i

-//===-- SWIG Interface for SBInstruction ------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <stdio.h>
-
-// There's a lot to be fixed here, but need to wait for underlying insn implementation
-// to be revised & settle down first.
-
-namespace lldb {
-
-%feature("docstring",
-"Represents a (machine language) instruction."
-) SBInstruction;
-class SBInstruction
-{
-public:
-
-    SBInstruction ();
-
-    SBInstruction (const SBInstruction &rhs);
-
-    ~SBInstruction ();
-
-    bool
-    IsValid();
-
-    explicit operator bool() const;
-
-    lldb::SBAddress
-    GetAddress();
-
-
-    const char *
-    GetMnemonic (lldb::SBTarget target);
-
-    const char *
-    GetOperands (lldb::SBTarget target);
-
-    const char *
-    GetComment (lldb::SBTarget target);
-
-    lldb::InstructionControlFlowKind
-    GetControlFlowKind(lldb::SBTarget target);
-
-    lldb::SBData
-    GetData (lldb::SBTarget target);
-
-    size_t
-    GetByteSize ();
-
-    bool
-    DoesBranch ();
-
-    bool
-    HasDelaySlot ();
-
-    bool
-    CanSetBreakpoint ();
-
-    void
-    Print (lldb::SBFile out);
-
-    void
-    Print (lldb::FileSP BORROWED);
-
-    bool
-    GetDescription (lldb::SBStream &description);
-
-    bool
-    EmulateWithFrame (lldb::SBFrame &frame, uint32_t evaluate_options);
-
-    bool
-    DumpEmulation (const char * triple); // triple is to specify the architecture, e.g. 'armv6' or 'armv7-apple-ios'
-
-    bool
-    TestEmulation (lldb::SBStream &output_stream, const char *test_file);
-
-    STRING_EXTENSION(SBInstruction)
-
-#ifdef SWIGPYTHON
-    %pythoncode %{
-        def __mnemonic_property__ (self):
-            return self.GetMnemonic (target)
-        def __operands_property__ (self):
-            return self.GetOperands (target)
-        def __comment_property__ (self):
-            return self.GetComment (target)
-        def __file_addr_property__ (self):
-            return self.GetAddress ().GetFileAddress()
-        def __load_adrr_property__ (self):
-            return self.GetComment (target)
-
-        mnemonic = property(__mnemonic_property__, None, doc='''A read only property that returns the mnemonic for this instruction as a string.''')
-        operands = property(__operands_property__, None, doc='''A read only property that returns the operands for this instruction as a string.''')
-        comment = property(__comment_property__, None, doc='''A read only property that returns the comment for this instruction as a string.''')
-        addr = property(GetAddress, None, doc='''A read only property that returns an lldb object that represents the address (lldb.SBAddress) for this instruction.''')
-        size = property(GetByteSize, None, doc='''A read only property that returns the size in bytes for this instruction as an integer.''')
-        is_branch = property(DoesBranch, None, doc='''A read only property that returns a boolean value that indicates if this instruction is a branch instruction.''')
-    %}
-#endif
-
-
-};
-
-} // namespace lldb

lldb/bindings/interface/SBInstructionDocstrings.i

+%feature("docstring",
+"Represents a (machine language) instruction."
+) lldb::SBInstruction;

lldb/bindings/interface/SBInstructionExtensions.i

+STRING_EXTENSION_OUTSIDE(SBInstruction)
+
+%extend lldb::SBInstruction {
+#ifdef SWIGPYTHON
+    %pythoncode %{
+        def __mnemonic_property__ (self):
+            return self.GetMnemonic (target)
+        def __operands_property__ (self):
+            return self.GetOperands (target)
+        def __comment_property__ (self):
+            return self.GetComment (target)
+        def __file_addr_property__ (self):
+            return self.GetAddress ().GetFileAddress()
+        def __load_adrr_property__ (self):
+            return self.GetComment (target)
+
+        mnemonic = property(__mnemonic_property__, None, doc='''A read only property that returns the mnemonic for this instruction as a string.''')
+        operands = property(__operands_property__, None, doc='''A read only property that returns the operands for this instruction as a string.''')
+        comment = property(__comment_property__, None, doc='''A read only property that returns the comment for this instruction as a string.''')
+        addr = property(GetAddress, None, doc='''A read only property that returns an lldb object that represents the address (lldb.SBAddress) for this instruction.''')
+        size = property(GetByteSize, None, doc='''A read only property that returns the size in bytes for this instruction as an integer.''')
+        is_branch = property(DoesBranch, None, doc='''A read only property that returns a boolean value that indicates if this instruction is a branch instruction.''')
+    %}
+#endif
+}

lldb/bindings/interface/SBInstructionList.i

-//===-- SWIG Interface for SBInstructionList --------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <stdio.h>
-
-namespace lldb {
-
-%feature("docstring",
-"Represents a list of machine instructions.  SBFunction and SBSymbol have
-GetInstructions() methods which return SBInstructionList instances.
-
-SBInstructionList supports instruction (:py:class:`SBInstruction` instance) iteration.
-For example (see also :py:class:`SBDebugger` for a more complete example), ::
-
-    def disassemble_instructions (insts):
-        for i in insts:
-            print i
-
-defines a function which takes an SBInstructionList instance and prints out
-the machine instructions in assembly format."
-) SBInstructionList;
-class SBInstructionList
-{
-public:
-
-    SBInstructionList ();
-
-    SBInstructionList (const SBInstructionList &rhs);
-
-    ~SBInstructionList ();
-
-    bool
-    IsValid () const;
-
-    explicit operator bool() const;
-
-    size_t
-    GetSize ();
-
-    lldb::SBInstruction
-    GetInstructionAtIndex (uint32_t idx);
-
-    size_t GetInstructionsCount(const SBAddress &start, const SBAddress &end,
-                                bool canSetBreakpoint);
-
-    void
-    Clear ();
-
-    void
-    AppendInstruction (lldb::SBInstruction inst);
-
-    void
-    Print (lldb::SBFile out);
-
-    void
-    Print (lldb::FileSP BORROWED);
-
-    bool
-    GetDescription (lldb::SBStream &description);
-
-    bool
-    DumpEmulationForAllInstructions (const char *triple);
-
-    STRING_EXTENSION(SBInstructionList)
-
-#ifdef SWIGPYTHON
-    %pythoncode %{
-        def __iter__(self):
-            '''Iterate over all instructions in a lldb.SBInstructionList
-            object.'''
-            return lldb_iter(self, 'GetSize', 'GetInstructionAtIndex')
-
-        def __len__(self):
-            '''Access len of the instruction list.'''
-            return int(self.GetSize())
-
-        def __getitem__(self, key):
-            '''Access instructions by integer index for array access or by lldb.SBAddress to find an instruction that matches a section offset address object.'''
-            if type(key) is int:
-                # Find an instruction by index
-                count = len(self)
-                if -count <= key < count:
-                    key %= count
-                    return self.GetInstructionAtIndex(key)
-            elif type(key) is SBAddress:
-                # Find an instruction using a lldb.SBAddress object
-                lookup_file_addr = key.file_addr
-                closest_inst = None
-                for idx in range(self.GetSize()):
-                    inst = self.GetInstructionAtIndex(idx)
-                    inst_file_addr = inst.addr.file_addr
-                    if inst_file_addr == lookup_file_addr:
-                        return inst
-                    elif inst_file_addr > lookup_file_addr:
-                        return closest_inst
-                    else:
-                        closest_inst = inst
-            return None
-    %}
-#endif
-
-};
-
-} // namespace lldb

lldb/bindings/interface/SBInstructionListDocstrings.i

+%feature("docstring",
+"Represents a list of machine instructions.  SBFunction and SBSymbol have
+GetInstructions() methods which return SBInstructionList instances.
+
+SBInstructionList supports instruction (:py:class:`SBInstruction` instance) iteration.
+For example (see also :py:class:`SBDebugger` for a more complete example), ::
+
+    def disassemble_instructions (insts):
+        for i in insts:
+            print i
+
+defines a function which takes an SBInstructionList instance and prints out
+the machine instructions in assembly format."
+) lldb::SBInstructionList;

lldb/bindings/interface/SBInstructionListExtensions.i

+STRING_EXTENSION_OUTSIDE(SBInstructionList)
+
+%extend lldb::SBInstructionList {
+#ifdef SWIGPYTHON
+    %pythoncode %{
+        def __iter__(self):
+            '''Iterate over all instructions in a lldb.SBInstructionList
+            object.'''
+            return lldb_iter(self, 'GetSize', 'GetInstructionAtIndex')
+
+        def __len__(self):
+            '''Access len of the instruction list.'''
+            return int(self.GetSize())
+
+        def __getitem__(self, key):
+            '''Access instructions by integer index for array access or by lldb.SBAddress to find an instruction that matches a section offset address object.'''
+            if type(key) is int:
+                # Find an instruction by index
+                count = len(self)
+                if -count <= key < count:
+                    key %= count
+                    return self.GetInstructionAtIndex(key)
+            elif type(key) is SBAddress:
+                # Find an instruction using a lldb.SBAddress object
+                lookup_file_addr = key.file_addr
+                closest_inst = None
+                for idx in range(self.GetSize()):
+                    inst = self.GetInstructionAtIndex(idx)
+                    inst_file_addr = inst.addr.file_addr
+                    if inst_file_addr == lookup_file_addr:
+                        return inst
+                    elif inst_file_addr > lookup_file_addr:
+                        return closest_inst
+                    else:
+                        closest_inst = inst
+            return None
+    %}
+#endif
+}

lldb/bindings/interface/SBLanguageRuntime.i

-//===-- SWIG Interface for SBLanguageRuntime --------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-%feature("docstring",
-"Utility functions for :ref:`LanguageType`"
-) SBLanguageRuntime;
-class SBLanguageRuntime
-{
-public:
-    static lldb::LanguageType
-    GetLanguageTypeFromString (const char *string);
-
-    static const char *
-    GetNameForLanguageType (lldb::LanguageType language);
-};
-
-} // namespace lldb

lldb/bindings/interface/SBLanguageRuntimeDocstrings.i

+%feature("docstring",
+"Utility functions for :ref:`LanguageType`"
+) lldb::SBLanguageRuntime;

lldb/bindings/interface/SBLaunchInfo.i

-//===-- SWIG Interface for SBLaunchInfo--------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-%feature("docstring",
-"Describes how a target or program should be launched."
-) SBLaunchInfo;
-class SBLaunchInfo
-{
-public:
-    SBLaunchInfo (const char **argv);
-
-    pid_t
-    GetProcessID();
-
-    uint32_t
-    GetUserID();
-
-    uint32_t
-    GetGroupID();
-
-    bool
-    UserIDIsValid ();
-
-    bool
-    GroupIDIsValid ();
-
-    void
-    SetUserID (uint32_t uid);
-
-    void
-    SetGroupID (uint32_t gid);
-
-    lldb::SBFileSpec
-    GetExecutableFile ();
-
-    void
-    SetExecutableFile (lldb::SBFileSpec exe_file, bool add_as_first_arg);
-
-    lldb::SBListener
-    GetListener ();
-
-    void
-    SetListener (lldb::SBListener &listener);
-
-    uint32_t
-    GetNumArguments ();
-
-    const char *
-    GetArgumentAtIndex (uint32_t idx);
-
-    void
-    SetArguments (const char **argv, bool append);
-
-    uint32_t
-    GetNumEnvironmentEntries ();
-
-    const char *
-    GetEnvironmentEntryAtIndex (uint32_t idx);
-
-    void
-    SetEnvironmentEntries (const char **envp, bool append);
-
-    void
-    SetEnvironment(const SBEnvironment &env, bool append);
-
-    SBEnvironment
-    GetEnvironment();
-
-    void
-    Clear ();
-
-    const char *
-    GetWorkingDirectory () const;
-
-    void
-    SetWorkingDirectory (const char *working_dir);
-
-    uint32_t
-    GetLaunchFlags ();
-
-    void
-    SetLaunchFlags (uint32_t flags);
-
-    const char *
-    GetProcessPluginName ();
-
-    void
-    SetProcessPluginName (const char *plugin_name);
-
-    const char *
-    GetShell ();
-
-    void
-    SetShell (const char * path);
-
-    bool
-    GetShellExpandArguments ();
-
-    void
-    SetShellExpandArguments (bool expand);
-
-    uint32_t
-    GetResumeCount ();
-
-    void
-    SetResumeCount (uint32_t c);
-
-    bool
-    AddCloseFileAction (int fd);
-
-    bool
-    AddDuplicateFileAction (int fd, int dup_fd);
-
-    bool
-    AddOpenFileAction (int fd, const char *path, bool read, bool write);
-
-    bool
-    AddSuppressFileAction (int fd, bool read, bool write);
-
-    void
-    SetLaunchEventData (const char *data);
-
-    const char *
-    GetLaunchEventData () const;
-
-    bool
-    GetDetachOnError() const;
-
-    void
-    SetDetachOnError(bool enable);
-
-    const char *
-    GetScriptedProcessClassName() const;
-
-    void SetScriptedProcessClassName(const char *class_name);
-
-    lldb::SBStructuredData
-    GetScriptedProcessDictionary() const;
-
-    void SetScriptedProcessDictionary(lldb::SBStructuredData dict);
-};
-
-} // namespace lldb

lldb/bindings/interface/SBLaunchInfoDocstrings.i

+%feature("docstring",
+"Describes how a target or program should be launched."
+) lldb::SBLaunchInfo;

lldb/bindings/interface/SBLineEntry.i

-//===-- SWIG Interface for SBLineEntry --------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-%feature("docstring",
-"Specifies an association with a contiguous range of instructions and
-a source file location.
-
-:py:class:`SBCompileUnit` contains SBLineEntry(s). For example, ::
-
-    for lineEntry in compileUnit:
-        print('line entry: %s:%d' % (str(lineEntry.GetFileSpec()),
-                                    lineEntry.GetLine()))
-        print('start addr: %s' % str(lineEntry.GetStartAddress()))
-        print('end   addr: %s' % str(lineEntry.GetEndAddress()))
-
-produces: ::
-
-    line entry: /Volumes/data/lldb/svn/trunk/test/python_api/symbol-context/main.c:20
-    start addr: a.out[0x100000d98]
-    end   addr: a.out[0x100000da3]
-    line entry: /Volumes/data/lldb/svn/trunk/test/python_api/symbol-context/main.c:21
-    start addr: a.out[0x100000da3]
-    end   addr: a.out[0x100000da9]
-    line entry: /Volumes/data/lldb/svn/trunk/test/python_api/symbol-context/main.c:22
-    start addr: a.out[0x100000da9]
-    end   addr: a.out[0x100000db6]
-    line entry: /Volumes/data/lldb/svn/trunk/test/python_api/symbol-context/main.c:23
-    start addr: a.out[0x100000db6]
-    end   addr: a.out[0x100000dbc]
-    ...
-
-See also :py:class:`SBCompileUnit` ."
-) SBLineEntry;
-class SBLineEntry
-{
-public:
-
-    SBLineEntry ();
-
-    SBLineEntry (const lldb::SBLineEntry &rhs);
-
-    ~SBLineEntry ();
-
-    lldb::SBAddress
-    GetStartAddress () const;
-
-    lldb::SBAddress
-    GetEndAddress () const;
-
-    bool
-    IsValid () const;
-
-    explicit operator bool() const;
-
-    lldb::SBFileSpec
-    GetFileSpec () const;
-
-    uint32_t
-    GetLine () const;
-
-    uint32_t
-    GetColumn () const;
-
-    bool
-    GetDescription (lldb::SBStream &description);
-
-    void
-    SetFileSpec (lldb::SBFileSpec filespec);
-
-    void
-    SetLine (uint32_t line);
-
-    void
-    SetColumn (uint32_t column);
-
-    bool
-    operator == (const lldb::SBLineEntry &rhs) const;
-
-    bool
-    operator != (const lldb::SBLineEntry &rhs) const;
-
-    STRING_EXTENSION(SBLineEntry)
-
-#ifdef SWIGPYTHON
-    %pythoncode %{
-        file = property(GetFileSpec, None, doc='''A read only property that returns an lldb object that represents the file (lldb.SBFileSpec) for this line entry.''')
-        line = property(GetLine, None, doc='''A read only property that returns the 1 based line number for this line entry, a return value of zero indicates that no line information is available.''')
-        column = property(GetColumn, None, doc='''A read only property that returns the 1 based column number for this line entry, a return value of zero indicates that no column information is available.''')
-        addr = property(GetStartAddress, None, doc='''A read only property that returns an lldb object that represents the start address (lldb.SBAddress) for this line entry.''')
-        end_addr = property(GetEndAddress, None, doc='''A read only property that returns an lldb object that represents the end address (lldb.SBAddress) for this line entry.''')
-    %}
-#endif
-};
-
-} // namespace lldb

lldb/bindings/interface/SBLineEntryDocstrings.i

+%feature("docstring",
+"Specifies an association with a contiguous range of instructions and
+a source file location.
+
+:py:class:`SBCompileUnit` contains SBLineEntry(s). For example, ::
+
+    for lineEntry in compileUnit:
+        print('line entry: %s:%d' % (str(lineEntry.GetFileSpec()),
+                                    lineEntry.GetLine()))
+        print('start addr: %s' % str(lineEntry.GetStartAddress()))
+        print('end   addr: %s' % str(lineEntry.GetEndAddress()))
+
+produces: ::
+
+    line entry: /Volumes/data/lldb/svn/trunk/test/python_api/symbol-context/main.c:20
+    start addr: a.out[0x100000d98]
+    end   addr: a.out[0x100000da3]
+    line entry: /Volumes/data/lldb/svn/trunk/test/python_api/symbol-context/main.c:21
+    start addr: a.out[0x100000da3]
+    end   addr: a.out[0x100000da9]
+    line entry: /Volumes/data/lldb/svn/trunk/test/python_api/symbol-context/main.c:22
+    start addr: a.out[0x100000da9]
+    end   addr: a.out[0x100000db6]
+    line entry: /Volumes/data/lldb/svn/trunk/test/python_api/symbol-context/main.c:23
+    start addr: a.out[0x100000db6]
+    end   addr: a.out[0x100000dbc]
+    ...
+
+See also :py:class:`SBCompileUnit` ."
+) lldb::SBLineEntry;

lldb/bindings/interface/SBLineEntryExtensions.i

+STRING_EXTENSION_OUTSIDE(SBLineEntry)
+
+%extend lldb::SBLineEntry {
+#ifdef SWIGPYTHON
+    %pythoncode %{
+        file = property(GetFileSpec, None, doc='''A read only property that returns an lldb object that represents the file (lldb.SBFileSpec) for this line entry.''')
+        line = property(GetLine, None, doc='''A read only property that returns the 1 based line number for this line entry, a return value of zero indicates that no line information is available.''')
+        column = property(GetColumn, None, doc='''A read only property that returns the 1 based column number for this line entry, a return value of zero indicates that no column information is available.''')
+        addr = property(GetStartAddress, None, doc='''A read only property that returns an lldb object that represents the start address (lldb.SBAddress) for this line entry.''')
+        end_addr = property(GetEndAddress, None, doc='''A read only property that returns an lldb object that represents the end address (lldb.SBAddress) for this line entry.''')
+    %}
+#endif
+}

lldb/bindings/interface/SBListener.i

-//===-- SWIG Interface for SBListener ---------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-%feature("docstring",
-"API clients can register its own listener to debugger events.
-
-See also :py:class:`SBEvent` for example usage of creating and adding a listener."
-) SBListener;
-class SBListener
-{
-public:
-    SBListener ();
-
-    SBListener (const char *name);
-
-    SBListener (const SBListener &rhs);
-
-    ~SBListener ();
-
-    void
-    AddEvent (const lldb::SBEvent &event);
-
-    void
-    Clear ();
-
-    bool
-    IsValid () const;
-
-    explicit operator bool() const;
-
-    uint32_t
-    StartListeningForEventClass (SBDebugger &debugger,
-                                 const char *broadcaster_class,
-                                 uint32_t event_mask);
-
-    uint32_t
-    StopListeningForEventClass (SBDebugger &debugger,
-                                const char *broadcaster_class,
-                                uint32_t event_mask);
-
-    uint32_t
-    StartListeningForEvents (const lldb::SBBroadcaster& broadcaster,
-                             uint32_t event_mask);
-
-    bool
-    StopListeningForEvents (const lldb::SBBroadcaster& broadcaster,
-                            uint32_t event_mask);
-
-    // Returns true if an event was received, false if we timed out.
-    bool
-    WaitForEvent (uint32_t num_seconds,
-                  lldb::SBEvent &event);
-
-    bool
-    WaitForEventForBroadcaster (uint32_t num_seconds,
-                                const lldb::SBBroadcaster &broadcaster,
-                                lldb::SBEvent &sb_event);
-
-    bool
-    WaitForEventForBroadcasterWithType (uint32_t num_seconds,
-                                        const lldb::SBBroadcaster &broadcaster,
-                                        uint32_t event_type_mask,
-                                        lldb::SBEvent &sb_event);
-
-    bool
-    PeekAtNextEvent (lldb::SBEvent &sb_event);
-
-    bool
-    PeekAtNextEventForBroadcaster (const lldb::SBBroadcaster &broadcaster,
-                                   lldb::SBEvent &sb_event);
-
-    bool
-    PeekAtNextEventForBroadcasterWithType (const lldb::SBBroadcaster &broadcaster,
-                                           uint32_t event_type_mask,
-                                           lldb::SBEvent &sb_event);
-
-    bool
-    GetNextEvent (lldb::SBEvent &sb_event);
-
-    bool
-    GetNextEventForBroadcaster (const lldb::SBBroadcaster &broadcaster,
-                                lldb::SBEvent &sb_event);
-
-    bool
-    GetNextEventForBroadcasterWithType (const lldb::SBBroadcaster &broadcaster,
-                                        uint32_t event_type_mask,
-                                        lldb::SBEvent &sb_event);
-
-    bool
-    HandleBroadcastEvent (const lldb::SBEvent &event);
-};
-
-} // namespace lldb

lldb/bindings/interface/SBListenerDocstrings.i

+%feature("docstring",
+"API clients can register its own listener to debugger events.
+
+See also :py:class:`SBEvent` for example usage of creating and adding a listener."
+) lldb::SBListener;

lldb/bindings/interface/SBMemoryRegionInfo.i

-//===-- SWIG Interface for SBMemoryRegionInfo -------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-%feature("docstring",
-"API clients can get information about memory regions in processes."
-) SBMemoryRegionInfo;
-
-class SBMemoryRegionInfo
-{
-public:
-
-    SBMemoryRegionInfo ();
-
-    SBMemoryRegionInfo (const lldb::SBMemoryRegionInfo &rhs);
-
-    SBMemoryRegionInfo::SBMemoryRegionInfo(const char *name, lldb::addr_t begin,
-    lldb::addr_t end, uint32_t permissions, bool mapped, bool stack_memory);
-
-    ~SBMemoryRegionInfo ();
-
-    void
-    Clear();
-
-    lldb::addr_t
-    GetRegionBase ();
-
-    lldb::addr_t
-    GetRegionEnd ();
-
-    bool
-    IsReadable ();
-
-    bool
-    IsWritable ();
-
-    bool
-    IsExecutable ();
-
-    bool
-    IsMapped ();
-
-    const char *
-    GetName ();
-
-    %feature("autodoc", "
-        GetRegionEnd(SBMemoryRegionInfo self) -> lldb::addr_t
-        Returns whether this memory region has a list of modified (dirty)
-        pages available or not.  When calling GetNumDirtyPages(), you will
-        have 0 returned for both \"dirty page list is not known\" and 
-        \"empty dirty page list\" (that is, no modified pages in this
-        memory region).  You must use this method to disambiguate.") HasDirtyMemoryPageList;
-    bool 
-    HasDirtyMemoryPageList();
-
-    %feature("autodoc", "
-        GetNumDirtyPages(SBMemoryRegionInfo self) -> uint32_t
-        Return the number of dirty (modified) memory pages in this
-        memory region, if available.  You must use the 
-        SBMemoryRegionInfo::HasDirtyMemoryPageList() method to
-        determine if a dirty memory list is available; it will depend
-        on the target system can provide this information.") GetNumDirtyPages;
-    uint32_t 
-    GetNumDirtyPages();
-
-    %feature("autodoc", "
-        GetDirtyPageAddressAtIndex(SBMemoryRegionInfo self, uint32_t idx) -> lldb::addr_t
-        Return the address of a modified, or dirty, page of memory.
-        If the provided index is out of range, or this memory region 
-        does not have dirty page information, LLDB_INVALID_ADDRESS 
-        is returned.") GetDirtyPageAddressAtIndex;
-    addr_t 
-    GetDirtyPageAddressAtIndex(uint32_t idx);
-
-    %feature("autodoc", "
-        GetPageSize(SBMemoryRegionInfo self) -> int
-        Return the size of pages in this memory region.  0 will be returned
-        if this information was unavailable.") GetPageSize();
-    int
-    GetPageSize();
-
-    bool
-    operator == (const lldb::SBMemoryRegionInfo &rhs) const;
-
-    bool
-    operator != (const lldb::SBMemoryRegionInfo &rhs) const;
-
-    bool
-    GetDescription (lldb::SBStream &description);
-
-    STRING_EXTENSION(SBMemoryRegionInfo)
-};
-
-} // namespace lldb

lldb/bindings/interface/SBMemoryRegionInfoDocstrings.i

+%feature("docstring",
+"API clients can get information about memory regions in processes."
+) lldb::SBMemoryRegionInfo;
+
+%feature("autodoc", "
+        GetRegionEnd(SBMemoryRegionInfo self) -> lldb::addr_t
+        Returns whether this memory region has a list of modified (dirty)
+        pages available or not.  When calling GetNumDirtyPages(), you will
+        have 0 returned for both \"dirty page list is not known\" and 
+        \"empty dirty page list\" (that is, no modified pages in this
+        memory region).  You must use this method to disambiguate."
+) lldb::SBMemoryRegionInfo::HasDirtyMemoryPageList;
+
+%feature("autodoc", "
+        GetNumDirtyPages(SBMemoryRegionInfo self) -> uint32_t
+        Return the number of dirty (modified) memory pages in this
+        memory region, if available.  You must use the 
+        SBMemoryRegionInfo::HasDirtyMemoryPageList() method to
+        determine if a dirty memory list is available; it will depend
+        on the target system can provide this information."
+) lldb::SBMemoryRegionInfo::GetNumDirtyPages;
+
+%feature("autodoc", "
+        GetDirtyPageAddressAtIndex(SBMemoryRegionInfo self, uint32_t idx) -> lldb::addr_t
+        Return the address of a modified, or dirty, page of memory.
+        If the provided index is out of range, or this memory region 
+        does not have dirty page information, LLDB_INVALID_ADDRESS 
+        is returned."
+) lldb::SBMemoryRegionInfo::GetDirtyPageAddressAtIndex;
+
+%feature("autodoc", "
+        GetPageSize(SBMemoryRegionInfo self) -> int
+        Return the size of pages in this memory region.  0 will be returned
+        if this information was unavailable."
+) lldb::SBMemoryRegionInfo::GetPageSize();

lldb/bindings/interface/SBMemoryRegionInfoExtensions.i

+STRING_EXTENSION_OUTSIDE(SBMemoryRegionInfo)

lldb/bindings/interface/SBMemoryRegionInfoList.i

-//===-- SBMemoryRegionInfoList.h --------------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-%feature("docstring",
-"Represents a list of :py:class:`SBMemoryRegionInfo`."
-) SBMemoryRegionInfoList;
-class SBMemoryRegionInfoList
-{
-public:
-
-    SBMemoryRegionInfoList ();
-
-    SBMemoryRegionInfoList (const lldb::SBMemoryRegionInfoList &rhs);
-
-    ~SBMemoryRegionInfoList ();
-
-    uint32_t
-    GetSize () const;
-
-    bool
-    GetMemoryRegionContainingAddress (lldb::addr_t addr, SBMemoryRegionInfo &region_info);
-
-    bool
-    GetMemoryRegionAtIndex (uint32_t idx, SBMemoryRegionInfo &region_info);
-
-    void
-    Append (lldb::SBMemoryRegionInfo &region);
-
-    void
-    Append (lldb::SBMemoryRegionInfoList &region_list);
-
-    void
-    Clear ();
-};
-
-} // namespace lldb

lldb/bindings/interface/SBMemoryRegionInfoListDocstrings.i

+%feature("docstring",
+"Represents a list of :py:class:`SBMemoryRegionInfo`."
+) lldb::SBMemoryRegionInfoList;

lldb/bindings/interface/SBModuleDocstrings.i

+%feature("docstring",
+"Represents an executable image and its associated object and symbol files.
+
+The module is designed to be able to select a single slice of an
+executable image as it would appear on disk and during program
+execution.
+
+You can retrieve SBModule from :py:class:`SBSymbolContext` , which in turn is available
+from SBFrame.
+
+SBModule supports symbol iteration, for example, ::
+
+    for symbol in module:
+        name = symbol.GetName()
+        saddr = symbol.GetStartAddress()
+        eaddr = symbol.GetEndAddress()
+
+and rich comparison methods which allow the API program to use, ::
+
+    if thisModule == thatModule:
+        print('This module is the same as that module')
+
+to test module equality.  A module also contains object file sections, namely
+:py:class:`SBSection` .  SBModule supports section iteration through section_iter(), for
+example, ::
+
+    print('Number of sections: %d' % module.GetNumSections())
+    for sec in module.section_iter():
+        print(sec)
+
+And to iterate the symbols within a SBSection, use symbol_in_section_iter(), ::
+
+    # Iterates the text section and prints each symbols within each sub-section.
+    for subsec in text_sec:
+        print(INDENT + repr(subsec))
+        for sym in exe_module.symbol_in_section_iter(subsec):
+            print(INDENT2 + repr(sym))
+            print(INDENT2 + 'symbol type: %s' % symbol_type_to_str(sym.GetType()))
+
+produces this following output: ::
+
+    [0x0000000100001780-0x0000000100001d5c) a.out.__TEXT.__text
+        id = {0x00000004}, name = 'mask_access(MaskAction, unsigned int)', range = [0x00000001000017c0-0x0000000100001870)
+        symbol type: code
+        id = {0x00000008}, name = 'thread_func(void*)', range = [0x0000000100001870-0x00000001000019b0)
+        symbol type: code
+        id = {0x0000000c}, name = 'main', range = [0x00000001000019b0-0x0000000100001d5c)
+        symbol type: code
+        id = {0x00000023}, name = 'start', address = 0x0000000100001780
+        symbol type: code
+    [0x0000000100001d5c-0x0000000100001da4) a.out.__TEXT.__stubs
+        id = {0x00000024}, name = '__stack_chk_fail', range = [0x0000000100001d5c-0x0000000100001d62)
+        symbol type: trampoline
+        id = {0x00000028}, name = 'exit', range = [0x0000000100001d62-0x0000000100001d68)
+        symbol type: trampoline
+        id = {0x00000029}, name = 'fflush', range = [0x0000000100001d68-0x0000000100001d6e)
+        symbol type: trampoline
+        id = {0x0000002a}, name = 'fgets', range = [0x0000000100001d6e-0x0000000100001d74)
+        symbol type: trampoline
+        id = {0x0000002b}, name = 'printf', range = [0x0000000100001d74-0x0000000100001d7a)
+        symbol type: trampoline
+        id = {0x0000002c}, name = 'pthread_create', range = [0x0000000100001d7a-0x0000000100001d80)
+        symbol type: trampoline
+        id = {0x0000002d}, name = 'pthread_join', range = [0x0000000100001d80-0x0000000100001d86)
+        symbol type: trampoline
+        id = {0x0000002e}, name = 'pthread_mutex_lock', range = [0x0000000100001d86-0x0000000100001d8c)
+        symbol type: trampoline
+        id = {0x0000002f}, name = 'pthread_mutex_unlock', range = [0x0000000100001d8c-0x0000000100001d92)
+        symbol type: trampoline
+        id = {0x00000030}, name = 'rand', range = [0x0000000100001d92-0x0000000100001d98)
+        symbol type: trampoline
+        id = {0x00000031}, name = 'strtoul', range = [0x0000000100001d98-0x0000000100001d9e)
+        symbol type: trampoline
+        id = {0x00000032}, name = 'usleep', range = [0x0000000100001d9e-0x0000000100001da4)
+        symbol type: trampoline
+    [0x0000000100001da4-0x0000000100001e2c) a.out.__TEXT.__stub_helper
+    [0x0000000100001e2c-0x0000000100001f10) a.out.__TEXT.__cstring
+    [0x0000000100001f10-0x0000000100001f68) a.out.__TEXT.__unwind_info
+    [0x0000000100001f68-0x0000000100001ff8) a.out.__TEXT.__eh_frame
+"
+) lldb::SBModule;
+
+%feature("docstring", "
+    Check if the module is file backed.
+
+    @return
+
+        True, if the module is backed by an object file on disk.
+        False, if the module is backed by an object file in memory."
+) lldb::SBModule::IsFileBacked;
+
+%feature("docstring", "
+    Get const accessor for the module file specification.
+
+    This function returns the file for the module on the host system
+    that is running LLDB. This can differ from the path on the
+    platform since we might be doing remote debugging.
+
+    @return
+        A const reference to the file specification object."
+) lldb::SBModule::GetFileSpec;
+
+%feature("docstring", "
+    Get accessor for the module platform file specification.
+
+    Platform file refers to the path of the module as it is known on
+    the remote system on which it is being debugged. For local
+    debugging this is always the same as Module::GetFileSpec(). But
+    remote debugging might mention a file '/usr/lib/liba.dylib'
+    which might be locally downloaded and cached. In this case the
+    platform file could be something like:
+    '/tmp/lldb/platform-cache/remote.host.computer/usr/lib/liba.dylib'
+    The file could also be cached in a local developer kit directory.
+
+    @return
+        A const reference to the file specification object."
+) lldb::SBModule::GetPlatformFileSpec;
+
+%feature("docstring", "Returns the UUID of the module as a Python string."
+) lldb::SBModule::GetUUIDString;
+
+%feature("docstring", "
+    Find compile units related to this module and passed source
+    file.
+
+    @param[in] sb_file_spec
+        A :py:class:`SBFileSpec` object that contains source file
+        specification.
+
+    @return
+        A :py:class:`SBSymbolContextList` that gets filled in with all of
+        the symbol contexts for all the matches."
+) lldb::SBModule::FindCompileUnits;
+
+%feature("docstring", "
+    Find functions by name.
+
+    @param[in] name
+        The name of the function we are looking for.
+
+    @param[in] name_type_mask
+        A logical OR of one or more FunctionNameType enum bits that
+        indicate what kind of names should be used when doing the
+        lookup. Bits include fully qualified names, base names,
+        C++ methods, or ObjC selectors.
+        See FunctionNameType for more details.
+
+    @return
+        A symbol context list that gets filled in with all of the
+        matches."
+) lldb::SBModule::FindFunctions;
+
+%feature("docstring", "
+    Get all types matching type_mask from debug info in this
+    module.
+
+    @param[in] type_mask
+        A bitfield that consists of one or more bits logically OR'ed
+        together from the lldb::TypeClass enumeration. This allows
+        you to request only structure types, or only class, struct
+        and union types. Passing in lldb::eTypeClassAny will return
+        all types found in the debug information for this module.
+
+    @return
+        A list of types in this module that match type_mask"
+) lldb::SBModule::GetTypes;
+
+%feature("docstring", "
+    Find global and static variables by name.
+
+    @param[in] target
+        A valid SBTarget instance representing the debuggee.
+
+    @param[in] name
+        The name of the global or static variable we are looking
+        for.
+
+    @param[in] max_matches
+        Allow the number of matches to be limited to max_matches.
+
+    @return
+        A list of matched variables in an SBValueList."
+) lldb::SBModule::FindGlobalVariables;
+
+%feature("docstring", "
+    Find the first global (or static) variable by name.
+
+    @param[in] target
+        A valid SBTarget instance representing the debuggee.
+
+    @param[in] name
+        The name of the global or static variable we are looking
+        for.
+
+    @return
+        An SBValue that gets filled in with the found variable (if any)."
+) lldb::SBModule::FindFirstGlobalVariable;
+
+%feature("docstring", "
+    Returns the number of modules in the module cache. This is an
+    implementation detail exposed for testing and should not be relied upon.
+
+    @return
+        The number of modules in the module cache."
+) lldb::SBModule::GetNumberAllocatedModules;
+
+%feature("docstring", "
+    Removes all modules which are no longer needed by any part of LLDB from
+    the module cache.
+
+    This is an implementation detail exposed for testing and should not be
+    relied upon. Use SBDebugger::MemoryPressureDetected instead to reduce
+    LLDB's memory consumption during execution.
+") lldb::SBModule::GarbageCollectAllocatedModules;

lldb/bindings/interface/SBModuleExtensions.i

-//===-- SWIG Interface for SBModule -----------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
 #ifdef SWIGPYTHON
 %pythoncode%{
 # ==================================
 # Helper function for SBModule class
 # ==================================
 def in_range(symbol, section):
     """Test whether a symbol is within the range of a section."""
     symSA = symbol.GetStartAddress().GetFileAddress()
def in_range(symbol, section):
     else:
         if secSA <= symSA and symSA < secEA:
             return True
         else:
             return False
 %}
 #endif
 
-%feature("docstring",
-"Represents an executable image and its associated object and symbol files.
-
-The module is designed to be able to select a single slice of an
-executable image as it would appear on disk and during program
-execution.
-
-You can retrieve SBModule from :py:class:`SBSymbolContext` , which in turn is available
-from SBFrame.
-
-SBModule supports symbol iteration, for example, ::
-
-    for symbol in module:
-        name = symbol.GetName()
-        saddr = symbol.GetStartAddress()
-        eaddr = symbol.GetEndAddress()
-
-and rich comparison methods which allow the API program to use, ::
-
-    if thisModule == thatModule:
-        print('This module is the same as that module')
-
-to test module equality.  A module also contains object file sections, namely
-:py:class:`SBSection` .  SBModule supports section iteration through section_iter(), for
-example, ::
-
-    print('Number of sections: %d' % module.GetNumSections())
-    for sec in module.section_iter():
-        print(sec)
-
-And to iterate the symbols within a SBSection, use symbol_in_section_iter(), ::
-
-    # Iterates the text section and prints each symbols within each sub-section.
-    for subsec in text_sec:
-        print(INDENT + repr(subsec))
-        for sym in exe_module.symbol_in_section_iter(subsec):
-            print(INDENT2 + repr(sym))
-            print(INDENT2 + 'symbol type: %s' % symbol_type_to_str(sym.GetType()))
-
-produces this following output: ::
-
-    [0x0000000100001780-0x0000000100001d5c) a.out.__TEXT.__text
-        id = {0x00000004}, name = 'mask_access(MaskAction, unsigned int)', range = [0x00000001000017c0-0x0000000100001870)
-        symbol type: code
-        id = {0x00000008}, name = 'thread_func(void*)', range = [0x0000000100001870-0x00000001000019b0)
-        symbol type: code
-        id = {0x0000000c}, name = 'main', range = [0x00000001000019b0-0x0000000100001d5c)
-        symbol type: code
-        id = {0x00000023}, name = 'start', address = 0x0000000100001780
-        symbol type: code
-    [0x0000000100001d5c-0x0000000100001da4) a.out.__TEXT.__stubs
-        id = {0x00000024}, name = '__stack_chk_fail', range = [0x0000000100001d5c-0x0000000100001d62)
-        symbol type: trampoline
-        id = {0x00000028}, name = 'exit', range = [0x0000000100001d62-0x0000000100001d68)
-        symbol type: trampoline
-        id = {0x00000029}, name = 'fflush', range = [0x0000000100001d68-0x0000000100001d6e)
-        symbol type: trampoline
-        id = {0x0000002a}, name = 'fgets', range = [0x0000000100001d6e-0x0000000100001d74)
-        symbol type: trampoline
-        id = {0x0000002b}, name = 'printf', range = [0x0000000100001d74-0x0000000100001d7a)
-        symbol type: trampoline
-        id = {0x0000002c}, name = 'pthread_create', range = [0x0000000100001d7a-0x0000000100001d80)
-        symbol type: trampoline
-        id = {0x0000002d}, name = 'pthread_join', range = [0x0000000100001d80-0x0000000100001d86)
-        symbol type: trampoline
-        id = {0x0000002e}, name = 'pthread_mutex_lock', range = [0x0000000100001d86-0x0000000100001d8c)
-        symbol type: trampoline
-        id = {0x0000002f}, name = 'pthread_mutex_unlock', range = [0x0000000100001d8c-0x0000000100001d92)
-        symbol type: trampoline
-        id = {0x00000030}, name = 'rand', range = [0x0000000100001d92-0x0000000100001d98)
-        symbol type: trampoline
-        id = {0x00000031}, name = 'strtoul', range = [0x0000000100001d98-0x0000000100001d9e)
-        symbol type: trampoline
-        id = {0x00000032}, name = 'usleep', range = [0x0000000100001d9e-0x0000000100001da4)
-        symbol type: trampoline
-    [0x0000000100001da4-0x0000000100001e2c) a.out.__TEXT.__stub_helper
-    [0x0000000100001e2c-0x0000000100001f10) a.out.__TEXT.__cstring
-    [0x0000000100001f10-0x0000000100001f68) a.out.__TEXT.__unwind_info
-    [0x0000000100001f68-0x0000000100001ff8) a.out.__TEXT.__eh_frame
-"
-) SBModule;
-class SBModule
-{
-public:
-
-    SBModule ();
-
-    SBModule (const lldb::SBModule &rhs);
-
-    SBModule (const lldb::SBModuleSpec &module_spec);
-
-    SBModule (lldb::SBProcess &process,
-              lldb::addr_t header_addr);
-
-    ~SBModule ();
-
-    bool
-    IsValid () const;
-
-    explicit operator bool() const;
-
-    void
-    Clear();
-
-    %feature("docstring", "
-    Check if the module is file backed.
-
-    @return
-
-        True, if the module is backed by an object file on disk.
-        False, if the module is backed by an object file in memory.") IsFileBacked;
-    bool
-    IsFileBacked() const;
-
-    %feature("docstring", "
-    Get const accessor for the module file specification.
-
-    This function returns the file for the module on the host system
-    that is running LLDB. This can differ from the path on the
-    platform since we might be doing remote debugging.
-
-    @return
-        A const reference to the file specification object.") GetFileSpec;
-    lldb::SBFileSpec
-    GetFileSpec () const;
-
-    %feature("docstring", "
-    Get accessor for the module platform file specification.
-
-    Platform file refers to the path of the module as it is known on
-    the remote system on which it is being debugged. For local
-    debugging this is always the same as Module::GetFileSpec(). But
-    remote debugging might mention a file '/usr/lib/liba.dylib'
-    which might be locally downloaded and cached. In this case the
-    platform file could be something like:
-    '/tmp/lldb/platform-cache/remote.host.computer/usr/lib/liba.dylib'
-    The file could also be cached in a local developer kit directory.
-
-    @return
-        A const reference to the file specification object.") GetPlatformFileSpec;
-    lldb::SBFileSpec
-    GetPlatformFileSpec () const;
-
-    bool
-    SetPlatformFileSpec (const lldb::SBFileSpec &platform_file);
-
-    lldb::SBFileSpec
-    GetRemoteInstallFileSpec ();
-
-    bool
-    SetRemoteInstallFileSpec (lldb::SBFileSpec &file);
-
-    %feature("docstring", "Returns the UUID of the module as a Python string."
-    ) GetUUIDString;
-    const char *
-    GetUUIDString () const;
-
-    bool operator==(const lldb::SBModule &rhs) const;
-
-    bool operator!=(const lldb::SBModule &rhs) const;
-
-    lldb::SBSection
-    FindSection (const char *sect_name);
-
-    lldb::SBAddress
-    ResolveFileAddress (lldb::addr_t vm_addr);
-
-    lldb::SBSymbolContext
-    ResolveSymbolContextForAddress (const lldb::SBAddress& addr,
-                                    uint32_t resolve_scope);
-
-    bool
-    GetDescription (lldb::SBStream &description);
-
-    uint32_t
-    GetNumCompileUnits();
-
-    lldb::SBCompileUnit
-    GetCompileUnitAtIndex (uint32_t);
-
-    %feature("docstring", "
-    Find compile units related to this module and passed source
-    file.
-
-    @param[in] sb_file_spec
-        A :py:class:`SBFileSpec` object that contains source file
-        specification.
-
-    @return
-        A :py:class:`SBSymbolContextList` that gets filled in with all of
-        the symbol contexts for all the matches.") FindCompileUnits;
-    lldb::SBSymbolContextList
-    FindCompileUnits (const lldb::SBFileSpec &sb_file_spec);
-
-    size_t
-    GetNumSymbols ();
-
-    lldb::SBSymbol
-    GetSymbolAtIndex (size_t idx);
-
-    lldb::SBSymbol
-    FindSymbol (const char *name,
-                lldb::SymbolType type = eSymbolTypeAny);
-
-    lldb::SBSymbolContextList
-    FindSymbols (const char *name,
-                 lldb::SymbolType type = eSymbolTypeAny);
-
-
-    size_t
-    GetNumSections ();
-
-    lldb::SBSection
-    GetSectionAtIndex (size_t idx);
-
-
-    %feature("docstring", "
-    Find functions by name.
-
-    @param[in] name
-        The name of the function we are looking for.
-
-    @param[in] name_type_mask
-        A logical OR of one or more FunctionNameType enum bits that
-        indicate what kind of names should be used when doing the
-        lookup. Bits include fully qualified names, base names,
-        C++ methods, or ObjC selectors.
-        See FunctionNameType for more details.
-
-    @return
-        A symbol context list that gets filled in with all of the
-        matches.") FindFunctions;
-    lldb::SBSymbolContextList
-    FindFunctions (const char *name,
-                   uint32_t name_type_mask = lldb::eFunctionNameTypeAny);
-
-    lldb::SBType
-    FindFirstType (const char* name);
-
-    lldb::SBTypeList
-    FindTypes (const char* type);
-
-    lldb::SBType
-    GetTypeByID (lldb::user_id_t uid);
-
-    lldb::SBType
-    GetBasicType(lldb::BasicType type);
-
-    %feature("docstring", "
-    Get all types matching type_mask from debug info in this
-    module.
-
-    @param[in] type_mask
-        A bitfield that consists of one or more bits logically OR'ed
-        together from the lldb::TypeClass enumeration. This allows
-        you to request only structure types, or only class, struct
-        and union types. Passing in lldb::eTypeClassAny will return
-        all types found in the debug information for this module.
-
-    @return
-        A list of types in this module that match type_mask") GetTypes;
-    lldb::SBTypeList
-    GetTypes (uint32_t type_mask = lldb::eTypeClassAny);
-
-    %feature("docstring", "
-    Find global and static variables by name.
-
-    @param[in] target
-        A valid SBTarget instance representing the debuggee.
-
-    @param[in] name
-        The name of the global or static variable we are looking
-        for.
-
-    @param[in] max_matches
-        Allow the number of matches to be limited to max_matches.
-
-    @return
-        A list of matched variables in an SBValueList.") FindGlobalVariables;
-    lldb::SBValueList
-    FindGlobalVariables (lldb::SBTarget &target,
-                         const char *name,
-                         uint32_t max_matches);
-
-    %feature("docstring", "
-    Find the first global (or static) variable by name.
-
-    @param[in] target
-        A valid SBTarget instance representing the debuggee.
-
-    @param[in] name
-        The name of the global or static variable we are looking
-        for.
-
-    @return
-        An SBValue that gets filled in with the found variable (if any).") FindFirstGlobalVariable;
-    lldb::SBValue
-    FindFirstGlobalVariable (lldb::SBTarget &target, const char *name);
-
-    lldb::ByteOrder
-    GetByteOrder ();
-
-    uint32_t
-    GetAddressByteSize();
-
-    const char *
-    GetTriple ();
-
-    uint32_t
-    GetVersion (uint32_t *versions,
-                uint32_t num_versions);
-
-    lldb::SBFileSpec
-    GetSymbolFileSpec() const;
-
-    lldb::SBAddress
-    GetObjectFileHeaderAddress() const;
-
-    lldb::SBAddress
-    GetObjectFileEntryPointAddress() const;
-
-    %feature("docstring", "
-    Returns the number of modules in the module cache. This is an
-    implementation detail exposed for testing and should not be relied upon.
-
-    @return
-        The number of modules in the module cache.") GetNumberAllocatedModules;
-    static uint32_t
-    GetNumberAllocatedModules();
-
-    %feature("docstring", "
-    Removes all modules which are no longer needed by any part of LLDB from
-    the module cache.
-
-    This is an implementation detail exposed for testing and should not be
-    relied upon. Use SBDebugger::MemoryPressureDetected instead to reduce
-    LLDB's memory consumption during execution.
-    ") GarbageCollectAllocatedModules;
-    static void
-    GarbageCollectAllocatedModules();
-
-    STRING_EXTENSION(SBModule)
+STRING_EXTENSION_OUTSIDE(SBModule)
 
+%extend lldb::SBModule {
 #ifdef SWIGPYTHON
     %pythoncode %{
         def __len__(self):
             '''Return the number of symbols in a lldb.SBModule object.'''
             return self.GetNumSymbols()
 
         def __iter__(self):
             '''Iterate over all symbols in a lldb.SBModule object.'''
%pythoncode %{
         byte_order = property(GetByteOrder, None, doc='''A read only property that returns an lldb enumeration value (lldb.eByteOrderLittle, lldb.eByteOrderBig, lldb.eByteOrderInvalid) that represents the byte order for this module.''')
         addr_size = property(GetAddressByteSize, None, doc='''A read only property that returns the size in bytes of an address for this module.''')
         triple = property(GetTriple, None, doc='''A read only property that returns the target triple (arch-vendor-os) for this module.''')
         num_symbols = property(GetNumSymbols, None, doc='''A read only property that returns number of symbols in the module symbol table as an integer.''')
         num_sections = property(GetNumSections, None, doc='''A read only property that returns number of sections in the module as an integer.''')
 
     %}
 #endif
-
-};
-
-} // namespace lldb
+}

lldb/bindings/interface/SBModuleSpec.i

-//===-- SWIG Interface for SBModule -----------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-class SBModuleSpec
-{
-public:
-
-    SBModuleSpec ();
-
-    SBModuleSpec (const lldb::SBModuleSpec &rhs);
-
-    ~SBModuleSpec ();
-
-    bool
-    IsValid () const;
-
-    explicit operator bool() const;
-
-    void
-    Clear();
-
-    %feature("docstring", "
-    Get const accessor for the module file.
-
-    This function returns the file for the module on the host system
-    that is running LLDB. This can differ from the path on the
-    platform since we might be doing remote debugging.
-
-    @return
-        A const reference to the file specification object.") GetFileSpec;
-    lldb::SBFileSpec
-    GetFileSpec ();
-
-    void
-    SetFileSpec (const lldb::SBFileSpec &fspec);
-
-    %feature("docstring", "
-    Get accessor for the module platform file.
-
-    Platform file refers to the path of the module as it is known on
-    the remote system on which it is being debugged. For local
-    debugging this is always the same as Module::GetFileSpec(). But
-    remote debugging might mention a file '/usr/lib/liba.dylib'
-    which might be locally downloaded and cached. In this case the
-    platform file could be something like:
-    '/tmp/lldb/platform-cache/remote.host.computer/usr/lib/liba.dylib'
-    The file could also be cached in a local developer kit directory.
-
-    @return
-        A const reference to the file specification object.") GetPlatformFileSpec;
-    lldb::SBFileSpec
-    GetPlatformFileSpec ();
-
-    void
-    SetPlatformFileSpec (const lldb::SBFileSpec &fspec);
-
-    lldb::SBFileSpec
-    GetSymbolFileSpec ();
-
-    void
-    SetSymbolFileSpec (const lldb::SBFileSpec &fspec);
-
-    const char *
-    GetObjectName ();
-
-    void
-    SetObjectName (const char *name);
-
-    const char *
-    GetTriple ();
-
-    void
-    SetTriple (const char *triple);
-
-    const uint8_t *
-    GetUUIDBytes ();
-
-    size_t
-    GetUUIDLength ();
-
-    bool
-    SetUUIDBytes (const uint8_t *uuid, size_t uuid_len);
-
-    bool
-    GetDescription (lldb::SBStream &description);
-
-    STRING_EXTENSION(SBModuleSpec)
-};
-
-
-%feature("docstring",
-"Represents a list of :py:class:`SBModuleSpec`."
-) SBModuleSpecList;
-class SBModuleSpecList
-{
-public:
-    SBModuleSpecList();
-
-    SBModuleSpecList (const SBModuleSpecList &rhs);
-
-    ~SBModuleSpecList();
-
-    static SBModuleSpecList
-    GetModuleSpecifications (const char *path);
-
-    void
-    Append (const lldb::SBModuleSpec &spec);
-
-    void
-    Append (const lldb::SBModuleSpecList &spec_list);
-
-    lldb::SBModuleSpec
-    FindFirstMatchingSpec (const lldb::SBModuleSpec &match_spec);
-
-    lldb::SBModuleSpecList
-    FindMatchingSpecs (const lldb::SBModuleSpec &match_spec);
-
-    size_t
-    GetSize();
-
-    lldb::SBModuleSpec
-    GetSpecAtIndex (size_t i);
-
-    bool
-    GetDescription (lldb::SBStream &description);
-
-    STRING_EXTENSION(SBModuleSpecList)
-};
-
-} // namespace lldb

lldb/bindings/interface/SBModuleSpecDocstrings.i

+%feature("docstring", "
+    Get const accessor for the module file.
+
+    This function returns the file for the module on the host system
+    that is running LLDB. This can differ from the path on the
+    platform since we might be doing remote debugging.
+
+    @return
+        A const reference to the file specification object."
+) lldb::SBModuleSpec::GetFileSpec;
+
+%feature("docstring", "
+    Get accessor for the module platform file.
+
+    Platform file refers to the path of the module as it is known on
+    the remote system on which it is being debugged. For local
+    debugging this is always the same as Module::GetFileSpec(). But
+    remote debugging might mention a file '/usr/lib/liba.dylib'
+    which might be locally downloaded and cached. In this case the
+    platform file could be something like:
+    '/tmp/lldb/platform-cache/remote.host.computer/usr/lib/liba.dylib'
+    The file could also be cached in a local developer kit directory.
+
+    @return
+        A const reference to the file specification object."
+) lldb::SBModuleSpec::GetPlatformFileSpec;
+
+%feature("docstring",
+"Represents a list of :py:class:`SBModuleSpec`."
+) lldb::SBModuleSpecList;

lldb/bindings/interface/SBModuleSpecExtensions.i

+STRING_EXTENSION_OUTSIDE(SBModuleSpec)
+
+STRING_EXTENSION_OUTSIDE(SBModuleSpecList)

lldb/bindings/interface/SBPlatform.i

-//===-- SWIG Interface for SBPlatform ---------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-
-%feature("docstring",
-"Describes how :py:class:`SBPlatform.ConnectRemote` connects to a remote platform."
-) SBPlatformConnectOptions;
-class SBPlatformConnectOptions
-{
-public:
-    SBPlatformConnectOptions (const char *url);
-
-    SBPlatformConnectOptions (const SBPlatformConnectOptions &rhs);
-
-    ~SBPlatformConnectOptions ();
-
-    const char *
-    GetURL();
-
-    void
-    SetURL(const char *url);
-
-    bool
-    GetRsyncEnabled();
-
-    void
-    EnableRsync (const char *options,
-                 const char *remote_path_prefix,
-                 bool omit_remote_hostname);
-
-    void
-    DisableRsync ();
-
-    const char *
-    GetLocalCacheDirectory();
-
-    void
-    SetLocalCacheDirectory(const char *path);
-};
-
-%feature("docstring",
-"Represents a shell command that can be run by :py:class:`SBPlatform.Run`."
-) SBPlatformShellCommand;
-class SBPlatformShellCommand
-{
-public:
-    SBPlatformShellCommand (const char *shell, const char *shell_command);
-    SBPlatformShellCommand (const char *shell_command);
-
-    SBPlatformShellCommand (const SBPlatformShellCommand &rhs);
-
-    ~SBPlatformShellCommand();
-
-    void
-    Clear();
-
-    const char *
-    GetShell();
-
-    void
-    SetShell(const char *shell_interpreter);
-
-    const char *
-    GetCommand();
-
-    void
-    SetCommand(const char *shell_command);
-
-    const char *
-    GetWorkingDirectory ();
-
-    void
-    SetWorkingDirectory (const char *path);
-
-    uint32_t
-    GetTimeoutSeconds ();
-
-    void
-    SetTimeoutSeconds (uint32_t sec);
-
-    int
-    GetSignal ();
-
-    int
-    GetStatus ();
-
-    const char *
-    GetOutput ();
-};
-
-%feature("docstring",
-"A class that represents a platform that can represent the current host or a remote host debug platform.
-
-The SBPlatform class represents the current host, or a remote host.
-It can be connected to a remote platform in order to provide ways
-to remotely launch and attach to processes, upload/download files,
-create directories, run remote shell commands, find locally cached
-versions of files from the remote system, and much more.
-
-SBPlatform objects can be created and then used to connect to a remote
-platform which allows the SBPlatform to be used to get a list of the
-current processes on the remote host, attach to one of those processes,
-install programs on the remote system, attach and launch processes,
-and much more.
-
-Every :py:class:`SBTarget` has a corresponding SBPlatform. The platform can be
-specified upon target creation, or the currently selected platform
-will attempt to be used when creating the target automatically as long
-as the currently selected platform matches the target architecture
-and executable type. If the architecture or executable type do not match,
-a suitable platform will be found automatically."
-
-) SBPlatform;
-class SBPlatform
-{
-public:
-
-    SBPlatform ();
-
-    SBPlatform (const char *);
-
-    ~SBPlatform();
-
-    static SBPlatform GetHostPlatform();
-
-    bool
-    IsValid () const;
-
-    explicit operator bool() const;
-
-    void
-    Clear ();
-
-    const char *
-    GetWorkingDirectory();
-
-    bool
-    SetWorkingDirectory(const char *);
-
-    const char *
-    GetName ();
-
-    SBError
-    ConnectRemote (lldb::SBPlatformConnectOptions &connect_options);
-
-    void
-    DisconnectRemote ();
-
-    bool
-    IsConnected();
-
-    const char *
-    GetTriple();
-
-    const char *
-    GetHostname ();
-
-    const char *
-    GetOSBuild ();
-
-    const char *
-    GetOSDescription ();
-
-    uint32_t
-    GetOSMajorVersion ();
-
-    uint32_t
-    GetOSMinorVersion ();
-
-    uint32_t
-    GetOSUpdateVersion ();
-
-    void
-    SetSDKRoot(const char *sysroot);
-
-    lldb::SBError
-    Get (lldb::SBFileSpec &src, lldb::SBFileSpec &dst);
-
-    lldb::SBError
-    Put (lldb::SBFileSpec &src, lldb::SBFileSpec &dst);
-
-    lldb::SBError
-    Install (lldb::SBFileSpec &src, lldb::SBFileSpec &dst);
-
-    lldb::SBError
-    Run (lldb::SBPlatformShellCommand &shell_command);
-
-    lldb::SBError
-    Launch (lldb::SBLaunchInfo &launch_info);
-
-    lldb::SBError
-    Kill (const lldb::pid_t pid);
-
-    lldb::SBError
-    MakeDirectory (const char *path, uint32_t file_permissions = lldb::eFilePermissionsDirectoryDefault);
-
-    uint32_t
-    GetFilePermissions (const char *path);
-
-    lldb::SBError
-    SetFilePermissions (const char *path, uint32_t file_permissions);
-
-    lldb::SBUnixSignals
-    GetUnixSignals();
-
-    lldb::SBEnvironment
-    GetEnvironment();
-
-};
-
-} // namespace lldb

lldb/bindings/interface/SBPlatformDocstrings.i

+%feature("docstring",
+"Describes how :py:class:`SBPlatform.ConnectRemote` connects to a remote platform."
+) lldb::SBPlatformConnectOptions;
+
+%feature("docstring",
+"Represents a shell command that can be run by :py:class:`SBPlatform.Run`."
+) lldb::SBPlatformShellCommand;
+
+%feature("docstring",
+"A class that represents a platform that can represent the current host or a remote host debug platform.
+
+The SBPlatform class represents the current host, or a remote host.
+It can be connected to a remote platform in order to provide ways
+to remotely launch and attach to processes, upload/download files,
+create directories, run remote shell commands, find locally cached
+versions of files from the remote system, and much more.
+
+SBPlatform objects can be created and then used to connect to a remote
+platform which allows the SBPlatform to be used to get a list of the
+current processes on the remote host, attach to one of those processes,
+install programs on the remote system, attach and launch processes,
+and much more.
+
+Every :py:class:`SBTarget` has a corresponding SBPlatform. The platform can be
+specified upon target creation, or the currently selected platform
+will attempt to be used when creating the target automatically as long
+as the currently selected platform matches the target architecture
+and executable type. If the architecture or executable type do not match,
+a suitable platform will be found automatically."
+
+) lldb::SBPlatform;

lldb/bindings/interface/SBProcess.i

-//===-- SWIG Interface for SBProcess ----------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-%feature("docstring",
-"Represents the process associated with the target program.
-
-SBProcess supports thread iteration. For example (from test/lldbutil.py), ::
-
-    # ==================================================
-    # Utility functions related to Threads and Processes
-    # ==================================================
-
-    def get_stopped_threads(process, reason):
-        '''Returns the thread(s) with the specified stop reason in a list.
-
-        The list can be empty if no such thread exists.
-        '''
-        threads = []
-        for t in process:
-            if t.GetStopReason() == reason:
-                threads.append(t)
-        return threads
-"
-) SBProcess;
-class SBProcess
-{
-public:
-    enum
-    {
-        eBroadcastBitStateChanged   = (1 << 0),
-        eBroadcastBitInterrupt      = (1 << 1),
-        eBroadcastBitSTDOUT         = (1 << 2),
-        eBroadcastBitSTDERR         = (1 << 3),
-        eBroadcastBitProfileData    = (1 << 4),
-        eBroadcastBitStructuredData = (1 << 5)
-    };
-
-    SBProcess ();
-
-    SBProcess (const lldb::SBProcess& rhs);
-
-    ~SBProcess();
-
-    static const char *
-    GetBroadcasterClassName ();
-
-    const char *
-    GetPluginName ();
-
-    const char *
-    GetShortPluginName ();
-
-    void
-    Clear ();
-
-    bool
-    IsValid() const;
-
-    explicit operator bool() const;
-
-    lldb::SBTarget
-    GetTarget() const;
-
-    lldb::ByteOrder
-    GetByteOrder() const;
-
-    %feature("autodoc", "
-    Writes data into the current process's stdin. API client specifies a Python
-    string as the only argument.") PutSTDIN;
-    size_t
-    PutSTDIN (const char *src, size_t src_len);
-
-    %feature("autodoc", "
-    Reads data from the current process's stdout stream. API client specifies
-    the size of the buffer to read data into. It returns the byte buffer in a
-    Python string.") GetSTDOUT;
-    size_t
-    GetSTDOUT (char *dst, size_t dst_len) const;
-
-    %feature("autodoc", "
-    Reads data from the current process's stderr stream. API client specifies
-    the size of the buffer to read data into. It returns the byte buffer in a
-    Python string.") GetSTDERR;
-    size_t
-    GetSTDERR (char *dst, size_t dst_len) const;
-
-    size_t
-    GetAsyncProfileData(char *dst, size_t dst_len) const;
-
-    void
-    ReportEventState (const lldb::SBEvent &event, SBFile out) const;
-
-    void
-    ReportEventState (const lldb::SBEvent &event, FileSP BORROWED) const;
-
-    void
-    AppendEventStateReport (const lldb::SBEvent &event, lldb::SBCommandReturnObject &result);
-
-    %feature("docstring", "
-    Remote connection related functions. These will fail if the
-    process is not in eStateConnected. They are intended for use
-    when connecting to an externally managed debugserver instance.") RemoteAttachToProcessWithID;
-    bool
-    RemoteAttachToProcessWithID (lldb::pid_t pid,
-                                 lldb::SBError& error);
-
-    %feature("docstring",
-    "See SBTarget.Launch for argument description and usage."
-    ) RemoteLaunch;
-    bool
-    RemoteLaunch (char const **argv,
-                  char const **envp,
-                  const char *stdin_path,
-                  const char *stdout_path,
-                  const char *stderr_path,
-                  const char *working_directory,
-                  uint32_t launch_flags,
-                  bool stop_at_entry,
-                  lldb::SBError& error);
-
-    //------------------------------------------------------------------
-    // Thread related functions
-    //------------------------------------------------------------------
-    uint32_t
-    GetNumThreads ();
-
-    %feature("autodoc", "
-    Returns the INDEX'th thread from the list of current threads.  The index
-    of a thread is only valid for the current stop.  For a persistent thread
-    identifier use either the thread ID or the IndexID.  See help on SBThread
-    for more details.") GetThreadAtIndex;
-    lldb::SBThread
-    GetThreadAtIndex (size_t index);
-
-    %feature("autodoc", "
-    Returns the thread with the given thread ID.") GetThreadByID;
-    lldb::SBThread
-    GetThreadByID (lldb::tid_t sb_thread_id);
-
-    %feature("autodoc", "
-    Returns the thread with the given thread IndexID.") GetThreadByIndexID;
-    lldb::SBThread
-    GetThreadByIndexID (uint32_t index_id);
-
-    %feature("autodoc", "
-    Returns the currently selected thread.") GetSelectedThread;
-    lldb::SBThread
-    GetSelectedThread () const;
-
-    %feature("autodoc", "
-    Lazily create a thread on demand through the current OperatingSystem plug-in, if the current OperatingSystem plug-in supports it.") CreateOSPluginThread;
-    lldb::SBThread
-    CreateOSPluginThread (lldb::tid_t tid, lldb::addr_t context);
-
-    bool
-    SetSelectedThread (const lldb::SBThread &thread);
-
-    bool
-    SetSelectedThreadByID (lldb::tid_t tid);
-
-    bool
-    SetSelectedThreadByIndexID (uint32_t index_id);
-
-    //------------------------------------------------------------------
-    // Queue related functions
-    //------------------------------------------------------------------
-    uint32_t
-    GetNumQueues ();
-
-    lldb::SBQueue
-    GetQueueAtIndex (uint32_t index);
-
-    //------------------------------------------------------------------
-    // Stepping related functions
-    //------------------------------------------------------------------
-
-    lldb::StateType
-    GetState ();
-
-    int
-    GetExitStatus ();
-
-    const char *
-    GetExitDescription ();
-
-    %feature("autodoc", "
-    Returns the process ID of the process.") GetProcessID;
-    lldb::pid_t
-    GetProcessID ();
-
-    %feature("autodoc", "
-    Returns an integer ID that is guaranteed to be unique across all process instances. This is not the process ID, just a unique integer for comparison and caching purposes.") GetUniqueID;
-    uint32_t
-    GetUniqueID();
-
-    uint32_t
-    GetAddressByteSize() const;
-
-    %feature("docstring", "
-    Kills the process and shuts down all threads that were spawned to
-    track and monitor process.") Destroy;
-    lldb::SBError
-    Destroy ();
-
-    lldb::SBError
-    Continue ();
-
-    lldb::SBError
-    Stop ();
-
-    %feature("docstring", "Same as Destroy(self).") Destroy;
-    lldb::SBError
-    Kill ();
-
-    lldb::SBError
-    Detach ();
-
-    %feature("docstring", "Sends the process a unix signal.") Signal;
-    lldb::SBError
-    Signal (int signal);
-
-    lldb::SBUnixSignals
-    GetUnixSignals();
-
-    %feature("docstring", "
-    Returns a stop id that will increase every time the process executes.  If
-    include_expression_stops is true, then stops caused by expression evaluation
-    will cause the returned value to increase, otherwise the counter returned will
-    only increase when execution is continued explicitly by the user.  Note, the value
-    will always increase, but may increase by more than one per stop.") GetStopID;
-    uint32_t
-    GetStopID(bool include_expression_stops = false);
-
-    void
-    SendAsyncInterrupt();
-
-    %feature("autodoc", "
-    Reads memory from the current process's address space and removes any
-    traps that may have been inserted into the memory. It returns the byte
-    buffer in a Python string. Example: ::
-
-        # Read 4 bytes from address 'addr' and assume error.Success() is True.
-        content = process.ReadMemory(addr, 4, error)
-        new_bytes = bytearray(content)") ReadMemory;
-    size_t
-    ReadMemory (addr_t addr, void *buf, size_t size, lldb::SBError &error);
-
-    %feature("autodoc", "
-    Writes memory to the current process's address space and maintains any
-    traps that might be present due to software breakpoints. Example: ::
-
-        # Create a Python string from the byte array.
-        new_value = str(bytes)
-        result = process.WriteMemory(addr, new_value, error)
-        if not error.Success() or result != len(bytes):
-            print('SBProcess.WriteMemory() failed!')") WriteMemory;
-    size_t
-    WriteMemory (addr_t addr, const void *buf, size_t size, lldb::SBError &error);
-
-    %feature("autodoc", "
-    Reads a NULL terminated C string from the current process's address space.
-    It returns a python string of the exact length, or truncates the string if
-    the maximum character limit is reached. Example: ::
-
-        # Read a C string of at most 256 bytes from address '0x1000'
-        error = lldb.SBError()
-        cstring = process.ReadCStringFromMemory(0x1000, 256, error)
-        if error.Success():
-            print('cstring: ', cstring)
-        else
-            print('error: ', error)") ReadCStringFromMemory;
-
-    size_t
-    ReadCStringFromMemory (addr_t addr, void *char_buf, size_t size, lldb::SBError &error);
-
-    %feature("autodoc", "
-    Reads an unsigned integer from memory given a byte size and an address.
-    Returns the unsigned integer that was read. Example: ::
-
-        # Read a 4 byte unsigned integer from address 0x1000
-        error = lldb.SBError()
-        uint = ReadUnsignedFromMemory(0x1000, 4, error)
-        if error.Success():
-            print('integer: %u' % uint)
-        else
-            print('error: ', error)") ReadUnsignedFromMemory;
-
-    uint64_t
-    ReadUnsignedFromMemory (addr_t addr, uint32_t byte_size, lldb::SBError &error);
-
-    %feature("autodoc", "
-    Reads a pointer from memory from an address and returns the value. Example: ::
-
-        # Read a pointer from address 0x1000
-        error = lldb.SBError()
-        ptr = ReadPointerFromMemory(0x1000, error)
-        if error.Success():
-            print('pointer: 0x%x' % ptr)
-        else
-            print('error: ', error)") ReadPointerFromMemory;
-
-    lldb::addr_t
-    ReadPointerFromMemory (addr_t addr, lldb::SBError &error);
-
-
-    // Events
-    static lldb::StateType
-    GetStateFromEvent (const lldb::SBEvent &event);
-
-    static bool
-    GetRestartedFromEvent (const lldb::SBEvent &event);
-
-    static size_t
-    GetNumRestartedReasonsFromEvent (const lldb::SBEvent &event);
-
-    static const char *
-    GetRestartedReasonAtIndexFromEvent (const lldb::SBEvent &event, size_t idx);
-
-    static lldb::SBProcess
-    GetProcessFromEvent (const lldb::SBEvent &event);
-
-    static bool
-    GetInterruptedFromEvent (const lldb::SBEvent &event);
-
-    static lldb::SBStructuredData
-    GetStructuredDataFromEvent (const lldb::SBEvent &event);
-
-    static bool
-    EventIsProcessEvent (const lldb::SBEvent &event);
-
-    static bool
-    EventIsStructuredDataEvent (const lldb::SBEvent &event);
-
-    lldb::SBBroadcaster
-    GetBroadcaster () const;
-
-    bool
-    GetDescription (lldb::SBStream &description);
-
-    %feature("autodoc", "
-    Returns the implementation object of the process plugin if available. None
-    otherwise.") GetScriptedImplementation;
-    ScriptedObject
-    GetScriptedImplementation();
-
-    %feature("autodoc", "
-    Returns the process' extended crash information.") GetExtendedCrashInformation;
-    lldb::SBStructuredData
-    GetExtendedCrashInformation ();
-
-    uint32_t
-    GetNumSupportedHardwareWatchpoints (lldb::SBError &error) const;
-
-    uint32_t
-    LoadImage (lldb::SBFileSpec &image_spec, lldb::SBError &error);
-
-    %feature("autodoc", "
-    Load the library whose filename is given by image_spec looking in all the
-    paths supplied in the paths argument.  If successful, return a token that
-    can be passed to UnloadImage and fill loaded_path with the path that was
-    successfully loaded.  On failure, return
-    lldb.LLDB_INVALID_IMAGE_TOKEN.") LoadImageUsingPaths;
-    uint32_t
-    LoadImageUsingPaths(const lldb::SBFileSpec &image_spec,
-                        SBStringList &paths,
-                        lldb::SBFileSpec &loaded_path,
-                        SBError &error);
-
-    lldb::SBError
-    UnloadImage (uint32_t image_token);
-
-    lldb::SBError
-    SendEventData (const char *event_data);
-
-    %feature("autodoc", "
-    Return the number of different thread-origin extended backtraces
-    this process can support as a uint32_t.
-    When the process is stopped and you have an SBThread, lldb may be
-    able to show a backtrace of when that thread was originally created,
-    or the work item was enqueued to it (in the case of a libdispatch
-    queue).") GetNumExtendedBacktraceTypes;
-
-    uint32_t
-    GetNumExtendedBacktraceTypes ();
-
-    %feature("autodoc", "
-    Takes an index argument, returns the name of one of the thread-origin
-    extended backtrace methods as a str.") GetExtendedBacktraceTypeAtIndex;
-
-    const char *
-    GetExtendedBacktraceTypeAtIndex (uint32_t idx);
-
-    lldb::SBThreadCollection
-    GetHistoryThreads (addr_t addr);
-
-    bool
-    IsInstrumentationRuntimePresent(lldb::InstrumentationRuntimeType type);
-
-    lldb::SBError
-    SaveCore(const char *file_name, const char *flavor, lldb::SaveCoreStyle core_style);
-
-    lldb::SBError
-    SaveCore(const char *file_name);
-
-    lldb::SBError
-    GetMemoryRegionInfo(lldb::addr_t load_addr, lldb::SBMemoryRegionInfo &region_info);
-
-    lldb::SBMemoryRegionInfoList
-    GetMemoryRegions();
-
-    %feature("autodoc", "
-    Get information about the process.
-    Valid process info will only be returned when the process is alive,
-    use IsValid() to check if the info returned is valid. ::
-
-        process_info = process.GetProcessInfo()
-        if process_info.IsValid():
-            process_info.GetProcessID()") GetProcessInfo;
-    lldb::SBProcessInfo
-    GetProcessInfo();
-
-    %feature("autodoc", "
-    Allocates a block of memory within the process, with size and
-    access permissions specified in the arguments. The permissions
-    argument is an or-combination of zero or more of
-    lldb.ePermissionsWritable, lldb.ePermissionsReadable, and
-    lldb.ePermissionsExecutable. Returns the address
-    of the allocated buffer in the process, or
-    lldb.LLDB_INVALID_ADDRESS if the allocation failed.") AllocateMemory;
-
-    lldb::addr_t
-    AllocateMemory(size_t size, uint32_t permissions, lldb::SBError &error);
-
-    %feature("autodoc", "
-    Deallocates the block of memory (previously allocated using
-    AllocateMemory) given in the argument.") DeallocateMemory;
-
-    lldb::SBError
-    DeallocateMemory(lldb::addr_t ptr);
-
-    STRING_EXTENSION(SBProcess)
-
-#ifdef SWIGPYTHON
-    %pythoncode %{
-        def __get_is_alive__(self):
-            '''Returns "True" if the process is currently alive, "False" otherwise'''
-            s = self.GetState()
-            if (s == eStateAttaching or
-                s == eStateLaunching or
-                s == eStateStopped or
-                s == eStateRunning or
-                s == eStateStepping or
-                s == eStateCrashed or
-                s == eStateSuspended):
-                return True
-            return False
-
-        def __get_is_running__(self):
-            '''Returns "True" if the process is currently running, "False" otherwise'''
-            state = self.GetState()
-            if state == eStateRunning or state == eStateStepping:
-                return True
-            return False
-
-        def __get_is_stopped__(self):
-            '''Returns "True" if the process is currently stopped, "False" otherwise'''
-            state = self.GetState()
-            if state == eStateStopped or state == eStateCrashed or state == eStateSuspended:
-                return True
-            return False
-
-        class threads_access(object):
-            '''A helper object that will lazily hand out thread for a process when supplied an index.'''
-            def __init__(self, sbprocess):
-                self.sbprocess = sbprocess
-
-            def __len__(self):
-                if self.sbprocess:
-                    return int(self.sbprocess.GetNumThreads())
-                return 0
-
-            def __getitem__(self, key):
-                if isinstance(key, int):
-                    count = len(self)
-                    if -count <= key < count:
-                        key %= count
-                        return self.sbprocess.GetThreadAtIndex(key)
-                return None
-
-        def get_threads_access_object(self):
-            '''An accessor function that returns a modules_access() object which allows lazy thread access from a lldb.SBProcess object.'''
-            return self.threads_access (self)
-
-        def get_process_thread_list(self):
-            '''An accessor function that returns a list() that contains all threads in a lldb.SBProcess object.'''
-            threads = []
-            accessor = self.get_threads_access_object()
-            for idx in range(len(accessor)):
-                threads.append(accessor[idx])
-            return threads
-
-        def __iter__(self):
-            '''Iterate over all threads in a lldb.SBProcess object.'''
-            return lldb_iter(self, 'GetNumThreads', 'GetThreadAtIndex')
-
-        def __len__(self):
-            '''Return the number of threads in a lldb.SBProcess object.'''
-            return self.GetNumThreads()
-
-
-        threads = property(get_process_thread_list, None, doc='''A read only property that returns a list() of lldb.SBThread objects for this process.''')
-        thread = property(get_threads_access_object, None, doc='''A read only property that returns an object that can access threads by thread index (thread = lldb.process.thread[12]).''')
-        is_alive = property(__get_is_alive__, None, doc='''A read only property that returns a boolean value that indicates if this process is currently alive.''')
-        is_running = property(__get_is_running__, None, doc='''A read only property that returns a boolean value that indicates if this process is currently running.''')
-        is_stopped = property(__get_is_stopped__, None, doc='''A read only property that returns a boolean value that indicates if this process is currently stopped.''')
-        id = property(GetProcessID, None, doc='''A read only property that returns the process ID as an integer.''')
-        target = property(GetTarget, None, doc='''A read only property that an lldb object that represents the target (lldb.SBTarget) that owns this process.''')
-        num_threads = property(GetNumThreads, None, doc='''A read only property that returns the number of threads in this process as an integer.''')
-        selected_thread = property(GetSelectedThread, SetSelectedThread, doc='''A read/write property that gets/sets the currently selected thread in this process. The getter returns a lldb.SBThread object and the setter takes an lldb.SBThread object.''')
-        state = property(GetState, None, doc='''A read only property that returns an lldb enumeration value (see enumerations that start with "lldb.eState") that represents the current state of this process (running, stopped, exited, etc.).''')
-        exit_state = property(GetExitStatus, None, doc='''A read only property that returns an exit status as an integer of this process when the process state is lldb.eStateExited.''')
-        exit_description = property(GetExitDescription, None, doc='''A read only property that returns an exit description as a string of this process when the process state is lldb.eStateExited.''')
-        broadcaster = property(GetBroadcaster, None, doc='''A read only property that an lldb object that represents the broadcaster (lldb.SBBroadcaster) for this process.''')
-    %}
-#endif
-
-};
-
-}  // namespace lldb

lldb/bindings/interface/SBProcessDocstrings.i

+%feature("docstring",
+"Represents the process associated with the target program.
+
+SBProcess supports thread iteration. For example (from test/lldbutil.py), ::
+
+    # ==================================================
+    # Utility functions related to Threads and Processes
+    # ==================================================
+
+    def get_stopped_threads(process, reason):
+        '''Returns the thread(s) with the specified stop reason in a list.
+
+        The list can be empty if no such thread exists.
+        '''
+        threads = []
+        for t in process:
+            if t.GetStopReason() == reason:
+                threads.append(t)
+        return threads
+"
+) lldb::SBProcess;
+
+%feature("autodoc", "
+    Writes data into the current process's stdin. API client specifies a Python
+    string as the only argument."
+) lldb::SBProcess::PutSTDIN;
+
+%feature("autodoc", "
+    Reads data from the current process's stdout stream. API client specifies
+    the size of the buffer to read data into. It returns the byte buffer in a
+    Python string."
+) lldb::SBProcess::GetSTDOUT;
+
+%feature("autodoc", "
+    Reads data from the current process's stderr stream. API client specifies
+    the size of the buffer to read data into. It returns the byte buffer in a
+    Python string."
+) lldb::SBProcess::GetSTDERR;
+
+%feature("docstring", "
+    Remote connection related functions. These will fail if the
+    process is not in eStateConnected. They are intended for use
+    when connecting to an externally managed debugserver instance."
+) lldb::SBProcess::RemoteAttachToProcessWithID;
+
+%feature("docstring",
+"See SBTarget.Launch for argument description and usage."
+) lldb::SBProcess::RemoteLaunch;
+
+%feature("autodoc", "
+    Returns the INDEX'th thread from the list of current threads.  The index
+    of a thread is only valid for the current stop.  For a persistent thread
+    identifier use either the thread ID or the IndexID.  See help on SBThread
+    for more details."
+) lldb::SBProcess::GetThreadAtIndex;
+
+%feature("autodoc", "
+    Returns the thread with the given thread ID."
+) lldb::SBProcess::GetThreadByID;
+
+%feature("autodoc", "
+    Returns the thread with the given thread IndexID."
+) lldb::SBProcess::GetThreadByIndexID;
+
+%feature("autodoc", "
+    Returns the currently selected thread."
+) lldb::SBProcess::GetSelectedThread;
+
+%feature("autodoc", "
+    Lazily create a thread on demand through the current OperatingSystem plug-in, if the current OperatingSystem plug-in supports it."
+) lldb::SBProcess::CreateOSPluginThread;
+
+%feature("autodoc", "
+    Returns the process ID of the process."
+) lldb::SBProcess::GetProcessID;
+
+%feature("autodoc", "
+    Returns an integer ID that is guaranteed to be unique across all process instances. This is not the process ID, just a unique integer for comparison and caching purposes."
+) lldb::SBProcess::GetUniqueID;
+
+%feature("docstring", "
+    Kills the process and shuts down all threads that were spawned to
+    track and monitor process."
+) lldb::SBProcess::Destroy;
+
+%feature("docstring", "Same as Destroy(self).") lldb::SBProcess::Kill;
+
+%feature("docstring", "Sends the process a unix signal.") lldb::SBProcess::Signal;
+
+%feature("docstring", "
+    Returns a stop id that will increase every time the process executes.  If
+    include_expression_stops is true, then stops caused by expression evaluation
+    will cause the returned value to increase, otherwise the counter returned will
+    only increase when execution is continued explicitly by the user.  Note, the value
+    will always increase, but may increase by more than one per stop."
+) lldb::SBProcess::GetStopID;
+
+%feature("autodoc", "
+    Reads memory from the current process's address space and removes any
+    traps that may have been inserted into the memory. It returns the byte
+    buffer in a Python string. Example: ::
+
+        # Read 4 bytes from address 'addr' and assume error.Success() is True.
+        content = process.ReadMemory(addr, 4, error)
+        new_bytes = bytearray(content)"
+) lldb::SBProcess::ReadMemory;
+
+%feature("autodoc", "
+    Writes memory to the current process's address space and maintains any
+    traps that might be present due to software breakpoints. Example: ::
+
+        # Create a Python string from the byte array.
+        new_value = str(bytes)
+        result = process.WriteMemory(addr, new_value, error)
+        if not error.Success() or result != len(bytes):
+            print('SBProcess.WriteMemory() failed!')"
+) lldb::SBProcess::WriteMemory;
+
+%feature("autodoc", "
+    Reads a NULL terminated C string from the current process's address space.
+    It returns a python string of the exact length, or truncates the string if
+    the maximum character limit is reached. Example: ::
+
+        # Read a C string of at most 256 bytes from address '0x1000'
+        error = lldb.SBError()
+        cstring = process.ReadCStringFromMemory(0x1000, 256, error)
+        if error.Success():
+            print('cstring: ', cstring)
+        else
+            print('error: ', error)"
+) lldb::SBProcess::ReadCStringFromMemory;
+
+
+%feature("autodoc", "
+    Reads an unsigned integer from memory given a byte size and an address.
+    Returns the unsigned integer that was read. Example: ::
+
+        # Read a 4 byte unsigned integer from address 0x1000
+        error = lldb.SBError()
+        uint = ReadUnsignedFromMemory(0x1000, 4, error)
+        if error.Success():
+            print('integer: %u' % uint)
+        else
+            print('error: ', error)"
+) lldb::SBProcess::ReadUnsignedFromMemory;
+
+
+%feature("autodoc", "
+    Reads a pointer from memory from an address and returns the value. Example: ::
+
+        # Read a pointer from address 0x1000
+        error = lldb.SBError()
+        ptr = ReadPointerFromMemory(0x1000, error)
+        if error.Success():
+            print('pointer: 0x%x' % ptr)
+        else
+            print('error: ', error)"
+) lldb::SBProcess::ReadPointerFromMemory;
+
+
+%feature("autodoc", "
+    Returns the implementation object of the process plugin if available. None
+    otherwise."
+) lldb::SBProcess::GetScriptedImplementation;
+
+%feature("autodoc", "
+    Returns the process' extended crash information."
+) lldb::SBProcess::GetExtendedCrashInformation;
+
+%feature("autodoc", "
+    Load the library whose filename is given by image_spec looking in all the
+    paths supplied in the paths argument.  If successful, return a token that
+    can be passed to UnloadImage and fill loaded_path with the path that was
+    successfully loaded.  On failure, return
+    lldb.LLDB_INVALID_IMAGE_TOKEN."
+) lldb::SBProcess::LoadImageUsingPaths;
+
+%feature("autodoc", "
+    Return the number of different thread-origin extended backtraces
+    this process can support as a uint32_t.
+    When the process is stopped and you have an SBThread, lldb may be
+    able to show a backtrace of when that thread was originally created,
+    or the work item was enqueued to it (in the case of a libdispatch
+    queue)."
+) lldb::SBProcess::GetNumExtendedBacktraceTypes;
+
+%feature("autodoc", "
+    Takes an index argument, returns the name of one of the thread-origin
+    extended backtrace methods as a str."
+) lldb::SBProcess::GetExtendedBacktraceTypeAtIndex;
+
+%feature("autodoc", "
+    Get information about the process.
+    Valid process info will only be returned when the process is alive,
+    use IsValid() to check if the info returned is valid. ::
+
+        process_info = process.GetProcessInfo()
+        if process_info.IsValid():
+            process_info.GetProcessID()"
+) lldb::SBProcess::GetProcessInfo;
+
+%feature("autodoc", "
+    Allocates a block of memory within the process, with size and
+    access permissions specified in the arguments. The permissions
+    argument is an or-combination of zero or more of
+    lldb.ePermissionsWritable, lldb.ePermissionsReadable, and
+    lldb.ePermissionsExecutable. Returns the address
+    of the allocated buffer in the process, or
+    lldb.LLDB_INVALID_ADDRESS if the allocation failed."
+) lldb::SBProcess::AllocateMemory;
+
+%feature("autodoc", "
+    Deallocates the block of memory (previously allocated using
+    AllocateMemory) given in the argument."
+) lldb::SBProcess::DeallocateMemory;

lldb/bindings/interface/SBProcessExtensions.i

+STRING_EXTENSION_OUTSIDE(SBProcess)
+%extend lldb::SBProcess {
+#ifdef SWIGPYTHON
+    %pythoncode %{
+        def __get_is_alive__(self):
+            '''Returns "True" if the process is currently alive, "False" otherwise'''
+            s = self.GetState()
+            if (s == eStateAttaching or
+                s == eStateLaunching or
+                s == eStateStopped or
+                s == eStateRunning or
+                s == eStateStepping or
+                s == eStateCrashed or
+                s == eStateSuspended):
+                return True
+            return False
+
+        def __get_is_running__(self):
+            '''Returns "True" if the process is currently running, "False" otherwise'''
+            state = self.GetState()
+            if state == eStateRunning or state == eStateStepping:
+                return True
+            return False
+
+        def __get_is_stopped__(self):
+            '''Returns "True" if the process is currently stopped, "False" otherwise'''
+            state = self.GetState()
+            if state == eStateStopped or state == eStateCrashed or state == eStateSuspended:
+                return True
+            return False
+
+        class threads_access(object):
+            '''A helper object that will lazily hand out thread for a process when supplied an index.'''
+            def __init__(self, sbprocess):
+                self.sbprocess = sbprocess
+
+            def __len__(self):
+                if self.sbprocess:
+                    return int(self.sbprocess.GetNumThreads())
+                return 0
+
+            def __getitem__(self, key):
+                if isinstance(key, int):
+                    count = len(self)
+                    if -count <= key < count:
+                        key %= count
+                        return self.sbprocess.GetThreadAtIndex(key)
+                return None
+
+        def get_threads_access_object(self):
+            '''An accessor function that returns a modules_access() object which allows lazy thread access from a lldb.SBProcess object.'''
+            return self.threads_access (self)
+
+        def get_process_thread_list(self):
+            '''An accessor function that returns a list() that contains all threads in a lldb.SBProcess object.'''
+            threads = []
+            accessor = self.get_threads_access_object()
+            for idx in range(len(accessor)):
+                threads.append(accessor[idx])
+            return threads
+
+        def __iter__(self):
+            '''Iterate over all threads in a lldb.SBProcess object.'''
+            return lldb_iter(self, 'GetNumThreads', 'GetThreadAtIndex')
+
+        def __len__(self):
+            '''Return the number of threads in a lldb.SBProcess object.'''
+            return self.GetNumThreads()
+
+
+        threads = property(get_process_thread_list, None, doc='''A read only property that returns a list() of lldb.SBThread objects for this process.''')
+        thread = property(get_threads_access_object, None, doc='''A read only property that returns an object that can access threads by thread index (thread = lldb.process.thread[12]).''')
+        is_alive = property(__get_is_alive__, None, doc='''A read only property that returns a boolean value that indicates if this process is currently alive.''')
+        is_running = property(__get_is_running__, None, doc='''A read only property that returns a boolean value that indicates if this process is currently running.''')
+        is_stopped = property(__get_is_stopped__, None, doc='''A read only property that returns a boolean value that indicates if this process is currently stopped.''')
+        id = property(GetProcessID, None, doc='''A read only property that returns the process ID as an integer.''')
+        target = property(GetTarget, None, doc='''A read only property that an lldb object that represents the target (lldb.SBTarget) that owns this process.''')
+        num_threads = property(GetNumThreads, None, doc='''A read only property that returns the number of threads in this process as an integer.''')
+        selected_thread = property(GetSelectedThread, SetSelectedThread, doc='''A read/write property that gets/sets the currently selected thread in this process. The getter returns a lldb.SBThread object and the setter takes an lldb.SBThread object.''')
+        state = property(GetState, None, doc='''A read only property that returns an lldb enumeration value (see enumerations that start with "lldb.eState") that represents the current state of this process (running, stopped, exited, etc.).''')
+        exit_state = property(GetExitStatus, None, doc='''A read only property that returns an exit status as an integer of this process when the process state is lldb.eStateExited.''')
+        exit_description = property(GetExitDescription, None, doc='''A read only property that returns an exit description as a string of this process when the process state is lldb.eStateExited.''')
+        broadcaster = property(GetBroadcaster, None, doc='''A read only property that an lldb object that represents the broadcaster (lldb.SBBroadcaster) for this process.''')
+    %}
+#endif
+}

lldb/bindings/interface/SBProcessInfo.i

-//===-- SWIG Interface for SBProcessInfo-------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-%feature("docstring",
-"Describes an existing process and any discoverable information that pertains to
-that process."
-) SBProcessInfo;
-
-class SBProcessInfo
-{
-public:
-    SBProcessInfo();
-
-    SBProcessInfo (const SBProcessInfo &rhs);
-
-    ~SBProcessInfo ();
-
-    bool
-    IsValid ();
-
-    explicit operator bool() const;
-
-    const char *
-    GetName ();
-
-    SBFileSpec
-    GetExecutableFile ();
-
-    lldb::pid_t
-    GetProcessID ();
-
-    uint32_t
-    GetUserID ();
-
-    uint32_t
-    GetGroupID ();
-
-    bool
-    UserIDIsValid ();
-
-    bool
-    GroupIDIsValid ();
-
-    uint32_t
-    GetEffectiveUserID ();
-
-    uint32_t
-    GetEffectiveGroupID ();
-
-    bool
-    EffectiveUserIDIsValid ();
-
-    bool
-    EffectiveGroupIDIsValid ();
-
-    lldb::pid_t
-    GetParentProcessID ();
-
-    %feature("docstring",
-    "Return the target triple (arch-vendor-os) for the described process."
-    ) GetTriple;
-    const char *
-    GetTriple ();
-};
-
-} // namespace lldb

lldb/bindings/interface/SBProcessInfoDocstrings.i

+%feature("docstring",
+"Describes an existing process and any discoverable information that pertains to
+that process."
+) lldb::SBProcessInfo;
+
+%feature("docstring",
+"Return the target triple (arch-vendor-os) for the described process."
+) lldb::SBProcessInfo::GetTriple;

lldb/bindings/interface/SBQueue.i

-//===-- SWIG Interface for SBQueue.h -----------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-%feature("docstring",
-"Represents a libdispatch queue in the process."
-) SBQueue;
-class SBQueue
-{
-public:
-    SBQueue ();
-
-    SBQueue (const lldb::QueueSP& queue_sp);
-
-   ~SBQueue();
-
-    bool
-    IsValid() const;
-
-    explicit operator bool() const;
-
-    void
-    Clear ();
-
-    lldb::SBProcess
-    GetProcess ();
-
-    %feature("autodoc", "
-    Returns an lldb::queue_id_t type unique identifier number for this
-    queue that will not be used by any other queue during this process'
-    execution.  These ID numbers often start at 1 with the first
-    system-created queues and increment from there.")
-    GetQueueID;
-
-    lldb::queue_id_t
-    GetQueueID () const;
-
-    const char *
-    GetName () const;
-
-    %feature("autodoc", "
-    Returns an lldb::QueueKind enumerated value (e.g. eQueueKindUnknown,
-    eQueueKindSerial, eQueueKindConcurrent) describing the type of this
-    queue.")
-    GetKind();
-
-    lldb::QueueKind
-    GetKind();
-
-    uint32_t
-    GetIndexID () const;
-
-    uint32_t
-    GetNumThreads ();
-
-    lldb::SBThread
-    GetThreadAtIndex (uint32_t);
-
-    uint32_t
-    GetNumPendingItems ();
-
-    lldb::SBQueueItem
-    GetPendingItemAtIndex (uint32_t);
-
-    uint32_t
-    GetNumRunningItems ();
-
-};
-
-} // namespace lldb
-

lldb/bindings/interface/SBQueueDocstrings.i

+%feature("docstring",
+"Represents a libdispatch queue in the process."
+) lldb::SBQueue;
+
+%feature("autodoc", "
+    Returns an lldb::queue_id_t type unique identifier number for this
+    queue that will not be used by any other queue during this process'
+    execution.  These ID numbers often start at 1 with the first
+    system-created queues and increment from there."
+) lldb::SBQueue::GetQueueID;
+
+%feature("autodoc", "
+    Returns an lldb::QueueKind enumerated value (e.g. eQueueKindUnknown,
+    eQueueKindSerial, eQueueKindConcurrent) describing the type of this
+    queue."
+) lldb::SBQueue::GetKind;

lldb/bindings/interface/SBQueueItem.i

-//===-- SWIG Interface for SBQueueItem.h ------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-%feature("docstring",
-"This class represents an item in an :py:class:`SBQueue`."
-) SBQueueItem;
-class SBQueueItem
-{
-public:
-    SBQueueItem ();
-
-    SBQueueItem (const lldb::QueueItemSP& queue_item_sp);
-
-   ~SBQueueItem();
-
-    bool
-    IsValid() const;
-
-    explicit operator bool() const;
-
-    void
-    Clear ();
-
-    lldb::QueueItemKind
-    GetKind () const;
-
-    void
-    SetKind (lldb::QueueItemKind kind);
-
-    lldb::SBAddress
-    GetAddress () const;
-
-    void
-    SetAddress (lldb::SBAddress addr);
-
-    void
-    SetQueueItem (const lldb::QueueItemSP& queue_item_sp);
-
-    lldb::SBThread
-    GetExtendedBacktraceThread (const char *type);
-};
-
-} // namespace lldb

lldb/bindings/interface/SBQueueItemDocstrings.i

+%feature("docstring",
+"This class represents an item in an :py:class:`SBQueue`."
+) lldb::SBQueueItem;

lldb/bindings/interface/SBReproducer.i

-//===-- SWIG Interface for SBReproducer--------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-%feature("docstring",
-"Controls LLDB's reproducer functionality."
-) SBReproducer;
-class SBReproducer
-{
-    public:
-        static const char *Capture(const char *path);
-        static const char *PassiveReplay(const char *path);
-        static bool SetAutoGenerate(bool b);
-        static void SetWorkingDirectory(const char *path);
-};
-}

lldb/bindings/interface/SBReproducerDocstrings.i

+%feature("docstring",
+"Controls LLDB's reproducer functionality."
+) lldb::SBReproducer;

lldb/bindings/interface/SBSection.i

-//===-- SWIG Interface for SBSection ----------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-%feature("docstring",
-"Represents an executable image section.
-
-SBSection supports iteration through its subsection, represented as SBSection
-as well.  For example, ::
-
-    for sec in exe_module:
-        if sec.GetName() == '__TEXT':
-            print sec
-            break
-    print INDENT + 'Number of subsections: %d' % sec.GetNumSubSections()
-    for subsec in sec:
-        print INDENT + repr(subsec)
-
-produces: ::
-
-  [0x0000000100000000-0x0000000100002000) a.out.__TEXT
-      Number of subsections: 6
-      [0x0000000100001780-0x0000000100001d5c) a.out.__TEXT.__text
-      [0x0000000100001d5c-0x0000000100001da4) a.out.__TEXT.__stubs
-      [0x0000000100001da4-0x0000000100001e2c) a.out.__TEXT.__stub_helper
-      [0x0000000100001e2c-0x0000000100001f10) a.out.__TEXT.__cstring
-      [0x0000000100001f10-0x0000000100001f68) a.out.__TEXT.__unwind_info
-      [0x0000000100001f68-0x0000000100001ff8) a.out.__TEXT.__eh_frame
-
-See also :py:class:`SBModule` ."
-) SBSection;
-
-class SBSection
-{
-public:
-
-    SBSection ();
-
-    SBSection (const lldb::SBSection &rhs);
-
-    ~SBSection ();
-
-    bool
-    IsValid () const;
-
-    explicit operator bool() const;
-
-    const char *
-    GetName ();
-
-    lldb::SBSection
-    GetParent();
-
-    lldb::SBSection
-    FindSubSection (const char *sect_name);
-
-    size_t
-    GetNumSubSections ();
-
-    lldb::SBSection
-    GetSubSectionAtIndex (size_t idx);
-
-    lldb::addr_t
-    GetFileAddress ();
-
-    lldb::addr_t
-    GetLoadAddress (lldb::SBTarget &target);
-
-    lldb::addr_t
-    GetByteSize ();
-
-    uint64_t
-    GetFileOffset ();
-
-    uint64_t
-    GetFileByteSize ();
-
-    lldb::SBData
-    GetSectionData ();
-
-    lldb::SBData
-    GetSectionData (uint64_t offset,
-                    uint64_t size);
-
-    SectionType
-    GetSectionType ();
-
-    uint32_t
-    GetPermissions() const;
-
-    %feature("docstring", "
-    Return the size of a target's byte represented by this section
-    in numbers of host bytes. Note that certain architectures have
-    varying minimum addressable unit (i.e. byte) size for their
-    CODE or DATA buses.
-
-    @return
-        The number of host (8-bit) bytes needed to hold a target byte") GetTargetByteSize;
-    uint32_t
-    GetTargetByteSize ();
-
-    uint32_t
-    GetAlignment ();
-
-    bool
-    GetDescription (lldb::SBStream &description);
-
-    bool
-    operator == (const lldb::SBSection &rhs);
-
-    bool
-    operator != (const lldb::SBSection &rhs);
-
-    STRING_EXTENSION(SBSection)
-
-#ifdef SWIGPYTHON
-    %pythoncode %{
-        def __iter__(self):
-            '''Iterate over all subsections in a lldb.SBSection object.'''
-            return lldb_iter(self, 'GetNumSubSections', 'GetSubSectionAtIndex')
-
-        def __len__(self):
-            '''Return the number of subsections in a lldb.SBSection object.'''
-            return self.GetNumSubSections()
-
-        def get_addr(self):
-            return SBAddress(self, 0)
-
-        name = property(GetName, None, doc='''A read only property that returns the name of this section as a string.''')
-        addr = property(get_addr, None, doc='''A read only property that returns an lldb object that represents the start address (lldb.SBAddress) for this section.''')
-        file_addr = property(GetFileAddress, None, doc='''A read only property that returns an integer that represents the starting "file" address for this section, or the address of the section in the object file in which it is defined.''')
-        size = property(GetByteSize, None, doc='''A read only property that returns the size in bytes of this section as an integer.''')
-        file_offset = property(GetFileOffset, None, doc='''A read only property that returns the file offset in bytes of this section as an integer.''')
-        file_size = property(GetFileByteSize, None, doc='''A read only property that returns the file size in bytes of this section as an integer.''')
-        data = property(GetSectionData, None, doc='''A read only property that returns an lldb object that represents the bytes for this section (lldb.SBData) for this section.''')
-        type = property(GetSectionType, None, doc='''A read only property that returns an lldb enumeration value (see enumerations that start with "lldb.eSectionType") that represents the type of this section (code, data, etc.).''')
-        target_byte_size = property(GetTargetByteSize, None, doc='''A read only property that returns the size of a target byte represented by this section as a number of host bytes.''')
-        alignment = property(GetAlignment, None, doc='''A read only property that returns the alignment of this section as a number of host bytes.''')
-    %}
-#endif
-
-private:
-
-    std::unique_ptr<lldb_private::SectionImpl> m_opaque_ap;
-};
-
-} // namespace lldb

lldb/bindings/interface/SBSectionDocstrings.i

+%feature("docstring",
+"Represents an executable image section.
+
+SBSection supports iteration through its subsection, represented as SBSection
+as well.  For example, ::
+
+    for sec in exe_module:
+        if sec.GetName() == '__TEXT':
+            print sec
+            break
+    print INDENT + 'Number of subsections: %d' % sec.GetNumSubSections()
+    for subsec in sec:
+        print INDENT + repr(subsec)
+
+produces: ::
+
+  [0x0000000100000000-0x0000000100002000) a.out.__TEXT
+      Number of subsections: 6
+      [0x0000000100001780-0x0000000100001d5c) a.out.__TEXT.__text
+      [0x0000000100001d5c-0x0000000100001da4) a.out.__TEXT.__stubs
+      [0x0000000100001da4-0x0000000100001e2c) a.out.__TEXT.__stub_helper
+      [0x0000000100001e2c-0x0000000100001f10) a.out.__TEXT.__cstring
+      [0x0000000100001f10-0x0000000100001f68) a.out.__TEXT.__unwind_info
+      [0x0000000100001f68-0x0000000100001ff8) a.out.__TEXT.__eh_frame
+
+See also :py:class:`SBModule` ."
+) lldb::SBSection;
+
+%feature("docstring", "
+    Return the size of a target's byte represented by this section
+    in numbers of host bytes. Note that certain architectures have
+    varying minimum addressable unit (i.e. byte) size for their
+    CODE or DATA buses.
+
+    @return
+        The number of host (8-bit) bytes needed to hold a target byte"
+) lldb::SBSection::GetTargetByteSize;

lldb/bindings/interface/SBSectionExtensions.i

+STRING_EXTENSION_OUTSIDE(SBSection)
+
+%extend lldb::SBSection {
+#ifdef SWIGPYTHON
+    %pythoncode %{
+        def __iter__(self):
+            '''Iterate over all subsections in a lldb.SBSection object.'''
+            return lldb_iter(self, 'GetNumSubSections', 'GetSubSectionAtIndex')
+
+        def __len__(self):
+            '''Return the number of subsections in a lldb.SBSection object.'''
+            return self.GetNumSubSections()
+
+        def get_addr(self):
+            return SBAddress(self, 0)
+
+        name = property(GetName, None, doc='''A read only property that returns the name of this section as a string.''')
+        addr = property(get_addr, None, doc='''A read only property that returns an lldb object that represents the start address (lldb.SBAddress) for this section.''')
+        file_addr = property(GetFileAddress, None, doc='''A read only property that returns an integer that represents the starting "file" address for this section, or the address of the section in the object file in which it is defined.''')
+        size = property(GetByteSize, None, doc='''A read only property that returns the size in bytes of this section as an integer.''')
+        file_offset = property(GetFileOffset, None, doc='''A read only property that returns the file offset in bytes of this section as an integer.''')
+        file_size = property(GetFileByteSize, None, doc='''A read only property that returns the file size in bytes of this section as an integer.''')
+        data = property(GetSectionData, None, doc='''A read only property that returns an lldb object that represents the bytes for this section (lldb.SBData) for this section.''')
+        type = property(GetSectionType, None, doc='''A read only property that returns an lldb enumeration value (see enumerations that start with "lldb.eSectionType") that represents the type of this section (code, data, etc.).''')
+        target_byte_size = property(GetTargetByteSize, None, doc='''A read only property that returns the size of a target byte represented by this section as a number of host bytes.''')
+        alignment = property(GetAlignment, None, doc='''A read only property that returns the alignment of this section as a number of host bytes.''')
+    %}
+#endif
+}

lldb/bindings/interface/SBSourceManager.i

-//===-- SWIG Interface for SBSourceManager ----------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-%feature("docstring",
-"Represents a central authority for displaying source code.
-
-For example (from test/source-manager/TestSourceManager.py), ::
-
-        # Create the filespec for 'main.c'.
-        filespec = lldb.SBFileSpec('main.c', False)
-        source_mgr = self.dbg.GetSourceManager()
-        # Use a string stream as the destination.
-        stream = lldb.SBStream()
-        source_mgr.DisplaySourceLinesWithLineNumbers(filespec,
-                                                     self.line,
-                                                     2, # context before
-                                                     2, # context after
-                                                     '=>', # prefix for current line
-                                                     stream)
-
-        #    2
-        #    3    int main(int argc, char const *argv[]) {
-        # => 4        printf('Hello world.\\n'); // Set break point at this line.
-        #    5        return 0;
-        #    6    }
-        self.expect(stream.GetData(), 'Source code displayed correctly',
-                    exe=False,
-            patterns = ['=> %d.*Hello world' % self.line])") SBSourceManager;
-class SBSourceManager
-{
-public:
-    SBSourceManager (const lldb::SBSourceManager &rhs);
-
-    ~SBSourceManager();
-
-    size_t
-    DisplaySourceLinesWithLineNumbers (const lldb::SBFileSpec &file,
-                                       uint32_t line,
-                                       uint32_t context_before,
-                                       uint32_t context_after,
-                                       const char* current_line_cstr,
-                                       lldb::SBStream &s);
-    size_t
-    DisplaySourceLinesWithLineNumbersAndColumn (const lldb::SBFileSpec &file,
-                                                uint32_t line, uint32_t column,
-                                                uint32_t context_before,
-                                                uint32_t context_after,
-                                                const char* current_line_cstr,
-                                                lldb::SBStream &s);
-};
-
-} // namespace lldb

lldb/bindings/interface/SBSourceManagerDocstrings.i

+%feature("docstring",
+"Represents a central authority for displaying source code.
+
+For example (from test/source-manager/TestSourceManager.py), ::
+
+        # Create the filespec for 'main.c'.
+        filespec = lldb.SBFileSpec('main.c', False)
+        source_mgr = self.dbg.GetSourceManager()
+        # Use a string stream as the destination.
+        stream = lldb.SBStream()
+        source_mgr.DisplaySourceLinesWithLineNumbers(filespec,
+                                                     self.line,
+                                                     2, # context before
+                                                     2, # context after
+                                                     '=>', # prefix for current line
+                                                     stream)
+
+        #    2
+        #    3    int main(int argc, char const *argv[]) {
+        # => 4        printf('Hello world.\\n'); // Set break point at this line.
+        #    5        return 0;
+        #    6    }
+        self.expect(stream.GetData(), 'Source code displayed correctly',
+                    exe=False,
+            patterns = ['=> %d.*Hello world' % self.line])"
+) lldb::SBSourceManager;

lldb/bindings/interface/SBStreamDocstrings.i

-//===-- SWIG Interface for SBStream -----------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <stdio.h>
-
-namespace lldb {
-
 %feature("docstring",
 "Represents a destination for streaming data output to. By default, a string
 stream is created.
 
 For example (from test/source-manager/TestSourceManager.py), ::
 
         # Create the filespec for 'main.c'.
         filespec = lldb.SBFileSpec('main.c', False)
For example (from test/source-manager/TestSourceManager.py), ::
 
         #    2
         #    3    int main(int argc, char const *argv[]) {
         # => 4        printf('Hello world.\\n'); // Set break point at this line.
         #    5        return 0;
         #    6    }
         self.expect(stream.GetData(), 'Source code displayed correctly',
                     exe=False,
-            patterns = ['=> %d.*Hello world' % self.line])") SBStream;
-class SBStream
-{
-public:
-
-    SBStream ();
-
-    ~SBStream ();
-
-    bool
-    IsValid() const;
-
-    explicit operator bool() const;
+            patterns = ['=> %d.*Hello world' % self.line])"
+) lldb::SBStream;
 
-    %feature("docstring", "
     If this stream is not redirected to a file, it will maintain a local
-    cache for the stream data which can be accessed using this accessor.") GetData;
-    const char *
-    GetData ();
+    cache for the stream data which can be accessed using this accessor."
+) lldb::SBStream::GetData;
 
-    %feature("docstring", "
     If this stream is not redirected to a file, it will maintain a local
     cache for the stream output whose length can be accessed using this
-    accessor.") GetSize;
-    size_t
-    GetSize();
-
-    void
-    Print (const char* str);
-
-    void
-    RedirectToFile (const char *path, bool append);
-
-    void
-    RedirectToFile (lldb::SBFile file);
-
-    void
-    RedirectToFile (lldb::FileSP file);
-
-    %extend {
-        %feature("autodoc", "DEPRECATED, use RedirectToFile");
-        void
-        RedirectToFileHandle (lldb::FileSP file, bool transfer_fh_ownership) {
-            self->RedirectToFile(file);
-        }
-    }
-
-    void
-    RedirectToFileDescriptor (int fd, bool transfer_fh_ownership);
+    accessor."
+) lldb::SBStream::GetSize;
 
-    %feature("docstring", "
     If the stream is redirected to a file, forget about the file and if
     ownership of the file was transferred to this object, close the file.
-    If the stream is backed by a local cache, clear this cache.") Clear;
-    void
-    Clear ();
-};
-
-} // namespace lldb
+    If the stream is backed by a local cache, clear this cache."
+) lldb::SBStream::Clear;

lldb/bindings/interface/SBStreamExtensions.i

+%extend lldb::SBStream {
+    %feature("autodoc", "DEPRECATED, use RedirectToFile") RedirectToFileHandle;
+    void
+    RedirectToFileHandle (lldb::FileSP file, bool transfer_fh_ownership) {
+        self->RedirectToFile(file);
+    }
+}

lldb/bindings/interface/SBStringList.i

-//===-- SWIG Interface for SBStringList -------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-%feature("docstring",
-"Represents a list of strings."
-) SBStringList;
-class SBStringList
-{
-public:
-
-    SBStringList ();
-
-    SBStringList (const lldb::SBStringList &rhs);
-
-    ~SBStringList ();
-
-    bool
-    IsValid() const;
-
-    explicit operator bool() const;
-
-    void
-    AppendString (const char *str);
-
-    void
-    AppendList (const char **strv, int strc);
-
-    void
-    AppendList (const lldb::SBStringList &strings);
-
-    uint32_t
-    GetSize () const;
-
-    const char *
-    GetStringAtIndex (size_t idx);
-
-    void
-    Clear ();
-
-#ifdef SWIGPYTHON
-    %pythoncode%{
-    def __iter__(self):
-        '''Iterate over all strings in a lldb.SBStringList object.'''
-        return lldb_iter(self, 'GetSize', 'GetStringAtIndex')
-
-    def __len__(self):
-        '''Return the number of strings in a lldb.SBStringList object.'''
-        return self.GetSize()
-    %}
-#endif
-};
-
-} // namespace lldb

lldb/bindings/interface/SBStringListDocstrings.i

+%feature("docstring",
+"Represents a list of strings."
+) lldb::SBStringList;

lldb/bindings/interface/SBStringListExtensions.i

+%extend lldb::SBStringList {
+#ifdef SWIGPYTHON
+    %pythoncode%{
+    def __iter__(self):
+        '''Iterate over all strings in a lldb.SBStringList object.'''
+        return lldb_iter(self, 'GetSize', 'GetStringAtIndex')
+
+    def __len__(self):
+        '''Return the number of strings in a lldb.SBStringList object.'''
+        return self.GetSize()
+    %}
+#endif
+}

lldb/bindings/interface/SBStructuredData.i

-//===-- SWIG Interface for SBStructuredData ---------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-%feature("docstring",
- "A class representing a StructuredData event.
-
-This class wraps the event type generated by StructuredData features."
-) SBStructuredData;
-    class SBStructuredData
-    {
-    public:
-        SBStructuredData();
-
-        SBStructuredData(const lldb::SBStructuredData &rhs);
-
-        SBStructuredData(const lldb::EventSP &event_sp);
-
-        ~SBStructuredData();
-
-        bool
-        IsValid() const;
-
-        explicit operator bool() const;
-
-        void
-        Clear();
-
-        lldb::StructuredDataType GetType() const;
-
-        size_t GetSize() const;
-
-        bool GetKeys(lldb::SBStringList &keys) const;
-
-        lldb::SBStructuredData GetValueForKey(const char *key) const;
-
-        lldb::SBStructuredData GetItemAtIndex(size_t idx) const;
-
-        uint64_t GetIntegerValue(uint64_t fail_value = 0) const;
-
-        double GetFloatValue(double fail_value = 0.0) const;
-
-        bool GetBooleanValue(bool fail_value = false) const;
-
-        size_t GetStringValue(char *dst, size_t dst_len) const;
-
-        lldb::SBError
-        GetAsJSON(lldb::SBStream &stream) const;
-
-        lldb::SBError
-        GetDescription(lldb::SBStream &stream) const;
-
-        lldb::SBError
-        SetFromJSON(lldb::SBStream &stream);
-
-        lldb::SBError
-        SetFromJSON(const char *json);
-    };
-}

lldb/bindings/interface/SBStructuredDataDocstrings.i

+%feature("docstring",
+ "A class representing a StructuredData event.
+
+This class wraps the event type generated by StructuredData features."
+) lldb::SBStructuredData;

lldb/bindings/interface/SBSymbolContext.i

-//===-- SWIG Interface for SBSymbolContext ----------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-%feature("docstring",
-"A context object that provides access to core debugger entities.
-
-Many debugger functions require a context when doing lookups. This class
-provides a common structure that can be used as the result of a query that
-can contain a single result.
-
-For example, ::
-
-        exe = os.path.join(os.getcwd(), 'a.out')
-
-        # Create a target for the debugger.
-        target = self.dbg.CreateTarget(exe)
-
-        # Now create a breakpoint on main.c by name 'c'.
-        breakpoint = target.BreakpointCreateByName('c', 'a.out')
-
-        # Now launch the process, and do not stop at entry point.
-        process = target.LaunchSimple(None, None, os.getcwd())
-
-        # The inferior should stop on 'c'.
-        from lldbutil import get_stopped_thread
-        thread = get_stopped_thread(process, lldb.eStopReasonBreakpoint)
-        frame0 = thread.GetFrameAtIndex(0)
-
-        # Now get the SBSymbolContext from this frame.  We want everything. :-)
-        context = frame0.GetSymbolContext(lldb.eSymbolContextEverything)
-
-        # Get the module.
-        module = context.GetModule()
-        ...
-
-        # And the compile unit associated with the frame.
-        compileUnit = context.GetCompileUnit()
-        ...
-"
-) SBSymbolContext;
-class SBSymbolContext
-{
-public:
-    SBSymbolContext ();
-
-    SBSymbolContext (const lldb::SBSymbolContext& rhs);
-
-    ~SBSymbolContext ();
-
-    bool
-    IsValid () const;
-
-    explicit operator bool() const;
-
-    lldb::SBModule        GetModule ();
-    lldb::SBCompileUnit   GetCompileUnit ();
-    lldb::SBFunction      GetFunction ();
-    lldb::SBBlock         GetBlock ();
-    lldb::SBLineEntry     GetLineEntry ();
-    lldb::SBSymbol        GetSymbol ();
-
-    void SetModule      (lldb::SBModule module);
-    void SetCompileUnit (lldb::SBCompileUnit compile_unit);
-    void SetFunction    (lldb::SBFunction function);
-    void SetBlock       (lldb::SBBlock block);
-    void SetLineEntry   (lldb::SBLineEntry line_entry);
-    void SetSymbol      (lldb::SBSymbol symbol);
-
-    lldb::SBSymbolContext
-    GetParentOfInlinedScope (const lldb::SBAddress &curr_frame_pc,
-                             lldb::SBAddress &parent_frame_addr) const;
-
-
-    bool
-    GetDescription (lldb::SBStream &description);
-
-    STRING_EXTENSION(SBSymbolContext)
-
-#ifdef SWIGPYTHON
-    %pythoncode %{
-        module = property(GetModule, SetModule, doc='''A read/write property that allows the getting/setting of the module (lldb.SBModule) in this symbol context.''')
-        compile_unit = property(GetCompileUnit, SetCompileUnit, doc='''A read/write property that allows the getting/setting of the compile unit (lldb.SBCompileUnit) in this symbol context.''')
-        function = property(GetFunction, SetFunction, doc='''A read/write property that allows the getting/setting of the function (lldb.SBFunction) in this symbol context.''')
-        block = property(GetBlock, SetBlock, doc='''A read/write property that allows the getting/setting of the block (lldb.SBBlock) in this symbol context.''')
-        symbol = property(GetSymbol, SetSymbol, doc='''A read/write property that allows the getting/setting of the symbol (lldb.SBSymbol) in this symbol context.''')
-        line_entry = property(GetLineEntry, SetLineEntry, doc='''A read/write property that allows the getting/setting of the line entry (lldb.SBLineEntry) in this symbol context.''')
-    %}
-#endif
-
-};
-
-} // namespace lldb

lldb/bindings/interface/SBSymbolContextDocstrings.i

+%feature("docstring",
+"A context object that provides access to core debugger entities.
+
+Many debugger functions require a context when doing lookups. This class
+provides a common structure that can be used as the result of a query that
+can contain a single result.
+
+For example, ::
+
+        exe = os.path.join(os.getcwd(), 'a.out')
+
+        # Create a target for the debugger.
+        target = self.dbg.CreateTarget(exe)
+
+        # Now create a breakpoint on main.c by name 'c'.
+        breakpoint = target.BreakpointCreateByName('c', 'a.out')
+
+        # Now launch the process, and do not stop at entry point.
+        process = target.LaunchSimple(None, None, os.getcwd())
+
+        # The inferior should stop on 'c'.
+        from lldbutil import get_stopped_thread
+        thread = get_stopped_thread(process, lldb.eStopReasonBreakpoint)
+        frame0 = thread.GetFrameAtIndex(0)
+
+        # Now get the SBSymbolContext from this frame.  We want everything. :-)
+        context = frame0.GetSymbolContext(lldb.eSymbolContextEverything)
+
+        # Get the module.
+        module = context.GetModule()
+        ...
+
+        # And the compile unit associated with the frame.
+        compileUnit = context.GetCompileUnit()
+        ...
+"
+) lldb::SBSymbolContext;

lldb/bindings/interface/SBSymbolContextExtensions.i

+STRING_EXTENSION_OUTSIDE(SBSymbolContext)
+
+%extend lldb::SBSymbolContext {
+#ifdef SWIGPYTHON
+    %pythoncode %{
+        module = property(GetModule, SetModule, doc='''A read/write property that allows the getting/setting of the module (lldb.SBModule) in this symbol context.''')
+        compile_unit = property(GetCompileUnit, SetCompileUnit, doc='''A read/write property that allows the getting/setting of the compile unit (lldb.SBCompileUnit) in this symbol context.''')
+        function = property(GetFunction, SetFunction, doc='''A read/write property that allows the getting/setting of the function (lldb.SBFunction) in this symbol context.''')
+        block = property(GetBlock, SetBlock, doc='''A read/write property that allows the getting/setting of the block (lldb.SBBlock) in this symbol context.''')
+        symbol = property(GetSymbol, SetSymbol, doc='''A read/write property that allows the getting/setting of the symbol (lldb.SBSymbol) in this symbol context.''')
+        line_entry = property(GetLineEntry, SetLineEntry, doc='''A read/write property that allows the getting/setting of the line entry (lldb.SBLineEntry) in this symbol context.''')
+    %}
+#endif
+}

lldb/bindings/interface/SBSymbolContextListDocstrings.i

+%feature("docstring",
+"Represents a list of symbol context object. See also SBSymbolContext.
+
+For example (from test/python_api/target/TestTargetAPI.py), ::
+
+    def find_functions(self, exe_name):
+        '''Exercise SBTarget.FindFunctions() API.'''
+        exe = os.path.join(os.getcwd(), exe_name)
+
+        # Create a target by the debugger.
+        target = self.dbg.CreateTarget(exe)
+        self.assertTrue(target, VALID_TARGET)
+
+        list = lldb.SBSymbolContextList()
+        num = target.FindFunctions('c', lldb.eFunctionNameTypeAuto, False, list)
+        self.assertTrue(num == 1 and list.GetSize() == 1)
+
+        for sc in list:
+            self.assertTrue(sc.GetModule().GetFileSpec().GetFilename() == exe_name)
+            self.assertTrue(sc.GetSymbol().GetName() == 'c')"
+) lldb::SBSymbolContextList;

lldb/bindings/interface/SBSymbolContextListExtensions.i

-//===-- SWIG Interface for SBSymbolContextList ------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-%feature("docstring",
-"Represents a list of symbol context object. See also SBSymbolContext.
-
-For example (from test/python_api/target/TestTargetAPI.py), ::
-
-    def find_functions(self, exe_name):
-        '''Exercise SBTarget.FindFunctions() API.'''
-        exe = os.path.join(os.getcwd(), exe_name)
-
-        # Create a target by the debugger.
-        target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target, VALID_TARGET)
-
-        list = lldb.SBSymbolContextList()
-        num = target.FindFunctions('c', lldb.eFunctionNameTypeAuto, False, list)
-        self.assertTrue(num == 1 and list.GetSize() == 1)
-
-        for sc in list:
-            self.assertTrue(sc.GetModule().GetFileSpec().GetFilename() == exe_name)
-            self.assertTrue(sc.GetSymbol().GetName() == 'c')") SBSymbolContextList;
-class SBSymbolContextList
-{
-public:
-    SBSymbolContextList ();
-
-    SBSymbolContextList (const lldb::SBSymbolContextList& rhs);
-
-    ~SBSymbolContextList ();
-
-    bool
-    IsValid () const;
-
-    explicit operator bool() const;
-
-    uint32_t
-    GetSize() const;
-
-    SBSymbolContext
-    GetContextAtIndex (uint32_t idx);
-
-    void
-    Append (lldb::SBSymbolContext &sc);
-
-    void
-    Append (lldb::SBSymbolContextList &sc_list);
-
-    bool
-    GetDescription (lldb::SBStream &description);
-
-    void
-    Clear();
-
-    STRING_EXTENSION(SBSymbolContextList)
+STRING_EXTENSION_OUTSIDE(SBSymbolContextList)
 
+%extend lldb::SBSymbolContextList {
 #ifdef SWIGPYTHON
     %pythoncode %{
         def __iter__(self):
             '''Iterate over all symbol contexts in a lldb.SBSymbolContextList
             object.'''
             return lldb_iter(self, 'GetSize', 'GetContextAtIndex')
 
         def __len__(self):
%pythoncode %{
         modules = property(get_module_array, None, doc='''Returns a list() of lldb.SBModule objects, one for each module in each SBSymbolContext object in this list.''')
         compile_units = property(get_compile_unit_array, None, doc='''Returns a list() of lldb.SBCompileUnit objects, one for each compile unit in each SBSymbolContext object in this list.''')
         functions = property(get_function_array, None, doc='''Returns a list() of lldb.SBFunction objects, one for each function in each SBSymbolContext object in this list.''')
         blocks = property(get_block_array, None, doc='''Returns a list() of lldb.SBBlock objects, one for each block in each SBSymbolContext object in this list.''')
         line_entries = property(get_line_entry_array, None, doc='''Returns a list() of lldb.SBLineEntry objects, one for each line entry in each SBSymbolContext object in this list.''')
         symbols = property(get_symbol_array, None, doc='''Returns a list() of lldb.SBSymbol objects, one for each symbol in each SBSymbolContext object in this list.''')
     %}
 #endif
-
-};
-
-} // namespace lldb
+}

lldb/bindings/interface/SBSymbolDocstrings.i

+%feature("docstring",
+"Represents the symbol possibly associated with a stack frame.
+:py:class:`SBModule` contains SBSymbol(s). SBSymbol can also be retrieved from :py:class:`SBFrame` ."
+) lldb::SBSymbol;

lldb/bindings/interface/SBSymbolExtensions.i

-//===-- SWIG Interface for SBSymbol -----------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-%feature("docstring",
-"Represents the symbol possibly associated with a stack frame.
-:py:class:`SBModule` contains SBSymbol(s). SBSymbol can also be retrieved from :py:class:`SBFrame` ."
-) SBSymbol;
-class SBSymbol
-{
-public:
-
-    SBSymbol ();
-
-    ~SBSymbol ();
-
-    SBSymbol (const lldb::SBSymbol &rhs);
-
-    bool
-    IsValid () const;
-
-    explicit operator bool() const;
-
-
-    const char *
-    GetName() const;
-
-    const char *
-    GetDisplayName() const;
-
-    const char *
-    GetMangledName () const;
-
-    lldb::SBInstructionList
-    GetInstructions (lldb::SBTarget target);
-
-    lldb::SBInstructionList
-    GetInstructions (lldb::SBTarget target, const char *flavor_string);
-
-    SBAddress
-    GetStartAddress ();
-
-    SBAddress
-    GetEndAddress ();
-
-    uint64_t GetValue();
-
-    uint64_t GetSize();
-
-    uint32_t
-    GetPrologueByteSize ();
-
-    SymbolType
-    GetType ();
-
-    bool
-    GetDescription (lldb::SBStream &description);
-
-    bool
-    IsExternal();
-
-    bool
-    IsSynthetic();
-
-    bool
-    operator == (const lldb::SBSymbol &rhs) const;
-
-    bool
-    operator != (const lldb::SBSymbol &rhs) const;
-
-    STRING_EXTENSION(SBSymbol)
+STRING_EXTENSION_OUTSIDE(SBSymbol)
 
+%extend lldb::SBSymbol {
 #ifdef SWIGPYTHON
     %pythoncode %{
         def get_instructions_from_current_target (self):
             return self.GetInstructions (target)
 
         name = property(GetName, None, doc='''A read only property that returns the name for this symbol as a string.''')
         mangled = property(GetMangledName, None, doc='''A read only property that returns the mangled (linkage) name for this symbol as a string.''')
         type = property(GetType, None, doc='''A read only property that returns an lldb enumeration value (see enumerations that start with "lldb.eSymbolType") that represents the type of this symbol.''')
         addr = property(GetStartAddress, None, doc='''A read only property that returns an lldb object that represents the start address (lldb.SBAddress) for this symbol.''')
         end_addr = property(GetEndAddress, None, doc='''A read only property that returns an lldb object that represents the end address (lldb.SBAddress) for this symbol.''')
         prologue_size = property(GetPrologueByteSize, None, doc='''A read only property that returns the size in bytes of the prologue instructions as an unsigned integer.''')
         instructions = property(get_instructions_from_current_target, None, doc='''A read only property that returns an lldb object that represents the instructions (lldb.SBInstructionList) for this symbol.''')
         external = property(IsExternal, None, doc='''A read only property that returns a boolean value that indicates if this symbol is externally visiable (exported) from the module that contains it.''')
         synthetic = property(IsSynthetic, None, doc='''A read only property that returns a boolean value that indicates if this symbol was synthetically created from information in module that contains it.''')
     %}
 #endif
-
-};
-
-} // namespace lldb
+}

lldb/bindings/interface/SBTarget.i

-//===-- SWIG Interface for SBTarget -----------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-%feature("docstring",
-"Represents the target program running under the debugger.
-
-SBTarget supports module, breakpoint, and watchpoint iterations. For example, ::
-
-    for m in target.module_iter():
-        print m
-
-produces: ::
-
-    (x86_64) /Volumes/data/lldb/svn/trunk/test/python_api/lldbutil/iter/a.out
-    (x86_64) /usr/lib/dyld
-    (x86_64) /usr/lib/libstdc++.6.dylib
-    (x86_64) /usr/lib/libSystem.B.dylib
-    (x86_64) /usr/lib/system/libmathCommon.A.dylib
-    (x86_64) /usr/lib/libSystem.B.dylib(__commpage)
-
-and, ::
-
-    for b in target.breakpoint_iter():
-        print b
-
-produces: ::
-
-    SBBreakpoint: id = 1, file ='main.cpp', line = 66, locations = 1
-    SBBreakpoint: id = 2, file ='main.cpp', line = 85, locations = 1
-
-and, ::
-
-    for wp_loc in target.watchpoint_iter():
-        print wp_loc
-
-produces: ::
-
-    Watchpoint 1: addr = 0x1034ca048 size = 4 state = enabled type = rw
-        declare @ '/Volumes/data/lldb/svn/trunk/test/python_api/watchpoint/main.c:12'
-        hw_index = 0  hit_count = 2     ignore_count = 0"
-) SBTarget;
-class SBTarget
-{
-public:
-    //------------------------------------------------------------------
-    // Broadcaster bits.
-    //------------------------------------------------------------------
-    enum
-    {
-        eBroadcastBitBreakpointChanged  = (1 << 0),
-        eBroadcastBitModulesLoaded      = (1 << 1),
-        eBroadcastBitModulesUnloaded    = (1 << 2),
-        eBroadcastBitWatchpointChanged  = (1 << 3),
-        eBroadcastBitSymbolsLoaded      = (1 << 4)
-    };
-
-    //------------------------------------------------------------------
-    // Constructors
-    //------------------------------------------------------------------
-    SBTarget ();
-
-    SBTarget (const lldb::SBTarget& rhs);
-
-    //------------------------------------------------------------------
-    // Destructor
-    //------------------------------------------------------------------
-    ~SBTarget();
-
-    static const char *
-    GetBroadcasterClassName ();
-
-    bool
-    IsValid() const;
-
-    explicit operator bool() const;
-
-    static bool
-    EventIsTargetEvent (const lldb::SBEvent &event);
-
-    static lldb::SBTarget
-    GetTargetFromEvent (const lldb::SBEvent &event);
-
-    static uint32_t
-    GetNumModulesFromEvent (const lldb::SBEvent &event);
-
-    static lldb::SBModule
-    GetModuleAtIndexFromEvent (const uint32_t idx, const lldb::SBEvent &event);
-
-    lldb::SBProcess
-    GetProcess ();
-
-
-    %feature("docstring", "
-    Return the platform object associated with the target.
-
-    After return, the platform object should be checked for
-    validity.
-
-    @return
-        A platform object.") GetPlatform;
-    lldb::SBPlatform
-    GetPlatform ();
-
-    %feature("docstring", "
-    Install any binaries that need to be installed.
-
-    This function does nothing when debugging on the host system.
-    When connected to remote platforms, the target's main executable
-    and any modules that have their install path set will be
-    installed on the remote platform. If the main executable doesn't
-    have an install location set, it will be installed in the remote
-    platform's working directory.
-
-    @return
-        An error describing anything that went wrong during
-        installation.") Install;
-    lldb::SBError
-    Install();
-
-    %feature("docstring", "
-    Launch a new process.
-
-    Launch a new process by spawning a new process using the
-    target object's executable module's file as the file to launch.
-    Arguments are given in argv, and the environment variables
-    are in envp. Standard input and output files can be
-    optionally re-directed to stdin_path, stdout_path, and
-    stderr_path.
-
-    @param[in] listener
-        An optional listener that will receive all process events.
-        If listener is valid then listener will listen to all
-        process events. If not valid, then this target's debugger
-        (SBTarget::GetDebugger()) will listen to all process events.
-
-    @param[in] argv
-        The argument array.
-
-    @param[in] envp
-        The environment array.
-
-    @param[in] launch_flags
-        Flags to modify the launch (@see lldb::LaunchFlags)
-
-    @param[in] stdin_path
-        The path to use when re-directing the STDIN of the new
-        process. If all stdXX_path arguments are NULL, a pseudo
-        terminal will be used.
-
-    @param[in] stdout_path
-        The path to use when re-directing the STDOUT of the new
-        process. If all stdXX_path arguments are NULL, a pseudo
-        terminal will be used.
-
-    @param[in] stderr_path
-        The path to use when re-directing the STDERR of the new
-        process. If all stdXX_path arguments are NULL, a pseudo
-        terminal will be used.
-
-    @param[in] working_directory
-        The working directory to have the child process run in
-
-    @param[in] launch_flags
-        Some launch options specified by logical OR'ing
-        lldb::LaunchFlags enumeration values together.
-
-    @param[in] stop_at_entry
-        If false do not stop the inferior at the entry point.
-
-    @param[out]
-        An error object. Contains the reason if there is some failure.
-
-    @return
-         A process object for the newly created process.
-
-    For example,
-
-        process = target.Launch(self.dbg.GetListener(), None, None,
-                                None, '/tmp/stdout.txt', None,
-                                None, 0, False, error)
-
-    launches a new process by passing nothing for both the args and the envs
-    and redirect the standard output of the inferior to the /tmp/stdout.txt
-    file. It does not specify a working directory so that the debug server
-    will use its idea of what the current working directory is for the
-    inferior. Also, we ask the debugger not to stop the inferior at the
-    entry point. If no breakpoint is specified for the inferior, it should
-    run to completion if no user interaction is required.") Launch;
-    lldb::SBProcess
-    Launch (SBListener &listener,
-            char const **argv,
-            char const **envp,
-            const char *stdin_path,
-            const char *stdout_path,
-            const char *stderr_path,
-            const char *working_directory,
-            uint32_t launch_flags,   // See LaunchFlags
-            bool stop_at_entry,
-            lldb::SBError& error);
-
-    %feature("docstring", "
-    Launch a new process with sensible defaults.
-
-    :param argv: The argument array.
-    :param envp: The environment array.
-    :param working_directory: The working directory to have the child process run in
-    :return: The newly created process.
-    :rtype: SBProcess
-
-    A pseudo terminal will be used as stdin/stdout/stderr.
-    No launch flags are passed and the target's debuger is used as a listener.
-
-    For example, ::
-
-        process = target.LaunchSimple(['X', 'Y', 'Z'], None, os.getcwd())
-
-    launches a new process by passing 'X', 'Y', 'Z' as the args to the
-    executable.") LaunchSimple;
-    lldb::SBProcess
-    LaunchSimple (const char **argv,
-                  const char **envp,
-                  const char *working_directory);
-
-    lldb::SBProcess
-    Launch (lldb::SBLaunchInfo &launch_info, lldb::SBError& error);
-
-    %feature("docstring", "
-    Load a core file
-
-    @param[in] core_file
-        File path of the core dump.
-
-    @param[out] error
-        An error explaining what went wrong if the operation fails.
-        (Optional)
-
-    @return
-         A process object for the newly created core file.
-
-    For example,
-
-        process = target.LoadCore('./a.out.core')
-
-    loads a new core file and returns the process object.") LoadCore;
-    lldb::SBProcess
-    LoadCore(const char *core_file);
-
-    lldb::SBProcess
-    LoadCore(const char *core_file, lldb::SBError &error);
-
-    lldb::SBProcess
-    Attach(lldb::SBAttachInfo &attach_info, lldb::SBError& error);
-
-    %feature("docstring", "
-    Attach to process with pid.
-
-    @param[in] listener
-        An optional listener that will receive all process events.
-        If listener is valid then listener will listen to all
-        process events. If not valid, then this target's debugger
-        (SBTarget::GetDebugger()) will listen to all process events.
-
-    @param[in] pid
-        The process ID to attach to.
-
-    @param[out]
-        An error explaining what went wrong if attach fails.
-
-    @return
-         A process object for the attached process.") AttachToProcessWithID;
-    lldb::SBProcess
-    AttachToProcessWithID (SBListener &listener,
-                           lldb::pid_t pid,
-                           lldb::SBError& error);
-
-    %feature("docstring", "
-    Attach to process with name.
-
-    @param[in] listener
-        An optional listener that will receive all process events.
-        If listener is valid then listener will listen to all
-        process events. If not valid, then this target's debugger
-        (SBTarget::GetDebugger()) will listen to all process events.
-
-    @param[in] name
-        Basename of process to attach to.
-
-    @param[in] wait_for
-        If true wait for a new instance of 'name' to be launched.
-
-    @param[out]
-        An error explaining what went wrong if attach fails.
-
-    @return
-         A process object for the attached process.") AttachToProcessWithName;
-    lldb::SBProcess
-    AttachToProcessWithName (SBListener &listener,
-                             const char *name,
-                             bool wait_for,
-                             lldb::SBError& error);
-
-    %feature("docstring", "
-    Connect to a remote debug server with url.
-
-    @param[in] listener
-        An optional listener that will receive all process events.
-        If listener is valid then listener will listen to all
-        process events. If not valid, then this target's debugger
-        (SBTarget::GetDebugger()) will listen to all process events.
-
-    @param[in] url
-        The url to connect to, e.g., 'connect://localhost:12345'.
-
-    @param[in] plugin_name
-        The plugin name to be used; can be NULL.
-
-    @param[out]
-        An error explaining what went wrong if the connect fails.
-
-    @return
-         A process object for the connected process.") ConnectRemote;
-    lldb::SBProcess
-    ConnectRemote (SBListener &listener,
-                   const char *url,
-                   const char *plugin_name,
-                   SBError& error);
-
-    lldb::SBFileSpec
-    GetExecutable ();
-
-    %feature("docstring", "
-    Append the path mapping (from -> to) to the target's paths mapping list.") AppendImageSearchPath;
-    void
-    AppendImageSearchPath (const char *from,
-                           const char *to,
-                           SBError &error);
-
-    bool
-    AddModule (lldb::SBModule &module);
-
-    lldb::SBModule
-    AddModule (const char *path,
-               const char *triple,
-               const char *uuid);
-
-    lldb::SBModule
-    AddModule (const char *path,
-               const char *triple,
-               const char *uuid_cstr,
-               const char *symfile);
-
-    lldb::SBModule
-    AddModule (const SBModuleSpec &module_spec);
-
-    uint32_t
-    GetNumModules () const;
-
-    lldb::SBModule
-    GetModuleAtIndex (uint32_t idx);
-
-    bool
-    RemoveModule (lldb::SBModule module);
-
-    lldb::SBDebugger
-    GetDebugger() const;
-
-    lldb::SBModule
-    FindModule (const lldb::SBFileSpec &file_spec);
-
-    %feature("docstring", "
-    Find compile units related to this target and passed source
-    file.
-
-    :param sb_file_spec: A :py:class:`lldb::SBFileSpec` object that contains source file
-        specification.
-    :return: The symbol contexts for all the matches.
-    :rtype: SBSymbolContextList") FindCompileUnits;
-    lldb::SBSymbolContextList
-    FindCompileUnits (const lldb::SBFileSpec &sb_file_spec);
-
-    lldb::ByteOrder
-    GetByteOrder ();
-
-    uint32_t
-    GetAddressByteSize();
-
-    const char *
-    GetTriple ();
-
-    const char *
-    GetABIName();
-
-    %feature("docstring", "
-    Architecture data byte width accessor
-
-    :return: The size in 8-bit (host) bytes of a minimum addressable unit from the Architecture's data bus.
-
-    ") GetDataByteSize;
-    uint32_t
-    GetDataByteSize ();
-
-    %feature("docstring", "
-    Architecture code byte width accessor.
-
-    :return: The size in 8-bit (host) bytes of a minimum addressable unit from the Architecture's code bus.
-
-    ") GetCodeByteSize;
-    uint32_t
-    GetCodeByteSize ();
-
-    uint32_t
-    GetMaximumNumberOfChildrenToDisplay() const;
-
-    lldb::SBError
-    SetSectionLoadAddress (lldb::SBSection section,
-                           lldb::addr_t section_base_addr);
-
-    lldb::SBError
-    ClearSectionLoadAddress (lldb::SBSection section);
-
-    lldb::SBError
-    SetModuleLoadAddress (lldb::SBModule module,
-                          int64_t sections_offset);
-
-    lldb::SBError
-    ClearModuleLoadAddress (lldb::SBModule module);
-
-    %feature("docstring", "
-    Find functions by name.
-
-    :param name: The name of the function we are looking for.
-
-    :param name_type_mask:
-        A logical OR of one or more FunctionNameType enum bits that
-        indicate what kind of names should be used when doing the
-        lookup. Bits include fully qualified names, base names,
-        C++ methods, or ObjC selectors.
-        See FunctionNameType for more details.
-
-    :return:
-        A lldb::SBSymbolContextList that gets filled in with all of
-        the symbol contexts for all the matches.") FindFunctions;
-    lldb::SBSymbolContextList
-    FindFunctions (const char *name,
-                   uint32_t name_type_mask = lldb::eFunctionNameTypeAny);
-
-    lldb::SBType
-    FindFirstType (const char* type);
-
-    lldb::SBTypeList
-    FindTypes (const char* type);
-
-    lldb::SBType
-    GetBasicType(lldb::BasicType type);
-
-    lldb::SBSourceManager
-    GetSourceManager ();
-
-    %feature("docstring", "
-    Find global and static variables by name.
-
-    @param[in] name
-        The name of the global or static variable we are looking
-        for.
-
-    @param[in] max_matches
-        Allow the number of matches to be limited to max_matches.
-
-    @return
-        A list of matched variables in an SBValueList.") FindGlobalVariables;
-    lldb::SBValueList
-    FindGlobalVariables (const char *name,
-                         uint32_t max_matches);
-
-     %feature("docstring", "
-    Find the first global (or static) variable by name.
-
-    @param[in] name
-        The name of the global or static variable we are looking
-        for.
-
-    @return
-        An SBValue that gets filled in with the found variable (if any).") FindFirstGlobalVariable;
-    lldb::SBValue
-    FindFirstGlobalVariable (const char* name);
-
-
-    lldb::SBValueList
-    FindGlobalVariables(const char *name,
-                        uint32_t max_matches,
-                        MatchType matchtype);
-
-    lldb::SBSymbolContextList
-    FindGlobalFunctions(const char *name,
-                        uint32_t max_matches,
-                        MatchType matchtype);
-
-    void
-    Clear ();
-
-     %feature("docstring", "
-    Resolve a current file address into a section offset address.
-
-    @param[in] file_addr
-
-    @return
-        An SBAddress which will be valid if...") ResolveFileAddress;
-    lldb::SBAddress
-    ResolveFileAddress (lldb::addr_t file_addr);
-
-    lldb::SBAddress
-    ResolveLoadAddress (lldb::addr_t vm_addr);
-
-    lldb::SBAddress
-    ResolvePastLoadAddress (uint32_t stop_id, lldb::addr_t vm_addr);
-
-    SBSymbolContext
-    ResolveSymbolContextForAddress (const SBAddress& addr,
-                                    uint32_t resolve_scope);
-
-     %feature("docstring", "
-    Read target memory. If a target process is running then memory
-    is read from here. Otherwise the memory is read from the object
-    files. For a target whose bytes are sized as a multiple of host
-    bytes, the data read back will preserve the target's byte order.
-
-    @param[in] addr
-        A target address to read from.
-
-    @param[out] buf
-        The buffer to read memory into.
-
-    @param[in] size
-        The maximum number of host bytes to read in the buffer passed
-        into this call
-
-    @param[out] error
-        Error information is written here if the memory read fails.
-
-    @return
-        The amount of data read in host bytes.") ReadMemory;
-    size_t
-    ReadMemory (const SBAddress addr, void *buf, size_t size, lldb::SBError &error);
-
-    lldb::SBBreakpoint
-    BreakpointCreateByLocation (const char *file, uint32_t line);
-
-    lldb::SBBreakpoint
-    BreakpointCreateByLocation (const lldb::SBFileSpec &file_spec, uint32_t line);
-
-    lldb::SBBreakpoint
-    BreakpointCreateByLocation (const lldb::SBFileSpec &file_spec, uint32_t line, lldb::addr_t offset);
-
-    lldb::SBBreakpoint
-    BreakpointCreateByLocation (const lldb::SBFileSpec &file_spec, uint32_t line,
-                                lldb::addr_t offset, SBFileSpecList &module_list);
-
-    lldb::SBBreakpoint
-    BreakpointCreateByLocation (const lldb::SBFileSpec &file_spec, uint32_t line,
-                                uint32_t column, lldb::addr_t offset,
-                                SBFileSpecList &module_list);
-
-    lldb::SBBreakpoint
-    BreakpointCreateByLocation (const lldb::SBFileSpec &file_spec, uint32_t line,
-                                uint32_t column, lldb::addr_t offset,
-                                SBFileSpecList &module_list,
-                                bool move_to_nearest_code);
-
-    lldb::SBBreakpoint
-    BreakpointCreateByName (const char *symbol_name, const char *module_name = NULL);
-
-    lldb::SBBreakpoint
-    BreakpointCreateByName (const char *symbol_name,
-                            uint32_t func_name_type,           // Logical OR one or more FunctionNameType enum bits
-                            const SBFileSpecList &module_list,
-                            const SBFileSpecList &comp_unit_list);
-
-    lldb::SBBreakpoint
-    BreakpointCreateByName (const char *symbol_name,
-                            uint32_t func_name_type,           // Logical OR one or more FunctionNameType enum bits
-                            lldb::LanguageType symbol_language,
-                            const SBFileSpecList &module_list,
-                            const SBFileSpecList &comp_unit_list);
-
-#ifdef SWIGPYTHON
-%typemap(in) (const char **symbol_name, uint32_t num_names) {
-  using namespace lldb_private;
-  /* Check if is a list  */
-  if (PythonList::Check($input)) {
-    PythonList list(PyRefType::Borrowed, $input);
-    $2 = list.GetSize();
-    int i = 0;
-    $1 = (char**)malloc(($2+1)*sizeof(char*));
-    for (i = 0; i < $2; i++) {
-      PythonString py_str = list.GetItemAtIndex(i).AsType<PythonString>();
-      if (!py_str.IsAllocated()) {
-        PyErr_SetString(PyExc_TypeError,"list must contain strings and blubby");
-        free($1);
-        return nullptr;
-      }
-
-      $1[i] = const_cast<char*>(py_str.GetString().data());
-    }
-    $1[i] = 0;
-  } else if ($input == Py_None) {
-    $1 =  NULL;
-  } else {
-    PyErr_SetString(PyExc_TypeError,"not a list");
-    return NULL;
-  }
-}
-#endif
-
-    lldb::SBBreakpoint
-    BreakpointCreateByNames (const char **symbol_name,
-                             uint32_t num_names,
-                             uint32_t name_type_mask,           // Logical OR one or more FunctionNameType enum bits
-                             const SBFileSpecList &module_list,
-                             const SBFileSpecList &comp_unit_list);
-
-    lldb::SBBreakpoint
-    BreakpointCreateByNames (const char **symbol_name,
-                             uint32_t num_names,
-                             uint32_t name_type_mask,           // Logical OR one or more FunctionNameType enum bits
-                             lldb::LanguageType symbol_language,
-                             const SBFileSpecList &module_list,
-                             const SBFileSpecList &comp_unit_list);
-
-    lldb::SBBreakpoint
-    BreakpointCreateByNames (const char **symbol_name,
-                             uint32_t num_names,
-                             uint32_t name_type_mask,           // Logical OR one or more FunctionNameType enum bits
-                             lldb::LanguageType symbol_language,
-                             lldb::addr_t offset,
-                             const SBFileSpecList &module_list,
-                             const SBFileSpecList &comp_unit_list);
-
-    lldb::SBBreakpoint
-    BreakpointCreateByRegex (const char *symbol_name_regex, const char *module_name = NULL);
-
-    lldb::SBBreakpoint
-    BreakpointCreateByRegex (const char *symbol_name_regex,
-                             lldb::LanguageType symbol_language,
-                             const SBFileSpecList &module_list,
-                             const SBFileSpecList &comp_unit_list);
-
-    lldb::SBBreakpoint
-    BreakpointCreateBySourceRegex (const char *source_regex, const lldb::SBFileSpec &source_file, const char *module_name = NULL);
-
-    lldb::SBBreakpoint
-    BreakpointCreateBySourceRegex (const char *source_regex, const lldb::SBFileSpecList &module_list, const lldb::SBFileSpecList &file_list);
-
-    lldb::SBBreakpoint
-    BreakpointCreateBySourceRegex (const char *source_regex,
-                                   const SBFileSpecList &module_list,
-                                   const SBFileSpecList &source_file,
-                                   const SBStringList  &func_names);
-
-    lldb::SBBreakpoint
-    BreakpointCreateForException  (lldb::LanguageType language,
-                                   bool catch_bp,
-                                   bool throw_bp);
-
-    lldb::SBBreakpoint
-    BreakpointCreateByAddress (addr_t address);
-
-    lldb::SBEnvironment
-    GetEnvironment();
-
-    lldb::SBBreakpoint
-    BreakpointCreateBySBAddress (SBAddress &sb_address);
-
-    %feature("docstring", "
-    Create a breakpoint using a scripted resolver.
-
-    @param[in] class_name
-       This is the name of the class that implements a scripted resolver.
-       The class should have the following signature: ::
-
-           class Resolver:
-               def __init__(self, bkpt, extra_args):
-                   # bkpt - the breakpoint for which this is the resolver.  When
-                   # the resolver finds an interesting address, call AddLocation
-                   # on this breakpoint to add it.
-                   #
-                   # extra_args - an SBStructuredData that can be used to
-                   # parametrize this instance.  Same as the extra_args passed
-                   # to BreakpointCreateFromScript.
-
-               def __get_depth__ (self):
-                   # This is optional, but if defined, you should return the
-                   # depth at which you want the callback to be called.  The
-                   # available options are:
-                   #    lldb.eSearchDepthModule
-                   #    lldb.eSearchDepthCompUnit
-                   # The default if you don't implement this method is
-                   # eSearchDepthModule.
-
-               def __callback__(self, sym_ctx):
-                   # sym_ctx - an SBSymbolContext that is the cursor in the
-                   # search through the program to resolve breakpoints.
-                   # The sym_ctx will be filled out to the depth requested in
-                   # __get_depth__.
-                   # Look in this sym_ctx for new breakpoint locations,
-                   # and if found use bkpt.AddLocation to add them.
-                   # Note, you will only get called for modules/compile_units that
-                   # pass the SearchFilter provided by the module_list & file_list
-                   # passed into BreakpointCreateFromScript.
-
-               def get_short_help(self):
-                   # Optional, but if implemented return a short string that will
-                   # be printed at the beginning of the break list output for the
-                   # breakpoint.
-
-    @param[in] extra_args
-       This is an SBStructuredData object that will get passed to the
-       constructor of the class in class_name.  You can use this to
-       reuse the same class, parametrizing it with entries from this
-       dictionary.
-
-    @param module_list
-       If this is non-empty, this will be used as the module filter in the
-       SearchFilter created for this breakpoint.
-
-    @param file_list
-       If this is non-empty, this will be used as the comp unit filter in the
-       SearchFilter created for this breakpoint.
-
-    @return
-        An SBBreakpoint that will set locations based on the logic in the
-        resolver's search callback.") BreakpointCreateFromScript;
-    lldb::SBBreakpoint BreakpointCreateFromScript(
-      const char *class_name,
-      SBStructuredData &extra_args,
-      const SBFileSpecList &module_list,
-      const SBFileSpecList &file_list,
-      bool request_hardware = false);
-
-    uint32_t
-    GetNumBreakpoints () const;
-
-    lldb::SBBreakpoint
-    GetBreakpointAtIndex (uint32_t idx) const;
-
-    bool
-    BreakpointDelete (break_id_t break_id);
-
-    lldb::SBBreakpoint
-    FindBreakpointByID (break_id_t break_id);
-
-
-    bool FindBreakpointsByName(const char *name, SBBreakpointList &bkpt_list);
-
-    void DeleteBreakpointName(const char *name);
-
-    void GetBreakpointNames(SBStringList &names);
-
-    bool
-    EnableAllBreakpoints ();
-
-    bool
-    DisableAllBreakpoints ();
-
-    bool
-    DeleteAllBreakpoints ();
-
-     %feature("docstring", "
-    Read breakpoints from source_file and return the newly created
-    breakpoints in bkpt_list.
-
-    @param[in] source_file
-       The file from which to read the breakpoints
-
-    @param[out] bkpt_list
-       A list of the newly created breakpoints.
-
-    @return
-        An SBError detailing any errors in reading in the breakpoints.") BreakpointsCreateFromFile;
-    lldb::SBError
-    BreakpointsCreateFromFile(SBFileSpec &source_file,
-                              SBBreakpointList &bkpt_list);
-
-     %feature("docstring", "
-    Read breakpoints from source_file and return the newly created
-    breakpoints in bkpt_list.
-
-    @param[in] source_file
-       The file from which to read the breakpoints
-
-    @param[in] matching_names
-       Only read in breakpoints whose names match one of the names in this
-       list.
-
-    @param[out] bkpt_list
-       A list of the newly created breakpoints.
-
-    @return
-        An SBError detailing any errors in reading in the breakpoints.") BreakpointsCreateFromFile;
-    lldb::SBError BreakpointsCreateFromFile(SBFileSpec &source_file,
-                                          SBStringList &matching_names,
-                                          SBBreakpointList &new_bps);
-
-     %feature("docstring", "
-    Write breakpoints to dest_file.
-
-    @param[in] dest_file
-       The file to which to write the breakpoints.
-
-    @return
-        An SBError detailing any errors in writing in the breakpoints.") BreakpointsCreateFromFile;
-    lldb::SBError
-    BreakpointsWriteToFile(SBFileSpec &dest_file);
-
-     %feature("docstring", "
-    Write breakpoints listed in bkpt_list to dest_file.
-
-    @param[in] dest_file
-       The file to which to write the breakpoints.
-
-    @param[in] bkpt_list
-       Only write breakpoints from this list.
-
-    @param[in] append
-       If true, append the breakpoints in bkpt_list to the others
-       serialized in dest_file.  If dest_file doesn't exist, then a new
-       file will be created and the breakpoints in bkpt_list written to it.
-
-    @return
-        An SBError detailing any errors in writing in the breakpoints.") BreakpointsCreateFromFile;
-    lldb::SBError
-    BreakpointsWriteToFile(SBFileSpec &dest_file,
-                           SBBreakpointList &bkpt_list,
-                           bool append = false);
-
-    uint32_t
-    GetNumWatchpoints () const;
-
-    lldb::SBWatchpoint
-    GetWatchpointAtIndex (uint32_t idx) const;
-
-    bool
-    DeleteWatchpoint (lldb::watch_id_t watch_id);
-
-    lldb::SBWatchpoint
-    FindWatchpointByID (lldb::watch_id_t watch_id);
-
-    bool
-    EnableAllWatchpoints ();
-
-    bool
-    DisableAllWatchpoints ();
-
-    bool
-    DeleteAllWatchpoints ();
-
-    lldb::SBWatchpoint
-    WatchAddress (lldb::addr_t addr,
-                  size_t size,
-                  bool read,
-                  bool write,
-                  SBError &error);
-
-
-    lldb::SBBroadcaster
-    GetBroadcaster () const;
-
-     %feature("docstring", "
-    Create an SBValue with the given name by treating the memory starting at addr as an entity of type.
-
-    @param[in] name
-        The name of the resultant SBValue
-
-    @param[in] addr
-        The address of the start of the memory region to be used.
-
-    @param[in] type
-        The type to use to interpret the memory starting at addr.
-
-    @return
-        An SBValue of the given type, may be invalid if there was an error reading
-        the underlying memory.") CreateValueFromAddress;
-    lldb::SBValue
-    CreateValueFromAddress (const char *name, lldb::SBAddress addr, lldb::SBType type);
-
-    lldb::SBValue
-    CreateValueFromData (const char *name, lldb::SBData data, lldb::SBType type);
-
-    lldb::SBValue
-    CreateValueFromExpression (const char *name, const char* expr);
-
-    %feature("docstring", "
-    Disassemble a specified number of instructions starting at an address.
-
-    :param base_addr: the address to start disassembly from.
-    :param count: the number of instructions to disassemble.
-    :param flavor_string: may be 'intel' or 'att' on x86 targets to specify that style of disassembly.
-    :rtype: SBInstructionList
-    ")
-    ReadInstructions;
-    lldb::SBInstructionList
-    ReadInstructions (lldb::SBAddress base_addr, uint32_t count);
-
-    lldb::SBInstructionList
-    ReadInstructions (lldb::SBAddress base_addr, uint32_t count, const char *flavor_string);
-
-    %feature("docstring", "
-    Disassemble the bytes in a buffer and return them in an SBInstructionList.
-
-    :param base_addr: used for symbolicating the offsets in the byte stream when disassembling.
-    :param buf: bytes to be disassembled.
-    :param size: (C++) size of the buffer.
-    :rtype: SBInstructionList
-    ")
-    GetInstructions;
-    lldb::SBInstructionList
-    GetInstructions (lldb::SBAddress base_addr, const void *buf, size_t size);
-
-    %feature("docstring", "
-    Disassemble the bytes in a buffer and return them in an SBInstructionList, with a supplied flavor.
-
-    :param base_addr: used for symbolicating the offsets in the byte stream when disassembling.
-    :param flavor:  may be 'intel' or 'att' on x86 targets to specify that style of disassembly.
-    :param buf: bytes to be disassembled.
-    :param size: (C++) size of the buffer.
-    :rtype: SBInstructionList
-    ")
-    GetInstructionsWithFlavor;
-    lldb::SBInstructionList
-    GetInstructionsWithFlavor (lldb::SBAddress base_addr, const char *flavor_string, const void *buf, size_t size);
-
-    lldb::SBSymbolContextList
-    FindSymbols (const char *name, lldb::SymbolType type = eSymbolTypeAny);
-
-    bool
-    GetDescription (lldb::SBStream &description, lldb::DescriptionLevel description_level);
-
-    lldb::addr_t
-    GetStackRedZoneSize();
-
-    %feature("docstring", "
-    Returns true if the module has been loaded in this `SBTarget`.
-    A module can be loaded either by the dynamic loader or by being manually
-    added to the target (see `SBTarget.AddModule` and the ``target module add`` command).
-
-    :rtype: bool
-    ") IsLoaded;
-    bool
-    IsLoaded (const lldb::SBModule &module) const;
-
-    lldb::SBLaunchInfo
-    GetLaunchInfo () const;
-
-    void
-    SetLaunchInfo (const lldb::SBLaunchInfo &launch_info);
-
-    void SetCollectingStats(bool v);
-
-    bool GetCollectingStats();
-
-    lldb::SBStructuredData GetStatistics();
-
-    bool
-    operator == (const lldb::SBTarget &rhs) const;
-
-    bool
-    operator != (const lldb::SBTarget &rhs) const;
-
-    lldb::SBValue
-    EvaluateExpression (const char *expr);
-
-    lldb::SBValue
-    EvaluateExpression (const char *expr, const lldb::SBExpressionOptions &options);
-
-    STRING_EXTENSION_LEVEL(SBTarget, lldb::eDescriptionLevelBrief)
-
-    lldb::SBTrace
-    GetTrace ();
-
-    lldb::SBTrace
-    CreateTrace (lldb::SBError &error);
-
-#ifdef SWIGPYTHON
-    %pythoncode %{
-        class modules_access(object):
-            '''A helper object that will lazily hand out lldb.SBModule objects for a target when supplied an index, or by full or partial path.'''
-            def __init__(self, sbtarget):
-                self.sbtarget = sbtarget
-
-            def __len__(self):
-                if self.sbtarget:
-                    return int(self.sbtarget.GetNumModules())
-                return 0
-
-            def __getitem__(self, key):
-                num_modules = self.sbtarget.GetNumModules()
-                if type(key) is int:
-                    if -num_modules <= key < num_modules:
-                        key %= num_modules
-                        return self.sbtarget.GetModuleAtIndex(key)
-                elif type(key) is str:
-                    if key.find('/') == -1:
-                        for idx in range(num_modules):
-                            module = self.sbtarget.GetModuleAtIndex(idx)
-                            if module.file.basename == key:
-                                return module
-                    else:
-                        for idx in range(num_modules):
-                            module = self.sbtarget.GetModuleAtIndex(idx)
-                            if module.file.fullpath == key:
-                                return module
-                    # See if the string is a UUID
-                    try:
-                        the_uuid = uuid.UUID(key)
-                        if the_uuid:
-                            for idx in range(num_modules):
-                                module = self.sbtarget.GetModuleAtIndex(idx)
-                                if module.uuid == the_uuid:
-                                    return module
-                    except:
-                        return None
-                elif type(key) is uuid.UUID:
-                    for idx in range(num_modules):
-                        module = self.sbtarget.GetModuleAtIndex(idx)
-                        if module.uuid == key:
-                            return module
-                elif type(key) is re.SRE_Pattern:
-                    matching_modules = []
-                    for idx in range(num_modules):
-                        module = self.sbtarget.GetModuleAtIndex(idx)
-                        re_match = key.search(module.path.fullpath)
-                        if re_match:
-                            matching_modules.append(module)
-                    return matching_modules
-                else:
-                    print("error: unsupported item type: %s" % type(key))
-                return None
-
-        def get_modules_access_object(self):
-            '''An accessor function that returns a modules_access() object which allows lazy module access from a lldb.SBTarget object.'''
-            return self.modules_access (self)
-
-        def get_modules_array(self):
-            '''An accessor function that returns a list() that contains all modules in a lldb.SBTarget object.'''
-            modules = []
-            for idx in range(self.GetNumModules()):
-                modules.append(self.GetModuleAtIndex(idx))
-            return modules
-
-        def module_iter(self):
-            '''Returns an iterator over all modules in a lldb.SBTarget
-            object.'''
-            return lldb_iter(self, 'GetNumModules', 'GetModuleAtIndex')
-
-        def breakpoint_iter(self):
-            '''Returns an iterator over all breakpoints in a lldb.SBTarget
-            object.'''
-            return lldb_iter(self, 'GetNumBreakpoints', 'GetBreakpointAtIndex')
-
-        def watchpoint_iter(self):
-            '''Returns an iterator over all watchpoints in a lldb.SBTarget
-            object.'''
-            return lldb_iter(self, 'GetNumWatchpoints', 'GetWatchpointAtIndex')
-
-        modules = property(get_modules_array, None, doc='''A read only property that returns a list() of lldb.SBModule objects contained in this target. This list is a list all modules that the target currently is tracking (the main executable and all dependent shared libraries).''')
-        module = property(get_modules_access_object, None, doc=r'''A read only property that returns an object that implements python operator overloading with the square brackets().\n    target.module[<int>] allows array access to any modules.\n    target.module[<str>] allows access to modules by basename, full path, or uuid string value.\n    target.module[uuid.UUID()] allows module access by UUID.\n    target.module[re] allows module access using a regular expression that matches the module full path.''')
-        process = property(GetProcess, None, doc='''A read only property that returns an lldb object that represents the process (lldb.SBProcess) that this target owns.''')
-        executable = property(GetExecutable, None, doc='''A read only property that returns an lldb object that represents the main executable module (lldb.SBModule) for this target.''')
-        debugger = property(GetDebugger, None, doc='''A read only property that returns an lldb object that represents the debugger (lldb.SBDebugger) that owns this target.''')
-        num_breakpoints = property(GetNumBreakpoints, None, doc='''A read only property that returns the number of breakpoints that this target has as an integer.''')
-        num_watchpoints = property(GetNumWatchpoints, None, doc='''A read only property that returns the number of watchpoints that this target has as an integer.''')
-        broadcaster = property(GetBroadcaster, None, doc='''A read only property that an lldb object that represents the broadcaster (lldb.SBBroadcaster) for this target.''')
-        byte_order = property(GetByteOrder, None, doc='''A read only property that returns an lldb enumeration value (lldb.eByteOrderLittle, lldb.eByteOrderBig, lldb.eByteOrderInvalid) that represents the byte order for this target.''')
-        addr_size = property(GetAddressByteSize, None, doc='''A read only property that returns the size in bytes of an address for this target.''')
-        triple = property(GetTriple, None, doc='''A read only property that returns the target triple (arch-vendor-os) for this target as a string.''')
-        data_byte_size = property(GetDataByteSize, None, doc='''A read only property that returns the size in host bytes of a byte in the data address space for this target.''')
-        code_byte_size = property(GetCodeByteSize, None, doc='''A read only property that returns the size in host bytes of a byte in the code address space for this target.''')
-        platform = property(GetPlatform, None, doc='''A read only property that returns the platform associated with with this target.''')
-    %}
-#endif
-};
-} // namespace lldb

lldb/bindings/interface/SBTargetDocstrings.i

+%feature("docstring",
+"Represents the target program running under the debugger.
+
+SBTarget supports module, breakpoint, and watchpoint iterations. For example, ::
+
+    for m in target.module_iter():
+        print m
+
+produces: ::
+
+    (x86_64) /Volumes/data/lldb/svn/trunk/test/python_api/lldbutil/iter/a.out
+    (x86_64) /usr/lib/dyld
+    (x86_64) /usr/lib/libstdc++.6.dylib
+    (x86_64) /usr/lib/libSystem.B.dylib
+    (x86_64) /usr/lib/system/libmathCommon.A.dylib
+    (x86_64) /usr/lib/libSystem.B.dylib(__commpage)
+
+and, ::
+
+    for b in target.breakpoint_iter():
+        print b
+
+produces: ::
+
+    SBBreakpoint: id = 1, file ='main.cpp', line = 66, locations = 1
+    SBBreakpoint: id = 2, file ='main.cpp', line = 85, locations = 1
+
+and, ::
+
+    for wp_loc in target.watchpoint_iter():
+        print wp_loc
+
+produces: ::
+
+    Watchpoint 1: addr = 0x1034ca048 size = 4 state = enabled type = rw
+        declare @ '/Volumes/data/lldb/svn/trunk/test/python_api/watchpoint/main.c:12'
+        hw_index = 0  hit_count = 2     ignore_count = 0"
+) lldb::SBTarget;
+
+%feature("docstring", "
+    Return the platform object associated with the target.
+
+    After return, the platform object should be checked for
+    validity.
+
+    @return
+        A platform object."
+) lldb::SBTarget::GetPlatform;
+
+%feature("docstring", "
+    Install any binaries that need to be installed.
+
+    This function does nothing when debugging on the host system.
+    When connected to remote platforms, the target's main executable
+    and any modules that have their install path set will be
+    installed on the remote platform. If the main executable doesn't
+    have an install location set, it will be installed in the remote
+    platform's working directory.
+
+    @return
+        An error describing anything that went wrong during
+        installation."
+) lldb::SBTarget::Install;
+
+%feature("docstring", "
+    Launch a new process.
+
+    Launch a new process by spawning a new process using the
+    target object's executable module's file as the file to launch.
+    Arguments are given in argv, and the environment variables
+    are in envp. Standard input and output files can be
+    optionally re-directed to stdin_path, stdout_path, and
+    stderr_path.
+
+    @param[in] listener
+        An optional listener that will receive all process events.
+        If listener is valid then listener will listen to all
+        process events. If not valid, then this target's debugger
+        (SBTarget::GetDebugger()) will listen to all process events.
+
+    @param[in] argv
+        The argument array.
+
+    @param[in] envp
+        The environment array.
+
+    @param[in] launch_flags
+        Flags to modify the launch (@see lldb::LaunchFlags)
+
+    @param[in] stdin_path
+        The path to use when re-directing the STDIN of the new
+        process. If all stdXX_path arguments are NULL, a pseudo
+        terminal will be used.
+
+    @param[in] stdout_path
+        The path to use when re-directing the STDOUT of the new
+        process. If all stdXX_path arguments are NULL, a pseudo
+        terminal will be used.
+
+    @param[in] stderr_path
+        The path to use when re-directing the STDERR of the new
+        process. If all stdXX_path arguments are NULL, a pseudo
+        terminal will be used.
+
+    @param[in] working_directory
+        The working directory to have the child process run in
+
+    @param[in] launch_flags
+        Some launch options specified by logical OR'ing
+        lldb::LaunchFlags enumeration values together.
+
+    @param[in] stop_at_entry
+        If false do not stop the inferior at the entry point.
+
+    @param[out]
+        An error object. Contains the reason if there is some failure.
+
+    @return
+         A process object for the newly created process.
+
+    For example,
+
+        process = target.Launch(self.dbg.GetListener(), None, None,
+                                None, '/tmp/stdout.txt', None,
+                                None, 0, False, error)
+
+    launches a new process by passing nothing for both the args and the envs
+    and redirect the standard output of the inferior to the /tmp/stdout.txt
+    file. It does not specify a working directory so that the debug server
+    will use its idea of what the current working directory is for the
+    inferior. Also, we ask the debugger not to stop the inferior at the
+    entry point. If no breakpoint is specified for the inferior, it should
+    run to completion if no user interaction is required."
+) lldb::SBTarget::Launch;
+
+%feature("docstring", "
+    Launch a new process with sensible defaults.
+
+    :param argv: The argument array.
+    :param envp: The environment array.
+    :param working_directory: The working directory to have the child process run in
+    :return: The newly created process.
+    :rtype: SBProcess
+
+    A pseudo terminal will be used as stdin/stdout/stderr.
+    No launch flags are passed and the target's debuger is used as a listener.
+
+    For example, ::
+
+        process = target.LaunchSimple(['X', 'Y', 'Z'], None, os.getcwd())
+
+    launches a new process by passing 'X', 'Y', 'Z' as the args to the
+    executable."
+) lldb::SBTarget::LaunchSimple;
+
+%feature("docstring", "
+    Load a core file
+
+    @param[in] core_file
+        File path of the core dump.
+
+    @param[out] error
+        An error explaining what went wrong if the operation fails.
+        (Optional)
+
+    @return
+         A process object for the newly created core file.
+
+    For example,
+
+        process = target.LoadCore('./a.out.core')
+
+    loads a new core file and returns the process object."
+) lldb::SBTarget::LoadCore;
+
+%feature("docstring", "
+    Attach to process with pid.
+
+    @param[in] listener
+        An optional listener that will receive all process events.
+        If listener is valid then listener will listen to all
+        process events. If not valid, then this target's debugger
+        (SBTarget::GetDebugger()) will listen to all process events.
+
+    @param[in] pid
+        The process ID to attach to.
+
+    @param[out]
+        An error explaining what went wrong if attach fails.
+
+    @return
+         A process object for the attached process."
+) lldb::SBTarget::AttachToProcessWithID;
+
+%feature("docstring", "
+    Attach to process with name.
+
+    @param[in] listener
+        An optional listener that will receive all process events.
+        If listener is valid then listener will listen to all
+        process events. If not valid, then this target's debugger
+        (SBTarget::GetDebugger()) will listen to all process events.
+
+    @param[in] name
+        Basename of process to attach to.
+
+    @param[in] wait_for
+        If true wait for a new instance of 'name' to be launched.
+
+    @param[out]
+        An error explaining what went wrong if attach fails.
+
+    @return
+         A process object for the attached process."
+) lldb::SBTarget::AttachToProcessWithName;
+
+%feature("docstring", "
+    Connect to a remote debug server with url.
+
+    @param[in] listener
+        An optional listener that will receive all process events.
+        If listener is valid then listener will listen to all
+        process events. If not valid, then this target's debugger
+        (SBTarget::GetDebugger()) will listen to all process events.
+
+    @param[in] url
+        The url to connect to, e.g., 'connect://localhost:12345'.
+
+    @param[in] plugin_name
+        The plugin name to be used; can be NULL.
+
+    @param[out]
+        An error explaining what went wrong if the connect fails.
+
+    @return
+         A process object for the connected process."
+) lldb::SBTarget::ConnectRemote;
+
+%feature("docstring", "
+    Append the path mapping (from -> to) to the target's paths mapping list."
+) lldb::SBTarget::AppendImageSearchPath;
+
+%feature("docstring", "
+    Find compile units related to this target and passed source
+    file.
+
+    :param sb_file_spec: A :py:class:`lldb::SBFileSpec` object that contains source file
+        specification.
+    :return: The symbol contexts for all the matches.
+    :rtype: SBSymbolContextList"
+) lldb::SBTarget::FindCompileUnits;
+
+%feature("docstring", "
+    Architecture data byte width accessor
+
+    :return: The size in 8-bit (host) bytes of a minimum addressable unit from the Architecture's data bus.
+
+    "
+) lldb::SBTarget::GetDataByteSize;
+
+%feature("docstring", "
+    Architecture code byte width accessor.
+
+    :return: The size in 8-bit (host) bytes of a minimum addressable unit from the Architecture's code bus.
+
+    "
+) lldb::SBTarget::GetCodeByteSize;
+
+%feature("docstring", "
+    Find functions by name.
+
+    :param name: The name of the function we are looking for.
+
+    :param name_type_mask:
+        A logical OR of one or more FunctionNameType enum bits that
+        indicate what kind of names should be used when doing the
+        lookup. Bits include fully qualified names, base names,
+        C++ methods, or ObjC selectors.
+        See FunctionNameType for more details.
+
+    :return:
+        A lldb::SBSymbolContextList that gets filled in with all of
+        the symbol contexts for all the matches."
+) lldb::SBTarget::FindFunctions;
+
+%feature("docstring", "
+    Find global and static variables by name.
+
+    @param[in] name
+        The name of the global or static variable we are looking
+        for.
+
+    @param[in] max_matches
+        Allow the number of matches to be limited to max_matches.
+
+    @return
+        A list of matched variables in an SBValueList."
+) lldb::SBTarget::FindGlobalVariables;
+
+ %feature("docstring", "
+    Find the first global (or static) variable by name.
+
+    @param[in] name
+        The name of the global or static variable we are looking
+        for.
+
+    @return
+        An SBValue that gets filled in with the found variable (if any)."
+) lldb::SBTarget::FindFirstGlobalVariable;
+
+%feature("docstring", "
+    Resolve a current file address into a section offset address.
+
+    @param[in] file_addr
+
+    @return
+        An SBAddress which will be valid if..."
+) lldb::SBTarget::ResolveFileAddress;
+
+%feature("docstring", "
+    Read target memory. If a target process is running then memory
+    is read from here. Otherwise the memory is read from the object
+    files. For a target whose bytes are sized as a multiple of host
+    bytes, the data read back will preserve the target's byte order.
+
+    @param[in] addr
+        A target address to read from.
+
+    @param[out] buf
+        The buffer to read memory into.
+
+    @param[in] size
+        The maximum number of host bytes to read in the buffer passed
+        into this call
+
+    @param[out] error
+        Error information is written here if the memory read fails.
+
+    @return
+        The amount of data read in host bytes."
+) lldb::SBTarget::ReadMemory;
+
+%feature("docstring", "
+    Create a breakpoint using a scripted resolver.
+
+    @param[in] class_name
+       This is the name of the class that implements a scripted resolver.
+       The class should have the following signature: ::
+
+           class Resolver:
+               def __init__(self, bkpt, extra_args):
+                   # bkpt - the breakpoint for which this is the resolver.  When
+                   # the resolver finds an interesting address, call AddLocation
+                   # on this breakpoint to add it.
+                   #
+                   # extra_args - an SBStructuredData that can be used to
+                   # parametrize this instance.  Same as the extra_args passed
+                   # to BreakpointCreateFromScript.
+
+               def __get_depth__ (self):
+                   # This is optional, but if defined, you should return the
+                   # depth at which you want the callback to be called.  The
+                   # available options are:
+                   #    lldb.eSearchDepthModule
+                   #    lldb.eSearchDepthCompUnit
+                   # The default if you don't implement this method is
+                   # eSearchDepthModule.
+
+               def __callback__(self, sym_ctx):
+                   # sym_ctx - an SBSymbolContext that is the cursor in the
+                   # search through the program to resolve breakpoints.
+                   # The sym_ctx will be filled out to the depth requested in
+                   # __get_depth__.
+                   # Look in this sym_ctx for new breakpoint locations,
+                   # and if found use bkpt.AddLocation to add them.
+                   # Note, you will only get called for modules/compile_units that
+                   # pass the SearchFilter provided by the module_list & file_list
+                   # passed into BreakpointCreateFromScript.
+
+               def get_short_help(self):
+                   # Optional, but if implemented return a short string that will
+                   # be printed at the beginning of the break list output for the
+                   # breakpoint.
+
+    @param[in] extra_args
+       This is an SBStructuredData object that will get passed to the
+       constructor of the class in class_name.  You can use this to
+       reuse the same class, parametrizing it with entries from this
+       dictionary.
+
+    @param module_list
+       If this is non-empty, this will be used as the module filter in the
+       SearchFilter created for this breakpoint.
+
+    @param file_list
+       If this is non-empty, this will be used as the comp unit filter in the
+       SearchFilter created for this breakpoint.
+
+    @return
+        An SBBreakpoint that will set locations based on the logic in the
+        resolver's search callback."
+) lldb::SBTarget::BreakpointCreateFromScript;
+
+%feature("docstring", "
+    Read breakpoints from source_file and return the newly created
+    breakpoints in bkpt_list.
+
+    @param[in] source_file
+       The file from which to read the breakpoints
+
+    @param[out] bkpt_list
+       A list of the newly created breakpoints.
+
+    @return
+        An SBError detailing any errors in reading in the breakpoints."
+) lldb::SBTarget::BreakpointsCreateFromFile;
+
+%feature("docstring", "
+    Read breakpoints from source_file and return the newly created
+    breakpoints in bkpt_list.
+
+    @param[in] source_file
+       The file from which to read the breakpoints
+
+    @param[in] matching_names
+       Only read in breakpoints whose names match one of the names in this
+       list.
+
+    @param[out] bkpt_list
+       A list of the newly created breakpoints.
+
+    @return
+        An SBError detailing any errors in reading in the breakpoints."
+) lldb::SBTarget::BreakpointsCreateFromFile;
+
+%feature("docstring", "
+    Write breakpoints to dest_file.
+
+    @param[in] dest_file
+       The file to which to write the breakpoints.
+
+    @return
+        An SBError detailing any errors in writing in the breakpoints."
+) lldb::SBTarget::BreakkpointsWriteToFile;
+
+%feature("docstring", "
+    Write breakpoints listed in bkpt_list to dest_file.
+
+    @param[in] dest_file
+       The file to which to write the breakpoints.
+
+    @param[in] bkpt_list
+       Only write breakpoints from this list.
+
+    @param[in] append
+       If true, append the breakpoints in bkpt_list to the others
+       serialized in dest_file.  If dest_file doesn't exist, then a new
+       file will be created and the breakpoints in bkpt_list written to it.
+
+    @return
+        An SBError detailing any errors in writing in the breakpoints."
+) lldb::SBTarget::BreakpointsWriteToFile;
+
+%feature("docstring", "
+    Create an SBValue with the given name by treating the memory starting at addr as an entity of type.
+
+    @param[in] name
+        The name of the resultant SBValue
+
+    @param[in] addr
+        The address of the start of the memory region to be used.
+
+    @param[in] type
+        The type to use to interpret the memory starting at addr.
+
+    @return
+        An SBValue of the given type, may be invalid if there was an error reading
+        the underlying memory."
+) lldb::SBTarget::CreateValueFromAddress;
+
+%feature("docstring", "
+    Disassemble a specified number of instructions starting at an address.
+
+    :param base_addr: the address to start disassembly from.
+    :param count: the number of instructions to disassemble.
+    :param flavor_string: may be 'intel' or 'att' on x86 targets to specify that style of disassembly.
+    :rtype: SBInstructionList
+    "
+) lldb::SBTarget::ReadInstructions;
+
+%feature("docstring", "
+    Disassemble the bytes in a buffer and return them in an SBInstructionList.
+
+    :param base_addr: used for symbolicating the offsets in the byte stream when disassembling.
+    :param buf: bytes to be disassembled.
+    :param size: (C++) size of the buffer.
+    :rtype: SBInstructionList
+    "
+) lldb::SBTarget::GetInstructions;
+
+%feature("docstring", "
+    Disassemble the bytes in a buffer and return them in an SBInstructionList, with a supplied flavor.
+
+    :param base_addr: used for symbolicating the offsets in the byte stream when disassembling.
+    :param flavor:  may be 'intel' or 'att' on x86 targets to specify that style of disassembly.
+    :param buf: bytes to be disassembled.
+    :param size: (C++) size of the buffer.
+    :rtype: SBInstructionList
+    "
+) lldb::SBTarget::GetInstructionsWithFlavor;
+
+%feature("docstring", "
+    Returns true if the module has been loaded in this `SBTarget`.
+    A module can be loaded either by the dynamic loader or by being manually
+    added to the target (see `SBTarget.AddModule` and the ``target module add`` command).
+
+    :rtype: bool
+    "
+) lldb::SBTarget::IsLoaded;

lldb/bindings/interface/SBTargetExtensions.i

+#ifdef SWIGPYTHON
+%typemap(in) (const char **symbol_name, uint32_t num_names) {
+  using namespace lldb_private;
+  /* Check if is a list  */
+  if (PythonList::Check($input)) {
+    PythonList list(PyRefType::Borrowed, $input);
+    $2 = list.GetSize();
+    int i = 0;
+    $1 = (char**)malloc(($2+1)*sizeof(char*));
+    for (i = 0; i < $2; i++) {
+      PythonString py_str = list.GetItemAtIndex(i).AsType<PythonString>();
+      if (!py_str.IsAllocated()) {
+        PyErr_SetString(PyExc_TypeError,"list must contain strings and blubby");
+        free($1);
+        return nullptr;
+      }
+
+      $1[i] = const_cast<char*>(py_str.GetString().data());
+    }
+    $1[i] = 0;
+  } else if ($input == Py_None) {
+    $1 =  NULL;
+  } else {
+    PyErr_SetString(PyExc_TypeError,"not a list");
+    return NULL;
+  }
+}
+#endif
+
+STRING_EXTENSION_LEVEL_OUTSIDE(SBTarget, lldb::eDescriptionLevelBrief)
+
+%extend lldb::SBTarget {
+#ifdef SWIGPYTHON
+    %pythoncode %{
+        class modules_access(object):
+            '''A helper object that will lazily hand out lldb.SBModule objects for a target when supplied an index, or by full or partial path.'''
+            def __init__(self, sbtarget):
+                self.sbtarget = sbtarget
+
+            def __len__(self):
+                if self.sbtarget:
+                    return int(self.sbtarget.GetNumModules())
+                return 0
+
+            def __getitem__(self, key):
+                num_modules = self.sbtarget.GetNumModules()
+                if type(key) is int:
+                    if -num_modules <= key < num_modules:
+                        key %= num_modules
+                        return self.sbtarget.GetModuleAtIndex(key)
+                elif type(key) is str:
+                    if key.find('/') == -1:
+                        for idx in range(num_modules):
+                            module = self.sbtarget.GetModuleAtIndex(idx)
+                            if module.file.basename == key:
+                                return module
+                    else:
+                        for idx in range(num_modules):
+                            module = self.sbtarget.GetModuleAtIndex(idx)
+                            if module.file.fullpath == key:
+                                return module
+                    # See if the string is a UUID
+                    try:
+                        the_uuid = uuid.UUID(key)
+                        if the_uuid:
+                            for idx in range(num_modules):
+                                module = self.sbtarget.GetModuleAtIndex(idx)
+                                if module.uuid == the_uuid:
+                                    return module
+                    except:
+                        return None
+                elif type(key) is uuid.UUID:
+                    for idx in range(num_modules):
+                        module = self.sbtarget.GetModuleAtIndex(idx)
+                        if module.uuid == key:
+                            return module
+                elif type(key) is re.SRE_Pattern:
+                    matching_modules = []
+                    for idx in range(num_modules):
+                        module = self.sbtarget.GetModuleAtIndex(idx)
+                        re_match = key.search(module.path.fullpath)
+                        if re_match:
+                            matching_modules.append(module)
+                    return matching_modules
+                else:
+                    print("error: unsupported item type: %s" % type(key))
+                return None
+
+        def get_modules_access_object(self):
+            '''An accessor function that returns a modules_access() object which allows lazy module access from a lldb.SBTarget object.'''
+            return self.modules_access (self)
+
+        def get_modules_array(self):
+            '''An accessor function that returns a list() that contains all modules in a lldb.SBTarget object.'''
+            modules = []
+            for idx in range(self.GetNumModules()):
+                modules.append(self.GetModuleAtIndex(idx))
+            return modules
+
+        def module_iter(self):
+            '''Returns an iterator over all modules in a lldb.SBTarget
+            object.'''
+            return lldb_iter(self, 'GetNumModules', 'GetModuleAtIndex')
+
+        def breakpoint_iter(self):
+            '''Returns an iterator over all breakpoints in a lldb.SBTarget
+            object.'''
+            return lldb_iter(self, 'GetNumBreakpoints', 'GetBreakpointAtIndex')
+
+        def watchpoint_iter(self):
+            '''Returns an iterator over all watchpoints in a lldb.SBTarget
+            object.'''
+            return lldb_iter(self, 'GetNumWatchpoints', 'GetWatchpointAtIndex')
+
+        modules = property(get_modules_array, None, doc='''A read only property that returns a list() of lldb.SBModule objects contained in this target. This list is a list all modules that the target currently is tracking (the main executable and all dependent shared libraries).''')
+        module = property(get_modules_access_object, None, doc=r'''A read only property that returns an object that implements python operator overloading with the square brackets().\n    target.module[<int>] allows array access to any modules.\n    target.module[<str>] allows access to modules by basename, full path, or uuid string value.\n    target.module[uuid.UUID()] allows module access by UUID.\n    target.module[re] allows module access using a regular expression that matches the module full path.''')
+        process = property(GetProcess, None, doc='''A read only property that returns an lldb object that represents the process (lldb.SBProcess) that this target owns.''')
+        executable = property(GetExecutable, None, doc='''A read only property that returns an lldb object that represents the main executable module (lldb.SBModule) for this target.''')
+        debugger = property(GetDebugger, None, doc='''A read only property that returns an lldb object that represents the debugger (lldb.SBDebugger) that owns this target.''')
+        num_breakpoints = property(GetNumBreakpoints, None, doc='''A read only property that returns the number of breakpoints that this target has as an integer.''')
+        num_watchpoints = property(GetNumWatchpoints, None, doc='''A read only property that returns the number of watchpoints that this target has as an integer.''')
+        broadcaster = property(GetBroadcaster, None, doc='''A read only property that an lldb object that represents the broadcaster (lldb.SBBroadcaster) for this target.''')
+        byte_order = property(GetByteOrder, None, doc='''A read only property that returns an lldb enumeration value (lldb.eByteOrderLittle, lldb.eByteOrderBig, lldb.eByteOrderInvalid) that represents the byte order for this target.''')
+        addr_size = property(GetAddressByteSize, None, doc='''A read only property that returns the size in bytes of an address for this target.''')
+        triple = property(GetTriple, None, doc='''A read only property that returns the target triple (arch-vendor-os) for this target as a string.''')
+        data_byte_size = property(GetDataByteSize, None, doc='''A read only property that returns the size in host bytes of a byte in the data address space for this target.''')
+        code_byte_size = property(GetCodeByteSize, None, doc='''A read only property that returns the size in host bytes of a byte in the code address space for this target.''')
+        platform = property(GetPlatform, None, doc='''A read only property that returns the platform associated with with this target.''')
+    %}
+#endif
+}

lldb/bindings/interface/SBThread.i

-//===-- SWIG Interface for SBThread -----------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-%feature("docstring",
-"Represents a thread of execution. :py:class:`SBProcess` contains SBThread(s).
-
-SBThreads can be referred to by their ID, which maps to the system specific thread
-identifier, or by IndexID.  The ID may or may not be unique depending on whether the
-system reuses its thread identifiers.  The IndexID is a monotonically increasing identifier
-that will always uniquely reference a particular thread, and when that thread goes
-away it will not be reused.
-
-SBThread supports frame iteration. For example (from test/python_api/
-lldbutil/iter/TestLLDBIterator.py), ::
-
-        from lldbutil import print_stacktrace
-        stopped_due_to_breakpoint = False
-        for thread in process:
-            if self.TraceOn():
-                print_stacktrace(thread)
-            ID = thread.GetThreadID()
-            if thread.GetStopReason() == lldb.eStopReasonBreakpoint:
-                stopped_due_to_breakpoint = True
-            for frame in thread:
-                self.assertTrue(frame.GetThread().GetThreadID() == ID)
-                if self.TraceOn():
-                    print frame
-
-        self.assertTrue(stopped_due_to_breakpoint)
-
-See also :py:class:`SBFrame` ."
-) SBThread;
-class SBThread
-{
-public:
-    //------------------------------------------------------------------
-    // Broadcaster bits.
-    //------------------------------------------------------------------
-    enum
-    {
-        eBroadcastBitStackChanged           = (1 << 0),
-        eBroadcastBitThreadSuspended        = (1 << 1),
-        eBroadcastBitThreadResumed          = (1 << 2),
-        eBroadcastBitSelectedFrameChanged   = (1 << 3),
-        eBroadcastBitThreadSelected         = (1 << 4)
-    };
-
-
-    SBThread ();
-
-    SBThread (const lldb::SBThread &thread);
-
-   ~SBThread();
-
-    static const char *
-    GetBroadcasterClassName ();
-
-    static bool
-    EventIsThreadEvent (const SBEvent &event);
-
-    static SBFrame
-    GetStackFrameFromEvent (const SBEvent &event);
-
-    static SBThread
-    GetThreadFromEvent (const SBEvent &event);
-
-    bool
-    IsValid() const;
-
-    explicit operator bool() const;
-
-    void
-    Clear ();
-
-    lldb::StopReason
-    GetStopReason();
-
-    %feature("docstring", "
-    Get the number of words associated with the stop reason.
-    See also GetStopReasonDataAtIndex().") GetStopReasonDataCount;
-    size_t
-    GetStopReasonDataCount();
-
-    %feature("docstring", "
-    Get information associated with a stop reason.
-
-    Breakpoint stop reasons will have data that consists of pairs of
-    breakpoint IDs followed by the breakpoint location IDs (they always come
-    in pairs).
-
-    Stop Reason              Count Data Type
-    ======================== ===== =========================================
-    eStopReasonNone          0
-    eStopReasonTrace         0
-    eStopReasonBreakpoint    N     duple: {breakpoint id, location id}
-    eStopReasonWatchpoint    1     watchpoint id
-    eStopReasonSignal        1     unix signal number
-    eStopReasonException     N     exception data
-    eStopReasonExec          0
-    eStopReasonFork          1     pid of the child process
-    eStopReasonVFork         1     pid of the child process
-    eStopReasonVForkDone     0
-    eStopReasonPlanComplete  0") GetStopReasonDataAtIndex;
-    uint64_t
-    GetStopReasonDataAtIndex(uint32_t idx);
-
-    %feature("autodoc", "
-    Collects a thread's stop reason extended information dictionary and prints it
-    into the SBStream in a JSON format. The format of this JSON dictionary depends
-    on the stop reason and is currently used only for instrumentation plugins.") GetStopReasonExtendedInfoAsJSON;
-    bool
-    GetStopReasonExtendedInfoAsJSON (lldb::SBStream &stream);
-
-    %feature("autodoc", "
-    Returns a collection of historical stack traces that are significant to the
-    current stop reason. Used by ThreadSanitizer, where we provide various stack
-    traces that were involved in a data race or other type of detected issue.") GetStopReasonExtendedBacktraces;
-    SBThreadCollection
-    GetStopReasonExtendedBacktraces (InstrumentationRuntimeType type);
-
-
-    %feature("autodoc", "
-    Pass only an (int)length and expect to get a Python string describing the
-    stop reason.") GetStopDescription;
-    size_t
-    GetStopDescription (char *dst_or_null, size_t dst_len);
-
-    SBValue
-    GetStopReturnValue ();
-
-    %feature("autodoc", "
-    Returns a unique thread identifier (type lldb::tid_t, typically a 64-bit type)
-    for the current SBThread that will remain constant throughout the thread's
-    lifetime in this process and will not be reused by another thread during this
-    process lifetime.  On Mac OS X systems, this is a system-wide unique thread
-    identifier; this identifier is also used by other tools like sample which helps
-    to associate data from those tools with lldb.  See related GetIndexID.")
-    GetThreadID;
-    lldb::tid_t
-    GetThreadID () const;
-
-    %feature("autodoc", "
-    Return the index number for this SBThread.  The index number is the same thing
-    that a user gives as an argument to 'thread select' in the command line lldb.
-    These numbers start at 1 (for the first thread lldb sees in a debug session)
-    and increments up throughout the process lifetime.  An index number will not be
-    reused for a different thread later in a process - thread 1 will always be
-    associated with the same thread.  See related GetThreadID.
-    This method returns a uint32_t index number, takes no arguments.")
-    GetIndexID;
-    uint32_t
-    GetIndexID () const;
-
-    const char *
-    GetName () const;
-
-    %feature("autodoc", "
-    Return the queue name associated with this thread, if any, as a str.
-    For example, with a libdispatch (aka Grand Central Dispatch) queue.") GetQueueName;
-
-    const char *
-    GetQueueName() const;
-
-    %feature("autodoc", "
-    Return the dispatch_queue_id for this thread, if any, as a lldb::queue_id_t.
-    For example, with a libdispatch (aka Grand Central Dispatch) queue.") GetQueueID;
-
-    lldb::queue_id_t
-    GetQueueID() const;
-
-    %feature("docstring", "
-    Takes a path string and a SBStream reference as parameters, returns a bool.
-    Collects the thread's 'info' dictionary from the remote system, uses the path
-    argument to descend into the dictionary to an item of interest, and prints
-    it into the SBStream in a natural format.  Return bool is to indicate if
-    anything was printed into the stream (true) or not (false).") GetInfoItemByPathAsString;
-
-    bool
-    GetInfoItemByPathAsString (const char *path, lldb::SBStream &strm);
-
-    %feature("autodoc", "
-    Return the SBQueue for this thread.  If this thread is not currently associated
-    with a libdispatch queue, the SBQueue object's IsValid() method will return false.
-    If this SBThread is actually a HistoryThread, we may be able to provide QueueID
-    and QueueName, but not provide an SBQueue.  Those individual attributes may have
-    been saved for the HistoryThread without enough information to reconstitute the
-    entire SBQueue at that time.
-    This method takes no arguments, returns an SBQueue.") GetQueue;
-
-    lldb::SBQueue
-    GetQueue () const;
-
-    void
-    StepOver (lldb::RunMode stop_other_threads = lldb::eOnlyDuringStepping);
-
-    %feature("autodoc",
-    "Do a source level single step over in the currently selected thread.") StepOver;
-    void
-    StepOver (lldb::RunMode stop_other_threads, SBError &error);
-
-    void
-    StepInto (lldb::RunMode stop_other_threads = lldb::eOnlyDuringStepping);
-
-    void
-    StepInto (const char *target_name, lldb::RunMode stop_other_threads = lldb::eOnlyDuringStepping);
-
-    %feature("autodoc", "
-    Step the current thread from the current source line to the line given by end_line, stopping if
-    the thread steps into the function given by target_name.  If target_name is None, then stepping will stop
-    in any of the places we would normally stop.") StepInto;
-    void
-    StepInto (const char *target_name,
-              uint32_t end_line,
-              SBError &error,
-              lldb::RunMode stop_other_threads = lldb::eOnlyDuringStepping);
-
-    void
-    StepOut ();
-
-    %feature("autodoc",
-    "Step out of the currently selected thread.") StepOut;
-    void
-    StepOut (SBError &error);
-
-    void
-    StepOutOfFrame (SBFrame &frame);
-
-    %feature("autodoc",
-    "Step out of the specified frame.") StepOutOfFrame;
-    void
-    StepOutOfFrame (SBFrame &frame, SBError &error);
-
-    void
-    StepInstruction(bool step_over);
-
-    %feature("autodoc",
-    "Do an instruction level single step in the currently selected thread.") StepInstruction;
-    void
-    StepInstruction(bool step_over, SBError &error);
-
-    SBError
-    StepOverUntil (lldb::SBFrame &frame,
-                   lldb::SBFileSpec &file_spec,
-                   uint32_t line);
-
-    SBError
-    StepUsingScriptedThreadPlan (const char *script_class_name);
-
-    SBError
-    StepUsingScriptedThreadPlan (const char *script_class_name, bool resume_immediately);
-
-    SBError
-    StepUsingScriptedThreadPlan(const char *script_class_name,
-                                lldb::SBStructuredData &args_data,
-                                bool resume_immediately);
-
-    SBError
-    JumpToLine (lldb::SBFileSpec &file_spec, uint32_t line);
-
-    void
-    RunToAddress (lldb::addr_t addr);
-
-    void
-    RunToAddress (lldb::addr_t addr, SBError &error);
-
-    %feature("autodoc", "
-    Force a return from the frame passed in (and any frames younger than it)
-    without executing any more code in those frames.  If return_value contains
-    a valid SBValue, that will be set as the return value from frame.  Note, at
-    present only scalar return values are supported.") ReturnFromFrame;
-
-    SBError
-    ReturnFromFrame (SBFrame &frame, SBValue &return_value);
-
-    %feature("autodoc", "
-    Unwind the stack frames from the innermost expression evaluation.
-    This API is equivalent to 'thread return -x'.") UnwindInnermostExpression;
-
-    SBError
-    UnwindInnermostExpression();
-
-    %feature("docstring", "
-    LLDB currently supports process centric debugging which means when any
-    thread in a process stops, all other threads are stopped. The Suspend()
-    call here tells our process to suspend a thread and not let it run when
-    the other threads in a process are allowed to run. So when
-    SBProcess::Continue() is called, any threads that aren't suspended will
-    be allowed to run. If any of the SBThread functions for stepping are
-    called (StepOver, StepInto, StepOut, StepInstruction, RunToAddres), the
-    thread will now be allowed to run and these functions will simply return.
-
-    Eventually we plan to add support for thread centric debugging where
-    each thread is controlled individually and each thread would broadcast
-    its state, but we haven't implemented this yet.
-
-    Likewise the SBThread::Resume() call will again allow the thread to run
-    when the process is continued.
-
-    Suspend() and Resume() functions are not currently reference counted, if
-    anyone has the need for them to be reference counted, please let us
-    know.") Suspend;
-    bool
-    Suspend();
-
-    bool
-    Suspend(SBError &error);
-
-    bool
-    Resume ();
-
-    bool
-    Resume (SBError &error);
-
-    bool
-    IsSuspended();
-
-    bool
-    IsStopped();
-
-    uint32_t
-    GetNumFrames ();
-
-    lldb::SBFrame
-    GetFrameAtIndex (uint32_t idx);
-
-    lldb::SBFrame
-    GetSelectedFrame ();
-
-    lldb::SBFrame
-    SetSelectedFrame (uint32_t frame_idx);
-
-    lldb::SBProcess
-    GetProcess ();
-
-    bool
-    GetDescription (lldb::SBStream &description) const;
-
-    %feature("docstring", "
-    Get the description strings for this thread that match what the
-    lldb driver will present, using the thread-format (stop_format==false)
-    or thread-stop-format (stop_format = true).") GetDescription;
-    bool GetDescription(lldb::SBStream &description, bool stop_format) const;
-
-    bool
-    GetStatus (lldb::SBStream &status) const;
-
-    bool
-    operator == (const lldb::SBThread &rhs) const;
-
-    bool
-    operator != (const lldb::SBThread &rhs) const;
-
-    %feature("autodoc","
-    Given an argument of str to specify the type of thread-origin extended
-    backtrace to retrieve, query whether the origin of this thread is
-    available.  An SBThread is retured; SBThread.IsValid will return true
-    if an extended backtrace was available.  The returned SBThread is not
-    a part of the SBProcess' thread list and it cannot be manipulated like
-    normal threads -- you cannot step or resume it, for instance -- it is
-    intended to used primarily for generating a backtrace.  You may request
-    the returned thread's own thread origin in turn.") GetExtendedBacktraceThread;
-    lldb::SBThread
-    GetExtendedBacktraceThread (const char *type);
-
-    %feature("autodoc","
-    Takes no arguments, returns a uint32_t.
-    If this SBThread is an ExtendedBacktrace thread, get the IndexID of the
-    original thread that this ExtendedBacktrace thread represents, if
-    available.  The thread that was running this backtrace in the past may
-    not have been registered with lldb's thread index (if it was created,
-    did its work, and was destroyed without lldb ever stopping execution).
-    In that case, this ExtendedBacktrace thread's IndexID will be returned.") GetExtendedBacktraceOriginatingIndexID;
-    uint32_t
-    GetExtendedBacktraceOriginatingIndexID();
-
-    %feature("autodoc","
-    Returns an SBValue object represeting the current exception for the thread,
-    if there is any. Currently, this works for Obj-C code and returns an SBValue
-    representing the NSException object at the throw site or that's currently
-    being processes.") GetCurrentException;
-    lldb::SBValue
-    GetCurrentException();
-
-    %feature("autodoc","
-    Returns a historical (fake) SBThread representing the stack trace of an
-    exception, if there is one for the thread. Currently, this works for Obj-C
-    code, and can retrieve the throw-site backtrace of an NSException object
-    even when the program is no longer at the throw site.") GetCurrentExceptionBacktrace;
-    lldb::SBThread
-    GetCurrentExceptionBacktrace();
-
-    %feature("autodoc","
-    Takes no arguments, returns a bool.
-    lldb may be able to detect that function calls should not be executed
-    on a given thread at a particular point in time.  It is recommended that
-    this is checked before performing an inferior function call on a given
-    thread.") SafeToCallFunctions;
-    bool
-    SafeToCallFunctions ();
-
-    %feature("autodoc","
-    Retruns a SBValue object representing the siginfo for the current signal.
-    ") GetSiginfo;
-    lldb::SBValue
-    GetSiginfo();
-
-    STRING_EXTENSION(SBThread)
-
-#ifdef SWIGPYTHON
-    %pythoncode %{
-        def __iter__(self):
-            '''Iterate over all frames in a lldb.SBThread object.'''
-            return lldb_iter(self, 'GetNumFrames', 'GetFrameAtIndex')
-
-        def __len__(self):
-            '''Return the number of frames in a lldb.SBThread object.'''
-            return self.GetNumFrames()
-
-        class frames_access(object):
-            '''A helper object that will lazily hand out frames for a thread when supplied an index.'''
-            def __init__(self, sbthread):
-                self.sbthread = sbthread
-
-            def __len__(self):
-                if self.sbthread:
-                    return int(self.sbthread.GetNumFrames())
-                return 0
-
-            def __getitem__(self, key):
-                if isinstance(key, int):
-                    count = len(self)
-                    if -count <= key < count:
-                        key %= count
-                        return self.sbthread.GetFrameAtIndex(key)
-                return None
-
-        def get_frames_access_object(self):
-            '''An accessor function that returns a frames_access() object which allows lazy frame access from a lldb.SBThread object.'''
-            return self.frames_access (self)
-
-        def get_thread_frames(self):
-            '''An accessor function that returns a list() that contains all frames in a lldb.SBThread object.'''
-            frames = []
-            for frame in self:
-                frames.append(frame)
-            return frames
-
-        id = property(GetThreadID, None, doc='''A read only property that returns the thread ID as an integer.''')
-        idx = property(GetIndexID, None, doc='''A read only property that returns the thread index ID as an integer. Thread index ID values start at 1 and increment as threads come and go and can be used to uniquely identify threads.''')
-        return_value = property(GetStopReturnValue, None, doc='''A read only property that returns an lldb object that represents the return value from the last stop (lldb.SBValue) if we just stopped due to stepping out of a function.''')
-        process = property(GetProcess, None, doc='''A read only property that returns an lldb object that represents the process (lldb.SBProcess) that owns this thread.''')
-        num_frames = property(GetNumFrames, None, doc='''A read only property that returns the number of stack frames in this thread as an integer.''')
-        frames = property(get_thread_frames, None, doc='''A read only property that returns a list() of lldb.SBFrame objects for all frames in this thread.''')
-        frame = property(get_frames_access_object, None, doc='''A read only property that returns an object that can be used to access frames as an array ("frame_12 = lldb.thread.frame[12]").''')
-        name = property(GetName, None, doc='''A read only property that returns the name of this thread as a string.''')
-        queue = property(GetQueueName, None, doc='''A read only property that returns the dispatch queue name of this thread as a string.''')
-        queue_id = property(GetQueueID, None, doc='''A read only property that returns the dispatch queue id of this thread as an integer.''')
-        stop_reason = property(GetStopReason, None, doc='''A read only property that returns an lldb enumeration value (see enumerations that start with "lldb.eStopReason") that represents the reason this thread stopped.''')
-        is_suspended = property(IsSuspended, None, doc='''A read only property that returns a boolean value that indicates if this thread is suspended.''')
-        is_stopped = property(IsStopped, None, doc='''A read only property that returns a boolean value that indicates if this thread is stopped but not exited.''')
-    %}
-#endif
-
-};
-
-} // namespace lldb

lldb/bindings/interface/SBThreadCollection.i

-//===-- SWIG Interface for SBThreadCollection -------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <stdio.h>
-
-namespace lldb {
-
-%feature("docstring",
-"Represents a collection of SBThread objects."
-) SBThreadCollection;
-class SBThreadCollection
-{
-public:
-
-    SBThreadCollection ();
-
-    SBThreadCollection (const SBThreadCollection &rhs);
-
-    ~SBThreadCollection ();
-
-    bool
-    IsValid () const;
-
-    explicit operator bool() const;
-
-    size_t
-    GetSize ();
-
-    lldb::SBThread
-    GetThreadAtIndex (size_t idx);
-
-};
-
-} // namespace lldb

lldb/bindings/interface/SBThreadCollectionDocstrings.i

+%feature("docstring",
+"Represents a collection of SBThread objects."
+) lldb::SBThreadCollection;

lldb/bindings/interface/SBThreadDocstrings.i

+%feature("docstring",
+"Represents a thread of execution. :py:class:`SBProcess` contains SBThread(s).
+
+SBThreads can be referred to by their ID, which maps to the system specific thread
+identifier, or by IndexID.  The ID may or may not be unique depending on whether the
+system reuses its thread identifiers.  The IndexID is a monotonically increasing identifier
+that will always uniquely reference a particular thread, and when that thread goes
+away it will not be reused.
+
+SBThread supports frame iteration. For example (from test/python_api/
+lldbutil/iter/TestLLDBIterator.py), ::
+
+        from lldbutil import print_stacktrace
+        stopped_due_to_breakpoint = False
+        for thread in process:
+            if self.TraceOn():
+                print_stacktrace(thread)
+            ID = thread.GetThreadID()
+            if thread.GetStopReason() == lldb.eStopReasonBreakpoint:
+                stopped_due_to_breakpoint = True
+            for frame in thread:
+                self.assertTrue(frame.GetThread().GetThreadID() == ID)
+                if self.TraceOn():
+                    print frame
+
+        self.assertTrue(stopped_due_to_breakpoint)
+
+See also :py:class:`SBFrame` ."
+) lldb::SBThread;
+
+%feature("docstring", "
+    Get the number of words associated with the stop reason.
+    See also GetStopReasonDataAtIndex()."
+) lldb::SBThread::GetStopReasonDataCount;
+
+%feature("docstring", "
+    Get information associated with a stop reason.
+
+    Breakpoint stop reasons will have data that consists of pairs of
+    breakpoint IDs followed by the breakpoint location IDs (they always come
+    in pairs).
+
+    Stop Reason              Count Data Type
+    ======================== ===== =========================================
+    eStopReasonNone          0
+    eStopReasonTrace         0
+    eStopReasonBreakpoint    N     duple: {breakpoint id, location id}
+    eStopReasonWatchpoint    1     watchpoint id
+    eStopReasonSignal        1     unix signal number
+    eStopReasonException     N     exception data
+    eStopReasonExec          0
+    eStopReasonFork          1     pid of the child process
+    eStopReasonVFork         1     pid of the child process
+    eStopReasonVForkDone     0
+    eStopReasonPlanComplete  0"
+) lldb::SBThread::GetStopReasonDataAtIndex;
+
+%feature("autodoc", "
+    Collects a thread's stop reason extended information dictionary and prints it
+    into the SBStream in a JSON format. The format of this JSON dictionary depends
+    on the stop reason and is currently used only for instrumentation plugins."
+) lldb::SBThread::GetStopReasonExtendedInfoAsJSON;
+
+%feature("autodoc", "
+    Returns a collection of historical stack traces that are significant to the
+    current stop reason. Used by ThreadSanitizer, where we provide various stack
+    traces that were involved in a data race or other type of detected issue."
+) lldb::SBThread::GetStopReasonExtendedBacktraces;
+
+%feature("autodoc", "
+    Pass only an (int)length and expect to get a Python string describing the
+    stop reason."
+) lldb::SBThread::GetStopDescription;
+
+%feature("autodoc", "
+    Returns a unique thread identifier (type lldb::tid_t, typically a 64-bit type)
+    for the current SBThread that will remain constant throughout the thread's
+    lifetime in this process and will not be reused by another thread during this
+    process lifetime.  On Mac OS X systems, this is a system-wide unique thread
+    identifier; this identifier is also used by other tools like sample which helps
+    to associate data from those tools with lldb.  See related GetIndexID."
+) lldb::SBThread::GetThreadID;
+
+%feature("autodoc", "
+    Return the index number for this SBThread.  The index number is the same thing
+    that a user gives as an argument to 'thread select' in the command line lldb.
+    These numbers start at 1 (for the first thread lldb sees in a debug session)
+    and increments up throughout the process lifetime.  An index number will not be
+    reused for a different thread later in a process - thread 1 will always be
+    associated with the same thread.  See related GetThreadID.
+    This method returns a uint32_t index number, takes no arguments."
+) lldb::SBThread::GetIndexID;
+
+%feature("autodoc", "
+    Return the queue name associated with this thread, if any, as a str.
+    For example, with a libdispatch (aka Grand Central Dispatch) queue."
+) lldb::SBThread::GetQueueName;
+
+%feature("autodoc", "
+    Return the dispatch_queue_id for this thread, if any, as a lldb::queue_id_t.
+    For example, with a libdispatch (aka Grand Central Dispatch) queue."
+) lldb::SBThread::GetQueueID;
+
+%feature("docstring", "
+    Takes a path string and a SBStream reference as parameters, returns a bool.
+    Collects the thread's 'info' dictionary from the remote system, uses the path
+    argument to descend into the dictionary to an item of interest, and prints
+    it into the SBStream in a natural format.  Return bool is to indicate if
+    anything was printed into the stream (true) or not (false)."
+) lldb::SBThread::GetInfoItemByPathAsString;
+
+%feature("autodoc", "
+    Return the SBQueue for this thread.  If this thread is not currently associated
+    with a libdispatch queue, the SBQueue object's IsValid() method will return false.
+    If this SBThread is actually a HistoryThread, we may be able to provide QueueID
+    and QueueName, but not provide an SBQueue.  Those individual attributes may have
+    been saved for the HistoryThread without enough information to reconstitute the
+    entire SBQueue at that time.
+    This method takes no arguments, returns an SBQueue."
+) lldb::SBThread::GetQueue;
+
+%feature("docstring",
+    "Do a source level single step over in the currently selected thread."
+) lldb::SBThread::StepOver;
+
+%feature("docstring", "
+    Step the current thread from the current source line to the line given by end_line, stopping if
+    the thread steps into the function given by target_name.  If target_name is None, then stepping will stop
+    in any of the places we would normally stop."
+) lldb::SBThread::StepInto;
+
+%feature("docstring",
+    "Step out of the currently selected thread."
+) lldb::SBThread::StepOut;
+
+%feature("docstring",
+    "Step out of the specified frame."
+) lldb::SBThread::StepOutOfFrame;
+
+%feature("docstring",
+    "Do an instruction level single step in the currently selected thread."
+) lldb::SBThread::StepInstruction;
+
+%feature("autodoc", "
+    Force a return from the frame passed in (and any frames younger than it)
+    without executing any more code in those frames.  If return_value contains
+    a valid SBValue, that will be set as the return value from frame.  Note, at
+    present only scalar return values are supported."
+) lldb::SBThread::ReturnFromFrame;
+
+%feature("autodoc", "
+    Unwind the stack frames from the innermost expression evaluation.
+    This API is equivalent to 'thread return -x'."
+) lldb::SBThread::UnwindInnermostExpression;
+
+%feature("docstring", "
+    LLDB currently supports process centric debugging which means when any
+    thread in a process stops, all other threads are stopped. The Suspend()
+    call here tells our process to suspend a thread and not let it run when
+    the other threads in a process are allowed to run. So when
+    SBProcess::Continue() is called, any threads that aren't suspended will
+    be allowed to run. If any of the SBThread functions for stepping are
+    called (StepOver, StepInto, StepOut, StepInstruction, RunToAddres), the
+    thread will now be allowed to run and these functions will simply return.
+
+    Eventually we plan to add support for thread centric debugging where
+    each thread is controlled individually and each thread would broadcast
+    its state, but we haven't implemented this yet.
+
+    Likewise the SBThread::Resume() call will again allow the thread to run
+    when the process is continued.
+
+    Suspend() and Resume() functions are not currently reference counted, if
+    anyone has the need for them to be reference counted, please let us
+    know."
+) lldb::SBThread::Suspend;
+
+%feature("docstring", "
+    Get the description strings for this thread that match what the
+    lldb driver will present, using the thread-format (stop_format==false)
+    or thread-stop-format (stop_format = true)."
+) lldb::SBThread::GetDescription;
+
+%feature("autodoc","
+    Given an argument of str to specify the type of thread-origin extended
+    backtrace to retrieve, query whether the origin of this thread is
+    available.  An SBThread is retured; SBThread.IsValid will return true
+    if an extended backtrace was available.  The returned SBThread is not
+    a part of the SBProcess' thread list and it cannot be manipulated like
+    normal threads -- you cannot step or resume it, for instance -- it is
+    intended to used primarily for generating a backtrace.  You may request
+    the returned thread's own thread origin in turn."
+) lldb::SBThread::GetExtendedBacktraceThread;
+
+%feature("autodoc","
+    Takes no arguments, returns a uint32_t.
+    If this SBThread is an ExtendedBacktrace thread, get the IndexID of the
+    original thread that this ExtendedBacktrace thread represents, if
+    available.  The thread that was running this backtrace in the past may
+    not have been registered with lldb's thread index (if it was created,
+    did its work, and was destroyed without lldb ever stopping execution).
+    In that case, this ExtendedBacktrace thread's IndexID will be returned."
+) lldb::SBThread::GetExtendedBacktraceOriginatingIndexID;
+
+%feature("autodoc","
+    Returns an SBValue object represeting the current exception for the thread,
+    if there is any. Currently, this works for Obj-C code and returns an SBValue
+    representing the NSException object at the throw site or that's currently
+    being processes."
+) lldb::SBThread::GetCurrentException;
+
+%feature("autodoc","
+    Returns a historical (fake) SBThread representing the stack trace of an
+    exception, if there is one for the thread. Currently, this works for Obj-C
+    code, and can retrieve the throw-site backtrace of an NSException object
+    even when the program is no longer at the throw site."
+) lldb::SBThread::GetCurrentExceptionBacktrace;
+
+%feature("autodoc","
+    Takes no arguments, returns a bool.
+    lldb may be able to detect that function calls should not be executed
+    on a given thread at a particular point in time.  It is recommended that
+    this is checked before performing an inferior function call on a given
+    thread."
+) lldb::SBThread::SafeToCallFunctions;
+
+%feature("autodoc","
+    Retruns a SBValue object representing the siginfo for the current signal.
+    "
+) lldb::SBThread::GetSiginfo;

lldb/bindings/interface/SBThreadExtensions.i

+STRING_EXTENSION_OUTSIDE(SBThread)
+
+%extend lldb::SBThread {
+#ifdef SWIGPYTHON
+    %pythoncode %{
+        def __iter__(self):
+            '''Iterate over all frames in a lldb.SBThread object.'''
+            return lldb_iter(self, 'GetNumFrames', 'GetFrameAtIndex')
+
+        def __len__(self):
+            '''Return the number of frames in a lldb.SBThread object.'''
+            return self.GetNumFrames()
+
+        class frames_access(object):
+            '''A helper object that will lazily hand out frames for a thread when supplied an index.'''
+            def __init__(self, sbthread):
+                self.sbthread = sbthread
+
+            def __len__(self):
+                if self.sbthread:
+                    return int(self.sbthread.GetNumFrames())
+                return 0
+
+            def __getitem__(self, key):
+                if isinstance(key, int):
+                    count = len(self)
+                    if -count <= key < count:
+                        key %= count
+                        return self.sbthread.GetFrameAtIndex(key)
+                return None
+
+        def get_frames_access_object(self):
+            '''An accessor function that returns a frames_access() object which allows lazy frame access from a lldb.SBThread object.'''
+            return self.frames_access (self)
+
+        def get_thread_frames(self):
+            '''An accessor function that returns a list() that contains all frames in a lldb.SBThread object.'''
+            frames = []
+            for frame in self:
+                frames.append(frame)
+            return frames
+
+        id = property(GetThreadID, None, doc='''A read only property that returns the thread ID as an integer.''')
+        idx = property(GetIndexID, None, doc='''A read only property that returns the thread index ID as an integer. Thread index ID values start at 1 and increment as threads come and go and can be used to uniquely identify threads.''')
+        return_value = property(GetStopReturnValue, None, doc='''A read only property that returns an lldb object that represents the return value from the last stop (lldb.SBValue) if we just stopped due to stepping out of a function.''')
+        process = property(GetProcess, None, doc='''A read only property that returns an lldb object that represents the process (lldb.SBProcess) that owns this thread.''')
+        num_frames = property(GetNumFrames, None, doc='''A read only property that returns the number of stack frames in this thread as an integer.''')
+        frames = property(get_thread_frames, None, doc='''A read only property that returns a list() of lldb.SBFrame objects for all frames in this thread.''')
+        frame = property(get_frames_access_object, None, doc='''A read only property that returns an object that can be used to access frames as an array ("frame_12 = lldb.thread.frame[12]").''')
+        name = property(GetName, None, doc='''A read only property that returns the name of this thread as a string.''')
+        queue = property(GetQueueName, None, doc='''A read only property that returns the dispatch queue name of this thread as a string.''')
+        queue_id = property(GetQueueID, None, doc='''A read only property that returns the dispatch queue id of this thread as an integer.''')
+        stop_reason = property(GetStopReason, None, doc='''A read only property that returns an lldb enumeration value (see enumerations that start with "lldb.eStopReason") that represents the reason this thread stopped.''')
+        is_suspended = property(IsSuspended, None, doc='''A read only property that returns a boolean value that indicates if this thread is suspended.''')
+        is_stopped = property(IsStopped, None, doc='''A read only property that returns a boolean value that indicates if this thread is stopped but not exited.''')
+    %}
+#endif
+}

lldb/bindings/interface/SBThreadPlan.i

-//===-- SBThread.h ----------------------------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLDB_SBThreadPlan_h_
-#define LLDB_SBThreadPlan_h_
-
-#include "lldb/API/SBDefines.h"
-
-#include <stdio.h>
-
-namespace lldb {
-
-%feature("docstring",
-"Represents a plan for the execution control of a given thread.
-
-See also :py:class:`SBThread` and :py:class:`SBFrame`."
-) SBThreadPlan;
-
-class SBThreadPlan
-{
-
-friend class lldb_private::ThreadPlan;
-
-public:
-    SBThreadPlan ();
-
-    SBThreadPlan (const lldb::SBThreadPlan &threadPlan);
-
-    SBThreadPlan (const lldb::ThreadPlanSP& lldb_object_sp);
-
-    SBThreadPlan (lldb::SBThread &thread, const char *class_name);
-
-   ~SBThreadPlan ();
-
-    bool
-    IsValid();
-
-    bool
-    IsValid() const;
-
-    explicit operator bool() const;
-
-    void
-    Clear ();
-
-    lldb::StopReason
-    GetStopReason();
-
-    %feature("docstring", "
-    Get the number of words associated with the stop reason.
-    See also GetStopReasonDataAtIndex().") GetStopReasonDataCount;
-    size_t
-    GetStopReasonDataCount();
-
-    %feature("docstring", "
-    Get information associated with a stop reason.
-
-    Breakpoint stop reasons will have data that consists of pairs of
-    breakpoint IDs followed by the breakpoint location IDs (they always come
-    in pairs).
-
-    Stop Reason              Count Data Type
-    ======================== ===== =========================================
-    eStopReasonNone          0
-    eStopReasonTrace         0
-    eStopReasonBreakpoint    N     duple: {breakpoint id, location id}
-    eStopReasonWatchpoint    1     watchpoint id
-    eStopReasonSignal        1     unix signal number
-    eStopReasonException     N     exception data
-    eStopReasonExec          0
-    eStopReasonFork          1     pid of the child process
-    eStopReasonVFork         1     pid of the child process
-    eStopReasonVForkDone     0
-    eStopReasonPlanComplete  0") GetStopReasonDataAtIndex;
-    uint64_t
-    GetStopReasonDataAtIndex(uint32_t idx);
-
-    SBThread
-    GetThread () const;
-
-    bool
-    GetDescription (lldb::SBStream &description) const;
-
-    void
-    SetPlanComplete (bool success);
-
-    bool
-    IsPlanComplete();
-
-    bool
-    IsPlanStale();
-
-    %feature("docstring", "Return whether this plan will ask to stop other threads when it runs.") GetStopOthers;
-    bool
-    GetStopOthers();
-
-    %feature("docstring", "Set whether this plan will ask to stop other threads when it runs.") GetStopOthers;
-    void
-    SetStopOthers(bool stop_others);
-
-    SBThreadPlan
-    QueueThreadPlanForStepOverRange (SBAddress &start_address,
-                                     lldb::addr_t range_size);
-
-    SBThreadPlan
-    QueueThreadPlanForStepInRange (SBAddress &start_address,
-                                   lldb::addr_t range_size);
-
-    SBThreadPlan
-    QueueThreadPlanForStepOut (uint32_t frame_idx_to_step_to, bool first_insn = false);
-
-    SBThreadPlan
-    QueueThreadPlanForRunToAddress (SBAddress address);
-
-    SBThreadPlan
-    QueueThreadPlanForStepScripted(const char *script_class_name);
-
-    SBThreadPlan
-    QueueThreadPlanForStepScripted(const char *script_class_name,
-                                   SBError &error);
-    SBThreadPlan
-    QueueThreadPlanForStepScripted(const char *script_class_name,
-                                   SBStructuredData &args_data,
-                                   SBError &error);
-
-
-protected:
-    friend class SBBreakpoint;
-    friend class SBBreakpointLocation;
-    friend class SBFrame;
-    friend class SBProcess;
-    friend class SBDebugger;
-    friend class SBValue;
-    friend class lldb_private::QueueImpl;
-    friend class SBQueueItem;
-
-private:
-    lldb::ThreadPlanSP m_opaque_sp;
-};
-
-} // namespace lldb
-
-#endif  // LLDB_SBThreadPlan_h_

lldb/bindings/interface/SBThreadPlanDocstrings.i

+%feature("docstring",
+"Represents a plan for the execution control of a given thread.
+
+See also :py:class:`SBThread` and :py:class:`SBFrame`."
+) lldb::SBThreadPlan;
+
+%feature("docstring", "
+    Get the number of words associated with the stop reason.
+    See also GetStopReasonDataAtIndex()."
+) lldb::SBThreadPlan::GetStopReasonDataCount;
+
+%feature("docstring", "
+    Get information associated with a stop reason.
+
+    Breakpoint stop reasons will have data that consists of pairs of
+    breakpoint IDs followed by the breakpoint location IDs (they always come
+    in pairs).
+
+    Stop Reason              Count Data Type
+    ======================== ===== =========================================
+    eStopReasonNone          0
+    eStopReasonTrace         0
+    eStopReasonBreakpoint    N     duple: {breakpoint id, location id}
+    eStopReasonWatchpoint    1     watchpoint id
+    eStopReasonSignal        1     unix signal number
+    eStopReasonException     N     exception data
+    eStopReasonExec          0
+    eStopReasonFork          1     pid of the child process
+    eStopReasonVFork         1     pid of the child process
+    eStopReasonVForkDone     0
+    eStopReasonPlanComplete  0"
+) lldb::SBThreadPlan::GetStopReasonDataAtIndex;
+
+%feature("docstring", "Return whether this plan will ask to stop other threads when it runs."
+) lldb::SBThreadPlan::GetStopOthers;
+
+%feature("docstring", "Set whether this plan will ask to stop other threads when it runs."
+) lldb::SBThreadPlan::SetStopOthers;

lldb/bindings/interface/SBTrace.i

-//===-- SWIG Interface for SBTrace.h ----------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-%feature("docstring",
-"Represents a processor trace."
-) SBTrace;
-class LLDB_API SBTrace {
-public:
-  SBTrace();
-
-  SBTraceCursor CreateNewCursor(SBError &error, SBThread &thread);
-
-  const char *GetStartConfigurationHelp();
-
-  SBFileSpec SaveToDisk(SBError &error, const SBFileSpec &bundle_dir, bool compact = false);
-
-  SBError Start(const SBStructuredData &configuration);
-
-  SBError Start(const SBThread &thread, const SBStructuredData &configuration);
-
-  SBError Stop();
-
-  SBError Stop(const SBThread &thread);
-
-  explicit operator bool() const;
-
-  bool IsValid();
-};
-} // namespace lldb

lldb/bindings/interface/SBTraceCursor.i

-//===-- SWIG Interface for SBTraceCursor.h ----------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-%feature("docstring",
-"Represents a trace cursor."
-) SBTrace;
-class LLDB_API SBTraceCursor {
-public:
-  SBTraceCursor();
-
-  SBTraceCursor(lldb::TraceCursorSP trace_cursor_sp);
-
-  void SetForwards(bool forwards);
-
-  bool IsForwards() const;
-
-  void Next();
-
-  bool HasValue();
-
-  bool GoToId(lldb::user_id_t id);
-
-  bool HasId(lldb::user_id_t id) const;
-
-  lldb::user_id_t GetId() const;
-
-  bool Seek(int64_t offset, lldb::TraceCursorSeekType origin);
-
-  lldb::TraceItemKind GetItemKind() const;
-
-  bool IsError() const;
-
-  const char *GetError() const;
-
-  bool IsEvent() const;
-
-  lldb::TraceEvent GetEventType() const;
-
-  const char *GetEventTypeAsString() const;
-
-  bool IsInstruction() const;
-
-  lldb::addr_t GetLoadAddress() const;
-
-  lldb::cpu_id_t GetCPU() const;
-
-  bool IsValid() const;
-
-  explicit operator bool() const;
-};
-} // namespace lldb

lldb/bindings/interface/SBTraceCursorDocstrings.i

+%feature("docstring",
+"Represents a trace cursor."
+) lldb::SBTraceCursor;

lldb/bindings/interface/SBTraceDocstrings.i

+%feature("docstring",
+"Represents a processor trace."
+) lldb::SBTrace;

lldb/bindings/interface/SBTypeCategoryDocstrings.i

+%feature("docstring",
+"Represents a category that can contain formatters for types."
+) lldb::SBTypeCategory;

lldb/bindings/interface/SBTypeCategoryExtensions.i

-//===-- SWIG Interface for SBTypeCategory---------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-    %feature("docstring",
-    "Represents a category that can contain formatters for types.") SBTypeCategory;
-
-    class SBTypeCategory
-    {
-    public:
-
-        SBTypeCategory();
-
-        SBTypeCategory (const lldb::SBTypeCategory &rhs);
-
-        ~SBTypeCategory ();
-
-        bool
-        IsValid() const;
-
-        explicit operator bool() const;
-
-        bool
-        GetEnabled ();
-
-        void
-        SetEnabled (bool);
-
-        const char*
-        GetName();
-
-        lldb::LanguageType
-        GetLanguageAtIndex (uint32_t idx);
-
-        uint32_t
-        GetNumLanguages ();
-
-        void
-        AddLanguage (lldb::LanguageType language);
-
-        bool
-        GetDescription (lldb::SBStream &description,
-                        lldb::DescriptionLevel description_level);
-
-        uint32_t
-        GetNumFormats ();
-
-        uint32_t
-        GetNumSummaries ();
-
-        uint32_t
-        GetNumFilters ();
-
-        uint32_t
-        GetNumSynthetics ();
-
-        lldb::SBTypeNameSpecifier
-        GetTypeNameSpecifierForFilterAtIndex (uint32_t);
-
-        lldb::SBTypeNameSpecifier
-        GetTypeNameSpecifierForFormatAtIndex (uint32_t);
-
-        lldb::SBTypeNameSpecifier
-        GetTypeNameSpecifierForSummaryAtIndex (uint32_t);
-
-        lldb::SBTypeNameSpecifier
-        GetTypeNameSpecifierForSyntheticAtIndex (uint32_t);
-
-        lldb::SBTypeFilter
-        GetFilterForType (lldb::SBTypeNameSpecifier);
-
-        lldb::SBTypeFormat
-        GetFormatForType (lldb::SBTypeNameSpecifier);
-
-        lldb::SBTypeSummary
-        GetSummaryForType (lldb::SBTypeNameSpecifier);
-
-        lldb::SBTypeSynthetic
-        GetSyntheticForType (lldb::SBTypeNameSpecifier);
-
-        lldb::SBTypeFilter
-        GetFilterAtIndex (uint32_t);
-
-        lldb::SBTypeFormat
-        GetFormatAtIndex (uint32_t);
-
-        lldb::SBTypeSummary
-        GetSummaryAtIndex (uint32_t);
-
-        lldb::SBTypeSynthetic
-        GetSyntheticAtIndex (uint32_t);
-
-        bool
-        AddTypeFormat (lldb::SBTypeNameSpecifier,
-                       lldb::SBTypeFormat);
-
-        bool
-        DeleteTypeFormat (lldb::SBTypeNameSpecifier);
-
-        bool
-        AddTypeSummary (lldb::SBTypeNameSpecifier,
-                        lldb::SBTypeSummary);
-
-        bool
-        DeleteTypeSummary (lldb::SBTypeNameSpecifier);
-
-        bool
-        AddTypeFilter (lldb::SBTypeNameSpecifier,
-                       lldb::SBTypeFilter);
-
-        bool
-        DeleteTypeFilter (lldb::SBTypeNameSpecifier);
-
-        bool
-        AddTypeSynthetic (lldb::SBTypeNameSpecifier,
-                          lldb::SBTypeSynthetic);
-
-        bool
-        DeleteTypeSynthetic (lldb::SBTypeNameSpecifier);
-
-        STRING_EXTENSION_LEVEL(SBTypeCategory, lldb::eDescriptionLevelBrief)
+STRING_EXTENSION_LEVEL_OUTSIDE(SBTypeCategory, lldb::eDescriptionLevelBrief)
 
+%extend lldb::SBTypeCategory {
 #ifdef SWIGPYTHON
         %pythoncode %{
 
             class formatters_access_class(object):
                 '''A helper object that will lazily hand out formatters for a specific category.'''
                 def __init__(self, sbcategory, get_count_function, get_at_index_function, get_by_name_function):
                     self.sbcategory = sbcategory
                     self.get_count_function = get_count_function
#ifdef SWIGPYTHON
             num_formats = property(GetNumFormats, None)
             num_summaries = property(GetNumSummaries, None)
             num_filters = property(GetNumFilters, None)
             num_synthetics = property(GetNumSynthetics, None)
             name = property(GetName, None)
             enabled = property(GetEnabled, SetEnabled)
         %}
 #endif
-
-    };
-
-
-} // namespace lldb
-
+}

lldb/bindings/interface/SBTypeDocstrings.i

-//===-- SWIG Interface for SBType -------------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-    %feature("docstring",
-"Represents a member of a type.") SBTypeMember;
-
-class SBTypeMember
-{
-public:
-    SBTypeMember ();
-
-    SBTypeMember (const lldb::SBTypeMember& rhs);
-
-    ~SBTypeMember();
-
-    bool
-    IsValid() const;
-
-    explicit operator bool() const;
-
-    const char *
-    GetName ();
-
-    lldb::SBType
-    GetType ();
-
-    uint64_t
-    GetOffsetInBytes();
-
-    uint64_t
-    GetOffsetInBits();
-
-    bool
-    IsBitfield();
-
-    uint32_t
-    GetBitfieldSizeInBits();
-
-    STRING_EXTENSION_LEVEL(SBTypeMember, lldb::eDescriptionLevelBrief)
-
-#ifdef SWIGPYTHON
-    %pythoncode %{
-        name = property(GetName, None, doc='''A read only property that returns the name for this member as a string.''')
-        type = property(GetType, None, doc='''A read only property that returns an lldb object that represents the type (lldb.SBType) for this member.''')
-        byte_offset = property(GetOffsetInBytes, None, doc='''A read only property that returns offset in bytes for this member as an integer.''')
-        bit_offset = property(GetOffsetInBits, None, doc='''A read only property that returns offset in bits for this member as an integer.''')
-        is_bitfield = property(IsBitfield, None, doc='''A read only property that returns true if this member is a bitfield.''')
-        bitfield_bit_size = property(GetBitfieldSizeInBits, None, doc='''A read only property that returns the bitfield size in bits for this member as an integer, or zero if this member is not a bitfield.''')
-    %}
-#endif
-
-protected:
-    std::unique_ptr<lldb_private::TypeMemberImpl> m_opaque_ap;
-};
+"Represents a member of a type."
+) lldb::SBTypeMember;
 
 %feature("docstring",
 "Represents a member function of a type."
-) SBTypeMemberFunction;
-class SBTypeMemberFunction
-{
-public:
-    SBTypeMemberFunction ();
-
-    SBTypeMemberFunction (const lldb::SBTypeMemberFunction& rhs);
-
-    ~SBTypeMemberFunction();
-
-    bool
-    IsValid() const;
-
-    explicit operator bool() const;
-
-    const char *
-    GetName ();
-
-    const char *
-    GetDemangledName ();
-
-    const char *
-    GetMangledName ();
-
-    lldb::SBType
-    GetType ();
-
-    lldb::SBType
-    GetReturnType ();
-
-    uint32_t
-    GetNumberOfArguments ();
-
-    lldb::SBType
-    GetArgumentTypeAtIndex (uint32_t);
-
-    lldb::MemberFunctionKind
-    GetKind();
-
-    bool
-    GetDescription (lldb::SBStream &description,
-                    lldb::DescriptionLevel description_level);
-
-    STRING_EXTENSION_LEVEL(SBTypeMemberFunction, lldb::eDescriptionLevelBrief)
-protected:
-    lldb::TypeMemberFunctionImplSP m_opaque_sp;
-};
+) lldb::SBTypeMemberFunction;
 
 %feature("docstring",
 "Represents a data type in lldb.
 
 The actual characteristics of each type are defined by the semantics of the
 programming language and the specific language implementation that was used
 to compile the target program. See the language-specific notes in the
 documentation of each method.
# find_type.py:
             id = task_head.GetChildMemberWithName('id')
             id_type = id.GetType()
 
             # SBType.GetBasicType() takes an enum 'BasicType' (lldb-enumerations.h).
             int_type = id_type.GetBasicType(lldb.eBasicTypeInt)
             # id_type and int_type should be the same type!
             self.assertTrue(id_type == int_type)
 
-") SBType;
-class SBType
-{
-public:
-    SBType ();
-
-    SBType (const lldb::SBType &rhs);
-
-    ~SBType ();
-
-    bool
-    IsValid();
-
-    explicit operator bool() const;
-
+") lldb::SBType;
 
-    %feature("docstring",
     "Returns the number of bytes a variable with the given types occupies in memory.
 
     Returns ``0`` if the size can't be determined.
 
     If a type occupies ``N`` bytes + ``M`` bits in memory, this function returns
     the rounded up amount of bytes (i.e., if ``M`` is ``0``,
     this function returns ``N`` and otherwise ``N + 1``).
 
     Language-specific behaviour:
 
     * C: The output is expected to match the value of ``sizeof(Type)``. If
       ``sizeof(Type)`` is not a valid expression for the given type, the
       function returns ``0``.
     * C++: Same as in C.
     * Objective-C: Same as in C. For Objective-C classes this always returns
       ``0`` as the actual size depends on runtime information.
-    ") GetByteSize;
-    uint64_t
-    GetByteSize();
-
+    "
+) lldb::SBType::GetByteSize;
 
-    %feature("docstring",
     "Returns true if this type is a pointer type.
 
     Language-specific behaviour:
 
     * C: Returns true for C pointer types (or typedefs of these types).
     * C++: Pointer types include the C pointer types as well as pointers to data
       mebers or member functions.
     * Objective-C: Pointer types include the C pointer types. ``id``, ``Class``
       and pointers to blocks are also considered pointer types.
-    ") IsPointerType;
-    bool
-    IsPointerType();
+    "
+) lldb::SBType::IsPointerType;
 
-    %feature("docstring",
     "Returns true if this type is a reference type.
 
     Language-specific behaviour:
 
     * C: Returns false for all types.
     * C++: Both l-value and r-value references are considered reference types.
     * Objective-C: Returns false for all types.
-    ") IsReferenceType;
-    bool
-    IsReferenceType();
+    "
+) lldb::SBType::IsReferenceType;
 
-    %feature("docstring",
     "Returns true if this type is a function type.
 
     Language-specific behaviour:
 
     * C: Returns true for types that represent functions. Note that function
       pointers are not function types (but their `GetPointeeType()` are function
       types).
     * C++: Same as in C.
     * Objective-C: Returns false for all types.
-    ") IsPolymorphicClass;
-    bool
-    IsFunctionType ();
+    "
+) lldb::SBType::IsPolymorphicClass;
 
-    %feature("docstring",
     "Returns true if this type is a polymorphic type.
 
     Language-specific behaviour:
 
     * C: Returns false for all types.
     * C++: Returns true if the type is a class type that contains at least one
       virtual member function or if at least one of its base classes is
       considered a polymorphic type.
     * Objective-C: Returns false for all types.
-    ") IsPolymorphicClass;
-    bool
-    IsPolymorphicClass ();
+    "
+) lldb::SBType::IsPolymorphicClass;
 
-    %feature("docstring",
     "Returns true if this type is an array type.
 
     Language-specific behaviour:
 
     * C: Returns true if the types is an array type. This includes incomplete
       array types ``T[]`` and array types with integer (``T[1]``) or variable
       length (``T[some_variable]``). Pointer types are not considered arrays.
     * C++: Includes C's array types and dependent array types (i.e., array types
       in templates which size depends on template arguments).
     * Objective-C: Same as in C.
-    ") IsArrayType;
-    bool
-    IsArrayType ();
+    "
+) lldb::SBType::IsArrayType;
 
-    %feature("docstring",
     "Returns true if this type is a vector type.
 
     Language-specific behaviour:
 
     * C: Returns true if the types is a vector type created with
       GCC's ``vector_size`` or Clang's ``ext_vector_type`` feature.
     * C++: Same as in C.
     * Objective-C: Same as in C.
-    ") IsVectorType;
-    bool
-    IsVectorType ();
+    "
+) lldb::SBType::IsVectorType;
 
-    %feature("docstring",
     "Returns true if this type is a typedef.
 
     Language-specific behaviour:
 
     * C: Returns true if the type is a C typedef.
     * C++: Same as in C. Also treats type aliases as typedefs.
     * Objective-C: Same as in C.
-    ") IsTypedefType;
-    bool
-    IsTypedefType ();
+    "
+) lldb::SBType::IsTypedefType;
 
-    %feature("docstring",
     "Returns true if this type is an anonymous type.
 
     Language-specific behaviour:
 
     * C: Returns true for anonymous unions. Also returns true for
       anonymous structs (which are a GNU language extension).
     * C++: Same as in C.
     * Objective-C: Same as in C.
-    ") IsAnonymousType;
-    bool
-    IsAnonymousType ();
+    "
+) lldb::SBType::IsAnonymousType;
 
-    %feature("docstring",
     "Returns true if this type is a scoped enum.
 
     Language-specific behaviour:
 
     * C: Returns false for all types.
     * C++: Return true only for C++11 scoped enums.
     * Objective-C: Returns false for all types.
-    ") IsScopedEnumerationType;
-    bool
-    IsScopedEnumerationType ();
+    "
+) lldb::SBType::IsScopedEnumerationType;
 
-    %feature("docstring",
     "Returns true if this type is an aggregate type.
 
     Language-specific behaviour:
 
     * C: Returns true for struct values, arrays, and vectors.
     * C++: Same a C. Also includes class instances.
     * Objective-C: Same as C. Also includes class instances.
-    ") IsAggregateType;
-    bool
-    IsAggregateType ();
+    "
+) lldb::SBType::IsAggregateType;
 
-    %feature("docstring",
     "Returns a type that represents a pointer to this type.
 
     If the type system of the current language can't represent a pointer to this
     type or this type is invalid, an invalid `SBType` is returned.
 
     Language-specific behaviour:
 
     * C: Returns the pointer type of this type.
     * C++: Same as in C.
     * Objective-C: Same as in C.
-    ") GetPointerType;
-    lldb::SBType
-    GetPointerType();
+    "
+) lldb::SBType::GetPointerType;
 
-    %feature("docstring",
     "Returns the underlying pointee type.
 
     If this type is a pointer type as specified by `IsPointerType` then this
     returns the underlying type. If this is not a pointer type or an invalid
     `SBType` then this returns an invalid `SBType`.
 
     Language-specific behaviour:
 
     * C: Returns the underlying type for for C pointer types or typedefs of
       these types). For example, ``int *`` will return ``int``.
     * C++: Same as in C. Returns an `SBType` representation for data members/
       member functions in case the `SBType` is a pointer to data member or
       pointer to member function.
     * Objective-C: Same as in C. The pointee type of ``id`` and ``Class`` is
       an invalid `SBType`. The pointee type of pointers Objective-C types is an
       `SBType` for the non-pointer type of the respective type. For example,
       ``NSString *`` will return ``NSString`` as a pointee type.
-    ") GetPointeeType;
-    lldb::SBType
-    GetPointeeType();
+    "
+) lldb::SBType::GetPointeeType;
 
-    %feature("docstring",
     "Returns a type that represents a reference to this type.
 
     If the type system of the current language can't represent a reference to
     this type, an invalid `SBType` is returned.
 
     Language-specific behaviour:
 
     * C: Currently assumes the type system is C++ and returns an l-value
       reference type. For example, ``int`` will return ``int&``. This behavior
       is likely to change in the future and shouldn't be relied on.
     * C++: Same as in C.
     * Objective-C: Same as in C.
-    ") GetReferenceType;
-    lldb::SBType
-    GetReferenceType();
+    "
+) lldb::SBType::GetReferenceType;
 
-    %feature("docstring",
     "Returns the underlying type of a typedef.
 
     If this type is a typedef as designated by `IsTypedefType`, then the
     underlying type is being returned. Otherwise an invalid `SBType` is
     returned.
 
     Language-specific behaviour:
 
     * C: Returns the underlying type of a typedef type.
     * C++: Same as in C. For type aliases, the underlying type is returned.
     * Objective-C: Same as in C.
-    ") GetTypedefedType;
-    lldb::SBType
-    SBType::GetTypedefedType();
+    "
+) lldb::SBType::GetTypedefedType;
 
-    %feature("docstring",
     "Returns the underlying type of a reference type.
 
     If this type is a reference as designated by `IsReferenceType`, then the
     underlying type is being returned. Otherwise an invalid `SBType` is
     returned.
 
     Language-specific behaviour:
 
     * C: Always returns an invalid type.
     * C++: For l-value and r-value references the underlying type is returned.
       For example, ``int &`` will return ``int``.
     * Objective-C: Same as in C.
-    ") GetDereferencedType;
-    lldb::SBType
-    GetDereferencedType();
+    "
+) lldb::SBType::GetDereferencedType;
 
-    %feature("docstring",
     "Returns the unqualified version of this type.
 
     Language-specific behaviour:
 
     * C: If this type with any const or volatile specifier removed.
     * C++: Same as in C.
     * Objective-C: Same as in C.
-    ") GetUnqualifiedType;
-    lldb::SBType
-    GetUnqualifiedType();
-
-    lldb::SBType
-    GetCanonicalType();
+    "
+) lldb::SBType::GetUnqualifiedType;
 
-    %feature("docstring",
     "Returns the underlying integer type if this is an enumeration type.
 
     If this type is an invalid `SBType` or not an enumeration type an invalid
     `SBType` is returned.
 
     Language-specific behaviour:
 
     * C: Returns the underlying type for enums.
     * C++: Same as in C but also returns the underlying type for scoped enums.
     * Objective-C: Same as in C.
-    ") GetEnumerationIntegerType;
-    lldb::SBType
-    GetEnumerationIntegerType();
+    "
+) lldb::SBType::GetEnumerationIntegerType;
 
-    %feature("docstring",
     "Returns the array element type if this type is an array type.
 
     Otherwise returns an invalid `SBType` if this type is invalid or not an
     array type.
 
     Language-specific behaviour:
 
     * C: If this is an array type (see `IsArrayType`) such as ``T[]``, returns
       the element type.
     * C++: Same as in C.
     * Objective-C: Same as in C.
 
     See also `IsArrayType`.
-    ") GetArrayElementType;
-    lldb::SBType
-    GetArrayElementType ();
+    "
+) lldb::SBType::GetArrayElementType;
 
-    %feature("docstring",
     "Returns the array type with the given constant size.
 
     Language-specific behaviour:
 
     * C: Returns a constant-size array ``T[size]`` for any non-void type.
     * C++: Same as in C.
     * Objective-C: Same as in C.
 
     See also `IsArrayType` and `GetArrayElementType`.
-    ") GetArrayType;
-    lldb::SBType
-    GetArrayType (uint64_t size);
+    "
+) lldb::SBType::GetArrayType;
 
-    %feature("docstring",
     "Returns the vector element type if this type is a vector type.
 
     Otherwise returns an invalid `SBType` if this type is invalid or not a
     vector type.
 
     Language-specific behaviour:
 
     * C: If this is a vector type (see `IsVectorType`), returns the element
       type.
     * C++: Same as in C.
     * Objective-C: Same as in C.
 
     See also `IsVectorType`.
-    ") GetVectorElementType;
-    lldb::SBType
-    GetVectorElementType ();
+    "
+) lldb::SBType::GetVectorElementType;
 
-    %feature("docstring",
     "Returns the `BasicType` value that is most appropriate to this type.
 
     Returns `eBasicTypeInvalid` if no appropriate `BasicType` was found or this
     type is invalid. See the `BasicType` documentation for the language-specific
     meaning of each `BasicType` value.
 
     **Overload behaviour:** When called with a `BasicType` parameter, the
     following behaviour applies:
 
     Returns the `SBType` that represents the passed `BasicType` value. Returns
     an invalid `SBType` if no fitting `SBType` could be created.
 
     Language-specific behaviour:
 
     * C: Returns the respective builtin type. Note that some types
       (e.g. ``__uint128_t``) might even be successfully created even if they are
       not available on the target platform. C++ and Objective-C specific types
       might also be created even if the target program is not written in C++ or
       Objective-C.
     * C++: Same as in C.
     * Objective-C: Same as in C.
-    ");
-    lldb::BasicType
-    GetBasicType();
-
-    lldb::SBType
-    GetBasicType (lldb::BasicType type);
+    "
+) lldb::SBType::GetBasicType;
 
-    %feature("docstring",
     "Returns the number of fields of this type.
 
     Returns ``0`` if this type does not have fields.
 
     Language-specific behaviour:
 
     * C: Returns the number of fields if the type is a struct. If the type
       contains an anonymous struct/union it only counts as a single field (even
       if the struct/union contains several fields).
     * C++: Returns the number of non-static fields if the type is a
       struct/class. If the type contains an anonymous struct/union it only
       counts as a single field (even if the struct/union contains several
       fields). The fields of any base classes are not included in the count.
     * Objective-C: Same as in C for structs. For Objective-C classes the number
       of ivars is returned.
 
     See also `GetFieldAtIndex`.
-    ") GetNumberOfFields;
-    uint32_t
-    GetNumberOfFields ();
+    "
+) lldb::SBType::GetNumberOfFields;
 
-    %feature("docstring",
     "Returns the number of base/parent classes of this type.
 
     Returns ``0`` if this type doesn't have any base classes.
 
     Language-specific behaviour:
 
     * C: Returns always ``0``.
     * C++: The number of direct non-virtual base classes if this type is
       a class.
     * Objective-C: The number of super classes for Objective-C classes.
       As Objective-C doesn't have multiple inheritance this is usually returns 1
       except for NSObject.
-    ") GetNumberOfDirectBaseClasses;
-    uint32_t
-    GetNumberOfDirectBaseClasses ();
+    "
+) lldb::SBType::GetNumberOfDirectBaseClasses;
 
-    %feature("docstring",
     "Returns the number of virtual base/parent classes of this type
 
     Returns ``0`` if this type doesn't have any base classes.
 
     Language-specific behaviour:
 
     * C: Returns always ``0``.
     * C++: The number of direct virtual base classes if this type is a
       class.
     * Objective-C: Returns always ``0``.
-    ") GetNumberOfVirtualBaseClasses;
-    uint32_t
-    GetNumberOfVirtualBaseClasses ();
+    "
+) lldb::SBType::GetNumberOfVirtualBaseClasses;
 
-    %feature("docstring",
     "Returns the field at the given index.
 
     Returns an invalid `SBType` if the index is out of range or the current
     type doesn't have any fields.
 
     Language-specific behaviour:
 
     * C: Returns the field with the given index for struct types. Fields are
       ordered/indexed starting from ``0`` for the first field in a struct (as
       declared in the definition).
     * C++: Returns the non-static field with the given index for struct types.
       Fields are ordered/indexed starting from ``0`` for the first field in a
       struct (as declared in the definition).
     * Objective-C: Same as in C for structs. For Objective-C classes the ivar
       with the given index is returned. ivars are indexed starting from ``0``.
-    ") GetFieldAtIndex;
-    lldb::SBTypeMember
-    GetFieldAtIndex (uint32_t idx);
+    "
+) lldb::SBType::GetFieldAtIndex;
 
-    %feature("docstring",
     "Returns the direct base class as indexed by `GetNumberOfDirectBaseClasses`.
 
     Returns an invalid SBTypeMember if the index is invalid or this SBType is
     invalid.
-    ") GetDirectBaseClassAtIndex;
-    lldb::SBTypeMember
-    GetDirectBaseClassAtIndex (uint32_t idx);
+    "
+) lldb::SBType::GetDirectBaseClassAtIndex;
 
-    %feature("docstring",
     "Returns the virtual base class as indexed by
     `GetNumberOfVirtualBaseClasses`.
 
     Returns an invalid SBTypeMember if the index is invalid or this SBType is
     invalid.
-    ") GetVirtualBaseClassAtIndex;
-    lldb::SBTypeMember
-    GetVirtualBaseClassAtIndex (uint32_t idx);
+    "
+) lldb::SBType::GetVirtualBaseClassAtIndex;
 
-    lldb::SBTypeEnumMemberList
-    GetEnumMembers();
-    %feature("docstring",
     "Returns the `SBModule` this `SBType` belongs to.
 
     Returns no `SBModule` if this type does not belong to any specific
     `SBModule` or this `SBType` is invalid. An invalid `SBModule` might also
     indicate that once came from an `SBModule` but LLDB could no longer
     determine the original module.
-    ") GetModule;
-    lldb::SBModule
-    GetModule();
+    "
+) lldb::SBType::GetModule;
+
+%feature("autodoc", "GetName() -> string") lldb::SBType::GetName;
 
-    %feature("autodoc", "GetName() -> string") GetName;
-    %feature("docstring",
     "Returns the name of this type.
 
     Returns an empty string if an error occurred or this type is invalid.
 
     Use this function when trying to match a specific type by name in a script.
     The names returned by this function try to uniquely identify a name but
     conflicts can occur (for example, if a C++ program contains two different
     classes with the same name in different translation units. `GetName` can
     return the same name for both class types.)
 
 
     Language-specific behaviour:
 
     * C: The name of the type. For structs the ``struct`` prefix is omitted.
     * C++: Returns the qualified name of the type (including anonymous/inline
       namespaces and all template arguments).
     * Objective-C: Same as in C.
-    ") GetName;
-    const char*
-    GetName();
+    "
+) lldb::SBType::GetName;
+
+%feature("autodoc", "GetDisplayTypeName() -> string") lldb::SBType::GetDisplayTypeName;
 
-    %feature("autodoc", "GetDisplayTypeName() -> string") GetDisplayTypeName;
-    %feature("docstring",
     "Returns the name of this type in a user-friendly format.
 
     Returns an empty string if an error occurred or this type is invalid.
 
     Use this function when displaying a type name to the user.
 
     Language-specific behaviour:
 
     * C: Returns the type name. For structs the ``struct`` prefix is omitted.
     * C++: Returns the qualified name. Anonymous/inline namespaces are omitted.
       Template arguments that match their default value might also be hidden
       (this functionality depends on whether LLDB can determine the template's
       default arguments).
     * Objective-C: Same as in C.
-    ") GetDisplayTypeName;
-    const char *
-    GetDisplayTypeName ();
+    "
+) lldb::SBType::GetDisplayTypeName;
+
+%feature("autodoc", "GetTypeClass() -> TypeClass") lldb::SBType::GetTypeClass;
 
-    %feature("autodoc", "GetTypeClass() -> TypeClass") GetTypeClass;
-    %feature("docstring",
     "Returns the `TypeClass` for this type.
 
     Returns an `eTypeClassInvalid` if this `SBType` is invalid.
 
     See `TypeClass` for the language-specific meaning of each `TypeClass` value.
-    ") GetTypeClass;
-    lldb::TypeClass
-    GetTypeClass ();
+    "
+) lldb::SBType::GetTypeClass;
 
-    %feature("docstring",
     "Returns the number of template arguments of this type.
 
     Returns ``0`` if this type is not a template.
 
     Language-specific behaviour:
 
     * C: Always returns ``0``.
     * C++: If this type is a class template instantiation then this returns the
       number of template parameters that were used in this instantiation. This
       includes both explicit and implicit template parameters.
     * Objective-C: Always returns ``0``.
-    ") GetNumberOfTemplateArguments;
-    uint32_t
-    GetNumberOfTemplateArguments ();
+    "
+) lldb::SBType::GetNumberOfTemplateArguments;
 
-    %feature("docstring",
     "Returns the type of the template argument with the given index.
 
     Returns an invalid `SBType` if there is no template argument with the given
     index or this type is not a template. The first template  argument has the
     index ``0``.
 
     Language-specific behaviour:
 
     * C: Always returns an invalid SBType.
     * C++: If this type is a class template instantiation and the template
       parameter with the given index is a type template parameter, then this
       returns the type of that parameter. Otherwise returns an invalid `SBType`.
     * Objective-C: Always returns an invalid SBType.
-    ") GetTemplateArgumentType;
-    lldb::SBType
-    GetTemplateArgumentType (uint32_t idx);
+    "
+) lldb::SBType::GetTemplateArgumentType;
 
-    %feature("docstring",
     "Returns the kind of the template argument with the given index.
 
     Returns `eTemplateArgumentKindNull` if there is no template argument
     with the given index or this type is not a template. The first template
     argument has the index ``0``.
 
     Language-specific behaviour:
 
     * C: Always returns `eTemplateArgumentKindNull`.
     * C++: If this type is a class template instantiation then this returns
       the appropriate `TemplateArgument` value for the parameter with the given
       index. See the documentation of `TemplateArgument` for how certain C++
       template parameter kinds are mapped to `TemplateArgument` values.
     * Objective-C: Always returns `eTemplateArgumentKindNull`.
-    ") GetTemplateArgumentKind;
-    lldb::TemplateArgumentKind
-    GetTemplateArgumentKind (uint32_t idx);
+    "
+) lldb::SBType::GetTemplateArgumentKind;
 
-    %feature("docstring",
     "Returns the return type if this type represents a function.
 
     Returns an invalid `SBType` if this type is not a function type or invalid.
 
     Language-specific behaviour:
 
     * C: For functions return the return type. Returns an invalid `SBType` if
       this type is a function pointer type.
     * C++: Same as in C for functions and instantiated template functions.
       Member functions are also considered functions. For functions that have
       their return type specified by a placeholder type specifier (``auto``)
       this returns the deduced return type.
     * Objective-C: Same as in C for functions. For Objective-C methods this
       returns the return type of the method.
-    ") GetFunctionReturnType;
-    lldb::SBType
-    GetFunctionReturnType ();
+    "
+) lldb::SBType::GetFunctionReturnType;
 
-    %feature("docstring",
     "Returns the list of argument types if this type represents a function.
 
     Returns an invalid `SBType` if this type is not a function type or invalid.
 
     Language-specific behaviour:
 
     * C: For functions return the types of each parameter. Returns an invalid
       `SBType` if this type is a function pointer. For variadic functions this
       just returns the list of parameters before the variadic arguments.
     * C++: Same as in C for functions and instantiated template functions.
       Member functions are also considered functions.
     * Objective-C: Always returns an invalid SBType for Objective-C methods.
-    ") GetFunctionArgumentTypes;
-    lldb::SBTypeList
-    GetFunctionArgumentTypes ();
+    "
+) lldb::SBType::GetFunctionArgumentTypes;
 
-    %feature("docstring",
     "Returns the number of member functions of this type.
 
     Returns ``0`` if an error occurred or this type is invalid.
 
     Language-specific behaviour:
 
     * C: Always returns ``0``.
     * C++: If this type represents a struct/class, then the number of
       member functions (static and non-static) is returned. The count includes
       constructors and destructors (both explicit and implicit). Member
       functions of base classes are not included in the count.
     * Objective-C: If this type represents a struct/class, then the
       number of methods is returned. Methods in categories or super classes
       are not counted.
-    ") GetNumberOfMemberFunctions;
-    uint32_t
-    GetNumberOfMemberFunctions ();
+    "
+) lldb::SBType::GetNumberOfMemberFunctions;
 
-    %feature("docstring",
     "Returns the member function of this type with the given index.
 
     Returns an invalid `SBTypeMemberFunction` if the index is invalid or this
     type is invalid.
 
     Language-specific behaviour:
 
     * C: Always returns an invalid `SBTypeMemberFunction`.
     * C++: Returns the member function or constructor/destructor with the given
       index.
     * Objective-C: Returns the method with the given index.
 
     See `GetNumberOfMemberFunctions` for what functions can be queried by this
     function.
-    ") GetMemberFunctionAtIndex;
-    lldb::SBTypeMemberFunction
-    GetMemberFunctionAtIndex (uint32_t idx);
+    "
+) lldb::SBType::GetMemberFunctionAtIndex;
 
-    %feature("docstring",
     "Returns true if the type is completely defined.
 
     Language-specific behaviour:
 
     * C: Returns false for struct types that were only forward declared in the
       type's `SBTarget`/`SBModule`. Otherwise returns true.
     * C++: Returns false for template/non-template struct/class types and
       scoped enums that were only forward declared inside the type's
       `SBTarget`/`SBModule`. Otherwise returns true.
     * Objective-C: Follows the same behavior as C for struct types. Objective-C
       classes are considered complete unless they were only forward declared via
       ``@class ClassName`` in the type's `SBTarget`/`SBModule`. Otherwise
       returns true.
-    ") IsTypeComplete;
-    bool
-    IsTypeComplete ();
+    "
+) lldb::SBType::IsTypeComplete;
 
-    %feature("docstring",
     "Returns the `TypeFlags` values for this type.
 
     See the respective `TypeFlags` values for what values can be set. Returns an
     integer in which each `TypeFlags` value is represented by a bit. Specific
     flags can be checked via Python's bitwise operators. For example, the
     `eTypeIsInteger` flag can be checked like this:
 
     ``(an_sb_type.GetTypeFlags() & lldb.eTypeIsInteger) != 0``
 
     If this type is invalid this returns ``0``.
 
     See the different values for `TypeFlags` for the language-specific meanings
     of each `TypeFlags` value.
-    ") GetTypeFlags;
-    uint32_t
-    GetTypeFlags ();
-
-    bool operator==(lldb::SBType &rhs);
-
-    bool operator!=(lldb::SBType &rhs);
-
-    STRING_EXTENSION_LEVEL(SBType, lldb::eDescriptionLevelBrief)
-
-#ifdef SWIGPYTHON
-    %pythoncode %{
-        def template_arg_array(self):
-            num_args = self.num_template_args
-            if num_args:
-                template_args = []
-                for i in range(num_args):
-                    template_args.append(self.GetTemplateArgumentType(i))
-                return template_args
-            return None
-
-        module = property(GetModule, None, doc='''A read only property that returns the module in which type is defined.''')
-        name = property(GetName, None, doc='''A read only property that returns the name for this type as a string.''')
-        size = property(GetByteSize, None, doc='''A read only property that returns size in bytes for this type as an integer.''')
-        is_pointer = property(IsPointerType, None, doc='''A read only property that returns a boolean value that indicates if this type is a pointer type.''')
-        is_reference = property(IsReferenceType, None, doc='''A read only property that returns a boolean value that indicates if this type is a reference type.''')
-        is_reference = property(IsReferenceType, None, doc='''A read only property that returns a boolean value that indicates if this type is a function type.''')
-        num_fields = property(GetNumberOfFields, None, doc='''A read only property that returns number of fields in this type as an integer.''')
-        num_bases = property(GetNumberOfDirectBaseClasses, None, doc='''A read only property that returns number of direct base classes in this type as an integer.''')
-        num_vbases = property(GetNumberOfVirtualBaseClasses, None, doc='''A read only property that returns number of virtual base classes in this type as an integer.''')
-        num_template_args = property(GetNumberOfTemplateArguments, None, doc='''A read only property that returns number of template arguments in this type as an integer.''')
-        template_args = property(template_arg_array, None, doc='''A read only property that returns a list() of lldb.SBType objects that represent all template arguments in this type.''')
-        type = property(GetTypeClass, None, doc='''A read only property that returns an lldb enumeration value (see enumerations that start with "lldb.eTypeClass") that represents a classification for this type.''')
-        is_complete = property(IsTypeComplete, None, doc='''A read only property that returns a boolean value that indicates if this type is a complete type (True) or a forward declaration (False).''')
-
-        def get_bases_array(self):
-            '''An accessor function that returns a list() that contains all direct base classes in a lldb.SBType object.'''
-            bases = []
-            for idx in range(self.GetNumberOfDirectBaseClasses()):
-                bases.append(self.GetDirectBaseClassAtIndex(idx))
-            return bases
-
-        def get_vbases_array(self):
-            '''An accessor function that returns a list() that contains all fields in a lldb.SBType object.'''
-            vbases = []
-            for idx in range(self.GetNumberOfVirtualBaseClasses()):
-                vbases.append(self.GetVirtualBaseClassAtIndex(idx))
-            return vbases
-
-        def get_fields_array(self):
-            '''An accessor function that returns a list() that contains all fields in a lldb.SBType object.'''
-            fields = []
-            for idx in range(self.GetNumberOfFields()):
-                fields.append(self.GetFieldAtIndex(idx))
-            return fields
-
-        def get_members_array(self):
-            '''An accessor function that returns a list() that contains all members (base classes and fields) in a lldb.SBType object in ascending bit offset order.'''
-            members = []
-            bases = self.get_bases_array()
-            fields = self.get_fields_array()
-            vbases = self.get_vbases_array()
-            for base in bases:
-                bit_offset = base.bit_offset
-                added = False
-                for idx, member in enumerate(members):
-                    if member.bit_offset > bit_offset:
-                        members.insert(idx, base)
-                        added = True
-                        break
-                if not added:
-                    members.append(base)
-            for vbase in vbases:
-                bit_offset = vbase.bit_offset
-                added = False
-                for idx, member in enumerate(members):
-                    if member.bit_offset > bit_offset:
-                        members.insert(idx, vbase)
-                        added = True
-                        break
-                if not added:
-                    members.append(vbase)
-            for field in fields:
-                bit_offset = field.bit_offset
-                added = False
-                for idx, member in enumerate(members):
-                    if member.bit_offset > bit_offset:
-                        members.insert(idx, field)
-                        added = True
-                        break
-                if not added:
-                    members.append(field)
-            return members
-
-        def get_enum_members_array(self):
-            '''An accessor function that returns a list() that contains all enum members in an lldb.SBType object.'''
-            enum_members_list = []
-            sb_enum_members = self.GetEnumMembers()
-            for idx in range(sb_enum_members.GetSize()):
-                enum_members_list.append(sb_enum_members.GetTypeEnumMemberAtIndex(idx))
-            return enum_members_list
-
-        bases = property(get_bases_array, None, doc='''A read only property that returns a list() of lldb.SBTypeMember objects that represent all of the direct base classes for this type.''')
-        vbases = property(get_vbases_array, None, doc='''A read only property that returns a list() of lldb.SBTypeMember objects that represent all of the virtual base classes for this type.''')
-        fields = property(get_fields_array, None, doc='''A read only property that returns a list() of lldb.SBTypeMember objects that represent all of the fields for this type.''')
-        members = property(get_members_array, None, doc='''A read only property that returns a list() of all lldb.SBTypeMember objects that represent all of the base classes, virtual base classes and fields for this type in ascending bit offset order.''')
-        enum_members = property(get_enum_members_array, None, doc='''A read only property that returns a list() of all lldb.SBTypeEnumMember objects that represent the enum members for this type.''')
-        %}
-#endif
-
-};
+    "
+) lldb::SBType::GetTypeFlags;
 
 %feature("docstring",
 "Represents a list of :py:class:`SBType` s.
 
 The FindTypes() method of :py:class:`SBTarget`/:py:class:`SBModule` returns a SBTypeList.
 
 SBTypeList supports :py:class:`SBType` iteration. For example,
 
.. code-block:: python
 
     # Get the type 'Task'.
     type_list = target.FindTypes('Task')
     self.assertTrue(len(type_list) == 1)
     # To illustrate the SBType iteration.
     for type in type_list:
         # do something with type
 
-") SBTypeList;
-class SBTypeList
-{
-public:
-    SBTypeList();
-
-    bool
-    IsValid();
-
-    explicit operator bool() const;
-
-    void
-    Append (lldb::SBType type);
-
-    lldb::SBType
-    GetTypeAtIndex (uint32_t index);
-
-    uint32_t
-    GetSize();
-
-    ~SBTypeList();
-
-#ifdef SWIGPYTHON
-    %pythoncode%{
-    def __iter__(self):
-        '''Iterate over all types in a lldb.SBTypeList object.'''
-        return lldb_iter(self, 'GetSize', 'GetTypeAtIndex')
-
-    def __len__(self):
-        '''Return the number of types in a lldb.SBTypeList object.'''
-        return self.GetSize()
-    %}
-#endif
-};
-
-} // namespace lldb
+") lldb::SBTypeList;

lldb/bindings/interface/SBTypeEnumMember.i

-//===-- SWIG Interface for SBTypeEnumMember ---------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-%feature(
-    "docstring",
-    "Represents a member of an enum in lldb."
-) SBTypeEnumMember;
-
-class SBTypeEnumMember
-{
-public:
-    SBTypeEnumMember ();
-
-    SBTypeEnumMember (const SBTypeEnumMember& rhs);
-
-    ~SBTypeEnumMember();
-
-    bool
-    IsValid() const;
-
-    explicit operator bool() const;
-
-    int64_t
-    GetValueAsSigned();
-
-    uint64_t
-    GetValueAsUnsigned();
-
-    const char *
-    GetName ();
-
-    lldb::SBType
-    GetType ();
-
-    bool
-    GetDescription (lldb::SBStream &description,
-                    lldb::DescriptionLevel description_level);
-
-    STRING_EXTENSION_LEVEL(SBTypeEnumMember, lldb::eDescriptionLevelBrief)
-#ifdef SWIGPYTHON
-    %pythoncode %{
-        name = property(GetName, None, doc='''A read only property that returns the name for this enum member as a string.''')
-        type = property(GetType, None, doc='''A read only property that returns an lldb object that represents the type (lldb.SBType) for this enum member.''')
-        signed = property(GetValueAsSigned, None, doc='''A read only property that returns the value of this enum member as a signed integer.''')
-        unsigned = property(GetValueAsUnsigned, None, doc='''A read only property that returns the value of this enum member as a unsigned integer.''')
-    %}
-#endif
-
-protected:
-    friend class SBType;
-    friend class SBTypeEnumMemberList;
-
-    void
-    reset (lldb_private::TypeEnumMemberImpl *);
-
-    lldb_private::TypeEnumMemberImpl &
-    ref ();
-
-    const lldb_private::TypeEnumMemberImpl &
-    ref () const;
-
-    lldb::TypeEnumMemberImplSP m_opaque_sp;
-
-    SBTypeEnumMember (const lldb::TypeEnumMemberImplSP &);
-};
-
-%feature("docstring",
-"Represents a list of SBTypeEnumMembers.
-
-SBTypeEnumMemberList supports SBTypeEnumMember iteration.
-It also supports [] access either by index, or by enum
-element name by doing: ::
-
-  myType = target.FindFirstType('MyEnumWithElementA')
-  members = myType.GetEnumMembers()
-  first_elem = members[0]
-  elem_A = members['A']
-
-") SBTypeEnumMemberList;
-
-class SBTypeEnumMemberList
-{
-public:
-    SBTypeEnumMemberList();
-
-    SBTypeEnumMemberList(const SBTypeEnumMemberList& rhs);
-
-    ~SBTypeEnumMemberList();
-
-    bool
-    IsValid();
-
-    explicit operator bool() const;
-
-    void
-    Append (SBTypeEnumMember entry);
-
-    SBTypeEnumMember
-    GetTypeEnumMemberAtIndex (uint32_t index);
-
-    uint32_t
-    GetSize();
-
-#ifdef SWIGPYTHON
-    %pythoncode %{
-        def __iter__(self):
-            '''Iterate over all members in a lldb.SBTypeEnumMemberList object.'''
-            return lldb_iter(self, 'GetSize', 'GetTypeEnumMemberAtIndex')
-
-        def __len__(self):
-            '''Return the number of members in a lldb.SBTypeEnumMemberList object.'''
-            return self.GetSize()
-
-        def __getitem__(self, key):
-          num_elements = self.GetSize()
-          if type(key) is int:
-              if -num_elements <= key < num_elements:
-                  key %= num_elements
-                  return self.GetTypeEnumMemberAtIndex(key)
-          elif type(key) is str:
-              for idx in range(num_elements):
-                  item = self.GetTypeEnumMemberAtIndex(idx)
-                  if item.name == key:
-                      return item
-          return None
-    %}
-#endif
-
-private:
-    std::unique_ptr<lldb_private::TypeEnumMemberListImpl> m_opaque_ap;
-};
-
-} // namespace lldb

lldb/bindings/interface/SBTypeEnumMemberDocstrings.i

+%feature(
+    "docstring",
+    "Represents a member of an enum in lldb."
+) lldb::SBTypeEnumMember;
+
+%feature("docstring",
+"Represents a list of SBTypeEnumMembers.
+
+SBTypeEnumMemberList supports SBTypeEnumMember iteration.
+It also supports [] access either by index, or by enum
+element name by doing: ::
+
+  myType = target.FindFirstType('MyEnumWithElementA')
+  members = myType.GetEnumMembers()
+  first_elem = members[0]
+  elem_A = members['A']
+
+") lldb::SBTypeEnumMemberList;

lldb/bindings/interface/SBTypeEnumMemberExtensions.i

+STRING_EXTENSION_LEVEL_OUTSIDE(SBTypeEnumMember, lldb::eDescriptionLevelBrief)
+%extend lldb::SBTypeEnumMember {
+#ifdef SWIGPYTHON
+    %pythoncode %{
+        name = property(GetName, None, doc='''A read only property that returns the name for this enum member as a string.''')
+        type = property(GetType, None, doc='''A read only property that returns an lldb object that represents the type (lldb.SBType) for this enum member.''')
+        signed = property(GetValueAsSigned, None, doc='''A read only property that returns the value of this enum member as a signed integer.''')
+        unsigned = property(GetValueAsUnsigned, None, doc='''A read only property that returns the value of this enum member as a unsigned integer.''')
+    %}
+#endif
+}
+
+%extend lldb::SBTypeEnumMemberList {
+#ifdef SWIGPYTHON
+    %pythoncode %{
+        def __iter__(self):
+            '''Iterate over all members in a lldb.SBTypeEnumMemberList object.'''
+            return lldb_iter(self, 'GetSize', 'GetTypeEnumMemberAtIndex')
+
+        def __len__(self):
+            '''Return the number of members in a lldb.SBTypeEnumMemberList object.'''
+            return self.GetSize()
+
+        def __getitem__(self, key):
+          num_elements = self.GetSize()
+          if type(key) is int:
+              if -num_elements <= key < num_elements:
+                  key %= num_elements
+                  return self.GetTypeEnumMemberAtIndex(key)
+          elif type(key) is str:
+              for idx in range(num_elements):
+                  item = self.GetTypeEnumMemberAtIndex(idx)
+                  if item.name == key:
+                      return item
+          return None
+    %}
+#endif
+}

lldb/bindings/interface/SBTypeExtensions.i

+STRING_EXTENSION_LEVEL_OUTSIDE(SBTypeMember, lldb::eDescriptionLevelBrief)
+%extend lldb::SBTypeMember {
+#ifdef SWIGPYTHON
+    %pythoncode %{
+        name = property(GetName, None, doc='''A read only property that returns the name for this member as a string.''')
+        type = property(GetType, None, doc='''A read only property that returns an lldb object that represents the type (lldb.SBType) for this member.''')
+        byte_offset = property(GetOffsetInBytes, None, doc='''A read only property that returns offset in bytes for this member as an integer.''')
+        bit_offset = property(GetOffsetInBits, None, doc='''A read only property that returns offset in bits for this member as an integer.''')
+        is_bitfield = property(IsBitfield, None, doc='''A read only property that returns true if this member is a bitfield.''')
+        bitfield_bit_size = property(GetBitfieldSizeInBits, None, doc='''A read only property that returns the bitfield size in bits for this member as an integer, or zero if this member is not a bitfield.''')
+    %}
+#endif
+}
+
+STRING_EXTENSION_LEVEL_OUTSIDE(SBTypeMemberFunction, lldb::eDescriptionLevelBrief)
+
+STRING_EXTENSION_LEVEL_OUTSIDE(SBType, lldb::eDescriptionLevelBrief)
+
+%extend lldb::SBType {
+#ifdef SWIGPYTHON
+    %pythoncode %{
+        def template_arg_array(self):
+            num_args = self.num_template_args
+            if num_args:
+                template_args = []
+                for i in range(num_args):
+                    template_args.append(self.GetTemplateArgumentType(i))
+                return template_args
+            return None
+
+        module = property(GetModule, None, doc='''A read only property that returns the module in which type is defined.''')
+        name = property(GetName, None, doc='''A read only property that returns the name for this type as a string.''')
+        size = property(GetByteSize, None, doc='''A read only property that returns size in bytes for this type as an integer.''')
+        is_pointer = property(IsPointerType, None, doc='''A read only property that returns a boolean value that indicates if this type is a pointer type.''')
+        is_reference = property(IsReferenceType, None, doc='''A read only property that returns a boolean value that indicates if this type is a reference type.''')
+        is_reference = property(IsReferenceType, None, doc='''A read only property that returns a boolean value that indicates if this type is a function type.''')
+        num_fields = property(GetNumberOfFields, None, doc='''A read only property that returns number of fields in this type as an integer.''')
+        num_bases = property(GetNumberOfDirectBaseClasses, None, doc='''A read only property that returns number of direct base classes in this type as an integer.''')
+        num_vbases = property(GetNumberOfVirtualBaseClasses, None, doc='''A read only property that returns number of virtual base classes in this type as an integer.''')
+        num_template_args = property(GetNumberOfTemplateArguments, None, doc='''A read only property that returns number of template arguments in this type as an integer.''')
+        template_args = property(template_arg_array, None, doc='''A read only property that returns a list() of lldb.SBType objects that represent all template arguments in this type.''')
+        type = property(GetTypeClass, None, doc='''A read only property that returns an lldb enumeration value (see enumerations that start with "lldb.eTypeClass") that represents a classification for this type.''')
+        is_complete = property(IsTypeComplete, None, doc='''A read only property that returns a boolean value that indicates if this type is a complete type (True) or a forward declaration (False).''')
+
+        def get_bases_array(self):
+            '''An accessor function that returns a list() that contains all direct base classes in a lldb.SBType object.'''
+            bases = []
+            for idx in range(self.GetNumberOfDirectBaseClasses()):
+                bases.append(self.GetDirectBaseClassAtIndex(idx))
+            return bases
+
+        def get_vbases_array(self):
+            '''An accessor function that returns a list() that contains all fields in a lldb.SBType object.'''
+            vbases = []
+            for idx in range(self.GetNumberOfVirtualBaseClasses()):
+                vbases.append(self.GetVirtualBaseClassAtIndex(idx))
+            return vbases
+
+        def get_fields_array(self):
+            '''An accessor function that returns a list() that contains all fields in a lldb.SBType object.'''
+            fields = []
+            for idx in range(self.GetNumberOfFields()):
+                fields.append(self.GetFieldAtIndex(idx))
+            return fields
+
+        def get_members_array(self):
+            '''An accessor function that returns a list() that contains all members (base classes and fields) in a lldb.SBType object in ascending bit offset order.'''
+            members = []
+            bases = self.get_bases_array()
+            fields = self.get_fields_array()
+            vbases = self.get_vbases_array()
+            for base in bases:
+                bit_offset = base.bit_offset
+                added = False
+                for idx, member in enumerate(members):
+                    if member.bit_offset > bit_offset:
+                        members.insert(idx, base)
+                        added = True
+                        break
+                if not added:
+                    members.append(base)
+            for vbase in vbases:
+                bit_offset = vbase.bit_offset
+                added = False
+                for idx, member in enumerate(members):
+                    if member.bit_offset > bit_offset:
+                        members.insert(idx, vbase)
+                        added = True
+                        break
+                if not added:
+                    members.append(vbase)
+            for field in fields:
+                bit_offset = field.bit_offset
+                added = False
+                for idx, member in enumerate(members):
+                    if member.bit_offset > bit_offset:
+                        members.insert(idx, field)
+                        added = True
+                        break
+                if not added:
+                    members.append(field)
+            return members
+
+        def get_enum_members_array(self):
+            '''An accessor function that returns a list() that contains all enum members in an lldb.SBType object.'''
+            enum_members_list = []
+            sb_enum_members = self.GetEnumMembers()
+            for idx in range(sb_enum_members.GetSize()):
+                enum_members_list.append(sb_enum_members.GetTypeEnumMemberAtIndex(idx))
+            return enum_members_list
+
+        bases = property(get_bases_array, None, doc='''A read only property that returns a list() of lldb.SBTypeMember objects that represent all of the direct base classes for this type.''')
+        vbases = property(get_vbases_array, None, doc='''A read only property that returns a list() of lldb.SBTypeMember objects that represent all of the virtual base classes for this type.''')
+        fields = property(get_fields_array, None, doc='''A read only property that returns a list() of lldb.SBTypeMember objects that represent all of the fields for this type.''')
+        members = property(get_members_array, None, doc='''A read only property that returns a list() of all lldb.SBTypeMember objects that represent all of the base classes, virtual base classes and fields for this type in ascending bit offset order.''')
+        enum_members = property(get_enum_members_array, None, doc='''A read only property that returns a list() of all lldb.SBTypeEnumMember objects that represent the enum members for this type.''')
+        %}
+#endif
+}
+
+%extend lldb::SBTypeList {
+#ifdef SWIGPYTHON
+    %pythoncode%{
+    def __iter__(self):
+        '''Iterate over all types in a lldb.SBTypeList object.'''
+        return lldb_iter(self, 'GetSize', 'GetTypeAtIndex')
+
+    def __len__(self):
+        '''Return the number of types in a lldb.SBTypeList object.'''
+        return self.GetSize()
+    %}
+#endif
+}

lldb/bindings/interface/SBTypeFilter.i

-//===-- SWIG Interface for SBTypeFilter----------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-    %feature("docstring",
-    "Represents a filter that can be associated to one or more types.") SBTypeFilter;
-
-    class SBTypeFilter
-    {
-        public:
-
-        SBTypeFilter();
-
-        SBTypeFilter (uint32_t options);
-
-        SBTypeFilter (const lldb::SBTypeFilter &rhs);
-
-        ~SBTypeFilter ();
-
-        bool
-        IsValid() const;
-
-        explicit operator bool() const;
-
-        bool
-        IsEqualTo (lldb::SBTypeFilter &rhs);
-
-        uint32_t
-        GetNumberOfExpressionPaths ();
-
-        const char*
-        GetExpressionPathAtIndex (uint32_t i);
-
-        bool
-        ReplaceExpressionPathAtIndex (uint32_t i, const char* item);
-
-        void
-        AppendExpressionPath (const char* item);
-
-        void
-        Clear();
-
-        uint32_t
-        GetOptions();
-
-        void
-        SetOptions (uint32_t);
-
-        bool
-        GetDescription (lldb::SBStream &description, lldb::DescriptionLevel description_level);
-
-        bool
-        operator == (lldb::SBTypeFilter &rhs);
-
-        bool
-        operator != (lldb::SBTypeFilter &rhs);
-
-        STRING_EXTENSION_LEVEL(SBTypeFilter, lldb::eDescriptionLevelBrief)
-
-#ifdef SWIGPYTHON
-        %pythoncode %{
-            options = property(GetOptions, SetOptions)
-            count = property(GetNumberOfExpressionPaths)
-        %}
-#endif
-
-    };
-
-} // namespace lldb

lldb/bindings/interface/SBTypeFilterDocstrings.i

+%feature("docstring",
+"Represents a filter that can be associated to one or more types."
+) lldb::SBTypeFilter;

lldb/bindings/interface/SBTypeFilterExtensions.i

+STRING_EXTENSION_LEVEL_OUTSIDE(SBTypeFilter, lldb::eDescriptionLevelBrief)
+%extend lldb::SBTypeFilter {
+#ifdef SWIGPYTHON
+        %pythoncode %{
+            options = property(GetOptions, SetOptions)
+            count = property(GetNumberOfExpressionPaths)
+        %}
+#endif
+}

lldb/bindings/interface/SBTypeFormat.i

-//===-- SWIG Interface for SBTypeFormat----------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-    %feature("docstring",
-             "Represents a format that can be associated to one or more types.") SBTypeFormat;
-
-    class SBTypeFormat
-    {
-    public:
-
-        SBTypeFormat();
-
-        SBTypeFormat (lldb::Format format, uint32_t options = 0);
-
-        SBTypeFormat (const char* type, uint32_t options = 0);
-
-        SBTypeFormat (const lldb::SBTypeFormat &rhs);
-
-        ~SBTypeFormat ();
-
-        bool
-        IsValid() const;
-
-        explicit operator bool() const;
-
-        bool
-        IsEqualTo (lldb::SBTypeFormat &rhs);
-
-        lldb::Format
-        GetFormat ();
-
-        const char*
-        GetTypeName ();
-
-        uint32_t
-        GetOptions();
-
-        void
-        SetFormat (lldb::Format);
-
-        void
-        SetTypeName (const char*);
-
-        void
-        SetOptions (uint32_t);
-
-        bool
-        GetDescription (lldb::SBStream &description,
-                        lldb::DescriptionLevel description_level);
-
-        bool
-        operator == (lldb::SBTypeFormat &rhs);
-
-        bool
-        operator != (lldb::SBTypeFormat &rhs);
-
-        STRING_EXTENSION_LEVEL(SBTypeFormat, lldb::eDescriptionLevelBrief)
-
-#ifdef SWIGPYTHON
-        %pythoncode %{
-            format = property(GetFormat, SetFormat)
-            options = property(GetOptions, SetOptions)
-        %}
-#endif
-
-    };
-
-
-} // namespace lldb
-

lldb/bindings/interface/SBTypeFormatDocstrings.i

+%feature("docstring",
+"Represents a format that can be associated to one or more types."
+) lldb::SBTypeFormat;

lldb/bindings/interface/SBTypeFormatExtensions.i

+STRING_EXTENSION_LEVEL_OUTSIDE(SBTypeFormat, lldb::eDescriptionLevelBrief)
+%extend lldb::SBTypeFormat {
+#ifdef SWIGPYTHON
+        %pythoncode %{
+            format = property(GetFormat, SetFormat)
+            options = property(GetOptions, SetOptions)
+        %}
+#endif
+}

lldb/bindings/interface/SBTypeNameSpecifier.i

-//===-- SWIG Interface for SBTypeNameSpecifier---------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-    %feature("docstring",
-    "Represents a general way to provide a type name to LLDB APIs.") SBTypeNameSpecifier;
-
-    class SBTypeNameSpecifier
-    {
-    public:
-
-        SBTypeNameSpecifier();
-
-        SBTypeNameSpecifier (const char* name,
-                             bool is_regex = false);
-
-        SBTypeNameSpecifier (const char* name,
-                             lldb::FormatterMatchType match_type);
-
-        SBTypeNameSpecifier (SBType type);
-
-        SBTypeNameSpecifier (const lldb::SBTypeNameSpecifier &rhs);
-
-        ~SBTypeNameSpecifier ();
-
-        bool
-        IsValid() const;
-
-        explicit operator bool() const;
-
-        bool
-        IsEqualTo (lldb::SBTypeNameSpecifier &rhs);
-
-        const char*
-        GetName();
-
-        lldb::SBType
-        GetType ();
-
-        lldb::FormatterMatchType
-        GetMatchType();
-
-        bool
-        IsRegex();
-
-        bool
-        GetDescription (lldb::SBStream &description,
-                        lldb::DescriptionLevel description_level);
-
-        bool
-        operator == (lldb::SBTypeNameSpecifier &rhs);
-
-        bool
-        operator != (lldb::SBTypeNameSpecifier &rhs);
-
-        STRING_EXTENSION_LEVEL(SBTypeNameSpecifier, lldb::eDescriptionLevelBrief)
-
-#ifdef SWIGPYTHON
-        %pythoncode %{
-            name = property(GetName)
-            is_regex = property(IsRegex)
-        %}
-#endif
-
-
-    };
-
-} // namespace lldb
-

lldb/bindings/interface/SBTypeNameSpecifierDocstrings.i

+%feature("docstring",
+"Represents a general way to provide a type name to LLDB APIs."
+) lldb::SBTypeNameSpecifier;

lldb/bindings/interface/SBTypeNameSpecifierExtensions.i

+STRING_EXTENSION_LEVEL_OUTSIDE(SBTypeNameSpecifier, lldb::eDescriptionLevelBrief)
+%extend lldb::SBTypeNameSpecifier {
+#ifdef SWIGPYTHON
+        %pythoncode %{
+            name = property(GetName)
+            is_regex = property(IsRegex)
+        %}
+#endif
+}

lldb/bindings/interface/SBTypeSummary.i

-//===-- SWIG Interface for SBTypeSummary---------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-    class SBTypeSummaryOptions
-    {
-    public:
-        SBTypeSummaryOptions();
-
-        SBTypeSummaryOptions (const lldb::SBTypeSummaryOptions &rhs);
-
-        ~SBTypeSummaryOptions ();
-
-        bool
-        IsValid ();
-
-        explicit operator bool() const;
-
-        lldb::LanguageType
-        GetLanguage ();
-
-        lldb::TypeSummaryCapping
-        GetCapping ();
-
-        void
-        SetLanguage (lldb::LanguageType);
-
-        void
-        SetCapping (lldb::TypeSummaryCapping);
-    };
-
-    %feature("docstring",
-    "Represents a summary that can be associated to one or more types.") SBTypeSummary;
-
-    class SBTypeSummary
-    {
-    public:
-
-        SBTypeSummary();
-
-        static SBTypeSummary
-        CreateWithSummaryString (const char* data, uint32_t options = 0);
-
-        static SBTypeSummary
-        CreateWithFunctionName (const char* data, uint32_t options = 0);
-
-        static SBTypeSummary
-        CreateWithScriptCode (const char* data, uint32_t options = 0);
-
-        SBTypeSummary (const lldb::SBTypeSummary &rhs);
-
-        ~SBTypeSummary ();
-
-        bool
-        IsValid() const;
-
-        explicit operator bool() const;
-
-        bool
-        IsEqualTo (lldb::SBTypeSummary &rhs);
-
-        bool
-        IsFunctionCode();
-
-        bool
-        IsFunctionName();
-
-        bool
-        IsSummaryString();
-
-        const char*
-        GetData ();
-
-        void
-        SetSummaryString (const char* data);
-
-        void
-        SetFunctionName (const char* data);
-
-        void
-        SetFunctionCode (const char* data);
-
-        uint32_t
-        GetOptions ();
-
-        void
-        SetOptions (uint32_t);
-
-        bool
-        GetDescription (lldb::SBStream &description,
-                        lldb::DescriptionLevel description_level);
-
-        bool
-        operator == (lldb::SBTypeSummary &rhs);
-
-        bool
-        operator != (lldb::SBTypeSummary &rhs);
-
-        STRING_EXTENSION_LEVEL(SBTypeSummary, lldb::eDescriptionLevelBrief)
-
-#ifdef SWIGPYTHON
-        %pythoncode %{
-            options = property(GetOptions, SetOptions)
-            is_summary_string = property(IsSummaryString)
-            is_function_name = property(IsFunctionName)
-            is_function_name = property(IsFunctionCode)
-            summary_data = property(GetData)
-        %}
-#endif
-
-    };
-
-} // namespace lldb
-

lldb/bindings/interface/SBTypeSummaryDocstrings.i

+%feature("docstring",
+"Represents a summary that can be associated to one or more types."
+) lldb::SBTypeSummary;

lldb/bindings/interface/SBTypeSummaryExtensions.i

+STRING_EXTENSION_LEVEL_OUTSIDE(SBTypeSummary, lldb::eDescriptionLevelBrief)
+%extend lldb::SBTypeSummary {
+#ifdef SWIGPYTHON
+        %pythoncode %{
+            options = property(GetOptions, SetOptions)
+            is_summary_string = property(IsSummaryString)
+            is_function_name = property(IsFunctionName)
+            is_function_name = property(IsFunctionCode)
+            summary_data = property(GetData)
+        %}
+#endif
+}

lldb/bindings/interface/SBTypeSynthetic.i

-//===-- SWIG Interface for SBTypeSynthetic-------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-    %feature("docstring",
-    "Represents a summary that can be associated to one or more types.") SBTypeSynthetic;
-
-    class SBTypeSynthetic
-    {
-    public:
-
-        SBTypeSynthetic();
-
-        static lldb::SBTypeSynthetic
-        CreateWithClassName (const char* data, uint32_t options = 0);
-
-        static lldb::SBTypeSynthetic
-        CreateWithScriptCode (const char* data, uint32_t options = 0);
-
-        SBTypeSynthetic (const lldb::SBTypeSynthetic &rhs);
-
-        ~SBTypeSynthetic ();
-
-        bool
-        IsValid() const;
-
-        explicit operator bool() const;
-
-        bool
-        IsEqualTo (lldb::SBTypeSynthetic &rhs);
-
-        bool
-        IsClassCode();
-
-        const char*
-        GetData ();
-
-        void
-        SetClassName (const char* data);
-
-        void
-        SetClassCode (const char* data);
-
-        uint32_t
-        GetOptions ();
-
-        void
-        SetOptions (uint32_t);
-
-        bool
-        GetDescription (lldb::SBStream &description,
-                        lldb::DescriptionLevel description_level);
-
-        bool
-        operator == (lldb::SBTypeSynthetic &rhs);
-
-        bool
-        operator != (lldb::SBTypeSynthetic &rhs);
-
-        STRING_EXTENSION_LEVEL(SBTypeSynthetic, lldb::eDescriptionLevelBrief)
-
-#ifdef SWIGPYTHON
-        %pythoncode %{
-            options = property(GetOptions, SetOptions)
-            contains_code = property(IsClassCode, None)
-            synthetic_data = property(GetData, None)
-        %}
-#endif
-
-    };
-
-} // namespace lldb

lldb/bindings/interface/SBTypeSyntheticDocstrings.i

+%feature("docstring",
+"Represents a summary that can be associated to one or more types."
+) lldb::SBTypeSynthetic;

lldb/bindings/interface/SBTypeSyntheticExtensions.i

+STRING_EXTENSION_LEVEL_OUTSIDE(SBTypeSynthetic, lldb::eDescriptionLevelBrief)
+%extend lldb::SBTypeSynthetic {
+#ifdef SWIGPYTHON
+        %pythoncode %{
+            options = property(GetOptions, SetOptions)
+            contains_code = property(IsClassCode, None)
+            synthetic_data = property(GetData, None)
+        %}
+#endif
+}

lldb/bindings/interface/SBUnixSignals.i

-//===-- SWIG Interface for SBUnixSignals ------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-%feature("docstring",
-"Allows you to manipulate LLDB's signal disposition"
-) SBUnixSignals;
-class SBUnixSignals
-{
-public:
-    SBUnixSignals ();
-
-    SBUnixSignals (const lldb::SBUnixSignals &rhs);
-
-    ~SBUnixSignals();
-
-    void
-    Clear ();
-
-    bool
-    IsValid () const;
-
-    explicit operator bool() const;
-
-    const char *
-    GetSignalAsCString (int32_t signo) const;
-
-    int32_t
-    GetSignalNumberFromName (const char *name) const;
-
-    bool
-    GetShouldSuppress (int32_t signo) const;
-
-    bool
-    SetShouldSuppress (int32_t signo,
-                       bool value);
-
-    bool
-    GetShouldStop (int32_t signo) const;
-
-    bool
-    SetShouldStop (int32_t signo,
-                   bool value);
-
-    bool
-    GetShouldNotify (int32_t signo) const;
-
-    bool
-    SetShouldNotify (int32_t signo, bool value);
-
-    int32_t
-    GetNumSignals () const;
-
-    int32_t
-    GetSignalAtIndex (int32_t index) const;
-
-#ifdef SWIGPYTHON
-    %pythoncode %{
-        def get_unix_signals_list(self):
-            signals = []
-            for idx in range(0, self.GetNumSignals()):
-                signals.append(self.GetSignalAtIndex(sig))
-            return signals
-
-        threads = property(get_unix_signals_list, None, doc='''A read only property that returns a list() of valid signal numbers for this platform.''')
-    %}
-#endif
-};
-
-}  // namespace lldb

lldb/bindings/interface/SBUnixSignalsDocstrings.i

+%feature("docstring",
+"Allows you to manipulate LLDB's signal disposition"
+) lldb::SBUnixSignals;

lldb/bindings/interface/SBUnixSignalsExtensions.i

+%extend lldb::SBUnixSignals {
+#ifdef SWIGPYTHON
+    %pythoncode %{
+        def get_unix_signals_list(self):
+            signals = []
+            for idx in range(0, self.GetNumSignals()):
+                signals.append(self.GetSignalAtIndex(sig))
+            return signals
+
+        threads = property(get_unix_signals_list, None, doc='''A read only property that returns a list() of valid signal numbers for this platform.''')
+    %}
+#endif
+}

lldb/bindings/interface/SBValue.i

-//===-- SWIG Interface for SBValue ------------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-%feature("docstring",
-"Represents the value of a variable, a register, or an expression.
-
-SBValue supports iteration through its child, which in turn is represented
-as an SBValue.  For example, we can get the general purpose registers of a
-frame as an SBValue, and iterate through all the registers,::
-
-    registerSet = frame.registers # Returns an SBValueList.
-    for regs in registerSet:
-        if 'general purpose registers' in regs.name.lower():
-            GPRs = regs
-            break
-
-    print('%s (number of children = %d):' % (GPRs.name, GPRs.num_children))
-    for reg in GPRs:
-        print('Name: ', reg.name, ' Value: ', reg.value)
-
-produces the output: ::
-
-    General Purpose Registers (number of children = 21):
-    Name:  rax  Value:  0x0000000100000c5c
-    Name:  rbx  Value:  0x0000000000000000
-    Name:  rcx  Value:  0x00007fff5fbffec0
-    Name:  rdx  Value:  0x00007fff5fbffeb8
-    Name:  rdi  Value:  0x0000000000000001
-    Name:  rsi  Value:  0x00007fff5fbffea8
-    Name:  rbp  Value:  0x00007fff5fbffe80
-    Name:  rsp  Value:  0x00007fff5fbffe60
-    Name:  r8  Value:  0x0000000008668682
-    Name:  r9  Value:  0x0000000000000000
-    Name:  r10  Value:  0x0000000000001200
-    Name:  r11  Value:  0x0000000000000206
-    Name:  r12  Value:  0x0000000000000000
-    Name:  r13  Value:  0x0000000000000000
-    Name:  r14  Value:  0x0000000000000000
-    Name:  r15  Value:  0x0000000000000000
-    Name:  rip  Value:  0x0000000100000dae
-    Name:  rflags  Value:  0x0000000000000206
-    Name:  cs  Value:  0x0000000000000027
-    Name:  fs  Value:  0x0000000000000010
-    Name:  gs  Value:  0x0000000000000048
-
-See also linked_list_iter() for another perspective on how to iterate through an
-SBValue instance which interprets the value object as representing the head of a
-linked list."
-) SBValue;
-class SBValue
-{
-public:
-    SBValue ();
-
-    SBValue (const SBValue &rhs);
-
-    ~SBValue ();
-
-    bool
-    IsValid();
-
-    explicit operator bool() const;
-
-    void
-    Clear();
-
-    SBError
-    GetError();
-
-    lldb::user_id_t
-    GetID ();
-
-    const char *
-    GetName();
-
-    const char *
-    GetTypeName ();
-
-    const char *
-    GetDisplayTypeName ();
-
-    size_t
-    GetByteSize ();
-
-    bool
-    IsInScope ();
-
-    lldb::Format
-    GetFormat ();
-
-    void
-    SetFormat (lldb::Format format);
-
-    const char *
-    GetValue ();
-
-    int64_t
-    GetValueAsSigned(SBError& error, int64_t fail_value=0);
-
-    uint64_t
-    GetValueAsUnsigned(SBError& error, uint64_t fail_value=0);
-
-    int64_t
-    GetValueAsSigned(int64_t fail_value=0);
-
-    uint64_t
-    GetValueAsUnsigned(uint64_t fail_value=0);
-
-    ValueType
-    GetValueType ();
-
-    bool
-    GetValueDidChange ();
-
-    const char *
-    GetSummary ();
-
-    const char *
-    GetSummary (lldb::SBStream& stream,
-                lldb::SBTypeSummaryOptions& options);
-
-    const char *
-    GetObjectDescription ();
-
-    lldb::SBValue
-    GetDynamicValue (lldb::DynamicValueType use_dynamic);
-
-    lldb::SBValue
-    GetStaticValue ();
-
-    lldb::SBValue
-    GetNonSyntheticValue ();
-
-    lldb::DynamicValueType
-    GetPreferDynamicValue ();
-
-    void
-    SetPreferDynamicValue (lldb::DynamicValueType use_dynamic);
-
-    bool
-    GetPreferSyntheticValue ();
-
-    void
-    SetPreferSyntheticValue (bool use_synthetic);
-
-    bool
-    IsDynamic();
-
-    bool
-    IsSynthetic ();
-
-    bool
-    IsSyntheticChildrenGenerated ();
-
-    void
-    SetSyntheticChildrenGenerated (bool);
-
-    const char *
-    GetLocation ();
-
-    bool
-    SetValueFromCString (const char *value_str);
-
-    bool
-    SetValueFromCString (const char *value_str, lldb::SBError& error);
-
-    lldb::SBTypeFormat
-    GetTypeFormat ();
-
-    lldb::SBTypeSummary
-    GetTypeSummary ();
-
-    lldb::SBTypeFilter
-    GetTypeFilter ();
-
-    lldb::SBTypeSynthetic
-    GetTypeSynthetic ();
-
-    lldb::SBValue
-    GetChildAtIndex (uint32_t idx);
-
-    %feature("docstring", "
-    Get a child value by index from a value.
-
-    Structs, unions, classes, arrays and pointers have child
-    values that can be access by index.
-
-    Structs and unions access child members using a zero based index
-    for each child member. For
-
-    Classes reserve the first indexes for base classes that have
-    members (empty base classes are omitted), and all members of the
-    current class will then follow the base classes.
-
-    Pointers differ depending on what they point to. If the pointer
-    points to a simple type, the child at index zero
-    is the only child value available, unless synthetic_allowed
-    is true, in which case the pointer will be used as an array
-    and can create 'synthetic' child values using positive or
-    negative indexes. If the pointer points to an aggregate type
-    (an array, class, union, struct), then the pointee is
-    transparently skipped and any children are going to be the indexes
-    of the child values within the aggregate type. For example if
-    we have a 'Point' type and we have a SBValue that contains a
-    pointer to a 'Point' type, then the child at index zero will be
-    the 'x' member, and the child at index 1 will be the 'y' member
-    (the child at index zero won't be a 'Point' instance).
-
-    If you actually need an SBValue that represents the type pointed
-    to by a SBValue for which GetType().IsPointeeType() returns true,
-    regardless of the pointee type, you can do that with the SBValue.Dereference
-    method (or the equivalent deref property).
-
-    Arrays have a preset number of children that can be accessed by
-    index and will returns invalid child values for indexes that are
-    out of bounds unless the synthetic_allowed is true. In this
-    case the array can create 'synthetic' child values for indexes
-    that aren't in the array bounds using positive or negative
-    indexes.
-
-    @param[in] idx
-        The index of the child value to get
-
-    @param[in] use_dynamic
-        An enumeration that specifies whether to get dynamic values,
-        and also if the target can be run to figure out the dynamic
-        type of the child value.
-
-    @param[in] synthetic_allowed
-        If true, then allow child values to be created by index
-        for pointers and arrays for indexes that normally wouldn't
-        be allowed.
-
-    @return
-        A new SBValue object that represents the child member value.") GetChildAtIndex;
-    lldb::SBValue
-    GetChildAtIndex (uint32_t idx,
-                     lldb::DynamicValueType use_dynamic,
-                     bool can_create_synthetic);
-
-    lldb::SBValue
-    CreateChildAtOffset (const char *name, uint32_t offset, lldb::SBType type);
-
-    lldb::SBValue
-    SBValue::Cast (lldb::SBType type);
-
-    lldb::SBValue
-    CreateValueFromExpression (const char *name, const char* expression);
-
-    lldb::SBValue
-    CreateValueFromExpression (const char *name, const char* expression, SBExpressionOptions &options);
-
-    lldb::SBValue
-    CreateValueFromAddress(const char* name, lldb::addr_t address, lldb::SBType type);
-
-  lldb::SBValue
-  CreateValueFromData (const char* name,
-                       lldb::SBData data,
-                       lldb::SBType type);
-
-    lldb::SBType
-    GetType();
-
-    %feature("docstring", "
-    Returns the child member index.
-
-    Matches children of this object only and will match base classes and
-    member names if this is a clang typed object.
-
-    @param[in] name
-        The name of the child value to get
-
-    @return
-        An index to the child member value.") GetIndexOfChildWithName;
-    uint32_t
-    GetIndexOfChildWithName (const char *name);
-
-    lldb::SBValue
-    GetChildMemberWithName (const char *name);
-
-    %feature("docstring", "
-    Returns the child member value.
-
-    Matches child members of this object and child members of any base
-    classes.
-
-    @param[in] name
-        The name of the child value to get
-
-    @param[in] use_dynamic
-        An enumeration that specifies whether to get dynamic values,
-        and also if the target can be run to figure out the dynamic
-        type of the child value.
-
-    @return
-        A new SBValue object that represents the child member value.") GetChildMemberWithName;
-    lldb::SBValue
-    GetChildMemberWithName (const char *name, lldb::DynamicValueType use_dynamic);
-
-    %feature("docstring", "Expands nested expressions like .a->b[0].c[1]->d."
-    ) GetValueForExpressionPath;
-    lldb::SBValue
-    GetValueForExpressionPath(const char* expr_path);
-
-    lldb::SBDeclaration
-    GetDeclaration ();
-
-    bool
-    MightHaveChildren ();
-
-    bool
-    IsRuntimeSupportValue ();
-
-    uint32_t
-    GetNumChildren ();
-
-    %feature("doctstring", "
-    Returns the number for children.
-
-    @param[in] max
-        If max is less the lldb.UINT32_MAX, then the returned value is
-        capped to max.
-
-    @return
-        An integer value capped to the argument max.") GetNumChildren;
-    uint32_t
-    GetNumChildren (uint32_t max);
-
-    void *
-    GetOpaqueType();
-
-    lldb::SBValue
-    Dereference ();
-
-    lldb::SBValue
-    AddressOf();
-
-    bool
-    TypeIsPointerType ();
-
-    lldb::SBTarget
-    GetTarget();
-
-    lldb::SBProcess
-    GetProcess();
-
-    lldb::SBThread
-    GetThread();
-
-    lldb::SBFrame
-    GetFrame();
-
-    %feature("docstring", "
-    Find and watch a variable.
-    It returns an SBWatchpoint, which may be invalid.") Watch;
-    lldb::SBWatchpoint
-    Watch (bool resolve_location, bool read, bool write, SBError &error);
-
-    %feature("docstring", "
-    Find and watch the location pointed to by a variable.
-    It returns an SBWatchpoint, which may be invalid.") WatchPointee;
-    lldb::SBWatchpoint
-    WatchPointee (bool resolve_location, bool read, bool write, SBError &error);
-
-    bool
-    GetDescription (lldb::SBStream &description);
-
-    bool
-    GetExpressionPath (lldb::SBStream &description);
-
-  %feature("docstring", "
-    Get an SBData wrapping what this SBValue points to.
-
-    This method will dereference the current SBValue, if its
-    data type is a ``T\*`` or ``T[]``, and extract ``item_count`` elements
-    of type ``T`` from it, copying their contents in an :py:class:`SBData`.
-
-    :param item_idx: The index of the first item to retrieve. For an array
-        this is equivalent to array[item_idx], for a pointer
-        to ``\*(pointer + item_idx)``. In either case, the measurement
-        unit for item_idx is the ``sizeof(T)`` rather than the byte
-    :param item_count: How many items should be copied into the output. By default
-        only one item is copied, but more can be asked for.
-    :return: The contents of the copied items on success. An empty :py:class:`SBData` otherwise.
-    :rtype: SBData
-    ") GetPointeeData;
-  lldb::SBData
-  GetPointeeData (uint32_t item_idx = 0,
-          uint32_t item_count = 1);
-
-    %feature("docstring", "
-    Get an SBData wrapping the contents of this SBValue.
-
-    This method will read the contents of this object in memory
-    and copy them into an SBData for future use.
-
-    @return
-        An SBData with the contents of this SBValue, on success.
-        An empty SBData otherwise.") GetData;
-    lldb::SBData
-    GetData ();
-
-    bool
-    SetData (lldb::SBData &data, lldb::SBError& error);
-
-    lldb::SBValue
-    Clone(const char *new_name);
-
-  lldb::addr_t
-  GetLoadAddress();
-
-  lldb::SBAddress
-  GetAddress();
-
-    lldb::SBValue
-    Persist ();
-
-    %feature("docstring", "Returns an expression path for this value."
-    ) GetExpressionPath;
-    bool
-    GetExpressionPath (lldb::SBStream &description, bool qualify_cxx_base_classes);
-
-    lldb::SBValue
-    EvaluateExpression(const char *expr) const;
-
-    lldb::SBValue
-    EvaluateExpression(const char *expr,
-                       const SBExpressionOptions &options) const;
-
-    lldb::SBValue
-    EvaluateExpression(const char *expr,
-                       const SBExpressionOptions &options,
-                       const char *name) const;
-
-    STRING_EXTENSION(SBValue)
-
-#ifdef SWIGPYTHON
-    %pythoncode %{
-        def __get_dynamic__ (self):
-            '''Helper function for the "SBValue.dynamic" property.'''
-            return self.GetDynamicValue (eDynamicCanRunTarget)
-
-        class children_access(object):
-            '''A helper object that will lazily hand out thread for a process when supplied an index.'''
-
-            def __init__(self, sbvalue):
-                self.sbvalue = sbvalue
-
-            def __len__(self):
-                if self.sbvalue:
-                    return int(self.sbvalue.GetNumChildren())
-                return 0
-
-            def __getitem__(self, key):
-                if isinstance(key, int):
-                    count = len(self)
-                    if -count <= key < count:
-                        key %= count
-                        return self.sbvalue.GetChildAtIndex(key)
-                return None
-
-        def get_child_access_object(self):
-            '''An accessor function that returns a children_access() object which allows lazy member variable access from a lldb.SBValue object.'''
-            return self.children_access (self)
-
-        def get_value_child_list(self):
-            '''An accessor function that returns a list() that contains all children in a lldb.SBValue object.'''
-            children = []
-            accessor = self.get_child_access_object()
-            for idx in range(len(accessor)):
-                children.append(accessor[idx])
-            return children
-
-        def __iter__(self):
-            '''Iterate over all child values of a lldb.SBValue object.'''
-            return lldb_iter(self, 'GetNumChildren', 'GetChildAtIndex')
-
-        def __len__(self):
-            '''Return the number of child values of a lldb.SBValue object.'''
-            return self.GetNumChildren()
-
-        children = property(get_value_child_list, None, doc='''A read only property that returns a list() of lldb.SBValue objects for the children of the value.''')
-        child = property(get_child_access_object, None, doc='''A read only property that returns an object that can access children of a variable by index (child_value = value.children[12]).''')
-        name = property(GetName, None, doc='''A read only property that returns the name of this value as a string.''')
-        type = property(GetType, None, doc='''A read only property that returns a lldb.SBType object that represents the type for this value.''')
-        size = property(GetByteSize, None, doc='''A read only property that returns the size in bytes of this value.''')
-        is_in_scope = property(IsInScope, None, doc='''A read only property that returns a boolean value that indicates whether this value is currently lexically in scope.''')
-        format = property(GetName, SetFormat, doc='''A read/write property that gets/sets the format used for lldb.SBValue().GetValue() for this value. See enumerations that start with "lldb.eFormat".''')
-        value = property(GetValue, SetValueFromCString, doc='''A read/write property that gets/sets value from a string.''')
-        value_type = property(GetValueType, None, doc='''A read only property that returns an lldb enumeration value (see enumerations that start with "lldb.eValueType") that represents the type of this value (local, argument, global, register, etc.).''')
-        changed = property(GetValueDidChange, None, doc='''A read only property that returns a boolean value that indicates if this value has changed since it was last updated.''')
-        data = property(GetData, None, doc='''A read only property that returns an lldb object (lldb.SBData) that represents the bytes that make up the value for this object.''')
-        load_addr = property(GetLoadAddress, None, doc='''A read only property that returns the load address of this value as an integer.''')
-        addr = property(GetAddress, None, doc='''A read only property that returns an lldb.SBAddress that represents the address of this value if it is in memory.''')
-        deref = property(Dereference, None, doc='''A read only property that returns an lldb.SBValue that is created by dereferencing this value.''')
-        address_of = property(AddressOf, None, doc='''A read only property that returns an lldb.SBValue that represents the address-of this value.''')
-        error = property(GetError, None, doc='''A read only property that returns the lldb.SBError that represents the error from the last time the variable value was calculated.''')
-        summary = property(GetSummary, None, doc='''A read only property that returns the summary for this value as a string''')
-        description = property(GetObjectDescription, None, doc='''A read only property that returns the language-specific description of this value as a string''')
-        dynamic = property(__get_dynamic__, None, doc='''A read only property that returns an lldb.SBValue that is created by finding the dynamic type of this value.''')
-        location = property(GetLocation, None, doc='''A read only property that returns the location of this value as a string.''')
-        target = property(GetTarget, None, doc='''A read only property that returns the lldb.SBTarget that this value is associated with.''')
-        process = property(GetProcess, None, doc='''A read only property that returns the lldb.SBProcess that this value is associated with, the returned value might be invalid and should be tested.''')
-        thread = property(GetThread, None, doc='''A read only property that returns the lldb.SBThread that this value is associated with, the returned value might be invalid and should be tested.''')
-        frame = property(GetFrame, None, doc='''A read only property that returns the lldb.SBFrame that this value is associated with, the returned value might be invalid and should be tested.''')
-        num_children = property(GetNumChildren, None, doc='''A read only property that returns the number of child lldb.SBValues that this value has.''')
-        unsigned = property(GetValueAsUnsigned, None, doc='''A read only property that returns the value of this SBValue as an usigned integer.''')
-        signed = property(GetValueAsSigned, None, doc='''A read only property that returns the value of this SBValue as a signed integer.''')
-
-        def get_expr_path(self):
-            s = SBStream()
-            self.GetExpressionPath (s)
-            return s.GetData()
-
-        path = property(get_expr_path, None, doc='''A read only property that returns the expression path that one can use to reach this value in an expression.''')
-
-        def synthetic_child_from_expression(self, name, expr, options=None):
-            if options is None: options = lldb.SBExpressionOptions()
-            child = self.CreateValueFromExpression(name, expr, options)
-            child.SetSyntheticChildrenGenerated(True)
-            return child
-
-        def synthetic_child_from_data(self, name, data, type):
-            child = self.CreateValueFromData(name, data, type)
-            child.SetSyntheticChildrenGenerated(True)
-            return child
-
-        def synthetic_child_from_address(self, name, addr, type):
-            child = self.CreateValueFromAddress(name, addr, type)
-            child.SetSyntheticChildrenGenerated(True)
-            return child
-
-        def __eol_test(val):
-            """Default function for end of list test takes an SBValue object.
-
-            Return True if val is invalid or it corresponds to a null pointer.
-            Otherwise, return False.
-            """
-            if not val or val.GetValueAsUnsigned() == 0:
-                return True
-            else:
-                return False
-
-        # ==================================================
-        # Iterator for lldb.SBValue treated as a linked list
-        # ==================================================
-        def linked_list_iter(self, next_item_name, end_of_list_test=__eol_test):
-            """Generator adaptor to support iteration for SBValue as a linked list.
-
-            linked_list_iter() is a special purpose iterator to treat the SBValue as
-            the head of a list data structure, where you specify the child member
-            name which points to the next item on the list and you specify the
-            end-of-list test function which takes an SBValue for an item and returns
-            True if EOL is reached and False if not.
-
-            linked_list_iter() also detects infinite loop and bails out early.
-
-            The end_of_list_test arg, if omitted, defaults to the __eol_test
-            function above.
-
-            For example,
-
-            # Get Frame #0.
-            ...
-
-            # Get variable 'task_head'.
-            task_head = frame0.FindVariable('task_head')
-            ...
-
-            for t in task_head.linked_list_iter('next'):
-                print t
-            """
-            if end_of_list_test(self):
-                return
-            item = self
-            visited = set()
-            try:
-                while not end_of_list_test(item) and not item.GetValueAsUnsigned() in visited:
-                    visited.add(item.GetValueAsUnsigned())
-                    yield item
-                    # Prepare for the next iteration.
-                    item = item.GetChildMemberWithName(next_item_name)
-            except:
-                # Exception occurred.  Stop the generator.
-                pass
-
-            return
-    %}
-#endif
-
-};
-
-} // namespace lldb

lldb/bindings/interface/SBValueDocstrings.i

+%feature("docstring",
+"Represents the value of a variable, a register, or an expression.
+
+SBValue supports iteration through its child, which in turn is represented
+as an SBValue.  For example, we can get the general purpose registers of a
+frame as an SBValue, and iterate through all the registers,::
+
+    registerSet = frame.registers # Returns an SBValueList.
+    for regs in registerSet:
+        if 'general purpose registers' in regs.name.lower():
+            GPRs = regs
+            break
+
+    print('%s (number of children = %d):' % (GPRs.name, GPRs.num_children))
+    for reg in GPRs:
+        print('Name: ', reg.name, ' Value: ', reg.value)
+
+produces the output: ::
+
+    General Purpose Registers (number of children = 21):
+    Name:  rax  Value:  0x0000000100000c5c
+    Name:  rbx  Value:  0x0000000000000000
+    Name:  rcx  Value:  0x00007fff5fbffec0
+    Name:  rdx  Value:  0x00007fff5fbffeb8
+    Name:  rdi  Value:  0x0000000000000001
+    Name:  rsi  Value:  0x00007fff5fbffea8
+    Name:  rbp  Value:  0x00007fff5fbffe80
+    Name:  rsp  Value:  0x00007fff5fbffe60
+    Name:  r8  Value:  0x0000000008668682
+    Name:  r9  Value:  0x0000000000000000
+    Name:  r10  Value:  0x0000000000001200
+    Name:  r11  Value:  0x0000000000000206
+    Name:  r12  Value:  0x0000000000000000
+    Name:  r13  Value:  0x0000000000000000
+    Name:  r14  Value:  0x0000000000000000
+    Name:  r15  Value:  0x0000000000000000
+    Name:  rip  Value:  0x0000000100000dae
+    Name:  rflags  Value:  0x0000000000000206
+    Name:  cs  Value:  0x0000000000000027
+    Name:  fs  Value:  0x0000000000000010
+    Name:  gs  Value:  0x0000000000000048
+
+See also linked_list_iter() for another perspective on how to iterate through an
+SBValue instance which interprets the value object as representing the head of a
+linked list."
+) lldb::SBValue;
+
+%feature("docstring", "
+    Get a child value by index from a value.
+
+    Structs, unions, classes, arrays and pointers have child
+    values that can be access by index.
+
+    Structs and unions access child members using a zero based index
+    for each child member. For
+
+    Classes reserve the first indexes for base classes that have
+    members (empty base classes are omitted), and all members of the
+    current class will then follow the base classes.
+
+    Pointers differ depending on what they point to. If the pointer
+    points to a simple type, the child at index zero
+    is the only child value available, unless synthetic_allowed
+    is true, in which case the pointer will be used as an array
+    and can create 'synthetic' child values using positive or
+    negative indexes. If the pointer points to an aggregate type
+    (an array, class, union, struct), then the pointee is
+    transparently skipped and any children are going to be the indexes
+    of the child values within the aggregate type. For example if
+    we have a 'Point' type and we have a SBValue that contains a
+    pointer to a 'Point' type, then the child at index zero will be
+    the 'x' member, and the child at index 1 will be the 'y' member
+    (the child at index zero won't be a 'Point' instance).
+
+    If you actually need an SBValue that represents the type pointed
+    to by a SBValue for which GetType().IsPointeeType() returns true,
+    regardless of the pointee type, you can do that with the SBValue.Dereference
+    method (or the equivalent deref property).
+
+    Arrays have a preset number of children that can be accessed by
+    index and will returns invalid child values for indexes that are
+    out of bounds unless the synthetic_allowed is true. In this
+    case the array can create 'synthetic' child values for indexes
+    that aren't in the array bounds using positive or negative
+    indexes.
+
+    @param[in] idx
+        The index of the child value to get
+
+    @param[in] use_dynamic
+        An enumeration that specifies whether to get dynamic values,
+        and also if the target can be run to figure out the dynamic
+        type of the child value.
+
+    @param[in] synthetic_allowed
+        If true, then allow child values to be created by index
+        for pointers and arrays for indexes that normally wouldn't
+        be allowed.
+
+    @return
+        A new SBValue object that represents the child member value."
+) lldb::SBValue::GetChildAtIndex;
+
+%feature("docstring", "
+    Returns the child member index.
+
+    Matches children of this object only and will match base classes and
+    member names if this is a clang typed object.
+
+    @param[in] name
+        The name of the child value to get
+
+    @return
+        An index to the child member value."
+) lldb::SBValue::GetIndexOfChildWithName;
+
+%feature("docstring", "
+    Returns the child member value.
+
+    Matches child members of this object and child members of any base
+    classes.
+
+    @param[in] name
+        The name of the child value to get
+
+    @param[in] use_dynamic
+        An enumeration that specifies whether to get dynamic values,
+        and also if the target can be run to figure out the dynamic
+        type of the child value.
+
+    @return
+        A new SBValue object that represents the child member value."
+) lldb::SBValue::GetChildMemberWithName;
+
+%feature("docstring", "Expands nested expressions like .a->b[0].c[1]->d."
+) lldb::SBValue::GetValueForExpressionPath;
+
+%feature("doctstring", "
+    Returns the number for children.
+
+    @param[in] max
+        If max is less the lldb.UINT32_MAX, then the returned value is
+        capped to max.
+
+    @return
+        An integer value capped to the argument max."
+) lldb::SBValue::GetNumChildren;
+
+%feature("docstring", "
+    Find and watch a variable.
+    It returns an SBWatchpoint, which may be invalid."
+) lldb::SBValue::Watch;
+
+%feature("docstring", "
+    Find and watch the location pointed to by a variable.
+    It returns an SBWatchpoint, which may be invalid."
+) lldb::SBValue::WatchPointee;
+
+%feature("docstring", "
+    Get an SBData wrapping what this SBValue points to.
+
+    This method will dereference the current SBValue, if its
+    data type is a ``T\*`` or ``T[]``, and extract ``item_count`` elements
+    of type ``T`` from it, copying their contents in an :py:class:`SBData`.
+
+    :param item_idx: The index of the first item to retrieve. For an array
+        this is equivalent to array[item_idx], for a pointer
+        to ``\*(pointer + item_idx)``. In either case, the measurement
+        unit for item_idx is the ``sizeof(T)`` rather than the byte
+    :param item_count: How many items should be copied into the output. By default
+        only one item is copied, but more can be asked for.
+    :return: The contents of the copied items on success. An empty :py:class:`SBData` otherwise.
+    :rtype: SBData
+    "
+) lldb::SBValue::GetPointeeData;
+
+%feature("docstring", "
+    Get an SBData wrapping the contents of this SBValue.
+
+    This method will read the contents of this object in memory
+    and copy them into an SBData for future use.
+
+    @return
+        An SBData with the contents of this SBValue, on success.
+        An empty SBData otherwise."
+) lldb::SBValue::GetData;
+
+%feature("docstring", "Returns an expression path for this value."
+) lldb::SBValue::GetExpressionPath;

lldb/bindings/interface/SBValueExtensions.i

+STRING_EXTENSION_OUTSIDE(SBValue)
+%extend lldb::SBValue {
+#ifdef SWIGPYTHON
+    %pythoncode %{
+        def __get_dynamic__ (self):
+            '''Helper function for the "SBValue.dynamic" property.'''
+            return self.GetDynamicValue (eDynamicCanRunTarget)
+
+        class children_access(object):
+            '''A helper object that will lazily hand out thread for a process when supplied an index.'''
+
+            def __init__(self, sbvalue):
+                self.sbvalue = sbvalue
+
+            def __len__(self):
+                if self.sbvalue:
+                    return int(self.sbvalue.GetNumChildren())
+                return 0
+
+            def __getitem__(self, key):
+                if isinstance(key, int):
+                    count = len(self)
+                    if -count <= key < count:
+                        key %= count
+                        return self.sbvalue.GetChildAtIndex(key)
+                return None
+
+        def get_child_access_object(self):
+            '''An accessor function that returns a children_access() object which allows lazy member variable access from a lldb.SBValue object.'''
+            return self.children_access (self)
+
+        def get_value_child_list(self):
+            '''An accessor function that returns a list() that contains all children in a lldb.SBValue object.'''
+            children = []
+            accessor = self.get_child_access_object()
+            for idx in range(len(accessor)):
+                children.append(accessor[idx])
+            return children
+
+        def __iter__(self):
+            '''Iterate over all child values of a lldb.SBValue object.'''
+            return lldb_iter(self, 'GetNumChildren', 'GetChildAtIndex')
+
+        def __len__(self):
+            '''Return the number of child values of a lldb.SBValue object.'''
+            return self.GetNumChildren()
+
+        children = property(get_value_child_list, None, doc='''A read only property that returns a list() of lldb.SBValue objects for the children of the value.''')
+        child = property(get_child_access_object, None, doc='''A read only property that returns an object that can access children of a variable by index (child_value = value.children[12]).''')
+        name = property(GetName, None, doc='''A read only property that returns the name of this value as a string.''')
+        type = property(GetType, None, doc='''A read only property that returns a lldb.SBType object that represents the type for this value.''')
+        size = property(GetByteSize, None, doc='''A read only property that returns the size in bytes of this value.''')
+        is_in_scope = property(IsInScope, None, doc='''A read only property that returns a boolean value that indicates whether this value is currently lexically in scope.''')
+        format = property(GetName, SetFormat, doc='''A read/write property that gets/sets the format used for lldb.SBValue().GetValue() for this value. See enumerations that start with "lldb.eFormat".''')
+        value = property(GetValue, SetValueFromCString, doc='''A read/write property that gets/sets value from a string.''')
+        value_type = property(GetValueType, None, doc='''A read only property that returns an lldb enumeration value (see enumerations that start with "lldb.eValueType") that represents the type of this value (local, argument, global, register, etc.).''')
+        changed = property(GetValueDidChange, None, doc='''A read only property that returns a boolean value that indicates if this value has changed since it was last updated.''')
+        data = property(GetData, None, doc='''A read only property that returns an lldb object (lldb.SBData) that represents the bytes that make up the value for this object.''')
+        load_addr = property(GetLoadAddress, None, doc='''A read only property that returns the load address of this value as an integer.''')
+        addr = property(GetAddress, None, doc='''A read only property that returns an lldb.SBAddress that represents the address of this value if it is in memory.''')
+        deref = property(Dereference, None, doc='''A read only property that returns an lldb.SBValue that is created by dereferencing this value.''')
+        address_of = property(AddressOf, None, doc='''A read only property that returns an lldb.SBValue that represents the address-of this value.''')
+        error = property(GetError, None, doc='''A read only property that returns the lldb.SBError that represents the error from the last time the variable value was calculated.''')
+        summary = property(GetSummary, None, doc='''A read only property that returns the summary for this value as a string''')
+        description = property(GetObjectDescription, None, doc='''A read only property that returns the language-specific description of this value as a string''')
+        dynamic = property(__get_dynamic__, None, doc='''A read only property that returns an lldb.SBValue that is created by finding the dynamic type of this value.''')
+        location = property(GetLocation, None, doc='''A read only property that returns the location of this value as a string.''')
+        target = property(GetTarget, None, doc='''A read only property that returns the lldb.SBTarget that this value is associated with.''')
+        process = property(GetProcess, None, doc='''A read only property that returns the lldb.SBProcess that this value is associated with, the returned value might be invalid and should be tested.''')
+        thread = property(GetThread, None, doc='''A read only property that returns the lldb.SBThread that this value is associated with, the returned value might be invalid and should be tested.''')
+        frame = property(GetFrame, None, doc='''A read only property that returns the lldb.SBFrame that this value is associated with, the returned value might be invalid and should be tested.''')
+        num_children = property(GetNumChildren, None, doc='''A read only property that returns the number of child lldb.SBValues that this value has.''')
+        unsigned = property(GetValueAsUnsigned, None, doc='''A read only property that returns the value of this SBValue as an usigned integer.''')
+        signed = property(GetValueAsSigned, None, doc='''A read only property that returns the value of this SBValue as a signed integer.''')
+
+        def get_expr_path(self):
+            s = SBStream()
+            self.GetExpressionPath (s)
+            return s.GetData()
+
+        path = property(get_expr_path, None, doc='''A read only property that returns the expression path that one can use to reach this value in an expression.''')
+
+        def synthetic_child_from_expression(self, name, expr, options=None):
+            if options is None: options = lldb.SBExpressionOptions()
+            child = self.CreateValueFromExpression(name, expr, options)
+            child.SetSyntheticChildrenGenerated(True)
+            return child
+
+        def synthetic_child_from_data(self, name, data, type):
+            child = self.CreateValueFromData(name, data, type)
+            child.SetSyntheticChildrenGenerated(True)
+            return child
+
+        def synthetic_child_from_address(self, name, addr, type):
+            child = self.CreateValueFromAddress(name, addr, type)
+            child.SetSyntheticChildrenGenerated(True)
+            return child
+
+        def __eol_test(val):
+            """Default function for end of list test takes an SBValue object.
+
+            Return True if val is invalid or it corresponds to a null pointer.
+            Otherwise, return False.
+            """
+            if not val or val.GetValueAsUnsigned() == 0:
+                return True
+            else:
+                return False
+
+        # ==================================================
+        # Iterator for lldb.SBValue treated as a linked list
+        # ==================================================
+        def linked_list_iter(self, next_item_name, end_of_list_test=__eol_test):
+            """Generator adaptor to support iteration for SBValue as a linked list.
+
+            linked_list_iter() is a special purpose iterator to treat the SBValue as
+            the head of a list data structure, where you specify the child member
+            name which points to the next item on the list and you specify the
+            end-of-list test function which takes an SBValue for an item and returns
+            True if EOL is reached and False if not.
+
+            linked_list_iter() also detects infinite loop and bails out early.
+
+            The end_of_list_test arg, if omitted, defaults to the __eol_test
+            function above.
+
+            For example,
+
+            # Get Frame #0.
+            ...
+
+            # Get variable 'task_head'.
+            task_head = frame0.FindVariable('task_head')
+            ...
+
+            for t in task_head.linked_list_iter('next'):
+                print t
+            """
+            if end_of_list_test(self):
+                return
+            item = self
+            visited = set()
+            try:
+                while not end_of_list_test(item) and not item.GetValueAsUnsigned() in visited:
+                    visited.add(item.GetValueAsUnsigned())
+                    yield item
+                    # Prepare for the next iteration.
+                    item = item.GetChildMemberWithName(next_item_name)
+            except:
+                # Exception occurred.  Stop the generator.
+                pass
+
+            return
+    %}
+#endif
+}

lldb/bindings/interface/SBValueList.i

-//===-- SWIG Interface for SBValueList --------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-%feature("docstring",
-"Represents a collection of SBValues.  Both :py:class:`SBFrame.GetVariables()` and
-:py:class:`SBFrame.GetRegisters()` return a SBValueList.
-
-SBValueList supports :py:class:`SBValue` iteration. For example (from test/lldbutil.py),::
-
-    def get_registers(frame, kind):
-        '''Returns the registers given the frame and the kind of registers desired.
-
-        Returns None if there's no such kind.
-        '''
-        registerSet = frame.GetRegisters() # Return type of SBValueList.
-        for value in registerSet:
-            if kind.lower() in value.GetName().lower():
-                return value
-
-        return None
-
-    def get_GPRs(frame):
-        '''Returns the general purpose registers of the frame as an SBValue.
-
-        The returned SBValue object is iterable.  An example:
-            ...
-            from lldbutil import get_GPRs
-            regs = get_GPRs(frame)
-            for reg in regs:
-                print('%s => %s' % (reg.GetName(), reg.GetValue()))
-            ...
-        '''
-        return get_registers(frame, 'general purpose')
-
-    def get_FPRs(frame):
-        '''Returns the floating point registers of the frame as an SBValue.
-
-        The returned SBValue object is iterable.  An example:
-            ...
-            from lldbutil import get_FPRs
-            regs = get_FPRs(frame)
-            for reg in regs:
-                print('%s => %s' % (reg.GetName(), reg.GetValue()))
-            ...
-        '''
-        return get_registers(frame, 'floating point')
-
-    def get_ESRs(frame):
-        '''Returns the exception state registers of the frame as an SBValue.
-
-        The returned SBValue object is iterable.  An example:
-            ...
-            from lldbutil import get_ESRs
-            regs = get_ESRs(frame)
-            for reg in regs:
-                print('%s => %s' % (reg.GetName(), reg.GetValue()))
-            ...
-        '''
-        return get_registers(frame, 'exception state')
-"
-) SBValueList;
-class SBValueList
-{
-public:
-
-    SBValueList ();
-
-    SBValueList (const lldb::SBValueList &rhs);
-
-    ~SBValueList();
-
-    bool
-    IsValid() const;
-
-    explicit operator bool() const;
-
-    void
-    Clear();
-
-    void
-    Append (const lldb::SBValue &val_obj);
-
-    void
-    Append (const lldb::SBValueList& value_list);
-
-    uint32_t
-    GetSize() const;
-
-    lldb::SBValue
-    GetValueAtIndex (uint32_t idx) const;
-
-    lldb::SBValue
-    FindValueObjectByUID (lldb::user_id_t uid);
-
-    lldb::SBValue
-    GetFirstValueByName (const char* name) const;
-
-    lldb::SBError GetError();
-
-    %extend {
-#ifdef SWIGPYTHON
-       %nothreadallow;
-#endif
-       std::string lldb::SBValueList::__str__ (){
-           lldb::SBStream description;
-           const size_t n = $self->GetSize();
-           if (n)
-           {
-               for (size_t i=0; i<n; ++i)
-                   $self->GetValueAtIndex(i).GetDescription(description);
-           }
-           else
-           {
-               description.Printf("<empty> lldb.SBValueList()");
-           }
-           const char *desc = description.GetData();
-           size_t desc_len = description.GetSize();
-           if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
-               --desc_len;
-           return std::string(desc, desc_len);
-       }
-#ifdef SWIGPYTHON
-       %clearnothreadallow;
-#endif
-    }
-
-#ifdef SWIGPYTHON
-    %pythoncode %{
-        def __iter__(self):
-            '''Iterate over all values in a lldb.SBValueList object.'''
-            return lldb_iter(self, 'GetSize', 'GetValueAtIndex')
-
-        def __len__(self):
-            return int(self.GetSize())
-
-        def __getitem__(self, key):
-            count = len(self)
-            #------------------------------------------------------------
-            # Access with "int" to get Nth item in the list
-            #------------------------------------------------------------
-            if type(key) is int:
-                if -count <= key < count:
-                    key %= count
-                    return self.GetValueAtIndex(key)
-            #------------------------------------------------------------
-            # Access with "str" to get values by name
-            #------------------------------------------------------------
-            elif type(key) is str:
-                matches = []
-                for idx in range(count):
-                    value = self.GetValueAtIndex(idx)
-                    if value.name == key:
-                        matches.append(value)
-                return matches
-            #------------------------------------------------------------
-            # Match with regex
-            #------------------------------------------------------------
-            elif isinstance(key, type(re.compile('.'))):
-                matches = []
-                for idx in range(count):
-                    value = self.GetValueAtIndex(idx)
-                    re_match = key.search(value.name)
-                    if re_match:
-                        matches.append(value)
-                return matches
-
-    %}
-#endif
-
-
-};
-
-} // namespace lldb

lldb/bindings/interface/SBValueListDocstrings.i

+%feature("docstring",
+"Represents a collection of SBValues.  Both :py:class:`SBFrame.GetVariables()` and
+:py:class:`SBFrame.GetRegisters()` return a SBValueList.
+
+SBValueList supports :py:class:`SBValue` iteration. For example (from test/lldbutil.py),::
+
+    def get_registers(frame, kind):
+        '''Returns the registers given the frame and the kind of registers desired.
+
+        Returns None if there's no such kind.
+        '''
+        registerSet = frame.GetRegisters() # Return type of SBValueList.
+        for value in registerSet:
+            if kind.lower() in value.GetName().lower():
+                return value
+
+        return None
+
+    def get_GPRs(frame):
+        '''Returns the general purpose registers of the frame as an SBValue.
+
+        The returned SBValue object is iterable.  An example:
+            ...
+            from lldbutil import get_GPRs
+            regs = get_GPRs(frame)
+            for reg in regs:
+                print('%s => %s' % (reg.GetName(), reg.GetValue()))
+            ...
+        '''
+        return get_registers(frame, 'general purpose')
+
+    def get_FPRs(frame):
+        '''Returns the floating point registers of the frame as an SBValue.
+
+        The returned SBValue object is iterable.  An example:
+            ...
+            from lldbutil import get_FPRs
+            regs = get_FPRs(frame)
+            for reg in regs:
+                print('%s => %s' % (reg.GetName(), reg.GetValue()))
+            ...
+        '''
+        return get_registers(frame, 'floating point')
+
+    def get_ESRs(frame):
+        '''Returns the exception state registers of the frame as an SBValue.
+
+        The returned SBValue object is iterable.  An example:
+            ...
+            from lldbutil import get_ESRs
+            regs = get_ESRs(frame)
+            for reg in regs:
+                print('%s => %s' % (reg.GetName(), reg.GetValue()))
+            ...
+        '''
+        return get_registers(frame, 'exception state')
+"
+) lldb::SBValueList;

lldb/bindings/interface/SBValueListExtensions.i

+%extend lldb::SBValueList {
+
+#ifdef SWIGPYTHON
+       %nothreadallow;
+#endif
+       std::string lldb::SBValueList::__str__ (){
+           lldb::SBStream description;
+           const size_t n = $self->GetSize();
+           if (n)
+           {
+               for (size_t i=0; i<n; ++i)
+                   $self->GetValueAtIndex(i).GetDescription(description);
+           }
+           else
+           {
+               description.Printf("<empty> lldb.SBValueList()");
+           }
+           const char *desc = description.GetData();
+           size_t desc_len = description.GetSize();
+           if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
+               --desc_len;
+           return std::string(desc, desc_len);
+       }
+#ifdef SWIGPYTHON
+       %clearnothreadallow;
+#endif
+
+#ifdef SWIGPYTHON
+    %pythoncode %{
+        def __iter__(self):
+            '''Iterate over all values in a lldb.SBValueList object.'''
+            return lldb_iter(self, 'GetSize', 'GetValueAtIndex')
+
+        def __len__(self):
+            return int(self.GetSize())
+
+        def __getitem__(self, key):
+            count = len(self)
+            #------------------------------------------------------------
+            # Access with "int" to get Nth item in the list
+            #------------------------------------------------------------
+            if type(key) is int:
+                if -count <= key < count:
+                    key %= count
+                    return self.GetValueAtIndex(key)
+            #------------------------------------------------------------
+            # Access with "str" to get values by name
+            #------------------------------------------------------------
+            elif type(key) is str:
+                matches = []
+                for idx in range(count):
+                    value = self.GetValueAtIndex(idx)
+                    if value.name == key:
+                        matches.append(value)
+                return matches
+            #------------------------------------------------------------
+            # Match with regex
+            #------------------------------------------------------------
+            elif isinstance(key, type(re.compile('.'))):
+                matches = []
+                for idx in range(count):
+                    value = self.GetValueAtIndex(idx)
+                    re_match = key.search(value.name)
+                    if re_match:
+                        matches.append(value)
+                return matches
+
+    %}
+#endif
+}

lldb/bindings/interface/SBVariablesOptions.i

-//===-- SWIG Interface for SBVariablesOptions ----------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-%feature("docstring",
-"Describes which variables should be returned from :py:class:`SBFrame.GetVariables`."
-) SBVariablesOptions;
-class SBVariablesOptions
-{
-public:
-    SBVariablesOptions ();
-
-    SBVariablesOptions (const SBVariablesOptions& options);
-
-    ~SBVariablesOptions ();
-
-    bool
-    IsValid () const;
-
-    explicit operator bool() const;
-
-    bool
-    GetIncludeArguments ()  const;
-
-    void
-    SetIncludeArguments (bool);
-
-    bool
-    GetIncludeRecognizedArguments (const lldb::SBTarget &)  const;
-
-    void
-    SetIncludeRecognizedArguments (bool);
-
-    bool
-    GetIncludeLocals ()  const;
-
-    void
-    SetIncludeLocals (bool);
-
-    bool
-    GetIncludeStatics ()  const;
-
-    void
-    SetIncludeStatics (bool);
-
-    bool
-    GetInScopeOnly ()  const;
-
-    void
-    SetInScopeOnly (bool);
-
-    bool
-    GetIncludeRuntimeSupportValues () const;
-
-    void
-    SetIncludeRuntimeSupportValues (bool);
-
-    lldb::DynamicValueType
-    GetUseDynamic () const;
-
-    void
-    SetUseDynamic (lldb::DynamicValueType);
-};
-
-} // namespace lldb

lldb/bindings/interface/SBVariablesOptionsDocstrings.i

+%feature("docstring",
+"Describes which variables should be returned from :py:class:`SBFrame.GetVariables`."
+) lldb::SBVariablesOptions;

lldb/bindings/interface/SBWatchpoint.i

-//===-- SWIG Interface for SBWatchpoint -----------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-%feature("docstring",
-"Represents an instance of watchpoint for a specific target program.
-
-A watchpoint is determined by the address and the byte size that resulted in
-this particular instantiation.  Each watchpoint has its settable options.
-
-See also :py:class:`SBTarget.watchpoint_iter()` for example usage of iterating through the
-watchpoints of the target."
-) SBWatchpoint;
-class SBWatchpoint
-{
-public:
-
-    SBWatchpoint ();
-
-    SBWatchpoint (const lldb::SBWatchpoint &rhs);
-
-    ~SBWatchpoint ();
-
-    bool
-    IsValid();
-
-    explicit operator bool() const;
-
-    bool operator==(const SBWatchpoint &rhs) const;
-
-    bool operator!=(const SBWatchpoint &rhs) const;
-
-    SBError
-    GetError();
-
-    watch_id_t
-    GetID ();
-
-    %feature("docstring", "
-    With -1 representing an invalid hardware index.") GetHardwareIndex;
-    int32_t
-    GetHardwareIndex ();
-
-    lldb::addr_t
-    GetWatchAddress ();
-
-    size_t
-    GetWatchSize();
-
-    void
-    SetEnabled(bool enabled);
-
-    bool
-    IsEnabled ();
-
-    uint32_t
-    GetHitCount ();
-
-    uint32_t
-    GetIgnoreCount ();
-
-    void
-    SetIgnoreCount (uint32_t n);
-
-    %feature("docstring", "
-    Get the condition expression for the watchpoint.") GetCondition;
-    const char *
-    GetCondition ();
-
-    %feature("docstring", "
-    The watchpoint stops only if the condition expression evaluates to true.") SetCondition;
-    void
-    SetCondition (const char *condition);
-
-    bool
-    GetDescription (lldb::SBStream &description, DescriptionLevel level);
-
-    static bool
-    EventIsWatchpointEvent (const lldb::SBEvent &event);
-
-    static lldb::WatchpointEventType
-    GetWatchpointEventTypeFromEvent (const lldb::SBEvent& event);
-
-    static lldb::SBWatchpoint
-    GetWatchpointFromEvent (const lldb::SBEvent& event);
-
-    STRING_EXTENSION_LEVEL(SBWatchpoint, lldb::eDescriptionLevelVerbose)
-};
-
-} // namespace lldb

lldb/bindings/interface/SBWatchpointDocstrings.i

+%feature("docstring",
+"Represents an instance of watchpoint for a specific target program.
+
+A watchpoint is determined by the address and the byte size that resulted in
+this particular instantiation.  Each watchpoint has its settable options.
+
+See also :py:class:`SBTarget.watchpoint_iter()` for example usage of iterating through the
+watchpoints of the target."
+) lldb::SBWatchpoint;
+
+%feature("docstring", "
+    With -1 representing an invalid hardware index."
+) lldb::SBWatchpoint::GetHardwareIndex;
+
+%feature("docstring", "
+    Get the condition expression for the watchpoint."
+) lldb::SBWatchpoint::GetCondition;
+
+%feature("docstring", "
+    The watchpoint stops only if the condition expression evaluates to true."
+) lldb::SBWatchpoint::SetCondition;

lldb/bindings/interface/SBWatchpointExtensions.i

+STRING_EXTENSION_LEVEL_OUTSIDE(SBWatchpoint, lldb::eDescriptionLevelVerbose)

lldb/bindings/interfaces.swig

 /* Various liblldb typedefs that SWIG needs to know about.  */
 #define __extension__ /* Undefine GCC keyword to make Swig happy when processing glibc's stdint.h. */
 %include "stdint.i"
 
 %include "lldb/lldb-defines.h"
 %include "lldb/lldb-enumerations.h"
 %include "lldb/lldb-forward.h"
 %include "lldb/lldb-types.h"
 
 /* Forward declaration of SB classes. */
 %include "lldb/API/SBDefines.h"
 
-/* Python interface files with docstrings. */
-%include "./interface/SBAddress.i"
-%include "./interface/SBAttachInfo.i"
-%include "./interface/SBBlock.i"
-%include "./interface/SBBreakpoint.i"
-%include "./interface/SBBreakpointLocation.i"
-%include "./interface/SBBreakpointName.i"
-%include "./interface/SBBroadcaster.i"
-%include "./interface/SBCommandInterpreter.i"
-%include "./interface/SBCommandInterpreterRunOptions.i"
-%include "./interface/SBCommandReturnObject.i"
-%include "./interface/SBCommunication.i"
-%include "./interface/SBCompileUnit.i"
-%include "./interface/SBData.i"
-%include "./interface/SBDebugger.i"
-%include "./interface/SBDeclaration.i"
-%include "./interface/SBError.i"
-%include "./interface/SBEnvironment.i"
-%include "./interface/SBEvent.i"
-%include "./interface/SBExecutionContext.i"
-%include "./interface/SBExpressionOptions.i"
-%include "./interface/SBFile.i"
-%include "./interface/SBFileSpec.i"
-%include "./interface/SBFileSpecList.i"
-%include "./interface/SBFrame.i"
-%include "./interface/SBFunction.i"
-%include "./interface/SBHostOS.i"
-%include "./interface/SBInstruction.i"
-%include "./interface/SBInstructionList.i"
-%include "./interface/SBLanguageRuntime.i"
-%include "./interface/SBLaunchInfo.i"
-%include "./interface/SBLineEntry.i"
-%include "./interface/SBListener.i"
-%include "./interface/SBMemoryRegionInfo.i"
-%include "./interface/SBMemoryRegionInfoList.i"
-%include "./interface/SBModule.i"
-%include "./interface/SBModuleSpec.i"
-%include "./interface/SBPlatform.i"
-%include "./interface/SBProcess.i"
-%include "./interface/SBProcessInfo.i"
-%include "./interface/SBQueue.i"
-%include "./interface/SBQueueItem.i"
-%include "./interface/SBReproducer.i"
-%include "./interface/SBSection.i"
-%include "./interface/SBSourceManager.i"
-%include "./interface/SBStream.i"
-%include "./interface/SBStringList.i"
-%include "./interface/SBStructuredData.i"
-%include "./interface/SBSymbol.i"
-%include "./interface/SBSymbolContext.i"
-%include "./interface/SBSymbolContextList.i"
-%include "./interface/SBTarget.i"
-%include "./interface/SBThread.i"
-%include "./interface/SBThreadCollection.i"
-%include "./interface/SBThreadPlan.i"
-%include "./interface/SBTrace.i"
-%include "./interface/SBTraceCursor.i"
-%include "./interface/SBType.i"
-%include "./interface/SBTypeCategory.i"
-%include "./interface/SBTypeEnumMember.i"
-%include "./interface/SBTypeFilter.i"
-%include "./interface/SBTypeFormat.i"
-%include "./interface/SBTypeNameSpecifier.i"
-%include "./interface/SBTypeSummary.i"
-%include "./interface/SBTypeSynthetic.i"
-%include "./interface/SBUnixSignals.i"
-%include "./interface/SBValue.i"
-%include "./interface/SBValueList.i"
-%include "./interface/SBVariablesOptions.i"
-%include "./interface/SBWatchpoint.i"
+/* Docstrings for SB classes and methods */
+%include "./interface/SBAddressDocstrings.i"
+%include "./interface/SBAttachInfoDocstrings.i"
+%include "./interface/SBBlockDocstrings.i"
+%include "./interface/SBBreakpointDocstrings.i"
+%include "./interface/SBBreakpointLocationDocstrings.i"
+%include "./interface/SBBreakpointNameDocstrings.i"
+%include "./interface/SBBroadcasterDocstrings.i"
+%include "./interface/SBCommandInterpreterDocstrings.i"
+%include "./interface/SBCommandInterpreterRunOptionsDocstrings.i"
+%include "./interface/SBCommandReturnObjectDocstrings.i"
+%include "./interface/SBCommunicationDocstrings.i"
+%include "./interface/SBCompileUnitDocstrings.i"
+%include "./interface/SBDataDocstrings.i"
+%include "./interface/SBDebuggerDocstrings.i"
+%include "./interface/SBDeclarationDocstrings.i"
+%include "./interface/SBErrorDocstrings.i"
+%include "./interface/SBEnvironmentDocstrings.i"
+%include "./interface/SBEventDocstrings.i"
+%include "./interface/SBExecutionContextDocstrings.i"
+%include "./interface/SBExpressionOptionsDocstrings.i"
+%include "./interface/SBFileDocstrings.i"
+%include "./interface/SBFileSpecDocstrings.i"
+%include "./interface/SBFileSpecListDocstrings.i"
+%include "./interface/SBFrameDocstrings.i"
+%include "./interface/SBFunctionDocstrings.i"
+%include "./interface/SBHostOSDocstrings.i"
+%include "./interface/SBInstructionDocstrings.i"
+%include "./interface/SBInstructionListDocstrings.i"
+%include "./interface/SBLanguageRuntimeDocstrings.i"
+%include "./interface/SBLaunchInfoDocstrings.i"
+%include "./interface/SBLineEntryDocstrings.i"
+%include "./interface/SBListenerDocstrings.i"
+%include "./interface/SBMemoryRegionInfoDocstrings.i"
+%include "./interface/SBMemoryRegionInfoListDocstrings.i"
+%include "./interface/SBModuleDocstrings.i"
+%include "./interface/SBModuleSpecDocstrings.i"
+%include "./interface/SBPlatformDocstrings.i"
+%include "./interface/SBProcessDocstrings.i"
+%include "./interface/SBProcessInfoDocstrings.i"
+%include "./interface/SBQueueDocstrings.i"
+%include "./interface/SBQueueItemDocstrings.i"
+%include "./interface/SBReproducerDocstrings.i"
+%include "./interface/SBSectionDocstrings.i"
+%include "./interface/SBSourceManagerDocstrings.i"
+%include "./interface/SBStreamDocstrings.i"
+%include "./interface/SBStringListDocstrings.i"
+%include "./interface/SBStructuredDataDocstrings.i"
+%include "./interface/SBSymbolDocstrings.i"
+%include "./interface/SBSymbolContextDocstrings.i"
+%include "./interface/SBSymbolContextListDocstrings.i"
+%include "./interface/SBTargetDocstrings.i"
+%include "./interface/SBThreadDocstrings.i"
+%include "./interface/SBThreadCollectionDocstrings.i"
+%include "./interface/SBThreadPlanDocstrings.i"
+%include "./interface/SBTraceDocstrings.i"
+%include "./interface/SBTraceCursorDocstrings.i"
+%include "./interface/SBTypeDocstrings.i"
+%include "./interface/SBTypeCategoryDocstrings.i"
+%include "./interface/SBTypeEnumMemberDocstrings.i"
+%include "./interface/SBTypeFilterDocstrings.i"
+%include "./interface/SBTypeFormatDocstrings.i"
+%include "./interface/SBTypeNameSpecifierDocstrings.i"
+%include "./interface/SBTypeSummaryDocstrings.i"
+%include "./interface/SBTypeSyntheticDocstrings.i"
+%include "./interface/SBUnixSignalsDocstrings.i"
+%include "./interface/SBValueDocstrings.i"
+%include "./interface/SBValueListDocstrings.i"
+%include "./interface/SBVariablesOptionsDocstrings.i"
+%include "./interface/SBWatchpointDocstrings.i"
+
+/* API headers */
+%include "lldb/API/SBAddress.h"
+%include "lldb/API/SBAttachInfo.h"
+%include "lldb/API/SBBlock.h"
+%include "lldb/API/SBBreakpoint.h"
+%include "lldb/API/SBBreakpointLocation.h"
+%include "lldb/API/SBBreakpointName.h"
+%include "lldb/API/SBBroadcaster.h"
+%include "lldb/API/SBCommandInterpreter.h"
+%include "lldb/API/SBCommandInterpreterRunOptions.h"
+%include "lldb/API/SBCommandReturnObject.h"
+%include "lldb/API/SBCommunication.h"
+%include "lldb/API/SBCompileUnit.h"
+%include "lldb/API/SBData.h"
+%include "lldb/API/SBDebugger.h"
+%include "lldb/API/SBDeclaration.h"
+%include "lldb/API/SBError.h"
+%include "lldb/API/SBEnvironment.h"
+%include "lldb/API/SBEvent.h"
+%include "lldb/API/SBExecutionContext.h"
+%include "lldb/API/SBExpressionOptions.h"
+%include "lldb/API/SBFile.h"
+%include "lldb/API/SBFileSpec.h"
+%include "lldb/API/SBFileSpecList.h"
+%include "lldb/API/SBFrame.h"
+%include "lldb/API/SBFunction.h"
+%include "lldb/API/SBHostOS.h"
+%include "lldb/API/SBInstruction.h"
+%include "lldb/API/SBInstructionList.h"
+%include "lldb/API/SBLanguageRuntime.h"
+%include "lldb/API/SBLaunchInfo.h"
+%include "lldb/API/SBLineEntry.h"
+%include "lldb/API/SBListener.h"
+%include "lldb/API/SBMemoryRegionInfo.h"
+%include "lldb/API/SBMemoryRegionInfoList.h"
+%include "lldb/API/SBModule.h"
+%include "lldb/API/SBModuleSpec.h"
+%include "lldb/API/SBPlatform.h"
+%include "lldb/API/SBProcess.h"
+%include "lldb/API/SBProcessInfo.h"
+%include "lldb/API/SBQueue.h"
+%include "lldb/API/SBQueueItem.h"
+%include "lldb/API/SBReproducer.h"
+%include "lldb/API/SBSection.h"
+%include "lldb/API/SBSourceManager.h"
+%include "lldb/API/SBStream.h"
+%include "lldb/API/SBStringList.h"
+%include "lldb/API/SBStructuredData.h"
+%include "lldb/API/SBSymbol.h"
+%include "lldb/API/SBSymbolContext.h"
+%include "lldb/API/SBSymbolContextList.h"
+%include "lldb/API/SBTarget.h"
+%include "lldb/API/SBThread.h"
+%include "lldb/API/SBThreadCollection.h"
+%include "lldb/API/SBThreadPlan.h"
+%include "lldb/API/SBTrace.h"
+%include "lldb/API/SBTraceCursor.h"
+%include "lldb/API/SBType.h"
+%include "lldb/API/SBTypeCategory.h"
+%include "lldb/API/SBTypeEnumMember.h"
+%include "lldb/API/SBTypeFilter.h"
+%include "lldb/API/SBTypeFormat.h"
+%include "lldb/API/SBTypeNameSpecifier.h"
+%include "lldb/API/SBTypeSummary.h"
+%include "lldb/API/SBTypeSynthetic.h"
+%include "lldb/API/SBUnixSignals.h"
+%include "lldb/API/SBValue.h"
+%include "lldb/API/SBValueList.h"
+%include "lldb/API/SBVariablesOptions.h"
+%include "lldb/API/SBWatchpoint.h"
+
+/* Extensions for SB classes */
+%include "./interface/SBAddressExtensions.i"
+%include "./interface/SBBlockExtensions.i"
+%include "./interface/SBBreakpointExtensions.i"
+%include "./interface/SBBreakpointLocationExtensions.i"
+%include "./interface/SBBreakpointNameExtensions.i"
+%include "./interface/SBCommandReturnObjectExtensions.i"
+%include "./interface/SBCompileUnitExtensions.i"
+%include "./interface/SBDataExtensions.i"
+%include "./interface/SBDebuggerExtensions.i"
+%include "./interface/SBDeclarationExtensions.i"
+%include "./interface/SBErrorExtensions.i"
+%include "./interface/SBExecutionContextExtensions.i"
+%include "./interface/SBFileExtensions.i"
+%include "./interface/SBFileSpecExtensions.i"
+%include "./interface/SBFrameExtensions.i"
+%include "./interface/SBFunctionExtensions.i"
+%include "./interface/SBInstructionExtensions.i"
+%include "./interface/SBInstructionListExtensions.i"
+%include "./interface/SBLineEntryExtensions.i"
+%include "./interface/SBMemoryRegionInfoExtensions.i"
+%include "./interface/SBModuleExtensions.i"
+%include "./interface/SBModuleSpecExtensions.i"
+%include "./interface/SBProcessExtensions.i"
+%include "./interface/SBSectionExtensions.i"
+%include "./interface/SBStreamExtensions.i"
+%include "./interface/SBStringListExtensions.i"
+%include "./interface/SBSymbolExtensions.i"
+%include "./interface/SBSymbolContextExtensions.i"
+%include "./interface/SBSymbolContextListExtensions.i"
+%include "./interface/SBTargetExtensions.i"
+%include "./interface/SBThreadExtensions.i"
+%include "./interface/SBTypeExtensions.i"
+%include "./interface/SBTypeCategoryExtensions.i"
+%include "./interface/SBTypeEnumMemberExtensions.i"
+%include "./interface/SBTypeFilterExtensions.i"
+%include "./interface/SBTypeFormatExtensions.i"
+%include "./interface/SBTypeNameSpecifierExtensions.i"
+%include "./interface/SBTypeSummaryExtensions.i"
+%include "./interface/SBTypeSyntheticExtensions.i"
+%include "./interface/SBUnixSignalsExtensions.i"
+%include "./interface/SBValueExtensions.i"
+%include "./interface/SBValueListExtensions.i"
+%include "./interface/SBWatchpointExtensions.i"

lldb/bindings/macros.swig

 %define STRING_EXTENSION_LEVEL(Class, Level)
 %extend {
   std::string lldb:: ## Class ## ::__repr__(){
     lldb::SBStream stream;
     $self->GetDescription (stream, Level);
     const char *desc = stream.GetData();
     size_t desc_len = stream.GetSize();
     if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
       --desc_len;
     }
     return std::string(desc, desc_len);
   }
 }
 %enddef
 
+%define STRING_EXTENSION_LEVEL_OUTSIDE(Class, Level)
+%extend lldb:: ## Class ## {
+  std::string __repr__(){
+    lldb::SBStream stream;
+    $self->GetDescription (stream, Level);
+    const char *desc = stream.GetData();
+    size_t desc_len = stream.GetSize();
+    if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
+      --desc_len;
+    }
+    return std::string(desc, desc_len);
+  }
+}
+%enddef
+
 %define STRING_EXTENSION(Class)
 %extend {
   std::string lldb:: ## Class ## ::__repr__(){
     lldb::SBStream stream;
     $self->GetDescription (stream);
     const char *desc = stream.GetData();
     size_t desc_len = stream.GetSize();
     if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
       --desc_len;
     }
     return std::string(desc, desc_len);
   }
 }
 %enddef
+
+// NOTE:
+// This is for when you are peforming the extension from outside of the class
+// instead of inside of it. If this change works out, it will replace
+// STRING_EXTENSION entirely.
+%define STRING_EXTENSION_OUTSIDE(Class)
+%extend lldb:: ## Class ## {
+  std::string __repr__(){
+    lldb::SBStream stream;
+    $self->GetDescription (stream);
+    const char *desc = stream.GetData();
+    size_t desc_len = stream.GetSize();
+    if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
+      --desc_len;
+    }
+    return std::string(desc, desc_len);
+  }
+}
+%enddef

lldb/bindings/python/python-typemaps.swig

%typemap(in) (TYPEMAP, SIZE) (Py_buffer_RAII view) {
   buf = view.buffer.buf;
   $1 = ($1_ltype)buf;
   $2 = ($2_ltype)(size / sizeof($*1_type));
 }
 %enddef
 
 %pybuffer_binary(const uint8_t *buf, size_t num_bytes);
 %pybuffer_mutable_binary(uint8_t *buf, size_t num_bytes);
+
+%typemap(in) (const char **symbol_name, uint32_t num_names) {
+  using namespace lldb_private;
+  /* Check if is a list  */
+  if (PythonList::Check($input)) {
+    PythonList list(PyRefType::Borrowed, $input);
+    $2 = list.GetSize();
+    int i = 0;
+    $1 = (char**)malloc(($2+1)*sizeof(char*));
+    for (i = 0; i < $2; i++) {
+      PythonString py_str = list.GetItemAtIndex(i).AsType<PythonString>();
+      if (!py_str.IsAllocated()) {
+        PyErr_SetString(PyExc_TypeError,"list must contain strings and blubby");
+        free($1);
+        return nullptr;
+      }
+
+      $1[i] = const_cast<char*>(py_str.GetString().data());
+    }
+    $1[i] = 0;
+  } else if ($input == Py_None) {
+    $1 =  NULL;
+  } else {
+    PyErr_SetString(PyExc_TypeError,"not a list");
+    return NULL;
+  }
+}

lldb/cmake/modules/LLDBFramework.cmake

 
 # At configuration time, collect headers for the framework bundle and copy them
 # into a staging directory. Later we can copy over the entire folder.
 file(GLOB public_headers ${LLDB_SOURCE_DIR}/include/lldb/API/*.h)
 file(GLOB root_public_headers ${LLDB_SOURCE_DIR}/include/lldb/lldb-*.h)
 file(GLOB root_private_headers ${LLDB_SOURCE_DIR}/include/lldb/lldb-private*.h)
 list(REMOVE_ITEM root_public_headers ${root_private_headers})
 
+find_program(unifdef_EXECUTABLE unifdef)
+
 set(lldb_header_staging ${CMAKE_CURRENT_BINARY_DIR}/FrameworkHeaders)
 foreach(header
     ${public_headers}
     ${root_public_headers})
 
   get_filename_component(basename ${header} NAME)
   set(staged_header ${lldb_header_staging}/${basename})
 
+  if(unifdef_EXECUTABLE)
+    # unifdef returns 0 when the file is unchanged and 1 if something was changed.
+    # That means if we successfully remove SWIG code, the build system believes
+    # that the command has failed and stops. This is undesirable.
+    set(copy_command ${unifdef_EXECUTABLE} -USWIG -o ${staged_header} ${header} || (exit 0))
+  else()
+    set(copy_command ${CMAKE_COMMAND} -E copy ${header} ${staged_header})
+  endif()
+
   add_custom_command(
     DEPENDS ${header} OUTPUT ${staged_header}
-    COMMAND ${CMAKE_COMMAND} -E copy ${header} ${staged_header}
-    COMMENT "LLDB.framework: collect framework header")
+    COMMAND ${copy_command}
+    COMMENT "LLDB.framework: collect framework header and remove SWIG macros")
 
   list(APPEND lldb_staged_headers ${staged_header})
 endforeach()
 
 # Wrap output in a target, so lldb-framework can depend on it.
 add_custom_target(liblldb-resource-headers DEPENDS ${lldb_staged_headers})
 set_target_properties(liblldb-resource-headers PROPERTIES FOLDER "lldb misc")
 add_dependencies(liblldb liblldb-resource-headers)

lldb/include/lldb/API/SBAddress.h

 //===-- SBAddress.h ---------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_API_SBADDRESS_H
 #define LLDB_API_SBADDRESS_H
 
 #include "lldb/API/SBDefines.h"
 #include "lldb/API/SBModule.h"
 
 namespace lldb {
 
 class LLDB_API SBAddress {
 public:
   SBAddress();
 
   SBAddress(const lldb::SBAddress &rhs);
 
   SBAddress(lldb::SBSection section, lldb::addr_t offset);
 
   // Create an address by resolving a load address using the supplied target
   SBAddress(lldb::addr_t load_addr, lldb::SBTarget &target);
 
   ~SBAddress();
 
   const lldb::SBAddress &operator=(const lldb::SBAddress &rhs);
 
   explicit operator bool() const;
 
   // operator== is a free function
 
   bool operator!=(const SBAddress &rhs) const;
 
   bool IsValid() const;
protected:
   friend class SBThreadPlan;
   friend class SBValue;
   friend class SBQueueItem;
 
   lldb_private::Address *operator->();
 
   const lldb_private::Address *operator->() const;
 
+#ifndef SWIG
   friend bool LLDB_API operator==(const SBAddress &lhs, const SBAddress &rhs);
+#endif
 
   lldb_private::Address *get();
 
   lldb_private::Address &ref();
 
   const lldb_private::Address &ref() const;
 
   SBAddress(const lldb_private::Address &address);
 
   void SetAddress(const lldb_private::Address &address);
 
 private:
   std::unique_ptr<lldb_private::Address> m_opaque_up;
 };
 
+#ifndef SWIG
 bool LLDB_API operator==(const SBAddress &lhs, const SBAddress &rhs);
+#endif
 
 } // namespace lldb
 
 #endif // LLDB_API_SBADDRESS_H

lldb/include/lldb/API/SBBreakpoint.h

 
 class LLDB_API SBBreakpoint {
 public:
 
   SBBreakpoint();
 
   SBBreakpoint(const lldb::SBBreakpoint &rhs);
 
+#ifndef SWIG
   SBBreakpoint(const lldb::BreakpointSP &bp_sp);
+#endif
 
   ~SBBreakpoint();
 
   const lldb::SBBreakpoint &operator=(const lldb::SBBreakpoint &rhs);
 
   // Tests to see if the opaque breakpoint object in this object matches the
   // opaque breakpoint object in "rhs".
   bool operator==(const lldb::SBBreakpoint &rhs);
#endif
   void SetThreadName(const char *thread_name);
 
   const char *GetThreadName() const;
 
   void SetQueueName(const char *queue_name);
 
   const char *GetQueueName() const;
 
+#ifndef SWIG
   void SetCallback(SBBreakpointHitCallback callback, void *baton);
+#endif
 
   void SetScriptCallbackFunction(const char *callback_function_name);
 
   SBError SetScriptCallbackFunction(const char *callback_function_name,
                                  SBStructuredData &extra_args);
 
   void SetCommandLineCommands(SBStringList &commands);
 

lldb/include/lldb/API/SBBreakpointLocation.h

public:
   void SetCondition(const char *condition);
 
   const char *GetCondition();
 
   void SetAutoContinue(bool auto_continue);
 
   bool GetAutoContinue();
 
+#ifndef SWIG
   void SetCallback(SBBreakpointHitCallback callback, void *baton);
+#endif
 
   void SetScriptCallbackFunction(const char *callback_function_name);
 
   SBError SetScriptCallbackFunction(const char *callback_function_name,
                                     lldb::SBStructuredData &extra_args);
 
   SBError SetScriptCallbackBody(const char *script_body_text);
   
#endif
   const char *GetQueueName() const;
 
   bool IsResolved();
 
   bool GetDescription(lldb::SBStream &description, DescriptionLevel level);
 
   SBBreakpoint GetBreakpoint();
 
+#ifndef SWIG
   SBBreakpointLocation(const lldb::BreakpointLocationSP &break_loc_sp);
+#endif
 
 private:
   friend class SBBreakpoint;
   friend class SBBreakpointCallbackBaton;
 
   void SetLocation(const lldb::BreakpointLocationSP &break_loc_sp);
   BreakpointLocationSP GetSP() const;
 
   lldb::BreakpointLocationWP m_opaque_wp;
 };
 
 } // namespace lldb
 
 #endif // LLDB_API_SBBREAKPOINTLOCATION_H

lldb/include/lldb/API/SBBreakpointName.h

//                                        lldb::SBBreakpointLocation &location);
   void SetThreadName(const char *thread_name);
 
   const char *GetThreadName() const;
 
   void SetQueueName(const char *queue_name);
 
   const char *GetQueueName() const;
 
+#ifndef SWIG
   void SetCallback(SBBreakpointHitCallback callback, void *baton);
+#endif
 
   void SetScriptCallbackFunction(const char *callback_function_name);
 
   SBError SetScriptCallbackFunction(const char *callback_function_name,
                                     SBStructuredData &extra_args);
 
   void SetCommandLineCommands(lldb::SBStringList &commands);
 

lldb/include/lldb/API/SBCommandInterpreter.h

public:
   bool HasAliasOptions();
 
   bool IsInteractive();
 
   lldb::SBProcess GetProcess();
 
   lldb::SBDebugger GetDebugger();
 
+#ifndef SWIG
   lldb::SBCommand AddMultiwordCommand(const char *name, const char *help);
 
   /// Add a new command to the lldb::CommandInterpreter.
   ///
   /// The new command won't support autorepeat. If you need this functionality,
   /// use the override of this function that accepts the \a auto_repeat_command
   /// parameter.
   ///
#ifndef SWIG
   ///     command.
   ///
   /// \return
   ///     A lldb::SBCommand representing the newly created command.
   lldb::SBCommand AddCommand(const char *name,
                              lldb::SBCommandPluginInterface *impl,
                              const char *help, const char *syntax,
                              const char *auto_repeat_command);
-
   void SourceInitFileInGlobalDirectory(lldb::SBCommandReturnObject &result);
+#endif
+
 
   void SourceInitFileInHomeDirectory(lldb::SBCommandReturnObject &result);
   void SourceInitFileInHomeDirectory(lldb::SBCommandReturnObject &result,
                                      bool is_repl);
 
   void
   SourceInitFileInCurrentWorkingDirectory(lldb::SBCommandReturnObject &result);
 
#endif
   // The first element is useful if you are emulating the common shell behavior
   // where the tab completes to the string that is common among all the
   // matches, then you should first check if the first element is non-empty,
   // and if so just insert it and move the cursor to the end of the insertion.
   // The next tab will return an empty common substring, and a list of choices
   // (if any), at which point you should display the choices and let the user
   // type further to disambiguate.
 
+#ifndef SWIG
   int HandleCompletion(const char *current_line, const char *cursor,
                        const char *last_char, int match_start_point,
                        int max_return_elements, lldb::SBStringList &matches);
+#endif
 
   int HandleCompletion(const char *current_line, uint32_t cursor_pos,
                        int match_start_point, int max_return_elements,
                        lldb::SBStringList &matches);
 
   // Same as HandleCompletion, but also fills out `descriptions` with
   // descriptions for each match.
+#ifndef SWIG
   int HandleCompletionWithDescriptions(
       const char *current_line, const char *cursor, const char *last_char,
       int match_start_point, int max_return_elements,
       lldb::SBStringList &matches, lldb::SBStringList &descriptions);
+#endif
 
   int HandleCompletionWithDescriptions(const char *current_line,
                                        uint32_t cursor_pos,
                                        int match_start_point,
                                        int max_return_elements,
                                        lldb::SBStringList &matches,
                                        lldb::SBStringList &descriptions);
 
   bool WasInterrupted() const;
 
   // Catch commands before they execute by registering a callback that will get
   // called when the command gets executed. This allows GUI or command line
   // interfaces to intercept a command and stop it from happening
+#ifndef SWIG
   bool SetCommandOverrideCallback(const char *command_name,
                                   lldb::CommandOverrideCallback callback,
                                   void *baton);
-
   SBCommandInterpreter(
       lldb_private::CommandInterpreter *interpreter_ptr =
           nullptr); // Access using SBDebugger::GetCommandInterpreter();
+#endif
 
   /// Return true if the command interpreter is the active IO handler.
   ///
   /// This indicates that any input coming into the debugger handles will
   /// go to the command interpreter and will result in LLDB command line
   /// commands being executed.
   bool IsActive();
 
protected:
   void reset(lldb_private::CommandInterpreter *);
 
 private:
   friend class SBDebugger;
 
   lldb_private::CommandInterpreter *m_opaque_ptr;
 };
 
+#ifndef SWIG
 class SBCommandPluginInterface {
 public:
   virtual ~SBCommandPluginInterface() = default;
 
   virtual bool DoExecute(lldb::SBDebugger /*debugger*/, char ** /*command*/,
                          lldb::SBCommandReturnObject & /*result*/) {
     return false;
   }

 private:
   friend class SBDebugger;
   friend class SBCommandInterpreter;
 
   SBCommand(lldb::CommandObjectSP cmd_sp);
 
   lldb::CommandObjectSP m_opaque_sp;
 };
+#endif
 
 } // namespace lldb
 
 #endif // LLDB_API_SBCOMMANDINTERPRETER_H

lldb/include/lldb/API/SBCommandInterpreterRunOptions.h

private:
 
   lldb_private::CommandInterpreterRunOptions &ref() const;
 
   // This is set in the constructor and will always be valid.
   mutable std::unique_ptr<lldb_private::CommandInterpreterRunOptions>
       m_opaque_up;
 };
 
+#ifndef SWIG
 class LLDB_API SBCommandInterpreterRunResult {
   friend class SBDebugger;
   friend class SBCommandInterpreter;
 
 public:
   SBCommandInterpreterRunResult();
   SBCommandInterpreterRunResult(const SBCommandInterpreterRunResult &rhs);
   ~SBCommandInterpreterRunResult();
 
   SBCommandInterpreterRunResult &
   operator=(const SBCommandInterpreterRunResult &rhs);
 
   int GetNumberOfErrors() const;
   lldb::CommandInterpreterResult GetResult() const;
 
 private:
   SBCommandInterpreterRunResult(
       const lldb_private::CommandInterpreterRunResult &rhs);
 
   // This is set in the constructor and will always be valid.
   std::unique_ptr<lldb_private::CommandInterpreterRunResult> m_opaque_up;
 };
+#endif
 
 } // namespace lldb
 
 #endif // LLDB_API_SBCOMMANDINTERPRETERRUNOPTIONS_H

lldb/include/lldb/API/SBCommandReturnObject.h

 }
 
 namespace lldb {
 
 class LLDB_API SBCommandReturnObject {
 public:
   SBCommandReturnObject();
 
+#ifndef SWIG
   SBCommandReturnObject(lldb_private::CommandReturnObject &ref);
+#endif
 
   // rvalue ctor+assignment are incompatible with Reproducers.
 
   SBCommandReturnObject(const lldb::SBCommandReturnObject &rhs);
 
   ~SBCommandReturnObject();
 
   lldb::SBCommandReturnObject &
   operator=(const lldb::SBCommandReturnObject &rhs);
 
   explicit operator bool() const;
 
   bool IsValid() const;
 
   const char *GetOutput();
 
   const char *GetError();
 
+#ifndef SWIG
   size_t PutOutput(FILE *fh); // DEPRECATED
+#endif
 
   size_t PutOutput(SBFile file);
 
-  size_t PutOutput(FileSP file);
+  size_t PutOutput(FileSP BORROWED);
 
   size_t GetOutputSize();
 
   size_t GetErrorSize();
 
+#ifndef SWIG
   size_t PutError(FILE *fh); // DEPRECATED
+#endif
 
   size_t PutError(SBFile file);
 
-  size_t PutError(FileSP file);
+  size_t PutError(FileSP BORROWED);
 
   void Clear();
 
   lldb::ReturnStatus GetStatus();
 
   void SetStatus(lldb::ReturnStatus status);
 
   bool Succeeded();
 
   bool HasResult();
 
   void AppendMessage(const char *message);
 
   void AppendWarning(const char *message);
 
   bool GetDescription(lldb::SBStream &description);
 
+#ifndef SWIG
   void SetImmediateOutputFile(FILE *fh); // DEPRECATED
 
   void SetImmediateErrorFile(FILE *fh); // DEPRECATED
 
   void SetImmediateOutputFile(FILE *fh, bool transfer_ownership); // DEPRECATED
 
   void SetImmediateErrorFile(FILE *fh, bool transfer_ownership); // DEPRECATED
+#endif
 
   void SetImmediateOutputFile(SBFile file);
 
   void SetImmediateErrorFile(SBFile file);
 
-  void SetImmediateOutputFile(FileSP file);
+  void SetImmediateOutputFile(FileSP BORROWED);
 
-  void SetImmediateErrorFile(FileSP file);
+  void SetImmediateErrorFile(FileSP BORROWED);
 
   void PutCString(const char *string, int len = -1);
 
-  size_t Printf(const char *format, ...) __attribute__((format(printf, 2, 3)));
+#ifndef SWIG
+  __attribute__((format(printf, 2, 3))) size_t Printf(const char *format, ...);
+#endif
 
   const char *GetOutput(bool only_if_no_immediate);
 
   const char *GetError(bool only_if_no_immediate);
 
   void SetError(lldb::SBError &error,
                 const char *fallback_error_cstr = nullptr);
 

lldb/include/lldb/API/SBDebugger.h

 
 #include <cstdio>
 
 #include "lldb/API/SBDefines.h"
 #include "lldb/API/SBPlatform.h"
 
 namespace lldb {
 
+#ifndef SWIG
 class LLDB_API SBInputReader {
 public:
   SBInputReader() = default;
   ~SBInputReader() = default;
 
   SBError Initialize(lldb::SBDebugger &sb_debugger,
                      unsigned long (*callback)(void *, lldb::SBInputReader *,
                                                lldb::InputReaderAction,
                                                char const *, unsigned long),
                      void *a, lldb::InputReaderGranularity b, char const *c,
                      char const *d, bool e);
   void SetIsDone(bool);
   bool IsActive() const;
 };
+#endif
 
 class LLDB_API SBDebugger {
 public:
   FLAGS_ANONYMOUS_ENUM(){
       eBroadcastBitProgress = (1 << 0),
       eBroadcastBitWarning = (1 << 1),
       eBroadcastBitError = (1 << 2),
   };
 
   SBDebugger();
 
   SBDebugger(const lldb::SBDebugger &rhs);
 
+#ifndef SWIG
   SBDebugger(const lldb::DebuggerSP &debugger_sp);
+#endif
 
   ~SBDebugger();
 
   static const char *GetBroadcasterClass();
 
   lldb::SBBroadcaster GetBroadcaster();
 
   /// Get progress data from a SBEvent whose type is eBroadcastBitProgress.
#endif
   /// \param [out] is_debugger_specific
   ///   Set to true if this progress is specific to this debugger only. Many
   ///   progress events are not specific to a debugger instance, like any
   ///   progress events for loading information in modules since LLDB has a
   ///   global module cache that all debuggers use.
   ///
   /// \return The message for the progress. If the returned value is NULL, then
   ///   \a event was not a eBroadcastBitProgress event.
+#ifdef SWIG
+  static const char *GetProgressFromEvent(const lldb::SBEvent &event,
+                                          uint64_t &OUTPUT,
+                                          uint64_t &OUTPUT, uint64_t &OUTPUT,
+                                          bool &OUTPUT);
+#else
   static const char *GetProgressFromEvent(const lldb::SBEvent &event,
                                           uint64_t &progress_id,
                                           uint64_t &completed, uint64_t &total,
                                           bool &is_debugger_specific);
+#endif
 
   static lldb::SBStructuredData
   GetProgressDataFromEvent(const lldb::SBEvent &event);
 
   static lldb::SBStructuredData
   GetDiagnosticFromEvent(const lldb::SBEvent &event);
 
   lldb::SBDebugger &operator=(const lldb::SBDebugger &rhs);
#endif
   void SetAsync(bool b);
 
   bool GetAsync();
 
   void SkipLLDBInitFiles(bool b);
 
   void SkipAppInitFiles(bool b);
 
+#ifndef SWIG
   void SetInputFileHandle(FILE *f, bool transfer_ownership);
 
   void SetOutputFileHandle(FILE *f, bool transfer_ownership);
 
   void SetErrorFileHandle(FILE *f, bool transfer_ownership);
+#endif
 
+#ifndef SWIG
   FILE *GetInputFileHandle();
 
   FILE *GetOutputFileHandle();
 
   FILE *GetErrorFileHandle();
+#endif
 
   SBError SetInputString(const char *data);
 
   SBError SetInputFile(SBFile file);
 
   SBError SetOutputFile(SBFile file);
 
   SBError SetErrorFile(SBFile file);
#endif
   void RestoreInputTerminalState();
 
   lldb::SBCommandInterpreter GetCommandInterpreter();
 
   void HandleCommand(const char *command);
 
   lldb::SBListener GetListener();
 
+#ifndef SWIG
   void HandleProcessEvent(const lldb::SBProcess &process,
                           const lldb::SBEvent &event, FILE *out,
                           FILE *err); // DEPRECATED
+#endif
 
   void HandleProcessEvent(const lldb::SBProcess &process,
                           const lldb::SBEvent &event, SBFile out, SBFile err);
 
+#ifdef SWIG
+  void HandleProcessEvent(const lldb::SBProcess &process,
+                          const lldb::SBEvent &event, FileSP BORROWED, FileSP BORROWED);
+#else
   void HandleProcessEvent(const lldb::SBProcess &process,
                           const lldb::SBEvent &event, FileSP out, FileSP err);
+#endif
 
   lldb::SBTarget CreateTarget(const char *filename, const char *target_triple,
                               const char *platform_name,
                               bool add_dependent_modules, lldb::SBError &error);
 
   lldb::SBTarget CreateTargetWithFileAndTargetTriple(const char *filename,
                                                      const char *target_triple);
 
#endif
 
   static bool StateIsStoppedState(lldb::StateType state);
 
   bool EnableLog(const char *channel, const char **categories);
 
   void SetLoggingCallback(lldb::LogOutputCallback log_callback, void *baton);
 
   // DEPRECATED
+#ifndef SWIG
   void DispatchInput(void *baton, const void *data, size_t data_len);
+#endif
 
   void DispatchInput(const void *data, size_t data_len);
 
   void DispatchInputInterrupt();
 
   void DispatchInputEndOfFile();
 
+#ifndef SWIG
   void PushInputReader(lldb::SBInputReader &reader);
+#endif
 
   const char *GetInstanceName();
 
   static SBDebugger FindDebuggerWithID(int id);
 
   static lldb::SBError SetInternalVariable(const char *var_name,
                                            const char *value,
                                            const char *debugger_instance_name);
#endif
   SBTypeFormat GetFormatForType(SBTypeNameSpecifier);
 
   SBTypeSummary GetSummaryForType(SBTypeNameSpecifier);
 
   SBTypeFilter GetFilterForType(SBTypeNameSpecifier);
 
   SBTypeSynthetic GetSyntheticForType(SBTypeNameSpecifier);
 
+#ifndef SWIG
   /// Run the command interpreter.
   ///
   /// \param[in] auto_handle_events
   ///     If true, automatically handle resulting events. This takes precedence
   ///     and overrides the corresponding option in
   ///     SBCommandInterpreterRunOptions.
   ///
   /// \param[in] spawn_thread
   ///     If true, start a new thread for IO handling. This takes precedence
   ///     and overrides the corresponding option in
   ///     SBCommandInterpreterRunOptions.
   void RunCommandInterpreter(bool auto_handle_events, bool spawn_thread);
+#endif
 
   /// Run the command interpreter.
   ///
   /// \param[in] auto_handle_events
   ///     If true, automatically handle resulting events. This takes precedence
   ///     and overrides the corresponding option in
   ///     SBCommandInterpreterRunOptions.
   ///
   /// \param[in] spawn_thread
   ///     If true, start a new thread for IO handling. This takes precedence
   ///     and overrides the corresponding option in
   ///     SBCommandInterpreterRunOptions.
   ///
   /// \param[in] options
   ///     Parameter collection of type SBCommandInterpreterRunOptions.
   ///
   /// \param[out] num_errors
   ///     The number of errors.
   ///
   /// \param[out] quit_requested
   ///     Whether a quit was requested.
   ///
   /// \param[out] stopped_for_crash
   ///     Whether the interpreter stopped for a crash.
+#ifdef SWIG
+  %apply int& INOUT { int& num_errors };
+  %apply bool& INOUT { bool& quit_requested };
+  %apply bool& INOUT { bool& stopped_for_crash };
+#endif
   void RunCommandInterpreter(bool auto_handle_events, bool spawn_thread,
                              SBCommandInterpreterRunOptions &options,
                              int &num_errors, bool &quit_requested,
                              bool &stopped_for_crash);
 
+#ifndef SWIG
   SBCommandInterpreterRunResult
   RunCommandInterpreter(const SBCommandInterpreterRunOptions &options);
+#endif
 
   SBError RunREPL(lldb::LanguageType language, const char *repl_options);
 
   /// Load a trace from a trace description file and create Targets,
   /// Processes and Threads based on the contents of such file.
   ///
   /// \param[out] error
   ///   An error if the trace could not be created.

lldb/include/lldb/API/SBError.h

 namespace lldb {
 
 class LLDB_API SBError {
 public:
   SBError();
 
   SBError(const lldb::SBError &rhs);
 
+#ifndef SWIG
   SBError(const lldb_private::Status &error);
+#endif
 
   ~SBError();
 
   const SBError &operator=(const lldb::SBError &rhs);
 
   /// Get the error string as a NULL terminated UTF8 c-string.
   ///
   /// This SBError object owns the returned string and this object must be kept
#endif
   void SetError(uint32_t err, lldb::ErrorType type);
 
   void SetErrorToErrno();
 
   void SetErrorToGenericError();
 
   void SetErrorString(const char *err_str);
 
-  int SetErrorStringWithFormat(const char *format, ...)
-      __attribute__((format(printf, 2, 3)));
+#ifndef SWIG
+  __attribute__((format(printf, 2, 3)))
+#else
+  // clang-format off
+  %varargs(3, char *str = NULL) SetErrorStringWithFormat;
+  // clang-format on
+#endif
+  int SetErrorStringWithFormat(const char *format, ...);
 
   explicit operator bool() const;
 
   bool IsValid() const;
 
   bool GetDescription(lldb::SBStream &description);
 
 protected:

lldb/include/lldb/API/SBEvent.h

 public:
   SBEvent();
 
   SBEvent(const lldb::SBEvent &rhs);
 
   // Make an event that contains a C string.
   SBEvent(uint32_t event, const char *cstr, uint32_t cstr_len);
 
+#ifndef SWIG
   SBEvent(lldb::EventSP &event_sp);
 
   SBEvent(lldb_private::Event *event_sp);
+#endif
 
   ~SBEvent();
 
   const SBEvent &operator=(const lldb::SBEvent &rhs);
 
   explicit operator bool() const;
 
   bool IsValid() const;
 
   const char *GetDataFlavor();
 
   uint32_t GetType() const;
 
   lldb::SBBroadcaster GetBroadcaster() const;
 
   const char *GetBroadcasterClass() const;
 
+#ifndef SWIG
   bool BroadcasterMatchesPtr(const lldb::SBBroadcaster *broadcaster);
+#endif
 
   bool BroadcasterMatchesRef(const lldb::SBBroadcaster &broadcaster);
 
   void Clear();
 
   static const char *GetCStringFromEvent(const lldb::SBEvent &event);
 
   bool GetDescription(lldb::SBStream &description);

lldb/include/lldb/API/SBExecutionContext.h

 class LLDB_API SBExecutionContext {
   friend class SBCommandInterpreter;
 
 public:
   SBExecutionContext();
 
   SBExecutionContext(const lldb::SBExecutionContext &rhs);
 
+#ifndef SWIG
   SBExecutionContext(lldb::ExecutionContextRefSP exe_ctx_ref_sp);
+#endif
 
   SBExecutionContext(const lldb::SBTarget &target);
 
   SBExecutionContext(const lldb::SBProcess &process);
 
   SBExecutionContext(lldb::SBThread thread); // can't be a const& because
                                              // SBThread::get() isn't itself a
                                              // const function

lldb/include/lldb/API/SBExpressionOptions.h

public:
   void SetStopOthers(bool stop_others = true);
 
   bool GetTrapExceptions() const;
 
   void SetTrapExceptions(bool trap_exceptions = true);
 
   void SetLanguage(lldb::LanguageType language);
 
+#ifndef SWIG
   void SetCancelCallback(lldb::ExpressionCancelCallback callback, void *baton);
+#endif
 
   bool GetGenerateDebugInfo();
 
   void SetGenerateDebugInfo(bool b = true);
 
   bool GetSuppressPersistentResult();
 
   void SetSuppressPersistentResult(bool b = false);

lldb/include/lldb/API/SBFile.h

class LLDB_API SBFile {
   friend class SBInstructionList;
   friend class SBDebugger;
   friend class SBCommandReturnObject;
   friend class SBProcess;
 
 public:
   SBFile();
   SBFile(FileSP file_sp);
+#ifndef SWIG
   SBFile(const SBFile &rhs);
   SBFile(FILE *file, bool transfer_ownership);
+#endif
   SBFile(int fd, const char *mode, bool transfer_ownership);
   ~SBFile();
 
   SBFile &operator=(const SBFile &rhs);
 
-  SBError Read(uint8_t *buf, size_t num_bytes, size_t *bytes_read);
-  SBError Write(const uint8_t *buf, size_t num_bytes, size_t *bytes_written);
+  SBError Read(uint8_t *buf, size_t num_bytes, size_t *OUTPUT);
+  SBError Write(const uint8_t *buf, size_t num_bytes, size_t *OUTPUT);
   SBError Flush();
   bool IsValid() const;
   SBError Close();
 
   operator bool() const;
+#ifndef SWIG
   bool operator!() const;
+#endif
 
   FileSP GetFile() const;
 
 private:
   FileSP m_opaque_sp;
 };
 
 } // namespace lldb
 
 #endif // LLDB_API_SBFILE_H

lldb/include/lldb/API/SBFrame.h

public:
   /// target's default.
   lldb::SBValue FindValue(const char *name, ValueType value_type);
 
   lldb::SBValue FindValue(const char *name, ValueType value_type,
                           lldb::DynamicValueType use_dynamic);
 
   bool GetDescription(lldb::SBStream &description);
 
+#ifndef SWIG
   SBFrame(const lldb::StackFrameSP &lldb_object_sp);
+#endif
 
 protected:
   friend class SBBlock;
   friend class SBExecutionContext;
   friend class SBInstruction;
   friend class SBThread;
   friend class SBValue;
 

lldb/include/lldb/API/SBInstruction.h

public:
   size_t GetByteSize();
 
   bool DoesBranch();
 
   bool HasDelaySlot();
 
   bool CanSetBreakpoint();
 
+#ifndef SWIG
   void Print(FILE *out);
+#endif
 
   void Print(SBFile out);
 
-  void Print(FileSP out);
+  void Print(FileSP BORROWED);
 
   bool GetDescription(lldb::SBStream &description);
 
   bool EmulateWithFrame(lldb::SBFrame &frame, uint32_t evaluate_options);
 
   bool DumpEmulation(const char *triple); // triple is to specify the
                                           // architecture, e.g. 'armv6' or
                                           // 'armv7-apple-ios'

lldb/include/lldb/API/SBInstructionList.h

public:
   size_t GetInstructionsCount(const SBAddress &start,
                               const SBAddress &end,
                               bool canSetBreakpoint = false);                                   
 
   void Clear();
 
   void AppendInstruction(lldb::SBInstruction inst);
 
+#ifndef SWIG
   void Print(FILE *out);
+#endif
 
   void Print(SBFile out);
 
-  void Print(FileSP out);
+  void Print(FileSP BORROWED);
 
   bool GetDescription(lldb::SBStream &description);
 
   bool DumpEmulationForAllInstructions(const char *triple);
 
 protected:
   friend class SBFunction;
   friend class SBSymbol;

lldb/include/lldb/API/SBListener.h

public:
   explicit operator bool() const;
 
   bool IsValid() const;
 
   uint32_t StartListeningForEventClass(SBDebugger &debugger,
                                        const char *broadcaster_class,
                                        uint32_t event_mask);
 
+  // TODO: This returns uint32_t in the interface files. :/
   bool StopListeningForEventClass(SBDebugger &debugger,
                                   const char *broadcaster_class,
                                   uint32_t event_mask);
 
   uint32_t StartListeningForEvents(const lldb::SBBroadcaster &broadcaster,
                                    uint32_t event_mask);
 
   bool StopListeningForEvents(const lldb::SBBroadcaster &broadcaster,

lldb/include/lldb/API/SBProcess.h

FLAGS_ANONYMOUS_ENUM(){eBroadcastBitStateChanged = (1 << 0),
                          eBroadcastBitStructuredData = (1 << 5)};
 
   SBProcess();
 
   SBProcess(const lldb::SBProcess &rhs);
 
   const lldb::SBProcess &operator=(const lldb::SBProcess &rhs);
 
+#ifndef SWIG
   SBProcess(const lldb::ProcessSP &process_sp);
+#endif
 
   ~SBProcess();
 
   static const char *GetBroadcasterClassName();
 
   const char *GetPluginName();
 
   // DEPRECATED: use GetPluginName()
#endif
   size_t PutSTDIN(const char *src, size_t src_len);
 
   size_t GetSTDOUT(char *dst, size_t dst_len) const;
 
   size_t GetSTDERR(char *dst, size_t dst_len) const;
 
   size_t GetAsyncProfileData(char *dst, size_t dst_len) const;
 
+#ifndef SWIG
   void ReportEventState(const lldb::SBEvent &event, FILE *out) const;
+#endif
 
   void ReportEventState(const lldb::SBEvent &event, SBFile file) const;
 
-  void ReportEventState(const lldb::SBEvent &event, FileSP file) const;
+  void ReportEventState(const lldb::SBEvent &event, FileSP BORROWED) const;
 
   void AppendEventStateReport(const lldb::SBEvent &event,
                               lldb::SBCommandReturnObject &result);
 
   /// Remote connection related functions. These will fail if the
   /// process is not in eStateConnected. They are intended for use
   /// when connecting to an externally managed debugserver instance.
   bool RemoteAttachToProcessWithID(lldb::pid_t pid, lldb::SBError &error);
#endif
 
   bool SetSelectedThreadByID(lldb::tid_t tid);
 
   bool SetSelectedThreadByIndexID(uint32_t index_id);
 
   // Queue related functions
   uint32_t GetNumQueues();
 
+  // TODO: This technically takes a uint32_t in the interface file.
   lldb::SBQueue GetQueueAtIndex(size_t index);
 
   // Stepping related functions
 
   lldb::StateType GetState();
 
   int GetExitStatus();
 
#endif
   ///   The stop event corresponding to stop ID.
   lldb::SBEvent GetStopEventForStopID(uint32_t stop_id);
 
   size_t ReadMemory(addr_t addr, void *buf, size_t size, lldb::SBError &error);
 
   size_t WriteMemory(addr_t addr, const void *buf, size_t size,
                      lldb::SBError &error);
 
-  size_t ReadCStringFromMemory(addr_t addr, void *buf, size_t size,
+  size_t ReadCStringFromMemory(addr_t addr, void *char_buf, size_t size,
                                lldb::SBError &error);
 
   uint64_t ReadUnsignedFromMemory(addr_t addr, uint32_t byte_size,
                                   lldb::SBError &error);
 
   lldb::addr_t ReadPointerFromMemory(addr_t addr, lldb::SBError &error);
 
   // Events

lldb/include/lldb/API/SBReproducer.h

 namespace lldb_private {
 namespace repro {
 struct ReplayOptions;
 }
 } // namespace lldb_private
 
 namespace lldb {
 
+#ifndef SWIG
 class LLDB_API SBReplayOptions {
 public:
   SBReplayOptions();
   SBReplayOptions(const SBReplayOptions &rhs);
   ~SBReplayOptions();
 
   SBReplayOptions &operator=(const SBReplayOptions &rhs);
 
   void SetVerify(bool verify);
   bool GetVerify() const;
 
   void SetCheckVersion(bool check);
   bool GetCheckVersion() const;
 };
+#endif
 
 /// The SBReproducer class is special because it bootstraps the capture and
 /// replay of SB API calls. As a result we cannot rely on any other SB objects
 /// in the interface or implementation of this class.
 class LLDB_API SBReproducer {
 public:
+#ifndef SWIG
   static const char *Capture();
+#endif
   static const char *Capture(const char *path);
+#ifndef SWIG
   static const char *Replay(const char *path);
   static const char *Replay(const char *path, bool skip_version_check);
   static const char *Replay(const char *path, const SBReplayOptions &options);
+#endif
   static const char *PassiveReplay(const char *path);
+#ifndef SWIG
   static const char *Finalize(const char *path);
   static const char *GetPath();
+#endif
   static bool SetAutoGenerate(bool b);
+#ifndef SWIG
   static bool Generate();
+#endif
 
   /// The working directory is set to the current working directory when the
   /// reproducers are initialized. This method allows setting a different
   /// working directory. This is used by the API test suite  which temporarily
   /// changes the directory to where the test lives. This is a NO-OP in every
   /// mode but capture.
   static void SetWorkingDirectory(const char *path);
 };
 
 } // namespace lldb
 
 #endif

lldb/include/lldb/API/SBStream.h

 #include "lldb/API/SBDefines.h"
 
 namespace lldb {
 
 class LLDB_API SBStream {
 public:
   SBStream();
 
+#ifndef SWIG
   SBStream(SBStream &&rhs);
+#endif
 
   ~SBStream();
 
   explicit operator bool() const;
 
   bool IsValid() const;
 
   // If this stream is not redirected to a file, it will maintain a local cache
   // for the stream data which can be accessed using this accessor.
   const char *GetData();
 
   // If this stream is not redirected to a file, it will maintain a local cache
   // for the stream output whose length can be accessed using this accessor.
   size_t GetSize();
 
-  void Printf(const char *format, ...) __attribute__((format(printf, 2, 3)));
+#ifndef SWIG
+  __attribute__((format(printf, 2, 3))) void Printf(const char *format, ...);
+#endif
 
   void Print(const char *str);
 
   void RedirectToFile(const char *path, bool append);
 
   void RedirectToFile(lldb::SBFile file);
 
   void RedirectToFile(lldb::FileSP file);
 
+#ifndef SWIG
   void RedirectToFileHandle(FILE *fh, bool transfer_fh_ownership);
+#endif
 
   void RedirectToFileDescriptor(int fd, bool transfer_fh_ownership);
 
   // If the stream is redirected to a file, forget about the file and if
   // ownership of the file was transferred to this object, close the file. If
   // the stream is backed by a local cache, clear this cache.
   void Clear();
 

lldb/include/lldb/API/SBStructuredData.h

 class SBStructuredData {
 public:
   SBStructuredData();
 
   SBStructuredData(const lldb::SBStructuredData &rhs);
 
   SBStructuredData(const lldb::EventSP &event_sp);
 
+#ifndef SWIG
   SBStructuredData(const lldb_private::StructuredDataImpl &impl);
+#endif
 
   ~SBStructuredData();
 
   lldb::SBStructuredData &operator=(const lldb::SBStructuredData &rhs);
 
   explicit operator bool() const;
 
   bool IsValid() const;

lldb/include/lldb/API/SBSymbolContext.h

 namespace lldb {
 
 class LLDB_API SBSymbolContext {
 public:
   SBSymbolContext();
 
   SBSymbolContext(const lldb::SBSymbolContext &rhs);
 
+#ifndef SWIG
   SBSymbolContext(const lldb_private::SymbolContext &sc_ptr);
+#endif
 
   ~SBSymbolContext();
 
   explicit operator bool() const;
 
   bool IsValid() const;
 
   const lldb::SBSymbolContext &operator=(const lldb::SBSymbolContext &rhs);

lldb/include/lldb/API/SBTarget.h

enum {
     eBroadcastBitSymbolsLoaded = (1 << 4)
   };
 
   // Constructors
   SBTarget();
 
   SBTarget(const lldb::SBTarget &rhs);
 
+#ifndef SWIG
   SBTarget(const lldb::TargetSP &target_sp);
+#endif
 
   // Destructor
   ~SBTarget();
 
   const lldb::SBTarget &operator=(const lldb::SBTarget &rhs);
 
   explicit operator bool() const;
 
#endif
 
   lldb::SBBreakpoint BreakpointCreateByName(
       const char *symbol_name,
       uint32_t
           name_type_mask, // Logical OR one or more FunctionNameType enum bits
       lldb::LanguageType symbol_language,
       const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list);
 
+#ifdef SWIG
+  lldb::SBBreakpoint BreakpointCreateByNames(
+      const char **symbol_name, uint32_t num_names,
+      uint32_t
+          name_type_mask, // Logical OR one or more FunctionNameType enum bits
+      const SBFileSpecList &module_list,
+      const SBFileSpecList &comp_unit_list);
+
+  lldb::SBBreakpoint BreakpointCreateByNames(
+      const char **symbol_name, uint32_t num_names,
+      uint32_t
+          name_type_mask, // Logical OR one or more FunctionNameType enum bits
+      lldb::LanguageType symbol_language,
+      const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list);
+
+  lldb::SBBreakpoint BreakpointCreateByNames(
+      const char **symbol_name, uint32_t num_names,
+      uint32_t
+          name_type_mask, // Logical OR one or more FunctionNameType enum bits
+      lldb::LanguageType symbol_language,
+      lldb::addr_t offset, const SBFileSpecList &module_list,
+      const SBFileSpecList &comp_unit_list);
+#else
   lldb::SBBreakpoint BreakpointCreateByNames(
       const char *symbol_name[], uint32_t num_names,
       uint32_t
           name_type_mask, // Logical OR one or more FunctionNameType enum bits
       const SBFileSpecList &module_list,
       const SBFileSpecList &comp_unit_list);
 
   lldb::SBBreakpoint BreakpointCreateByNames(
       const char *symbol_name[], uint32_t num_names,
       uint32_t
           name_type_mask, // Logical OR one or more FunctionNameType enum bits
       lldb::LanguageType symbol_language,
       const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list);
 
   lldb::SBBreakpoint BreakpointCreateByNames(
       const char *symbol_name[], uint32_t num_names,
       uint32_t
           name_type_mask, // Logical OR one or more FunctionNameType enum bits
       lldb::LanguageType symbol_language,
       lldb::addr_t offset, const SBFileSpecList &module_list,
       const SBFileSpecList &comp_unit_list);
+#endif
 
   lldb::SBBreakpoint BreakpointCreateByRegex(const char *symbol_name_regex,
                                              const char *module_name = nullptr);
 
   lldb::SBBreakpoint
   BreakpointCreateByRegex(const char *symbol_name_regex,
                           const SBFileSpecList &module_list,
                           const SBFileSpecList &comp_unit_list);
#endif
   // The "WithFlavor" is necessary to keep SWIG from getting confused about
   // overloaded arguments when using the buf + size -> Python Object magic.
 
   lldb::SBInstructionList GetInstructionsWithFlavor(lldb::SBAddress base_addr,
                                                     const char *flavor_string,
                                                     const void *buf,
                                                     size_t size);
 
+#ifndef SWIG
   lldb::SBInstructionList GetInstructions(lldb::addr_t base_addr,
                                           const void *buf, size_t size);
-
   lldb::SBInstructionList GetInstructionsWithFlavor(lldb::addr_t base_addr,
                                                     const char *flavor_string,
                                                     const void *buf,
                                                     size_t size);
+#endif
 
   lldb::SBSymbolContextList FindSymbols(const char *name,
                                         lldb::SymbolType type = eSymbolTypeAny);
 
   bool operator==(const lldb::SBTarget &rhs) const;
 
   bool operator!=(const lldb::SBTarget &rhs) const;
 

lldb/include/lldb/API/SBThread.h

public:
   };
 
   static const char *GetBroadcasterClassName();
 
   SBThread();
 
   SBThread(const lldb::SBThread &thread);
 
+#ifndef SWIG
   SBThread(const lldb::ThreadSP &lldb_object_sp);
+#endif
 
   ~SBThread();
 
   lldb::SBQueue GetQueue() const;
 
   explicit operator bool() const;
 
   bool IsValid() const;
#endif
   /// eStopReasonPlanComplete  0
   uint64_t GetStopReasonDataAtIndex(uint32_t idx);
 
   bool GetStopReasonExtendedInfoAsJSON(lldb::SBStream &stream);
 
   SBThreadCollection
   GetStopReasonExtendedBacktraces(InstrumentationRuntimeType type);
 
-  size_t GetStopDescription(char *dst, size_t dst_len);
+  size_t GetStopDescription(char *dst_or_null, size_t dst_len);
 
   SBValue GetStopReturnValue();
 
   lldb::tid_t GetThreadID() const;
 
   uint32_t GetIndexID() const;
 
   const char *GetName() const;

lldb/include/lldb/API/SBTrace.h

 
 namespace lldb {
 
 class LLDB_API SBTrace {
 public:
   /// Default constructor for an invalid Trace object.
   SBTrace();
 
+#ifndef SWIG
   SBTrace(const lldb::TraceSP &trace_sp);
+#endif
 
   /// See SBDebugger::LoadTraceFromFile.
   static SBTrace LoadTraceFromFile(SBError &error, SBDebugger &debugger,
                                    const SBFileSpec &trace_description_file);
 
   /// Get a \a TraceCursor for the given thread's trace.
   ///
   /// \param[out] error

lldb/include/lldb/API/SBType.h

protected:
   lldb::TypeMemberFunctionImplSP m_opaque_sp;
 };
 
 class SBType {
 public:
   SBType();
 
   SBType(const lldb::SBType &rhs);
+#ifndef SWIG
   SBType(const lldb::TypeImplSP &);
+#endif
 
   ~SBType();
 
   explicit operator bool() const;
 
   bool IsValid() const;
 
   uint64_t GetByteSize();

lldb/include/lldb/API/SBTypeSummary.h

 
 namespace lldb {
 class LLDB_API SBTypeSummaryOptions {
 public:
   SBTypeSummaryOptions();
 
   SBTypeSummaryOptions(const lldb::SBTypeSummaryOptions &rhs);
 
+#ifndef SWIG
   SBTypeSummaryOptions(const lldb_private::TypeSummaryOptions &lldb_object);
+#endif
 
   ~SBTypeSummaryOptions();
 
   explicit operator bool() const;
 
   bool IsValid();
 
   lldb::LanguageType GetLanguage();
public:
   static SBTypeSummary
   CreateWithFunctionName(const char *data,
                          uint32_t options = 0); // see lldb::eTypeOption values
 
   static SBTypeSummary
   CreateWithScriptCode(const char *data,
                        uint32_t options = 0); // see lldb::eTypeOption values
 
+#ifndef SWIG
   static SBTypeSummary CreateWithCallback(FormatCallback cb,
                                           uint32_t options = 0,
                                           const char *description = nullptr);
+#endif
 
   SBTypeSummary(const lldb::SBTypeSummary &rhs);
 
   ~SBTypeSummary();
 
   explicit operator bool() const;
 
   bool IsValid() const;

lldb/include/lldb/API/SBValue.h

public:
 
   lldb::SBValue EvaluateExpression(const char *expr) const;
   lldb::SBValue EvaluateExpression(const char *expr,
                                    const SBExpressionOptions &options) const;
   lldb::SBValue EvaluateExpression(const char *expr,
                                    const SBExpressionOptions &options,
                                    const char *name) const;
 
+#ifndef SWIG
   SBValue(const lldb::ValueObjectSP &value_sp);
+#endif
 
   /// Watch this value if it resides in memory.
   ///
   /// Sets a watchpoint on the value.
   ///
   /// \param[in] resolve_location
   ///     Resolve the location of this value once and watch its address.
   ///     This value must currently be set to \b true as watching all
#endif
   /// \return
   ///     An SBWatchpoint object. This object might not be valid upon
   ///     return due to a value not being contained in memory, too
   ///     large, or watchpoint resources are not available or all in
   ///     use.
   lldb::SBWatchpoint WatchPointee(bool resolve_location, bool read, bool write,
                                   SBError &error);
 
+#ifndef SWIG
   /// Same as the protected version of GetSP that takes a locker, except that we
   /// make the
   /// locker locally in the function.  Since the Target API mutex is recursive,
   /// and the
   /// StopLocker is a read lock, you can call this function even if you are
   /// already
   /// holding the two above-mentioned locks.
   ///
   /// \return
   ///     A ValueObjectSP of the best kind (static, dynamic or synthetic) we
   ///     can cons up, in accordance with the SBValue's settings.
   lldb::ValueObjectSP GetSP() const;
+#endif
 
 protected:
   friend class SBBlock;
   friend class SBFrame;
   friend class SBTarget;
   friend class SBThread;
   friend class SBValueList;
 

lldb/include/lldb/API/SBWatchpoint.h

 namespace lldb {
 
 class LLDB_API SBWatchpoint {
 public:
   SBWatchpoint();
 
   SBWatchpoint(const lldb::SBWatchpoint &rhs);
 
+#ifndef SWIG
   SBWatchpoint(const lldb::WatchpointSP &wp_sp);
+#endif
 
   ~SBWatchpoint();
 
   const lldb::SBWatchpoint &operator=(const lldb::SBWatchpoint &rhs);
 
   explicit operator bool() const;
 
   bool operator==(const SBWatchpoint &rhs) const;
#endif
   const char *GetCondition();
 
   void SetCondition(const char *condition);
 
   bool GetDescription(lldb::SBStream &description, DescriptionLevel level);
 
   void Clear();
 
+#ifndef SWIG
   lldb::WatchpointSP GetSP() const;
 
   void SetSP(const lldb::WatchpointSP &sp);
+#endif
 
   static bool EventIsWatchpointEvent(const lldb::SBEvent &event);
 
   static lldb::WatchpointEventType
   GetWatchpointEventTypeFromEvent(const lldb::SBEvent &event);
 
   static lldb::SBWatchpoint GetWatchpointFromEvent(const lldb::SBEvent &event);