This is an archive of the discontinued LLVM Phabricator instance.

Differential D29427

Move some classes from Core -> Utility
ClosedPublic

Authored by zturner on Feb 1 2017, 2:33 PM.

Details

Reviewers
beanz
jingham
Commits
rGbf9a77305f7d: Move classes from Core -> Utility.
rLLDB293941: Move classes from Core -> Utility.
rL293941: Move classes from Core -> Utility.
Summary

NFC here, this only moves ConstString, Error, RegularExpression, Stream, and StreamString from Core to Utility. The CL is large because these headers are included in many places, so it required updating every include to point to the new location.

This change isn't very controversial, but it will require an update of the Xcode project. We can do that now so that I can submit this in one large patch, or I can just go in with this and someone can fix up the Xcode project later. LMK what is preferred.

Diff Detail

Event Timeline

zturner created this revision.Feb 1 2017, 2:33 PM
Herald added subscribers: mgorny, nemanjai, srhines and 2 others. · View Herald TranscriptFeb 1 2017, 2:33 PM
jingham accepted this revision.Feb 1 2017, 4:49 PM

This looks fine to me. Just check it on in and we'll fix the project files after the fact.

BTW, did you scrub the Host code and do the mutatis mutandis on them, or will we have to do that too?

This revision is now accepted and ready to land.Feb 1 2017, 4:49 PM
zturner added a comment.Feb 1 2017, 4:58 PM

I didn't do everything needed to get Utility to be standalone if that's what you mean. Some things are trickier than others, so I wanted to isolate this CL to strictly mechanical code move.

What Host code were you referring to?

BTW, I'll probably submit this tomorrow since I'm heading out soon and won't be around in case something breaks.

jingham added a comment.Feb 1 2017, 5:02 PM

I meant the code in source/Host, but somehow missed the change to Host/macosx/Symbols.cpp on the first pass, so you probably did.

Closed by commit rL293941: Move classes from Core -> Utility. (authored by zturner). · Explain WhyFeb 2 2017, 1:52 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
lldb/
include/
lldb/
Breakpoint/
4 lines
2 lines
Core/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
6 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
4 lines
4 lines
6 lines
2 lines
4 lines
DataFormatters/
2 lines
2 lines
2 lines
2 lines
2 lines
Expression/
2 lines
2 lines
2 lines
4 lines
2 lines
Host/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
common/
2 lines
2 lines
2 lines
posix/
2 lines
Interpreter/
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
4 lines
8 lines
2 lines
2 lines
2 lines
2 lines
Symbol/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
Target/
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
Utility/
479 lines
315 lines
2 lines
4 lines
217 lines
548 lines
51 lines
141 lines
source/
API/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
6 lines
4 lines
2 lines
2 lines
2 lines
4 lines
6 lines
2 lines
2 lines
Breakpoint/
4 lines
4 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
Commands/
4 lines
2 lines
4 lines
2 lines
4 lines
2 lines
Core/
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
5 lines
2 lines
4 lines
2 lines
4 lines
4 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
6 lines
6 lines
2 lines
2 lines
6 lines
4 lines
4 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
8 lines
2 lines
2 lines
2 lines
DataFormatters/
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
Expression/
2 lines
2 lines
2 lines
2 lines
6 lines
2 lines
4 lines
4 lines
4 lines
Host/
common/
4 lines
2 lines
6 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
freebsd/
4 lines
linux/
2 lines
macosx/
2 lines
netbsd/
4 lines
posix/
2 lines
4 lines
2 lines
4 lines
windows/
2 lines
2 lines
2 lines
2 lines
Interpreter/
4 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
Plugins/
ABI/
MacOSX-arm/
4 lines
MacOSX-arm64/
2 lines
4 lines
MacOSX-i386/
4 lines
SysV-arm/
4 lines
SysV-arm64/
4 lines
SysV-hexagon/
4 lines
SysV-i386/
4 lines
SysV-mips/
4 lines
SysV-mips64/
4 lines
SysV-ppc/
4 lines
SysV-ppc64/
4 lines
SysV-s390x/
4 lines
SysV-x86_64/
4 lines
Disassembler/
llvm/
4 lines
DynamicLoader/
Hexagon-DYLD/
2 lines
POSIX-DYLD/
2 lines
ExpressionParser/
Clang/
2 lines
2 lines
2 lines
4 lines
2 lines
4 lines
2 lines
2 lines
4 lines
4 lines
8 lines
4 lines
Go/
2 lines
4 lines
Instruction/
ARM/
4 lines
4 lines
ARM64/
2 lines
4 lines
MIPS/
2 lines
4 lines
MIPS64/
2 lines
4 lines
InstrumentationRuntime/
AddressSanitizer/
4 lines
ThreadSanitizer/
4 lines
JITLoader/
GDB/
2 lines
Language/
CPlusPlus/
2 lines
4 lines
2 lines
4 lines
2 lines
4 lines
2 lines
2 lines
4 lines
4 lines
4 lines
2 lines
2 lines
4 lines
2 lines
2 lines
Go/
2 lines
2 lines
2 lines
Java/
2 lines
2 lines
OCaml/
2 lines
2 lines
ObjC/
2 lines
4 lines
2 lines
4 lines
2 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
2 lines
4 lines
2 lines
4 lines
ObjCPlusPlus/
2 lines
LanguageRuntime/
CPlusPlus/
ItaniumABI/
4 lines
Go/
4 lines
ObjC/
AppleObjCRuntime/
6 lines
6 lines
8 lines
2 lines
RenderScript/
RenderScriptRuntime/
6 lines
4 lines
ObjectContainer/
BSD-Archive/
2 lines
2 lines
Universal-Mach-O/
2 lines
ObjectFile/
ELF/
2 lines
4 lines
JIT/
2 lines
Mach-O/
4 lines
PECOFF/
2 lines
OperatingSystem/
Go/
2 lines
Python/
2 lines
Platform/
Android/
2 lines
2 lines
2 lines
FreeBSD/
2 lines
Kalimba/
4 lines
Linux/
4 lines
MacOSX/
4 lines
4 lines
4 lines
2 lines
2 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
NetBSD/
2 lines
POSIX/
2 lines
Windows/
2 lines
gdb-server/
4 lines
Process/
Darwin/
4 lines
4 lines
2 lines
2 lines
4 lines
FreeBSD/
2 lines
Linux/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
MacOSX-Kernel/
6 lines
2 lines
Utility/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
Windows/
Common/
2 lines
2 lines
2 lines
x64/
2 lines
x86/
2 lines
elf-core/
4 lines
gdb-remote/
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
6 lines
2 lines
2 lines
mach-core/
4 lines
2 lines
minidump/
2 lines
2 lines
4 lines
ScriptInterpreter/
None/
2 lines
Python/
2 lines
2 lines
StructuredData/
DarwinLog/
2 lines
SymbolFile/
DWARF/
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
8 lines
2 lines
4 lines
2 lines
Symtab/
2 lines
SymbolVendor/
ELF/
2 lines
MacOSX/
2 lines
SystemRuntime/
MacOSX/
2 lines
4 lines
2 lines
4 lines
2 lines
4 lines
2 lines
4 lines
2 lines
2 lines
UnwindAssembly/
InstEmulation/
4 lines
x86/
2 lines
2 lines
Symbol/
2 lines
2 lines
2 lines
6 lines
2 lines
2 lines
2 lines
6 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
4 lines
2 lines
Target/
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
6 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
Utility/
5 lines
336 lines
336 lines
2 lines
2 lines
2 lines
208 lines
2 lines
613 lines
65 lines
tools/
argdumper/
2 lines
lldb-server/
2 lines
2 lines
2 lines
2 lines
2 lines
unittests/
Breakpoint/
2 lines
Core/
2 lines
2 lines
4 lines
2 lines
2 lines
Editline/
2 lines
Expression/
2 lines

Diff 86722

lldb/include/lldb/Breakpoint/BreakpointResolver.h

Context not available.
#include "lldb/Breakpoint/Breakpoint.h" #include "lldb/Breakpoint/Breakpoint.h"
#include "lldb/Breakpoint/BreakpointResolver.h" #include "lldb/Breakpoint/BreakpointResolver.h"
#include "lldb/Core/Address.h" #include "lldb/Core/Address.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/RegularExpression.h"
#include "lldb/Core/SearchFilter.h" #include "lldb/Core/SearchFilter.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/RegularExpression.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/include/lldb/Breakpoint/BreakpointResolverFileRegex.h

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Breakpoint/BreakpointResolver.h" #include "lldb/Breakpoint/BreakpointResolver.h"
#include "lldb/Core/ConstString.h" #include "lldb/Utility/ConstString.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/include/lldb/Core/AddressResolver.h

Context not available.
// Project includes // Project includes
#include "lldb/Core/Address.h" #include "lldb/Core/Address.h"
#include "lldb/Core/AddressRange.h" #include "lldb/Core/AddressRange.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/SearchFilter.h" #include "lldb/Core/SearchFilter.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/include/lldb/Core/AddressResolverName.h

Context not available.
// Project includes // Project includes
#include "lldb/Core/AddressResolver.h" #include "lldb/Core/AddressResolver.h"
#include "lldb/Core/RegularExpression.h" #include "lldb/Utility/RegularExpression.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/include/lldb/Core/ArchSpec.h

Context not available.
#if defined(__cplusplus) #if defined(__cplusplus)
#include "lldb/Core/ConstString.h" #include "lldb/Utility/ConstString.h"
#include "lldb/lldb-forward.h" #include "lldb/lldb-forward.h"
#include "llvm/ADT/Triple.h" #include "llvm/ADT/Triple.h"
Context not available.

lldb/include/lldb/Core/Broadcaster.h

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/ConstString.h" #include "lldb/Utility/ConstString.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/SmallVector.h"
Context not available.

lldb/include/lldb/Core/Communication.h

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/Broadcaster.h" #include "lldb/Core/Broadcaster.h"
#include "lldb/Core/Error.h"
#include "lldb/Host/HostThread.h" #include "lldb/Host/HostThread.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/Timeout.h" #include "lldb/Utility/Timeout.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
Context not available.

lldb/include/lldb/Core/ConstString.h

  • This file was deleted.
//===-- ConstString.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_ConstString_h_
#define liblldb_ConstString_h_
// C Includes
// C++ Includes
// Other libraries and framework includes
#include "llvm/ADT/StringRef.h"
// Project includes
#include "lldb/lldb-private.h"
namespace lldb_private {
//----------------------------------------------------------------------
/// @class ConstString ConstString.h "lldb/Core/ConstString.h"
/// @brief A uniqued constant string class.
///
/// Provides an efficient way to store strings as uniqued strings. After
/// the strings are uniqued, finding strings that are equal to one
/// another is very fast as just the pointers need to be compared. It
/// also allows for many common strings from many different sources to
/// be shared to keep the memory footprint low.
///
/// No reference counting is done on strings that are added to the
/// string pool, once strings are added they are in the string pool for
/// the life of the program.
//----------------------------------------------------------------------
class ConstString {
public:
//------------------------------------------------------------------
/// Default constructor
///
/// Initializes the string to an empty string.
//------------------------------------------------------------------
ConstString() : m_string(nullptr) {}
//------------------------------------------------------------------
/// Copy constructor
///
/// Copies the string value in \a rhs into this object.
///
/// @param[in] rhs
/// Another string object to copy.
//------------------------------------------------------------------
ConstString(const ConstString &rhs) : m_string(rhs.m_string) {}
explicit ConstString(const llvm::StringRef &s);
//------------------------------------------------------------------
/// Construct with C String value
///
/// Constructs this object with a C string by looking to see if the
/// C string already exists in the global string pool. If it doesn't
/// exist, it is added to the string pool.
///
/// @param[in] cstr
/// A NULL terminated C string to add to the string pool.
//------------------------------------------------------------------
explicit ConstString(const char *cstr);
//------------------------------------------------------------------
/// Construct with C String value with max length
///
/// Constructs this object with a C string with a length. If
/// \a max_cstr_len is greater than the actual length of the string,
/// the string length will be truncated. This allows substrings to
/// be created without the need to NULL terminate the string as it
/// is passed into this function.
///
/// @param[in] cstr
/// A pointer to the first character in the C string. The C
/// string can be NULL terminated in a buffer that contains
/// more characters than the length of the string, or the
/// string can be part of another string and a new substring
/// can be created.
///
/// @param[in] max_cstr_len
/// The max length of \a cstr. If the string length of \a cstr
/// is less than \a max_cstr_len, then the string will be
/// truncated. If the string length of \a cstr is greater than
/// \a max_cstr_len, then only max_cstr_len bytes will be used
/// from \a cstr.
//------------------------------------------------------------------
explicit ConstString(const char *cstr, size_t max_cstr_len);
//------------------------------------------------------------------
/// Destructor
///
/// Since constant string values are currently not reference counted,
/// there isn't much to do here.
//------------------------------------------------------------------
~ConstString() = default;
//----------------------------------------------------------------------
/// C string equality binary predicate function object for ConstString
/// objects.
//----------------------------------------------------------------------
struct StringIsEqual {
//--------------------------------------------------------------
/// C equality test.
///
/// Two C strings are equal when they are contained in ConstString
/// objects when their pointer values are equal to each other.
///
/// @return
/// Returns \b true if the C string in \a lhs is equal to
/// the C string value in \a rhs, \b false otherwise.
//--------------------------------------------------------------
bool operator()(const char *lhs, const char *rhs) const {
return lhs == rhs;
}
};
//------------------------------------------------------------------
/// Convert to bool operator.
///
/// This allows code to check a ConstString object to see if it
/// contains a valid string using code such as:
///
/// @code
/// ConstString str(...);
/// if (str)
/// { ...
/// @endcode
///
/// @return
/// /b True this object contains a valid non-empty C string, \b
/// false otherwise.
//------------------------------------------------------------------
explicit operator bool() const { return m_string && m_string[0]; }
//------------------------------------------------------------------
/// Assignment operator
///
/// Assigns the string in this object with the value from \a rhs.
///
/// @param[in] rhs
/// Another string object to copy into this object.
///
/// @return
/// A const reference to this object.
//------------------------------------------------------------------
const ConstString &operator=(const ConstString &rhs) {
m_string = rhs.m_string;
return *this;
}
//------------------------------------------------------------------
/// Equal to operator
///
/// Returns true if this string is equal to the string in \a rhs.
/// This operation is very fast as it results in a pointer
/// comparison since all strings are in a uniqued in a global string
/// pool.
///
/// @param[in] rhs
/// Another string object to compare this object to.
///
/// @return
/// @li \b true if this object is equal to \a rhs.
/// @li \b false if this object is not equal to \a rhs.
//------------------------------------------------------------------
bool operator==(const ConstString &rhs) const {
// We can do a pointer compare to compare these strings since they
// must come from the same pool in order to be equal.
return m_string == rhs.m_string;
}
//------------------------------------------------------------------
/// Not equal to operator
///
/// Returns true if this string is not equal to the string in \a rhs.
/// This operation is very fast as it results in a pointer
/// comparison since all strings are in a uniqued in a global string
/// pool.
///
/// @param[in] rhs
/// Another string object to compare this object to.
///
/// @return
/// @li \b true if this object is not equal to \a rhs.
/// @li \b false if this object is equal to \a rhs.
//------------------------------------------------------------------
bool operator!=(const ConstString &rhs) const {
return m_string != rhs.m_string;
}
bool operator<(const ConstString &rhs) const;
//------------------------------------------------------------------
/// Get the string value as a C string.
///
/// Get the value of the contained string as a NULL terminated C
/// string value.
///
/// If \a value_if_empty is nullptr, then nullptr will be returned.
///
/// @return
/// Returns \a value_if_empty if the string is empty, otherwise
/// the C string value contained in this object.
//------------------------------------------------------------------
const char *AsCString(const char *value_if_empty = nullptr) const {
return (IsEmpty() ? value_if_empty : m_string);
}
//------------------------------------------------------------------
/// Get the string value as a llvm::StringRef
///
/// @return
/// Returns a new llvm::StringRef object filled in with the
/// needed data.
//------------------------------------------------------------------
llvm::StringRef GetStringRef() const {
return llvm::StringRef(m_string, GetLength());
}
//------------------------------------------------------------------
/// Get the string value as a C string.
///
/// Get the value of the contained string as a NULL terminated C
/// string value. Similar to the ConstString::AsCString() function,
/// yet this function will always return nullptr if the string is not
/// valid. So this function is a direct accessor to the string
/// pointer value.
///
/// @return
/// Returns nullptr the string is invalid, otherwise the C string
/// value contained in this object.
//------------------------------------------------------------------
const char *GetCString() const { return m_string; }
//------------------------------------------------------------------
/// Get the length in bytes of string value.
///
/// The string pool stores the length of the string, so we can avoid
/// calling strlen() on the pointer value with this function.
///
/// @return
/// Returns the number of bytes that this string occupies in
/// memory, not including the NULL termination byte.
//------------------------------------------------------------------
size_t GetLength() const;
//------------------------------------------------------------------
/// Clear this object's state.
///
/// Clear any contained string and reset the value to the an empty
/// string value.
//------------------------------------------------------------------
void Clear() { m_string = nullptr; }
//------------------------------------------------------------------
/// Equal to operator
///
/// Returns true if this string is equal to the string in \a rhs.
/// If case sensitive equality is tested, this operation is very
/// fast as it results in a pointer comparison since all strings
/// are in a uniqued in a global string pool.
///
/// @param[in] rhs
/// The Left Hand Side const ConstString object reference.
///
/// @param[in] rhs
/// The Right Hand Side const ConstString object reference.
///
/// @param[in] case_sensitive
/// Case sensitivity. If true, case sensitive equality
/// will be tested, otherwise character case will be ignored
///
/// @return
/// @li \b true if this object is equal to \a rhs.
/// @li \b false if this object is not equal to \a rhs.
//------------------------------------------------------------------
static bool Equals(const ConstString &lhs, const ConstString &rhs,
const bool case_sensitive = true);
//------------------------------------------------------------------
/// Compare two string objects.
///
/// Compares the C string values contained in \a lhs and \a rhs and
/// returns an integer result.
///
/// NOTE: only call this function when you want a true string
/// comparison. If you want string equality use the, use the ==
/// operator as it is much more efficient. Also if you want string
/// inequality, use the != operator for the same reasons.
///
/// @param[in] lhs
/// The Left Hand Side const ConstString object reference.
///
/// @param[in] rhs
/// The Right Hand Side const ConstString object reference.
///
/// @param[in] case_sensitive
/// Case sensitivity of compare. If true, case sensitive compare
/// will be performed, otherwise character case will be ignored
///
/// @return
/// @li -1 if lhs < rhs
/// @li 0 if lhs == rhs
/// @li 1 if lhs > rhs
//------------------------------------------------------------------
static int Compare(const ConstString &lhs, const ConstString &rhs,
const bool case_sensitive = true);
//------------------------------------------------------------------
/// Dump the object description to a stream.
///
/// Dump the string value to the stream \a s. If the contained string
/// is empty, print \a value_if_empty to the stream instead. If
/// \a value_if_empty is nullptr, then nothing will be dumped to the
/// stream.
///
/// @param[in] s
/// The stream that will be used to dump the object description.
///
/// @param[in] value_if_empty
/// The value to dump if the string is empty. If nullptr, nothing
/// will be output to the stream.
//------------------------------------------------------------------
void Dump(Stream *s, const char *value_if_empty = nullptr) const;
//------------------------------------------------------------------
/// Dump the object debug description to a stream.
///
/// @param[in] s
/// The stream that will be used to dump the object description.
//------------------------------------------------------------------
void DumpDebug(Stream *s) const;
//------------------------------------------------------------------
/// Test for empty string.
///
/// @return
/// @li \b true if the contained string is empty.
/// @li \b false if the contained string is not empty.
//------------------------------------------------------------------
bool IsEmpty() const { return m_string == nullptr || m_string[0] == '\0'; }
//------------------------------------------------------------------
/// Set the C string value.
///
/// Set the string value in the object by uniquing the \a cstr
/// string value in our global string pool.
///
/// If the C string already exists in the global string pool, it
/// finds the current entry and returns the existing value. If it
/// doesn't exist, it is added to the string pool.
///
/// @param[in] cstr
/// A NULL terminated C string to add to the string pool.
//------------------------------------------------------------------
void SetCString(const char *cstr);
void SetString(const llvm::StringRef &s);
//------------------------------------------------------------------
/// Set the C string value and its mangled counterpart.
///
/// Object files and debug symbols often use mangled string to
/// represent the linkage name for a symbol, function or global.
/// The string pool can efficiently store these values and their
/// counterparts so when we run into another instance of a mangled
/// name, we can avoid calling the name demangler over and over on
/// the same strings and then trying to unique them.
///
/// @param[in] demangled
/// The demangled C string to correlate with the \a mangled
/// name.
///
/// @param[in] mangled
/// The already uniqued mangled ConstString to correlate the
/// soon to be uniqued version of \a demangled.
//------------------------------------------------------------------
void SetCStringWithMangledCounterpart(const char *demangled,
const ConstString &mangled);
//------------------------------------------------------------------
/// Retrieve the mangled or demangled counterpart for a mangled
/// or demangled ConstString.
///
/// Object files and debug symbols often use mangled string to
/// represent the linkage name for a symbol, function or global.
/// The string pool can efficiently store these values and their
/// counterparts so when we run into another instance of a mangled
/// name, we can avoid calling the name demangler over and over on
/// the same strings and then trying to unique them.
///
/// @param[in] counterpart
/// A reference to a ConstString object that might get filled in
/// with the demangled/mangled counterpart.
///
/// @return
/// /b True if \a counterpart was filled in with the counterpart
/// /b false otherwise.
//------------------------------------------------------------------
bool GetMangledCounterpart(ConstString &counterpart) const;
//------------------------------------------------------------------
/// Set the C string value with length.
///
/// Set the string value in the object by uniquing \a cstr_len bytes
/// starting at the \a cstr string value in our global string pool.
/// If trim is true, then \a cstr_len indicates a maximum length of
/// the CString and if the actual length of the string is less, then
/// it will be trimmed.
///
/// If the C string already exists in the global string pool, it
/// finds the current entry and returns the existing value. If it
/// doesn't exist, it is added to the string pool.
///
/// @param[in] cstr
/// A NULL terminated C string to add to the string pool.
///
/// @param[in] cstr_len
/// The maximum length of the C string.
//------------------------------------------------------------------
void SetCStringWithLength(const char *cstr, size_t cstr_len);
//------------------------------------------------------------------
/// Set the C string value with the minimum length between
/// \a fixed_cstr_len and the actual length of the C string. This
/// can be used for data structures that have a fixed length to
/// store a C string where the string might not be NULL terminated
/// if the string takes the entire buffer.
//------------------------------------------------------------------
void SetTrimmedCStringWithLength(const char *cstr, size_t fixed_cstr_len);
//------------------------------------------------------------------
/// Get the memory cost of this object.
///
/// Return the size in bytes that this object takes in memory. This
/// returns the size in bytes of this object, which does not include
/// any the shared string values it may refer to.
///
/// @return
/// The number of bytes that this object occupies in memory.
///
/// @see ConstString::StaticMemorySize ()
//------------------------------------------------------------------
size_t MemorySize() const { return sizeof(ConstString); }
//------------------------------------------------------------------
/// Get the size in bytes of the current global string pool.
///
/// Reports the size in bytes of all shared C string values,
/// containers and any other values as a byte size for the
/// entire string pool.
///
/// @return
/// The number of bytes that the global string pool occupies
/// in memory.
//------------------------------------------------------------------
static size_t StaticMemorySize();
protected:
//------------------------------------------------------------------
// Member variables
//------------------------------------------------------------------
const char *m_string;
};
//------------------------------------------------------------------
/// Stream the string value \a str to the stream \a s
//------------------------------------------------------------------
Stream &operator<<(Stream &s, const ConstString &str);
} // namespace lldb_private
#endif // liblldb_ConstString_h_

lldb/include/lldb/Core/DataBufferMemoryMap.h

Context not available.
#define liblldb_DataBufferMemoryMap_h_ #define liblldb_DataBufferMemoryMap_h_
#include "lldb/Core/DataBuffer.h" #include "lldb/Core/DataBuffer.h"
#include "lldb/Core/Error.h" #include "lldb/Utility/Error.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
#include <string> #include <string>
Context not available.

lldb/include/lldb/Core/Error.h

  • This file was deleted.
//===-- Error.h -------------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef __DCError_h__
#define __DCError_h__
#if defined(__cplusplus)
#include "llvm/Support/DataTypes.h"
#include "llvm/Support/FormatVariadic.h"
#include <cstdarg>
#include <cstdio>
#include <string>
#include "lldb/lldb-private.h"
#include "llvm/Support/FormatVariadic.h"
namespace lldb_private {
class Log;
//----------------------------------------------------------------------
/// @class Error Error.h "lldb/Core/Error.h"
/// @brief An error handling class.
///
/// This class is designed to be able to hold any error code that can be
/// encountered on a given platform. The errors are stored as a value
/// of type Error::ValueType. This value should be large enough to hold
/// any and all errors that the class supports. Each error has an
/// associated type that is of type lldb::ErrorType. New types
/// can be added to support new error types, and architecture specific
/// types can be enabled. In the future we may wish to switch to a
/// registration mechanism where new error types can be registered at
/// runtime instead of a hard coded scheme.
///
/// All errors in this class also know how to generate a string
/// representation of themselves for printing results and error codes.
/// The string value will be fetched on demand and its string value will
/// be cached until the error is cleared of the value of the error
/// changes.
//----------------------------------------------------------------------
class Error {
public:
//------------------------------------------------------------------
/// Every error value that this object can contain needs to be able
/// to fit into ValueType.
//------------------------------------------------------------------
typedef uint32_t ValueType;
//------------------------------------------------------------------
/// Default constructor.
///
/// Initialize the error object with a generic success value.
///
/// @param[in] err
/// An error code.
///
/// @param[in] type
/// The type for \a err.
//------------------------------------------------------------------
Error();
explicit Error(ValueType err, lldb::ErrorType type = lldb::eErrorTypeGeneric);
explicit Error(const char *format, ...) __attribute__((format(printf, 2, 3)));
Error(const Error &rhs);
//------------------------------------------------------------------
/// Assignment operator.
///
/// @param[in] err
/// An error code.
///
/// @return
/// A const reference to this object.
//------------------------------------------------------------------
const Error &operator=(const Error &rhs);
//------------------------------------------------------------------
/// Assignment operator from a kern_return_t.
///
/// Sets the type to \c MachKernel and the error code to \a err.
///
/// @param[in] err
/// A mach error code.
///
/// @return
/// A const reference to this object.
//------------------------------------------------------------------
const Error &operator=(uint32_t err);
~Error();
//------------------------------------------------------------------
/// Get the error string associated with the current error.
//
/// Gets the error value as a NULL terminated C string. The error
/// string will be fetched and cached on demand. The error string
/// will be retrieved from a callback that is appropriate for the
/// type of the error and will be cached until the error value is
/// changed or cleared.
///
/// @return
/// The error as a NULL terminated C string value if the error
/// is valid and is able to be converted to a string value,
/// NULL otherwise.
//------------------------------------------------------------------
const char *AsCString(const char *default_error_str = "unknown error") const;
//------------------------------------------------------------------
/// Clear the object state.
///
/// Reverts the state of this object to contain a generic success
/// value and frees any cached error string value.
//------------------------------------------------------------------
void Clear();
//------------------------------------------------------------------
/// Test for error condition.
///
/// @return
/// \b true if this object contains an error, \b false
/// otherwise.
//------------------------------------------------------------------
bool Fail() const;
//------------------------------------------------------------------
/// Access the error value.
///
/// @return
/// The error value.
//------------------------------------------------------------------
ValueType GetError() const;
//------------------------------------------------------------------
/// Access the error type.
///
/// @return
/// The error type enumeration value.
//------------------------------------------------------------------
lldb::ErrorType GetType() const;
//------------------------------------------------------------------
/// Log an error to Log().
///
/// Log the error given a formatted string \a format. If the this
/// object contains an error code, update the error string to
/// contain the prefix "error: ", followed by the formatted string,
/// followed by the error value and any string that describes the
/// error value. This allows more context to be given to an error
/// string that remains cached in this object. Logging always occurs
/// even when the error code contains a non-error value.
///
/// @param[in] format
/// A printf style format string.
///
/// @param[in] ...
/// Variable arguments that are needed for the printf style
/// format string \a format.
//------------------------------------------------------------------
void PutToLog(Log *log, const char *format, ...)
__attribute__((format(printf, 3, 4)));
//------------------------------------------------------------------
/// Log an error to Log() if the error value is an error.
///
/// Log the error given a formatted string \a format only if the
/// error value in this object describes an error condition. If the
/// this object contains an error, update the error string to
/// contain the prefix "error: " followed by the formatted string,
/// followed by the error value and any string that describes the
/// error value. This allows more context to be given to an error
/// string that remains cached in this object.
///
/// @param[in] format
/// A printf style format string.
///
/// @param[in] ...
/// Variable arguments that are needed for the printf style
/// format string \a format.
//------------------------------------------------------------------
void LogIfError(Log *log, const char *format, ...)
__attribute__((format(printf, 3, 4)));
//------------------------------------------------------------------
/// Set accessor from a kern_return_t.
///
/// Set accesssor for the error value to \a err and the error type
/// to \c MachKernel.
///
/// @param[in] err
/// A mach error code.
//------------------------------------------------------------------
void SetMachError(uint32_t err);
void SetExpressionError(lldb::ExpressionResults, const char *mssg);
int SetExpressionErrorWithFormat(lldb::ExpressionResults, const char *format,
...) __attribute__((format(printf, 3, 4)));
//------------------------------------------------------------------
/// Set accesssor with an error value and type.
///
/// Set accesssor for the error value to \a err and the error type
/// to \a type.
///
/// @param[in] err
/// A mach error code.
///
/// @param[in] type
/// The type for \a err.
//------------------------------------------------------------------
void SetError(ValueType err, lldb::ErrorType type);
//------------------------------------------------------------------
/// Set the current error to errno.
///
/// Update the error value to be \c errno and update the type to
/// be \c Error::POSIX.
//------------------------------------------------------------------
void SetErrorToErrno();
//------------------------------------------------------------------
/// Set the current error to a generic error.
///
/// Update the error value to be \c LLDB_GENERIC_ERROR and update the
/// type to be \c Error::Generic.
//------------------------------------------------------------------
void SetErrorToGenericError();
//------------------------------------------------------------------
/// Set the current error string to \a err_str.
///
/// Set accessor for the error string value for a generic errors,
/// or to supply additional details above and beyond the standard
/// error strings that the standard type callbacks typically
/// provide. This allows custom strings to be supplied as an
/// error explanation. The error string value will remain until the
/// error value is cleared or a new error value/type is assigned.
///
/// @param err_str
/// The new custom error string to copy and cache.
//------------------------------------------------------------------
void SetErrorString(llvm::StringRef err_str);
//------------------------------------------------------------------
/// Set the current error string to a formatted error string.
///
/// @param format
/// A printf style format string
//------------------------------------------------------------------
int SetErrorStringWithFormat(const char *format, ...)
__attribute__((format(printf, 2, 3)));
int SetErrorStringWithVarArg(const char *format, va_list args);
template <typename... Args>
void SetErrorStringWithFormatv(const char *format, Args &&... args) {
SetErrorString(llvm::formatv(format, std::forward<Args>(args)...).str());
}
//------------------------------------------------------------------
/// Test for success condition.
///
/// Returns true if the error code in this object is considered a
/// successful return value.
///
/// @return
/// \b true if this object contains an value that describes
/// success (non-erro), \b false otherwise.
//------------------------------------------------------------------
bool Success() const;
//------------------------------------------------------------------
/// Test for a failure due to a generic interrupt.
///
/// Returns true if the error code in this object was caused by an interrupt.
/// At present only supports Posix EINTR.
///
/// @return
/// \b true if this object contains an value that describes
/// failure due to interrupt, \b false otherwise.
//------------------------------------------------------------------
bool WasInterrupted() const;
protected:
//------------------------------------------------------------------
/// Member variables
//------------------------------------------------------------------
ValueType m_code; ///< Error code as an integer value.
lldb::ErrorType m_type; ///< The type of the above error code.
mutable std::string m_string; ///< A string representation of the error code.
};
} // namespace lldb_private
namespace llvm {
template <> struct format_provider<lldb_private::Error> {
static void format(const lldb_private::Error &error, llvm::raw_ostream &OS,
llvm::StringRef Options) {
llvm::format_provider<llvm::StringRef>::format(error.AsCString(), OS,
Options);
}
};
}
#endif // #if defined(__cplusplus)
#endif // #ifndef __DCError_h__

lldb/include/lldb/Core/Event.h

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/Broadcaster.h" #include "lldb/Core/Broadcaster.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/StructuredData.h" #include "lldb/Core/StructuredData.h"
#include "lldb/Host/Predicate.h" #include "lldb/Host/Predicate.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/include/lldb/Core/FormatEntity.h

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/Error.h" #include "lldb/Utility/Error.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
namespace llvm { namespace llvm {
Context not available.

lldb/include/lldb/Core/IOHandler.h

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Flags.h" #include "lldb/Core/Flags.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/StringList.h" #include "lldb/Core/StringList.h"
#include "lldb/Core/ValueObjectList.h" #include "lldb/Core/ValueObjectList.h"
#include "lldb/Host/Predicate.h" #include "lldb/Host/Predicate.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/Stream.h"
#include "lldb/lldb-enumerations.h" #include "lldb/lldb-enumerations.h"
#include "lldb/lldb-public.h" #include "lldb/lldb-public.h"
Context not available.

lldb/include/lldb/Core/Log.h

Context not available.
#define liblldb_Log_h_ #define liblldb_Log_h_
// Project includes // Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Flags.h" #include "lldb/Core/Flags.h"
#include "lldb/Core/Logging.h" #include "lldb/Core/Logging.h"
#include "lldb/Core/PluginInterface.h" #include "lldb/Core/PluginInterface.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
// Other libraries and framework includes // Other libraries and framework includes
Context not available.

lldb/include/lldb/Core/Mangled.h

Context not available.
#define liblldb_Mangled_h_ #define liblldb_Mangled_h_
#if defined(__cplusplus) #if defined(__cplusplus)
#include "lldb/Core/ConstString.h" #include "lldb/Utility/ConstString.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
#include <vector> #include <vector>
Context not available.

lldb/include/lldb/Core/MappedHash.h

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/DataExtractor.h" #include "lldb/Core/DataExtractor.h"
#include "lldb/Core/Stream.h" #include "lldb/Utility/Stream.h"
class MappedHash { class MappedHash {
public: public:
Context not available.

lldb/include/lldb/Core/ModuleSpec.h

Context not available.
// Project includes // Project includes
#include "lldb/Core/ArchSpec.h" #include "lldb/Core/ArchSpec.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/UUID.h" #include "lldb/Core/UUID.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
#include "lldb/Target/PathMappingList.h" #include "lldb/Target/PathMappingList.h"
#include "lldb/Utility/Stream.h"
// Other libraries and framework includes // Other libraries and framework includes
#include "llvm/Support/Chrono.h" #include "llvm/Support/Chrono.h"
Context not available.

lldb/include/lldb/Core/RegularExpression.h

  • This file was deleted.
//===-- RegularExpression.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_RegularExpression_h_
#define liblldb_RegularExpression_h_
#ifdef _WIN32
#include "../lib/Support/regex_impl.h"
typedef llvm_regmatch_t regmatch_t;
typedef llvm_regex_t regex_t;
inline int regcomp(llvm_regex_t *a, const char *b, int c) {
return llvm_regcomp(a, b, c);
}
inline size_t regerror(int a, const llvm_regex_t *b, char *c, size_t d) {
return llvm_regerror(a, b, c, d);
}
inline int regexec(const llvm_regex_t *a, const char *b, size_t c,
llvm_regmatch_t d[], int e) {
return llvm_regexec(a, b, c, d, e);
}
inline void regfree(llvm_regex_t *a) { llvm_regfree(a); }
#else
#ifdef __ANDROID__
#include <regex>
#endif
#include <regex.h>
#endif
#include <stdint.h>
#include <string>
#include <vector>
namespace llvm {
class StringRef;
} // namespace llvm
namespace lldb_private {
//----------------------------------------------------------------------
/// @class RegularExpression RegularExpression.h "lldb/Core/RegularExpression.h"
/// @brief A C++ wrapper class for regex.
///
/// This regular expression class wraps the posix regex functions
/// \c regcomp(), \c regerror(), \c regexec(), and \c regfree() from
/// the header file in \c /usr/include/regex\.h.
//----------------------------------------------------------------------
class RegularExpression {
public:
class Match {
public:
Match(uint32_t max_matches) : m_matches() {
if (max_matches > 0)
m_matches.resize(max_matches + 1);
}
void Clear() {
const size_t num_matches = m_matches.size();
regmatch_t invalid_match = {-1, -1};
for (size_t i = 0; i < num_matches; ++i)
m_matches[i] = invalid_match;
}
size_t GetSize() const { return m_matches.size(); }
regmatch_t *GetData() {
return (m_matches.empty() ? nullptr : m_matches.data());
}
bool GetMatchAtIndex(llvm::StringRef s, uint32_t idx,
std::string &match_str) const;
bool GetMatchAtIndex(llvm::StringRef s, uint32_t idx,
llvm::StringRef &match_str) const;
bool GetMatchSpanningIndices(llvm::StringRef s, uint32_t idx1,
uint32_t idx2,
llvm::StringRef &match_str) const;
protected:
std::vector<regmatch_t>
m_matches; ///< Where parenthesized subexpressions results are stored
};
//------------------------------------------------------------------
/// Default constructor.
///
/// The default constructor that initializes the object state such
/// that it contains no compiled regular expression.
//------------------------------------------------------------------
RegularExpression();
explicit RegularExpression(llvm::StringRef string);
//------------------------------------------------------------------
/// Destructor.
///
/// Any previously compiled regular expression contained in this
/// object will be freed.
//------------------------------------------------------------------
~RegularExpression();
RegularExpression(const RegularExpression &rhs);
const RegularExpression &operator=(const RegularExpression &rhs);
//------------------------------------------------------------------
/// Compile a regular expression.
///
/// Compile a regular expression using the supplied regular
/// expression text. The compiled regular expression lives
/// in this object so that it can be readily used for regular
/// expression matches. Execute() can be called after the regular
/// expression is compiled. Any previously compiled regular
/// expression contained in this object will be freed.
///
/// @param[in] re
/// A NULL terminated C string that represents the regular
/// expression to compile.
///
/// @return
/// \b true if the regular expression compiles successfully,
/// \b false otherwise.
//------------------------------------------------------------------
bool Compile(llvm::StringRef string);
bool Compile(const char *) = delete;
//------------------------------------------------------------------
/// Executes a regular expression.
///
/// Execute a regular expression match using the compiled regular
/// expression that is already in this object against the match
/// string \a s. If any parens are used for regular expression
/// matches \a match_count should indicate the number of regmatch_t
/// values that are present in \a match_ptr.
///
/// @param[in] string
/// The string to match against the compile regular expression.
///
/// @param[in] match
/// A pointer to a RegularExpression::Match structure that was
/// properly initialized with the desired number of maximum
/// matches, or nullptr if no parenthesized matching is needed.
///
/// @return
/// \b true if \a string matches the compiled regular
/// expression, \b false otherwise.
//------------------------------------------------------------------
bool Execute(llvm::StringRef string, Match *match = nullptr) const;
bool Execute(const char *, Match * = nullptr) = delete;
size_t GetErrorAsCString(char *err_str, size_t err_str_max_len) const;
//------------------------------------------------------------------
/// Free the compiled regular expression.
///
/// If this object contains a valid compiled regular expression,
/// this function will free any resources it was consuming.
//------------------------------------------------------------------
void Free();
//------------------------------------------------------------------
/// Access the regular expression text.
///
/// Returns the text that was used to compile the current regular
/// expression.
///
/// @return
/// The NULL terminated C string that was used to compile the
/// current regular expression
//------------------------------------------------------------------
llvm::StringRef GetText() const;
//------------------------------------------------------------------
/// Test if valid.
///
/// Test if this object contains a valid regular expression.
///
/// @return
/// \b true if the regular expression compiled and is ready
/// for execution, \b false otherwise.
//------------------------------------------------------------------
bool IsValid() const;
void Clear() {
Free();
m_re.clear();
m_comp_err = 1;
}
int GetErrorCode() const { return m_comp_err; }
bool operator<(const RegularExpression &rhs) const;
private:
//------------------------------------------------------------------
// Member variables
//------------------------------------------------------------------
std::string m_re; ///< A copy of the original regular expression text
int m_comp_err; ///< Error code for the regular expression compilation
regex_t m_preg; ///< The compiled regular expression
};
} // namespace lldb_private
#endif // liblldb_RegularExpression_h_

lldb/include/lldb/Core/Section.h

Context not available.
#define liblldb_Section_h_ #define liblldb_Section_h_
#include "lldb/Core/AddressRange.h" #include "lldb/Core/AddressRange.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Flags.h" #include "lldb/Core/Flags.h"
#include "lldb/Core/ModuleChild.h" #include "lldb/Core/ModuleChild.h"
#include "lldb/Core/RangeMap.h" #include "lldb/Core/RangeMap.h"
#include "lldb/Core/UserID.h" #include "lldb/Core/UserID.h"
#include "lldb/Core/VMRange.h" #include "lldb/Core/VMRange.h"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
#include <limits.h> #include <limits.h>
Context not available.

lldb/include/lldb/Core/Stream.h

  • This file was deleted.
//===-- Stream.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_Stream_h_
#define liblldb_Stream_h_
// C Includes
#include <stdarg.h>
// C++ Includes
// Other libraries and framework includes
// Project includes
#include "lldb/Core/Flags.h"
#include "lldb/lldb-private.h"
#include "llvm/Support/FormatVariadic.h"
namespace lldb_private {
//----------------------------------------------------------------------
/// @class Stream Stream.h "lldb/Core/Stream.h"
/// @brief A stream class that can stream formatted output to a file.
//----------------------------------------------------------------------
class Stream {
public:
//------------------------------------------------------------------
/// \a m_flags bit values.
//------------------------------------------------------------------
enum {
eBinary = (1 << 0) ///< Get and put data as binary instead of as the default
///string mode.
};
//------------------------------------------------------------------
/// Construct with flags and address size and byte order.
///
/// Construct with dump flags \a flags and the default address
/// size. \a flags can be any of the above enumeration logical OR'ed
/// together.
//------------------------------------------------------------------
Stream(uint32_t flags, uint32_t addr_size, lldb::ByteOrder byte_order);
//------------------------------------------------------------------
/// Construct a default Stream, not binary, host byte order and
/// host addr size.
///
//------------------------------------------------------------------
Stream();
//------------------------------------------------------------------
/// Destructor
//------------------------------------------------------------------
virtual ~Stream();
//------------------------------------------------------------------
// Subclasses must override these methods
//------------------------------------------------------------------
//------------------------------------------------------------------
/// Flush the stream.
///
/// Subclasses should flush the stream to make any output appear
/// if the stream has any buffering.
//------------------------------------------------------------------
virtual void Flush() = 0;
//------------------------------------------------------------------
/// Output character bytes to the stream.
///
/// Appends \a src_len characters from the buffer \a src to the
/// stream.
///
/// @param[in] src
/// A buffer containing at least \a src_len bytes of data.
///
/// @param[in] src_len
/// A number of bytes to append to the stream.
///
/// @return
/// The number of bytes that were appended to the stream.
//------------------------------------------------------------------
virtual size_t Write(const void *src, size_t src_len) = 0;
//------------------------------------------------------------------
// Member functions
//------------------------------------------------------------------
size_t PutChar(char ch);
//------------------------------------------------------------------
/// Set the byte_order value.
///
/// Sets the byte order of the data to extract. Extracted values
/// will be swapped if necessary when decoding.
///
/// @param[in] byte_order
/// The byte order value to use when extracting data.
///
/// @return
/// The old byte order value.
//------------------------------------------------------------------
lldb::ByteOrder SetByteOrder(lldb::ByteOrder byte_order);
//------------------------------------------------------------------
/// Format a C string from a printf style format and variable
/// arguments and encode and append the resulting C string as hex
/// bytes.
///
/// @param[in] format
/// A printf style format string.
///
/// @param[in] ...
/// Any additional arguments needed for the printf format string.
///
/// @return
/// The number of bytes that were appended to the stream.
//------------------------------------------------------------------
size_t PrintfAsRawHex8(const char *format, ...)
__attribute__((__format__(__printf__, 2, 3)));
//------------------------------------------------------------------
/// Format a C string from a printf style format and variable
/// arguments and encode and append the resulting C string as hex
/// bytes.
///
/// @param[in] format
/// A printf style format string.
///
/// @param[in] ...
/// Any additional arguments needed for the printf format string.
///
/// @return
/// The number of bytes that were appended to the stream.
//------------------------------------------------------------------
size_t PutHex8(uint8_t uvalue);
size_t PutNHex8(size_t n, uint8_t uvalue);
size_t PutHex16(uint16_t uvalue,
lldb::ByteOrder byte_order = lldb::eByteOrderInvalid);
size_t PutHex32(uint32_t uvalue,
lldb::ByteOrder byte_order = lldb::eByteOrderInvalid);
size_t PutHex64(uint64_t uvalue,
lldb::ByteOrder byte_order = lldb::eByteOrderInvalid);
size_t PutMaxHex64(uint64_t uvalue, size_t byte_size,
lldb::ByteOrder byte_order = lldb::eByteOrderInvalid);
size_t PutFloat(float f,
lldb::ByteOrder byte_order = lldb::eByteOrderInvalid);
size_t PutDouble(double d,
lldb::ByteOrder byte_order = lldb::eByteOrderInvalid);
size_t PutLongDouble(long double ld,
lldb::ByteOrder byte_order = lldb::eByteOrderInvalid);
size_t PutPointer(void *ptr);
// Append \a src_len bytes from \a src to the stream as hex characters
// (two ascii characters per byte of input data)
size_t
PutBytesAsRawHex8(const void *src, size_t src_len,
lldb::ByteOrder src_byte_order = lldb::eByteOrderInvalid,
lldb::ByteOrder dst_byte_order = lldb::eByteOrderInvalid);
// Append \a src_len bytes from \a s to the stream as binary data.
size_t PutRawBytes(const void *s, size_t src_len,
lldb::ByteOrder src_byte_order = lldb::eByteOrderInvalid,
lldb::ByteOrder dst_byte_order = lldb::eByteOrderInvalid);
size_t PutCStringAsRawHex8(const char *s);
//------------------------------------------------------------------
/// Output a NULL terminated C string \a cstr to the stream \a s.
///
/// @param[in] cstr
/// A NULL terminated C string.
///
/// @return
/// A reference to this class so multiple things can be streamed
/// in one statement.
//------------------------------------------------------------------
Stream &operator<<(const char *cstr);
Stream &operator<<(llvm::StringRef str);
//------------------------------------------------------------------
/// Output a pointer value \a p to the stream \a s.
///
/// @param[in] p
/// A void pointer.
///
/// @return
/// A reference to this class so multiple things can be streamed
/// in one statement.
//------------------------------------------------------------------
Stream &operator<<(const void *p);
//------------------------------------------------------------------
/// Output a character \a ch to the stream \a s.
///
/// @param[in] ch
/// A printable character value.
///
/// @return
/// A reference to this class so multiple things can be streamed
/// in one statement.
//------------------------------------------------------------------
Stream &operator<<(char ch);
//------------------------------------------------------------------
/// Output a uint8_t \a uval to the stream \a s.
///
/// @param[in] uval
/// A uint8_t value.
///
/// @return
/// A reference to this class so multiple things can be streamed
/// in one statement.
//------------------------------------------------------------------
Stream &operator<<(uint8_t uval);
//------------------------------------------------------------------
/// Output a uint16_t \a uval to the stream \a s.
///
/// @param[in] uval
/// A uint16_t value.
///
/// @return
/// A reference to this class so multiple things can be streamed
/// in one statement.
//------------------------------------------------------------------
Stream &operator<<(uint16_t uval);
//------------------------------------------------------------------
/// Output a uint32_t \a uval to the stream \a s.
///
/// @param[in] uval
/// A uint32_t value.
///
/// @return
/// A reference to this class so multiple things can be streamed
/// in one statement.
//------------------------------------------------------------------
Stream &operator<<(uint32_t uval);
//------------------------------------------------------------------
/// Output a uint64_t \a uval to the stream \a s.
///
/// @param[in] uval
/// A uint64_t value.
///
/// @return
/// A reference to this class so multiple things can be streamed
/// in one statement.
//------------------------------------------------------------------
Stream &operator<<(uint64_t uval);
//------------------------------------------------------------------
/// Output a int8_t \a sval to the stream \a s.
///
/// @param[in] sval
/// A int8_t value.
///
/// @return
/// A reference to this class so multiple things can be streamed
/// in one statement.
//------------------------------------------------------------------
Stream &operator<<(int8_t sval);
//------------------------------------------------------------------
/// Output a int16_t \a sval to the stream \a s.
///
/// @param[in] sval
/// A int16_t value.
///
/// @return
/// A reference to this class so multiple things can be streamed
/// in one statement.
//------------------------------------------------------------------
Stream &operator<<(int16_t sval);
//------------------------------------------------------------------
/// Output a int32_t \a sval to the stream \a s.
///
/// @param[in] sval
/// A int32_t value.
///
/// @return
/// A reference to this class so multiple things can be streamed
/// in one statement.
//------------------------------------------------------------------
Stream &operator<<(int32_t sval);
//------------------------------------------------------------------
/// Output a int64_t \a sval to the stream \a s.
///
/// @param[in] sval
/// A int64_t value.
///
/// @return
/// A reference to this class so multiple things can be streamed
/// in one statement.
//------------------------------------------------------------------
Stream &operator<<(int64_t sval);
//------------------------------------------------------------------
/// Output an address value to this stream.
///
/// Put an address \a addr out to the stream with optional \a prefix
/// and \a suffix strings.
///
/// @param[in] addr
/// An address value.
///
/// @param[in] addr_size
/// Size in bytes of the address, used for formatting.
///
/// @param[in] prefix
/// A prefix C string. If nullptr, no prefix will be output.
///
/// @param[in] suffix
/// A suffix C string. If nullptr, no suffix will be output.
//------------------------------------------------------------------
void Address(uint64_t addr, uint32_t addr_size, const char *prefix = nullptr,
const char *suffix = nullptr);
//------------------------------------------------------------------
/// Output an address range to this stream.
///
/// Put an address range \a lo_addr - \a hi_addr out to the stream
/// with optional \a prefix and \a suffix strings.
///
/// @param[in] lo_addr
/// The start address of the address range.
///
/// @param[in] hi_addr
/// The end address of the address range.
///
/// @param[in] addr_size
/// Size in bytes of the address, used for formatting.
///
/// @param[in] prefix
/// A prefix C string. If nullptr, no prefix will be output.
///
/// @param[in] suffix
/// A suffix C string. If nullptr, no suffix will be output.
//------------------------------------------------------------------
void AddressRange(uint64_t lo_addr, uint64_t hi_addr, uint32_t addr_size,
const char *prefix = nullptr, const char *suffix = nullptr);
//------------------------------------------------------------------
/// Output a C string to the stream.
///
/// Print a C string \a cstr to the stream.
///
/// @param[in] cstr
/// The string to be output to the stream.
//------------------------------------------------------------------
size_t PutCString(llvm::StringRef cstr);
//------------------------------------------------------------------
/// Output and End of Line character to the stream.
//------------------------------------------------------------------
size_t EOL();
//------------------------------------------------------------------
/// Get the address size in bytes.
///
/// @return
/// The size of an address in bytes that is used when outputting
/// address and pointer values to the stream.
//------------------------------------------------------------------
uint32_t GetAddressByteSize() const;
//------------------------------------------------------------------
/// The flags accessor.
///
/// @return
/// A reference to the Flags member variable.
//------------------------------------------------------------------
Flags &GetFlags();
//------------------------------------------------------------------
/// The flags const accessor.
///
/// @return
/// A const reference to the Flags member variable.
//------------------------------------------------------------------
const Flags &GetFlags() const;
//------------------------------------------------------------------
//// The byte order accessor.
////
//// @return
//// The byte order.
//------------------------------------------------------------------
lldb::ByteOrder GetByteOrder() const;
//------------------------------------------------------------------
/// Get the current indentation level.
///
/// @return
/// The current indentation level as an integer.
//------------------------------------------------------------------
int GetIndentLevel() const;
//------------------------------------------------------------------
/// Indent the current line in the stream.
///
/// Indent the current line using the current indentation level and
/// print an optional string following the indentation spaces.
///
/// @param[in] s
/// A C string to print following the indentation. If nullptr, just
/// output the indentation characters.
//------------------------------------------------------------------
size_t Indent(const char *s = nullptr);
size_t Indent(llvm::StringRef s);
//------------------------------------------------------------------
/// Decrement the current indentation level.
//------------------------------------------------------------------
void IndentLess(int amount = 2);
//------------------------------------------------------------------
/// Increment the current indentation level.
//------------------------------------------------------------------
void IndentMore(int amount = 2);
//------------------------------------------------------------------
/// Output an offset value.
///
/// Put an offset \a uval out to the stream using the printf format
/// in \a format.
///
/// @param[in] offset
/// The offset value.
///
/// @param[in] format
/// The printf style format to use when outputting the offset.
//------------------------------------------------------------------
void Offset(uint32_t offset, const char *format = "0x%8.8x: ");
//------------------------------------------------------------------
/// Output printf formatted output to the stream.
///
/// Print some formatted output to the stream.
///
/// @param[in] format
/// A printf style format string.
///
/// @param[in] ...
/// Variable arguments that are needed for the printf style
/// format string \a format.
//------------------------------------------------------------------
size_t Printf(const char *format, ...) __attribute__((format(printf, 2, 3)));
size_t PrintfVarArg(const char *format, va_list args);
template <typename... Args> void Format(const char *format, Args &&... args) {
PutCString(llvm::formatv(format, std::forward<Args>(args)...).str());
}
//------------------------------------------------------------------
/// Output a quoted C string value to the stream.
///
/// Print a double quoted NULL terminated C string to the stream
/// using the printf format in \a format.
///
/// @param[in] cstr
/// A NULL terminated C string value.
///
/// @param[in] format
/// The optional C string format that can be overridden.
//------------------------------------------------------------------
void QuotedCString(const char *cstr, const char *format = "\"%s\"");
//------------------------------------------------------------------
/// Set the address size in bytes.
///
/// @param[in] addr_size
/// The new size in bytes of an address to use when outputting
/// address and pointer values.
//------------------------------------------------------------------
void SetAddressByteSize(uint32_t addr_size);
//------------------------------------------------------------------
/// Set the current indentation level.
///
/// @param[in] level
/// The new indentation level.
//------------------------------------------------------------------
void SetIndentLevel(int level);
//------------------------------------------------------------------
/// Output a SLEB128 number to the stream.
///
/// Put an SLEB128 \a uval out to the stream using the printf format
/// in \a format.
///
/// @param[in] uval
/// A uint64_t value that was extracted as a SLEB128 value.
///
/// @param[in] format
/// The optional printf format that can be overridden.
//------------------------------------------------------------------
size_t PutSLEB128(int64_t uval);
//------------------------------------------------------------------
/// Output a ULEB128 number to the stream.
///
/// Put an ULEB128 \a uval out to the stream using the printf format
/// in \a format.
///
/// @param[in] uval
/// A uint64_t value that was extracted as a ULEB128 value.
///
/// @param[in] format
/// The optional printf format that can be overridden.
//------------------------------------------------------------------
size_t PutULEB128(uint64_t uval);
static void UnitTest(Stream *s);
protected:
//------------------------------------------------------------------
// Member variables
//------------------------------------------------------------------
Flags m_flags; ///< Dump flags.
uint32_t m_addr_size; ///< Size of an address in bytes.
lldb::ByteOrder
m_byte_order; ///< Byte order to use when encoding scalar types.
int m_indent_level; ///< Indention level.
size_t _PutHex8(uint8_t uvalue, bool add_prefix);
};
} // namespace lldb_private
#endif // liblldb_Stream_h_

lldb/include/lldb/Core/StreamAsynchronousIO.h

Context not available.
#include <string> #include <string>
#include "lldb/Core/Stream.h" #include "lldb/Utility/Stream.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/include/lldb/Core/StreamBuffer.h

Context not available.
#ifndef liblldb_StreamBuffer_h_ #ifndef liblldb_StreamBuffer_h_
#define liblldb_StreamBuffer_h_ #define liblldb_StreamBuffer_h_
#include "lldb/Core/Stream.h" #include "lldb/Utility/Stream.h"
#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/SmallVector.h"
#include <stdio.h> #include <stdio.h>
#include <string> #include <string>
Context not available.

lldb/include/lldb/Core/StreamCallback.h

Context not available.
#include <mutex> #include <mutex>
#include <string> #include <string>
#include "lldb/Core/Stream.h" #include "lldb/Utility/Stream.h"
#include "lldb/Core/StreamString.h" #include "lldb/Utility/StreamString.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/include/lldb/Core/StreamFile.h

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/Stream.h"
#include "lldb/Host/File.h" #include "lldb/Host/File.h"
#include "lldb/Utility/Stream.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/include/lldb/Core/StreamGDBRemote.h

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/StreamString.h" #include "lldb/Utility/StreamString.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/include/lldb/Core/StreamString.h

  • This file was deleted.
//===-- StreamString.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_StreamString_h_
#define liblldb_StreamString_h_
#include <string>
#include "lldb/Core/Stream.h"
namespace lldb_private {
class StreamString : public Stream {
public:
StreamString();
StreamString(uint32_t flags, uint32_t addr_size, lldb::ByteOrder byte_order);
~StreamString() override;
void Flush() override;
size_t Write(const void *s, size_t length) override;
void Clear();
bool Empty() const;
size_t GetSize() const;
size_t GetSizeOfLastLine() const;
llvm::StringRef GetString() const;
const char *GetData() const { return m_packet.c_str(); }
void FillLastLineToColumn(uint32_t column, char fill_char);
protected:
std::string m_packet;
};
} // namespace lldb_private
#endif // liblldb_StreamString_h_

lldb/include/lldb/Core/StreamTee.h

  • This file was deleted.
//===-- StreamTee.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_StreamTee_h_
#define liblldb_StreamTee_h_
#include <limits.h>
#include <mutex>
#include "lldb/Core/Stream.h"
namespace lldb_private {
class StreamTee : public Stream {
public:
StreamTee() : Stream(), m_streams_mutex(), m_streams() {}
StreamTee(lldb::StreamSP &stream_sp)
: Stream(), m_streams_mutex(), m_streams() {
// No need to lock mutex during construction
if (stream_sp)
m_streams.push_back(stream_sp);
}
StreamTee(lldb::StreamSP &stream_sp, lldb::StreamSP &stream_2_sp)
: Stream(), m_streams_mutex(), m_streams() {
// No need to lock mutex during construction
if (stream_sp)
m_streams.push_back(stream_sp);
if (stream_2_sp)
m_streams.push_back(stream_2_sp);
}
StreamTee(const StreamTee &rhs)
: Stream(rhs), m_streams_mutex(), m_streams() {
// Don't copy until we lock down "rhs"
std::lock_guard<std::recursive_mutex> guard(rhs.m_streams_mutex);
m_streams = rhs.m_streams;
}
~StreamTee() override {}
StreamTee &operator=(const StreamTee &rhs) {
if (this != &rhs) {
Stream::operator=(rhs);
std::lock_guard<std::recursive_mutex> lhs_locker(m_streams_mutex);
std::lock_guard<std::recursive_mutex> rhs_locker(rhs.m_streams_mutex);
m_streams = rhs.m_streams;
}
return *this;
}
void Flush() override {
std::lock_guard<std::recursive_mutex> guard(m_streams_mutex);
collection::iterator pos, end;
for (pos = m_streams.begin(), end = m_streams.end(); pos != end; ++pos) {
// Allow for our collection to contain NULL streams. This allows
// the StreamTee to be used with hard coded indexes for clients
// that might want N total streams with only a few that are set
// to valid values.
Stream *strm = pos->get();
if (strm)
strm->Flush();
}
}
size_t Write(const void *s, size_t length) override {
std::lock_guard<std::recursive_mutex> guard(m_streams_mutex);
if (m_streams.empty())
return 0;
size_t min_bytes_written = SIZE_MAX;
collection::iterator pos, end;
for (pos = m_streams.begin(), end = m_streams.end(); pos != end; ++pos) {
// Allow for our collection to contain NULL streams. This allows
// the StreamTee to be used with hard coded indexes for clients
// that might want N total streams with only a few that are set
// to valid values.
Stream *strm = pos->get();
if (strm) {
const size_t bytes_written = strm->Write(s, length);
if (min_bytes_written > bytes_written)
min_bytes_written = bytes_written;
}
}
if (min_bytes_written == SIZE_MAX)
return 0;
return min_bytes_written;
}
size_t AppendStream(const lldb::StreamSP &stream_sp) {
size_t new_idx = m_streams.size();
std::lock_guard<std::recursive_mutex> guard(m_streams_mutex);
m_streams.push_back(stream_sp);
return new_idx;
}
size_t GetNumStreams() const {
size_t result = 0;
{
std::lock_guard<std::recursive_mutex> guard(m_streams_mutex);
result = m_streams.size();
}
return result;
}
lldb::StreamSP GetStreamAtIndex(uint32_t idx) {
lldb::StreamSP stream_sp;
std::lock_guard<std::recursive_mutex> guard(m_streams_mutex);
if (idx < m_streams.size())
stream_sp = m_streams[idx];
return stream_sp;
}
void SetStreamAtIndex(uint32_t idx, const lldb::StreamSP &stream_sp) {
std::lock_guard<std::recursive_mutex> guard(m_streams_mutex);
// Resize our stream vector as necessary to fit as many streams
// as needed. This also allows this class to be used with hard
// coded indexes that can be used contain many streams, not all
// of which are valid.
if (idx >= m_streams.size())
m_streams.resize(idx + 1);
m_streams[idx] = stream_sp;
}
protected:
typedef std::vector<lldb::StreamSP> collection;
mutable std::recursive_mutex m_streams_mutex;
collection m_streams;
};
} // namespace lldb_private
#endif // liblldb_StreamTee_h_

lldb/include/lldb/Core/StructuredData.h

Context not available.
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
// Project includes // Project includes
#include "lldb/Core/ConstString.h" #include "lldb/Utility/ConstString.h"
#include "lldb/Core/Stream.h" #include "lldb/Utility/Stream.h"
#include "lldb/lldb-defines.h" #include "lldb/lldb-defines.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/include/lldb/Core/UniqueCStringMap.h

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/RegularExpression.h" #include "lldb/Utility/RegularExpression.h"
#include "llvm/ADT/StringRef.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/include/lldb/Core/UserSettingsController.h

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/StringList.h" #include "lldb/Core/StringList.h"
#include "lldb/Interpreter/OptionValue.h" #include "lldb/Interpreter/OptionValue.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Utility/StreamString.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/include/lldb/Core/Value.h

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Scalar.h" #include "lldb/Core/Scalar.h"
#include "lldb/Symbol/CompilerType.h" #include "lldb/Symbol/CompilerType.h"
#include "lldb/Utility/Error.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/include/lldb/Core/ValueObject.h

Context not available.
#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/SmallVector.h"
// Project includes // Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Core/DataExtractor.h" #include "lldb/Core/DataExtractor.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Flags.h" #include "lldb/Core/Flags.h"
#include "lldb/Core/UserID.h" #include "lldb/Core/UserID.h"
#include "lldb/Core/Value.h" #include "lldb/Core/Value.h"
Context not available.
#include "lldb/Target/ExecutionContextScope.h" #include "lldb/Target/ExecutionContextScope.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/StackID.h" #include "lldb/Target/StackID.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/SharedCluster.h" #include "lldb/Utility/SharedCluster.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
Context not available.

lldb/include/lldb/DataFormatters/DataVisualization.h

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/DataFormatters/FormatClasses.h" #include "lldb/DataFormatters/FormatClasses.h"
#include "lldb/DataFormatters/FormatManager.h" #include "lldb/DataFormatters/FormatManager.h"
#include "lldb/Utility/ConstString.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/include/lldb/DataFormatters/FormatCache.h

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/ConstString.h" #include "lldb/Utility/ConstString.h"
#include "lldb/lldb-public.h" #include "lldb/lldb-public.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/include/lldb/DataFormatters/FormattersContainer.h

Context not available.
// Project includes // Project includes
#include "lldb/lldb-public.h" #include "lldb/lldb-public.h"
#include "lldb/Core/RegularExpression.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/DataFormatters/FormatClasses.h" #include "lldb/DataFormatters/FormatClasses.h"
#include "lldb/DataFormatters/TypeFormat.h" #include "lldb/DataFormatters/TypeFormat.h"
Context not available.
#include "lldb/DataFormatters/TypeSynthetic.h" #include "lldb/DataFormatters/TypeSynthetic.h"
#include "lldb/DataFormatters/TypeValidator.h" #include "lldb/DataFormatters/TypeValidator.h"
#include "lldb/Symbol/CompilerType.h" #include "lldb/Symbol/CompilerType.h"
#include "lldb/Utility/RegularExpression.h"
#include "lldb/Utility/StringLexer.h" #include "lldb/Utility/StringLexer.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/include/lldb/DataFormatters/TypeSummary.h

Context not available.
#include "lldb/lldb-enumerations.h" #include "lldb/lldb-enumerations.h"
#include "lldb/lldb-public.h" #include "lldb/lldb-public.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/FormatEntity.h" #include "lldb/Core/FormatEntity.h"
#include "lldb/Core/StructuredData.h" #include "lldb/Core/StructuredData.h"
#include "lldb/Utility/Error.h"
namespace lldb_private { namespace lldb_private {
class TypeSummaryOptions { class TypeSummaryOptions {
Context not available.

lldb/include/lldb/DataFormatters/VectorIterator.h

Context not available.
#include "lldb/lldb-forward.h" #include "lldb/lldb-forward.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Target/ExecutionContext.h" #include "lldb/Target/ExecutionContext.h"
#include "lldb/Utility/ConstString.h"
namespace lldb_private { namespace lldb_private {
namespace formatters { namespace formatters {
Context not available.

lldb/include/lldb/Expression/DWARFExpression.h

Context not available.
#include "lldb/Core/Address.h" #include "lldb/Core/Address.h"
#include "lldb/Core/DataExtractor.h" #include "lldb/Core/DataExtractor.h"
#include "lldb/Core/Disassembler.h" #include "lldb/Core/Disassembler.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Scalar.h" #include "lldb/Core/Scalar.h"
#include "lldb/Utility/Error.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
#include <functional> #include <functional>
Context not available.

lldb/include/lldb/Expression/ExpressionParser.h

Context not available.
#ifndef liblldb_ExpressionParser_h_ #ifndef liblldb_ExpressionParser_h_
#define liblldb_ExpressionParser_h_ #define liblldb_ExpressionParser_h_
#include "lldb/Core/Error.h" #include "lldb/Utility/Error.h"
#include "lldb/lldb-public.h" #include "lldb/lldb-public.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/include/lldb/Expression/ExpressionVariable.h

Context not available.
#include "llvm/ADT/DenseMap.h" #include "llvm/ADT/DenseMap.h"
// Project includes // Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/lldb-public.h" #include "lldb/lldb-public.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/include/lldb/Expression/IRInterpreter.h

Context not available.
#ifndef liblldb_IRInterpreter_h_ #ifndef liblldb_IRInterpreter_h_
#define liblldb_IRInterpreter_h_ #define liblldb_IRInterpreter_h_
#include "lldb/Core/ConstString.h" #include "lldb/Utility/ConstString.h"
#include "lldb/Core/Stream.h" #include "lldb/Utility/Stream.h"
#include "lldb/lldb-public.h" #include "lldb/lldb-public.h"
#include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/ArrayRef.h"
#include "llvm/Pass.h" #include "llvm/Pass.h"
Context not available.

lldb/include/lldb/Expression/Materializer.h

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/Error.h"
#include "lldb/Expression/IRMemoryMap.h" #include "lldb/Expression/IRMemoryMap.h"
#include "lldb/Symbol/TaggedASTType.h" #include "lldb/Symbol/TaggedASTType.h"
#include "lldb/Target/StackFrame.h" #include "lldb/Target/StackFrame.h"
#include "lldb/Utility/Error.h"
#include "lldb/lldb-private-types.h" #include "lldb/lldb-private-types.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/include/lldb/Host/FileCache.h

Context not available.
#include "lldb/lldb-forward.h" #include "lldb/lldb-forward.h"
#include "lldb/lldb-types.h" #include "lldb/lldb-types.h"
#include "lldb/Core/Error.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
#include "lldb/Utility/Error.h"
namespace lldb_private { namespace lldb_private {
class FileCache { class FileCache {
Context not available.

lldb/include/lldb/Host/FileSpec.h

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Core/STLUtils.h" #include "lldb/Core/STLUtils.h"
#include "lldb/Host/PosixApi.h" #include "lldb/Host/PosixApi.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
#include "llvm/Support/FormatVariadic.h" #include "llvm/Support/FormatVariadic.h"
Context not available.

lldb/include/lldb/Host/FileSystem.h

Context not available.
#ifndef liblldb_Host_FileSystem_h #ifndef liblldb_Host_FileSystem_h
#define liblldb_Host_FileSystem_h #define liblldb_Host_FileSystem_h
#include "lldb/Core/Error.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
#include "lldb/Utility/Error.h"
#include "llvm/Support/Chrono.h" #include "llvm/Support/Chrono.h"
#include "lldb/lldb-types.h" #include "lldb/lldb-types.h"
Context not available.

lldb/include/lldb/Host/HostNativeProcessBase.h

Context not available.
#ifndef lldb_Host_HostNativeProcessBase_h_ #ifndef lldb_Host_HostNativeProcessBase_h_
#define lldb_Host_HostNativeProcessBase_h_ #define lldb_Host_HostNativeProcessBase_h_
#include "lldb/Core/Error.h"
#include "lldb/Host/HostProcess.h" #include "lldb/Host/HostProcess.h"
#include "lldb/Utility/Error.h"
#include "lldb/lldb-defines.h" #include "lldb/lldb-defines.h"
#include "lldb/lldb-types.h" #include "lldb/lldb-types.h"
Context not available.

lldb/include/lldb/Host/HostNativeThreadBase.h

Context not available.
#ifndef lldb_Host_HostNativeThreadBase_h_ #ifndef lldb_Host_HostNativeThreadBase_h_
#define lldb_Host_HostNativeThreadBase_h_ #define lldb_Host_HostNativeThreadBase_h_
#include "lldb/Core/Error.h" #include "lldb/Utility/Error.h"
#include "lldb/lldb-defines.h" #include "lldb/lldb-defines.h"
#include "lldb/lldb-types.h" #include "lldb/lldb-types.h"
Context not available.

lldb/include/lldb/Host/HostThread.h

Context not available.
#ifndef lldb_Host_HostThread_h_ #ifndef lldb_Host_HostThread_h_
#define lldb_Host_HostThread_h_ #define lldb_Host_HostThread_h_
#include "lldb/Core/Error.h"
#include "lldb/Host/HostNativeThreadForward.h" #include "lldb/Host/HostNativeThreadForward.h"
#include "lldb/Utility/Error.h"
#include "lldb/lldb-types.h" #include "lldb/lldb-types.h"
#include <memory> #include <memory>
Context not available.

lldb/include/lldb/Host/LockFileBase.h

Context not available.
#ifndef liblldb_Host_LockFileBase_h_ #ifndef liblldb_Host_LockFileBase_h_
#define liblldb_Host_LockFileBase_h_ #define liblldb_Host_LockFileBase_h_
#include "lldb/Core/Error.h" #include "lldb/Utility/Error.h"
#include <functional> #include <functional>
Context not available.

lldb/include/lldb/Host/MainLoopBase.h

Context not available.
#include "llvm/Support/ErrorHandling.h" #include "llvm/Support/ErrorHandling.h"
#include "lldb/Core/Error.h"
#include "lldb/Host/IOObject.h" #include "lldb/Host/IOObject.h"
#include "lldb/Utility/Error.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/include/lldb/Host/PipeBase.h

Context not available.
#include <chrono> #include <chrono>
#include <string> #include <string>
#include "lldb/Core/Error.h" #include "lldb/Utility/Error.h"
#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
Context not available.

lldb/include/lldb/Host/Socket.h

Context not available.
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
#include "lldb/Core/Error.h"
#include "lldb/Host/IOObject.h" #include "lldb/Host/IOObject.h"
#include "lldb/Host/Predicate.h" #include "lldb/Host/Predicate.h"
#include "lldb/Host/SocketAddress.h" #include "lldb/Host/SocketAddress.h"
#include "lldb/Utility/Error.h"
#ifdef _WIN32 #ifdef _WIN32
#include "lldb/Host/windows/windows.h" #include "lldb/Host/windows/windows.h"
Context not available.

lldb/include/lldb/Host/ThreadLauncher.h

Context not available.
#ifndef lldb_Host_ThreadLauncher_h_ #ifndef lldb_Host_ThreadLauncher_h_
#define lldb_Host_ThreadLauncher_h_ #define lldb_Host_ThreadLauncher_h_
#include "lldb/Core/Error.h"
#include "lldb/Host/HostThread.h" #include "lldb/Host/HostThread.h"
#include "lldb/Utility/Error.h"
#include "lldb/lldb-types.h" #include "lldb/lldb-types.h"
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
Context not available.

lldb/include/lldb/Host/XML.h

Context not available.
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
// Project includes // Project includes
#include "lldb/Core/StreamString.h"
#include "lldb/Core/StructuredData.h" #include "lldb/Core/StructuredData.h"
#include "lldb/Utility/StreamString.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/include/lldb/Host/common/NativeBreakpointList.h

Context not available.
#ifndef liblldb_NativeBreakpointList_h_ #ifndef liblldb_NativeBreakpointList_h_
#define liblldb_NativeBreakpointList_h_ #define liblldb_NativeBreakpointList_h_
#include "lldb/Core/Error.h" #include "lldb/Utility/Error.h"
#include "lldb/lldb-private-forward.h" #include "lldb/lldb-private-forward.h"
// #include "lldb/Host/NativeBreakpoint.h" // #include "lldb/Host/NativeBreakpoint.h"
Context not available.

lldb/include/lldb/Host/common/NativeProcessProtocol.h

Context not available.
#include <mutex> #include <mutex>
#include <vector> #include <vector>
#include "lldb/Core/Error.h"
#include "lldb/Host/MainLoop.h" #include "lldb/Host/MainLoop.h"
#include "lldb/Utility/Error.h"
#include "lldb/lldb-private-forward.h" #include "lldb/lldb-private-forward.h"
#include "lldb/lldb-types.h" #include "lldb/lldb-types.h"
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
Context not available.

lldb/include/lldb/Host/common/NativeWatchpointList.h

Context not available.
#ifndef liblldb_NativeWatchpointList_h_ #ifndef liblldb_NativeWatchpointList_h_
#define liblldb_NativeWatchpointList_h_ #define liblldb_NativeWatchpointList_h_
#include "lldb/Core/Error.h" #include "lldb/Utility/Error.h"
#include "lldb/lldb-private-forward.h" #include "lldb/lldb-private-forward.h"
#include <map> #include <map>
Context not available.

lldb/include/lldb/Host/posix/HostProcessPosix.h

Context not available.
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/Error.h"
#include "lldb/Host/HostNativeProcessBase.h" #include "lldb/Host/HostNativeProcessBase.h"
#include "lldb/Utility/Error.h"
#include "lldb/lldb-types.h" #include "lldb/lldb-types.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/include/lldb/Interpreter/Args.h

Context not available.
#include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
// Project includes // Project includes
#include "lldb/Core/Error.h"
#include "lldb/Host/OptionParser.h" #include "lldb/Host/OptionParser.h"
#include "lldb/Utility/Error.h"
#include "lldb/lldb-private-types.h" #include "lldb/lldb-private-types.h"
#include "lldb/lldb-types.h" #include "lldb/lldb-types.h"
Context not available.

lldb/include/lldb/Interpreter/CommandCompletions.h

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/FileSpecList.h" #include "lldb/Core/FileSpecList.h"
#include "lldb/Core/RegularExpression.h"
#include "lldb/Core/SearchFilter.h" #include "lldb/Core/SearchFilter.h"
#include "lldb/Utility/RegularExpression.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/include/lldb/Interpreter/CommandHistory.h

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/Stream.h" #include "lldb/Utility/Stream.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/include/lldb/Interpreter/CommandObjectRegexCommand.h

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/RegularExpression.h"
#include "lldb/Interpreter/CommandObject.h" #include "lldb/Interpreter/CommandObject.h"
#include "lldb/Utility/RegularExpression.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/include/lldb/Interpreter/CommandReturnObject.h

Context not available.
// Project includes // Project includes
#include "lldb/Core/STLUtils.h" #include "lldb/Core/STLUtils.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Core/StreamString.h" #include "lldb/Utility/StreamString.h"
#include "lldb/Core/StreamTee.h" #include "lldb/Utility/StreamTee.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
Context not available.

lldb/include/lldb/Interpreter/OptionGroupPlatform.h

Context not available.
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Interpreter/Options.h" #include "lldb/Interpreter/Options.h"
#include "lldb/Utility/ConstString.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/include/lldb/Interpreter/OptionValue.h

Context not available.
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/FormatEntity.h" #include "lldb/Core/FormatEntity.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Error.h"
#include "lldb/lldb-defines.h" #include "lldb/lldb-defines.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/include/lldb/Interpreter/OptionValueEnumeration.h

Context not available.
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/UniqueCStringMap.h" #include "lldb/Core/UniqueCStringMap.h"
#include "lldb/Interpreter/OptionValue.h" #include "lldb/Interpreter/OptionValue.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Utility/StreamString.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/include/lldb/Interpreter/OptionValueProperties.h

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Core/FormatEntity.h" #include "lldb/Core/FormatEntity.h"
#include "lldb/Core/UniqueCStringMap.h" #include "lldb/Core/UniqueCStringMap.h"
#include "lldb/Interpreter/OptionValue.h" #include "lldb/Interpreter/OptionValue.h"
#include "lldb/Interpreter/Property.h" #include "lldb/Interpreter/Property.h"
#include "lldb/Utility/ConstString.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/include/lldb/Interpreter/OptionValueRegex.h

Context not available.
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/RegularExpression.h"
#include "lldb/Interpreter/OptionValue.h" #include "lldb/Interpreter/OptionValue.h"
#include "lldb/Utility/RegularExpression.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/include/lldb/Interpreter/Property.h

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Flags.h" #include "lldb/Core/Flags.h"
#include "lldb/Interpreter/OptionValue.h" #include "lldb/Interpreter/OptionValue.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/lldb-defines.h" #include "lldb/lldb-defines.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/include/lldb/Interpreter/ScriptInterpreter.h

Context not available.
#include "lldb/Breakpoint/BreakpointOptions.h" #include "lldb/Breakpoint/BreakpointOptions.h"
#include "lldb/Core/Broadcaster.h" #include "lldb/Core/Broadcaster.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/PluginInterface.h" #include "lldb/Core/PluginInterface.h"
#include "lldb/Core/StructuredData.h" #include "lldb/Core/StructuredData.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/PseudoTerminal.h" #include "lldb/Utility/PseudoTerminal.h"
Context not available.

lldb/include/lldb/Symbol/Block.h

Context not available.
// Project includes // Project includes
#include "lldb/Core/AddressRange.h" #include "lldb/Core/AddressRange.h"
#include "lldb/Core/RangeMap.h" #include "lldb/Core/RangeMap.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/UserID.h" #include "lldb/Core/UserID.h"
#include "lldb/Symbol/CompilerType.h" #include "lldb/Symbol/CompilerType.h"
#include "lldb/Symbol/LineEntry.h" #include "lldb/Symbol/LineEntry.h"
#include "lldb/Symbol/SymbolContext.h" #include "lldb/Symbol/SymbolContext.h"
#include "lldb/Utility/Stream.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/include/lldb/Symbol/ClangASTContext.h

Context not available.
// Project includes // Project includes
#include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h" #include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h"
#include "lldb/Core/ClangForward.h" #include "lldb/Core/ClangForward.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Symbol/CompilerType.h" #include "lldb/Symbol/CompilerType.h"
#include "lldb/Symbol/TypeSystem.h" #include "lldb/Symbol/TypeSystem.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/lldb-enumerations.h" #include "lldb/lldb-enumerations.h"
class DWARFASTParserClang; class DWARFASTParserClang;
Context not available.

lldb/include/lldb/Symbol/CompileUnit.h

Context not available.
#include "lldb/Core/FileSpecList.h" #include "lldb/Core/FileSpecList.h"
#include "lldb/Core/ModuleChild.h" #include "lldb/Core/ModuleChild.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/UserID.h" #include "lldb/Core/UserID.h"
#include "lldb/Symbol/DebugMacros.h" #include "lldb/Symbol/DebugMacros.h"
#include "lldb/Symbol/Function.h" #include "lldb/Symbol/Function.h"
#include "lldb/Utility/Stream.h"
#include "lldb/lldb-enumerations.h" #include "lldb/lldb-enumerations.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/include/lldb/Symbol/CompilerDecl.h

Context not available.
#ifndef liblldb_CompilerDecl_h_ #ifndef liblldb_CompilerDecl_h_
#define liblldb_CompilerDecl_h_ #define liblldb_CompilerDecl_h_
#include "lldb/Core/ConstString.h"
#include "lldb/Symbol/CompilerType.h" #include "lldb/Symbol/CompilerType.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/include/lldb/Symbol/CompilerDeclContext.h

Context not available.
#include <vector> #include <vector>
#include "lldb/Core/ConstString.h" #include "lldb/Utility/ConstString.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/include/lldb/Symbol/DebugMacros.h

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/ConstString.h" #include "lldb/Utility/ConstString.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/include/lldb/Symbol/GoASTContext.h

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Symbol/CompilerType.h" #include "lldb/Symbol/CompilerType.h"
#include "lldb/Symbol/TypeSystem.h" #include "lldb/Symbol/TypeSystem.h"
#include "lldb/Utility/ConstString.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/include/lldb/Symbol/JavaASTContext.h

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Symbol/TypeSystem.h" #include "lldb/Symbol/TypeSystem.h"
#include "lldb/Utility/ConstString.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/include/lldb/Symbol/OCamlASTContext.h

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Symbol/CompilerType.h" #include "lldb/Symbol/CompilerType.h"
#include "lldb/Symbol/TypeSystem.h" #include "lldb/Symbol/TypeSystem.h"
#include "lldb/Utility/ConstString.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/include/lldb/Symbol/Type.h

Context not available.
#define liblldb_Type_h_ #define liblldb_Type_h_
#include "lldb/Core/ClangForward.h" #include "lldb/Core/ClangForward.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/UserID.h" #include "lldb/Core/UserID.h"
#include "lldb/Symbol/CompilerDecl.h" #include "lldb/Symbol/CompilerDecl.h"
#include "lldb/Symbol/CompilerType.h" #include "lldb/Symbol/CompilerType.h"
#include "lldb/Symbol/Declaration.h" #include "lldb/Symbol/Declaration.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
#include "llvm/ADT/APSInt.h" #include "llvm/ADT/APSInt.h"
Context not available.

lldb/include/lldb/Symbol/UnwindPlan.h

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/AddressRange.h" #include "lldb/Core/AddressRange.h"
#include "lldb/Core/ConstString.h" #include "lldb/Utility/ConstString.h"
#include "lldb/Core/Stream.h" #include "lldb/Utility/Stream.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/include/lldb/Target/ABI.h

Context not available.
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/Error.h"
#include "lldb/Core/PluginInterface.h" #include "lldb/Core/PluginInterface.h"
#include "lldb/Symbol/UnwindPlan.h" #include "lldb/Symbol/UnwindPlan.h"
#include "lldb/Utility/Error.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
#include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/ArrayRef.h"
Context not available.

lldb/include/lldb/Target/DynamicLoader.h

Context not available.
#define liblldb_DynamicLoader_h_ #define liblldb_DynamicLoader_h_
// Project includes // Project includes
#include "lldb/Core/Error.h"
#include "lldb/Core/PluginInterface.h" #include "lldb/Core/PluginInterface.h"
#include "lldb/Core/UUID.h" #include "lldb/Core/UUID.h"
#include "lldb/Utility/Error.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/include/lldb/Target/MemoryRegionInfo.h

Context not available.
#ifndef lldb_MemoryRegionInfo_h #ifndef lldb_MemoryRegionInfo_h
#define lldb_MemoryRegionInfo_h #define lldb_MemoryRegionInfo_h
#include "lldb/Core/ConstString.h"
#include "lldb/Core/RangeMap.h" #include "lldb/Core/RangeMap.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Range.h" #include "lldb/Utility/Range.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/include/lldb/Target/PathMappingList.h

Context not available.
#include <map> #include <map>
#include <vector> #include <vector>
// Other libraries and framework includes // Other libraries and framework includes
#include "lldb/Core/ConstString.h" #include "lldb/Utility/ConstString.h"
#include "lldb/Core/Error.h" #include "lldb/Utility/Error.h"
// Project includes // Project includes
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/include/lldb/Target/Platform.h

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/ArchSpec.h" #include "lldb/Core/ArchSpec.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/PluginInterface.h" #include "lldb/Core/PluginInterface.h"
#include "lldb/Core/UserSettingsController.h" #include "lldb/Core/UserSettingsController.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
#include "lldb/Interpreter/Options.h" #include "lldb/Interpreter/Options.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/lldb-private-forward.h" #include "lldb/lldb-private-forward.h"
#include "lldb/lldb-public.h" #include "lldb/lldb-public.h"
Context not available.

lldb/include/lldb/Target/Process.h

Context not available.
#include "lldb/Core/ArchSpec.h" #include "lldb/Core/ArchSpec.h"
#include "lldb/Core/Broadcaster.h" #include "lldb/Core/Broadcaster.h"
#include "lldb/Core/Communication.h" #include "lldb/Core/Communication.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Event.h" #include "lldb/Core/Event.h"
#include "lldb/Core/Listener.h" #include "lldb/Core/Listener.h"
#include "lldb/Core/LoadedModuleInfoList.h" #include "lldb/Core/LoadedModuleInfoList.h"
Context not available.
#include "lldb/Target/ProcessLaunchInfo.h" #include "lldb/Target/ProcessLaunchInfo.h"
#include "lldb/Target/QueueList.h" #include "lldb/Target/QueueList.h"
#include "lldb/Target/ThreadList.h" #include "lldb/Target/ThreadList.h"
#include "lldb/Utility/Error.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
#include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/ArrayRef.h"
Context not available.

lldb/include/lldb/Target/QueueItem.h

Context not available.
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
#include "lldb/Core/Address.h" #include "lldb/Core/Address.h"
#include "lldb/Core/ConstString.h" #include "lldb/Utility/ConstString.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/include/lldb/Target/StackFrame.h

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/Error.h"
#include "lldb/Core/Flags.h" #include "lldb/Core/Flags.h"
#include "lldb/Core/Scalar.h" #include "lldb/Core/Scalar.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/UserID.h" #include "lldb/Core/UserID.h"
#include "lldb/Core/ValueObjectList.h" #include "lldb/Core/ValueObjectList.h"
#include "lldb/Symbol/SymbolContext.h" #include "lldb/Symbol/SymbolContext.h"
#include "lldb/Target/ExecutionContextScope.h" #include "lldb/Target/ExecutionContextScope.h"
#include "lldb/Target/StackID.h" #include "lldb/Target/StackID.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/StreamString.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/include/lldb/Target/SystemRuntime.h

Context not available.
// Project includes // Project includes
#include <vector> #include <vector>
#include "lldb/Core/ConstString.h"
#include "lldb/Core/ModuleList.h" #include "lldb/Core/ModuleList.h"
#include "lldb/Core/PluginInterface.h" #include "lldb/Core/PluginInterface.h"
#include "lldb/Core/StructuredData.h" #include "lldb/Core/StructuredData.h"
#include "lldb/Target/QueueItem.h" #include "lldb/Target/QueueItem.h"
#include "lldb/Target/QueueList.h" #include "lldb/Target/QueueList.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
#include "lldb/lldb-public.h" #include "lldb/lldb-public.h"
Context not available.

lldb/include/lldb/Target/UnixSignals.h

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/ConstString.h" #include "lldb/Utility/ConstString.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/include/lldb/Utility/ConstString.h

  • This file was added.
//===-- ConstString.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_ConstString_h_
#define liblldb_ConstString_h_
// C Includes
// C++ Includes
// Other libraries and framework includes
#include "llvm/ADT/StringRef.h"
// Project includes
#include "lldb/lldb-private.h"
namespace lldb_private {
//----------------------------------------------------------------------
/// @class ConstString ConstString.h "lldb/Utility/ConstString.h"
/// @brief A uniqued constant string class.
///
/// Provides an efficient way to store strings as uniqued strings. After
/// the strings are uniqued, finding strings that are equal to one
/// another is very fast as just the pointers need to be compared. It
/// also allows for many common strings from many different sources to
/// be shared to keep the memory footprint low.
///
/// No reference counting is done on strings that are added to the
/// string pool, once strings are added they are in the string pool for
/// the life of the program.
//----------------------------------------------------------------------
class ConstString {
public:
//------------------------------------------------------------------
/// Default constructor
///
/// Initializes the string to an empty string.
//------------------------------------------------------------------
ConstString() : m_string(nullptr) {}
//------------------------------------------------------------------
/// Copy constructor
///
/// Copies the string value in \a rhs into this object.
///
/// @param[in] rhs
/// Another string object to copy.
//------------------------------------------------------------------
ConstString(const ConstString &rhs) : m_string(rhs.m_string) {}
explicit ConstString(const llvm::StringRef &s);
//------------------------------------------------------------------
/// Construct with C String value
///
/// Constructs this object with a C string by looking to see if the
/// C string already exists in the global string pool. If it doesn't
/// exist, it is added to the string pool.
///
/// @param[in] cstr
/// A NULL terminated C string to add to the string pool.
//------------------------------------------------------------------
explicit ConstString(const char *cstr);
//------------------------------------------------------------------
/// Construct with C String value with max length
///
/// Constructs this object with a C string with a length. If
/// \a max_cstr_len is greater than the actual length of the string,
/// the string length will be truncated. This allows substrings to
/// be created without the need to NULL terminate the string as it
/// is passed into this function.
///
/// @param[in] cstr
/// A pointer to the first character in the C string. The C
/// string can be NULL terminated in a buffer that contains
/// more characters than the length of the string, or the
/// string can be part of another string and a new substring
/// can be created.
///
/// @param[in] max_cstr_len
/// The max length of \a cstr. If the string length of \a cstr
/// is less than \a max_cstr_len, then the string will be
/// truncated. If the string length of \a cstr is greater than
/// \a max_cstr_len, then only max_cstr_len bytes will be used
/// from \a cstr.
//------------------------------------------------------------------
explicit ConstString(const char *cstr, size_t max_cstr_len);
//------------------------------------------------------------------
/// Destructor
///
/// Since constant string values are currently not reference counted,
/// there isn't much to do here.
//------------------------------------------------------------------
~ConstString() = default;
//----------------------------------------------------------------------
/// C string equality binary predicate function object for ConstString
/// objects.
//----------------------------------------------------------------------
struct StringIsEqual {
//--------------------------------------------------------------
/// C equality test.
///
/// Two C strings are equal when they are contained in ConstString
/// objects when their pointer values are equal to each other.
///
/// @return
/// Returns \b true if the C string in \a lhs is equal to
/// the C string value in \a rhs, \b false otherwise.
//--------------------------------------------------------------
bool operator()(const char *lhs, const char *rhs) const {
return lhs == rhs;
}
};
//------------------------------------------------------------------
/// Convert to bool operator.
///
/// This allows code to check a ConstString object to see if it
/// contains a valid string using code such as:
///
/// @code
/// ConstString str(...);
/// if (str)
/// { ...
/// @endcode
///
/// @return
/// /b True this object contains a valid non-empty C string, \b
/// false otherwise.
//------------------------------------------------------------------
explicit operator bool() const { return m_string && m_string[0]; }
//------------------------------------------------------------------
/// Assignment operator
///
/// Assigns the string in this object with the value from \a rhs.
///
/// @param[in] rhs
/// Another string object to copy into this object.
///
/// @return
/// A const reference to this object.
//------------------------------------------------------------------
const ConstString &operator=(const ConstString &rhs) {
m_string = rhs.m_string;
return *this;
}
//------------------------------------------------------------------
/// Equal to operator
///
/// Returns true if this string is equal to the string in \a rhs.
/// This operation is very fast as it results in a pointer
/// comparison since all strings are in a uniqued in a global string
/// pool.
///
/// @param[in] rhs
/// Another string object to compare this object to.
///
/// @return
/// @li \b true if this object is equal to \a rhs.
/// @li \b false if this object is not equal to \a rhs.
//------------------------------------------------------------------
bool operator==(const ConstString &rhs) const {
// We can do a pointer compare to compare these strings since they
// must come from the same pool in order to be equal.
return m_string == rhs.m_string;
}
//------------------------------------------------------------------
/// Not equal to operator
///
/// Returns true if this string is not equal to the string in \a rhs.
/// This operation is very fast as it results in a pointer
/// comparison since all strings are in a uniqued in a global string
/// pool.
///
/// @param[in] rhs
/// Another string object to compare this object to.
///
/// @return
/// @li \b true if this object is not equal to \a rhs.
/// @li \b false if this object is equal to \a rhs.
//------------------------------------------------------------------
bool operator!=(const ConstString &rhs) const {
return m_string != rhs.m_string;
}
bool operator<(const ConstString &rhs) const;
//------------------------------------------------------------------
/// Get the string value as a C string.
///
/// Get the value of the contained string as a NULL terminated C
/// string value.
///
/// If \a value_if_empty is nullptr, then nullptr will be returned.
///
/// @return
/// Returns \a value_if_empty if the string is empty, otherwise
/// the C string value contained in this object.
//------------------------------------------------------------------
const char *AsCString(const char *value_if_empty = nullptr) const {
return (IsEmpty() ? value_if_empty : m_string);
}
//------------------------------------------------------------------
/// Get the string value as a llvm::StringRef
///
/// @return
/// Returns a new llvm::StringRef object filled in with the
/// needed data.
//------------------------------------------------------------------
llvm::StringRef GetStringRef() const {
return llvm::StringRef(m_string, GetLength());
}
//------------------------------------------------------------------
/// Get the string value as a C string.
///
/// Get the value of the contained string as a NULL terminated C
/// string value. Similar to the ConstString::AsCString() function,
/// yet this function will always return nullptr if the string is not
/// valid. So this function is a direct accessor to the string
/// pointer value.
///
/// @return
/// Returns nullptr the string is invalid, otherwise the C string
/// value contained in this object.
//------------------------------------------------------------------
const char *GetCString() const { return m_string; }
//------------------------------------------------------------------
/// Get the length in bytes of string value.
///
/// The string pool stores the length of the string, so we can avoid
/// calling strlen() on the pointer value with this function.
///
/// @return
/// Returns the number of bytes that this string occupies in
/// memory, not including the NULL termination byte.
//------------------------------------------------------------------
size_t GetLength() const;
//------------------------------------------------------------------
/// Clear this object's state.
///
/// Clear any contained string and reset the value to the an empty
/// string value.
//------------------------------------------------------------------
void Clear() { m_string = nullptr; }
//------------------------------------------------------------------
/// Equal to operator
///
/// Returns true if this string is equal to the string in \a rhs.
/// If case sensitive equality is tested, this operation is very
/// fast as it results in a pointer comparison since all strings
/// are in a uniqued in a global string pool.
///
/// @param[in] rhs
/// The Left Hand Side const ConstString object reference.
///
/// @param[in] rhs
/// The Right Hand Side const ConstString object reference.
///
/// @param[in] case_sensitive
/// Case sensitivity. If true, case sensitive equality
/// will be tested, otherwise character case will be ignored
///
/// @return
/// @li \b true if this object is equal to \a rhs.
/// @li \b false if this object is not equal to \a rhs.
//------------------------------------------------------------------
static bool Equals(const ConstString &lhs, const ConstString &rhs,
const bool case_sensitive = true);
//------------------------------------------------------------------
/// Compare two string objects.
///
/// Compares the C string values contained in \a lhs and \a rhs and
/// returns an integer result.
///
/// NOTE: only call this function when you want a true string
/// comparison. If you want string equality use the, use the ==
/// operator as it is much more efficient. Also if you want string
/// inequality, use the != operator for the same reasons.
///
/// @param[in] lhs
/// The Left Hand Side const ConstString object reference.
///
/// @param[in] rhs
/// The Right Hand Side const ConstString object reference.
///
/// @param[in] case_sensitive
/// Case sensitivity of compare. If true, case sensitive compare
/// will be performed, otherwise character case will be ignored
///
/// @return
/// @li -1 if lhs < rhs
/// @li 0 if lhs == rhs
/// @li 1 if lhs > rhs
//------------------------------------------------------------------
static int Compare(const ConstString &lhs, const ConstString &rhs,
const bool case_sensitive = true);
//------------------------------------------------------------------
/// Dump the object description to a stream.
///
/// Dump the string value to the stream \a s. If the contained string
/// is empty, print \a value_if_empty to the stream instead. If
/// \a value_if_empty is nullptr, then nothing will be dumped to the
/// stream.
///
/// @param[in] s
/// The stream that will be used to dump the object description.
///
/// @param[in] value_if_empty
/// The value to dump if the string is empty. If nullptr, nothing
/// will be output to the stream.
//------------------------------------------------------------------
void Dump(Stream *s, const char *value_if_empty = nullptr) const;
//------------------------------------------------------------------
/// Dump the object debug description to a stream.
///
/// @param[in] s
/// The stream that will be used to dump the object description.
//------------------------------------------------------------------
void DumpDebug(Stream *s) const;
//------------------------------------------------------------------
/// Test for empty string.
///
/// @return
/// @li \b true if the contained string is empty.
/// @li \b false if the contained string is not empty.
//------------------------------------------------------------------
bool IsEmpty() const { return m_string == nullptr || m_string[0] == '\0'; }
//------------------------------------------------------------------
/// Set the C string value.
///
/// Set the string value in the object by uniquing the \a cstr
/// string value in our global string pool.
///
/// If the C string already exists in the global string pool, it
/// finds the current entry and returns the existing value. If it
/// doesn't exist, it is added to the string pool.
///
/// @param[in] cstr
/// A NULL terminated C string to add to the string pool.
//------------------------------------------------------------------
void SetCString(const char *cstr);
void SetString(const llvm::StringRef &s);
//------------------------------------------------------------------
/// Set the C string value and its mangled counterpart.
///
/// Object files and debug symbols often use mangled string to
/// represent the linkage name for a symbol, function or global.
/// The string pool can efficiently store these values and their
/// counterparts so when we run into another instance of a mangled
/// name, we can avoid calling the name demangler over and over on
/// the same strings and then trying to unique them.
///
/// @param[in] demangled
/// The demangled C string to correlate with the \a mangled
/// name.
///
/// @param[in] mangled
/// The already uniqued mangled ConstString to correlate the
/// soon to be uniqued version of \a demangled.
//------------------------------------------------------------------
void SetCStringWithMangledCounterpart(const char *demangled,
const ConstString &mangled);
//------------------------------------------------------------------
/// Retrieve the mangled or demangled counterpart for a mangled
/// or demangled ConstString.
///
/// Object files and debug symbols often use mangled string to
/// represent the linkage name for a symbol, function or global.
/// The string pool can efficiently store these values and their
/// counterparts so when we run into another instance of a mangled
/// name, we can avoid calling the name demangler over and over on
/// the same strings and then trying to unique them.
///
/// @param[in] counterpart
/// A reference to a ConstString object that might get filled in
/// with the demangled/mangled counterpart.
///
/// @return
/// /b True if \a counterpart was filled in with the counterpart
/// /b false otherwise.
//------------------------------------------------------------------
bool GetMangledCounterpart(ConstString &counterpart) const;
//------------------------------------------------------------------
/// Set the C string value with length.
///
/// Set the string value in the object by uniquing \a cstr_len bytes
/// starting at the \a cstr string value in our global string pool.
/// If trim is true, then \a cstr_len indicates a maximum length of
/// the CString and if the actual length of the string is less, then
/// it will be trimmed.
///
/// If the C string already exists in the global string pool, it
/// finds the current entry and returns the existing value. If it
/// doesn't exist, it is added to the string pool.
///
/// @param[in] cstr
/// A NULL terminated C string to add to the string pool.
///
/// @param[in] cstr_len
/// The maximum length of the C string.
//------------------------------------------------------------------
void SetCStringWithLength(const char *cstr, size_t cstr_len);
//------------------------------------------------------------------
/// Set the C string value with the minimum length between
/// \a fixed_cstr_len and the actual length of the C string. This
/// can be used for data structures that have a fixed length to
/// store a C string where the string might not be NULL terminated
/// if the string takes the entire buffer.
//------------------------------------------------------------------
void SetTrimmedCStringWithLength(const char *cstr, size_t fixed_cstr_len);
//------------------------------------------------------------------
/// Get the memory cost of this object.
///
/// Return the size in bytes that this object takes in memory. This
/// returns the size in bytes of this object, which does not include
/// any the shared string values it may refer to.
///
/// @return
/// The number of bytes that this object occupies in memory.
///
/// @see ConstString::StaticMemorySize ()
//------------------------------------------------------------------
size_t MemorySize() const { return sizeof(ConstString); }
//------------------------------------------------------------------
/// Get the size in bytes of the current global string pool.
///
/// Reports the size in bytes of all shared C string values,
/// containers and any other values as a byte size for the
/// entire string pool.
///
/// @return
/// The number of bytes that the global string pool occupies
/// in memory.
//------------------------------------------------------------------
static size_t StaticMemorySize();
protected:
//------------------------------------------------------------------
// Member variables
//------------------------------------------------------------------
const char *m_string;
};
//------------------------------------------------------------------
/// Stream the string value \a str to the stream \a s
//------------------------------------------------------------------
Stream &operator<<(Stream &s, const ConstString &str);
} // namespace lldb_private
#endif // liblldb_ConstString_h_

lldb/include/lldb/Utility/Error.h

  • This file was added.
//===-- Error.h -------------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef __DCError_h__
#define __DCError_h__
#if defined(__cplusplus)
#include "llvm/Support/DataTypes.h"
#include "llvm/Support/FormatVariadic.h"
#include <cstdarg>
#include <cstdio>
#include <string>
#include "lldb/lldb-private.h"
#include "llvm/Support/FormatVariadic.h"
namespace lldb_private {
class Log;
//----------------------------------------------------------------------
/// @class Error Error.h "lldb/Utility/Error.h"
/// @brief An error handling class.
///
/// This class is designed to be able to hold any error code that can be
/// encountered on a given platform. The errors are stored as a value
/// of type Error::ValueType. This value should be large enough to hold
/// any and all errors that the class supports. Each error has an
/// associated type that is of type lldb::ErrorType. New types
/// can be added to support new error types, and architecture specific
/// types can be enabled. In the future we may wish to switch to a
/// registration mechanism where new error types can be registered at
/// runtime instead of a hard coded scheme.
///
/// All errors in this class also know how to generate a string
/// representation of themselves for printing results and error codes.
/// The string value will be fetched on demand and its string value will
/// be cached until the error is cleared of the value of the error
/// changes.
//----------------------------------------------------------------------
class Error {
public:
//------------------------------------------------------------------
/// Every error value that this object can contain needs to be able
/// to fit into ValueType.
//------------------------------------------------------------------
typedef uint32_t ValueType;
//------------------------------------------------------------------
/// Default constructor.
///
/// Initialize the error object with a generic success value.
///
/// @param[in] err
/// An error code.
///
/// @param[in] type
/// The type for \a err.
//------------------------------------------------------------------
Error();
explicit Error(ValueType err, lldb::ErrorType type = lldb::eErrorTypeGeneric);
explicit Error(const char *format, ...) __attribute__((format(printf, 2, 3)));
Error(const Error &rhs);
//------------------------------------------------------------------
/// Assignment operator.
///
/// @param[in] err
/// An error code.
///
/// @return
/// A const reference to this object.
//------------------------------------------------------------------
const Error &operator=(const Error &rhs);
//------------------------------------------------------------------
/// Assignment operator from a kern_return_t.
///
/// Sets the type to \c MachKernel and the error code to \a err.
///
/// @param[in] err
/// A mach error code.
///
/// @return
/// A const reference to this object.
//------------------------------------------------------------------
const Error &operator=(uint32_t err);
~Error();
//------------------------------------------------------------------
/// Get the error string associated with the current error.
//
/// Gets the error value as a NULL terminated C string. The error
/// string will be fetched and cached on demand. The error string
/// will be retrieved from a callback that is appropriate for the
/// type of the error and will be cached until the error value is
/// changed or cleared.
///
/// @return
/// The error as a NULL terminated C string value if the error
/// is valid and is able to be converted to a string value,
/// NULL otherwise.
//------------------------------------------------------------------
const char *AsCString(const char *default_error_str = "unknown error") const;
//------------------------------------------------------------------
/// Clear the object state.
///
/// Reverts the state of this object to contain a generic success
/// value and frees any cached error string value.
//------------------------------------------------------------------
void Clear();
//------------------------------------------------------------------
/// Test for error condition.
///
/// @return
/// \b true if this object contains an error, \b false
/// otherwise.
//------------------------------------------------------------------
bool Fail() const;
//------------------------------------------------------------------
/// Access the error value.
///
/// @return
/// The error value.
//------------------------------------------------------------------
ValueType GetError() const;
//------------------------------------------------------------------
/// Access the error type.
///
/// @return
/// The error type enumeration value.
//------------------------------------------------------------------
lldb::ErrorType GetType() const;
//------------------------------------------------------------------
/// Log an error to Log().
///
/// Log the error given a formatted string \a format. If the this
/// object contains an error code, update the error string to
/// contain the prefix "error: ", followed by the formatted string,
/// followed by the error value and any string that describes the
/// error value. This allows more context to be given to an error
/// string that remains cached in this object. Logging always occurs
/// even when the error code contains a non-error value.
///
/// @param[in] format
/// A printf style format string.
///
/// @param[in] ...
/// Variable arguments that are needed for the printf style
/// format string \a format.
//------------------------------------------------------------------
void PutToLog(Log *log, const char *format, ...)
__attribute__((format(printf, 3, 4)));
//------------------------------------------------------------------
/// Log an error to Log() if the error value is an error.
///
/// Log the error given a formatted string \a format only if the
/// error value in this object describes an error condition. If the
/// this object contains an error, update the error string to
/// contain the prefix "error: " followed by the formatted string,
/// followed by the error value and any string that describes the
/// error value. This allows more context to be given to an error
/// string that remains cached in this object.
///
/// @param[in] format
/// A printf style format string.
///
/// @param[in] ...
/// Variable arguments that are needed for the printf style
/// format string \a format.
//------------------------------------------------------------------
void LogIfError(Log *log, const char *format, ...)
__attribute__((format(printf, 3, 4)));
//------------------------------------------------------------------
/// Set accessor from a kern_return_t.
///
/// Set accesssor for the error value to \a err and the error type
/// to \c MachKernel.
///
/// @param[in] err
/// A mach error code.
//------------------------------------------------------------------
void SetMachError(uint32_t err);
void SetExpressionError(lldb::ExpressionResults, const char *mssg);
int SetExpressionErrorWithFormat(lldb::ExpressionResults, const char *format,
...) __attribute__((format(printf, 3, 4)));
//------------------------------------------------------------------
/// Set accesssor with an error value and type.
///
/// Set accesssor for the error value to \a err and the error type
/// to \a type.
///
/// @param[in] err
/// A mach error code.
///
/// @param[in] type
/// The type for \a err.
//------------------------------------------------------------------
void SetError(ValueType err, lldb::ErrorType type);
//------------------------------------------------------------------
/// Set the current error to errno.
///
/// Update the error value to be \c errno and update the type to
/// be \c Error::POSIX.
//------------------------------------------------------------------
void SetErrorToErrno();
//------------------------------------------------------------------
/// Set the current error to a generic error.
///
/// Update the error value to be \c LLDB_GENERIC_ERROR and update the
/// type to be \c Error::Generic.
//------------------------------------------------------------------
void SetErrorToGenericError();
//------------------------------------------------------------------
/// Set the current error string to \a err_str.
///
/// Set accessor for the error string value for a generic errors,
/// or to supply additional details above and beyond the standard
/// error strings that the standard type callbacks typically
/// provide. This allows custom strings to be supplied as an
/// error explanation. The error string value will remain until the
/// error value is cleared or a new error value/type is assigned.
///
/// @param err_str
/// The new custom error string to copy and cache.
//------------------------------------------------------------------
void SetErrorString(llvm::StringRef err_str);
//------------------------------------------------------------------
/// Set the current error string to a formatted error string.
///
/// @param format
/// A printf style format string
//------------------------------------------------------------------
int SetErrorStringWithFormat(const char *format, ...)
__attribute__((format(printf, 2, 3)));
int SetErrorStringWithVarArg(const char *format, va_list args);
template <typename... Args>
void SetErrorStringWithFormatv(const char *format, Args &&... args) {
SetErrorString(llvm::formatv(format, std::forward<Args>(args)...).str());
}
//------------------------------------------------------------------
/// Test for success condition.
///
/// Returns true if the error code in this object is considered a
/// successful return value.
///
/// @return
/// \b true if this object contains an value that describes
/// success (non-erro), \b false otherwise.
//------------------------------------------------------------------
bool Success() const;
//------------------------------------------------------------------
/// Test for a failure due to a generic interrupt.
///
/// Returns true if the error code in this object was caused by an interrupt.
/// At present only supports Posix EINTR.
///
/// @return
/// \b true if this object contains an value that describes
/// failure due to interrupt, \b false otherwise.
//------------------------------------------------------------------
bool WasInterrupted() const;
protected:
//------------------------------------------------------------------
/// Member variables
//------------------------------------------------------------------
ValueType m_code; ///< Error code as an integer value.
lldb::ErrorType m_type; ///< The type of the above error code.
mutable std::string m_string; ///< A string representation of the error code.
};
} // namespace lldb_private
namespace llvm {
template <> struct format_provider<lldb_private::Error> {
static void format(const lldb_private::Error &error, llvm::raw_ostream &OS,
llvm::StringRef Options) {
llvm::format_provider<llvm::StringRef>::format(error.AsCString(), OS,
Options);
}
};
}
#endif // #if defined(__cplusplus)
#endif // #ifndef __DCError_h__

lldb/include/lldb/Utility/JSON.h

Context not available.
#ifndef utility_JSON_h_ #ifndef utility_JSON_h_
#define utility_JSON_h_ #define utility_JSON_h_
#include "lldb/Core/Stream.h" #include "lldb/Utility/Stream.h"
#include "lldb/Utility/StringExtractor.h" #include "lldb/Utility/StringExtractor.h"
#include <inttypes.h> #include <inttypes.h>
Context not available.

lldb/include/lldb/Utility/ProcessStructReader.h

Context not available.
#include "lldb/lldb-defines.h" #include "lldb/lldb-defines.h"
#include "lldb/lldb-types.h" #include "lldb/lldb-types.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/DataExtractor.h" #include "lldb/Core/DataExtractor.h"
#include "lldb/Core/Error.h"
#include "lldb/Symbol/CompilerType.h" #include "lldb/Symbol/CompilerType.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Error.h"
#include <initializer_list> #include <initializer_list>
#include <map> #include <map>
Context not available.

lldb/include/lldb/Utility/RegularExpression.h

  • This file was added.
//===-- RegularExpression.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_RegularExpression_h_
#define liblldb_RegularExpression_h_
#ifdef _WIN32
#include "../lib/Support/regex_impl.h"
typedef llvm_regmatch_t regmatch_t;
typedef llvm_regex_t regex_t;
inline int regcomp(llvm_regex_t *a, const char *b, int c) {
return llvm_regcomp(a, b, c);
}
inline size_t regerror(int a, const llvm_regex_t *b, char *c, size_t d) {
return llvm_regerror(a, b, c, d);
}
inline int regexec(const llvm_regex_t *a, const char *b, size_t c,
llvm_regmatch_t d[], int e) {
return llvm_regexec(a, b, c, d, e);
}
inline void regfree(llvm_regex_t *a) { llvm_regfree(a); }
#else
#ifdef __ANDROID__
#include <regex>
#endif
#include <regex.h>
#endif
#include <stdint.h>
#include <string>
#include <vector>
namespace llvm {
class StringRef;
} // namespace llvm
namespace lldb_private {
//----------------------------------------------------------------------
/// @class RegularExpression RegularExpression.h
/// "lldb/Utility/RegularExpression.h"
/// @brief A C++ wrapper class for regex.
///
/// This regular expression class wraps the posix regex functions
/// \c regcomp(), \c regerror(), \c regexec(), and \c regfree() from
/// the header file in \c /usr/include/regex\.h.
//----------------------------------------------------------------------
class RegularExpression {
public:
class Match {
public:
Match(uint32_t max_matches) : m_matches() {
if (max_matches > 0)
m_matches.resize(max_matches + 1);
}
void Clear() {
const size_t num_matches = m_matches.size();
regmatch_t invalid_match = {-1, -1};
for (size_t i = 0; i < num_matches; ++i)
m_matches[i] = invalid_match;
}
size_t GetSize() const { return m_matches.size(); }
regmatch_t *GetData() {
return (m_matches.empty() ? nullptr : m_matches.data());
}
bool GetMatchAtIndex(llvm::StringRef s, uint32_t idx,
std::string &match_str) const;
bool GetMatchAtIndex(llvm::StringRef s, uint32_t idx,
llvm::StringRef &match_str) const;
bool GetMatchSpanningIndices(llvm::StringRef s, uint32_t idx1,
uint32_t idx2,
llvm::StringRef &match_str) const;
protected:
std::vector<regmatch_t>
m_matches; ///< Where parenthesized subexpressions results are stored
};
//------------------------------------------------------------------
/// Default constructor.
///
/// The default constructor that initializes the object state such
/// that it contains no compiled regular expression.
//------------------------------------------------------------------
RegularExpression();
explicit RegularExpression(llvm::StringRef string);
//------------------------------------------------------------------
/// Destructor.
///
/// Any previously compiled regular expression contained in this
/// object will be freed.
//------------------------------------------------------------------
~RegularExpression();
RegularExpression(const RegularExpression &rhs);
const RegularExpression &operator=(const RegularExpression &rhs);
//------------------------------------------------------------------
/// Compile a regular expression.
///
/// Compile a regular expression using the supplied regular
/// expression text. The compiled regular expression lives
/// in this object so that it can be readily used for regular
/// expression matches. Execute() can be called after the regular
/// expression is compiled. Any previously compiled regular
/// expression contained in this object will be freed.
///
/// @param[in] re
/// A NULL terminated C string that represents the regular
/// expression to compile.
///
/// @return
/// \b true if the regular expression compiles successfully,
/// \b false otherwise.
//------------------------------------------------------------------
bool Compile(llvm::StringRef string);
bool Compile(const char *) = delete;
//------------------------------------------------------------------
/// Executes a regular expression.
///
/// Execute a regular expression match using the compiled regular
/// expression that is already in this object against the match
/// string \a s. If any parens are used for regular expression
/// matches \a match_count should indicate the number of regmatch_t
/// values that are present in \a match_ptr.
///
/// @param[in] string
/// The string to match against the compile regular expression.
///
/// @param[in] match
/// A pointer to a RegularExpression::Match structure that was
/// properly initialized with the desired number of maximum
/// matches, or nullptr if no parenthesized matching is needed.
///
/// @return
/// \b true if \a string matches the compiled regular
/// expression, \b false otherwise.
//------------------------------------------------------------------
bool Execute(llvm::StringRef string, Match *match = nullptr) const;
bool Execute(const char *, Match * = nullptr) = delete;
size_t GetErrorAsCString(char *err_str, size_t err_str_max_len) const;
//------------------------------------------------------------------
/// Free the compiled regular expression.
///
/// If this object contains a valid compiled regular expression,
/// this function will free any resources it was consuming.
//------------------------------------------------------------------
void Free();
//------------------------------------------------------------------
/// Access the regular expression text.
///
/// Returns the text that was used to compile the current regular
/// expression.
///
/// @return
/// The NULL terminated C string that was used to compile the
/// current regular expression
//------------------------------------------------------------------
llvm::StringRef GetText() const;
//------------------------------------------------------------------
/// Test if valid.
///
/// Test if this object contains a valid regular expression.
///
/// @return
/// \b true if the regular expression compiled and is ready
/// for execution, \b false otherwise.
//------------------------------------------------------------------
bool IsValid() const;
void Clear() {
Free();
m_re.clear();
m_comp_err = 1;
}
int GetErrorCode() const { return m_comp_err; }
bool operator<(const RegularExpression &rhs) const;
private:
//------------------------------------------------------------------
// Member variables
//------------------------------------------------------------------
std::string m_re; ///< A copy of the original regular expression text
int m_comp_err; ///< Error code for the regular expression compilation
regex_t m_preg; ///< The compiled regular expression
};
} // namespace lldb_private
#endif // liblldb_RegularExpression_h_

lldb/include/lldb/Utility/Stream.h

  • This file was added.
//===-- Stream.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_Stream_h_
#define liblldb_Stream_h_
// C Includes
#include <stdarg.h>
// C++ Includes
// Other libraries and framework includes
// Project includes
#include "lldb/Core/Flags.h"
#include "lldb/lldb-private.h"
#include "llvm/Support/FormatVariadic.h"
namespace lldb_private {
//----------------------------------------------------------------------
/// @class Stream Stream.h "lldb/Utility/Stream.h"
/// @brief A stream class that can stream formatted output to a file.
//----------------------------------------------------------------------
class Stream {
public:
//------------------------------------------------------------------
/// \a m_flags bit values.
//------------------------------------------------------------------
enum {
eBinary = (1 << 0) ///< Get and put data as binary instead of as the default
/// string mode.
};
//------------------------------------------------------------------
/// Construct with flags and address size and byte order.
///
/// Construct with dump flags \a flags and the default address
/// size. \a flags can be any of the above enumeration logical OR'ed
/// together.
//------------------------------------------------------------------
Stream(uint32_t flags, uint32_t addr_size, lldb::ByteOrder byte_order);
//------------------------------------------------------------------
/// Construct a default Stream, not binary, host byte order and
/// host addr size.
///
//------------------------------------------------------------------
Stream();
//------------------------------------------------------------------
/// Destructor
//------------------------------------------------------------------
virtual ~Stream();
//------------------------------------------------------------------
// Subclasses must override these methods
//------------------------------------------------------------------
//------------------------------------------------------------------
/// Flush the stream.
///
/// Subclasses should flush the stream to make any output appear
/// if the stream has any buffering.
//------------------------------------------------------------------
virtual void Flush() = 0;
//------------------------------------------------------------------
/// Output character bytes to the stream.
///
/// Appends \a src_len characters from the buffer \a src to the
/// stream.
///
/// @param[in] src
/// A buffer containing at least \a src_len bytes of data.
///
/// @param[in] src_len
/// A number of bytes to append to the stream.
///
/// @return
/// The number of bytes that were appended to the stream.
//------------------------------------------------------------------
virtual size_t Write(const void *src, size_t src_len) = 0;
//------------------------------------------------------------------
// Member functions
//------------------------------------------------------------------
size_t PutChar(char ch);
//------------------------------------------------------------------
/// Set the byte_order value.
///
/// Sets the byte order of the data to extract. Extracted values
/// will be swapped if necessary when decoding.
///
/// @param[in] byte_order
/// The byte order value to use when extracting data.
///
/// @return
/// The old byte order value.
//------------------------------------------------------------------
lldb::ByteOrder SetByteOrder(lldb::ByteOrder byte_order);
//------------------------------------------------------------------
/// Format a C string from a printf style format and variable
/// arguments and encode and append the resulting C string as hex
/// bytes.
///
/// @param[in] format
/// A printf style format string.
///
/// @param[in] ...
/// Any additional arguments needed for the printf format string.
///
/// @return
/// The number of bytes that were appended to the stream.
//------------------------------------------------------------------
size_t PrintfAsRawHex8(const char *format, ...)
__attribute__((__format__(__printf__, 2, 3)));
//------------------------------------------------------------------
/// Format a C string from a printf style format and variable
/// arguments and encode and append the resulting C string as hex
/// bytes.
///
/// @param[in] format
/// A printf style format string.
///
/// @param[in] ...
/// Any additional arguments needed for the printf format string.
///
/// @return
/// The number of bytes that were appended to the stream.
//------------------------------------------------------------------
size_t PutHex8(uint8_t uvalue);
size_t PutNHex8(size_t n, uint8_t uvalue);
size_t PutHex16(uint16_t uvalue,
lldb::ByteOrder byte_order = lldb::eByteOrderInvalid);
size_t PutHex32(uint32_t uvalue,
lldb::ByteOrder byte_order = lldb::eByteOrderInvalid);
size_t PutHex64(uint64_t uvalue,
lldb::ByteOrder byte_order = lldb::eByteOrderInvalid);
size_t PutMaxHex64(uint64_t uvalue, size_t byte_size,
lldb::ByteOrder byte_order = lldb::eByteOrderInvalid);
size_t PutFloat(float f,
lldb::ByteOrder byte_order = lldb::eByteOrderInvalid);
size_t PutDouble(double d,
lldb::ByteOrder byte_order = lldb::eByteOrderInvalid);
size_t PutLongDouble(long double ld,
lldb::ByteOrder byte_order = lldb::eByteOrderInvalid);
size_t PutPointer(void *ptr);
// Append \a src_len bytes from \a src to the stream as hex characters
// (two ascii characters per byte of input data)
size_t
PutBytesAsRawHex8(const void *src, size_t src_len,
lldb::ByteOrder src_byte_order = lldb::eByteOrderInvalid,
lldb::ByteOrder dst_byte_order = lldb::eByteOrderInvalid);
// Append \a src_len bytes from \a s to the stream as binary data.
size_t PutRawBytes(const void *s, size_t src_len,
lldb::ByteOrder src_byte_order = lldb::eByteOrderInvalid,
lldb::ByteOrder dst_byte_order = lldb::eByteOrderInvalid);
size_t PutCStringAsRawHex8(const char *s);
//------------------------------------------------------------------
/// Output a NULL terminated C string \a cstr to the stream \a s.
///
/// @param[in] cstr
/// A NULL terminated C string.
///
/// @return
/// A reference to this class so multiple things can be streamed
/// in one statement.
//------------------------------------------------------------------
Stream &operator<<(const char *cstr);
Stream &operator<<(llvm::StringRef str);
//------------------------------------------------------------------
/// Output a pointer value \a p to the stream \a s.
///
/// @param[in] p
/// A void pointer.
///
/// @return
/// A reference to this class so multiple things can be streamed
/// in one statement.
//------------------------------------------------------------------
Stream &operator<<(const void *p);
//------------------------------------------------------------------
/// Output a character \a ch to the stream \a s.
///
/// @param[in] ch
/// A printable character value.
///
/// @return
/// A reference to this class so multiple things can be streamed
/// in one statement.
//------------------------------------------------------------------
Stream &operator<<(char ch);
//------------------------------------------------------------------
/// Output a uint8_t \a uval to the stream \a s.
///
/// @param[in] uval
/// A uint8_t value.
///
/// @return
/// A reference to this class so multiple things can be streamed
/// in one statement.
//------------------------------------------------------------------
Stream &operator<<(uint8_t uval);
//------------------------------------------------------------------
/// Output a uint16_t \a uval to the stream \a s.
///
/// @param[in] uval
/// A uint16_t value.
///
/// @return
/// A reference to this class so multiple things can be streamed
/// in one statement.
//------------------------------------------------------------------
Stream &operator<<(uint16_t uval);
//------------------------------------------------------------------
/// Output a uint32_t \a uval to the stream \a s.
///
/// @param[in] uval
/// A uint32_t value.
///
/// @return
/// A reference to this class so multiple things can be streamed
/// in one statement.
//------------------------------------------------------------------
Stream &operator<<(uint32_t uval);
//------------------------------------------------------------------
/// Output a uint64_t \a uval to the stream \a s.
///
/// @param[in] uval
/// A uint64_t value.
///
/// @return
/// A reference to this class so multiple things can be streamed
/// in one statement.
//------------------------------------------------------------------
Stream &operator<<(uint64_t uval);
//------------------------------------------------------------------
/// Output a int8_t \a sval to the stream \a s.
///
/// @param[in] sval
/// A int8_t value.
///
/// @return
/// A reference to this class so multiple things can be streamed
/// in one statement.
//------------------------------------------------------------------
Stream &operator<<(int8_t sval);
//------------------------------------------------------------------
/// Output a int16_t \a sval to the stream \a s.
///
/// @param[in] sval
/// A int16_t value.
///
/// @return
/// A reference to this class so multiple things can be streamed
/// in one statement.
//------------------------------------------------------------------
Stream &operator<<(int16_t sval);
//------------------------------------------------------------------
/// Output a int32_t \a sval to the stream \a s.
///
/// @param[in] sval
/// A int32_t value.
///
/// @return
/// A reference to this class so multiple things can be streamed
/// in one statement.
//------------------------------------------------------------------
Stream &operator<<(int32_t sval);
//------------------------------------------------------------------
/// Output a int64_t \a sval to the stream \a s.
///
/// @param[in] sval
/// A int64_t value.
///
/// @return
/// A reference to this class so multiple things can be streamed
/// in one statement.
//------------------------------------------------------------------
Stream &operator<<(int64_t sval);
//------------------------------------------------------------------
/// Output an address value to this stream.
///
/// Put an address \a addr out to the stream with optional \a prefix
/// and \a suffix strings.
///
/// @param[in] addr
/// An address value.
///
/// @param[in] addr_size
/// Size in bytes of the address, used for formatting.
///
/// @param[in] prefix
/// A prefix C string. If nullptr, no prefix will be output.
///
/// @param[in] suffix
/// A suffix C string. If nullptr, no suffix will be output.
//------------------------------------------------------------------
void Address(uint64_t addr, uint32_t addr_size, const char *prefix = nullptr,
const char *suffix = nullptr);
//------------------------------------------------------------------
/// Output an address range to this stream.
///
/// Put an address range \a lo_addr - \a hi_addr out to the stream
/// with optional \a prefix and \a suffix strings.
///
/// @param[in] lo_addr
/// The start address of the address range.
///
/// @param[in] hi_addr
/// The end address of the address range.
///
/// @param[in] addr_size
/// Size in bytes of the address, used for formatting.
///
/// @param[in] prefix
/// A prefix C string. If nullptr, no prefix will be output.
///
/// @param[in] suffix
/// A suffix C string. If nullptr, no suffix will be output.
//------------------------------------------------------------------
void AddressRange(uint64_t lo_addr, uint64_t hi_addr, uint32_t addr_size,
const char *prefix = nullptr, const char *suffix = nullptr);
//------------------------------------------------------------------
/// Output a C string to the stream.
///
/// Print a C string \a cstr to the stream.
///
/// @param[in] cstr
/// The string to be output to the stream.
//------------------------------------------------------------------
size_t PutCString(llvm::StringRef cstr);
//------------------------------------------------------------------
/// Output and End of Line character to the stream.
//------------------------------------------------------------------
size_t EOL();
//------------------------------------------------------------------
/// Get the address size in bytes.
///
/// @return
/// The size of an address in bytes that is used when outputting
/// address and pointer values to the stream.
//------------------------------------------------------------------
uint32_t GetAddressByteSize() const;
//------------------------------------------------------------------
/// The flags accessor.
///
/// @return
/// A reference to the Flags member variable.
//------------------------------------------------------------------
Flags &GetFlags();
//------------------------------------------------------------------
/// The flags const accessor.
///
/// @return
/// A const reference to the Flags member variable.
//------------------------------------------------------------------
const Flags &GetFlags() const;
//------------------------------------------------------------------
//// The byte order accessor.
////
//// @return
//// The byte order.
//------------------------------------------------------------------
lldb::ByteOrder GetByteOrder() const;
//------------------------------------------------------------------
/// Get the current indentation level.
///
/// @return
/// The current indentation level as an integer.
//------------------------------------------------------------------
int GetIndentLevel() const;
//------------------------------------------------------------------
/// Indent the current line in the stream.
///
/// Indent the current line using the current indentation level and
/// print an optional string following the indentation spaces.
///
/// @param[in] s
/// A C string to print following the indentation. If nullptr, just
/// output the indentation characters.
//------------------------------------------------------------------
size_t Indent(const char *s = nullptr);
size_t Indent(llvm::StringRef s);
//------------------------------------------------------------------
/// Decrement the current indentation level.
//------------------------------------------------------------------
void IndentLess(int amount = 2);
//------------------------------------------------------------------
/// Increment the current indentation level.
//------------------------------------------------------------------
void IndentMore(int amount = 2);
//------------------------------------------------------------------
/// Output an offset value.
///
/// Put an offset \a uval out to the stream using the printf format
/// in \a format.
///
/// @param[in] offset
/// The offset value.
///
/// @param[in] format
/// The printf style format to use when outputting the offset.
//------------------------------------------------------------------
void Offset(uint32_t offset, const char *format = "0x%8.8x: ");
//------------------------------------------------------------------
/// Output printf formatted output to the stream.
///
/// Print some formatted output to the stream.
///
/// @param[in] format
/// A printf style format string.
///
/// @param[in] ...
/// Variable arguments that are needed for the printf style
/// format string \a format.
//------------------------------------------------------------------
size_t Printf(const char *format, ...) __attribute__((format(printf, 2, 3)));
size_t PrintfVarArg(const char *format, va_list args);
template <typename... Args> void Format(const char *format, Args &&... args) {
PutCString(llvm::formatv(format, std::forward<Args>(args)...).str());
}
//------------------------------------------------------------------
/// Output a quoted C string value to the stream.
///
/// Print a double quoted NULL terminated C string to the stream
/// using the printf format in \a format.
///
/// @param[in] cstr
/// A NULL terminated C string value.
///
/// @param[in] format
/// The optional C string format that can be overridden.
//------------------------------------------------------------------
void QuotedCString(const char *cstr, const char *format = "\"%s\"");
//------------------------------------------------------------------
/// Set the address size in bytes.
///
/// @param[in] addr_size
/// The new size in bytes of an address to use when outputting
/// address and pointer values.
//------------------------------------------------------------------
void SetAddressByteSize(uint32_t addr_size);
//------------------------------------------------------------------
/// Set the current indentation level.
///
/// @param[in] level
/// The new indentation level.
//------------------------------------------------------------------
void SetIndentLevel(int level);
//------------------------------------------------------------------
/// Output a SLEB128 number to the stream.
///
/// Put an SLEB128 \a uval out to the stream using the printf format
/// in \a format.
///
/// @param[in] uval
/// A uint64_t value that was extracted as a SLEB128 value.
///
/// @param[in] format
/// The optional printf format that can be overridden.
//------------------------------------------------------------------
size_t PutSLEB128(int64_t uval);
//------------------------------------------------------------------
/// Output a ULEB128 number to the stream.
///
/// Put an ULEB128 \a uval out to the stream using the printf format
/// in \a format.
///
/// @param[in] uval
/// A uint64_t value that was extracted as a ULEB128 value.
///
/// @param[in] format
/// The optional printf format that can be overridden.
//------------------------------------------------------------------
size_t PutULEB128(uint64_t uval);
static void UnitTest(Stream *s);
protected:
//------------------------------------------------------------------
// Member variables
//------------------------------------------------------------------
Flags m_flags; ///< Dump flags.
uint32_t m_addr_size; ///< Size of an address in bytes.
lldb::ByteOrder
m_byte_order; ///< Byte order to use when encoding scalar types.
int m_indent_level; ///< Indention level.
size_t _PutHex8(uint8_t uvalue, bool add_prefix);
};
} // namespace lldb_private
#endif // liblldb_Stream_h_

lldb/include/lldb/Utility/StreamString.h

  • This file was added.
//===-- StreamString.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_StreamString_h_
#define liblldb_StreamString_h_
#include <string>
#include "lldb/Utility/Stream.h"
namespace lldb_private {
class StreamString : public Stream {
public:
StreamString();
StreamString(uint32_t flags, uint32_t addr_size, lldb::ByteOrder byte_order);
~StreamString() override;
void Flush() override;
size_t Write(const void *s, size_t length) override;
void Clear();
bool Empty() const;
size_t GetSize() const;
size_t GetSizeOfLastLine() const;
llvm::StringRef GetString() const;
const char *GetData() const { return m_packet.c_str(); }
void FillLastLineToColumn(uint32_t column, char fill_char);
protected:
std::string m_packet;
};
} // namespace lldb_private
#endif // liblldb_StreamString_h_

lldb/include/lldb/Utility/StreamTee.h

  • This file was added.
//===-- StreamTee.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_StreamTee_h_
#define liblldb_StreamTee_h_
#include <limits.h>
#include <mutex>
#include "lldb/Utility/Stream.h"
namespace lldb_private {
class StreamTee : public Stream {
public:
StreamTee() : Stream(), m_streams_mutex(), m_streams() {}
StreamTee(lldb::StreamSP &stream_sp)
: Stream(), m_streams_mutex(), m_streams() {
// No need to lock mutex during construction
if (stream_sp)
m_streams.push_back(stream_sp);
}
StreamTee(lldb::StreamSP &stream_sp, lldb::StreamSP &stream_2_sp)
: Stream(), m_streams_mutex(), m_streams() {
// No need to lock mutex during construction
if (stream_sp)
m_streams.push_back(stream_sp);
if (stream_2_sp)
m_streams.push_back(stream_2_sp);
}
StreamTee(const StreamTee &rhs)
: Stream(rhs), m_streams_mutex(), m_streams() {
// Don't copy until we lock down "rhs"
std::lock_guard<std::recursive_mutex> guard(rhs.m_streams_mutex);
m_streams = rhs.m_streams;
}
~StreamTee() override {}
StreamTee &operator=(const StreamTee &rhs) {
if (this != &rhs) {
Stream::operator=(rhs);
std::lock_guard<std::recursive_mutex> lhs_locker(m_streams_mutex);
std::lock_guard<std::recursive_mutex> rhs_locker(rhs.m_streams_mutex);
m_streams = rhs.m_streams;
}
return *this;
}
void Flush() override {
std::lock_guard<std::recursive_mutex> guard(m_streams_mutex);
collection::iterator pos, end;
for (pos = m_streams.begin(), end = m_streams.end(); pos != end; ++pos) {
// Allow for our collection to contain NULL streams. This allows
// the StreamTee to be used with hard coded indexes for clients
// that might want N total streams with only a few that are set
// to valid values.
Stream *strm = pos->get();
if (strm)
strm->Flush();
}
}
size_t Write(const void *s, size_t length) override {
std::lock_guard<std::recursive_mutex> guard(m_streams_mutex);
if (m_streams.empty())
return 0;
size_t min_bytes_written = SIZE_MAX;
collection::iterator pos, end;
for (pos = m_streams.begin(), end = m_streams.end(); pos != end; ++pos) {
// Allow for our collection to contain NULL streams. This allows
// the StreamTee to be used with hard coded indexes for clients
// that might want N total streams with only a few that are set
// to valid values.
Stream *strm = pos->get();
if (strm) {
const size_t bytes_written = strm->Write(s, length);
if (min_bytes_written > bytes_written)
min_bytes_written = bytes_written;
}
}
if (min_bytes_written == SIZE_MAX)
return 0;
return min_bytes_written;
}
size_t AppendStream(const lldb::StreamSP &stream_sp) {
size_t new_idx = m_streams.size();
std::lock_guard<std::recursive_mutex> guard(m_streams_mutex);
m_streams.push_back(stream_sp);
return new_idx;
}
size_t GetNumStreams() const {
size_t result = 0;
{
std::lock_guard<std::recursive_mutex> guard(m_streams_mutex);
result = m_streams.size();
}
return result;
}
lldb::StreamSP GetStreamAtIndex(uint32_t idx) {
lldb::StreamSP stream_sp;
std::lock_guard<std::recursive_mutex> guard(m_streams_mutex);
if (idx < m_streams.size())
stream_sp = m_streams[idx];
return stream_sp;
}
void SetStreamAtIndex(uint32_t idx, const lldb::StreamSP &stream_sp) {
std::lock_guard<std::recursive_mutex> guard(m_streams_mutex);
// Resize our stream vector as necessary to fit as many streams
// as needed. This also allows this class to be used with hard
// coded indexes that can be used contain many streams, not all
// of which are valid.
if (idx >= m_streams.size())
m_streams.resize(idx + 1);
m_streams[idx] = stream_sp;
}
protected:
typedef std::vector<lldb::StreamSP> collection;
mutable std::recursive_mutex m_streams_mutex;
collection m_streams;
};
} // namespace lldb_private
#endif // liblldb_StreamTee_h_

lldb/source/API/SBAddress.cpp

Context not available.
#include "lldb/Core/Address.h" #include "lldb/Core/Address.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Symbol/LineEntry.h" #include "lldb/Symbol/LineEntry.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/API/SBBreakpoint.cpp

Context not available.
#include "lldb/Core/Address.h" #include "lldb/Core/Address.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Interpreter/ScriptInterpreter.h" #include "lldb/Interpreter/ScriptInterpreter.h"
Context not available.
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Target/ThreadSpec.h" #include "lldb/Target/ThreadSpec.h"
#include "lldb/Utility/Stream.h"
#include "lldb/lldb-enumerations.h" #include "lldb/lldb-enumerations.h"
Context not available.

lldb/source/API/SBBreakpointLocation.cpp

Context not available.
#include "lldb/Breakpoint/BreakpointLocation.h" #include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Interpreter/ScriptInterpreter.h" #include "lldb/Interpreter/ScriptInterpreter.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/ThreadSpec.h" #include "lldb/Target/ThreadSpec.h"
#include "lldb/Target/ThreadSpec.h" #include "lldb/Target/ThreadSpec.h"
#include "lldb/Utility/Stream.h"
#include "lldb/lldb-defines.h" #include "lldb/lldb-defines.h"
#include "lldb/lldb-types.h" #include "lldb/lldb-types.h"
Context not available.

lldb/source/API/SBCommandReturnObject.cpp

Context not available.
#include "lldb/API/SBError.h" #include "lldb/API/SBError.h"
#include "lldb/API/SBStream.h" #include "lldb/API/SBStream.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Interpreter/CommandReturnObject.h" #include "lldb/Interpreter/CommandReturnObject.h"
#include "lldb/Utility/Error.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/API/SBData.cpp

Context not available.
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/DataExtractor.h" #include "lldb/Core/DataExtractor.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Stream.h" #include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/API/SBDeclaration.cpp

Context not available.
#include "lldb/API/SBDeclaration.h" #include "lldb/API/SBDeclaration.h"
#include "lldb/API/SBStream.h" #include "lldb/API/SBStream.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Stream.h"
#include "lldb/Symbol/Declaration.h" #include "lldb/Symbol/Declaration.h"
#include "lldb/Utility/Stream.h"
#include <limits.h> #include <limits.h>
Context not available.

lldb/source/API/SBError.cpp

Context not available.
#include "lldb/API/SBError.h" #include "lldb/API/SBError.h"
#include "lldb/API/SBStream.h" #include "lldb/API/SBStream.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Utility/Error.h"
#include <stdarg.h> #include <stdarg.h>
Context not available.

lldb/source/API/SBEvent.cpp

Context not available.
#include "lldb/API/SBStream.h" #include "lldb/API/SBStream.h"
#include "lldb/Breakpoint/Breakpoint.h" #include "lldb/Breakpoint/Breakpoint.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Event.h" #include "lldb/Core/Event.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/API/SBFileSpec.cpp

Context not available.
#include "lldb/API/SBFileSpec.h" #include "lldb/API/SBFileSpec.h"
#include "lldb/API/SBStream.h" #include "lldb/API/SBStream.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Stream.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
#include "lldb/Utility/Stream.h"
#include "llvm/ADT/SmallString.h" #include "llvm/ADT/SmallString.h"
Context not available.

lldb/source/API/SBFileSpecList.cpp

Context not available.
#include "lldb/API/SBStream.h" #include "lldb/API/SBStream.h"
#include "lldb/Core/FileSpecList.h" #include "lldb/Core/FileSpecList.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Stream.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/API/SBFrame.cpp

Context not available.
#include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h" #include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h"
#include "lldb/Core/Address.h" #include "lldb/Core/Address.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Core/ValueObjectRegister.h" #include "lldb/Core/ValueObjectRegister.h"
#include "lldb/Core/ValueObjectVariable.h" #include "lldb/Core/ValueObjectVariable.h"
Context not available.
#include "lldb/Target/StackID.h" #include "lldb/Target/StackID.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Stream.h"
#include "lldb/API/SBAddress.h" #include "lldb/API/SBAddress.h"
#include "lldb/API/SBDebugger.h" #include "lldb/API/SBDebugger.h"
Context not available.

lldb/source/API/SBInstructionList.cpp

Context not available.
#include "lldb/API/SBStream.h" #include "lldb/API/SBStream.h"
#include "lldb/Core/Disassembler.h" #include "lldb/Core/Disassembler.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/Stream.h"
#include "lldb/Symbol/SymbolContext.h" #include "lldb/Symbol/SymbolContext.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/API/SBLineEntry.cpp

Context not available.
#include "lldb/API/SBLineEntry.h" #include "lldb/API/SBLineEntry.h"
#include "lldb/API/SBStream.h" #include "lldb/API/SBStream.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Symbol/LineEntry.h" #include "lldb/Symbol/LineEntry.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/API/SBListener.cpp

Context not available.
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/Listener.h" #include "lldb/Core/Listener.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/StreamString.h" #include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/API/SBMemoryRegionInfo.cpp

Context not available.
#include "lldb/API/SBDefines.h" #include "lldb/API/SBDefines.h"
#include "lldb/API/SBError.h" #include "lldb/API/SBError.h"
#include "lldb/API/SBStream.h" #include "lldb/API/SBStream.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Target/MemoryRegionInfo.h" #include "lldb/Target/MemoryRegionInfo.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/API/SBModule.cpp

Context not available.
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/Section.h" #include "lldb/Core/Section.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/ValueObjectList.h" #include "lldb/Core/ValueObjectList.h"
#include "lldb/Core/ValueObjectVariable.h" #include "lldb/Core/ValueObjectVariable.h"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
Context not available.
#include "lldb/Symbol/TypeSystem.h" #include "lldb/Symbol/TypeSystem.h"
#include "lldb/Symbol/VariableList.h" #include "lldb/Symbol/VariableList.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/API/SBModuleSpec.cpp

Context not available.
#include "lldb/API/SBStream.h" #include "lldb/API/SBStream.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/ModuleSpec.h" #include "lldb/Core/ModuleSpec.h"
#include "lldb/Core/Stream.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/API/SBPlatform.cpp

Context not available.
#include "lldb/API/SBLaunchInfo.h" #include "lldb/API/SBLaunchInfo.h"
#include "lldb/API/SBUnixSignals.h" #include "lldb/API/SBUnixSignals.h"
#include "lldb/Core/ArchSpec.h" #include "lldb/Core/ArchSpec.h"
#include "lldb/Core/Error.h"
#include "lldb/Host/File.h" #include "lldb/Host/File.h"
#include "lldb/Interpreter/Args.h" #include "lldb/Interpreter/Args.h"
#include "lldb/Target/Platform.h" #include "lldb/Target/Platform.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Error.h"
#include <functional> #include <functional>
Context not available.

lldb/source/API/SBProcess.cpp

Context not available.
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/State.h" #include "lldb/Core/State.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Interpreter/Args.h" #include "lldb/Interpreter/Args.h"
#include "lldb/Target/MemoryRegionInfo.h" #include "lldb/Target/MemoryRegionInfo.h"
Context not available.
#include "lldb/Target/SystemRuntime.h" #include "lldb/Target/SystemRuntime.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/Stream.h"
// Project includes // Project includes
Context not available.

lldb/source/API/SBSection.cpp

Context not available.
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/Section.h" #include "lldb/Core/Section.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/API/SBSourceManager.cpp

Context not available.
#include "lldb/API/SBFileSpec.h" #include "lldb/API/SBFileSpec.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/SourceManager.h" #include "lldb/Core/SourceManager.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
Context not available.

lldb/source/API/SBStream.cpp

Context not available.
#include "lldb/API/SBStream.h" #include "lldb/API/SBStream.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Core/StreamString.h" #include "lldb/Utility/Error.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/API/SBStructuredData.cpp

Context not available.
#include "lldb/API/SBStructuredData.h" #include "lldb/API/SBStructuredData.h"
#include "lldb/API/SBStream.h" #include "lldb/API/SBStream.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Event.h" #include "lldb/Core/Event.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/StructuredData.h" #include "lldb/Core/StructuredData.h"
#include "lldb/Target/StructuredDataPlugin.h" #include "lldb/Target/StructuredDataPlugin.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/API/SBTarget.cpp

Context not available.
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/ModuleSpec.h" #include "lldb/Core/ModuleSpec.h"
#include "lldb/Core/RegularExpression.h"
#include "lldb/Core/STLUtils.h" #include "lldb/Core/STLUtils.h"
#include "lldb/Core/SearchFilter.h" #include "lldb/Core/SearchFilter.h"
#include "lldb/Core/Section.h" #include "lldb/Core/Section.h"
Context not available.
#include "lldb/Target/StackFrame.h" #include "lldb/Target/StackFrame.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/TargetList.h" #include "lldb/Target/TargetList.h"
#include "lldb/Utility/RegularExpression.h"
#include "../source/Commands/CommandObjectBreakpoint.h" #include "../source/Commands/CommandObjectBreakpoint.h"
#include "lldb/Interpreter/CommandReturnObject.h" #include "lldb/Interpreter/CommandReturnObject.h"
Context not available.

lldb/source/API/SBThread.cpp

Context not available.
#include "lldb/Breakpoint/BreakpointLocation.h" #include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/State.h" #include "lldb/Core/State.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Core/StructuredData.h" #include "lldb/Core/StructuredData.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
Context not available.
#include "lldb/Target/ThreadPlanStepOut.h" #include "lldb/Target/ThreadPlanStepOut.h"
#include "lldb/Target/ThreadPlanStepRange.h" #include "lldb/Target/ThreadPlanStepRange.h"
#include "lldb/Target/UnixSignals.h" #include "lldb/Target/UnixSignals.h"
#include "lldb/Utility/Stream.h"
#include "lldb/API/SBAddress.h" #include "lldb/API/SBAddress.h"
#include "lldb/API/SBDebugger.h" #include "lldb/API/SBDebugger.h"
Context not available.

lldb/source/API/SBThreadPlan.cpp

Context not available.
#include "lldb/Breakpoint/BreakpointLocation.h" #include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/State.h" #include "lldb/Core/State.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Core/StructuredData.h" #include "lldb/Core/StructuredData.h"
#include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandInterpreter.h"
Context not available.
#include "lldb/Target/ThreadPlanStepInstruction.h" #include "lldb/Target/ThreadPlanStepInstruction.h"
#include "lldb/Target/ThreadPlanStepOut.h" #include "lldb/Target/ThreadPlanStepOut.h"
#include "lldb/Target/ThreadPlanStepRange.h" #include "lldb/Target/ThreadPlanStepRange.h"
#include "lldb/Utility/Stream.h"
#include "lldb/API/SBAddress.h" #include "lldb/API/SBAddress.h"
#include "lldb/API/SBDebugger.h" #include "lldb/API/SBDebugger.h"
Context not available.

lldb/source/API/SBType.cpp

Context not available.
#include "lldb/API/SBDefines.h" #include "lldb/API/SBDefines.h"
#include "lldb/API/SBStream.h" #include "lldb/API/SBStream.h"
#include "lldb/API/SBTypeEnumMember.h" #include "lldb/API/SBTypeEnumMember.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Mangled.h" #include "lldb/Core/Mangled.h"
#include "lldb/Core/Stream.h"
#include "lldb/Symbol/CompilerType.h" #include "lldb/Symbol/CompilerType.h"
#include "lldb/Symbol/Type.h" #include "lldb/Symbol/Type.h"
#include "lldb/Symbol/TypeSystem.h" #include "lldb/Symbol/TypeSystem.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Stream.h"
#include "llvm/ADT/APSInt.h" #include "llvm/ADT/APSInt.h"
Context not available.

lldb/source/API/SBTypeEnumMember.cpp

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/API/SBType.h" #include "lldb/API/SBTypeEnumMember.h"
#include "lldb/API/SBDefines.h" #include "lldb/API/SBDefines.h"
#include "lldb/API/SBStream.h" #include "lldb/API/SBStream.h"
#include "lldb/API/SBTypeEnumMember.h" #include "lldb/API/SBType.h"
#include "lldb/Core/Stream.h"
#include "lldb/Symbol/CompilerType.h" #include "lldb/Symbol/CompilerType.h"
#include "lldb/Symbol/Type.h" #include "lldb/Symbol/Type.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/API/SBValue.cpp

Context not available.
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/Scalar.h" #include "lldb/Core/Scalar.h"
#include "lldb/Core/Section.h" #include "lldb/Core/Section.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Core/Value.h" #include "lldb/Core/Value.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
Context not available.
#include "lldb/Target/StackFrame.h" #include "lldb/Target/StackFrame.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/Stream.h"
#include "lldb/API/SBDebugger.h" #include "lldb/API/SBDebugger.h"
#include "lldb/API/SBExpressionOptions.h" #include "lldb/API/SBExpressionOptions.h"
Context not available.

lldb/source/API/SBWatchpoint.cpp

Context not available.
#include "lldb/Breakpoint/Watchpoint.h" #include "lldb/Breakpoint/Watchpoint.h"
#include "lldb/Breakpoint/WatchpointList.h" #include "lldb/Breakpoint/WatchpointList.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Stream.h"
#include "lldb/lldb-defines.h" #include "lldb/lldb-defines.h"
#include "lldb/lldb-types.h" #include "lldb/lldb-types.h"
Context not available.

lldb/source/Breakpoint/Breakpoint.cpp

Context not available.
#include "lldb/Core/ModuleList.h" #include "lldb/Core/ModuleList.h"
#include "lldb/Core/SearchFilter.h" #include "lldb/Core/SearchFilter.h"
#include "lldb/Core/Section.h" #include "lldb/Core/Section.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Symbol/CompileUnit.h" #include "lldb/Symbol/CompileUnit.h"
#include "lldb/Symbol/Function.h" #include "lldb/Symbol/Function.h"
#include "lldb/Symbol/SymbolContext.h" #include "lldb/Symbol/SymbolContext.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/ThreadSpec.h" #include "lldb/Target/ThreadSpec.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Breakpoint/BreakpointID.cpp

Context not available.
// Project includes // Project includes
#include "lldb/Breakpoint/Breakpoint.h" #include "lldb/Breakpoint/Breakpoint.h"
#include "lldb/Breakpoint/BreakpointID.h" #include "lldb/Breakpoint/BreakpointID.h"
#include "lldb/Core/Error.h" #include "lldb/Utility/Error.h"
#include "lldb/Core/Stream.h" #include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Breakpoint/BreakpointLocation.cpp

Context not available.
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/Expression/DiagnosticManager.h" #include "lldb/Expression/DiagnosticManager.h"
#include "lldb/Expression/ExpressionVariable.h" #include "lldb/Expression/ExpressionVariable.h"
Context not available.
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Target/ThreadSpec.h" #include "lldb/Target/ThreadSpec.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Breakpoint/BreakpointOptions.cpp

Context not available.
#include "lldb/Breakpoint/BreakpointOptions.h" #include "lldb/Breakpoint/BreakpointOptions.h"
#include "lldb/Breakpoint/StoppointCallbackContext.h" #include "lldb/Breakpoint/StoppointCallbackContext.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/StringList.h" #include "lldb/Core/StringList.h"
#include "lldb/Core/Value.h" #include "lldb/Core/Value.h"
#include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandInterpreter.h"
Context not available.
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/ThreadSpec.h" #include "lldb/Target/ThreadSpec.h"
#include "lldb/Utility/Stream.h"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
Context not available.

lldb/source/Breakpoint/BreakpointResolver.cpp

Context not available.
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/ModuleList.h" #include "lldb/Core/ModuleList.h"
#include "lldb/Core/SearchFilter.h" #include "lldb/Core/SearchFilter.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Symbol/CompileUnit.h" #include "lldb/Symbol/CompileUnit.h"
#include "lldb/Symbol/Function.h" #include "lldb/Symbol/Function.h"
#include "lldb/Symbol/SymbolContext.h" #include "lldb/Symbol/SymbolContext.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb_private; using namespace lldb_private;
using namespace lldb; using namespace lldb;
Context not available.

lldb/source/Breakpoint/BreakpointResolverAddress.cpp

Context not available.
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/Section.h" #include "lldb/Core/Section.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Breakpoint/BreakpointResolverFileLine.cpp

Context not available.
#include "lldb/Breakpoint/BreakpointLocation.h" #include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Symbol/CompileUnit.h" #include "lldb/Symbol/CompileUnit.h"
#include "lldb/Symbol/Function.h" #include "lldb/Symbol/Function.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Breakpoint/BreakpointResolverFileRegex.cpp

Context not available.
#include "lldb/Breakpoint/BreakpointLocation.h" #include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/SourceManager.h" #include "lldb/Core/SourceManager.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Symbol/CompileUnit.h" #include "lldb/Symbol/CompileUnit.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Breakpoint/BreakpointResolverName.cpp

Context not available.
#include "lldb/Breakpoint/BreakpointLocation.h" #include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Symbol/Block.h" #include "lldb/Symbol/Block.h"
#include "lldb/Symbol/Function.h" #include "lldb/Symbol/Function.h"
#include "lldb/Symbol/Symbol.h" #include "lldb/Symbol/Symbol.h"
#include "lldb/Symbol/SymbolContext.h" #include "lldb/Symbol/SymbolContext.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Breakpoint/BreakpointSite.cpp

Context not available.
#include "lldb/Breakpoint/Breakpoint.h" #include "lldb/Breakpoint/Breakpoint.h"
#include "lldb/Breakpoint/BreakpointLocation.h" #include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Breakpoint/BreakpointSiteList.h" #include "lldb/Breakpoint/BreakpointSiteList.h"
#include "lldb/Core/Stream.h" #include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Breakpoint/BreakpointSiteList.cpp

Context not available.
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/Stream.h" #include "lldb/Utility/Stream.h"
#include <algorithm> #include <algorithm>
using namespace lldb; using namespace lldb;
Context not available.

lldb/source/Breakpoint/Watchpoint.cpp

Context not available.
#include "lldb/Breakpoint/Watchpoint.h" #include "lldb/Breakpoint/Watchpoint.h"
#include "lldb/Breakpoint/StoppointCallbackContext.h" #include "lldb/Breakpoint/StoppointCallbackContext.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/Value.h" #include "lldb/Core/Value.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/Core/ValueObjectMemory.h" #include "lldb/Core/ValueObjectMemory.h"
Context not available.
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/ThreadSpec.h" #include "lldb/Target/ThreadSpec.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Breakpoint/WatchpointOptions.cpp

Context not available.
#include "lldb/Breakpoint/WatchpointOptions.h" #include "lldb/Breakpoint/WatchpointOptions.h"
#include "lldb/Breakpoint/StoppointCallbackContext.h" #include "lldb/Breakpoint/StoppointCallbackContext.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/StringList.h" #include "lldb/Core/StringList.h"
#include "lldb/Core/Value.h" #include "lldb/Core/Value.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/ThreadSpec.h" #include "lldb/Target/ThreadSpec.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Commands/CommandObjectBreakpoint.cpp

Context not available.
#include "lldb/Breakpoint/Breakpoint.h" #include "lldb/Breakpoint/Breakpoint.h"
#include "lldb/Breakpoint/BreakpointIDList.h" #include "lldb/Breakpoint/BreakpointIDList.h"
#include "lldb/Breakpoint/BreakpointLocation.h" #include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Core/RegularExpression.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Host/StringConvert.h" #include "lldb/Host/StringConvert.h"
#include "lldb/Interpreter/CommandCompletions.h" #include "lldb/Interpreter/CommandCompletions.h"
#include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandInterpreter.h"
Context not available.
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Target/ThreadSpec.h" #include "lldb/Target/ThreadSpec.h"
#include "lldb/Utility/RegularExpression.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Commands/CommandObjectFrame.cpp

Context not available.
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/Timer.h" #include "lldb/Core/Timer.h"
#include "lldb/Core/Value.h" #include "lldb/Core/Value.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
Context not available.
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/LLDBAssert.h" #include "lldb/Utility/LLDBAssert.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Commands/CommandObjectLog.cpp

Context not available.
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/RegularExpression.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Core/Timer.h" #include "lldb/Core/Timer.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
Context not available.
#include "lldb/Symbol/SymbolVendor.h" #include "lldb/Symbol/SymbolVendor.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/RegularExpression.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Commands/CommandObjectMemory.cpp

Context not available.
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/Section.h" #include "lldb/Core/Section.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/ValueObjectMemory.h" #include "lldb/Core/ValueObjectMemory.h"
#include "lldb/DataFormatters/ValueObjectPrinter.h" #include "lldb/DataFormatters/ValueObjectPrinter.h"
#include "lldb/Host/StringConvert.h" #include "lldb/Host/StringConvert.h"
Context not available.
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/StackFrame.h" #include "lldb/Target/StackFrame.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/StreamString.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
Context not available.

lldb/source/Commands/CommandObjectType.cpp

Context not available.
#include <functional> #include <functional>
// Project includes // Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/IOHandler.h" #include "lldb/Core/IOHandler.h"
#include "lldb/Core/RegularExpression.h"
#include "lldb/Core/State.h" #include "lldb/Core/State.h"
#include "lldb/Core/StringList.h" #include "lldb/Core/StringList.h"
#include "lldb/DataFormatters/DataVisualization.h" #include "lldb/DataFormatters/DataVisualization.h"
Context not available.
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Target/ThreadList.h" #include "lldb/Target/ThreadList.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/RegularExpression.h"
// Other libraries and framework includes // Other libraries and framework includes
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
Context not available.

lldb/source/Commands/CommandObjectWatchpoint.cpp

Context not available.
// Project includes // Project includes
#include "lldb/Breakpoint/Watchpoint.h" #include "lldb/Breakpoint/Watchpoint.h"
#include "lldb/Breakpoint/WatchpointList.h" #include "lldb/Breakpoint/WatchpointList.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/Core/ValueObjectVariable.h" #include "lldb/Core/ValueObjectVariable.h"
#include "lldb/Host/StringConvert.h" #include "lldb/Host/StringConvert.h"
Context not available.
#include "lldb/Symbol/VariableList.h" #include "lldb/Symbol/VariableList.h"
#include "lldb/Target/StackFrame.h" #include "lldb/Target/StackFrame.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Core/AddressRange.cpp

Context not available.
#include "lldb/Core/AddressRange.h" #include "lldb/Core/AddressRange.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/Stream.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Core/AddressResolver.cpp

Context not available.
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/ModuleList.h" #include "lldb/Core/ModuleList.h"
#include "lldb/Core/SearchFilter.h" #include "lldb/Core/SearchFilter.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Symbol/SymbolContext.h" #include "lldb/Symbol/SymbolContext.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Core/AddressResolverFileLine.cpp

Context not available.
// Project includes // Project includes
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Symbol/CompileUnit.h" #include "lldb/Symbol/CompileUnit.h"
#include "lldb/Symbol/SymbolContext.h" #include "lldb/Symbol/SymbolContext.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Core/AddressResolverName.cpp

Context not available.
// Project includes // Project includes
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Symbol/Function.h" #include "lldb/Symbol/Function.h"
#include "lldb/Symbol/Symbol.h" #include "lldb/Symbol/Symbol.h"
#include "lldb/Symbol/SymbolContext.h" #include "lldb/Symbol/SymbolContext.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Core/ArchSpec.cpp

Context not available.
// Project includes // Project includes
#include "Plugins/Process/Utility/ARMDefines.h" #include "Plugins/Process/Utility/ARMDefines.h"
#include "Plugins/Process/Utility/InstructionUtils.h" #include "Plugins/Process/Utility/InstructionUtils.h"
#include "lldb/Core/RegularExpression.h"
#include "lldb/Core/StringList.h" #include "lldb/Core/StringList.h"
#include "lldb/Host/Endian.h" #include "lldb/Host/Endian.h"
#include "lldb/Host/HostInfo.h" #include "lldb/Host/HostInfo.h"
Context not available.
#include "lldb/Target/RegisterContext.h" #include "lldb/Target/RegisterContext.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/NameMatches.h" #include "lldb/Utility/NameMatches.h"
#include "lldb/Utility/RegularExpression.h"
#include "lldb/Utility/SafeMachO.h" #include "lldb/Utility/SafeMachO.h"
using namespace lldb; using namespace lldb;
Context not available.

lldb/source/Core/Baton.cpp

Context not available.
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/Stream.h" #include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Core/Broadcaster.cpp

Context not available.
#include "lldb/Core/Event.h" #include "lldb/Core/Event.h"
#include "lldb/Core/Listener.h" #include "lldb/Core/Listener.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/StreamString.h" #include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Core/CMakeLists.txt

Context not available.
Broadcaster.cpp Broadcaster.cpp
Communication.cpp Communication.cpp
Connection.cpp Connection.cpp
ConstString.cpp
DataBufferHeap.cpp DataBufferHeap.cpp
DataBufferMemoryMap.cpp DataBufferMemoryMap.cpp
DataEncoder.cpp DataEncoder.cpp
Context not available.
Disassembler.cpp Disassembler.cpp
DynamicLoader.cpp DynamicLoader.cpp
EmulateInstruction.cpp EmulateInstruction.cpp
Error.cpp
Event.cpp Event.cpp
FastDemangle.cpp FastDemangle.cpp
FileLineResolver.cpp FileLineResolver.cpp
Context not available.
Opcode.cpp Opcode.cpp
PluginManager.cpp PluginManager.cpp
RegisterValue.cpp RegisterValue.cpp
RegularExpression.cpp
Scalar.cpp Scalar.cpp
SearchFilter.cpp SearchFilter.cpp
Section.cpp Section.cpp
SourceManager.cpp SourceManager.cpp
State.cpp State.cpp
Stream.cpp
StreamAsynchronousIO.cpp StreamAsynchronousIO.cpp
StreamCallback.cpp StreamCallback.cpp
StreamFile.cpp StreamFile.cpp
StreamGDBRemote.cpp StreamGDBRemote.cpp
StreamString.cpp
StringList.cpp StringList.cpp
StructuredData.cpp StructuredData.cpp
Timer.cpp Timer.cpp
Context not available.

lldb/source/Core/ConstString.cpp

  • This file was deleted.
//===-- ConstString.cpp -----------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "lldb/Core/ConstString.h"
// C Includes
// C++ Includes
#include <array>
#include <mutex>
// Other libraries and framework includes
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringMap.h"
#include "llvm/Support/RWMutex.h"
// Project includes
#include "lldb/Core/Stream.h"
using namespace lldb_private;
class Pool {
public:
typedef const char *StringPoolValueType;
typedef llvm::StringMap<StringPoolValueType, llvm::BumpPtrAllocator>
StringPool;
typedef llvm::StringMapEntry<StringPoolValueType> StringPoolEntryType;
static StringPoolEntryType &
GetStringMapEntryFromKeyData(const char *keyData) {
char *ptr = const_cast<char *>(keyData) - sizeof(StringPoolEntryType);
return *reinterpret_cast<StringPoolEntryType *>(ptr);
}
size_t GetConstCStringLength(const char *ccstr) const {
if (ccstr != nullptr) {
const uint8_t h = hash(llvm::StringRef(ccstr));
llvm::sys::SmartScopedReader<false> rlock(m_string_pools[h].m_mutex);
const StringPoolEntryType &entry = GetStringMapEntryFromKeyData(ccstr);
return entry.getKey().size();
}
return 0;
}
StringPoolValueType GetMangledCounterpart(const char *ccstr) const {
if (ccstr != nullptr) {
const uint8_t h = hash(llvm::StringRef(ccstr));
llvm::sys::SmartScopedReader<false> rlock(m_string_pools[h].m_mutex);
return GetStringMapEntryFromKeyData(ccstr).getValue();
}
return nullptr;
}
bool SetMangledCounterparts(const char *key_ccstr, const char *value_ccstr) {
if (key_ccstr != nullptr && value_ccstr != nullptr) {
{
const uint8_t h = hash(llvm::StringRef(key_ccstr));
llvm::sys::SmartScopedWriter<false> wlock(m_string_pools[h].m_mutex);
GetStringMapEntryFromKeyData(key_ccstr).setValue(value_ccstr);
}
{
const uint8_t h = hash(llvm::StringRef(value_ccstr));
llvm::sys::SmartScopedWriter<false> wlock(m_string_pools[h].m_mutex);
GetStringMapEntryFromKeyData(value_ccstr).setValue(key_ccstr);
}
return true;
}
return false;
}
const char *GetConstCString(const char *cstr) {
if (cstr != nullptr)
return GetConstCStringWithLength(cstr, strlen(cstr));
return nullptr;
}
const char *GetConstCStringWithLength(const char *cstr, size_t cstr_len) {
if (cstr != nullptr)
return GetConstCStringWithStringRef(llvm::StringRef(cstr, cstr_len));
return nullptr;
}
const char *GetConstCStringWithStringRef(const llvm::StringRef &string_ref) {
if (string_ref.data()) {
const uint8_t h = hash(string_ref);
{
llvm::sys::SmartScopedReader<false> rlock(m_string_pools[h].m_mutex);
auto it = m_string_pools[h].m_string_map.find(string_ref);
if (it != m_string_pools[h].m_string_map.end())
return it->getKeyData();
}
llvm::sys::SmartScopedWriter<false> wlock(m_string_pools[h].m_mutex);
StringPoolEntryType &entry =
*m_string_pools[h]
.m_string_map.insert(std::make_pair(string_ref, nullptr))
.first;
return entry.getKeyData();
}
return nullptr;
}
const char *
GetConstCStringAndSetMangledCounterPart(const char *demangled_cstr,
const char *mangled_ccstr) {
if (demangled_cstr != nullptr) {
const char *demangled_ccstr = nullptr;
{
llvm::StringRef string_ref(demangled_cstr);
const uint8_t h = hash(string_ref);
llvm::sys::SmartScopedWriter<false> wlock(m_string_pools[h].m_mutex);
// Make string pool entry with the mangled counterpart already set
StringPoolEntryType &entry =
*m_string_pools[h]
.m_string_map.insert(std::make_pair(string_ref, mangled_ccstr))
.first;
// Extract the const version of the demangled_cstr
demangled_ccstr = entry.getKeyData();
}
{
// Now assign the demangled const string as the counterpart of the
// mangled const string...
const uint8_t h = hash(llvm::StringRef(mangled_ccstr));
llvm::sys::SmartScopedWriter<false> wlock(m_string_pools[h].m_mutex);
GetStringMapEntryFromKeyData(mangled_ccstr).setValue(demangled_ccstr);
}
// Return the constant demangled C string
return demangled_ccstr;
}
return nullptr;
}
const char *GetConstTrimmedCStringWithLength(const char *cstr,
size_t cstr_len) {
if (cstr != nullptr) {
const size_t trimmed_len = std::min<size_t>(strlen(cstr), cstr_len);
return GetConstCStringWithLength(cstr, trimmed_len);
}
return nullptr;
}
//------------------------------------------------------------------
// Return the size in bytes that this object and any items in its
// collection of uniqued strings + data count values takes in
// memory.
//------------------------------------------------------------------
size_t MemorySize() const {
size_t mem_size = sizeof(Pool);
for (const auto &pool : m_string_pools) {
llvm::sys::SmartScopedReader<false> rlock(pool.m_mutex);
for (const auto &entry : pool.m_string_map)
mem_size += sizeof(StringPoolEntryType) + entry.getKey().size();
}
return mem_size;
}
protected:
uint8_t hash(const llvm::StringRef &s) const {
uint32_t h = llvm::HashString(s);
return ((h >> 24) ^ (h >> 16) ^ (h >> 8) ^ h) & 0xff;
}
struct PoolEntry {
mutable llvm::sys::SmartRWMutex<false> m_mutex;
StringPool m_string_map;
};
std::array<PoolEntry, 256> m_string_pools;
};
//----------------------------------------------------------------------
// Frameworks and dylibs aren't supposed to have global C++
// initializers so we hide the string pool in a static function so
// that it will get initialized on the first call to this static
// function.
//
// Note, for now we make the string pool a pointer to the pool, because
// we can't guarantee that some objects won't get destroyed after the
// global destructor chain is run, and trying to make sure no destructors
// touch ConstStrings is difficult. So we leak the pool instead.
//----------------------------------------------------------------------
static Pool &StringPool() {
static std::once_flag g_pool_initialization_flag;
static Pool *g_string_pool = nullptr;
std::call_once(g_pool_initialization_flag,
[]() { g_string_pool = new Pool(); });
return *g_string_pool;
}
ConstString::ConstString(const char *cstr)
: m_string(StringPool().GetConstCString(cstr)) {}
ConstString::ConstString(const char *cstr, size_t cstr_len)
: m_string(StringPool().GetConstCStringWithLength(cstr, cstr_len)) {}
ConstString::ConstString(const llvm::StringRef &s)
: m_string(StringPool().GetConstCStringWithLength(s.data(), s.size())) {}
bool ConstString::operator<(const ConstString &rhs) const {
if (m_string == rhs.m_string)
return false;
llvm::StringRef lhs_string_ref(m_string,
StringPool().GetConstCStringLength(m_string));
llvm::StringRef rhs_string_ref(
rhs.m_string, StringPool().GetConstCStringLength(rhs.m_string));
// If both have valid C strings, then return the comparison
if (lhs_string_ref.data() && rhs_string_ref.data())
return lhs_string_ref < rhs_string_ref;
// Else one of them was nullptr, so if LHS is nullptr then it is less than
return lhs_string_ref.data() == nullptr;
}
Stream &lldb_private::operator<<(Stream &s, const ConstString &str) {
const char *cstr = str.GetCString();
if (cstr != nullptr)
s << cstr;
return s;
}
size_t ConstString::GetLength() const {
return StringPool().GetConstCStringLength(m_string);
}
bool ConstString::Equals(const ConstString &lhs, const ConstString &rhs,
const bool case_sensitive) {
if (lhs.m_string == rhs.m_string)
return true;
// Since the pointers weren't equal, and identical ConstStrings always have
// identical pointers,
// the result must be false for case sensitive equality test.
if (case_sensitive)
return false;
// perform case insensitive equality test
llvm::StringRef lhs_string_ref(
lhs.m_string, StringPool().GetConstCStringLength(lhs.m_string));
llvm::StringRef rhs_string_ref(
rhs.m_string, StringPool().GetConstCStringLength(rhs.m_string));
return lhs_string_ref.equals_lower(rhs_string_ref);
}
int ConstString::Compare(const ConstString &lhs, const ConstString &rhs,
const bool case_sensitive) {
// If the iterators are the same, this is the same string
const char *lhs_cstr = lhs.m_string;
const char *rhs_cstr = rhs.m_string;
if (lhs_cstr == rhs_cstr)
return 0;
if (lhs_cstr && rhs_cstr) {
llvm::StringRef lhs_string_ref(
lhs_cstr, StringPool().GetConstCStringLength(lhs_cstr));
llvm::StringRef rhs_string_ref(
rhs_cstr, StringPool().GetConstCStringLength(rhs_cstr));
if (case_sensitive) {
return lhs_string_ref.compare(rhs_string_ref);
} else {
return lhs_string_ref.compare_lower(rhs_string_ref);
}
}
if (lhs_cstr)
return +1; // LHS isn't nullptr but RHS is
else
return -1; // LHS is nullptr but RHS isn't
}
void ConstString::Dump(Stream *s, const char *fail_value) const {
if (s != nullptr) {
const char *cstr = AsCString(fail_value);
if (cstr != nullptr)
s->PutCString(cstr);
}
}
void ConstString::DumpDebug(Stream *s) const {
const char *cstr = GetCString();
size_t cstr_len = GetLength();
// Only print the parens if we have a non-nullptr string
const char *parens = cstr ? "\"" : "";
s->Printf("%*p: ConstString, string = %s%s%s, length = %" PRIu64,
static_cast<int>(sizeof(void *) * 2),
static_cast<const void *>(this), parens, cstr, parens,
static_cast<uint64_t>(cstr_len));
}
void ConstString::SetCString(const char *cstr) {
m_string = StringPool().GetConstCString(cstr);
}
void ConstString::SetString(const llvm::StringRef &s) {
m_string = StringPool().GetConstCStringWithLength(s.data(), s.size());
}
void ConstString::SetCStringWithMangledCounterpart(const char *demangled,
const ConstString &mangled) {
m_string = StringPool().GetConstCStringAndSetMangledCounterPart(
demangled, mangled.m_string);
}
bool ConstString::GetMangledCounterpart(ConstString &counterpart) const {
counterpart.m_string = StringPool().GetMangledCounterpart(m_string);
return (bool)counterpart;
}
void ConstString::SetCStringWithLength(const char *cstr, size_t cstr_len) {
m_string = StringPool().GetConstCStringWithLength(cstr, cstr_len);
}
void ConstString::SetTrimmedCStringWithLength(const char *cstr,
size_t cstr_len) {
m_string = StringPool().GetConstTrimmedCStringWithLength(cstr, cstr_len);
}
size_t ConstString::StaticMemorySize() {
// Get the size of the static string pool
return StringPool().MemorySize();
}

lldb/source/Core/DataBufferMemoryMap.cpp

Context not available.
// Project includes // Project includes
#include "lldb/Core/DataBufferMemoryMap.h" #include "lldb/Core/DataBufferMemoryMap.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Host/File.h" #include "lldb/Host/File.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
#include "lldb/Host/HostInfo.h" #include "lldb/Host/HostInfo.h"
#include "lldb/Utility/Error.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Core/DataExtractor.cpp

Context not available.
#include "lldb/Core/DataExtractor.h" #include "lldb/Core/DataExtractor.h"
#include "lldb/Core/Disassembler.h" #include "lldb/Core/Disassembler.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/UUID.h" #include "lldb/Core/UUID.h"
#include "lldb/Core/dwarf.h" #include "lldb/Core/dwarf.h"
#include "lldb/Host/Endian.h" #include "lldb/Host/Endian.h"
Context not available.
#include "lldb/Target/ExecutionContextScope.h" #include "lldb/Target/ExecutionContextScope.h"
#include "lldb/Target/SectionLoadList.h" #include "lldb/Target/SectionLoadList.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Core/Debugger.cpp

Context not available.
#include "lldb/Core/StreamAsynchronousIO.h" #include "lldb/Core/StreamAsynchronousIO.h"
#include "lldb/Core/StreamCallback.h" #include "lldb/Core/StreamCallback.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/StructuredData.h" #include "lldb/Core/StructuredData.h"
#include "lldb/Core/Timer.h" #include "lldb/Core/Timer.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
Context not available.
#include "lldb/Target/TargetList.h" #include "lldb/Target/TargetList.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/AnsiTerminal.h" #include "lldb/Utility/AnsiTerminal.h"
#include "lldb/Utility/StreamString.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
using namespace lldb; using namespace lldb;
Context not available.

lldb/source/Core/Disassembler.cpp

Context not available.
#include "lldb/Core/DataExtractor.h" #include "lldb/Core/DataExtractor.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/EmulateInstruction.h" #include "lldb/Core/EmulateInstruction.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/RegularExpression.h"
#include "lldb/Core/Timer.h" #include "lldb/Core/Timer.h"
#include "lldb/Host/FileSystem.h" #include "lldb/Host/FileSystem.h"
#include "lldb/Interpreter/OptionValue.h" #include "lldb/Interpreter/OptionValue.h"
Context not available.
#include "lldb/Target/SectionLoadList.h" #include "lldb/Target/SectionLoadList.h"
#include "lldb/Target/StackFrame.h" #include "lldb/Target/StackFrame.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/RegularExpression.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
#define DEFAULT_DISASM_BYTE_SIZE 32 #define DEFAULT_DISASM_BYTE_SIZE 32
Context not available.

lldb/source/Core/EmulateInstruction.cpp

Context not available.
// Project includes // Project includes
#include "lldb/Core/Address.h" #include "lldb/Core/Address.h"
#include "lldb/Core/DataExtractor.h" #include "lldb/Core/DataExtractor.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/RegisterValue.h" #include "lldb/Core/RegisterValue.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Host/Endian.h" #include "lldb/Host/Endian.h"
#include "lldb/Symbol/UnwindPlan.h" #include "lldb/Symbol/UnwindPlan.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h" #include "lldb/Target/RegisterContext.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Core/Error.cpp

  • This file was deleted.
//===-- Error.cpp -----------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// C Includes
#ifdef __APPLE__
#include <mach/mach.h>
#endif
// C++ Includes
#include <cerrno>
#include <cstdarg>
// Other libraries and framework includes
#include "llvm/ADT/SmallVector.h"
// Project includes
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h"
#include "lldb/Host/PosixApi.h"
using namespace lldb;
using namespace lldb_private;
Error::Error() : m_code(0), m_type(eErrorTypeInvalid), m_string() {}
Error::Error(ValueType err, ErrorType type)
: m_code(err), m_type(type), m_string() {}
Error::Error(const Error &rhs) = default;
Error::Error(const char *format, ...)
: m_code(0), m_type(eErrorTypeInvalid), m_string() {
va_list args;
va_start(args, format);
SetErrorToGenericError();
SetErrorStringWithVarArg(format, args);
va_end(args);
}
//----------------------------------------------------------------------
// Assignment operator
//----------------------------------------------------------------------
const Error &Error::operator=(const Error &rhs) {
if (this != &rhs) {
m_code = rhs.m_code;
m_type = rhs.m_type;
m_string = rhs.m_string;
}
return *this;
}
//----------------------------------------------------------------------
// Assignment operator
//----------------------------------------------------------------------
const Error &Error::operator=(uint32_t err) {
m_code = err;
m_type = eErrorTypeMachKernel;
m_string.clear();
return *this;
}
Error::~Error() = default;
//----------------------------------------------------------------------
// Get the error value as a NULL C string. The error string will be
// fetched and cached on demand. The cached error string value will
// remain until the error value is changed or cleared.
//----------------------------------------------------------------------
const char *Error::AsCString(const char *default_error_str) const {
if (Success())
return nullptr;
if (m_string.empty()) {
const char *s = nullptr;
switch (m_type) {
case eErrorTypeMachKernel:
#if defined(__APPLE__)
s = ::mach_error_string(m_code);
#endif
break;
case eErrorTypePOSIX:
s = ::strerror(m_code);
break;
default:
break;
}
if (s != nullptr)
m_string.assign(s);
}
if (m_string.empty()) {
if (default_error_str)
m_string.assign(default_error_str);
else
return nullptr; // User wanted a nullptr string back...
}
return m_string.c_str();
}
//----------------------------------------------------------------------
// Clear the error and any cached error string that it might contain.
//----------------------------------------------------------------------
void Error::Clear() {
m_code = 0;
m_type = eErrorTypeInvalid;
m_string.clear();
}
//----------------------------------------------------------------------
// Access the error value.
//----------------------------------------------------------------------
Error::ValueType Error::GetError() const { return m_code; }
//----------------------------------------------------------------------
// Access the error type.
//----------------------------------------------------------------------
ErrorType Error::GetType() const { return m_type; }
//----------------------------------------------------------------------
// Returns true if this object contains a value that describes an
// error or otherwise non-success result.
//----------------------------------------------------------------------
bool Error::Fail() const { return m_code != 0; }
//----------------------------------------------------------------------
// Log the error given a string with format. If the this object
// contains an error code, update the error string to contain the
// "error: " followed by the formatted string, followed by the error
// value and any string that describes the current error. This
// allows more context to be given to an error string that remains
// cached in this object. Logging always occurs even when the error
// code contains a non-error value.
//----------------------------------------------------------------------
void Error::PutToLog(Log *log, const char *format, ...) {
char *arg_msg = nullptr;
va_list args;
va_start(args, format);
::vasprintf(&arg_msg, format, args);
va_end(args);
if (arg_msg != nullptr) {
if (Fail()) {
const char *err_str = AsCString();
if (err_str == nullptr)
err_str = "???";
SetErrorStringWithFormat("error: %s err = %s (0x%8.8x)", arg_msg, err_str,
m_code);
if (log != nullptr)
log->Error("%s", m_string.c_str());
} else {
if (log != nullptr)
log->Printf("%s err = 0x%8.8x", arg_msg, m_code);
}
::free(arg_msg);
}
}
//----------------------------------------------------------------------
// Log the error given a string with format. If the this object
// contains an error code, update the error string to contain the
// "error: " followed by the formatted string, followed by the error
// value and any string that describes the current error. This
// allows more context to be given to an error string that remains
// cached in this object. Logging only occurs even when the error
// code contains a error value.
//----------------------------------------------------------------------
void Error::LogIfError(Log *log, const char *format, ...) {
if (Fail()) {
char *arg_msg = nullptr;
va_list args;
va_start(args, format);
::vasprintf(&arg_msg, format, args);
va_end(args);
if (arg_msg != nullptr) {
const char *err_str = AsCString();
if (err_str == nullptr)
err_str = "???";
SetErrorStringWithFormat("%s err = %s (0x%8.8x)", arg_msg, err_str,
m_code);
if (log != nullptr)
log->Error("%s", m_string.c_str());
::free(arg_msg);
}
}
}
//----------------------------------------------------------------------
// Set accesssor for the error value to "err" and the type to
// "eErrorTypeMachKernel"
//----------------------------------------------------------------------
void Error::SetMachError(uint32_t err) {
m_code = err;
m_type = eErrorTypeMachKernel;
m_string.clear();
}
void Error::SetExpressionError(lldb::ExpressionResults result,
const char *mssg) {
m_code = result;
m_type = eErrorTypeExpression;
m_string = mssg;
}
int Error::SetExpressionErrorWithFormat(lldb::ExpressionResults result,
const char *format, ...) {
int length = 0;
if (format != nullptr && format[0]) {
va_list args;
va_start(args, format);
length = SetErrorStringWithVarArg(format, args);
va_end(args);
} else {
m_string.clear();
}
m_code = result;
m_type = eErrorTypeExpression;
return length;
}
//----------------------------------------------------------------------
// Set accesssor for the error value and type.
//----------------------------------------------------------------------
void Error::SetError(ValueType err, ErrorType type) {
m_code = err;
m_type = type;
m_string.clear();
}
//----------------------------------------------------------------------
// Update the error value to be "errno" and update the type to
// be "POSIX".
//----------------------------------------------------------------------
void Error::SetErrorToErrno() {
m_code = errno;
m_type = eErrorTypePOSIX;
m_string.clear();
}
//----------------------------------------------------------------------
// Update the error value to be LLDB_GENERIC_ERROR and update the type
// to be "Generic".
//----------------------------------------------------------------------
void Error::SetErrorToGenericError() {
m_code = LLDB_GENERIC_ERROR;
m_type = eErrorTypeGeneric;
m_string.clear();
}
//----------------------------------------------------------------------
// Set accessor for the error string value for a specific error.
// This allows any string to be supplied as an error explanation.
// The error string value will remain until the error value is
// cleared or a new error value/type is assigned.
//----------------------------------------------------------------------
void Error::SetErrorString(llvm::StringRef err_str) {
if (!err_str.empty()) {
// If we have an error string, we should always at least have an error
// set to a generic value.
if (Success())
SetErrorToGenericError();
}
m_string = err_str;
}
//------------------------------------------------------------------
/// Set the current error string to a formatted error string.
///
/// @param format
/// A printf style format string
//------------------------------------------------------------------
int Error::SetErrorStringWithFormat(const char *format, ...) {
if (format != nullptr && format[0]) {
va_list args;
va_start(args, format);
int length = SetErrorStringWithVarArg(format, args);
va_end(args);
return length;
} else {
m_string.clear();
}
return 0;
}
int Error::SetErrorStringWithVarArg(const char *format, va_list args) {
if (format != nullptr && format[0]) {
// If we have an error string, we should always at least have
// an error set to a generic value.
if (Success())
SetErrorToGenericError();
// Try and fit our error into a 1024 byte buffer first...
llvm::SmallVector<char, 1024> buf;
buf.resize(1024);
// Copy in case our first call to vsnprintf doesn't fit into our
// allocated buffer above
va_list copy_args;
va_copy(copy_args, args);
unsigned length = ::vsnprintf(buf.data(), buf.size(), format, args);
if (length >= buf.size()) {
// The error formatted string didn't fit into our buffer, resize it
// to the exact needed size, and retry
buf.resize(length + 1);
length = ::vsnprintf(buf.data(), buf.size(), format, copy_args);
va_end(copy_args);
assert(length < buf.size());
}
m_string.assign(buf.data(), length);
va_end(args);
return length;
} else {
m_string.clear();
}
return 0;
}
//----------------------------------------------------------------------
// Returns true if the error code in this object is considered a
// successful return value.
//----------------------------------------------------------------------
bool Error::Success() const { return m_code == 0; }
bool Error::WasInterrupted() const {
return (m_type == eErrorTypePOSIX && m_code == EINTR);
}

lldb/source/Core/Event.cpp

Context not available.
#include "lldb/Core/Event.h" #include "lldb/Core/Event.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/State.h" #include "lldb/Core/State.h"
#include "lldb/Core/Stream.h"
#include "lldb/Host/Endian.h" #include "lldb/Host/Endian.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Core/FileLineResolver.cpp

Context not available.
// Project includes // Project includes
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Symbol/CompileUnit.h" #include "lldb/Symbol/CompileUnit.h"
#include "lldb/Symbol/LineTable.h" #include "lldb/Symbol/LineTable.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Core/FileSpecList.cpp

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/Stream.h" #include "lldb/Utility/Stream.h"
using namespace lldb_private; using namespace lldb_private;
using namespace std; using namespace std;
Context not available.

lldb/source/Core/FormatEntity.cpp

Context not available.
#include "lldb/Core/Address.h" #include "lldb/Core/Address.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/Core/ValueObjectVariable.h" #include "lldb/Core/ValueObjectVariable.h"
#include "lldb/DataFormatters/DataVisualization.h" #include "lldb/DataFormatters/DataVisualization.h"
Context not available.
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/AnsiTerminal.h" #include "lldb/Utility/AnsiTerminal.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Core/History.cpp

Context not available.
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/Stream.h" #include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Core/Listener.cpp

Context not available.
#include "lldb/Core/Broadcaster.h" #include "lldb/Core/Broadcaster.h"
#include "lldb/Core/Event.h" #include "lldb/Core/Event.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/StreamString.h" #include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Core/Log.cpp

Context not available.
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Host/ThisThread.h" #include "lldb/Host/ThisThread.h"
#include "lldb/Interpreter/Args.h" #include "lldb/Interpreter/Args.h"
#include "lldb/Utility/NameMatches.h" #include "lldb/Utility/NameMatches.h"
#include "lldb/Utility/StreamString.h"
// Other libraries and framework includes // Other libraries and framework includes
#include "llvm/ADT/SmallString.h" #include "llvm/ADT/SmallString.h"
Context not available.

lldb/source/Core/Mangled.cpp

Context not available.
#include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h" #include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
#include "Plugins/Language/ObjC/ObjCLanguage.h" #include "Plugins/Language/ObjC/ObjCLanguage.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Logging.h" #include "lldb/Core/Logging.h"
#include "lldb/Core/Mangled.h" #include "lldb/Core/Mangled.h"
#include "lldb/Core/RegularExpression.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/Timer.h" #include "lldb/Core/Timer.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/RegularExpression.h"
#include "lldb/Utility/Stream.h"
#include <ctype.h> #include <ctype.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
Context not available.

lldb/source/Core/Module.cpp

Context not available.
#include "lldb/Core/AddressResolverFileLine.h" #include "lldb/Core/AddressResolverFileLine.h"
#include "lldb/Core/DataBuffer.h" #include "lldb/Core/DataBuffer.h"
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/ModuleList.h" #include "lldb/Core/ModuleList.h"
#include "lldb/Core/ModuleSpec.h" #include "lldb/Core/ModuleSpec.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/RegularExpression.h"
#include "lldb/Core/Section.h" #include "lldb/Core/Section.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/Timer.h" #include "lldb/Core/Timer.h"
#include "lldb/Host/FileSystem.h" #include "lldb/Host/FileSystem.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
Context not available.
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/SectionLoadList.h" #include "lldb/Target/SectionLoadList.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/RegularExpression.h"
#include "lldb/Utility/StreamString.h"
#include "Plugins/ObjectFile/JIT/ObjectFileJIT.h" #include "Plugins/ObjectFile/JIT/ObjectFileJIT.h"
Context not available.

lldb/source/Core/Opcode.cpp

Context not available.
#include "lldb/Core/ArchSpec.h" #include "lldb/Core/ArchSpec.h"
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/DataExtractor.h" #include "lldb/Core/DataExtractor.h"
#include "lldb/Core/Stream.h"
#include "lldb/Host/Endian.h" #include "lldb/Host/Endian.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Core/PluginManager.cpp

Context not available.
// Project includes // Project includes
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/Error.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Host/HostInfo.h" #include "lldb/Host/HostInfo.h"
#include "lldb/Interpreter/OptionValueProperties.h" #include "lldb/Interpreter/OptionValueProperties.h"
#include "lldb/Utility/Error.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Core/RegisterValue.cpp

Context not available.
// Project includes // Project includes
#include "lldb/Core/DataExtractor.h" #include "lldb/Core/DataExtractor.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Scalar.h" #include "lldb/Core/Scalar.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Host/StringConvert.h" #include "lldb/Host/StringConvert.h"
#include "lldb/Interpreter/Args.h" #include "lldb/Interpreter/Args.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Core/RegularExpression.cpp

  • This file was deleted.
//===-- RegularExpression.cpp -----------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "lldb/Core/RegularExpression.h"
// C Includes
// C++ Includes
#include <cstring>
// Other libraries and framework includes
#include "llvm/ADT/StringRef.h"
// Project includes
#include "lldb/Core/Error.h"
//----------------------------------------------------------------------
// Enable enhanced mode if it is available. This allows for things like
// \d for digit, \s for space, and many more, but it isn't available
// everywhere.
//----------------------------------------------------------------------
#if defined(REG_ENHANCED)
#define DEFAULT_COMPILE_FLAGS (REG_ENHANCED | REG_EXTENDED)
#else
#define DEFAULT_COMPILE_FLAGS (REG_EXTENDED)
#endif
using namespace lldb_private;
RegularExpression::RegularExpression() : m_re(), m_comp_err(1), m_preg() {
memset(&m_preg, 0, sizeof(m_preg));
}
//----------------------------------------------------------------------
// Constructor that compiles "re" using "flags" and stores the
// resulting compiled regular expression into this object.
//----------------------------------------------------------------------
RegularExpression::RegularExpression(llvm::StringRef str)
: m_re(), m_comp_err(1), m_preg() {
memset(&m_preg, 0, sizeof(m_preg));
Compile(str);
}
RegularExpression::RegularExpression(const RegularExpression &rhs) {
memset(&m_preg, 0, sizeof(m_preg));
Compile(rhs.GetText());
}
const RegularExpression &RegularExpression::
operator=(const RegularExpression &rhs) {
if (&rhs != this)
Compile(rhs.GetText());
return *this;
}
//----------------------------------------------------------------------
// Destructor
//
// Any previously compiled regular expression contained in this
// object will be freed.
//----------------------------------------------------------------------
RegularExpression::~RegularExpression() { Free(); }
//----------------------------------------------------------------------
// Compile a regular expression using the supplied regular
// expression text and flags. The compiled regular expression lives
// in this object so that it can be readily used for regular
// expression matches. Execute() can be called after the regular
// expression is compiled. Any previously compiled regular
// expression contained in this object will be freed.
//
// RETURNS
// True if the regular expression compiles successfully, false
// otherwise.
//----------------------------------------------------------------------
bool RegularExpression::Compile(llvm::StringRef str) {
Free();
if (!str.empty()) {
m_re = str;
m_comp_err = ::regcomp(&m_preg, m_re.c_str(), DEFAULT_COMPILE_FLAGS);
} else {
// No valid regular expression
m_comp_err = 1;
}
return m_comp_err == 0;
}
//----------------------------------------------------------------------
// Execute a regular expression match using the compiled regular
// expression that is already in this object against the match
// string "s". If any parens are used for regular expression
// matches "match_count" should indicate the number of regmatch_t
// values that are present in "match_ptr". The regular expression
// will be executed using the "execute_flags".
//---------------------------------------------------------------------
bool RegularExpression::Execute(llvm::StringRef str, Match *match) const {
int err = 1;
if (m_comp_err == 0) {
// Argument to regexec must be null-terminated.
std::string reg_str = str;
if (match) {
err = ::regexec(&m_preg, reg_str.c_str(), match->GetSize(),
match->GetData(), 0);
} else {
err = ::regexec(&m_preg, reg_str.c_str(), 0, nullptr, 0);
}
}
if (err != 0) {
// The regular expression didn't compile, so clear the matches
if (match)
match->Clear();
return false;
}
return true;
}
bool RegularExpression::Match::GetMatchAtIndex(llvm::StringRef s, uint32_t idx,
std::string &match_str) const {
llvm::StringRef match_str_ref;
if (GetMatchAtIndex(s, idx, match_str_ref)) {
match_str = match_str_ref.str();
return true;
}
return false;
}
bool RegularExpression::Match::GetMatchAtIndex(
llvm::StringRef s, uint32_t idx, llvm::StringRef &match_str) const {
if (idx < m_matches.size()) {
if (m_matches[idx].rm_eo == -1 && m_matches[idx].rm_so == -1)
return false;
if (m_matches[idx].rm_eo == m_matches[idx].rm_so) {
// Matched the empty string...
match_str = llvm::StringRef();
return true;
} else if (m_matches[idx].rm_eo > m_matches[idx].rm_so) {
match_str = s.substr(m_matches[idx].rm_so,
m_matches[idx].rm_eo - m_matches[idx].rm_so);
return true;
}
}
return false;
}
bool RegularExpression::Match::GetMatchSpanningIndices(
llvm::StringRef s, uint32_t idx1, uint32_t idx2,
llvm::StringRef &match_str) const {
if (idx1 < m_matches.size() && idx2 < m_matches.size()) {
if (m_matches[idx1].rm_so == m_matches[idx2].rm_eo) {
// Matched the empty string...
match_str = llvm::StringRef();
return true;
} else if (m_matches[idx1].rm_so < m_matches[idx2].rm_eo) {
match_str = s.substr(m_matches[idx1].rm_so,
m_matches[idx2].rm_eo - m_matches[idx1].rm_so);
return true;
}
}
return false;
}
//----------------------------------------------------------------------
// Returns true if the regular expression compiled and is ready
// for execution.
//----------------------------------------------------------------------
bool RegularExpression::IsValid() const { return m_comp_err == 0; }
//----------------------------------------------------------------------
// Returns the text that was used to compile the current regular
// expression.
//----------------------------------------------------------------------
llvm::StringRef RegularExpression::GetText() const { return m_re; }
//----------------------------------------------------------------------
// Free any contained compiled regular expressions.
//----------------------------------------------------------------------
void RegularExpression::Free() {
if (m_comp_err == 0) {
m_re.clear();
regfree(&m_preg);
// Set a compile error since we no longer have a valid regex
m_comp_err = 1;
}
}
size_t RegularExpression::GetErrorAsCString(char *err_str,
size_t err_str_max_len) const {
if (m_comp_err == 0) {
if (err_str && err_str_max_len)
*err_str = '\0';
return 0;
}
return ::regerror(m_comp_err, &m_preg, err_str, err_str_max_len);
}
bool RegularExpression::operator<(const RegularExpression &rhs) const {
return (m_re < rhs.m_re);
}

lldb/source/Core/Scalar.cpp

Context not available.
// Project includes // Project includes
#include "lldb/Core/DataExtractor.h" #include "lldb/Core/DataExtractor.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Stream.h"
#include "lldb/Host/Endian.h" #include "lldb/Host/Endian.h"
#include "lldb/Host/StringConvert.h" #include "lldb/Host/StringConvert.h"
#include "lldb/Interpreter/Args.h" #include "lldb/Interpreter/Args.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/Stream.h"
#include "Plugins/Process/Utility/InstructionUtils.h" #include "Plugins/Process/Utility/InstructionUtils.h"
Context not available.

lldb/source/Core/SourceManager.cpp

Context not available.
#include "lldb/Core/DataBuffer.h" #include "lldb/Core/DataBuffer.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/RegularExpression.h"
#include "lldb/Core/Stream.h"
#include "lldb/Host/FileSystem.h" #include "lldb/Host/FileSystem.h"
#include "lldb/Symbol/CompileUnit.h" #include "lldb/Symbol/CompileUnit.h"
#include "lldb/Symbol/Function.h" #include "lldb/Symbol/Function.h"
#include "lldb/Symbol/SymbolContext.h" #include "lldb/Symbol/SymbolContext.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/AnsiTerminal.h" #include "lldb/Utility/AnsiTerminal.h"
#include "lldb/Utility/RegularExpression.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Core/Stream.cpp

  • This file was deleted.
//===-- Stream.cpp ----------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "lldb/Core/Stream.h"
#include "lldb/Host/Endian.h"
#include "lldb/Host/PosixApi.h"
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <inttypes.h>
using namespace lldb;
using namespace lldb_private;
Stream::Stream(uint32_t flags, uint32_t addr_size, ByteOrder byte_order)
: m_flags(flags), m_addr_size(addr_size), m_byte_order(byte_order),
m_indent_level(0) {}
Stream::Stream()
: m_flags(0), m_addr_size(4), m_byte_order(endian::InlHostByteOrder()),
m_indent_level(0) {}
//------------------------------------------------------------------
// Destructor
//------------------------------------------------------------------
Stream::~Stream() {}
ByteOrder Stream::SetByteOrder(ByteOrder byte_order) {
ByteOrder old_byte_order = m_byte_order;
m_byte_order = byte_order;
return old_byte_order;
}
//------------------------------------------------------------------
// Put an offset "uval" out to the stream using the printf format
// in "format".
//------------------------------------------------------------------
void Stream::Offset(uint32_t uval, const char *format) { Printf(format, uval); }
//------------------------------------------------------------------
// Put an SLEB128 "uval" out to the stream using the printf format
// in "format".
//------------------------------------------------------------------
size_t Stream::PutSLEB128(int64_t sval) {
size_t bytes_written = 0;
if (m_flags.Test(eBinary)) {
bool more = true;
while (more) {
uint8_t byte = sval & 0x7fu;
sval >>= 7;
/* sign bit of byte is 2nd high order bit (0x40) */
if ((sval == 0 && !(byte & 0x40)) || (sval == -1 && (byte & 0x40)))
more = false;
else
// more bytes to come
byte |= 0x80u;
bytes_written += Write(&byte, 1);
}
} else {
bytes_written = Printf("0x%" PRIi64, sval);
}
return bytes_written;
}
//------------------------------------------------------------------
// Put an ULEB128 "uval" out to the stream using the printf format
// in "format".
//------------------------------------------------------------------
size_t Stream::PutULEB128(uint64_t uval) {
size_t bytes_written = 0;
if (m_flags.Test(eBinary)) {
do {
uint8_t byte = uval & 0x7fu;
uval >>= 7;
if (uval != 0) {
// more bytes to come
byte |= 0x80u;
}
bytes_written += Write(&byte, 1);
} while (uval != 0);
} else {
bytes_written = Printf("0x%" PRIx64, uval);
}
return bytes_written;
}
//------------------------------------------------------------------
// Print a raw NULL terminated C string to the stream.
//------------------------------------------------------------------
size_t Stream::PutCString(llvm::StringRef str) {
size_t bytes_written = 0;
bytes_written = Write(str.data(), str.size());
// when in binary mode, emit the NULL terminator
if (m_flags.Test(eBinary))
bytes_written += PutChar('\0');
return bytes_written;
}
//------------------------------------------------------------------
// Print a double quoted NULL terminated C string to the stream
// using the printf format in "format".
//------------------------------------------------------------------
void Stream::QuotedCString(const char *cstr, const char *format) {
Printf(format, cstr);
}
//------------------------------------------------------------------
// Put an address "addr" out to the stream with optional prefix
// and suffix strings.
//------------------------------------------------------------------
void Stream::Address(uint64_t addr, uint32_t addr_size, const char *prefix,
const char *suffix) {
if (prefix == NULL)
prefix = "";
if (suffix == NULL)
suffix = "";
// int addr_width = m_addr_size << 1;
// Printf ("%s0x%0*" PRIx64 "%s", prefix, addr_width, addr, suffix);
Printf("%s0x%0*" PRIx64 "%s", prefix, addr_size * 2, (uint64_t)addr, suffix);
}
//------------------------------------------------------------------
// Put an address range out to the stream with optional prefix
// and suffix strings.
//------------------------------------------------------------------
void Stream::AddressRange(uint64_t lo_addr, uint64_t hi_addr,
uint32_t addr_size, const char *prefix,
const char *suffix) {
if (prefix && prefix[0])
PutCString(prefix);
Address(lo_addr, addr_size, "[");
Address(hi_addr, addr_size, "-", ")");
if (suffix && suffix[0])
PutCString(suffix);
}
size_t Stream::PutChar(char ch) { return Write(&ch, 1); }
//------------------------------------------------------------------
// Print some formatted output to the stream.
//------------------------------------------------------------------
size_t Stream::Printf(const char *format, ...) {
va_list args;
va_start(args, format);
size_t result = PrintfVarArg(format, args);
va_end(args);
return result;
}
//------------------------------------------------------------------
// Print some formatted output to the stream.
//------------------------------------------------------------------
size_t Stream::PrintfVarArg(const char *format, va_list args) {
char str[1024];
va_list args_copy;
va_copy(args_copy, args);
size_t bytes_written = 0;
// Try and format our string into a fixed buffer first and see if it fits
size_t length = ::vsnprintf(str, sizeof(str), format, args);
if (length < sizeof(str)) {
// Include the NULL termination byte for binary output
if (m_flags.Test(eBinary))
length += 1;
// The formatted string fit into our stack based buffer, so we can just
// append that to our packet
bytes_written = Write(str, length);
} else {
// Our stack buffer wasn't big enough to contain the entire formatted
// string, so lets let vasprintf create the string for us!
char *str_ptr = NULL;
length = ::vasprintf(&str_ptr, format, args_copy);
if (str_ptr) {
// Include the NULL termination byte for binary output
if (m_flags.Test(eBinary))
length += 1;
bytes_written = Write(str_ptr, length);
::free(str_ptr);
}
}
va_end(args_copy);
return bytes_written;
}
//------------------------------------------------------------------
// Print and End of Line character to the stream
//------------------------------------------------------------------
size_t Stream::EOL() { return PutChar('\n'); }
//------------------------------------------------------------------
// Indent the current line using the current indentation level and
// print an optional string following the indentation spaces.
//------------------------------------------------------------------
size_t Stream::Indent(const char *s) {
return Printf("%*.*s%s", m_indent_level, m_indent_level, "", s ? s : "");
}
size_t Stream::Indent(llvm::StringRef str) {
return Printf("%*.*s%s", m_indent_level, m_indent_level, "", str.str().c_str());
}
//------------------------------------------------------------------
// Stream a character "ch" out to this stream.
//------------------------------------------------------------------
Stream &Stream::operator<<(char ch) {
PutChar(ch);
return *this;
}
//------------------------------------------------------------------
// Stream the NULL terminated C string out to this stream.
//------------------------------------------------------------------
Stream &Stream::operator<<(const char *s) {
Printf("%s", s);
return *this;
}
Stream &Stream::operator<<(llvm::StringRef str) {
Write(str.data(), str.size());
return *this;
}
//------------------------------------------------------------------
// Stream the pointer value out to this stream.
//------------------------------------------------------------------
Stream &Stream::operator<<(const void *p) {
Printf("0x%.*tx", (int)sizeof(const void *) * 2, (ptrdiff_t)p);
return *this;
}
//------------------------------------------------------------------
// Stream a uint8_t "uval" out to this stream.
//------------------------------------------------------------------
Stream &Stream::operator<<(uint8_t uval) {
PutHex8(uval);
return *this;
}
//------------------------------------------------------------------
// Stream a uint16_t "uval" out to this stream.
//------------------------------------------------------------------
Stream &Stream::operator<<(uint16_t uval) {
PutHex16(uval, m_byte_order);
return *this;
}
//------------------------------------------------------------------
// Stream a uint32_t "uval" out to this stream.
//------------------------------------------------------------------
Stream &Stream::operator<<(uint32_t uval) {
PutHex32(uval, m_byte_order);
return *this;
}
//------------------------------------------------------------------
// Stream a uint64_t "uval" out to this stream.
//------------------------------------------------------------------
Stream &Stream::operator<<(uint64_t uval) {
PutHex64(uval, m_byte_order);
return *this;
}
//------------------------------------------------------------------
// Stream a int8_t "sval" out to this stream.
//------------------------------------------------------------------
Stream &Stream::operator<<(int8_t sval) {
Printf("%i", (int)sval);
return *this;
}
//------------------------------------------------------------------
// Stream a int16_t "sval" out to this stream.
//------------------------------------------------------------------
Stream &Stream::operator<<(int16_t sval) {
Printf("%i", (int)sval);
return *this;
}
//------------------------------------------------------------------
// Stream a int32_t "sval" out to this stream.
//------------------------------------------------------------------
Stream &Stream::operator<<(int32_t sval) {
Printf("%i", (int)sval);
return *this;
}
//------------------------------------------------------------------
// Stream a int64_t "sval" out to this stream.
//------------------------------------------------------------------
Stream &Stream::operator<<(int64_t sval) {
Printf("%" PRIi64, sval);
return *this;
}
//------------------------------------------------------------------
// Get the current indentation level
//------------------------------------------------------------------
int Stream::GetIndentLevel() const { return m_indent_level; }
//------------------------------------------------------------------
// Set the current indentation level
//------------------------------------------------------------------
void Stream::SetIndentLevel(int indent_level) { m_indent_level = indent_level; }
//------------------------------------------------------------------
// Increment the current indentation level
//------------------------------------------------------------------
void Stream::IndentMore(int amount) { m_indent_level += amount; }
//------------------------------------------------------------------
// Decrement the current indentation level
//------------------------------------------------------------------
void Stream::IndentLess(int amount) {
if (m_indent_level >= amount)
m_indent_level -= amount;
else
m_indent_level = 0;
}
//------------------------------------------------------------------
// Get the address size in bytes
//------------------------------------------------------------------
uint32_t Stream::GetAddressByteSize() const { return m_addr_size; }
//------------------------------------------------------------------
// Set the address size in bytes
//------------------------------------------------------------------
void Stream::SetAddressByteSize(uint32_t addr_size) { m_addr_size = addr_size; }
//------------------------------------------------------------------
// The flags get accessor
//------------------------------------------------------------------
Flags &Stream::GetFlags() { return m_flags; }
//------------------------------------------------------------------
// The flags const get accessor
//------------------------------------------------------------------
const Flags &Stream::GetFlags() const { return m_flags; }
//------------------------------------------------------------------
// The byte order get accessor
//------------------------------------------------------------------
lldb::ByteOrder Stream::GetByteOrder() const { return m_byte_order; }
size_t Stream::PrintfAsRawHex8(const char *format, ...) {
va_list args;
va_list args_copy;
va_start(args, format);
va_copy(args_copy, args); // Copy this so we
char str[1024];
size_t bytes_written = 0;
// Try and format our string into a fixed buffer first and see if it fits
size_t length = ::vsnprintf(str, sizeof(str), format, args);
if (length < sizeof(str)) {
// The formatted string fit into our stack based buffer, so we can just
// append that to our packet
for (size_t i = 0; i < length; ++i)
bytes_written += _PutHex8(str[i], false);
} else {
// Our stack buffer wasn't big enough to contain the entire formatted
// string, so lets let vasprintf create the string for us!
char *str_ptr = NULL;
length = ::vasprintf(&str_ptr, format, args_copy);
if (str_ptr) {
for (size_t i = 0; i < length; ++i)
bytes_written += _PutHex8(str_ptr[i], false);
::free(str_ptr);
}
}
va_end(args);
va_end(args_copy);
return bytes_written;
}
size_t Stream::PutNHex8(size_t n, uint8_t uvalue) {
size_t bytes_written = 0;
for (size_t i = 0; i < n; ++i)
bytes_written += _PutHex8(uvalue, false);
return bytes_written;
}
size_t Stream::_PutHex8(uint8_t uvalue, bool add_prefix) {
size_t bytes_written = 0;
if (m_flags.Test(eBinary)) {
bytes_written = Write(&uvalue, 1);
} else {
if (add_prefix)
PutCString("0x");
static char g_hex_to_ascii_hex_char[16] = {'0', '1', '2', '3', '4', '5',
'6', '7', '8', '9', 'a', 'b',
'c', 'd', 'e', 'f'};
char nibble_chars[2];
nibble_chars[0] = g_hex_to_ascii_hex_char[(uvalue >> 4) & 0xf];
nibble_chars[1] = g_hex_to_ascii_hex_char[(uvalue >> 0) & 0xf];
bytes_written = Write(nibble_chars, sizeof(nibble_chars));
}
return bytes_written;
}
size_t Stream::PutHex8(uint8_t uvalue) { return _PutHex8(uvalue, false); }
size_t Stream::PutHex16(uint16_t uvalue, ByteOrder byte_order) {
if (byte_order == eByteOrderInvalid)
byte_order = m_byte_order;
size_t bytes_written = 0;
if (byte_order == eByteOrderLittle) {
for (size_t byte = 0; byte < sizeof(uvalue); ++byte)
bytes_written += _PutHex8((uint8_t)(uvalue >> (byte * 8)), false);
} else {
for (size_t byte = sizeof(uvalue) - 1; byte < sizeof(uvalue); --byte)
bytes_written += _PutHex8((uint8_t)(uvalue >> (byte * 8)), false);
}
return bytes_written;
}
size_t Stream::PutHex32(uint32_t uvalue, ByteOrder byte_order) {
if (byte_order == eByteOrderInvalid)
byte_order = m_byte_order;
size_t bytes_written = 0;
if (byte_order == eByteOrderLittle) {
for (size_t byte = 0; byte < sizeof(uvalue); ++byte)
bytes_written += _PutHex8((uint8_t)(uvalue >> (byte * 8)), false);
} else {
for (size_t byte = sizeof(uvalue) - 1; byte < sizeof(uvalue); --byte)
bytes_written += _PutHex8((uint8_t)(uvalue >> (byte * 8)), false);
}
return bytes_written;
}
size_t Stream::PutHex64(uint64_t uvalue, ByteOrder byte_order) {
if (byte_order == eByteOrderInvalid)
byte_order = m_byte_order;
size_t bytes_written = 0;
if (byte_order == eByteOrderLittle) {
for (size_t byte = 0; byte < sizeof(uvalue); ++byte)
bytes_written += _PutHex8((uint8_t)(uvalue >> (byte * 8)), false);
} else {
for (size_t byte = sizeof(uvalue) - 1; byte < sizeof(uvalue); --byte)
bytes_written += _PutHex8((uint8_t)(uvalue >> (byte * 8)), false);
}
return bytes_written;
}
size_t Stream::PutMaxHex64(uint64_t uvalue, size_t byte_size,
lldb::ByteOrder byte_order) {
switch (byte_size) {
case 1:
return PutHex8((uint8_t)uvalue);
case 2:
return PutHex16((uint16_t)uvalue);
case 4:
return PutHex32((uint32_t)uvalue);
case 8:
return PutHex64(uvalue);
}
return 0;
}
size_t Stream::PutPointer(void *ptr) {
return PutRawBytes(&ptr, sizeof(ptr), endian::InlHostByteOrder(),
endian::InlHostByteOrder());
}
size_t Stream::PutFloat(float f, ByteOrder byte_order) {
if (byte_order == eByteOrderInvalid)
byte_order = m_byte_order;
return PutRawBytes(&f, sizeof(f), endian::InlHostByteOrder(), byte_order);
}
size_t Stream::PutDouble(double d, ByteOrder byte_order) {
if (byte_order == eByteOrderInvalid)
byte_order = m_byte_order;
return PutRawBytes(&d, sizeof(d), endian::InlHostByteOrder(), byte_order);
}
size_t Stream::PutLongDouble(long double ld, ByteOrder byte_order) {
if (byte_order == eByteOrderInvalid)
byte_order = m_byte_order;
return PutRawBytes(&ld, sizeof(ld), endian::InlHostByteOrder(), byte_order);
}
size_t Stream::PutRawBytes(const void *s, size_t src_len,
ByteOrder src_byte_order, ByteOrder dst_byte_order) {
if (src_byte_order == eByteOrderInvalid)
src_byte_order = m_byte_order;
if (dst_byte_order == eByteOrderInvalid)
dst_byte_order = m_byte_order;
size_t bytes_written = 0;
const uint8_t *src = (const uint8_t *)s;
bool binary_was_set = m_flags.Test(eBinary);
if (!binary_was_set)
m_flags.Set(eBinary);
if (src_byte_order == dst_byte_order) {
for (size_t i = 0; i < src_len; ++i)
bytes_written += _PutHex8(src[i], false);
} else {
for (size_t i = src_len - 1; i < src_len; --i)
bytes_written += _PutHex8(src[i], false);
}
if (!binary_was_set)
m_flags.Clear(eBinary);
return bytes_written;
}
size_t Stream::PutBytesAsRawHex8(const void *s, size_t src_len,
ByteOrder src_byte_order,
ByteOrder dst_byte_order) {
if (src_byte_order == eByteOrderInvalid)
src_byte_order = m_byte_order;
if (dst_byte_order == eByteOrderInvalid)
dst_byte_order = m_byte_order;
size_t bytes_written = 0;
const uint8_t *src = (const uint8_t *)s;
bool binary_is_set = m_flags.Test(eBinary);
m_flags.Clear(eBinary);
if (src_byte_order == dst_byte_order) {
for (size_t i = 0; i < src_len; ++i)
bytes_written += _PutHex8(src[i], false);
} else {
for (size_t i = src_len - 1; i < src_len; --i)
bytes_written += _PutHex8(src[i], false);
}
if (binary_is_set)
m_flags.Set(eBinary);
return bytes_written;
}
size_t Stream::PutCStringAsRawHex8(const char *s) {
size_t bytes_written = 0;
bool binary_is_set = m_flags.Test(eBinary);
m_flags.Clear(eBinary);
do {
bytes_written += _PutHex8(*s, false);
++s;
} while (*s);
if (binary_is_set)
m_flags.Set(eBinary);
return bytes_written;
}
void Stream::UnitTest(Stream *s) {
s->PutHex8(0x12);
s->PutChar(' ');
s->PutHex16(0x3456, endian::InlHostByteOrder());
s->PutChar(' ');
s->PutHex16(0x3456, eByteOrderBig);
s->PutChar(' ');
s->PutHex16(0x3456, eByteOrderLittle);
s->PutChar(' ');
s->PutHex32(0x789abcde, endian::InlHostByteOrder());
s->PutChar(' ');
s->PutHex32(0x789abcde, eByteOrderBig);
s->PutChar(' ');
s->PutHex32(0x789abcde, eByteOrderLittle);
s->PutChar(' ');
s->PutHex64(0x1122334455667788ull, endian::InlHostByteOrder());
s->PutChar(' ');
s->PutHex64(0x1122334455667788ull, eByteOrderBig);
s->PutChar(' ');
s->PutHex64(0x1122334455667788ull, eByteOrderLittle);
const char *hola = "Hello World!!!";
s->PutChar(' ');
s->PutCString(hola);
s->PutChar(' ');
s->Write(hola, 5);
s->PutChar(' ');
s->PutCStringAsRawHex8(hola);
s->PutChar(' ');
s->PutCStringAsRawHex8("01234");
s->PutChar(' ');
s->Printf("pid=%i", 12733);
s->PutChar(' ');
s->PrintfAsRawHex8("pid=%i", 12733);
s->PutChar('\n');
}

lldb/source/Core/StreamFile.cpp

Context not available.
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/Error.h" #include "lldb/Utility/Error.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Core/StreamString.cpp

  • This file was deleted.
//===-- StreamString.cpp ----------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "lldb/Core/StreamString.h"
#include <stdio.h>
using namespace lldb;
using namespace lldb_private;
StreamString::StreamString() : Stream(0, 4, eByteOrderBig) {}
StreamString::StreamString(uint32_t flags, uint32_t addr_size,
ByteOrder byte_order)
: Stream(flags, addr_size, byte_order), m_packet() {}
StreamString::~StreamString() {}
void StreamString::Flush() {
// Nothing to do when flushing a buffer based stream...
}
size_t StreamString::Write(const void *s, size_t length) {
m_packet.append(reinterpret_cast<const char *>(s), length);
return length;
}
void StreamString::Clear() { m_packet.clear(); }
bool StreamString::Empty() const { return GetSize() == 0; }
size_t StreamString::GetSize() const { return m_packet.size(); }
size_t StreamString::GetSizeOfLastLine() const {
const size_t length = m_packet.size();
size_t last_line_begin_pos = m_packet.find_last_of("\r\n");
if (last_line_begin_pos == std::string::npos) {
return length;
} else {
++last_line_begin_pos;
return length - last_line_begin_pos;
}
}
llvm::StringRef StreamString::GetString() const { return m_packet; }
void StreamString::FillLastLineToColumn(uint32_t column, char fill_char) {
const size_t length = m_packet.size();
size_t last_line_begin_pos = m_packet.find_last_of("\r\n");
if (last_line_begin_pos == std::string::npos) {
last_line_begin_pos = 0;
} else {
++last_line_begin_pos;
}
const size_t line_columns = length - last_line_begin_pos;
if (column > line_columns) {
m_packet.append(column - line_columns, fill_char);
}
}

lldb/source/Core/StringList.cpp

Context not available.
#include "lldb/Core/StringList.h" #include "lldb/Core/StringList.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
#include "lldb/Utility/StreamString.h"
#include <string> #include <string>
Context not available.

lldb/source/Core/StructuredData.cpp

Context not available.
#include <stdlib.h> #include <stdlib.h>
#include "lldb/Core/DataBuffer.h" #include "lldb/Core/DataBuffer.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Host/File.h" #include "lldb/Host/File.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
#include "lldb/Host/StringConvert.h" #include "lldb/Host/StringConvert.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/JSON.h" #include "lldb/Utility/JSON.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Core/Timer.cpp

Context not available.
#include <mutex> #include <mutex>
#include <vector> #include <vector>
#include "lldb/Core/Stream.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Utility/Stream.h"
#include <stdio.h> #include <stdio.h>
Context not available.

lldb/source/Core/UUID.cpp

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/Stream.h" #include "lldb/Utility/Stream.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/source/Core/UserID.cpp

Context not available.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Core/UserID.h" #include "lldb/Core/UserID.h"
#include "lldb/Core/Stream.h" #include "lldb/Utility/Stream.h"
#include <inttypes.h> #include <inttypes.h>
Context not available.

lldb/source/Core/UserSettingsController.cpp

Context not available.
#include <algorithm> #include <algorithm>
#include <string.h> #include <string.h>
#include "lldb/Core/Error.h"
#include "lldb/Core/RegularExpression.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/UserSettingsController.h" #include "lldb/Core/UserSettingsController.h"
#include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Interpreter/OptionValueProperties.h" #include "lldb/Interpreter/OptionValueProperties.h"
#include "lldb/Interpreter/OptionValueString.h" #include "lldb/Interpreter/OptionValueString.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/RegularExpression.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Core/VMRange.cpp

Context not available.
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/VMRange.h" #include "lldb/Core/VMRange.h"
#include "lldb/Utility/Stream.h"
#include <algorithm> #include <algorithm>
using namespace lldb; using namespace lldb;
Context not available.

lldb/source/Core/Value.cpp

Context not available.
#include "lldb/Core/DataExtractor.h" #include "lldb/Core/DataExtractor.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/State.h" #include "lldb/Core/State.h"
#include "lldb/Core/Stream.h"
#include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/ClangASTContext.h"
#include "lldb/Symbol/CompilerType.h" #include "lldb/Symbol/CompilerType.h"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
Context not available.
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/SectionLoadList.h" #include "lldb/Target/SectionLoadList.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Core/ValueObject.cpp

Context not available.
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/ValueObjectCast.h" #include "lldb/Core/ValueObjectCast.h"
#include "lldb/Core/ValueObjectChild.h" #include "lldb/Core/ValueObjectChild.h"
#include "lldb/Core/ValueObjectConstResult.h" #include "lldb/Core/ValueObjectConstResult.h"
Context not available.
#include "lldb/Core/ValueObjectList.h" #include "lldb/Core/ValueObjectList.h"
#include "lldb/Core/ValueObjectMemory.h" #include "lldb/Core/ValueObjectMemory.h"
#include "lldb/Core/ValueObjectSyntheticFilter.h" #include "lldb/Core/ValueObjectSyntheticFilter.h"
#include "lldb/Utility/StreamString.h"
#include "lldb/DataFormatters/DataVisualization.h" #include "lldb/DataFormatters/DataVisualization.h"
#include "lldb/DataFormatters/StringPrinter.h" #include "lldb/DataFormatters/StringPrinter.h"
Context not available.

lldb/source/DataFormatters/CXXFunctionPointer.cpp

Context not available.
#include "lldb/DataFormatters/CXXFunctionPointer.h" #include "lldb/DataFormatters/CXXFunctionPointer.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/Target/SectionLoadList.h" #include "lldb/Target/SectionLoadList.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Stream.h"
#include <string> #include <string>
Context not available.

lldb/source/DataFormatters/FormattersHelpers.cpp

Context not available.
// Project includes // Project includes
#include "lldb/DataFormatters/FormattersHelpers.h" #include "lldb/DataFormatters/FormattersHelpers.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/RegularExpression.h"
#include "lldb/Target/StackFrame.h" #include "lldb/Target/StackFrame.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/RegularExpression.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/DataFormatters/StringPrinter.cpp

Context not available.
#include "lldb/DataFormatters/StringPrinter.h" #include "lldb/DataFormatters/StringPrinter.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/Target/Language.h" #include "lldb/Target/Language.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Error.h"
#include "llvm/Support/ConvertUTF.h" #include "llvm/Support/ConvertUTF.h"
Context not available.

lldb/source/DataFormatters/TypeFormat.cpp

Context not available.
#include "lldb/lldb-enumerations.h" #include "lldb/lldb-enumerations.h"
#include "lldb/lldb-public.h" #include "lldb/lldb-public.h"
#include "lldb/Core/StreamString.h"
#include "lldb/DataFormatters/FormatManager.h" #include "lldb/DataFormatters/FormatManager.h"
#include "lldb/Symbol/CompilerType.h" #include "lldb/Symbol/CompilerType.h"
#include "lldb/Symbol/SymbolContext.h" #include "lldb/Symbol/SymbolContext.h"
#include "lldb/Symbol/SymbolFile.h" #include "lldb/Symbol/SymbolFile.h"
#include "lldb/Symbol/TypeList.h" #include "lldb/Symbol/TypeList.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/DataFormatters/TypeSummary.cpp

Context not available.
#include "lldb/lldb-public.h" #include "lldb/lldb-public.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/DataFormatters/ValueObjectPrinter.h" #include "lldb/DataFormatters/ValueObjectPrinter.h"
#include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Symbol/CompilerType.h" #include "lldb/Symbol/CompilerType.h"
#include "lldb/Target/StackFrame.h" #include "lldb/Target/StackFrame.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/DataFormatters/TypeSynthetic.cpp

Context not available.
#include "lldb/lldb-public.h" #include "lldb/lldb-public.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/StreamString.h"
#include "lldb/DataFormatters/TypeSynthetic.h" #include "lldb/DataFormatters/TypeSynthetic.h"
#include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Interpreter/ScriptInterpreter.h" #include "lldb/Interpreter/ScriptInterpreter.h"
#include "lldb/Symbol/CompilerType.h" #include "lldb/Symbol/CompilerType.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/DataFormatters/TypeValidator.cpp

Context not available.
// Project includes // Project includes
#include "lldb/DataFormatters/TypeValidator.h" #include "lldb/DataFormatters/TypeValidator.h"
#include "lldb/Core/StreamString.h" #include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/DataFormatters/ValueObjectPrinter.cpp

Context not available.
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/Stream.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/DataFormatters/DataVisualization.h" #include "lldb/DataFormatters/DataVisualization.h"
#include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Target/Language.h" #include "lldb/Target/Language.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Expression/DWARFExpression.cpp

Context not available.
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/RegisterValue.h" #include "lldb/Core/RegisterValue.h"
#include "lldb/Core/Scalar.h" #include "lldb/Core/Scalar.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/VMRange.h" #include "lldb/Core/VMRange.h"
#include "lldb/Core/Value.h" #include "lldb/Core/Value.h"
#include "lldb/Core/dwarf.h" #include "lldb/Core/dwarf.h"
#include "lldb/Utility/StreamString.h"
#include "Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.h" #include "Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.h"
#include "Plugins/ExpressionParser/Clang/ClangExpressionVariable.h" #include "Plugins/ExpressionParser/Clang/ClangExpressionVariable.h"
Context not available.

lldb/source/Expression/DiagnosticManager.cpp

Context not available.
#include "llvm/Support/ErrorHandling.h" #include "llvm/Support/ErrorHandling.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/StreamString.h" #include "lldb/Utility/StreamString.h"
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Expression/ExpressionSourceCode.cpp

Context not available.
#include "Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.h" #include "Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.h"
#include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h" #include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Symbol/Block.h" #include "lldb/Symbol/Block.h"
#include "lldb/Symbol/CompileUnit.h" #include "lldb/Symbol/CompileUnit.h"
#include "lldb/Symbol/DebugMacros.h" #include "lldb/Symbol/DebugMacros.h"
Context not available.
#include "lldb/Target/Platform.h" #include "lldb/Target/Platform.h"
#include "lldb/Target/StackFrame.h" #include "lldb/Target/StackFrame.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Expression/IRDynamicChecks.cpp

Context not available.
// Project includes // Project includes
#include "lldb/Expression/IRDynamicChecks.h" #include "lldb/Expression/IRDynamicChecks.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Expression/UtilityFunction.h" #include "lldb/Expression/UtilityFunction.h"
#include "lldb/Target/ExecutionContext.h" #include "lldb/Target/ExecutionContext.h"
Context not available.
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/StackFrame.h" #include "lldb/Target/StackFrame.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/ConstString.h"
using namespace llvm; using namespace llvm;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Expression/IRInterpreter.cpp

Context not available.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Expression/IRInterpreter.h" #include "lldb/Expression/IRInterpreter.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/DataExtractor.h" #include "lldb/Core/DataExtractor.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/ModuleSpec.h" #include "lldb/Core/ModuleSpec.h"
#include "lldb/Core/Scalar.h" #include "lldb/Core/Scalar.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/Expression/DiagnosticManager.h" #include "lldb/Expression/DiagnosticManager.h"
#include "lldb/Expression/IRExecutionUnit.h" #include "lldb/Expression/IRExecutionUnit.h"
#include "lldb/Expression/IRMemoryMap.h" #include "lldb/Expression/IRMemoryMap.h"
#include "lldb/Host/Endian.h" #include "lldb/Host/Endian.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/StreamString.h"
#include "lldb/Target/ABI.h" #include "lldb/Target/ABI.h"
#include "lldb/Target/ExecutionContext.h" #include "lldb/Target/ExecutionContext.h"
Context not available.

lldb/source/Expression/IRMemoryMap.cpp

Context not available.
#include "lldb/Expression/IRMemoryMap.h" #include "lldb/Expression/IRMemoryMap.h"
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/DataExtractor.h" #include "lldb/Core/DataExtractor.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Scalar.h" #include "lldb/Core/Scalar.h"
#include "lldb/Target/MemoryRegionInfo.h" #include "lldb/Target/MemoryRegionInfo.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/LLDBAssert.h" #include "lldb/Utility/LLDBAssert.h"
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Expression/LLVMUserExpression.cpp

Context not available.
// Project includes // Project includes
#include "lldb/Expression/LLVMUserExpression.h" #include "lldb/Expression/LLVMUserExpression.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/ValueObjectConstResult.h" #include "lldb/Core/ValueObjectConstResult.h"
#include "lldb/Expression/DiagnosticManager.h" #include "lldb/Expression/DiagnosticManager.h"
#include "lldb/Expression/ExpressionSourceCode.h" #include "lldb/Expression/ExpressionSourceCode.h"
Context not available.
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/ThreadPlan.h" #include "lldb/Target/ThreadPlan.h"
#include "lldb/Target/ThreadPlanCallUserExpression.h" #include "lldb/Target/ThreadPlanCallUserExpression.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Expression/UserExpression.cpp

Context not available.
#include <string> #include <string>
#include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h" #include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/ValueObjectConstResult.h" #include "lldb/Core/ValueObjectConstResult.h"
#include "lldb/Expression/DiagnosticManager.h" #include "lldb/Expression/DiagnosticManager.h"
#include "lldb/Expression/ExpressionSourceCode.h" #include "lldb/Expression/ExpressionSourceCode.h"
Context not available.
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/ThreadPlan.h" #include "lldb/Target/ThreadPlan.h"
#include "lldb/Target/ThreadPlanCallUserExpression.h" #include "lldb/Target/ThreadPlanCallUserExpression.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Expression/UtilityFunction.cpp

Context not available.
// C++ Includes // C++ Includes
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Expression/DiagnosticManager.h" #include "lldb/Expression/DiagnosticManager.h"
#include "lldb/Expression/ExpressionSourceCode.h" #include "lldb/Expression/ExpressionSourceCode.h"
Context not available.
#include "lldb/Target/ExecutionContext.h" #include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Stream.h"
using namespace lldb_private; using namespace lldb_private;
using namespace lldb; using namespace lldb;
Context not available.

lldb/source/Host/common/Editline.cpp

Context not available.
#include <iostream> #include <iostream>
#include <limits.h> #include <limits.h>
#include "lldb/Core/Error.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/StringList.h" #include "lldb/Core/StringList.h"
#include "lldb/Host/ConnectionFileDescriptor.h" #include "lldb/Host/ConnectionFileDescriptor.h"
#include "lldb/Host/Editline.h" #include "lldb/Host/Editline.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
#include "lldb/Host/FileSystem.h" #include "lldb/Host/FileSystem.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/LLDBAssert.h" #include "lldb/Utility/LLDBAssert.h"
#include "lldb/Utility/SelectHelper.h" #include "lldb/Utility/SelectHelper.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb_private; using namespace lldb_private;
using namespace lldb_private::line_editor; using namespace lldb_private::line_editor;
Context not available.

lldb/source/Host/common/File.cpp

Context not available.
#include "llvm/Support/Process.h" // for llvm::sys::Process::FileDescriptorHasColors() #include "llvm/Support/Process.h" // for llvm::sys::Process::FileDescriptorHasColors()
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Host/Config.h" #include "lldb/Host/Config.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
#include "lldb/Host/FileSystem.h" #include "lldb/Host/FileSystem.h"
#include "lldb/Utility/Error.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Host/common/FileSpec.cpp

Context not available.
#include "lldb/Core/ArchSpec.h" #include "lldb/Core/ArchSpec.h"
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/DataBufferMemoryMap.h" #include "lldb/Core/DataBufferMemoryMap.h"
#include "lldb/Core/RegularExpression.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Host/File.h" #include "lldb/Host/File.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
#include "lldb/Host/FileSystem.h" #include "lldb/Host/FileSystem.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Utility/CleanUp.h" #include "lldb/Utility/CleanUp.h"
#include "lldb/Utility/RegularExpression.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Utility/StreamString.h"
#include "llvm/ADT/StringExtras.h" #include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
Context not available.

lldb/source/Host/common/Host.cpp

Context not available.
// Project includes // Project includes
#include "lldb/Core/ArchSpec.h" #include "lldb/Core/ArchSpec.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
#include "lldb/Host/FileSystem.h" #include "lldb/Host/FileSystem.h"
Context not available.
#include "lldb/Target/ProcessLaunchInfo.h" #include "lldb/Target/ProcessLaunchInfo.h"
#include "lldb/Target/UnixSignals.h" #include "lldb/Target/UnixSignals.h"
#include "lldb/Utility/CleanUp.h" #include "lldb/Utility/CleanUp.h"
#include "lldb/Utility/Error.h"
#include "lldb/lldb-private-forward.h" #include "lldb/lldb-private-forward.h"
#include "llvm/ADT/SmallString.h" #include "llvm/ADT/SmallString.h"
#include "llvm/Support/FileSystem.h" #include "llvm/Support/FileSystem.h"
Context not available.

lldb/source/Host/common/HostInfoBase.cpp

Context not available.
#include "lldb/Core/ArchSpec.h" #include "lldb/Core/ArchSpec.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Host/FileSystem.h" #include "lldb/Host/FileSystem.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Host/HostInfo.h" #include "lldb/Host/HostInfo.h"
#include "lldb/Host/HostInfoBase.h" #include "lldb/Host/HostInfoBase.h"
#include "lldb/Utility/StreamString.h"
#include "llvm/ADT/StringExtras.h" #include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/Triple.h" #include "llvm/ADT/Triple.h"
Context not available.

lldb/source/Host/common/MonitoringProcessLauncher.cpp

Context not available.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Host/MonitoringProcessLauncher.h" #include "lldb/Host/MonitoringProcessLauncher.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/ModuleSpec.h" #include "lldb/Core/ModuleSpec.h"
Context not available.
#include "lldb/Target/Platform.h" #include "lldb/Target/Platform.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/ProcessLaunchInfo.h" #include "lldb/Target/ProcessLaunchInfo.h"
#include "lldb/Utility/Error.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Host/common/NativeBreakpoint.cpp

Context not available.
#include "lldb/Host/common/NativeBreakpoint.h" #include "lldb/Host/common/NativeBreakpoint.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Utility/Error.h"
#include "lldb/lldb-defines.h" #include "lldb/lldb-defines.h"
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Host/common/Socket.cpp

Context not available.
#include "lldb/Host/Socket.h" #include "lldb/Host/Socket.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/RegularExpression.h"
#include "lldb/Host/Config.h" #include "lldb/Host/Config.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Host/SocketAddress.h" #include "lldb/Host/SocketAddress.h"
#include "lldb/Host/StringConvert.h" #include "lldb/Host/StringConvert.h"
#include "lldb/Host/common/TCPSocket.h" #include "lldb/Host/common/TCPSocket.h"
#include "lldb/Host/common/UDPSocket.h" #include "lldb/Host/common/UDPSocket.h"
#include "lldb/Utility/RegularExpression.h"
#ifndef LLDB_DISABLE_POSIX #ifndef LLDB_DISABLE_POSIX
#include "lldb/Host/posix/DomainSocket.h" #include "lldb/Host/posix/DomainSocket.h"
Context not available.

lldb/source/Host/common/SoftwareBreakpoint.cpp

Context not available.
#include "lldb/Host/common/SoftwareBreakpoint.h" #include "lldb/Host/common/SoftwareBreakpoint.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Host/Debug.h" #include "lldb/Host/Debug.h"
#include "lldb/Utility/Error.h"
#include "lldb/Host/common/NativeProcessProtocol.h" #include "lldb/Host/common/NativeProcessProtocol.h"
Context not available.

lldb/source/Host/common/Symbols.cpp

Context not available.
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/ModuleSpec.h" #include "lldb/Core/ModuleSpec.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/Timer.h" #include "lldb/Core/Timer.h"
#include "lldb/Core/UUID.h" #include "lldb/Core/UUID.h"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/SafeMachO.h" #include "lldb/Utility/SafeMachO.h"
#include "lldb/Utility/StreamString.h"
#include "llvm/Support/FileSystem.h" #include "llvm/Support/FileSystem.h"
Context not available.

lldb/source/Host/common/ThisThread.cpp

Context not available.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Host/ThisThread.h" #include "lldb/Host/ThisThread.h"
#include "lldb/Core/Error.h"
#include "lldb/Host/HostInfo.h" #include "lldb/Host/HostInfo.h"
#include "lldb/Utility/Error.h"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
Context not available.

lldb/source/Host/freebsd/Host.cpp

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/DataExtractor.h" #include "lldb/Core/DataExtractor.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Host/Endian.h" #include "lldb/Host/Endian.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Host/HostInfo.h" #include "lldb/Host/HostInfo.h"
#include "lldb/Target/Platform.h" #include "lldb/Target/Platform.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/StreamString.h"
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/DataExtractor.h" #include "lldb/Core/DataExtractor.h"
Context not available.

lldb/source/Host/linux/Host.cpp

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
#include "llvm/Support/ScopedPrinter.h" #include "llvm/Support/ScopedPrinter.h"
// Project includes // Project includes
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Utility/Error.h"
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/DataExtractor.h" #include "lldb/Core/DataExtractor.h"
Context not available.

lldb/source/Host/macosx/Symbols.cpp

Context not available.
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/ModuleSpec.h" #include "lldb/Core/ModuleSpec.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/Timer.h" #include "lldb/Core/Timer.h"
#include "lldb/Core/UUID.h" #include "lldb/Core/UUID.h"
#include "lldb/Host/Endian.h" #include "lldb/Host/Endian.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
#include "lldb/Utility/CleanUp.h" #include "lldb/Utility/CleanUp.h"
#include "lldb/Utility/StreamString.h"
#include "mach/machine.h" #include "mach/machine.h"
using namespace lldb; using namespace lldb;
Context not available.

lldb/source/Host/netbsd/Host.cpp

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/DataExtractor.h" #include "lldb/Core/DataExtractor.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Host/Endian.h" #include "lldb/Host/Endian.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Host/HostInfo.h" #include "lldb/Host/HostInfo.h"
#include "lldb/Target/Platform.h" #include "lldb/Target/Platform.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/StreamString.h"
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/DataExtractor.h" #include "lldb/Core/DataExtractor.h"
Context not available.

lldb/source/Host/posix/ConnectionFileDescriptorPosix.cpp

Context not available.
// Project includes // Project includes
#include "lldb/Core/Communication.h" #include "lldb/Core/Communication.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/Timer.h" #include "lldb/Core/Timer.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Host/Socket.h" #include "lldb/Host/Socket.h"
#include "lldb/Host/common/TCPSocket.h" #include "lldb/Host/common/TCPSocket.h"
#include "lldb/Interpreter/Args.h" #include "lldb/Interpreter/Args.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Host/posix/FileSystem.cpp

Context not available.
#endif #endif
// lldb Includes // lldb Includes
#include "lldb/Core/Error.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Host/posix/HostThreadPosix.cpp

Context not available.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Host/posix/HostThreadPosix.h" #include "lldb/Host/posix/HostThreadPosix.h"
#include "lldb/Core/Error.h" #include "lldb/Utility/Error.h"
#include <errno.h> #include <errno.h>
#include <pthread.h> #include <pthread.h>
Context not available.

lldb/source/Host/posix/MainLoopPosix.cpp

Context not available.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Host/posix/MainLoopPosix.h" #include "lldb/Host/posix/MainLoopPosix.h"
#include "lldb/Core/Error.h" #include "lldb/Utility/Error.h"
#include <algorithm> #include <algorithm>
#include <cassert> #include <cassert>
#include <cerrno> #include <cerrno>
#include <csignal> #include <csignal>
#include <vector>
#include <sys/select.h> #include <sys/select.h>
#include <vector>
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Host/windows/ConnectionGenericFileWindows.cpp

Context not available.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Host/windows/ConnectionGenericFileWindows.h" #include "lldb/Host/windows/ConnectionGenericFileWindows.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Utility/Error.h"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
Context not available.

lldb/source/Host/windows/Host.cpp

Context not available.
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Utility/Error.h"
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/DataExtractor.h" #include "lldb/Core/DataExtractor.h"
Context not available.

lldb/source/Host/windows/HostThreadWindows.cpp

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Core/Error.h" #include "lldb/Utility/Error.h"
#include "lldb/Host/windows/HostThreadWindows.h" #include "lldb/Host/windows/HostThreadWindows.h"
#include "lldb/Host/windows/windows.h" #include "lldb/Host/windows/windows.h"
Context not available.

lldb/source/Host/windows/ThisThread.cpp

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Core/Error.h" #include "lldb/Utility/Error.h"
#include "lldb/Host/ThisThread.h" #include "lldb/Host/ThisThread.h"
#include "lldb/Host/windows/windows.h" #include "lldb/Host/windows/windows.h"
Context not available.

lldb/source/Interpreter/Args.cpp

Context not available.
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/Stream.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Core/StreamString.h"
#include "lldb/DataFormatters/FormatManager.h" #include "lldb/DataFormatters/FormatManager.h"
#include "lldb/Host/StringConvert.h" #include "lldb/Host/StringConvert.h"
#include "lldb/Interpreter/Args.h" #include "lldb/Interpreter/Args.h"
Context not available.
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/StackFrame.h" #include "lldb/Target/StackFrame.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Utility/StreamString.h"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/StringExtras.h" #include "llvm/ADT/StringExtras.h"
Context not available.

lldb/source/Interpreter/CommandAlias.cpp

Context not available.
#include "llvm/Support/ErrorHandling.h" #include "llvm/Support/ErrorHandling.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Interpreter/CommandObject.h" #include "lldb/Interpreter/CommandObject.h"
#include "lldb/Interpreter/CommandReturnObject.h" #include "lldb/Interpreter/CommandReturnObject.h"
#include "lldb/Interpreter/Options.h" #include "lldb/Interpreter/Options.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Interpreter/CommandInterpreter.cpp

Context not available.
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/State.h" #include "lldb/Core/State.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Core/Timer.h" #include "lldb/Core/Timer.h"
#include "lldb/Utility/Stream.h"
#ifndef LLDB_DISABLE_LIBEDIT #ifndef LLDB_DISABLE_LIBEDIT
#include "lldb/Host/Editline.h" #include "lldb/Host/Editline.h"
Context not available.

lldb/source/Interpreter/CommandReturnObject.cpp

Context not available.
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/Error.h" #include "lldb/Utility/Error.h"
#include "lldb/Core/StreamString.h" #include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Interpreter/OptionGroupVariable.cpp

Context not available.
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/Error.h"
#include "lldb/DataFormatters/DataVisualization.h" #include "lldb/DataFormatters/DataVisualization.h"
#include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Error.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Interpreter/OptionValueArray.cpp

Context not available.
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/Stream.h"
#include "lldb/Host/StringConvert.h" #include "lldb/Host/StringConvert.h"
#include "lldb/Interpreter/Args.h" #include "lldb/Interpreter/Args.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Interpreter/OptionValueBoolean.cpp

Context not available.
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/Stream.h"
#include "lldb/Core/StringList.h" #include "lldb/Core/StringList.h"
#include "lldb/Host/PosixApi.h" #include "lldb/Host/PosixApi.h"
#include "lldb/Interpreter/Args.h" #include "lldb/Interpreter/Args.h"
#include "lldb/Utility/Stream.h"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
using namespace lldb; using namespace lldb;
Context not available.

lldb/source/Interpreter/OptionValueChar.cpp

Context not available.
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/Stream.h"
#include "lldb/Core/StringList.h" #include "lldb/Core/StringList.h"
#include "lldb/Interpreter/Args.h" #include "lldb/Interpreter/Args.h"
#include "lldb/Utility/Stream.h"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
using namespace lldb; using namespace lldb;
Context not available.

lldb/source/Interpreter/OptionValueFileSpecLIst.cpp

Context not available.
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/Stream.h"
#include "lldb/Host/StringConvert.h" #include "lldb/Host/StringConvert.h"
#include "lldb/Interpreter/Args.h" #include "lldb/Interpreter/Args.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Interpreter/OptionValueFormat.cpp

Context not available.
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/Stream.h"
#include "lldb/DataFormatters/FormatManager.h" #include "lldb/DataFormatters/FormatManager.h"
#include "lldb/Interpreter/Args.h" #include "lldb/Interpreter/Args.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Interpreter/OptionValueFormatEntity.cpp

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/StringList.h" #include "lldb/Core/StringList.h"
#include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Interpreter/OptionValueLanguage.cpp

Context not available.
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/Stream.h"
#include "lldb/DataFormatters/FormatManager.h" #include "lldb/DataFormatters/FormatManager.h"
#include "lldb/Interpreter/Args.h" #include "lldb/Interpreter/Args.h"
#include "lldb/Target/Language.h" #include "lldb/Target/Language.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Interpreter/OptionValuePathMappings.cpp

Context not available.
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/Stream.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
#include "lldb/Host/StringConvert.h" #include "lldb/Host/StringConvert.h"
#include "lldb/Interpreter/Args.h" #include "lldb/Interpreter/Args.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Interpreter/OptionValueProperties.cpp

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/Flags.h" #include "lldb/Core/Flags.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/StringList.h" #include "lldb/Core/StringList.h"
#include "lldb/Core/UserSettingsController.h" #include "lldb/Core/UserSettingsController.h"
#include "lldb/Interpreter/Args.h" #include "lldb/Interpreter/Args.h"
#include "lldb/Interpreter/OptionValues.h" #include "lldb/Interpreter/OptionValues.h"
#include "lldb/Interpreter/Property.h" #include "lldb/Interpreter/Property.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Interpreter/OptionValueRegex.cpp

Context not available.
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/Stream.h" #include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Interpreter/OptionValueSInt64.cpp

Context not available.
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/Stream.h"
#include "lldb/Host/StringConvert.h" #include "lldb/Host/StringConvert.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Interpreter/OptionValueString.cpp

Context not available.
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/Stream.h"
#include "lldb/Interpreter/Args.h" #include "lldb/Interpreter/Args.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Interpreter/OptionValueUInt64.cpp

Context not available.
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/Stream.h"
#include "lldb/Host/StringConvert.h" #include "lldb/Host/StringConvert.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Interpreter/OptionValueUUID.cpp

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/StringList.h" #include "lldb/Core/StringList.h"
#include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Interpreter/Options.cpp

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/StreamString.h"
#include "lldb/Interpreter/CommandCompletions.h" #include "lldb/Interpreter/CommandCompletions.h"
#include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Interpreter/CommandObject.h" #include "lldb/Interpreter/CommandObject.h"
#include "lldb/Interpreter/CommandReturnObject.h" #include "lldb/Interpreter/CommandReturnObject.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Interpreter/ScriptInterpreter.cpp

Context not available.
#include <stdlib.h> #include <stdlib.h>
#include <string> #include <string>
#include "lldb/Core/Error.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/StringList.h" #include "lldb/Core/StringList.h"
#include "lldb/Interpreter/CommandReturnObject.h" #include "lldb/Interpreter/CommandReturnObject.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/PseudoTerminal.h" #include "lldb/Utility/PseudoTerminal.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.cpp

Context not available.
#include "llvm/ADT/Triple.h" #include "llvm/ADT/Triple.h"
// Project includes // Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/RegisterValue.h" #include "lldb/Core/RegisterValue.h"
Context not available.
#include "lldb/Target/RegisterContext.h" #include "lldb/Target/RegisterContext.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Error.h"
#include "Plugins/Process/Utility/ARMDefines.h" #include "Plugins/Process/Utility/ARMDefines.h"
#include "Utility/ARM_DWARF_Registers.h" #include "Utility/ARM_DWARF_Registers.h"
Context not available.

lldb/source/Plugins/ABI/MacOSX-arm64/ABIMacOSX_arm64.h

Context not available.
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Target/ABI.h" #include "lldb/Target/ABI.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
class ABIMacOSX_arm64 : public lldb_private::ABI { class ABIMacOSX_arm64 : public lldb_private::ABI {
Context not available.

lldb/source/Plugins/ABI/MacOSX-arm64/ABIMacOSX_arm64.cpp

Context not available.
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/Triple.h" #include "llvm/ADT/Triple.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
Context not available.
#include "lldb/Target/RegisterContext.h" #include "lldb/Target/RegisterContext.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Error.h"
#include "Utility/ARM64_DWARF_Registers.h" #include "Utility/ARM64_DWARF_Registers.h"
Context not available.

lldb/source/Plugins/ABI/MacOSX-i386/ABIMacOSX_i386.cpp

Context not available.
#include "llvm/ADT/Triple.h" #include "llvm/ADT/Triple.h"
// Project includes // Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/RegisterValue.h" #include "lldb/Core/RegisterValue.h"
Context not available.
#include "lldb/Target/RegisterContext.h" #include "lldb/Target/RegisterContext.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Error.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/ABI/SysV-arm/ABISysV_arm.cpp

Context not available.
#include "llvm/ADT/Triple.h" #include "llvm/ADT/Triple.h"
// Project includes // Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/RegisterValue.h" #include "lldb/Core/RegisterValue.h"
Context not available.
#include "lldb/Target/RegisterContext.h" #include "lldb/Target/RegisterContext.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Error.h"
#include "Plugins/Process/Utility/ARMDefines.h" #include "Plugins/Process/Utility/ARMDefines.h"
#include "Utility/ARM_DWARF_Registers.h" #include "Utility/ARM_DWARF_Registers.h"
Context not available.

lldb/source/Plugins/ABI/SysV-arm64/ABISysV_arm64.cpp

Context not available.
#include "llvm/ADT/Triple.h" #include "llvm/ADT/Triple.h"
// Project includes // Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
Context not available.
#include "lldb/Target/RegisterContext.h" #include "lldb/Target/RegisterContext.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Error.h"
#include "Utility/ARM64_DWARF_Registers.h" #include "Utility/ARM64_DWARF_Registers.h"
Context not available.

lldb/source/Plugins/ABI/SysV-hexagon/ABISysV_hexagon.cpp

Context not available.
#include "llvm/IR/DerivedTypes.h" #include "llvm/IR/DerivedTypes.h"
// Project includes // Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Core/DataExtractor.h" #include "lldb/Core/DataExtractor.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
Context not available.
#include "lldb/Target/StackFrame.h" #include "lldb/Target/StackFrame.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Error.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/ABI/SysV-i386/ABISysV_i386.cpp

Context not available.
#include "llvm/ADT/Triple.h" #include "llvm/ADT/Triple.h"
// Project includes // Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Core/DataExtractor.h" #include "lldb/Core/DataExtractor.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
Context not available.
#include "lldb/Target/StackFrame.h" #include "lldb/Target/StackFrame.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Error.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/ABI/SysV-mips/ABISysV_mips.cpp

Context not available.
#include "llvm/ADT/Triple.h" #include "llvm/ADT/Triple.h"
// Project includes // Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Core/DataExtractor.h" #include "lldb/Core/DataExtractor.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
Context not available.
#include "lldb/Target/StackFrame.h" #include "lldb/Target/StackFrame.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Error.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/ABI/SysV-mips64/ABISysV_mips64.cpp

Context not available.
#include "llvm/ADT/Triple.h" #include "llvm/ADT/Triple.h"
// Project includes // Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Core/DataExtractor.h" #include "lldb/Core/DataExtractor.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
Context not available.
#include "lldb/Target/StackFrame.h" #include "lldb/Target/StackFrame.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Error.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/ABI/SysV-ppc/ABISysV_ppc.cpp

Context not available.
#include "llvm/ADT/Triple.h" #include "llvm/ADT/Triple.h"
// Project includes // Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Core/DataExtractor.h" #include "lldb/Core/DataExtractor.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
Context not available.
#include "lldb/Target/StackFrame.h" #include "lldb/Target/StackFrame.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Error.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/ABI/SysV-ppc64/ABISysV_ppc64.cpp

Context not available.
#include "llvm/ADT/Triple.h" #include "llvm/ADT/Triple.h"
// Project includes // Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Core/DataExtractor.h" #include "lldb/Core/DataExtractor.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
Context not available.
#include "lldb/Target/StackFrame.h" #include "lldb/Target/StackFrame.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Error.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/ABI/SysV-s390x/ABISysV_s390x.cpp

Context not available.
#include "llvm/ADT/Triple.h" #include "llvm/ADT/Triple.h"
// Project includes // Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Core/DataExtractor.h" #include "lldb/Core/DataExtractor.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
Context not available.
#include "lldb/Target/StackFrame.h" #include "lldb/Target/StackFrame.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Error.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/ABI/SysV-x86_64/ABISysV_x86_64.cpp

Context not available.
#include "llvm/ADT/Triple.h" #include "llvm/ADT/Triple.h"
// Project includes // Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Core/DataExtractor.h" #include "lldb/Core/DataExtractor.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
Context not available.
#include "lldb/Target/StackFrame.h" #include "lldb/Target/StackFrame.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Error.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/Disassembler/llvm/DisassemblerLLVMC.cpp

Context not available.
#include "lldb/Core/DataExtractor.h" #include "lldb/Core/DataExtractor.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/Stream.h"
#include "lldb/Symbol/SymbolContext.h" #include "lldb/Symbol/SymbolContext.h"
#include "lldb/Target/ExecutionContext.h" #include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
Context not available.
#include "lldb/Target/SectionLoadList.h" #include "lldb/Target/SectionLoadList.h"
#include "lldb/Target/StackFrame.h" #include "lldb/Target/StackFrame.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Core/RegularExpression.h" #include "lldb/Utility/RegularExpression.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/DynamicLoader/Hexagon-DYLD/HexagonDYLDRendezvous.cpp

Context not available.
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
#include "lldb/Core/ArchSpec.h" #include "lldb/Core/ArchSpec.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Symbol/Symbol.h" #include "lldb/Symbol/Symbol.h"
#include "lldb/Symbol/SymbolContext.h" #include "lldb/Symbol/SymbolContext.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Error.h"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
Context not available.

lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.cpp

Context not available.
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
#include "lldb/Core/ArchSpec.h" #include "lldb/Core/ArchSpec.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
Context not available.
#include "lldb/Target/Platform.h" #include "lldb/Target/Platform.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Error.h"
#include "llvm/Support/Path.h" #include "llvm/Support/Path.h"
Context not available.

lldb/source/Plugins/ExpressionParser/Clang/ASTDumper.h

Context not available.
#include "clang/AST/DeclVisitor.h" #include "clang/AST/DeclVisitor.h"
#include "clang/AST/TypeVisitor.h" #include "clang/AST/TypeVisitor.h"
#include "lldb/Core/Stream.h" #include "lldb/Utility/Stream.h"
#include "llvm/ADT/DenseSet.h" #include "llvm/ADT/DenseSet.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

Context not available.
#include "ClangPersistentVariables.h" #include "ClangPersistentVariables.h"
#include "lldb/Core/Address.h" #include "lldb/Core/Address.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/ModuleSpec.h" #include "lldb/Core/ModuleSpec.h"
Context not available.
#include "lldb/Target/StackFrame.h" #include "lldb/Target/StackFrame.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/Error.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
#include "clang/AST/ASTConsumer.h" #include "clang/AST/ASTConsumer.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
Context not available.

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.h

Context not available.
#include "lldb/Core/ArchSpec.h" #include "lldb/Core/ArchSpec.h"
#include "lldb/Core/ClangForward.h" #include "lldb/Core/ClangForward.h"
#include "lldb/Core/Error.h"
#include "lldb/Expression/DiagnosticManager.h" #include "lldb/Expression/DiagnosticManager.h"
#include "lldb/Expression/ExpressionParser.h" #include "lldb/Expression/ExpressionParser.h"
#include "lldb/Utility/Error.h"
#include "lldb/lldb-public.h" #include "lldb/lldb-public.h"
#include <string> #include <string>
Context not available.

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp

Context not available.
#include "lldb/Core/Disassembler.h" #include "lldb/Core/Disassembler.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/StringList.h" #include "lldb/Core/StringList.h"
#include "lldb/Expression/IRDynamicChecks.h" #include "lldb/Expression/IRDynamicChecks.h"
#include "lldb/Expression/IRExecutionUnit.h" #include "lldb/Expression/IRExecutionUnit.h"
Context not available.
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/ThreadPlanCallFunction.h" #include "lldb/Target/ThreadPlanCallFunction.h"
#include "lldb/Utility/LLDBAssert.h" #include "lldb/Utility/LLDBAssert.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Utility/StreamString.h"
using namespace clang; using namespace clang;
using namespace llvm; using namespace llvm;
Context not available.

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionVariable.h

Context not available.
// Project includes // Project includes
#include "lldb/Core/ClangForward.h" #include "lldb/Core/ClangForward.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Value.h" #include "lldb/Core/Value.h"
#include "lldb/Expression/ExpressionVariable.h" #include "lldb/Expression/ExpressionVariable.h"
#include "lldb/Symbol/TaggedASTType.h" #include "lldb/Symbol/TaggedASTType.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/lldb-public.h" #include "lldb/lldb-public.h"
namespace llvm { namespace llvm {
Context not available.

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionVariable.cpp

Context not available.
#include "ClangExpressionVariable.h" #include "ClangExpressionVariable.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/DataExtractor.h" #include "lldb/Core/DataExtractor.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/Value.h" #include "lldb/Core/Value.h"
#include "lldb/Core/ValueObjectConstResult.h" #include "lldb/Core/ValueObjectConstResult.h"
#include "lldb/Target/ExecutionContext.h" #include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Stream.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.cpp

Context not available.
#include "ClangModulesDeclVendor.h" #include "ClangModulesDeclVendor.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Host/HostInfo.h" #include "lldb/Host/HostInfo.h"
#include "lldb/Symbol/CompileUnit.h" #include "lldb/Symbol/CompileUnit.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/LLDBAssert.h" #include "lldb/Utility/LLDBAssert.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/ExpressionParser/Clang/ClangPersistentVariables.cpp

Context not available.
#include "lldb/Core/DataExtractor.h" #include "lldb/Core/DataExtractor.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/Value.h" #include "lldb/Core/Value.h"
#include "lldb/Utility/StreamString.h"
#include "clang/AST/Decl.h" #include "clang/AST/Decl.h"
Context not available.

lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.cpp

Context not available.
#include "ClangModulesDeclVendor.h" #include "ClangModulesDeclVendor.h"
#include "ClangPersistentVariables.h" #include "ClangPersistentVariables.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/ValueObjectConstResult.h" #include "lldb/Core/ValueObjectConstResult.h"
#include "lldb/Expression/ExpressionSourceCode.h" #include "lldb/Expression/ExpressionSourceCode.h"
#include "lldb/Expression/IRExecutionUnit.h" #include "lldb/Expression/IRExecutionUnit.h"
Context not available.
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/ThreadPlan.h" #include "lldb/Target/ThreadPlan.h"
#include "lldb/Target/ThreadPlanCallUserExpression.h" #include "lldb/Target/ThreadPlanCallUserExpression.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/StreamString.h"
#include "clang/AST/DeclCXX.h" #include "clang/AST/DeclCXX.h"
#include "clang/AST/DeclObjC.h" #include "clang/AST/DeclObjC.h"
Context not available.

lldb/source/Plugins/ExpressionParser/Clang/ClangUtilityFunction.cpp

Context not available.
// C++ Includes // C++ Includes
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Expression/ExpressionSourceCode.h" #include "lldb/Expression/ExpressionSourceCode.h"
#include "lldb/Expression/IRExecutionUnit.h" #include "lldb/Expression/IRExecutionUnit.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Target/ExecutionContext.h" #include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Stream.h"
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.h

Context not available.
#ifndef liblldb_IRForTarget_h_ #ifndef liblldb_IRForTarget_h_
#define liblldb_IRForTarget_h_ #define liblldb_IRForTarget_h_
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Symbol/TaggedASTType.h" #include "lldb/Symbol/TaggedASTType.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Utility/StreamString.h"
#include "lldb/lldb-public.h" #include "lldb/lldb-public.h"
#include "llvm/Pass.h" #include "llvm/Pass.h"
Context not available.

lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.cpp

Context not available.
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Scalar.h" #include "lldb/Core/Scalar.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/dwarf.h" #include "lldb/Core/dwarf.h"
#include "lldb/Expression/IRExecutionUnit.h" #include "lldb/Expression/IRExecutionUnit.h"
#include "lldb/Expression/IRInterpreter.h" #include "lldb/Expression/IRInterpreter.h"
Context not available.
#include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/ClangASTContext.h"
#include "lldb/Symbol/ClangUtil.h" #include "lldb/Symbol/ClangUtil.h"
#include "lldb/Symbol/CompilerType.h" #include "lldb/Symbol/CompilerType.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/StreamString.h"
#include <map> #include <map>
Context not available.

lldb/source/Plugins/ExpressionParser/Go/GoParser.cpp

Context not available.
#include "GoParser.h" #include "GoParser.h"
#include "Plugins/ExpressionParser/Go/GoAST.h" #include "Plugins/ExpressionParser/Go/GoAST.h"
#include "lldb/Core/Error.h" #include "lldb/Utility/Error.h"
#include "llvm/ADT/SmallString.h" #include "llvm/ADT/SmallString.h"
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/ExpressionParser/Go/GoUserExpression.cpp

Context not available.
// Project includes // Project includes
#include "GoUserExpression.h" #include "GoUserExpression.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/DataEncoder.h" #include "lldb/Core/DataEncoder.h"
#include "lldb/Core/DataExtractor.h" #include "lldb/Core/DataExtractor.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/ValueObjectConstResult.h" #include "lldb/Core/ValueObjectConstResult.h"
#include "lldb/Core/ValueObjectRegister.h" #include "lldb/Core/ValueObjectRegister.h"
#include "lldb/Expression/DiagnosticManager.h" #include "lldb/Expression/DiagnosticManager.h"
Context not available.
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/ThreadPlan.h" #include "lldb/Target/ThreadPlan.h"
#include "lldb/Target/ThreadPlanCallUserExpression.h" #include "lldb/Target/ThreadPlanCallUserExpression.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/StreamString.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
#include "Plugins/ExpressionParser/Go/GoAST.h" #include "Plugins/ExpressionParser/Go/GoAST.h"
Context not available.

lldb/source/Plugins/Instruction/ARM/EmulateInstructionARM.h

Context not available.
#define lldb_EmulateInstructionARM_h_ #define lldb_EmulateInstructionARM_h_
#include "Plugins/Process/Utility/ARMDefines.h" #include "Plugins/Process/Utility/ARMDefines.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/EmulateInstruction.h" #include "lldb/Core/EmulateInstruction.h"
#include "lldb/Core/Error.h" #include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Error.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/source/Plugins/Instruction/ARM/EmulateInstructionARM.cpp

Context not available.
#include "EmulationStateARM.h" #include "EmulationStateARM.h"
#include "lldb/Core/Address.h" #include "lldb/Core/Address.h"
#include "lldb/Core/ArchSpec.h" #include "lldb/Core/ArchSpec.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/Stream.h"
#include "lldb/Host/PosixApi.h" #include "lldb/Host/PosixApi.h"
#include "lldb/Interpreter/OptionValueArray.h" #include "lldb/Interpreter/OptionValueArray.h"
#include "lldb/Interpreter/OptionValueDictionary.h" #include "lldb/Interpreter/OptionValueDictionary.h"
#include "lldb/Symbol/UnwindPlan.h" #include "lldb/Symbol/UnwindPlan.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Stream.h"
#include "Plugins/Process/Utility/ARMDefines.h" #include "Plugins/Process/Utility/ARMDefines.h"
#include "Plugins/Process/Utility/ARMUtils.h" #include "Plugins/Process/Utility/ARMUtils.h"
Context not available.

lldb/source/Plugins/Instruction/ARM64/EmulateInstructionARM64.h

Context not available.
// Project includes // Project includes
#include "Plugins/Process/Utility/ARMDefines.h" #include "Plugins/Process/Utility/ARMDefines.h"
#include "lldb/Core/EmulateInstruction.h" #include "lldb/Core/EmulateInstruction.h"
#include "lldb/Core/Error.h"
#include "lldb/Interpreter/OptionValue.h" #include "lldb/Interpreter/OptionValue.h"
#include "lldb/Utility/Error.h"
class EmulateInstructionARM64 : public lldb_private::EmulateInstruction { class EmulateInstructionARM64 : public lldb_private::EmulateInstruction {
public: public:
Context not available.

lldb/source/Plugins/Instruction/ARM64/EmulateInstructionARM64.cpp

Context not available.
#include "lldb/Core/Address.h" #include "lldb/Core/Address.h"
#include "lldb/Core/ArchSpec.h" #include "lldb/Core/ArchSpec.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/Stream.h"
#include "lldb/Symbol/UnwindPlan.h" #include "lldb/Symbol/UnwindPlan.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Stream.h"
#include "Plugins/Process/Utility/ARMDefines.h" #include "Plugins/Process/Utility/ARMDefines.h"
#include "Plugins/Process/Utility/ARMUtils.h" #include "Plugins/Process/Utility/ARMUtils.h"
Context not available.

lldb/source/Plugins/Instruction/MIPS/EmulateInstructionMIPS.h

Context not available.
} }
#include "lldb/Core/EmulateInstruction.h" #include "lldb/Core/EmulateInstruction.h"
#include "lldb/Core/Error.h"
#include "lldb/Interpreter/OptionValue.h" #include "lldb/Interpreter/OptionValue.h"
#include "lldb/Utility/Error.h"
class EmulateInstructionMIPS : public lldb_private::EmulateInstruction { class EmulateInstructionMIPS : public lldb_private::EmulateInstruction {
public: public:
Context not available.

lldb/source/Plugins/Instruction/MIPS/EmulateInstructionMIPS.cpp

Context not available.
#include "lldb/Core/Address.h" #include "lldb/Core/Address.h"
#include "lldb/Core/ArchSpec.h" #include "lldb/Core/ArchSpec.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/DataExtractor.h" #include "lldb/Core/DataExtractor.h"
#include "lldb/Core/Opcode.h" #include "lldb/Core/Opcode.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/Stream.h"
#include "lldb/Symbol/UnwindPlan.h" #include "lldb/Symbol/UnwindPlan.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Stream.h"
#include "llvm-c/Disassembler.h" #include "llvm-c/Disassembler.h"
#include "llvm/MC/MCAsmInfo.h" #include "llvm/MC/MCAsmInfo.h"
#include "llvm/MC/MCContext.h" #include "llvm/MC/MCContext.h"
Context not available.

lldb/source/Plugins/Instruction/MIPS64/EmulateInstructionMIPS64.h

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/EmulateInstruction.h" #include "lldb/Core/EmulateInstruction.h"
#include "lldb/Core/Error.h"
#include "lldb/Interpreter/OptionValue.h" #include "lldb/Interpreter/OptionValue.h"
#include "lldb/Utility/Error.h"
namespace llvm { namespace llvm {
class MCDisassembler; class MCDisassembler;
Context not available.

lldb/source/Plugins/Instruction/MIPS64/EmulateInstructionMIPS64.cpp

Context not available.
#include "lldb/Core/Address.h" #include "lldb/Core/Address.h"
#include "lldb/Core/ArchSpec.h" #include "lldb/Core/ArchSpec.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/DataExtractor.h" #include "lldb/Core/DataExtractor.h"
#include "lldb/Core/Opcode.h" #include "lldb/Core/Opcode.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/Stream.h"
#include "lldb/Host/PosixApi.h" #include "lldb/Host/PosixApi.h"
#include "lldb/Symbol/UnwindPlan.h" #include "lldb/Symbol/UnwindPlan.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Stream.h"
#include "llvm-c/Disassembler.h" #include "llvm-c/Disassembler.h"
#include "llvm/MC/MCAsmInfo.h" #include "llvm/MC/MCAsmInfo.h"
#include "llvm/MC/MCContext.h" #include "llvm/MC/MCContext.h"
Context not available.

lldb/source/Plugins/InstrumentationRuntime/AddressSanitizer/AddressSanitizerRuntime.cpp

Context not available.
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/PluginInterface.h" #include "lldb/Core/PluginInterface.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/RegularExpression.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/Expression/UserExpression.h" #include "lldb/Expression/UserExpression.h"
Context not available.
#include "lldb/Target/StopInfo.h" #include "lldb/Target/StopInfo.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/RegularExpression.h"
#include "lldb/Utility/Stream.h"
#include "llvm/ADT/StringSwitch.h" #include "llvm/ADT/StringSwitch.h"
Context not available.

lldb/source/Plugins/InstrumentationRuntime/ThreadSanitizer/ThreadSanitizerRuntime.cpp

Context not available.
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/PluginInterface.h" #include "lldb/Core/PluginInterface.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/RegularExpression.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/Expression/UserExpression.h" #include "lldb/Expression/UserExpression.h"
Context not available.
#include "lldb/Target/StopInfo.h" #include "lldb/Target/StopInfo.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/RegularExpression.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/JITLoader/GDB/JITLoaderGDB.cpp

Context not available.
#include "lldb/Core/ModuleSpec.h" #include "lldb/Core/ModuleSpec.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/Section.h" #include "lldb/Core/Section.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Interpreter/OptionValueProperties.h" #include "lldb/Interpreter/OptionValueProperties.h"
#include "lldb/Symbol/SymbolContext.h" #include "lldb/Symbol/SymbolContext.h"
#include "lldb/Symbol/SymbolVendor.h" #include "lldb/Symbol/SymbolVendor.h"
Context not available.
#include "lldb/Target/SectionLoadList.h" #include "lldb/Target/SectionLoadList.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/LLDBAssert.h" #include "lldb/Utility/LLDBAssert.h"
#include "lldb/Utility/StreamString.h"
#include "JITLoaderGDB.h" #include "JITLoaderGDB.h"
Context not available.

lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.h

Context not available.
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
// Project includes // Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Target/Language.h" #include "lldb/Target/Language.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp

Context not available.
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
// Project includes // Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Core/FastDemangle.h" #include "lldb/Core/FastDemangle.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/RegularExpression.h"
#include "lldb/Core/UniqueCStringMap.h" #include "lldb/Core/UniqueCStringMap.h"
#include "lldb/DataFormatters/CXXFunctionPointer.h" #include "lldb/DataFormatters/CXXFunctionPointer.h"
#include "lldb/DataFormatters/DataVisualization.h" #include "lldb/DataFormatters/DataVisualization.h"
#include "lldb/DataFormatters/FormattersHelpers.h" #include "lldb/DataFormatters/FormattersHelpers.h"
#include "lldb/DataFormatters/VectorType.h" #include "lldb/DataFormatters/VectorType.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/RegularExpression.h"
#include "BlockPointer.h" #include "BlockPointer.h"
#include "CxxStringTypes.h" #include "CxxStringTypes.h"
Context not available.

lldb/source/Plugins/Language/CPlusPlus/CxxStringTypes.h

Context not available.
#ifndef liblldb_CxxStringTypes_h_ #ifndef liblldb_CxxStringTypes_h_
#define liblldb_CxxStringTypes_h_ #define liblldb_CxxStringTypes_h_
#include "lldb/Core/Stream.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/DataFormatters/TypeSummary.h" #include "lldb/DataFormatters/TypeSummary.h"
#include "lldb/Utility/Stream.h"
namespace lldb_private { namespace lldb_private {
namespace formatters { namespace formatters {
Context not available.

lldb/source/Plugins/Language/CPlusPlus/CxxStringTypes.cpp

Context not available.
#include "llvm/Support/ConvertUTF.h" #include "llvm/Support/ConvertUTF.h"
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/Core/ValueObjectConstResult.h" #include "lldb/Core/ValueObjectConstResult.h"
#include "lldb/DataFormatters/FormattersHelpers.h" #include "lldb/DataFormatters/FormattersHelpers.h"
Context not available.
#include "lldb/Target/SectionLoadList.h" #include "lldb/Target/SectionLoadList.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/ProcessStructReader.h" #include "lldb/Utility/ProcessStructReader.h"
#include "lldb/Utility/Stream.h"
#include <algorithm> #include <algorithm>
Context not available.

lldb/source/Plugins/Language/CPlusPlus/LibCxx.h

Context not available.
#ifndef liblldb_LibCxx_h_ #ifndef liblldb_LibCxx_h_
#define liblldb_LibCxx_h_ #define liblldb_LibCxx_h_
#include "lldb/Core/Stream.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/DataFormatters/TypeSummary.h" #include "lldb/DataFormatters/TypeSummary.h"
#include "lldb/DataFormatters/TypeSynthetic.h" #include "lldb/DataFormatters/TypeSynthetic.h"
#include "lldb/Utility/Stream.h"
namespace lldb_private { namespace lldb_private {
namespace formatters { namespace formatters {
Context not available.

lldb/source/Plugins/Language/CPlusPlus/LibCxx.cpp

Context not available.
// Project includes // Project includes
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/FormatEntity.h" #include "lldb/Core/FormatEntity.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/Core/ValueObjectConstResult.h" #include "lldb/Core/ValueObjectConstResult.h"
#include "lldb/DataFormatters/FormattersHelpers.h" #include "lldb/DataFormatters/FormattersHelpers.h"
Context not available.
#include "lldb/Host/Endian.h" #include "lldb/Host/Endian.h"
#include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/ClangASTContext.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/ProcessStructReader.h" #include "lldb/Utility/ProcessStructReader.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/Language/CPlusPlus/LibCxxAtomic.h

Context not available.
#ifndef liblldb_LibCxxAtomic_h_ #ifndef liblldb_LibCxxAtomic_h_
#define liblldb_LibCxxAtomic_h_ #define liblldb_LibCxxAtomic_h_
#include "lldb/Core/Stream.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/DataFormatters/TypeSummary.h" #include "lldb/DataFormatters/TypeSummary.h"
#include "lldb/DataFormatters/TypeSynthetic.h" #include "lldb/DataFormatters/TypeSynthetic.h"
#include "lldb/Utility/Stream.h"
namespace lldb_private { namespace lldb_private {
namespace formatters { namespace formatters {
Context not available.

lldb/source/Plugins/Language/CPlusPlus/LibCxxInitializerList.cpp

Context not available.
// Project includes // Project includes
#include "LibCxx.h" #include "LibCxx.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/DataFormatters/FormattersHelpers.h" #include "lldb/DataFormatters/FormattersHelpers.h"
#include "lldb/Utility/ConstString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/Language/CPlusPlus/LibCxxList.cpp

Context not available.
#include "LibCxx.h" #include "LibCxx.h"
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/Core/ValueObjectConstResult.h" #include "lldb/Core/ValueObjectConstResult.h"
#include "lldb/DataFormatters/FormattersHelpers.h" #include "lldb/DataFormatters/FormattersHelpers.h"
#include "lldb/Host/Endian.h" #include "lldb/Host/Endian.h"
#include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/ClangASTContext.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/Language/CPlusPlus/LibCxxMap.cpp

Context not available.
#include "LibCxx.h" #include "LibCxx.h"
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/Core/ValueObjectConstResult.h" #include "lldb/Core/ValueObjectConstResult.h"
#include "lldb/DataFormatters/FormattersHelpers.h" #include "lldb/DataFormatters/FormattersHelpers.h"
#include "lldb/Host/Endian.h" #include "lldb/Host/Endian.h"
#include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/ClangASTContext.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/Language/CPlusPlus/LibCxxUnorderedMap.cpp

Context not available.
#include "LibCxx.h" #include "LibCxx.h"
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/Core/ValueObjectConstResult.h" #include "lldb/Core/ValueObjectConstResult.h"
#include "lldb/DataFormatters/FormattersHelpers.h" #include "lldb/DataFormatters/FormattersHelpers.h"
#include "lldb/Host/Endian.h" #include "lldb/Host/Endian.h"
#include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/ClangASTContext.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/Language/CPlusPlus/LibCxxVector.cpp

Context not available.
// Project includes // Project includes
#include "LibCxx.h" #include "LibCxx.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/DataFormatters/FormattersHelpers.h" #include "lldb/DataFormatters/FormattersHelpers.h"
#include "lldb/Utility/ConstString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/Language/CPlusPlus/LibStdcpp.h

Context not available.
#ifndef liblldb_LibStdCpp_h_ #ifndef liblldb_LibStdCpp_h_
#define liblldb_LibStdCpp_h_ #define liblldb_LibStdCpp_h_
#include "lldb/Core/Stream.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/DataFormatters/TypeSummary.h" #include "lldb/DataFormatters/TypeSummary.h"
#include "lldb/DataFormatters/TypeSynthetic.h" #include "lldb/DataFormatters/TypeSynthetic.h"
#include "lldb/Utility/Stream.h"
namespace lldb_private { namespace lldb_private {
namespace formatters { namespace formatters {
Context not available.

lldb/source/Plugins/Language/CPlusPlus/LibStdcpp.cpp

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/Core/ValueObjectConstResult.h" #include "lldb/Core/ValueObjectConstResult.h"
#include "lldb/DataFormatters/StringPrinter.h" #include "lldb/DataFormatters/StringPrinter.h"
Context not available.
#include "lldb/Host/Endian.h" #include "lldb/Host/Endian.h"
#include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/ClangASTContext.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/Language/CPlusPlus/LibStdcppTuple.cpp

Context not available.
#include "LibStdcpp.h" #include "LibStdcpp.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/DataFormatters/FormattersHelpers.h" #include "lldb/DataFormatters/FormattersHelpers.h"
#include "lldb/DataFormatters/TypeSynthetic.h" #include "lldb/DataFormatters/TypeSynthetic.h"
#include "lldb/Utility/ConstString.h"
#include <memory> #include <memory>
#include <vector> #include <vector>
Context not available.

lldb/source/Plugins/Language/CPlusPlus/LibStdcppUniquePointer.cpp

Context not available.
#include "LibStdcpp.h" #include "LibStdcpp.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/DataFormatters/FormattersHelpers.h" #include "lldb/DataFormatters/FormattersHelpers.h"
#include "lldb/DataFormatters/TypeSynthetic.h" #include "lldb/DataFormatters/TypeSynthetic.h"
#include "lldb/Utility/ConstString.h"
#include <memory> #include <memory>
#include <vector> #include <vector>
Context not available.

lldb/source/Plugins/Language/Go/GoFormatterFunctions.h

Context not available.
// Project includes // Project includes
#include "lldb/lldb-forward.h" #include "lldb/lldb-forward.h"
#include "lldb/Core/ConstString.h"
#include "lldb/DataFormatters/FormatClasses.h" #include "lldb/DataFormatters/FormatClasses.h"
#include "lldb/DataFormatters/TypeSynthetic.h" #include "lldb/DataFormatters/TypeSynthetic.h"
#include "lldb/Target/ExecutionContext.h" #include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/ObjCLanguageRuntime.h" #include "lldb/Target/ObjCLanguageRuntime.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/ConstString.h"
namespace lldb_private { namespace lldb_private {
namespace formatters { namespace formatters {
Context not available.

lldb/source/Plugins/Language/Go/GoLanguage.h

Context not available.
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
// Project includes // Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Target/Language.h" #include "lldb/Target/Language.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/source/Plugins/Language/Go/GoLanguage.cpp

Context not available.
// Project includes // Project includes
#include "GoLanguage.h" #include "GoLanguage.h"
#include "Plugins/Language/Go/GoFormatterFunctions.h" #include "Plugins/Language/Go/GoFormatterFunctions.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/DataFormatters/FormattersHelpers.h" #include "lldb/DataFormatters/FormattersHelpers.h"
#include "lldb/Symbol/GoASTContext.h" #include "lldb/Symbol/GoASTContext.h"
#include "lldb/Utility/ConstString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/Language/Java/JavaLanguage.h

Context not available.
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
// Project includes // Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Target/Language.h" #include "lldb/Target/Language.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/source/Plugins/Language/Java/JavaLanguage.cpp

Context not available.
// Project includes // Project includes
#include "JavaFormatterFunctions.h" #include "JavaFormatterFunctions.h"
#include "JavaLanguage.h" #include "JavaLanguage.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/DataFormatters/DataVisualization.h" #include "lldb/DataFormatters/DataVisualization.h"
#include "lldb/DataFormatters/FormattersHelpers.h" #include "lldb/DataFormatters/FormattersHelpers.h"
#include "lldb/Symbol/JavaASTContext.h" #include "lldb/Symbol/JavaASTContext.h"
#include "lldb/Utility/ConstString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/Language/OCaml/OCamlLanguage.h

Context not available.
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
// Project includes // Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Target/Language.h" #include "lldb/Target/Language.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/source/Plugins/Language/OCaml/OCamlLanguage.cpp

Context not available.
// Project includes // Project includes
#include "OCamlLanguage.h" #include "OCamlLanguage.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/DataFormatters/DataVisualization.h" #include "lldb/DataFormatters/DataVisualization.h"
#include "lldb/DataFormatters/FormattersHelpers.h" #include "lldb/DataFormatters/FormattersHelpers.h"
#include "lldb/Symbol/OCamlASTContext.h" #include "lldb/Symbol/OCamlASTContext.h"
#include "lldb/Utility/ConstString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/Language/ObjC/CF.h

Context not available.
#ifndef liblldb_CF_h_ #ifndef liblldb_CF_h_
#define liblldb_CF_h_ #define liblldb_CF_h_
#include "lldb/Core/Stream.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/DataFormatters/TypeSummary.h" #include "lldb/DataFormatters/TypeSummary.h"
#include "lldb/Utility/Stream.h"
namespace lldb_private { namespace lldb_private {
namespace formatters { namespace formatters {
Context not available.

lldb/source/Plugins/Language/ObjC/CF.cpp

Context not available.
#include "CF.h" #include "CF.h"
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/Core/ValueObjectConstResult.h" #include "lldb/Core/ValueObjectConstResult.h"
#include "lldb/DataFormatters/FormattersHelpers.h" #include "lldb/DataFormatters/FormattersHelpers.h"
Context not available.
#include "lldb/Target/ObjCLanguageRuntime.h" #include "lldb/Target/ObjCLanguageRuntime.h"
#include "lldb/Target/StackFrame.h" #include "lldb/Target/StackFrame.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/Language/ObjC/Cocoa.h

Context not available.
#ifndef liblldb_Cocoa_h_ #ifndef liblldb_Cocoa_h_
#define liblldb_Cocoa_h_ #define liblldb_Cocoa_h_
#include "lldb/Core/Stream.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/DataFormatters/TypeSummary.h" #include "lldb/DataFormatters/TypeSummary.h"
#include "lldb/DataFormatters/TypeSynthetic.h" #include "lldb/DataFormatters/TypeSynthetic.h"
#include "lldb/Target/ObjCLanguageRuntime.h" #include "lldb/Target/ObjCLanguageRuntime.h"
#include "lldb/Utility/Stream.h"
namespace lldb_private { namespace lldb_private {
namespace formatters { namespace formatters {
Context not available.

lldb/source/Plugins/Language/ObjC/Cocoa.cpp

Context not available.
#include "Cocoa.h" #include "Cocoa.h"
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Mangled.h" #include "lldb/Core/Mangled.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/Core/ValueObjectConstResult.h" #include "lldb/Core/ValueObjectConstResult.h"
#include "lldb/DataFormatters/FormattersHelpers.h" #include "lldb/DataFormatters/FormattersHelpers.h"
Context not available.
#include "lldb/Target/ObjCLanguageRuntime.h" #include "lldb/Target/ObjCLanguageRuntime.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/ProcessStructReader.h" #include "lldb/Utility/ProcessStructReader.h"
#include "lldb/Utility/Stream.h"
#include "Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.h" #include "Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.h"
Context not available.

lldb/source/Plugins/Language/ObjC/CoreMedia.h

Context not available.
#ifndef liblldb_CoreMedia_h_ #ifndef liblldb_CoreMedia_h_
#define liblldb_CoreMedia_h_ #define liblldb_CoreMedia_h_
#include "lldb/Core/Stream.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/DataFormatters/TypeSummary.h" #include "lldb/DataFormatters/TypeSummary.h"
#include "lldb/Utility/Stream.h"
namespace lldb_private { namespace lldb_private {
namespace formatters { namespace formatters {
Context not available.

lldb/source/Plugins/Language/ObjC/NSArray.cpp

Context not available.
#include "Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.h" #include "Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.h"
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/Core/ValueObjectConstResult.h" #include "lldb/Core/ValueObjectConstResult.h"
#include "lldb/DataFormatters/FormattersHelpers.h" #include "lldb/DataFormatters/FormattersHelpers.h"
Context not available.
#include "lldb/Target/Language.h" #include "lldb/Target/Language.h"
#include "lldb/Target/ObjCLanguageRuntime.h" #include "lldb/Target/ObjCLanguageRuntime.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/Language/ObjC/NSDictionary.h

Context not available.
#ifndef liblldb_NSDictionary_h_ #ifndef liblldb_NSDictionary_h_
#define liblldb_NSDictionary_h_ #define liblldb_NSDictionary_h_
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/DataFormatters/TypeSummary.h" #include "lldb/DataFormatters/TypeSummary.h"
#include "lldb/DataFormatters/TypeSynthetic.h" #include "lldb/DataFormatters/TypeSynthetic.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Stream.h"
#include <map> #include <map>
#include <memory> #include <memory>
Context not available.

lldb/source/Plugins/Language/ObjC/NSDictionary.cpp

Context not available.
#include "NSDictionary.h" #include "NSDictionary.h"
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/Core/ValueObjectConstResult.h" #include "lldb/Core/ValueObjectConstResult.h"
#include "lldb/DataFormatters/FormattersHelpers.h" #include "lldb/DataFormatters/FormattersHelpers.h"
Context not available.
#include "lldb/Target/ObjCLanguageRuntime.h" #include "lldb/Target/ObjCLanguageRuntime.h"
#include "lldb/Target/StackFrame.h" #include "lldb/Target/StackFrame.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/Language/ObjC/NSError.cpp

Context not available.
#include "Cocoa.h" #include "Cocoa.h"
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/Core/ValueObjectConstResult.h" #include "lldb/Core/ValueObjectConstResult.h"
#include "lldb/DataFormatters/FormattersHelpers.h" #include "lldb/DataFormatters/FormattersHelpers.h"
Context not available.
#include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/ClangASTContext.h"
#include "lldb/Target/ObjCLanguageRuntime.h" #include "lldb/Target/ObjCLanguageRuntime.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Utility/ProcessStructReader.h" #include "lldb/Utility/ProcessStructReader.h"
Context not available.

lldb/source/Plugins/Language/ObjC/NSException.cpp

Context not available.
#include "Cocoa.h" #include "Cocoa.h"
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/Core/ValueObjectConstResult.h" #include "lldb/Core/ValueObjectConstResult.h"
#include "lldb/DataFormatters/FormattersHelpers.h" #include "lldb/DataFormatters/FormattersHelpers.h"
Context not available.
#include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/ClangASTContext.h"
#include "lldb/Target/ObjCLanguageRuntime.h" #include "lldb/Target/ObjCLanguageRuntime.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Utility/ProcessStructReader.h" #include "lldb/Utility/ProcessStructReader.h"
Context not available.

lldb/source/Plugins/Language/ObjC/NSSet.h

Context not available.
#ifndef liblldb_NSSet_h_ #ifndef liblldb_NSSet_h_
#define liblldb_NSSet_h_ #define liblldb_NSSet_h_
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/DataFormatters/TypeSummary.h" #include "lldb/DataFormatters/TypeSummary.h"
#include "lldb/DataFormatters/TypeSynthetic.h" #include "lldb/DataFormatters/TypeSynthetic.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Stream.h"
namespace lldb_private { namespace lldb_private {
namespace formatters { namespace formatters {
Context not available.

lldb/source/Plugins/Language/ObjC/NSSet.cpp

Context not available.
#include "NSSet.h" #include "NSSet.h"
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/Core/ValueObjectConstResult.h" #include "lldb/Core/ValueObjectConstResult.h"
#include "lldb/DataFormatters/FormattersHelpers.h" #include "lldb/DataFormatters/FormattersHelpers.h"
Context not available.
#include "lldb/Target/Language.h" #include "lldb/Target/Language.h"
#include "lldb/Target/ObjCLanguageRuntime.h" #include "lldb/Target/ObjCLanguageRuntime.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/Language/ObjC/NSString.h

Context not available.
#ifndef liblldb_NSString_h_ #ifndef liblldb_NSString_h_
#define liblldb_NSString_h_ #define liblldb_NSString_h_
#include "lldb/Core/Stream.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/DataFormatters/TypeSummary.h" #include "lldb/DataFormatters/TypeSummary.h"
#include "lldb/Target/ObjCLanguageRuntime.h" #include "lldb/Target/ObjCLanguageRuntime.h"
#include "lldb/Utility/Stream.h"
namespace lldb_private { namespace lldb_private {
namespace formatters { namespace formatters {
Context not available.

lldb/source/Plugins/Language/ObjC/NSString.cpp

Context not available.
#include "NSString.h" #include "NSString.h"
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/Core/ValueObjectConstResult.h" #include "lldb/Core/ValueObjectConstResult.h"
#include "lldb/DataFormatters/FormattersHelpers.h" #include "lldb/DataFormatters/FormattersHelpers.h"
Context not available.
#include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/ClangASTContext.h"
#include "lldb/Target/Language.h" #include "lldb/Target/Language.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/ProcessStructReader.h" #include "lldb/Utility/ProcessStructReader.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/Language/ObjC/ObjCLanguage.h

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Target/Language.h" #include "lldb/Target/Language.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/source/Plugins/Language/ObjC/ObjCLanguage.cpp

Context not available.
// Project includes // Project includes
#include "ObjCLanguage.h" #include "ObjCLanguage.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/DataFormatters/DataVisualization.h" #include "lldb/DataFormatters/DataVisualization.h"
#include "lldb/DataFormatters/FormattersHelpers.h" #include "lldb/DataFormatters/FormattersHelpers.h"
Context not available.
#include "lldb/Symbol/CompilerType.h" #include "lldb/Symbol/CompilerType.h"
#include "lldb/Target/ObjCLanguageRuntime.h" #include "lldb/Target/ObjCLanguageRuntime.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/StreamString.h"
#include "CF.h" #include "CF.h"
#include "Cocoa.h" #include "Cocoa.h"
Context not available.

lldb/source/Plugins/Language/ObjCPlusPlus/ObjCPlusPlusLanguage.cpp

Context not available.
#include "ObjCPlusPlusLanguage.h" #include "ObjCPlusPlusLanguage.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Utility/ConstString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.cpp

Context not available.
#include "ItaniumABILanguageRuntime.h" #include "ItaniumABILanguageRuntime.h"
#include "lldb/Breakpoint/BreakpointLocation.h" #include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Mangled.h" #include "lldb/Core/Mangled.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
Context not available.
#include "lldb/Target/StopInfo.h" #include "lldb/Target/StopInfo.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Error.h"
#include <vector> #include <vector>
Context not available.

lldb/source/Plugins/LanguageRuntime/Go/GoLanguageRuntime.cpp

Context not available.
#include "GoLanguageRuntime.h" #include "GoLanguageRuntime.h"
#include "lldb/Breakpoint/BreakpointLocation.h" #include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
Context not available.
#include "lldb/Target/StopInfo.h" #include "lldb/Target/StopInfo.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Error.h"
#include "llvm/ADT/Twine.h" #include "llvm/ADT/Twine.h"
#include <vector> #include <vector>
Context not available.

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.cpp

Context not available.
#include "clang/AST/Type.h" #include "clang/AST/Type.h"
#include "lldb/Breakpoint/BreakpointLocation.h" #include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/ModuleList.h" #include "lldb/Core/ModuleList.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/Scalar.h" #include "lldb/Core/Scalar.h"
#include "lldb/Core/Section.h" #include "lldb/Core/Section.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/Expression/DiagnosticManager.h" #include "lldb/Expression/DiagnosticManager.h"
#include "lldb/Expression/FunctionCaller.h" #include "lldb/Expression/FunctionCaller.h"
Context not available.
#include "lldb/Target/StopInfo.h" #include "lldb/Target/StopInfo.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/StreamString.h"
#include <vector> #include <vector>
Context not available.

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV1.cpp

Context not available.
#include "clang/AST/Type.h" #include "clang/AST/Type.h"
#include "lldb/Breakpoint/BreakpointLocation.h" #include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/Scalar.h" #include "lldb/Core/Scalar.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Expression/FunctionCaller.h" #include "lldb/Expression/FunctionCaller.h"
#include "lldb/Expression/UtilityFunction.h" #include "lldb/Expression/UtilityFunction.h"
#include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/ClangASTContext.h"
Context not available.
#include "lldb/Target/RegisterContext.h" #include "lldb/Target/RegisterContext.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/StreamString.h"
#include <vector> #include <vector>
Context not available.

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp

Context not available.
#include "lldb/lldb-enumerations.h" #include "lldb/lldb-enumerations.h"
#include "lldb/Core/ClangForward.h" #include "lldb/Core/ClangForward.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/Scalar.h" #include "lldb/Core/Scalar.h"
#include "lldb/Core/Section.h" #include "lldb/Core/Section.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/Timer.h" #include "lldb/Core/Timer.h"
#include "lldb/Core/ValueObjectVariable.h" #include "lldb/Core/ValueObjectVariable.h"
#include "lldb/Expression/DiagnosticManager.h" #include "lldb/Expression/DiagnosticManager.h"
Context not available.
#include "lldb/Target/RegisterContext.h" #include "lldb/Target/RegisterContext.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Utility/StreamString.h"
#include "AppleObjCClassDescriptorV2.h" #include "AppleObjCClassDescriptorV2.h"
#include "AppleObjCDeclVendor.h" #include "AppleObjCDeclVendor.h"
Context not available.

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.cpp

Context not available.
#include "AppleThreadPlanStepThroughObjCTrampoline.h" #include "AppleThreadPlanStepThroughObjCTrampoline.h"
#include "lldb/Breakpoint/StoppointCallbackContext.h" #include "lldb/Breakpoint/StoppointCallbackContext.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
Context not available.
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Target/ThreadPlanRunToAddress.h" #include "lldb/Target/ThreadPlanRunToAddress.h"
#include "lldb/Utility/ConstString.h"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
Context not available.

lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp

Context not available.
#include "RenderScriptScriptGroup.h" #include "RenderScriptScriptGroup.h"
#include "lldb/Breakpoint/StoppointCallbackContext.h" #include "lldb/Breakpoint/StoppointCallbackContext.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/RegularExpression.h"
#include "lldb/Core/ValueObjectVariable.h" #include "lldb/Core/ValueObjectVariable.h"
#include "lldb/DataFormatters/DumpValueObjectOptions.h" #include "lldb/DataFormatters/DumpValueObjectOptions.h"
#include "lldb/Expression/UserExpression.h" #include "lldb/Expression/UserExpression.h"
Context not available.
#include "lldb/Target/SectionLoadList.h" #include "lldb/Target/SectionLoadList.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/RegularExpression.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptScriptGroup.cpp

Context not available.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Breakpoint/StoppointCallbackContext.h" #include "lldb/Breakpoint/StoppointCallbackContext.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Host/StringConvert.h" #include "lldb/Host/StringConvert.h"
Context not available.
#include "lldb/Symbol/VariableList.h" #include "lldb/Symbol/VariableList.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Error.h"
#include "RenderScriptRuntime.h" #include "RenderScriptRuntime.h"
#include "RenderScriptScriptGroup.h" #include "RenderScriptScriptGroup.h"
Context not available.

lldb/source/Plugins/ObjectContainer/BSD-Archive/ObjectContainerBSDArchive.h

Context not available.
// Project includes // Project includes
#include "lldb/Core/ArchSpec.h" #include "lldb/Core/ArchSpec.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/UniqueCStringMap.h" #include "lldb/Core/UniqueCStringMap.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
#include "lldb/Symbol/ObjectContainer.h" #include "lldb/Symbol/ObjectContainer.h"
#include "lldb/Utility/ConstString.h"
// Other libraries and framework includes // Other libraries and framework includes
#include "llvm/Support/Chrono.h" #include "llvm/Support/Chrono.h"
Context not available.

lldb/source/Plugins/ObjectContainer/BSD-Archive/ObjectContainerBSDArchive.cpp

Context not available.
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/ModuleSpec.h" #include "lldb/Core/ModuleSpec.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/Timer.h" #include "lldb/Core/Timer.h"
#include "lldb/Host/FileSystem.h" #include "lldb/Host/FileSystem.h"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/ObjectContainer/Universal-Mach-O/ObjectContainerUniversalMachO.cpp

Context not available.
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/ModuleSpec.h" #include "lldb/Core/ModuleSpec.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/Stream.h"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/ObjectFile/ELF/ELFHeader.cpp

Context not available.
#include "lldb/Core/DataExtractor.h" #include "lldb/Core/DataExtractor.h"
#include "lldb/Core/Section.h" #include "lldb/Core/Section.h"
#include "lldb/Core/Stream.h" #include "lldb/Utility/Stream.h"
#include "ELFHeader.h" #include "ELFHeader.h"
Context not available.

lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

Context not available.
#include "lldb/Core/ArchSpec.h" #include "lldb/Core/ArchSpec.h"
#include "lldb/Core/DataBuffer.h" #include "lldb/Core/DataBuffer.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/FileSpecList.h" #include "lldb/Core/FileSpecList.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/ModuleSpec.h" #include "lldb/Core/ModuleSpec.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/Section.h" #include "lldb/Core/Section.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/Timer.h" #include "lldb/Core/Timer.h"
#include "lldb/Symbol/DWARFCallFrameInfo.h" #include "lldb/Symbol/DWARFCallFrameInfo.h"
#include "lldb/Symbol/SymbolContext.h" #include "lldb/Symbol/SymbolContext.h"
#include "lldb/Target/SectionLoadList.h" #include "lldb/Target/SectionLoadList.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/Stream.h"
#include "llvm/ADT/PointerUnion.h" #include "llvm/ADT/PointerUnion.h"
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
Context not available.

lldb/source/Plugins/ObjectFile/JIT/ObjectFileJIT.cpp

Context not available.
#include "lldb/Core/RangeMap.h" #include "lldb/Core/RangeMap.h"
#include "lldb/Core/Section.h" #include "lldb/Core/Section.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/Timer.h" #include "lldb/Core/Timer.h"
#include "lldb/Core/UUID.h" #include "lldb/Core/UUID.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
Context not available.
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/SectionLoadList.h" #include "lldb/Target/SectionLoadList.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/StreamString.h"
#ifndef __APPLE__ #ifndef __APPLE__
#include "Utility/UuidCompatibility.h" #include "Utility/UuidCompatibility.h"
Context not available.

lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

Context not available.
#include "lldb/Core/ArchSpec.h" #include "lldb/Core/ArchSpec.h"
#include "lldb/Core/DataBuffer.h" #include "lldb/Core/DataBuffer.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/FileSpecList.h" #include "lldb/Core/FileSpecList.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
Context not available.
#include "lldb/Core/RangeMap.h" #include "lldb/Core/RangeMap.h"
#include "lldb/Core/Section.h" #include "lldb/Core/Section.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/Timer.h" #include "lldb/Core/Timer.h"
#include "lldb/Core/UUID.h" #include "lldb/Core/UUID.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
Context not available.
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Target/ThreadList.h" #include "lldb/Target/ThreadList.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/StreamString.h"
#include "lldb/Utility/SafeMachO.h" #include "lldb/Utility/SafeMachO.h"
Context not available.

lldb/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp

Context not available.
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/Section.h" #include "lldb/Core/Section.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/Timer.h" #include "lldb/Core/Timer.h"
#include "lldb/Core/UUID.h" #include "lldb/Core/UUID.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
Context not available.
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/SectionLoadList.h" #include "lldb/Target/SectionLoadList.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/StreamString.h"
#define IMAGE_DOS_SIGNATURE 0x5A4D // MZ #define IMAGE_DOS_SIGNATURE 0x5A4D // MZ
#define IMAGE_NT_SIGNATURE 0x00004550 // PE00 #define IMAGE_NT_SIGNATURE 0x00004550 // PE00
Context not available.

lldb/source/Plugins/OperatingSystem/Go/OperatingSystemGo.cpp

Context not available.
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/RegisterValue.h" #include "lldb/Core/RegisterValue.h"
#include "lldb/Core/Section.h" #include "lldb/Core/Section.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/ValueObjectVariable.h" #include "lldb/Core/ValueObjectVariable.h"
#include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Interpreter/OptionGroupBoolean.h" #include "lldb/Interpreter/OptionGroupBoolean.h"
Context not available.
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Target/ThreadList.h" #include "lldb/Target/ThreadList.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/OperatingSystem/Python/OperatingSystemPython.cpp

Context not available.
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/RegisterValue.h" #include "lldb/Core/RegisterValue.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/StructuredData.h" #include "lldb/Core/StructuredData.h"
#include "lldb/Core/ValueObjectVariable.h" #include "lldb/Core/ValueObjectVariable.h"
#include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandInterpreter.h"
Context not available.
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Target/ThreadList.h" #include "lldb/Target/ThreadList.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/Platform/Android/AdbClient.h

Context not available.
#ifndef liblldb_AdbClient_h_ #ifndef liblldb_AdbClient_h_
#define liblldb_AdbClient_h_ #define liblldb_AdbClient_h_
#include "lldb/Core/Error.h" #include "lldb/Utility/Error.h"
#include <chrono> #include <chrono>
#include <functional> #include <functional>
#include <list> #include <list>
Context not available.

lldb/source/Plugins/Platform/Android/AdbClient.cpp

Context not available.
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/DataEncoder.h" #include "lldb/Core/DataEncoder.h"
#include "lldb/Core/DataExtractor.h" #include "lldb/Core/DataExtractor.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Host/ConnectionFileDescriptor.h" #include "lldb/Host/ConnectionFileDescriptor.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
#include "lldb/Host/FileSystem.h" #include "lldb/Host/FileSystem.h"
#include "lldb/Host/PosixApi.h" #include "lldb/Host/PosixApi.h"
#include "lldb/Utility/StreamString.h"
#include <limits.h> #include <limits.h>
Context not available.

lldb/source/Plugins/Platform/Android/PlatformAndroidRemoteGDBServer.cpp

Context not available.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Other libraries and framework includes // Other libraries and framework includes
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Host/ConnectionFileDescriptor.h" #include "lldb/Host/ConnectionFileDescriptor.h"
#include "lldb/Host/common/TCPSocket.h" #include "lldb/Host/common/TCPSocket.h"
#include "lldb/Utility/Error.h"
#include "PlatformAndroidRemoteGDBServer.h" #include "PlatformAndroidRemoteGDBServer.h"
#include "Utility/UriParser.h" #include "Utility/UriParser.h"
Context not available.

lldb/source/Plugins/Platform/FreeBSD/PlatformFreeBSD.cpp

Context not available.
#include "lldb/Breakpoint/BreakpointLocation.h" #include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Breakpoint/BreakpointSite.h" #include "lldb/Breakpoint/BreakpointSite.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/ModuleSpec.h" #include "lldb/Core/ModuleSpec.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Host/HostInfo.h" #include "lldb/Host/HostInfo.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Utility/Error.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/Platform/Kalimba/PlatformKalimba.cpp

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/ModuleList.h" #include "lldb/Core/ModuleList.h"
#include "lldb/Core/ModuleSpec.h" #include "lldb/Core/ModuleSpec.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
#include "lldb/Host/HostInfo.h" #include "lldb/Host/HostInfo.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/Platform/Linux/PlatformLinux.cpp

Context not available.
// Project includes // Project includes
#include "lldb/Breakpoint/BreakpointLocation.h" #include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/ModuleList.h" #include "lldb/Core/ModuleList.h"
#include "lldb/Core/ModuleSpec.h" #include "lldb/Core/ModuleSpec.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/State.h" #include "lldb/Core/State.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
#include "lldb/Host/HostInfo.h" #include "lldb/Host/HostInfo.h"
#include "lldb/Interpreter/OptionValueProperties.h" #include "lldb/Interpreter/OptionValueProperties.h"
#include "lldb/Interpreter/Property.h" #include "lldb/Interpreter/Property.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/StreamString.h"
// Define these constants from Linux mman.h for use when targeting // Define these constants from Linux mman.h for use when targeting
// remote linux systems even when host has different values. // remote linux systems even when host has different values.
Context not available.

lldb/source/Plugins/Platform/MacOSX/PlatformAppleSimulator.cpp

Context not available.
#include <thread> #include <thread>
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/Error.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/LLDBAssert.h" #include "lldb/Utility/LLDBAssert.h"
#include "lldb/Utility/PseudoTerminal.h" #include "lldb/Utility/PseudoTerminal.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/Platform/MacOSX/PlatformAppleTVSimulator.cpp

Context not available.
// Project includes // Project includes
#include "lldb/Breakpoint/BreakpointLocation.h" #include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Core/ArchSpec.h" #include "lldb/Core/ArchSpec.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/ModuleList.h" #include "lldb/Core/ModuleList.h"
#include "lldb/Core/ModuleSpec.h" #include "lldb/Core/ModuleSpec.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Host/HostInfo.h" #include "lldb/Host/HostInfo.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/Platform/MacOSX/PlatformAppleWatchSimulator.cpp

Context not available.
// Project includes // Project includes
#include "lldb/Breakpoint/BreakpointLocation.h" #include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Core/ArchSpec.h" #include "lldb/Core/ArchSpec.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/ModuleList.h" #include "lldb/Core/ModuleList.h"
#include "lldb/Core/ModuleSpec.h" #include "lldb/Core/ModuleSpec.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Host/HostInfo.h" #include "lldb/Host/HostInfo.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/Platform/MacOSX/PlatformDarwin.cpp

Context not available.
#include "lldb/Breakpoint/BreakpointLocation.h" #include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Breakpoint/BreakpointSite.h" #include "lldb/Breakpoint/BreakpointSite.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/ModuleSpec.h" #include "lldb/Core/ModuleSpec.h"
Context not available.
#include "lldb/Symbol/SymbolVendor.h" #include "lldb/Symbol/SymbolVendor.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Error.h"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#if defined(__APPLE__) #if defined(__APPLE__)
Context not available.

lldb/source/Plugins/Platform/MacOSX/PlatformDarwinKernel.h

Context not available.
#ifndef liblldb_PlatformDarwinKernel_h_ #ifndef liblldb_PlatformDarwinKernel_h_
#define liblldb_PlatformDarwinKernel_h_ #define liblldb_PlatformDarwinKernel_h_
#include "lldb/Core/ConstString.h" #include "lldb/Utility/ConstString.h"
#if defined(__APPLE__) // This Plugin uses the Mac-specific #if defined(__APPLE__) // This Plugin uses the Mac-specific
// source/Host/macosx/cfcpp utilities // source/Host/macosx/cfcpp utilities
Context not available.

lldb/source/Plugins/Platform/MacOSX/PlatformDarwinKernel.cpp

Context not available.
// Project includes // Project includes
#include "lldb/Breakpoint/BreakpointLocation.h" #include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Core/ArchSpec.h" #include "lldb/Core/ArchSpec.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/ModuleList.h" #include "lldb/Core/ModuleList.h"
#include "lldb/Core/ModuleSpec.h" #include "lldb/Core/ModuleSpec.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Interpreter/OptionValueFileSpecList.h" #include "lldb/Interpreter/OptionValueFileSpecList.h"
Context not available.
#include "lldb/Target/Platform.h" #include "lldb/Target/Platform.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/StreamString.h"
#include <CoreFoundation/CoreFoundation.h> #include <CoreFoundation/CoreFoundation.h>
Context not available.

lldb/source/Plugins/Platform/MacOSX/PlatformMacOSX.cpp

Context not available.
// Project includes // Project includes
#include "lldb/Breakpoint/BreakpointLocation.h" #include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/ModuleList.h" #include "lldb/Core/ModuleList.h"
#include "lldb/Core/ModuleSpec.h" #include "lldb/Core/ModuleSpec.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
#include "lldb/Host/FileSystem.h" #include "lldb/Host/FileSystem.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
Context not available.
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/Platform/MacOSX/PlatformRemoteAppleTV.cpp

Context not available.
#include "lldb/Breakpoint/BreakpointLocation.h" #include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Core/ArchSpec.h" #include "lldb/Core/ArchSpec.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/ModuleList.h" #include "lldb/Core/ModuleList.h"
#include "lldb/Core/ModuleSpec.h" #include "lldb/Core/ModuleSpec.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/Platform/MacOSX/PlatformRemoteAppleWatch.cpp

Context not available.
#include "lldb/Breakpoint/BreakpointLocation.h" #include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Core/ArchSpec.h" #include "lldb/Core/ArchSpec.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/ModuleList.h" #include "lldb/Core/ModuleList.h"
#include "lldb/Core/ModuleSpec.h" #include "lldb/Core/ModuleSpec.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/Platform/MacOSX/PlatformRemoteiOS.cpp

Context not available.
// Project includes // Project includes
#include "lldb/Breakpoint/BreakpointLocation.h" #include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Core/ArchSpec.h" #include "lldb/Core/ArchSpec.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/ModuleList.h" #include "lldb/Core/ModuleList.h"
#include "lldb/Core/ModuleSpec.h" #include "lldb/Core/ModuleSpec.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/Platform/MacOSX/PlatformiOSSimulator.cpp

Context not available.
// Project includes // Project includes
#include "lldb/Breakpoint/BreakpointLocation.h" #include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Core/ArchSpec.h" #include "lldb/Core/ArchSpec.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/ModuleList.h" #include "lldb/Core/ModuleList.h"
#include "lldb/Core/ModuleSpec.h" #include "lldb/Core/ModuleSpec.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Host/HostInfo.h" #include "lldb/Host/HostInfo.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/Platform/MacOSX/PlatformiOSSimulatorCoreSimulatorSupport.h

Context not available.
typedef void *id; typedef void *id;
#endif #endif
// Project includes // Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Error.h"
#include "lldb/Interpreter/Args.h" #include "lldb/Interpreter/Args.h"
#include "lldb/Target/ProcessLaunchInfo.h" #include "lldb/Target/ProcessLaunchInfo.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Error.h"
#include "llvm/ADT/Optional.h" #include "llvm/ADT/Optional.h"
Context not available.

lldb/source/Plugins/Platform/NetBSD/PlatformNetBSD.cpp

Context not available.
#include "lldb/Breakpoint/BreakpointLocation.h" #include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Breakpoint/BreakpointSite.h" #include "lldb/Breakpoint/BreakpointSite.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/ModuleSpec.h" #include "lldb/Core/ModuleSpec.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Host/HostInfo.h" #include "lldb/Host/HostInfo.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Utility/Error.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/Platform/POSIX/PlatformPOSIX.cpp

Context not available.
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/Expression/UserExpression.h" #include "lldb/Expression/UserExpression.h"
#include "lldb/Host/File.h" #include "lldb/Host/File.h"
Context not available.
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/ProcessLaunchInfo.h" #include "lldb/Target/ProcessLaunchInfo.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/Platform/Windows/PlatformWindows.cpp

Context not available.
#include "lldb/Breakpoint/BreakpointLocation.h" #include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Breakpoint/BreakpointSite.h" #include "lldb/Breakpoint/BreakpointSite.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/ModuleSpec.h" #include "lldb/Core/ModuleSpec.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Host/HostInfo.h" #include "lldb/Host/HostInfo.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Utility/Error.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.cpp

Context not available.
// Project includes // Project includes
#include "lldb/Breakpoint/BreakpointLocation.h" #include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/ModuleList.h" #include "lldb/Core/ModuleList.h"
#include "lldb/Core/ModuleSpec.h" #include "lldb/Core/ModuleSpec.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Host/ConnectionFileDescriptor.h" #include "lldb/Host/ConnectionFileDescriptor.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
Context not available.
#include "lldb/Host/StringConvert.h" #include "lldb/Host/StringConvert.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/StreamString.h"
#include "Utility/UriParser.h" #include "Utility/UriParser.h"
Context not available.

lldb/source/Plugins/Process/Darwin/DarwinProcessLauncher.cpp

Context not available.
// LLDB includes // LLDB includes
#include "lldb/lldb-enumerations.h" #include "lldb/lldb-enumerations.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Target/ProcessLaunchInfo.h" #include "lldb/Target/ProcessLaunchInfo.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/PseudoTerminal.h" #include "lldb/Utility/PseudoTerminal.h"
#include "lldb/Utility/StreamString.h"
#include "CFBundle.h" #include "CFBundle.h"
#include "CFString.h" #include "CFString.h"
Context not available.

lldb/source/Plugins/Process/Darwin/MachException.cpp

Context not available.
#include <mutex> #include <mutex>
// LLDB includes // LLDB includes
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Stream.h"
#include "lldb/Target/UnixSignals.h" #include "lldb/Target/UnixSignals.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/LLDBAssert.h" #include "lldb/Utility/LLDBAssert.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/Process/Darwin/NativeProcessDarwin.cpp

Context not available.
// LLDB includes // LLDB includes
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/State.h" #include "lldb/Core/State.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Target/ProcessLaunchInfo.h" #include "lldb/Target/ProcessLaunchInfo.h"
#include "lldb/Utility/PseudoTerminal.h" #include "lldb/Utility/PseudoTerminal.h"
#include "lldb/Utility/StreamString.h"
#include "CFBundle.h" #include "CFBundle.h"
#include "CFString.h" #include "CFString.h"
Context not available.

lldb/source/Plugins/Process/Darwin/NativeThreadDarwin.cpp

Context not available.
#include <libproc.h> #include <libproc.h>
// LLDB includes // LLDB includes
#include "lldb/Core/Stream.h" #include "lldb/Utility/Stream.h"
#include "NativeProcessDarwin.h" #include "NativeProcessDarwin.h"
Context not available.

lldb/source/Plugins/Process/Darwin/NativeThreadListDarwin.cpp

Context not available.
#include <sys/sysctl.h> #include <sys/sysctl.h>
// LLDB includes // LLDB includes
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Stream.h" #include "lldb/Utility/Error.h"
#include "lldb/Utility/Stream.h"
#include "lldb/lldb-enumerations.h" #include "lldb/lldb-enumerations.h"
#include "NativeProcessDarwin.h" #include "NativeProcessDarwin.h"
Context not available.

lldb/source/Plugins/Process/FreeBSD/ProcessMonitor.cpp

Context not available.
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
#include "lldb/Core/Error.h"
#include "lldb/Core/RegisterValue.h" #include "lldb/Core/RegisterValue.h"
#include "lldb/Core/Scalar.h" #include "lldb/Core/Scalar.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
Context not available.
#include "lldb/Target/RegisterContext.h" #include "lldb/Target/RegisterContext.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Target/UnixSignals.h" #include "lldb/Target/UnixSignals.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/PseudoTerminal.h" #include "lldb/Utility/PseudoTerminal.h"
#include "FreeBSDThread.h" #include "FreeBSDThread.h"
Context not available.

lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
#include "lldb/Core/EmulateInstruction.h" #include "lldb/Core/EmulateInstruction.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/ModuleSpec.h" #include "lldb/Core/ModuleSpec.h"
#include "lldb/Core/RegisterValue.h" #include "lldb/Core/RegisterValue.h"
#include "lldb/Core/State.h" #include "lldb/Core/State.h"
Context not available.
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/ProcessLaunchInfo.h" #include "lldb/Target/ProcessLaunchInfo.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/LLDBAssert.h" #include "lldb/Utility/LLDBAssert.h"
#include "lldb/Utility/PseudoTerminal.h" #include "lldb/Utility/PseudoTerminal.h"
#include "lldb/Utility/StringExtractor.h" #include "lldb/Utility/StringExtractor.h"
Context not available.

lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux_arm.cpp

Context not available.
#include "NativeRegisterContextLinux_arm.h" #include "NativeRegisterContextLinux_arm.h"
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/RegisterValue.h" #include "lldb/Core/RegisterValue.h"
#include "lldb/Utility/Error.h"
#include "Plugins/Process/Linux/Procfs.h" #include "Plugins/Process/Linux/Procfs.h"
#include "Plugins/Process/Utility/RegisterContextLinux_arm.h" #include "Plugins/Process/Utility/RegisterContextLinux_arm.h"
Context not available.

lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux_arm64.cpp

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/RegisterValue.h" #include "lldb/Core/RegisterValue.h"
#include "lldb/Host/common/NativeProcessProtocol.h" #include "lldb/Host/common/NativeProcessProtocol.h"
#include "lldb/Utility/Error.h"
#include "Plugins/Process/Linux/NativeProcessLinux.h" #include "Plugins/Process/Linux/NativeProcessLinux.h"
#include "Plugins/Process/Linux/Procfs.h" #include "Plugins/Process/Linux/Procfs.h"
Context not available.

lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.cpp

Context not available.
#include "Plugins/Process/Utility/RegisterContextLinux_mips64.h" #include "Plugins/Process/Utility/RegisterContextLinux_mips64.h"
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/EmulateInstruction.h" #include "lldb/Core/EmulateInstruction.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/RegisterValue.h" #include "lldb/Core/RegisterValue.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Host/HostInfo.h" #include "lldb/Host/HostInfo.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/LLDBAssert.h" #include "lldb/Utility/LLDBAssert.h"
#include "lldb/lldb-enumerations.h" #include "lldb/lldb-enumerations.h"
#include "lldb/lldb-private-enumerations.h" #include "lldb/lldb-private-enumerations.h"
Context not available.

lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux_s390x.cpp

Context not available.
#include "NativeRegisterContextLinux_s390x.h" #include "NativeRegisterContextLinux_s390x.h"
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/RegisterValue.h" #include "lldb/Core/RegisterValue.h"
#include "lldb/Host/HostInfo.h" #include "lldb/Host/HostInfo.h"
#include "lldb/Utility/Error.h"
#include "Plugins/Process/Utility/RegisterContextLinux_s390x.h" #include "Plugins/Process/Utility/RegisterContextLinux_s390x.h"
Context not available.

lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux_x86_64.cpp

Context not available.
#include "NativeRegisterContextLinux_x86_64.h" #include "NativeRegisterContextLinux_x86_64.h"
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/RegisterValue.h" #include "lldb/Core/RegisterValue.h"
#include "lldb/Host/HostInfo.h" #include "lldb/Host/HostInfo.h"
#include "lldb/Utility/Error.h"
#include "Plugins/Process/Utility/RegisterContextLinux_i386.h" #include "Plugins/Process/Utility/RegisterContextLinux_i386.h"
#include "Plugins/Process/Utility/RegisterContextLinux_x86_64.h" #include "Plugins/Process/Utility/RegisterContextLinux_x86_64.h"
Context not available.

lldb/source/Plugins/Process/Linux/ProcFileReader.cpp

Context not available.
// LLDB Headers // LLDB Headers
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/Error.h" #include "lldb/Utility/Error.h"
using namespace lldb_private; using namespace lldb_private;
using namespace lldb_private::process_linux; using namespace lldb_private::process_linux;
Context not available.

lldb/source/Plugins/Process/Linux/SingleStepCheck.cpp

Context not available.
#include "llvm/Support/Compiler.h" #include "llvm/Support/Compiler.h"
#include "Plugins/Process/POSIX/ProcessPOSIXLog.h" #include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
#include "lldb/Core/Error.h"
#include "lldb/Host/linux/Ptrace.h" #include "lldb/Host/linux/Ptrace.h"
#include "lldb/Utility/Error.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/Process/MacOSX-Kernel/ProcessKDP.h

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
#include "lldb/Core/ArchSpec.h" #include "lldb/Core/ArchSpec.h"
#include "lldb/Core/Broadcaster.h" #include "lldb/Core/Broadcaster.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/StringList.h" #include "lldb/Core/StringList.h"
#include "lldb/Core/ThreadSafeValue.h" #include "lldb/Core/ThreadSafeValue.h"
#include "lldb/Host/HostThread.h" #include "lldb/Host/HostThread.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/StreamString.h"
#include "CommunicationKDP.h" #include "CommunicationKDP.h"
Context not available.

lldb/source/Plugins/Process/MacOSX-Kernel/ThreadKDP.cpp

Context not available.
#include "lldb/Core/ArchSpec.h" #include "lldb/Core/ArchSpec.h"
#include "lldb/Core/DataExtractor.h" #include "lldb/Core/DataExtractor.h"
#include "lldb/Core/State.h" #include "lldb/Core/State.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h" #include "lldb/Target/RegisterContext.h"
#include "lldb/Target/StopInfo.h" #include "lldb/Target/StopInfo.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Unwind.h" #include "lldb/Target/Unwind.h"
#include "lldb/Utility/StreamString.h"
#include "Plugins/Process/Utility/StopInfoMachException.h" #include "Plugins/Process/Utility/StopInfoMachException.h"
#include "ProcessKDP.h" #include "ProcessKDP.h"
Context not available.

lldb/source/Plugins/Process/Utility/DynamicRegisterInfo.h

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Core/StructuredData.h" #include "lldb/Core/StructuredData.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
class DynamicRegisterInfo { class DynamicRegisterInfo {
Context not available.

lldb/source/Plugins/Process/Utility/DynamicRegisterInfo.cpp

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/ArchSpec.h" #include "lldb/Core/ArchSpec.h"
#include "lldb/Core/RegularExpression.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Core/StructuredData.h" #include "lldb/Core/StructuredData.h"
#include "lldb/DataFormatters/FormatManager.h" #include "lldb/DataFormatters/FormatManager.h"
#include "lldb/Host/StringConvert.h" #include "lldb/Host/StringConvert.h"
#include "lldb/Utility/RegularExpression.h"
#include "lldb/Utility/StringExtractor.h" #include "lldb/Utility/StringExtractor.h"
using namespace lldb; using namespace lldb;
Context not available.

lldb/source/Plugins/Process/Utility/RegisterContextMacOSXFrameBackchain.cpp

Context not available.
#include "lldb/Core/DataExtractor.h" #include "lldb/Core/DataExtractor.h"
#include "lldb/Core/RegisterValue.h" #include "lldb/Core/RegisterValue.h"
#include "lldb/Core/Scalar.h" #include "lldb/Core/Scalar.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/StreamString.h"
// Project includes // Project includes
#include "Utility/StringExtractorGDBRemote.h" #include "Utility/StringExtractorGDBRemote.h"
Context not available.

lldb/source/Plugins/Process/Utility/RegisterContextMemory.cpp

Context not available.
// Project includes // Project includes
#include "DynamicRegisterInfo.h" #include "DynamicRegisterInfo.h"
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/RegisterValue.h" #include "lldb/Core/RegisterValue.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/Error.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/Process/Utility/RegisterContextThreadMemory.cpp

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Core/Error.h"
#include "lldb/Target/OperatingSystem.h" #include "lldb/Target/OperatingSystem.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/Error.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
#include "RegisterContextThreadMemory.h" #include "RegisterContextThreadMemory.h"
Context not available.

lldb/source/Plugins/Process/Utility/StopInfoMachException.cpp

Context not available.
// Project includes // Project includes
#include "lldb/Breakpoint/Watchpoint.h" #include "lldb/Breakpoint/Watchpoint.h"
#include "lldb/Core/ArchSpec.h" #include "lldb/Core/ArchSpec.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Symbol/Symbol.h" #include "lldb/Symbol/Symbol.h"
#include "lldb/Target/DynamicLoader.h" #include "lldb/Target/DynamicLoader.h"
#include "lldb/Target/ExecutionContext.h" #include "lldb/Target/ExecutionContext.h"
Context not available.
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Target/ThreadPlan.h" #include "lldb/Target/ThreadPlan.h"
#include "lldb/Target/UnixSignals.h" #include "lldb/Target/UnixSignals.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/Process/Utility/UnwindLLDB.h

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Symbol/FuncUnwinders.h" #include "lldb/Symbol/FuncUnwinders.h"
#include "lldb/Symbol/UnwindPlan.h" #include "lldb/Symbol/UnwindPlan.h"
#include "lldb/Target/RegisterContext.h" #include "lldb/Target/RegisterContext.h"
#include "lldb/Target/Unwind.h" #include "lldb/Target/Unwind.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/lldb-public.h" #include "lldb/lldb-public.h"
namespace lldb_private { namespace lldb_private {
Context not available.

lldb/source/Plugins/Process/Windows/Common/DebuggerThread.cpp

Context not available.
#include "ExceptionRecord.h" #include "ExceptionRecord.h"
#include "IDebugDelegate.h" #include "IDebugDelegate.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/ModuleSpec.h" #include "lldb/Core/ModuleSpec.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
Context not available.
#include "lldb/Host/windows/ProcessLauncherWindows.h" #include "lldb/Host/windows/ProcessLauncherWindows.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/ProcessLaunchInfo.h" #include "lldb/Target/ProcessLaunchInfo.h"
#include "lldb/Utility/Error.h"
#include "Plugins/Process/Windows/Common/ProcessWindowsLog.h" #include "Plugins/Process/Windows/Common/ProcessWindowsLog.h"
Context not available.

lldb/source/Plugins/Process/Windows/Common/ProcessWindows.h

Context not available.
#define liblldb_Plugins_Process_Windows_Common_ProcessWindows_H_ #define liblldb_Plugins_Process_Windows_Common_ProcessWindows_H_
// Other libraries and framework includes // Other libraries and framework includes
#include "lldb/Core/Error.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Utility/Error.h"
#include "lldb/lldb-forward.h" #include "lldb/lldb-forward.h"
#include "llvm/Support/Mutex.h" #include "llvm/Support/Mutex.h"
Context not available.

lldb/source/Plugins/Process/Windows/Common/RegisterContextWindows.cpp

Context not available.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/Error.h"
#include "lldb/Host/windows/HostThreadWindows.h" #include "lldb/Host/windows/HostThreadWindows.h"
#include "lldb/Host/windows/windows.h" #include "lldb/Host/windows/windows.h"
#include "lldb/Utility/Error.h"
#include "lldb/lldb-private-types.h" #include "lldb/lldb-private-types.h"
#include "ProcessWindowsLog.h" #include "ProcessWindowsLog.h"
Context not available.

lldb/source/Plugins/Process/Windows/Common/x64/RegisterContextWindows_x64.cpp

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Core/Error.h"
#include "lldb/Core/RegisterValue.h" #include "lldb/Core/RegisterValue.h"
#include "lldb/Host/windows/HostThreadWindows.h" #include "lldb/Host/windows/HostThreadWindows.h"
#include "lldb/Host/windows/windows.h" #include "lldb/Host/windows/windows.h"
#include "lldb/Utility/Error.h"
#include "lldb/lldb-private-types.h" #include "lldb/lldb-private-types.h"
#include "RegisterContextWindows_x64.h" #include "RegisterContextWindows_x64.h"
Context not available.

lldb/source/Plugins/Process/Windows/Common/x86/RegisterContextWindows_x86.cpp

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Core/Error.h"
#include "lldb/Core/RegisterValue.h" #include "lldb/Core/RegisterValue.h"
#include "lldb/Host/windows/HostThreadWindows.h" #include "lldb/Host/windows/HostThreadWindows.h"
#include "lldb/Host/windows/windows.h" #include "lldb/Host/windows/windows.h"
#include "lldb/Utility/Error.h"
#include "lldb/lldb-private-types.h" #include "lldb/lldb-private-types.h"
#include "ProcessWindowsLog.h" #include "ProcessWindowsLog.h"
Context not available.

lldb/source/Plugins/Process/elf-core/ProcessElfCore.h

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Error.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Error.h"
#include "Plugins/ObjectFile/ELF/ELFHeader.h" #include "Plugins/ObjectFile/ELF/ELFHeader.h"
Context not available.

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp

Context not available.
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/RegularExpression.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Host/ConnectionFileDescriptor.h" #include "lldb/Host/ConnectionFileDescriptor.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
Context not available.
#include "lldb/Host/ThreadLauncher.h" #include "lldb/Host/ThreadLauncher.h"
#include "lldb/Target/Platform.h" #include "lldb/Target/Platform.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Utility/RegularExpression.h"
#include "lldb/Utility/StreamString.h"
#include "llvm/ADT/SmallString.h" #include "llvm/ADT/SmallString.h"
#include "llvm/Support/ScopedPrinter.h" #include "llvm/Support/ScopedPrinter.h"
Context not available.

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp

Context not available.
#include "lldb/Core/ModuleSpec.h" #include "lldb/Core/ModuleSpec.h"
#include "lldb/Core/State.h" #include "lldb/Core/State.h"
#include "lldb/Core/StreamGDBRemote.h" #include "lldb/Core/StreamGDBRemote.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Host/HostInfo.h" #include "lldb/Host/HostInfo.h"
#include "lldb/Host/StringConvert.h" #include "lldb/Host/StringConvert.h"
#include "lldb/Interpreter/Args.h" #include "lldb/Interpreter/Args.h"
Context not available.
#include "lldb/Target/UnixSignals.h" #include "lldb/Target/UnixSignals.h"
#include "lldb/Utility/JSON.h" #include "lldb/Utility/JSON.h"
#include "lldb/Utility/LLDBAssert.h" #include "lldb/Utility/LLDBAssert.h"
#include "lldb/Utility/StreamString.h"
// Project includes // Project includes
#include "ProcessGDBRemote.h" #include "ProcessGDBRemote.h"
Context not available.

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.cpp

Context not available.
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/ModuleSpec.h" #include "lldb/Core/ModuleSpec.h"
#include "lldb/Core/StreamGDBRemote.h" #include "lldb/Core/StreamGDBRemote.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Host/Config.h" #include "lldb/Host/Config.h"
#include "lldb/Host/Endian.h" #include "lldb/Host/Endian.h"
#include "lldb/Host/File.h" #include "lldb/Host/File.h"
Context not available.
#include "lldb/Target/Platform.h" #include "lldb/Target/Platform.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Utility/JSON.h" #include "lldb/Utility/JSON.h"
#include "lldb/Utility/StreamString.h"
#include "llvm/ADT/Triple.h" #include "llvm/ADT/Triple.h"
// Project includes // Project includes
Context not available.

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp

Context not available.
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/RegisterValue.h" #include "lldb/Core/RegisterValue.h"
#include "lldb/Core/State.h" #include "lldb/Core/State.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Host/ConnectionFileDescriptor.h" #include "lldb/Host/ConnectionFileDescriptor.h"
#include "lldb/Host/Debug.h" #include "lldb/Host/Debug.h"
#include "lldb/Host/Endian.h" #include "lldb/Host/Endian.h"
Context not available.
#include "lldb/Target/MemoryRegionInfo.h" #include "lldb/Target/MemoryRegionInfo.h"
#include "lldb/Utility/JSON.h" #include "lldb/Utility/JSON.h"
#include "lldb/Utility/LLDBAssert.h" #include "lldb/Utility/LLDBAssert.h"
#include "lldb/Utility/StreamString.h"
#include "llvm/ADT/Triple.h" #include "llvm/ADT/Triple.h"
#include "llvm/Support/ScopedPrinter.h" #include "llvm/Support/ScopedPrinter.h"
Context not available.

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.cpp

Context not available.
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/StreamGDBRemote.h" #include "lldb/Core/StreamGDBRemote.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/StructuredData.h" #include "lldb/Core/StructuredData.h"
#include "lldb/Host/Config.h" #include "lldb/Host/Config.h"
#include "lldb/Host/ConnectionFileDescriptor.h" #include "lldb/Host/ConnectionFileDescriptor.h"
Context not available.
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/UnixSignals.h" #include "lldb/Target/UnixSignals.h"
#include "lldb/Utility/JSON.h" #include "lldb/Utility/JSON.h"
#include "lldb/Utility/StreamString.h"
// Project includes // Project includes
#include "Utility/StringExtractorGDBRemote.h" #include "Utility/StringExtractorGDBRemote.h"
Context not available.

lldb/source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.h

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "Plugins/Process/Utility/DynamicRegisterInfo.h" #include "Plugins/Process/Utility/DynamicRegisterInfo.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/DataExtractor.h" #include "lldb/Core/DataExtractor.h"
#include "lldb/Target/RegisterContext.h" #include "lldb/Target/RegisterContext.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/lldb-enumerations.h" #include "lldb/lldb-enumerations.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
Context not available.

lldb/source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.cpp

Context not available.
#include "lldb/Core/DataExtractor.h" #include "lldb/Core/DataExtractor.h"
#include "lldb/Core/RegisterValue.h" #include "lldb/Core/RegisterValue.h"
#include "lldb/Core/Scalar.h" #include "lldb/Core/Scalar.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Target/ExecutionContext.h" #include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/StreamString.h"
// Project includes // Project includes
#include "ProcessGDBRemote.h" #include "ProcessGDBRemote.h"
#include "ProcessGDBRemoteLog.h" #include "ProcessGDBRemoteLog.h"
Context not available.

lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.h

Context not available.
// Project includes // Project includes
#include "lldb/Core/ArchSpec.h" #include "lldb/Core/ArchSpec.h"
#include "lldb/Core/Broadcaster.h" #include "lldb/Core/Broadcaster.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/LoadedModuleInfoList.h" #include "lldb/Core/LoadedModuleInfoList.h"
#include "lldb/Core/ModuleSpec.h" #include "lldb/Core/ModuleSpec.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/StringList.h" #include "lldb/Core/StringList.h"
#include "lldb/Core/StructuredData.h" #include "lldb/Core/StructuredData.h"
#include "lldb/Core/ThreadSafeValue.h" #include "lldb/Core/ThreadSafeValue.h"
#include "lldb/Host/HostThread.h" #include "lldb/Host/HostThread.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/StreamString.h"
#include "lldb/Utility/StringExtractor.h" #include "lldb/Utility/StringExtractor.h"
#include "lldb/lldb-private-forward.h" #include "lldb/lldb-private-forward.h"
Context not available.

lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

Context not available.
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/State.h" #include "lldb/Core/State.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/Timer.h" #include "lldb/Core/Timer.h"
#include "lldb/Core/Value.h" #include "lldb/Core/Value.h"
#include "lldb/DataFormatters/FormatManager.h" #include "lldb/DataFormatters/FormatManager.h"
Context not available.
#include "lldb/Target/ThreadPlanCallFunction.h" #include "lldb/Target/ThreadPlanCallFunction.h"
#include "lldb/Utility/CleanUp.h" #include "lldb/Utility/CleanUp.h"
#include "lldb/Utility/PseudoTerminal.h" #include "lldb/Utility/PseudoTerminal.h"
#include "lldb/Utility/StreamString.h"
// Project includes // Project includes
#include "GDBRemoteRegisterContext.h" #include "GDBRemoteRegisterContext.h"
Context not available.

lldb/source/Plugins/Process/gdb-remote/ThreadGDBRemote.cpp

Context not available.
#include "lldb/Core/ArchSpec.h" #include "lldb/Core/ArchSpec.h"
#include "lldb/Core/DataExtractor.h" #include "lldb/Core/DataExtractor.h"
#include "lldb/Core/State.h" #include "lldb/Core/State.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Target/Platform.h" #include "lldb/Target/Platform.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h" #include "lldb/Target/RegisterContext.h"
Context not available.
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/UnixSignals.h" #include "lldb/Target/UnixSignals.h"
#include "lldb/Target/Unwind.h" #include "lldb/Target/Unwind.h"
#include "lldb/Utility/StreamString.h"
#include "ProcessGDBRemote.h" #include "ProcessGDBRemote.h"
#include "ProcessGDBRemoteLog.h" #include "ProcessGDBRemoteLog.h"
Context not available.

lldb/source/Plugins/Process/mach-core/ProcessMachCore.h

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Error.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Error.h"
class ThreadKDP; class ThreadKDP;
Context not available.

lldb/source/Plugins/Process/mach-core/ThreadMachCore.cpp

Context not available.
#include "lldb/Core/ArchSpec.h" #include "lldb/Core/ArchSpec.h"
#include "lldb/Core/DataExtractor.h" #include "lldb/Core/DataExtractor.h"
#include "lldb/Core/State.h" #include "lldb/Core/State.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h" #include "lldb/Target/RegisterContext.h"
#include "lldb/Target/StopInfo.h" #include "lldb/Target/StopInfo.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Unwind.h" #include "lldb/Target/Unwind.h"
#include "lldb/Utility/StreamString.h"
#include "ProcessMachCore.h" #include "ProcessMachCore.h"
//#include "RegisterContextKDP_arm.h" //#include "RegisterContextKDP_arm.h"
Context not available.

lldb/source/Plugins/Process/minidump/MinidumpParser.h

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
#include "lldb/Core/ArchSpec.h" #include "lldb/Core/ArchSpec.h"
#include "lldb/Core/DataBuffer.h" #include "lldb/Core/DataBuffer.h"
#include "lldb/Core/Error.h" #include "lldb/Utility/Error.h"
#include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/DenseMap.h" #include "llvm/ADT/DenseMap.h"
Context not available.

lldb/source/Plugins/Process/minidump/MinidumpTypes.h

Context not available.
// Project includes // Project includes
// Other libraries and framework includes // Other libraries and framework includes
#include "lldb/Core/Error.h" #include "lldb/Utility/Error.h"
#include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/BitmaskEnum.h" #include "llvm/ADT/BitmaskEnum.h"
Context not available.

lldb/source/Plugins/Process/minidump/ProcessMinidump.h

Context not available.
#include "MinidumpTypes.h" #include "MinidumpTypes.h"
// Other libraries and framework includes // Other libraries and framework includes
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Error.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/StopInfo.h" #include "lldb/Target/StopInfo.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Error.h"
#include "llvm/Support/Format.h" #include "llvm/Support/Format.h"
#include "llvm/Support/raw_ostream.h" #include "llvm/Support/raw_ostream.h"
Context not available.

lldb/source/Plugins/ScriptInterpreter/None/ScriptInterpreterNone.cpp

Context not available.
#include "ScriptInterpreterNone.h" #include "ScriptInterpreterNone.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Core/StringList.h" #include "lldb/Core/StringList.h"
#include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Utility/Stream.h"
#include <mutex> #include <mutex>
Context not available.

lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.h

Context not available.
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Flags.h" #include "lldb/Core/Flags.h"
#include "lldb/Core/StructuredData.h" #include "lldb/Core/StructuredData.h"
#include "lldb/Host/File.h" #include "lldb/Host/File.h"
#include "lldb/Interpreter/OptionValue.h" #include "lldb/Interpreter/OptionValue.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/lldb-defines.h" #include "lldb/lldb-defines.h"
#include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/ArrayRef.h"
Context not available.

lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp

Context not available.
#include "PythonDataObjects.h" #include "PythonDataObjects.h"
#include "ScriptInterpreterPython.h" #include "ScriptInterpreterPython.h"
#include "lldb/Core/Stream.h"
#include "lldb/Host/File.h" #include "lldb/Host/File.h"
#include "lldb/Host/FileSystem.h" #include "lldb/Host/FileSystem.h"
#include "lldb/Interpreter/ScriptInterpreter.h" #include "lldb/Interpreter/ScriptInterpreter.h"
#include "lldb/Utility/Stream.h"
#include "llvm/Support/ConvertUTF.h" #include "llvm/Support/ConvertUTF.h"
Context not available.

lldb/source/Plugins/StructuredData/DarwinLog/StructuredDataDarwinLog.cpp

Context not available.
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/RegularExpression.h"
#include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Interpreter/CommandObjectMultiword.h" #include "lldb/Interpreter/CommandObjectMultiword.h"
#include "lldb/Interpreter/CommandReturnObject.h" #include "lldb/Interpreter/CommandReturnObject.h"
Context not available.
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/ThreadPlanCallOnFunctionExit.h" #include "lldb/Target/ThreadPlanCallOnFunctionExit.h"
#include "lldb/Utility/RegularExpression.h"
#define DARWIN_LOG_TYPE_VALUE "DarwinLog" #define DARWIN_LOG_TYPE_VALUE "DarwinLog"
Context not available.

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

Context not available.
#include "Plugins/Language/ObjC/ObjCLanguage.h" #include "Plugins/Language/ObjC/ObjCLanguage.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/Value.h" #include "lldb/Core/Value.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Interpreter/Args.h" #include "lldb/Interpreter/Args.h"
Context not available.
#include "lldb/Symbol/TypeMap.h" #include "lldb/Symbol/TypeMap.h"
#include "lldb/Target/Language.h" #include "lldb/Target/Language.h"
#include "lldb/Utility/LLDBAssert.h" #include "lldb/Utility/LLDBAssert.h"
#include "lldb/Utility/StreamString.h"
#include "clang/AST/DeclCXX.h" #include "clang/AST/DeclCXX.h"
#include "clang/AST/DeclObjC.h" #include "clang/AST/DeclObjC.h"
Context not available.

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserOCaml.cpp

Context not available.
#include "DWARFASTParserOCaml.h" #include "DWARFASTParserOCaml.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Symbol/CompileUnit.h" #include "lldb/Symbol/CompileUnit.h"
Context not available.
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
#include "lldb/Symbol/Type.h" #include "lldb/Symbol/Type.h"
#include "lldb/Symbol/TypeList.h" #include "lldb/Symbol/TypeList.h"
#include "lldb/Utility/Error.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.cpp

Context not available.
#include "Plugins/Language/ObjC/ObjCLanguage.h" #include "Plugins/Language/ObjC/ObjCLanguage.h"
#include "lldb/Core/Mangled.h" #include "lldb/Core/Mangled.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/Timer.h" #include "lldb/Core/Timer.h"
#include "lldb/Host/StringConvert.h" #include "lldb/Host/StringConvert.h"
#include "lldb/Symbol/CompileUnit.h" #include "lldb/Symbol/CompileUnit.h"
#include "lldb/Symbol/LineTable.h" #include "lldb/Symbol/LineTable.h"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Utility/StreamString.h"
#include "DWARFDIECollection.h" #include "DWARFDIECollection.h"
#include "DWARFDebugAbbrev.h" #include "DWARFDebugAbbrev.h"
Context not available.

lldb/source/Plugins/SymbolFile/DWARF/DWARFDIECollection.cpp

Context not available.
#include <algorithm> #include <algorithm>
#include "lldb/Core/Stream.h" #include "lldb/Utility/Stream.h"
using namespace lldb_private; using namespace lldb_private;
using namespace std; using namespace std;
Context not available.

lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugAbbrev.cpp

Context not available.
#include "DWARFDebugAbbrev.h" #include "DWARFDebugAbbrev.h"
#include "DWARFDataExtractor.h" #include "DWARFDataExtractor.h"
#include "lldb/Core/Stream.h" #include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugArangeSet.cpp

Context not available.
#include "DWARFDebugArangeSet.h" #include "DWARFDebugArangeSet.h"
#include "SymbolFileDWARF.h" #include "SymbolFileDWARF.h"
#include "lldb/Core/Stream.h" #include "lldb/Utility/Stream.h"
#include <assert.h> #include <assert.h>
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugAranges.cpp

Context not available.
#include <algorithm> #include <algorithm>
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/Timer.h" #include "lldb/Core/Timer.h"
#include "lldb/Utility/Stream.h"
#include "DWARFCompileUnit.h" #include "DWARFCompileUnit.h"
#include "DWARFDebugInfo.h" #include "DWARFDebugInfo.h"
Context not available.

lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.cpp

Context not available.
#include <algorithm> #include <algorithm>
#include <set> #include <set>
#include "lldb/Core/RegularExpression.h"
#include "lldb/Core/Stream.h"
#include "lldb/Host/PosixApi.h" #include "lldb/Host/PosixApi.h"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
#include "lldb/Utility/RegularExpression.h"
#include "lldb/Utility/Stream.h"
#include "DWARFCompileUnit.h" #include "DWARFCompileUnit.h"
#include "DWARFDebugAranges.h" #include "DWARFDebugAranges.h"
Context not available.

lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

Context not available.
#include <algorithm> #include <algorithm>
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/Stream.h"
#include "lldb/Expression/DWARFExpression.h" #include "lldb/Expression/DWARFExpression.h"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
#include "lldb/Utility/Stream.h"
#include "DWARFCompileUnit.h" #include "DWARFCompileUnit.h"
#include "DWARFDIECollection.h" #include "DWARFDIECollection.h"
Context not available.

lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugMacinfo.cpp

Context not available.
#include "DWARFDebugMacinfoEntry.h" #include "DWARFDebugMacinfoEntry.h"
#include "SymbolFileDWARF.h" #include "SymbolFileDWARF.h"
#include "lldb/Core/Stream.h" #include "lldb/Utility/Stream.h"
using namespace lldb_private; using namespace lldb_private;
using namespace std; using namespace std;
Context not available.

lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugMacinfoEntry.cpp

Context not available.
#include "DWARFDebugMacinfoEntry.h" #include "DWARFDebugMacinfoEntry.h"
#include "lldb/Core/Stream.h" #include "lldb/Utility/Stream.h"
using namespace lldb_private; using namespace lldb_private;
using namespace std; using namespace std;
Context not available.

lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugPubnames.cpp

Context not available.
#include "DWARFDebugPubnames.h" #include "DWARFDebugPubnames.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/Timer.h" #include "lldb/Core/Timer.h"
#include "lldb/Utility/Stream.h"
#include "DWARFCompileUnit.h" #include "DWARFCompileUnit.h"
#include "DWARFDIECollection.h" #include "DWARFDIECollection.h"
Context not available.

lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugPubnamesSet.cpp

Context not available.
#include "DWARFDebugPubnamesSet.h" #include "DWARFDebugPubnamesSet.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/RegularExpression.h" #include "lldb/Utility/RegularExpression.h"
#include "SymbolFileDWARF.h" #include "SymbolFileDWARF.h"
Context not available.

lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugRanges.cpp

Context not available.
#include "DWARFDebugRanges.h" #include "DWARFDebugRanges.h"
#include "SymbolFileDWARF.h" #include "SymbolFileDWARF.h"
#include "lldb/Core/Stream.h" #include "lldb/Utility/Stream.h"
#include <assert.h> #include <assert.h>
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/SymbolFile/DWARF/DWARFDeclContext.h

Context not available.
#include <string> #include <string>
#include <vector> #include <vector>
// Other libraries and framework includes // Other libraries and framework includes
#include "lldb/Core/ConstString.h" #include "lldb/Utility/ConstString.h"
// Project includes // Project includes
#include "DWARFDefines.h" #include "DWARFDefines.h"
Context not available.

lldb/source/Plugins/SymbolFile/DWARF/DWARFDefines.cpp

Context not available.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "DWARFDefines.h" #include "DWARFDefines.h"
#include "lldb/Core/ConstString.h" #include "lldb/Utility/ConstString.h"
#include <cstdio> #include <cstdio>
#include <cstring> #include <cstring>
#include <string> #include <string>
Context not available.

lldb/source/Plugins/SymbolFile/DWARF/DWARFFormValue.cpp

Context not available.
#include <assert.h> #include <assert.h>
#include "lldb/Core/Stream.h"
#include "lldb/Core/dwarf.h" #include "lldb/Core/dwarf.h"
#include "lldb/Utility/Stream.h"
#include "DWARFCompileUnit.h" #include "DWARFCompileUnit.h"
#include "DWARFFormValue.h" #include "DWARFFormValue.h"
Context not available.

lldb/source/Plugins/SymbolFile/DWARF/HashedNameToDIE.h

Context not available.
#include <vector> #include <vector>
#include "lldb/Core/MappedHash.h" #include "lldb/Core/MappedHash.h"
#include "lldb/Core/RegularExpression.h"
#include "lldb/Core/dwarf.h" #include "lldb/Core/dwarf.h"
#include "lldb/Utility/RegularExpression.h"
#include "lldb/lldb-defines.h" #include "lldb/lldb-defines.h"
#include "DWARFDefines.h" #include "DWARFDefines.h"
Context not available.

lldb/source/Plugins/SymbolFile/DWARF/NameToDIE.cpp

Context not available.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "NameToDIE.h" #include "NameToDIE.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/RegularExpression.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/RegularExpression.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Utility/StreamString.h"
#include "DWARFCompileUnit.h" #include "DWARFCompileUnit.h"
#include "DWARFDebugInfo.h" #include "DWARFDebugInfo.h"
Context not available.

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
#include "llvm/ADT/DenseMap.h" #include "llvm/ADT/DenseMap.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Flags.h" #include "lldb/Core/Flags.h"
#include "lldb/Core/RangeMap.h" #include "lldb/Core/RangeMap.h"
#include "lldb/Core/UniqueCStringMap.h" #include "lldb/Core/UniqueCStringMap.h"
Context not available.
#include "lldb/Symbol/DebugMacros.h" #include "lldb/Symbol/DebugMacros.h"
#include "lldb/Symbol/SymbolContext.h" #include "lldb/Symbol/SymbolContext.h"
#include "lldb/Symbol/SymbolFile.h" #include "lldb/Symbol/SymbolFile.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
// Project includes // Project includes
Context not available.

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

Context not available.
#include "lldb/Core/ModuleList.h" #include "lldb/Core/ModuleList.h"
#include "lldb/Core/ModuleSpec.h" #include "lldb/Core/ModuleSpec.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/RegularExpression.h"
#include "lldb/Core/Scalar.h" #include "lldb/Core/Scalar.h"
#include "lldb/Core/Section.h" #include "lldb/Core/Section.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/Timer.h" #include "lldb/Core/Timer.h"
#include "lldb/Core/Value.h" #include "lldb/Core/Value.h"
#include "lldb/Utility/RegularExpression.h"
#include "lldb/Utility/StreamString.h"
#include "Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.h" #include "Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.h"
Context not available.

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

Context not available.
#include "lldb/Core/ModuleList.h" #include "lldb/Core/ModuleList.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/RangeMap.h" #include "lldb/Core/RangeMap.h"
#include "lldb/Core/RegularExpression.h"
#include "lldb/Core/Section.h" #include "lldb/Core/Section.h"
#include "lldb/Host/FileSystem.h" #include "lldb/Host/FileSystem.h"
#include "lldb/Utility/RegularExpression.h"
//#define DEBUG_OSO_DMAP // DO NOT CHECKIN WITH THIS NOT COMMENTED OUT //#define DEBUG_OSO_DMAP // DO NOT CHECKIN WITH THIS NOT COMMENTED OUT
#if defined(DEBUG_OSO_DMAP) #if defined(DEBUG_OSO_DMAP)
Context not available.

lldb/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.cpp

Context not available.
#include "SymbolFileSymtab.h" #include "SymbolFileSymtab.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/RegularExpression.h"
#include "lldb/Core/Timer.h" #include "lldb/Core/Timer.h"
#include "lldb/Symbol/CompileUnit.h" #include "lldb/Symbol/CompileUnit.h"
#include "lldb/Symbol/Function.h" #include "lldb/Symbol/Function.h"
Context not available.
#include "lldb/Symbol/SymbolContext.h" #include "lldb/Symbol/SymbolContext.h"
#include "lldb/Symbol/Symtab.h" #include "lldb/Symbol/Symtab.h"
#include "lldb/Symbol/TypeList.h" #include "lldb/Symbol/TypeList.h"
#include "lldb/Utility/RegularExpression.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/SymbolVendor/ELF/SymbolVendorELF.cpp

Context not available.
#include "lldb/Core/ModuleSpec.h" #include "lldb/Core/ModuleSpec.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/Section.h" #include "lldb/Core/Section.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/Timer.h" #include "lldb/Core/Timer.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Host/Symbols.h" #include "lldb/Host/Symbols.h"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/SymbolVendor/MacOSX/SymbolVendorMacOSX.cpp

Context not available.
#include "lldb/Core/ModuleSpec.h" #include "lldb/Core/ModuleSpec.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/Section.h" #include "lldb/Core/Section.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/Timer.h" #include "lldb/Core/Timer.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Host/Symbols.h" #include "lldb/Host/Symbols.h"
#include "lldb/Host/XML.h" #include "lldb/Host/XML.h"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetItemInfoHandler.h

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/Error.h"
#include "lldb/Expression/UtilityFunction.h" #include "lldb/Expression/UtilityFunction.h"
#include "lldb/Symbol/CompilerType.h" #include "lldb/Symbol/CompilerType.h"
#include "lldb/Utility/Error.h"
#include "lldb/lldb-public.h" #include "lldb/lldb-public.h"
// This class will insert a UtilityFunction into the inferior process for // This class will insert a UtilityFunction into the inferior process for
Context not available.

lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetItemInfoHandler.cpp

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/Value.h" #include "lldb/Core/Value.h"
#include "lldb/Expression/DiagnosticManager.h" #include "lldb/Expression/DiagnosticManager.h"
#include "lldb/Expression/FunctionCaller.h" #include "lldb/Expression/FunctionCaller.h"
Context not available.
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetPendingItemsHandler.h

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/Error.h"
#include "lldb/Symbol/CompilerType.h" #include "lldb/Symbol/CompilerType.h"
#include "lldb/Utility/Error.h"
#include "lldb/lldb-public.h" #include "lldb/lldb-public.h"
// This class will insert a UtilityFunction into the inferior process for // This class will insert a UtilityFunction into the inferior process for
Context not available.

lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetPendingItemsHandler.cpp

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/Value.h" #include "lldb/Core/Value.h"
#include "lldb/Expression/DiagnosticManager.h" #include "lldb/Expression/DiagnosticManager.h"
#include "lldb/Expression/FunctionCaller.h" #include "lldb/Expression/FunctionCaller.h"
Context not available.
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetQueuesHandler.h

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/Error.h"
#include "lldb/Symbol/CompilerType.h" #include "lldb/Symbol/CompilerType.h"
#include "lldb/Utility/Error.h"
#include "lldb/lldb-public.h" #include "lldb/lldb-public.h"
// This class will insert a UtilityFunction into the inferior process for // This class will insert a UtilityFunction into the inferior process for
Context not available.

lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetQueuesHandler.cpp

Context not available.
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/Value.h" #include "lldb/Core/Value.h"
#include "lldb/Expression/DiagnosticManager.h" #include "lldb/Expression/DiagnosticManager.h"
#include "lldb/Expression/FunctionCaller.h" #include "lldb/Expression/FunctionCaller.h"
Context not available.
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetThreadItemInfoHandler.h

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/Error.h"
#include "lldb/Symbol/CompilerType.h" #include "lldb/Symbol/CompilerType.h"
#include "lldb/Utility/Error.h"
#include "lldb/lldb-public.h" #include "lldb/lldb-public.h"
// This class will insert a UtilityFunction into the inferior process for // This class will insert a UtilityFunction into the inferior process for
Context not available.

lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetThreadItemInfoHandler.cpp

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/Value.h" #include "lldb/Core/Value.h"
#include "lldb/Expression/DiagnosticManager.h" #include "lldb/Expression/DiagnosticManager.h"
#include "lldb/Expression/Expression.h" #include "lldb/Expression/Expression.h"
Context not available.
#include "lldb/Target/StackFrame.h" #include "lldb/Target/StackFrame.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/StreamString.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
using namespace lldb; using namespace lldb;
Context not available.

lldb/source/Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.h

Context not available.
// Other libraries and framework include // Other libraries and framework include
// Project includes // Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Core/ModuleList.h" #include "lldb/Core/ModuleList.h"
#include "lldb/Core/StructuredData.h" #include "lldb/Core/StructuredData.h"
#include "lldb/Core/UUID.h" #include "lldb/Core/UUID.h"
Context not available.
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/QueueItem.h" #include "lldb/Target/QueueItem.h"
#include "lldb/Target/SystemRuntime.h" #include "lldb/Target/SystemRuntime.h"
#include "lldb/Utility/ConstString.h"
#include "AppleGetItemInfoHandler.h" #include "AppleGetItemInfoHandler.h"
#include "AppleGetPendingItemsHandler.h" #include "AppleGetPendingItemsHandler.h"
Context not available.

lldb/source/Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.cpp

Context not available.
#include "lldb/Core/ModuleSpec.h" #include "lldb/Core/ModuleSpec.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/Section.h" #include "lldb/Core/Section.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
#include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/ClangASTContext.h"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
Context not available.
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/ProcessStructReader.h" #include "lldb/Utility/ProcessStructReader.h"
#include "lldb/Utility/StreamString.h"
#include "SystemRuntimeMacOSX.h" #include "SystemRuntimeMacOSX.h"
Context not available.

lldb/source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.cpp

Context not available.
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/DataExtractor.h" #include "lldb/Core/DataExtractor.h"
#include "lldb/Core/Disassembler.h" #include "lldb/Core/Disassembler.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/FormatEntity.h" #include "lldb/Core/FormatEntity.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Target/ExecutionContext.h" #include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Plugins/UnwindAssembly/x86/UnwindAssembly-x86.cpp

Context not available.
#include "lldb/Core/Address.h" #include "lldb/Core/Address.h"
#include "lldb/Core/ArchSpec.h" #include "lldb/Core/ArchSpec.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Symbol/UnwindPlan.h" #include "lldb/Symbol/UnwindPlan.h"
#include "lldb/Target/ABI.h" #include "lldb/Target/ABI.h"
Context not available.
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Target/UnwindAssembly.h" #include "lldb/Target/UnwindAssembly.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/RegisterNumber.h" #include "lldb/Utility/RegisterNumber.h"
using namespace lldb; using namespace lldb;
Context not available.

lldb/source/Plugins/UnwindAssembly/x86/x86AssemblyInspectionEngine.h

Context not available.
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
#include "lldb/Core/ArchSpec.h" #include "lldb/Core/ArchSpec.h"
#include "lldb/Core/ConstString.h" #include "lldb/Utility/ConstString.h"
#include <map> #include <map>
#include <vector> #include <vector>
Context not available.

lldb/source/Symbol/ClangASTContext.cpp

Context not available.
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/RegularExpression.h"
#include "lldb/Core/Scalar.h" #include "lldb/Core/Scalar.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Core/ThreadSafeDenseMap.h" #include "lldb/Core/ThreadSafeDenseMap.h"
Context not available.
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/LLDBAssert.h" #include "lldb/Utility/LLDBAssert.h"
#include "lldb/Utility/RegularExpression.h"
#include "Plugins/SymbolFile/DWARF/DWARFASTParserClang.h" #include "Plugins/SymbolFile/DWARF/DWARFASTParserClang.h"
#include "Plugins/SymbolFile/PDB/PDBASTParser.h" #include "Plugins/SymbolFile/PDB/PDBASTParser.h"
Context not available.

lldb/source/Symbol/ClangExternalASTSourceCommon.cpp

Context not available.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Symbol/ClangExternalASTSourceCommon.h" #include "lldb/Symbol/ClangExternalASTSourceCommon.h"
#include "lldb/Core/Stream.h" #include "lldb/Utility/Stream.h"
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Symbol/CompactUnwindInfo.cpp

Context not available.
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/Section.h" #include "lldb/Core/Section.h"
#include "lldb/Core/Section.h" #include "lldb/Core/Section.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Symbol/CompactUnwindInfo.h" #include "lldb/Symbol/CompactUnwindInfo.h"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
#include "lldb/Symbol/UnwindPlan.h" #include "lldb/Symbol/UnwindPlan.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/StreamString.h"
#include "llvm/Support/MathExtras.h" #include "llvm/Support/MathExtras.h"
Context not available.

lldb/source/Symbol/CompilerType.cpp

Context not available.
#include "lldb/Symbol/CompilerType.h" #include "lldb/Symbol/CompilerType.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/DataExtractor.h" #include "lldb/Core/DataExtractor.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/Scalar.h" #include "lldb/Core/Scalar.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/ClangASTContext.h"
#include "lldb/Symbol/ClangExternalASTSourceCommon.h" #include "lldb/Symbol/ClangExternalASTSourceCommon.h"
#include "lldb/Symbol/Type.h" #include "lldb/Symbol/Type.h"
#include "lldb/Target/ExecutionContext.h" #include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Utility/StreamString.h"
#include <iterator> #include <iterator>
#include <mutex> #include <mutex>
Context not available.

lldb/source/Symbol/Declaration.cpp

Context not available.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Symbol/Declaration.h" #include "lldb/Symbol/Declaration.h"
#include "lldb/Core/Stream.h" #include "lldb/Utility/Stream.h"
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Symbol/JavaASTContext.cpp

Context not available.
#include "lldb/Core/DataExtractor.h" #include "lldb/Core/DataExtractor.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/Expression/DWARFExpression.h" #include "lldb/Expression/DWARFExpression.h"
Context not available.
#include "lldb/Symbol/SymbolFile.h" #include "lldb/Symbol/SymbolFile.h"
#include "lldb/Symbol/Type.h" #include "lldb/Symbol/Type.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Stream.h"
#include "Plugins/SymbolFile/DWARF/DWARFASTParserJava.h" #include "Plugins/SymbolFile/DWARF/DWARFASTParserJava.h"
Context not available.

lldb/source/Symbol/LineTable.cpp

Context not available.
#include "lldb/Core/Address.h" #include "lldb/Core/Address.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/Section.h" #include "lldb/Core/Section.h"
#include "lldb/Core/Stream.h"
#include "lldb/Symbol/CompileUnit.h" #include "lldb/Symbol/CompileUnit.h"
#include "lldb/Utility/Stream.h"
#include <algorithm> #include <algorithm>
using namespace lldb; using namespace lldb;
Context not available.

lldb/source/Symbol/ObjectFile.cpp

Context not available.
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/ModuleSpec.h" #include "lldb/Core/ModuleSpec.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/RegularExpression.h"
#include "lldb/Core/Section.h" #include "lldb/Core/Section.h"
#include "lldb/Core/Timer.h" #include "lldb/Core/Timer.h"
#include "lldb/Symbol/ObjectContainer.h" #include "lldb/Symbol/ObjectContainer.h"
#include "lldb/Symbol/SymbolFile.h" #include "lldb/Symbol/SymbolFile.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h" #include "lldb/Target/RegisterContext.h"
#include "lldb/Target/SectionLoadList.h" #include "lldb/Target/SectionLoadList.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/RegularExpression.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
using namespace lldb; using namespace lldb;
Context not available.

lldb/source/Symbol/Symbol.cpp

Context not available.
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/ModuleSpec.h" #include "lldb/Core/ModuleSpec.h"
#include "lldb/Core/Section.h" #include "lldb/Core/Section.h"
#include "lldb/Core/Stream.h"
#include "lldb/Symbol/Function.h" #include "lldb/Symbol/Function.h"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
#include "lldb/Symbol/SymbolVendor.h" #include "lldb/Symbol/SymbolVendor.h"
#include "lldb/Symbol/Symtab.h" #include "lldb/Symbol/Symtab.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Symbol/SymbolFile.cpp

Context not available.
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
#include "lldb/Symbol/TypeMap.h" #include "lldb/Symbol/TypeMap.h"
#include "lldb/Symbol/TypeSystem.h" #include "lldb/Symbol/TypeSystem.h"
#include "lldb/Symbol/VariableList.h" #include "lldb/Symbol/VariableList.h"
#include "lldb/Utility/StreamString.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Symbol/SymbolVendor.cpp

Context not available.
// Project includes // Project includes
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/Stream.h"
#include "lldb/Symbol/CompileUnit.h" #include "lldb/Symbol/CompileUnit.h"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
#include "lldb/Symbol/SymbolFile.h" #include "lldb/Symbol/SymbolFile.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Symbol/Symtab.cpp

Context not available.
#include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h" #include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
#include "Plugins/Language/ObjC/ObjCLanguage.h" #include "Plugins/Language/ObjC/ObjCLanguage.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/RegularExpression.h"
#include "lldb/Core/Section.h" #include "lldb/Core/Section.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/Timer.h" #include "lldb/Core/Timer.h"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
#include "lldb/Symbol/Symbol.h" #include "lldb/Symbol/Symbol.h"
#include "lldb/Symbol/SymbolContext.h" #include "lldb/Symbol/SymbolContext.h"
#include "lldb/Symbol/Symtab.h" #include "lldb/Symbol/Symtab.h"
#include "lldb/Utility/RegularExpression.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Symbol/Type.cpp

Context not available.
#include "lldb/Core/DataExtractor.h" #include "lldb/Core/DataExtractor.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/Scalar.h" #include "lldb/Core/Scalar.h"
#include "lldb/Core/StreamString.h" #include "lldb/Utility/StreamString.h"
#include "lldb/Symbol/CompilerType.h" #include "lldb/Symbol/CompilerType.h"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
Context not available.

lldb/source/Symbol/UnwindPlan.cpp

Context not available.
#include "lldb/Symbol/UnwindPlan.h" #include "lldb/Symbol/UnwindPlan.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h" #include "lldb/Target/RegisterContext.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/ConstString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Symbol/Variable.cpp

Context not available.
#include "lldb/Symbol/Variable.h" #include "lldb/Symbol/Variable.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/RegularExpression.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/Core/ValueObjectVariable.h" #include "lldb/Core/ValueObjectVariable.h"
#include "lldb/Symbol/Block.h" #include "lldb/Symbol/Block.h"
Context not available.
#include "lldb/Target/StackFrame.h" #include "lldb/Target/StackFrame.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/RegularExpression.h"
#include "lldb/Utility/Stream.h"
#include "llvm/ADT/Twine.h" #include "llvm/ADT/Twine.h"
Context not available.

lldb/source/Symbol/VariableList.cpp

Context not available.
#include "lldb/Symbol/VariableList.h" #include "lldb/Symbol/VariableList.h"
#include "lldb/Core/RegularExpression.h"
#include "lldb/Symbol/Block.h" #include "lldb/Symbol/Block.h"
#include "lldb/Symbol/CompileUnit.h" #include "lldb/Symbol/CompileUnit.h"
#include "lldb/Symbol/Function.h" #include "lldb/Symbol/Function.h"
#include "lldb/Utility/RegularExpression.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Target/FileAction.cpp

Context not available.
#include <fcntl.h> #include <fcntl.h>
#include "lldb/Core/Stream.h"
#include "lldb/Host/PosixApi.h" #include "lldb/Host/PosixApi.h"
#include "lldb/Target/FileAction.h" #include "lldb/Target/FileAction.h"
#include "lldb/Utility/Stream.h"
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Target/InstrumentationRuntime.cpp

Context not available.
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/ModuleList.h" #include "lldb/Core/ModuleList.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/RegularExpression.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Utility/RegularExpression.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
using namespace lldb; using namespace lldb;
Context not available.

lldb/source/Target/Language.cpp

Context not available.
#include "lldb/Target/Language.h" #include "lldb/Target/Language.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/Stream.h"
#include "lldb/Symbol/SymbolFile.h" #include "lldb/Symbol/SymbolFile.h"
#include "lldb/Symbol/TypeList.h" #include "lldb/Symbol/TypeList.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Target/PathMappingList.cpp

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/Error.h"
#include "lldb/Core/Stream.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
#include "lldb/Host/PosixApi.h" #include "lldb/Host/PosixApi.h"
#include "lldb/Target/PathMappingList.h" #include "lldb/Target/PathMappingList.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Target/Platform.cpp

Context not available.
#include "lldb/Breakpoint/BreakpointLocation.h" #include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/ModuleSpec.h" #include "lldb/Core/ModuleSpec.h"
Context not available.
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/UnixSignals.h" #include "lldb/Target/UnixSignals.h"
#include "lldb/Utility/Error.h"
// Define these constants from POSIX mman.h rather than include the file // Define these constants from POSIX mman.h rather than include the file
// so that they will be correct even when compiled on Linux. // so that they will be correct even when compiled on Linux.
Context not available.

lldb/source/Target/ProcessInfo.cpp

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/Stream.h"
#include "lldb/Host/PosixApi.h" #include "lldb/Host/PosixApi.h"
#include "lldb/Utility/Stream.h"
#include "llvm/ADT/SmallString.h" #include "llvm/ADT/SmallString.h"
Context not available.

lldb/source/Target/SectionLoadHistory.cpp

Context not available.
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/Stream.h"
#include "lldb/Target/SectionLoadList.h" #include "lldb/Target/SectionLoadList.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Target/SectionLoadList.cpp

Context not available.
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/Section.h" #include "lldb/Core/Section.h"
#include "lldb/Core/Stream.h"
#include "lldb/Symbol/Block.h" #include "lldb/Symbol/Block.h"
#include "lldb/Symbol/Symbol.h" #include "lldb/Symbol/Symbol.h"
#include "lldb/Symbol/SymbolContext.h" #include "lldb/Symbol/SymbolContext.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Target/StackID.cpp

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Target/StackID.h" #include "lldb/Target/StackID.h"
#include "lldb/Core/Stream.h"
#include "lldb/Symbol/Block.h" #include "lldb/Symbol/Block.h"
#include "lldb/Symbol/Symbol.h" #include "lldb/Symbol/Symbol.h"
#include "lldb/Symbol/SymbolContext.h" #include "lldb/Symbol/SymbolContext.h"
#include "lldb/Utility/Stream.h"
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Target/StopInfo.cpp

Context not available.
#include "lldb/Breakpoint/Watchpoint.h" #include "lldb/Breakpoint/Watchpoint.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/Expression/UserExpression.h" #include "lldb/Expression/UserExpression.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
Context not available.
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Target/ThreadPlan.h" #include "lldb/Target/ThreadPlan.h"
#include "lldb/Target/UnixSignals.h" #include "lldb/Target/UnixSignals.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Target/Target.cpp

Context not available.
#include "lldb/Core/SourceManager.h" #include "lldb/Core/SourceManager.h"
#include "lldb/Core/State.h" #include "lldb/Core/State.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/Timer.h" #include "lldb/Core/Timer.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/Expression/REPL.h" #include "lldb/Expression/REPL.h"
Context not available.
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Target/ThreadSpec.h" #include "lldb/Target/ThreadSpec.h"
#include "lldb/Utility/LLDBAssert.h" #include "lldb/Utility/LLDBAssert.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Target/Thread.cpp

Context not available.
#include "lldb/Core/FormatEntity.h" #include "lldb/Core/FormatEntity.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/RegularExpression.h"
#include "lldb/Core/State.h" #include "lldb/Core/State.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Interpreter/OptionValueFileSpecList.h" #include "lldb/Interpreter/OptionValueFileSpecList.h"
Context not available.
#include "lldb/Target/ThreadPlanStepUntil.h" #include "lldb/Target/ThreadPlanStepUntil.h"
#include "lldb/Target/ThreadSpec.h" #include "lldb/Target/ThreadSpec.h"
#include "lldb/Target/Unwind.h" #include "lldb/Target/Unwind.h"
#include "lldb/Utility/RegularExpression.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Target/ThreadPlanBase.cpp

Context not available.
#include "lldb/Breakpoint/BreakpointSite.h" #include "lldb/Breakpoint/BreakpointSite.h"
#include "lldb/Breakpoint/StoppointCallbackContext.h" #include "lldb/Breakpoint/StoppointCallbackContext.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Stream.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h" #include "lldb/Target/RegisterContext.h"
#include "lldb/Target/StopInfo.h" #include "lldb/Target/StopInfo.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Target/ThreadPlanCallFunction.cpp

Context not available.
#include "lldb/Core/Address.h" #include "lldb/Core/Address.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/Stream.h"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
#include "lldb/Target/ABI.h" #include "lldb/Target/ABI.h"
#include "lldb/Target/LanguageRuntime.h" #include "lldb/Target/LanguageRuntime.h"
Context not available.
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Target/ThreadPlanRunToAddress.h" #include "lldb/Target/ThreadPlanRunToAddress.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Target/ThreadPlanCallFunctionUsingABI.cpp

Context not available.
#include "lldb/Target/ThreadPlanCallFunctionUsingABI.h" #include "lldb/Target/ThreadPlanCallFunctionUsingABI.h"
#include "lldb/Core/Address.h" #include "lldb/Core/Address.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Stream.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h" #include "lldb/Target/RegisterContext.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Target/ThreadPlanCallUserExpression.cpp

Context not available.
#include "lldb/Breakpoint/BreakpointLocation.h" #include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Core/Address.h" #include "lldb/Core/Address.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Stream.h"
#include "lldb/Expression/DiagnosticManager.h" #include "lldb/Expression/DiagnosticManager.h"
#include "lldb/Expression/IRDynamicChecks.h" #include "lldb/Expression/IRDynamicChecks.h"
#include "lldb/Expression/UserExpression.h" #include "lldb/Expression/UserExpression.h"
Context not available.
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Target/ThreadPlanRunToAddress.h" #include "lldb/Target/ThreadPlanRunToAddress.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Target/ThreadPlanRunToAddress.cpp

Context not available.
// Project includes // Project includes
#include "lldb/Target/ThreadPlanRunToAddress.h" #include "lldb/Target/ThreadPlanRunToAddress.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Stream.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h" #include "lldb/Target/RegisterContext.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Target/ThreadPlanStepInRange.cpp

Context not available.
#include "lldb/Target/ThreadPlanStepInRange.h" #include "lldb/Target/ThreadPlanStepInRange.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/RegularExpression.h"
#include "lldb/Core/Stream.h"
#include "lldb/Symbol/Function.h" #include "lldb/Symbol/Function.h"
#include "lldb/Symbol/Symbol.h" #include "lldb/Symbol/Symbol.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
Context not available.
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Target/ThreadPlanStepOut.h" #include "lldb/Target/ThreadPlanStepOut.h"
#include "lldb/Target/ThreadPlanStepThrough.h" #include "lldb/Target/ThreadPlanStepThrough.h"
#include "lldb/Utility/RegularExpression.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Target/ThreadPlanStepInstruction.cpp

Context not available.
// Project includes // Project includes
#include "lldb/Target/ThreadPlanStepInstruction.h" #include "lldb/Target/ThreadPlanStepInstruction.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Stream.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h" #include "lldb/Target/RegisterContext.h"
#include "lldb/Target/RegisterContext.h" #include "lldb/Target/RegisterContext.h"
#include "lldb/Target/StopInfo.h" #include "lldb/Target/StopInfo.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Target/ThreadPlanStepOverBreakpoint.cpp

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Stream.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h" #include "lldb/Target/RegisterContext.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Target/ThreadPlanStepOverRange.cpp

Context not available.
// Project includes // Project includes
#include "lldb/Target/ThreadPlanStepOverRange.h" #include "lldb/Target/ThreadPlanStepOverRange.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Stream.h"
#include "lldb/Symbol/Block.h" #include "lldb/Symbol/Block.h"
#include "lldb/Symbol/CompileUnit.h" #include "lldb/Symbol/CompileUnit.h"
#include "lldb/Symbol/Function.h" #include "lldb/Symbol/Function.h"
Context not available.
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Target/ThreadPlanStepOut.h" #include "lldb/Target/ThreadPlanStepOut.h"
#include "lldb/Target/ThreadPlanStepThrough.h" #include "lldb/Target/ThreadPlanStepThrough.h"
#include "lldb/Utility/Stream.h"
using namespace lldb_private; using namespace lldb_private;
using namespace lldb; using namespace lldb;
Context not available.

lldb/source/Target/ThreadPlanStepRange.cpp

Context not available.
#include "lldb/Breakpoint/BreakpointSite.h" #include "lldb/Breakpoint/BreakpointSite.h"
#include "lldb/Core/Disassembler.h" #include "lldb/Core/Disassembler.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Stream.h"
#include "lldb/Symbol/Function.h" #include "lldb/Symbol/Function.h"
#include "lldb/Symbol/Symbol.h" #include "lldb/Symbol/Symbol.h"
#include "lldb/Target/ExecutionContext.h" #include "lldb/Target/ExecutionContext.h"
Context not available.
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Target/ThreadPlanRunToAddress.h" #include "lldb/Target/ThreadPlanRunToAddress.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Target/ThreadPlanStepThrough.cpp

Context not available.
#include "lldb/Target/ThreadPlanStepThrough.h" #include "lldb/Target/ThreadPlanStepThrough.h"
#include "lldb/Breakpoint/Breakpoint.h" #include "lldb/Breakpoint/Breakpoint.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Stream.h"
#include "lldb/Target/DynamicLoader.h" #include "lldb/Target/DynamicLoader.h"
#include "lldb/Target/ObjCLanguageRuntime.h" #include "lldb/Target/ObjCLanguageRuntime.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h" #include "lldb/Target/RegisterContext.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/source/Utility/CMakeLists.txt

add_lldb_library(lldbUtility add_lldb_library(lldbUtility
ConstString.cpp
Error.cpp
JSON.cpp JSON.cpp
LLDBAssert.cpp LLDBAssert.cpp
ModuleCache.cpp ModuleCache.cpp
Context not available.
PseudoTerminal.cpp PseudoTerminal.cpp
Range.cpp Range.cpp
RegisterNumber.cpp RegisterNumber.cpp
RegularExpression.cpp
SelectHelper.cpp SelectHelper.cpp
SharingPtr.cpp SharingPtr.cpp
Stream.cpp
StreamString.cpp
StringExtractor.cpp StringExtractor.cpp
StringExtractorGDBRemote.cpp StringExtractorGDBRemote.cpp
StringLexer.cpp StringLexer.cpp
Context not available.

lldb/source/Utility/ConstString.cpp

  • This file was added.
//===-- ConstString.cpp -----------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "lldb/Utility/ConstString.h"
// C Includes
// C++ Includes
#include <array>
#include <mutex>
// Other libraries and framework includes
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringMap.h"
#include "llvm/Support/RWMutex.h"
// Project includes
#include "lldb/Utility/Stream.h"
using namespace lldb_private;
class Pool {
public:
typedef const char *StringPoolValueType;
typedef llvm::StringMap<StringPoolValueType, llvm::BumpPtrAllocator>
StringPool;
typedef llvm::StringMapEntry<StringPoolValueType> StringPoolEntryType;
static StringPoolEntryType &
GetStringMapEntryFromKeyData(const char *keyData) {
char *ptr = const_cast<char *>(keyData) - sizeof(StringPoolEntryType);
return *reinterpret_cast<StringPoolEntryType *>(ptr);
}
size_t GetConstCStringLength(const char *ccstr) const {
if (ccstr != nullptr) {
const uint8_t h = hash(llvm::StringRef(ccstr));
llvm::sys::SmartScopedReader<false> rlock(m_string_pools[h].m_mutex);
const StringPoolEntryType &entry = GetStringMapEntryFromKeyData(ccstr);
return entry.getKey().size();
}
return 0;
}
StringPoolValueType GetMangledCounterpart(const char *ccstr) const {
if (ccstr != nullptr) {
const uint8_t h = hash(llvm::StringRef(ccstr));
llvm::sys::SmartScopedReader<false> rlock(m_string_pools[h].m_mutex);
return GetStringMapEntryFromKeyData(ccstr).getValue();
}
return nullptr;
}
bool SetMangledCounterparts(const char *key_ccstr, const char *value_ccstr) {
if (key_ccstr != nullptr && value_ccstr != nullptr) {
{
const uint8_t h = hash(llvm::StringRef(key_ccstr));
llvm::sys::SmartScopedWriter<false> wlock(m_string_pools[h].m_mutex);
GetStringMapEntryFromKeyData(key_ccstr).setValue(value_ccstr);
}
{
const uint8_t h = hash(llvm::StringRef(value_ccstr));
llvm::sys::SmartScopedWriter<false> wlock(m_string_pools[h].m_mutex);
GetStringMapEntryFromKeyData(value_ccstr).setValue(key_ccstr);
}
return true;
}
return false;
}
const char *GetConstCString(const char *cstr) {
if (cstr != nullptr)
return GetConstCStringWithLength(cstr, strlen(cstr));
return nullptr;
}
const char *GetConstCStringWithLength(const char *cstr, size_t cstr_len) {
if (cstr != nullptr)
return GetConstCStringWithStringRef(llvm::StringRef(cstr, cstr_len));
return nullptr;
}
const char *GetConstCStringWithStringRef(const llvm::StringRef &string_ref) {
if (string_ref.data()) {
const uint8_t h = hash(string_ref);
{
llvm::sys::SmartScopedReader<false> rlock(m_string_pools[h].m_mutex);
auto it = m_string_pools[h].m_string_map.find(string_ref);
if (it != m_string_pools[h].m_string_map.end())
return it->getKeyData();
}
llvm::sys::SmartScopedWriter<false> wlock(m_string_pools[h].m_mutex);
StringPoolEntryType &entry =
*m_string_pools[h]
.m_string_map.insert(std::make_pair(string_ref, nullptr))
.first;
return entry.getKeyData();
}
return nullptr;
}
const char *
GetConstCStringAndSetMangledCounterPart(const char *demangled_cstr,
const char *mangled_ccstr) {
if (demangled_cstr != nullptr) {
const char *demangled_ccstr = nullptr;
{
llvm::StringRef string_ref(demangled_cstr);
const uint8_t h = hash(string_ref);
llvm::sys::SmartScopedWriter<false> wlock(m_string_pools[h].m_mutex);
// Make string pool entry with the mangled counterpart already set
StringPoolEntryType &entry =
*m_string_pools[h]
.m_string_map.insert(std::make_pair(string_ref, mangled_ccstr))
.first;
// Extract the const version of the demangled_cstr
demangled_ccstr = entry.getKeyData();
}
{
// Now assign the demangled const string as the counterpart of the
// mangled const string...
const uint8_t h = hash(llvm::StringRef(mangled_ccstr));
llvm::sys::SmartScopedWriter<false> wlock(m_string_pools[h].m_mutex);
GetStringMapEntryFromKeyData(mangled_ccstr).setValue(demangled_ccstr);
}
// Return the constant demangled C string
return demangled_ccstr;
}
return nullptr;
}
const char *GetConstTrimmedCStringWithLength(const char *cstr,
size_t cstr_len) {
if (cstr != nullptr) {
const size_t trimmed_len = std::min<size_t>(strlen(cstr), cstr_len);
return GetConstCStringWithLength(cstr, trimmed_len);
}
return nullptr;
}
//------------------------------------------------------------------
// Return the size in bytes that this object and any items in its
// collection of uniqued strings + data count values takes in
// memory.
//------------------------------------------------------------------
size_t MemorySize() const {
size_t mem_size = sizeof(Pool);
for (const auto &pool : m_string_pools) {
llvm::sys::SmartScopedReader<false> rlock(pool.m_mutex);
for (const auto &entry : pool.m_string_map)
mem_size += sizeof(StringPoolEntryType) + entry.getKey().size();
}
return mem_size;
}
protected:
uint8_t hash(const llvm::StringRef &s) const {
uint32_t h = llvm::HashString(s);
return ((h >> 24) ^ (h >> 16) ^ (h >> 8) ^ h) & 0xff;
}
struct PoolEntry {
mutable llvm::sys::SmartRWMutex<false> m_mutex;
StringPool m_string_map;
};
std::array<PoolEntry, 256> m_string_pools;
};
//----------------------------------------------------------------------
// Frameworks and dylibs aren't supposed to have global C++
// initializers so we hide the string pool in a static function so
// that it will get initialized on the first call to this static
// function.
//
// Note, for now we make the string pool a pointer to the pool, because
// we can't guarantee that some objects won't get destroyed after the
// global destructor chain is run, and trying to make sure no destructors
// touch ConstStrings is difficult. So we leak the pool instead.
//----------------------------------------------------------------------
static Pool &StringPool() {
static std::once_flag g_pool_initialization_flag;
static Pool *g_string_pool = nullptr;
std::call_once(g_pool_initialization_flag,
[]() { g_string_pool = new Pool(); });
return *g_string_pool;
}
ConstString::ConstString(const char *cstr)
: m_string(StringPool().GetConstCString(cstr)) {}
ConstString::ConstString(const char *cstr, size_t cstr_len)
: m_string(StringPool().GetConstCStringWithLength(cstr, cstr_len)) {}
ConstString::ConstString(const llvm::StringRef &s)
: m_string(StringPool().GetConstCStringWithLength(s.data(), s.size())) {}
bool ConstString::operator<(const ConstString &rhs) const {
if (m_string == rhs.m_string)
return false;
llvm::StringRef lhs_string_ref(m_string,
StringPool().GetConstCStringLength(m_string));
llvm::StringRef rhs_string_ref(
rhs.m_string, StringPool().GetConstCStringLength(rhs.m_string));
// If both have valid C strings, then return the comparison
if (lhs_string_ref.data() && rhs_string_ref.data())
return lhs_string_ref < rhs_string_ref;
// Else one of them was nullptr, so if LHS is nullptr then it is less than
return lhs_string_ref.data() == nullptr;
}
Stream &lldb_private::operator<<(Stream &s, const ConstString &str) {
const char *cstr = str.GetCString();
if (cstr != nullptr)
s << cstr;
return s;
}
size_t ConstString::GetLength() const {
return StringPool().GetConstCStringLength(m_string);
}
bool ConstString::Equals(const ConstString &lhs, const ConstString &rhs,
const bool case_sensitive) {
if (lhs.m_string == rhs.m_string)
return true;
// Since the pointers weren't equal, and identical ConstStrings always have
// identical pointers,
// the result must be false for case sensitive equality test.
if (case_sensitive)
return false;
// perform case insensitive equality test
llvm::StringRef lhs_string_ref(
lhs.m_string, StringPool().GetConstCStringLength(lhs.m_string));
llvm::StringRef rhs_string_ref(
rhs.m_string, StringPool().GetConstCStringLength(rhs.m_string));
return lhs_string_ref.equals_lower(rhs_string_ref);
}
int ConstString::Compare(const ConstString &lhs, const ConstString &rhs,
const bool case_sensitive) {
// If the iterators are the same, this is the same string
const char *lhs_cstr = lhs.m_string;
const char *rhs_cstr = rhs.m_string;
if (lhs_cstr == rhs_cstr)
return 0;
if (lhs_cstr && rhs_cstr) {
llvm::StringRef lhs_string_ref(
lhs_cstr, StringPool().GetConstCStringLength(lhs_cstr));
llvm::StringRef rhs_string_ref(
rhs_cstr, StringPool().GetConstCStringLength(rhs_cstr));
if (case_sensitive) {
return lhs_string_ref.compare(rhs_string_ref);
} else {
return lhs_string_ref.compare_lower(rhs_string_ref);
}
}
if (lhs_cstr)
return +1; // LHS isn't nullptr but RHS is
else
return -1; // LHS is nullptr but RHS isn't
}
void ConstString::Dump(Stream *s, const char *fail_value) const {
if (s != nullptr) {
const char *cstr = AsCString(fail_value);
if (cstr != nullptr)
s->PutCString(cstr);
}
}
void ConstString::DumpDebug(Stream *s) const {
const char *cstr = GetCString();
size_t cstr_len = GetLength();
// Only print the parens if we have a non-nullptr string
const char *parens = cstr ? "\"" : "";
s->Printf("%*p: ConstString, string = %s%s%s, length = %" PRIu64,
static_cast<int>(sizeof(void *) * 2),
static_cast<const void *>(this), parens, cstr, parens,
static_cast<uint64_t>(cstr_len));
}
void ConstString::SetCString(const char *cstr) {
m_string = StringPool().GetConstCString(cstr);
}
void ConstString::SetString(const llvm::StringRef &s) {
m_string = StringPool().GetConstCStringWithLength(s.data(), s.size());
}
void ConstString::SetCStringWithMangledCounterpart(const char *demangled,
const ConstString &mangled) {
m_string = StringPool().GetConstCStringAndSetMangledCounterPart(
demangled, mangled.m_string);
}
bool ConstString::GetMangledCounterpart(ConstString &counterpart) const {
counterpart.m_string = StringPool().GetMangledCounterpart(m_string);
return (bool)counterpart;
}
void ConstString::SetCStringWithLength(const char *cstr, size_t cstr_len) {
m_string = StringPool().GetConstCStringWithLength(cstr, cstr_len);
}
void ConstString::SetTrimmedCStringWithLength(const char *cstr,
size_t cstr_len) {
m_string = StringPool().GetConstTrimmedCStringWithLength(cstr, cstr_len);
}
size_t ConstString::StaticMemorySize() {
// Get the size of the static string pool
return StringPool().MemorySize();
}

lldb/source/Utility/Error.cpp

  • This file was added.
//===-- Error.cpp -----------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// C Includes
#ifdef __APPLE__
#include <mach/mach.h>
#endif
// C++ Includes
#include <cerrno>
#include <cstdarg>
// Other libraries and framework includes
#include "llvm/ADT/SmallVector.h"
// Project includes
#include "lldb/Core/Log.h"
#include "lldb/Host/PosixApi.h"
#include "lldb/Utility/Error.h"
using namespace lldb;
using namespace lldb_private;
Error::Error() : m_code(0), m_type(eErrorTypeInvalid), m_string() {}
Error::Error(ValueType err, ErrorType type)
: m_code(err), m_type(type), m_string() {}
Error::Error(const Error &rhs) = default;
Error::Error(const char *format, ...)
: m_code(0), m_type(eErrorTypeInvalid), m_string() {
va_list args;
va_start(args, format);
SetErrorToGenericError();
SetErrorStringWithVarArg(format, args);
va_end(args);
}
//----------------------------------------------------------------------
// Assignment operator
//----------------------------------------------------------------------
const Error &Error::operator=(const Error &rhs) {
if (this != &rhs) {
m_code = rhs.m_code;
m_type = rhs.m_type;
m_string = rhs.m_string;
}
return *this;
}
//----------------------------------------------------------------------
// Assignment operator
//----------------------------------------------------------------------
const Error &Error::operator=(uint32_t err) {
m_code = err;
m_type = eErrorTypeMachKernel;
m_string.clear();
return *this;
}
Error::~Error() = default;
//----------------------------------------------------------------------
// Get the error value as a NULL C string. The error string will be
// fetched and cached on demand. The cached error string value will
// remain until the error value is changed or cleared.
//----------------------------------------------------------------------
const char *Error::AsCString(const char *default_error_str) const {
if (Success())
return nullptr;
if (m_string.empty()) {
const char *s = nullptr;
switch (m_type) {
case eErrorTypeMachKernel:
#if defined(__APPLE__)
s = ::mach_error_string(m_code);
#endif
break;
case eErrorTypePOSIX:
s = ::strerror(m_code);
break;
default:
break;
}
if (s != nullptr)
m_string.assign(s);
}
if (m_string.empty()) {
if (default_error_str)
m_string.assign(default_error_str);
else
return nullptr; // User wanted a nullptr string back...
}
return m_string.c_str();
}
//----------------------------------------------------------------------
// Clear the error and any cached error string that it might contain.
//----------------------------------------------------------------------
void Error::Clear() {
m_code = 0;
m_type = eErrorTypeInvalid;
m_string.clear();
}
//----------------------------------------------------------------------
// Access the error value.
//----------------------------------------------------------------------
Error::ValueType Error::GetError() const { return m_code; }
//----------------------------------------------------------------------
// Access the error type.
//----------------------------------------------------------------------
ErrorType Error::GetType() const { return m_type; }
//----------------------------------------------------------------------
// Returns true if this object contains a value that describes an
// error or otherwise non-success result.
//----------------------------------------------------------------------
bool Error::Fail() const { return m_code != 0; }
//----------------------------------------------------------------------
// Log the error given a string with format. If the this object
// contains an error code, update the error string to contain the
// "error: " followed by the formatted string, followed by the error
// value and any string that describes the current error. This
// allows more context to be given to an error string that remains
// cached in this object. Logging always occurs even when the error
// code contains a non-error value.
//----------------------------------------------------------------------
void Error::PutToLog(Log *log, const char *format, ...) {
char *arg_msg = nullptr;
va_list args;
va_start(args, format);
::vasprintf(&arg_msg, format, args);
va_end(args);
if (arg_msg != nullptr) {
if (Fail()) {
const char *err_str = AsCString();
if (err_str == nullptr)
err_str = "???";
SetErrorStringWithFormat("error: %s err = %s (0x%8.8x)", arg_msg, err_str,
m_code);
if (log != nullptr)
log->Error("%s", m_string.c_str());
} else {
if (log != nullptr)
log->Printf("%s err = 0x%8.8x", arg_msg, m_code);
}
::free(arg_msg);
}
}
//----------------------------------------------------------------------
// Log the error given a string with format. If the this object
// contains an error code, update the error string to contain the
// "error: " followed by the formatted string, followed by the error
// value and any string that describes the current error. This
// allows more context to be given to an error string that remains
// cached in this object. Logging only occurs even when the error
// code contains a error value.
//----------------------------------------------------------------------
void Error::LogIfError(Log *log, const char *format, ...) {
if (Fail()) {
char *arg_msg = nullptr;
va_list args;
va_start(args, format);
::vasprintf(&arg_msg, format, args);
va_end(args);
if (arg_msg != nullptr) {
const char *err_str = AsCString();
if (err_str == nullptr)
err_str = "???";
SetErrorStringWithFormat("%s err = %s (0x%8.8x)", arg_msg, err_str,
m_code);
if (log != nullptr)
log->Error("%s", m_string.c_str());
::free(arg_msg);
}
}
}
//----------------------------------------------------------------------
// Set accesssor for the error value to "err" and the type to
// "eErrorTypeMachKernel"
//----------------------------------------------------------------------
void Error::SetMachError(uint32_t err) {
m_code = err;
m_type = eErrorTypeMachKernel;
m_string.clear();
}
void Error::SetExpressionError(lldb::ExpressionResults result,
const char *mssg) {
m_code = result;
m_type = eErrorTypeExpression;
m_string = mssg;
}
int Error::SetExpressionErrorWithFormat(lldb::ExpressionResults result,
const char *format, ...) {
int length = 0;
if (format != nullptr && format[0]) {
va_list args;
va_start(args, format);
length = SetErrorStringWithVarArg(format, args);
va_end(args);
} else {
m_string.clear();
}
m_code = result;
m_type = eErrorTypeExpression;
return length;
}
//----------------------------------------------------------------------
// Set accesssor for the error value and type.
//----------------------------------------------------------------------
void Error::SetError(ValueType err, ErrorType type) {
m_code = err;
m_type = type;
m_string.clear();
}
//----------------------------------------------------------------------
// Update the error value to be "errno" and update the type to
// be "POSIX".
//----------------------------------------------------------------------
void Error::SetErrorToErrno() {
m_code = errno;
m_type = eErrorTypePOSIX;
m_string.clear();
}
//----------------------------------------------------------------------
// Update the error value to be LLDB_GENERIC_ERROR and update the type
// to be "Generic".
//----------------------------------------------------------------------
void Error::SetErrorToGenericError() {
m_code = LLDB_GENERIC_ERROR;
m_type = eErrorTypeGeneric;
m_string.clear();
}
//----------------------------------------------------------------------
// Set accessor for the error string value for a specific error.
// This allows any string to be supplied as an error explanation.
// The error string value will remain until the error value is
// cleared or a new error value/type is assigned.
//----------------------------------------------------------------------
void Error::SetErrorString(llvm::StringRef err_str) {
if (!err_str.empty()) {
// If we have an error string, we should always at least have an error
// set to a generic value.
if (Success())
SetErrorToGenericError();
}
m_string = err_str;
}
//------------------------------------------------------------------
/// Set the current error string to a formatted error string.
///
/// @param format
/// A printf style format string
//------------------------------------------------------------------
int Error::SetErrorStringWithFormat(const char *format, ...) {
if (format != nullptr && format[0]) {
va_list args;
va_start(args, format);
int length = SetErrorStringWithVarArg(format, args);
va_end(args);
return length;
} else {
m_string.clear();
}
return 0;
}
int Error::SetErrorStringWithVarArg(const char *format, va_list args) {
if (format != nullptr && format[0]) {
// If we have an error string, we should always at least have
// an error set to a generic value.
if (Success())
SetErrorToGenericError();
// Try and fit our error into a 1024 byte buffer first...
llvm::SmallVector<char, 1024> buf;
buf.resize(1024);
// Copy in case our first call to vsnprintf doesn't fit into our
// allocated buffer above
va_list copy_args;
va_copy(copy_args, args);
unsigned length = ::vsnprintf(buf.data(), buf.size(), format, args);
if (length >= buf.size()) {
// The error formatted string didn't fit into our buffer, resize it
// to the exact needed size, and retry
buf.resize(length + 1);
length = ::vsnprintf(buf.data(), buf.size(), format, copy_args);
va_end(copy_args);
assert(length < buf.size());
}
m_string.assign(buf.data(), length);
va_end(args);
return length;
} else {
m_string.clear();
}
return 0;
}
//----------------------------------------------------------------------
// Returns true if the error code in this object is considered a
// successful return value.
//----------------------------------------------------------------------
bool Error::Success() const { return m_code == 0; }
bool Error::WasInterrupted() const {
return (m_type == eErrorTypePOSIX && m_code == EINTR);
}

lldb/source/Utility/JSON.cpp

Context not available.
#include "lldb/Utility/JSON.h" #include "lldb/Utility/JSON.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Host/StringConvert.h" #include "lldb/Host/StringConvert.h"
#include "lldb/Utility/StreamString.h"
#include "llvm/Support/ErrorHandling.h" #include "llvm/Support/ErrorHandling.h"
#include <limits.h> #include <limits.h>
Context not available.

lldb/source/Utility/ModuleCache.h

Context not available.
#include "lldb/lldb-forward.h" #include "lldb/lldb-forward.h"
#include "lldb/lldb-types.h" #include "lldb/lldb-types.h"
#include "lldb/Core/Error.h"
#include "lldb/Host/File.h" #include "lldb/Host/File.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
#include "lldb/Utility/Error.h"
#include <functional> #include <functional>
#include <string> #include <string>
Context not available.

lldb/source/Utility/NameMatches.cpp

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Utility/NameMatches.h" #include "lldb/Utility/NameMatches.h"
#include "lldb/Core/RegularExpression.h" #include "lldb/Utility/RegularExpression.h"
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
Context not available.

lldb/source/Utility/RegularExpression.cpp

  • This file was added.
//===-- RegularExpression.cpp -----------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "lldb/Utility/RegularExpression.h"
// C Includes
// C++ Includes
#include <cstring>
// Other libraries and framework includes
#include "llvm/ADT/StringRef.h"
// Project includes
#include "lldb/Utility/Error.h"
//----------------------------------------------------------------------
// Enable enhanced mode if it is available. This allows for things like
// \d for digit, \s for space, and many more, but it isn't available
// everywhere.
//----------------------------------------------------------------------
#if defined(REG_ENHANCED)
#define DEFAULT_COMPILE_FLAGS (REG_ENHANCED | REG_EXTENDED)
#else
#define DEFAULT_COMPILE_FLAGS (REG_EXTENDED)
#endif
using namespace lldb_private;
RegularExpression::RegularExpression() : m_re(), m_comp_err(1), m_preg() {
memset(&m_preg, 0, sizeof(m_preg));
}
//----------------------------------------------------------------------
// Constructor that compiles "re" using "flags" and stores the
// resulting compiled regular expression into this object.
//----------------------------------------------------------------------
RegularExpression::RegularExpression(llvm::StringRef str)
: m_re(), m_comp_err(1), m_preg() {
memset(&m_preg, 0, sizeof(m_preg));
Compile(str);
}
RegularExpression::RegularExpression(const RegularExpression &rhs) {
memset(&m_preg, 0, sizeof(m_preg));
Compile(rhs.GetText());
}
const RegularExpression &RegularExpression::
operator=(const RegularExpression &rhs) {
if (&rhs != this)
Compile(rhs.GetText());
return *this;
}
//----------------------------------------------------------------------
// Destructor
//
// Any previously compiled regular expression contained in this
// object will be freed.
//----------------------------------------------------------------------
RegularExpression::~RegularExpression() { Free(); }
//----------------------------------------------------------------------
// Compile a regular expression using the supplied regular
// expression text and flags. The compiled regular expression lives
// in this object so that it can be readily used for regular
// expression matches. Execute() can be called after the regular
// expression is compiled. Any previously compiled regular
// expression contained in this object will be freed.
//
// RETURNS
// True if the regular expression compiles successfully, false
// otherwise.
//----------------------------------------------------------------------
bool RegularExpression::Compile(llvm::StringRef str) {
Free();
if (!str.empty()) {
m_re = str;
m_comp_err = ::regcomp(&m_preg, m_re.c_str(), DEFAULT_COMPILE_FLAGS);
} else {
// No valid regular expression
m_comp_err = 1;
}
return m_comp_err == 0;
}
//----------------------------------------------------------------------
// Execute a regular expression match using the compiled regular
// expression that is already in this object against the match
// string "s". If any parens are used for regular expression
// matches "match_count" should indicate the number of regmatch_t
// values that are present in "match_ptr". The regular expression
// will be executed using the "execute_flags".
//---------------------------------------------------------------------
bool RegularExpression::Execute(llvm::StringRef str, Match *match) const {
int err = 1;
if (m_comp_err == 0) {
// Argument to regexec must be null-terminated.
std::string reg_str = str;
if (match) {
err = ::regexec(&m_preg, reg_str.c_str(), match->GetSize(),
match->GetData(), 0);
} else {
err = ::regexec(&m_preg, reg_str.c_str(), 0, nullptr, 0);
}
}
if (err != 0) {
// The regular expression didn't compile, so clear the matches
if (match)
match->Clear();
return false;
}
return true;
}
bool RegularExpression::Match::GetMatchAtIndex(llvm::StringRef s, uint32_t idx,
std::string &match_str) const {
llvm::StringRef match_str_ref;
if (GetMatchAtIndex(s, idx, match_str_ref)) {
match_str = match_str_ref.str();
return true;
}
return false;
}
bool RegularExpression::Match::GetMatchAtIndex(
llvm::StringRef s, uint32_t idx, llvm::StringRef &match_str) const {
if (idx < m_matches.size()) {
if (m_matches[idx].rm_eo == -1 && m_matches[idx].rm_so == -1)
return false;
if (m_matches[idx].rm_eo == m_matches[idx].rm_so) {
// Matched the empty string...
match_str = llvm::StringRef();
return true;
} else if (m_matches[idx].rm_eo > m_matches[idx].rm_so) {
match_str = s.substr(m_matches[idx].rm_so,
m_matches[idx].rm_eo - m_matches[idx].rm_so);
return true;
}
}
return false;
}
bool RegularExpression::Match::GetMatchSpanningIndices(
llvm::StringRef s, uint32_t idx1, uint32_t idx2,
llvm::StringRef &match_str) const {
if (idx1 < m_matches.size() && idx2 < m_matches.size()) {
if (m_matches[idx1].rm_so == m_matches[idx2].rm_eo) {
// Matched the empty string...
match_str = llvm::StringRef();
return true;
} else if (m_matches[idx1].rm_so < m_matches[idx2].rm_eo) {
match_str = s.substr(m_matches[idx1].rm_so,
m_matches[idx2].rm_eo - m_matches[idx1].rm_so);
return true;
}
}
return false;
}
//----------------------------------------------------------------------
// Returns true if the regular expression compiled and is ready
// for execution.
//----------------------------------------------------------------------
bool RegularExpression::IsValid() const { return m_comp_err == 0; }
//----------------------------------------------------------------------
// Returns the text that was used to compile the current regular
// expression.
//----------------------------------------------------------------------
llvm::StringRef RegularExpression::GetText() const { return m_re; }
//----------------------------------------------------------------------
// Free any contained compiled regular expressions.
//----------------------------------------------------------------------
void RegularExpression::Free() {
if (m_comp_err == 0) {
m_re.clear();
regfree(&m_preg);
// Set a compile error since we no longer have a valid regex
m_comp_err = 1;
}
}
size_t RegularExpression::GetErrorAsCString(char *err_str,
size_t err_str_max_len) const {
if (m_comp_err == 0) {
if (err_str && err_str_max_len)
*err_str = '\0';
return 0;
}
return ::regerror(m_comp_err, &m_preg, err_str, err_str_max_len);
}
bool RegularExpression::operator<(const RegularExpression &rhs) const {
return (m_re < rhs.m_re);
}

lldb/source/Utility/SelectHelper.cpp

Context not available.
#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/SmallVector.h"
// Project includes // Project includes
#include "lldb/Core/Error.h" #include "lldb/Utility/Error.h"
#include "lldb/Utility/LLDBAssert.h" #include "lldb/Utility/LLDBAssert.h"
#include "lldb/Utility/SelectHelper.h" #include "lldb/Utility/SelectHelper.h"
Context not available.

lldb/source/Utility/Stream.cpp

  • This file was added.
//===-- Stream.cpp ----------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "lldb/Utility/Stream.h"
#include "lldb/Host/Endian.h"
#include "lldb/Host/PosixApi.h"
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <inttypes.h>
using namespace lldb;
using namespace lldb_private;
Stream::Stream(uint32_t flags, uint32_t addr_size, ByteOrder byte_order)
: m_flags(flags), m_addr_size(addr_size), m_byte_order(byte_order),
m_indent_level(0) {}
Stream::Stream()
: m_flags(0), m_addr_size(4), m_byte_order(endian::InlHostByteOrder()),
m_indent_level(0) {}
//------------------------------------------------------------------
// Destructor
//------------------------------------------------------------------
Stream::~Stream() {}
ByteOrder Stream::SetByteOrder(ByteOrder byte_order) {
ByteOrder old_byte_order = m_byte_order;
m_byte_order = byte_order;
return old_byte_order;
}
//------------------------------------------------------------------
// Put an offset "uval" out to the stream using the printf format
// in "format".
//------------------------------------------------------------------
void Stream::Offset(uint32_t uval, const char *format) { Printf(format, uval); }
//------------------------------------------------------------------
// Put an SLEB128 "uval" out to the stream using the printf format
// in "format".
//------------------------------------------------------------------
size_t Stream::PutSLEB128(int64_t sval) {
size_t bytes_written = 0;
if (m_flags.Test(eBinary)) {
bool more = true;
while (more) {
uint8_t byte = sval & 0x7fu;
sval >>= 7;
/* sign bit of byte is 2nd high order bit (0x40) */
if ((sval == 0 && !(byte & 0x40)) || (sval == -1 && (byte & 0x40)))
more = false;
else
// more bytes to come
byte |= 0x80u;
bytes_written += Write(&byte, 1);
}
} else {
bytes_written = Printf("0x%" PRIi64, sval);
}
return bytes_written;
}
//------------------------------------------------------------------
// Put an ULEB128 "uval" out to the stream using the printf format
// in "format".
//------------------------------------------------------------------
size_t Stream::PutULEB128(uint64_t uval) {
size_t bytes_written = 0;
if (m_flags.Test(eBinary)) {
do {
uint8_t byte = uval & 0x7fu;
uval >>= 7;
if (uval != 0) {
// more bytes to come
byte |= 0x80u;
}
bytes_written += Write(&byte, 1);
} while (uval != 0);
} else {
bytes_written = Printf("0x%" PRIx64, uval);
}
return bytes_written;
}
//------------------------------------------------------------------
// Print a raw NULL terminated C string to the stream.
//------------------------------------------------------------------
size_t Stream::PutCString(llvm::StringRef str) {
size_t bytes_written = 0;
bytes_written = Write(str.data(), str.size());
// when in binary mode, emit the NULL terminator
if (m_flags.Test(eBinary))
bytes_written += PutChar('\0');
return bytes_written;
}
//------------------------------------------------------------------
// Print a double quoted NULL terminated C string to the stream
// using the printf format in "format".
//------------------------------------------------------------------
void Stream::QuotedCString(const char *cstr, const char *format) {
Printf(format, cstr);
}
//------------------------------------------------------------------
// Put an address "addr" out to the stream with optional prefix
// and suffix strings.
//------------------------------------------------------------------
void Stream::Address(uint64_t addr, uint32_t addr_size, const char *prefix,
const char *suffix) {
if (prefix == NULL)
prefix = "";
if (suffix == NULL)
suffix = "";
// int addr_width = m_addr_size << 1;
// Printf ("%s0x%0*" PRIx64 "%s", prefix, addr_width, addr, suffix);
Printf("%s0x%0*" PRIx64 "%s", prefix, addr_size * 2, (uint64_t)addr, suffix);
}
//------------------------------------------------------------------
// Put an address range out to the stream with optional prefix
// and suffix strings.
//------------------------------------------------------------------
void Stream::AddressRange(uint64_t lo_addr, uint64_t hi_addr,
uint32_t addr_size, const char *prefix,
const char *suffix) {
if (prefix && prefix[0])
PutCString(prefix);
Address(lo_addr, addr_size, "[");
Address(hi_addr, addr_size, "-", ")");
if (suffix && suffix[0])
PutCString(suffix);
}
size_t Stream::PutChar(char ch) { return Write(&ch, 1); }
//------------------------------------------------------------------
// Print some formatted output to the stream.
//------------------------------------------------------------------
size_t Stream::Printf(const char *format, ...) {
va_list args;
va_start(args, format);
size_t result = PrintfVarArg(format, args);
va_end(args);
return result;
}
//------------------------------------------------------------------
// Print some formatted output to the stream.
//------------------------------------------------------------------
size_t Stream::PrintfVarArg(const char *format, va_list args) {
char str[1024];
va_list args_copy;
va_copy(args_copy, args);
size_t bytes_written = 0;
// Try and format our string into a fixed buffer first and see if it fits
size_t length = ::vsnprintf(str, sizeof(str), format, args);
if (length < sizeof(str)) {
// Include the NULL termination byte for binary output
if (m_flags.Test(eBinary))
length += 1;
// The formatted string fit into our stack based buffer, so we can just
// append that to our packet
bytes_written = Write(str, length);
} else {
// Our stack buffer wasn't big enough to contain the entire formatted
// string, so lets let vasprintf create the string for us!
char *str_ptr = NULL;
length = ::vasprintf(&str_ptr, format, args_copy);
if (str_ptr) {
// Include the NULL termination byte for binary output
if (m_flags.Test(eBinary))
length += 1;
bytes_written = Write(str_ptr, length);
::free(str_ptr);
}
}
va_end(args_copy);
return bytes_written;
}
//------------------------------------------------------------------
// Print and End of Line character to the stream
//------------------------------------------------------------------
size_t Stream::EOL() { return PutChar('\n'); }
//------------------------------------------------------------------
// Indent the current line using the current indentation level and
// print an optional string following the indentation spaces.
//------------------------------------------------------------------
size_t Stream::Indent(const char *s) {
return Printf("%*.*s%s", m_indent_level, m_indent_level, "", s ? s : "");
}
size_t Stream::Indent(llvm::StringRef str) {
return Printf("%*.*s%s", m_indent_level, m_indent_level, "",
str.str().c_str());
}
//------------------------------------------------------------------
// Stream a character "ch" out to this stream.
//------------------------------------------------------------------
Stream &Stream::operator<<(char ch) {
PutChar(ch);
return *this;
}
//------------------------------------------------------------------
// Stream the NULL terminated C string out to this stream.
//------------------------------------------------------------------
Stream &Stream::operator<<(const char *s) {
Printf("%s", s);
return *this;
}
Stream &Stream::operator<<(llvm::StringRef str) {
Write(str.data(), str.size());
return *this;
}
//------------------------------------------------------------------
// Stream the pointer value out to this stream.
//------------------------------------------------------------------
Stream &Stream::operator<<(const void *p) {
Printf("0x%.*tx", (int)sizeof(const void *) * 2, (ptrdiff_t)p);
return *this;
}
//------------------------------------------------------------------
// Stream a uint8_t "uval" out to this stream.
//------------------------------------------------------------------
Stream &Stream::operator<<(uint8_t uval) {
PutHex8(uval);
return *this;
}
//------------------------------------------------------------------
// Stream a uint16_t "uval" out to this stream.
//------------------------------------------------------------------
Stream &Stream::operator<<(uint16_t uval) {
PutHex16(uval, m_byte_order);
return *this;
}
//------------------------------------------------------------------
// Stream a uint32_t "uval" out to this stream.
//------------------------------------------------------------------
Stream &Stream::operator<<(uint32_t uval) {
PutHex32(uval, m_byte_order);
return *this;
}
//------------------------------------------------------------------
// Stream a uint64_t "uval" out to this stream.
//------------------------------------------------------------------
Stream &Stream::operator<<(uint64_t uval) {
PutHex64(uval, m_byte_order);
return *this;
}
//------------------------------------------------------------------
// Stream a int8_t "sval" out to this stream.
//------------------------------------------------------------------
Stream &Stream::operator<<(int8_t sval) {
Printf("%i", (int)sval);
return *this;
}
//------------------------------------------------------------------
// Stream a int16_t "sval" out to this stream.
//------------------------------------------------------------------
Stream &Stream::operator<<(int16_t sval) {
Printf("%i", (int)sval);
return *this;
}
//------------------------------------------------------------------
// Stream a int32_t "sval" out to this stream.
//------------------------------------------------------------------
Stream &Stream::operator<<(int32_t sval) {
Printf("%i", (int)sval);
return *this;
}
//------------------------------------------------------------------
// Stream a int64_t "sval" out to this stream.
//------------------------------------------------------------------
Stream &Stream::operator<<(int64_t sval) {
Printf("%" PRIi64, sval);
return *this;
}
//------------------------------------------------------------------
// Get the current indentation level
//------------------------------------------------------------------
int Stream::GetIndentLevel() const { return m_indent_level; }
//------------------------------------------------------------------
// Set the current indentation level
//------------------------------------------------------------------
void Stream::SetIndentLevel(int indent_level) { m_indent_level = indent_level; }
//------------------------------------------------------------------
// Increment the current indentation level
//------------------------------------------------------------------
void Stream::IndentMore(int amount) { m_indent_level += amount; }
//------------------------------------------------------------------
// Decrement the current indentation level
//------------------------------------------------------------------
void Stream::IndentLess(int amount) {
if (m_indent_level >= amount)
m_indent_level -= amount;
else
m_indent_level = 0;
}
//------------------------------------------------------------------
// Get the address size in bytes
//------------------------------------------------------------------
uint32_t Stream::GetAddressByteSize() const { return m_addr_size; }
//------------------------------------------------------------------
// Set the address size in bytes
//------------------------------------------------------------------
void Stream::SetAddressByteSize(uint32_t addr_size) { m_addr_size = addr_size; }
//------------------------------------------------------------------
// The flags get accessor
//------------------------------------------------------------------
Flags &Stream::GetFlags() { return m_flags; }
//------------------------------------------------------------------
// The flags const get accessor
//------------------------------------------------------------------
const Flags &Stream::GetFlags() const { return m_flags; }
//------------------------------------------------------------------
// The byte order get accessor
//------------------------------------------------------------------
lldb::ByteOrder Stream::GetByteOrder() const { return m_byte_order; }
size_t Stream::PrintfAsRawHex8(const char *format, ...) {
va_list args;
va_list args_copy;
va_start(args, format);
va_copy(args_copy, args); // Copy this so we
char str[1024];
size_t bytes_written = 0;
// Try and format our string into a fixed buffer first and see if it fits
size_t length = ::vsnprintf(str, sizeof(str), format, args);
if (length < sizeof(str)) {
// The formatted string fit into our stack based buffer, so we can just
// append that to our packet
for (size_t i = 0; i < length; ++i)
bytes_written += _PutHex8(str[i], false);
} else {
// Our stack buffer wasn't big enough to contain the entire formatted
// string, so lets let vasprintf create the string for us!
char *str_ptr = NULL;
length = ::vasprintf(&str_ptr, format, args_copy);
if (str_ptr) {
for (size_t i = 0; i < length; ++i)
bytes_written += _PutHex8(str_ptr[i], false);
::free(str_ptr);
}
}
va_end(args);
va_end(args_copy);
return bytes_written;
}
size_t Stream::PutNHex8(size_t n, uint8_t uvalue) {
size_t bytes_written = 0;
for (size_t i = 0; i < n; ++i)
bytes_written += _PutHex8(uvalue, false);
return bytes_written;
}
size_t Stream::_PutHex8(uint8_t uvalue, bool add_prefix) {
size_t bytes_written = 0;
if (m_flags.Test(eBinary)) {
bytes_written = Write(&uvalue, 1);
} else {
if (add_prefix)
PutCString("0x");
static char g_hex_to_ascii_hex_char[16] = {'0', '1', '2', '3', '4', '5',
'6', '7', '8', '9', 'a', 'b',
'c', 'd', 'e', 'f'};
char nibble_chars[2];
nibble_chars[0] = g_hex_to_ascii_hex_char[(uvalue >> 4) & 0xf];
nibble_chars[1] = g_hex_to_ascii_hex_char[(uvalue >> 0) & 0xf];
bytes_written = Write(nibble_chars, sizeof(nibble_chars));
}
return bytes_written;
}
size_t Stream::PutHex8(uint8_t uvalue) { return _PutHex8(uvalue, false); }
size_t Stream::PutHex16(uint16_t uvalue, ByteOrder byte_order) {
if (byte_order == eByteOrderInvalid)
byte_order = m_byte_order;
size_t bytes_written = 0;
if (byte_order == eByteOrderLittle) {
for (size_t byte = 0; byte < sizeof(uvalue); ++byte)
bytes_written += _PutHex8((uint8_t)(uvalue >> (byte * 8)), false);
} else {
for (size_t byte = sizeof(uvalue) - 1; byte < sizeof(uvalue); --byte)
bytes_written += _PutHex8((uint8_t)(uvalue >> (byte * 8)), false);
}
return bytes_written;
}
size_t Stream::PutHex32(uint32_t uvalue, ByteOrder byte_order) {
if (byte_order == eByteOrderInvalid)
byte_order = m_byte_order;
size_t bytes_written = 0;
if (byte_order == eByteOrderLittle) {
for (size_t byte = 0; byte < sizeof(uvalue); ++byte)
bytes_written += _PutHex8((uint8_t)(uvalue >> (byte * 8)), false);
} else {
for (size_t byte = sizeof(uvalue) - 1; byte < sizeof(uvalue); --byte)
bytes_written += _PutHex8((uint8_t)(uvalue >> (byte * 8)), false);
}
return bytes_written;
}
size_t Stream::PutHex64(uint64_t uvalue, ByteOrder byte_order) {
if (byte_order == eByteOrderInvalid)
byte_order = m_byte_order;
size_t bytes_written = 0;
if (byte_order == eByteOrderLittle) {
for (size_t byte = 0; byte < sizeof(uvalue); ++byte)
bytes_written += _PutHex8((uint8_t)(uvalue >> (byte * 8)), false);
} else {
for (size_t byte = sizeof(uvalue) - 1; byte < sizeof(uvalue); --byte)
bytes_written += _PutHex8((uint8_t)(uvalue >> (byte * 8)), false);
}
return bytes_written;
}
size_t Stream::PutMaxHex64(uint64_t uvalue, size_t byte_size,
lldb::ByteOrder byte_order) {
switch (byte_size) {
case 1:
return PutHex8((uint8_t)uvalue);
case 2:
return PutHex16((uint16_t)uvalue);
case 4:
return PutHex32((uint32_t)uvalue);
case 8:
return PutHex64(uvalue);
}
return 0;
}
size_t Stream::PutPointer(void *ptr) {
return PutRawBytes(&ptr, sizeof(ptr), endian::InlHostByteOrder(),
endian::InlHostByteOrder());
}
size_t Stream::PutFloat(float f, ByteOrder byte_order) {
if (byte_order == eByteOrderInvalid)
byte_order = m_byte_order;
return PutRawBytes(&f, sizeof(f), endian::InlHostByteOrder(), byte_order);
}
size_t Stream::PutDouble(double d, ByteOrder byte_order) {
if (byte_order == eByteOrderInvalid)
byte_order = m_byte_order;
return PutRawBytes(&d, sizeof(d), endian::InlHostByteOrder(), byte_order);
}
size_t Stream::PutLongDouble(long double ld, ByteOrder byte_order) {
if (byte_order == eByteOrderInvalid)
byte_order = m_byte_order;
return PutRawBytes(&ld, sizeof(ld), endian::InlHostByteOrder(), byte_order);
}
size_t Stream::PutRawBytes(const void *s, size_t src_len,
ByteOrder src_byte_order, ByteOrder dst_byte_order) {
if (src_byte_order == eByteOrderInvalid)
src_byte_order = m_byte_order;
if (dst_byte_order == eByteOrderInvalid)
dst_byte_order = m_byte_order;
size_t bytes_written = 0;
const uint8_t *src = (const uint8_t *)s;
bool binary_was_set = m_flags.Test(eBinary);
if (!binary_was_set)
m_flags.Set(eBinary);
if (src_byte_order == dst_byte_order) {
for (size_t i = 0; i < src_len; ++i)
bytes_written += _PutHex8(src[i], false);
} else {
for (size_t i = src_len - 1; i < src_len; --i)
bytes_written += _PutHex8(src[i], false);
}
if (!binary_was_set)
m_flags.Clear(eBinary);
return bytes_written;
}
size_t Stream::PutBytesAsRawHex8(const void *s, size_t src_len,
ByteOrder src_byte_order,
ByteOrder dst_byte_order) {
if (src_byte_order == eByteOrderInvalid)
src_byte_order = m_byte_order;
if (dst_byte_order == eByteOrderInvalid)
dst_byte_order = m_byte_order;
size_t bytes_written = 0;
const uint8_t *src = (const uint8_t *)s;
bool binary_is_set = m_flags.Test(eBinary);
m_flags.Clear(eBinary);
if (src_byte_order == dst_byte_order) {
for (size_t i = 0; i < src_len; ++i)
bytes_written += _PutHex8(src[i], false);
} else {
for (size_t i = src_len - 1; i < src_len; --i)
bytes_written += _PutHex8(src[i], false);
}
if (binary_is_set)
m_flags.Set(eBinary);
return bytes_written;
}
size_t Stream::PutCStringAsRawHex8(const char *s) {
size_t bytes_written = 0;
bool binary_is_set = m_flags.Test(eBinary);
m_flags.Clear(eBinary);
do {
bytes_written += _PutHex8(*s, false);
++s;
} while (*s);
if (binary_is_set)
m_flags.Set(eBinary);
return bytes_written;
}
void Stream::UnitTest(Stream *s) {
s->PutHex8(0x12);
s->PutChar(' ');
s->PutHex16(0x3456, endian::InlHostByteOrder());
s->PutChar(' ');
s->PutHex16(0x3456, eByteOrderBig);
s->PutChar(' ');
s->PutHex16(0x3456, eByteOrderLittle);
s->PutChar(' ');
s->PutHex32(0x789abcde, endian::InlHostByteOrder());
s->PutChar(' ');
s->PutHex32(0x789abcde, eByteOrderBig);
s->PutChar(' ');
s->PutHex32(0x789abcde, eByteOrderLittle);
s->PutChar(' ');
s->PutHex64(0x1122334455667788ull, endian::InlHostByteOrder());
s->PutChar(' ');
s->PutHex64(0x1122334455667788ull, eByteOrderBig);
s->PutChar(' ');
s->PutHex64(0x1122334455667788ull, eByteOrderLittle);
const char *hola = "Hello World!!!";
s->PutChar(' ');
s->PutCString(hola);
s->PutChar(' ');
s->Write(hola, 5);
s->PutChar(' ');
s->PutCStringAsRawHex8(hola);
s->PutChar(' ');
s->PutCStringAsRawHex8("01234");
s->PutChar(' ');
s->Printf("pid=%i", 12733);
s->PutChar(' ');
s->PrintfAsRawHex8("pid=%i", 12733);
s->PutChar('\n');
}

lldb/source/Utility/StreamString.cpp

  • This file was added.
//===-- StreamString.cpp ----------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "lldb/Utility/StreamString.h"
#include <stdio.h>
using namespace lldb;
using namespace lldb_private;
StreamString::StreamString() : Stream(0, 4, eByteOrderBig) {}
StreamString::StreamString(uint32_t flags, uint32_t addr_size,
ByteOrder byte_order)
: Stream(flags, addr_size, byte_order), m_packet() {}
StreamString::~StreamString() {}
void StreamString::Flush() {
// Nothing to do when flushing a buffer based stream...
}
size_t StreamString::Write(const void *s, size_t length) {
m_packet.append(reinterpret_cast<const char *>(s), length);
return length;
}
void StreamString::Clear() { m_packet.clear(); }
bool StreamString::Empty() const { return GetSize() == 0; }
size_t StreamString::GetSize() const { return m_packet.size(); }
size_t StreamString::GetSizeOfLastLine() const {
const size_t length = m_packet.size();
size_t last_line_begin_pos = m_packet.find_last_of("\r\n");
if (last_line_begin_pos == std::string::npos) {
return length;
} else {
++last_line_begin_pos;
return length - last_line_begin_pos;
}
}
llvm::StringRef StreamString::GetString() const { return m_packet; }
void StreamString::FillLastLineToColumn(uint32_t column, char fill_char) {
const size_t length = m_packet.size();
size_t last_line_begin_pos = m_packet.find_last_of("\r\n");
if (last_line_begin_pos == std::string::npos) {
last_line_begin_pos = 0;
} else {
++last_line_begin_pos;
}
const size_t line_columns = length - last_line_begin_pos;
if (column > line_columns) {
m_packet.append(column - line_columns, fill_char);
}
}

lldb/tools/argdumper/argdumper.cpp

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Core/StreamString.h"
#include "lldb/Utility/JSON.h" #include "lldb/Utility/JSON.h"
#include "lldb/Utility/StreamString.h"
#include <iostream> #include <iostream>
Context not available.

lldb/tools/lldb-server/Acceptor.h

Context not available.
#define lldb_server_Acceptor_h_ #define lldb_server_Acceptor_h_
#include "lldb/Core/Connection.h" #include "lldb/Core/Connection.h"
#include "lldb/Core/Error.h"
#include "lldb/Host/Socket.h" #include "lldb/Host/Socket.h"
#include "lldb/Utility/Error.h"
#include <functional> #include <functional>
#include <memory> #include <memory>
Context not available.

lldb/tools/lldb-server/Acceptor.cpp

Context not available.
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
#include "llvm/Support/ScopedPrinter.h" #include "llvm/Support/ScopedPrinter.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Host/ConnectionFileDescriptor.h" #include "lldb/Host/ConnectionFileDescriptor.h"
#include "lldb/Host/common/TCPSocket.h" #include "lldb/Host/common/TCPSocket.h"
#include "lldb/Utility/StreamString.h"
#include "Utility/UriParser.h" #include "Utility/UriParser.h"
Context not available.

lldb/tools/lldb-server/LLDBServerUtilities.cpp

Context not available.
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Interpreter/Args.h" #include "lldb/Interpreter/Args.h"
#include "lldb/Utility/StreamString.h"
#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
Context not available.

lldb/tools/lldb-server/lldb-gdbserver.cpp

Context not available.
#include "LLDBServerUtilities.h" #include "LLDBServerUtilities.h"
#include "Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.h" #include "Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.h"
#include "Plugins/Process/gdb-remote/ProcessGDBRemoteLog.h" #include "Plugins/Process/gdb-remote/ProcessGDBRemoteLog.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Host/ConnectionFileDescriptor.h" #include "lldb/Host/ConnectionFileDescriptor.h"
#include "lldb/Host/HostGetOpt.h" #include "lldb/Host/HostGetOpt.h"
Context not available.
#include "lldb/Host/Pipe.h" #include "lldb/Host/Pipe.h"
#include "lldb/Host/Socket.h" #include "lldb/Host/Socket.h"
#include "lldb/Host/StringConvert.h" #include "lldb/Host/StringConvert.h"
#include "lldb/Utility/Error.h"
#ifndef LLGS_PROGRAM_NAME #ifndef LLGS_PROGRAM_NAME
#define LLGS_PROGRAM_NAME "lldb-server" #define LLGS_PROGRAM_NAME "lldb-server"
Context not available.

lldb/tools/lldb-server/lldb-platform.cpp

Context not available.
#include "LLDBServerUtilities.h" #include "LLDBServerUtilities.h"
#include "Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.h" #include "Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.h"
#include "Plugins/Process/gdb-remote/ProcessGDBRemoteLog.h" #include "Plugins/Process/gdb-remote/ProcessGDBRemoteLog.h"
#include "lldb/Core/Error.h"
#include "lldb/Host/ConnectionFileDescriptor.h" #include "lldb/Host/ConnectionFileDescriptor.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
#include "lldb/Host/FileSystem.h" #include "lldb/Host/FileSystem.h"
#include "lldb/Host/HostGetOpt.h" #include "lldb/Host/HostGetOpt.h"
#include "lldb/Host/OptionParser.h" #include "lldb/Host/OptionParser.h"
#include "lldb/Host/common/TCPSocket.h" #include "lldb/Host/common/TCPSocket.h"
#include "lldb/Utility/Error.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/unittests/Breakpoint/BreakpointIDTest.cpp

Context not available.
#include "gtest/gtest.h" #include "gtest/gtest.h"
#include "lldb/Breakpoint/BreakpointID.h" #include "lldb/Breakpoint/BreakpointID.h"
#include "lldb/Core/Error.h" #include "lldb/Utility/Error.h"
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
Context not available.

lldb/unittests/Core/ErrorTest.cpp

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Utility/Error.h"
#include "gtest/gtest.h" #include "gtest/gtest.h"
#include "lldb/Core/Error.h"
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/unittests/Core/LogTest.cpp

Context not available.
#include "gtest/gtest.h" #include "gtest/gtest.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/unittests/Core/ScalarTest.cpp

Context not available.
#include "gtest/gtest.h" #include "gtest/gtest.h"
#include "lldb/Core/DataExtractor.h" #include "lldb/Core/DataExtractor.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Scalar.h" #include "lldb/Core/Scalar.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Host/Endian.h" #include "lldb/Host/Endian.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/unittests/Core/StructuredDataTest.cpp

Context not available.
#include "gtest/gtest.h" #include "gtest/gtest.h"
#include "lldb/Core/StructuredData.h" #include "lldb/Core/StructuredData.h"
#include "lldb/Core/StreamString.h" #include "lldb/Utility/StreamString.h"
#include "llvm/Support/MachO.h" #include "llvm/Support/MachO.h"
Context not available.

lldb/unittests/Core/TimerTest.cpp

Context not available.
#include "lldb/Core/Timer.h" #include "lldb/Core/Timer.h"
#include "gtest/gtest.h" #include "gtest/gtest.h"
#include "lldb/Core/StreamString.h" #include "lldb/Utility/StreamString.h"
#include <thread> #include <thread>
using namespace lldb_private; using namespace lldb_private;
Context not available.

lldb/unittests/Editline/EditlineTest.cpp

Context not available.
#include "gtest/gtest.h" #include "gtest/gtest.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/StringList.h" #include "lldb/Core/StringList.h"
#include "lldb/Host/Editline.h" #include "lldb/Host/Editline.h"
#include "lldb/Host/Pipe.h" #include "lldb/Host/Pipe.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/PseudoTerminal.h" #include "lldb/Utility/PseudoTerminal.h"
namespace { namespace {
Context not available.

lldb/unittests/Expression/GoParserTest.cpp

Context not available.
#include "gtest/gtest.h" #include "gtest/gtest.h"
#include "Plugins/ExpressionParser/Go/GoParser.h" #include "Plugins/ExpressionParser/Go/GoParser.h"
#include "lldb/Core/Error.h" #include "lldb/Utility/Error.h"
using namespace lldb_private; using namespace lldb_private;
Context not available.
lldb/source/Core/SourceManager.cpp