[WebAssembly] Separate out InputGlobal from InputChunk

[ncw]

Summary

This is a follow-up to D43264, or maybe Sam could take this apply and merge into D43264?

This is a follow-on from the discussion in that issue.

I've tried to separate out InputGlobal from InputChunk, so that it doesn't derive from it (since InputChunk has relocations, but InputGlobal doesn't). This change ripples out and impacts the rest of the code a bit.

Rejected alternative:

InputGlobal (not derived from anything, this duplicates/complicates too much code)
InputChunk
  -> InputFunction
  -> InputSegment

What I've done here:

InputChunk
  -> InputSection - new class, all the relocation stuff and section offsets
                    moved from InputChunk to here
    -> InputFunction
    -> InputSegment
  -> InputGlobal

As part of that, I had a re-jigg of the handling of the function/global signature on the FunctionSymbol/GlobalSymbol objects, and discovered a bug! The current handling of undefined function signatures is wrong, oops, as evidenced by the fact that one of tests provides __cxa_at_exit with the wrong signature, yet the test passes. I discovered this when my refactoring broke the test, and then I realised I'd accidentally fixed a bug.

Other small fixes, while I was at it (should surely be rolled into D43264):

• Fixed MarkLive to log the InputGlobals that are discarded
• Fixed Symbol::hasOutputIndex for globals
• Added missing DefinedGlobal::classof! Yikes.

[ruiu]

I haven't looked at the details of this patch yet, but this class hierarchy doesn't honestly look good to me, because I think global variables are not really Chunks. Chunk basically represents a piece of bytes that is copied from input file to output file. I don't think that wasm global variables fall in that category. Maybe you can still find some common parts between global variables and chunks, but it doesn't necessarily mean that we should put them in the same class hierarchy. Keeping different things different is as important as finding commonality and factor it out. I believe in this case, we should keep them separated.

InputChunk
  -> InputSection - new class, all the relocation stuff and section offsets
                    moved from InputChunk to here
    -> InputFunction
    -> InputSegment
  -> InputGlobal

[sbc100]

Thanks Nicolas!

I split out the bug fix into a separate CL and added an addition test to exercise the signature checking:
https://reviews.llvm.org/D43399

[ncw]

In D43391#1010450, @ruiu wrote:

I haven't looked at the details of this patch yet, but this class hierarchy doesn't honestly look good to me, because I think global variables are not really Chunks. Chunk basically represents a piece of bytes that is copied from input file to output file. I don't think that wasm global variables fall in that category. Maybe you can still find some common parts between global variables and chunks, but it doesn't necessarily mean that we should put them in the same class hierarchy. Keeping different things different is as important as finding commonality and factor it out. I believe in this case, we should keep them separated.

InputGlobal is a "thing" that's copied from an input file into the output file; but clearly I hear what you're saying that it doesn't fit into your idea of what a "chunk" is.

Goal: Can we come up with a suitable name or description for the behaviour that's shared between InputGlobal & InputChunk? If it's named right, would you be happy?

Background: I did do the work this morning (on your suggestion) to implement InputGlobal as a completely separate class, and I got the code all working, but it was nasty in several places. There was extra code duplication. That's how I ended up with this patch, after going down that route first.

The fact is, InputGlobal shares a number of members with InputChunk - namely the Live flag, the Comdat handling, the output-index handling.

I know sometimes that shared members can be copy-pasted into another class... but what really counts for determining whether to make a base class is shared behaviour. In this case we do have that, with several places where we operate on an InputThing in a generic way:

• MarkLive sets the live bit on InputChunks/InputGlobals, so it's awkward if they don't share a base class. You end up doubling the amount of code in MarkLive's critical loop, if it requires a switch statement to set the Live bit depending on whether it's an InputGlobal or InputChunk that's being GC'd.
• Similarly when writing out Wasm exports, we want to iterate over all the InputThings together, and make use of the members that InputGlobal/InputChunk have in common
• Some more instances in Writer that operate on the "chunk" for a defined symbol - would need to copy-paste that code if some symbols have an InputGlobal and some symbols have an InputChunk, and there's nothing common between them
• And also for Comdat handling we'll need to handle them together...

Let's just imagine that we have this hierarchy - could you suggest some names that would work for you, to describe these classes:

CLASS_ONE // represents a "thing" or "item" to be copied from an input file to an output file. 
          // Interface: getName(), getFileName(), Live, getComdat()
          // Suggested names: InputObject, InputChunk, Gcable.... do any of those resonate?
  -> CLASS_TWO // represents a block of binary data to be copied from an input file to an output file
               // Interface: getSectionOffset(), getRelocations()
               // Suggested names: InputSection, InputBytes, InputChunk...
    -> InputSegment (data section)
    -> InputFunction (code section)
  -> InputGlobal // represents a block of defined data for a special type of data symbol

[ruiu]

I can say that handling global variables as Chunks as you did in this patch isn't an intended use of Chunk class, but in order to answer to your question as to what is a better way of abstracting it, I need to experiment various ideas until I find something that fits snugly to the entire design of lld.

The fact that global variables is a "thing" that copied from input files to an output file doesn't mean that that need to be abstracted as Chunks. Everything in the linker, except the one given via the command line, are after all created from input files, and most of them are in some way copied to the output file. Symbols are created for input files and copied to the output symbol table, for example. As I wrote, Chunk essentially represents a contiguous bytes in input files, and I'm not convinced that global variables have that property.

I'd think you are perhaps overthinking about the design. In lld, we are careful not to be too clever. We are trying to keep the class hierarchy simple and shallow, and we are trying to not abstract things too much. And I believe you can find that design principle throughout the lld code.

When we find that something needs to be abstracted in order to make program better, I'm totally fine with doing that. But I don't want to design something too much beforehand, because in many cases that's inappropriate or wouldn't be needed in the future. I'm not worried that the fundamental design of wasm lld is wrong (it's based on the proven design!), so even if we have to refactor code, that's not a big task. So, can we just keep global variables as a symbol until we find that that's not a suitable representation?

[sbc100]

In D43391#1010785, @ruiu wrote:

I can say that handling global variables as Chunks as you did in this patch isn't an intended use of Chunk class, but in order to answer to your question as to what is a better way of abstracting it, I need to experiment various ideas until I find something that fits snugly to the entire design of lld.

The fact that global variables is a "thing" that copied from input files to an output file doesn't mean that that need to be abstracted as Chunks. Everything in the linker, except the one given via the command line, are after all created from input files, and most of them are in some way copied to the output file. Symbols are created for input files and copied to the output symbol table, for example. As I wrote, Chunk essentially represents a contiguous bytes in input files, and I'm not convinced that global variables have that property.

I'd think you are perhaps overthinking about the design. In lld, we are careful not to be too clever. We are trying to keep the class hierarchy simple and shallow, and we are trying to not abstract things too much. And I believe you can find that design principle throughout the lld code.

When we find that something needs to be abstracted in order to make program better, I'm totally fine with doing that. But I don't want to design something too much beforehand, because in many cases that's inappropriate or wouldn't be needed in the future. I'm not worried that the fundamental design of wasm lld is wrong (it's based on the proven design!), so even if we have to refactor code, that's not a big task. So, can we just keep global variables as a symbol until we find that that's not a suitable representation?

I'm working on a simpler abstraction now.

[ncw]

I had a great idea on this last night - I think I've been misrepresenting globals somewhat. This came to me after Andreas Rossberg answered a question I had about globals.

They're actually more like functions than data! Our rather, they are used/accessed as data at runtime, but the Globals section of the Wasm file actually contains a function body for each global, which contains executable code that's run through the interpreter to give the global its initial value.

I kept saying "globals are like a chunk in every way except that they don't have relocations" - but that's wrong, they should have relocations! The "body" for a global can contain a get_global instruction, which requires a relocation for its operand, so what's really been misleading is that thelinking conventions for wasm simply forgot to mention that the linker needs to handle a "reloc.GLOBAL" section.

I know what you're thinking - "Nick, the clang front-end currently doesn't emit globals that contain a get_global instruction, so we don't need to process relocations for them".

But the linking conventions should still specify it, regardless of the fact that the clang front-end doesn't yet emit them. One thing's sure, fPIC and shared-objects and threading will find more uses for globals than we had before.

More to the point - the "wasmy" way to think of globals is as a runtime data register, which is packaged in the wasm file with a function body used to initialize it. That could be reflected in LLD's model. (A typical function body for a global is something like a single "ret i32 <immediate>" instruction, or "const.i32 NNN" in wasm assembly, but a few other forms are legal.)

To conclude: I'm not trying to complicate things for globals, I'm just trying to use exactly the same tried-and-tested abstraction for them, that LLD is already right now using for functions and segments, rather than try and make up something new.

And since globals can contain relocations after all, they look a lot more like functions; treating them as chunks like the rest really should give us basically the least amount of code overall, as well as ensuring the various symbol types work in the same way for "free".

Edit - I'll see if I have any time on Monday to confirm my conjecture on the potential simplification of the code, by updating this PR to model globals as a chunk like functions. I had been intending that later on as a tidy-up, before realising that globals would actually benefit from relocation processing.

[sbc100]

In D43391#1011480, @ncw wrote:

I had a great idea on this last night - I think I've been misrepresenting globals somewhat. This came to me after Andreas Rossberg answered a question I had about globals.

They're actually more like functions than data! Our rather, they are used/accessed as data at runtime, but the Globals section of the Wasm file actually contains a function body for each global, which contains executable code that's run through the interpreter to give the global its initial value.

I kept saying "globals are like a chunk in every way except that they don't have relocations" - but that's wrong, they should have relocations! The "body" for a global can contain a get_global instruction, which requires a relocation for its operand, so what's really been misleading is that thelinking conventions for wasm simply forgot to mention that the linker needs to handle a "reloc.GLOBAL" section.

I know what you're thinking - "Nick, the clang front-end currently doesn't emit globals that contain a get_global instruction, so we don't need to process relocations for them".

But the linking conventions should still specify it, regardless of the fact that the clang front-end doesn't yet emit them. One thing's sure, fPIC and shared-objects and threading will find more uses for globals than we had before.

More to the point - the "wasmy" way to think of globals is as a runtime data register, which is packaged in the wasm file with a function body used to initialize it. That could be reflected in LLD's model. (A typical function body for a global is something like a single "ret i32 <immediate>" instruction, or "const.i32 NNN" in wasm assembly, but a few other forms are legal.)

To conclude: I'm not trying to complicate things for globals, I'm just trying to use exactly the same tried-and-tested abstraction for them, that LLD is already right now using for functions and segments, rather than try and make up something new.

And since globals can contain relocations after all, they look a lot more like functions; treating them as chunks like the rest really should give us basically the least amount of code overall, as well as ensuring the various symbol types work in the same way for "free".

Edit - I'll see if I have any time on Monday to confirm my conjecture on the potential simplification of the code, by updating this PR to model globals as a chunk like functions. I had been intending that later on as a tidy-up, before realising that globals would actually benefit from relocation processing.

I think the important distinction is "OutputSection" vs "SyntheticOutputSection". The former is constructed in parallel based on memcpy+relocations. The latter is created from scratch by the linker. You are suggesting that we might want to make the global sections into non-synthetic section. We might want to do that one day, but I don't think we should for this initial patch. I think we are already getting a bit ahead of ourselves by even including first class globals in this patch (I was hoping to switch to symbol table without introducing a new symbol type but I don't really think that can be avoided).

[ncw]

Abandoning, now that symbol table has landed.

Well done @sbc100 (and thanks) on getting it through!

test/wasm/gc-sections.ll

 ; RUN: llc -filetype=obj %s -o %t.o
 ; RUN: lld -flavor wasm -print-gc-sections -o %t1.wasm %t.o | FileCheck %s -check-prefix=PRINT-GC
-; PRINT-GC: removing unused section 'unused_function' in file '{{.*}}'
-; PRINT-GC-NOT: removing unused section 'used_function' in file '{{.*}}'
-; PRINT-GC: removing unused section '.data.unused_data' in file '{{.*}}'
-; PRINT-GC-NOT: removing unused section '.data.used_data' in file '{{.*}}'
+; PRINT-GC: removing unused function 'unused_function' in file '{{.*}}'
+; PRINT-GC-NOT: removing unused function 'used_function' in file '{{.*}}'
+; PRINT-GC: removing unused segment '.data.unused_data' in file '{{.*}}'
+; PRINT-GC-NOT: removing unused segment '.data.used_data' in file '{{.*}}'
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 @unused_data = hidden global i64 1, align 4
 @used_data = hidden global i32 2, align 4
 
 define hidden i64 @unused_function() {
   %1 = load i64, i64* @unused_data, align 4

test/wasm/init-fini.ll

entry:
   ret void
 }
 
 define hidden void @func4() {
 entry:
   ret void
 }
 
-define void @__cxa_atexit() {
-  ret void
+define i32 @__cxa_atexit(i32 %func, i32 %arg, i32 %dso_handle) {
+  ret i32 0
 }
 
 define hidden void @_start() {
 entry:
   ret void
 }
 
 @llvm.global_ctors = appending global [3 x { i32, void ()*, i8* }] [

 ; RUN: lld -flavor wasm --check-signatures %t.o %t.global-ctor-dtor.o -o %t.wasm
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 ; CHECK:        - Type:            ELEM
 ; CHECK-NEXT:     Segments:
 ; CHECK-NEXT:       - Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1
-; CHECK-NEXT:         Functions:       [ 6, 9, 13, 15, 17 ]
+; CHECK-NEXT:         Functions:       [ 6, 8, 12, 14, 16 ]
 
-; CHECK:              Body:            100010011007100B100E100B10101000100A100B10120B
+; CHECK:              Body:            100010011007100A100D100A100F10001009100A10110B
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
 ; CHECK-NEXT:     DataSize:        0
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            name
 ; CHECK-NEXT:     FunctionNames:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            func1
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Name:            func2
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Name:            func3
 ; CHECK-NEXT:       - Index:           3
 ; CHECK-NEXT:         Name:            func4
 ; CHECK-NEXT:       - Index:           4
 ; CHECK-NEXT:         Name:            __cxa_atexit
 ; CHECK-NEXT:       - Index:           5
 ; CHECK-NEXT:         Name:            _start
 ; CHECK-NEXT:       - Index:           6
 ; CHECK-NEXT:         Name:            .Lcall_dtors.101
 ; CHECK-NEXT:       - Index:           7
 ; CHECK-NEXT:         Name:            .Lregister_call_dtors.101
 ; CHECK-NEXT:       - Index:           8
-; CHECK-NEXT:         Name:            .Lbitcast
-; CHECK-NEXT:       - Index:           9
 ; CHECK-NEXT:         Name:            .Lcall_dtors.1001
-; CHECK-NEXT:       - Index:           10
+; CHECK-NEXT:       - Index:           9
 ; CHECK-NEXT:         Name:            .Lregister_call_dtors.1001
-; CHECK-NEXT:       - Index:           11
+; CHECK-NEXT:       - Index:           10
 ; CHECK-NEXT:         Name:            myctor
-; CHECK-NEXT:       - Index:           12
+; CHECK-NEXT:       - Index:           11
 ; CHECK-NEXT:         Name:            mydtor
-; CHECK-NEXT:       - Index:           13
+; CHECK-NEXT:       - Index:           12
 ; CHECK-NEXT:         Name:            .Lcall_dtors.101
-; CHECK-NEXT:       - Index:           14
+; CHECK-NEXT:       - Index:           13
 ; CHECK-NEXT:         Name:            .Lregister_call_dtors.101
-; CHECK-NEXT:       - Index:           15
+; CHECK-NEXT:       - Index:           14
 ; CHECK-NEXT:         Name:            .Lcall_dtors.202
-; CHECK-NEXT:       - Index:           16
+; CHECK-NEXT:       - Index:           15
 ; CHECK-NEXT:         Name:            .Lregister_call_dtors.202
-; CHECK-NEXT:       - Index:           17
+; CHECK-NEXT:       - Index:           16
 ; CHECK-NEXT:         Name:            .Lcall_dtors.2002
-; CHECK-NEXT:       - Index:           18
+; CHECK-NEXT:       - Index:           17
 ; CHECK-NEXT:         Name:            .Lregister_call_dtors.2002
-; CHECK-NEXT:       - Index:           19
+; CHECK-NEXT:       - Index:           18
 ; CHECK-NEXT:         Name:            __wasm_call_ctors
 ; CHECK-NEXT: ...
 
 
 ; RUN: lld -flavor wasm --check-signatures -r %t.o %t.global-ctor-dtor.o -o %t.reloc.wasm
 ; RUN: obj2yaml %t.reloc.wasm | FileCheck -check-prefix=RELOC %s
 
 ; RELOC:          Name:            linking

 ; RELOC-NEXT:         Function:        6
 ; RELOC-NEXT:       - Index:           8
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            .Lregister_call_dtors.101
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
 ; RELOC-NEXT:         Function:        7
 ; RELOC-NEXT:       - Index:           9
 ; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Name:            .Lbitcast
+; RELOC-NEXT:         Name:            .Lcall_dtors.1001
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
 ; RELOC-NEXT:         Function:        8
 ; RELOC-NEXT:       - Index:           10
 ; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Name:            .Lcall_dtors.1001
+; RELOC-NEXT:         Name:            .Lregister_call_dtors.1001
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
 ; RELOC-NEXT:         Function:        9
 ; RELOC-NEXT:       - Index:           11
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Name:            .Lregister_call_dtors.1001
-; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
-; RELOC-NEXT:         Function:        10
-; RELOC-NEXT:       - Index:           12
 ; RELOC-NEXT:         Kind:            GLOBAL
 ; RELOC-NEXT:         Name:            __stack_pointer
 ; RELOC-NEXT:         Flags:           [ UNDEFINED ]
 ; RELOC-NEXT:         Global:          0
-; RELOC-NEXT:       - Index:           13
+; RELOC-NEXT:       - Index:           12
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            myctor
 ; RELOC-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
-; RELOC-NEXT:         Function:        11
-; RELOC-NEXT:       - Index:           14
+; RELOC-NEXT:         Function:        10
+; RELOC-NEXT:       - Index:           13
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            mydtor
 ; RELOC-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
+; RELOC-NEXT:         Function:        11
+; RELOC-NEXT:       - Index:           14
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            .Lcall_dtors.101
+; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
 ; RELOC-NEXT:         Function:        12
 ; RELOC-NEXT:       - Index:           15
 ; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Name:            .Lcall_dtors.101
+; RELOC-NEXT:         Name:            .Lregister_call_dtors.101
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
 ; RELOC-NEXT:         Function:        13
 ; RELOC-NEXT:       - Index:           16
 ; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Name:            .Lregister_call_dtors.101
+; RELOC-NEXT:         Name:            .Lcall_dtors.202
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
 ; RELOC-NEXT:         Function:        14
 ; RELOC-NEXT:       - Index:           17
 ; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Name:            .Lcall_dtors.202
+; RELOC-NEXT:         Name:            .Lregister_call_dtors.202
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
 ; RELOC-NEXT:         Function:        15
 ; RELOC-NEXT:       - Index:           18
 ; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Name:            .Lregister_call_dtors.202
+; RELOC-NEXT:         Name:            .Lcall_dtors.2002
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
 ; RELOC-NEXT:         Function:        16
 ; RELOC-NEXT:       - Index:           19
 ; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Name:            .Lcall_dtors.2002
-; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
-; RELOC-NEXT:         Function:        17
-; RELOC-NEXT:       - Index:           20
-; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            .Lregister_call_dtors.2002
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
-; RELOC-NEXT:         Function:        18
+; RELOC-NEXT:         Function:        17
 ; RELOC-NEXT:     InitFunctions:
 ; RELOC-NEXT:       - Priority:        101
 ; RELOC-NEXT:         Symbol:          1
 ; RELOC-NEXT:       - Priority:        101
 ; RELOC-NEXT:         Symbol:          2
 ; RELOC-NEXT:       - Priority:        101
 ; RELOC-NEXT:         Symbol:          8
 ; RELOC-NEXT:       - Priority:        101
-; RELOC-NEXT:         Symbol:          13
+; RELOC-NEXT:         Symbol:          12
 ; RELOC-NEXT:       - Priority:        101
-; RELOC-NEXT:         Symbol:          16
+; RELOC-NEXT:         Symbol:          15
 ; RELOC-NEXT:       - Priority:        202
-; RELOC-NEXT:         Symbol:          13
+; RELOC-NEXT:         Symbol:          12
 ; RELOC-NEXT:       - Priority:        202
-; RELOC-NEXT:         Symbol:          18
+; RELOC-NEXT:         Symbol:          17
 ; RELOC-NEXT:       - Priority:        1001
 ; RELOC-NEXT:         Symbol:          1
 ; RELOC-NEXT:       - Priority:        1001
-; RELOC-NEXT:         Symbol:          11
+; RELOC-NEXT:         Symbol:          10
 ; RELOC-NEXT:       - Priority:        2002
-; RELOC-NEXT:         Symbol:          13
+; RELOC-NEXT:         Symbol:          12
 ; RELOC-NEXT:       - Priority:        2002
-; RELOC-NEXT:         Symbol:          20
+; RELOC-NEXT:         Symbol:          19
 ; RELOC-NEXT:   - Type:            CUSTOM
 ; RELOC-NEXT:     Name:            name
 ; RELOC-NEXT:     FunctionNames:
 ; RELOC-NEXT:       - Index:           0
 ; RELOC-NEXT:         Name:            func1
 ; RELOC-NEXT:       - Index:           1
 ; RELOC-NEXT:         Name:            func2
 ; RELOC-NEXT:       - Index:           2
 ; RELOC-NEXT:         Name:            func3
 ; RELOC-NEXT:       - Index:           3
 ; RELOC-NEXT:         Name:            func4
 ; RELOC-NEXT:       - Index:           4
 ; RELOC-NEXT:         Name:            __cxa_atexit
 ; RELOC-NEXT:       - Index:           5
 ; RELOC-NEXT:         Name:            _start
 ; RELOC-NEXT:       - Index:           6
 ; RELOC-NEXT:         Name:            .Lcall_dtors.101
 ; RELOC-NEXT:       - Index:           7
 ; RELOC-NEXT:         Name:            .Lregister_call_dtors.101
 ; RELOC-NEXT:       - Index:           8
-; RELOC-NEXT:         Name:            .Lbitcast
-; RELOC-NEXT:       - Index:           9
 ; RELOC-NEXT:         Name:            .Lcall_dtors.1001
-; RELOC-NEXT:       - Index:           10
+; RELOC-NEXT:       - Index:           9
 ; RELOC-NEXT:         Name:            .Lregister_call_dtors.1001
-; RELOC-NEXT:       - Index:           11
+; RELOC-NEXT:       - Index:           10
 ; RELOC-NEXT:         Name:            myctor
-; RELOC-NEXT:       - Index:           12
+; RELOC-NEXT:       - Index:           11
 ; RELOC-NEXT:         Name:            mydtor
-; RELOC-NEXT:       - Index:           13
+; RELOC-NEXT:       - Index:           12
 ; RELOC-NEXT:         Name:            .Lcall_dtors.101
-; RELOC-NEXT:       - Index:           14
+; RELOC-NEXT:       - Index:           13
 ; RELOC-NEXT:         Name:            .Lregister_call_dtors.101
-; RELOC-NEXT:       - Index:           15
+; RELOC-NEXT:       - Index:           14
 ; RELOC-NEXT:         Name:            .Lcall_dtors.202
-; RELOC-NEXT:       - Index:           16
+; RELOC-NEXT:       - Index:           15
 ; RELOC-NEXT:         Name:            .Lregister_call_dtors.202
-; RELOC-NEXT:       - Index:           17
+; RELOC-NEXT:       - Index:           16
 ; RELOC-NEXT:         Name:            .Lcall_dtors.2002
-; RELOC-NEXT:       - Index:           18
+; RELOC-NEXT:       - Index:           17
 ; RELOC-NEXT:         Name:            .Lregister_call_dtors.2002
 ; RELOC-NEXT: ...

wasm/InputChunks.h

 #include "lld/Common/ErrorHandler.h"
 #include "llvm/Object/Wasm.h"
 
 using llvm::object::WasmSegment;
 using llvm::wasm::WasmFunction;
 using llvm::wasm::WasmGlobal;
 using llvm::wasm::WasmRelocation;
 using llvm::wasm::WasmSignature;
+using llvm::wasm::WasmGlobalType;
 using llvm::wasm::WasmInitExpr;
 using llvm::object::WasmSection;
 
 namespace lld {
 namespace wasm {
 
 class ObjFile;
 class OutputSegment;
 
 class InputChunk {
 public:
   enum Kind { DataSegment, Function, Global };
 
-  Kind kind() const { return SectionKind; }
+  Kind kind() const { return ChunkKind; }
+  StringRef getFileName() const { return File->getName(); }
+
+  virtual StringRef getComdat() const = 0;
+  virtual StringRef getName() const = 0;
+
+  ObjFile *File;
+
+  // Signals that the section is part of the output.  The garbage collector,
+  // and COMDAT handling can set a sections' Live bit.
+  // If GC is disabled, all sections start out as live by default.
+  unsigned Live : 1;
+
+protected:
+  InputChunk(ObjFile *F, Kind K)
+      : File(F), Live(!Config->GcSections), ChunkKind(K) {}
+  virtual ~InputChunk() = default;
+  Kind ChunkKind;
+};
+
+class InputSection : public InputChunk {
+public:
+  static bool classof(const InputChunk *C) {
+    return C->kind() == DataSegment ||
+           C->kind() == Function;
+  }
 
   uint32_t getSize() const { return data().size(); }
 
   void copyRelocations(const WasmSection &Section);
 
   void writeTo(uint8_t *SectionStart) const;
 
   void setOutputOffset(uint32_t Offset) {
     OutputOffset = Offset;
     calcRelocations();
   }
 
   uint32_t getOutputOffset() const { return OutputOffset; }
   ArrayRef<WasmRelocation> getRelocations() const { return Relocations; }
-  StringRef getFileName() const { return File->getName(); }
-
-  virtual StringRef getComdat() const = 0;
-  virtual StringRef getName() const = 0;
 
   std::vector<OutputRelocation> OutRelocations;
-  ObjFile *File;
-
-  // Signals that the section is part of the output.  The garbage collector,
-  // and COMDAT handling can set a sections' Live bit.
-  // If GC is disabled, all sections start out as live by default.
-  unsigned Live : 1;
 
 protected:
-  InputChunk(ObjFile *F, Kind K)
-      : File(F), Live(!Config->GcSections), SectionKind(K) {}
-  virtual ~InputChunk() = default;
+  InputSection(ObjFile *F, Kind K) : InputChunk(F, K) {}
   void calcRelocations();
   virtual ArrayRef<uint8_t> data() const = 0;
   virtual uint32_t getInputSectionOffset() const = 0;
 
   std::vector<WasmRelocation> Relocations;
-  int32_t OutputOffset = 0;
-  Kind SectionKind;
+  uint32_t OutputOffset = 0;
 };
 
 // Represents a WebAssembly data segment which can be included as part of
 // an output data segments.  Note that in WebAssembly, unlike ELF and other
 // formats, used the term "data segment" to refer to the continous regions of
 // memory that make on the data section. See:
 // https://webassembly.github.io/spec/syntax/modules.html#syntax-data
 //
 // For example, by default, clang will produce a separate data section for
 // each global variable.
-class InputSegment : public InputChunk {
+class InputSegment : public InputSection {
 public:
   InputSegment(const WasmSegment &Seg, ObjFile *F)
-      : InputChunk(F, InputChunk::DataSegment), Segment(Seg) {}
+      : InputSection(F, InputChunk::DataSegment), Segment(Seg) {}
 
   static bool classof(const InputChunk *C) { return C->kind() == DataSegment; }
 
   // Translate an offset in the input segment to an offset in the output
   // segment.
   uint32_t translateVA(uint32_t Address) const;
 
   const OutputSegment *getOutputSegment() const { return OutputSeg; }
protected:
   }
 
   const WasmSegment &Segment;
   const OutputSegment *OutputSeg = nullptr;
 };
 
 // Represents a single wasm function within and input file.  These are
 // combined to create the final output CODE section.
-class InputFunction : public InputChunk {
+class InputFunction : public InputSection {
 public:
   InputFunction(const WasmSignature &S, const WasmFunction *Func,
                 ObjFile *F)
-      : InputChunk(F, InputChunk::Function), Signature(S), Function(Func) {}
+      : InputSection(F, InputChunk::Function), Signature(S), Function(Func) {}
 
   static bool classof(const InputChunk *C) {
     return C->kind() == InputChunk::Function;
   }
 
   StringRef getName() const override { return Function->Name; }
   StringRef getComdat() const override { return Function->Comdat; }
   uint32_t getOutputIndex() const { return OutputIndex.getValue(); }
protected:
   StringRef Name;
   ArrayRef<uint8_t> Body;
 };
 
 // Represents a single Wasm Global within an input file. These are combined to
 // form the final GLOBALS section.
 class InputGlobal : public InputChunk {
 public:
-  InputGlobal(const WasmGlobal *G, ObjFile *F)
-      : InputChunk(F, InputChunk::Global), Global(G) {}
+  InputGlobal(const WasmGlobalType &S, const WasmGlobal *G, ObjFile *F)
+      : InputChunk(F, InputChunk::Global), Signature(S), Global(G) {}
 
   static bool classof(const InputChunk *C) {
     return C->kind() == InputChunk::Global;
   }
 
-  StringRef getComdat() const override { return StringRef(); }
   uint32_t getOutputIndex() const { return OutputIndex.getValue(); }
   bool hasOutputIndex() const { return OutputIndex.hasValue(); }
   void setOutputIndex(uint32_t Index);
 
   virtual const WasmInitExpr &getInitExpr() const { return Global->InitExpr; }
-  virtual const WasmGlobalType &getType() const { return Global->Type; }
+
+  const WasmGlobalType &Signature;
 
 protected:
-  // TODO(sbc): Globals don't really belong in this class heirarchy.
-  // Refactor so to avoid this ugliness.
-  StringRef getName() const override { return {}; }
-  ArrayRef<uint8_t> data() const override { return {}; }
-  uint32_t getInputSectionOffset() const override { return 0; }
+  StringRef getComdat() const override { return StringRef(); }
+  StringRef getName() const override { return StringRef(); }
 
   const WasmGlobal *Global;
   llvm::Optional<uint32_t> OutputIndex;
 };
 
 class SyntheticGlobal : public InputGlobal {
 public:
   SyntheticGlobal(const WasmGlobalType &Type, const WasmInitExpr &InitExpr)
-      : InputGlobal(nullptr, nullptr), InitExpr(InitExpr), Type(Type) {
+      : InputGlobal(Type, nullptr, nullptr), InitExpr(InitExpr) {
     Live = true;
   }
 
   const WasmInitExpr &getInitExpr() const override { return InitExpr; }
-  const WasmGlobalType &getType() const override { return Type; }
 
 protected:
   WasmInitExpr InitExpr;
-  const WasmGlobalType Type;
 };
 
 } // namespace wasm
+
+// Returns a chunk name for an error message.
+std::string toString(const wasm::InputChunk::Kind Type);
+
 } // namespace lld
 
 #endif // LLD_WASM_INPUT_CHUNKS_H

wasm/InputChunks.cpp

 uint32_t InputSegment::translateVA(uint32_t Address) const {
   assert(Address >= startVA() && Address <= endVA());
   int32_t Delta = OutputSeg->StartVA + OutputSegmentOffset - startVA();
   DEBUG(dbgs() << "translateVA: " << getName() << " Delta=" << Delta
                << " Address=" << Address << "\n");
   return Address + Delta;
 }
 
-void InputChunk::copyRelocations(const WasmSection &Section) {
+void InputSection::copyRelocations(const WasmSection &Section) {
   if (Section.Relocations.empty())
     return;
   size_t Start = getInputSectionOffset();
   size_t Size = getSize();
   for (const WasmRelocation &R : Section.Relocations)
     if (R.Offset >= Start && R.Offset < Start + Size)
       Relocations.push_back(R);
 }

 static void applyRelocations(uint8_t *Buf, ArrayRef<OutputRelocation> Relocs) {
   if (!Relocs.size())
     return;
   DEBUG(dbgs() << "applyRelocations: count=" << Relocs.size() << "\n");
   for (const OutputRelocation &Reloc : Relocs)
     applyRelocation(Buf, Reloc);
 }
 
-void InputChunk::writeTo(uint8_t *SectionStart) const {
+void InputSection::writeTo(uint8_t *SectionStart) const {
   memcpy(SectionStart + getOutputOffset(), data().data(), data().size());
   applyRelocations(SectionStart, OutRelocations);
 }
 
 // Populate OutRelocations based on the input relocations and offset within the
 // output section.  Calculates the updated index and offset for each relocation
 // as well as the value to write out in the final binary.
-void InputChunk::calcRelocations() {
+void InputSection::calcRelocations() {
   if (Relocations.empty())
     return;
   int32_t Off = getOutputOffset() - getInputSectionOffset();
   DEBUG(dbgs() << "calcRelocations: " << File->getName()
                << " offset=" << Twine(Off) << "\n");
   for (const WasmRelocation &Reloc : Relocations) {
     OutputRelocation NewReloc;
     NewReloc.Reloc = Reloc;

 }
 
 void InputGlobal::setOutputIndex(uint32_t Index) {
   DEBUG(dbgs() << "InputGlobal::setOutputIndex: " << getName() << " -> "
                << Index << "\n");
   assert(!hasOutputIndex());
   OutputIndex = Index;
 }
+
+std::string lld::toString(const wasm::InputChunk::Kind Type) {
+  switch (Type) {
+  case InputChunk::Function:
+    return "function";
+  case InputChunk::DataSegment:
+    return "segment";
+  case InputChunk::Global:
+    return "global";
+  }
+  llvm_unreachable("invalid chunk type");
+}

wasm/InputFiles.h

 private:
   uint32_t relocateVirtualAddress(uint32_t Index) const;
   uint32_t relocateFunctionIndex(uint32_t Original) const;
   uint32_t relocateTypeIndex(uint32_t Original) const;
   uint32_t relocateGlobalIndex(uint32_t Original) const;
   uint32_t relocateTableIndex(uint32_t Original) const;
   uint32_t relocateSymbolIndex(uint32_t Original) const;
 
-  Symbol *createDefinedData(const WasmSymbol &Sym, InputChunk *Chunk,
+  Symbol *createDefinedData(const WasmSymbol &Sym, InputSegment *Segment,
                             uint32_t Address, uint32_t DataSize);
-  Symbol *createDefinedFunction(const WasmSymbol &Sym, InputChunk *Chunk);
-  Symbol *createDefinedGlobal(const WasmSymbol &Sym, InputChunk *Chunk);
+  Symbol *createDefinedFunction(const WasmSymbol &Sym, InputFunction *Function);
+  Symbol *createDefinedGlobal(const WasmSymbol &Sym, InputGlobal *Global);
   Symbol *createUndefined(const WasmSymbol &Sym);
 
   void initializeSymbols();
   InputSegment *getSegment(const WasmSymbol &WasmSym) const;
   InputFunction *getFunction(const WasmSymbol &Sym) const;
   InputGlobal *getGlobal(const WasmSymbol &Sym) const;
   bool isExcludedByComdat(InputChunk *Chunk) const;
 

wasm/InputFiles.cpp

void ObjFile::initializeSymbols() {
 
   for (const WasmSegment &S : WasmObj->dataSegments()) {
     InputSegment *Seg = make<InputSegment>(S, this);
     Seg->copyRelocations(*DataSection);
     Segments.emplace_back(Seg);
   }
 
   for (const WasmGlobal &G : WasmObj->globals()) {
-    InputGlobal *Global = make<InputGlobal>(&G, this);
+    InputGlobal *Global = make<InputGlobal>(G.Type, &G, this);
     Globals.emplace_back(Global);
   }
 
   for (size_t I = 0; I < Funcs.size(); ++I) {
     const WasmFunction &Func = Funcs[I];
     const WasmSignature &Sig = Types[FuncTypes[I]];
     InputFunction *F = make<InputFunction>(Sig, &Func, this);
     F->copyRelocations(*CodeSection);

 }
 
 Symbol *ObjFile::createUndefined(const WasmSymbol &Sym) {
   return Symtab->addUndefined(Sym.Info.Name, getType(Sym), Sym.Info.Flags, this,
                               Sym.FunctionType, Sym.GlobalType);
 }
 
 Symbol *ObjFile::createDefinedFunction(const WasmSymbol &Sym,
-                                       InputChunk *Chunk) {
+                                       InputFunction *Function) {
   if (Sym.isBindingLocal())
-    return make<DefinedFunction>(Sym.Info.Name, Sym.Info.Flags, this, Chunk);
+    return make<DefinedFunction>(Sym.Info.Name, Sym.Info.Flags, this, Function);
   return Symtab->addDefined(Sym.Info.Name, getType(Sym), Sym.Info.Flags, this,
-                            Chunk);
+                            Function);
 }
 
-Symbol *ObjFile::createDefinedData(const WasmSymbol &Sym, InputChunk *Chunk,
+Symbol *ObjFile::createDefinedData(const WasmSymbol &Sym, InputSegment *Segment,
                                    uint32_t Address, uint32_t Size) {
   if (Sym.isBindingLocal())
-    return make<DefinedData>(Sym.Info.Name, Sym.Info.Flags, this, Chunk,
+    return make<DefinedData>(Sym.Info.Name, Sym.Info.Flags, this, Segment,
                              Address, Size);
   return Symtab->addDefined(Sym.Info.Name, getType(Sym), Sym.Info.Flags, this,
-                            Chunk, Address, Size);
+                            Segment, Address, Size);
 }
 
-Symbol *ObjFile::createDefinedGlobal(const WasmSymbol &Sym, InputChunk *Chunk) {
+Symbol *ObjFile::createDefinedGlobal(const WasmSymbol &Sym,
+                                     InputGlobal *Global) {
   if (Sym.isBindingLocal())
-    return make<DefinedGlobal>(Sym.Info.Name, Sym.Info.Flags, this, Chunk);
+    return make<DefinedGlobal>(Sym.Info.Name, Sym.Info.Flags, this, Global);
   return Symtab->addDefined(Sym.Info.Name, getType(Sym), Sym.Info.Flags, this,
-                            Chunk);
+                            Global);
 }
 
 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/MarkLive.cpp

 using namespace lld;
 using namespace lld::wasm;
 
 void lld::wasm::markLive() {
   if (!Config->GcSections)
     return;
 
   DEBUG(dbgs() << "markLive\n");
-  SmallVector<InputChunk *, 256> Q;
+  SmallVector<InputSection *, 256> Q;
 
   auto Enqueue = [&](Symbol *Sym) {
     if (!Sym)
       return;
     InputChunk *Chunk = Sym->getChunk();
     if (!Chunk || Chunk->Live)
       return;
     Chunk->Live = true;
-    Q.push_back(Chunk);
+    if (InputSection *Section = dyn_cast<InputSection>(Chunk))
+      Q.push_back(Section);
   };
 
   // Add GC root symbols.
   if (!Config->Entry.empty())
     Enqueue(Symtab->find(Config->Entry));
   Enqueue(WasmSym::CallCtors);
 
   // By default we export all non-hidden, so they are gc roots too
   for (Symbol *Sym : Symtab->getSymbols())
     if (!Sym->isHidden())
       Enqueue(Sym);
 
-  // The ctor fuctions are all used the synthetic __wasm_call_ctors function,
-  // but since this function is created in-place it doesn't contain reloctations
-  // which mean we have to manually mark the ctors.
+  // The ctor functions are all used in the synthetic __wasm_call_ctors
+  // function, but since this function is created in-place it doesn't contain
+  // relocatations, which mean we have to manually mark the ctors.
   for (const ObjFile *Obj : Symtab->ObjectFiles) {
     const WasmLinkingData &L = Obj->getWasmObj()->linkingData();
     for (const WasmInitFunc &F : L.InitFunctions)
       Enqueue(Obj->getFunctionSymbol(F.Symbol));
   }
 
-  auto EnqueueSuccessors = [Enqueue](InputChunk &Chunk) {
+  auto EnqueueSuccessors = [Enqueue](InputSection &Chunk) {
     for (const WasmRelocation Reloc : Chunk.getRelocations())
       if (Reloc.Type != R_WEBASSEMBLY_TYPE_INDEX_LEB)
         Enqueue(Chunk.File->getSymbol(Reloc.Index));
   };
 
   while (!Q.empty())
     EnqueueSuccessors(*Q.pop_back_val());
 
   // Report garbage-collected sections.
   if (Config->PrintGcSections) {
     auto CheckChunk = [](const InputChunk *C) {
       if (!C->Live)
-        message("removing unused section '" + C->getName() + "' in file '" +
-                C->getFileName() + "'");
+        message("removing unused " + toString(C->kind()) + " '" + C->getName() +
+                "' in file '" + C->getFileName() + "'");
     };
 
     for (const ObjFile *Obj : Symtab->ObjectFiles) {
       for (InputChunk *C : Obj->Functions)
         CheckChunk(C);
       for (InputChunk *C : Obj->Segments)
         CheckChunk(C);
+      for (InputGlobal *G : Obj->Globals)
+        CheckChunk(G);
     }
   }
 }

wasm/OutputSections.cpp

CodeSection::CodeSection(ArrayRef<InputFunction *> Functions)
     : OutputSection(WASM_SEC_CODE), Functions(Functions) {
   assert(Functions.size() > 0);
 
   raw_string_ostream OS(CodeSectionHeader);
   writeUleb128(OS, Functions.size(), "function count");
   OS.flush();
   BodySize = CodeSectionHeader.size();
 
-  for (InputChunk *Func : Functions) {
+  for (InputSection *Func : Functions) {
     Func->setOutputOffset(BodySize);
     BodySize += Func->getSize();
   }
 
   createHeader(BodySize);
 }
 
 void CodeSection::writeTo(uint8_t *Buf) {
void CodeSection::writeTo(uint8_t *Buf) {
 
   uint8_t *ContentsStart = Buf;
 
   // Write code section headers
   memcpy(Buf, CodeSectionHeader.data(), CodeSectionHeader.size());
   Buf += CodeSectionHeader.size();
 
   // Write code section bodies
-  parallelForEach(Functions, [ContentsStart](const InputChunk *Chunk) {
+  parallelForEach(Functions, [ContentsStart](const InputSection *Chunk) {
     Chunk->writeTo(ContentsStart);
   });
 }
 
 uint32_t CodeSection::numRelocations() const {
   uint32_t Count = 0;
-  for (const InputChunk *Func : Functions)
+  for (const InputSection *Func : Functions)
     Count += Func->OutRelocations.size();
   return Count;
 }
 
 void CodeSection::writeRelocations(raw_ostream &OS) const {
-  for (const InputChunk *Func : Functions)
+  for (const InputSection *Func : Functions)
     for (const OutputRelocation &Reloc : Func->OutRelocations)
       writeReloc(OS, Reloc);
 }
 
 DataSection::DataSection(ArrayRef<OutputSegment *> Segments)
     : OutputSection(WASM_SEC_DATA), Segments(Segments) {
   raw_string_ostream OS(DataSectionHeader);
 
void DataSection::writeTo(uint8_t *Buf) {
   memcpy(Buf, DataSectionHeader.data(), DataSectionHeader.size());
 
   parallelForEach(Segments, [ContentsStart](const OutputSegment *Segment) {
     // Write data segment header
     uint8_t *SegStart = ContentsStart + Segment->getSectionOffset();
     memcpy(SegStart, Segment->Header.data(), Segment->Header.size());
 
     // Write segment data payload
-    for (const InputChunk *Chunk : Segment->InputSegments)
+    for (const InputSection *Chunk : Segment->InputSegments)
       Chunk->writeTo(ContentsStart);
   });
 }
 
 uint32_t DataSection::numRelocations() const {
   uint32_t Count = 0;
   for (const OutputSegment *Seg : Segments)
-    for (const InputChunk *InputSeg : Seg->InputSegments)
+    for (const InputSection *InputSeg : Seg->InputSegments)
       Count += InputSeg->OutRelocations.size();
   return Count;
 }
 
 void DataSection::writeRelocations(raw_ostream &OS) const {
   for (const OutputSegment *Seg : Segments)
-    for (const InputChunk *InputSeg : Seg->InputSegments)
+    for (const InputSection *InputSeg : Seg->InputSegments)
       for (const OutputRelocation &Reloc : InputSeg->OutRelocations)
         writeReloc(OS, Reloc);
 }

wasm/SymbolTable.cpp

 
 static void checkSymbolTypes(const Symbol &Existing, const InputFile &F,
                              WasmSymbolType NewType, const InputChunk *Chunk) {
   const WasmSignature *FunctionSig = nullptr;
   const WasmGlobalType *GlobalType = nullptr;
   if (auto *Function = dyn_cast_or_null<InputFunction>(Chunk))
     FunctionSig = &Function->Signature;
   if (auto *Global = dyn_cast_or_null<InputGlobal>(Chunk))
-    GlobalType = &Global->getType();
+    GlobalType = &Global->Signature;
   return checkSymbolTypes(Existing, F, NewType, FunctionSig, GlobalType);
 }
 
 DefinedFunction *SymbolTable::addSyntheticFunction(StringRef Name,
                                                    const WasmSignature *Type,
                                                    uint32_t Flags) {
   DEBUG(dbgs() << "addSyntheticFunction: " << Name << "\n");
   Symbol *S;
DefinedGlobal *SymbolTable::addSyntheticGlobal(StringRef Name, uint32_t Flags,
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name);
   return replaceSymbol<DefinedGlobal>(S, Name, Flags, Type);
 }
 
 Symbol *SymbolTable::addDefined(StringRef Name, WasmSymbolType Type,
                                 uint32_t Flags, InputFile *F, InputChunk *Chunk,
                                 uint32_t Address, uint32_t DataSize) {
-  if (Type == WASM_SYMBOL_TYPE_FUNCTION)
-    DEBUG(dbgs() << "addDefined: func:" << Name << "\n");
-  else
-    DEBUG(dbgs() << "addDefined: global:" << Name << " addr:" << Address
-                 << "\n");
+  DEBUG(dbgs() << "addDefined: " << toString(Type) << ":" << Name << "\n");
   Symbol *S;
   bool WasInserted;
   bool Replace = false;
   bool CheckTypes = false;
 
   std::tie(S, WasInserted) = insert(Name);
   if (WasInserted) {
     Replace = true;
if (WasInserted) {
     reportDuplicate(S, F);
   }
 
   if (Replace) {
     if (CheckTypes)
       checkSymbolTypes(*S, *F, Type, Chunk);
     switch (Type) {
     case WASM_SYMBOL_TYPE_FUNCTION:
-      replaceSymbol<DefinedFunction>(S, Name, Flags, F, Chunk);
+      replaceSymbol<DefinedFunction>(S, Name, Flags, F,
+                                     cast<InputFunction>(Chunk));
       break;
     case WASM_SYMBOL_TYPE_DATA:
-      replaceSymbol<DefinedData>(S, Name, Flags, F, Chunk, Address, DataSize);
+      replaceSymbol<DefinedData>(S, Name, Flags, F, cast<InputSegment>(Chunk),
+                                 Address, DataSize);
       break;
     case WASM_SYMBOL_TYPE_GLOBAL:
-      replaceSymbol<DefinedGlobal>(S, Name, Flags, F, Chunk);
+      replaceSymbol<DefinedGlobal>(S, Name, Flags, F, cast<InputGlobal>(Chunk));
       break;
     }
   }
   return S;
 }
 
 Symbol *SymbolTable::addUndefined(StringRef Name, WasmSymbolType Type,
                                   uint32_t Flags, InputFile *F,

wasm/Symbols.h

 using llvm::wasm::WasmGlobalType;
 using llvm::wasm::WasmSymbolType;
 
 namespace lld {
 namespace wasm {
 
 class InputFile;
 class InputChunk;
+class InputFunction;
+class InputGlobal;
+class InputSegment;
 
 #define INVALID_INDEX UINT32_MAX
 
 // The base class for real symbol classes.
 class Symbol {
 public:
   enum Kind {
     DefinedFunctionKind,
public:
 
   // Returns true if a table index has been set for this symbol
   bool hasTableIndex() const;
 
   // Set the table index of the symbol
   void setTableIndex(uint32_t Index);
 
 protected:
-  void setFunctionType(const WasmSignature *Type);
-
-  FunctionSymbol(StringRef Name, Kind K, uint32_t Flags, InputFile *F,
-                 InputChunk *C)
-      : Symbol(Name, K, Flags, F, C) {}
+  FunctionSymbol(StringRef Name, Kind K, uint32_t Flags, InputFile *F)
+      : Symbol(Name, K, Flags, F, nullptr) {}
 
   uint32_t TableIndex = INVALID_INDEX;
 
-  // Explicit function type, needed for undefined or synthetic functions only.
-  // For regular defined functions this information comes from the InputChunk.
+  // Explicit function type.  For regular defined functions this information
+  // comes from the InputFunction.
   const WasmSignature *FunctionType = nullptr;
 };
 
 class DefinedFunction : public FunctionSymbol {
 public:
   // Primary constructor for file-defined functions.
   DefinedFunction(StringRef Name, uint32_t Flags, InputFile *F = nullptr,
-                  InputChunk *C = nullptr)
-      : FunctionSymbol(Name, DefinedFunctionKind, Flags, F, C) {}
+                  InputFunction *Func = nullptr)
+      : FunctionSymbol(Name, DefinedFunctionKind, Flags, F) {
+    setFunction(Func);
+  }
 
   // Second constructor used when creating synthetic functions.
   DefinedFunction(StringRef Name, uint32_t Flags, const WasmSignature *Type)
-      : FunctionSymbol(Name, DefinedFunctionKind, Flags, nullptr, nullptr) {
-    setFunctionType(Type);
+      : FunctionSymbol(Name, DefinedFunctionKind, Flags, nullptr) {
+    FunctionType = Type;
   }
 
   static bool classof(const Symbol *S) {
     return S->kind() == DefinedFunctionKind;
   }
 
-  // This is used when constructing the __wasm_call_ctors function
-  // which happens after the DefinedSymbol has been created.
+  // This is used when constructing the __wasm_call_ctors function, which
+  // happens after the DefinedFunction has been created.
   // TODO(sbc): Refactor to avoid the need to handling this special case.
-  void setChunk(InputChunk *C) { Chunk = C; }
+  void setFunction(InputFunction *F);
 };
 
 class UndefinedFunction : public FunctionSymbol {
 public:
   UndefinedFunction(StringRef Name, uint32_t Flags, InputFile *File = nullptr,
                     const WasmSignature *Type = nullptr)
-      : FunctionSymbol(Name, UndefinedFunctionKind, Flags, File, nullptr) {
-    setFunctionType(Type);
+      : FunctionSymbol(Name, UndefinedFunctionKind, Flags, File) {
+    FunctionType = Type;
   }
 
   static bool classof(const Symbol *S) {
     return S->kind() == UndefinedFunctionKind;
   }
 };
 
 class DataSymbol : public Symbol {
protected:
   uint32_t VirtualAddress;
   uint32_t Size;
 };
 
 class UndefinedData : public DataSymbol {
 public:
   UndefinedData(StringRef Name, uint32_t Flags, InputFile *File = nullptr)
       : DataSymbol(Name, UndefinedDataKind, Flags, File, nullptr) {}
+
   static bool classof(const Symbol *S) {
     return S->kind() == UndefinedDataKind;
   }
 };
 
 class GlobalSymbol : public Symbol {
 public:
   static bool classof(const Symbol *S) {
     return S->kind() == DefinedGlobalKind || S->kind() == UndefinedGlobalKind;
   }
 
   const WasmGlobalType &getGlobalType() const;
 
 protected:
-  void setGlobalType(const WasmGlobalType *Type);
+  GlobalSymbol(StringRef Name, Kind K, uint32_t Flags, InputFile *F)
+      : Symbol(Name, K, Flags, F, nullptr) {}
 
-  GlobalSymbol(StringRef Name, Kind K, uint32_t Flags, InputFile *F,
-               InputChunk *C)
-      : Symbol(Name, K, Flags, F, C) {}
-
-  // Explicit function type, needed for undefined or synthetic functions only.
-  // For regular defined globals this information comes from the InputChunk.
+  // Explicit global type.  For regular defined globals this information comes
+  // from the InputGlobal.
   const WasmGlobalType *GlobalType = nullptr;
 };
 
 class DefinedGlobal : public GlobalSymbol {
 public:
   // Primary constructor for file-defined globals.
-  DefinedGlobal(StringRef Name, uint32_t Flags, InputFile *File, InputChunk *C)
-      : GlobalSymbol(Name, DefinedGlobalKind, Flags, File, C) {}
+  DefinedGlobal(StringRef Name, uint32_t Flags, InputFile *File,
+                InputGlobal *G = nullptr)
+      : GlobalSymbol(Name, DefinedGlobalKind, Flags, File) {
+    setGlobal(G);
+  }
 
   // Second constructor used when creating synthetic globals.
   DefinedGlobal(StringRef Name, uint32_t Flags, const WasmGlobalType *Type)
-      : GlobalSymbol(Name, DefinedGlobalKind, Flags, nullptr, nullptr) {
-    setGlobalType(Type);
+      : GlobalSymbol(Name, DefinedGlobalKind, Flags, nullptr) {
+    GlobalType = Type;
+  }
+
+  static bool classof(const Symbol *S) {
+    return S->kind() == DefinedGlobalKind;
   }
 
-  void setChunk(InputChunk *C) { Chunk = C; }
+  // This is used when constructing the __stack_pointer global, which happens
+  // after the DefinedGlobal has been created.
+  // TODO(sbc): Refactor to avoid the need to handling this special case.
+  void setGlobal(InputGlobal *G);
 };
 
 class UndefinedGlobal : public GlobalSymbol {
 public:
   UndefinedGlobal(StringRef Name, uint32_t Flags, InputFile *File = nullptr,
                   const WasmGlobalType *Type = nullptr)
-      : GlobalSymbol(Name, UndefinedGlobalKind, Flags, File, nullptr) {
-    setGlobalType(Type);
+      : GlobalSymbol(Name, UndefinedGlobalKind, Flags, File) {
+    GlobalType = Type;
   }
 
   static bool classof(const Symbol *S) {
     return S->kind() == UndefinedGlobalKind;
   }
 };
 
 class LazySymbol : public Symbol {

wasm/Symbols.cpp

WasmSymbolType Symbol::getWasmType() const {
   default:
     llvm_unreachable("invalid symbol kind");
   }
 }
 
 bool Symbol::hasOutputIndex() const {
   if (auto *F = dyn_cast_or_null<InputFunction>(Chunk))
     return F->hasOutputIndex();
+  if (auto *G = dyn_cast_or_null<InputGlobal>(Chunk))
+    return G->hasOutputIndex();
+  assert(!isData());
+  assert(!Chunk);
   return OutputIndex != INVALID_INDEX;
 }
 
 uint32_t Symbol::getOutputIndex() const {
-  assert(!isData());
   if (auto *F = dyn_cast_or_null<InputFunction>(Chunk))
     return F->getOutputIndex();
   if (auto *G = dyn_cast_or_null<InputGlobal>(Chunk))
     return G->getOutputIndex();
+  assert(!isData());
+  assert(!Chunk);
   assert(OutputIndex != INVALID_INDEX);
   return OutputIndex;
 }
 
 uint32_t Symbol::getOutputSymbolIndex() const {
   assert(OutputSymbolIndex != INVALID_INDEX);
   return OutputSymbolIndex;
 }
void Symbol::setHidden(bool IsHidden) {
   Flags &= ~WASM_SYMBOL_VISIBILITY_MASK;
   if (IsHidden)
     Flags |= WASM_SYMBOL_VISIBILITY_HIDDEN;
   else
     Flags |= WASM_SYMBOL_VISIBILITY_DEFAULT;
 }
 
 const WasmSignature &FunctionSymbol::getFunctionType() const {
-  if (auto *F = dyn_cast_or_null<InputFunction>(Chunk))
-    return F->Signature;
-
   assert(FunctionType != nullptr);
   return *FunctionType;
 }
 
-void FunctionSymbol::setFunctionType(const WasmSignature *Type) {
-  assert(FunctionType == nullptr);
-  assert(!Chunk);
-  FunctionType = Type;
-}
-
 uint32_t FunctionSymbol::getTableIndex() const {
   if (auto *F = dyn_cast_or_null<InputFunction>(Chunk))
     return F->getTableIndex();
   assert(TableIndex != INVALID_INDEX);
   return TableIndex;
 }
 
 bool FunctionSymbol::hasTableIndex() const {
if (auto *F = dyn_cast_or_null<InputFunction>(Chunk)) {
     F->setTableIndex(Index);
     return;
   }
   DEBUG(dbgs() << "setTableIndex " << Name << " -> " << Index << "\n");
   assert(TableIndex == INVALID_INDEX);
   TableIndex = Index;
 }
 
+void DefinedFunction::setFunction(InputFunction *F) {
+  Chunk = F;
+  assert(FunctionType == nullptr || *FunctionType == F->Signature);
+  FunctionType = &F->Signature;
+}
+
 uint32_t DefinedData::getVirtualAddress() const {
   DEBUG(dbgs() << "getVirtualAddress: " << getName() << "\n");
-  return Chunk ? dyn_cast<InputSegment>(Chunk)->translateVA(VirtualAddress)
+  return Chunk ? cast<InputSegment>(Chunk)->translateVA(VirtualAddress)
                : VirtualAddress;
 }
 
 void DefinedData::setVirtualAddress(uint32_t Value) {
   DEBUG(dbgs() << "setVirtualAddress " << Name << " -> " << Value << "\n");
   assert(isData());
   VirtualAddress = Value;
 }
 
 uint32_t DefinedData::getOutputSegmentOffset() const {
   DEBUG(dbgs() << "getOutputSegmentOffset: " << getName() << "\n");
   const InputSegment *Segment = dyn_cast<InputSegment>(Chunk);
   return Segment->OutputSegmentOffset + VirtualAddress - Segment->startVA();
 }
 
 uint32_t DefinedData::getOutputSegmentIndex() const {
   DEBUG(dbgs() << "getOutputSegmentIndex: " << getName() << "\n");
   const InputSegment *Segment = dyn_cast<InputSegment>(Chunk);
   return Segment->getOutputSegment()->Index;
 }
 
 const WasmGlobalType &GlobalSymbol::getGlobalType() const {
-  if (auto *G = dyn_cast_or_null<InputGlobal>(Chunk))
-    return G->getType();
-
-  DEBUG(dbgs() << "getGlobalType: " << getName() << "\n");
   assert(GlobalType != nullptr);
   return *GlobalType;
 }
 
-void GlobalSymbol::setGlobalType(const WasmGlobalType *Type) {
-  assert(GlobalType == nullptr);
-  assert(!Chunk);
-  GlobalType = Type;
+void DefinedGlobal::setGlobal(InputGlobal *G) {
+  Chunk = G;
+  assert(GlobalType == nullptr || *GlobalType == G->Signature);
+  GlobalType = &G->Signature;
 }
 
 std::string lld::toString(const wasm::Symbol &Sym) {
   if (Config->Demangle)
     if (Optional<std::string> S = demangleItanium(Sym.getName()))
       return "`" + *S + "'";
   return Sym.getName();
 }

wasm/Writer.cpp

if (NumGlobals == 0)
     return;
 
   SyntheticSection *Section = createSyntheticSection(WASM_SEC_GLOBAL);
   raw_ostream &OS = Section->getStream();
 
   writeUleb128(OS, NumGlobals, "global count");
   for (const InputGlobal *G : DefinedGlobals) {
     WasmGlobal Global;
-    Global.Type = G->getType();
+    Global.Type = G->Signature;
     Global.InitExpr = G->getInitExpr();
     writeGlobal(OS, Global);
   }
   for (const DefinedData *Sym : DefinedFakeGlobals) {
     WasmGlobal Global;
     Global.Type = {WASM_TYPE_I32, false};
     Global.InitExpr.Opcode = WASM_OPCODE_I32_CONST;
     Global.InitExpr.Value.Int32 = Sym->getVirtualAddress();
for (InputFunction *Func : File->Functions) {
       DefinedFunctions.emplace_back(Func);
       Func->setOutputIndex(FunctionIndex++);
     }
   }
 
   uint32_t TableIndex = kInitialTableOffset;
   for (ObjFile *File : Symtab->ObjectFiles) {
     DEBUG(dbgs() << "Handle relocs: " << File->getName() << "\n");
-    auto HandleRelocs = [&](InputChunk *Chunk) {
+    auto HandleRelocs = [&](InputSection *Chunk) {
       if (!Chunk->Live)
         return;
       ArrayRef<WasmSignature> Types = File->getWasmObj()->types();
       for (const WasmRelocation& Reloc : Chunk->getRelocations()) {
         if (Reloc.Type == R_WEBASSEMBLY_TABLE_INDEX_I32 ||
             Reloc.Type == R_WEBASSEMBLY_TABLE_INDEX_SLEB) {
           FunctionSymbol *Sym = File->getFunctionSymbol(Reloc.Index);
           if (Sym->hasTableIndex() || !Sym->hasOutputIndex())

 
 static const int OPCODE_CALL = 0x10;
 static const int OPCODE_END = 0xb;
 
 // Create synthetic "__wasm_call_ctors" function based on ctor functions
 // in input object.
 void Writer::createCtorFunction() {
   uint32_t FunctionIndex = NumImportedFunctions + DefinedFunctions.size();
-  WasmSym::CallCtors->setOutputIndex(FunctionIndex);
 
   // First write the body bytes to a string.
   std::string FunctionBody;
   const WasmSignature &Signature = WasmSym::CallCtors->getFunctionType();
   {
     raw_string_ostream OS(FunctionBody);
     writeUleb128(OS, 0, "num locals");
     for (const WasmInitEntry &F : InitFunctions) {
       writeU8(OS, OPCODE_CALL, "CALL");
       writeUleb128(OS, F.Sym->getOutputIndex(), "function index");
     }
     writeU8(OS, OPCODE_END, "END");
   }
 
   // Once we know the size of the body we can create the final function body
   raw_string_ostream OS(CtorFunctionBody);
   writeUleb128(OS, FunctionBody.size(), "function size");
   OS.flush();
   CtorFunctionBody += FunctionBody;
   ArrayRef<uint8_t> BodyArray(
       reinterpret_cast<const uint8_t *>(CtorFunctionBody.data()),
       CtorFunctionBody.size());
   CtorFunction = llvm::make_unique<SyntheticFunction>(
       Signature, BodyArray, WasmSym::CallCtors->getName());
+  WasmSym::CallCtors->setFunction(CtorFunction.get());
   CtorFunction->setOutputIndex(FunctionIndex);
-  WasmSym::CallCtors->setChunk(CtorFunction.get());
   DefinedFunctions.emplace_back(CtorFunction.get());
 }
 
 // Populate InitFunctions vector with init functions from all input objects.
 // This is then used either when creating the output linking section or to
 // synthesize the "__wasm_call_ctors" function.
 void Writer::calculateInitFunctions() {
   for (ObjFile *File : Symtab->ObjectFiles) {

 void Writer::createStackPointer(uint32_t Address) {
   WasmInitExpr InitExpr;
   InitExpr.Opcode = WASM_OPCODE_I32_CONST;
   InitExpr.Value.Int32 = Address;
   StackPtrGlobal = make_unique<SyntheticGlobal>(
       WasmSym::StackPointer->getGlobalType(), InitExpr);
   StackPtrGlobal->setOutputIndex(NumImportedGlobals + DefinedGlobals.size());
   DefinedGlobals.emplace_back(StackPtrGlobal.get());
-  WasmSym::StackPointer->setChunk(StackPtrGlobal.get());
+  WasmSym::StackPointer->setGlobal(StackPtrGlobal.get());
 }
 
 void Writer::run() {
   log("-- calculateImports");
   calculateImports();
   log("-- assignIndexes");
   assignIndexes();
   log("-- calculateInitFunctions");

wasm/WriterUtils.cpp

std::string lld::toString(const WasmSignature &Sig) {
   if (Sig.ReturnType == WASM_TYPE_NORESULT)
     S += "void";
   else
     S += toString(static_cast<ValType>(Sig.ReturnType));
   return S.str();
 }
 
 std::string lld::toString(const WasmGlobalType &Sig) {
-  std::string S = toString(static_cast<ValType>(Sig.Type));
-  if (Sig.Mutable)
-    return "mutable " + S;
-  return S;
+  return (Sig.Mutable ? "var " : "const ") +
+      toString(static_cast<ValType>(Sig.Type));
 }