[WebAssembly] Linking debug (DWARF) sections from WebAssembly object files

[yurydelendik]

Summary

The debug (custom) sections can be generated using D44184 logic. The linker needs to combine/concat these sections and re-adjust relocation records. (The documentation for relocation records can be found at https://github.com/WebAssembly/tool-conventions/pull/50)

[yurydelendik]

extract getFunctionSizeLength

[ruiu]

For a patch like this, I'd like to know the overview of the debug story in the wasm world first, so that I can review this patch in that story line. I can imagine a lot of different strategies to enable debug info for wasm. Is debug info embedded to wasm file or handled as a separate file? Will it be in DWARF format (looks like so)? Can DWARF really support wasm-style memory abstraction? I'd be really helpful if you share your plan.

[yurydelendik]

In D45118#1054556, @ruiu wrote:

For a patch like this, I'd like to know the overview of the debug story in the wasm world first, so that I can review this patch in that story line. I can imagine a lot of different strategies to enable debug info for wasm... I'd be really helpful if you share your plan.

As now, there is no concrete proposal/specs on the table for wasm debug information and support yet. The D44184 and this patch will export DWARF information as it is generated by LLVM, which is more than enough to export source maps for WebAssembly. At the moment there is some information missing, such as DebugValue, but that's addressable in the future. While this entire work appears to be too experimental, it will help to prototype and identify future debug information format for WebAssembly and start experiments with debuggers earlier.

Is debug info embedded to wasm file or handled as a separate file? Will it be in DWARF format (looks like so)?

The generated by LLVM wasm files will have custom sections with DWARF (?) information in them as it is generated by LLVM. But it is not necessarily what will be published on the web -- the non-functional requirement for the wasm is still to keep binary as small as possible, so the custom sections (including debug one) will not be present in production builds.

Can DWARF really support wasm-style memory abstraction?

We will try to find the way to express that in DWARF structures, if it's not already happening. I'm more concerned about expressing stack machine registers (in DebugValue expressions) via DWARF -- in a worst case, we will need to extend the format to address that.

[sbc100]

If its OK with you I'm going to try and split off the generic custom section handling and land that first. See https://reviews.llvm.org/D45297

[yurydelendik]

In D45118#1058696, @sbc100 wrote:

If its OK with you I'm going to try and split off the generic custom section handling and land that first. See https://reviews.llvm.org/D45297

It is okay with me.

[yurydelendik]

Don't export DefinedSection symbols.

[ruiu]

Since this looks like a straightforward implementation to copy DWARF sections to an output, I think I'm fine with this change overall as long as wasm guys are fine. But I feel more comfortable if you document the debug story somewhere (as a separate doc or as a comment). Currently it is too terse that readers of the code can't tell what is decided and what's not.

[ruiu]

wasm/InputFiles.cpp

309

Is this a new enum? Looks like it doesn't exist at the moment.

[sbc100]

General support for custom sections is here: https://reviews.llvm.org/D45340

Once that lands this change should get a lot smaller I hope.

[yurydelendik]

Rebase on top of D45340

[ruiu]

I don't think I understand what you are trying to achieve with this patch in the first place, as you didn't explain it anywhere. Can you write a patch description properly so that we can understand the intention of the change and what the change is?

wasm/InputChunks.h

189

This function looks a bit odd. This is "InputSection", so an instance of this class is a section. And does a section has "getSection" method? It doesn't sound quite right.

190

We don't use the term "Payload" in lld. We simply call it Data when we have to name it.

Looks like this function is unused? Can you remove this?

wasm/InputFiles.cpp

46

getSizeLength sounds a odd name. Aren't size and length synonyms?

47

Let's be consistent. Since this function returns size_t, it should be size_t.

But I think it is better to use uint64_t when something can be larger than uint32_t.

134

Are you sure that uint8_t is enough?

We don't normally add const when it is obvious.

141

We don't use auto unless it's type is obvious.

187

When you use {}, add braces to all if and else ifs.

I.e.

if (...) {
} else if (...) {
} else {
}

or

if (...) ...;
else if (...) ...;
else ...;

are OK, but

if (...)
else if (...)
else if (...) {
} else ...

isn't.

[yurydelendik]

Rebase at D45579.
Address review comments.

[yurydelendik]

wasm/InputFiles.cpp

46

Renamed to getFunctionCodeOffset

309

Yes, it is. It will be defined in D44184

[yurydelendik]

Rebase on top of D45795

[sbc100]

wasm/InputFiles.cpp

96

Can you use Sym->Function->getFunctionBody() here like you do below?

101

Can you remove this TODO? Shouldn't the value in the file always be section-relative?

331

I don't think undefined section symbols should be possible.

In fact, so we even want defined section symbols in the symbol table? They don't have unique names after all. The way ELF handles this is that all section symbols have local binding so should never get added to symboltable.

wasm/SymbolTable.h

42

We already type with this name in OutputSections.h.

wasm/Symbols.h

191

I don't think we can have undefined section symbols, so maybe we only need one type here?

[yurydelendik]

Rename SyntheticSection
Remove UndefinedSection
Add getFunctionInputOffset
Rebase

[yurydelendik]

wasm/SymbolTable.h

42

Renamed to InputFilesSectionsSet (not sure how to give a better name for structure that holds and maps InputSections to their InputFiles)

[sbc100]

wasm/InputChunks.h

28

No longer needed here? maybe in the cpp file?

wasm/InputFiles.cpp

141

Maybe I'm missing something but SymbolTable seems like the wrong place to store this.
What do you think about my last comments about how these symbols should be local and therefore not be added to symbol table at all?

Why can't you just replace this code with ?

InputSection* IS = CustomSectionsByIndex[Sym->SectionIndex];
return IS->OutputOffset + Reloc.Addend;

I'm probably missing something here.

[yurydelendik]

wasm/InputFiles.cpp

141

What do you think about my last comments about how these symbols should be local and therefore not be added to symbol table at all?

Yeah, I'm trying to figure this out atm

Why can't you just replace this code with ?

Index CustomSectionsByIndex in expectes InputFile section index, but Sym->SectionIndex just contains index for symbol data (not associated with output or input section index).

[yurydelendik]

Remove tracking of InputSection from Symtab.

[sbc100]

Looking much better in general

wasm/Symbols.h

178

This extra symbol type seems a little strange to me...

Could we put the getOutputSectionIndex/setOutputSectionIndex in the base SectionSymbol class so we don't need a separate CombinedSection?

Then we could want to call getOutputSectionIndex on all of the DefinedSection object too.

wasm/Writer.cpp

777

You can just use S->getName() I think

789

I don't see how you can use SymbolIndex here without incrementing it.

793

This loop seems like its doing some different things.

I wonder if we can find a way to build CombinedSectionSymbols in some other phase? For example perhaps in createCustomSections? Since for each custom section we need such a symbol?

798

Can you replace these three lines with Sym = &P.first->second and avoid the continue?

[yurydelendik]

Simplify assignSymtab for CombinedSectionSymbols
Fix createCustomSections for non-referred sections

[yurydelendik]

wasm/Symbols.h

178

The CombinedSection comprised from InputChunks of one or more DefinedSections and only CombinedSection will be needed getOutputSectionIndex() for linking section. We have getOutputSymbolIndex() for reloc entries, that is assigned in the assignSymtab.

wasm/Writer.cpp

789

It is incremented at OutputSym->setOutputSymbolIndex(SymbolIndex++); below

[yurydelendik]

Move CombinedSectionSymbols creation
Add test

[sbc100]

wasm/InputFiles.cpp

47

I don't think you need "const" with ArrayRef as Refs are immutable already.

83

Section symbols are always defined. So you can just cast here and never return 0.

Also, perhaps getSectionSymbol should just return DefinedSection instead?

331

The error message is little confusing. How about "section symbols cannot be undefined"

wasm/Symbols.h

191

Hot about this: We can have single SectionSymbol which we know is always defined. It can have getOutputSectionIndex() / setOutputSectionIndex() as well as const InputSection *Section;.

The Writer could then just pick the first SectionSymbol with a given name to be the in the symbol table? Then we wouldn't need to create any new symbols and we wouldn't need CombinedSection class at all.

Would that work? I could be missing something.

wasm/Writer.cpp

392

Is this just to save the Strings? If so does Saver.save() work?

490

A pattern use elsewhere is to simply to assume you can cast to the ramaining type in the final else.

e.g:

} else {
   // At this point we know we have CombinedSection 
   auto *S = cast<CombinedSection>(Sym));
   ...
}

That way the cast will fail at runtime if anything goes wrong and you don't need the assert case

[yurydelendik]

Refactor SectionSymbol (remove CombinedSection and DefinedSection)
Remove InternedStrings
Review items

[sbc100]

I like this better. Almost ready to land I think.

I'm mentioned that we can/should remove as much of the checking for ".debug_" as we can since I don't think change is specific the debug sections really, it should work for any custom section that want to include relocations.

@ruiu do you understand what are trying to do here?

wasm/Writer.cpp

391

I think we can drop the second part of this condition perhaps?

394

now I guess it should be "code, data, or custom sections"

759

SectionSymbolIndices?

778

Can we drop the first clause of this condition?

779

.count(Name) == 0?

[yurydelendik]

Remove startswith(".debug") checks
Rename SectionSymbolIndices

[sbc100]

wasm/InputFiles.cpp

80

No need for this cast anymore

140

No need for this cast anymore, or the if I guess

[sbc100]

We normally use [WebAssembly] at the start of the CL description.

[yurydelendik]

Remove cast<SectionSymbol>

[sbc100]

wasm/Writer.cpp

744

I don't think you need this since sections symbols are always local right?

[yurydelendik]

Remove isa<SectionSymbol> check

[sbc100]

Fixed in rLLD331566

wasm/InputChunks.h

 
 #ifndef LLD_WASM_INPUT_CHUNKS_H
 #define LLD_WASM_INPUT_CHUNKS_H
 
 #include "Config.h"
 #include "InputFiles.h"
 #include "lld/Common/ErrorHandler.h"
 #include "llvm/Object/Wasm.h"
+#include "llvm/Support/LEB128.h"
 
 using llvm::object::WasmSection;
 using llvm::object::WasmSegment;
 using llvm::wasm::WasmFunction;
 using llvm::wasm::WasmRelocation;
 using llvm::wasm::WasmSignature;
 
 namespace llvm {
public:
 
   static bool classof(const InputChunk *C) {
     return C->kind() == InputChunk::Function ||
            C->kind() == InputChunk::SyntheticFunction;
   }
 
   StringRef getName() const override { return Function->Name; }
   uint32_t getComdat() const override { return Function->Comdat; }
+  const ArrayRef<uint8_t> getFunctionBody() const { return Function->Body; }
   uint32_t getFunctionIndex() const { return FunctionIndex.getValue(); }
   bool hasFunctionIndex() const { return FunctionIndex.hasValue(); }
   void setFunctionIndex(uint32_t Index);
   uint32_t getTableIndex() const { return TableIndex.getValue(); }
   bool hasTableIndex() const { return TableIndex.hasValue(); }
   void setTableIndex(uint32_t Index);
 
   const WasmSignature &Signature;
public:
   InputSection(const WasmSection &S, ObjFile *F)
       : InputChunk(F, InputChunk::Section), Section(S) {
     assert(Section.Type == llvm::wasm::WASM_SEC_CUSTOM);
   }
 
   StringRef getName() const override { return Section.Name; }
   uint32_t getComdat() const override { return UINT32_MAX; }
 
 protected:
   ArrayRef<uint8_t> data() const override { return Section.Content; }
 
   // Offset within the input section.  This is only zero since this chunk
   // type represents an entire input section, not part of one.
   uint32_t getInputSectionOffset() const override { return 0; }
 
   const WasmSection &Section;
 };
 
 } // namespace wasm
 
 std::string toString(const wasm::InputChunk *);
 } // namespace lld
 
 #endif // LLD_WASM_INPUT_CHUNKS_H

wasm/InputChunks.cpp

case R_WEBASSEMBLY_MEMORY_ADDR_LEB:
       break;
     case R_WEBASSEMBLY_TABLE_INDEX_SLEB:
     case R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
       ExistingValue = static_cast<uint32_t>(decodeSLEB128(Loc));
       encodeSLEB128(static_cast<int32_t>(Value), Loc, 5);
       break;
     case R_WEBASSEMBLY_TABLE_INDEX_I32:
     case R_WEBASSEMBLY_MEMORY_ADDR_I32:
+    case R_WEBASSEMBLY_FUNCTION_OFFSET_I32:
+    case R_WEBASSEMBLY_SECTION_OFFSET_I32:
       ExistingValue = static_cast<uint32_t>(read32le(Loc));
       write32le(Loc, Value);
       break;
     default:
       llvm_unreachable("unknown relocation type");
     }
 
     uint32_t ExpectedValue = File->calcExpectedValue(Rel);
for (const WasmRelocation &Rel : Relocations) {
     writeUleb128(OS, Rel.Type, "reloc type");
     writeUleb128(OS, Rel.Offset + Off, "reloc offset");
     writeUleb128(OS, File->calcNewIndex(Rel), "reloc index");
 
     switch (Rel.Type) {
     case R_WEBASSEMBLY_MEMORY_ADDR_LEB:
     case R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
     case R_WEBASSEMBLY_MEMORY_ADDR_I32:
+    case R_WEBASSEMBLY_FUNCTION_OFFSET_I32:
+    case R_WEBASSEMBLY_SECTION_OFFSET_I32:
       writeUleb128(OS, Rel.Addend, "reloc addend");
       break;
     }
   }
 }
 
 void InputFunction::setFunctionIndex(uint32_t Index) {
   DEBUG(dbgs() << "InputFunction::setFunctionIndex: " << getName() << " -> "

wasm/InputFiles.h

 //===- InputFiles.h ---------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_WASM_INPUT_FILES_H
 #define LLD_WASM_INPUT_FILES_H
 
 #include "Symbols.h"
 #include "lld/Common/LLVM.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
+#include "llvm/ADT/StringMap.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/Wasm.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include <vector>
 
 using llvm::object::Archive;
 using llvm::object::WasmObjectFile;
 using llvm::object::WasmSection;
public:
   std::vector<bool> TypeIsUsed;
   // Maps function indices to table indices
   std::vector<uint32_t> TableEntries;
   std::vector<bool> UsedComdats;
   std::vector<InputSegment *> Segments;
   std::vector<InputFunction *> Functions;
   std::vector<InputGlobal *> Globals;
   std::vector<InputSection *> CustomSections;
+  llvm::StringMap<InputSection *> CustomSectionSymbols;
 
   ArrayRef<Symbol *> getSymbols() const { return Symbols; }
   Symbol *getSymbol(uint32_t Index) const { return Symbols[Index]; }
   FunctionSymbol *getFunctionSymbol(uint32_t Index) const;
   DataSymbol *getDataSymbol(uint32_t Index) const;
   GlobalSymbol *getGlobalSymbol(uint32_t Index) const;
+  SectionSymbol *getSectionSymbol(uint32_t Index) const;
 
 private:
   Symbol *createDefined(const WasmSymbol &Sym);
   Symbol *createUndefined(const WasmSymbol &Sym);
 
   bool isExcludedByComdat(InputChunk *Chunk) const;
 
   // List of all symbols referenced or defined by this file.

wasm/InputFiles.cpp

 #include "Config.h"
 #include "InputChunks.h"
 #include "InputGlobal.h"
 #include "SymbolTable.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "llvm/Object/Binary.h"
 #include "llvm/Object/Wasm.h"
+#include "llvm/Support/LEB128.h"
 #include "llvm/Support/raw_ostream.h"
 
 #define DEBUG_TYPE "lld"
 
 using namespace lld;
 using namespace lld::wasm;
 
 using namespace llvm;
Optional<MemoryBufferRef> lld::wasm::readFile(StringRef Path) {
   }
   std::unique_ptr<MemoryBuffer> &MB = *MBOrErr;
   MemoryBufferRef MBRef = MB->getMemBufferRef();
   make<std::unique_ptr<MemoryBuffer>>(std::move(MB)); // take MB ownership
 
   return MBRef;
 }
 
+static size_t getFunctionCodeOffset(const ArrayRef<uint8_t> FunctionBody) {
+  unsigned Count;
+  llvm::decodeULEB128(FunctionBody.data(), &Count);
+  return Count;
+}
+
 void ObjFile::dumpInfo() const {
   log("info for: " + getName() +
       "\n              Symbols : " + Twine(Symbols.size()) +
       "\n     Function Imports : " + Twine(WasmObj->getNumImportedFunctions()) +
       "\n       Global Imports : " + Twine(WasmObj->getNumImportedGlobals()));
 }
 
 // Relocations contain either symbol or type indices.  This function takes a

 // location.  It is useful for catching bugs in the compiler and linker.
 uint32_t ObjFile::calcExpectedValue(const WasmRelocation &Reloc) const {
   switch (Reloc.Type) {
   case R_WEBASSEMBLY_TABLE_INDEX_I32:
   case R_WEBASSEMBLY_TABLE_INDEX_SLEB: {
     const WasmSymbol& Sym = WasmObj->syms()[Reloc.Index];
     return TableEntries[Sym.Info.ElementIndex];
   }
   case R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
   case R_WEBASSEMBLY_MEMORY_ADDR_I32:
   case R_WEBASSEMBLY_MEMORY_ADDR_LEB: {
     const WasmSymbol& Sym = WasmObj->syms()[Reloc.Index];
     if (Sym.isUndefined())
       return 0;
     const WasmSegment& Segment = WasmObj->dataSegments()[Sym.Info.DataRef.Segment];
     return Segment.Data.Offset.Value.Int32 + Sym.Info.DataRef.Offset +
            Reloc.Addend;
   }
+  case R_WEBASSEMBLY_FUNCTION_OFFSET_I32: {
+    const WasmSymbol &Sym = WasmObj->syms()[Reloc.Index];
+    if (Sym.isUndefined())
+      return 0;
+    const WasmFunction &Function =
+        WasmObj->functions()[Sym.Info.ElementIndex -
+                             WasmObj->getNumImportedFunctions()];
+    size_t FunctionCodeOffset = getFunctionCodeOffset(Function.Body);
+    return Function.CodeSectionOffset + FunctionCodeOffset + Reloc.Addend;
+  }
+  case R_WEBASSEMBLY_SECTION_OFFSET_I32:
+    return Reloc.Addend; // TODO absolute to wasm file start?
   case R_WEBASSEMBLY_TYPE_INDEX_LEB:
     return Reloc.Index;
   case R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
   case R_WEBASSEMBLY_GLOBAL_INDEX_LEB: {
     const WasmSymbol& Sym = WasmObj->syms()[Reloc.Index];
     return Sym.Info.ElementIndex;
   }
   default:
if (auto *Sym = dyn_cast<DefinedData>(getDataSymbol(Reloc.Index)))
       return Sym->getVirtualAddress() + Reloc.Addend;
     return 0;
   case R_WEBASSEMBLY_TYPE_INDEX_LEB:
     return TypeMap[Reloc.Index];
   case R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
     return getFunctionSymbol(Reloc.Index)->getFunctionIndex();
   case R_WEBASSEMBLY_GLOBAL_INDEX_LEB:
     return getGlobalSymbol(Reloc.Index)->getGlobalIndex();
+  case R_WEBASSEMBLY_FUNCTION_OFFSET_I32:
+    if (auto *Sym = dyn_cast<DefinedFunction>(getFunctionSymbol(Reloc.Index))) {
+      size_t FunctionCodeOffset =
+          getFunctionCodeOffset(Sym->Function->getFunctionBody());
+      return Sym->Function->OutputOffset + FunctionCodeOffset + Reloc.Addend;
+    }
+    return 0;
+  case R_WEBASSEMBLY_SECTION_OFFSET_I32:
+    if (auto *Sym = dyn_cast<DefinedSection>(getSectionSymbol(Reloc.Index))) {
+      const SymbolTable::SyntheticSection &SyntheticSection =
+          Symtab->SyntheticSections[Sym->SectionIndex];
+      const auto &InputSection = SyntheticSection.find(this);
+      if (InputSection != SyntheticSection.end())
+        return InputSection->second->OutputOffset + Reloc.Addend;
+    }
+    return 0;
   default:
     llvm_unreachable("unknown relocation type");
   }
 }
 
 void ObjFile::parse() {
   // Parse a memory buffer as a wasm file.
   DEBUG(dbgs() << "Parsing object: " << toString(this) << "\n");
for (uint32_t Index = 0; Index < Seg.Functions.size(); Index++) {
       TableEntries[FunctionIndex] = Offset + Index;
     }
   }
 
   // Find the code and data sections.  Wasm objects can have at most one code
   // and one data section.
   for (const SectionRef &Sec : WasmObj->sections()) {
     const WasmSection &Section = WasmObj->getWasmSection(Sec);
-    if (Section.Type == WASM_SEC_CODE)
+    if (Section.Type == WASM_SEC_CODE) {
       CodeSection = &Section;
-    else if (Section.Type == WASM_SEC_DATA)
+    } else if (Section.Type == WASM_SEC_DATA) {
       DataSection = &Section;
-    else if (Section.Type == WASM_SEC_CUSTOM)
+    } else if (Section.Type == WASM_SEC_CUSTOM) {
       CustomSections.emplace_back(make<InputSection>(Section, this));
+      CustomSections.back()->copyRelocations(Section);
+      if (Section.Name.startswith(".debug_")) {
+        // Recording debug sections (starts) as symbols.
+        CustomSectionSymbols.insert(std::pair<StringRef, InputSection *>(
+            Section.Name, CustomSections.back()));
+      }
+    }
   }
 
   TypeMap.resize(getWasmObj()->types().size());
   TypeIsUsed.resize(getWasmObj()->types().size(), false);
 
   ArrayRef<StringRef> Comdats = WasmObj->linkingData().Comdats;
   UsedComdats.resize(Comdats.size());
   for (unsigned I = 0; I < Comdats.size(); ++I)

 FunctionSymbol *ObjFile::getFunctionSymbol(uint32_t Index) const {
   return cast<FunctionSymbol>(Symbols[Index]);
 }
 
 GlobalSymbol *ObjFile::getGlobalSymbol(uint32_t Index) const {
   return cast<GlobalSymbol>(Symbols[Index]);
 }
 
+SectionSymbol *ObjFile::getSectionSymbol(uint32_t Index) const {
+  return cast<SectionSymbol>(Symbols[Index]);
+}
+
 DataSymbol *ObjFile::getDataSymbol(uint32_t Index) const {
   return cast<DataSymbol>(Symbols[Index]);
 }
 
 Symbol *ObjFile::createDefined(const WasmSymbol &Sym) {
   if (!Sym.isDefined())
     return nullptr;
 
case WASM_SYMBOL_TYPE_DATA: {
 
     uint32_t Offset = Sym.Info.DataRef.Offset;
     uint32_t Size = Sym.Info.DataRef.Size;
 
     if (Sym.isBindingLocal())
       return make<DefinedData>(Name, Flags, this, Seg, Offset, Size);
     return Symtab->addDefinedData(Name, Flags, this, Seg, Offset, Size);
   }
-  case WASM_SYMBOL_TYPE_GLOBAL:
+  case WASM_SYMBOL_TYPE_GLOBAL: {
     InputGlobal *Global =
         Globals[Sym.Info.ElementIndex - WasmObj->getNumImportedGlobals()];
     if (Sym.isBindingLocal())
       return make<DefinedGlobal>(Name, Flags, this, Global);
     return Symtab->addDefinedGlobal(Name, Flags, this, Global);
   }
-  llvm_unreachable("unkown symbol kind");
+  case WASM_SYMBOL_TYPE_SECTION: {
+    if (Sym.Info.SectionCode != WASM_SEC_CUSTOM)
+      llvm_unreachable("invalid section symbol");
+    InputSection *Section = CustomSectionSymbols[Sym.Info.SectionName];
+    return Symtab->addDefinedSection(Name, Flags, this, Section);
+  }
+  }
+  llvm_unreachable("unknown symbol kind");
 }
 
 Symbol *ObjFile::createUndefined(const WasmSymbol &Sym) {
   StringRef Name = Sym.Info.Name;
   uint32_t Flags = Sym.Info.Flags;
 
   switch (Sym.Info.Kind) {
   case WASM_SYMBOL_TYPE_FUNCTION:
     return Symtab->addUndefinedFunction(Name, Flags, this, Sym.FunctionType);
   case WASM_SYMBOL_TYPE_DATA:
     return Symtab->addUndefinedData(Name, Flags, this);
   case WASM_SYMBOL_TYPE_GLOBAL:
     return Symtab->addUndefinedGlobal(Name, Flags, this, Sym.GlobalType);
+  case WASM_SYMBOL_TYPE_SECTION:
+    return Symtab->addUndefinedSection(Name, Flags, this);
   }
-  llvm_unreachable("unkown symbol kind");
+  llvm_unreachable("unknown symbol kind");
 }
 
 void ArchiveFile::parse() {
   // Parse a MemoryBufferRef as an archive file.
   DEBUG(dbgs() << "Parsing library: " << toString(this) << "\n");
   File = CHECK(Archive::create(MB), toString(this));
 
   // Read the symbol table to construct Lazy symbols.

wasm/OutputSections.h

 // separately and are instead synthesized by the linker.
 class CustomSection : public OutputSection {
 public:
   CustomSection(std::string Name, ArrayRef<InputSection *> InputSections);
   size_t getSize() const override {
     return Header.size() + NameData.size() + PayloadSize;
   }
   void writeTo(uint8_t *Buf) override;
+  uint32_t numRelocations() const override;
+  void writeRelocations(raw_ostream &OS) const override;
 
 protected:
   size_t PayloadSize;
   ArrayRef<InputSection *> InputSections;
   std::string NameData;
 };
 
 } // namespace wasm
 } // namespace lld
 
 #endif // LLD_WASM_OUTPUT_SECTIONS_H

wasm/OutputSections.cpp

void CustomSection::writeTo(uint8_t *Buf) {
   Buf += Header.size();
   memcpy(Buf, NameData.data(), NameData.size());
   Buf += NameData.size();
 
   // Write custom sections payload
   parallelForEach(InputSections,
                   [&](const InputSection *Section) { Section->writeTo(Buf); });
 }
+
+uint32_t CustomSection::numRelocations() const {
+  uint32_t Count = 0;
+  for (const InputSection *InputSect : InputSections)
+    Count += InputSect->NumRelocations();
+  return Count;
+}
+
+void CustomSection::writeRelocations(raw_ostream &OS) const {
+  for (const InputSection *S : InputSections)
+    S->writeRelocations(OS);
+}

wasm/SymbolTable.h

 //===- SymbolTable.h --------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_WASM_SYMBOL_TABLE_H
 #define LLD_WASM_SYMBOL_TABLE_H
 
 #include "InputFiles.h"
 #include "Symbols.h"
 #include "llvm/ADT/CachedHashString.h"
+#include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/Support/raw_ostream.h"
 
 using llvm::wasm::WasmGlobalType;
 using llvm::wasm::WasmSignature;
 
 namespace lld {
 namespace wasm {

 // conflicts. For example, obviously, a defined symbol is better than
 // an undefined symbol. Or, if there's a conflict between a lazy and a
 // undefined, it'll read an archive member to read a real definition
 // to replace the lazy symbol. The logic is implemented in the
 // add*() functions, which are called by input files as they are parsed.
 // There is one add* function per symbol type.
 class SymbolTable {
 public:
+  using SyntheticSection = llvm::DenseMap<InputFile *, InputSection *>;
+
   void addFile(InputFile *File);
 
   std::vector<ObjFile *> ObjectFiles;
   std::vector<InputFunction *> SyntheticFunctions;
   std::vector<InputGlobal *> SyntheticGlobals;
+  std::vector<SyntheticSection> SyntheticSections;
 
   void reportRemainingUndefines();
 
   ArrayRef<Symbol *> getSymbols() const { return SymVector; }
   Symbol *find(StringRef Name);
 
   Symbol *addDefinedFunction(StringRef Name, uint32_t Flags, InputFile *File,
                              InputFunction *Function);
   Symbol *addDefinedData(StringRef Name, uint32_t Flags, InputFile *File,
                          InputSegment *Segment, uint32_t Address,
                          uint32_t Size);
   Symbol *addDefinedGlobal(StringRef Name, uint32_t Flags, InputFile *File,
                            InputGlobal *G);
+  Symbol *addDefinedSection(StringRef Name, uint32_t Flags, InputFile *File,
+                            InputSection *S);
 
   Symbol *addUndefinedFunction(StringRef Name, uint32_t Flags, InputFile *File,
                                const WasmSignature *Signature);
   Symbol *addUndefinedData(StringRef Name, uint32_t Flags, InputFile *File);
   Symbol *addUndefinedGlobal(StringRef Name, uint32_t Flags, InputFile *File,
                              const WasmGlobalType *Type);
+  Symbol *addUndefinedSection(StringRef Name, uint32_t Flags, InputFile *File);
 
   void addLazy(ArchiveFile *F, const Archive::Symbol *Sym);
 
   bool addComdat(StringRef Name);
 
   DefinedData *addSyntheticDataSymbol(StringRef Name, uint32_t Flags);
   DefinedGlobal *addSyntheticGlobal(StringRef Name, uint32_t Flags,
                                     InputGlobal *Global);

wasm/SymbolTable.cpp

Symbol *SymbolTable::addDefinedGlobal(StringRef Name, uint32_t Flags,
 
   checkGlobalType(S, File, &Global->getType());
 
   if (shouldReplace(S, File, Flags))
     replaceSymbol<DefinedGlobal>(S, Name, Flags, File, Global);
   return S;
 }
 
+Symbol *SymbolTable::addDefinedSection(StringRef Name, uint32_t Flags,
+                                       InputFile *File, InputSection *Section) {
+  DEBUG(dbgs() << "addDefinedSection:" << Name << "\n");
+  Symbol *S;
+  bool WasInserted;
+  std::tie(S, WasInserted) = insert(Name);
+
+  if (WasInserted || S->isLazy() || isa<UndefinedSection>(S)) {
+    replaceSymbol<DefinedSection>(S, Name, Flags, SyntheticSections.size());
+    SyntheticSections.emplace_back();
+    SyntheticSections.back()[File] = Section;
+    return S;
+  }
+
+  assert(isa<DefinedSection>(S));
+  auto &SectionItems =
+      SyntheticSections[dyn_cast<DefinedSection>(S)->SectionIndex];
+  SectionItems[File] = Section;
+  return S;
+}
+
 Symbol *SymbolTable::addUndefinedFunction(StringRef Name, uint32_t Flags,
                                           InputFile *File,
                                           const WasmSignature *Sig) {
   DEBUG(dbgs() << "addUndefinedFunction: " << Name << "\n");
 
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name);
if (WasInserted)
     replaceSymbol<UndefinedGlobal>(S, Name, Flags, File, Type);
   else if (auto *Lazy = dyn_cast<LazySymbol>(S))
     Lazy->fetch();
   else if (S->isDefined())
     checkGlobalType(S, File, Type);
   return S;
 }
 
+Symbol *SymbolTable::addUndefinedSection(StringRef Name, uint32_t Flags,
+                                         InputFile *File) {
+  DEBUG(dbgs() << "addUndefinedSection:" << Name << "\n");
+
+  Symbol *S;
+  bool WasInserted;
+  std::tie(S, WasInserted) = insert(Name);
+
+  if (WasInserted)
+    replaceSymbol<UndefinedSection>(S, Name, Flags);
+  assert(isa<DefinedSection>(S));
+  return S;
+}
+
 void SymbolTable::addLazy(ArchiveFile *File, const Archive::Symbol *Sym) {
   DEBUG(dbgs() << "addLazy: " << Sym->getName() << "\n");
   StringRef Name = Sym->getName();
 
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name);
 

wasm/Symbols.h

 namespace lld {
 namespace wasm {
 
 class InputFile;
 class InputChunk;
 class InputSegment;
 class InputFunction;
 class InputGlobal;
+class InputSection;
 
 #define INVALID_INDEX UINT32_MAX
 
 // The base class for real symbol classes.
 class Symbol {
 public:
   enum Kind {
     DefinedFunctionKind,
     DefinedDataKind,
     DefinedGlobalKind,
+    DefinedSectionKind,
     UndefinedFunctionKind,
     UndefinedDataKind,
     UndefinedGlobalKind,
+    UndefinedSectionKind,
     LazyKind,
   };
 
   Kind kind() const { return SymbolKind; }
 
   bool isDefined() const {
     return SymbolKind == DefinedFunctionKind || SymbolKind == DefinedDataKind ||
-           SymbolKind == DefinedGlobalKind;
+           SymbolKind == DefinedGlobalKind || SymbolKind == DefinedSectionKind;
   }
 
   bool isUndefined() const {
     return SymbolKind == UndefinedFunctionKind ||
-           SymbolKind == UndefinedDataKind || SymbolKind == UndefinedGlobalKind;
+           SymbolKind == UndefinedDataKind ||
+           SymbolKind == UndefinedGlobalKind ||
+           SymbolKind == UndefinedSectionKind;
   }
 
   bool isLazy() const { return SymbolKind == LazyKind; }
 
   bool isLocal() const;
   bool isWeak() const;
   bool isHidden() const;
 
UndefinedFunction(StringRef Name, uint32_t Flags, InputFile *File = nullptr,
                     const WasmSignature *Type = nullptr)
       : FunctionSymbol(Name, UndefinedFunctionKind, Flags, File, Type) {}
 
   static bool classof(const Symbol *S) {
     return S->kind() == UndefinedFunctionKind;
   }
 };
 
+class SectionSymbol : public Symbol {
+public:
+  static bool classof(const Symbol *S) {
+    return S->kind() == DefinedSectionKind || S->kind() == UndefinedSectionKind;
+  }
+
+  SectionSymbol(StringRef Name, Kind K, uint32_t Flags, InputFile *F = nullptr)
+      : Symbol(Name, K, Flags, F) {}
+
+  uint32_t getOutputSymbolIndex() const;
+  void setOutputSymbolIndex(uint32_t Index);
+
+protected:
+  uint32_t OutputSymbolIndex = INVALID_INDEX;
+};
+
+class DefinedSection : public SectionSymbol {
+public:
+  DefinedSection(StringRef Name, uint32_t Flags, size_t Index)
+      : SectionSymbol(Name, DefinedSectionKind, Flags), SectionIndex(Index) {}
+
+  static bool classof(const Symbol *S) {
+    return S->kind() == DefinedSectionKind;
+  }
+
+  size_t SectionIndex;
+};
+
+class UndefinedSection : public SectionSymbol {
+public:
+  UndefinedSection(StringRef Name, uint32_t Flags)
+      : SectionSymbol(Name, UndefinedSectionKind, Flags) {}
+
+  static bool classof(const Symbol *S) {
+    return S->kind() == UndefinedSectionKind;
+  }
+};
+
 class DataSymbol : public Symbol {
 public:
   static bool classof(const Symbol *S) {
     return S->kind() == DefinedDataKind || S->kind() == UndefinedDataKind;
   }
 
 protected:
   DataSymbol(StringRef Name, Kind K, uint32_t Flags, InputFile *F)

 
 // A buffer class that is large enough to hold any Symbol-derived
 // object. We allocate memory using this class and instantiate a symbol
 // using the placement new.
 union SymbolUnion {
   alignas(DefinedFunction) char A[sizeof(DefinedFunction)];
   alignas(DefinedData) char B[sizeof(DefinedData)];
   alignas(DefinedGlobal) char C[sizeof(DefinedGlobal)];
+  alignas(DefinedSection) char I[sizeof(DefinedSection)];
   alignas(LazySymbol) char D[sizeof(LazySymbol)];
   alignas(UndefinedFunction) char E[sizeof(UndefinedFunction)];
   alignas(UndefinedData) char F[sizeof(UndefinedData)];
   alignas(UndefinedGlobal) char G[sizeof(UndefinedGlobal)];
+  alignas(UndefinedSection) char J[sizeof(UndefinedSection)];
 };
 
 template <typename T, typename... ArgT>
 T *replaceSymbol(Symbol *S, ArgT &&... Arg) {
   static_assert(std::is_trivially_destructible<T>(),
                 "Symbol types must be trivially destructible");
   static_assert(sizeof(T) <= sizeof(SymbolUnion), "Symbol too small");
   static_assert(alignof(T) <= alignof(SymbolUnion),

wasm/Symbols.cpp

 
 WasmSymbolType Symbol::getWasmType() const {
   if (isa<FunctionSymbol>(this))
     return llvm::wasm::WASM_SYMBOL_TYPE_FUNCTION;
   if (isa<DataSymbol>(this))
     return llvm::wasm::WASM_SYMBOL_TYPE_DATA;
   if (isa<GlobalSymbol>(this))
     return llvm::wasm::WASM_SYMBOL_TYPE_GLOBAL;
+  if (isa<SectionSymbol>(this))
+    return llvm::wasm::WASM_SYMBOL_TYPE_SECTION;
   llvm_unreachable("invalid symbol kind");
 }
 
 InputChunk *Symbol::getChunk() const {
   if (auto *F = dyn_cast<DefinedFunction>(this))
     return F->Function;
   if (auto *D = dyn_cast<DefinedData>(this))
     return D->Segment;

 }
 
 DefinedGlobal::DefinedGlobal(StringRef Name, uint32_t Flags, InputFile *File,
                              InputGlobal *Global)
     : GlobalSymbol(Name, DefinedGlobalKind, Flags, File,
                    Global ? &Global->getType() : nullptr),
       Global(Global) {}
 
+uint32_t SectionSymbol::getOutputSymbolIndex() const {
+  DEBUG(dbgs() << "getOutputSymbolIndex: " << getName() << "\n");
+  assert(OutputSymbolIndex != INVALID_INDEX);
+  return OutputSymbolIndex;
+}
+
+void SectionSymbol::setOutputSymbolIndex(uint32_t Index) {
+  DEBUG(dbgs() << "setOutputSymbolIndex: " << getName() << " -> " << Index
+               << "\n");
+  assert(Index != INVALID_INDEX);
+  OutputSymbolIndex = Index;
+}
+
 void LazySymbol::fetch() { cast<ArchiveFile>(File)->addMember(&ArchiveSymbol); }
 
 std::string lld::toString(const wasm::Symbol &Sym) {
   if (Config->Demangle)
     if (Optional<std::string> S = demangleItanium(Sym.getName()))
       return *S;
   return Sym.getName();
 }
 
 std::string lld::toString(wasm::Symbol::Kind Kind) {
   switch (Kind) {
   case wasm::Symbol::DefinedFunctionKind:
     return "DefinedFunction";
   case wasm::Symbol::DefinedDataKind:
     return "DefinedData";
   case wasm::Symbol::DefinedGlobalKind:
     return "DefinedGlobal";
+  case wasm::Symbol::DefinedSectionKind:
+    return "DefinedSection";
   case wasm::Symbol::UndefinedFunctionKind:
     return "UndefinedFunction";
   case wasm::Symbol::UndefinedDataKind:
     return "UndefinedData";
   case wasm::Symbol::UndefinedGlobalKind:
     return "UndefinedGlobal";
+  case wasm::Symbol::UndefinedSectionKind:
+    return "UndefinedSection";
   case wasm::Symbol::LazyKind:
     return "LazyKind";
   }
   llvm_unreachable("invalid symbol kind");
 }
 
 std::string lld::toString(WasmSymbolType Type) {
   switch (Type) {
   case llvm::wasm::WASM_SYMBOL_TYPE_FUNCTION:
     return "Function";
   case llvm::wasm::WASM_SYMBOL_TYPE_DATA:
     return "Data";
   case llvm::wasm::WASM_SYMBOL_TYPE_GLOBAL:
     return "Global";
+  case llvm::wasm::WASM_SYMBOL_TYPE_SECTION:
+    return "Section";
   }
   llvm_unreachable("invalid symbol type");
 }

wasm/Writer.cpp

private:
   uint32_t lookupType(const WasmSignature &Sig);
   uint32_t registerType(const WasmSignature &Sig);
 
   void createCtorFunction();
   void calculateInitFunctions();
   void assignIndexes();
   void calculateImports();
   void calculateExports();
+  void calculateCustomSections();
   void assignSymtab();
   void calculateTypes();
   void createOutputSegments();
   void layoutMemory();
   void createHeader();
   void createSections();
   SyntheticSection *createSyntheticSection(uint32_t Type, StringRef Name = "");
 
private:
   // Elements that are used to construct the final output
   std::string Header;
   std::vector<OutputSection *> OutputSections;
 
   std::unique_ptr<FileOutputBuffer> Buffer;
 
   std::vector<OutputSegment *> Segments;
   llvm::SmallDenseMap<StringRef, OutputSegment *> SegmentMap;
+  llvm::StringSet<> InternedNames;
 };
 
 } // anonymous namespace
 
 void Writer::createImportSection() {
   uint32_t NumImports = ImportedSymbols.size();
   if (Config->ImportMemory)
     ++NumImports;
for (const Symbol *Sym : ExportedSymbols) {
     else if (isa<DefinedData>(Sym))
       Export = {Name, WASM_EXTERNAL_GLOBAL, FakeGlobalIndex++};
     else
       llvm_unreachable("unexpected symbol type");
     writeExport(OS, Export);
   }
 }
 
-void Writer::createCustomSections() {
+void Writer::calculateCustomSections() {
   log("createCustomSections");
-  for (ObjFile *File : Symtab->ObjectFiles)
-    for (InputSection *Section : File->CustomSections)
-      CustomSectionMapping[Section->getName()].push_back(Section);
-
-  for (auto &Pair : CustomSectionMapping) {
-    StringRef Name = Pair.first();
+  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
       if (Name == "linking" || Name == "name" || Name.startswith("reloc."))
         continue;
+      // .. or it is a debug section
+      if (StripDebug && Name.startswith(".debug_"))
+        continue;
+      CustomSectionMapping[Name].push_back(Section);
+    }
+  }
+}
+
+void Writer::createCustomSections() {
+  log("createCustomSections");
+  for (auto &Pair : CustomSectionMapping) {
+    StringRef Name = Pair.first();
     DEBUG(dbgs() << "createCustomSection: " << Name << "\n");
     OutputSections.push_back(make<CustomSection>(Name, Pair.second));
   }
 }
 
 void Writer::createElemSection() {
   if (IndirectFunctions.empty())
     return;
for (size_t i = 0; i < OrigSize; i++) {
     if (!Count)
       continue;
 
     StringRef Name;
     if (OSec->Type == WASM_SEC_DATA)
       Name = "reloc.DATA";
     else if (OSec->Type == WASM_SEC_CODE)
       Name = "reloc.CODE";
+    else if (OSec->Type == WASM_SEC_CUSTOM &&
+             StringRef(OSec->Name).startswith(".debug"))
+      Name = InternedNames.insert("reloc." + OSec->Name).first->getKey();
     else
-      llvm_unreachable("relocations only supported for code and data");
+      llvm_unreachable("relocations only supported for code, data and debug");
 
     SyntheticSection *Section = createSyntheticSection(WASM_SEC_CUSTOM, Name);
     raw_ostream &OS = Section->getStream();
     writeUleb128(OS, OSec->Type, "reloc section");
+    if (OSec->Type == WASM_SEC_CUSTOM)
+      writeStr(OS, OSec->Name, "reloc custom section name");
     writeUleb128(OS, Count, "reloc count");
     OSec->writeRelocations(OS);
   }
 }
 
 static uint32_t getWasmFlags(const Symbol *Sym) {
   uint32_t Flags = 0;
   if (Sym->isLocal())

 private:
   uint32_t Type;
   std::string Body;
 
 public:
   raw_string_ostream OS{Body};
 };
 
+static StringRef getSectionNameFromSymbol(const DefinedSection *Sym) {
+  const auto &SyntheticSection = Symtab->SyntheticSections[Sym->SectionIndex];
+  const auto &InputSection = SyntheticSection.begin()->second;
+  return InputSection->getName();
+}
+
 // Create the custom "linking" section containing linker metadata.
 // This is only created when relocatable output is requested.
 void Writer::createLinkingSection() {
   SyntheticSection *Section =
       createSyntheticSection(WASM_SEC_CUSTOM, "linking");
   raw_ostream &OS = Section->getStream();
 
   if (!Config->Relocatable)
for (const Symbol *Sym : SymtabEntries) {
       if (auto *F = dyn_cast<FunctionSymbol>(Sym)) {
         writeUleb128(Sub.OS, F->getFunctionIndex(), "index");
         if (Sym->isDefined())
           writeStr(Sub.OS, Sym->getName(), "sym name");
       } else if (auto *G = dyn_cast<GlobalSymbol>(Sym)) {
         writeUleb128(Sub.OS, G->getGlobalIndex(), "index");
         if (Sym->isDefined())
           writeStr(Sub.OS, Sym->getName(), "sym name");
-      } else {
-        assert(isa<DataSymbol>(Sym));
+      } else if (auto *D = dyn_cast<DataSymbol>(Sym)) {
         writeStr(Sub.OS, Sym->getName(), "sym name");
         if (auto *DataSym = dyn_cast<DefinedData>(Sym)) {
           writeUleb128(Sub.OS, DataSym->getOutputSegmentIndex(), "index");
           writeUleb128(Sub.OS, DataSym->getOutputSegmentOffset(),
                        "data offset");
           writeUleb128(Sub.OS, DataSym->getSize(), "data size");
         }
-      }
+      } else if (auto *S = dyn_cast<DefinedSection>(Sym)) {
+        StringRef SectionName = getSectionNameFromSymbol(S);
+        writeUleb128(Sub.OS, WASM_SEC_CUSTOM, "sym section type");
+        writeStr(Sub.OS, SectionName, "sym section name");
+      } else
+        assert(false);
     }
 
     Sub.writeTo(OS);
   }
 
   if (Segments.size()) {
     SubSection Sub(WASM_SEGMENT_INFO);
     writeUleb128(Sub.OS, Segments.size(), "num data segments");
void Writer::calculateExports() {
 
   for (Symbol *Sym : Symtab->getSymbols()) {
     if (!Sym->isDefined())
       continue;
     if (Sym->isHidden() || Sym->isLocal())
       continue;
     if (!Sym->isLive())
       continue;
+    if (isa<DefinedSection>(Sym))
+      continue;
 
     DEBUG(dbgs() << "exporting sym: " << Sym->getName() << "\n");
 
     if (auto *D = dyn_cast<DefinedData>(Sym))
       DefinedFakeGlobals.emplace_back(D);
     ExportedSymbols.emplace_back(Sym);
   }
 }
 
 void Writer::assignSymtab() {
   if (!Config->Relocatable)
     return;
 
   unsigned SymbolIndex = SymtabEntries.size();
   for (ObjFile *File : Symtab->ObjectFiles) {
     DEBUG(dbgs() << "Symtab entries: " << File->getName() << "\n");
     for (Symbol *Sym : File->getSymbols()) {
+      if (auto *S = dyn_cast<DefinedSection>(Sym)) {
+        StringRef SectionName = getSectionNameFromSymbol(S);
+        if (CustomSectionMapping.find(SectionName) !=
+            CustomSectionMapping.end()) {
+          Sym->setOutputSymbolIndex(SymbolIndex++);
+          SymtabEntries.emplace_back(Sym);
+        }
+        continue;
+      }
+
       if (Sym->getFile() != File)
         continue;
       // (Since this is relocatable output, GC is not performed so symbols must
       // be live.)
       assert(Sym->isLive());
       Sym->setOutputSymbolIndex(SymbolIndex++);
       SymtabEntries.emplace_back(Sym);
     }
   }
 
   // For the moment, relocatable output doesn't contain any synthetic functions,
   // so no need to look through the Symtab for symbols not referenced by
   // Symtab->ObjectFiles.
 }
 
 uint32_t Writer::lookupType(const WasmSignature &Sig) {
   auto It = TypeIndices.find(Sig);
   if (It == TypeIndices.end()) {
     error("type not found: " + toString(Sig));
     return 0;
   }
   return It->second;
 }
 
 uint32_t Writer::registerType(const WasmSignature &Sig) {
   auto Pair = TypeIndices.insert(std::make_pair(Sig, Types.size()));
   if (Pair.second) {
     DEBUG(dbgs() << "type " << toString(Sig) << "\n");
     Types.push_back(&Sig);
   }
   return Pair.first->second;
 }
 
 void Writer::calculateTypes() {
void Writer::assignIndexes() {
   };
 
   for (ObjFile *File : Symtab->ObjectFiles) {
     DEBUG(dbgs() << "Handle relocs: " << File->getName() << "\n");
     for (InputChunk *Chunk : File->Functions)
       HandleRelocs(Chunk);
     for (InputChunk *Chunk : File->Segments)
       HandleRelocs(Chunk);
+    for (auto &P : File->CustomSections)
+      HandleRelocs(P);
   }
 
   uint32_t GlobalIndex = NumImportedGlobals + InputGlobals.size();
   auto AddDefinedGlobal = [&](InputGlobal *Global) {
     if (Global->Live) {
       DEBUG(dbgs() << "AddDefinedGlobal: " << GlobalIndex << "\n");
       Global->setGlobalIndex(GlobalIndex++);
       InputGlobals.push_back(Global);
void Writer::run() {
   if (!Config->Relocatable)
     createCtorFunction();
   log("-- calculateTypes");
   calculateTypes();
   log("-- layoutMemory");
   layoutMemory();
   log("-- calculateExports");
   calculateExports();
+  log("-- calculateCustomSections");
+  calculateCustomSections();
   log("-- assignSymtab");
   assignSymtab();
 
   if (errorHandler().Verbose) {
     log("Defined Functions: " + Twine(InputFunctions.size()));
     log("Defined Globals  : " + Twine(InputGlobals.size()));
     log("Function Imports : " + Twine(NumImportedFunctions));
     log("Global Imports   : " + Twine(NumImportedGlobals));