[WebAssembly] Handle weak undefined functions with a synthetic stub
This error case is described in Linking.md. The operand for call requires
generation of a synthetic stub.
Differential Revision: https://reviews.llvm.org/D44028
llvm-svn: 327151
diff --git a/lld/wasm/Driver.cpp b/lld/wasm/Driver.cpp
index c3f53e5..98d1f5d 100644
--- a/lld/wasm/Driver.cpp
+++ b/lld/wasm/Driver.cpp
@@ -215,6 +215,44 @@
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->isUndefined() || !Sym->isWeak())
+ continue;
+ auto *FuncSym = dyn_cast<FunctionSymbol>(Sym);
+ if (!FuncSym)
+ continue;
+
+ // 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->getFunctionType());
+ const WasmSignature &Sig = *FuncSym->getFunctionType();
+
+ // 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 StubName =
+ Saver.save("undefined function " + toString(*Sym, false));
+ SyntheticFunction *Func = make<SyntheticFunction>(Sig, StubName);
+ 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);
+ }
+}
+
void LinkerDriver::link(ArrayRef<const char *> ArgsArr) {
WasmOptTable Parser;
opt::InputArgList Args = Parser.parse(ArgsArr.slice(1));
@@ -326,6 +364,10 @@
for (InputFile *F : Files)
Symtab->addFile(F);
+ // Add synthetic dummies for weak undefined functions.
+ if (!Config->Relocatable)
+ handleWeakUndefines();
+
// Make sure we have resolved all symbols.
if (!Config->Relocatable && !Config->AllowUndefined) {
Symtab->reportRemainingUndefines();
diff --git a/lld/wasm/InputFiles.cpp b/lld/wasm/InputFiles.cpp
index 2c65c7b..12ee9ec 100644
--- a/lld/wasm/InputFiles.cpp
+++ b/lld/wasm/InputFiles.cpp
@@ -65,14 +65,8 @@
uint32_t ObjFile::calcNewValue(const WasmRelocation &Reloc) const {
switch (Reloc.Type) {
case R_WEBASSEMBLY_TABLE_INDEX_I32:
- case R_WEBASSEMBLY_TABLE_INDEX_SLEB: {
- // The null case is possible, if you take the address of a weak function
- // that's simply not supplied.
- FunctionSymbol *Sym = getFunctionSymbol(Reloc.Index);
- if (Sym->hasTableIndex())
- return Sym->getTableIndex();
- return 0;
- }
+ case R_WEBASSEMBLY_TABLE_INDEX_SLEB:
+ return getFunctionSymbol(Reloc.Index)->getTableIndex();
case R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
case R_WEBASSEMBLY_MEMORY_ADDR_I32:
case R_WEBASSEMBLY_MEMORY_ADDR_LEB:
diff --git a/lld/wasm/MarkLive.cpp b/lld/wasm/MarkLive.cpp
index 22211c1..9b72697 100644
--- a/lld/wasm/MarkLive.cpp
+++ b/lld/wasm/MarkLive.cpp
@@ -73,8 +73,25 @@
InputChunk *C = Q.pop_back_val();
for (const WasmRelocation Reloc : C->getRelocations()) {
- if (Reloc.Type != R_WEBASSEMBLY_TYPE_INDEX_LEB)
- Enqueue(C->File->getSymbol(Reloc.Index));
+ if (Reloc.Type == R_WEBASSEMBLY_TYPE_INDEX_LEB)
+ continue;
+ Symbol *Sym = C->File->getSymbol(Reloc.Index);
+
+ // If the function has been assigned the special index zero in the table,
+ // the relocation doesn't pull in the function body, since the function
+ // won't actually go in the table (the runtime will trap attempts to call
+ // that index, since we don't use it). A function with a table index of
+ // zero is only reachable via "call", not via "call_indirect". The stub
+ // functions used for weak-undefined symbols have this behaviour (compare
+ // equal to null pointer, only reachable via direct call).
+ if (Reloc.Type == R_WEBASSEMBLY_TABLE_INDEX_SLEB ||
+ Reloc.Type == R_WEBASSEMBLY_TABLE_INDEX_I32) {
+ FunctionSymbol *FuncSym = cast<FunctionSymbol>(Sym);
+ if (FuncSym->hasTableIndex() && FuncSym->getTableIndex() == 0)
+ continue;
+ }
+
+ Enqueue(Sym);
}
}
diff --git a/lld/wasm/Symbols.cpp b/lld/wasm/Symbols.cpp
index 742c887..b1bf9b3 100644
--- a/lld/wasm/Symbols.cpp
+++ b/lld/wasm/Symbols.cpp
@@ -180,10 +180,10 @@
void LazySymbol::fetch() { cast<ArchiveFile>(File)->addMember(&ArchiveSymbol); }
-std::string lld::toString(const wasm::Symbol &Sym) {
+std::string lld::toString(const wasm::Symbol &Sym, bool QuoteDemangled) {
if (Config->Demangle)
if (Optional<std::string> S = demangleItanium(Sym.getName()))
- return "`" + *S + "'";
+ return QuoteDemangled ? ("`" + *S + "'") : *S;
return Sym.getName();
}
diff --git a/lld/wasm/Symbols.h b/lld/wasm/Symbols.h
index 76a7417..92acabb 100644
--- a/lld/wasm/Symbols.h
+++ b/lld/wasm/Symbols.h
@@ -312,7 +312,7 @@
} // namespace wasm
// Returns a symbol name for an error message.
-std::string toString(const wasm::Symbol &Sym);
+std::string toString(const wasm::Symbol &Sym, bool QuoteDemangled = true);
std::string toString(wasm::Symbol::Kind Kind);
std::string toString(WasmSymbolType Type);