[WebAssembly] MC: Create and use first class section symbols

[sbc100]

• cleanup

[sbc100]

• cleanup

[yurydelendik]

lib/MC/WasmObjectWriter.cpp

512

cast_or_null is used in if-else branch, do we need to check SectionSymbol?

[sbc100]

• cleanup
• cleanup

[yurydelendik]

Looks good to me. Thanks

lib/MC/MCContext.cpp

auto IterBool = WasmUniquingMap.insert(
       std::make_pair(WasmSectionKey{Section.str(), Group, UniqueID}, nullptr));
   auto &Entry = *IterBool.first;
   if (!IterBool.second)
     return Entry.second;
 
   StringRef CachedName = Entry.first.SectionName;
 
   MCSymbol *Begin = nullptr;
-  if (BeginSymName)
-    Begin = createTempSymbol(BeginSymName, false);
+  if (BeginSymName) {
+    Begin = createSymbol(BeginSymName, false, false);
+    cast<MCSymbolWasm>(Begin)->setType(wasm::WASM_SYMBOL_TYPE_SECTION);
+  }
 
   MCSectionWasm *Result = new (WasmAllocator.Allocate())
       MCSectionWasm(CachedName, Kind, GroupSym, UniqueID, Begin);
   Entry.second = Result;
   return Result;
 }
 
 MCSubtargetInfo &MCContext::getSubtargetCopy(const MCSubtargetInfo &STI) {

lib/MC/MCObjectFileInfo.cpp

 }
 
 void MCObjectFileInfo::initWasmMCObjectFileInfo(const Triple &T) {
   // TODO: Set the section types and flags.
   TextSection = Ctx->getWasmSection(".text", SectionKind::getText());
   DataSection = Ctx->getWasmSection(".data", SectionKind::getData());
 
   // TODO: Set the section types and flags.
-  DwarfLineSection = Ctx->getWasmSection(".debug_line", SectionKind::getMetadata());
+  DwarfLineSection = Ctx->getWasmSection(".debug_line", SectionKind::getMetadata(), ".debug_line");
   DwarfLineStrSection =
       Ctx->getWasmSection(".debug_line_str", SectionKind::getMetadata());
-  DwarfStrSection = Ctx->getWasmSection(".debug_str", SectionKind::getMetadata());
+  DwarfStrSection = Ctx->getWasmSection(".debug_str", SectionKind::getMetadata(), ".debug_str");
   DwarfLocSection = Ctx->getWasmSection(".debug_loc", SectionKind::getMetadata());
-  DwarfAbbrevSection = Ctx->getWasmSection(".debug_abbrev", SectionKind::getMetadata(), "section_abbrev");
+  DwarfAbbrevSection = Ctx->getWasmSection(".debug_abbrev", SectionKind::getMetadata(), ".section_abbrev");
   DwarfARangesSection = Ctx->getWasmSection(".debug_aranges", SectionKind::getMetadata());
-  DwarfRangesSection = Ctx->getWasmSection(".debug_ranges", SectionKind::getMetadata(), "debug_range");
-  DwarfMacinfoSection = Ctx->getWasmSection(".debug_macinfo", SectionKind::getMetadata(), "debug_macinfo");
+  DwarfRangesSection = Ctx->getWasmSection(".debug_ranges", SectionKind::getMetadata(), ".debug_range");
+  DwarfMacinfoSection = Ctx->getWasmSection(".debug_macinfo", SectionKind::getMetadata(), ".debug_macinfo");
   DwarfAddrSection = Ctx->getWasmSection(".debug_addr", SectionKind::getMetadata());
   DwarfCUIndexSection = Ctx->getWasmSection(".debug_cu_index", SectionKind::getMetadata());
   DwarfTUIndexSection = Ctx->getWasmSection(".debug_tu_index", SectionKind::getMetadata());
-  DwarfInfoSection = Ctx->getWasmSection(".debug_info", SectionKind::getMetadata(), "section_info");
+  DwarfInfoSection = Ctx->getWasmSection(".debug_info", SectionKind::getMetadata(), ".debug_info");
   DwarfFrameSection = Ctx->getWasmSection(".debug_frame", SectionKind::getMetadata());
   DwarfPubNamesSection = Ctx->getWasmSection(".debug_pubnames", SectionKind::getMetadata());
   DwarfPubTypesSection = Ctx->getWasmSection(".debug_pubtypes", SectionKind::getMetadata());
 
   // TODO: Define more sections.
 }
 
 void MCObjectFileInfo::InitMCObjectFileInfo(const Triple &TheTriple, bool PIC,

lib/MC/MCWasmStreamer.cpp

 void MCWasmStreamer::EmitValueToAlignment(unsigned ByteAlignment, int64_t Value,
                                           unsigned ValueSize,
                                           unsigned MaxBytesToEmit) {
   MCObjectStreamer::EmitValueToAlignment(ByteAlignment, Value, ValueSize,
                                          MaxBytesToEmit);
 }
 
 void MCWasmStreamer::EmitIdent(StringRef IdentString) {
-  MCSection *Comment = getAssembler().getContext().getWasmSection(
-      ".comment", SectionKind::getMetadata());
-  PushSection();
-  SwitchSection(Comment);
-  if (!SeenIdent) {
-    EmitIntValue(0, 1);
-    SeenIdent = true;
-  }
-  EmitBytes(IdentString);
-  EmitIntValue(0, 1);
-  PopSection();
+  // TODO(sbc): Add the ident section once we support mergable strings
+  // sections in the object format
 }
 
 void MCWasmStreamer::EmitInstToFragment(const MCInst &Inst,
                                         const MCSubtargetInfo &STI) {
   this->MCObjectStreamer::EmitInstToFragment(Inst, STI);
 }
 
 void MCWasmStreamer::EmitInstToData(const MCInst &Inst,

lib/MC/WasmObjectWriter.cpp

class WasmObjectWriter : public MCObjectWriter {
   // for TABLE_INDEX relocation types (i.e. address taken functions).
   DenseMap<const MCSymbolWasm *, uint32_t> TableIndices;
   // Maps function/global symbols to the (shared) Symbol index space.
   DenseMap<const MCSymbolWasm *, uint32_t> SymbolIndices;
   // Maps function/global symbols to the function/global/section index space.
   DenseMap<const MCSymbolWasm *, uint32_t> WasmIndices;
   // Maps data symbols to the Wasm segment and offset/size with the segment.
   DenseMap<const MCSymbolWasm *, wasm::WasmDataReference> DataLocations;
-  // Maps section symbols to the section.
-  DenseMap<const MCSymbolWasm *, const MCSectionWasm *> CustomSectionSymbols;
 
   // Stores output data (index, relocations, content offset) for custom
   // section.
   std::vector<WasmCustomSection> CustomSections;
   // Relocations for fixing up references in the custom sections.
   DenseMap<const MCSectionWasm *, std::vector<WasmRelocationEntry>>
       CustomSectionsRelocations;
 
void reset() override {
     WasmIndices.clear();
     TableIndices.clear();
     DataLocations.clear();
     CustomSectionsRelocations.clear();
     FunctionTypeIndices.clear();
     FunctionTypes.clear();
     Globals.clear();
     DataSegments.clear();
-    CustomSectionSymbols.clear();
     MCObjectWriter::reset();
     NumFunctionImports = 0;
     NumGlobalImports = 0;
   }
 
   void writeHeader(const MCAssembler &Asm);
 
   void recordRelocation(MCAssembler &Asm, const MCAsmLayout &Layout,
void WasmObjectWriter::recordRelocation(MCAssembler &Asm,
   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;
 
-  // TODO: Add support for non-debug metadata sections?
-  if (FixupSection.getKind().isMetadata() &&
-      !FixupSection.getSectionName().startswith(".debug_"))
-    return;
-
   if (const MCSymbolRefExpr *RefB = Target.getSymB()) {
     assert(RefB->getKind() == MCSymbolRefExpr::VK_None &&
            "Should not have constructed this");
 
     // Let A, B and C being the components of Target and R be the location of
     // the fixup. If the fixup is not pcrel, we want to compute (A - B + C).
     // If it is pcrel, we want to compute (A - B + C - R).
 
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
   // LLVM expects wrapping, in contrast to wasm's immediates which can't
   // be negative and don't wrap.
   FixedValue = 0;
 
-  if (SymA)
-    SymA->setUsedInReloc();
-
+  unsigned Type = getRelocType(Target, Fixup);
   assert(!IsPCRel);
   assert(SymA);
 
-  unsigned Type = getRelocType(Target, Fixup);
+  // Absolute offset within a section or a function.
+  // Currently only supported for for metadata sections.
+  // See: test/MC/WebAssembly/blockaddress.ll
+  if (Type == wasm::R_WEBASSEMBLY_FUNCTION_OFFSET_I32 ||
+      Type == wasm::R_WEBASSEMBLY_SECTION_OFFSET_I32) {
+    if (!FixupSection.getKind().isMetadata())
+      report_fatal_error("relocations for function or section offsets are "
+                         "only supported in metadata sections");
+
+    const MCSymbolWasm *SectionSymbol = nullptr;
+    const MCSection &SecA = SymA->getSection();
+    if (SecA.getKind().isText()) {
+      const MCFragment &Frag = *SecA.begin();
+      SectionSymbol = cast<MCSymbolWasm>(Frag.getAtom());
+    } else {
+      SectionSymbol = cast_or_null<MCSymbolWasm>(SecA.getBeginSymbol());
+    }
+    if (!SectionSymbol)
+      report_fatal_error("section symbol require for relocation");
 
-  WasmRelocationEntry Rec(FixupOffset, SymA, C, Type, &FixupSection);
-  DEBUG(dbgs() << "WasmReloc: " << Rec << "\n");
+    C += Layout.getSymbolOffset(*SymA);
+    SymA = SectionSymbol;
+  }
 
-  // Relocation other than R_WEBASSEMBLY_TYPE_INDEX_LEB,
-  // R_WEBASSEMBLY_SECTION_OFFSET_I32 or R_WEBASSEMBLY_FUNCTION_OFFSET_I32
-  // are currently required to be against a named symbol.
-  // TODO(sbc): Add support for relocations against unnamed temporaries such
-  // as those generated by llvm's `blockaddress`.
-  // See: test/MC/WebAssembly/blockaddress.ll
-  if (SymA->getName().empty() &&
-      !(Type == wasm::R_WEBASSEMBLY_TYPE_INDEX_LEB ||
-        Type == wasm::R_WEBASSEMBLY_FUNCTION_OFFSET_I32 ||
-        Type == wasm::R_WEBASSEMBLY_SECTION_OFFSET_I32))
+  // Relocation other than R_WEBASSEMBLY_TYPE_INDEX_LEB are required to be
+  // against a named symbol.
+  if (Type != wasm::R_WEBASSEMBLY_TYPE_INDEX_LEB) {
+    if (SymA->getName().empty())
       report_fatal_error("relocations against un-named temporaries are not yet "
                          "supported by wasm");
 
+    SymA->setUsedInReloc();
+  }
+
+  WasmRelocationEntry Rec(FixupOffset, SymA, C, Type, &FixupSection);
+  DEBUG(dbgs() << "WasmReloc: " << Rec << "\n");
+
   if (FixupSection.isWasmData()) {
     DataRelocations.push_back(Rec);
   } else if (FixupSection.getKind().isText()) {
     CodeRelocations.push_back(Rec);
   } else if (FixupSection.getKind().isMetadata()) {
-    assert(FixupSection.getSectionName().startswith(".debug_"));
     CustomSectionsRelocations[&FixupSection].push_back(Rec);
   } else {
     llvm_unreachable("unexpected section type");
   }
 }
 
 // Write X as an (unsigned) LEB value at offset Offset in Stream, padded
 // to allow patching.
case wasm::R_WEBASSEMBLY_TYPE_INDEX_LEB:
     return getRelocationIndexValue(RelEntry);
   case wasm::R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
   case wasm::R_WEBASSEMBLY_GLOBAL_INDEX_LEB:
     // Provisional value is function/global Wasm index
     if (!WasmIndices.count(RelEntry.Symbol))
       report_fatal_error("symbol not found in wasm index space: " +
                          RelEntry.Symbol->getName());
     return WasmIndices[RelEntry.Symbol];
-  case wasm::R_WEBASSEMBLY_FUNCTION_OFFSET_I32: {
+  case wasm::R_WEBASSEMBLY_FUNCTION_OFFSET_I32:
+  case wasm::R_WEBASSEMBLY_SECTION_OFFSET_I32: {
     const auto &Section =
         static_cast<const MCSectionWasm &>(RelEntry.Symbol->getSection());
     return Section.getSectionOffset() + RelEntry.Addend;
   }
-  case wasm::R_WEBASSEMBLY_SECTION_OFFSET_I32: {
-    const auto &Section = *CustomSectionSymbols.find(RelEntry.Symbol)->second;
-    return Section.getSectionOffset() + RelEntry.Addend;
-  }
   case wasm::R_WEBASSEMBLY_MEMORY_ADDR_LEB:
   case wasm::R_WEBASSEMBLY_MEMORY_ADDR_I32:
   case wasm::R_WEBASSEMBLY_MEMORY_ADDR_SLEB: {
     // Provisional value is address of the global
     const MCSymbolWasm *Sym = ResolveSymbol(*RelEntry.Symbol);
     // For undefined symbols, use zero
     if (!Sym->isDefined())
       return 0;
for (auto &CustomSection : CustomSections) {
 
     Sec->setSectionOffset(getStream().tell() - Section.ContentsOffset);
     Asm.writeSectionData(Sec, Layout);
 
     CustomSection.OutputContentsOffset = Section.ContentsOffset;
     CustomSection.OutputIndex = Section.Index;
 
     endSection(Section);
-  }
-}
-
-void WasmObjectWriter::updateCustomSectionRelocations(
-    const SmallVector<WasmFunction, 4> &Functions, const MCAsmLayout &Layout) {
-  std::map<const MCSection *, const MCSymbolWasm *> SectionSymbols;
-  for (const auto &P : CustomSectionSymbols)
-    SectionSymbols[P.second] = P.first;
-  std::map<const MCSection *, const MCSymbolWasm *> FuncSymbols;
-  for (const auto &FuncInfo : Functions)
-    FuncSymbols[&FuncInfo.Sym->getSection()] = FuncInfo.Sym;
-
-  // Patch relocation records for R_WEBASSEMBLY_FUNCTION_OFFSET_I32 and
-  // R_WEBASSEMBLY_SECTION_OFFSET_I32. The Addend is stuffed the offset from
-  // the beginning of the function or custom section -- all such relocations
-  // target the function or custom section starts.
-  for (auto &Section : CustomSections) {
-    auto &Relocations = CustomSectionsRelocations[Section.Section];
-    for (WasmRelocationEntry &RelEntry : Relocations) {
-      switch (RelEntry.Type) {
-      case wasm::R_WEBASSEMBLY_FUNCTION_OFFSET_I32: {
-        assert(RelEntry.hasAddend());
-        auto &Section =
-            static_cast<MCSectionWasm &>(RelEntry.Symbol->getSection());
-        RelEntry.Addend += Layout.getSymbolOffset(*RelEntry.Symbol);
-        RelEntry.Symbol = FuncSymbols[&Section];
-        break;
-      }
-      case wasm::R_WEBASSEMBLY_SECTION_OFFSET_I32: {
-        assert(RelEntry.hasAddend());
-        auto &Section =
-            static_cast<MCSectionWasm &>(RelEntry.Symbol->getSection());
-        RelEntry.Addend += Layout.getSymbolOffset(*RelEntry.Symbol);
-        RelEntry.Symbol = SectionSymbols[&Section];
-        break;
-      }
-      default:
-        break;
-      }
-    }
 
     // Apply fixups.
-    applyRelocations(Relocations, Section.OutputContentsOffset);
+    auto &Relocations = CustomSectionsRelocations[CustomSection.Section];
+    applyRelocations(Relocations, CustomSection.OutputContentsOffset);
   }
 }
 
 uint32_t WasmObjectWriter::getFunctionType(const MCSymbolWasm& Symbol) {
   assert(Symbol.isFunction());
   assert(TypeIndices.count(&Symbol));
   return TypeIndices[&Symbol];
 }
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;
 }
 
+static bool isInSymtab(const MCSymbolWasm &Sym) {
+  if (Sym.isUsedInReloc())
+    return true;
+
+  if (Sym.isComdat() && !Sym.isDefined())
+    return false;
+
+  if (Sym.isTemporary() && Sym.getName().empty())
+    return false;
+
+  if (Sym.isTemporary() && Sym.isData() && !Sym.getSize())
+    return false;
+
+  if (Sym.isSection())
+    return false;
+
+  return true;
+}
+
 void WasmObjectWriter::writeObject(MCAssembler &Asm,
                                    const MCAsmLayout &Layout) {
   DEBUG(dbgs() << "WasmObjectWriter::writeObject\n");
   MCContext &Ctx = Asm.getContext();
 
   // Collect information from the available symbols.
   SmallVector<WasmFunction, 4> Functions;
   SmallVector<uint32_t, 4> TableElems;
if (!WS.isDefined() && !WS.isComdat()) {
         Import.Kind = wasm::WASM_EXTERNAL_GLOBAL;
         Import.Global = WS.getGlobalType();
         Imports.push_back(Import);
         WasmIndices[&WS] = NumGlobalImports++;
       }
     }
   }
 
-  // Populate DataSegments, which must be done before populating DataLocations.
+  // Populate DataSegments and CustomSections, which must be done before
+  // populating DataLocations.
   for (MCSection &Sec : Asm) {
     auto &Section = static_cast<MCSectionWasm &>(Sec);
+    StringRef SectionName = Section.getSectionName();
 
-    if (Section.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);
-      CustomSections.emplace_back(UserName, &Section);
-      continue;
-    }
-
-    if (!Section.isWasmData())
+    // .init_array sections are handled specially elsewhere.
+    if (SectionName.startswith(".init_array"))
       continue;
 
-    // .init_array sections are handled specially elsewhere.
-    if (cast<MCSectionWasm>(Sec).getSectionName().startswith(".init_array"))
+    // Code is handled separately
+    if (Section.getKind().isText())
       continue;
 
+    if (Section.isWasmData()) {
       uint32_t SegmentIndex = DataSegments.size();
       DataSize = alignTo(DataSize, Section.getAlignment());
       DataSegments.emplace_back();
       WasmDataSegment &Segment = DataSegments.back();
-    Segment.Name = Section.getSectionName();
+      Segment.Name = SectionName;
       Segment.Offset = DataSize;
       Segment.Section = &Section;
       addData(Segment.Data, Section);
       Segment.Alignment = Section.getAlignment();
       Segment.Flags = 0;
       DataSize += Segment.Data.size();
       Section.setSegmentIndex(SegmentIndex);
 
       if (const MCSymbolWasm *C = Section.getGroup()) {
         Comdats[C->getName()].emplace_back(
             WasmComdatEntry{wasm::WASM_COMDAT_DATA, SegmentIndex});
       }
-  }
-
-  // Create symbols for debug/custom sections.
-  for (MCSection &Sec : Asm) {
-    auto &DebugSection = static_cast<MCSectionWasm &>(Sec);
-    StringRef SectionName = DebugSection.getSectionName();
-
-    // TODO: Add support for non-debug metadata sections?
-    if (!Sec.getKind().isMetadata() || !SectionName.startswith(".debug_"))
-      continue;
-
-    uint32_t ElementIndex = CustomSections.size();
-    CustomSections.emplace_back(SectionName, &DebugSection);
+    } else {
+      // Create custom sections
+      assert(Sec.getKind().isMetadata());
 
-    MCSymbolWasm *SectionSym =
-        cast<MCSymbolWasm>(Ctx.getOrCreateSymbol(SectionName));
-    CustomSectionSymbols[SectionSym] = &DebugSection;
+      StringRef Name = SectionName;
 
-    wasm::WasmSymbolInfo Info;
-    Info.Name = SectionSym->getName();
-    Info.Kind = wasm::WASM_SYMBOL_TYPE_SECTION;
-    Info.Flags = wasm::WASM_SYMBOL_BINDING_LOCAL;
-    Info.ElementIndex = ElementIndex;
-    SymbolIndices[SectionSym] = SymbolInfos.size();
-    SymbolInfos.emplace_back(Info);
+      // For user-defined custom sections, strip the prefix
+      if (Name.startswith(".custom_section."))
+        Name = Name.substr(strlen(".custom_section."));
+
+      MCSymbol* Begin = Sec.getBeginSymbol();
+      if (Begin)
+        WasmIndices[cast<MCSymbolWasm>(Begin)] = CustomSections.size();
+      CustomSections.emplace_back(Name, &Section);
+    }
   }
 
   // Populate WasmIndices and DataLocations for defined 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;
for (const MCSymbol &S : Asm.symbols()) {
     } else {
       report_fatal_error("don't yet support global aliases");
     }
   }
 
   // Finally, populate the symbol table itself, in its "natural" order.
   for (const MCSymbol &S : Asm.symbols()) {
     const auto &WS = static_cast<const MCSymbolWasm &>(S);
-    if (WS.isTemporary() && WS.getName().empty())
-      continue;
-    if (WS.isComdat() && !WS.isDefined())
-      continue;
-    if (WS.isTemporary() && WS.isData() && !WS.getSize())
+    if (!isInSymtab(WS))
       continue;
+    DEBUG(dbgs() << "adding to symtab: " << WS << "\n");
 
     uint32_t Flags = 0;
     if (WS.isWeak())
       Flags |= wasm::WASM_SYMBOL_BINDING_WEAK;
     if (WS.isHidden())
       Flags |= wasm::WASM_SYMBOL_VISIBILITY_HIDDEN;
     if (!WS.isExternal() && WS.isDefined())
       Flags |= wasm::WASM_SYMBOL_BINDING_LOCAL;
     if (WS.isUndefined())
       Flags |= wasm::WASM_SYMBOL_UNDEFINED;
 
     wasm::WasmSymbolInfo Info;
     Info.Name = WS.getName();
     Info.Kind = WS.getType();
     Info.Flags = Flags;
-    if (!WS.isData())
+    if (!WS.isData()) {
+      assert(WasmIndices.count(&WS) > 0);
       Info.ElementIndex = WasmIndices.find(&WS)->second;
-    else if (WS.isDefined())
+    } else if (WS.isDefined()) {
+      assert(DataLocations.count(&WS) > 0);
       Info.DataRef = DataLocations.find(&WS)->second;
+    }
     SymbolIndices[&WS] = SymbolInfos.size();
     SymbolInfos.emplace_back(Info);
   }
 
   {
     auto HandleReloc = [&](const WasmRelocationEntry &Rel) {
       // Functions referenced by a relocation need to put in the table.  This is
       // purely to make the object file's provisional values readable, and is
for (const MCSection &S : Asm) {
     if (AlignFrag.getKind() != MCFragment::FT_Align)
       report_fatal_error(".init_array section should be aligned");
     if (cast<MCAlignFragment>(AlignFrag).getAlignment() != (is64Bit() ? 8 : 4))
       report_fatal_error(".init_array section should be aligned for pointers");
     const MCFragment &Frag = *std::next(WS.begin());
     if (Frag.hasInstructions() || Frag.getKind() != MCFragment::FT_Data)
       report_fatal_error("only data supported in .init_array section");
     uint16_t Priority = UINT16_MAX;
-    if (WS.getSectionName().size() != 11) {
-      if (WS.getSectionName()[11] != '.')
+    unsigned PrefixLength = strlen(".init_array");
+    if (WS.getSectionName().size() > PrefixLength) {
+      if (WS.getSectionName()[PrefixLength] != '.')
         report_fatal_error(".init_array section priority should start with '.'");
-      if (WS.getSectionName().substr(12).getAsInteger(10, Priority))
+      if (WS.getSectionName()
+              .substr(PrefixLength + 1)
+              .getAsInteger(10, Priority))
         report_fatal_error("invalid .init_array section priority");
     }
     const auto &DataFrag = cast<MCDataFragment>(Frag);
     const SmallVectorImpl<char> &Contents = DataFrag.getContents();
     for (const uint8_t *p = (const uint8_t *)Contents.data(),
                      *end = (const uint8_t *)Contents.data() + Contents.size();
          p != end; ++p) {
       if (*p != 0)
void WasmObjectWriter::writeObject(MCAssembler &Asm,
   // 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();
   writeCustomSections(Asm, Layout);
-  updateCustomSectionRelocations(Functions, Layout);
   writeLinkingMetaDataSection(SymbolInfos, InitFuncs, Comdats);
   writeRelocSection(CodeSectionIndex, "CODE", CodeRelocations);
   writeRelocSection(DataSectionIndex, "DATA", DataRelocations);
   writeCustomRelocSections();
 
   // TODO: Translate the .comment section 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);
 }

test/MC/WebAssembly/blockaddress.ll

 ; TODO(sbc): Make this test pass by adding support for unnamed tempoaries
 ; in wasm relocations.
-; RUN: not llc -filetype=obj %s
+; RUN: not llc -filetype=obj %s 2>&1 | FileCheck %s
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 @foo = internal global i8* blockaddress(@bar, %addr), align 4
 
 define hidden i32 @bar() #0 {
 entry:
   br label %addr
 
 addr:
   ret i32 0
 }
+
+; CHECK: LLVM ERROR: relocations for function or section offsets are only supported in metadata sections

test/MC/WebAssembly/debug-info.ll

 ; CHECK-NEXT:  Section {
 ; CHECK-NEXT:    Type: CUSTOM (0x0)
 ; CHECK-NEXT:    Size: 57
 ; CHECK-NEXT:    Offset: 658
 ; CHECK-NEXT:    Name: .debug_line
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Section {
 ; CHECK-NEXT:    Type: CUSTOM (0x0)
-; CHECK-NEXT:    Size: 100
+; CHECK-NEXT:    Size: 88
 ; CHECK-NEXT:    Offset: 733
 ; CHECK-NEXT:    Name: linking
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Section {
 ; CHECK-NEXT:    Type: CUSTOM (0x0)
 ; CHECK-NEXT:    Size: 9
-; CHECK-NEXT:    Offset: 847
+; CHECK-NEXT:    Offset: 835
 ; CHECK-NEXT:    Name: reloc.DATA
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Section {
 ; CHECK-NEXT:    Type: CUSTOM (0x0)
 ; CHECK-NEXT:    Size: 58
-; CHECK-NEXT:    Offset: 873
+; CHECK-NEXT:    Offset: 861
 ; CHECK-NEXT:    Name: reloc..debug_info
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Section {
 ; CHECK-NEXT:    Type: CUSTOM (0x0)
 ; CHECK-NEXT:    Size: 6
-; CHECK-NEXT:    Offset: 955
+; CHECK-NEXT:    Offset: 943
 ; CHECK-NEXT:    Name: reloc..debug_pubnames
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Section {
 ; CHECK-NEXT:    Type: CUSTOM (0x0)
 ; CHECK-NEXT:    Size: 6
-; CHECK-NEXT:    Offset: 989
+; CHECK-NEXT:    Offset: 977
 ; CHECK-NEXT:    Name: reloc..debug_pubtypes
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Section {
 ; CHECK-NEXT:    Type: CUSTOM (0x0)
 ; CHECK-NEXT:    Size: 6
-; CHECK-NEXT:    Offset: 1023
+; CHECK-NEXT:    Offset: 1011
 ; CHECK-NEXT:    Name: reloc..debug_line
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:]
 ; CHECK-NEXT:Relocations [
 ; CHECK-NEXT:  Section (6) DATA {
 ; CHECK-NEXT:    0x6 R_WEBASSEMBLY_MEMORY_ADDR_I32 myextern 0
 ; CHECK-NEXT:    0xF R_WEBASSEMBLY_TABLE_INDEX_I32 f2
 ; CHECK-NEXT:  }

 ; CHECK-NEXT:    0x6 R_WEBASSEMBLY_SECTION_OFFSET_I32 .debug_info 0
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Section (14) .debug_line {
 ; CHECK-NEXT:    0x2B R_WEBASSEMBLY_FUNCTION_OFFSET_I32 f2 0
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:]
 ; CHECK-NEXT:Symbols [
 ; CHECK-NEXT:  Symbol {
-; CHECK-NEXT:    Name: .debug_str
-; CHECK-NEXT:    Type: SECTION (0x3)
-; CHECK-NEXT:    Flags: 0x2
+; CHECK-NEXT:    Name: f2
+; CHECK-NEXT:    Type: FUNCTION (0x0)
+; CHECK-NEXT:    Flags: 0x4
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Symbol {
-; CHECK-NEXT:    Name: .debug_abbrev
-; CHECK-NEXT:    Type: SECTION (0x3)
-; CHECK-NEXT:    Flags: 0x2
+; CHECK-NEXT:    Name: foo
+; CHECK-NEXT:    Type: DATA (0x1)
+; CHECK-NEXT:    Flags: 0x4
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Symbol {
-; CHECK-NEXT:    Name: .debug_info
-; CHECK-NEXT:    Type: SECTION (0x3)
-; CHECK-NEXT:    Flags: 0x2
+; CHECK-NEXT:    Name: myextern
+; CHECK-NEXT:    Type: DATA (0x1)
+; CHECK-NEXT:    Flags: 0x10
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Symbol {
-; CHECK-NEXT:    Name: .debug_ranges
-; CHECK-NEXT:    Type: SECTION (0x3)
-; CHECK-NEXT:    Flags: 0x2
+; CHECK-NEXT:    Name: ptr2
+; CHECK-NEXT:    Type: DATA (0x1)
+; CHECK-NEXT:    Flags: 0x4
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Symbol {
-; CHECK-NEXT:    Name: .debug_macinfo
+; CHECK-NEXT:    Name: .debug_str
 ; CHECK-NEXT:    Type: SECTION (0x3)
 ; CHECK-NEXT:    Flags: 0x2
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Symbol {
-; CHECK-NEXT:    Name: .debug_pubnames
+; CHECK-NEXT:    Name: .debug_abbrev
 ; CHECK-NEXT:    Type: SECTION (0x3)
 ; CHECK-NEXT:    Flags: 0x2
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Symbol {
-; CHECK-NEXT:    Name: .debug_pubtypes
+; CHECK-NEXT:    Name: .debug_info
 ; CHECK-NEXT:    Type: SECTION (0x3)
 ; CHECK-NEXT:    Flags: 0x2
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Symbol {
 ; CHECK-NEXT:    Name: .debug_line
 ; CHECK-NEXT:    Type: SECTION (0x3)
 ; CHECK-NEXT:    Flags: 0x2
 ; CHECK-NEXT:  }
-; CHECK-NEXT:  Symbol {
-; CHECK-NEXT:    Name: f2
-; CHECK-NEXT:    Type: FUNCTION (0x0)
-; CHECK-NEXT:    Flags: 0x4
-; CHECK-NEXT:  }
-; CHECK-NEXT:  Symbol {
-; CHECK-NEXT:    Name: foo
-; CHECK-NEXT:    Type: DATA (0x1)
-; CHECK-NEXT:    Flags: 0x4
-; CHECK-NEXT:  }
-; CHECK-NEXT:  Symbol {
-; CHECK-NEXT:    Name: myextern
-; CHECK-NEXT:    Type: DATA (0x1)
-; CHECK-NEXT:    Flags: 0x10
-; CHECK-NEXT:  }
-; CHECK-NEXT:  Symbol {
-; CHECK-NEXT:    Name: ptr2
-; CHECK-NEXT:    Type: DATA (0x1)
-; CHECK-NEXT:    Flags: 0x4
-; CHECK-NEXT:  }
 ; CHECK-NEXT:]
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 source_filename = "test.c"
 
 @myextern = external global i32, align 4
 @foo = hidden global i32* @myextern, align 4, !dbg !0