[WebAssembly] Add support for named globals in the object format.

[sbc100]

• rename var

[tlively]

Nice! This will be helpful for reading disassembled modules. In a future where we have a clang extension allowing users to define their own WebAssembly globals from C/C++, would it be easy to extend this to support names for those arbitrary globals as well?

[sbc100]

In D91769#2404789, @tlively wrote:

Nice! This will be helpful for reading disassembled modules. In a future where we have a clang extension allowing users to define their own WebAssembly globals from C/C++, would it be easy to extend this to support names for those arbitrary globals as well?

Yup. Anything that has a name in the symbol table will end up with a name in the name section.

lld/test/wasm/alias.s

 # CHECK-NEXT:       - Index:           0
 # CHECK-NEXT:         Locals:
 # CHECK-NEXT:         Body:            0B
 # CHECK-NEXT:   - Type:            CUSTOM
 # CHECK-NEXT:     Name:            name
 # CHECK-NEXT:     FunctionNames:
 # CHECK-NEXT:       - Index:           0
 # CHECK-NEXT:         Name:            _start
+# CHECK-NEXT:     GlobalNames:
+# CHECK-NEXT:       - Index:           0
+# CHECK-NEXT:         Name:            __stack_pointer
 # CHECK-NEXT: ...

lld/test/wasm/call-indirect.ll

 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Name:            call_bar_indirect
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Name:            foo
 ; CHECK-NEXT:       - Index:           3
 ; CHECK-NEXT:         Name:            _start
 ; CHECK-NEXT:       - Index:           4
 ; CHECK-NEXT:         Name:            call_ptr
+; CHECK-NEXT:     GlobalNames:
+; CHECK-NEXT:       - Index:           0
+; CHECK-NEXT:         Name:            __stack_pointer
 ; CHECK-NEXT: ...

lld/test/wasm/ctor_return_value.s

 # CHECK-NEXT:     Name:            name
 # CHECK-NEXT:     FunctionNames:
 # CHECK-NEXT:       - Index:           0
 # CHECK-NEXT:         Name:            __wasm_call_ctors
 # CHECK-NEXT:       - Index:           1
 # CHECK-NEXT:         Name:            myctor
 # CHECK-NEXT:       - Index:           2
 # CHECK-NEXT:         Name:            _start
+# CHECK-NEXT:     GlobalNames:
+# CHECK-NEXT:       - Index:           0
+# CHECK-NEXT:         Name:            __stack_pointer
 # CHECK-NEXT: ...

lld/test/wasm/cxx-mangling.ll

 ; CHECK-NEXT:       - Index:           0
 ; DEMANGLE-NEXT:      Name:            'undefined_weak:bar(int)'
 ; MANGLE-NEXT:        Name:            'undefined_weak:_Z3bari'
 ; CHECK-NEXT:       - Index:           1
 ; DEMANGLE-NEXT:      Name:            'foo(int)'
 ; MANGLE-NEXT:        Name:            _Z3fooi
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Name:            _start
+; CHECK-NEXT:     GlobalNames:
+; CHECK-NEXT:       - Index:           0
+; CHECK-NEXT:         Name:            __stack_pointer
 ; CHECK-NEXT: ...

lld/test/wasm/data-segment-merging.ll

 ; MERGE-NEXT:        InitFlags:       0
 ; MERGE-NEXT:        Offset:
 ; MERGE:             Content:         68656C6C6F00676F6F6462796500776861746576657200002A000000
 ; MERGE-NEXT:  - Type:            CUSTOM
 ; MERGE-NEXT:    Name:            name
 ; MERGE-NEXT:    FunctionNames:
 ; MERGE-NEXT:      - Index:           0
 ; MERGE-NEXT:        Name:            __wasm_call_ctors
+; MERGE-NEXT:    GlobalNames:
+; MERGE-NEXT:      - Index:           0
+; MERGE-NEXT:        Name:            __stack_pointer
 ; MERGE-NOT:       - Index:
 
 ; RUN: wasm-ld -no-gc-sections --no-entry --no-merge-data-segments -o %t.separate.wasm %t.o
 ; RUN: obj2yaml %t.separate.wasm | FileCheck %s --check-prefix=SEPARATE
 
 ; SEPARATE-NOT:                  DATACOUNT
 ; SEPARATE-LABEL: - Type:            DATA
 ; SEPARATE-NEXT:    Segments:

 ; SEPARATE-NEXT:        InitFlags:       0
 ; SEPARATE-NEXT:        Offset:
 ; SEPARATE:             Content:         2A000000
 ; SEPARATE-NEXT:  - Type:            CUSTOM
 ; SEPARATE-NEXT:    Name:            name
 ; SEPARATE-NEXT:    FunctionNames:
 ; SEPARATE-NEXT:      - Index:           0
 ; SEPARATE-NEXT:        Name:            __wasm_call_ctors
+; SEPARATE-NEXT:    GlobalNames:
+; SEPARATE-NEXT:      - Index:           0
+; SEPARATE-NEXT:        Name:            __stack_pointer
 ; SEPARATE-NOT:       - Index:
 
 ; RUN: wasm-ld -no-gc-sections --no-entry --shared-memory --max-memory=131072 -o %t.merged.passive.wasm %t.passive.o
 ; RUN: obj2yaml %t.merged.passive.wasm | FileCheck %s --check-prefix=PASSIVE-MERGE
 
 ; PASSIVE-MERGE-LABEL: - Type:            DATACOUNT
 ; PASSIVE-MERGE-NEXT:    Count:           2
 ; PASSIVE-MERGE-LABEL: - Type:            DATA

lld/test/wasm/function-imports-first.ll

 ; CHECK-NEXT:        Body:            41000B
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            name
 ; CHECK-NEXT:     FunctionNames:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            _start
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Name:            ret32
+; CHECK-NEXT:     GlobalNames:
+; CHECK-NEXT:       - Index:           0
+; CHECK-NEXT:         Name:            __stack_pointer
 ; CHECK-NEXT: ...

lld/test/wasm/function-imports.ll

 ; CHECK:           - Index:       0
 ; CHECK:           - Index:       1
 ; CHECK:         Name:            name
 ; CHECK-NEXT:    FunctionNames:
 ; CHECK-NEXT:      - Index:           0
 ; CHECK-NEXT:        Name:            ret32
 ; CHECK-NEXT:      - Index:           1
 ; CHECK-NEXT:        Name:            _start
+; CHECK-NEXT:    GlobalNames:
+; CHECK-NEXT:      - Index:           0
+; CHECK-NEXT:        Name:            __stack_pointer
 ; CHECK-NEXT: ...

lld/test/wasm/gc-imports.s

 # CHECK-NEXT:     Name:            name
 # CHECK-NEXT:     FunctionNames:
 # CHECK-NEXT:       - Index:           0
 # CHECK-NEXT:         Name:            used_undef_function
 # CHECK-NEXT:       - Index:           1
 # CHECK-NEXT:         Name:            _start
 # CHECK-NEXT:       - Index:           2
 # CHECK-NEXT:         Name:            use_undef_global
+# CHECK-NEXT:     GlobalNames:
+# CHECK-NEXT:       - Index:           0
+# CHECK-NEXT:         Name:            used_undef_global
+# CHECK-NEXT:       - Index:           1
+# CHECK-NEXT:         Name:            __stack_pointer
 # CHECK-NEXT: ...
 
 # RUN: wasm-ld --no-gc-sections --allow-undefined \
 # RUN:     -o %t1.no-gc.wasm %t.o %t_globals.o
 # RUN: obj2yaml %t1.no-gc.wasm | FileCheck %s -check-prefix=NO-GC
 
 # NO-GC:        - Type:            IMPORT
 # NO-GC-NEXT:     Imports:

 # NO-GC-NEXT:       - Index:           2
 # NO-GC-NEXT:         Name:            __wasm_call_ctors
 # NO-GC-NEXT:       - Index:           3
 # NO-GC-NEXT:         Name:            foo
 # NO-GC-NEXT:       - Index:           4
 # NO-GC-NEXT:         Name:            _start
 # NO-GC-NEXT:       - Index:           5
 # NO-GC-NEXT:         Name:            use_undef_global
+# NO-GC-NEXT:     GlobalNames:
+# NO-GC-NEXT:       - Index:           0
+# NO-GC-NEXT:         Name:            unused_undef_global
+# NO-GC-NEXT:       - Index:           1
+# NO-GC-NEXT:         Name:            used_undef_global
+# NO-GC-NEXT:       - Index:           2
+# NO-GC-NEXT:         Name:            __stack_pointer
 # NO-GC-NEXT: ...

lld/test/wasm/gc-sections.ll

 ; CHECK-NEXT:     Name:            name
 ; CHECK-NEXT:     FunctionNames:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            used_function
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Name:            _start
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Name:            use_global
+; CHECK-NEXT:     GlobalNames:
+; CHECK-NEXT:       - Index:           0
+; CHECK-NEXT:         Name:            __stack_pointer
+; CHECK-NEXT:       - Index:           1
+; CHECK-NEXT:         Name:            used_global
 ; CHECK-NEXT: ...
 
 ; RUN: wasm-ld -print-gc-sections --no-gc-sections -o %t1.no-gc.wasm \
 ; RUN:     %t.o %t_globals.o
 ; RUN: obj2yaml %t1.no-gc.wasm | FileCheck %s -check-prefix=NO-GC
 
 ; NO-GC:        - Type:            TYPE
 ; NO-GC-NEXT:     Signatures:

 ; NO-GC-NEXT:       - Index:           1
 ; NO-GC-NEXT:         Name:            unused_function
 ; NO-GC-NEXT:       - Index:           2
 ; NO-GC-NEXT:         Name:            used_function
 ; NO-GC-NEXT:       - Index:           3
 ; NO-GC-NEXT:         Name:            _start
 ; NO-GC-NEXT:       - Index:           4
 ; NO-GC-NEXT:         Name:            use_global
+; NO-GC-NEXT:     GlobalNames:
+; NO-GC-NEXT:       - Index:           0
+; NO-GC-NEXT:         Name:            __stack_pointer
+; NO-GC-NEXT:       - Index:           1
+; NO-GC-NEXT:         Name:            unused_global
+; NO-GC-NEXT:       - Index:           2
+; NO-GC-NEXT:         Name:            used_global
 ; NO-GC-NEXT: ...
 
 ; RUN: not wasm-ld --gc-sections --relocatable -o %t1.no-gc.wasm %t.o 2>&1 | FileCheck %s -check-prefix=CHECK-ERROR
 ; CHECK-ERROR: error: -r and --gc-sections may not be used together

lld/test/wasm/init-fini.ll

 ; CHECK-NEXT:       - Index:           19
 ; CHECK-NEXT:         Name:            .Lcall_dtors.202
 ; CHECK-NEXT:       - Index:           20
 ; CHECK-NEXT:         Name:            .Lregister_call_dtors.202
 ; CHECK-NEXT:       - Index:           21
 ; CHECK-NEXT:         Name:            .Lcall_dtors.2002
 ; CHECK-NEXT:       - Index:           22
 ; CHECK-NEXT:         Name:            .Lregister_call_dtors.2002
+; CHECK-NEXT:     GlobalNames:
+; CHECK-NEXT:       - Index:           0
+; CHECK-NEXT:         Name:            __stack_pointer
 ; CHECK-NEXT: ...
 
 ; RUN: wasm-ld -r %t.o %t.global-ctor-dtor.o -o %t.reloc.wasm
 ; RUN: llvm-readobj --symbols --sections %t.reloc.wasm | FileCheck -check-prefix=RELOC %s
 
 ; RELOC:       Name: linking
 ; RELOC-NEXT:  InitFunctions [
 ; RELOC-NEXT:    0 (priority=101)

lld/test/wasm/load-undefined.test

 ; CHECK-NEXT:      - Index:           0
 ; CHECK-NEXT:        Name:            __wasm_call_ctors
 ; CHECK-NEXT:      - Index:           1
 ; CHECK-NEXT:        Name:            _start
 ; CHECK-NEXT:      - Index:           2
 ; CHECK-NEXT:        Name:            ret64
 ; CHECK-NEXT:      - Index:           3
 ; CHECK-NEXT:        Name:            ret32
+; CHECK-NEXT:     GlobalNames:
+; CHECK-NEXT:       - Index:           0
+; CHECK-NEXT:         Name:            __stack_pointer
 ; CHECK-NEXT: ...
 
 ; NO-LOAD:         Name:            name
 ; NO-LOAD-NEXT:    FunctionNames:   
 ; NO-LOAD-NEXT:      - Index:           0
 ; NO-LOAD-NEXT:        Name:            __wasm_call_ctors
 ; NO-LOAD-NEXT:      - Index:           1
 ; NO-LOAD-NEXT:        Name:            _start
 ; NO-LOAD-NEXT:      - Index:           2
 ; NO-LOAD-NEXT:        Name:            ret64
+; NO-LOAD-NEXT:     GlobalNames:
+; NO-LOAD-NEXT:       - Index:           0
+; NO-LOAD-NEXT:         Name:            __stack_pointer
 ; NO-LOAD-NEXT: ...
 
 ; Verify that referencing a symbol that is not found doesn't result in a link
 ; failure.  This matches the behaviour of the ELF linker.
 ; RUN: wasm-ld %t.start.o -o %t.wasm -u symboldoesnotexist

lld/test/wasm/local-symbols.ll

 ; CHECK-NEXT:         Content:         '0100000003000000'
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            name
 ; CHECK-NEXT:     FunctionNames:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            baz
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Name:            _start
+; CHECK-NEXT:     GlobalNames:
+; CHECK-NEXT:       - Index:           0
+; CHECK-NEXT:         Name:            __stack_pointer
 ; CHECK-NEXT: ...

lld/test/wasm/locals-duplicate.test

 ; CHECK-NEXT:       - Index:           14
 ; CHECK-NEXT:         Name:            get_global3B
 ; CHECK-NEXT:       - Index:           15
 ; CHECK-NEXT:         Name:            get_func1B
 ; CHECK-NEXT:       - Index:           16
 ; CHECK-NEXT:         Name:            get_func2B
 ; CHECK-NEXT:       - Index:           17
 ; CHECK-NEXT:         Name:            get_func3B
+; CHECK-NEXT:     GlobalNames:
+; CHECK-NEXT:       - Index:           0
+; CHECK-NEXT:         Name:            __stack_pointer
 ; CHECK-NEXT: ...
 
 
 ; RUN: wasm-ld -r --no-entry -o %t.reloc.wasm %t1.o %t2.o
 ; RUN: obj2yaml %t.reloc.wasm | FileCheck -check-prefix=RELOC %s
 
 ; RELOC:      --- !WASM
 ; RELOC-NEXT: FileHeader:

lld/test/wasm/map-file.s

 # CHECK-NEXT:       -       3f        9                 bar
 # CHECK-NEXT:       -       48        9         {{.*}}{{/|\\}}map-file.s.tmp1.o:(_start)
 # CHECK-NEXT:       -       48        9                 _start
 # CHECK-NEXT:       -       53        d DATA
 # CHECK-NEXT:     400       54        4 .data
 # CHECK-NEXT:     400       5a        4         {{.*}}{{/|\\}}map-file.s.tmp1.o:(.data.somedata)
 # CHECK-NEXT:     400       5a        4                 somedata
 # CHECK-NEXT:       -       60       12 CUSTOM(.debug_info)
-# CHECK-NEXT:       -       72       17 CUSTOM(name)
+# CHECK-NEXT:       -       72       2b CUSTOM(name)
 
 # RUN: not wasm-ld %t1.o -o /dev/null -Map=/ 2>&1 \
 # RUN:  | FileCheck -check-prefix=FAIL %s
 # FAIL: wasm-ld: error: cannot open map file /

lld/test/wasm/signature-mismatch-export.ll

 ; CHECK-NEXT:     Name:            name
 ; CHECK-NEXT:     FunctionNames:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            'signature_mismatch:ret32'
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Name:            _start
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Name:            ret32
+; CHECK-NEXT:     GlobalNames:
+; CHECK-NEXT:       - Index:           0
+; CHECK-NEXT:         Name:            __stack_pointer
 ; CHECK-NEXT: ...

lld/test/wasm/signature-mismatch.ll

 ; YAML-NEXT:       - Index:           0
 ; YAML-NEXT:         Name:            'signature_mismatch:ret32'
 ; YAML-NEXT:       - Index:           1
 ; YAML-NEXT:         Name:            _start
 ; YAML-NEXT:       - Index:           2
 ; YAML-NEXT:         Name:            ret32
 ; YAML-NEXT:       - Index:           3
 ; YAML-NEXT:         Name:            call_ret32
+; YAML-NEXT:     GlobalNames:
+; YAML-NEXT:       - Index:           0
+; YAML-NEXT:         Name:            __stack_pointer
 ; YAML-NEXT: ...
 
 ;      RELOC:     Name:            linking
 ; RELOC-NEXT:     Version:         2
 ; RELOC-NEXT:     SymbolTable:
 ; RELOC-NEXT:       - Index:           0
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            _start

lld/test/wasm/stack-pointer.ll

 ; CHECK-NEXT:         Name:            __stack_pointer
 ; CHECK-NEXT:         Flags:           [ UNDEFINED ]
 ; CHECK-NEXT:         Global:          0
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            name
 ; CHECK-NEXT:     FunctionNames:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            _start
+; CHECK-NEXT:     GlobalNames:
+; CHECK-NEXT:       - Index:           0
+; CHECK-NEXT:         Name:            __stack_pointer
 ; CHECK-NEXT: ...

lld/test/wasm/target-feature-disallowed.yaml

Features:
       - Prefix:        DISALLOWED
         Name:          "foo"
         # included so output has target features section
       - Prefix:        USED
         Name:          "bar"
 ...
 
 # SPECIFIED:        - Type:            CUSTOM
-# SPECIFIED-NEXT:     Name:            target_features
+# SPECIFIED:          Name:            target_features
 # SPECIFIED-NEXT:     Features:
 # SPECIFIED-NEXT:       - Prefix:          USED
 # SPECIFIED-NEXT:         Name:            bar
 # SPECIFIED-NEXT:       - Prefix:          USED
 # SPECIFIED-NEXT:         Name:            baz
 # SPECIFIED-NEXT:       - Prefix:          USED
 # SPECIFIED-NEXT:         Name:            foo
 # SPECIFIED-NEXT: ...
 
 # UNSPECIFIED:        - Type:            CUSTOM
-# UNSPECIFIED-NEXT:     Name:            target_features
+# UNSPECIFIED:          Name:            target_features
 # UNSPECIFIED-NEXT:     Features:
 # UNSPECIFIED-NEXT:       - Prefix:          USED
 # UNSPECIFIED-NEXT:         Name:            bar
 # UNSPECIFIED-NEXT:       - Prefix:          USED
 # UNSPECIFIED-NEXT:         Name:            baz
 # UNSPECIFIED-NEXT:       - Prefix:          USED
 # UNSPECIFIED-NEXT:         Name:            quux
 # UNSPECIFIED-NEXT: ...
 
 # DISALLOWED:        - Type:            CUSTOM
-# DISALLOWED-NEXT:     Name:            target_features
+# DISALLOWED:          Name:            target_features
 # DISALLOWED-NEXT:     Features:
 # DISALLOWED-NEXT:       - Prefix:          USED
 # DISALLOWED-NEXT:         Name:            bar
 # DISALLOWED-NEXT: ...
 
 # NONE:        - Type:            CUSTOM
-# NONE-NEXT:     Name:            target_features
+# NONE:          Name:            target_features
 # NONE-NEXT:     Features:
 # NONE-NEXT:       - Prefix:          USED
 # NONE-NEXT:         Name:            bar
 # NONE-NEXT: ...

lld/test/wasm/target-feature-none.yaml

- Type:            CUSTOM
     Name:            target_features
     Features:        [ ]
 ...
 
 # section is not emitted if it would be empty
 # EMPTY-NOT: target_features
 
 # SPECIFIED:        - Type:            CUSTOM
-# SPECIFIED-NEXT:     Name:            target_features
+# SPECIFIED:          Name:            target_features
 # SPECIFIED-NEXT:     Features:
 # SPECIFIED-NEXT:       - Prefix:          USED
 # SPECIFIED-NEXT:         Name:            bar
 # SPECIFIED-NEXT:       - Prefix:          USED
 # SPECIFIED-NEXT:         Name:            baz
 # SPECIFIED-NEXT:       - Prefix:          USED
 # SPECIFIED-NEXT:         Name:            foo
 # SPECIFIED-NEXT: ...

lld/test/wasm/target-feature-required.yaml

Sections:
   - Type:            CUSTOM
     Name:            target_features
     Features:
       - Prefix:        REQUIRED
         Name:          "foo"
 ...
 
 # SPECIFIED:        - Type:            CUSTOM
-# SPECIFIED-NEXT:     Name:            target_features
+# SPECIFIED:          Name:            target_features
 # SPECIFIED-NEXT:     Features:
 # SPECIFIED-NEXT:       - Prefix:          USED
 # SPECIFIED-NEXT:         Name:            bar
 # SPECIFIED-NEXT:       - Prefix:          USED
 # SPECIFIED-NEXT:         Name:            baz
 # SPECIFIED-NEXT:       - Prefix:          USED
 # SPECIFIED-NEXT:         Name:            foo
 # SPECIFIED-NEXT: ...
 
 # UNSPECIFIED: Target feature 'foo' used by {{.*}}target-feature-required.yaml.tmp1.o is not allowed.{{$}}
 
 # UNSPECIFIED-NOCHECK:        - Type:            CUSTOM
-# UNSPECIFIED-NOCHECK-NEXT:     Name:            target_features
+# UNSPECIFIED-NOCHECK:          Name:            target_features
 # UNSPECIFIED-NOCHECK-NEXT:     Features:
 # UNSPECIFIED-NOCHECK-NEXT:       - Prefix:          USED
 # UNSPECIFIED-NOCHECK-NEXT:         Name:            bar
 # UNSPECIFIED-NOCHECK-NEXT:       - Prefix:          USED
 # UNSPECIFIED-NOCHECK-NEXT:         Name:            baz
 # UNSPECIFIED-NOCHECK-NEXT:       - Prefix:          USED
 # UNSPECIFIED-NOCHECK-NEXT:         Name:            quux
 # UNSPECIFIED-NOCHECK-NEXT: ...
 
 # REQUIRED:        - Type:            CUSTOM
-# REQUIRED-NEXT:     Name:            target_features
+# REQUIRED:          Name:            target_features
 # REQUIRED-NEXT:     Features:
 # REQUIRED-NEXT:       - Prefix:          USED
 # REQUIRED-NEXT:         Name:            foo
 # REQUIRED-NEXT: ...
 
 # DISALLOWED: Target feature 'foo' used in {{.*}}target-feature-required.yaml.tmp1.o is disallowed by {{.*}}target-feature-required.yaml.tmp.disallowed.o. Use --no-check-features to suppress.{{$}}
 
 # DISALLOWED-NOCHECK:        - Type:            CUSTOM
-# DISALLOWED-NOCHECK-NEXT:     Name:            target_features
+# DISALLOWED-NOCHECK:          Name:            target_features
 # DISALLOWED-NOCHECK-NEXT:     Features:
 # DISALLOWED-NOCHECK-NEXT:       - Prefix:          USED
 # DISALLOWED-NOCHECK-NEXT:         Name:            foo
 # DISALLOWED-NOCHECK-NEXT: ...
 
 # NONE: Missing target feature 'foo' in {{.*}}target-feature-required.yaml.tmp.none.o, required by {{.*}}target-feature-required.yaml.tmp1.o. Use --no-check-features to suppress.{{$}}
 
 # NONE-NOCHECK:        - Type:            CUSTOM
-# NONE-NOCHECK-NEXT:     Name:            target_features
+# NONE-NOCHECK:          Name:            target_features
 # NONE-NOCHECK-NEXT:     Features:
 # NONE-NOCHECK-NEXT:       - Prefix:          USED
 # NONE-NOCHECK-NEXT:         Name:            foo
 # NONE-NOCHECK-NEXT: ...

lld/test/wasm/target-feature-used.yaml

Sections:
   - Type:            CUSTOM
     Name:            target_features
     Features:
       - Prefix:        USED
         Name:          "foo"
 ...
 
 # SPECIFIED:        - Type:            CUSTOM
-# SPECIFIED-NEXT:     Name:            target_features
+# SPECIFIED:          Name:            target_features
 # SPECIFIED-NEXT:     Features:
 # SPECIFIED-NEXT:       - Prefix:          USED
 # SPECIFIED-NEXT:         Name:            bar
 # SPECIFIED-NEXT:       - Prefix:          USED
 # SPECIFIED-NEXT:         Name:            baz
 # SPECIFIED-NEXT:       - Prefix:          USED
 # SPECIFIED-NEXT:         Name:            foo
 # SPECIFIED-NEXT: ...
 
 # UNSPECIFIED: Target feature 'foo' used by {{.*}}target-feature-used.yaml.tmp1.o is not allowed.{{$}}
 
 # UNSPECIFIED-NOCHECK:        - Type:            CUSTOM
-# UNSPECIFIED-NOCHECK-NEXT:     Name:            target_features
+# UNSPECIFIED-NOCHECK:          Name:            target_features
 # UNSPECIFIED-NOCHECK-NEXT:     Features:
 # UNSPECIFIED-NOCHECK-NEXT:       - Prefix:          USED
 # UNSPECIFIED-NOCHECK-NEXT:         Name:            bar
 # UNSPECIFIED-NOCHECK-NEXT:       - Prefix:          USED
 # UNSPECIFIED-NOCHECK-NEXT:         Name:            baz
 # UNSPECIFIED-NOCHECK-NEXT:       - Prefix:          USED
 # UNSPECIFIED-NOCHECK-NEXT:         Name:            quux
 # UNSPECIFIED-NOCHECK-NEXT: ...
 
 # USED:        - Type:            CUSTOM
-# USED-NEXT:     Name:            target_features
+# USED:          Name:            target_features
 # USED-NEXT:     Features:
 # USED-NEXT:       - Prefix:          USED
 # USED-NEXT:         Name:            foo
 # USED-NEXT: ...
 
 # REQUIRED:        - Type:            CUSTOM
-# REQUIRED-NEXT:     Name:            target_features
+# REQUIRED:          Name:            target_features
 # REQUIRED-NEXT:     Features:
 # REQUIRED-NEXT:       - Prefix:          USED
 # REQUIRED-NEXT:         Name:            foo
 # REQUIRED-NEXT: ...
 
 # DISALLOWED: Target feature 'foo' used in {{.*}}target-feature-used.yaml.tmp1.o is disallowed by {{.*}}target-feature-used.yaml.tmp.disallowed.o. Use --no-check-features to suppress.{{$}}
 
 # DISALLOWED-NOCHECK:        - Type:            CUSTOM
-# DISALLOWED-NOCHECK-NEXT:     Name:            target_features
+# DISALLOWED-NOCHECK:          Name:            target_features
 # DISALLOWED-NOCHECK-NEXT:     Features:
 # DISALLOWED-NOCHECK-NEXT:       - Prefix:          USED
 # DISALLOWED-NOCHECK-NEXT:         Name:            foo
 # DISALLOWED-NOCHECK-NEXT: ...
 
 # NONE:        - Type:            CUSTOM
-# NONE-NEXT:     Name:            target_features
+# NONE:          Name:            target_features
 # NONE-NEXT:     Features:
 # NONE-NEXT:       - Prefix:          USED
 # NONE-NEXT:         Name:            foo
 # NONE-NEXT: ...

lld/test/wasm/undefined-weak-call.ll

 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            'undefined_weak:weakFunc1'
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Name:            'undefined_weak:weakFunc2'
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Name:            'undefined_weak:weakFunc3'
 ; CHECK-NEXT:       - Index:           3
 ; CHECK-NEXT:         Name:            callWeakFuncs
+; CHECK-NEXT:     GlobalNames:
+; CHECK-NEXT:       - Index:           0
+; CHECK-NEXT:         Name:            __stack_pointer
 ; CHECK-NEXT: ...

lld/test/wasm/weak-alias-overide.ll

 ; CHECK-NEXT:       - Index:           3
 ; CHECK-NEXT:         Name:            call_direct
 ; CHECK-NEXT:       - Index:           4
 ; CHECK-NEXT:         Name:            call_alias
 ; CHECK-NEXT:       - Index:           5
 ; CHECK-NEXT:         Name:            call_alias_ptr
 ; CHECK-NEXT:       - Index:           6
 ; CHECK-NEXT:         Name:            call_direct_ptr
+; CHECK-NEXT:     GlobalNames:
+; CHECK-NEXT:       - Index:           0
+; CHECK-NEXT:         Name:            __stack_pointer
 ; CHECK-NEXT: ...

lld/test/wasm/weak-alias.ll

 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Name:            call_direct
 ; CHECK-NEXT:       - Index:           3
 ; CHECK-NEXT:         Name:            call_alias
 ; CHECK-NEXT:       - Index:           4
 ; CHECK-NEXT:         Name:            call_alias_ptr
 ; CHECK-NEXT:       - Index:           5
 ; CHECK-NEXT:         Name:            call_direct_ptr
+; CHECK-NEXT:     GlobalNames:
+; CHECK-NEXT:       - Index:           0
+; CHECK-NEXT:         Name:            __stack_pointer
 ; CHECK-NEXT: ...
 
 ; RUN: wasm-ld --relocatable %t.o %t2.o -o %t.reloc.o
 ; RUN: obj2yaml %t.reloc.o | FileCheck %s -check-prefix=RELOC
 
 ; RELOC:      --- !WASM
 ; RELOC-NEXT: FileHeader:
 ; RELOC-NEXT:   Version:         0x1

 ; RELOC-NEXT:       - Index:           2
 ; RELOC-NEXT:         Name:            call_direct
 ; RELOC-NEXT:       - Index:           3
 ; RELOC-NEXT:         Name:            call_alias
 ; RELOC-NEXT:       - Index:           4
 ; RELOC-NEXT:         Name:            call_alias_ptr
 ; RELOC-NEXT:       - Index:           5
 ; RELOC-NEXT:         Name:            call_direct_ptr
+; RELOC-NEXT:     GlobalNames:
+; RELOC-NEXT:       - Index:           0
+; RELOC-NEXT:         Name:            __stack_pointer
 ; RELOC-NEXT: ...

lld/test/wasm/weak-symbols.ll

 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            _start
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Name:            weakFn
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Name:            exportWeak1
 ; CHECK-NEXT:       - Index:           3
 ; CHECK-NEXT:         Name:            exportWeak2
+; CHECK-NEXT:     GlobalNames:
+; CHECK-NEXT:       - Index:           0
+; CHECK-NEXT:         Name:            __stack_pointer
 ; CHECK-NEXT: ...

lld/wasm/SyntheticSections.h

uint32_t getNumImportedFunctions() const {
     return numImportedFunctions;
   }
   uint32_t getNumImportedEvents() const {
     assert(isSealed);
     return numImportedEvents;
   }
 
   std::vector<const Symbol *> importedSymbols;
+  std::vector<const Symbol *> gotSymbols;
 
 protected:
   bool isSealed = false;
   unsigned numImportedGlobals = 0;
   unsigned numImportedFunctions = 0;
   unsigned numImportedEvents = 0;
-  std::vector<const Symbol *> gotSymbols;
 };
 
 class FunctionSection : public SyntheticSection {
 public:
   FunctionSection() : SyntheticSection(llvm::wasm::WASM_SEC_FUNCTION) {}
 
   bool isNeeded() const override { return inputFunctions.size() > 0; };
   void writeBody() override;
public:
   //
   // TODO(sbc): Another approach to optimizing these away could be to use
   // specific relocation types combined with linker relaxation which could
   // transform a `global.get` to an `i32.const`.
   void addInternalGOTEntry(Symbol *sym);
   void generateRelocationCode(raw_ostream &os) const;
 
   std::vector<const DefinedData *> dataAddressGlobals;
+  std::vector<InputGlobal *> inputGlobals;
+  std::vector<Symbol *> internalGotSymbols;
 
 protected:
   bool isSealed = false;
-  std::vector<InputGlobal *> inputGlobals;
-  std::vector<Symbol *> internalGotSymbols;
 };
 
 class ExportSection : public SyntheticSection {
 public:
   ExportSection() : SyntheticSection(llvm::wasm::WASM_SEC_EXPORT) {}
   bool isNeeded() const override { return exports.size() > 0; }
   void writeBody() override;
 

 // Create the custom "name" section containing debug symbol names.
 class NameSection : public SyntheticSection {
 public:
   NameSection() : SyntheticSection(llvm::wasm::WASM_SEC_CUSTOM, "name") {}
   bool isNeeded() const override {
     return !config->stripDebug && !config->stripAll && numNames() > 0;
   }
   void writeBody() override;
-  unsigned numNames() const;
+  unsigned numNames() const { return numNamedGlobals() + numNamedFunctions(); }
+  unsigned numNamedGlobals() const;
+  unsigned numNamedFunctions() const;
 };
 
 class ProducersSection : public SyntheticSection {
 public:
   ProducersSection()
       : SyntheticSection(llvm::wasm::WASM_SEC_CUSTOM, "producers") {}
   bool isNeeded() const override {
     return !config->stripAll && fieldCount() > 0;

lld/wasm/SyntheticSections.cpp

#endif
   }
 }
 
 void LinkingSection::addToSymtab(Symbol *sym) {
   sym->setOutputSymbolIndex(symtabEntries.size());
   symtabEntries.emplace_back(sym);
 }
 
-unsigned NameSection::numNames() const {
+unsigned NameSection::numNamedFunctions() const {
   unsigned numNames = out.importSec->getNumImportedFunctions();
+
   for (const InputFunction *f : out.functionSec->inputFunctions)
     if (!f->getName().empty() || !f->getDebugName().empty())
       ++numNames;
 
   return numNames;
 }
 
+unsigned NameSection::numNamedGlobals() const {
+  unsigned numNames = out.importSec->getNumImportedGlobals();
+
+  for (const InputGlobal *g : out.globalSec->inputGlobals)
+    if (!g->getName().empty())
+      ++numNames;
+
+  numNames += out.globalSec->internalGotSymbols.size();
+  return numNames;
+}
+
 // Create the custom "name" section containing debug symbol names.
 void NameSection::writeBody() {
+  unsigned count = numNamedFunctions();
+  if (count) {
     SubSection sub(WASM_NAMES_FUNCTION);
-  writeUleb128(sub.os, numNames(), "name count");
+    writeUleb128(sub.os, count, "name count");
 
-  // Names must appear in function index order.  As it happens importedSymbols
-  // and inputFunctions are numbered in order with imported functions coming
-  // first.
+    // Function names appear in function index order.  As it happens
+    // importedSymbols and inputFunctions are numbered in order with imported
+    // functions coming first.
     for (const Symbol *s : out.importSec->importedSymbols) {
       if (auto *f = dyn_cast<FunctionSymbol>(s)) {
         writeUleb128(sub.os, f->getFunctionIndex(), "func index");
         writeStr(sub.os, toString(*s), "symbol name");
       }
     }
     for (const InputFunction *f : out.functionSec->inputFunctions) {
       if (!f->getName().empty()) {
         writeUleb128(sub.os, f->getFunctionIndex(), "func index");
         if (!f->getDebugName().empty()) {
           writeStr(sub.os, f->getDebugName(), "symbol name");
         } else {
           writeStr(sub.os, maybeDemangleSymbol(f->getName()), "symbol name");
         }
       }
     }
+    sub.writeTo(bodyOutputStream);
+  }
+
+  count = numNamedGlobals();
+  if (count) {
+    SubSection sub(WASM_NAMES_GLOBAL);
+    writeUleb128(sub.os, count, "name count");
+
+    for (const Symbol *s : out.importSec->importedSymbols) {
+      if (auto *g = dyn_cast<GlobalSymbol>(s)) {
+        writeUleb128(sub.os, g->getGlobalIndex(), "global index");
+        writeStr(sub.os, toString(*s), "symbol name");
+      }
+    }
+    for (const Symbol *s : out.importSec->gotSymbols) {
+      writeUleb128(sub.os, s->getGOTIndex(), "global index");
+      writeStr(sub.os, toString(*s), "symbol name");
+    }
+    for (const InputGlobal *g : out.globalSec->inputGlobals) {
+      if (!g->getName().empty()) {
+        writeUleb128(sub.os, g->getGlobalIndex(), "global index");
+        writeStr(sub.os, maybeDemangleSymbol(g->getName()), "symbol name");
+      }
+    }
+    for (Symbol *s : out.globalSec->internalGotSymbols) {
+      writeUleb128(sub.os, s->getGOTIndex(), "global index");
+      writeStr(sub.os, toString(*s), "symbol name");
+    }
 
     sub.writeTo(bodyOutputStream);
   }
+}
 
 void ProducersSection::addInfo(const WasmProducerInfo &info) {
   for (auto &producers :
        {std::make_pair(&info.Languages, &languages),
         std::make_pair(&info.Tools, &tools), std::make_pair(&info.SDKs, &sDKs)})
     for (auto &producer : *producers.first)
       if (producers.second->end() ==
           llvm::find_if(*producers.second,

llvm/include/llvm/BinaryFormat/Wasm.h

union {
     // For function or global symbols, the index in function or global index
     // space.
     uint32_t ElementIndex;
     // For a data symbols, the address of the data relative to segment.
     WasmDataReference DataRef;
   };
 };
 
-struct WasmFunctionName {
+enum class NameType {
+  FUNCTION,
+  GLOBAL
+};
+
+struct WasmDebugName {
+  NameType Type;
   uint32_t Index;
   StringRef Name;
 };
 
 struct WasmLinkingData {
   uint32_t Version;
   std::vector<WasmInitFunc> InitFunctions;
   std::vector<StringRef> Comdats;
enum : uint8_t {
   WASM_FEATURE_PREFIX_REQUIRED = '=',
   WASM_FEATURE_PREFIX_DISALLOWED = '-',
 };
 
 // Kind codes used in the custom "name" section
 enum : unsigned {
   WASM_NAMES_FUNCTION = 0x1,
   WASM_NAMES_LOCAL = 0x2,
+  WASM_NAMES_GLOBAL = 0x7,
 };
 
 // Kind codes used in the custom "linking" section
 enum : unsigned {
   WASM_SEGMENT_INFO = 0x5,
   WASM_INIT_FUNCS = 0x6,
   WASM_COMDAT_INFO = 0x7,
   WASM_SYMBOL_TABLE = 0x8,

llvm/include/llvm/Object/Wasm.h

public:
   ArrayRef<wasm::WasmEvent> events() const { return Events; }
   ArrayRef<wasm::WasmExport> exports() const { return Exports; }
   ArrayRef<WasmSymbol> syms() const { return Symbols; }
   const wasm::WasmLinkingData &linkingData() const { return LinkingData; }
   uint32_t getNumberOfSymbols() const { return Symbols.size(); }
   ArrayRef<wasm::WasmElemSegment> elements() const { return ElemSegments; }
   ArrayRef<WasmSegment> dataSegments() const { return DataSegments; }
   ArrayRef<wasm::WasmFunction> functions() const { return Functions; }
-  ArrayRef<wasm::WasmFunctionName> debugNames() const { return DebugNames; }
+  ArrayRef<wasm::WasmDebugName> debugNames() const { return DebugNames; }
   uint32_t startFunction() const { return StartFunction; }
   uint32_t getNumImportedGlobals() const { return NumImportedGlobals; }
   uint32_t getNumImportedTables() const { return NumImportedTables; }
   uint32_t getNumImportedFunctions() const { return NumImportedFunctions; }
   uint32_t getNumImportedEvents() const { return NumImportedEvents; }
   uint32_t getNumSections() const { return Sections.size(); }
   void moveSymbolNext(DataRefImpl &Symb) const override;
 
private:
   std::vector<wasm::WasmEvent> Events;
   std::vector<wasm::WasmImport> Imports;
   std::vector<wasm::WasmExport> Exports;
   std::vector<wasm::WasmElemSegment> ElemSegments;
   std::vector<WasmSegment> DataSegments;
   llvm::Optional<size_t> DataCount;
   std::vector<wasm::WasmFunction> Functions;
   std::vector<WasmSymbol> Symbols;
-  std::vector<wasm::WasmFunctionName> DebugNames;
+  std::vector<wasm::WasmDebugName> DebugNames;
   uint32_t StartFunction = -1;
   bool HasLinkingSection = false;
   bool HasDylinkSection = false;
   bool SeenCodeSection = false;
   bool HasMemory64 = false;
   wasm::WasmLinkingData LinkingData;
   uint32_t NumImportedGlobals = 0;
   uint32_t NumImportedTables = 0;

llvm/include/llvm/ObjectYAML/WasmYAML.h

struct NameSection : CustomSection {
   NameSection() : CustomSection("name") {}
 
   static bool classof(const Section *S) {
     auto C = dyn_cast<CustomSection>(S);
     return C && C->Name == "name";
   }
 
   std::vector<NameEntry> FunctionNames;
+  std::vector<NameEntry> GlobalNames;
 };
 
 struct LinkingSection : CustomSection {
   LinkingSection() : CustomSection("linking") {}
 
   static bool classof(const Section *S) {
     auto C = dyn_cast<CustomSection>(S);
     return C && C->Name == "linking";

llvm/lib/Object/WasmObjectFile.cpp

Error WasmObjectFile::parseDylinkSection(ReadContext &Ctx) {
   }
   if (Ctx.Ptr != Ctx.End)
     return make_error<GenericBinaryError>("dylink section ended prematurely",
                                           object_error::parse_failed);
   return Error::success();
 }
 
 Error WasmObjectFile::parseNameSection(ReadContext &Ctx) {
-  llvm::DenseSet<uint64_t> Seen;
+  llvm::DenseSet<uint64_t> SeenFunctions;
+  llvm::DenseSet<uint64_t> SeenGlobals;
   if (FunctionTypes.size() && !SeenCodeSection) {
     return make_error<GenericBinaryError>("Names must come after code section",
                                           object_error::parse_failed);
   }
 
   while (Ctx.Ptr < Ctx.End) {
     uint8_t Type = readUint8(Ctx);
     uint32_t Size = readVaruint32(Ctx);
     const uint8_t *SubSectionEnd = Ctx.Ptr + Size;
     switch (Type) {
-    case wasm::WASM_NAMES_FUNCTION: {
+    case wasm::WASM_NAMES_FUNCTION:
+    case wasm::WASM_NAMES_GLOBAL: {
       uint32_t Count = readVaruint32(Ctx);
       while (Count--) {
         uint32_t Index = readVaruint32(Ctx);
-        if (!Seen.insert(Index).second)
-          return make_error<GenericBinaryError>("Function named more than once",
-                                                object_error::parse_failed);
         StringRef Name = readString(Ctx);
+        if (Type == wasm::WASM_NAMES_FUNCTION) {
+          if (!SeenFunctions.insert(Index).second)
+            return make_error<GenericBinaryError>(
+                "Function named more than once", object_error::parse_failed);
           if (!isValidFunctionIndex(Index) || Name.empty())
             return make_error<GenericBinaryError>("Invalid name entry",
                                                   object_error::parse_failed);
-        DebugNames.push_back(wasm::WasmFunctionName{Index, Name});
+
           if (isDefinedFunctionIndex(Index))
             getDefinedFunction(Index).DebugName = Name;
+        } else {
+          if (!SeenGlobals.insert(Index).second)
+            return make_error<GenericBinaryError>("Global named more than once",
+                                                  object_error::parse_failed);
+          if (!isValidGlobalIndex(Index) || Name.empty())
+            return make_error<GenericBinaryError>("Invalid name entry",
+                                                  object_error::parse_failed);
+        }
+        wasm::NameType T = Type == wasm::WASM_NAMES_FUNCTION
+                               ? wasm::NameType::FUNCTION
+                               : wasm::NameType::GLOBAL;
+        DebugNames.push_back(wasm::WasmDebugName{T, Index, Name});
       }
       break;
     }
     // Ignore local names for now
     case wasm::WASM_NAMES_LOCAL:
     default:
       Ctx.Ptr += Size;
       break;

llvm/lib/ObjectYAML/WasmEmitter.cpp

if (Section.FunctionNames.size()) {
     encodeULEB128(Section.FunctionNames.size(), SubSection.getStream());
     for (const WasmYAML::NameEntry &NameEntry : Section.FunctionNames) {
       encodeULEB128(NameEntry.Index, SubSection.getStream());
       writeStringRef(NameEntry.Name, SubSection.getStream());
     }
 
     SubSection.done();
   }
+  if (Section.GlobalNames.size()) {
+    writeUint8(OS, wasm::WASM_NAMES_GLOBAL);
+
+    SubSectionWriter SubSection(OS);
+
+    encodeULEB128(Section.GlobalNames.size(), SubSection.getStream());
+    for (const WasmYAML::NameEntry &NameEntry : Section.GlobalNames) {
+      encodeULEB128(NameEntry.Index, SubSection.getStream());
+      writeStringRef(NameEntry.Name, SubSection.getStream());
+    }
+
+    SubSection.done();
+  }
 }
 
 void WasmWriter::writeSectionContent(raw_ostream &OS,
                                      WasmYAML::ProducersSection &Section) {
   writeStringRef(Section.Name, OS);
   int Fields = int(!Section.Languages.empty()) + int(!Section.Tools.empty()) +
                int(!Section.SDKs.empty());
   if (Fields == 0)

llvm/lib/ObjectYAML/WasmYAML.cpp

static void sectionMapping(IO &IO, WasmYAML::DylinkSection &Section) {
   IO.mapRequired("TableAlignment", Section.TableAlignment);
   IO.mapRequired("Needed", Section.Needed);
 }
 
 static void sectionMapping(IO &IO, WasmYAML::NameSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapRequired("Name", Section.Name);
   IO.mapOptional("FunctionNames", Section.FunctionNames);
+  IO.mapOptional("GlobalNames", Section.GlobalNames);
 }
 
 static void sectionMapping(IO &IO, WasmYAML::LinkingSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapRequired("Name", Section.Name);
   IO.mapRequired("Version", Section.Version);
   IO.mapOptional("SymbolTable", Section.SymbolTable);
   IO.mapOptional("SegmentInfo", Section.SegmentInfos);

llvm/tools/obj2yaml/wasm2yaml.cpp

if (WasmSec.Name == "dylink") {
     DylinkSec->MemoryAlignment = Info.MemoryAlignment;
     DylinkSec->TableSize = Info.TableSize;
     DylinkSec->TableAlignment = Info.TableAlignment;
     DylinkSec->Needed = Info.Needed;
     CustomSec = std::move(DylinkSec);
   } else if (WasmSec.Name == "name") {
     std::unique_ptr<WasmYAML::NameSection> NameSec =
         std::make_unique<WasmYAML::NameSection>();
-    for (const llvm::wasm::WasmFunctionName &Func : Obj.debugNames()) {
+    for (const llvm::wasm::WasmDebugName &Name : Obj.debugNames()) {
       WasmYAML::NameEntry NameEntry;
-      NameEntry.Name = Func.Name;
-      NameEntry.Index = Func.Index;
+      NameEntry.Name = Name.Name;
+      NameEntry.Index = Name.Index;
+      if (Name.Type == llvm::wasm::NameType::FUNCTION) {
         NameSec->FunctionNames.push_back(NameEntry);
+      } else {
+        assert(Name.Type == llvm::wasm::NameType::GLOBAL);
+        NameSec->GlobalNames.push_back(NameEntry);
+      }
     }
     CustomSec = std::move(NameSec);
   } else if (WasmSec.Name == "linking") {
     std::unique_ptr<WasmYAML::LinkingSection> LinkingSec =
         std::make_unique<WasmYAML::LinkingSection>();
     LinkingSec->Version = Obj.linkingData().Version;
 
     ArrayRef<StringRef> Comdats = Obj.linkingData().Comdats;