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

375 ↗

(On Diff #137308)

No curly braces here.

891 ↗

(On Diff #137308)

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?

1011 ↗

(On Diff #137308)

remove curlys

1021 ↗

(On Diff #137308)

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

155 ↗

(On Diff #138480)

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

927 ↗

(On Diff #138480)

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

1074 ↗

(On Diff #138480)

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

[yurydelendik]

include/llvm/BinaryFormat/Wasm.h

155 ↗

(On Diff #138480)

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 ↗

(On Diff #138600)

This could probably be llvm::StringSet

lib/MC/WasmObjectWriter.cpp

1059 ↗

(On Diff #138600)

should this be indented?

1062 ↗

(On Diff #138600)

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

1062 ↗

(On Diff #138600)

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 ↗

(On Diff #140889)

Can you just write these 6 lines as:

CustomSectionsRelocations[FixupSectionName].push_back(Rec);

tools/yaml2obj/yaml2wasm.cpp

439 ↗

(On Diff #140889)

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 ↗

(On Diff #140889)

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 ↗

(On Diff #140889)

MCSection *Section (here and 141)

[yurydelendik]

Update style via clang-format
Review fixes

[yurydelendik]

lib/MC/WasmObjectWriter.cpp

52 ↗

(On Diff #140889)

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

[sbc100]

lib/MC/WasmObjectWriter.cpp

52 ↗

(On Diff #140889)

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 ↗

(On Diff #141250)

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 ↗

(On Diff #141250)

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 ↗

(On Diff #141936)

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

lib/MC/WasmObjectWriter.cpp

175 ↗

(On Diff #141936)

How about just a bool here? isDebug?

490 ↗

(On Diff #141936)

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 ↗

(On Diff #141936)

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

1237 ↗

(On Diff #141936)

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 ↗

(On Diff #141936)

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

lib/Object/WasmObjectFile.cpp

1237 ↗

(On Diff #141936)

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

[sbc100]

lib/Object/WasmObjectFile.cpp

1174 ↗

(On Diff #141936)

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

490 ↗

(On Diff #141936)

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

[sbc100]

include/llvm/Object/RelocVisitor.h

323 ↗

(On Diff #141936)

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

177 ↗

(On Diff #143000)

Looks like this field isn't used. Remove?

401 ↗

(On Diff #143000)

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.

1236 ↗

(On Diff #143000)

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

1242 ↗

(On Diff #143000)

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 ↗

(On Diff #144019)

Just reuse ElementIndex?

[sbc100]

include/llvm/Object/RelocVisitor.h

339 ↗

(On Diff #144019)

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 ↗

(On Diff #144019)

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 ↗

(On Diff #144019)

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

1012 ↗

(On Diff #144035)

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

llvm/trunk/include/llvm/BinaryFormat/Wasm.h

 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;

llvm/trunk/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)

llvm/trunk/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
+        return 0;
+      }
+    }
+    HasError = true;
+    return 0;
+  }
 };
 
 } // end namespace object
 } // end namespace llvm
 
 #endif // LLVM_OBJECT_RELOCVISITOR_H

llvm/trunk/include/llvm/Object/Wasm.h

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;
 
   const uint8_t *getPtr(size_t Offset) const;
   Error parseSection(WasmSection &Sec);

llvm/trunk/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;
   uint32_t Index;
 };
 
 // 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.
WasmRelocationEntry(uint64_t Offset, const MCSymbolWasm *Symbol,
       : 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
 };
 
 struct WasmCustomSection {
+  const uint32_t INVALID_INDEX = -1;
+
   StringRef Name;
-  const SmallVectorImpl<char> &Contents;
+  MCSectionWasm *Section;
+
+  uint32_t OutputContentsOffset;
+  uint32_t OutputIndex;
 
-  WasmCustomSection(StringRef Name, const SmallVectorImpl<char> &Contents)
-      : Name(Name), Contents(Contents) {}
+  WasmCustomSection(StringRef Name, MCSectionWasm *Section)
+      : Name(Name), Section(Section), OutputContentsOffset(0),
+        OutputIndex(INVALID_INDEX) {}
 };
 
 #if !defined(NDEBUG)
 raw_ostream &operator<<(raw_ostream &OS, const WasmRelocationEntry &Rel) {
   Rel.print(OS);
   return OS;
 }
 #endif
class WasmObjectWriter : public MCObjectWriter {
   // for TABLE_INDEX relocation types (i.e. address taken functions).
   DenseMap<const MCSymbolWasm *, uint32_t> TableIndices;
   // Maps function/global symbols to the (shared) Symbol index space.
   DenseMap<const MCSymbolWasm *, uint32_t> SymbolIndices;
   // Maps function/global symbols to the function/global 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 *> CustomSectionSymbols;
+
+  // Stores output data (index, relocations, content offset) for custom
+  // section.
+  std::vector<WasmCustomSection> CustomSections;
+  // Relocations for fixing up references in the custom sections.
+  DenseMap<const MCSectionWasm *, std::vector<WasmRelocationEntry>>
+      CustomSectionsRelocations;
 
   DenseMap<WasmFunctionType, int32_t, WasmFunctionTypeDenseMapInfo>
       FunctionTypeIndices;
   SmallVector<WasmFunctionType, 4> FunctionTypes;
   SmallVector<WasmGlobal, 4> Globals;
   SmallVector<WasmDataSegment, 4> DataSegments;
-  std::vector<WasmCustomSection> CustomSections;
   unsigned NumFunctionImports = 0;
   unsigned NumGlobalImports = 0;
   uint32_t SectionCount = 0;
 
   // TargetObjectWriter wrappers.
   bool is64Bit() const { return TargetObjectWriter->is64Bit(); }
   unsigned getRelocType(const MCValue &Target, const MCFixup &Fixup) const {
     return TargetObjectWriter->getRelocType(Target, Fixup);
private:
   void reset() override {
     CodeRelocations.clear();
     DataRelocations.clear();
     TypeIndices.clear();
     SymbolIndices.clear();
     WasmIndices.clear();
     TableIndices.clear();
     DataLocations.clear();
+    CustomSectionsRelocations.clear();
     FunctionTypeIndices.clear();
     FunctionTypes.clear();
     Globals.clear();
     DataSegments.clear();
+    CustomSectionSymbols.clear();
     MCObjectWriter::reset();
     NumFunctionImports = 0;
     NumGlobalImports = 0;
   }
 
   void writeHeader(const MCAssembler &Asm);
 
   void recordRelocation(MCAssembler &Asm, const MCAsmLayout &Layout,
void writeCodeSection(const MCAssembler &Asm, const MCAsmLayout &Layout,
                         ArrayRef<WasmFunction> Functions);
   void writeDataSection();
   void writeRelocSection(uint32_t SectionIndex, StringRef Name,
                          ArrayRef<WasmRelocationEntry> Relocations);
   void writeLinkingMetaDataSection(
       ArrayRef<wasm::WasmSymbolInfo> SymbolInfos,
       ArrayRef<std::pair<uint16_t, uint32_t>> InitFuncs,
       const std::map<StringRef, std::vector<WasmComdatEntry>> &Comdats);
-  void writeUserCustomSections(ArrayRef<WasmCustomSection> CustomSections);
+  void writeCustomSections(const MCAssembler &Asm, const MCAsmLayout &Layout);
+  void writeCustomRelocSections();
+  void
+  updateCustomSectionRelocations(const SmallVector<WasmFunction, 4> &Functions,
+                                 const MCAsmLayout &Layout);
 
   uint32_t getProvisionalValue(const WasmRelocationEntry &RelEntry);
   void applyRelocations(ArrayRef<WasmRelocationEntry> Relocations,
                         uint64_t ContentsOffset);
 
   uint32_t getRelocationIndexValue(const WasmRelocationEntry &RelEntry);
   uint32_t getFunctionType(const MCSymbolWasm &Symbol);
   uint32_t registerFunctionType(const MCSymbolWasm &Symbol);
void WasmObjectWriter::startSection(SectionBookkeeping &Section,
   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();
+  Section.PayloadOffset = getStream().tell();
   Section.Index = SectionCount++;
 }
 
 void WasmObjectWriter::startCustomSection(SectionBookkeeping &Section,
                                           StringRef Name) {
   DEBUG(dbgs() << "startCustomSection " << Name << "\n");
   startSection(Section, wasm::WASM_SEC_CUSTOM);
+
+  // The position where the section header ends, for measuring its size.
+  Section.PayloadOffset = getStream().tell();
+
   // Custom sections in wasm also have a string identifier.
   writeString(Name);
+
+  // The position where the custom 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())
+  // TODO: Add support for non-debug metadata sections?
+  if (FixupSection.getKind().isMetadata() &&
+      !FixupSection.getSectionName().startswith(".debug_"))
     return;
 
   if (const MCSymbolRefExpr *RefB = Target.getSymB()) {
     assert(RefB->getKind() == MCSymbolRefExpr::VK_None &&
            "Should not have constructed this");
 
     // Let A, B and C being the components of Target and R be the location of
     // the fixup. If the fixup is not pcrel, we want to compute (A - B + C).
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");
 
-  // Relocation other than R_WEBASSEMBLY_TYPE_INDEX_LEB are currently required
-  // to be against a named symbol.
+  // Relocation other than R_WEBASSEMBLY_TYPE_INDEX_LEB,
+  // R_WEBASSEMBLY_SECTION_OFFSET_I32 or R_WEBASSEMBLY_FUNCTION_OFFSET_I32
+  // are currently required to be against a named symbol.
   // TODO(sbc): Add support for relocations against unnamed temporaries such
   // as those generated by llvm's `blockaddress`.
   // See: test/MC/WebAssembly/blockaddress.ll
-  if (SymA->getName().empty() && Type != wasm::R_WEBASSEMBLY_TYPE_INDEX_LEB)
+  if (SymA->getName().empty() &&
+      !(Type == wasm::R_WEBASSEMBLY_TYPE_INDEX_LEB ||
+        Type == wasm::R_WEBASSEMBLY_FUNCTION_OFFSET_I32 ||
+        Type == wasm::R_WEBASSEMBLY_SECTION_OFFSET_I32))
     report_fatal_error("relocations against un-named temporaries are not yet "
                        "supported by wasm");
 
-  if (FixupSection.isWasmData())
+  if (FixupSection.isWasmData()) {
     DataRelocations.push_back(Rec);
-  else if (FixupSection.getKind().isText())
+  } else if (FixupSection.getKind().isText()) {
     CodeRelocations.push_back(Rec);
-  else
+  } else if (FixupSection.getKind().isMetadata()) {
+    assert(FixupSection.getSectionName().startswith(".debug_"));
+    CustomSectionsRelocations[&FixupSection].push_back(Rec);
+  } else {
     llvm_unreachable("unexpected section type");
   }
+}
 
 // Write X as an (unsigned) LEB value at offset Offset in Stream, padded
 // to allow patching.
 static void
 WritePatchableLEB(raw_pwrite_stream &Stream, uint32_t X, uint64_t Offset) {
   uint8_t Buffer[5];
   unsigned SizeLen = encodeULEB128(X, Buffer, 5);
   assert(SizeLen == 5);
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 = *CustomSectionSymbols.find(RelEntry.Symbol)->second;
+    return Section.getSectionOffset() + RelEntry.Addend;
+  }
   case wasm::R_WEBASSEMBLY_MEMORY_ADDR_LEB:
   case wasm::R_WEBASSEMBLY_MEMORY_ADDR_I32:
   case wasm::R_WEBASSEMBLY_MEMORY_ADDR_SLEB: {
     // Provisional value is address of the global
     const MCSymbolWasm *Sym = ResolveSymbol(*RelEntry.Symbol);
     // For undefined symbols, use zero
     if (!Sym->isDefined())
       return 0;
for (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");
for (const WasmRelocationEntry& RelEntry : Relocations) {
     encodeULEB128(Index, Stream);
     if (RelEntry.hasAddend())
       encodeSLEB128(RelEntry.Addend, Stream);
   }
 
   endSection(Section);
 }
 
+void WasmObjectWriter::writeCustomRelocSections() {
+  for (const auto &Sec : CustomSections) {
+    auto &Relocations = CustomSectionsRelocations[Sec.Section];
+    writeRelocSection(Sec.OutputIndex, Sec.Name, Relocations);
+  }
+}
+
 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;
   startCustomSection(Section, "linking");
   encodeULEB128(wasm::WasmMetadataVersion, getStream());
 
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: {
+        const uint32_t SectionIndex =
+            CustomSections[Sym.ElementIndex].OutputIndex;
+        encodeULEB128(SectionIndex, getStream());
+        break;
+      }
       default:
         llvm_unreachable("unexpected kind");
       }
     }
     endSection(SubSection);
   }
 
   if (DataSegments.size()) {
for (const auto &C : Comdats) {
       }
     }
     endSection(SubSection);
   }
 
   endSection(Section);
 }
 
-void WasmObjectWriter::writeUserCustomSections(
-    ArrayRef<WasmCustomSection> CustomSections) {
-  for (const auto &CustomSection : CustomSections) {
+void WasmObjectWriter::writeCustomSections(const MCAssembler &Asm,
+                                           const MCAsmLayout &Layout) {
+  for (auto &CustomSection : CustomSections) {
     SectionBookkeeping Section;
+    auto *Sec = CustomSection.Section;
     startCustomSection(Section, CustomSection.Name);
-    writeBytes(CustomSection.Contents);
+
+    Sec->setSectionOffset(getStream().tell() - Section.ContentsOffset);
+    Asm.writeSectionData(Sec, Layout);
+
+    CustomSection.OutputContentsOffset = Section.ContentsOffset;
+    CustomSection.OutputIndex = Section.Index;
+
     endSection(Section);
   }
 }
 
+void WasmObjectWriter::updateCustomSectionRelocations(
+    const SmallVector<WasmFunction, 4> &Functions, const MCAsmLayout &Layout) {
+  std::map<const MCSection *, const MCSymbolWasm *> SectionSymbols;
+  for (const auto &P : CustomSectionSymbols)
+    SectionSymbols[P.second] = P.first;
+  std::map<const MCSection *, const MCSymbolWasm *> FuncSymbols;
+  for (const auto &FuncInfo : Functions)
+    FuncSymbols[&FuncInfo.Sym->getSection()] = FuncInfo.Sym;
+
+  // Patch relocation records for R_WEBASSEMBLY_FUNCTION_OFFSET_I32 and
+  // R_WEBASSEMBLY_SECTION_OFFSET_I32. The Addend is stuffed the offset from
+  // the beginning of the function or custom section -- all such relocations
+  // target the function or custom section starts.
+  for (auto &Section : CustomSections) {
+    auto &Relocations = CustomSectionsRelocations[Section.Section];
+    for (WasmRelocationEntry &RelEntry : Relocations) {
+      switch (RelEntry.Type) {
+      case wasm::R_WEBASSEMBLY_FUNCTION_OFFSET_I32: {
+        assert(RelEntry.hasAddend());
+        auto &Section =
+            static_cast<MCSectionWasm &>(RelEntry.Symbol->getSection());
+        RelEntry.Addend += Layout.getSymbolOffset(*RelEntry.Symbol);
+        RelEntry.Symbol = FuncSymbols[&Section];
+        break;
+      }
+      case wasm::R_WEBASSEMBLY_SECTION_OFFSET_I32: {
+        assert(RelEntry.hasAddend());
+        auto &Section =
+            static_cast<MCSectionWasm &>(RelEntry.Symbol->getSection());
+        RelEntry.Addend += Layout.getSymbolOffset(*RelEntry.Symbol);
+        RelEntry.Symbol = SectionSymbols[&Section];
+        break;
+      }
+      default:
+        break;
+      }
+    }
+
+    // Apply fixups.
+    applyRelocations(Relocations, Section.OutputContentsOffset);
+  }
+}
+
 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());
if (!WS.isDefined() && !WS.isComdat()) {
       }
     }
   }
 
   // Populate DataSegments, which must be done before populating DataLocations.
   for (MCSection &Sec : Asm) {
     auto &Section = static_cast<MCSectionWasm &>(Sec);
 
-    if (cast<MCSectionWasm>(Sec).getSectionName().startswith(
-            ".custom_section.")) {
+    if (Section.getSectionName().startswith(".custom_section.")) {
       if (Section.getFragmentList().empty())
         continue;
       if (Section.getFragmentList().size() != 1)
         report_fatal_error(
             "only one .custom_section section fragment supported");
       const MCFragment &Frag = *Section.begin();
       if (Frag.hasInstructions() || Frag.getKind() != MCFragment::FT_Data)
         report_fatal_error("only data supported in .custom_section section");
       const auto &DataFrag = cast<MCDataFragment>(Frag);
       if (!DataFrag.getFixups().empty())
         report_fatal_error("fixups not supported in .custom_section section");
       StringRef UserName = Section.getSectionName().substr(16);
-      const SmallVectorImpl<char> &Contents = DataFrag.getContents();
-      CustomSections.push_back(WasmCustomSection(UserName, Contents));
+      CustomSections.emplace_back(UserName, &Section);
       continue;
     }
 
     if (!Section.isWasmData())
       continue;
 
     // .init_array sections are handled specially elsewhere.
     if (cast<MCSectionWasm>(Sec).getSectionName().startswith(".init_array"))
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 (MCSection &Sec : Asm) {
+    auto &DebugSection = static_cast<MCSectionWasm &>(Sec);
+    StringRef SectionName = DebugSection.getSectionName();
+
+    // TODO: Add support for non-debug metadata sections?
+    if (!Sec.getKind().isMetadata() || !SectionName.startswith(".debug_"))
+      continue;
+
+    uint32_t ElementIndex = CustomSections.size();
+    CustomSections.emplace_back(SectionName, &DebugSection);
+
+    MCSymbolWasm *SectionSym =
+        cast<MCSymbolWasm>(Ctx.getOrCreateSymbol(SectionName));
+    CustomSectionSymbols[SectionSym] = &DebugSection;
+
+    wasm::WasmSymbolInfo Info;
+    Info.Name = SectionSym->getName();
+    Info.Kind = wasm::WASM_SYMBOL_TYPE_SECTION;
+    Info.Flags = 0;
+    Info.ElementIndex = ElementIndex;
+    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();
-  writeUserCustomSections(CustomSections);
+  writeCustomSections(Asm, Layout);
+  updateCustomSectionRelocations(Functions, Layout);
   writeLinkingMetaDataSection(SymbolInfos, InitFuncs, Comdats);
   writeRelocSection(CodeSectionIndex, "CODE", CodeRelocations);
   writeRelocSection(DataSectionIndex, "DATA", DataRelocations);
+  writeCustomRelocSections();
 
   // TODO: Translate the .comment section to the output.
-  // 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);
 }

llvm/trunk/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.ElementIndex = readVaruint32(Ptr);
+      // Use somewhat unique section name as symbol name.
+      StringRef SectionName = Sections[Info.ElementIndex].Name;
+      Info.Name = SectionName;
+      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;
   }
   llvm_unreachable("invalid symbol type");
 }
 
 uint64_t WasmObjectFile::getSymbolValueImpl(DataRefImpl Symb) const {
   return getWasmSymbolValue(getWasmSymbol(Symb));
 }
 
WasmObjectFile::getSymbolType(DataRefImpl Symb) const {
 
   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:
+    return SymbolRef::ST_Debug;
   }
 
   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: {
+    Ref.d.a = Sym.Info.ElementIndex;
+    break;
+  }
   default:
     llvm_unreachable("Unknown WasmSymbol::SymbolType");
   }
   return section_iterator(SectionRef(Ref, this));
 }
 
 void WasmObjectFile::moveSectionNext(DataRefImpl &Sec) const { Sec.d.a++; }
 

llvm/trunk/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("Section", Info.ElementIndex);
   } 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);

llvm/trunk/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)) {
+    if (SyExp->getSymbol().isInSection())
+      return &SyExp->getSymbol().getSection();
+    return nullptr;
+  }
+
+  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);
 }

llvm/trunk/test/MC/WebAssembly/debug-info.ll

-; RUN: llc -filetype=obj %s -o - | llvm-readobj -r -s -expand-relocs
+; RUN: llc -filetype=obj %s -o - | llvm-readobj -r -s | FileCheck %s
+
+; CHECK: Format: WASM
+; CHECK-NEXT:Arch: wasm32
+; CHECK-NEXT:AddressSize: 32bit
+; CHECK-NEXT:Sections [
+; CHECK-NEXT:  Section {
+; CHECK-NEXT:    Type: TYPE (0x1)
+; CHECK-NEXT:    Size: 4
+; CHECK-NEXT:    Offset: 8
+; CHECK-NEXT:  }
+; CHECK-NEXT:  Section {
+; CHECK-NEXT:    Type: IMPORT (0x2)
+; CHECK-NEXT:    Size: 58
+; CHECK-NEXT:    Offset: 18
+; CHECK-NEXT:  }
+; CHECK-NEXT:  Section {
+; CHECK-NEXT:    Type: FUNCTION (0x3)
+; CHECK-NEXT:    Size: 2
+; CHECK-NEXT:    Offset: 82
+; CHECK-NEXT:  }
+; CHECK-NEXT:  Section {
+; CHECK-NEXT:    Type: ELEM (0x9)
+; CHECK-NEXT:    Size: 7
+; CHECK-NEXT:    Offset: 90
+; CHECK-NEXT:  }
+; CHECK-NEXT:  Section {
+; CHECK-NEXT:    Type: CODE (0xA)
+; CHECK-NEXT:    Size: 4
+; CHECK-NEXT:    Offset: 103
+; CHECK-NEXT:  }
+; CHECK-NEXT:  Section {
+; CHECK-NEXT:    Type: DATA (0xB)
+; CHECK-NEXT:    Size: 19
+; CHECK-NEXT:    Offset: 113
+; CHECK-NEXT:    Segments [
+; CHECK-NEXT:      Segment {
+; CHECK-NEXT:        Name: .data.foo
+; CHECK-NEXT:        Size: 4
+; CHECK-NEXT:        Offset: 0
+; CHECK-NEXT:      }
+; CHECK-NEXT:      Segment {
+; CHECK-NEXT:        Name: .data.ptr2
+; CHECK-NEXT:        Size: 4
+; CHECK-NEXT:        Offset: 4
+; CHECK-NEXT:      }
+; CHECK-NEXT:    ]
+; CHECK-NEXT:  }
+; CHECK-NEXT:  Section {
+; CHECK-NEXT:    Type: CUSTOM (0x0)
+; CHECK-NEXT:    Size: 121
+; CHECK-NEXT:    Offset: 138
+; CHECK-NEXT:    Name: .debug_str
+; CHECK-NEXT:  }
+; CHECK-NEXT:  Section {
+; CHECK-NEXT:    Type: CUSTOM (0x0)
+; CHECK-NEXT:    Size: 84
+; CHECK-NEXT:    Offset: 276
+; CHECK-NEXT:    Name: .debug_abbrev
+; CHECK-NEXT:  }
+; CHECK-NEXT:  Section {
+; CHECK-NEXT:    Type: CUSTOM (0x0)
+; CHECK-NEXT:    Size: 106
+; CHECK-NEXT:    Offset: 380
+; CHECK-NEXT:    Name: .debug_info
+; CHECK-NEXT:  }
+; CHECK-NEXT:  Section {
+; CHECK-NEXT:    Type: CUSTOM (0x0)
+; CHECK-NEXT:    Size: 0
+; CHECK-NEXT:    Offset: 504
+; CHECK-NEXT:    Name: .debug_ranges
+; CHECK-NEXT:  }
+; CHECK-NEXT:  Section {
+; CHECK-NEXT:    Type: CUSTOM (0x0)
+; CHECK-NEXT:    Size: 1
+; CHECK-NEXT:    Offset: 524
+; CHECK-NEXT:    Name: .debug_macinfo
+; CHECK-NEXT:  }
+; CHECK-NEXT:  Section {
+; CHECK-NEXT:    Type: CUSTOM (0x0)
+; CHECK-NEXT:    Size: 42
+; CHECK-NEXT:    Offset: 546
+; CHECK-NEXT:    Name: .debug_pubnames
+; CHECK-NEXT:  }
+; CHECK-NEXT:  Section {
+; CHECK-NEXT:    Type: CUSTOM (0x0)
+; CHECK-NEXT:    Size: 26
+; CHECK-NEXT:    Offset: 610
+; CHECK-NEXT:    Name: .debug_pubtypes
+; CHECK-NEXT:  }
+; CHECK-NEXT:  Section {
+; CHECK-NEXT:    Type: CUSTOM (0x0)
+; CHECK-NEXT:    Size: 57
+; CHECK-NEXT:    Offset: 658
+; CHECK-NEXT:    Name: .debug_line
+; CHECK-NEXT:  }
+; CHECK-NEXT:  Section {
+; CHECK-NEXT:    Type: CUSTOM (0x0)
+; CHECK-NEXT:    Size: 100
+; CHECK-NEXT:    Offset: 733
+; CHECK-NEXT:    Name: linking
+; CHECK-NEXT:  }
+; CHECK-NEXT:  Section {
+; CHECK-NEXT:    Type: CUSTOM (0x0)
+; CHECK-NEXT:    Size: 9
+; CHECK-NEXT:    Offset: 847
+; CHECK-NEXT:    Name: reloc.DATA
+; CHECK-NEXT:  }
+; CHECK-NEXT:  Section {
+; CHECK-NEXT:    Type: CUSTOM (0x0)
+; CHECK-NEXT:    Size: 58
+; CHECK-NEXT:    Offset: 873
+; CHECK-NEXT:    Name: reloc..debug_info
+; CHECK-NEXT:  }
+; CHECK-NEXT:  Section {
+; CHECK-NEXT:    Type: CUSTOM (0x0)
+; CHECK-NEXT:    Size: 6
+; CHECK-NEXT:    Offset: 955
+; CHECK-NEXT:    Name: reloc..debug_pubnames
+; CHECK-NEXT:  }
+; CHECK-NEXT:  Section {
+; CHECK-NEXT:    Type: CUSTOM (0x0)
+; CHECK-NEXT:    Size: 6
+; CHECK-NEXT:    Offset: 989
+; CHECK-NEXT:    Name: reloc..debug_pubtypes
+; CHECK-NEXT:  }
+; CHECK-NEXT:  Section {
+; CHECK-NEXT:    Type: CUSTOM (0x0)
+; CHECK-NEXT:    Size: 6
+; CHECK-NEXT:    Offset: 1023
+; CHECK-NEXT:    Name: reloc..debug_line
+; CHECK-NEXT:  }
+; CHECK-NEXT:]
+; CHECK-NEXT:Relocations [
+; CHECK-NEXT:  Section (6) DATA {
+; CHECK-NEXT:    0x6 R_WEBASSEMBLY_MEMORY_ADDR_I32[10] 0
+; CHECK-NEXT:    0xF R_WEBASSEMBLY_TABLE_INDEX_I32[8]
+; CHECK-NEXT:  }
+; CHECK-NEXT:  Section (9) .debug_info {
+; CHECK-NEXT:    0x6 R_WEBASSEMBLY_SECTION_OFFSET_I32[1] 0
+; CHECK-NEXT:    0xC R_WEBASSEMBLY_SECTION_OFFSET_I32[0] 0
+; CHECK-NEXT:    0x12 R_WEBASSEMBLY_SECTION_OFFSET_I32[0] 55
+; CHECK-NEXT:    0x16 R_WEBASSEMBLY_SECTION_OFFSET_I32[7] 0
+; CHECK-NEXT:    0x1A R_WEBASSEMBLY_SECTION_OFFSET_I32[0] 62
+; CHECK-NEXT:    0x1E R_WEBASSEMBLY_FUNCTION_OFFSET_I32[8] 0
+; CHECK-NEXT:    0x27 R_WEBASSEMBLY_SECTION_OFFSET_I32[0] 105
+; CHECK-NEXT:    0x33 R_WEBASSEMBLY_MEMORY_ADDR_I32[9] 0
+; CHECK-NEXT:    0x3D R_WEBASSEMBLY_SECTION_OFFSET_I32[0] 109
+; CHECK-NEXT:    0x44 R_WEBASSEMBLY_SECTION_OFFSET_I32[0] 113
+; CHECK-NEXT:    0x50 R_WEBASSEMBLY_MEMORY_ADDR_I32[11] 0
+; CHECK-NEXT:    0x5B R_WEBASSEMBLY_FUNCTION_OFFSET_I32[8] 0
+; CHECK-NEXT:    0x63 R_WEBASSEMBLY_SECTION_OFFSET_I32[0] 118
+; CHECK-NEXT:  }
+; CHECK-NEXT:  Section (12) .debug_pubnames {
+; CHECK-NEXT:    0x6 R_WEBASSEMBLY_SECTION_OFFSET_I32[2] 0
+; CHECK-NEXT:  }
+; CHECK-NEXT:  Section (13) .debug_pubtypes {
+; CHECK-NEXT:    0x6 R_WEBASSEMBLY_SECTION_OFFSET_I32[2] 0
+; CHECK-NEXT:  }
+; CHECK-NEXT:  Section (14) .debug_line {
+; CHECK-NEXT:    0x2B R_WEBASSEMBLY_FUNCTION_OFFSET_I32[8] 0
+; CHECK-NEXT:  }
+; CHECK-NEXT:]
 
 target triple = "wasm32-unknown-unknown-wasm"
 
-; Debug information is currently not supported.  This test simply verifies that
-; a valid object generated.
 source_filename = "test.c"
 
 @myextern = external global i32, align 4
 @foo = hidden global i32* @myextern, align 4, !dbg !0
 @ptr2 = hidden global void ()* @f2, align 4, !dbg !6
 
 ; Function Attrs: noinline nounwind optnone
 define hidden void @f2() #0 !dbg !17 {

llvm/trunk/test/MC/WebAssembly/dwarfdump.ll

+; RUN: llc -filetype=obj %s -o - | llvm-dwarfdump - | FileCheck %s
+
+; CHECK: .debug_info contents:
+; CHECK-NEXT: 0x00000000: Compile Unit: length = 0x00000066 version = 0x0004 abbr_offset = 0x0000 addr_size = 0x04 (next unit at 0x0000006a)
+
+; CHECK: 0x0000000b: DW_TAG_compile_unit
+; CHECK-NEXT:              DW_AT_producer ("clang version 6.0.0 (trunk 315924) (llvm/trunk 315960)")
+; CHECK-NEXT:              DW_AT_language (DW_LANG_C99)
+; CHECK-NEXT:              DW_AT_name ("test.c")
+; CHECK-NEXT:              DW_AT_stmt_list  (0x00000000)
+; CHECK-NEXT:              DW_AT_comp_dir ("/usr/local/google/home/sbc/dev/wasm/simple")
+; CHECK-NEXT:              DW_AT_GNU_pubnames (true)
+; CHECK-NEXT:              DW_AT_low_pc   (0x0000000000000002)
+; CHECK-NEXT:              DW_AT_high_pc    (0x0000000000000004)
+
+; CHECK: 0x00000026:   DW_TAG_variable
+; CHECK-NEXT:                DW_AT_name ("foo")
+; CHECK-NEXT:                DW_AT_type (0x00000037 "int*")
+; CHECK-NEXT:                DW_AT_external (true)
+; CHECK-NEXT:                DW_AT_decl_file  ("/usr/local/google/home/sbc/dev/wasm/simple/test.c")
+; CHECK-NEXT:                DW_AT_decl_line  (4)
+; CHECK-NEXT:                DW_AT_location (DW_OP_addr 0x0)
+
+; CHECK: 0x00000037:   DW_TAG_pointer_type
+; CHECK-NEXT:                DW_AT_type (0x0000003c "int")
+
+; CHECK: 0x0000003c:   DW_TAG_base_type
+; CHECK-NEXT:                DW_AT_name ("int")
+; CHECK-NEXT:                DW_AT_encoding (DW_ATE_signed)
+; CHECK-NEXT:                DW_AT_byte_size  (0x04)
+
+; CHECK: 0x00000043:   DW_TAG_variable
+; CHECK-NEXT:                DW_AT_name ("ptr2")
+; CHECK-NEXT:                DW_AT_type (0x00000054 "subroutine *")
+; CHECK-NEXT:                DW_AT_external (true)
+; CHECK-NEXT:                DW_AT_decl_file  ("/usr/local/google/home/sbc/dev/wasm/simple/test.c")
+; CHECK-NEXT:                DW_AT_decl_line  (5)
+; CHECK-NEXT:                DW_AT_location (DW_OP_addr 0x4)
+
+; CHECK: 0x00000054:   DW_TAG_pointer_type
+; CHECK-NEXT:                DW_AT_type (0x00000059 "subroutine ")
+
+; CHECK: 0x00000059:   DW_TAG_subroutine_type
+; CHECK-NEXT:                DW_AT_prototyped (true)
+
+; CHECK: 0x0000005a:   DW_TAG_subprogram
+; CHECK-NEXT:                DW_AT_low_pc (0x0000000000000002)
+; CHECK-NEXT:                DW_AT_high_pc  (0x0000000000000004)
+; CHECK-NEXT:                DW_AT_name ("f2")
+; CHECK-NEXT:                DW_AT_decl_file  ("/usr/local/google/home/sbc/dev/wasm/simple/test.c")
+; CHECK-NEXT:                DW_AT_decl_line  (2)
+; CHECK-NEXT:                DW_AT_prototyped (true)
+; CHECK-NEXT:                DW_AT_external   (true)
+
+; CHECK: 0x00000069:   NULL
+
+target triple = "wasm32-unknown-unknown-wasm"
+
+source_filename = "test.c"
+
+@myextern = external global i32, align 4
+@foo = hidden global i32* @myextern, align 4, !dbg !0
+@ptr2 = hidden global void ()* @f2, align 4, !dbg !6
+
+; Function Attrs: noinline nounwind optnone
+define hidden void @f2() #0 !dbg !17 {
+entry:
+  ret void, !dbg !18
+}
+
+attributes #0 = { noinline nounwind optnone "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="generic" "unsafe-fp-math"="false" "use-soft-float"="false" }
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!13, !14, !15}
+!llvm.ident = !{!16}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "foo", scope: !2, file: !3, line: 4, type: !11, isLocal: false, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 6.0.0 (trunk 315924) (llvm/trunk 315960)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5)
+!3 = !DIFile(filename: "test.c", directory: "/usr/local/google/home/sbc/dev/wasm/simple")
+!4 = !{}
+!5 = !{!0, !6}
+!6 = !DIGlobalVariableExpression(var: !7, expr: !DIExpression())
+!7 = distinct !DIGlobalVariable(name: "ptr2", scope: !2, file: !3, line: 5, type: !8, isLocal: false, isDefinition: true)
+!8 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !9, size: 32)
+!9 = !DISubroutineType(types: !10)
+!10 = !{null}
+!11 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !12, size: 32)
+!12 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!13 = !{i32 2, !"Dwarf Version", i32 4}
+!14 = !{i32 2, !"Debug Info Version", i32 3}
+!15 = !{i32 1, !"wchar_size", i32 4}
+!16 = !{!"clang version 6.0.0 (trunk 315924) (llvm/trunk 315960)"}
+!17 = distinct !DISubprogram(name: "f2", scope: !3, file: !3, line: 2, type: !9, isLocal: false, isDefinition: true, scopeLine: 2, flags: DIFlagPrototyped, isOptimized: false, unit: !2, variables: !4)
+!18 = !DILocation(line: 2, column: 16, scope: !17)

llvm/trunk/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);

llvm/trunk/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.ElementIndex = Symbol.ElementIndex;
+        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);
     }

llvm/trunk/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.ElementIndex, 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,
                                   uint32_t SectionIndex) {
-  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);
   encodeULEB128(SectionIndex, 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) {