[WebAssembly] Add initial support for llvm-nm

[sbc100]

Summary

Basic support based on only on reading the names section of a wasm file.

[sunfish]

Overall, looks good. You know things are starting to get real when you can run nm on them ;-).

lib/Object/WasmObjectFile.cpp

119

This code doesn't handle truncated object files, where the file stops before Count names, or a name stops before the number of bytes it's supposed to have, or an LEB stops before its terminating byte. It could end up reading memory beyond the end of the object file. At a glance, it looks like lib/Object code in general isn't super picky about this kind of thing in general though, so I'll leave it up to you what you want to do here.

170

ObjectFile's default printSymbolName implementation just calls getSymbolName. Could we implement getSymbolName instead, and drop this printSymbolName override?

173

Concerning SF_Executable, that makes sense to hard-code here for now because the current patch is only parsing the current name section, which only provides names for functions. Could you mention this in a comment?

Concerning SF_Global, it seems like the real global symbol names would be the import/export names, which this patch isn't decoding yet. Name-section names are a different kind of thing; at first glance, it does seem useful to include them in nm output, however they're not visible to other modules. So perhaps they should be non-global.

194

Symb.d.a is effectively holding a function-index-space value here. That seems fine for now, though it's worth thinking about whether we eventually want to be printing table indices instead (although that raises other questions, since not all functions will be in the table, and functions could theoretically appear in the table multiple times.) Could you add some comments here mentioning these considerations?

[sbc100]

• update wasm binaries
• Update to new names section format

[sbc100]

Abandoning in favor of larger change that handles imports and exports too: https://reviews.llvm.org/D31099

include/llvm/Object/Wasm.h

protected:
   unsigned getArch() const override;
   SubtargetFeatures getFeatures() const override;
   bool isRelocatableObject() const override;
 
 private:
   const uint8_t *getPtr(size_t Offset) const;
   Error parseCustomSection(wasm::WasmSection &Sec, const uint8_t *Ptr,
                            size_t Length);
+  Error parseNameSection(const uint8_t *Ptr, const uint8_t *End);
 
   wasm::WasmObjectHeader Header;
   std::vector<wasm::WasmSection> Sections;
+  std::vector<StringRef> Symbols;
 };
 
 } // end namespace object
 } // end namespace llvm
 
 #endif // LLVM_OBJECT_WASM_H

include/llvm/Support/Wasm.h

enum : unsigned {
   WASM_OPCODE_END        = 0x0b,
   WASM_OPCODE_GET_GLOBAL = 0x23,
   WASM_OPCODE_I32_CONST  = 0x41,
   WASM_OPCODE_I64_CONST  = 0x42,
   WASM_OPCODE_F32_CONST  = 0x43,
   WASM_OPCODE_F64_CONST  = 0x44,
 };
 
+enum : unsigned {
+  WASM_NAMES_FUNCTION    = 0x1,
+  WASM_NAMES_LOCAL       = 0x2,
+};
+
 #define WASM_RELOC(name, value) name = value,
 
 enum : unsigned {
 #include "WasmRelocs/WebAssembly.def"
 };
 
 } // end namespace wasm
 } // end namespace llvm
 
 #endif

lib/Object/WasmObjectFile.cpp

if (Sec.Type == wasm::WASM_SEC_CUSTOM) {
       if ((Err =
                parseCustomSection(Sec, Sec.Content.data(), Sec.Content.size())))
         return;
     }
     Sections.push_back(Sec);
   }
 }
 
+Error WasmObjectFile::parseNameSection(const uint8_t *Ptr, const uint8_t *End) {
+  while (Ptr < End) {
+    uint32_t Type = readULEB128(Ptr);
+    uint32_t Size = readULEB128(Ptr);
+    switch (Type) {
+      case wasm::WASM_NAMES_FUNCTION: {
+        uint32_t Count = readULEB128(Ptr);
+        while (Count--) {
+          uint32_t Index = readULEB128(Ptr);
+          StringRef Name = readString(Ptr);
+          Symbols.push_back(Name);
+        }
+        break;
+      }
+      case wasm::WASM_NAMES_LOCAL: {
+        // Ignore local names for now
+        uint32_t FuncCount = readULEB128(Ptr);
+        while (FuncCount--) {
+          uint32_t FuncIndex = readULEB128(Ptr);
+          uint32_t LocalCount = readULEB128(Ptr);
+          while (LocalCount--) {
+            uint32_t LocalIndex = readULEB128(Ptr);
+            StringRef Name = readString(Ptr);
+          }
+        }
+        break;
+      }
+      default:
+        Ptr += Size;
+        break;
+    }
+  }
+
+  assert(Ptr == End);
+  return Error::success();
+}
+
 Error WasmObjectFile::parseCustomSection(wasm::WasmSection &Sec,
                                          const uint8_t *Ptr, size_t Length) {
+  const uint8_t *End = Ptr + Length;
   Sec.Name = readString(Ptr);
+  if (Sec.Name == "name") {
+    if (Error Err = parseNameSection(Ptr, End))
+      return Err;
+  }
   return Error::success();
 }
 
 const uint8_t *WasmObjectFile::getPtr(size_t Offset) const {
   return reinterpret_cast<const uint8_t *>(getData().substr(Offset, 1).data());
 }
 
 const wasm::WasmObjectHeader &WasmObjectFile::getHeader() const {
   return Header;
 }
 
 void WasmObjectFile::moveSymbolNext(DataRefImpl &Symb) const {
-  llvm_unreachable("not yet implemented");
+  Symb.d.a++;
 }
 
 std::error_code WasmObjectFile::printSymbolName(raw_ostream &OS,
                                                 DataRefImpl Symb) const {
-  llvm_unreachable("not yet implemented");
-  return object_error::invalid_symbol_index;
+  OS << Symbols[Symb.d.a];
+  return std::error_code();
 }
 
 uint32_t WasmObjectFile::getSymbolFlags(DataRefImpl Symb) const {
-  llvm_unreachable("not yet implemented");
-  return 0;
+  return object::SymbolRef::SF_Global | SymbolRef::SF_Executable;
 }
 
 basic_symbol_iterator WasmObjectFile::symbol_begin() const {
-  return BasicSymbolRef(DataRefImpl(), this);
+  DataRefImpl Ref;
+  Ref.d.a = 0;
+  return BasicSymbolRef(Ref, this);
 }
 
 basic_symbol_iterator WasmObjectFile::symbol_end() const {
-  return BasicSymbolRef(DataRefImpl(), this);
+  DataRefImpl Ref;
+  Ref.d.a = Symbols.size();
+  return BasicSymbolRef(Ref, this);
 }
 
 Expected<StringRef> WasmObjectFile::getSymbolName(DataRefImpl Symb) const {
   llvm_unreachable("not yet implemented");
   return errorCodeToError(object_error::invalid_symbol_index);
 }
 
 Expected<uint64_t> WasmObjectFile::getSymbolAddress(DataRefImpl Symb) const {
-  llvm_unreachable("not yet implemented");
-  return errorCodeToError(object_error::invalid_symbol_index);
+  return (uint64_t)Symb.d.a;
 }
 
 uint64_t WasmObjectFile::getSymbolValueImpl(DataRefImpl Symb) const {
   llvm_unreachable("not yet implemented");
   return 0;
 }
 
 uint32_t WasmObjectFile::getSymbolAlignment(DataRefImpl Symb) const {

test/tools/llvm-nm/wasm/externalonly.txt

+# RUN: llvm-nm -g %p/Inputs/trivial.obj.wasm | FileCheck %s
+
+# CHECK: $func0
+# CHECK: $import

tools/llvm-nm/llvm-nm.cpp

 #include "llvm/IR/Module.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/Object/IRObjectFile.h"
 #include "llvm/Object/MachO.h"
 #include "llvm/Object/MachOUniversal.h"
 #include "llvm/Object/ObjectFile.h"
+#include "llvm/Object/Wasm.h"
 #include "llvm/Support/COFF.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Program.h"
return std::make_tuple(A.Name, A.Size, A.Address) <
          std::make_tuple(B.Name, B.Size, B.Address);
 }
 
 static char isSymbolList64Bit(SymbolicFile &Obj) {
   if (auto *IRObj = dyn_cast<IRObjectFile>(&Obj))
     return Triple(IRObj->getTargetTriple()).isArch64Bit();
   if (isa<COFFObjectFile>(Obj))
     return false;
+  if (isa<WasmObjectFile>(Obj))
+    return false;
   if (MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(&Obj))
     return MachO->is64Bit();
   return cast<ELFObjectFileBase>(Obj).getBytesInAddress() == 8;
 }
 
 static StringRef CurrentFilename;
 typedef std::vector<NMSymbol> SymbolListT;
 static SymbolListT SymbolList;
if (SegmentName == "__DATA" && SectionName == "__bss")
       return 'b';
     return 's';
   }
   }
 
   return '?';
 }
 
+static char getSymbolNMTypeChar(WasmObjectFile &Obj, basic_symbol_iterator I) {
+  uint32_t Flags = I->getFlags();
+  if (Flags & SymbolRef::SF_Executable)
+    return 't';
+  return 'd';
+}
+
 static char getSymbolNMTypeChar(IRObjectFile &Obj, basic_symbol_iterator I) {
   uint32_t Flags = I->getFlags();
   // FIXME: should we print 'b'? At the IR level we cannot be sure if this
   // will be in bss or not, but we could approximate.
   if (Flags & SymbolRef::SF_Executable)
     return 't';
   else if (Triple(Obj.getTargetTriple()).isOSDarwin() &&
            (Flags & SymbolRef::SF_Const))
static char getNMTypeChar(SymbolicFile &Obj, basic_symbol_iterator I) {
   if (Symflags & object::SymbolRef::SF_Absolute)
     Ret = 'a';
   else if (IRObjectFile *IR = dyn_cast<IRObjectFile>(&Obj))
     Ret = getSymbolNMTypeChar(*IR, I);
   else if (COFFObjectFile *COFF = dyn_cast<COFFObjectFile>(&Obj))
     Ret = getSymbolNMTypeChar(*COFF, I);
   else if (MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(&Obj))
     Ret = getSymbolNMTypeChar(*MachO, I);
+  else if (WasmObjectFile *Wasm = dyn_cast<WasmObjectFile>(&Obj))
+    Ret = getSymbolNMTypeChar(*Wasm, I);
   else
     Ret = getSymbolNMTypeChar(cast<ELFObjectFileBase>(Obj), I);
 
   if (Symflags & object::SymbolRef::SF_Global)
     Ret = toupper(Ret);
 
   return Ret;
 }