[WebAssembly] Add wasm support for llvm-readobj

[sbc100]

• Run clang-format

[dschuff]

tools/llvm-readobj/WasmDumper.cpp

26 ↗

(On Diff #80091)

I guess these are now "CUSTOM" sections.

[sbc100]

• Rename sections to
• Merge remote-tracking branch 'origin/master' into wasm_readobj_support
• Merge remote-tracking branch 'origin/master' into wasm_readobj_support

tools/llvm-readobj/WasmDumper.cpp

26 ↗

(On Diff #80091)

Sure, I was going to make that a seperate CL but will do that now.

[sbc100]

• clang-format

[dschuff]

tools/llvm-readobj/WasmDumper.cpp

57 ↗

(On Diff #80475)

I wonder if we should have a field in the output for the name as well. Output for user sections wouldn't be very interesting without it, and it would be consistent with other formats which have names for every section. Obviously only user sections have interesting names that are different from their types, but it wouldn't hurt to also print "TABLE" or "EXPORT" or whatever for the standard sections as well.

[dschuff]

tools/llvm-readobj/WasmDumper.cpp

57 ↗

(On Diff #80475)

Come to think of it, we should do that in llvm-objdump as well, so maybe that can just be a separate change.

[sbc100]

• Merge remote-tracking branch 'origin/master' into wasm_readobj_support
• Dump custom section name

[sbc100]

Any other comments on this?

[sbc100]

Ping. Can we land this Derek?

[dschuff]

I'd prefer to get at least a brief look by @Bigcheese or someone (suggestions, if not you?) that knows this part of the code better than I do, since we're creating something new here. Let's see if we can get a response now that people may be coming back from vacation.

[dschuff]

ping. Any comments from @Bigcheese or perhaps @davide ?

[davide]

test/tools/llvm-readobj/file-headers.test

29–31 ↗

(On Diff #82171)

Please add a comment exaplining how you created the source file. That is:
-> compiler/linker/any tool used invocation & source code. Thanks!
This is useful in case we need to regenerate the input object file.

tools/llvm-readobj/WasmDumper.cpp

1 ↗

(On Diff #82171)

You may want to mention WASM Object file dumping utility ?

85–88 ↗

(On Diff #82171)

Can this always happen? You enter here under Obj->isWasm().
If there's a legitimate where this can happen, I would add a test (if you don't mind).
Also, not entirely sure if unsupported_obj_file_format is the best diagnostic we can emit. Maybe broken_file? (I suspect this is consistent with what other dumpers are doing, if so, leave it as is but please add a test to exercise this code).

[Bigcheese]

lgtm with davide's concerns resolved.

[sbc100]

• Run clang-format
• Rename sections to
• clang-format
• Dump custom section name
• update comment
• Add rebuild instructions for trivial.obj.wasm

[sbc100]

tools/llvm-readobj/WasmDumper.cpp

85–88 ↗

(On Diff #82171)

This is exactly what the MachO and COFF dumpers do yes, and basically the same as the ELF dumper.

You are correct that in practice there is no way this can happen, at least not by running the tool itself. In light of this I don't see how I can write a test to tickle this, and I think perhaps an assert would be more appropriate here?

[davide]

tools/llvm-readobj/WasmDumper.cpp

85–88 ↗

(On Diff #82171)

Yes, that's what I would do.
Probably better not cargo culting dubious code from other drivers.

[davide]

LGTM with the modification suggested in createWasmDumper (replace with an assertion).

[davide]

Another minor comment (and thanks for your patience).

lib/Object/WasmObjectFile.cpp

86–89 ↗

(On Diff #86343)

Also, clang-format the patch before submitting. This looks a little bit weirdly formatted but it could be just phab.

[sbc100]

• switch to assert()

[sbc100]

lib/Object/WasmObjectFile.cpp

86–89 ↗

(On Diff #86343)

This is what clang-format wants apparently.

[davide]

Feel free to submit.

llvm/trunk/include/llvm/Object/Wasm.h

protected:
   uint8_t getBytesInAddress() const override;
   StringRef getFileFormatName() const override;
   unsigned getArch() const override;
   SubtargetFeatures getFeatures() const override;
   bool isRelocatableObject() const override;
 
 private:
   const uint8_t *getPtr(size_t Offset) const;
-  Error parseUserSection(wasm::WasmSection &Sec, const uint8_t *Ptr,
+  Error parseCustomSection(wasm::WasmSection &Sec, const uint8_t *Ptr,
                            size_t Length);
 
   wasm::WasmObjectHeader Header;
   std::vector<wasm::WasmSection> Sections;
 };
 }
 }
 
 #endif

llvm/trunk/include/llvm/Support/Wasm.h

 struct WasmSection {
   uint32_t Type;             // Section type (See below)
   uint32_t Offset;           // Offset with in the file
   StringRef Name;            // Section name (User-defined sections only)
   ArrayRef<uint8_t> Content; // Section content
 };
 
 enum : unsigned {
-  WASM_SEC_USER = 0,     // User-defined section
+  WASM_SEC_CUSTOM = 0,   // Custom / User-defined section
   WASM_SEC_TYPE = 1,     // Function signature declarations
   WASM_SEC_IMPORT = 2,   // Import declarations
   WASM_SEC_FUNCTION = 3, // Function declarations
   WASM_SEC_TABLE = 4,    // Indirect function table and other tables
   WASM_SEC_MEMORY = 5,   // Memory attributes
   WASM_SEC_GLOBAL = 6,   // Global declarations
   WASM_SEC_EXPORT = 7,   // Exports
   WASM_SEC_START = 8,    // Start function declaration

llvm/trunk/lib/Object/WasmObjectFile.cpp

if (Header.Version != wasm::WasmVersion) {
     return;
   }
 
   const uint8_t *Eof = getPtr(getData().size());
   wasm::WasmSection Sec;
   while (Ptr < Eof) {
     if ((Err = readSection(Sec, Ptr, getPtr(0))))
       return;
-    if (Sec.Type == wasm::WASM_SEC_USER) {
-      if ((Err = parseUserSection(Sec, Sec.Content.data(), Sec.Content.size())))
+    if (Sec.Type == wasm::WASM_SEC_CUSTOM) {
+      if ((Err =
+               parseCustomSection(Sec, Sec.Content.data(), Sec.Content.size())))
         return;
     }
     Sections.push_back(Sec);
   }
 }
 
-Error WasmObjectFile::parseUserSection(wasm::WasmSection &Sec,
+Error WasmObjectFile::parseCustomSection(wasm::WasmSection &Sec,
                                          const uint8_t *Ptr, size_t Length) {
   Sec.Name = readString(Ptr);
   return Error::success();
 }
 
 const uint8_t *WasmObjectFile::getPtr(size_t Offset) const {
   return reinterpret_cast<const uint8_t *>(getData().substr(Offset, 1).data());
 }
 
switch (S.Type) {
     ECase(TABLE);
     ECase(MEMORY);
     ECase(GLOBAL);
     ECase(EXPORT);
     ECase(START);
     ECase(ELEM);
     ECase(CODE);
     ECase(DATA);
-  case wasm::WASM_SEC_USER:
+  case wasm::WASM_SEC_CUSTOM:
     Res = S.Name;
     break;
   default:
     return object_error::invalid_section_index;
   }
 #undef ECase
   return std::error_code();
 }

llvm/trunk/test/tools/llvm-readobj/file-headers.test

 RUN: llvm-readobj -h %p/Inputs/trivial.obj.macho-arm \
 RUN:   | FileCheck %s -check-prefix MACHO-ARM
 RUN: llvm-readobj -h %p/Inputs/magic.coff-unknown \
 RUN:   | FileCheck %s -check-prefix COFF-UNKNOWN
 RUN: llvm-readobj -h %p/Inputs/magic.coff-importlib \
 RUN:   | FileCheck %s -check-prefix COFF-IMPORTLIB
 RUN: llvm-readobj -h %p/Inputs/trivial.obj.elf-lanai \
 RUN:   | FileCheck %s -check-prefix ELF-LANAI
+# trivial.obj.wasm was generated using wast2wasm which is part of the wabt
+# project (https://github.com/WebAssembly/wabt) using the following command:
+# $ wast2wasm --debug-names ./test/roundtrip/generate-some-names.txt -o \
+#   trivial.obj.wasm
+RUN: llvm-readobj -h %p/Inputs/trivial.obj.wasm \
+RUN:   | FileCheck %s -check-prefix WASM
 
 COFF-ARM:      File: {{(.*[/\\])?}}trivial.obj.coff-arm
 COFF-ARM-NEXT: Format: COFF-ARM
 COFF-ARM-NEXT: Arch: thumb
 COFF-ARM-NEXT: AddressSize: 32bit
 COFF-ARM-NEXT: ImageFileHeader {
 COFF-ARM-NEXT:   Machine: IMAGE_FILE_MACHINE_ARMNT (0x1C4)
 COFF-ARM-NEXT:   SectionCount: 2

 ELF-LANAI-NEXT:   ]
 ELF-LANAI-NEXT:   HeaderSize: 52
 ELF-LANAI-NEXT:   ProgramHeaderEntrySize: 0
 ELF-LANAI-NEXT:   ProgramHeaderCount: 0
 ELF-LANAI-NEXT:   SectionHeaderEntrySize: 40
 ELF-LANAI-NEXT:   SectionHeaderCount: 8
 ELF-LANAI-NEXT:   StringTableSectionIndex: 1
 ELF-LANAI-NEXT: }
+
+WASM: Format: WASM
+WASM-NEXT: Arch: wasm32
+WASM-NEXT: AddressSize: 32bit
+WASM-NEXT: Version: 0xD

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

 RUN: llvm-readobj -s %p/Inputs/trivial.obj.coff-i386 \
 RUN:   | FileCheck %s -check-prefix COFF
 RUN: llvm-readobj -s %p/Inputs/trivial.obj.elf-i386 \
 RUN:   | FileCheck %s -check-prefix ELF
 RUN: llvm-readobj -s %p/Inputs/trivial.obj.elf-mipsel \
 RUN:   | FileCheck %s -check-prefix ELF-MIPSEL
 RUN: llvm-readobj -s %p/Inputs/trivial.obj.macho-i386 \
 RUN:   | FileCheck %s -check-prefix MACHO-I386
 RUN: llvm-readobj -s %p/Inputs/trivial.obj.macho-x86-64 \
 RUN:   | FileCheck %s -check-prefix MACHO-X86-64
 RUN: llvm-readobj -s %p/Inputs/trivial.obj.macho-ppc \
 RUN:   | FileCheck %s -check-prefix MACHO-PPC
 RUN: llvm-readobj -s %p/Inputs/trivial.obj.macho-ppc64 \
 RUN:   | FileCheck %s -check-prefix MACHO-PPC64
 RUN: llvm-readobj -s %p/Inputs/trivial.obj.macho-arm \
 RUN:   | FileCheck %s -check-prefix MACHO-ARM
+RUN: llvm-readobj -s %p/Inputs/trivial.obj.wasm \
+RUN:   | FileCheck %s -check-prefix WASM
 
 COFF:      Sections [
 COFF-NEXT:   Section {
 COFF-NEXT:     Number: 1
 COFF-NEXT:     Name: .text (2E 74 65 78 74 00 00 00)
 COFF-NEXT:     VirtualSize: 0x0
 COFF-NEXT:     VirtualAddress: 0x0
 COFF-NEXT:     RawDataSize: 22

 MACHO-ARM-NEXT:    RelocationCount: 0
 MACHO-ARM-NEXT:    Type: 0x6
 MACHO-ARM-NEXT:    Attributes [ (0x0)
 MACHO-ARM-NEXT:    ]
 MACHO-ARM-NEXT:    Reserved1: 0x0
 MACHO-ARM-NEXT:    Reserved2: 0x0
 MACHO-ARM-NEXT:  }
 MACHO-ARM-NEXT:]
+
+WASM: Sections [
+WASM-NEXT:   Section {
+WASM-NEXT:     Type: TYPE (0x1)
+WASM-NEXT:     Size: 15
+WASM-NEXT:     Offset: 8
+WASM-NEXT:   }
+WASM-NEXT:   Section {
+WASM-NEXT:     Type: IMPORT (0x2)
+WASM-NEXT:     Size: 11
+WASM-NEXT:     Offset: 25
+WASM-NEXT:   }
+WASM-NEXT:   Section {
+WASM-NEXT:     Type: FUNCTION (0x3)
+WASM-NEXT:     Size: 3
+WASM-NEXT:     Offset: 38
+WASM-NEXT:   }
+WASM-NEXT:   Section {
+WASM-NEXT:     Type: TABLE (0x4)
+WASM-NEXT:     Size: 5
+WASM-NEXT:     Offset: 43
+WASM-NEXT:   }
+WASM-NEXT:   Section {
+WASM-NEXT:     Type: EXPORT (0x7)
+WASM-NEXT:     Size: 14
+WASM-NEXT:     Offset: 50
+WASM-NEXT:   }
+WASM-NEXT:   Section {
+WASM-NEXT:     Type: ELEM (0x9)
+WASM-NEXT:     Size: 7
+WASM-NEXT:     Offset: 66
+WASM-NEXT:   }
+WASM-NEXT:   Section {
+WASM-NEXT:     Type: CODE (0xA)
+WASM-NEXT:     Size: 42
+WASM-NEXT:     Offset: 75
+WASM-NEXT:   }
+WASM-NEXT:   Section {
+WASM-NEXT:     Type: CUSTOM (0x0)
+WASM-NEXT:     Size: 44
+WASM-NEXT:     Offset: 119
+WASM-NEXT:     Name: name
+WASM-NEXT:   }
+WASM-NEXT: ]

llvm/trunk/tools/llvm-readobj/CMakeLists.txt

add_llvm_tool(llvm-readobj
   ARMWinEHPrinter.cpp
   COFFDumper.cpp
   COFFImportDumper.cpp
   ELFDumper.cpp
   Error.cpp
   llvm-readobj.cpp
   MachODumper.cpp
   ObjDumper.cpp
+  WasmDumper.cpp
   Win64EHDumper.cpp
   )

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

 std::error_code createELFDumper(const object::ObjectFile *Obj,
                                 ScopedPrinter &Writer,
                                 std::unique_ptr<ObjDumper> &Result);
 
 std::error_code createMachODumper(const object::ObjectFile *Obj,
                                   ScopedPrinter &Writer,
                                   std::unique_ptr<ObjDumper> &Result);
 
+std::error_code createWasmDumper(const object::ObjectFile *Obj,
+                                 ScopedPrinter &Writer,
+                                 std::unique_ptr<ObjDumper> &Result);
+
 void dumpCOFFImportFile(const object::COFFImportFile *File);
 
 void dumpCodeViewMergedTypes(ScopedPrinter &Writer,
                              llvm::codeview::TypeTableBuilder &CVTypes);
 
 } // namespace llvm
 
 #endif

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

+//===-- WasmDumper.cpp - Wasm-specific object file dumper -----------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements the Wasm-specific dumper for llvm-readobj.
+//
+//===----------------------------------------------------------------------===//
+
+#include "Error.h"
+#include "ObjDumper.h"
+#include "llvm/Object/Wasm.h"
+#include "llvm/Support/ScopedPrinter.h"
+
+using namespace llvm;
+using namespace object;
+
+namespace {
+
+const char *wasmSectionTypeToString(uint32_t Type) {
+#define ECase(X)                                                               \
+  case wasm::WASM_SEC_##X:                                                     \
+    return #X;
+  switch (Type) {
+    ECase(CUSTOM);
+    ECase(TYPE);
+    ECase(IMPORT);
+    ECase(FUNCTION);
+    ECase(TABLE);
+    ECase(MEMORY);
+    ECase(GLOBAL);
+    ECase(EXPORT);
+    ECase(START);
+    ECase(ELEM);
+    ECase(CODE);
+    ECase(DATA);
+  }
+#undef ECase
+  return "";
+}
+
+class WasmDumper : public ObjDumper {
+public:
+  WasmDumper(const WasmObjectFile *Obj, ScopedPrinter &Writer)
+      : ObjDumper(Writer), Obj(Obj) {}
+
+  void printFileHeaders() override {
+    W.printHex("Version", Obj->getHeader().Version);
+  }
+
+  void printSections() override {
+    ListScope Group(W, "Sections");
+    for (const SectionRef &Section : Obj->sections()) {
+      const wasm::WasmSection *WasmSec = Obj->getWasmSection(Section);
+      DictScope SectionD(W, "Section");
+      const char *Type = wasmSectionTypeToString(WasmSec->Type);
+      W.printHex("Type", Type, WasmSec->Type);
+      W.printNumber("Size", WasmSec->Content.size());
+      W.printNumber("Offset", WasmSec->Offset);
+      if (WasmSec->Type == wasm::WASM_SEC_CUSTOM) {
+        W.printString("Name", WasmSec->Name);
+      }
+    }
+  }
+  void printRelocations() override { llvm_unreachable("unimplemented"); }
+  void printSymbols() override { llvm_unreachable("unimplemented"); }
+  void printDynamicSymbols() override { llvm_unreachable("unimplemented"); }
+  void printUnwindInfo() override { llvm_unreachable("unimplemented"); }
+  void printStackMap() const override { llvm_unreachable("unimplemented"); }
+
+private:
+  const WasmObjectFile *Obj;
+};
+}
+
+namespace llvm {
+
+std::error_code createWasmDumper(const object::ObjectFile *Obj,
+                                 ScopedPrinter &Writer,
+                                 std::unique_ptr<ObjDumper> &Result) {
+  const WasmObjectFile *WasmObj = dyn_cast<WasmObjectFile>(Obj);
+  assert(WasmObj && "createWasmDumper called with non-wasm object");
+
+  Result.reset(new WasmDumper(WasmObj, Writer));
+  return readobj_error::success;
+}
+
+} // namespace llvm

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

if (!Obj)
     return readobj_error::unsupported_file_format;
 
   if (Obj->isCOFF())
     return createCOFFDumper(Obj, Writer, Result);
   if (Obj->isELF())
     return createELFDumper(Obj, Writer, Result);
   if (Obj->isMachO())
     return createMachODumper(Obj, Writer, Result);
+  if (Obj->isWasm())
+    return createWasmDumper(Obj, Writer, Result);
 
   return readobj_error::unsupported_obj_file_format;
 }
 
 /// @brief Dumps the specified object file.
 static void dumpObject(const ObjectFile *Obj) {
   ScopedPrinter Writer(outs());
   std::unique_ptr<ObjDumper> Dumper;