Boilerplate for modifications to the readobj tool to display .rsrc

[ecbeckmann]

Summary

Adding functionality to readobj to display resource section data. This is necessary in order to test the cvtres tool when it is added.

[zturner]

I think this is a bit too small of a change. I know I said to do it incrementally and not as one big patch, but it seems like we should be able to do something meaningful. For example, there's a .rsrc$1 and .rsrc$2, perhaps you could display some metadata about them and dump the raw bytes of the sections without parsing the tree structure and individual resources.

[ecbeckmann]

Adding some basic functionality for displaying timestamps of .rsrc directory table.

[ecbeckmann]

Prints timestamp and actual data of .rsrc sections.

[ecbeckmann]

Fixed some descriptions, removed logging

[zturner]

Since this is printing something real now, can we add a FileCheck test for it?

llvm/include/llvm/Object/COFF.h

1064–1066 ↗

(On Diff #96646)

Seems like either all fields should be initialized inline, or none should. Is there a reason only OwningObject gets the special treatment?

llvm/lib/Object/COFFObjectFile.cpp

454 ↗

(On Diff #96646)

delete this debug statement as well as the subsequent ones as well.

llvm/tools/llvm-readobj/COFFDumper.cpp

1536–1537 ↗

(On Diff #96646)

This will miss a couple of cases.

1. .rsrc. This occurs in the merged executable file. For example:

D:\src\llvmbuild\ninja>bin\llvm-objdump -section-headers bin\clang.exe

bin\clang.exe:  file format COFF-i386

Sections:
Idx Name          Size      Address          Type
            ...
  6 .rsrc         0000075c 0000000006bb2000 DATA
            ...

2. It's possible in the future we may end up finding out there's a .rsrc$03. I'd change this check to if (!Name.starts_with(".rsrc"))

1540–1541 ↗

(On Diff #96646)

Move these two lines up out of the if statement.

1544–1549 ↗

(On Diff #96646)

It looks like this is a time_t? We have some functions so you don't have to reproduce this formatting code every time.

#include "llvm/Support/Chrono.h"

...

auto Time = sys::toTimePoint(TimeDateStamp);
SmallString<20> FormattedTime;
raw_svector_ostream OS(FormattedTime);
OS << Time;

W.printHex("Time/Date Stamp", FormattedTime, TimeDateStamp);

1553–1555 ↗

(On Diff #96646)

Then delete this branch and call printBinaryBlock below.

[ruiu]

llvm/tools/llvm-readobj/COFFDumper.cpp

1542–1543 ↗

(On Diff #96650)

I don't see why you need this ResourceDirTableRef class. Since you are accessing section data by casting it to coff_resource_dir_table *, you can just access members directly. I mean, you could do something like this.

auto *Ent = reinterpret_cast<const coff_resource_dir_table *>(Ref.data()));
...
time_t TDS = time_t(Ent->TimeDateStamp);

This is I think the usual way of accessing COFF section data.

[ecbeckmann]

Update to print .rsrc in both .o and .exe

[ecbeckmann]

llvm/include/llvm/Object/COFF.h

1064–1066 ↗

(On Diff #96646)

This pattern is followed for all other section wrapper classes in this file. I don't understand the inherent benefit of doing this but I see no reason to break the pattern either.

llvm/tools/llvm-readobj/COFFDumper.cpp

1542–1543 ↗

(On Diff #96650)

True, however in the coming patches I think the ResourceDirTableRef class will be extended to do many more complicated things, like traversing the tree structure and returning certain resource data. I think it will be good to encapsulate this.

1536–1537 ↗

(On Diff #96646)

Ah okay...I was thinking for now we can just build the feature around reading .o's and not .exe's because that's what we want to test, but if it's not much more effort we might as well do both.

1544–1549 ↗

(On Diff #96646)

Done, however it looks like using the TimePoint library gives times based on 1969-12-31 instead of 1970-1-1, is this expected behavior?

[ruiu]

llvm/include/llvm/Object/COFF.h

1064–1066 ↗

(On Diff #96646)

Adding a wrapper that you don't need and even understand existential reason is not a good idea. You can add it later if you need it, but at the moment this new code just complicates the code unnecessarily.

[zturner]

llvm/tools/llvm-readobj/COFFDumper.cpp

1544–1549 ↗

(On Diff #96646)

Hmm, I find this a bit surprising. Looking at the code, it calls std::chrono::system_clock::from_time_t which takes a std::time_t. cppreference says that it's not technically defined, but almost always uses the unix epoch. I would expect that your implementation is also using the unix epoch. So maybe it's a problem in the printing code?

Can you paste the exact formatted string both with the original code and the operator<< code?

[ruiu]

I seems like a timezone issue. We are in PST, and PST is UTC-0800, which describes why you got 1969-12-31 16:00:00 instead of 1970-00-00 00:00:00. You want to print it out in UTC.

[ecbeckmann]

Removed the unnecessary wrapper class for now, updated printing time stamp.

[ecbeckmann]

In D32463#738457, @ruiu wrote:

I seems like a timezone issue. We are in PST, and PST is UTC-0800, which describes why you got 1969-12-31 16:00:00 instead of 1970-00-00 00:00:00. You want to print it out in UTC.

The new code should print the correct time zone.

[zturner]

looks good, thanks for being patient :)

[ruiu]

This looks much better now. A few minor nits.

llvm/tools/llvm-readobj/COFFDumper.cpp

1545 ↗

(On Diff #96810)

I think strftime null-terminates a string, so you don't need to initialize the buffer with = {}.

1547 ↗

(On Diff #96810)

sizeof(FormattedTime) is better than 20.

[ecbeckmann]

Fixed some nits.

[ruiu]

LGTM

llvm/trunk/include/llvm/Object/COFF.h

 
 struct coff_base_reloc_block_entry {
   support::ulittle16_t Data;
 
   int getType() const { return Data >> 12; }
   int getOffset() const { return Data & ((1 << 12) - 1); }
 };
 
+struct coff_resource_dir_table {
+  support::ulittle32_t Characteristics;
+  support::ulittle32_t TimeDateStamp;
+  support::ulittle16_t MajorVersion;
+  support::ulittle16_t MinorVersion;
+  support::ulittle16_t NumberOfNameEntries;
+  support::ulittle16_t NumberOfIDEntries;
+};
+
 class COFFObjectFile : public ObjectFile {
 private:
   friend class ImportDirectoryEntryRef;
   friend class ExportDirectoryEntryRef;
   const coff_file_header *COFFHeader;
   const coff_bigobj_file_header *COFFBigObjHeader;
   const pe32_header *PE32Header;
   const pe32plus_header *PE32PlusHeader;

llvm/trunk/test/tools/llvm-readobj/resources.test

+RUN: llvm-readobj -coff-resources %p/Inputs/zero-string-table.obj.coff-i386 \
+RUN:   | FileCheck %s -check-prefix RESOURCE
+
+RESOURCE:      Resources [
+RESOURCE-NEXT:   Time/Date Stamp: 1970-01-01 00:00:00 (0x0)
+RESOURCE-NEXT:   .rsrc$01 Data (
+RESOURCE-NEXT:     0000: 00000000 00000000 00000000 00000100  |................|
+RESOURCE-NEXT:     0010: 06000000 18000080 00000000 00000000  |................|
+RESOURCE-NEXT:     0020: 00000000 00000100 01000000 30000080  |............0...|
+RESOURCE-NEXT:     0030: 00000000 00000000 00000000 00000100  |................|
+RESOURCE-NEXT:     0040: 09040000 48000000 00000000 2A000000  |....H.......*...|
+RESOURCE-NEXT:     0050: 00000000 00000000                    |........|
+RESOURCE-NEXT:   )
+RESOURCE-NEXT:   .rsrc$02 Data (
+RESOURCE-NEXT:     0000: 00000500 48006500 6C006C00 6F000000  |....H.e.l.l.o...|
+RESOURCE-NEXT:     0010: 00000000 00000000 00000000 00000000  |................|
+RESOURCE-NEXT:     0020: 00000000 00000000 00000000 00000000  |................|
+RESOURCE-NEXT:   )
+RESOURCE-NEXT: ]

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

public:
   void printSymbols() override;
   void printDynamicSymbols() override;
   void printUnwindInfo() override;
   void printCOFFImports() override;
   void printCOFFExports() override;
   void printCOFFDirectives() override;
   void printCOFFBaseReloc() override;
   void printCOFFDebugDirectory() override;
+  void printCOFFResources() override;
   void printCodeViewDebugInfo() override;
   void mergeCodeViewTypes(llvm::codeview::TypeTableBuilder &CVIDs,
                           llvm::codeview::TypeTableBuilder &CVTypes) override;
   void printStackMap() const override;
 private:
   void printSymbol(const SymbolRef &Sym);
   void printRelocation(const SectionRef &Section, const RelocationRef &Reloc,
                        uint64_t Bias = 0);
for (const BaseRelocRef &I : Obj->base_relocs()) {
     error(I.getRVA(RVA));
     error(I.getType(Type));
     DictScope Import(W, "Entry");
     W.printString("Type", getBaseRelocTypeName(Type));
     W.printHex("Address", RVA);
   }
 }
 
+void COFFDumper::printCOFFResources() {
+  ListScope ResourcesD(W, "Resources");
+  for (const SectionRef &S : Obj->sections()) {
+    StringRef Name;
+    error(S.getName(Name));
+    if (!Name.startswith(".rsrc"))
+      continue;
+
+    StringRef Ref;
+    error(S.getContents(Ref));
+
+    if ((Name == ".rsrc") || (Name == ".rsrc$01")) {
+      auto Table =
+          reinterpret_cast<const coff_resource_dir_table *>(Ref.data());
+      char FormattedTime[20];
+      time_t TDS = time_t(Table->TimeDateStamp);
+      strftime(FormattedTime, sizeof(FormattedTime), "%Y-%m-%d %H:%M:%S",
+               gmtime(&TDS));
+      W.printHex("Time/Date Stamp", FormattedTime, Table->TimeDateStamp);
+    }
+    W.printBinaryBlock(Name.str() + " Data", Ref);
+  }
+}
+
 void COFFDumper::printStackMap() const {
   object::SectionRef StackMapSection;
   for (auto Sec : Obj->sections()) {
     StringRef Name;
     Sec.getName(Name);
     if (Name == ".llvm_stackmaps") {
       StackMapSection = Sec;
       break;

llvm/trunk/tools/llvm-readobj/ObjDumper.h

public:
   virtual void printAMDGPUCodeObjectMetadata() {}
 
   // Only implemented for PE/COFF.
   virtual void printCOFFImports() { }
   virtual void printCOFFExports() { }
   virtual void printCOFFDirectives() { }
   virtual void printCOFFBaseReloc() { }
   virtual void printCOFFDebugDirectory() { }
+  virtual void printCOFFResources() {}
   virtual void printCodeViewDebugInfo() { }
   virtual void mergeCodeViewTypes(llvm::codeview::TypeTableBuilder &CVIDs,
                                   llvm::codeview::TypeTableBuilder &CVTypes) {}
 
   // Only implemented for MachO.
   virtual void printMachODataInCode() { }
   virtual void printMachOVersionMin() { }
   virtual void printMachODysymtab() { }

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

namespace opts {
   COFFBaseRelocs("coff-basereloc",
                  cl::desc("Display the PE/COFF .reloc section"));
 
   // -coff-debug-directory
   cl::opt<bool>
   COFFDebugDirectory("coff-debug-directory",
                      cl::desc("Display the PE/COFF debug directory"));
 
+  // -coff-resources
+  cl::opt<bool> COFFResources("coff-resources",
+                              cl::desc("Display the PE/COFF .rsrc section"));
+
   // -macho-data-in-code
   cl::opt<bool>
   MachODataInCode("macho-data-in-code",
                   cl::desc("Display MachO Data in Code command"));
 
   // -macho-indirect-symbols
   cl::opt<bool>
   MachOIndirectSymbols("macho-indirect-symbols",
if (Obj->isCOFF()) {
     if (opts::COFFExports)
       Dumper->printCOFFExports();
     if (opts::COFFDirectives)
       Dumper->printCOFFDirectives();
     if (opts::COFFBaseRelocs)
       Dumper->printCOFFBaseReloc();
     if (opts::COFFDebugDirectory)
       Dumper->printCOFFDebugDirectory();
+    if (opts::COFFResources)
+      Dumper->printCOFFResources();
     if (opts::CodeView)
       Dumper->printCodeViewDebugInfo();
     if (opts::CodeViewMergedTypes)
       Dumper->mergeCodeViewTypes(CVTypes.IDTable, CVTypes.TypeTable);
   }
   if (Obj->isMachO()) {
     if (opts::MachODataInCode)
       Dumper->printMachODataInCode();