[lld][WebAssembly] Add optional symbols after input file handling

[sbc100]

Summary

This allows undefined references in input files be resolved by the
optional symbols. Previously we were doing this before input file
reading which means it was working only for command line symbols
references (i.e. -u or --export).

Also use addOptionalDataSymbol for __dso_handle and make all optional
symbols hidden by default.

[ruiu]

LGTM

Nice!

lld/test/wasm/global-base.test

 CHECK-1024-NEXT:      - Index:           2
 CHECK-1024-NEXT:        Type:            I32
 CHECK-1024-NEXT:        Mutable:         false
 CHECK-1024-NEXT:        InitExpr:
 CHECK-1024-NEXT:          Opcode:          I32_CONST
 CHECK-1024-NEXT:          Value:           1024
 
 CHECK-1024:       - Type:            EXPORT
-CHECK-1024-NEXT:    Exports:
-CHECK-1024-NEXT:      - Name:            memory
-CHECK-1024-NEXT:        Kind:            MEMORY
-CHECK-1024-NEXT:        Index:           0
-CHECK-1024-NEXT:      - Name:            __data_end
+CHECK-1024:           - Name:            __data_end
 CHECK-1024-NEXT:        Kind:            GLOBAL
 CHECK-1024-NEXT:        Index:           1
 CHECK-1024-NEXT:      - Name:            __global_base
 CHECK-1024-NEXT:        Kind:            GLOBAL
 CHECK-1024-NEXT:        Index:           2
 
 RUN: wasm-ld --export=__global_base --export=__data_end --allow-undefined --global-base=16777216 -o %t.wasm %t.o
 RUN: obj2yaml %t.wasm | FileCheck %s  -check-prefix=CHECK-16777216

 CHECK-16777216-NEXT:      - Index:           2
 CHECK-16777216-NEXT:        Type:            I32
 CHECK-16777216-NEXT:        Mutable:         false
 CHECK-16777216-NEXT:        InitExpr:
 CHECK-16777216-NEXT:          Opcode:          I32_CONST
 CHECK-16777216-NEXT:          Value:           16777216
 
 CHECK-16777216:       - Type:            EXPORT
-CHECK-16777216-NEXT:    Exports:
-CHECK-16777216-NEXT:      - Name:            memory
-CHECK-16777216-NEXT:        Kind:            MEMORY
-CHECK-16777216-NEXT:        Index:           0
-CHECK-16777216-NEXT:      - Name:            __data_end
+CHECK-16777216:           - Name:            __data_end
 CHECK-16777216-NEXT:        Kind:            GLOBAL
 CHECK-16777216-NEXT:        Index:           1
 CHECK-16777216-NEXT:      - Name:            __global_base
 CHECK-16777216-NEXT:        Kind:            GLOBAL
 CHECK-16777216-NEXT:        Index:           2

lld/test/wasm/optional-symbol.ll

+; RUN: llc -filetype=obj -o %t.o %s
+; RUN: wasm-ld --export=get_handle %t.o -o %t.wasm
+
+target triple = "wasm32-unknown-unknown"
+
+@__dso_handle = external global i8*
+
+define i8** @get_handle() {
+  ret i8** @__dso_handle
+}
+
+define void @_start() {
+  ret void
+}

lld/test/wasm/stack-first.test

 CHECK-NEXT:         InitExpr:        
 CHECK-NEXT:           Opcode:          I32_CONST
 CHECK-NEXT:           Value:           512
 CHECK-NEXT:   - Type:            EXPORT
 CHECK-NEXT:     Exports:         
 CHECK-NEXT:       - Name:            memory
 CHECK-NEXT:         Kind:            MEMORY
 CHECK-NEXT:         Index:           0
+CHECK-NEXT:       - Name:            _start
+CHECK-NEXT:         Kind:            FUNCTION
+CHECK-NEXT:         Index:           0
 CHECK-NEXT:       - Name:            __data_end
 CHECK-NEXT:         Kind:            GLOBAL
 CHECK-NEXT:         Index:           1
 CHECK-NEXT:       - Name:            __heap_base
 CHECK-NEXT:         Kind:            GLOBAL
 CHECK-NEXT:         Index:           2
-CHECK-NEXT:       - Name:            _start
-CHECK-NEXT:         Kind:            FUNCTION
-CHECK-NEXT:         Index:           0

lld/wasm/Driver.cpp

if (config->isPic) {
       // For PIC code we create a synthetic function __wasm_apply_relocs which
       // is called from __wasm_call_ctors before the user-level constructors.
       WasmSym::applyRelocs = symtab->addSyntheticFunction(
           "__wasm_apply_relocs", WASM_SYMBOL_VISIBILITY_HIDDEN,
           make<SyntheticFunction>(nullSignature, "__wasm_apply_relocs"));
     }
   }
 
-  if (!config->shared)
-    WasmSym::dataEnd = symtab->addOptionalDataSymbol("__data_end");
 
   if (config->isPic) {
     WasmSym::stackPointer =
         createUndefinedGlobal("__stack_pointer", &mutableGlobalTypeI32);
     // For PIC code, we import two global variables (__memory_base and
     // __table_base) from the environment and use these as the offset at
     // which to load our static data and function table.
     // See:
if (config->isPic) {
     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::globalBase = symtab->addOptionalDataSymbol("__global_base");
-    WasmSym::heapBase = symtab->addOptionalDataSymbol("__heap_base");
   }
 
   if (config->sharedMemory && !config->shared) {
     WasmSym::tlsBase = createGlobalVariable("__tls_base", true, 0);
     WasmSym::tlsSize = createGlobalVariable("__tls_size", false, 0);
     WasmSym::tlsAlign = createGlobalVariable("__tls_align", false, 1);
     WasmSym::initTLS = symtab->addSyntheticFunction(
         "__wasm_init_tls", WASM_SYMBOL_VISIBILITY_HIDDEN,
         make<SyntheticFunction>(i32ArgSignature, "__wasm_init_tls"));
   }
+}
+
+static void createOptionalSymbols() {
+  if (!config->relocatable)
+    WasmSym::dsoHandle = symtab->addOptionalDataSymbol("__dso_handle");
 
-  WasmSym::dsoHandle = symtab->addSyntheticDataSymbol(
-      "__dso_handle", WASM_SYMBOL_VISIBILITY_HIDDEN);
+  if (!config->isPic) {
+    WasmSym::dataEnd = symtab->addOptionalDataSymbol("__data_end");
+    WasmSym::globalBase = symtab->addOptionalDataSymbol("__global_base");
+    WasmSym::heapBase = symtab->addOptionalDataSymbol("__heap_base");
+  }
 }
 
 // Reconstructs command line arguments so that so that you can re-run
 // the same command with the same inputs. This is for --reproduce.
 static std::string createResponseFile(const opt::InputArgList &args) {
   SmallString<0> data;
   raw_svector_ostream os(data);
 
void LinkerDriver::link(ArrayRef<const char *> argsArr) {
 
   // Add all files to the symbol table. This will add almost all
   // symbols that we need to the symbol table.
   for (InputFile *f : files)
     symtab->addFile(f);
   if (errorCount())
     return;
 
+  createOptionalSymbols();
+
   // Handle the `--undefined <sym>` options.
   for (auto *arg : args.filtered(OPT_undefined))
     handleUndefined(arg->getValue());
 
   // Handle the `--export <sym>` options
   // This works like --undefined but also exports the symbol if its found
   for (auto *arg : args.filtered(OPT_export))
     handleUndefined(arg->getValue());

lld/wasm/SymbolTable.h

public:
 
   bool addComdat(StringRef name);
 
   DefinedData *addSyntheticDataSymbol(StringRef name, uint32_t flags);
   DefinedGlobal *addSyntheticGlobal(StringRef name, uint32_t flags,
                                     InputGlobal *global);
   DefinedFunction *addSyntheticFunction(StringRef name, uint32_t flags,
                                         InputFunction *function);
-  DefinedData *addOptionalDataSymbol(StringRef name, uint32_t value = 0,
-                                     uint32_t flags = 0);
+  DefinedData *addOptionalDataSymbol(StringRef name, uint32_t value = 0);
 
   void handleSymbolVariants();
   void handleWeakUndefines();
 
   std::vector<ObjFile *> objectFiles;
   std::vector<SharedFile *> sharedFiles;
   std::vector<BitcodeFile *> bitcodeFiles;
   std::vector<InputFunction *> syntheticFunctions;

lld/wasm/SymbolTable.cpp

DefinedFunction *SymbolTable::addSyntheticFunction(StringRef name,
   syntheticFunctions.emplace_back(function);
   return replaceSymbol<DefinedFunction>(insertName(name).first, name,
                                         flags, nullptr, function);
 }
 
 // Adds an optional, linker generated, data symbols.  The symbol will only be
 // added if there is an undefine reference to it, or if it is explictly exported
 // via the --export flag.  Otherwise we don't add the symbol and return nullptr.
-DefinedData *SymbolTable::addOptionalDataSymbol(StringRef name, uint32_t value,
-                                                uint32_t flags) {
+DefinedData *SymbolTable::addOptionalDataSymbol(StringRef name,
+                                                uint32_t value) {
   Symbol *s = find(name);
   if (!s && (config->exportAll || config->exportedSymbols.count(name) != 0))
     s = insertName(name).first;
   else if (!s || s->isDefined())
     return nullptr;
   LLVM_DEBUG(dbgs() << "addOptionalDataSymbol: " << name << "\n");
-  auto *rtn = replaceSymbol<DefinedData>(s, name, flags);
+  auto *rtn = replaceSymbol<DefinedData>(s, name, WASM_SYMBOL_VISIBILITY_HIDDEN);
   rtn->setVirtualAddress(value);
   rtn->referenced = true;
   return rtn;
 }
 
 DefinedData *SymbolTable::addSyntheticDataSymbol(StringRef name,
                                                  uint32_t flags) {
   LLVM_DEBUG(dbgs() << "addSyntheticDataSymbol: " << name << "\n");