diff options
32 files changed, 1769 insertions, 1551 deletions
diff --git a/lldb/include/lldb/Core/ClangForward.h b/lldb/include/lldb/Core/ClangForward.h index 3f4a2aee832..ab5166fc09d 100644 --- a/lldb/include/lldb/Core/ClangForward.h +++ b/lldb/include/lldb/Core/ClangForward.h @@ -24,9 +24,13 @@ namespace clang class Context; } + class Action; class ASTContext; + class ASTRecordLayout; class AddrLabelExpr; + class AnalyzerOptions; class BinaryOperator; + class CodeGenOptions; class CodeGenerator; class CompilerInstance; class CXXBaseSpecifier; @@ -38,18 +42,23 @@ namespace clang class CharacterLiteral; class CompoundAssignOperator; class Decl; + class DeclarationName; class DeclaratorDecl; class DeclContext; class DeclRefExpr; class DeclStmt; + class DependencyOutputOptions; class Diagnostic; + class DiagnosticOptions; class EnumDecl; class Expr; class ExtVectorElementExpr; class FieldDecl; class FloatingLiteral; + class FrontendOptions; class FunctionDecl; class GotoStmt; + class HeaderSearchOptions; class IdentifierTable; class IntegerLiteral; class LabelStmt; @@ -72,6 +81,8 @@ namespace clang class ParenExpr; class ParmVarDecl; class PredefinedExpr; + class PreprocessorOptions; + class PreprocessorOutputOptions; class QualType; class QualifiedNameType; class RecordDecl; diff --git a/lldb/include/lldb/Expression/ClangExpressionDeclMap.h b/lldb/include/lldb/Expression/ClangExpressionDeclMap.h index 7e1bdca1244..366067ff859 100644 --- a/lldb/include/lldb/Expression/ClangExpressionDeclMap.h +++ b/lldb/include/lldb/Expression/ClangExpressionDeclMap.h @@ -21,13 +21,7 @@ // Project includes #include "lldb/Core/ClangForward.h" #include "lldb/Core/Value.h" -#include "lldb/Symbol/ASTType.h" - -namespace clang { - class DeclarationName; - class DeclContext; - class QualType; -} +#include "lldb/Symbol/ClangASTType.h" namespace llvm { class Value; @@ -35,6 +29,33 @@ namespace llvm { namespace lldb_private { +//---------------------------------------------------------------------- +// For cases in which there are multiple classes of types that are not +// interchangeable, to allow static type checking. +//---------------------------------------------------------------------- +template <unsigned int C> class TaggedClangASTType : public ClangASTType +{ +public: + TaggedClangASTType (void *type, clang::ASTContext *ast_context) : + ClangASTType(type, ast_context) { } + + TaggedClangASTType (const TaggedClangASTType<C> &tw) : + ClangASTType(tw) { } + + TaggedClangASTType () : + ClangASTType() { } + + ~TaggedClangASTType() { } + + const TaggedClangASTType<C> & + operator= (const TaggedClangASTType<C> &tw) + { + ClangASTType::operator= (tw); + return *this; + } +}; + + class Error; class Function; class NameSearchContext; @@ -83,8 +104,8 @@ public: void GetDecls (NameSearchContext &context, const char *name); private: - typedef TaggedASTType<0> TypeFromParser; - typedef TaggedASTType<1> TypeFromUser; + typedef TaggedClangASTType<0> TypeFromParser; + typedef TaggedClangASTType<1> TypeFromUser; struct Tuple { diff --git a/lldb/include/lldb/Expression/ClangFunction.h b/lldb/include/lldb/Expression/ClangFunction.h index f76157a9c6d..f0555bc916a 100644 --- a/lldb/include/lldb/Expression/ClangFunction.h +++ b/lldb/include/lldb/Expression/ClangFunction.h @@ -26,11 +26,6 @@ // Right now, this is just a toy. It calls a set function, with fixed // values. -namespace clang -{ - class ASTRecordLayout; -} - namespace lldb_private { diff --git a/lldb/include/lldb/Expression/ClangResultSynthesizer.h b/lldb/include/lldb/Expression/ClangResultSynthesizer.h index ed00401486a..4953bd4b707 100644 --- a/lldb/include/lldb/Expression/ClangResultSynthesizer.h +++ b/lldb/include/lldb/Expression/ClangResultSynthesizer.h @@ -11,10 +11,7 @@ #define liblldb_ClangResultSynthesizer_h_ #include "clang/Sema/SemaConsumer.h" - -namespace clang { - class Action; -} +#include "lldb/Core/ClangForward.h" namespace lldb_private { diff --git a/lldb/include/lldb/Symbol/ASTType.h b/lldb/include/lldb/Symbol/ASTType.h deleted file mode 100644 index 3ce0789ab47..00000000000 --- a/lldb/include/lldb/Symbol/ASTType.h +++ /dev/null @@ -1,113 +0,0 @@ -//===-- ASTType.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_ASTType_h_ -#define liblldb_ASTType_h_ - -namespace clang -{ - class ASTContext; -} - -namespace lldb_private -{ - -class ASTTypeBase -{ -protected: - ASTTypeBase (void *type, clang::ASTContext *ast_context) : - m_type(type), - m_ast_context(ast_context) - { - } - - ASTTypeBase (const ASTTypeBase &tw) : - m_type(tw.m_type), - m_ast_context(tw.m_ast_context) - { - } - - ASTTypeBase () : - m_type(0), - m_ast_context(0) - { - } - - ~ASTTypeBase(); - - ASTTypeBase &operator= (const ASTTypeBase &atb) - { - m_type = atb.m_type; - m_ast_context = atb.m_ast_context; - return *this; - } - -public: - void *GetType() const - { - return m_type; - } - - clang::ASTContext *GetASTContext() const - { - return m_ast_context; - } - -private: - void *m_type; - clang::ASTContext *m_ast_context; -}; - -class ASTType : public ASTTypeBase -{ -public: - ASTType (void *type, clang::ASTContext *ast_context) : - ASTTypeBase(type, ast_context) { } - - ASTType (const ASTType &at) : - ASTTypeBase(at) { } - - ASTType () : - ASTTypeBase() { } - - ~ASTType(); - - ASTType &operator= (const ASTType &at) - { - ASTTypeBase::operator= (at); - return *this; - } -}; - -// For cases in which there are multiple classes of types that are not -// interchangeable, to allow static type checking. -template <unsigned int C> class TaggedASTType : public ASTTypeBase -{ -public: - TaggedASTType (void *type, clang::ASTContext *ast_context) : - ASTTypeBase(type, ast_context) { } - - TaggedASTType (const TaggedASTType<C> &tw) : - ASTTypeBase(tw) { } - - TaggedASTType () : - ASTTypeBase() { } - - ~TaggedASTType() { } - - TaggedASTType<C> &operator= (const TaggedASTType<C> &tw) - { - ASTTypeBase::operator= (tw); - return *this; - } -}; - -} - -#endif diff --git a/lldb/include/lldb/Symbol/ClangASTContext.h b/lldb/include/lldb/Symbol/ClangASTContext.h index faaf5872a60..565f3ce2e57 100644 --- a/lldb/include/lldb/Symbol/ClangASTContext.h +++ b/lldb/include/lldb/Symbol/ClangASTContext.h @@ -21,7 +21,7 @@ // Project includes #include "lldb/lldb-enumerations.h" #include "lldb/Core/ClangForward.h" -#include "lldb/Symbol/ASTType.h" +#include "lldb/Symbol/ClangASTType.h" namespace lldb_private { diff --git a/lldb/include/lldb/Symbol/ClangASTType.h b/lldb/include/lldb/Symbol/ClangASTType.h new file mode 100644 index 00000000000..b463d13d563 --- /dev/null +++ b/lldb/include/lldb/Symbol/ClangASTType.h @@ -0,0 +1,219 @@ +//===-- ClangASTType.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_ClangASTType_h_ +#define liblldb_ClangASTType_h_ + +#include "lldb/lldb-include.h" +#include "lldb/Core/ClangForward.h" + +namespace lldb_private { + +//---------------------------------------------------------------------- +// A class that can carry around a clang ASTContext and a opaque clang +// QualType. A clang::QualType can be easily reconstructed from an +// opaque clang type and often the ASTContext is needed when doing +// various type related tasks, so this class allows both items to travel +// in a single very lightweight class that can be used. There are many +// static equivalents of the member functions that allow the ASTContext +// and the opaque clang QualType to be specified for ease of use and +// to avoid code duplication. +//---------------------------------------------------------------------- +class ClangASTType +{ +protected: + ClangASTType (void *type, clang::ASTContext *ast_context) : + m_type (type), + m_ast (ast_context) + { + } + + ClangASTType (const ClangASTType &tw) : + m_type (tw.m_type), + m_ast (tw.m_ast) + { + } + + ClangASTType () : + m_type (0), + m_ast (0) + { + } + + ~ClangASTType(); + + const ClangASTType & + operator= (const ClangASTType &atb) + { + m_type = atb.m_type; + m_ast = atb.m_ast; + return *this; + } + +public: + void * + GetOpaqueQualType() const + { + return m_type; + } + + clang::ASTContext * + GetASTContext() const + { + return m_ast; + } + + ConstString + GetClangTypeName (); + + static ConstString + GetClangTypeName (void *clang_type); + + void + DumpValue (ExecutionContext *exe_ctx, + Stream *s, + lldb::Format format, + const DataExtractor &data, + uint32_t data_offset, + size_t data_byte_size, + uint32_t bitfield_bit_size, + uint32_t bitfield_bit_offset, + bool show_types, + bool show_summary, + bool verbose, + uint32_t depth); + + static void + DumpValue (clang::ASTContext *ast_context, + void *opaque_clang_qual_type, + ExecutionContext *exe_ctx, + Stream *s, + lldb::Format format, + const DataExtractor &data, + uint32_t data_offset, + size_t data_byte_size, + uint32_t bitfield_bit_size, + uint32_t bitfield_bit_offset, + bool show_types, + bool show_summary, + bool verbose, + uint32_t depth); + + bool + DumpTypeValue (Stream *s, + lldb::Format format, + const DataExtractor &data, + uint32_t data_offset, + size_t data_byte_size, + uint32_t bitfield_bit_size, + uint32_t bitfield_bit_offset); + + + static bool + DumpTypeValue (clang::ASTContext *ast_context, + void *opaque_clang_qual_type, + Stream *s, + lldb::Format format, + const DataExtractor &data, + uint32_t data_offset, + size_t data_byte_size, + uint32_t bitfield_bit_size, + uint32_t bitfield_bit_offset); + + void + DumpSummary (ExecutionContext *exe_ctx, + Stream *s, + const DataExtractor &data, + uint32_t data_offset, + size_t data_byte_size); + + + static void + DumpSummary (clang::ASTContext *ast_context, + void *opaque_clang_qual_type, + ExecutionContext *exe_ctx, + Stream *s, + const DataExtractor &data, + uint32_t data_offset, + size_t data_byte_size); + + + lldb::Encoding + GetEncoding (uint32_t &count); + + static lldb::Encoding + GetEncoding (void *opaque_clang_qual_type, uint32_t &count); + + lldb::Format + GetFormat (); + + static lldb::Format + GetFormat (void *opaque_clang_qual_type); + + bool + GetValueAsScalar (const DataExtractor &data, + uint32_t data_offset, + size_t data_byte_size, + Scalar &value); + + static bool + GetValueAsScalar (clang::ASTContext *ast_context, + void *opaque_clang_qual_type, + const DataExtractor &data, + uint32_t data_offset, + size_t data_byte_size, + Scalar &value); + + bool + SetValueFromScalar (const Scalar &value, + Stream &strm); + + static bool + SetValueFromScalar (clang::ASTContext *ast_context, + void *opaque_clang_qual_type, + const Scalar &value, + Stream &strm); + + bool + ReadFromMemory (ExecutionContext *exe_ctx, + lldb::addr_t addr, + lldb::AddressType address_type, + DataExtractor &data); + + static bool + ReadFromMemory (clang::ASTContext *ast_context, + void *opaque_clang_qual_type, + ExecutionContext *exe_ctx, + lldb::addr_t addr, + lldb::AddressType address_type, + DataExtractor &data); + + bool + WriteToMemory (ExecutionContext *exe_ctx, + lldb::addr_t addr, + lldb::AddressType address_type, + StreamString &new_value); + + static bool + WriteToMemory (clang::ASTContext *ast_context, + void *opaque_clang_qual_type, + ExecutionContext *exe_ctx, + lldb::addr_t addr, + lldb::AddressType address_type, + StreamString &new_value); + +private: + void *m_type; + clang::ASTContext *m_ast; +}; + + +} // namespace lldb_private + +#endif // #ifndef liblldb_ClangASTType_h_ diff --git a/lldb/include/lldb/Symbol/Type.h b/lldb/include/lldb/Symbol/Type.h index c25675ee584..d2b14018045 100644 --- a/lldb/include/lldb/Symbol/Type.h +++ b/lldb/include/lldb/Symbol/Type.h @@ -103,35 +103,6 @@ public: return m_name; } - static ConstString - GetClangTypeName (void *clang_qual_type); - - static void - DumpValue(ExecutionContext *exe_ctx, - clang::ASTContext *ast_context, - void *clang_qual_type, - Stream *s, - lldb::Format format, - const DataExtractor &data, - uint32_t data_offset, - size_t data_byte_size, - uint32_t bitfield_bit_size, - uint32_t bitfield_bit_offset, - bool show_types, - bool show_summary, - bool verbose, - uint32_t depth); - - static void - DumpSummary (ExecutionContext *exe_ctx, - clang::ASTContext *ast_context, - void *clang_qual_type, - Stream *s, - const DataExtractor &data, - uint32_t data_offset, - size_t data_byte_size); - - void DumpValue(ExecutionContext *exe_ctx, Stream *s, @@ -151,31 +122,6 @@ public: bool show_summary, bool verbose); - static bool - DumpTypeValue ( Stream *s, - clang::ASTContext *ast_context, - void *clang_qual_type, - lldb::Format format, - const DataExtractor &data, - uint32_t data_offset, - size_t data_byte_size, - uint32_t bitfield_bit_size, - uint32_t bitfield_bit_offset); - - static bool - GetValueAsScalar (clang::ASTContext *ast_context, - void *clang_qual_type, - const DataExtractor &data, - uint32_t data_offset, - size_t data_byte_size, - Scalar &value); - - static bool - SetValueFromScalar (clang::ASTContext *ast_context, - void *clang_qual_type, - const Scalar &value, - Stream &strm); - bool ReadFromMemory (ExecutionContext *exe_ctx, lldb::addr_t address, @@ -188,23 +134,6 @@ public: lldb::AddressType address_type, DataExtractor &data); - - static bool - ReadFromMemory (ExecutionContext *exe_ctx, - clang::ASTContext *ast_context, - void *clang_qual_type, - lldb::addr_t addr, - lldb::AddressType address_type, - DataExtractor &data); - - static bool - WriteToMemory (ExecutionContext *exe_ctx, - clang::ASTContext *ast_context, - void *clang_qual_type, - lldb::addr_t addr, - lldb::AddressType address_type, - StreamString &new_value); - bool GetIsDeclaration() const; @@ -223,9 +152,6 @@ public: lldb::Encoding GetEncoding (uint32_t &count); - static lldb::Encoding - GetEncoding (void *clang_qual_type, uint32_t &count); - SymbolContextScope * GetSymbolContextScope() { @@ -265,12 +191,6 @@ public: static int Compare(const Type &a, const Type &b); - static lldb::Format - GetFormat (void *clang_qual_type); - - static int - DumpClangTypeName(Stream *s, void *clang_qual_type); - protected: ConstString m_name; uint64_t m_byte_size; diff --git a/lldb/lldb.xcodeproj/project.pbxproj b/lldb/lldb.xcodeproj/project.pbxproj index d14976fc0ee..6c8863448c2 100644 --- a/lldb/lldb.xcodeproj/project.pbxproj +++ b/lldb/lldb.xcodeproj/project.pbxproj @@ -335,8 +335,8 @@ 49D7072911B5AD11001AD875 /* ClangASTSource.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 49D7072811B5AD11001AD875 /* ClangASTSource.cpp */; settings = {COMPILER_FLAGS = "-fno-rtti"; }; }; 49DA743011DE6A5A006AEF7E /* IRToDWARF.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 49DA742F11DE6A5A006AEF7E /* IRToDWARF.cpp */; }; 49DA743511DE6BB2006AEF7E /* IRToDWARF.h in Headers */ = {isa = PBXBuildFile; fileRef = 49DA743411DE6BB2006AEF7E /* IRToDWARF.h */; }; - 49E45FAA11F660DC008F7B28 /* ASTType.h in Headers */ = {isa = PBXBuildFile; fileRef = 49E45FA911F660DC008F7B28 /* ASTType.h */; }; - 49E45FAF11F660FE008F7B28 /* ASTType.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 49E45FAD11F660FE008F7B28 /* ASTType.cpp */; }; + 49E45FAA11F660DC008F7B28 /* ClangASTType.h in Headers */ = {isa = PBXBuildFile; fileRef = 49E45FA911F660DC008F7B28 /* ClangASTType.h */; }; + 49E45FAF11F660FE008F7B28 /* ClangASTType.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 49E45FAD11F660FE008F7B28 /* ClangASTType.cpp */; }; 49F1A74611B3388F003ED505 /* ClangExpressionDeclMap.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 49F1A74511B3388F003ED505 /* ClangExpressionDeclMap.cpp */; }; 49F1A74A11B338AE003ED505 /* ClangExpressionDeclMap.h in Headers */ = {isa = PBXBuildFile; fileRef = 49F1A74911B338AE003ED505 /* ClangExpressionDeclMap.h */; }; 4C08CDE811C81EF8001610A8 /* ThreadSpec.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4C08CDE711C81EF8001610A8 /* ThreadSpec.cpp */; }; @@ -912,8 +912,8 @@ 49D7072811B5AD11001AD875 /* ClangASTSource.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ClangASTSource.cpp; path = source/Expression/ClangASTSource.cpp; sourceTree = "<group>"; }; 49DA742F11DE6A5A006AEF7E /* IRToDWARF.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = IRToDWARF.cpp; path = source/Expression/IRToDWARF.cpp; sourceTree = "<group>"; }; 49DA743411DE6BB2006AEF7E /* IRToDWARF.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = IRToDWARF.h; path = include/lldb/Expression/IRToDWARF.h; sourceTree = "<group>"; }; - 49E45FA911F660DC008F7B28 /* ASTType.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = ASTType.h; path = include/lldb/Symbol/ASTType.h; sourceTree = "<group>"; }; - 49E45FAD11F660FE008F7B28 /* ASTType.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ASTType.cpp; path = source/Symbol/ASTType.cpp; sourceTree = "<group>"; }; + 49E45FA911F660DC008F7B28 /* ClangASTType.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = ClangASTType.h; path = include/lldb/Symbol/ClangASTType.h; sourceTree = "<group>"; }; + 49E45FAD11F660FE008F7B28 /* ClangASTType.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ClangASTType.cpp; path = source/Symbol/ClangASTType.cpp; sourceTree = "<group>"; }; 49EC3E98118F90AC00B1265E /* ThreadPlanCallFunction.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ThreadPlanCallFunction.cpp; path = source/Target/ThreadPlanCallFunction.cpp; sourceTree = "<group>"; }; 49EC3E9C118F90D400B1265E /* ThreadPlanCallFunction.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = ThreadPlanCallFunction.h; path = include/lldb/Target/ThreadPlanCallFunction.h; sourceTree = "<group>"; }; 49F1A74511B3388F003ED505 /* ClangExpressionDeclMap.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ClangExpressionDeclMap.cpp; path = source/Expression/ClangExpressionDeclMap.cpp; sourceTree = "<group>"; }; @@ -1669,12 +1669,12 @@ isa = PBXGroup; children = ( AF94005711C03F6500085DB9 /* SymbolVendor.cpp */, - 49E45FA911F660DC008F7B28 /* ASTType.h */, - 49E45FAD11F660FE008F7B28 /* ASTType.cpp */, 26BC7C5510F1B6E900F91463 /* Block.h */, 26BC7F1310F1B8EC00F91463 /* Block.cpp */, 26BC7C5610F1B6E900F91463 /* ClangASTContext.h */, 26BC7F1410F1B8EC00F91463 /* ClangASTContext.cpp */, + 49E45FA911F660DC008F7B28 /* ClangASTType.h */, + 49E45FAD11F660FE008F7B28 /* ClangASTType.cpp */, 26BC7C5710F1B6E900F91463 /* CompileUnit.h */, 26BC7F1510F1B8EC00F91463 /* CompileUnit.cpp */, 26BC7C5810F1B6E900F91463 /* Declaration.h */, @@ -2201,7 +2201,7 @@ 49307AB211DEA4F20081F992 /* IRForTarget.h in Headers */, 4C5DBBC911E3FEC60035160F /* CommandObjectCommands.h in Headers */, 26D27CA011ED3A4E0024D721 /* ELFHeader.h in Headers */, - 49E45FAA11F660DC008F7B28 /* ASTType.h in Headers */, + 49E45FAA11F660DC008F7B28 /* ClangASTType.h in Headers */, ); runOnlyForDeploymentPostprocessing = 0; }; @@ -2655,7 +2655,7 @@ 49307AAE11DEA4D90081F992 /* IRForTarget.cpp in Sources */, 4C5DBBC811E3FEC60035160F /* CommandObjectCommands.cpp in Sources */, 26D27C9F11ED3A4E0024D721 /* ELFHeader.cpp in Sources */, - 49E45FAF11F660FE008F7B28 /* ASTType.cpp in Sources */, + 49E45FAF11F660FE008F7B28 /* ClangASTType.cpp in Sources */, ); runOnlyForDeploymentPostprocessing = 0; }; diff --git a/lldb/source/Commands/CommandObjectExpression.cpp b/lldb/source/Commands/CommandObjectExpression.cpp index 637d3dcd52a..4135ed82cc0 100644 --- a/lldb/source/Commands/CommandObjectExpression.cpp +++ b/lldb/source/Commands/CommandObjectExpression.cpp @@ -12,8 +12,10 @@ // C Includes // C++ Includes // Other libraries and framework includes +#include "llvm/ADT/StringRef.h" + // Project includes -#include "lldb/Interpreter/Args.h" +#include "lldb/Core/Debugger.h" #include "lldb/Core/Value.h" #include "lldb/Core/InputReader.h" #include "lldb/Expression/ClangExpression.h" @@ -21,15 +23,15 @@ #include "lldb/Expression/ClangExpressionVariable.h" #include "lldb/Expression/DWARFExpression.h" #include "lldb/Host/Host.h" -#include "lldb/Core/Debugger.h" +#include "lldb/Interpreter/Args.h" #include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandReturnObject.h" +#include "lldb/Symbol/ClangASTType.h" #include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/Variable.h" #include "lldb/Target/Process.h" #include "lldb/Target/StackFrame.h" #include "lldb/Target/Target.h" -#include "llvm/ADT/StringRef.h" using namespace lldb; using namespace lldb_private; @@ -402,22 +404,26 @@ CommandObjectExpression::EvaluateExpression (const char *expr, bool bare, Stream if (clang_type) { if (m_options.show_types) - Type::DumpClangTypeName (&output_stream, clang_type); + { + ConstString type_name(ClangASTType::GetClangTypeName (clang_type)); + if (type_name) + output_stream.Printf("(%s) ", type_name.AsCString("<invalid>")); + } - Type::DumpValue (&m_exe_ctx, // The execution context for memory and variable access - ast_context, // The ASTContext that the clang type belongs to - clang_type, // The opaque clang type we want to dump that value of - &output_stream, // Stream to dump to - format, // Format to use when dumping - data, // A buffer containing the bytes for the clang type - 0, // Byte offset within "data" where value is - data.GetByteSize (), // Size in bytes of the value we are dumping - 0, // Bitfield bit size - 0, // Bitfield bit offset - m_options.show_types, // Show types? - m_options.show_summary, // Show summary? - m_options.debug, // Debug logging output? - UINT32_MAX); // Depth to dump in case this is an aggregate type + ClangASTType::DumpValue (ast_context, // The ASTContext that the clang type belongs to + clang_type, // The opaque clang type we want to dump that value of + &m_exe_ctx, // The execution context for memory and variable access + &output_stream, // Stream to dump to + format, // Format to use when dumping + data, // A buffer containing the bytes for the clang type + 0, // Byte offset within "data" where value is + data.GetByteSize (), // Size in bytes of the value we are dumping + 0, // Bitfield bit size + 0, // Bitfield bit offset + m_options.show_types, // Show types? + m_options.show_summary, // Show summary? + m_options.debug, // Debug logging output? + UINT32_MAX); // Depth to dump in case this is an aggregate type } else { diff --git a/lldb/source/Commands/CommandObjectVariable.cpp b/lldb/source/Commands/CommandObjectVariable.cpp index a14fa510d5c..7a6592b9b84 100644 --- a/lldb/source/Commands/CommandObjectVariable.cpp +++ b/lldb/source/Commands/CommandObjectVariable.cpp @@ -23,6 +23,7 @@ #include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandReturnObject.h" +#include "lldb/Symbol/ClangASTType.h" #include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/SymbolContext.h" @@ -386,12 +387,12 @@ public: Scalar scalar; - if (!Type::GetValueAsScalar (valobj->GetClangAST(), - valobj->GetOpaqueClangQualType(), - valobj->GetDataExtractor(), - 0, - valobj->GetByteSize(), - scalar)) + if (!ClangASTType::GetValueAsScalar (valobj->GetClangAST(), + valobj->GetOpaqueClangQualType(), + valobj->GetDataExtractor(), + 0, + valobj->GetByteSize(), + scalar)) return; ConstString po_output; diff --git a/lldb/source/Core/Value.cpp b/lldb/source/Core/Value.cpp index 32c27496b8f..2399059b730 100644 --- a/lldb/source/Core/Value.cpp +++ b/lldb/source/Core/Value.cpp @@ -17,6 +17,7 @@ #include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/Module.h" #include "lldb/Core/Stream.h" +#include "lldb/Symbol/ClangASTType.h" #include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/SymbolContext.h" @@ -472,7 +473,7 @@ Value::GetValueDefaultFormat () break; case eContextTypeOpaqueClangQualType: - return Type::GetFormat (m_context); + return ClangASTType::GetFormat (m_context); case eContextTypeDCRegisterInfo: if (GetRegisterInfo()) @@ -692,9 +693,9 @@ Value::ResolveValue(ExecutionContext *exe_ctx, clang::ASTContext *ast_context) lldb::AddressType address_type = m_value_type == eValueTypeLoadAddress ? eAddressTypeLoad : eAddressTypeHost; lldb::addr_t addr = m_value.ULongLong(LLDB_INVALID_ADDRESS); DataExtractor data; - if (Type::ReadFromMemory (exe_ctx, ast_context, opaque_clang_qual_type, addr, address_type, data)) + if (ClangASTType::ReadFromMemory (ast_context, opaque_clang_qual_type, exe_ctx, addr, address_type, data)) { - if (Type::GetValueAsScalar (ast_context, opaque_clang_qual_type, data, 0, data.GetByteSize(), scalar)) + if (ClangASTType::GetValueAsScalar (ast_context, opaque_clang_qual_type, data, 0, data.GetByteSize(), scalar)) { m_value = scalar; m_value_type = eValueTypeScalar; diff --git a/lldb/source/Core/ValueObject.cpp b/lldb/source/Core/ValueObject.cpp index 72984c6c082..065b18d0553 100644 --- a/lldb/source/Core/ValueObject.cpp +++ b/lldb/source/Core/ValueObject.cpp @@ -20,6 +20,7 @@ #include "lldb/Core/ValueObjectChild.h" #include "lldb/Core/ValueObjectList.h" +#include "lldb/Symbol/ClangASTType.h" #include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/Type.h" @@ -488,16 +489,16 @@ ValueObject::GetValueAsCString (ExecutionContextScope *exe_scope) if (clang_type) { StreamString sstr; - lldb::Format format = Type::GetFormat(clang_type); - if (Type::DumpTypeValue(&sstr, - GetClangAST(), // The clang AST - clang_type, // The clang type to display - format, // Format to display this type with - m_data, // Data to extract from - 0, // Byte offset into "m_data" - GetByteSize(), // Byte size of item in "m_data" - GetBitfieldBitSize(), // Bitfield bit size - GetBitfieldBitOffset())) // Bitfield bit offset + lldb::Format format = ClangASTType::GetFormat(clang_type); + if (ClangASTType::DumpTypeValue(GetClangAST(), // The clang AST + clang_type, // The clang type to display + &sstr, + format, // Format to display this type with + m_data, // Data to extract from + 0, // Byte offset into "m_data" + GetByteSize(), // Byte size of item in "m_data" + GetBitfieldBitSize(), // Bitfield bit size + GetBitfieldBitOffset())) // Bitfield bit offset m_value_str.swap(sstr.GetString()); else m_value_str.clear(); @@ -537,7 +538,7 @@ ValueObject::SetValueFromCString (ExecutionContextScope *exe_scope, const char * return false; uint32_t count = 0; - lldb::Encoding encoding = Type::GetEncoding (GetOpaqueClangQualType(), count); + lldb::Encoding encoding = ClangASTType::GetEncoding (GetOpaqueClangQualType(), count); char *end = NULL; const size_t byte_size = GetByteSize(); diff --git a/lldb/source/Core/ValueObjectChild.cpp b/lldb/source/Core/ValueObjectChild.cpp index 9b9b8d9e849..3093582998c 100644 --- a/lldb/source/Core/ValueObjectChild.cpp +++ b/lldb/source/Core/ValueObjectChild.cpp @@ -12,6 +12,7 @@ #include "lldb/Core/Module.h" #include "lldb/Core/ValueObjectList.h" +#include "lldb/Symbol/ClangASTType.h" #include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/SymbolContext.h" #include "lldb/Symbol/Type.h" @@ -103,7 +104,7 @@ ValueObjectChild::GetTypeName() { if (m_type_name.IsEmpty()) { - m_type_name = Type::GetClangTypeName (GetOpaqueClangQualType()); + m_type_name = ClangASTType::GetClangTypeName (GetOpaqueClangQualType()); if (m_type_name) { if (m_bitfield_bit_size > 0) diff --git a/lldb/source/Core/ValueObjectRegister.cpp b/lldb/source/Core/ValueObjectRegister.cpp index aae818eadd6..5d5215fe83d 100644 --- a/lldb/source/Core/ValueObjectRegister.cpp +++ b/lldb/source/Core/ValueObjectRegister.cpp @@ -15,6 +15,7 @@ // Other libraries and framework includes // Project includes #include "lldb/Core/Module.h" +#include "lldb/Symbol/ClangASTType.h" #include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/TypeList.h" #include "lldb/Target/ExecutionContext.h" @@ -250,7 +251,7 @@ ConstString ValueObjectRegister::GetTypeName() { if (m_type_name.IsEmpty()) - m_type_name = Type::GetClangTypeName (GetOpaqueClangQualType()); + m_type_name = ClangASTType::GetClangTypeName (GetOpaqueClangQualType()); return m_type_name; } diff --git a/lldb/source/Expression/ClangExpression.cpp b/lldb/source/Expression/ClangExpression.cpp index e996749de9e..9468a706c0b 100644 --- a/lldb/source/Expression/ClangExpression.cpp +++ b/lldb/source/Expression/ClangExpression.cpp @@ -55,6 +55,7 @@ // Project includes #include "lldb/Core/Log.h" +#include "lldb/Core/ClangForward.h" #include "lldb/Expression/ClangExpression.h" #include "lldb/Expression/ClangASTSource.h" #include "lldb/Expression/ClangResultSynthesizer.h" @@ -74,23 +75,6 @@ using namespace lldb_private; using namespace clang; using namespace llvm; -namespace clang { - -class AnalyzerOptions; -class CodeGenOptions; -class DependencyOutputOptions; -class DiagnosticOptions; -class FrontendOptions; -class HeaderSearchOptions; -class LangOptions; -class PreprocessorOptions; -class PreprocessorOutputOptions; -class TargetInfo; -class TargetOptions; - -} // end namespace clang - - //===----------------------------------------------------------------------===// // Utility Methods diff --git a/lldb/source/Expression/ClangExpressionDeclMap.cpp b/lldb/source/Expression/ClangExpressionDeclMap.cpp index 5a6b6740750..54bfad5772a 100644 --- a/lldb/source/Expression/ClangExpressionDeclMap.cpp +++ b/lldb/source/Expression/ClangExpressionDeclMap.cpp @@ -292,10 +292,11 @@ ClangExpressionDeclMap::DoMaterialize (bool dematerialize, TypeFromUser copied_type(ClangASTContext::CopyType(context, iter->m_parser_type.GetASTContext(), - iter->m_parser_type.GetType()), + iter->m_parser_type.GetOpaqueQualType()), context); - result_value->SetContext(Value::eContextTypeOpaqueClangQualType, copied_type.GetType()); + result_value->SetContext(Value::eContextTypeOpaqueClangQualType, + copied_type.GetOpaqueQualType()); } continue; @@ -329,7 +330,10 @@ ClangExpressionDeclMap::DoMaterializeOneVariable(bool dematerialize, return false; } - log->Printf("%s %s with type %p", (dematerialize ? "Dematerializing" : "Materializing"), name, type.GetType()); + log->Printf("%s %s with type %p", + (dematerialize ? "Dematerializing" : "Materializing"), + name, + type.GetOpaqueQualType()); std::auto_ptr<lldb_private::Value> location_value(GetVariableValue(exe_ctx, var, @@ -345,7 +349,8 @@ ClangExpressionDeclMap::DoMaterializeOneVariable(bool dematerialize, { lldb::addr_t value_addr = location_value->GetScalar().ULongLong(); - size_t bit_size = ClangASTContext::GetTypeBitSize(type.GetASTContext(), type.GetType()); + size_t bit_size = ClangASTContext::GetTypeBitSize (type.GetASTContext(), + type.GetOpaqueQualType()); size_t byte_size = bit_size % 8 ? ((bit_size + 8) / 8) : (bit_size / 8); DataBufferHeap data; @@ -488,7 +493,9 @@ ClangExpressionDeclMap::FindVariableInScope(const SymbolContext &sym_ctx, if (type->GetASTContext() == var->GetType()->GetClangAST()) { - if (!ClangASTContext::AreTypesSame(type->GetASTContext(), type->GetType(), var->GetType()->GetOpaqueClangQualType())) + if (!ClangASTContext::AreTypesSame(type->GetASTContext(), + type->GetOpaqueQualType(), + var->GetType()->GetOpaqueClangQualType())) return NULL; } else @@ -657,7 +664,7 @@ ClangExpressionDeclMap::AddOneVariable(NameSearchContext &context, &ut, &pt); - NamedDecl *var_decl = context.AddVarDecl(pt.GetType()); + NamedDecl *var_decl = context.AddVarDecl(pt.GetOpaqueQualType()); Tuple tuple; diff --git a/lldb/source/Expression/DWARFExpression.cpp b/lldb/source/Expression/DWARFExpression.cpp index 839cf2ef592..20c97b28e07 100644 --- a/lldb/source/Expression/DWARFExpression.cpp +++ b/lldb/source/Expression/DWARFExpression.cpp @@ -24,6 +24,7 @@ #include "lldb/lldb-private-log.h" +#include "lldb/Symbol/ClangASTType.h" #include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/Type.h" @@ -2273,10 +2274,10 @@ DWARFExpression::Evaluate } else { - if (!Type::SetValueFromScalar(ast_context, - clang_type, - tmp.ResolveValue(exe_ctx, ast_context), - new_value)) + if (!ClangASTType::SetValueFromScalar (ast_context, + clang_type, + tmp.ResolveValue(exe_ctx, ast_context), + new_value)) { if (error_ptr) error_ptr->SetErrorStringWithFormat ("Couldn't extract a value from an integral type.\n"); @@ -2292,12 +2293,12 @@ DWARFExpression::Evaluate { lldb::AddressType address_type = (value_type == Value::eValueTypeLoadAddress ? eAddressTypeLoad : eAddressTypeHost); lldb::addr_t addr = stack.back().GetScalar().ULongLong(LLDB_INVALID_ADDRESS); - if (!Type::WriteToMemory (exe_ctx, - ast_context, - clang_type, - addr, - address_type, - new_value)) + if (!ClangASTType::WriteToMemory (ast_context, + clang_type, + exe_ctx, + addr, + address_type, + new_value)) { if (error_ptr) error_ptr->SetErrorStringWithFormat ("Failed to write value to memory at 0x%llx.\n", addr); diff --git a/lldb/source/Host/macosx/Symbols.cpp b/lldb/source/Host/macosx/Symbols.cpp index ccdde69bcbf..3502ff5d2b0 100644 --- a/lldb/source/Host/macosx/Symbols.cpp +++ b/lldb/source/Host/macosx/Symbols.cpp @@ -11,8 +11,7 @@ // C Includes #include <dirent.h> -#include <mach-o/loader.h> -#include <mach-o/fat.h> +#include "llvm/Support/MachO.h" // C++ Includes // Other libraries and framework includes @@ -29,6 +28,7 @@ using namespace lldb; using namespace lldb_private; +using namespace llvm::MachO; extern "C" { @@ -49,8 +49,8 @@ SkinnyMachOFileContainsArchAndUUID const uint32_t magic ) { - assert(magic == MH_CIGAM || magic == MH_MAGIC || magic == MH_CIGAM_64 || magic == MH_MAGIC_64); - if (magic == MH_MAGIC || magic == MH_MAGIC_64) + assert(magic == HeaderMagic32 || magic == HeaderMagic32Swapped || magic == HeaderMagic64 || magic == HeaderMagic64Swapped); + if (magic == HeaderMagic32 || magic == HeaderMagic64) data.SetByteOrder (eByteOrderHost); else if (eByteOrderHost == eByteOrderBig) data.SetByteOrder (eByteOrderLittle); @@ -80,11 +80,11 @@ SkinnyMachOFileContainsArchAndUUID if (uuid == NULL) return true; - if (magic == MH_CIGAM_64 || magic == MH_MAGIC_64) + if (magic == HeaderMagic64Swapped || magic == HeaderMagic64) data_offset += 4; // Skip reserved field for in mach_header_64 // Make sure we have enough data for all the load commands - if (magic == MH_CIGAM_64 || magic == MH_MAGIC_64) + if (magic == HeaderMagic64Swapped || magic == HeaderMagic64) { if (data.GetByteSize() < sizeof(struct mach_header_64) + sizeofcmds) { @@ -106,7 +106,7 @@ SkinnyMachOFileContainsArchAndUUID const uint32_t cmd_offset = data_offset; // Save this data_offset in case parsing of the segment goes awry! uint32_t cmd = data.GetU32(&data_offset); uint32_t cmd_size = data.GetU32(&data_offset); - if (cmd == LC_UUID) + if (cmd == LoadCommandUUID) { UUID file_uuid (data.GetData(&data_offset, 16), 16); return file_uuid == *uuid; @@ -128,7 +128,7 @@ UniversalMachOFileContainsArchAndUUID const uint32_t magic ) { - assert(magic == FAT_CIGAM || magic == FAT_MAGIC); + assert(magic == UniversalMagic || magic == UniversalMagicSwapped); // Universal mach-o files always have their headers encoded as BIG endian data.SetByteOrder(eByteOrderBig); @@ -167,10 +167,10 @@ UniversalMachOFileContainsArchAndUUID switch (arch_magic) { - case MH_CIGAM: // 32 bit mach-o file - case MH_MAGIC: // 32 bit mach-o file - case MH_CIGAM_64: // 64 bit mach-o file - case MH_MAGIC_64: // 64 bit mach-o file + case HeaderMagic32: + case HeaderMagic32Swapped: + case HeaderMagic64: + case HeaderMagic64Swapped: if (SkinnyMachOFileContainsArchAndUUID (file_spec, arch, uuid, file_offset + arch_offset, arch_data, arch_data_offset, arch_magic)) return true; break; @@ -201,15 +201,15 @@ FileAtPathContainsArchAndUUID switch (magic) { // 32 bit mach-o file - case MH_CIGAM: - case MH_MAGIC: - case MH_CIGAM_64: - case MH_MAGIC_64: + case HeaderMagic32: + case HeaderMagic32Swapped: + case HeaderMagic64: + case HeaderMagic64Swapped: return SkinnyMachOFileContainsArchAndUUID (file_spec, arch, uuid, file_offset, data, data_offset, magic); // fat mach-o file - case FAT_CIGAM: - case FAT_MAGIC: + case UniversalMagic: + case UniversalMagicSwapped: return UniversalMachOFileContainsArchAndUUID (file_spec, arch, uuid, file_offset, data, data_offset, magic); default: diff --git a/lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.cpp b/lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.cpp index a8489dae8fb..fea069e5fc3 100644 --- a/lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.cpp +++ b/lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.cpp @@ -34,7 +34,7 @@ using namespace lldb; using namespace lldb_private; - +using namespace llvm::MachO; /// FIXME - The ObjC Runtime trampoline handler doesn't really belong here. /// I am putting it here so I can invoke it in the Trampoline code here, but @@ -191,7 +191,7 @@ DynamicLoaderMacOSXDYLD::ReadDYLDInfoFromMemoryAndSetNotificationCallback(lldb:: DataExtractor data; // Load command data if (ReadMachHeader (addr, &m_dyld.header, &data)) { - if (m_dyld.header.filetype == MH_DYLINKER) + if (m_dyld.header.filetype == HeaderFileTypeDynamicLinkEditor) { m_dyld.address = addr; ModuleSP dyld_module_sp; @@ -670,15 +670,15 @@ DynamicLoaderMacOSXDYLD::UpdateAllImageInfos() // Returns true if we succeed, false if we fail for any reason. //---------------------------------------------------------------------- bool -DynamicLoaderMacOSXDYLD::ReadMachHeader (lldb::addr_t addr, struct mach_header *header, DataExtractor *load_command_data) +DynamicLoaderMacOSXDYLD::ReadMachHeader (lldb::addr_t addr, mach_header *header, DataExtractor *load_command_data) { - DataBufferHeap header_bytes(sizeof(struct mach_header), 0); + DataBufferHeap header_bytes(sizeof(mach_header), 0); Error error; size_t bytes_read = m_process->ReadMemory (addr, header_bytes.GetBytes(), header_bytes.GetByteSize(), error); - if (bytes_read == sizeof(struct mach_header)) + if (bytes_read == sizeof(mach_header)) { uint32_t offset = 0; ::memset (header, 0, sizeof(header)); @@ -690,16 +690,16 @@ DynamicLoaderMacOSXDYLD::ReadMachHeader (lldb::addr_t addr, struct mach_header * data.SetByteOrder(DynamicLoaderMacOSXDYLD::GetByteOrderFromMagic(header->magic)); switch (header->magic) { - case MH_MAGIC: - case MH_CIGAM: + case llvm::MachO::HeaderMagic32: + case llvm::MachO::HeaderMagic32Swapped: data.SetAddressByteSize(4); - load_cmd_addr += sizeof(struct mach_header); + load_cmd_addr += sizeof(mach_header); break; - case MH_MAGIC_64: - case MH_CIGAM_64: + case llvm::MachO::HeaderMagic64: + case llvm::MachO::HeaderMagic64Swapped: data.SetAddressByteSize(8); - load_cmd_addr += sizeof(struct mach_header_64); + load_cmd_addr += sizeof(mach_header_64); break; default: @@ -707,7 +707,7 @@ DynamicLoaderMacOSXDYLD::ReadMachHeader (lldb::addr_t addr, struct mach_header * } // Read the rest of dyld's mach header - if (data.GetU32(&offset, &header->cputype, (sizeof(struct mach_header)/sizeof(uint32_t)) - 1)) + if (data.GetU32(&offset, &header->cputype, (sizeof(mach_header)/sizeof(uint32_t)) - 1)) { if (load_command_data == NULL) return true; // We were able to read the mach_header and weren't asked to read the load command bytes @@ -752,15 +752,15 @@ DynamicLoaderMacOSXDYLD::ParseLoadCommands (const DataExtractor& data, struct DY // Clear out any load command specific data from DYLIB_INFO since // we are about to read it. - if (data.ValidOffsetForDataOfSize (offset, sizeof(struct load_command))) + if (data.ValidOffsetForDataOfSize (offset, sizeof(load_command))) { - struct load_command load_cmd; + load_command load_cmd; uint32_t load_cmd_offset = offset; load_cmd.cmd = data.GetU32 (&offset); load_cmd.cmdsize = data.GetU32 (&offset); switch (load_cmd.cmd) { - case LC_SEGMENT: + case LoadCommandSegment32: { segment.name.SetTrimmedCStringWithLength ((const char *)data.GetData(&offset, 16), 16); segment.addr = data.GetU32 (&offset); @@ -769,7 +769,7 @@ DynamicLoaderMacOSXDYLD::ParseLoadCommands (const DataExtractor& data, struct DY } break; - case LC_SEGMENT_64: + case LoadCommandSegment64: { segment.name.SetTrimmedCStringWithLength ((const char *)data.GetData(&offset, 16), 16); segment.addr = data.GetU64 (&offset); @@ -778,7 +778,7 @@ DynamicLoaderMacOSXDYLD::ParseLoadCommands (const DataExtractor& data, struct DY } break; - case LC_ID_DYLINKER: + case LoadCommandDynamicLinkerIdent: if (lc_id_dylinker) { uint32_t name_offset = load_cmd_offset + data.GetU32 (&offset); @@ -787,7 +787,7 @@ DynamicLoaderMacOSXDYLD::ParseLoadCommands (const DataExtractor& data, struct DY } break; - case LC_UUID: + case LoadCommandUUID: dylib_info.uuid.SetBytes(data.GetData (&offset, 16)); break; @@ -820,7 +820,7 @@ DynamicLoaderMacOSXDYLD::UpdateAllImageInfosHeaderAndLoadCommands() ParseLoadCommands (data, m_dyld_image_infos[i], NULL); - if (m_dyld_image_infos[i].header.filetype == MH_EXECUTE) + if (m_dyld_image_infos[i].header.filetype == HeaderFileTypeExecutable) exe_idx = i; } } diff --git a/lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.h b/lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.h index 724a8b6bd6d..44fb329e35e 100644 --- a/lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.h +++ b/lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.h @@ -11,19 +11,20 @@ #define liblldb_DynamicLoaderMacOSXDYLD_h_ // C Includes -#include <mach-o/loader.h> - // C++ Includes #include <map> #include <vector> #include <string> // Other libraries and framework includes +#include "llvm/Support/MachO.h" + #include "lldb/Target/DynamicLoader.h" #include "lldb/Core/FileSpec.h" #include "lldb/Core/UUID.h" #include "lldb/Host/Mutex.h" #include "lldb/Target/Process.h" + #include "ObjCTrampolineHandler.h" class DynamicLoaderMacOSXDYLD : public lldb_private::DynamicLoader @@ -144,12 +145,12 @@ protected: { switch (m_dyld.header.magic) { - case MH_MAGIC: - case MH_CIGAM: + case llvm::MachO::HeaderMagic32: + case llvm::MachO::HeaderMagic32Swapped: return 4; - case MH_MAGIC_64: - case MH_CIGAM_64: + case llvm::MachO::HeaderMagic64: + case llvm::MachO::HeaderMagic64Swapped: return 8; default: @@ -163,12 +164,12 @@ protected: { switch (magic) { - case MH_MAGIC: - case MH_MAGIC_64: + case llvm::MachO::HeaderMagic32: + case llvm::MachO::HeaderMagic64: return lldb::eByteOrderHost; - case MH_CIGAM: - case MH_CIGAM_64: + case llvm::MachO::HeaderMagic32Swapped: + case llvm::MachO::HeaderMagic64Swapped: if (lldb::eByteOrderHost == lldb::eByteOrderBig) return lldb::eByteOrderLittle; else @@ -182,7 +183,7 @@ protected: bool ReadMachHeader (lldb::addr_t addr, - struct mach_header *header, + llvm::MachO::mach_header *header, lldb_private::DataExtractor *load_command_data); class Segment { @@ -218,7 +219,7 @@ protected: lldb::addr_t mod_date; // Modification date for this dylib lldb_private::FileSpec file_spec; // Resolved path for this dylib lldb_private::UUID uuid; // UUID for this dylib if it has one, else all zeros - struct mach_header header; // The mach header for this image + llvm::MachO::mach_header header; // The mach header for this image std::vector<Segment> segments; // All segment vmaddr and vmsize pairs for this executable (from memory of inferior) DYLDImageInfo() : diff --git a/lldb/source/Plugins/ObjectContainer/Universal-Mach-O/ObjectContainerUniversalMachO.cpp b/lldb/source/Plugins/ObjectContainer/Universal-Mach-O/ObjectContainerUniversalMachO.cpp index 015e498a7cc..f9bf3eb8cb1 100644 --- a/lldb/source/Plugins/ObjectContainer/Universal-Mach-O/ObjectContainerUniversalMachO.cpp +++ b/lldb/source/Plugins/ObjectContainer/Universal-Mach-O/ObjectContainerUniversalMachO.cpp @@ -16,7 +16,7 @@ using namespace lldb; using namespace lldb_private; - +using namespace llvm::MachO; void ObjectContainerUniversalMachO::Initialize() @@ -75,7 +75,7 @@ ObjectContainerUniversalMachO::MagicBytesMatch (DataBufferSP& dataSP) DataExtractor data(dataSP, eByteOrderHost, 4); uint32_t offset = 0; uint32_t magic = data.GetU32(&offset); - return magic == FAT_MAGIC || magic == FAT_CIGAM; + return magic == UniversalMagic || magic == UniversalMagicSwapped; } ObjectContainerUniversalMachO::ObjectContainerUniversalMachO @@ -108,20 +108,20 @@ ObjectContainerUniversalMachO::ParseHeader () m_data.SetByteOrder (eByteOrderBig); m_header.magic = m_data.GetU32(&offset); - if (m_header.magic == FAT_MAGIC) + if (m_header.magic == UniversalMagic) { m_data.SetAddressByteSize(4); m_header.nfat_arch = m_data.GetU32(&offset); - const size_t nfat_arch_size = sizeof(fat_arch_t) * m_header.nfat_arch; + const size_t nfat_arch_size = sizeof(fat_arch) * m_header.nfat_arch; // See if the current data we have is enough for all of the fat headers? if (!m_data.ValidOffsetForDataOfSize(offset, nfat_arch_size)) { // The fat headers are larger than the number of bytes we have been // given when this class was constructed. We will read the exact number // of bytes that we need. - DataBufferSP data_sp(m_file.ReadFileContents(m_offset, nfat_arch_size + sizeof(fat_header_t))); + DataBufferSP data_sp(m_file.ReadFileContents(m_offset, nfat_arch_size + sizeof(fat_header))); m_data.SetData (data_sp); } @@ -130,10 +130,10 @@ ObjectContainerUniversalMachO::ParseHeader () uint32_t arch_idx = 0; for (arch_idx = 0; arch_idx < m_header.nfat_arch; ++arch_idx) { - if (m_data.ValidOffsetForDataOfSize(offset, sizeof(fat_arch_t))) + if (m_data.ValidOffsetForDataOfSize(offset, sizeof(fat_arch))) { - fat_arch_t arch; - if (m_data.GetU32(&offset, &arch, sizeof(fat_arch_t)/sizeof(uint32_t))) + fat_arch arch; + if (m_data.GetU32(&offset, &arch, sizeof(fat_arch)/sizeof(uint32_t))) { m_fat_archs.push_back(arch); } diff --git a/lldb/source/Plugins/ObjectContainer/Universal-Mach-O/ObjectContainerUniversalMachO.h b/lldb/source/Plugins/ObjectContainer/Universal-Mach-O/ObjectContainerUniversalMachO.h index 8a7f975bc67..55a88278d8a 100644 --- a/lldb/source/Plugins/ObjectContainer/Universal-Mach-O/ObjectContainerUniversalMachO.h +++ b/lldb/source/Plugins/ObjectContainer/Universal-Mach-O/ObjectContainerUniversalMachO.h @@ -10,11 +10,11 @@ #ifndef liblldb_ObjectContainerUniversalMachO_h_ #define liblldb_ObjectContainerUniversalMachO_h_ -#include <mach-o/fat.h> - #include "lldb/Symbol/ObjectContainer.h" #include "lldb/Core/FileSpec.h" +#include "llvm/Support/MachO.h" + class ObjectContainerUniversalMachO : public lldb_private::ObjectContainer { @@ -94,10 +94,8 @@ public: protected: - typedef struct fat_header fat_header_t; - typedef struct fat_arch fat_arch_t; - fat_header_t m_header; - std::vector<fat_arch_t> m_fat_archs; + llvm::MachO::fat_header m_header; + std::vector<llvm::MachO::fat_arch> m_fat_archs; }; #endif // liblldb_ObjectContainerUniversalMachO_h_ diff --git a/lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp b/lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp index e4810a219a4..de5c73c84b4 100644 --- a/lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp +++ b/lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp @@ -9,9 +9,6 @@ #include "ObjectFileMachO.h" -#include <mach-o/nlist.h> -#include <mach-o/stab.h> - #include "lldb/Core/ArchSpec.h" #include "lldb/Core/DataBuffer.h" #include "lldb/Core/FileSpec.h" @@ -25,18 +22,10 @@ #include "lldb/Core/UUID.h" #include "lldb/Symbol/ObjectFile.h" -#ifndef S_DTRACE_DOF -// section contains DTrace Object Format -#define S_DTRACE_DOF 0xf -#endif - -#ifndef S_LAZY_DYLIB_SYMBOL_POINTERS -// section with only lazy symbol pointers to lazy loaded dylibs -#define S_LAZY_DYLIB_SYMBOL_POINTERS 0x10 -#endif using namespace lldb; using namespace lldb_private; +using namespace llvm::MachO; void @@ -85,12 +74,12 @@ MachHeaderSizeFromMagic(uint32_t magic) { switch (magic) { - case MH_MAGIC: - case MH_CIGAM: + case HeaderMagic32: + case HeaderMagic32Swapped: return sizeof(struct mach_header); - case MH_MAGIC_64: - case MH_CIGAM_64: + case HeaderMagic64: + case HeaderMagic64Swapped: return sizeof(struct mach_header_64); break; @@ -139,25 +128,25 @@ ObjectFileMachO::ParseHeader () m_header.magic = m_data.GetU32(&offset); switch (m_header.magic) { - case MH_MAGIC: + case HeaderMagic32: m_data.SetByteOrder (eByteOrderHost); m_data.SetAddressByteSize(4); can_parse = true; break; - case MH_MAGIC_64: + case HeaderMagic64: m_data.SetByteOrder (eByteOrderHost); m_data.SetAddressByteSize(8); can_parse = true; break; - case MH_CIGAM: + case HeaderMagic32Swapped: m_data.SetByteOrder(eByteOrderHost == eByteOrderBig ? eByteOrderLittle : eByteOrderBig); m_data.SetAddressByteSize(4); can_parse = true; break; - case MH_CIGAM_64: + case HeaderMagic64Swapped: m_data.SetByteOrder(eByteOrderHost == eByteOrderBig ? eByteOrderLittle : eByteOrderBig); m_data.SetAddressByteSize(8); can_parse = true; @@ -245,7 +234,7 @@ ObjectFileMachO::ParseSections () if (m_data.GetU32(&offset, &load_cmd, 2) == NULL) break; - if (load_cmd.cmd == LC_SEGMENT || load_cmd.cmd == LC_SEGMENT_64) + if (load_cmd.cmd == LoadCommandSegment32 || load_cmd.cmd == LoadCommandSegment64) { if (m_data.GetU8(&offset, (uint8_t*)load_cmd.segname, 16)) { @@ -282,13 +271,13 @@ ObjectFileMachO::ParseSections () struct section_64 sect64; ::bzero (§64, sizeof(sect64)); // Push a section into our mach sections for the section at - // index zero (NO_SECT) + // index zero (NListSectionNoSection) m_mach_sections.push_back(sect64); uint32_t segment_sect_idx; const lldb::user_id_t first_segment_sectID = sectID + 1; - const uint32_t num_u32s = load_cmd.cmd == LC_SEGMENT ? 7 : 8; + const uint32_t num_u32s = load_cmd.cmd == LoadCommandSegment32 ? 7 : 8; for (segment_sect_idx=0; segment_sect_idx<load_cmd.nsects; ++segment_sect_idx) { if (m_data.GetU8(&offset, (uint8_t*)sect64.sectname, sizeof(sect64.sectname)) == NULL) @@ -375,7 +364,7 @@ ObjectFileMachO::ParseSections () } assert (segment_sp.get()); - uint32_t mach_sect_type = sect64.flags & SECTION_TYPE; + uint32_t mach_sect_type = sect64.flags & SectionFlagMaskSectionType; static ConstString g_sect_name_objc_data ("__objc_data"); static ConstString g_sect_name_objc_msgrefs ("__objc_msgrefs"); static ConstString g_sect_name_objc_selrefs ("__objc_selrefs"); @@ -412,26 +401,23 @@ ObjectFileMachO::ParseSections () switch (mach_sect_type) { // TODO: categorize sections by other flags for regular sections - case S_REGULAR: - - sect_type = eSectionTypeOther; - break; - case S_ZEROFILL: sect_type = eSectionTypeZeroFill; break; - case S_CSTRING_LITERALS: sect_type = eSectionTypeDataCString; break; // section with only literal C strings - case S_4BYTE_LITERALS: sect_type = eSectionTypeData4; break; // section with only 4 byte literals - case S_8BYTE_LITERALS: sect_type = eSectionTypeData8; break; // section with only 8 byte literals - case S_LITERAL_POINTERS: sect_type = eSectionTypeDataPointers; break; // section with only pointers to literals - case S_NON_LAZY_SYMBOL_POINTERS: sect_type = eSectionTypeDataPointers; break; // section with only non-lazy symbol pointers - case S_LAZY_SYMBOL_POINTERS: sect_type = eSectionTypeDataPointers; break; // section with only lazy symbol pointers - case S_SYMBOL_STUBS: sect_type = eSectionTypeCode; break; // section with only symbol stubs, byte size of stub in the reserved2 field - case S_MOD_INIT_FUNC_POINTERS: sect_type = eSectionTypeDataPointers; break; // section with only function pointers for initialization - case S_MOD_TERM_FUNC_POINTERS: sect_type = eSectionTypeDataPointers; break; // section with only function pointers for termination - case S_COALESCED: sect_type = eSectionTypeOther; break; - case S_GB_ZEROFILL: sect_type = eSectionTypeZeroFill; break; - case S_INTERPOSING: sect_type = eSectionTypeCode; break; // section with only pairs of function pointers for interposing - case S_16BYTE_LITERALS: sect_type = eSectionTypeData16; break; // section with only 16 byte literals - case S_DTRACE_DOF: sect_type = eSectionTypeDebug; break; - case S_LAZY_DYLIB_SYMBOL_POINTERS: sect_type = eSectionTypeDataPointers; break; + case SectionTypeRegular: sect_type = eSectionTypeOther; break; + case SectionTypeZeroFill: sect_type = eSectionTypeZeroFill; break; + case SectionTypeCStringLiterals: sect_type = eSectionTypeDataCString; break; // section with only literal C strings + case SectionType4ByteLiterals: sect_type = eSectionTypeData4; break; // section with only 4 byte literals + case SectionType8ByteLiterals: sect_type = eSectionTypeData8; break; // section with only 8 byte literals + case SectionTypeLiteralPointers: sect_type = eSectionTypeDataPointers; break; // section with only pointers to literals + case SectionTypeNonLazySymbolPointers: sect_type = eSectionTypeDataPointers; break; // section with only non-lazy symbol pointers + case SectionTypeLazySymbolPointers: sect_type = eSectionTypeDataPointers; break; // section with only lazy symbol pointers + case SectionTypeSymbolStubs: sect_type = eSectionTypeCode; break; // section with only symbol stubs, byte size of stub in the reserved2 field + case SectionTypeModuleInitFunctionPointers: sect_type = eSectionTypeDataPointers; break; // section with only function pointers for initialization + case SectionTypeModuleTermFunctionPointers: sect_type = eSectionTypeDataPointers; break; // section with only function pointers for termination + case SectionTypeCoalesced: sect_type = eSectionTypeOther; break; + case SectionTypeZeroFillLarge: sect_type = eSectionTypeZeroFill; break; + case SectionTypeInterposing: sect_type = eSectionTypeCode; break; // section with only pairs of function pointers for interposing + case SectionType16ByteLiterals: sect_type = eSectionTypeData16; break; // section with only 16 byte literals + case SectionTypeDTraceObjectFormat: sect_type = eSectionTypeDebug; break; + case SectionTypeLazyDylibSymbolPointers: sect_type = eSectionTypeDataPointers; break; default: break; } } @@ -454,7 +440,7 @@ ObjectFileMachO::ParseSections () segment_name.Clear(); } } - if (m_header.filetype == MH_DSYM) + if (m_header.filetype == HeaderFileTypeDSYM) { if (first_segment_sectID <= sectID) { @@ -482,7 +468,7 @@ ObjectFileMachO::ParseSections () } } } - else if (load_cmd.cmd == LC_DYSYMTAB) + else if (load_cmd.cmd == LoadCommandDynamicSymtabInfo) { m_dysymtab.cmd = load_cmd.cmd; m_dysymtab.cmdsize = load_cmd.cmdsize; @@ -569,7 +555,7 @@ ObjectFileMachO::ParseSymtab (bool minimize) if (m_data.GetU32(&offset, &symtab_load_command, 2) == NULL) break; // Watch for the symbol table load command - if (symtab_load_command.cmd == LC_SYMTAB) + if (symtab_load_command.cmd == LoadCommandSymtab) { // Read in the rest of the symtab load command if (m_data.GetU32(&offset, &symtab_load_command.symoff, 4)) // fill in symoff, nsyms, stroff, strsize fields @@ -602,7 +588,7 @@ ObjectFileMachO::ParseSymtab (bool minimize) else eh_frame_section_sp = section_list->FindSectionByName (g_section_name_eh_frame); - uint8_t TEXT_eh_frame_sectID = eh_frame_section_sp.get() ? eh_frame_section_sp->GetID() : NO_SECT; + uint8_t TEXT_eh_frame_sectID = eh_frame_section_sp.get() ? eh_frame_section_sp->GetID() : NListSectionNoSection; //uint32_t symtab_offset = 0; const uint8_t* nlist_data = symtab_data_sp->GetBytes(); assert (symtab_data_sp->GetByteSize()/nlist_size >= symtab_load_command.nsyms); @@ -635,7 +621,7 @@ ObjectFileMachO::ParseSymtab (bool minimize) if (bit_width_32) { struct nlist* nlist32_ptr = (struct nlist*)(nlist_data + (nlist_idx * nlist_size)); - nlist.n_un.n_strx = nlist32_ptr->n_un.n_strx; + nlist.n_strx = nlist32_ptr->n_strx; nlist.n_type = nlist32_ptr->n_type; nlist.n_sect = nlist32_ptr->n_sect; nlist.n_desc = nlist32_ptr->n_desc; @@ -647,12 +633,12 @@ ObjectFileMachO::ParseSymtab (bool minimize) } SymbolType type = eSymbolTypeInvalid; - const char* symbol_name = &strtab_data[nlist.n_un.n_strx]; + const char* symbol_name = &strtab_data[nlist.n_strx]; if (symbol_name[0] == '\0') symbol_name = NULL; Section* symbol_section = NULL; bool add_nlist = true; - bool is_debug = ((nlist.n_type & N_STAB) != 0); + bool is_debug = ((nlist.n_type & NlistMaskStab) != 0); assert (sym_idx < num_syms); @@ -662,18 +648,21 @@ ObjectFileMachO::ParseSymtab (bool minimize) { switch (nlist.n_type) { - case N_GSYM: // global symbol: name,,NO_SECT,type,0 + case StabGlobalSymbol: + // N_GSYM -- global symbol: name,,NO_SECT,type,0 // Sometimes the N_GSYM value contains the address. if (nlist.n_value != 0) symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value); type = eSymbolTypeGlobal; break; - case N_FNAME: // procedure name (f77 kludge): name,,NO_SECT,0,0 + case StabFunctionName: + // N_FNAME -- procedure name (f77 kludge): name,,NO_SECT,0,0 type = eSymbolTypeFunction; break; - case N_FUN: // procedure: name,,n_sect,linenumber,address + case StabFunction: + // N_FUN -- procedure: name,,n_sect,linenumber,address if (symbol_name) { type = eSymbolTypeFunction; @@ -701,17 +690,20 @@ ObjectFileMachO::ParseSymtab (bool minimize) } break; - case N_STSYM: // static symbol: name,,n_sect,type,address + case StabStaticSymbol: + // N_STSYM -- static symbol: name,,n_sect,type,address symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value); type = eSymbolTypeStatic; break; - case N_LCSYM: // .lcomm symbol: name,,n_sect,type,address + case StabLocalCommon: + // N_LCSYM -- .lcomm symbol: name,,n_sect,type,address symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value); type = eSymbolTypeCommonBlock; break; - case N_BNSYM: + case StabBeginSymbol: + // N_BNSYM // We use the current number of symbols in the symbol table in lieu of // using nlist_idx in case we ever start trimming entries out if (minimize) @@ -727,7 +719,8 @@ ObjectFileMachO::ParseSymtab (bool minimize) } break; - case N_ENSYM: + case StabEndSymbol: + // N_ENSYM // Set the size of the N_BNSYM to the terminating index of this N_ENSYM // so that we can always skip the entire symbol if we need to navigate // more quickly at the source level when parsing STABS @@ -750,24 +743,29 @@ ObjectFileMachO::ParseSymtab (bool minimize) break; - case N_OPT: // emitted with gcc2_compiled and in gcc source + case StabSourceFileOptions: + // N_OPT - emitted with gcc2_compiled and in gcc source type = eSymbolTypeCompiler; break; - case N_RSYM: // register sym: name,,NO_SECT,type,register + case StabRegisterSymbol: + // N_RSYM - register sym: name,,NO_SECT,type,register type = eSymbolTypeVariable; break; - case N_SLINE: // src line: 0,,n_sect,linenumber,address + case StabSourceLine: + // N_SLINE - src line: 0,,n_sect,linenumber,address symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value); type = eSymbolTypeLineEntry; break; - case N_SSYM: // structure elt: name,,NO_SECT,type,struct_offset + case StabStructureType: + // N_SSYM - structure elt: name,,NO_SECT,type,struct_offset type = eSymbolTypeVariableType; break; - case N_SO: + case StabSourceFileName: + // N_SO - source file name type = eSymbolTypeSourceFile; if (symbol_name == NULL) { @@ -802,25 +800,29 @@ ObjectFileMachO::ParseSymtab (bool minimize) } break; - case N_OSO: // object file name: name,,0,0,st_mtime + case StabObjectFileName: + // N_OSO - object file name: name,,0,0,st_mtime type = eSymbolTypeObjectFile; break; - case N_LSYM: // local sym: name,,NO_SECT,type,offset + case StabLocalSymbol: + // N_LSYM - local sym: name,,NO_SECT,type,offset type = eSymbolTypeLocal; break; //---------------------------------------------------------------------- // INCL scopes //---------------------------------------------------------------------- - case N_BINCL: // include file beginning: name,,NO_SECT,0,sum + case StabBeginIncludeFileName: + // N_BINCL - include file beginning: name,,NO_SECT,0,sum // We use the current number of symbols in the symbol table in lieu of // using nlist_idx in case we ever start trimming entries out N_INCL_indexes.push_back(sym_idx); type = eSymbolTypeScopeBegin; break; - case N_EINCL: // include file end: name,,NO_SECT,0,0 + case StabEndIncludeFile: + // N_EINCL - include file end: name,,NO_SECT,0,0 // Set the size of the N_BINCL to the terminating index of this N_EINCL // so that we can always skip the entire symbol if we need to navigate // more quickly at the source level when parsing STABS @@ -834,27 +836,33 @@ ObjectFileMachO::ParseSymtab (bool minimize) type = eSymbolTypeScopeEnd; break; - case N_SOL: // #included file name: name,,n_sect,0,address + case StabIncludeFileName: + // N_SOL - #included file name: name,,n_sect,0,address type = eSymbolTypeHeaderFile; break; - case N_PARAMS: // compiler parameters: name,,NO_SECT,0,0 + case StabCompilerParameters: + // N_PARAMS - compiler parameters: name,,NO_SECT,0,0 type = eSymbolTypeCompiler; break; - case N_VERSION: // compiler version: name,,NO_SECT,0,0 + case StabCompilerVersion: + // N_VERSION - compiler version: name,,NO_SECT,0,0 type = eSymbolTypeCompiler; break; - case N_OLEVEL: // compiler -O level: name,,NO_SECT,0,0 + case StabCompilerOptLevel: + // N_OLEVEL - compiler -O level: name,,NO_SECT,0,0 type = eSymbolTypeCompiler; break; - case N_PSYM: // parameter: name,,NO_SECT,type,offset + case StabParameter: + // N_PSYM - parameter: name,,NO_SECT,type,offset type = eSymbolTypeVariable; break; - case N_ENTRY: // alternate entry: name,,n_sect,linenumber,address + case StabAlternateEntry: + // N_ENTRY - alternate entry: name,,n_sect,linenumber,address symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value); type = eSymbolTypeLineEntry; break; @@ -862,7 +870,8 @@ ObjectFileMachO::ParseSymtab (bool minimize) //---------------------------------------------------------------------- // Left and Right Braces //---------------------------------------------------------------------- - case N_LBRAC: // left bracket: 0,,NO_SECT,nesting level,address + case StabLeftBracket: + // N_LBRAC - left bracket: 0,,NO_SECT,nesting level,address // We use the current number of symbols in the symbol table in lieu of // using nlist_idx in case we ever start trimming entries out symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value); @@ -870,7 +879,8 @@ ObjectFileMachO::ParseSymtab (bool minimize) type = eSymbolTypeScopeBegin; break; - case N_RBRAC: // right bracket: 0,,NO_SECT,nesting level,address + case StabRightBracket: + // N_RBRAC - right bracket: 0,,NO_SECT,nesting level,address // Set the size of the N_LBRAC to the terminating index of this N_RBRAC // so that we can always skip the entire symbol if we need to navigate // more quickly at the source level when parsing STABS @@ -885,25 +895,29 @@ ObjectFileMachO::ParseSymtab (bool minimize) type = eSymbolTypeScopeEnd; break; - case N_EXCL: // deleted include file: name,,NO_SECT,0,sum + case StabDeletedIncludeFile: + // N_EXCL - deleted include file: name,,NO_SECT,0,sum type = eSymbolTypeHeaderFile; break; //---------------------------------------------------------------------- // COMM scopes //---------------------------------------------------------------------- - case N_BCOMM: // begin common: name,,NO_SECT,0,0 + case StabBeginCommon: + // N_BCOMM - begin common: name,,NO_SECT,0,0 // We use the current number of symbols in the symbol table in lieu of // using nlist_idx in case we ever start trimming entries out type = eSymbolTypeScopeBegin; N_COMM_indexes.push_back(sym_idx); break; - case N_ECOML: // end common (local name): 0,,n_sect,0,address + case StabEndCommonLocal: + // N_ECOML - end common (local name): 0,,n_sect,0,address symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value); // Fall through - case N_ECOMM: // end common: name,,n_sect,0,0 + case StabEndCommon: + // N_ECOMM - end common: name,,n_sect,0,0 // Set the size of the N_BCOMM to the terminating index of this N_ECOMM/N_ECOML // so that we can always skip the entire symbol if we need to navigate // more quickly at the source level when parsing STABS @@ -917,7 +931,8 @@ ObjectFileMachO::ParseSymtab (bool minimize) type = eSymbolTypeScopeEnd; break; - case N_LENG: // second stab entry with length information + case StabLength: + // N_LENG - second stab entry with length information type = eSymbolTypeAdditional; break; @@ -926,9 +941,9 @@ ObjectFileMachO::ParseSymtab (bool minimize) } else { - //uint8_t n_pext = N_PEXT & nlist.n_type; - uint8_t n_type = N_TYPE & nlist.n_type; - sym[sym_idx].SetExternal((N_EXT & nlist.n_type) != 0); + //uint8_t n_pext = NlistMaskPrivateExternal & nlist.n_type; + uint8_t n_type = NlistMaskType & nlist.n_type; + sym[sym_idx].SetExternal((NlistMaskExternal & nlist.n_type) != 0); if (symbol_name && ::strstr (symbol_name, ".objc") == symbol_name) { @@ -938,17 +953,17 @@ ObjectFileMachO::ParseSymtab (bool minimize) { switch (n_type) { - case N_INDR: // Fall through - case N_PBUD: // Fall through - case N_UNDF: + case NListTypeIndirect: // N_INDR - Fall through + case NListTypePreboundUndefined:// N_PBUD - Fall through + case NListTypeUndefined: // N_UNDF type = eSymbolTypeExtern; break; - case N_ABS: + case NListTypeAbsolute: // N_ABS type = eSymbolTypeAbsolute; break; - case N_SECT: + case NListTypeSection: // N_SECT symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value); assert(symbol_section != NULL); @@ -958,27 +973,27 @@ ObjectFileMachO::ParseSymtab (bool minimize) } else { - uint32_t section_type = symbol_section->GetAllFlagBits() & SECTION_TYPE; + uint32_t section_type = symbol_section->GetAllFlagBits() & SectionFlagMaskSectionType; switch (section_type) { - case S_REGULAR: break; // regular section - //case S_ZEROFILL: type = eSymbolTypeData; break; // zero fill on demand section - case S_CSTRING_LITERALS: type = eSymbolTypeData; break; // section with only literal C strings - case S_4BYTE_LITERALS: type = eSymbolTypeData; break; // section with only 4 byte literals - case S_8BYTE_LITERALS: type = eSymbolTypeData; break; // section with only 8 byte literals - case S_LITERAL_POINTERS: type = eSymbolTypeTrampoline; break; // section with only pointers to literals - case S_NON_LAZY_SYMBOL_POINTERS: type = eSymbolTypeTrampoline; break; // section with only non-lazy symbol pointers - case S_LAZY_SYMBOL_POINTERS: type = eSymbolTypeTrampoline; break; // section with only lazy symbol pointers - case S_SYMBOL_STUBS: type = eSymbolTypeTrampoline; break; // section with only symbol stubs, byte size of stub in the reserved2 field - case S_MOD_INIT_FUNC_POINTERS: type = eSymbolTypeCode; break; // section with only function pointers for initialization - case S_MOD_TERM_FUNC_POINTERS: type = eSymbolTypeCode; break; // section with only function pointers for termination - //case S_COALESCED: type = eSymbolType; break; // section contains symbols that are to be coalesced - //case S_GB_ZEROFILL: type = eSymbolTypeData; break; // zero fill on demand section (that can be larger than 4 gigabytes) - case S_INTERPOSING: type = eSymbolTypeTrampoline; break; // section with only pairs of function pointers for interposing - case S_16BYTE_LITERALS: type = eSymbolTypeData; break; // section with only 16 byte literals - case S_DTRACE_DOF: type = eSymbolTypeInstrumentation; break; - case S_LAZY_DYLIB_SYMBOL_POINTERS: type = eSymbolTypeTrampoline; break; + case SectionTypeRegular: break; // regular section + //case SectionTypeZeroFill: type = eSymbolTypeData; break; // zero fill on demand section + case SectionTypeCStringLiterals: type = eSymbolTypeData; break; // section with only literal C strings + case SectionType4ByteLiterals: type = eSymbolTypeData; break; // section with only 4 byte literals + case SectionType8ByteLiterals: type = eSymbolTypeData; break; // section with only 8 byte literals + case SectionTypeLiteralPointers: type = eSymbolTypeTrampoline; break; // section with only pointers to literals + case SectionTypeNonLazySymbolPointers: type = eSymbolTypeTrampoline; break; // section with only non-lazy symbol pointers + case SectionTypeLazySymbolPointers: type = eSymbolTypeTrampoline; break; // section with only lazy symbol pointers + case SectionTypeSymbolStubs: type = eSymbolTypeTrampoline; break; // section with only symbol stubs, byte size of stub in the reserved2 field + case SectionTypeModuleInitFunctionPointers: type = eSymbolTypeCode; break; // section with only function pointers for initialization + case SectionTypeModuleTermFunctionPointers: type = eSymbolTypeCode; break; // section with only function pointers for termination + //case SectionTypeCoalesced: type = eSymbolType; break; // section contains symbols that are to be coalesced + //case SectionTypeZeroFillLarge: type = eSymbolTypeData; break; // zero fill on demand section (that can be larger than 4 gigabytes) + case SectionTypeInterposing: type = eSymbolTypeTrampoline; break; // section with only pairs of function pointers for interposing + case SectionType16ByteLiterals: type = eSymbolTypeData; break; // section with only 16 byte literals + case SectionTypeDTraceObjectFormat: type = eSymbolTypeInstrumentation; break; + case SectionTypeLazyDylibSymbolPointers: type = eSymbolTypeTrampoline; break; default: break; } @@ -987,7 +1002,9 @@ ObjectFileMachO::ParseSymtab (bool minimize) const char *symbol_sect_name = symbol_section->GetName().AsCString(); if (symbol_section->IsDescendant (text_section_sp.get())) { - if (symbol_section->IsClear(S_ATTR_PURE_INSTRUCTIONS | S_ATTR_SELF_MODIFYING_CODE | S_ATTR_SOME_INSTRUCTIONS)) + if (symbol_section->IsClear(SectionAttrUserPureInstructions | + SectionAttrUserSelfModifyingCode | + SectionAttrSytemSomeInstructions)) type = eSymbolTypeData; else type = eSymbolTypeCode; @@ -1097,7 +1114,7 @@ ObjectFileMachO::ParseSymtab (bool minimize) for (uint32_t sect_idx = 1; sect_idx < m_mach_sections.size(); ++sect_idx) { - if ((m_mach_sections[sect_idx].flags & SECTION_TYPE) == S_SYMBOL_STUBS) + if ((m_mach_sections[sect_idx].flags & SectionFlagMaskSectionType) == SectionTypeSymbolStubs) { uint32_t symbol_stub_byte_size = m_mach_sections[sect_idx].reserved2; if (symbol_stub_byte_size == 0) @@ -1177,7 +1194,7 @@ ObjectFileMachO::Dump (Stream *s) lldb_private::Mutex::Locker locker(m_mutex); s->Printf("%.*p: ", (int)sizeof(void*) * 2, this); s->Indent(); - if (m_header.magic == MH_MAGIC_64 || m_header.magic == MH_CIGAM_64) + if (m_header.magic == HeaderMagic64 || m_header.magic == HeaderMagic64Swapped) s->PutCString("ObjectFileMachO64"); else s->PutCString("ObjectFileMachO32"); @@ -1207,7 +1224,7 @@ ObjectFileMachO::GetUUID (UUID* uuid) if (m_data.GetU32(&offset, &load_cmd, 2) == NULL) break; - if (load_cmd.cmd == LC_UUID) + if (load_cmd.cmd == LoadCommandUUID) { const uint8_t *uuid_bytes = m_data.PeekData(offset, 16); if (uuid_bytes) @@ -1239,11 +1256,11 @@ ObjectFileMachO::GetDependentModules (FileSpecList& files) switch (load_cmd.cmd) { - case LC_LOAD_DYLIB: - case LC_LOAD_WEAK_DYLIB: - case LC_REEXPORT_DYLIB: - case LC_LOAD_DYLINKER: - case LC_LOADFVMLIB: + case LoadCommandDylibLoad: + case LoadCommandDylibLoadWeak: + case LoadCommandDylibReexport: + case LoadCommandDynamicLinkerLoad: + case LoadCommandFixedVMShlibLoad: { uint32_t name_offset = cmd_offset + m_data.GetU32(&offset); const char *path = m_data.PeekCStr(name_offset); diff --git a/lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.h b/lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.h index 3ffeb242b7c..d00ae0d73c0 100644 --- a/lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.h +++ b/lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.h @@ -10,7 +10,8 @@ #ifndef liblldb_ObjectFileMachO_h_ #define liblldb_ObjectFileMachO_h_ -#include <mach-o/loader.h> +#include "llvm/Support/MachO.h" + #include "lldb/Core/FileSpec.h" #include "lldb/Host/Mutex.h" #include "lldb/Symbol/ObjectFile.h" @@ -112,13 +113,13 @@ public: protected: mutable lldb_private::Mutex m_mutex; - struct mach_header m_header; + llvm::MachO::mach_header m_header; mutable std::auto_ptr<lldb_private::SectionList> m_sections_ap; mutable std::auto_ptr<lldb_private::Symtab> m_symtab_ap; - struct dysymtab_command m_dysymtab; - std::vector<struct segment_command_64> m_mach_segments; - std::vector<struct section_64> m_mach_sections; + llvm::MachO::dysymtab_command m_dysymtab; + std::vector<llvm::MachO::segment_command_64> m_mach_segments; + std::vector<llvm::MachO::section_64> m_mach_sections; size_t ParseSections (); diff --git a/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp b/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp index ea5ac5cd14f..268e08ae29c 100644 --- a/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp +++ b/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp @@ -9,15 +9,9 @@ // C Includes #include <errno.h> -#include <mach/mach.h> -#include <mach-o/dyld.h> #include <spawn.h> -#include <sys/fcntl.h> #include <sys/types.h> -#include <sys/ptrace.h> #include <sys/stat.h> -#include <sys/sysctl.h> -#include <unistd.h> // C++ Includes #include <algorithm> diff --git a/lldb/source/Plugins/SymbolVendor/MacOSX/SymbolVendorMacOSX.cpp b/lldb/source/Plugins/SymbolVendor/MacOSX/SymbolVendorMacOSX.cpp index 270d7ed0f5d..14a62198fdb 100644 --- a/lldb/source/Plugins/SymbolVendor/MacOSX/SymbolVendorMacOSX.cpp +++ b/lldb/source/Plugins/SymbolVendor/MacOSX/SymbolVendorMacOSX.cpp @@ -9,8 +9,6 @@ #include "SymbolVendorMacOSX.h" -#include <mach/machine.h> // DebugSymbols needs this on Leopard... - #include <AvailabilityMacros.h> #include "lldb/Core/Module.h" diff --git a/lldb/source/Symbol/ASTType.cpp b/lldb/source/Symbol/ASTType.cpp deleted file mode 100644 index 8ca19db4569..00000000000 --- a/lldb/source/Symbol/ASTType.cpp +++ /dev/null @@ -1,20 +0,0 @@ -//===-- ASTType.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/Symbol/ASTType.h" - -using namespace lldb_private; - -ASTTypeBase::~ASTTypeBase() -{ -} - -ASTType::~ASTType() -{ -}
\ No newline at end of file diff --git a/lldb/source/Symbol/ClangASTContext.cpp b/lldb/source/Symbol/ClangASTContext.cpp index 754ab195930..721656532cf 100644 --- a/lldb/source/Symbol/ClangASTContext.cpp +++ b/lldb/source/Symbol/ClangASTContext.cpp @@ -316,11 +316,11 @@ ClangASTContext::getSelectorTable() return m_selector_table_ap.get(); } -SourceManager * +clang::SourceManager * ClangASTContext::getSourceManager() { if (m_source_manager_ap.get() == NULL) - m_source_manager_ap.reset(new SourceManager(*getDiagnostic())); + m_source_manager_ap.reset(new clang::SourceManager(*getDiagnostic())); return m_source_manager_ap.get(); } @@ -758,7 +758,7 @@ ClangASTContext::AddFieldToRecordType (void * record_clang_type, const char *nam QualType record_qual_type(QualType::getFromOpaquePtr(record_clang_type)); - Type *clang_type = record_qual_type.getTypePtr(); + clang::Type *clang_type = record_qual_type.getTypePtr(); if (clang_type) { const RecordType *record_type = dyn_cast<RecordType>(clang_type); @@ -863,7 +863,7 @@ ClangASTContext::SetDefaultAccessForRecordFields (void *clang_qual_type, int def if (clang_qual_type) { QualType qual_type(QualType::getFromOpaquePtr(clang_qual_type)); - Type *clang_type = qual_type.getTypePtr(); + clang::Type *clang_type = qual_type.getTypePtr(); if (clang_type) { RecordType *record_type = dyn_cast<RecordType>(clang_type); @@ -913,7 +913,7 @@ ClangASTContext::SetBaseClassesForClassType (void *class_clang_type, CXXBaseSpec { if (class_clang_type) { - Type *clang_type = QualType::getFromOpaquePtr(class_clang_type).getTypePtr(); + clang::Type *clang_type = QualType::getFromOpaquePtr(class_clang_type).getTypePtr(); if (clang_type) { RecordType *record_type = dyn_cast<RecordType>(clang_type); @@ -948,15 +948,15 @@ ClangASTContext::IsAggregateType (void *clang_type) switch (qual_type->getTypeClass()) { - case Type::IncompleteArray: - case Type::VariableArray: - case Type::ConstantArray: - case Type::ExtVector: - case Type::Vector: - case Type::Record: + case clang::Type::IncompleteArray: + case clang::Type::VariableArray: + case clang::Type::ConstantArray: + case clang::Type::ExtVector: + case clang::Type::Vector: + case clang::Type::Record: return true; - case Type::Typedef: + case clang::Type::Typedef: return ClangASTContext::IsAggregateType (cast<TypedefType>(qual_type)->LookThroughTypedefs().getAsOpaquePtr()); default: @@ -976,7 +976,7 @@ ClangASTContext::GetNumChildren (void *clang_qual_type, bool omit_empty_base_cla QualType qual_type(QualType::getFromOpaquePtr(clang_qual_type)); switch (qual_type->getTypeClass()) { - case Type::Record: + case clang::Type::Record: { const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr()); const RecordDecl *record_decl = record_type->getDecl(); @@ -1017,11 +1017,11 @@ ClangASTContext::GetNumChildren (void *clang_qual_type, bool omit_empty_base_cla } break; - case Type::ConstantArray: + case clang::Type::ConstantArray: num_children = cast<ConstantArrayType>(qual_type.getTypePtr())->getSize().getLimitedValue(); break; - case Type::Pointer: + case clang::Type::Pointer: { PointerType *pointer_type = cast<PointerType>(qual_type.getTypePtr()); QualType pointee_type = pointer_type->getPointeeType(); @@ -1034,7 +1034,7 @@ ClangASTContext::GetNumChildren (void *clang_qual_type, bool omit_empty_base_cla } break; - case Type::Typedef: + case clang::Type::Typedef: num_children = ClangASTContext::GetNumChildren (cast<TypedefType>(qual_type)->LookThroughTypedefs().getAsOpaquePtr(), omit_empty_base_classes); break; @@ -1103,7 +1103,7 @@ ClangASTContext::GetChildClangTypeAtIndex QualType parent_qual_type(QualType::getFromOpaquePtr(parent_clang_type)); switch (parent_qual_type->getTypeClass()) { - case Type::Record: + case clang::Type::Record: { const RecordType *record_type = cast<RecordType>(parent_qual_type.getTypePtr()); const RecordDecl *record_decl = record_type->getDecl(); @@ -1190,7 +1190,7 @@ ClangASTContext::GetChildClangTypeAtIndex } break; - case Type::ConstantArray: + case clang::Type::ConstantArray: { const ConstantArrayType *array = cast<ConstantArrayType>(parent_qual_type.getTypePtr()); const uint64_t element_count = array->getSize().getLimitedValue(); @@ -1211,7 +1211,7 @@ ClangASTContext::GetChildClangTypeAtIndex } break; - case Type::Pointer: + case clang::Type::Pointer: { PointerType *pointer_type = cast<PointerType>(parent_qual_type.getTypePtr()); QualType pointee_type = pointer_type->getPointeeType(); @@ -1251,7 +1251,7 @@ ClangASTContext::GetChildClangTypeAtIndex } break; - case Type::Typedef: + case clang::Type::Typedef: return GetChildClangTypeAtIndex (ast_context, parent_name, cast<TypedefType>(parent_qual_type)->LookThroughTypedefs().getAsOpaquePtr(), @@ -1461,7 +1461,7 @@ ClangASTContext::GetIndexOfChildMemberWithName QualType qual_type(QualType::getFromOpaquePtr(clang_type)); switch (qual_type->getTypeClass()) { - case Type::Record: + case clang::Type::Record: { const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr()); const RecordDecl *record_decl = record_type->getDecl(); @@ -1548,7 +1548,7 @@ ClangASTContext::GetIndexOfChildMemberWithName } break; - case Type::ConstantArray: + case clang::Type::ConstantArray: { // const ConstantArrayType *array = cast<ConstantArrayType>(parent_qual_type.getTypePtr()); // const uint64_t element_count = array->getSize().getLimitedValue(); @@ -1569,7 +1569,7 @@ ClangASTContext::GetIndexOfChildMemberWithName } break; -// case Type::MemberPointerType: +// case clang::Type::MemberPointerType: // { // MemberPointerType *mem_ptr_type = cast<MemberPointerType>(qual_type.getTypePtr()); // QualType pointee_type = mem_ptr_type->getPointeeType(); @@ -1583,8 +1583,8 @@ ClangASTContext::GetIndexOfChildMemberWithName // } // break; // - case Type::LValueReference: - case Type::RValueReference: + case clang::Type::LValueReference: + case clang::Type::RValueReference: { ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr()); QualType pointee_type = reference_type->getPointeeType(); @@ -1600,7 +1600,7 @@ ClangASTContext::GetIndexOfChildMemberWithName } break; - case Type::Pointer: + case clang::Type::Pointer: { PointerType *pointer_type = cast<PointerType>(qual_type.getTypePtr()); QualType pointee_type = pointer_type->getPointeeType(); @@ -1634,7 +1634,7 @@ ClangASTContext::GetIndexOfChildMemberWithName } break; - case Type::Typedef: + case clang::Type::Typedef: return GetIndexOfChildMemberWithName (ast_context, cast<TypedefType>(qual_type)->LookThroughTypedefs().getAsOpaquePtr(), name, @@ -1667,7 +1667,7 @@ ClangASTContext::GetIndexOfChildWithName QualType qual_type(QualType::getFromOpaquePtr(clang_type)); switch (qual_type->getTypeClass()) { - case Type::Record: + case clang::Type::Record: { const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr()); const RecordDecl *record_decl = record_type->getDecl(); @@ -1709,7 +1709,7 @@ ClangASTContext::GetIndexOfChildWithName } break; - case Type::ConstantArray: + case clang::Type::ConstantArray: { // const ConstantArrayType *array = cast<ConstantArrayType>(parent_qual_type.getTypePtr()); // const uint64_t element_count = array->getSize().getLimitedValue(); @@ -1730,7 +1730,7 @@ ClangASTContext::GetIndexOfChildWithName } break; -// case Type::MemberPointerType: +// case clang::Type::MemberPointerType: // { // MemberPointerType *mem_ptr_type = cast<MemberPointerType>(qual_type.getTypePtr()); // QualType pointee_type = mem_ptr_type->getPointeeType(); @@ -1744,8 +1744,8 @@ ClangASTContext::GetIndexOfChildWithName // } // break; // - case Type::LValueReference: - case Type::RValueReference: + case clang::Type::LValueReference: + case clang::Type::RValueReference: { ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr()); QualType pointee_type = reference_type->getPointeeType(); @@ -1760,7 +1760,7 @@ ClangASTContext::GetIndexOfChildWithName } break; - case Type::Pointer: + case clang::Type::Pointer: { PointerType *pointer_type = cast<PointerType>(qual_type.getTypePtr()); QualType pointee_type = pointer_type->getPointeeType(); @@ -1793,7 +1793,7 @@ ClangASTContext::GetIndexOfChildWithName } break; - case Type::Typedef: + case clang::Type::Typedef: return GetIndexOfChildWithName (ast_context, cast<TypedefType>(qual_type)->LookThroughTypedefs().getAsOpaquePtr(), name, @@ -1814,7 +1814,7 @@ ClangASTContext::SetTagTypeKind (void *tag_clang_type, int kind) if (tag_clang_type) { QualType tag_qual_type(QualType::getFromOpaquePtr(tag_clang_type)); - Type *clang_type = tag_qual_type.getTypePtr(); + clang::Type *clang_type = tag_qual_type.getTypePtr(); if (clang_type) { TagType *tag_type = dyn_cast<TagType>(clang_type); @@ -1844,34 +1844,34 @@ ClangASTContext::GetDeclContextForType (void *clang_type) QualType qual_type(QualType::getFromOpaquePtr(clang_type)); switch (qual_type->getTypeClass()) { - case Type::FunctionNoProto: break; - case Type::FunctionProto: break; - case Type::IncompleteArray: break; - case Type::VariableArray: break; - case Type::ConstantArray: break; - case Type::ExtVector: break; - case Type::Vector: break; - case Type::Builtin: break; - case Type::ObjCObjectPointer: break; - case Type::BlockPointer: break; - case Type::Pointer: break; - case Type::LValueReference: break; - case Type::RValueReference: break; - case Type::MemberPointer: break; - case Type::Complex: break; - case Type::ObjCInterface: break; - case Type::Record: + case clang::Type::FunctionNoProto: break; + case clang::Type::FunctionProto: break; + case clang::Type::IncompleteArray: break; + case clang::Type::VariableArray: break; + case clang::Type::ConstantArray: break; + case clang::Type::ExtVector: break; + case clang::Type::Vector: break; + case clang::Type::Builtin: break; + case clang::Type::ObjCObjectPointer: break; + case clang::Type::BlockPointer: break; + case clang::Type::Pointer: break; + case clang::Type::LValueReference: break; + case clang::Type::RValueReference: break; + case clang::Type::MemberPointer: break; + case clang::Type::Complex: break; + case clang::Type::ObjCInterface: break; + case clang::Type::Record: return cast<RecordType>(qual_type)->getDecl(); - case Type::Enum: + case clang::Type::Enum: return cast<EnumType>(qual_type)->getDecl(); - case Type::Typedef: + case clang::Type::Typedef: return ClangASTContext::GetDeclContextForType (cast<TypedefType>(qual_type)->LookThroughTypedefs().getAsOpaquePtr()); - case Type::TypeOfExpr: break; - case Type::TypeOf: break; - case Type::Decltype: break; - //case Type::QualifiedName: break; - case Type::TemplateSpecialization: break; + case clang::Type::TypeOfExpr: break; + case clang::Type::TypeOf: break; + case clang::Type::Decltype: break; + //case clang::Type::QualifiedName: break; + case clang::Type::TemplateSpecialization: break; } // No DeclContext in this type... return NULL; @@ -2006,7 +2006,7 @@ ClangASTContext::StartTagDeclarationDefinition (void *clang_type) if (clang_type) { QualType qual_type (QualType::getFromOpaquePtr(clang_type)); - Type *t = qual_type.getTypePtr(); + clang::Type *t = qual_type.getTypePtr(); if (t) { TagType *tag_type = dyn_cast<TagType>(t); @@ -2030,7 +2030,7 @@ ClangASTContext::CompleteTagDeclarationDefinition (void *clang_type) if (clang_type) { QualType qual_type (QualType::getFromOpaquePtr(clang_type)); - Type *t = qual_type.getTypePtr(); + clang::Type *t = qual_type.getTypePtr(); if (t) { TagType *tag_type = dyn_cast<TagType>(t); @@ -2091,7 +2091,7 @@ ClangASTContext::AddEnumerationValueToEnumerationType assert (identifier_table != NULL); QualType enum_qual_type (QualType::getFromOpaquePtr(enum_clang_type)); - Type *clang_type = enum_qual_type.getTypePtr(); + clang::Type *clang_type = enum_qual_type.getTypePtr(); if (clang_type) { const EnumType *enum_type = dyn_cast<EnumType>(clang_type); @@ -2171,31 +2171,31 @@ ClangASTContext::IsPointerOrReferenceType (void *clang_type, void **target_type) QualType qual_type (QualType::getFromOpaquePtr(clang_type)); switch (qual_type->getTypeClass()) { - case Type::ObjCObjectPointer: + case clang::Type::ObjCObjectPointer: if (target_type) *target_type = cast<ObjCObjectPointerType>(qual_type)->getPointeeType().getAsOpaquePtr(); return true; - case Type::BlockPointer: + case clang::Type::BlockPointer: if (target_type) *target_type = cast<BlockPointerType>(qual_type)->getPointeeType().getAsOpaquePtr(); return true; - case Type::Pointer: + case clang::Type::Pointer: if (target_type) *target_type = cast<PointerType>(qual_type)->getPointeeType().getAsOpaquePtr(); return true; - case Type::MemberPointer: + case clang::Type::MemberPointer: if (target_type) *target_type = cast<MemberPointerType>(qual_type)->getPointeeType().getAsOpaquePtr(); return true; - case Type::LValueReference: + case clang::Type::LValueReference: if (target_type) *target_type = cast<LValueReferenceType>(qual_type)->desugar().getAsOpaquePtr(); return true; - case Type::RValueReference: + case clang::Type::RValueReference: if (target_type) *target_type = cast<LValueReferenceType>(qual_type)->desugar().getAsOpaquePtr(); return true; - case Type::Typedef: + case clang::Type::Typedef: return ClangASTContext::IsPointerOrReferenceType (cast<TypedefType>(qual_type)->LookThroughTypedefs().getAsOpaquePtr()); default: break; @@ -2247,23 +2247,23 @@ ClangASTContext::IsPointerType (void *clang_type, void **target_type) QualType qual_type (QualType::getFromOpaquePtr(clang_type)); switch (qual_type->getTypeClass()) { - case Type::ObjCObjectPointer: + case clang::Type::ObjCObjectPointer: if (target_type) *target_type = cast<ObjCObjectPointerType>(qual_type)->getPointeeType().getAsOpaquePtr(); return true; - case Type::BlockPointer: + case clang::Type::BlockPointer: if (target_type) *target_type = cast<BlockPointerType>(qual_type)->getPointeeType().getAsOpaquePtr(); return true; - case Type::Pointer: + case clang::Type::Pointer: if (target_type) *target_type = cast<PointerType>(qual_type)->getPointeeType().getAsOpaquePtr(); return true; - case Type::MemberPointer: + case clang::Type::MemberPointer: if (target_type) *target_type = cast<MemberPointerType>(qual_type)->getPointeeType().getAsOpaquePtr(); return true; - case Type::Typedef: + case clang::Type::Typedef: return ClangASTContext::IsPointerOrReferenceType (cast<TypedefType>(qual_type)->LookThroughTypedefs().getAsOpaquePtr(), target_type); default: break; @@ -2320,11 +2320,11 @@ ClangASTContext::IsCStringType (void *clang_type, uint32_t &length) QualType qual_type (QualType::getFromOpaquePtr(clang_type)); switch (qual_type->getTypeClass()) { - case Type::ConstantArray: + case clang::Type::ConstantArray: { ConstantArrayType *array = cast<ConstantArrayType>(qual_type.getTypePtr()); QualType element_qual_type = array->getElementType(); - Type *canonical_type = element_qual_type->getCanonicalTypeInternal().getTypePtr(); + clang::Type *canonical_type = element_qual_type->getCanonicalTypeInternal().getTypePtr(); if (canonical_type && canonical_type->isCharType()) { // We know the size of the array and it could be a C string @@ -2335,13 +2335,13 @@ ClangASTContext::IsCStringType (void *clang_type, uint32_t &length) } break; - case Type::Pointer: + case clang::Type::Pointer: { PointerType *pointer_type = cast<PointerType>(qual_type.getTypePtr()); - Type *pointee_type_ptr = pointer_type->getPointeeType().getTypePtr(); + clang::Type *pointee_type_ptr = pointer_type->getPointeeType().getTypePtr(); if (pointee_type_ptr) { - Type *canonical_type_ptr = pointee_type_ptr->getCanonicalTypeInternal().getTypePtr(); + clang::Type *canonical_type_ptr = pointee_type_ptr->getCanonicalTypeInternal().getTypePtr(); length = 0; // No length info, read until a NULL terminator is received if (canonical_type_ptr) return canonical_type_ptr->isCharType(); @@ -2351,17 +2351,17 @@ ClangASTContext::IsCStringType (void *clang_type, uint32_t &length) } break; - case Type::Typedef: + case clang::Type::Typedef: return ClangASTContext::IsCStringType (cast<TypedefType>(qual_type)->LookThroughTypedefs().getAsOpaquePtr(), length); - case Type::LValueReference: - case Type::RValueReference: + case clang::Type::LValueReference: + case clang::Type::RValueReference: { ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr()); - Type *pointee_type_ptr = reference_type->getPointeeType().getTypePtr(); + clang::Type *pointee_type_ptr = reference_type->getPointeeType().getTypePtr(); if (pointee_type_ptr) { - Type *canonical_type_ptr = pointee_type_ptr->getCanonicalTypeInternal().getTypePtr(); + clang::Type *canonical_type_ptr = pointee_type_ptr->getCanonicalTypeInternal().getTypePtr(); length = 0; // No length info, read until a NULL terminator is received if (canonical_type_ptr) return canonical_type_ptr->isCharType(); @@ -2385,24 +2385,24 @@ ClangASTContext::IsArrayType (void * clang_type, void **member_type, uint64_t *s switch (qual_type->getTypeClass()) { - case Type::ConstantArray: + case clang::Type::ConstantArray: if (member_type) *member_type = cast<ConstantArrayType>(qual_type)->getElementType().getAsOpaquePtr(); if (size) *size = cast<ConstantArrayType>(qual_type)->getSize().getLimitedValue(ULONG_LONG_MAX); return true; - case Type::IncompleteArray: + case clang::Type::IncompleteArray: if (member_type) *member_type = cast<IncompleteArrayType>(qual_type)->getElementType().getAsOpaquePtr(); if (size) *size = 0; return true; - case Type::VariableArray: + case clang::Type::VariableArray: if (member_type) *member_type = cast<VariableArrayType>(qual_type)->getElementType().getAsOpaquePtr(); if (size) *size = 0; - case Type::DependentSizedArray: + case clang::Type::DependentSizedArray: if (member_type) *member_type = cast<DependentSizedArrayType>(qual_type)->getElementType().getAsOpaquePtr(); if (size) diff --git a/lldb/source/Symbol/ClangASTType.cpp b/lldb/source/Symbol/ClangASTType.cpp new file mode 100644 index 00000000000..6c831db5e35 --- /dev/null +++ b/lldb/source/Symbol/ClangASTType.cpp @@ -0,0 +1,1114 @@ +//===-- ClangASTType.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/Symbol/ClangASTType.h" + +#include "clang/AST/ASTConsumer.h" +#include "clang/AST/ASTContext.h" +#include "clang/AST/Decl.h" +#include "clang/AST/DeclCXX.h" +#include "clang/AST/DeclGroup.h" +#include "clang/AST/RecordLayout.h" + +#include "clang/Basic/Builtins.h" +#include "clang/Basic/IdentifierTable.h" +#include "clang/Basic/LangOptions.h" +#include "clang/Basic/SourceManager.h" +#include "clang/Basic/TargetInfo.h" + +#include "llvm/Support/FormattedStream.h" +#include "llvm/Support/raw_ostream.h" + +#include "lldb/Core/ConstString.h" +#include "lldb/Core/DataBufferHeap.h" +#include "lldb/Core/DataExtractor.h" +#include "lldb/Core/Scalar.h" +#include "lldb/Core/Stream.h" +#include "lldb/Core/StreamString.h" +#include "lldb/Symbol/ClangASTContext.h" +#include "lldb/Target/ExecutionContext.h" +#include "lldb/Target/Process.h" + +using namespace lldb_private; + +ClangASTType::~ClangASTType() +{ +} + +ConstString +ClangASTType::GetClangTypeName () +{ + return GetClangTypeName (m_type); +} + +ConstString +ClangASTType::GetClangTypeName (void *opaque_clang_qual_type) +{ + ConstString clang_type_name; + if (opaque_clang_qual_type) + { + clang::QualType qual_type(clang::QualType::getFromOpaquePtr(opaque_clang_qual_type)); + + const clang::TypedefType *typedef_type = qual_type->getAs<clang::TypedefType>(); + if (typedef_type) + { + const clang::TypedefDecl *typedef_decl = typedef_type->getDecl(); + std::string clang_typedef_name (typedef_decl->getQualifiedNameAsString()); + if (!clang_typedef_name.empty()) + clang_type_name.SetCString (clang_typedef_name.c_str()); + } + else + { + std::string type_name(qual_type.getAsString()); + if (!type_name.empty()) + clang_type_name.SetCString (type_name.c_str()); + } + } + else + { + clang_type_name.SetCString ("<invalid>"); + } + + return clang_type_name; +} + +lldb::Encoding +ClangASTType::GetEncoding (uint32_t &count) +{ + return GetEncoding(m_type, count); +} + + +lldb::Encoding +ClangASTType::GetEncoding (void *opaque_clang_qual_type, uint32_t &count) +{ + count = 1; + clang::QualType qual_type(clang::QualType::getFromOpaquePtr(opaque_clang_qual_type)); + + switch (qual_type->getTypeClass()) + { + case clang::Type::FunctionNoProto: + case clang::Type::FunctionProto: + break; + + case clang::Type::IncompleteArray: + case clang::Type::VariableArray: + break; + + case clang::Type::ConstantArray: + break; + + case clang::Type::ExtVector: + case clang::Type::Vector: + // TODO: Set this to more than one??? + break; + + case clang::Type::Builtin: + switch (cast<clang::BuiltinType>(qual_type)->getKind()) + { + default: assert(0 && "Unknown builtin type!"); + case clang::BuiltinType::Void: + break; + + case clang::BuiltinType::Bool: + case clang::BuiltinType::Char_S: + case clang::BuiltinType::SChar: + case clang::BuiltinType::WChar: + case clang::BuiltinType::Char16: + case clang::BuiltinType::Char32: + case clang::BuiltinType::Short: + case clang::BuiltinType::Int: + case clang::BuiltinType::Long: + case clang::BuiltinType::LongLong: + case clang::BuiltinType::Int128: return lldb::eEncodingSint; + + case clang::BuiltinType::Char_U: + case clang::BuiltinType::UChar: + case clang::BuiltinType::UShort: + case clang::BuiltinType::UInt: + case clang::BuiltinType::ULong: + case clang::BuiltinType::ULongLong: + case clang::BuiltinType::UInt128: return lldb::eEncodingUint; + + case clang::BuiltinType::Float: + case clang::BuiltinType::Double: + case clang::BuiltinType::LongDouble: return lldb::eEncodingIEEE754; + + case clang::BuiltinType::NullPtr: return lldb::eEncodingUint; + } + break; + // All pointer types are represented as unsigned integer encodings. + // We may nee to add a eEncodingPointer if we ever need to know the + // difference + case clang::Type::ObjCObjectPointer: + case clang::Type::BlockPointer: + case clang::Type::Pointer: + case clang::Type::LValueReference: + case clang::Type::RValueReference: + case clang::Type::MemberPointer: return lldb::eEncodingUint; + // Complex numbers are made up of floats + case clang::Type::Complex: + count = 2; + return lldb::eEncodingIEEE754; + + case clang::Type::ObjCInterface: break; + case clang::Type::Record: break; + case clang::Type::Enum: return lldb::eEncodingSint; + case clang::Type::Typedef: + return GetEncoding(cast<clang::TypedefType>(qual_type)->LookThroughTypedefs().getAsOpaquePtr(), count); + break; + + case clang::Type::TypeOfExpr: + case clang::Type::TypeOf: + case clang::Type::Decltype: +// case clang::Type::QualifiedName: + case clang::Type::TemplateSpecialization: break; + } + count = 0; + return lldb::eEncodingInvalid; +} + +lldb::Format +ClangASTType::GetFormat () +{ + return GetFormat (m_type); +} + +lldb::Format +ClangASTType::GetFormat (void *opaque_clang_qual_type) +{ + clang::QualType qual_type(clang::QualType::getFromOpaquePtr(opaque_clang_qual_type)); + + switch (qual_type->getTypeClass()) + { + case clang::Type::FunctionNoProto: + case clang::Type::FunctionProto: + break; + + case clang::Type::IncompleteArray: + case clang::Type::VariableArray: + break; + + case clang::Type::ConstantArray: + break; + + case clang::Type::ExtVector: + case clang::Type::Vector: + break; + + case clang::Type::Builtin: + switch (cast<clang::BuiltinType>(qual_type)->getKind()) + { + default: assert(0 && "Unknown builtin type!"); + case clang::BuiltinType::Void: + break; + + case clang::BuiltinType::Bool: return lldb::eFormatBoolean; + case clang::BuiltinType::Char_S: + case clang::BuiltinType::SChar: + case clang::BuiltinType::Char_U: + case clang::BuiltinType::UChar: + case clang::BuiltinType::WChar: return lldb::eFormatChar; + case clang::BuiltinType::Char16: return lldb::eFormatUnicode16; + case clang::BuiltinType::Char32: return lldb::eFormatUnicode32; + case clang::BuiltinType::UShort: return lldb::eFormatHex; + case clang::BuiltinType::Short: return lldb::eFormatDecimal; + case clang::BuiltinType::UInt: return lldb::eFormatHex; + case clang::BuiltinType::Int: return lldb::eFormatDecimal; + case clang::BuiltinType::ULong: return lldb::eFormatHex; + case clang::BuiltinType::Long: return lldb::eFormatDecimal; + case clang::BuiltinType::ULongLong: return lldb::eFormatHex; + case clang::BuiltinType::LongLong: return lldb::eFormatDecimal; + case clang::BuiltinType::UInt128: return lldb::eFormatHex; + case clang::BuiltinType::Int128: return lldb::eFormatDecimal; + case clang::BuiltinType::Float: return lldb::eFormatFloat; + case clang::BuiltinType::Double: return lldb::eFormatFloat; + case clang::BuiltinType::LongDouble: return lldb::eFormatFloat; + case clang::BuiltinType::NullPtr: return lldb::eFormatHex; + } + break; + case clang::Type::ObjCObjectPointer: return lldb::eFormatHex; + case clang::Type::BlockPointer: return lldb::eFormatHex; + case clang::Type::Pointer: return lldb::eFormatHex; + case clang::Type::LValueReference: + case clang::Type::RValueReference: return lldb::eFormatHex; + case clang::Type::MemberPointer: break; + case clang::Type::Complex: return lldb::eFormatComplex; + case clang::Type::ObjCInterface: break; + case clang::Type::Record: break; + case clang::Type::Enum: return lldb::eFormatEnum; + case clang::Type::Typedef: + return ClangASTType::GetFormat(cast<clang::TypedefType>(qual_type)->LookThroughTypedefs().getAsOpaquePtr()); + + case clang::Type::TypeOfExpr: + case clang::Type::TypeOf: + case clang::Type::Decltype: +// case clang::Type::QualifiedName: + case clang::Type::TemplateSpecialization: break; + } + // We don't know hot to display this type... + return lldb::eFormatBytes; +} + + +void +ClangASTType::DumpValue +( + ExecutionContext *exe_ctx, + Stream *s, + lldb::Format format, + const lldb_private::DataExtractor &data, + uint32_t data_byte_offset, + size_t data_byte_size, + uint32_t bitfield_bit_size, + uint32_t bitfield_bit_offset, + bool show_types, + bool show_summary, + bool verbose, + uint32_t depth +) +{ + return DumpValue (m_ast, + m_type, + exe_ctx, + s, + format, + data, + data_byte_offset, + data_byte_size, + bitfield_bit_size, + bitfield_bit_offset, + show_types, + show_summary, + verbose, + depth); +} + +#define DEPTH_INCREMENT 2 +void +ClangASTType::DumpValue +( + clang::ASTContext *ast_context, + void *opaque_clang_qual_type, + ExecutionContext *exe_ctx, + Stream *s, + lldb::Format format, + const lldb_private::DataExtractor &data, + uint32_t data_byte_offset, + size_t data_byte_size, + uint32_t bitfield_bit_size, + uint32_t bitfield_bit_offset, + bool show_types, + bool show_summary, + bool verbose, + uint32_t depth +) +{ + clang::QualType qual_type(clang::QualType::getFromOpaquePtr(opaque_clang_qual_type)); + switch (qual_type->getTypeClass()) + { + case clang::Type::Record: + { + const clang::RecordType *record_type = cast<clang::RecordType>(qual_type.getTypePtr()); + const clang::RecordDecl *record_decl = record_type->getDecl(); + assert(record_decl); + uint32_t field_bit_offset = 0; + uint32_t field_byte_offset = 0; + const clang::ASTRecordLayout &record_layout = ast_context->getASTRecordLayout(record_decl); + uint32_t child_idx = 0; + + + const clang::CXXRecordDecl *cxx_record_decl = dyn_cast<clang::CXXRecordDecl>(record_decl); + if (cxx_record_decl) + { + // We might have base classes to print out first + clang::CXXRecordDecl::base_class_const_iterator base_class, base_class_end; + for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end(); + base_class != base_class_end; + ++base_class) + { + const clang::CXXRecordDecl *base_class_decl = cast<clang::CXXRecordDecl>(base_class->getType()->getAs<clang::RecordType>()->getDecl()); + + // Skip empty base classes + if (verbose == false && ClangASTContext::RecordHasFields(base_class_decl) == false) + continue; + + if (base_class->isVirtual()) + field_bit_offset = record_layout.getVBaseClassOffset(base_class_decl); + else + field_bit_offset = record_layout.getBaseClassOffset(base_class_decl); + field_byte_offset = field_bit_offset / 8; + assert (field_bit_offset % 8 == 0); + if (child_idx == 0) + s->PutChar('{'); + else + s->PutChar(','); + + clang::QualType base_class_qual_type = base_class->getType(); + std::string base_class_type_name(base_class_qual_type.getAsString()); + + // Indent and print the base class type name + s->Printf("\n%*s%s ", depth + DEPTH_INCREMENT, "", base_class_type_name.c_str()); + + std::pair<uint64_t, unsigned> base_class_type_info = ast_context->getTypeInfo(base_class_qual_type); + + // Dump the value of the member + DumpValue (ast_context, // The clang AST context for this type + base_class_qual_type.getAsOpaquePtr(),// The clang type we want to dump + exe_ctx, + s, // Stream to dump to + ClangASTType::GetFormat(base_class_qual_type.getAsOpaquePtr()), // The format with which to display the member + data, // Data buffer containing all bytes for this type + data_byte_offset + field_byte_offset,// Offset into "data" where to grab value from + base_class_type_info.first / 8, // Size of this type in bytes + 0, // Bitfield bit size + 0, // Bitfield bit offset + show_types, // Boolean indicating if we should show the variable types + show_summary, // Boolean indicating if we should show a summary for the current type + verbose, // Verbose output? + depth + DEPTH_INCREMENT); // Scope depth for any types that have children + + ++child_idx; + } + } + uint32_t field_idx = 0; + clang::RecordDecl::field_iterator field, field_end; + for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field, ++field_idx, ++child_idx) + { + // Print the starting squiggly bracket (if this is the + // first member) or comman (for member 2 and beyong) for + // the struct/union/class member. + if (child_idx == 0) + s->PutChar('{'); + else + s->PutChar(','); + + // Indent + s->Printf("\n%*s", depth + DEPTH_INCREMENT, ""); + + clang::QualType field_type = field->getType(); + // Print the member type if requested + // Figure out the type byte size (field_type_info.first) and + // alignment (field_type_info.second) from the AST context. + std::pair<uint64_t, unsigned> field_type_info = ast_context->getTypeInfo(field_type); + assert(field_idx < record_layout.getFieldCount()); + // Figure out the field offset within the current struct/union/class type + field_bit_offset = record_layout.getFieldOffset (field_idx); + field_byte_offset = field_bit_offset / 8; + uint32_t field_bitfield_bit_size = 0; + uint32_t field_bitfield_bit_offset = 0; + if (ClangASTContext::FieldIsBitfield (ast_context, *field, field_bitfield_bit_size)) + field_bitfield_bit_offset = field_bit_offset % 8; + + if (show_types) + { + std::string field_type_name(field_type.getAsString()); + if (field_bitfield_bit_size > 0) + s->Printf("(%s:%u) ", field_type_name.c_str(), field_bitfield_bit_size); + else + s->Printf("(%s) ", field_type_name.c_str()); + } + // Print the member name and equal sign + s->Printf("%s = ", field->getNameAsString().c_str()); + + + // Dump the value of the member + DumpValue (ast_context, // The clang AST context for this type + field_type.getAsOpaquePtr(), // The clang type we want to dump + exe_ctx, + s, // Stream to dump to + ClangASTType::GetFormat(field_type.getAsOpaquePtr()), // The format with which to display the member + data, // Data buffer containing all bytes for this type + data_byte_offset + field_byte_offset,// Offset into "data" where to grab value from + field_type_info.first / 8, // Size of this type in bytes + field_bitfield_bit_size, // Bitfield bit size + field_bitfield_bit_offset, // Bitfield bit offset + show_types, // Boolean indicating if we should show the variable types + show_summary, // Boolean indicating if we should show a summary for the current type + verbose, // Verbose output? + depth + DEPTH_INCREMENT); // Scope depth for any types that have children + } + + // Indent the trailing squiggly bracket + if (child_idx > 0) + s->Printf("\n%*s}", depth, ""); + } + return; + + case clang::Type::Enum: + { + const clang::EnumType *enum_type = cast<clang::EnumType>(qual_type.getTypePtr()); + const clang::EnumDecl *enum_decl = enum_type->getDecl(); + assert(enum_decl); + clang::EnumDecl::enumerator_iterator enum_pos, enum_end_pos; + uint32_t offset = data_byte_offset; + const int64_t enum_value = data.GetMaxU64Bitfield(&offset, data_byte_size, bitfield_bit_size, bitfield_bit_offset); + for (enum_pos = enum_decl->enumerator_begin(), enum_end_pos = enum_decl->enumerator_end(); enum_pos != enum_end_pos; ++enum_pos) + { + if (enum_pos->getInitVal() == enum_value) + { + s->Printf("%s", enum_pos->getNameAsCString()); + return; + } + } + // If we have gotten here we didn't get find the enumerator in the + // enum decl, so just print the integer. + s->Printf("%lli", enum_value); + } + return; + + case clang::Type::ConstantArray: + { + const clang::ConstantArrayType *array = cast<clang::ConstantArrayType>(qual_type.getTypePtr()); + bool is_array_of_characters = false; + clang::QualType element_qual_type = array->getElementType(); + + clang::Type *canonical_type = element_qual_type->getCanonicalTypeInternal().getTypePtr(); + if (canonical_type) + is_array_of_characters = canonical_type->isCharType(); + + const uint64_t element_count = array->getSize().getLimitedValue(); + + std::pair<uint64_t, unsigned> field_type_info = ast_context->getTypeInfo(element_qual_type); + + uint32_t element_idx = 0; + uint32_t element_offset = 0; + uint64_t element_byte_size = field_type_info.first / 8; + uint32_t element_stride = element_byte_size; + + if (is_array_of_characters) + { + s->PutChar('"'); + data.Dump(s, data_byte_offset, lldb::eFormatChar, element_byte_size, element_count, UINT32_MAX, LLDB_INVALID_ADDRESS, 0, 0); + s->PutChar('"'); + return; + } + else + { + lldb::Format element_format = ClangASTType::GetFormat(element_qual_type.getAsOpaquePtr()); + + for (element_idx = 0; element_idx < element_count; ++element_idx) + { + // Print the starting squiggly bracket (if this is the + // first member) or comman (for member 2 and beyong) for + // the struct/union/class member. + if (element_idx == 0) + s->PutChar('{'); + else + s->PutChar(','); + + // Indent and print the index + s->Printf("\n%*s[%u] ", depth + DEPTH_INCREMENT, "", element_idx); + + // Figure out the field offset within the current struct/union/class type + element_offset = element_idx * element_stride; + + // Dump the value of the member + DumpValue (ast_context, // The clang AST context for this type + element_qual_type.getAsOpaquePtr(), // The clang type we want to dump + exe_ctx, + s, // Stream to dump to + element_format, // The format with which to display the element + data, // Data buffer containing all bytes for this type + data_byte_offset + element_offset,// Offset into "data" where to grab value from + element_byte_size, // Size of this type in bytes + 0, // Bitfield bit size + 0, // Bitfield bit offset + show_types, // Boolean indicating if we should show the variable types + show_summary, // Boolean indicating if we should show a summary for the current type + verbose, // Verbose output? + depth + DEPTH_INCREMENT); // Scope depth for any types that have children + } + + // Indent the trailing squiggly bracket + if (element_idx > 0) + s->Printf("\n%*s}", depth, ""); + } + } + return; + + case clang::Type::Typedef: + { + clang::QualType typedef_qual_type = cast<clang::TypedefType>(qual_type)->LookThroughTypedefs(); + lldb::Format typedef_format = ClangASTType::GetFormat(typedef_qual_type.getAsOpaquePtr()); + std::pair<uint64_t, unsigned> typedef_type_info = ast_context->getTypeInfo(typedef_qual_type); + uint64_t typedef_byte_size = typedef_type_info.first / 8; + + return DumpValue (ast_context, // The clang AST context for this type + typedef_qual_type.getAsOpaquePtr(), // The clang type we want to dump + exe_ctx, + s, // Stream to dump to + typedef_format, // The format with which to display the element + data, // Data buffer containing all bytes for this type + data_byte_offset, // Offset into "data" where to grab value from + typedef_byte_size, // Size of this type in bytes + bitfield_bit_size, // Bitfield bit size + bitfield_bit_offset,// Bitfield bit offset + show_types, // Boolean indicating if we should show the variable types + show_summary, // Boolean indicating if we should show a summary for the current type + verbose, // Verbose output? + depth); // Scope depth for any types that have children + } + break; + + default: + // We are down the a scalar type that we just need to display. + data.Dump(s, data_byte_offset, format, data_byte_size, 1, UINT32_MAX, LLDB_INVALID_ADDRESS, bitfield_bit_size, bitfield_bit_offset); + + if (show_summary) + DumpSummary (ast_context, opaque_clang_qual_type, exe_ctx, s, data, data_byte_offset, data_byte_size); + break; + } +} + + + +bool +ClangASTType::DumpTypeValue +( + Stream *s, + lldb::Format format, + const lldb_private::DataExtractor &data, + uint32_t byte_offset, + size_t byte_size, + uint32_t bitfield_bit_size, + uint32_t bitfield_bit_offset +) +{ + return DumpTypeValue (m_ast, + m_type, + s, + format, + data, + byte_offset, + byte_size, + bitfield_bit_size, + bitfield_bit_offset); +} + + +bool +ClangASTType::DumpTypeValue +( + clang::ASTContext *ast_context, + void *opaque_clang_qual_type, + Stream *s, + lldb::Format format, + const lldb_private::DataExtractor &data, + uint32_t byte_offset, + size_t byte_size, + uint32_t bitfield_bit_size, + uint32_t bitfield_bit_offset +) +{ + clang::QualType qual_type(clang::QualType::getFromOpaquePtr(opaque_clang_qual_type)); + if (ClangASTContext::IsAggregateType (opaque_clang_qual_type)) + { + return 0; + } + else + { + switch (qual_type->getTypeClass()) + { + case clang::Type::Enum: + { + const clang::EnumType *enum_type = cast<clang::EnumType>(qual_type.getTypePtr()); + const clang::EnumDecl *enum_decl = enum_type->getDecl(); + assert(enum_decl); + clang::EnumDecl::enumerator_iterator enum_pos, enum_end_pos; + uint32_t offset = byte_offset; + const int64_t enum_value = data.GetMaxU64Bitfield (&offset, byte_size, bitfield_bit_size, bitfield_bit_offset); + for (enum_pos = enum_decl->enumerator_begin(), enum_end_pos = enum_decl->enumerator_end(); enum_pos != enum_end_pos; ++enum_pos) + { + if (enum_pos->getInitVal() == enum_value) + { + s->PutCString (enum_pos->getNameAsCString()); + return true; + } + } + // If we have gotten here we didn't get find the enumerator in the + // enum decl, so just print the integer. + + s->Printf("%lli", enum_value); + return true; + } + break; + + case clang::Type::Typedef: + { + clang::QualType typedef_qual_type = cast<clang::TypedefType>(qual_type)->LookThroughTypedefs(); + lldb::Format typedef_format = ClangASTType::GetFormat(typedef_qual_type.getAsOpaquePtr()); + std::pair<uint64_t, unsigned> typedef_type_info = ast_context->getTypeInfo(typedef_qual_type); + uint64_t typedef_byte_size = typedef_type_info.first / 8; + + return ClangASTType::DumpTypeValue( + ast_context, // The clang AST context for this type + typedef_qual_type.getAsOpaquePtr(), // The clang type we want to dump + s, + typedef_format, // The format with which to display the element + data, // Data buffer containing all bytes for this type + byte_offset, // Offset into "data" where to grab value from + typedef_byte_size, // Size of this type in bytes + bitfield_bit_size, // Size in bits of a bitfield value, if zero don't treat as a bitfield + bitfield_bit_offset); // Offset in bits of a bitfield value if bitfield_bit_size != 0 + } + break; + + default: + // We are down the a scalar type that we just need to display. + return data.Dump(s, + byte_offset, + format, + byte_size, + 1, + UINT32_MAX, + LLDB_INVALID_ADDRESS, + bitfield_bit_size, + bitfield_bit_offset); + break; + } + } + return 0; +} + + + +void +ClangASTType::DumpSummary +( + ExecutionContext *exe_ctx, + Stream *s, + const lldb_private::DataExtractor &data, + uint32_t data_byte_offset, + size_t data_byte_size +) +{ + return DumpSummary (m_ast, + m_type, + exe_ctx, + s, + data, + data_byte_offset, + data_byte_size); +} + +void +ClangASTType::DumpSummary +( + clang::ASTContext *ast_context, + void *opaque_clang_qual_type, + ExecutionContext *exe_ctx, + Stream *s, + const lldb_private::DataExtractor &data, + uint32_t data_byte_offset, + size_t data_byte_size +) +{ + uint32_t length = 0; + clang::QualType qual_type(clang::QualType::getFromOpaquePtr(opaque_clang_qual_type)); + if (ClangASTContext::IsCStringType (opaque_clang_qual_type, length)) + { + + if (exe_ctx && exe_ctx->process) + { + uint32_t offset = data_byte_offset; + lldb::addr_t pointer_addresss = data.GetMaxU64(&offset, data_byte_size); + std::vector<uint8_t> buf; + if (length > 0) + buf.resize (length); + else + buf.resize (256); + + lldb_private::DataExtractor cstr_data(&buf.front(), buf.size(), exe_ctx->process->GetByteOrder(), 4); + buf.back() = '\0'; + size_t bytes_read; + size_t total_cstr_len = 0; + Error error; + while ((bytes_read = exe_ctx->process->ReadMemory (pointer_addresss, &buf.front(), buf.size(), error)) > 0) + { + const size_t len = strlen((const char *)&buf.front()); + if (len == 0) + break; + if (total_cstr_len == 0) + s->PutCString (" \""); + cstr_data.Dump(s, 0, lldb::eFormatChar, 1, len, UINT32_MAX, LLDB_INVALID_ADDRESS, 0, 0); + total_cstr_len += len; + if (len < buf.size()) + break; + pointer_addresss += total_cstr_len; + } + if (total_cstr_len > 0) + s->PutChar ('"'); + } + } +} + +bool +ClangASTType::GetValueAsScalar +( + const lldb_private::DataExtractor &data, + uint32_t data_byte_offset, + size_t data_byte_size, + Scalar &value +) +{ + return GetValueAsScalar (m_ast, + m_type, + data, + data_byte_offset, + data_byte_size, + value); +} + +bool +ClangASTType::GetValueAsScalar +( + clang::ASTContext *ast_context, + void *opaque_clang_qual_type, + const lldb_private::DataExtractor &data, + uint32_t data_byte_offset, + size_t data_byte_size, + Scalar &value +) +{ + clang::QualType qual_type(clang::QualType::getFromOpaquePtr(opaque_clang_qual_type)); + + if (ClangASTContext::IsAggregateType (opaque_clang_qual_type)) + { + return false; // Aggregate types don't have scalar values + } + else + { + uint32_t count = 0; + lldb::Encoding encoding = GetEncoding (opaque_clang_qual_type, count); + + if (encoding == lldb::eEncodingInvalid || count != 1) + return false; + + uint64_t bit_width = ast_context->getTypeSize(qual_type); + uint32_t byte_size = (bit_width + 7 ) / 8; + uint32_t offset = data_byte_offset; + switch (encoding) + { + case lldb::eEncodingUint: + if (byte_size <= sizeof(unsigned long long)) + { + uint64_t uval64 = data.GetMaxU64 (&offset, byte_size); + if (byte_size <= sizeof(unsigned int)) + { + value = (unsigned int)uval64; + return true; + } + else if (byte_size <= sizeof(unsigned long)) + { + value = (unsigned long)uval64; + return true; + } + else if (byte_size <= sizeof(unsigned long long)) + { + value = (unsigned long long )uval64; + return true; + } + else + value.Clear(); + } + break; + + case lldb::eEncodingSint: + if (byte_size <= sizeof(long long)) + { + int64_t sval64 = (int64_t)data.GetMaxU64 (&offset, byte_size); + if (byte_size <= sizeof(int)) + { + value = (int)sval64; + return true; + } + else if (byte_size <= sizeof(long)) + { + value = (long)sval64; + return true; + } + else if (byte_size <= sizeof(long long)) + { + value = (long long )sval64; + return true; + } + else + value.Clear(); + } + break; + + case lldb::eEncodingIEEE754: + if (byte_size <= sizeof(long double)) + { + uint32_t u32; + uint64_t u64; + if (byte_size == sizeof(float)) + { + if (sizeof(float) == sizeof(uint32_t)) + { + u32 = data.GetU32(&offset); + value = *((float *)&u32); + return true; + } + else if (sizeof(float) == sizeof(uint64_t)) + { + u64 = data.GetU64(&offset); + value = *((float *)&u64); + return true; + } + } + else + if (byte_size == sizeof(double)) + { + if (sizeof(double) == sizeof(uint32_t)) + { + u32 = data.GetU32(&offset); + value = *((double *)&u32); + return true; + } + else if (sizeof(double) == sizeof(uint64_t)) + { + u64 = data.GetU64(&offset); + value = *((double *)&u64); + return true; + } + } + else + if (byte_size == sizeof(long double)) + { + if (sizeof(long double) == sizeof(uint32_t)) + { + u32 = data.GetU32(&offset); + value = *((long double *)&u32); + return true; + } + else if (sizeof(long double) == sizeof(uint64_t)) + { + u64 = data.GetU64(&offset); + value = *((long double *)&u64); + return true; + } + } + } + break; + } + } + return false; +} + +bool +ClangASTType::SetValueFromScalar (const Scalar &value, Stream &strm) +{ + return SetValueFromScalar (m_ast, m_type, value, strm); +} + +bool +ClangASTType::SetValueFromScalar +( + clang::ASTContext *ast_context, + void *opaque_clang_qual_type, + const Scalar &value, + Stream &strm +) +{ + clang::QualType qual_type(clang::QualType::getFromOpaquePtr(opaque_clang_qual_type)); + + // Aggregate types don't have scalar values + if (!ClangASTContext::IsAggregateType (opaque_clang_qual_type)) + { + strm.GetFlags().Set(Stream::eBinary); + uint32_t count = 0; + lldb::Encoding encoding = GetEncoding (opaque_clang_qual_type, count); + + if (encoding == lldb::eEncodingInvalid || count != 1) + return false; + + uint64_t bit_width = ast_context->getTypeSize(qual_type); + // This function doesn't currently handle non-byte aligned assignments + if ((bit_width % 8) != 0) + return false; + + uint32_t byte_size = (bit_width + 7 ) / 8; + switch (encoding) + { + case lldb::eEncodingUint: + switch (byte_size) + { + case 1: strm.PutHex8(value.UInt()); return true; + case 2: strm.PutHex16(value.UInt()); return true; + case 4: strm.PutHex32(value.UInt()); return true; + case 8: strm.PutHex64(value.ULongLong()); return true; + default: + break; + } + break; + + case lldb::eEncodingSint: + switch (byte_size) + { + case 1: strm.PutHex8(value.SInt()); return true; + case 2: strm.PutHex16(value.SInt()); return true; + case 4: strm.PutHex32(value.SInt()); return true; + case 8: strm.PutHex64(value.SLongLong()); return true; + default: + break; + } + break; + + case lldb::eEncodingIEEE754: + if (byte_size <= sizeof(long double)) + { + if (byte_size == sizeof(float)) + { + strm.PutFloat(value.Float()); + return true; + } + else + if (byte_size == sizeof(double)) + { + strm.PutDouble(value.Double()); + return true; + } + else + if (byte_size == sizeof(long double)) + { + strm.PutDouble(value.LongDouble()); + return true; + } + } + break; + } + } + return false; +} + +bool +ClangASTType::ReadFromMemory +( + lldb_private::ExecutionContext *exe_ctx, + lldb::addr_t addr, + lldb::AddressType address_type, + lldb_private::DataExtractor &data +) +{ + return ReadFromMemory (m_ast, + m_type, + exe_ctx, + addr, + address_type, + data); +} + + +bool +ClangASTType::ReadFromMemory +( + clang::ASTContext *ast_context, + void *opaque_clang_qual_type, + lldb_private::ExecutionContext *exe_ctx, + lldb::addr_t addr, + lldb::AddressType address_type, + lldb_private::DataExtractor &data +) +{ + if (address_type == lldb::eAddressTypeFile) + { + // Can't convert a file address to anything valid without more + // context (which Module it came from) + return false; + } + clang::QualType qual_type(clang::QualType::getFromOpaquePtr(opaque_clang_qual_type)); + + const uint32_t byte_size = (ast_context->getTypeSize (qual_type) + 7) / 8; + if (data.GetByteSize() < byte_size) + { + lldb::DataBufferSP data_sp(new DataBufferHeap (byte_size, '\0')); + data.SetData(data_sp); + } + + uint8_t* dst = (uint8_t*)data.PeekData(0, byte_size); + if (dst != NULL) + { + if (address_type == lldb::eAddressTypeHost) + { + // The address is an address in this process, so just copy it + memcpy (dst, (uint8_t*)NULL + addr, byte_size); + return true; + } + else + { + if (exe_ctx && exe_ctx->process) + { + Error error; + return exe_ctx->process->ReadMemory(addr, dst, byte_size, error) == byte_size; + } + } + } + return false; +} + +bool +ClangASTType::WriteToMemory +( + lldb_private::ExecutionContext *exe_ctx, + lldb::addr_t addr, + lldb::AddressType address_type, + StreamString &new_value +) +{ + return WriteToMemory (m_ast, + m_type, + exe_ctx, + addr, + address_type, + new_value); +} + +bool +ClangASTType::WriteToMemory +( + clang::ASTContext *ast_context, + void *opaque_clang_qual_type, + lldb_private::ExecutionContext *exe_ctx, + lldb::addr_t addr, + lldb::AddressType address_type, + StreamString &new_value +) +{ + if (address_type == lldb::eAddressTypeFile) + { + // Can't convert a file address to anything valid without more + // context (which Module it came from) + return false; + } + clang::QualType qual_type(clang::QualType::getFromOpaquePtr(opaque_clang_qual_type)); + const uint32_t byte_size = (ast_context->getTypeSize (qual_type) + 7) / 8; + + if (byte_size > 0) + { + if (address_type == lldb::eAddressTypeHost) + { + // The address is an address in this process, so just copy it + memcpy ((void *)addr, new_value.GetData(), byte_size); + return true; + } + else + { + if (exe_ctx && exe_ctx->process) + { + Error error; + return exe_ctx->process->WriteMemory(addr, new_value.GetData(), byte_size, error) == byte_size; + } + } + } + return false; +} + + diff --git a/lldb/source/Symbol/Function.cpp b/lldb/source/Symbol/Function.cpp index 57f6cb4cd55..94eec1e7478 100644 --- a/lldb/source/Symbol/Function.cpp +++ b/lldb/source/Symbol/Function.cpp @@ -10,10 +10,11 @@ #include "lldb/Symbol/Function.h" #include "lldb/Core/Module.h" #include "lldb/Core/Section.h" +#include "lldb/Symbol/ClangASTType.h" +#include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/CompileUnit.h" #include "lldb/Symbol/LineTable.h" #include "lldb/Symbol/SymbolVendor.h" -#include "lldb/Symbol/ClangASTContext.h" #include "clang/AST/Type.h" #include "clang/AST/CanonicalType.h" @@ -339,7 +340,7 @@ Function::GetReturnType () clang::FunctionType *function_type = dyn_cast<clang::FunctionType> (clang_type); clang::QualType fun_return_qualtype = function_type->getResultType(); - const ConstString fun_return_name(Type::GetClangTypeName(fun_return_qualtype.getAsOpaquePtr())); + const ConstString fun_return_name(ClangASTType::GetClangTypeName(fun_return_qualtype.getAsOpaquePtr())); SymbolContext sc; CalculateSymbolContext (&sc); @@ -381,7 +382,7 @@ Function::GetArgumentTypeAtIndex (size_t idx) return Type(); clang::QualType arg_qualtype = (function_proto_type->arg_type_begin())[idx]; - const ConstString arg_return_name(Type::GetClangTypeName(arg_qualtype.getAsOpaquePtr())); + const ConstString arg_return_name(ClangASTType::GetClangTypeName(arg_qualtype.getAsOpaquePtr())); SymbolContext sc; CalculateSymbolContext (&sc); // Null out everything below the CompUnit 'cause we don't actually know these. diff --git a/lldb/source/Symbol/Type.cpp b/lldb/source/Symbol/Type.cpp index 31a5bac7d51..e58d0d4f40b 100644 --- a/lldb/source/Symbol/Type.cpp +++ b/lldb/source/Symbol/Type.cpp @@ -30,6 +30,7 @@ #include "lldb/Core/Scalar.h" #include "lldb/Core/StreamString.h" +#include "lldb/Symbol/ClangASTType.h" #include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/SymbolContextScope.h" @@ -270,59 +271,6 @@ lldb_private::Type::GetName() return m_name; } -int -lldb_private::Type::DumpClangTypeName(Stream *s, void *clang_type) -{ - clang::QualType qual_type(clang::QualType::getFromOpaquePtr(clang_type)); - std::string type_name; - const clang::TypedefType *typedef_type = qual_type->getAs<clang::TypedefType>(); - if (typedef_type) - { - const clang::TypedefDecl *typedef_decl = typedef_type->getDecl(); - type_name = typedef_decl->getQualifiedNameAsString(); - } - else - { - type_name = qual_type.getAsString(); - } - if (!type_name.empty()) - return s->Printf("(%s) ", type_name.c_str()); - return 0; -} - -lldb_private::ConstString -lldb_private::Type::GetClangTypeName (void *clang_type) -{ - ConstString clang_type_name; - if (clang_type) - { - clang::QualType qual_type(clang::QualType::getFromOpaquePtr(clang_type)); - - const clang::TypedefType *typedef_type = qual_type->getAs<clang::TypedefType>(); - if (typedef_type) - { - const clang::TypedefDecl *typedef_decl = typedef_type->getDecl(); - std::string clang_typedef_name (typedef_decl->getQualifiedNameAsString()); - if (!clang_typedef_name.empty()) - clang_type_name.SetCString (clang_typedef_name.c_str()); - } - else - { - std::string type_name(qual_type.getAsString()); - if (!type_name.empty()) - clang_type_name.SetCString (type_name.c_str()); - } - } - else - { - clang_type_name.SetCString ("<invalid>"); - } - - return clang_type_name; -} - - - void lldb_private::Type::DumpTypeName(Stream *s) { @@ -354,658 +302,23 @@ lldb_private::Type::DumpValue s->PutCString(") "); } - lldb_private::Type::DumpValue (exe_ctx, - GetClangAST (), - m_clang_qual_type, - s, - format == lldb::eFormatDefault ? GetFormat() : format, - data, - data_byte_offset, - GetByteSize(), - 0, // Bitfield bit size - 0, // Bitfield bit offset - show_types, - show_summary, - verbose, - 0); - } -} - - -void -lldb_private::Type::DumpSummary -( - ExecutionContext *exe_ctx, - clang::ASTContext *ast_context, - void *clang_type, - Stream *s, - const lldb_private::DataExtractor &data, - uint32_t data_byte_offset, - size_t data_byte_size -) -{ - uint32_t length = 0; - clang::QualType qual_type(clang::QualType::getFromOpaquePtr(clang_type)); - if (ClangASTContext::IsCStringType (clang_type, length)) - { - - if (exe_ctx && exe_ctx->process) - { - uint32_t offset = data_byte_offset; - lldb::addr_t pointer_addresss = data.GetMaxU64(&offset, data_byte_size); - std::vector<uint8_t> buf; - if (length > 0) - buf.resize (length); - else - buf.resize (256); - - lldb_private::DataExtractor cstr_data(&buf.front(), buf.size(), exe_ctx->process->GetByteOrder(), 4); - buf.back() = '\0'; - size_t bytes_read; - size_t total_cstr_len = 0; - Error error; - while ((bytes_read = exe_ctx->process->ReadMemory (pointer_addresss, &buf.front(), buf.size(), error)) > 0) - { - const size_t len = strlen((const char *)&buf.front()); - if (len == 0) - break; - if (total_cstr_len == 0) - s->PutCString (" \""); - cstr_data.Dump(s, 0, lldb::eFormatChar, 1, len, UINT32_MAX, LLDB_INVALID_ADDRESS, 0, 0); - total_cstr_len += len; - if (len < buf.size()) - break; - pointer_addresss += total_cstr_len; - } - if (total_cstr_len > 0) - s->PutChar ('"'); - } - } -} - -#define DEPTH_INCREMENT 2 -void -lldb_private::Type::DumpValue -( - ExecutionContext *exe_ctx, - clang::ASTContext *ast_context, - void *clang_type, - Stream *s, - lldb::Format format, - const lldb_private::DataExtractor &data, - uint32_t data_byte_offset, - size_t data_byte_size, - uint32_t bitfield_bit_size, - uint32_t bitfield_bit_offset, - bool show_types, - bool show_summary, - bool verbose, - uint32_t depth -) -{ - clang::QualType qual_type(clang::QualType::getFromOpaquePtr(clang_type)); - switch (qual_type->getTypeClass()) - { - case clang::Type::Record: - { - const clang::RecordType *record_type = cast<clang::RecordType>(qual_type.getTypePtr()); - const clang::RecordDecl *record_decl = record_type->getDecl(); - assert(record_decl); - uint32_t field_bit_offset = 0; - uint32_t field_byte_offset = 0; - const clang::ASTRecordLayout &record_layout = ast_context->getASTRecordLayout(record_decl); - uint32_t child_idx = 0; - - - const clang::CXXRecordDecl *cxx_record_decl = dyn_cast<clang::CXXRecordDecl>(record_decl); - if (cxx_record_decl) - { - // We might have base classes to print out first - clang::CXXRecordDecl::base_class_const_iterator base_class, base_class_end; - for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end(); - base_class != base_class_end; - ++base_class) - { - const clang::CXXRecordDecl *base_class_decl = cast<clang::CXXRecordDecl>(base_class->getType()->getAs<clang::RecordType>()->getDecl()); - - // Skip empty base classes - if (verbose == false && ClangASTContext::RecordHasFields(base_class_decl) == false) - continue; - - if (base_class->isVirtual()) - field_bit_offset = record_layout.getVBaseClassOffset(base_class_decl); - else - field_bit_offset = record_layout.getBaseClassOffset(base_class_decl); - field_byte_offset = field_bit_offset / 8; - assert (field_bit_offset % 8 == 0); - if (child_idx == 0) - s->PutChar('{'); - else - s->PutChar(','); - - clang::QualType base_class_qual_type = base_class->getType(); - std::string base_class_type_name(base_class_qual_type.getAsString()); - - // Indent and print the base class type name - s->Printf("\n%*s%s ", depth + DEPTH_INCREMENT, "", base_class_type_name.c_str()); - - std::pair<uint64_t, unsigned> base_class_type_info = ast_context->getTypeInfo(base_class_qual_type); - - // Dump the value of the member - Type::DumpValue ( - exe_ctx, - ast_context, // The clang AST context for this type - base_class_qual_type.getAsOpaquePtr(),// The clang type we want to dump - s, // Stream to dump to - Type::GetFormat(base_class_qual_type.getAsOpaquePtr()), // The format with which to display the member - data, // Data buffer containing all bytes for this type - data_byte_offset + field_byte_offset,// Offset into "data" where to grab value from - base_class_type_info.first / 8, // Size of this type in bytes - 0, // Bitfield bit size - 0, // Bitfield bit offset - show_types, // Boolean indicating if we should show the variable types - show_summary, // Boolean indicating if we should show a summary for the current type - verbose, // Verbose output? - depth + DEPTH_INCREMENT); // Scope depth for any types that have children - - ++child_idx; - } - } - uint32_t field_idx = 0; - clang::RecordDecl::field_iterator field, field_end; - for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field, ++field_idx, ++child_idx) - { - // Print the starting squiggly bracket (if this is the - // first member) or comman (for member 2 and beyong) for - // the struct/union/class member. - if (child_idx == 0) - s->PutChar('{'); - else - s->PutChar(','); - - // Indent - s->Printf("\n%*s", depth + DEPTH_INCREMENT, ""); - - clang::QualType field_type = field->getType(); - // Print the member type if requested - // Figure out the type byte size (field_type_info.first) and - // alignment (field_type_info.second) from the AST context. - std::pair<uint64_t, unsigned> field_type_info = ast_context->getTypeInfo(field_type); - assert(field_idx < record_layout.getFieldCount()); - // Figure out the field offset within the current struct/union/class type - field_bit_offset = record_layout.getFieldOffset (field_idx); - field_byte_offset = field_bit_offset / 8; - uint32_t field_bitfield_bit_size = 0; - uint32_t field_bitfield_bit_offset = 0; - if (ClangASTContext::FieldIsBitfield (ast_context, *field, field_bitfield_bit_size)) - field_bitfield_bit_offset = field_bit_offset % 8; - - if (show_types) - { - std::string field_type_name(field_type.getAsString()); - if (field_bitfield_bit_size > 0) - s->Printf("(%s:%u) ", field_type_name.c_str(), field_bitfield_bit_size); - else - s->Printf("(%s) ", field_type_name.c_str()); - } - // Print the member name and equal sign - s->Printf("%s = ", field->getNameAsString().c_str()); - - - // Dump the value of the member - Type::DumpValue ( - exe_ctx, - ast_context, // The clang AST context for this type - field_type.getAsOpaquePtr(), // The clang type we want to dump - s, // Stream to dump to - Type::GetFormat(field_type.getAsOpaquePtr()), // The format with which to display the member - data, // Data buffer containing all bytes for this type - data_byte_offset + field_byte_offset,// Offset into "data" where to grab value from - field_type_info.first / 8, // Size of this type in bytes - field_bitfield_bit_size, // Bitfield bit size - field_bitfield_bit_offset, // Bitfield bit offset - show_types, // Boolean indicating if we should show the variable types - show_summary, // Boolean indicating if we should show a summary for the current type - verbose, // Verbose output? - depth + DEPTH_INCREMENT); // Scope depth for any types that have children - } - - // Indent the trailing squiggly bracket - if (child_idx > 0) - s->Printf("\n%*s}", depth, ""); - } - return; - - case clang::Type::Enum: - { - const clang::EnumType *enum_type = cast<clang::EnumType>(qual_type.getTypePtr()); - const clang::EnumDecl *enum_decl = enum_type->getDecl(); - assert(enum_decl); - clang::EnumDecl::enumerator_iterator enum_pos, enum_end_pos; - uint32_t offset = data_byte_offset; - const int64_t enum_value = data.GetMaxU64Bitfield(&offset, data_byte_size, bitfield_bit_size, bitfield_bit_offset); - for (enum_pos = enum_decl->enumerator_begin(), enum_end_pos = enum_decl->enumerator_end(); enum_pos != enum_end_pos; ++enum_pos) - { - if (enum_pos->getInitVal() == enum_value) - { - s->Printf("%s", enum_pos->getNameAsCString()); - return; - } - } - // If we have gotten here we didn't get find the enumerator in the - // enum decl, so just print the integer. - s->Printf("%lli", enum_value); - } - return; - - case clang::Type::ConstantArray: - { - const clang::ConstantArrayType *array = cast<clang::ConstantArrayType>(qual_type.getTypePtr()); - bool is_array_of_characters = false; - clang::QualType element_qual_type = array->getElementType(); - - clang::Type *canonical_type = element_qual_type->getCanonicalTypeInternal().getTypePtr(); - if (canonical_type) - is_array_of_characters = canonical_type->isCharType(); - - const uint64_t element_count = array->getSize().getLimitedValue(); - - std::pair<uint64_t, unsigned> field_type_info = ast_context->getTypeInfo(element_qual_type); - - uint32_t element_idx = 0; - uint32_t element_offset = 0; - uint64_t element_byte_size = field_type_info.first / 8; - uint32_t element_stride = element_byte_size; - - if (is_array_of_characters) - { - s->PutChar('"'); - data.Dump(s, data_byte_offset, lldb::eFormatChar, element_byte_size, element_count, UINT32_MAX, LLDB_INVALID_ADDRESS, 0, 0); - s->PutChar('"'); - return; - } - else - { - lldb::Format element_format = Type::GetFormat(element_qual_type.getAsOpaquePtr()); - - for (element_idx = 0; element_idx < element_count; ++element_idx) - { - // Print the starting squiggly bracket (if this is the - // first member) or comman (for member 2 and beyong) for - // the struct/union/class member. - if (element_idx == 0) - s->PutChar('{'); - else - s->PutChar(','); - - // Indent and print the index - s->Printf("\n%*s[%u] ", depth + DEPTH_INCREMENT, "", element_idx); - - // Figure out the field offset within the current struct/union/class type - element_offset = element_idx * element_stride; - - // Dump the value of the member - Type::DumpValue ( - exe_ctx, - ast_context, // The clang AST context for this type - element_qual_type.getAsOpaquePtr(), // The clang type we want to dump - s, // Stream to dump to - element_format, // The format with which to display the element - data, // Data buffer containing all bytes for this type - data_byte_offset + element_offset,// Offset into "data" where to grab value from - element_byte_size, // Size of this type in bytes - 0, // Bitfield bit size - 0, // Bitfield bit offset - show_types, // Boolean indicating if we should show the variable types - show_summary, // Boolean indicating if we should show a summary for the current type - verbose, // Verbose output? - depth + DEPTH_INCREMENT); // Scope depth for any types that have children - } - - // Indent the trailing squiggly bracket - if (element_idx > 0) - s->Printf("\n%*s}", depth, ""); - } - } - return; - - case clang::Type::Typedef: - { - clang::QualType typedef_qual_type = cast<clang::TypedefType>(qual_type)->LookThroughTypedefs(); - lldb::Format typedef_format = lldb_private::Type::GetFormat(typedef_qual_type.getAsOpaquePtr()); - std::pair<uint64_t, unsigned> typedef_type_info = ast_context->getTypeInfo(typedef_qual_type); - uint64_t typedef_byte_size = typedef_type_info.first / 8; - - return Type::DumpValue( - exe_ctx, - ast_context, // The clang AST context for this type - typedef_qual_type.getAsOpaquePtr(), // The clang type we want to dump - s, // Stream to dump to - typedef_format, // The format with which to display the element - data, // Data buffer containing all bytes for this type - data_byte_offset, // Offset into "data" where to grab value from - typedef_byte_size, // Size of this type in bytes - bitfield_bit_size, // Bitfield bit size - bitfield_bit_offset,// Bitfield bit offset - show_types, // Boolean indicating if we should show the variable types - show_summary, // Boolean indicating if we should show a summary for the current type - verbose, // Verbose output? - depth); // Scope depth for any types that have children - } - break; - - default: - // We are down the a scalar type that we just need to display. - data.Dump(s, data_byte_offset, format, data_byte_size, 1, UINT32_MAX, LLDB_INVALID_ADDRESS, bitfield_bit_size, bitfield_bit_offset); - - if (show_summary) - Type::DumpSummary (exe_ctx, ast_context, clang_type, s, data, data_byte_offset, data_byte_size); - break; - } -} - -bool -lldb_private::Type::DumpTypeValue -( - Stream *s, - clang::ASTContext *ast_context, - void *clang_type, - lldb::Format format, - const lldb_private::DataExtractor &data, - uint32_t byte_offset, - size_t byte_size, - uint32_t bitfield_bit_size, - uint32_t bitfield_bit_offset -) -{ - clang::QualType qual_type(clang::QualType::getFromOpaquePtr(clang_type)); - if (ClangASTContext::IsAggregateType (clang_type)) - { - return 0; - } - else - { - switch (qual_type->getTypeClass()) - { - case clang::Type::Enum: - { - const clang::EnumType *enum_type = cast<clang::EnumType>(qual_type.getTypePtr()); - const clang::EnumDecl *enum_decl = enum_type->getDecl(); - assert(enum_decl); - clang::EnumDecl::enumerator_iterator enum_pos, enum_end_pos; - uint32_t offset = byte_offset; - const int64_t enum_value = data.GetMaxU64Bitfield (&offset, byte_size, bitfield_bit_size, bitfield_bit_offset); - for (enum_pos = enum_decl->enumerator_begin(), enum_end_pos = enum_decl->enumerator_end(); enum_pos != enum_end_pos; ++enum_pos) - { - if (enum_pos->getInitVal() == enum_value) - { - s->PutCString (enum_pos->getNameAsCString()); - return true; - } - } - // If we have gotten here we didn't get find the enumerator in the - // enum decl, so just print the integer. - - s->Printf("%lli", enum_value); - return true; - } - break; - - case clang::Type::Typedef: - { - clang::QualType typedef_qual_type = cast<clang::TypedefType>(qual_type)->LookThroughTypedefs(); - lldb::Format typedef_format = Type::GetFormat(typedef_qual_type.getAsOpaquePtr()); - std::pair<uint64_t, unsigned> typedef_type_info = ast_context->getTypeInfo(typedef_qual_type); - uint64_t typedef_byte_size = typedef_type_info.first / 8; - - return Type::DumpTypeValue( - s, - ast_context, // The clang AST context for this type - typedef_qual_type.getAsOpaquePtr(), // The clang type we want to dump - typedef_format, // The format with which to display the element - data, // Data buffer containing all bytes for this type - byte_offset, // Offset into "data" where to grab value from - typedef_byte_size, // Size of this type in bytes - bitfield_bit_size, // Size in bits of a bitfield value, if zero don't treat as a bitfield - bitfield_bit_offset); // Offset in bits of a bitfield value if bitfield_bit_size != 0 - } - break; - - default: - // We are down the a scalar type that we just need to display. - return data.Dump(s, - byte_offset, - format, - byte_size, - 1, - UINT32_MAX, - LLDB_INVALID_ADDRESS, - bitfield_bit_size, - bitfield_bit_offset); - break; - } - } - return 0; -} - -bool -lldb_private::Type::GetValueAsScalar -( - clang::ASTContext *ast_context, - void *clang_type, - const lldb_private::DataExtractor &data, - uint32_t data_byte_offset, - size_t data_byte_size, - Scalar &value -) -{ - clang::QualType qual_type(clang::QualType::getFromOpaquePtr(clang_type)); - - if (ClangASTContext::IsAggregateType (clang_type)) - { - return false; // Aggregate types don't have scalar values - } - else - { - uint32_t count = 0; - lldb::Encoding encoding = Type::GetEncoding (clang_type, count); - - if (encoding == lldb::eEncodingInvalid || count != 1) - return false; - - uint64_t bit_width = ast_context->getTypeSize(qual_type); - uint32_t byte_size = (bit_width + 7 ) / 8; - uint32_t offset = data_byte_offset; - switch (encoding) - { - case lldb::eEncodingUint: - if (byte_size <= sizeof(unsigned long long)) - { - uint64_t uval64 = data.GetMaxU64 (&offset, byte_size); - if (byte_size <= sizeof(unsigned int)) - { - value = (unsigned int)uval64; - return true; - } - else if (byte_size <= sizeof(unsigned long)) - { - value = (unsigned long)uval64; - return true; - } - else if (byte_size <= sizeof(unsigned long long)) - { - value = (unsigned long long )uval64; - return true; - } - else - value.Clear(); - } - break; - - case lldb::eEncodingSint: - if (byte_size <= sizeof(long long)) - { - int64_t sval64 = (int64_t)data.GetMaxU64 (&offset, byte_size); - if (byte_size <= sizeof(int)) - { - value = (int)sval64; - return true; - } - else if (byte_size <= sizeof(long)) - { - value = (long)sval64; - return true; - } - else if (byte_size <= sizeof(long long)) - { - value = (long long )sval64; - return true; - } - else - value.Clear(); - } - break; - - case lldb::eEncodingIEEE754: - if (byte_size <= sizeof(long double)) - { - uint32_t u32; - uint64_t u64; - if (byte_size == sizeof(float)) - { - if (sizeof(float) == sizeof(uint32_t)) - { - u32 = data.GetU32(&offset); - value = *((float *)&u32); - return true; - } - else if (sizeof(float) == sizeof(uint64_t)) - { - u64 = data.GetU64(&offset); - value = *((float *)&u64); - return true; - } - } - else - if (byte_size == sizeof(double)) - { - if (sizeof(double) == sizeof(uint32_t)) - { - u32 = data.GetU32(&offset); - value = *((double *)&u32); - return true; - } - else if (sizeof(double) == sizeof(uint64_t)) - { - u64 = data.GetU64(&offset); - value = *((double *)&u64); - return true; - } - } - else - if (byte_size == sizeof(long double)) - { - if (sizeof(long double) == sizeof(uint32_t)) - { - u32 = data.GetU32(&offset); - value = *((long double *)&u32); - return true; - } - else if (sizeof(long double) == sizeof(uint64_t)) - { - u64 = data.GetU64(&offset); - value = *((long double *)&u64); - return true; - } - } - } - break; - } - } - return false; -} - -bool -lldb_private::Type::SetValueFromScalar -( - clang::ASTContext *ast_context, - void *clang_type, - const Scalar &value, - Stream &strm -) -{ - clang::QualType qual_type(clang::QualType::getFromOpaquePtr(clang_type)); - - // Aggregate types don't have scalar values - if (!ClangASTContext::IsAggregateType (clang_type)) - { - strm.GetFlags().Set(Stream::eBinary); - uint32_t count = 0; - lldb::Encoding encoding = Type::GetEncoding (clang_type, count); - - if (encoding == lldb::eEncodingInvalid || count != 1) - return false; - - uint64_t bit_width = ast_context->getTypeSize(qual_type); - // This function doesn't currently handle non-byte aligned assignments - if ((bit_width % 8) != 0) - return false; - - uint32_t byte_size = (bit_width + 7 ) / 8; - switch (encoding) - { - case lldb::eEncodingUint: - switch (byte_size) - { - case 1: strm.PutHex8(value.UInt()); return true; - case 2: strm.PutHex16(value.UInt()); return true; - case 4: strm.PutHex32(value.UInt()); return true; - case 8: strm.PutHex64(value.ULongLong()); return true; - default: - break; - } - break; - - case lldb::eEncodingSint: - switch (byte_size) - { - case 1: strm.PutHex8(value.SInt()); return true; - case 2: strm.PutHex16(value.SInt()); return true; - case 4: strm.PutHex32(value.SInt()); return true; - case 8: strm.PutHex64(value.SLongLong()); return true; - default: - break; - } - break; - - case lldb::eEncodingIEEE754: - if (byte_size <= sizeof(long double)) - { - if (byte_size == sizeof(float)) - { - strm.PutFloat(value.Float()); - return true; - } - else - if (byte_size == sizeof(double)) - { - strm.PutDouble(value.Double()); - return true; - } - else - if (byte_size == sizeof(long double)) - { - strm.PutDouble(value.LongDouble()); - return true; - } - } - break; - } + lldb_private::ClangASTType::DumpValue (GetClangAST (), + m_clang_qual_type, + exe_ctx, + s, + format == lldb::eFormatDefault ? GetFormat() : format, + data, + data_byte_offset, + GetByteSize(), + 0, // Bitfield bit size + 0, // Bitfield bit offset + show_types, + show_summary, + verbose, + 0); } - return false; } - uint64_t lldb_private::Type::GetByteSize() { @@ -1066,86 +379,10 @@ lldb_private::Type::GetFormat () // Make sure we resolve our type if it already hasn't been. if (!ResolveClangType()) return lldb::eFormatInvalid; - return lldb_private::Type::GetFormat (m_clang_qual_type); + return lldb_private::ClangASTType::GetFormat (m_clang_qual_type); } -lldb::Format -lldb_private::Type::GetFormat (void *clang_type) -{ - clang::QualType qual_type(clang::QualType::getFromOpaquePtr(clang_type)); - - switch (qual_type->getTypeClass()) - { - case clang::Type::FunctionNoProto: - case clang::Type::FunctionProto: - break; - - case clang::Type::IncompleteArray: - case clang::Type::VariableArray: - break; - - case clang::Type::ConstantArray: - break; - - case clang::Type::ExtVector: - case clang::Type::Vector: - break; - - case clang::Type::Builtin: - switch (cast<clang::BuiltinType>(qual_type)->getKind()) - { - default: assert(0 && "Unknown builtin type!"); - case clang::BuiltinType::Void: - break; - - case clang::BuiltinType::Bool: return lldb::eFormatBoolean; - case clang::BuiltinType::Char_S: - case clang::BuiltinType::SChar: - case clang::BuiltinType::Char_U: - case clang::BuiltinType::UChar: - case clang::BuiltinType::WChar: return lldb::eFormatChar; - case clang::BuiltinType::Char16: return lldb::eFormatUnicode16; - case clang::BuiltinType::Char32: return lldb::eFormatUnicode32; - case clang::BuiltinType::UShort: return lldb::eFormatHex; - case clang::BuiltinType::Short: return lldb::eFormatDecimal; - case clang::BuiltinType::UInt: return lldb::eFormatHex; - case clang::BuiltinType::Int: return lldb::eFormatDecimal; - case clang::BuiltinType::ULong: return lldb::eFormatHex; - case clang::BuiltinType::Long: return lldb::eFormatDecimal; - case clang::BuiltinType::ULongLong: return lldb::eFormatHex; - case clang::BuiltinType::LongLong: return lldb::eFormatDecimal; - case clang::BuiltinType::UInt128: return lldb::eFormatHex; - case clang::BuiltinType::Int128: return lldb::eFormatDecimal; - case clang::BuiltinType::Float: return lldb::eFormatFloat; - case clang::BuiltinType::Double: return lldb::eFormatFloat; - case clang::BuiltinType::LongDouble: return lldb::eFormatFloat; - case clang::BuiltinType::NullPtr: return lldb::eFormatHex; - } - break; - case clang::Type::ObjCObjectPointer: return lldb::eFormatHex; - case clang::Type::BlockPointer: return lldb::eFormatHex; - case clang::Type::Pointer: return lldb::eFormatHex; - case clang::Type::LValueReference: - case clang::Type::RValueReference: return lldb::eFormatHex; - case clang::Type::MemberPointer: break; - case clang::Type::Complex: return lldb::eFormatComplex; - case clang::Type::ObjCInterface: break; - case clang::Type::Record: break; - case clang::Type::Enum: return lldb::eFormatEnum; - case clang::Type::Typedef: - return lldb_private::Type::GetFormat(cast<clang::TypedefType>(qual_type)->LookThroughTypedefs().getAsOpaquePtr()); - - case clang::Type::TypeOfExpr: - case clang::Type::TypeOf: - case clang::Type::Decltype: -// case clang::Type::QualifiedName: - case clang::Type::TemplateSpecialization: break; - } - // We don't know hot to display this type... - return lldb::eFormatBytes; -} - lldb::Encoding lldb_private::Type::GetEncoding (uint32_t &count) @@ -1154,99 +391,10 @@ lldb_private::Type::GetEncoding (uint32_t &count) if (!ResolveClangType()) return lldb::eEncodingInvalid; - return Type::GetEncoding (m_clang_qual_type, count); + return lldb_private::ClangASTType::GetEncoding (m_clang_qual_type, count); } -lldb::Encoding -lldb_private::Type::GetEncoding (void *clang_type, uint32_t &count) -{ - count = 1; - clang::QualType qual_type(clang::QualType::getFromOpaquePtr(clang_type)); - - switch (qual_type->getTypeClass()) - { - case clang::Type::FunctionNoProto: - case clang::Type::FunctionProto: - break; - - case clang::Type::IncompleteArray: - case clang::Type::VariableArray: - break; - - case clang::Type::ConstantArray: - break; - - case clang::Type::ExtVector: - case clang::Type::Vector: - // TODO: Set this to more than one??? - break; - - case clang::Type::Builtin: - switch (cast<clang::BuiltinType>(qual_type)->getKind()) - { - default: assert(0 && "Unknown builtin type!"); - case clang::BuiltinType::Void: - break; - - case clang::BuiltinType::Bool: - case clang::BuiltinType::Char_S: - case clang::BuiltinType::SChar: - case clang::BuiltinType::WChar: - case clang::BuiltinType::Char16: - case clang::BuiltinType::Char32: - case clang::BuiltinType::Short: - case clang::BuiltinType::Int: - case clang::BuiltinType::Long: - case clang::BuiltinType::LongLong: - case clang::BuiltinType::Int128: return lldb::eEncodingSint; - - case clang::BuiltinType::Char_U: - case clang::BuiltinType::UChar: - case clang::BuiltinType::UShort: - case clang::BuiltinType::UInt: - case clang::BuiltinType::ULong: - case clang::BuiltinType::ULongLong: - case clang::BuiltinType::UInt128: return lldb::eEncodingUint; - - case clang::BuiltinType::Float: - case clang::BuiltinType::Double: - case clang::BuiltinType::LongDouble: return lldb::eEncodingIEEE754; - - case clang::BuiltinType::NullPtr: return lldb::eEncodingUint; - } - break; - // All pointer types are represented as unsigned integer encodings. - // We may nee to add a eEncodingPointer if we ever need to know the - // difference - case clang::Type::ObjCObjectPointer: - case clang::Type::BlockPointer: - case clang::Type::Pointer: - case clang::Type::LValueReference: - case clang::Type::RValueReference: - case clang::Type::MemberPointer: return lldb::eEncodingUint; - // Complex numbers are made up of floats - case clang::Type::Complex: - count = 2; - return lldb::eEncodingIEEE754; - - case clang::Type::ObjCInterface: break; - case clang::Type::Record: break; - case clang::Type::Enum: return lldb::eEncodingSint; - case clang::Type::Typedef: - return Type::GetEncoding(cast<clang::TypedefType>(qual_type)->LookThroughTypedefs().getAsOpaquePtr(), count); - break; - - case clang::Type::TypeOfExpr: - case clang::Type::TypeOf: - case clang::Type::Decltype: -// case clang::Type::QualifiedName: - case clang::Type::TemplateSpecialization: break; - } - count = 0; - return lldb::eEncodingInvalid; -} - bool lldb_private::Type::DumpValueInMemory @@ -1273,93 +421,6 @@ lldb_private::Type::DumpValueInMemory return false; } -bool -lldb_private::Type::ReadFromMemory -( - lldb_private::ExecutionContext *exe_ctx, - clang::ASTContext *ast_context, - void *clang_type, - lldb::addr_t addr, - lldb::AddressType address_type, - lldb_private::DataExtractor &data -) -{ - if (address_type == lldb::eAddressTypeFile) - { - // Can't convert a file address to anything valid without more - // context (which Module it came from) - return false; - } - clang::QualType qual_type(clang::QualType::getFromOpaquePtr(clang_type)); - - const uint32_t byte_size = (ast_context->getTypeSize (qual_type) + 7) / 8; - if (data.GetByteSize() < byte_size) - { - lldb::DataBufferSP data_sp(new DataBufferHeap (byte_size, '\0')); - data.SetData(data_sp); - } - - uint8_t* dst = (uint8_t*)data.PeekData(0, byte_size); - if (dst != NULL) - { - if (address_type == lldb::eAddressTypeHost) - { - // The address is an address in this process, so just copy it - memcpy (dst, (uint8_t*)NULL + addr, byte_size); - return true; - } - else - { - if (exe_ctx && exe_ctx->process) - { - Error error; - return exe_ctx->process->ReadMemory(addr, dst, byte_size, error) == byte_size; - } - } - } - return false; -} - -bool -lldb_private::Type::WriteToMemory -( - lldb_private::ExecutionContext *exe_ctx, - clang::ASTContext *ast_context, - void *clang_type, - lldb::addr_t addr, - lldb::AddressType address_type, - StreamString &new_value -) -{ - if (address_type == lldb::eAddressTypeFile) - { - // Can't convert a file address to anything valid without more - // context (which Module it came from) - return false; - } - clang::QualType qual_type(clang::QualType::getFromOpaquePtr(clang_type)); - const uint32_t byte_size = (ast_context->getTypeSize (qual_type) + 7) / 8; - - if (byte_size > 0) - { - if (address_type == lldb::eAddressTypeHost) - { - // The address is an address in this process, so just copy it - memcpy ((void *)addr, new_value.GetData(), byte_size); - return true; - } - else - { - if (exe_ctx && exe_ctx->process) - { - Error error; - return exe_ctx->process->WriteMemory(addr, new_value.GetData(), byte_size, error) == byte_size; - } - } - } - return false; -} - bool lldb_private::Type::ReadFromMemory (lldb_private::ExecutionContext *exe_ctx, lldb::addr_t addr, lldb::AddressType address_type, lldb_private::DataExtractor &data) |
