[lld][WebAssembly] Add --unresolved-symbols=import-dynamic

[sbc100]

Summary

This is a new mode for handling unresolved symbols that allows all
symbols to be imported in the same way they would be in the case of
-fpie or -shared but generating an otherwise fixes/non-relocatable
binary.

Code linked in this way should still be compiled with -fPIC so that
data symbols can be resolved via imports.

This essentially allow the building of static binaries that have dynamic
imports. See:
https://github.com/emscripten-core/emscripten/issues/12682

As with other used of dynamic linking ABI this beviour will produce a
warning unless run with --experimental-pic.

[dschuff]

What's the use case for 'import-functions' mode after we roll this out?

lld/test/wasm/unresolved-symbols.s

76

shouldn't these runs/checks go in unresolved-symbols-dynamic.s?

[sbc100]

In D91577#2401182, @dschuff wrote:

What's the use case for 'import-functions' mode after we roll this out?

It allows folks to have the semantics of --allow-undefined which has existing users. We've seen a it bunch of times in bug reports, mostly among users of wasi-sdk.

The semantics of this option are still useful because it allows the binary to import all undefined function while zero-ing out undefined data symbols. The new import-dynamic mode is not a suitable replacement for all users because (a) it requires use of the the experimental PIC ABI and (b) it requires all objects files that reference undefined data symbols to be built with -fPIC.

Indeed this is the default behaviour expected by emscripten, and will continue to be for a while now.

Are are you are asking.. "why bother allowing the --unresolved-symbols= version of this option when we can just use --allow-undefined"?

[dschuff]

I was curious about emscripten. You mean that this is the mode that links the final wasm? Does emscripten allow users to inject JS functions that are directly imported by the wasm? (I assume we could use that mode for JS functions that are directly packaged by emscripten if we wanted).

[sbc100]

In D91577#2401285, @dschuff wrote:

I was curious about emscripten. You mean that this is the mode that links the final wasm? Does emscripten allow users to inject JS functions that are directly imported by the wasm? (I assume we could use that mode for JS functions that are directly packaged by emscripten if we wanted).

Yes, emscripten (almost) always links with --allow-undefined and then reported its undefined symbols later on in the JS library processor. And yes emscripten fills in any imported functions with JS implementations if it can, and errors if it can't.

lld/test/wasm/unresolved-symbols.s

76

I guess you are right.. I'll move these.

[sbc100]

• feedback

[sbc100]

rebase

[sbc100]

rebase

[sbc100]

rebase

[sbc100]

• rebase

[sbc100]

• comments

[dschuff]

lld/docs/WebAssembly.rst

97

this is now slightly confusing since --unresolved symbols is no longer completely orthogonal to --import-undefined? Probably at least the doc for --import-undefined should go just above --unresolved-symbols

[sbc100]

• update docs

[sbc100]

lld/docs/WebAssembly.rst

97

I went back and forth between adding --import-dynamic and --unresolved-symbols=import-dynamic. In the end I think this is more clear since unlike --import-undefined this new option effects all undefined symbols.

This option is currently behind the --experimental-pic flag so revisiting this decision in the future is still possible.

[sbc100]

I re-wrote the documentation to make this a little more clear

[sbc100]

-docs

lld/docs/WebAssembly.rst

report-all:
      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-dynamic:
+
+     Undefined symbols generate WebAssembly imports, including undefined data
+     symbols.  This is somewhat similar to the --import-undefined option but
+     works all symbol types.  This options puts limitations on the type of
+     relocations that are allowed for imported data symbols.  Relocations that
+     require absolute data addresses (i.e. All R_WASM_MEMORY_ADDR_I32) will
+     generate an error if they cannot be resolved statically.  For clang/llvm
+     this means inputs should be compiled with `-fPIC` (i.e. `pic` or
+     `dynamic-no-pic` relocation models).  This options is useful for linking
+     binaries that are themselves static (non-relocatable) but whose undefined
+     symbols are resolved by a dynamic linker.  Since the dynamic linking API is
+     experimental, this option currently requires `--experimental-pic` to also
+     be specified.
+
 .. option:: --import-memory
 
   Import memory from the environment.
 
 .. option:: --import-undefined
 
    Generate WebAssembly imports for undefined symbols, where possible.  For
    example, for function symbols this is always possible, but in general this

lld/test/wasm/shared.s

 
 # DIS:      <__wasm_call_ctors>:
 # DIS-EMPTY:
 # DIS-NEXT:                 call    1
 # DIS-NEXT:                 end
 
 # DIS:      <__wasm_apply_data_relocs>:
 # DIS-EMPTY:
-# DIS-NEXT:                 global.get      1
 # DIS-NEXT:                 i32.const       4
+# DIS-NEXT:                 global.get      1
 # DIS-NEXT:                 i32.add
 # DIS-NEXT:                 global.get      4
 # DIS-NEXT:                 i32.store       0
-# DIS-NEXT:                 global.get      1
 # DIS-NEXT:                 i32.const       8
+# DIS-NEXT:                 global.get      1
 # DIS-NEXT:                 i32.add
 # DIS-NEXT:                 global.get      2
 # DIS-NEXT:                 i32.const       1
 # DIS-NEXT:                 i32.add
 # DIS-NEXT:                 i32.store       0
-# DIS-NEXT:                 global.get      1
 # DIS-NEXT:                 i32.const       12
+# DIS-NEXT:                 global.get      1
 # DIS-NEXT:                 i32.add
 # DIS-NEXT:                 global.get      1
 # DIS-NEXT:                 i32.const       0
 # DIS-NEXT:                 i32.add
 # DIS-NEXT:                 i32.store       0
-# DIS-NEXT:                 global.get      1
 # DIS-NEXT:                 i32.const       16
+# DIS-NEXT:                 global.get      1
 # DIS-NEXT:                 i32.add
 # DIS-NEXT:                 global.get      5
 # DIS-NEXT:                 i32.store       0
-# DIS-NEXT:                 global.get      1
 # DIS-NEXT:                 i32.const       20
+# DIS-NEXT:                 global.get      1
 # DIS-NEXT:                 i32.add
 # DIS-NEXT:                 global.get      6
 # DIS-NEXT:                 i32.const       4
 # DIS-NEXT:                 i32.add
 # DIS-NEXT:                 i32.store       0
 # DIS-NEXT:                 end
 
 # check the data segment initialized with __memory_base global as offset

lld/test/wasm/shared64.s

 
 # DIS:      <__wasm_call_ctors>:
 # DIS-EMPTY:
 # DIS-NEXT:                 call    1
 # DIS-NEXT:                 end
 
 # DIS:      <__wasm_apply_data_relocs>:
 # DIS-EMPTY:
-# DIS-NEXT:                 global.get      1
 # DIS-NEXT:                 i64.const       4
+# DIS-NEXT:                 global.get      1
 # DIS-NEXT:                 i64.add
 # DIS-NEXT:                 global.get      5
 # DIS-NEXT:                 i64.store       0:p2align=2
-# DIS-NEXT:                 global.get      1
 # DIS-NEXT:                 i64.const       12
+# DIS-NEXT:                 global.get      1
 # DIS-NEXT:                 i64.add
 # DIS-NEXT:                 global.get      2
 # DIS-NEXT:                 i64.const       1
 # DIS-NEXT:                 i64.add
 # DIS-NEXT:                 i64.store       0:p2align=2
-# DIS-NEXT:                 global.get      1
 # DIS-NEXT:                 i64.const       20
+# DIS-NEXT:                 global.get      1
 # DIS-NEXT:                 i64.add
 # DIS-NEXT:                 global.get      1
 # DIS-NEXT:                 i32.const       0
 # DIS-NEXT:                 i32.add
 # DIS-NEXT:                 i32.store       0
-# DIS-NEXT:                 global.get      1
 # DIS-NEXT:                 i64.const       24
+# DIS-NEXT:                 global.get      1
 # DIS-NEXT:                 i64.add
 # DIS-NEXT:                 global.get      6
 # DIS-NEXT:                 i64.store       0:p2align=2
-# DIS-NEXT:                 global.get      1
 # DIS-NEXT:                 i64.const       32
+# DIS-NEXT:                 global.get      1
 # DIS-NEXT:                 i64.add
 # DIS-NEXT:                 global.get      7
 # DIS-NEXT:                 i32.const       4
 # DIS-NEXT:                 i32.add
 # DIS-NEXT:                 i32.store       0
 # DIS-NEXT:                 end
 
 # check the data segment initialized with __memory_base global as offset

lld/test/wasm/undefined-data.s

 # RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown -o %t.o %s
 # RUN: not wasm-ld -o %t.wasm %t.o 2>&1 | FileCheck %s -check-prefix=UNDEF
 # RUN: wasm-ld --allow-undefined -o %t.wasm %t.o
 # RUN: not wasm-ld --shared -o %t.wasm %t.o 2>&1 | FileCheck %s -check-prefix=SHARED
 
 .globl  _start
 _start:
   .functype _start () -> (i32)
   i32.const 0
   i32.load  data_external
   end_function
 
 .size data_external, 4
 
 # UNDEF: error: {{.*}}undefined-data.s.tmp.o: undefined symbol: data_external
-# SHARED: error: {{.*}}undefined-data.s.tmp.o: relocation R_WASM_MEMORY_ADDR_LEB cannot be used against symbol data_external; recompile with -fPIC
+# SHARED: error: {{.*}}undefined-data.s.tmp.o: relocation R_WASM_MEMORY_ADDR_LEB cannot be used against symbol `data_external`; recompile with -fPIC

lld/test/wasm/unresolved-symbols-dynamic.s

+# Unresolve data symbols are allowing under import-dynamic when GOT
+# relocations are used
+# RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown %s -o %t-dynamic.o
+# RUN: wasm-ld %t-dynamic.o -o %t.wasm --unresolved-symbols=import-dynamic 2>&1 | FileCheck -check-prefix=WARN %s
+# WARN: wasm-ld: warning: dynamic imports are not yet stable (--unresolved-symbols=import-dynamic)
+# RUN: obj2yaml %t.wasm | FileCheck %s
+
+.functype undef () -> ()
+
+.globl get_data_addr
+get_data_addr:
+    .functype get_data_addr () -> (i32)
+    global.get undef_data@GOT
+    return
+    end_function
+
+.globl get_func_addr
+get_func_addr:
+    .functype get_func_addr () -> (i32)
+    global.get undef@GOT
+    return
+    end_function
+
+.globl _start
+_start:
+    .functype _start () -> ()
+    call undef
+    call get_func_addr
+    drop
+    call get_data_addr
+    i32.load data_ptr
+    drop
+    end_function
+
+.section  .data.data_ptr,"",@
+data_ptr:
+  .int32  data_external+42
+  .size data_ptr, 4
+
+.size data_external, 4
+
+#      CHECK:  - Type:            IMPORT
+# CHECK-NEXT:    Imports:
+# CHECK-NEXT:      - Module:          env
+# CHECK-NEXT:        Field:           undef
+# CHECK-NEXT:        Kind:            FUNCTION
+# CHECK-NEXT:        SigIndex:        0
+# CHECK-NEXT:      - Module:          GOT.mem
+# CHECK-NEXT:        Field:           undef_data
+# CHECK-NEXT:        Kind:            GLOBAL
+# CHECK-NEXT:        GlobalType:      I32
+# CHECK-NEXT:        GlobalMutable:   true
+# CHECK-NEXT:      - Module:          GOT.func
+# CHECK-NEXT:        Field:           undef
+# CHECK-NEXT:        Kind:            GLOBAL
+# CHECK-NEXT:        GlobalType:      I32
+# CHECK-NEXT:        GlobalMutable:   true
+
+#      CHECK:  - Type:            CUSTOM
+# CHECK-NEXT:    Name:            name
+# CHECK-NEXT:    FunctionNames:
+# CHECK-NEXT:      - Index:           0
+# CHECK-NEXT:        Name:            undef
+# CHECK-NEXT:      - Index:           1
+# CHECK-NEXT:        Name:            __wasm_apply_data_relocs
+# CHECK-NEXT:      - Index:           2
+# CHECK-NEXT:        Name:            get_data_addr
+# CHECK-NEXT:      - Index:           3
+# CHECK-NEXT:        Name:            get_func_addr
+# CHECK-NEXT:      - Index:           4
+# CHECK-NEXT:        Name:            _start
+# CHECK-NEXT:    GlobalNames:
+# CHECK-NEXT:      - Index:           0
+# CHECK-NEXT:        Name:            undef_data
+# CHECK-NEXT:      - Index:           1
+# CHECK-NEXT:        Name:            undef
+# CHECK-NEXT:      - Index:           2
+# CHECK-NEXT:        Name:            data_external
+# CHECK-NEXT:      - Index:           3
+# CHECK-NEXT:        Name:            __stack_pointer
+# CHECK-NEXT:    DataSegmentNames:
+# CHECK-NEXT:      - Index:           0
+# CHECK-NEXT:        Name:            .data
+# CHECK-NEXT:...

lld/test/wasm/unresolved-symbols.s

 
 ## Check that --import-undefined reports unresolved data symbols.
 # RUN: not wasm-ld %t1.o -o %t3.wasm --import-undefined --unresolved-symbols=report-all 2>&1 | FileCheck -check-prefix=IMPORTUNDEFINED %s
 # IMPORTUNDEFINED-NOT: error: {{.*}}1.o: undefined symbol: undef_func
 # IMPORTUNDEFINED: error: {{.*}}1.o: undefined symbol: undef_data
 
 ## 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
 
 .functype undef_func () -> ()
 .functype get_data_addr () -> (i32)
 .functype get_func_addr () -> (i32)
 
+## import-dynamic should fail due to incompatible relocations.
+# RUN: not wasm-ld %t1.o -o %t5.wasm --unresolved-symbols=import-dynamic 2>&1 | FileCheck -check-prefix=ERRNOPIC %s
+# ERRNOPIC: relocation R_WASM_MEMORY_ADDR_SLEB cannot be used against symbol `undef_data`; recompile with -fPIC
+# ERRNOPIC: relocation R_WASM_TABLE_INDEX_SLEB cannot be used against symbol `undef_func`; recompile with -fPIC
+
 .globl _start
 _start:
     .functype _start () -> ()
     call undef_func
     call get_data_addr
     call get_func_addr
     drop
     drop

lld/wasm/Config.h

 #include "llvm/ADT/StringSet.h"
 #include "llvm/BinaryFormat/Wasm.h"
 #include "llvm/Support/CachePruning.h"
 
 namespace lld {
 namespace wasm {
 
 // For --unresolved-symbols.
-enum class UnresolvedPolicy { ReportError, Warn, Ignore };
+enum class UnresolvedPolicy { ReportError, Warn, Ignore, ImportDynamic };
 
 // 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 bsymbolic;
   bool checkFeatures;

lld/wasm/Driver.cpp

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-dynamic")
+      return UnresolvedPolicy::ImportDynamic;
     if (s == "report-all")
       return errorOrWarn;
     error("unknown --unresolved-symbols value: " + s);
   }
 
   return errorOrWarn;
 }
 
if (!config->experimentalPic) {
     if (config->shared) {
       warn("creating shared libraries, with -shared, is not yet stable");
     }
 
     // -pie will change meaning when Module Linking is implemented.
     if (config->pie) {
       warn("creating PIEs, with -pie, is not yet stable");
     }
+
+    if (config->unresolvedSymbols == UnresolvedPolicy::ImportDynamic) {
+      warn("dynamic imports are not yet stable "
+           "(--unresolved-symbols=import-dynamic)");
+    }
   }
 
   if (config->bsymbolic && !config->shared) {
     warn("-Bsymbolic is only meaningful when combined with -shared");
   }
 }
 
 // Force Sym to be entered in the output. Used for -u or equivalent.

lld/wasm/InputChunks.cpp

unsigned opcode_ptr_add = is64 ? WASM_OPCODE_I64_ADD
                                  : WASM_OPCODE_I32_ADD;
 
   uint64_t tombstone = getTombstone();
   // TODO(sbc): Encode the relocations in the data section and write a loop
   // here to apply them.
   for (const WasmRelocation &rel : relocations) {
     uint64_t offset = getVA(rel.Offset) - getInputSectionOffset();
 
+    Symbol *sym = file->getSymbol(rel);
+    if (!config->isPic && sym->isDefined())
+      continue;
+
     LLVM_DEBUG(dbgs() << "gen reloc: type=" << relocTypeToString(rel.Type)
                       << " addend=" << rel.Addend << " index=" << rel.Index
                       << " output offset=" << offset << "\n");
 
-    // Get __memory_base
-    writeU8(os, WASM_OPCODE_GLOBAL_GET, "GLOBAL_GET");
-    writeUleb128(os, WasmSym::memoryBase->getGlobalIndex(), "memory_base");
-
-    // Add the offset of the relocation
+    // Calculate the address at which to apply the relocations
     writeU8(os, opcode_ptr_const, "CONST");
     writeSleb128(os, offset, "offset");
+
+    // In PIC mode we need to add the __memory_base
+    if (config->isPic) {
+      writeU8(os, WASM_OPCODE_GLOBAL_GET, "GLOBAL_GET");
+      writeUleb128(os, WasmSym::memoryBase->getGlobalIndex(), "memory_base");
       writeU8(os, opcode_ptr_add, "ADD");
+    }
 
+    // Now figure out what we want to store at this location
     bool is64 = relocIs64(rel.Type);
     unsigned opcode_reloc_const =
         is64 ? WASM_OPCODE_I64_CONST : WASM_OPCODE_I32_CONST;
     unsigned opcode_reloc_add =
         is64 ? WASM_OPCODE_I64_ADD : WASM_OPCODE_I32_ADD;
     unsigned opcode_reloc_store =
         is64 ? WASM_OPCODE_I64_STORE : WASM_OPCODE_I32_STORE;
 
-    Symbol *sym = file->getSymbol(rel);
-    // Now figure out what we want to store
     if (sym->hasGOTIndex()) {
       writeU8(os, WASM_OPCODE_GLOBAL_GET, "GLOBAL_GET");
       writeUleb128(os, sym->getGOTIndex(), "global index");
       if (rel.Addend) {
         writeU8(os, opcode_reloc_const, "CONST");
         writeSleb128(os, rel.Addend, "addend");
         writeU8(os, opcode_reloc_add, "ADD");
       }
     } else {
+      assert(config->isPic);
       const GlobalSymbol* baseSymbol = WasmSym::memoryBase;
       if (rel.Type == R_WASM_TABLE_INDEX_I32 ||
           rel.Type == R_WASM_TABLE_INDEX_I64)
         baseSymbol = WasmSym::tableBase;
       writeU8(os, WASM_OPCODE_GLOBAL_GET, "GLOBAL_GET");
       writeUleb128(os, baseSymbol->getGlobalIndex(), "base");
       writeU8(os, opcode_reloc_const, "CONST");
       writeSleb128(os, file->calcNewValue(rel, tombstone, this), "offset");

lld/wasm/Relocations.cpp

 
 using namespace llvm;
 using namespace llvm::wasm;
 
 namespace lld {
 namespace wasm {
 
 static bool requiresGOTAccess(const Symbol *sym) {
-  if (!config->isPic)
+  if (!config->isPic &&
+      config->unresolvedSymbols != UnresolvedPolicy::ImportDynamic)
     return false;
   if (sym->isHidden() || sym->isLocal())
     return false;
   // With `-Bsymbolic` (or when building an executable) as don't need to use
   // the GOT for symbols that are defined within the current module.
   if (sym->isDefined() && (!config->shared || config->bsymbolic))
     return false;
   return true;
case UnresolvedPolicy::Ignore:
             f->stubFunction->markLive();
             // Mark the function itself as a stub which prevents it from being
             // assigned a table entry.
             f->isStub = true;
           }
         }
       }
       break;
+    case UnresolvedPolicy::ImportDynamic:
+      break;
     }
   }
 }
 
 static void addGOTEntry(Symbol *sym) {
   if (requiresGOTAccess(sym))
     out.importSec->addGOTEntry(sym);
   else
case R_WASM_MEMORY_ADDR_TLS_SLEB64:
                   toString(*sym) +
                   "` in non-TLS section: " + D->segment->outputSeg->name);
           }
         }
       }
       break;
     }
 
-    if (config->isPic) {
+    if (config->isPic ||
+        (sym->isUndefined() &&
+         config->unresolvedSymbols == UnresolvedPolicy::ImportDynamic)) {
       switch (reloc.Type) {
       case R_WASM_TABLE_INDEX_SLEB:
       case R_WASM_TABLE_INDEX_SLEB64:
       case R_WASM_MEMORY_ADDR_SLEB:
       case R_WASM_MEMORY_ADDR_LEB:
       case R_WASM_MEMORY_ADDR_SLEB64:
       case R_WASM_MEMORY_ADDR_LEB64:
         // Certain relocation types can't be used when building PIC output,
         // since they would require absolute symbol addresses at link time.
         error(toString(file) + ": relocation " + relocTypeToString(reloc.Type) +
-              " cannot be used against symbol " + toString(*sym) +
-              "; recompile with -fPIC");
+              " cannot be used against symbol `" + toString(*sym) +
+              "`; recompile with -fPIC");
         break;
       case R_WASM_TABLE_INDEX_I32:
       case R_WASM_TABLE_INDEX_I64:
       case R_WASM_MEMORY_ADDR_I32:
       case R_WASM_MEMORY_ADDR_I64:
         // These relocation types are only present in the data section and
         // will be converted into code by `generateRelocationCode`.  This code
         // requires the symbols to have GOT entries.

lld/wasm/SyntheticSections.h

 
 // Create the custom "dylink" section containing information for the dynamic
 // linker.
 // See
 // https://github.com/WebAssembly/tool-conventions/blob/main/DynamicLinking.md
 class DylinkSection : public SyntheticSection {
 public:
   DylinkSection() : SyntheticSection(llvm::wasm::WASM_SEC_CUSTOM, "dylink.0") {}
-  bool isNeeded() const override { return config->isPic; }
+  bool isNeeded() const override;
   void writeBody() override;
 
   uint32_t memAlign = 0;
   uint32_t memSize = 0;
 };
 
 class TypeSection : public SyntheticSection {
 public:

lld/wasm/SyntheticSections.cpp

private:
   std::string body;
 
 public:
   raw_string_ostream os{body};
 };
 
 } // namespace
 
+bool DylinkSection::isNeeded() const {
+  return config->isPic ||
+         config->unresolvedSymbols == UnresolvedPolicy::ImportDynamic ||
+         !symtab->sharedFiles.empty();
+}
+
 void DylinkSection::writeBody() {
   raw_ostream &os = bodyOutputStream;
 
   {
     SubSection sub(WASM_DYLINK_MEM_INFO);
     writeUleb128(sub.os, memSize, "MemSize");
     writeUleb128(sub.os, memAlign, "MemAlign");
     writeUleb128(sub.os, out.elemSec->numEntries(), "TableSize");

lld/wasm/Writer.cpp

static bool shouldImport(Symbol *sym) {
   // In PIC mode we only need to import functions when they are called directly.
   // Indirect usage all goes via GOT imports.
   if (config->isPic) {
     if (auto *f = dyn_cast<UndefinedFunction>(sym))
       if (!f->isCalledDirectly)
         return false;
   }
 
-  if (config->isPic || config->relocatable || config->importUndefined)
+  if (config->isPic || config->relocatable || config->importUndefined ||
+      config->unresolvedSymbols == UnresolvedPolicy::ImportDynamic)
     return true;
   if (config->allowUndefinedSymbols.count(sym->getName()) != 0)
     return true;
 
   return sym->importName.hasValue();
 }
 
 void Writer::calculateImports() {
void Writer::createSyntheticInitFunctions() {
   if (config->sharedMemory && out.globalSec->needsTLSRelocations()) {
     WasmSym::applyGlobalTLSRelocs = symtab->addSyntheticFunction(
         "__wasm_apply_global_tls_relocs", WASM_SYMBOL_VISIBILITY_HIDDEN,
         make<SyntheticFunction>(nullSignature,
                                 "__wasm_apply_global_tls_relocs"));
     WasmSym::applyGlobalTLSRelocs->markLive();
   }
 
-  if (config->isPic) {
-    // For PIC code we create synthetic functions that apply relocations.
-    // These get called from __wasm_call_ctors before the user-level
-    // constructors.
+  if (config->isPic ||
+      config->unresolvedSymbols == UnresolvedPolicy::ImportDynamic) {
+    // For PIC code, or when dynamically importing addresses, we create
+    // synthetic functions that apply relocations.  These get called from
+    // __wasm_call_ctors before the user-level constructors.
     WasmSym::applyDataRelocs = symtab->addSyntheticFunction(
         "__wasm_apply_data_relocs", WASM_SYMBOL_VISIBILITY_HIDDEN,
         make<SyntheticFunction>(nullSignature, "__wasm_apply_data_relocs"));
     WasmSym::applyDataRelocs->markLive();
+  }
 
-    if (out.globalSec->needsRelocations()) {
-      WasmSym::applyGlobalRelocs = symtab->addSyntheticFunction(
-          "__wasm_apply_global_relocs", WASM_SYMBOL_VISIBILITY_HIDDEN,
-          make<SyntheticFunction>(nullSignature, "__wasm_apply_global_relocs"));
-      WasmSym::applyGlobalRelocs->markLive();
-    }
-  }
+  if (config->isPic && out.globalSec->needsRelocations()) {
 
   int startCount = 0;
   if (WasmSym::applyGlobalRelocs)
     startCount++;
   if (WasmSym::WasmSym::initMemory || WasmSym::applyDataRelocs)
     startCount++;
 
   // If there is only one start function we can just use that function