#include <memory>
namespace llvm {
+namespace pdb {
template <typename ChildType>
class ConcreteSymbolEnumerator : public IPDBEnumChildren<ChildType> {
std::unique_ptr<IPDBEnumSymbols> Enumerator;
};
}
+}
#endif
#include "llvm/DebugInfo/PDB/IPDBDataStream.h"
namespace llvm {
+namespace pdb {
class DIADataStream : public IPDBDataStream {
public:
explicit DIADataStream(CComPtr<IDiaEnumDebugStreamData> DiaStreamData);
CComPtr<IDiaEnumDebugStreamData> StreamData;
};
}
+}
#endif
#include "llvm/DebugInfo/PDB/IPDBEnumChildren.h"
namespace llvm {
+namespace pdb {
class IPDBDataStream;
CComPtr<IDiaEnumDebugStreams> Enumerator;
};
}
+}
#endif
#include "llvm/DebugInfo/PDB/IPDBEnumChildren.h"
namespace llvm {
-
+namespace pdb {
class IPDBLineNumber;
class DIAEnumLineNumbers : public IPDBEnumChildren<IPDBLineNumber> {
CComPtr<IDiaEnumLineNumbers> Enumerator;
};
}
+}
#endif
#include "llvm/DebugInfo/PDB/IPDBEnumChildren.h"
namespace llvm {
-
+namespace pdb {
class DIASession;
class DIAEnumSourceFiles : public IPDBEnumChildren<IPDBSourceFile> {
CComPtr<IDiaEnumSourceFiles> Enumerator;
};
}
+}
#endif
#include "llvm/DebugInfo/PDB/IPDBEnumChildren.h"
namespace llvm {
-
+namespace pdb {
class DIASession;
class DIAEnumSymbols : public IPDBEnumChildren<PDBSymbol> {
CComPtr<IDiaEnumSymbols> Enumerator;
};
}
+}
#endif
#include "llvm/DebugInfo/PDB/IPDBLineNumber.h"
namespace llvm {
+namespace pdb {
class DIALineNumber : public IPDBLineNumber {
public:
explicit DIALineNumber(CComPtr<IDiaLineNumber> DiaLineNumber);
CComPtr<IDiaLineNumber> LineNumber;
};
}
-
+}
#endif
#include "llvm/DebugInfo/PDB/IPDBRawSymbol.h"
namespace llvm {
+namespace pdb {
class DIASession;
class DIARawSymbol : public IPDBRawSymbol {
public:
CComPtr<IDiaSymbol> Symbol;
};
}
+}
#endif
namespace llvm {
class StringRef;
+namespace pdb {
class DIASession : public IPDBSession {
public:
explicit DIASession(CComPtr<IDiaSession> DiaSession);
CComPtr<IDiaSession> Session;
};
}
-
+}
#endif
#include "llvm/DebugInfo/PDB/IPDBSourceFile.h"
namespace llvm {
+namespace pdb {
class DIASession;
class DIASourceFile : public IPDBSourceFile {
CComPtr<IDiaSourceFile> SourceFile;
};
}
+}
#endif
#include "llvm/ADT/SmallVector.h"
namespace llvm {
+namespace pdb {
/// IPDBDataStream defines an interface used to represent a stream consisting
/// of a name and a series of records whose formats depend on the particular
virtual IPDBDataStream *clone() const = 0;
};
}
+}
#endif
#include <memory>
namespace llvm {
+namespace pdb {
template <typename ChildType> class IPDBEnumChildren {
public:
virtual MyType *clone() const = 0;
};
}
+}
#endif
#include "PDBTypes.h"
namespace llvm {
-
+namespace pdb {
class IPDBLineNumber {
public:
virtual ~IPDBLineNumber();
virtual bool isStatement() const = 0;
};
}
+}
#endif
#include <memory>
namespace llvm {
-
class raw_ostream;
+namespace pdb {
+
/// IPDBRawSymbol defines an interface used to represent an arbitrary symbol.
/// It exposes a monolithic interface consisting of accessors for the union of
/// all properties that are valid for any symbol type. This interface is then
virtual std::string getUnused() const = 0;
};
+} // namespace pdb
} // namespace llvm
#endif
#include <memory>
namespace llvm {
-
+namespace pdb {
class PDBSymbolCompiland;
class PDBSymbolExe;
virtual std::unique_ptr<IPDBEnumDataStreams> getDebugStreams() const = 0;
};
}
+}
#endif
#include <string>
namespace llvm {
-
class raw_ostream;
+namespace pdb {
+
/// IPDBSourceFile defines an interface used to represent source files whose
/// information are stored in the PDB.
class IPDBSourceFile {
getCompilands() const = 0;
};
}
+}
#endif
namespace llvm {
class StringRef;
+namespace pdb {
+
PDB_ErrorCode loadDataForPDB(PDB_ReaderType Type, StringRef Path,
std::unique_ptr<IPDBSession> &Session);
PDB_ErrorCode loadDataForEXE(PDB_ReaderType Type, StringRef Path,
std::unique_ptr<IPDBSession> &Session);
}
-
+}
#endif
namespace object {
class COFFObjectFile;
-}
-
-/// PDBContext
-/// This data structure is the top level entity that deals with PDB debug
-/// information parsing. This data structure exists only when there is a
-/// need for a transparent interface to different debug information formats
-/// (e.g. PDB and DWARF). More control and power over the debug information
-/// access can be had by using the PDB interfaces directly.
-class PDBContext : public DIContext {
-
- PDBContext(PDBContext &) = delete;
- PDBContext &operator=(PDBContext &) = delete;
-
-public:
- PDBContext(const object::COFFObjectFile &Object,
- std::unique_ptr<IPDBSession> PDBSession);
-
- static bool classof(const DIContext *DICtx) {
- return DICtx->getKind() == CK_PDB;
}
- void dump(raw_ostream &OS, DIDumpType DumpType = DIDT_All,
- bool DumpEH = false) override;
-
- DILineInfo getLineInfoForAddress(
- uint64_t Address,
- DILineInfoSpecifier Specifier = DILineInfoSpecifier()) override;
- DILineInfoTable getLineInfoForAddressRange(
- uint64_t Address, uint64_t Size,
- DILineInfoSpecifier Specifier = DILineInfoSpecifier()) override;
- DIInliningInfo getInliningInfoForAddress(
- uint64_t Address,
- DILineInfoSpecifier Specifier = DILineInfoSpecifier()) override;
-
-private:
- std::string getFunctionName(uint64_t Address, DINameKind NameKind) const;
- std::unique_ptr<IPDBSession> Session;
-};
+ namespace pdb {
+ /// PDBContext
+ /// This data structure is the top level entity that deals with PDB debug
+ /// information parsing. This data structure exists only when there is a
+ /// need for a transparent interface to different debug information formats
+ /// (e.g. PDB and DWARF). More control and power over the debug information
+ /// access can be had by using the PDB interfaces directly.
+ class PDBContext : public DIContext {
+
+ PDBContext(PDBContext &) = delete;
+ PDBContext &operator=(PDBContext &) = delete;
+
+ public:
+ PDBContext(const object::COFFObjectFile &Object,
+ std::unique_ptr<IPDBSession> PDBSession);
+
+ static bool classof(const DIContext *DICtx) {
+ return DICtx->getKind() == CK_PDB;
+ }
+
+ void dump(raw_ostream &OS, DIDumpType DumpType = DIDT_All,
+ bool DumpEH = false) override;
+
+ DILineInfo getLineInfoForAddress(
+ uint64_t Address,
+ DILineInfoSpecifier Specifier = DILineInfoSpecifier()) override;
+ DILineInfoTable getLineInfoForAddressRange(
+ uint64_t Address, uint64_t Size,
+ DILineInfoSpecifier Specifier = DILineInfoSpecifier()) override;
+ DIInliningInfo getInliningInfoForAddress(
+ uint64_t Address,
+ DILineInfoSpecifier Specifier = DILineInfoSpecifier()) override;
+
+ private:
+ std::string getFunctionName(uint64_t Address, DINameKind NameKind) const;
+ std::unique_ptr<IPDBSession> Session;
+ };
+ }
}
#endif
#include <unordered_map>
namespace llvm {
+
+namespace pdb {
typedef std::unordered_map<PDB_SymType, int> TagStats;
raw_ostream &operator<<(raw_ostream &OS, const PDB_VariantType &Value);
raw_ostream &operator<<(raw_ostream &OS, const VersionInfo &Version);
raw_ostream &operator<<(raw_ostream &OS, const TagStats &Stats);
}
+}
#endif
namespace llvm {
class raw_ostream;
+namespace pdb {
class PDBSymDumper {
public:
bool RequireImpl;
};
}
+}
#endif
namespace llvm {
class StringRef;
-class IPDBRawSymbol;
class raw_ostream;
+namespace pdb {
+class IPDBRawSymbol;
+
#define DECLARE_PDB_SYMBOL_CONCRETE_TYPE(TagValue) \
static const PDB_SymType Tag = TagValue; \
static bool classof(const PDBSymbol *S) { return S->getSymTag() == Tag; }
/// https://msdn.microsoft.com/en-us/library/370hs6k4.aspx
class PDBSymbol {
protected:
- PDBSymbol(const IPDBSession &PDBSession, std::unique_ptr<IPDBRawSymbol> Symbol);
+ PDBSymbol(const IPDBSession &PDBSession,
+ std::unique_ptr<IPDBRawSymbol> Symbol);
public:
static std::unique_ptr<PDBSymbol>
};
} // namespace llvm
+}
#endif
namespace llvm {
class raw_ostream;
+namespace pdb {
class PDBSymbolAnnotation : public PDBSymbol {
public:
FORWARD_SYMBOL_METHOD(getVirtualAddress)
};
}
+}
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLANNOTATION_H
class raw_ostream;
+namespace pdb {
+
class PDBSymbolBlock : public PDBSymbol {
public:
PDBSymbolBlock(const IPDBSession &PDBSession,
FORWARD_SYMBOL_METHOD(getVirtualAddress)
};
}
+}
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLBLOCK_H
class raw_ostream;
+namespace pdb {
+
class PDBSymbolCompiland : public PDBSymbol {
public:
PDBSymbolCompiland(const IPDBSession &PDBSession,
std::string getSourceFileName() const;
};
}
+}
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLCOMPILAND_H
namespace llvm {
class raw_ostream;
+namespace pdb {
class PDBSymbolCompilandDetails : public PDBSymbol {
public:
};
} // namespace llvm
+}
#endif // LLVM_DEBUGINFO_PDB_PDBFUNCTION_H
namespace llvm {
class raw_ostream;
-
+namespace pdb {
class PDBSymbolCompilandEnv : public PDBSymbol {
public:
PDBSymbolCompilandEnv(const IPDBSession &PDBSession,
};
} // namespace llvm
+}
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLCOMPILANDENV_H
class raw_ostream;
+namespace pdb {
/// PDBSymbolCustom represents symbols that are compiler-specific and do not
/// fit anywhere else in the lexical hierarchy.
/// https://msdn.microsoft.com/en-us/library/d88sf09h.aspx
};
} // namespace llvm
+}
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLCUSTOM_H
class raw_ostream;
+namespace pdb {
+
class PDBSymbolData : public PDBSymbol {
public:
PDBSymbolData(const IPDBSession &PDBSession,
};
} // namespace llvm
+}
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLDATA_H
class raw_ostream;
+namespace pdb {
+
class PDBSymbolExe : public PDBSymbol {
public:
PDBSymbolExe(const IPDBSession &PDBSession,
int Indent) const;
};
} // namespace llvm
+}
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLEXE_H
class raw_ostream;
+namespace pdb {
+
class PDBSymbolFunc : public PDBSymbol {
public:
PDBSymbolFunc(const IPDBSession &PDBSession,
};
} // namespace llvm
+}
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLFUNC_H
class raw_ostream;
+namespace pdb {
+
class PDBSymbolFuncDebugEnd : public PDBSymbol {
public:
PDBSymbolFuncDebugEnd(const IPDBSession &PDBSession,
};
} // namespace llvm
+}
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLFUNCDEBUGEND_H
namespace llvm {
class raw_ostream;
+namespace pdb {
class PDBSymbolFuncDebugStart : public PDBSymbol {
public:
};
} // namespace llvm
+}
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLFUNCDEBUGSTART_H
namespace llvm {
class raw_ostream;
+namespace pdb {
class PDBSymbolLabel : public PDBSymbol {
public:
};
} // namespace llvm
+}
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLLABEL_H
namespace llvm {
class raw_ostream;
+namespace pdb {
class PDBSymbolPublicSymbol : public PDBSymbol {
public:
};
} // namespace llvm
+}
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLPUBLICSYMBOL_H
namespace llvm {
class raw_ostream;
+namespace pdb {
class PDBSymbolThunk : public PDBSymbol {
public:
FORWARD_SYMBOL_METHOD(isVolatileType)
};
} // namespace llvm
+}
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTHUNK_H
namespace llvm {
class raw_ostream;
+namespace pdb {
class PDBSymbolTypeArray : public PDBSymbol {
public:
};
} // namespace llvm
+}
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEARRAY_H
namespace llvm {
class raw_ostream;
+namespace pdb {
class PDBSymbolTypeBaseClass : public PDBSymbol {
public:
};
} // namespace llvm
+}
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEBASECLASS_H
namespace llvm {
class raw_ostream;
+namespace pdb {
class PDBSymbolTypeBuiltin : public PDBSymbol {
public:
};
} // namespace llvm
+}
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEBUILTIN_H
namespace llvm {
class raw_ostream;
+namespace pdb {
class PDBSymbolTypeCustom : public PDBSymbol {
public:
};
} // namespace llvm
+}
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPECUSTOM_H
namespace llvm {
class raw_ostream;
+namespace pdb {
class PDBSymbolTypeDimension : public PDBSymbol {
public:
};
} // namespace llvm
+}
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEDIMENSION_H
namespace llvm {
class raw_ostream;
+namespace pdb {
class PDBSymbolTypeEnum : public PDBSymbol {
public:
};
} // namespace llvm
+}
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEENUM_H
namespace llvm {
class raw_ostream;
+namespace pdb {
class PDBSymbolTypeFriend : public PDBSymbol {
public:
};
} // namespace llvm
+}
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEFRIEND_H
namespace llvm {
class raw_ostream;
+namespace pdb {
class PDBSymbolTypeFunctionArg : public PDBSymbol {
public:
};
} // namespace llvm
+}
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEFUNCTIONARG_H
namespace llvm {
class raw_ostream;
+namespace pdb {
class PDBSymbolTypeFunctionSig : public PDBSymbol {
public:
};
} // namespace llvm
+}
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEFUNCTIONSIG_H
namespace llvm {
class raw_ostream;
+namespace pdb {
class PDBSymbolTypeManaged : public PDBSymbol {
public:
};
} // namespace llvm
+}
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEMANAGED_H
namespace llvm {
class raw_ostream;
+namespace pdb {
class PDBSymbolTypePointer : public PDBSymbol {
public:
};
} // namespace llvm
+}
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEPOINTER_H
namespace llvm {
class raw_ostream;
+namespace pdb {
class PDBSymbolTypeTypedef : public PDBSymbol {
public:
};
} // namespace llvm
+}
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPETYPEDEF_H
class raw_ostream;
+namespace pdb {
class PDBSymbolTypeUDT : public PDBSymbol {
public:
PDBSymbolTypeUDT(const IPDBSession &PDBSession,
FORWARD_SYMBOL_METHOD(getVirtualTableShapeId)
FORWARD_SYMBOL_METHOD(isVolatileType)
};
-
+}
} // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEUDT_H
namespace llvm {
class raw_ostream;
+namespace pdb {
class PDBSymbolTypeVTable : public PDBSymbol {
public:
};
} // namespace llvm
+}
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEVTABLE_H
namespace llvm {
class raw_ostream;
+namespace pdb {
class PDBSymbolTypeVTableShape : public PDBSymbol {
public:
};
} // namespace llvm
+}
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEVTABLESHAPE_H
namespace llvm {
class raw_ostream;
+namespace pdb {
class PDBSymbolUnknown : public PDBSymbol {
public:
};
} // namespace llvm
+}
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLUNKNOWN_H
namespace llvm {
class raw_ostream;
+namespace pdb {
class PDBSymbolUsingNamespace : public PDBSymbol {
public:
};
} // namespace llvm
+}
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLUSINGNAMESPACE_H
#include <cstring>
namespace llvm {
+namespace pdb {
class PDBSymDumper;
class PDBSymbol;
};
struct Variant {
- Variant()
- : Type(PDB_VariantType::Empty) {
- }
+ Variant() : Type(PDB_VariantType::Empty) {}
Variant(const Variant &Other) : Type(PDB_VariantType::Empty) {
*this = Other;
};
} // end namespace llvm
+}
namespace std {
-template <> struct hash<llvm::PDB_SymType> {
- typedef llvm::PDB_SymType argument_type;
+template <> struct hash<llvm::pdb::PDB_SymType> {
+ typedef llvm::pdb::PDB_SymType argument_type;
typedef std::size_t result_type;
result_type operator()(const argument_type &Arg) const {
#include "llvm/Support/ConvertUTF.h"
using namespace llvm;
+using namespace llvm::pdb;
DIADataStream::DIADataStream(CComPtr<IDiaEnumDebugStreamData> DiaStreamData)
: StreamData(DiaStreamData) {}
#include "llvm/DebugInfo/PDB/DIA/DIAEnumDebugStreams.h"
using namespace llvm;
+using namespace llvm::pdb;
DIAEnumDebugStreams::DIAEnumDebugStreams(
CComPtr<IDiaEnumDebugStreams> DiaEnumerator)
#include "llvm/DebugInfo/PDB/DIA/DIALineNumber.h"
using namespace llvm;
+using namespace llvm::pdb;
DIAEnumLineNumbers::DIAEnumLineNumbers(
CComPtr<IDiaEnumLineNumbers> DiaEnumerator)
#include "llvm/DebugInfo/PDB/DIA/DIASourceFile.h"
using namespace llvm;
+using namespace llvm::pdb;
DIAEnumSourceFiles::DIAEnumSourceFiles(
const DIASession &PDBSession, CComPtr<IDiaEnumSourceFiles> DiaEnumerator)
#include "llvm/DebugInfo/PDB/DIA/DIASession.h"
using namespace llvm;
+using namespace llvm::pdb;
DIAEnumSymbols::DIAEnumSymbols(const DIASession &PDBSession,
CComPtr<IDiaEnumSymbols> DiaEnumerator)
#include "llvm/DebugInfo/PDB/DIA/DIALineNumber.h"
using namespace llvm;
+using namespace llvm::pdb;
DIALineNumber::DIALineNumber(CComPtr<IDiaLineNumber> DiaLineNumber)
: LineNumber(DiaLineNumber) {}
#include "llvm/Support/raw_ostream.h"
using namespace llvm;
+using namespace llvm::pdb;
namespace {
Variant VariantFromVARIANT(const VARIANT &V) {
#include <diacreate.h>
using namespace llvm;
+using namespace llvm::pdb;
namespace {
#include "llvm/Support/ConvertUTF.h"
using namespace llvm;
+using namespace llvm::pdb;
DIASourceFile::DIASourceFile(const DIASession &PDBSession,
CComPtr<IDiaSourceFile> DiaSourceFile)
#include "llvm/Support/raw_ostream.h"
using namespace llvm;
+using namespace llvm::pdb;
IPDBSourceFile::~IPDBSourceFile() {}
#include "llvm/DebugInfo/PDB/Raw/RawSession.h"
using namespace llvm;
+using namespace llvm::pdb;
-PDB_ErrorCode llvm::loadDataForPDB(PDB_ReaderType Type, StringRef Path,
- std::unique_ptr<IPDBSession> &Session) {
+PDB_ErrorCode llvm::pdb::loadDataForPDB(PDB_ReaderType Type, StringRef Path,
+ std::unique_ptr<IPDBSession> &Session) {
// Create the correct concrete instance type based on the value of Type.
if (Type == PDB_ReaderType::Raw)
- return pdb::RawSession::createFromPdb(Path, Session);
+ return RawSession::createFromPdb(Path, Session);
#if HAVE_DIA_SDK
return DIASession::createFromPdb(Path, Session);
#endif
}
-PDB_ErrorCode llvm::loadDataForEXE(PDB_ReaderType Type, StringRef Path,
- std::unique_ptr<IPDBSession> &Session) {
+PDB_ErrorCode llvm::pdb::loadDataForEXE(PDB_ReaderType Type, StringRef Path,
+ std::unique_ptr<IPDBSession> &Session) {
// Create the correct concrete instance type based on the value of Type.
if (Type == PDB_ReaderType::Raw)
- return pdb::RawSession::createFromExe(Path, Session);
+ return RawSession::createFromExe(Path, Session);
#if HAVE_DIA_SDK
return DIASession::createFromExe(Path, Session);
using namespace llvm;
using namespace llvm::object;
+using namespace llvm::pdb;
PDBContext::PDBContext(const COFFObjectFile &Object,
std::unique_ptr<IPDBSession> PDBSession)
#include "llvm/ADT/ArrayRef.h"
using namespace llvm;
+using namespace llvm::pdb;
#define CASE_OUTPUT_ENUM_CLASS_STR(Class, Value, Str, Stream) \
case Class::Value: \
#define CASE_OUTPUT_ENUM_CLASS_NAME(Class, Value, Stream) \
CASE_OUTPUT_ENUM_CLASS_STR(Class, Value, #Value, Stream)
-raw_ostream &llvm::operator<<(raw_ostream &OS, const PDB_VariantType &Type) {
+raw_ostream &llvm::pdb::operator<<(raw_ostream &OS,
+ const PDB_VariantType &Type) {
switch (Type) {
CASE_OUTPUT_ENUM_CLASS_NAME(PDB_VariantType, Bool, OS)
CASE_OUTPUT_ENUM_CLASS_NAME(PDB_VariantType, Single, OS)
return OS;
}
-raw_ostream &llvm::operator<<(raw_ostream &OS, const PDB_CallingConv &Conv) {
+raw_ostream &llvm::pdb::operator<<(raw_ostream &OS,
+ const PDB_CallingConv &Conv) {
OS << "__";
switch (Conv) {
CASE_OUTPUT_ENUM_CLASS_STR(PDB_CallingConv, NearC , "cdecl", OS)
return OS;
}
-raw_ostream &llvm::operator<<(raw_ostream &OS, const PDB_DataKind &Data) {
+raw_ostream &llvm::pdb::operator<<(raw_ostream &OS, const PDB_DataKind &Data) {
switch (Data) {
CASE_OUTPUT_ENUM_CLASS_STR(PDB_DataKind, Unknown, "unknown", OS)
CASE_OUTPUT_ENUM_CLASS_STR(PDB_DataKind, Local, "local", OS)
return OS;
}
-raw_ostream &llvm::operator<<(raw_ostream &OS, const PDB_RegisterId &Reg) {
+raw_ostream &llvm::pdb::operator<<(raw_ostream &OS, const PDB_RegisterId &Reg) {
switch (Reg) {
CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, AL, OS)
CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, CL, OS)
return OS;
}
-raw_ostream &llvm::operator<<(raw_ostream &OS, const PDB_LocType &Loc) {
+raw_ostream &llvm::pdb::operator<<(raw_ostream &OS, const PDB_LocType &Loc) {
switch (Loc) {
CASE_OUTPUT_ENUM_CLASS_STR(PDB_LocType, Static, "static", OS)
CASE_OUTPUT_ENUM_CLASS_STR(PDB_LocType, TLS, "tls", OS)
return OS;
}
-raw_ostream &llvm::operator<<(raw_ostream &OS, const PDB_ThunkOrdinal &Thunk) {
+raw_ostream &llvm::pdb::operator<<(raw_ostream &OS,
+ const PDB_ThunkOrdinal &Thunk) {
switch (Thunk) {
CASE_OUTPUT_ENUM_CLASS_NAME(PDB_ThunkOrdinal, BranchIsland, OS)
CASE_OUTPUT_ENUM_CLASS_NAME(PDB_ThunkOrdinal, Pcode, OS)
return OS;
}
-raw_ostream &llvm::operator<<(raw_ostream &OS, const PDB_Checksum &Checksum) {
+raw_ostream &llvm::pdb::operator<<(raw_ostream &OS,
+ const PDB_Checksum &Checksum) {
switch (Checksum) {
CASE_OUTPUT_ENUM_CLASS_NAME(PDB_Checksum, None, OS)
CASE_OUTPUT_ENUM_CLASS_NAME(PDB_Checksum, MD5, OS)
return OS;
}
-raw_ostream &llvm::operator<<(raw_ostream &OS, const PDB_Lang &Lang) {
+raw_ostream &llvm::pdb::operator<<(raw_ostream &OS, const PDB_Lang &Lang) {
switch (Lang) {
CASE_OUTPUT_ENUM_CLASS_NAME(PDB_Lang, C, OS)
CASE_OUTPUT_ENUM_CLASS_STR(PDB_Lang, Cpp, "C++", OS)
return OS;
}
-raw_ostream &llvm::operator<<(raw_ostream &OS, const PDB_SymType &Tag) {
+raw_ostream &llvm::pdb::operator<<(raw_ostream &OS, const PDB_SymType &Tag) {
switch (Tag) {
CASE_OUTPUT_ENUM_CLASS_NAME(PDB_SymType, Exe, OS)
CASE_OUTPUT_ENUM_CLASS_NAME(PDB_SymType, Compiland, OS)
return OS;
}
-raw_ostream &llvm::operator<<(raw_ostream &OS, const PDB_MemberAccess &Access) {
+raw_ostream &llvm::pdb::operator<<(raw_ostream &OS,
+ const PDB_MemberAccess &Access) {
switch (Access) {
CASE_OUTPUT_ENUM_CLASS_STR(PDB_MemberAccess, Public, "public", OS)
CASE_OUTPUT_ENUM_CLASS_STR(PDB_MemberAccess, Protected, "protected", OS)
return OS;
}
-raw_ostream &llvm::operator<<(raw_ostream &OS, const PDB_UdtType &Type) {
+raw_ostream &llvm::pdb::operator<<(raw_ostream &OS, const PDB_UdtType &Type) {
switch (Type) {
CASE_OUTPUT_ENUM_CLASS_STR(PDB_UdtType, Class, "class", OS)
CASE_OUTPUT_ENUM_CLASS_STR(PDB_UdtType, Struct, "struct", OS)
return OS;
}
-raw_ostream &llvm::operator<<(raw_ostream &OS, const PDB_UniqueId &Id) {
+raw_ostream &llvm::pdb::operator<<(raw_ostream &OS, const PDB_UniqueId &Id) {
static const char *Lookup = "0123456789ABCDEF";
static_assert(sizeof(PDB_UniqueId) == 16, "Expected 16-byte GUID");
return OS;
}
-raw_ostream &llvm::operator<<(raw_ostream &OS, const PDB_Machine &Machine) {
+raw_ostream &llvm::pdb::operator<<(raw_ostream &OS,
+ const PDB_Machine &Machine) {
switch (Machine) {
CASE_OUTPUT_ENUM_CLASS_NAME(PDB_Machine, Am33, OS)
CASE_OUTPUT_ENUM_CLASS_NAME(PDB_Machine, Amd64, OS)
return OS;
}
-raw_ostream &llvm::operator<<(raw_ostream &OS, const Variant &Value) {
+raw_ostream &llvm::pdb::operator<<(raw_ostream &OS, const Variant &Value) {
switch (Value.Type) {
case PDB_VariantType::Bool:
OS << (Value.Value.Bool ? "true" : "false");
return OS;
}
-raw_ostream &llvm::operator<<(raw_ostream &OS, const VersionInfo &Version) {
+raw_ostream &llvm::pdb::operator<<(raw_ostream &OS,
+ const VersionInfo &Version) {
OS << Version.Major << "." << Version.Minor << "." << Version.Build;
return OS;
}
-raw_ostream &llvm::operator<<(raw_ostream &OS, const TagStats &Stats) {
+raw_ostream &llvm::pdb::operator<<(raw_ostream &OS, const TagStats &Stats) {
for (auto Tag : Stats) {
OS << Tag.first << ":" << Tag.second << " ";
}
#include "llvm/DebugInfo/PDB/IPDBRawSymbol.h"
using namespace llvm;
+using namespace llvm::pdb;
IPDBSession::~IPDBSession() {}
#include "llvm/Support/ErrorHandling.h"
using namespace llvm;
+using namespace llvm::pdb;
#define PDB_SYMDUMP_UNREACHABLE(Type) \
if (RequireImpl) \
#include <utility>
using namespace llvm;
+using namespace llvm::pdb;
PDBSymbol::PDBSymbol(const IPDBSession &PDBSession,
std::unique_ptr<IPDBRawSymbol> Symbol)
#include <utility>
using namespace llvm;
+using namespace llvm::pdb;
PDBSymbolAnnotation::PDBSymbolAnnotation(const IPDBSession &PDBSession,
std::unique_ptr<IPDBRawSymbol> Symbol)
#include <utility>
using namespace llvm;
+using namespace llvm::pdb;
PDBSymbolBlock::PDBSymbolBlock(const IPDBSession &PDBSession,
std::unique_ptr<IPDBRawSymbol> Symbol)
#include <utility>
using namespace llvm;
+using namespace llvm::pdb;
PDBSymbolCompiland::PDBSymbolCompiland(const IPDBSession &PDBSession,
std::unique_ptr<IPDBRawSymbol> Symbol)
#include <utility>
using namespace llvm;
+using namespace llvm::pdb;
PDBSymbolCompilandDetails::PDBSymbolCompilandDetails(
const IPDBSession &PDBSession, std::unique_ptr<IPDBRawSymbol> Symbol)
#include <utility>
using namespace llvm;
+using namespace llvm::pdb;
PDBSymbolCompilandEnv::PDBSymbolCompilandEnv(
const IPDBSession &PDBSession, std::unique_ptr<IPDBRawSymbol> Symbol)
: PDBSymbol(PDBSession, std::move(Symbol)) {}
std::string PDBSymbolCompilandEnv::getValue() const {
- llvm::Variant Value = RawSymbol->getValue();
- if (Value.Type != PDB_VariantType::String)
- return std::string();
- return std::string(Value.Value.String);
+ Variant Value = RawSymbol->getValue();
+ if (Value.Type != PDB_VariantType::String)
+ return std::string();
+ return std::string(Value.Value.String);
}
void PDBSymbolCompilandEnv::dump(PDBSymDumper &Dumper) const {
#include <utility>
using namespace llvm;
+using namespace llvm::pdb;
PDBSymbolCustom::PDBSymbolCustom(const IPDBSession &PDBSession,
std::unique_ptr<IPDBRawSymbol> CustomSymbol)
#include <utility>
using namespace llvm;
+using namespace llvm::pdb;
PDBSymbolData::PDBSymbolData(const IPDBSession &PDBSession,
std::unique_ptr<IPDBRawSymbol> DataSymbol)
#include <utility>
using namespace llvm;
+using namespace llvm::pdb;
PDBSymbolExe::PDBSymbolExe(const IPDBSession &PDBSession,
std::unique_ptr<IPDBRawSymbol> Symbol)
#include <vector>
using namespace llvm;
+using namespace llvm::pdb;
namespace {
class FunctionArgEnumerator : public IPDBEnumChildren<PDBSymbolData> {
#include <utility>
using namespace llvm;
+using namespace llvm::pdb;
PDBSymbolFuncDebugEnd::PDBSymbolFuncDebugEnd(
const IPDBSession &PDBSession, std::unique_ptr<IPDBRawSymbol> Symbol)
#include <utility>
using namespace llvm;
+using namespace llvm::pdb;
PDBSymbolFuncDebugStart::PDBSymbolFuncDebugStart(
const IPDBSession &PDBSession, std::unique_ptr<IPDBRawSymbol> Symbol)
#include <utility>
using namespace llvm;
+using namespace llvm::pdb;
PDBSymbolLabel::PDBSymbolLabel(const IPDBSession &PDBSession,
std::unique_ptr<IPDBRawSymbol> Symbol)
#include <utility>
using namespace llvm;
+using namespace llvm::pdb;
PDBSymbolPublicSymbol::PDBSymbolPublicSymbol(
const IPDBSession &PDBSession, std::unique_ptr<IPDBRawSymbol> Symbol)
#include <utility>
using namespace llvm;
+using namespace llvm::pdb;
PDBSymbolThunk::PDBSymbolThunk(const IPDBSession &PDBSession,
std::unique_ptr<IPDBRawSymbol> Symbol)
#include <utility>
using namespace llvm;
+using namespace llvm::pdb;
PDBSymbolTypeArray::PDBSymbolTypeArray(const IPDBSession &PDBSession,
std::unique_ptr<IPDBRawSymbol> Symbol)
#include <utility>
using namespace llvm;
+using namespace llvm::pdb;
PDBSymbolTypeBaseClass::PDBSymbolTypeBaseClass(
const IPDBSession &PDBSession, std::unique_ptr<IPDBRawSymbol> Symbol)
#include <utility>
using namespace llvm;
+using namespace llvm::pdb;
PDBSymbolTypeBuiltin::PDBSymbolTypeBuiltin(
const IPDBSession &PDBSession, std::unique_ptr<IPDBRawSymbol> Symbol)
#include <utility>
using namespace llvm;
+using namespace llvm::pdb;
PDBSymbolTypeCustom::PDBSymbolTypeCustom(const IPDBSession &PDBSession,
std::unique_ptr<IPDBRawSymbol> Symbol)
#include <utility>
using namespace llvm;
+using namespace llvm::pdb;
PDBSymbolTypeDimension::PDBSymbolTypeDimension(
const IPDBSession &PDBSession, std::unique_ptr<IPDBRawSymbol> Symbol)
#include <utility>
using namespace llvm;
+using namespace llvm::pdb;
PDBSymbolTypeEnum::PDBSymbolTypeEnum(const IPDBSession &PDBSession,
std::unique_ptr<IPDBRawSymbol> Symbol)
#include <utility>
using namespace llvm;
+using namespace llvm::pdb;
PDBSymbolTypeFriend::PDBSymbolTypeFriend(const IPDBSession &PDBSession,
std::unique_ptr<IPDBRawSymbol> Symbol)
#include <utility>
using namespace llvm;
+using namespace llvm::pdb;
PDBSymbolTypeFunctionArg::PDBSymbolTypeFunctionArg(
const IPDBSession &PDBSession, std::unique_ptr<IPDBRawSymbol> Symbol)
#include <utility>
using namespace llvm;
+using namespace llvm::pdb;
namespace {
class FunctionArgEnumerator : public IPDBEnumSymbols {
#include <utility>
using namespace llvm;
+using namespace llvm::pdb;
PDBSymbolTypeManaged::PDBSymbolTypeManaged(
const IPDBSession &PDBSession, std::unique_ptr<IPDBRawSymbol> Symbol)
#include <utility>
using namespace llvm;
+using namespace llvm::pdb;
PDBSymbolTypePointer::PDBSymbolTypePointer(
const IPDBSession &PDBSession, std::unique_ptr<IPDBRawSymbol> Symbol)
#include <utility>
using namespace llvm;
+using namespace llvm::pdb;
PDBSymbolTypeTypedef::PDBSymbolTypeTypedef(
const IPDBSession &PDBSession, std::unique_ptr<IPDBRawSymbol> Symbol)
#include <utility>
using namespace llvm;
+using namespace llvm::pdb;
PDBSymbolTypeUDT::PDBSymbolTypeUDT(const IPDBSession &PDBSession,
std::unique_ptr<IPDBRawSymbol> Symbol)
#include <utility>
using namespace llvm;
+using namespace llvm::pdb;
PDBSymbolTypeVTable::PDBSymbolTypeVTable(const IPDBSession &PDBSession,
std::unique_ptr<IPDBRawSymbol> Symbol)
#include <utility>
using namespace llvm;
+using namespace llvm::pdb;
PDBSymbolTypeVTableShape::PDBSymbolTypeVTableShape(
const IPDBSession &PDBSession, std::unique_ptr<IPDBRawSymbol> Symbol)
#include <utility>
using namespace llvm;
+using namespace llvm::pdb;
PDBSymbolUnknown::PDBSymbolUnknown(const IPDBSession &PDBSession,
std::unique_ptr<IPDBRawSymbol> Symbol)
#include <utility>
using namespace llvm;
+using namespace llvm::pdb;
PDBSymbolUsingNamespace::PDBSymbolUsingNamespace(
const IPDBSession &PDBSession, std::unique_ptr<IPDBRawSymbol> Symbol)
std::unique_ptr<DIContext> Context;
if (auto CoffObject = dyn_cast<COFFObjectFile>(Objects.first)) {
+ using namespace pdb;
// If this is a COFF object, assume it contains PDB debug information. If
// we don't find any we will fall back to the DWARF case.
std::unique_ptr<IPDBSession> Session;
#include "llvm/DebugInfo/PDB/PDBSymbolTypeBuiltin.h"
using namespace llvm;
+using namespace llvm::pdb;
BuiltinDumper::BuiltinDumper(LinePrinter &P)
: PDBSymDumper(false), Printer(P) {}
#include "llvm/DebugInfo/PDB/PDBSymDumper.h"
namespace llvm {
+namespace pdb {
class LinePrinter;
LinePrinter &Printer;
};
}
+}
#endif
#include "llvm/Support/Format.h"
using namespace llvm;
+using namespace llvm::pdb;
ClassDefinitionDumper::ClassDefinitionDumper(LinePrinter &P)
: PDBSymDumper(true), Printer(P) {}
#include <unordered_map>
namespace llvm {
+namespace pdb {
class LinePrinter;
int dumpAccessGroup(PDB_MemberAccess Access, const SymbolGroup &Group);
};
}
-
+}
#endif
#include <utility>
using namespace llvm;
+using namespace llvm::pdb;
CompilandDumper::CompilandDumper(LinePrinter &P)
: PDBSymDumper(true), Printer(P) {}
#include "llvm/DebugInfo/PDB/PDBSymDumper.h"
namespace llvm {
+namespace pdb {
class LinePrinter;
LinePrinter &Printer;
};
}
+}
#endif
#include "llvm/DebugInfo/PDB/PDBSymbolTypeEnum.h"
using namespace llvm;
+using namespace llvm::pdb;
EnumDumper::EnumDumper(LinePrinter &P) : PDBSymDumper(true), Printer(P) {}
#include "llvm/DebugInfo/PDB/PDBSymDumper.h"
namespace llvm {
+namespace pdb {
class LinePrinter;
LinePrinter &Printer;
};
}
-
+}
#endif
#include "llvm/Support/Format.h"
using namespace llvm;
+using namespace llvm::pdb;
ExternalSymbolDumper::ExternalSymbolDumper(LinePrinter &P)
: PDBSymDumper(true), Printer(P) {}
#include "llvm/DebugInfo/PDB/PDBSymDumper.h"
namespace llvm {
+namespace pdb {
class LinePrinter;
LinePrinter &Printer;
};
}
+}
#endif
#include "llvm-pdbdump.h"
#include "llvm/DebugInfo/PDB/IPDBSession.h"
+#include "llvm/DebugInfo/PDB/PDBExtras.h"
#include "llvm/DebugInfo/PDB/PDBSymbolData.h"
#include "llvm/DebugInfo/PDB/PDBSymbolFunc.h"
#include "llvm/DebugInfo/PDB/PDBSymbolFuncDebugEnd.h"
using namespace llvm;
using namespace llvm::codeview;
+using namespace llvm::pdb;
namespace {
template <class T>
void dumpClassParentWithScopeOperator(const T &Symbol, LinePrinter &Printer,
- llvm::FunctionDumper &Dumper) {
+ FunctionDumper &Dumper) {
uint32_t ClassParentId = Symbol.getClassParentId();
auto ClassParent =
Symbol.getSession().template getConcreteSymbolById<PDBSymbolTypeUDT>(
Symbol.getSession().getConcreteSymbolById<PDBSymbolTypeUDT>(
ClassParentId);
- CallingConvention CC = Symbol.getCallingConvention();
+ PDB_CallingConv CC = Symbol.getCallingConvention();
bool ShouldDumpCallingConvention = true;
if ((ClassParent && CC == CallingConvention::ThisCall) ||
(!ClassParent && CC == CallingConvention::NearStdCall)) {
#include "llvm/DebugInfo/PDB/PDBSymDumper.h"
namespace llvm {
-
+namespace pdb {
class LinePrinter;
class FunctionDumper : public PDBSymDumper {
LinePrinter &Printer;
};
}
+}
#endif
#include <algorithm>
+using namespace llvm;
+using namespace llvm::pdb;
+
namespace {
bool IsItemExcluded(llvm::StringRef Item,
std::list<llvm::Regex> &IncludeFilters,
#include <list>
namespace llvm {
+namespace pdb {
class LinePrinter {
friend class WithColor;
raw_ostream &OS;
};
}
+}
#endif
#include "llvm/DebugInfo/PDB/PDBSymbolTypeUDT.h"
using namespace llvm;
+using namespace llvm::pdb;
TypeDumper::TypeDumper(LinePrinter &P) : PDBSymDumper(true), Printer(P) {}
#include "llvm/DebugInfo/PDB/PDBSymDumper.h"
namespace llvm {
-
+namespace pdb {
class LinePrinter;
class TypeDumper : public PDBSymDumper {
LinePrinter &Printer;
};
}
-
+}
#endif
#include "llvm/DebugInfo/PDB/PDBSymbolTypeUDT.h"
using namespace llvm;
+using namespace llvm::pdb;
TypedefDumper::TypedefDumper(LinePrinter &P) : PDBSymDumper(true), Printer(P) {}
#include "llvm/DebugInfo/PDB/PDBSymDumper.h"
namespace llvm {
+namespace pdb {
class LinePrinter;
LinePrinter &Printer;
};
}
+}
#endif
#include "llvm/Support/Format.h"
using namespace llvm;
+using namespace llvm::pdb;
VariableDumper::VariableDumper(LinePrinter &P)
: PDBSymDumper(true), Printer(P) {}
namespace llvm {
class StringRef;
+
+namespace pdb {
+
class LinePrinter;
class VariableDumper : public PDBSymDumper {
LinePrinter &Printer;
};
}
-
+}
#endif
projects / llvm / commitdiff