[WebAssembly] MC: Support for static init and fini sections

[sbc100]

• add test

[rnk]

llvm/trunk/test/MC/WebAssembly/init-fini-array.ll

87–94 ↗

(On Diff #117497)

These test expectations didn't match what obj2yaml prints, so I updated them in rL314823

include/llvm/MC/MCSectionWasm.h

 //===- MCSectionWasm.h - Wasm Machine Code Sections -------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares the MCSectionWasm class.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_MC_MCSECTIONWASM_H
 #define LLVM_MC_MCSECTIONWASM_H
 
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/MC/MCSection.h"
 #include "llvm/MC/MCSymbolWasm.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace llvm {
 
private:
 
   unsigned UniqueID;
 
   const MCSymbolWasm *Group;
 
   // The offset of the MC function/data section in the wasm code/data section.
   // For data relocations the offset is relative to start of the data payload
   // itself and does not include the size of the section header.
-  uint64_t SectionOffset;
+  Optional<uint64_t> SectionOffset;
 
   friend class MCContext;
   MCSectionWasm(StringRef Section, unsigned type, SectionKind K,
                 const MCSymbolWasm *group, unsigned UniqueID, MCSymbol *Begin)
       : MCSection(SV_Wasm, K, Begin), SectionName(Section), Type(type),
-        UniqueID(UniqueID), Group(group), SectionOffset(0) {}
+        UniqueID(UniqueID), Group(group) {}
 
   void setSectionName(StringRef Name) { SectionName = Name; }
 
 public:
   ~MCSectionWasm();
 
   /// Decides whether a '.section' directive should be printed before the
   /// section name
   bool ShouldOmitSectionDirective(StringRef Name, const MCAsmInfo &MAI) const;
 
   StringRef getSectionName() const { return SectionName; }
   unsigned getType() const { return Type; }
   const MCSymbolWasm *getGroup() const { return Group; }
 
   void PrintSwitchToSection(const MCAsmInfo &MAI, const Triple &T,
                             raw_ostream &OS,
                             const MCExpr *Subsection) const override;
   bool UseCodeAlign() const override;
   bool isVirtualSection() const override;
 
   bool isUnique() const { return UniqueID != ~0U; }
   unsigned getUniqueID() const { return UniqueID; }
 
-  uint64_t getSectionOffset() const { return SectionOffset; }
+  uint64_t getSectionOffset() const { return SectionOffset.getValue(); }
   void setSectionOffset(uint64_t Offset) { SectionOffset = Offset; }
 
   static bool classof(const MCSection *S) { return S->getVariant() == SV_Wasm; }
 };
 
 } // end namespace llvm
 
 #endif

lib/CodeGen/TargetLoweringObjectFileImpl.cpp

if (LHS->getType()->getPointerAddressSpace() != 0 ||
     return nullptr;
 
   return MCBinaryExpr::createSub(
       MCSymbolRefExpr::create(TM.getSymbol(LHS), MCSymbolRefExpr::VK_None,
                               getContext()),
       MCSymbolRefExpr::create(TM.getSymbol(RHS), getContext()), getContext());
 }
 
-void
-TargetLoweringObjectFileWasm::InitializeWasm() {
-  // TODO: Initialize StaticCtorSection and StaticDtorSection.
+void TargetLoweringObjectFileWasm::InitializeWasm() {
+  StaticCtorSection = getContext().getWasmSection(".init_array", 0);
+  StaticDtorSection = getContext().getWasmSection(".fini_array", 0);
 }

lib/MC/WasmObjectWriter.cpp

case wasm::R_WEBASSEMBLY_MEMORY_ADDR_I32:
       return true;
     default:
       return false;
     }
   }
 
   void print(raw_ostream &Out) const {
     Out << "Off=" << Offset << ", Sym=" << *Symbol << ", Addend=" << Addend
-        << ", Type=" << Type << ", FixupSection=" << FixupSection;
+        << ", Type=" << Type
+        << ", FixupSection=" << FixupSection->getSectionName();
   }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   LLVM_DUMP_METHOD void dump() const { print(dbgs()); }
 #endif
 };
 
 #if !defined(NDEBUG)
class WasmObjectWriter : public MCObjectWriter {
   // for TABLE_INDEX relocation types (i.e. address taken functions).
   DenseMap<const MCSymbolWasm *, uint32_t> IndirectSymbolIndices;
   // Maps function/global symbols to the function/global index space.
   DenseMap<const MCSymbolWasm *, uint32_t> SymbolIndices;
 
   DenseMap<WasmFunctionType, int32_t, WasmFunctionTypeDenseMapInfo>
       FunctionTypeIndices;
   SmallVector<WasmFunctionType, 4> FunctionTypes;
+  SmallVector<WasmGlobal, 4> Globals;
+  SmallVector<WasmExport, 4> Exports;
+  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 startSection(SectionBookkeeping &Section, unsigned SectionId,
private:
   void reset() override {
     CodeRelocations.clear();
     DataRelocations.clear();
     TypeIndices.clear();
     SymbolIndices.clear();
     IndirectSymbolIndices.clear();
     FunctionTypeIndices.clear();
     FunctionTypes.clear();
+    Globals.clear();
+    Exports.clear();
     MCObjectWriter::reset();
+    NumGlobalImports = 0;
   }
 
   void writeHeader(const MCAssembler &Asm);
 
+  void addGlobal(StringRef Name, uint32_t Value);
+
   void recordRelocation(MCAssembler &Asm, const MCAsmLayout &Layout,
                         const MCFragment *Fragment, const MCFixup &Fixup,
                         MCValue Target, uint64_t &FixedValue) override;
 
   void executePostLayoutBinding(MCAssembler &Asm,
                                 const MCAsmLayout &Layout) override;
 
   void writeObject(MCAssembler &Asm, const MCAsmLayout &Layout) override;
static uint32_t ProvisionalValue(const WasmRelocationEntry &RelEntry) {
   uint64_t Address = Section.getSectionOffset() + RelEntry.Addend;
 
   // Ignore overflow. LLVM allows address arithmetic to silently wrap.
   uint32_t Value = Address;
 
   return Value;
 }
 
+static void addData(SmallVector<char, 0> &DataBytes, MCSectionWasm &DataSection,
+                    uint32_t &DataAlignment) {
+  DataBytes.resize(alignTo(DataBytes.size(), DataSection.getAlignment()));
+  DataAlignment = std::max(DataAlignment, DataSection.getAlignment());
+
+  DataSection.setSectionOffset(DataBytes.size());
+
+  for (const MCFragment &Frag : DataSection) {
+    if (Frag.hasInstructions())
+      report_fatal_error("only data supported in data sections");
+
+    if (auto *Align = dyn_cast<MCAlignFragment>(&Frag)) {
+      if (Align->getValueSize() != 1)
+        report_fatal_error("only byte values supported for alignment");
+      // If nops are requested, use zeros, as this is the data section.
+      uint8_t Value = Align->hasEmitNops() ? 0 : Align->getValue();
+      uint64_t Size = std::min<uint64_t>(alignTo(DataBytes.size(),
+                                                 Align->getAlignment()),
+                                         DataBytes.size() +
+                                             Align->getMaxBytesToEmit());
+      DataBytes.resize(Size, Value);
+    } else if (auto *Fill = dyn_cast<MCFillFragment>(&Frag)) {
+      DataBytes.insert(DataBytes.end(), Fill->getSize(), Fill->getValue());
+    } else {
+      const auto &DataFrag = cast<MCDataFragment>(Frag);
+      const SmallVectorImpl<char> &Contents = DataFrag.getContents();
+
+      DataBytes.insert(DataBytes.end(), Contents.begin(), Contents.end());
+    }
+  }
+}
+
 uint32_t WasmObjectWriter::getRelocationIndexValue(
     const WasmRelocationEntry &RelEntry) {
   switch (RelEntry.Type) {
   case wasm::R_WEBASSEMBLY_TABLE_INDEX_SLEB:
   case wasm::R_WEBASSEMBLY_TABLE_INDEX_I32:
     if (!IndirectSymbolIndices.count(RelEntry.Symbol))
       report_fatal_error("symbol not found table index space: " +
                          RelEntry.Symbol->getName());
if (Pair.second)
     FunctionTypes.push_back(F);
   TypeIndices[&Symbol] = Pair.first->second;
 
   DEBUG(dbgs() << "registerFunctionType: " << Symbol << " new:" << Pair.second << "\n");
   DEBUG(dbgs() << "  -> type index: " << Pair.first->second << "\n");
   return Pair.first->second;
 }
 
+void WasmObjectWriter::addGlobal(StringRef Name, uint32_t Value) {
+  uint32_t Index = NumGlobalImports + Globals.size();
+  WasmGlobal Global;
+  Global.Type = is64Bit() ? wasm::ValType::I64 : wasm::ValType::I32;
+  Global.IsMutable = false;
+  Global.HasImport = false;
+  Global.InitialValue = Value;
+  Global.ImportIndex = 0;
+  Globals.push_back(Global);
+  WasmExport Export;
+  Export.FieldName = Name;
+  Export.Index = Index;
+  Export.Kind = wasm::WASM_EXTERNAL_GLOBAL;
+  Exports.push_back(Export);
+}
+
 void WasmObjectWriter::writeObject(MCAssembler &Asm,
                                    const MCAsmLayout &Layout) {
   DEBUG(dbgs() << "WasmObjectWriter::writeObject\n");
   MCContext &Ctx = Asm.getContext();
   wasm::ValType PtrType = is64Bit() ? wasm::ValType::I64 : wasm::ValType::I32;
 
   // Collect information from the available symbols.
   SmallVector<WasmFunction, 4> Functions;
   SmallVector<uint32_t, 4> TableElems;
-  SmallVector<WasmGlobal, 4> Globals;
   SmallVector<WasmImport, 4> Imports;
-  SmallVector<WasmExport, 4> Exports;
   SmallVector<StringRef, 4> WeakSymbols;
   SmallPtrSet<const MCSymbolWasm *, 4> IsAddressTaken;
   unsigned NumFuncImports = 0;
-  unsigned NumGlobalImports = 0;
   SmallVector<char, 0> DataBytes;
   uint32_t DataAlignment = 1;
   uint32_t StackPointerGlobal = 0;
   bool HasStackPointer = false;
 
   // Populate the IsAddressTaken set.
   for (const WasmRelocationEntry &RelEntry : CodeRelocations) {
     switch (RelEntry.Type) {
if (!DataFrag.getFixups().empty())
       report_fatal_error("fixups not supported in .stack_pointer");
     const SmallVectorImpl<char> &Contents = DataFrag.getContents();
     if (Contents.size() != 4)
       report_fatal_error("only one entry supported in .stack_pointer");
     HasStackPointer = true;
     StackPointerGlobal = NumGlobalImports + *(const int32_t *)Contents.data();
   }
 
+  MCSectionWasm *InitArray = Ctx.getWasmSection(".init_array", 0, 0);
+  if (!InitArray->getFragmentList().empty()) {
+    addGlobal("__init_array_start", DataBytes.size());
+    addData(DataBytes, *InitArray, DataAlignment);
+    addGlobal("__init_array_end", DataBytes.size());
+  }
+
+  MCSectionWasm *FiniArray = Ctx.getWasmSection(".fini_array", 0, 0);
+  if (!FiniArray->getFragmentList().empty()) {
+    addGlobal("__fini_array_start", DataBytes.size());
+    addData(DataBytes, *FiniArray, DataAlignment);
+    addGlobal("__fini_array_end", DataBytes.size());
+  }
+
   // Handle regular defined and undefined symbols.
   for (const MCSymbol &S : Asm.symbols()) {
     // Ignore unnamed temporary symbols, which aren't ever exported, imported,
     // or used in relocations.
     if (S.isTemporary() && S.getName().empty())
       continue;
 
     const auto &WS = static_cast<const MCSymbolWasm &>(S);
if (WS.isFunction()) {
         report_fatal_error("data symbols must have a size set with .size: " +
                            WS.getName());
 
       int64_t Size = 0;
       if (!WS.getSize()->evaluateAsAbsolute(Size, Layout))
         report_fatal_error(".size expression must be evaluatable");
 
       auto &DataSection = static_cast<MCSectionWasm &>(WS.getSection());
-
       if (uint64_t(Size) != Layout.getSectionFileSize(&DataSection))
         report_fatal_error("data sections must contain at most one variable");
 
-      DataBytes.resize(alignTo(DataBytes.size(), DataSection.getAlignment()));
-      DataAlignment = std::max(DataAlignment, DataSection.getAlignment());
-
-      DataSection.setSectionOffset(DataBytes.size());
-
-      for (const MCFragment &Frag : DataSection) {
-        if (Frag.hasInstructions())
-          report_fatal_error("only data supported in data sections");
-
-        if (auto *Align = dyn_cast<MCAlignFragment>(&Frag)) {
-          if (Align->getValueSize() != 1)
-            report_fatal_error("only byte values supported for alignment");
-          // If nops are requested, use zeros, as this is the data section.
-          uint8_t Value = Align->hasEmitNops() ? 0 : Align->getValue();
-          uint64_t Size = std::min<uint64_t>(alignTo(DataBytes.size(),
-                                                     Align->getAlignment()),
-                                             DataBytes.size() +
-                                                 Align->getMaxBytesToEmit());
-          DataBytes.resize(Size, Value);
-        } else if (auto *Fill = dyn_cast<MCFillFragment>(&Frag)) {
-          DataBytes.insert(DataBytes.end(), Fill->getSize(), Fill->getValue());
-        } else {
-          const auto &DataFrag = cast<MCDataFragment>(Frag);
-          const SmallVectorImpl<char> &Contents = DataFrag.getContents();
-
-          DataBytes.insert(DataBytes.end(), Contents.begin(), Contents.end());
-        }
-      }
+      addData(DataBytes, DataSection, DataAlignment);
 
       // For each global, prepare a corresponding wasm global holding its
       // address.  For externals these will also be named exports.
       Index = NumGlobalImports + Globals.size();
 
       WasmGlobal Global;
       Global.Type = PtrType;
       Global.IsMutable = false;