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

Repository
rL LLVM

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/
trunk/
include/
lldb/
Breakpoint/
4 lines
2 lines
Core/
2 lines
2 lines
2 lines
2 lines
2 lines
479 lines
2 lines
315 lines
2 lines
2 lines
6 lines
2 lines
2 lines
2 lines
2 lines
216 lines
2 lines
548 lines
2 lines
2 lines
4 lines
2 lines
2 lines
51 lines
141 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
3 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
336 lines
2 lines
4 lines
2 lines
4 lines
4 lines
336 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
208 lines
4 lines
4 lines
612 lines
2 lines
65 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 86879

lldb/trunk/include/lldb/Breakpoint/BreakpointResolver.h

Show All 11 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#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 {
//---------------------------------------------------------------------- //----------------------------------------------------------------------
/// @class BreakpointResolver BreakpointResolver.h /// @class BreakpointResolver BreakpointResolver.h
/// "lldb/Breakpoint/BreakpointResolver.h" /// "lldb/Breakpoint/BreakpointResolver.h"
/// @brief This class works with SearchFilter to resolve logical breakpoints to /// @brief This class works with SearchFilter to resolve logical breakpoints to
▲ Show 20 Lines • Show All 227 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Breakpoint/BreakpointResolverFileRegex.h

Show All 11 Lines
#define liblldb_BreakpointResolverFileRegex_h_ #define liblldb_BreakpointResolverFileRegex_h_
// C Includes // C Includes
// C++ Includes // C++ Includes
#include <set> #include <set>
// 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 {
//---------------------------------------------------------------------- //----------------------------------------------------------------------
/// @class BreakpointResolverFileRegex BreakpointResolverFileRegex.h /// @class BreakpointResolverFileRegex BreakpointResolverFileRegex.h
/// "lldb/Breakpoint/BreakpointResolverFileRegex.h" /// "lldb/Breakpoint/BreakpointResolverFileRegex.h"
/// @brief This class sets breakpoints by file and line. Optionally, it will /// @brief This class sets breakpoints by file and line. Optionally, it will
/// look for inlined /// look for inlined
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Core/AddressResolver.h

Show All 12 Lines
#include <vector> #include <vector>
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// 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 {
//---------------------------------------------------------------------- //----------------------------------------------------------------------
/// @class AddressResolver AddressResolver.h "lldb/Core/AddressResolver.h" /// @class AddressResolver AddressResolver.h "lldb/Core/AddressResolver.h"
/// @brief This class works with SearchFilter to resolve function names and /// @brief This class works with SearchFilter to resolve function names and
/// source file locations to their concrete addresses. /// source file locations to their concrete addresses.
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Core/AddressResolverName.h

//===-- AddressResolverName.h -----------------------------------*- C++ -*-===// //===-- AddressResolverName.h -----------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef liblldb_AddressResolverName_h_ #ifndef liblldb_AddressResolverName_h_
#define liblldb_AddressResolverName_h_ #define liblldb_AddressResolverName_h_
// 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 {
//---------------------------------------------------------------------- //----------------------------------------------------------------------
/// @class AddressResolverName AddressResolverName.h /// @class AddressResolverName AddressResolverName.h
/// "lldb/Core/AddressResolverName.h" /// "lldb/Core/AddressResolverName.h"
/// @brief This class finds addresses for a given function name, either by exact /// @brief This class finds addresses for a given function name, either by exact
/// match /// match
Show All 39 Lines

lldb/trunk/include/lldb/Core/ArchSpec.h

//===-- ArchSpec.h ----------------------------------------------*- C++ -*-===// //===-- ArchSpec.h ----------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef liblldb_ArchSpec_h_ #ifndef liblldb_ArchSpec_h_
#define liblldb_ArchSpec_h_ #define liblldb_ArchSpec_h_
#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"
namespace lldb_private { namespace lldb_private {
struct CoreDefinition; struct CoreDefinition;
//---------------------------------------------------------------------- //----------------------------------------------------------------------
▲ Show 20 Lines • Show All 623 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Core/Broadcaster.h

Show All 15 Lines
#include <list> #include <list>
#include <map> #include <map>
#include <mutex> #include <mutex>
#include <string> #include <string>
#include <vector> #include <vector>
// 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"
namespace lldb_private { namespace lldb_private {
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// lldb::BroadcastEventSpec // lldb::BroadcastEventSpec
▲ Show 20 Lines • Show All 563 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Core/Communication.h

Show All 13 Lines
// C++ Includes // C++ Includes
#include <atomic> #include <atomic>
#include <mutex> #include <mutex>
#include <string> #include <string>
// 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"
namespace lldb_private { namespace lldb_private {
//---------------------------------------------------------------------- //----------------------------------------------------------------------
/// @class Communication Communication.h "lldb/Core/Communication.h" /// @class Communication Communication.h "lldb/Core/Communication.h"
/// @brief An abstract communications class. /// @brief An abstract communications class.
▲ Show 20 Lines • Show All 373 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Core/ConstString.h

//===-- 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/trunk/include/lldb/Core/DataBufferMemoryMap.h

//===-- DataBufferMemoryMap.h -----------------------------------*- C++ -*-===// //===-- DataBufferMemoryMap.h -----------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef liblldb_DataBufferMemoryMap_h_ #ifndef liblldb_DataBufferMemoryMap_h_
#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>
namespace lldb_private { namespace lldb_private {
//---------------------------------------------------------------------- //----------------------------------------------------------------------
/// @class DataBufferMemoryMap DataBufferMemoryMap.h /// @class DataBufferMemoryMap DataBufferMemoryMap.h
/// "lldb/Core/DataBufferMemoryMap.h" /// "lldb/Core/DataBufferMemoryMap.h"
▲ Show 20 Lines • Show All 132 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Core/Error.h

//===-- 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/trunk/include/lldb/Core/Event.h

Show All 13 Lines
// C++ Includes // C++ Includes
#include <chrono> #include <chrono>
#include <memory> #include <memory>
#include <string> #include <string>
// 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 {
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// lldb::EventData // lldb::EventData
//---------------------------------------------------------------------- //----------------------------------------------------------------------
class EventData { class EventData {
▲ Show 20 Lines • Show All 235 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Core/FormatEntity.h

Show All 11 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
#include <string> #include <string>
#include <vector> #include <vector>
// 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 {
class StringRef; class StringRef;
} // namespace llvm } // namespace llvm
namespace lldb_private { namespace lldb_private {
class FormatEntity { class FormatEntity {
▲ Show 20 Lines • Show All 189 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Core/IOHandler.h

Show All 15 Lines
// C++ Includes // C++ Includes
#include <memory> #include <memory>
#include <mutex> #include <mutex>
#include <string> #include <string>
#include <vector> #include <vector>
// 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"
namespace curses { namespace curses {
class Application; class Application;
typedef std::unique_ptr<Application> ApplicationAP; typedef std::unique_ptr<Application> ApplicationAP;
} // namespace curses } // namespace curses
▲ Show 20 Lines • Show All 569 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Core/Log.h

//===-- Log.h ---------------------------------------------------*- C++ -*-===// //===-- Log.h ---------------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef liblldb_Log_h_ #ifndef liblldb_Log_h_
#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
#include "llvm/Support/FormatVariadic.h" #include "llvm/Support/FormatVariadic.h"
// C++ Includes // C++ Includes
#include <cstdarg> #include <cstdarg>
#include <cstdint> #include <cstdint>
// C Includes // C Includes
▲ Show 20 Lines • Show All 178 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Core/Mangled.h

//===-- Mangled.h -----------------------------------------------*- C++ -*-===// //===-- Mangled.h -----------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef liblldb_Mangled_h_ #ifndef liblldb_Mangled_h_
#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>
namespace lldb_private { namespace lldb_private {
//---------------------------------------------------------------------- //----------------------------------------------------------------------
/// @class Mangled Mangled.h "lldb/Core/Mangled.h" /// @class Mangled Mangled.h "lldb/Core/Mangled.h"
/// @brief A class that handles mangled names. /// @brief A class that handles mangled names.
▲ Show 20 Lines • Show All 286 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Core/MappedHash.h

Show All 17 Lines
#include <algorithm> #include <algorithm>
#include <functional> #include <functional>
#include <map> #include <map>
#include <vector> #include <vector>
// 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:
enum HashFunctionType { enum HashFunctionType {
eHashFunctionDJB = 0u // Daniel J Bernstein hash function that is also used eHashFunctionDJB = 0u // Daniel J Bernstein hash function that is also used
// by the ELF GNU_HASH sections // by the ELF GNU_HASH sections
}; };
▲ Show 20 Lines • Show All 449 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Core/ModuleSpec.h

//===-- ModuleSpec.h --------------------------------------------*- C++ -*-===// //===-- ModuleSpec.h --------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef liblldb_ModuleSpec_h_ #ifndef liblldb_ModuleSpec_h_
#define liblldb_ModuleSpec_h_ #define liblldb_ModuleSpec_h_
// 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"
// C Includes // C Includes
// C++ Includes // C++ Includes
#include <mutex> #include <mutex>
#include <vector> #include <vector>
▲ Show 20 Lines • Show All 399 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Core/RegularExpression.h

//===-- 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/trunk/include/lldb/Core/Section.h

//===-- Section.h -----------------------------------------------*- C++ -*-===// //===-- Section.h -----------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef liblldb_Section_h_ #ifndef liblldb_Section_h_
#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>
namespace lldb_private { namespace lldb_private {
class SectionList { class SectionList {
public: public:
typedef std::vector<lldb::SectionSP> collection; typedef std::vector<lldb::SectionSP> collection;
▲ Show 20 Lines • Show All 235 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Core/Stream.h

//===-- 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/trunk/include/lldb/Core/StreamAsynchronousIO.h

//===-- StreamAsynchronousIO.h -----------------------------------*- C++ //===-- StreamAsynchronousIO.h -----------------------------------*- C++
//-*-===// //-*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef liblldb_StreamAsynchronousIO_h_ #ifndef liblldb_StreamAsynchronousIO_h_
#define liblldb_StreamAsynchronousIO_h_ #define liblldb_StreamAsynchronousIO_h_
#include <string> #include <string>
#include "lldb/Core/Stream.h" #include "lldb/Utility/Stream.h"
namespace lldb_private { namespace lldb_private {
class StreamAsynchronousIO : public Stream { class StreamAsynchronousIO : public Stream {
public: public:
StreamAsynchronousIO(Debugger &debugger, bool for_stdout); StreamAsynchronousIO(Debugger &debugger, bool for_stdout);
~StreamAsynchronousIO() override; ~StreamAsynchronousIO() override;
Show All 14 Lines

lldb/trunk/include/lldb/Core/StreamBuffer.h

//===-- StreamBuffer.h ------------------------------------------*- C++ -*-===// //===-- StreamBuffer.h ------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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>
namespace lldb_private { namespace lldb_private {
template <unsigned N> class StreamBuffer : public Stream { template <unsigned N> class StreamBuffer : public Stream {
public: public:
Show All 35 Lines

lldb/trunk/include/lldb/Core/StreamCallback.h

//===-- StreamCallback.h -----------------------------------*- C++ -*-===// //===-- StreamCallback.h -----------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef liblldb_StreamCallback_h_ #ifndef liblldb_StreamCallback_h_
#define liblldb_StreamCallback_h_ #define liblldb_StreamCallback_h_
#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 {
class StreamCallback : public Stream { class StreamCallback : public Stream {
public: public:
StreamCallback(lldb::LogOutputCallback callback, void *baton); StreamCallback(lldb::LogOutputCallback callback, void *baton);
~StreamCallback() override; ~StreamCallback() override;
Show All 18 Lines

lldb/trunk/include/lldb/Core/StreamFile.h

Show All 12 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
#include <string> #include <string>
// 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 {
class StreamFile : public Stream { class StreamFile : public Stream {
public: public:
//------------------------------------------------------------------ //------------------------------------------------------------------
// Constructors and Destructors // Constructors and Destructors
//------------------------------------------------------------------ //------------------------------------------------------------------
Show All 36 Lines

lldb/trunk/include/lldb/Core/StreamGDBRemote.h

Show All 11 Lines
#define liblldb_StreamGDBRemote_h_ #define liblldb_StreamGDBRemote_h_
// C Includes // C Includes
// C++ Includes // C++ Includes
// 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 {
class StreamGDBRemote : public StreamString { class StreamGDBRemote : public StreamString {
public: public:
StreamGDBRemote(); StreamGDBRemote();
StreamGDBRemote(uint32_t flags, uint32_t addr_size, StreamGDBRemote(uint32_t flags, uint32_t addr_size,
Show All 23 Lines

lldb/trunk/include/lldb/Core/StreamString.h

//===-- 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/trunk/include/lldb/Core/StreamTee.h

//===-- 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/trunk/include/lldb/Core/StructuredData.h

Show All 17 Lines
#include <string> #include <string>
#include <utility> #include <utility>
#include <vector> #include <vector>
// Other libraries and framework includes // Other libraries and framework includes
#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 {
//---------------------------------------------------------------------- //----------------------------------------------------------------------
/// @class StructuredData StructuredData.h "lldb/Core/StructuredData.h" /// @class StructuredData StructuredData.h "lldb/Core/StructuredData.h"
/// @brief A class which can hold structured data /// @brief A class which can hold structured data
/// ///
▲ Show 20 Lines • Show All 525 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Core/UniqueCStringMap.h

Show All 11 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
#include <algorithm> #include <algorithm>
#include <vector> #include <vector>
// 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 {
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// Templatized uniqued string map. // Templatized uniqued string map.
// //
// This map is useful for mapping unique C string names to values of // This map is useful for mapping unique C string names to values of
// type T. Each "const char *" name added must be unique for a given // type T. Each "const char *" name added must be unique for a given
▲ Show 20 Lines • Show All 243 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Core/UserSettingsController.h

Show All 13 Lines
// C++ Includes // C++ Includes
#include <string> #include <string>
#include <vector> #include <vector>
// 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 {
class Properties { class Properties {
public: public:
Properties() : m_collection_sp() {} Properties() : m_collection_sp() {}
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Core/Value.h

Show All 11 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
#include <vector> #include <vector>
// 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 {
class Value { class Value {
public: public:
// Values Less than zero are an error, greater than or equal to zero // Values Less than zero are an error, greater than or equal to zero
// returns what the Scalar result is. // returns what the Scalar result is.
▲ Show 20 Lines • Show All 219 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Core/ValueObject.h

Show All 16 Lines
#include <map> #include <map>
#include <vector> #include <vector>
// Other libraries and framework includes // Other libraries and framework includes
#include "llvm/ADT/Optional.h" #include "llvm/ADT/Optional.h"
#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"
#include "lldb/Symbol/CompilerType.h" #include "lldb/Symbol/CompilerType.h"
#include "lldb/Target/ExecutionContext.h" #include "lldb/Target/ExecutionContext.h"
#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"
namespace lldb_private { namespace lldb_private {
/// ValueObject: /// ValueObject:
/// ///
/// This abstract class provides an interface to a particular value, be it a /// This abstract class provides an interface to a particular value, be it a
▲ Show 20 Lines • Show All 1,015 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/DataFormatters/DataVisualization.h

Show All 9 Lines
#ifndef lldb_DataVisualization_h_ #ifndef lldb_DataVisualization_h_
#define lldb_DataVisualization_h_ #define lldb_DataVisualization_h_
// C Includes // C Includes
// 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/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 {
// this class is the high-level front-end of LLDB Data Visualization // this class is the high-level front-end of LLDB Data Visualization
// code in FormatManager.h/cpp is the low-level implementation of this feature // code in FormatManager.h/cpp is the low-level implementation of this feature
// clients should refer to this class as the entry-point into the data // clients should refer to this class as the entry-point into the data
// formatters // formatters
// unless they have a good reason to bypass this and go to the backend // unless they have a good reason to bypass this and go to the backend
▲ Show 20 Lines • Show All 118 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/DataFormatters/FormatCache.h

Show All 12 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
#include <map> #include <map>
#include <mutex> #include <mutex>
// 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 {
class FormatCache { class FormatCache {
private: private:
struct Entry { struct Entry {
private: private:
bool m_format_cached : 1; bool m_format_cached : 1;
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/DataFormatters/FormattersContainer.h

Show All 16 Lines
#include <memory> #include <memory>
#include <mutex> #include <mutex>
#include <string> #include <string>
// Other libraries and framework includes // Other libraries and framework includes
// 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"
#include "lldb/DataFormatters/TypeSummary.h" #include "lldb/DataFormatters/TypeSummary.h"
#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 {
class IFormatChangeListener { class IFormatChangeListener {
public: public:
virtual ~IFormatChangeListener() = default; virtual ~IFormatChangeListener() = default;
▲ Show 20 Lines • Show All 310 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/DataFormatters/TypeSummary.h

Show All 17 Lines
#include <memory> #include <memory>
#include <string> #include <string>
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#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 {
public: public:
TypeSummaryOptions(); TypeSummaryOptions();
TypeSummaryOptions(const TypeSummaryOptions &rhs); TypeSummaryOptions(const TypeSummaryOptions &rhs);
~TypeSummaryOptions() = default; ~TypeSummaryOptions() = default;
▲ Show 20 Lines • Show All 367 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/DataFormatters/VectorIterator.h

//===-- VectorIterator.h ----------------------------------------------*- C++ //===-- VectorIterator.h ----------------------------------------------*- C++
//-*-===// //-*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef liblldb_VectorIterator_h_ #ifndef liblldb_VectorIterator_h_
#define liblldb_VectorIterator_h_ #define liblldb_VectorIterator_h_
#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 {
class VectorIteratorSyntheticFrontEnd : public SyntheticChildrenFrontEnd { class VectorIteratorSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
public: public:
VectorIteratorSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp, VectorIteratorSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp,
ConstString item_name); ConstString item_name);
Show All 20 Lines

lldb/trunk/include/lldb/Expression/DWARFExpression.h

//===-- DWARFExpression.h ---------------------------------------*- C++ -*-===// //===-- DWARFExpression.h ---------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef liblldb_DWARFExpression_h_ #ifndef liblldb_DWARFExpression_h_
#define liblldb_DWARFExpression_h_ #define liblldb_DWARFExpression_h_
#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>
class DWARFCompileUnit; class DWARFCompileUnit;
namespace lldb_private { namespace lldb_private {
class ClangExpressionDeclMap; class ClangExpressionDeclMap;
▲ Show 20 Lines • Show All 419 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Expression/ExpressionParser.h

//===-- ExpressionParser.h --------------------------------------*- C++ -*-===// //===-- ExpressionParser.h --------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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 {
class IRExecutionUnit; class IRExecutionUnit;
//---------------------------------------------------------------------- //----------------------------------------------------------------------
/// @class ExpressionParser ExpressionParser.h /// @class ExpressionParser ExpressionParser.h
▲ Show 20 Lines • Show All 104 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Expression/ExpressionVariable.h

Show All 13 Lines
// C++ Includes // C++ Includes
#include <memory> #include <memory>
#include <vector> #include <vector>
// Other libraries and framework includes // Other libraries and framework includes
#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 {
class ClangExpressionVariable; class ClangExpressionVariable;
class ExpressionVariable class ExpressionVariable
: public std::enable_shared_from_this<ExpressionVariable> { : public std::enable_shared_from_this<ExpressionVariable> {
▲ Show 20 Lines • Show All 237 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Expression/IRInterpreter.h

//===-- IRInterpreter.h -----------------------------------------*- C++ -*-===// //===-- IRInterpreter.h -----------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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"
namespace llvm { namespace llvm {
class Function; class Function;
class Module; class Module;
} }
Show All 36 Lines

lldb/trunk/include/lldb/Expression/Materializer.h

Show All 11 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
#include <memory> #include <memory>
#include <vector> #include <vector>
// 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 {
class Materializer { class Materializer {
public: public:
Materializer(); Materializer();
~Materializer(); ~Materializer();
▲ Show 20 Lines • Show All 113 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Host/FileCache.h

//===-- FileCache.h ---------------------------------------------*- C++ -*-===// //===-- FileCache.h ---------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef liblldb_Host_FileCache_h #ifndef liblldb_Host_FileCache_h
#define liblldb_Host_FileCache_h #define liblldb_Host_FileCache_h
#include <stdint.h> #include <stdint.h>
#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 {
private: private:
FileCache() {} FileCache() {}
typedef std::map<lldb::user_id_t, lldb::FileSP> FDToFileMap; typedef std::map<lldb::user_id_t, lldb::FileSP> FDToFileMap;
Show All 20 Lines

lldb/trunk/include/lldb/Host/FileSpec.h

Show All 11 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
#include <functional> #include <functional>
#include <string> #include <string>
// 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"
namespace lldb_private { namespace lldb_private {
//---------------------------------------------------------------------- //----------------------------------------------------------------------
/// @class FileSpec FileSpec.h "lldb/Host/FileSpec.h" /// @class FileSpec FileSpec.h "lldb/Host/FileSpec.h"
▲ Show 20 Lines • Show All 760 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Host/FileSystem.h

//===-- FileSystem.h --------------------------------------------*- C++ -*-===// //===-- FileSystem.h --------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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"
#include <stdint.h> #include <stdint.h>
#include <stdio.h> #include <stdio.h>
#include <sys/stat.h> #include <sys/stat.h>
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Host/HostNativeProcessBase.h

//===-- HostNativeProcessBase.h ---------------------------------*- C++ -*-===// //===-- HostNativeProcessBase.h ---------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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"
namespace lldb_private { namespace lldb_private {
class HostThread; class HostThread;
class HostNativeProcessBase { class HostNativeProcessBase {
Show All 26 Lines

lldb/trunk/include/lldb/Host/HostNativeThreadBase.h

//===-- HostNativeThreadBase.h ----------------------------------*- C++ -*-===// //===-- HostNativeThreadBase.h ----------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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"
namespace lldb_private { namespace lldb_private {
#if defined(_WIN32) #if defined(_WIN32)
#define THREAD_ROUTINE __stdcall #define THREAD_ROUTINE __stdcall
#else #else
Show All 31 Lines

lldb/trunk/include/lldb/Host/HostThread.h

//===-- HostThread.h --------------------------------------------*- C++ -*-===// //===-- HostThread.h --------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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>
namespace lldb_private { namespace lldb_private {
class HostNativeThreadBase; class HostNativeThreadBase;
Show All 32 Lines

lldb/trunk/include/lldb/Host/LockFileBase.h

//===-- LockFileBase.h ------------------------------------------*- C++ -*-===// //===-- LockFileBase.h ------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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>
namespace lldb_private { namespace lldb_private {
class LockFileBase { class LockFileBase {
public: public:
virtual ~LockFileBase() = default; virtual ~LockFileBase() = default;
Show All 36 Lines

lldb/trunk/include/lldb/Host/MainLoopBase.h

//===-- MainLoopBase.h ------------------------------------------*- C++ -*-===// //===-- MainLoopBase.h ------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef lldb_Host_posix_MainLoopBase_h_ #ifndef lldb_Host_posix_MainLoopBase_h_
#define lldb_Host_posix_MainLoopBase_h_ #define lldb_Host_posix_MainLoopBase_h_
#include <functional> #include <functional>
#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 {
// The purpose of this class is to enable multiplexed processing of data from // The purpose of this class is to enable multiplexed processing of data from
// different sources // different sources
// without resorting to multi-threading. Clients can register IOObjects, which // without resorting to multi-threading. Clients can register IOObjects, which
// will be monitored // will be monitored
// for readability, and when they become ready, the specified callback will be // for readability, and when they become ready, the specified callback will be
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Host/PipeBase.h

//===-- PipeBase.h -----------------------------------------------*- C++ //===-- PipeBase.h -----------------------------------------------*- C++
//-*-===// //-*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef liblldb_Host_PipeBase_h_ #ifndef liblldb_Host_PipeBase_h_
#define liblldb_Host_PipeBase_h_ #define liblldb_Host_PipeBase_h_
#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"
namespace lldb_private { namespace lldb_private {
class PipeBase { class PipeBase {
public: public:
virtual ~PipeBase(); virtual ~PipeBase();
Show All 39 Lines

lldb/trunk/include/lldb/Host/Socket.h

Show All 9 Lines
#ifndef liblldb_Host_Socket_h_ #ifndef liblldb_Host_Socket_h_
#define liblldb_Host_Socket_h_ #define liblldb_Host_Socket_h_
#include <memory> #include <memory>
#include <string> #include <string>
#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"
#include <winsock2.h> #include <winsock2.h>
#include <ws2tcpip.h> #include <ws2tcpip.h>
#endif #endif
namespace llvm { namespace llvm {
▲ Show 20 Lines • Show All 96 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Host/ThreadLauncher.h

//===-- ThreadLauncher.h -----------------------------------------*- C++ //===-- ThreadLauncher.h -----------------------------------------*- C++
//-*-===// //-*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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"
namespace lldb_private { namespace lldb_private {
class ThreadLauncher { class ThreadLauncher {
public: public:
Show All 21 Lines

lldb/trunk/include/lldb/Host/XML.h

Show All 18 Lines
#include <functional> #include <functional>
#include <string> #include <string>
#include <vector> #include <vector>
// Other libraries and framework includes // Other libraries and framework includes
#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 {
#if defined(LIBXML2_DEFINED) #if defined(LIBXML2_DEFINED)
typedef xmlNodePtr XMLNodeImpl; typedef xmlNodePtr XMLNodeImpl;
typedef xmlDocPtr XMLDocumentImpl; typedef xmlDocPtr XMLDocumentImpl;
#else #else
▲ Show 20 Lines • Show All 155 Lines • Show Last 20 Lines

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

//===-- NativeBreakpointList.h ----------------------------------*- C++ -*-===// //===-- NativeBreakpointList.h ----------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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"
#include <functional> #include <functional>
#include <map> #include <map>
#include <mutex> #include <mutex>
namespace lldb_private { namespace lldb_private {
Show All 30 Lines

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

//===-- NativeProcessProtocol.h ---------------------------------*- C++ -*-===// //===-- NativeProcessProtocol.h ---------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef liblldb_NativeProcessProtocol_h_ #ifndef liblldb_NativeProcessProtocol_h_
#define liblldb_NativeProcessProtocol_h_ #define liblldb_NativeProcessProtocol_h_
#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"
#include "NativeBreakpointList.h" #include "NativeBreakpointList.h"
#include "NativeWatchpointList.h" #include "NativeWatchpointList.h"
namespace lldb_private { namespace lldb_private {
▲ Show 20 Lines • Show All 336 Lines • Show Last 20 Lines

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

//===-- NativeWatchpointList.h ----------------------------------*- C++ -*-===// //===-- NativeWatchpointList.h ----------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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>
namespace lldb_private { namespace lldb_private {
struct NativeWatchpoint { struct NativeWatchpoint {
lldb::addr_t m_addr; lldb::addr_t m_addr;
size_t m_size; size_t m_size;
Show All 21 Lines

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

//===-- HostProcessPosix.h --------------------------------------*- C++ -*-===// //===-- HostProcessPosix.h --------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef lldb_Host_HostProcesPosix_h_ #ifndef lldb_Host_HostProcesPosix_h_
#define lldb_Host_HostProcesPosix_h_ #define lldb_Host_HostProcesPosix_h_
// C Includes // C Includes
// 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 {
class FileSpec; class FileSpec;
class HostProcessPosix : public HostNativeProcessBase { class HostProcessPosix : public HostNativeProcessBase {
public: public:
Show All 20 Lines

lldb/trunk/include/lldb/Interpreter/Args.h

Show All 15 Lines
#include <string> #include <string>
#include <utility> #include <utility>
#include <vector> #include <vector>
// Other libraries and framework includes // Other libraries and framework includes
#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"
namespace lldb_private { namespace lldb_private {
typedef std::vector<std::tuple<std::string, int, std::string>> OptionArgVector; typedef std::vector<std::tuple<std::string, int, std::string>> OptionArgVector;
typedef std::shared_ptr<OptionArgVector> OptionArgVectorSP; typedef std::shared_ptr<OptionArgVector> OptionArgVectorSP;
▲ Show 20 Lines • Show All 436 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Interpreter/CommandCompletions.h

Show All 11 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
#include <set> #include <set>
// 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 {
class CommandCompletions { class CommandCompletions {
public: public:
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// This is the command completion callback that is used to complete the // This is the command completion callback that is used to complete the
// argument of the option // argument of the option
▲ Show 20 Lines • Show All 220 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Interpreter/CommandHistory.h

Show All 12 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
#include <mutex> #include <mutex>
#include <string> #include <string>
#include <vector> #include <vector>
// 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 {
class CommandHistory { class CommandHistory {
public: public:
CommandHistory(); CommandHistory();
Show All 34 Lines

lldb/trunk/include/lldb/Interpreter/CommandObjectRegexCommand.h

Show All 10 Lines
#define liblldb_CommandObjectRegexCommand_h_ #define liblldb_CommandObjectRegexCommand_h_
// C Includes // C Includes
// C++ Includes // C++ Includes
#include <list> #include <list>
// 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 {
//------------------------------------------------------------------------- //-------------------------------------------------------------------------
// CommandObjectRegexCommand // CommandObjectRegexCommand
//------------------------------------------------------------------------- //-------------------------------------------------------------------------
class CommandObjectRegexCommand : public CommandObjectRaw { class CommandObjectRegexCommand : public CommandObjectRaw {
Show All 40 Lines

lldb/trunk/include/lldb/Interpreter/CommandReturnObject.h

Show All 10 Lines
#define liblldb_CommandReturnObject_h_ #define liblldb_CommandReturnObject_h_
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// 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"
#include "llvm/Support/FormatVariadic.h" #include "llvm/Support/FormatVariadic.h"
#include <memory> #include <memory>
namespace lldb_private { namespace lldb_private {
▲ Show 20 Lines • Show All 154 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Interpreter/OptionGroupPlatform.h

//===-- OptionGroupPlatform.h -----------------------------------*- C++ -*-===// //===-- OptionGroupPlatform.h -----------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef liblldb_OptionGroupPlatform_h_ #ifndef liblldb_OptionGroupPlatform_h_
#define liblldb_OptionGroupPlatform_h_ #define liblldb_OptionGroupPlatform_h_
// C Includes // C Includes
// 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 {
//------------------------------------------------------------------------- //-------------------------------------------------------------------------
// PlatformOptionGroup // PlatformOptionGroup
// //
// Make platform options available to any commands that need the settings. // Make platform options available to any commands that need the settings.
//------------------------------------------------------------------------- //-------------------------------------------------------------------------
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Interpreter/OptionValue.h

//===-- OptionValue.h -------------------------------------------*- C++ -*-===// //===-- OptionValue.h -------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef liblldb_OptionValue_h_ #ifndef liblldb_OptionValue_h_
#define liblldb_OptionValue_h_ #define liblldb_OptionValue_h_
// C Includes // C Includes
// 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 {
//--------------------------------------------------------------------- //---------------------------------------------------------------------
// OptionValue // OptionValue
//--------------------------------------------------------------------- //---------------------------------------------------------------------
class OptionValue { class OptionValue {
▲ Show 20 Lines • Show All 320 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Interpreter/OptionValueEnumeration.h

//===-- OptionValueEnumeration.h --------------------------------*- C++ -*-===// //===-- OptionValueEnumeration.h --------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef liblldb_OptionValueEnumeration_h_ #ifndef liblldb_OptionValueEnumeration_h_
#define liblldb_OptionValueEnumeration_h_ #define liblldb_OptionValueEnumeration_h_
// C Includes // C Includes
// 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 {
class OptionValueEnumeration : public OptionValue { class OptionValueEnumeration : public OptionValue {
public: public:
typedef int64_t enum_type; typedef int64_t enum_type;
struct EnumeratorInfo { struct EnumeratorInfo {
enum_type value; enum_type value;
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Interpreter/OptionValueProperties.h

Show All 10 Lines
#define liblldb_OptionValueProperties_h_ #define liblldb_OptionValueProperties_h_
// C Includes // C Includes
// C++ Includes // C++ Includes
#include <vector> #include <vector>
// 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 {
class OptionValueProperties class OptionValueProperties
: public OptionValue, : public OptionValue,
public std::enable_shared_from_this<OptionValueProperties> { public std::enable_shared_from_this<OptionValueProperties> {
public: public:
OptionValueProperties() OptionValueProperties()
▲ Show 20 Lines • Show All 203 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Interpreter/OptionValueRegex.h

//===-- OptionValueRegex.h --------------------------------------*- C++ -*-===// //===-- OptionValueRegex.h --------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef liblldb_OptionValueRegex_h_ #ifndef liblldb_OptionValueRegex_h_
#define liblldb_OptionValueRegex_h_ #define liblldb_OptionValueRegex_h_
// C Includes // C Includes
// 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 {
class OptionValueRegex : public OptionValue { class OptionValueRegex : public OptionValue {
public: public:
OptionValueRegex(const char *value = nullptr) OptionValueRegex(const char *value = nullptr)
: OptionValue(), m_regex(llvm::StringRef::withNullAsEmpty(value)) {} : OptionValue(), m_regex(llvm::StringRef::withNullAsEmpty(value)) {}
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Interpreter/Property.h

Show All 10 Lines
#define liblldb_Property_h_ #define liblldb_Property_h_
// C Includes // C Includes
// C++ Includes // C++ Includes
#include <string> #include <string>
// 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 {
// A structure that can be used to create a global table for all properties. // A structure that can be used to create a global table for all properties.
// Property class instances can be constructed using one of these. // Property class instances can be constructed using one of these.
struct PropertyDefinition { struct PropertyDefinition {
const char *name; const char *name;
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Interpreter/ScriptInterpreter.h

Show All 12 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
#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"
namespace lldb_private { namespace lldb_private {
class ScriptInterpreterLocker { class ScriptInterpreterLocker {
public: public:
ScriptInterpreterLocker() = default; ScriptInterpreterLocker() = default;
▲ Show 20 Lines • Show All 423 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Symbol/Block.h

Show All 12 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
#include <vector> #include <vector>
// 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/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 {
//---------------------------------------------------------------------- //----------------------------------------------------------------------
/// @class Block Block.h "lldb/Symbol/Block.h" /// @class Block Block.h "lldb/Symbol/Block.h"
/// @brief A class that describes a single lexical block. /// @brief A class that describes a single lexical block.
/// ///
▲ Show 20 Lines • Show All 407 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Symbol/ClangASTContext.h

Show All 25 Lines
// Other libraries and framework includes // Other libraries and framework includes
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/AST/TemplateBase.h" #include "clang/AST/TemplateBase.h"
#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/SmallVector.h"
// 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;
class PDBASTParser; class PDBASTParser;
namespace lldb_private { namespace lldb_private {
class Declaration; class Declaration;
▲ Show 20 Lines • Show All 997 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Symbol/CompileUnit.h

//===-- CompileUnit.h -------------------------------------------*- C++ -*-===// //===-- CompileUnit.h -------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef liblldb_CompUnit_h_ #ifndef liblldb_CompUnit_h_
#define liblldb_CompUnit_h_ #define liblldb_CompUnit_h_
#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 {
//---------------------------------------------------------------------- //----------------------------------------------------------------------
/// @class CompileUnit CompileUnit.h "lldb/Symbol/CompileUnit.h" /// @class CompileUnit CompileUnit.h "lldb/Symbol/CompileUnit.h"
/// @brief A class that describes a compilation unit. /// @brief A class that describes a compilation unit.
/// ///
/// A representation of a compilation unit, or compiled source file. /// A representation of a compilation unit, or compiled source file.
▲ Show 20 Lines • Show All 440 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Symbol/CompilerDecl.h

//===-- CompilerDecl.h ------------------------------------------*- C++ -*-===// //===-- CompilerDecl.h ------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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 {
class CompilerDecl { class CompilerDecl {
public: public:
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// Constructors and Destructors // Constructors and Destructors
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Symbol/CompilerDeclContext.h

//===-- CompilerDeclContext.h -----------------------------------*- C++ -*-===// //===-- CompilerDeclContext.h -----------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef liblldb_CompilerDeclContext_h_ #ifndef liblldb_CompilerDeclContext_h_
#define liblldb_CompilerDeclContext_h_ #define liblldb_CompilerDeclContext_h_
#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 {
class CompilerDeclContext { class CompilerDeclContext {
public: public:
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// Constructors and Destructors // Constructors and Destructors
▲ Show 20 Lines • Show All 90 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Symbol/DebugMacros.h

Show All 11 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
#include <memory> #include <memory>
#include <vector> #include <vector>
// 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 {
class CompileUnit; class CompileUnit;
class DebugMacros; class DebugMacros;
typedef std::shared_ptr<DebugMacros> DebugMacrosSP; typedef std::shared_ptr<DebugMacros> DebugMacrosSP;
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Symbol/GoASTContext.h

Show All 14 Lines
#include <map> #include <map>
#include <memory> #include <memory>
#include <set> #include <set>
#include <string> #include <string>
#include <vector> #include <vector>
// 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 {
class Declaration; class Declaration;
class GoType; class GoType;
class GoASTContext : public TypeSystem { class GoASTContext : public TypeSystem {
public: public:
▲ Show 20 Lines • Show All 395 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Symbol/JavaASTContext.h

Show All 12 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
#include <map> #include <map>
#include <memory> #include <memory>
#include <set> #include <set>
// 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 {
class JavaASTContext : public TypeSystem { class JavaASTContext : public TypeSystem {
public: public:
class JavaType; class JavaType;
typedef std::map<ConstString, std::unique_ptr<JavaType>> JavaTypeMap; typedef std::map<ConstString, std::unique_ptr<JavaType>> JavaTypeMap;
▲ Show 20 Lines • Show All 324 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Symbol/OCamlASTContext.h

Show All 15 Lines
#include <map> #include <map>
#include <memory> #include <memory>
#include <set> #include <set>
#include <string> #include <string>
#include <vector> #include <vector>
// 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 {
class OCamlASTContext : public TypeSystem { class OCamlASTContext : public TypeSystem {
public: public:
class OCamlType; class OCamlType;
typedef std::map<ConstString, std::unique_ptr<OCamlType>> OCamlTypeMap; typedef std::map<ConstString, std::unique_ptr<OCamlType>> OCamlTypeMap;
▲ Show 20 Lines • Show All 290 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Symbol/Type.h

//===-- Type.h --------------------------------------------------*- C++ -*-===// //===-- Type.h --------------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef liblldb_Type_h_ #ifndef liblldb_Type_h_
#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"
#include <set> #include <set>
namespace lldb_private { namespace lldb_private {
▲ Show 20 Lines • Show All 649 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Symbol/UnwindPlan.h

Show All 13 Lines
// C++ Includes // C++ Includes
#include <map> #include <map>
#include <memory> #include <memory>
#include <vector> #include <vector>
// 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 {
// The UnwindPlan object specifies how to unwind out of a function - where // The UnwindPlan object specifies how to unwind out of a function - where
// this function saves the caller's register values before modifying them // this function saves the caller's register values before modifying them
// (for non-volatile aka saved registers) and how to find this frame's // (for non-volatile aka saved registers) and how to find this frame's
// Canonical Frame Address (CFA). // Canonical Frame Address (CFA).
▲ Show 20 Lines • Show All 463 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Target/ABI.h

//===-- ABI.h ---------------------------------------------------*- C++ -*-===// //===-- ABI.h ---------------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef liblldb_ABI_h_ #ifndef liblldb_ABI_h_
#define liblldb_ABI_h_ #define liblldb_ABI_h_
// C Includes // C Includes
// 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"
// forward define the llvm::Type class // forward define the llvm::Type class
namespace llvm { namespace llvm {
class Type; class Type;
} }
▲ Show 20 Lines • Show All 121 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Target/DynamicLoader.h

//===-- DynamicLoader.h -----------------------------------------*- C++ -*-===// //===-- DynamicLoader.h -----------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef liblldb_DynamicLoader_h_ #ifndef liblldb_DynamicLoader_h_
#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 {
//---------------------------------------------------------------------- //----------------------------------------------------------------------
/// @class DynamicLoader DynamicLoader.h "lldb/Target/DynamicLoader.h" /// @class DynamicLoader DynamicLoader.h "lldb/Target/DynamicLoader.h"
/// @brief A plug-in interface definition class for dynamic loaders. /// @brief A plug-in interface definition class for dynamic loaders.
/// ///
▲ Show 20 Lines • Show All 323 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Target/MemoryRegionInfo.h

//===-- MemoryRegionInfo.h ---------------------------------------*- C++ //===-- MemoryRegionInfo.h ---------------------------------------*- C++
//-*-===// //-*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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 {
class MemoryRegionInfo { class MemoryRegionInfo {
public: public:
typedef Range<lldb::addr_t, lldb::addr_t> RangeType; typedef Range<lldb::addr_t, lldb::addr_t> RangeType;
enum OptionalBool { eDontKnow = -1, eNo = 0, eYes = 1 }; enum OptionalBool { eDontKnow = -1, eNo = 0, eYes = 1 };
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Target/PathMappingList.h

Show All 9 Lines
#ifndef liblldb_PathMappingList_h_ #ifndef liblldb_PathMappingList_h_
#define liblldb_PathMappingList_h_ #define liblldb_PathMappingList_h_
// C Includes // C Includes
// C++ Includes // C++ Includes
#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 {
class PathMappingList { class PathMappingList {
public: public:
typedef void (*ChangedCallback)(const PathMappingList &path_list, typedef void (*ChangedCallback)(const PathMappingList &path_list,
void *baton); void *baton);
▲ Show 20 Lines • Show All 112 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Target/Platform.h

Show All 16 Lines
#include <memory> #include <memory>
#include <mutex> #include <mutex>
#include <string> #include <string>
#include <vector> #include <vector>
// 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"
// TODO pull NativeDelegate class out of NativeProcessProtocol so we // TODO pull NativeDelegate class out of NativeProcessProtocol so we
// can just forward ref the NativeDelegate rather than include it here. // can just forward ref the NativeDelegate rather than include it here.
#include "lldb/Host/common/NativeProcessProtocol.h" #include "lldb/Host/common/NativeProcessProtocol.h"
namespace lldb_private { namespace lldb_private {
▲ Show 20 Lines • Show All 1,132 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Target/Process.h

Show All 24 Lines
#include <vector> #include <vector>
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Breakpoint/BreakpointSiteList.h" #include "lldb/Breakpoint/BreakpointSiteList.h"
#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"
#include "lldb/Core/PluginInterface.h" #include "lldb/Core/PluginInterface.h"
#include "lldb/Core/StructuredData.h" #include "lldb/Core/StructuredData.h"
#include "lldb/Core/ThreadSafeValue.h" #include "lldb/Core/ThreadSafeValue.h"
#include "lldb/Core/UserSettingsController.h" #include "lldb/Core/UserSettingsController.h"
#include "lldb/Host/HostThread.h" #include "lldb/Host/HostThread.h"
#include "lldb/Host/ProcessRunLock.h" #include "lldb/Host/ProcessRunLock.h"
#include "lldb/Interpreter/Options.h" #include "lldb/Interpreter/Options.h"
#include "lldb/Target/ExecutionContextScope.h" #include "lldb/Target/ExecutionContextScope.h"
#include "lldb/Target/InstrumentationRuntime.h" #include "lldb/Target/InstrumentationRuntime.h"
#include "lldb/Target/Memory.h" #include "lldb/Target/Memory.h"
#include "lldb/Target/ProcessInfo.h" #include "lldb/Target/ProcessInfo.h"
#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"
namespace lldb_private { namespace lldb_private {
template <typename B, typename S> struct Range; template <typename B, typename S> struct Range;
▲ Show 20 Lines • Show All 3,119 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Target/QueueItem.h

Show All 17 Lines
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/lldb-enumerations.h" #include "lldb/lldb-enumerations.h"
#include "lldb/lldb-forward.h" #include "lldb/lldb-forward.h"
#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 {
//------------------------------------------------------------------ //------------------------------------------------------------------
// QueueItem: // QueueItem:
// This class represents a work item enqueued on a libdispatch aka // This class represents a work item enqueued on a libdispatch aka
// Grand Central Dispatch (GCD) queue. Most often, this will be a // Grand Central Dispatch (GCD) queue. Most often, this will be a
// function or block. // function or block.
▲ Show 20 Lines • Show All 153 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Target/StackFrame.h

Show All 11 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
#include <memory> #include <memory>
#include <mutex> #include <mutex>
// 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 {
/// @class StackFrame StackFrame.h "lldb/Target/StackFrame.h" /// @class StackFrame StackFrame.h "lldb/Target/StackFrame.h"
/// ///
/// @brief This base class provides an interface to stack frames. /// @brief This base class provides an interface to stack frames.
/// ///
/// StackFrames may have a Canonical Frame Address (CFA) or not. /// StackFrames may have a Canonical Frame Address (CFA) or not.
▲ Show 20 Lines • Show All 520 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Target/SystemRuntime.h

Show All 10 Lines
#define liblldb_SystemRuntime_h_ #define liblldb_SystemRuntime_h_
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// 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"
namespace lldb_private { namespace lldb_private {
//---------------------------------------------------------------------- //----------------------------------------------------------------------
/// @class SystemRuntime SystemRuntime.h "lldb/Target/SystemRuntime.h" /// @class SystemRuntime SystemRuntime.h "lldb/Target/SystemRuntime.h"
/// @brief A plug-in interface definition class for system runtimes. /// @brief A plug-in interface definition class for system runtimes.
▲ Show 20 Lines • Show All 330 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Target/UnixSignals.h

Show All 11 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
#include <map> #include <map>
#include <string> #include <string>
// 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 {
class UnixSignals { class UnixSignals {
public: public:
static lldb::UnixSignalsSP Create(const ArchSpec &arch); static lldb::UnixSignalsSP Create(const ArchSpec &arch);
▲ Show 20 Lines • Show All 93 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Utility/ConstString.h

//===-- 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/trunk/include/lldb/Utility/Error.h

//===-- 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/trunk/include/lldb/Utility/JSON.h

//===---------------------JSON.h --------------------------------*- C++ -*-===// //===---------------------JSON.h --------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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>
#include <map> #include <map>
#include <memory> #include <memory>
#include <stdint.h> #include <stdint.h>
#include <string> #include <string>
#include <vector> #include <vector>
▲ Show 20 Lines • Show All 265 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Utility/ProcessStructReader.h

//===---------------------ProcessStructReader.h ------------------*- C++ //===---------------------ProcessStructReader.h ------------------*- C++
//-*-===// //-*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef utility_ProcessStructReader_h_ #ifndef utility_ProcessStructReader_h_
#define utility_ProcessStructReader_h_ #define utility_ProcessStructReader_h_
#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>
#include <string> #include <string>
namespace lldb_private { namespace lldb_private {
class ProcessStructReader { class ProcessStructReader {
protected: protected:
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Utility/RegularExpression.h

//===-- 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/trunk/include/lldb/Utility/Stream.h

//===-- 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/trunk/include/lldb/Utility/StreamString.h

//===-- 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/trunk/include/lldb/Utility/StreamTee.h

//===-- 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/trunk/include/lldb/lldb-private-enumerations.h

Show First 20 Lines • Show All 262 Lines • ▼ Show 20 Lines
namespace llvm { namespace llvm {
template <> struct format_provider<lldb_private::Vote> { template <> struct format_provider<lldb_private::Vote> {
static void format(const lldb_private::Vote &V, llvm::raw_ostream &Stream, static void format(const lldb_private::Vote &V, llvm::raw_ostream &Stream,
StringRef Style) { StringRef Style) {
switch (V) { switch (V) {
case lldb_private::eVoteNo: case lldb_private::eVoteNo:
Stream << "no"; Stream << "no";
return;
case lldb_private::eVoteNoOpinion: case lldb_private::eVoteNoOpinion:
Stream << "no opinion"; Stream << "no opinion";
return;
case lldb_private::eVoteYes: case lldb_private::eVoteYes:
Stream << "yes"; Stream << "yes";
return;
} }
Stream << "invalid"; Stream << "invalid";
} }
}; };
} }
#endif // LLDB_lldb_private_enumerations_h_ #endif // LLDB_lldb_private_enumerations_h_

lldb/trunk/source/API/SBAddress.cpp

//===-- SBAddress.cpp -------------------------------------------*- C++ -*-===// //===-- SBAddress.cpp -------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/API/SBAddress.h" #include "lldb/API/SBAddress.h"
#include "lldb/API/SBProcess.h" #include "lldb/API/SBProcess.h"
#include "lldb/API/SBSection.h" #include "lldb/API/SBSection.h"
#include "lldb/API/SBStream.h" #include "lldb/API/SBStream.h"
#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;
SBAddress::SBAddress() : m_opaque_ap(new Address()) {} SBAddress::SBAddress() : m_opaque_ap(new Address()) {}
SBAddress::SBAddress(const Address *lldb_object_ptr) SBAddress::SBAddress(const Address *lldb_object_ptr)
: m_opaque_ap(new Address()) { : m_opaque_ap(new Address()) {
▲ Show 20 Lines • Show All 217 Lines • Show Last 20 Lines

lldb/trunk/source/API/SBBreakpoint.cpp

Show All 21 Lines
#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/Breakpoint/StoppointCallbackContext.h" #include "lldb/Breakpoint/StoppointCallbackContext.h"
#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"
#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/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"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
▲ Show 20 Lines • Show All 810 Lines • Show Last 20 Lines

lldb/trunk/source/API/SBBreakpointLocation.cpp

Show All 11 Lines
#include "lldb/API/SBDebugger.h" #include "lldb/API/SBDebugger.h"
#include "lldb/API/SBDefines.h" #include "lldb/API/SBDefines.h"
#include "lldb/API/SBStream.h" #include "lldb/API/SBStream.h"
#include "lldb/Breakpoint/Breakpoint.h" #include "lldb/Breakpoint/Breakpoint.h"
#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"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
SBBreakpointLocation::SBBreakpointLocation() : m_opaque_sp() {} SBBreakpointLocation::SBBreakpointLocation() : m_opaque_sp() {}
▲ Show 20 Lines • Show All 282 Lines • Show Last 20 Lines

lldb/trunk/source/API/SBCommandReturnObject.cpp

Show All 9 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/API/SBCommandReturnObject.h" #include "lldb/API/SBCommandReturnObject.h"
#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;
SBCommandReturnObject::SBCommandReturnObject() SBCommandReturnObject::SBCommandReturnObject()
: m_opaque_ap(new CommandReturnObject()) {} : m_opaque_ap(new CommandReturnObject()) {}
SBCommandReturnObject::SBCommandReturnObject(const SBCommandReturnObject &rhs) SBCommandReturnObject::SBCommandReturnObject(const SBCommandReturnObject &rhs)
▲ Show 20 Lines • Show All 252 Lines • Show Last 20 Lines

lldb/trunk/source/API/SBData.cpp

Show All 10 Lines
#include "lldb/API/SBData.h" #include "lldb/API/SBData.h"
#include "lldb/API/SBError.h" #include "lldb/API/SBError.h"
#include "lldb/API/SBStream.h" #include "lldb/API/SBStream.h"
#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;
SBData::SBData() : m_opaque_sp(new DataExtractor()) {} SBData::SBData() : m_opaque_sp(new DataExtractor()) {}
SBData::SBData(const lldb::DataExtractorSP &data_sp) : m_opaque_sp(data_sp) {} SBData::SBData(const lldb::DataExtractorSP &data_sp) : m_opaque_sp(data_sp) {}
▲ Show 20 Lines • Show All 676 Lines • Show Last 20 Lines

lldb/trunk/source/API/SBDeclaration.cpp

//===-- SBDeclaration.cpp -----------------------------------------*- C++ //===-- SBDeclaration.cpp -----------------------------------------*- C++
//-*-===// //-*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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>
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
SBDeclaration::SBDeclaration() : m_opaque_ap() {} SBDeclaration::SBDeclaration() : m_opaque_ap() {}
▲ Show 20 Lines • Show All 130 Lines • Show Last 20 Lines

lldb/trunk/source/API/SBError.cpp

//===-- SBError.cpp ---------------------------------------------*- C++ -*-===// //===-- SBError.cpp ---------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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>
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
SBError::SBError() : m_opaque_ap() {} SBError::SBError() : m_opaque_ap() {}
▲ Show 20 Lines • Show All 152 Lines • Show Last 20 Lines

lldb/trunk/source/API/SBEvent.cpp

//===-- SBEvent.cpp ---------------------------------------------*- C++ -*-===// //===-- SBEvent.cpp ---------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/API/SBEvent.h" #include "lldb/API/SBEvent.h"
#include "lldb/API/SBBroadcaster.h" #include "lldb/API/SBBroadcaster.h"
#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;
SBEvent::SBEvent() : m_event_sp(), m_opaque_ptr(NULL) {} SBEvent::SBEvent() : m_event_sp(), m_opaque_ptr(NULL) {}
SBEvent::SBEvent(uint32_t event_type, const char *cstr, uint32_t cstr_len) SBEvent::SBEvent(uint32_t event_type, const char *cstr, uint32_t cstr_len)
: m_event_sp(new Event(event_type, new EventDataBytes(cstr, cstr_len))), : m_event_sp(new Event(event_type, new EventDataBytes(cstr, cstr_len))),
▲ Show 20 Lines • Show All 163 Lines • Show Last 20 Lines

lldb/trunk/source/API/SBFileSpec.cpp

//===-- SBFileSpec.cpp ------------------------------------------*- C++ -*-===// //===-- SBFileSpec.cpp ------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include <inttypes.h> // PRIu64 #include <inttypes.h> // PRIu64
#include <limits.h> #include <limits.h>
#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"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
SBFileSpec::SBFileSpec() : m_opaque_ap(new lldb_private::FileSpec()) {} SBFileSpec::SBFileSpec() : m_opaque_ap(new lldb_private::FileSpec()) {}
▲ Show 20 Lines • Show All 141 Lines • Show Last 20 Lines

lldb/trunk/source/API/SBFileSpecList.cpp

//===-- SBFileSpecList.cpp --------------------------------------*- C++ -*-===// //===-- SBFileSpecList.cpp --------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include <limits.h> #include <limits.h>
#include "lldb/API/SBFileSpec.h" #include "lldb/API/SBFileSpec.h"
#include "lldb/API/SBFileSpecList.h" #include "lldb/API/SBFileSpecList.h"
#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;
SBFileSpecList::SBFileSpecList() : m_opaque_ap(new FileSpecList()) {} SBFileSpecList::SBFileSpecList() : m_opaque_ap(new FileSpecList()) {}
SBFileSpecList::SBFileSpecList(const SBFileSpecList &rhs) : m_opaque_ap() { SBFileSpecList::SBFileSpecList(const SBFileSpecList &rhs) : m_opaque_ap() {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

lldb/trunk/source/API/SBFrame.cpp

Show All 15 Lines
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/API/SBFrame.h" #include "lldb/API/SBFrame.h"
#include "lldb/lldb-types.h" #include "lldb/lldb-types.h"
#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"
#include "lldb/Expression/UserExpression.h" #include "lldb/Expression/UserExpression.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.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/Symbol/Variable.h" #include "lldb/Symbol/Variable.h"
#include "lldb/Symbol/VariableList.h" #include "lldb/Symbol/VariableList.h"
#include "lldb/Target/ExecutionContext.h" #include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h" #include "lldb/Target/RegisterContext.h"
#include "lldb/Target/StackFrame.h" #include "lldb/Target/StackFrame.h"
#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"
#include "lldb/API/SBExpressionOptions.h" #include "lldb/API/SBExpressionOptions.h"
#include "lldb/API/SBStream.h" #include "lldb/API/SBStream.h"
#include "lldb/API/SBSymbolContext.h" #include "lldb/API/SBSymbolContext.h"
#include "lldb/API/SBThread.h" #include "lldb/API/SBThread.h"
#include "lldb/API/SBValue.h" #include "lldb/API/SBValue.h"
▲ Show 20 Lines • Show All 1,419 Lines • Show Last 20 Lines

lldb/trunk/source/API/SBInstructionList.cpp

//===-- SBInstructionList.cpp -----------------------------------*- C++ -*-===// //===-- SBInstructionList.cpp -----------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/API/SBInstructionList.h" #include "lldb/API/SBInstructionList.h"
#include "lldb/API/SBInstruction.h" #include "lldb/API/SBInstruction.h"
#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;
SBInstructionList::SBInstructionList() : m_opaque_sp() {} SBInstructionList::SBInstructionList() : m_opaque_sp() {}
SBInstructionList::SBInstructionList(const SBInstructionList &rhs) SBInstructionList::SBInstructionList(const SBInstructionList &rhs)
: m_opaque_sp(rhs.m_opaque_sp) {} : m_opaque_sp(rhs.m_opaque_sp) {}
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

lldb/trunk/source/API/SBLineEntry.cpp

//===-- SBLineEntry.cpp -----------------------------------------*- C++ -*-===// //===-- SBLineEntry.cpp -----------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include <limits.h> #include <limits.h>
#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;
SBLineEntry::SBLineEntry() : m_opaque_ap() {} SBLineEntry::SBLineEntry() : m_opaque_ap() {}
SBLineEntry::SBLineEntry(const SBLineEntry &rhs) : m_opaque_ap() { SBLineEntry::SBLineEntry(const SBLineEntry &rhs) : m_opaque_ap() {
if (rhs.IsValid()) if (rhs.IsValid())
▲ Show 20 Lines • Show All 165 Lines • Show Last 20 Lines

lldb/trunk/source/API/SBListener.cpp

Show All 10 Lines
#include "lldb/API/SBBroadcaster.h" #include "lldb/API/SBBroadcaster.h"
#include "lldb/API/SBDebugger.h" #include "lldb/API/SBDebugger.h"
#include "lldb/API/SBEvent.h" #include "lldb/API/SBEvent.h"
#include "lldb/API/SBStream.h" #include "lldb/API/SBStream.h"
#include "lldb/Core/Broadcaster.h" #include "lldb/Core/Broadcaster.h"
#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;
SBListener::SBListener() : m_opaque_sp(), m_unused_ptr(NULL) {} SBListener::SBListener() : m_opaque_sp(), m_unused_ptr(NULL) {}
SBListener::SBListener(const char *name) SBListener::SBListener(const char *name)
: m_opaque_sp(Listener::MakeListener(name)), m_unused_ptr(nullptr) { : m_opaque_sp(Listener::MakeListener(name)), m_unused_ptr(nullptr) {
▲ Show 20 Lines • Show All 285 Lines • Show Last 20 Lines

lldb/trunk/source/API/SBMemoryRegionInfo.cpp

//===-- SBMemoryRegionInfo.cpp ----------------------------------*- C++ -*-===// //===-- SBMemoryRegionInfo.cpp ----------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/API/SBMemoryRegionInfo.h" #include "lldb/API/SBMemoryRegionInfo.h"
#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;
SBMemoryRegionInfo::SBMemoryRegionInfo() SBMemoryRegionInfo::SBMemoryRegionInfo()
: m_opaque_ap(new MemoryRegionInfo()) {} : m_opaque_ap(new MemoryRegionInfo()) {}
SBMemoryRegionInfo::SBMemoryRegionInfo(const MemoryRegionInfo *lldb_object_ptr) SBMemoryRegionInfo::SBMemoryRegionInfo(const MemoryRegionInfo *lldb_object_ptr)
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

lldb/trunk/source/API/SBModule.cpp

Show All 11 Lines
#include "lldb/API/SBFileSpec.h" #include "lldb/API/SBFileSpec.h"
#include "lldb/API/SBModuleSpec.h" #include "lldb/API/SBModuleSpec.h"
#include "lldb/API/SBProcess.h" #include "lldb/API/SBProcess.h"
#include "lldb/API/SBStream.h" #include "lldb/API/SBStream.h"
#include "lldb/API/SBSymbolContextList.h" #include "lldb/API/SBSymbolContextList.h"
#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"
#include "lldb/Symbol/SymbolFile.h" #include "lldb/Symbol/SymbolFile.h"
#include "lldb/Symbol/SymbolVendor.h" #include "lldb/Symbol/SymbolVendor.h"
#include "lldb/Symbol/Symtab.h" #include "lldb/Symbol/Symtab.h"
#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;
SBModule::SBModule() : m_opaque_sp() {} SBModule::SBModule() : m_opaque_sp() {}
SBModule::SBModule(const lldb::ModuleSP &module_sp) : m_opaque_sp(module_sp) {} SBModule::SBModule(const lldb::ModuleSP &module_sp) : m_opaque_sp(module_sp) {}
▲ Show 20 Lines • Show All 530 Lines • Show Last 20 Lines

lldb/trunk/source/API/SBModuleSpec.cpp

//===-- SBModuleSpec.cpp ----------------------------------------*- C++ -*-===// //===-- SBModuleSpec.cpp ----------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/API/SBModuleSpec.h" #include "lldb/API/SBModuleSpec.h"
#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;
SBModuleSpec::SBModuleSpec() : m_opaque_ap(new lldb_private::ModuleSpec()) {} SBModuleSpec::SBModuleSpec() : m_opaque_ap(new lldb_private::ModuleSpec()) {}
SBModuleSpec::SBModuleSpec(const SBModuleSpec &rhs) SBModuleSpec::SBModuleSpec(const SBModuleSpec &rhs)
: m_opaque_ap(new lldb_private::ModuleSpec(*rhs.m_opaque_ap)) {} : m_opaque_ap(new lldb_private::ModuleSpec(*rhs.m_opaque_ap)) {}
▲ Show 20 Lines • Show All 133 Lines • Show Last 20 Lines

lldb/trunk/source/API/SBPlatform.cpp

//===-- SBPlatform.cpp ------------------------------------------*- C++ -*-===// //===-- SBPlatform.cpp ------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/API/SBPlatform.h" #include "lldb/API/SBPlatform.h"
#include "lldb/API/SBError.h" #include "lldb/API/SBError.h"
#include "lldb/API/SBFileSpec.h" #include "lldb/API/SBFileSpec.h"
#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>
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// PlatformConnectOptions // PlatformConnectOptions
▲ Show 20 Lines • Show All 454 Lines • Show Last 20 Lines

lldb/trunk/source/API/SBProcess.cpp

Show All 14 Lines
#include "lldb/lldb-defines.h" #include "lldb/lldb-defines.h"
#include "lldb/lldb-types.h" #include "lldb/lldb-types.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/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"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h" #include "lldb/Target/RegisterContext.h"
#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
#include "lldb/API/SBBroadcaster.h" #include "lldb/API/SBBroadcaster.h"
#include "lldb/API/SBCommandReturnObject.h" #include "lldb/API/SBCommandReturnObject.h"
#include "lldb/API/SBDebugger.h" #include "lldb/API/SBDebugger.h"
#include "lldb/API/SBEvent.h" #include "lldb/API/SBEvent.h"
#include "lldb/API/SBFileSpec.h" #include "lldb/API/SBFileSpec.h"
▲ Show 20 Lines • Show All 1,299 Lines • Show Last 20 Lines

lldb/trunk/source/API/SBSection.cpp

Show All 9 Lines
#include "lldb/API/SBSection.h" #include "lldb/API/SBSection.h"
#include "lldb/API/SBStream.h" #include "lldb/API/SBStream.h"
#include "lldb/API/SBTarget.h" #include "lldb/API/SBTarget.h"
#include "lldb/Core/DataBuffer.h" #include "lldb/Core/DataBuffer.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/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;
SBSection::SBSection() : m_opaque_wp() {} SBSection::SBSection() : m_opaque_wp() {}
SBSection::SBSection(const SBSection &rhs) : m_opaque_wp(rhs.m_opaque_wp) {} SBSection::SBSection(const SBSection &rhs) : m_opaque_wp(rhs.m_opaque_wp) {}
▲ Show 20 Lines • Show All 208 Lines • Show Last 20 Lines

lldb/trunk/source/API/SBSourceManager.cpp

Show All 9 Lines
#include "lldb/API/SBSourceManager.h" #include "lldb/API/SBSourceManager.h"
#include "lldb/API/SBDebugger.h" #include "lldb/API/SBDebugger.h"
#include "lldb/API/SBStream.h" #include "lldb/API/SBStream.h"
#include "lldb/API/SBTarget.h" #include "lldb/API/SBTarget.h"
#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"
namespace lldb_private { namespace lldb_private {
class SourceManagerImpl { class SourceManagerImpl {
public: public:
SourceManagerImpl(const lldb::DebuggerSP &debugger_sp) SourceManagerImpl(const lldb::DebuggerSP &debugger_sp)
: m_debugger_wp(debugger_sp), m_target_wp() {} : m_debugger_wp(debugger_sp), m_target_wp() {}
▲ Show 20 Lines • Show All 89 Lines • Show Last 20 Lines

lldb/trunk/source/API/SBStream.cpp

//===-- SBStream.cpp ----------------------------------------*- C++ -*-===// //===-- SBStream.cpp ----------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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;
SBStream::SBStream() : m_opaque_ap(new StreamString()), m_is_file(false) {} SBStream::SBStream() : m_opaque_ap(new StreamString()), m_is_file(false) {}
SBStream::SBStream(SBStream &&rhs) SBStream::SBStream(SBStream &&rhs)
: m_opaque_ap(std::move(rhs.m_opaque_ap)), m_is_file(rhs.m_is_file) {} : m_opaque_ap(std::move(rhs.m_opaque_ap)), m_is_file(rhs.m_is_file) {}
▲ Show 20 Lines • Show All 131 Lines • Show Last 20 Lines

lldb/trunk/source/API/SBStructuredData.cpp

//===-- SBStructuredData.cpp ------------------------------------*- C++ -*-===// //===-- SBStructuredData.cpp ------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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;
#pragma mark-- #pragma mark--
#pragma mark StructuredDataImpl #pragma mark StructuredDataImpl
class StructuredDataImpl { class StructuredDataImpl {
▲ Show 20 Lines • Show All 93 Lines • Show Last 20 Lines

lldb/trunk/source/API/SBTarget.cpp

Show All 31 Lines
#include "lldb/Core/AddressResolver.h" #include "lldb/Core/AddressResolver.h"
#include "lldb/Core/AddressResolverName.h" #include "lldb/Core/AddressResolverName.h"
#include "lldb/Core/ArchSpec.h" #include "lldb/Core/ArchSpec.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#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/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"
#include "lldb/Core/ValueObjectConstResult.h" #include "lldb/Core/ValueObjectConstResult.h"
#include "lldb/Core/ValueObjectList.h" #include "lldb/Core/ValueObjectList.h"
#include "lldb/Core/ValueObjectVariable.h" #include "lldb/Core/ValueObjectVariable.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Interpreter/Args.h" #include "lldb/Interpreter/Args.h"
#include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/ClangASTContext.h"
#include "lldb/Symbol/DeclVendor.h" #include "lldb/Symbol/DeclVendor.h"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
#include "lldb/Symbol/SymbolFile.h" #include "lldb/Symbol/SymbolFile.h"
#include "lldb/Symbol/SymbolVendor.h" #include "lldb/Symbol/SymbolVendor.h"
#include "lldb/Symbol/VariableList.h" #include "lldb/Symbol/VariableList.h"
#include "lldb/Target/ABI.h" #include "lldb/Target/ABI.h"
#include "lldb/Target/Language.h" #include "lldb/Target/Language.h"
#include "lldb/Target/LanguageRuntime.h" #include "lldb/Target/LanguageRuntime.h"
#include "lldb/Target/ObjCLanguageRuntime.h" #include "lldb/Target/ObjCLanguageRuntime.h"
#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/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"
#include "llvm/Support/PrettyStackTrace.h" #include "llvm/Support/PrettyStackTrace.h"
#include "llvm/Support/Regex.h" #include "llvm/Support/Regex.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
▲ Show 20 Lines • Show All 2,121 Lines • Show Last 20 Lines

lldb/trunk/source/API/SBThread.cpp

Show All 9 Lines
#include "lldb/API/SBThread.h" #include "lldb/API/SBThread.h"
#include "lldb/API/SBFileSpec.h" #include "lldb/API/SBFileSpec.h"
#include "lldb/API/SBStream.h" #include "lldb/API/SBStream.h"
#include "lldb/API/SBSymbolContext.h" #include "lldb/API/SBSymbolContext.h"
#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"
#include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Symbol/CompileUnit.h" #include "lldb/Symbol/CompileUnit.h"
#include "lldb/Symbol/SymbolContext.h" #include "lldb/Symbol/SymbolContext.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/Queue.h" #include "lldb/Target/Queue.h"
#include "lldb/Target/StopInfo.h" #include "lldb/Target/StopInfo.h"
#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/Target/ThreadPlan.h" #include "lldb/Target/ThreadPlan.h"
#include "lldb/Target/ThreadPlanStepInRange.h" #include "lldb/Target/ThreadPlanStepInRange.h"
#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/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"
#include "lldb/API/SBEvent.h" #include "lldb/API/SBEvent.h"
#include "lldb/API/SBFrame.h" #include "lldb/API/SBFrame.h"
#include "lldb/API/SBProcess.h" #include "lldb/API/SBProcess.h"
#include "lldb/API/SBThreadCollection.h" #include "lldb/API/SBThreadCollection.h"
#include "lldb/API/SBThreadPlan.h" #include "lldb/API/SBThreadPlan.h"
▲ Show 20 Lines • Show All 1,399 Lines • Show Last 20 Lines

lldb/trunk/source/API/SBThreadPlan.cpp

Show All 9 Lines
#include "lldb/API/SBThread.h" #include "lldb/API/SBThread.h"
#include "lldb/API/SBFileSpec.h" #include "lldb/API/SBFileSpec.h"
#include "lldb/API/SBStream.h" #include "lldb/API/SBStream.h"
#include "lldb/API/SBSymbolContext.h" #include "lldb/API/SBSymbolContext.h"
#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"
#include "lldb/Symbol/CompileUnit.h" #include "lldb/Symbol/CompileUnit.h"
#include "lldb/Symbol/SymbolContext.h" #include "lldb/Symbol/SymbolContext.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/Queue.h" #include "lldb/Target/Queue.h"
#include "lldb/Target/StopInfo.h" #include "lldb/Target/StopInfo.h"
#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/Target/ThreadPlan.h" #include "lldb/Target/ThreadPlan.h"
#include "lldb/Target/ThreadPlan.h" #include "lldb/Target/ThreadPlan.h"
#include "lldb/Target/ThreadPlanPython.h" #include "lldb/Target/ThreadPlanPython.h"
#include "lldb/Target/ThreadPlanStepInRange.h" #include "lldb/Target/ThreadPlanStepInRange.h"
#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"
#include "lldb/API/SBEvent.h" #include "lldb/API/SBEvent.h"
#include "lldb/API/SBFrame.h" #include "lldb/API/SBFrame.h"
#include "lldb/API/SBProcess.h" #include "lldb/API/SBProcess.h"
#include "lldb/API/SBThreadPlan.h" #include "lldb/API/SBThreadPlan.h"
#include "lldb/API/SBValue.h" #include "lldb/API/SBValue.h"
▲ Show 20 Lines • Show All 167 Lines • Show Last 20 Lines

lldb/trunk/source/API/SBType.cpp

//===-- SBType.cpp ----------------------------------------------*- C++ -*-===// //===-- SBType.cpp ----------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/API/SBType.h" #include "lldb/API/SBType.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/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"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
SBType::SBType() : m_opaque_sp() {} SBType::SBType() : m_opaque_sp() {}
▲ Show 20 Lines • Show All 641 Lines • Show Last 20 Lines

lldb/trunk/source/API/SBTypeEnumMember.cpp

//===-- SBTypeEnumMember.cpp ---------------------------------- -*- C++ -*-===// //===-- SBTypeEnumMember.cpp ---------------------------------- -*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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;
SBTypeEnumMember::SBTypeEnumMember() : m_opaque_sp() {} SBTypeEnumMember::SBTypeEnumMember() : m_opaque_sp() {}
SBTypeEnumMember::~SBTypeEnumMember() {} SBTypeEnumMember::~SBTypeEnumMember() {}
SBTypeEnumMember::SBTypeEnumMember( SBTypeEnumMember::SBTypeEnumMember(
▲ Show 20 Lines • Show All 117 Lines • Show Last 20 Lines

lldb/trunk/source/API/SBValue.cpp

Show All 16 Lines
#include "lldb/API/SBTypeSynthetic.h" #include "lldb/API/SBTypeSynthetic.h"
#include "lldb/Breakpoint/Watchpoint.h" #include "lldb/Breakpoint/Watchpoint.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/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"
#include "lldb/Core/ValueObjectConstResult.h" #include "lldb/Core/ValueObjectConstResult.h"
#include "lldb/DataFormatters/DataVisualization.h" #include "lldb/DataFormatters/DataVisualization.h"
#include "lldb/Symbol/Block.h" #include "lldb/Symbol/Block.h"
#include "lldb/Symbol/Declaration.h" #include "lldb/Symbol/Declaration.h"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
#include "lldb/Symbol/Type.h" #include "lldb/Symbol/Type.h"
#include "lldb/Symbol/Variable.h" #include "lldb/Symbol/Variable.h"
#include "lldb/Symbol/VariableList.h" #include "lldb/Symbol/VariableList.h"
#include "lldb/Target/ExecutionContext.h" #include "lldb/Target/ExecutionContext.h"
#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/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"
#include "lldb/API/SBFrame.h" #include "lldb/API/SBFrame.h"
#include "lldb/API/SBProcess.h" #include "lldb/API/SBProcess.h"
#include "lldb/API/SBTarget.h" #include "lldb/API/SBTarget.h"
#include "lldb/API/SBThread.h" #include "lldb/API/SBThread.h"
▲ Show 20 Lines • Show All 1,558 Lines • Show Last 20 Lines

lldb/trunk/source/API/SBWatchpoint.cpp

Show All 11 Lines
#include "lldb/API/SBDebugger.h" #include "lldb/API/SBDebugger.h"
#include "lldb/API/SBDefines.h" #include "lldb/API/SBDefines.h"
#include "lldb/API/SBEvent.h" #include "lldb/API/SBEvent.h"
#include "lldb/API/SBStream.h" #include "lldb/API/SBStream.h"
#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"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
SBWatchpoint::SBWatchpoint() : m_opaque_sp() {} SBWatchpoint::SBWatchpoint() : m_opaque_sp() {}
▲ Show 20 Lines • Show All 220 Lines • Show Last 20 Lines

lldb/trunk/source/Breakpoint/Breakpoint.cpp

Show All 18 Lines
#include "lldb/Breakpoint/BreakpointResolver.h" #include "lldb/Breakpoint/BreakpointResolver.h"
#include "lldb/Breakpoint/BreakpointResolverFileLine.h" #include "lldb/Breakpoint/BreakpointResolverFileLine.h"
#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/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;
using namespace llvm; using namespace llvm;
const ConstString &Breakpoint::GetEventIdentifier() { const ConstString &Breakpoint::GetEventIdentifier() {
static ConstString g_identifier("event-identifier.breakpoint.changed"); static ConstString g_identifier("event-identifier.breakpoint.changed");
return g_identifier; return g_identifier;
▲ Show 20 Lines • Show All 1,067 Lines • Show Last 20 Lines

lldb/trunk/source/Breakpoint/BreakpointID.cpp

Show All 9 Lines
// C Includes // C Includes
#include <stdio.h> #include <stdio.h>
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// 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;
BreakpointID::BreakpointID(break_id_t bp_id, break_id_t loc_id) BreakpointID::BreakpointID(break_id_t bp_id, break_id_t loc_id)
: m_break_id(bp_id), m_location_id(loc_id) {} : m_break_id(bp_id), m_location_id(loc_id) {}
BreakpointID::~BreakpointID() = default; BreakpointID::~BreakpointID() = default;
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/trunk/source/Breakpoint/BreakpointLocation.cpp

Show All 11 Lines
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Breakpoint/BreakpointLocation.h" #include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Breakpoint/BreakpointID.h" #include "lldb/Breakpoint/BreakpointID.h"
#include "lldb/Breakpoint/StoppointCallbackContext.h" #include "lldb/Breakpoint/StoppointCallbackContext.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/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"
#include "lldb/Expression/UserExpression.h" #include "lldb/Expression/UserExpression.h"
#include "lldb/Symbol/CompileUnit.h" #include "lldb/Symbol/CompileUnit.h"
#include "lldb/Symbol/Symbol.h" #include "lldb/Symbol/Symbol.h"
#include "lldb/Symbol/TypeSystem.h" #include "lldb/Symbol/TypeSystem.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/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;
BreakpointLocation::BreakpointLocation(break_id_t loc_id, Breakpoint &owner, BreakpointLocation::BreakpointLocation(break_id_t loc_id, Breakpoint &owner,
const Address &addr, lldb::tid_t tid, const Address &addr, lldb::tid_t tid,
bool hardware, bool check_for_resolver) bool hardware, bool check_for_resolver)
: StoppointLocation(loc_id, addr.GetOpcodeLoadAddress(&owner.GetTarget()), : StoppointLocation(loc_id, addr.GetOpcodeLoadAddress(&owner.GetTarget()),
▲ Show 20 Lines • Show All 597 Lines • Show Last 20 Lines

lldb/trunk/source/Breakpoint/BreakpointOptions.cpp

//===-- BreakpointOptions.cpp -----------------------------------*- C++ -*-===// //===-- BreakpointOptions.cpp -----------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#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"
#include "lldb/Interpreter/CommandReturnObject.h" #include "lldb/Interpreter/CommandReturnObject.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"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
const char const char
*BreakpointOptions::CommandData::g_option_names[static_cast<uint32_t>( *BreakpointOptions::CommandData::g_option_names[static_cast<uint32_t>(
▲ Show 20 Lines • Show All 532 Lines • Show Last 20 Lines

lldb/trunk/source/Breakpoint/BreakpointResolver.cpp

Show All 19 Lines
#include "lldb/Breakpoint/BreakpointResolverAddress.h" #include "lldb/Breakpoint/BreakpointResolverAddress.h"
#include "lldb/Breakpoint/BreakpointResolverFileLine.h" #include "lldb/Breakpoint/BreakpointResolverFileLine.h"
#include "lldb/Breakpoint/BreakpointResolverFileRegex.h" #include "lldb/Breakpoint/BreakpointResolverFileRegex.h"
#include "lldb/Breakpoint/BreakpointResolverName.h" #include "lldb/Breakpoint/BreakpointResolverName.h"
#include "lldb/Core/Address.h" #include "lldb/Core/Address.h"
#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;
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// BreakpointResolver: // BreakpointResolver:
//---------------------------------------------------------------------- //----------------------------------------------------------------------
const char *BreakpointResolver::g_ty_to_name[] = {"FileAndLine", "Address", const char *BreakpointResolver::g_ty_to_name[] = {"FileAndLine", "Address",
▲ Show 20 Lines • Show All 282 Lines • Show Last 20 Lines

lldb/trunk/source/Breakpoint/BreakpointResolverAddress.cpp

Show All 12 Lines
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#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/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;
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// BreakpointResolverAddress: // BreakpointResolverAddress:
//---------------------------------------------------------------------- //----------------------------------------------------------------------
BreakpointResolverAddress::BreakpointResolverAddress( BreakpointResolverAddress::BreakpointResolverAddress(
▲ Show 20 Lines • Show All 164 Lines • Show Last 20 Lines

lldb/trunk/source/Breakpoint/BreakpointResolverFileLine.cpp

Show All 10 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#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;
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// BreakpointResolverFileLine: // BreakpointResolverFileLine:
//---------------------------------------------------------------------- //----------------------------------------------------------------------
BreakpointResolverFileLine::BreakpointResolverFileLine( BreakpointResolverFileLine::BreakpointResolverFileLine(
▲ Show 20 Lines • Show All 147 Lines • Show Last 20 Lines

lldb/trunk/source/Breakpoint/BreakpointResolverFileRegex.cpp

Show All 10 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#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;
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// BreakpointResolverFileRegex: // BreakpointResolverFileRegex:
//---------------------------------------------------------------------- //----------------------------------------------------------------------
BreakpointResolverFileRegex::BreakpointResolverFileRegex( BreakpointResolverFileRegex::BreakpointResolverFileRegex(
▲ Show 20 Lines • Show All 151 Lines • Show Last 20 Lines

lldb/trunk/source/Breakpoint/BreakpointResolverName.cpp

Show All 12 Lines
// Project includes // Project includes
#include "lldb/Breakpoint/BreakpointResolverName.h" #include "lldb/Breakpoint/BreakpointResolverName.h"
#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/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;
BreakpointResolverName::BreakpointResolverName( BreakpointResolverName::BreakpointResolverName(
Breakpoint *bkpt, const char *name_cstr, uint32_t name_type_mask, Breakpoint *bkpt, const char *name_cstr, uint32_t name_type_mask,
LanguageType language, Breakpoint::MatchType type, lldb::addr_t offset, LanguageType language, Breakpoint::MatchType type, lldb::addr_t offset,
bool skip_prologue) bool skip_prologue)
▲ Show 20 Lines • Show All 391 Lines • Show Last 20 Lines

lldb/trunk/source/Breakpoint/BreakpointSite.cpp

Show All 12 Lines
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Breakpoint/BreakpointSite.h" #include "lldb/Breakpoint/BreakpointSite.h"
#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;
BreakpointSite::BreakpointSite(BreakpointSiteList *list, BreakpointSite::BreakpointSite(BreakpointSiteList *list,
const BreakpointLocationSP &owner, const BreakpointLocationSP &owner,
lldb::addr_t addr, bool use_hardware) lldb::addr_t addr, bool use_hardware)
: StoppointLocation(GetNextID(), addr, 0, use_hardware), : StoppointLocation(GetNextID(), addr, 0, use_hardware),
▲ Show 20 Lines • Show All 174 Lines • Show Last 20 Lines

lldb/trunk/source/Breakpoint/BreakpointSiteList.cpp

//===-- BreakpointSiteList.cpp ----------------------------------*- C++ -*-===// //===-- BreakpointSiteList.cpp ----------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Breakpoint/BreakpointSiteList.h" #include "lldb/Breakpoint/BreakpointSiteList.h"
// C Includes // C Includes
// 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;
using namespace lldb_private; using namespace lldb_private;
BreakpointSiteList::BreakpointSiteList() : m_mutex(), m_bp_site_list() {} BreakpointSiteList::BreakpointSiteList() : m_mutex(), m_bp_site_list() {}
BreakpointSiteList::~BreakpointSiteList() {} BreakpointSiteList::~BreakpointSiteList() {}
▲ Show 20 Lines • Show All 182 Lines • Show Last 20 Lines

lldb/trunk/source/Breakpoint/Watchpoint.cpp

//===-- Watchpoint.cpp ------------------------------------------*- C++ -*-===// //===-- Watchpoint.cpp ------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#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"
#include "lldb/Expression/UserExpression.h" #include "lldb/Expression/UserExpression.h"
#include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/ClangASTContext.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;
Watchpoint::Watchpoint(Target &target, lldb::addr_t addr, uint32_t size, Watchpoint::Watchpoint(Target &target, lldb::addr_t addr, uint32_t size,
const CompilerType *type, bool hardware) const CompilerType *type, bool hardware)
: StoppointLocation(0, addr, size, hardware), m_target(target), : StoppointLocation(0, addr, size, hardware), m_target(target),
m_enabled(false), m_is_hardware(hardware), m_is_watch_variable(false), m_enabled(false), m_is_hardware(hardware), m_is_watch_variable(false),
▲ Show 20 Lines • Show All 355 Lines • Show Last 20 Lines

lldb/trunk/source/Breakpoint/WatchpointOptions.cpp

//===-- WatchpointOptions.cpp -----------------------------------*- C++ -*-===// //===-- WatchpointOptions.cpp -----------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#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;
bool WatchpointOptions::NullCallback(void *baton, bool WatchpointOptions::NullCallback(void *baton,
StoppointCallbackContext *context, StoppointCallbackContext *context,
lldb::user_id_t watch_id) { lldb::user_id_t watch_id) {
return true; return true;
▲ Show 20 Lines • Show All 169 Lines • Show Last 20 Lines

lldb/trunk/source/Commands/CommandObjectBreakpoint.cpp

Show All 12 Lines
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "CommandObjectBreakpoint.h" #include "CommandObjectBreakpoint.h"
#include "CommandObjectBreakpointCommand.h" #include "CommandObjectBreakpointCommand.h"
#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"
#include "lldb/Interpreter/CommandReturnObject.h" #include "lldb/Interpreter/CommandReturnObject.h"
#include "lldb/Interpreter/OptionValueBoolean.h" #include "lldb/Interpreter/OptionValueBoolean.h"
#include "lldb/Interpreter/OptionValueString.h" #include "lldb/Interpreter/OptionValueString.h"
#include "lldb/Interpreter/OptionValueUInt64.h" #include "lldb/Interpreter/OptionValueUInt64.h"
#include "lldb/Interpreter/Options.h" #include "lldb/Interpreter/Options.h"
#include "lldb/Target/Language.h" #include "lldb/Target/Language.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/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;
static void AddBreakpointDescription(Stream *s, Breakpoint *bp, static void AddBreakpointDescription(Stream *s, Breakpoint *bp,
lldb::DescriptionLevel level) { lldb::DescriptionLevel level) {
s->IndentMore(); s->IndentMore();
bp->GetDescription(s, level, true); bp->GetDescription(s, level, true);
▲ Show 20 Lines • Show All 2,398 Lines • Show Last 20 Lines

lldb/trunk/source/Commands/CommandObjectFrame.cpp

Show All 11 Lines
#include <string> #include <string>
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "CommandObjectFrame.h" #include "CommandObjectFrame.h"
#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"
#include "lldb/Core/ValueObjectVariable.h" #include "lldb/Core/ValueObjectVariable.h"
#include "lldb/DataFormatters/DataVisualization.h" #include "lldb/DataFormatters/DataVisualization.h"
#include "lldb/DataFormatters/ValueObjectPrinter.h" #include "lldb/DataFormatters/ValueObjectPrinter.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Host/StringConvert.h" #include "lldb/Host/StringConvert.h"
Show All 13 Lines
#include "lldb/Symbol/Variable.h" #include "lldb/Symbol/Variable.h"
#include "lldb/Symbol/VariableList.h" #include "lldb/Symbol/VariableList.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/StackFrame.h" #include "lldb/Target/StackFrame.h"
#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/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;
#pragma mark CommandObjectFrameDiagnose #pragma mark CommandObjectFrameDiagnose
//------------------------------------------------------------------------- //-------------------------------------------------------------------------
// CommandObjectFrameInfo // CommandObjectFrameInfo
▲ Show 20 Lines • Show All 684 Lines • Show Last 20 Lines

lldb/trunk/source/Commands/CommandObjectLog.cpp

Show All 10 Lines
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "CommandObjectLog.h" #include "CommandObjectLog.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.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/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"
#include "lldb/Host/StringConvert.h" #include "lldb/Host/StringConvert.h"
#include "lldb/Interpreter/Args.h" #include "lldb/Interpreter/Args.h"
#include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Interpreter/CommandReturnObject.h" #include "lldb/Interpreter/CommandReturnObject.h"
#include "lldb/Interpreter/Options.h" #include "lldb/Interpreter/Options.h"
#include "lldb/Symbol/LineTable.h" #include "lldb/Symbol/LineTable.h"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
#include "lldb/Symbol/SymbolFile.h" #include "lldb/Symbol/SymbolFile.h"
#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;
static OptionDefinition g_log_options[] = { static OptionDefinition g_log_options[] = {
// clang-format off // clang-format off
{ LLDB_OPT_SET_1, false, "file", 'f', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeFilename, "Set the destination file to log to." }, { LLDB_OPT_SET_1, false, "file", 'f', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeFilename, "Set the destination file to log to." },
{ LLDB_OPT_SET_1, false, "threadsafe", 't', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Enable thread safe logging to avoid interweaved log lines." }, { LLDB_OPT_SET_1, false, "threadsafe", 't', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Enable thread safe logging to avoid interweaved log lines." },
▲ Show 20 Lines • Show All 354 Lines • Show Last 20 Lines

lldb/trunk/source/Commands/CommandObjectMemory.cpp

Show All 16 Lines
// Project includes // Project includes
#include "CommandObjectMemory.h" #include "CommandObjectMemory.h"
#include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h" #include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.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/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"
#include "lldb/Interpreter/Args.h" #include "lldb/Interpreter/Args.h"
#include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Interpreter/CommandReturnObject.h" #include "lldb/Interpreter/CommandReturnObject.h"
#include "lldb/Interpreter/OptionGroupFormat.h" #include "lldb/Interpreter/OptionGroupFormat.h"
#include "lldb/Interpreter/OptionGroupOutputFile.h" #include "lldb/Interpreter/OptionGroupOutputFile.h"
#include "lldb/Interpreter/OptionGroupValueObjectDisplay.h" #include "lldb/Interpreter/OptionGroupValueObjectDisplay.h"
#include "lldb/Interpreter/OptionValueString.h" #include "lldb/Interpreter/OptionValueString.h"
#include "lldb/Interpreter/Options.h" #include "lldb/Interpreter/Options.h"
#include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/ClangASTContext.h"
#include "lldb/Symbol/SymbolFile.h" #include "lldb/Symbol/SymbolFile.h"
#include "lldb/Symbol/TypeList.h" #include "lldb/Symbol/TypeList.h"
#include "lldb/Target/MemoryHistory.h" #include "lldb/Target/MemoryHistory.h"
#include "lldb/Target/MemoryRegionInfo.h" #include "lldb/Target/MemoryRegionInfo.h"
#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"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
static OptionDefinition g_read_memory_options[] = { static OptionDefinition g_read_memory_options[] = {
// clang-format off // clang-format off
▲ Show 20 Lines • Show All 1,730 Lines • Show Last 20 Lines

lldb/trunk/source/Commands/CommandObjectType.cpp

Show All 10 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
#include <algorithm> #include <algorithm>
#include <cctype> #include <cctype>
#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"
#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/OptionGroupFormat.h" #include "lldb/Interpreter/OptionGroupFormat.h"
#include "lldb/Interpreter/OptionValueBoolean.h" #include "lldb/Interpreter/OptionValueBoolean.h"
#include "lldb/Interpreter/OptionValueLanguage.h" #include "lldb/Interpreter/OptionValueLanguage.h"
#include "lldb/Interpreter/OptionValueString.h" #include "lldb/Interpreter/OptionValueString.h"
#include "lldb/Interpreter/Options.h" #include "lldb/Interpreter/Options.h"
#include "lldb/Symbol/Symbol.h" #include "lldb/Symbol/Symbol.h"
#include "lldb/Target/Language.h" #include "lldb/Target/Language.h"
#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/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"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
class ScriptAddOptions { class ScriptAddOptions {
▲ Show 20 Lines • Show All 3,178 Lines • Show Last 20 Lines

lldb/trunk/source/Commands/CommandObjectWatchpoint.cpp

Show All 14 Lines
#include <vector> #include <vector>
// Other libraries and framework includes // Other libraries and framework includes
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
// 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"
#include "lldb/Interpreter/CommandCompletions.h" #include "lldb/Interpreter/CommandCompletions.h"
#include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Interpreter/CommandReturnObject.h" #include "lldb/Interpreter/CommandReturnObject.h"
#include "lldb/Symbol/Variable.h" #include "lldb/Symbol/Variable.h"
#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;
static void AddWatchpointDescription(Stream *s, Watchpoint *wp, static void AddWatchpointDescription(Stream *s, Watchpoint *wp,
lldb::DescriptionLevel level) { lldb::DescriptionLevel level) {
s->IndentMore(); s->IndentMore();
wp->GetDescription(s, level); wp->GetDescription(s, level);
▲ Show 20 Lines • Show All 1,193 Lines • Show Last 20 Lines

lldb/trunk/source/Core/AddressRange.cpp

//===-- AddressRange.cpp ----------------------------------------*- C++ -*-===// //===-- AddressRange.cpp ----------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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;
AddressRange::AddressRange() : m_base_addr(), m_byte_size(0) {} AddressRange::AddressRange() : m_base_addr(), m_byte_size(0) {}
AddressRange::AddressRange(addr_t file_addr, addr_t byte_size, AddressRange::AddressRange(addr_t file_addr, addr_t byte_size,
const SectionList *section_list) const SectionList *section_list)
▲ Show 20 Lines • Show All 160 Lines • Show Last 20 Lines

lldb/trunk/source/Core/AddressResolver.cpp

Show All 9 Lines
#include "lldb/Core/AddressResolver.h" #include "lldb/Core/AddressResolver.h"
// Project includes // Project includes
#include "lldb/Core/Address.h" #include "lldb/Core/Address.h"
#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;
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// AddressResolver: // AddressResolver:
//---------------------------------------------------------------------- //----------------------------------------------------------------------
AddressResolver::AddressResolver() {} AddressResolver::AddressResolver() {}
Show All 22 Lines

lldb/trunk/source/Core/AddressResolverFileLine.cpp

//===-- AddressResolverFileLine.cpp -----------------------------*- C++ -*-===// //===-- AddressResolverFileLine.cpp -----------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Core/AddressResolverFileLine.h" #include "lldb/Core/AddressResolverFileLine.h"
// 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;
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// AddressResolverFileLine: // AddressResolverFileLine:
//---------------------------------------------------------------------- //----------------------------------------------------------------------
AddressResolverFileLine::AddressResolverFileLine(const FileSpec &file_spec, AddressResolverFileLine::AddressResolverFileLine(const FileSpec &file_spec,
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

lldb/trunk/source/Core/AddressResolverName.cpp

Show All 9 Lines
#include "lldb/Core/AddressResolverName.h" #include "lldb/Core/AddressResolverName.h"
// C Includes // C Includes
// C++ Includes // C++ Includes
// 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/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;
AddressResolverName::AddressResolverName(const char *func_name, AddressResolverName::AddressResolverName(const char *func_name,
AddressResolver::MatchType type) AddressResolver::MatchType type)
: AddressResolver(), m_func_name(func_name), m_class_name(nullptr), : AddressResolver(), m_func_name(func_name), m_class_name(nullptr),
m_regex(), m_match_type(type) { m_regex(), m_match_type(type) {
▲ Show 20 Lines • Show All 163 Lines • Show Last 20 Lines

lldb/trunk/source/Core/ArchSpec.cpp

Show All 18 Lines
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#include "llvm/Support/COFF.h" #include "llvm/Support/COFF.h"
#include "llvm/Support/ELF.h" #include "llvm/Support/ELF.h"
#include "llvm/Support/Host.h" #include "llvm/Support/Host.h"
// 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"
#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"
#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;
using namespace lldb_private; using namespace lldb_private;
static bool cores_match(const ArchSpec::Core core1, const ArchSpec::Core core2, static bool cores_match(const ArchSpec::Core core1, const ArchSpec::Core core2,
bool try_inverse, bool enforce_exact_match); bool try_inverse, bool enforce_exact_match);
▲ Show 20 Lines • Show All 1,626 Lines • Show Last 20 Lines

lldb/trunk/source/Core/Baton.cpp

//===-- Baton.cpp -----------------------------------------------*- C++ -*-===// //===-- Baton.cpp -----------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Core/Baton.h" #include "lldb/Core/Baton.h"
// C Includes // C Includes
// 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;
void UntypedBaton::GetDescription(Stream *s, void UntypedBaton::GetDescription(Stream *s,
lldb::DescriptionLevel level) const {} lldb::DescriptionLevel level) const {}

lldb/trunk/source/Core/Broadcaster.cpp

Show All 10 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#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;
Broadcaster::Broadcaster(BroadcasterManagerSP manager_sp, const char *name) Broadcaster::Broadcaster(BroadcasterManagerSP manager_sp, const char *name)
: m_broadcaster_sp(new BroadcasterImpl(*this)), m_manager_sp(manager_sp), : m_broadcaster_sp(new BroadcasterImpl(*this)), m_manager_sp(manager_sp),
m_broadcaster_name(name) { m_broadcaster_name(name) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT)); Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
▲ Show 20 Lines • Show All 448 Lines • Show Last 20 Lines

lldb/trunk/source/Core/CMakeLists.txt

add_lldb_library(lldbCore add_lldb_library(lldbCore
Address.cpp Address.cpp
AddressRange.cpp AddressRange.cpp
AddressResolver.cpp AddressResolver.cpp
AddressResolverFileLine.cpp AddressResolverFileLine.cpp
AddressResolverName.cpp AddressResolverName.cpp
ArchSpec.cpp ArchSpec.cpp
Baton.cpp Baton.cpp
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
DataExtractor.cpp DataExtractor.cpp
Debugger.cpp Debugger.cpp
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
FileSpecList.cpp FileSpecList.cpp
FormatEntity.cpp FormatEntity.cpp
History.cpp History.cpp
IOHandler.cpp IOHandler.cpp
Listener.cpp Listener.cpp
Log.cpp Log.cpp
Logging.cpp Logging.cpp
Mangled.cpp Mangled.cpp
Module.cpp Module.cpp
ModuleChild.cpp ModuleChild.cpp
ModuleList.cpp ModuleList.cpp
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
UserID.cpp UserID.cpp
UserSettingsController.cpp UserSettingsController.cpp
UUID.cpp UUID.cpp
Value.cpp Value.cpp
ValueObject.cpp ValueObject.cpp
Show All 34 Lines

lldb/trunk/source/Core/ConstString.cpp

//===-- 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/trunk/source/Core/DataBufferMemoryMap.cpp

Show All 40 Lines
#include <cerrno> #include <cerrno>
#include <climits> #include <climits>
// Other libraries and framework includes // Other libraries and framework includes
#include "llvm/Support/MathExtras.h" #include "llvm/Support/MathExtras.h"
// 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;
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// Default Constructor // Default Constructor
//---------------------------------------------------------------------- //----------------------------------------------------------------------
DataBufferMemoryMap::DataBufferMemoryMap() DataBufferMemoryMap::DataBufferMemoryMap()
▲ Show 20 Lines • Show All 246 Lines • Show Last 20 Lines

lldb/trunk/source/Core/DataExtractor.cpp

Show All 26 Lines
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
// Project includes // Project includes
#include "lldb/Core/DataBuffer.h" #include "lldb/Core/DataBuffer.h"
#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/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"
#include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/ClangASTContext.h"
#include "lldb/Target/ExecutionContext.h" #include "lldb/Target/ExecutionContext.h"
#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;
static inline uint16_t ReadInt16(const unsigned char *ptr, offset_t offset) { static inline uint16_t ReadInt16(const unsigned char *ptr, offset_t offset) {
uint16_t value; uint16_t value;
memcpy(&value, ptr + offset, 2); memcpy(&value, ptr + offset, 2);
return value; return value;
▲ Show 20 Lines • Show All 2,091 Lines • Show Last 20 Lines

lldb/trunk/source/Core/Debugger.cpp

Show All 22 Lines
#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/RegisterValue.h" #include "lldb/Core/RegisterValue.h"
#include "lldb/Core/State.h" #include "lldb/Core/State.h"
#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"
#include "lldb/Core/ValueObjectVariable.h" #include "lldb/Core/ValueObjectVariable.h"
#include "lldb/DataFormatters/DataVisualization.h" #include "lldb/DataFormatters/DataVisualization.h"
#include "lldb/DataFormatters/FormatManager.h" #include "lldb/DataFormatters/FormatManager.h"
#include "lldb/DataFormatters/TypeSummary.h" #include "lldb/DataFormatters/TypeSummary.h"
#include "lldb/Expression/REPL.h" #include "lldb/Expression/REPL.h"
Show All 14 Lines
#include "lldb/Target/RegisterContext.h" #include "lldb/Target/RegisterContext.h"
#include "lldb/Target/SectionLoadList.h" #include "lldb/Target/SectionLoadList.h"
#include "lldb/Target/StopInfo.h" #include "lldb/Target/StopInfo.h"
#include "lldb/Target/StructuredDataPlugin.h" #include "lldb/Target/StructuredDataPlugin.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#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;
using namespace lldb_private; using namespace lldb_private;
static lldb::user_id_t g_unique_id = 1; static lldb::user_id_t g_unique_id = 1;
static size_t g_debugger_event_thread_stack_bytes = 8 * 1024 * 1024; static size_t g_debugger_event_thread_stack_bytes = 8 * 1024 * 1024;
▲ Show 20 Lines • Show All 1,652 Lines • Show Last 20 Lines

lldb/trunk/source/Core/Disassembler.cpp

Show All 14 Lines
#include <cstring> #include <cstring>
// 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/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"
#include "lldb/Interpreter/OptionValueArray.h" #include "lldb/Interpreter/OptionValueArray.h"
#include "lldb/Interpreter/OptionValueDictionary.h" #include "lldb/Interpreter/OptionValueDictionary.h"
#include "lldb/Interpreter/OptionValueRegex.h" #include "lldb/Interpreter/OptionValueRegex.h"
#include "lldb/Interpreter/OptionValueString.h" #include "lldb/Interpreter/OptionValueString.h"
#include "lldb/Interpreter/OptionValueUInt64.h" #include "lldb/Interpreter/OptionValueUInt64.h"
#include "lldb/Symbol/Function.h" #include "lldb/Symbol/Function.h"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
#include "lldb/Target/ExecutionContext.h" #include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#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
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
DisassemblerSP Disassembler::FindPlugin(const ArchSpec &arch, DisassemblerSP Disassembler::FindPlugin(const ArchSpec &arch,
▲ Show 20 Lines • Show All 1,401 Lines • Show Last 20 Lines

lldb/trunk/source/Core/EmulateInstruction.cpp

Show All 11 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
#include <cstring> #include <cstring>
// Other libraries and framework includes // Other libraries and framework includes
// 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;
EmulateInstruction * EmulateInstruction *
EmulateInstruction::FindPlugin(const ArchSpec &arch, EmulateInstruction::FindPlugin(const ArchSpec &arch,
InstructionType supported_inst_type, InstructionType supported_inst_type,
const char *plugin_name) { const char *plugin_name) {
▲ Show 20 Lines • Show All 546 Lines • Show Last 20 Lines

lldb/trunk/source/Core/Error.cpp

//===-- 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/trunk/source/Core/Event.cpp

Show All 12 Lines
// 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/DataExtractor.h" #include "lldb/Core/DataExtractor.h"
#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;
#pragma mark - #pragma mark -
#pragma mark Event #pragma mark Event
//------------------------------------------------------------------ //------------------------------------------------------------------
▲ Show 20 Lines • Show All 273 Lines • Show Last 20 Lines

lldb/trunk/source/Core/FileLineResolver.cpp

//===-- FileLineResolver.cpp ------------------------------------*- C++ -*-===// //===-- FileLineResolver.cpp ------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Core/FileLineResolver.h" #include "lldb/Core/FileLineResolver.h"
// 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;
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// FileLineResolver: // FileLineResolver:
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FileLineResolver::FileLineResolver(const FileSpec &file_spec, uint32_t line_no, FileLineResolver::FileLineResolver(const FileSpec &file_spec, uint32_t line_no,
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

lldb/trunk/source/Core/FileSpecList.cpp

Show All 9 Lines
#include "lldb/Core/FileSpecList.h" #include "lldb/Core/FileSpecList.h"
// C Includes // C Includes
// C++ Includes // C++ Includes
#include <algorithm> #include <algorithm>
// 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;
FileSpecList::FileSpecList() : m_files() {} FileSpecList::FileSpecList() : m_files() {}
FileSpecList::FileSpecList(const FileSpecList &rhs) = default; FileSpecList::FileSpecList(const FileSpecList &rhs) = default;
▲ Show 20 Lines • Show All 166 Lines • Show Last 20 Lines

lldb/trunk/source/Core/FormatEntity.cpp

Show All 13 Lines
// Other libraries and framework includes // Other libraries and framework includes
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
// Project includes // Project includes
#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"
#include "lldb/DataFormatters/FormatManager.h" #include "lldb/DataFormatters/FormatManager.h"
#include "lldb/DataFormatters/ValueObjectPrinter.h" #include "lldb/DataFormatters/ValueObjectPrinter.h"
#include "lldb/Expression/ExpressionVariable.h" #include "lldb/Expression/ExpressionVariable.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
#include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandInterpreter.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/Symbol/LineEntry.h" #include "lldb/Symbol/LineEntry.h"
#include "lldb/Symbol/Symbol.h" #include "lldb/Symbol/Symbol.h"
#include "lldb/Symbol/VariableList.h" #include "lldb/Symbol/VariableList.h"
#include "lldb/Target/ExecutionContext.h" #include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Language.h" #include "lldb/Target/Language.h"
#include "lldb/Target/Process.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/StackFrame.h" #include "lldb/Target/StackFrame.h"
#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/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;
enum FileKind { FileError = 0, Basename, Dirname, Fullpath }; enum FileKind { FileError = 0, Basename, Dirname, Fullpath };
#define ENTRY(n, t, f) \ #define ENTRY(n, t, f) \
{ \ { \
▲ Show 20 Lines • Show All 2,334 Lines • Show Last 20 Lines

lldb/trunk/source/Core/History.cpp

//===-- History.cpp ---------------------------------------------*- C++ -*-===// //===-- History.cpp ---------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Core/History.h" #include "lldb/Core/History.h"
// C Includes // C Includes
#include <inttypes.h> #include <inttypes.h>
// 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;
void HistorySourceUInt::DumpHistoryEvent(Stream &strm, HistoryEvent event) { void HistorySourceUInt::DumpHistoryEvent(Stream &strm, HistoryEvent event) {
strm.Printf("%s %" PRIu64, m_name.c_str(), (uint64_t)((uintptr_t)event)); strm.Printf("%s %" PRIu64, m_name.c_str(), (uint64_t)((uintptr_t)event));
} }

lldb/trunk/source/Core/Listener.cpp

Show All 12 Lines
// C++ Includes // C++ Includes
#include <algorithm> #include <algorithm>
// 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/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;
namespace { namespace {
class BroadcasterManagerWPMatcher { class BroadcasterManagerWPMatcher {
public: public:
BroadcasterManagerWPMatcher(BroadcasterManagerSP manager_sp) BroadcasterManagerWPMatcher(BroadcasterManagerSP manager_sp)
▲ Show 20 Lines • Show All 446 Lines • Show Last 20 Lines

lldb/trunk/source/Core/Log.cpp

//===-- Log.cpp -------------------------------------------------*- C++ -*-===// //===-- Log.cpp -------------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Project includes // Project includes
#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"
#include "llvm/Support/Chrono.h" #include "llvm/Support/Chrono.h"
#include "llvm/Support/Path.h" #include "llvm/Support/Path.h"
#include "llvm/Support/Signals.h" #include "llvm/Support/Signals.h"
#include "llvm/Support/raw_ostream.h" #include "llvm/Support/raw_ostream.h"
▲ Show 20 Lines • Show All 384 Lines • Show Last 20 Lines

lldb/trunk/source/Core/Mangled.cpp

Show All 22 Lines
#else #else
#include <cxxabi.h> #include <cxxabi.h>
#endif #endif
#include "llvm/ADT/DenseMap.h" #include "llvm/ADT/DenseMap.h"
#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>
using namespace lldb_private; using namespace lldb_private;
static inline Mangled::ManglingScheme cstring_mangling_scheme(const char *s) { static inline Mangled::ManglingScheme cstring_mangling_scheme(const char *s) {
if (s) { if (s) {
▲ Show 20 Lines • Show All 390 Lines • Show Last 20 Lines

lldb/trunk/source/Core/Module.cpp

Show All 15 Lines
#include "llvm/Support/raw_os_ostream.h" #include "llvm/Support/raw_os_ostream.h"
// Project includes // Project includes
#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/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"
#include "lldb/Host/Symbols.h" #include "lldb/Host/Symbols.h"
#include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Interpreter/ScriptInterpreter.h" #include "lldb/Interpreter/ScriptInterpreter.h"
#include "lldb/Symbol/CompileUnit.h" #include "lldb/Symbol/CompileUnit.h"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
#include "lldb/Symbol/SymbolContext.h" #include "lldb/Symbol/SymbolContext.h"
#include "lldb/Symbol/SymbolFile.h" #include "lldb/Symbol/SymbolFile.h"
#include "lldb/Symbol/SymbolVendor.h" #include "lldb/Symbol/SymbolVendor.h"
#include "lldb/Symbol/TypeMap.h" #include "lldb/Symbol/TypeMap.h"
#include "lldb/Symbol/TypeSystem.h" #include "lldb/Symbol/TypeSystem.h"
#include "lldb/Target/Language.h" #include "lldb/Target/Language.h"
#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"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
// Shared pointers to modules track module lifetimes in // Shared pointers to modules track module lifetimes in
// targets and in the global module, but this collection // targets and in the global module, but this collection
▲ Show 20 Lines • Show All 1,614 Lines • Show Last 20 Lines

lldb/trunk/source/Core/Opcode.cpp

Show All 12 Lines
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
#include "llvm/ADT/Triple.h" #include "llvm/ADT/Triple.h"
// Project includes // Project includes
#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;
int Opcode::Dump(Stream *s, uint32_t min_byte_width) { int Opcode::Dump(Stream *s, uint32_t min_byte_width) {
int bytes_written = 0; int bytes_written = 0;
switch (m_type) { switch (m_type) {
case Opcode::eTypeInvalid: case Opcode::eTypeInvalid:
▲ Show 20 Lines • Show All 112 Lines • Show Last 20 Lines

lldb/trunk/source/Core/PluginManager.cpp

Show All 16 Lines
#include <vector> #include <vector>
// Other libraries and framework includes // Other libraries and framework includes
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
#include "llvm/Support/DynamicLibrary.h" #include "llvm/Support/DynamicLibrary.h"
// 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;
enum PluginAction { enum PluginAction {
ePluginRegisterInstance, ePluginRegisterInstance,
ePluginUnregisterInstance, ePluginUnregisterInstance,
ePluginGetInstanceAtIndex ePluginGetInstanceAtIndex
▲ Show 20 Lines • Show All 2,601 Lines • Show Last 20 Lines

lldb/trunk/source/Core/RegisterValue.cpp

Show All 13 Lines
#include <vector> #include <vector>
// Other libraries and framework includes // Other libraries and framework includes
#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/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;
bool RegisterValue::Dump(Stream *s, const RegisterInfo *reg_info, bool RegisterValue::Dump(Stream *s, const RegisterInfo *reg_info,
bool prefix_with_name, bool prefix_with_alt_name, bool prefix_with_name, bool prefix_with_alt_name,
Format format, Format format,
uint32_t reg_name_right_align_at) const { uint32_t reg_name_right_align_at) const {
▲ Show 20 Lines • Show All 925 Lines • Show Last 20 Lines

lldb/trunk/source/Core/RegularExpression.cpp

//===-- 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/trunk/source/Core/Scalar.cpp

Show All 14 Lines
#include <cmath> #include <cmath>
#include <cstdio> #include <cstdio>
// Other libraries and framework includes // Other libraries and framework includes
#include "llvm/ADT/SmallString.h" #include "llvm/ADT/SmallString.h"
// 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"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// Promote to max type currently follows the ANSI C rule for type // Promote to max type currently follows the ANSI C rule for type
▲ Show 20 Lines • Show All 3,041 Lines • Show Last 20 Lines

lldb/trunk/source/Core/SourceManager.cpp

Show All 10 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#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;
static inline bool is_newline_char(char ch) { return ch == '\n' || ch == '\r'; } static inline bool is_newline_char(char ch) { return ch == '\n' || ch == '\r'; }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// SourceManager constructor // SourceManager constructor
▲ Show 20 Lines • Show All 663 Lines • Show Last 20 Lines

lldb/trunk/source/Core/Stream.cpp

//===-- 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/trunk/source/Core/StreamFile.cpp

//===-- StreamFile.cpp ------------------------------------------*- C++ -*-===// //===-- StreamFile.cpp ------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
// C Includes // C Includes
#include <stdio.h> #include <stdio.h>
// 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;
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// StreamFile constructor // StreamFile constructor
//---------------------------------------------------------------------- //----------------------------------------------------------------------
StreamFile::StreamFile() : Stream(), m_file() {} StreamFile::StreamFile() : Stream(), m_file() {}
Show All 27 Lines

lldb/trunk/source/Core/StreamString.cpp

//===-- 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/trunk/source/Core/StringList.cpp

//===-- StringList.cpp ------------------------------------------*- C++ -*-===// //===-- StringList.cpp ------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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>
using namespace lldb_private; using namespace lldb_private;
StringList::StringList() : m_strings() {} StringList::StringList() : m_strings() {}
StringList::StringList(const char *str) : m_strings() { StringList::StringList(const char *str) : m_strings() {
▲ Show 20 Lines • Show All 249 Lines • Show Last 20 Lines

lldb/trunk/source/Core/StructuredData.cpp

//===---------------------StructuredData.cpp ---------------------*- C++-*-===// //===---------------------StructuredData.cpp ---------------------*- C++-*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Core/StructuredData.h" #include "lldb/Core/StructuredData.h"
#include <errno.h> #include <errno.h>
#include <inttypes.h> #include <inttypes.h>
#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;
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// Functions that use a JSONParser to parse JSON into StructuredData // Functions that use a JSONParser to parse JSON into StructuredData
//---------------------------------------------------------------------- //----------------------------------------------------------------------
static StructuredData::ObjectSP ParseJSONValue(JSONParser &json_parser); static StructuredData::ObjectSP ParseJSONValue(JSONParser &json_parser);
static StructuredData::ObjectSP ParseJSONObject(JSONParser &json_parser); static StructuredData::ObjectSP ParseJSONObject(JSONParser &json_parser);
▲ Show 20 Lines • Show All 277 Lines • Show Last 20 Lines

lldb/trunk/source/Core/Timer.cpp

//===-- Timer.cpp -----------------------------------------------*- C++ -*-===// //===-- Timer.cpp -----------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Core/Timer.h" #include "lldb/Core/Timer.h"
#include <algorithm> #include <algorithm>
#include <map> #include <map>
#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>
using namespace lldb_private; using namespace lldb_private;
#define TIMER_INDENT_AMOUNT 2 #define TIMER_INDENT_AMOUNT 2
namespace { namespace {
▲ Show 20 Lines • Show All 129 Lines • Show Last 20 Lines

lldb/trunk/source/Core/UUID.cpp

Show All 12 Lines
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
// C++ Includes // C++ Includes
#include <string> #include <string>
// 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 {
UUID::UUID() : m_num_uuid_bytes(16) { ::memset(m_uuid, 0, sizeof(m_uuid)); } UUID::UUID() : m_num_uuid_bytes(16) { ::memset(m_uuid, 0, sizeof(m_uuid)); }
UUID::UUID(const UUID &rhs) { UUID::UUID(const UUID &rhs) {
m_num_uuid_bytes = rhs.m_num_uuid_bytes; m_num_uuid_bytes = rhs.m_num_uuid_bytes;
::memcpy(m_uuid, rhs.m_uuid, sizeof(m_uuid)); ::memcpy(m_uuid, rhs.m_uuid, sizeof(m_uuid));
▲ Show 20 Lines • Show All 195 Lines • Show Last 20 Lines

lldb/trunk/source/Core/UserID.cpp

//===-- UserID.cpp ----------------------------------------------*- C++ -*-===// //===-- UserID.cpp ----------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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>
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Stream &lldb_private::operator<<(Stream &strm, const UserID &uid) { Stream &lldb_private::operator<<(Stream &strm, const UserID &uid) {
strm.Printf("{0x%8.8" PRIx64 "}", uid.GetID()); strm.Printf("{0x%8.8" PRIx64 "}", uid.GetID());
return strm; return strm;
} }

lldb/trunk/source/Core/UserSettingsController.cpp

//====-- UserSettingsController.cpp ------------------------------*- C++ //====-- UserSettingsController.cpp ------------------------------*- C++
//-*-===// //-*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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;
lldb::OptionValueSP lldb::OptionValueSP
Properties::GetPropertyValue(const ExecutionContext *exe_ctx, llvm::StringRef path, Properties::GetPropertyValue(const ExecutionContext *exe_ctx, llvm::StringRef path,
bool will_modify, Error &error) const { bool will_modify, Error &error) const {
OptionValuePropertiesSP properties_sp(GetValueProperties()); OptionValuePropertiesSP properties_sp(GetValueProperties());
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

lldb/trunk/source/Core/VMRange.cpp

//===-- VMRange.cpp ---------------------------------------------*- C++ -*-===// //===-- VMRange.cpp ---------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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;
using namespace lldb_private; using namespace lldb_private;
bool VMRange::ContainsValue(const VMRange::collection &coll, bool VMRange::ContainsValue(const VMRange::collection &coll,
lldb::addr_t value) { lldb::addr_t value) {
ValueInRangeUnaryPredicate in_range_predicate(value); ValueInRangeUnaryPredicate in_range_predicate(value);
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

lldb/trunk/source/Core/Value.cpp

Show All 11 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
// 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/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"
#include "lldb/Symbol/SymbolContext.h" #include "lldb/Symbol/SymbolContext.h"
#include "lldb/Symbol/Type.h" #include "lldb/Symbol/Type.h"
#include "lldb/Symbol/Variable.h" #include "lldb/Symbol/Variable.h"
#include "lldb/Target/ExecutionContext.h" #include "lldb/Target/ExecutionContext.h"
#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;
Value::Value() Value::Value()
: m_value(), m_vector(), m_compiler_type(), m_context(NULL), : m_value(), m_vector(), m_compiler_type(), m_context(NULL),
m_value_type(eValueTypeScalar), m_context_type(eContextTypeInvalid), m_value_type(eValueTypeScalar), m_context_type(eContextTypeInvalid),
m_data_buffer() {} m_data_buffer() {}
▲ Show 20 Lines • Show All 668 Lines • Show Last 20 Lines

lldb/trunk/source/Core/ValueObject.cpp

Show All 15 Lines
// Other libraries and framework includes // Other libraries and framework includes
#include "llvm/Support/raw_ostream.h" #include "llvm/Support/raw_ostream.h"
// 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/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"
#include "lldb/Core/ValueObjectDynamicValue.h" #include "lldb/Core/ValueObjectDynamicValue.h"
#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"
#include "lldb/DataFormatters/ValueObjectPrinter.h" #include "lldb/DataFormatters/ValueObjectPrinter.h"
#include "Plugins/ExpressionParser/Clang/ClangExpressionVariable.h" #include "Plugins/ExpressionParser/Clang/ClangExpressionVariable.h"
#include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h" #include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h"
▲ Show 20 Lines • Show All 3,410 Lines • Show Last 20 Lines

lldb/trunk/source/DataFormatters/CXXFunctionPointer.cpp

//===-- CXXFunctionPointer.cpp-----------------------------------*- C++ -*-===// //===-- CXXFunctionPointer.cpp-----------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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>
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
using namespace lldb_private::formatters; using namespace lldb_private::formatters;
bool lldb_private::formatters::CXXFunctionPointerSummaryProvider( bool lldb_private::formatters::CXXFunctionPointerSummaryProvider(
Show All 34 Lines

lldb/trunk/source/DataFormatters/FormattersHelpers.cpp

Show All 11 Lines
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// 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;
using namespace lldb_private::formatters; using namespace lldb_private::formatters;
void lldb_private::formatters::AddFormat( void lldb_private::formatters::AddFormat(
TypeCategoryImpl::SharedPointer category_sp, lldb::Format format, TypeCategoryImpl::SharedPointer category_sp, lldb::Format format,
ConstString type_name, TypeFormatImpl::Flags flags, bool regex) { ConstString type_name, TypeFormatImpl::Flags flags, bool regex) {
▲ Show 20 Lines • Show All 120 Lines • Show Last 20 Lines

lldb/trunk/source/DataFormatters/StringPrinter.cpp

//===-- StringPrinter.cpp ----------------------------------------*- C++ //===-- StringPrinter.cpp ----------------------------------------*- C++
//-*-===// //-*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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"
#include <ctype.h> #include <ctype.h>
#include <locale> #include <locale>
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
▲ Show 20 Lines • Show All 626 Lines • Show Last 20 Lines

lldb/trunk/source/DataFormatters/TypeFormat.cpp

Show All 13 Lines
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#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;
TypeFormatImpl::TypeFormatImpl(const Flags &flags) TypeFormatImpl::TypeFormatImpl(const Flags &flags)
: m_flags(flags), m_my_revision(0) {} : m_flags(flags), m_my_revision(0) {}
TypeFormatImpl::~TypeFormatImpl() {} TypeFormatImpl::~TypeFormatImpl() {}
▲ Show 20 Lines • Show All 171 Lines • Show Last 20 Lines

lldb/trunk/source/DataFormatters/TypeSummary.cpp

Show All 14 Lines
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/lldb-enumerations.h" #include "lldb/lldb-enumerations.h"
#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;
TypeSummaryOptions::TypeSummaryOptions() TypeSummaryOptions::TypeSummaryOptions()
: m_lang(eLanguageTypeUnknown), m_capping(eTypeSummaryCapped) {} : m_lang(eLanguageTypeUnknown), m_capping(eTypeSummaryCapped) {}
TypeSummaryOptions::TypeSummaryOptions(const TypeSummaryOptions &rhs) TypeSummaryOptions::TypeSummaryOptions(const TypeSummaryOptions &rhs)
▲ Show 20 Lines • Show All 179 Lines • Show Last 20 Lines

lldb/trunk/source/DataFormatters/TypeSynthetic.cpp

Show All 13 Lines
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/lldb-enumerations.h" #include "lldb/lldb-enumerations.h"
#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;
void TypeFilterImpl::AddExpressionPath(const std::string &path) { void TypeFilterImpl::AddExpressionPath(const std::string &path) {
bool need_add_dot = true; bool need_add_dot = true;
if (path[0] == '.' || (path[0] == '-' && path[1] == '>') || path[0] == '[') if (path[0] == '.' || (path[0] == '-' && path[1] == '>') || path[0] == '[')
need_add_dot = false; need_add_dot = false;
▲ Show 20 Lines • Show All 192 Lines • Show Last 20 Lines

lldb/trunk/source/DataFormatters/TypeValidator.cpp

Show All 9 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// 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;
TypeValidatorImpl::TypeValidatorImpl(const Flags &flags) TypeValidatorImpl::TypeValidatorImpl(const Flags &flags)
: m_flags(flags), m_my_revision(0) {} : m_flags(flags), m_my_revision(0) {}
TypeValidatorImpl::~TypeValidatorImpl() {} TypeValidatorImpl::~TypeValidatorImpl() {}
Show All 32 Lines

lldb/trunk/source/DataFormatters/ValueObjectPrinter.cpp

//===-- ValueObjectPrinter.cpp -----------------------------------*- C++-*-===// //===-- ValueObjectPrinter.cpp -----------------------------------*- C++-*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/DataFormatters/ValueObjectPrinter.h" #include "lldb/DataFormatters/ValueObjectPrinter.h"
// C Includes // C Includes
// 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;
ValueObjectPrinter::ValueObjectPrinter(ValueObject *valobj, Stream *s) { ValueObjectPrinter::ValueObjectPrinter(ValueObject *valobj, Stream *s) {
if (valobj) { if (valobj) {
DumpValueObjectOptions options(*valobj); DumpValueObjectOptions options(*valobj);
Init(valobj, s, options, m_options.m_max_ptr_depth, 0, nullptr); Init(valobj, s, options, m_options.m_max_ptr_depth, 0, nullptr);
▲ Show 20 Lines • Show All 826 Lines • Show Last 20 Lines

lldb/trunk/source/Expression/DWARFExpression.cpp

Show All 13 Lines
// C++ Includes // C++ Includes
#include <vector> #include <vector>
#include "lldb/Core/DataEncoder.h" #include "lldb/Core/DataEncoder.h"
#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"
#include "lldb/Host/Endian.h" #include "lldb/Host/Endian.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Symbol/Function.h" #include "lldb/Symbol/Function.h"
▲ Show 20 Lines • Show All 3,361 Lines • Show Last 20 Lines

lldb/trunk/source/Expression/DiagnosticManager.cpp

//===-- DiagnosticManager.cpp -----------------------------------*- C++ -*-===// //===-- DiagnosticManager.cpp -----------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Expression/DiagnosticManager.h" #include "lldb/Expression/DiagnosticManager.h"
#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;
void DiagnosticManager::Dump(Log *log) { void DiagnosticManager::Dump(Log *log) {
if (!log) if (!log)
return; return;
std::string str = GetString(); std::string str = GetString();
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

lldb/trunk/source/Expression/ExpressionSourceCode.cpp

//===-- ExpressionSourceCode.cpp --------------------------------*- C++ -*-===// //===-- ExpressionSourceCode.cpp --------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Expression/ExpressionSourceCode.h" #include "lldb/Expression/ExpressionSourceCode.h"
#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"
#include "lldb/Symbol/TypeSystem.h" #include "lldb/Symbol/TypeSystem.h"
#include "lldb/Symbol/VariableList.h" #include "lldb/Symbol/VariableList.h"
#include "lldb/Target/ExecutionContext.h" #include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Language.h" #include "lldb/Target/Language.h"
#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;
const char *ExpressionSourceCode::g_expression_prefix = R"( const char *ExpressionSourceCode::g_expression_prefix = R"(
#ifndef NULL #ifndef NULL
#define NULL (__null) #define NULL (__null)
#endif #endif
#ifndef Nil #ifndef Nil
▲ Show 20 Lines • Show All 352 Lines • Show Last 20 Lines

lldb/trunk/source/Expression/IRDynamicChecks.cpp

Show All 15 Lines
#include "llvm/IR/Instructions.h" #include "llvm/IR/Instructions.h"
#include "llvm/IR/Module.h" #include "llvm/IR/Module.h"
#include "llvm/IR/Value.h" #include "llvm/IR/Value.h"
#include "llvm/Support/raw_ostream.h" #include "llvm/Support/raw_ostream.h"
// 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"
#include "lldb/Target/ObjCLanguageRuntime.h" #include "lldb/Target/ObjCLanguageRuntime.h"
#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;
static char ID; static char ID;
#define VALID_POINTER_CHECK_NAME "_$__lldb_valid_pointer_check" #define VALID_POINTER_CHECK_NAME "_$__lldb_valid_pointer_check"
#define VALID_OBJC_OBJECT_CHECK_NAME "$__lldb_objc_object_check" #define VALID_OBJC_OBJECT_CHECK_NAME "$__lldb_objc_object_check"
▲ Show 20 Lines • Show All 573 Lines • Show Last 20 Lines

lldb/trunk/source/Expression/IRInterpreter.cpp

//===-- IRInterpreter.cpp ---------------------------------------*- C++ -*-===// //===-- IRInterpreter.cpp ---------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Target/ThreadPlan.h" #include "lldb/Target/ThreadPlan.h"
#include "lldb/Target/ThreadPlanCallFunctionUsingABI.h" #include "lldb/Target/ThreadPlanCallFunctionUsingABI.h"
▲ Show 20 Lines • Show All 1,674 Lines • Show Last 20 Lines

lldb/trunk/source/Expression/IRMemoryMap.cpp

//===-- IRMemoryMap.cpp -----------------------------------------*- C++ -*-===// //===-- IRMemoryMap.cpp -----------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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;
IRMemoryMap::IRMemoryMap(lldb::TargetSP target_sp) : m_target_wp(target_sp) { IRMemoryMap::IRMemoryMap(lldb::TargetSP target_sp) : m_target_wp(target_sp) {
if (target_sp) if (target_sp)
m_process_wp = target_sp->GetProcessSP(); m_process_wp = target_sp->GetProcessSP();
} }
▲ Show 20 Lines • Show All 818 Lines • Show Last 20 Lines

lldb/trunk/source/Expression/LLVMUserExpression.cpp

//===-- LLVMUserExpression.cpp ----------------------------------*- C++ -*-===// //===-- LLVMUserExpression.cpp ----------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// C Includes // C Includes
// C++ Includes // C++ Includes
// 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"
#include "lldb/Expression/IRExecutionUnit.h" #include "lldb/Expression/IRExecutionUnit.h"
#include "lldb/Expression/IRInterpreter.h" #include "lldb/Expression/IRInterpreter.h"
#include "lldb/Expression/Materializer.h" #include "lldb/Expression/Materializer.h"
#include "lldb/Host/HostInfo.h" #include "lldb/Host/HostInfo.h"
#include "lldb/Symbol/Block.h" #include "lldb/Symbol/Block.h"
#include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/ClangASTContext.h"
#include "lldb/Symbol/ClangExternalASTSourceCommon.h" #include "lldb/Symbol/ClangExternalASTSourceCommon.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/Type.h" #include "lldb/Symbol/Type.h"
#include "lldb/Symbol/VariableList.h" #include "lldb/Symbol/VariableList.h"
#include "lldb/Target/ExecutionContext.h" #include "lldb/Target/ExecutionContext.h"
#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/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;
LLVMUserExpression::LLVMUserExpression(ExecutionContextScope &exe_scope, LLVMUserExpression::LLVMUserExpression(ExecutionContextScope &exe_scope,
llvm::StringRef expr, llvm::StringRef expr,
llvm::StringRef prefix, llvm::StringRef prefix,
lldb::LanguageType language, lldb::LanguageType language,
ResultType desired_type, ResultType desired_type,
▲ Show 20 Lines • Show All 328 Lines • Show Last 20 Lines

lldb/trunk/source/Expression/UserExpression.cpp

Show All 11 Lines
#include <sys/types.h> #include <sys/types.h>
#endif #endif
#include <cstdlib> #include <cstdlib>
#include <map> #include <map>
#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"
#include "lldb/Expression/IRExecutionUnit.h" #include "lldb/Expression/IRExecutionUnit.h"
#include "lldb/Expression/IRInterpreter.h" #include "lldb/Expression/IRInterpreter.h"
#include "lldb/Expression/Materializer.h" #include "lldb/Expression/Materializer.h"
#include "lldb/Expression/UserExpression.h" #include "lldb/Expression/UserExpression.h"
#include "lldb/Host/HostInfo.h" #include "lldb/Host/HostInfo.h"
#include "lldb/Symbol/Block.h" #include "lldb/Symbol/Block.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/Type.h" #include "lldb/Symbol/Type.h"
#include "lldb/Symbol/TypeSystem.h" #include "lldb/Symbol/TypeSystem.h"
#include "lldb/Symbol/VariableList.h" #include "lldb/Symbol/VariableList.h"
#include "lldb/Target/ExecutionContext.h" #include "lldb/Target/ExecutionContext.h"
#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/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;
UserExpression::UserExpression(ExecutionContextScope &exe_scope, UserExpression::UserExpression(ExecutionContextScope &exe_scope,
llvm::StringRef expr, llvm::StringRef prefix, llvm::StringRef expr, llvm::StringRef prefix,
lldb::LanguageType language, lldb::LanguageType language,
ResultType desired_type, ResultType desired_type,
const EvaluateExpressionOptions &options) const EvaluateExpressionOptions &options)
▲ Show 20 Lines • Show All 335 Lines • Show Last 20 Lines

lldb/trunk/source/Expression/UtilityFunction.cpp

Show All 9 Lines
// C Includes // C Includes
#include <stdio.h> #include <stdio.h>
#if HAVE_SYS_TYPES_H #if HAVE_SYS_TYPES_H
#include <sys/types.h> #include <sys/types.h>
#endif #endif
// 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"
#include "lldb/Expression/FunctionCaller.h" #include "lldb/Expression/FunctionCaller.h"
#include "lldb/Expression/IRExecutionUnit.h" #include "lldb/Expression/IRExecutionUnit.h"
#include "lldb/Expression/UtilityFunction.h" #include "lldb/Expression/UtilityFunction.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.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/Utility/ConstString.h"
#include "lldb/Utility/Stream.h"
using namespace lldb_private; using namespace lldb_private;
using namespace lldb; using namespace lldb;
//------------------------------------------------------------------ //------------------------------------------------------------------
/// Constructor /// Constructor
/// ///
/// @param[in] text /// @param[in] text
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

lldb/trunk/source/Host/common/Editline.cpp

//===-- Editline.cpp --------------------------------------------*- C++ -*-===// //===-- Editline.cpp --------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include <iomanip> #include <iomanip>
#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;
// Workaround for what looks like an OS X-specific issue, but other platforms // Workaround for what looks like an OS X-specific issue, but other platforms
// may benefit from something similar if issues arise. The libedit library // may benefit from something similar if issues arise. The libedit library
// doesn't explicitly initialize the curses termcap library, which it gets away // doesn't explicitly initialize the curses termcap library, which it gets away
// with until TERM is set to VT100 where it stumbles over an implementation // with until TERM is set to VT100 where it stumbles over an implementation
▲ Show 20 Lines • Show All 1,365 Lines • Show Last 20 Lines

lldb/trunk/source/Host/common/File.cpp

Show All 20 Lines
#include <sys/ioctl.h> #include <sys/ioctl.h>
#include <termios.h> #include <termios.h>
#endif #endif
#include "llvm/Support/ConvertUTF.h" #include "llvm/Support/ConvertUTF.h"
#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;
static const char *GetStreamOpenModeFromOptions(uint32_t options) { static const char *GetStreamOpenModeFromOptions(uint32_t options) {
if (options & File::eOpenOptionAppend) { if (options & File::eOpenOptionAppend) {
if (options & File::eOpenOptionRead) { if (options & File::eOpenOptionRead) {
if (options & File::eOpenOptionCanCreateNewOnly) if (options & File::eOpenOptionCanCreateNewOnly)
▲ Show 20 Lines • Show All 822 Lines • Show Last 20 Lines

lldb/trunk/source/Host/common/FileSpec.cpp

Show All 22 Lines
#include "lldb/Host/Config.h" // Have to include this before we test the define... #include "lldb/Host/Config.h" // Have to include this before we test the define...
#ifdef LLDB_CONFIG_TILDE_RESOLVES_TO_USER #ifdef LLDB_CONFIG_TILDE_RESOLVES_TO_USER
#include <pwd.h> #include <pwd.h>
#endif #endif
#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"
#include "llvm/Support/ConvertUTF.h" #include "llvm/Support/ConvertUTF.h"
#include "llvm/Support/FileSystem.h" #include "llvm/Support/FileSystem.h"
#include "llvm/Support/Path.h" #include "llvm/Support/Path.h"
#include "llvm/Support/Program.h" #include "llvm/Support/Program.h"
▲ Show 20 Lines • Show All 1,383 Lines • Show Last 20 Lines

lldb/trunk/source/Host/common/Host.cpp

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Lines
#endif #endif
// C++ Includes // C++ Includes
// 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/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"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Host/HostInfo.h" #include "lldb/Host/HostInfo.h"
#include "lldb/Host/HostProcess.h" #include "lldb/Host/HostProcess.h"
#include "lldb/Host/MonitoringProcessLauncher.h" #include "lldb/Host/MonitoringProcessLauncher.h"
#include "lldb/Host/Predicate.h" #include "lldb/Host/Predicate.h"
#include "lldb/Host/ProcessLauncher.h" #include "lldb/Host/ProcessLauncher.h"
#include "lldb/Host/ThreadLauncher.h" #include "lldb/Host/ThreadLauncher.h"
#include "lldb/Target/FileAction.h" #include "lldb/Target/FileAction.h"
#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"
#if defined(_WIN32) #if defined(_WIN32)
#include "lldb/Host/windows/ProcessLauncherWindows.h" #include "lldb/Host/windows/ProcessLauncherWindows.h"
#elif defined(__linux__) || defined(__NetBSD__) #elif defined(__linux__) || defined(__NetBSD__)
#include "lldb/Host/posix/ProcessLauncherPosixFork.h" #include "lldb/Host/posix/ProcessLauncherPosixFork.h"
▲ Show 20 Lines • Show All 939 Lines • Show Last 20 Lines

lldb/trunk/source/Host/common/HostInfoBase.cpp

//===-- HostInfoBase.cpp ----------------------------------------*- C++ -*-===// //===-- HostInfoBase.cpp ----------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Host/Config.h" #include "lldb/Host/Config.h"
#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"
#include "llvm/Support/Host.h" #include "llvm/Support/Host.h"
#include "llvm/Support/Path.h" #include "llvm/Support/Path.h"
#include "llvm/Support/ScopedPrinter.h" #include "llvm/Support/ScopedPrinter.h"
#include "llvm/Support/raw_ostream.h" #include "llvm/Support/raw_ostream.h"
▲ Show 20 Lines • Show All 369 Lines • Show Last 20 Lines

lldb/trunk/source/Host/common/MonitoringProcessLauncher.cpp

//===-- MonitoringProcessLauncher.cpp ---------------------------*- C++ -*-===// //===-- MonitoringProcessLauncher.cpp ---------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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"
#include "lldb/Host/HostProcess.h" #include "lldb/Host/HostProcess.h"
#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;
MonitoringProcessLauncher::MonitoringProcessLauncher( MonitoringProcessLauncher::MonitoringProcessLauncher(
std::unique_ptr<ProcessLauncher> delegate_launcher) std::unique_ptr<ProcessLauncher> delegate_launcher)
: m_delegate_launcher(std::move(delegate_launcher)) {} : m_delegate_launcher(std::move(delegate_launcher)) {}
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

lldb/trunk/source/Host/common/NativeBreakpoint.cpp

//===-- NativeBreakpoint.cpp ------------------------------------*- C++ -*-===// //===-- NativeBreakpoint.cpp ------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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;
NativeBreakpoint::NativeBreakpoint(lldb::addr_t addr) NativeBreakpoint::NativeBreakpoint(lldb::addr_t addr)
: m_addr(addr), m_ref_count(1), m_enabled(true) { : m_addr(addr), m_ref_count(1), m_enabled(true) {
assert(addr != LLDB_INVALID_ADDRESS && "breakpoint set for invalid address"); assert(addr != LLDB_INVALID_ADDRESS && "breakpoint set for invalid address");
} }
▲ Show 20 Lines • Show All 88 Lines • Show Last 20 Lines

lldb/trunk/source/Host/common/Socket.cpp

//===-- Socket.cpp ----------------------------------------------*- C++ -*-===// //===-- Socket.cpp ----------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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"
#include <arpa/inet.h> #include <arpa/inet.h>
#include <netdb.h> #include <netdb.h>
#include <netinet/in.h> #include <netinet/in.h>
#include <netinet/tcp.h> #include <netinet/tcp.h>
▲ Show 20 Lines • Show All 430 Lines • Show Last 20 Lines

lldb/trunk/source/Host/common/SoftwareBreakpoint.cpp

//===-- SoftwareBreakpoint.cpp ----------------------------------*- C++ -*-===// //===-- SoftwareBreakpoint.cpp ----------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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"
using namespace lldb_private; using namespace lldb_private;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
// static members // static members
// ------------------------------------------------------------------- // -------------------------------------------------------------------
▲ Show 20 Lines • Show All 330 Lines • Show Last 20 Lines

lldb/trunk/source/Host/common/Symbols.cpp

//===-- Symbols.cpp ---------------------------------------------*- C++ -*-===// //===-- Symbols.cpp ---------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Host/Symbols.h" #include "lldb/Host/Symbols.h"
#include "lldb/Core/ArchSpec.h" #include "lldb/Core/ArchSpec.h"
#include "lldb/Core/DataBuffer.h" #include "lldb/Core/DataBuffer.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/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"
// From MacOSX system header "mach/machine.h" // From MacOSX system header "mach/machine.h"
typedef int cpu_type_t; typedef int cpu_type_t;
typedef int cpu_subtype_t; typedef int cpu_subtype_t;
using namespace lldb; using namespace lldb;
▲ Show 20 Lines • Show All 262 Lines • Show Last 20 Lines

lldb/trunk/source/Host/common/ThisThread.cpp

//===-- ThisThread.cpp ------------------------------------------*- C++ -*-===// //===-- ThisThread.cpp ------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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"
#include <algorithm> #include <algorithm>
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Show All 30 Lines

lldb/trunk/source/Host/freebsd/Host.cpp

Show All 21 Lines
#include <dlfcn.h> #include <dlfcn.h>
#include <execinfo.h> #include <execinfo.h>
#include <stdio.h> #include <stdio.h>
// C++ Includes // C++ Includes
// 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"
#include "lldb/Utility/CleanUp.h" #include "lldb/Utility/CleanUp.h"
#include "lldb/Utility/NameMatches.h" #include "lldb/Utility/NameMatches.h"
#include "llvm/Support/Host.h" #include "llvm/Support/Host.h"
▲ Show 20 Lines • Show All 218 Lines • Show Last 20 Lines

lldb/trunk/source/Host/linux/Host.cpp

Show All 15 Lines
#include <sys/stat.h> #include <sys/stat.h>
#include <sys/types.h> #include <sys/types.h>
#include <sys/utsname.h> #include <sys/utsname.h>
// C++ Includes // C++ Includes
// 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"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Host/HostInfo.h" #include "lldb/Host/HostInfo.h"
#include "Plugins/Process/Linux/ProcFileReader.h" #include "Plugins/Process/Linux/ProcFileReader.h"
#include "lldb/Core/ModuleSpec.h" #include "lldb/Core/ModuleSpec.h"
▲ Show 20 Lines • Show All 343 Lines • Show Last 20 Lines

lldb/trunk/source/Host/macosx/Symbols.cpp

Show All 23 Lines
#include "Host/macosx/cfcpp/CFCReleaser.h" #include "Host/macosx/cfcpp/CFCReleaser.h"
#include "Host/macosx/cfcpp/CFCString.h" #include "Host/macosx/cfcpp/CFCString.h"
#include "lldb/Core/ArchSpec.h" #include "lldb/Core/ArchSpec.h"
#include "lldb/Core/DataBuffer.h" #include "lldb/Core/DataBuffer.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/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;
using namespace lldb_private; using namespace lldb_private;
using namespace llvm::MachO; using namespace llvm::MachO;
#if !defined(__arm__) && !defined(__arm64__) && \ #if !defined(__arm__) && !defined(__arm64__) && \
!defined(__aarch64__) // No DebugSymbols on the iOS devices !defined(__aarch64__) // No DebugSymbols on the iOS devices
▲ Show 20 Lines • Show All 550 Lines • Show Last 20 Lines

lldb/trunk/source/Host/netbsd/Host.cpp

Show All 22 Lines
#include <kvm.h> #include <kvm.h>
#include <sys/exec.h> #include <sys/exec.h>
#include <sys/ptrace.h> #include <sys/ptrace.h>
// C++ Includes // C++ Includes
// 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"
#include "lldb/Utility/CleanUp.h" #include "lldb/Utility/CleanUp.h"
#include "lldb/Utility/NameMatches.h" #include "lldb/Utility/NameMatches.h"
#include "llvm/Support/Host.h" #include "llvm/Support/Host.h"
▲ Show 20 Lines • Show All 220 Lines • Show Last 20 Lines

lldb/trunk/source/Host/posix/ConnectionFileDescriptorPosix.cpp

Show All 38 Lines
// Other libraries and framework includes // Other libraries and framework includes
#include "llvm/Support/ErrorHandling.h" #include "llvm/Support/ErrorHandling.h"
#if defined(__APPLE__) #if defined(__APPLE__)
#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/SmallVector.h"
#endif #endif
// 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;
const char *ConnectionFileDescriptor::LISTEN_SCHEME = "listen"; const char *ConnectionFileDescriptor::LISTEN_SCHEME = "listen";
const char *ConnectionFileDescriptor::ACCEPT_SCHEME = "accept"; const char *ConnectionFileDescriptor::ACCEPT_SCHEME = "accept";
const char *ConnectionFileDescriptor::UNIX_ACCEPT_SCHEME = "unix-accept"; const char *ConnectionFileDescriptor::UNIX_ACCEPT_SCHEME = "unix-accept";
const char *ConnectionFileDescriptor::CONNECT_SCHEME = "connect"; const char *ConnectionFileDescriptor::CONNECT_SCHEME = "connect";
▲ Show 20 Lines • Show All 740 Lines • Show Last 20 Lines

lldb/trunk/source/Host/posix/FileSystem.cpp

Show All 19 Lines
#include <sys/mount.h> #include <sys/mount.h>
#include <sys/statfs.h> #include <sys/statfs.h>
#endif #endif
#if defined(__NetBSD__) #if defined(__NetBSD__)
#include <sys/statvfs.h> #include <sys/statvfs.h>
#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;
const char *FileSystem::DEV_NULL = "/dev/null"; const char *FileSystem::DEV_NULL = "/dev/null";
FileSpec::PathSyntax FileSystem::GetNativePathSyntax() { FileSpec::PathSyntax FileSystem::GetNativePathSyntax() {
return FileSpec::ePathSyntaxPosix; return FileSpec::ePathSyntaxPosix;
▲ Show 20 Lines • Show All 224 Lines • Show Last 20 Lines

lldb/trunk/source/Host/posix/HostThreadPosix.cpp

//===-- HostThreadPosix.cpp -------------------------------------*- C++ -*-===// //===-- HostThreadPosix.cpp -------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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>
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
HostThreadPosix::HostThreadPosix() {} HostThreadPosix::HostThreadPosix() {}
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

lldb/trunk/source/Host/posix/MainLoopPosix.cpp

//===-- MainLoopPosix.cpp ---------------------------------------*- C++ -*-===// //===-- MainLoopPosix.cpp ---------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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;
static sig_atomic_t g_signal_flags[NSIG]; static sig_atomic_t g_signal_flags[NSIG];
static void SignalHandler(int signo, siginfo_t *info, void *) { static void SignalHandler(int signo, siginfo_t *info, void *) {
assert(signo < NSIG); assert(signo < NSIG);
▲ Show 20 Lines • Show All 157 Lines • Show Last 20 Lines

lldb/trunk/source/Host/windows/ConnectionGenericFileWindows.cpp

//===-- ConnectionGenericFileWindows.cpp ------------------------*- C++ -*-===// //===-- ConnectionGenericFileWindows.cpp ------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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"
#include "llvm/Support/ConvertUTF.h" #include "llvm/Support/ConvertUTF.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
▲ Show 20 Lines • Show All 310 Lines • Show Last 20 Lines

lldb/trunk/source/Host/windows/Host.cpp

Show All 9 Lines
// C Includes // C Includes
#include "lldb/Host/windows/AutoHandle.h" #include "lldb/Host/windows/AutoHandle.h"
#include "lldb/Host/windows/windows.h" #include "lldb/Host/windows/windows.h"
#include <stdio.h> #include <stdio.h>
// 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"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Core/StructuredData.h" #include "lldb/Core/StructuredData.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Host/HostInfo.h" #include "lldb/Host/HostInfo.h"
▲ Show 20 Lines • Show All 276 Lines • Show Last 20 Lines

lldb/trunk/source/Host/windows/HostThreadWindows.cpp

//===-- HostThreadWindows.cpp -----------------------------------*- C++ -*-===// //===-- HostThreadWindows.cpp -----------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

lldb/trunk/source/Host/windows/ThisThread.cpp

//===-- ThisThread.cpp ------------------------------------------*- C++ -*-===// //===-- ThisThread.cpp ------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/SmallVector.h"
using namespace lldb; using namespace lldb;
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

lldb/trunk/source/Interpreter/Args.cpp

//===-- Args.cpp ------------------------------------------------*- C++ -*-===// //===-- Args.cpp ------------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// C Includes // C Includes
#include <cstdlib> #include <cstdlib>
// 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"
#include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Interpreter/CommandReturnObject.h" #include "lldb/Interpreter/CommandReturnObject.h"
#include "lldb/Interpreter/Options.h" #include "lldb/Interpreter/Options.h"
#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"
#include "llvm/ADT/StringSwitch.h" #include "llvm/ADT/StringSwitch.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
▲ Show 20 Lines • Show All 1,466 Lines • Show Last 20 Lines

lldb/trunk/source/Interpreter/CommandAlias.cpp

//===-- CommandAlias.cpp -----------------------------------------*- C++-*-===// //===-- CommandAlias.cpp -----------------------------------------*- C++-*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Interpreter/CommandAlias.h" #include "lldb/Interpreter/CommandAlias.h"
#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;
static bool ProcessAliasOptionsArgs(lldb::CommandObjectSP &cmd_obj_sp, static bool ProcessAliasOptionsArgs(lldb::CommandObjectSP &cmd_obj_sp,
llvm::StringRef options_args, llvm::StringRef options_args,
OptionArgVectorSP &option_arg_vector_sp) { OptionArgVectorSP &option_arg_vector_sp) {
bool success = true; bool success = true;
▲ Show 20 Lines • Show All 226 Lines • Show Last 20 Lines

lldb/trunk/source/Interpreter/CommandInterpreter.cpp

Show All 39 Lines
#include "../Commands/CommandObjectType.h" #include "../Commands/CommandObjectType.h"
#include "../Commands/CommandObjectVersion.h" #include "../Commands/CommandObjectVersion.h"
#include "../Commands/CommandObjectWatchpoint.h" #include "../Commands/CommandObjectWatchpoint.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#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"
#endif #endif
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Host/HostInfo.h" #include "lldb/Host/HostInfo.h"
#include "lldb/Interpreter/Args.h" #include "lldb/Interpreter/Args.h"
▲ Show 20 Lines • Show All 3,021 Lines • Show Last 20 Lines

lldb/trunk/source/Interpreter/CommandReturnObject.cpp

//===-- CommandReturnObject.cpp ---------------------------------*- C++ -*-===// //===-- CommandReturnObject.cpp ---------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Interpreter/CommandReturnObject.h" #include "lldb/Interpreter/CommandReturnObject.h"
// C Includes // C Includes
// 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;
static void DumpStringToStreamWithNewline(Stream &strm, const std::string &s, static void DumpStringToStreamWithNewline(Stream &strm, const std::string &s,
bool add_newline_if_empty) { bool add_newline_if_empty) {
bool add_newline = false; bool add_newline = false;
if (s.empty()) { if (s.empty()) {
▲ Show 20 Lines • Show All 150 Lines • Show Last 20 Lines

lldb/trunk/source/Interpreter/OptionGroupVariable.cpp

//===-- OptionGroupVariable.cpp -----------------------*- C++ -*-===// //===-- OptionGroupVariable.cpp -----------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Interpreter/OptionGroupVariable.h" #include "lldb/Interpreter/OptionGroupVariable.h"
// C Includes // C Includes
// 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;
// if you add any options here, remember to update the counters in // if you add any options here, remember to update the counters in
// OptionGroupVariable::GetNumDefinitions() // OptionGroupVariable::GetNumDefinitions()
static OptionDefinition g_variable_options[] = { static OptionDefinition g_variable_options[] = {
{LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "no-args", 'a', {LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "no-args", 'a',
▲ Show 20 Lines • Show All 114 Lines • Show Last 20 Lines

lldb/trunk/source/Interpreter/OptionValueArray.cpp

//===-- OptionValueArray.cpp ------------------------------------*- C++ -*-===// //===-- OptionValueArray.cpp ------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Interpreter/OptionValueArray.h" #include "lldb/Interpreter/OptionValueArray.h"
// C Includes // C Includes
// 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;
void OptionValueArray::DumpValue(const ExecutionContext *exe_ctx, Stream &strm, void OptionValueArray::DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
uint32_t dump_mask) { uint32_t dump_mask) {
const Type array_element_type = ConvertTypeMaskToType(m_type_mask); const Type array_element_type = ConvertTypeMaskToType(m_type_mask);
if (dump_mask & eDumpOptionType) { if (dump_mask & eDumpOptionType) {
▲ Show 20 Lines • Show All 284 Lines • Show Last 20 Lines

lldb/trunk/source/Interpreter/OptionValueBoolean.cpp

//===-- OptionValueBoolean.cpp ----------------------------------*- C++ -*-===// //===-- OptionValueBoolean.cpp ----------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Interpreter/OptionValueBoolean.h" #include "lldb/Interpreter/OptionValueBoolean.h"
// C Includes // C Includes
// 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;
using namespace lldb_private; using namespace lldb_private;
void OptionValueBoolean::DumpValue(const ExecutionContext *exe_ctx, void OptionValueBoolean::DumpValue(const ExecutionContext *exe_ctx,
Stream &strm, uint32_t dump_mask) { Stream &strm, uint32_t dump_mask) {
if (dump_mask & eDumpOptionType) if (dump_mask & eDumpOptionType)
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

lldb/trunk/source/Interpreter/OptionValueChar.cpp

//===-- OptionValueChar.cpp -------------------------------------*- C++ -*-===// //===-- OptionValueChar.cpp -------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Interpreter/OptionValueChar.h" #include "lldb/Interpreter/OptionValueChar.h"
// C Includes // C Includes
// 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;
using namespace lldb_private; using namespace lldb_private;
void OptionValueChar::DumpValue(const ExecutionContext *exe_ctx, Stream &strm, void OptionValueChar::DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
uint32_t dump_mask) { uint32_t dump_mask) {
if (dump_mask & eDumpOptionType) if (dump_mask & eDumpOptionType)
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

lldb/trunk/source/Interpreter/OptionValueFileSpecLIst.cpp

//===-- OptionValueFileSpecLIst.cpp -----------------------------*- C++ -*-===// //===-- OptionValueFileSpecLIst.cpp -----------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Interpreter/OptionValueFileSpecList.h" #include "lldb/Interpreter/OptionValueFileSpecList.h"
// C Includes // C Includes
// 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;
void OptionValueFileSpecList::DumpValue(const ExecutionContext *exe_ctx, void OptionValueFileSpecList::DumpValue(const ExecutionContext *exe_ctx,
Stream &strm, uint32_t dump_mask) { Stream &strm, uint32_t dump_mask) {
if (dump_mask & eDumpOptionType) if (dump_mask & eDumpOptionType)
strm.Printf("(%s)", GetTypeAsCString()); strm.Printf("(%s)", GetTypeAsCString());
▲ Show 20 Lines • Show All 138 Lines • Show Last 20 Lines

lldb/trunk/source/Interpreter/OptionValueFormat.cpp

//===-- OptionValueFormat.cpp -----------------------------------*- C++ -*-===// //===-- OptionValueFormat.cpp -----------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Interpreter/OptionValueFormat.h" #include "lldb/Interpreter/OptionValueFormat.h"
// C Includes // C Includes
// 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;
void OptionValueFormat::DumpValue(const ExecutionContext *exe_ctx, Stream &strm, void OptionValueFormat::DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
uint32_t dump_mask) { uint32_t dump_mask) {
if (dump_mask & eDumpOptionType) if (dump_mask & eDumpOptionType)
strm.Printf("(%s)", GetTypeAsCString()); strm.Printf("(%s)", GetTypeAsCString());
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

lldb/trunk/source/Interpreter/OptionValueFormatEntity.cpp

//===-- OptionValueFormatEntity.cpp -----------------------------*- C++ -*-===// //===-- OptionValueFormatEntity.cpp -----------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Interpreter/OptionValueFormatEntity.h" #include "lldb/Interpreter/OptionValueFormatEntity.h"
// C Includes // C Includes
// C++ Includes // C++ Includes
// 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;
OptionValueFormatEntity::OptionValueFormatEntity(const char *default_format) OptionValueFormatEntity::OptionValueFormatEntity(const char *default_format)
: OptionValue(), m_current_format(), m_default_format(), m_current_entry(), : OptionValue(), m_current_format(), m_default_format(), m_current_entry(),
m_default_entry() { m_default_entry() {
if (default_format && default_format[0]) { if (default_format && default_format[0]) {
llvm::StringRef default_format_str(default_format); llvm::StringRef default_format_str(default_format);
▲ Show 20 Lines • Show All 88 Lines • Show Last 20 Lines

lldb/trunk/source/Interpreter/OptionValueLanguage.cpp

//===-- OptionValueLanguage.cpp ---------------------------------*- C++ -*-===// //===-- OptionValueLanguage.cpp ---------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Interpreter/OptionValueLanguage.h" #include "lldb/Interpreter/OptionValueLanguage.h"
// C Includes // C Includes
// 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;
void OptionValueLanguage::DumpValue(const ExecutionContext *exe_ctx, void OptionValueLanguage::DumpValue(const ExecutionContext *exe_ctx,
Stream &strm, uint32_t dump_mask) { Stream &strm, uint32_t dump_mask) {
if (dump_mask & eDumpOptionType) if (dump_mask & eDumpOptionType)
strm.Printf("(%s)", GetTypeAsCString()); strm.Printf("(%s)", GetTypeAsCString());
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

lldb/trunk/source/Interpreter/OptionValuePathMappings.cpp

//===-- OptionValuePathMappings.cpp -----------------------------*- C++ -*-===// //===-- OptionValuePathMappings.cpp -----------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Interpreter/OptionValuePathMappings.h" #include "lldb/Interpreter/OptionValuePathMappings.h"
// C Includes // C Includes
// 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;
namespace { namespace {
static bool VerifyPathExists(const char *path) { static bool VerifyPathExists(const char *path) {
if (path && path[0]) if (path && path[0])
return FileSpec(path, false).Exists(); return FileSpec(path, false).Exists();
else else
▲ Show 20 Lines • Show All 181 Lines • Show Last 20 Lines

lldb/trunk/source/Interpreter/OptionValueProperties.cpp

//===-- OptionValueProperties.cpp --------------------------------*- C++-*-===// //===-- OptionValueProperties.cpp --------------------------------*- C++-*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Interpreter/OptionValueProperties.h" #include "lldb/Interpreter/OptionValueProperties.h"
// C Includes // C Includes
// C++ Includes // C++ Includes
// 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;
OptionValueProperties::OptionValueProperties(const ConstString &name) OptionValueProperties::OptionValueProperties(const ConstString &name)
: OptionValue(), m_name(name), m_properties(), m_name_to_index() {} : OptionValue(), m_name(name), m_properties(), m_name_to_index() {}
OptionValueProperties::OptionValueProperties( OptionValueProperties::OptionValueProperties(
▲ Show 20 Lines • Show All 645 Lines • Show Last 20 Lines

lldb/trunk/source/Interpreter/OptionValueRegex.cpp

//===-- OptionValueRegex.cpp ------------------------------------*- C++ -*-===// //===-- OptionValueRegex.cpp ------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Interpreter/OptionValueRegex.h" #include "lldb/Interpreter/OptionValueRegex.h"
// C Includes // C Includes
// 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;
void OptionValueRegex::DumpValue(const ExecutionContext *exe_ctx, Stream &strm, void OptionValueRegex::DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
uint32_t dump_mask) { uint32_t dump_mask) {
if (dump_mask & eDumpOptionType) if (dump_mask & eDumpOptionType)
strm.Printf("(%s)", GetTypeAsCString()); strm.Printf("(%s)", GetTypeAsCString());
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

lldb/trunk/source/Interpreter/OptionValueSInt64.cpp

//===-- OptionValueSInt64.cpp -----------------------------------*- C++ -*-===// //===-- OptionValueSInt64.cpp -----------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Interpreter/OptionValueSInt64.h" #include "lldb/Interpreter/OptionValueSInt64.h"
// C Includes // C Includes
// 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;
void OptionValueSInt64::DumpValue(const ExecutionContext *exe_ctx, Stream &strm, void OptionValueSInt64::DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
uint32_t dump_mask) { uint32_t dump_mask) {
// printf ("%p: DumpValue (exe_ctx=%p, strm, mask) m_current_value = %" PRIi64 // printf ("%p: DumpValue (exe_ctx=%p, strm, mask) m_current_value = %" PRIi64
// "\n", this, exe_ctx, m_current_value); // "\n", this, exe_ctx, m_current_value);
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

lldb/trunk/source/Interpreter/OptionValueString.cpp

//===-- OptionValueString.cpp ------------------------------------*- C++ //===-- OptionValueString.cpp ------------------------------------*- C++
//-*-===// //-*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Interpreter/OptionValueString.h" #include "lldb/Interpreter/OptionValueString.h"
// C Includes // C Includes
// 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;
void OptionValueString::DumpValue(const ExecutionContext *exe_ctx, Stream &strm, void OptionValueString::DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
uint32_t dump_mask) { uint32_t dump_mask) {
if (dump_mask & eDumpOptionType) if (dump_mask & eDumpOptionType)
strm.Printf("(%s)", GetTypeAsCString()); strm.Printf("(%s)", GetTypeAsCString());
▲ Show 20 Lines • Show All 126 Lines • Show Last 20 Lines

lldb/trunk/source/Interpreter/OptionValueUInt64.cpp

//===-- OptionValueUInt64.cpp ------------------------------------*- C++ //===-- OptionValueUInt64.cpp ------------------------------------*- C++
//-*-===// //-*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Interpreter/OptionValueUInt64.h" #include "lldb/Interpreter/OptionValueUInt64.h"
// C Includes // C Includes
// 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;
lldb::OptionValueSP OptionValueUInt64::Create(llvm::StringRef value_str, lldb::OptionValueSP OptionValueUInt64::Create(llvm::StringRef value_str,
Error &error) { Error &error) {
lldb::OptionValueSP value_sp(new OptionValueUInt64()); lldb::OptionValueSP value_sp(new OptionValueUInt64());
error = value_sp->SetValueFromString(value_str); error = value_sp->SetValueFromString(value_str);
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

lldb/trunk/source/Interpreter/OptionValueUUID.cpp

//===-- OptionValueUUID.cpp ------------------------------------*- C++ -*-===// //===-- OptionValueUUID.cpp ------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Interpreter/OptionValueUUID.h" #include "lldb/Interpreter/OptionValueUUID.h"
// C Includes // C Includes
// C++ Includes // C++ Includes
// 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;
void OptionValueUUID::DumpValue(const ExecutionContext *exe_ctx, Stream &strm, void OptionValueUUID::DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
uint32_t dump_mask) { uint32_t dump_mask) {
if (dump_mask & eDumpOptionType) if (dump_mask & eDumpOptionType)
strm.Printf("(%s)", GetTypeAsCString()); strm.Printf("(%s)", GetTypeAsCString());
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

lldb/trunk/source/Interpreter/Options.cpp

Show All 12 Lines
// C++ Includes // C++ Includes
#include <algorithm> #include <algorithm>
#include <bitset> #include <bitset>
#include <map> #include <map>
#include <set> #include <set>
// 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;
//------------------------------------------------------------------------- //-------------------------------------------------------------------------
// Options // Options
//------------------------------------------------------------------------- //-------------------------------------------------------------------------
Options::Options() : m_getopt_table() { BuildValidOptionSets(); } Options::Options() : m_getopt_table() { BuildValidOptionSets(); }
▲ Show 20 Lines • Show All 918 Lines • Show Last 20 Lines

lldb/trunk/source/Interpreter/ScriptInterpreter.cpp

//===-- ScriptInterpreter.cpp -----------------------------------*- C++ -*-===// //===-- ScriptInterpreter.cpp -----------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Interpreter/ScriptInterpreter.h" #include "lldb/Interpreter/ScriptInterpreter.h"
#include <stdio.h> #include <stdio.h>
#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;
ScriptInterpreter::ScriptInterpreter(CommandInterpreter &interpreter, ScriptInterpreter::ScriptInterpreter(CommandInterpreter &interpreter,
lldb::ScriptLanguage script_lang) lldb::ScriptLanguage script_lang)
: m_interpreter(interpreter), m_script_lang(script_lang) {} : m_interpreter(interpreter), m_script_lang(script_lang) {}
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

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

Show All 12 Lines
// C++ Includes // C++ Includes
#include <vector> #include <vector>
// Other libraries and framework includes // Other libraries and framework includes
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#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"
#include "lldb/Core/Scalar.h" #include "lldb/Core/Scalar.h"
#include "lldb/Core/Value.h" #include "lldb/Core/Value.h"
#include "lldb/Core/ValueObjectConstResult.h" #include "lldb/Core/ValueObjectConstResult.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/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"
#include "Utility/ARM_ehframe_Registers.h" #include "Utility/ARM_ehframe_Registers.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
▲ Show 20 Lines • Show All 2,022 Lines • Show Last 20 Lines

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

//===-- ABIMacOSX_arm64.h ---------------------------------------*- C++ -*-===// //===-- ABIMacOSX_arm64.h ---------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef liblldb_ABIMacOSX_arm64_h_ #ifndef liblldb_ABIMacOSX_arm64_h_
#define liblldb_ABIMacOSX_arm64_h_ #define liblldb_ABIMacOSX_arm64_h_
// C Includes // C Includes
// 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 {
public: public:
~ABIMacOSX_arm64() override = default; ~ABIMacOSX_arm64() override = default;
size_t GetRedZoneSize() const override; size_t GetRedZoneSize() const override;
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

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

Show All 11 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
#include <vector> #include <vector>
// Other libraries and framework includes // Other libraries and framework includes
#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"
#include "lldb/Core/RegisterValue.h" #include "lldb/Core/RegisterValue.h"
#include "lldb/Core/Scalar.h" #include "lldb/Core/Scalar.h"
#include "lldb/Core/Value.h" #include "lldb/Core/Value.h"
#include "lldb/Core/Value.h" #include "lldb/Core/Value.h"
#include "lldb/Core/ValueObjectConstResult.h" #include "lldb/Core/ValueObjectConstResult.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/ConstString.h"
#include "lldb/Utility/Error.h"
#include "Utility/ARM64_DWARF_Registers.h" #include "Utility/ARM64_DWARF_Registers.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
static const char *pluginDesc = "Mac OS X ABI for arm64 targets"; static const char *pluginDesc = "Mac OS X ABI for arm64 targets";
▲ Show 20 Lines • Show All 2,411 Lines • Show Last 20 Lines

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

Show All 12 Lines
// C++ Includes // C++ Includes
#include <vector> #include <vector>
// Other libraries and framework includes // Other libraries and framework includes
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#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"
#include "lldb/Core/Scalar.h" #include "lldb/Core/Scalar.h"
#include "lldb/Core/ValueObjectConstResult.h" #include "lldb/Core/ValueObjectConstResult.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/ConstString.h"
#include "lldb/Utility/Error.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
enum { enum {
ehframe_eax = 0, ehframe_eax = 0,
ehframe_ecx, ehframe_ecx,
ehframe_edx, ehframe_edx,
▲ Show 20 Lines • Show All 1,103 Lines • Show Last 20 Lines

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

Show All 12 Lines
// C++ Includes // C++ Includes
#include <vector> #include <vector>
// Other libraries and framework includes // Other libraries and framework includes
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#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"
#include "lldb/Core/Scalar.h" #include "lldb/Core/Scalar.h"
#include "lldb/Core/Value.h" #include "lldb/Core/Value.h"
#include "lldb/Core/ValueObjectConstResult.h" #include "lldb/Core/ValueObjectConstResult.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/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"
#include "Utility/ARM_ehframe_Registers.h" #include "Utility/ARM_ehframe_Registers.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
▲ Show 20 Lines • Show All 2,124 Lines • Show Last 20 Lines

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

Show All 12 Lines
// C++ Includes // C++ Includes
#include <vector> #include <vector>
// Other libraries and framework includes // Other libraries and framework includes
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#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"
#include "lldb/Core/RegisterValue.h" #include "lldb/Core/RegisterValue.h"
#include "lldb/Core/Scalar.h" #include "lldb/Core/Scalar.h"
#include "lldb/Core/Value.h" #include "lldb/Core/Value.h"
#include "lldb/Core/ValueObjectConstResult.h" #include "lldb/Core/ValueObjectConstResult.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/ConstString.h"
#include "lldb/Utility/Error.h"
#include "Utility/ARM64_DWARF_Registers.h" #include "Utility/ARM64_DWARF_Registers.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
static RegisterInfo g_register_infos[] = { static RegisterInfo g_register_infos[] = {
// NAME ALT SZ OFF ENCODING FORMAT // NAME ALT SZ OFF ENCODING FORMAT
▲ Show 20 Lines • Show All 2,384 Lines • Show Last 20 Lines

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

Show All 10 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
#include "llvm/ADT/Triple.h" #include "llvm/ADT/Triple.h"
#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"
#include "lldb/Core/RegisterValue.h" #include "lldb/Core/RegisterValue.h"
#include "lldb/Core/Value.h" #include "lldb/Core/Value.h"
#include "lldb/Core/ValueObjectConstResult.h" #include "lldb/Core/ValueObjectConstResult.h"
#include "lldb/Core/ValueObjectMemory.h" #include "lldb/Core/ValueObjectMemory.h"
#include "lldb/Core/ValueObjectRegister.h" #include "lldb/Core/ValueObjectRegister.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/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;
static RegisterInfo g_register_infos[] = { static RegisterInfo g_register_infos[] = {
// hexagon-core.xml // hexagon-core.xml
{"r00", {"r00",
"", "",
▲ Show 20 Lines • Show All 1,321 Lines • Show Last 20 Lines

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

Show All 10 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#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"
#include "lldb/Core/RegisterValue.h" #include "lldb/Core/RegisterValue.h"
#include "lldb/Core/Value.h" #include "lldb/Core/Value.h"
#include "lldb/Core/ValueObjectConstResult.h" #include "lldb/Core/ValueObjectConstResult.h"
#include "lldb/Core/ValueObjectMemory.h" #include "lldb/Core/ValueObjectMemory.h"
#include "lldb/Core/ValueObjectRegister.h" #include "lldb/Core/ValueObjectRegister.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/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;
// This source file uses the following document as a reference: // This source file uses the following document as a reference:
//==================================================================== //====================================================================
// System V Application Binary Interface // System V Application Binary Interface
// Intel386 Architecture Processor Supplement, Version 1.0 // Intel386 Architecture Processor Supplement, Version 1.0
▲ Show 20 Lines • Show All 816 Lines • Show Last 20 Lines

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

Show All 10 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#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"
#include "lldb/Core/RegisterValue.h" #include "lldb/Core/RegisterValue.h"
#include "lldb/Core/Value.h" #include "lldb/Core/Value.h"
#include "lldb/Core/ValueObjectConstResult.h" #include "lldb/Core/ValueObjectConstResult.h"
#include "lldb/Core/ValueObjectMemory.h" #include "lldb/Core/ValueObjectMemory.h"
#include "lldb/Core/ValueObjectRegister.h" #include "lldb/Core/ValueObjectRegister.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/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;
enum dwarf_regnums { enum dwarf_regnums {
dwarf_r0 = 0, dwarf_r0 = 0,
dwarf_r1, dwarf_r1,
dwarf_r2, dwarf_r2,
▲ Show 20 Lines • Show All 1,036 Lines • Show Last 20 Lines

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

Show All 10 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#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"
#include "lldb/Core/RegisterValue.h" #include "lldb/Core/RegisterValue.h"
#include "lldb/Core/Value.h" #include "lldb/Core/Value.h"
#include "lldb/Core/ValueObjectConstResult.h" #include "lldb/Core/ValueObjectConstResult.h"
#include "lldb/Core/ValueObjectMemory.h" #include "lldb/Core/ValueObjectMemory.h"
#include "lldb/Core/ValueObjectRegister.h" #include "lldb/Core/ValueObjectRegister.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/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;
enum dwarf_regnums { enum dwarf_regnums {
dwarf_r0 = 0, dwarf_r0 = 0,
dwarf_r1, dwarf_r1,
dwarf_r2, dwarf_r2,
▲ Show 20 Lines • Show All 1,185 Lines • Show Last 20 Lines

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

Show All 10 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#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"
#include "lldb/Core/RegisterValue.h" #include "lldb/Core/RegisterValue.h"
#include "lldb/Core/Value.h" #include "lldb/Core/Value.h"
#include "lldb/Core/ValueObjectConstResult.h" #include "lldb/Core/ValueObjectConstResult.h"
#include "lldb/Core/ValueObjectMemory.h" #include "lldb/Core/ValueObjectMemory.h"
#include "lldb/Core/ValueObjectRegister.h" #include "lldb/Core/ValueObjectRegister.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/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;
enum dwarf_regnums { enum dwarf_regnums {
dwarf_r0 = 0, dwarf_r0 = 0,
dwarf_r1, dwarf_r1,
dwarf_r2, dwarf_r2,
▲ Show 20 Lines • Show All 980 Lines • Show Last 20 Lines

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

Show All 10 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#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"
#include "lldb/Core/RegisterValue.h" #include "lldb/Core/RegisterValue.h"
#include "lldb/Core/Value.h" #include "lldb/Core/Value.h"
#include "lldb/Core/ValueObjectConstResult.h" #include "lldb/Core/ValueObjectConstResult.h"
#include "lldb/Core/ValueObjectMemory.h" #include "lldb/Core/ValueObjectMemory.h"
#include "lldb/Core/ValueObjectRegister.h" #include "lldb/Core/ValueObjectRegister.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/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;
enum dwarf_regnums { enum dwarf_regnums {
dwarf_r0 = 0, dwarf_r0 = 0,
dwarf_r1, dwarf_r1,
dwarf_r2, dwarf_r2,
▲ Show 20 Lines • Show All 984 Lines • Show Last 20 Lines

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

Show All 10 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#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"
#include "lldb/Core/RegisterValue.h" #include "lldb/Core/RegisterValue.h"
#include "lldb/Core/Value.h" #include "lldb/Core/Value.h"
#include "lldb/Core/ValueObjectConstResult.h" #include "lldb/Core/ValueObjectConstResult.h"
#include "lldb/Core/ValueObjectMemory.h" #include "lldb/Core/ValueObjectMemory.h"
#include "lldb/Core/ValueObjectRegister.h" #include "lldb/Core/ValueObjectRegister.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/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;
enum dwarf_regnums { enum dwarf_regnums {
// General Purpose Registers // General Purpose Registers
dwarf_r0_s390x = 0, dwarf_r0_s390x = 0,
dwarf_r1_s390x, dwarf_r1_s390x,
▲ Show 20 Lines • Show All 710 Lines • Show Last 20 Lines

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

Show All 10 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#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"
#include "lldb/Core/RegisterValue.h" #include "lldb/Core/RegisterValue.h"
#include "lldb/Core/Value.h" #include "lldb/Core/Value.h"
#include "lldb/Core/ValueObjectConstResult.h" #include "lldb/Core/ValueObjectConstResult.h"
#include "lldb/Core/ValueObjectMemory.h" #include "lldb/Core/ValueObjectMemory.h"
#include "lldb/Core/ValueObjectRegister.h" #include "lldb/Core/ValueObjectRegister.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/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;
enum dwarf_regnums { enum dwarf_regnums {
dwarf_rax = 0, dwarf_rax = 0,
dwarf_rdx, dwarf_rdx,
dwarf_rcx, dwarf_rcx,
▲ Show 20 Lines • Show All 1,938 Lines • Show Last 20 Lines

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

Show All 28 Lines
// Other libraries and framework includes // Other libraries and framework includes
#include "DisassemblerLLVMC.h" #include "DisassemblerLLVMC.h"
#include "lldb/Core/Address.h" #include "lldb/Core/Address.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/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"
#include "lldb/Target/RegisterContext.h" #include "lldb/Target/RegisterContext.h"
#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;
class InstructionLLVMC : public lldb_private::Instruction { class InstructionLLVMC : public lldb_private::Instruction {
public: public:
InstructionLLVMC(DisassemblerLLVMC &disasm, InstructionLLVMC(DisassemblerLLVMC &disasm,
const lldb_private::Address &address, const lldb_private::Address &address,
▲ Show 20 Lines • Show All 1,321 Lines • Show Last 20 Lines

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

//===-- HexagonDYLDRendezvous.cpp -------------------------------*- C++ -*-===// //===-- HexagonDYLDRendezvous.cpp -------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// C Includes // C Includes
// 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"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "HexagonDYLDRendezvous.h" #include "HexagonDYLDRendezvous.h"
using namespace lldb; using namespace lldb;
▲ Show 20 Lines • Show All 344 Lines • Show Last 20 Lines

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

//===-- DYLDRendezvous.cpp --------------------------------------*- C++ -*-===// //===-- DYLDRendezvous.cpp --------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// C Includes // C Includes
// 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"
#include "lldb/Symbol/Symbol.h" #include "lldb/Symbol/Symbol.h"
#include "lldb/Symbol/SymbolContext.h" #include "lldb/Symbol/SymbolContext.h"
#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"
#include "DYLDRendezvous.h" #include "DYLDRendezvous.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
▲ Show 20 Lines • Show All 581 Lines • Show Last 20 Lines

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

//===-- ASTDumper.h ---------------------------------------------*- C++ -*-===// //===-- ASTDumper.h ---------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef liblldb_ASTDumper_h_ #ifndef liblldb_ASTDumper_h_
#define liblldb_ASTDumper_h_ #define liblldb_ASTDumper_h_
#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 {
class ASTDumper { class ASTDumper {
public: public:
ASTDumper(clang::Decl *decl); ASTDumper(clang::Decl *decl);
ASTDumper(clang::DeclContext *decl_ctx); ASTDumper(clang::DeclContext *decl_ctx);
Show All 17 Lines

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

Show All 9 Lines
#include "ClangExpressionDeclMap.h" #include "ClangExpressionDeclMap.h"
#include "ASTDumper.h" #include "ASTDumper.h"
#include "ClangASTSource.h" #include "ClangASTSource.h"
#include "ClangModulesDeclVendor.h" #include "ClangModulesDeclVendor.h"
#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"
#include "lldb/Core/RegisterValue.h" #include "lldb/Core/RegisterValue.h"
#include "lldb/Core/ValueObjectConstResult.h" #include "lldb/Core/ValueObjectConstResult.h"
#include "lldb/Core/ValueObjectVariable.h" #include "lldb/Core/ValueObjectVariable.h"
#include "lldb/Expression/Materializer.h" #include "lldb/Expression/Materializer.h"
#include "lldb/Host/Endian.h" #include "lldb/Host/Endian.h"
Show All 13 Lines
#include "lldb/Target/CPPLanguageRuntime.h" #include "lldb/Target/CPPLanguageRuntime.h"
#include "lldb/Target/ExecutionContext.h" #include "lldb/Target/ExecutionContext.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/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"
#include "clang/AST/Decl.h" #include "clang/AST/Decl.h"
#include "clang/AST/DeclarationName.h" #include "clang/AST/DeclarationName.h"
#include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h" #include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
▲ Show 20 Lines • Show All 2,165 Lines • Show Last 20 Lines

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

//===-- ClangExpressionParser.h ---------------------------------*- C++ -*-===// //===-- ClangExpressionParser.h ---------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef liblldb_ClangExpressionParser_h_ #ifndef liblldb_ClangExpressionParser_h_
#define liblldb_ClangExpressionParser_h_ #define liblldb_ClangExpressionParser_h_
#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>
#include <vector> #include <vector>
namespace lldb_private { namespace lldb_private {
class IRExecutionUnit; class IRExecutionUnit;
▲ Show 20 Lines • Show All 141 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 66 Lines • ▼ Show 20 Lines
#include "IRForTarget.h" #include "IRForTarget.h"
#include "lldb/Core/ArchSpec.h" #include "lldb/Core/ArchSpec.h"
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#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"
#include "lldb/Expression/IRInterpreter.h" #include "lldb/Expression/IRInterpreter.h"
#include "lldb/Host/File.h" #include "lldb/Host/File.h"
#include "lldb/Host/HostInfo.h" #include "lldb/Host/HostInfo.h"
#include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/ClangASTContext.h"
#include "lldb/Symbol/SymbolVendor.h" #include "lldb/Symbol/SymbolVendor.h"
#include "lldb/Target/ExecutionContext.h" #include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Language.h" #include "lldb/Target/Language.h"
#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/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;
using namespace lldb_private; using namespace lldb_private;
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Utility Methods for Clang // Utility Methods for Clang
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
▲ Show 20 Lines • Show All 886 Lines • Show Last 20 Lines

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

Show All 19 Lines
#include <string> #include <string>
#include <vector> #include <vector>
// Other libraries and framework includes // Other libraries and framework includes
#include "llvm/Support/Casting.h" #include "llvm/Support/Casting.h"
// 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 {
class Value; class Value;
} }
namespace lldb_private { namespace lldb_private {
▲ Show 20 Lines • Show All 201 Lines • Show Last 20 Lines

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

//===-- ClangExpressionVariable.cpp -----------------------------*- C++ -*-===// //===-- ClangExpressionVariable.cpp -----------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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;
using namespace clang; using namespace clang;
ClangExpressionVariable::ClangExpressionVariable( ClangExpressionVariable::ClangExpressionVariable(
ExecutionContextScope *exe_scope, lldb::ByteOrder byte_order, ExecutionContextScope *exe_scope, lldb::ByteOrder byte_order,
uint32_t addr_byte_size) uint32_t addr_byte_size)
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

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

Show All 20 Lines
#include "clang/Sema/Lookup.h" #include "clang/Sema/Lookup.h"
#include "clang/Serialization/ASTReader.h" #include "clang/Serialization/ASTReader.h"
#include "llvm/Support/Path.h" #include "llvm/Support/Path.h"
// Project includes // Project includes
#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;
namespace { namespace {
// Any Clang compiler requires a consumer for diagnostics. This one stores them // Any Clang compiler requires a consumer for diagnostics. This one stores them
// as strings // as strings
// so we can provide them to the user in case a module failed to load. // so we can provide them to the user in case a module failed to load.
class StoringDiagnosticConsumer : public clang::DiagnosticConsumer { class StoringDiagnosticConsumer : public clang::DiagnosticConsumer {
▲ Show 20 Lines • Show All 637 Lines • Show Last 20 Lines

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

//===-- ClangPersistentVariables.cpp ----------------------------*- C++ -*-===// //===-- ClangPersistentVariables.cpp ----------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "ClangPersistentVariables.h" #include "ClangPersistentVariables.h"
#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"
#include "llvm/ADT/StringMap.h" #include "llvm/ADT/StringMap.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

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

Show All 19 Lines
#include "ASTResultSynthesizer.h" #include "ASTResultSynthesizer.h"
#include "ClangDiagnostic.h" #include "ClangDiagnostic.h"
#include "ClangExpressionDeclMap.h" #include "ClangExpressionDeclMap.h"
#include "ClangExpressionParser.h" #include "ClangExpressionParser.h"
#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"
#include "lldb/Expression/IRInterpreter.h" #include "lldb/Expression/IRInterpreter.h"
#include "lldb/Expression/Materializer.h" #include "lldb/Expression/Materializer.h"
#include "lldb/Host/HostInfo.h" #include "lldb/Host/HostInfo.h"
#include "lldb/Symbol/Block.h" #include "lldb/Symbol/Block.h"
#include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/ClangASTContext.h"
#include "lldb/Symbol/ClangExternalASTSourceCommon.h" #include "lldb/Symbol/ClangExternalASTSourceCommon.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/Type.h" #include "lldb/Symbol/Type.h"
#include "lldb/Symbol/VariableList.h" #include "lldb/Symbol/VariableList.h"
#include "lldb/Target/ExecutionContext.h" #include "lldb/Target/ExecutionContext.h"
#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/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"
using namespace lldb_private; using namespace lldb_private;
ClangUserExpression::ClangUserExpression( ClangUserExpression::ClangUserExpression(
ExecutionContextScope &exe_scope, llvm::StringRef expr, ExecutionContextScope &exe_scope, llvm::StringRef expr,
▲ Show 20 Lines • Show All 628 Lines • Show Last 20 Lines

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

Show All 13 Lines
// C Includes // C Includes
#include <stdio.h> #include <stdio.h>
#if HAVE_SYS_TYPES_H #if HAVE_SYS_TYPES_H
#include <sys/types.h> #include <sys/types.h>
#endif #endif
// 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;
//------------------------------------------------------------------ //------------------------------------------------------------------
/// Constructor /// Constructor
/// ///
/// @param[in] text /// @param[in] text
/// The text of the function. Must be a full translation unit. /// The text of the function. Must be a full translation unit.
▲ Show 20 Lines • Show All 133 Lines • Show Last 20 Lines

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

//===-- IRForTarget.h ---------------------------------------------*- C++ //===-- IRForTarget.h ---------------------------------------------*- C++
//-*-===// //-*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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"
#include <functional> #include <functional>
#include <map> #include <map>
namespace llvm { namespace llvm {
class BasicBlock; class BasicBlock;
▲ Show 20 Lines • Show All 642 Lines • Show Last 20 Lines

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

Show All 19 Lines
#include "llvm/IR/Metadata.h" #include "llvm/IR/Metadata.h"
#include "llvm/IR/Module.h" #include "llvm/IR/Module.h"
#include "llvm/IR/ValueSymbolTable.h" #include "llvm/IR/ValueSymbolTable.h"
#include "llvm/Support/raw_ostream.h" #include "llvm/Support/raw_ostream.h"
#include "llvm/Transforms/IPO.h" #include "llvm/Transforms/IPO.h"
#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"
#include "lldb/Host/Endian.h" #include "lldb/Host/Endian.h"
#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>
using namespace llvm; using namespace llvm;
static char ID; static char ID;
IRForTarget::FunctionValueCache::FunctionValueCache(Maker const &maker) IRForTarget::FunctionValueCache::FunctionValueCache(Maker const &maker)
▲ Show 20 Lines • Show All 2,227 Lines • Show Last 20 Lines

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

//===-- GoParser.cpp ---------------------------------*- C++ -*-===// //===-- GoParser.cpp ---------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include <vector> #include <vector>
#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;
using namespace lldb; using namespace lldb;
namespace { namespace {
llvm::StringRef DescribeToken(GoLexer::TokenType t) { llvm::StringRef DescribeToken(GoLexer::TokenType t) {
switch (t) { switch (t) {
▲ Show 20 Lines • Show All 857 Lines • Show Last 20 Lines

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

Show All 20 Lines
// Other libraries and framework includes // Other libraries and framework includes
#include "llvm/ADT/StringMap.h" #include "llvm/ADT/StringMap.h"
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
// 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"
#include "lldb/Expression/ExpressionVariable.h" #include "lldb/Expression/ExpressionVariable.h"
#include "lldb/Symbol/GoASTContext.h" #include "lldb/Symbol/GoASTContext.h"
#include "lldb/Symbol/SymbolFile.h" #include "lldb/Symbol/SymbolFile.h"
#include "lldb/Symbol/TypeList.h" #include "lldb/Symbol/TypeList.h"
#include "lldb/Symbol/VariableList.h" #include "lldb/Symbol/VariableList.h"
#include "lldb/Target/ExecutionContext.h" #include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h" #include "lldb/Target/RegisterContext.h"
#include "lldb/Target/StackFrame.h" #include "lldb/Target/StackFrame.h"
#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"
#include "Plugins/ExpressionParser/Go/GoParser.h" #include "Plugins/ExpressionParser/Go/GoParser.h"
using namespace lldb_private; using namespace lldb_private;
using namespace lldb; using namespace lldb;
▲ Show 20 Lines • Show All 619 Lines • Show Last 20 Lines

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

//===-- lldb_EmulateInstructionARM.h ----------------------------*- C++ -*-===// //===-- lldb_EmulateInstructionARM.h ----------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef lldb_EmulateInstructionARM_h_ #ifndef lldb_EmulateInstructionARM_h_
#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 {
// ITSession - Keep track of the IT Block progression. // ITSession - Keep track of the IT Block progression.
class ITSession { class ITSession {
public: public:
ITSession() : ITCounter(0), ITState(0) {} ITSession() : ITCounter(0), ITState(0) {}
~ITSession() {} ~ITSession() {}
▲ Show 20 Lines • Show All 763 Lines • Show Last 20 Lines

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

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
//===-- EmulateInstructionARM.cpp -------------------------------*- C++ -*-===// //===-- EmulateInstructionARM.cpp -------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include <stdlib.h> #include <stdlib.h>
#include "EmulateInstructionARM.h" #include "EmulateInstructionARM.h"
#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"
#include "Utility/ARM_DWARF_Registers.h" #include "Utility/ARM_DWARF_Registers.h"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#include "llvm/Support/MathExtras.h" // for SignExtend32 template function #include "llvm/Support/MathExtras.h" // for SignExtend32 template function
// and countTrailingZeros function // and countTrailingZeros function
▲ Show 20 Lines • Show All 14,979 Lines • Show Last 20 Lines

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

Show All 10 Lines
#define EmulateInstructionARM64_h_ #define EmulateInstructionARM64_h_
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// 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:
EmulateInstructionARM64(const lldb_private::ArchSpec &arch) EmulateInstructionARM64(const lldb_private::ArchSpec &arch)
: EmulateInstruction(arch), m_opcode_pstate(), m_emulated_pstate(), : EmulateInstruction(arch), m_opcode_pstate(), m_emulated_pstate(),
m_ignore_conditions(false) {} m_ignore_conditions(false) {}
static void Initialize(); static void Initialize();
▲ Show 20 Lines • Show All 177 Lines • Show Last 20 Lines

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

//===-- EmulateInstructionARM64.cpp ------------------------------*- C++-*-===// //===-- EmulateInstructionARM64.cpp ------------------------------*- C++-*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "EmulateInstructionARM64.h" #include "EmulateInstructionARM64.h"
#include <stdlib.h> #include <stdlib.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/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"
#include "Plugins/Process/Utility/lldb-arm64-register-enums.h" #include "Plugins/Process/Utility/lldb-arm64-register-enums.h"
#define GPR_OFFSET(idx) ((idx)*8) #define GPR_OFFSET(idx) ((idx)*8)
#define GPR_OFFSET_NAME(reg) 0 #define GPR_OFFSET_NAME(reg) 0
#define FPU_OFFSET(idx) ((idx)*16) #define FPU_OFFSET(idx) ((idx)*16)
▲ Show 20 Lines • Show All 1,195 Lines • Show Last 20 Lines

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

Show All 16 Lines
class MCRegisterInfo; class MCRegisterInfo;
class MCAsmInfo; class MCAsmInfo;
class MCContext; class MCContext;
class MCInstrInfo; class MCInstrInfo;
class MCInst; class MCInst;
} }
#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:
static void Initialize(); static void Initialize();
static void Terminate(); static void Terminate();
static lldb_private::ConstString GetPluginNameStatic(); static lldb_private::ConstString GetPluginNameStatic();
▲ Show 20 Lines • Show All 185 Lines • Show Last 20 Lines

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

//===-- EmulateInstructionMIPS.cpp -------------------------------*- C++ //===-- EmulateInstructionMIPS.cpp -------------------------------*- C++
//-*-===// //-*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "EmulateInstructionMIPS.h" #include "EmulateInstructionMIPS.h"
#include <stdlib.h> #include <stdlib.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/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"
#include "llvm/MC/MCDisassembler/MCDisassembler.h" #include "llvm/MC/MCDisassembler/MCDisassembler.h"
#include "llvm/MC/MCInst.h" #include "llvm/MC/MCInst.h"
#include "llvm/MC/MCInstrInfo.h" #include "llvm/MC/MCInstrInfo.h"
#include "llvm/MC/MCRegisterInfo.h" #include "llvm/MC/MCRegisterInfo.h"
#include "llvm/MC/MCSubtargetInfo.h" #include "llvm/MC/MCSubtargetInfo.h"
▲ Show 20 Lines • Show All 3,099 Lines • Show Last 20 Lines

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

Show All 9 Lines
#ifndef EmulateInstructionMIPS64_h_ #ifndef EmulateInstructionMIPS64_h_
#define EmulateInstructionMIPS64_h_ #define EmulateInstructionMIPS64_h_
// C Includes // C Includes
// C++ Includes // C++ Includes
// 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;
class MCSubtargetInfo; class MCSubtargetInfo;
class MCRegisterInfo; class MCRegisterInfo;
class MCAsmInfo; class MCAsmInfo;
class MCContext; class MCContext;
class MCInstrInfo; class MCInstrInfo;
▲ Show 20 Lines • Show All 160 Lines • Show Last 20 Lines

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

//===-- EmulateInstructionMIPS64.cpp -------------------------------*- C++ //===-- EmulateInstructionMIPS64.cpp -------------------------------*- C++
//-*-===// //-*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "EmulateInstructionMIPS64.h" #include "EmulateInstructionMIPS64.h"
#include <stdlib.h> #include <stdlib.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/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"
#include "llvm/MC/MCDisassembler/MCDisassembler.h" #include "llvm/MC/MCDisassembler/MCDisassembler.h"
#include "llvm/MC/MCInst.h" #include "llvm/MC/MCInst.h"
#include "llvm/MC/MCInstrInfo.h" #include "llvm/MC/MCInstrInfo.h"
#include "llvm/MC/MCRegisterInfo.h" #include "llvm/MC/MCRegisterInfo.h"
#include "llvm/MC/MCSubtargetInfo.h" #include "llvm/MC/MCSubtargetInfo.h"
▲ Show 20 Lines • Show All 2,344 Lines • Show Last 20 Lines

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

//===-- AddressSanitizerRuntime.cpp -----------------------------*- C++ -*-===// //===-- AddressSanitizerRuntime.cpp -----------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "AddressSanitizerRuntime.h" #include "AddressSanitizerRuntime.h"
#include "lldb/Breakpoint/StoppointCallbackContext.h" #include "lldb/Breakpoint/StoppointCallbackContext.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#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"
#include "lldb/Interpreter/CommandReturnObject.h" #include "lldb/Interpreter/CommandReturnObject.h"
#include "lldb/Symbol/Symbol.h" #include "lldb/Symbol/Symbol.h"
#include "lldb/Target/InstrumentationRuntimeStopInfo.h" #include "lldb/Target/InstrumentationRuntimeStopInfo.h"
#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"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
lldb::InstrumentationRuntimeSP lldb::InstrumentationRuntimeSP
AddressSanitizerRuntime::CreateInstance(const lldb::ProcessSP &process_sp) { AddressSanitizerRuntime::CreateInstance(const lldb::ProcessSP &process_sp) {
▲ Show 20 Lines • Show All 295 Lines • Show Last 20 Lines

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

Show All 9 Lines
#include "ThreadSanitizerRuntime.h" #include "ThreadSanitizerRuntime.h"
#include "Plugins/Process/Utility/HistoryThread.h" #include "Plugins/Process/Utility/HistoryThread.h"
#include "lldb/Breakpoint/StoppointCallbackContext.h" #include "lldb/Breakpoint/StoppointCallbackContext.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#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"
#include "lldb/Interpreter/CommandReturnObject.h" #include "lldb/Interpreter/CommandReturnObject.h"
#include "lldb/Symbol/Symbol.h" #include "lldb/Symbol/Symbol.h"
#include "lldb/Symbol/SymbolContext.h" #include "lldb/Symbol/SymbolContext.h"
#include "lldb/Symbol/Variable.h" #include "lldb/Symbol/Variable.h"
#include "lldb/Symbol/VariableList.h" #include "lldb/Symbol/VariableList.h"
#include "lldb/Target/InstrumentationRuntimeStopInfo.h" #include "lldb/Target/InstrumentationRuntimeStopInfo.h"
#include "lldb/Target/SectionLoadList.h" #include "lldb/Target/SectionLoadList.h"
#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;
lldb::InstrumentationRuntimeSP lldb::InstrumentationRuntimeSP
ThreadSanitizerRuntime::CreateInstance(const lldb::ProcessSP &process_sp) { ThreadSanitizerRuntime::CreateInstance(const lldb::ProcessSP &process_sp) {
return InstrumentationRuntimeSP(new ThreadSanitizerRuntime(process_sp)); return InstrumentationRuntimeSP(new ThreadSanitizerRuntime(process_sp));
} }
▲ Show 20 Lines • Show All 981 Lines • Show Last 20 Lines

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

Show All 12 Lines
#include "lldb/Breakpoint/Breakpoint.h" #include "lldb/Breakpoint/Breakpoint.h"
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.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/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"
#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/LLDBAssert.h" #include "lldb/Utility/LLDBAssert.h"
#include "lldb/Utility/StreamString.h"
#include "JITLoaderGDB.h" #include "JITLoaderGDB.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
//------------------------------------------------------------------ //------------------------------------------------------------------
// Debug Interface Structures // Debug Interface Structures
▲ Show 20 Lines • Show All 418 Lines • Show Last 20 Lines

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

Show All 13 Lines
// C++ Includes // C++ Includes
#include <set> #include <set>
#include <vector> #include <vector>
// Other libraries and framework includes // Other libraries and framework includes
#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 {
class CPlusPlusLanguage : public Language { class CPlusPlusLanguage : public Language {
public: public:
class MethodName { class MethodName {
public: public:
▲ Show 20 Lines • Show All 130 Lines • Show Last 20 Lines

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

Show All 17 Lines
#include <memory> #include <memory>
#include <mutex> #include <mutex>
#include <set> #include <set>
// Other libraries and framework includes // Other libraries and framework includes
#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"
#include "LibCxx.h" #include "LibCxx.h"
#include "LibCxxAtomic.h" #include "LibCxxAtomic.h"
#include "LibStdcpp.h" #include "LibStdcpp.h"
using namespace lldb; using namespace lldb;
▲ Show 20 Lines • Show All 1,122 Lines • Show Last 20 Lines

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

//===-- CxxStringTypes.h ----------------------------------------------*- C++ //===-- CxxStringTypes.h ----------------------------------------------*- C++
//-*-===// //-*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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 {
bool Char16StringSummaryProvider( bool Char16StringSummaryProvider(
ValueObject &valobj, Stream &stream, ValueObject &valobj, Stream &stream,
const TypeSummaryOptions &options); // char16_t* and unichar* const TypeSummaryOptions &options); // char16_t* and unichar*
bool Char32StringSummaryProvider( bool Char32StringSummaryProvider(
Show All 20 Lines

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

//===-- CxxStringTypes.cpp --------------------------------------*- C++ -*-===// //===-- CxxStringTypes.cpp --------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "CxxStringTypes.h" #include "CxxStringTypes.h"
#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"
#include "lldb/DataFormatters/StringPrinter.h" #include "lldb/DataFormatters/StringPrinter.h"
#include "lldb/DataFormatters/TypeSummary.h" #include "lldb/DataFormatters/TypeSummary.h"
#include "lldb/Host/Endian.h" #include "lldb/Host/Endian.h"
#include "lldb/Host/Time.h" #include "lldb/Host/Time.h"
#include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/ClangASTContext.h"
#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>
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
using namespace lldb_private::formatters; using namespace lldb_private::formatters;
bool lldb_private::formatters::Char16StringSummaryProvider( bool lldb_private::formatters::Char16StringSummaryProvider(
▲ Show 20 Lines • Show All 187 Lines • Show Last 20 Lines

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

//===-- LibCxx.h ---------------------------------------------------*- C++ //===-- LibCxx.h ---------------------------------------------------*- C++
//-*-===// //-*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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 {
bool LibcxxStringSummaryProvider( bool LibcxxStringSummaryProvider(
ValueObject &valobj, Stream &stream, ValueObject &valobj, Stream &stream,
const TypeSummaryOptions &options); // libc++ std::string const TypeSummaryOptions &options); // libc++ std::string
▲ Show 20 Lines • Show All 124 Lines • Show Last 20 Lines

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

Show All 9 Lines
#include "LibCxx.h" #include "LibCxx.h"
// C Includes // C Includes
// C++ Includes // C++ Includes
// 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/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"
#include "lldb/DataFormatters/StringPrinter.h" #include "lldb/DataFormatters/StringPrinter.h"
#include "lldb/DataFormatters/TypeSummary.h" #include "lldb/DataFormatters/TypeSummary.h"
#include "lldb/DataFormatters/VectorIterator.h" #include "lldb/DataFormatters/VectorIterator.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/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;
using namespace lldb_private::formatters; using namespace lldb_private::formatters;
bool lldb_private::formatters::LibcxxSmartPointerSummaryProvider( bool lldb_private::formatters::LibcxxSmartPointerSummaryProvider(
ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) { ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
ValueObjectSP valobj_sp(valobj.GetNonSyntheticValue()); ValueObjectSP valobj_sp(valobj.GetNonSyntheticValue());
▲ Show 20 Lines • Show All 698 Lines • Show Last 20 Lines

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

//===-- LibCxxAtomic.h -------------------------------------------*- C++ //===-- LibCxxAtomic.h -------------------------------------------*- C++
//-*-===// //-*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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 {
bool LibCxxAtomicSummaryProvider(ValueObject &valobj, Stream &stream, bool LibCxxAtomicSummaryProvider(ValueObject &valobj, Stream &stream,
const TypeSummaryOptions &options); const TypeSummaryOptions &options);
SyntheticChildrenFrontEnd * SyntheticChildrenFrontEnd *
LibcxxAtomicSyntheticFrontEndCreator(CXXSyntheticChildren *, LibcxxAtomicSyntheticFrontEndCreator(CXXSyntheticChildren *,
lldb::ValueObjectSP); lldb::ValueObjectSP);
} // namespace formatters } // namespace formatters
} // namespace lldb_private } // namespace lldb_private
#endif // liblldb_LibCxxAtomic_h_ #endif // liblldb_LibCxxAtomic_h_

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

//===-- LibCxxInitializerList.cpp -------------------------------*- C++ -*-===// //===-- LibCxxInitializerList.cpp -------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// 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;
using namespace lldb_private::formatters; using namespace lldb_private::formatters;
namespace lldb_private { namespace lldb_private {
namespace formatters { namespace formatters {
class LibcxxInitializerListSyntheticFrontEnd class LibcxxInitializerListSyntheticFrontEnd
▲ Show 20 Lines • Show All 103 Lines • Show Last 20 Lines

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

//===-- LibCxxList.cpp ------------------------------------------*- C++ -*-===// //===-- LibCxxList.cpp ------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#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;
using namespace lldb_private::formatters; using namespace lldb_private::formatters;
namespace { namespace {
class ListEntry { class ListEntry {
▲ Show 20 Lines • Show All 327 Lines • Show Last 20 Lines

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

//===-- LibCxxMap.cpp -------------------------------------------*- C++ -*-===// //===-- LibCxxMap.cpp -------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#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;
using namespace lldb_private::formatters; using namespace lldb_private::formatters;
class MapEntry { class MapEntry {
public: public:
MapEntry() = default; MapEntry() = default;
▲ Show 20 Lines • Show All 422 Lines • Show Last 20 Lines

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

//===-- LibCxxUnorderedMap.cpp ----------------------------------*- C++ -*-===// //===-- LibCxxUnorderedMap.cpp ----------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#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;
using namespace lldb_private::formatters; using namespace lldb_private::formatters;
namespace lldb_private { namespace lldb_private {
namespace formatters { namespace formatters {
class LibcxxStdUnorderedMapSyntheticFrontEnd class LibcxxStdUnorderedMapSyntheticFrontEnd
▲ Show 20 Lines • Show All 157 Lines • Show Last 20 Lines

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

//===-- LibCxxVector.cpp ----------------------------------------*- C++ -*-===// //===-- LibCxxVector.cpp ----------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// 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;
using namespace lldb_private::formatters; using namespace lldb_private::formatters;
namespace lldb_private { namespace lldb_private {
namespace formatters { namespace formatters {
class LibcxxStdVectorSyntheticFrontEnd : public SyntheticChildrenFrontEnd { class LibcxxStdVectorSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
▲ Show 20 Lines • Show All 115 Lines • Show Last 20 Lines

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

//===-- LibStdcpp.h ---------------------------------------------*- C++ -*-===// //===-- LibStdcpp.h ---------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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 {
bool LibStdcppStringSummaryProvider( bool LibStdcppStringSummaryProvider(
ValueObject &valobj, Stream &stream, ValueObject &valobj, Stream &stream,
const TypeSummaryOptions &options); // libcstdc++ c++11 std::string const TypeSummaryOptions &options); // libcstdc++ c++11 std::string
bool LibStdcppWStringSummaryProvider( bool LibStdcppWStringSummaryProvider(
Show All 36 Lines

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

//===-- LibStdcpp.cpp -------------------------------------------*- C++ -*-===// //===-- LibStdcpp.cpp -------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "LibStdcpp.h" #include "LibStdcpp.h"
// C Includes // C Includes
// C++ Includes // C++ Includes
// 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"
#include "lldb/DataFormatters/VectorIterator.h" #include "lldb/DataFormatters/VectorIterator.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;
using namespace lldb_private::formatters; using namespace lldb_private::formatters;
namespace { namespace {
class LibstdcppMapIteratorSyntheticFrontEnd : public SyntheticChildrenFrontEnd { class LibstdcppMapIteratorSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
▲ Show 20 Lines • Show All 398 Lines • Show Last 20 Lines

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

//===-- LibStdcppTuple.cpp --------------------------------------*- C++ -*-===// //===-- LibStdcppTuple.cpp --------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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>
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
using namespace lldb_private::formatters; using namespace lldb_private::formatters;
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

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

//===-- LibStdcppUniquePointer.cpp ------------------------------*- C++ -*-===// //===-- LibStdcppUniquePointer.cpp ------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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>
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
using namespace lldb_private::formatters; using namespace lldb_private::formatters;
▲ Show 20 Lines • Show All 128 Lines • Show Last 20 Lines

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

Show All 15 Lines
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
// 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 {
bool GoStringSummaryProvider(ValueObject &valobj, Stream &stream, bool GoStringSummaryProvider(ValueObject &valobj, Stream &stream,
const TypeSummaryOptions &options); const TypeSummaryOptions &options);
SyntheticChildrenFrontEnd * SyntheticChildrenFrontEnd *
GoSliceSyntheticFrontEndCreator(CXXSyntheticChildren *, lldb::ValueObjectSP); GoSliceSyntheticFrontEndCreator(CXXSyntheticChildren *, lldb::ValueObjectSP);
} // namespace formatters } // namespace formatters
} // namespace lldb_private } // namespace lldb_private
#endif // liblldb_GoFormatterFunctions_h_ #endif // liblldb_GoFormatterFunctions_h_

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

Show All 12 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
#include <vector> #include <vector>
// Other libraries and framework includes // Other libraries and framework includes
#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 {
class GoLanguage : public Language { class GoLanguage : public Language {
public: public:
GoLanguage() = default; GoLanguage() = default;
Show All 33 Lines

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

Show All 13 Lines
#include <mutex> #include <mutex>
// Other libraries and framework includes // Other libraries and framework includes
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
// 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;
using namespace lldb_private::formatters; using namespace lldb_private::formatters;
void GoLanguage::Initialize() { void GoLanguage::Initialize() {
PluginManager::RegisterPlugin(GetPluginNameStatic(), "Go Language", PluginManager::RegisterPlugin(GetPluginNameStatic(), "Go Language",
CreateInstance); CreateInstance);
▲ Show 20 Lines • Show All 93 Lines • Show Last 20 Lines

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

Show All 12 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
#include <vector> #include <vector>
// Other libraries and framework includes // Other libraries and framework includes
#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 {
class JavaLanguage : public Language { class JavaLanguage : public Language {
public: public:
lldb::LanguageType GetLanguageType() const override { lldb::LanguageType GetLanguageType() const override {
return lldb::eLanguageTypeJava; return lldb::eLanguageTypeJava;
Show All 22 Lines

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

Show All 13 Lines
#include <mutex> #include <mutex>
// Other libraries and framework includes // Other libraries and framework includes
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
// 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;
using namespace lldb_private::formatters; using namespace lldb_private::formatters;
void JavaLanguage::Initialize() { void JavaLanguage::Initialize() {
PluginManager::RegisterPlugin(GetPluginNameStatic(), "Java Language", PluginManager::RegisterPlugin(GetPluginNameStatic(), "Java Language",
CreateInstance); CreateInstance);
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

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

Show All 13 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
#include <vector> #include <vector>
// Other libraries and framework includes // Other libraries and framework includes
#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 {
class OCamlLanguage : public Language { class OCamlLanguage : public Language {
public: public:
lldb::LanguageType GetLanguageType() const override { lldb::LanguageType GetLanguageType() const override {
return lldb::eLanguageTypeOCaml; return lldb::eLanguageTypeOCaml;
Show All 20 Lines

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

Show All 13 Lines
#include <functional> #include <functional>
#include <mutex> #include <mutex>
// Other libraries and framework includes // Other libraries and framework includes
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
// 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;
void OCamlLanguage::Initialize() { void OCamlLanguage::Initialize() {
PluginManager::RegisterPlugin(GetPluginNameStatic(), "OCaml Language", PluginManager::RegisterPlugin(GetPluginNameStatic(), "OCaml Language",
CreateInstance); CreateInstance);
} }
Show All 29 Lines

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

//===-- CF.h ---------------------------------------------------*- C++ -*-===// //===-- CF.h ---------------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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 {
bool CFBagSummaryProvider(ValueObject &valobj, Stream &stream, bool CFBagSummaryProvider(ValueObject &valobj, Stream &stream,
const TypeSummaryOptions &options); const TypeSummaryOptions &options);
bool CFBinaryHeapSummaryProvider(ValueObject &valobj, Stream &stream, bool CFBinaryHeapSummaryProvider(ValueObject &valobj, Stream &stream,
const TypeSummaryOptions &options); const TypeSummaryOptions &options);
Show All 10 Lines

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

//===-- CF.cpp ----------------------------------------------------*- C++ //===-- CF.cpp ----------------------------------------------------*- C++
//-*-===// //-*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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"
#include "lldb/Host/Endian.h" #include "lldb/Host/Endian.h"
#include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/ClangASTContext.h"
#include "lldb/Target/Language.h" #include "lldb/Target/Language.h"
#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;
using namespace lldb_private::formatters; using namespace lldb_private::formatters;
bool lldb_private::formatters::CFAbsoluteTimeSummaryProvider( bool lldb_private::formatters::CFAbsoluteTimeSummaryProvider(
ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) { ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
time_t epoch = GetOSXEpoch(); time_t epoch = GetOSXEpoch();
▲ Show 20 Lines • Show All 271 Lines • Show Last 20 Lines

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

//===-- Cocoa.h ---------------------------------------------------*- C++ //===-- Cocoa.h ---------------------------------------------------*- C++
//-*-===// //-*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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 {
bool NSIndexSetSummaryProvider(ValueObject &valobj, Stream &stream, bool NSIndexSetSummaryProvider(ValueObject &valobj, Stream &stream,
const TypeSummaryOptions &options); const TypeSummaryOptions &options);
bool NSArraySummaryProvider(ValueObject &valobj, Stream &stream, bool NSArraySummaryProvider(ValueObject &valobj, Stream &stream,
const TypeSummaryOptions &options); const TypeSummaryOptions &options);
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

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

//===-- Cocoa.cpp -----------------------------------------------*- C++ -*-===// //===-- Cocoa.cpp -----------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#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"
#include "lldb/DataFormatters/StringPrinter.h" #include "lldb/DataFormatters/StringPrinter.h"
#include "lldb/DataFormatters/TypeSummary.h" #include "lldb/DataFormatters/TypeSummary.h"
#include "lldb/Host/Endian.h" #include "lldb/Host/Endian.h"
#include "lldb/Host/Time.h" #include "lldb/Host/Time.h"
#include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/ClangASTContext.h"
#include "lldb/Target/Language.h" #include "lldb/Target/Language.h"
#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"
#include "NSString.h" #include "NSString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
using namespace lldb_private::formatters; using namespace lldb_private::formatters;
▲ Show 20 Lines • Show All 904 Lines • Show Last 20 Lines

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

//===-- CoreMedia.h -----------------------------------------------*- C++ //===-- CoreMedia.h -----------------------------------------------*- C++
//-*-===// //-*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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 {
bool CMTimeSummaryProvider(ValueObject &valobj, Stream &stream, bool CMTimeSummaryProvider(ValueObject &valobj, Stream &stream,
const TypeSummaryOptions &options); const TypeSummaryOptions &options);
} // namespace formatters } // namespace formatters
} // namespace lldb_private } // namespace lldb_private
#endif // liblldb_CF_h_ #endif // liblldb_CF_h_

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

Show All 11 Lines
// Other libraries and framework includes // Other libraries and framework includes
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
// Project includes // Project includes
#include "Cocoa.h" #include "Cocoa.h"
#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"
#include "lldb/Expression/FunctionCaller.h" #include "lldb/Expression/FunctionCaller.h"
#include "lldb/Host/Endian.h" #include "lldb/Host/Endian.h"
#include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/ClangASTContext.h"
#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;
using namespace lldb_private::formatters; using namespace lldb_private::formatters;
namespace lldb_private { namespace lldb_private {
namespace formatters { namespace formatters {
std::map<ConstString, CXXFunctionSummaryFormat::Callback> & std::map<ConstString, CXXFunctionSummaryFormat::Callback> &
▲ Show 20 Lines • Show All 671 Lines • Show Last 20 Lines

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

//===-- NSDictionary.h ---------------------------------------------------*- C++ //===-- NSDictionary.h ---------------------------------------------------*- C++
//-*-===// //-*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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>
namespace lldb_private { namespace lldb_private {
namespace formatters { namespace formatters {
template <bool name_entries> template <bool name_entries>
bool NSDictionarySummaryProvider(ValueObject &valobj, Stream &stream, bool NSDictionarySummaryProvider(ValueObject &valobj, Stream &stream,
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

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

Show All 12 Lines
// Other libraries and framework includes // Other libraries and framework includes
#include "clang/AST/DeclCXX.h" #include "clang/AST/DeclCXX.h"
// Project includes // Project includes
#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"
#include "lldb/Host/Endian.h" #include "lldb/Host/Endian.h"
#include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/ClangASTContext.h"
#include "lldb/Target/Language.h" #include "lldb/Target/Language.h"
#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;
using namespace lldb_private::formatters; using namespace lldb_private::formatters;
NSDictionary_Additionals::AdditionalFormatterMatching::Prefix::Prefix( NSDictionary_Additionals::AdditionalFormatterMatching::Prefix::Prefix(
ConstString p) ConstString p)
: m_prefix(p) {} : m_prefix(p) {}
▲ Show 20 Lines • Show All 703 Lines • Show Last 20 Lines

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

Show All 10 Lines
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
#include "clang/AST/DeclCXX.h" #include "clang/AST/DeclCXX.h"
// Project includes // Project includes
#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"
#include "lldb/Host/Endian.h" #include "lldb/Host/Endian.h"
#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"
#include "Plugins/Language/ObjC/NSString.h" #include "Plugins/Language/ObjC/NSString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
using namespace lldb_private::formatters; using namespace lldb_private::formatters;
▲ Show 20 Lines • Show All 185 Lines • Show Last 20 Lines

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

Show All 10 Lines
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
#include "clang/AST/DeclCXX.h" #include "clang/AST/DeclCXX.h"
// Project includes // Project includes
#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"
#include "lldb/Host/Endian.h" #include "lldb/Host/Endian.h"
#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"
#include "Plugins/Language/ObjC/NSString.h" #include "Plugins/Language/ObjC/NSString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
using namespace lldb_private::formatters; using namespace lldb_private::formatters;
▲ Show 20 Lines • Show All 181 Lines • Show Last 20 Lines

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

//===-- NSSet.h ---------------------------------------------------*- C++ //===-- NSSet.h ---------------------------------------------------*- C++
//-*-===// //-*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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 {
template <bool cf_style> template <bool cf_style>
bool NSSetSummaryProvider(ValueObject &valobj, Stream &stream, bool NSSetSummaryProvider(ValueObject &valobj, Stream &stream,
const TypeSummaryOptions &options); const TypeSummaryOptions &options);
SyntheticChildrenFrontEnd *NSSetSyntheticFrontEndCreator(CXXSyntheticChildren *, SyntheticChildrenFrontEnd *NSSetSyntheticFrontEndCreator(CXXSyntheticChildren *,
Show All 14 Lines

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

//===-- NSSet.cpp -----------------------------------------------*- C++ -*-===// //===-- NSSet.cpp -----------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#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"
#include "lldb/Host/Endian.h" #include "lldb/Host/Endian.h"
#include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/ClangASTContext.h"
#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;
using namespace lldb_private::formatters; using namespace lldb_private::formatters;
std::map<ConstString, CXXFunctionSummaryFormat::Callback> & std::map<ConstString, CXXFunctionSummaryFormat::Callback> &
NSSet_Additionals::GetAdditionalSummaries() { NSSet_Additionals::GetAdditionalSummaries() {
static std::map<ConstString, CXXFunctionSummaryFormat::Callback> g_map; static std::map<ConstString, CXXFunctionSummaryFormat::Callback> g_map;
▲ Show 20 Lines • Show All 566 Lines • Show Last 20 Lines

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

//===-- NSString.h ---------------------------------------------------*- C++ //===-- NSString.h ---------------------------------------------------*- C++
//-*-===// //-*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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 {
bool NSStringSummaryProvider(ValueObject &valobj, Stream &stream, bool NSStringSummaryProvider(ValueObject &valobj, Stream &stream,
const TypeSummaryOptions &options); const TypeSummaryOptions &options);
bool NSTaggedString_SummaryProvider( bool NSTaggedString_SummaryProvider(
ValueObject &valobj, ObjCLanguageRuntime::ClassDescriptorSP descriptor, ValueObject &valobj, ObjCLanguageRuntime::ClassDescriptorSP descriptor,
Show All 17 Lines

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

//===-- NSString.cpp ----------------------------------------------*- C++ //===-- NSString.cpp ----------------------------------------------*- C++
//-*-===// //-*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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"
#include "lldb/DataFormatters/StringPrinter.h" #include "lldb/DataFormatters/StringPrinter.h"
#include "lldb/Host/Endian.h" #include "lldb/Host/Endian.h"
#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;
using namespace lldb_private::formatters; using namespace lldb_private::formatters;
std::map<ConstString, CXXFunctionSummaryFormat::Callback> & std::map<ConstString, CXXFunctionSummaryFormat::Callback> &
NSString_Additionals::GetAdditionalSummaries() { NSString_Additionals::GetAdditionalSummaries() {
static std::map<ConstString, CXXFunctionSummaryFormat::Callback> g_map; static std::map<ConstString, CXXFunctionSummaryFormat::Callback> g_map;
▲ Show 20 Lines • Show All 373 Lines • Show Last 20 Lines

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

Show All 11 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
#include <cstring> #include <cstring>
#include <vector> #include <vector>
// 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 {
class ObjCLanguage : public Language { class ObjCLanguage : public Language {
public: public:
class MethodName { class MethodName {
public: public:
▲ Show 20 Lines • Show All 136 Lines • Show Last 20 Lines

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

Show All 9 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
#include <mutex> #include <mutex>
// Other libraries and framework includes // Other libraries and framework includes
// 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"
#include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/ClangASTContext.h"
#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"
#include "CoreMedia.h" #include "CoreMedia.h"
#include "NSDictionary.h" #include "NSDictionary.h"
#include "NSSet.h" #include "NSSet.h"
#include "NSString.h" #include "NSString.h"
▲ Show 20 Lines • Show All 1,059 Lines • Show Last 20 Lines

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

//===-- ObjCPlusPlusLanguage.cpp --------------------------------------*- C++ //===-- ObjCPlusPlusLanguage.cpp --------------------------------------*- C++
//-*-===// //-*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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;
void ObjCPlusPlusLanguage::Initialize() { void ObjCPlusPlusLanguage::Initialize() {
PluginManager::RegisterPlugin(GetPluginNameStatic(), "Objective-C++ Language", PluginManager::RegisterPlugin(GetPluginNameStatic(), "Objective-C++ Language",
CreateInstance); CreateInstance);
} }
Show All 30 Lines

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

//===-- ItaniumABILanguageRuntime.cpp --------------------------------------*- //===-- ItaniumABILanguageRuntime.cpp --------------------------------------*-
//C++ -*-===// //C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/Scalar.h" #include "lldb/Core/Scalar.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/Core/ValueObjectMemory.h" #include "lldb/Core/ValueObjectMemory.h"
#include "lldb/Interpreter/CommandObject.h" #include "lldb/Interpreter/CommandObject.h"
#include "lldb/Interpreter/CommandObjectMultiword.h" #include "lldb/Interpreter/CommandObjectMultiword.h"
#include "lldb/Interpreter/CommandReturnObject.h" #include "lldb/Interpreter/CommandReturnObject.h"
#include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/ClangASTContext.h"
#include "lldb/Symbol/Symbol.h" #include "lldb/Symbol/Symbol.h"
#include "lldb/Symbol/SymbolFile.h" #include "lldb/Symbol/SymbolFile.h"
#include "lldb/Symbol/TypeList.h" #include "lldb/Symbol/TypeList.h"
#include "lldb/Target/Process.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/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>
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
static const char *vtable_demangled_prefix = "vtable for "; static const char *vtable_demangled_prefix = "vtable for ";
▲ Show 20 Lines • Show All 530 Lines • Show Last 20 Lines

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

//===-- GoLanguageRuntime.cpp --------------------------------------*- C++ //===-- GoLanguageRuntime.cpp --------------------------------------*- C++
//-*-===// //-*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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"
#include "lldb/Core/Scalar.h" #include "lldb/Core/Scalar.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/Core/ValueObjectMemory.h" #include "lldb/Core/ValueObjectMemory.h"
#include "lldb/Symbol/GoASTContext.h" #include "lldb/Symbol/GoASTContext.h"
#include "lldb/Symbol/Symbol.h" #include "lldb/Symbol/Symbol.h"
#include "lldb/Symbol/SymbolFile.h" #include "lldb/Symbol/SymbolFile.h"
#include "lldb/Symbol/TypeList.h" #include "lldb/Symbol/TypeList.h"
#include "lldb/Target/Process.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/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>
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
namespace { namespace {
▲ Show 20 Lines • Show All 176 Lines • Show Last 20 Lines

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

//===-- AppleObjCRuntime.cpp -------------------------------------*- C++ //===-- AppleObjCRuntime.cpp -------------------------------------*- C++
//-*-===// //-*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "AppleObjCRuntime.h" #include "AppleObjCRuntime.h"
#include "AppleObjCTrampolineHandler.h" #include "AppleObjCTrampolineHandler.h"
#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"
#include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/ClangASTContext.h"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
#include "lldb/Target/ExecutionContext.h" #include "lldb/Target/ExecutionContext.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/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>
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
static constexpr std::chrono::seconds g_po_function_timeout(15); static constexpr std::chrono::seconds g_po_function_timeout(15);
▲ Show 20 Lines • Show All 445 Lines • Show Last 20 Lines

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

Show All 9 Lines
#include "AppleObjCRuntimeV1.h" #include "AppleObjCRuntimeV1.h"
#include "AppleObjCDeclVendor.h" #include "AppleObjCDeclVendor.h"
#include "AppleObjCTrampolineHandler.h" #include "AppleObjCTrampolineHandler.h"
#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"
#include "lldb/Symbol/Symbol.h" #include "lldb/Symbol/Symbol.h"
#include "lldb/Target/ExecutionContext.h" #include "lldb/Target/ExecutionContext.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/ConstString.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/StreamString.h"
#include <vector> #include <vector>
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
AppleObjCRuntimeV1::AppleObjCRuntimeV1(Process *process) AppleObjCRuntimeV1::AppleObjCRuntimeV1(Process *process)
: AppleObjCRuntime(process), m_hash_signature(), : AppleObjCRuntime(process), m_hash_signature(),
▲ Show 20 Lines • Show All 398 Lines • Show Last 20 Lines

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

Show All 18 Lines
#include "clang/AST/DeclObjC.h" #include "clang/AST/DeclObjC.h"
// Project includes // Project includes
#include "lldb/Core/ClangForward.h" #include "lldb/Core/ClangForward.h"
#include "lldb/Symbol/CompilerType.h" #include "lldb/Symbol/CompilerType.h"
#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"
#include "lldb/Expression/FunctionCaller.h" #include "lldb/Expression/FunctionCaller.h"
#include "lldb/Expression/UtilityFunction.h" #include "lldb/Expression/UtilityFunction.h"
#include "lldb/Host/StringConvert.h" #include "lldb/Host/StringConvert.h"
#include "lldb/Interpreter/CommandObject.h" #include "lldb/Interpreter/CommandObject.h"
#include "lldb/Interpreter/CommandObjectMultiword.h" #include "lldb/Interpreter/CommandObjectMultiword.h"
#include "lldb/Interpreter/CommandReturnObject.h" #include "lldb/Interpreter/CommandReturnObject.h"
#include "lldb/Interpreter/OptionValueBoolean.h" #include "lldb/Interpreter/OptionValueBoolean.h"
#include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/ClangASTContext.h"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
#include "lldb/Symbol/Symbol.h" #include "lldb/Symbol/Symbol.h"
#include "lldb/Symbol/TypeList.h" #include "lldb/Symbol/TypeList.h"
#include "lldb/Symbol/VariableList.h" #include "lldb/Symbol/VariableList.h"
#include "lldb/Target/ExecutionContext.h" #include "lldb/Target/ExecutionContext.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"
#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"
#include "AppleObjCRuntimeV2.h" #include "AppleObjCRuntimeV2.h"
#include "AppleObjCTrampolineHandler.h" #include "AppleObjCTrampolineHandler.h"
#include "AppleObjCTypeEncodingParser.h" #include "AppleObjCTypeEncodingParser.h"
using namespace lldb; using namespace lldb;
▲ Show 20 Lines • Show All 2,384 Lines • Show Last 20 Lines

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

Show All 11 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#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"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.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"
#include "lldb/Expression/UserExpression.h" #include "lldb/Expression/UserExpression.h"
#include "lldb/Expression/UtilityFunction.h" #include "lldb/Expression/UtilityFunction.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
#include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/ClangASTContext.h"
#include "lldb/Symbol/Symbol.h" #include "lldb/Symbol/Symbol.h"
#include "lldb/Target/ABI.h" #include "lldb/Target/ABI.h"
#include "lldb/Target/ExecutionContext.h" #include "lldb/Target/ExecutionContext.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/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"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
const char *AppleObjCTrampolineHandler::g_lookup_implementation_function_name = const char *AppleObjCTrampolineHandler::g_lookup_implementation_function_name =
"__lldb_objc_find_implementation_for_selector"; "__lldb_objc_find_implementation_for_selector";
▲ Show 20 Lines • Show All 1,102 Lines • Show Last 20 Lines

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

Show All 11 Lines
// Other libraries and framework includes // Other libraries and framework includes
#include "llvm/ADT/StringSwitch.h" #include "llvm/ADT/StringSwitch.h"
// Project includes // Project includes
#include "RenderScriptRuntime.h" #include "RenderScriptRuntime.h"
#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"
#include "lldb/Host/StringConvert.h" #include "lldb/Host/StringConvert.h"
#include "lldb/Interpreter/Args.h" #include "lldb/Interpreter/Args.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"
#include "lldb/Interpreter/Options.h" #include "lldb/Interpreter/Options.h"
#include "lldb/Symbol/Function.h" #include "lldb/Symbol/Function.h"
#include "lldb/Symbol/Symbol.h" #include "lldb/Symbol/Symbol.h"
#include "lldb/Symbol/Type.h" #include "lldb/Symbol/Type.h"
#include "lldb/Symbol/VariableList.h" #include "lldb/Symbol/VariableList.h"
#include "lldb/Target/Process.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/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;
using namespace lldb_renderscript; using namespace lldb_renderscript;
#define FMT_COORD "(%" PRIu32 ", %" PRIu32 ", %" PRIu32 ")" #define FMT_COORD "(%" PRIu32 ", %" PRIu32 ", %" PRIu32 ")"
namespace { namespace {
▲ Show 20 Lines • Show All 5,001 Lines • Show Last 20 Lines

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

//===-- RenderScriptScriptGroup.cpp -----------------------------*- C++ -*-===// //===-- RenderScriptScriptGroup.cpp -----------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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"
#include "lldb/Interpreter/Args.h" #include "lldb/Interpreter/Args.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"
#include "lldb/Interpreter/Options.h" #include "lldb/Interpreter/Options.h"
#include "lldb/Symbol/Symbol.h" #include "lldb/Symbol/Symbol.h"
#include "lldb/Symbol/Type.h" #include "lldb/Symbol/Type.h"
#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"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
using namespace lldb_renderscript; using namespace lldb_renderscript;
▲ Show 20 Lines • Show All 128 Lines • Show Last 20 Lines

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

//===-- ObjectContainerBSDArchive.h -----------------------------*- C++ -*-===// //===-- ObjectContainerBSDArchive.h -----------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef liblldb_ObjectContainerBSDArchive_h_ #ifndef liblldb_ObjectContainerBSDArchive_h_
#define liblldb_ObjectContainerBSDArchive_h_ #define liblldb_ObjectContainerBSDArchive_h_
// 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"
// C Includes // C Includes
// C++ Includes // C++ Includes
#include <mutex> #include <mutex>
▲ Show 20 Lines • Show All 151 Lines • Show Last 20 Lines

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

Show All 26 Lines
#include <ar.h> #include <ar.h>
#endif #endif
#include "lldb/Core/ArchSpec.h" #include "lldb/Core/ArchSpec.h"
#include "lldb/Core/DataBuffer.h" #include "lldb/Core/DataBuffer.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/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;
ObjectContainerBSDArchive::Object::Object() ObjectContainerBSDArchive::Object::Object()
: ar_name(), ar_date(0), ar_uid(0), ar_gid(0), ar_mode(0), ar_size(0), : ar_name(), ar_date(0), ar_uid(0), ar_gid(0), ar_mode(0), ar_size(0),
ar_file_offset(0), ar_file_size(0) {} ar_file_offset(0), ar_file_size(0) {}
▲ Show 20 Lines • Show All 469 Lines • Show Last 20 Lines

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

//===-- ObjectContainerUniversalMachO.cpp -----------------------*- C++ -*-===// //===-- ObjectContainerUniversalMachO.cpp -----------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "ObjectContainerUniversalMachO.h" #include "ObjectContainerUniversalMachO.h"
#include "lldb/Core/ArchSpec.h" #include "lldb/Core/ArchSpec.h"
#include "lldb/Core/DataBuffer.h" #include "lldb/Core/DataBuffer.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/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;
using namespace llvm::MachO; using namespace llvm::MachO;
void ObjectContainerUniversalMachO::Initialize() { void ObjectContainerUniversalMachO::Initialize() {
PluginManager::RegisterPlugin(GetPluginNameStatic(), PluginManager::RegisterPlugin(GetPluginNameStatic(),
GetPluginDescriptionStatic(), CreateInstance, GetPluginDescriptionStatic(), CreateInstance,
▲ Show 20 Lines • Show All 213 Lines • Show Last 20 Lines

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

//===-- ELFHeader.cpp ----------------------------------------- -*- C++ -*-===// //===-- ELFHeader.cpp ----------------------------------------- -*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include <cstring> #include <cstring>
#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"
using namespace elf; using namespace elf;
using namespace lldb; using namespace lldb;
using namespace llvm::ELF; using namespace llvm::ELF;
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
▲ Show 20 Lines • Show All 426 Lines • Show Last 20 Lines

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

Show All 9 Lines
#include "ObjectFileELF.h" #include "ObjectFileELF.h"
#include <algorithm> #include <algorithm>
#include <cassert> #include <cassert>
#include <unordered_map> #include <unordered_map>
#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"
#include "llvm/Support/ARMBuildAttributes.h" #include "llvm/Support/ARMBuildAttributes.h"
#include "llvm/Support/MathExtras.h" #include "llvm/Support/MathExtras.h"
#include "llvm/Support/MipsABIFlags.h" #include "llvm/Support/MipsABIFlags.h"
#define CASE_AND_STREAM(s, def, width) \ #define CASE_AND_STREAM(s, def, width) \
▲ Show 20 Lines • Show All 3,378 Lines • Show Last 20 Lines

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

Show All 17 Lines
#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/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"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
#include "lldb/Target/Platform.h" #include "lldb/Target/Platform.h"
#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"
#endif #endif
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
▲ Show 20 Lines • Show All 224 Lines • Show Last 20 Lines

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

Show All 14 Lines
// Project includes // Project includes
#include "Plugins/Process/Utility/RegisterContextDarwin_arm.h" #include "Plugins/Process/Utility/RegisterContextDarwin_arm.h"
#include "Plugins/Process/Utility/RegisterContextDarwin_arm64.h" #include "Plugins/Process/Utility/RegisterContextDarwin_arm64.h"
#include "Plugins/Process/Utility/RegisterContextDarwin_i386.h" #include "Plugins/Process/Utility/RegisterContextDarwin_i386.h"
#include "Plugins/Process/Utility/RegisterContextDarwin_x86_64.h" #include "Plugins/Process/Utility/RegisterContextDarwin_x86_64.h"
#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"
#include "lldb/Core/ModuleSpec.h" #include "lldb/Core/ModuleSpec.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#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"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Symbol/DWARFCallFrameInfo.h" #include "lldb/Symbol/DWARFCallFrameInfo.h"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
#include "lldb/Target/DynamicLoader.h" #include "lldb/Target/DynamicLoader.h"
#include "lldb/Target/MemoryRegionInfo.h" #include "lldb/Target/MemoryRegionInfo.h"
#include "lldb/Target/Platform.h" #include "lldb/Target/Platform.h"
#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/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"
#include "ObjectFileMachO.h" #include "ObjectFileMachO.h"
#if defined(__APPLE__) && \ #if defined(__APPLE__) && \
(defined(__arm__) || defined(__arm64__) || defined(__aarch64__)) (defined(__arm__) || defined(__arm64__) || defined(__aarch64__))
// GetLLDBSharedCacheUUID() needs to call dlsym() // GetLLDBSharedCacheUUID() needs to call dlsym()
▲ Show 20 Lines • Show All 6,040 Lines • Show Last 20 Lines

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

Show All 15 Lines
#include "lldb/Core/DataBuffer.h" #include "lldb/Core/DataBuffer.h"
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/FileSpecList.h" #include "lldb/Core/FileSpecList.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/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"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
#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
#define OPT_HEADER_MAGIC_PE32 0x010b #define OPT_HEADER_MAGIC_PE32 0x010b
#define OPT_HEADER_MAGIC_PE32_PLUS 0x020b #define OPT_HEADER_MAGIC_PE32_PLUS 0x020b
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
▲ Show 20 Lines • Show All 997 Lines • Show Last 20 Lines

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

Show All 18 Lines
#include "Plugins/Process/Utility/RegisterContextMemory.h" #include "Plugins/Process/Utility/RegisterContextMemory.h"
#include "Plugins/Process/Utility/ThreadMemory.h" #include "Plugins/Process/Utility/ThreadMemory.h"
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.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"
#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"
#include "lldb/Interpreter/OptionGroupUInt64.h" #include "lldb/Interpreter/OptionGroupUInt64.h"
#include "lldb/Interpreter/OptionValueProperties.h" #include "lldb/Interpreter/OptionValueProperties.h"
#include "lldb/Interpreter/Options.h" #include "lldb/Interpreter/Options.h"
#include "lldb/Interpreter/Property.h" #include "lldb/Interpreter/Property.h"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
#include "lldb/Symbol/Type.h" #include "lldb/Symbol/Type.h"
#include "lldb/Symbol/VariableList.h" #include "lldb/Symbol/VariableList.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/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;
namespace { namespace {
static PropertyDefinition g_properties[] = { static PropertyDefinition g_properties[] = {
{"enable", OptionValue::eTypeBoolean, true, true, nullptr, nullptr, {"enable", OptionValue::eTypeBoolean, true, true, nullptr, nullptr,
▲ Show 20 Lines • Show All 449 Lines • Show Last 20 Lines

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

Show All 17 Lines
#include "Plugins/Process/Utility/RegisterContextMemory.h" #include "Plugins/Process/Utility/RegisterContextMemory.h"
#include "Plugins/Process/Utility/ThreadMemory.h" #include "Plugins/Process/Utility/ThreadMemory.h"
#include "lldb/Core/ArchSpec.h" #include "lldb/Core/ArchSpec.h"
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.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"
#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"
#include "lldb/Interpreter/ScriptInterpreter.h" #include "lldb/Interpreter/ScriptInterpreter.h"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
#include "lldb/Symbol/VariableList.h" #include "lldb/Symbol/VariableList.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/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;
void OperatingSystemPython::Initialize() { void OperatingSystemPython::Initialize() {
PluginManager::RegisterPlugin(GetPluginNameStatic(), PluginManager::RegisterPlugin(GetPluginNameStatic(),
GetPluginDescriptionStatic(), CreateInstance, GetPluginDescriptionStatic(), CreateInstance,
nullptr); nullptr);
▲ Show 20 Lines • Show All 372 Lines • Show Last 20 Lines

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

//===-- AdbClient.h ---------------------------------------------*- C++ -*-===// //===-- AdbClient.h ---------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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>
#include <memory> #include <memory>
#include <string> #include <string>
#include <vector> #include <vector>
namespace lldb_private { namespace lldb_private {
▲ Show 20 Lines • Show All 119 Lines • Show Last 20 Lines

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

Show All 13 Lines
#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
#include "llvm/Support/FileUtilities.h" #include "llvm/Support/FileUtilities.h"
#include "lldb/Core/DataBuffer.h" #include "lldb/Core/DataBuffer.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/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>
#include <algorithm> #include <algorithm>
#include <cstdlib> #include <cstdlib>
#include <fstream> #include <fstream>
#include <sstream> #include <sstream>
▲ Show 20 Lines • Show All 611 Lines • Show Last 20 Lines

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

//===-- PlatformAndroidRemoteGDBServer.cpp ----------------------*- C++ -*-===// //===-- PlatformAndroidRemoteGDBServer.cpp ----------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// 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"
#include <sstream> #include <sstream>
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
▲ Show 20 Lines • Show All 211 Lines • Show Last 20 Lines

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

Show All 16 Lines
#endif #endif
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#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;
using namespace lldb_private::platform_freebsd; using namespace lldb_private::platform_freebsd;
PlatformSP PlatformFreeBSD::CreateInstance(bool force, const ArchSpec *arch) { PlatformSP PlatformFreeBSD::CreateInstance(bool force, const ArchSpec *arch) {
// The only time we create an instance is when we are creating a remote // The only time we create an instance is when we are creating a remote
// freebsd platform // freebsd platform
▲ Show 20 Lines • Show All 472 Lines • Show Last 20 Lines

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

Show All 9 Lines
#include "PlatformKalimba.h" #include "PlatformKalimba.h"
#include "lldb/Host/Config.h" #include "lldb/Host/Config.h"
// C++ Includes // C++ Includes
// 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;
static uint32_t g_initialize_count = 0; static uint32_t g_initialize_count = 0;
PlatformSP PlatformKalimba::CreateInstance(bool force, const ArchSpec *arch) { PlatformSP PlatformKalimba::CreateInstance(bool force, const ArchSpec *arch) {
bool create = force; bool create = force;
▲ Show 20 Lines • Show All 140 Lines • Show Last 20 Lines

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

Show All 15 Lines
#include <sys/utsname.h> #include <sys/utsname.h>
#endif #endif
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// 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.
#define MAP_PRIVATE 2 #define MAP_PRIVATE 2
#define MAP_ANON 0x20 #define MAP_ANON 0x20
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
▲ Show 20 Lines • Show All 547 Lines • Show Last 20 Lines

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

Show All 13 Lines
#include <dlfcn.h> #include <dlfcn.h>
#endif #endif
// C++ Includes // C++ Includes
#include <mutex> #include <mutex>
#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;
#if !defined(__APPLE__) #if !defined(__APPLE__)
#define UNSUPPORTED_ERROR ("Apple simulators aren't supported on this platform") #define UNSUPPORTED_ERROR ("Apple simulators aren't supported on this platform")
#endif #endif
▲ Show 20 Lines • Show All 235 Lines • Show Last 20 Lines

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

Show All 9 Lines
#include "PlatformAppleTVSimulator.h" #include "PlatformAppleTVSimulator.h"
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// 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;
//------------------------------------------------------------------ //------------------------------------------------------------------
// Static Variables // Static Variables
//------------------------------------------------------------------ //------------------------------------------------------------------
static uint32_t g_initialize_count = 0; static uint32_t g_initialize_count = 0;
▲ Show 20 Lines • Show All 356 Lines • Show Last 20 Lines

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

Show All 9 Lines
#include "PlatformAppleWatchSimulator.h" #include "PlatformAppleWatchSimulator.h"
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// 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;
//------------------------------------------------------------------ //------------------------------------------------------------------
// Static Variables // Static Variables
//------------------------------------------------------------------ //------------------------------------------------------------------
static uint32_t g_initialize_count = 0; static uint32_t g_initialize_count = 0;
▲ Show 20 Lines • Show All 359 Lines • Show Last 20 Lines

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

Show All 16 Lines
#include <mutex> #include <mutex>
// Other libraries and framework includes // Other libraries and framework includes
#include "clang/Basic/VersionTuple.h" #include "clang/Basic/VersionTuple.h"
// Project includes // Project includes
#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"
#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"
#include "lldb/Host/HostInfo.h" #include "lldb/Host/HostInfo.h"
#include "lldb/Host/StringConvert.h" #include "lldb/Host/StringConvert.h"
#include "lldb/Host/Symbols.h" #include "lldb/Host/Symbols.h"
#include "lldb/Host/XML.h" #include "lldb/Host/XML.h"
#include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
#include "lldb/Symbol/SymbolFile.h" #include "lldb/Symbol/SymbolFile.h"
#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__)
#include <TargetConditionals.h> // for TARGET_OS_TV, TARGET_OS_WATCH #include <TargetConditionals.h> // for TARGET_OS_TV, TARGET_OS_WATCH
#endif #endif
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
▲ Show 20 Lines • Show All 1,728 Lines • Show Last 20 Lines

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

//===-- PlatformDarwinKernel.h ----------------------------------*- C++ -*-===// //===-- PlatformDarwinKernel.h ----------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
▲ Show 20 Lines • Show All 187 Lines • Show Last 20 Lines

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

Show All 13 Lines#if defined(__APPLE__) // This Plugin uses the Mac-specific
// source/Host/macosx/cfcpp utilities // source/Host/macosx/cfcpp utilities
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// 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"
#include "lldb/Interpreter/OptionValueProperties.h" #include "lldb/Interpreter/OptionValueProperties.h"
#include "lldb/Interpreter/Property.h" #include "lldb/Interpreter/Property.h"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
#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>
#include "Host/macosx/cfcpp/CFCBundle.h" #include "Host/macosx/cfcpp/CFCBundle.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
▲ Show 20 Lines • Show All 782 Lines • Show Last 20 Lines

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

Show All 12 Lines
// C++ Includes // C++ Includes
#include <sstream> #include <sstream>
// Other libraries and framework includes // Other libraries and framework includes
// 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"
#include "lldb/Host/HostInfo.h" #include "lldb/Host/HostInfo.h"
#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;
static uint32_t g_initialize_count = 0; static uint32_t g_initialize_count = 0;
void PlatformMacOSX::Initialize() { void PlatformMacOSX::Initialize() {
PlatformDarwin::Initialize(); PlatformDarwin::Initialize();
▲ Show 20 Lines • Show All 302 Lines • Show Last 20 Lines

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

Show All 12 Lines
#include <vector> #include <vector>
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "PlatformRemoteAppleTV.h" #include "PlatformRemoteAppleTV.h"
#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;
//------------------------------------------------------------------ //------------------------------------------------------------------
/// Default Constructor /// Default Constructor
//------------------------------------------------------------------ //------------------------------------------------------------------
PlatformRemoteAppleTV::PlatformRemoteAppleTV() PlatformRemoteAppleTV::PlatformRemoteAppleTV()
▲ Show 20 Lines • Show All 857 Lines • Show Last 20 Lines

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

Show All 12 Lines
#include <vector> #include <vector>
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "PlatformRemoteAppleWatch.h" #include "PlatformRemoteAppleWatch.h"
#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;
//------------------------------------------------------------------ //------------------------------------------------------------------
/// Default Constructor /// Default Constructor
//------------------------------------------------------------------ //------------------------------------------------------------------
PlatformRemoteAppleWatch::PlatformRemoteAppleWatch() PlatformRemoteAppleWatch::PlatformRemoteAppleWatch()
▲ Show 20 Lines • Show All 920 Lines • Show Last 20 Lines

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

Show All 9 Lines
#include "PlatformRemoteiOS.h" #include "PlatformRemoteiOS.h"
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// 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;
PlatformRemoteiOS::SDKDirectoryInfo::SDKDirectoryInfo( PlatformRemoteiOS::SDKDirectoryInfo::SDKDirectoryInfo(
const lldb_private::FileSpec &sdk_dir) const lldb_private::FileSpec &sdk_dir)
: directory(sdk_dir), build(), version_major(0), version_minor(0), : directory(sdk_dir), build(), version_major(0), version_minor(0),
version_update(0), user_cached(false) { version_update(0), user_cached(false) {
▲ Show 20 Lines • Show All 804 Lines • Show Last 20 Lines

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

Show All 10 Lines
#include "PlatformiOSSimulator.h" #include "PlatformiOSSimulator.h"
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// 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;
//------------------------------------------------------------------ //------------------------------------------------------------------
// Static Variables // Static Variables
//------------------------------------------------------------------ //------------------------------------------------------------------
static uint32_t g_initialize_count = 0; static uint32_t g_initialize_count = 0;
▲ Show 20 Lines • Show All 385 Lines • Show Last 20 Lines

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

Show All 18 Lines
#include <vector> #include <vector>
// Other libraries and framework includes // Other libraries and framework includes
#ifdef __APPLE__ #ifdef __APPLE__
#include <objc/objc.h> #include <objc/objc.h>
#else #else
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"
// And now the actual magic // And now the actual magic
namespace CoreSimulatorSupport { namespace CoreSimulatorSupport {
class Process { class Process {
public: public:
lldb::pid_t GetPID() { return m_pid; } lldb::pid_t GetPID() { return m_pid; }
▲ Show 20 Lines • Show All 187 Lines • Show Last 20 Lines

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

Show All 16 Lines
#endif #endif
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#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;
using namespace lldb_private::platform_netbsd; using namespace lldb_private::platform_netbsd;
PlatformSP PlatformNetBSD::CreateInstance(bool force, const ArchSpec *arch) { PlatformSP PlatformNetBSD::CreateInstance(bool force, const ArchSpec *arch) {
// The only time we create an instance is when we are creating a remote // The only time we create an instance is when we are creating a remote
// netbsd platform // netbsd platform
▲ Show 20 Lines • Show All 404 Lines • Show Last 20 Lines

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

Show All 13 Lines
// 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/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/ModuleSpec.h" #include "lldb/Core/ModuleSpec.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"
#include "lldb/Host/FileCache.h" #include "lldb/Host/FileCache.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/Host/HostInfo.h" #include "lldb/Host/HostInfo.h"
#include "lldb/Target/DynamicLoader.h" #include "lldb/Target/DynamicLoader.h"
#include "lldb/Target/ExecutionContext.h" #include "lldb/Target/ExecutionContext.h"
#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;
//------------------------------------------------------------------ //------------------------------------------------------------------
/// Default Constructor /// Default Constructor
//------------------------------------------------------------------ //------------------------------------------------------------------
PlatformPOSIX::PlatformPOSIX(bool is_host) PlatformPOSIX::PlatformPOSIX(bool is_host)
▲ Show 20 Lines • Show All 962 Lines • Show Last 20 Lines

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

Show All 16 Lines
#endif #endif
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#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;
static uint32_t g_initialize_count = 0; static uint32_t g_initialize_count = 0;
namespace { namespace {
class SupportedArchList { class SupportedArchList {
▲ Show 20 Lines • Show All 569 Lines • Show Last 20 Lines

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

Show All 9 Lines
#include "PlatformRemoteGDBServer.h" #include "PlatformRemoteGDBServer.h"
#include "lldb/Host/Config.h" #include "lldb/Host/Config.h"
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// 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"
#include "lldb/Host/HostInfo.h" #include "lldb/Host/HostInfo.h"
#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"
#include "Plugins/Process/Utility/GDBRemoteSignals.h" #include "Plugins/Process/Utility/GDBRemoteSignals.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
using namespace lldb_private::platform_gdb_server; using namespace lldb_private::platform_gdb_server;
▲ Show 20 Lines • Show All 851 Lines • Show Last 20 Lines

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

Show All 24 Lines
#ifndef _POSIX_SPAWN_DISABLE_ASLR #ifndef _POSIX_SPAWN_DISABLE_ASLR
#define _POSIX_SPAWN_DISABLE_ASLR 0x0100 #define _POSIX_SPAWN_DISABLE_ASLR 0x0100
#endif #endif
// 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"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
using namespace lldb_private::process_darwin; using namespace lldb_private::process_darwin;
using namespace lldb_private::darwin_process_launcher; using namespace lldb_private::darwin_process_launcher;
▲ Show 20 Lines • Show All 608 Lines • Show Last 20 Lines

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

Show All 16 Lines
#include <errno.h> #include <errno.h>
#include <sys/ptrace.h> #include <sys/ptrace.h>
#include <sys/types.h> #include <sys/types.h>
// C++ includes // C++ includes
#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;
using namespace lldb_private::process_darwin; using namespace lldb_private::process_darwin;
// Routine mach_exception_raise // Routine mach_exception_raise
extern "C" kern_return_t extern "C" kern_return_t
catch_mach_exception_raise(mach_port_t exception_port, mach_port_t thread, catch_mach_exception_raise(mach_port_t exception_port, mach_port_t thread,
▲ Show 20 Lines • Show All 506 Lines • Show Last 20 Lines

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

Show All 15 Lines
#include <sys/stat.h> #include <sys/stat.h>
#include <sys/sysctl.h> #include <sys/sysctl.h>
#include <sys/types.h> #include <sys/types.h>
// C++ includes // C++ includes
// 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"
#include "DarwinProcessLauncher.h" #include "DarwinProcessLauncher.h"
#include "MachException.h" #include "MachException.h"
using namespace lldb; using namespace lldb;
▲ Show 20 Lines • Show All 1,542 Lines • Show Last 20 Lines

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

//===-- NativeThreadDarwin.cpp -------------------------------- -*- C++ -*-===// //===-- NativeThreadDarwin.cpp -------------------------------- -*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "NativeThreadDarwin.h" #include "NativeThreadDarwin.h"
// C includes // C includes
#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"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
using namespace lldb_private::process_darwin; using namespace lldb_private::process_darwin;
uint64_t NativeThreadDarwin::GetGloballyUniqueThreadIDForMachPortID( uint64_t NativeThreadDarwin::GetGloballyUniqueThreadIDForMachPortID(
▲ Show 20 Lines • Show All 260 Lines • Show Last 20 Lines

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

Show All 14 Lines
#include "NativeThreadListDarwin.h" #include "NativeThreadListDarwin.h"
// C includes // C includes
#include <inttypes.h> #include <inttypes.h>
#include <mach/vm_map.h> #include <mach/vm_map.h>
#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"
#include "NativeThreadDarwin.h" #include "NativeThreadDarwin.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
using namespace lldb_private::process_darwin; using namespace lldb_private::process_darwin;
▲ Show 20 Lines • Show All 665 Lines • Show Last 20 Lines

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

Show All 15 Lines
#include <sys/ptrace.h> #include <sys/ptrace.h>
#include <sys/socket.h> #include <sys/socket.h>
#include <sys/types.h> #include <sys/types.h>
#include <sys/wait.h> #include <sys/wait.h>
#include <unistd.h> #include <unistd.h>
// 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"
#include "lldb/Host/ThreadLauncher.h" #include "lldb/Host/ThreadLauncher.h"
#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"
#include "Plugins/Process/POSIX/CrashReason.h" #include "Plugins/Process/POSIX/CrashReason.h"
#include "ProcessFreeBSD.h" #include "ProcessFreeBSD.h"
#include "ProcessMonitor.h" #include "ProcessMonitor.h"
#include "ProcessPOSIXLog.h" #include "ProcessPOSIXLog.h"
▲ Show 20 Lines • Show All 1,420 Lines • Show Last 20 Lines

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

Show All 18 Lines
#include <fstream> #include <fstream>
#include <mutex> #include <mutex>
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <unordered_map> #include <unordered_map>
// 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"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Host/HostProcess.h" #include "lldb/Host/HostProcess.h"
#include "lldb/Host/ThreadLauncher.h" #include "lldb/Host/ThreadLauncher.h"
#include "lldb/Host/common/NativeBreakpoint.h" #include "lldb/Host/common/NativeBreakpoint.h"
#include "lldb/Host/common/NativeRegisterContext.h" #include "lldb/Host/common/NativeRegisterContext.h"
#include "lldb/Host/posix/ProcessLauncherPosixFork.h" #include "lldb/Host/posix/ProcessLauncherPosixFork.h"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
#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"
#include "NativeThreadLinux.h" #include "NativeThreadLinux.h"
#include "Plugins/Process/POSIX/ProcessPOSIXLog.h" #include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
#include "ProcFileReader.h" #include "ProcFileReader.h"
#include "Procfs.h" #include "Procfs.h"
▲ Show 20 Lines • Show All 2,380 Lines • Show Last 20 Lines

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

//===-- NativeRegisterContextLinux_arm.cpp --------------------*- C++ -*-===// //===-- NativeRegisterContextLinux_arm.cpp --------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#if defined(__arm__) || defined(__arm64__) || defined(__aarch64__) #if defined(__arm__) || defined(__arm64__) || defined(__aarch64__)
#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"
#include <elf.h> #include <elf.h>
#include <sys/socket.h> #include <sys/socket.h>
#define REG_CONTEXT_SIZE (GetGPRSize() + sizeof(m_fpr)) #define REG_CONTEXT_SIZE (GetGPRSize() + sizeof(m_fpr))
▲ Show 20 Lines • Show All 929 Lines • Show Last 20 Lines

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

Show All 11 Lines
#include "NativeRegisterContextLinux_arm.h" #include "NativeRegisterContextLinux_arm.h"
#include "NativeRegisterContextLinux_arm64.h" #include "NativeRegisterContextLinux_arm64.h"
// C Includes // C Includes
// C++ Includes // C++ Includes
// 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"
#include "Plugins/Process/POSIX/ProcessPOSIXLog.h" #include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
#include "Plugins/Process/Utility/RegisterInfoPOSIX_arm64.h" #include "Plugins/Process/Utility/RegisterInfoPOSIX_arm64.h"
// System includes - They have to be included after framework includes because // System includes - They have to be included after framework includes because
// they define some // they define some
▲ Show 20 Lines • Show All 942 Lines • Show Last 20 Lines

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

Show All 15 Lines
// Other libraries and framework includes // Other libraries and framework includes
#include "Plugins/Process/Linux/NativeProcessLinux.h" #include "Plugins/Process/Linux/NativeProcessLinux.h"
#include "Plugins/Process/Linux/Procfs.h" #include "Plugins/Process/Linux/Procfs.h"
#include "Plugins/Process/Utility/RegisterContextLinux_mips.h" #include "Plugins/Process/Utility/RegisterContextLinux_mips.h"
#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"
#define NT_MIPS_MSA 0x600 #define NT_MIPS_MSA 0x600
#define CONFIG5_FRE (1 << 8) #define CONFIG5_FRE (1 << 8)
#define SR_FR (1 << 26) #define SR_FR (1 << 26)
#define NUM_REGISTERS 32 #define NUM_REGISTERS 32
▲ Show 20 Lines • Show All 1,173 Lines • Show Last 20 Lines

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

//===-- NativeRegisterContextLinux_s390x.cpp --------------------*- C++ -*-===// //===-- NativeRegisterContextLinux_s390x.cpp --------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#if defined(__s390x__) && defined(__linux__) #if defined(__s390x__) && defined(__linux__)
#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"
#include <asm/ptrace.h> #include <asm/ptrace.h>
#include <linux/uio.h> #include <linux/uio.h>
#include <sys/ptrace.h> #include <sys/ptrace.h>
using namespace lldb_private; using namespace lldb_private;
▲ Show 20 Lines • Show All 610 Lines • Show Last 20 Lines

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

//===-- NativeRegisterContextLinux_x86_64.cpp ---------------*- C++ -*-===// //===-- NativeRegisterContextLinux_x86_64.cpp ---------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#if defined(__i386__) || defined(__x86_64__) #if defined(__i386__) || defined(__x86_64__)
#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"
#include <linux/elf.h> #include <linux/elf.h>
using namespace lldb_private; using namespace lldb_private;
using namespace lldb_private::process_linux; using namespace lldb_private::process_linux;
▲ Show 20 Lines • Show All 1,195 Lines • Show Last 20 Lines

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

Show All 15 Lines
#include <stdio.h> #include <stdio.h>
#include <sys/stat.h> #include <sys/stat.h>
// C++ Headers // C++ Headers
#include <fstream> #include <fstream>
// 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;
lldb::DataBufferSP ProcFileReader::ReadIntoDataBuffer(lldb::pid_t pid, lldb::DataBufferSP ProcFileReader::ReadIntoDataBuffer(lldb::pid_t pid,
const char *name) { const char *name) {
int fd; int fd;
char path[PATH_MAX]; char path[PATH_MAX];
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

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

Show All 13 Lines
#include <sys/wait.h> #include <sys/wait.h>
#include <unistd.h> #include <unistd.h>
#include "NativeProcessLinux.h" #include "NativeProcessLinux.h"
#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;
using namespace lldb_private::process_linux; using namespace lldb_private::process_linux;
#if defined(__arm64__) || defined(__aarch64__) #if defined(__arm64__) || defined(__aarch64__)
namespace { namespace {
▲ Show 20 Lines • Show All 150 Lines • Show Last 20 Lines

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

Show All 13 Lines
// C++ Includes // C++ Includes
#include <list> #include <list>
#include <vector> #include <vector>
// 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"
class ThreadKDP; class ThreadKDP;
class ProcessKDP : public lldb_private::Process { class ProcessKDP : public lldb_private::Process {
public: public:
//------------------------------------------------------------------ //------------------------------------------------------------------
▲ Show 20 Lines • Show All 186 Lines • Show Last 20 Lines

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

Show All 9 Lines
#include "ThreadKDP.h" #include "ThreadKDP.h"
#include "lldb/Utility/SafeMachO.h" #include "lldb/Utility/SafeMachO.h"
#include "lldb/Breakpoint/Watchpoint.h" #include "lldb/Breakpoint/Watchpoint.h"
#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"
#include "ProcessKDPLog.h" #include "ProcessKDPLog.h"
#include "RegisterContextKDP_arm.h" #include "RegisterContextKDP_arm.h"
#include "RegisterContextKDP_arm64.h" #include "RegisterContextKDP_arm64.h"
#include "RegisterContextKDP_i386.h" #include "RegisterContextKDP_i386.h"
#include "RegisterContextKDP_x86_64.h" #include "RegisterContextKDP_x86_64.h"
▲ Show 20 Lines • Show All 141 Lines • Show Last 20 Lines

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

Show All 11 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
#include <map> #include <map>
#include <vector> #include <vector>
// 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 {
public: public:
DynamicRegisterInfo(); DynamicRegisterInfo();
DynamicRegisterInfo(const lldb_private::StructuredData::Dictionary &dict, DynamicRegisterInfo(const lldb_private::StructuredData::Dictionary &dict,
const lldb_private::ArchSpec &arch); const lldb_private::ArchSpec &arch);
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

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

//===-- DynamicRegisterInfo.cpp ----------------------------*- C++ -*-===// //===-- DynamicRegisterInfo.cpp ----------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "DynamicRegisterInfo.h" #include "DynamicRegisterInfo.h"
// C Includes // C Includes
// C++ Includes // C++ Includes
// 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;
using namespace lldb_private; using namespace lldb_private;
DynamicRegisterInfo::DynamicRegisterInfo() DynamicRegisterInfo::DynamicRegisterInfo()
: m_regs(), m_sets(), m_set_reg_nums(), m_set_names(), m_value_regs_map(), : m_regs(), m_sets(), m_set_reg_nums(), m_set_names(), m_value_regs_map(),
m_invalidate_regs_map(), m_dynamic_reg_size_map(), m_invalidate_regs_map(), m_dynamic_reg_size_map(),
▲ Show 20 Lines • Show All 719 Lines • Show Last 20 Lines

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

Show All 10 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.h"
#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"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// RegisterContextMacOSXFrameBackchain constructor // RegisterContextMacOSXFrameBackchain constructor
▲ Show 20 Lines • Show All 141 Lines • Show Last 20 Lines

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

Show All 9 Lines
#include "RegisterContextMemory.h" #include "RegisterContextMemory.h"
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// 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;
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// RegisterContextMemory constructor // RegisterContextMemory constructor
//---------------------------------------------------------------------- //----------------------------------------------------------------------
RegisterContextMemory::RegisterContextMemory(Thread &thread, RegisterContextMemory::RegisterContextMemory(Thread &thread,
▲ Show 20 Lines • Show All 119 Lines • Show Last 20 Lines

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

//===-- RegisterContextThreadMemory.cpp -------------------------*- C++ -*-===// //===-- RegisterContextThreadMemory.cpp -------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
RegisterContextThreadMemory::RegisterContextThreadMemory( RegisterContextThreadMemory::RegisterContextThreadMemory(
▲ Show 20 Lines • Show All 198 Lines • Show Last 20 Lines

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

Show All 9 Lines
#include "StopInfoMachException.h" #include "StopInfoMachException.h"
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// 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"
#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/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;
const char *StopInfoMachException::GetDescription() { const char *StopInfoMachException::GetDescription() {
if (m_description.empty() && m_value != 0) { if (m_description.empty() && m_value != 0) {
ExecutionContext exe_ctx(m_thread_wp.lock()); ExecutionContext exe_ctx(m_thread_wp.lock());
Target *target = exe_ctx.GetTargetPtr(); Target *target = exe_ctx.GetTargetPtr();
▲ Show 20 Lines • Show All 549 Lines • Show Last 20 Lines

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

Show All 10 Lines
#define lldb_UnwindLLDB_h_ #define lldb_UnwindLLDB_h_
// C Includes // C Includes
// C++ Includes // C++ Includes
#include <vector> #include <vector>
// 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 {
class RegisterContextLLDB; class RegisterContextLLDB;
class UnwindLLDB : public lldb_private::Unwind { class UnwindLLDB : public lldb_private::Unwind {
public: public:
▲ Show 20 Lines • Show All 136 Lines • Show Last 20 Lines

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

//===-- DebuggerThread.cpp --------------------------------------*- C++ -*-===// //===-- DebuggerThread.cpp --------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "DebuggerThread.h" #include "DebuggerThread.h"
#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"
#include "lldb/Host/Predicate.h" #include "lldb/Host/Predicate.h"
#include "lldb/Host/ThisThread.h" #include "lldb/Host/ThisThread.h"
#include "lldb/Host/ThreadLauncher.h" #include "lldb/Host/ThreadLauncher.h"
#include "lldb/Host/windows/HostProcessWindows.h" #include "lldb/Host/windows/HostProcessWindows.h"
#include "lldb/Host/windows/HostThreadWindows.h" #include "lldb/Host/windows/HostThreadWindows.h"
#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"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#include "llvm/Support/ConvertUTF.h" #include "llvm/Support/ConvertUTF.h"
#include "llvm/Support/raw_ostream.h" #include "llvm/Support/raw_ostream.h"
using namespace lldb; using namespace lldb;
▲ Show 20 Lines • Show All 516 Lines • Show Last 20 Lines

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

//===-- ProcessWindows.h ----------------------------------------*- C++ -*-===// //===-- ProcessWindows.h ----------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef liblldb_Plugins_Process_Windows_Common_ProcessWindows_H_ #ifndef liblldb_Plugins_Process_Windows_Common_ProcessWindows_H_
#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"
#include "IDebugDelegate.h" #include "IDebugDelegate.h"
namespace lldb_private { namespace lldb_private {
▲ Show 20 Lines • Show All 96 Lines • Show Last 20 Lines

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

//===-- RegisterContextWindows.cpp ------------------------------*- C++ -*-===// //===-- RegisterContextWindows.cpp ------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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"
#include "RegisterContextWindows.h" #include "RegisterContextWindows.h"
#include "TargetThreadWindows.h" #include "TargetThreadWindows.h"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
▲ Show 20 Lines • Show All 114 Lines • Show Last 20 Lines

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

//===-- RegisterContextWindows_x64.cpp --------------------------*- C++ -*-===// //===-- RegisterContextWindows_x64.cpp --------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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"
#include "RegisterContext_x86.h" #include "RegisterContext_x86.h"
#include "TargetThreadWindows.h" #include "TargetThreadWindows.h"
#include "lldb-x86-register-enums.h" #include "lldb-x86-register-enums.h"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
▲ Show 20 Lines • Show All 321 Lines • Show Last 20 Lines

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

//===-- RegisterContextWindows_x86.cpp --------------------------*- C++ -*-===// //===-- RegisterContextWindows_x86.cpp --------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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"
#include "RegisterContextWindows_x86.h" #include "RegisterContextWindows_x86.h"
#include "RegisterContext_x86.h" #include "RegisterContext_x86.h"
#include "TargetThreadWindows.h" #include "TargetThreadWindows.h"
#include "lldb-x86-register-enums.h" #include "lldb-x86-register-enums.h"
▲ Show 20 Lines • Show All 277 Lines • Show Last 20 Lines

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

Show All 18 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
#include <list> #include <list>
#include <vector> #include <vector>
// 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"
struct ThreadData; struct ThreadData;
class ProcessElfCore : public lldb_private::Process { class ProcessElfCore : public lldb_private::Process {
public: public:
//------------------------------------------------------------------ //------------------------------------------------------------------
▲ Show 20 Lines • Show All 138 Lines • Show Last 20 Lines

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

Show All 11 Lines
// C Includes // C Includes
#include <limits.h> #include <limits.h>
#include <string.h> #include <string.h>
#include <sys/stat.h> #include <sys/stat.h>
// 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"
#include "lldb/Host/HostInfo.h" #include "lldb/Host/HostInfo.h"
#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/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"
// Project includes // Project includes
#include "ProcessGDBRemoteLog.h" #include "ProcessGDBRemoteLog.h"
#if defined(__APPLE__) #if defined(__APPLE__)
#define DEBUGSERVER_BASENAME "debugserver" #define DEBUGSERVER_BASENAME "debugserver"
▲ Show 20 Lines • Show All 1,322 Lines • Show Last 20 Lines

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

Show All 17 Lines
#include <sstream> #include <sstream>
// Other libraries and framework includes // Other libraries and framework includes
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#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"
#include "lldb/Symbol/Symbol.h" #include "lldb/Symbol/Symbol.h"
#include "lldb/Target/MemoryRegionInfo.h" #include "lldb/Target/MemoryRegionInfo.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#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"
#include "ProcessGDBRemoteLog.h" #include "ProcessGDBRemoteLog.h"
#include "Utility/StringExtractorGDBRemote.h" #include "Utility/StringExtractorGDBRemote.h"
#include "lldb/Host/Config.h" #include "lldb/Host/Config.h"
#include "llvm/ADT/StringSwitch.h" #include "llvm/ADT/StringSwitch.h"
▲ Show 20 Lines • Show All 3,587 Lines • Show Last 20 Lines

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

Show All 19 Lines
// C++ Includes // C++ Includes
#include <chrono> #include <chrono>
#include <cstring> #include <cstring>
// Other libraries and framework includes // Other libraries and framework includes
#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"
#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/StringConvert.h" #include "lldb/Host/StringConvert.h"
#include "lldb/Interpreter/Args.h" #include "lldb/Interpreter/Args.h"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
#include "lldb/Target/FileAction.h" #include "lldb/Target/FileAction.h"
#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
#include "ProcessGDBRemoteLog.h" #include "ProcessGDBRemoteLog.h"
#include "Utility/StringExtractorGDBRemote.h" #include "Utility/StringExtractorGDBRemote.h"
#ifdef __ANDROID__ #ifdef __ANDROID__
#include "lldb/Host/android/HostInfoAndroid.h" #include "lldb/Host/android/HostInfoAndroid.h"
▲ Show 20 Lines • Show All 1,251 Lines • Show Last 20 Lines

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

Show All 19 Lines
#include <cstring> #include <cstring>
#include <thread> #include <thread>
// Other libraries and framework includes // Other libraries and framework includes
#include "lldb/Core/DataBuffer.h" #include "lldb/Core/DataBuffer.h"
#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"
#include "lldb/Host/File.h" #include "lldb/Host/File.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/StringConvert.h" #include "lldb/Host/StringConvert.h"
#include "lldb/Host/common/NativeProcessProtocol.h" #include "lldb/Host/common/NativeProcessProtocol.h"
#include "lldb/Host/common/NativeRegisterContext.h" #include "lldb/Host/common/NativeRegisterContext.h"
#include "lldb/Host/common/NativeThreadProtocol.h" #include "lldb/Host/common/NativeThreadProtocol.h"
#include "lldb/Interpreter/Args.h" #include "lldb/Interpreter/Args.h"
#include "lldb/Target/FileAction.h" #include "lldb/Target/FileAction.h"
#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"
// Project includes // Project includes
#include "ProcessGDBRemote.h" #include "ProcessGDBRemote.h"
#include "ProcessGDBRemoteLog.h" #include "ProcessGDBRemoteLog.h"
#include "Utility/StringExtractorGDBRemote.h" #include "Utility/StringExtractorGDBRemote.h"
#include "Utility/UriParser.h" #include "Utility/UriParser.h"
▲ Show 20 Lines • Show All 3,152 Lines • Show Last 20 Lines

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

Show All 17 Lines
#include <mutex> #include <mutex>
#include <sstream> #include <sstream>
// Other libraries and framework includes // Other libraries and framework includes
#include "llvm/Support/FileSystem.h" #include "llvm/Support/FileSystem.h"
#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"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Host/HostInfo.h" #include "lldb/Host/HostInfo.h"
#include "lldb/Host/StringConvert.h" #include "lldb/Host/StringConvert.h"
#include "lldb/Target/FileAction.h" #include "lldb/Target/FileAction.h"
#include "lldb/Target/Platform.h" #include "lldb/Target/Platform.h"
#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"
#include "Utility/UriParser.h" #include "Utility/UriParser.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
using namespace lldb_private::process_gdb_remote; using namespace lldb_private::process_gdb_remote;
▲ Show 20 Lines • Show All 522 Lines • Show Last 20 Lines

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

Show All 11 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
#include <vector> #include <vector>
// 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"
#include "GDBRemoteCommunicationClient.h" #include "GDBRemoteCommunicationClient.h"
class StringExtractor; class StringExtractor;
namespace lldb_private { namespace lldb_private {
▲ Show 20 Lines • Show All 107 Lines • Show Last 20 Lines

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

Show All 10 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.h"
#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"
#include "ThreadGDBRemote.h" #include "ThreadGDBRemote.h"
#include "Utility/ARM_DWARF_Registers.h" #include "Utility/ARM_DWARF_Registers.h"
#include "Utility/ARM_ehframe_Registers.h" #include "Utility/ARM_ehframe_Registers.h"
#include "Utility/StringExtractorGDBRemote.h" #include "Utility/StringExtractorGDBRemote.h"
▲ Show 20 Lines • Show All 957 Lines • Show Last 20 Lines

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

Show All 16 Lines
#include <mutex> #include <mutex>
#include <string> #include <string>
#include <vector> #include <vector>
// 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/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"
#include "GDBRemoteCommunicationClient.h" #include "GDBRemoteCommunicationClient.h"
#include "GDBRemoteRegisterContext.h" #include "GDBRemoteRegisterContext.h"
#include "llvm/ADT/DenseMap.h" #include "llvm/ADT/DenseMap.h"
▲ Show 20 Lines • Show All 409 Lines • Show Last 20 Lines

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

Show All 29 Lines
#include "lldb/Breakpoint/Watchpoint.h" #include "lldb/Breakpoint/Watchpoint.h"
#include "lldb/Core/ArchSpec.h" #include "lldb/Core/ArchSpec.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.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/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"
#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/HostThread.h" #include "lldb/Host/HostThread.h"
#include "lldb/Host/StringConvert.h" #include "lldb/Host/StringConvert.h"
Show All 14 Lines
#include "lldb/Target/ABI.h" #include "lldb/Target/ABI.h"
#include "lldb/Target/DynamicLoader.h" #include "lldb/Target/DynamicLoader.h"
#include "lldb/Target/SystemRuntime.h" #include "lldb/Target/SystemRuntime.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/TargetList.h" #include "lldb/Target/TargetList.h"
#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"
#include "Plugins/Platform/MacOSX/PlatformRemoteiOS.h" #include "Plugins/Platform/MacOSX/PlatformRemoteiOS.h"
#include "Plugins/Process/Utility/GDBRemoteSignals.h" #include "Plugins/Process/Utility/GDBRemoteSignals.h"
#include "Plugins/Process/Utility/InferiorCallPOSIX.h" #include "Plugins/Process/Utility/InferiorCallPOSIX.h"
#include "Plugins/Process/Utility/StopInfoMachException.h" #include "Plugins/Process/Utility/StopInfoMachException.h"
#include "ProcessGDBRemote.h" #include "ProcessGDBRemote.h"
▲ Show 20 Lines • Show All 5,092 Lines • Show Last 20 Lines

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

//===-- ThreadGDBRemote.cpp -------------------------------------*- C++ -*-===// //===-- ThreadGDBRemote.cpp -------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "ThreadGDBRemote.h" #include "ThreadGDBRemote.h"
#include "lldb/Breakpoint/Watchpoint.h" #include "lldb/Breakpoint/Watchpoint.h"
#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"
#include "lldb/Target/StopInfo.h" #include "lldb/Target/StopInfo.h"
#include "lldb/Target/SystemRuntime.h" #include "lldb/Target/SystemRuntime.h"
#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"
#include "Utility/StringExtractorGDBRemote.h" #include "Utility/StringExtractorGDBRemote.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
using namespace lldb_private::process_gdb_remote; using namespace lldb_private::process_gdb_remote;
▲ Show 20 Lines • Show All 320 Lines • Show Last 20 Lines

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

Show All 11 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
#include <list> #include <list>
#include <vector> #include <vector>
// 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;
class ProcessMachCore : public lldb_private::Process { class ProcessMachCore : public lldb_private::Process {
public: public:
//------------------------------------------------------------------ //------------------------------------------------------------------
// Constructors and Destructors // Constructors and Destructors
//------------------------------------------------------------------ //------------------------------------------------------------------
▲ Show 20 Lines • Show All 123 Lines • Show Last 20 Lines

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

Show All 9 Lines
#include "ThreadMachCore.h" #include "ThreadMachCore.h"
#include "lldb/Utility/SafeMachO.h" #include "lldb/Utility/SafeMachO.h"
#include "lldb/Breakpoint/Watchpoint.h" #include "lldb/Breakpoint/Watchpoint.h"
#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"
//#include "RegisterContextKDP_i386.h" //#include "RegisterContextKDP_i386.h"
//#include "RegisterContextKDP_x86_64.h" //#include "RegisterContextKDP_x86_64.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

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

Show All 11 Lines
#define liblldb_MinidumpParser_h_ #define liblldb_MinidumpParser_h_
// Project includes // Project includes
#include "MinidumpTypes.h" #include "MinidumpTypes.h"
// 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"
#include "llvm/ADT/Optional.h" #include "llvm/ADT/Optional.h"
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
// C includes // C includes
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

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

//===-- MinidumpTypes.h -----------------------------------------*- C++ -*-===// //===-- MinidumpTypes.h -----------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef liblldb_MinidumpTypes_h_ #ifndef liblldb_MinidumpTypes_h_
#define liblldb_MinidumpTypes_h_ #define liblldb_MinidumpTypes_h_
// 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"
#include "llvm/ADT/Optional.h" #include "llvm/ADT/Optional.h"
#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
#include "llvm/Support/ConvertUTF.h" #include "llvm/Support/ConvertUTF.h"
#include "llvm/Support/Endian.h" #include "llvm/Support/Endian.h"
▲ Show 20 Lines • Show All 446 Lines • Show Last 20 Lines

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

Show All 9 Lines
#ifndef liblldb_ProcessMinidump_h_ #ifndef liblldb_ProcessMinidump_h_
#define liblldb_ProcessMinidump_h_ #define liblldb_ProcessMinidump_h_
// Project includes // Project includes
#include "MinidumpParser.h" #include "MinidumpParser.h"
#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"
// C Includes // C Includes
// C++ Includes // C++ Includes
namespace lldb_private { namespace lldb_private {
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

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

//===-- ScriptInterpreterNone.cpp -------------------------------*- C++ -*-===// //===-- ScriptInterpreterNone.cpp -------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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>
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
ScriptInterpreterNone::ScriptInterpreterNone(CommandInterpreter &interpreter) ScriptInterpreterNone::ScriptInterpreterNone(CommandInterpreter &interpreter)
: ScriptInterpreter(interpreter, eScriptLanguageNone) {} : ScriptInterpreter(interpreter, eScriptLanguageNone) {}
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

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

Show All 13 Lines
// LLDB Python header must be included first // LLDB Python header must be included first
#include "lldb-python.h" #include "lldb-python.h"
// C Includes // C Includes
// 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"
namespace lldb_private { namespace lldb_private {
class PythonBytes; class PythonBytes;
class PythonString; class PythonString;
▲ Show 20 Lines • Show All 439 Lines • Show Last 20 Lines

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

Show All 11 Lines
// Python is disabled in this build // Python is disabled in this build
#else #else
#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"
#include <stdio.h> #include <stdio.h>
#include "llvm/ADT/StringSwitch.h" #include "llvm/ADT/StringSwitch.h"
using namespace lldb_private; using namespace lldb_private;
▲ Show 20 Lines • Show All 1,019 Lines • Show Last 20 Lines

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

Show All 14 Lines
// C++ includes // C++ includes
#include <sstream> #include <sstream>
#include "lldb/Breakpoint/StoppointCallbackContext.h" #include "lldb/Breakpoint/StoppointCallbackContext.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/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"
#include "lldb/Interpreter/OptionValueProperties.h" #include "lldb/Interpreter/OptionValueProperties.h"
#include "lldb/Interpreter/OptionValueString.h" #include "lldb/Interpreter/OptionValueString.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/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"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
#pragma mark - #pragma mark -
#pragma mark Anonymous Namespace #pragma mark Anonymous Namespace
▲ Show 20 Lines • Show All 1,978 Lines • Show Last 20 Lines

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

Show All 17 Lines
#include "DWARFDefines.h" #include "DWARFDefines.h"
#include "SymbolFileDWARF.h" #include "SymbolFileDWARF.h"
#include "SymbolFileDWARFDebugMap.h" #include "SymbolFileDWARFDebugMap.h"
#include "UniqueDWARFASTType.h" #include "UniqueDWARFASTType.h"
#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"
#include "lldb/Symbol/ClangASTImporter.h" #include "lldb/Symbol/ClangASTImporter.h"
#include "lldb/Symbol/ClangExternalASTSourceCommon.h" #include "lldb/Symbol/ClangExternalASTSourceCommon.h"
#include "lldb/Symbol/ClangUtil.h" #include "lldb/Symbol/ClangUtil.h"
#include "lldb/Symbol/CompileUnit.h" #include "lldb/Symbol/CompileUnit.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/TypeList.h" #include "lldb/Symbol/TypeList.h"
#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"
#include <map> #include <map>
#include <vector> #include <vector>
//#define ENABLE_DEBUG_PRINTF // COMMENT OUT THIS LINE PRIOR TO CHECKIN //#define ENABLE_DEBUG_PRINTF // COMMENT OUT THIS LINE PRIOR TO CHECKIN
▲ Show 20 Lines • Show All 4,040 Lines • Show Last 20 Lines

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

//===-- DWARFASTParserOCaml.cpp ---------------------------------*- C++ -*-===// //===-- DWARFASTParserOCaml.cpp ---------------------------------*- C++ -*-===//
#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"
#include "lldb/Symbol/Function.h" #include "lldb/Symbol/Function.h"
#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;
DWARFASTParserOCaml::DWARFASTParserOCaml(OCamlASTContext &ast) : m_ast(ast) {} DWARFASTParserOCaml::DWARFASTParserOCaml(OCamlASTContext &ast) : m_ast(ast) {}
DWARFASTParserOCaml::~DWARFASTParserOCaml() {} DWARFASTParserOCaml::~DWARFASTParserOCaml() {}
▲ Show 20 Lines • Show All 189 Lines • Show Last 20 Lines

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

//===-- DWARFCompileUnit.cpp ------------------------------------*- C++ -*-===// //===-- DWARFCompileUnit.cpp ------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "DWARFCompileUnit.h" #include "DWARFCompileUnit.h"
#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"
#include "DWARFDebugAranges.h" #include "DWARFDebugAranges.h"
#include "DWARFDebugInfo.h" #include "DWARFDebugInfo.h"
#include "DWARFFormValue.h" #include "DWARFFormValue.h"
#include "LogChannelDWARF.h" #include "LogChannelDWARF.h"
#include "NameToDIE.h" #include "NameToDIE.h"
▲ Show 20 Lines • Show All 1,098 Lines • Show Last 20 Lines

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

//===-- DWARFDIECollection.cpp ----------------------------------*- C++ -*-===// //===-- DWARFDIECollection.cpp ----------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "DWARFDIECollection.h" #include "DWARFDIECollection.h"
#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;
void DWARFDIECollection::Append(const DWARFDIE &die) { m_dies.push_back(die); } void DWARFDIECollection::Append(const DWARFDIE &die) { m_dies.push_back(die); }
DWARFDIE DWARFDIE
DWARFDIECollection::GetDIEAtIndex(uint32_t idx) const { DWARFDIECollection::GetDIEAtIndex(uint32_t idx) const {
Show All 13 Lines

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

//===-- DWARFDebugAbbrev.cpp ------------------------------------*- C++ -*-===// //===-- DWARFDebugAbbrev.cpp ------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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;
using namespace std; using namespace std;
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// DWARFAbbreviationDeclarationSet::Clear() // DWARFAbbreviationDeclarationSet::Clear()
//---------------------------------------------------------------------- //----------------------------------------------------------------------
▲ Show 20 Lines • Show All 157 Lines • Show Last 20 Lines

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

//===-- DWARFDebugArangeSet.cpp ---------------------------------*- C++ -*-===// //===-- DWARFDebugArangeSet.cpp ---------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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;
DWARFDebugArangeSet::DWARFDebugArangeSet() DWARFDebugArangeSet::DWARFDebugArangeSet()
: m_offset(DW_INVALID_OFFSET), m_header(), m_arange_descriptors() { : m_offset(DW_INVALID_OFFSET), m_header(), m_arange_descriptors() {
m_header.length = 0; m_header.length = 0;
m_header.version = 0; m_header.version = 0;
▲ Show 20 Lines • Show All 249 Lines • Show Last 20 Lines

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

Show All 9 Lines
#include "DWARFDebugAranges.h" #include "DWARFDebugAranges.h"
#include <assert.h> #include <assert.h>
#include <stdio.h> #include <stdio.h>
#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"
#include "LogChannelDWARF.h" #include "LogChannelDWARF.h"
#include "SymbolFileDWARF.h" #include "SymbolFileDWARF.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
▲ Show 20 Lines • Show All 123 Lines • Show Last 20 Lines

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

//===-- DWARFDebugInfo.cpp --------------------------------------*- C++ -*-===// //===-- DWARFDebugInfo.cpp --------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "SymbolFileDWARF.h" #include "SymbolFileDWARF.h"
#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"
#include "DWARFDebugAranges.h" #include "DWARFDebugAranges.h"
#include "DWARFDebugInfo.h" #include "DWARFDebugInfo.h"
#include "DWARFDebugInfoEntry.h" #include "DWARFDebugInfoEntry.h"
#include "DWARFFormValue.h" #include "DWARFFormValue.h"
#include "LogChannelDWARF.h" #include "LogChannelDWARF.h"
▲ Show 20 Lines • Show All 560 Lines • Show Last 20 Lines

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

//===-- DWARFDebugInfoEntry.cpp ---------------------------------*- C++ -*-===// //===-- DWARFDebugInfoEntry.cpp ---------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "DWARFDebugInfoEntry.h" #include "DWARFDebugInfoEntry.h"
#include <assert.h> #include <assert.h>
#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"
#include "DWARFDebugAbbrev.h" #include "DWARFDebugAbbrev.h"
#include "DWARFDebugAranges.h" #include "DWARFDebugAranges.h"
#include "DWARFDebugInfo.h" #include "DWARFDebugInfo.h"
#include "DWARFDebugRanges.h" #include "DWARFDebugRanges.h"
#include "DWARFDeclContext.h" #include "DWARFDeclContext.h"
▲ Show 20 Lines • Show All 1,811 Lines • Show Last 20 Lines

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

//===-- DWARFDebugMacinfo.cpp -----------------------------------*- C++ -*-===// //===-- DWARFDebugMacinfo.cpp -----------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "DWARFDebugMacinfo.h" #include "DWARFDebugMacinfo.h"
#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;
DWARFDebugMacinfo::DWARFDebugMacinfo() {} DWARFDebugMacinfo::DWARFDebugMacinfo() {}
DWARFDebugMacinfo::~DWARFDebugMacinfo() {} DWARFDebugMacinfo::~DWARFDebugMacinfo() {}
Show All 16 Lines

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

//===-- DWARFDebugMacinfoEntry.cpp ------------------------------*- C++ -*-===// //===-- DWARFDebugMacinfoEntry.cpp ------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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;
DWARFDebugMacinfoEntry::DWARFDebugMacinfoEntry() DWARFDebugMacinfoEntry::DWARFDebugMacinfoEntry()
: m_type_code(0), m_line(0), m_op2() { : m_type_code(0), m_line(0), m_op2() {
m_op2.cstr = NULL; m_op2.cstr = NULL;
} }
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

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

//===-- DWARFDebugPubnames.cpp ----------------------------------*- C++ -*-===// //===-- DWARFDebugPubnames.cpp ----------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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"
#include "DWARFDebugInfo.h" #include "DWARFDebugInfo.h"
#include "DWARFFormValue.h" #include "DWARFFormValue.h"
#include "LogChannelDWARF.h" #include "LogChannelDWARF.h"
#include "SymbolFileDWARF.h" #include "SymbolFileDWARF.h"
▲ Show 20 Lines • Show All 232 Lines • Show Last 20 Lines

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

//===-- DWARFDebugPubnamesSet.cpp -------------------------------*- C++ -*-===// //===-- DWARFDebugPubnamesSet.cpp -------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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"
using namespace lldb_private; using namespace lldb_private;
DWARFDebugPubnamesSet::DWARFDebugPubnamesSet() DWARFDebugPubnamesSet::DWARFDebugPubnamesSet()
: m_offset(DW_INVALID_OFFSET), m_header(), m_descriptors(), : m_offset(DW_INVALID_OFFSET), m_header(), m_descriptors(),
m_name_to_descriptor_index() {} m_name_to_descriptor_index() {}
▲ Show 20 Lines • Show All 125 Lines • Show Last 20 Lines

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

//===-- DWARFDebugRanges.cpp ------------------------------------*- C++ -*-===// //===-- DWARFDebugRanges.cpp ------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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;
using namespace std; using namespace std;
DWARFDebugRanges::DWARFDebugRanges() : m_range_map() {} DWARFDebugRanges::DWARFDebugRanges() : m_range_map() {}
DWARFDebugRanges::~DWARFDebugRanges() {} DWARFDebugRanges::~DWARFDebugRanges() {}
▲ Show 20 Lines • Show All 104 Lines • Show Last 20 Lines

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

Show All 9 Lines
#ifndef SymbolFileDWARF_DWARFDeclContext_h_ #ifndef SymbolFileDWARF_DWARFDeclContext_h_
#define SymbolFileDWARF_DWARFDeclContext_h_ #define SymbolFileDWARF_DWARFDeclContext_h_
// C Includes // C Includes
// C++ Includes // C++ Includes
#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"
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// DWARFDeclContext // DWARFDeclContext
// //
// A class that represents a declaration context all the way down to a // A class that represents a declaration context all the way down to a
// DIE. This is useful when trying to find a DIE in one DWARF to a DIE // DIE. This is useful when trying to find a DIE in one DWARF to a DIE
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

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

//===-- DWARFDefines.cpp ----------------------------------------*- C++ -*-===// //===-- DWARFDefines.cpp ----------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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>
namespace lldb_private { namespace lldb_private {
const char *DW_TAG_value_to_name(uint32_t val) { const char *DW_TAG_value_to_name(uint32_t val) {
static char invalid[100]; static char invalid[100];
▲ Show 20 Lines • Show All 628 Lines • Show Last 20 Lines

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

//===-- DWARFFormValue.cpp --------------------------------------*- C++ -*-===// //===-- DWARFFormValue.cpp --------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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"
class DWARFCompileUnit; class DWARFCompileUnit;
using namespace lldb_private; using namespace lldb_private;
▲ Show 20 Lines • Show All 706 Lines • Show Last 20 Lines

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

//===-- HashedNameToDIE.h ---------------------------------------*- C++ -*-===// //===-- HashedNameToDIE.h ---------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef SymbolFileDWARF_HashedNameToDIE_h_ #ifndef SymbolFileDWARF_HashedNameToDIE_h_
#define SymbolFileDWARF_HashedNameToDIE_h_ #define SymbolFileDWARF_HashedNameToDIE_h_
#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"
#include "DWARFFormValue.h" #include "DWARFFormValue.h"
#include "NameToDIE.h" #include "NameToDIE.h"
class SymbolFileDWARF; class SymbolFileDWARF;
class DWARFCompileUnit; class DWARFCompileUnit;
▲ Show 20 Lines • Show All 168 Lines • Show Last 20 Lines

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

//===-- NameToDIE.cpp -------------------------------------------*- C++ -*-===// //===-- NameToDIE.cpp -------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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"
#include "DWARFDebugInfoEntry.h" #include "DWARFDebugInfoEntry.h"
#include "SymbolFileDWARF.h" #include "SymbolFileDWARF.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

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

Show All 16 Lines
#include <mutex> #include <mutex>
#include <set> #include <set>
#include <unordered_map> #include <unordered_map>
#include <vector> #include <vector>
// 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"
#include "lldb/Core/dwarf.h" #include "lldb/Core/dwarf.h"
#include "lldb/Expression/DWARFExpression.h" #include "lldb/Expression/DWARFExpression.h"
#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
#include "DWARFDataExtractor.h" #include "DWARFDataExtractor.h"
#include "DWARFDefines.h" #include "DWARFDefines.h"
#include "HashedNameToDIE.h" #include "HashedNameToDIE.h"
#include "NameToDIE.h" #include "NameToDIE.h"
#include "UniqueDWARFASTType.h" #include "UniqueDWARFASTType.h"
▲ Show 20 Lines • Show All 483 Lines • Show Last 20 Lines

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

Show All 11 Lines
// Other libraries and framework includes // Other libraries and framework includes
#include "llvm/Support/Casting.h" #include "llvm/Support/Casting.h"
#include "lldb/Core/ArchSpec.h" #include "lldb/Core/ArchSpec.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/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"
#include "lldb/Host/FileSystem.h" #include "lldb/Host/FileSystem.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Interpreter/OptionValueFileSpecList.h" #include "lldb/Interpreter/OptionValueFileSpecList.h"
#include "lldb/Interpreter/OptionValueProperties.h" #include "lldb/Interpreter/OptionValueProperties.h"
▲ Show 20 Lines • Show All 4,247 Lines • Show Last 20 Lines

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

Show All 13 Lines
#include "SymbolFileDWARFDebugMap.h" #include "SymbolFileDWARFDebugMap.h"
#include "DWARFDebugAranges.h" #include "DWARFDebugAranges.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/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)
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#endif #endif
#include "lldb/Core/Timer.h" #include "lldb/Core/Timer.h"
#include "lldb/Symbol/CompileUnit.h" #include "lldb/Symbol/CompileUnit.h"
▲ Show 20 Lines • Show All 1,408 Lines • Show Last 20 Lines

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

//===-- SymbolFileSymtab.cpp ------------------------------------*- C++ -*-===// //===-- SymbolFileSymtab.cpp ------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.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/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;
void SymbolFileSymtab::Initialize() { void SymbolFileSymtab::Initialize() {
PluginManager::RegisterPlugin(GetPluginNameStatic(), PluginManager::RegisterPlugin(GetPluginNameStatic(),
GetPluginDescriptionStatic(), CreateInstance); GetPluginDescriptionStatic(), CreateInstance);
} }
▲ Show 20 Lines • Show All 244 Lines • Show Last 20 Lines

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

Show All 9 Lines
#include "SymbolVendorELF.h" #include "SymbolVendorELF.h"
#include <string.h> #include <string.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/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;
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// SymbolVendorELF constructor // SymbolVendorELF constructor
//---------------------------------------------------------------------- //----------------------------------------------------------------------
SymbolVendorELF::SymbolVendorELF(const lldb::ModuleSP &module_sp) SymbolVendorELF::SymbolVendorELF(const lldb::ModuleSP &module_sp)
▲ Show 20 Lines • Show All 138 Lines • Show Last 20 Lines

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

Show All 9 Lines
#include "SymbolVendorMacOSX.h" #include "SymbolVendorMacOSX.h"
#include <string.h> #include <string.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/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;
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// SymbolVendorMacOSX constructor // SymbolVendorMacOSX constructor
//---------------------------------------------------------------------- //----------------------------------------------------------------------
SymbolVendorMacOSX::SymbolVendorMacOSX(const lldb::ModuleSP &module_sp) SymbolVendorMacOSX::SymbolVendorMacOSX(const lldb::ModuleSP &module_sp)
▲ Show 20 Lines • Show All 265 Lines • Show Last 20 Lines

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

Show All 12 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
#include <map> #include <map>
#include <mutex> #include <mutex>
#include <vector> #include <vector>
// 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
// calling libBacktraceRecording's // calling libBacktraceRecording's
// __introspection_dispatch_queue_item_get_info() // __introspection_dispatch_queue_item_get_info()
// function. The function in the inferior will return a struct by value // function. The function in the inferior will return a struct by value
// with these members: // with these members:
// //
▲ Show 20 Lines • Show All 88 Lines • Show Last 20 Lines

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

Show All 9 Lines
#include "AppleGetItemInfoHandler.h" #include "AppleGetItemInfoHandler.h"
// C Includes // C Includes
// 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"
#include "lldb/Expression/UtilityFunction.h" #include "lldb/Expression/UtilityFunction.h"
#include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/ClangASTContext.h"
#include "lldb/Symbol/Symbol.h" #include "lldb/Symbol/Symbol.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/ConstString.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
const char *AppleGetItemInfoHandler::g_get_item_info_function_name = const char *AppleGetItemInfoHandler::g_get_item_info_function_name =
"__lldb_backtrace_recording_get_item_info"; "__lldb_backtrace_recording_get_item_info";
const char *AppleGetItemInfoHandler::g_get_item_info_function_code = const char *AppleGetItemInfoHandler::g_get_item_info_function_code =
" \n\ " \n\
▲ Show 20 Lines • Show All 364 Lines • Show Last 20 Lines

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

Show All 13 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
#include <map> #include <map>
#include <mutex> #include <mutex>
#include <vector> #include <vector>
// 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
// calling libBacktraceRecording's // calling libBacktraceRecording's
// __introspection_dispatch_queue_get_pending_items() // __introspection_dispatch_queue_get_pending_items()
// function. The function in the inferior will return a struct by value // function. The function in the inferior will return a struct by value
// with these members: // with these members:
// //
▲ Show 20 Lines • Show All 93 Lines • Show Last 20 Lines

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

Show All 9 Lines
#include "AppleGetPendingItemsHandler.h" #include "AppleGetPendingItemsHandler.h"
// C Includes // C Includes
// 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"
#include "lldb/Expression/UtilityFunction.h" #include "lldb/Expression/UtilityFunction.h"
#include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/ClangASTContext.h"
#include "lldb/Symbol/Symbol.h" #include "lldb/Symbol/Symbol.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/ConstString.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
const char *AppleGetPendingItemsHandler::g_get_pending_items_function_name = const char *AppleGetPendingItemsHandler::g_get_pending_items_function_name =
"__lldb_backtrace_recording_get_pending_items"; "__lldb_backtrace_recording_get_pending_items";
const char *AppleGetPendingItemsHandler::g_get_pending_items_function_code = const char *AppleGetPendingItemsHandler::g_get_pending_items_function_code =
" \n\ " \n\
▲ Show 20 Lines • Show All 374 Lines • Show Last 20 Lines

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

Show All 12 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
#include <map> #include <map>
#include <mutex> #include <mutex>
#include <vector> #include <vector>
// 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
// calling libBacktraceRecording's introspection_get_dispatch_queues() // calling libBacktraceRecording's introspection_get_dispatch_queues()
// function. The function in the inferior will return a struct by value // function. The function in the inferior will return a struct by value
// with these members: // with these members:
// //
// struct get_current_queues_return_values // struct get_current_queues_return_values
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

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

//===-- AppleGetQueuesHandler.cpp -------------------------------*- C++ -*-===// //===-- AppleGetQueuesHandler.cpp -------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "AppleGetQueuesHandler.h" #include "AppleGetQueuesHandler.h"
// C Includes // C Includes
// 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"
#include "lldb/Expression/UtilityFunction.h" #include "lldb/Expression/UtilityFunction.h"
#include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/ClangASTContext.h"
#include "lldb/Symbol/Symbol.h" #include "lldb/Symbol/Symbol.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/ConstString.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
const char *AppleGetQueuesHandler::g_get_current_queues_function_name = const char *AppleGetQueuesHandler::g_get_current_queues_function_name =
"__lldb_backtrace_recording_get_current_queues"; "__lldb_backtrace_recording_get_current_queues";
const char *AppleGetQueuesHandler::g_get_current_queues_function_code = const char *AppleGetQueuesHandler::g_get_current_queues_function_code =
" \n\ " \n\
▲ Show 20 Lines • Show All 374 Lines • Show Last 20 Lines

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

Show All 13 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
#include <map> #include <map>
#include <mutex> #include <mutex>
#include <vector> #include <vector>
// 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
// calling libBacktraceRecording's // calling libBacktraceRecording's
// __introspection_dispatch_thread_get_item_info() // __introspection_dispatch_thread_get_item_info()
// function. The function in the inferior will return a struct by value // function. The function in the inferior will return a struct by value
// with these members: // with these members:
// //
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

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

Show All 9 Lines
#include "AppleGetThreadItemInfoHandler.h" #include "AppleGetThreadItemInfoHandler.h"
// C Includes // C Includes
// 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/Expression.h" #include "lldb/Expression/Expression.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"
#include "lldb/Symbol/Symbol.h" #include "lldb/Symbol/Symbol.h"
#include "lldb/Target/ExecutionContext.h" #include "lldb/Target/ExecutionContext.h"
#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/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;
using namespace lldb_private; using namespace lldb_private;
const char const char
*AppleGetThreadItemInfoHandler::g_get_thread_item_info_function_name = *AppleGetThreadItemInfoHandler::g_get_thread_item_info_function_name =
"__lldb_backtrace_recording_get_thread_item_info"; "__lldb_backtrace_recording_get_thread_item_info";
▲ Show 20 Lines • Show All 378 Lines • Show Last 20 Lines

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

Show All 12 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
#include <mutex> #include <mutex>
#include <string> #include <string>
#include <vector> #include <vector>
// 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"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
#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"
#include "AppleGetQueuesHandler.h" #include "AppleGetQueuesHandler.h"
#include "AppleGetThreadItemInfoHandler.h" #include "AppleGetThreadItemInfoHandler.h"
class SystemRuntimeMacOSX : public lldb_private::SystemRuntime { class SystemRuntimeMacOSX : public lldb_private::SystemRuntime {
public: public:
▲ Show 20 Lines • Show All 266 Lines • Show Last 20 Lines

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

Show All 10 Lines
#include "lldb/Breakpoint/StoppointCallbackContext.h" #include "lldb/Breakpoint/StoppointCallbackContext.h"
#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/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/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"
#include "lldb/Symbol/SymbolContext.h" #include "lldb/Symbol/SymbolContext.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/Queue.h" #include "lldb/Target/Queue.h"
#include "lldb/Target/QueueList.h" #include "lldb/Target/QueueList.h"
#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"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// Create an instance of this class. This function is filled into // Create an instance of this class. This function is filled into
▲ Show 20 Lines • Show All 998 Lines • Show Last 20 Lines

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

//===-- UnwindAssemblyInstEmulation.cpp --------------------------*- C++-*-===// //===-- UnwindAssemblyInstEmulation.cpp --------------------------*- C++-*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "UnwindAssemblyInstEmulation.h" #include "UnwindAssemblyInstEmulation.h"
#include "lldb/Core/Address.h" #include "lldb/Core/Address.h"
#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/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;
//----------------------------------------------------------------------------------------------- //-----------------------------------------------------------------------------------------------
// UnwindAssemblyInstEmulation method definitions // UnwindAssemblyInstEmulation method definitions
//----------------------------------------------------------------------------------------------- //-----------------------------------------------------------------------------------------------
▲ Show 20 Lines • Show All 631 Lines • Show Last 20 Lines

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

Show All 10 Lines
#include "x86AssemblyInspectionEngine.h" #include "x86AssemblyInspectionEngine.h"
#include "llvm-c/Disassembler.h" #include "llvm-c/Disassembler.h"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#include "llvm/Support/TargetSelect.h" #include "llvm/Support/TargetSelect.h"
#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"
#include "lldb/Target/ExecutionContext.h" #include "lldb/Target/ExecutionContext.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/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;
using namespace lldb_private; using namespace lldb_private;
//----------------------------------------------------------------------------------------------- //-----------------------------------------------------------------------------------------------
// UnwindAssemblyParser_x86 method definitions // UnwindAssemblyParser_x86 method definitions
//----------------------------------------------------------------------------------------------- //-----------------------------------------------------------------------------------------------
▲ Show 20 Lines • Show All 243 Lines • Show Last 20 Lines

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

Show All 11 Lines
#include "llvm-c/Disassembler.h" #include "llvm-c/Disassembler.h"
#include "lldb/lldb-enumerations.h" #include "lldb/lldb-enumerations.h"
#include "lldb/lldb-forward.h" #include "lldb/lldb-forward.h"
#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>
namespace lldb_private { namespace lldb_private {
// x86AssemblyInspectionEngine - a class which will take a buffer of bytes // x86AssemblyInspectionEngine - a class which will take a buffer of bytes
// of i386/x86_64 instructions and create an UnwindPlan based on those // of i386/x86_64 instructions and create an UnwindPlan based on those
▲ Show 20 Lines • Show All 153 Lines • Show Last 20 Lines

lldb/trunk/source/Symbol/ClangASTContext.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 68 Lines • ▼ Show 20 Lines
#include "Plugins/ExpressionParser/Clang/ClangFunctionCaller.h" #include "Plugins/ExpressionParser/Clang/ClangFunctionCaller.h"
#include "Plugins/ExpressionParser/Clang/ClangUserExpression.h" #include "Plugins/ExpressionParser/Clang/ClangUserExpression.h"
#include "Plugins/ExpressionParser/Clang/ClangUtilityFunction.h" #include "Plugins/ExpressionParser/Clang/ClangUtilityFunction.h"
#include "lldb/Core/ArchSpec.h" #include "lldb/Core/ArchSpec.h"
#include "lldb/Core/Flags.h" #include "lldb/Core/Flags.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/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"
#include "lldb/Core/UniqueCStringMap.h" #include "lldb/Core/UniqueCStringMap.h"
#include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/ClangASTContext.h"
#include "lldb/Symbol/ClangASTImporter.h" #include "lldb/Symbol/ClangASTImporter.h"
#include "lldb/Symbol/ClangExternalASTSourceCallbacks.h" #include "lldb/Symbol/ClangExternalASTSourceCallbacks.h"
#include "lldb/Symbol/ClangExternalASTSourceCommon.h" #include "lldb/Symbol/ClangExternalASTSourceCommon.h"
#include "lldb/Symbol/ClangUtil.h" #include "lldb/Symbol/ClangUtil.h"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
#include "lldb/Symbol/SymbolFile.h" #include "lldb/Symbol/SymbolFile.h"
#include "lldb/Symbol/VerifyDecl.h" #include "lldb/Symbol/VerifyDecl.h"
#include "lldb/Target/ExecutionContext.h" #include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Language.h" #include "lldb/Target/Language.h"
#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/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"
#include <stdio.h> #include <stdio.h>
#include <mutex> #include <mutex>
▲ Show 20 Lines • Show All 9,988 Lines • Show Last 20 Lines

lldb/trunk/source/Symbol/ClangExternalASTSourceCommon.cpp

//===-- ClangExternalASTSourceCommon.cpp ------------------------*- C++ -*-===// //===-- ClangExternalASTSourceCommon.cpp ------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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;
uint64_t g_TotalSizeOfMetadata = 0; uint64_t g_TotalSizeOfMetadata = 0;
typedef llvm::DenseMap<clang::ExternalASTSource *, typedef llvm::DenseMap<clang::ExternalASTSource *,
ClangExternalASTSourceCommon *> ClangExternalASTSourceCommon *>
ASTSourceMap; ASTSourceMap;
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

lldb/trunk/source/Symbol/CompactUnwindInfo.cpp

Show All 11 Lines
#include <algorithm> #include <algorithm>
#include "lldb/Core/ArchSpec.h" #include "lldb/Core/ArchSpec.h"
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.h"
#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/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"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
namespace lldb_private { namespace lldb_private {
▲ Show 20 Lines • Show All 1,594 Lines • Show Last 20 Lines

lldb/trunk/source/Symbol/CompilerType.cpp

//===-- CompilerType.cpp ----------------------------------------*- C++ -*-===// //===-- CompilerType.cpp ----------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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>
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
CompilerType::CompilerType(TypeSystem *type_system, CompilerType::CompilerType(TypeSystem *type_system,
▲ Show 20 Lines • Show All 1,040 Lines • Show Last 20 Lines

lldb/trunk/source/Symbol/Declaration.cpp

//===-- Declaration.cpp -----------------------------------------*- C++ -*-===// //===-- Declaration.cpp -----------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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;
void Declaration::Dump(Stream *s, bool show_fullpaths) const { void Declaration::Dump(Stream *s, bool show_fullpaths) const {
if (m_file) { if (m_file) {
*s << ", decl = "; *s << ", decl = ";
if (show_fullpaths) if (show_fullpaths)
*s << m_file; *s << m_file;
▲ Show 20 Lines • Show All 78 Lines • Show Last 20 Lines

lldb/trunk/source/Symbol/JavaASTContext.cpp

//===-- JavaASTContext.cpp --------------------------------------*- C++ -*-===// //===-- JavaASTContext.cpp --------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include <sstream> #include <sstream>
#include "lldb/Core/ArchSpec.h" #include "lldb/Core/ArchSpec.h"
#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"
#include "lldb/Symbol/CompilerType.h" #include "lldb/Symbol/CompilerType.h"
#include "lldb/Symbol/JavaASTContext.h" #include "lldb/Symbol/JavaASTContext.h"
#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"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
namespace lldb_private { namespace lldb_private {
▲ Show 20 Lines • Show All 1,301 Lines • Show Last 20 Lines

lldb/trunk/source/Symbol/LineTable.cpp

//===-- LineTable.cpp -------------------------------------------*- C++ -*-===// //===-- LineTable.cpp -------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Symbol/LineTable.h" #include "lldb/Symbol/LineTable.h"
#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;
using namespace lldb_private; using namespace lldb_private;
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// LineTable constructor // LineTable constructor
//---------------------------------------------------------------------- //----------------------------------------------------------------------
▲ Show 20 Lines • Show All 520 Lines • Show Last 20 Lines

lldb/trunk/source/Symbol/ObjectFile.cpp

Show All 9 Lines
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
#include "Plugins/ObjectContainer/BSD-Archive/ObjectContainerBSDArchive.h" #include "Plugins/ObjectContainer/BSD-Archive/ObjectContainerBSDArchive.h"
#include "lldb/Core/DataBuffer.h" #include "lldb/Core/DataBuffer.h"
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.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/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;
using namespace lldb_private; using namespace lldb_private;
ObjectFileSP ObjectFileSP
ObjectFile::FindPlugin(const lldb::ModuleSP &module_sp, const FileSpec *file, ObjectFile::FindPlugin(const lldb::ModuleSP &module_sp, const FileSpec *file,
lldb::offset_t file_offset, lldb::offset_t file_size, lldb::offset_t file_offset, lldb::offset_t file_size,
▲ Show 20 Lines • Show All 656 Lines • Show Last 20 Lines

lldb/trunk/source/Symbol/Symbol.cpp

//===-- Symbol.cpp ----------------------------------------------*- C++ -*-===// //===-- Symbol.cpp ----------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Symbol/Symbol.h" #include "lldb/Symbol/Symbol.h"
#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;
Symbol::Symbol() Symbol::Symbol()
: SymbolContextScope(), m_uid(UINT32_MAX), m_type_data(0), : SymbolContextScope(), m_uid(UINT32_MAX), m_type_data(0),
m_type_data_resolved(false), m_is_synthetic(false), m_is_debug(false), m_type_data_resolved(false), m_is_synthetic(false), m_is_debug(false),
m_is_external(false), m_size_is_sibling(false), m_is_external(false), m_size_is_sibling(false),
▲ Show 20 Lines • Show All 542 Lines • Show Last 20 Lines

lldb/trunk/source/Symbol/SymbolFile.cpp

//===-- SymbolFile.cpp ------------------------------------------*- C++ -*-===// //===-- SymbolFile.cpp ------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Symbol/SymbolFile.h" #include "lldb/Symbol/SymbolFile.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/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;
SymbolFile *SymbolFile::FindPlugin(ObjectFile *obj_file) { SymbolFile *SymbolFile::FindPlugin(ObjectFile *obj_file) {
std::unique_ptr<SymbolFile> best_symfile_ap; std::unique_ptr<SymbolFile> best_symfile_ap;
if (obj_file != nullptr) { if (obj_file != nullptr) {
▲ Show 20 Lines • Show All 125 Lines • Show Last 20 Lines

lldb/trunk/source/Symbol/SymbolVendor.cpp

Show All 9 Lines
#include "lldb/Symbol/SymbolVendor.h" #include "lldb/Symbol/SymbolVendor.h"
// C Includes // C Includes
// C++ Includes // C++ Includes
// 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/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;
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// FindPlugin // FindPlugin
// //
// Platforms can register a callback to use when creating symbol // Platforms can register a callback to use when creating symbol
▲ Show 20 Lines • Show All 455 Lines • Show Last 20 Lines

lldb/trunk/source/Symbol/Symtab.cpp

//===-- Symtab.cpp ----------------------------------------------*- C++ -*-===// //===-- Symtab.cpp ----------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include <map> #include <map>
#include <set> #include <set>
#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;
Symtab::Symtab(ObjectFile *objfile) Symtab::Symtab(ObjectFile *objfile)
: m_objfile(objfile), m_symbols(), m_file_addr_to_index(), : m_objfile(objfile), m_symbols(), m_file_addr_to_index(),
m_name_to_index(), m_mutex(), m_file_addr_to_index_computed(false), m_name_to_index(), m_mutex(), m_file_addr_to_index_computed(false),
m_name_indexes_computed(false) {} m_name_indexes_computed(false) {}
▲ Show 20 Lines • Show All 1,132 Lines • Show Last 20 Lines

lldb/trunk/source/Symbol/Type.cpp

Show All 11 Lines
// C++ Includes // C++ Includes
// 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/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"
#include "lldb/Symbol/SymbolContextScope.h" #include "lldb/Symbol/SymbolContextScope.h"
#include "lldb/Symbol/SymbolFile.h" #include "lldb/Symbol/SymbolFile.h"
#include "lldb/Symbol/SymbolVendor.h" #include "lldb/Symbol/SymbolVendor.h"
#include "lldb/Symbol/Type.h" #include "lldb/Symbol/Type.h"
#include "lldb/Symbol/TypeList.h" #include "lldb/Symbol/TypeList.h"
▲ Show 20 Lines • Show All 1,094 Lines • Show Last 20 Lines

lldb/trunk/source/Symbol/UnwindPlan.cpp

//===-- UnwindPlan.cpp ----------------------------------*- C++ -*-===// //===-- UnwindPlan.cpp ----------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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;
bool UnwindPlan::Row::RegisterLocation:: bool UnwindPlan::Row::RegisterLocation::
operator==(const UnwindPlan::Row::RegisterLocation &rhs) const { operator==(const UnwindPlan::Row::RegisterLocation &rhs) const {
if (m_type == rhs.m_type) { if (m_type == rhs.m_type) {
switch (m_type) { switch (m_type) {
▲ Show 20 Lines • Show All 490 Lines • Show Last 20 Lines

lldb/trunk/source/Symbol/Variable.cpp

//===-- Variable.cpp --------------------------------------------*- C++ -*-===// //===-- Variable.cpp --------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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"
#include "lldb/Symbol/CompileUnit.h" #include "lldb/Symbol/CompileUnit.h"
#include "lldb/Symbol/CompilerDecl.h" #include "lldb/Symbol/CompilerDecl.h"
#include "lldb/Symbol/CompilerDeclContext.h" #include "lldb/Symbol/CompilerDeclContext.h"
#include "lldb/Symbol/Function.h" #include "lldb/Symbol/Function.h"
#include "lldb/Symbol/SymbolContext.h" #include "lldb/Symbol/SymbolContext.h"
#include "lldb/Symbol/SymbolFile.h" #include "lldb/Symbol/SymbolFile.h"
#include "lldb/Symbol/Type.h" #include "lldb/Symbol/Type.h"
#include "lldb/Symbol/TypeSystem.h" #include "lldb/Symbol/TypeSystem.h"
#include "lldb/Symbol/VariableList.h" #include "lldb/Symbol/VariableList.h"
#include "lldb/Target/ABI.h" #include "lldb/Target/ABI.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h" #include "lldb/Target/RegisterContext.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/RegularExpression.h"
#include "lldb/Utility/Stream.h"
#include "llvm/ADT/Twine.h" #include "llvm/ADT/Twine.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// Variable constructor // Variable constructor
▲ Show 20 Lines • Show All 737 Lines • Show Last 20 Lines

lldb/trunk/source/Symbol/VariableList.cpp

//===-- VariableList.cpp ----------------------------------------*- C++ -*-===// //===-- VariableList.cpp ----------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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;
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// VariableList constructor // VariableList constructor
//---------------------------------------------------------------------- //----------------------------------------------------------------------
VariableList::VariableList() : m_variables() {} VariableList::VariableList() : m_variables() {}
▲ Show 20 Lines • Show All 158 Lines • Show Last 20 Lines

lldb/trunk/source/Target/FileAction.cpp

//===-- FileAction.cpp ------------------------------------------*- C++ -*-===// //===-- FileAction.cpp ------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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;
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
// FileAction member functions // FileAction member functions
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
FileAction::FileAction() FileAction::FileAction()
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

lldb/trunk/source/Target/InstrumentationRuntime.cpp

Show All 9 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Target/InstrumentationRuntime.h" #include "lldb/Target/InstrumentationRuntime.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/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;
using namespace lldb_private; using namespace lldb_private;
void InstrumentationRuntime::ModulesDidLoad( void InstrumentationRuntime::ModulesDidLoad(
lldb_private::ModuleList &module_list, lldb_private::Process *process, lldb_private::ModuleList &module_list, lldb_private::Process *process,
InstrumentationRuntimeCollection &runtimes) { InstrumentationRuntimeCollection &runtimes) {
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

lldb/trunk/source/Target/Language.cpp

Show All 9 Lines
#include <functional> #include <functional>
#include <map> #include <map>
#include <mutex> #include <mutex>
#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;
using namespace lldb_private::formatters; using namespace lldb_private::formatters;
typedef std::unique_ptr<Language> LanguageUP; typedef std::unique_ptr<Language> LanguageUP;
typedef std::map<lldb::LanguageType, LanguageUP> LanguagesMap; typedef std::map<lldb::LanguageType, LanguageUP> LanguagesMap;
▲ Show 20 Lines • Show All 393 Lines • Show Last 20 Lines

lldb/trunk/source/Target/PathMappingList.cpp

//===-- PathMappingList.cpp -------------------------------------*- C++ -*-===// //===-- PathMappingList.cpp -------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// C Includes // C Includes
// C++ Includes // C++ Includes
#include <climits> #include <climits>
#include <cstring> #include <cstring>
// 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;
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// PathMappingList constructor // PathMappingList constructor
//---------------------------------------------------------------------- //----------------------------------------------------------------------
PathMappingList::PathMappingList() PathMappingList::PathMappingList()
▲ Show 20 Lines • Show All 262 Lines • Show Last 20 Lines

lldb/trunk/source/Target/Platform.cpp

Show All 17 Lines
#include "llvm/Support/Path.h" #include "llvm/Support/Path.h"
// Project includes // Project includes
#include "Utility/ModuleCache.h" #include "Utility/ModuleCache.h"
#include "lldb/Breakpoint/BreakpointIDList.h" #include "lldb/Breakpoint/BreakpointIDList.h"
#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"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Core/StructuredData.h" #include "lldb/Core/StructuredData.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/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/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
#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/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.
#define MAP_PRIVATE 2 #define MAP_PRIVATE 2
#define MAP_ANON 0x1000 #define MAP_ANON 0x1000
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
▲ Show 20 Lines • Show All 1,834 Lines • Show Last 20 Lines

lldb/trunk/source/Target/ProcessInfo.cpp

Show All 9 Lines
#include "lldb/Target/ProcessInfo.h" #include "lldb/Target/ProcessInfo.h"
// C Includes // C Includes
// C++ Includes // C++ Includes
#include <climits> #include <climits>
// 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"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
ProcessInfo::ProcessInfo() ProcessInfo::ProcessInfo()
: m_executable(), m_arguments(), m_environment(), m_uid(UINT32_MAX), : m_executable(), m_arguments(), m_environment(), m_uid(UINT32_MAX),
▲ Show 20 Lines • Show All 94 Lines • Show Last 20 Lines

lldb/trunk/source/Target/SectionLoadHistory.cpp

//===-- SectionLoadHistory.cpp ----------------------------------*- C++ -*-===// //===-- SectionLoadHistory.cpp ----------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Target/SectionLoadHistory.h" #include "lldb/Target/SectionLoadHistory.h"
// C Includes // C Includes
// 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;
bool SectionLoadHistory::IsEmpty() const { bool SectionLoadHistory::IsEmpty() const {
std::lock_guard<std::recursive_mutex> guard(m_mutex); std::lock_guard<std::recursive_mutex> guard(m_mutex);
return m_stop_id_to_section_load_list.empty(); return m_stop_id_to_section_load_list.empty();
} }
▲ Show 20 Lines • Show All 147 Lines • Show Last 20 Lines

lldb/trunk/source/Target/SectionLoadList.cpp

Show All 10 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
// 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/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;
SectionLoadList::SectionLoadList(const SectionLoadList &rhs) SectionLoadList::SectionLoadList(const SectionLoadList &rhs)
: m_addr_to_sect(), m_sect_to_addr(), m_mutex() { : m_addr_to_sect(), m_sect_to_addr(), m_mutex() {
std::lock_guard<std::recursive_mutex> guard(rhs.m_mutex); std::lock_guard<std::recursive_mutex> guard(rhs.m_mutex);
m_addr_to_sect = rhs.m_addr_to_sect; m_addr_to_sect = rhs.m_addr_to_sect;
▲ Show 20 Lines • Show All 237 Lines • Show Last 20 Lines

lldb/trunk/source/Target/StackID.cpp

//===-- StackID.cpp ---------------------------------------------*- C++ -*-===// //===-- StackID.cpp ---------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// C Includes // C Includes
// C++ Includes // C++ Includes
// 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;
void StackID::Dump(Stream *s) { void StackID::Dump(Stream *s) {
s->Printf("StackID (pc = 0x%16.16" PRIx64 ", cfa = 0x%16.16" PRIx64 s->Printf("StackID (pc = 0x%16.16" PRIx64 ", cfa = 0x%16.16" PRIx64
", symbol_scope = %p", ", symbol_scope = %p",
m_pc, m_cfa, static_cast<void *>(m_symbol_scope)); m_pc, m_cfa, static_cast<void *>(m_symbol_scope));
if (m_symbol_scope) { if (m_symbol_scope) {
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

lldb/trunk/source/Target/StopInfo.cpp

Show All 13 Lines
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Breakpoint/Breakpoint.h" #include "lldb/Breakpoint/Breakpoint.h"
#include "lldb/Breakpoint/BreakpointLocation.h" #include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Breakpoint/StoppointCallbackContext.h" #include "lldb/Breakpoint/StoppointCallbackContext.h"
#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"
#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/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;
StopInfo::StopInfo(Thread &thread, uint64_t value) StopInfo::StopInfo(Thread &thread, uint64_t value)
: m_thread_wp(thread.shared_from_this()), : m_thread_wp(thread.shared_from_this()),
m_stop_id(thread.GetProcess()->GetStopID()), m_stop_id(thread.GetProcess()->GetStopID()),
m_resume_id(thread.GetProcess()->GetResumeID()), m_value(value), m_resume_id(thread.GetProcess()->GetResumeID()), m_value(value),
▲ Show 20 Lines • Show All 1,145 Lines • Show Last 20 Lines

lldb/trunk/source/Target/Target.cpp

Show All 25 Lines
#include "lldb/Core/Event.h" #include "lldb/Core/Event.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/Section.h" #include "lldb/Core/Section.h"
#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"
#include "lldb/Expression/UserExpression.h" #include "lldb/Expression/UserExpression.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Interpreter/CommandReturnObject.h" #include "lldb/Interpreter/CommandReturnObject.h"
Show All 10 Lines
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/SectionLoadList.h" #include "lldb/Target/SectionLoadList.h"
#include "lldb/Target/StackFrame.h" #include "lldb/Target/StackFrame.h"
#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/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;
constexpr std::chrono::milliseconds EvaluateExpressionOptions::default_timeout; constexpr std::chrono::milliseconds EvaluateExpressionOptions::default_timeout;
ConstString &Target::GetStaticBroadcasterClass() { ConstString &Target::GetStaticBroadcasterClass() {
static ConstString class_name("lldb.target"); static ConstString class_name("lldb.target");
▲ Show 20 Lines • Show All 4,047 Lines • Show Last 20 Lines

lldb/trunk/source/Target/Thread.cpp

Show All 13 Lines
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "Plugins/Process/Utility/UnwindLLDB.h" #include "Plugins/Process/Utility/UnwindLLDB.h"
#include "Plugins/Process/Utility/UnwindMacOSXFrameBackchain.h" #include "Plugins/Process/Utility/UnwindMacOSXFrameBackchain.h"
#include "lldb/Breakpoint/BreakpointLocation.h" #include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#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"
#include "lldb/Interpreter/OptionValueProperties.h" #include "lldb/Interpreter/OptionValueProperties.h"
#include "lldb/Interpreter/Property.h" #include "lldb/Interpreter/Property.h"
#include "lldb/Symbol/Function.h" #include "lldb/Symbol/Function.h"
#include "lldb/Target/ABI.h" #include "lldb/Target/ABI.h"
#include "lldb/Target/DynamicLoader.h" #include "lldb/Target/DynamicLoader.h"
Show All 12 Lines
#include "lldb/Target/ThreadPlanStepInstruction.h" #include "lldb/Target/ThreadPlanStepInstruction.h"
#include "lldb/Target/ThreadPlanStepOut.h" #include "lldb/Target/ThreadPlanStepOut.h"
#include "lldb/Target/ThreadPlanStepOverBreakpoint.h" #include "lldb/Target/ThreadPlanStepOverBreakpoint.h"
#include "lldb/Target/ThreadPlanStepOverRange.h" #include "lldb/Target/ThreadPlanStepOverRange.h"
#include "lldb/Target/ThreadPlanStepThrough.h" #include "lldb/Target/ThreadPlanStepThrough.h"
#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;
const ThreadPropertiesSP &Thread::GetGlobalProperties() { const ThreadPropertiesSP &Thread::GetGlobalProperties() {
// NOTE: intentional leak so we don't crash if global destructor chain gets // NOTE: intentional leak so we don't crash if global destructor chain gets
// called as other threads still use the result of this function // called as other threads still use the result of this function
static ThreadPropertiesSP *g_settings_sp_ptr = static ThreadPropertiesSP *g_settings_sp_ptr =
▲ Show 20 Lines • Show All 2,119 Lines • Show Last 20 Lines

lldb/trunk/source/Target/ThreadPlanBase.cpp

Show All 13 Lines
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
// //
#include "lldb/Breakpoint/Breakpoint.h" #include "lldb/Breakpoint/Breakpoint.h"
#include "lldb/Breakpoint/BreakpointLocation.h" #include "lldb/Breakpoint/BreakpointLocation.h"
#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;
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// ThreadPlanBase: This one always stops, and never has anything particular // ThreadPlanBase: This one always stops, and never has anything particular
// to do. // to do.
// FIXME: The "signal handling" policies should probably go here. // FIXME: The "signal handling" policies should probably go here.
▲ Show 20 Lines • Show All 179 Lines • Show Last 20 Lines

lldb/trunk/source/Target/ThreadPlanCallFunction.cpp

Show All 11 Lines
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Target/ThreadPlanCallFunction.h" #include "lldb/Target/ThreadPlanCallFunction.h"
#include "lldb/Breakpoint/Breakpoint.h" #include "lldb/Breakpoint/Breakpoint.h"
#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/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"
#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/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;
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// ThreadPlanCallFunction: Plan to call a single function // ThreadPlanCallFunction: Plan to call a single function
//---------------------------------------------------------------------- //----------------------------------------------------------------------
bool ThreadPlanCallFunction::ConstructorSetup( bool ThreadPlanCallFunction::ConstructorSetup(
▲ Show 20 Lines • Show All 478 Lines • Show Last 20 Lines

lldb/trunk/source/Target/ThreadPlanCallFunctionUsingABI.cpp

//===-- ThreadPlanCallFunctionUsingABI.cpp ----------------------*- C++ -*-===// //===-- ThreadPlanCallFunctionUsingABI.cpp ----------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#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;
//-------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------
// ThreadPlanCallFunctionUsingABI: Plan to call a single function using the ABI // ThreadPlanCallFunctionUsingABI: Plan to call a single function using the ABI
// instead of JIT // instead of JIT
//------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

lldb/trunk/source/Target/ThreadPlanCallUserExpression.cpp

Show All 12 Lines
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Breakpoint/Breakpoint.h" #include "lldb/Breakpoint/Breakpoint.h"
#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"
#include "lldb/Host/HostInfo.h" #include "lldb/Host/HostInfo.h"
#include "lldb/Target/LanguageRuntime.h" #include "lldb/Target/LanguageRuntime.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/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;
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// ThreadPlanCallUserExpression: Plan to call a single function // ThreadPlanCallUserExpression: Plan to call a single function
//---------------------------------------------------------------------- //----------------------------------------------------------------------
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

lldb/trunk/source/Target/ThreadPlanRunToAddress.cpp

//===-- ThreadPlanRunToAddress.cpp ------------------------------*- C++ -*-===// //===-- ThreadPlanRunToAddress.cpp ------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// 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;
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// ThreadPlanRunToAddress: Continue plan // ThreadPlanRunToAddress: Continue plan
//---------------------------------------------------------------------- //----------------------------------------------------------------------
▲ Show 20 Lines • Show All 176 Lines • Show Last 20 Lines

lldb/trunk/source/Target/ThreadPlanStepInRange.cpp

//===-- ThreadPlanStepInRange.cpp -------------------------------*- C++ -*-===// //===-- ThreadPlanStepInRange.cpp -------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#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"
#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/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;
uint32_t ThreadPlanStepInRange::s_default_flag_values = uint32_t ThreadPlanStepInRange::s_default_flag_values =
ThreadPlanShouldStopHere::eStepInAvoidNoDebug; ThreadPlanShouldStopHere::eStepInAvoidNoDebug;
//---------------------------------------------------------------------- //----------------------------------------------------------------------
▲ Show 20 Lines • Show All 474 Lines • Show Last 20 Lines

lldb/trunk/source/Target/ThreadPlanStepInstruction.cpp

//===-- ThreadPlanStepInstruction.cpp ---------------------------*- C++ -*-===// //===-- ThreadPlanStepInstruction.cpp ---------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// 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;
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// ThreadPlanStepInstruction: Step over the current instruction // ThreadPlanStepInstruction: Step over the current instruction
//---------------------------------------------------------------------- //----------------------------------------------------------------------
▲ Show 20 Lines • Show All 215 Lines • Show Last 20 Lines

lldb/trunk/source/Target/ThreadPlanStepOverBreakpoint.cpp

//===-- ThreadPlanStepOverBreakpoint.cpp ------------------------*- C++ -*-===// //===-- ThreadPlanStepOverBreakpoint.cpp ------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Target/ThreadPlanStepOverBreakpoint.h" #include "lldb/Target/ThreadPlanStepOverBreakpoint.h"
// C Includes // C Includes
// C++ Includes // C++ Includes
// 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;
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// ThreadPlanStepOverBreakpoint: Single steps over a breakpoint bp_site_sp at // ThreadPlanStepOverBreakpoint: Single steps over a breakpoint bp_site_sp at
// the pc. // the pc.
//---------------------------------------------------------------------- //----------------------------------------------------------------------
▲ Show 20 Lines • Show All 146 Lines • Show Last 20 Lines

lldb/trunk/source/Target/ThreadPlanStepOverRange.cpp

//===-- ThreadPlanStepOverRange.cpp -----------------------------*- C++ -*-===// //===-- ThreadPlanStepOverRange.cpp -----------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// 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"
#include "lldb/Symbol/LineTable.h" #include "lldb/Symbol/LineTable.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/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;
uint32_t ThreadPlanStepOverRange::s_default_flag_values = 0; uint32_t ThreadPlanStepOverRange::s_default_flag_values = 0;
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// ThreadPlanStepOverRange: Step through a stack range, either stepping over or // ThreadPlanStepOverRange: Step through a stack range, either stepping over or
▲ Show 20 Lines • Show All 401 Lines • Show Last 20 Lines

lldb/trunk/source/Target/ThreadPlanStepRange.cpp

Show All 10 Lines
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Target/ThreadPlanStepRange.h" #include "lldb/Target/ThreadPlanStepRange.h"
#include "lldb/Breakpoint/BreakpointLocation.h" #include "lldb/Breakpoint/BreakpointLocation.h"
#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"
#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/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;
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// ThreadPlanStepRange: Step through a stack range, either stepping over or into // ThreadPlanStepRange: Step through a stack range, either stepping over or into
// based on the value of \a type. // based on the value of \a type.
//---------------------------------------------------------------------- //----------------------------------------------------------------------
▲ Show 20 Lines • Show All 432 Lines • Show Last 20 Lines

lldb/trunk/source/Target/ThreadPlanStepThrough.cpp

//===-- ThreadPlanStepThrough.cpp -------------------------------*- C++ -*-===// //===-- ThreadPlanStepThrough.cpp -------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#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;
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// ThreadPlanStepThrough: If the current instruction is a trampoline, step // ThreadPlanStepThrough: If the current instruction is a trampoline, step
// through it // through it
// If it is the beginning of the prologue of a function, step through that as // If it is the beginning of the prologue of a function, step through that as
▲ Show 20 Lines • Show All 224 Lines • Show Last 20 Lines

lldb/trunk/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
NameMatches.cpp NameMatches.cpp
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
TaskPool.cpp TaskPool.cpp
UriParser.cpp UriParser.cpp
LINK_LIBS LINK_LIBS
lldbCore lldbCore
lldbHost lldbHost
lldbTarget lldbTarget
LINK_COMPONENTS LINK_COMPONENTS
Support Support
) )

lldb/trunk/source/Utility/ConstString.cpp

//===-- 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/trunk/source/Utility/Error.cpp

//===-- 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/trunk/source/Utility/JSON.cpp

//===--------------------- JSON.cpp -----------------------------*- C++ -*-===// //===--------------------- JSON.cpp -----------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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>
using namespace lldb_private; using namespace lldb_private;
std::string JSONString::json_string_quote_metachars(const std::string &s) { std::string JSONString::json_string_quote_metachars(const std::string &s) {
if (s.find('"') == std::string::npos) if (s.find('"') == std::string::npos)
return s; return s;
▲ Show 20 Lines • Show All 529 Lines • Show Last 20 Lines

lldb/trunk/source/Utility/ModuleCache.h

//===-- ModuleCache.h -------------------------------------------*- C++ -*-===// //===-- ModuleCache.h -------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef utility_ModuleCache_h_ #ifndef utility_ModuleCache_h_
#define utility_ModuleCache_h_ #define utility_ModuleCache_h_
#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>
#include <unordered_map> #include <unordered_map>
namespace lldb_private { namespace lldb_private {
class Module; class Module;
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

lldb/trunk/source/Utility/NameMatches.cpp

//===-- NameMatches.cpp -----------------------------------------*- C++ -*-===// //===-- NameMatches.cpp -----------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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"
using namespace lldb_private; using namespace lldb_private;
bool lldb_private::NameMatches(llvm::StringRef name, NameMatchType match_type, bool lldb_private::NameMatches(llvm::StringRef name, NameMatchType match_type,
llvm::StringRef match) { llvm::StringRef match) {
if (match_type == eNameMatchIgnore) if (match_type == eNameMatchIgnore)
Show All 26 Lines

lldb/trunk/source/Utility/RegularExpression.cpp

//===-- 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/trunk/source/Utility/SelectHelper.cpp

Show All 25 Lines
// C++ Includes // C++ Includes
#include <algorithm> #include <algorithm>
// Other libraries and framework includes // Other libraries and framework includes
#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"
SelectHelper::SelectHelper() SelectHelper::SelectHelper()
: m_fd_map(), m_end_time() // Infinite timeout unless : m_fd_map(), m_end_time() // Infinite timeout unless
// SelectHelper::SetTimeout() gets called // SelectHelper::SetTimeout() gets called
{} {}
▲ Show 20 Lines • Show All 218 Lines • Show Last 20 Lines

lldb/trunk/source/Utility/Stream.cpp

//===-- 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/trunk/source/Utility/StreamString.cpp

//===-- 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/trunk/tools/argdumper/argdumper.cpp

//===-- argdumper.cpp --------------------------------------------*- C++-*-===// //===-- argdumper.cpp --------------------------------------------*- C++-*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Core/StreamString.h"
#include "lldb/Utility/JSON.h" #include "lldb/Utility/JSON.h"
#include "lldb/Utility/StreamString.h"
#include <iostream> #include <iostream>
using namespace lldb_private; using namespace lldb_private;
int main(int argc, char *argv[]) { int main(int argc, char *argv[]) {
JSONArray::SP arguments(new JSONArray()); JSONArray::SP arguments(new JSONArray());
for (int i = 1; i < argc; i++) { for (int i = 1; i < argc; i++) {
Show All 14 Lines

lldb/trunk/tools/lldb-server/Acceptor.h

//===-- Acceptor.h ----------------------------------------------*- C++ -*-===// //===-- Acceptor.h ----------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef lldb_server_Acceptor_h_ #ifndef lldb_server_Acceptor_h_
#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>
#include <string> #include <string>
namespace llvm { namespace llvm {
class StringRef; class StringRef;
} }
Show All 39 Lines

lldb/trunk/tools/lldb-server/Acceptor.cpp

//===-- Acceptor.cpp --------------------------------------------*- C++ -*-===// //===-- Acceptor.cpp --------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "Acceptor.h" #include "Acceptor.h"
#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"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
using namespace lldb_private::lldb_server; using namespace lldb_private::lldb_server;
using namespace llvm; using namespace llvm;
▲ Show 20 Lines • Show All 113 Lines • Show Last 20 Lines

lldb/trunk/tools/lldb-server/LLDBServerUtilities.cpp

//===-- LLDBServerUtilities.cpp ---------------------------------*- C++ -*-===// //===-- LLDBServerUtilities.cpp ---------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "LLDBServerUtilities.h" #include "LLDBServerUtilities.h"
#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"
using namespace lldb; using namespace lldb;
using namespace lldb_private::lldb_server; using namespace lldb_private::lldb_server;
using namespace llvm; using namespace llvm;
Show All 34 Lines

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

Show All 22 Lines
// Other libraries and framework includes // Other libraries and framework includes
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
#include "Acceptor.h" #include "Acceptor.h"
#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"
#include "lldb/Host/OptionParser.h" #include "lldb/Host/OptionParser.h"
#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"
#endif #endif
#ifndef LLGS_VERSION_STR #ifndef LLGS_VERSION_STR
#define LLGS_VERSION_STR "local_build" #define LLGS_VERSION_STR "local_build"
#endif #endif
▲ Show 20 Lines • Show All 439 Lines • Show Last 20 Lines

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

Show All 24 Lines
// Other libraries and framework includes // Other libraries and framework includes
#include "llvm/Support/FileSystem.h" #include "llvm/Support/FileSystem.h"
#include "llvm/Support/FileUtilities.h" #include "llvm/Support/FileUtilities.h"
#include "Acceptor.h" #include "Acceptor.h"
#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;
using namespace lldb_private::lldb_server; using namespace lldb_private::lldb_server;
using namespace lldb_private::process_gdb_remote; using namespace lldb_private::process_gdb_remote;
using namespace llvm; using namespace llvm;
//---------------------------------------------------------------------- //----------------------------------------------------------------------
▲ Show 20 Lines • Show All 338 Lines • Show Last 20 Lines

lldb/trunk/unittests/Breakpoint/BreakpointIDTest.cpp

//===-- BreakpointIDTest.cpp ------------------------------------*- C++ -*-===// //===-- BreakpointIDTest.cpp ------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
TEST(BreakpointIDTest, StringIsBreakpointName) { TEST(BreakpointIDTest, StringIsBreakpointName) {
Error E; Error E;
Show All 9 Lines

lldb/trunk/unittests/Core/ErrorTest.cpp

//===-- ErrorTest.cpp -------------------------------------------*- C++ -*-===// //===-- ErrorTest.cpp -------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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;
TEST(ErrorTest, Formatv) { TEST(ErrorTest, Formatv) {
EXPECT_EQ("", llvm::formatv("{0}", Error()).str()); EXPECT_EQ("", llvm::formatv("{0}", Error()).str());
EXPECT_EQ("Hello Error", llvm::formatv("{0}", Error("Hello Error")).str()); EXPECT_EQ("Hello Error", llvm::formatv("{0}", Error("Hello Error")).str());
EXPECT_EQ("Hello", llvm::formatv("{0:5}", Error("Hello Error")).str()); EXPECT_EQ("Hello", llvm::formatv("{0:5}", Error("Hello Error")).str());
} }

lldb/trunk/unittests/Core/LogTest.cpp

//===-- LogTest.cpp ---------------------------------------------*- C++ -*-===// //===-- LogTest.cpp ---------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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;
static std::string GetLogString(uint32_t log_options, const char *format, static std::string GetLogString(uint32_t log_options, const char *format,
int arg) { int arg) {
std::shared_ptr<StreamString> stream_sp(new StreamString()); std::shared_ptr<StreamString> stream_sp(new StreamString());
Log log_(stream_sp); Log log_(stream_sp);
Show All 35 Lines

lldb/trunk/unittests/Core/ScalarTest.cpp

Show All 11 Lines
// when // when
// exceptions are disabled. // exceptions are disabled.
#include <eh.h> #include <eh.h>
#endif #endif
#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;
TEST(ScalarTest, RightShiftOperator) { TEST(ScalarTest, RightShiftOperator) {
int a = 0x00001000; int a = 0x00001000;
int b = 0xFFFFFFFF; int b = 0xFFFFFFFF;
int c = 4; int c = 4;
Scalar a_scalar(a); Scalar a_scalar(a);
▲ Show 20 Lines • Show All 110 Lines • Show Last 20 Lines

lldb/trunk/unittests/Core/StructuredDataTest.cpp

//===-- StructuredDataTest.cpp ----------------------------------*- C++ -*-===// //===-- StructuredDataTest.cpp ----------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
TEST(StructuredDataTest, StringDump) { TEST(StructuredDataTest, StringDump) {
std::pair<llvm::StringRef, llvm::StringRef> TestCases[] = { std::pair<llvm::StringRef, llvm::StringRef> TestCases[] = {
Show All 11 Lines

lldb/trunk/unittests/Core/TimerTest.cpp

Show All 10 Lines
// Workaround for MSVC standard library bug, which fails to include <thread> // Workaround for MSVC standard library bug, which fails to include <thread>
// when exceptions are disabled. // when exceptions are disabled.
#include <eh.h> #include <eh.h>
#endif #endif
#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;
TEST(TimerTest, CategoryTimes) { TEST(TimerTest, CategoryTimes) {
Timer::ResetCategoryTimes(); Timer::ResetCategoryTimes();
{ {
Timer t("CAT1", ""); Timer t("CAT1", "");
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

lldb/trunk/unittests/Editline/EditlineTest.cpp

Show All 13 Lines
#include <stdio.h> #include <stdio.h>
#include <unistd.h> #include <unistd.h>
#include <memory> #include <memory>
#include <thread> #include <thread>
#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 {
const size_t TIMEOUT_MILLIS = 5000; const size_t TIMEOUT_MILLIS = 5000;
} }
class FilePointer { class FilePointer {
public: public:
▲ Show 20 Lines • Show All 280 Lines • Show Last 20 Lines

lldb/trunk/unittests/Expression/GoParserTest.cpp

Show All 14 Lines
#include <eh.h> #include <eh.h>
#endif #endif
#include <sstream> #include <sstream>
#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;
namespace { namespace {
struct ASTPrinter { struct ASTPrinter {
ASTPrinter(GoASTNode *n) { (*this)(n); } ASTPrinter(GoASTNode *n) { (*this)(n); }
void operator()(GoASTNode *n) { void operator()(GoASTNode *n) {
▲ Show 20 Lines • Show All 249 Lines • Show Last 20 Lines
lldb/trunk/source/Core/StreamFile.cpp