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

Merge lldb trunk r300422 and resolve conflicts.

Browse Source
This commit is contained in:
Dimitry Andric 2017-04-16 16:48:25 +00:00
commit f678e45dc4
Notes: svn2git 2020-12-20 02:59:44 +00:00 
svn path=/projects/clang500-import/; revision=317032
889 changed files with 16258 additions and 13380 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -86,7 +86,7 @@ class LLDB_API SBAttachInfo {
/// This function implies that a call to SBTarget::Attach(...) will
/// be synchronous.
///
/// @param[in] wait_for
/// @param[in] b
/// If \b false, attach to an existing process whose name matches.
/// If \b true, then wait for the next process whose name matches.
//------------------------------------------------------------------
@ -99,7 +99,7 @@ class LLDB_API SBAttachInfo {
/// Future calls to SBTarget::Attach(...) will be synchronous or
/// asynchronous depending on the \a async argument.
///
/// @param[in] wait_for
/// @param[in] b
/// If \b false, attach to an existing process whose name matches.
/// If \b true, then wait for the next process whose name matches.
///

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

@ -133,19 +133,13 @@ class LLDB_API SBBreakpoint {
SBBreakpoint(const lldb::BreakpointSP &bp_sp);
lldb_private::Breakpoint *operator->() const;
lldb_private::Breakpoint *get() const;
lldb::BreakpointSP &operator*();
const lldb::BreakpointSP &operator*() const;
static bool PrivateBreakpointHitCallback(
void *baton, lldb_private::StoppointCallbackContext *context,
lldb::user_id_t break_id, lldb::user_id_t break_loc_id);
lldb::BreakpointSP m_opaque_sp;
lldb::BreakpointSP GetSP() const;
lldb::BreakpointWP m_opaque_wp;
};
class LLDB_API SBBreakpointList {

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

@ -78,8 +78,9 @@ class LLDB_API SBBreakpointLocation {
friend class SBBreakpoint;
void SetLocation(const lldb::BreakpointLocationSP &break_loc_sp);
BreakpointLocationSP GetSP() const;
lldb::BreakpointLocationSP m_opaque_sp;
lldb::BreakpointLocationWP m_opaque_wp;
};
} // namespace lldb

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

@ -78,6 +78,10 @@ class LLDB_API SBFrame {
const char *GetDisplayFunctionName();
const char *GetFunctionName() const;
// Return the frame function's language. If there isn't a function, then
// guess the language type from the mangled name.
lldb::LanguageType GuessLanguage() const;
/// Return true if this frame represents an inlined function.
///

2
contrib/llvm/tools/lldb/include/lldb/API/SBListener.h
View File

@ -89,7 +89,7 @@ class LLDB_API SBListener {
SBListener(const lldb::ListenerSP &listener_sp);
lldb::ListenerSP GetSP() { return m_opaque_sp; }
lldb::ListenerSP GetSP();
private:
lldb_private::Listener *operator->() const;

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

@ -124,9 +124,6 @@ class LLDB_API SBTarget {
/// @param[in] envp
/// The environment array.
///
/// @param[in] launch_flags
/// Flags to modify the launch (@see lldb::LaunchFlags)
///
/// @param[in] stdin_path
/// The path to use when re-directing the STDIN of the new
/// process. If all stdXX_path arguments are nullptr, a pseudo
@ -480,6 +477,7 @@ class LLDB_API SBTarget {
/// Resolve a current file address into a section offset address.
///
/// @param[in] file_addr
/// The file address to resolve.
///
/// @return
/// An SBAddress which will be valid if...
@ -653,7 +651,7 @@ class LLDB_API SBTarget {
/// @param[in] source_file
/// The file from which to read the breakpoints.
///
/// @param[out] bkpt_list
/// @param[out] new_bps
/// A list of the newly created breakpoints.
///
/// @return
@ -673,7 +671,7 @@ class LLDB_API SBTarget {
/// Only read in breakpoints whose names match one of the names in this
/// list.
///
/// @param[out] bkpt_list
/// @param[out] new_bps
/// A list of the newly created breakpoints.
///
/// @return

2
contrib/llvm/tools/lldb/include/lldb/API/SBWatchpoint.h
View File

@ -72,7 +72,7 @@ class LLDB_API SBWatchpoint {
friend class SBTarget;
friend class SBValue;
lldb::WatchpointSP m_opaque_sp;
std::weak_ptr<lldb_private::Watchpoint> m_opaque_wp;
};
} // namespace lldb

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

@ -26,8 +26,8 @@
#include "lldb/Breakpoint/Stoppoint.h"
#include "lldb/Core/Event.h"
#include "lldb/Core/SearchFilter.h"
#include "lldb/Core/StringList.h"
#include "lldb/Core/StructuredData.h"
#include "lldb/Utility/StringList.h"
namespace lldb_private {

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

@ -19,7 +19,7 @@
// Project includes
#include "lldb/Breakpoint/StoppointLocation.h"
#include "lldb/Core/Address.h"
#include "lldb/Core/UserID.h"
#include "lldb/Utility/UserID.h"
#include "lldb/lldb-private.h"
namespace lldb_private {

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

@ -17,9 +17,9 @@
// Other libraries and framework includes
// Project includes
#include "lldb/Core/Baton.h"
#include "lldb/Core/StringList.h"
#include "lldb/Core/StructuredData.h"
#include "lldb/Utility/Baton.h"
#include "lldb/Utility/StringList.h"
#include "lldb/lldb-private.h"
namespace lldb_private {

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

@ -15,12 +15,11 @@
// Other libraries and framework includes
// Project includes
#include "lldb/Breakpoint/Breakpoint.h"
#include "lldb/Breakpoint/BreakpointResolver.h"
#include "lldb/Core/Address.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/RegularExpression.h"
#include "lldb/Core/SearchFilter.h"
#include "lldb/Host/FileSpec.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/FileSpec.h"
#include "lldb/Utility/RegularExpression.h"
#include "lldb/lldb-private.h"
namespace lldb_private {

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

@ -63,6 +63,8 @@ class BreakpointResolverFileLine : public BreakpointResolver {
lldb::BreakpointResolverSP CopyForBreakpoint(Breakpoint &breakpoint) override;
protected:
void FilterContexts(SymbolContextList &sc_list);
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.

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

@ -17,7 +17,7 @@
// Other libraries and framework includes
// Project includes
#include "lldb/Breakpoint/BreakpointResolver.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Utility/ConstString.h"
namespace lldb_private {

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

@ -21,7 +21,7 @@
// Project includes
#include "lldb/Breakpoint/BreakpointLocationCollection.h"
#include "lldb/Breakpoint/StoppointLocation.h"
#include "lldb/Core/UserID.h"
#include "lldb/Utility/UserID.h"
#include "lldb/lldb-forward.h"
namespace lldb_private {

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

@ -14,7 +14,7 @@
// C++ Includes
// Other libraries and framework includes
// Project includes
#include "lldb/Core/UserID.h"
#include "lldb/Utility/UserID.h"
#include "lldb/lldb-private.h"
namespace lldb_private {

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

@ -14,7 +14,7 @@
// C++ Includes
// Other libraries and framework includes
// Project includes
#include "lldb/Core/UserID.h"
#include "lldb/Utility/UserID.h"
#include "lldb/lldb-private.h"
// #include "lldb/Breakpoint/BreakpointOptions.h"

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

@ -19,9 +19,9 @@
// Project includes
#include "lldb/Breakpoint/StoppointLocation.h"
#include "lldb/Breakpoint/WatchpointOptions.h"
#include "lldb/Core/UserID.h"
#include "lldb/Symbol/CompilerType.h"
#include "lldb/Target/Target.h"
#include "lldb/Utility/UserID.h"
#include "lldb/lldb-private.h"
namespace lldb_private {

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

@ -17,8 +17,8 @@
// Other libraries and framework includes
// Project includes
#include "lldb/Core/Baton.h"
#include "lldb/Core/StringList.h"
#include "lldb/Utility/Baton.h"
#include "lldb/Utility/StringList.h"
#include "lldb/lldb-private.h"
namespace lldb_private {

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

@ -10,13 +10,44 @@
#ifndef liblldb_Address_h_
#define liblldb_Address_h_
// C Includes
// C++ Includes
#include "lldb/lldb-defines.h" // for LLDB_INVALID_ADDRESS
#include "lldb/lldb-enumerations.h" // for AddressClass::eAddressClassInvalid
#include "lldb/lldb-forward.h" // for SectionWP, SectionSP, ModuleSP
#include "lldb/lldb-types.h" // for addr_t
// Other libraries and framework includes
// Project includes
#include "lldb/Symbol/SymbolContextScope.h"
#include "lldb/lldb-private.h"
#include <stddef.h> // for size_t
#include <stdint.h> // for uint32_t, UINT32_MAX, int64_t
namespace lldb_private {
class Block;
}
namespace lldb_private {
class CompileUnit;
}
namespace lldb_private {
class ExecutionContextScope;
}
namespace lldb_private {
class Function;
}
namespace lldb_private {
class SectionList;
}
namespace lldb_private {
class Stream;
}
namespace lldb_private {
class Symbol;
}
namespace lldb_private {
class SymbolContext;
}
namespace lldb_private {
class Target;
}
namespace lldb_private {
struct LineEntry;
}
namespace lldb_private {

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

@ -10,11 +10,21 @@
#ifndef liblldb_AddressRange_h_
#define liblldb_AddressRange_h_
// C Includes
// C++ Includes
// Other libraries and framework includes
// Project includes
#include "lldb/Core/Address.h"
#include "lldb/lldb-forward.h" // for SectionSP
#include "lldb/lldb-types.h" // for addr_t
#include <stddef.h> // for size_t
namespace lldb_private {
class SectionList;
}
namespace lldb_private {
class Stream;
}
namespace lldb_private {
class Target;
}
namespace lldb_private {

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

@ -10,19 +10,19 @@
#ifndef liblldb_AddressResolver_h_
#define liblldb_AddressResolver_h_
#include "lldb/Core/AddressRange.h"
#include "lldb/Core/SearchFilter.h"
#include "lldb/lldb-defines.h" // for DISALLOW_COPY_AND_ASSIGN
#include <stddef.h> // for size_t
#include <vector>
// C Includes
// C++ Includes
// Other libraries and framework includes
// Project includes
#include "lldb/Core/Address.h"
#include "lldb/Core/AddressRange.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/SearchFilter.h"
#include "lldb/Host/FileSpec.h"
#include "lldb/lldb-private.h"
namespace lldb_private {
class ModuleList;
}
namespace lldb_private {
class Stream;
}
namespace lldb_private {
//----------------------------------------------------------------------

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

@ -10,8 +10,22 @@
#ifndef liblldb_AddressResolverFileLine_h_
#define liblldb_AddressResolverFileLine_h_
// Project includes
#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 <stdint.h> // for uint32_t
namespace lldb_private {
class Address;
}
namespace lldb_private {
class Stream;
}
namespace lldb_private {
class SymbolContext;
}
namespace lldb_private {

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

@ -10,10 +10,21 @@
#ifndef liblldb_AddressResolverName_h_
#define liblldb_AddressResolverName_h_
// Project includes
#include "lldb/Core/AddressResolver.h"
#include "lldb/Core/RegularExpression.h"
#include "lldb/Core/SearchFilter.h" // for Searcher, Searcher::Call...
#include "lldb/Utility/ConstString.h" // for ConstString
#include "lldb/Utility/RegularExpression.h"
#include "lldb/lldb-defines.h" // for DISALLOW_COPY_AND_ASSIGN
namespace lldb_private {
class Address;
}
namespace lldb_private {
class Stream;
}
namespace lldb_private {
class SymbolContext;
}
namespace lldb_private {

28
contrib/llvm/tools/lldb/include/lldb/Core/ArchSpec.h
View File

@ -12,13 +12,31 @@
#if defined(__cplusplus)
#include "lldb/Core/ConstString.h"
#include "lldb/lldb-forward.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/lldb-enumerations.h"
#include "lldb/lldb-private-enumerations.h"
#include "llvm/ADT/StringRef.h" // for StringRef
#include "llvm/ADT/Triple.h"
namespace lldb_private {
#include <string> // for string
struct CoreDefinition;
#include <stddef.h> // for size_t
#include <stdint.h> // for uint32_t
namespace lldb_private {
class Platform;
}
namespace lldb_private {
class Stream;
}
namespace lldb_private {
class StringList;
}
namespace lldb_private {
class Thread;
}
namespace lldb_private {
//----------------------------------------------------------------------
/// @class ArchSpec ArchSpec.h "lldb/Core/ArchSpec.h"
@ -307,7 +325,7 @@ class ArchSpec {
/// @return A string representing target CPU for the current
/// architecture.
//------------------------------------------------------------------
std::string GetClangTargetCPU();
std::string GetClangTargetCPU() const;
//------------------------------------------------------------------
/// Return a string representing target application ABI.

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

@ -10,22 +10,34 @@
#ifndef liblldb_Broadcaster_h_
#define liblldb_Broadcaster_h_
// C Includes
// C++ Includes
#include <functional>
#include <list>
#include <map>
#include <mutex>
#include <string>
#include <vector>
// Other libraries and framework includes
// Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/lldb-private.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/lldb-defines.h" // for DISALLOW_COPY_AND_ASSIGN
#include "lldb/lldb-forward.h" // for ListenerSP, EventSP, Broadcast...
#include "llvm/ADT/SmallVector.h"
#include <cstdint> // for uint32_t, UINT32_MAX
#include <map>
#include <memory> // for shared_ptr, operator==, enable...
#include <mutex>
#include <set> // for set
#include <string>
#include <utility> // for pair
#include <vector>
namespace lldb_private {
class Broadcaster;
}
namespace lldb_private {
class EventData;
}
namespace lldb_private {
class Listener;
}
namespace lldb_private {
class Stream;
}
namespace lldb_private {
//----------------------------------------------------------------------
@ -82,8 +94,8 @@ class BroadcasterManager
public:
// Listeners hold onto weak pointers to their broadcaster managers. So they
// must be
// made into shared pointers, which you do with MakeBroadcasterManager.
// must be made into shared pointers, which you do with
// MakeBroadcasterManager.
static lldb::BroadcasterManagerSP MakeBroadcasterManager();

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

@ -10,19 +10,31 @@
#ifndef liblldb_Communication_h_
#define liblldb_Communication_h_
// C Includes
// C++ Includes
#include <atomic>
#include <mutex>
#include <string>
// Other libraries and framework includes
// Project includes
#include "lldb/Core/Broadcaster.h"
#include "lldb/Core/Error.h"
#include "lldb/Host/HostThread.h"
#include "lldb/Utility/Timeout.h"
#include "lldb/lldb-private.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 <atomic>
#include <mutex>
#include <ratio> // for micro
#include <string>
#include <stddef.h> // for size_t
#include <stdint.h> // for uint8_t
namespace lldb_private {
class Connection;
}
namespace lldb_private {
class ConstString;
}
namespace lldb_private {
class Error;
}
namespace lldb_private {

21
contrib/llvm/tools/lldb/include/lldb/Core/Connection.h
View File

@ -10,15 +10,24 @@
#ifndef liblldb_Connection_h_
#define liblldb_Connection_h_
// Other libraries and framework includes
// Project includes
#include "lldb/Utility/Timeout.h"
#include "lldb/lldb-private.h"
#include "lldb/lldb-defines.h" // for DISALLOW_COPY_AND_ASSIGN
#include "lldb/lldb-enumerations.h" // for ConnectionStatus
#include "lldb/lldb-forward.h" // for IOObjectSP
// C Includes
// C++ Includes
#include "llvm/ADT/StringRef.h" // for StringRef
#include <ratio> // for micro
#include <string>
#include <stddef.h> // for size_t
namespace lldb_private {
class Error;
}
namespace lldb_private {
template <typename Ratio> class Timeout;
}
namespace lldb_private {
//----------------------------------------------------------------------

154
contrib/llvm/tools/lldb/include/lldb/Core/DataBufferMemoryMap.h
View File

@ -1,154 +0,0 @@
//===-- DataBufferMemoryMap.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_DataBufferMemoryMap_h_
#define liblldb_DataBufferMemoryMap_h_
#include "lldb/Core/DataBuffer.h"
#include "lldb/Core/Error.h"
#include "lldb/lldb-private.h"
#include <string>
namespace lldb_private {
//----------------------------------------------------------------------
/// @class DataBufferMemoryMap DataBufferMemoryMap.h
/// "lldb/Core/DataBufferMemoryMap.h"
/// @brief A subclass of DataBuffer that memory maps data.
///
/// This class memory maps data and stores any needed data for the
/// memory mapping in its internal state. Memory map requests are not
/// required to have any alignment or size constraints, this class will
/// work around any host OS issues regarding such things.
///
/// This class is designed to allow pages to be faulted in as needed and
/// works well data from large files that won't be accessed all at once.
//----------------------------------------------------------------------
class DataBufferMemoryMap : public DataBuffer {
public:
//------------------------------------------------------------------
/// Default Constructor
//------------------------------------------------------------------
DataBufferMemoryMap();
//------------------------------------------------------------------
/// Destructor.
///
/// Virtual destructor since this class inherits from a pure virtual
/// base class #DataBuffer.
//------------------------------------------------------------------
~DataBufferMemoryMap() override;
//------------------------------------------------------------------
/// Reverts this object to an empty state by unmapping any memory
/// that is currently owned.
//------------------------------------------------------------------
void Clear();
//------------------------------------------------------------------
/// @copydoc DataBuffer::GetBytes()
//------------------------------------------------------------------
uint8_t *GetBytes() override;
//------------------------------------------------------------------
/// @copydoc DataBuffer::GetBytes() const
//------------------------------------------------------------------
const uint8_t *GetBytes() const override;
//------------------------------------------------------------------
/// @copydoc DataBuffer::GetByteSize() const
//------------------------------------------------------------------
lldb::offset_t GetByteSize() const override;
//------------------------------------------------------------------
/// Error get accessor.
///
/// @return
/// A const reference to Error object in case memory mapping
/// fails.
//------------------------------------------------------------------
const Error &GetError() const;
//------------------------------------------------------------------
/// Memory map all or part of a file.
///
/// Memory map \a length bytes from \a file starting \a offset
/// bytes into the file. If \a length is set to \c SIZE_MAX,
/// then map as many bytes as possible.
///
/// @param[in] file
/// The file specification from which to map data.
///
/// @param[in] offset
/// The offset in bytes from the beginning of the file where
/// memory mapping should begin.
///
/// @param[in] length
/// The size in bytes that should be mapped starting \a offset
/// bytes into the file. If \a length is \c SIZE_MAX, map
/// as many bytes as possible. Even though it may be possible
/// for a 32-bit host debugger to debug a 64-bit target, size_t
/// still dictates the maximum possible size that can be mapped
/// into this process. For this kind of cross-arch debugging
/// scenario, mappings and views should be managed at a higher
/// level.
///
/// @return
/// The number of bytes mapped starting from the \a offset.
//------------------------------------------------------------------
size_t MemoryMapFromFileSpec(const FileSpec *file, lldb::offset_t offset = 0,
size_t length = SIZE_MAX,
bool writeable = false);
//------------------------------------------------------------------
/// Memory map all or part of a file.
///
/// Memory map \a length bytes from an opened file descriptor \a fd
/// starting \a offset bytes into the file. If \a length is set to
/// \c SIZE_MAX, then map as many bytes as possible.
///
/// @param[in] fd
/// The posix file descriptor for an already opened file
/// from which to map data.
///
/// @param[in] offset
/// The offset in bytes from the beginning of the file where
/// memory mapping should begin.
///
/// @param[in] length
/// The size in bytes that should be mapped starting \a offset
/// bytes into the file. If \a length is \c SIZE_MAX, map
/// as many bytes as possible.
///
/// @return
/// The number of bytes mapped starting from the \a offset.
//------------------------------------------------------------------
size_t MemoryMapFromFileDescriptor(int fd, lldb::offset_t offset,
size_t length, bool write,
bool fd_is_file);
protected:
//------------------------------------------------------------------
// Classes that inherit from DataBufferMemoryMap can see and modify these
//------------------------------------------------------------------
uint8_t *m_mmap_addr; ///< The actual pointer that was returned from \c mmap()
size_t m_mmap_size; ///< The actual number of bytes that were mapped when \c
///mmap() was called
uint8_t *m_data; ///< The data the user requested somewhere within the memory
///mapped data.
lldb::offset_t
m_size; ///< The size of the data the user got when data was requested
private:
DISALLOW_COPY_AND_ASSIGN(DataBufferMemoryMap);
};
} // namespace lldb_private
#endif // liblldb_DataBufferMemoryMap_h_

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

@ -14,9 +14,7 @@
#include <stdint.h>
// C++ Includes
#include <map>
#include <memory>
#include <mutex>
#include <vector>
// Other libraries and framework includes
@ -24,21 +22,55 @@
#include "lldb/Core/Broadcaster.h"
#include "lldb/Core/FormatEntity.h"
#include "lldb/Core/IOHandler.h"
#include "lldb/Core/Listener.h"
#include "lldb/Core/SourceManager.h"
#include "lldb/Core/UserID.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/Platform.h"
#include "lldb/Target/TargetList.h"
#include "lldb/lldb-public.h"
#include "lldb/Utility/ConstString.h" // for ConstString
#include "lldb/Utility/Error.h" // for Error
#include "lldb/Utility/FileSpec.h" // for FileSpec
#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 "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/Support/Threading.h"
#include <assert.h> // for assert
#include <stddef.h> // for size_t
#include <stdio.h>
namespace lldb_private {
class Address;
}
namespace lldb_private {
class CommandInterpreter;
}
namespace lldb_private {
class Process;
}
namespace lldb_private {
class Stream;
}
namespace lldb_private {
class SymbolContext;
}
namespace lldb_private {
class Target;
}
namespace llvm {
namespace sys {
class DynamicLibrary;
} // namespace sys
} // namespace llvm
class raw_ostream;
}
namespace lldb_private {
@ -190,9 +222,10 @@ class Debugger : public std::enable_shared_from_this<Debugger>,
void SetCloseInputOnEOF(bool b);
bool EnableLog(const char *channel, const char **categories,
const char *log_file, uint32_t log_options,
Stream &error_stream);
bool EnableLog(llvm::StringRef channel,
llvm::ArrayRef<const char *> categories,
llvm::StringRef log_file, uint32_t log_options,
llvm::raw_ostream &error_stream);
void SetLoggingCallback(lldb::LogOutputCallback log_callback, void *baton);
@ -363,9 +396,8 @@ class Debugger : public std::enable_shared_from_this<Debugger>,
std::unique_ptr<CommandInterpreter> m_command_interpreter_ap;
IOHandlerStack m_input_reader_stack;
typedef std::map<std::string, lldb::StreamWP> LogStreamMap;
LogStreamMap m_log_streams;
lldb::StreamSP m_log_callback_stream_sp;
llvm::StringMap<std::weak_ptr<llvm::raw_ostream>> m_log_streams;
std::shared_ptr<llvm::raw_ostream> m_log_callback_stream_sp;
ConstString m_instance_name;
static LoadPluginCallbackType g_load_plugin_callback;
typedef std::vector<llvm::sys::DynamicLibrary> LoadedPluginsList;
@ -374,7 +406,7 @@ class Debugger : public std::enable_shared_from_this<Debugger>,
HostThread m_io_handler_thread;
Broadcaster m_sync_broadcaster;
lldb::ListenerSP m_forward_listener_sp;
std::once_flag m_clear_once;
llvm::once_flag m_clear_once;
//----------------------------------------------------------------------
// Events for m_sync_broadcaster

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

@ -10,22 +10,68 @@
#ifndef liblldb_Disassembler_h_
#define liblldb_Disassembler_h_
// C Includes
// C++ Includes
#include <string>
#include <vector>
// Other libraries and framework includes
// Project includes
#include "lldb/Core/Address.h"
#include "lldb/Core/ArchSpec.h"
#include "lldb/Core/EmulateInstruction.h"
#include "lldb/Core/FormatEntity.h" // for FormatEntity
#include "lldb/Core/Opcode.h"
#include "lldb/Core/PluginInterface.h"
#include "lldb/Host/FileSpec.h"
#include "lldb/Interpreter/OptionValue.h"
#include "lldb/Symbol/LineEntry.h"
#include "lldb/lldb-private.h"
#include "lldb/Target/ExecutionContext.h" // for ExecutionContext
#include "lldb/Utility/ConstString.h" // for ConstString
#include "lldb/Utility/FileSpec.h"
#include "lldb/lldb-defines.h" // for DISALLOW_COPY_AND_ASSIGN
#include "lldb/lldb-enumerations.h" // for AddressClass, AddressClass...
#include "lldb/lldb-forward.h" // for InstructionSP, DisassemblerSP
#include "lldb/lldb-types.h" // for addr_t, offset_t
#include "llvm/ADT/StringRef.h" // for StringRef
#include <functional> // for function
#include <map>
#include <memory> // for enable_shared_from_this
#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
namespace lldb_private {
class AddressRange;
}
namespace lldb_private {
class DataExtractor;
}
namespace lldb_private {
class Debugger;
}
namespace lldb_private {
class Disassembler;
}
namespace lldb_private {
class Module;
}
namespace lldb_private {
class Stream;
}
namespace lldb_private {
class SymbolContext;
}
namespace lldb_private {
class SymbolContextList;
}
namespace lldb_private {
class Target;
}
namespace lldb_private {
struct RegisterInfo;
}
namespace llvm {
template <typename T> class SmallVectorImpl;
}
namespace lldb_private {

95
contrib/llvm/tools/lldb/include/lldb/Core/DumpDataExtractor.h Normal file
View File

@ -0,0 +1,95 @@
//===-- DumpDataExtractor.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_CORE_DUMPDATAEXTRACTOR_H
#define LLDB_CORE_DUMPDATAEXTRACTOR_H
#include "lldb/lldb-enumerations.h" // for Format
#include "lldb/lldb-types.h"
#include <stddef.h> // for size_t
#include <stdint.h> // for uint32_t, uint64_t
namespace lldb_private {
class DataExtractor;
class ExecutionContextScope;
class Stream;
//------------------------------------------------------------------
/// Dumps \a item_count objects into the stream \a s.
///
/// Dumps \a item_count objects using \a item_format, each of which
/// are \a item_byte_size bytes long starting at offset \a offset
/// bytes into the contained data, into the stream \a s. \a
/// num_per_line objects will be dumped on each line before a new
/// line will be output. If \a base_addr is a valid address, then
/// each new line of output will be preceded by the address value
/// plus appropriate offset, and a colon and space. Bitfield values
/// can be dumped by calling this function multiple times with the
/// same start offset, format and size, yet differing \a
/// item_bit_size and \a item_bit_offset values.
///
/// @param[in] s
/// The stream to dump the output to. This value can not be nullptr.
///
/// @param[in] offset
/// The offset into the data at which to start dumping.
///
/// @param[in] item_format
/// The format to use when dumping each item.
///
/// @param[in] item_byte_size
/// The byte size of each item.
///
/// @param[in] item_count
/// The number of items to dump.
///
/// @param[in] num_per_line
/// The number of items to display on each line.
///
/// @param[in] base_addr
/// The base address that gets added to the offset displayed on
/// each line if the value is valid. Is \a base_addr is
/// LLDB_INVALID_ADDRESS then no address values will be prepended
/// to any lines.
///
/// @param[in] item_bit_size
/// If the value to display is a bitfield, this value should
/// be the number of bits that the bitfield item has within the
/// item's byte size value. This function will need to be called
/// multiple times with identical \a offset and \a item_byte_size
/// values in order to display multiple bitfield values that
/// exist within the same integer value. If the items being
/// displayed are not bitfields, this value should be zero.
///
/// @param[in] item_bit_offset
/// If the value to display is a bitfield, this value should
/// be the offset in bits, or shift right amount, that the
/// bitfield item occupies within the item's byte size value.
/// This function will need to be called multiple times with
/// identical \a offset and \a item_byte_size values in order
/// to display multiple bitfield values that exist within the
/// same integer value. If the items being displayed are not
/// bitfields, this value should be zero.
///
/// @return
/// The offset at which dumping ended.
//------------------------------------------------------------------
lldb::offset_t
DumpDataExtractor(const DataExtractor &DE, Stream *s, lldb::offset_t offset,
lldb::Format item_format, size_t item_byte_size,
size_t item_count, size_t num_per_line, uint64_t base_addr,
uint32_t item_bit_size, uint32_t item_bit_offset,
ExecutionContextScope *exe_scope = nullptr);
void DumpHexBytes(Stream *s, const void *src, size_t src_len,
uint32_t bytes_per_line, lldb::addr_t base_addr);
}
#endif

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

@ -15,9 +15,34 @@
#include "lldb/Core/ArchSpec.h"
#include "lldb/Core/Opcode.h"
#include "lldb/Core/PluginInterface.h"
#include "lldb/Core/RegisterValue.h"
#include "lldb/lldb-private.h"
#include "lldb/lldb-public.h"
#include "lldb/Core/Address.h" // for Address
#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 <stddef.h> // for size_t
#include <stdint.h> // for uint32_t, uint64_t, int64_t
namespace lldb_private {
class OptionValueDictionary;
}
namespace lldb_private {
class RegisterContext;
}
namespace lldb_private {
class RegisterValue;
}
namespace lldb_private {
class Stream;
}
namespace lldb_private {
class Target;
}
namespace lldb_private {
class UnwindPlan;
}
namespace lldb_private {

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

@ -10,19 +10,28 @@
#ifndef liblldb_Event_h_
#define liblldb_Event_h_
// C Includes
// C++ Includes
#include "lldb/Core/Broadcaster.h"
#include "lldb/Core/StructuredData.h"
#include "lldb/Host/Predicate.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/lldb-defines.h" // for DISALLOW_COPY_AND_ASSIGN
#include "lldb/lldb-forward.h" // for EventDataSP, ProcessSP, Struct...
#include "llvm/ADT/StringRef.h" // for StringRef
#include <chrono>
#include <memory>
#include <string>
// Other libraries and framework includes
// Project includes
#include "lldb/Core/Broadcaster.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/StructuredData.h"
#include "lldb/Host/Predicate.h"
#include "lldb/lldb-private.h"
#include <stddef.h> // for size_t
#include <stdint.h> // for uint32_t
namespace lldb_private {
class Event;
}
namespace lldb_private {
class Stream;
}
namespace lldb_private {

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

@ -10,9 +10,19 @@
#ifndef liblldb_FileLineResolver_h_
#define liblldb_FileLineResolver_h_
// Project includes
#include "lldb/Core/AddressResolver.h"
#include "lldb/Core/SearchFilter.h" // for Searcher, Searcher::CallbackR...
#include "lldb/Symbol/SymbolContext.h"
#include "lldb/Utility/FileSpec.h" // for FileSpec
#include "lldb/lldb-defines.h" // for DISALLOW_COPY_AND_ASSIGN
#include <stdint.h> // for uint32_t, UINT32_MAX
namespace lldb_private {
class Address;
}
namespace lldb_private {
class Stream;
}
namespace lldb_private {

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

@ -11,10 +11,16 @@
#define liblldb_FileSpecList_h_
#if defined(__cplusplus)
#include "lldb/Host/FileSpec.h"
#include "lldb/lldb-private.h"
#include "lldb/Utility/FileSpec.h"
#include <vector>
#include <stddef.h> // for size_t
namespace lldb_private {
class Stream;
}
namespace lldb_private {
//----------------------------------------------------------------------

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

@ -10,19 +10,38 @@
#ifndef liblldb_FormatEntity_h_
#define liblldb_FormatEntity_h_
// C Includes
// C++ Includes
#include "lldb/Utility/Error.h"
#include "lldb/Utility/FileSpec.h" // for FileSpec
#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 <string>
#include <vector>
// Other libraries and framework includes
// Project includes
#include "lldb/Core/Error.h"
#include "lldb/lldb-private.h"
namespace lldb_private {
class Address;
}
namespace lldb_private {
class ExecutionContext;
}
namespace lldb_private {
class Stream;
}
namespace lldb_private {
class StringList;
}
namespace lldb_private {
class SymbolContext;
}
namespace lldb_private {
class ValueObject;
}
namespace llvm {
class StringRef;
} // namespace llvm
}
namespace lldb_private {
class FormatEntity {

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

@ -10,26 +10,27 @@
#ifndef liblldb_IOHandler_h_
#define liblldb_IOHandler_h_
// C Includes
#include <string.h>
#include "lldb/Core/ValueObjectList.h"
#include "lldb/Host/Predicate.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Flags.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
// C++ Includes
#include <memory>
#include <mutex>
#include <string>
#include <vector>
// Other libraries and framework includes
// Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Flags.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/StringList.h"
#include "lldb/Core/ValueObjectList.h"
#include "lldb/Host/Predicate.h"
#include "lldb/lldb-enumerations.h"
#include "lldb/lldb-public.h"
#include <stdint.h> // for uint32_t
#include <stdio.h> // for FILE
namespace lldb_private {
class Debugger;
}
namespace curses {
class Application;

28
contrib/llvm/tools/lldb/include/lldb/Core/Listener.h
View File

@ -10,20 +10,29 @@
#ifndef liblldb_Select_h_
#define liblldb_Select_h_
// C Includes
// C++ Includes
#include <chrono>
#include "lldb/Core/Broadcaster.h" // for Broadcaster::BroadcasterImplWP
#include "lldb/Utility/Timeout.h"
#include "lldb/lldb-defines.h" // for DISALLOW_COPY_AND_ASSIGN
#include "lldb/lldb-forward.h" // for BroadcasterManagerWP, EventSP
#include <condition_variable>
#include <list>
#include <map>
#include <memory> // for owner_less, enable_shared_from_this
#include <mutex>
#include <ratio> // for micro
#include <string>
#include <vector>
// Other libraries and framework includes
// Project includes
#include "lldb/Core/Event.h"
#include "lldb/Utility/Timeout.h"
#include "lldb/lldb-private.h"
#include <stddef.h> // for size_t
#include <stdint.h> // for uint32_t
namespace lldb_private {
class ConstString;
}
namespace lldb_private {
class Event;
}
namespace lldb_private {
@ -39,8 +48,7 @@ class Listener : public std::enable_shared_from_this<Listener> {
//------------------------------------------------------------------
//
// Listeners have to be constructed into shared pointers - at least if you
// want them to listen to
// Broadcasters,
// want them to listen to Broadcasters,
protected:
Listener(const char *name);

189
contrib/llvm/tools/lldb/include/lldb/Core/Log.h
View File

@ -1,189 +0,0 @@
//===-- Log.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_Log_h_
#define liblldb_Log_h_
// C Includes
#include <signal.h>
#include <stdarg.h>
#include <stdint.h>
#include <stdio.h>
// C++ Includes
// Other libraries and framework includes
// Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Flags.h"
#include "lldb/Core/Logging.h"
#include "lldb/Core/PluginInterface.h"
#include "lldb/lldb-private.h"
#include "llvm/Support/FormatVariadic.h"
//----------------------------------------------------------------------
// Logging Options
//----------------------------------------------------------------------
#define LLDB_LOG_OPTION_THREADSAFE (1u << 0)
#define LLDB_LOG_OPTION_VERBOSE (1u << 1)
#define LLDB_LOG_OPTION_DEBUG (1u << 2)
#define LLDB_LOG_OPTION_PREPEND_SEQUENCE (1u << 3)
#define LLDB_LOG_OPTION_PREPEND_TIMESTAMP (1u << 4)
#define LLDB_LOG_OPTION_PREPEND_PROC_AND_THREAD (1u << 5)
#define LLDB_LOG_OPTION_PREPEND_THREAD_NAME (1U << 6)
#define LLDB_LOG_OPTION_BACKTRACE (1U << 7)
#define LLDB_LOG_OPTION_APPEND (1U << 8)
//----------------------------------------------------------------------
// Logging Functions
//----------------------------------------------------------------------
namespace lldb_private {
class Log final {
public:
//------------------------------------------------------------------
// Callback definitions for abstracted plug-in log access.
//------------------------------------------------------------------
typedef void (*DisableCallback)(const char **categories,
Stream *feedback_strm);
typedef Log *(*EnableCallback)(lldb::StreamSP &log_stream_sp,
uint32_t log_options, const char **categories,
Stream *feedback_strm);
typedef void (*ListCategoriesCallback)(Stream *strm);
struct Callbacks {
DisableCallback disable;
EnableCallback enable;
ListCategoriesCallback list_categories;
};
//------------------------------------------------------------------
// Static accessors for logging channels
//------------------------------------------------------------------
static void RegisterLogChannel(const ConstString &channel,
const Log::Callbacks &log_callbacks);
static bool UnregisterLogChannel(const ConstString &channel);
static bool GetLogChannelCallbacks(const ConstString &channel,
Log::Callbacks &log_callbacks);
static bool EnableLogChannel(lldb::StreamSP &log_stream_sp,
uint32_t log_options, const char *channel,
const char **categories, Stream &error_stream);
static void EnableAllLogChannels(lldb::StreamSP &log_stream_sp,
uint32_t log_options,
const char **categories,
Stream *feedback_strm);
static void DisableAllLogChannels(Stream *feedback_strm);
static void ListAllLogChannels(Stream *strm);
static void Initialize();
static void Terminate();
//------------------------------------------------------------------
// Auto completion
//------------------------------------------------------------------
static void AutoCompleteChannelName(const char *channel_name,
StringList &matches);
//------------------------------------------------------------------
// Member functions
//------------------------------------------------------------------
Log();
Log(const lldb::StreamSP &stream_sp);
~Log();
void PutCString(const char *cstr);
void PutString(llvm::StringRef str);
template <typename... Args> void Format(const char *fmt, Args &&... args) {
PutString(llvm::formatv(fmt, std::forward<Args>(args)...).str());
}
// CLEANUP: Add llvm::raw_ostream &Stream() function.
void Printf(const char *format, ...) __attribute__((format(printf, 2, 3)));
void VAPrintf(const char *format, va_list args);
void LogIf(uint32_t mask, const char *fmt, ...)
__attribute__((format(printf, 3, 4)));
void Debug(const char *fmt, ...) __attribute__((format(printf, 2, 3)));
void Error(const char *fmt, ...) __attribute__((format(printf, 2, 3)));
void VAError(const char *format, va_list args);
void Verbose(const char *fmt, ...) __attribute__((format(printf, 2, 3)));
void Warning(const char *fmt, ...) __attribute__((format(printf, 2, 3)));
Flags &GetOptions();
const Flags &GetOptions() const;
Flags &GetMask();
const Flags &GetMask() const;
bool GetVerbose() const;
bool GetDebug() const;
void SetStream(const lldb::StreamSP &stream_sp) { m_stream_sp = stream_sp; }
protected:
//------------------------------------------------------------------
// Member variables
//------------------------------------------------------------------
lldb::StreamSP m_stream_sp;
Flags m_options;
Flags m_mask_bits;
private:
DISALLOW_COPY_AND_ASSIGN(Log);
};
class LogChannel : public PluginInterface {
public:
LogChannel();
~LogChannel() override;
static lldb::LogChannelSP FindPlugin(const char *plugin_name);
// categories is an array of chars that ends with a NULL element.
virtual void Disable(const char **categories, Stream *feedback_strm) = 0;
virtual bool
Enable(lldb::StreamSP &log_stream_sp, uint32_t log_options,
Stream *feedback_strm, // Feedback stream for argument errors etc
const char **categories) = 0; // The categories to enable within this
// logging stream, if empty, enable
// default set
virtual void ListCategories(Stream *strm) = 0;
protected:
std::unique_ptr<Log> m_log_ap;
private:
DISALLOW_COPY_AND_ASSIGN(LogChannel);
};
} // namespace lldb_private
#endif // liblldb_Log_h_

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

@ -11,9 +11,18 @@
#define liblldb_Mangled_h_
#if defined(__cplusplus)
#include "lldb/Core/ConstString.h"
#include "lldb/lldb-private.h"
#include <vector>
#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
namespace lldb_private {
class RegularExpression;
}
namespace lldb_private {
class Stream;
}
namespace lldb_private {

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

@ -22,8 +22,8 @@
// Other libraries and framework includes
// Project includes
#include "lldb/Core/DataExtractor.h"
#include "lldb/Core/Stream.h"
#include "lldb/Utility/DataExtractor.h"
#include "lldb/Utility/Stream.h"
class MappedHash {
public:
@ -353,7 +353,7 @@ class MappedHash {
bool IsValid() const {
return m_header.version == 1 &&
m_header.hash_function == eHashFunctionDJB &&
m_header.bucket_count > 0 && m_header.hashes_count > 0;
m_header.bucket_count > 0;
}
uint32_t GetHashIndex(uint32_t bucket_idx) const {

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

@ -10,28 +10,85 @@
#ifndef liblldb_Module_h_
#define liblldb_Module_h_
#include "lldb/Symbol/SymbolContextScope.h"
// Project includes
#include "lldb/Core/Address.h" // for Address
#include "lldb/Core/ArchSpec.h"
#include "lldb/Core/UUID.h"
#include "lldb/Host/FileSpec.h"
#include "lldb/Core/ModuleSpec.h" // for ModuleSpec
#include "lldb/Symbol/SymbolContextScope.h"
#include "lldb/Symbol/TypeSystem.h"
#include "lldb/Target/PathMappingList.h"
#include "lldb/Utility/ConstString.h" // for ConstString
#include "lldb/Utility/Error.h" // for Error
#include "lldb/Utility/FileSpec.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-forward.h"
#include "lldb/lldb-types.h" // for addr_t, offset_t
// Other libraries and framework includes
#include "llvm/ADT/DenseSet.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/Chrono.h"
// C Includes
// C++ Includes
#include <atomic>
#include <memory> // for enable_shared_from_this
#include <mutex>
#include <stddef.h> // for size_t
#include <stdint.h> // for uint32_t, uint64_t
#include <string>
#include <vector>
namespace lldb_private {
class CompilerDeclContext;
}
namespace lldb_private {
class Function;
}
namespace lldb_private {
class Log;
}
namespace lldb_private {
class ObjectFile;
}
namespace lldb_private {
class RegularExpression;
}
namespace lldb_private {
class SectionList;
}
namespace lldb_private {
class Stream;
}
namespace lldb_private {
class Symbol;
}
namespace lldb_private {
class SymbolContext;
}
namespace lldb_private {
class SymbolContextList;
}
namespace lldb_private {
class SymbolFile;
}
namespace lldb_private {
class SymbolVendor;
}
namespace lldb_private {
class Symtab;
}
namespace lldb_private {
class Target;
}
namespace lldb_private {
class TypeList;
}
namespace lldb_private {
class TypeMap;
}
namespace lldb_private {
class VariableList;
}
namespace lldb_private {
//----------------------------------------------------------------------
@ -962,6 +1019,20 @@ class Module : public std::enable_shared_from_this<Module>,
bool RemapSourceFile(llvm::StringRef path, std::string &new_path) const;
bool RemapSourceFile(const char *, std::string &) const = delete;
//------------------------------------------------------------------
/// Loads this module to memory.
///
/// Loads the bits needed to create an executable image to the memory.
/// It is useful with bare-metal targets where target does not have the
/// ability to start a process itself.
///
/// @param[in] target
/// Target where to load the module.
///
/// @return
//------------------------------------------------------------------
Error LoadInMemory(Target &target, bool set_pc);
//----------------------------------------------------------------------
/// @class LookupInfo Module.h "lldb/Core/Module.h"
/// @brief A class that encapsulates name lookup information.

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

@ -10,7 +10,7 @@
#ifndef liblldb_ModuleChild_h_
#define liblldb_ModuleChild_h_
#include "lldb/lldb-private.h"
#include "lldb/lldb-forward.h"
namespace lldb_private {

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

@ -10,18 +10,67 @@
#ifndef liblldb_ModuleList_h_
#define liblldb_ModuleList_h_
// C Includes
// C++ Includes
#include "lldb/Core/Address.h" // for Address
#include "lldb/Core/ModuleSpec.h" // for ModuleSpec
#include "lldb/Utility/Error.h" // for Error
#include "lldb/Utility/FileSpec.h" // for FileSpec
#include "lldb/Utility/Iterable.h"
#include "lldb/lldb-enumerations.h"
#include "lldb/lldb-forward.h"
#include "lldb/lldb-types.h"
#include "llvm/ADT/DenseSet.h"
#include <functional>
#include <list>
#include <mutex>
#include <vector>
// Other libraries and framework includes
// Project includes
#include "lldb/Utility/Iterable.h"
#include "lldb/lldb-private.h"
#include "llvm/ADT/DenseSet.h"
#include <stddef.h> // for size_t
#include <stdint.h> // for uint32_t
namespace lldb_private {
class ConstString;
}
namespace lldb_private {
class FileSpecList;
}
namespace lldb_private {
class Function;
}
namespace lldb_private {
class Log;
}
namespace lldb_private {
class Module;
}
namespace lldb_private {
class RegularExpression;
}
namespace lldb_private {
class Stream;
}
namespace lldb_private {
class SymbolContext;
}
namespace lldb_private {
class SymbolContextList;
}
namespace lldb_private {
class SymbolFile;
}
namespace lldb_private {
class Target;
}
namespace lldb_private {
class TypeList;
}
namespace lldb_private {
class UUID;
}
namespace lldb_private {
class VariableList;
}
namespace lldb_private {

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

@ -12,10 +12,10 @@
// Project includes
#include "lldb/Core/ArchSpec.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/UUID.h"
#include "lldb/Host/FileSpec.h"
#include "lldb/Target/PathMappingList.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"

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

@ -10,20 +10,25 @@
#ifndef lldb_Opcode_h
#define lldb_Opcode_h
// C Includes
#include <string.h>
#include "lldb/Utility/Endian.h"
#include "lldb/lldb-enumerations.h" // for ByteOrder, ByteOrder::eByteOrde...
// C++ Includes
// Other libraries and framework includes
#include "llvm/Support/MathExtras.h"
// Project includes
#include "lldb/Host/Endian.h"
#include "lldb/lldb-public.h"
#include <assert.h> // for assert
#include <stdint.h> // for uint32_t, uint8_t, uint16_t
#include <string.h>
namespace lldb_private {
class DataExtractor;
}
namespace lldb_private {
class Stream;
}
namespace lldb {
class SBInstruction;
} // namespace lldb
}
namespace lldb_private {

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

@ -10,13 +10,28 @@
#ifndef liblldb_PluginManager_h_
#define liblldb_PluginManager_h_
// C Includes
// C++ Includes
// Other libraries and framework includes
// Project includes
#include "lldb/Host/FileSpec.h"
#include "lldb/lldb-private.h"
#include "lldb/Utility/Error.h" // for Error
#include "lldb/Utility/FileSpec.h"
#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 <stddef.h> // for size_t
#include <stdint.h> // for uint32_t
namespace lldb_private {
class CommandInterpreter;
}
namespace lldb_private {
class ConstString;
}
namespace lldb_private {
class Debugger;
}
namespace lldb_private {
class StringList;
}
namespace lldb_private {
class PluginManager {
@ -209,22 +224,6 @@ class PluginManager {
static ObjectFileGetModuleSpecifications
GetObjectContainerGetModuleSpecificationsCallbackAtIndex(uint32_t idx);
//------------------------------------------------------------------
// LogChannel
//------------------------------------------------------------------
static bool RegisterPlugin(const ConstString &name, const char *description,
LogChannelCreateInstance create_callback);
static bool UnregisterPlugin(LogChannelCreateInstance create_callback);
static LogChannelCreateInstance
GetLogChannelCreateCallbackAtIndex(uint32_t idx);
static LogChannelCreateInstance
GetLogChannelCreateCallbackForPluginName(const ConstString &name);
static const char *GetLogChannelCreateNameAtIndex(uint32_t idx);
//------------------------------------------------------------------
// Platform
//------------------------------------------------------------------

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

@ -59,6 +59,18 @@ template <typename B, typename S> struct Range {
void Slide(BaseType slide) { base += slide; }
bool Union(const Range &rhs)
{
if (DoesAdjoinOrIntersect(rhs))
{
auto new_end = std::max<BaseType>(GetRangeEnd(), rhs.GetRangeEnd());
base = std::min<BaseType>(base, rhs.base);
size = new_end - base;
return true;
}
return false;
}
BaseType GetRangeEnd() const { return base + size; }
void SetRangeEnd(BaseType end) {
@ -348,7 +360,33 @@ template <typename B, typename S> class RangeVector {
void Append(B base, S size) { m_entries.emplace_back(base, size); }
bool RemoveEntrtAtIndex(uint32_t idx) {
// Insert an item into a sorted list and optionally combine it with any
// adjacent blocks if requested.
void Insert(const Entry &entry, bool combine) {
if (m_entries.empty()) {
m_entries.push_back(entry);
return;
}
auto begin = m_entries.begin();
auto end = m_entries.end();
auto pos = std::lower_bound(begin, end, entry);
if (combine) {
if (pos != end && pos->Union(entry)) {
CombinePrevAndNext(pos);
return;
}
if (pos != begin) {
auto prev = pos - 1;
if (prev->Union(entry)) {
CombinePrevAndNext(prev);
return;
}
}
}
m_entries.insert(pos, entry);
}
bool RemoveEntryAtIndex(uint32_t idx) {
if (idx < m_entries.size()) {
m_entries.erase(m_entries.begin() + idx);
return true;
@ -458,6 +496,7 @@ template <typename B, typename S> class RangeVector {
// Clients must ensure that "i" is a valid index prior to calling this
// function
Entry &GetEntryRef(size_t i) { return m_entries[i]; }
const Entry &GetEntryRef(size_t i) const { return m_entries[i]; }
Entry *Back() { return (m_entries.empty() ? nullptr : &m_entries.back()); }
@ -538,6 +577,28 @@ template <typename B, typename S> class RangeVector {
}
protected:
void CombinePrevAndNext(typename Collection::iterator pos) {
// Check if the prev or next entries in case they need to be unioned with
// the entry pointed to by "pos".
if (pos != m_entries.begin()) {
auto prev = pos - 1;
if (prev->Union(*pos))
m_entries.erase(pos);
pos = prev;
}
auto end = m_entries.end();
if (pos != end) {
auto next = pos + 1;
if (next != end) {
if (pos->Union(*next))
m_entries.erase(next);
}
}
return;
}
Collection m_entries;
};

30
contrib/llvm/tools/lldb/include/lldb/Core/RegisterValue.h
View File

@ -10,19 +10,27 @@
#ifndef lldb_RegisterValue_h
#define lldb_RegisterValue_h
// C Includes
#include "lldb/Core/Scalar.h"
#include "lldb/Utility/Endian.h"
#include "lldb/Utility/Error.h" // for Error
#include "lldb/lldb-enumerations.h" // for ByteOrder, Format
#include "lldb/lldb-types.h" // for offset_t
#include "llvm/ADT/APInt.h"
#include "llvm/ADT/StringRef.h" // for StringRef
#include <stdint.h> // for uint32_t, uint8_t, uint64_t, uin...
#include <string.h>
// C++ Includes
// Other libraries and framework includes
#include "llvm/ADT/APInt.h"
// Project includes
#include "lldb/Core/Scalar.h"
#include "lldb/Host/Endian.h"
#include "lldb/lldb-private.h"
#include "lldb/lldb-public.h"
namespace lldb_private {
class DataExtractor;
}
namespace lldb_private {
class Stream;
}
namespace lldb_private {
struct RegisterInfo;
}
namespace lldb_private {
class RegisterValue {

15
contrib/llvm/tools/lldb/include/lldb/Core/Scalar.h
View File

@ -10,10 +10,23 @@
#ifndef liblldb_Scalar_h_
#define liblldb_Scalar_h_
#include "lldb/lldb-private.h"
#include "lldb/Utility/Error.h" // for Error
#include "lldb/lldb-enumerations.h" // for Encoding, ByteOrder
#include "lldb/lldb-private-types.h" // for type128
#include "llvm/ADT/APFloat.h"
#include "llvm/ADT/APInt.h"
#include <stddef.h> // for size_t
#include <stdint.h> // for uint32_t, uint64_t, int64_t
namespace lldb_private {
class DataExtractor;
}
namespace lldb_private {
class Stream;
}
#define NUM_OF_WORDS_INT128 2
#define BITWIDTH_INT128 128
#define NUM_OF_WORDS_INT256 4

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

@ -10,13 +10,44 @@
#ifndef liblldb_SearchFilter_h_
#define liblldb_SearchFilter_h_
// C Includes
// C++ Includes
// Other libraries and framework includes
// Project includes
#include "lldb/Core/FileSpecList.h"
#include "lldb/Core/StructuredData.h"
#include "lldb/lldb-private.h"
#include "lldb/Utility/FileSpec.h" // for FileSpec
#include "lldb/lldb-forward.h" // for SearchFilterSP, TargetSP, Modu...
#include <stdint.h> // for uint32_t
namespace lldb_private {
class Address;
}
namespace lldb_private {
class Breakpoint;
}
namespace lldb_private {
class CompileUnit;
}
namespace lldb_private {
class Error;
}
namespace lldb_private {
class Function;
}
namespace lldb_private {
class ModuleList;
}
namespace lldb_private {
class SearchFilter;
}
namespace lldb_private {
class Stream;
}
namespace lldb_private {
class SymbolContext;
}
namespace lldb_private {
class Target;
}
namespace lldb_private {

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

@ -10,16 +10,39 @@
#ifndef liblldb_Section_h_
#define liblldb_Section_h_
#include "lldb/Core/AddressRange.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Flags.h"
#include "lldb/Core/ModuleChild.h"
#include "lldb/Core/RangeMap.h"
#include "lldb/Core/UserID.h"
#include "lldb/Core/VMRange.h"
#include "lldb/Symbol/ObjectFile.h"
#include "lldb/lldb-private.h"
#include <limits.h>
#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 <memory> // for enable_shared_from_this
#include <vector> // for vector
#include <stddef.h> // for size_t
#include <stdint.h> // for uint32_t, UINT32_MAX
namespace lldb_private {
class Address;
}
namespace lldb_private {
class DataExtractor;
}
namespace lldb_private {
class ObjectFile;
}
namespace lldb_private {
class Section;
}
namespace lldb_private {
class Stream;
}
namespace lldb_private {
class Target;
}
namespace lldb_private {

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

@ -10,19 +10,32 @@
#ifndef liblldb_SourceManager_h_
#define liblldb_SourceManager_h_
// Project includes
#include "lldb/Host/FileSpec.h"
#include "lldb/lldb-private.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
// Other libraries and framework includes
#include "llvm/Support/Chrono.h"
// C Includes
// C++ Includes
#include <cstdint> // for uint32_t, UINT32_MAX
#include <map>
#include <memory>
#include <stddef.h> // for size_t
#include <string> // for string
#include <vector>
namespace lldb_private {
class RegularExpression;
}
namespace lldb_private {
class Stream;
}
namespace lldb_private {
class SymbolContextList;
}
namespace lldb_private {
class Target;
}
namespace lldb_private {
class SourceManager {

21
contrib/llvm/tools/lldb/include/lldb/Core/State.h
View File

@ -10,11 +10,13 @@
#ifndef liblldb_State_h_
#define liblldb_State_h_
// C Includes
// C++ Includes
// Other libraries and framework includes
// Project includes
#include "lldb/lldb-private.h"
#include "llvm/Support/FormatProviders.h"
#include "lldb/lldb-enumerations.h" // for StateType
#include "llvm/ADT/StringRef.h" // for StringRef
#include "llvm/Support/raw_ostream.h" // for raw_ostream
#include <stdint.h> // for uint32_t
namespace lldb_private {
@ -71,4 +73,13 @@ const char *GetPermissionsAsCString(uint32_t permissions);
} // namespace lldb_private
namespace llvm {
template <> struct format_provider<lldb::StateType> {
static void format(const lldb::StateType &state, raw_ostream &Stream,
StringRef Style) {
Stream << lldb_private::StateAsCString(state);
}
};
}
#endif // liblldb_State_h_

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

@ -1,5 +1,4 @@
//===-- StreamAsynchronousIO.h -----------------------------------*- C++
//-*-===//
//===-- StreamAsynchronousIO.h -----------------------------------*- C++-*-===//
//
// The LLVM Compiler Infrastructure
//
@ -11,9 +10,15 @@
#ifndef liblldb_StreamAsynchronousIO_h_
#define liblldb_StreamAsynchronousIO_h_
#include "lldb/Utility/Stream.h"
#include <string>
#include "lldb/Core/Stream.h"
#include <stddef.h> // for size_t
namespace lldb_private {
class Debugger;
}
namespace lldb_private {

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

@ -10,7 +10,7 @@
#ifndef liblldb_StreamBuffer_h_
#define liblldb_StreamBuffer_h_
#include "lldb/Core/Stream.h"
#include "lldb/Utility/Stream.h"
#include "llvm/ADT/SmallVector.h"
#include <stdio.h>
#include <string>

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

@ -10,16 +10,13 @@
#ifndef liblldb_StreamFile_h_
#define liblldb_StreamFile_h_
// C Includes
// C++ Includes
#include <string>
// Other libraries and framework includes
// Project includes
#include "lldb/Core/Stream.h"
#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 <stdint.h> // for uint32_t
#include <stdio.h> // for size_t, FILE
namespace lldb_private {

40
contrib/llvm/tools/lldb/include/lldb/Core/StructuredData.h
View File

@ -10,22 +10,29 @@
#ifndef liblldb_StructuredData_h_
#define liblldb_StructuredData_h_
// C Includes
// C++ Includes
#include "llvm/ADT/StringRef.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/FileSpec.h" // for FileSpec
#include <functional>
#include <map>
#include <memory>
#include <string>
#include <type_traits> // for move
#include <utility>
#include <vector>
// Other libraries and framework includes
#include "llvm/ADT/StringRef.h"
#include <assert.h> // for assert
#include <stddef.h> // for size_t
#include <stdint.h> // for uint64_t
// Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Stream.h"
#include "lldb/lldb-defines.h"
namespace lldb_private {
class Error;
}
namespace lldb_private {
class Stream;
}
namespace lldb_private {
@ -368,13 +375,12 @@ class StructuredData {
}
ObjectSP GetKeys() const {
ObjectSP object_sp(new Array());
Array *array = object_sp->GetAsArray();
auto object_sp = std::make_shared<Array>();
collection::const_iterator iter;
for (iter = m_dict.begin(); iter != m_dict.end(); ++iter) {
ObjectSP key_object_sp(new String());
key_object_sp->GetAsString()->SetValue(iter->first.AsCString());
array->Push(key_object_sp);
auto key_object_sp = std::make_shared<String>();
key_object_sp->SetValue(iter->first.AsCString());
object_sp->Push(key_object_sp);
}
return object_sp;
}
@ -500,19 +506,19 @@ class StructuredData {
}
void AddIntegerItem(llvm::StringRef key, uint64_t value) {
AddItem(key, ObjectSP(new Integer(value)));
AddItem(key, std::make_shared<Integer>(value));
}
void AddFloatItem(llvm::StringRef key, double value) {
AddItem(key, ObjectSP(new Float(value)));
AddItem(key, std::make_shared<Float>(value));
}
void AddStringItem(llvm::StringRef key, std::string value) {
AddItem(key, ObjectSP(new String(std::move(value))));
AddItem(key, std::make_shared<String>(std::move(value)));
}
void AddBooleanItem(llvm::StringRef key, bool value) {
AddItem(key, ObjectSP(new Boolean(value)));
AddItem(key, std::make_shared<Boolean>(value));
}
void Dump(Stream &s, bool pretty_print = true) const override;

20
contrib/llvm/tools/lldb/include/lldb/Core/Timer.h
View File

@ -10,19 +10,17 @@
#ifndef liblldb_Timer_h_
#define liblldb_Timer_h_
// C Includes
#include <stdarg.h>
#include <stdio.h>
// C++ Includes
#include <atomic>
#include <mutex>
// Other libraries and framework includes
// Project includes
#include "lldb/lldb-private.h"
#include "lldb/lldb-defines.h" // for DISALLOW_COPY_AND_ASSIGN
#include "llvm/Support/Chrono.h"
#include <atomic>
#include <stdint.h> // for uint32_t
namespace lldb_private {
class Stream;
}
namespace lldb_private {
//----------------------------------------------------------------------

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

@ -17,7 +17,9 @@
// Other libraries and framework includes
// Project includes
#include "lldb/Core/RegularExpression.h"
#include "lldb/Utility/RegularExpression.h"
#include "llvm/ADT/StringRef.h"
namespace lldb_private {

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

@ -10,21 +10,32 @@
#ifndef liblldb_UserSettingsController_h_
#define liblldb_UserSettingsController_h_
// C Includes
// C++ Includes
#include "lldb/Utility/Error.h" // for Error
#include "lldb/lldb-forward.h" // for OptionValuePropertiesSP
#include "lldb/lldb-private-enumerations.h" // for VarSetOperationType
#include "llvm/ADT/StringRef.h" // for StringRef
#include <string>
#include <vector>
// Other libraries and framework includes
// Project includes
#include <stddef.h> // for size_t
#include <stdint.h> // for uint32_t
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/StringList.h"
#include "lldb/Interpreter/OptionValue.h"
#include "lldb/lldb-private.h"
namespace lldb_private {
class CommandInterpreter;
}
namespace lldb_private {
class ConstString;
}
namespace lldb_private {
class ExecutionContext;
}
namespace lldb_private {
class Property;
}
namespace lldb_private {
class Stream;
}
namespace lldb_private {

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

@ -10,17 +10,39 @@
#ifndef liblldb_Value_h_
#define liblldb_Value_h_
// C Includes
// C++ Includes
#include <vector>
// Other libraries and framework includes
// Project includes
#include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Scalar.h"
#include "lldb/Symbol/CompilerType.h"
#include "lldb/lldb-private.h"
#include "lldb/Utility/DataBufferHeap.h"
#include "lldb/Utility/Error.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 "llvm/ADT/APInt.h" // for APInt
#include <vector>
#include <stdint.h> // for uint8_t, uint32_t, uint64_t
#include <string.h> // for size_t, memcpy
namespace lldb_private {
class DataExtractor;
}
namespace lldb_private {
class ExecutionContext;
}
namespace lldb_private {
class Module;
}
namespace lldb_private {
class Stream;
}
namespace lldb_private {
class Type;
}
namespace lldb_private {
class Variable;
}
namespace lldb_private {

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

@ -10,32 +10,67 @@
#ifndef liblldb_ValueObject_h_
#define liblldb_ValueObject_h_
// C Includes
// C++ Includes
#include "lldb/Core/Value.h"
#include "lldb/DataFormatters/DumpValueObjectOptions.h" // for DumpValueObj...
#include "lldb/Symbol/CompilerType.h"
#include "lldb/Symbol/Type.h" // for TypeImpl
#include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Process.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/DataExtractor.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/SharedCluster.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 "llvm/ADT/Optional.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringRef.h" // for StringRef
#include <functional>
#include <initializer_list>
#include <map>
#include <mutex> // for recursive_mutex
#include <string> // for string
#include <utility> // for pair
#include <vector>
// Other libraries and framework includes
#include "llvm/ADT/Optional.h"
#include "llvm/ADT/SmallVector.h"
// Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Core/DataExtractor.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Flags.h"
#include "lldb/Core/UserID.h"
#include "lldb/Core/Value.h"
#include "lldb/Symbol/CompilerType.h"
#include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/ExecutionContextScope.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/StackID.h"
#include "lldb/Utility/SharedCluster.h"
#include "lldb/lldb-private.h"
#include <stddef.h> // for size_t
#include <stdint.h> // for uint32_t
namespace lldb_private {
class Declaration;
}
namespace lldb_private {
class EvaluateExpressionOptions;
}
namespace lldb_private {
class ExecutionContextScope;
}
namespace lldb_private {
class Log;
}
namespace lldb_private {
class Scalar;
}
namespace lldb_private {
class Stream;
}
namespace lldb_private {
class SymbolContextScope;
}
namespace lldb_private {
class TypeFormatImpl;
}
namespace lldb_private {
class TypeSummaryImpl;
}
namespace lldb_private {
class TypeSummaryOptions;
}
namespace lldb_private {
/// ValueObject:
@ -552,6 +587,9 @@ class ValueObject : public UserID {
lldb::ValueObjectSP GetSP() { return m_manager->GetSharedPointer(this); }
// Change the name of the current ValueObject. Should *not* be used from a
// synthetic child provider as it would change the name of the non synthetic
// child as well.
void SetName(const ConstString &name);
virtual lldb::addr_t GetAddressOf(bool scalar_is_load_address = true,
@ -600,6 +638,12 @@ class ValueObject : public UserID {
virtual lldb::ValueObjectSP Dereference(Error &error);
// Creates a copy of the ValueObject with a new name and setting the current
// ValueObject as its parent. It should be used when we want to change the
// name of a ValueObject without modifying the actual ValueObject itself
// (e.g. sythetic child provider).
virtual lldb::ValueObjectSP Clone(const ConstString &new_name);
virtual lldb::ValueObjectSP AddressOf(Error &error);
virtual lldb::addr_t GetLiveAddress() { return LLDB_INVALID_ADDRESS; }

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

@ -10,11 +10,18 @@
#ifndef liblldb_ValueObjectCast_h_
#define liblldb_ValueObjectCast_h_
// C Includes
// C++ Includes
// Other libraries and framework includes
// Project includes
#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 <stddef.h> // for size_t
#include <stdint.h> // for uint32_t, uint64_t
namespace lldb_private {
class ConstString;
}
namespace lldb_private {

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

@ -10,14 +10,20 @@
#ifndef liblldb_ValueObjectChild_h_
#define liblldb_ValueObjectChild_h_
// C Includes
// C++ Includes
// Other libraries and framework includes
// Project includes
#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 "llvm/ADT/Optional.h"
#include <stddef.h> // for size_t
#include <stdint.h> // for uint32_t, uint64_t, int32_t
namespace lldb_private {
//----------------------------------------------------------------------

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

@ -10,14 +10,30 @@
#ifndef liblldb_ValueObjectConstResult_h_
#define liblldb_ValueObjectConstResult_h_
// C Includes
// C++ Includes
// Other libraries and framework includes
// Project includes
#include "lldb/Core/Value.h" // for Value
#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/Error.h" // for Error
#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 <stddef.h> // for size_t
#include <stdint.h> // for uint32_t, uint64_t
namespace lldb_private {
class DataExtractor;
}
namespace lldb_private {
class ExecutionContextScope;
}
namespace lldb_private {
class Module;
}
namespace lldb_private {
//----------------------------------------------------------------------

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

@ -10,12 +10,26 @@
#ifndef liblldb_ValueObjectConstResultCast_h_
#define liblldb_ValueObjectConstResultCast_h_
// C Includes
// C++ Includes
// Other libraries and framework includes
// Project includes
#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 <stddef.h> // for size_t
#include <stdint.h> // for uint32_t, int32_t
namespace lldb_private {
class DataExtractor;
}
namespace lldb_private {
class Error;
}
namespace lldb_private {
class ValueObject;
}
namespace lldb_private {

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

@ -1,5 +1,4 @@
//===-- ValueObjectConstResultChild.h -------------------------------*- C++
//-*-===//
//===-- ValueObjectConstResultChild.h ----------------------------*- C++-*-===//
//
// The LLVM Compiler Infrastructure
//
@ -11,12 +10,25 @@
#ifndef liblldb_ValueObjectConstResultChild_h_
#define liblldb_ValueObjectConstResultChild_h_
// C Includes
// C++ Includes
// Other libraries and framework includes
// Project includes
#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 <stddef.h> // for size_t
#include <stdint.h> // for uint32_t, int32_t
namespace lldb_private {
class DataExtractor;
}
namespace lldb_private {
class Error;
}
namespace lldb_private {
class ValueObject;
}
namespace lldb_private {

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

@ -10,11 +10,26 @@
#ifndef liblldb_ValueObjectConstResultImpl_h_
#define liblldb_ValueObjectConstResultImpl_h_
// C Includes
// C++ Includes
// Other libraries and framework includes
// Project includes
#include "lldb/Core/ValueObject.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 <stddef.h> // for size_t
#include <stdint.h> // for uint32_t, int32_t
namespace lldb_private {
class CompilerType;
}
namespace lldb_private {
class DataExtractor;
}
namespace lldb_private {
class Error;
}
namespace lldb_private {
class ValueObject;
}
namespace lldb_private {

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

@ -10,13 +10,30 @@
#ifndef liblldb_ValueObjectDynamicValue_h_
#define liblldb_ValueObjectDynamicValue_h_
// C Includes
// C++ Includes
// Other libraries and framework includes
// Project includes
#include "lldb/Core/Address.h" // for Address
#include "lldb/Core/ValueObject.h"
#include "lldb/Symbol/CompilerType.h" // for CompilerType
#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 <assert.h> // for assert
#include <stddef.h> // for size_t
#include <stdint.h> // for uint64_t, uint32_t
namespace lldb_private {
class DataExtractor;
}
namespace lldb_private {
class Declaration;
}
namespace lldb_private {
class Error;
}
namespace lldb_private {
//----------------------------------------------------------------------

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

@ -10,15 +10,16 @@
#ifndef liblldb_ValueObjectList_h_
#define liblldb_ValueObjectList_h_
// C Includes
// C++ Includes
#include "lldb/lldb-forward.h" // for ValueObjectSP
#include "lldb/lldb-types.h" // for user_id_t
#include <vector>
// Other libraries and framework includes
// Project includes
#include "lldb/Core/UserID.h"
#include "lldb/Target/ExecutionContextScope.h"
#include "lldb/lldb-private.h"
#include <stddef.h> // for size_t
namespace lldb_private {
class ValueObject;
}
namespace lldb_private {

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

@ -10,12 +10,21 @@
#ifndef liblldb_ValueObjectMemory_h_
#define liblldb_ValueObjectMemory_h_
// C Includes
// C++ Includes
// Other libraries and framework includes
// Project includes
#include "lldb/Core/Address.h" // for Address
#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 <stddef.h> // for size_t
#include <stdint.h> // for uint32_t, uint64_t
namespace lldb_private {
class ExecutionContextScope;
}
namespace lldb_private {

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

@ -10,13 +10,33 @@
#ifndef liblldb_ValueObjectRegister_h_
#define liblldb_ValueObjectRegister_h_
// C Includes
// C++ Includes
// Other libraries and framework includes
// Project includes
#include "lldb/Core/RegisterValue.h"
#include "lldb/Core/ValueObject.h"
#include "lldb/lldb-private.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 <stddef.h> // for size_t
#include <stdint.h> // for uint32_t, uint64_t, int32_t
namespace lldb_private {
class DataExtractor;
}
namespace lldb_private {
class Error;
}
namespace lldb_private {
class ExecutionContextScope;
}
namespace lldb_private {
class Scalar;
}
namespace lldb_private {
class Stream;
}
namespace lldb_private {

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

@ -10,16 +10,30 @@
#ifndef liblldb_ValueObjectSyntheticFilter_h_
#define liblldb_ValueObjectSyntheticFilter_h_
// C Includes
// C++ Includes
#include <memory>
// Other libraries and framework includes
// Project includes
#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 <cstdint> // for uint32_t, uint64_t
#include <memory>
#include <stddef.h> // for size_t
namespace lldb_private {
class Declaration;
}
namespace lldb_private {
class Error;
}
namespace lldb_private {
class SyntheticChildrenFrontEnd;
}
namespace lldb_private {
//----------------------------------------------------------------------

30
contrib/llvm/tools/lldb/include/lldb/Core/ValueObjectVariable.h
View File

@ -10,12 +10,34 @@
#ifndef liblldb_ValueObjectVariable_h_
#define liblldb_ValueObjectVariable_h_
// C Includes
// C++ Includes
// Other libraries and framework includes
// Project includes
#include "lldb/Core/ValueObject.h"
#include "lldb/Core/Value.h" // for Value
#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-forward.h" // for VariableSP, ModuleSP, ValueObj...
#include <stddef.h> // for size_t
#include <stdint.h> // for uint32_t, uint64_t
namespace lldb_private {
class DataExtractor;
}
namespace lldb_private {
class Declaration;
}
namespace lldb_private {
class Error;
}
namespace lldb_private {
class ExecutionContextScope;
}
namespace lldb_private {
class SymbolContextScope;
}
namespace lldb_private {
//----------------------------------------------------------------------

2
contrib/llvm/tools/lldb/include/lldb/DataFormatters/DataVisualization.h
View File

@ -15,9 +15,9 @@
// Other libraries and framework includes
// Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/DataFormatters/FormatClasses.h"
#include "lldb/DataFormatters/FormatManager.h"
#include "lldb/Utility/ConstString.h"
namespace lldb_private {

5
contrib/llvm/tools/lldb/include/lldb/DataFormatters/DumpValueObjectOptions.h
View File

@ -27,7 +27,7 @@ namespace lldb_private {
class DumpValueObjectOptions {
public:
struct PointerDepth {
enum class Mode { Always, Formatters, Default, Never } m_mode;
enum class Mode { Always, Default, Never } m_mode;
uint32_t m_count;
PointerDepth operator--() const {
@ -37,9 +37,6 @@ class DumpValueObjectOptions {
}
bool CanAllowExpansion() const;
bool CanAllowExpansion(bool is_root, TypeSummaryImpl *entry,
ValueObject *valobj, const std::string &summary);
};
struct PointerAsArraySettings {

2
contrib/llvm/tools/lldb/include/lldb/DataFormatters/FormatCache.h
View File

@ -18,7 +18,7 @@
// Other libraries and framework includes
// Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/lldb-public.h"
namespace lldb_private {

2
contrib/llvm/tools/lldb/include/lldb/DataFormatters/FormattersContainer.h
View File

@ -22,7 +22,6 @@
// Project includes
#include "lldb/lldb-public.h"
#include "lldb/Core/RegularExpression.h"
#include "lldb/Core/ValueObject.h"
#include "lldb/DataFormatters/FormatClasses.h"
#include "lldb/DataFormatters/TypeFormat.h"
@ -30,6 +29,7 @@
#include "lldb/DataFormatters/TypeSynthetic.h"
#include "lldb/DataFormatters/TypeValidator.h"
#include "lldb/Symbol/CompilerType.h"
#include "lldb/Utility/RegularExpression.h"
#include "lldb/Utility/StringLexer.h"
namespace lldb_private {

2
contrib/llvm/tools/lldb/include/lldb/DataFormatters/StringPrinter.h
View File

@ -19,7 +19,7 @@
// Project includes
#include "lldb/lldb-forward.h"
#include "lldb/Core/DataExtractor.h"
#include "lldb/Utility/DataExtractor.h"
namespace lldb_private {
namespace formatters {

2
contrib/llvm/tools/lldb/include/lldb/DataFormatters/TypeSummary.h
View File

@ -23,9 +23,9 @@
#include "lldb/lldb-enumerations.h"
#include "lldb/lldb-public.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/FormatEntity.h"
#include "lldb/Core/StructuredData.h"
#include "lldb/Utility/Error.h"
namespace lldb_private {
class TypeSummaryOptions {

3
contrib/llvm/tools/lldb/include/lldb/DataFormatters/ValueObjectPrinter.h
View File

@ -19,7 +19,8 @@
#include "lldb/lldb-private.h"
#include "lldb/lldb-public.h"
#include "lldb/Core/Flags.h"
#include "lldb/Utility/Flags.h"
#include "lldb/DataFormatters/DumpValueObjectOptions.h"
#include "lldb/Symbol/CompilerType.h"

2
contrib/llvm/tools/lldb/include/lldb/DataFormatters/VectorIterator.h
View File

@ -13,8 +13,8 @@
#include "lldb/lldb-forward.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Target/ExecutionContext.h"
#include "lldb/Utility/ConstString.h"
namespace lldb_private {
namespace formatters {

4
contrib/llvm/tools/lldb/include/lldb/Expression/DWARFExpression.h
View File

@ -11,10 +11,10 @@
#define liblldb_DWARFExpression_h_
#include "lldb/Core/Address.h"
#include "lldb/Core/DataExtractor.h"
#include "lldb/Core/Disassembler.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Scalar.h"
#include "lldb/Utility/DataExtractor.h"
#include "lldb/Utility/Error.h"
#include "lldb/lldb-private.h"
#include <functional>

2
contrib/llvm/tools/lldb/include/lldb/Expression/ExpressionParser.h
View File

@ -10,7 +10,7 @@
#ifndef liblldb_ExpressionParser_h_
#define liblldb_ExpressionParser_h_
#include "lldb/Core/Error.h"
#include "lldb/Utility/Error.h"
#include "lldb/lldb-public.h"
namespace lldb_private {

2
contrib/llvm/tools/lldb/include/lldb/Expression/ExpressionVariable.h
View File

@ -19,8 +19,8 @@
#include "llvm/ADT/DenseMap.h"
// Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Core/ValueObject.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/lldb-public.h"
namespace lldb_private {

2
contrib/llvm/tools/lldb/include/lldb/Expression/IRExecutionUnit.h
View File

@ -22,10 +22,10 @@
#include "llvm/IR/Module.h"
// Project includes
#include "lldb/Core/DataBufferHeap.h"
#include "lldb/Expression/IRMemoryMap.h"
#include "lldb/Symbol/ObjectFile.h"
#include "lldb/Symbol/SymbolContext.h"
#include "lldb/Utility/DataBufferHeap.h"
#include "lldb/lldb-forward.h"
#include "lldb/lldb-private.h"

4
contrib/llvm/tools/lldb/include/lldb/Expression/IRInterpreter.h
View File

@ -10,8 +10,8 @@
#ifndef liblldb_IRInterpreter_h_
#define liblldb_IRInterpreter_h_
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Stream.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Stream.h"
#include "lldb/lldb-public.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/Pass.h"

4
contrib/llvm/tools/lldb/include/lldb/Expression/IRMemoryMap.h
View File

@ -10,8 +10,8 @@
#ifndef lldb_IRMemoryMap_h_
#define lldb_IRMemoryMap_h_
#include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/UserID.h"
#include "lldb/Utility/DataBufferHeap.h"
#include "lldb/Utility/UserID.h"
#include "lldb/lldb-public.h"
#include <map>

2
contrib/llvm/tools/lldb/include/lldb/Expression/Materializer.h
View File

@ -17,10 +17,10 @@
// Other libraries and framework includes
// Project includes
#include "lldb/Core/Error.h"
#include "lldb/Expression/IRMemoryMap.h"
#include "lldb/Symbol/TaggedASTType.h"
#include "lldb/Target/StackFrame.h"
#include "lldb/Utility/Error.h"
#include "lldb/lldb-private-types.h"
namespace lldb_private {

39
contrib/llvm/tools/lldb/include/lldb/Host/Config.h
View File

@ -7,42 +7,21 @@
//
//===----------------------------------------------------------------------===//
#ifndef liblldb_Config_h_
#define liblldb_Config_h_
#ifndef LLDB_HOST_CONFIG_H
#define LLDB_HOST_CONFIG_H
#if defined(__APPLE__)
#include "lldb/Host/macosx/Config.h"
// This block of code only exists to keep the Xcode project working in the
// absence of a configuration step.
#define LLDB_CONFIG_TERMIOS_SUPPORTED 1
#elif defined(__ANDROID__)
#include "lldb/Host/android/Config.h"
#elif defined(__linux__) || defined(__GNU__)
#include "lldb/Host/linux/Config.h"
#elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || \
defined(__OpenBSD__)
#include "lldb/Host/freebsd/Config.h"
#elif defined(__NetBSD__)
#include "lldb/Host/netbsd/Config.h"
#elif defined(__MINGW__) || defined(__MINGW32__)
#include "lldb/Host/mingw/Config.h"
#elif defined(_MSC_VER)
#include "lldb/Host/msvc/Config.h"
#define HAVE_SYS_EVENT_H 1
#else
#error undefined platform
#error This file is only used by the Xcode build.
#endif
#endif // #ifndef liblldb_Config_h_
#endif // #ifndef LLDB_HOST_CONFIG_H

19
contrib/llvm/tools/lldb/include/lldb/Host/Config.h.cmake Normal file
View File

@ -0,0 +1,19 @@
//===-- Config.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_HOST_CONFIG_H
#define LLDB_HOST_CONFIG_H
#cmakedefine LLDB_CONFIG_TERMIOS_SUPPORTED
#cmakedefine LLDB_DISABLE_POSIX
#cmakedefine01 HAVE_SYS_EVENT_H
#endif // #ifndef LLDB_HOST_CONFIG_H

5
contrib/llvm/tools/lldb/include/lldb/Host/Editline.h
View File

@ -43,7 +43,8 @@
// will only be
// used in cases where this is true. This is a compile time dependecy, for now
// selected per target Platform
#if defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__)
#if defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__) || \
defined(__OpenBSD__)
#define LLDB_EDITLINE_USE_WCHAR 1
#include <codecvt>
#else
@ -64,8 +65,8 @@
#include <vector>
#include "lldb/Host/ConnectionFileDescriptor.h"
#include "lldb/Host/FileSpec.h"
#include "lldb/Host/Predicate.h"
#include "lldb/Utility/FileSpec.h"
namespace lldb_private {
namespace line_editor {

13
contrib/llvm/tools/lldb/include/lldb/Host/File.h
View File

@ -10,18 +10,15 @@
#ifndef liblldb_File_h_
#define liblldb_File_h_
// C Includes
// C++ Includes
#include "lldb/Host/IOObject.h"
#include "lldb/Host/PosixApi.h"
#include "lldb/Utility/Error.h"
#include "lldb/lldb-private.h"
#include <stdarg.h>
#include <stdio.h>
#include <sys/types.h>
// Other libraries and framework includes
// Project includes
#include "lldb/Host/IOObject.h"
#include "lldb/Host/PosixApi.h"
#include "lldb/lldb-private.h"
namespace lldb_private {
//----------------------------------------------------------------------

5
contrib/llvm/tools/lldb/include/lldb/Host/FileCache.h
View File

@ -9,13 +9,14 @@
#ifndef liblldb_Host_FileCache_h
#define liblldb_Host_FileCache_h
#include <map>
#include <stdint.h>
#include "lldb/lldb-forward.h"
#include "lldb/lldb-types.h"
#include "lldb/Core/Error.h"
#include "lldb/Host/FileSpec.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/FileSpec.h"
namespace lldb_private {
class FileCache {

36
contrib/llvm/tools/lldb/include/lldb/Host/FileSystem.h
View File

@ -10,8 +10,8 @@
#ifndef liblldb_Host_FileSystem_h
#define liblldb_Host_FileSystem_h
#include "lldb/Core/Error.h"
#include "lldb/Host/FileSpec.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/FileSpec.h"
#include "llvm/Support/Chrono.h"
#include "lldb/lldb-types.h"
@ -26,47 +26,15 @@ class FileSystem {
static const char *DEV_NULL;
static const char *PATH_CONVERSION_ERROR;
static FileSpec::PathSyntax GetNativePathSyntax();
static Error MakeDirectory(const FileSpec &file_spec, uint32_t mode);
static Error DeleteDirectory(const FileSpec &file_spec, bool recurse);
static Error GetFilePermissions(const FileSpec &file_spec,
uint32_t &file_permissions);
static Error SetFilePermissions(const FileSpec &file_spec,
uint32_t file_permissions);
static lldb::user_id_t GetFileSize(const FileSpec &file_spec);
static bool GetFileExists(const FileSpec &file_spec);
static Error Hardlink(const FileSpec &src, const FileSpec &dst);
static int GetHardlinkCount(const FileSpec &file_spec);
static Error Symlink(const FileSpec &src, const FileSpec &dst);
static Error Readlink(const FileSpec &src, FileSpec &dst);
static Error Unlink(const FileSpec &file_spec);
static Error ResolveSymbolicLink(const FileSpec &src, FileSpec &dst);
static bool CalculateMD5(const FileSpec &file_spec, uint64_t &low,
uint64_t &high);
static bool CalculateMD5(const FileSpec &file_spec, uint64_t offset,
uint64_t length, uint64_t &low, uint64_t &high);
static bool CalculateMD5AsString(const FileSpec &file_spec,
std::string &digest_str);
static bool CalculateMD5AsString(const FileSpec &file_spec, uint64_t offset,
uint64_t length, std::string &digest_str);
/// Return \b true if \a spec is on a locally mounted file system, \b false
/// otherwise.
static bool IsLocal(const FileSpec &spec);
/// Wraps ::fopen in a platform-independent way. Once opened, FILEs can be
/// manipulated and closed with the normal ::fread, ::fclose, etc. functions.
static FILE *Fopen(const char *path, const char *mode);
/// Wraps ::stat in a platform-independent way.
static int Stat(const char *path, struct stat *stats);
static llvm::sys::TimePoint<> GetModificationTime(const FileSpec &file_spec);
};
}

18
contrib/llvm/tools/lldb/include/lldb/Host/Host.h
View File

@ -16,10 +16,10 @@
#include <map>
#include <string>
#include "lldb/Core/StringList.h"
#include "lldb/Host/File.h"
#include "lldb/Host/FileSpec.h"
#include "lldb/Host/HostThread.h"
#include "lldb/Utility/FileSpec.h"
#include "lldb/Utility/StringList.h"
#include "lldb/lldb-private-forward.h"
#include "lldb/lldb-private.h"
@ -99,14 +99,6 @@ class Host {
static void Kill(lldb::pid_t pid, int signo);
//------------------------------------------------------------------
/// Get the thread ID for the calling thread in the current process.
///
/// @return
/// The thread ID for the calling thread in the current process.
//------------------------------------------------------------------
static lldb::tid_t GetCurrentThreadID();
//------------------------------------------------------------------
/// Get the thread token (the one returned by ThreadCreate when the thread was
/// created) for the
@ -193,7 +185,7 @@ class Host {
static bool GetProcessInfo(lldb::pid_t pid, ProcessInstanceInfo &proc_info);
#if (defined(__APPLE__) || defined(__linux__) || defined(__FreeBSD__) || \
defined(__GLIBC__) || defined(__NetBSD__)) && \
defined(__GLIBC__) || defined(__NetBSD__) || defined(__OpenBSD__)) && \
!defined(__ANDROID__)
static short GetPosixspawnFlags(const ProcessLaunchInfo &launch_info);
@ -246,10 +238,6 @@ class Host {
uint32_t timeout_sec,
bool run_in_default_shell = true);
static lldb::DataBufferSP GetAuxvData(lldb_private::Process *process);
static lldb::DataBufferSP GetAuxvData(lldb::pid_t pid);
static bool OpenFileInExternalEditor(const FileSpec &file_spec,
uint32_t line_no);

3
contrib/llvm/tools/lldb/include/lldb/Host/HostInfo.h
View File

@ -51,6 +51,9 @@
#elif defined(__NetBSD__)
#include "lldb/Host/netbsd/HostInfoNetBSD.h"
#define HOST_INFO_TYPE HostInfoNetBSD
#elif defined(__OpenBSD__)
#include "lldb/Host/openbsd/HostInfoOpenBSD.h"
#define HOST_INFO_TYPE HostInfoOpenBSD
#elif defined(__APPLE__)
#include "lldb/Host/macosx/HostInfoMacOSX.h"
#define HOST_INFO_TYPE HostInfoMacOSX

35
contrib/llvm/tools/lldb/include/lldb/Host/HostInfoBase.h
View File

@ -11,7 +11,7 @@
#define lldb_Host_HostInfoBase_h_
#include "lldb/Core/ArchSpec.h"
#include "lldb/Host/FileSpec.h"
#include "lldb/Utility/FileSpec.h"
#include "lldb/lldb-enumerations.h"
#include "llvm/ADT/StringRef.h"
@ -34,39 +34,6 @@ class HostInfoBase {
static void Initialize();
static void Terminate();
//------------------------------------------------------------------
/// Returns the number of CPUs on this current host.
///
/// @return
/// Number of CPUs on this current host, or zero if the number
/// of CPUs can't be determined on this host.
//------------------------------------------------------------------
static uint32_t GetNumberCPUS();
//------------------------------------------------------------------
/// Returns the maximum length of a thread name on this platform.
///
/// @return
/// Maximum length of a thread name on this platform.
//------------------------------------------------------------------
static uint32_t GetMaxThreadNameLength();
//------------------------------------------------------------------
/// Gets the host vendor string.
///
/// @return
/// A const string object containing the host vendor name.
//------------------------------------------------------------------
static llvm::StringRef GetVendorString();
//------------------------------------------------------------------
/// Gets the host Operating System (OS) string.
///
/// @return
/// A const string object containing the host OS name.
//------------------------------------------------------------------
static llvm::StringRef GetOSString();
//------------------------------------------------------------------
/// Gets the host target triple as a const string.
///

2
contrib/llvm/tools/lldb/include/lldb/Host/HostNativeProcessBase.h
View File

@ -10,8 +10,8 @@
#ifndef lldb_Host_HostNativeProcessBase_h_
#define lldb_Host_HostNativeProcessBase_h_
#include "lldb/Core/Error.h"
#include "lldb/Host/HostProcess.h"
#include "lldb/Utility/Error.h"
#include "lldb/lldb-defines.h"
#include "lldb/lldb-types.h"

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