From: Mike McLaughlin Date: Fri, 25 May 2018 23:21:19 +0000 (-0700) Subject: Fix MacOS lldb plugin build and tests. X-Git-Tag: submit/tizen/20190813.035844~97^2 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=d5c04e8fd9936d0c749986480b707c2b57d3ef0a;p=platform%2Fcore%2Fdotnet%2Fdiagnostics.git Fix MacOS lldb plugin build and tests. Add swift 4.0 include files to build plugin on MacOS. --- diff --git a/eng/build-native.sh b/eng/build-native.sh index 6d36189c6..fd120a023 100755 --- a/eng/build-native.sh +++ b/eng/build-native.sh @@ -362,7 +362,12 @@ fi # 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." diff --git a/eng/gen-buildsys-clang.sh b/eng/gen-buildsys-clang.sh index 413a4ab50..bec17f302 100755 --- a/eng/gen-buildsys-clang.sh +++ b/eng/gen-buildsys-clang.sh @@ -114,12 +114,6 @@ if [ $OS = "Linux" -o $OS = "FreeBSD" -o $OS = "OpenBSD" -o $OS = "NetBSD" -o $O 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 diff --git a/src/SOS/lldbplugin/CMakeLists.txt b/src/SOS/lldbplugin/CMakeLists.txt index edf6d84f6..86e4e1dab 100644 --- a/src/SOS/lldbplugin/CMakeLists.txt +++ b/src/SOS/lldbplugin/CMakeLists.txt @@ -19,40 +19,60 @@ set(ENABLE_LLDBPLUGIN ${CLR_CMAKE_PLATFORM_UNIX} CACHE BOOL "Enable building the 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 @@ -73,13 +93,17 @@ find_path(LLDB_H "lldb/API/LLDB.h" PATHS "/usr/local/llvm39/include") 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}") @@ -99,8 +123,8 @@ set(SOURCES _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 diff --git a/src/SOS/lldbplugin/swift/lldb/API/LLDB.h b/src/SOS/lldbplugin/swift/lldb/API/LLDB.h new file mode 100644 index 000000000..d8604cd07 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/LLDB.h @@ -0,0 +1,80 @@ +//===-- 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_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBAddress.h b/src/SOS/lldbplugin/swift/lldb/API/SBAddress.h new file mode 100644 index 000000000..ddbe5a742 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBAddress.h @@ -0,0 +1,122 @@ +//===-- 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 m_opaque_ap; +}; + +} // namespace lldb + +#endif // LLDB_SBAddress_h_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBAttachInfo.h b/src/SOS/lldbplugin/swift/lldb/API/SBAttachInfo.h new file mode 100644 index 000000000..6c3561615 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBAttachInfo.h @@ -0,0 +1,190 @@ +//===-- 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_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBBlock.h b/src/SOS/lldbplugin/swift/lldb/API/SBBlock.h new file mode 100644 index 000000000..112de9673 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBBlock.h @@ -0,0 +1,96 @@ +//===-- 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_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBBreakpoint.h b/src/SOS/lldbplugin/swift/lldb/API/SBBreakpoint.h new file mode 100644 index 000000000..56509c903 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBBreakpoint.h @@ -0,0 +1,182 @@ +//===-- 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 m_opaque_sp; +}; + +} // namespace lldb + +#endif // LLDB_SBBreakpoint_h_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBBreakpointLocation.h b/src/SOS/lldbplugin/swift/lldb/API/SBBreakpointLocation.h new file mode 100644 index 000000000..344c39c7b --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBBreakpointLocation.h @@ -0,0 +1,87 @@ +//===-- 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_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBBroadcaster.h b/src/SOS/lldbplugin/swift/lldb/API/SBBroadcaster.h new file mode 100644 index 000000000..3fc47af65 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBBroadcaster.h @@ -0,0 +1,83 @@ +//===-- 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_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBCommandInterpreter.h b/src/SOS/lldbplugin/swift/lldb/API/SBCommandInterpreter.h new file mode 100644 index 000000000..f68407174 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBCommandInterpreter.h @@ -0,0 +1,284 @@ +//===-- 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 + +// 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 + 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_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBCommandReturnObject.h b/src/SOS/lldbplugin/swift/lldb/API/SBCommandReturnObject.h new file mode 100644 index 000000000..c73e3f7cf --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBCommandReturnObject.h @@ -0,0 +1,113 @@ +//===-- 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 + +// C++ Includes +#include + +// 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 m_opaque_ap; +}; + +} // namespace lldb + +#endif // LLDB_SBCommandReturnObject_h_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBCommunication.h b/src/SOS/lldbplugin/swift/lldb/API/SBCommunication.h new file mode 100644 index 000000000..f0016275b --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBCommunication.h @@ -0,0 +1,82 @@ +//===-- 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_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBCompileUnit.h b/src/SOS/lldbplugin/swift/lldb/API/SBCompileUnit.h new file mode 100644 index 000000000..4d5f9f36f --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBCompileUnit.h @@ -0,0 +1,96 @@ +//===-- 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_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBData.h b/src/SOS/lldbplugin/swift/lldb/API/SBData.h new file mode 100644 index 000000000..7aa4ea0ff --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBData.h @@ -0,0 +1,156 @@ +//===-- 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_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBDebugger.h b/src/SOS/lldbplugin/swift/lldb/API/SBDebugger.h new file mode 100644 index 000000000..9084943b9 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBDebugger.h @@ -0,0 +1,273 @@ +//===-- 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 + +#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_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBDeclaration.h b/src/SOS/lldbplugin/swift/lldb/API/SBDeclaration.h new file mode 100644 index 000000000..42cf76963 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBDeclaration.h @@ -0,0 +1,70 @@ +//===-- 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 m_opaque_ap; +}; + +} // namespace lldb + +#endif // LLDB_SBDeclaration_h_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBDefines.h b/src/SOS/lldbplugin/swift/lldb/API/SBDefines.h new file mode 100644 index 000000000..25443c476 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBDefines.h @@ -0,0 +1,101 @@ +//===-- 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_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBError.h b/src/SOS/lldbplugin/swift/lldb/API/SBError.h new file mode 100644 index 000000000..5713756f1 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBError.h @@ -0,0 +1,89 @@ +//===-- 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 m_opaque_ap; + + void CreateIfNeeded(); +}; + +} // namespace lldb + +#endif // LLDB_SBError_h_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBEvent.h b/src/SOS/lldbplugin/swift/lldb/API/SBEvent.h new file mode 100644 index 000000000..ff15716d8 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBEvent.h @@ -0,0 +1,86 @@ +//===-- 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 +#include + +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_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBExecutionContext.h b/src/SOS/lldbplugin/swift/lldb/API/SBExecutionContext.h new file mode 100644 index 000000000..c19d539bc --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBExecutionContext.h @@ -0,0 +1,66 @@ +//===-- 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 +#include + +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_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBExpressionOptions.h b/src/SOS/lldbplugin/swift/lldb/API/SBExpressionOptions.h new file mode 100644 index 000000000..af5f0c506 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBExpressionOptions.h @@ -0,0 +1,123 @@ +//===-- 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 + +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 m_opaque_ap; +}; + +} // namespace lldb + +#endif // LLDB_SBExpressionOptions_h_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBFileSpec.h b/src/SOS/lldbplugin/swift/lldb/API/SBFileSpec.h new file mode 100644 index 000000000..a31d95abb --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBFileSpec.h @@ -0,0 +1,89 @@ +//===-- 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 m_opaque_ap; +}; + +} // namespace lldb + +#endif // LLDB_SBFileSpec_h_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBFileSpecList.h b/src/SOS/lldbplugin/swift/lldb/API/SBFileSpecList.h new file mode 100644 index 000000000..97f843adb --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBFileSpecList.h @@ -0,0 +1,58 @@ +//===-- 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 m_opaque_ap; +}; + +} // namespace lldb + +#endif // LLDB_SBFileSpecList_h_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBFrame.h b/src/SOS/lldbplugin/swift/lldb/API/SBFrame.h new file mode 100644 index 000000000..9aa611cd1 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBFrame.h @@ -0,0 +1,201 @@ +//===-- 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_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBFunction.h b/src/SOS/lldbplugin/swift/lldb/API/SBFunction.h new file mode 100644 index 000000000..936fcaaac --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBFunction.h @@ -0,0 +1,83 @@ +//===-- 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_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBHostOS.h b/src/SOS/lldbplugin/swift/lldb/API/SBHostOS.h new file mode 100644 index 000000000..1671917f8 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBHostOS.h @@ -0,0 +1,45 @@ +//===-- 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_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBInstruction.h b/src/SOS/lldbplugin/swift/lldb/API/SBInstruction.h new file mode 100644 index 000000000..0fc12eb61 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBInstruction.h @@ -0,0 +1,85 @@ +//===-- 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 + +// 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 m_opaque_sp; +}; + +} // namespace lldb + +#endif // LLDB_SBInstruction_h_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBInstructionList.h b/src/SOS/lldbplugin/swift/lldb/API/SBInstructionList.h new file mode 100644 index 000000000..29baef579 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBInstructionList.h @@ -0,0 +1,58 @@ +//===-- 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 + +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_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBLanguageRuntime.h b/src/SOS/lldbplugin/swift/lldb/API/SBLanguageRuntime.h new file mode 100644 index 000000000..3912f3524 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBLanguageRuntime.h @@ -0,0 +1,26 @@ +//===-- 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_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBLaunchInfo.h b/src/SOS/lldbplugin/swift/lldb/API/SBLaunchInfo.h new file mode 100644 index 000000000..1cece2351 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBLaunchInfo.h @@ -0,0 +1,153 @@ +//===-- 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_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBLineEntry.h b/src/SOS/lldbplugin/swift/lldb/API/SBLineEntry.h new file mode 100644 index 000000000..3d58ea827 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBLineEntry.h @@ -0,0 +1,77 @@ +//===-- 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 m_opaque_ap; +}; + +} // namespace lldb + +#endif // LLDB_SBLineEntry_h_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBListener.h b/src/SOS/lldbplugin/swift/lldb/API/SBListener.h new file mode 100644 index 000000000..a2f82a83c --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBListener.h @@ -0,0 +1,107 @@ +//===-- 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_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBMemoryRegionInfo.h b/src/SOS/lldbplugin/swift/lldb/API/SBMemoryRegionInfo.h new file mode 100644 index 000000000..297f877a6 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBMemoryRegionInfo.h @@ -0,0 +1,112 @@ +//===-- 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_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBMemoryRegionInfoList.h b/src/SOS/lldbplugin/swift/lldb/API/SBMemoryRegionInfoList.h new file mode 100644 index 000000000..883a2224c --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBMemoryRegionInfoList.h @@ -0,0 +1,50 @@ +//===-- 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 m_opaque_ap; +}; + +} // namespace lldb + +#endif // LLDB_SBMemoryRegionInfoList_h_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBModule.h b/src/SOS/lldbplugin/swift/lldb/API/SBModule.h new file mode 100644 index 000000000..5bc4529a7 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBModule.h @@ -0,0 +1,318 @@ +//===-- 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_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBModuleSpec.h b/src/SOS/lldbplugin/swift/lldb/API/SBModuleSpec.h new file mode 100644 index 000000000..1a862703a --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBModuleSpec.h @@ -0,0 +1,125 @@ +//===-- 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 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 m_opaque_ap; +}; + +} // namespace lldb + +#endif // LLDB_SBModuleSpec_h_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBPlatform.h b/src/SOS/lldbplugin/swift/lldb/API/SBPlatform.h new file mode 100644 index 000000000..3f7e1acb7 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBPlatform.h @@ -0,0 +1,166 @@ +//===-- 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 + +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 &func); + + lldb::PlatformSP m_opaque_sp; +}; + +} // namespace lldb + +#endif // LLDB_SBPlatform_h_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBProcess.h b/src/SOS/lldbplugin/swift/lldb/API/SBProcess.h new file mode 100644 index 000000000..fd95790c6 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBProcess.h @@ -0,0 +1,379 @@ +//===-- 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 + +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_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBQueue.h b/src/SOS/lldbplugin/swift/lldb/API/SBQueue.h new file mode 100644 index 000000000..53612c0a1 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBQueue.h @@ -0,0 +1,72 @@ +//===-- 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 + +#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 m_opaque_sp; +}; + +} // namespace lldb + +#endif // LLDB_SBQueue_h_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBQueueItem.h b/src/SOS/lldbplugin/swift/lldb/API/SBQueueItem.h new file mode 100644 index 000000000..78ca3ba02 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBQueueItem.h @@ -0,0 +1,48 @@ +//===-- 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_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBSection.h b/src/SOS/lldbplugin/swift/lldb/API/SBSection.h new file mode 100644 index 000000000..ffd8bf7c9 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBSection.h @@ -0,0 +1,104 @@ +//===-- 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_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBSourceManager.h b/src/SOS/lldbplugin/swift/lldb/API/SBSourceManager.h new file mode 100644 index 000000000..6f1c49504 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBSourceManager.h @@ -0,0 +1,50 @@ +//===-- 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 + +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 m_opaque_ap; +}; + +} // namespace lldb + +#endif // LLDB_SBSourceManager_h_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBStream.h b/src/SOS/lldbplugin/swift/lldb/API/SBStream.h new file mode 100644 index 000000000..68fcae21c --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBStream.h @@ -0,0 +1,104 @@ +//===-- 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 + +#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 m_opaque_ap; + bool m_is_file; +}; + +} // namespace lldb + +#endif // LLDB_SBStream_h_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBStringList.h b/src/SOS/lldbplugin/swift/lldb/API/SBStringList.h new file mode 100644 index 000000000..66b5172a0 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBStringList.h @@ -0,0 +1,62 @@ +//===-- 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 m_opaque_ap; +}; + +} // namespace lldb + +#endif // LLDB_SBStringList_h_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBStructuredData.h b/src/SOS/lldbplugin/swift/lldb/API/SBStructuredData.h new file mode 100644 index 000000000..9f0203bb2 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBStructuredData.h @@ -0,0 +1,45 @@ +//===-- 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 m_impl_up; +}; +} + +#endif /* SBStructuredData_h */ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBSymbol.h b/src/SOS/lldbplugin/swift/lldb/API/SBSymbol.h new file mode 100644 index 000000000..d17a4ccff --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBSymbol.h @@ -0,0 +1,89 @@ +//===-- 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_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBSymbolContext.h b/src/SOS/lldbplugin/swift/lldb/API/SBSymbolContext.h new file mode 100644 index 000000000..04ee15e8e --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBSymbolContext.h @@ -0,0 +1,82 @@ +//===-- 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 m_opaque_ap; +}; + +} // namespace lldb + +#endif // LLDB_SBSymbolContext_h_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBSymbolContextList.h b/src/SOS/lldbplugin/swift/lldb/API/SBSymbolContextList.h new file mode 100644 index 000000000..e7299dd53 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBSymbolContextList.h @@ -0,0 +1,57 @@ +//===-- 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 m_opaque_ap; +}; + +} // namespace lldb + +#endif // LLDB_SBSymbolContextList_h_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBTarget.h b/src/SOS/lldbplugin/swift/lldb/API/SBTarget.h new file mode 100644 index 000000000..2a738572c --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBTarget.h @@ -0,0 +1,860 @@ +//===-- 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 + // ". + 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_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBThread.h b/src/SOS/lldbplugin/swift/lldb/API/SBThread.h new file mode 100644 index 000000000..65ad45686 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBThread.h @@ -0,0 +1,224 @@ +//===-- 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 + +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_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBThreadCollection.h b/src/SOS/lldbplugin/swift/lldb/API/SBThreadCollection.h new file mode 100644 index 000000000..715b0826b --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBThreadCollection.h @@ -0,0 +1,56 @@ +//===-- 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_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBThreadPlan.h b/src/SOS/lldbplugin/swift/lldb/API/SBThreadPlan.h new file mode 100644 index 000000000..abc14bf8f --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBThreadPlan.h @@ -0,0 +1,115 @@ +//===-- 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 + +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_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBType.h b/src/SOS/lldbplugin/swift/lldb/API/SBType.h new file mode 100644 index 000000000..0dde02579 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBType.h @@ -0,0 +1,255 @@ +//===-- 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 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 m_opaque_ap; + friend class SBModule; + friend class SBCompileUnit; +}; + +} // namespace lldb + +#endif // LLDB_SBType_h_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBTypeCategory.h b/src/SOS/lldbplugin/swift/lldb/API/SBTypeCategory.h new file mode 100644 index 000000000..f44dfc451 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBTypeCategory.h @@ -0,0 +1,133 @@ +//===-- 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_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBTypeEnumMember.h b/src/SOS/lldbplugin/swift/lldb/API/SBTypeEnumMember.h new file mode 100644 index 000000000..f45c234d2 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBTypeEnumMember.h @@ -0,0 +1,80 @@ + +//===-- 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 m_opaque_ap; +}; + +} // namespace lldb + +#endif // LLDB_SBTypeEnumMember_h_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBTypeFilter.h b/src/SOS/lldbplugin/swift/lldb/API/SBTypeFilter.h new file mode 100644 index 000000000..19888ba7c --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBTypeFilter.h @@ -0,0 +1,73 @@ +//===-- 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_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBTypeFormat.h b/src/SOS/lldbplugin/swift/lldb/API/SBTypeFormat.h new file mode 100644 index 000000000..d0429e97f --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBTypeFormat.h @@ -0,0 +1,77 @@ +//===-- 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_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBTypeNameSpecifier.h b/src/SOS/lldbplugin/swift/lldb/API/SBTypeNameSpecifier.h new file mode 100644 index 000000000..2a4f09c20 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBTypeNameSpecifier.h @@ -0,0 +1,64 @@ +//===-- 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_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBTypeSummary.h b/src/SOS/lldbplugin/swift/lldb/API/SBTypeSummary.h new file mode 100644 index 000000000..c9ccdff83 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBTypeSummary.h @@ -0,0 +1,136 @@ +//===-- 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 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_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBTypeSynthetic.h b/src/SOS/lldbplugin/swift/lldb/API/SBTypeSynthetic.h new file mode 100644 index 000000000..2099df316 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBTypeSynthetic.h @@ -0,0 +1,83 @@ +//===-- 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_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBUnixSignals.h b/src/SOS/lldbplugin/swift/lldb/API/SBUnixSignals.h new file mode 100644 index 000000000..d44a508fb --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBUnixSignals.h @@ -0,0 +1,70 @@ +//===-- 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_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBValue.h b/src/SOS/lldbplugin/swift/lldb/API/SBValue.h new file mode 100644 index 000000000..5ef8915b5 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBValue.h @@ -0,0 +1,446 @@ +//===-- 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 ValueImplSP; + ValueImplSP m_opaque_sp; + + void SetSP(ValueImplSP impl_sp); +}; + +} // namespace lldb + +#endif // LLDB_SBValue_h_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBValueList.h b/src/SOS/lldbplugin/swift/lldb/API/SBValueList.h new file mode 100644 index 000000000..495b0140c --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBValueList.h @@ -0,0 +1,74 @@ +//===-- 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 m_opaque_ap; +}; + +} // namespace lldb + +#endif // LLDB_SBValueList_h_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBVariablesOptions.h b/src/SOS/lldbplugin/swift/lldb/API/SBVariablesOptions.h new file mode 100644 index 000000000..756da6439 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBVariablesOptions.h @@ -0,0 +1,77 @@ +//===-- 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 m_opaque_ap; +}; + +} // namespace lldb + +#endif // LLDB_SBValue_h_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SBWatchpoint.h b/src/SOS/lldbplugin/swift/lldb/API/SBWatchpoint.h new file mode 100644 index 000000000..284ec1239 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SBWatchpoint.h @@ -0,0 +1,80 @@ +//===-- 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_ diff --git a/src/SOS/lldbplugin/swift/lldb/API/SystemInitializerFull.h b/src/SOS/lldbplugin/swift/lldb/API/SystemInitializerFull.h new file mode 100644 index 000000000..9cfc6896d --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/API/SystemInitializerFull.h @@ -0,0 +1,38 @@ +//===-- 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 diff --git a/src/SOS/lldbplugin/swift/lldb/Utility/AnsiTerminal.h b/src/SOS/lldbplugin/swift/lldb/Utility/AnsiTerminal.h new file mode 100644 index 000000000..5eaf2fd0e --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/Utility/AnsiTerminal.h @@ -0,0 +1,136 @@ +//===---------------------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 + +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; +} +} +} diff --git a/src/SOS/lldbplugin/swift/lldb/Utility/CleanUp.h b/src/SOS/lldbplugin/swift/lldb/Utility/CleanUp.h new file mode 100644 index 000000000..0d7bc8d99 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/Utility/CleanUp.h @@ -0,0 +1,261 @@ +//===-- 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 + +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 fd(open("/tmp/a.txt", O_RDONLY, 0), -1, close); +// +// // malloc/free example +// CleanUp malloced_bytes(malloc(32), NULL, free); +//---------------------------------------------------------------------- +template class CleanUp { +public: + typedef T value_type; + typedef std::function 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 class CleanUp2 { +public: + typedef T value_type; + typedef std::function 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_ diff --git a/src/SOS/lldbplugin/swift/lldb/Utility/ConvertEnum.h b/src/SOS/lldbplugin/swift/lldb/Utility/ConvertEnum.h new file mode 100644 index 000000000..239247d6a --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/Utility/ConvertEnum.h @@ -0,0 +1,21 @@ +//===-- 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 diff --git a/src/SOS/lldbplugin/swift/lldb/Utility/Either.h b/src/SOS/lldbplugin/swift/lldb/Utility/Either.h new file mode 100644 index 000000000..f3913e217 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/Utility/Either.h @@ -0,0 +1,130 @@ +//===-- 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 + +namespace lldb_utility { +template 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 &rhs) { + switch (rhs.m_selected) { + case Selected::One: + m_t1 = rhs.GetAs().getValue(); + m_selected = Selected::One; + break; + case Selected::Two: + m_t2 = rhs.GetAs().getValue(); + m_selected = Selected::Two; + break; + } + } + + template ::value>::type + * = nullptr> + llvm::Optional GetAs() const { + switch (m_selected) { + case Selected::One: + return m_t1; + default: + return llvm::Optional(); + } + } + + template ::value>::type + * = nullptr> + llvm::Optional GetAs() const { + switch (m_selected) { + case Selected::Two: + return m_t2; + default: + return llvm::Optional(); + } + } + + template + ResultType Apply(std::function if_T1, + std::function 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 &rhs) { + return (GetAs() == rhs.GetAs()) && (GetAs() == rhs.GetAs()); + } + + 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 &operator=(const Either &rhs) { + switch (rhs.m_selected) { + case Selected::One: + m_t1 = rhs.GetAs().getValue(); + m_selected = Selected::One; + break; + case Selected::Two: + m_t2 = rhs.GetAs().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_ diff --git a/src/SOS/lldbplugin/swift/lldb/Utility/Iterable.h b/src/SOS/lldbplugin/swift/lldb/Utility/Iterable.h new file mode 100644 index 000000000..dcb340a05 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/Utility/Iterable.h @@ -0,0 +1,202 @@ +//===-- 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 + +// Other libraries and framework includes +// Project includes + +namespace lldb_private { + +template E map_adapter(I &iter) { + return iter->second; +} + +template E vector_adapter(I &iter) { return *iter; } + +template E list_adapter(I &iter) { return *iter; } + +template +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 + friend AdaptedConstIterator + operator+(typename C1::const_iterator::difference_type, + AdaptedConstIterator &); + + template + friend typename C1::const_iterator::difference_type + operator-(AdaptedConstIterator &, + AdaptedConstIterator &); + + template + friend void swap(AdaptedConstIterator &, + AdaptedConstIterator &); + +private: + BackingIterator m_iter; +}; + +template +AdaptedConstIterator operator+( + typename AdaptedConstIterator::BackingIterator::difference_type + offset, + AdaptedConstIterator &rhs) { + return rhs.operator+(offset); +} + +template +typename AdaptedConstIterator::BackingIterator::difference_type +operator-(AdaptedConstIterator &lhs, + AdaptedConstIterator &rhs) { + return (lhs.m_iter - rhs.m_iter); +} + +template +void swap(AdaptedConstIterator &lhs, + AdaptedConstIterator &rhs) { + std::swap(lhs.m_iter, rhs.m_iter); +} + +template +class AdaptedIterable { +private: + const C &m_container; + +public: + AdaptedIterable(const C &container) : m_container(container) {} + + AdaptedConstIterator begin() { + return AdaptedConstIterator(m_container.begin()); + } + + AdaptedConstIterator end() { + return AdaptedConstIterator(m_container.end()); + } +}; + +template +class LockingAdaptedIterable : public AdaptedIterable { +public: + LockingAdaptedIterable(C &container, MutexType &mutex) + : AdaptedIterable(container), m_mutex(&mutex) { + m_mutex->lock(); + } + + LockingAdaptedIterable(LockingAdaptedIterable &&rhs) + : AdaptedIterable(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_ diff --git a/src/SOS/lldbplugin/swift/lldb/Utility/JSON.h b/src/SOS/lldbplugin/swift/lldb/Utility/JSON.h new file mode 100644 index 000000000..145ef4868 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/Utility/JSON.h @@ -0,0 +1,286 @@ +//===---------------------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 +#include +#include +#include +#include +#include + +#include "llvm/Support/Casting.h" + +namespace lldb_private { + +class JSONValue { +public: + virtual void Write(Stream &s) = 0; + + typedef std::shared_ptr 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 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 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 ::value && + std::is_unsigned::value>::type * = nullptr> + explicit JSONNumber(T u) + : JSONValue(JSONValue::Kind::Number), m_data_type(DataType::Unsigned) { + m_data.m_unsigned = u; + } + + template ::value && + std::is_signed::value>::type * = nullptr> + explicit JSONNumber(T s) + : JSONValue(JSONValue::Kind::Number), m_data_type(DataType::Signed) { + m_data.m_signed = s; + } + + template ::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 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 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 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 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 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 SP; + + static bool classof(const JSONValue *V) { + return V->GetKind() == JSONValue::Kind::Array; + } + +private: + typedef std::vector 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_ diff --git a/src/SOS/lldbplugin/swift/lldb/Utility/LLDBAssert.h b/src/SOS/lldbplugin/swift/lldb/Utility/LLDBAssert.h new file mode 100644 index 000000000..328a4d4f9 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/Utility/LLDBAssert.h @@ -0,0 +1,28 @@ +//===----------------- 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 + +#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_ diff --git a/src/SOS/lldbplugin/swift/lldb/Utility/NameMatches.h b/src/SOS/lldbplugin/swift/lldb/Utility/NameMatches.h new file mode 100644 index 000000000..50ea7ba7f --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/Utility/NameMatches.h @@ -0,0 +1,21 @@ +//===-- 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 diff --git a/src/SOS/lldbplugin/swift/lldb/Utility/PriorityPointerPair.h b/src/SOS/lldbplugin/swift/lldb/Utility/PriorityPointerPair.h new file mode 100644 index 000000000..2bd369e78 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/Utility/PriorityPointerPair.h @@ -0,0 +1,86 @@ +//===-- 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. 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 class PriorityPointerPair { +public: + typedef T &reference_type; + typedef T *pointer_type; + + typedef typename std::shared_ptr 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_ diff --git a/src/SOS/lldbplugin/swift/lldb/Utility/ProcessStructReader.h b/src/SOS/lldbplugin/swift/lldb/Utility/ProcessStructReader.h new file mode 100644 index 000000000..eb5126329 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/Utility/ProcessStructReader.h @@ -0,0 +1,103 @@ +//===---------------------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 +#include +#include + +namespace lldb_private { +class ProcessStructReader { +protected: + struct FieldImpl { + CompilerType type; + size_t offset; + size_t size; + }; + + std::map 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(bit_offset / 8); + m_fields[const_name] = + FieldImpl{field_type, byte_index, static_cast(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 + 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_ diff --git a/src/SOS/lldbplugin/swift/lldb/Utility/PseudoTerminal.h b/src/SOS/lldbplugin/swift/lldb/Utility/PseudoTerminal.h new file mode 100644 index 000000000..fbe933434 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/Utility/PseudoTerminal.h @@ -0,0 +1,252 @@ +//===-- 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 +#include + +#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_ diff --git a/src/SOS/lldbplugin/swift/lldb/Utility/Range.h b/src/SOS/lldbplugin/swift/lldb/Utility/Range.h new file mode 100644 index 000000000..c13bc0d08 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/Utility/Range.h @@ -0,0 +1,61 @@ +//===--------------------- 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 +#include + +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_ diff --git a/src/SOS/lldbplugin/swift/lldb/Utility/RegisterNumber.h b/src/SOS/lldbplugin/swift/lldb/Utility/RegisterNumber.h new file mode 100644 index 000000000..b3845ac0d --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/Utility/RegisterNumber.h @@ -0,0 +1,62 @@ +//===-- 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 + +//-------------------------------------------------------------------- +/// 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 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 diff --git a/src/SOS/lldbplugin/swift/lldb/Utility/SafeMachO.h b/src/SOS/lldbplugin/swift/lldb/Utility/SafeMachO.h new file mode 100644 index 000000000..5da03c15d --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/Utility/SafeMachO.h @@ -0,0 +1,119 @@ +//===-- 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_ diff --git a/src/SOS/lldbplugin/swift/lldb/Utility/SelectHelper.h b/src/SOS/lldbplugin/swift/lldb/Utility/SelectHelper.h new file mode 100644 index 000000000..0251c8e72 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/Utility/SelectHelper.h @@ -0,0 +1,76 @@ +//===-- 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 + +// 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 m_fd_map; + llvm::Optional m_end_time; +}; + +#endif // liblldb_SelectHelper_h_ diff --git a/src/SOS/lldbplugin/swift/lldb/Utility/SharedCluster.h b/src/SOS/lldbplugin/swift/lldb/Utility/SharedCluster.h new file mode 100644 index 000000000..b01f702c2 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/Utility/SharedCluster.h @@ -0,0 +1,94 @@ +//===------------------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 +class shared_ptr_refcount : public lldb_private::imp::shared_count { +public: + template + 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 ClusterManager { +public: + ClusterManager() : m_objects(), m_external_ref(0), m_mutex() {} + + ~ClusterManager() { + for (typename llvm::SmallPtrSet::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 guard(m_mutex); + m_objects.insert(new_object); + } + + typename lldb_private::SharingPtr GetSharedPointer(T *desired_object) { + { + std::lock_guard 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( + desired_object, new imp::shared_ptr_refcount(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; + + llvm::SmallPtrSet m_objects; + int m_external_ref; + std::mutex m_mutex; +}; + +} // namespace lldb_private + +#endif // utility_SharedCluster_h_ diff --git a/src/SOS/lldbplugin/swift/lldb/Utility/SharingPtr.h b/src/SOS/lldbplugin/swift/lldb/Utility/SharingPtr.h new file mode 100644 index 000000000..4e91222b3 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/Utility/SharingPtr.h @@ -0,0 +1,624 @@ +//===---------------------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 +#include + +// 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 +#else +#include +#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 shared_owners_; +#endif + virtual ~shared_count(); + +private: + virtual void on_zero_shared() = 0; +}; + +template 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 void shared_ptr_pointer::on_zero_shared() { + delete data_; +} + +template class shared_ptr_emplace : public shared_count { + T data_; + +public: + shared_ptr_emplace() : data_() {} + + template shared_ptr_emplace(A0 &a0) : data_(a0) {} + + template + shared_ptr_emplace(A0 &a0, A1 &a1) : data_(a0, a1) {} + + template + shared_ptr_emplace(A0 &a0, A1 &a1, A2 &a2) : data_(a0, a1, a2) {} + + template + shared_ptr_emplace(A0 &a0, A1 &a1, A2 &a2, A3 &a3) : data_(a0, a1, a2, a3) {} + + template + 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 void shared_ptr_emplace::on_zero_shared() {} + +} // namespace imp + +template 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 explicit SharingPtr(Y *p); + template explicit SharingPtr(Y *p, imp::shared_count *ctrl_block); + template SharingPtr(const SharingPtr &r, element_type *p); + SharingPtr(const SharingPtr &r); + template SharingPtr(const SharingPtr &r); + + ~SharingPtr(); + + SharingPtr &operator=(const SharingPtr &r); + template SharingPtr &operator=(const SharingPtr &r); + + void swap(SharingPtr &r); + void reset(); + template 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 make_shared(); + + template static SharingPtr make_shared(A0 &); + + template static SharingPtr make_shared(A0 &, A1 &); + + template + static SharingPtr make_shared(A0 &, A1 &, A2 &); + + template + static SharingPtr make_shared(A0 &, A1 &, A2 &, A3 &); + + template + static SharingPtr make_shared(A0 &, A1 &, A2 &, A3 &, A4 &); + +private: + template friend class SharingPtr; +}; + +template +inline SharingPtr::SharingPtr() : ptr_(nullptr), cntrl_(nullptr) {} + +template +inline SharingPtr::SharingPtr(std::nullptr_t) + : ptr_(nullptr), cntrl_(nullptr) {} + +template +template +SharingPtr::SharingPtr(Y *p) : ptr_(p), cntrl_(nullptr) { + std::unique_ptr hold(p); + typedef imp::shared_ptr_pointer _CntrlBlk; + cntrl_ = new _CntrlBlk(p); + hold.release(); +} + +template +template +SharingPtr::SharingPtr(Y *p, imp::shared_count *cntrl_block) + : ptr_(p), cntrl_(cntrl_block) {} + +template +template +inline SharingPtr::SharingPtr(const SharingPtr &r, element_type *p) + : ptr_(p), cntrl_(r.cntrl_) { + if (cntrl_) + cntrl_->add_shared(); +} + +template +inline SharingPtr::SharingPtr(const SharingPtr &r) + : ptr_(r.ptr_), cntrl_(r.cntrl_) { + if (cntrl_) + cntrl_->add_shared(); +} + +template +template +inline SharingPtr::SharingPtr(const SharingPtr &r) + : ptr_(r.ptr_), cntrl_(r.cntrl_) { + if (cntrl_) + cntrl_->add_shared(); +} + +template SharingPtr::~SharingPtr() { + if (cntrl_) + cntrl_->release_shared(); +} + +template +inline SharingPtr &SharingPtr::operator=(const SharingPtr &r) { + SharingPtr(r).swap(*this); + return *this; +} + +template +template +inline SharingPtr &SharingPtr::operator=(const SharingPtr &r) { + SharingPtr(r).swap(*this); + return *this; +} + +template inline void SharingPtr::swap(SharingPtr &r) { + std::swap(ptr_, r.ptr_); + std::swap(cntrl_, r.cntrl_); +} + +template inline void SharingPtr::reset() { + SharingPtr().swap(*this); +} + +template inline void SharingPtr::reset(std::nullptr_t p) { + reset(); +} + +template template inline void SharingPtr::reset(Y *p) { + SharingPtr(p).swap(*this); +} + +template SharingPtr SharingPtr::make_shared() { + typedef imp::shared_ptr_emplace CntrlBlk; + SharingPtr r; + r.cntrl_ = new CntrlBlk(); + r.ptr_ = static_cast(r.cntrl_)->get(); + return r; +} + +template +template +SharingPtr SharingPtr::make_shared(A0 &a0) { + typedef imp::shared_ptr_emplace CntrlBlk; + SharingPtr r; + r.cntrl_ = new CntrlBlk(a0); + r.ptr_ = static_cast(r.cntrl_)->get(); + return r; +} + +template +template +SharingPtr SharingPtr::make_shared(A0 &a0, A1 &a1) { + typedef imp::shared_ptr_emplace CntrlBlk; + SharingPtr r; + r.cntrl_ = new CntrlBlk(a0, a1); + r.ptr_ = static_cast(r.cntrl_)->get(); + return r; +} + +template +template +SharingPtr SharingPtr::make_shared(A0 &a0, A1 &a1, A2 &a2) { + typedef imp::shared_ptr_emplace CntrlBlk; + SharingPtr r; + r.cntrl_ = new CntrlBlk(a0, a1, a2); + r.ptr_ = static_cast(r.cntrl_)->get(); + return r; +} + +template +template +SharingPtr SharingPtr::make_shared(A0 &a0, A1 &a1, A2 &a2, A3 &a3) { + typedef imp::shared_ptr_emplace CntrlBlk; + SharingPtr r; + r.cntrl_ = new CntrlBlk(a0, a1, a2, a3); + r.ptr_ = static_cast(r.cntrl_)->get(); + return r; +} + +template +template +SharingPtr SharingPtr::make_shared(A0 &a0, A1 &a1, A2 &a2, A3 &a3, + A4 &a4) { + typedef imp::shared_ptr_emplace CntrlBlk; + SharingPtr r; + r.cntrl_ = new CntrlBlk(a0, a1, a2, a3, a4); + r.ptr_ = static_cast(r.cntrl_)->get(); + return r; +} + +template inline SharingPtr make_shared() { + return SharingPtr::make_shared(); +} + +template inline SharingPtr make_shared(A0 &a0) { + return SharingPtr::make_shared(a0); +} + +template +inline SharingPtr make_shared(A0 &a0, A1 &a1) { + return SharingPtr::make_shared(a0, a1); +} + +template +inline SharingPtr make_shared(A0 &a0, A1 &a1, A2 &a2) { + return SharingPtr::make_shared(a0, a1, a2); +} + +template +inline SharingPtr make_shared(A0 &a0, A1 &a1, A2 &a2, A3 &a3) { + return SharingPtr::make_shared(a0, a1, a2, a3); +} + +template +inline SharingPtr make_shared(A0 &a0, A1 &a1, A2 &a2, A3 &a3, A4 &a4) { + return SharingPtr::make_shared(a0, a1, a2, a3, a4); +} + +template +inline bool operator==(const SharingPtr &__x, const SharingPtr &__y) { + return __x.get() == __y.get(); +} + +template +inline bool operator!=(const SharingPtr &__x, const SharingPtr &__y) { + return !(__x == __y); +} + +template +inline bool operator<(const SharingPtr &__x, const SharingPtr &__y) { + return __x.get() < __y.get(); +} + +template inline void swap(SharingPtr &__x, SharingPtr &__y) { + __x.swap(__y); +} + +template +inline SharingPtr static_pointer_cast(const SharingPtr &r) { + return SharingPtr(r, static_cast(r.get())); +} + +template +SharingPtr const_pointer_cast(const SharingPtr &r) { + return SharingPtr(r, const_cast(r.get())); +} + +template class LoggingSharingPtr : public SharingPtr { + typedef SharingPtr 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 + LoggingSharingPtr(Y *p) : base(p), cb_(0), baton_(nullptr) {} + + template + 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 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 IntrusiveSharingPtr; + +template 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; + +private: + ReferenceCountedBase(const ReferenceCountedBase &); + ReferenceCountedBase &operator=(const ReferenceCountedBase &); +}; + +template void lldb_private::ReferenceCountedBase::add_shared() { +#ifdef _MSC_VER + _InterlockedIncrement(&shared_owners_); +#else + ++shared_owners_; +#endif +} + +template +void lldb_private::ReferenceCountedBase::release_shared() { +#ifdef _MSC_VER + if (_InterlockedDecrement(&shared_owners_) == -1) +#else + if (--shared_owners_ == -1) +#endif + delete static_cast(this); +} + +template +class ReferenceCountedBaseVirtual : public imp::shared_count { +public: + explicit ReferenceCountedBaseVirtual() : imp::shared_count(-1) {} + + ~ReferenceCountedBaseVirtual() override = default; + + void on_zero_shared() override; +}; + +template void ReferenceCountedBaseVirtual::on_zero_shared() {} + +template 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 + IntrusiveSharingPtr(const IntrusiveSharingPtr &rhs) : ptr_(rhs.get()) { + add_shared(); + } + + IntrusiveSharingPtr &operator=(const IntrusiveSharingPtr &rhs) { + reset(rhs.get()); + return *this; + } + + template + IntrusiveSharingPtr &operator=(const IntrusiveSharingPtr &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 +inline bool operator==(const IntrusiveSharingPtr &lhs, + const IntrusiveSharingPtr &rhs) { + return lhs.get() == rhs.get(); +} + +template +inline bool operator!=(const IntrusiveSharingPtr &lhs, + const IntrusiveSharingPtr &rhs) { + return lhs.get() != rhs.get(); +} + +template +inline bool operator==(const IntrusiveSharingPtr &lhs, U *rhs) { + return lhs.get() == rhs; +} + +template +inline bool operator!=(const IntrusiveSharingPtr &lhs, U *rhs) { + return lhs.get() != rhs; +} + +template +inline bool operator==(T *lhs, const IntrusiveSharingPtr &rhs) { + return lhs == rhs.get(); +} + +template +inline bool operator!=(T *lhs, const IntrusiveSharingPtr &rhs) { + return lhs != rhs.get(); +} + +} // namespace lldb_private + +#endif // utility_SharingPtr_h_ diff --git a/src/SOS/lldbplugin/swift/lldb/Utility/StringExtractor.h b/src/SOS/lldbplugin/swift/lldb/Utility/StringExtractor.h new file mode 100644 index 000000000..624d1ef3e --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/Utility/StringExtractor.h @@ -0,0 +1,136 @@ +//===-- 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 +#include + +// 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 dest, + uint8_t fail_fill_value); + + size_t GetHexBytesAvail(llvm::MutableArrayRef 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_ diff --git a/src/SOS/lldbplugin/swift/lldb/Utility/StringLexer.h b/src/SOS/lldbplugin/swift/lldb/Utility/StringLexer.h new file mode 100644 index 000000000..3a399dfd7 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/Utility/StringLexer.h @@ -0,0 +1,62 @@ +//===--------------------- 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 +#include +#include + +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 NextIf(std::initializer_list 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_ diff --git a/src/SOS/lldbplugin/swift/lldb/Utility/TaskPool.h b/src/SOS/lldbplugin/swift/lldb/Utility/TaskPool.h new file mode 100644 index 000000000..db15b2081 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/Utility/TaskPool.h @@ -0,0 +1,210 @@ +//===--------------------- 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 ensures that it is +// declared. This may not be necessary after MSVC 12. +#include +#endif + +#if defined(_MSC_VER) +// Due to another bug in MSVC 2013, including 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 +#include +#include +#include +#include +#include +#include + +// 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 + static std::future::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 static void RunTasks(T &&... tasks); + +private: + TaskPool() = delete; + + template struct RunTaskImpl; + + static void AddTaskImpl(std::function &&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 // 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 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 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> m_ready; + std::list> m_pending; + std::mutex m_mutex; + std::condition_variable m_cv; +}; + +template +std::future::type> +TaskPool::AddTask(F &&f, Args &&... args) { + auto task_sp = std::make_shared< + std::packaged_task::type()>>( + std::bind(std::forward(f), std::forward(args)...)); + + AddTaskImpl([task_sp]() { (*task_sp)(); }); + + return task_sp->get_future(); +} + +template void TaskPool::RunTasks(T &&... tasks) { + RunTaskImpl::Run(std::forward(tasks)...); +} + +template +struct TaskPool::RunTaskImpl { + static void Run(Head &&h, Tail &&... t) { + auto f = AddTask(std::forward(h)); + RunTaskImpl::Run(std::forward(t)...); + f.wait(); + } +}; + +template <> struct TaskPool::RunTaskImpl<> { + static void Run() {} +}; + +template +template +void TaskRunner::AddTask(F &&f, Args &&... args) { + std::unique_lock 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)...); + + std::unique_lock 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), std::forward(args)...)); +} + +template <> +template +void TaskRunner::AddTask(F &&f, Args &&... args) { + std::unique_lock 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)...); + + std::unique_lock 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), std::forward(args)...)); +} + +template std::future TaskRunner::WaitForNextCompletedTask() { + std::unique_lock lock(m_mutex); + if (m_ready.empty() && m_pending.empty()) + return std::future(); // No more tasks + + if (m_ready.empty()) + m_cv.wait(lock, [this]() { return !this->m_ready.empty(); }); + + std::future res = std::move(m_ready.front()); + m_ready.pop_front(); + + lock.unlock(); + res.wait(); + + return std::move(res); +} + +template void TaskRunner::WaitForAllTasks() { + while (WaitForNextCompletedTask().valid()) + ; +} + +#if defined(_MSC_VER) +#pragma warning(pop) +#endif + +#endif // #ifndef utility_TaskPool_h_ diff --git a/src/SOS/lldbplugin/swift/lldb/Utility/Timeout.h b/src/SOS/lldbplugin/swift/lldb/Utility/Timeout.h new file mode 100644 index 000000000..6c6fd009a --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/Utility/Timeout.h @@ -0,0 +1,55 @@ +//===-- 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 + +namespace lldb_private { + +// A general purpose class for representing timeouts for various APIs. It's +// basically an llvm::Optional>, but we +// customize it a bit to enable the standard chrono implicit conversions (e.g. +// from Timeout to Timeout. +// +// 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 +class Timeout : public llvm::Optional> { +private: + template using Dur = std::chrono::duration; + template + using EnableIf = std::enable_if< + std::is_convertible, + std::chrono::duration>::value>; + + using Base = llvm::Optional>; + +public: + Timeout(llvm::NoneType none) : Base(none) {} + Timeout(const Timeout &other) = default; + + template ::type> + Timeout(const Timeout &other) + : Base(other ? Base(Dur(*other)) : llvm::None) {} + + template ::type> + Timeout(const std::chrono::duration &other) + : Base(Dur(other)) {} +}; + +} // namespace lldb_private + +#endif // liblldb_Timeout_h_ diff --git a/src/SOS/lldbplugin/swift/lldb/Utility/Utils.h b/src/SOS/lldbplugin/swift/lldb/Utility/Utils.h new file mode 100644 index 000000000..46bc1847c --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/Utility/Utils.h @@ -0,0 +1,22 @@ +//===-- 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 diff --git a/src/SOS/lldbplugin/swift/lldb/lldb-defines.h b/src/SOS/lldbplugin/swift/lldb/lldb-defines.h new file mode 100644 index 000000000..a1318f441 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/lldb-defines.h @@ -0,0 +1,165 @@ +//===-- 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_ diff --git a/src/SOS/lldbplugin/swift/lldb/lldb-enumerations.h b/src/SOS/lldbplugin/swift/lldb/lldb-enumerations.h new file mode 100644 index 000000000..2e26d0b56 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/lldb-enumerations.h @@ -0,0 +1,1104 @@ +//===-- 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_ diff --git a/src/SOS/lldbplugin/swift/lldb/lldb-forward.h b/src/SOS/lldbplugin/swift/lldb/lldb-forward.h new file mode 100644 index 000000000..6614dfd8d --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/lldb-forward.h @@ -0,0 +1,495 @@ +//===-- 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 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 ABISP; +typedef std::shared_ptr BatonSP; +typedef std::shared_ptr BlockSP; +typedef std::shared_ptr BreakpointSP; +typedef std::weak_ptr BreakpointWP; +typedef std::shared_ptr BreakpointSiteSP; +typedef std::weak_ptr BreakpointSiteWP; +typedef std::shared_ptr BreakpointLocationSP; +typedef std::weak_ptr BreakpointLocationWP; +typedef std::shared_ptr BreakpointResolverSP; +typedef std::shared_ptr BroadcasterSP; +typedef std::shared_ptr BroadcasterManagerSP; +typedef std::weak_ptr BroadcasterManagerWP; +typedef std::unique_ptr ClangASTContextUP; +typedef std::shared_ptr ClangASTImporterSP; +typedef std::unique_ptr + ClangModulesDeclVendorUP; +typedef std::unique_ptr + ClangPersistentVariablesUP; +typedef std::shared_ptr UserExpressionSP; +typedef std::shared_ptr CommandObjectSP; +typedef std::shared_ptr CommunicationSP; +typedef std::shared_ptr ConnectionSP; +typedef std::shared_ptr CompUnitSP; +typedef std::shared_ptr DataBufferSP; +typedef std::shared_ptr DataExtractorSP; +typedef std::shared_ptr DebuggerSP; +typedef std::weak_ptr DebuggerWP; +typedef std::shared_ptr DisassemblerSP; +typedef std::unique_ptr + DynamicCheckerFunctionsUP; +typedef std::shared_ptr DynamicLoaderSP; +typedef std::unique_ptr DynamicLoaderUP; +typedef std::shared_ptr EventSP; +typedef std::shared_ptr EventDataSP; +typedef std::shared_ptr + EventDataStructuredDataSP; +typedef std::shared_ptr + ExecutionContextRefSP; +typedef std::shared_ptr ExpressionVariableSP; +typedef std::shared_ptr FileSP; +typedef std::shared_ptr FunctionSP; +typedef std::shared_ptr FunctionCallerSP; +typedef std::shared_ptr FuncUnwindersSP; +typedef std::unique_ptr GoASTContextUP; +typedef std::shared_ptr InlineFunctionInfoSP; +typedef std::shared_ptr InstructionSP; +typedef std::shared_ptr + InstrumentationRuntimeSP; +typedef std::shared_ptr IOHandlerSP; +typedef std::shared_ptr IOObjectSP; +typedef std::shared_ptr IRExecutionUnitSP; +typedef std::shared_ptr JITLoaderSP; +typedef std::unique_ptr JITLoaderListUP; +typedef std::shared_ptr LanguageRuntimeSP; +typedef std::shared_ptr SystemRuntimeSP; +typedef std::unique_ptr SystemRuntimeUP; +typedef std::shared_ptr LineTableSP; +typedef std::shared_ptr ListenerSP; +typedef std::weak_ptr ListenerWP; +typedef std::shared_ptr LogChannelSP; +typedef std::shared_ptr MemoryHistorySP; +typedef std::shared_ptr MemoryRegionInfoSP; +typedef std::unique_ptr MemoryRegionInfoUP; +typedef std::shared_ptr ModuleSP; +typedef std::weak_ptr ModuleWP; +typedef std::shared_ptr ObjectFileSP; +typedef std::weak_ptr ObjectFileWP; +typedef std::shared_ptr + ObjectFileJITDelegateSP; +typedef std::weak_ptr + ObjectFileJITDelegateWP; +typedef std::unique_ptr OperatingSystemUP; +typedef std::shared_ptr OptionValueSP; +typedef std::weak_ptr OptionValueWP; +typedef std::shared_ptr OptionValueArchSP; +typedef std::shared_ptr OptionValueArgsSP; +typedef std::shared_ptr OptionValueArraySP; +typedef std::shared_ptr OptionValueBooleanSP; +typedef std::shared_ptr + OptionValueDictionarySP; +typedef std::shared_ptr + OptionValueFileSpecSP; +typedef std::shared_ptr + OptionValueFileSpecListSP; +typedef std::shared_ptr OptionValueFormatSP; +typedef std::shared_ptr + OptionValuePathMappingsSP; +typedef std::shared_ptr + OptionValuePropertiesSP; +typedef std::shared_ptr OptionValueRegexSP; +typedef std::shared_ptr OptionValueSInt64SP; +typedef std::shared_ptr OptionValueStringSP; +typedef std::shared_ptr OptionValueUInt64SP; +typedef std::shared_ptr OptionValueUUIDSP; +typedef std::shared_ptr PlatformSP; +typedef std::shared_ptr ProcessSP; +typedef std::shared_ptr ProcessAttachInfoSP; +typedef std::shared_ptr ProcessLaunchInfoSP; +typedef std::weak_ptr ProcessWP; +typedef std::shared_ptr PropertySP; +typedef std::shared_ptr RegisterCheckpointSP; +typedef std::shared_ptr RegisterContextSP; +typedef std::shared_ptr RegularExpressionSP; +typedef std::shared_ptr QueueSP; +typedef std::weak_ptr QueueWP; +typedef std::shared_ptr QueueItemSP; +typedef std::shared_ptr REPLSP; +typedef std::shared_ptr + ScriptSummaryFormatSP; +typedef std::shared_ptr ScriptInterpreterSP; +typedef std::unique_ptr ScriptInterpreterUP; +typedef std::shared_ptr SectionSP; +typedef std::unique_ptr SectionListUP; +typedef std::weak_ptr SectionWP; +typedef std::shared_ptr SectionLoadListSP; +typedef std::shared_ptr SearchFilterSP; +typedef std::shared_ptr SettingsSP; +typedef std::shared_ptr SwiftASTContextSP; +typedef std::unique_ptr SourceManagerUP; +typedef std::shared_ptr StackFrameSP; +typedef std::unique_ptr StackFrameUP; +typedef std::weak_ptr StackFrameWP; +typedef std::shared_ptr StackFrameListSP; +typedef std::shared_ptr StopInfoSP; +typedef std::shared_ptr StoppointLocationSP; +typedef std::shared_ptr StreamSP; +typedef std::weak_ptr StreamWP; +typedef std::shared_ptr StreamFileSP; +typedef std::shared_ptr + StringTypeSummaryImplSP; +typedef std::shared_ptr + StructuredDataPluginSP; +typedef std::weak_ptr + StructuredDataPluginWP; +typedef std::shared_ptr SymbolFileSP; +typedef std::shared_ptr SymbolFileTypeSP; +typedef std::weak_ptr SymbolFileTypeWP; +typedef std::shared_ptr + SymbolContextSpecifierSP; +typedef std::unique_ptr SymbolVendorUP; +typedef std::shared_ptr SyntheticChildrenSP; +typedef std::shared_ptr + SyntheticChildrenFrontEndSP; +typedef std::shared_ptr TargetSP; +typedef std::weak_ptr TargetWP; +typedef std::shared_ptr TargetPropertiesSP; +typedef std::shared_ptr ThreadSP; +typedef std::weak_ptr ThreadWP; +typedef std::shared_ptr ThreadCollectionSP; +typedef std::shared_ptr ThreadPlanSP; +typedef std::shared_ptr ThreadPlanTracerSP; +typedef std::shared_ptr TypeSP; +typedef std::weak_ptr TypeWP; +typedef std::shared_ptr TypeCategoryImplSP; +typedef std::shared_ptr TypeImplSP; +typedef std::shared_ptr + TypeMemberFunctionImplSP; +typedef std::shared_ptr TypeEnumMemberImplSP; +typedef std::shared_ptr TypeFilterImplSP; +typedef std::shared_ptr TypeSystemSP; +typedef std::shared_ptr TypeFormatImplSP; +typedef std::shared_ptr + TypeNameSpecifierImplSP; +typedef std::shared_ptr TypeSummaryImplSP; +typedef std::shared_ptr TypeSummaryOptionsSP; +typedef std::shared_ptr TypeValidatorImplSP; +#ifndef LLDB_DISABLE_PYTHON +typedef std::shared_ptr + ScriptedSyntheticChildrenSP; +#endif +typedef std::shared_ptr UnixSignalsSP; +typedef std::weak_ptr UnixSignalsWP; +typedef std::shared_ptr UnwindAssemblySP; +typedef std::shared_ptr UnwindPlanSP; +typedef std::shared_ptr UtilityFunctionSP; +typedef lldb_private::SharingPtr ValueObjectSP; +typedef std::shared_ptr ValueSP; +typedef std::shared_ptr ValueListSP; +typedef std::shared_ptr VariableSP; +typedef std::shared_ptr VariableListSP; +typedef std::shared_ptr ValueObjectListSP; +typedef std::shared_ptr WatchpointSP; + +} // namespace lldb + +#endif // #if defined(__cplusplus) +#endif // LLDB_lldb_forward_h_ diff --git a/src/SOS/lldbplugin/swift/lldb/lldb-private-defines.h b/src/SOS/lldbplugin/swift/lldb/lldb-private-defines.h new file mode 100644 index 000000000..53c5f31ba --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/lldb-private-defines.h @@ -0,0 +1,38 @@ +//===-- 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_ diff --git a/src/SOS/lldbplugin/swift/lldb/lldb-private-enumerations.h b/src/SOS/lldbplugin/swift/lldb/lldb-private-enumerations.h new file mode 100644 index 000000000..d6e30b33b --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/lldb-private-enumerations.h @@ -0,0 +1,260 @@ +//===-- 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_ diff --git a/src/SOS/lldbplugin/swift/lldb/lldb-private-forward.h b/src/SOS/lldbplugin/swift/lldb/lldb-private-forward.h new file mode 100644 index 000000000..69a231132 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/lldb-private-forward.h @@ -0,0 +1,44 @@ +//===-- 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 + +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 NativeBreakpointSP; +typedef std::shared_ptr + NativeProcessProtocolSP; +typedef std::weak_ptr + NativeProcessProtocolWP; +typedef std::shared_ptr + NativeRegisterContextSP; +typedef std::shared_ptr + NativeThreadProtocolSP; +} + +#endif // #if defined(__cplusplus) +#endif // #ifndef LLDB_lldb_private_forward_h_ diff --git a/src/SOS/lldbplugin/swift/lldb/lldb-private-interfaces.h b/src/SOS/lldbplugin/swift/lldb/lldb-private-interfaces.h new file mode 100644 index 000000000..5b9d6ea92 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/lldb-private-interfaces.h @@ -0,0 +1,115 @@ +//===-- 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 + +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 &languages_for_types, + std::set &languages_for_expressions); +typedef void (*REPLEnumerateSupportedLanguages)( + std::set &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_ diff --git a/src/SOS/lldbplugin/swift/lldb/lldb-private-types.h b/src/SOS/lldbplugin/swift/lldb/lldb-private-types.h new file mode 100644 index 000000000..4f192b663 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/lldb-private-types.h @@ -0,0 +1,132 @@ +//===-- 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 data(const uint8_t *context_base) const { + return llvm::ArrayRef(context_base + byte_offset, byte_size); + } + + llvm::MutableArrayRef mutable_data(uint8_t *context_base) const { + return llvm::MutableArrayRef(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_ diff --git a/src/SOS/lldbplugin/swift/lldb/lldb-private.h b/src/SOS/lldbplugin/swift/lldb/lldb-private.h new file mode 100644 index 000000000..252ca09fa --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/lldb-private.h @@ -0,0 +1,29 @@ +//===-- 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_ diff --git a/src/SOS/lldbplugin/swift/lldb/lldb-public.h b/src/SOS/lldbplugin/swift/lldb/lldb-public.h new file mode 100644 index 000000000..290ff6e6d --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/lldb-public.h @@ -0,0 +1,18 @@ +//===-- 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_ diff --git a/src/SOS/lldbplugin/swift/lldb/lldb-types.h b/src/SOS/lldbplugin/swift/lldb/lldb-types.h new file mode 100644 index 000000000..07e9f5ac7 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/lldb-types.h @@ -0,0 +1,120 @@ +//===-- 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 +#include +#include + +//---------------------------------------------------------------------- +// 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 +#include +#endif + +#ifdef _WIN32 + +#include + +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 + +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_ diff --git a/src/SOS/lldbplugin/swift/lldb/lldb-versioning.h b/src/SOS/lldbplugin/swift/lldb/lldb-versioning.h new file mode 100644 index 000000000..b0af5dc64 --- /dev/null +++ b/src/SOS/lldbplugin/swift/lldb/lldb-versioning.h @@ -0,0 +1,1545 @@ +//===-- 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_ diff --git a/src/SOS/tests/test_libsosplugin.py b/src/SOS/tests/test_libsosplugin.py index a2d711c20..99aa3e9d9 100755 --- a/src/SOS/tests/test_libsosplugin.py +++ b/src/SOS/tests/test_libsosplugin.py @@ -66,7 +66,7 @@ class TestSosCommands(unittest.TestCase): ("-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)) diff --git a/src/SOS/tests/testsos.sh b/src/SOS/tests/testsos.sh index b1b9a02b7..1a134fdd9 100755 --- a/src/SOS/tests/testsos.sh +++ b/src/SOS/tests/testsos.sh @@ -1,16 +1,15 @@ #!/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