[codeview] Isolate type dumping from object file state

[rnk]

Summary

This isolates the state we use for type dumping from the knowledge of object
files. We can use CVTypeDumper to dump types from anywhere in memory now.

[rnk]

style

[zturner]

I wonder if llvm-pdbdump will want to use this eventually. Although I don't have a good idea where to put it in common code so that it can be reused.

[rnk]

In D19824#419069, @zturner wrote:

I wonder if llvm-pdbdump will want to use this eventually. Although I don't have a good idea where to put it in common code so that it can be reused.

Agreed. I think maybe it's best for llvm-pdbdump to keep testing the interface you have that abstracts over DIA.

My goal for this is to be able to dump a merged type stream without creating an object file or PDB. That should let us write more targeted tests.

[zturner]

In D19824#419096, @rnk wrote:

In D19824#419069, @zturner wrote:

I wonder if llvm-pdbdump will want to use this eventually. Although I don't have a good idea where to put it in common code so that it can be reused.

Agreed. I think maybe it's best for llvm-pdbdump to keep testing the interface you have that abstracts over DIA.

It should certainly continue to test that, but I think it should also dump the raw properties of a file, such as the stuff I've been working on the past week. Low level file structure type stuff.

[amccarth]

tools/llvm-readobj/COFFDumper.cpp

57 ↗

(On Diff #55873)

explicit?

70 ↗

(On Diff #55873)

user-defined (hyphen)

llvm/trunk/tools/llvm-readobj/COFFDumper.cpp

 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::codeview;
 using namespace llvm::support;
 using namespace llvm::Win64EH;
 
 namespace {
 
+class CVTypeDumper {
+public:
+  CVTypeDumper(StreamWriter &W) : W(W) {}
+
+  StringRef getTypeName(TypeIndex TI);
+  void printTypeIndex(StringRef FieldName, TypeIndex TI);
+
+  void dump(StringRef Data);
+
+private:
+  void printCodeViewFieldList(StringRef FieldData);
+  void printMemberAttributes(MemberAttributes Attrs);
+
+  StreamWriter &W;
+
+  /// All user defined type records in .debug$T live in here. Type indices
+  /// greater than 0x1000 are user defined. Subtract 0x1000 from the index to
+  /// index into this vector.
+  SmallVector<StringRef, 10> CVUDTNames;
+
+  StringSet<> TypeNames;
+};
+
 class COFFDumper : public ObjDumper {
 public:
-  COFFDumper(const llvm::object::COFFObjectFile *Obj, StreamWriter& Writer)
-    : ObjDumper(Writer)
-    , Obj(Obj) {
-  }
+  COFFDumper(const llvm::object::COFFObjectFile *Obj, StreamWriter &Writer)
+      : ObjDumper(Writer), Obj(Obj), CVTD(Writer) {}
 
   void printFileHeaders() override;
   void printSections() override;
   void printRelocations() override;
   void printSymbols() override;
   void printDynamicSymbols() override;
   void printUnwindInfo() override;
   void printCOFFImports() override;
private:
 
   void printDOSHeader(const dos_header *DH);
   template <class PEHeader> void printPEHeader(const PEHeader *Hdr);
   void printBaseOfDataField(const pe32_header *Hdr);
   void printBaseOfDataField(const pe32plus_header *Hdr);
 
   void printCodeViewSymbolSection(StringRef SectionName, const SectionRef &Section);
   void printCodeViewTypeSection(StringRef SectionName, const SectionRef &Section);
-  void printCodeViewFieldList(StringRef FieldData);
   StringRef getTypeName(TypeIndex Ty);
   StringRef getFileNameForFileOffset(uint32_t FileOffset);
   void printFileNameForOffset(StringRef Label, uint32_t FileOffset);
-  void printTypeIndex(StringRef FieldName, TypeIndex TI);
+  void printTypeIndex(StringRef FieldName, TypeIndex TI) {
+    // Forward to CVTypeDumper for simplicity.
+    CVTD.printTypeIndex(FieldName, TI);
+  }
   void printLocalVariableAddrRange(const LocalVariableAddrRange &Range,
                                    const coff_section *Sec,
                                    StringRef SectionContents);
   void printLocalVariableAddrGap(StringRef &SymData);
 
   void printCodeViewSymbolsSubsection(StringRef Subsection,
                                       const SectionRef &Section,
                                       StringRef SectionContents);
 
   void printCodeViewFileChecksums(StringRef Subsection);
 
   void printCodeViewInlineeLines(StringRef Subsection);
 
-  void printMemberAttributes(MemberAttributes Attrs);
-
   void printRelocatedField(StringRef Label, const coff_section *Sec,
                            StringRef SectionContents, const ulittle32_t *Field,
                            StringRef *RelocSym = nullptr);
 
   void printBinaryBlockWithRelocs(StringRef Label, const SectionRef &Sec,
                                   StringRef SectionContents, StringRef Block);
 
   /// Given a .debug$S section, find the string table and file checksum table.
private:
   typedef DenseMap<const coff_section*, std::vector<RelocationRef> > RelocMapTy;
 
   const llvm::object::COFFObjectFile *Obj;
   bool RelocCached = false;
   RelocMapTy RelocMap;
   StringRef CVFileChecksumTable;
   StringRef CVStringTable;
 
-  /// All user defined type records in .debug$T live in here. Type indices
-  /// greater than 0x1000 are user defined. Subtract 0x1000 from the index to
-  /// index into this vector.
-  SmallVector<StringRef, 10> CVUDTNames;
-
-  StringSet<> TypeNames;
+  CVTypeDumper CVTD;
 };
 
 } // namespace
 
 
 namespace llvm {
 
 std::error_code createCOFFDumper(const object::ObjectFile *Obj,

 
 StringRef getRemainingBytesAsString(const TypeRecordPrefix *Rec, const char *Start) {
   StringRef Remaining = getRemainingTypeBytes(Rec, Start);
   StringRef Leading, Trailing;
   std::tie(Leading, Trailing) = Remaining.split('\0');
   return Leading;
 }
 
-StringRef COFFDumper::getTypeName(TypeIndex TI) {
+StringRef CVTypeDumper::getTypeName(TypeIndex TI) {
   if (TI.isNoType())
     return "<no type>";
 
   if (TI.isSimple()) {
     // This is a simple type.
     for (const auto &SimpleTypeName : SimpleTypeNames) {
       if (SimpleTypeName.Value == TI.getSimpleKind()) {
         if (TI.getSimpleMode() == SimpleTypeMode::Direct)
StringRef CVTypeDumper::getTypeName(TypeIndex TI) {
   StringRef UDTName;
   unsigned UDTIndex = TI.getIndex() - 0x1000;
   if (UDTIndex < CVUDTNames.size())
     return CVUDTNames[UDTIndex];
 
   return "<unknown UDT>";
 }
 
-void COFFDumper::printTypeIndex(StringRef FieldName, TypeIndex TI) {
+void CVTypeDumper::printTypeIndex(StringRef FieldName, TypeIndex TI) {
   StringRef TypeName;
   if (!TI.isNoType())
     TypeName = getTypeName(TI);
   if (!TypeName.empty())
     W.printHex(FieldName, TypeName, TI.getIndex());
   else
     W.printHex(FieldName, TI.getIndex());
 }
void COFFDumper::printCodeViewTypeSection(StringRef SectionName,
   if (opts::CodeViewSubsectionBytes)
     W.printBinaryBlock("Data", Data);
 
   unsigned Magic = *reinterpret_cast<const ulittle32_t *>(Data.data());
   W.printHex("Magic", Magic);
 
   Data = Data.drop_front(4);
 
+  CVTD.dump(Data);
+}
+
+void CVTypeDumper::dump(StringRef Data) {
   while (!Data.empty()) {
     const TypeRecordPrefix *Rec;
     error(consumeObject(Data, Rec));
     auto Leaf = static_cast<TypeLeafKind>(uint16_t(Rec->Leaf));
 
     // This record is 'Len - 2' bytes, and the next one starts immediately
     // afterwards.
     StringRef LeafData = Data.substr(0, Rec->Len - 2);
static StringRef skipPadding(StringRef Data) {
   uint8_t Leaf = Data.front();
   if (Leaf < LF_PAD0)
     return Data;
   // Leaf is greater than 0xf0. We should advance by the number of bytes in the
   // low 4 bits.
   return Data.drop_front(Leaf & 0x0F);
 }
 
-void COFFDumper::printMemberAttributes(MemberAttributes Attrs) {
+void CVTypeDumper::printMemberAttributes(MemberAttributes Attrs) {
   W.printEnum("AccessSpecifier", uint8_t(Attrs.getAccess()),
               makeArrayRef(MemberAccessNames));
   auto MK = Attrs.getMethodKind();
   // Data members will be vanilla. Don't try to print a method kind for them.
   if (MK != MethodKind::Vanilla)
     W.printEnum("MethodKind", unsigned(MK), makeArrayRef(MemberKindNames));
   if (Attrs.getFlags() != MethodOptions::None) {
     W.printFlags("MethodOptions", unsigned(Attrs.getFlags()),
                  makeArrayRef(MethodOptionNames));
   }
 }
 
-void COFFDumper::printCodeViewFieldList(StringRef FieldData) {
+void CVTypeDumper::printCodeViewFieldList(StringRef FieldData) {
   while (!FieldData.empty()) {
     const ulittle16_t *LeafPtr;
     error(consumeObject(FieldData, LeafPtr));
     uint16_t Leaf = *LeafPtr;
     switch (Leaf) {
     default:
       W.printHex("UnknownMember", Leaf);
       // We can't advance once we hit an unknown field. The size is not encoded.