Write DWARF data into WASM object file

[yurydelendik]

Summary

• Writes ".debug_XXX" into corresponding WASM custom sections
• Writes relocation records into "reloc.DEBUG" section

[sbc100]

lib/MC/WasmObjectWriter.cpp

399

No curly braces here.

940

There should be one reloc section for each wasm section that contains relocs.

So I think this should generate multiple relocations sections with names like reloc.debug_strings etc..

Each of the reloc sections starts by specifying the target section, then each relocation entry doesn't need to specify the target section.

See: https://github.com/WebAssembly/tool-conventions/blob/master/Linking.md

Maybe there is some reason why this doesn't work for you?

1030

remove curlys

1040

remove comment

[yurydelendik]

Record relocatations per custom section
Add section symbols
Add special code, data, custom section relocation records

[yurydelendik]

Update llvm-readobj to support reading section symbols and new relocations.

[sbc100]

include/llvm/BinaryFormat/Wasm.h

150

Could we just use the the section index here and reuse the existing ElementIndex? (Or at last move the Section inside the union?)

lib/MC/WasmObjectWriter.cpp

925

Is there anything debug specific here? How about writeCustomRelocSections()?

Or better still factor out the duplicate code in writeCodeRelocSection and writeDataRelocSection in single writeRelocSection(Name, Relocations);, then call that in a loop?

lib/Object/WasmObjectFile.cpp

1076

ELF uses ST_Debug for STT_SECTION symbols. (see include/llvm/Object/ELFObjectFile.h)

[yurydelendik]

include/llvm/BinaryFormat/Wasm.h

150

at last move the Section inside the union?

I moved it here due to compiler complaining about StringRef not being a trivial type.

[yurydelendik]

Update obj2yaml/yaml2obj support for custom DWARF sections

[dschuff]

include/llvm/Object/Wasm.h

264

This could probably be llvm::StringSet

lib/MC/WasmObjectWriter.cpp

1058

should this be indented?

1061

What is the section offset in this case? Are we just stuffing the offset from the beginning of the function in there?

[sbc100]

We probably will need to coordinate with: https://reviews.llvm.org/D43097

[yurydelendik]

Changes std::unordered_set to StringSet
Comment for patching XXX_OFFSET_I32 relocations
Minor fixes for reading section symbols

[yurydelendik]

lib/MC/WasmObjectWriter.cpp

1061

Are we just stuffing the offset from the beginning of the function in there

That's correct -- added this in a comment

[yurydelendik]

Fix patching relocations for custom/debug sections.
Fix code style

[yurydelendik]

Use proper symbol offset when hoisting symbols.

[yurydelendik]

Fixes llvm-dwarfdump tools for wasm files w/DWARF sections

[sbc100]

lib/MC/WasmObjectWriter.cpp

488

Can you just write these 6 lines as:

CustomSectionsRelocations[FixupSectionName].push_back(Rec);

tools/yaml2obj/yaml2wasm.cpp

448

Indentation looks strange here and a few other places too. git clang-format?

[dschuff]

lib/DebugInfo/DWARF/DWARFContext.cpp

1146 ↗

(On Diff #140889)

Debug print should go back out or go behind DEBUG()

lib/MC/WasmObjectWriter.cpp

52

If we always reserve 5 bytes for the section size, couldn't the payload offset always be size offset + 5? We don't rewrite those in MC, right?

139

MCSection *Section (here and 141)

[yurydelendik]

Update style via clang-format
Review fixes

[yurydelendik]

lib/MC/WasmObjectWriter.cpp

52

Would you like to express it as invariant / debug only field, and add related asserts in the code?

[sbc100]

lib/MC/WasmObjectWriter.cpp

52

I think are you right Derek. Its not strictly related to this change but i guess we never really needed ContentsOffset.

[sbc100]

include/llvm/ObjectYAML/WasmYAML.h

143

Can we reuse the existing name field here? i.e. can section symbols avoid storing a name at all?

Or how about dropping SectionType and simply using ElementIndex to store the index of the section as it appears in the file. That way there is no ambiguity (e.g. when two custom sections have the same name) and you don't need the SectionName field, since it can be looked up by finding the corresponding section. I know we don't really have section index space yet, but I think it might make sense to use that here.

[yurydelendik]

include/llvm/ObjectYAML/WasmYAML.h

143

The decision to go with such section reference was made based on the pattern we used in the "reloc."-section header. Will this bring some inconsistency in the linker spec?

[sbc100]

Can you rebase now that https://reviews.llvm.org/D45297 has landed?

[yurydelendik]

Rebase on top of D45297

[yurydelendik]

Fix tests at test/MC/WebAssembly/

[sbc100]

include/llvm/Object/RelocVisitor.h

323

Where is this RelocVistor change used? Can this be a separate change perhaps?

lib/MC/WasmObjectWriter.cpp

183

How about just a bool here? isDebug?

483

Could we move this down the end of the function and just have an .isMetadata() before the final else?

Do we need the above error?

lib/Object/WasmObjectFile.cpp

1083

Seems like ELF always return ST_Debug for STT_SECTION type symbols: ELFObjectFile.h:536

1237

Is this needed as part of this change?

On thing to note is that Rel.Index is not always a symbol. For the TYPE_INDEX relocation types its a type index. We might want to revisit this in order to be consistent.

[sbc100]

When I patched this change in I got a failure in test/tools/llvm-objdump/wasm.txt

Also, can you update the test/MC/WebAssembly/debug-info.ll test? In my local version I changed the first line to

; RUN: llc -filetype=obj %s -o - | llvm-readobj -r -s | FileCheck %s

Then added the entire output of readobj as CHECK-NEXT: lines.

[yurydelendik]

include/llvm/Object/RelocVisitor.h

323

This is needed to make llvm-dwarfdump not fail. It can be added in the separate change.

lib/Object/WasmObjectFile.cpp

1237

The change is needed for llvm-dwarfdump tool to not fail.

[sbc100]

lib/Object/WasmObjectFile.cpp

1174

I think you can revert this part once https://reviews.llvm.org/D45579 lands

[yurydelendik]

Fix test/tools/llvm-objdump/wasm.txt and test/MC/WebAssembly/debug-info.ll tests

[yurydelendik]

Addresses recordRelocation review
Removes WasmCustomSectionKind

[yurydelendik]

lib/MC/WasmObjectWriter.cpp

483

Yes. But I adjusted named symbols check to ignore R_WEBASSEMBLY_*_OFFSET_I32:

[sbc100]

include/llvm/Object/RelocVisitor.h

323

I guess we should add a test for llvm-dwarfdump too?

[yurydelendik]

Rebase at D45579

[yurydelendik]

Add dwarfdump test

[sbc100]

Both test files can have the "Debug information is currently not supported" comment remove now I guess?

[yurydelendik]

Remove "Debug information is not supported" comment.

[sbc100]

lib/MC/WasmObjectWriter.cpp

183

Looks like this field isn't used. Remove?

395–401

Make this into a single condition?

In my simple test it looks like ".comment" is the only other section.. maybe we should allow that and just remove this condition? Or that can be a followup CL.

1227

Can we check for isMetadata here as well and perhaps copy the TODO about allowing all metadata sections from above?

1233

Is this what ELF calls these? I thought it was just ".data" etc. perhaps you can just use SectionName for this symbol name since it already starts with "." so can't conflict with a C/C++ symbol?

[yurydelendik]

Remove isDebug and simplify SectionName

[yurydelendik]

Remove .Lsection_start from obj reader
Fix debug section filter

[yurydelendik]

Fix debug-info.ll test -- custom section sizes

[yurydelendik]

Rebase to D45980 attempt.

[sbc100]

include/llvm/ObjectYAML/WasmYAML.h

141

Just reuse ElementIndex?

[sbc100]

include/llvm/Object/RelocVisitor.h

339

Presumably we should be returning something useful here?

Looks like COFF and Mach-O just "return Value" and don't see "HasError" in the success case.

lib/ObjectYAML/WasmYAML.cpp

408

I would drop the suffix "Index" since we don't use it above in Function, or Global

[yurydelendik]

Replace SectionIndex (with ElementIndex)

[yurydelendik]

include/llvm/Object/RelocVisitor.h

339

Whatever passed as Value to RelocVisitor as SymInfo address (https://github.com/llvm-mirror/llvm/blob/0c191c5e264b8cab92b7fe720a1173f54cd4c9b2/lib/DebugInfo/DWARF/DWARFContext.cpp#L1430) is not suitable for DWARFContext

[sbc100]

LGTM. Lets get this landed!

lib/Object/WasmObjectFile.cpp

1049

You can remove this TODO. My understanding is that sections symbols always have value 0. At least on ELF they seem to

[yurydelendik]

Remove TODOs
Rebase on top of D46092

[sbc100]

Do you have llvm commit access to land this?

[lebedev.ri]

That commit broke lld build.
I have committed the obvious fix, please check that it is indeed the expected fix.

[sbc100]

In D44184#1080006, @lebedev.ri wrote:

That commit broke lld build.
I have committed the obvious fix, please check that it is indeed the expected fix.

Thanks Roman

include/llvm/BinaryFormat/Wasm.h

 
 struct WasmSymbolInfo {
   StringRef Name;
   uint8_t Kind;
   uint32_t Flags;
   union {
     // For function or global symbols, the index in function of global index
     // space.
     uint32_t ElementIndex;
     // For a data symbols, the address of the data relative to segment.
     WasmDataReference DataRef;
+    // For a section symbols, the code of the section (see also SectionName).
+    uint32_t SectionCode;
   };
+  // Present for a section symbols, when code is a custom section.
+  StringRef SectionName;
 };
 
 struct WasmFunctionName {
   uint32_t Index;
   StringRef Name;
 };
 
 struct WasmLinkingData {

 enum : unsigned {
   WASM_COMDAT_DATA        = 0x0,
   WASM_COMDAT_FUNCTION    = 0x1,
 };
 
 // Kind codes used in the custom "linking" section in the WASM_SYMBOL_TABLE
 enum WasmSymbolType : unsigned {
   WASM_SYMBOL_TYPE_FUNCTION = 0x0,
-  WASM_SYMBOL_TYPE_DATA     = 0x1,
-  WASM_SYMBOL_TYPE_GLOBAL   = 0x2,
+  WASM_SYMBOL_TYPE_DATA = 0x1,
+  WASM_SYMBOL_TYPE_GLOBAL = 0x2,
+  WASM_SYMBOL_TYPE_SECTION = 0x3,
 };
 
 const unsigned WASM_SYMBOL_BINDING_MASK       = 0x3;
 const unsigned WASM_SYMBOL_VISIBILITY_MASK    = 0xc;
 
 const unsigned WASM_SYMBOL_BINDING_GLOBAL     = 0x0;
 const unsigned WASM_SYMBOL_BINDING_WEAK       = 0x1;
 const unsigned WASM_SYMBOL_BINDING_LOCAL      = 0x2;

include/llvm/BinaryFormat/WasmRelocs.def

 
 #ifndef WASM_RELOC
 #error "WASM_RELOC must be defined"
 #endif
 
 WASM_RELOC(R_WEBASSEMBLY_FUNCTION_INDEX_LEB,   0)
 WASM_RELOC(R_WEBASSEMBLY_TABLE_INDEX_SLEB,     1)
 WASM_RELOC(R_WEBASSEMBLY_TABLE_INDEX_I32,      2)
 WASM_RELOC(R_WEBASSEMBLY_MEMORY_ADDR_LEB,      3)
 WASM_RELOC(R_WEBASSEMBLY_MEMORY_ADDR_SLEB,     4)
 WASM_RELOC(R_WEBASSEMBLY_MEMORY_ADDR_I32,      5)
 WASM_RELOC(R_WEBASSEMBLY_TYPE_INDEX_LEB,       6)
 WASM_RELOC(R_WEBASSEMBLY_GLOBAL_INDEX_LEB,     7)
+WASM_RELOC(R_WEBASSEMBLY_FUNCTION_OFFSET_I32,  8)
+WASM_RELOC(R_WEBASSEMBLY_SECTION_OFFSET_I32,   9)

include/llvm/Object/RelocVisitor.h

 
 #include "llvm/ADT/Triple.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/BinaryFormat/MachO.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/Object/MachO.h"
 #include "llvm/Object/ObjectFile.h"
+#include "llvm/Object/Wasm.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
 #include <cstdint>
 #include <system_error>
 
 namespace llvm {
 namespace object {
 
 /// @brief Base class for object file relocation visitors.
 class RelocVisitor {
 public:
   explicit RelocVisitor(const ObjectFile &Obj) : ObjToVisit(Obj) {}
 
   // TODO: Should handle multiple applied relocations via either passing in the
   // previously computed value or just count paired relocations as a single
   // visit.
   uint64_t visit(uint32_t Rel, RelocationRef R, uint64_t Value = 0) {
     if (isa<ELFObjectFileBase>(ObjToVisit))
       return visitELF(Rel, R, Value);
     if (isa<COFFObjectFile>(ObjToVisit))
       return visitCOFF(Rel, R, Value);
     if (isa<MachOObjectFile>(ObjToVisit))
       return visitMachO(Rel, R, Value);
+    if (isa<WasmObjectFile>(ObjToVisit))
+      return visitWasm(Rel, R, Value);
 
     HasError = true;
     return 0;
   }
 
   bool error() { return HasError; }
 
 private:
private:
 
   uint64_t visitMachO(uint32_t Rel, RelocationRef R, uint64_t Value) {
     if (ObjToVisit.getArch() == Triple::x86_64 &&
         Rel == MachO::X86_64_RELOC_UNSIGNED)
       return Value;
     HasError = true;
     return 0;
   }
+
+  uint64_t visitWasm(uint32_t Rel, RelocationRef R, uint64_t Value) {
+    if (ObjToVisit.getArch() == Triple::wasm32) {
+      switch (Rel) {
+      case wasm::R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
+      case wasm::R_WEBASSEMBLY_TABLE_INDEX_SLEB:
+      case wasm::R_WEBASSEMBLY_TABLE_INDEX_I32:
+      case wasm::R_WEBASSEMBLY_MEMORY_ADDR_LEB:
+      case wasm::R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
+      case wasm::R_WEBASSEMBLY_MEMORY_ADDR_I32:
+      case wasm::R_WEBASSEMBLY_TYPE_INDEX_LEB:
+      case wasm::R_WEBASSEMBLY_GLOBAL_INDEX_LEB:
+      case wasm::R_WEBASSEMBLY_FUNCTION_OFFSET_I32:
+      case wasm::R_WEBASSEMBLY_SECTION_OFFSET_I32:
+        // For wasm section, its offset at 0 -- ignoring Value
+        // TODO do we want to use absolute section offset in the wasm file?
+        HasError = false;
+        return 0;
+      }
+    }
+    HasError = true;
+    return 0;
+  }
 };
 
 } // end namespace object
 } // end namespace llvm
 
 #endif // LLVM_OBJECT_RELOCVISITOR_H

include/llvm/Object/Wasm.h

 // See: https://github.com/WebAssembly/design/blob/master/BinaryEncoding.md
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_OBJECT_WASM_H
 #define LLVM_OBJECT_WASM_H
 
 #include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringMap.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/StringSet.h"
 #include "llvm/BinaryFormat/Wasm.h"
 #include "llvm/Object/Binary.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include <cstddef>
 #include <cstdint>
 #include <vector>
public:
   }
 
   bool isTypeData() const { return Info.Kind == wasm::WASM_SYMBOL_TYPE_DATA; }
 
   bool isTypeGlobal() const {
     return Info.Kind == wasm::WASM_SYMBOL_TYPE_GLOBAL;
   }
 
+  bool isTypeSection() const {
+    return Info.Kind == wasm::WASM_SYMBOL_TYPE_SECTION;
+  }
+
   bool isDefined() const { return !isUndefined(); }
 
   bool isUndefined() const {
     return (Info.Flags & wasm::WASM_SYMBOL_UNDEFINED) != 0;
   }
 
   bool isBindingWeak() const {
     return getBinding() == wasm::WASM_SYMBOL_BINDING_WEAK;

 private:
   bool isValidFunctionIndex(uint32_t Index) const;
   bool isDefinedFunctionIndex(uint32_t Index) const;
   bool isValidGlobalIndex(uint32_t Index) const;
   bool isDefinedGlobalIndex(uint32_t Index) const;
   bool isValidFunctionSymbol(uint32_t Index) const;
   bool isValidGlobalSymbol(uint32_t Index) const;
   bool isValidDataSymbol(uint32_t Index) const;
+  bool isValidSectionSymbol(uint32_t Index) const;
   wasm::WasmFunction &getDefinedFunction(uint32_t Index);
   wasm::WasmGlobal &getDefinedGlobal(uint32_t Index);
 
   const WasmSection &getWasmSection(DataRefImpl Ref) const;
   const wasm::WasmRelocation &getWasmRelocation(DataRefImpl Ref) const;
 
   WasmSection* findCustomSectionByName(StringRef Name);
   WasmSection* findSectionByType(uint32_t Type);
private:
   std::vector<wasm::WasmGlobal> Globals;
   std::vector<wasm::WasmImport> Imports;
   std::vector<wasm::WasmExport> Exports;
   std::vector<wasm::WasmElemSegment> ElemSegments;
   std::vector<WasmSegment> DataSegments;
   std::vector<wasm::WasmFunction> Functions;
   std::vector<WasmSymbol> Symbols;
   std::vector<wasm::WasmFunctionName> DebugNames;
+  StringSet<> InternedNames;
   uint32_t StartFunction = -1;
   bool HasLinkingSection = false;
   wasm::WasmLinkingData LinkingData;
   uint32_t NumImportedGlobals = 0;
   uint32_t NumImportedFunctions = 0;
   uint32_t CodeSection = 0;
   uint32_t DataSection = 0;
   uint32_t GlobalSection = 0;

include/llvm/ObjectYAML/WasmYAML.h

 struct SymbolInfo {
   uint32_t Index;
   StringRef Name;
   SymbolKind Kind;
   SymbolFlags Flags;
   union {
     uint32_t ElementIndex;
     wasm::WasmDataReference DataRef;
+    SectionType SectionType;
   };
+  StringRef SectionName; // present when SectionType is a custom section
 };
 
 struct InitFunction {
   uint32_t Priority;
   uint32_t Symbol;
 };
 
 struct ComdatEntry {

lib/MC/WasmObjectWriter.cpp

 static const uint32_t kInitialTableOffset = 1;
 
 // For patching purposes, we need to remember where each section starts, both
 // for patching up the section size field, and for patching up references to
 // locations within the section.
 struct SectionBookkeeping {
   // Where the size of the section is written.
   uint64_t SizeOffset;
-  // Where the contents of the section starts (after the header).
+  // Where the section header ends (without custom section name).
+  uint64_t PayloadOffset;
+  // Where the contents of the section starts.
   uint64_t ContentsOffset;
 };
 
 // The signature of a wasm function, in a struct capable of being used as a
 // DenseMap key.
 struct WasmFunctionType {
   // Support empty and tombstone instances, needed by DenseMap.
   enum { Plain, Empty, Tombstone } State;

 // Information about a single item which is part of a COMDAT.  For each data
 // segment or function which is in the COMDAT, there is a corresponding
 // WasmComdatEntry.
 struct WasmComdatEntry {
   unsigned Kind;
   uint32_t Index;
 };
 
+// Information to store symbols that point to Wasm sections content offsets.
+struct WasmSectionEntry {
+  const MCSymbolWasm *Sym;
+  const MCSection *Section;
+
+  WasmSectionEntry(const MCSymbolWasm *Sym, const MCSection *Section)
+      : Sym(Sym), Section(Section) {}
+};
+
 // Information about a single relocation.
 struct WasmRelocationEntry {
   uint64_t Offset;                  // Where is the relocation.
   const MCSymbolWasm *Symbol;       // The symbol to relocate with.
   int64_t Addend;                   // A value to add to the symbol.
   unsigned Type;                    // The type of the relocation.
   const MCSectionWasm *FixupSection;// The section the relocation is targeting.
 
   WasmRelocationEntry(uint64_t Offset, const MCSymbolWasm *Symbol,
                       int64_t Addend, unsigned Type,
                       const MCSectionWasm *FixupSection)
       : Offset(Offset), Symbol(Symbol), Addend(Addend), Type(Type),
         FixupSection(FixupSection) {}
 
   bool hasAddend() const {
     switch (Type) {
     case wasm::R_WEBASSEMBLY_MEMORY_ADDR_LEB:
     case wasm::R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
     case wasm::R_WEBASSEMBLY_MEMORY_ADDR_I32:
+    case wasm::R_WEBASSEMBLY_FUNCTION_OFFSET_I32:
+    case wasm::R_WEBASSEMBLY_SECTION_OFFSET_I32:
       return true;
     default:
       return false;
     }
   }
 
   void print(raw_ostream &Out) const {
     Out << "Off=" << Offset << ", Sym=" << *Symbol << ", Addend=" << Addend
         << ", Type=" << Type
         << ", FixupSection=" << FixupSection->getSectionName();
   }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   LLVM_DUMP_METHOD void dump() const { print(dbgs()); }
 #endif
 };
 
 #if !defined(NDEBUG)
 raw_ostream &operator<<(raw_ostream &OS, const WasmRelocationEntry &Rel) {
   Rel.print(OS);
   return OS;
 }
 #endif
 
 class WasmObjectWriter : public MCObjectWriter {
   /// The target specific Wasm writer instance.
   std::unique_ptr<MCWasmObjectTargetWriter> TargetObjectWriter;
 
   // Relocations for fixing up references in the code section.
   std::vector<WasmRelocationEntry> CodeRelocations;
 
   // Relocations for fixing up references in the data section.
   std::vector<WasmRelocationEntry> DataRelocations;
 
+  // Relocations for fixing up references in the custom sections.
+  StringMap<std::vector<WasmRelocationEntry>> CustomSectionsRelocations;
+
   // Index values to use for fixing up call_indirect type indices.
   // Maps function symbols to the index of the type of the function
   DenseMap<const MCSymbolWasm *, uint32_t> TypeIndices;
   // Maps function symbols to the table element index space. Used
   // 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 Wasm 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 *> CustomSections;
 
   DenseMap<WasmFunctionType, int32_t, WasmFunctionTypeDenseMapInfo>
       FunctionTypeIndices;
   SmallVector<WasmFunctionType, 4> FunctionTypes;
   SmallVector<WasmGlobal, 4> Globals;
   SmallVector<WasmDataSegment, 4> DataSegments;
+  DenseMap<const MCSectionWasm *, uint64_t> CustomSectionContents;
   unsigned NumFunctionImports = 0;
   unsigned NumGlobalImports = 0;
 
   // TargetObjectWriter wrappers.
   bool is64Bit() const { return TargetObjectWriter->is64Bit(); }
   unsigned getRelocType(const MCValue &Target, const MCFixup &Fixup) const {
     return TargetObjectWriter->getRelocType(Target, Fixup);
   }
WasmObjectWriter(std::unique_ptr<MCWasmObjectTargetWriter> MOTW,
         TargetObjectWriter(std::move(MOTW)) {}
 
   ~WasmObjectWriter() override;
 
 private:
   void reset() override {
     CodeRelocations.clear();
     DataRelocations.clear();
+    CustomSectionsRelocations.clear();
     TypeIndices.clear();
     SymbolIndices.clear();
     WasmIndices.clear();
     TableIndices.clear();
     DataLocations.clear();
+    CustomSections.clear();
     FunctionTypeIndices.clear();
     FunctionTypes.clear();
     Globals.clear();
     DataSegments.clear();
+    CustomSectionContents.clear();
     MCObjectWriter::reset();
     NumFunctionImports = 0;
     NumGlobalImports = 0;
   }
 
   void writeHeader(const MCAssembler &Asm);
 
   void recordRelocation(MCAssembler &Asm, const MCAsmLayout &Layout,
private:
   void writeGlobalSection();
   void writeExportSection(ArrayRef<wasm::WasmExport> Exports);
   void writeElemSection(ArrayRef<uint32_t> TableElems);
   void writeCodeSection(const MCAssembler &Asm, const MCAsmLayout &Layout,
                         ArrayRef<WasmFunction> Functions);
   void writeDataSection();
   void writeCodeRelocSection();
   void writeDataRelocSection();
+  void writeCustomRelocSections();
   void writeLinkingMetaDataSection(
       ArrayRef<wasm::WasmSymbolInfo> SymbolInfos,
       ArrayRef<std::pair<uint16_t, uint32_t>> InitFuncs,
       const std::map<StringRef, std::vector<WasmComdatEntry>> &Comdats);
 
+  void writeDebugSections(const MCAssembler &Asm, const MCAsmLayout &Layout);
+  void
+  updateCustomSectionRelocations(const SmallVector<WasmFunction, 4> &Functions,
+                                 const MCAsmLayout &Layout);
   uint32_t getProvisionalValue(const WasmRelocationEntry &RelEntry);
   void applyRelocations(ArrayRef<WasmRelocationEntry> Relocations,
                         uint64_t ContentsOffset);
 
   void writeRelocations(ArrayRef<WasmRelocationEntry> Relocations);
   uint32_t getRelocationIndexValue(const WasmRelocationEntry &RelEntry);
   uint32_t getFunctionType(const MCSymbolWasm& Symbol);
   uint32_t registerFunctionType(const MCSymbolWasm& Symbol);
void WasmObjectWriter::startSection(SectionBookkeeping &Section,
   write8(SectionId);
 
   Section.SizeOffset = getStream().tell();
 
   // The section size. We don't know the size yet, so reserve enough space
   // for any 32-bit value; we'll patch it later.
   encodeULEB128(UINT32_MAX, getStream());
 
-  // The position where the section starts, for measuring its size.
-  Section.ContentsOffset = getStream().tell();
+  // The position where the section header ends, for measuring its size.
+  Section.PayloadOffset = getStream().tell();
 
   // Custom sections in wasm also have a string identifier.
   if (SectionId == wasm::WASM_SEC_CUSTOM) {
     assert(Name);
     writeString(StringRef(Name));
   }
+
+  // The position where the section starts.
+  Section.ContentsOffset = getStream().tell();
 }
 
 // Now that the section is complete and we know how big it is, patch up the
 // section size field at the start of the section.
 void WasmObjectWriter::endSection(SectionBookkeeping &Section) {
-  uint64_t Size = getStream().tell() - Section.ContentsOffset;
+  uint64_t Size = getStream().tell() - Section.PayloadOffset;
   if (uint32_t(Size) != Size)
     report_fatal_error("section size does not fit in a uint32_t");
 
   DEBUG(dbgs() << "endSection size=" << Size << "\n");
 
   // Write the final section size to the payload_len field, which follows
   // the section id byte.
   uint8_t Buffer[16];
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(sbc): Add support for debug sections.
-  if (FixupSection.getKind().isMetadata())
+  bool IsDebugFixup = false;
+  // TODO: Add support for non-debug metadata sections?
+  if (FixupSection.getKind().isMetadata()) {
+    if (!FixupSection.getSectionName().startswith(".debug_"))
       return;
+    IsDebugFixup = true;
+  }
 
   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).
void WasmObjectWriter::recordRelocation(MCAssembler &Asm,
   assert(!IsPCRel);
   assert(SymA);
 
   unsigned Type = getRelocType(Target, Fixup);
 
   WasmRelocationEntry Rec(FixupOffset, SymA, C, Type, &FixupSection);
   DEBUG(dbgs() << "WasmReloc: " << Rec << "\n");
 
+  if (IsDebugFixup) {
+    switch (Type) {
+    case wasm::R_WEBASSEMBLY_MEMORY_ADDR_I32:
+    case wasm::R_WEBASSEMBLY_FUNCTION_OFFSET_I32:
+    case wasm::R_WEBASSEMBLY_SECTION_OFFSET_I32:
+      break;
+    default:
+      report_fatal_error("relocation in debug section supported only for "
+                         "R_WEBASSEMBLY_MEMORY_ADDR_I32 or _OFFSET_I32");
+    }
+
+    const auto &FixupSectionName = FixupSection.getSectionName().str();
+    CustomSectionsRelocations[FixupSectionName].push_back(Rec);
+    return;
+  }
+
   // Relocation other than R_WEBASSEMBLY_TYPE_INDEX_LEB 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)
     report_fatal_error("relocations against un-named temporaries are not yet "
                        "supported by wasm");
 
   if (FixupSection.isWasmData())
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: {
+    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 = *CustomSections.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 (const WasmRelocationEntry &RelEntry : Relocations) {
     case wasm::R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
     case wasm::R_WEBASSEMBLY_TYPE_INDEX_LEB:
     case wasm::R_WEBASSEMBLY_GLOBAL_INDEX_LEB:
     case wasm::R_WEBASSEMBLY_MEMORY_ADDR_LEB:
       WritePatchableLEB(Stream, Value, Offset);
       break;
     case wasm::R_WEBASSEMBLY_TABLE_INDEX_I32:
     case wasm::R_WEBASSEMBLY_MEMORY_ADDR_I32:
+    case wasm::R_WEBASSEMBLY_FUNCTION_OFFSET_I32:
+    case wasm::R_WEBASSEMBLY_SECTION_OFFSET_I32:
       WriteI32(Stream, Value, Offset);
       break;
     case wasm::R_WEBASSEMBLY_TABLE_INDEX_SLEB:
     case wasm::R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
       WritePatchableSLEB(Stream, Value, Offset);
       break;
     default:
       llvm_unreachable("invalid relocation type");
void WasmObjectWriter::writeDataRelocSection() {
   encodeULEB128(wasm::WASM_SEC_DATA, getStream());
   encodeULEB128(DataRelocations.size(), getStream());
 
   writeRelocations(DataRelocations);
 
   endSection(Section);
 }
 
+void WasmObjectWriter::writeCustomRelocSections() {
+  for (const auto &P : CustomSectionsRelocations) {
+    auto CustomSectionName = P.first();
+    auto CustomSectionRelocations = P.second;
+
+    SectionBookkeeping Section;
+    startSection(Section, wasm::WASM_SEC_CUSTOM,
+                 ("reloc." + CustomSectionName).str().c_str());
+
+    encodeULEB128(wasm::WASM_SEC_CUSTOM, getStream());
+    writeString(CustomSectionName);
+    encodeULEB128(CustomSectionRelocations.size(), getStream());
+
+    writeRelocations(CustomSectionRelocations);
+
+    endSection(Section);
+  }
+}
+
 void WasmObjectWriter::writeLinkingMetaDataSection(
     ArrayRef<wasm::WasmSymbolInfo> SymbolInfos,
     ArrayRef<std::pair<uint16_t, uint32_t>> InitFuncs,
     const std::map<StringRef, std::vector<WasmComdatEntry>> &Comdats) {
   SectionBookkeeping Section;
   startSection(Section, wasm::WASM_SEC_CUSTOM, "linking");
   SectionBookkeeping SubSection;
 
for (const wasm::WasmSymbolInfo &Sym : SymbolInfos) {
       case wasm::WASM_SYMBOL_TYPE_DATA:
         writeString(Sym.Name);
         if ((Sym.Flags & wasm::WASM_SYMBOL_UNDEFINED) == 0) {
           encodeULEB128(Sym.DataRef.Segment, getStream());
           encodeULEB128(Sym.DataRef.Offset, getStream());
           encodeULEB128(Sym.DataRef.Size, getStream());
         }
         break;
+      case wasm::WASM_SYMBOL_TYPE_SECTION:
+        encodeULEB128(Sym.SectionCode, getStream());
+        if (Sym.SectionCode == wasm::WASM_SEC_CUSTOM)
+          writeString(Sym.SectionName);
+        break;
       default:
         llvm_unreachable("unexpected kind");
       }
     }
     endSection(SubSection);
   }
 
   if (DataSegments.size()) {
for (const auto &C : Comdats) {
       }
     }
     endSection(SubSection);
   }
 
   endSection(Section);
 }
 
+void WasmObjectWriter::writeDebugSections(const MCAssembler &Asm,
+                                          const MCAsmLayout &Layout) {
+  for (MCSection &Sec : Asm) {
+    auto &DebugSection = static_cast<MCSectionWasm &>(Sec);
+    StringRef SectionName = DebugSection.getSectionName();
+
+    if (!SectionName.startswith(".debug_"))
+      continue;
+
+    SectionBookkeeping Section;
+    startSection(Section, wasm::WASM_SEC_CUSTOM, SectionName.str().c_str());
+
+    DebugSection.setSectionOffset(getStream().tell() - Section.ContentsOffset);
+    Asm.writeSectionData(&DebugSection, Layout);
+
+    CustomSectionContents[&DebugSection] = Section.ContentsOffset;
+
+    endSection(Section);
+  }
+}
+
+void WasmObjectWriter::updateCustomSectionRelocations(
+    const SmallVector<WasmFunction, 4> &Functions, const MCAsmLayout &Layout) {
+  std::map<const MCSection *, const MCSymbolWasm *> SectionSymbols;
+  for (const auto &P : CustomSections)
+    SectionSymbols[P.second] = P.first;
+  std::map<const MCSection *, const MCSymbolWasm *> FuncSymbols;
+  for (const auto &FuncInfo : Functions)
+    FuncSymbols[&FuncInfo.Sym->getSection()] = FuncInfo.Sym;
+  StringMap<const MCSectionWasm *> CustomSectionsByName;
+  for (auto &P : CustomSections)
+    CustomSectionsByName[P.second->getSectionName()] = P.second;
+
+  // 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 &P : CustomSectionsRelocations) {
+    for (WasmRelocationEntry &RelEntry : P.second) {
+      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.
+    const auto &Section = CustomSectionsByName.find(P.first())->second;
+    applyRelocations(P.second, CustomSectionContents[Section]);
+  }
+}
+
 uint32_t WasmObjectWriter::getFunctionType(const MCSymbolWasm& Symbol) {
   assert(Symbol.isFunction());
   assert(TypeIndices.count(&Symbol));
   return TypeIndices[&Symbol];
 }
 
 uint32_t WasmObjectWriter::registerFunctionType(const MCSymbolWasm& Symbol) {
   assert(Symbol.isFunction());
for (MCSection &Sec : Asm) {
     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 (const MCSection &Sec : Asm) {
+    const auto &DebugSection = static_cast<const MCSectionWasm &>(Sec);
+    StringRef SectionName = DebugSection.getSectionName();
+
+    if (!SectionName.startswith(".debug_"))
+      continue;
+
+    auto SymbolName = (".Lsection_start" + SectionName).str();
+    MCSymbolWasm *SectionSym =
+        cast<MCSymbolWasm>(Ctx.getOrCreateSymbol(SymbolName));
+    CustomSections[SectionSym] = &DebugSection;
+
+    wasm::WasmSymbolInfo Info;
+    Info.Name = SectionSym->getName();
+    Info.Kind = wasm::WASM_SYMBOL_TYPE_SECTION;
+    Info.Flags = 0;
+    Info.SectionCode = wasm::WASM_SEC_CUSTOM;
+    Info.SectionName = SectionName;
+    SymbolIndices[SectionSym] = SymbolInfos.size();
+    SymbolInfos.emplace_back(Info);
+  }
+
   // 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;
 
     const auto &WS = static_cast<const MCSymbolWasm &>(S);
void WasmObjectWriter::writeObject(MCAssembler &Asm,
   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();
+  writeDebugSections(Asm, Layout);
+  updateCustomSectionRelocations(Functions, Layout);
   writeLinkingMetaDataSection(SymbolInfos, InitFuncs, Comdats);
   writeCodeRelocSection();
   writeDataRelocSection();
+  writeCustomRelocSections();
 
   // TODO: Translate the .comment section to the output.
-  // TODO: Translate debug sections 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);
 }

lib/Object/WasmObjectFile.cpp

case wasm::WASM_SYMBOL_TYPE_DATA:
         uint32_t Size = readVaruint32(Ptr);
         if (Offset + Size > DataSegments[Index].Data.Content.size())
           return make_error<GenericBinaryError>("invalid data symbol offset",
                                                 object_error::parse_failed);
         Info.DataRef = wasm::WasmDataReference{Index, Offset, Size};
       }
       break;
 
+    case wasm::WASM_SYMBOL_TYPE_SECTION: {
+      Info.SectionCode = readVaruint32(Ptr);
+      if (Info.SectionCode != wasm::WASM_SEC_CUSTOM)
+        return make_error<GenericBinaryError>("invalid section symbol target",
+                                              object_error::parse_failed);
+      Info.SectionName = readString(Ptr);
+      if (!findCustomSectionByName(Info.SectionName))
+        return make_error<GenericBinaryError>(
+            "referred symbol section " + Info.SectionName + " is missing",
+            object_error::parse_failed);
+
+      // Generate somewhat unique name for the section symbol.
+      auto SymbolName = (".Lsection_start" + Info.SectionName).str();
+      Info.Name = InternedNames.insert(SymbolName).first->getKey();
+      break;
+    }
+
     default:
       return make_error<GenericBinaryError>("Invalid symbol type",
                                             object_error::parse_failed);
     }
 
     if ((Info.Flags & wasm::WASM_SYMBOL_BINDING_MASK) !=
             wasm::WASM_SYMBOL_BINDING_LOCAL &&
         !SymbolNames.insert(Info.Name).second)
while (RelocCount--) {
     case wasm::R_WEBASSEMBLY_MEMORY_ADDR_LEB:
     case wasm::R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
     case wasm::R_WEBASSEMBLY_MEMORY_ADDR_I32:
       if (!isValidDataSymbol(Reloc.Index))
         return make_error<GenericBinaryError>("Bad relocation data index",
                                               object_error::parse_failed);
       Reloc.Addend = readVarint32(Ptr);
       break;
+    case wasm::R_WEBASSEMBLY_FUNCTION_OFFSET_I32:
+      if (!isValidFunctionSymbol(Reloc.Index))
+        return make_error<GenericBinaryError>("Bad relocation function index",
+                                              object_error::parse_failed);
+      Reloc.Addend = readVarint32(Ptr);
+      break;
+    case wasm::R_WEBASSEMBLY_SECTION_OFFSET_I32:
+      if (!isValidSectionSymbol(Reloc.Index))
+        return make_error<GenericBinaryError>("Bad relocation section index",
+                                              object_error::parse_failed);
+      Reloc.Addend = readVarint32(Ptr);
+      break;
     default:
       return make_error<GenericBinaryError>("Bad relocation type: " +
                                                 Twine(Reloc.Type),
                                             object_error::parse_failed);
     }
 
     // Relocations must fit inside the section, and must appear in order.  They
     // also shouldn't overlap a function/element boundary, but we don't bother
     // to check that.
     uint64_t Size = 5;
     if (Reloc.Type == wasm::R_WEBASSEMBLY_TABLE_INDEX_I32 ||
-        Reloc.Type == wasm::R_WEBASSEMBLY_MEMORY_ADDR_I32)
+        Reloc.Type == wasm::R_WEBASSEMBLY_MEMORY_ADDR_I32 ||
+        Reloc.Type == wasm::R_WEBASSEMBLY_SECTION_OFFSET_I32 ||
+        Reloc.Type == wasm::R_WEBASSEMBLY_FUNCTION_OFFSET_I32)
       Size = 4;
     if (Reloc.Offset + Size > EndOffset)
       return make_error<GenericBinaryError>("Bad relocation offset",
                                             object_error::parse_failed);
 
     Section->Relocations.push_back(Reloc);
   }
   if (Ptr != End)

 bool WasmObjectFile::isValidGlobalSymbol(uint32_t Index) const {
   return Index < Symbols.size() && Symbols[Index].isTypeGlobal();
 }
 
 bool WasmObjectFile::isValidDataSymbol(uint32_t Index) const {
   return Index < Symbols.size() && Symbols[Index].isTypeData();
 }
 
+bool WasmObjectFile::isValidSectionSymbol(uint32_t Index) const {
+  return Index < Symbols.size() && Symbols[Index].isTypeSection();
+}
+
 wasm::WasmFunction &WasmObjectFile::getDefinedFunction(uint32_t Index) {
   assert(isDefinedFunctionIndex(Index));
   return Functions[Index - NumImportedFunctions];
 }
 
 wasm::WasmGlobal &WasmObjectFile::getDefinedGlobal(uint32_t Index) {
   assert(isDefinedGlobalIndex(Index));
   return Globals[Index - NumImportedGlobals];
uint64_t WasmObjectFile::getWasmSymbolValue(const WasmSymbol& Sym) const {
   case wasm::WASM_SYMBOL_TYPE_DATA: {
     // The value of a data symbol is the segment offset, plus the symbol
     // offset within the segment.
     uint32_t SegmentIndex = Sym.Info.DataRef.Segment;
     const wasm::WasmDataSegment &Segment = DataSegments[SegmentIndex].Data;
     assert(Segment.Offset.Opcode == wasm::WASM_OPCODE_I32_CONST);
     return Segment.Offset.Value.Int32 + Sym.Info.DataRef.Offset;
   }
+  case wasm::WASM_SYMBOL_TYPE_SECTION:
+    return 0; // TODO(yury): section offset from top of the object file?
   }
   llvm_unreachable("invalid symbol type");
 }
 
 uint64_t WasmObjectFile::getSymbolValueImpl(DataRefImpl Symb) const {
   return getWasmSymbolValue(getWasmSymbol(Symb));
 }
 

 Expected<SymbolRef::Type>
 WasmObjectFile::getSymbolType(DataRefImpl Symb) const {
   const WasmSymbol &Sym = getWasmSymbol(Symb);
 
   switch (Sym.Info.Kind) {
   case wasm::WASM_SYMBOL_TYPE_FUNCTION:
     return SymbolRef::ST_Function;
   case wasm::WASM_SYMBOL_TYPE_GLOBAL:
     return SymbolRef::ST_Other;
   case wasm::WASM_SYMBOL_TYPE_DATA:
     return SymbolRef::ST_Data;
+  case wasm::WASM_SYMBOL_TYPE_SECTION:
+    if (Sym.Info.SectionCode == wasm::WASM_SEC_CUSTOM &&
+        Sym.Info.SectionName.startswith(".debug_"))
+      return SymbolRef::ST_Debug;
+    // Support of non-debug custom sections is not implemented yet.
+    break;
   }
 
   llvm_unreachable("Unknown WasmSymbol::SymbolType");
   return SymbolRef::ST_Other;
 }
 
 Expected<section_iterator>
 WasmObjectFile::getSymbolSection(DataRefImpl Symb) const {
   const WasmSymbol& Sym = getWasmSymbol(Symb);
   if (Sym.isUndefined())
     return section_end();
 
   DataRefImpl Ref;
   switch (Sym.Info.Kind) {
   case wasm::WASM_SYMBOL_TYPE_FUNCTION:
     Ref.d.a = CodeSection;
     break;
   case wasm::WASM_SYMBOL_TYPE_GLOBAL:
     Ref.d.a = GlobalSection;
     break;
   case wasm::WASM_SYMBOL_TYPE_DATA:
     Ref.d.a = DataSection;
     break;
+  case wasm::WASM_SYMBOL_TYPE_SECTION: {
+    assert(Sym.Info.SectionCode == wasm::WASM_SEC_CUSTOM);
+    // Find index of the referred custom section.
+    auto Section = std::find_if(Sections.begin(), Sections.end(),
+                                [&](const WasmSection &Sec) -> bool {
+                                  return Sec.Type == wasm::WASM_SEC_CUSTOM &&
+                                         Sec.Name == Sym.Info.SectionName;
+                                });
+    assert(Section != Sections.end());
+    Ref.d.a = std::distance(Sections.begin(), Section);
+    break;
+  }
   default:
     llvm_unreachable("Unknown WasmSymbol::SymbolType");
   }
   return section_iterator(SectionRef(Ref, this));
 }
 
 void WasmObjectFile::moveSectionNext(DataRefImpl &Sec) const { Sec.d.a++; }
 

 }
 
 uint64_t WasmObjectFile::getSectionAddress(DataRefImpl Sec) const { return 0; }
 
 uint64_t WasmObjectFile::getSectionIndex(DataRefImpl Sec) const {
   return Sec.d.a;
 }
 
+static size_t getPayloadOffset(const WasmSection &Section) {
+  if (Section.Type != llvm::wasm::WASM_SEC_CUSTOM)
+    return 0;
+  const uint8_t *Ptr = Section.Content.data();
+  readString(Ptr);
+  return Ptr - Section.Content.data();
+}
+
 uint64_t WasmObjectFile::getSectionSize(DataRefImpl Sec) const {
   const WasmSection &S = Sections[Sec.d.a];
-  return S.Content.size();
+  assert(S.Content.size() >= getPayloadOffset(S));
+  return S.Content.size() - getPayloadOffset(S);
 }
 
 std::error_code WasmObjectFile::getSectionContents(DataRefImpl Sec,
                                                    StringRef &Res) const {
   const WasmSection &S = Sections[Sec.d.a];
   // This will never fail since wasm sections can never be empty (user-sections
   // must have a name and non-user sections each have a defined structure).
-  Res = StringRef(reinterpret_cast<const char *>(S.Content.data()),
-                  S.Content.size());
+  size_t PayloadOffset = getPayloadOffset(S);
+  assert(S.Content.size() >= PayloadOffset);
+  Res = StringRef(
+      reinterpret_cast<const char *>(S.Content.data() + PayloadOffset),
+      S.Content.size() - PayloadOffset);
   return std::error_code();
 }
 
 uint64_t WasmObjectFile::getSectionAlignment(DataRefImpl Sec) const {
   return 1;
 }
 
 bool WasmObjectFile::isSectionCompressed(DataRefImpl Sec) const {
void WasmObjectFile::moveRelocationNext(DataRefImpl &Rel) const {
   Rel.d.b++;
 }
 
 uint64_t WasmObjectFile::getRelocationOffset(DataRefImpl Ref) const {
   const wasm::WasmRelocation &Rel = getWasmRelocation(Ref);
   return Rel.Offset;
 }
 
-symbol_iterator WasmObjectFile::getRelocationSymbol(DataRefImpl Rel) const {
-  llvm_unreachable("not yet implemented");
-  SymbolRef Ref;
-  return symbol_iterator(Ref);
+symbol_iterator WasmObjectFile::getRelocationSymbol(DataRefImpl Ref) const {
+  const wasm::WasmRelocation &Rel = getWasmRelocation(Ref);
+  DataRefImpl Sym;
+  Sym.d.a = Rel.Index;
+  Sym.d.b = 0;
+  return symbol_iterator(SymbolRef(Sym, this));
 }
 
 uint64_t WasmObjectFile::getRelocationType(DataRefImpl Ref) const {
   const wasm::WasmRelocation &Rel = getWasmRelocation(Ref);
   return Rel.Type;
 }
 
 void WasmObjectFile::getRelocationTypeName(

lib/ObjectYAML/WasmYAML.cpp

void MappingTraits<WasmYAML::SymbolInfo>::mapping(IO &IO,
   } else if (Info.Kind == wasm::WASM_SYMBOL_TYPE_GLOBAL) {
     IO.mapRequired("Global", Info.ElementIndex);
   } else if (Info.Kind == wasm::WASM_SYMBOL_TYPE_DATA) {
     if ((Info.Flags & wasm::WASM_SYMBOL_UNDEFINED) == 0) {
       IO.mapRequired("Segment", Info.DataRef.Segment);
       IO.mapOptional("Offset", Info.DataRef.Offset, 0u);
       IO.mapRequired("Size", Info.DataRef.Size);
     }
+  } else if (Info.Kind == wasm::WASM_SYMBOL_TYPE_SECTION) {
+    IO.mapRequired("SectionType", Info.SectionType);
+    if (Info.SectionType == wasm::WASM_SEC_CUSTOM)
+      IO.mapRequired("SectionName", Info.SectionName);
   } else {
     llvm_unreachable("unsupported symbol kind");
   }
 }
 
 void ScalarBitSetTraits<WasmYAML::LimitFlags>::bitset(
     IO &IO, WasmYAML::LimitFlags &Value) {
 #define BCase(X) IO.bitSetCase(Value, #X, wasm::WASM_LIMITS_FLAG_##X)

 }
 
 void ScalarEnumerationTraits<WasmYAML::SymbolKind>::enumeration(
     IO &IO, WasmYAML::SymbolKind &Kind) {
 #define ECase(X) IO.enumCase(Kind, #X, wasm::WASM_SYMBOL_TYPE_##X);
   ECase(FUNCTION);
   ECase(DATA);
   ECase(GLOBAL);
+  ECase(SECTION);
 #undef ECase
 }
 
 void ScalarEnumerationTraits<WasmYAML::ValueType>::enumeration(
     IO &IO, WasmYAML::ValueType &Type) {
 #define ECase(X) IO.enumCase(Type, #X, wasm::WASM_TYPE_##X);
   ECase(I32);
   ECase(I64);

lib/Target/WebAssembly/MCTargetDesc/WebAssemblyWasmObjectWriter.cpp

 
 #include "MCTargetDesc/WebAssemblyFixupKinds.h"
 #include "MCTargetDesc/WebAssemblyMCTargetDesc.h"
 #include "llvm/BinaryFormat/Wasm.h"
 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/MC/MCFixup.h"
 #include "llvm/MC/MCFixupKindInfo.h"
 #include "llvm/MC/MCObjectWriter.h"
+#include "llvm/MC/MCSectionWasm.h"
 #include "llvm/MC/MCSymbolWasm.h"
-#include "llvm/MC/MCWasmObjectWriter.h"
 #include "llvm/MC/MCValue.h"
+#include "llvm/MC/MCWasmObjectWriter.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
 
 using namespace llvm;
 
 namespace {
 class WebAssemblyWasmObjectWriter final : public MCWasmObjectTargetWriter {
 public:
static bool IsFunctionExpr(const MCExpr *Expr) {
   return false;
 }
 
 static bool IsFunctionType(const MCValue &Target) {
   const MCSymbolRefExpr *RefA = Target.getSymA();
   return RefA && RefA->getKind() == MCSymbolRefExpr::VK_WebAssembly_TYPEINDEX;
 }
 
+static const MCSection *GetFixupSection(const MCExpr *Expr) {
+  if (auto SyExp = dyn_cast<MCSymbolRefExpr>(Expr))
+    return &SyExp->getSymbol().getSection();
+
+  if (auto BinOp = dyn_cast<MCBinaryExpr>(Expr)) {
+    auto SectionLHS = GetFixupSection(BinOp->getLHS());
+    auto SectionRHS = GetFixupSection(BinOp->getRHS());
+    return SectionLHS == SectionRHS ? nullptr : SectionLHS;
+  }
+
+  if (auto UnOp = dyn_cast<MCUnaryExpr>(Expr))
+    return GetFixupSection(UnOp->getSubExpr());
+
+  return nullptr;
+}
+
 unsigned
 WebAssemblyWasmObjectWriter::getRelocType(const MCValue &Target,
                                           const MCFixup &Fixup) const {
   // WebAssembly functions are not allocated in the data address space. To
   // resolve a pointer to a function, we must use a special relocation type.
   bool IsFunction = IsFunctionExpr(Fixup.getValue());
 
   switch (unsigned(Fixup.getKind())) {
case WebAssembly::fixup_code_uleb128_i32:
     if (IsFunctionType(Target))
       return wasm::R_WEBASSEMBLY_TYPE_INDEX_LEB;
     if (IsFunction)
       return wasm::R_WEBASSEMBLY_FUNCTION_INDEX_LEB;
     return wasm::R_WEBASSEMBLY_MEMORY_ADDR_LEB;
   case FK_Data_4:
     if (IsFunction)
       return wasm::R_WEBASSEMBLY_TABLE_INDEX_I32;
+    if (auto Section = static_cast<const MCSectionWasm *>(
+            GetFixupSection(Fixup.getValue()))) {
+      if (Section->getKind().isText())
+        return wasm::R_WEBASSEMBLY_FUNCTION_OFFSET_I32;
+      else if (!Section->isWasmData())
+        return wasm::R_WEBASSEMBLY_SECTION_OFFSET_I32;
+    }
     return wasm::R_WEBASSEMBLY_MEMORY_ADDR_I32;
   case FK_Data_8:
     llvm_unreachable("FK_Data_8 not implemented yet");
   default:
     llvm_unreachable("unimplemented fixup kind");
   }
 }
 
 std::unique_ptr<MCObjectWriter>
 llvm::createWebAssemblyWasmObjectWriter(raw_pwrite_stream &OS,
                                         bool Is64Bit) {
   auto MOTW = llvm::make_unique<WebAssemblyWasmObjectWriter>(Is64Bit);
   return createWasmObjectWriter(std::move(MOTW), OS);
 }

tools/llvm-readobj/WasmDumper.cpp

void WasmDumper::printRelocation(const SectionRef &Section,
   Reloc.getTypeName(RelocTypeName);
   const wasm::WasmRelocation &WasmReloc = Obj->getWasmRelocation(Reloc);
 
   bool HasAddend = false;
   switch (RelocType) {
   case wasm::R_WEBASSEMBLY_MEMORY_ADDR_LEB:
   case wasm::R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
   case wasm::R_WEBASSEMBLY_MEMORY_ADDR_I32:
+  case wasm::R_WEBASSEMBLY_FUNCTION_OFFSET_I32:
+  case wasm::R_WEBASSEMBLY_SECTION_OFFSET_I32:
     HasAddend = true;
     break;
   default:
     break;
   }
   if (opts::ExpandRelocs) {
     DictScope Group(W, "Relocation");
     W.printNumber("Type", RelocTypeName, RelocType);

tools/obj2yaml/wasm2yaml.cpp

for (const wasm::WasmSymbolInfo &Symbol : Obj.linkingData().SymbolTable) {
       switch (Symbol.Kind) {
       case wasm::WASM_SYMBOL_TYPE_DATA:
         Info.DataRef = Symbol.DataRef;
         break;
       case wasm::WASM_SYMBOL_TYPE_FUNCTION:
       case wasm::WASM_SYMBOL_TYPE_GLOBAL:
         Info.ElementIndex = Symbol.ElementIndex;
         break;
+      case wasm::WASM_SYMBOL_TYPE_SECTION:
+        Info.SectionType = Symbol.SectionCode;
+        Info.SectionName = Symbol.SectionName;
+        break;
       }
       LinkingSec->SymbolTable.emplace_back(Info);
     }
     for (const wasm::WasmInitFunc &Func : Obj.linkingData().InitFunctions) {
       WasmYAML::InitFunction F{Func.Priority, Func.Symbol};
       LinkingSec->InitFunctions.emplace_back(F);
     }
     CustomSec = std::move(LinkingSec);

tools/yaml2obj/yaml2wasm.cpp

for (const WasmYAML::SymbolInfo &Info : Section.SymbolTable) {
       case wasm::WASM_SYMBOL_TYPE_DATA:
         writeStringRef(Info.Name, SubSection.GetStream());
         if ((Info.Flags & wasm::WASM_SYMBOL_UNDEFINED) == 0) {
           encodeULEB128(Info.DataRef.Segment, SubSection.GetStream());
           encodeULEB128(Info.DataRef.Offset, SubSection.GetStream());
           encodeULEB128(Info.DataRef.Size, SubSection.GetStream());
         }
         break;
+      case wasm::WASM_SYMBOL_TYPE_SECTION:
+        encodeULEB128(Info.SectionType, SubSection.GetStream());
+        if (Info.SectionType == wasm::WASM_SEC_CUSTOM)
+          writeStringRef(Info.SectionName, SubSection.GetStream());
+        break;
       default:
         llvm_unreachable("unexpected kind");
       }
     }
 
     SubSection.Done();
   }
 
for (auto &Segment : Section.Segments) {
     encodeULEB128(Segment.Content.binary_size(), OS);
     Segment.Content.writeAsBinary(OS);
   }
   return 0;
 }
 
 int WasmWriter::writeRelocSection(raw_ostream &OS,
                                   WasmYAML::Section &Sec) {
-  StringRef Name;
   switch (Sec.Type) {
     case wasm::WASM_SEC_CODE:
-      Name = "reloc.CODE";
+      writeStringRef("reloc.CODE", OS);
       break;
     case wasm::WASM_SEC_DATA:
-      Name = "reloc.DATA";
+      writeStringRef("reloc.DATA", OS);
+      break;
+    case wasm::WASM_SEC_CUSTOM: {
+      auto CustomSection = dyn_cast<WasmYAML::CustomSection>(&Sec);
+      if (!CustomSection->Name.startswith(".debug_")) {
+        llvm_unreachable("not yet implemented (only for debug sections)");
+        return 1;
+      }
+
+      writeStringRef(("reloc." + CustomSection->Name).str(), OS);
       break;
+    }
     default:
       llvm_unreachable("not yet implemented");
       return 1;
   }
 
-  writeStringRef(Name, OS);
   writeUint8(OS, Sec.Type);
+  if (Sec.Type == wasm::WASM_SEC_CUSTOM)
+    writeStringRef(dyn_cast<WasmYAML::CustomSection>(&Sec)->Name, OS);
   encodeULEB128(Sec.Relocations.size(), OS);
 
   for (auto Reloc: Sec.Relocations) {
     writeUint8(OS, Reloc.Type);
     encodeULEB128(Reloc.Offset, OS);
     encodeULEB128(Reloc.Index, OS);
     switch (Reloc.Type) {
       case wasm::R_WEBASSEMBLY_MEMORY_ADDR_LEB:
       case wasm::R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
       case wasm::R_WEBASSEMBLY_MEMORY_ADDR_I32:
+      case wasm::R_WEBASSEMBLY_FUNCTION_OFFSET_I32:
+      case wasm::R_WEBASSEMBLY_SECTION_OFFSET_I32:
         encodeULEB128(Reloc.Addend, OS);
     }
   }
   return 0;
 }
 
 
 int WasmWriter::writeWasm(raw_ostream &OS) {