[lld][WebAssembly] Add support for --require-defined linker flag

[sbc100]

Summary

This option is the same as option --undefined except that if symbol is
not defined in the output file then the linker will issue an error and
exit.

[sbc100]

• add test

lld/test/wasm/driver.s

 
 ## Note: in GNU ld, --fatal-warning still leads to a warning.
 # RUN: not wasm-ld %t.o -z foo --fatal-warnings 2>&1 | FileCheck --check-prefix=ERR10-FATAL %s
 # ERR10-FATAL: error: unknown -z value: foo
 
 ## stack-size without an = is also an error
 # RUN: not wasm-ld %t.o -z stack-size 2>&1 | FileCheck -check-prefix=ERR11 %s
 # ERR11: unknown -z value: stack-size
+
+# RUN: not wasm-ld %t.o --require-defined=foo -o /dev/null 2>&1 | FileCheck -check-prefix=REQUIRE-DEFINED %s
+# REQUIRE-DEFINED: wasm-ld: error: required symbol `foo` not defined

lld/wasm/Config.h

struct Configuration {
   llvm::StringRef entry;
   llvm::StringRef mapFile;
   llvm::StringRef outputFile;
   llvm::StringRef thinLTOCacheDir;
 
   llvm::StringSet<> allowUndefinedSymbols;
   llvm::StringSet<> exportedSymbols;
   std::vector<llvm::StringRef> requiredExports;
+  std::vector<llvm::StringRef> requireDefined;
   std::vector<llvm::StringRef> searchPaths;
   llvm::CachePruningPolicy thinLTOCachePolicy;
   llvm::Optional<std::vector<std::string>> features;
 
   // The following config options do not directly correspond to any
   // particular command line options.
 
   // True if we are creating position-independent code.

lld/wasm/Driver.cpp

void LinkerDriver::linkerMain(ArrayRef<const char *> argsArr) {
 
   // Handle --trace-symbol.
   for (auto *arg : args.filtered(OPT_trace_symbol))
     symtab->trace(arg->getValue());
 
   for (auto *arg : args.filtered(OPT_export_if_defined))
     config->exportedSymbols.insert(arg->getValue());
 
+  for (auto *arg : args.filtered(OPT_require_defined))
+    config->requireDefined.push_back(arg->getValue());
+
   for (auto *arg : args.filtered(OPT_export)) {
     config->exportedSymbols.insert(arg->getValue());
     config->requiredExports.push_back(arg->getValue());
   }
 
   createSyntheticSymbols();
 
   // Add all files to the symbol table. This will add almost all

lld/wasm/Options.td

def NAME # _eq: Joined<["--", "-"], name # "=">, Alias<!cast<Separate>(NAME)>,
     HelpText<help>;
 }
 
 multiclass B<string name, string help1, string help2> {
   def NAME: Flag<["--", "-"], name>, HelpText<help1>;
   def no_ # NAME: Flag<["--", "-"], "no-" # name>, HelpText<help2>;
 }
 
+defm require_defined: Eq<"require-defined",
+     "Force symbol to be added to symbol table as an undefined one">;
+
 // The following flags are shared with the ELF linker
 def Bsymbolic: F<"Bsymbolic">, HelpText<"Bind defined symbols locally">;
 
 defm color_diagnostics: B<"color-diagnostics",
   "Alias for --color-diagnostics=always",
   "Alias for --color-diagnostics=never">;
 def color_diagnostics_eq: J<"color-diagnostics=">,
   HelpText<"Use colors in diagnostics (default: auto)">,

lld/wasm/Writer.cpp

void Writer::run() {
   for (auto &pair : config->exportedSymbols) {
     Symbol *sym = symtab->find(pair.first());
     if (sym && sym->isDefined())
       sym->forceExport = true;
   }
 
   // Delay reporting error about explicit exports until after
   // addStartStopSymbols which can create optional symbols.
+  for (auto &name : config->requireDefined) {
+    Symbol *sym = symtab->find(name);
+    if (!sym || !sym->isDefined()) {
+      error(Twine("required symbol `") + name + "` not defined");
+    }
+  }
+
   for (auto &name : config->requiredExports) {
     Symbol *sym = symtab->find(name);
     if (!sym || !sym->isDefined()) {
       if (config->unresolvedSymbols == UnresolvedPolicy::ReportError)
         error(Twine("symbol exported via --export not found: ") + name);
       if (config->unresolvedSymbols == UnresolvedPolicy::Warn)
         warn(Twine("symbol exported via --export not found: ") + name);
     }