[WebAssembly] Allow undefined symbols when building shared libraries

[ruiu]

LGTM

lld/trunk/test/wasm/shared.ll

 ; RUN: llc -O0 -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"
 
-@used_data = hidden global i32 2, align 4
+@data = hidden global i32 2, align 4
 @indirect_func = local_unnamed_addr global void ()* @foo, align 4
+@indirect_func_external = local_unnamed_addr global void ()* @func_external, align 4
 
 define default void @foo() {
 entry:
   ; To ensure we use __stack_pointer
   %ptr = alloca i32
-  %0 = load i32, i32* @used_data, align 4
-  %1 = load void ()*, void ()** @indirect_func, align 4
-  call void %1()
+  %0 = load i32, i32* @data, align 4
+  %1 = load i32, i32* @data_external, align 4
+  %2 = load void ()*, void ()** @indirect_func, align 4
+  call void %2()
   ret void
 }
 
+declare void @func_external()
+
+@data_external = external global i32
+
+
 ; check for dylink section at start
 
 ; CHECK:      Sections:
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            dylink
-; CHECK-NEXT:     MemorySize:      4
+; CHECK-NEXT:     MemorySize:      8
 ; CHECK-NEXT:     MemoryAlignment: 2
-; CHECK-NEXT:     TableSize:       1
+; CHECK-NEXT:     TableSize:       2
 ; CHECK-NEXT:     TableAlignment:  0
 
 ; check for import of __table_base and __memory_base globals
 
 ; CHECK:        - Type:            IMPORT
 ; CHECK-NEXT:     Imports:
 ; 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:             Flags:           [ HAS_MAX ]
-; CHECK-NEXT:             Initial:         0x00000001
-; CHECK-NEXT:             Maximum:         0x00000001
+; CHECK-NEXT:             Initial:         0x00000002
+; CHECK-NEXT:             Maximum:         0x00000002
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           __stack_pointer
 ; CHECK-NEXT:         Kind:            GLOBAL
 ; CHECK-NEXT:         GlobalType:      I32
 ; CHECK-NEXT:         GlobalMutable:   true
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           __memory_base
 ; CHECK-NEXT:         Kind:            GLOBAL
 ; CHECK-NEXT:         GlobalType:      I32
 ; CHECK-NEXT:         GlobalMutable:   false
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           __table_base
 ; CHECK-NEXT:         Kind:            GLOBAL
 ; CHECK-NEXT:         GlobalType:      I32
 ; CHECK-NEXT:         GlobalMutable:   false
 
 ; check for elem segment initialized with __table_base global as offset
 
 ; CHECK:        - Type:            ELEM
 ; CHECK-NEXT:     Segments:
 ; CHECK-NEXT:       - Offset:
 ; CHECK-NEXT:           Opcode:          GET_GLOBAL
 ; CHECK-NEXT:           Index:           2
-; CHECK-NEXT:         Functions:       [ 1 ]
+; CHECK-NEXT:         Functions:       [ 2, 0 ]
 
 ; check the data segment initialized with __memory_base global as offset
 
 ; CHECK:        - Type:            DATA
 ; CHECK-NEXT:     Segments:
 ; CHECK-NEXT:       - SectionOffset:   6
 ; CHECK-NEXT:         MemoryIndex:     0
 ; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          GET_GLOBAL
 ; CHECK-NEXT:           Index:           1
-; CHECK-NEXT:         Content:         '00000000'
+; CHECK-NEXT:         Content:         '0000000001000000'

lld/trunk/wasm/Driver.cpp

for (Symbol *Sym : Symtab->getSymbols()) {
     // added via "--undefined"), but weak undefined ones do have a signature.
     assert(FuncSym->FunctionType);
     const WasmSignature &Sig = *FuncSym->FunctionType;
 
     // Add a synthetic dummy for weak undefined functions.  These dummies will
     // be GC'd if not used as the target of any "call" instructions.
     std::string SymName = toString(*Sym);
     StringRef DebugName = Saver.save("undefined function " + SymName);
-    SyntheticFunction *Func =
-        make<SyntheticFunction>(Sig, Sym->getName(), DebugName);
+    auto *Func = make<SyntheticFunction>(Sig, Sym->getName(), DebugName);
     Func->setBody(UnreachableFn);
     // Ensure it compares equal to the null pointer, and so that table relocs
     // don't pull in the stub body (only call-operand relocs should do that).
     Func->setTableIndex(0);
     Symtab->SyntheticFunctions.emplace_back(Func);
     // Hide our dummy to prevent export.
     uint32_t Flags = WASM_SYMBOL_VISIBILITY_HIDDEN;
     replaceSymbol<DefinedFunction>(Sym, Sym->getName(), Flags, nullptr, Func);

 
 // Create ABI-defined synthetic symbols
 static void createSyntheticSymbols() {
   static WasmSignature NullSignature = {{}, {}};
   static llvm::wasm::WasmGlobalType GlobalTypeI32 = {WASM_TYPE_I32, false};
   static llvm::wasm::WasmGlobalType MutableGlobalTypeI32 = {WASM_TYPE_I32,
                                                             true};
 
+  if (!Config->Relocatable)
     WasmSym::CallCtors = Symtab->addSyntheticFunction(
         "__wasm_call_ctors", WASM_SYMBOL_VISIBILITY_HIDDEN,
         make<SyntheticFunction>(NullSignature, "__wasm_call_ctors"));
 
   // The __stack_pointer is imported in the shared library case, and exported
   // in the non-shared (executable) case.
   if (Config->Shared) {
     WasmSym::StackPointer =
         createUndefinedGlobal("__stack_pointer", &MutableGlobalTypeI32);
   } else {
     llvm::wasm::WasmGlobal Global;
     Global.Type = {WASM_TYPE_I32, true};
     Global.InitExpr.Value.Int32 = 0;
     Global.InitExpr.Opcode = WASM_OPCODE_I32_CONST;
     Global.SymbolName = "__stack_pointer";
-    InputGlobal *StackPointer = make<InputGlobal>(Global, nullptr);
+    auto *StackPointer = make<InputGlobal>(Global, nullptr);
     StackPointer->Live = true;
     // For non-PIC code
     // TODO(sbc): Remove WASM_SYMBOL_VISIBILITY_HIDDEN when the mutable global
     // spec proposal is implemented in all major browsers.
     // See: https://github.com/WebAssembly/mutable-global
     WasmSym::StackPointer = Symtab->addSyntheticGlobal(
         "__stack_pointer", WASM_SYMBOL_VISIBILITY_HIDDEN, StackPointer);
     WasmSym::HeapBase = Symtab->addSyntheticDataSymbol("__heap_base", 0);
void LinkerDriver::link(ArrayRef<const char *> ArgsArr) {
   Config->Pic = Config->Pie || Config->Shared;
 
   if (Config->Pic) {
     if (Config->ExportTable)
       error("-shared/-pie is incompatible with --export-table");
     Config->ImportTable = true;
   }
 
-  if (Config->Shared)
+  if (Config->Shared) {
     Config->ExportDynamic = true;
+    Config->AllowUndefined = true;
+  }
 
   if (!Config->Relocatable)
     createSyntheticSymbols();
 
   createFiles(Args);
   if (errorCount())
     return;