[lld][WebAssembly] Allow symbols with explict import names to be undefined at link time.

[merge_guards_bot]

Unit tests: unknown.

clang-tidy: unknown.

clang-format: unknown.

Build artifacts: CMakeCache.txt, console-log.txt

Pre-merge checks is in beta. Report issue. Please join beta or enable it for your project.

[sbc100]

• add docs

[sbc100]

typo

[sunfish]

Looks good, with the clang-format lint fixed :-).

[sbc100]

• clang-format

lld/docs/WebAssembly.rst

 mismatches: it can simply error-out or it can create stub functions that will
 trap at runtime (functions that contain only an ``unreachable`` instruction)
 and use these stub functions at the otherwise invalid call sites.
 
 The default behaviour is to generate these stub function and to produce
 a warning.  The ``--fatal-warnings`` flag can be used to disable this behaviour
 and error out if mismatched are found.
 
-Imports and Exports
-~~~~~~~~~~~~~~~~~~~
+Exports
+~~~~~~~
 
 When building a shared library any symbols marked as ``visibility=default`` will
 be exported.
 
 When building an executable, only the entry point (``_start``) and symbols with
 the ``WASM_SYMBOL_EXPORTED`` flag are exported by default.  In LLVM the
 ``WASM_SYMBOL_EXPORTED`` flag is set by the ``wasm-export-name`` attribute which
 in turn can be set using ``__attribute__((export_name))`` clang attribute.
 
 In addition, symbols can be exported via the linker command line using
 ``--export``.
 
 Finally, just like with native ELF linker the ``--export-dynamic`` flag can be
 used to export symbols in the executable which are marked as
 ``visibility=default``.
 
+Imports
+~~~~~~~
+
+By default no undefined symbols are allowed in the final binary.  The flag
+``--allow-undefined`` results in a WebAssembly import being defined for each
+undefined symbol.  It is then up to the runtime to provide such symbols.
+
+Alternativly symbols can be marked in the source code as with the
+``import_name`` and/or ``import_module`` clang attributes which signals that
+they are expected to be undefined at static link time.
+
 Garbage Collection
 ~~~~~~~~~~~~~~~~~~
 
 Since WebAssembly is designed with size in mind the linker defaults to
 ``--gc-sections`` which means that all unused functions and data segments will
 be stripped from the binary.
 
 The symbols which are preserved by default are:

lld/test/wasm/import-name.ll

 ; RUN: llc -filetype=obj %s -o %t.o
-; RUN: wasm-ld --allow-undefined -o %t.wasm %t.o
+; RUN: wasm-ld -o %t.wasm %t.o
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 target triple = "wasm32-unknown-unknown"
 
 declare void @f0() #0
 
 define void @_start() {
     call void @f0()

lld/wasm/Relocations.cpp

 static bool allowUndefined(const Symbol* sym) {
   // Historically --allow-undefined doesn't work for data symbols since we don't
   // have any way to represent these as imports in the final binary.  The idea
   // behind allowing undefined symbols is to allow importing these symbols from
   // the embedder and we can't do this for data symbols (at least not without
   // compiling with -fPIC)
   if (isa<DataSymbol>(sym))
     return false;
+  // Undefined functions with explicit import name are allowed to be undefined
+  // at link time.
+  if (auto *F = dyn_cast<UndefinedFunction>(sym))
+    if (F->importName)
+      return true;
   return (config->allowUndefined ||
           config->allowUndefinedSymbols.count(sym->getName()) != 0);
 }
 
 static void reportUndefined(const Symbol* sym) {
   assert(sym->isUndefined());
   assert(!sym->isWeak());
   if (!allowUndefined(sym))