Add swift 4.0 include files to build plugin on MacOS.
# Run native SOS/lldbplugin tests
if [ $__Test == 1 ]; then
- "$__ProjectRoot/src/SOS/tests/testsos.sh" "$__ProjectRoot" "$__CMakeBinDir" "$__RootBinDir/$__BuildType/bin" "$__LogFileDir" "$__BuildArch"
+ if [ "$__BuildOS" == "OSX" ]; then
+ __Plugin=$__CMakeBinDir/libsosplugin.dylib
+ else
+ __Plugin=$__CMakeBinDir/libsosplugin.so
+ fi
+ "$__ProjectRoot/src/SOS/tests/testsos.sh" "$__ProjectRoot" "$__Plugin" "$__RootBinDir/$__BuildType/bin" "$__LogFileDir" "$__BuildArch"
fi
echo "BUILD: Repo sucessfully built."
fi
cmake_extra_defines=
-if [[ -n "$LLDB_LIB_DIR" ]]; then
- cmake_extra_defines="$cmake_extra_defines -DWITH_LLDB_LIBS=$LLDB_LIB_DIR"
-fi
-if [[ -n "$LLDB_INCLUDE_DIR" ]]; then
- cmake_extra_defines="$cmake_extra_defines -DWITH_LLDB_INCLUDES=$LLDB_INCLUDE_DIR"
-fi
if [[ -n "$CROSSCOMPONENT" ]]; then
cmake_extra_defines="$cmake_extra_defines -DCLR_CROSS_COMPONENTS_BUILD=1"
fi
set(REQUIRE_LLDBPLUGIN ${CLR_CMAKE_PLATFORM_LINUX} CACHE BOOL "Require building the SOS plugin for LLDB.")
if(SKIP_LLDBPLUGIN)
- SET(REQUIRE_LLDBPLUGIN false)
+ set(REQUIRE_LLDBPLUGIN false)
endif()
if(CLR_CMAKE_PLATFORM_ARCH_AMD64)
add_definitions(-DBIT64)
elseif(CLR_CMAKE_PLATFORM_ARCH_ARM)
add_definitions(-DBIT64)
- SET(REQUIRE_LLDBPLUGIN false)
+ set(REQUIRE_LLDBPLUGIN false)
endif()
-set(LLVM_HOST_DIR "$ENV{LLVM_HOME}")
-set(WITH_LLDB_LIBS "${LLVM_HOST_DIR}/lib" CACHE PATH "Path to LLDB libraries")
-set(WITH_LLDB_INCLUDES "${LLVM_HOST_DIR}/include" CACHE PATH "Path to LLDB headers")
+if(NOT $ENV{LLVM_HOME} STREQUAL "")
+ set(LLDB_INCLUDE_DIR "$ENV{LLVM_HOME}/include")
+ set(LLDB_LIB_DIR "$ENV{LLVM_HOME}/lib")
+else()
+ if(NOT $ENV{LLDB_INCLUDE_DIR} STREQUAL "")
+ set(LLDB_INCLUDE_DIR "$ENV{LLDB_INCLUDE_DIR}")
+ endif()
+ if(NOT $ENV{LLDB_LIB_DIR} STREQUAL "")
+ set(LLDB_LIB_DIR "$ENV{LLDB_LIB_DIR}")
+ endif()
+endif()
+
+set(WITH_LLDB_LIBS "${LLDB_LIB_DIR}" CACHE PATH "Path to LLDB libraries")
+set(WITH_LLDB_INCLUDES "${LLDB_INCLUDE_DIR}" CACHE PATH "Path to LLDB headers")
+
+message(STATUS "WITH_LLDB_LIBS: ${WITH_LLDB_LIBS}")
+message(STATUS "WITH_LLDB_INCLUDES: ${WITH_LLDB_INCLUDES}")
if(NOT ENABLE_LLDBPLUGIN)
return()
endif()
-if (CLR_CMAKE_PLATFORM_DARWIN)
+if(NOT $ENV{LLDB_LIB} STREQUAL "")
+ set(LLDB_LIB "$ENV{LLDB_LIB}")
+ message(STATUS "LLDB_LIB: ${LLDB_LIB}")
+else()
# Check for LLDB library
- find_library(LLDB NAMES LLDB lldb lldb-6.0 lldb-5.0 lldb-4.0 lldb-3.9 lldb-3.8 lldb-3.7 lldb-3.6 lldb-3.5 PATHS "${WITH_LLDB_LIBS}" PATH_SUFFIXES llvm NO_DEFAULT_PATH)
- find_library(LLDB NAMES LLDB lldb lldb-6.0 lldb-5.0 lldb-4.0 lldb-3.9 lldb-3.8 lldb-3.7 lldb-3.6 lldb-3.5 PATH_SUFFIXES llvm)
- if(LLDB STREQUAL LLDB-NOTFOUND)
- if(REQUIRE_LLDBPLUGIN)
- set(MESSAGE_MODE FATAL_ERROR)
- else()
- set(MESSAGE_MODE WARNING)
+ if(CLR_CMAKE_PLATFORM_DARWIN)
+ find_library(LLDB_LIB NAMES LLDB lldb lldb-6.0 lldb-5.0 lldb-4.0 lldb-3.9 lldb-3.8 lldb-3.7 lldb-3.6 lldb-3.5 PATHS "${WITH_LLDB_LIBS}" PATH_SUFFIXES llvm NO_DEFAULT_PATH)
+ find_library(LLDB_LIB NAMES LLDB lldb lldb-6.0 lldb-5.0 lldb-4.0 lldb-3.9 lldb-3.8 lldb-3.7 lldb-3.6 lldb-3.5 PATH_SUFFIXES llvm)
+ if(LLDB_LIB STREQUAL LLDB_LIB-NOTFOUND)
+ set(LLDB_LIB "/Applications/Xcode.app/Contents/SharedFrameworks/LLDB.framework/LLDB")
+ if (NOT EXISTS ${LLDB_LIB})
+ if(REQUIRE_LLDBPLUGIN)
+ set(MESSAGE_MODE FATAL_ERROR)
+ else()
+ set(MESSAGE_MODE WARNING)
+ endif()
+ message(${MESSAGE_MODE} "Cannot find lldb library. Try installing Xcode. You may need to set LLVM_HOME, LLDB_LIB_DIR or LLDB_LIB if the build still can't find it.")
+ return()
+ endif()
endif()
- message(${MESSAGE_MODE} "Cannot find lldb-3.5, lldb-3.6, lldb-3.8, lldb-3.9, lldb-4.0, lldb-5.0 or lldb-6.0. Try installing liblldb-3.9-dev (or the appropriate package for your platform). You may need to set LLVM_HOME if the build still can't find it.")
-
- return()
+ message(STATUS "LLDB_LIB: ${LLDB_LIB}")
endif()
-
- message(STATUS "LLDB: ${LLDB}")
endif()
# Check for LLDB headers
find_path(LLDB_H "lldb/API/LLDB.h" PATHS "/usr/local/llvm38/include")
if(LLDB_H STREQUAL LLDB_H-NOTFOUND)
- if(REQUIRE_LLDBPLUGIN)
- set(MESSAGE_MODE FATAL_ERROR)
+ if(CLR_CMAKE_PLATFORM_DARWIN)
+ set(LLDB_H "swift")
else()
- set(MESSAGE_MODE WARNING)
+ if(REQUIRE_LLDBPLUGIN)
+ set(MESSAGE_MODE FATAL_ERROR)
+ else()
+ set(MESSAGE_MODE WARNING)
+ endif()
+ message(${MESSAGE_MODE} "Cannot find LLDB.h Try installing lldb-3.9-dev (or the appropriate package for your platform). You may need to set LLVM_HOME or LLDB_INCLUDE_DIR if the build still can't find it.")
+ return()
endif()
- message(${MESSAGE_MODE} "Cannot find LLDB.h Try installing lldb-3.9-dev (or the appropriate package for your platform). You may need to set LLVM_HOME if the build still can't find it.")
- return()
endif()
message(STATUS "LLDB_H: ${LLDB_H}")
_add_library(sosplugin SHARED ${SOURCES})
-if (CLR_CMAKE_PLATFORM_DARWIN)
- target_link_libraries(sosplugin ${LLDB})
+if(NOT ${LLDB_LIB} STREQUAL "")
+ target_link_libraries(sosplugin ${LLDB_LIB})
endif()
# add the install targets
--- /dev/null
+//===-- LLDB.h --------------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_LLDB_h_
+#define LLDB_LLDB_h_
+
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
+#include "lldb/API/SBAddress.h"
+#include "lldb/API/SBAttachInfo.h"
+#include "lldb/API/SBBlock.h"
+#include "lldb/API/SBBreakpoint.h"
+#include "lldb/API/SBBreakpointLocation.h"
+#include "lldb/API/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/SBQueue.h"
+#include "lldb/API/SBQueueItem.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/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_
--- /dev/null
+//===-- SBAddress.h ---------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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);
+
+ 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();
+
+ lldb::AddressClass GetAddressClass();
+
+protected:
+ friend class SBBlock;
+ 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;
+
+ 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_ap;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBAddress_h_
--- /dev/null
+//===-- SBAttachInfo.h ------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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] 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.
+ //------------------------------------------------------------------
+ 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] 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.
+ //------------------------------------------------------------------
+ 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
+ /// 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);
+
+protected:
+ friend class SBTarget;
+
+ lldb_private::ProcessAttachInfo &ref();
+
+ ProcessAttachInfoSP m_opaque_sp;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBAttachInfo_h_
--- /dev/null
+//===-- SBBlock.h -----------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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;
+
+ 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_
--- /dev/null
+//===-- SBBreakpoint.h ------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_SBBreakpoint_h_
+#define LLDB_SBBreakpoint_h_
+
+#include "lldb/API/SBDefines.h"
+
+class SBBreakpointListImpl;
+
+namespace lldb {
+
+class LLDB_API SBBreakpoint {
+public:
+ typedef bool (*BreakpointHitCallback)(void *baton, SBProcess &process,
+ SBThread &thread,
+ lldb::SBBreakpointLocation &location);
+
+ SBBreakpoint();
+
+ SBBreakpoint(const lldb::SBBreakpoint &rhs);
+
+ ~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;
+
+ 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 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(BreakpointHitCallback 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);
+
+private:
+ friend class SBBreakpointList;
+ friend class SBBreakpointLocation;
+ friend class SBTarget;
+
+ SBBreakpoint(const lldb::BreakpointSP &bp_sp);
+
+ lldb_private::Breakpoint *operator->() const;
+
+ lldb_private::Breakpoint *get() const;
+
+ lldb::BreakpointSP &operator*();
+
+ const lldb::BreakpointSP &operator*() const;
+
+ static bool PrivateBreakpointHitCallback(
+ void *baton, lldb_private::StoppointCallbackContext *context,
+ lldb::user_id_t break_id, lldb::user_id_t break_loc_id);
+
+ lldb::BreakpointSP m_opaque_sp;
+};
+
+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_file);
+
+ bool AppendIfUnique(const SBBreakpoint &sb_file);
+
+ 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_
--- /dev/null
+//===-- SBBreakpointLocation.h ----------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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();
+
+ bool IsValid() const;
+
+ lldb::SBAddress GetAddress();
+
+ lldb::addr_t GetLoadAddress();
+
+ void SetEnabled(bool enabled);
+
+ bool IsEnabled();
+
+ uint32_t GetIgnoreCount();
+
+ void SetIgnoreCount(uint32_t n);
+
+ void SetCondition(const char *condition);
+
+ const char *GetCondition();
+
+ void SetScriptCallbackFunction(const char *callback_function_name);
+
+ SBError SetScriptCallbackBody(const char *script_body_text);
+
+ 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;
+
+ void SetLocation(const lldb::BreakpointLocationSP &break_loc_sp);
+
+ lldb::BreakpointLocationSP m_opaque_sp;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBBreakpointLocation_h_
--- /dev/null
+//===-- SBBroadcaster.h -----------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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();
+
+ 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_
--- /dev/null
+//===-- SBCommandInterpreter.h ----------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_SBCommandInterpreter_h_
+#define LLDB_SBCommandInterpreter_h_
+
+// C Includes
+// C++ Includes
+#include <memory>
+
+// Other libraries and framework includes
+// Project includes
+#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 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);
+
+ 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);
+
+ // 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);
+
+ //----------------------------------------------------------------------
+ /// 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;
+
+ static void InitializeSWIG();
+
+ 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();
+
+ 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_
--- /dev/null
+//===-- SBCommandReturnObject.h ---------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_SBCommandReturnObject_h_
+#define LLDB_SBCommandReturnObject_h_
+
+// C Includes
+#include <stdio.h>
+
+// C++ Includes
+#include <memory>
+
+// Other libraries and framework includes
+// Project includes
+#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();
+
+ 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_ap;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBCommandReturnObject_h_
--- /dev/null
+//===-- SBCommunication.h ---------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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();
+
+ 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_
--- /dev/null
+//===-- SBCompileUnit.h -----------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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);
+
+ 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_
--- /dev/null
+//===-- SBData.h -----------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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();
+
+ 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_
--- /dev/null
+//===-- SBDebugger.h --------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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 &,
+ unsigned long (*)(void *, lldb::SBInputReader *,
+ lldb::InputReaderAction, char const *,
+ unsigned long),
+ void *, lldb::InputReaderGranularity, char const *,
+ char const *, bool);
+ 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 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();
+
+ 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);
+
+ // 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);
+
+ 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 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);
+
+ 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);
+
+#ifndef LLDB_DISABLE_PYTHON
+ SBTypeSummary GetSummaryForType(SBTypeNameSpecifier);
+#endif
+
+ SBTypeFilter GetFilterForType(SBTypeNameSpecifier);
+
+#ifndef LLDB_DISABLE_PYTHON
+ SBTypeSynthetic GetSyntheticForType(SBTypeNameSpecifier);
+#endif
+
+ 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_
--- /dev/null
+//===-- SBDeclaration.h -------------------------------------------*- C++
+//-*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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);
+
+ 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_ap;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBDeclaration_h_
--- /dev/null
+//===-- SBDefines.h ---------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_SBDefines_h_
+#define LLDB_SBDefines_h_
+
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
+
+#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"
+
+#ifdef SWIG
+#define LLDB_API
+#endif
+
+// Forward Declarations
+namespace lldb {
+
+class LLDB_API SBAddress;
+class LLDB_API SBBlock;
+class LLDB_API SBBreakpoint;
+class LLDB_API SBBreakpointLocation;
+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 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 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;
+}
+
+#endif // LLDB_SBDefines_h_
--- /dev/null
+//===-- SBError.h -----------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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)));
+
+ bool IsValid() const;
+
+ bool GetDescription(lldb::SBStream &description);
+
+protected:
+ friend class SBCommandReturnObject;
+ friend class SBData;
+ friend class SBDebugger;
+ friend class SBCommunication;
+ friend class SBHostOS;
+ friend class SBModule;
+ friend class SBPlatform;
+ friend class SBProcess;
+ friend class SBStructuredData;
+ friend class SBThread;
+ friend class SBTarget;
+ friend class SBValue;
+ friend class SBWatchpoint;
+ friend class SBBreakpoint;
+ friend class SBBreakpointLocation;
+
+ lldb_private::Error *get();
+
+ lldb_private::Error *operator->();
+
+ const lldb_private::Error &operator*() const;
+
+ lldb_private::Error &ref();
+
+ void SetError(const lldb_private::Error &lldb_error);
+
+private:
+ std::unique_ptr<lldb_private::Error> m_opaque_ap;
+
+ void CreateIfNeeded();
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBError_h_
--- /dev/null
+//===-- SBEvent.h -----------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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);
+
+ 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_
--- /dev/null
+//===-- SBExecutionContext.h -----------------------------------------*- C++
+//-*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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:
+ ExecutionContextRefSP &GetSP() const;
+
+ 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_
--- /dev/null
+//===-- SBEvent.h -----------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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 GetPlaygroundTransformEnabled() const;
+
+ void SetPlaygroundTransformEnabled(bool enable_playground_transform = true);
+
+ bool GetREPLMode() const;
+
+ void SetREPLMode(bool enable_repl_mode = true);
+
+ 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);
+
+protected:
+ SBExpressionOptions(
+ lldb_private::EvaluateExpressionOptions &expression_options);
+
+ 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_ap;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBExpressionOptions_h_
--- /dev/null
+//===-- SBFileSpec.h --------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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);
+
+ 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 SBSourceManager;
+ friend class SBThread;
+ friend class SBTarget;
+
+ 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_ap;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBFileSpec_h_
--- /dev/null
+//===-- SBFileSpecList.h --------------------------------------------*- C++
+//-*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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_ap;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBFileSpecList_h_
--- /dev/null
+//===-- SBFrame.h -----------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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;
+
+ 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;
+
+ bool IsSwiftThunk() const;
+ /// Return true if this frame represents an inlined function.
+ ///
+ /// See also GetFunctionName().
+ bool IsInlined();
+
+ bool IsInlined() 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_
--- /dev/null
+//===-- SBFunction.h --------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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();
+
+ 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 GetCanThrow();
+
+ 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_
--- /dev/null
+//===-- SBHostOS.h ----------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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_
--- /dev/null
+//===-- SBInstruction.h -----------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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();
+
+ bool IsValid();
+
+ SBAddress GetAddress();
+
+ lldb::AddressClass GetAddressClass();
+
+ 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();
+
+ 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_
--- /dev/null
+//===-- SBInstructionList.h -------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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();
+
+ bool IsValid() const;
+
+ size_t GetSize();
+
+ lldb::SBInstruction GetInstructionAtIndex(uint32_t idx);
+
+ 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_
--- /dev/null
+//===-- SBLanguageRuntime.h -------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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_
--- /dev/null
+//===-- SBLaunchInfo.h ------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_SBLaunchInfo_h_
+#define LLDB_SBLaunchInfo_h_
+
+#include "lldb/API/SBDefines.h"
+
+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;
+
+ lldb_private::ProcessLaunchInfo &ref();
+
+ const lldb_private::ProcessLaunchInfo &ref() const;
+
+ ProcessLaunchInfoSP m_opaque_sp;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBLaunchInfo_h_
--- /dev/null
+//===-- SBLineEntry.h -------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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;
+
+ 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_ap;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBLineEntry_h_
--- /dev/null
+//===-- SBListener.h --------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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();
+
+ 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_
--- /dev/null
+//===-- SBMemoryRegionInfo.h ------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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;
+
+ SBMemoryRegionInfo(const lldb_private::MemoryRegionInfo *lldb_object_ptr);
+
+ lldb::MemoryRegionInfoUP m_opaque_ap;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBMemoryRegionInfo_h_
--- /dev/null
+//===-- SBMemoryRegionInfoList.h --------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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:
+ std::unique_ptr<MemoryRegionInfoListImpl> m_opaque_ap;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBMemoryRegionInfoList_h_
--- /dev/null
+//===-- SBModule.h ----------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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();
+
+ 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);
+
+ 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::SBError IsTypeSystemCompatible(lldb::LanguageType language);
+
+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_
--- /dev/null
+//===-- SBModuleSpec.h ------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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);
+
+ 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_ap;
+};
+
+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_ap;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBModuleSpec_h_
--- /dev/null
+//===-- SBPlatform.h --------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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();
+
+ 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::Error(const lldb::PlatformSP &)> &func);
+
+ lldb::PlatformSP m_opaque_sp;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBPlatform_h_
--- /dev/null
+//===-- SBProcess.h ---------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_SBProcess_h_
+#define LLDB_SBProcess_h_
+
+#include "lldb/API/SBDefines.h"
+#include "lldb/API/SBError.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();
+
+ 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);
+
+ 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);
+
+ 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();
+
+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_
--- /dev/null
+//===-- SBQueue.h -----------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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();
+
+ 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);
+
+ void FetchThreads();
+
+ void FetchItems();
+
+private:
+ std::shared_ptr<lldb_private::QueueImpl> m_opaque_sp;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBQueue_h_
--- /dev/null
+//===-- SBQueueItem.h -------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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();
+
+ 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_
--- /dev/null
+//===-- SBSection.h ---------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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);
+
+ 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_
--- /dev/null
+//===-- SBSourceManager.h ---------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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;
+
+ SBSourceManager(lldb_private::SourceManager *source_manager);
+
+private:
+ std::unique_ptr<lldb_private::SourceManagerImpl> m_opaque_ap;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBSourceManager_h_
--- /dev/null
+//===-- SBStream.h ----------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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();
+
+ 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 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_ap;
+ bool m_is_file;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBStream_h_
--- /dev/null
+//===-- SBStringList.h ------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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();
+
+ 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;
+
+ 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_ap;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBStringList_h_
--- /dev/null
+//===-- SBStructuredData.h --------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SBStructuredData_h
+#define SBStructuredData_h
+
+#include "lldb/API/SBDefines.h"
+#include "lldb/API/SBModule.h"
+
+class StructuredDataImpl;
+
+namespace lldb {
+
+class SBStructuredData {
+public:
+ SBStructuredData();
+
+ SBStructuredData(const lldb::SBStructuredData &rhs);
+
+ SBStructuredData(const lldb::EventSP &event_sp);
+
+ ~SBStructuredData();
+
+ lldb::SBStructuredData &operator=(const lldb::SBStructuredData &rhs);
+
+ bool IsValid() const;
+
+ void Clear();
+
+ lldb::SBError GetAsJSON(lldb::SBStream &stream) const;
+
+ lldb::SBError GetDescription(lldb::SBStream &stream) const;
+
+private:
+ std::unique_ptr<StructuredDataImpl> m_impl_up;
+};
+}
+
+#endif /* SBStructuredData_h */
--- /dev/null
+//===-- SBSymbol.h ----------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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);
+
+ 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_
--- /dev/null
+//===-- SBSymbolContext.h ---------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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();
+
+ 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;
+
+ SBSymbolContext(const lldb_private::SymbolContext *sc_ptr);
+
+ void SetSymbolContext(const lldb_private::SymbolContext *sc_ptr);
+
+private:
+ std::unique_ptr<lldb_private::SymbolContext> m_opaque_ap;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBSymbolContext_h_
--- /dev/null
+//===-- SBSymbolContextList.h -----------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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);
+
+ 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_ap;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBSymbolContextList_h_
--- /dev/null
+//===-- SBTarget.h ----------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_SBTarget_h_
+#define LLDB_SBTarget_h_
+
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
+#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);
+
+ 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();
+
+ //------------------------------------------------------------------
+ /// 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] launch_flags
+ /// Flags to modify the launch (@see lldb::LaunchFlags)
+ ///
+ /// @param[in] stdin_path
+ /// The path to use when re-directing the STDIN of the new
+ /// process. If all stdXX_path arguments are 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);
+
+ //------------------------------------------------------------------
+ /// 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);
+
+#if defined(__APPLE__)
+ // We need to keep this around for a build or two since Xcode links
+ // to the 32 bit version of this function. We will take it out soon.
+ lldb::SBProcess AttachToProcessWithID(SBListener &listener,
+ ::pid_t pid, // 32 bit int process ID
+ lldb::SBError &error); // DEPRECATED
+#endif
+
+ //------------------------------------------------------------------
+ /// 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();
+
+ 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);
+
+ 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
+ ///
+ /// @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
+ /// Error 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 BreakpointCreateByName(const char *symbol_name,
+ const char *module_name = nullptr);
+
+ // This version uses name_type_mask = eFunctionNameTypeAuto, symbol_language =
+ // eLanguageTypeUnknown
+ lldb::SBBreakpoint
+ BreakpointCreateByName(const char *symbol_name,
+ const SBFileSpecList &module_list,
+ const SBFileSpecList &comp_unit_list);
+
+ // symbol_language = eLanguageTypeUnknown.
+ 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);
+
+ // The extra_args parameter will hold any number of pairs, the first element
+ // is the extra
+ // argument type, and the second the value.
+ // The argument types all follow the option long name from "breakpoint set -E
+ // <Language>".
+ lldb::SBBreakpoint BreakpointCreateForException(lldb::LanguageType language,
+ bool catch_bp, bool throw_bp,
+ SBStringList &extra_args);
+
+ lldb::SBBreakpoint BreakpointCreateByAddress(addr_t address);
+
+ lldb::SBBreakpoint BreakpointCreateBySBAddress(SBAddress &address);
+
+ //------------------------------------------------------------------
+ /// Read breakpoints from source_file and return the newly created
+ /// breakpoints in bkpt_list.
+ ///
+ /// @param[in] source_file
+ /// The file from which to read the breakpoints.
+ ///
+ /// @param[out] bkpt_list
+ /// A list of the newly created breakpoints.
+ ///
+ /// @return
+ /// An SBError detailing any errors in reading in the breakpoints.
+ //------------------------------------------------------------------
+ lldb::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] bkpt_list
+ /// 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 \btrue, 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);
+
+ 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 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;
+
+ //------------------------------------------------------------------
+ // 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_
--- /dev/null
+//===-- SBThread.h ----------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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;
+
+ 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();
+
+ SBValue GetStopErrorValue();
+
+ SBValue GetStopReturnOrErrorValue(bool &is_swift_error_value);
+
+ 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 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 StepOutOfFrame(lldb::SBFrame &frame);
+
+ void StepInstruction(bool step_over);
+
+ 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);
+
+ 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 Resume();
+
+ 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();
+
+ bool SafeToCallFunctions();
+
+#ifndef SWIG
+ lldb_private::Thread *operator->();
+
+ lldb_private::Thread *get();
+
+#endif
+
+protected:
+ friend class SBBreakpoint;
+ friend class SBBreakpointLocation;
+ friend class SBExecutionContext;
+ friend class SBFrame;
+ friend class SBProcess;
+ friend class SBDebugger;
+ friend class SBValue;
+ friend class lldb_private::QueueImpl;
+ friend class SBQueueItem;
+
+ void SetThread(const lldb::ThreadSP &lldb_object_sp);
+
+#ifndef SWIG
+ SBError ResumeNewPlan(lldb_private::ExecutionContext &exe_ctx,
+ lldb_private::ThreadPlan *new_plan);
+#endif
+
+private:
+ lldb::ExecutionContextRefSP m_opaque_sp;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBThread_h_
--- /dev/null
+//===-- SBThreadCollection.h ------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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();
+
+ 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_
--- /dev/null
+//===-- SBThread.h ----------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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();
+
+ 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 QueueThreadPlanForStepInRange(SBAddress &start_address,
+ lldb::addr_t range_size);
+
+ SBThreadPlan QueueThreadPlanForStepOut(uint32_t frame_idx_to_step_to,
+ bool first_insn = false);
+
+ SBThreadPlan QueueThreadPlanForRunToAddress(SBAddress address);
+
+#ifndef SWIG
+ lldb_private::ThreadPlan *get();
+#endif
+
+protected:
+ friend class SBBreakpoint;
+ friend class SBBreakpointLocation;
+ friend class SBFrame;
+ friend class SBProcess;
+ friend class SBDebugger;
+ friend class SBValue;
+ friend class lldb_private::QueueImpl;
+ friend class SBQueueItem;
+
+#ifndef SWIG
+ void SetThreadPlan(const lldb::ThreadPlanSP &lldb_object_sp);
+#endif
+
+private:
+ lldb::ThreadPlanSP m_opaque_sp;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBThreadPlan_h_
--- /dev/null
+//===-- SBType.h ------------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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);
+
+ 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_ap;
+};
+
+class SBTypeMemberFunction {
+public:
+ SBTypeMemberFunction();
+
+ SBTypeMemberFunction(const lldb::SBTypeMemberFunction &rhs);
+
+ ~SBTypeMemberFunction();
+
+ lldb::SBTypeMemberFunction &operator=(const lldb::SBTypeMemberFunction &rhs);
+
+ 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();
+
+ 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);
+
+ 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_ap;
+ friend class SBModule;
+ friend class SBCompileUnit;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBType_h_
--- /dev/null
+//===-- SBTypeCategory.h --------------------------------------------*- C++
+//-*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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();
+
+ 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();
+
+#ifndef LLDB_DISABLE_PYTHON
+ uint32_t GetNumSynthetics();
+#endif
+
+ SBTypeNameSpecifier GetTypeNameSpecifierForFilterAtIndex(uint32_t);
+
+ SBTypeNameSpecifier GetTypeNameSpecifierForFormatAtIndex(uint32_t);
+
+ SBTypeNameSpecifier GetTypeNameSpecifierForSummaryAtIndex(uint32_t);
+
+#ifndef LLDB_DISABLE_PYTHON
+ SBTypeNameSpecifier GetTypeNameSpecifierForSyntheticAtIndex(uint32_t);
+#endif
+
+ SBTypeFilter GetFilterForType(SBTypeNameSpecifier);
+
+ SBTypeFormat GetFormatForType(SBTypeNameSpecifier);
+
+#ifndef LLDB_DISABLE_PYTHON
+ SBTypeSummary GetSummaryForType(SBTypeNameSpecifier);
+#endif
+
+#ifndef LLDB_DISABLE_PYTHON
+ SBTypeSynthetic GetSyntheticForType(SBTypeNameSpecifier);
+#endif
+
+#ifndef LLDB_DISABLE_PYTHON
+ SBTypeFilter GetFilterAtIndex(uint32_t);
+#endif
+
+ SBTypeFormat GetFormatAtIndex(uint32_t);
+
+#ifndef LLDB_DISABLE_PYTHON
+ SBTypeSummary GetSummaryAtIndex(uint32_t);
+#endif
+
+#ifndef LLDB_DISABLE_PYTHON
+ SBTypeSynthetic GetSyntheticAtIndex(uint32_t);
+#endif
+
+ bool AddTypeFormat(SBTypeNameSpecifier, SBTypeFormat);
+
+ bool DeleteTypeFormat(SBTypeNameSpecifier);
+
+#ifndef LLDB_DISABLE_PYTHON
+ bool AddTypeSummary(SBTypeNameSpecifier, SBTypeSummary);
+#endif
+
+ bool DeleteTypeSummary(SBTypeNameSpecifier);
+
+ bool AddTypeFilter(SBTypeNameSpecifier, SBTypeFilter);
+
+ bool DeleteTypeFilter(SBTypeNameSpecifier);
+
+#ifndef LLDB_DISABLE_PYTHON
+ bool AddTypeSynthetic(SBTypeNameSpecifier, SBTypeSynthetic);
+
+ bool DeleteTypeSynthetic(SBTypeNameSpecifier);
+#endif
+
+ 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_
--- /dev/null
+
+//===-- SBTypeEnumMember.h --------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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);
+
+ 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);
+
+ bool IsValid();
+
+ void Append(SBTypeEnumMember entry);
+
+ SBTypeEnumMember GetTypeEnumMemberAtIndex(uint32_t index);
+
+ uint32_t GetSize();
+
+private:
+ std::unique_ptr<lldb_private::TypeEnumMemberListImpl> m_opaque_ap;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBTypeEnumMember_h_
--- /dev/null
+//===-- SBTypeFilter.h --------------------------------------------*- C++
+//-*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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();
+
+ 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_
--- /dev/null
+//===-- SBTypeFormat.h --------------------------------------------*- C++
+//-*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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();
+
+ 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_
--- /dev/null
+//===-- SBTypeNameSpecifier.h --------------------------------------*- C++
+//-*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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();
+
+ 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_
--- /dev/null
+//===-- SBTypeSummary.h -------------------------------------------*- C++
+//-*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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();
+
+ 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_ap;
+};
+
+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();
+
+ 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_
--- /dev/null
+//===-- SBTypeSynthetic.h -----------------------------------------*- C++
+//-*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_SBTypeSynthetic_h_
+#define LLDB_SBTypeSynthetic_h_
+
+#include "lldb/API/SBDefines.h"
+
+#ifndef LLDB_DISABLE_PYTHON
+
+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();
+
+ 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_DISABLE_PYTHON
+
+#endif // LLDB_SBTypeSynthetic_h_
--- /dev/null
+//===-- SBUnixSignals.h -----------------------------------------------*- C++
+//-*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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();
+
+ 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_
--- /dev/null
+//===-- SBValue.h -----------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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();
+
+ 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();
+
+#ifndef LLDB_DISABLE_PYTHON
+ lldb::SBTypeSynthetic GetTypeSynthetic();
+#endif
+
+ 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);
+
+ 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_
--- /dev/null
+//===-- SBValueList.h -------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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();
+
+ 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_ap;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBValueList_h_
--- /dev/null
+//===-- SBVariablesOptions.h ------------------------------------------*- C++
+//-*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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();
+
+ bool IsValid() const;
+
+ bool GetIncludeArguments() const;
+
+ void SetIncludeArguments(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_ap;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBValue_h_
--- /dev/null
+//===-- SBWatchpoint.h ----------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#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);
+
+ 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;
+
+ lldb::WatchpointSP m_opaque_sp;
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBWatchpoint_h_
--- /dev/null
+//===-- SystemInitializerFull.h ---------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_API_SYSTEM_INITIALIZER_FULL_H
+#define LLDB_API_SYSTEM_INITIALIZER_FULL_H
+
+#include "lldb/Initialization/SystemInitializerCommon.h"
+
+namespace lldb_private {
+//------------------------------------------------------------------
+/// Initializes lldb.
+///
+/// This class is responsible for initializing all of lldb system
+/// services needed to use the full LLDB application. This class is
+/// not intended to be used externally, but is instead used
+/// internally by SBDebugger to initialize the system.
+//------------------------------------------------------------------
+class SystemInitializerFull : public SystemInitializerCommon {
+public:
+ SystemInitializerFull();
+ ~SystemInitializerFull() override;
+
+ void Initialize() override;
+ void Terminate() override;
+
+private:
+ void InitializeSWIG();
+};
+
+} // namespace lldb_private
+
+#endif // LLDB_API_SYSTEM_INITIALIZER_FULL_H
--- /dev/null
+//===---------------------AnsiTerminal.h ------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#define ANSI_FG_COLOR_BLACK 30
+#define ANSI_FG_COLOR_RED 31
+#define ANSI_FG_COLOR_GREEN 32
+#define ANSI_FG_COLOR_YELLOW 33
+#define ANSI_FG_COLOR_BLUE 34
+#define ANSI_FG_COLOR_PURPLE 35
+#define ANSI_FG_COLOR_CYAN 36
+#define ANSI_FG_COLOR_WHITE 37
+
+#define ANSI_BG_COLOR_BLACK 40
+#define ANSI_BG_COLOR_RED 41
+#define ANSI_BG_COLOR_GREEN 42
+#define ANSI_BG_COLOR_YELLOW 43
+#define ANSI_BG_COLOR_BLUE 44
+#define ANSI_BG_COLOR_PURPLE 45
+#define ANSI_BG_COLOR_CYAN 46
+#define ANSI_BG_COLOR_WHITE 47
+
+#define ANSI_SPECIAL_FRAMED 51
+#define ANSI_SPECIAL_ENCIRCLED 52
+
+#define ANSI_CTRL_NORMAL 0
+#define ANSI_CTRL_BOLD 1
+#define ANSI_CTRL_FAINT 2
+#define ANSI_CTRL_ITALIC 3
+#define ANSI_CTRL_UNDERLINE 4
+#define ANSI_CTRL_SLOW_BLINK 5
+#define ANSI_CTRL_FAST_BLINK 6
+#define ANSI_CTRL_IMAGE_NEGATIVE 7
+#define ANSI_CTRL_CONCEAL 8
+#define ANSI_CTRL_CROSSED_OUT 9
+
+#define ANSI_ESC_START "\033["
+#define ANSI_ESC_END "m"
+
+#define ANSI_STR(s) #s
+#define ANSI_DEF_STR(s) ANSI_STR(s)
+
+#define ANSI_ESCAPE1(s) ANSI_ESC_START ANSI_DEF_STR(s) ANSI_ESC_END
+
+#define ANSI_1_CTRL(ctrl1) "\033["##ctrl1 ANSI_ESC_END
+#define ANSI_2_CTRL(ctrl1, ctrl2) "\033["##ctrl1 ";"##ctrl2 ANSI_ESC_END
+
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/StringRef.h"
+
+#include <string>
+
+namespace lldb_utility {
+
+namespace ansi {
+
+inline std::string FormatAnsiTerminalCodes(llvm::StringRef format,
+ bool do_color = true) {
+ // Convert "${ansi.XXX}" tokens to ansi values or clear them if do_color is
+ // false.
+ static const struct {
+ const char *name;
+ const char *value;
+ } g_color_tokens[] = {
+#define _TO_STR2(_val) #_val
+#define _TO_STR(_val) _TO_STR2(_val)
+ {"fg.black}", ANSI_ESC_START _TO_STR(ANSI_FG_COLOR_BLACK) ANSI_ESC_END},
+ {"fg.red}", ANSI_ESC_START _TO_STR(ANSI_FG_COLOR_RED) ANSI_ESC_END},
+ {"fg.green}", ANSI_ESC_START _TO_STR(ANSI_FG_COLOR_GREEN) ANSI_ESC_END},
+ {"fg.yellow}", ANSI_ESC_START _TO_STR(ANSI_FG_COLOR_YELLOW) ANSI_ESC_END},
+ {"fg.blue}", ANSI_ESC_START _TO_STR(ANSI_FG_COLOR_BLUE) ANSI_ESC_END},
+ {"fg.purple}", ANSI_ESC_START _TO_STR(ANSI_FG_COLOR_PURPLE) ANSI_ESC_END},
+ {"fg.cyan}", ANSI_ESC_START _TO_STR(ANSI_FG_COLOR_CYAN) ANSI_ESC_END},
+ {"fg.white}", ANSI_ESC_START _TO_STR(ANSI_FG_COLOR_WHITE) ANSI_ESC_END},
+ {"bg.black}", ANSI_ESC_START _TO_STR(ANSI_BG_COLOR_BLACK) ANSI_ESC_END},
+ {"bg.red}", ANSI_ESC_START _TO_STR(ANSI_BG_COLOR_RED) ANSI_ESC_END},
+ {"bg.green}", ANSI_ESC_START _TO_STR(ANSI_BG_COLOR_GREEN) ANSI_ESC_END},
+ {"bg.yellow}", ANSI_ESC_START _TO_STR(ANSI_BG_COLOR_YELLOW) ANSI_ESC_END},
+ {"bg.blue}", ANSI_ESC_START _TO_STR(ANSI_BG_COLOR_BLUE) ANSI_ESC_END},
+ {"bg.purple}", ANSI_ESC_START _TO_STR(ANSI_BG_COLOR_PURPLE) ANSI_ESC_END},
+ {"bg.cyan}", ANSI_ESC_START _TO_STR(ANSI_BG_COLOR_CYAN) ANSI_ESC_END},
+ {"bg.white}", ANSI_ESC_START _TO_STR(ANSI_BG_COLOR_WHITE) ANSI_ESC_END},
+ {"normal}", ANSI_ESC_START _TO_STR(ANSI_CTRL_NORMAL) ANSI_ESC_END},
+ {"bold}", ANSI_ESC_START _TO_STR(ANSI_CTRL_BOLD) ANSI_ESC_END},
+ {"faint}", ANSI_ESC_START _TO_STR(ANSI_CTRL_FAINT) ANSI_ESC_END},
+ {"italic}", ANSI_ESC_START _TO_STR(ANSI_CTRL_ITALIC) ANSI_ESC_END},
+ {"underline}", ANSI_ESC_START _TO_STR(ANSI_CTRL_UNDERLINE) ANSI_ESC_END},
+ {"slow-blink}",
+ ANSI_ESC_START _TO_STR(ANSI_CTRL_SLOW_BLINK) ANSI_ESC_END},
+ {"fast-blink}",
+ ANSI_ESC_START _TO_STR(ANSI_CTRL_FAST_BLINK) ANSI_ESC_END},
+ {"negative}",
+ ANSI_ESC_START _TO_STR(ANSI_CTRL_IMAGE_NEGATIVE) ANSI_ESC_END},
+ {"conceal}", ANSI_ESC_START _TO_STR(ANSI_CTRL_CONCEAL) ANSI_ESC_END},
+ {"crossed-out}",
+ ANSI_ESC_START _TO_STR(ANSI_CTRL_CROSSED_OUT) ANSI_ESC_END},
+#undef _TO_STR
+#undef _TO_STR2
+ };
+ auto codes = llvm::makeArrayRef(g_color_tokens);
+
+ static const char tok_hdr[] = "${ansi.";
+
+ std::string fmt;
+ while (!format.empty()) {
+ llvm::StringRef left, right;
+ std::tie(left, right) = format.split(tok_hdr);
+
+ fmt.append(left);
+
+ if (left == format && right.empty()) {
+ // The header was not found. Just exit.
+ break;
+ }
+
+ for (const auto &code : codes) {
+ if (!right.consume_front(code.name))
+ continue;
+
+ if (do_color)
+ fmt.append(code.value);
+ format = right;
+ break;
+ }
+
+ format = format.drop_front();
+ }
+ return fmt;
+}
+}
+}
--- /dev/null
+//===-- CleanUp.h -----------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_CleanUp_h_
+#define liblldb_CleanUp_h_
+
+#include "lldb/lldb-public.h"
+#include <functional>
+
+namespace lldb_utility {
+
+//----------------------------------------------------------------------
+// Templated class that guarantees that a cleanup callback function will
+// be called. The cleanup function will be called once under the
+// following conditions:
+// - when the object goes out of scope
+// - when the user explicitly calls clean.
+// - the current value will be cleaned up when a new value is set using
+// set(T value) as long as the current value hasn't already been cleaned.
+//
+// This class is designed to be used with simple types for type T (like
+// file descriptors, opaque handles, pointers, etc). If more complex
+// type T objects are desired, we need to probably specialize this class
+// to take "const T&" for all input T parameters. Yet if a type T is
+// complex already it might be better to build the cleanup functionality
+// into T.
+//
+// The cleanup function must take one argument that is of type T.
+// The calback function return type is R. The return value is currently
+// needed for "CallbackType". If there is an easy way to get around the
+// need for the return value we can change this class.
+//
+// The two template parameters are:
+// T - The variable type of value that will be stored and used as the
+// sole argument for the cleanup callback.
+// R - The return type for the cleanup function.
+//
+// EXAMPLES
+// // Use with file handles that get opened where you want to close
+// // them. Below we use "int open(const char *path, int oflag, ...)"
+// // which returns an integer file descriptor. -1 is the invalid file
+// // descriptor so to make an object that will call "int close(int fd)"
+// // automatically we can use:
+//
+// CleanUp <int, int> fd(open("/tmp/a.txt", O_RDONLY, 0), -1, close);
+//
+// // malloc/free example
+// CleanUp <void *, void> malloced_bytes(malloc(32), NULL, free);
+//----------------------------------------------------------------------
+template <typename T, typename R = void> class CleanUp {
+public:
+ typedef T value_type;
+ typedef std::function<R(value_type)> CallbackType;
+
+ //----------------------------------------------------------------------
+ // Constructor that sets the current value only. No values are
+ // considered to be invalid and the cleanup function will be called
+ // regardless of the value of m_current_value.
+ //----------------------------------------------------------------------
+ CleanUp(value_type value, CallbackType callback)
+ : m_current_value(value), m_invalid_value(), m_callback(callback),
+ m_callback_called(false), m_invalid_value_is_valid(false) {}
+
+ //----------------------------------------------------------------------
+ // Constructor that sets the current value and also the invalid value.
+ // The cleanup function will be called on "m_value" as long as it isn't
+ // equal to "m_invalid_value".
+ //----------------------------------------------------------------------
+ CleanUp(value_type value, value_type invalid, CallbackType callback)
+ : m_current_value(value), m_invalid_value(invalid), m_callback(callback),
+ m_callback_called(false), m_invalid_value_is_valid(true) {}
+
+ //----------------------------------------------------------------------
+ // Automatically cleanup when this object goes out of scope.
+ //----------------------------------------------------------------------
+ ~CleanUp() { clean(); }
+
+ //----------------------------------------------------------------------
+ // Access the value stored in this class
+ //----------------------------------------------------------------------
+ value_type get() { return m_current_value; }
+
+ //----------------------------------------------------------------------
+ // Access the value stored in this class
+ //----------------------------------------------------------------------
+ const value_type get() const { return m_current_value; }
+
+ //----------------------------------------------------------------------
+ // Reset the owned value to "value". If a current value is valid and
+ // the cleanup callback hasn't been called, the previous value will
+ // be cleaned up (see void CleanUp::clean()).
+ //----------------------------------------------------------------------
+ void set(const value_type value) {
+ // Cleanup the current value if needed
+ clean();
+ // Now set the new value and mark our callback as not called
+ m_callback_called = false;
+ m_current_value = value;
+ }
+
+ //----------------------------------------------------------------------
+ // Checks is "m_current_value" is valid. The value is considered valid
+ // no invalid value was supplied during construction of this object or
+ // if an invalid value was supplied and "m_current_value" is not equal
+ // to "m_invalid_value".
+ //
+ // Returns true if "m_current_value" is valid, false otherwise.
+ //----------------------------------------------------------------------
+ bool is_valid() const {
+ if (m_invalid_value_is_valid)
+ return m_current_value != m_invalid_value;
+ return true;
+ }
+
+ //----------------------------------------------------------------------
+ // This function will call the cleanup callback provided in the
+ // constructor one time if the value is considered valid (See is_valid()).
+ // This function sets m_callback_called to true so we don't call the
+ // cleanup callback multiple times on the same value.
+ //----------------------------------------------------------------------
+ void clean() {
+ if (m_callback && !m_callback_called) {
+ m_callback_called = true;
+ if (is_valid())
+ m_callback(m_current_value);
+ }
+ }
+
+ //----------------------------------------------------------------------
+ // Cancels the cleanup that would have been called on "m_current_value"
+ // if it was valid. This function can be used to release the value
+ // contained in this object so ownership can be transferred to the caller.
+ //----------------------------------------------------------------------
+ value_type release() {
+ m_callback_called = true;
+ return m_current_value;
+ }
+
+private:
+ value_type m_current_value;
+ const value_type m_invalid_value;
+ CallbackType m_callback;
+ bool m_callback_called;
+ bool m_invalid_value_is_valid;
+
+ // Outlaw default constructor, copy constructor and the assignment operator
+ DISALLOW_COPY_AND_ASSIGN(CleanUp);
+};
+
+template <typename T, typename R, typename A0> class CleanUp2 {
+public:
+ typedef T value_type;
+ typedef std::function<R(value_type, A0)> CallbackType;
+
+ //----------------------------------------------------------------------
+ // Constructor that sets the current value only. No values are
+ // considered to be invalid and the cleanup function will be called
+ // regardless of the value of m_current_value.
+ //----------------------------------------------------------------------
+ CleanUp2(value_type value, CallbackType callback, A0 arg)
+ : m_current_value(value), m_invalid_value(), m_callback(callback),
+ m_callback_called(false), m_invalid_value_is_valid(false),
+ m_argument(arg) {}
+
+ //----------------------------------------------------------------------
+ // Constructor that sets the current value and also the invalid value.
+ // The cleanup function will be called on "m_value" as long as it isn't
+ // equal to "m_invalid_value".
+ //----------------------------------------------------------------------
+ CleanUp2(value_type value, value_type invalid, CallbackType callback, A0 arg)
+ : m_current_value(value), m_invalid_value(invalid), m_callback(callback),
+ m_callback_called(false), m_invalid_value_is_valid(true),
+ m_argument(arg) {}
+
+ //----------------------------------------------------------------------
+ // Automatically cleanup when this object goes out of scope.
+ //----------------------------------------------------------------------
+ ~CleanUp2() { clean(); }
+
+ //----------------------------------------------------------------------
+ // Access the value stored in this class
+ //----------------------------------------------------------------------
+ value_type get() { return m_current_value; }
+
+ //----------------------------------------------------------------------
+ // Access the value stored in this class
+ //----------------------------------------------------------------------
+ const value_type get() const { return m_current_value; }
+
+ //----------------------------------------------------------------------
+ // Reset the owned value to "value". If a current value is valid and
+ // the cleanup callback hasn't been called, the previous value will
+ // be cleaned up (see void CleanUp::clean()).
+ //----------------------------------------------------------------------
+ void set(const value_type value) {
+ // Cleanup the current value if needed
+ clean();
+ // Now set the new value and mark our callback as not called
+ m_callback_called = false;
+ m_current_value = value;
+ }
+
+ //----------------------------------------------------------------------
+ // Checks is "m_current_value" is valid. The value is considered valid
+ // no invalid value was supplied during construction of this object or
+ // if an invalid value was supplied and "m_current_value" is not equal
+ // to "m_invalid_value".
+ //
+ // Returns true if "m_current_value" is valid, false otherwise.
+ //----------------------------------------------------------------------
+ bool is_valid() const {
+ if (m_invalid_value_is_valid)
+ return m_current_value != m_invalid_value;
+ return true;
+ }
+
+ //----------------------------------------------------------------------
+ // This function will call the cleanup callback provided in the
+ // constructor one time if the value is considered valid (See is_valid()).
+ // This function sets m_callback_called to true so we don't call the
+ // cleanup callback multiple times on the same value.
+ //----------------------------------------------------------------------
+ void clean() {
+ if (m_callback && !m_callback_called) {
+ m_callback_called = true;
+ if (is_valid())
+ m_callback(m_current_value, m_argument);
+ }
+ }
+
+ //----------------------------------------------------------------------
+ // Cancels the cleanup that would have been called on "m_current_value"
+ // if it was valid. This function can be used to release the value
+ // contained in this object so ownership can be transferred to the caller.
+ //----------------------------------------------------------------------
+ value_type release() {
+ m_callback_called = true;
+ return m_current_value;
+ }
+
+private:
+ value_type m_current_value;
+ const value_type m_invalid_value;
+ CallbackType m_callback;
+ bool m_callback_called;
+ bool m_invalid_value_is_valid;
+ A0 m_argument;
+
+ // Outlaw default constructor, copy constructor and the assignment operator
+ DISALLOW_COPY_AND_ASSIGN(CleanUp2);
+};
+
+} // namespace lldb_utility
+
+#endif // #ifndef liblldb_CleanUp_h_
--- /dev/null
+//===-- ConvertEnum.h -------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef LLDB_UTILITY_CONVERTENUM_H
+#define LLDB_UTILITY_CONVERTENUM_H
+
+#include "lldb/lldb-enumerations.h"
+#include "lldb/lldb-private-enumerations.h"
+
+namespace lldb_private {
+
+const char *GetVoteAsCString(Vote vote);
+const char *GetSectionTypeAsCString(lldb::SectionType sect_type);
+}
+
+#endif
--- /dev/null
+//===-- Either.h -----------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_Either_h_
+#define liblldb_Either_h_
+
+#include "llvm/ADT/Optional.h"
+
+#include <functional>
+
+namespace lldb_utility {
+template <typename T1, typename T2> class Either {
+private:
+ enum class Selected { One, Two };
+
+ Selected m_selected;
+ union {
+ T1 m_t1;
+ T2 m_t2;
+ };
+
+public:
+ Either(const T1 &t1) {
+ m_t1 = t1;
+ m_selected = Selected::One;
+ }
+
+ Either(const T2 &t2) {
+ m_t2 = t2;
+ m_selected = Selected::Two;
+ }
+
+ Either(const Either<T1, T2> &rhs) {
+ switch (rhs.m_selected) {
+ case Selected::One:
+ m_t1 = rhs.GetAs<T1>().getValue();
+ m_selected = Selected::One;
+ break;
+ case Selected::Two:
+ m_t2 = rhs.GetAs<T2>().getValue();
+ m_selected = Selected::Two;
+ break;
+ }
+ }
+
+ template <class X, typename std::enable_if<std::is_same<T1, X>::value>::type
+ * = nullptr>
+ llvm::Optional<T1> GetAs() const {
+ switch (m_selected) {
+ case Selected::One:
+ return m_t1;
+ default:
+ return llvm::Optional<T1>();
+ }
+ }
+
+ template <class X, typename std::enable_if<std::is_same<T2, X>::value>::type
+ * = nullptr>
+ llvm::Optional<T2> GetAs() const {
+ switch (m_selected) {
+ case Selected::Two:
+ return m_t2;
+ default:
+ return llvm::Optional<T2>();
+ }
+ }
+
+ template <class ResultType>
+ ResultType Apply(std::function<ResultType(T1)> if_T1,
+ std::function<ResultType(T2)> if_T2) const {
+ switch (m_selected) {
+ case Selected::One:
+ return if_T1(m_t1);
+ case Selected::Two:
+ return if_T2(m_t2);
+ }
+
+ llvm_unreachable("Unhandled Selected in switch.");
+ }
+
+ bool operator==(const Either<T1, T2> &rhs) {
+ return (GetAs<T1>() == rhs.GetAs<T1>()) && (GetAs<T2>() == rhs.GetAs<T2>());
+ }
+
+ explicit operator bool() {
+ switch (m_selected) {
+ case Selected::One:
+ return (bool)m_t1;
+ case Selected::Two:
+ return (bool)m_t2;
+ }
+
+ llvm_unreachable("Unhandled Selected in switch.");
+ }
+
+ Either<T1, T2> &operator=(const Either<T1, T2> &rhs) {
+ switch (rhs.m_selected) {
+ case Selected::One:
+ m_t1 = rhs.GetAs<T1>().getValue();
+ m_selected = Selected::One;
+ break;
+ case Selected::Two:
+ m_t2 = rhs.GetAs<T2>().getValue();
+ m_selected = Selected::Two;
+ break;
+ }
+ return *this;
+ }
+
+ ~Either() {
+ switch (m_selected) {
+ case Selected::One:
+ m_t1.T1::~T1();
+ break;
+ case Selected::Two:
+ m_t2.T2::~T2();
+ break;
+ }
+ }
+};
+
+} // namespace lldb_utility
+
+#endif // #ifndef liblldb_Either_h_
--- /dev/null
+//===-- Iterable.h ----------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_Iterable_h_
+#define liblldb_Iterable_h_
+
+// C Includes
+// C++ Includes
+#include <utility>
+
+// Other libraries and framework includes
+// Project includes
+
+namespace lldb_private {
+
+template <typename I, typename E> E map_adapter(I &iter) {
+ return iter->second;
+}
+
+template <typename I, typename E> E vector_adapter(I &iter) { return *iter; }
+
+template <typename I, typename E> E list_adapter(I &iter) { return *iter; }
+
+template <typename C, typename E, E (*A)(typename C::const_iterator &)>
+class AdaptedConstIterator {
+public:
+ typedef typename C::const_iterator BackingIterator;
+
+ // Wrapping constructor
+ AdaptedConstIterator(BackingIterator backing_iterator)
+ : m_iter(backing_iterator) {}
+
+ // Default-constructible
+ AdaptedConstIterator() : m_iter() {}
+
+ // Copy-constructible
+ AdaptedConstIterator(const AdaptedConstIterator &rhs) : m_iter(rhs.m_iter) {}
+
+ // Copy-assignable
+ AdaptedConstIterator &operator=(const AdaptedConstIterator &rhs) {
+ m_iter = rhs.m_iter;
+ return *this;
+ }
+
+ // Destructible
+ ~AdaptedConstIterator() = default;
+
+ // Comparable
+ bool operator==(const AdaptedConstIterator &rhs) {
+ return m_iter == rhs.m_iter;
+ }
+
+ bool operator!=(const AdaptedConstIterator &rhs) {
+ return m_iter != rhs.m_iter;
+ }
+
+ // Rvalue dereferenceable
+ E operator*() { return (*A)(m_iter); }
+
+ E operator->() { return (*A)(m_iter); }
+
+ // Offset dereferenceable
+ E operator[](typename BackingIterator::difference_type offset) {
+ return AdaptedConstIterator(m_iter + offset);
+ }
+
+ // Incrementable
+ AdaptedConstIterator &operator++() {
+ m_iter++;
+ return *this;
+ }
+
+ // Decrementable
+ AdaptedConstIterator &operator--() {
+ m_iter--;
+ return *this;
+ }
+
+ // Compound assignment
+ AdaptedConstIterator &
+ operator+=(typename BackingIterator::difference_type offset) {
+ m_iter += offset;
+ return *this;
+ }
+
+ AdaptedConstIterator &
+ operator-=(typename BackingIterator::difference_type offset) {
+ m_iter -= offset;
+ return *this;
+ }
+
+ // Arithmetic
+ AdaptedConstIterator
+ operator+(typename BackingIterator::difference_type offset) {
+ return AdaptedConstIterator(m_iter + offset);
+ }
+
+ AdaptedConstIterator
+ operator-(typename BackingIterator::difference_type offset) {
+ return AdaptedConstIterator(m_iter - offset);
+ }
+
+ // Comparable
+ bool operator<(AdaptedConstIterator &rhs) { return m_iter < rhs.m_iter; }
+
+ bool operator<=(AdaptedConstIterator &rhs) { return m_iter <= rhs.m_iter; }
+
+ bool operator>(AdaptedConstIterator &rhs) { return m_iter > rhs.m_iter; }
+
+ bool operator>=(AdaptedConstIterator &rhs) { return m_iter >= rhs.m_iter; }
+
+ template <typename C1, typename E1, E1 (*A1)(typename C1::const_iterator &)>
+ friend AdaptedConstIterator<C1, E1, A1>
+ operator+(typename C1::const_iterator::difference_type,
+ AdaptedConstIterator<C1, E1, A1> &);
+
+ template <typename C1, typename E1, E1 (*A1)(typename C1::const_iterator &)>
+ friend typename C1::const_iterator::difference_type
+ operator-(AdaptedConstIterator<C1, E1, A1> &,
+ AdaptedConstIterator<C1, E1, A1> &);
+
+ template <typename C1, typename E1, E1 (*A1)(typename C1::const_iterator &)>
+ friend void swap(AdaptedConstIterator<C1, E1, A1> &,
+ AdaptedConstIterator<C1, E1, A1> &);
+
+private:
+ BackingIterator m_iter;
+};
+
+template <typename C, typename E, E (*A)(typename C::const_iterator &)>
+AdaptedConstIterator<C, E, A> operator+(
+ typename AdaptedConstIterator<C, E, A>::BackingIterator::difference_type
+ offset,
+ AdaptedConstIterator<C, E, A> &rhs) {
+ return rhs.operator+(offset);
+}
+
+template <typename C, typename E, E (*A)(typename C::const_iterator &)>
+typename AdaptedConstIterator<C, E, A>::BackingIterator::difference_type
+operator-(AdaptedConstIterator<C, E, A> &lhs,
+ AdaptedConstIterator<C, E, A> &rhs) {
+ return (lhs.m_iter - rhs.m_iter);
+}
+
+template <typename C, typename E, E (*A)(typename C::const_iterator &)>
+void swap(AdaptedConstIterator<C, E, A> &lhs,
+ AdaptedConstIterator<C, E, A> &rhs) {
+ std::swap(lhs.m_iter, rhs.m_iter);
+}
+
+template <typename C, typename E, E (*A)(typename C::const_iterator &)>
+class AdaptedIterable {
+private:
+ const C &m_container;
+
+public:
+ AdaptedIterable(const C &container) : m_container(container) {}
+
+ AdaptedConstIterator<C, E, A> begin() {
+ return AdaptedConstIterator<C, E, A>(m_container.begin());
+ }
+
+ AdaptedConstIterator<C, E, A> end() {
+ return AdaptedConstIterator<C, E, A>(m_container.end());
+ }
+};
+
+template <typename C, typename E, E (*A)(typename C::const_iterator &),
+ typename MutexType>
+class LockingAdaptedIterable : public AdaptedIterable<C, E, A> {
+public:
+ LockingAdaptedIterable(C &container, MutexType &mutex)
+ : AdaptedIterable<C, E, A>(container), m_mutex(&mutex) {
+ m_mutex->lock();
+ }
+
+ LockingAdaptedIterable(LockingAdaptedIterable &&rhs)
+ : AdaptedIterable<C, E, A>(rhs), m_mutex(rhs.m_mutex) {
+ rhs.m_mutex = nullptr;
+ }
+
+ ~LockingAdaptedIterable() {
+ if (m_mutex)
+ m_mutex->unlock();
+ }
+
+private:
+ MutexType *m_mutex = nullptr;
+
+ LockingAdaptedIterable(const LockingAdaptedIterable &) = delete;
+ LockingAdaptedIterable &operator=(const LockingAdaptedIterable &) = delete;
+};
+
+} // namespace lldb_private
+
+#endif // liblldb_Iterable_h_
--- /dev/null
+//===---------------------JSON.h --------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef utility_JSON_h_
+#define utility_JSON_h_
+
+#include "lldb/Core/Stream.h"
+#include "lldb/Utility/StringExtractor.h"
+
+#include <inttypes.h>
+#include <map>
+#include <memory>
+#include <stdint.h>
+#include <string>
+#include <vector>
+
+#include "llvm/Support/Casting.h"
+
+namespace lldb_private {
+
+class JSONValue {
+public:
+ virtual void Write(Stream &s) = 0;
+
+ typedef std::shared_ptr<JSONValue> SP;
+
+ enum class Kind { String, Number, True, False, Null, Object, Array };
+
+ JSONValue(Kind k) : m_kind(k) {}
+
+ Kind GetKind() const { return m_kind; }
+
+ virtual ~JSONValue() = default;
+
+private:
+ const Kind m_kind;
+};
+
+class JSONString : public JSONValue {
+public:
+ JSONString();
+ JSONString(const char *s);
+ JSONString(const std::string &s);
+
+ JSONString(const JSONString &s) = delete;
+ JSONString &operator=(const JSONString &s) = delete;
+
+ void Write(Stream &s) override;
+
+ typedef std::shared_ptr<JSONString> SP;
+
+ std::string GetData() { return m_data; }
+
+ static bool classof(const JSONValue *V) {
+ return V->GetKind() == JSONValue::Kind::String;
+ }
+
+ ~JSONString() override = default;
+
+private:
+ static std::string json_string_quote_metachars(const std::string &);
+
+ std::string m_data;
+};
+
+class JSONNumber : public JSONValue {
+public:
+ typedef std::shared_ptr<JSONNumber> SP;
+
+ // We cretae a constructor for all integer and floating point type with using
+ // templates and
+ // SFINAE to avoid having ambiguous overloads because of the implicit type
+ // promotion. If we
+ // would have constructors only with int64_t, uint64_t and double types then
+ // constructing a
+ // JSONNumber from an int32_t (or any other similar type) would fail to
+ // compile.
+
+ template <typename T, typename std::enable_if<
+ std::is_integral<T>::value &&
+ std::is_unsigned<T>::value>::type * = nullptr>
+ explicit JSONNumber(T u)
+ : JSONValue(JSONValue::Kind::Number), m_data_type(DataType::Unsigned) {
+ m_data.m_unsigned = u;
+ }
+
+ template <typename T,
+ typename std::enable_if<std::is_integral<T>::value &&
+ std::is_signed<T>::value>::type * = nullptr>
+ explicit JSONNumber(T s)
+ : JSONValue(JSONValue::Kind::Number), m_data_type(DataType::Signed) {
+ m_data.m_signed = s;
+ }
+
+ template <typename T, typename std::enable_if<
+ std::is_floating_point<T>::value>::type * = nullptr>
+ explicit JSONNumber(T d)
+ : JSONValue(JSONValue::Kind::Number), m_data_type(DataType::Double) {
+ m_data.m_double = d;
+ }
+
+ ~JSONNumber() override = default;
+
+ JSONNumber(const JSONNumber &s) = delete;
+ JSONNumber &operator=(const JSONNumber &s) = delete;
+
+ void Write(Stream &s) override;
+
+ uint64_t GetAsUnsigned() const;
+
+ int64_t GetAsSigned() const;
+
+ double GetAsDouble() const;
+
+ static bool classof(const JSONValue *V) {
+ return V->GetKind() == JSONValue::Kind::Number;
+ }
+
+private:
+ enum class DataType : uint8_t { Unsigned, Signed, Double } m_data_type;
+
+ union {
+ uint64_t m_unsigned;
+ int64_t m_signed;
+ double m_double;
+ } m_data;
+};
+
+class JSONTrue : public JSONValue {
+public:
+ JSONTrue();
+
+ JSONTrue(const JSONTrue &s) = delete;
+ JSONTrue &operator=(const JSONTrue &s) = delete;
+
+ void Write(Stream &s) override;
+
+ typedef std::shared_ptr<JSONTrue> SP;
+
+ static bool classof(const JSONValue *V) {
+ return V->GetKind() == JSONValue::Kind::True;
+ }
+
+ ~JSONTrue() override = default;
+};
+
+class JSONFalse : public JSONValue {
+public:
+ JSONFalse();
+
+ JSONFalse(const JSONFalse &s) = delete;
+ JSONFalse &operator=(const JSONFalse &s) = delete;
+
+ void Write(Stream &s) override;
+
+ typedef std::shared_ptr<JSONFalse> SP;
+
+ static bool classof(const JSONValue *V) {
+ return V->GetKind() == JSONValue::Kind::False;
+ }
+
+ ~JSONFalse() override = default;
+};
+
+class JSONNull : public JSONValue {
+public:
+ JSONNull();
+
+ JSONNull(const JSONNull &s) = delete;
+ JSONNull &operator=(const JSONNull &s) = delete;
+
+ void Write(Stream &s) override;
+
+ typedef std::shared_ptr<JSONNull> SP;
+
+ static bool classof(const JSONValue *V) {
+ return V->GetKind() == JSONValue::Kind::Null;
+ }
+
+ ~JSONNull() override = default;
+};
+
+class JSONObject : public JSONValue {
+public:
+ JSONObject();
+
+ JSONObject(const JSONObject &s) = delete;
+ JSONObject &operator=(const JSONObject &s) = delete;
+
+ void Write(Stream &s) override;
+
+ typedef std::shared_ptr<JSONObject> SP;
+
+ static bool classof(const JSONValue *V) {
+ return V->GetKind() == JSONValue::Kind::Object;
+ }
+
+ bool SetObject(const std::string &key, JSONValue::SP value);
+
+ JSONValue::SP GetObject(const std::string &key);
+
+ ~JSONObject() override = default;
+
+private:
+ typedef std::map<std::string, JSONValue::SP> Map;
+ typedef Map::iterator Iterator;
+ Map m_elements;
+};
+
+class JSONArray : public JSONValue {
+public:
+ JSONArray();
+
+ JSONArray(const JSONArray &s) = delete;
+ JSONArray &operator=(const JSONArray &s) = delete;
+
+ void Write(Stream &s) override;
+
+ typedef std::shared_ptr<JSONArray> SP;
+
+ static bool classof(const JSONValue *V) {
+ return V->GetKind() == JSONValue::Kind::Array;
+ }
+
+private:
+ typedef std::vector<JSONValue::SP> Vector;
+ typedef Vector::iterator Iterator;
+ typedef Vector::size_type Index;
+ typedef Vector::size_type Size;
+
+public:
+ bool SetObject(Index i, JSONValue::SP value);
+
+ bool AppendObject(JSONValue::SP value);
+
+ JSONValue::SP GetObject(Index i);
+
+ Size GetNumElements();
+
+ ~JSONArray() override = default;
+
+ Vector m_elements;
+};
+
+class JSONParser : public StringExtractor {
+public:
+ enum Token {
+ Invalid,
+ Error,
+ ObjectStart,
+ ObjectEnd,
+ ArrayStart,
+ ArrayEnd,
+ Comma,
+ Colon,
+ String,
+ Integer,
+ Float,
+ True,
+ False,
+ Null,
+ EndOfFile
+ };
+
+ JSONParser(const char *cstr);
+
+ int GetEscapedChar(bool &was_escaped);
+
+ Token GetToken(std::string &value);
+
+ JSONValue::SP ParseJSONValue();
+
+protected:
+ JSONValue::SP ParseJSONObject();
+
+ JSONValue::SP ParseJSONArray();
+};
+} // namespace lldb_private
+
+#endif // utility_JSON_h_
--- /dev/null
+//===----------------- LLDBAssert.h --------------------------------*- C++
+//-*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef utility_LLDBAssert_h_
+#define utility_LLDBAssert_h_
+
+#include <assert.h>
+
+#ifdef LLDB_CONFIGURATION_DEBUG
+#define lldbassert(x) assert(x)
+#else
+#define lldbassert(x) \
+ lldb_private::lldb_assert(x, #x, __FUNCTION__, __FILE__, __LINE__)
+#endif
+
+namespace lldb_private {
+void lldb_assert(bool expression, const char *expr_text, const char *func,
+ const char *file, unsigned int line);
+}
+
+#endif // utility_LLDBAssert_h_
--- /dev/null
+//===-- NameMatches.h -------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef LLDB_UTILITY_NAMEMATCHES_H
+#define LLDB_UTILITY_NAMEMATCHES_H
+
+#include "lldb/lldb-private-enumerations.h"
+
+#include "llvm/ADT/StringRef.h"
+
+namespace lldb_private {
+bool NameMatches(llvm::StringRef name, NameMatchType match_type,
+ llvm::StringRef match);
+}
+
+#endif
--- /dev/null
+//===-- PriorityPointerPair.h ----------------------------------------*- C++
+//-*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_PriorityPointerPair_h_
+#define liblldb_PriorityPointerPair_h_
+
+#include "lldb/Utility/SharingPtr.h"
+#include "lldb/lldb-public.h"
+
+namespace lldb_utility {
+
+//----------------------------------------------------------------------
+// A prioritized pair of SharedPtr<T>. One of the two pointers is high
+// priority, the other is low priority.
+// The Get() method always returns high, if *high != NULL,
+// otherwise, low is returned (even if *low == NULL)
+//----------------------------------------------------------------------
+
+template <typename T> class PriorityPointerPair {
+public:
+ typedef T &reference_type;
+ typedef T *pointer_type;
+
+ typedef typename std::shared_ptr<T> T_SP;
+
+ PriorityPointerPair() : m_high(), m_low() {}
+
+ PriorityPointerPair(pointer_type high, pointer_type low)
+ : m_high(high), m_low(low) {}
+
+ PriorityPointerPair(pointer_type low) : m_high(), m_low(low) {}
+
+ PriorityPointerPair(T_SP &high, T_SP &low) : m_high(high), m_low(low) {}
+
+ PriorityPointerPair(T_SP &low) : m_high(), m_low(low) {}
+
+ void SwapLow(pointer_type l) { m_low.swap(l); }
+
+ void SwapHigh(pointer_type h) { m_high.swap(h); }
+
+ void SwapLow(T_SP l) { m_low.swap(l); }
+
+ void SwapHigh(T_SP h) { m_high.swap(h); }
+
+ T_SP GetLow() { return m_low; }
+
+ T_SP GetHigh() { return m_high; }
+
+ T_SP Get() {
+ if (m_high.get())
+ return m_high;
+ return m_low;
+ }
+
+ void ResetHigh() { m_high.reset(); }
+
+ void ResetLow() { m_low.reset(); }
+
+ void Reset() {
+ ResetLow();
+ ResetHigh();
+ }
+
+ reference_type operator*() const { return Get().operator*(); }
+
+ pointer_type operator->() const { return Get().operator->(); }
+
+ ~PriorityPointerPair();
+
+private:
+ T_SP m_high;
+ T_SP m_low;
+
+ DISALLOW_COPY_AND_ASSIGN(PriorityPointerPair);
+};
+
+} // namespace lldb_utility
+
+#endif // #ifndef liblldb_PriorityPointerPair_h_
--- /dev/null
+//===---------------------ProcessStructReader.h ------------------*- C++
+//-*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef utility_ProcessStructReader_h_
+#define utility_ProcessStructReader_h_
+
+#include "lldb/lldb-defines.h"
+#include "lldb/lldb-types.h"
+
+#include "lldb/Core/ConstString.h"
+#include "lldb/Core/DataExtractor.h"
+#include "lldb/Core/Error.h"
+#include "lldb/Symbol/CompilerType.h"
+#include "lldb/Target/Process.h"
+
+#include <initializer_list>
+#include <map>
+#include <string>
+
+namespace lldb_private {
+class ProcessStructReader {
+protected:
+ struct FieldImpl {
+ CompilerType type;
+ size_t offset;
+ size_t size;
+ };
+
+ std::map<ConstString, FieldImpl> m_fields;
+ DataExtractor m_data;
+ lldb::ByteOrder m_byte_order;
+ size_t m_addr_byte_size;
+
+public:
+ ProcessStructReader(Process *process, lldb::addr_t base_addr,
+ CompilerType struct_type) {
+ if (!process)
+ return;
+ if (base_addr == 0 || base_addr == LLDB_INVALID_ADDRESS)
+ return;
+ m_byte_order = process->GetByteOrder();
+ m_addr_byte_size = process->GetAddressByteSize();
+
+ for (size_t idx = 0; idx < struct_type.GetNumFields(); idx++) {
+ std::string name;
+ uint64_t bit_offset;
+ uint32_t bitfield_bit_size;
+ bool is_bitfield;
+ CompilerType field_type = struct_type.GetFieldAtIndex(
+ idx, name, &bit_offset, &bitfield_bit_size, &is_bitfield);
+ // no support for bitfields in here (yet)
+ if (is_bitfield)
+ return;
+ auto size = field_type.GetByteSize(nullptr);
+ // no support for things larger than a uint64_t (yet)
+ if (size > 8)
+ return;
+ ConstString const_name = ConstString(name.c_str());
+ size_t byte_index = static_cast<size_t>(bit_offset / 8);
+ m_fields[const_name] =
+ FieldImpl{field_type, byte_index, static_cast<size_t>(size)};
+ }
+ size_t total_size = struct_type.GetByteSize(nullptr);
+ lldb::DataBufferSP buffer_sp(new DataBufferHeap(total_size, 0));
+ Error error;
+ process->ReadMemoryFromInferior(base_addr, buffer_sp->GetBytes(),
+ total_size, error);
+ if (error.Fail())
+ return;
+ m_data = DataExtractor(buffer_sp, m_byte_order, m_addr_byte_size);
+ }
+
+ template <typename RetType>
+ RetType GetField(ConstString name, RetType fail_value = RetType()) {
+ auto iter = m_fields.find(name), end = m_fields.end();
+ if (iter == end)
+ return fail_value;
+ auto size = iter->second.size;
+ if (sizeof(RetType) < size)
+ return fail_value;
+ lldb::offset_t offset = iter->second.offset;
+ if (offset + size > m_data.GetByteSize())
+ return fail_value;
+ return (RetType)(m_data.GetMaxU64(&offset, size));
+ }
+
+ size_t GetOffsetOf(ConstString name, size_t fail_value = SIZE_MAX) {
+ auto iter = m_fields.find(name), end = m_fields.end();
+ if (iter == end)
+ return fail_value;
+ return iter->second.offset;
+ }
+};
+}
+
+#endif // utility_ProcessStructReader_h_
--- /dev/null
+//===-- PseudoTerminal.h ----------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_PseudoTerminal_h_
+#define liblldb_PseudoTerminal_h_
+#if defined(__cplusplus)
+
+#include <fcntl.h>
+#include <string>
+
+#include "lldb/lldb-defines.h"
+
+namespace lldb_utility {
+
+//----------------------------------------------------------------------
+/// @class PseudoTerminal PseudoTerminal.h "lldb/Core/PseudoTerminal.h"
+/// @brief A pseudo terminal helper class.
+///
+/// The pseudo terminal class abstracts the use of pseudo terminals on
+/// the host system.
+//----------------------------------------------------------------------
+class PseudoTerminal {
+public:
+ enum {
+ invalid_fd = -1 ///< Invalid file descriptor value
+ };
+
+ //------------------------------------------------------------------
+ /// Default constructor
+ ///
+ /// Constructs this object with invalid master and slave file
+ /// descriptors.
+ //------------------------------------------------------------------
+ PseudoTerminal();
+
+ //------------------------------------------------------------------
+ /// Destructor
+ ///
+ /// The destructor will close the master and slave file descriptors
+ /// if they are valid and ownership has not been released using
+ /// one of:
+ /// @li PseudoTerminal::ReleaseMasterFileDescriptor()
+ /// @li PseudoTerminal::ReleaseSaveFileDescriptor()
+ //------------------------------------------------------------------
+ ~PseudoTerminal();
+
+ //------------------------------------------------------------------
+ /// Close the master file descriptor if it is valid.
+ //------------------------------------------------------------------
+ void CloseMasterFileDescriptor();
+
+ //------------------------------------------------------------------
+ /// Close the slave file descriptor if it is valid.
+ //------------------------------------------------------------------
+ void CloseSlaveFileDescriptor();
+
+ //------------------------------------------------------------------
+ /// Fork a child process that uses pseudo terminals for its stdio.
+ ///
+ /// In the parent process, a call to this function results in a pid
+ /// being returned. If the pid is valid, the master file descriptor
+ /// can be used for read/write access to stdio of the child process.
+ ///
+ /// In the child process the stdin/stdout/stderr will already be
+ /// routed to the slave pseudo terminal and the master file
+ /// descriptor will be closed as it is no longer needed by the child
+ /// process.
+ ///
+ /// This class will close the file descriptors for the master/slave
+ /// when the destructor is called. The file handles can be released
+ /// using either:
+ /// @li PseudoTerminal::ReleaseMasterFileDescriptor()
+ /// @li PseudoTerminal::ReleaseSaveFileDescriptor()
+ ///
+ /// @param[out] error
+ /// An pointer to an error that can describe any errors that
+ /// occur. This can be NULL if no error status is desired.
+ ///
+ /// @return
+ /// @li \b Parent process: a child process ID that is greater
+ /// than zero, or -1 if the fork fails.
+ /// @li \b Child process: zero.
+ //------------------------------------------------------------------
+ lldb::pid_t Fork(char *error_str, size_t error_len);
+
+ //------------------------------------------------------------------
+ /// The master file descriptor accessor.
+ ///
+ /// This object retains ownership of the master file descriptor when
+ /// this accessor is used. Users can call the member function
+ /// PseudoTerminal::ReleaseMasterFileDescriptor() if this
+ /// object should release ownership of the slave file descriptor.
+ ///
+ /// @return
+ /// The master file descriptor, or PseudoTerminal::invalid_fd
+ /// if the master file descriptor is not currently valid.
+ ///
+ /// @see PseudoTerminal::ReleaseMasterFileDescriptor()
+ //------------------------------------------------------------------
+ int GetMasterFileDescriptor() const;
+
+ //------------------------------------------------------------------
+ /// The slave file descriptor accessor.
+ ///
+ /// This object retains ownership of the slave file descriptor when
+ /// this accessor is used. Users can call the member function
+ /// PseudoTerminal::ReleaseSlaveFileDescriptor() if this
+ /// object should release ownership of the slave file descriptor.
+ ///
+ /// @return
+ /// The slave file descriptor, or PseudoTerminal::invalid_fd
+ /// if the slave file descriptor is not currently valid.
+ ///
+ /// @see PseudoTerminal::ReleaseSlaveFileDescriptor()
+ //------------------------------------------------------------------
+ int GetSlaveFileDescriptor() const;
+
+ //------------------------------------------------------------------
+ /// Get the name of the slave pseudo terminal.
+ ///
+ /// A master pseudo terminal should already be valid prior to
+ /// calling this function.
+ ///
+ /// @param[out] error
+ /// An pointer to an error that can describe any errors that
+ /// occur. This can be NULL if no error status is desired.
+ ///
+ /// @return
+ /// The name of the slave pseudo terminal as a NULL terminated
+ /// C. This string that comes from static memory, so a copy of
+ /// the string should be made as subsequent calls can change
+ /// this value. NULL is returned if this object doesn't have
+ /// a valid master pseudo terminal opened or if the call to
+ /// \c ptsname() fails.
+ ///
+ /// @see PseudoTerminal::OpenFirstAvailableMaster()
+ //------------------------------------------------------------------
+ const char *GetSlaveName(char *error_str, size_t error_len) const;
+
+ //------------------------------------------------------------------
+ /// Open the first available pseudo terminal.
+ ///
+ /// Opens the first available pseudo terminal with \a oflag as the
+ /// permissions. The opened master file descriptor is stored in this
+ /// object and can be accessed by calling the
+ /// PseudoTerminal::GetMasterFileDescriptor() accessor. Clients
+ /// can call the PseudoTerminal::ReleaseMasterFileDescriptor()
+ /// accessor function if they wish to use the master file descriptor
+ /// beyond the lifespan of this object.
+ ///
+ /// If this object still has a valid master file descriptor when its
+ /// destructor is called, it will close it.
+ ///
+ /// @param[in] oflag
+ /// Flags to use when calling \c posix_openpt(\a oflag).
+ /// A value of "O_RDWR|O_NOCTTY" is suggested.
+ ///
+ /// @param[out] error
+ /// An pointer to an error that can describe any errors that
+ /// occur. This can be NULL if no error status is desired.
+ ///
+ /// @return
+ /// @li \b true when the master files descriptor is
+ /// successfully opened.
+ /// @li \b false if anything goes wrong.
+ ///
+ /// @see PseudoTerminal::GetMasterFileDescriptor()
+ /// @see PseudoTerminal::ReleaseMasterFileDescriptor()
+ //------------------------------------------------------------------
+ bool OpenFirstAvailableMaster(int oflag, char *error_str, size_t error_len);
+
+ //------------------------------------------------------------------
+ /// Open the slave for the current master pseudo terminal.
+ ///
+ /// A master pseudo terminal should already be valid prior to
+ /// calling this function. The opened slave file descriptor is
+ /// stored in this object and can be accessed by calling the
+ /// PseudoTerminal::GetSlaveFileDescriptor() accessor. Clients
+ /// can call the PseudoTerminal::ReleaseSlaveFileDescriptor()
+ /// accessor function if they wish to use the slave file descriptor
+ /// beyond the lifespan of this object.
+ ///
+ /// If this object still has a valid slave file descriptor when its
+ /// destructor is called, it will close it.
+ ///
+ /// @param[in] oflag
+ /// Flags to use when calling \c open(\a oflag).
+ ///
+ /// @param[out] error
+ /// An pointer to an error that can describe any errors that
+ /// occur. This can be NULL if no error status is desired.
+ ///
+ /// @return
+ /// @li \b true when the master files descriptor is
+ /// successfully opened.
+ /// @li \b false if anything goes wrong.
+ ///
+ /// @see PseudoTerminal::OpenFirstAvailableMaster()
+ /// @see PseudoTerminal::GetSlaveFileDescriptor()
+ /// @see PseudoTerminal::ReleaseSlaveFileDescriptor()
+ //------------------------------------------------------------------
+ bool OpenSlave(int oflag, char *error_str, size_t error_len);
+
+ //------------------------------------------------------------------
+ /// Release the master file descriptor.
+ ///
+ /// Releases ownership of the master pseudo terminal file descriptor
+ /// without closing it. The destructor for this class will close the
+ /// master file descriptor if the ownership isn't released using this
+ /// call and the master file descriptor has been opened.
+ ///
+ /// @return
+ /// The master file descriptor, or PseudoTerminal::invalid_fd
+ /// if the mast file descriptor is not currently valid.
+ //------------------------------------------------------------------
+ int ReleaseMasterFileDescriptor();
+
+ //------------------------------------------------------------------
+ /// Release the slave file descriptor.
+ ///
+ /// Release ownership of the slave pseudo terminal file descriptor
+ /// without closing it. The destructor for this class will close the
+ /// slave file descriptor if the ownership isn't released using this
+ /// call and the slave file descriptor has been opened.
+ ///
+ /// @return
+ /// The slave file descriptor, or PseudoTerminal::invalid_fd
+ /// if the slave file descriptor is not currently valid.
+ //------------------------------------------------------------------
+ int ReleaseSlaveFileDescriptor();
+
+protected:
+ //------------------------------------------------------------------
+ // Member variables
+ //------------------------------------------------------------------
+ int m_master_fd; ///< The file descriptor for the master.
+ int m_slave_fd; ///< The file descriptor for the slave.
+
+private:
+ DISALLOW_COPY_AND_ASSIGN(PseudoTerminal);
+};
+
+} // namespace lldb_utility
+
+#endif // #if defined(__cplusplus)
+#endif // #ifndef liblldb_PseudoTerminal_h_
--- /dev/null
+//===--------------------- Range.h ------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef utility_Range_h_
+#define utility_Range_h_
+
+#include <algorithm>
+#include <stdint.h>
+
+namespace lldb_utility {
+
+class Range {
+public:
+ typedef uint64_t ValueType;
+
+ static const ValueType OPEN_END = UINT64_MAX;
+
+ Range(const Range &rng);
+
+ Range(ValueType low = 0, ValueType high = OPEN_END);
+
+ Range &operator=(const Range &rhs);
+
+ ValueType GetLow() { return m_low; }
+
+ ValueType GetHigh() { return m_high; }
+
+ void SetLow(ValueType low) { m_low = low; }
+
+ void SetHigh(ValueType high) { m_high = high; }
+
+ void Flip();
+
+ void Intersection(const Range &other);
+
+ void Union(const Range &other);
+
+ typedef bool (*RangeCallback)(ValueType index);
+
+ void Iterate(RangeCallback callback);
+
+ ValueType GetSize();
+
+ bool IsEmpty();
+
+private:
+ void InitRange();
+
+ ValueType m_low;
+ ValueType m_high;
+};
+
+} // namespace lldb_private
+
+#endif // #ifndef utility_Range_h_
--- /dev/null
+//===-- RegisterNumber.h ----------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_RegisterNumber_h
+#define liblldb_RegisterNumber_h
+
+#include "lldb/lldb-private.h"
+#include <map>
+
+//--------------------------------------------------------------------
+/// A class to represent register numbers, and able to convert between
+/// different register numbering schemes that may be used in a single
+/// debug session.
+//--------------------------------------------------------------------
+
+class RegisterNumber {
+public:
+ RegisterNumber(lldb_private::Thread &thread, lldb::RegisterKind kind,
+ uint32_t num);
+
+ // This constructor plus the init() method below allow for the placeholder
+ // creation of an invalid object initially, possibly to be filled in. It
+ // would be more consistent to have three Set* methods to set the three
+ // data that the object needs.
+ RegisterNumber();
+
+ void init(lldb_private::Thread &thread, lldb::RegisterKind kind,
+ uint32_t num);
+
+ const RegisterNumber &operator=(const RegisterNumber &rhs);
+
+ bool operator==(RegisterNumber &rhs);
+
+ bool operator!=(RegisterNumber &rhs);
+
+ bool IsValid() const;
+
+ uint32_t GetAsKind(lldb::RegisterKind kind);
+
+ uint32_t GetRegisterNumber() const;
+
+ lldb::RegisterKind GetRegisterKind() const;
+
+ const char *GetName();
+
+private:
+ typedef std::map<lldb::RegisterKind, uint32_t> Collection;
+
+ lldb::RegisterContextSP m_reg_ctx_sp;
+ uint32_t m_regnum;
+ lldb::RegisterKind m_kind;
+ Collection m_kind_regnum_map;
+ const char *m_name;
+};
+
+#endif // liblldb_RegisterNumber_h
--- /dev/null
+//===-- SafeMachO.h -----------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef liblldb_SafeMachO_h_
+#define liblldb_SafeMachO_h_
+
+// This header file is required to work around collisions between the defines in
+// mach/machine.h, and enum members
+// of the same name in llvm's MachO.h. If you want to use llvm/Support/MachO.h,
+// use this file instead.
+// The caveats are:
+// 1) You can only use the MachO.h enums, you can't use the defines. That won't
+// make a difference since the values
+// are the same.
+// 2) If you need any header file that relies on mach/machine.h, you must
+// include that first.
+// 3) This isn't a total solution, it doesn't undef every define that MachO.h
+// has borrowed from various system headers,
+// only the ones that come from mach/machine.h because that is the one we
+// ended up pulling in from various places.
+//
+
+#undef CPU_ARCH_MASK
+#undef CPU_ARCH_ABI64
+
+#undef CPU_TYPE_ANY
+#undef CPU_TYPE_X86
+#undef CPU_TYPE_I386
+#undef CPU_TYPE_X86_64
+#undef CPU_TYPE_MC98000
+#undef CPU_TYPE_ARM
+#undef CPU_TYPE_ARM64
+#undef CPU_TYPE_SPARC
+#undef CPU_TYPE_POWERPC
+#undef CPU_TYPE_POWERPC64
+
+#undef CPU_SUB_TYPE_MASK
+#undef CPU_SUB_TYPE_LIB64
+
+#undef CPU_SUBTYPE_MULTIPLE
+
+#undef CPU_SUBTYPE_I386_ALL
+#undef CPU_SUBTYPE_386
+#undef CPU_SUBTYPE_486
+#undef CPU_SUBTYPE_486SX
+#undef CPU_SUBTYPE_586
+#undef CPU_SUBTYPE_PENT
+#undef CPU_SUBTYPE_PENTPRO
+#undef CPU_SUBTYPE_PENTII_M3
+#undef CPU_SUBTYPE_PENTII_M5
+#undef CPU_SUBTYPE_CELERON
+#undef CPU_SUBTYPE_CELERON_MOBILE
+#undef CPU_SUBTYPE_PENTIUM_3
+#undef CPU_SUBTYPE_PENTIUM_3_M
+#undef CPU_SUBTYPE_PENTIUM_3_XEON
+#undef CPU_SUBTYPE_PENTIUM_M
+#undef CPU_SUBTYPE_PENTIUM_4
+#undef CPU_SUBTYPE_PENTIUM_4_M
+#undef CPU_SUBTYPE_ITANIUM
+#undef CPU_SUBTYPE_ITANIUM_2
+#undef CPU_SUBTYPE_XEON
+#undef CPU_SUBTYPE_XEON_MP
+
+#undef CPU_SUBTYPE_X86_ALL
+#undef CPU_SUBTYPE_X86_64_ALL
+#undef CPU_SUBTYPE_X86_ARCH1
+#undef CPU_SUBTYPE_X86_64_H
+
+#undef CPU_SUBTYPE_INTEL
+#undef CPU_SUBTYPE_INTEL_FAMILY
+#undef CPU_SUBTYPE_INTEL_FAMILY_MAX
+#undef CPU_SUBTYPE_INTEL_MODEL
+#undef CPU_SUBTYPE_INTEL_MODEL_ALL
+
+#undef CPU_SUBTYPE_ARM
+#undef CPU_SUBTYPE_ARM_ALL
+#undef CPU_SUBTYPE_ARM_V4T
+#undef CPU_SUBTYPE_ARM_V6
+#undef CPU_SUBTYPE_ARM_V5
+#undef CPU_SUBTYPE_ARM_V5TEJ
+#undef CPU_SUBTYPE_ARM_XSCALE
+#undef CPU_SUBTYPE_ARM_V7
+
+#undef CPU_SUBTYPE_ARM_V7S
+#undef CPU_SUBTYPE_ARM_V7K
+#undef CPU_SUBTYPE_ARM_V6M
+#undef CPU_SUBTYPE_ARM_V7M
+#undef CPU_SUBTYPE_ARM_V7EM
+
+#undef CPU_SUBTYPE_ARM64_ALL
+
+#undef CPU_SUBTYPE_SPARC_ALL
+
+#undef CPU_SUBTYPE_POWERPC
+#undef CPU_SUBTYPE_POWERPC_ALL
+#undef CPU_SUBTYPE_POWERPC_601
+#undef CPU_SUBTYPE_POWERPC_602
+#undef CPU_SUBTYPE_POWERPC_603
+#undef CPU_SUBTYPE_POWERPC_603e
+#undef CPU_SUBTYPE_POWERPC_603ev
+#undef CPU_SUBTYPE_POWERPC_604
+#undef CPU_SUBTYPE_POWERPC_604e
+#undef CPU_SUBTYPE_POWERPC_620
+#undef CPU_SUBTYPE_POWERPC_750
+#undef CPU_SUBTYPE_POWERPC_7400
+#undef CPU_SUBTYPE_POWERPC_7450
+#undef CPU_SUBTYPE_POWERPC_970
+
+#undef CPU_SUBTYPE_MC980000_ALL
+#undef CPU_SUBTYPE_MC98601
+
+#include "llvm/Support/MachO.h"
+
+#endif // liblldb_SafeMachO_h_
--- /dev/null
+//===-- SelectHelper.h ------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_SelectHelper_h_
+#define liblldb_SelectHelper_h_
+
+// C Includes
+// C++ Includes
+#include <chrono>
+
+// Other libraries and framework includes
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/Optional.h"
+
+// Project includes
+#include "lldb/lldb-forward.h"
+
+class SelectHelper {
+public:
+ // Defaults to infinite wait for select unless you call SetTimeout()
+ SelectHelper();
+
+ // Call SetTimeout() before calling SelectHelper::Select() to set the
+ // timeout based on the current time + the timeout. This allows multiple
+ // calls to SelectHelper::Select() without having to worry about the
+ // absolute timeout as this class manages to set the relative timeout
+ // correctly.
+ void SetTimeout(const std::chrono::microseconds &timeout);
+
+ // Call the FDSet*() functions before calling SelectHelper::Select() to
+ // set the file descriptors that we will watch for when calling
+ // select. This will cause FD_SET() to be called prior to calling select
+ // using the "fd" provided.
+ void FDSetRead(lldb::socket_t fd);
+ void FDSetWrite(lldb::socket_t fd);
+ void FDSetError(lldb::socket_t fd);
+
+ // Call the FDIsSet*() functions after calling SelectHelper::Select()
+ // to check which file descriptors are ready for read/write/error. This
+ // will contain the result of FD_ISSET after calling select for a given
+ // file descriptor.
+ bool FDIsSetRead(lldb::socket_t fd) const;
+ bool FDIsSetWrite(lldb::socket_t fd) const;
+ bool FDIsSetError(lldb::socket_t fd) const;
+
+ // Call the system's select() to wait for descriptors using
+ // timeout provided in a call the SelectHelper::SetTimeout(),
+ // or infinite wait if no timeout was set.
+ lldb_private::Error Select();
+
+protected:
+ struct FDInfo {
+ FDInfo()
+ : read_set(false), write_set(false), error_set(false),
+ read_is_set(false), write_is_set(false), error_is_set(false) {}
+
+ void PrepareForSelect() {
+ read_is_set = false;
+ write_is_set = false;
+ error_is_set = false;
+ }
+
+ bool read_set : 1, write_set : 1, error_set : 1, read_is_set : 1,
+ write_is_set : 1, error_is_set : 1;
+ };
+ llvm::DenseMap<lldb::socket_t, FDInfo> m_fd_map;
+ llvm::Optional<std::chrono::steady_clock::time_point> m_end_time;
+};
+
+#endif // liblldb_SelectHelper_h_
--- /dev/null
+//===------------------SharedCluster.h --------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef utility_SharedCluster_h_
+#define utility_SharedCluster_h_
+
+#include "lldb/Utility/LLDBAssert.h"
+#include "lldb/Utility/SharingPtr.h"
+
+#include "llvm/ADT/SmallPtrSet.h"
+
+namespace lldb_private {
+
+namespace imp {
+template <typename T>
+class shared_ptr_refcount : public lldb_private::imp::shared_count {
+public:
+ template <class Y>
+ shared_ptr_refcount(Y *in) : shared_count(0), manager(in) {}
+
+ shared_ptr_refcount() : shared_count(0) {}
+
+ ~shared_ptr_refcount() override {}
+
+ void on_zero_shared() override { manager->DecrementRefCount(); }
+
+private:
+ T *manager;
+};
+
+} // namespace imp
+
+template <class T> class ClusterManager {
+public:
+ ClusterManager() : m_objects(), m_external_ref(0), m_mutex() {}
+
+ ~ClusterManager() {
+ for (typename llvm::SmallPtrSet<T *, 16>::iterator pos = m_objects.begin(),
+ end = m_objects.end();
+ pos != end; ++pos) {
+ T *object = *pos;
+ delete object;
+ }
+
+ // Decrement refcount should have been called on this ClusterManager,
+ // and it should have locked the mutex, now we will unlock it before
+ // we destroy it...
+ m_mutex.unlock();
+ }
+
+ void ManageObject(T *new_object) {
+ std::lock_guard<std::mutex> guard(m_mutex);
+ m_objects.insert(new_object);
+ }
+
+ typename lldb_private::SharingPtr<T> GetSharedPointer(T *desired_object) {
+ {
+ std::lock_guard<std::mutex> guard(m_mutex);
+ m_external_ref++;
+ if (0 == m_objects.count(desired_object)) {
+ lldbassert(false && "object not found in shared cluster when expected");
+ desired_object = nullptr;
+ }
+ }
+ return typename lldb_private::SharingPtr<T>(
+ desired_object, new imp::shared_ptr_refcount<ClusterManager>(this));
+ }
+
+private:
+ void DecrementRefCount() {
+ m_mutex.lock();
+ m_external_ref--;
+ if (m_external_ref == 0)
+ delete this;
+ else
+ m_mutex.unlock();
+ }
+
+ friend class imp::shared_ptr_refcount<ClusterManager>;
+
+ llvm::SmallPtrSet<T *, 16> m_objects;
+ int m_external_ref;
+ std::mutex m_mutex;
+};
+
+} // namespace lldb_private
+
+#endif // utility_SharedCluster_h_
--- /dev/null
+//===---------------------SharingPtr.h --------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef utility_SharingPtr_h_
+#define utility_SharingPtr_h_
+
+// C Includes
+// C++ Includes
+#include <algorithm>
+#include <memory>
+
+// Microsoft Visual C++ currently does not enable std::atomic to work
+// in CLR mode - as such we need to "hack around it" for MSVC++ builds only
+// using Windows specific intrinsics instead of the C++11 atomic support
+#ifdef _MSC_VER
+#include <intrin.h>
+#else
+#include <atomic>
+#endif
+
+// Other libraries and framework includes
+// Project includes
+
+//#define ENABLE_SP_LOGGING 1 // DON'T CHECK THIS LINE IN UNLESS COMMENTED OUT
+#if defined(ENABLE_SP_LOGGING)
+
+extern "C" void track_sp(void *sp_this, void *ptr, long count);
+
+#endif
+
+namespace lldb_private {
+
+namespace imp {
+
+class shared_count {
+ shared_count(const shared_count &);
+ shared_count &operator=(const shared_count &);
+
+public:
+ explicit shared_count(long refs = 0) : shared_owners_(refs) {}
+
+ void add_shared();
+ void release_shared();
+ long use_count() const { return shared_owners_ + 1; }
+
+protected:
+#ifdef _MSC_VER
+ long shared_owners_;
+#else
+ std::atomic<long> shared_owners_;
+#endif
+ virtual ~shared_count();
+
+private:
+ virtual void on_zero_shared() = 0;
+};
+
+template <class T> class shared_ptr_pointer : public shared_count {
+ T data_;
+
+public:
+ shared_ptr_pointer(T p) : data_(p) {}
+
+private:
+ void on_zero_shared() override;
+
+ // Outlaw copy constructor and assignment operator to keep effective C++
+ // warnings down to a minimum
+ shared_ptr_pointer(const shared_ptr_pointer &);
+ shared_ptr_pointer &operator=(const shared_ptr_pointer &);
+};
+
+template <class T> void shared_ptr_pointer<T>::on_zero_shared() {
+ delete data_;
+}
+
+template <class T> class shared_ptr_emplace : public shared_count {
+ T data_;
+
+public:
+ shared_ptr_emplace() : data_() {}
+
+ template <class A0> shared_ptr_emplace(A0 &a0) : data_(a0) {}
+
+ template <class A0, class A1>
+ shared_ptr_emplace(A0 &a0, A1 &a1) : data_(a0, a1) {}
+
+ template <class A0, class A1, class A2>
+ shared_ptr_emplace(A0 &a0, A1 &a1, A2 &a2) : data_(a0, a1, a2) {}
+
+ template <class A0, class A1, class A2, class A3>
+ shared_ptr_emplace(A0 &a0, A1 &a1, A2 &a2, A3 &a3) : data_(a0, a1, a2, a3) {}
+
+ template <class A0, class A1, class A2, class A3, class A4>
+ shared_ptr_emplace(A0 &a0, A1 &a1, A2 &a2, A3 &a3, A4 &a4)
+ : data_(a0, a1, a2, a3, a4) {}
+
+private:
+ void on_zero_shared() override;
+
+public:
+ T *get() { return &data_; }
+};
+
+template <class T> void shared_ptr_emplace<T>::on_zero_shared() {}
+
+} // namespace imp
+
+template <class T> class SharingPtr {
+public:
+ typedef T element_type;
+
+private:
+ element_type *ptr_;
+ imp::shared_count *cntrl_;
+
+ struct nat {
+ int for_bool_;
+ };
+
+public:
+ SharingPtr();
+ SharingPtr(std::nullptr_t);
+ template <class Y> explicit SharingPtr(Y *p);
+ template <class Y> explicit SharingPtr(Y *p, imp::shared_count *ctrl_block);
+ template <class Y> SharingPtr(const SharingPtr<Y> &r, element_type *p);
+ SharingPtr(const SharingPtr &r);
+ template <class Y> SharingPtr(const SharingPtr<Y> &r);
+
+ ~SharingPtr();
+
+ SharingPtr &operator=(const SharingPtr &r);
+ template <class Y> SharingPtr &operator=(const SharingPtr<Y> &r);
+
+ void swap(SharingPtr &r);
+ void reset();
+ template <class Y> void reset(Y *p);
+ void reset(std::nullptr_t);
+
+ element_type *get() const { return ptr_; }
+ element_type &operator*() const { return *ptr_; }
+ element_type *operator->() const { return ptr_; }
+ long use_count() const { return cntrl_ ? cntrl_->use_count() : 0; }
+ bool unique() const { return use_count() == 1; }
+ bool empty() const { return cntrl_ == nullptr; }
+ operator nat *() const { return (nat *)get(); }
+
+ static SharingPtr<T> make_shared();
+
+ template <class A0> static SharingPtr<T> make_shared(A0 &);
+
+ template <class A0, class A1> static SharingPtr<T> make_shared(A0 &, A1 &);
+
+ template <class A0, class A1, class A2>
+ static SharingPtr<T> make_shared(A0 &, A1 &, A2 &);
+
+ template <class A0, class A1, class A2, class A3>
+ static SharingPtr<T> make_shared(A0 &, A1 &, A2 &, A3 &);
+
+ template <class A0, class A1, class A2, class A3, class A4>
+ static SharingPtr<T> make_shared(A0 &, A1 &, A2 &, A3 &, A4 &);
+
+private:
+ template <class U> friend class SharingPtr;
+};
+
+template <class T>
+inline SharingPtr<T>::SharingPtr() : ptr_(nullptr), cntrl_(nullptr) {}
+
+template <class T>
+inline SharingPtr<T>::SharingPtr(std::nullptr_t)
+ : ptr_(nullptr), cntrl_(nullptr) {}
+
+template <class T>
+template <class Y>
+SharingPtr<T>::SharingPtr(Y *p) : ptr_(p), cntrl_(nullptr) {
+ std::unique_ptr<Y> hold(p);
+ typedef imp::shared_ptr_pointer<Y *> _CntrlBlk;
+ cntrl_ = new _CntrlBlk(p);
+ hold.release();
+}
+
+template <class T>
+template <class Y>
+SharingPtr<T>::SharingPtr(Y *p, imp::shared_count *cntrl_block)
+ : ptr_(p), cntrl_(cntrl_block) {}
+
+template <class T>
+template <class Y>
+inline SharingPtr<T>::SharingPtr(const SharingPtr<Y> &r, element_type *p)
+ : ptr_(p), cntrl_(r.cntrl_) {
+ if (cntrl_)
+ cntrl_->add_shared();
+}
+
+template <class T>
+inline SharingPtr<T>::SharingPtr(const SharingPtr &r)
+ : ptr_(r.ptr_), cntrl_(r.cntrl_) {
+ if (cntrl_)
+ cntrl_->add_shared();
+}
+
+template <class T>
+template <class Y>
+inline SharingPtr<T>::SharingPtr(const SharingPtr<Y> &r)
+ : ptr_(r.ptr_), cntrl_(r.cntrl_) {
+ if (cntrl_)
+ cntrl_->add_shared();
+}
+
+template <class T> SharingPtr<T>::~SharingPtr() {
+ if (cntrl_)
+ cntrl_->release_shared();
+}
+
+template <class T>
+inline SharingPtr<T> &SharingPtr<T>::operator=(const SharingPtr &r) {
+ SharingPtr(r).swap(*this);
+ return *this;
+}
+
+template <class T>
+template <class Y>
+inline SharingPtr<T> &SharingPtr<T>::operator=(const SharingPtr<Y> &r) {
+ SharingPtr(r).swap(*this);
+ return *this;
+}
+
+template <class T> inline void SharingPtr<T>::swap(SharingPtr &r) {
+ std::swap(ptr_, r.ptr_);
+ std::swap(cntrl_, r.cntrl_);
+}
+
+template <class T> inline void SharingPtr<T>::reset() {
+ SharingPtr().swap(*this);
+}
+
+template <class T> inline void SharingPtr<T>::reset(std::nullptr_t p) {
+ reset();
+}
+
+template <class T> template <class Y> inline void SharingPtr<T>::reset(Y *p) {
+ SharingPtr(p).swap(*this);
+}
+
+template <class T> SharingPtr<T> SharingPtr<T>::make_shared() {
+ typedef imp::shared_ptr_emplace<T> CntrlBlk;
+ SharingPtr<T> r;
+ r.cntrl_ = new CntrlBlk();
+ r.ptr_ = static_cast<CntrlBlk *>(r.cntrl_)->get();
+ return r;
+}
+
+template <class T>
+template <class A0>
+SharingPtr<T> SharingPtr<T>::make_shared(A0 &a0) {
+ typedef imp::shared_ptr_emplace<T> CntrlBlk;
+ SharingPtr<T> r;
+ r.cntrl_ = new CntrlBlk(a0);
+ r.ptr_ = static_cast<CntrlBlk *>(r.cntrl_)->get();
+ return r;
+}
+
+template <class T>
+template <class A0, class A1>
+SharingPtr<T> SharingPtr<T>::make_shared(A0 &a0, A1 &a1) {
+ typedef imp::shared_ptr_emplace<T> CntrlBlk;
+ SharingPtr<T> r;
+ r.cntrl_ = new CntrlBlk(a0, a1);
+ r.ptr_ = static_cast<CntrlBlk *>(r.cntrl_)->get();
+ return r;
+}
+
+template <class T>
+template <class A0, class A1, class A2>
+SharingPtr<T> SharingPtr<T>::make_shared(A0 &a0, A1 &a1, A2 &a2) {
+ typedef imp::shared_ptr_emplace<T> CntrlBlk;
+ SharingPtr<T> r;
+ r.cntrl_ = new CntrlBlk(a0, a1, a2);
+ r.ptr_ = static_cast<CntrlBlk *>(r.cntrl_)->get();
+ return r;
+}
+
+template <class T>
+template <class A0, class A1, class A2, class A3>
+SharingPtr<T> SharingPtr<T>::make_shared(A0 &a0, A1 &a1, A2 &a2, A3 &a3) {
+ typedef imp::shared_ptr_emplace<T> CntrlBlk;
+ SharingPtr<T> r;
+ r.cntrl_ = new CntrlBlk(a0, a1, a2, a3);
+ r.ptr_ = static_cast<CntrlBlk *>(r.cntrl_)->get();
+ return r;
+}
+
+template <class T>
+template <class A0, class A1, class A2, class A3, class A4>
+SharingPtr<T> SharingPtr<T>::make_shared(A0 &a0, A1 &a1, A2 &a2, A3 &a3,
+ A4 &a4) {
+ typedef imp::shared_ptr_emplace<T> CntrlBlk;
+ SharingPtr<T> r;
+ r.cntrl_ = new CntrlBlk(a0, a1, a2, a3, a4);
+ r.ptr_ = static_cast<CntrlBlk *>(r.cntrl_)->get();
+ return r;
+}
+
+template <class T> inline SharingPtr<T> make_shared() {
+ return SharingPtr<T>::make_shared();
+}
+
+template <class T, class A0> inline SharingPtr<T> make_shared(A0 &a0) {
+ return SharingPtr<T>::make_shared(a0);
+}
+
+template <class T, class A0, class A1>
+inline SharingPtr<T> make_shared(A0 &a0, A1 &a1) {
+ return SharingPtr<T>::make_shared(a0, a1);
+}
+
+template <class T, class A0, class A1, class A2>
+inline SharingPtr<T> make_shared(A0 &a0, A1 &a1, A2 &a2) {
+ return SharingPtr<T>::make_shared(a0, a1, a2);
+}
+
+template <class T, class A0, class A1, class A2, class A3>
+inline SharingPtr<T> make_shared(A0 &a0, A1 &a1, A2 &a2, A3 &a3) {
+ return SharingPtr<T>::make_shared(a0, a1, a2, a3);
+}
+
+template <class T, class A0, class A1, class A2, class A3, class A4>
+inline SharingPtr<T> make_shared(A0 &a0, A1 &a1, A2 &a2, A3 &a3, A4 &a4) {
+ return SharingPtr<T>::make_shared(a0, a1, a2, a3, a4);
+}
+
+template <class T, class U>
+inline bool operator==(const SharingPtr<T> &__x, const SharingPtr<U> &__y) {
+ return __x.get() == __y.get();
+}
+
+template <class T, class U>
+inline bool operator!=(const SharingPtr<T> &__x, const SharingPtr<U> &__y) {
+ return !(__x == __y);
+}
+
+template <class T, class U>
+inline bool operator<(const SharingPtr<T> &__x, const SharingPtr<U> &__y) {
+ return __x.get() < __y.get();
+}
+
+template <class T> inline void swap(SharingPtr<T> &__x, SharingPtr<T> &__y) {
+ __x.swap(__y);
+}
+
+template <class T, class U>
+inline SharingPtr<T> static_pointer_cast(const SharingPtr<U> &r) {
+ return SharingPtr<T>(r, static_cast<T *>(r.get()));
+}
+
+template <class T, class U>
+SharingPtr<T> const_pointer_cast(const SharingPtr<U> &r) {
+ return SharingPtr<T>(r, const_cast<T *>(r.get()));
+}
+
+template <class T> class LoggingSharingPtr : public SharingPtr<T> {
+ typedef SharingPtr<T> base;
+
+public:
+ typedef void (*Callback)(void *, const LoggingSharingPtr &, bool action);
+ // action: false means increment just happened
+ // true means decrement is about to happen
+
+ LoggingSharingPtr() : cb_(0), baton_(nullptr) {}
+
+ LoggingSharingPtr(Callback cb, void *baton) : cb_(cb), baton_(baton) {
+ if (cb_)
+ cb_(baton_, *this, false);
+ }
+
+ template <class Y>
+ LoggingSharingPtr(Y *p) : base(p), cb_(0), baton_(nullptr) {}
+
+ template <class Y>
+ LoggingSharingPtr(Y *p, Callback cb, void *baton)
+ : base(p), cb_(cb), baton_(baton) {
+ if (cb_)
+ cb_(baton_, *this, false);
+ }
+
+ ~LoggingSharingPtr() {
+ if (cb_)
+ cb_(baton_, *this, true);
+ }
+
+ LoggingSharingPtr(const LoggingSharingPtr &p)
+ : base(p), cb_(p.cb_), baton_(p.baton_) {
+ if (cb_)
+ cb_(baton_, *this, false);
+ }
+
+ LoggingSharingPtr &operator=(const LoggingSharingPtr &p) {
+ if (cb_)
+ cb_(baton_, *this, true);
+ base::operator=(p);
+ cb_ = p.cb_;
+ baton_ = p.baton_;
+ if (cb_)
+ cb_(baton_, *this, false);
+ return *this;
+ }
+
+ void reset() {
+ if (cb_)
+ cb_(baton_, *this, true);
+ base::reset();
+ }
+
+ template <class Y> void reset(Y *p) {
+ if (cb_)
+ cb_(baton_, *this, true);
+ base::reset(p);
+ if (cb_)
+ cb_(baton_, *this, false);
+ }
+
+ void SetCallback(Callback cb, void *baton) {
+ cb_ = cb;
+ baton_ = baton;
+ }
+
+ void ClearCallback() {
+ cb_ = 0;
+ baton_ = 0;
+ }
+
+private:
+ Callback cb_;
+ void *baton_;
+};
+
+template <class T> class IntrusiveSharingPtr;
+
+template <class T> class ReferenceCountedBase {
+public:
+ explicit ReferenceCountedBase() : shared_owners_(-1) {}
+
+ void add_shared();
+
+ void release_shared();
+
+ long use_count() const { return shared_owners_ + 1; }
+
+protected:
+ long shared_owners_;
+
+ friend class IntrusiveSharingPtr<T>;
+
+private:
+ ReferenceCountedBase(const ReferenceCountedBase &);
+ ReferenceCountedBase &operator=(const ReferenceCountedBase &);
+};
+
+template <class T> void lldb_private::ReferenceCountedBase<T>::add_shared() {
+#ifdef _MSC_VER
+ _InterlockedIncrement(&shared_owners_);
+#else
+ ++shared_owners_;
+#endif
+}
+
+template <class T>
+void lldb_private::ReferenceCountedBase<T>::release_shared() {
+#ifdef _MSC_VER
+ if (_InterlockedDecrement(&shared_owners_) == -1)
+#else
+ if (--shared_owners_ == -1)
+#endif
+ delete static_cast<T *>(this);
+}
+
+template <class T>
+class ReferenceCountedBaseVirtual : public imp::shared_count {
+public:
+ explicit ReferenceCountedBaseVirtual() : imp::shared_count(-1) {}
+
+ ~ReferenceCountedBaseVirtual() override = default;
+
+ void on_zero_shared() override;
+};
+
+template <class T> void ReferenceCountedBaseVirtual<T>::on_zero_shared() {}
+
+template <typename T> class IntrusiveSharingPtr {
+public:
+ typedef T element_type;
+
+ explicit IntrusiveSharingPtr() : ptr_(0) {}
+
+ explicit IntrusiveSharingPtr(T *ptr) : ptr_(ptr) { add_shared(); }
+
+ IntrusiveSharingPtr(const IntrusiveSharingPtr &rhs) : ptr_(rhs.ptr_) {
+ add_shared();
+ }
+
+ template <class X>
+ IntrusiveSharingPtr(const IntrusiveSharingPtr<X> &rhs) : ptr_(rhs.get()) {
+ add_shared();
+ }
+
+ IntrusiveSharingPtr &operator=(const IntrusiveSharingPtr &rhs) {
+ reset(rhs.get());
+ return *this;
+ }
+
+ template <class X>
+ IntrusiveSharingPtr &operator=(const IntrusiveSharingPtr<X> &rhs) {
+ reset(rhs.get());
+ return *this;
+ }
+
+ IntrusiveSharingPtr &operator=(T *ptr) {
+ reset(ptr);
+ return *this;
+ }
+
+ ~IntrusiveSharingPtr() {
+ release_shared();
+#if defined(LLDB_CONFIGURATION_DEBUG) || defined(LLDB_CONFIGURATION_RELEASE)
+ // NULL out the pointer in objects which can help with leaks detection.
+ // We don't enable this for LLDB_CONFIGURATION_BUILD_AND_INTEGRATION or
+ // when none of the LLDB_CONFIGURATION_XXX macros are defined since
+ // those would be builds for release. But for debug and release builds
+ // that are for development, we NULL out the pointers to catch potential
+ // issues.
+ ptr_ = nullptr;
+#endif // #if defined (LLDB_CONFIGURATION_DEBUG) || defined
+ // (LLDB_CONFIGURATION_RELEASE)
+ }
+
+ T &operator*() const { return *ptr_; }
+
+ T *operator->() const { return ptr_; }
+
+ T *get() const { return ptr_; }
+
+ explicit operator bool() const { return ptr_ != 0; }
+
+ void swap(IntrusiveSharingPtr &rhs) {
+ std::swap(ptr_, rhs.ptr_);
+#if defined(ENABLE_SP_LOGGING)
+ track_sp(this, ptr_, use_count());
+ track_sp(&rhs, rhs.ptr_, rhs.use_count());
+#endif
+ }
+
+ void reset(T *ptr = nullptr) { IntrusiveSharingPtr(ptr).swap(*this); }
+
+ long use_count() const {
+ if (ptr_)
+ return ptr_->use_count();
+ return 0;
+ }
+
+ bool unique() const { return use_count() == 1; }
+
+private:
+ element_type *ptr_;
+
+ void add_shared() {
+ if (ptr_) {
+ ptr_->add_shared();
+#if defined(ENABLE_SP_LOGGING)
+ track_sp(this, ptr_, ptr_->use_count());
+#endif
+ }
+ }
+ void release_shared() {
+ if (ptr_) {
+#if defined(ENABLE_SP_LOGGING)
+ track_sp(this, nullptr, ptr_->use_count() - 1);
+#endif
+ ptr_->release_shared();
+ }
+ }
+};
+
+template <class T, class U>
+inline bool operator==(const IntrusiveSharingPtr<T> &lhs,
+ const IntrusiveSharingPtr<U> &rhs) {
+ return lhs.get() == rhs.get();
+}
+
+template <class T, class U>
+inline bool operator!=(const IntrusiveSharingPtr<T> &lhs,
+ const IntrusiveSharingPtr<U> &rhs) {
+ return lhs.get() != rhs.get();
+}
+
+template <class T, class U>
+inline bool operator==(const IntrusiveSharingPtr<T> &lhs, U *rhs) {
+ return lhs.get() == rhs;
+}
+
+template <class T, class U>
+inline bool operator!=(const IntrusiveSharingPtr<T> &lhs, U *rhs) {
+ return lhs.get() != rhs;
+}
+
+template <class T, class U>
+inline bool operator==(T *lhs, const IntrusiveSharingPtr<U> &rhs) {
+ return lhs == rhs.get();
+}
+
+template <class T, class U>
+inline bool operator!=(T *lhs, const IntrusiveSharingPtr<U> &rhs) {
+ return lhs != rhs.get();
+}
+
+} // namespace lldb_private
+
+#endif // utility_SharingPtr_h_
--- /dev/null
+//===-- StringExtractor.h ---------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef utility_StringExtractor_h_
+#define utility_StringExtractor_h_
+
+// C Includes
+// C++ Includes
+#include <stdint.h>
+#include <string>
+
+// Other libraries and framework includes
+// Project includes
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/StringRef.h"
+
+class StringExtractor {
+public:
+ enum { BigEndian = 0, LittleEndian = 1 };
+ //------------------------------------------------------------------
+ // Constructors and Destructors
+ //------------------------------------------------------------------
+ StringExtractor();
+ StringExtractor(llvm::StringRef packet_str);
+ StringExtractor(const char *packet_cstr);
+ StringExtractor(const StringExtractor &rhs);
+ virtual ~StringExtractor();
+
+ //------------------------------------------------------------------
+ // Operators
+ //------------------------------------------------------------------
+ const StringExtractor &operator=(const StringExtractor &rhs);
+
+ void Reset(llvm::StringRef str) {
+ m_packet = str;
+ m_index = 0;
+ }
+
+ // Returns true if the file position is still valid for the data
+ // contained in this string extractor object.
+ bool IsGood() const { return m_index != UINT64_MAX; }
+
+ uint64_t GetFilePos() const { return m_index; }
+
+ void SetFilePos(uint32_t idx) { m_index = idx; }
+
+ void Clear() {
+ m_packet.clear();
+ m_index = 0;
+ }
+
+ void SkipSpaces();
+
+ std::string &GetStringRef() { return m_packet; }
+
+ const std::string &GetStringRef() const { return m_packet; }
+
+ bool Empty() { return m_packet.empty(); }
+
+ size_t GetBytesLeft() {
+ if (m_index < m_packet.size())
+ return m_packet.size() - m_index;
+ return 0;
+ }
+
+ char GetChar(char fail_value = '\0');
+
+ char PeekChar(char fail_value = '\0') {
+ const char *cstr = Peek();
+ if (cstr)
+ return cstr[0];
+ return fail_value;
+ }
+
+ int DecodeHexU8();
+
+ uint8_t GetHexU8(uint8_t fail_value = 0, bool set_eof_on_fail = true);
+
+ bool GetHexU8Ex(uint8_t &ch, bool set_eof_on_fail = true);
+
+ bool GetNameColonValue(llvm::StringRef &name, llvm::StringRef &value);
+
+ int32_t GetS32(int32_t fail_value, int base = 0);
+
+ uint32_t GetU32(uint32_t fail_value, int base = 0);
+
+ int64_t GetS64(int64_t fail_value, int base = 0);
+
+ uint64_t GetU64(uint64_t fail_value, int base = 0);
+
+ uint32_t GetHexMaxU32(bool little_endian, uint32_t fail_value);
+
+ uint64_t GetHexMaxU64(bool little_endian, uint64_t fail_value);
+
+ size_t GetHexBytes(llvm::MutableArrayRef<uint8_t> dest,
+ uint8_t fail_fill_value);
+
+ size_t GetHexBytesAvail(llvm::MutableArrayRef<uint8_t> dest);
+
+ uint64_t GetHexWithFixedSize(uint32_t byte_size, bool little_endian,
+ uint64_t fail_value);
+
+ size_t GetHexByteString(std::string &str);
+
+ size_t GetHexByteStringFixedLength(std::string &str, uint32_t nibble_length);
+
+ size_t GetHexByteStringTerminatedBy(std::string &str, char terminator);
+
+ const char *Peek() {
+ if (m_index < m_packet.size())
+ return m_packet.c_str() + m_index;
+ return nullptr;
+ }
+
+protected:
+ bool fail() {
+ m_index = UINT64_MAX;
+ return false;
+ }
+ //------------------------------------------------------------------
+ // For StringExtractor only
+ //------------------------------------------------------------------
+ std::string m_packet; // The string in which to extract data.
+ uint64_t m_index; // When extracting data from a packet, this index
+ // will march along as things get extracted. If set
+ // to UINT64_MAX the end of the packet data was
+ // reached when decoding information
+};
+
+#endif // utility_StringExtractor_h_
--- /dev/null
+//===--------------------- StringLexer.h -------------------------*- C++
+//-*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef utility_StringLexer_h_
+#define utility_StringLexer_h_
+
+#include <initializer_list>
+#include <list>
+#include <string>
+
+namespace lldb_utility {
+
+class StringLexer {
+public:
+ typedef std::string::size_type Position;
+ typedef std::string::size_type Size;
+
+ typedef std::string::value_type Character;
+
+ StringLexer(std::string s);
+
+ StringLexer(const StringLexer &rhs);
+
+ // These APIs are not bounds-checked. Use HasAtLeast() if you're not sure.
+ Character Peek();
+
+ bool NextIf(Character c);
+
+ std::pair<bool, Character> NextIf(std::initializer_list<Character> cs);
+
+ bool AdvanceIf(const std::string &token);
+
+ Character Next();
+
+ bool HasAtLeast(Size s);
+
+ bool HasAny(Character c);
+
+ std::string GetUnlexed();
+
+ // This will assert if there are less than s characters preceding the cursor.
+ void PutBack(Size s);
+
+ StringLexer &operator=(const StringLexer &rhs);
+
+private:
+ std::string m_data;
+ Position m_position;
+
+ void Consume();
+};
+
+} // namespace lldb_private
+
+#endif // #ifndef utility_StringLexer_h_
--- /dev/null
+//===--------------------- TaskPool.h ---------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef utility_TaskPool_h_
+#define utility_TaskPool_h_
+
+#if defined(__cplusplus) && defined(_MSC_VER) && (_HAS_EXCEPTIONS == 0)
+// Compiling MSVC libraries with _HAS_EXCEPTIONS=0, eliminates most but not all
+// calls to __uncaught_exception. Unfortunately, it does seem to eliminate
+// the delcaration of __uncaught_excpeiton. Including <eh.h> ensures that it is
+// declared. This may not be necessary after MSVC 12.
+#include <eh.h>
+#endif
+
+#if defined(_MSC_VER)
+// Due to another bug in MSVC 2013, including <future> will generate hundreds of
+// warnings in the Concurrency Runtime. This can be removed when we switch to
+// MSVC 2015
+#pragma warning(push)
+#pragma warning(disable : 4062)
+#endif
+
+#include <cassert>
+#include <cstdint>
+#include <future>
+#include <list>
+#include <queue>
+#include <thread>
+#include <vector>
+
+// Global TaskPool class for running tasks in parallel on a set of worker thread
+// created the first
+// time the task pool is used. The TaskPool provide no guarantee about the order
+// the task will be run
+// and about what tasks will run in parallel. None of the task added to the task
+// pool should block
+// on something (mutex, future, condition variable) what will be set only by the
+// completion of an
+// other task on the task pool as they may run on the same thread sequentally.
+class TaskPool {
+public:
+ // Add a new task to the task pool and return a std::future belonging to the
+ // newly created task.
+ // The caller of this function has to wait on the future for this task to
+ // complete.
+ template <typename F, typename... Args>
+ static std::future<typename std::result_of<F(Args...)>::type>
+ AddTask(F &&f, Args &&... args);
+
+ // Run all of the specified tasks on the task pool and wait until all of them
+ // are finished
+ // before returning. This method is intended to be used for small number tasks
+ // where listing
+ // them as function arguments is acceptable. For running large number of tasks
+ // you should use
+ // AddTask for each task and then call wait() on each returned future.
+ template <typename... T> static void RunTasks(T &&... tasks);
+
+private:
+ TaskPool() = delete;
+
+ template <typename... T> struct RunTaskImpl;
+
+ static void AddTaskImpl(std::function<void()> &&task_fn);
+};
+
+// Wrapper class around the global TaskPool implementation to make it possible
+// to create a set of
+// tasks and then wait for the tasks to be completed by the
+// WaitForNextCompletedTask call. This
+// class should be used when WaitForNextCompletedTask is needed because this
+// class add no other
+// extra functionality to the TaskPool class and it have a very minor
+// performance overhead.
+template <typename T> // The return type of the tasks what will be added to this
+ // task runner
+ class TaskRunner {
+public:
+ // Add a task to the task runner what will also add the task to the global
+ // TaskPool. The
+ // function doesn't return the std::future for the task because it will be
+ // supplied by the
+ // WaitForNextCompletedTask after the task is completed.
+ template <typename F, typename... Args> void AddTask(F &&f, Args &&... args);
+
+ // Wait for the next task in this task runner to finish and then return the
+ // std::future what
+ // belongs to the finished task. If there is no task in this task runner
+ // (neither pending nor
+ // comleted) then this function will return an invalid future. Usually this
+ // function should be
+ // called in a loop processing the results of the tasks until it returns an
+ // invalid std::future
+ // what means that all task in this task runner is completed.
+ std::future<T> WaitForNextCompletedTask();
+
+ // Convenience method to wait for all task in this TaskRunner to finish. Do
+ // NOT use this class
+ // just because of this method. Use TaskPool instead and wait for each
+ // std::future returned by
+ // AddTask in a loop.
+ void WaitForAllTasks();
+
+private:
+ std::list<std::future<T>> m_ready;
+ std::list<std::future<T>> m_pending;
+ std::mutex m_mutex;
+ std::condition_variable m_cv;
+};
+
+template <typename F, typename... Args>
+std::future<typename std::result_of<F(Args...)>::type>
+TaskPool::AddTask(F &&f, Args &&... args) {
+ auto task_sp = std::make_shared<
+ std::packaged_task<typename std::result_of<F(Args...)>::type()>>(
+ std::bind(std::forward<F>(f), std::forward<Args>(args)...));
+
+ AddTaskImpl([task_sp]() { (*task_sp)(); });
+
+ return task_sp->get_future();
+}
+
+template <typename... T> void TaskPool::RunTasks(T &&... tasks) {
+ RunTaskImpl<T...>::Run(std::forward<T>(tasks)...);
+}
+
+template <typename Head, typename... Tail>
+struct TaskPool::RunTaskImpl<Head, Tail...> {
+ static void Run(Head &&h, Tail &&... t) {
+ auto f = AddTask(std::forward<Head>(h));
+ RunTaskImpl<Tail...>::Run(std::forward<Tail>(t)...);
+ f.wait();
+ }
+};
+
+template <> struct TaskPool::RunTaskImpl<> {
+ static void Run() {}
+};
+
+template <typename T>
+template <typename F, typename... Args>
+void TaskRunner<T>::AddTask(F &&f, Args &&... args) {
+ std::unique_lock<std::mutex> lock(m_mutex);
+ auto it = m_pending.emplace(m_pending.end());
+ *it = std::move(TaskPool::AddTask(
+ [this, it](F f, Args... args) {
+ T &&r = f(std::forward<Args>(args)...);
+
+ std::unique_lock<std::mutex> lock(this->m_mutex);
+ this->m_ready.splice(this->m_ready.end(), this->m_pending, it);
+ lock.unlock();
+
+ this->m_cv.notify_one();
+ return r;
+ },
+ std::forward<F>(f), std::forward<Args>(args)...));
+}
+
+template <>
+template <typename F, typename... Args>
+void TaskRunner<void>::AddTask(F &&f, Args &&... args) {
+ std::unique_lock<std::mutex> lock(m_mutex);
+ auto it = m_pending.emplace(m_pending.end());
+ *it = std::move(TaskPool::AddTask(
+ [this, it](F f, Args... args) {
+ f(std::forward<Args>(args)...);
+
+ std::unique_lock<std::mutex> lock(this->m_mutex);
+ this->m_ready.emplace_back(std::move(*it));
+ this->m_pending.erase(it);
+ lock.unlock();
+
+ this->m_cv.notify_one();
+ },
+ std::forward<F>(f), std::forward<Args>(args)...));
+}
+
+template <typename T> std::future<T> TaskRunner<T>::WaitForNextCompletedTask() {
+ std::unique_lock<std::mutex> lock(m_mutex);
+ if (m_ready.empty() && m_pending.empty())
+ return std::future<T>(); // No more tasks
+
+ if (m_ready.empty())
+ m_cv.wait(lock, [this]() { return !this->m_ready.empty(); });
+
+ std::future<T> res = std::move(m_ready.front());
+ m_ready.pop_front();
+
+ lock.unlock();
+ res.wait();
+
+ return std::move(res);
+}
+
+template <typename T> void TaskRunner<T>::WaitForAllTasks() {
+ while (WaitForNextCompletedTask().valid())
+ ;
+}
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+#endif // #ifndef utility_TaskPool_h_
--- /dev/null
+//===-- Timeout.h -----------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_Timeout_h_
+#define liblldb_Timeout_h_
+
+#include "llvm/ADT/Optional.h"
+#include <chrono>
+
+namespace lldb_private {
+
+// A general purpose class for representing timeouts for various APIs. It's
+// basically an llvm::Optional<std::chrono::duration<int64_t, Ratio>>, but we
+// customize it a bit to enable the standard chrono implicit conversions (e.g.
+// from Timeout<std::milli> to Timeout<std::micro>.
+//
+// The intended meaning of the values is:
+// - llvm::None - no timeout, the call should wait forever
+// - 0 - poll, only complete the call if it will not block
+// - >0 - wait for a given number of units for the result
+template <typename Ratio>
+class Timeout : public llvm::Optional<std::chrono::duration<int64_t, Ratio>> {
+private:
+ template <typename Ratio2> using Dur = std::chrono::duration<int64_t, Ratio2>;
+ template <typename Rep2, typename Ratio2>
+ using EnableIf = std::enable_if<
+ std::is_convertible<std::chrono::duration<Rep2, Ratio2>,
+ std::chrono::duration<int64_t, Ratio>>::value>;
+
+ using Base = llvm::Optional<Dur<Ratio>>;
+
+public:
+ Timeout(llvm::NoneType none) : Base(none) {}
+ Timeout(const Timeout &other) = default;
+
+ template <typename Ratio2,
+ typename = typename EnableIf<int64_t, Ratio2>::type>
+ Timeout(const Timeout<Ratio2> &other)
+ : Base(other ? Base(Dur<Ratio>(*other)) : llvm::None) {}
+
+ template <typename Rep2, typename Ratio2,
+ typename = typename EnableIf<Rep2, Ratio2>::type>
+ Timeout(const std::chrono::duration<Rep2, Ratio2> &other)
+ : Base(Dur<Ratio>(other)) {}
+};
+
+} // namespace lldb_private
+
+#endif // liblldb_Timeout_h_
--- /dev/null
+//===-- Utils.h -------------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef utility_Utils_h_
+#define utility_Utils_h_
+
+// These utilities have llvm namespace.
+#include "llvm/ADT/STLExtras.h"
+
+namespace lldb_private {
+
+// Add lldb utilities here.
+
+} // namespace lldb_private
+
+#endif // utility_Utils
--- /dev/null
+//===-- lldb-defines.h ------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_lldb_defines_h_
+#define LLDB_lldb_defines_h_
+
+#include "lldb/lldb-types.h"
+
+#if defined(_MSC_VER)
+#if defined(EXPORT_LIBLLDB)
+#define LLDB_API __declspec(dllexport)
+#elif defined(IMPORT_LIBLLDB)
+#define LLDB_API __declspec(dllimport)
+#else
+#define LLDB_API
+#endif
+#else // defined (_MSC_VER)
+#define LLDB_API
+#endif
+
+#if !defined(INT32_MAX)
+#define INT32_MAX 2147483647
+#endif
+
+#if !defined(UINT32_MAX)
+#define UINT32_MAX 4294967295U
+#endif
+
+#if !defined(UINT64_MAX)
+#define UINT64_MAX 18446744073709551615ULL
+#endif
+
+//----------------------------------------------------------------------
+// LLDB version
+//
+// A build script phase can modify this version number if needed.
+//----------------------------------------------------------------------
+//#define LLDB_VERSION
+//#define LLDB_REVISION
+//#define LLDB_VERSION_STRING
+
+//----------------------------------------------------------------------
+// LLDB defines
+//----------------------------------------------------------------------
+#define LLDB_GENERIC_ERROR UINT32_MAX
+
+//----------------------------------------------------------------------
+// Breakpoints
+//----------------------------------------------------------------------
+#define LLDB_INVALID_BREAK_ID 0
+#define LLDB_DEFAULT_BREAK_SIZE 0
+#define LLDB_BREAK_ID_IS_VALID(bid) ((bid) != (LLDB_INVALID_BREAK_ID))
+#define LLDB_BREAK_ID_IS_INTERNAL(bid) ((bid) < 0)
+
+//----------------------------------------------------------------------
+// Watchpoints
+//----------------------------------------------------------------------
+#define LLDB_INVALID_WATCH_ID 0
+#define LLDB_WATCH_ID_IS_VALID(uid) ((uid) != (LLDB_INVALID_WATCH_ID))
+#define LLDB_WATCH_TYPE_READ (1u << 0)
+#define LLDB_WATCH_TYPE_WRITE (1u << 1)
+#define LLDB_WATCH_TYPE_IS_VALID(type) \
+ ((type | LLDB_WATCH_TYPE_READ) || (type | LLDB_WATCH_TYPE_WRITE))
+
+//----------------------------------------------------------------------
+// Generic Register Numbers
+//----------------------------------------------------------------------
+#define LLDB_REGNUM_GENERIC_PC 0 // Program Counter
+#define LLDB_REGNUM_GENERIC_SP 1 // Stack Pointer
+#define LLDB_REGNUM_GENERIC_FP 2 // Frame Pointer
+#define LLDB_REGNUM_GENERIC_RA 3 // Return Address
+#define LLDB_REGNUM_GENERIC_FLAGS 4 // Processor flags register
+#define LLDB_REGNUM_GENERIC_ARG1 \
+ 5 // The register that would contain pointer size or less argument 1 (if any)
+#define LLDB_REGNUM_GENERIC_ARG2 \
+ 6 // The register that would contain pointer size or less argument 2 (if any)
+#define LLDB_REGNUM_GENERIC_ARG3 \
+ 7 // The register that would contain pointer size or less argument 3 (if any)
+#define LLDB_REGNUM_GENERIC_ARG4 \
+ 8 // The register that would contain pointer size or less argument 4 (if any)
+#define LLDB_REGNUM_GENERIC_ARG5 \
+ 9 // The register that would contain pointer size or less argument 5 (if any)
+#define LLDB_REGNUM_GENERIC_ARG6 \
+ 10 // The register that would contain pointer size or less argument 6 (if any)
+#define LLDB_REGNUM_GENERIC_ARG7 \
+ 11 // The register that would contain pointer size or less argument 7 (if any)
+#define LLDB_REGNUM_GENERIC_ARG8 \
+ 12 // The register that would contain pointer size or less argument 8 (if any)
+//---------------------------------------------------------------------
+/// Invalid value definitions
+//----------------------------------------------------------------------
+#define LLDB_INVALID_ADDRESS UINT64_MAX
+#define LLDB_INVALID_INDEX32 UINT32_MAX
+#define LLDB_INVALID_IVAR_OFFSET UINT32_MAX
+#define LLDB_INVALID_IMAGE_TOKEN UINT32_MAX
+#define LLDB_INVALID_MODULE_VERSION UINT32_MAX
+#define LLDB_INVALID_REGNUM UINT32_MAX
+#define LLDB_INVALID_UID UINT64_MAX
+#define LLDB_INVALID_PROCESS_ID 0
+#define LLDB_INVALID_THREAD_ID 0
+#define LLDB_INVALID_FRAME_ID UINT32_MAX
+#define LLDB_INVALID_SIGNAL_NUMBER INT32_MAX
+#define LLDB_INVALID_OFFSET UINT64_MAX // Must match max of lldb::offset_t
+#define LLDB_INVALID_LINE_NUMBER UINT32_MAX
+#define LLDB_INVALID_QUEUE_ID 0
+
+//----------------------------------------------------------------------
+/// CPU Type definitions
+//----------------------------------------------------------------------
+#define LLDB_ARCH_DEFAULT "systemArch"
+#define LLDB_ARCH_DEFAULT_32BIT "systemArch32"
+#define LLDB_ARCH_DEFAULT_64BIT "systemArch64"
+#define LLDB_INVALID_CPUTYPE (0xFFFFFFFEu)
+
+//----------------------------------------------------------------------
+/// Option Set definitions
+//----------------------------------------------------------------------
+// FIXME: I'm sure there's some #define magic that can create all 32 sets on the
+// fly. That would have the added benefit of making this unreadable.
+#define LLDB_MAX_NUM_OPTION_SETS 32
+#define LLDB_OPT_SET_ALL 0xFFFFFFFFU
+#define LLDB_OPT_SET_1 (1U << 0)
+#define LLDB_OPT_SET_2 (1U << 1)
+#define LLDB_OPT_SET_3 (1U << 2)
+#define LLDB_OPT_SET_4 (1U << 3)
+#define LLDB_OPT_SET_5 (1U << 4)
+#define LLDB_OPT_SET_6 (1U << 5)
+#define LLDB_OPT_SET_7 (1U << 6)
+#define LLDB_OPT_SET_8 (1U << 7)
+#define LLDB_OPT_SET_9 (1U << 8)
+#define LLDB_OPT_SET_10 (1U << 9)
+#define LLDB_OPT_SET_FROM_TO(A, B) \
+ (((1U << (B)) - 1) ^ (((1U << (A)) - 1) >> 1))
+
+#if defined(_WIN32) && !defined(MAX_PATH)
+#define MAX_PATH 260
+#endif
+
+// ignore GCC function attributes
+#if defined(_MSC_VER) && !defined(__clang__)
+#define __attribute__(X)
+#endif
+
+#define UNUSED_IF_ASSERT_DISABLED(x) ((void)(x))
+
+#if defined(__cplusplus)
+
+//----------------------------------------------------------------------
+/// @def DISALLOW_COPY_AND_ASSIGN(TypeName)
+/// Macro definition for easily disallowing copy constructor and
+/// assignment operators in C++ classes.
+//----------------------------------------------------------------------
+#define DISALLOW_COPY_AND_ASSIGN(TypeName) \
+ TypeName(const TypeName &) = delete; \
+ const TypeName &operator=(const TypeName &) = delete
+
+#endif // #if defined(__cplusplus)
+
+#endif // LLDB_lldb_defines_h_
--- /dev/null
+//===-- lldb-enumerations.h -------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_lldb_enumerations_h_
+#define LLDB_lldb_enumerations_h_
+
+#ifndef SWIG
+// With MSVC, the default type of an enum is always signed, even if one of the
+// enumerator values is too large to fit into a signed integer but would
+// otherwise fit into an unsigned integer. As a result of this, all of LLDB's
+// flag-style enumerations that specify something like eValueFoo = 1u << 31
+// result in negative values. This usually just results in a benign warning,
+// but in a few places we actually do comparisons on the enum values, which
+// would cause a real bug. Furthermore, there's no way to silence only this
+// warning, as it's part of -Wmicrosoft which also catches a whole slew of
+// other useful issues.
+//
+// To make matters worse, early versions of SWIG don't recognize the syntax
+// of specifying the underlying type of an enum (and Python doesn't care anyway)
+// so we need a way to specify the underlying type when the enum is being used
+// from C++ code, but just use a regular enum when swig is pre-processing.
+#define FLAGS_ENUM(Name) enum Name : unsigned
+#define FLAGS_ANONYMOUS_ENUM() enum : unsigned
+#else
+#define FLAGS_ENUM(Name) enum Name
+#define FLAGS_ANONYMOUS_ENUM() enum
+#endif
+
+namespace lldb {
+
+//----------------------------------------------------------------------
+// Process and Thread States
+//----------------------------------------------------------------------
+enum StateType {
+ eStateInvalid = 0,
+ eStateUnloaded, ///< Process is object is valid, but not currently loaded
+ eStateConnected, ///< Process is connected to remote debug services, but not
+ ///launched or attached to anything yet
+ eStateAttaching, ///< Process is currently trying to attach
+ eStateLaunching, ///< Process is in the process of launching
+ eStateStopped, ///< Process or thread is stopped and can be examined.
+ eStateRunning, ///< Process or thread is running and can't be examined.
+ eStateStepping, ///< Process or thread is in the process of stepping and can
+ ///not be examined.
+ eStateCrashed, ///< Process or thread has crashed and can be examined.
+ eStateDetached, ///< Process has been detached and can't be examined.
+ eStateExited, ///< Process has exited and can't be examined.
+ eStateSuspended ///< Process or thread is in a suspended state as far
+ ///< as the debugger is concerned while other processes
+ ///< or threads get the chance to run.
+};
+
+//----------------------------------------------------------------------
+// Launch Flags
+//----------------------------------------------------------------------
+FLAGS_ENUM(LaunchFlags){
+ eLaunchFlagNone = 0u,
+ eLaunchFlagExec = (1u << 0), ///< Exec when launching and turn the calling
+ ///process into a new process
+ eLaunchFlagDebug = (1u << 1), ///< Stop as soon as the process launches to
+ ///allow the process to be debugged
+ eLaunchFlagStopAtEntry = (1u << 2), ///< Stop at the program entry point
+ ///instead of auto-continuing when
+ ///launching or attaching at entry point
+ eLaunchFlagDisableASLR =
+ (1u << 3), ///< Disable Address Space Layout Randomization
+ eLaunchFlagDisableSTDIO =
+ (1u << 4), ///< Disable stdio for inferior process (e.g. for a GUI app)
+ eLaunchFlagLaunchInTTY =
+ (1u << 5), ///< Launch the process in a new TTY if supported by the host
+ eLaunchFlagLaunchInShell =
+ (1u << 6), ///< Launch the process inside a shell to get shell expansion
+ eLaunchFlagLaunchInSeparateProcessGroup =
+ (1u << 7), ///< Launch the process in a separate process group
+ eLaunchFlagDontSetExitStatus = (1u << 8), ///< If you are going to hand the
+ ///process off (e.g. to
+ ///debugserver)
+ ///< set this flag so lldb & the handee don't race to set its exit status.
+ eLaunchFlagDetachOnError = (1u << 9), ///< If set, then the client stub
+ ///should detach rather than killing
+ ///the debugee
+ ///< if it loses connection with lldb.
+ eLaunchFlagShellExpandArguments =
+ (1u << 10), ///< Perform shell-style argument expansion
+ eLaunchFlagCloseTTYOnExit = (1u << 11), ///< Close the open TTY on exit
+};
+
+//----------------------------------------------------------------------
+// Thread Run Modes
+//----------------------------------------------------------------------
+enum RunMode { eOnlyThisThread, eAllThreads, eOnlyDuringStepping };
+
+//----------------------------------------------------------------------
+// Byte ordering definitions
+//----------------------------------------------------------------------
+enum ByteOrder {
+ eByteOrderInvalid = 0,
+ eByteOrderBig = 1,
+ eByteOrderPDP = 2,
+ eByteOrderLittle = 4
+};
+
+//----------------------------------------------------------------------
+// Register encoding definitions
+//----------------------------------------------------------------------
+enum Encoding {
+ eEncodingInvalid = 0,
+ eEncodingUint, // unsigned integer
+ eEncodingSint, // signed integer
+ eEncodingIEEE754, // float
+ eEncodingVector // vector registers
+};
+
+//----------------------------------------------------------------------
+// Display format definitions
+//----------------------------------------------------------------------
+enum Format {
+ eFormatDefault = 0,
+ eFormatInvalid = 0,
+ eFormatBoolean,
+ eFormatBinary,
+ eFormatBytes,
+ eFormatBytesWithASCII,
+ eFormatChar,
+ eFormatCharPrintable, // Only printable characters, space if not printable
+ eFormatComplex, // Floating point complex type
+ eFormatComplexFloat = eFormatComplex,
+ eFormatCString, // NULL terminated C strings
+ eFormatDecimal,
+ eFormatEnum,
+ eFormatHex,
+ eFormatHexUppercase,
+ eFormatFloat,
+ eFormatOctal,
+ eFormatOSType, // OS character codes encoded into an integer 'PICT' 'text'
+ // etc...
+ eFormatUnicode16,
+ eFormatUnicode32,
+ eFormatUnsigned,
+ eFormatPointer,
+ eFormatVectorOfChar,
+ eFormatVectorOfSInt8,
+ eFormatVectorOfUInt8,
+ eFormatVectorOfSInt16,
+ eFormatVectorOfUInt16,
+ eFormatVectorOfSInt32,
+ eFormatVectorOfUInt32,
+ eFormatVectorOfSInt64,
+ eFormatVectorOfUInt64,
+ eFormatVectorOfFloat16,
+ eFormatVectorOfFloat32,
+ eFormatVectorOfFloat64,
+ eFormatVectorOfUInt128,
+ eFormatComplexInteger, // Integer complex type
+ eFormatCharArray, // Print characters with no single quotes, used for
+ // character arrays that can contain non printable
+ // characters
+ eFormatAddressInfo, // Describe what an address points to (func + offset with
+ // file/line, symbol + offset, data, etc)
+ eFormatHexFloat, // ISO C99 hex float string
+ eFormatInstruction, // Disassemble an opcode
+ eFormatVoid, // Do not print this
+ kNumFormats
+};
+
+//----------------------------------------------------------------------
+// Description levels for "void GetDescription(Stream *, DescriptionLevel)"
+// calls
+//----------------------------------------------------------------------
+enum DescriptionLevel {
+ eDescriptionLevelBrief = 0,
+ eDescriptionLevelFull,
+ eDescriptionLevelVerbose,
+ eDescriptionLevelInitial,
+ kNumDescriptionLevels
+};
+
+//----------------------------------------------------------------------
+// Script interpreter types
+//----------------------------------------------------------------------
+enum ScriptLanguage {
+ eScriptLanguageNone,
+ eScriptLanguagePython,
+ eScriptLanguageDefault = eScriptLanguagePython,
+ eScriptLanguageUnknown
+};
+
+//----------------------------------------------------------------------
+// Register numbering types
+// See RegisterContext::ConvertRegisterKindToRegisterNumber to convert
+// any of these to the lldb internal register numbering scheme
+// (eRegisterKindLLDB).
+//----------------------------------------------------------------------
+enum RegisterKind {
+ eRegisterKindEHFrame = 0, // the register numbers seen in eh_frame
+ eRegisterKindDWARF, // the register numbers seen DWARF
+ eRegisterKindGeneric, // insn ptr reg, stack ptr reg, etc not specific to any
+ // particular target
+ eRegisterKindProcessPlugin, // num used by the process plugin - e.g. by the
+ // remote gdb-protocol stub program
+ eRegisterKindLLDB, // lldb's internal register numbers
+ kNumRegisterKinds
+};
+
+//----------------------------------------------------------------------
+// Thread stop reasons
+//----------------------------------------------------------------------
+enum StopReason {
+ eStopReasonInvalid = 0,
+ eStopReasonNone,
+ eStopReasonTrace,
+ eStopReasonBreakpoint,
+ eStopReasonWatchpoint,
+ eStopReasonSignal,
+ eStopReasonException,
+ eStopReasonExec, // Program was re-exec'ed
+ eStopReasonPlanComplete,
+ eStopReasonThreadExiting,
+ eStopReasonInstrumentation
+};
+
+//----------------------------------------------------------------------
+// Command Return Status Types
+//----------------------------------------------------------------------
+enum ReturnStatus {
+ eReturnStatusInvalid,
+ eReturnStatusSuccessFinishNoResult,
+ eReturnStatusSuccessFinishResult,
+ eReturnStatusSuccessContinuingNoResult,
+ eReturnStatusSuccessContinuingResult,
+ eReturnStatusStarted,
+ eReturnStatusFailed,
+ eReturnStatusQuit
+};
+
+//----------------------------------------------------------------------
+// The results of expression evaluation:
+//----------------------------------------------------------------------
+enum ExpressionResults {
+ eExpressionCompleted = 0,
+ eExpressionSetupError,
+ eExpressionParseError,
+ eExpressionDiscarded,
+ eExpressionInterrupted,
+ eExpressionHitBreakpoint,
+ eExpressionTimedOut,
+ eExpressionResultUnavailable,
+ eExpressionStoppedForDebug
+};
+
+//----------------------------------------------------------------------
+// Connection Status Types
+//----------------------------------------------------------------------
+enum ConnectionStatus {
+ eConnectionStatusSuccess, // Success
+ eConnectionStatusEndOfFile, // End-of-file encountered
+ eConnectionStatusError, // Check GetError() for details
+ eConnectionStatusTimedOut, // Request timed out
+ eConnectionStatusNoConnection, // No connection
+ eConnectionStatusLostConnection, // Lost connection while connected to a valid
+ // connection
+ eConnectionStatusInterrupted // Interrupted read
+};
+
+enum ErrorType {
+ eErrorTypeInvalid,
+ eErrorTypeGeneric, ///< Generic errors that can be any value.
+ eErrorTypeMachKernel, ///< Mach kernel error codes.
+ eErrorTypePOSIX, ///< POSIX error codes.
+ eErrorTypeExpression, ///< These are from the ExpressionResults enum.
+ eErrorTypeWin32 ///< Standard Win32 error codes.
+};
+
+enum ValueType {
+ eValueTypeInvalid = 0,
+ eValueTypeVariableGlobal = 1, // globals variable
+ eValueTypeVariableStatic = 2, // static variable
+ eValueTypeVariableArgument = 3, // function argument variables
+ eValueTypeVariableLocal = 4, // function local variables
+ eValueTypeRegister = 5, // stack frame register value
+ eValueTypeRegisterSet = 6, // A collection of stack frame register values
+ eValueTypeConstResult = 7, // constant result variables
+ eValueTypeVariableThreadLocal = 8 // thread local storage variable
+};
+
+//----------------------------------------------------------------------
+// Token size/granularities for Input Readers
+//----------------------------------------------------------------------
+
+enum InputReaderGranularity {
+ eInputReaderGranularityInvalid = 0,
+ eInputReaderGranularityByte,
+ eInputReaderGranularityWord,
+ eInputReaderGranularityLine,
+ eInputReaderGranularityAll
+};
+
+//------------------------------------------------------------------
+/// These mask bits allow a common interface for queries that can
+/// limit the amount of information that gets parsed to only the
+/// information that is requested. These bits also can indicate what
+/// actually did get resolved during query function calls.
+///
+/// Each definition corresponds to a one of the member variables
+/// in this class, and requests that that item be resolved, or
+/// indicates that the member did get resolved.
+//------------------------------------------------------------------
+FLAGS_ENUM(SymbolContextItem){
+ eSymbolContextTarget = (1u << 0), ///< Set when \a target is requested from
+ ///a query, or was located in query
+ ///results
+ eSymbolContextModule = (1u << 1), ///< Set when \a module is requested from
+ ///a query, or was located in query
+ ///results
+ eSymbolContextCompUnit = (1u << 2), ///< Set when \a comp_unit is requested
+ ///from a query, or was located in query
+ ///results
+ eSymbolContextFunction = (1u << 3), ///< Set when \a function is requested
+ ///from a query, or was located in query
+ ///results
+ eSymbolContextBlock = (1u << 4), ///< Set when the deepest \a block is
+ ///requested from a query, or was located
+ ///in query results
+ eSymbolContextLineEntry = (1u << 5), ///< Set when \a line_entry is
+ ///requested from a query, or was
+ ///located in query results
+ eSymbolContextSymbol = (1u << 6), ///< Set when \a symbol is requested from
+ ///a query, or was located in query
+ ///results
+ eSymbolContextEverything = ((eSymbolContextSymbol << 1) -
+ 1u), ///< Indicates to try and lookup everything
+ ///up during a routine symbol context
+ ///query.
+ eSymbolContextVariable = (1u << 7) ///< Set when \a global or static
+ ///variable is requested from a query, or
+ ///was located in query results.
+ ///< eSymbolContextVariable is potentially expensive to lookup so it isn't
+ ///included in
+ ///< eSymbolContextEverything which stops it from being used during frame PC
+ ///lookups and
+ ///< many other potential address to symbol context lookups.
+};
+
+FLAGS_ENUM(Permissions){ePermissionsWritable = (1u << 0),
+ ePermissionsReadable = (1u << 1),
+ ePermissionsExecutable = (1u << 2)};
+
+enum InputReaderAction {
+ eInputReaderActivate, // reader is newly pushed onto the reader stack
+ eInputReaderAsynchronousOutputWritten, // an async output event occurred; the
+ // reader may want to do something
+ eInputReaderReactivate, // reader is on top of the stack again after another
+ // reader was popped off
+ eInputReaderDeactivate, // another reader was pushed on the stack
+ eInputReaderGotToken, // reader got one of its tokens (granularity)
+ eInputReaderInterrupt, // reader received an interrupt signal (probably from a
+ // control-c)
+ eInputReaderEndOfFile, // reader received an EOF char (probably from a
+ // control-d)
+ eInputReaderDone // reader was just popped off the stack and is done
+};
+
+FLAGS_ENUM(BreakpointEventType){
+ eBreakpointEventTypeInvalidType = (1u << 0),
+ eBreakpointEventTypeAdded = (1u << 1),
+ eBreakpointEventTypeRemoved = (1u << 2),
+ eBreakpointEventTypeLocationsAdded = (1u << 3), // Locations added doesn't
+ // get sent when the
+ // breakpoint is created
+ eBreakpointEventTypeLocationsRemoved = (1u << 4),
+ eBreakpointEventTypeLocationsResolved = (1u << 5),
+ eBreakpointEventTypeEnabled = (1u << 6),
+ eBreakpointEventTypeDisabled = (1u << 7),
+ eBreakpointEventTypeCommandChanged = (1u << 8),
+ eBreakpointEventTypeConditionChanged = (1u << 9),
+ eBreakpointEventTypeIgnoreChanged = (1u << 10),
+ eBreakpointEventTypeThreadChanged = (1u << 11)};
+
+FLAGS_ENUM(WatchpointEventType){
+ eWatchpointEventTypeInvalidType = (1u << 0),
+ eWatchpointEventTypeAdded = (1u << 1),
+ eWatchpointEventTypeRemoved = (1u << 2),
+ eWatchpointEventTypeEnabled = (1u << 6),
+ eWatchpointEventTypeDisabled = (1u << 7),
+ eWatchpointEventTypeCommandChanged = (1u << 8),
+ eWatchpointEventTypeConditionChanged = (1u << 9),
+ eWatchpointEventTypeIgnoreChanged = (1u << 10),
+ eWatchpointEventTypeThreadChanged = (1u << 11),
+ eWatchpointEventTypeTypeChanged = (1u << 12)};
+
+//----------------------------------------------------------------------
+/// Programming language type.
+///
+/// These enumerations use the same language enumerations as the DWARF
+/// specification for ease of use and consistency.
+/// The enum -> string code is in Language.cpp, don't change this
+/// table without updating that code as well.
+//----------------------------------------------------------------------
+enum LanguageType {
+ eLanguageTypeUnknown = 0x0000, ///< Unknown or invalid language value.
+ eLanguageTypeC89 = 0x0001, ///< ISO C:1989.
+ eLanguageTypeC = 0x0002, ///< Non-standardized C, such as K&R.
+ eLanguageTypeAda83 = 0x0003, ///< ISO Ada:1983.
+ eLanguageTypeC_plus_plus = 0x0004, ///< ISO C++:1998.
+ eLanguageTypeCobol74 = 0x0005, ///< ISO Cobol:1974.
+ eLanguageTypeCobol85 = 0x0006, ///< ISO Cobol:1985.
+ eLanguageTypeFortran77 = 0x0007, ///< ISO Fortran 77.
+ eLanguageTypeFortran90 = 0x0008, ///< ISO Fortran 90.
+ eLanguageTypePascal83 = 0x0009, ///< ISO Pascal:1983.
+ eLanguageTypeModula2 = 0x000a, ///< ISO Modula-2:1996.
+ eLanguageTypeJava = 0x000b, ///< Java.
+ eLanguageTypeC99 = 0x000c, ///< ISO C:1999.
+ eLanguageTypeAda95 = 0x000d, ///< ISO Ada:1995.
+ eLanguageTypeFortran95 = 0x000e, ///< ISO Fortran 95.
+ eLanguageTypePLI = 0x000f, ///< ANSI PL/I:1976.
+ eLanguageTypeObjC = 0x0010, ///< Objective-C.
+ eLanguageTypeObjC_plus_plus = 0x0011, ///< Objective-C++.
+ eLanguageTypeUPC = 0x0012, ///< Unified Parallel C.
+ eLanguageTypeD = 0x0013, ///< D.
+ eLanguageTypePython = 0x0014, ///< Python.
+ // NOTE: The below are DWARF5 constants, subject to change upon
+ // completion of the DWARF5 specification
+ eLanguageTypeOpenCL = 0x0015, ///< OpenCL.
+ eLanguageTypeGo = 0x0016, ///< Go.
+ eLanguageTypeModula3 = 0x0017, ///< Modula 3.
+ eLanguageTypeHaskell = 0x0018, ///< Haskell.
+ eLanguageTypeC_plus_plus_03 = 0x0019, ///< ISO C++:2003.
+ eLanguageTypeC_plus_plus_11 = 0x001a, ///< ISO C++:2011.
+ eLanguageTypeOCaml = 0x001b, ///< OCaml.
+ eLanguageTypeRust = 0x001c, ///< Rust.
+ eLanguageTypeC11 = 0x001d, ///< ISO C:2011.
+ eLanguageTypeSwift = 0x001e, ///< Swift.
+ eLanguageTypeJulia = 0x001f, ///< Julia.
+ eLanguageTypeDylan = 0x0020, ///< Dylan.
+ eLanguageTypeC_plus_plus_14 = 0x0021, ///< ISO C++:2014.
+ eLanguageTypeFortran03 = 0x0022, ///< ISO Fortran 2003.
+ eLanguageTypeFortran08 = 0x0023, ///< ISO Fortran 2008.
+ // Vendor Extensions
+ // Note: Language::GetNameForLanguageType
+ // assumes these can be used as indexes into array language_names, and
+ // Language::SetLanguageFromCString and Language::AsCString
+ // assume these can be used as indexes into array g_languages.
+ eLanguageTypeMipsAssembler = 0x0024, ///< Mips_Assembler.
+ eLanguageTypeExtRenderScript = 0x0025, ///< RenderScript.
+ eNumLanguageTypes
+};
+
+enum InstrumentationRuntimeType {
+ eInstrumentationRuntimeTypeAddressSanitizer = 0x0000,
+ eInstrumentationRuntimeTypeThreadSanitizer = 0x0001,
+ eInstrumentationRuntimeTypeUndefinedBehaviorSanitizer = 0x0002,
+ eInstrumentationRuntimeTypeMainThreadChecker = 0x0003,
+ eInstrumentationRuntimeTypeSwiftRuntimeReporting = 0x0004,
+ eNumInstrumentationRuntimeTypes
+};
+
+enum DynamicValueType {
+ eNoDynamicValues = 0,
+ eDynamicCanRunTarget = 1,
+ eDynamicDontRunTarget = 2
+};
+
+enum StopShowColumn {
+ eStopShowColumnAnsiOrCaret = 0,
+ eStopShowColumnAnsi = 1,
+ eStopShowColumnCaret = 2,
+ eStopShowColumnNone = 3
+};
+
+enum AccessType {
+ eAccessNone,
+ eAccessPublic,
+ eAccessPrivate,
+ eAccessProtected,
+ eAccessPackage
+};
+
+enum CommandArgumentType {
+ eArgTypeAddress = 0,
+ eArgTypeAddressOrExpression,
+ eArgTypeAliasName,
+ eArgTypeAliasOptions,
+ eArgTypeArchitecture,
+ eArgTypeBoolean,
+ eArgTypeBreakpointID,
+ eArgTypeBreakpointIDRange,
+ eArgTypeBreakpointName,
+ eArgTypeByteSize,
+ eArgTypeClassName,
+ eArgTypeCommandName,
+ eArgTypeCount,
+ eArgTypeDescriptionVerbosity,
+ eArgTypeDirectoryName,
+ eArgTypeDisassemblyFlavor,
+ eArgTypeEndAddress,
+ eArgTypeExpression,
+ eArgTypeExpressionPath,
+ eArgTypeExprFormat,
+ eArgTypeFilename,
+ eArgTypeFormat,
+ eArgTypeFrameIndex,
+ eArgTypeFullName,
+ eArgTypeFunctionName,
+ eArgTypeFunctionOrSymbol,
+ eArgTypeGDBFormat,
+ eArgTypeHelpText,
+ eArgTypeIndex,
+ eArgTypeLanguage,
+ eArgTypeLineNum,
+ eArgTypeLogCategory,
+ eArgTypeLogChannel,
+ eArgTypeMethod,
+ eArgTypeName,
+ eArgTypeNewPathPrefix,
+ eArgTypeNumLines,
+ eArgTypeNumberPerLine,
+ eArgTypeOffset,
+ eArgTypeOldPathPrefix,
+ eArgTypeOneLiner,
+ eArgTypePath,
+ eArgTypePermissionsNumber,
+ eArgTypePermissionsString,
+ eArgTypePid,
+ eArgTypePlugin,
+ eArgTypeProcessName,
+ eArgTypePythonClass,
+ eArgTypePythonFunction,
+ eArgTypePythonScript,
+ eArgTypeQueueName,
+ eArgTypeRegisterName,
+ eArgTypeRegularExpression,
+ eArgTypeRunArgs,
+ eArgTypeRunMode,
+ eArgTypeScriptedCommandSynchronicity,
+ eArgTypeScriptLang,
+ eArgTypeSearchWord,
+ eArgTypeSelector,
+ eArgTypeSettingIndex,
+ eArgTypeSettingKey,
+ eArgTypeSettingPrefix,
+ eArgTypeSettingVariableName,
+ eArgTypeShlibName,
+ eArgTypeSourceFile,
+ eArgTypeSortOrder,
+ eArgTypeStartAddress,
+ eArgTypeSummaryString,
+ eArgTypeSymbol,
+ eArgTypeThreadID,
+ eArgTypeThreadIndex,
+ eArgTypeThreadName,
+ eArgTypeTypeName,
+ eArgTypeUnsignedInteger,
+ eArgTypeUnixSignal,
+ eArgTypeVarName,
+ eArgTypeValue,
+ eArgTypeWidth,
+ eArgTypeNone,
+ eArgTypePlatform,
+ eArgTypeWatchpointID,
+ eArgTypeWatchpointIDRange,
+ eArgTypeWatchType,
+ eArgRawInput,
+ eArgTypeLastArg // Always keep this entry as the last entry in this
+ // enumeration!!
+};
+
+//----------------------------------------------------------------------
+// Symbol types
+//----------------------------------------------------------------------
+enum SymbolType {
+ eSymbolTypeAny = 0,
+ eSymbolTypeInvalid = 0,
+ eSymbolTypeAbsolute,
+ eSymbolTypeCode,
+ eSymbolTypeResolver,
+ eSymbolTypeData,
+ eSymbolTypeTrampoline,
+ eSymbolTypeRuntime,
+ eSymbolTypeException,
+ eSymbolTypeSourceFile,
+ eSymbolTypeHeaderFile,
+ eSymbolTypeObjectFile,
+ eSymbolTypeCommonBlock,
+ eSymbolTypeBlock,
+ eSymbolTypeLocal,
+ eSymbolTypeParam,
+ eSymbolTypeVariable,
+ eSymbolTypeVariableType,
+ eSymbolTypeLineEntry,
+ eSymbolTypeLineHeader,
+ eSymbolTypeScopeBegin,
+ eSymbolTypeScopeEnd,
+ eSymbolTypeAdditional, // When symbols take more than one entry, the extra
+ // entries get this type
+ eSymbolTypeCompiler,
+ eSymbolTypeInstrumentation,
+ eSymbolTypeUndefined,
+ eSymbolTypeObjCClass,
+ eSymbolTypeObjCMetaClass,
+ eSymbolTypeObjCIVar,
+ eSymbolTypeIVarOffset, // A symbol that contains an offset for an instance
+ // variable
+ eSymbolTypeReExported,
+ eSymbolTypeMetadata, // A symbol that contains the location of a direct
+ // metadata for a type
+ eSymbolTypeASTFile // A symbol whose name is the path to a compiler AST file
+};
+
+enum SectionType {
+ eSectionTypeInvalid,
+ eSectionTypeCode,
+ eSectionTypeContainer, // The section contains child sections
+ eSectionTypeData,
+ eSectionTypeDataCString, // Inlined C string data
+ eSectionTypeDataCStringPointers, // Pointers to C string data
+ eSectionTypeDataSymbolAddress, // Address of a symbol in the symbol table
+ eSectionTypeData4,
+ eSectionTypeData8,
+ eSectionTypeData16,
+ eSectionTypeDataPointers,
+ eSectionTypeDebug,
+ eSectionTypeZeroFill,
+ eSectionTypeDataObjCMessageRefs, // Pointer to function pointer + selector
+ eSectionTypeDataObjCCFStrings, // Objective C const CFString/NSString objects
+ eSectionTypeDWARFDebugAbbrev,
+ eSectionTypeDWARFDebugAddr,
+ eSectionTypeDWARFDebugAranges,
+ eSectionTypeDWARFDebugFrame,
+ eSectionTypeDWARFDebugInfo,
+ eSectionTypeDWARFDebugLine,
+ eSectionTypeDWARFDebugLoc,
+ eSectionTypeDWARFDebugMacInfo,
+ eSectionTypeDWARFDebugMacro,
+ eSectionTypeDWARFDebugPubNames,
+ eSectionTypeDWARFDebugPubTypes,
+ eSectionTypeDWARFDebugRanges,
+ eSectionTypeDWARFDebugStr,
+ eSectionTypeDWARFDebugStrOffsets,
+ eSectionTypeDWARFAppleNames,
+ eSectionTypeDWARFAppleTypes,
+ eSectionTypeDWARFAppleExternalTypes,
+ eSectionTypeDWARFAppleNamespaces,
+ eSectionTypeDWARFAppleObjC,
+ eSectionTypeELFSymbolTable, // Elf SHT_SYMTAB section
+ eSectionTypeELFDynamicSymbols, // Elf SHT_DYNSYM section
+ eSectionTypeELFRelocationEntries, // Elf SHT_REL or SHT_REL section
+ eSectionTypeELFDynamicLinkInfo, // Elf SHT_DYNAMIC section
+ eSectionTypeEHFrame,
+ eSectionTypeSwiftModules,
+ eSectionTypeARMexidx,
+ eSectionTypeARMextab,
+ eSectionTypeCompactUnwind, // compact unwind section in Mach-O,
+ // __TEXT,__unwind_info
+ eSectionTypeGoSymtab,
+ eSectionTypeAbsoluteAddress, // Dummy section for symbols with absolute
+ // address
+ eSectionTypeOther
+};
+
+FLAGS_ENUM(EmulateInstructionOptions){
+ eEmulateInstructionOptionNone = (0u),
+ eEmulateInstructionOptionAutoAdvancePC = (1u << 0),
+ eEmulateInstructionOptionIgnoreConditions = (1u << 1)};
+
+FLAGS_ENUM(FunctionNameType){
+ eFunctionNameTypeNone = 0u,
+ eFunctionNameTypeAuto =
+ (1u << 1), // Automatically figure out which FunctionNameType
+ // bits to set based on the function name.
+ eFunctionNameTypeFull = (1u << 2), // The function name.
+ // For C this is the same as just the name of the function
+ // For C++ this is the mangled or demangled version of the mangled name.
+ // For ObjC this is the full function signature with the + or
+ // - and the square brackets and the class and selector
+ eFunctionNameTypeBase = (1u << 3), // The function name only, no namespaces
+ // or arguments and no class
+ // methods or selectors will be searched.
+ eFunctionNameTypeMethod = (1u << 4), // Find function by method name (C++)
+ // with no namespace or arguments
+ eFunctionNameTypeSelector =
+ (1u << 5), // Find function by selector name (ObjC) names
+ eFunctionNameTypeAny =
+ eFunctionNameTypeAuto // DEPRECATED: use eFunctionNameTypeAuto
+};
+
+//----------------------------------------------------------------------
+// Basic types enumeration for the public API SBType::GetBasicType()
+//----------------------------------------------------------------------
+enum BasicType {
+ eBasicTypeInvalid = 0,
+ eBasicTypeVoid = 1,
+ eBasicTypeChar,
+ eBasicTypeSignedChar,
+ eBasicTypeUnsignedChar,
+ eBasicTypeWChar,
+ eBasicTypeSignedWChar,
+ eBasicTypeUnsignedWChar,
+ eBasicTypeChar16,
+ eBasicTypeChar32,
+ eBasicTypeShort,
+ eBasicTypeUnsignedShort,
+ eBasicTypeInt,
+ eBasicTypeUnsignedInt,
+ eBasicTypeLong,
+ eBasicTypeUnsignedLong,
+ eBasicTypeLongLong,
+ eBasicTypeUnsignedLongLong,
+ eBasicTypeInt128,
+ eBasicTypeUnsignedInt128,
+ eBasicTypeBool,
+ eBasicTypeHalf,
+ eBasicTypeFloat,
+ eBasicTypeDouble,
+ eBasicTypeLongDouble,
+ eBasicTypeFloatComplex,
+ eBasicTypeDoubleComplex,
+ eBasicTypeLongDoubleComplex,
+ eBasicTypeObjCID,
+ eBasicTypeObjCClass,
+ eBasicTypeObjCSel,
+ eBasicTypeNullPtr,
+ eBasicTypeOther
+};
+
+FLAGS_ENUM(TypeClass){
+ eTypeClassInvalid = (0u),
+ eTypeClassArray = (1u << 0),
+ eTypeClassBlockPointer = (1u << 1), eTypeClassBuiltin = (1u << 2),
+ eTypeClassClass = (1u << 3), eTypeClassComplexFloat = (1u << 4),
+ eTypeClassComplexInteger = (1u << 5), eTypeClassEnumeration = (1u << 6),
+ eTypeClassFunction = (1u << 7), eTypeClassMemberPointer = (1u << 8),
+ eTypeClassObjCObject = (1u << 9), eTypeClassObjCInterface = (1u << 10),
+ eTypeClassObjCObjectPointer = (1u << 11), eTypeClassPointer = (1u << 12),
+ eTypeClassReference = (1u << 13), eTypeClassStruct = (1u << 14),
+ eTypeClassTypedef = (1u << 15), eTypeClassUnion = (1u << 16),
+ eTypeClassVector = (1u << 17),
+ // Define the last type class as the MSBit of a 32 bit value
+ eTypeClassOther = (1u << 31),
+ // Define a mask that can be used for any type when finding types
+ eTypeClassAny = (0xffffffffu)};
+
+enum TemplateArgumentKind {
+ eTemplateArgumentKindNull = 0,
+ eTemplateArgumentKindType,
+ eTemplateArgumentKindDeclaration,
+ eTemplateArgumentKindIntegral,
+ eTemplateArgumentKindTemplate,
+ eTemplateArgumentKindTemplateExpansion,
+ eTemplateArgumentKindExpression,
+ eTemplateArgumentKindPack
+
+};
+
+//----------------------------------------------------------------------
+// Options that can be set for a formatter to alter its behavior
+// Not all of these are applicable to all formatter types
+//----------------------------------------------------------------------
+FLAGS_ENUM(TypeOptions){eTypeOptionNone = (0u),
+ eTypeOptionCascade = (1u << 0),
+ eTypeOptionSkipPointers = (1u << 1),
+ eTypeOptionSkipReferences = (1u << 2),
+ eTypeOptionHideChildren = (1u << 3),
+ eTypeOptionHideValue = (1u << 4),
+ eTypeOptionShowOneLiner = (1u << 5),
+ eTypeOptionHideNames = (1u << 6),
+ eTypeOptionNonCacheable = (1u << 7),
+ eTypeOptionHideEmptyAggregates = (1u << 8)};
+
+//----------------------------------------------------------------------
+// This is the return value for frame comparisons. If you are comparing frame A
+// to frame B
+// the following cases arise:
+// 1) When frame A pushes frame B (or a frame that ends up pushing B) A is Older
+// than B.
+// 2) When frame A pushed frame B (or if frame A is on the stack but B is not) A
+// is Younger than B
+// 3) When frame A and frame B have the same StackID, they are Equal.
+// 4) When frame A and frame B have the same immediate parent frame, but are not
+// equal, the comparison yields
+// SameParent.
+// 5) If the two frames are on different threads or processes the comparison is
+// Invalid
+// 6) If for some reason we can't figure out what went on, we return Unknown.
+//----------------------------------------------------------------------
+enum FrameComparison {
+ eFrameCompareInvalid,
+ eFrameCompareUnknown,
+ eFrameCompareEqual,
+ eFrameCompareSameParent,
+ eFrameCompareYounger,
+ eFrameCompareOlder
+};
+
+//----------------------------------------------------------------------
+// Address Class
+//
+// A way of classifying an address used for disassembling and setting
+// breakpoints. Many object files can track exactly what parts of their
+// object files are code, data and other information. This is of course
+// above and beyond just looking at the section types. For example, code
+// might contain PC relative data and the object file might be able to
+// tell us that an address in code is data.
+//----------------------------------------------------------------------
+enum AddressClass {
+ eAddressClassInvalid,
+ eAddressClassUnknown,
+ eAddressClassCode,
+ eAddressClassCodeAlternateISA,
+ eAddressClassData,
+ eAddressClassDebug,
+ eAddressClassRuntime
+};
+
+//----------------------------------------------------------------------
+// File Permissions
+//
+// Designed to mimic the unix file permission bits so they can be
+// used with functions that set 'mode_t' to certain values for
+// permissions.
+//----------------------------------------------------------------------
+FLAGS_ENUM(FilePermissions){
+ eFilePermissionsUserRead = (1u << 8), eFilePermissionsUserWrite = (1u << 7),
+ eFilePermissionsUserExecute = (1u << 6),
+ eFilePermissionsGroupRead = (1u << 5),
+ eFilePermissionsGroupWrite = (1u << 4),
+ eFilePermissionsGroupExecute = (1u << 3),
+ eFilePermissionsWorldRead = (1u << 2),
+ eFilePermissionsWorldWrite = (1u << 1),
+ eFilePermissionsWorldExecute = (1u << 0),
+
+ eFilePermissionsUserRW = (eFilePermissionsUserRead |
+ eFilePermissionsUserWrite | 0),
+ eFileFilePermissionsUserRX = (eFilePermissionsUserRead | 0 |
+ eFilePermissionsUserExecute),
+ eFilePermissionsUserRWX = (eFilePermissionsUserRead |
+ eFilePermissionsUserWrite |
+ eFilePermissionsUserExecute),
+
+ eFilePermissionsGroupRW = (eFilePermissionsGroupRead |
+ eFilePermissionsGroupWrite | 0),
+ eFilePermissionsGroupRX = (eFilePermissionsGroupRead | 0 |
+ eFilePermissionsGroupExecute),
+ eFilePermissionsGroupRWX = (eFilePermissionsGroupRead |
+ eFilePermissionsGroupWrite |
+ eFilePermissionsGroupExecute),
+
+ eFilePermissionsWorldRW = (eFilePermissionsWorldRead |
+ eFilePermissionsWorldWrite | 0),
+ eFilePermissionsWorldRX = (eFilePermissionsWorldRead | 0 |
+ eFilePermissionsWorldExecute),
+ eFilePermissionsWorldRWX = (eFilePermissionsWorldRead |
+ eFilePermissionsWorldWrite |
+ eFilePermissionsWorldExecute),
+
+ eFilePermissionsEveryoneR = (eFilePermissionsUserRead |
+ eFilePermissionsGroupRead |
+ eFilePermissionsWorldRead),
+ eFilePermissionsEveryoneW = (eFilePermissionsUserWrite |
+ eFilePermissionsGroupWrite |
+ eFilePermissionsWorldWrite),
+ eFilePermissionsEveryoneX = (eFilePermissionsUserExecute |
+ eFilePermissionsGroupExecute |
+ eFilePermissionsWorldExecute),
+
+ eFilePermissionsEveryoneRW = (eFilePermissionsEveryoneR |
+ eFilePermissionsEveryoneW | 0),
+ eFilePermissionsEveryoneRX = (eFilePermissionsEveryoneR | 0 |
+ eFilePermissionsEveryoneX),
+ eFilePermissionsEveryoneRWX = (eFilePermissionsEveryoneR |
+ eFilePermissionsEveryoneW |
+ eFilePermissionsEveryoneX),
+ eFilePermissionsFileDefault = eFilePermissionsUserRW,
+ eFilePermissionsDirectoryDefault = eFilePermissionsUserRWX,
+};
+
+//----------------------------------------------------------------------
+// Queue work item types
+//
+// The different types of work that can be enqueued on a libdispatch
+// aka Grand Central Dispatch (GCD) queue.
+//----------------------------------------------------------------------
+enum QueueItemKind {
+ eQueueItemKindUnknown = 0,
+ eQueueItemKindFunction,
+ eQueueItemKindBlock
+};
+
+//----------------------------------------------------------------------
+// Queue type
+// libdispatch aka Grand Central Dispatch (GCD) queues can be either serial
+// (executing on one thread) or concurrent (executing on multiple threads).
+//----------------------------------------------------------------------
+enum QueueKind {
+ eQueueKindUnknown = 0,
+ eQueueKindSerial,
+ eQueueKindConcurrent
+};
+
+//----------------------------------------------------------------------
+// Expression Evaluation Stages
+// These are the cancellable stages of expression evaluation, passed to the
+// expression evaluation callback, so that you can interrupt expression
+// evaluation at the various points in its lifecycle.
+//----------------------------------------------------------------------
+enum ExpressionEvaluationPhase {
+ eExpressionEvaluationParse = 0,
+ eExpressionEvaluationIRGen,
+ eExpressionEvaluationExecution,
+ eExpressionEvaluationComplete
+};
+
+//----------------------------------------------------------------------
+// Watchpoint Kind
+// Indicates what types of events cause the watchpoint to fire.
+// Used by Native*Protocol-related classes.
+//----------------------------------------------------------------------
+FLAGS_ENUM(WatchpointKind){eWatchpointKindRead = (1u << 0),
+ eWatchpointKindWrite = (1u << 1)};
+
+enum GdbSignal {
+ eGdbSignalBadAccess = 0x91,
+ eGdbSignalBadInstruction = 0x92,
+ eGdbSignalArithmetic = 0x93,
+ eGdbSignalEmulation = 0x94,
+ eGdbSignalSoftware = 0x95,
+ eGdbSignalBreakpoint = 0x96
+};
+
+//----------------------------------------------------------------------
+// Used with SBHost::GetPath (lldb::PathType) to find files that are
+// related to LLDB on the current host machine. Most files are relative
+// to LLDB or are in known locations.
+//----------------------------------------------------------------------
+enum PathType {
+ ePathTypeLLDBShlibDir, // The directory where the lldb.so (unix) or LLDB
+ // mach-o file in LLDB.framework (MacOSX) exists
+ ePathTypeSupportExecutableDir, // Find LLDB support executable directory
+ // (debugserver, etc)
+ ePathTypeSupportFileDir, // Find LLDB support file directory (non-executable
+ // files)
+ ePathTypeHeaderDir, // Find LLDB header file directory
+ ePathTypePythonDir, // Find Python modules (PYTHONPATH) directory
+ ePathTypeLLDBSystemPlugins, // System plug-ins directory
+ ePathTypeLLDBUserPlugins, // User plug-ins directory
+ ePathTypeLLDBTempSystemDir, // The LLDB temp directory for this system that
+ // will be cleaned up on exit
+ ePathTypeGlobalLLDBTempSystemDir, // The LLDB temp directory for this system,
+ // NOT cleaned up on a process exit.
+ ePathTypeClangDir, // Find path to Clang builtin headers
+ ePathTypeSwiftDir // Find path to Swift libraries
+};
+
+//----------------------------------------------------------------------
+// Kind of member function
+// Used by the type system
+//----------------------------------------------------------------------
+enum MemberFunctionKind {
+ eMemberFunctionKindUnknown = 0, // Not sure what the type of this is
+ eMemberFunctionKindConstructor, // A function used to create instances
+ eMemberFunctionKindDestructor, // A function used to tear down existing
+ // instances
+ eMemberFunctionKindInstanceMethod, // A function that applies to a specific
+ // instance
+ eMemberFunctionKindStaticMethod // A function that applies to a type rather
+ // than any instance
+};
+
+//----------------------------------------------------------------------
+// String matching algorithm used by SBTarget
+//----------------------------------------------------------------------
+enum MatchType { eMatchTypeNormal, eMatchTypeRegex, eMatchTypeStartsWith };
+
+//----------------------------------------------------------------------
+// Bitmask that describes details about a type
+//----------------------------------------------------------------------
+FLAGS_ENUM(TypeFlags){eTypeHasChildren = (1u << 0),
+ eTypeHasValue = (1u << 1),
+ eTypeIsArray = (1u << 2),
+ eTypeIsBlock = (1u << 3),
+ eTypeIsBuiltIn = (1u << 4),
+ eTypeIsClass = (1u << 5),
+ eTypeIsCPlusPlus = (1u << 6),
+ eTypeIsEnumeration = (1u << 7),
+ eTypeIsFuncPrototype = (1u << 8),
+ eTypeIsMember = (1u << 9),
+ eTypeIsObjC = (1u << 10),
+ eTypeIsPointer = (1u << 11),
+ eTypeIsReference = (1u << 12),
+ eTypeIsStructUnion = (1u << 13),
+ eTypeIsTemplate = (1u << 14),
+ eTypeIsTypedef = (1u << 15),
+ eTypeIsVector = (1u << 16),
+ eTypeIsScalar = (1u << 17),
+ eTypeIsInteger = (1u << 18),
+ eTypeIsFloat = (1u << 19),
+ eTypeIsComplex = (1u << 20),
+ eTypeIsSigned = (1u << 21),
+ eTypeInstanceIsPointer = (1u << 22),
+ eTypeIsSwift = (1u << 23),
+ eTypeIsArchetype = (1u << 24),
+ eTypeIsProtocol = (1u << 25),
+ eTypeIsTuple = (1u << 26),
+ eTypeIsMetatype = (1u << 27),
+ eTypeIsGeneric = (1u << 28),
+ eTypeIsBound = (1u << 29)};
+
+FLAGS_ENUM(CommandFlags){
+ //----------------------------------------------------------------------
+ // eCommandRequiresTarget
+ //
+ // Ensures a valid target is contained in m_exe_ctx prior to executing
+ // the command. If a target doesn't exist or is invalid, the command
+ // will fail and CommandObject::GetInvalidTargetDescription() will be
+ // returned as the error. CommandObject subclasses can override the
+ // virtual function for GetInvalidTargetDescription() to provide custom
+ // strings when needed.
+ //----------------------------------------------------------------------
+ eCommandRequiresTarget = (1u << 0),
+ //----------------------------------------------------------------------
+ // eCommandRequiresProcess
+ //
+ // Ensures a valid process is contained in m_exe_ctx prior to executing
+ // the command. If a process doesn't exist or is invalid, the command
+ // will fail and CommandObject::GetInvalidProcessDescription() will be
+ // returned as the error. CommandObject subclasses can override the
+ // virtual function for GetInvalidProcessDescription() to provide custom
+ // strings when needed.
+ //----------------------------------------------------------------------
+ eCommandRequiresProcess = (1u << 1),
+ //----------------------------------------------------------------------
+ // eCommandRequiresThread
+ //
+ // Ensures a valid thread is contained in m_exe_ctx prior to executing
+ // the command. If a thread doesn't exist or is invalid, the command
+ // will fail and CommandObject::GetInvalidThreadDescription() will be
+ // returned as the error. CommandObject subclasses can override the
+ // virtual function for GetInvalidThreadDescription() to provide custom
+ // strings when needed.
+ //----------------------------------------------------------------------
+ eCommandRequiresThread = (1u << 2),
+ //----------------------------------------------------------------------
+ // eCommandRequiresFrame
+ //
+ // Ensures a valid frame is contained in m_exe_ctx prior to executing
+ // the command. If a frame doesn't exist or is invalid, the command
+ // will fail and CommandObject::GetInvalidFrameDescription() will be
+ // returned as the error. CommandObject subclasses can override the
+ // virtual function for GetInvalidFrameDescription() to provide custom
+ // strings when needed.
+ //----------------------------------------------------------------------
+ eCommandRequiresFrame = (1u << 3),
+ //----------------------------------------------------------------------
+ // eCommandRequiresRegContext
+ //
+ // Ensures a valid register context (from the selected frame if there
+ // is a frame in m_exe_ctx, or from the selected thread from m_exe_ctx)
+ // is available from m_exe_ctx prior to executing the command. If a
+ // target doesn't exist or is invalid, the command will fail and
+ // CommandObject::GetInvalidRegContextDescription() will be returned as
+ // the error. CommandObject subclasses can override the virtual function
+ // for GetInvalidRegContextDescription() to provide custom strings when
+ // needed.
+ //----------------------------------------------------------------------
+ eCommandRequiresRegContext = (1u << 4),
+ //----------------------------------------------------------------------
+ // eCommandTryTargetAPILock
+ //
+ // Attempts to acquire the target lock if a target is selected in the
+ // command interpreter. If the command object fails to acquire the API
+ // lock, the command will fail with an appropriate error message.
+ //----------------------------------------------------------------------
+ eCommandTryTargetAPILock = (1u << 5),
+ //----------------------------------------------------------------------
+ // eCommandProcessMustBeLaunched
+ //
+ // Verifies that there is a launched process in m_exe_ctx, if there
+ // isn't, the command will fail with an appropriate error message.
+ //----------------------------------------------------------------------
+ eCommandProcessMustBeLaunched = (1u << 6),
+ //----------------------------------------------------------------------
+ // eCommandProcessMustBePaused
+ //
+ // Verifies that there is a paused process in m_exe_ctx, if there
+ // isn't, the command will fail with an appropriate error message.
+ //----------------------------------------------------------------------
+ eCommandProcessMustBePaused = (1u << 7)};
+
+//----------------------------------------------------------------------
+// Whether a summary should cap how much data it returns to users or not
+//----------------------------------------------------------------------
+enum TypeSummaryCapping {
+ eTypeSummaryCapped = true,
+ eTypeSummaryUncapped = false
+};
+
+} // namespace lldb
+
+#endif // LLDB_lldb_enumerations_h_
--- /dev/null
+//===-- lldb-forward.h ------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_lldb_forward_h_
+#define LLDB_lldb_forward_h_
+
+#if defined(__cplusplus)
+
+#include "lldb/Utility/SharingPtr.h"
+
+//----------------------------------------------------------------------
+// lldb forward declarations
+//----------------------------------------------------------------------
+namespace lldb_private {
+
+class ABI;
+class Address;
+class AddressImpl;
+class AddressRange;
+class AddressResolver;
+class ArchSpec;
+class ArmUnwindInfo;
+class Args;
+class ASTResultSynthesizer;
+class ASTStructExtractor;
+class Baton;
+class Block;
+class Breakpoint;
+class BreakpointID;
+class BreakpointIDList;
+class BreakpointList;
+class BreakpointLocation;
+class BreakpointLocationCollection;
+class BreakpointLocationList;
+class BreakpointOptions;
+class BreakpointResolver;
+class BreakpointSite;
+class BreakpointSiteList;
+class BroadcastEventSpec;
+class Broadcaster;
+class BroadcasterManager;
+class CPPLanguageRuntime;
+class ClangASTContext;
+class ClangASTImporter;
+class ClangASTMetadata;
+class ClangASTSource;
+class ClangExpressionDeclMap;
+class ClangExpressionParser;
+class ClangExpressionVariable;
+class ClangExpressionVariables;
+class ClangModulesDeclVendor;
+class ClangPersistentVariables;
+class CommandInterpreter;
+class CommandInterpreterRunOptions;
+class CommandObject;
+class CommandObjectMultiword;
+class CommandReturnObject;
+class Communication;
+class CompactUnwindInfo;
+struct CompilerContext;
+class CompilerDecl;
+class CompilerDeclContext;
+class CompilerType;
+class CompileUnit;
+class Condition;
+class Connection;
+class ConnectionFileDescriptor;
+class ConstString;
+class CXXSyntheticChildren;
+class DWARFCallFrameInfo;
+class DWARFExpression;
+class DataBuffer;
+class DataEncoder;
+class DataExtractor;
+class Debugger;
+class Declaration;
+class DiagnosticManager;
+class Disassembler;
+class DumpValueObjectOptions;
+class DynamicCheckerFunctions;
+class DynamicLoader;
+class Editline;
+class EmulateInstruction;
+class Error;
+class EvaluateExpressionOptions;
+class Event;
+class EventData;
+class EventDataStructuredData;
+class ExecutionContext;
+class ExecutionContextRef;
+class ExecutionContextRefLocker;
+class ExecutionContextScope;
+class Expression;
+class ExpressionVariable;
+class ExpressionVariableList;
+class ExpressionTypeSystemHelper;
+class File;
+class FileSpec;
+class FileSpecList;
+class Flags;
+class GoASTContext;
+class TypeCategoryImpl;
+class FormatManager;
+class FormattersMatchCandidate;
+class FuncUnwinders;
+class Function;
+class FunctionInfo;
+class InlineFunctionInfo;
+class Instruction;
+class InstructionList;
+class InstrumentationRuntime;
+class IOHandler;
+class IOObject;
+class IRExecutionUnit;
+class JITLoader;
+class JITLoaderList;
+class Language;
+class LanguageCategory;
+class LanguageRuntime;
+class MemoryRegionInfo;
+class LineTable;
+class Listener;
+class Log;
+class LogChannel;
+class Mangled;
+class Materializer;
+class MemoryHistory;
+class Module;
+class ModuleList;
+class ModuleSpec;
+class ModuleSpecList;
+class Mutex;
+struct NameSearchContext;
+class ObjCLanguageRuntime;
+class ObjCRuntimeSyntheticProvider;
+class ObjectContainer;
+class OptionGroup;
+class OptionGroupOptions;
+class OptionGroupPlatform;
+class ObjectFile;
+class ObjectFileJITDelegate;
+class OperatingSystem;
+class Options;
+class OptionValue;
+class OptionValueArch;
+class OptionValueArgs;
+class OptionValueArray;
+class OptionValueBoolean;
+class OptionValueChar;
+class OptionValueDictionary;
+class OptionValueEnumeration;
+class OptionValueFileSpec;
+class OptionValueFileSpecList;
+class OptionValueFormat;
+class OptionValueLanguage;
+class OptionValueFormatEntity;
+class OptionValuePathMappings;
+class OptionValueProperties;
+class OptionValueRegex;
+class OptionValueSInt64;
+class OptionValueString;
+class OptionValueUInt64;
+class OptionValueUUID;
+class NamedOption;
+class PathMappingList;
+class FunctionCaller;
+class PersistentExpressionState;
+class Platform;
+class Process;
+class ProcessAttachInfo;
+class ProcessModID;
+class ProcessInfo;
+class ProcessInstanceInfo;
+class ProcessInstanceInfoList;
+class ProcessInstanceInfoMatch;
+class ProcessLaunchInfo;
+class Property;
+struct PropertyDefinition;
+class RegisterCheckpoint;
+class RegisterContext;
+class RegisterLocation;
+class RegisterLocationList;
+class RegisterValue;
+class RegularExpression;
+class REPL;
+class Scalar;
+class ScriptInterpreter;
+class ScriptInterpreterLocker;
+struct ScriptSummaryFormat;
+class SearchFilter;
+class Section;
+class SectionImpl;
+class SectionList;
+class SectionLoadHistory;
+class SectionLoadList;
+class Settings;
+class SwiftASTContext;
+class SwiftLanguageRuntime;
+class SwiftREPL;
+class SourceManager;
+class SourceManagerImpl;
+class StackFrame;
+class StackFrameImpl;
+class StackFrameList;
+class StackID;
+class StopInfo;
+class Stoppoint;
+class StoppointCallbackContext;
+class StoppointLocation;
+class Stream;
+template <unsigned N> class StreamBuffer;
+class StreamFile;
+class StreamString;
+class StringList;
+struct StringSummaryFormat;
+class StructuredDataPlugin;
+class SystemRuntime;
+class TypeSummaryImpl;
+class TypeSummaryOptions;
+class Symbol;
+class SymbolContext;
+class SymbolContextList;
+class SymbolContextScope;
+class SymbolContextSpecifier;
+class SymbolFile;
+class SymbolFileType;
+class SymbolVendor;
+class Symtab;
+class SyntheticChildren;
+class SyntheticChildrenFrontEnd;
+class TypeFilterImpl;
+class TypeSystem;
+#ifndef LLDB_DISABLE_PYTHON
+class ScriptedSyntheticChildren;
+#endif
+class Queue;
+class QueueItem;
+class QueueImpl;
+class Target;
+class TargetList;
+class TargetProperties;
+class Thread;
+class ThreadCollection;
+class ThreadList;
+class ThreadPlan;
+class ThreadPlanBase;
+class ThreadPlanRunToAddress;
+class ThreadPlanStepInstruction;
+class ThreadPlanStepOut;
+class ThreadPlanStepOverBreakpoint;
+class ThreadPlanStepRange;
+class ThreadPlanStepThrough;
+class ThreadPlanTracer;
+class ThreadSpec;
+class Type;
+class TypeAndOrName;
+class TypeCategoryMap;
+class TypeImpl;
+class TypeList;
+class TypeMap;
+class TypeListImpl;
+class TypeMemberImpl;
+class TypeMemberFunctionImpl;
+class TypeEnumMemberImpl;
+class TypeEnumMemberListImpl;
+class TypeFormatImpl;
+class TypeNameSpecifierImpl;
+class TypePair;
+class TypeValidatorImpl;
+class UUID;
+class UnixSignals;
+class Unwind;
+class UnwindAssembly;
+class UnwindPlan;
+class UnwindTable;
+class UserExpression;
+class UtilityFunction;
+class VMRange;
+class Value;
+class ValueList;
+class ValueObject;
+class ValueObjectChild;
+class ValueObjectConstResult;
+class ValueObjectConstResultChild;
+class ValueObjectConstResultImpl;
+class ValueObjectList;
+class ValueObjectPrinter;
+class Variable;
+class VariableList;
+class Watchpoint;
+class WatchpointList;
+class WatchpointOptions;
+struct LineEntry;
+
+} // namespace lldb_private
+
+//----------------------------------------------------------------------
+// lldb forward declarations
+//----------------------------------------------------------------------
+namespace lldb {
+
+typedef std::shared_ptr<lldb_private::ABI> ABISP;
+typedef std::shared_ptr<lldb_private::Baton> BatonSP;
+typedef std::shared_ptr<lldb_private::Block> BlockSP;
+typedef std::shared_ptr<lldb_private::Breakpoint> BreakpointSP;
+typedef std::weak_ptr<lldb_private::Breakpoint> BreakpointWP;
+typedef std::shared_ptr<lldb_private::BreakpointSite> BreakpointSiteSP;
+typedef std::weak_ptr<lldb_private::BreakpointSite> BreakpointSiteWP;
+typedef std::shared_ptr<lldb_private::BreakpointLocation> BreakpointLocationSP;
+typedef std::weak_ptr<lldb_private::BreakpointLocation> BreakpointLocationWP;
+typedef std::shared_ptr<lldb_private::BreakpointResolver> BreakpointResolverSP;
+typedef std::shared_ptr<lldb_private::Broadcaster> BroadcasterSP;
+typedef std::shared_ptr<lldb_private::BroadcasterManager> BroadcasterManagerSP;
+typedef std::weak_ptr<lldb_private::BroadcasterManager> BroadcasterManagerWP;
+typedef std::unique_ptr<lldb_private::ClangASTContext> ClangASTContextUP;
+typedef std::shared_ptr<lldb_private::ClangASTImporter> ClangASTImporterSP;
+typedef std::unique_ptr<lldb_private::ClangModulesDeclVendor>
+ ClangModulesDeclVendorUP;
+typedef std::unique_ptr<lldb_private::ClangPersistentVariables>
+ ClangPersistentVariablesUP;
+typedef std::shared_ptr<lldb_private::UserExpression> UserExpressionSP;
+typedef std::shared_ptr<lldb_private::CommandObject> CommandObjectSP;
+typedef std::shared_ptr<lldb_private::Communication> CommunicationSP;
+typedef std::shared_ptr<lldb_private::Connection> ConnectionSP;
+typedef std::shared_ptr<lldb_private::CompileUnit> CompUnitSP;
+typedef std::shared_ptr<lldb_private::DataBuffer> DataBufferSP;
+typedef std::shared_ptr<lldb_private::DataExtractor> DataExtractorSP;
+typedef std::shared_ptr<lldb_private::Debugger> DebuggerSP;
+typedef std::weak_ptr<lldb_private::Debugger> DebuggerWP;
+typedef std::shared_ptr<lldb_private::Disassembler> DisassemblerSP;
+typedef std::unique_ptr<lldb_private::DynamicCheckerFunctions>
+ DynamicCheckerFunctionsUP;
+typedef std::shared_ptr<lldb_private::DynamicLoader> DynamicLoaderSP;
+typedef std::unique_ptr<lldb_private::DynamicLoader> DynamicLoaderUP;
+typedef std::shared_ptr<lldb_private::Event> EventSP;
+typedef std::shared_ptr<lldb_private::EventData> EventDataSP;
+typedef std::shared_ptr<lldb_private::EventDataStructuredData>
+ EventDataStructuredDataSP;
+typedef std::shared_ptr<lldb_private::ExecutionContextRef>
+ ExecutionContextRefSP;
+typedef std::shared_ptr<lldb_private::ExpressionVariable> ExpressionVariableSP;
+typedef std::shared_ptr<lldb_private::File> FileSP;
+typedef std::shared_ptr<lldb_private::Function> FunctionSP;
+typedef std::shared_ptr<lldb_private::FunctionCaller> FunctionCallerSP;
+typedef std::shared_ptr<lldb_private::FuncUnwinders> FuncUnwindersSP;
+typedef std::unique_ptr<lldb_private::GoASTContext> GoASTContextUP;
+typedef std::shared_ptr<lldb_private::InlineFunctionInfo> InlineFunctionInfoSP;
+typedef std::shared_ptr<lldb_private::Instruction> InstructionSP;
+typedef std::shared_ptr<lldb_private::InstrumentationRuntime>
+ InstrumentationRuntimeSP;
+typedef std::shared_ptr<lldb_private::IOHandler> IOHandlerSP;
+typedef std::shared_ptr<lldb_private::IOObject> IOObjectSP;
+typedef std::shared_ptr<lldb_private::IRExecutionUnit> IRExecutionUnitSP;
+typedef std::shared_ptr<lldb_private::JITLoader> JITLoaderSP;
+typedef std::unique_ptr<lldb_private::JITLoaderList> JITLoaderListUP;
+typedef std::shared_ptr<lldb_private::LanguageRuntime> LanguageRuntimeSP;
+typedef std::shared_ptr<lldb_private::SystemRuntime> SystemRuntimeSP;
+typedef std::unique_ptr<lldb_private::SystemRuntime> SystemRuntimeUP;
+typedef std::shared_ptr<lldb_private::LineTable> LineTableSP;
+typedef std::shared_ptr<lldb_private::Listener> ListenerSP;
+typedef std::weak_ptr<lldb_private::Listener> ListenerWP;
+typedef std::shared_ptr<lldb_private::LogChannel> LogChannelSP;
+typedef std::shared_ptr<lldb_private::MemoryHistory> MemoryHistorySP;
+typedef std::shared_ptr<lldb_private::MemoryRegionInfo> MemoryRegionInfoSP;
+typedef std::unique_ptr<lldb_private::MemoryRegionInfo> MemoryRegionInfoUP;
+typedef std::shared_ptr<lldb_private::Module> ModuleSP;
+typedef std::weak_ptr<lldb_private::Module> ModuleWP;
+typedef std::shared_ptr<lldb_private::ObjectFile> ObjectFileSP;
+typedef std::weak_ptr<lldb_private::ObjectFile> ObjectFileWP;
+typedef std::shared_ptr<lldb_private::ObjectFileJITDelegate>
+ ObjectFileJITDelegateSP;
+typedef std::weak_ptr<lldb_private::ObjectFileJITDelegate>
+ ObjectFileJITDelegateWP;
+typedef std::unique_ptr<lldb_private::OperatingSystem> OperatingSystemUP;
+typedef std::shared_ptr<lldb_private::OptionValue> OptionValueSP;
+typedef std::weak_ptr<lldb_private::OptionValue> OptionValueWP;
+typedef std::shared_ptr<lldb_private::OptionValueArch> OptionValueArchSP;
+typedef std::shared_ptr<lldb_private::OptionValueArgs> OptionValueArgsSP;
+typedef std::shared_ptr<lldb_private::OptionValueArray> OptionValueArraySP;
+typedef std::shared_ptr<lldb_private::OptionValueBoolean> OptionValueBooleanSP;
+typedef std::shared_ptr<lldb_private::OptionValueDictionary>
+ OptionValueDictionarySP;
+typedef std::shared_ptr<lldb_private::OptionValueFileSpec>
+ OptionValueFileSpecSP;
+typedef std::shared_ptr<lldb_private::OptionValueFileSpecList>
+ OptionValueFileSpecListSP;
+typedef std::shared_ptr<lldb_private::OptionValueFormat> OptionValueFormatSP;
+typedef std::shared_ptr<lldb_private::OptionValuePathMappings>
+ OptionValuePathMappingsSP;
+typedef std::shared_ptr<lldb_private::OptionValueProperties>
+ OptionValuePropertiesSP;
+typedef std::shared_ptr<lldb_private::OptionValueRegex> OptionValueRegexSP;
+typedef std::shared_ptr<lldb_private::OptionValueSInt64> OptionValueSInt64SP;
+typedef std::shared_ptr<lldb_private::OptionValueString> OptionValueStringSP;
+typedef std::shared_ptr<lldb_private::OptionValueUInt64> OptionValueUInt64SP;
+typedef std::shared_ptr<lldb_private::OptionValueUUID> OptionValueUUIDSP;
+typedef std::shared_ptr<lldb_private::Platform> PlatformSP;
+typedef std::shared_ptr<lldb_private::Process> ProcessSP;
+typedef std::shared_ptr<lldb_private::ProcessAttachInfo> ProcessAttachInfoSP;
+typedef std::shared_ptr<lldb_private::ProcessLaunchInfo> ProcessLaunchInfoSP;
+typedef std::weak_ptr<lldb_private::Process> ProcessWP;
+typedef std::shared_ptr<lldb_private::Property> PropertySP;
+typedef std::shared_ptr<lldb_private::RegisterCheckpoint> RegisterCheckpointSP;
+typedef std::shared_ptr<lldb_private::RegisterContext> RegisterContextSP;
+typedef std::shared_ptr<lldb_private::RegularExpression> RegularExpressionSP;
+typedef std::shared_ptr<lldb_private::Queue> QueueSP;
+typedef std::weak_ptr<lldb_private::Queue> QueueWP;
+typedef std::shared_ptr<lldb_private::QueueItem> QueueItemSP;
+typedef std::shared_ptr<lldb_private::REPL> REPLSP;
+typedef std::shared_ptr<lldb_private::ScriptSummaryFormat>
+ ScriptSummaryFormatSP;
+typedef std::shared_ptr<lldb_private::ScriptInterpreter> ScriptInterpreterSP;
+typedef std::unique_ptr<lldb_private::ScriptInterpreter> ScriptInterpreterUP;
+typedef std::shared_ptr<lldb_private::Section> SectionSP;
+typedef std::unique_ptr<lldb_private::SectionList> SectionListUP;
+typedef std::weak_ptr<lldb_private::Section> SectionWP;
+typedef std::shared_ptr<lldb_private::SectionLoadList> SectionLoadListSP;
+typedef std::shared_ptr<lldb_private::SearchFilter> SearchFilterSP;
+typedef std::shared_ptr<lldb_private::Settings> SettingsSP;
+typedef std::shared_ptr<lldb_private::SwiftASTContext> SwiftASTContextSP;
+typedef std::unique_ptr<lldb_private::SourceManager> SourceManagerUP;
+typedef std::shared_ptr<lldb_private::StackFrame> StackFrameSP;
+typedef std::unique_ptr<lldb_private::StackFrame> StackFrameUP;
+typedef std::weak_ptr<lldb_private::StackFrame> StackFrameWP;
+typedef std::shared_ptr<lldb_private::StackFrameList> StackFrameListSP;
+typedef std::shared_ptr<lldb_private::StopInfo> StopInfoSP;
+typedef std::shared_ptr<lldb_private::StoppointLocation> StoppointLocationSP;
+typedef std::shared_ptr<lldb_private::Stream> StreamSP;
+typedef std::weak_ptr<lldb_private::Stream> StreamWP;
+typedef std::shared_ptr<lldb_private::StreamFile> StreamFileSP;
+typedef std::shared_ptr<lldb_private::StringSummaryFormat>
+ StringTypeSummaryImplSP;
+typedef std::shared_ptr<lldb_private::StructuredDataPlugin>
+ StructuredDataPluginSP;
+typedef std::weak_ptr<lldb_private::StructuredDataPlugin>
+ StructuredDataPluginWP;
+typedef std::shared_ptr<lldb_private::SymbolFile> SymbolFileSP;
+typedef std::shared_ptr<lldb_private::SymbolFileType> SymbolFileTypeSP;
+typedef std::weak_ptr<lldb_private::SymbolFileType> SymbolFileTypeWP;
+typedef std::shared_ptr<lldb_private::SymbolContextSpecifier>
+ SymbolContextSpecifierSP;
+typedef std::unique_ptr<lldb_private::SymbolVendor> SymbolVendorUP;
+typedef std::shared_ptr<lldb_private::SyntheticChildren> SyntheticChildrenSP;
+typedef std::shared_ptr<lldb_private::SyntheticChildrenFrontEnd>
+ SyntheticChildrenFrontEndSP;
+typedef std::shared_ptr<lldb_private::Target> TargetSP;
+typedef std::weak_ptr<lldb_private::Target> TargetWP;
+typedef std::shared_ptr<lldb_private::TargetProperties> TargetPropertiesSP;
+typedef std::shared_ptr<lldb_private::Thread> ThreadSP;
+typedef std::weak_ptr<lldb_private::Thread> ThreadWP;
+typedef std::shared_ptr<lldb_private::ThreadCollection> ThreadCollectionSP;
+typedef std::shared_ptr<lldb_private::ThreadPlan> ThreadPlanSP;
+typedef std::shared_ptr<lldb_private::ThreadPlanTracer> ThreadPlanTracerSP;
+typedef std::shared_ptr<lldb_private::Type> TypeSP;
+typedef std::weak_ptr<lldb_private::Type> TypeWP;
+typedef std::shared_ptr<lldb_private::TypeCategoryImpl> TypeCategoryImplSP;
+typedef std::shared_ptr<lldb_private::TypeImpl> TypeImplSP;
+typedef std::shared_ptr<lldb_private::TypeMemberFunctionImpl>
+ TypeMemberFunctionImplSP;
+typedef std::shared_ptr<lldb_private::TypeEnumMemberImpl> TypeEnumMemberImplSP;
+typedef std::shared_ptr<lldb_private::TypeFilterImpl> TypeFilterImplSP;
+typedef std::shared_ptr<lldb_private::TypeSystem> TypeSystemSP;
+typedef std::shared_ptr<lldb_private::TypeFormatImpl> TypeFormatImplSP;
+typedef std::shared_ptr<lldb_private::TypeNameSpecifierImpl>
+ TypeNameSpecifierImplSP;
+typedef std::shared_ptr<lldb_private::TypeSummaryImpl> TypeSummaryImplSP;
+typedef std::shared_ptr<lldb_private::TypeSummaryOptions> TypeSummaryOptionsSP;
+typedef std::shared_ptr<lldb_private::TypeValidatorImpl> TypeValidatorImplSP;
+#ifndef LLDB_DISABLE_PYTHON
+typedef std::shared_ptr<lldb_private::ScriptedSyntheticChildren>
+ ScriptedSyntheticChildrenSP;
+#endif
+typedef std::shared_ptr<lldb_private::UnixSignals> UnixSignalsSP;
+typedef std::weak_ptr<lldb_private::UnixSignals> UnixSignalsWP;
+typedef std::shared_ptr<lldb_private::UnwindAssembly> UnwindAssemblySP;
+typedef std::shared_ptr<lldb_private::UnwindPlan> UnwindPlanSP;
+typedef std::shared_ptr<lldb_private::UtilityFunction> UtilityFunctionSP;
+typedef lldb_private::SharingPtr<lldb_private::ValueObject> ValueObjectSP;
+typedef std::shared_ptr<lldb_private::Value> ValueSP;
+typedef std::shared_ptr<lldb_private::ValueList> ValueListSP;
+typedef std::shared_ptr<lldb_private::Variable> VariableSP;
+typedef std::shared_ptr<lldb_private::VariableList> VariableListSP;
+typedef std::shared_ptr<lldb_private::ValueObjectList> ValueObjectListSP;
+typedef std::shared_ptr<lldb_private::Watchpoint> WatchpointSP;
+
+} // namespace lldb
+
+#endif // #if defined(__cplusplus)
+#endif // LLDB_lldb_forward_h_
--- /dev/null
+//===-- lldb-private-defines.h ----------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_lldb_private_defines_h_
+#define liblldb_lldb_private_defines_h_
+
+#if defined(__cplusplus)
+
+// Include Compiler.h here so we don't define LLVM_FALLTHROUGH and then
+// Compiler.h
+// later tries to redefine it.
+#include "llvm/Support/Compiler.h"
+
+#ifndef LLVM_FALLTHROUGH
+
+#ifndef __has_cpp_attribute
+#define __has_cpp_attribute(x) 0
+#endif
+
+/// \macro LLVM_FALLTHROUGH
+/// \brief Marks an empty statement preceding a deliberate switch fallthrough.
+#if __has_cpp_attribute(clang::fallthrough)
+#define LLVM_FALLTHROUGH [[clang::fallthrough]]
+#else
+#define LLVM_FALLTHROUGH
+#endif
+
+#endif // ifndef LLVM_FALLTHROUGH
+
+#endif // #if defined(__cplusplus)
+
+#endif // liblldb_lldb_private_defines_h_
--- /dev/null
+//===-- lldb-private-enumerations.h -----------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_lldb_private_enumerations_h_
+#define LLDB_lldb_private_enumerations_h_
+
+namespace lldb_private {
+
+//----------------------------------------------------------------------
+// Thread Step Types
+//----------------------------------------------------------------------
+typedef enum StepType {
+ eStepTypeNone,
+ eStepTypeTrace, ///< Single step one instruction.
+ eStepTypeTraceOver, ///< Single step one instruction, stepping over.
+ eStepTypeInto, ///< Single step into a specified context.
+ eStepTypeOver, ///< Single step over a specified context.
+ eStepTypeOut, ///< Single step out a specified context.
+ eStepTypeScripted ///< A step type implemented by the script interpreter.
+} StepType;
+
+//----------------------------------------------------------------------
+// Address Types
+//----------------------------------------------------------------------
+typedef enum AddressType {
+ eAddressTypeInvalid = 0,
+ eAddressTypeFile, ///< Address is an address as found in an object or symbol
+ ///file
+ eAddressTypeLoad, ///< Address is an address as in the current target inferior
+ ///process
+ eAddressTypeHost ///< Address is an address in the process that is running
+ ///this code
+} AddressType;
+
+//----------------------------------------------------------------------
+// Votes - Need a tri-state, yes, no, no opinion...
+//----------------------------------------------------------------------
+typedef enum Vote { eVoteNo = -1, eVoteNoOpinion = 0, eVoteYes = 1 } Vote;
+
+typedef enum ArchitectureType {
+ eArchTypeInvalid,
+ eArchTypeMachO,
+ eArchTypeELF,
+ eArchTypeCOFF,
+ kNumArchTypes
+} ArchitectureType;
+
+//----------------------------------------------------------------------
+/// Settable state variable types.
+///
+//----------------------------------------------------------------------
+
+// typedef enum SettableVariableType
+//{
+// eSetVarTypeInt,
+// eSetVarTypeBoolean,
+// eSetVarTypeString,
+// eSetVarTypeArray,
+// eSetVarTypeDictionary,
+// eSetVarTypeEnum,
+// eSetVarTypeNone
+//} SettableVariableType;
+
+typedef enum VarSetOperationType {
+ eVarSetOperationReplace,
+ eVarSetOperationInsertBefore,
+ eVarSetOperationInsertAfter,
+ eVarSetOperationRemove,
+ eVarSetOperationAppend,
+ eVarSetOperationClear,
+ eVarSetOperationAssign,
+ eVarSetOperationInvalid
+} VarSetOperationType;
+
+typedef enum ArgumentRepetitionType {
+ eArgRepeatPlain, // Exactly one occurrence
+ eArgRepeatOptional, // At most one occurrence, but it's optional
+ eArgRepeatPlus, // One or more occurrences
+ eArgRepeatStar, // Zero or more occurrences
+ eArgRepeatRange, // Repetition of same argument, from 1 to n
+ eArgRepeatPairPlain, // A pair of arguments that must always go together
+ // ([arg-type arg-value]), occurs exactly once
+ eArgRepeatPairOptional, // A pair that occurs at most once (optional)
+ eArgRepeatPairPlus, // One or more occurrences of a pair
+ eArgRepeatPairStar, // Zero or more occurrences of a pair
+ eArgRepeatPairRange, // A pair that repeats from 1 to n
+ eArgRepeatPairRangeOptional // A pair that repeats from 1 to n, but is
+ // optional
+} ArgumentRepetitionType;
+
+typedef enum SortOrder {
+ eSortOrderNone,
+ eSortOrderByAddress,
+ eSortOrderByName
+} SortOrder;
+
+//----------------------------------------------------------------------
+// LazyBool is for boolean values that need to be calculated lazily.
+// Values start off set to eLazyBoolCalculate, and then they can be
+// calculated once and set to eLazyBoolNo or eLazyBoolYes.
+//----------------------------------------------------------------------
+typedef enum LazyBool {
+ eLazyBoolCalculate = -1,
+ eLazyBoolNo = 0,
+ eLazyBoolYes = 1
+} LazyBool;
+
+//------------------------------------------------------------------
+/// Name matching
+//------------------------------------------------------------------
+typedef enum NameMatchType {
+ eNameMatchIgnore,
+ eNameMatchEquals,
+ eNameMatchContains,
+ eNameMatchStartsWith,
+ eNameMatchEndsWith,
+ eNameMatchRegularExpression
+
+} NameMatchType;
+
+//------------------------------------------------------------------
+/// Instruction types
+//------------------------------------------------------------------
+typedef enum InstructionType {
+ eInstructionTypeAny, // Support for any instructions at all (at least one)
+ eInstructionTypePrologueEpilogue, // All prologue and epilogue instructions
+ // that push and pop register values and
+ // modify sp/fp
+ eInstructionTypePCModifying, // Any instruction that modifies the program
+ // counter/instruction pointer
+ eInstructionTypeAll // All instructions of any kind
+
+} InstructionType;
+
+//------------------------------------------------------------------
+/// Format category entry types
+//------------------------------------------------------------------
+typedef enum FormatCategoryItem {
+ eFormatCategoryItemSummary = 0x0001,
+ eFormatCategoryItemRegexSummary = 0x0002,
+ eFormatCategoryItemFilter = 0x0004,
+ eFormatCategoryItemRegexFilter = 0x0008,
+ eFormatCategoryItemSynth = 0x0010,
+ eFormatCategoryItemRegexSynth = 0x0020,
+ eFormatCategoryItemValue = 0x0040,
+ eFormatCategoryItemRegexValue = 0x0080,
+ eFormatCategoryItemValidator = 0x0100,
+ eFormatCategoryItemRegexValidator = 0x0200
+} FormatCategoryItem;
+
+//------------------------------------------------------------------
+/// Expression execution policies
+//------------------------------------------------------------------
+typedef enum {
+ eExecutionPolicyOnlyWhenNeeded,
+ eExecutionPolicyNever,
+ eExecutionPolicyAlways,
+ eExecutionPolicyTopLevel // used for top-level code
+} ExecutionPolicy;
+
+//----------------------------------------------------------------------
+// Ways that the FormatManager picks a particular format for a type
+//----------------------------------------------------------------------
+typedef enum FormatterChoiceCriterion {
+ eFormatterChoiceCriterionDirectChoice = 0x00000000,
+ eFormatterChoiceCriterionStrippedPointerReference = 0x00000001,
+ eFormatterChoiceCriterionNavigatedTypedefs = 0x00000002,
+ eFormatterChoiceCriterionRegularExpressionSummary = 0x00000004,
+ eFormatterChoiceCriterionRegularExpressionFilter = 0x00000004,
+ eFormatterChoiceCriterionLanguagePlugin = 0x00000008,
+ eFormatterChoiceCriterionStrippedBitField = 0x00000010,
+ eFormatterChoiceCriterionWentToStaticValue = 0x00000020
+} FormatterChoiceCriterion;
+
+//----------------------------------------------------------------------
+// Synchronicity behavior of scripted commands
+//----------------------------------------------------------------------
+typedef enum ScriptedCommandSynchronicity {
+ eScriptedCommandSynchronicitySynchronous,
+ eScriptedCommandSynchronicityAsynchronous,
+ eScriptedCommandSynchronicityCurrentValue // use whatever the current
+ // synchronicity is
+} ScriptedCommandSynchronicity;
+
+//----------------------------------------------------------------------
+// Verbosity mode of "po" output
+//----------------------------------------------------------------------
+typedef enum LanguageRuntimeDescriptionDisplayVerbosity {
+ eLanguageRuntimeDescriptionDisplayVerbosityCompact, // only print the
+ // description string, if
+ // any
+ eLanguageRuntimeDescriptionDisplayVerbosityFull, // print the full-blown
+ // output
+} LanguageRuntimeDescriptionDisplayVerbosity;
+
+//----------------------------------------------------------------------
+// Loading modules from memory
+//----------------------------------------------------------------------
+typedef enum MemoryModuleLoadLevel {
+ eMemoryModuleLoadLevelMinimal, // Load sections only
+ eMemoryModuleLoadLevelPartial, // Load function bounds but no symbols
+ eMemoryModuleLoadLevelComplete, // Load sections and all symbols
+} MemoryModuleLoadLevel;
+
+//----------------------------------------------------------------------
+// Result enums for when reading multiple lines from IOHandlers
+//----------------------------------------------------------------------
+enum class LineStatus {
+ Success, // The line that was just edited if good and should be added to the
+ // lines
+ Error, // There is an error with the current line and it needs to be re-edited
+ // before it can be accepted
+ Done // Lines are complete
+};
+
+//----------------------------------------------------------------------
+// Exit Type for inferior processes
+//----------------------------------------------------------------------
+typedef enum ExitType {
+ eExitTypeInvalid,
+ eExitTypeExit, // The exit status represents the return code from normal
+ // program exit (i.e. WIFEXITED() was true)
+ eExitTypeSignal, // The exit status represents the signal number that caused
+ // the program to exit (i.e. WIFSIGNALED() was true)
+ eExitTypeStop, // The exit status represents the stop signal that caused the
+ // program to exit (i.e. WIFSTOPPED() was true)
+} ExitType;
+
+//----------------------------------------------------------------------
+// Boolean result of running a Type Validator
+//----------------------------------------------------------------------
+enum class TypeValidatorResult : bool { Success = true, Failure = false };
+
+//----------------------------------------------------------------------
+// Enumerations that can be used to specify scopes types when looking up
+// types.
+//----------------------------------------------------------------------
+enum class CompilerContextKind {
+ Invalid = 0,
+ TranslationUnit,
+ Module,
+ Namespace,
+ Class,
+ Structure,
+ Union,
+ Function,
+ Variable,
+ Enumeration,
+ Typedef
+};
+
+} // namespace lldb_private
+
+#endif // LLDB_lldb_private_enumerations_h_
--- /dev/null
+//===-- lldb-private-forward.h ----------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_lldb_private_forward_h_
+#define LLDB_lldb_private_forward_h_
+
+#if defined(__cplusplus)
+
+#include <memory>
+
+namespace lldb_private {
+// ---------------------------------------------------------------
+// Class forward decls.
+// ---------------------------------------------------------------
+class NativeBreakpoint;
+class NativeBreakpointList;
+class NativeProcessProtocol;
+class NativeRegisterContext;
+class NativeThreadProtocol;
+class ResumeActionList;
+class UnixSignals;
+
+// ---------------------------------------------------------------
+// SP/WP decls.
+// ---------------------------------------------------------------
+typedef std::shared_ptr<NativeBreakpoint> NativeBreakpointSP;
+typedef std::shared_ptr<lldb_private::NativeProcessProtocol>
+ NativeProcessProtocolSP;
+typedef std::weak_ptr<lldb_private::NativeProcessProtocol>
+ NativeProcessProtocolWP;
+typedef std::shared_ptr<lldb_private::NativeRegisterContext>
+ NativeRegisterContextSP;
+typedef std::shared_ptr<lldb_private::NativeThreadProtocol>
+ NativeThreadProtocolSP;
+}
+
+#endif // #if defined(__cplusplus)
+#endif // #ifndef LLDB_lldb_private_forward_h_
--- /dev/null
+//===-- lldb-private-interfaces.h -------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_lldb_private_interfaces_h_
+#define liblldb_lldb_private_interfaces_h_
+
+#if defined(__cplusplus)
+
+#include "lldb/lldb-enumerations.h"
+#include "lldb/lldb-forward.h"
+#include "lldb/lldb-types.h"
+
+#include <set>
+
+namespace lldb_private {
+typedef lldb::ABISP (*ABICreateInstance)(const ArchSpec &arch);
+typedef Disassembler *(*DisassemblerCreateInstance)(const ArchSpec &arch,
+ const char *flavor);
+typedef DynamicLoader *(*DynamicLoaderCreateInstance)(Process *process,
+ bool force);
+typedef lldb::JITLoaderSP (*JITLoaderCreateInstance)(Process *process,
+ bool force);
+typedef ObjectContainer *(*ObjectContainerCreateInstance)(
+ const lldb::ModuleSP &module_sp, lldb::DataBufferSP &data_sp,
+ lldb::offset_t data_offset, const FileSpec *file, lldb::offset_t offset,
+ lldb::offset_t length);
+typedef size_t (*ObjectFileGetModuleSpecifications)(
+ const FileSpec &file, lldb::DataBufferSP &data_sp,
+ lldb::offset_t data_offset, lldb::offset_t file_offset,
+ lldb::offset_t length, ModuleSpecList &module_specs);
+typedef ObjectFile *(*ObjectFileCreateInstance)(const lldb::ModuleSP &module_sp,
+ lldb::DataBufferSP &data_sp,
+ lldb::offset_t data_offset,
+ const FileSpec *file,
+ lldb::offset_t file_offset,
+ lldb::offset_t length);
+typedef ObjectFile *(*ObjectFileCreateMemoryInstance)(
+ const lldb::ModuleSP &module_sp, lldb::DataBufferSP &data_sp,
+ const lldb::ProcessSP &process_sp, lldb::addr_t offset);
+typedef bool (*ObjectFileSaveCore)(const lldb::ProcessSP &process_sp,
+ const FileSpec &outfile, Error &error);
+typedef LogChannel *(*LogChannelCreateInstance)();
+typedef EmulateInstruction *(*EmulateInstructionCreateInstance)(
+ const ArchSpec &arch, InstructionType inst_type);
+typedef OperatingSystem *(*OperatingSystemCreateInstance)(Process *process,
+ bool force);
+typedef Language *(*LanguageCreateInstance)(lldb::LanguageType language);
+typedef LanguageRuntime *(*LanguageRuntimeCreateInstance)(
+ Process *process, lldb::LanguageType language);
+typedef lldb::CommandObjectSP (*LanguageRuntimeGetCommandObject)(
+ CommandInterpreter &interpreter);
+typedef lldb::StructuredDataPluginSP (*StructuredDataPluginCreateInstance)(
+ Process &process);
+typedef Error (*StructuredDataFilterLaunchInfo)(ProcessLaunchInfo &launch_info,
+ Target *target);
+typedef SystemRuntime *(*SystemRuntimeCreateInstance)(Process *process);
+typedef lldb::PlatformSP (*PlatformCreateInstance)(bool force,
+ const ArchSpec *arch);
+typedef lldb::ProcessSP (*ProcessCreateInstance)(
+ lldb::TargetSP target_sp, lldb::ListenerSP listener_sp,
+ const FileSpec *crash_file_path);
+typedef lldb::ScriptInterpreterSP (*ScriptInterpreterCreateInstance)(
+ CommandInterpreter &interpreter);
+typedef SymbolFile *(*SymbolFileCreateInstance)(ObjectFile *obj_file);
+typedef SymbolVendor *(*SymbolVendorCreateInstance)(
+ const lldb::ModuleSP &module_sp,
+ lldb_private::Stream
+ *feedback_strm); // Module can be NULL for default system symbol vendor
+typedef bool (*BreakpointHitCallback)(void *baton,
+ StoppointCallbackContext *context,
+ lldb::user_id_t break_id,
+ lldb::user_id_t break_loc_id);
+typedef bool (*WatchpointHitCallback)(void *baton,
+ StoppointCallbackContext *context,
+ lldb::user_id_t watch_id);
+typedef void (*OptionValueChangedCallback)(void *baton,
+ OptionValue *option_value);
+typedef bool (*ThreadPlanShouldStopHereCallback)(
+ ThreadPlan *current_plan, Flags &flags, lldb::FrameComparison operation,
+ void *baton);
+typedef lldb::ThreadPlanSP (*ThreadPlanStepFromHereCallback)(
+ ThreadPlan *current_plan, Flags &flags, lldb::FrameComparison operation,
+ void *baton);
+typedef UnwindAssembly *(*UnwindAssemblyCreateInstance)(const ArchSpec &arch);
+typedef lldb::MemoryHistorySP (*MemoryHistoryCreateInstance)(
+ const lldb::ProcessSP &process_sp);
+typedef lldb::InstrumentationRuntimeType (*InstrumentationRuntimeGetType)();
+typedef lldb::InstrumentationRuntimeSP (*InstrumentationRuntimeCreateInstance)(
+ const lldb::ProcessSP &process_sp);
+typedef lldb::TypeSystemSP (*TypeSystemCreateInstance)(
+ lldb::LanguageType language, Module *module, Target *target,
+ const char *compiler_options);
+typedef lldb::REPLSP (*REPLCreateInstance)(Error &error,
+ lldb::LanguageType language,
+ Debugger *debugger, Target *target,
+ const char *repl_options);
+typedef void (*TypeSystemEnumerateSupportedLanguages)(
+ std::set<lldb::LanguageType> &languages_for_types,
+ std::set<lldb::LanguageType> &languages_for_expressions);
+typedef void (*REPLEnumerateSupportedLanguages)(
+ std::set<lldb::LanguageType> &languages);
+typedef int (*ComparisonFunction)(const void *, const void *);
+typedef void (*DebuggerInitializeCallback)(Debugger &debugger);
+
+} // namespace lldb_private
+
+#endif // #if defined(__cplusplus)
+
+#endif // liblldb_lldb_private_interfaces_h_
--- /dev/null
+//===-- lldb-private-types.h ------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_lldb_private_types_h_
+#define liblldb_lldb_private_types_h_
+
+#if defined(__cplusplus)
+
+#include "lldb/lldb-private.h"
+
+#include "llvm/ADT/ArrayRef.h"
+
+namespace llvm {
+namespace sys {
+class DynamicLibrary;
+}
+}
+
+namespace lldb_private {
+class Platform;
+class ExecutionContext;
+
+typedef llvm::sys::DynamicLibrary (*LoadPluginCallbackType)(
+ const lldb::DebuggerSP &debugger_sp, const FileSpec &spec, Error &error);
+
+//----------------------------------------------------------------------
+// Every register is described in detail including its name, alternate
+// name (optional), encoding, size in bytes and the default display
+// format.
+//----------------------------------------------------------------------
+struct RegisterInfo {
+ const char *name; // Name of this register, can't be NULL
+ const char *alt_name; // Alternate name of this register, can be NULL
+ uint32_t byte_size; // Size in bytes of the register
+ uint32_t byte_offset; // The byte offset in the register context data where
+ // this register's value is found.
+ // This is optional, and can be 0 if a particular RegisterContext does not
+ // need to
+ // address its registers by byte offset.
+ lldb::Encoding encoding; // Encoding of the register bits
+ lldb::Format format; // Default display format
+ uint32_t kinds[lldb::kNumRegisterKinds]; // Holds all of the various register
+ // numbers for all register kinds
+ uint32_t *value_regs; // List of registers (terminated with
+ // LLDB_INVALID_REGNUM). If this value is not
+ // null, all registers in this list will be read first, at which point the
+ // value
+ // for this register will be valid. For example, the value list for ah
+ // would be eax (x86) or rax (x64).
+ uint32_t *invalidate_regs; // List of registers (terminated with
+ // LLDB_INVALID_REGNUM). If this value is not
+ // null, all registers in this list will be invalidated when the value of this
+ // register changes. For example, the invalidate list for eax would be rax
+ // ax, ah, and al.
+ const uint8_t *dynamic_size_dwarf_expr_bytes; // A DWARF expression that when
+ // evaluated gives
+ // the byte size of this register.
+ size_t dynamic_size_dwarf_len; // The length of the DWARF expression in bytes
+ // in the dynamic_size_dwarf_expr_bytes member.
+
+ llvm::ArrayRef<uint8_t> data(const uint8_t *context_base) const {
+ return llvm::ArrayRef<uint8_t>(context_base + byte_offset, byte_size);
+ }
+
+ llvm::MutableArrayRef<uint8_t> mutable_data(uint8_t *context_base) const {
+ return llvm::MutableArrayRef<uint8_t>(context_base + byte_offset,
+ byte_size);
+ }
+};
+
+//----------------------------------------------------------------------
+// Registers are grouped into register sets
+//----------------------------------------------------------------------
+struct RegisterSet {
+ const char *name; // Name of this register set
+ const char *short_name; // A short name for this register set
+ size_t num_registers; // The number of registers in REGISTERS array below
+ const uint32_t *registers; // An array of register indices in this set. The
+ // values in this array are
+ // *indices* (not register numbers) into a particular RegisterContext's
+ // register array. For example, if eax is defined at index 4 for a
+ // particular RegisterContext, eax would be included in this RegisterSet
+ // by adding the value 4. Not by adding the value lldb_eax_i386.
+};
+
+struct OptionEnumValueElement {
+ int64_t value;
+ const char *string_value;
+ const char *usage;
+};
+
+struct OptionValidator {
+ virtual ~OptionValidator() {}
+ virtual bool IsValid(Platform &platform,
+ const ExecutionContext &target) const = 0;
+ virtual const char *ShortConditionString() const = 0;
+ virtual const char *LongConditionString() const = 0;
+};
+
+struct OptionDefinition {
+ uint32_t usage_mask; // Used to mark options that can be used together. If (1
+ // << n & usage_mask) != 0
+ // then this option belongs to option set n.
+ bool required; // This option is required (in the current usage level)
+ const char *long_option; // Full name for this option.
+ int short_option; // Single character for this option.
+ int option_has_arg; // no_argument, required_argument or optional_argument
+ OptionValidator *validator; // If non-NULL, option is valid iff
+ // |validator->IsValid()|, otherwise always valid.
+ OptionEnumValueElement *enum_values; // If non-NULL an array of enum values.
+ uint32_t completion_type; // Cookie the option class can use to do define the
+ // argument completion.
+ lldb::CommandArgumentType argument_type; // Type of argument this option takes
+ const char *usage_text; // Full text explaining what this options does and
+ // what (if any) argument to
+ // pass it.
+};
+
+typedef struct type128 { uint64_t x[2]; } type128;
+typedef struct type256 { uint64_t x[4]; } type256;
+
+} // namespace lldb_private
+
+#endif // #if defined(__cplusplus)
+
+#endif // liblldb_lldb_private_types_h_
--- /dev/null
+//===-- lldb-private.h ------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef lldb_lldb_private_h_
+#define lldb_lldb_private_h_
+
+#if defined(__cplusplus)
+
+#include "lldb/lldb-private-defines.h"
+#include "lldb/lldb-private-enumerations.h"
+#include "lldb/lldb-private-interfaces.h"
+#include "lldb/lldb-private-types.h"
+#include "lldb/lldb-public.h"
+
+namespace lldb_private {
+
+const char *GetVersion();
+
+} // namespace lldb_private
+
+#endif // defined(__cplusplus)
+
+#endif // lldb_lldb_private_h_
--- /dev/null
+//===-- lldb-include.h ------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_lldb_h_
+#define LLDB_lldb_h_
+
+#include "lldb/lldb-defines.h"
+#include "lldb/lldb-enumerations.h"
+#include "lldb/lldb-forward.h"
+#include "lldb/lldb-types.h"
+
+#endif // LLDB_lldb_h_
--- /dev/null
+//===-- lldb-types.h --------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_lldb_types_h_
+#define LLDB_lldb_types_h_
+
+#include "lldb/lldb-enumerations.h"
+#include "lldb/lldb-forward.h"
+
+#include <assert.h>
+#include <signal.h>
+#include <stdint.h>
+
+//----------------------------------------------------------------------
+// All host systems must define:
+// lldb::condition_t The native condition type (or a substitute class)
+// for conditions on the host system.
+// lldb::mutex_t The native mutex type for mutex objects on the host
+// system.
+// lldb::thread_t The native thread type for spawned threads on the
+// system
+// lldb::thread_arg_t The type of the one any only thread creation
+// argument for the host system
+// lldb::thread_result_t The return type that gets returned when a thread
+// finishes.
+// lldb::thread_func_t The function prototype used to spawn a thread on the
+// host system.
+// #define LLDB_INVALID_PROCESS_ID ...
+// #define LLDB_INVALID_THREAD_ID ...
+// #define LLDB_INVALID_HOST_THREAD ...
+// #define IS_VALID_LLDB_HOST_THREAD ...
+//----------------------------------------------------------------------
+
+// TODO: Add a bunch of ifdefs to determine the host system and what
+// things should be defined. Currently MacOSX is being assumed by default
+// since that is what lldb was first developed for.
+
+#ifndef _MSC_VER
+#include <stdbool.h>
+#include <unistd.h>
+#endif
+
+#ifdef _WIN32
+
+#include <process.h>
+
+namespace lldb {
+typedef void *mutex_t;
+typedef void *condition_t;
+typedef void *rwlock_t;
+typedef void *process_t; // Process type is HANDLE
+typedef void *thread_t; // Host thread type
+typedef void *file_t; // Host file type
+typedef void *pipe_t; // Host pipe type
+typedef unsigned int __w64 socket_t; // Host socket type
+typedef uint32_t thread_key_t;
+typedef void *thread_arg_t; // Host thread argument type
+typedef unsigned thread_result_t; // Host thread result type
+typedef thread_result_t (*thread_func_t)(void *); // Host thread function type
+}
+
+#else
+
+#include <pthread.h>
+
+namespace lldb {
+//----------------------------------------------------------------------
+// MacOSX Types
+//----------------------------------------------------------------------
+typedef ::pthread_mutex_t mutex_t;
+typedef pthread_cond_t condition_t;
+typedef pthread_rwlock_t rwlock_t;
+typedef uint64_t process_t; // Process type is just a pid.
+typedef pthread_t thread_t; // Host thread type
+typedef int file_t; // Host file type
+typedef int pipe_t; // Host pipe type
+typedef int socket_t; // Host socket type
+typedef pthread_key_t thread_key_t;
+typedef void *thread_arg_t; // Host thread argument type
+typedef void *thread_result_t; // Host thread result type
+typedef void *(*thread_func_t)(void *); // Host thread function type
+} // namespace lldb
+
+#endif
+
+namespace lldb {
+typedef void (*LogOutputCallback)(const char *, void *baton);
+typedef bool (*CommandOverrideCallback)(void *baton, const char **argv);
+typedef bool (*CommandOverrideCallbackWithResult)(
+ void *baton, const char **argv, lldb_private::CommandReturnObject &result);
+typedef bool (*ExpressionCancelCallback)(ExpressionEvaluationPhase phase,
+ void *baton);
+}
+
+#define LLDB_INVALID_PROCESS ((lldb::process_t)-1)
+#define LLDB_INVALID_HOST_THREAD ((lldb::thread_t)NULL)
+#define IS_VALID_LLDB_HOST_THREAD(t) ((t) != LLDB_INVALID_HOST_THREAD)
+
+#define LLDB_INVALID_HOST_TIME \
+ { 0, 0 }
+
+namespace lldb {
+typedef uint64_t addr_t;
+typedef uint64_t user_id_t;
+typedef uint64_t pid_t;
+typedef uint64_t tid_t;
+typedef uint64_t offset_t;
+typedef int32_t break_id_t;
+typedef int32_t watch_id_t;
+typedef void *opaque_compiler_type_t;
+typedef uint64_t queue_id_t;
+}
+
+#endif // LLDB_lldb_types_h_
--- /dev/null
+//===-- lldb-versioning.h ----------------------------------------*- C++
+//-*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_lldb_versioning_h_
+#define LLDB_lldb_versioning_h_
+
+//----------------------------------------------------------------------
+// LLDB API version
+//----------------------------------------------------------------------
+#define LLDB_API_MAJOR_VERSION 1
+#define LLDB_API_MINOR_VERSION 0
+
+/*
+ API versioning
+ ---------------------------------
+
+ The LLDB API is versioned independently of the LLDB source base
+ Our API version numbers are composed of a major and a minor number
+
+ The major number means a complete and stable revision of the API. Major numbers
+ are compatibility breakers
+ (i.e. when we change the API major number, there is no promise of compatibility
+ with the previous major version
+ and we are free to remove and/or change any APIs)
+ Minor numbers are a work-in-progress evolution of the API. APIs will not be
+ removed or changed across minor versions
+ (minors do not break compatibility). However, we can deprecate APIs in minor
+ versions or add new APIs in minor versions
+ A deprecated API is supposedly going to be removed in the next major version
+ and will generate a warning if used
+ APIs we add in minor versions will not be removed (at least until the following
+ major) but they might theoretically be deprecated
+ in a following minor version
+ Users are discouraged from using the LLDB version number to test for API
+ features and should instead use the API version checking
+ as discussed below
+
+ API version checking
+ ---------------------------------
+
+ You can (optionally) sign into an API version checking feature
+ To do so you need to define three macros:
+ LLDB_API_CHECK_VERSIONING - define to any value (or no value)
+ LLDB_API_MAJOR_VERSION_WANTED - which major version of the LLDB API you are
+ targeting
+ LLDB_API_MINOR_VERSION_WANTED - which minor version of the LLDB API you are
+ targeting
+
+ If these macros exist - LLDB will enable version checking of the public API
+
+ If LLDB_API_MAJOR_VERSION is not equal to LLDB_API_MAJOR_VERSION_WANTED we will
+ immediately halt your compilation with an error
+ This is by design, since we do not make any promise of compatibility across
+ major versions - if you really want to test your luck, disable the versioning
+ altogether
+
+ If the major version test passes, you have signed up for a specific minor
+ version of the API
+ Whenever we add or deprecate an API in a minor version, we will mark it with
+ either
+ LLDB_API_NEW_IN_DOT_x - this API is new in LLDB .x
+ LLDB_API_DEPRECATED_IN_DOT_x - this API is deprecated as of .x
+
+ If you are using an API new in DOT_x
+ if LLDB_API_MINOR_VERSION_WANTED >= x then all is well, else you will get a
+ compilation error
+ This is meant to prevent you from using APIs that are newer than whatever
+ LLDB you want to target
+
+ If you are using an API deprecated in DOT_x
+ if LLDB_API_MINOR_VERSION_WANTED >= x then you will get a compilation warning,
+ else all is well
+ This is meant to let you know that you are using an API that is deprecated and
+ might go away
+
+ Caveats
+ ---------------------------------
+
+ Version checking only works on clang on OSX - you will get an error if you try
+ to enable it on any other OS/compiler
+ If you want to enable version checking on other platforms, you will need to
+ define appropriate implementations for
+ LLDB_API_IMPL_DEPRECATED and LLDB_API_IMPL_TOONEW and any other infrastructure
+ your compiler needs for this purpose
+
+ We have no deprecation-as-error mode
+
+ There is no support for API versioning in Python
+
+ We reserve to use macros whose names begin with LLDB_API_ and you should not
+ use them in your source code as they might conflict
+ with present or future macro names we are using to implement versioning
+*/
+
+// if you want the version checking to work on other OS/compiler, define
+// appropriate IMPL_DEPRECATED/IMPL_TOONEW
+// and define LLDB_API_CHECK_VERSIONING_WORKS when you are ready to go live
+#if defined(__APPLE__) && defined(__clang__)
+#define LLDB_API_IMPL_DEPRECATED __attribute__((deprecated))
+#define LLDB_API_IMPL_TOONEW __attribute__((unavailable))
+#define LLDB_API_CHECK_VERSIONING_WORKS
+#endif
+
+#if defined(LLDB_API_CHECK_VERSIONING) && \
+ !defined(LLDB_API_CHECK_VERSIONING_WORKS)
+#error \
+ "API version checking will not work here - please disable or create and submit patches to lldb-versioning.h"
+#endif
+
+#if defined(LLDB_API_CHECK_VERSIONING_WORKS) && \
+ (!defined(LLDB_API_IMPL_DEPRECATED) || !defined(LLDB_API_IMPL_TOONEW))
+#error \
+ "LLDB_API_CHECK_VERSIONING_WORKS needs LLDB_API_IMPL_DEPRECATED and LLDB_API_IMPL_TOONEW to be defined"
+#endif
+
+#if defined(LLDB_API_CHECK_VERSIONING) && \
+ defined(LLDB_API_MAJOR_VERSION_WANTED) && \
+ defined(LLDB_API_MINOR_VERSION_WANTED)
+
+#if defined(LLDB_API_MAJOR_VERSION) && \
+ (LLDB_API_MAJOR_VERSION != LLDB_API_MAJOR_VERSION_WANTED)
+#error \
+ "Cannot link using this LLDB version - public API versions are incompatible"
+#endif
+
+#define LLDB_API_MINOR_VERSION_DOT_0 0
+#define LLDB_API_MINOR_VERSION_DOT_1 1
+#define LLDB_API_MINOR_VERSION_DOT_2 2
+#define LLDB_API_MINOR_VERSION_DOT_3 3
+#define LLDB_API_MINOR_VERSION_DOT_4 4
+#define LLDB_API_MINOR_VERSION_DOT_5 5
+#define LLDB_API_MINOR_VERSION_DOT_6 6
+#define LLDB_API_MINOR_VERSION_DOT_7 7
+#define LLDB_API_MINOR_VERSION_DOT_8 8
+#define LLDB_API_MINOR_VERSION_DOT_9 9
+#define LLDB_API_MINOR_VERSION_DOT_10 10
+#define LLDB_API_MINOR_VERSION_DOT_11 11
+#define LLDB_API_MINOR_VERSION_DOT_12 12
+#define LLDB_API_MINOR_VERSION_DOT_13 13
+#define LLDB_API_MINOR_VERSION_DOT_14 14
+#define LLDB_API_MINOR_VERSION_DOT_15 15
+#define LLDB_API_MINOR_VERSION_DOT_16 16
+#define LLDB_API_MINOR_VERSION_DOT_17 17
+#define LLDB_API_MINOR_VERSION_DOT_18 18
+#define LLDB_API_MINOR_VERSION_DOT_19 19
+#define LLDB_API_MINOR_VERSION_DOT_20 20
+#define LLDB_API_MINOR_VERSION_DOT_21 21
+#define LLDB_API_MINOR_VERSION_DOT_22 22
+#define LLDB_API_MINOR_VERSION_DOT_23 23
+#define LLDB_API_MINOR_VERSION_DOT_24 24
+#define LLDB_API_MINOR_VERSION_DOT_25 25
+#define LLDB_API_MINOR_VERSION_DOT_26 26
+#define LLDB_API_MINOR_VERSION_DOT_27 27
+#define LLDB_API_MINOR_VERSION_DOT_28 28
+#define LLDB_API_MINOR_VERSION_DOT_29 29
+#define LLDB_API_MINOR_VERSION_DOT_30 30
+#define LLDB_API_MINOR_VERSION_DOT_31 31
+#define LLDB_API_MINOR_VERSION_DOT_32 32
+#define LLDB_API_MINOR_VERSION_DOT_33 33
+#define LLDB_API_MINOR_VERSION_DOT_34 34
+#define LLDB_API_MINOR_VERSION_DOT_35 35
+#define LLDB_API_MINOR_VERSION_DOT_36 36
+#define LLDB_API_MINOR_VERSION_DOT_37 37
+#define LLDB_API_MINOR_VERSION_DOT_38 38
+#define LLDB_API_MINOR_VERSION_DOT_39 39
+#define LLDB_API_MINOR_VERSION_DOT_40 40
+#define LLDB_API_MINOR_VERSION_DOT_41 41
+#define LLDB_API_MINOR_VERSION_DOT_42 42
+#define LLDB_API_MINOR_VERSION_DOT_43 43
+#define LLDB_API_MINOR_VERSION_DOT_44 44
+#define LLDB_API_MINOR_VERSION_DOT_45 45
+#define LLDB_API_MINOR_VERSION_DOT_46 46
+#define LLDB_API_MINOR_VERSION_DOT_47 47
+#define LLDB_API_MINOR_VERSION_DOT_48 48
+#define LLDB_API_MINOR_VERSION_DOT_49 49
+#define LLDB_API_MINOR_VERSION_DOT_50 50
+#define LLDB_API_MINOR_VERSION_DOT_51 51
+#define LLDB_API_MINOR_VERSION_DOT_52 52
+#define LLDB_API_MINOR_VERSION_DOT_53 53
+#define LLDB_API_MINOR_VERSION_DOT_54 54
+#define LLDB_API_MINOR_VERSION_DOT_55 55
+#define LLDB_API_MINOR_VERSION_DOT_56 56
+#define LLDB_API_MINOR_VERSION_DOT_57 57
+#define LLDB_API_MINOR_VERSION_DOT_58 58
+#define LLDB_API_MINOR_VERSION_DOT_59 59
+#define LLDB_API_MINOR_VERSION_DOT_60 60
+#define LLDB_API_MINOR_VERSION_DOT_61 61
+#define LLDB_API_MINOR_VERSION_DOT_62 62
+#define LLDB_API_MINOR_VERSION_DOT_63 63
+#define LLDB_API_MINOR_VERSION_DOT_64 64
+#define LLDB_API_MINOR_VERSION_DOT_65 65
+#define LLDB_API_MINOR_VERSION_DOT_66 66
+#define LLDB_API_MINOR_VERSION_DOT_67 67
+#define LLDB_API_MINOR_VERSION_DOT_68 68
+#define LLDB_API_MINOR_VERSION_DOT_69 69
+#define LLDB_API_MINOR_VERSION_DOT_70 70
+#define LLDB_API_MINOR_VERSION_DOT_71 71
+#define LLDB_API_MINOR_VERSION_DOT_72 72
+#define LLDB_API_MINOR_VERSION_DOT_73 73
+#define LLDB_API_MINOR_VERSION_DOT_74 74
+#define LLDB_API_MINOR_VERSION_DOT_75 75
+#define LLDB_API_MINOR_VERSION_DOT_76 76
+#define LLDB_API_MINOR_VERSION_DOT_77 77
+#define LLDB_API_MINOR_VERSION_DOT_78 78
+#define LLDB_API_MINOR_VERSION_DOT_79 79
+#define LLDB_API_MINOR_VERSION_DOT_80 80
+#define LLDB_API_MINOR_VERSION_DOT_81 81
+#define LLDB_API_MINOR_VERSION_DOT_82 82
+#define LLDB_API_MINOR_VERSION_DOT_83 83
+#define LLDB_API_MINOR_VERSION_DOT_84 84
+#define LLDB_API_MINOR_VERSION_DOT_85 85
+#define LLDB_API_MINOR_VERSION_DOT_86 86
+#define LLDB_API_MINOR_VERSION_DOT_87 87
+#define LLDB_API_MINOR_VERSION_DOT_88 88
+#define LLDB_API_MINOR_VERSION_DOT_89 89
+#define LLDB_API_MINOR_VERSION_DOT_90 90
+#define LLDB_API_MINOR_VERSION_DOT_91 91
+#define LLDB_API_MINOR_VERSION_DOT_92 92
+#define LLDB_API_MINOR_VERSION_DOT_93 93
+#define LLDB_API_MINOR_VERSION_DOT_94 94
+#define LLDB_API_MINOR_VERSION_DOT_95 95
+#define LLDB_API_MINOR_VERSION_DOT_96 96
+#define LLDB_API_MINOR_VERSION_DOT_97 97
+#define LLDB_API_MINOR_VERSION_DOT_98 98
+#define LLDB_API_MINOR_VERSION_DOT_99 99
+
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_0
+#define LLDB_API_NEW_IN_DOT_0 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_0
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_0
+#define LLDB_API_DEPRECATED_IN_DOT_0 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_0
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_1
+#define LLDB_API_NEW_IN_DOT_1 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_1
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_1
+#define LLDB_API_DEPRECATED_IN_DOT_1 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_1
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_2
+#define LLDB_API_NEW_IN_DOT_2 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_2
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_2
+#define LLDB_API_DEPRECATED_IN_DOT_2 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_2
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_3
+#define LLDB_API_NEW_IN_DOT_3 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_3
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_3
+#define LLDB_API_DEPRECATED_IN_DOT_3 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_3
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_4
+#define LLDB_API_NEW_IN_DOT_4 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_4
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_4
+#define LLDB_API_DEPRECATED_IN_DOT_4 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_4
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_5
+#define LLDB_API_NEW_IN_DOT_5 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_5
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_5
+#define LLDB_API_DEPRECATED_IN_DOT_5 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_5
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_6
+#define LLDB_API_NEW_IN_DOT_6 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_6
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_6
+#define LLDB_API_DEPRECATED_IN_DOT_6 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_6
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_7
+#define LLDB_API_NEW_IN_DOT_7 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_7
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_7
+#define LLDB_API_DEPRECATED_IN_DOT_7 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_7
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_8
+#define LLDB_API_NEW_IN_DOT_8 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_8
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_8
+#define LLDB_API_DEPRECATED_IN_DOT_8 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_8
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_9
+#define LLDB_API_NEW_IN_DOT_9 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_9
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_9
+#define LLDB_API_DEPRECATED_IN_DOT_9 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_9
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_10
+#define LLDB_API_NEW_IN_DOT_10 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_10
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_10
+#define LLDB_API_DEPRECATED_IN_DOT_10 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_10
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_11
+#define LLDB_API_NEW_IN_DOT_11 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_11
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_11
+#define LLDB_API_DEPRECATED_IN_DOT_11 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_11
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_12
+#define LLDB_API_NEW_IN_DOT_12 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_12
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_12
+#define LLDB_API_DEPRECATED_IN_DOT_12 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_12
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_13
+#define LLDB_API_NEW_IN_DOT_13 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_13
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_13
+#define LLDB_API_DEPRECATED_IN_DOT_13 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_13
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_14
+#define LLDB_API_NEW_IN_DOT_14 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_14
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_14
+#define LLDB_API_DEPRECATED_IN_DOT_14 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_14
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_15
+#define LLDB_API_NEW_IN_DOT_15 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_15
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_15
+#define LLDB_API_DEPRECATED_IN_DOT_15 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_15
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_16
+#define LLDB_API_NEW_IN_DOT_16 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_16
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_16
+#define LLDB_API_DEPRECATED_IN_DOT_16 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_16
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_17
+#define LLDB_API_NEW_IN_DOT_17 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_17
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_17
+#define LLDB_API_DEPRECATED_IN_DOT_17 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_17
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_18
+#define LLDB_API_NEW_IN_DOT_18 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_18
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_18
+#define LLDB_API_DEPRECATED_IN_DOT_18 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_18
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_19
+#define LLDB_API_NEW_IN_DOT_19 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_19
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_19
+#define LLDB_API_DEPRECATED_IN_DOT_19 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_19
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_20
+#define LLDB_API_NEW_IN_DOT_20 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_20
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_20
+#define LLDB_API_DEPRECATED_IN_DOT_20 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_20
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_21
+#define LLDB_API_NEW_IN_DOT_21 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_21
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_21
+#define LLDB_API_DEPRECATED_IN_DOT_21 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_21
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_22
+#define LLDB_API_NEW_IN_DOT_22 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_22
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_22
+#define LLDB_API_DEPRECATED_IN_DOT_22 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_22
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_23
+#define LLDB_API_NEW_IN_DOT_23 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_23
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_23
+#define LLDB_API_DEPRECATED_IN_DOT_23 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_23
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_24
+#define LLDB_API_NEW_IN_DOT_24 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_24
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_24
+#define LLDB_API_DEPRECATED_IN_DOT_24 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_24
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_25
+#define LLDB_API_NEW_IN_DOT_25 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_25
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_25
+#define LLDB_API_DEPRECATED_IN_DOT_25 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_25
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_26
+#define LLDB_API_NEW_IN_DOT_26 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_26
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_26
+#define LLDB_API_DEPRECATED_IN_DOT_26 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_26
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_27
+#define LLDB_API_NEW_IN_DOT_27 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_27
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_27
+#define LLDB_API_DEPRECATED_IN_DOT_27 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_27
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_28
+#define LLDB_API_NEW_IN_DOT_28 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_28
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_28
+#define LLDB_API_DEPRECATED_IN_DOT_28 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_28
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_29
+#define LLDB_API_NEW_IN_DOT_29 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_29
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_29
+#define LLDB_API_DEPRECATED_IN_DOT_29 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_29
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_30
+#define LLDB_API_NEW_IN_DOT_30 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_30
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_30
+#define LLDB_API_DEPRECATED_IN_DOT_30 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_30
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_31
+#define LLDB_API_NEW_IN_DOT_31 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_31
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_31
+#define LLDB_API_DEPRECATED_IN_DOT_31 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_31
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_32
+#define LLDB_API_NEW_IN_DOT_32 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_32
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_32
+#define LLDB_API_DEPRECATED_IN_DOT_32 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_32
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_33
+#define LLDB_API_NEW_IN_DOT_33 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_33
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_33
+#define LLDB_API_DEPRECATED_IN_DOT_33 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_33
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_34
+#define LLDB_API_NEW_IN_DOT_34 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_34
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_34
+#define LLDB_API_DEPRECATED_IN_DOT_34 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_34
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_35
+#define LLDB_API_NEW_IN_DOT_35 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_35
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_35
+#define LLDB_API_DEPRECATED_IN_DOT_35 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_35
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_36
+#define LLDB_API_NEW_IN_DOT_36 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_36
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_36
+#define LLDB_API_DEPRECATED_IN_DOT_36 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_36
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_37
+#define LLDB_API_NEW_IN_DOT_37 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_37
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_37
+#define LLDB_API_DEPRECATED_IN_DOT_37 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_37
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_38
+#define LLDB_API_NEW_IN_DOT_38 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_38
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_38
+#define LLDB_API_DEPRECATED_IN_DOT_38 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_38
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_39
+#define LLDB_API_NEW_IN_DOT_39 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_39
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_39
+#define LLDB_API_DEPRECATED_IN_DOT_39 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_39
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_40
+#define LLDB_API_NEW_IN_DOT_40 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_40
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_40
+#define LLDB_API_DEPRECATED_IN_DOT_40 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_40
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_41
+#define LLDB_API_NEW_IN_DOT_41 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_41
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_41
+#define LLDB_API_DEPRECATED_IN_DOT_41 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_41
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_42
+#define LLDB_API_NEW_IN_DOT_42 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_42
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_42
+#define LLDB_API_DEPRECATED_IN_DOT_42 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_42
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_43
+#define LLDB_API_NEW_IN_DOT_43 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_43
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_43
+#define LLDB_API_DEPRECATED_IN_DOT_43 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_43
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_44
+#define LLDB_API_NEW_IN_DOT_44 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_44
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_44
+#define LLDB_API_DEPRECATED_IN_DOT_44 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_44
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_45
+#define LLDB_API_NEW_IN_DOT_45 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_45
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_45
+#define LLDB_API_DEPRECATED_IN_DOT_45 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_45
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_46
+#define LLDB_API_NEW_IN_DOT_46 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_46
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_46
+#define LLDB_API_DEPRECATED_IN_DOT_46 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_46
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_47
+#define LLDB_API_NEW_IN_DOT_47 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_47
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_47
+#define LLDB_API_DEPRECATED_IN_DOT_47 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_47
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_48
+#define LLDB_API_NEW_IN_DOT_48 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_48
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_48
+#define LLDB_API_DEPRECATED_IN_DOT_48 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_48
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_49
+#define LLDB_API_NEW_IN_DOT_49 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_49
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_49
+#define LLDB_API_DEPRECATED_IN_DOT_49 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_49
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_50
+#define LLDB_API_NEW_IN_DOT_50 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_50
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_50
+#define LLDB_API_DEPRECATED_IN_DOT_50 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_50
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_51
+#define LLDB_API_NEW_IN_DOT_51 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_51
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_51
+#define LLDB_API_DEPRECATED_IN_DOT_51 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_51
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_52
+#define LLDB_API_NEW_IN_DOT_52 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_52
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_52
+#define LLDB_API_DEPRECATED_IN_DOT_52 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_52
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_53
+#define LLDB_API_NEW_IN_DOT_53 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_53
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_53
+#define LLDB_API_DEPRECATED_IN_DOT_53 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_53
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_54
+#define LLDB_API_NEW_IN_DOT_54 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_54
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_54
+#define LLDB_API_DEPRECATED_IN_DOT_54 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_54
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_55
+#define LLDB_API_NEW_IN_DOT_55 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_55
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_55
+#define LLDB_API_DEPRECATED_IN_DOT_55 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_55
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_56
+#define LLDB_API_NEW_IN_DOT_56 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_56
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_56
+#define LLDB_API_DEPRECATED_IN_DOT_56 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_56
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_57
+#define LLDB_API_NEW_IN_DOT_57 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_57
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_57
+#define LLDB_API_DEPRECATED_IN_DOT_57 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_57
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_58
+#define LLDB_API_NEW_IN_DOT_58 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_58
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_58
+#define LLDB_API_DEPRECATED_IN_DOT_58 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_58
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_59
+#define LLDB_API_NEW_IN_DOT_59 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_59
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_59
+#define LLDB_API_DEPRECATED_IN_DOT_59 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_59
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_60
+#define LLDB_API_NEW_IN_DOT_60 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_60
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_60
+#define LLDB_API_DEPRECATED_IN_DOT_60 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_60
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_61
+#define LLDB_API_NEW_IN_DOT_61 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_61
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_61
+#define LLDB_API_DEPRECATED_IN_DOT_61 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_61
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_62
+#define LLDB_API_NEW_IN_DOT_62 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_62
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_62
+#define LLDB_API_DEPRECATED_IN_DOT_62 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_62
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_63
+#define LLDB_API_NEW_IN_DOT_63 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_63
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_63
+#define LLDB_API_DEPRECATED_IN_DOT_63 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_63
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_64
+#define LLDB_API_NEW_IN_DOT_64 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_64
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_64
+#define LLDB_API_DEPRECATED_IN_DOT_64 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_64
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_65
+#define LLDB_API_NEW_IN_DOT_65 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_65
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_65
+#define LLDB_API_DEPRECATED_IN_DOT_65 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_65
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_66
+#define LLDB_API_NEW_IN_DOT_66 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_66
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_66
+#define LLDB_API_DEPRECATED_IN_DOT_66 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_66
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_67
+#define LLDB_API_NEW_IN_DOT_67 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_67
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_67
+#define LLDB_API_DEPRECATED_IN_DOT_67 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_67
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_68
+#define LLDB_API_NEW_IN_DOT_68 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_68
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_68
+#define LLDB_API_DEPRECATED_IN_DOT_68 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_68
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_69
+#define LLDB_API_NEW_IN_DOT_69 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_69
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_69
+#define LLDB_API_DEPRECATED_IN_DOT_69 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_69
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_70
+#define LLDB_API_NEW_IN_DOT_70 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_70
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_70
+#define LLDB_API_DEPRECATED_IN_DOT_70 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_70
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_71
+#define LLDB_API_NEW_IN_DOT_71 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_71
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_71
+#define LLDB_API_DEPRECATED_IN_DOT_71 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_71
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_72
+#define LLDB_API_NEW_IN_DOT_72 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_72
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_72
+#define LLDB_API_DEPRECATED_IN_DOT_72 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_72
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_73
+#define LLDB_API_NEW_IN_DOT_73 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_73
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_73
+#define LLDB_API_DEPRECATED_IN_DOT_73 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_73
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_74
+#define LLDB_API_NEW_IN_DOT_74 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_74
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_74
+#define LLDB_API_DEPRECATED_IN_DOT_74 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_74
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_75
+#define LLDB_API_NEW_IN_DOT_75 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_75
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_75
+#define LLDB_API_DEPRECATED_IN_DOT_75 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_75
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_76
+#define LLDB_API_NEW_IN_DOT_76 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_76
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_76
+#define LLDB_API_DEPRECATED_IN_DOT_76 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_76
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_77
+#define LLDB_API_NEW_IN_DOT_77 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_77
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_77
+#define LLDB_API_DEPRECATED_IN_DOT_77 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_77
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_78
+#define LLDB_API_NEW_IN_DOT_78 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_78
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_78
+#define LLDB_API_DEPRECATED_IN_DOT_78 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_78
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_79
+#define LLDB_API_NEW_IN_DOT_79 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_79
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_79
+#define LLDB_API_DEPRECATED_IN_DOT_79 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_79
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_80
+#define LLDB_API_NEW_IN_DOT_80 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_80
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_80
+#define LLDB_API_DEPRECATED_IN_DOT_80 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_80
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_81
+#define LLDB_API_NEW_IN_DOT_81 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_81
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_81
+#define LLDB_API_DEPRECATED_IN_DOT_81 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_81
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_82
+#define LLDB_API_NEW_IN_DOT_82 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_82
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_82
+#define LLDB_API_DEPRECATED_IN_DOT_82 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_82
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_83
+#define LLDB_API_NEW_IN_DOT_83 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_83
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_83
+#define LLDB_API_DEPRECATED_IN_DOT_83 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_83
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_84
+#define LLDB_API_NEW_IN_DOT_84 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_84
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_84
+#define LLDB_API_DEPRECATED_IN_DOT_84 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_84
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_85
+#define LLDB_API_NEW_IN_DOT_85 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_85
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_85
+#define LLDB_API_DEPRECATED_IN_DOT_85 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_85
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_86
+#define LLDB_API_NEW_IN_DOT_86 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_86
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_86
+#define LLDB_API_DEPRECATED_IN_DOT_86 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_86
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_87
+#define LLDB_API_NEW_IN_DOT_87 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_87
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_87
+#define LLDB_API_DEPRECATED_IN_DOT_87 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_87
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_88
+#define LLDB_API_NEW_IN_DOT_88 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_88
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_88
+#define LLDB_API_DEPRECATED_IN_DOT_88 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_88
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_89
+#define LLDB_API_NEW_IN_DOT_89 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_89
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_89
+#define LLDB_API_DEPRECATED_IN_DOT_89 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_89
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_90
+#define LLDB_API_NEW_IN_DOT_90 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_90
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_90
+#define LLDB_API_DEPRECATED_IN_DOT_90 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_90
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_91
+#define LLDB_API_NEW_IN_DOT_91 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_91
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_91
+#define LLDB_API_DEPRECATED_IN_DOT_91 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_91
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_92
+#define LLDB_API_NEW_IN_DOT_92 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_92
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_92
+#define LLDB_API_DEPRECATED_IN_DOT_92 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_92
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_93
+#define LLDB_API_NEW_IN_DOT_93 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_93
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_93
+#define LLDB_API_DEPRECATED_IN_DOT_93 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_93
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_94
+#define LLDB_API_NEW_IN_DOT_94 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_94
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_94
+#define LLDB_API_DEPRECATED_IN_DOT_94 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_94
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_95
+#define LLDB_API_NEW_IN_DOT_95 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_95
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_95
+#define LLDB_API_DEPRECATED_IN_DOT_95 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_95
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_96
+#define LLDB_API_NEW_IN_DOT_96 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_96
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_96
+#define LLDB_API_DEPRECATED_IN_DOT_96 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_96
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_97
+#define LLDB_API_NEW_IN_DOT_97 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_97
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_97
+#define LLDB_API_DEPRECATED_IN_DOT_97 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_97
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_98
+#define LLDB_API_NEW_IN_DOT_98 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_98
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_98
+#define LLDB_API_DEPRECATED_IN_DOT_98 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_98
+#endif
+#if LLDB_API_MINOR_VERSION_WANTED < LLDB_API_MINOR_VERSION_DOT_99
+#define LLDB_API_NEW_IN_DOT_99 LLDB_API_IMPL_TOONEW
+#else
+#define LLDB_API_NEW_IN_DOT_99
+#endif
+
+#if LLDB_API_MINOR_VERSION_WANTED >= LLDB_API_MINOR_VERSION_DOT_99
+#define LLDB_API_DEPRECATED_IN_DOT_99 LLDB_API_IMPL_DEPRECATED
+#else
+#define LLDB_API_DEPRECATED_IN_DOT_99
+#endif
+
+#else // defined(LLDB_CHECK_API_VERSIONING) &&
+ // defined(LLDB_API_MAJOR_VERSION_WANTED) &&
+ // defined(LLDB_API_MINOR_VERSION_WANTED) && defined
+ // (LLDB_API_MAJOR_VERSION)
+
+#define LLDB_API_NEW_IN_DOT_0
+#define LLDB_API_DEPRECATED_IN_DOT_0
+#define LLDB_API_NEW_IN_DOT_1
+#define LLDB_API_DEPRECATED_IN_DOT_1
+#define LLDB_API_NEW_IN_DOT_2
+#define LLDB_API_DEPRECATED_IN_DOT_2
+#define LLDB_API_NEW_IN_DOT_3
+#define LLDB_API_DEPRECATED_IN_DOT_3
+#define LLDB_API_NEW_IN_DOT_4
+#define LLDB_API_DEPRECATED_IN_DOT_4
+#define LLDB_API_NEW_IN_DOT_5
+#define LLDB_API_DEPRECATED_IN_DOT_5
+#define LLDB_API_NEW_IN_DOT_6
+#define LLDB_API_DEPRECATED_IN_DOT_6
+#define LLDB_API_NEW_IN_DOT_7
+#define LLDB_API_DEPRECATED_IN_DOT_7
+#define LLDB_API_NEW_IN_DOT_8
+#define LLDB_API_DEPRECATED_IN_DOT_8
+#define LLDB_API_NEW_IN_DOT_9
+#define LLDB_API_DEPRECATED_IN_DOT_9
+#define LLDB_API_NEW_IN_DOT_10
+#define LLDB_API_DEPRECATED_IN_DOT_10
+#define LLDB_API_NEW_IN_DOT_11
+#define LLDB_API_DEPRECATED_IN_DOT_11
+#define LLDB_API_NEW_IN_DOT_12
+#define LLDB_API_DEPRECATED_IN_DOT_12
+#define LLDB_API_NEW_IN_DOT_13
+#define LLDB_API_DEPRECATED_IN_DOT_13
+#define LLDB_API_NEW_IN_DOT_14
+#define LLDB_API_DEPRECATED_IN_DOT_14
+#define LLDB_API_NEW_IN_DOT_15
+#define LLDB_API_DEPRECATED_IN_DOT_15
+#define LLDB_API_NEW_IN_DOT_16
+#define LLDB_API_DEPRECATED_IN_DOT_16
+#define LLDB_API_NEW_IN_DOT_17
+#define LLDB_API_DEPRECATED_IN_DOT_17
+#define LLDB_API_NEW_IN_DOT_18
+#define LLDB_API_DEPRECATED_IN_DOT_18
+#define LLDB_API_NEW_IN_DOT_19
+#define LLDB_API_DEPRECATED_IN_DOT_19
+#define LLDB_API_NEW_IN_DOT_20
+#define LLDB_API_DEPRECATED_IN_DOT_20
+#define LLDB_API_NEW_IN_DOT_21
+#define LLDB_API_DEPRECATED_IN_DOT_21
+#define LLDB_API_NEW_IN_DOT_22
+#define LLDB_API_DEPRECATED_IN_DOT_22
+#define LLDB_API_NEW_IN_DOT_23
+#define LLDB_API_DEPRECATED_IN_DOT_23
+#define LLDB_API_NEW_IN_DOT_24
+#define LLDB_API_DEPRECATED_IN_DOT_24
+#define LLDB_API_NEW_IN_DOT_25
+#define LLDB_API_DEPRECATED_IN_DOT_25
+#define LLDB_API_NEW_IN_DOT_26
+#define LLDB_API_DEPRECATED_IN_DOT_26
+#define LLDB_API_NEW_IN_DOT_27
+#define LLDB_API_DEPRECATED_IN_DOT_27
+#define LLDB_API_NEW_IN_DOT_28
+#define LLDB_API_DEPRECATED_IN_DOT_28
+#define LLDB_API_NEW_IN_DOT_29
+#define LLDB_API_DEPRECATED_IN_DOT_29
+#define LLDB_API_NEW_IN_DOT_30
+#define LLDB_API_DEPRECATED_IN_DOT_30
+#define LLDB_API_NEW_IN_DOT_31
+#define LLDB_API_DEPRECATED_IN_DOT_31
+#define LLDB_API_NEW_IN_DOT_32
+#define LLDB_API_DEPRECATED_IN_DOT_32
+#define LLDB_API_NEW_IN_DOT_33
+#define LLDB_API_DEPRECATED_IN_DOT_33
+#define LLDB_API_NEW_IN_DOT_34
+#define LLDB_API_DEPRECATED_IN_DOT_34
+#define LLDB_API_NEW_IN_DOT_35
+#define LLDB_API_DEPRECATED_IN_DOT_35
+#define LLDB_API_NEW_IN_DOT_36
+#define LLDB_API_DEPRECATED_IN_DOT_36
+#define LLDB_API_NEW_IN_DOT_37
+#define LLDB_API_DEPRECATED_IN_DOT_37
+#define LLDB_API_NEW_IN_DOT_38
+#define LLDB_API_DEPRECATED_IN_DOT_38
+#define LLDB_API_NEW_IN_DOT_39
+#define LLDB_API_DEPRECATED_IN_DOT_39
+#define LLDB_API_NEW_IN_DOT_40
+#define LLDB_API_DEPRECATED_IN_DOT_40
+#define LLDB_API_NEW_IN_DOT_41
+#define LLDB_API_DEPRECATED_IN_DOT_41
+#define LLDB_API_NEW_IN_DOT_42
+#define LLDB_API_DEPRECATED_IN_DOT_42
+#define LLDB_API_NEW_IN_DOT_43
+#define LLDB_API_DEPRECATED_IN_DOT_43
+#define LLDB_API_NEW_IN_DOT_44
+#define LLDB_API_DEPRECATED_IN_DOT_44
+#define LLDB_API_NEW_IN_DOT_45
+#define LLDB_API_DEPRECATED_IN_DOT_45
+#define LLDB_API_NEW_IN_DOT_46
+#define LLDB_API_DEPRECATED_IN_DOT_46
+#define LLDB_API_NEW_IN_DOT_47
+#define LLDB_API_DEPRECATED_IN_DOT_47
+#define LLDB_API_NEW_IN_DOT_48
+#define LLDB_API_DEPRECATED_IN_DOT_48
+#define LLDB_API_NEW_IN_DOT_49
+#define LLDB_API_DEPRECATED_IN_DOT_49
+#define LLDB_API_NEW_IN_DOT_50
+#define LLDB_API_DEPRECATED_IN_DOT_50
+#define LLDB_API_NEW_IN_DOT_51
+#define LLDB_API_DEPRECATED_IN_DOT_51
+#define LLDB_API_NEW_IN_DOT_52
+#define LLDB_API_DEPRECATED_IN_DOT_52
+#define LLDB_API_NEW_IN_DOT_53
+#define LLDB_API_DEPRECATED_IN_DOT_53
+#define LLDB_API_NEW_IN_DOT_54
+#define LLDB_API_DEPRECATED_IN_DOT_54
+#define LLDB_API_NEW_IN_DOT_55
+#define LLDB_API_DEPRECATED_IN_DOT_55
+#define LLDB_API_NEW_IN_DOT_56
+#define LLDB_API_DEPRECATED_IN_DOT_56
+#define LLDB_API_NEW_IN_DOT_57
+#define LLDB_API_DEPRECATED_IN_DOT_57
+#define LLDB_API_NEW_IN_DOT_58
+#define LLDB_API_DEPRECATED_IN_DOT_58
+#define LLDB_API_NEW_IN_DOT_59
+#define LLDB_API_DEPRECATED_IN_DOT_59
+#define LLDB_API_NEW_IN_DOT_60
+#define LLDB_API_DEPRECATED_IN_DOT_60
+#define LLDB_API_NEW_IN_DOT_61
+#define LLDB_API_DEPRECATED_IN_DOT_61
+#define LLDB_API_NEW_IN_DOT_62
+#define LLDB_API_DEPRECATED_IN_DOT_62
+#define LLDB_API_NEW_IN_DOT_63
+#define LLDB_API_DEPRECATED_IN_DOT_63
+#define LLDB_API_NEW_IN_DOT_64
+#define LLDB_API_DEPRECATED_IN_DOT_64
+#define LLDB_API_NEW_IN_DOT_65
+#define LLDB_API_DEPRECATED_IN_DOT_65
+#define LLDB_API_NEW_IN_DOT_66
+#define LLDB_API_DEPRECATED_IN_DOT_66
+#define LLDB_API_NEW_IN_DOT_67
+#define LLDB_API_DEPRECATED_IN_DOT_67
+#define LLDB_API_NEW_IN_DOT_68
+#define LLDB_API_DEPRECATED_IN_DOT_68
+#define LLDB_API_NEW_IN_DOT_69
+#define LLDB_API_DEPRECATED_IN_DOT_69
+#define LLDB_API_NEW_IN_DOT_70
+#define LLDB_API_DEPRECATED_IN_DOT_70
+#define LLDB_API_NEW_IN_DOT_71
+#define LLDB_API_DEPRECATED_IN_DOT_71
+#define LLDB_API_NEW_IN_DOT_72
+#define LLDB_API_DEPRECATED_IN_DOT_72
+#define LLDB_API_NEW_IN_DOT_73
+#define LLDB_API_DEPRECATED_IN_DOT_73
+#define LLDB_API_NEW_IN_DOT_74
+#define LLDB_API_DEPRECATED_IN_DOT_74
+#define LLDB_API_NEW_IN_DOT_75
+#define LLDB_API_DEPRECATED_IN_DOT_75
+#define LLDB_API_NEW_IN_DOT_76
+#define LLDB_API_DEPRECATED_IN_DOT_76
+#define LLDB_API_NEW_IN_DOT_77
+#define LLDB_API_DEPRECATED_IN_DOT_77
+#define LLDB_API_NEW_IN_DOT_78
+#define LLDB_API_DEPRECATED_IN_DOT_78
+#define LLDB_API_NEW_IN_DOT_79
+#define LLDB_API_DEPRECATED_IN_DOT_79
+#define LLDB_API_NEW_IN_DOT_80
+#define LLDB_API_DEPRECATED_IN_DOT_80
+#define LLDB_API_NEW_IN_DOT_81
+#define LLDB_API_DEPRECATED_IN_DOT_81
+#define LLDB_API_NEW_IN_DOT_82
+#define LLDB_API_DEPRECATED_IN_DOT_82
+#define LLDB_API_NEW_IN_DOT_83
+#define LLDB_API_DEPRECATED_IN_DOT_83
+#define LLDB_API_NEW_IN_DOT_84
+#define LLDB_API_DEPRECATED_IN_DOT_84
+#define LLDB_API_NEW_IN_DOT_85
+#define LLDB_API_DEPRECATED_IN_DOT_85
+#define LLDB_API_NEW_IN_DOT_86
+#define LLDB_API_DEPRECATED_IN_DOT_86
+#define LLDB_API_NEW_IN_DOT_87
+#define LLDB_API_DEPRECATED_IN_DOT_87
+#define LLDB_API_NEW_IN_DOT_88
+#define LLDB_API_DEPRECATED_IN_DOT_88
+#define LLDB_API_NEW_IN_DOT_89
+#define LLDB_API_DEPRECATED_IN_DOT_89
+#define LLDB_API_NEW_IN_DOT_90
+#define LLDB_API_DEPRECATED_IN_DOT_90
+#define LLDB_API_NEW_IN_DOT_91
+#define LLDB_API_DEPRECATED_IN_DOT_91
+#define LLDB_API_NEW_IN_DOT_92
+#define LLDB_API_DEPRECATED_IN_DOT_92
+#define LLDB_API_NEW_IN_DOT_93
+#define LLDB_API_DEPRECATED_IN_DOT_93
+#define LLDB_API_NEW_IN_DOT_94
+#define LLDB_API_DEPRECATED_IN_DOT_94
+#define LLDB_API_NEW_IN_DOT_95
+#define LLDB_API_DEPRECATED_IN_DOT_95
+#define LLDB_API_NEW_IN_DOT_96
+#define LLDB_API_DEPRECATED_IN_DOT_96
+#define LLDB_API_NEW_IN_DOT_97
+#define LLDB_API_DEPRECATED_IN_DOT_97
+#define LLDB_API_NEW_IN_DOT_98
+#define LLDB_API_DEPRECATED_IN_DOT_98
+#define LLDB_API_NEW_IN_DOT_99
+#define LLDB_API_DEPRECATED_IN_DOT_99
+#endif // defined(LLDB_CHECK_API_VERSIONING) &&
+ // defined(LLDB_API_MAJOR_VERSION_WANTED) &&
+ // defined(LLDB_API_MINOR_VERSION_WANTED) && defined
+ // (LLDB_API_MAJOR_VERSION)
+
+#endif // LLDB_lldb_versioning_h_
("-o \"script test.summary_file = '%s'\" " % summary_file) +
("-o \"script test.run('%s', '%s')\" " % (assembly, command)) +
("-o \"quit\" ") +
- (" -- %s %s > %s.log 2> %s.log.2" % (host, assembly, logfile, logfile)))
+ (" -- %s %s > %s.log 2>&1" % (host, assembly, logfile)))
runWithTimeout(cmd)
self.assertFalse(os.path.isfile(fail_flag))
#!/usr/bin/env bash
__ProjectRoot="$1"
-__NativeBinDir="$2"
+__Plugin="$2"
__ManagedBinDir="$3"
__LogFileDir="$4"
__BuildArch="$5"
-if [[ "$__ProjectRoot" = "" || "$__NativeBinDir" = "" || "$__ManagedBinDir" = "" || "$__LogFileDir" = "" ]]; then
- echo "Project root, bin or log directory required"
+if [[ "$__ProjectRoot" = "" || "$__Plugin" = "" || "$__ManagedBinDir" = "" || "$__LogFileDir" = "" ]]; then
+ echo "Project root, plugin or log directory required"
exit 1
fi
-__Plugin=$__NativeBinDir/libsosplugin.so
__Host=$__ProjectRoot/.dotnet/dotnet
__TestProgram=$__ManagedBinDir/TestDebuggee/netcoreapp2.0/TestDebuggee.dll
projects / platform / core / dotnet / diagnostics.git / commitdiff