--- /dev/null
+//===- NativeTypeArray.h ------------------------------------------ C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEBUGINFO_PDB_NATIVE_NATIVETYPEARRAY_H
+#define LLVM_DEBUGINFO_PDB_NATIVE_NATIVETYPEARRAY_H
+
+#include "llvm/DebugInfo/PDB/Native/NativeRawSymbol.h"
+
+#include "llvm/DebugInfo/CodeView/TypeRecord.h"
+#include "llvm/DebugInfo/PDB/PDBTypes.h"
+
+namespace llvm {
+namespace pdb {
+
+class NativeSession;
+
+class NativeTypeArray : public NativeRawSymbol {
+public:
+ NativeTypeArray(NativeSession &Session, SymIndexId Id, codeview::TypeIndex TI,
+ codeview::ArrayRecord Record);
+ ~NativeTypeArray() override;
+
+ void dump(raw_ostream &OS, int Indent, PdbSymbolIdField ShowIdFields,
+ PdbSymbolIdField RecurseIdFields) const override;
+
+ SymIndexId getArrayIndexTypeId() const override;
+
+ bool isConstType() const override;
+ bool isUnalignedType() const override;
+ bool isVolatileType() const override;
+
+ uint32_t getCount() const override;
+ SymIndexId getTypeId() const override;
+ uint64_t getLength() const override;
+
+protected:
+ codeview::ArrayRecord Record;
+ codeview::TypeIndex Index;
+};
+
+} // namespace pdb
+} // namespace llvm
+
+#endif
Native/NativeExeSymbol.cpp
Native/NativeRawSymbol.cpp
Native/NativeSymbolEnumerator.cpp
+ Native/NativeTypeArray.cpp
Native/NativeTypeBuiltin.cpp
Native/NativeTypeEnum.cpp
Native/NativeTypeFunctionSig.cpp
return std::unique_ptr<IPDBEnumSymbols>(new NativeEnumModules(Session));
break;
}
+ case PDB_SymType::ArrayType:
+ return Session.getSymbolCache().createTypeEnumerator(codeview::LF_ARRAY);
case PDB_SymType::Enum:
return Session.getSymbolCache().createTypeEnumerator(codeview::LF_ENUM);
case PDB_SymType::PointerType:
--- /dev/null
+//===- NativeTypeArray.cpp - info about arrays ------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/DebugInfo/PDB/Native/NativeTypeArray.h"
+
+#include "llvm/DebugInfo/CodeView/SymbolRecord.h"
+#include "llvm/DebugInfo/PDB/Native/NativeTypeBuiltin.h"
+#include "llvm/DebugInfo/PDB/Native/NativeTypeEnum.h"
+
+using namespace llvm;
+using namespace llvm::codeview;
+using namespace llvm::pdb;
+
+NativeTypeArray::NativeTypeArray(NativeSession &Session, SymIndexId Id,
+ codeview::TypeIndex TI,
+ codeview::ArrayRecord Record)
+ : NativeRawSymbol(Session, PDB_SymType::ArrayType, Id), Record(Record),
+ Index(TI) {}
+NativeTypeArray::~NativeTypeArray() {}
+
+void NativeTypeArray::dump(raw_ostream &OS, int Indent,
+ PdbSymbolIdField ShowIdFields,
+ PdbSymbolIdField RecurseIdFields) const {
+ NativeRawSymbol::dump(OS, Indent, ShowIdFields, RecurseIdFields);
+
+ dumpSymbolField(OS, "arrayIndexTypeId", getArrayIndexTypeId(), Indent);
+ dumpSymbolIdField(OS, "elementTypeId", getTypeId(), Indent, Session,
+ PdbSymbolIdField::Type, ShowIdFields, RecurseIdFields);
+
+ dumpSymbolIdField(OS, "lexicalParentId", 0, Indent, Session,
+ PdbSymbolIdField::LexicalParent, ShowIdFields,
+ RecurseIdFields);
+ dumpSymbolField(OS, "length", getLength(), Indent);
+ dumpSymbolField(OS, "count", getCount(), Indent);
+ dumpSymbolField(OS, "constType", isConstType(), Indent);
+ dumpSymbolField(OS, "unalignedType", isUnalignedType(), Indent);
+ dumpSymbolField(OS, "volatileType", isVolatileType(), Indent);
+}
+
+SymIndexId NativeTypeArray::getArrayIndexTypeId() const {
+ return Session.getSymbolCache().findSymbolByTypeIndex(Record.getIndexType());
+}
+
+bool NativeTypeArray::isConstType() const { return false; }
+
+bool NativeTypeArray::isUnalignedType() const { return false; }
+
+bool NativeTypeArray::isVolatileType() const { return false; }
+
+uint32_t NativeTypeArray::getCount() const {
+ NativeRawSymbol &Element =
+ Session.getSymbolCache().getNativeSymbolById(getTypeId());
+ return getLength() / Element.getLength();
+}
+
+SymIndexId NativeTypeArray::getTypeId() const {
+ return Session.getSymbolCache().findSymbolByTypeIndex(
+ Record.getElementType());
+}
+
+uint64_t NativeTypeArray::getLength() const { return Record.Size; }
\ No newline at end of file
#include "llvm/DebugInfo/PDB/Native/NativeEnumTypes.h"
#include "llvm/DebugInfo/PDB/Native/NativeRawSymbol.h"
#include "llvm/DebugInfo/PDB/Native/NativeSession.h"
+#include "llvm/DebugInfo/PDB/Native/NativeTypeArray.h"
#include "llvm/DebugInfo/PDB/Native/NativeTypeBuiltin.h"
#include "llvm/DebugInfo/PDB/Native/NativeTypeEnum.h"
#include "llvm/DebugInfo/PDB/Native/NativeTypeFunctionSig.h"
case codeview::LF_ENUM:
Id = createSymbolForType<NativeTypeEnum, EnumRecord>(Index, std::move(CVT));
break;
+ case codeview::LF_ARRAY:
+ Id = createSymbolForType<NativeTypeArray, ArrayRecord>(Index,
+ std::move(CVT));
+ break;
case codeview::LF_CLASS:
case codeview::LF_STRUCTURE:
case codeview::LF_INTERFACE:
--- /dev/null
+// Build with "cl.exe /Zi /GR- /GX- every-array.cpp /link /debug /nodefaultlib /entry:main"
+
+// clang-format off
+void *__purecall = 0;
+
+void __cdecl operator delete(void *,unsigned int) {}
+void __cdecl operator delete(void *,unsigned __int64) {}
+
+
+int func1() { return 42; }
+int func2() { return 43; }
+int func3() { return 44; }
+
+template<typename T>
+void Reference(T &t) { }
+
+int IA[3] = {1, 2, 3};
+const int CIA[3] = {1, 2, 3};
+volatile int VIA[3] = {1, 2, 3};
+
+using FuncPtr = decltype(&func1);
+FuncPtr FA[3] = {&func1, &func2, &func3};
+
+struct S {
+ int N;
+ int f() const { return 42; }
+};
+
+using MemDataPtr = decltype(&S::N);
+using MemFunPtr = decltype(&S::f);
+
+MemDataPtr MDA[1] = {&S::N};
+MemFunPtr MFA[1] = {&S::f};
+
+
+int main(int argc, char **argv) {
+}
#include "llvm/DebugInfo/PDB/IPDBSession.h"
#include "llvm/DebugInfo/PDB/PDBSymbolExe.h"
+#include "llvm/DebugInfo/PDB/PDBSymbolTypeArray.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeBuiltin.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeEnum.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeFunctionSig.h"
if (opts::pretty::Typedefs)
dumpSymbolCategory<PDBSymbolTypeTypedef>(Printer, Exe, *this, "Typedefs");
+ if (opts::pretty::Arrays)
+ dumpSymbolCategory<PDBSymbolTypeArray>(Printer, Exe, *this, "Arrays");
+
if (opts::pretty::Pointers)
dumpSymbolCategory<PDBSymbolTypePointer>(Printer, Exe, *this, "Pointers");
Dumper.start(Symbol);
}
+void TypeDumper::dump(const PDBSymbolTypeArray &Symbol) {
+ auto ElementType = Symbol.getElementType();
+
+ ElementType->dump(*this);
+ Printer << "[";
+ WithColor(Printer, PDB_ColorItem::LiteralValue).get() << Symbol.getCount();
+ Printer << "]";
+}
+
void TypeDumper::dump(const PDBSymbolTypeFunctionSig &Symbol) {
FunctionDumper Dumper(Printer);
Dumper.start(Symbol, nullptr, FunctionDumper::PointerType::None);
void dump(const PDBSymbolTypeEnum &Symbol) override;
void dump(const PDBSymbolTypeTypedef &Symbol) override;
void dump(const PDBSymbolTypeFunctionSig &Symbol) override;
+ void dump(const PDBSymbolTypeArray &Symbol) override;
void dump(const PDBSymbolTypeBuiltin &Symbol) override;
void dump(const PDBSymbolTypePointer &Symbol) override;
static cl::opt<bool> Funcsigs("funcsigs",
cl::desc("Dump function signature information"),
cl::sub(DiaDumpSubcommand));
+static cl::opt<bool> Arrays("arrays", cl::desc("Dump array types"),
+ cl::sub(DiaDumpSubcommand));
} // namespace diadump
namespace pretty {
cl::cat(TypeCategory), cl::sub(PrettySubcommand));
cl::opt<bool> Pointers("pointers", cl::desc("Display pointer types"),
cl::cat(TypeCategory), cl::sub(PrettySubcommand));
+cl::opt<bool> Arrays("arrays", cl::desc("Display arrays"),
+ cl::cat(TypeCategory), cl::sub(PrettySubcommand));
cl::opt<SymbolSortMode> SymbolOrder(
"symbol-order", cl::desc("symbol sort order"),
SymTypes.push_back(PDB_SymType::UDT);
if (opts::diadump::Funcsigs)
SymTypes.push_back(PDB_SymType::FunctionSig);
-
+ if (opts::diadump::Arrays)
+ SymTypes.push_back(PDB_SymType::ArrayType);
PdbSymbolIdField Ids = opts::diadump::NoSymIndexIds ? PdbSymbolIdField::None
: PdbSymbolIdField::All;
PdbSymbolIdField Recurse = PdbSymbolIdField::None;
}
if (opts::pretty::Classes || opts::pretty::Enums || opts::pretty::Typedefs ||
- opts::pretty::Funcsigs || opts::pretty::Pointers) {
+ opts::pretty::Funcsigs || opts::pretty::Pointers ||
+ opts::pretty::Arrays) {
Printer.NewLine();
WithColor(Printer, PDB_ColorItem::SectionHeader).get() << "---TYPES---";
Printer.Indent();
dumpInjectedSources(Printer, *Session);
}
+ Printer.NewLine();
outs().flush();
}
extern llvm::cl::opt<bool> Classes;
extern llvm::cl::opt<bool> Enums;
extern llvm::cl::opt<bool> Funcsigs;
+extern llvm::cl::opt<bool> Arrays;
extern llvm::cl::opt<bool> Typedefs;
extern llvm::cl::opt<bool> Pointers;
extern llvm::cl::opt<bool> All;