[WebAssembly] Emit .llvmcmd and .llvmbc as custom sections

[sbc100]

Summary

Fixes: https://bugs.llvm.org/show_bug.cgi?id=45362

[alexcrichton]

Seems reasonable to me! In my testing though if these existed as custom sections they'd still make their way to the final binary through LLD, so could LLD skip over these sectiosn by default?

[sbc100]

In D77115#1952536, @alexcrichton wrote:

Seems reasonable to me! In my testing though if these existed as custom sections they'd still make their way to the final binary through LLD, so could LLD skip over these sectiosn by default?

I'll take a look at that.

Can you confirm that you tools are able to find and use the sections in the same way they do for ELF files?

[sbc100]

strip in linker

[alexcrichton]

At least from my POV looks good :)

Thanks for the quick patch!

Should this link also be updated to handle the special section names?

[sbc100]

Avoid resuing IsUsedInReloc

clang/test/Driver/embed-bitcode-wasm.c

+// REQUIRES: webassembly-registered-target
+
+// RUN: %clang -c -target wasm32-unknown-unknown %s -fembed-bitcode -o %t.o
+// RUN: llvm-readobj -S %t.o | FileCheck --check-prefix=CHECK %s
+// CHECK:   Name: .llvmbc
+// CHECK:   Name: .llvmcmd

clang/test/Driver/fembed-bitcode.c

 // CHECK-AARCH64: "-target-abi"
 // CHECK-AARCH64: "darwinpcs"
 // CHECK-AARCH64-NOT: "-fdebug-compilation-dir
 
 // RUN: %clang -target hexagon-unknown-elf -ffixed-r19 -fembed-bitcode=all -c %s -### 2>&1 \
 // RUN:     | FileCheck --check-prefix=CHECK-HEXAGON %s
 // CHECK-HEXAGON: "-target-feature"
 // CHECK-HEXAGON: "+reserved-r19"
+//
+// RUN: %clang -target wasm32-unknown-unknown -fembed-bitcode=all -pthread -c %s -o /dev/null -### 2>&1 \
+// RUN:     | FileCheck --check-prefix=CHECK-WASM %s
+
+// CHECK-WASM: "-cc1"
+// CHECK-WASM: "-target-feature" "+atomics"
+
+// CHECK-WASM: "-cc1"
+// CHECK-WASM: "-target-feature" "+atomics"

lld/wasm/Writer.cpp

 
 void Writer::calculateCustomSections() {
   log("calculateCustomSections");
   bool stripDebug = config->stripDebug || config->stripAll;
   for (ObjFile *file : symtab->objectFiles) {
     for (InputSection *section : file->customSections) {
       StringRef name = section->getName();
       // These custom sections are known the linker and synthesized rather than
-      // blindly copied
+      // blindly copied.
       if (name == "linking" || name == "name" || name == "producers" ||
           name == "target_features" || name.startswith("reloc."))
         continue;
-      // .. or it is a debug section
+      // These custom sections are generated by `clang -fembed-bitcode`.
+      // These are used by the rust toolchain to ship LTO data along with
+      // compiled object code, but they don't want this included in the linker
+      // output.
+      if (name == ".llvmbc" || name == ".llvmcmd")
+        continue;
+      // Strip debug section in that option was specified.
       if (stripDebug && name.startswith(".debug_"))
         continue;
+      // Otherwise include custom sections by default and concatenate their
+      // contents.
       customSectionMapping[name].push_back(section);
     }
   }
 }
 
 void Writer::createCustomSections() {
   log("createCustomSections");
   for (auto &pair : customSectionMapping) {

llvm/include/llvm/MC/MCSymbolWasm.h

 
 namespace llvm {
 
 class MCSymbolWasm : public MCSymbol {
   wasm::WasmSymbolType Type = wasm::WASM_SYMBOL_TYPE_DATA;
   bool IsWeak = false;
   bool IsHidden = false;
   bool IsComdat = false;
+  mutable bool IsUsedInInitArray = false;
   mutable bool IsUsedInGOT = false;
   Optional<StringRef> ImportModule;
   Optional<StringRef> ImportName;
   Optional<StringRef> ExportName;
   wasm::WasmSignature *Signature = nullptr;
   Optional<wasm::WasmGlobalType> GlobalType;
   Optional<wasm::WasmEventType> EventType;
 
public:
 
   bool hasExportName() const { return ExportName.hasValue(); }
   StringRef getExportName() const { return ExportName.getValue(); }
   void setExportName(StringRef Name) { ExportName = Name; }
 
   void setUsedInGOT() const { IsUsedInGOT = true; }
   bool isUsedInGOT() const { return IsUsedInGOT; }
 
+  void setUsedInInitArray() const { IsUsedInInitArray = true; }
+  bool isUsedInInitArray() const { return IsUsedInInitArray; }
+
   const wasm::WasmSignature *getSignature() const { return Signature; }
   void setSignature(wasm::WasmSignature *Sig) { Signature = Sig; }
 
   const wasm::WasmGlobalType &getGlobalType() const {
     assert(GlobalType.hasValue());
     return GlobalType.getValue();
   }
   void setGlobalType(wasm::WasmGlobalType GT) { GlobalType = GT; }

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

MCSection *TargetLoweringObjectFileWasm::getExplicitSectionGlobal(
   // We don't support explict section names for functions in the wasm object
   // format.  Each function has to be in its own unique section.
   if (isa<Function>(GO)) {
     return SelectSectionForGlobal(GO, Kind, TM);
   }
 
   StringRef Name = GO->getSection();
 
+  // Certain data sections we treat as named custom sections rather than
+  // segments within the data section.
+  // This could be avoided if all data segements (the wasm sense) were
+  // represented as thier own sections (in the llvm sense).
+  // TODO(sbc): https://github.com/WebAssembly/tool-conventions/issues/138
+  if (Name == ".llvmcmd" || Name == ".llvmbc")
+    Kind = SectionKind::getMetadata();
+
   StringRef Group = "";
   if (const Comdat *C = getWasmComdat(GO)) {
     Group = C->getName();
   }
 
   MCSectionWasm* Section =
       getContext().getWasmSection(Name, Kind, Group,
                                   MCContext::GenericSectionID);

llvm/lib/MC/WasmObjectWriter.cpp

void WasmObjectWriter::recordRelocation(MCAssembler &Asm,
   assert(!(Asm.getBackend().getFixupKindInfo(Fixup.getKind()).Flags &
            MCFixupKindInfo::FKF_IsPCRel));
 
   const auto &FixupSection = cast<MCSectionWasm>(*Fragment->getParent());
   uint64_t C = Target.getConstant();
   uint64_t FixupOffset = Layout.getFragmentOffset(Fragment) + Fixup.getOffset();
   MCContext &Ctx = Asm.getContext();
 
-  // The .init_array isn't translated as data, so don't do relocations in it.
-  if (FixupSection.getSectionName().startswith(".init_array"))
-    return;
-
   if (const MCSymbolRefExpr *RefB = Target.getSymB()) {
     // To get here the A - B expression must have failed evaluateAsRelocatable.
     // This means either A or B must be undefined and in WebAssembly we can't
     // support either of those cases.
     const auto &SymB = cast<MCSymbolWasm>(RefB->getSymbol());
     Ctx.reportError(
         Fixup.getLoc(),
         Twine("symbol '") + SymB.getName() +
             "': unsupported subtraction expression used in relocation.");
     return;
   }
 
   // We either rejected the fixup or folded B into C at this point.
   const MCSymbolRefExpr *RefA = Target.getSymA();
   const auto *SymA = cast<MCSymbolWasm>(&RefA->getSymbol());
 
+  // The .init_array isn't translated as data, so don't do relocations in it.
+  if (FixupSection.getSectionName().startswith(".init_array")) {
+    SymA->setUsedInInitArray();
+    return;
+  }
+
   if (SymA->isVariable()) {
     const MCExpr *Expr = SymA->getVariableValue();
     const auto *Inner = cast<MCSymbolRefExpr>(Expr);
     if (Inner->getKind() == MCSymbolRefExpr::VK_WEAKREF)
       llvm_unreachable("weakref used in reloc not yet implemented");
   }
 
   // Put any constant offset in an addend. Offsets can be negative, and
void WasmObjectWriter::registerEventType(const MCSymbolWasm &Symbol) {
   TypeIndices[&Symbol] = Pair.first->second;
 
   LLVM_DEBUG(dbgs() << "registerEventType: " << Symbol << " new:" << Pair.second
                     << "\n");
   LLVM_DEBUG(dbgs() << "  -> type index: " << Pair.first->second << "\n");
 }
 
 static bool isInSymtab(const MCSymbolWasm &Sym) {
-  if (Sym.isUsedInReloc())
+  if (Sym.isUsedInReloc() || Sym.isUsedInInitArray())
     return true;
 
   if (Sym.isComdat() && !Sym.isDefined())
     return false;
 
-  if (Sym.isTemporary() && Sym.getName().empty())
-    return false;
-
-  if (Sym.isTemporary() && Sym.isData() && !Sym.getSize())
+  if (Sym.isTemporary())
     return false;
 
   if (Sym.isSection())
     return false;
 
   return true;
 }
 
for (const MCFixup &Fixup : DataFrag.getFixups()) {
       assert(Fixup.getKind() ==
              MCFixup::getKindForSize(is64Bit() ? 8 : 4, false));
       const MCExpr *Expr = Fixup.getValue();
       auto *SymRef = dyn_cast<MCSymbolRefExpr>(Expr);
       if (!SymRef)
         report_fatal_error("fixups in .init_array should be symbol references");
       const auto &TargetSym = cast<const MCSymbolWasm>(SymRef->getSymbol());
       if (TargetSym.getIndex() == InvalidIndex)
-        report_fatal_error("symbols in .init_array should exist in symbtab");
+        report_fatal_error("symbols in .init_array should exist in symtab");
       if (!TargetSym.isFunction())
         report_fatal_error("symbols in .init_array should be for functions");
       InitFuncs.push_back(
           std::make_pair(Priority, TargetSym.getIndex()));
     }
   }
 
   // Write out the Wasm header.