[WebAssembly] Allow for the creation of user-defined custom sections

[sbc100]

Summary

This patch adds a way for users to create their own custom sections to
be added to wasm files. At the LLVM IR layer, they are defined through
the "wasm.custom_sections" named metadata. The expected use case for
this is bindings generators such as wasm-bindgen.

Patch by Dan Gohman

[sbc100]

clang-format

[sbc100]

cleanup

[sunfish]

Looks good to me. Thanks!

llvm/trunk/lib/MC/WasmObjectWriter.cpp

Out << "Off=" << Offset << ", Sym=" << *Symbol << ", Addend=" << Addend
         << ", FixupSection=" << FixupSection->getSectionName();
   }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   LLVM_DUMP_METHOD void dump() const { print(dbgs()); }
 #endif
 };
 
+struct WasmCustomSection {
+  StringRef Name;
+  const SmallVectorImpl<char> &Contents;
+
+  WasmCustomSection(StringRef Name, const SmallVectorImpl<char> &Contents)
+      : Name(Name), Contents(Contents) {}
+};
+
 #if !defined(NDEBUG)
 raw_ostream &operator<<(raw_ostream &OS, const WasmRelocationEntry &Rel) {
   Rel.print(OS);
   return OS;
 }
 #endif
 
 class WasmObjectWriter : public MCObjectWriter {
class WasmObjectWriter : public MCObjectWriter {
   // Maps data symbols to the Wasm segment and offset/size with the segment.
   DenseMap<const MCSymbolWasm *, wasm::WasmDataReference> DataLocations;
 
   DenseMap<WasmFunctionType, int32_t, WasmFunctionTypeDenseMapInfo>
       FunctionTypeIndices;
   SmallVector<WasmFunctionType, 4> FunctionTypes;
   SmallVector<WasmGlobal, 4> Globals;
   SmallVector<WasmDataSegment, 4> DataSegments;
+  std::vector<WasmCustomSection> CustomSections;
   unsigned NumFunctionImports = 0;
   unsigned NumGlobalImports = 0;
 
   // TargetObjectWriter wrappers.
   bool is64Bit() const { return TargetObjectWriter->is64Bit(); }
   unsigned getRelocType(const MCValue &Target, const MCFixup &Fixup) const {
     return TargetObjectWriter->getRelocType(Target, Fixup);
   }
void writeCodeSection(const MCAssembler &Asm, const MCAsmLayout &Layout,
                         ArrayRef<WasmFunction> Functions);
   void writeDataSection();
   void writeCodeRelocSection();
   void writeDataRelocSection();
   void writeLinkingMetaDataSection(
       ArrayRef<wasm::WasmSymbolInfo> SymbolInfos,
       ArrayRef<std::pair<uint16_t, uint32_t>> InitFuncs,
       const std::map<StringRef, std::vector<WasmComdatEntry>> &Comdats);
+  void writeUserCustomSections(ArrayRef<WasmCustomSection> CustomSections);
 
   uint32_t getProvisionalValue(const WasmRelocationEntry &RelEntry);
   void applyRelocations(ArrayRef<WasmRelocationEntry> Relocations,
                         uint64_t ContentsOffset);
 
   void writeRelocations(ArrayRef<WasmRelocationEntry> Relocations);
   uint32_t getRelocationIndexValue(const WasmRelocationEntry &RelEntry);
   uint32_t getFunctionType(const MCSymbolWasm& Symbol);
void WasmObjectWriter::startSection(SectionBookkeeping &Section,
   encodeULEB128(UINT32_MAX, getStream());
 
   // The position where the section starts, for measuring its size.
   Section.ContentsOffset = getStream().tell();
 
   // Custom sections in wasm also have a string identifier.
   if (SectionId == wasm::WASM_SEC_CUSTOM) {
     assert(Name);
-    writeString(StringRef(Name));
+    writeString(Name);
   }
 }
 
 // Now that the section is complete and we know how big it is, patch up the
 // section size field at the start of the section.
 void WasmObjectWriter::endSection(SectionBookkeeping &Section) {
   uint64_t Size = getStream().tell() - Section.ContentsOffset;
   if (uint32_t(Size) != Size)
for (const auto &C : Comdats) {
       }
     }
     endSection(SubSection);
   }
 
   endSection(Section);
 }
 
+void WasmObjectWriter::writeUserCustomSections(
+    ArrayRef<WasmCustomSection> CustomSections) {
+  for (const auto &CustomSection : CustomSections) {
+    SectionBookkeeping Section;
+    startSection(Section, wasm::WASM_SEC_CUSTOM,
+                 CustomSection.Name.str().c_str());
+    writeBytes(CustomSection.Contents);
+    endSection(Section);
+  }
+}
+
 uint32_t WasmObjectWriter::getFunctionType(const MCSymbolWasm& Symbol) {
   assert(Symbol.isFunction());
   assert(TypeIndices.count(&Symbol));
   return TypeIndices[&Symbol];
 }
 
 uint32_t WasmObjectWriter::registerFunctionType(const MCSymbolWasm& Symbol) {
   assert(Symbol.isFunction());
if (!WS.isDefined() && !WS.isComdat()) {
         WasmIndices[&WS] = NumGlobalImports++;
       }
     }
   }
 
   // Populate DataSegments, which must be done before populating DataLocations.
   for (MCSection &Sec : Asm) {
     auto &Section = static_cast<MCSectionWasm &>(Sec);
+
+    if (cast<MCSectionWasm>(Sec).getSectionName().startswith(
+            ".custom_section.")) {
+      if (Section.getFragmentList().empty())
+        continue;
+      if (Section.getFragmentList().size() != 1)
+        report_fatal_error(
+            "only one .custom_section section fragment supported");
+      const MCFragment &Frag = *Section.begin();
+      if (Frag.hasInstructions() || Frag.getKind() != MCFragment::FT_Data)
+        report_fatal_error("only data supported in .custom_section section");
+      const auto &DataFrag = cast<MCDataFragment>(Frag);
+      if (!DataFrag.getFixups().empty())
+        report_fatal_error("fixups not supported in .custom_section section");
+      StringRef UserName = Section.getSectionName().substr(16);
+      const SmallVectorImpl<char> &Contents = DataFrag.getContents();
+      CustomSections.push_back(WasmCustomSection(UserName, Contents));
+      continue;
+    }
+
     if (!Section.isWasmData())
       continue;
 
     // .init_array sections are handled specially elsewhere.
     if (cast<MCSectionWasm>(Sec).getSectionName().startswith(".init_array"))
       continue;
 
     uint32_t SegmentIndex = DataSegments.size();
void WasmObjectWriter::writeObject(MCAssembler &Asm,
   writeFunctionSection(Functions);
   // Skip the "table" section; we import the table instead.
   // Skip the "memory" section; we import the memory instead.
   writeGlobalSection();
   writeExportSection(Exports);
   writeElemSection(TableElems);
   writeCodeSection(Asm, Layout, Functions);
   writeDataSection();
+  writeUserCustomSections(CustomSections);
   writeLinkingMetaDataSection(SymbolInfos, InitFuncs, Comdats);
   writeCodeRelocSection();
   writeDataRelocSection();
 
   // TODO: Translate the .comment section to the output.
   // TODO: Translate debug sections to the output.
 }
 
 std::unique_ptr<MCObjectWriter>
 llvm::createWasmObjectWriter(std::unique_ptr<MCWasmObjectTargetWriter> MOTW,
                              raw_pwrite_stream &OS) {
   return llvm::make_unique<WasmObjectWriter>(std::move(MOTW), OS);
 }

llvm/trunk/lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp

 #include "llvm/CodeGen/Analysis.h"
 #include "llvm/CodeGen/AsmPrinter.h"
 #include "llvm/CodeGen/MachineConstantPool.h"
 #include "llvm/CodeGen/MachineInstr.h"
 #include "llvm/CodeGen/MachineModuleInfoImpls.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/MC/MCContext.h"
+#include "llvm/MC/MCSectionWasm.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSymbol.h"
-#include "llvm/MC/MCSymbolWasm.h"
 #include "llvm/MC/MCSymbolELF.h"
+#include "llvm/MC/MCSymbolWasm.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/raw_ostream.h"
 using namespace llvm;
 
 #define DEBUG_TYPE "asm-printer"
 
 //===----------------------------------------------------------------------===//
if (!G.hasInitializer() && G.hasExternalLinkage()) {
         uint16_t Size = M.getDataLayout().getTypeAllocSize(G.getValueType());
         if (TM.getTargetTriple().isOSBinFormatELF())
           getTargetStreamer()->emitGlobalImport(G.getGlobalIdentifier());
         OutStreamer->emitELFSize(getSymbol(&G),
                                  MCConstantExpr::create(Size, OutContext));
       }
     }
   }
+
+  if (const NamedMDNode *Named = M.getNamedMetadata("wasm.custom_sections")) {
+    for (const Metadata *MD : Named->operands()) {
+      const MDTuple *Tuple = dyn_cast<MDTuple>(MD);
+      if (!Tuple || Tuple->getNumOperands() != 2)
+        continue;
+      const MDString *Name = dyn_cast<MDString>(Tuple->getOperand(0));
+      const MDString *Contents = dyn_cast<MDString>(Tuple->getOperand(1));
+      if (!Name || !Contents)
+        continue;
+
+      OutStreamer->PushSection();
+      std::string SectionName = (".custom_section." + Name->getString()).str();
+      MCSectionWasm *mySection =
+          OutContext.getWasmSection(SectionName, SectionKind::getMetadata());
+      OutStreamer->SwitchSection(mySection);
+      OutStreamer->EmitBytes(Contents->getString());
+      OutStreamer->PopSection();
+    }
+  }
 }
 
 void WebAssemblyAsmPrinter::EmitConstantPool() {
   assert(MF->getConstantPool()->getConstants().empty() &&
          "WebAssembly disables constant pools");
 }
 
 void WebAssemblyAsmPrinter::EmitJumpTableInfo() {

llvm/trunk/test/CodeGen/WebAssembly/custom-sections.ll

+; RUN: llc < %s -asm-verbose=false | FileCheck %s
+
+; Test the mechanism for defining user custom sections.
+
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-unknown-wasm"
+
+!0 = !{ !"red", !"foo" }
+!1 = !{ !"green", !"bar" }
+!2 = !{ !"green", !"qux" }
+!wasm.custom_sections = !{ !0, !1, !2 }
+
+; CHECK:      .section  .custom_section.red,"",@
+; CHECK-NEXT: .ascii  "foo"
+
+; CHECK:      .section  .custom_section.green,"",@
+; CHECK-NEXT: .ascii  "bar"
+
+; CHECK:      .section  .custom_section.green,"",@
+; CHECK-NEXT: .ascii  "qux"

llvm/trunk/test/MC/WebAssembly/custom-sections.ll

+; RUN: llc -filetype=obj %s -o - | llvm-readobj -s | FileCheck %s
+
+; Test the mechanism for defining user custom sections.
+
+target triple = "wasm32-unknown-unknown-wasm"
+
+!0 = !{ !"red", !"foo" }
+!1 = !{ !"green", !"bar" }
+!2 = !{ !"green", !"qux" }
+!wasm.custom_sections = !{ !0, !1, !2 }
+
+; CHECK:  Section {
+; CHECK:    Type: CUSTOM (0x0)
+; CHECK:    Size: 7
+; CHECK:    Offset: 72
+; CHECK:    Name: red
+; CHECK:  }
+; CHECK:  Section {
+; CHECK:    Type: CUSTOM (0x0)
+; CHECK:    Size: 12
+; CHECK:    Offset: 85
+; CHECK:    Name: green
+; CHECK:  }