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

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

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

llvm/tools/llvm-readobj/COFFDumper.cpp

1536–1537

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

Move these two lines up out of the if statement.

1544–1549

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

Then delete this branch and call printBinaryBlock below.

[ruiu]

llvm/tools/llvm-readobj/COFFDumper.cpp

1542–1543

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

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

1536–1537

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.

1542–1543

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.

1544–1549

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

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

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

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

1547

sizeof(FormattedTime) is better than 20.

[ecbeckmann]

Fixed some nits.

[ruiu]

LGTM

llvm/include/llvm/Object/COFF.h

 
 namespace object {
 
 class BaseRelocRef;
 class DelayImportDirectoryEntryRef;
 class ExportDirectoryEntryRef;
 class ImportDirectoryEntryRef;
 class ImportedSymbolRef;
+class ResourceDirTableRef;
 
 using import_directory_iterator = content_iterator<ImportDirectoryEntryRef>;
 using delay_import_directory_iterator =
     content_iterator<DelayImportDirectoryEntryRef>;
 using export_directory_iterator = content_iterator<ExportDirectoryEntryRef>;
 using imported_symbol_iterator = content_iterator<ImportedSymbolRef>;
 using base_reloc_iterator = content_iterator<BaseRelocRef>;
 

 
 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;
public:
   std::error_code getRVA(uint32_t &Result) const;
 
 private:
   const coff_base_reloc_block_header *Header;
   uint32_t Index;
   const COFFObjectFile *OwningObject = nullptr;
 };
 
+class ResourceDirTableRef {
+public:
+  ResourceDirTableRef() = default;
+  ResourceDirTableRef(const coff_resource_dir_table *Table,
+                      const COFFObjectFile *Owner)
+      : Table(Table), Index(0), OwningObject(Owner) {}
+
+  std::error_code getCharacteristics(uint32_t &Characteristics) const;
+  std::error_code getTimeDateStamp(uint32_t &Stamp) const;
+  std::error_code getNumberOfIDs(uint16_t &IDs) const;
+  std::error_code getNumberOfNames(uint16_t &Names) const;
+
+private:
+  const coff_resource_dir_table *Table;
+  uint32_t Index;
+  const COFFObjectFile *OwningObject = nullptr;
+};
+
 // Corresponds to `_FPO_DATA` structure in the PE/COFF spec.
 struct FpoData {
   support::ulittle32_t Offset; // ulOffStart: Offset 1st byte of function code
   support::ulittle32_t Size;   // cbProcSize: # bytes in function
   support::ulittle32_t NumLocals; // cdwLocals: # bytes in locals/4
   support::ulittle16_t NumParams; // cdwParams: # bytes in params/4
   support::ulittle16_t Attributes;
 

llvm/lib/Object/COFFObjectFile.cpp

uint64_t COFFObjectFile::getImageBase() const {
   else if (PE32PlusHeader)
     return PE32PlusHeader->ImageBase;
   // This actually comes up in practice.
   return 0;
 }
 
 // Returns the file offset for the given VA.
 std::error_code COFFObjectFile::getVaPtr(uint64_t Addr, uintptr_t &Res) const {
   uint64_t ImageBase = getImageBase();
   uint64_t Rva = Addr - ImageBase;
   assert(Rva <= UINT32_MAX);
   return getRvaPtr((uint32_t)Rva, Res);
 }
 
 // Returns the file offset for the given RVA.
 std::error_code COFFObjectFile::getRvaPtr(uint32_t Addr, uintptr_t &Res) const {
   for (const SectionRef &S : sections()) {
std::error_code BaseRelocRef::getType(uint8_t &Type) const {
   return std::error_code();
 }
 
 std::error_code BaseRelocRef::getRVA(uint32_t &Result) const {
   auto *Entry = reinterpret_cast<const coff_base_reloc_block_entry *>(Header + 1);
   Result = Header->PageRVA + Entry[Index].getOffset();
   return std::error_code();
 }
+
+std::error_code
+ResourceDirTableRef::getCharacteristics(uint32_t &Characteristics) const {
+  Characteristics = Table->Characteristics;
+  return std::error_code();
+}
+
+std::error_code ResourceDirTableRef::getTimeDateStamp(uint32_t &Stamp) const {
+  Stamp = Table->TimeDateStamp;
+  return std::error_code();
+}
+
+std::error_code ResourceDirTableRef::getNumberOfNames(uint16_t &Names) const {
+  Names = Table->NumberOfNameEntries;
+  return std::error_code();
+}
+
+std::error_code ResourceDirTableRef::getNumberOfIDs(uint16_t &IDs) const {
+  IDs = Table->NumberOfIDEntries;
+  return std::error_code();
+}

llvm/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 != ".rsrc$01") && (Name != ".rsrc$02"))
+      continue;
+
+    if (Name == ".rsrc$01") {
+      StringRef Ref;
+      error(S.getContents(Ref));
+      ResourceDirTableRef Table(
+          reinterpret_cast<const coff_resource_dir_table *>(Ref.data()), Obj);
+      uint32_t TimeDateStamp;
+      error(Table.getTimeDateStamp(TimeDateStamp));
+      char FormattedTime[20] = { };
+      time_t TDS = time_t(TimeDateStamp);
+      strftime(FormattedTime, 20, "%Y-%m-%d %H:%M:%S", gmtime(&TDS));
+      W.printHex("Time/Date Stamp", FormattedTime, TDS);
+      W.printBinaryBlock(".rsrc$01 Data", Ref);
+    }
+    else {
+      StringRef Ref;
+      error(S.getContents(Ref));
+      W.printBinaryBlock(".rsrc$02 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/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/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 (.o file only)"));
+
   // -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();