d/freebsd-skq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge lldb trunk r351319, resolve conflicts, and update FREEBSD-Xlist.

Browse Source
This commit is contained in:
dim 2019-01-20 15:00:15 +00:00
commit 2fc08b92b0
1161 changed files with 31789 additions and 31265 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

115
contrib/llvm/tools/lldb/FREEBSD-Xlist
View File

@ -5,7 +5,6 @@
CMakeLists.txt
CODE_OWNERS.txt
INSTALL.txt
Makefile
cmake/
docs/CMakeLists.txt
docs/building-with-debug-llvm.txt
@ -16,196 +15,166 @@ docs/doxygen.header
docs/doxygen.intro
docs/lldb-for-gdb-users.txt
docs/lldb-gdb-remote.txt
docs/lldb-platform-packets.txt
docs/structured_data/
docs/testsuite/
examples/
gtest/
include/Makefile
include/lldb/Host/Config.h
include/lldb/Host/android/
include/lldb/Host/linux/
include/lldb/Host/macosx/
include/lldb/Host/mingw/
include/lldb/Host/msvc/
include/lldb/Host/windows/
include/lldb/Makefile
lib/
lit/
lldb.xcodeproj/
lldb.xcworkspace/
packages/
resources/
scripts/
source/API/CMakeLists.txt
source/API/Makefile
source/Breakpoint/CMakeLists.txt
source/Breakpoint/Makefile
source/CMakeLists.txt
source/Commands/CMakeLists.txt
source/Commands/Makefile
source/Core/CMakeLists.txt
source/Core/Makefile
source/DataFormatters/CMakeLists.txt
source/DataFormatters/Makefile
source/Expression/CMakeLists.txt
source/Expression/Makefile
source/Host/CMakeLists.txt
source/Host/Makefile
source/Host/android/
source/Host/linux/
source/Host/macosx/
source/Host/windows/
source/Initialization/CMakeLists.txt
source/Initialization/Makefile
source/Interpreter/CMakeLists.txt
source/Interpreter/Makefile
source/Makefile
source/Plugins/ABI/CMakeLists.txt
source/Plugins/ABI/MacOSX-arm/CMakeLists.txt
source/Plugins/ABI/MacOSX-arm/Makefile
source/Plugins/ABI/MacOSX-arm64/CMakeLists.txt
source/Plugins/ABI/MacOSX-arm64/Makefile
source/Plugins/ABI/MacOSX-i386/CMakeLists.txt
source/Plugins/ABI/MacOSX-i386/Makefile
source/Plugins/ABI/SysV-arm/CMakeLists.txt
source/Plugins/ABI/SysV-arm/Makefile
source/Plugins/ABI/SysV-arm64/CMakeLists.txt
source/Plugins/ABI/SysV-arm64/Makefile
source/Plugins/ABI/SysV-hexagon/CMakeLists.txt
source/Plugins/ABI/SysV-hexagon/Makefile
source/Plugins/ABI/SysV-i386/CMakeLists.txt
source/Plugins/ABI/SysV-i386/Makefile
source/Plugins/ABI/SysV-mips/CMakeLists.txt
source/Plugins/ABI/SysV-mips/Makefile
source/Plugins/ABI/SysV-mips64/CMakeLists.txt
source/Plugins/ABI/SysV-mips64/Makefile
source/Plugins/ABI/SysV-ppc/CMakeLists.txt
source/Plugins/ABI/SysV-ppc/Makefile
source/Plugins/ABI/SysV-ppc64/CMakeLists.txt
source/Plugins/ABI/SysV-ppc64/Makefile
source/Plugins/ABI/SysV-s390x/CMakeLists.txt
source/Plugins/ABI/SysV-x86_64/CMakeLists.txt
source/Plugins/ABI/SysV-x86_64/Makefile
source/Plugins/Architecture/Arm/CMakeLists.txt
source/Plugins/Architecture/CMakeLists.txt
source/Plugins/Architecture/Mips/CMakeLists.txt
source/Plugins/Architecture/PPC64/CMakeLists.txt
source/Plugins/CMakeLists.txt
source/Plugins/Disassembler/CMakeLists.txt
source/Plugins/Disassembler/llvm/CMakeLists.txt
source/Plugins/Disassembler/llvm/Makefile
source/Plugins/DynamicLoader/CMakeLists.txt
source/Plugins/DynamicLoader/Darwin-Kernel/
source/Plugins/DynamicLoader/Hexagon-DYLD/CMakeLists.txt
source/Plugins/DynamicLoader/Hexagon-DYLD/Makefile
source/Plugins/DynamicLoader/MacOSX-DYLD/
source/Plugins/DynamicLoader/POSIX-DYLD/CMakeLists.txt
source/Plugins/DynamicLoader/POSIX-DYLD/Makefile
source/Plugins/DynamicLoader/Static/CMakeLists.txt
source/Plugins/DynamicLoader/Static/Makefile
source/Plugins/DynamicLoader/Windows-DYLD/CMakeLists.txt
source/Plugins/DynamicLoader/Windows-DYLD/Makefile
source/Plugins/ExpressionParser/CMakeLists.txt
source/Plugins/ExpressionParser/Clang/CMakeLists.txt
source/Plugins/Instruction/ARM/CMakeLists.txt
source/Plugins/Instruction/ARM/Makefile
source/Plugins/Instruction/ARM64/CMakeLists.txt
source/Plugins/Instruction/ARM64/Makefile
source/Plugins/Instruction/CMakeLists.txt
source/Plugins/Instruction/MIPS/CMakeLists.txt
source/Plugins/Instruction/MIPS/Makefile
source/Plugins/Instruction/MIPS64/CMakeLists.txt
source/Plugins/Instruction/MIPS64/Makefile
source/Plugins/InstrumentationRuntime/AddressSanitizer/CMakeLists.txt
source/Plugins/InstrumentationRuntime/AddressSanitizer/Makefile
source/Plugins/Instruction/PPC64/CMakeLists.txt
source/Plugins/InstrumentationRuntime/ASan/CMakeLists.txt
source/Plugins/InstrumentationRuntime/CMakeLists.txt
source/Plugins/InstrumentationRuntime/MainThreadChecker/CMakeLists.txt
source/Plugins/InstrumentationRuntime/TSan/CMakeLists.txt
source/Plugins/InstrumentationRuntime/UBSan/CMakeLists.txt
source/Plugins/JITLoader/CMakeLists.txt
source/Plugins/JITLoader/GDB/CMakeLists.txt
source/Plugins/JITLoader/GDB/Makefile
source/Plugins/Language/CMakeLists.txt
source/Plugins/Language/CPlusPlus/CMakeLists.txt
source/Plugins/Language/ClangCommon/CMakeLists.txt
source/Plugins/Language/ObjC/CMakeLists.txt
source/Plugins/Language/ObjCPlusPlus/CMakeLists.txt
source/Plugins/LanguageRuntime/CMakeLists.txt
source/Plugins/LanguageRuntime/CPlusPlus/CMakeLists.txt
source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/CMakeLists.txt
source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/Makefile
source/Plugins/LanguageRuntime/ObjC/
source/Plugins/LanguageRuntime/Go/CMakeLists.txt
source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/CMakeLists.txt
source/Plugins/LanguageRuntime/ObjC/CMakeLists.txt
source/Plugins/LanguageRuntime/RenderScript/CMakeLists.txt
source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/CMakeLists.txt
source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/Makefile
source/Plugins/Makefile
source/Plugins/MemoryHistory/CMakeLists.txt
source/Plugins/MemoryHistory/asan/CMakeLists.txt
source/Plugins/MemoryHistory/asan/Makefile
source/Plugins/ObjectContainer/BSD-Archive/CMakeLists.txt
source/Plugins/ObjectContainer/BSD-Archive/Makefile
source/Plugins/ObjectContainer/CMakeLists.txt
source/Plugins/ObjectContainer/Universal-Mach-O/
source/Plugins/ObjectFile/Breakpad/CMakeLists.txt
source/Plugins/ObjectFile/CMakeLists.txt
source/Plugins/ObjectFile/ELF/CMakeLists.txt
source/Plugins/ObjectFile/ELF/Makefile
source/Plugins/ObjectFile/JIT/CMakeLists.txt
source/Plugins/ObjectFile/JIT/Makefile
source/Plugins/ObjectFile/Mach-O/
source/Plugins/ObjectFile/PECOFF/
source/Plugins/OperatingSystem/CMakeLists.txt
source/Plugins/OperatingSystem/Python/CMakeLists.txt
source/Plugins/OperatingSystem/Python/Makefile
source/Plugins/Platform/Android/
source/Plugins/Platform/CMakeLists.txt
source/Plugins/Platform/FreeBSD/CMakeLists.txt
source/Plugins/Platform/FreeBSD/Makefile
source/Plugins/Platform/Kalimba/
source/Plugins/Platform/Linux/
source/Plugins/Platform/MacOSX/
source/Plugins/Platform/Makefile
source/Plugins/Platform/NetBSD/CMakeLists.txt
source/Plugins/Platform/OpenBSD/CMakeLists.txt
source/Plugins/Platform/POSIX/CMakeLists.txt
source/Plugins/Platform/POSIX/Makefile
source/Plugins/Platform/Windows/
source/Plugins/Platform/gdb-server/CMakeLists.txt
source/Plugins/Platform/gdb-server/Makefile
source/Plugins/Process/CMakeLists.txt
source/Plugins/Process/FreeBSD/CMakeLists.txt
source/Plugins/Process/FreeBSD/Makefile
source/Plugins/Process/Linux/
source/Plugins/Process/MacOSX-Kernel/
source/Plugins/Process/NetBSD/CMakeLists.txt
source/Plugins/Process/POSIX/CMakeLists.txt
source/Plugins/Process/POSIX/Makefile
source/Plugins/Process/Utility/CMakeLists.txt
source/Plugins/Process/Utility/Makefile
source/Plugins/Process/Windows/
source/Plugins/Process/elf-core/CMakeLists.txt
source/Plugins/Process/elf-core/Makefile
source/Plugins/Process/gdb-remote/CMakeLists.txt
source/Plugins/Process/gdb-remote/Makefile
source/Plugins/Process/mach-core/
source/Plugins/Process/minidump/CMakeLists.txt
source/Plugins/ScriptInterpreter/CMakeLists.txt
source/Plugins/ScriptInterpreter/None/CMakeLists.txt
source/Plugins/ScriptInterpreter/Python/CMakeLists.txt
source/Plugins/StructuredData/CMakeLists.txt
source/Plugins/StructuredData/DarwinLog/CMakeLists.txt
source/Plugins/SymbolFile/Breakpad/CMakeLists.txt
source/Plugins/SymbolFile/CMakeLists.txt
source/Plugins/SymbolFile/DWARF/CMakeLists.txt
source/Plugins/SymbolFile/DWARF/Makefile
source/Plugins/SymbolFile/NativePDB/CMakeLists.txt
source/Plugins/SymbolFile/PDB/CMakeLists.txt
source/Plugins/SymbolFile/Symtab/CMakeLists.txt
source/Plugins/SymbolFile/Symtab/Makefile
source/Plugins/SymbolVendor/CMakeLists.txt
source/Plugins/SymbolVendor/ELF/CMakeLists.txt
source/Plugins/SymbolVendor/ELF/Makefile
source/Plugins/SymbolVendor/MacOSX/
source/Plugins/SystemRuntime/
source/Plugins/UnwindAssembly/CMakeLists.txt
source/Plugins/UnwindAssembly/InstEmulation/CMakeLists.txt
source/Plugins/UnwindAssembly/InstEmulation/Makefile
source/Plugins/UnwindAssembly/x86/CMakeLists.txt
source/Plugins/UnwindAssembly/x86/Makefile
source/Symbol/CMakeLists.txt
source/Symbol/Makefile
source/Target/CMakeLists.txt
source/Target/Makefile
source/Utility/CMakeLists.txt
source/Utility/Makefile
test/
third_party/
tools/CMakeLists.txt
tools/Makefile
tools/argdumper/CMakeLists.txt
tools/darwin-debug/
tools/darwin-threads/
tools/debugserver/
tools/driver/CMakeLists.txt
tools/driver/Makefile
tools/driver/lldb-Info.plist
tools/install-headers/
tools/lldb-gdbserver/
tools/intel-features/
tools/lldb-mi/CMakeLists.txt
tools/lldb-mi/Makefile
tools/lldb-mi/lldb-Info.plist
tools/lldb-perf/
tools/lldb-platform/
tools/lldb-server/CMakeLists.txt
tools/lldb-server/Makefile
tools/lldb-test/
tools/lldb-vscode/
unittests/
use_lldb_suite_root.py
utils/
www/

4
contrib/llvm/tools/lldb/include/lldb/API/LLDB.h
View File

@ -10,10 +10,6 @@
#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"

1
contrib/llvm/tools/lldb/include/lldb/API/SBAddress.h
View File

@ -82,6 +82,7 @@ class LLDB_API SBAddress {
protected:
friend class SBBlock;
friend class SBBreakpoint;
friend class SBBreakpointLocation;
friend class SBFrame;
friend class SBFunction;

10
contrib/llvm/tools/lldb/include/lldb/API/SBBreakpoint.h
View File

@ -23,6 +23,8 @@ class LLDB_API SBBreakpoint {
SBBreakpoint(const lldb::SBBreakpoint &rhs);
SBBreakpoint(const lldb::BreakpointSP &bp_sp);
~SBBreakpoint();
const lldb::SBBreakpoint &operator=(const lldb::SBBreakpoint &rhs);
@ -127,14 +129,18 @@ class LLDB_API SBBreakpoint {
static uint32_t
GetNumBreakpointLocationsFromEvent(const lldb::SBEvent &event_sp);
bool IsHardware() const;
// Can only be called from a ScriptedBreakpointResolver...
SBError
AddLocation(SBAddress &address);
private:
friend class SBBreakpointList;
friend class SBBreakpointLocation;
friend class SBBreakpointName;
friend class SBTarget;
SBBreakpoint(const lldb::BreakpointSP &bp_sp);
lldb::BreakpointSP GetSP() const;
lldb::BreakpointWP m_opaque_wp;

22
contrib/llvm/tools/lldb/include/lldb/API/SBCommandInterpreter.h
View File

@ -10,12 +10,8 @@
#ifndef LLDB_SBCommandInterpreter_h_
#define LLDB_SBCommandInterpreter_h_
// C Includes
// C++ Includes
#include <memory>
// Other libraries and framework includes
// Project includes
#include "lldb/API/SBDebugger.h"
#include "lldb/API/SBDefines.h"
@ -45,6 +41,10 @@ class LLDB_API SBCommandInterpreterRunOptions {
void SetEchoCommands(bool);
bool GetEchoCommentCommands() const;
void SetEchoCommentCommands(bool echo);
bool GetPrintResults() const;
void SetPrintResults(bool);
@ -162,6 +162,20 @@ class SBCommandInterpreter {
int match_start_point, int max_return_elements,
lldb::SBStringList &matches);
// Same as HandleCompletion, but also fills out `descriptions` with
// descriptions for each match.
int HandleCompletionWithDescriptions(
const char *current_line, const char *cursor, const char *last_char,
int match_start_point, int max_return_elements,
lldb::SBStringList &matches, lldb::SBStringList &descriptions);
int HandleCompletionWithDescriptions(const char *current_line,
uint32_t cursor_pos,
int match_start_point,
int max_return_elements,
lldb::SBStringList &matches,
lldb::SBStringList &descriptions);
bool WasInterrupted() const;
// Catch commands before they execute by registering a callback that will get

4
contrib/llvm/tools/lldb/include/lldb/API/SBCommandReturnObject.h
View File

@ -10,14 +10,10 @@
#ifndef LLDB_SBCommandReturnObject_h_
#define LLDB_SBCommandReturnObject_h_
// C Includes
#include <stdio.h>
// C++ Includes
#include <memory>
// Other libraries and framework includes
// Project includes
#include "lldb/API/SBDefines.h"
namespace lldb {

6
contrib/llvm/tools/lldb/include/lldb/API/SBDebugger.h
View File

@ -13,6 +13,7 @@
#include <stdio.h>
#include "lldb/API/SBDefines.h"
#include "lldb/API/SBInitializerOptions.h"
#include "lldb/API/SBPlatform.h"
namespace lldb {
@ -45,6 +46,7 @@ class LLDB_API SBDebugger {
lldb::SBDebugger &operator=(const lldb::SBDebugger &rhs);
static void Initialize();
static lldb::SBError Initialize(SBInitializerOptions &options);
static void Terminate();
@ -109,7 +111,7 @@ class LLDB_API SBDebugger {
const char *archname);
lldb::SBTarget CreateTarget(const char *filename);
lldb::SBTarget GetDummyTarget();
// Return true if target is deleted from the target list of the debugger.
@ -226,6 +228,8 @@ class LLDB_API SBDebugger {
void SetPrompt(const char *prompt);
const char *GetReproducerPath() const;
lldb::ScriptLanguage GetScriptLanguage() const;
void SetScriptLanguage(lldb::ScriptLanguage script_lang);

5
contrib/llvm/tools/lldb/include/lldb/API/SBDefines.h
View File

@ -10,10 +10,6 @@
#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"
@ -55,6 +51,7 @@ class LLDB_API SBFileSpecList;
class LLDB_API SBFrame;
class LLDB_API SBFunction;
class LLDB_API SBHostOS;
class LLDB_API SBInitializerOptions;
class LLDB_API SBInstruction;
class LLDB_API SBInstructionList;
class LLDB_API SBLanguageRuntime;

6
contrib/llvm/tools/lldb/include/lldb/API/SBExpressionOptions.h
View File

@ -90,6 +90,12 @@ class LLDB_API SBExpressionOptions {
bool GetTopLevel();
void SetTopLevel(bool b = true);
// Gets whether we will JIT an expression if it cannot be interpreted
bool GetAllowJIT();
// Sets whether we will JIT an expression if it cannot be interpreted
void SetAllowJIT(bool allow);
protected:
SBExpressionOptions(

3
contrib/llvm/tools/lldb/include/lldb/API/SBFileSpec.h
View File

@ -59,6 +59,7 @@ class LLDB_API SBFileSpec {
friend class SBDeclaration;
friend class SBFileSpecList;
friend class SBHostOS;
friend class SBInitializerOptions;
friend class SBLaunchInfo;
friend class SBLineEntry;
friend class SBModule;
@ -67,8 +68,8 @@ class LLDB_API SBFileSpec {
friend class SBProcess;
friend class SBProcessInfo;
friend class SBSourceManager;
friend class SBThread;
friend class SBTarget;
friend class SBThread;
SBFileSpec(const lldb_private::FileSpec &fspec);

4
contrib/llvm/tools/lldb/include/lldb/API/SBFrame.h
View File

@ -90,6 +90,10 @@ class LLDB_API SBFrame {
bool IsInlined() const;
bool IsArtificial();
bool IsArtificial() const;
/// The version that doesn't supply a 'use_dynamic' value will use the
/// target's default.
lldb::SBValue EvaluateExpression(const char *expr);

43
contrib/llvm/tools/lldb/include/lldb/API/SBInitializerOptions.h Normal file
View File

@ -0,0 +1,43 @@
//===-- SBInitializerOptions.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_SBInitializerOptuions_h_
#define LLDB_SBInitializerOptuions_h_
#include "lldb/API/SBDefines.h"
#include "lldb/API/SBFileSpec.h"
namespace lldb_private {
struct InitializerOptions;
}
namespace lldb {
class LLDB_API SBInitializerOptions {
public:
SBInitializerOptions();
SBInitializerOptions(const lldb::SBInitializerOptions &rhs);
~SBInitializerOptions();
const SBInitializerOptions &operator=(const lldb::SBInitializerOptions &rhs);
void SetCaptureReproducer(bool b);
void SetReplayReproducer(bool b);
void SetReproducerPath(const char *path);
lldb_private::InitializerOptions &ref() const;
private:
friend class SBDebugger;
std::unique_ptr<lldb_private::InitializerOptions> m_opaque_up;
};
} // namespace lldb
#endif // LLDB_SBInitializerOptuions_h_

1
contrib/llvm/tools/lldb/include/lldb/API/SBMemoryRegionInfo.h
View File

@ -102,6 +102,7 @@ class LLDB_API SBMemoryRegionInfo {
const lldb_private::MemoryRegionInfo &ref() const;
// Unused.
SBMemoryRegionInfo(const lldb_private::MemoryRegionInfo *lldb_object_ptr);
lldb::MemoryRegionInfoUP m_opaque_ap;

6
contrib/llvm/tools/lldb/include/lldb/API/SBMemoryRegionInfoList.h
View File

@ -42,6 +42,12 @@ class LLDB_API SBMemoryRegionInfoList {
const MemoryRegionInfoListImpl &operator*() const;
private:
friend class SBProcess;
lldb_private::MemoryRegionInfos &ref();
const lldb_private::MemoryRegionInfos &ref() const;
std::unique_ptr<MemoryRegionInfoListImpl> m_opaque_ap;
};

1
contrib/llvm/tools/lldb/include/lldb/API/SBModule.h
View File

@ -309,6 +309,7 @@ class LLDB_API SBModule {
lldb::SBFileSpec GetSymbolFileSpec() const;
lldb::SBAddress GetObjectFileHeaderAddress() const;
lldb::SBAddress GetObjectFileEntryPointAddress() const;
private:
friend class SBAddress;

6
contrib/llvm/tools/lldb/include/lldb/API/SBProcess.h
View File

@ -318,11 +318,11 @@ class LLDB_API SBProcess {
/// library name and a list of paths, searching along the list of
/// paths till you find a matching library.
///
/// @param[in] local_spec
/// @param[in] image_spec
/// The name of the shared library that you want to load.
/// If local_spec is a relative path, the relative path will be
/// If image_spec is a relative path, the relative path will be
/// appended to the search paths.
/// If the local_spec is an absolute path, just the basename is used.
/// If the image_spec is an absolute path, just the basename is used.
///
/// @param[in] paths
/// A list of paths to search for the library whose basename is

10
contrib/llvm/tools/lldb/include/lldb/API/SBStructuredData.h
View File

@ -22,6 +22,8 @@ class SBStructuredData {
SBStructuredData(const lldb::SBStructuredData &rhs);
SBStructuredData(const lldb::EventSP &event_sp);
SBStructuredData(lldb_private::StructuredDataImpl *impl);
~SBStructuredData();
@ -41,7 +43,7 @@ class SBStructuredData {
/// Return the type of data in this data structure
//------------------------------------------------------------------
lldb::StructuredDataType GetType() const;
//------------------------------------------------------------------
/// Return the size (i.e. number of elements) in this data structure
/// if it is an array or dictionary type. For other types, 0 will be
@ -49,6 +51,12 @@ class SBStructuredData {
//------------------------------------------------------------------
size_t GetSize() const;
//------------------------------------------------------------------
/// Fill keys with the keys in this object and return true if this data
/// structure is a dictionary. Returns false otherwise.
//------------------------------------------------------------------
bool GetKeys(lldb::SBStringList &keys) const;
//------------------------------------------------------------------
/// Return the value corresponding to a key if this data structure
/// is a dictionary type.

4
contrib/llvm/tools/lldb/include/lldb/API/SBSymbolContext.h
View File

@ -26,6 +26,8 @@ class LLDB_API SBSymbolContext {
SBSymbolContext(const lldb::SBSymbolContext &rhs);
SBSymbolContext(const lldb_private::SymbolContext *sc_ptr);
~SBSymbolContext();
bool IsValid() const;
@ -69,8 +71,6 @@ class LLDB_API SBSymbolContext {
lldb_private::SymbolContext *get() const;
SBSymbolContext(const lldb_private::SymbolContext *sc_ptr);
void SetSymbolContext(const lldb_private::SymbolContext *sc_ptr);
private:

70
contrib/llvm/tools/lldb/include/lldb/API/SBTarget.h
View File

@ -10,10 +10,6 @@
#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"
@ -75,6 +71,31 @@ class LLDB_API SBTarget {
lldb::SBProcess GetProcess();
//------------------------------------------------------------------
/// Sets whether we should collect statistics on lldb or not.
///
/// @param[in] v
/// A boolean to control the collection.
/// @return
/// void
//------------------------------------------------------------------
void SetCollectingStats(bool v);
//------------------------------------------------------------------
/// Returns whether statistics collection are enabled.
///
/// @return
/// true if statistics are currently being collected, false
/// otherwise.
//------------------------------------------------------------------
bool GetCollectingStats();
//------------------------------------------------------------------
/// Returns a dump of the collected statistics.
///
/// @return
/// A SBStructuredData with the statistics collected.
//------------------------------------------------------------------
lldb::SBStructuredData GetStatistics();
//------------------------------------------------------------------
@ -272,6 +293,10 @@ class LLDB_API SBTarget {
lldb::SBFileSpec GetExecutable();
// Append the path mapping (from -> to) to the target's paths mapping list.
void AppendImageSearchPath(const char *from, const char *to,
lldb::SBError &error);
bool AddModule(lldb::SBModule &module);
lldb::SBModule AddModule(const char *path, const char *triple,
@ -576,6 +601,11 @@ class LLDB_API SBTarget {
BreakpointCreateByLocation(const lldb::SBFileSpec &file_spec, uint32_t line,
lldb::addr_t offset, SBFileSpecList &module_list);
lldb::SBBreakpoint
BreakpointCreateByLocation(const lldb::SBFileSpec &file_spec, uint32_t line,
uint32_t column, lldb::addr_t offset,
SBFileSpecList &module_list);
lldb::SBBreakpoint BreakpointCreateByName(const char *symbol_name,
const char *module_name = nullptr);
@ -653,6 +683,37 @@ class LLDB_API SBTarget {
lldb::SBBreakpoint BreakpointCreateByAddress(addr_t address);
lldb::SBBreakpoint BreakpointCreateBySBAddress(SBAddress &address);
//------------------------------------------------------------------
/// Create a breakpoint using a scripted resolver.
///
/// @param[in] class_name
/// This is the name of the class that implements a scripted resolver.
///
/// @param[in] extra_args
/// This is an SBStructuredData object that will get passed to the
/// constructor of the class in class_name. You can use this to
/// reuse the same class, parametrizing with entries from this
/// dictionary.
///
/// @param module_list
/// If this is non-empty, this will be used as the module filter in the
/// SearchFilter created for this breakpoint.
///
/// @param file_list
/// If this is non-empty, this will be used as the comp unit filter in the
/// SearchFilter created for this breakpoint.
///
/// @return
/// An SBBreakpoint that will set locations based on the logic in the
/// resolver's search callback.
//------------------------------------------------------------------
lldb::SBBreakpoint BreakpointCreateFromScript(
const char *class_name,
SBStructuredData &extra_args,
const SBFileSpecList &module_list,
const SBFileSpecList &file_list,
bool request_hardware = false);
//------------------------------------------------------------------
/// Read breakpoints from source_file and return the newly created
@ -842,6 +903,7 @@ class LLDB_API SBTarget {
friend class SBSourceManager;
friend class SBSymbol;
friend class SBValue;
friend class SBVariablesOptions;
//------------------------------------------------------------------
// Constructors are private, use static Target::Create function to create an

4
contrib/llvm/tools/lldb/include/lldb/API/SBThread.h
View File

@ -198,6 +198,10 @@ class LLDB_API SBThread {
uint32_t GetExtendedBacktraceOriginatingIndexID();
SBValue GetCurrentException();
SBThread GetCurrentExceptionBacktrace();
bool SafeToCallFunctions();
#ifndef SWIG

14
contrib/llvm/tools/lldb/include/lldb/API/SBThreadPlan.h
View File

@ -79,14 +79,28 @@ class LLDB_API SBThreadPlan {
// plans...
SBThreadPlan QueueThreadPlanForStepOverRange(SBAddress &start_address,
lldb::addr_t range_size);
SBThreadPlan QueueThreadPlanForStepOverRange(SBAddress &start_address,
lldb::addr_t range_size,
SBError &error);
SBThreadPlan QueueThreadPlanForStepInRange(SBAddress &start_address,
lldb::addr_t range_size);
SBThreadPlan QueueThreadPlanForStepInRange(SBAddress &start_address,
lldb::addr_t range_size,
SBError &error);
SBThreadPlan QueueThreadPlanForStepOut(uint32_t frame_idx_to_step_to,
bool first_insn = false);
SBThreadPlan QueueThreadPlanForStepOut(uint32_t frame_idx_to_step_to,
bool first_insn, SBError &error);
SBThreadPlan QueueThreadPlanForRunToAddress(SBAddress address);
SBThreadPlan QueueThreadPlanForRunToAddress(SBAddress address,
SBError &error);
SBThreadPlan QueueThreadPlanForStepScripted(const char *script_class_name);
SBThreadPlan QueueThreadPlanForStepScripted(const char *script_class_name,
SBError &error);
#ifndef SWIG
lldb_private::ThreadPlan *get();

4
contrib/llvm/tools/lldb/include/lldb/API/SBVariablesOptions.h
View File

@ -33,6 +33,10 @@ class LLDB_API SBVariablesOptions {
void SetIncludeArguments(bool);
bool GetIncludeRecognizedArguments(const lldb::SBTarget &) const;
void SetIncludeRecognizedArguments(bool);
bool GetIncludeLocals() const;
void SetIncludeLocals(bool);

14
contrib/llvm/tools/lldb/include/lldb/Breakpoint/Breakpoint.h
View File

@ -10,23 +10,19 @@
#ifndef liblldb_Breakpoint_h_
#define liblldb_Breakpoint_h_
// C Includes
// C++ Includes
#include <memory>
#include <string>
#include <unordered_set>
#include <vector>
// Other libraries and framework includes
// Project includes
#include "lldb/Breakpoint/BreakpointID.h"
#include "lldb/Breakpoint/BreakpointLocationCollection.h"
#include "lldb/Breakpoint/BreakpointLocationList.h"
#include "lldb/Breakpoint/BreakpointName.h"
#include "lldb/Breakpoint/BreakpointOptions.h"
#include "lldb/Breakpoint/Stoppoint.h"
#include "lldb/Core/Event.h"
#include "lldb/Core/SearchFilter.h"
#include "lldb/Utility/Event.h"
#include "lldb/Utility/StringList.h"
#include "lldb/Utility/StructuredData.h"
@ -502,6 +498,14 @@ class Breakpoint : public std::enable_shared_from_this<Breakpoint>,
//------------------------------------------------------------------
size_t GetNumResolvedLocations() const;
//------------------------------------------------------------------
/// Return whether this breakpoint has any resolved locations.
///
/// @return
/// True if GetNumResolvedLocations > 0
//------------------------------------------------------------------
bool HasResolvedLocations() const;
//------------------------------------------------------------------
/// Return the number of breakpoint locations.
///

4
contrib/llvm/tools/lldb/include/lldb/Breakpoint/BreakpointID.h
View File

@ -10,10 +10,6 @@
#ifndef liblldb_BreakpointID_h_
#define liblldb_BreakpointID_h_
// C Includes
// C++ Includes
// Other libraries and framework includes
// Project includes
#include "lldb/lldb-private.h"

4
contrib/llvm/tools/lldb/include/lldb/Breakpoint/BreakpointIDList.h
View File

@ -10,13 +10,9 @@
#ifndef liblldb_BreakpointIDList_h_
#define liblldb_BreakpointIDList_h_
// C Includes
// C++ Includes
#include <utility>
#include <vector>
// Other libraries and framework includes
// Project includes
#include "lldb/lldb-enumerations.h"
#include "lldb/Breakpoint/BreakpointID.h"

37
contrib/llvm/tools/lldb/include/lldb/Breakpoint/BreakpointList.h
View File

@ -10,13 +10,9 @@
#ifndef liblldb_BreakpointList_h_
#define liblldb_BreakpointList_h_
// C Includes
// C++ Includes
#include <list>
#include <mutex>
// Other libraries and framework includes
// Project includes
#include "lldb/Breakpoint/Breakpoint.h"
namespace lldb_private {
@ -53,18 +49,6 @@ class BreakpointList {
//------------------------------------------------------------------
void Dump(Stream *s) const;
//------------------------------------------------------------------
/// Returns a shared pointer to the breakpoint with id \a breakID.
///
/// @param[in] breakID
/// The breakpoint ID to seek for.
///
/// @result
/// A shared pointer to the breakpoint. May contain a NULL pointer if the
/// breakpoint doesn't exist.
//------------------------------------------------------------------
lldb::BreakpointSP FindBreakpointByID(lldb::break_id_t breakID);
//------------------------------------------------------------------
/// Returns a shared pointer to the breakpoint with id \a breakID. Const
/// version.
@ -76,7 +60,7 @@ class BreakpointList {
/// A shared pointer to the breakpoint. May contain a NULL pointer if the
/// breakpoint doesn't exist.
//------------------------------------------------------------------
const lldb::BreakpointSP FindBreakpointByID(lldb::break_id_t breakID) const;
lldb::BreakpointSP FindBreakpointByID(lldb::break_id_t breakID) const;
//------------------------------------------------------------------
/// Returns a shared pointer to the breakpoint with index \a i.
@ -88,20 +72,7 @@ class BreakpointList {
/// A shared pointer to the breakpoint. May contain a NULL pointer if the
/// breakpoint doesn't exist.
//------------------------------------------------------------------
lldb::BreakpointSP GetBreakpointAtIndex(size_t i);
//------------------------------------------------------------------
/// Returns a shared pointer to the breakpoint with index \a i, const
/// version
///
/// @param[in] i
/// The breakpoint index to seek for.
///
/// @result
/// A shared pointer to the breakpoint. May contain a NULL pointer if the
/// breakpoint doesn't exist.
//------------------------------------------------------------------
const lldb::BreakpointSP GetBreakpointAtIndex(size_t i) const;
lldb::BreakpointSP GetBreakpointAtIndex(size_t i) const;
//------------------------------------------------------------------
/// Find all the breakpoints with a given name
@ -201,7 +172,7 @@ class BreakpointList {
void GetListMutex(std::unique_lock<std::recursive_mutex> &lock);
protected:
typedef std::list<lldb::BreakpointSP> bp_collection;
typedef std::vector<lldb::BreakpointSP> bp_collection;
bp_collection::iterator GetBreakpointIDIterator(lldb::break_id_t breakID);
@ -211,7 +182,7 @@ class BreakpointList {
std::recursive_mutex &GetMutex() const { return m_mutex; }
mutable std::recursive_mutex m_mutex;
bp_collection m_breakpoints; // The breakpoint list, currently a list.
bp_collection m_breakpoints;
lldb::break_id_t m_next_break_id;
bool m_is_internal;

4
contrib/llvm/tools/lldb/include/lldb/Breakpoint/BreakpointLocation.h
View File

@ -10,13 +10,9 @@
#ifndef liblldb_BreakpointLocation_h_
#define liblldb_BreakpointLocation_h_
// C Includes
// C++ Includes
#include <memory>
#include <mutex>
// Other libraries and framework includes
// Project includes
#include "lldb/Breakpoint/BreakpointOptions.h"
#include "lldb/Breakpoint/StoppointLocation.h"
#include "lldb/Core/Address.h"

4
contrib/llvm/tools/lldb/include/lldb/Breakpoint/BreakpointLocationCollection.h
View File

@ -10,13 +10,9 @@
#ifndef liblldb_BreakpointLocationCollection_h_
#define liblldb_BreakpointLocationCollection_h_
// C Includes
// C++ Includes
#include <mutex>
#include <vector>
// Other libraries and framework includes
// Project includes
#include "lldb/Utility/Iterable.h"
#include "lldb/lldb-private.h"

4
contrib/llvm/tools/lldb/include/lldb/Breakpoint/BreakpointLocationList.h
View File

@ -10,14 +10,10 @@
#ifndef liblldb_BreakpointLocationList_h_
#define liblldb_BreakpointLocationList_h_
// C Includes
// C++ Includes
#include <map>
#include <mutex>
#include <vector>
// Other libraries and framework includes
// Project includes
#include "lldb/Core/Address.h"
#include "lldb/Utility/Iterable.h"
#include "lldb/lldb-private.h"

6
contrib/llvm/tools/lldb/include/lldb/Breakpoint/BreakpointName.h
View File

@ -10,22 +10,18 @@
#ifndef liblldb_Breakpoint_Name_h_
#define liblldb_Breakpoint_Name_h_
// C Includes
// C++ Includes
#include <memory>
#include <string>
#include <unordered_set>
#include <vector>
// Other libraries and framework includes
// Project includes
#include "lldb/Breakpoint/BreakpointID.h"
#include "lldb/Breakpoint/BreakpointLocationCollection.h"
#include "lldb/Breakpoint/BreakpointLocationList.h"
#include "lldb/Breakpoint/BreakpointOptions.h"
#include "lldb/Breakpoint/Stoppoint.h"
#include "lldb/Core/Event.h"
#include "lldb/Core/SearchFilter.h"
#include "lldb/Utility/Event.h"
#include "lldb/Utility/Flags.h"
#include "lldb/Utility/StringList.h"
#include "lldb/Utility/StructuredData.h"

4
contrib/llvm/tools/lldb/include/lldb/Breakpoint/BreakpointOptions.h
View File

@ -10,13 +10,9 @@
#ifndef liblldb_BreakpointOptions_h_
#define liblldb_BreakpointOptions_h_
// C Includes
// C++ Includes
#include <memory>
#include <string>
// Other libraries and framework includes
// Project includes
#include "lldb/Utility/Baton.h"
#include "lldb/Utility/Flags.h"
#include "lldb/Utility/StringList.h"

20
contrib/llvm/tools/lldb/include/lldb/Breakpoint/BreakpointResolver.h
View File

@ -10,10 +10,6 @@
#ifndef liblldb_BreakpointResolver_h_
#define liblldb_BreakpointResolver_h_
// C Includes
// C++ Includes
// Other libraries and framework includes
// Project includes
#include "lldb/Breakpoint/Breakpoint.h"
#include "lldb/Core/Address.h"
#include "lldb/Core/SearchFilter.h"
@ -158,6 +154,7 @@ class BreakpointResolver : public Searcher {
AddressResolver, // This is an instance of BreakpointResolverAddress
NameResolver, // This is an instance of BreakpointResolverName
FileRegexResolver,
PythonResolver,
ExceptionResolver,
LastKnownResolverType = ExceptionResolver,
UnknownResolver
@ -200,17 +197,23 @@ class BreakpointResolver : public Searcher {
Inlines,
LanguageName,
LineNumber,
Column,
ModuleName,
NameMaskArray,
Offset,
PythonClassName,
RegexString,
ScriptArgs,
SectionName,
SearchDepth,
SkipPrologue,
SymbolNameArray,
LastOptionName
};
static const char
*g_option_names[static_cast<uint32_t>(OptionNames::LastOptionName)];
virtual void NotifyBreakpointSet() {};
public:
static const char *GetKey(OptionNames enum_value) {
@ -224,8 +227,11 @@ class BreakpointResolver : public Searcher {
/// number that matches, and then filter down the matching addresses to
/// unique entries, and skip the prologue if asked to do so, and then set
/// breakpoint locations in this breakpoint for all the resultant addresses.
/// When \p column is nonzero the \p line and \p column args are used to
/// filter the results to find the first breakpoint >= (line, column).
void SetSCMatchesByLine(SearchFilter &filter, SymbolContextList &sc_list,
bool skip_prologue, llvm::StringRef log_ident);
bool skip_prologue, llvm::StringRef log_ident,
uint32_t line = 0, uint32_t column = 0);
void SetSCMatchesByLine(SearchFilter &, SymbolContextList &, bool,
const char *) = delete;
@ -237,6 +243,10 @@ class BreakpointResolver : public Searcher {
// breakpoints we set.
private:
/// Helper for \p SetSCMatchesByLine.
void AddLocation(SearchFilter &filter, const SymbolContext &sc,
bool skip_prologue, llvm::StringRef log_ident);
// Subclass identifier (for llvm isa/dyn_cast)
const unsigned char SubclassID;
DISALLOW_COPY_AND_ASSIGN(BreakpointResolver);

6
contrib/llvm/tools/lldb/include/lldb/Breakpoint/BreakpointResolverAddress.h
View File

@ -10,10 +10,6 @@
#ifndef liblldb_BreakpointResolverAddress_h_
#define liblldb_BreakpointResolverAddress_h_
// C Includes
// C++ Includes
// Other libraries and framework includes
// Project includes
#include "lldb/Breakpoint/BreakpointResolver.h"
#include "lldb/Core/ModuleSpec.h"
@ -51,7 +47,7 @@ class BreakpointResolverAddress : public BreakpointResolver {
SymbolContext &context, Address *addr,
bool containing) override;
Searcher::Depth GetDepth() override;
lldb::SearchDepth GetDepth() override;
void GetDescription(Stream *s) override;

21
contrib/llvm/tools/lldb/include/lldb/Breakpoint/BreakpointResolverFileLine.h
View File

@ -10,10 +10,6 @@
#ifndef liblldb_BreakpointResolverFileLine_h_
#define liblldb_BreakpointResolverFileLine_h_
// C Includes
// C++ Includes
// Other libraries and framework includes
// Project includes
#include "lldb/Breakpoint/BreakpointResolver.h"
namespace lldb_private {
@ -28,9 +24,9 @@ namespace lldb_private {
class BreakpointResolverFileLine : public BreakpointResolver {
public:
BreakpointResolverFileLine(Breakpoint *bkpt, const FileSpec &resolver,
uint32_t line_no, lldb::addr_t m_offset,
bool check_inlines, bool skip_prologue,
bool exact_match);
uint32_t line_no, uint32_t column,
lldb::addr_t m_offset, bool check_inlines,
bool skip_prologue, bool exact_match);
static BreakpointResolver *
CreateFromStructuredData(Breakpoint *bkpt,
@ -45,7 +41,7 @@ class BreakpointResolverFileLine : public BreakpointResolver {
SymbolContext &context, Address *addr,
bool containing) override;
Searcher::Depth GetDepth() override;
lldb::SearchDepth GetDepth() override;
void GetDescription(Stream *s) override;
@ -65,10 +61,11 @@ class BreakpointResolverFileLine : public BreakpointResolver {
void FilterContexts(SymbolContextList &sc_list, bool is_relative);
friend class Breakpoint;
FileSpec m_file_spec; // This is the file spec we are looking for.
uint32_t m_line_number; // This is the line number that we are looking for.
bool m_inlines; // This determines whether the resolver looks for inlined
// functions or not.
FileSpec m_file_spec; ///< This is the file spec we are looking for.
uint32_t m_line_number; ///< This is the line number that we are looking for.
uint32_t m_column; ///< This is the column that we are looking for.
bool m_inlines; ///< This determines whether the resolver looks for inlined
///< functions or not.
bool m_skip_prologue;
bool m_exact_match;

6
contrib/llvm/tools/lldb/include/lldb/Breakpoint/BreakpointResolverFileRegex.h
View File

@ -11,11 +11,7 @@
#ifndef liblldb_BreakpointResolverFileRegex_h_
#define liblldb_BreakpointResolverFileRegex_h_
// C Includes
// C++ Includes
#include <set>
// Other libraries and framework includes
// Project includes
#include "lldb/Breakpoint/BreakpointResolver.h"
#include "lldb/Utility/ConstString.h"
@ -47,7 +43,7 @@ class BreakpointResolverFileRegex : public BreakpointResolver {
SymbolContext &context, Address *addr,
bool containing) override;
Searcher::Depth GetDepth() override;
lldb::SearchDepth GetDepth() override;
void GetDescription(Stream *s) override;

20
contrib/llvm/tools/lldb/include/lldb/Breakpoint/BreakpointResolverName.h
View File

@ -10,13 +10,9 @@
#ifndef liblldb_BreakpointResolverName_h_
#define liblldb_BreakpointResolverName_h_
// C Includes
// C++ Includes
#include <string>
#include <vector>
// Other libraries and framework includes
// Project includes
#include "lldb/Breakpoint/BreakpointResolver.h"
#include "lldb/Core/Module.h"
@ -31,20 +27,23 @@ namespace lldb_private {
class BreakpointResolverName : public BreakpointResolver {
public:
BreakpointResolverName(Breakpoint *bkpt, const char *name,
uint32_t name_type_mask, lldb::LanguageType language,
lldb::FunctionNameType name_type_mask,
lldb::LanguageType language,
Breakpoint::MatchType type, lldb::addr_t offset,
bool skip_prologue);
// This one takes an array of names. It is always MatchType = Exact.
BreakpointResolverName(Breakpoint *bkpt, const char *names[],
size_t num_names, uint32_t name_type_mask,
size_t num_names,
lldb::FunctionNameType name_type_mask,
lldb::LanguageType language, lldb::addr_t offset,
bool skip_prologue);
// This one takes a C++ array of names. It is always MatchType = Exact.
BreakpointResolverName(Breakpoint *bkpt, std::vector<std::string> names,
uint32_t name_type_mask, lldb::LanguageType language,
lldb::addr_t offset, bool skip_prologue);
lldb::FunctionNameType name_type_mask,
lldb::LanguageType language, lldb::addr_t offset,
bool skip_prologue);
// Creates a function breakpoint by regular expression. Takes over control
// of the lifespan of func_regex.
@ -65,7 +64,7 @@ class BreakpointResolverName : public BreakpointResolver {
SymbolContext &context, Address *addr,
bool containing) override;
Searcher::Depth GetDepth() override;
lldb::SearchDepth GetDepth() override;
void GetDescription(Stream *s) override;
@ -89,7 +88,8 @@ class BreakpointResolverName : public BreakpointResolver {
lldb::LanguageType m_language;
bool m_skip_prologue;
void AddNameLookup(const ConstString &name, uint32_t name_type_mask);
void AddNameLookup(const ConstString &name,
lldb::FunctionNameType name_type_mask);
};
} // namespace lldb_private

81
contrib/llvm/tools/lldb/include/lldb/Breakpoint/BreakpointResolverScripted.h Normal file
View File

@ -0,0 +1,81 @@
//===-- BreakpointResolverScripted.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_BreakpointResolverScripted_h_
#define liblldb_BreakpointResolverScripted_h_
#include "lldb/lldb-forward.h"
#include "lldb/Breakpoint/BreakpointResolver.h"
#include "lldb/Core/ModuleSpec.h"
namespace lldb_private {
//----------------------------------------------------------------------
/// @class BreakpointResolverScripted BreakpointResolverScripted.h
/// "lldb/Breakpoint/BreakpointResolverScripted.h" This class sets breakpoints
/// on a given Address. This breakpoint only takes once, and then it won't
/// attempt to reset itself.
//----------------------------------------------------------------------
class BreakpointResolverScripted : public BreakpointResolver {
public:
BreakpointResolverScripted(Breakpoint *bkpt,
const llvm::StringRef class_name,
lldb::SearchDepth depth,
StructuredDataImpl *args_data,
ScriptInterpreter &script_interp);
~BreakpointResolverScripted() override;
static BreakpointResolver *
CreateFromStructuredData(Breakpoint *bkpt,
const StructuredData::Dictionary &options_dict,
Status &error);
StructuredData::ObjectSP SerializeToStructuredData() override;
Searcher::CallbackReturn SearchCallback(SearchFilter &filter,
SymbolContext &context, Address *addr,
bool containing) override;
lldb::SearchDepth GetDepth() override;
void GetDescription(Stream *s) override;
void Dump(Stream *s) const override;
/// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const BreakpointResolverScripted *) { return true; }
static inline bool classof(const BreakpointResolver *V) {
return V->getResolverID() == BreakpointResolver::PythonResolver;
}
lldb::BreakpointResolverSP CopyForBreakpoint(Breakpoint &breakpoint) override;
protected:
void NotifyBreakpointSet() override;
private:
void CreateImplementationIfNeeded();
ScriptInterpreter *GetScriptInterpreter();
std::string m_class_name;
lldb::SearchDepth m_depth;
StructuredDataImpl *m_args_ptr; // We own this, but the implementation
// has to manage the UP (since that is
// how it gets stored in the
// SBStructuredData).
StructuredData::GenericSP m_implementation_sp;
DISALLOW_COPY_AND_ASSIGN(BreakpointResolverScripted);
};
} // namespace lldb_private
#endif // liblldb_BreakpointResolverScripted_h_

4
contrib/llvm/tools/lldb/include/lldb/Breakpoint/BreakpointSite.h
View File

@ -10,15 +10,11 @@
#ifndef liblldb_BreakpointSite_h_
#define liblldb_BreakpointSite_h_
// C Includes
// C++ Includes
#include <list>
#include <mutex>
// Other libraries and framework includes
// Project includes
#include "lldb/Breakpoint/BreakpointLocationCollection.h"
#include "lldb/Breakpoint/StoppointLocation.h"
#include "lldb/Utility/UserID.h"

4
contrib/llvm/tools/lldb/include/lldb/Breakpoint/BreakpointSiteList.h
View File

@ -10,14 +10,10 @@
#ifndef liblldb_BreakpointSiteList_h_
#define liblldb_BreakpointSiteList_h_
// C Includes
// C++ Includes
#include <functional>
#include <map>
#include <mutex>
// Other libraries and framework includes
// Project includes
#include "lldb/Breakpoint/BreakpointSite.h"
namespace lldb_private {

4
contrib/llvm/tools/lldb/include/lldb/Breakpoint/Stoppoint.h
View File

@ -10,10 +10,6 @@
#ifndef liblldb_Stoppoint_h_
#define liblldb_Stoppoint_h_
// C Includes
// C++ Includes
// Other libraries and framework includes
// Project includes
#include "lldb/Utility/UserID.h"
#include "lldb/lldb-private.h"

4
contrib/llvm/tools/lldb/include/lldb/Breakpoint/StoppointLocation.h
View File

@ -10,10 +10,6 @@
#ifndef liblldb_StoppointLocation_h_
#define liblldb_StoppointLocation_h_
// C Includes
// C++ Includes
// Other libraries and framework includes
// Project includes
#include "lldb/Utility/UserID.h"
#include "lldb/lldb-private.h"
// #include "lldb/Breakpoint/BreakpointOptions.h"

4
contrib/llvm/tools/lldb/include/lldb/Breakpoint/Watchpoint.h
View File

@ -10,13 +10,9 @@
#ifndef liblldb_Watchpoint_h_
#define liblldb_Watchpoint_h_
// C Includes
// C++ Includes
#include <memory>
#include <string>
// Other libraries and framework includes
// Project includes
#include "lldb/Breakpoint/StoppointLocation.h"
#include "lldb/Breakpoint/WatchpointOptions.h"
#include "lldb/Symbol/CompilerType.h"

4
contrib/llvm/tools/lldb/include/lldb/Breakpoint/WatchpointList.h
View File

@ -10,14 +10,10 @@
#ifndef liblldb_WatchpointList_h_
#define liblldb_WatchpointList_h_
// C Includes
// C++ Includes
#include <list>
#include <mutex>
#include <vector>
// Other libraries and framework includes
// Project includes
#include "lldb/Core/Address.h"
#include "lldb/lldb-private.h"

4
contrib/llvm/tools/lldb/include/lldb/Breakpoint/WatchpointOptions.h
View File

@ -10,13 +10,9 @@
#ifndef liblldb_WatchpointOptions_h_
#define liblldb_WatchpointOptions_h_
// C Includes
// C++ Includes
#include <memory>
#include <string>
// Other libraries and framework includes
// Project includes
#include "lldb/Utility/Baton.h"
#include "lldb/Utility/StringList.h"
#include "lldb/lldb-private.h"

18
contrib/llvm/tools/lldb/include/lldb/Core/Address.h
View File

@ -10,13 +10,13 @@
#ifndef liblldb_Address_h_
#define liblldb_Address_h_
#include "lldb/lldb-defines.h" // for LLDB_INVALID_ADDRESS
#include "lldb/lldb-forward.h" // for SectionWP, SectionSP, ModuleSP
#include "lldb/lldb-private-enumerations.h" // for AddressClass
#include "lldb/lldb-types.h" // for addr_t
#include "lldb/lldb-defines.h"
#include "lldb/lldb-forward.h"
#include "lldb/lldb-private-enumerations.h"
#include "lldb/lldb-types.h"
#include <stddef.h> // for size_t
#include <stdint.h> // for uint32_t, UINT32_MAX, int64_t
#include <stddef.h>
#include <stdint.h>
namespace lldb_private {
class Block;
@ -508,9 +508,9 @@ class Address {
///
/// @see SymbolContextScope::CalculateSymbolContext(SymbolContext*)
//------------------------------------------------------------------
uint32_t CalculateSymbolContext(
SymbolContext *sc,
uint32_t resolve_scope = lldb::eSymbolContextEverything) const;
uint32_t CalculateSymbolContext(SymbolContext *sc,
lldb::SymbolContextItem resolve_scope =
lldb::eSymbolContextEverything) const;
lldb::ModuleSP CalculateSymbolContextModule() const;

6
contrib/llvm/tools/lldb/include/lldb/Core/AddressRange.h
View File

@ -11,10 +11,10 @@
#define liblldb_AddressRange_h_
#include "lldb/Core/Address.h"
#include "lldb/lldb-forward.h" // for SectionSP
#include "lldb/lldb-types.h" // for addr_t
#include "lldb/lldb-forward.h"
#include "lldb/lldb-types.h"
#include <stddef.h> // for size_t
#include <stddef.h>
namespace lldb_private {
class SectionList;

4
contrib/llvm/tools/lldb/include/lldb/Core/AddressResolver.h
View File

@ -12,9 +12,9 @@
#include "lldb/Core/AddressRange.h"
#include "lldb/Core/SearchFilter.h"
#include "lldb/lldb-defines.h" // for DISALLOW_COPY_AND_ASSIGN
#include "lldb/lldb-defines.h"
#include <stddef.h> // for size_t
#include <stddef.h>
#include <vector>
namespace lldb_private {

10
contrib/llvm/tools/lldb/include/lldb/Core/AddressResolverFileLine.h
View File

@ -11,11 +11,11 @@
#define liblldb_AddressResolverFileLine_h_
#include "lldb/Core/AddressResolver.h"
#include "lldb/Core/SearchFilter.h" // for Searcher, Searcher::CallbackR...
#include "lldb/Utility/FileSpec.h" // for FileSpec
#include "lldb/lldb-defines.h" // for DISALLOW_COPY_AND_ASSIGN
#include "lldb/Core/SearchFilter.h"
#include "lldb/Utility/FileSpec.h"
#include "lldb/lldb-defines.h"
#include <stdint.h> // for uint32_t
#include <stdint.h>
namespace lldb_private {
class Address;
@ -47,7 +47,7 @@ class AddressResolverFileLine : public AddressResolver {
SymbolContext &context, Address *addr,
bool containing) override;
Searcher::Depth GetDepth() override;
lldb::SearchDepth GetDepth() override;
void GetDescription(Stream *s) override;

8
contrib/llvm/tools/lldb/include/lldb/Core/AddressResolverName.h
View File

@ -11,10 +11,10 @@
#define liblldb_AddressResolverName_h_
#include "lldb/Core/AddressResolver.h"
#include "lldb/Core/SearchFilter.h" // for Searcher, Searcher::Call...
#include "lldb/Utility/ConstString.h" // for ConstString
#include "lldb/Core/SearchFilter.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/RegularExpression.h"
#include "lldb/lldb-defines.h" // for DISALLOW_COPY_AND_ASSIGN
#include "lldb/lldb-defines.h"
namespace lldb_private {
class Address;
@ -52,7 +52,7 @@ class AddressResolverName : public AddressResolver {
SymbolContext &context, Address *addr,
bool containing) override;
Searcher::Depth GetDepth() override;
lldb::SearchDepth GetDepth() override;
void GetDescription(Stream *s) override;

45
contrib/llvm/tools/lldb/include/lldb/Core/Architecture.h
View File

@ -67,6 +67,51 @@ class Architecture : public PluginInterface {
virtual void AdjustBreakpointAddress(const Symbol &func,
Address &addr) const {}
//------------------------------------------------------------------
/// Get \a load_addr as a callable code load address for this target
///
/// Take \a load_addr and potentially add any address bits that are
/// needed to make the address callable. For ARM this can set bit
/// zero (if it already isn't) if \a load_addr is a thumb function.
/// If \a addr_class is set to AddressClass::eInvalid, then the address
/// adjustment will always happen. If it is set to an address class
/// that doesn't have code in it, LLDB_INVALID_ADDRESS will be
/// returned.
//------------------------------------------------------------------
virtual lldb::addr_t GetCallableLoadAddress(
lldb::addr_t addr, AddressClass addr_class = AddressClass::eInvalid) const {
return addr;
}
//------------------------------------------------------------------
/// Get \a load_addr as an opcode for this target.
///
/// Take \a load_addr and potentially strip any address bits that are
/// needed to make the address point to an opcode. For ARM this can
/// clear bit zero (if it already isn't) if \a load_addr is a
/// thumb function and load_addr is in code.
/// If \a addr_class is set to AddressClass::eInvalid, then the address
/// adjustment will always happen. If it is set to an address class
/// that doesn't have code in it, LLDB_INVALID_ADDRESS will be
/// returned.
//------------------------------------------------------------------
virtual lldb::addr_t GetOpcodeLoadAddress(
lldb::addr_t addr, AddressClass addr_class = AddressClass::eInvalid) const {
return addr;
}
// Get load_addr as breakable load address for this target. Take a addr and
// check if for any reason there is a better address than this to put a
// breakpoint on. If there is then return that address. For MIPS, if
// instruction at addr is a delay slot instruction then this method will find
// the address of its previous instruction and return that address.
virtual lldb::addr_t GetBreakableLoadAddress(lldb::addr_t addr,
Target &target) const {
return addr;
}
private:
Architecture(const Architecture &) = delete;
void operator=(const Architecture &) = delete;

4
contrib/llvm/tools/lldb/include/lldb/Core/ClangForward.h
View File

@ -10,10 +10,6 @@
#ifndef liblldb_ClangForward_h_
#define liblldb_ClangForward_h_
// C Includes
// C++ Includes
// Other libraries and framework includes
// Project includes
#if defined(__cplusplus)

16
contrib/llvm/tools/lldb/include/lldb/Core/Communication.h
View File

@ -10,21 +10,21 @@
#ifndef liblldb_Communication_h_
#define liblldb_Communication_h_
#include "lldb/Core/Broadcaster.h"
#include "lldb/Host/HostThread.h"
#include "lldb/Utility/Broadcaster.h"
#include "lldb/Utility/Timeout.h"
#include "lldb/lldb-defines.h" // for DISALLOW_COPY_AND_ASSIGN
#include "lldb/lldb-enumerations.h" // for ConnectionStatus, FLAGS_ANONYMOU...
#include "lldb/lldb-forward.h" // for ConnectionSP
#include "lldb/lldb-types.h" // for thread_arg_t, thread_result_t
#include "lldb/lldb-defines.h"
#include "lldb/lldb-enumerations.h"
#include "lldb/lldb-forward.h"
#include "lldb/lldb-types.h"
#include <atomic>
#include <mutex>
#include <ratio> // for micro
#include <ratio>
#include <string>
#include <stddef.h> // for size_t
#include <stdint.h> // for uint8_t
#include <stddef.h>
#include <stdint.h>
namespace lldb_private {
class Connection;

49
contrib/llvm/tools/lldb/include/lldb/Core/Debugger.h
View File

@ -10,44 +10,40 @@
#ifndef liblldb_Debugger_h_
#define liblldb_Debugger_h_
// C Includes
#include <stdint.h>
// C++ Includes
#include <memory>
#include <vector>
// Other libraries and framework includes
// Project includes
#include "lldb/Core/Broadcaster.h"
#include "lldb/Core/FormatEntity.h"
#include "lldb/Core/IOHandler.h"
#include "lldb/Core/SourceManager.h"
#include "lldb/Core/UserSettingsController.h"
#include "lldb/Host/HostThread.h"
#include "lldb/Host/Terminal.h"
#include "lldb/Target/ExecutionContext.h" // for ExecutionContext
#include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Platform.h"
#include "lldb/Target/TargetList.h"
#include "lldb/Utility/ConstString.h" // for ConstString
#include "lldb/Utility/FileSpec.h" // for FileSpec
#include "lldb/Utility/Status.h" // for Status
#include "lldb/Utility/Broadcaster.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/FileSpec.h"
#include "lldb/Utility/Status.h"
#include "lldb/Utility/UserID.h"
#include "lldb/lldb-defines.h" // for DISALLOW_COPY_AND_ASSIGN
#include "lldb/lldb-enumerations.h" // for ScriptLanguage, Langua...
#include "lldb/lldb-forward.h" // for StreamFileSP, DebuggerSP
#include "lldb/lldb-private-enumerations.h" // for VarSetOperationType
#include "lldb/lldb-private-types.h" // for LoadPluginCallbackType
#include "lldb/lldb-types.h" // for LogOutputCallback, thr...
#include "lldb/lldb-defines.h"
#include "lldb/lldb-enumerations.h"
#include "lldb/lldb-forward.h"
#include "lldb/lldb-private-enumerations.h"
#include "lldb/lldb-private-types.h"
#include "lldb/lldb-types.h"
#include "llvm/ADT/ArrayRef.h" // for ArrayRef
#include "llvm/ADT/StringMap.h" // for StringMap
#include "llvm/ADT/StringRef.h" // for StringRef
#include "llvm/Support/DynamicLibrary.h" // for DynamicLibrary
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/StringMap.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/DynamicLibrary.h"
#include "llvm/Support/Threading.h"
#include <assert.h> // for assert
#include <stddef.h> // for size_t
#include <assert.h>
#include <stddef.h>
#include <stdio.h>
namespace lldb_private {
@ -192,7 +188,8 @@ class Debugger : public std::enable_shared_from_this<Debugger>,
lldb::StreamFileSP &out,
lldb::StreamFileSP &err);
void PushIOHandler(const lldb::IOHandlerSP &reader_sp);
void PushIOHandler(const lldb::IOHandlerSP &reader_sp,
bool cancel_top_handler = true);
bool PopIOHandler(const lldb::IOHandlerSP &reader_sp);
@ -264,6 +261,8 @@ class Debugger : public std::enable_shared_from_this<Debugger>,
void SetPrompt(llvm::StringRef p);
void SetPrompt(const char *) = delete;
llvm::StringRef GetReproducerPath() const;
bool GetUseExternalEditor() const;
bool SetUseExternalEditor(bool use_external_editor_p);
@ -272,11 +271,13 @@ class Debugger : public std::enable_shared_from_this<Debugger>,
bool SetUseColor(bool use_color);
bool GetHighlightSource() const;
lldb::StopShowColumn GetStopShowColumn() const;
const FormatEntity::Entry *GetStopShowColumnAnsiPrefix() const;
llvm::StringRef GetStopShowColumnAnsiPrefix() const;
const FormatEntity::Entry *GetStopShowColumnAnsiSuffix() const;
llvm::StringRef GetStopShowColumnAnsiSuffix() const;
uint32_t GetStopSourceLineCount(bool before) const;

26
contrib/llvm/tools/lldb/include/lldb/Core/Disassembler.h
View File

@ -12,32 +12,32 @@
#include "lldb/Core/Address.h"
#include "lldb/Core/EmulateInstruction.h"
#include "lldb/Core/FormatEntity.h" // for FormatEntity
#include "lldb/Core/FormatEntity.h"
#include "lldb/Core/Opcode.h"
#include "lldb/Core/PluginInterface.h"
#include "lldb/Interpreter/OptionValue.h"
#include "lldb/Symbol/LineEntry.h"
#include "lldb/Target/ExecutionContext.h" // for ExecutionContext
#include "lldb/Target/ExecutionContext.h"
#include "lldb/Utility/ArchSpec.h"
#include "lldb/Utility/ConstString.h" // for ConstString
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/FileSpec.h"
#include "lldb/lldb-defines.h" // for DISALLOW_COPY_AND_ASSIGN
#include "lldb/lldb-forward.h" // for InstructionSP, DisassemblerSP
#include "lldb/lldb-private-enumerations.h" // for AddressClass
#include "lldb/lldb-types.h" // for addr_t, offset_t
#include "lldb/lldb-defines.h"
#include "lldb/lldb-forward.h"
#include "lldb/lldb-private-enumerations.h"
#include "lldb/lldb-types.h"
#include "llvm/ADT/StringRef.h" // for StringRef
#include "llvm/ADT/StringRef.h"
#include <functional> // for function
#include <functional>
#include <map>
#include <memory> // for enable_shared_from_this
#include <memory>
#include <set>
#include <string>
#include <vector>
#include <stddef.h> // for size_t
#include <stdint.h> // for uint32_t, int64_t
#include <stdio.h> // for FILE
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
namespace lldb_private {
class AddressRange;

6
contrib/llvm/tools/lldb/include/lldb/Core/DumpDataExtractor.h
View File

@ -10,11 +10,11 @@
#ifndef LLDB_CORE_DUMPDATAEXTRACTOR_H
#define LLDB_CORE_DUMPDATAEXTRACTOR_H
#include "lldb/lldb-enumerations.h" // for Format
#include "lldb/lldb-enumerations.h"
#include "lldb/lldb-types.h"
#include <stddef.h> // for size_t
#include <stdint.h> // for uint32_t, uint64_t
#include <stddef.h>
#include <stdint.h>
namespace lldb_private {
class DataExtractor;

16
contrib/llvm/tools/lldb/include/lldb/Core/EmulateInstruction.h
View File

@ -12,18 +12,18 @@
#include <string>
#include "lldb/Core/Address.h" // for Address
#include "lldb/Core/Address.h"
#include "lldb/Core/Opcode.h"
#include "lldb/Core/PluginInterface.h"
#include "lldb/Utility/ArchSpec.h"
#include "lldb/lldb-defines.h" // for DISALLOW_COPY_AND_ASSIGN
#include "lldb/lldb-enumerations.h" // for RegisterKind, ByteOrder
#include "lldb/lldb-private-enumerations.h" // for InstructionType
#include "lldb/lldb-private-types.h" // for RegisterInfo
#include "lldb/lldb-types.h" // for addr_t
#include "lldb/lldb-defines.h"
#include "lldb/lldb-enumerations.h"
#include "lldb/lldb-private-enumerations.h"
#include "lldb/lldb-private-types.h"
#include "lldb/lldb-types.h"
#include <stddef.h> // for size_t
#include <stdint.h> // for uint32_t, uint64_t, int64_t
#include <stddef.h>
#include <stdint.h>
namespace lldb_private {
class OptionValueDictionary;
}

10
contrib/llvm/tools/lldb/include/lldb/Core/FileLineResolver.h
View File

@ -10,12 +10,12 @@
#ifndef liblldb_FileLineResolver_h_
#define liblldb_FileLineResolver_h_
#include "lldb/Core/SearchFilter.h" // for Searcher, Searcher::CallbackR...
#include "lldb/Core/SearchFilter.h"
#include "lldb/Symbol/SymbolContext.h"
#include "lldb/Utility/FileSpec.h" // for FileSpec
#include "lldb/lldb-defines.h" // for DISALLOW_COPY_AND_ASSIGN
#include "lldb/Utility/FileSpec.h"
#include "lldb/lldb-defines.h"
#include <stdint.h> // for uint32_t, UINT32_MAX
#include <stdint.h>
namespace lldb_private {
class Address;
@ -48,7 +48,7 @@ class FileLineResolver : public Searcher {
SymbolContext &context, Address *addr,
bool containing) override;
Searcher::Depth GetDepth() override;
lldb::SearchDepth GetDepth() override;
void GetDescription(Stream *s) override;

2
contrib/llvm/tools/lldb/include/lldb/Core/FileSpecList.h
View File

@ -15,7 +15,7 @@
#include <vector>
#include <stddef.h> // for size_t
#include <stddef.h>
namespace lldb_private {
class Stream;

14
contrib/llvm/tools/lldb/include/lldb/Core/FormatEntity.h
View File

@ -11,13 +11,13 @@
#define liblldb_FormatEntity_h_
#include "lldb/Utility/CompletionRequest.h"
#include "lldb/Utility/FileSpec.h" // for FileSpec
#include "lldb/Utility/FileSpec.h"
#include "lldb/Utility/Status.h"
#include "lldb/lldb-enumerations.h" // for Format::eFormatDefault, Format
#include "lldb/lldb-types.h" // for addr_t
#include <algorithm> // for min
#include <stddef.h> // for size_t
#include <stdint.h> // for uint32_t, uint64_t
#include "lldb/lldb-enumerations.h"
#include "lldb/lldb-types.h"
#include <algorithm>
#include <stddef.h>
#include <stdint.h>
#include <string>
#include <vector>
@ -88,6 +88,7 @@ class FormatEntity {
FrameRegisterFP,
FrameRegisterFlags,
FrameRegisterByName,
FrameIsArtificial,
ScriptFrame,
FunctionID,
FunctionDidChange,
@ -104,6 +105,7 @@ class FormatEntity {
FunctionIsOptimized,
LineEntryFile,
LineEntryLineNumber,
LineEntryColumn,
LineEntryStartAddress,
LineEntryEndAddress,
CurrentPCArrow

165
contrib/llvm/tools/lldb/include/lldb/Core/Highlighter.h Normal file
View File

@ -0,0 +1,165 @@
//===-- Highlighter.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_Highlighter_h_
#define liblldb_Highlighter_h_
#include <utility>
#include <vector>
#include "lldb/Utility/Stream.h"
#include "lldb/lldb-enumerations.h"
#include "llvm/ADT/StringRef.h"
namespace lldb_private {
//----------------------------------------------------------------------
/// Represents style that the highlighter should apply to the given source code.
/// Stores information about how every kind of token should be annotated.
//----------------------------------------------------------------------
struct HighlightStyle {
//----------------------------------------------------------------------
/// A pair of strings that should be placed around a certain token. Usually
/// stores color codes in these strings (the suffix string is often used for
/// resetting the terminal attributes back to normal).
//----------------------------------------------------------------------
class ColorStyle {
std::string m_prefix;
std::string m_suffix;
public:
ColorStyle() = default;
ColorStyle(llvm::StringRef prefix, llvm::StringRef suffix) {
Set(prefix, suffix);
}
/// Applies this style to the given value.
/// \param s
/// The stream to which the result should be appended.
/// \param value
/// The value that we should place our strings around.
void Apply(Stream &s, llvm::StringRef value) const;
/// Sets the prefix and suffix strings.
/// @param prefix
/// @param suffix
void Set(llvm::StringRef prefix, llvm::StringRef suffix);
};
/// The style for the token which is below the cursor of the user. Note that
/// this style is overwritten by the SourceManager with the values of
/// stop-show-column-ansi-prefix/stop-show-column-ansi-suffix.
ColorStyle selected;
/// Matches identifiers to variable or functions.
ColorStyle identifier;
/// Matches any string or character literals in the language: "foo" or 'f'
ColorStyle string_literal;
/// Matches scalar value literals like '42' or '0.1'.
ColorStyle scalar_literal;
/// Matches all reserved keywords in the language.
ColorStyle keyword;
/// Matches any comments in the language.
ColorStyle comment;
/// Matches commas: ','
ColorStyle comma;
/// Matches one colon: ':'
ColorStyle colon;
/// Matches any semicolon: ';'
ColorStyle semicolons;
/// Matches operators like '+', '-', '%', '&', '='
ColorStyle operators;
/// Matches '{' or '}'
ColorStyle braces;
/// Matches '[' or ']'
ColorStyle square_brackets;
/// Matches '(' or ')'
ColorStyle parentheses;
//-----------------------------------------------------------------------
// C language specific options
//-----------------------------------------------------------------------
/// Matches directives to a preprocessor (if the language has any).
ColorStyle pp_directive;
/// Returns a HighlightStyle that is based on vim's default highlight style.
static HighlightStyle MakeVimStyle();
};
//----------------------------------------------------------------------
/// Annotates source code with color attributes.
//----------------------------------------------------------------------
class Highlighter {
public:
Highlighter() = default;
virtual ~Highlighter() = default;
DISALLOW_COPY_AND_ASSIGN(Highlighter);
/// Returns a human readable name for the selected highlighter.
virtual llvm::StringRef GetName() const = 0;
/// Highlights the given line
/// \param options
/// \param line
/// The user supplied line that needs to be highlighted.
/// \param cursor_pos
/// The cursor position of the user in this line, starting at 0 (which
/// means the cursor is on the first character in 'line').
/// \param previous_lines
/// Any previous lines the user has written which we should only use
/// for getting the context of the Highlighting right.
/// \param s
/// The stream to which the highlighted version of the user string should
/// be written.
virtual void Highlight(const HighlightStyle &options, llvm::StringRef line,
llvm::Optional<size_t> cursor_pos,
llvm::StringRef previous_lines, Stream &s) const = 0;
/// Utility method for calling Highlight without a stream.
std::string Highlight(const HighlightStyle &options, llvm::StringRef line,
llvm::Optional<size_t> cursor_pos,
llvm::StringRef previous_lines = "") const;
};
/// A default highlighter that only highlights the user cursor, but doesn't
/// do any other highlighting.
class DefaultHighlighter : public Highlighter {
public:
llvm::StringRef GetName() const override { return "none"; }
void Highlight(const HighlightStyle &options, llvm::StringRef line,
llvm::Optional<size_t> cursor_pos,
llvm::StringRef previous_lines, Stream &s) const override;
};
/// Manages the available highlighters.
class HighlighterManager {
DefaultHighlighter m_default;
public:
/// Queries all known highlighter for one that can highlight some source code.
/// \param language_type
/// The language type that the caller thinks the source code was given in.
/// \param path
/// The path to the file the source code is from. Used as a fallback when
/// the user can't provide a language.
/// \return
/// The highlighter that wants to highlight the source code. Could be an
/// empty highlighter that does nothing.
const Highlighter &getHighlighterFor(lldb::LanguageType language_type,
llvm::StringRef path) const;
const Highlighter &getDefaultHighlighter() const { return m_default; }
};
} // namespace lldb_private
#endif // liblldb_Highlighter_h_

19
contrib/llvm/tools/lldb/include/lldb/Core/IOHandler.h
View File

@ -11,22 +11,22 @@
#define liblldb_IOHandler_h_
#include "lldb/Core/ValueObjectList.h"
#include "lldb/Host/Predicate.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Flags.h"
#include "lldb/Utility/Predicate.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Utility/StringList.h"
#include "lldb/lldb-defines.h" // for DISALLOW_COPY_AND_ASSIGN
#include "lldb/lldb-forward.h" // for IOHandlerSP, StreamFileSP
#include "llvm/ADT/StringRef.h" // for StringRef
#include "lldb/lldb-defines.h"
#include "lldb/lldb-forward.h"
#include "llvm/ADT/StringRef.h"
#include <memory>
#include <mutex>
#include <string>
#include <vector>
#include <stdint.h> // for uint32_t
#include <stdio.h> // for FILE
#include <stdint.h>
#include <stdio.h>
namespace lldb_private {
class Debugger;
@ -205,7 +205,7 @@ class IOHandlerDelegate {
virtual int IOHandlerComplete(IOHandler &io_handler, const char *current_line,
const char *cursor, const char *last_char,
int skip_first_n_matches, int max_matches,
StringList &matches);
StringList &matches, StringList &descriptions);
virtual const char *IOHandlerGetFixIndentationCharacters() { return nullptr; }
@ -430,7 +430,8 @@ class IOHandlerEditline : public IOHandler {
static int AutoCompleteCallback(const char *current_line, const char *cursor,
const char *last_char,
int skip_first_n_matches, int max_matches,
StringList &matches, void *baton);
StringList &matches, StringList &descriptions,
void *baton);
#endif
protected:
@ -464,7 +465,7 @@ class IOHandlerConfirm : public IOHandlerDelegate, public IOHandlerEditline {
int IOHandlerComplete(IOHandler &io_handler, const char *current_line,
const char *cursor, const char *last_char,
int skip_first_n_matches, int max_matches,
StringList &matches) override;
StringList &matches, StringList &descriptions) override;
void IOHandlerInputComplete(IOHandler &io_handler,
std::string &data) override;

3
contrib/llvm/tools/lldb/include/lldb/Core/LoadedModuleInfoList.h
View File

@ -10,14 +10,11 @@
#ifndef liblldb_LoadedModuleInfoList_h_
#define liblldb_LoadedModuleInfoList_h_
// C Includes
// C++ Includes
#include <cassert>
#include <string>
#include <vector>
// Other libraries and framework includes
#include "lldb/lldb-defines.h"
#include "lldb/lldb-private-forward.h"
#include "lldb/lldb-types.h"

46
contrib/llvm/tools/lldb/include/lldb/Core/Mangled.h
View File

@ -11,18 +11,15 @@
#define liblldb_Mangled_h_
#if defined(__cplusplus)
#include "lldb/lldb-enumerations.h"
#include "lldb/lldb-forward.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/lldb-enumerations.h" // for LanguageType
#include "llvm/ADT/StringRef.h" // for StringRef
#include <stddef.h> // for size_t
#include "llvm/ADT/StringRef.h"
namespace lldb_private {
class RegularExpression;
}
namespace lldb_private {
class Stream;
}
#include <memory>
#include <stddef.h>
namespace lldb_private {
@ -238,7 +235,6 @@ class Mangled {
return true;
return GetDemangledName(language) == name;
}
bool NameMatches(const RegularExpression &regex,
lldb::LanguageType language) const;
@ -300,6 +296,36 @@ class Mangled {
//----------------------------------------------------------------------
lldb::LanguageType GuessLanguage() const;
/// Function signature for filtering mangled names.
using SkipMangledNameFn = bool(llvm::StringRef, ManglingScheme);
//----------------------------------------------------------------------
/// Trigger explicit demangling to obtain rich mangling information. This is
/// optimized for batch processing while populating a name index. To get the
/// pure demangled name string for a single entity, use GetDemangledName()
/// instead.
///
/// For names that match the Itanium mangling scheme, this uses LLVM's
/// ItaniumPartialDemangler. All other names fall back to LLDB's builtin
/// parser currently.
///
/// This function is thread-safe when used with different \a context
/// instances in different threads.
///
/// @param[in] context
/// The context for this function. A single instance can be stack-
/// allocated in the caller's frame and used for multiple calls.
///
/// @param[in] skip_mangled_name
/// A filtering function for skipping entities based on name and mangling
/// scheme. This can be null if unused.
///
/// @return
/// True on success, false otherwise.
//----------------------------------------------------------------------
bool DemangleWithRichManglingInfo(RichManglingContext &context,
SkipMangledNameFn *skip_mangled_name);
private:
//----------------------------------------------------------------------
/// Mangled member variables.

4
contrib/llvm/tools/lldb/include/lldb/Core/MappedHash.h
View File

@ -10,18 +10,14 @@
#ifndef liblldb_MappedHash_h_
#define liblldb_MappedHash_h_
// C Includes
#include <assert.h>
#include <stdint.h>
// C++ Includes
#include <algorithm>
#include <functional>
#include <map>
#include <vector>
// Other libraries and framework includes
// Project includes
#include "lldb/Utility/DataExtractor.h"
#include "lldb/Utility/Stream.h"
#include "llvm/Support/DJB.h"

113
contrib/llvm/tools/lldb/include/lldb/Core/Module.h
View File

@ -10,31 +10,31 @@
#ifndef liblldb_Module_h_
#define liblldb_Module_h_
#include "lldb/Core/Address.h" // for Address
#include "lldb/Core/ModuleSpec.h" // for ModuleSpec
#include "lldb/Symbol/ObjectFile.h" // for ObjectFile
#include "lldb/Core/Address.h"
#include "lldb/Core/ModuleSpec.h"
#include "lldb/Symbol/ObjectFile.h"
#include "lldb/Symbol/SymbolContextScope.h"
#include "lldb/Symbol/TypeSystem.h"
#include "lldb/Target/PathMappingList.h"
#include "lldb/Utility/ArchSpec.h"
#include "lldb/Utility/ConstString.h" // for ConstString
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/FileSpec.h"
#include "lldb/Utility/Status.h" // for Status
#include "lldb/Utility/Status.h"
#include "lldb/Utility/UUID.h"
#include "lldb/lldb-defines.h" // for DISALLOW_COPY_AND_ASSIGN
#include "lldb/lldb-enumerations.h" // for LanguageType, SymbolType
#include "lldb/lldb-defines.h"
#include "lldb/lldb-enumerations.h"
#include "lldb/lldb-forward.h"
#include "lldb/lldb-types.h" // for addr_t, offset_t
#include "lldb/lldb-types.h"
#include "llvm/ADT/DenseSet.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/Chrono.h"
#include <atomic>
#include <memory> // for enable_shared_from_this
#include <memory>
#include <mutex>
#include <stddef.h> // for size_t
#include <stdint.h> // for uint32_t, uint64_t
#include <stddef.h>
#include <stdint.h>
#include <string>
#include <vector>
@ -168,10 +168,11 @@ class Module : public std::enable_shared_from_this<Module>,
// Once we get the object file, update our module with the object file's
// architecture since it might differ in vendor/os if some parts were
// unknown.
if (!module_sp->m_objfile_sp->GetArchitecture(module_sp->m_arch))
return nullptr;
return module_sp;
if (ArchSpec arch = module_sp->m_objfile_sp->GetArchitecture()) {
module_sp->m_arch = arch;
return module_sp;
}
return nullptr;
}
//------------------------------------------------------------------
@ -380,7 +381,7 @@ class Module : public std::enable_shared_from_this<Module>,
//------------------------------------------------------------------
size_t FindFunctions(const ConstString &name,
const CompilerDeclContext *parent_decl_ctx,
uint32_t name_type_mask, bool symbols_ok,
lldb::FunctionNameType name_type_mask, bool symbols_ok,
bool inlines_ok, bool append,
SymbolContextList &sc_list);
@ -498,10 +499,6 @@ class Module : public std::enable_shared_from_this<Module>,
/// have to specify complete scoping on all expressions, but it also allows
/// for exact matching when required.
///
/// @param[in] sc
/// A symbol context that scopes where to extract a type list
/// from.
///
/// @param[in] type_name
/// The name of the type we are looking for that is a fully
/// or partially qualified type name.
@ -520,8 +517,7 @@ class Module : public std::enable_shared_from_this<Module>,
/// The number of matches added to \a type_list.
//------------------------------------------------------------------
size_t
FindTypes(const SymbolContext &sc, const ConstString &type_name,
bool exact_match, size_t max_matches,
FindTypes(const ConstString &type_name, bool exact_match, size_t max_matches,
llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
TypeList &types);
@ -533,10 +529,6 @@ class Module : public std::enable_shared_from_this<Module>,
/// expression parser when searches need to happen in an exact namespace
/// scope.
///
/// @param[in] sc
/// A symbol context that scopes where to extract a type list
/// from.
///
/// @param[in] type_name
/// The name of a type within a namespace that should not include
/// any qualifying namespaces (just a type basename).
@ -550,8 +542,7 @@ class Module : public std::enable_shared_from_this<Module>,
/// @return
/// The number of matches added to \a type_list.
//------------------------------------------------------------------
size_t FindTypesInNamespace(const SymbolContext &sc,
const ConstString &type_name,
size_t FindTypesInNamespace(const ConstString &type_name,
const CompilerDeclContext *parent_decl_ctx,
size_t max_matches, TypeList &type_list);
@ -816,10 +807,9 @@ class Module : public std::enable_shared_from_this<Module>,
///
/// @see SymbolContext::Scope
//------------------------------------------------------------------
uint32_t
ResolveSymbolContextForAddress(const Address &so_addr, uint32_t resolve_scope,
SymbolContext &sc,
bool resolve_tail_call_address = false);
uint32_t ResolveSymbolContextForAddress(
const Address &so_addr, lldb::SymbolContextItem resolve_scope,
SymbolContext &sc, bool resolve_tail_call_address = false);
//------------------------------------------------------------------
/// Resolve items in the symbol context for a given file and line.
@ -862,10 +852,9 @@ class Module : public std::enable_shared_from_this<Module>,
///
/// @see SymbolContext::Scope
//------------------------------------------------------------------
uint32_t ResolveSymbolContextForFilePath(const char *file_path, uint32_t line,
bool check_inlines,
uint32_t resolve_scope,
SymbolContextList &sc_list);
uint32_t ResolveSymbolContextForFilePath(
const char *file_path, uint32_t line, bool check_inlines,
lldb::SymbolContextItem resolve_scope, SymbolContextList &sc_list);
//------------------------------------------------------------------
/// Resolve items in the symbol context for a given file and line.
@ -909,10 +898,9 @@ class Module : public std::enable_shared_from_this<Module>,
///
/// @see SymbolContext::Scope
//------------------------------------------------------------------
uint32_t ResolveSymbolContextsForFileSpec(const FileSpec &file_spec,
uint32_t line, bool check_inlines,
uint32_t resolve_scope,
SymbolContextList &sc_list);
uint32_t ResolveSymbolContextsForFileSpec(
const FileSpec &file_spec, uint32_t line, bool check_inlines,
lldb::SymbolContextItem resolve_scope, SymbolContextList &sc_list);
void SetFileSpecAndObjectName(const FileSpec &file,
const ConstString &object_name);
@ -1031,9 +1019,10 @@ class Module : public std::enable_shared_from_this<Module>,
public:
LookupInfo()
: m_name(), m_lookup_name(), m_language(lldb::eLanguageTypeUnknown),
m_name_type_mask(0), m_match_name_after_lookup(false) {}
m_name_type_mask(lldb::eFunctionNameTypeNone),
m_match_name_after_lookup(false) {}
LookupInfo(const ConstString &name, uint32_t name_type_mask,
LookupInfo(const ConstString &name, lldb::FunctionNameType name_type_mask,
lldb::LanguageType language);
const ConstString &GetName() const { return m_name; }
@ -1044,24 +1033,31 @@ class Module : public std::enable_shared_from_this<Module>,
void SetLookupName(const ConstString &name) { m_lookup_name = name; }
uint32_t GetNameTypeMask() const { return m_name_type_mask; }
lldb::FunctionNameType GetNameTypeMask() const { return m_name_type_mask; }
void SetNameTypeMask(uint32_t mask) { m_name_type_mask = mask; }
void SetNameTypeMask(lldb::FunctionNameType mask) {
m_name_type_mask = mask;
}
void Prune(SymbolContextList &sc_list, size_t start_idx) const;
protected:
ConstString m_name; ///< What the user originally typed
ConstString m_lookup_name; ///< The actual name will lookup when calling in
///the object or symbol file
lldb::LanguageType
m_language; ///< Limit matches to only be for this language
uint32_t m_name_type_mask; ///< One or more bits from lldb::FunctionNameType
///that indicate what kind of names we are
///looking for
bool m_match_name_after_lookup; ///< If \b true, then demangled names that
///match will need to contain "m_name" in
///order to be considered a match
/// What the user originally typed
ConstString m_name;
/// The actual name will lookup when calling in the object or symbol file
ConstString m_lookup_name;
/// Limit matches to only be for this language
lldb::LanguageType m_language;
/// One or more bits from lldb::FunctionNameType that indicate what kind of
/// names we are looking for
lldb::FunctionNameType m_name_type_mask;
///< If \b true, then demangled names that match will need to contain
///< "m_name" in order to be considered a match
bool m_match_name_after_lookup;
};
protected:
@ -1155,7 +1151,7 @@ class Module : public std::enable_shared_from_this<Module>,
//------------------------------------------------------------------
uint32_t ResolveSymbolContextForAddress(lldb::addr_t vm_addr,
bool vm_addr_is_file_addr,
uint32_t resolve_scope,
lldb::SymbolContextItem resolve_scope,
Address &so_addr, SymbolContext &sc);
void SymbolIndicesToSymbolContextList(Symtab *symtab,
@ -1176,9 +1172,8 @@ class Module : public std::enable_shared_from_this<Module>,
Module(); // Only used internally by CreateJITModule ()
size_t FindTypes_Impl(
const SymbolContext &sc, const ConstString &name,
const CompilerDeclContext *parent_decl_ctx, bool append,
size_t max_matches,
const ConstString &name, const CompilerDeclContext *parent_decl_ctx,
bool append, size_t max_matches,
llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
TypeMap &types);

42
contrib/llvm/tools/lldb/include/lldb/Core/ModuleList.h
View File

@ -10,12 +10,12 @@
#ifndef liblldb_ModuleList_h_
#define liblldb_ModuleList_h_
#include "lldb/Core/Address.h" // for Address
#include "lldb/Core/ModuleSpec.h" // for ModuleSpec
#include "lldb/Core/Address.h"
#include "lldb/Core/ModuleSpec.h"
#include "lldb/Core/UserSettingsController.h"
#include "lldb/Utility/FileSpec.h" // for FileSpec
#include "lldb/Utility/FileSpec.h"
#include "lldb/Utility/Iterable.h"
#include "lldb/Utility/Status.h" // for Status
#include "lldb/Utility/Status.h"
#include "lldb/lldb-enumerations.h"
#include "lldb/lldb-forward.h"
#include "lldb/lldb-types.h"
@ -27,8 +27,8 @@
#include <mutex>
#include <vector>
#include <stddef.h> // for size_t
#include <stdint.h> // for uint32_t
#include <stddef.h>
#include <stdint.h>
namespace lldb_private {
class ConstString;
@ -300,14 +300,16 @@ class ModuleList {
//------------------------------------------------------------------
/// @see Module::FindFunctions ()
//------------------------------------------------------------------
size_t FindFunctions(const ConstString &name, uint32_t name_type_mask,
size_t FindFunctions(const ConstString &name,
lldb::FunctionNameType name_type_mask,
bool include_symbols, bool include_inlines, bool append,
SymbolContextList &sc_list) const;
//------------------------------------------------------------------
/// @see Module::FindFunctionSymbols ()
//------------------------------------------------------------------
size_t FindFunctionSymbols(const ConstString &name, uint32_t name_type_mask,
size_t FindFunctionSymbols(const ConstString &name,
lldb::FunctionNameType name_type_mask,
SymbolContextList &sc_list);
//------------------------------------------------------------------
@ -415,9 +417,9 @@ class ModuleList {
//------------------------------------------------------------------
/// Find types by name.
///
/// @param[in] sc
/// A symbol context that scopes where to extract a type list
/// from.
/// @param[in] search_first
/// If non-null, this module will be searched before any other
/// modules.
///
/// @param[in] name
/// The name of the type we are looking for.
@ -445,7 +447,7 @@ class ModuleList {
/// @return
/// The number of matches added to \a type_list.
//------------------------------------------------------------------
size_t FindTypes(const SymbolContext &sc, const ConstString &name,
size_t FindTypes(Module *search_first, const ConstString &name,
bool name_is_fully_qualified, size_t max_matches,
llvm::DenseSet<SymbolFile *> &searched_symbol_files,
TypeList &types) const;
@ -495,26 +497,24 @@ class ModuleList {
/// &,uint32_t,SymbolContext&)
//------------------------------------------------------------------
uint32_t ResolveSymbolContextForAddress(const Address &so_addr,
uint32_t resolve_scope,
lldb::SymbolContextItem resolve_scope,
SymbolContext &sc) const;
//------------------------------------------------------------------
/// @copydoc Module::ResolveSymbolContextForFilePath (const char
/// *,uint32_t,bool,uint32_t,SymbolContextList&)
//------------------------------------------------------------------
uint32_t ResolveSymbolContextForFilePath(const char *file_path, uint32_t line,
bool check_inlines,
uint32_t resolve_scope,
SymbolContextList &sc_list) const;
uint32_t ResolveSymbolContextForFilePath(
const char *file_path, uint32_t line, bool check_inlines,
lldb::SymbolContextItem resolve_scope, SymbolContextList &sc_list) const;
//------------------------------------------------------------------
/// @copydoc Module::ResolveSymbolContextsForFileSpec (const FileSpec
/// &,uint32_t,bool,uint32_t,SymbolContextList&)
//------------------------------------------------------------------
uint32_t ResolveSymbolContextsForFileSpec(const FileSpec &file_spec,
uint32_t line, bool check_inlines,
uint32_t resolve_scope,
SymbolContextList &sc_list) const;
uint32_t ResolveSymbolContextsForFileSpec(
const FileSpec &file_spec, uint32_t line, bool check_inlines,
lldb::SymbolContextItem resolve_scope, SymbolContextList &sc_list) const;
//------------------------------------------------------------------
/// Gets the size of the module list.

19
contrib/llvm/tools/lldb/include/lldb/Core/ModuleSpec.h
View File

@ -10,18 +10,15 @@
#ifndef liblldb_ModuleSpec_h_
#define liblldb_ModuleSpec_h_
// Project includes
#include "lldb/Host/FileSystem.h"
#include "lldb/Target/PathMappingList.h"
#include "lldb/Utility/ArchSpec.h"
#include "lldb/Utility/FileSpec.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Utility/UUID.h"
// Other libraries and framework includes
#include "llvm/Support/Chrono.h"
// C Includes
// C++ Includes
#include <mutex>
#include <vector>
@ -34,15 +31,17 @@ class ModuleSpec {
m_object_name(), m_object_offset(0), m_object_size(0),
m_source_mappings() {}
ModuleSpec(const FileSpec &file_spec, const UUID& uuid = UUID())
ModuleSpec(const FileSpec &file_spec, const UUID &uuid = UUID())
: m_file(file_spec), m_platform_file(), m_symbol_file(), m_arch(),
m_uuid(uuid), m_object_name(), m_object_offset(0),
m_object_size(file_spec.GetByteSize()), m_source_mappings() {}
m_object_size(FileSystem::Instance().GetByteSize(file_spec)),
m_source_mappings() {}
ModuleSpec(const FileSpec &file_spec, const ArchSpec &arch)
: m_file(file_spec), m_platform_file(), m_symbol_file(), m_arch(arch),
m_uuid(), m_object_name(), m_object_offset(0),
m_object_size(file_spec.GetByteSize()), m_source_mappings() {}
m_object_size(FileSystem::Instance().GetByteSize(file_spec)),
m_source_mappings() {}
ModuleSpec(const ModuleSpec &rhs)
: m_file(rhs.m_file), m_platform_file(rhs.m_platform_file),
@ -256,20 +255,20 @@ class ModuleSpec {
if (match_module_spec.GetFileSpecPtr()) {
const FileSpec &fspec = match_module_spec.GetFileSpec();
if (!FileSpec::Equal(fspec, GetFileSpec(),
fspec.GetDirectory().IsEmpty() == false))
!fspec.GetDirectory().IsEmpty()))
return false;
}
if (GetPlatformFileSpec() && match_module_spec.GetPlatformFileSpecPtr()) {
const FileSpec &fspec = match_module_spec.GetPlatformFileSpec();
if (!FileSpec::Equal(fspec, GetPlatformFileSpec(),
fspec.GetDirectory().IsEmpty() == false))
!fspec.GetDirectory().IsEmpty()))
return false;
}
// Only match the symbol file spec if there is one in this ModuleSpec
if (GetSymbolFileSpec() && match_module_spec.GetSymbolFileSpecPtr()) {
const FileSpec &fspec = match_module_spec.GetSymbolFileSpec();
if (!FileSpec::Equal(fspec, GetSymbolFileSpec(),
fspec.GetDirectory().IsEmpty() == false))
!fspec.GetDirectory().IsEmpty()))
return false;
}
if (match_module_spec.GetArchitecturePtr()) {

6
contrib/llvm/tools/lldb/include/lldb/Core/Opcode.h
View File

@ -11,12 +11,12 @@
#define lldb_Opcode_h
#include "lldb/Utility/Endian.h"
#include "lldb/lldb-enumerations.h" // for ByteOrder, ByteOrder::eByteOrde...
#include "lldb/lldb-enumerations.h"
#include "llvm/Support/MathExtras.h"
#include <assert.h> // for assert
#include <stdint.h> // for uint32_t, uint8_t, uint16_t
#include <assert.h>
#include <stdint.h>
#include <string.h>
namespace lldb_private {

4
contrib/llvm/tools/lldb/include/lldb/Core/PluginInterface.h
View File

@ -10,10 +10,6 @@
#ifndef liblldb_PluginInterface_h_
#define liblldb_PluginInterface_h_
// C Includes
// C++ Includes
// Other libraries and framework includes
// Project includes
#include "lldb/lldb-private.h"
namespace lldb_private {

14
contrib/llvm/tools/lldb/include/lldb/Core/PluginManager.h
View File

@ -12,14 +12,14 @@
#include "lldb/Core/Architecture.h"
#include "lldb/Utility/FileSpec.h"
#include "lldb/Utility/Status.h" // for Status
#include "lldb/lldb-enumerations.h" // for ScriptLanguage
#include "lldb/lldb-forward.h" // for OptionValuePropertiesSP
#include "lldb/lldb-private-interfaces.h" // for DebuggerInitializeCallback
#include "llvm/ADT/StringRef.h" // for StringRef
#include "lldb/Utility/Status.h"
#include "lldb/lldb-enumerations.h"
#include "lldb/lldb-forward.h"
#include "lldb/lldb-private-interfaces.h"
#include "llvm/ADT/StringRef.h"
#include <stddef.h> // for size_t
#include <stdint.h> // for uint32_t
#include <stddef.h>
#include <stdint.h>
namespace lldb_private {
class CommandInterpreter;

290
contrib/llvm/tools/lldb/include/lldb/Core/RangeMap.h
View File

@ -10,15 +10,11 @@
#ifndef liblldb_RangeMap_h_
#define liblldb_RangeMap_h_
// C Includes
// C++ Includes
#include <algorithm>
#include <vector>
// Other libraries and framework includes
#include "llvm/ADT/SmallVector.h"
// Project includes
#include "lldb/lldb-private.h"
// Uncomment to make sure all Range objects are sorted when needed
@ -169,8 +165,6 @@ template <typename B, typename S, unsigned N> class RangeArray {
#ifdef ASSERT_RANGEMAP_ARE_SORTED
bool IsSorted() const {
typename Collection::const_iterator pos, end, prev;
// First we determine if we can combine any of the Entry objects so we
// don't end up allocating and making a new collection for no reason
for (pos = m_entries.begin(), end = m_entries.end(), prev = end; pos != end;
prev = pos++) {
if (prev != end && *pos < *prev)
@ -639,201 +633,12 @@ struct RangeData : public Range<B, S> {
}
};
template <typename B, typename S, typename T, unsigned N> class RangeDataArray {
template <typename B, typename S, typename T, unsigned N = 0>
class RangeDataVector {
public:
typedef RangeData<B, S, T> Entry;
typedef llvm::SmallVector<Entry, N> Collection;
RangeDataArray() = default;
~RangeDataArray() = default;
void Append(const Entry &entry) { m_entries.push_back(entry); }
void Sort() {
if (m_entries.size() > 1)
std::stable_sort(m_entries.begin(), m_entries.end());
}
#ifdef ASSERT_RANGEMAP_ARE_SORTED
bool IsSorted() const {
typename Collection::const_iterator pos, end, prev;
// First we determine if we can combine any of the Entry objects so we
// don't end up allocating and making a new collection for no reason
for (pos = m_entries.begin(), end = m_entries.end(), prev = end; pos != end;
prev = pos++) {
if (prev != end && *pos < *prev)
return false;
}
return true;
}
#endif
void CombineConsecutiveEntriesWithEqualData() {
#ifdef ASSERT_RANGEMAP_ARE_SORTED
assert(IsSorted());
#endif
typename Collection::iterator pos;
typename Collection::iterator end;
typename Collection::iterator prev;
bool can_combine = false;
// First we determine if we can combine any of the Entry objects so we
// don't end up allocating and making a new collection for no reason
for (pos = m_entries.begin(), end = m_entries.end(), prev = end; pos != end;
prev = pos++) {
if (prev != end && prev->data == pos->data) {
can_combine = true;
break;
}
}
// We we can combine at least one entry, then we make a new collection and
// populate it accordingly, and then swap it into place.
if (can_combine) {
Collection minimal_ranges;
for (pos = m_entries.begin(), end = m_entries.end(), prev = end;
pos != end; prev = pos++) {
if (prev != end && prev->data == pos->data)
minimal_ranges.back().SetRangeEnd(pos->GetRangeEnd());
else
minimal_ranges.push_back(*pos);
}
// Use the swap technique in case our new vector is much smaller. We must
// swap when using the STL because std::vector objects never release or
// reduce the memory once it has been allocated/reserved.
m_entries.swap(minimal_ranges);
}
}
void Clear() { m_entries.clear(); }
bool IsEmpty() const { return m_entries.empty(); }
size_t GetSize() const { return m_entries.size(); }
const Entry *GetEntryAtIndex(size_t i) const {
return ((i < m_entries.size()) ? &m_entries[i] : nullptr);
}
// Clients must ensure that "i" is a valid index prior to calling this
// function
const Entry &GetEntryRef(size_t i) const { return m_entries[i]; }
static bool BaseLessThan(const Entry &lhs, const Entry &rhs) {
return lhs.GetRangeBase() < rhs.GetRangeBase();
}
uint32_t FindEntryIndexThatContains(B addr) const {
#ifdef ASSERT_RANGEMAP_ARE_SORTED
assert(IsSorted());
#endif
if (!m_entries.empty()) {
Entry entry(addr, 1);
typename Collection::const_iterator begin = m_entries.begin();
typename Collection::const_iterator end = m_entries.end();
typename Collection::const_iterator pos =
std::lower_bound(begin, end, entry, BaseLessThan);
if (pos != end && pos->Contains(addr)) {
return std::distance(begin, pos);
} else if (pos != begin) {
--pos;
if (pos->Contains(addr))
return std::distance(begin, pos);
}
}
return UINT32_MAX;
}
Entry *FindEntryThatContains(B addr) {
#ifdef ASSERT_RANGEMAP_ARE_SORTED
assert(IsSorted());
#endif
if (!m_entries.empty()) {
Entry entry;
entry.SetRangeBase(addr);
entry.SetByteSize(1);
typename Collection::iterator begin = m_entries.begin();
typename Collection::iterator end = m_entries.end();
typename Collection::iterator pos =
std::lower_bound(begin, end, entry, BaseLessThan);
if (pos != end && pos->Contains(addr)) {
return &(*pos);
} else if (pos != begin) {
--pos;
if (pos->Contains(addr)) {
return &(*pos);
}
}
}
return nullptr;
}
const Entry *FindEntryThatContains(B addr) const {
#ifdef ASSERT_RANGEMAP_ARE_SORTED
assert(IsSorted());
#endif
if (!m_entries.empty()) {
Entry entry;
entry.SetRangeBase(addr);
entry.SetByteSize(1);
typename Collection::const_iterator begin = m_entries.begin();
typename Collection::const_iterator end = m_entries.end();
typename Collection::const_iterator pos =
std::lower_bound(begin, end, entry, BaseLessThan);
if (pos != end && pos->Contains(addr)) {
return &(*pos);
} else if (pos != begin) {
--pos;
if (pos->Contains(addr)) {
return &(*pos);
}
}
}
return nullptr;
}
const Entry *FindEntryThatContains(const Entry &range) const {
#ifdef ASSERT_RANGEMAP_ARE_SORTED
assert(IsSorted());
#endif
if (!m_entries.empty()) {
typename Collection::const_iterator begin = m_entries.begin();
typename Collection::const_iterator end = m_entries.end();
typename Collection::const_iterator pos =
std::lower_bound(begin, end, range, BaseLessThan);
if (pos != end && pos->Contains(range)) {
return &(*pos);
} else if (pos != begin) {
--pos;
if (pos->Contains(range)) {
return &(*pos);
}
}
}
return nullptr;
}
Entry *Back() { return (m_entries.empty() ? nullptr : &m_entries.back()); }
const Entry *Back() const {
return (m_entries.empty() ? nullptr : &m_entries.back());
}
protected:
Collection m_entries;
};
// Same as RangeDataArray, but uses std::vector as to not require static
// storage of N items in the class itself
template <typename B, typename S, typename T> class RangeDataVector {
public:
typedef RangeData<B, S, T> Entry;
typedef std::vector<Entry> Collection;
RangeDataVector() = default;
~RangeDataVector() = default;
@ -895,38 +700,8 @@ template <typename B, typename S, typename T> class RangeDataVector {
}
}
// Calculate the byte size of ranges with zero byte sizes by finding the next
// entry with a base address > the current base address
void CalculateSizesOfZeroByteSizeRanges(S full_size = 0) {
#ifdef ASSERT_RANGEMAP_ARE_SORTED
assert(IsSorted());
#endif
typename Collection::iterator pos;
typename Collection::iterator end;
typename Collection::iterator next;
for (pos = m_entries.begin(), end = m_entries.end(); pos != end; ++pos) {
if (pos->GetByteSize() == 0) {
// Watch out for multiple entries with same address and make sure we
// find an entry that is greater than the current base address before
// we use that for the size
auto curr_base = pos->GetRangeBase();
for (next = pos + 1; next != end; ++next) {
auto next_base = next->GetRangeBase();
if (next_base > curr_base) {
pos->SetByteSize(next_base - curr_base);
break;
}
}
if (next == end && full_size > curr_base)
pos->SetByteSize(full_size - curr_base);
}
}
}
void Clear() { m_entries.clear(); }
void Reserve(typename Collection::size_type size) { m_entries.resize(size); }
bool IsEmpty() const { return m_entries.empty(); }
size_t GetSize() const { return m_entries.size(); }
@ -948,22 +723,9 @@ template <typename B, typename S, typename T> class RangeDataVector {
}
uint32_t FindEntryIndexThatContains(B addr) const {
#ifdef ASSERT_RANGEMAP_ARE_SORTED
assert(IsSorted());
#endif
if (!m_entries.empty()) {
Entry entry(addr, 1);
typename Collection::const_iterator begin = m_entries.begin();
typename Collection::const_iterator end = m_entries.end();
typename Collection::const_iterator pos =
std::lower_bound(begin, end, entry, BaseLessThan);
while (pos != begin && pos[-1].Contains(addr))
--pos;
if (pos != end && pos->Contains(addr))
return std::distance(begin, pos);
}
const Entry *entry = FindEntryThatContains(addr);
if (entry)
return std::distance(m_entries.begin(), entry);
return UINT32_MAX;
}
@ -983,47 +745,13 @@ template <typename B, typename S, typename T> class RangeDataVector {
}
Entry *FindEntryThatContains(B addr) {
#ifdef ASSERT_RANGEMAP_ARE_SORTED
assert(IsSorted());
#endif
if (!m_entries.empty()) {
Entry entry;
entry.SetRangeBase(addr);
entry.SetByteSize(1);
typename Collection::iterator begin = m_entries.begin();
typename Collection::iterator end = m_entries.end();
typename Collection::iterator pos =
std::lower_bound(begin, end, entry, BaseLessThan);
while (pos != begin && pos[-1].Contains(addr))
--pos;
if (pos != end && pos->Contains(addr))
return &(*pos);
}
return nullptr;
return const_cast<Entry *>(
static_cast<const RangeDataVector *>(this)->FindEntryThatContains(
addr));
}
const Entry *FindEntryThatContains(B addr) const {
#ifdef ASSERT_RANGEMAP_ARE_SORTED
assert(IsSorted());
#endif
if (!m_entries.empty()) {
Entry entry;
entry.SetRangeBase(addr);
entry.SetByteSize(1);
typename Collection::const_iterator begin = m_entries.begin();
typename Collection::const_iterator end = m_entries.end();
typename Collection::const_iterator pos =
std::lower_bound(begin, end, entry, BaseLessThan);
while (pos != begin && pos[-1].Contains(addr))
--pos;
if (pos != end && pos->Contains(addr))
return &(*pos);
}
return nullptr;
return FindEntryThatContains(Entry(addr, 1));
}
const Entry *FindEntryThatContains(const Entry &range) const {

108
contrib/llvm/tools/lldb/include/lldb/Core/RichManglingContext.h Normal file
View File

@ -0,0 +1,108 @@
//===-- RichManglingContext.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_RichManglingContext_h_
#define liblldb_RichManglingContext_h_
#include "lldb/lldb-forward.h"
#include "lldb/lldb-private.h"
#include "lldb/Utility/ConstString.h"
#include "llvm/ADT/Any.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/Demangle/Demangle.h"
namespace lldb_private {
/// Uniform wrapper for access to rich mangling information from different
/// providers. See Mangled::DemangleWithRichManglingInfo()
class RichManglingContext {
public:
RichManglingContext() : m_provider(None), m_ipd_buf_size(2048) {
m_ipd_buf = static_cast<char *>(std::malloc(m_ipd_buf_size));
m_ipd_buf[0] = '\0';
}
~RichManglingContext() { std::free(m_ipd_buf); }
/// Use the ItaniumPartialDemangler to obtain rich mangling information from
/// the given mangled name.
bool FromItaniumName(const ConstString &mangled);
/// Use the legacy language parser implementation to obtain rich mangling
/// information from the given demangled name.
bool FromCxxMethodName(const ConstString &demangled);
/// If this symbol describes a constructor or destructor.
bool IsCtorOrDtor() const;
/// If this symbol describes a function.
bool IsFunction() const;
/// Get the base name of a function. This doesn't include trailing template
/// arguments, ie "a::b<int>" gives "b". The result will overwrite the
/// internal buffer. It can be obtained via GetBufferRef().
void ParseFunctionBaseName();
/// Get the context name for a function. For "a::b::c", this function returns
/// "a::b". The result will overwrite the internal buffer. It can be obtained
/// via GetBufferRef().
void ParseFunctionDeclContextName();
/// Get the entire demangled name. The result will overwrite the internal
/// buffer. It can be obtained via GetBufferRef().
void ParseFullName();
/// Obtain a StringRef to the internal buffer that holds the result of the
/// most recent ParseXy() operation. The next ParseXy() call invalidates it.
llvm::StringRef GetBufferRef() const {
assert(m_provider != None && "Initialize a provider first");
return m_buffer;
}
private:
enum InfoProvider { None, ItaniumPartialDemangler, PluginCxxLanguage };
/// Selects the rich mangling info provider.
InfoProvider m_provider;
/// Reference to the buffer used for results of ParseXy() operations.
llvm::StringRef m_buffer;
/// Members for ItaniumPartialDemangler
llvm::ItaniumPartialDemangler m_ipd;
char *m_ipd_buf;
size_t m_ipd_buf_size;
/// Members for PluginCxxLanguage
/// Cannot forward declare inner class CPlusPlusLanguage::MethodName. The
/// respective header is in Plugins and including it from here causes cyclic
/// dependency. Instead keep a llvm::Any and cast it on-access in the cpp.
llvm::Any m_cxx_method_parser;
/// Clean up memory and set a new info provider for this instance.
void ResetProvider(InfoProvider new_provider);
/// Uniform handling of string buffers for ItaniumPartialDemangler.
void processIPDStrResult(char *ipd_res, size_t res_len);
/// Cast the given parser to the given type. Ideally we would have a type
/// trait to deduce \a ParserT from a given InfoProvider, but unfortunately we
/// can't access CPlusPlusLanguage::MethodName from within the header.
template <class ParserT> static ParserT *get(llvm::Any parser) {
assert(parser.hasValue());
assert(llvm::any_isa<ParserT *>(parser));
return llvm::any_cast<ParserT *>(parser);
}
};
} // namespace lldb_private
#endif

4
contrib/llvm/tools/lldb/include/lldb/Core/STLUtils.h
View File

@ -10,16 +10,12 @@
#ifndef liblldb_STLUtils_h_
#define liblldb_STLUtils_h_
// C Includes
#include <string.h>
// C++ Includes
#include <map>
#include <ostream>
#include <vector>
// Other libraries and framework includes
// Project includes
//----------------------------------------------------------------------
// C string less than compare function object

29
contrib/llvm/tools/lldb/include/lldb/Core/SearchFilter.h
View File

@ -13,10 +13,10 @@
#include "lldb/Core/FileSpecList.h"
#include "lldb/Utility/StructuredData.h"
#include "lldb/Utility/FileSpec.h" // for FileSpec
#include "lldb/lldb-forward.h" // for SearchFilterSP, TargetSP, Modu...
#include "lldb/Utility/FileSpec.h"
#include "lldb/lldb-forward.h"
#include <stdint.h> // for uint32_t
#include <stdint.h>
namespace lldb_private {
class Address;
@ -70,15 +70,6 @@ class Searcher {
eCallbackReturnPop // Pop one level up and continue iterating
} CallbackReturn;
typedef enum {
eDepthTarget,
eDepthModule,
eDepthCompUnit,
eDepthFunction,
eDepthBlock,
eDepthAddress
} Depth;
Searcher();
virtual ~Searcher();
@ -87,7 +78,7 @@ class Searcher {
SymbolContext &context, Address *addr,
bool complete) = 0;
virtual Depth GetDepth() = 0;
virtual lldb::SearchDepth GetDepth() = 0;
//------------------------------------------------------------------
/// Prints a canonical description for the searcher to the stream \a s.
@ -192,6 +183,18 @@ class SearchFilter {
//------------------------------------------------------------------
virtual bool CompUnitPasses(CompileUnit &compUnit);
//------------------------------------------------------------------
/// Call this method with a Function to see if \a function passes the
/// filter.
///
/// @param[in] function
/// The Functions to check against the filter.
///
/// @return
/// \b true if \a function passes, and \b false otherwise.
//------------------------------------------------------------------
virtual bool FunctionPasses(Function &function);
//------------------------------------------------------------------
/// Call this method to do the search using the Searcher.
///

16
contrib/llvm/tools/lldb/include/lldb/Core/Section.h
View File

@ -14,16 +14,16 @@
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Flags.h"
#include "lldb/Utility/UserID.h"
#include "lldb/lldb-defines.h" // for DISALLOW_COPY_AND_ASSIGN
#include "lldb/lldb-enumerations.h" // for SectionType
#include "lldb/lldb-forward.h" // for SectionSP, ModuleSP, SectionWP
#include "lldb/lldb-types.h" // for addr_t, offset_t, user_id_t
#include "lldb/lldb-defines.h"
#include "lldb/lldb-enumerations.h"
#include "lldb/lldb-forward.h"
#include "lldb/lldb-types.h"
#include <memory> // for enable_shared_from_this
#include <vector> // for vector
#include <memory>
#include <vector>
#include <stddef.h> // for size_t
#include <stdint.h> // for uint32_t, UINT32_MAX
#include <stddef.h>
#include <stdint.h>
namespace lldb_private {
class Address;

12
contrib/llvm/tools/lldb/include/lldb/Core/SourceManager.h
View File

@ -11,16 +11,16 @@
#define liblldb_SourceManager_h_
#include "lldb/Utility/FileSpec.h"
#include "lldb/lldb-defines.h" // for DISALLOW_COPY_AND_ASSIGN
#include "lldb/lldb-forward.h" // for DebuggerSP, DebuggerWP, DataBufferSP
#include "lldb/lldb-defines.h"
#include "lldb/lldb-forward.h"
#include "llvm/Support/Chrono.h"
#include <cstdint> // for uint32_t, UINT32_MAX
#include <cstdint>
#include <map>
#include <memory>
#include <stddef.h> // for size_t
#include <string> // for string
#include <stddef.h>
#include <string>
#include <vector>
namespace lldb_private {
@ -52,7 +52,7 @@ class SourceManager {
void UpdateIfNeeded();
size_t DisplaySourceLines(uint32_t line, uint32_t column,
size_t DisplaySourceLines(uint32_t line, llvm::Optional<size_t> column,
uint32_t context_before, uint32_t context_after,
Stream *s);
void FindLinesMatchingRegex(RegularExpression &regex, uint32_t start_line,

5
contrib/llvm/tools/lldb/include/lldb/Core/StreamAsynchronousIO.h
View File

@ -14,7 +14,7 @@
#include <string>
#include <stddef.h> // for size_t
#include <stddef.h>
namespace lldb_private {
class Debugger;
@ -30,7 +30,8 @@ class StreamAsynchronousIO : public Stream {
void Flush() override;
size_t Write(const void *src, size_t src_len) override;
protected:
size_t WriteImpl(const void *src, size_t src_len) override;
private:
Debugger &m_debugger;

12
contrib/llvm/tools/lldb/include/lldb/Core/StreamBuffer.h
View File

@ -30,12 +30,6 @@ template <unsigned N> class StreamBuffer : public Stream {
// Nothing to do when flushing a buffer based stream...
}
virtual size_t Write(const void *s, size_t length) {
if (s && length)
m_packet.append((const char *)s, ((const char *)s) + length);
return length;
}
void Clear() { m_packet.clear(); }
// Beware, this might not be NULL terminated as you can expect from
@ -48,6 +42,12 @@ template <unsigned N> class StreamBuffer : public Stream {
protected:
llvm::SmallVector<char, N> m_packet;
virtual size_t WriteImpl(const void *s, size_t length) {
if (s && length)
m_packet.append((const char *)s, ((const char *)s) + length);
return length;
}
};
} // namespace lldb_private

10
contrib/llvm/tools/lldb/include/lldb/Core/StreamFile.h
View File

@ -12,11 +12,11 @@
#include "lldb/Host/File.h"
#include "lldb/Utility/Stream.h"
#include "lldb/lldb-defines.h" // for DISALLOW_COPY_AND_ASSIGN
#include "lldb/lldb-enumerations.h" // for FilePermissions::eFilePermission...
#include "lldb/lldb-defines.h"
#include "lldb/lldb-enumerations.h"
#include <stdint.h> // for uint32_t
#include <stdio.h> // for size_t, FILE
#include <stdint.h>
#include <stdio.h>
namespace lldb_private {
@ -46,13 +46,13 @@ class StreamFile : public Stream {
void Flush() override;
size_t Write(const void *s, size_t length) override;
protected:
//------------------------------------------------------------------
// Classes that inherit from StreamFile can see and modify these
//------------------------------------------------------------------
File m_file;
size_t WriteImpl(const void *s, size_t length) override;
private:
DISALLOW_COPY_AND_ASSIGN(StreamFile);

2
contrib/llvm/tools/lldb/include/lldb/Core/StructuredDataImpl.h
View File

@ -10,8 +10,8 @@
#ifndef liblldb_StructuredDataImpl_h_
#define liblldb_StructuredDataImpl_h_
#include "lldb/Core/Event.h"
#include "lldb/Target/StructuredDataPlugin.h"
#include "lldb/Utility/Event.h"
#include "lldb/Utility/Status.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Utility/StructuredData.h"

4
contrib/llvm/tools/lldb/include/lldb/Core/ThreadSafeDenseMap.h
View File

@ -11,14 +11,10 @@
#ifndef liblldb_ThreadSafeDenseMap_h_
#define liblldb_ThreadSafeDenseMap_h_
// C Includes
// C++ Includes
#include <mutex>
// Other libraries and framework includes
#include "llvm/ADT/DenseMap.h"
// Project includes
namespace lldb_private {

4
contrib/llvm/tools/lldb/include/lldb/Core/ThreadSafeDenseSet.h
View File

@ -11,14 +11,10 @@
#ifndef liblldb_ThreadSafeDenseSet_h_
#define liblldb_ThreadSafeDenseSet_h_
// C Includes
// C++ Includes
#include <mutex>
// Other libraries and framework includes
#include "llvm/ADT/DenseSet.h"
// Project includes
namespace lldb_private {

4
contrib/llvm/tools/lldb/include/lldb/Core/ThreadSafeSTLMap.h
View File

@ -10,13 +10,9 @@
#ifndef liblldb_ThreadSafeSTLMap_h_
#define liblldb_ThreadSafeSTLMap_h_
// C Includes
// C++ Includes
#include <map>
#include <mutex>
// Other libraries and framework includes
// Project includes
#include "lldb/lldb-defines.h"
namespace lldb_private {

4
contrib/llvm/tools/lldb/include/lldb/Core/ThreadSafeSTLVector.h
View File

@ -11,13 +11,9 @@
#ifndef liblldb_ThreadSafeSTLVector_h_
#define liblldb_ThreadSafeSTLVector_h_
// C Includes
// C++ Includes
#include <mutex>
#include <vector>
// Other libraries and framework includes
// Project includes
#include "lldb/lldb-defines.h"
namespace lldb_private {

4
contrib/llvm/tools/lldb/include/lldb/Core/ThreadSafeValue.h
View File

@ -10,13 +10,9 @@
#ifndef liblldb_ThreadSafeValue_h_
#define liblldb_ThreadSafeValue_h_
// C Includes
// C++ Includes
#include <mutex>
// Other libraries and framework includes
// Project includes
#include "lldb/lldb-defines.h"
namespace lldb_private {

6
contrib/llvm/tools/lldb/include/lldb/Core/UniqueCStringMap.h
View File

@ -10,13 +10,9 @@
#ifndef liblldb_UniqueCStringMap_h_
#define liblldb_UniqueCStringMap_h_
// C Includes
// C++ Includes
#include <algorithm>
#include <vector>
// Other libraries and framework includes
// Project includes
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/RegularExpression.h"
@ -221,7 +217,7 @@ template <typename T> class UniqueCStringMap {
// }
// my_map.Sort();
//------------------------------------------------------------------
void Sort() { std::sort(m_map.begin(), m_map.end()); }
void Sort() { llvm::sort(m_map.begin(), m_map.end()); }
//------------------------------------------------------------------
// Since we are using a vector to contain our items it will always double its

12
contrib/llvm/tools/lldb/include/lldb/Core/UserSettingsController.h
View File

@ -10,16 +10,16 @@
#ifndef liblldb_UserSettingsController_h_
#define liblldb_UserSettingsController_h_
#include "lldb/Utility/Status.h" // for Status
#include "lldb/lldb-forward.h" // for OptionValuePropertiesSP
#include "lldb/lldb-private-enumerations.h" // for VarSetOperationType
#include "lldb/Utility/Status.h"
#include "lldb/lldb-forward.h"
#include "lldb/lldb-private-enumerations.h"
#include "llvm/ADT/StringRef.h" // for StringRef
#include "llvm/ADT/StringRef.h"
#include <vector>
#include <stddef.h> // for size_t
#include <stdint.h> // for uint32_t
#include <stddef.h>
#include <stdint.h>
namespace lldb_private {
class CommandInterpreter;

14
contrib/llvm/tools/lldb/include/lldb/Core/Value.h
View File

@ -10,20 +10,20 @@
#ifndef liblldb_Value_h_
#define liblldb_Value_h_
#include "lldb/Core/Scalar.h"
#include "lldb/Symbol/CompilerType.h"
#include "lldb/Utility/DataBufferHeap.h"
#include "lldb/Utility/Scalar.h"
#include "lldb/Utility/Status.h"
#include "lldb/lldb-enumerations.h" // for ByteOrder, ByteOrder::eB...
#include "lldb/lldb-private-enumerations.h" // for AddressType
#include "lldb/lldb-private-types.h" // for type128, RegisterInfo
#include "lldb/lldb-enumerations.h"
#include "lldb/lldb-private-enumerations.h"
#include "lldb/lldb-private-types.h"
#include "llvm/ADT/APInt.h" // for APInt
#include "llvm/ADT/APInt.h"
#include <vector>
#include <stdint.h> // for uint8_t, uint32_t, uint64_t
#include <string.h> // for size_t, memcpy
#include <stdint.h>
#include <string.h>
namespace lldb_private {
class DataExtractor;

27
contrib/llvm/tools/lldb/include/lldb/Core/ValueObject.h
View File

@ -12,7 +12,7 @@
#include "lldb/Core/Value.h"
#include "lldb/Symbol/CompilerType.h"
#include "lldb/Symbol/Type.h" // for TypeImpl
#include "lldb/Symbol/Type.h"
#include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Process.h"
#include "lldb/Utility/ConstString.h"
@ -20,26 +20,26 @@
#include "lldb/Utility/SharedCluster.h"
#include "lldb/Utility/Status.h"
#include "lldb/Utility/UserID.h"
#include "lldb/lldb-defines.h" // for LLDB_INVALID...
#include "lldb/lldb-enumerations.h" // for DynamicValue...
#include "lldb/lldb-forward.h" // for ValueObjectSP
#include "lldb/lldb-private-enumerations.h" // for AddressType
#include "lldb/lldb-types.h" // for addr_t, offs...
#include "lldb/lldb-defines.h"
#include "lldb/lldb-enumerations.h"
#include "lldb/lldb-forward.h"
#include "lldb/lldb-private-enumerations.h"
#include "lldb/lldb-types.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/Optional.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringRef.h" // for StringRef
#include "llvm/ADT/StringRef.h"
#include <functional>
#include <initializer_list>
#include <map>
#include <mutex> // for recursive_mutex
#include <string> // for string
#include <utility> // for pair
#include <mutex>
#include <string>
#include <utility>
#include <stddef.h> // for size_t
#include <stdint.h> // for uint32_t
#include <stddef.h>
#include <stdint.h>
namespace lldb_private {
class Declaration;
}
@ -635,9 +635,6 @@ class ValueObject : public UserID {
virtual void SetLiveAddress(lldb::addr_t addr = LLDB_INVALID_ADDRESS,
AddressType address_type = eAddressTypeLoad) {}
// Find the address of the C++ vtable pointer
virtual lldb::addr_t GetCPPVTableAddress(AddressType &address_type);
virtual lldb::ValueObjectSP Cast(const CompilerType &compiler_type);
virtual lldb::ValueObjectSP CastPointerType(const char *name,

12
contrib/llvm/tools/lldb/include/lldb/Core/ValueObjectCast.h
View File

@ -11,13 +11,13 @@
#define liblldb_ValueObjectCast_h_
#include "lldb/Core/ValueObject.h"
#include "lldb/Symbol/CompilerType.h" // for CompilerType
#include "lldb/lldb-defines.h" // for DISALLOW_COPY_AND_ASSIGN
#include "lldb/lldb-enumerations.h" // for ValueType
#include "lldb/lldb-forward.h" // for ValueObjectSP
#include "lldb/Symbol/CompilerType.h"
#include "lldb/lldb-defines.h"
#include "lldb/lldb-enumerations.h"
#include "lldb/lldb-forward.h"
#include <stddef.h> // for size_t
#include <stdint.h> // for uint32_t, uint64_t
#include <stddef.h>
#include <stdint.h>
namespace lldb_private {
class ConstString;

16
contrib/llvm/tools/lldb/include/lldb/Core/ValueObjectChild.h
View File

@ -12,17 +12,17 @@
#include "lldb/Core/ValueObject.h"
#include "lldb/Symbol/CompilerType.h" // for CompilerType
#include "lldb/Utility/ConstString.h" // for ConstString
#include "lldb/lldb-defines.h" // for DISALLOW_COPY_AND_ASSIGN
#include "lldb/lldb-enumerations.h" // for ValueType
#include "lldb/lldb-private-enumerations.h" // for LazyBool, AddressType
#include "lldb/lldb-types.h" // for offset_t
#include "lldb/Symbol/CompilerType.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/lldb-defines.h"
#include "lldb/lldb-enumerations.h"
#include "lldb/lldb-private-enumerations.h"
#include "lldb/lldb-types.h"
#include "llvm/ADT/Optional.h"
#include <stddef.h> // for size_t
#include <stdint.h> // for uint32_t, uint64_t, int32_t
#include <stddef.h>
#include <stdint.h>
namespace lldb_private {

22
contrib/llvm/tools/lldb/include/lldb/Core/ValueObjectConstResult.h
View File

@ -10,20 +10,20 @@
#ifndef liblldb_ValueObjectConstResult_h_
#define liblldb_ValueObjectConstResult_h_
#include "lldb/Core/Value.h" // for Value
#include "lldb/Core/Value.h"
#include "lldb/Core/ValueObject.h"
#include "lldb/Core/ValueObjectConstResultImpl.h"
#include "lldb/Symbol/CompilerType.h" // for CompilerType
#include "lldb/Utility/ConstString.h" // for ConstString
#include "lldb/Utility/Status.h" // for Status
#include "lldb/lldb-defines.h" // for LLDB_INVALID_ADDRESS
#include "lldb/lldb-enumerations.h" // for ByteOrder, Dynamic...
#include "lldb/lldb-forward.h" // for ValueObjectSP, Dat...
#include "lldb/lldb-private-enumerations.h" // for AddressType, Addre...
#include "lldb/lldb-types.h" // for addr_t
#include "lldb/Symbol/CompilerType.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Status.h"
#include "lldb/lldb-defines.h"
#include "lldb/lldb-enumerations.h"
#include "lldb/lldb-forward.h"
#include "lldb/lldb-private-enumerations.h"
#include "lldb/lldb-types.h"
#include <stddef.h> // for size_t
#include <stdint.h> // for uint32_t, uint64_t
#include <stddef.h>
#include <stdint.h>
namespace lldb_private {
class DataExtractor;

14
contrib/llvm/tools/lldb/include/lldb/Core/ValueObjectConstResultCast.h
View File

@ -12,14 +12,14 @@
#include "lldb/Core/ValueObjectCast.h"
#include "lldb/Core/ValueObjectConstResultImpl.h"
#include "lldb/Symbol/CompilerType.h" // for CompilerType
#include "lldb/Utility/ConstString.h" // for ConstString
#include "lldb/lldb-defines.h" // for DISALLOW_COPY_AND_...
#include "lldb/lldb-forward.h" // for ValueObjectSP
#include "lldb/lldb-types.h" // for addr_t
#include "lldb/Symbol/CompilerType.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/lldb-defines.h"
#include "lldb/lldb-forward.h"
#include "lldb/lldb-types.h"
#include <stddef.h> // for size_t
#include <stdint.h> // for uint32_t, int32_t
#include <stddef.h>
#include <stdint.h>
namespace lldb_private {
class DataExtractor;

17
contrib/llvm/tools/lldb/include/lldb/Core/ValueObjectConstResultChild.h
View File

@ -12,14 +12,14 @@
#include "lldb/Core/ValueObjectChild.h"
#include "lldb/Core/ValueObjectConstResultImpl.h"
#include "lldb/Symbol/CompilerType.h" // for CompilerType
#include "lldb/Utility/ConstString.h" // for ConstString
#include "lldb/lldb-defines.h" // for DISALLOW_COPY_AND_...
#include "lldb/lldb-forward.h" // for ValueObjectSP
#include "lldb/lldb-types.h" // for addr_t
#include "lldb/Symbol/CompilerType.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/lldb-defines.h"
#include "lldb/lldb-forward.h"
#include "lldb/lldb-types.h"
#include <stddef.h> // for size_t
#include <stdint.h> // for uint32_t, int32_t
#include <stddef.h>
#include <stdint.h>
namespace lldb_private {
class DataExtractor;
}
@ -63,6 +63,9 @@ class ValueObjectConstResultChild : public ValueObjectChild {
lldb::ValueObjectSP AddressOf(Status &error) override;
lldb::addr_t GetAddressOf(bool scalar_is_load_address = true,
AddressType *address_type = nullptr) override;
size_t GetPointeeData(DataExtractor &data, uint32_t item_idx = 0,
uint32_t item_count = 1) override;

14
contrib/llvm/tools/lldb/include/lldb/Core/ValueObjectConstResultImpl.h
View File

@ -10,14 +10,14 @@
#ifndef liblldb_ValueObjectConstResultImpl_h_
#define liblldb_ValueObjectConstResultImpl_h_
#include "lldb/Utility/ConstString.h" // for ConstString
#include "lldb/lldb-defines.h" // for LLDB_INVALID_ADDRESS
#include "lldb/lldb-forward.h" // for ValueObjectSP
#include "lldb/lldb-private-enumerations.h" // for AddressType, AddressType...
#include "lldb/lldb-types.h" // for addr_t
#include "lldb/Utility/ConstString.h"
#include "lldb/lldb-defines.h"
#include "lldb/lldb-forward.h"
#include "lldb/lldb-private-enumerations.h"
#include "lldb/lldb-types.h"
#include <stddef.h> // for size_t
#include <stdint.h> // for uint32_t, int32_t
#include <stddef.h>
#include <stdint.h>
namespace lldb_private {
class CompilerType;
}

22
contrib/llvm/tools/lldb/include/lldb/Core/ValueObjectDynamicValue.h
View File

@ -10,20 +10,20 @@
#ifndef liblldb_ValueObjectDynamicValue_h_
#define liblldb_ValueObjectDynamicValue_h_
#include "lldb/Core/Address.h" // for Address
#include "lldb/Core/Address.h"
#include "lldb/Core/ValueObject.h"
#include "lldb/Symbol/CompilerType.h" // for CompilerType
#include "lldb/Symbol/CompilerType.h"
#include "lldb/Symbol/Type.h"
#include "lldb/Utility/ConstString.h" // for ConstString
#include "lldb/Utility/SharingPtr.h" // for operator==
#include "lldb/lldb-defines.h" // for DISALLOW_COPY_AND_ASSIGN
#include "lldb/lldb-enumerations.h" // for DynamicValueType, Langua...
#include "lldb/lldb-forward.h" // for ValueObjectSP, VariableSP
#include "lldb/lldb-private-enumerations.h" // for LazyBool, LazyBool::eLaz...
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/SharingPtr.h"
#include "lldb/lldb-defines.h"
#include "lldb/lldb-enumerations.h"
#include "lldb/lldb-forward.h"
#include "lldb/lldb-private-enumerations.h"
#include <assert.h> // for assert
#include <stddef.h> // for size_t
#include <stdint.h> // for uint64_t, uint32_t
#include <assert.h>
#include <stddef.h>
#include <stdint.h>
namespace lldb_private {
class DataExtractor;

6
contrib/llvm/tools/lldb/include/lldb/Core/ValueObjectList.h
View File

@ -10,12 +10,12 @@
#ifndef liblldb_ValueObjectList_h_
#define liblldb_ValueObjectList_h_
#include "lldb/lldb-forward.h" // for ValueObjectSP
#include "lldb/lldb-types.h" // for user_id_t
#include "lldb/lldb-forward.h"
#include "lldb/lldb-types.h"
#include <vector>
#include <stddef.h> // for size_t
#include <stddef.h>
namespace lldb_private {
class ValueObject;

16
contrib/llvm/tools/lldb/include/lldb/Core/ValueObjectMemory.h
View File

@ -10,17 +10,17 @@
#ifndef liblldb_ValueObjectMemory_h_
#define liblldb_ValueObjectMemory_h_
#include "lldb/Core/Address.h" // for Address
#include "lldb/Core/Address.h"
#include "lldb/Core/ValueObject.h"
#include "lldb/Symbol/CompilerType.h"
#include "lldb/Utility/ConstString.h" // for ConstString
#include "lldb/lldb-defines.h" // for DISALLOW_COPY_AND_ASSIGN
#include "lldb/lldb-enumerations.h" // for ValueType
#include "lldb/lldb-forward.h" // for TypeSP, ValueObjectSP, ModuleSP
#include "llvm/ADT/StringRef.h" // for StringRef
#include "lldb/Utility/ConstString.h"
#include "lldb/lldb-defines.h"
#include "lldb/lldb-enumerations.h"
#include "lldb/lldb-forward.h"
#include "llvm/ADT/StringRef.h"
#include <stddef.h> // for size_t
#include <stdint.h> // for uint32_t, uint64_t
#include <stddef.h>
#include <stdint.h>
namespace lldb_private {
class ExecutionContextScope;

18
contrib/llvm/tools/lldb/include/lldb/Core/ValueObjectRegister.h
View File

@ -10,17 +10,17 @@
#ifndef liblldb_ValueObjectRegister_h_
#define liblldb_ValueObjectRegister_h_
#include "lldb/Core/RegisterValue.h"
#include "lldb/Core/ValueObject.h"
#include "lldb/Symbol/CompilerType.h" // for CompilerType
#include "lldb/Utility/ConstString.h" // for ConstString
#include "lldb/lldb-defines.h" // for DISALLOW_COPY_AND_ASSIGN
#include "lldb/lldb-enumerations.h" // for ValueType, ValueType::eValueTy...
#include "lldb/lldb-forward.h" // for RegisterContextSP, ValueObjectSP
#include "lldb/lldb-private-types.h" // for RegisterInfo, RegisterSet (ptr...
#include "lldb/Symbol/CompilerType.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/RegisterValue.h"
#include "lldb/lldb-defines.h"
#include "lldb/lldb-enumerations.h"
#include "lldb/lldb-forward.h"
#include "lldb/lldb-private-types.h"
#include <stddef.h> // for size_t
#include <stdint.h> // for uint32_t, uint64_t, int32_t
#include <stddef.h>
#include <stdint.h>
namespace lldb_private {
class DataExtractor;

16
contrib/llvm/tools/lldb/include/lldb/Core/ValueObjectSyntheticFilter.h
View File

@ -13,17 +13,17 @@
#include "lldb/Core/ThreadSafeSTLMap.h"
#include "lldb/Core/ThreadSafeSTLVector.h"
#include "lldb/Core/ValueObject.h"
#include "lldb/Symbol/CompilerType.h" // for CompilerType
#include "lldb/Utility/ConstString.h" // for ConstString
#include "lldb/lldb-defines.h" // for ThreadSafeSTLMap::operator=
#include "lldb/lldb-enumerations.h" // for DynamicValueType, Langua...
#include "lldb/lldb-forward.h" // for ValueObjectSP, Synthetic...
#include "lldb/lldb-private-enumerations.h" // for LazyBool, LazyBool::eLaz...
#include "lldb/Symbol/CompilerType.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/lldb-defines.h"
#include "lldb/lldb-enumerations.h"
#include "lldb/lldb-forward.h"
#include "lldb/lldb-private-enumerations.h"
#include <cstdint> // for uint32_t, uint64_t
#include <cstdint>
#include <memory>
#include <stddef.h> // for size_t
#include <stddef.h>
namespace lldb_private {
class Declaration;

Some files were not shown because too many files have changed in this diff Show More