[WebAssembly] MC: Fix for address taken aliases

[sbc100]

Summary

Previously, taking the address for an alias would
result in:
"Symbol not found in table index space"

Increase test coverage for weak aliases.

This code should be more efficient too as it avoids building the
IsAddressTaken set.

[ncw]

Looks like it should work. One thing I wonder about is the size of the table? It looks like we're now writing out a table entry for each relocation, which is (a tiny amount of) bloat and makes function pointers not compare equal (which is irrelevant for the object file which can't run anyway). It was neater before to be writing out the table entry only once per symbol.

In https://bugs.llvm.org/show_bug.cgi?id=35625, I'd suggested augmenting the alias-loop (it could actually be pulled out into a helper function rather than copy-and-pasted, oops). Then at least you'd only have one table entry per-symbol, even if the "ideal" would be one table entry per function.

[sbc100]

• don't duplicate table entries

[sbc100]

In D41510#962735, @ncw wrote:

Looks like it should work. One thing I wonder about is the size of the table? It looks like we're now writing out a table entry for each relocation, which is (a tiny amount of) bloat and makes function pointers not compare equal (which is irrelevant for the object file which can't run anyway). It was neater before to be writing out the table entry only once per symbol.

In https://bugs.llvm.org/show_bug.cgi?id=35625, I'd suggested augmenting the alias-loop (it could actually be pulled out into a helper function rather than copy-and-pasted, oops). Then at least you'd only have one table entry per-symbol, even if the "ideal" would be one table entry per function.

Oops, you are totally right. I forgot to add the extra check.

[sbc100]

In D41510#962735, @ncw wrote:

Looks like it should work. One thing I wonder about is the size of the table? It looks like we're now writing out a table entry for each relocation, which is (a tiny amount of) bloat and makes function pointers not compare equal (which is irrelevant for the object file which can't run anyway). It was neater before to be writing out the table entry only once per symbol.

In https://bugs.llvm.org/show_bug.cgi?id=35625, I'd suggested augmenting the alias-loop (it could actually be pulled out into a helper function rather than copy-and-pasted, oops). Then at least you'd only have one table entry per-symbol, even if the "ideal" would be one table entry per function.

It makes sense to me to build the indirect table via single pass through the relocations since that tells us precisely which functions have had their address taken.

[ncw]

Thanks, you're right that's nicer. I'll leave the bugzilla issue open for now until the Linking.md issue is closed as well.

(The lambda could become a proper member function, just to keep the length down on these huge functions that need splitting.)

[ncw]

llvm/trunk/lib/MC/WasmObjectWriter.cpp

1285

Having just approved this, I'm wondering why we have to handle the MEMORY_ADDR relocations? OK, so I can see that IsAddressTaken used to handle them - but was for address-taken globals? Since we're now inside as isFunction() block, I'd have thought that only TABLE_INDEX relocations can target the symbol.

[sbc100]

llvm/trunk/lib/MC/WasmObjectWriter.cpp

1285

I think are you right. IsAddressTaken was built to include globals and functions but only ever used for functions, so these cases can be removed I think.

[ncw]

llvm/trunk/lib/MC/WasmObjectWriter.cpp

1285

For the record: the unused switch cases were (will be) removed in D42095

llvm/trunk/lib/MC/WasmObjectWriter.cpp

 }
 
 uint32_t WasmObjectWriter::getRelocationIndexValue(
     const WasmRelocationEntry &RelEntry) {
   switch (RelEntry.Type) {
   case wasm::R_WEBASSEMBLY_TABLE_INDEX_SLEB:
   case wasm::R_WEBASSEMBLY_TABLE_INDEX_I32:
     if (!IndirectSymbolIndices.count(RelEntry.Symbol))
-      report_fatal_error("symbol not found table index space: " +
+      report_fatal_error("symbol not found in table index space: " +
                          RelEntry.Symbol->getName());
     return IndirectSymbolIndices[RelEntry.Symbol];
   case wasm::R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
   case wasm::R_WEBASSEMBLY_GLOBAL_INDEX_LEB:
   case wasm::R_WEBASSEMBLY_MEMORY_ADDR_LEB:
   case wasm::R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
   case wasm::R_WEBASSEMBLY_MEMORY_ADDR_I32:
     if (!SymbolIndices.count(RelEntry.Symbol))
-      report_fatal_error("symbol not found function/global index space: " +
+      report_fatal_error("symbol not found in function/global index space: " +
                          RelEntry.Symbol->getName());
     return SymbolIndices[RelEntry.Symbol];
   case wasm::R_WEBASSEMBLY_TYPE_INDEX_LEB:
     if (!TypeIndices.count(RelEntry.Symbol))
       report_fatal_error("symbol not found in type index space: " +
                          RelEntry.Symbol->getName());
     return TypeIndices[RelEntry.Symbol];
   default:
void WasmObjectWriter::writeObject(MCAssembler &Asm,
 
   // Collect information from the available symbols.
   SmallVector<WasmFunction, 4> Functions;
   SmallVector<uint32_t, 4> TableElems;
   SmallVector<WasmImport, 4> Imports;
   SmallVector<WasmExport, 4> Exports;
   SmallVector<std::pair<StringRef, uint32_t>, 4> SymbolFlags;
   SmallVector<std::pair<uint16_t, uint32_t>, 2> InitFuncs;
-  SmallPtrSet<const MCSymbolWasm *, 4> IsAddressTaken;
   unsigned NumFuncImports = 0;
   SmallVector<WasmDataSegment, 4> DataSegments;
   uint32_t DataSize = 0;
 
-  // Populate the IsAddressTaken set.
-  for (const WasmRelocationEntry &RelEntry : CodeRelocations) {
-    switch (RelEntry.Type) {
-    case wasm::R_WEBASSEMBLY_TABLE_INDEX_SLEB:
-    case wasm::R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
-      IsAddressTaken.insert(RelEntry.Symbol);
-      break;
-    default:
-      break;
-    }
-  }
-  for (const WasmRelocationEntry &RelEntry : DataRelocations) {
-    switch (RelEntry.Type) {
-    case wasm::R_WEBASSEMBLY_TABLE_INDEX_I32:
-    case wasm::R_WEBASSEMBLY_MEMORY_ADDR_I32:
-      IsAddressTaken.insert(RelEntry.Symbol);
-      break;
-    default:
-      break;
-    }
-  }
-
   // In the special .global_variables section, we've encoded global
   // variables used by the function. Translate them into the Globals
   // list.
   MCSectionWasm *GlobalVars =
       Ctx.getWasmSection(".global_variables", SectionKind::getMetadata());
   if (!GlobalVars->getFragmentList().empty()) {
     if (GlobalVars->getFragmentList().size() != 1)
       report_fatal_error("only one .global_variables fragment supported");
if (WS.isFunction()) {
         SymbolIndices[&WS] = Index;
         Functions.push_back(Func);
       } else {
         // An import; the index was assigned above.
         Index = SymbolIndices.find(&WS)->second;
       }
 
       DEBUG(dbgs() << "  -> function index: " << Index << "\n");
-
-      // If needed, prepare the function to be called indirectly.
-      if (IsAddressTaken.count(&WS) != 0) {
-        IndirectSymbolIndices[&WS] = TableElems.size();
-        DEBUG(dbgs() << "  -> adding to table: " << TableElems.size() << "\n");
-        TableElems.push_back(Index);
-      }
-    } else {
       if (WS.isTemporary() && !WS.getSize())
         continue;
 
       if (!WS.isDefined(/*SetUsed=*/false))
         continue;
 
       if (!WS.getSize())
         report_fatal_error("data symbols must have a size set with .size: " +
for (const MCSymbol &S : Asm.symbols()) {
     // Find the target symbol of this weak alias and export that index
     const auto &WS = static_cast<const MCSymbolWasm &>(S);
     const MCSymbolWasm *ResolvedSym = ResolveSymbol(WS);
     DEBUG(dbgs() << WS.getName() << ": weak alias of '" << *ResolvedSym << "'\n");
     assert(SymbolIndices.count(ResolvedSym) > 0);
     uint32_t Index = SymbolIndices.find(ResolvedSym)->second;
     DEBUG(dbgs() << "  -> index:" << Index << "\n");
 
-    //SymbolIndices[&WS] = Index;
     WasmExport Export;
     Export.FieldName = WS.getName();
     Export.Index = Index;
     if (WS.isFunction())
       Export.Kind = wasm::WASM_EXTERNAL_FUNCTION;
     else
       Export.Kind = wasm::WASM_EXTERNAL_GLOBAL;
     DEBUG(dbgs() << "  -> export " << Exports.size() << "\n");
     Exports.push_back(Export);
 
     if (!WS.isExternal())
       SymbolFlags.emplace_back(WS.getName(), wasm::WASM_SYMBOL_BINDING_LOCAL);
   }
 
-  // Add types for indirect function calls.
-  for (const WasmRelocationEntry &Fixup : CodeRelocations) {
-    if (Fixup.Type != wasm::R_WEBASSEMBLY_TYPE_INDEX_LEB)
-      continue;
+  {
+    auto HandleReloc = [&](const WasmRelocationEntry &Rel) {
+      // Functions referenced by a relocation need to prepared to be called
+      // indirectly.
+      const MCSymbolWasm& WS = *Rel.Symbol;
+      if (WS.isFunction() && IndirectSymbolIndices.count(&WS) == 0) {
+        switch (Rel.Type) {
+        case wasm::R_WEBASSEMBLY_TABLE_INDEX_I32:
+        case wasm::R_WEBASSEMBLY_TABLE_INDEX_SLEB:
+        case wasm::R_WEBASSEMBLY_MEMORY_ADDR_I32:
+        case wasm::R_WEBASSEMBLY_MEMORY_ADDR_SLEB: {
+          uint32_t Index = SymbolIndices.find(&WS)->second;
+          IndirectSymbolIndices[&WS] = TableElems.size();
+          DEBUG(dbgs() << "  -> adding to table: " << TableElems.size() << "\n");
+          TableElems.push_back(Index);
+          registerFunctionType(WS);
+          break;
+        }
+        default:
+          break;
+        }
+      }
+    };
 
-    registerFunctionType(*Fixup.Symbol);
+    for (const WasmRelocationEntry &RelEntry : CodeRelocations)
+      HandleReloc(RelEntry);
+    for (const WasmRelocationEntry &RelEntry : DataRelocations)
+      HandleReloc(RelEntry);
   }
 
   // Translate .init_array section contents into start functions.
   for (const MCSection &S : Asm) {
     const auto &WS = static_cast<const MCSectionWasm &>(S);
     if (WS.getSectionName().startswith(".fini_array"))
       report_fatal_error(".fini_array sections are unsupported");
     if (!WS.getSectionName().startswith(".init_array"))

llvm/trunk/test/MC/WebAssembly/weak-alias.ll

 ; RUN: llc -mtriple wasm32-unknown-unknown-wasm -filetype=obj %s -o %t.o
 ; RUN: obj2yaml %t.o | FileCheck %s
 ; RUN: llvm-objdump -t %t.o | FileCheck --check-prefix=CHECK-SYMS %s
 
 ; 'foo_alias()' is weak alias of function 'foo()'
 ; 'bar_alias' is weak alias of global variable 'bar'
 ; Generates two exports of the same function, one of them weak
 
 @bar = global i32 7, align 8
 @bar_alias = weak hidden alias i32, i32* @bar
-@bar_alias_address = global i32* @bar_alias, align 8
-
 @foo_alias = weak hidden alias i32 (), i32 ()* @foo
 
+@direct_address = global i32()* @foo, align 8
+@alias_address = global i32()* @foo_alias, align 8
+
+define hidden i32 @foo() #0 {
+entry:
+  ret i32 0
+}
+
+define hidden i32 @call_direct() #0 {
+entry:
+  %call = call i32 @foo()
+  ret i32 %call
+}
+
 define hidden i32 @call_alias() #0 {
 entry:
   %call = call i32 @foo_alias()
   ret i32 %call
 }
 
-define hidden i32 @foo() #0 {
+define hidden i32 @call_direct_ptr() #0 {
 entry:
-  ret i32 0
+  %0 = load i32 ()*, i32 ()** @direct_address, align 8
+  %call = call i32 %0()
+  ret i32 %call
 }
 
+define hidden i32 @call_alias_ptr() #0 {
+entry:
+  %0 = load i32 ()*, i32 ()** @alias_address, align 8
+  %call = call i32 %0()
+  ret i32 %call
+}
 
 ; CHECK:        - Type:            TYPE
 ; CHECK-NEXT:     Signatures:      
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         ReturnType:      I32
 ; CHECK-NEXT:         ParamTypes:      
 ; CHECK-NEXT:   - Type:            IMPORT
 ; CHECK-NEXT:     Imports:
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           __linear_memory
 ; CHECK-NEXT:         Kind:            MEMORY
 ; CHECK-NEXT:         Memory:
 ; CHECK-NEXT:           Initial:         0x00000001
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           __indirect_function_table
 ; CHECK-NEXT:         Kind:            TABLE
 ; CHECK-NEXT:         Table:
 ; CHECK-NEXT:           ElemType:        ANYFUNC
 ; CHECK-NEXT:           Limits:
-; CHECK-NEXT:             Initial:         0x00000000
+; CHECK-NEXT:             Initial:         0x00000002
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           foo_alias
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         SigIndex:        0
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           bar_alias
 ; CHECK-NEXT:         Kind:            GLOBAL
 ; CHECK-NEXT:         GlobalType:      I32
 ; CHECK-NEXT:         GlobalMutable:   false
 ; CHECK-NEXT:   - Type:            FUNCTION
-; CHECK-NEXT:     FunctionTypes:   [ 0, 0 ]
+; CHECK-NEXT:     FunctionTypes:   [ 0, 0, 0, 0, 0 ]
 ; CHECK-NEXT:   - Type:            GLOBAL
 ; CHECK-NEXT:     Globals:         
 ; CHECK-NEXT:       - Type:            I32
 ; CHECK-NEXT:         Mutable:         false
 ; CHECK-NEXT:         InitExpr:        
 ; CHECK-NEXT:           Opcode:          I32_CONST
-; CHECK-NEXT:           Value:           0
+; CHECK-NEXT:           Value:           8
 ; CHECK-NEXT:       - Type:            I32
 ; CHECK-NEXT:         Mutable:         false
 ; CHECK-NEXT:         InitExpr:        
 ; CHECK-NEXT:           Opcode:          I32_CONST
-; CHECK-NEXT:           Value:           8
+; CHECK-NEXT:           Value:           16
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         false
+; CHECK-NEXT:         InitExpr:        
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           0
 ; CHECK-NEXT:   - Type:            EXPORT
 ; CHECK-NEXT:     Exports:         
-; CHECK-NEXT:       - Name:            call_alias
+; CHECK-NEXT:       - Name:            foo
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Index:           1
-; CHECK-NEXT:       - Name:            foo
+; CHECK-NEXT:       - Name:            call_direct
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Index:           2
-; CHECK-NEXT:       - Name:            bar
+; CHECK-NEXT:       - Name:            call_alias
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Index:           3
+; CHECK-NEXT:       - Name:            call_direct_ptr
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Index:           4
+; CHECK-NEXT:       - Name:            direct_address
 ; CHECK-NEXT:         Kind:            GLOBAL
 ; CHECK-NEXT:         Index:           1
-; CHECK-NEXT:       - Name:            bar_alias_address
+; CHECK-NEXT:       - Name:            call_alias_ptr
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Index:           5
+; CHECK-NEXT:       - Name:            alias_address
 ; CHECK-NEXT:         Kind:            GLOBAL
 ; CHECK-NEXT:         Index:           2
+; CHECK-NEXT:       - Name:            bar
+; CHECK-NEXT:         Kind:            GLOBAL
+; CHECK-NEXT:         Index:           3
 ; CHECK-NEXT:       - Name:            foo_alias
 ; CHECK-NEXT:         Kind:            FUNCTION
-; CHECK-NEXT:         Index:           2
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:       - Name:            bar_alias
 ; CHECK-NEXT:         Kind:            GLOBAL
-; CHECK-NEXT:         Index:           1
+; CHECK-NEXT:         Index:           3
+; CHECK-NEXT:   - Type:            ELEM
+; CHECK-NEXT:     Segments:        
+; CHECK-NEXT:       - Offset:          
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           0
+; CHECK-NEXT:         Functions:       [ 1, 0 ]
 ; CHECK-NEXT:   - Type:            CODE
 ; CHECK-NEXT:     Relocations:     
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
+; CHECK-NEXT:         Index:           1
+; CHECK-NEXT:         Offset:          0x00000009
+; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
+; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Offset:          0x00000012
+; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
+; CHECK-NEXT:         Index:           1
+; CHECK-NEXT:         Offset:          0x0000001E
+; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_TYPE_INDEX_LEB
 ; CHECK-NEXT:         Index:           0
-; CHECK-NEXT:         Offset:          0x00000004
+; CHECK-NEXT:         Offset:          0x00000024
+; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
+; CHECK-NEXT:         Index:           2
+; CHECK-NEXT:         Offset:          0x00000031
+; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_TYPE_INDEX_LEB
+; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Offset:          0x00000037
 ; CHECK-NEXT:     Functions:       
 ; CHECK-NEXT:       - Locals:          
+; CHECK-NEXT:         Body:            41000B
+; CHECK-NEXT:       - Locals:          
+; CHECK-NEXT:         Body:            1081808080000B
+; CHECK-NEXT:       - Locals:          
 ; CHECK-NEXT:         Body:            1080808080000B
 ; CHECK-NEXT:       - Locals:          
-; CHECK-NEXT:         Body:            41000B
+; CHECK-NEXT:         Body:            410028028880808000118080808000000B
+; CHECK-NEXT:       - Locals:          
+; CHECK-NEXT:         Body:            410028029080808000118080808000000B
 ; CHECK-NEXT:   - Type:            DATA
 ; CHECK-NEXT:     Relocations:     
-; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_I32
+; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_I32
 ; CHECK-NEXT:         Index:           0
 ; CHECK-NEXT:         Offset:          0x0000000F
+; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_I32
+; CHECK-NEXT:         Index:           1
+; CHECK-NEXT:         Offset:          0x00000018
 ; CHECK-NEXT:     Segments:        
 ; CHECK-NEXT:       - SectionOffset:   6
 ; CHECK-NEXT:         MemoryIndex:     0
 ; CHECK-NEXT:         Offset:          
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           0
 ; CHECK-NEXT:         Content:         '07000000'
 ; CHECK-NEXT:       - SectionOffset:   15
 ; CHECK-NEXT:         MemoryIndex:     0
 ; CHECK-NEXT:         Offset:          
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           8
 ; CHECK-NEXT:         Content:         '00000000'
 
 ; CHECK:        - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            name
 ; CHECK-NEXT:     FunctionNames:   
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            foo_alias
 ; CHECK-NEXT:       - Index:           1
-; CHECK-NEXT:         Name:            call_alias
-; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Name:            foo
+; 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_direct_ptr
+; CHECK-NEXT:       - Index:           5
+; CHECK-NEXT:         Name:            call_alias_ptr
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
-; CHECK-NEXT:     DataSize:        12
+; CHECK-NEXT:     DataSize:        20
 ; CHECK-NEXT:     SymbolInfo:      
 ; CHECK-NEXT:       - Name:            foo_alias
 ; CHECK-NEXT:         Flags:           [ BINDING_WEAK, VISIBILITY_HIDDEN ]
 ; CHECK-NEXT:       - Name:            bar_alias
 ; CHECK-NEXT:         Flags:           [ BINDING_WEAK, VISIBILITY_HIDDEN ]
+; CHECK-NEXT:       - Name:            foo
+; CHECK-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
+; CHECK-NEXT:       - Name:            call_direct
+; CHECK-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
 ; CHECK-NEXT:       - Name:            call_alias
 ; CHECK-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
-; CHECK-NEXT:       - Name:            foo
+; CHECK-NEXT:       - Name:            call_direct_ptr
+; CHECK-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
+; CHECK-NEXT:       - Name:            call_alias_ptr
 ; CHECK-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
 ; CHECK-NEXT:     SegmentInfo:    
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            .data.bar
 ; CHECK-NEXT:         Alignment:       8
 ; CHECK-NEXT:         Flags:           [ ]
 ; CHECK-NEXT:       - Index:           1
-; CHECK-NEXT:         Name:            .data.bar_alias_address
+; CHECK-NEXT:         Name:            .data.direct_address
+; CHECK-NEXT:         Alignment:       8
+; CHECK-NEXT:         Flags:           [ ]
+; CHECK-NEXT:       - Index:           2
+; CHECK-NEXT:         Name:            .data.alias_address
 ; CHECK-NEXT:         Alignment:       8
 ; CHECK-NEXT:         Flags:           [ ]
 ; CHECK-NEXT: ...
 
 ; CHECK-SYMS: SYMBOL TABLE:
 ; CHECK-SYMS-NEXT: 00000000 g     F name  foo_alias
-; CHECK-SYMS-NEXT: 00000001 g     F name  call_alias
-; CHECK-SYMS-NEXT: 00000002 g     F name  foo
-; CHECK-SYMS-NEXT: 00000002 gw    F EXPORT  .hidden foo_alias
+; CHECK-SYMS-NEXT: 00000001 g     F name  foo
+; CHECK-SYMS-NEXT: 00000002 g     F name  call_direct
+; CHECK-SYMS-NEXT: 00000003 g     F name  call_alias
+; CHECK-SYMS-NEXT: 00000004 g     F name  call_direct_ptr
+; CHECK-SYMS-NEXT: 00000005 g     F name  call_alias_ptr
+; CHECK-SYMS-NEXT: 00000001 gw    F EXPORT  .hidden foo_alias
 ; CHECK-SYMS-NEXT: 00000000 gw      EXPORT  .hidden bar_alias
-; CHECK-SYMS-NEXT: 00000001 g     F EXPORT  .hidden call_alias
-; CHECK-SYMS-NEXT: 00000002 g     F EXPORT  .hidden foo
+; CHECK-SYMS-NEXT: 00000001 g     F EXPORT  .hidden foo
+; CHECK-SYMS-NEXT: 00000002 g     F EXPORT  .hidden call_direct
+; CHECK-SYMS-NEXT: 00000003 g     F EXPORT  .hidden call_alias
+; CHECK-SYMS-NEXT: 00000004 g     F EXPORT  .hidden call_direct_ptr
+; CHECK-SYMS-NEXT: 00000008 g       EXPORT  direct_address
+; CHECK-SYMS-NEXT: 00000005 g     F EXPORT  .hidden call_alias_ptr
+; CHECK-SYMS-NEXT: 00000010 g       EXPORT  alias_address
 ; CHECK-SYMS-NEXT: 00000000 g       EXPORT  bar
-; CHECK-SYMS-NEXT: 00000008 g       EXPORT  bar_alias_address