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

[yurydelendik]

Summary

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

[yurydelendik]

extract getFunctionSizeLength

[ruiu]

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

[yurydelendik]

In D45118#1054556, @ruiu wrote:

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

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

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

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

Can DWARF really support wasm-style memory abstraction?

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

[sbc100]

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

[yurydelendik]

In D45118#1058696, @sbc100 wrote:

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

It is okay with me.

[yurydelendik]

Don't export DefinedSection symbols.

[ruiu]

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

[ruiu]

wasm/InputFiles.cpp

314

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

[sbc100]

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

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

[yurydelendik]

Rebase on top of D45340

[ruiu]

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

wasm/InputChunks.h

196

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

197

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

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

wasm/InputFiles.cpp

46

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

47

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

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

148

Are you sure that uint8_t is enough?

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

155

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

195

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

I.e.

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

or

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

are OK, but

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

isn't.

[yurydelendik]

Rebase at D45579.
Address review comments.

[yurydelendik]

wasm/InputFiles.cpp

46

Renamed to getFunctionCodeOffset

314

Yes, it is. It will be defined in D44184

[yurydelendik]

Rebase on top of D45795

[sbc100]

wasm/InputFiles.cpp

112

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

117

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

335

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

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

wasm/SymbolTable.h

42 ↗

(On Diff #144045)

We already type with this name in OutputSections.h.

wasm/Symbols.h

196

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

[yurydelendik]

Rename SyntheticSection
Remove UndefinedSection
Add getFunctionInputOffset
Rebase

[yurydelendik]

wasm/SymbolTable.h

42 ↗

(On Diff #144045)

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

[sbc100]

wasm/InputChunks.h

28

No longer needed here? maybe in the cpp file?

wasm/InputFiles.cpp

155

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

Why can't you just replace this code with ?

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

I'm probably missing something here.

[yurydelendik]

wasm/InputFiles.cpp

155

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

Yeah, I'm trying to figure this out atm

Why can't you just replace this code with ?

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

[yurydelendik]

Remove tracking of InputSection from Symtab.

[sbc100]

Looking much better in general

wasm/Symbols.h

183

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

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

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

wasm/Writer.cpp

790

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

802

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

806

This loop seems like its doing some different things.

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

811

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

[yurydelendik]

Simplify assignSymtab for CombinedSectionSymbols
Fix createCustomSections for non-referred sections

[yurydelendik]

wasm/Symbols.h

183

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

wasm/Writer.cpp

802

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

[yurydelendik]

Move CombinedSectionSymbols creation
Add test

[sbc100]

wasm/InputFiles.cpp

47

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

83

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

Also, perhaps getSectionSymbol should just return DefinedSection instead?

335

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

wasm/Symbols.h

196

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

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

Would that work? I could be missing something.

wasm/Writer.cpp

399

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

491

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

e.g:

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

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

[yurydelendik]

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

[sbc100]

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

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

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

wasm/Writer.cpp

398

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

400–401

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

780

SectionSymbolIndices?

791

Can we drop the first clause of this condition?

792

.count(Name) == 0?

[yurydelendik]

Remove startswith(".debug") checks
Rename SectionSymbolIndices

[sbc100]

wasm/InputFiles.cpp

80

No need for this cast anymore

154

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

[sbc100]

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

[yurydelendik]

Remove cast<SectionSymbol>

[sbc100]

wasm/Writer.cpp

765

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

[yurydelendik]

Remove isa<SectionSymbol> check

[sbc100]

Fixed in rLLD331566

test/wasm/Inputs/debuginfo1.ll

+; ModuleID = 'hi.c'
+source_filename = "hi.c"
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-unknown-wasm"
+
+; // hi.c:
+; extern void foo(int);
+;  
+; int test(int t) {
+;   return t * t;
+; }
+;
+; int _start() {
+;   foo(test(10));
+;   return 0;
+; }
+
+; Function Attrs: nounwind readnone
+define hidden i32 @test(i32 %t) local_unnamed_addr #0 !dbg !7 {
+entry:
+  call void @llvm.dbg.value(metadata i32 %t, metadata !12, metadata !DIExpression()), !dbg !13
+  %mul = mul nsw i32 %t, %t, !dbg !14
+  ret i32 %mul, !dbg !15
+}
+
+; Function Attrs: nounwind
+define hidden i32 @_start() local_unnamed_addr #1 !dbg !16 {
+entry:
+  tail call void @foo(i32 100) #4, !dbg !19
+  ret i32 0, !dbg !20
+}
+
+declare void @foo(i32) local_unnamed_addr #2
+
+; Function Attrs: nounwind readnone speculatable
+declare void @llvm.dbg.value(metadata, metadata, metadata) #3
+
+attributes #0 = { nounwind readnone "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" }
+attributes #1 = { nounwind "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" }
+attributes #2 = { "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-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" }
+attributes #3 = { nounwind readnone speculatable }
+attributes #4 = { nounwind }
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3, !4, !5}
+!llvm.ident = !{!6}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 7.0.0 (trunk 331321)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2)
+!1 = !DIFile(filename: "hi.c", directory: "/Users/yury/llvmwasm")
+!2 = !{}
+!3 = !{i32 2, !"Dwarf Version", i32 4}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{i32 1, !"wchar_size", i32 4}
+!6 = !{!"clang version 7.0.0 (trunk 331321)"}
+!7 = distinct !DISubprogram(name: "test", scope: !1, file: !1, line: 3, type: !8, isLocal: false, isDefinition: true, scopeLine: 3, flags: DIFlagPrototyped, isOptimized: true, unit: !0, variables: !11)
+!8 = !DISubroutineType(types: !9)
+!9 = !{!10, !10}
+!10 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!11 = !{!12}
+!12 = !DILocalVariable(name: "t", arg: 1, scope: !7, file: !1, line: 3, type: !10)
+!13 = !DILocation(line: 3, column: 14, scope: !7)
+!14 = !DILocation(line: 4, column: 12, scope: !7)
+!15 = !DILocation(line: 4, column: 3, scope: !7)
+!16 = distinct !DISubprogram(name: "_start", scope: !1, file: !1, line: 7, type: !17, isLocal: false, isDefinition: true, scopeLine: 7, isOptimized: true, unit: !0, variables: !2)
+!17 = !DISubroutineType(types: !18)
+!18 = !{!10}
+!19 = !DILocation(line: 8, column: 3, scope: !16)
+!20 = !DILocation(line: 9, column: 3, scope: !16)

test/wasm/Inputs/debuginfo2.ll

+; ModuleID = 'hi_foo.c'
+source_filename = "hi_foo.c"
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-unknown-wasm"
+
+; // hi_foo.c:
+; int y[2] = {23, 41};
+;  
+; void foo(int p) {
+;   y[p & 1]++;
+; }
+
+@y = hidden local_unnamed_addr global [2 x i32] [i32 23, i32 41], align 4, !dbg !0
+
+; Function Attrs: nounwind
+define hidden void @foo(i32 %p) local_unnamed_addr #0 !dbg !14 {
+entry:
+  call void @llvm.dbg.value(metadata i32 %p, metadata !18, metadata !DIExpression()), !dbg !19
+  %and = and i32 %p, 1, !dbg !20
+  %arrayidx = getelementptr inbounds [2 x i32], [2 x i32]* @y, i32 0, i32 %and, !dbg !21
+  %0 = load i32, i32* %arrayidx, align 4, !dbg !22, !tbaa !23
+  %inc = add nsw i32 %0, 1, !dbg !22
+  store i32 %inc, i32* %arrayidx, align 4, !dbg !22, !tbaa !23
+  ret void, !dbg !27
+}
+
+; Function Attrs: nounwind readnone speculatable
+declare void @llvm.dbg.value(metadata, metadata, metadata) #1
+
+attributes #0 = { nounwind "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" }
+attributes #1 = { nounwind readnone speculatable }
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!10, !11, !12}
+!llvm.ident = !{!13}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "y", scope: !2, file: !3, line: 1, type: !6, isLocal: false, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 7.0.0 (trunk 331321)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5)
+!3 = !DIFile(filename: "hi_foo.c", directory: "/Users/yury/llvmwasm")
+!4 = !{}
+!5 = !{!0}
+!6 = !DICompositeType(tag: DW_TAG_array_type, baseType: !7, size: 64, elements: !8)
+!7 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!8 = !{!9}
+!9 = !DISubrange(count: 2)
+!10 = !{i32 2, !"Dwarf Version", i32 4}
+!11 = !{i32 2, !"Debug Info Version", i32 3}
+!12 = !{i32 1, !"wchar_size", i32 4}
+!13 = !{!"clang version 7.0.0 (trunk 331321)"}
+!14 = distinct !DISubprogram(name: "foo", scope: !3, file: !3, line: 3, type: !15, isLocal: false, isDefinition: true, scopeLine: 3, flags: DIFlagPrototyped, isOptimized: true, unit: !2, variables: !17)
+!15 = !DISubroutineType(types: !16)
+!16 = !{null, !7}
+!17 = !{!18}
+!18 = !DILocalVariable(name: "p", arg: 1, scope: !14, file: !3, line: 3, type: !7)
+!19 = !DILocation(line: 3, column: 14, scope: !14)
+!20 = !DILocation(line: 4, column: 7, scope: !14)
+!21 = !DILocation(line: 4, column: 3, scope: !14)
+!22 = !DILocation(line: 4, column: 11, scope: !14)
+!23 = !{!24, !24, i64 0}
+!24 = !{!"int", !25, i64 0}
+!25 = !{!"omnipotent char", !26, i64 0}
+!26 = !{!"Simple C/C++ TBAA"}
+!27 = !DILocation(line: 5, column: 1, scope: !14)

test/wasm/debuginfo.test

+RUN: llc -filetype=obj %p/Inputs/debuginfo1.ll -o %t.debuginfo1.o
+RUN: llc -filetype=obj %p/Inputs/debuginfo2.ll -o %t.debuginfo2.o
+RUN: wasm-ld -r -o %t.wasm %t.debuginfo1.o %t.debuginfo2.o
+RUN: llvm-dwarfdump %t.wasm | FileCheck %s
+
+CHECK: file format WASM
+
+CHECK: .debug_info contents:
+CHECK: DW_TAG_compile_unit
+CHECK-NEXT:              DW_AT_producer ("clang version 7.0.0 (trunk 331321)")
+CHECK-NEXT:              DW_AT_language (DW_LANG_C99)
+CHECK-NEXT:              DW_AT_name ("hi.c")
+
+CHECK:   DW_TAG_subprogram
+CHECK-NEXT:                DW_AT_low_pc
+CHECK-NEXT:                DW_AT_high_pc
+CHECK-NEXT:                DW_AT_name ("test")
+CHECK-NEXT:                DW_AT_decl_file  ("/Users/yury/llvmwasm/hi.c")
+CHECK-NEXT:                DW_AT_decl_line  (3)
+CHECK-NEXT:                DW_AT_prototyped (true)
+
+CHECK:     DW_TAG_formal_parameter
+CHECK-NEXT:                  DW_AT_name ("t")
+CHECK-NEXT:                  DW_AT_decl_file  ("/Users/yury/llvmwasm/hi.c")
+CHECK-NEXT:                  DW_AT_decl_line  (3)
+
+CHECK:   DW_TAG_subprogram
+CHECK-NEXT:                DW_AT_low_pc
+CHECK-NEXT:                DW_AT_high_pc
+CHECK-NEXT:                DW_AT_name ("_start")
+CHECK-NEXT:                DW_AT_decl_file  ("/Users/yury/llvmwasm/hi.c")
+CHECK-NEXT:                DW_AT_decl_line  (7)
+
+CHECK:   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: DW_TAG_compile_unit
+CHECK-NEXT:              DW_AT_producer ("clang version 7.0.0 (trunk 331321)")
+CHECK-NEXT:              DW_AT_language (DW_LANG_C99)
+CHECK-NEXT:              DW_AT_name ("hi_foo.c")
+
+CHECK:   DW_TAG_variable
+CHECK-NEXT:                DW_AT_name ("y")
+CHECK-NEXT:                "int[]"
+
+CHECK:   DW_TAG_array_type
+
+CHECK:     DW_TAG_subrange_type
+
+CHECK:   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:   DW_TAG_base_type
+CHECK-NEXT:                DW_AT_name ("__ARRAY_SIZE_TYPE__")
+CHECK-NEXT:                DW_AT_byte_size  (0x08)
+CHECK-NEXT:                DW_AT_encoding (DW_ATE_unsigned)
+
+CHECK:   DW_TAG_subprogram
+CHECK-NEXT:                DW_AT_low_pc 
+CHECK-NEXT:                DW_AT_high_pc
+CHECK-NEXT:                DW_AT_name ("foo")
+CHECK-NEXT:                DW_AT_decl_file  ("/Users/yury/llvmwasm/hi_foo.c")
+CHECK-NEXT:                DW_AT_decl_line  (3)
+
+CHECK:     DW_TAG_formal_parameter
+CHECK-NEXT:                  DW_AT_name ("p")
+CHECK-NEXT:                  DW_AT_decl_file  ("/Users/yury/llvmwasm/hi_foo.c")
+CHECK-NEXT:                  DW_AT_decl_line  (3)
+

wasm/InputChunks.h

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

wasm/InputChunks.cpp

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

wasm/InputFiles.h

public:
 
   // Returns the underlying wasm file.
   const WasmObjectFile *getWasmObj() const { return WasmObj.get(); }
 
   void dumpInfo() const;
 
   uint32_t calcNewIndex(const WasmRelocation &Reloc) const;
   uint32_t calcNewValue(const WasmRelocation &Reloc) const;
+  uint32_t calcNewAddend(const WasmRelocation &Reloc) const;
   uint32_t calcExpectedValue(const WasmRelocation &Reloc) const;
 
   const WasmSection *CodeSection = nullptr;
   const WasmSection *DataSection = nullptr;
 
   // Maps input type indices to output type indices
   std::vector<uint32_t> TypeMap;
   std::vector<bool> TypeIsUsed;
   // Maps function indices to table indices
   std::vector<uint32_t> TableEntries;
   std::vector<bool> UsedComdats;
   std::vector<InputSegment *> Segments;
   std::vector<InputFunction *> Functions;
   std::vector<InputGlobal *> Globals;
   std::vector<InputSection *> CustomSections;
+  llvm::DenseMap<uint32_t, InputSection *> CustomSectionsByIndex;
 
   ArrayRef<Symbol *> getSymbols() const { return Symbols; }
   Symbol *getSymbol(uint32_t Index) const { return Symbols[Index]; }
   FunctionSymbol *getFunctionSymbol(uint32_t Index) const;
   DataSymbol *getDataSymbol(uint32_t Index) const;
   GlobalSymbol *getGlobalSymbol(uint32_t Index) const;
+  SectionSymbol *getSectionSymbol(uint32_t Index) const;
 
 private:
   Symbol *createDefined(const WasmSymbol &Sym);
   Symbol *createUndefined(const WasmSymbol &Sym);
 
   bool isExcludedByComdat(InputChunk *Chunk) const;
 
   // List of all symbols referenced or defined by this file.

wasm/InputFiles.cpp

 #include "Config.h"
 #include "InputChunks.h"
 #include "InputGlobal.h"
 #include "SymbolTable.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "llvm/Object/Binary.h"
 #include "llvm/Object/Wasm.h"
+#include "llvm/Support/LEB128.h"
 #include "llvm/Support/raw_ostream.h"
 
 #define DEBUG_TYPE "lld"
 
 using namespace lld;
 using namespace lld::wasm;
 
 using namespace llvm;
Optional<MemoryBufferRef> lld::wasm::readFile(StringRef Path) {
   }
   std::unique_ptr<MemoryBuffer> &MB = *MBOrErr;
   MemoryBufferRef MBRef = MB->getMemBufferRef();
   make<std::unique_ptr<MemoryBuffer>>(std::move(MB)); // take MB ownership
 
   return MBRef;
 }
 
+static size_t getFunctionCodeOffset(ArrayRef<uint8_t> FunctionBody) {
+  unsigned Count;
+  llvm::decodeULEB128(FunctionBody.data(), &Count);
+  return Count;
+}
+
 void ObjFile::dumpInfo() const {
   log("info for: " + getName() +
       "\n              Symbols : " + Twine(Symbols.size()) +
       "\n     Function Imports : " + Twine(WasmObj->getNumImportedFunctions()) +
       "\n       Global Imports : " + Twine(WasmObj->getNumImportedGlobals()));
 }
 
 // Relocations contain either symbol or type indices.  This function takes a
 // relocation and returns relocated index (i.e. translates from the input
 // sybmol/type space to the output symbol/type space).
 uint32_t ObjFile::calcNewIndex(const WasmRelocation &Reloc) const {
   if (Reloc.Type == R_WEBASSEMBLY_TYPE_INDEX_LEB) {
     assert(TypeIsUsed[Reloc.Index]);
     return TypeMap[Reloc.Index];
   }
   return Symbols[Reloc.Index]->getOutputSymbolIndex();
 }
 
+// Relocations can contain addend for combined sections. This function takes a
+// relocation and returns updated addend by offset in the output section.
+uint32_t ObjFile::calcNewAddend(const WasmRelocation &Reloc) const {
+  switch (Reloc.Type) {
+  case R_WEBASSEMBLY_MEMORY_ADDR_LEB:
+  case R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
+  case R_WEBASSEMBLY_MEMORY_ADDR_I32:
+  case R_WEBASSEMBLY_FUNCTION_OFFSET_I32:
+    return Reloc.Addend;
+  case R_WEBASSEMBLY_SECTION_OFFSET_I32:
+    return getSectionSymbol(Reloc.Index)->Section->OutputOffset + Reloc.Addend;
+  default:
+    llvm_unreachable("unexpected relocation type");
+  }
+}
+
 // Calculate the value we expect to find at the relocation location.
 // This is used as a sanity check before applying a relocation to a given
 // location.  It is useful for catching bugs in the compiler and linker.
 uint32_t ObjFile::calcExpectedValue(const WasmRelocation &Reloc) const {
   switch (Reloc.Type) {
   case R_WEBASSEMBLY_TABLE_INDEX_I32:
   case R_WEBASSEMBLY_TABLE_INDEX_SLEB: {
     const WasmSymbol& Sym = WasmObj->syms()[Reloc.Index];
     return TableEntries[Sym.Info.ElementIndex];
   }
   case R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
   case R_WEBASSEMBLY_MEMORY_ADDR_I32:
   case R_WEBASSEMBLY_MEMORY_ADDR_LEB: {
     const WasmSymbol& Sym = WasmObj->syms()[Reloc.Index];
     if (Sym.isUndefined())
       return 0;
     const WasmSegment& Segment = WasmObj->dataSegments()[Sym.Info.DataRef.Segment];
     return Segment.Data.Offset.Value.Int32 + Sym.Info.DataRef.Offset +
            Reloc.Addend;
   }
+  case R_WEBASSEMBLY_FUNCTION_OFFSET_I32:
+    if (auto *Sym = dyn_cast<DefinedFunction>(getFunctionSymbol(Reloc.Index))) {
+      size_t FunctionCodeOffset =
+          getFunctionCodeOffset(Sym->Function->getFunctionBody());
+      return Sym->Function->getFunctionInputOffset() + FunctionCodeOffset +
+             Reloc.Addend;
+    }
+    return 0;
+  case R_WEBASSEMBLY_SECTION_OFFSET_I32:
+    return Reloc.Addend;
   case R_WEBASSEMBLY_TYPE_INDEX_LEB:
     return Reloc.Index;
   case R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
   case R_WEBASSEMBLY_GLOBAL_INDEX_LEB: {
     const WasmSymbol& Sym = WasmObj->syms()[Reloc.Index];
     return Sym.Info.ElementIndex;
   }
   default:
     llvm_unreachable("unknown relocation type");
   }
if (auto *Sym = dyn_cast<DefinedData>(getDataSymbol(Reloc.Index)))
       return Sym->getVirtualAddress() + Reloc.Addend;
     return 0;
   case R_WEBASSEMBLY_TYPE_INDEX_LEB:
     return TypeMap[Reloc.Index];
   case R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
     return getFunctionSymbol(Reloc.Index)->getFunctionIndex();
   case R_WEBASSEMBLY_GLOBAL_INDEX_LEB:
     return getGlobalSymbol(Reloc.Index)->getGlobalIndex();
+  case R_WEBASSEMBLY_FUNCTION_OFFSET_I32:
+    if (auto *Sym = dyn_cast<DefinedFunction>(getFunctionSymbol(Reloc.Index))) {
+      size_t FunctionCodeOffset =
+          getFunctionCodeOffset(Sym->Function->getFunctionBody());
+      return Sym->Function->OutputOffset + FunctionCodeOffset + Reloc.Addend;
+    }
+    return 0;
+  case R_WEBASSEMBLY_SECTION_OFFSET_I32:
+    return getSectionSymbol(Reloc.Index)->Section->OutputOffset + Reloc.Addend;
   default:
     llvm_unreachable("unknown relocation type");
   }
 }
 
 void ObjFile::parse() {
   // Parse a memory buffer as a wasm file.
   DEBUG(dbgs() << "Parsing object: " << toString(this) << "\n");
   std::unique_ptr<Binary> Bin = CHECK(createBinary(MB), toString(this));
for (uint32_t Index = 0; Index < Seg.Functions.size(); Index++) {
 
       uint32_t FunctionIndex = Seg.Functions[Index];
       TableEntries[FunctionIndex] = Offset + Index;
     }
   }
 
   // Find the code and data sections.  Wasm objects can have at most one code
   // and one data section.
+  uint32_t SectionIndex = 0;
   for (const SectionRef &Sec : WasmObj->sections()) {
     const WasmSection &Section = WasmObj->getWasmSection(Sec);
-    if (Section.Type == WASM_SEC_CODE)
+    if (Section.Type == WASM_SEC_CODE) {
       CodeSection = &Section;
-    else if (Section.Type == WASM_SEC_DATA)
+    } else if (Section.Type == WASM_SEC_DATA) {
       DataSection = &Section;
-    else if (Section.Type == WASM_SEC_CUSTOM)
+    } else if (Section.Type == WASM_SEC_CUSTOM) {
       CustomSections.emplace_back(make<InputSection>(Section, this));
+      CustomSections.back()->copyRelocations(Section);
+      CustomSectionsByIndex[SectionIndex] = CustomSections.back();
+    }
+    SectionIndex++;
   }
 
   TypeMap.resize(getWasmObj()->types().size());
   TypeIsUsed.resize(getWasmObj()->types().size(), false);
 
   ArrayRef<StringRef> Comdats = WasmObj->linkingData().Comdats;
   UsedComdats.resize(Comdats.size());
   for (unsigned I = 0; I < Comdats.size(); ++I)

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

wasm/OutputSections.h

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

wasm/OutputSections.cpp

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

wasm/Symbols.h

 namespace lld {
 namespace wasm {
 
 class InputFile;
 class InputChunk;
 class InputSegment;
 class InputFunction;
 class InputGlobal;
+class InputSection;
 
 #define INVALID_INDEX UINT32_MAX
 
 // The base class for real symbol classes.
 class Symbol {
 public:
   enum Kind {
     DefinedFunctionKind,
     DefinedDataKind,
     DefinedGlobalKind,
+    SectionKind,
     UndefinedFunctionKind,
     UndefinedDataKind,
     UndefinedGlobalKind,
     LazyKind,
   };
 
   Kind kind() const { return SymbolKind; }
 
   bool isDefined() const {
     return SymbolKind == DefinedFunctionKind || SymbolKind == DefinedDataKind ||
-           SymbolKind == DefinedGlobalKind;
+           SymbolKind == DefinedGlobalKind || SymbolKind == SectionKind;
   }
 
   bool isUndefined() const {
     return SymbolKind == UndefinedFunctionKind ||
            SymbolKind == UndefinedDataKind || SymbolKind == UndefinedGlobalKind;
   }
 
   bool isLazy() const { return SymbolKind == LazyKind; }
UndefinedFunction(StringRef Name, uint32_t Flags, InputFile *File = nullptr,
                     const WasmSignature *Type = nullptr)
       : FunctionSymbol(Name, UndefinedFunctionKind, Flags, File, Type) {}
 
   static bool classof(const Symbol *S) {
     return S->kind() == UndefinedFunctionKind;
   }
 };
 
+class SectionSymbol : public Symbol {
+public:
+  static bool classof(const Symbol *S) { return S->kind() == SectionKind; }
+
+  SectionSymbol(StringRef Name, uint32_t Flags, const InputSection *S,
+                InputFile *F = nullptr)
+      : Symbol(Name, SectionKind, Flags, F), Section(S) {}
+
+  const InputSection *Section;
+
+  uint32_t getOutputSectionIndex() const;
+  void setOutputSectionIndex(uint32_t Index);
+
+protected:
+  uint32_t OutputSectionIndex = INVALID_INDEX;
+};
+
 class DataSymbol : public Symbol {
 public:
   static bool classof(const Symbol *S) {
     return S->kind() == DefinedDataKind || S->kind() == UndefinedDataKind;
   }
 
 protected:
   DataSymbol(StringRef Name, Kind K, uint32_t Flags, InputFile *F)
       : Symbol(Name, K, Flags, F) {}
 };
 
 class DefinedData : public DataSymbol {
 public:
   // Constructor for regular data symbols originating from input files.
   DefinedData(StringRef Name, uint32_t Flags, InputFile *F,
               InputSegment *Segment, uint32_t Offset, uint32_t Size)
       : DataSymbol(Name, DefinedDataKind, Flags, F), Segment(Segment),
         Offset(Offset), Size(Size) {}
 
   // Constructor for linker synthetic data symbols.
   DefinedData(StringRef Name, uint32_t Flags)
       : DataSymbol(Name, DefinedDataKind, Flags, nullptr) {}
 
   static bool classof(const Symbol *S) { return S->kind() == DefinedDataKind; }
 
   // Returns the output virtual address of a defined data symbol.
   uint32_t getVirtualAddress() const;
   void setVirtualAddress(uint32_t VA);

 union SymbolUnion {
   alignas(DefinedFunction) char A[sizeof(DefinedFunction)];
   alignas(DefinedData) char B[sizeof(DefinedData)];
   alignas(DefinedGlobal) char C[sizeof(DefinedGlobal)];
   alignas(LazySymbol) char D[sizeof(LazySymbol)];
   alignas(UndefinedFunction) char E[sizeof(UndefinedFunction)];
   alignas(UndefinedData) char F[sizeof(UndefinedData)];
   alignas(UndefinedGlobal) char G[sizeof(UndefinedGlobal)];
+  alignas(SectionSymbol) char I[sizeof(SectionSymbol)];
 };
 
 template <typename T, typename... ArgT>
 T *replaceSymbol(Symbol *S, ArgT &&... Arg) {
   static_assert(std::is_trivially_destructible<T>(),
                 "Symbol types must be trivially destructible");
   static_assert(sizeof(T) <= sizeof(SymbolUnion), "Symbol too small");
   static_assert(alignof(T) <= alignof(SymbolUnion),

wasm/Symbols.cpp

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

 }
 
 DefinedGlobal::DefinedGlobal(StringRef Name, uint32_t Flags, InputFile *File,
                              InputGlobal *Global)
     : GlobalSymbol(Name, DefinedGlobalKind, Flags, File,
                    Global ? &Global->getType() : nullptr),
       Global(Global) {}
 
+uint32_t SectionSymbol::getOutputSectionIndex() const {
+  DEBUG(dbgs() << "getOutputSectionIndex: " << getName() << "\n");
+  assert(OutputSectionIndex != INVALID_INDEX);
+  return OutputSectionIndex;
+}
+
+void SectionSymbol::setOutputSectionIndex(uint32_t Index) {
+  DEBUG(dbgs() << "setOutputSectionIndex: " << getName() << " -> " << Index
+               << "\n");
+  assert(Index != INVALID_INDEX);
+  OutputSectionIndex = Index;
+}
+
 void LazySymbol::fetch() { cast<ArchiveFile>(File)->addMember(&ArchiveSymbol); }
 
 std::string lld::toString(const wasm::Symbol &Sym) {
   if (Config->Demangle)
     if (Optional<std::string> S = demangleItanium(Sym.getName()))
       return *S;
   return Sym.getName();
 }
std::string lld::toString(wasm::Symbol::Kind Kind) {
   case wasm::Symbol::UndefinedFunctionKind:
     return "UndefinedFunction";
   case wasm::Symbol::UndefinedDataKind:
     return "UndefinedData";
   case wasm::Symbol::UndefinedGlobalKind:
     return "UndefinedGlobal";
   case wasm::Symbol::LazyKind:
     return "LazyKind";
+  case wasm::Symbol::SectionKind:
+    return "SectionKind";
   }
   llvm_unreachable("invalid symbol kind");
 }
 
 std::string lld::toString(WasmSymbolType Type) {
   switch (Type) {
   case llvm::wasm::WASM_SYMBOL_TYPE_FUNCTION:
     return "Function";

wasm/Writer.cpp

private:
   uint32_t lookupType(const WasmSignature &Sig);
   uint32_t registerType(const WasmSignature &Sig);
 
   void createCtorFunction();
   void calculateInitFunctions();
   void assignIndexes();
   void calculateImports();
   void calculateExports();
+  void calculateCustomSections();
   void assignSymtab();
   void calculateTypes();
   void createOutputSegments();
   void layoutMemory();
   void createHeader();
   void createSections();
   SyntheticSection *createSyntheticSection(uint32_t Type, StringRef Name = "");
 
private:
   std::vector<const DefinedData *> DefinedFakeGlobals;
   std::vector<InputGlobal *> InputGlobals;
   std::vector<InputFunction *> InputFunctions;
   std::vector<const FunctionSymbol *> IndirectFunctions;
   std::vector<const Symbol *> SymtabEntries;
   std::vector<WasmInitEntry> InitFunctions;
 
   llvm::StringMap<std::vector<InputSection *>> CustomSectionMapping;
+  llvm::StringMap<SectionSymbol *> CustomSectionSymbols;
 
   // Elements that are used to construct the final output
   std::string Header;
   std::vector<OutputSection *> OutputSections;
 
   std::unique_ptr<FileOutputBuffer> Buffer;
 
   std::vector<OutputSegment *> Segments;
for (const Symbol *Sym : ExportedSymbols) {
     else if (isa<DefinedData>(Sym))
       Export = {Name, WASM_EXTERNAL_GLOBAL, FakeGlobalIndex++};
     else
       llvm_unreachable("unexpected symbol type");
     writeExport(OS, Export);
   }
 }
 
-void Writer::createCustomSections() {
-  log("createCustomSections");
-  for (ObjFile *File : Symtab->ObjectFiles)
-    for (InputSection *Section : File->CustomSections)
-      CustomSectionMapping[Section->getName()].push_back(Section);
-
-  for (auto &Pair : CustomSectionMapping) {
-    StringRef Name = Pair.first();
+void Writer::calculateCustomSections() {
+  log("calculateCustomSections");
+  bool StripDebug = Config->StripDebug || Config->StripAll;
+  for (ObjFile *File : Symtab->ObjectFiles) {
+    for (InputSection *Section : File->CustomSections) {
+      StringRef Name = Section->getName();
       // These custom sections are known the linker and synthesized rather than
       // blindly copied
       if (Name == "linking" || Name == "name" || Name.startswith("reloc."))
         continue;
+      // .. or it is a debug section
+      if (StripDebug && Name.startswith(".debug_"))
+        continue;
+      CustomSectionMapping[Name].push_back(Section);
+    }
+  }
+}
+
+void Writer::createCustomSections() {
+  log("createCustomSections");
+  for (auto &Pair : CustomSectionMapping) {
+    StringRef Name = Pair.first();
+
+    auto P = CustomSectionSymbols.find(Name);
+    if (P != CustomSectionSymbols.end()) {
+      uint32_t SectionIndex = OutputSections.size();
+      P->second->setOutputSectionIndex(SectionIndex);
+    }
+
     DEBUG(dbgs() << "createCustomSection: " << Name << "\n");
     OutputSections.push_back(make<CustomSection>(Name, Pair.second));
   }
 }
 
 void Writer::createElemSection() {
   if (IndirectFunctions.empty())
     return;
for (size_t I = 0; I < OrigSize; I++) {
     if (!Count)
       continue;
 
     StringRef Name;
     if (OSec->Type == WASM_SEC_DATA)
       Name = "reloc.DATA";
     else if (OSec->Type == WASM_SEC_CODE)
       Name = "reloc.CODE";
+    else if (OSec->Type == WASM_SEC_CUSTOM)
+      Name = Saver.save("reloc." + OSec->Name);
     else
-      llvm_unreachable("relocations only supported for code and data");
+      llvm_unreachable(
+          "relocations only supported for code, data, or custom sections");
 
     SyntheticSection *Section = createSyntheticSection(WASM_SEC_CUSTOM, Name);
     raw_ostream &OS = Section->getStream();
     writeUleb128(OS, I, "reloc section");
     writeUleb128(OS, Count, "reloc count");
     OSec->writeRelocations(OS);
   }
 }
for (const Symbol *Sym : SymtabEntries) {
       if (auto *F = dyn_cast<FunctionSymbol>(Sym)) {
         writeUleb128(Sub.OS, F->getFunctionIndex(), "index");
         if (Sym->isDefined())
           writeStr(Sub.OS, Sym->getName(), "sym name");
       } else if (auto *G = dyn_cast<GlobalSymbol>(Sym)) {
         writeUleb128(Sub.OS, G->getGlobalIndex(), "index");
         if (Sym->isDefined())
           writeStr(Sub.OS, Sym->getName(), "sym name");
-      } else {
-        assert(isa<DataSymbol>(Sym));
+      } else if (auto *D = dyn_cast<DataSymbol>(Sym)) {
         writeStr(Sub.OS, Sym->getName(), "sym name");
         if (auto *DataSym = dyn_cast<DefinedData>(Sym)) {
           writeUleb128(Sub.OS, DataSym->getOutputSegmentIndex(), "index");
           writeUleb128(Sub.OS, DataSym->getOutputSegmentOffset(),
                        "data offset");
           writeUleb128(Sub.OS, DataSym->getSize(), "data size");
         }
+      } else {
+        auto *S = cast<SectionSymbol>(Sym);
+        writeUleb128(Sub.OS, S->getOutputSectionIndex(), "sym section index");
       }
     }
 
     Sub.writeTo(OS);
   }
 
   if (Segments.size()) {
     SubSection Sub(WASM_SEGMENT_INFO);
     writeUleb128(Sub.OS, Segments.size(), "num data segments");
     for (const OutputSegment *S : Segments) {
       writeStr(Sub.OS, S->Name, "segment name");
       writeUleb128(Sub.OS, S->Alignment, "alignment");
void Writer::calculateExports() {
 
   for (Symbol *Sym : Symtab->getSymbols()) {
     if (!Sym->isDefined())
       continue;
     if (Sym->isHidden() || Sym->isLocal())
       continue;
     if (!Sym->isLive())
       continue;
+    if (isa<SectionSymbol>(Sym))
+      continue;
 
     DEBUG(dbgs() << "exporting sym: " << Sym->getName() << "\n");
 
     if (auto *D = dyn_cast<DefinedData>(Sym))
       DefinedFakeGlobals.emplace_back(D);
     ExportedSymbols.emplace_back(Sym);
   }
 }
 
 void Writer::assignSymtab() {
   if (!Config->Relocatable)
     return;
 
+  StringMap<uint32_t> SectionSymbolIndices;
+
   unsigned SymbolIndex = SymtabEntries.size();
   for (ObjFile *File : Symtab->ObjectFiles) {
     DEBUG(dbgs() << "Symtab entries: " << File->getName() << "\n");
     for (Symbol *Sym : File->getSymbols()) {
       if (Sym->getFile() != File)
         continue;
+
+      if (auto *S = dyn_cast<SectionSymbol>(Sym)) {
+        StringRef Name = S->getName();
+        if (CustomSectionMapping.count(Name) == 0)
+          continue;
+
+        auto SSI = SectionSymbolIndices.find(Name);
+        if (SSI != SectionSymbolIndices.end()) {
+          Sym->setOutputSymbolIndex(SSI->second);
+          continue;
+        }
+
+        SectionSymbolIndices[Name] = SymbolIndex;
+        CustomSectionSymbols[Name] = cast<SectionSymbol>(Sym);
+
+        Sym->markLive();
+      }
+
       // (Since this is relocatable output, GC is not performed so symbols must
       // be live.)
       assert(Sym->isLive());
       Sym->setOutputSymbolIndex(SymbolIndex++);
       SymtabEntries.emplace_back(Sym);
     }
   }
 
   // For the moment, relocatable output doesn't contain any synthetic functions,
   // so no need to look through the Symtab for symbols not referenced by
   // Symtab->ObjectFiles.
 }
 
 uint32_t Writer::lookupType(const WasmSignature &Sig) {
void Writer::assignIndexes() {
   };
 
   for (ObjFile *File : Symtab->ObjectFiles) {
     DEBUG(dbgs() << "Handle relocs: " << File->getName() << "\n");
     for (InputChunk *Chunk : File->Functions)
       HandleRelocs(Chunk);
     for (InputChunk *Chunk : File->Segments)
       HandleRelocs(Chunk);
+    for (auto &P : File->CustomSections)
+      HandleRelocs(P);
   }
 
   uint32_t GlobalIndex = NumImportedGlobals + InputGlobals.size();
   auto AddDefinedGlobal = [&](InputGlobal *Global) {
     if (Global->Live) {
       DEBUG(dbgs() << "AddDefinedGlobal: " << GlobalIndex << "\n");
       Global->setGlobalIndex(GlobalIndex++);
       InputGlobals.push_back(Global);
void Writer::run() {
   if (!Config->Relocatable)
     createCtorFunction();
   log("-- calculateTypes");
   calculateTypes();
   log("-- layoutMemory");
   layoutMemory();
   log("-- calculateExports");
   calculateExports();
+  log("-- calculateCustomSections");
+  calculateCustomSections();
   log("-- assignSymtab");
   assignSymtab();
 
   if (errorHandler().Verbose) {
     log("Defined Functions: " + Twine(InputFunctions.size()));
     log("Defined Globals  : " + Twine(InputGlobals.size()));
     log("Function Imports : " + Twine(NumImportedFunctions));
     log("Global Imports   : " + Twine(NumImportedGlobals));