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

[sbc100]

• cleanup

[sbc100]

• cleanup

[yurydelendik]

lib/MC/WasmObjectWriter.cpp

554

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(), ".section_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);
+  bool shouldRelocateWithSymbol(const MCSymbolRefExpr *Ref,
+                                const MCSymbolWasm *Sym,
+                                unsigned Type) const;
 
   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 WasmObjectWriter::writeHeader(const MCAssembler &Asm) {
   writeBytes(StringRef(wasm::WasmMagic, sizeof(wasm::WasmMagic)));
   writeLE32(wasm::WasmVersion);
 }
 
 void WasmObjectWriter::executePostLayoutBinding(MCAssembler &Asm,
                                                 const MCAsmLayout &Layout) {
 }
 
+// It is always valid to create a relocation with a symbol. It is preferable
+// to use a relocation with a section if that is possible. Using the section
+// allows us to omit some local symbols from the symbol table.
+bool WasmObjectWriter::shouldRelocateWithSymbol(const MCSymbolRefExpr *Ref,
+                                                const MCSymbolWasm *Sym,
+                                                unsigned Type) const {
+  if (!Ref)
+    return false;
+
+  if (Type == wasm::R_WEBASSEMBLY_FUNCTION_OFFSET_I32 ||
+      Type == wasm::R_WEBASSEMBLY_SECTION_OFFSET_I32)
+    return false;
+
+  if (Sym->isUndefined())
+    return true;
+
+  if (Sym->isTemporary() && Sym->getName().empty())
+    return false;
+
+  if (Sym->isData())
+    return true;
+
+  if (Sym->isFunction())
+    return true;
+
+  if (Sym->isWeak()) {
+    // If the symbol is weak, it might be overridden by a symbol in another
+    // file. The relocation has to point to the symbol so that the linker
+    // can update it.
+    return true;
+  }
+
+  if (Sym->isGlobal()) {
+    // Global ELF symbols can be preempted by the dynamic linker. The relocation
+    // has to point to the symbol for a reason analogous to the STB_WEAK case.
+    return true;
+  }
+
+  return false;
+}
+
 void WasmObjectWriter::recordRelocation(MCAssembler &Asm,
                                         const MCAsmLayout &Layout,
                                         const MCFragment *Fragment,
                                         const MCFixup &Fixup, MCValue Target,
                                         uint64_t &FixedValue) {
   MCAsmBackend &Backend = Asm.getBackend();
   bool IsPCRel = Backend.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;
 
-  // 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);
-
-  WasmRelocationEntry Rec(FixupOffset, SymA, C, Type, &FixupSection);
-  DEBUG(dbgs() << "WasmReloc: " << Rec << "\n");
-
-  // 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`.
+  // Add containing absolute offset within functions or sections are only
+  // currently supports for metadata sections
   // 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))
+  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 for metadata sections");
+  }
+
+  bool RelocateWithSymbol = shouldRelocateWithSymbol(RefA, SymA, Type);
+  if (!RelocateWithSymbol) {
+    const MCSymbolWasm *SectionSymbol = nullptr;
+    const MCSection &SecA = SymA->getSection();
+    if (SecA.getKind().isText()) {
+      //dbgs() << "FRAGS = " << SecA.getFragmentList().size() << "\n";
+      const MCFragment &Frag = *SecA.begin();
+      //dbgs() << Frag << "\n";
+      SectionSymbol = cast<MCSymbolWasm>(Frag.getAtom());
+    } else {
+      SectionSymbol = cast_or_null<MCSymbolWasm>(SecA.getBeginSymbol());
+    }
+    if (SectionSymbol) {
+      assert(Type != wasm::R_WEBASSEMBLY_TYPE_INDEX_LEB);
+      SectionSymbol->setUsedInReloc();
+      C += Layout.getSymbolOffset(*SymA);
+      WasmRelocationEntry Rec(FixupOffset, SectionSymbol, C, Type, &FixupSection);
+      DEBUG(dbgs() << "WasmRelocX: " << Rec << "\n");
+      assert(FixupSection.getKind().isMetadata());
+      CustomSectionsRelocations[&FixupSection].push_back(Rec);
+      return;
+    }
+  }
+
+  // Relocation other than R_WEBASSEMBLY_TYPE_INDEX_LEB are required to be
+  // against a named symbol.
+  if (SymA->getName().empty() && Type != wasm::R_WEBASSEMBLY_TYPE_INDEX_LEB)
     report_fatal_error("relocations against un-named temporaries are not yet "
                        "supported by wasm");
 
+  if (SymA && Type != wasm::R_WEBASSEMBLY_TYPE_INDEX_LEB)
+    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.
if (!WasmIndices.count(RelEntry.Symbol))
                          RelEntry.Symbol->getName());
     return WasmIndices[RelEntry.Symbol];
   case wasm::R_WEBASSEMBLY_FUNCTION_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;
+    const auto &Section =
+        static_cast<const MCSectionWasm &>(RelEntry.Symbol->getSection());
     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
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;
 
-    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);
+      // Create section symbols for debug sections.
+      // We don't do this for user-defined custom sections becasue they
+      // don't have relocations, and also the names could collide with other
+      // things in the symbol table.
+      if (SectionName.startswith(".custom_section."))
+        Name = SectionName.substr(strlen(".custom_section."));
+      else
+        Name = SectionName;
+
+      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 << " " << WS.isData() << "\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()) {
+      if (WasmIndices.count(&WS) == 0)
+        report_fatal_error("symbol not found in WasmIndices: " + WS.getName());
       Info.ElementIndex = WasmIndices.find(&WS)->second;
-    else if (WS.isDefined())
+    } else if (WS.isDefined()) {
+      if (DataLocations.count(&WS) == 0)
+        report_fatal_error("symbol not found in DataLocations: " +
+                           WS.getName());
       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)
         report_fatal_error("non-symbolic data in .init_array section");
     }
     for (const MCFixup &Fixup : DataFrag.getFixups()) {
       assert(Fixup.getKind() == MCFixup::getKindForSize(is64Bit() ? 8 : 4, false));
       const MCExpr *Expr = Fixup.getValue();
       auto *Sym = dyn_cast<MCSymbolRefExpr>(Expr);
       if (!Sym)
         report_fatal_error("fixups in .init_array should be symbol references");
       if (Sym->getKind() != MCSymbolRefExpr::VK_WebAssembly_FUNCTION)
         report_fatal_error("symbols in .init_array should be for functions");
       auto I = SymbolIndices.find(cast<MCSymbolWasm>(&Sym->getSymbol()));
-      if (I == SymbolIndices.end())
+      if (I == SymbolIndices.end()) {
+        dbgs() << *Sym << "\n";
         report_fatal_error("symbols in .init_array should be defined");
+      }
       uint32_t Index = I->second;
       InitFuncs.push_back(std::make_pair(Priority, Index));
     }
   }
 
   // Write out the Wasm header.
   writeHeader(Asm);
 
   writeTypeSection(FunctionTypes);
   writeImportSection(Imports, DataSize, TableElems.size());
   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();
   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 for 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