[WebAssembly] Assign GOT entries symbols used in data relocations

[sbc100]

• add comment

[ruiu]

LGTM

lld/test/wasm/shared.ll

 ; RUN: llc -relocation-model=pic -filetype=obj %s -o %t.o
 ; RUN: wasm-ld -shared -o %t.wasm %t.o
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 target triple = "wasm32-unknown-unknown"
 
 @data = hidden global i32 2, align 4
 @data_external = external global i32
 @indirect_func = local_unnamed_addr global i32 ()* @foo, align 4
 @indirect_func_external = local_unnamed_addr global void ()* @func_external, align 4
 
 @data_addr = local_unnamed_addr global i32* @data, align 4
 @data_addr_external = local_unnamed_addr global i32* @data_external, align 4
 
-define default i32 @foo() {
+define hidden i32 @foo() {
 entry:
   ; To ensure we use __stack_pointer
   %ptr = alloca i32
   %0 = load i32, i32* @data, align 4
   %1 = load i32 ()*, i32 ()** @indirect_func, align 4
   call i32 %1()
   ret i32 %0
 }

lld/wasm/InputChunks.cpp

case R_WASM_TABLE_INDEX_I32:
       writeU8(OS, WASM_OPCODE_GLOBAL_GET, "GLOBAL_GET");
       writeUleb128(OS, WasmSym::TableBase->getGlobalIndex(), "table_base");
       writeU8(OS, WASM_OPCODE_I32_CONST, "CONST");
       writeSleb128(OS, File->calcNewValue(Rel), "new table index");
       writeU8(OS, WASM_OPCODE_I32_ADD, "ADD");
       break;
     case R_WASM_MEMORY_ADDR_I32: {
       Symbol *Sym = File->getSymbol(Rel);
-      if (Sym->isUndefined()) {
-        // Undefined addresses are accessed via imported GOT globals
-        writeU8(OS, WASM_OPCODE_GLOBAL_GET, "GLOBAL_GET");
-        writeUleb128(OS, Sym->getGOTIndex(), "global index");
-      } else {
-        // Defined global data is accessed via known offset from __memory_base
+      if (Sym->isLocal() || Sym->isHidden()) {
+        // Hidden/Local data symbols are accessed via known offset from
+        // __memory_base
         writeU8(OS, WASM_OPCODE_GLOBAL_GET, "GLOBAL_GET");
         writeUleb128(OS, WasmSym::MemoryBase->getGlobalIndex(), "memory_base");
         writeU8(OS, WASM_OPCODE_I32_CONST, "CONST");
         writeSleb128(OS, File->calcNewValue(Rel), "new memory offset");
         writeU8(OS, WASM_OPCODE_I32_ADD, "ADD");
+      } else {
+        // Default data symbols are accessed via imported GOT globals
+        writeU8(OS, WASM_OPCODE_GLOBAL_GET, "GLOBAL_GET");
+        writeUleb128(OS, Sym->getGOTIndex(), "global index");
       }
       break;
     }
     default:
       llvm_unreachable("unexpected relocation type in data segment");
     }
 
     // Store that value at the virtual address
     writeU8(OS, WASM_OPCODE_I32_STORE, "I32_STORE");
     writeUleb128(OS, 2, "align");
     writeUleb128(OS, 0, "offset");
   }
 }

lld/wasm/Writer.cpp

case R_WASM_GLOBAL_INDEX_LEB: {
       if (!isa<GlobalSymbol>(Sym) && !Sym->isInGOT()) {
         Sym->setGOTIndex(NumImportedGlobals++);
         GOTSymbols.push_back(Sym);
       }
     }
     }
 
     if (Config->Pic) {
-      // Certain relocation types can't be used when building PIC output, since
-      // they would require absolute symbol addresses at link time.
       switch (Reloc.Type) {
       case R_WASM_TABLE_INDEX_SLEB:
       case R_WASM_MEMORY_ADDR_SLEB:
       case R_WASM_MEMORY_ADDR_LEB: {
+        // Certain relocation types can't be used when building PIC output, since
+        // they would require absolute symbol addresses at link time.
         Symbol *Sym = File->getSymbols()[Reloc.Index];
         error(toString(File) + ": relocation " +
               relocTypeToString(Reloc.Type) + " cannot be used againt symbol " +
               toString(*Sym) + "; recompile with -fPIC");
         break;
       }
+      case R_WASM_TABLE_INDEX_I32:
+      case R_WASM_MEMORY_ADDR_I32: {
+        // These relocation types are only present in the data section and
+        // will be converted into code by `generateRelocationCode`.  This code
+        // requires the symbols to have GOT entires.
+        auto* Sym = File->getSymbols()[Reloc.Index];
+        if (!Sym->isHidden() && !Sym->isLocal() && !Sym->isInGOT()) {
+          Sym->setGOTIndex(NumImportedGlobals++);
+          GOTSymbols.push_back(Sym);
+        }
+        break;
+      }
       }
     }
   }
-
 }
 
 void Writer::assignIndexes() {
   assert(InputFunctions.empty());
   uint32_t FunctionIndex = NumImportedFunctions;
   auto AddDefinedFunction = [&](InputFunction *Func) {
     if (!Func->Live)
       return;