[lld][WebAssembly] Implement --unresolved-symbols

[sbc100]

Summary

This is a more full featured version of --allow-undefined.
The semantics of the different methods are as follows:

report-all:

                                                                      
Report all unresolved symbols.  This is the default.  Normally the linker
will generate an error message for each reported unresolved symbol but the 
option `--warn-unresolved-symbols` can change this to a warning.

ignore-all:

                                                                      
Resolve all undefined symbols to zero.  For data and function addresses
this is trivial.  For direct function calls, the linker will generate a
trapping stub function in place of the undefined function.

import-functions:

                                                                      
Generate WebAssembly imports for any undefined functions.  Undefined data
symbols are resolved to zero as in `ignore-all`.  This corresponds the

The plan is to followup with a new mode called import-all which allows
for statically linked binaries to refer to both data and functions
symbols from the embedder.

[sbc100]

rebase

[sbc100]

• typos

[sbc100]

remove some tracing

[sbc100]

• cleanup

[sbc100]

Downstream emscripten issue: https://github.com/emscripten-core/emscripten/issues/12682
Design doc: https://docs.google.com/document/d/1viN3qTS5QzeDP7NR0pGg9D5JuuOrQzsORumMswYGpsA/edit?resourcekey=0-2Rnysxch2EuXNT3cvoD1MA

[MaskRay]

In ELF, --unresolved-symbols= sets --[no-]allow-shlib-undefined and -z (un)defs simultaneously.

• --[no-]allow-shlib-undefined: whether an unresolved undefined symbol from a shared object should be errored
• -z (un)defs: whether an unresolved undefined symbol from a regular object should be errored.

Does the wasm usage fit well in the existing practice?

[sbc100]

In D79248#2396409, @MaskRay wrote:

In ELF, --unresolved-symbols= sets --[no-]allow-shlib-undefined and -z (un)defs simultaneously.

• --[no-]allow-shlib-undefined: whether an unresolved undefined symbol from a shared object should be errored
• -z (un)defs: whether an unresolved undefined symbol from a regular object should be errored.

Does the wasm usage fit well in the existing practice?

The support for shared libraries in wasm-ld, and indeed the entire PIC ABI, is experimental (in fact, it will warn until you also pass --experimental-pic).

In particular, support for linking against shared libraries does not yet

In D79248#2396409, @MaskRay wrote:

In ELF, --unresolved-symbols= sets --[no-]allow-shlib-undefined and -z (un)defs simultaneously.

• --[no-]allow-shlib-undefined: whether an unresolved undefined symbol from a shared object should be errored
• -z (un)defs: whether an unresolved undefined symbol from a regular object should be errored.

Does the wasm usage fit well in the existing practice?

Yes. While we don't currently support either of those flags I believe the implementation of ignore-all here will match -z defs, so I think that adding support for -z (un)defs would be trivial if decide do add that flag in the future.

Regarding --[no-]allow-shlib-undefined, our shared library support is still experimental is rather limited. Using it currently requires the --experimental-pic flag.

BTW, looking at the ELF code I don't see --unresolved-symbols currently effecting `--allow-shlib-undefined.

In ELF/Driver.cpp we have:

config->allowShlibUndefined =                                                  
      args.hasFlag(OPT_allow_shlib_undefined, OPT_no_allow_shlib_undefined,                        
                   args.hasArg(OPT_shared));

And this doesn't look like it gets updated based on --unresolved-symbols.

[sbc100]

clang-tidy

[MaskRay]

In D79248#2397526, @sbc100 wrote:

In D79248#2396409, @MaskRay wrote:

In ELF, --unresolved-symbols= sets --[no-]allow-shlib-undefined and -z (un)defs simultaneously.

• --[no-]allow-shlib-undefined: whether an unresolved undefined symbol from a shared object should be errored
• -z (un)defs: whether an unresolved undefined symbol from a regular object should be errored.

Does the wasm usage fit well in the existing practice?

The support for shared libraries in wasm-ld, and indeed the entire PIC ABI, is experimental (in fact, it will warn until you also pass --experimental-pic).

In particular, support for linking against shared libraries does not yet

In D79248#2396409, @MaskRay wrote:

In ELF, --unresolved-symbols= sets --[no-]allow-shlib-undefined and -z (un)defs simultaneously.

• --[no-]allow-shlib-undefined: whether an unresolved undefined symbol from a shared object should be errored
• -z (un)defs: whether an unresolved undefined symbol from a regular object should be errored.

Does the wasm usage fit well in the existing practice?

Yes. While we don't currently support either of those flags I believe the implementation of ignore-all here will match -z defs, so I think that adding support for -z (un)defs would be trivial if decide do add that flag in the future.

Regarding --[no-]allow-shlib-undefined, our shared library support is still experimental is rather limited. Using it currently requires the --experimental-pic flag.

BTW, looking at the ELF code I don't see --unresolved-symbols currently effecting `--allow-shlib-undefined.

In ELF/Driver.cpp we have:

config->allowShlibUndefined =                                                  
      args.hasFlag(OPT_allow_shlib_undefined, OPT_no_allow_shlib_undefined,                        
                   args.hasArg(OPT_shared));

And this doesn't look like it gets updated based on --unresolved-symbols.

You are right. I knew this when investigating https://reviews.llvm.org/D67479#1667256
It is of very low priority because --unresolved-symbols= has too few use cases. Now wasm is adding this option I'll make the ELF side semantics clearer: D91510

[sbc100]

• -z (un)defs: whether an unresolved undefined symbol from a regular object should be errored.

I wish I had known about -z undefs when I first created wasm-ld.. I could have avoided inventing --allow-undefined

[sbc100]

@dschuff ptal.

[sbc100]

@MaskRay any objections to landing this?

BTW, how to you feel about being a reviewer on wasm-ld change in general.. if you are OK with it I could use a reviewer for my work here now that @Rui is less active.

[MaskRay]

In D79248#2400523, @sbc100 wrote:

@MaskRay any objections to landing this?

BTW, how to you feel about being a reviewer on wasm-ld change in general.. if you are OK with it I could use a reviewer for my work here now that @Rui is less active.

I don't mind but you'll throw out some learning resources on me.. (Persoanlly I do want to study more binary formats) For now I guess the best I can provide is how some options are used in ELF..

I just committed D91510 for ELF - personally I think the option is a bit awkward to use as it changes two bits simultaneously. There are more values in the wasm-lld version: do you think these values should all be mutually exclusive. If yes, this looks fine to me.

[sbc100]

In D79248#2400768, @MaskRay wrote:

In D79248#2400523, @sbc100 wrote:

@MaskRay any objections to landing this?

BTW, how to you feel about being a reviewer on wasm-ld change in general.. if you are OK with it I could use a reviewer for my work here now that @Rui is less active.

I don't mind but you'll throw out some learning resources on me.. (Persoanlly I do want to study more binary formats) For now I guess the best I can provide is how some options are used in ELF..

That sounds good. I can include wasm-specific people too in all my changes, but its good to have somebody with deep knowledge on the other linker take a look at changes like this for sure.

I just committed D91510 for ELF - personally I think the option is a bit awkward to use as it changes two bits simultaneously. There are more values in the wasm-lld version: do you think these values should all be mutually exclusive. If yes, this looks fine to me.

That an interesting point. Yes I am certainly imagining the various modes being mutually exclusive. Unlike ELF we have a couple of different ways that we want to be able to handle undefined symbols accepting various value here makes sense to me. Just doing -z undefs would not be enough in general as I would also want to know *how* to handle those undefined symbols. Once the followup to this change lands there will be 3 different ways to deal with them once we know we want to allow them.

[sbc100]

@dschuff can I get an final lgtm from you?

[dschuff]

lld/docs/WebAssembly.rst

97

"corresponds the" -> "corresponds to the"

98

The copy of this text in the commit message is missing this line.

lld/docs/WebAssembly.rst

.. option:: --compress-relocations
   Relocation targets in the code section are 5-bytes wide in order to
   potentially accommodate the largest LEB128 value.  This option will cause the
   linker to shrink the code section to remove any padding from the final
   output.  However because it affects code offset, this option is not
   compatible with outputting debug information.
 
 .. option:: --allow-undefined
 
-  Allow undefined symbols in linked binary.
+  Allow undefined symbols in linked binary.  This is the legacy
+  flag which corresponds to ``--unresolved-symbols=import-functions``.
+
+.. option:: --unresolved-symbols=<method>
+
+  This is a more full featured version of ``--allow-undefined``.
+  The semanatics of the different methods are as follows:
+
+  report-all:
+
+     Report all unresolved symbols.  This is the default.  Normally the linker
+     will generate an error message for each reported unresolved symbol but the
+     option ``--warn-unresolved-symbols`` can change this to a warning.
+
+  ignore-all:
+
+     Resolve all undefined symbols to zero.  For data and function addresses
+     this is trivial.  For direct function calls, the linker will generate a
+     trapping stub function in place of the undefined function.
+
+  import-functions:
+
+     Generate WebAssembly imports for any undefined functions.  Undefined data
+     symbols are resolved to zero as in ``ignore-all``.  This corresponds the
+     legacy ``--allow-undefined`` flag.
 
 .. option:: --import-memory
 
   Import memory from the environment.
 
 .. option:: --initial-memory=<value>
 
   Initial size of the linear memory. Default: static data size.

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

if.end:
   ret void
 }
 
 ; Ensure we have no data section.  If we do, would mean that hello_str was
 ; pulled out of the library.
 ; CHECK-NOT:  Type:            DATA
 ; CHECK-DATA: Type:            DATA
 
-; CHECK: Name: 'undefined:ret32'
+; CHECK: Name: 'undefined_weak:ret32'
 ; CHECK-NOT: Name: ret32

lld/test/wasm/cxx-mangling.ll

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

lld/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:foo'
+; CHECK: Name:            'undefined_weak:foo'

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

 ; CHECK-NEXT:         Body:            000B
 ; CHECK-NEXT:       - Index:           3
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            10808080800010818080800041021082808080004180808080004180808080006A0B
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            name
 ; CHECK-NEXT:     FunctionNames:
 ; CHECK-NEXT:       - Index:           0
-; CHECK-NEXT:         Name:            'undefined:weakFunc1'
+; CHECK-NEXT:         Name:            'undefined_weak:weakFunc1'
 ; CHECK-NEXT:       - Index:           1
-; CHECK-NEXT:         Name:            'undefined:weakFunc2'
+; CHECK-NEXT:         Name:            'undefined_weak:weakFunc2'
 ; CHECK-NEXT:       - Index:           2
-; CHECK-NEXT:         Name:            'undefined:weakFunc3'
+; CHECK-NEXT:         Name:            'undefined_weak:weakFunc3'
 ; CHECK-NEXT:       - Index:           3
 ; CHECK-NEXT:         Name:            callWeakFuncs
 ; CHECK-NEXT: ...

lld/test/wasm/unresolved-symbols.s

+# RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown %s -o %t1.o
+
+## Check that %t1.o contains undefined symbol undef.
+# RUN: not wasm-ld %t1.o -o /dev/null 2>&1 | \
+# RUN:   FileCheck -check-prefix=ERRUND %s
+# ERRUND: error: {{.*}}1.o: undefined symbol: undef
+
+## report-all is the default one. Check that we get the same error
+# RUN: not wasm-ld %t1.o -o /dev/null --unresolved-symbols=report-all 2>&1 | \
+# RUN:   FileCheck -check-prefix=ERRUND %s
+
+## Error out if unknown option value was set.
+# RUN: not wasm-ld %t1.o -o /dev/null --unresolved-symbols=xxx 2>&1 | \
+# RUN:   FileCheck -check-prefix=ERR1 %s
+# ERR1: unknown --unresolved-symbols value: xxx
+## Check alias.
+# RUN: not wasm-ld %t1.o -o /dev/null --unresolved-symbols xxx 2>&1 | \
+# RUN:   FileCheck -check-prefix=ERR1 %s
+
+## Ignore all should not produce error and should not produce
+# any imports.  It should create a stub function in the place of the missing
+# function symbol.
+# RUN: wasm-ld %t1.o -o %t2.wasm --unresolved-symbols=ignore-all
+# RUN: obj2yaml %t2.wasm | FileCheck -check-prefix=IGNORE %s
+# IGNORE-NOT: - Type:            IMPORT
+# IGNORE-NOT: - Type:            ELEM
+#
+#      IGNORE:  - Type:            CODE
+# IGNORE-NEXT:    Functions:
+# IGNORE-NEXT:      - Index:           0
+# IGNORE-NEXT:        Locals:          []
+# IGNORE-NEXT:        Body:            000B
+# IGNORE-NEXT:      - Index:           1
+# IGNORE-NEXT:        Locals:          []
+# IGNORE-NEXT:        Body:            1080808080001082808080001083808080000B
+# IGNORE-NEXT:      - Index:           2
+# IGNORE-NEXT:        Locals:          []
+# IGNORE-NEXT:        Body:            4180808080000F0B
+# IGNORE-NEXT:      - Index:           3
+# IGNORE-NEXT:        Locals:          []
+# IGNORE-NEXT:        Body:            4180808080000F0B
+#
+#      IGNORE:  - Type:            CUSTOM
+# IGNORE-NEXT:    Name:            name
+# IGNORE-NEXT:    FunctionNames:
+# IGNORE-NEXT:      - Index:           0
+# IGNORE-NEXT:        Name:            undefined
+# IGNORE-NEXT:      - Index:           1
+# IGNORE-NEXT:        Name:            _start
+# IGNORE-NEXT:      - Index:           2
+# IGNORE-NEXT:        Name:            get_data_addr
+# IGNORE-NEXT:      - Index:           3
+# IGNORE-NEXT:        Name:            get_func_addr
+
+## import-functions should not produce errors and should resolve in
+# imports for the missing functions but not the missing data symbols.
+# `--allow-undefined` should behave exactly the same.
+# RUN: wasm-ld %t1.o -o %t3.wasm --unresolved-symbols=import-functions
+# RUN: obj2yaml %t3.wasm | FileCheck -check-prefix=IMPORT %s
+#      IMPORT:  - Type:            IMPORT
+# IMPORT-NEXT:    Imports:
+# IMPORT-NEXT:      - Module:          env
+# IMPORT-NEXT:        Field:           undef
+# IMPORT-NEXT:        Kind:            FUNCTION
+# IMPORT-NEXT:        SigIndex:        0
+# IMPORT-NEXT:  - Type:            FUNCTION
+
+## Do not report undefines if linking relocatable.
+# RUN: wasm-ld -r %t1.o -o %t4.wasm --unresolved-symbols=report-all
+# RUN: llvm-readobj %t4.wasm > /dev/null 2>&1
+
+.globl _start
+_start:
+    .functype _start () -> ()
+    call undef
+    call get_data_addr
+    call get_func_addr
+    end_function
+
+.globl get_data_addr
+get_data_addr:
+    .functype get_data_addr () -> (i32)
+    i32.const undef_data
+    return
+    end_function
+
+.globl get_func_addr
+get_func_addr:
+    .functype get_func_addr () -> (i32)
+    i32.const undef
+    return
+    end_function
+
+.functype undef () -> ()

lld/test/wasm/weak-undefined.ll

 define i32* @get_address_of_global_var() #0 {
   ret i32* @global_var
 }
 
 define void @_start() #0 {
 entry:
     %call1 = call i32* @get_address_of_global_var()
     %call2 = call i8* @get_address_of_foo()
+    call i32 @foo()
     ret void
 }
 
 ; CHECK:      --- !WASM
 ; CHECK-NEXT: FileHeader:
 ; CHECK-NEXT:   Version:         0x00000001
 ; CHECK-NEXT: Sections:
 ; CHECK-NEXT:   - Type:            TYPE
 ; CHECK-NEXT:     Signatures:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         ParamTypes:      []
 ; CHECK-NEXT:         ReturnTypes:
 ; CHECK-NEXT:           - I32
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         ParamTypes:      []
 ; CHECK-NEXT:         ReturnTypes:     []
 ; CHECK-NEXT:   - Type:            FUNCTION
-; CHECK-NEXT:     FunctionTypes:   [ 0, 0, 1 ]
+; CHECK-NEXT:     FunctionTypes:   [ 0, 0, 0, 1 ]
 ; CHECK-NEXT:   - Type:            TABLE
 ; CHECK-NEXT:     Tables:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         ElemType:        FUNCREF
 ; CHECK-NEXT:         Limits:
 ; CHECK-NEXT:           Flags:           [ HAS_MAX ]
 ; CHECK-NEXT:           Initial:         0x00000001
 ; CHECK-NEXT:           Maximum:         0x00000001

 ; CHECK-NEXT:           Value:           66560
 ; 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:           2
+; CHECK-NEXT:         Index:           3
 ; CHECK-NEXT:   - Type:            CODE
 ; CHECK-NEXT:     Functions:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Locals:
-; CHECK-NEXT:         Body:            4180808080000B
+; CHECK-NEXT:         Body:            000B
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            4180808080000B
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Locals:
-; CHECK-NEXT:         Body:            1081808080001A1080808080001A0B
+; CHECK-NEXT:         Body:            4180808080000B
+; CHECK-NEXT:       - Index:           3
+; CHECK-NEXT:         Locals:
+; CHECK-NEXT:         Body:            1082808080001A1081808080001A1080808080001A0B
 ; CHECK-NEXT: ...

lld/wasm/Config.h

 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/BinaryFormat/Wasm.h"
 #include "llvm/Support/CachePruning.h"
 
 namespace lld {
 namespace wasm {
 
+// For --unresolved-symbols.
+// The `ImportFuncs` mode is an additional mode that corresponds to the
+// --allow-undefined flag which turns undefined functions in imports
+// as opposed ed to Ignore or Warn which turn them into unreachables.
+enum class UnresolvedPolicy { ReportError, Warn, Ignore, ImportFuncs };
+
 // This struct contains the global configuration for the linker.
 // Most fields are direct mapping from the command line options
 // and such fields have the same name as the corresponding options.
 // Most fields are initialized by the driver.
 struct Configuration {
-  bool allowUndefined;
   bool bsymbolic;
   bool checkFeatures;
   bool compressRelocations;
   bool demangle;
   bool disableVerify;
   bool experimentalPic;
   bool emitRelocs;
   bool exportAll;
struct Configuration {
   uint64_t globalBase;
   uint64_t initialMemory;
   uint64_t maxMemory;
   uint64_t zStackSize;
   unsigned ltoPartitions;
   unsigned ltoo;
   unsigned optimize;
   llvm::StringRef thinLTOJobs;
+  UnresolvedPolicy unresolvedSymbols;
 
   llvm::StringRef entry;
   llvm::StringRef mapFile;
   llvm::StringRef outputFile;
   llvm::StringRef thinLTOCacheDir;
 
   llvm::StringSet<> allowUndefinedSymbols;
   llvm::StringSet<> exportedSymbols;

lld/wasm/Driver.cpp

if (args.hasArg(OPT_shared))
       return "__wasm_call_ctors";
     return "_start";
   }
   if (arg->getOption().getID() == OPT_no_entry)
     return "";
   return arg->getValue();
 }
 
+// Determines what we should do if there are remaining unresolved
+// symbols after the name resolution.
+static UnresolvedPolicy getUnresolvedSymbolPolicy(opt::InputArgList &args) {
+  UnresolvedPolicy errorOrWarn = args.hasFlag(OPT_error_unresolved_symbols,
+                                              OPT_warn_unresolved_symbols, true)
+                                     ? UnresolvedPolicy::ReportError
+                                     : UnresolvedPolicy::Warn;
+
+  if (auto *arg = args.getLastArg(OPT_unresolved_symbols)) {
+    StringRef s = arg->getValue();
+    if (s == "ignore-all")
+      return UnresolvedPolicy::Ignore;
+    if (s == "import-functions")
+      return UnresolvedPolicy::ImportFuncs;
+    if (s == "report-all")
+      return errorOrWarn;
+    error("unknown --unresolved-symbols value: " + s);
+  }
+
+  // Legacy --allow-undefined flag which is equivalent to
+  // --unresolve-symbols=ignore-all
+  if (args.hasArg(OPT_allow_undefined))
+    return UnresolvedPolicy::ImportFuncs;
+
+  return errorOrWarn;
+}
+
 // Initializes Config members by the command line options.
 static void readConfigs(opt::InputArgList &args) {
-  config->allowUndefined = args.hasArg(OPT_allow_undefined);
   config->bsymbolic = args.hasArg(OPT_Bsymbolic);
   config->checkFeatures =
       args.hasFlag(OPT_check_features, OPT_no_check_features, true);
   config->compressRelocations = args.hasArg(OPT_compress_relocations);
   config->demangle = args.hasFlag(OPT_demangle, OPT_no_demangle, true);
   config->disableVerify = args.hasArg(OPT_disable_verify);
   config->emitRelocs = args.hasArg(OPT_emit_relocs);
   config->experimentalPic = args.hasArg(OPT_experimental_pic);
static void readConfigs(opt::InputArgList &args) {
   config->stripAll = args.hasArg(OPT_strip_all);
   config->stripDebug = args.hasArg(OPT_strip_debug);
   config->stackFirst = args.hasArg(OPT_stack_first);
   config->trace = args.hasArg(OPT_trace);
   config->thinLTOCacheDir = args.getLastArgValue(OPT_thinlto_cache_dir);
   config->thinLTOCachePolicy = CHECK(
       parseCachePruningPolicy(args.getLastArgValue(OPT_thinlto_cache_policy)),
       "--thinlto-cache-policy: invalid cache policy");
+  config->unresolvedSymbols = getUnresolvedSymbolPolicy(args);
   errorHandler().verbose = args.hasArg(OPT_verbose);
   LLVM_DEBUG(errorHandler().verbose = true);
 
   config->initialMemory = args::getInteger(args, OPT_initial_memory, 0);
   config->globalBase = args::getInteger(args, OPT_global_base, 1024);
   config->maxMemory = args::getInteger(args, OPT_max_memory, 0);
   config->zStackSize =
       args::getZOptionValue(args, OPT_z, "stack-size", WasmPageSize);
static void setConfigs() {
   if (config->isPic) {
     if (config->exportTable)
       error("-shared/-pie is incompatible with --export-table");
     config->importTable = true;
   }
 
   if (config->shared) {
     config->importMemory = true;
-    config->allowUndefined = true;
+    config->unresolvedSymbols = UnresolvedPolicy::ImportFuncs;
   }
 }
 
 // Some command line options or some combinations of them are not allowed.
 // This function checks for such errors.
 static void checkOptions(opt::InputArgList &args) {
   if (!config->stripDebug && !config->stripAll && config->compressRelocations)
     error("--compress-relocations is incompatible with output debug"
void LinkerDriver::link(ArrayRef<const char *> argsArr) {
   // Apply symbol renames for -wrap.
   if (!wrapped.empty())
     wrapSymbols(wrapped);
 
   for (auto *arg : args.filtered(OPT_export)) {
     Symbol *sym = symtab->find(arg->getValue());
     if (sym && sym->isDefined())
       sym->forceExport = true;
-    else if (!config->allowUndefined)
+    else if (config->unresolvedSymbols == UnresolvedPolicy::ReportError)
       error(Twine("symbol exported via --export not found: ") +
             arg->getValue());
+    else if (config->unresolvedSymbols == UnresolvedPolicy::Warn)
+      warn(Twine("symbol exported via --export not found: ") + arg->getValue());
   }
 
   if (!config->relocatable) {
     // Add synthetic dummies for weak undefined functions.  Must happen
     // after LTO otherwise functions may not yet have signatures.
     symtab->handleWeakUndefines();
   }
 

lld/wasm/Options.td

def compress_relocations: F<"compress-relocations">,
   HelpText<"Compress the relocation targets in the code section.">;
 
 defm demangle: B<"demangle",
     "Demangle symbol names",
     "Do not demangle symbol names">;
 
 def emit_relocs: F<"emit-relocs">, HelpText<"Generate relocations in output">;
 
+def error_unresolved_symbols: F<"error-unresolved-symbols">,
+  HelpText<"Report unresolved symbols as errors">;
+
 defm export_dynamic: B<"export-dynamic",
     "Put symbols in the dynamic symbol table",
     "Do not put symbols in the dynamic symbol table (default)">;
 
 def entry: S<"entry">, MetaVarName<"<entry>">,
   HelpText<"Name of entry point symbol">;
 
 def error_limit: J<"error-limit=">,
: Eq<"threads", "Number of threads. '1' disables multi-threading. By "
                     "default all available hardware threads are used">;
 
 def trace: F<"trace">, HelpText<"Print the names of the input files">;
 
 defm trace_symbol: Eq<"trace-symbol", "Trace references to symbols">;
 
 defm undefined: Eq<"undefined", "Force undefined symbol during linking">;
 
+defm unresolved_symbols:
+  Eq<"unresolved-symbols", "Determine how to handle unresolved symbols">;
+
 def v: Flag<["-"], "v">, HelpText<"Display the version number">;
 
 def verbose: F<"verbose">, HelpText<"Verbose mode">;
 
 def version: F<"version">, HelpText<"Display the version number and exit">;
 
-def z: JoinedOrSeparate<["-"], "z">, MetaVarName<"<option>">,
-  HelpText<"Linker option extensions">;
+def warn_unresolved_symbols: F<"warn-unresolved-symbols">,
+  HelpText<"Report unresolved symbols as warnings">;
 
 defm wrap: Eq<"wrap", "Use wrapper functions for symbol">,
   MetaVarName<"<symbol>=<symbol>">;
 
+def z: JoinedOrSeparate<["-"], "z">, MetaVarName<"<option>">,
+  HelpText<"Linker option extensions">;
+
 // The follow flags are unique to wasm
 
 def allow_undefined: F<"allow-undefined">,
   HelpText<"Allow undefined symbols in linked binary">;
 
 def allow_undefined_file: J<"allow-undefined-file=">,
   HelpText<"Allow symbols listed in <file> to be undefined in linked binary">;
 

lld/wasm/Relocations.cpp

 //===- Relocations.cpp ----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "Relocations.h"
 
 #include "InputChunks.h"
 #include "OutputSegment.h"
+#include "SymbolTable.h"
 #include "SyntheticSections.h"
 
 using namespace llvm;
 using namespace llvm::wasm;
 
 namespace lld {
 namespace wasm {
 
static bool allowUndefined(const Symbol* sym) {
   // Undefined functions and globals with explicit import name are allowed to be
   // undefined at link time.
   if (auto *f = dyn_cast<UndefinedFunction>(sym))
     if (f->importName)
       return true;
   if (auto *g = dyn_cast<UndefinedGlobal>(sym))
     if (g->importName)
       return true;
-  return (config->allowUndefined ||
-          config->allowUndefinedSymbols.count(sym->getName()) != 0);
+  if (auto *g = dyn_cast<UndefinedGlobal>(sym))
+    if (g->importName)
+      return true;
+  return config->allowUndefinedSymbols.count(sym->getName()) != 0;
 }
 
-static void reportUndefined(const Symbol* sym) {
-  assert(sym->isUndefined());
-  assert(!sym->isWeak());
-  if (!allowUndefined(sym))
+static void reportUndefined(Symbol *sym) {
+  if (!allowUndefined(sym)) {
+    switch (config->unresolvedSymbols) {
+    case UnresolvedPolicy::ReportError:
       error(toString(sym->getFile()) + ": undefined symbol: " + toString(*sym));
+      break;
+    case UnresolvedPolicy::Warn:
+      warn(toString(sym->getFile()) + ": undefined symbol: " + toString(*sym));
+      break;
+    case UnresolvedPolicy::Ignore:
+      if (auto *f = dyn_cast<UndefinedFunction>(sym)) {
+        if (!f->stubFunction) {
+          LLVM_DEBUG(dbgs()
+                     << "ignoring undefined symbol: " + toString(*sym) + "\n");
+          f->stubFunction = symtab->createUndefinedStub(*f->getSignature());
+          f->stubFunction->markLive();
+          f->setTableIndex(0);
+        }
+      }
+      break;
+    case UnresolvedPolicy::ImportFuncs:
+      break;
+    }
+  }
 }
 
 static void addGOTEntry(Symbol *sym) {
   if (requiresGOTAccess(sym))
     out.importSec->addGOTEntry(sym);
   else
     out.globalSec->addInternalGOTEntry(sym);
 }
if (config->isPic) {
           addGOTEntry(sym);
         break;
       }
     } else {
       // Report undefined symbols
       if (sym->isUndefined() && !config->relocatable && !sym->isWeak())
         reportUndefined(sym);
     }
-
   }
 }
 
 } // namespace wasm
 } // namespace lld

lld/wasm/SymbolTable.h

 
 #include "InputFiles.h"
 #include "LTO.h"
 #include "Symbols.h"
 #include "lld/Common/LLVM.h"
 #include "llvm/ADT/CachedHashString.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/Optional.h"
+#include "llvm/BinaryFormat/WasmTraits.h"
 
 namespace lld {
 namespace wasm {
 
 class InputSegment;
 
 // SymbolTable is a bucket of all known symbols, including defined,
 // undefined, or lazy symbols (the last one is symbols in archive
public:
   DefinedFunction *addSyntheticFunction(StringRef name, uint32_t flags,
                                         InputFunction *function);
   DefinedData *addOptionalDataSymbol(StringRef name, uint64_t value = 0);
   DefinedGlobal *addOptionalGlobalSymbols(StringRef name, uint32_t flags,
                                           InputGlobal *global);
 
   void handleSymbolVariants();
   void handleWeakUndefines();
+  DefinedFunction *createUndefinedStub(const WasmSignature &sig);
 
   std::vector<ObjFile *> objectFiles;
   std::vector<SharedFile *> sharedFiles;
   std::vector<BitcodeFile *> bitcodeFiles;
   std::vector<InputFunction *> syntheticFunctions;
   std::vector<InputGlobal *> syntheticGlobals;
 
 private:
   std::pair<Symbol *, bool> insert(StringRef name, const InputFile *file);
   std::pair<Symbol *, bool> insertName(StringRef name);
 
   bool getFunctionVariant(Symbol* sym, const WasmSignature *sig,
                           const InputFile *file, Symbol **out);
   InputFunction *replaceWithUnreachable(Symbol *sym, const WasmSignature &sig,
                                         StringRef debugName);
+  void replaceWithUndefined(Symbol *sym);
 
   // 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;
 
   // For certain symbols types, e.g. function symbols, we allow for multiple
   // variants of the same symbol with different signatures.
   llvm::DenseMap<llvm::CachedHashStringRef, std::vector<Symbol *>> symVariants;
+  llvm::DenseMap<WasmSignature, DefinedFunction *> stubFunctions;
 
   // Comdat groups define "link once" sections. If two comdat groups have the
   // same name, only one of them is linked, and the other is ignored. This set
   // is used to uniquify them.
   llvm::DenseSet<llvm::CachedHashStringRef> comdatGroups;
 
   // For LTO.
   std::unique_ptr<BitcodeCompiler> lto;
 };
 
 extern SymbolTable *symtab;
 
 } // namespace wasm
 } // namespace lld
 
 #endif

lld/wasm/SymbolTable.cpp

InputFunction *SymbolTable::replaceWithUnreachable(Symbol *sym,
                                                    StringRef debugName) {
   auto *func = make<SyntheticFunction>(sig, sym->getName(), debugName);
   func->setBody(unreachableFn);
   syntheticFunctions.emplace_back(func);
   // Mark new symbols as local. For relocatable output we don't want them
   // to be exported outside the object file.
   replaceSymbol<DefinedFunction>(sym, debugName, WASM_SYMBOL_BINDING_LOCAL,
                                  nullptr, func);
+  // 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);
   return func;
 }
 
+void SymbolTable::replaceWithUndefined(Symbol *sym) {
+  // 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_weak:" + toString(*sym));
+  replaceWithUnreachable(sym, *sym->getSignature(), debugName);
+  // Hide our dummy to prevent export.
+  sym->setHidden(true);
+}
+
 // 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 = sym->getSignature();
-    if (!sig) {
-      // It is possible for undefined functions not to have a signature (eg. if
-      // added via "--undefined"), but weak undefined ones do have a signature.
-      // Lazy symbols may not be functions and therefore Sig can still be null
-      // in some circumstance.
+    if (sym->isUndefWeak()) {
+      if (sym->getSignature()) {
+        replaceWithUndefined(sym);
+      } else {
+        // It is possible for undefined functions not to have a signature (eg.
+        // if added via "--undefined"), but weak undefined ones do have a
+        // signature.  Lazy symbols may not be functions and therefore Sig can
+        // still be null in some circumstance.
         assert(!isa<FunctionSymbol>(sym));
-      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);
     }
   }
+}
+
+DefinedFunction *SymbolTable::createUndefinedStub(const WasmSignature &sig) {
+  if (stubFunctions.count(sig))
+    return stubFunctions[sig];
+  LLVM_DEBUG(dbgs() << "createUndefinedStub: " << toString(sig) << "\n");
+  auto *sym = reinterpret_cast<DefinedFunction *>(make<SymbolUnion>());
+  sym->isUsedInRegularObj = true;
+  sym->canInline = true;
+  sym->traced = false;
+  sym->forceExport = false;
+  sym->signature = &sig;
+  replaceSymbol<DefinedFunction>(
+      sym, "undefined_stub", WASM_SYMBOL_VISIBILITY_HIDDEN, nullptr, nullptr);
+  replaceWithUnreachable(sym, sig, "undefined_stub");
+  stubFunctions[sig] = sym;
+  return sym;
+}
 
 static void reportFunctionSignatureMismatch(StringRef symName,
                                             FunctionSymbol *a,
                                             FunctionSymbol *b, bool isError) {
   std::string msg = ("function signature mismatch: " + symName +
                      "\n>>> defined as " + toString(*a->signature) + " in " +
                      toString(a->getFile()) + "\n>>> defined as " +
                      toString(*b->signature) + " in " + toString(b->getFile()))

lld/wasm/Symbols.h

UndefinedFunction(StringRef name, llvm::Optional<StringRef> importName,
         isCalledDirectly(isCalledDirectly) {}
 
   static bool classof(const Symbol *s) {
     return s->kind() == UndefinedFunctionKind;
   }
 
   llvm::Optional<StringRef> importName;
   llvm::Optional<StringRef> importModule;
+  DefinedFunction *stubFunction = nullptr;
   bool isCalledDirectly;
 };
 
 // Section symbols for output sections are different from those for input
 // section.  These are generated by the linker and point the OutputSection
 // rather than an InputSection.
 class OutputSectionSymbol : public Symbol {
 public:
union SymbolUnion {
   alignas(UndefinedData) char g[sizeof(UndefinedData)];
   alignas(UndefinedGlobal) char h[sizeof(UndefinedGlobal)];
   alignas(SectionSymbol) char i[sizeof(SectionSymbol)];
 };
 
 // It is important to keep the size of SymbolUnion small for performance and
 // memory usage reasons. 96 bytes is a soft limit based on the size of
 // UndefinedFunction on a 64-bit system.
-static_assert(sizeof(SymbolUnion) <= 112, "SymbolUnion too large");
+static_assert(sizeof(SymbolUnion) <= 120, "SymbolUnion too large");
 
 void printTraceSymbol(Symbol *sym);
 void printTraceSymbolUndefined(StringRef name, const InputFile* file);
 
 template <typename T, typename... ArgT>
 T *replaceSymbol(Symbol *s, ArgT &&... arg) {
   static_assert(std::is_trivially_destructible<T>(),
                 "Symbol types must be trivially destructible");

lld/wasm/Symbols.cpp

const WasmSignature *Symbol::getSignature() const {
   if (auto *l = dyn_cast<LazySymbol>(this))
     return l->signature;
   return nullptr;
 }
 
 InputChunk *Symbol::getChunk() const {
   if (auto *f = dyn_cast<DefinedFunction>(this))
     return f->function;
+  if (auto *f = dyn_cast<UndefinedFunction>(this))
+    if (f->stubFunction)
+      return f->stubFunction->function;
   if (auto *d = dyn_cast<DefinedData>(this))
     return d->segment;
   return nullptr;
 }
 
 bool Symbol::isDiscarded() const {
   if (InputChunk *c = getChunk())
     return c->discarded;

 
 bool Symbol::isNoStrip() const {
   return flags & WASM_SYMBOL_NO_STRIP;
 }
 
 uint32_t FunctionSymbol::getFunctionIndex() const {
   if (auto *f = dyn_cast<DefinedFunction>(this))
     return f->function->getFunctionIndex();
+  if (auto *u = dyn_cast<UndefinedFunction>(this)) {
+    if (u->stubFunction) {
+      return u->stubFunction->getFunctionIndex();
+    }
+  }
   assert(functionIndex != INVALID_INDEX);
   return functionIndex;
 }
 
 void FunctionSymbol::setFunctionIndex(uint32_t index) {
   LLVM_DEBUG(dbgs() << "setFunctionIndex " << name << " -> " << index << "\n");
   assert(functionIndex == INVALID_INDEX);
   functionIndex = index;

lld/wasm/Writer.cpp

for (auto &feature : required.keys()) {
       if (!objectFeatures.count(std::string(feature)))
         error(Twine("Missing target feature '") + feature + "' in " + fileName +
               ", required by " + required[feature] +
               ". Use --no-check-features to suppress.");
     }
   }
 }
 
+static bool shouldImport(Symbol *sym) {
+  // We don't generate imports for data symbols. They however can be imported
+  // as GOT entries.
+  if (isa<DataSymbol>(sym))
+    return false;
+
+  if (config->relocatable ||
+      config->unresolvedSymbols == UnresolvedPolicy::ImportFuncs)
+    return true;
+  if (config->allowUndefinedSymbols.count(sym->getName()) != 0)
+    return true;
+  if (auto *G = dyn_cast<UndefinedGlobal>(sym))
+    return G->importName.hasValue();
+  if (auto *F = dyn_cast<UndefinedFunction>(sym))
+    return F->importName.hasValue();
+
+  return false;
+}
+
 void Writer::calculateImports() {
   for (Symbol *sym : symtab->getSymbols()) {
     if (!sym->isUndefined())
       continue;
     if (sym->isWeak() && !config->relocatable)
       continue;
     if (!sym->isLive())
       continue;
     if (!sym->isUsedInRegularObj)
       continue;
-    // We don't generate imports for data symbols. They however can be imported
-    // as GOT entries.
-    if (isa<DataSymbol>(sym))
-      continue;
-
+    if (shouldImport(sym)) {
       LLVM_DEBUG(dbgs() << "import: " << sym->getName() << "\n");
       out.importSec->addImport(sym);
     }
   }
+}
 
 void Writer::calculateExports() {
   if (config->relocatable)
     return;
 
   if (!config->relocatable && !config->importMemory)
     out.exportSec->exports.push_back(
         WasmExport{"memory", WASM_EXTERNAL_MEMORY, 0});