[WebAssembly] Refactor handling of weak undefined functions. NFC.

[sbc100]

Summary

Also add to the docs.

This is refactor in preparation for https://reviews.llvm.org/D57909

[sbc100]

• add docs

[sbc100]

• add docs

[ruiu]

LGTM

lld/trunk/docs/WebAssembly.rst

 be stripped from the binary.
 
 The symbols which are preserved by default are:
 
 - The entry point (by default ``_start``).
 - Any symbol which is to be exported.
 - Any symbol transitively referenced by the above.
 
+Weak Undefined Functions
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+On native platforms, calls to weak undefined functions end up as calls to the
+null function pointer.  With WebAssembly, direct calls must reference a defined
+function (with the correct signature).  In order to handle this case the linker
+will generate function a stub containing only the ``unreachable`` instruction
+and use this for any direct references to an undefined weak function.
+
+For example a runtime call to a weak undefined function ``foo`` will up trapping
+on ``unreachable`` inside and linker-generated function called
+``undefined:foo``.
 
 Missing features
 ----------------
 
 - Merging of data section similar to ``SHF_MERGE`` in the ELF world is not
   supported.
 - No support for creating shared libraries.  The spec for shared libraries in
   WebAssembly is still in flux:
   https://github.com/WebAssembly/tool-conventions/blob/master/DynamicLinking.md
 
 .. _linking: https://github.com/WebAssembly/tool-conventions/blob/master/Linking.md

lld/trunk/test/wasm/archive-weak-undefined.ll

 declare extern_weak i32 @ret32()
 
 define void @_start() {
 entry:
   %call1 = call i32 @ret32()
   ret void
 }
 
-; CHECK: Name: undefined function ret32
+; CHECK: Name: 'undefined:ret32'
 ; CHECK-NOT: Name: ret32

lld/trunk/test/wasm/cxx-mangling.ll

 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            410110828080800041011081808080000B
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            name
 ; CHECK-NEXT:     FunctionNames:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            __wasm_call_ctors
 ; CHECK-NEXT:       - Index:           1
-; DEMANGLE-NEXT:      Name:            'undefined function bar(int)'
-; MANGLE-NEXT:        Name:            undefined function _Z3bari
+; DEMANGLE-NEXT:      Name:            'undefined:bar(int)'
+; MANGLE-NEXT:        Name:            'undefined:_Z3bari'
 ; CHECK-NEXT:       - Index:           2
 ; DEMANGLE-NEXT:      Name:            'foo(int)'
 ; MANGLE-NEXT:        Name:            _Z3fooi
 ; CHECK-NEXT:       - Index:           3
 ; CHECK-NEXT:         Name:            _start
 ; CHECK-NEXT: ...

lld/trunk/test/wasm/lto/weak-undefined.ll

 declare extern_weak i32 @foo()
 
 define void @_start() #0 {
 entry:
     %call2 = call i32 @foo()
     ret void
 }
 
-; CHECK: Name:            undefined function foo
+; CHECK: Name:            'undefined:foo'

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

 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            10818080800010828080800041021083808080004180808080004180808080006A0B
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            name
 ; CHECK-NEXT:     FunctionNames:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            __wasm_call_ctors
 ; CHECK-NEXT:       - Index:           1
-; CHECK-NEXT:         Name:            undefined function weakFunc1
+; CHECK-NEXT:         Name:            'undefined:weakFunc1'
 ; CHECK-NEXT:       - Index:           2
-; CHECK-NEXT:         Name:            undefined function weakFunc2
+; CHECK-NEXT:         Name:            'undefined:weakFunc2'
 ; CHECK-NEXT:       - Index:           3
-; CHECK-NEXT:         Name:            undefined function weakFunc3
+; CHECK-NEXT:         Name:            'undefined:weakFunc3'
 ; CHECK-NEXT:       - Index:           4
 ; CHECK-NEXT:         Name:            callWeakFuncs
 ; CHECK-NEXT: ...

lld/trunk/wasm/Driver.cpp

static StringRef getEntry(opt::InputArgList &Args, StringRef Default) {
   auto *Arg = Args.getLastArg(OPT_entry, OPT_no_entry);
   if (!Arg)
     return Default;
   if (Arg->getOption().getID() == OPT_no_entry)
     return "";
   return Arg->getValue();
 }
 
-static const uint8_t UnreachableFn[] = {
-    0x03 /* ULEB length */, 0x00 /* ULEB num locals */,
-    0x00 /* opcode unreachable */, 0x0b /* opcode end */
-};
-
-// For weak undefined functions, there may be "call" instructions that reference
-// the symbol. In this case, we need to synthesise a dummy/stub function that
-// will abort at runtime, so that relocations can still provided an operand to
-// the call instruction that passes Wasm validation.
-static void handleWeakUndefines() {
-  for (Symbol *Sym : Symtab->getSymbols()) {
-    if (!Sym->isUndefWeak())
-      continue;
-
-    const WasmSignature *Sig = nullptr;
-
-    if (auto *FuncSym = dyn_cast<FunctionSymbol>(Sym)) {
-      // It is possible for undefined functions not to have a signature (eg. if
-      // added via "--undefined"), but weak undefined ones do have a signature.
-      assert(FuncSym->Signature);
-      Sig = FuncSym->Signature;
-    } else if (auto *LazySym = dyn_cast<LazySymbol>(Sym)) {
-      // Lazy symbols may not be functions and therefore can have a null
-      // signature.
-      Sig = LazySym->Signature;
-    }
-
-    if (!Sig)
-      continue;
-
-
-    // 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);
-    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);
-  }
-}
-
 // Some Config members do not directly correspond to any particular
 // command line options, but computed based on other Config values.
 // This function initialize such members. See Config.h for the details
 // of these values.
 static void setConfigs(opt::InputArgList &Args) {
   Config->AllowUndefined = Args.hasArg(OPT_allow_undefined);
   Config->CompressRelocations = Args.hasArg(OPT_compress_relocations);
   Config->Demangle = Args.hasFlag(OPT_demangle, OPT_no_demangle, true);
void LinkerDriver::link(ArrayRef<const char *> ArgsArr) {
   // This compiles bitcode files into real object files.
   Symtab->addCombinedLTOObject();
   if (errorCount())
     return;
 
   // Add synthetic dummies for weak undefined functions.  Must happen
   // after LTO otherwise functions may not yet have signatures.
   if (!Config->Relocatable)
-    handleWeakUndefines();
+    Symtab->handleWeakUndefines();
 
   if (EntrySym)
     EntrySym->setHidden(false);
 
   if (errorCount())
     return;
 
   // Do size optimizations: garbage collection
   markLive();
 
   // Write the result to the file.
   writeResult();
 }

lld/trunk/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);
 
+  void handleWeakUndefines();
+
 private:
-  std::pair<Symbol *, bool> insert(StringRef Name, InputFile *File);
+  std::pair<Symbol *, bool> insert(StringRef Name, const InputFile *File);
   std::pair<Symbol *, bool> insertName(StringRef Name);
 
+  InputFunction *replaceWithUnreachable(Symbol *Sym, const WasmSignature &Sig,
+                                        StringRef DebugName);
+
   // Maps symbol names to index into the SymVector.  -1 means that symbols
   // is to not yet in the vector but it should have tracing enabled if it is
   // ever added.
   llvm::DenseMap<llvm::CachedHashStringRef, int> SymMap;
   std::vector<Symbol *> SymVector;
 
   llvm::DenseSet<llvm::CachedHashStringRef> Comdats;
 

lld/trunk/wasm/SymbolTable.cpp

std::pair<Symbol *, bool> SymbolTable::insertName(StringRef Name) {
 
   Symbol *Sym = reinterpret_cast<Symbol *>(make<SymbolUnion>());
   Sym->IsUsedInRegularObj = false;
   Sym->Traced = Trace;
   SymVector.emplace_back(Sym);
   return {Sym, true};
 }
 
-std::pair<Symbol *, bool> SymbolTable::insert(StringRef Name, InputFile *File) {
+std::pair<Symbol *, bool> SymbolTable::insert(StringRef Name,
+                                              const InputFile *File) {
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insertName(Name);
 
   if (!File || File->kind() == InputFile::ObjectKind)
     S->IsUsedInRegularObj = true;
 
   return {S, WasInserted};
bool SymbolTable::addComdat(StringRef Name) {
   return Comdats.insert(CachedHashStringRef(Name)).second;
 }
 
 // Set a flag for --trace-symbol so that we can print out a log message
 // if a new symbol with the same name is inserted into the symbol table.
 void SymbolTable::trace(StringRef Name) {
   SymMap.insert({CachedHashStringRef(Name), -1});
 }
+
+static const uint8_t UnreachableFn[] = {
+    0x03 /* ULEB length */, 0x00 /* ULEB num locals */,
+    0x00 /* opcode unreachable */, 0x0b /* opcode end */
+};
+
+// Replace the given symbol body with an unreachable function.
+// This is used by handleWeakUndefines in order to generate a callable
+// equivalent of an undefined function.
+InputFunction *SymbolTable::replaceWithUnreachable(Symbol *Sym,
+                                                   const WasmSignature &Sig,
+                                                   StringRef DebugName) {
+  auto *Func = make<SyntheticFunction>(Sig, Sym->getName(), DebugName);
+  Func->setBody(UnreachableFn);
+  SyntheticFunctions.emplace_back(Func);
+  replaceSymbol<DefinedFunction>(Sym, Sym->getName(), Sym->getFlags(), nullptr, Func);
+  return Func;
+}
+
+// For weak undefined functions, there may be "call" instructions that reference
+// the symbol. In this case, we need to synthesise a dummy/stub function that
+// will abort at runtime, so that relocations can still provided an operand to
+// the call instruction that passes Wasm validation.
+void SymbolTable::handleWeakUndefines() {
+  for (Symbol *Sym : getSymbols()) {
+    if (!Sym->isUndefWeak())
+      continue;
+
+    const WasmSignature *Sig = nullptr;
+
+    if (auto *FuncSym = dyn_cast<FunctionSymbol>(Sym)) {
+      // It is possible for undefined functions not to have a signature (eg. if
+      // added via "--undefined"), but weak undefined ones do have a signature.
+      assert(FuncSym->Signature);
+      Sig = FuncSym->Signature;
+    } else if (auto *LazySym = dyn_cast<LazySymbol>(Sym)) {
+      // Lazy symbols may not be functions and therefore can have a null
+      // signature.
+      Sig = LazySym->Signature;
+    }
+
+    if (!Sig)
+      continue;
+
+    // Add a synthetic dummy for weak undefined functions.  These dummies will
+    // be GC'd if not used as the target of any "call" instructions.
+    StringRef DebugName = Saver.save("undefined:" + toString(*Sym));
+    InputFunction* Func = replaceWithUnreachable(Sym, *Sig, DebugName);
+    // 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);
+    // Hide our dummy to prevent export.
+    Sym->setHidden(true);
+  }
+}

lld/trunk/wasm/Symbols.h

public:
   }
 
   // Returns the symbol name.
   StringRef getName() const { return Name; }
 
   // Returns the file from which this symbol was created.
   InputFile *getFile() const { return File; }
 
+  uint32_t getFlags() const { return Flags; }
+
   InputChunk *getChunk() const;
 
   // Indicates that the section or import for this symbol will be included in
   // the final image.
   bool isLive() const;
 
   // Marks the symbol's InputChunk as Live, so that it will be included in the
   // final image.