[WebAssembly] Add ObjectYAML support for wasm name section

[sbc100]

• remove debugging

[dschuff]

include/llvm/ObjectYAML/WasmYAML.h

130

The new name section format has subsections, each with a different type of name. So I'm not sure this is the best way to go in that direction, but I'm also not too familiar with yaml/obj either. Do you plan to add local names too?

[sbc100]

include/llvm/ObjectYAML/WasmYAML.h

130

Yes, I'm only doing enough to support the name section that the MC layer currently generates which is just Function names. I was planning on improving this later, but can do it sooner if you prefer. Otherwise I will add a TODO to make it clear.

[sbc100]

• Merge remote-tracking branch 'origin/master' into yaml_name_section
• add todo

[dschuff]

include/llvm/ObjectYAML/WasmYAML.h

130

Oh, I was looking at the lib/Object code and thinking that it supported the extensible names section but I misread it. Yeah this is consistent with what we have now, and we just need to update everything.

include/llvm/ObjectYAML/WasmYAML.h

 };
 
 struct DataSegment {
   uint32_t Index;
   wasm::WasmInitExpr Offset;
   yaml::BinaryRef Content;
 };
 
+struct NameEntry {
+  uint32_t Index;
+  StringRef Name;
+};
+
 struct Signature {
   Signature() : Form(wasm::WASM_TYPE_FUNC) {}
 
   uint32_t Index;
   SignatureForm Form;
   std::vector<ValueType> ParamTypes;
   ValueType ReturnType;
 };

 struct CustomSection : Section {
   CustomSection() : Section(wasm::WASM_SEC_CUSTOM) {}
   static bool classof(const Section *S) {
     return S->Type == wasm::WASM_SEC_CUSTOM;
   }
 
   StringRef Name;
   yaml::BinaryRef Payload;
+  std::vector<NameEntry> FunctionNames;
 };
 
 struct TypeSection : Section {
   TypeSection() : Section(wasm::WASM_SEC_TYPE) {}
   static bool classof(const Section *S) {
     return S->Type == wasm::WASM_SEC_TYPE;
   }
 

 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Export)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::ElemSegment)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Limits)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::DataSegment)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Global)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Function)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::LocalDecl)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Relocation)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::NameEntry)
 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(uint32_t)
 
 namespace llvm {
 namespace yaml {
 
 template <> struct MappingTraits<WasmYAML::FileHeader> {
   static void mapping(IO &IO, WasmYAML::FileHeader &FileHdr);
 };

 template <> struct MappingTraits<WasmYAML::Function> {
   static void mapping(IO &IO, WasmYAML::Function &Function);
 };
 
 template <> struct MappingTraits<WasmYAML::Relocation> {
   static void mapping(IO &IO, WasmYAML::Relocation &Relocation);
 };
 
+template <> struct MappingTraits<WasmYAML::NameEntry> {
+  static void mapping(IO &IO, WasmYAML::NameEntry &NameEntry);
+};
+
 template <> struct MappingTraits<WasmYAML::LocalDecl> {
   static void mapping(IO &IO, WasmYAML::LocalDecl &LocalDecl);
 };
 
 template <> struct MappingTraits<wasm::WasmInitExpr> {
   static void mapping(IO &IO, wasm::WasmInitExpr &Expr);
 };
 

lib/ObjectYAML/WasmYAML.cpp

 static void commonSectionMapping(IO &IO, WasmYAML::Section &Section) {
   IO.mapRequired("Type", Section.Type);
   IO.mapOptional("Relocations", Section.Relocations);
 }
 
 static void sectionMapping(IO &IO, WasmYAML::CustomSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapRequired("Name", Section.Name);
+  if (Section.Name == "name") {
+    IO.mapOptional("FunctionNames", Section.FunctionNames);
+  } else {
     IO.mapRequired("Payload", Section.Payload);
   }
+}
 
 static void sectionMapping(IO &IO, WasmYAML::TypeSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapOptional("Signatures", Section.Signatures);
 }
 
 static void sectionMapping(IO &IO, WasmYAML::ImportSection &Section) {
   commonSectionMapping(IO, Section);

 void MappingTraits<WasmYAML::Relocation>::mapping(
     IO &IO, WasmYAML::Relocation &Relocation) {
   IO.mapRequired("Type", Relocation.Type);
   IO.mapRequired("Index", Relocation.Index);
   IO.mapRequired("Offset", Relocation.Offset);
   IO.mapOptional("Addend", Relocation.Addend, 0);
 }
 
+void MappingTraits<WasmYAML::NameEntry>::mapping(
+    IO &IO, WasmYAML::NameEntry &NameEntry) {
+  IO.mapRequired("Index", NameEntry.Index);
+  IO.mapRequired("Name", NameEntry.Name);
+}
+
 void MappingTraits<WasmYAML::LocalDecl>::mapping(
     IO &IO, WasmYAML::LocalDecl &LocalDecl) {
   IO.mapRequired("Type", LocalDecl.Type);
   IO.mapRequired("Count", LocalDecl.Count);
 }
 
 void MappingTraits<WasmYAML::Limits>::mapping(IO &IO,
                                               WasmYAML::Limits &Limits) {

test/ObjectYAML/wasm/name_section.yaml

+# RUN: yaml2obj %s | obj2yaml | FileCheck %s
+--- !WASM
+FileHeader:
+  Version:         0x00000001
+Sections:
+  - Type:            TYPE
+    Signatures:
+      - ReturnType:      I32
+        ParamTypes:
+          - I32
+  - Type:            IMPORT
+    Imports:
+      - Module:          foo
+        Field:           a
+        Kind:            FUNCTION
+        SigIndex:        0
+      - Module:          foo
+        Field:           b
+        Kind:            FUNCTION
+        SigIndex:        0
+      - Module:          foo
+        Field:           c
+        Kind:            FUNCTION
+        SigIndex:        0
+  - Type:            CUSTOM
+    Name:            name
+    FunctionNames:
+      - Index:         1
+        Name:          foo
+      - Index:         0
+        Name:          bar
+...
+# CHECK:  - Type:            CUSTOM
+# CHECK-NEXT:    Name:            name
+# CHECK-NEXT:    FunctionNames:
+# CHECK-NEXT:      - Index:         1
+# CHECK-NEXT:        Name:          foo
+# CHECK-NEXT:      - Index:         0
+# CHECK-NEXT:        Name:          bar
+# CHECK: ...

tools/obj2yaml/wasm2yaml.cpp

for (const auto &Sec : Obj.sections()) {
     case wasm::WASM_SEC_CUSTOM: {
       if (WasmSec.Name.startswith("reloc.")) {
         // Relocations are attached the sections they apply to rather than
         // being represented as a custom section in the YAML output.
         continue;
       }
       auto CustomSec = make_unique<WasmYAML::CustomSection>();
       CustomSec->Name = WasmSec.Name;
+      if (CustomSec->Name == "name") {
+        for (const object::SymbolRef& Sym: Obj.symbols()) {
+          uint32_t Flags = Sym.getFlags();
+          // Skip over symbols that come from imports or exports
+          if (Flags &
+              (object::SymbolRef::SF_Global | object::SymbolRef::SF_Undefined))
+            continue;
+          Expected<StringRef> NameOrError = Sym.getName();
+          if (!NameOrError)
+            continue;
+          WasmYAML::NameEntry NameEntry;
+          NameEntry.Name = *NameOrError;
+          NameEntry.Index = Sym.getValue();
+          CustomSec->FunctionNames.push_back(NameEntry);
+        }
+      } else {
         CustomSec->Payload = yaml::BinaryRef(WasmSec.Content);
+      }
       S = std::move(CustomSec);
       break;
     }
     case wasm::WASM_SEC_TYPE: {
       auto TypeSec = make_unique<WasmYAML::TypeSection>();
       uint32_t Index = 0;
       for (const auto &FunctionSig : Obj.types()) {
         WasmYAML::Signature Sig;

tools/yaml2obj/yaml2wasm.cpp

 
 /// This parses a yaml stream that represents a Wasm object file.
 /// See docs/yaml2obj for the yaml scheema.
 class WasmWriter {
 public:
   WasmWriter(WasmYAML::Object &Obj) : Obj(Obj) {}
   int writeWasm(raw_ostream &OS);
   int writeRelocSection(raw_ostream &OS, WasmYAML::Section &Sec);
+  int writeNameSection(raw_ostream &OS, WasmYAML::CustomSection &Section);
+
   int writeSectionContent(raw_ostream &OS, WasmYAML::CustomSection &Section);
   int writeSectionContent(raw_ostream &OS, WasmYAML::TypeSection &Section);
   int writeSectionContent(raw_ostream &OS, WasmYAML::ImportSection &Section);
   int writeSectionContent(raw_ostream &OS, WasmYAML::FunctionSection &Section);
   int writeSectionContent(raw_ostream &OS, WasmYAML::TableSection &Section);
   int writeSectionContent(raw_ostream &OS, WasmYAML::MemorySection &Section);
   int writeSectionContent(raw_ostream &OS, WasmYAML::GlobalSection &Section);
   int writeSectionContent(raw_ostream &OS, WasmYAML::ExportSection &Section);

 
 static int writeUint8(raw_ostream &OS, uint8_t Value) {
   char Data[sizeof(Value)];
   memcpy(Data, &Value, sizeof(Data));
   OS.write(Data, sizeof(Data));
   return 0;
 }
 
-static int writeStringRef(StringRef &Str, raw_ostream &OS) {
+static int writeStringRef(const StringRef &Str, raw_ostream &OS) {
   encodeULEB128(Str.size(), OS);
   OS << Str;
   return 0;
 }
 
-static int writeLimits(WasmYAML::Limits Lim, raw_ostream &OS) {
+static int writeLimits(const WasmYAML::Limits &Lim, raw_ostream &OS) {
   encodeULEB128(Lim.Flags, OS);
   encodeULEB128(Lim.Initial, OS);
   if (Lim.Flags & wasm::WASM_LIMITS_FLAG_HAS_MAX)
     encodeULEB128(Lim.Maximum, OS);
   return 0;
 }
 
-static int writeInitExpr(wasm::WasmInitExpr InitExpr, raw_ostream &OS) {
+static int writeInitExpr(const wasm::WasmInitExpr &InitExpr, raw_ostream &OS) {
   writeUint8(OS, InitExpr.Opcode);
   switch (InitExpr.Opcode) {
   case wasm::WASM_OPCODE_I32_CONST:
     encodeSLEB128(InitExpr.Value.Int32, OS);
     break;
   case wasm::WASM_OPCODE_I64_CONST:
     encodeSLEB128(InitExpr.Value.Int64, OS);
     break;
static int writeInitExpr(const wasm::WasmInitExpr &InitExpr, raw_ostream &OS) {
   default:
     errs() << "Unknown opcode in init_expr: " << InitExpr.Opcode;
     return 1;
   }
   writeUint8(OS, wasm::WASM_OPCODE_END);
   return 0;
 }
 
+int WasmWriter::writeNameSection(raw_ostream &OS,
+                                 WasmYAML::CustomSection &Section) {
+  writeStringRef(Section.Name, OS);
+  if (Section.FunctionNames.size()) {
+    encodeULEB128(wasm::WASM_NAMES_FUNCTION, OS);
+
+    std::string OutString;
+    raw_string_ostream StringStream(OutString);
+
+    encodeULEB128(Section.FunctionNames.size(), StringStream);
+    for (const WasmYAML::NameEntry &NameEntry : Section.FunctionNames) {
+      encodeULEB128(NameEntry.Index, StringStream);
+      writeStringRef(NameEntry.Name, StringStream);
+    }
+
+    StringStream.flush();
+    encodeULEB128(OutString.size(), OS);
+    OS << OutString;
+  }
+  return 0;
+}
+
 int WasmWriter::writeSectionContent(raw_ostream &OS,
                                     WasmYAML::CustomSection &Section) {
-  // writeStringRef(Section.Name, OS);
-  // encodeULEB128(Section.Payload.binary_size(), OS);
+  if (Section.Name == "name") {
+    writeNameSection(OS, Section);
+  } else {
     Section.Payload.writeAsBinary(OS);
+  }
   return 0;
 }
 
 int WasmWriter::writeSectionContent(raw_ostream &OS,
                                     WasmYAML::TypeSection &Section) {
   encodeULEB128(Section.Signatures.size(), OS);
-  for (auto &Sig : Section.Signatures) {
+  for (const WasmYAML::Signature &Sig : Section.Signatures) {
     encodeSLEB128(Sig.Form, OS);
     encodeULEB128(Sig.ParamTypes.size(), OS);
     for (auto ParamType : Sig.ParamTypes)
       encodeSLEB128(ParamType, OS);
     if (Sig.ReturnType == wasm::WASM_TYPE_NORESULT) {
       encodeSLEB128(0, OS);
     } else {
       encodeULEB128(1, OS);
       encodeSLEB128(Sig.ReturnType, OS);
     }
   }
   return 0;
 }
 
 int WasmWriter::writeSectionContent(raw_ostream &OS,
                                     WasmYAML::ImportSection &Section) {
   encodeULEB128(Section.Imports.size(), OS);
-  for (auto &Import : Section.Imports) {
+  for (const WasmYAML::Import &Import : Section.Imports) {
     writeStringRef(Import.Module, OS);
     writeStringRef(Import.Field, OS);
     encodeULEB128(Import.Kind, OS);
     switch (Import.Kind) {
     case wasm::WASM_EXTERNAL_FUNCTION:
       encodeULEB128(Import.SigIndex, OS);
       break;
     case wasm::WASM_EXTERNAL_GLOBAL:
for (uint32_t FuncType : Section.FunctionTypes) {
     encodeULEB128(FuncType, OS);
   }
   return 0;
 }
 
 int WasmWriter::writeSectionContent(raw_ostream &OS,
                                     WasmYAML::ExportSection &Section) {
   encodeULEB128(Section.Exports.size(), OS);
-  for (auto &Export : Section.Exports) {
+  for (const WasmYAML::Export &Export : Section.Exports) {
     writeStringRef(Export.Name, OS);
     encodeULEB128(Export.Kind, OS);
     encodeULEB128(Export.Index, OS);
   }
   return 0;
 }
 
 int WasmWriter::writeSectionContent(raw_ostream &OS,
for (auto &Table : Section.Tables) {
     writeLimits(Table.TableLimits, OS);
   }
   return 0;
 }
 
 int WasmWriter::writeSectionContent(raw_ostream &OS,
                                     WasmYAML::MemorySection &Section) {
   encodeULEB128(Section.Memories.size(), OS);
-  for (auto &Mem : Section.Memories) {
+  for (const WasmYAML::Limits &Mem : Section.Memories) {
     writeLimits(Mem, OS);
   }
   return 0;
 }
 
 int WasmWriter::writeSectionContent(raw_ostream &OS,
                                     WasmYAML::GlobalSection &Section) {
   encodeULEB128(Section.Globals.size(), OS);