Update prebuilt Clang to r365631c1 from Android.
The version we had was segfaulting.
Bug: 132420445
Change-Id: Icb45a6fe0b4e2166f7895e669df1157cec9fb4e0
diff --git a/linux-x64/clang/include/lldb/API/LLDB.h b/linux-x64/clang/include/lldb/API/LLDB.h
new file mode 100644
index 0000000..0806ab7
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/LLDB.h
@@ -0,0 +1,80 @@
+//===-- LLDB.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_LLDB_h_
+#define LLDB_LLDB_h_
+
+#include "lldb/API/SBAddress.h"
+#include "lldb/API/SBAttachInfo.h"
+#include "lldb/API/SBBlock.h"
+#include "lldb/API/SBBreakpoint.h"
+#include "lldb/API/SBBreakpointName.h"
+#include "lldb/API/SBBreakpointLocation.h"
+#include "lldb/API/SBBroadcaster.h"
+#include "lldb/API/SBCommandInterpreter.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/SBDefines.h"
+#include "lldb/API/SBError.h"
+#include "lldb/API/SBEvent.h"
+#include "lldb/API/SBExecutionContext.h"
+#include "lldb/API/SBExpressionOptions.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/SBTraceOptions.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"
+
+#endif // LLDB_LLDB_h_
diff --git a/linux-x64/clang/include/lldb/API/SBAddress.h b/linux-x64/clang/include/lldb/API/SBAddress.h
new file mode 100644
index 0000000..2874a36
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBAddress.h
@@ -0,0 +1,130 @@
+//===-- 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_SBAddress_h_
+#define LLDB_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;
+
+ void Clear();
+
+ addr_t GetFileAddress() const;
+
+ addr_t GetLoadAddress(const lldb::SBTarget &target) const;
+
+ void SetAddress(lldb::SBSection section, lldb::addr_t offset);
+
+ void SetLoadAddress(lldb::addr_t load_addr, lldb::SBTarget &target);
+ bool OffsetAddress(addr_t offset);
+
+ bool GetDescription(lldb::SBStream &description);
+
+ // The following queries 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 "void SBAddress::SetLoadAddress(...)" or
+ // "lldb::SBAddress SBTarget::ResolveLoadAddress (...)".
+ lldb::SBSymbolContext GetSymbolContext(uint32_t resolve_scope);
+
+ // The following functions grab individual objects for a given address and
+ // are less efficient if you want more than one symbol related objects. Use
+ // one of the following when you want multiple debug symbol related objects
+ // for an address:
+ // lldb::SBSymbolContext SBAddress::GetSymbolContext (uint32_t
+ // resolve_scope);
+ // lldb::SBSymbolContext SBTarget::ResolveSymbolContextForAddress (const
+ // SBAddress &addr, uint32_t resolve_scope);
+ // One or more bits from the SymbolContextItem enumerations can be logically
+ // OR'ed together to more efficiently retrieve multiple symbol objects.
+
+ lldb::SBSection GetSection();
+
+ lldb::addr_t GetOffset();
+
+ lldb::SBModule GetModule();
+
+ lldb::SBCompileUnit GetCompileUnit();
+
+ lldb::SBFunction GetFunction();
+
+ lldb::SBBlock GetBlock();
+
+ lldb::SBSymbol GetSymbol();
+
+ lldb::SBLineEntry GetLineEntry();
+
+protected:
+ friend class SBBlock;
+ friend class SBBreakpoint;
+ friend class SBBreakpointLocation;
+ friend class SBFrame;
+ friend class SBFunction;
+ friend class SBLineEntry;
+ friend class SBInstruction;
+ friend class SBModule;
+ friend class SBSection;
+ friend class SBSymbol;
+ friend class SBSymbolContext;
+ friend class SBTarget;
+ friend class SBThread;
+ friend class SBThreadPlan;
+ friend class SBValue;
+ friend class SBQueueItem;
+
+ lldb_private::Address *operator->();
+
+ const lldb_private::Address *operator->() const;
+
+ friend bool LLDB_API operator==(const SBAddress &lhs, const SBAddress &rhs);
+
+ lldb_private::Address *get();
+
+ lldb_private::Address &ref();
+
+ const lldb_private::Address &ref() const;
+
+ SBAddress(const lldb_private::Address *lldb_object_ptr);
+
+ void SetAddress(const lldb_private::Address *lldb_object_ptr);
+
+private:
+ std::unique_ptr<lldb_private::Address> m_opaque_up;
+};
+
+bool LLDB_API operator==(const SBAddress &lhs, const SBAddress &rhs);
+
+} // namespace lldb
+
+#endif // LLDB_SBAddress_h_
diff --git a/linux-x64/clang/include/lldb/API/SBAttachInfo.h b/linux-x64/clang/include/lldb/API/SBAttachInfo.h
new file mode 100644
index 0000000..3c20a08
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBAttachInfo.h
@@ -0,0 +1,177 @@
+//===-- SBAttachInfo.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_SBAttachInfo_h_
+#define LLDB_SBAttachInfo_h_
+
+#include "lldb/API/SBDefines.h"
+
+namespace lldb {
+
+class SBTarget;
+
+class LLDB_API SBAttachInfo {
+public:
+ SBAttachInfo();
+
+ SBAttachInfo(lldb::pid_t pid);
+
+ /// Attach to a process by name.
+ ///
+ /// This function implies that a future call to SBTarget::Attach(...)
+ /// will be synchronous.
+ ///
+ /// \param[in] path
+ /// A full or partial name for the process to attach to.
+ ///
+ /// \param[in] wait_for
+ /// If \b false, attach to an existing process whose name matches.
+ /// If \b true, then wait for the next process whose name matches.
+ SBAttachInfo(const char *path, bool wait_for);
+
+ /// Attach to a process by name.
+ ///
+ /// Future calls to SBTarget::Attach(...) will be synchronous or
+ /// asynchronous depending on the \a async argument.
+ ///
+ /// \param[in] path
+ /// A full or partial name for the process to attach to.
+ ///
+ /// \param[in] wait_for
+ /// If \b false, attach to an existing process whose name matches.
+ /// If \b true, then wait for the next process whose name matches.
+ ///
+ /// \param[in] async
+ /// If \b false, then the SBTarget::Attach(...) call will be a
+ /// synchronous call with no way to cancel the attach in
+ /// progress.
+ /// If \b true, then the SBTarget::Attach(...) function will
+ /// return immediately and clients are expected to wait for a
+ /// process eStateStopped event if a suitable process is
+ /// eventually found. If the client wants to cancel the event,
+ /// SBProcess::Stop() can be called and an eStateExited process
+ /// event will be delivered.
+ SBAttachInfo(const char *path, bool wait_for, bool async);
+
+ SBAttachInfo(const SBAttachInfo &rhs);
+
+ ~SBAttachInfo();
+
+ SBAttachInfo &operator=(const 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();
+
+ /// Set attach by process name settings.
+ ///
+ /// Designed to be used after a call to SBAttachInfo::SetExecutable().
+ /// This function implies that a call to SBTarget::Attach(...) will
+ /// be synchronous.
+ ///
+ /// \param[in] b
+ /// If \b false, attach to an existing process whose name matches.
+ /// If \b true, then wait for the next process whose name matches.
+ void SetWaitForLaunch(bool b);
+
+ /// Set attach by process name settings.
+ ///
+ /// Designed to be used after a call to SBAttachInfo::SetExecutable().
+ /// Future calls to SBTarget::Attach(...) will be synchronous or
+ /// asynchronous depending on the \a async argument.
+ ///
+ /// \param[in] b
+ /// If \b false, attach to an existing process whose name matches.
+ /// If \b true, then wait for the next process whose name matches.
+ ///
+ /// \param[in] async
+ /// If \b false, then the SBTarget::Attach(...) call will be a
+ /// synchronous call with no way to cancel the attach in
+ /// progress.
+ /// If \b true, then the SBTarget::Attach(...) function will
+ /// return immediately and clients are expected to wait for a
+ /// process eStateStopped event if a suitable process is
+ /// eventually found. If the client wants to cancel the event,
+ /// SBProcess::Stop() can be called and an eStateExited process
+ /// event will be delivered.
+ 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();
+
+ /// Get the listener that will be used to receive process events.
+ ///
+ /// If no listener has been set via a call to
+ /// SBAttachInfo::SetListener(), then an invalid SBListener will be
+ /// returned (SBListener::IsValid() will return false). If a listener
+ /// has been set, then the valid listener object will be returned.
+ SBListener GetListener();
+
+ /// Set the listener that will be used to receive process events.
+ ///
+ /// By default the SBDebugger, which has a listener, that the SBTarget
+ /// belongs to will listen for the process events. Calling this function
+ /// allows a different listener to be used to listen for process events.
+ void SetListener(SBListener &listener);
+
+protected:
+ friend class SBTarget;
+
+ lldb_private::ProcessAttachInfo &ref();
+
+ ProcessAttachInfoSP m_opaque_sp;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBAttachInfo_h_
diff --git a/linux-x64/clang/include/lldb/API/SBBlock.h b/linux-x64/clang/include/lldb/API/SBBlock.h
new file mode 100644
index 0000000..0ca92ff
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBBlock.h
@@ -0,0 +1,95 @@
+//===-- SBBlock.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_SBBlock_h_
+#define LLDB_SBBlock_h_
+
+#include "lldb/API/SBDefines.h"
+#include "lldb/API/SBFrame.h"
+#include "lldb/API/SBTarget.h"
+#include "lldb/API/SBValueList.h"
+
+namespace lldb {
+
+class LLDB_API SBBlock {
+public:
+ SBBlock();
+
+ SBBlock(const lldb::SBBlock &rhs);
+
+ ~SBBlock();
+
+ const lldb::SBBlock &operator=(const lldb::SBBlock &rhs);
+
+ bool IsInlined() const;
+
+ explicit operator bool() const;
+
+ bool IsValid() const;
+
+ const char *GetInlinedName() const;
+
+ lldb::SBFileSpec GetInlinedCallSiteFile() const;
+
+ uint32_t GetInlinedCallSiteLine() const;
+
+ uint32_t GetInlinedCallSiteColumn() const;
+
+ lldb::SBBlock GetParent();
+
+ lldb::SBBlock GetSibling();
+
+ 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);
+
+ 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);
+ /// Get the inlined block that contains this block.
+ ///
+ /// \return
+ /// If this block is inlined, it will return this block, else
+ /// parent blocks will be searched to see if any contain this
+ /// block and are themselves inlined. An invalid SBBlock will
+ /// be returned if this block nor any parent blocks are inlined
+ /// function blocks.
+ lldb::SBBlock GetContainingInlinedBlock();
+
+ bool GetDescription(lldb::SBStream &description);
+
+private:
+ friend class SBAddress;
+ friend class SBFrame;
+ friend class SBFunction;
+ friend class SBSymbolContext;
+
+ lldb_private::Block *GetPtr();
+
+ void SetPtr(lldb_private::Block *lldb_object_ptr);
+
+ SBBlock(lldb_private::Block *lldb_object_ptr);
+
+ void AppendVariables(bool can_create, bool get_parent_variables,
+ lldb_private::VariableList *var_list);
+
+ lldb_private::Block *m_opaque_ptr;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBBlock_h_
diff --git a/linux-x64/clang/include/lldb/API/SBBreakpoint.h b/linux-x64/clang/include/lldb/API/SBBreakpoint.h
new file mode 100644
index 0000000..75c0e69
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBBreakpoint.h
@@ -0,0 +1,181 @@
+//===-- SBBreakpoint.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_SBBreakpoint_h_
+#define LLDB_SBBreakpoint_h_
+
+#include "lldb/API/SBDefines.h"
+
+class SBBreakpointListImpl;
+
+namespace lldb {
+
+class LLDB_API SBBreakpoint {
+public:
+
+ SBBreakpoint();
+
+ SBBreakpoint(const lldb::SBBreakpoint &rhs);
+
+ SBBreakpoint(const lldb::BreakpointSP &bp_sp);
+
+ ~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);
+
+ bool operator!=(const lldb::SBBreakpoint &rhs);
+
+ break_id_t GetID() const;
+
+ explicit operator bool() const;
+
+ bool IsValid() const;
+
+ void ClearAllBreakpointSites();
+
+ 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() const;
+
+ bool IsInternal();
+
+ uint32_t GetHitCount() 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 SetCallback(SBBreakpointHitCallback callback, void *baton);
+
+ void SetScriptCallbackFunction(const char *callback_function_name);
+
+ void SetCommandLineCommands(SBStringList &commands);
+
+ bool GetCommandLineCommands(SBStringList &commands);
+
+ SBError SetScriptCallbackBody(const char *script_body_text);
+
+ bool AddName(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);
+
+ 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() const;
+
+ // Can only be called from a ScriptedBreakpointResolver...
+ SBError
+ AddLocation(SBAddress &address);
+
+private:
+ friend class SBBreakpointList;
+ friend class SBBreakpointLocation;
+ friend class SBBreakpointName;
+ friend class SBTarget;
+
+ lldb::BreakpointSP GetSP() const;
+
+ lldb::BreakpointWP m_opaque_wp;
+};
+
+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();
+
+protected:
+ friend class SBTarget;
+
+ void CopyToBreakpointIDList(lldb_private::BreakpointIDList &bp_id_list);
+
+private:
+ std::shared_ptr<SBBreakpointListImpl> m_opaque_sp;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBBreakpoint_h_
diff --git a/linux-x64/clang/include/lldb/API/SBBreakpointLocation.h b/linux-x64/clang/include/lldb/API/SBBreakpointLocation.h
new file mode 100644
index 0000000..085bed9
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBBreakpointLocation.h
@@ -0,0 +1,100 @@
+//===-- SBBreakpointLocation.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_SBBreakpointLocation_h_
+#define LLDB_SBBreakpointLocation_h_
+
+#include "lldb/API/SBBreakpoint.h"
+#include "lldb/API/SBDefines.h"
+
+namespace lldb {
+
+class LLDB_API SBBreakpointLocation {
+public:
+ SBBreakpointLocation();
+
+ SBBreakpointLocation(const lldb::SBBreakpointLocation &rhs);
+
+ ~SBBreakpointLocation();
+
+ const lldb::SBBreakpointLocation &
+ operator=(const lldb::SBBreakpointLocation &rhs);
+
+ break_id_t GetID();
+
+ explicit operator bool() const;
+
+ bool IsValid() 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);
+
+ void SetCondition(const char *condition);
+
+ const char *GetCondition();
+
+ void SetAutoContinue(bool auto_continue);
+
+ bool GetAutoContinue();
+
+ void SetScriptCallbackFunction(const char *callback_function_name);
+
+ 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();
+
+ SBBreakpointLocation(const lldb::BreakpointLocationSP &break_loc_sp);
+
+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_SBBreakpointLocation_h_
diff --git a/linux-x64/clang/include/lldb/API/SBBreakpointName.h b/linux-x64/clang/include/lldb/API/SBBreakpointName.h
new file mode 100644
index 0000000..018238b
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBBreakpointName.h
@@ -0,0 +1,119 @@
+//===-- 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_SBBreakpointName_h_
+#define LLDB_SBBreakpointName_h_
+
+#include "lldb/API/SBDefines.h"
+
+class SBBreakpointNameImpl;
+
+namespace lldb {
+
+class LLDB_API SBBreakpointName {
+public:
+// typedef bool (*BreakpointHitCallback)(void *baton, SBProcess &process,
+// SBThread &thread,
+// lldb::SBBreakpointLocation &location);
+
+ SBBreakpointName();
+
+ SBBreakpointName(SBTarget &target, const char *name);
+
+ SBBreakpointName(SBBreakpoint &bkpt, const char *name);
+
+ SBBreakpointName(const lldb::SBBreakpointName &rhs);
+
+ ~SBBreakpointName();
+
+ const lldb::SBBreakpointName &operator=(const lldb::SBBreakpointName &rhs);
+
+ // 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 SetCallback(SBBreakpointHitCallback callback, void *baton);
+
+ void SetScriptCallbackFunction(const char *callback_function_name);
+
+ 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);
+
+private:
+ friend class SBTarget;
+
+ lldb_private::BreakpointName *GetBreakpointName() const;
+ void UpdateName(lldb_private::BreakpointName &bp_name);
+
+ std::unique_ptr<SBBreakpointNameImpl> m_impl_up;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBBreakpointName_h_
diff --git a/linux-x64/clang/include/lldb/API/SBBroadcaster.h b/linux-x64/clang/include/lldb/API/SBBroadcaster.h
new file mode 100644
index 0000000..fc5e888
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBBroadcaster.h
@@ -0,0 +1,84 @@
+//===-- SBBroadcaster.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_SBBroadcaster_h_
+#define LLDB_SBBroadcaster_h_
+
+#include "lldb/API/SBDefines.h"
+
+namespace lldb {
+
+class LLDB_API SBBroadcaster {
+public:
+ SBBroadcaster();
+
+ SBBroadcaster(const char *name);
+
+ SBBroadcaster(const SBBroadcaster &rhs);
+
+ const SBBroadcaster &operator=(const SBBroadcaster &rhs);
+
+ ~SBBroadcaster();
+
+ explicit operator bool() const;
+
+ bool IsValid() 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);
+
+ // This comparison is checking if the internal opaque pointer value is equal
+ // to that in "rhs".
+ bool operator==(const lldb::SBBroadcaster &rhs) const;
+
+ // This comparison is checking if the internal opaque pointer value is not
+ // equal to that in "rhs".
+ bool operator!=(const lldb::SBBroadcaster &rhs) const;
+
+ // This comparison is checking if the internal opaque pointer value is less
+ // than that in "rhs" so SBBroadcaster objects can be contained in ordered
+ // containers.
+ bool operator<(const lldb::SBBroadcaster &rhs) const;
+
+protected:
+ friend class SBCommandInterpreter;
+ friend class SBCommunication;
+ friend class SBEvent;
+ friend class SBListener;
+ friend class SBProcess;
+ friend class SBTarget;
+
+ SBBroadcaster(lldb_private::Broadcaster *broadcaster, bool owns);
+
+ lldb_private::Broadcaster *get() const;
+
+ void reset(lldb_private::Broadcaster *broadcaster, bool owns);
+
+private:
+ lldb::BroadcasterSP m_opaque_sp;
+ lldb_private::Broadcaster *m_opaque_ptr;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBBroadcaster_h_
diff --git a/linux-x64/clang/include/lldb/API/SBCommandInterpreter.h b/linux-x64/clang/include/lldb/API/SBCommandInterpreter.h
new file mode 100644
index 0000000..6c80e8e
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBCommandInterpreter.h
@@ -0,0 +1,305 @@
+//===-- SBCommandInterpreter.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_SBCommandInterpreter_h_
+#define LLDB_SBCommandInterpreter_h_
+
+#include <memory>
+
+#include "lldb/API/SBDebugger.h"
+#include "lldb/API/SBDefines.h"
+
+namespace lldb {
+
+class LLDB_API SBCommandInterpreterRunOptions {
+ friend class SBDebugger;
+ friend class SBCommandInterpreter;
+
+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 GetEchoCommentCommands() const;
+
+ void SetEchoCommentCommands(bool echo);
+
+ bool GetPrintResults() const;
+
+ void SetPrintResults(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;
+};
+
+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();
+
+ const lldb::SBCommandInterpreter &
+ operator=(const lldb::SBCommandInterpreter &rhs);
+
+ 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);
+
+ explicit operator bool() const;
+
+ bool IsValid() const;
+
+ bool CommandExists(const char *cmd);
+
+ bool AliasExists(const char *cmd);
+
+ lldb::SBBroadcaster GetBroadcaster();
+
+ static const char *GetBroadcasterClass();
+
+ bool HasCommands();
+
+ bool HasAliases();
+
+ bool HasAliasOptions();
+
+ lldb::SBProcess GetProcess();
+
+ lldb::SBDebugger GetDebugger();
+
+ lldb::SBCommand AddMultiwordCommand(const char *name, const char *help);
+
+ lldb::SBCommand AddCommand(const char *name,
+ lldb::SBCommandPluginInterface *impl,
+ const char *help);
+
+ lldb::SBCommand AddCommand(const char *name,
+ lldb::SBCommandPluginInterface *impl,
+ const char *help, const char *syntax);
+
+ 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);
+
+ // The pointer based interface is not useful in SWIG, since the cursor &
+ // last_char arguments are string pointers INTO current_line and you can't do
+ // that in a scripting language interface in general...
+
+ // In either case, the way this works is that the you give it a line and
+ // cursor position in the line. The function will return the number of
+ // completions. The matches list will contain number_of_completions + 1
+ // elements. The first element is the common substring after the cursor
+ // position for all the matches. The rest of the elements are the matches.
+ // 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.
+
+ int HandleCompletion(const char *current_line, const char *cursor,
+ const char *last_char, int match_start_point,
+ int max_return_elements, lldb::SBStringList &matches);
+
+ 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.
+ 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);
+
+ 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
+ bool SetCommandOverrideCallback(const char *command_name,
+ lldb::CommandOverrideCallback callback,
+ void *baton);
+
+ SBCommandInterpreter(
+ lldb_private::CommandInterpreter *interpreter_ptr =
+ nullptr); // Access using SBDebugger::GetCommandInterpreter();
+
+ /// 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();
+
+ /// Get the string that needs to be written to the debugger stdin file
+ /// handle when a control character is typed.
+ ///
+ /// Some GUI programs will intercept "control + char" sequences and want
+ /// to have them do what normally would happen when using a real
+ /// terminal, so this function allows GUI programs to emulate this
+ /// functionality.
+ ///
+ /// \param[in] ch
+ /// The character that was typed along with the control key
+ ///
+ /// \return
+ /// The string that should be written into the file handle that is
+ /// feeding the input stream for the debugger, or nullptr if there is
+ /// no string for this control key.
+ const char *GetIOHandlerControlSequence(char ch);
+
+ bool GetPromptOnQuit();
+
+ void SetPromptOnQuit(bool b);
+
+ /// Sets whether the command interpreter should allow custom exit codes
+ /// for the 'quit' command.
+ void AllowExitCodeOnQuit(bool allow);
+
+ /// Returns true if the user has called the 'quit' command with a custom exit
+ /// code.
+ bool HasCustomQuitExitCode();
+
+ /// Returns the exit code that the user has specified when running the
+ /// 'quit' command. Returns 0 if the user hasn't called 'quit' at all or
+ /// without a custom exit code.
+ int GetQuitStatus();
+
+ /// Resolve the command just as HandleCommand would, expanding abbreviations
+ /// and aliases. If successful, result->GetOutput has the full expansion.
+ void ResolveCommand(const char *command_line, SBCommandReturnObject &result);
+
+protected:
+ lldb_private::CommandInterpreter &ref();
+
+ lldb_private::CommandInterpreter *get();
+
+ void reset(lldb_private::CommandInterpreter *);
+
+private:
+ friend class SBDebugger;
+
+ lldb_private::CommandInterpreter *m_opaque_ptr;
+};
+
+class SBCommandPluginInterface {
+public:
+ virtual ~SBCommandPluginInterface() = default;
+
+ virtual bool DoExecute(lldb::SBDebugger /*debugger*/, char ** /*command*/,
+ lldb::SBCommandReturnObject & /*result*/) {
+ return false;
+ }
+};
+
+class SBCommand {
+public:
+ SBCommand();
+
+ explicit operator bool() const;
+
+ bool IsValid();
+
+ const char *GetName();
+
+ const char *GetHelp();
+
+ const char *GetHelpLong();
+
+ void SetHelp(const char *);
+
+ void SetHelpLong(const char *);
+
+ uint32_t GetFlags();
+
+ void SetFlags(uint32_t flags);
+
+ lldb::SBCommand AddMultiwordCommand(const char *name,
+ const char *help = nullptr);
+
+ lldb::SBCommand AddCommand(const char *name,
+ lldb::SBCommandPluginInterface *impl,
+ const char *help = nullptr);
+
+ lldb::SBCommand AddCommand(const char *name,
+ lldb::SBCommandPluginInterface *impl,
+ const char *help, const char *syntax);
+
+private:
+ friend class SBDebugger;
+ friend class SBCommandInterpreter;
+
+ SBCommand(lldb::CommandObjectSP cmd_sp);
+
+ lldb::CommandObjectSP m_opaque_sp;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBCommandInterpreter_h_
diff --git a/linux-x64/clang/include/lldb/API/SBCommandReturnObject.h b/linux-x64/clang/include/lldb/API/SBCommandReturnObject.h
new file mode 100644
index 0000000..2877afb
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBCommandReturnObject.h
@@ -0,0 +1,109 @@
+//===-- SBCommandReturnObject.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_SBCommandReturnObject_h_
+#define LLDB_SBCommandReturnObject_h_
+
+#include <stdio.h>
+
+#include <memory>
+
+#include "lldb/API/SBDefines.h"
+
+namespace lldb {
+
+class LLDB_API SBCommandReturnObject {
+public:
+ SBCommandReturnObject();
+
+ SBCommandReturnObject(const lldb::SBCommandReturnObject &rhs);
+
+ ~SBCommandReturnObject();
+
+ const lldb::SBCommandReturnObject &
+ operator=(const lldb::SBCommandReturnObject &rhs);
+
+ SBCommandReturnObject(lldb_private::CommandReturnObject *ptr);
+
+ lldb_private::CommandReturnObject *Release();
+
+ explicit operator bool() const;
+
+ bool IsValid() const;
+
+ const char *GetOutput();
+
+ const char *GetError();
+
+ size_t PutOutput(FILE *fh);
+
+ size_t GetOutputSize();
+
+ size_t GetErrorSize();
+
+ size_t PutError(FILE *fh);
+
+ 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);
+
+ // deprecated, these two functions do not take ownership of file handle
+ void SetImmediateOutputFile(FILE *fh);
+
+ void SetImmediateErrorFile(FILE *fh);
+
+ void SetImmediateOutputFile(FILE *fh, bool transfer_ownership);
+
+ void SetImmediateErrorFile(FILE *fh, bool transfer_ownership);
+
+ void PutCString(const char *string, int len = -1);
+
+ size_t Printf(const char *format, ...) __attribute__((format(printf, 2, 3)));
+
+ 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);
+
+ void SetError(const char *error_cstr);
+
+protected:
+ friend class SBCommandInterpreter;
+ friend class SBOptions;
+
+ lldb_private::CommandReturnObject *operator->() const;
+
+ lldb_private::CommandReturnObject *get() const;
+
+ lldb_private::CommandReturnObject &operator*() const;
+
+ lldb_private::CommandReturnObject &ref() const;
+
+ void SetLLDBObjectPtr(lldb_private::CommandReturnObject *ptr);
+
+private:
+ std::unique_ptr<lldb_private::CommandReturnObject> m_opaque_up;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBCommandReturnObject_h_
diff --git a/linux-x64/clang/include/lldb/API/SBCommunication.h b/linux-x64/clang/include/lldb/API/SBCommunication.h
new file mode 100644
index 0000000..5b803fc
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBCommunication.h
@@ -0,0 +1,83 @@
+//===-- SBCommunication.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_SBCommunication_h_
+#define LLDB_SBCommunication_h_
+
+#include "lldb/API/SBDefines.h"
+#include "lldb/API/SBError.h"
+
+namespace lldb {
+
+class LLDB_API SBCommunication {
+public:
+ FLAGS_ANONYMOUS_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();
+
+ explicit operator bool() const;
+
+ bool IsValid() 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);
+
+private:
+ DISALLOW_COPY_AND_ASSIGN(SBCommunication);
+
+ lldb_private::Communication *m_opaque;
+ bool m_opaque_owned;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBCommunication_h_
diff --git a/linux-x64/clang/include/lldb/API/SBCompileUnit.h b/linux-x64/clang/include/lldb/API/SBCompileUnit.h
new file mode 100644
index 0000000..b6b1382
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBCompileUnit.h
@@ -0,0 +1,95 @@
+//===-- SBCompileUnit.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_SBCompileUnit_h_
+#define LLDB_SBCompileUnit_h_
+
+#include "lldb/API/SBDefines.h"
+#include "lldb/API/SBFileSpec.h"
+
+namespace lldb {
+
+class LLDB_API SBCompileUnit {
+public:
+ SBCompileUnit();
+
+ SBCompileUnit(const lldb::SBCompileUnit &rhs);
+
+ ~SBCompileUnit();
+
+ const lldb::SBCompileUnit &operator=(const lldb::SBCompileUnit &rhs);
+
+ explicit operator bool() const;
+
+ bool IsValid() const;
+
+ lldb::SBFileSpec GetFileSpec() const;
+
+ uint32_t GetNumLineEntries() const;
+
+ lldb::SBLineEntry GetLineEntryAtIndex(uint32_t idx) 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);
+
+ /// Get all types matching \a 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 \a type_mask
+ lldb::SBTypeList GetTypes(uint32_t type_mask = lldb::eTypeClassAny);
+
+ lldb::LanguageType GetLanguage();
+
+ bool operator==(const lldb::SBCompileUnit &rhs) const;
+
+ bool operator!=(const lldb::SBCompileUnit &rhs) const;
+
+ bool GetDescription(lldb::SBStream &description);
+
+private:
+ friend class SBAddress;
+ friend class SBFrame;
+ friend class SBSymbolContext;
+ friend class SBModule;
+
+ SBCompileUnit(lldb_private::CompileUnit *lldb_object_ptr);
+
+ const lldb_private::CompileUnit *operator->() const;
+
+ const lldb_private::CompileUnit &operator*() const;
+
+ lldb_private::CompileUnit *get();
+
+ void reset(lldb_private::CompileUnit *lldb_object_ptr);
+
+ lldb_private::CompileUnit *m_opaque_ptr;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBCompileUnit_h_
diff --git a/linux-x64/clang/include/lldb/API/SBData.h b/linux-x64/clang/include/lldb/API/SBData.h
new file mode 100644
index 0000000..886fe82
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBData.h
@@ -0,0 +1,155 @@
+//===-- SBData.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_SBData_h_
+#define LLDB_SBData_h_
+
+#include "lldb/API/SBDefines.h"
+
+namespace lldb {
+
+class LLDB_API SBData {
+public:
+ SBData();
+
+ SBData(const SBData &rhs);
+
+ const SBData &operator=(const SBData &rhs);
+
+ ~SBData();
+
+ uint8_t GetAddressByteSize();
+
+ void SetAddressByteSize(uint8_t addr_byte_size);
+
+ void Clear();
+
+ explicit operator bool() const;
+
+ bool IsValid();
+
+ 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);
+
+ size_t ReadRawData(lldb::SBError &error, lldb::offset_t offset, void *buf,
+ size_t size);
+
+ bool GetDescription(lldb::SBStream &description,
+ lldb::addr_t base_addr = LLDB_INVALID_ADDRESS);
+
+ // it would be nice to have SetData(SBError, const void*, size_t) when
+ // endianness and address size can be inferred from the existing
+ // DataExtractor, but having two SetData() signatures triggers a SWIG bug
+ // where the typemap isn't applied before resolving the overload, and thus
+ // the right function never gets called
+ void SetData(lldb::SBError &error, const void *buf, size_t size,
+ lldb::ByteOrder endian, uint8_t addr_size);
+
+ // see SetData() for why we don't have Append(const void* buf, size_t 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);
+
+protected:
+ // Mimic shared pointer...
+ lldb_private::DataExtractor *get() const;
+
+ lldb_private::DataExtractor *operator->() const;
+
+ lldb::DataExtractorSP &operator*();
+
+ const lldb::DataExtractorSP &operator*() const;
+
+ SBData(const lldb::DataExtractorSP &data_sp);
+
+ void SetOpaque(const lldb::DataExtractorSP &data_sp);
+
+private:
+ friend class SBInstruction;
+ friend class SBProcess;
+ friend class SBSection;
+ friend class SBTarget;
+ friend class SBValue;
+
+ lldb::DataExtractorSP m_opaque_sp;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBData_h_
diff --git a/linux-x64/clang/include/lldb/API/SBDebugger.h b/linux-x64/clang/include/lldb/API/SBDebugger.h
new file mode 100644
index 0000000..417cead
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBDebugger.h
@@ -0,0 +1,297 @@
+//===-- SBDebugger.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_SBDebugger_h_
+#define LLDB_SBDebugger_h_
+
+#include <stdio.h>
+
+#include "lldb/API/SBDefines.h"
+#include "lldb/API/SBPlatform.h"
+
+namespace lldb {
+
+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;
+};
+
+class LLDB_API SBDebugger {
+public:
+ SBDebugger();
+
+ SBDebugger(const lldb::SBDebugger &rhs);
+
+ SBDebugger(const lldb::DebuggerSP &debugger_sp);
+
+ ~SBDebugger();
+
+ lldb::SBDebugger &operator=(const lldb::SBDebugger &rhs);
+
+ static void Initialize();
+
+ static lldb::SBError InitializeWithErrorHandling();
+
+ static void Terminate();
+
+ // Deprecated, use the one that takes a source_init_files bool.
+ 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();
+
+ explicit operator bool() const;
+
+ bool IsValid() const;
+
+ void Clear();
+
+ void SetAsync(bool b);
+
+ bool GetAsync();
+
+ void SkipLLDBInitFiles(bool b);
+
+ void SkipAppInitFiles(bool b);
+
+ void SetInputFileHandle(FILE *f, bool transfer_ownership);
+
+ void SetOutputFileHandle(FILE *f, bool transfer_ownership);
+
+ void SetErrorFileHandle(FILE *f, bool transfer_ownership);
+
+ FILE *GetInputFileHandle();
+
+ FILE *GetOutputFileHandle();
+
+ FILE *GetErrorFileHandle();
+
+ void SaveInputTerminalState();
+
+ void RestoreInputTerminalState();
+
+ lldb::SBCommandInterpreter GetCommandInterpreter();
+
+ void HandleCommand(const char *command);
+
+ lldb::SBListener GetListener();
+
+ void HandleProcessEvent(const lldb::SBProcess &process,
+ const lldb::SBEvent &event, FILE *out, FILE *err);
+
+ 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);
+
+ lldb::SBTarget CreateTargetWithFileAndArch(const char *filename,
+ const char *archname);
+
+ lldb::SBTarget CreateTarget(const char *filename);
+
+ lldb::SBTarget GetDummyTarget();
+
+ // Return true if target is deleted from the target list of the debugger.
+ 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(SBTarget &target);
+
+ lldb::SBPlatform GetSelectedPlatform();
+
+ void SetSelectedPlatform(lldb::SBPlatform &platform);
+
+ /// Get the number of currently active platforms.
+ uint32_t GetNumPlatforms();
+
+ /// Get one of the currently active platforms.
+ lldb::SBPlatform GetPlatformAtIndex(uint32_t idx);
+
+ /// Get the number of available platforms.
+ ///
+ /// The return value should match the number of entries output by the
+ /// "platform list" command.
+ uint32_t GetNumAvailablePlatforms();
+
+ /// Get the name and description of one of the available platforms.
+ ///
+ /// \param[in] idx
+ /// Zero-based index of the platform for which info should be retrieved,
+ /// must be less than the value returned by GetNumAvailablePlatforms().
+ 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 **categories);
+
+ void SetLoggingCallback(lldb::LogOutputCallback log_callback, void *baton);
+
+ // DEPRECATED
+ void DispatchInput(void *baton, const void *data, size_t data_len);
+
+ void DispatchInput(const void *data, size_t data_len);
+
+ void DispatchInputInterrupt();
+
+ void DispatchInputEndOfFile();
+
+ void PushInputReader(lldb::SBInputReader &reader);
+
+ 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);
+
+ SBTypeCategory GetCategory(const char *category_name);
+
+ SBTypeCategory GetCategory(lldb::LanguageType lang_type);
+
+ SBTypeCategory CreateCategory(const char *category_name);
+
+ bool DeleteCategory(const char *category_name);
+
+ uint32_t GetNumCategories();
+
+ SBTypeCategory GetCategoryAtIndex(uint32_t);
+
+ SBTypeCategory GetDefaultCategory();
+
+ SBTypeFormat GetFormatForType(SBTypeNameSpecifier);
+
+ SBTypeSummary GetSummaryForType(SBTypeNameSpecifier);
+
+ SBTypeFilter GetFilterForType(SBTypeNameSpecifier);
+
+ SBTypeSynthetic GetSyntheticForType(SBTypeNameSpecifier);
+
+ void RunCommandInterpreter(bool auto_handle_events, bool spawn_thread);
+
+ void RunCommandInterpreter(bool auto_handle_events, bool spawn_thread,
+ SBCommandInterpreterRunOptions &options,
+ int &num_errors, bool &quit_requested,
+ bool &stopped_for_crash);
+
+ SBError RunREPL(lldb::LanguageType language, const char *repl_options);
+
+private:
+ friend class SBCommandInterpreter;
+ friend class SBInputReader;
+ friend class SBListener;
+ friend class SBProcess;
+ friend class SBSourceManager;
+ friend class SBTarget;
+
+ lldb::SBTarget FindTargetWithLLDBProcess(const lldb::ProcessSP &processSP);
+
+ void reset(const lldb::DebuggerSP &debugger_sp);
+
+ lldb_private::Debugger *get() const;
+
+ lldb_private::Debugger &ref() const;
+
+ const lldb::DebuggerSP &get_sp() const;
+
+ lldb::DebuggerSP m_opaque_sp;
+
+}; // class SBDebugger
+
+} // namespace lldb
+
+#endif // LLDB_SBDebugger_h_
diff --git a/linux-x64/clang/include/lldb/API/SBDeclaration.h b/linux-x64/clang/include/lldb/API/SBDeclaration.h
new file mode 100644
index 0000000..d2b423e
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBDeclaration.h
@@ -0,0 +1,71 @@
+//===-- SBDeclaration.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_SBDeclaration_h_
+#define LLDB_SBDeclaration_h_
+
+#include "lldb/API/SBDefines.h"
+#include "lldb/API/SBFileSpec.h"
+
+namespace lldb {
+
+class LLDB_API SBDeclaration {
+public:
+ SBDeclaration();
+
+ SBDeclaration(const lldb::SBDeclaration &rhs);
+
+ ~SBDeclaration();
+
+ const lldb::SBDeclaration &operator=(const lldb::SBDeclaration &rhs);
+
+ explicit operator bool() const;
+
+ bool IsValid() const;
+
+ lldb::SBFileSpec GetFileSpec() const;
+
+ uint32_t GetLine() const;
+
+ uint32_t GetColumn() const;
+
+ 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;
+
+ bool GetDescription(lldb::SBStream &description);
+
+protected:
+ lldb_private::Declaration *get();
+
+private:
+ friend class SBValue;
+
+ const lldb_private::Declaration *operator->() const;
+
+ lldb_private::Declaration &ref();
+
+ const lldb_private::Declaration &ref() const;
+
+ SBDeclaration(const lldb_private::Declaration *lldb_object_ptr);
+
+ void SetDeclaration(const lldb_private::Declaration &lldb_object_ref);
+
+ std::unique_ptr<lldb_private::Declaration> m_opaque_up;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBDeclaration_h_
diff --git a/linux-x64/clang/include/lldb/API/SBDefines.h b/linux-x64/clang/include/lldb/API/SBDefines.h
new file mode 100644
index 0000000..838c84c
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBDefines.h
@@ -0,0 +1,101 @@
+//===-- SBDefines.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_SBDefines_h_
+#define LLDB_SBDefines_h_
+
+
+#include "lldb/lldb-defines.h"
+#include "lldb/lldb-enumerations.h"
+#include "lldb/lldb-forward.h"
+#include "lldb/lldb-types.h"
+#include "lldb/lldb-versioning.h"
+
+// Forward Declarations
+namespace lldb {
+
+class LLDB_API SBAddress;
+class LLDB_API SBBlock;
+class LLDB_API SBBreakpoint;
+class LLDB_API SBBreakpointLocation;
+class LLDB_API SBBreakpointName;
+class LLDB_API SBBreakpointNameImpl;
+class LLDB_API SBBroadcaster;
+class LLDB_API SBCommand;
+class LLDB_API SBCommandInterpreter;
+class LLDB_API SBCommandInterpreterRunOptions;
+class LLDB_API SBCommandPluginInterface;
+class LLDB_API SBCommandReturnObject;
+class LLDB_API SBCommunication;
+class LLDB_API SBCompileUnit;
+class LLDB_API SBData;
+class LLDB_API SBDebugger;
+class LLDB_API SBDeclaration;
+class LLDB_API SBError;
+class LLDB_API SBEvent;
+class LLDB_API SBEventList;
+class LLDB_API SBExecutionContext;
+class LLDB_API SBExpressionOptions;
+class LLDB_API SBFileSpec;
+class LLDB_API SBFileSpecList;
+class LLDB_API SBFrame;
+class LLDB_API SBFunction;
+class LLDB_API SBHostOS;
+class LLDB_API SBInstruction;
+class LLDB_API SBInstructionList;
+class LLDB_API SBLanguageRuntime;
+class LLDB_API SBLaunchInfo;
+class LLDB_API SBLineEntry;
+class LLDB_API SBListener;
+class LLDB_API SBMemoryRegionInfo;
+class LLDB_API SBMemoryRegionInfoList;
+class LLDB_API SBModule;
+class LLDB_API SBModuleSpec;
+class LLDB_API SBModuleSpecList;
+class LLDB_API SBProcess;
+class LLDB_API SBProcessInfo;
+class LLDB_API SBQueue;
+class LLDB_API SBQueueItem;
+class LLDB_API SBSection;
+class LLDB_API SBSourceManager;
+class LLDB_API SBStream;
+class LLDB_API SBStringList;
+class LLDB_API SBStructuredData;
+class LLDB_API SBSymbol;
+class LLDB_API SBSymbolContext;
+class LLDB_API SBSymbolContextList;
+class LLDB_API SBTarget;
+class LLDB_API SBThread;
+class LLDB_API SBThreadCollection;
+class LLDB_API SBThreadPlan;
+class LLDB_API SBTrace;
+class LLDB_API SBTraceOptions;
+class LLDB_API SBType;
+class LLDB_API SBTypeCategory;
+class LLDB_API SBTypeEnumMember;
+class LLDB_API SBTypeEnumMemberList;
+class LLDB_API SBTypeFilter;
+class LLDB_API SBTypeFormat;
+class LLDB_API SBTypeMemberFunction;
+class LLDB_API SBTypeNameSpecifier;
+class LLDB_API SBTypeSummary;
+class LLDB_API SBTypeSummaryOptions;
+class LLDB_API SBTypeSynthetic;
+class LLDB_API SBTypeList;
+class LLDB_API SBValue;
+class LLDB_API SBValueList;
+class LLDB_API SBVariablesOptions;
+class LLDB_API SBWatchpoint;
+class LLDB_API SBUnixSignals;
+
+typedef bool (*SBBreakpointHitCallback)(void *baton, SBProcess &process,
+ SBThread &thread,
+ lldb::SBBreakpointLocation &location);
+}
+
+#endif // LLDB_SBDefines_h_
diff --git a/linux-x64/clang/include/lldb/API/SBError.h b/linux-x64/clang/include/lldb/API/SBError.h
new file mode 100644
index 0000000..b076f87
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBError.h
@@ -0,0 +1,92 @@
+//===-- SBError.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_SBError_h_
+#define LLDB_SBError_h_
+
+#include "lldb/API/SBDefines.h"
+
+namespace lldb {
+
+class LLDB_API SBError {
+public:
+ SBError();
+
+ SBError(const lldb::SBError &rhs);
+
+ ~SBError();
+
+ const SBError &operator=(const lldb::SBError &rhs);
+
+ 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);
+
+ int SetErrorStringWithFormat(const char *format, ...)
+ __attribute__((format(printf, 2, 3)));
+
+ explicit operator bool() const;
+
+ bool IsValid() const;
+
+ bool GetDescription(lldb::SBStream &description);
+
+protected:
+ friend class SBBreakpoint;
+ friend class SBBreakpointLocation;
+ friend class SBBreakpointName;
+ friend class SBCommandReturnObject;
+ friend class SBCommunication;
+ friend class SBData;
+ friend class SBDebugger;
+ friend class SBHostOS;
+ friend class SBPlatform;
+ friend class SBProcess;
+ friend class SBReproducer;
+ friend class SBStructuredData;
+ friend class SBTarget;
+ friend class SBThread;
+ friend class SBTrace;
+ friend class SBValue;
+ friend class SBWatchpoint;
+
+ lldb_private::Status *get();
+
+ lldb_private::Status *operator->();
+
+ const lldb_private::Status &operator*() const;
+
+ lldb_private::Status &ref();
+
+ void SetError(const lldb_private::Status &lldb_error);
+
+private:
+ std::unique_ptr<lldb_private::Status> m_opaque_up;
+
+ void CreateIfNeeded();
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBError_h_
diff --git a/linux-x64/clang/include/lldb/API/SBEvent.h b/linux-x64/clang/include/lldb/API/SBEvent.h
new file mode 100644
index 0000000..d297cbe
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBEvent.h
@@ -0,0 +1,87 @@
+//===-- SBEvent.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_SBEvent_h_
+#define LLDB_SBEvent_h_
+
+#include "lldb/API/SBDefines.h"
+
+#include <stdio.h>
+#include <vector>
+
+namespace lldb {
+
+class SBBroadcaster;
+
+class LLDB_API SBEvent {
+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);
+
+ SBEvent(lldb::EventSP &event_sp);
+
+ SBEvent(lldb_private::Event *event_sp);
+
+ ~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;
+
+ bool BroadcasterMatchesPtr(const lldb::SBBroadcaster *broadcaster);
+
+ bool BroadcasterMatchesRef(const lldb::SBBroadcaster &broadcaster);
+
+ void Clear();
+
+ static const char *GetCStringFromEvent(const lldb::SBEvent &event);
+
+ bool GetDescription(lldb::SBStream &description);
+
+ bool GetDescription(lldb::SBStream &description) const;
+
+protected:
+ friend class SBListener;
+ friend class SBBroadcaster;
+ friend class SBBreakpoint;
+ friend class SBDebugger;
+ friend class SBProcess;
+ friend class SBTarget;
+ friend class SBThread;
+ friend class SBWatchpoint;
+
+ lldb::EventSP &GetSP() const;
+
+ void reset(lldb::EventSP &event_sp);
+
+ void reset(lldb_private::Event *event);
+
+ lldb_private::Event *get() const;
+
+private:
+ mutable lldb::EventSP m_event_sp;
+ mutable lldb_private::Event *m_opaque_ptr;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBEvent_h_
diff --git a/linux-x64/clang/include/lldb/API/SBExecutionContext.h b/linux-x64/clang/include/lldb/API/SBExecutionContext.h
new file mode 100644
index 0000000..45c0b1b
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBExecutionContext.h
@@ -0,0 +1,63 @@
+//===-- SBExecutionContext.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_SBExecutionContext_h_
+#define LLDB_SBExecutionContext_h_
+
+#include "lldb/API/SBDefines.h"
+
+#include <stdio.h>
+#include <vector>
+
+namespace lldb {
+
+class LLDB_API SBExecutionContext {
+ friend class SBCommandInterpreter;
+
+public:
+ SBExecutionContext();
+
+ SBExecutionContext(const lldb::SBExecutionContext &rhs);
+
+ SBExecutionContext(lldb::ExecutionContextRefSP exe_ctx_ref_sp);
+
+ 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();
+
+ const SBExecutionContext &operator=(const lldb::SBExecutionContext &rhs);
+
+ SBTarget GetTarget() const;
+
+ SBProcess GetProcess() const;
+
+ SBThread GetThread() const;
+
+ SBFrame GetFrame() const;
+
+protected:
+ void reset(lldb::ExecutionContextRefSP &event_sp);
+
+ lldb_private::ExecutionContextRef *get() const;
+
+private:
+ mutable lldb::ExecutionContextRefSP m_exe_ctx_sp;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBExecutionContext_h_
diff --git a/linux-x64/clang/include/lldb/API/SBExpressionOptions.h b/linux-x64/clang/include/lldb/API/SBExpressionOptions.h
new file mode 100644
index 0000000..04cd74f
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBExpressionOptions.h
@@ -0,0 +1,115 @@
+//===-- SBExpressionOptions.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_SBExpressionOptions_h_
+#define LLDB_SBExpressionOptions_h_
+
+#include "lldb/API/SBDefines.h"
+
+#include <vector>
+
+namespace lldb {
+
+class LLDB_API SBExpressionOptions {
+public:
+ SBExpressionOptions();
+
+ SBExpressionOptions(const lldb::SBExpressionOptions &rhs);
+
+ ~SBExpressionOptions();
+
+ const SBExpressionOptions &operator=(const lldb::SBExpressionOptions &rhs);
+
+ bool GetCoerceResultToId() const;
+
+ void SetCoerceResultToId(bool coerce = true);
+
+ bool GetUnwindOnError() const;
+
+ void SetUnwindOnError(bool unwind = true);
+
+ bool GetIgnoreBreakpoints() const;
+
+ void SetIgnoreBreakpoints(bool ignore = true);
+
+ lldb::DynamicValueType GetFetchDynamicValue() const;
+
+ void SetFetchDynamicValue(
+ lldb::DynamicValueType dynamic = lldb::eDynamicCanRunTarget);
+
+ uint32_t GetTimeoutInMicroSeconds() const;
+
+ // Set the timeout for the expression, 0 means wait forever.
+ void SetTimeoutInMicroSeconds(uint32_t timeout = 0);
+
+ uint32_t GetOneThreadTimeoutInMicroSeconds() const;
+
+ // Set the timeout for running on one thread, 0 means use the default
+ // behavior. If you set this higher than the overall timeout, you'll get an
+ // error when you try to run the expression.
+ void SetOneThreadTimeoutInMicroSeconds(uint32_t timeout = 0);
+
+ bool GetTryAllThreads() const;
+
+ void SetTryAllThreads(bool run_others = true);
+
+ bool GetStopOthers() const;
+
+ void SetStopOthers(bool stop_others = true);
+
+ bool GetTrapExceptions() const;
+
+ void SetTrapExceptions(bool trap_exceptions = true);
+
+ void SetLanguage(lldb::LanguageType language);
+
+ void SetCancelCallback(lldb::ExpressionCancelCallback callback, void *baton);
+
+ bool GetGenerateDebugInfo();
+
+ void SetGenerateDebugInfo(bool b = true);
+
+ bool GetSuppressPersistentResult();
+
+ void SetSuppressPersistentResult(bool b = false);
+
+ const char *GetPrefix() const;
+
+ void SetPrefix(const char *prefix);
+
+ void SetAutoApplyFixIts(bool b = true);
+
+ bool GetAutoApplyFixIts();
+
+ bool GetTopLevel();
+
+ void SetTopLevel(bool b = true);
+
+ // Gets whether we will JIT an expression if it cannot be interpreted
+ bool GetAllowJIT();
+
+ // Sets whether we will JIT an expression if it cannot be interpreted
+ void SetAllowJIT(bool allow);
+
+protected:
+ lldb_private::EvaluateExpressionOptions *get() const;
+
+ lldb_private::EvaluateExpressionOptions &ref() const;
+
+ friend class SBFrame;
+ friend class SBValue;
+ friend class SBTarget;
+
+private:
+ // This auto_pointer is made in the constructor and is always valid.
+ mutable std::unique_ptr<lldb_private::EvaluateExpressionOptions> m_opaque_up;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBExpressionOptions_h_
diff --git a/linux-x64/clang/include/lldb/API/SBFileSpec.h b/linux-x64/clang/include/lldb/API/SBFileSpec.h
new file mode 100644
index 0000000..2714977
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBFileSpec.h
@@ -0,0 +1,95 @@
+//===-- SBFileSpec.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_SBFileSpec_h_
+#define LLDB_SBFileSpec_h_
+
+#include "lldb/API/SBDefines.h"
+
+namespace lldb {
+
+class LLDB_API 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();
+
+ const SBFileSpec &operator=(const lldb::SBFileSpec &rhs);
+
+ explicit operator bool() const;
+
+ bool operator==(const SBFileSpec &rhs) const;
+
+ bool operator!=(const SBFileSpec &rhs) const;
+
+ bool IsValid() 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);
+
+private:
+ friend class SBAttachInfo;
+ friend class SBBlock;
+ friend class SBCommandInterpreter;
+ friend class SBCompileUnit;
+ friend class SBDeclaration;
+ friend class SBFileSpecList;
+ friend class SBHostOS;
+ friend class SBLaunchInfo;
+ friend class SBLineEntry;
+ friend class SBModule;
+ friend class SBModuleSpec;
+ friend class SBPlatform;
+ friend class SBProcess;
+ friend class SBProcessInfo;
+ friend class SBSourceManager;
+ friend class SBTarget;
+ friend class SBThread;
+
+ SBFileSpec(const lldb_private::FileSpec &fspec);
+
+ void SetFileSpec(const lldb_private::FileSpec &fspec);
+
+ const lldb_private::FileSpec *operator->() const;
+
+ const lldb_private::FileSpec *get() const;
+
+ const lldb_private::FileSpec &operator*() const;
+
+ const lldb_private::FileSpec &ref() const;
+
+ std::unique_ptr<lldb_private::FileSpec> m_opaque_up;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBFileSpec_h_
diff --git a/linux-x64/clang/include/lldb/API/SBFileSpecList.h b/linux-x64/clang/include/lldb/API/SBFileSpecList.h
new file mode 100644
index 0000000..5a13150
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBFileSpecList.h
@@ -0,0 +1,57 @@
+//===-- SBFileSpecList.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_SBFileSpecList_h_
+#define LLDB_SBFileSpecList_h_
+
+#include "lldb/API/SBDefines.h"
+
+namespace lldb {
+
+class LLDB_API SBFileSpecList {
+public:
+ SBFileSpecList();
+
+ SBFileSpecList(const lldb::SBFileSpecList &rhs);
+
+ ~SBFileSpecList();
+
+ const SBFileSpecList &operator=(const lldb::SBFileSpecList &rhs);
+
+ 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;
+
+private:
+ friend class SBTarget;
+
+ const lldb_private::FileSpecList *operator->() const;
+
+ const lldb_private::FileSpecList *get() const;
+
+ const lldb_private::FileSpecList &operator*() const;
+
+ const lldb_private::FileSpecList &ref() const;
+
+ std::unique_ptr<lldb_private::FileSpecList> m_opaque_up;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBFileSpecList_h_
diff --git a/linux-x64/clang/include/lldb/API/SBFrame.h b/linux-x64/clang/include/lldb/API/SBFrame.h
new file mode 100644
index 0000000..b213f89
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBFrame.h
@@ -0,0 +1,205 @@
+//===-- SBFrame.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_SBFrame_h_
+#define LLDB_SBFrame_h_
+
+#include "lldb/API/SBDefines.h"
+#include "lldb/API/SBValueList.h"
+
+namespace lldb {
+
+class LLDB_API SBFrame {
+public:
+ SBFrame();
+
+ SBFrame(const lldb::SBFrame &rhs);
+
+ const lldb::SBFrame &operator=(const lldb::SBFrame &rhs);
+
+ ~SBFrame();
+
+ bool IsEqual(const lldb::SBFrame &that) const;
+
+ explicit operator bool() const;
+
+ bool IsValid() const;
+
+ uint32_t GetFrameID() const;
+
+ 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;
+
+ /// Gets the deepest block that contains the frame PC.
+ ///
+ /// See also GetFrameBlock().
+ lldb::SBBlock GetBlock() const;
+
+ /// 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().
+ const char *GetFunctionName();
+
+ // Get an appropriate function name for this frame that is suitable for
+ // display to a user
+ const char *GetDisplayFunctionName();
+
+ const char *GetFunctionName() const;
+
+ // Return the frame function's language. If there isn't a function, then
+ // guess the language type from the mangled name.
+ lldb::LanguageType GuessLanguage() const;
+
+ /// Return true if this frame represents an inlined function.
+ ///
+ /// See also GetFunctionName().
+ bool IsInlined();
+
+ bool IsInlined() const;
+
+ bool IsArtificial();
+
+ bool IsArtificial() const;
+
+ /// The version that doesn't supply a 'use_dynamic' value will use the
+ /// target's default.
+ 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,
+ const SBExpressionOptions &options);
+
+ /// 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::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;
+
+ /// The version that doesn't supply a 'use_dynamic' value will use the
+ /// target's default.
+ 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();
+
+ lldb::SBValue FindRegister(const char *name);
+
+ /// The version that doesn't supply a 'use_dynamic' value will use the
+ /// target's default.
+ lldb::SBValue FindVariable(const char *var_name);
+
+ lldb::SBValue FindVariable(const char *var_name,
+ lldb::DynamicValueType use_dynamic);
+
+ // Find a value for a variable expression path like "rect.origin.x" or
+ // "pt_ptr->x", "*self", "*this->obj_ptr". The returned value is _not_ and
+ // expression result and is not a constant object like
+ // SBFrame::EvaluateExpression(...) returns, but a child object of the
+ // variable value.
+ lldb::SBValue GetValueForVariablePath(const char *var_expr_cstr,
+ DynamicValueType use_dynamic);
+
+ /// The version that doesn't supply a 'use_dynamic' value will use the
+ /// target's default.
+ lldb::SBValue GetValueForVariablePath(const char *var_path);
+
+ /// Find variables, register sets, registers, or persistent variables using
+ /// the frame as the scope.
+ ///
+ /// NB. This function does not look up ivars in the function object pointer.
+ /// To do that use GetValueForVariablePath.
+ ///
+ /// The version that doesn't supply a 'use_dynamic' value will use the
+ /// 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);
+
+ SBFrame(const lldb::StackFrameSP &lldb_object_sp);
+
+protected:
+ friend class SBBlock;
+ friend class SBExecutionContext;
+ friend class SBInstruction;
+ friend class SBThread;
+ friend class SBValue;
+
+ lldb::StackFrameSP GetFrameSP() const;
+
+ void SetFrameSP(const lldb::StackFrameSP &lldb_object_sp);
+
+ lldb::ExecutionContextRefSP m_opaque_sp;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBFrame_h_
diff --git a/linux-x64/clang/include/lldb/API/SBFunction.h b/linux-x64/clang/include/lldb/API/SBFunction.h
new file mode 100644
index 0000000..43f01d7
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBFunction.h
@@ -0,0 +1,82 @@
+//===-- SBFunction.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_SBFunction_h_
+#define LLDB_SBFunction_h_
+
+#include "lldb/API/SBAddress.h"
+#include "lldb/API/SBDefines.h"
+#include "lldb/API/SBInstructionList.h"
+
+namespace lldb {
+
+class LLDB_API SBFunction {
+public:
+ SBFunction();
+
+ SBFunction(const lldb::SBFunction &rhs);
+
+ const lldb::SBFunction &operator=(const lldb::SBFunction &rhs);
+
+ ~SBFunction();
+
+ explicit operator bool() const;
+
+ bool IsValid() 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();
+
+ bool GetIsOptimized();
+
+ bool operator==(const lldb::SBFunction &rhs) const;
+
+ bool operator!=(const lldb::SBFunction &rhs) const;
+
+ bool GetDescription(lldb::SBStream &description);
+
+protected:
+ lldb_private::Function *get();
+
+ void reset(lldb_private::Function *lldb_object_ptr);
+
+private:
+ friend class SBAddress;
+ friend class SBFrame;
+ friend class SBSymbolContext;
+
+ SBFunction(lldb_private::Function *lldb_object_ptr);
+
+ lldb_private::Function *m_opaque_ptr;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBFunction_h_
diff --git a/linux-x64/clang/include/lldb/API/SBHostOS.h b/linux-x64/clang/include/lldb/API/SBHostOS.h
new file mode 100644
index 0000000..ecd7920
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBHostOS.h
@@ -0,0 +1,44 @@
+//===-- SBHostOS.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_SBHostOS_h_
+#define LLDB_SBHostOS_h_
+
+#include "lldb/API/SBDefines.h"
+#include "lldb/API/SBFileSpec.h"
+
+namespace lldb {
+
+class LLDB_API 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 thread_function,
+ 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);
+
+private:
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBHostOS_h_
diff --git a/linux-x64/clang/include/lldb/API/SBInstruction.h b/linux-x64/clang/include/lldb/API/SBInstruction.h
new file mode 100644
index 0000000..0bb5877
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBInstruction.h
@@ -0,0 +1,85 @@
+//===-- SBInstruction.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_SBInstruction_h_
+#define LLDB_SBInstruction_h_
+
+#include "lldb/API/SBData.h"
+#include "lldb/API/SBDefines.h"
+
+#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.
+
+class InstructionImpl;
+
+namespace lldb {
+
+class LLDB_API SBInstruction {
+public:
+ SBInstruction();
+
+ SBInstruction(const SBInstruction &rhs);
+
+ const SBInstruction &operator=(const SBInstruction &rhs);
+
+ ~SBInstruction();
+
+ explicit operator bool() const;
+
+ bool IsValid();
+
+ SBAddress GetAddress();
+
+ const char *GetMnemonic(lldb::SBTarget target);
+
+ const char *GetOperands(lldb::SBTarget target);
+
+ const char *GetComment(lldb::SBTarget target);
+
+ lldb::SBData GetData(lldb::SBTarget target);
+
+ size_t GetByteSize();
+
+ bool DoesBranch();
+
+ bool HasDelaySlot();
+
+ bool CanSetBreakpoint();
+
+ void Print(FILE *out);
+
+ 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);
+
+protected:
+ friend class SBInstructionList;
+
+ SBInstruction(const lldb::DisassemblerSP &disasm_sp,
+ const lldb::InstructionSP &inst_sp);
+
+ void SetOpaque(const lldb::DisassemblerSP &disasm_sp,
+ const lldb::InstructionSP &inst_sp);
+
+ lldb::InstructionSP GetOpaque();
+
+private:
+ std::shared_ptr<InstructionImpl> m_opaque_sp;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBInstruction_h_
diff --git a/linux-x64/clang/include/lldb/API/SBInstructionList.h b/linux-x64/clang/include/lldb/API/SBInstructionList.h
new file mode 100644
index 0000000..4434d50
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBInstructionList.h
@@ -0,0 +1,66 @@
+//===-- SBInstructionList.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_SBInstructionList_h_
+#define LLDB_SBInstructionList_h_
+
+#include "lldb/API/SBDefines.h"
+
+#include <stdio.h>
+
+namespace lldb {
+
+class LLDB_API SBInstructionList {
+public:
+ SBInstructionList();
+
+ SBInstructionList(const SBInstructionList &rhs);
+
+ const SBInstructionList &operator=(const SBInstructionList &rhs);
+
+ ~SBInstructionList();
+
+ explicit operator bool() const;
+
+ bool IsValid() const;
+
+ size_t GetSize();
+
+ lldb::SBInstruction GetInstructionAtIndex(uint32_t idx);
+
+ // Returns the number of instructions between the start and end address. If
+ // canSetBreakpoint is true then the count will be the number of
+ // instructions on which a breakpoint can be set.
+ size_t GetInstructionsCount(const SBAddress &start,
+ const SBAddress &end,
+ bool canSetBreakpoint = false);
+
+ void Clear();
+
+ void AppendInstruction(lldb::SBInstruction inst);
+
+ void Print(FILE *out);
+
+ bool GetDescription(lldb::SBStream &description);
+
+ bool DumpEmulationForAllInstructions(const char *triple);
+
+protected:
+ friend class SBFunction;
+ friend class SBSymbol;
+ friend class SBTarget;
+
+ void SetDisassembler(const lldb::DisassemblerSP &opaque_sp);
+
+private:
+ lldb::DisassemblerSP m_opaque_sp;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBInstructionList_h_
diff --git a/linux-x64/clang/include/lldb/API/SBLanguageRuntime.h b/linux-x64/clang/include/lldb/API/SBLanguageRuntime.h
new file mode 100644
index 0000000..d28c441
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBLanguageRuntime.h
@@ -0,0 +1,25 @@
+//===-- SBLanguageRuntime.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_SBLanguageRuntime_h_
+#define LLDB_SBLanguageRuntime_h_
+
+#include "lldb/API/SBDefines.h"
+
+namespace lldb {
+
+class SBLanguageRuntime {
+public:
+ static lldb::LanguageType GetLanguageTypeFromString(const char *string);
+
+ static const char *GetNameForLanguageType(lldb::LanguageType language);
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBLanguageRuntime_h_
diff --git a/linux-x64/clang/include/lldb/API/SBLaunchInfo.h b/linux-x64/clang/include/lldb/API/SBLaunchInfo.h
new file mode 100644
index 0000000..c7b381f
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBLaunchInfo.h
@@ -0,0 +1,149 @@
+//===-- SBLaunchInfo.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_SBLaunchInfo_h_
+#define LLDB_SBLaunchInfo_h_
+
+#include "lldb/API/SBDefines.h"
+
+namespace lldb_private {
+class SBLaunchInfoImpl;
+}
+
+namespace lldb {
+
+class SBPlatform;
+class SBTarget;
+
+class LLDB_API SBLaunchInfo {
+public:
+ SBLaunchInfo(const char **argv);
+
+ ~SBLaunchInfo();
+
+ lldb::pid_t GetProcessID();
+
+ uint32_t GetUserID();
+
+ uint32_t GetGroupID();
+
+ bool UserIDIsValid();
+
+ bool GroupIDIsValid();
+
+ void SetUserID(uint32_t uid);
+
+ void SetGroupID(uint32_t gid);
+
+ SBFileSpec GetExecutableFile();
+
+ /// Set the executable file that will be used to launch the process and
+ /// optionally set it as the first argument in the argument vector.
+ ///
+ /// This only needs to be specified if clients wish to carefully control
+ /// the exact path will be used to launch a binary. If you create a
+ /// target with a symlink, that symlink will get resolved in the target
+ /// and the resolved path will get used to launch the process. Calling
+ /// this function can help you still launch your process using the
+ /// path of your choice.
+ ///
+ /// If this function is not called prior to launching with
+ /// SBTarget::Launch(...), the target will use the resolved executable
+ /// path that was used to create the target.
+ ///
+ /// \param[in] exe_file
+ /// The override path to use when launching the executable.
+ ///
+ /// \param[in] add_as_first_arg
+ /// If true, then the path will be inserted into the argument vector
+ /// prior to launching. Otherwise the argument vector will be left
+ /// alone.
+ void SetExecutableFile(SBFileSpec exe_file, bool add_as_first_arg);
+
+ /// Get the listener that will be used to receive process events.
+ ///
+ /// If no listener has been set via a call to
+ /// SBLaunchInfo::SetListener(), then an invalid SBListener will be
+ /// returned (SBListener::IsValid() will return false). If a listener
+ /// has been set, then the valid listener object will be returned.
+ SBListener GetListener();
+
+ /// Set the listener that will be used to receive process events.
+ ///
+ /// By default the SBDebugger, which has a listener, that the SBTarget
+ /// belongs to will listen for the process events. Calling this function
+ /// allows a different listener to be used to listen for process events.
+ void SetListener(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 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);
+
+protected:
+ friend class SBPlatform;
+ friend class SBTarget;
+
+ const lldb_private::ProcessLaunchInfo &ref() const;
+ void set_ref(const lldb_private::ProcessLaunchInfo &info);
+
+ std::shared_ptr<lldb_private::SBLaunchInfoImpl> m_opaque_sp;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBLaunchInfo_h_
diff --git a/linux-x64/clang/include/lldb/API/SBLineEntry.h b/linux-x64/clang/include/lldb/API/SBLineEntry.h
new file mode 100644
index 0000000..855c28d
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBLineEntry.h
@@ -0,0 +1,78 @@
+//===-- SBLineEntry.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_SBLineEntry_h_
+#define LLDB_SBLineEntry_h_
+
+#include "lldb/API/SBAddress.h"
+#include "lldb/API/SBDefines.h"
+#include "lldb/API/SBFileSpec.h"
+
+namespace lldb {
+
+class LLDB_API SBLineEntry {
+public:
+ SBLineEntry();
+
+ SBLineEntry(const lldb::SBLineEntry &rhs);
+
+ ~SBLineEntry();
+
+ const lldb::SBLineEntry &operator=(const lldb::SBLineEntry &rhs);
+
+ lldb::SBAddress GetStartAddress() const;
+
+ lldb::SBAddress GetEndAddress() const;
+
+ explicit operator bool() const;
+
+ bool IsValid() const;
+
+ lldb::SBFileSpec GetFileSpec() const;
+
+ uint32_t GetLine() const;
+
+ uint32_t GetColumn() const;
+
+ 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;
+
+ bool GetDescription(lldb::SBStream &description);
+
+protected:
+ lldb_private::LineEntry *get();
+
+private:
+ friend class SBAddress;
+ friend class SBCompileUnit;
+ friend class SBFrame;
+ friend class SBSymbolContext;
+
+ const lldb_private::LineEntry *operator->() const;
+
+ lldb_private::LineEntry &ref();
+
+ const lldb_private::LineEntry &ref() const;
+
+ SBLineEntry(const lldb_private::LineEntry *lldb_object_ptr);
+
+ void SetLineEntry(const lldb_private::LineEntry &lldb_object_ref);
+
+ std::unique_ptr<lldb_private::LineEntry> m_opaque_up;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBLineEntry_h_
diff --git a/linux-x64/clang/include/lldb/API/SBListener.h b/linux-x64/clang/include/lldb/API/SBListener.h
new file mode 100644
index 0000000..21aface
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBListener.h
@@ -0,0 +1,108 @@
+//===-- SBListener.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_SBListener_h_
+#define LLDB_SBListener_h_
+
+#include "lldb/API/SBDefines.h"
+
+namespace lldb {
+
+class LLDB_API SBListener {
+public:
+ SBListener();
+
+ SBListener(const char *name);
+
+ SBListener(const SBListener &rhs);
+
+ ~SBListener();
+
+ const lldb::SBListener &operator=(const lldb::SBListener &rhs);
+
+ void AddEvent(const lldb::SBEvent &event);
+
+ void Clear();
+
+ explicit operator bool() const;
+
+ bool IsValid() const;
+
+ uint32_t StartListeningForEventClass(SBDebugger &debugger,
+ const char *broadcaster_class,
+ uint32_t event_mask);
+
+ 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,
+ 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);
+
+protected:
+ friend class SBAttachInfo;
+ friend class SBBroadcaster;
+ friend class SBCommandInterpreter;
+ friend class SBDebugger;
+ friend class SBLaunchInfo;
+ friend class SBTarget;
+
+ SBListener(const lldb::ListenerSP &listener_sp);
+
+ lldb::ListenerSP GetSP();
+
+private:
+ lldb_private::Listener *operator->() const;
+
+ lldb_private::Listener *get() const;
+
+ void reset(lldb::ListenerSP listener_sp);
+
+ lldb::ListenerSP m_opaque_sp;
+ lldb_private::Listener *m_unused_ptr;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBListener_h_
diff --git a/linux-x64/clang/include/lldb/API/SBMemoryRegionInfo.h b/linux-x64/clang/include/lldb/API/SBMemoryRegionInfo.h
new file mode 100644
index 0000000..2a9ae94
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBMemoryRegionInfo.h
@@ -0,0 +1,98 @@
+//===-- SBMemoryRegionInfo.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_SBMemoryRegionInfo_h_
+#define LLDB_SBMemoryRegionInfo_h_
+
+#include "lldb/API/SBData.h"
+#include "lldb/API/SBDefines.h"
+
+namespace lldb {
+
+class LLDB_API SBMemoryRegionInfo {
+public:
+ SBMemoryRegionInfo();
+
+ SBMemoryRegionInfo(const lldb::SBMemoryRegionInfo &rhs);
+
+ ~SBMemoryRegionInfo();
+
+ const lldb::SBMemoryRegionInfo &
+ operator=(const lldb::SBMemoryRegionInfo &rhs);
+
+ void Clear();
+
+ /// Get the base address of this memory range.
+ ///
+ /// \return
+ /// The base address of this memory range.
+ lldb::addr_t GetRegionBase();
+
+ /// Get the end address of this memory range.
+ ///
+ /// \return
+ /// The base address of this memory range.
+ lldb::addr_t GetRegionEnd();
+
+ /// Check if this memory address is marked readable to the process.
+ ///
+ /// \return
+ /// true if this memory address is marked readable
+ bool IsReadable();
+
+ /// Check if this memory address is marked writable to the process.
+ ///
+ /// \return
+ /// true if this memory address is marked writable
+ bool IsWritable();
+
+ /// Check if this memory address is marked executable to the process.
+ ///
+ /// \return
+ /// true if this memory address is marked executable
+ bool IsExecutable();
+
+ /// Check if this memory address is mapped into the process address
+ /// space.
+ ///
+ /// \return
+ /// true if this memory address is in the process address space.
+ bool IsMapped();
+
+ /// Returns the name of the memory region mapped at the given
+ /// address.
+ ///
+ /// \return
+ /// In case of memory mapped files it is the absolute path of
+ /// the file otherwise it is a name associated with the memory
+ /// region. If no name can be determined the returns nullptr.
+ const char *GetName();
+
+ bool operator==(const lldb::SBMemoryRegionInfo &rhs) const;
+
+ bool operator!=(const lldb::SBMemoryRegionInfo &rhs) const;
+
+ bool GetDescription(lldb::SBStream &description);
+
+private:
+ friend class SBProcess;
+ friend class SBMemoryRegionInfoList;
+
+ lldb_private::MemoryRegionInfo &ref();
+
+ const lldb_private::MemoryRegionInfo &ref() const;
+
+ // Unused.
+ SBMemoryRegionInfo(const lldb_private::MemoryRegionInfo *lldb_object_ptr);
+
+ lldb::MemoryRegionInfoUP m_opaque_up;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBMemoryRegionInfo_h_
diff --git a/linux-x64/clang/include/lldb/API/SBMemoryRegionInfoList.h b/linux-x64/clang/include/lldb/API/SBMemoryRegionInfoList.h
new file mode 100644
index 0000000..5592efe
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBMemoryRegionInfoList.h
@@ -0,0 +1,55 @@
+//===-- 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_SBMemoryRegionInfoList_h_
+#define LLDB_SBMemoryRegionInfoList_h_
+
+#include "lldb/API/SBDefines.h"
+
+class MemoryRegionInfoListImpl;
+
+namespace lldb {
+
+class LLDB_API SBMemoryRegionInfoList {
+public:
+ SBMemoryRegionInfoList();
+
+ SBMemoryRegionInfoList(const lldb::SBMemoryRegionInfoList &rhs);
+
+ const SBMemoryRegionInfoList &operator=(const SBMemoryRegionInfoList &rhs);
+
+ ~SBMemoryRegionInfoList();
+
+ uint32_t GetSize() const;
+
+ bool GetMemoryRegionAtIndex(uint32_t idx, SBMemoryRegionInfo ®ion_info);
+
+ void Append(lldb::SBMemoryRegionInfo ®ion);
+
+ void Append(lldb::SBMemoryRegionInfoList ®ion_list);
+
+ void Clear();
+
+protected:
+ const MemoryRegionInfoListImpl *operator->() const;
+
+ const MemoryRegionInfoListImpl &operator*() const;
+
+private:
+ friend class SBProcess;
+
+ lldb_private::MemoryRegionInfos &ref();
+
+ const lldb_private::MemoryRegionInfos &ref() const;
+
+ std::unique_ptr<MemoryRegionInfoListImpl> m_opaque_up;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBMemoryRegionInfoList_h_
diff --git a/linux-x64/clang/include/lldb/API/SBModule.h b/linux-x64/clang/include/lldb/API/SBModule.h
new file mode 100644
index 0000000..d2b6a18
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBModule.h
@@ -0,0 +1,309 @@
+//===-- SBModule.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_SBModule_h_
+#define LLDB_SBModule_h_
+
+#include "lldb/API/SBDefines.h"
+#include "lldb/API/SBError.h"
+#include "lldb/API/SBSection.h"
+#include "lldb/API/SBSymbolContext.h"
+#include "lldb/API/SBValueList.h"
+
+namespace lldb {
+
+class LLDB_API SBModule {
+public:
+ SBModule();
+
+ SBModule(const SBModule &rhs);
+
+ SBModule(const SBModuleSpec &module_spec);
+
+ const SBModule &operator=(const SBModule &rhs);
+
+ SBModule(lldb::SBProcess &process, lldb::addr_t header_addr);
+
+ ~SBModule();
+
+ explicit operator bool() const;
+
+ bool IsValid() const;
+
+ void Clear();
+
+ /// 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::SBFileSpec GetFileSpec() const;
+
+ /// 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::SBFileSpec GetPlatformFileSpec() const;
+
+ bool SetPlatformFileSpec(const lldb::SBFileSpec &platform_file);
+
+ /// Get accessor for the remote install path for a module.
+ ///
+ /// When debugging to a remote platform by connecting to a remote
+ /// platform, the install path of the module can be set. If the
+ /// install path is set, every time the process is about to launch
+ /// the target will install this module on the remote platform prior
+ /// to launching.
+ ///
+ /// \return
+ /// A file specification object.
+ lldb::SBFileSpec GetRemoteInstallFileSpec();
+
+ /// Set accessor for the remote install path for a module.
+ ///
+ /// When debugging to a remote platform by connecting to a remote
+ /// platform, the install path of the module can be set. If the
+ /// install path is set, every time the process is about to launch
+ /// the target will install this module on the remote platform prior
+ /// to launching.
+ ///
+ /// If \a file specifies a full path to an install location, the
+ /// module will be installed to this path. If the path is relative
+ /// (no directory specified, or the path is partial like "usr/lib"
+ /// or "./usr/lib", then the install path will be resolved using
+ /// the platform's current working directory as the base path.
+ ///
+ /// \param[in] file
+ /// A file specification object.
+ bool SetRemoteInstallFileSpec(lldb::SBFileSpec &file);
+
+ lldb::ByteOrder GetByteOrder();
+
+ uint32_t GetAddressByteSize();
+
+ const char *GetTriple();
+
+ const uint8_t *GetUUIDBytes() const;
+
+ 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);
+
+ /// Find compile units related to *this module and passed source
+ /// file.
+ ///
+ /// \param[in] sb_file_spec
+ /// A lldb::SBFileSpec object that contains source file
+ /// specification.
+ ///
+ /// \return
+ /// A lldb::SBSymbolContextList that gets filled in with all of
+ /// the symbol contexts for all the matches.
+ 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);
+ /// 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 lldb::SBSymbolContextList that gets filled in with all of
+ /// the symbol contexts for all the matches.
+ lldb::SBSymbolContextList
+ FindFunctions(const char *name,
+ uint32_t name_type_mask = lldb::eFunctionNameTypeAny);
+
+ /// 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 \a max_matches.
+ ///
+ /// \return
+ /// A list of matched variables in an SBValueList.
+ lldb::SBValueList FindGlobalVariables(lldb::SBTarget &target,
+ const char *name, uint32_t max_matches);
+
+ /// 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::SBValue FindFirstGlobalVariable(lldb::SBTarget &target,
+ const char *name);
+
+ lldb::SBType FindFirstType(const char *name);
+
+ lldb::SBTypeList FindTypes(const char *type);
+
+ /// Get a type using its type ID.
+ ///
+ /// Each symbol file reader will assign different user IDs to their
+ /// types, but it is sometimes useful when debugging type issues to
+ /// be able to grab a type using its type ID.
+ ///
+ /// For DWARF debug info, the type ID is the DIE offset.
+ ///
+ /// \param[in] uid
+ /// The type user ID.
+ ///
+ /// \return
+ /// An SBType for the given type ID, or an empty SBType if the
+ /// type was not found.
+ lldb::SBType GetTypeByID(lldb::user_id_t uid);
+
+ lldb::SBType GetBasicType(lldb::BasicType type);
+
+ /// Get all types matching \a 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 \a type_mask
+ lldb::SBTypeList GetTypes(uint32_t type_mask = lldb::eTypeClassAny);
+
+ /// Get the module version numbers.
+ ///
+ /// Many object files have a set of version numbers that describe
+ /// the version of the executable or shared library. Typically there
+ /// are major, minor and build, but there may be more. This function
+ /// will extract the versions from object files if they are available.
+ ///
+ /// If \a versions is NULL, or if \a num_versions is 0, the return
+ /// value will indicate how many version numbers are available in
+ /// this object file. Then a subsequent call can be made to this
+ /// function with a value of \a versions and \a num_versions that
+ /// has enough storage to store some or all version numbers.
+ ///
+ /// \param[out] versions
+ /// A pointer to an array of uint32_t types that is \a num_versions
+ /// long. If this value is NULL, the return value will indicate
+ /// how many version numbers are required for a subsequent call
+ /// to this function so that all versions can be retrieved. If
+ /// the value is non-NULL, then at most \a num_versions of the
+ /// existing versions numbers will be filled into \a versions.
+ /// If there is no version information available, \a versions
+ /// will be filled with \a num_versions UINT32_MAX values
+ /// and zero will be returned.
+ ///
+ /// \param[in] num_versions
+ /// The maximum number of entries to fill into \a versions. If
+ /// this value is zero, then the return value will indicate
+ /// how many version numbers there are in total so another call
+ /// to this function can be make with adequate storage in
+ /// \a versions to get all of the version numbers. If \a
+ /// num_versions is less than the actual number of version
+ /// numbers in this object file, only \a num_versions will be
+ /// filled into \a versions (if \a versions is non-NULL).
+ ///
+ /// \return
+ /// This function always returns the number of version numbers
+ /// that this object file has regardless of the number of
+ /// version numbers that were copied into \a versions.
+ uint32_t GetVersion(uint32_t *versions, uint32_t num_versions);
+
+ /// Get accessor for the symbol file specification.
+ ///
+ /// When debugging an object file an additional debug information can
+ /// be provided in separate file. Therefore if you debugging something
+ /// like '/usr/lib/liba.dylib' then debug information can be located
+ /// in folder like '/usr/lib/liba.dylib.dSYM/'.
+ ///
+ /// \return
+ /// A const reference to the file specification object.
+ lldb::SBFileSpec GetSymbolFileSpec() const;
+
+ lldb::SBAddress GetObjectFileHeaderAddress() const;
+ lldb::SBAddress GetObjectFileEntryPointAddress() const;
+
+private:
+ friend class SBAddress;
+ friend class SBFrame;
+ friend class SBSection;
+ friend class SBSymbolContext;
+ friend class SBTarget;
+
+ explicit SBModule(const lldb::ModuleSP &module_sp);
+
+ ModuleSP GetSP() const;
+
+ void SetSP(const ModuleSP &module_sp);
+
+ lldb::ModuleSP m_opaque_sp;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBModule_h_
diff --git a/linux-x64/clang/include/lldb/API/SBModuleSpec.h b/linux-x64/clang/include/lldb/API/SBModuleSpec.h
new file mode 100644
index 0000000..29b3117
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBModuleSpec.h
@@ -0,0 +1,122 @@
+//===-- SBModuleSpec.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_SBModuleSpec_h_
+#define LLDB_SBModuleSpec_h_
+
+#include "lldb/API/SBDefines.h"
+#include "lldb/API/SBFileSpec.h"
+
+namespace lldb {
+
+class LLDB_API SBModuleSpec {
+public:
+ SBModuleSpec();
+
+ SBModuleSpec(const SBModuleSpec &rhs);
+
+ ~SBModuleSpec();
+
+ const SBModuleSpec &operator=(const SBModuleSpec &rhs);
+
+ explicit operator bool() const;
+
+ bool IsValid() const;
+
+ void Clear();
+
+ /// 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::SBFileSpec GetFileSpec();
+
+ void SetFileSpec(const lldb::SBFileSpec &fspec);
+
+ /// 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::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);
+
+private:
+ friend class SBModuleSpecList;
+ friend class SBModule;
+ friend class SBTarget;
+
+ std::unique_ptr<lldb_private::ModuleSpec> m_opaque_up;
+};
+
+class SBModuleSpecList {
+public:
+ SBModuleSpecList();
+
+ SBModuleSpecList(const SBModuleSpecList &rhs);
+
+ ~SBModuleSpecList();
+
+ SBModuleSpecList &operator=(const SBModuleSpecList &rhs);
+
+ static SBModuleSpecList GetModuleSpecifications(const char *path);
+
+ void Append(const SBModuleSpec &spec);
+
+ void Append(const SBModuleSpecList &spec_list);
+
+ SBModuleSpec FindFirstMatchingSpec(const SBModuleSpec &match_spec);
+
+ SBModuleSpecList FindMatchingSpecs(const SBModuleSpec &match_spec);
+
+ size_t GetSize();
+
+ SBModuleSpec GetSpecAtIndex(size_t i);
+
+ bool GetDescription(lldb::SBStream &description);
+
+private:
+ std::unique_ptr<lldb_private::ModuleSpecList> m_opaque_up;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBModuleSpec_h_
diff --git a/linux-x64/clang/include/lldb/API/SBPlatform.h b/linux-x64/clang/include/lldb/API/SBPlatform.h
new file mode 100644
index 0000000..7207b2e
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBPlatform.h
@@ -0,0 +1,166 @@
+//===-- SBPlatform.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_SBPlatform_h_
+#define LLDB_SBPlatform_h_
+
+#include "lldb/API/SBDefines.h"
+
+#include <functional>
+
+struct PlatformConnectOptions;
+struct PlatformShellCommand;
+
+namespace lldb {
+
+class SBLaunchInfo;
+
+class LLDB_API SBPlatformConnectOptions {
+public:
+ SBPlatformConnectOptions(const char *url);
+
+ SBPlatformConnectOptions(const SBPlatformConnectOptions &rhs);
+
+ ~SBPlatformConnectOptions();
+
+ void operator=(const SBPlatformConnectOptions &rhs);
+
+ 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);
+
+protected:
+ PlatformConnectOptions *m_opaque_ptr;
+};
+
+class LLDB_API SBPlatformShellCommand {
+public:
+ SBPlatformShellCommand(const char *shell_command);
+
+ SBPlatformShellCommand(const SBPlatformShellCommand &rhs);
+
+ ~SBPlatformShellCommand();
+
+ void Clear();
+
+ 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();
+
+protected:
+ friend class SBPlatform;
+
+ PlatformShellCommand *m_opaque_ptr;
+};
+
+class LLDB_API SBPlatform {
+public:
+ SBPlatform();
+
+ SBPlatform(const char *platform_name);
+
+ ~SBPlatform();
+
+ explicit operator bool() const;
+
+ bool IsValid() const;
+
+ void Clear();
+
+ const char *GetWorkingDirectory();
+
+ bool SetWorkingDirectory(const char *path);
+
+ const char *GetName();
+
+ SBError ConnectRemote(SBPlatformConnectOptions &connect_options);
+
+ void DisconnectRemote();
+
+ bool IsConnected();
+
+ // The following functions will work if the platform is connected
+ const char *GetTriple();
+
+ const char *GetHostname();
+
+ const char *GetOSBuild();
+
+ const char *GetOSDescription();
+
+ uint32_t GetOSMajorVersion();
+
+ uint32_t GetOSMinorVersion();
+
+ uint32_t GetOSUpdateVersion();
+
+ SBError Put(SBFileSpec &src, SBFileSpec &dst);
+
+ SBError Get(SBFileSpec &src, SBFileSpec &dst);
+
+ SBError Install(SBFileSpec &src, SBFileSpec &dst);
+
+ SBError Run(SBPlatformShellCommand &shell_command);
+
+ SBError Launch(SBLaunchInfo &launch_info);
+
+ SBError Kill(const lldb::pid_t pid);
+
+ SBError
+ MakeDirectory(const char *path,
+ uint32_t file_permissions = eFilePermissionsDirectoryDefault);
+
+ uint32_t GetFilePermissions(const char *path);
+
+ SBError SetFilePermissions(const char *path, uint32_t file_permissions);
+
+ SBUnixSignals GetUnixSignals() const;
+
+protected:
+ friend class SBDebugger;
+ friend class SBTarget;
+
+ lldb::PlatformSP GetSP() const;
+
+ void SetSP(const lldb::PlatformSP &platform_sp);
+
+ SBError ExecuteConnected(
+ const std::function<lldb_private::Status(const lldb::PlatformSP &)>
+ &func);
+
+ lldb::PlatformSP m_opaque_sp;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBPlatform_h_
diff --git a/linux-x64/clang/include/lldb/API/SBProcess.h b/linux-x64/clang/include/lldb/API/SBProcess.h
new file mode 100644
index 0000000..863cb3c
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBProcess.h
@@ -0,0 +1,415 @@
+//===-- SBProcess.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_SBProcess_h_
+#define LLDB_SBProcess_h_
+
+#include "lldb/API/SBDefines.h"
+#include "lldb/API/SBError.h"
+#include "lldb/API/SBProcessInfo.h"
+#include "lldb/API/SBQueue.h"
+#include "lldb/API/SBTarget.h"
+#include <stdio.h>
+
+namespace lldb {
+
+class SBEvent;
+
+class LLDB_API SBProcess {
+public:
+ /// Broadcaster event bits definitions.
+ FLAGS_ANONYMOUS_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);
+
+ const lldb::SBProcess &operator=(const lldb::SBProcess &rhs);
+
+ SBProcess(const lldb::ProcessSP &process_sp);
+
+ ~SBProcess();
+
+ static const char *GetBroadcasterClassName();
+
+ const char *GetPluginName();
+
+ // DEPRECATED: use GetPluginName()
+ const char *GetShortPluginName();
+
+ void Clear();
+
+ explicit operator bool() const;
+
+ bool IsValid() const;
+
+ lldb::SBTarget GetTarget() const;
+
+ lldb::ByteOrder GetByteOrder() const;
+
+ 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;
+
+ void ReportEventState(const lldb::SBEvent &event, FILE *out) 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);
+
+ 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();
+
+ lldb::SBThread GetThreadAtIndex(size_t index);
+
+ lldb::SBThread GetThreadByID(lldb::tid_t sb_thread_id);
+
+ lldb::SBThread GetThreadByIndexID(uint32_t index_id);
+
+ lldb::SBThread GetSelectedThread() const;
+
+ // Function for lazily creating a thread using the current OS plug-in. This
+ // function will be removed in the future when there are APIs to create
+ // SBThread objects through the interface and add them to the process through
+ // the SBProcess API.
+ 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(size_t index);
+
+ // Stepping related functions
+
+ lldb::StateType GetState();
+
+ int GetExitStatus();
+
+ const char *GetExitDescription();
+
+ /// Gets the process ID
+ ///
+ /// Returns the process identifier for the process as it is known
+ /// on the system on which the process is running. For unix systems
+ /// this is typically the same as if you called "getpid()" in the
+ /// process.
+ ///
+ /// \return
+ /// Returns LLDB_INVALID_PROCESS_ID if this object does not
+ /// contain a valid process object, or if the process has not
+ /// been launched. Returns a valid process ID if the process is
+ /// valid.
+ lldb::pid_t GetProcessID();
+
+ /// Gets the unique ID associated with this process object
+ ///
+ /// Unique IDs start at 1 and increment up with each new process
+ /// instance. Since starting a process on a system might always
+ /// create a process with the same process ID, there needs to be a
+ /// way to tell two process instances apart.
+ ///
+ /// \return
+ /// Returns a non-zero integer ID if this object contains a
+ /// valid process object, zero if this object does not contain
+ /// a valid process object.
+ uint32_t GetUniqueID();
+
+ uint32_t GetAddressByteSize() const;
+
+ lldb::SBError Destroy();
+
+ lldb::SBError Continue();
+
+ lldb::SBError Stop();
+
+ lldb::SBError Kill();
+
+ lldb::SBError Detach();
+
+ lldb::SBError Detach(bool keep_stopped);
+
+ lldb::SBError Signal(int signal);
+
+ lldb::SBUnixSignals GetUnixSignals();
+
+ void SendAsyncInterrupt();
+
+ uint32_t GetStopID(bool include_expression_stops = false);
+
+ /// Gets the stop event corresponding to stop ID.
+ //
+ /// Note that it wasn't fully implemented and tracks only the stop
+ /// event for the last natural stop ID.
+ ///
+ /// \param [in] stop_id
+ /// The ID of the stop event to return.
+ ///
+ /// \return
+ /// 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,
+ 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
+ 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;
+
+ static const char *GetBroadcasterClass();
+
+ bool GetDescription(lldb::SBStream &description);
+
+ /// Start Tracing with the given SBTraceOptions.
+ ///
+ /// \param[in] options
+ /// Class containing trace options like trace buffer size, meta
+ /// data buffer size, TraceType and any custom parameters
+ /// {formatted as a JSON Dictionary}. In case of errors in
+ /// formatting, an error would be reported.
+ /// It must be noted that tracing options such as buffer sizes
+ /// or other custom parameters passed maybe invalid for some
+ /// trace technologies. In such cases the trace implementations
+ /// could choose to either throw an error or could round off to
+ /// the nearest valid options to start tracing if the passed
+ /// value is not supported. To obtain the actual used trace
+ /// options please use the GetTraceConfig API. For the custom
+ /// parameters, only the parameters recognized by the target
+ /// would be used and others would be ignored.
+ ///
+ /// \param[out] error
+ /// An error explaining what went wrong.
+ ///
+ /// \return
+ /// A SBTrace instance, which should be used
+ /// to get the trace data or other trace related operations.
+ lldb::SBTrace StartTrace(SBTraceOptions &options, lldb::SBError &error);
+
+ uint32_t GetNumSupportedHardwareWatchpoints(lldb::SBError &error) const;
+
+ /// Load a shared library into this process.
+ ///
+ /// \param[in] remote_image_spec
+ /// The path for the shared library on the target what you want
+ /// to load.
+ ///
+ /// \param[out] error
+ /// An error object that gets filled in with any errors that
+ /// might occur when trying to load the shared library.
+ ///
+ /// \return
+ /// A token that represents the shared library that can be
+ /// later used to unload the shared library. A value of
+ /// LLDB_INVALID_IMAGE_TOKEN will be returned if the shared
+ /// library can't be opened.
+ uint32_t LoadImage(lldb::SBFileSpec &remote_image_spec, lldb::SBError &error);
+
+ /// Load a shared library into this process.
+ ///
+ /// \param[in] local_image_spec
+ /// The file spec that points to the shared library that you
+ /// want to load if the library is located on the host. The
+ /// library will be copied over to the location specified by
+ /// remote_image_spec or into the current working directory with
+ /// the same filename if the remote_image_spec isn't specified.
+ ///
+ /// \param[in] remote_image_spec
+ /// If local_image_spec is specified then the location where the
+ /// library should be copied over from the host. If
+ /// local_image_spec isn't specified, then the path for the
+ /// shared library on the target what you want to load.
+ ///
+ /// \param[out] error
+ /// An error object that gets filled in with any errors that
+ /// might occur when trying to load the shared library.
+ ///
+ /// \return
+ /// A token that represents the shared library that can be
+ /// later used to unload the shared library. A value of
+ /// LLDB_INVALID_IMAGE_TOKEN will be returned if the shared
+ /// library can't be opened.
+ uint32_t LoadImage(const lldb::SBFileSpec &local_image_spec,
+ const lldb::SBFileSpec &remote_image_spec,
+ lldb::SBError &error);
+
+ /// Load a shared library into this process, starting with a
+ /// library name and a list of paths, searching along the list of
+ /// paths till you find a matching library.
+ ///
+ /// \param[in] image_spec
+ /// The name of the shared library that you want to load.
+ /// If image_spec is a relative path, the relative path will be
+ /// appended to the search paths.
+ /// If the image_spec is an absolute path, just the basename is used.
+ ///
+ /// \param[in] paths
+ /// A list of paths to search for the library whose basename is
+ /// local_spec.
+ ///
+ /// \param[out] loaded_path
+ /// If the library was found along the paths, this will store the
+ /// full path to the found library.
+ ///
+ /// \param[out] error
+ /// An error object that gets filled in with any errors that
+ /// might occur when trying to search for the shared library.
+ ///
+ /// \return
+ /// A token that represents the shared library that can be
+ /// later passed to UnloadImage. A value of
+ /// LLDB_INVALID_IMAGE_TOKEN will be returned if the shared
+ /// library can't be opened.
+ uint32_t LoadImageUsingPaths(const lldb::SBFileSpec &image_spec,
+ SBStringList &paths,
+ lldb::SBFileSpec &loaded_path,
+ lldb::SBError &error);
+
+ lldb::SBError UnloadImage(uint32_t image_token);
+
+ lldb::SBError SendEventData(const char *data);
+
+ /// Return the number of different thread-origin extended backtraces
+ /// this process can support.
+ ///
+ /// 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).
+ ///
+ /// \return
+ /// The number of thread-origin extended backtrace types that may be
+ /// available.
+ uint32_t GetNumExtendedBacktraceTypes();
+
+ /// Return the name of one of the thread-origin extended backtrace
+ /// methods.
+ ///
+ /// \param [in] idx
+ /// The index of the name to return. They will be returned in
+ /// the order that the user will most likely want to see them.
+ /// e.g. if the type at index 0 is not available for a thread,
+ /// see if the type at index 1 provides an extended backtrace.
+ ///
+ /// \return
+ /// The name at that index.
+ const char *GetExtendedBacktraceTypeAtIndex(uint32_t idx);
+
+ lldb::SBThreadCollection GetHistoryThreads(addr_t addr);
+
+ bool IsInstrumentationRuntimePresent(InstrumentationRuntimeType type);
+
+ /// Save the state of the process in a core file (or mini dump on Windows).
+ lldb::SBError SaveCore(const char *file_name);
+
+ /// Query the address load_addr and store the details of the memory
+ /// region that contains it in the supplied SBMemoryRegionInfo object.
+ /// To iterate over all memory regions use GetMemoryRegionList.
+ ///
+ /// \param[in] load_addr
+ /// The address to be queried.
+ ///
+ /// \param[out] region_info
+ /// A reference to an SBMemoryRegionInfo object that will contain
+ /// the details of the memory region containing load_addr.
+ ///
+ /// \return
+ /// An error object describes any errors that occurred while
+ /// querying load_addr.
+ lldb::SBError GetMemoryRegionInfo(lldb::addr_t load_addr,
+ lldb::SBMemoryRegionInfo ®ion_info);
+
+ /// Return the list of memory regions within the process.
+ ///
+ /// \return
+ /// A list of all witin the process memory regions.
+ lldb::SBMemoryRegionInfoList GetMemoryRegions();
+
+ /// Return information about the process.
+ ///
+ /// Valid process info will only be returned when the process is
+ /// alive, use SBProcessInfo::IsValid() to check returned info is
+ /// valid.
+ lldb::SBProcessInfo GetProcessInfo();
+
+protected:
+ friend class SBAddress;
+ friend class SBBreakpoint;
+ friend class SBBreakpointLocation;
+ friend class SBCommandInterpreter;
+ friend class SBDebugger;
+ friend class SBExecutionContext;
+ friend class SBFunction;
+ friend class SBModule;
+ friend class SBTarget;
+ friend class SBThread;
+ friend class SBValue;
+ friend class lldb_private::QueueImpl;
+
+ lldb::ProcessSP GetSP() const;
+
+ void SetSP(const lldb::ProcessSP &process_sp);
+
+ lldb::ProcessWP m_opaque_wp;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBProcess_h_
diff --git a/linux-x64/clang/include/lldb/API/SBProcessInfo.h b/linux-x64/clang/include/lldb/API/SBProcessInfo.h
new file mode 100644
index 0000000..86dba9a
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBProcessInfo.h
@@ -0,0 +1,65 @@
+//===-- SBProcessInfo.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_SBProcessInfo_h_
+#define LLDB_SBProcessInfo_h_
+
+#include "lldb/API/SBDefines.h"
+
+namespace lldb {
+
+class LLDB_API SBProcessInfo {
+public:
+ SBProcessInfo();
+ SBProcessInfo(const SBProcessInfo &rhs);
+
+ ~SBProcessInfo();
+
+ SBProcessInfo &operator=(const SBProcessInfo &rhs);
+
+ explicit operator bool() const;
+
+ bool IsValid() 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();
+
+private:
+ friend class SBProcess;
+
+ lldb_private::ProcessInstanceInfo &ref();
+
+ void SetProcessInfo(const lldb_private::ProcessInstanceInfo &proc_info_ref);
+
+ std::unique_ptr<lldb_private::ProcessInstanceInfo> m_opaque_up;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBProcessInfo_h_
diff --git a/linux-x64/clang/include/lldb/API/SBQueue.h b/linux-x64/clang/include/lldb/API/SBQueue.h
new file mode 100644
index 0000000..0124c1c
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBQueue.h
@@ -0,0 +1,69 @@
+//===-- 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_SBQueue_h_
+#define LLDB_SBQueue_h_
+
+#include <vector>
+
+#include "lldb/API/SBDefines.h"
+#include "lldb/lldb-forward.h"
+
+namespace lldb {
+
+class LLDB_API SBQueue {
+public:
+ SBQueue();
+
+ SBQueue(const QueueSP &queue_sp);
+
+ SBQueue(const SBQueue &rhs);
+
+ const SBQueue &operator=(const lldb::SBQueue &rhs);
+
+ ~SBQueue();
+
+ explicit operator bool() const;
+
+ bool IsValid() const;
+
+ void Clear();
+
+ lldb::SBProcess GetProcess();
+
+ lldb::queue_id_t GetQueueID() const;
+
+ const char *GetName() const;
+
+ uint32_t GetIndexID() const;
+
+ uint32_t GetNumThreads();
+
+ lldb::SBThread GetThreadAtIndex(uint32_t);
+
+ uint32_t GetNumPendingItems();
+
+ lldb::SBQueueItem GetPendingItemAtIndex(uint32_t);
+
+ uint32_t GetNumRunningItems();
+
+ lldb::QueueKind GetKind();
+
+protected:
+ friend class SBProcess;
+ friend class SBThread;
+
+ void SetQueue(const lldb::QueueSP &queue_sp);
+
+private:
+ std::shared_ptr<lldb_private::QueueImpl> m_opaque_sp;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBQueue_h_
diff --git a/linux-x64/clang/include/lldb/API/SBQueueItem.h b/linux-x64/clang/include/lldb/API/SBQueueItem.h
new file mode 100644
index 0000000..455a1f9
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBQueueItem.h
@@ -0,0 +1,49 @@
+//===-- 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_SBQueueItem_h_
+#define LLDB_SBQueueItem_h_
+
+#include "lldb/API/SBAddress.h"
+#include "lldb/API/SBDefines.h"
+
+namespace lldb {
+
+class LLDB_API SBQueueItem {
+public:
+ SBQueueItem();
+
+ SBQueueItem(const lldb::QueueItemSP &queue_item_sp);
+
+ ~SBQueueItem();
+
+ explicit operator bool() const;
+
+ bool IsValid() 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);
+
+ SBThread GetExtendedBacktraceThread(const char *type);
+
+private:
+ lldb::QueueItemSP m_queue_item_sp;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBQueueItem_h_
diff --git a/linux-x64/clang/include/lldb/API/SBReproducer.h b/linux-x64/clang/include/lldb/API/SBReproducer.h
new file mode 100644
index 0000000..0f1739d
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBReproducer.h
@@ -0,0 +1,28 @@
+//===-- SBReproducer.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_SBREPRODUCER_H
+#define LLDB_API_SBREPRODUCER_H
+
+#include "lldb/API/SBDefines.h"
+
+namespace lldb {
+
+/// 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:
+ static const char *Capture();
+ static const char *Capture(const char *path);
+ static const char *Replay(const char *path);
+};
+
+} // namespace lldb
+
+#endif
diff --git a/linux-x64/clang/include/lldb/API/SBSection.h b/linux-x64/clang/include/lldb/API/SBSection.h
new file mode 100644
index 0000000..06a195e
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBSection.h
@@ -0,0 +1,101 @@
+//===-- SBSection.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_SBSection_h_
+#define LLDB_SBSection_h_
+
+#include "lldb/API/SBData.h"
+#include "lldb/API/SBDefines.h"
+
+namespace lldb {
+
+class LLDB_API SBSection {
+public:
+ SBSection();
+
+ SBSection(const lldb::SBSection &rhs);
+
+ ~SBSection();
+
+ const lldb::SBSection &operator=(const lldb::SBSection &rhs);
+
+ explicit operator bool() const;
+
+ bool IsValid() 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();
+
+ /// Gets the permissions (RWX) of the section of the object file
+ ///
+ /// Returns a mask of bits of enum lldb::Permissions for this section.
+ /// Sections for which permissions are not defined, 0 is returned for
+ /// them. The binary representation of this value corresponds to [XRW]
+ /// i.e. for a section having read and execute permissions, the value
+ /// returned is 6
+ ///
+ /// \return
+ /// Returns an unsigned value for Permissions for the section.
+ uint32_t
+ GetPermissions() const;
+
+ /// 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
+ uint32_t GetTargetByteSize();
+
+ bool operator==(const lldb::SBSection &rhs);
+
+ bool operator!=(const lldb::SBSection &rhs);
+
+ bool GetDescription(lldb::SBStream &description);
+
+private:
+ friend class SBAddress;
+ friend class SBModule;
+ friend class SBTarget;
+
+ SBSection(const lldb::SectionSP §ion_sp);
+
+ lldb::SectionSP GetSP() const;
+
+ void SetSP(const lldb::SectionSP §ion_sp);
+
+ lldb::SectionWP m_opaque_wp;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBSection_h_
diff --git a/linux-x64/clang/include/lldb/API/SBSourceManager.h b/linux-x64/clang/include/lldb/API/SBSourceManager.h
new file mode 100644
index 0000000..3d69aa2
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBSourceManager.h
@@ -0,0 +1,47 @@
+//===-- SBSourceManager.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_SBSourceManager_h_
+#define LLDB_SBSourceManager_h_
+
+#include "lldb/API/SBDefines.h"
+
+#include <stdio.h>
+
+namespace lldb {
+
+class LLDB_API SBSourceManager {
+public:
+ SBSourceManager(const SBDebugger &debugger);
+ SBSourceManager(const SBTarget &target);
+ SBSourceManager(const SBSourceManager &rhs);
+
+ ~SBSourceManager();
+
+ const lldb::SBSourceManager &operator=(const lldb::SBSourceManager &rhs);
+
+ 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);
+
+protected:
+ friend class SBCommandInterpreter;
+ friend class SBDebugger;
+
+private:
+ std::unique_ptr<lldb_private::SourceManagerImpl> m_opaque_up;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBSourceManager_h_
diff --git a/linux-x64/clang/include/lldb/API/SBStream.h b/linux-x64/clang/include/lldb/API/SBStream.h
new file mode 100644
index 0000000..8afbf45
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBStream.h
@@ -0,0 +1,105 @@
+//===-- SBStream.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_SBStream_h_
+#define LLDB_SBStream_h_
+
+#include <stdio.h>
+
+#include "lldb/API/SBDefines.h"
+
+namespace lldb {
+
+class LLDB_API SBStream {
+public:
+ SBStream();
+
+ SBStream(SBStream &&rhs);
+
+ ~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)));
+
+ void RedirectToFile(const char *path, bool append);
+
+ void RedirectToFileHandle(FILE *fh, bool transfer_fh_ownership);
+
+ 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();
+
+protected:
+ friend class SBAddress;
+ friend class SBBlock;
+ friend class SBBreakpoint;
+ friend class SBBreakpointLocation;
+ friend class SBBreakpointName;
+ friend class SBCommandReturnObject;
+ friend class SBCompileUnit;
+ friend class SBData;
+ friend class SBDebugger;
+ friend class SBDeclaration;
+ friend class SBEvent;
+ friend class SBFileSpec;
+ friend class SBFileSpecList;
+ friend class SBFrame;
+ friend class SBFunction;
+ friend class SBInstruction;
+ friend class SBInstructionList;
+ friend class SBLineEntry;
+ friend class SBMemoryRegionInfo;
+ friend class SBModule;
+ friend class SBModuleSpec;
+ friend class SBModuleSpecList;
+ friend class SBProcess;
+ friend class SBSection;
+ friend class SBSourceManager;
+ friend class SBStructuredData;
+ friend class SBSymbol;
+ friend class SBSymbolContext;
+ friend class SBSymbolContextList;
+ friend class SBTarget;
+ friend class SBThread;
+ friend class SBThreadPlan;
+ friend class SBType;
+ friend class SBTypeEnumMember;
+ friend class SBTypeMemberFunction;
+ friend class SBTypeMember;
+ friend class SBValue;
+ friend class SBWatchpoint;
+
+ lldb_private::Stream *operator->();
+
+ lldb_private::Stream *get();
+
+ lldb_private::Stream &ref();
+
+private:
+ DISALLOW_COPY_AND_ASSIGN(SBStream);
+ std::unique_ptr<lldb_private::Stream> m_opaque_up;
+ bool m_is_file;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBStream_h_
diff --git a/linux-x64/clang/include/lldb/API/SBStringList.h b/linux-x64/clang/include/lldb/API/SBStringList.h
new file mode 100644
index 0000000..1df1e45
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBStringList.h
@@ -0,0 +1,65 @@
+//===-- SBStringList.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_SBStringList_h_
+#define LLDB_SBStringList_h_
+
+#include "lldb/API/SBDefines.h"
+
+namespace lldb {
+
+class LLDB_API SBStringList {
+public:
+ SBStringList();
+
+ SBStringList(const lldb::SBStringList &rhs);
+
+ const SBStringList &operator=(const SBStringList &rhs);
+
+ ~SBStringList();
+
+ explicit operator bool() const;
+
+ bool IsValid() 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);
+
+ const char *GetStringAtIndex(size_t idx) const;
+
+ void Clear();
+
+protected:
+ friend class SBCommandInterpreter;
+ friend class SBDebugger;
+ friend class SBBreakpoint;
+ friend class SBBreakpointLocation;
+ friend class SBBreakpointName;
+
+ SBStringList(const lldb_private::StringList *lldb_strings);
+
+ void AppendList(const lldb_private::StringList &strings);
+
+ const lldb_private::StringList *operator->() const;
+
+ const lldb_private::StringList &operator*() const;
+
+private:
+ std::unique_ptr<lldb_private::StringList> m_opaque_up;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBStringList_h_
diff --git a/linux-x64/clang/include/lldb/API/SBStructuredData.h b/linux-x64/clang/include/lldb/API/SBStructuredData.h
new file mode 100644
index 0000000..5b10133
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBStructuredData.h
@@ -0,0 +1,99 @@
+//===-- SBStructuredData.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 SBStructuredData_h
+#define SBStructuredData_h
+
+#include "lldb/API/SBDefines.h"
+#include "lldb/API/SBModule.h"
+
+namespace lldb {
+
+class SBStructuredData {
+public:
+ SBStructuredData();
+
+ SBStructuredData(const lldb::SBStructuredData &rhs);
+
+ SBStructuredData(const lldb::EventSP &event_sp);
+
+ SBStructuredData(lldb_private::StructuredDataImpl *impl);
+
+ ~SBStructuredData();
+
+ lldb::SBStructuredData &operator=(const lldb::SBStructuredData &rhs);
+
+ explicit operator bool() const;
+
+ bool IsValid() const;
+
+ lldb::SBError SetFromJSON(lldb::SBStream &stream);
+
+ void Clear();
+
+ lldb::SBError GetAsJSON(lldb::SBStream &stream) const;
+
+ lldb::SBError GetDescription(lldb::SBStream &stream) const;
+
+ /// Return the type of data in this data structure
+ lldb::StructuredDataType GetType() const;
+
+ /// Return the size (i.e. number of elements) in this data structure
+ /// if it is an array or dictionary type. For other types, 0 will be
+ // returned.
+ size_t GetSize() const;
+
+ /// Fill keys with the keys in this object and return true if this data
+ /// structure is a dictionary. Returns false otherwise.
+ bool GetKeys(lldb::SBStringList &keys) const;
+
+ /// Return the value corresponding to a key if this data structure
+ /// is a dictionary type.
+ lldb::SBStructuredData GetValueForKey(const char *key) const;
+
+ /// Return the value corresponding to an index if this data structure
+ /// is array.
+ lldb::SBStructuredData GetItemAtIndex(size_t idx) const;
+
+ /// Return the integer value if this data structure is an integer type.
+ uint64_t GetIntegerValue(uint64_t fail_value = 0) const;
+
+ /// Return the floating point value if this data structure is a floating
+ /// type.
+ double GetFloatValue(double fail_value = 0.0) const;
+
+ /// Return the boolean value if this data structure is a boolean type.
+ bool GetBooleanValue(bool fail_value = false) const;
+
+ /// Provides the string value if this data structure is a string type.
+ ///
+ /// \param[out] dst
+ /// pointer where the string value will be written. In case it is null,
+ /// nothing will be written at \a dst.
+ ///
+ /// \param[in] dst_len
+ /// max number of characters that can be written at \a dst. In case it is
+ /// zero, nothing will be written at \a dst. If this length is not enough
+ /// to write the complete string value, (\a dst_len - 1) bytes of the
+ /// string value will be written at \a dst followed by a null character.
+ ///
+ /// \return
+ /// Returns the byte size needed to completely write the string value at
+ /// \a dst in all cases.
+ size_t GetStringValue(char *dst, size_t dst_len) const;
+
+protected:
+ friend class SBTraceOptions;
+ friend class SBDebugger;
+ friend class SBTarget;
+
+ StructuredDataImplUP m_impl_up;
+};
+} // namespace lldb
+
+#endif /* SBStructuredData_h */
diff --git a/linux-x64/clang/include/lldb/API/SBSymbol.h b/linux-x64/clang/include/lldb/API/SBSymbol.h
new file mode 100644
index 0000000..52486b8
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBSymbol.h
@@ -0,0 +1,86 @@
+//===-- SBSymbol.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_SBSymbol_h_
+#define LLDB_SBSymbol_h_
+
+#include "lldb/API/SBAddress.h"
+#include "lldb/API/SBDefines.h"
+#include "lldb/API/SBInstructionList.h"
+#include "lldb/API/SBTarget.h"
+
+namespace lldb {
+
+class LLDB_API SBSymbol {
+public:
+ SBSymbol();
+
+ ~SBSymbol();
+
+ SBSymbol(const lldb::SBSymbol &rhs);
+
+ const lldb::SBSymbol &operator=(const lldb::SBSymbol &rhs);
+
+ explicit operator bool() const;
+
+ bool IsValid() 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();
+
+ uint32_t GetPrologueByteSize();
+
+ SymbolType GetType();
+
+ bool operator==(const lldb::SBSymbol &rhs) const;
+
+ bool operator!=(const lldb::SBSymbol &rhs) const;
+
+ bool GetDescription(lldb::SBStream &description);
+
+ // Returns true if the symbol is externally visible in the module that it is
+ // defined in
+ bool IsExternal();
+
+ // Returns true if the symbol was synthetically generated from something
+ // other than the actual symbol table itself in the object file.
+ bool IsSynthetic();
+
+protected:
+ lldb_private::Symbol *get();
+
+ void reset(lldb_private::Symbol *);
+
+private:
+ friend class SBAddress;
+ friend class SBFrame;
+ friend class SBModule;
+ friend class SBSymbolContext;
+
+ SBSymbol(lldb_private::Symbol *lldb_object_ptr);
+
+ void SetSymbol(lldb_private::Symbol *lldb_object_ptr);
+
+ lldb_private::Symbol *m_opaque_ptr;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBSymbol_h_
diff --git a/linux-x64/clang/include/lldb/API/SBSymbolContext.h b/linux-x64/clang/include/lldb/API/SBSymbolContext.h
new file mode 100644
index 0000000..3d16d09
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBSymbolContext.h
@@ -0,0 +1,83 @@
+//===-- SBSymbolContext.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_SBSymbolContext_h_
+#define LLDB_SBSymbolContext_h_
+
+#include "lldb/API/SBBlock.h"
+#include "lldb/API/SBCompileUnit.h"
+#include "lldb/API/SBDefines.h"
+#include "lldb/API/SBFunction.h"
+#include "lldb/API/SBLineEntry.h"
+#include "lldb/API/SBModule.h"
+#include "lldb/API/SBSymbol.h"
+
+namespace lldb {
+
+class LLDB_API SBSymbolContext {
+public:
+ SBSymbolContext();
+
+ SBSymbolContext(const lldb::SBSymbolContext &rhs);
+
+ SBSymbolContext(const lldb_private::SymbolContext *sc_ptr);
+
+ ~SBSymbolContext();
+
+ explicit operator bool() const;
+
+ bool IsValid() const;
+
+ const lldb::SBSymbolContext &operator=(const lldb::SBSymbolContext &rhs);
+
+ 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);
+
+ SBSymbolContext GetParentOfInlinedScope(const SBAddress &curr_frame_pc,
+ SBAddress &parent_frame_addr) const;
+
+ bool GetDescription(lldb::SBStream &description);
+
+protected:
+ friend class SBAddress;
+ friend class SBFrame;
+ friend class SBModule;
+ friend class SBThread;
+ friend class SBTarget;
+ friend class SBSymbolContextList;
+
+ lldb_private::SymbolContext *operator->() const;
+
+ lldb_private::SymbolContext &operator*();
+
+ lldb_private::SymbolContext &ref();
+
+ const lldb_private::SymbolContext &operator*() const;
+
+ lldb_private::SymbolContext *get() const;
+
+ void SetSymbolContext(const lldb_private::SymbolContext *sc_ptr);
+
+private:
+ std::unique_ptr<lldb_private::SymbolContext> m_opaque_up;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBSymbolContext_h_
diff --git a/linux-x64/clang/include/lldb/API/SBSymbolContextList.h b/linux-x64/clang/include/lldb/API/SBSymbolContextList.h
new file mode 100644
index 0000000..577993c
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBSymbolContextList.h
@@ -0,0 +1,58 @@
+//===-- SBSymbolContextList.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_SBSymbolContextList_h_
+#define LLDB_SBSymbolContextList_h_
+
+#include "lldb/API/SBDefines.h"
+#include "lldb/API/SBSymbolContext.h"
+
+namespace lldb {
+
+class LLDB_API SBSymbolContextList {
+public:
+ SBSymbolContextList();
+
+ SBSymbolContextList(const lldb::SBSymbolContextList &rhs);
+
+ ~SBSymbolContextList();
+
+ const lldb::SBSymbolContextList &
+ operator=(const lldb::SBSymbolContextList &rhs);
+
+ explicit operator bool() const;
+
+ bool IsValid() const;
+
+ uint32_t GetSize() const;
+
+ lldb::SBSymbolContext GetContextAtIndex(uint32_t idx);
+
+ bool GetDescription(lldb::SBStream &description);
+
+ void Append(lldb::SBSymbolContext &sc);
+
+ void Append(lldb::SBSymbolContextList &sc_list);
+
+ void Clear();
+
+protected:
+ friend class SBModule;
+ friend class SBTarget;
+
+ lldb_private::SymbolContextList *operator->() const;
+
+ lldb_private::SymbolContextList &operator*() const;
+
+private:
+ std::unique_ptr<lldb_private::SymbolContextList> m_opaque_up;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBSymbolContextList_h_
diff --git a/linux-x64/clang/include/lldb/API/SBTarget.h b/linux-x64/clang/include/lldb/API/SBTarget.h
new file mode 100644
index 0000000..80a7fa0
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBTarget.h
@@ -0,0 +1,852 @@
+//===-- SBTarget.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_SBTarget_h_
+#define LLDB_SBTarget_h_
+
+#include "lldb/API/SBAddress.h"
+#include "lldb/API/SBAttachInfo.h"
+#include "lldb/API/SBBreakpoint.h"
+#include "lldb/API/SBBroadcaster.h"
+#include "lldb/API/SBDefines.h"
+#include "lldb/API/SBFileSpec.h"
+#include "lldb/API/SBFileSpecList.h"
+#include "lldb/API/SBLaunchInfo.h"
+#include "lldb/API/SBSymbolContextList.h"
+#include "lldb/API/SBType.h"
+#include "lldb/API/SBValue.h"
+#include "lldb/API/SBWatchpoint.h"
+
+namespace lldb {
+
+class SBPlatform;
+
+class LLDB_API 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);
+
+ SBTarget(const lldb::TargetSP &target_sp);
+
+ // Destructor
+ ~SBTarget();
+
+ const lldb::SBTarget &operator=(const lldb::SBTarget &rhs);
+
+ explicit operator bool() const;
+
+ bool IsValid() 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);
+
+ static const char *GetBroadcasterClassName();
+
+ lldb::SBProcess GetProcess();
+
+ /// Sets whether we should collect statistics on lldb or not.
+ ///
+ /// \param[in] v
+ /// A boolean to control the collection.
+ void SetCollectingStats(bool v);
+
+ /// Returns whether statistics collection are enabled.
+ ///
+ /// \return
+ /// true if statistics are currently being collected, false
+ /// otherwise.
+ bool GetCollectingStats();
+
+ /// Returns a dump of the collected statistics.
+ ///
+ /// \return
+ /// A SBStructuredData with the statistics collected.
+ lldb::SBStructuredData GetStatistics();
+
+ /// Return the platform object associated with the target.
+ ///
+ /// After return, the platform object should be checked for
+ /// validity.
+ ///
+ /// \return
+ /// A platform object.
+ lldb::SBPlatform GetPlatform();
+
+ /// 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 remote 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.
+ SBError Install();
+
+ /// 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 \a argv, and the environment variables
+ /// are in \a envp. Standard input and output files can be
+ /// optionally re-directed to \a stdin_path, \a stdout_path, and
+ /// \a stderr_path.
+ ///
+ /// \param[in] listener
+ /// An optional listener that will receive all process events.
+ /// If \a listener is valid then \a 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] stdin_path
+ /// The path to use when re-directing the STDIN of the new
+ /// process. If all stdXX_path arguments are nullptr, 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 nullptr, 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 nullptr, 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] error
+ /// An error object. Contains the reason if there is some failure.
+ ///
+ /// \return
+ /// A process object for the newly created process.
+ 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);
+
+ SBProcess LoadCore(const char *core_file);
+ SBProcess LoadCore(const char *core_file, lldb::SBError &error);
+
+ /// Launch a new process with sensible defaults.
+ ///
+ /// \param[in] argv
+ /// The argument array.
+ ///
+ /// \param[in] envp
+ /// The environment array.
+ ///
+ /// \param[in] working_directory
+ /// The working directory to have the child process run in
+ ///
+ /// Default: listener
+ /// Set to the target's debugger (SBTarget::GetDebugger())
+ ///
+ /// Default: launch_flags
+ /// Empty launch flags
+ ///
+ /// Default: stdin_path
+ /// Default: stdout_path
+ /// Default: stderr_path
+ /// A pseudo terminal will be used.
+ ///
+ /// \return
+ /// A process object for the newly created process.
+ SBProcess LaunchSimple(const char **argv, const char **envp,
+ const char *working_directory);
+
+ SBProcess Launch(SBLaunchInfo &launch_info, SBError &error);
+
+ SBProcess Attach(SBAttachInfo &attach_info, SBError &error);
+
+ /// Attach to process with pid.
+ ///
+ /// \param[in] listener
+ /// An optional listener that will receive all process events.
+ /// If \a listener is valid then \a 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] error
+ /// An error explaining what went wrong if attach fails.
+ ///
+ /// \return
+ /// A process object for the attached process.
+ lldb::SBProcess AttachToProcessWithID(SBListener &listener, lldb::pid_t pid,
+ lldb::SBError &error);
+
+ /// Attach to process with name.
+ ///
+ /// \param[in] listener
+ /// An optional listener that will receive all process events.
+ /// If \a listener is valid then \a 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] error
+ /// An error explaining what went wrong if attach fails.
+ ///
+ /// \return
+ /// A process object for the attached process.
+ lldb::SBProcess AttachToProcessWithName(SBListener &listener,
+ const char *name, bool wait_for,
+ lldb::SBError &error);
+
+ /// Connect to a remote debug server with url.
+ ///
+ /// \param[in] listener
+ /// An optional listener that will receive all process events.
+ /// If \a listener is valid then \a 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 nullptr.
+ ///
+ /// \param[out] error
+ /// An error explaining what went wrong if the connect fails.
+ ///
+ /// \return
+ /// A process object for the connected process.
+ lldb::SBProcess ConnectRemote(SBListener &listener, const char *url,
+ const char *plugin_name, SBError &error);
+
+ lldb::SBFileSpec GetExecutable();
+
+ // Append the path mapping (from -> to) to the target's paths mapping list.
+ void AppendImageSearchPath(const char *from, const char *to,
+ lldb::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);
+
+ /// Find compile units related to *this target and passed source
+ /// file.
+ ///
+ /// \param[in] sb_file_spec
+ /// A lldb::SBFileSpec object that contains source file
+ /// specification.
+ ///
+ /// \return
+ /// A lldb::SBSymbolContextList that gets filled in with all of
+ /// the symbol contexts for all the matches.
+ lldb::SBSymbolContextList
+ FindCompileUnits(const lldb::SBFileSpec &sb_file_spec);
+
+ lldb::ByteOrder GetByteOrder();
+
+ uint32_t GetAddressByteSize();
+
+ const char *GetTriple();
+
+ /// Architecture data byte width accessor
+ ///
+ /// \return
+ /// The size in 8-bit (host) bytes of a minimum addressable
+ /// unit from the Architecture's data bus
+ uint32_t GetDataByteSize();
+
+ /// Architecture code byte width accessor
+ ///
+ /// \return
+ /// The size in 8-bit (host) bytes of a minimum addressable
+ /// unit from the Architecture's code bus
+ uint32_t GetCodeByteSize();
+
+ /// Set the base load address for a module section.
+ ///
+ /// \param[in] section
+ /// The section whose base load address will be set within this
+ /// target.
+ ///
+ /// \param[in] section_base_addr
+ /// The base address for the section.
+ ///
+ /// \return
+ /// An error to indicate success, fail, and any reason for
+ /// failure.
+ lldb::SBError SetSectionLoadAddress(lldb::SBSection section,
+ lldb::addr_t section_base_addr);
+
+ /// Clear the base load address for a module section.
+ ///
+ /// \param[in] section
+ /// The section whose base load address will be cleared within
+ /// this target.
+ ///
+ /// \return
+ /// An error to indicate success, fail, and any reason for
+ /// failure.
+ lldb::SBError ClearSectionLoadAddress(lldb::SBSection section);
+
+ /// Slide all file addresses for all module sections so that \a module
+ /// appears to loaded at these slide addresses.
+ ///
+ /// When you need all sections within a module to be loaded at a
+ /// rigid slide from the addresses found in the module object file,
+ /// this function will allow you to easily and quickly slide all
+ /// module sections.
+ ///
+ /// \param[in] module
+ /// The module to load.
+ ///
+ /// \param[in] sections_offset
+ /// An offset that will be applied to all section file addresses
+ /// (the virtual addresses found in the object file itself).
+ ///
+ /// \return
+ /// An error to indicate success, fail, and any reason for
+ /// failure.
+ lldb::SBError SetModuleLoadAddress(lldb::SBModule module,
+ int64_t sections_offset);
+
+ /// Clear the section base load addresses for all sections in a module.
+ ///
+ /// \param[in] module
+ /// The module to unload.
+ ///
+ /// \return
+ /// An error to indicate success, fail, and any reason for
+ /// failure.
+ lldb::SBError ClearModuleLoadAddress(lldb::SBModule module);
+
+ /// 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 lldb::SBSymbolContextList that gets filled in with all of
+ /// the symbol contexts for all the matches.
+ lldb::SBSymbolContextList
+ FindFunctions(const char *name,
+ uint32_t name_type_mask = lldb::eFunctionNameTypeAny);
+
+ /// 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 \a max_matches.
+ ///
+ /// \return
+ /// A list of matched variables in an SBValueList.
+ lldb::SBValueList FindGlobalVariables(const char *name, uint32_t max_matches);
+
+ /// 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::SBValue FindFirstGlobalVariable(const char *name);
+
+ /// Find global and static variables by pattern.
+ ///
+ /// \param[in] name
+ /// The pattern to search for global or static variables
+ ///
+ /// \param[in] max_matches
+ /// Allow the number of matches to be limited to \a max_matches.
+ ///
+ /// \param[in] matchtype
+ /// The match type to use.
+ ///
+ /// \return
+ /// A list of matched variables in an SBValueList.
+ lldb::SBValueList FindGlobalVariables(const char *name, uint32_t max_matches,
+ MatchType matchtype);
+
+ /// Find global functions by their name with pattern matching.
+ ///
+ /// \param[in] name
+ /// The pattern to search for global or static variables
+ ///
+ /// \param[in] max_matches
+ /// Allow the number of matches to be limited to \a max_matches.
+ ///
+ /// \param[in] matchtype
+ /// The match type to use.
+ ///
+ /// \return
+ /// A list of matched variables in an SBValueList.
+ lldb::SBSymbolContextList FindGlobalFunctions(const char *name,
+ uint32_t max_matches,
+ MatchType matchtype);
+
+ void Clear();
+
+ /// Resolve a current file address into a section offset address.
+ ///
+ /// \param[in] file_addr
+ /// The file address to resolve.
+ ///
+ /// \return
+ /// An SBAddress which will be valid if...
+ lldb::SBAddress ResolveFileAddress(lldb::addr_t file_addr);
+
+ /// Resolve a current load address into a section offset address.
+ ///
+ /// \param[in] vm_addr
+ /// A virtual address from the current process state that is to
+ /// be translated into a section offset address.
+ ///
+ /// \return
+ /// An SBAddress which will be valid if \a vm_addr was
+ /// successfully resolved into a section offset address, or an
+ /// invalid SBAddress if \a vm_addr doesn't resolve to a section
+ /// in a module.
+ lldb::SBAddress ResolveLoadAddress(lldb::addr_t vm_addr);
+
+ /// Resolve a current load address into a section offset address
+ /// using the process stop ID to identify a time in the past.
+ ///
+ /// \param[in] stop_id
+ /// Each time a process stops, the process stop ID integer gets
+ /// incremented. These stop IDs are used to identify past times
+ /// and can be used in history objects as a cheap way to store
+ /// the time at which the sample was taken. Specifying
+ /// UINT32_MAX will always resolve the address using the
+ /// currently loaded sections.
+ ///
+ /// \param[in] vm_addr
+ /// A virtual address from the current process state that is to
+ /// be translated into a section offset address.
+ ///
+ /// \return
+ /// An SBAddress which will be valid if \a vm_addr was
+ /// successfully resolved into a section offset address, or an
+ /// invalid SBAddress if \a vm_addr doesn't resolve to a section
+ /// in a module.
+ lldb::SBAddress ResolvePastLoadAddress(uint32_t stop_id,
+ lldb::addr_t vm_addr);
+
+ SBSymbolContext ResolveSymbolContextForAddress(const SBAddress &addr,
+ uint32_t resolve_scope);
+
+ /// 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
+ /// Status information is written here if the memory read fails.
+ ///
+ /// \return
+ /// The amount of data read in host bytes.
+ 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 BreakpointCreateByName(const char *symbol_name,
+ const char *module_name = nullptr);
+
+ // This version uses name_type_mask = eFunctionNameTypeAuto
+ lldb::SBBreakpoint
+ BreakpointCreateByName(const char *symbol_name,
+ const SBFileSpecList &module_list,
+ const SBFileSpecList &comp_unit_list);
+
+ lldb::SBBreakpoint BreakpointCreateByName(
+ const char *symbol_name,
+ uint32_t
+ name_type_mask, // 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
+ 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
+ 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 = nullptr);
+
+ lldb::SBBreakpoint
+ BreakpointCreateByRegex(const char *symbol_name_regex,
+ const SBFileSpecList &module_list,
+ const SBFileSpecList &comp_unit_list);
+
+ 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 SBFileSpec &source_file,
+ const char *module_name = nullptr);
+
+ lldb::SBBreakpoint
+ BreakpointCreateBySourceRegex(const char *source_regex,
+ const SBFileSpecList &module_list,
+ const SBFileSpecList &source_file);
+
+ 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::SBBreakpoint BreakpointCreateBySBAddress(SBAddress &address);
+
+ /// Create a breakpoint using a scripted resolver.
+ ///
+ /// \param[in] class_name
+ /// This is the name of the class that implements a scripted resolver.
+ ///
+ /// \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 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::SBBreakpoint BreakpointCreateFromScript(
+ const char *class_name,
+ SBStructuredData &extra_args,
+ const SBFileSpecList &module_list,
+ const SBFileSpecList &file_list,
+ bool request_hardware = false);
+
+ /// 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] new_bps
+ /// A list of the newly created breakpoints.
+ ///
+ /// \return
+ /// An SBError detailing any errors in reading in the breakpoints.
+ lldb::SBError BreakpointsCreateFromFile(SBFileSpec &source_file,
+ SBBreakpointList &new_bps);
+
+ /// 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] new_bps
+ /// A list of the newly created breakpoints.
+ ///
+ /// \return
+ /// An SBError detailing any errors in reading in the breakpoints.
+ lldb::SBError BreakpointsCreateFromFile(SBFileSpec &source_file,
+ SBStringList &matching_names,
+ SBBreakpointList &new_bps);
+
+ /// 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::SBError BreakpointsWriteToFile(SBFileSpec &dest_file);
+
+ /// 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 \b 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::SBError BreakpointsWriteToFile(SBFileSpec &dest_file,
+ SBBreakpointList &bkpt_list,
+ bool append = 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);
+
+ // Finds all breakpoints by name, returning the list in bkpt_list. Returns
+ // false if the name is not a valid breakpoint name, true otherwise.
+ bool FindBreakpointsByName(const char *name, SBBreakpointList &bkpt_list);
+
+ void GetBreakpointNames(SBStringList &names);
+
+ void DeleteBreakpointName(const char *name);
+
+ bool EnableAllBreakpoints();
+
+ bool DisableAllBreakpoints();
+
+ bool DeleteAllBreakpoints();
+
+ 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);
+
+ lldb::SBWatchpoint WatchAddress(lldb::addr_t addr, size_t size, bool read,
+ bool write, SBError &error);
+
+ bool EnableAllWatchpoints();
+
+ bool DisableAllWatchpoints();
+
+ bool DeleteAllWatchpoints();
+
+ lldb::SBBroadcaster GetBroadcaster() const;
+
+ lldb::SBType FindFirstType(const char *type);
+
+ lldb::SBTypeList FindTypes(const char *type);
+
+ lldb::SBType GetBasicType(lldb::BasicType type);
+
+ 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);
+
+ SBSourceManager GetSourceManager();
+
+ lldb::SBInstructionList ReadInstructions(lldb::SBAddress base_addr,
+ uint32_t count);
+
+ lldb::SBInstructionList ReadInstructions(lldb::SBAddress base_addr,
+ uint32_t count,
+ const char *flavor_string);
+
+ lldb::SBInstructionList GetInstructions(lldb::SBAddress base_addr,
+ const void *buf, size_t size);
+
+ // 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);
+
+ 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);
+
+ lldb::SBSymbolContextList FindSymbols(const char *name,
+ lldb::SymbolType type = eSymbolTypeAny);
+
+ bool operator==(const lldb::SBTarget &rhs) const;
+
+ bool operator!=(const lldb::SBTarget &rhs) const;
+
+ bool GetDescription(lldb::SBStream &description,
+ lldb::DescriptionLevel description_level);
+
+ lldb::SBValue EvaluateExpression(const char *expr);
+
+ lldb::SBValue EvaluateExpression(const char *expr,
+ const SBExpressionOptions &options);
+
+ lldb::addr_t GetStackRedZoneSize();
+
+ lldb::SBLaunchInfo GetLaunchInfo() const;
+
+ void SetLaunchInfo(const lldb::SBLaunchInfo &launch_info);
+
+protected:
+ friend class SBAddress;
+ friend class SBBlock;
+ friend class SBBreakpointList;
+ friend class SBBreakpointNameImpl;
+ friend class SBDebugger;
+ friend class SBExecutionContext;
+ friend class SBFunction;
+ friend class SBInstruction;
+ friend class SBModule;
+ friend class SBProcess;
+ friend class SBSection;
+ friend class SBSourceManager;
+ friend class SBSymbol;
+ friend class SBValue;
+ friend class SBVariablesOptions;
+
+ // Constructors are private, use static Target::Create function to create an
+ // instance of this class.
+
+ lldb::TargetSP GetSP() const;
+
+ void SetSP(const lldb::TargetSP &target_sp);
+
+private:
+ lldb::TargetSP m_opaque_sp;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBTarget_h_
diff --git a/linux-x64/clang/include/lldb/API/SBThread.h b/linux-x64/clang/include/lldb/API/SBThread.h
new file mode 100644
index 0000000..da8726a
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBThread.h
@@ -0,0 +1,231 @@
+//===-- 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_SBThread_h_
+#define LLDB_SBThread_h_
+
+#include "lldb/API/SBDefines.h"
+
+#include <stdio.h>
+
+namespace lldb {
+
+class SBFrame;
+
+class LLDB_API SBThread {
+public:
+ enum {
+ eBroadcastBitStackChanged = (1 << 0),
+ eBroadcastBitThreadSuspended = (1 << 1),
+ eBroadcastBitThreadResumed = (1 << 2),
+ eBroadcastBitSelectedFrameChanged = (1 << 3),
+ eBroadcastBitThreadSelected = (1 << 4)
+ };
+
+ static const char *GetBroadcasterClassName();
+
+ SBThread();
+
+ SBThread(const lldb::SBThread &thread);
+
+ SBThread(const lldb::ThreadSP &lldb_object_sp);
+
+ ~SBThread();
+
+ lldb::SBQueue GetQueue() const;
+
+ explicit operator bool() const;
+
+ bool IsValid() const;
+
+ void Clear();
+
+ lldb::StopReason GetStopReason();
+
+ /// Get the number of words associated with the stop reason.
+ /// See also GetStopReasonDataAtIndex().
+ size_t GetStopReasonDataCount();
+
+ /// 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
+ /// 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);
+
+ SBValue GetStopReturnValue();
+
+ lldb::tid_t GetThreadID() const;
+
+ uint32_t GetIndexID() const;
+
+ const char *GetName() const;
+
+ const char *GetQueueName() const;
+
+ lldb::queue_id_t GetQueueID() const;
+
+ bool GetInfoItemByPathAsString(const char *path, SBStream &strm);
+
+ void StepOver(lldb::RunMode stop_other_threads = lldb::eOnlyDuringStepping);
+
+ 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);
+
+ void StepInto(const char *target_name, uint32_t end_line, SBError &error,
+ lldb::RunMode stop_other_threads = lldb::eOnlyDuringStepping);
+
+ void StepOut();
+
+ void StepOut(SBError &error);
+
+ void StepOutOfFrame(SBFrame &frame);
+
+ void StepOutOfFrame(SBFrame &frame, SBError &error);
+
+ void StepInstruction(bool step_over);
+
+ 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 JumpToLine(lldb::SBFileSpec &file_spec, uint32_t line);
+
+ void RunToAddress(lldb::addr_t addr);
+
+ void RunToAddress(lldb::addr_t addr, SBError &error);
+
+ SBError ReturnFromFrame(SBFrame &frame, SBValue &return_value);
+
+ SBError UnwindInnermostExpression();
+
+ /// 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, RunToAddress), the
+ /// thread will not 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.
+ 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);
+
+ static bool EventIsThreadEvent(const SBEvent &event);
+
+ static SBFrame GetStackFrameFromEvent(const SBEvent &event);
+
+ static SBThread GetThreadFromEvent(const SBEvent &event);
+
+ lldb::SBProcess GetProcess();
+
+ const lldb::SBThread &operator=(const lldb::SBThread &rhs);
+
+ bool operator==(const lldb::SBThread &rhs) const;
+
+ bool operator!=(const lldb::SBThread &rhs) const;
+
+ bool GetDescription(lldb::SBStream &description) const;
+
+ bool GetDescription(lldb::SBStream &description, bool stop_format) const;
+
+ bool GetStatus(lldb::SBStream &status) const;
+
+ SBThread GetExtendedBacktraceThread(const char *type);
+
+ uint32_t GetExtendedBacktraceOriginatingIndexID();
+
+ SBValue GetCurrentException();
+
+ SBThread GetCurrentExceptionBacktrace();
+
+ bool SafeToCallFunctions();
+
+private:
+ friend class SBBreakpoint;
+ friend class SBBreakpointLocation;
+ friend class SBBreakpointCallbackBaton;
+ friend class SBExecutionContext;
+ friend class SBFrame;
+ friend class SBProcess;
+ friend class SBDebugger;
+ friend class SBValue;
+ friend class lldb_private::QueueImpl;
+ friend class SBQueueItem;
+ friend class SBThreadPlan;
+
+ void SetThread(const lldb::ThreadSP &lldb_object_sp);
+
+ SBError ResumeNewPlan(lldb_private::ExecutionContext &exe_ctx,
+ lldb_private::ThreadPlan *new_plan);
+
+ lldb::ExecutionContextRefSP m_opaque_sp;
+
+ lldb_private::Thread *operator->();
+
+ lldb_private::Thread *get();
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBThread_h_
diff --git a/linux-x64/clang/include/lldb/API/SBThreadCollection.h b/linux-x64/clang/include/lldb/API/SBThreadCollection.h
new file mode 100644
index 0000000..1c6b463
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBThreadCollection.h
@@ -0,0 +1,57 @@
+//===-- SBThreadCollection.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_SBThreadCollection_h_
+#define LLDB_SBThreadCollection_h_
+
+#include "lldb/API/SBDefines.h"
+
+namespace lldb {
+
+class LLDB_API SBThreadCollection {
+public:
+ SBThreadCollection();
+
+ SBThreadCollection(const SBThreadCollection &rhs);
+
+ const SBThreadCollection &operator=(const SBThreadCollection &rhs);
+
+ ~SBThreadCollection();
+
+ explicit operator bool() const;
+
+ bool IsValid() const;
+
+ size_t GetSize();
+
+ lldb::SBThread GetThreadAtIndex(size_t idx);
+
+protected:
+ // Mimic shared pointer...
+ lldb_private::ThreadCollection *get() const;
+
+ lldb_private::ThreadCollection *operator->() const;
+
+ lldb::ThreadCollectionSP &operator*();
+
+ const lldb::ThreadCollectionSP &operator*() const;
+
+ SBThreadCollection(const lldb::ThreadCollectionSP &threads);
+
+ void SetOpaque(const lldb::ThreadCollectionSP &threads);
+
+private:
+ friend class SBProcess;
+ friend class SBThread;
+
+ lldb::ThreadCollectionSP m_opaque_sp;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBThreadCollection_h_
diff --git a/linux-x64/clang/include/lldb/API/SBThreadPlan.h b/linux-x64/clang/include/lldb/API/SBThreadPlan.h
new file mode 100644
index 0000000..007e9e2
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBThreadPlan.h
@@ -0,0 +1,122 @@
+//===-- SBThreadPlan.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 {
+
+class LLDB_API 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();
+
+ explicit operator bool() const;
+
+ bool IsValid() const;
+
+ void Clear();
+
+ lldb::StopReason GetStopReason();
+
+ /// Get the number of words associated with the stop reason.
+ /// See also GetStopReasonDataAtIndex().
+ size_t GetStopReasonDataCount();
+
+ /// 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
+ /// eStopReasonPlanComplete 0
+ uint64_t GetStopReasonDataAtIndex(uint32_t idx);
+
+ SBThread GetThread() const;
+
+ const lldb::SBThreadPlan &operator=(const lldb::SBThreadPlan &rhs);
+
+ bool GetDescription(lldb::SBStream &description) const;
+
+ void SetPlanComplete(bool success);
+
+ bool IsPlanComplete();
+
+ bool IsPlanStale();
+
+ bool IsValid();
+
+ // This section allows an SBThreadPlan to push another of the common types of
+ // plans...
+ SBThreadPlan QueueThreadPlanForStepOverRange(SBAddress &start_address,
+ lldb::addr_t range_size);
+ SBThreadPlan QueueThreadPlanForStepOverRange(SBAddress &start_address,
+ lldb::addr_t range_size,
+ SBError &error);
+
+ SBThreadPlan QueueThreadPlanForStepInRange(SBAddress &start_address,
+ lldb::addr_t range_size);
+ SBThreadPlan QueueThreadPlanForStepInRange(SBAddress &start_address,
+ lldb::addr_t range_size,
+ SBError &error);
+
+ SBThreadPlan QueueThreadPlanForStepOut(uint32_t frame_idx_to_step_to,
+ bool first_insn = false);
+ SBThreadPlan QueueThreadPlanForStepOut(uint32_t frame_idx_to_step_to,
+ bool first_insn, SBError &error);
+
+ SBThreadPlan QueueThreadPlanForRunToAddress(SBAddress address);
+ SBThreadPlan QueueThreadPlanForRunToAddress(SBAddress address,
+ SBError &error);
+
+ SBThreadPlan QueueThreadPlanForStepScripted(const char *script_class_name);
+ SBThreadPlan QueueThreadPlanForStepScripted(const char *script_class_name,
+ SBError &error);
+
+private:
+ 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;
+
+ lldb_private::ThreadPlan *get();
+ void SetThreadPlan(const lldb::ThreadPlanSP &lldb_object_sp);
+
+ lldb::ThreadPlanSP m_opaque_sp;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBThreadPlan_h_
diff --git a/linux-x64/clang/include/lldb/API/SBTrace.h b/linux-x64/clang/include/lldb/API/SBTrace.h
new file mode 100644
index 0000000..87c67ad
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBTrace.h
@@ -0,0 +1,116 @@
+//===-- 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_SBTrace_h_
+#define LLDB_SBTrace_h_
+
+#include "lldb/API/SBDefines.h"
+#include "lldb/API/SBError.h"
+
+class TraceImpl;
+
+namespace lldb {
+
+class LLDB_API SBTrace {
+public:
+ SBTrace();
+ /// Obtain the trace data as raw bytes.
+ ///
+ /// \param[out] error
+ /// An error explaining what went wrong.
+ ///
+ /// \param[in] buf
+ /// Buffer to write the trace data to.
+ ///
+ /// \param[in] size
+ /// The size of the buffer used to read the data. This is
+ /// also the size of the data intended to read. It is also
+ /// possible to partially read the trace data for some trace
+ /// technologies by specifying a smaller buffer.
+ ///
+ /// \param[in] offset
+ /// The start offset to begin reading the trace data.
+ ///
+ /// \param[in] thread_id
+ /// Tracing could be started for the complete process or a
+ /// single thread, in the first case the traceid obtained would
+ /// map to all the threads existing within the process and the
+ /// ones spawning later. The thread_id parameter can be used in
+ /// such a scenario to select the trace data for a specific
+ /// thread.
+ ///
+ /// \return
+ /// The size of the trace data effectively read by the API call.
+ size_t GetTraceData(SBError &error, void *buf, size_t size, size_t offset = 0,
+ lldb::tid_t thread_id = LLDB_INVALID_THREAD_ID);
+
+ /// Obtain any meta data as raw bytes for the tracing instance.
+ /// The input parameter definition is similar to the previous
+ /// function.
+ size_t GetMetaData(SBError &error, void *buf, size_t size, size_t offset = 0,
+ lldb::tid_t thread_id = LLDB_INVALID_THREAD_ID);
+
+ /// Stop the tracing instance. Stopping the trace will also
+ /// lead to deletion of any gathered trace data.
+ ///
+ /// \param[out] error
+ /// An error explaining what went wrong.
+ ///
+ /// \param[in] thread_id
+ /// The trace id could map to a tracing instance for a thread
+ /// or could also map to a group of threads being traced with
+ /// the same trace options. A thread_id is normally optional
+ /// except in the case of tracing a complete process and tracing
+ /// needs to switched off on a particular thread.
+ /// A situation could occur where initially a thread (lets say
+ /// thread A) is being individually traced with a particular
+ /// trace id and then tracing is started on the complete
+ /// process, in this case thread A will continue without any
+ /// change. All newly spawned threads would be traced with the
+ /// trace id of the process.
+ /// Now if the StopTrace API is called for the whole process,
+ /// thread A will not be stopped and must be stopped separately.
+ void StopTrace(SBError &error,
+ lldb::tid_t thread_id = LLDB_INVALID_THREAD_ID);
+
+ /// Get the trace configuration being used for the trace instance.
+ /// The threadid in the SBTraceOptions needs to be set when the
+ /// configuration used by a specific thread is being requested.
+ ///
+ /// \param[out] options
+ /// The trace options actually used by the trace instance
+ /// would be filled by the API.
+ ///
+ /// \param[out] error
+ /// An error explaining what went wrong.
+ void GetTraceConfig(SBTraceOptions &options, SBError &error);
+
+ lldb::user_id_t GetTraceUID();
+
+ explicit operator bool() const;
+
+ bool IsValid();
+
+protected:
+ typedef std::shared_ptr<TraceImpl> TraceImplSP;
+
+ friend class SBProcess;
+
+ void SetTraceUID(lldb::user_id_t uid);
+
+ TraceImplSP m_trace_impl_sp;
+
+ lldb::ProcessSP GetSP() const;
+
+ void SetSP(const ProcessSP &process_sp);
+
+ lldb::ProcessWP m_opaque_wp;
+};
+} // namespace lldb
+
+#endif // LLDB_SBTrace_h_
diff --git a/linux-x64/clang/include/lldb/API/SBTraceOptions.h b/linux-x64/clang/include/lldb/API/SBTraceOptions.h
new file mode 100644
index 0000000..4c586bf
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBTraceOptions.h
@@ -0,0 +1,59 @@
+//===-- SBTraceOptions ------------------------------------------*- 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 SBTRACEOPTIONS_H_
+#define SBTRACEOPTIONS_H_
+
+#include "lldb/API/SBDefines.h"
+
+namespace lldb {
+
+class LLDB_API SBTraceOptions {
+public:
+ SBTraceOptions();
+
+ lldb::TraceType getType() const;
+
+ uint64_t getTraceBufferSize() const;
+
+ /// The trace parameters consist of any custom parameters
+ /// apart from the generic parameters such as
+ /// TraceType, trace_buffer_size and meta_data_buffer_size.
+ /// The returned parameters would be formatted as a JSON Dictionary.
+ lldb::SBStructuredData getTraceParams(lldb::SBError &error);
+
+ uint64_t getMetaDataBufferSize() const;
+
+ /// SBStructuredData is meant to hold any custom parameters
+ /// apart from meta buffer size and trace size. They should
+ /// be formatted as a JSON Dictionary.
+ void setTraceParams(lldb::SBStructuredData ¶ms);
+
+ void setType(lldb::TraceType type);
+
+ void setTraceBufferSize(uint64_t size);
+
+ void setMetaDataBufferSize(uint64_t size);
+
+ void setThreadID(lldb::tid_t thread_id);
+
+ lldb::tid_t getThreadID();
+
+ explicit operator bool() const;
+
+ bool IsValid();
+
+protected:
+ friend class SBProcess;
+ friend class SBTrace;
+
+ lldb::TraceOptionsSP m_traceoptions_sp;
+};
+}
+
+#endif /* SBTRACEOPTIONS_H_ */
diff --git a/linux-x64/clang/include/lldb/API/SBType.h b/linux-x64/clang/include/lldb/API/SBType.h
new file mode 100644
index 0000000..b3f92b7
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBType.h
@@ -0,0 +1,262 @@
+//===-- SBType.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_SBType_h_
+#define LLDB_SBType_h_
+
+#include "lldb/API/SBDefines.h"
+
+namespace lldb {
+
+class SBTypeList;
+
+class LLDB_API SBTypeMember {
+public:
+ SBTypeMember();
+
+ SBTypeMember(const lldb::SBTypeMember &rhs);
+
+ ~SBTypeMember();
+
+ lldb::SBTypeMember &operator=(const lldb::SBTypeMember &rhs);
+
+ explicit operator bool() const;
+
+ bool IsValid() const;
+
+ const char *GetName();
+
+ lldb::SBType GetType();
+
+ uint64_t GetOffsetInBytes();
+
+ uint64_t GetOffsetInBits();
+
+ bool IsBitfield();
+
+ uint32_t GetBitfieldSizeInBits();
+
+ bool GetDescription(lldb::SBStream &description,
+ lldb::DescriptionLevel description_level);
+
+protected:
+ friend class SBType;
+
+ void reset(lldb_private::TypeMemberImpl *);
+
+ lldb_private::TypeMemberImpl &ref();
+
+ const lldb_private::TypeMemberImpl &ref() const;
+
+ std::unique_ptr<lldb_private::TypeMemberImpl> m_opaque_up;
+};
+
+class SBTypeMemberFunction {
+public:
+ SBTypeMemberFunction();
+
+ SBTypeMemberFunction(const lldb::SBTypeMemberFunction &rhs);
+
+ ~SBTypeMemberFunction();
+
+ lldb::SBTypeMemberFunction &operator=(const lldb::SBTypeMemberFunction &rhs);
+
+ explicit operator bool() const;
+
+ bool IsValid() 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);
+
+protected:
+ friend class SBType;
+
+ void reset(lldb_private::TypeMemberFunctionImpl *);
+
+ lldb_private::TypeMemberFunctionImpl &ref();
+
+ const lldb_private::TypeMemberFunctionImpl &ref() const;
+
+ lldb::TypeMemberFunctionImplSP m_opaque_sp;
+};
+
+class SBType {
+public:
+ SBType();
+
+ SBType(const lldb::SBType &rhs);
+
+ ~SBType();
+
+ explicit operator bool() const;
+
+ bool IsValid() const;
+
+ uint64_t GetByteSize();
+
+ bool IsPointerType();
+
+ bool IsReferenceType();
+
+ bool IsFunctionType();
+
+ bool IsPolymorphicClass();
+
+ bool IsArrayType();
+
+ bool IsVectorType();
+
+ bool IsTypedefType();
+
+ bool IsAnonymousType();
+
+ lldb::SBType GetPointerType();
+
+ lldb::SBType GetPointeeType();
+
+ lldb::SBType GetReferenceType();
+
+ lldb::SBType GetTypedefedType();
+
+ lldb::SBType GetDereferencedType();
+
+ lldb::SBType GetUnqualifiedType();
+
+ lldb::SBType GetArrayElementType();
+
+ lldb::SBType GetArrayType(uint64_t size);
+
+ lldb::SBType GetVectorElementType();
+
+ lldb::SBType GetCanonicalType();
+ // Get the "lldb::BasicType" enumeration for a type. If a type is not a basic
+ // type eBasicTypeInvalid will be returned
+ lldb::BasicType GetBasicType();
+
+ // The call below confusing and should really be renamed to "CreateBasicType"
+ lldb::SBType GetBasicType(lldb::BasicType type);
+
+ uint32_t GetNumberOfFields();
+
+ uint32_t GetNumberOfDirectBaseClasses();
+
+ uint32_t GetNumberOfVirtualBaseClasses();
+
+ lldb::SBTypeMember GetFieldAtIndex(uint32_t idx);
+
+ lldb::SBTypeMember GetDirectBaseClassAtIndex(uint32_t idx);
+
+ lldb::SBTypeMember GetVirtualBaseClassAtIndex(uint32_t idx);
+
+ lldb::SBTypeEnumMemberList GetEnumMembers();
+
+ uint32_t GetNumberOfTemplateArguments();
+
+ lldb::SBType GetTemplateArgumentType(uint32_t idx);
+
+ lldb::TemplateArgumentKind GetTemplateArgumentKind(uint32_t idx);
+
+ lldb::SBType GetFunctionReturnType();
+
+ lldb::SBTypeList GetFunctionArgumentTypes();
+
+ uint32_t GetNumberOfMemberFunctions();
+
+ lldb::SBTypeMemberFunction GetMemberFunctionAtIndex(uint32_t idx);
+
+ const char *GetName();
+
+ const char *GetDisplayTypeName();
+
+ lldb::TypeClass GetTypeClass();
+
+ bool IsTypeComplete();
+
+ uint32_t GetTypeFlags();
+
+ bool GetDescription(lldb::SBStream &description,
+ lldb::DescriptionLevel description_level);
+
+ lldb::SBType &operator=(const lldb::SBType &rhs);
+
+ bool operator==(lldb::SBType &rhs);
+
+ bool operator!=(lldb::SBType &rhs);
+
+protected:
+ lldb_private::TypeImpl &ref();
+
+ const lldb_private::TypeImpl &ref() const;
+
+ lldb::TypeImplSP GetSP();
+
+ void SetSP(const lldb::TypeImplSP &type_impl_sp);
+
+ lldb::TypeImplSP m_opaque_sp;
+
+ friend class SBFunction;
+ friend class SBModule;
+ friend class SBTarget;
+ friend class SBTypeEnumMember;
+ friend class SBTypeEnumMemberList;
+ friend class SBTypeNameSpecifier;
+ friend class SBTypeMember;
+ friend class SBTypeMemberFunction;
+ friend class SBTypeList;
+ friend class SBValue;
+
+ SBType(const lldb_private::CompilerType &);
+ SBType(const lldb::TypeSP &);
+ SBType(const lldb::TypeImplSP &);
+};
+
+class SBTypeList {
+public:
+ SBTypeList();
+
+ SBTypeList(const lldb::SBTypeList &rhs);
+
+ ~SBTypeList();
+
+ lldb::SBTypeList &operator=(const lldb::SBTypeList &rhs);
+
+ explicit operator bool() const;
+
+ bool IsValid();
+
+ void Append(lldb::SBType type);
+
+ lldb::SBType GetTypeAtIndex(uint32_t index);
+
+ uint32_t GetSize();
+
+private:
+ std::unique_ptr<lldb_private::TypeListImpl> m_opaque_up;
+ friend class SBModule;
+ friend class SBCompileUnit;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBType_h_
diff --git a/linux-x64/clang/include/lldb/API/SBTypeCategory.h b/linux-x64/clang/include/lldb/API/SBTypeCategory.h
new file mode 100644
index 0000000..c0f4cee
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBTypeCategory.h
@@ -0,0 +1,116 @@
+//===-- SBTypeCategory.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_SBTypeCategory_h_
+#define LLDB_SBTypeCategory_h_
+
+#include "lldb/API/SBDefines.h"
+
+namespace lldb {
+
+class LLDB_API SBTypeCategory {
+public:
+ SBTypeCategory();
+
+ SBTypeCategory(const lldb::SBTypeCategory &rhs);
+
+ ~SBTypeCategory();
+
+ explicit operator bool() const;
+
+ bool IsValid() 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();
+
+ SBTypeNameSpecifier GetTypeNameSpecifierForFilterAtIndex(uint32_t);
+
+ SBTypeNameSpecifier GetTypeNameSpecifierForFormatAtIndex(uint32_t);
+
+ SBTypeNameSpecifier GetTypeNameSpecifierForSummaryAtIndex(uint32_t);
+
+ SBTypeNameSpecifier GetTypeNameSpecifierForSyntheticAtIndex(uint32_t);
+
+ SBTypeFilter GetFilterForType(SBTypeNameSpecifier);
+
+ SBTypeFormat GetFormatForType(SBTypeNameSpecifier);
+
+ SBTypeSummary GetSummaryForType(SBTypeNameSpecifier);
+
+ SBTypeSynthetic GetSyntheticForType(SBTypeNameSpecifier);
+
+ SBTypeFilter GetFilterAtIndex(uint32_t);
+
+ SBTypeFormat GetFormatAtIndex(uint32_t);
+
+ SBTypeSummary GetSummaryAtIndex(uint32_t);
+
+ SBTypeSynthetic GetSyntheticAtIndex(uint32_t);
+
+ bool AddTypeFormat(SBTypeNameSpecifier, SBTypeFormat);
+
+ bool DeleteTypeFormat(SBTypeNameSpecifier);
+
+ bool AddTypeSummary(SBTypeNameSpecifier, SBTypeSummary);
+
+ bool DeleteTypeSummary(SBTypeNameSpecifier);
+
+ bool AddTypeFilter(SBTypeNameSpecifier, SBTypeFilter);
+
+ bool DeleteTypeFilter(SBTypeNameSpecifier);
+
+ bool AddTypeSynthetic(SBTypeNameSpecifier, SBTypeSynthetic);
+
+ bool DeleteTypeSynthetic(SBTypeNameSpecifier);
+
+ lldb::SBTypeCategory &operator=(const lldb::SBTypeCategory &rhs);
+
+ bool operator==(lldb::SBTypeCategory &rhs);
+
+ bool operator!=(lldb::SBTypeCategory &rhs);
+
+protected:
+ friend class SBDebugger;
+
+ lldb::TypeCategoryImplSP GetSP();
+
+ void SetSP(const lldb::TypeCategoryImplSP &typecategory_impl_sp);
+
+ TypeCategoryImplSP m_opaque_sp;
+
+ SBTypeCategory(const lldb::TypeCategoryImplSP &);
+
+ SBTypeCategory(const char *);
+
+ bool IsDefaultCategory();
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBTypeCategory_h_
diff --git a/linux-x64/clang/include/lldb/API/SBTypeEnumMember.h b/linux-x64/clang/include/lldb/API/SBTypeEnumMember.h
new file mode 100644
index 0000000..2410dbc
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBTypeEnumMember.h
@@ -0,0 +1,83 @@
+
+//===-- SBTypeEnumMember.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_SBTypeEnumMember_h_
+#define LLDB_SBTypeEnumMember_h_
+
+#include "lldb/API/SBDefines.h"
+
+namespace lldb {
+
+class LLDB_API SBTypeEnumMember {
+public:
+ SBTypeEnumMember();
+
+ SBTypeEnumMember(const SBTypeEnumMember &rhs);
+
+ ~SBTypeEnumMember();
+
+ SBTypeEnumMember &operator=(const SBTypeEnumMember &rhs);
+
+ explicit operator bool() const;
+
+ bool IsValid() const;
+
+ int64_t GetValueAsSigned();
+
+ uint64_t GetValueAsUnsigned();
+
+ const char *GetName();
+
+ lldb::SBType GetType();
+
+ bool GetDescription(lldb::SBStream &description,
+ lldb::DescriptionLevel description_level);
+
+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 &);
+};
+
+class SBTypeEnumMemberList {
+public:
+ SBTypeEnumMemberList();
+
+ SBTypeEnumMemberList(const SBTypeEnumMemberList &rhs);
+
+ ~SBTypeEnumMemberList();
+
+ SBTypeEnumMemberList &operator=(const SBTypeEnumMemberList &rhs);
+
+ explicit operator bool() const;
+
+ bool IsValid();
+
+ void Append(SBTypeEnumMember entry);
+
+ SBTypeEnumMember GetTypeEnumMemberAtIndex(uint32_t index);
+
+ uint32_t GetSize();
+
+private:
+ std::unique_ptr<lldb_private::TypeEnumMemberListImpl> m_opaque_up;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBTypeEnumMember_h_
diff --git a/linux-x64/clang/include/lldb/API/SBTypeFilter.h b/linux-x64/clang/include/lldb/API/SBTypeFilter.h
new file mode 100644
index 0000000..4a0de11
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBTypeFilter.h
@@ -0,0 +1,74 @@
+//===-- SBTypeFilter.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_SBTypeFilter_h_
+#define LLDB_SBTypeFilter_h_
+
+#include "lldb/API/SBDefines.h"
+
+namespace lldb {
+
+class LLDB_API SBTypeFilter {
+public:
+ SBTypeFilter();
+
+ SBTypeFilter(uint32_t options); // see lldb::eTypeOption values
+
+ SBTypeFilter(const lldb::SBTypeFilter &rhs);
+
+ ~SBTypeFilter();
+
+ explicit operator bool() const;
+
+ bool IsValid() const;
+
+ 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);
+
+ lldb::SBTypeFilter &operator=(const lldb::SBTypeFilter &rhs);
+
+ bool IsEqualTo(lldb::SBTypeFilter &rhs);
+
+ bool operator==(lldb::SBTypeFilter &rhs);
+
+ bool operator!=(lldb::SBTypeFilter &rhs);
+
+protected:
+ friend class SBDebugger;
+ friend class SBTypeCategory;
+ friend class SBValue;
+
+ lldb::TypeFilterImplSP GetSP();
+
+ void SetSP(const lldb::TypeFilterImplSP &typefilter_impl_sp);
+
+ lldb::TypeFilterImplSP m_opaque_sp;
+
+ SBTypeFilter(const lldb::TypeFilterImplSP &);
+
+ bool CopyOnWrite_Impl();
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBTypeFilter_h_
diff --git a/linux-x64/clang/include/lldb/API/SBTypeFormat.h b/linux-x64/clang/include/lldb/API/SBTypeFormat.h
new file mode 100644
index 0000000..8a0ac77
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBTypeFormat.h
@@ -0,0 +1,78 @@
+//===-- SBTypeFormat.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_SBTypeFormat_h_
+#define LLDB_SBTypeFormat_h_
+
+#include "lldb/API/SBDefines.h"
+
+namespace lldb {
+
+class LLDB_API SBTypeFormat {
+public:
+ SBTypeFormat();
+
+ SBTypeFormat(lldb::Format format,
+ uint32_t options = 0); // see lldb::eTypeOption values
+
+ SBTypeFormat(const char *type,
+ uint32_t options = 0); // see lldb::eTypeOption values
+
+ SBTypeFormat(const lldb::SBTypeFormat &rhs);
+
+ ~SBTypeFormat();
+
+ explicit operator bool() const;
+
+ bool IsValid() const;
+
+ 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);
+
+ lldb::SBTypeFormat &operator=(const lldb::SBTypeFormat &rhs);
+
+ bool IsEqualTo(lldb::SBTypeFormat &rhs);
+
+ bool operator==(lldb::SBTypeFormat &rhs);
+
+ bool operator!=(lldb::SBTypeFormat &rhs);
+
+protected:
+ friend class SBDebugger;
+ friend class SBTypeCategory;
+ friend class SBValue;
+
+ lldb::TypeFormatImplSP GetSP();
+
+ void SetSP(const lldb::TypeFormatImplSP &typeformat_impl_sp);
+
+ lldb::TypeFormatImplSP m_opaque_sp;
+
+ SBTypeFormat(const lldb::TypeFormatImplSP &);
+
+ enum class Type { eTypeKeepSame, eTypeFormat, eTypeEnum };
+
+ bool CopyOnWrite_Impl(Type);
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBTypeFormat_h_
diff --git a/linux-x64/clang/include/lldb/API/SBTypeNameSpecifier.h b/linux-x64/clang/include/lldb/API/SBTypeNameSpecifier.h
new file mode 100644
index 0000000..9fe449d
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBTypeNameSpecifier.h
@@ -0,0 +1,65 @@
+//===-- SBTypeNameSpecifier.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_SBTypeNameSpecifier_h_
+#define LLDB_SBTypeNameSpecifier_h_
+
+#include "lldb/API/SBDefines.h"
+
+namespace lldb {
+
+class LLDB_API SBTypeNameSpecifier {
+public:
+ SBTypeNameSpecifier();
+
+ SBTypeNameSpecifier(const char *name, bool is_regex = false);
+
+ SBTypeNameSpecifier(SBType type);
+
+ SBTypeNameSpecifier(const lldb::SBTypeNameSpecifier &rhs);
+
+ ~SBTypeNameSpecifier();
+
+ explicit operator bool() const;
+
+ bool IsValid() const;
+
+ const char *GetName();
+
+ SBType GetType();
+
+ bool IsRegex();
+
+ bool GetDescription(lldb::SBStream &description,
+ lldb::DescriptionLevel description_level);
+
+ lldb::SBTypeNameSpecifier &operator=(const lldb::SBTypeNameSpecifier &rhs);
+
+ bool IsEqualTo(lldb::SBTypeNameSpecifier &rhs);
+
+ bool operator==(lldb::SBTypeNameSpecifier &rhs);
+
+ bool operator!=(lldb::SBTypeNameSpecifier &rhs);
+
+protected:
+ friend class SBDebugger;
+ friend class SBTypeCategory;
+
+ lldb::TypeNameSpecifierImplSP GetSP();
+
+ void SetSP(const lldb::TypeNameSpecifierImplSP &type_namespec_sp);
+
+ lldb::TypeNameSpecifierImplSP m_opaque_sp;
+
+ SBTypeNameSpecifier(const lldb::TypeNameSpecifierImplSP &);
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBTypeNameSpecifier_h_
diff --git a/linux-x64/clang/include/lldb/API/SBTypeSummary.h b/linux-x64/clang/include/lldb/API/SBTypeSummary.h
new file mode 100644
index 0000000..bb7121f
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBTypeSummary.h
@@ -0,0 +1,139 @@
+//===-- SBTypeSummary.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_SBTypeSummary_h_
+#define LLDB_SBTypeSummary_h_
+
+#include "lldb/API/SBDefines.h"
+
+namespace lldb {
+class LLDB_API SBTypeSummaryOptions {
+public:
+ SBTypeSummaryOptions();
+
+ SBTypeSummaryOptions(const lldb::SBTypeSummaryOptions &rhs);
+
+ SBTypeSummaryOptions(const lldb_private::TypeSummaryOptions *lldb_object_ptr);
+
+ ~SBTypeSummaryOptions();
+
+ explicit operator bool() const;
+
+ bool IsValid();
+
+ lldb::LanguageType GetLanguage();
+
+ lldb::TypeSummaryCapping GetCapping();
+
+ void SetLanguage(lldb::LanguageType);
+
+ void SetCapping(lldb::TypeSummaryCapping);
+
+protected:
+ friend class SBValue;
+
+ lldb_private::TypeSummaryOptions *operator->();
+
+ const lldb_private::TypeSummaryOptions *operator->() const;
+
+ lldb_private::TypeSummaryOptions *get();
+
+ lldb_private::TypeSummaryOptions &ref();
+
+ const lldb_private::TypeSummaryOptions &ref() const;
+
+ void SetOptions(const lldb_private::TypeSummaryOptions *lldb_object_ptr);
+
+private:
+ std::unique_ptr<lldb_private::TypeSummaryOptions> m_opaque_up;
+};
+
+class SBTypeSummary {
+public:
+ SBTypeSummary();
+
+ // Native function summary formatter callback
+ typedef bool (*FormatCallback)(SBValue, SBTypeSummaryOptions, SBStream &);
+
+ static SBTypeSummary
+ CreateWithSummaryString(const char *data,
+ uint32_t options = 0); // see lldb::eTypeOption values
+
+ 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
+
+ static SBTypeSummary CreateWithCallback(FormatCallback cb,
+ uint32_t options = 0,
+ const char *description = nullptr);
+
+ SBTypeSummary(const lldb::SBTypeSummary &rhs);
+
+ ~SBTypeSummary();
+
+ explicit operator bool() const;
+
+ bool IsValid() const;
+
+ 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);
+
+ lldb::SBTypeSummary &operator=(const lldb::SBTypeSummary &rhs);
+
+ bool DoesPrintValue(lldb::SBValue value);
+
+ bool IsEqualTo(lldb::SBTypeSummary &rhs);
+
+ bool operator==(lldb::SBTypeSummary &rhs);
+
+ bool operator!=(lldb::SBTypeSummary &rhs);
+
+protected:
+ friend class SBDebugger;
+ friend class SBTypeCategory;
+ friend class SBValue;
+
+ lldb::TypeSummaryImplSP GetSP();
+
+ void SetSP(const lldb::TypeSummaryImplSP &typefilter_impl_sp);
+
+ lldb::TypeSummaryImplSP m_opaque_sp;
+
+ SBTypeSummary(const lldb::TypeSummaryImplSP &);
+
+ bool CopyOnWrite_Impl();
+
+ bool ChangeSummaryType(bool want_script);
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBTypeSummary_h_
diff --git a/linux-x64/clang/include/lldb/API/SBTypeSynthetic.h b/linux-x64/clang/include/lldb/API/SBTypeSynthetic.h
new file mode 100644
index 0000000..c190643
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBTypeSynthetic.h
@@ -0,0 +1,80 @@
+//===-- SBTypeSynthetic.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_SBTypeSynthetic_h_
+#define LLDB_SBTypeSynthetic_h_
+
+#include "lldb/API/SBDefines.h"
+
+namespace lldb {
+
+class LLDB_API SBTypeSynthetic {
+public:
+ SBTypeSynthetic();
+
+ static SBTypeSynthetic
+ CreateWithClassName(const char *data,
+ uint32_t options = 0); // see lldb::eTypeOption values
+
+ static SBTypeSynthetic
+ CreateWithScriptCode(const char *data,
+ uint32_t options = 0); // see lldb::eTypeOption values
+
+ SBTypeSynthetic(const lldb::SBTypeSynthetic &rhs);
+
+ ~SBTypeSynthetic();
+
+ explicit operator bool() const;
+
+ bool IsValid() const;
+
+ bool IsClassCode();
+
+ bool IsClassName();
+
+ 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);
+
+ lldb::SBTypeSynthetic &operator=(const lldb::SBTypeSynthetic &rhs);
+
+ bool IsEqualTo(lldb::SBTypeSynthetic &rhs);
+
+ bool operator==(lldb::SBTypeSynthetic &rhs);
+
+ bool operator!=(lldb::SBTypeSynthetic &rhs);
+
+protected:
+ friend class SBDebugger;
+ friend class SBTypeCategory;
+ friend class SBValue;
+
+ lldb::ScriptedSyntheticChildrenSP GetSP();
+
+ void SetSP(const lldb::ScriptedSyntheticChildrenSP &typefilter_impl_sp);
+
+ lldb::ScriptedSyntheticChildrenSP m_opaque_sp;
+
+ SBTypeSynthetic(const lldb::ScriptedSyntheticChildrenSP &);
+
+ bool CopyOnWrite_Impl();
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBTypeSynthetic_h_
diff --git a/linux-x64/clang/include/lldb/API/SBUnixSignals.h b/linux-x64/clang/include/lldb/API/SBUnixSignals.h
new file mode 100644
index 0000000..c7e99d1
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBUnixSignals.h
@@ -0,0 +1,71 @@
+//===-- SBUnixSignals.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_SBUnixSignals_h_
+#define LLDB_SBUnixSignals_h_
+
+#include "lldb/API/SBDefines.h"
+
+namespace lldb {
+
+class LLDB_API SBUnixSignals {
+public:
+ SBUnixSignals();
+
+ SBUnixSignals(const lldb::SBUnixSignals &rhs);
+
+ ~SBUnixSignals();
+
+ const SBUnixSignals &operator=(const lldb::SBUnixSignals &rhs);
+
+ void Clear();
+
+ explicit operator bool() const;
+
+ bool IsValid() 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;
+
+protected:
+ friend class SBProcess;
+ friend class SBPlatform;
+
+ SBUnixSignals(lldb::ProcessSP &process_sp);
+
+ SBUnixSignals(lldb::PlatformSP &platform_sp);
+
+ lldb::UnixSignalsSP GetSP() const;
+
+ void SetSP(const lldb::UnixSignalsSP &signals_sp);
+
+private:
+ lldb::UnixSignalsWP m_opaque_wp;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBUnixSignals_h_
diff --git a/linux-x64/clang/include/lldb/API/SBValue.h b/linux-x64/clang/include/lldb/API/SBValue.h
new file mode 100644
index 0000000..c36ba20
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBValue.h
@@ -0,0 +1,435 @@
+//===-- SBValue.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_SBValue_h_
+#define LLDB_SBValue_h_
+
+#include "lldb/API/SBData.h"
+#include "lldb/API/SBDefines.h"
+#include "lldb/API/SBType.h"
+
+class ValueImpl;
+class ValueLocker;
+
+namespace lldb {
+
+class LLDB_API SBValue {
+public:
+ SBValue();
+
+ SBValue(const lldb::SBValue &rhs);
+
+ lldb::SBValue &operator=(const lldb::SBValue &rhs);
+
+ ~SBValue();
+
+ explicit operator bool() const;
+
+ bool IsValid();
+
+ 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(lldb::SBError &error, int64_t fail_value = 0);
+
+ uint64_t GetValueAsUnsigned(lldb::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();
+
+ // If you call this on a newly created ValueObject, it will always return
+ // false.
+ bool GetValueDidChange();
+
+ const char *GetSummary();
+
+ const char *GetSummary(lldb::SBStream &stream,
+ lldb::SBTypeSummaryOptions &options);
+
+ const char *GetObjectDescription();
+
+ const char *GetTypeValidatorResult();
+
+ 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();
+
+ // Deprecated - use the one that takes SBError&
+ 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);
+
+ lldb::SBValue CreateChildAtOffset(const char *name, uint32_t offset,
+ lldb::SBType type);
+
+ // Deprecated - use the expression evaluator to perform type casting
+ lldb::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);
+
+ // this has no address! GetAddress() and GetLoadAddress() as well as
+ // AddressOf() on the return of this call all return invalid
+ lldb::SBValue CreateValueFromData(const char *name, lldb::SBData data,
+ lldb::SBType type);
+
+ /// 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 \a synthetic_allowed
+ /// is \b 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 SBValue::Dereference.
+ ///
+ /// 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 \a synthetic_allowed is \b 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] can_create_synthetic
+ /// If \b 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(uint32_t idx,
+ lldb::DynamicValueType use_dynamic,
+ bool can_create_synthetic);
+
+ // Matches children of this object only and will match base classes and
+ // member names if this is a clang typed object.
+ uint32_t GetIndexOfChildWithName(const char *name);
+
+ // Matches child members of this object and child members of any base
+ // classes.
+ lldb::SBValue GetChildMemberWithName(const char *name);
+
+ // Matches child members of this object and child members of any base
+ // classes.
+ lldb::SBValue GetChildMemberWithName(const char *name,
+ lldb::DynamicValueType use_dynamic);
+
+ // Expands nested expressions like .a->b[0].c[1]->d
+ lldb::SBValue GetValueForExpressionPath(const char *expr_path);
+
+ lldb::SBValue AddressOf();
+
+ lldb::addr_t GetLoadAddress();
+
+ lldb::SBAddress GetAddress();
+
+ /// 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 SBData.
+ ///
+ /// \param[in] 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[in] 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
+ /// An SBData with the contents of the copied items, on success.
+ /// An empty SBData otherwise.
+ lldb::SBData GetPointeeData(uint32_t item_idx = 0, uint32_t item_count = 1);
+
+ /// 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::SBData GetData();
+
+ bool SetData(lldb::SBData &data, lldb::SBError &error);
+
+ lldb::SBDeclaration GetDeclaration();
+
+ /// Find out if a SBValue might have children.
+ ///
+ /// This call is much more efficient than GetNumChildren() as it
+ /// doesn't need to complete the underlying type. This is designed
+ /// to be used in a UI environment in order to detect if the
+ /// disclosure triangle should be displayed or not.
+ ///
+ /// This function returns true for class, union, structure,
+ /// pointers, references, arrays and more. Again, it does so without
+ /// doing any expensive type completion.
+ ///
+ /// \return
+ /// Returns \b true if the SBValue might have children, or \b
+ /// false otherwise.
+ bool MightHaveChildren();
+
+ bool IsRuntimeSupportValue();
+
+ uint32_t GetNumChildren();
+
+ uint32_t GetNumChildren(uint32_t max);
+
+ void *GetOpaqueType();
+
+ lldb::SBTarget GetTarget();
+
+ lldb::SBProcess GetProcess();
+
+ lldb::SBThread GetThread();
+
+ lldb::SBFrame GetFrame();
+
+ lldb::SBValue Dereference();
+
+ // Deprecated - please use GetType().IsPointerType() instead.
+ bool TypeIsPointerType();
+
+ lldb::SBType GetType();
+
+ lldb::SBValue Persist();
+
+ bool GetDescription(lldb::SBStream &description);
+
+ bool GetExpressionPath(lldb::SBStream &description);
+
+ 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;
+
+ SBValue(const lldb::ValueObjectSP &value_sp);
+
+ /// 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
+ /// locations of a variable or a variable path is not yet supported,
+ /// though we plan to support it in the future.
+ ///
+ /// \param[in] read
+ /// Stop when this value is accessed.
+ ///
+ /// \param[in] write
+ /// Stop when this value is modified
+ ///
+ /// \param[out] error
+ /// An error object. Contains the reason if there is some failure.
+ ///
+ /// \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 Watch(bool resolve_location, bool read, bool write,
+ SBError &error);
+
+ // Backward compatibility fix in the interim.
+ lldb::SBWatchpoint Watch(bool resolve_location, bool read, bool write);
+
+ /// Watch this value that this value points to 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
+ /// locations of a variable or a variable path is not yet supported,
+ /// though we plan to support it in the future.
+ ///
+ /// \param[in] read
+ /// Stop when this value is accessed.
+ ///
+ /// \param[in] write
+ /// Stop when this value is modified
+ ///
+ /// \param[out] error
+ /// An error object. Contains the reason if there is some failure.
+ ///
+ /// \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);
+
+ /// 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;
+
+protected:
+ friend class SBBlock;
+ friend class SBFrame;
+ friend class SBTarget;
+ friend class SBThread;
+ friend class SBValueList;
+
+ /// Get the appropriate ValueObjectSP from this SBValue, consulting the
+ /// use_dynamic and use_synthetic options passed in to SetSP when the
+ /// SBValue's contents were set. Since this often requires examining memory,
+ /// and maybe even running code, it needs to acquire the Target API and
+ /// Process StopLock.
+ /// Those are held in an opaque class ValueLocker which is currently local to
+ /// SBValue.cpp.
+ /// So you don't have to get these yourself just default construct a
+ /// ValueLocker, and pass it into this.
+ /// If we need to make a ValueLocker and use it in some other .cpp file, we'll
+ /// have to move it to
+ /// ValueObject.h/cpp or somewhere else convenient. We haven't needed to so
+ /// far.
+ ///
+ /// \param[in] value_locker
+ /// An object that will hold the Target API, and Process RunLocks, and
+ /// auto-destroy them when it goes out of scope. Currently this is only
+ /// useful in
+ /// SBValue.cpp.
+ ///
+ /// \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(ValueLocker &value_locker) const;
+
+ // these calls do the right thing WRT adjusting their settings according to
+ // the target's preferences
+ void SetSP(const lldb::ValueObjectSP &sp);
+
+ void SetSP(const lldb::ValueObjectSP &sp, bool use_synthetic);
+
+ void SetSP(const lldb::ValueObjectSP &sp, lldb::DynamicValueType use_dynamic);
+
+ void SetSP(const lldb::ValueObjectSP &sp, lldb::DynamicValueType use_dynamic,
+ bool use_synthetic);
+
+ void SetSP(const lldb::ValueObjectSP &sp, lldb::DynamicValueType use_dynamic,
+ bool use_synthetic, const char *name);
+
+private:
+ typedef std::shared_ptr<ValueImpl> ValueImplSP;
+ ValueImplSP m_opaque_sp;
+
+ void SetSP(ValueImplSP impl_sp);
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBValue_h_
diff --git a/linux-x64/clang/include/lldb/API/SBValueList.h b/linux-x64/clang/include/lldb/API/SBValueList.h
new file mode 100644
index 0000000..d305b35
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBValueList.h
@@ -0,0 +1,75 @@
+//===-- SBValueList.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_SBValueList_h_
+#define LLDB_SBValueList_h_
+
+#include "lldb/API/SBDefines.h"
+
+class ValueListImpl;
+
+namespace lldb {
+
+class LLDB_API SBValueList {
+public:
+ SBValueList();
+
+ SBValueList(const lldb::SBValueList &rhs);
+
+ ~SBValueList();
+
+ explicit operator bool() const;
+
+ bool IsValid() 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 GetFirstValueByName(const char *name) const;
+
+ lldb::SBValue FindValueObjectByUID(lldb::user_id_t uid);
+
+ const lldb::SBValueList &operator=(const lldb::SBValueList &rhs);
+
+protected:
+ // only useful for visualizing the pointer or comparing two SBValueLists to
+ // see if they are backed by the same underlying Impl.
+ void *opaque_ptr();
+
+private:
+ friend class SBFrame;
+
+ SBValueList(const ValueListImpl *lldb_object_ptr);
+
+ void Append(lldb::ValueObjectSP &val_obj_sp);
+
+ void CreateIfNeeded();
+
+ ValueListImpl *operator->();
+
+ ValueListImpl &operator*();
+
+ const ValueListImpl *operator->() const;
+
+ const ValueListImpl &operator*() const;
+
+ ValueListImpl &ref();
+
+ std::unique_ptr<ValueListImpl> m_opaque_up;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBValueList_h_
diff --git a/linux-x64/clang/include/lldb/API/SBVariablesOptions.h b/linux-x64/clang/include/lldb/API/SBVariablesOptions.h
new file mode 100644
index 0000000..e226ce4
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBVariablesOptions.h
@@ -0,0 +1,82 @@
+//===-- SBVariablesOptions.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_SBVariablesOptions_h_
+#define LLDB_SBVariablesOptions_h_
+
+#include "lldb/API/SBDefines.h"
+
+class VariablesOptionsImpl;
+
+namespace lldb {
+
+class LLDB_API SBVariablesOptions {
+public:
+ SBVariablesOptions();
+
+ SBVariablesOptions(const SBVariablesOptions &options);
+
+ SBVariablesOptions &operator=(const SBVariablesOptions &options);
+
+ ~SBVariablesOptions();
+
+ explicit operator bool() const;
+
+ bool IsValid() 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);
+
+protected:
+ VariablesOptionsImpl *operator->();
+
+ const VariablesOptionsImpl *operator->() const;
+
+ VariablesOptionsImpl *get();
+
+ VariablesOptionsImpl &ref();
+
+ const VariablesOptionsImpl &ref() const;
+
+ SBVariablesOptions(VariablesOptionsImpl *lldb_object_ptr);
+
+ void SetOptions(VariablesOptionsImpl *lldb_object_ptr);
+
+private:
+ std::unique_ptr<VariablesOptionsImpl> m_opaque_up;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBValue_h_
diff --git a/linux-x64/clang/include/lldb/API/SBWatchpoint.h b/linux-x64/clang/include/lldb/API/SBWatchpoint.h
new file mode 100644
index 0000000..05ff0ca
--- /dev/null
+++ b/linux-x64/clang/include/lldb/API/SBWatchpoint.h
@@ -0,0 +1,85 @@
+//===-- SBWatchpoint.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_SBWatchpoint_h_
+#define LLDB_SBWatchpoint_h_
+
+#include "lldb/API/SBDefines.h"
+
+namespace lldb {
+
+class LLDB_API SBWatchpoint {
+public:
+ SBWatchpoint();
+
+ SBWatchpoint(const lldb::SBWatchpoint &rhs);
+
+ SBWatchpoint(const lldb::WatchpointSP &wp_sp);
+
+ ~SBWatchpoint();
+
+ const lldb::SBWatchpoint &operator=(const lldb::SBWatchpoint &rhs);
+
+ explicit operator bool() const;
+
+ bool operator==(const SBWatchpoint &rhs) const;
+
+ bool operator!=(const SBWatchpoint &rhs) const;
+
+ bool IsValid() const;
+
+ SBError GetError();
+
+ watch_id_t GetID();
+
+ /// With -1 representing an invalid hardware index.
+ 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);
+
+ const char *GetCondition();
+
+ void SetCondition(const char *condition);
+
+ bool GetDescription(lldb::SBStream &description, DescriptionLevel level);
+
+ void Clear();
+
+ lldb::WatchpointSP GetSP() const;
+
+ void SetSP(const lldb::WatchpointSP &sp);
+
+ static bool EventIsWatchpointEvent(const lldb::SBEvent &event);
+
+ static lldb::WatchpointEventType
+ GetWatchpointEventTypeFromEvent(const lldb::SBEvent &event);
+
+ static lldb::SBWatchpoint GetWatchpointFromEvent(const lldb::SBEvent &event);
+
+private:
+ friend class SBTarget;
+ friend class SBValue;
+
+ std::weak_ptr<lldb_private::Watchpoint> m_opaque_wp;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBWatchpoint_h_