[lld][WebAssembly] Add `--table-base` setting

[sbc100]

Summary

This is similar to --global-base but determines where to place the
table segments rather than that data segments.

See https://github.com/emscripten-core/emscripten/issues/20097

[dschuff]

LGTM otherwise

lld/test/wasm/table-base.s

28

what is this global 0 for?

68

seems like maybe it's worth noting somehow that this line is the important one.

[sbc100]

lld/test/wasm/table-base.s

28

__stack_pointer

lld/test/wasm/table-base.s

+# RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown %s -o %t.o
+
+# RUN: wasm-ld --export=__table_base -o %t.wasm %t.o
+# RUN: obj2yaml %t.wasm | FileCheck %s  -check-prefix=CHECK-DEFAULT
+
+# RUN: wasm-ld --table-base=100 --export=__table_base -o %t.wasm %t.o
+# RUN: obj2yaml %t.wasm | FileCheck %s  -check-prefix=CHECK-100
+
+.globl _start
+_start:
+  .functype _start () -> ()
+  i32.const _start
+  drop
+  end_function
+
+# CHECK-DEFAULT:       - Type:            TABLE
+# CHECK-DEFAULT-NEXT:    Tables:
+# CHECK-DEFAULT-NEXT:      - Index:           0
+# CHECK-DEFAULT-NEXT:        ElemType:        FUNCREF
+# CHECK-DEFAULT-NEXT:        Limits:
+# CHECK-DEFAULT-NEXT:          Flags:           [ HAS_MAX ]
+# CHECK-DEFAULT-NEXT:          Minimum:         0x2
+# CHECK-DEFAULT-NEXT:          Maximum:         0x2
+
+# CHECK-DEFAULT:       - Type:            GLOBAL
+# CHECK-DEFAULT-NEXT:    Globals:
+# CHECK-DEFAULT-NEXT:      - Index:           0
+# CHECK-DEFAULT-NEXT:        Type:            I32
+# CHECK-DEFAULT-NEXT:        Mutable:         true
+# CHECK-DEFAULT-NEXT:        InitExpr:
+# CHECK-DEFAULT-NEXT:          Opcode:          I32_CONST
+# CHECK-DEFAULT-NEXT:          Value:           66560
+# CHECK-DEFAULT-NEXT:      - Index:           1
+# CHECK-DEFAULT-NEXT:        Type:            I32
+# CHECK-DEFAULT-NEXT:        Mutable:         false
+# CHECK-DEFAULT-NEXT:        InitExpr:
+# CHECK-DEFAULT-NEXT:          Opcode:          I32_CONST
+# CHECK-DEFAULT-NEXT:          Value:           1
+
+# CHECK-DEFAULT:       - Type:            EXPORT
+# CHECK-DEFAULT:           - Name:            __table_base
+# CHECK-DEFAULT-NEXT:        Kind:            GLOBAL
+# CHECK-DEFAULT-NEXT:        Index:           1
+
+# CHECK-100:       - Type:            TABLE
+# CHECK-100-NEXT:    Tables:
+# CHECK-100-NEXT:      - Index:           0
+# CHECK-100-NEXT:        ElemType:        FUNCREF
+# CHECK-100-NEXT:        Limits:
+# CHECK-100-NEXT:          Flags:           [ HAS_MAX ]
+# CHECK-100-NEXT:          Minimum:         0x65
+# CHECK-100-NEXT:          Maximum:         0x65
+
+# CHECK-100:       - Type:            GLOBAL
+# CHECK-100-NEXT:    Globals:
+# CHECK-100-NEXT:      - Index:           0
+# CHECK-100-NEXT:        Type:            I32
+# CHECK-100-NEXT:        Mutable:         true
+# CHECK-100-NEXT:        InitExpr:
+# CHECK-100-NEXT:          Opcode:          I32_CONST
+# CHECK-100-NEXT:          Value:           66560
+# CHECK-100-NEXT:      - Index:           1
+# CHECK-100-NEXT:        Type:            I32
+# CHECK-100-NEXT:        Mutable:         false
+# CHECK-100-NEXT:        InitExpr:
+# CHECK-100-NEXT:          Opcode:          I32_CONST
+# CHECK-100-NEXT:          Value:           100
+
+# CHECK-100:       - Type:            EXPORT
+# CHECK-100:           - Name:            __table_base
+# CHECK-100-NEXT:        Kind:            GLOBAL
+# CHECK-100-NEXT:        Index:           1

lld/wasm/Driver.cpp

config->thinLTOCachePolicy = CHECK(
       "--thinlto-cache-policy: invalid cache policy");
   config->unresolvedSymbols = getUnresolvedSymbolPolicy(args);
   config->whyExtract = args.getLastArgValue(OPT_why_extract);
   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, 0);
+  config->tableBase = args::getInteger(args, OPT_table_base, 0);
   config->maxMemory = args::getInteger(args, OPT_max_memory, 0);
   config->zStackSize =
       args::getZOptionValue(args, OPT_z, "stack-size", WasmPageSize);
 
   // Default value of exportDynamic depends on `-shared`
   config->exportDynamic =
       args.hasFlag(OPT_export_dynamic, OPT_no_export_dynamic, config->shared);
 

 // of these values.
 static void setConfigs() {
   config->isPic = config->pie || config->shared;
 
   if (config->isPic) {
     if (config->exportTable)
       error("-shared/-pie is incompatible with --export-table");
     config->importTable = true;
+  } else {
+    // Default table base.  Defaults to 1, reserving 0 for the NULL function
+    // pointer.
+    if (!config->tableBase)
+      config->tableBase = 1;
+    // The default offset for static/global data, for when --global-base is
+    // not specified on the command line.  The precise value of 1024 is
+    // somewhat arbitrary, and pre-dates wasm-ld (Its the value that
+    // emscripten used prior to wasm-ld).
+    if (!config->globalBase && !config->relocatable && !config->stackFirst)
+      config->globalBase = 1024;
   }
 
   if (config->relocatable) {
     if (config->exportTable)
       error("--relocatable is incompatible with --export-table");
     if (config->growableTable)
       error("--relocatable is incompatible with --growable-table");
     // Ignore any --import-table, as it's redundant.
if (config->unresolvedSymbols == UnresolvedPolicy::ImportDynamic) {
            "(--unresolved-symbols=import-dynamic)");
     }
   }
 
   if (config->bsymbolic && !config->shared) {
     warn("-Bsymbolic is only meaningful when combined with -shared");
   }
 
-  if (config->globalBase && config->isPic) {
+  if (config->isPic) {
+    if (config->globalBase)
       error("--global-base may not be used with -shared/-pie");
+    if (config->tableBase)
+      error("--table-base may not be used with -shared/-pie");
   }
 }
 
 static const char *getReproduceOption(opt::InputArgList &args) {
   if (auto *arg = args.getLastArg(OPT_reproduce))
     return arg->getValue();
   return getenv("LLD_REPRODUCE");
 }

lld/wasm/Options.td

 
 def export_table: FF<"export-table">,
   HelpText<"Export function table to the environment">;
 
 def growable_table: FF<"growable-table">,
   HelpText<"Remove maximum size from function table, allowing table to grow">;
 
 def global_base: JJ<"global-base=">,
-  HelpText<"Where to start to place global data">;
+  HelpText<"Memory offset at which to place global data (Defaults to 1024)">;
 
 def import_memory: FF<"import-memory">,
   HelpText<"Import the module's memory from the default module of \"env\" with the name \"memory\".">;
 def import_memory_with_name: JJ<"import-memory=">,
   HelpText<"Import the module's memory from the passed module with the passed name.">,
   MetaVarName<"<module>,<name>">;
 
 def export_memory: FF<"export-memory">,
def max_memory: JJ<"max-memory=">,
   HelpText<"Maximum size of the linear memory">;
 
 def no_entry: FF<"no-entry">,
   HelpText<"Do not output any entry point">;
 
 def stack_first: FF<"stack-first">,
   HelpText<"Place stack at start of linear memory rather than after data">;
 
+def table_base: JJ<"table-base=">,
+  HelpText<"Table offset at which to place address taken functions (Defaults to 1)">;
+
 defm whole_archive: B<"whole-archive",
     "Force load of all members in a static library",
     "Do not force load of all members in a static library (default)">;
 
 def why_extract: JJ<"why-extract=">, HelpText<"Print to a file about why archive members are extracted">;
 
 defm check_features: BB<"check-features",
     "Check feature compatibility of linked objects (default)",

lld/wasm/Writer.cpp

if (config->stackFirst) {
     if (config->globalBase) {
       if (config->globalBase < memoryPtr) {
         error("--global-base cannot be less than stack size when --stack-first is used");
         return;
       }
       memoryPtr = config->globalBase;
     }
   } else {
-    if (!config->globalBase && !config->relocatable && !config->isPic) {
-      // The default offset for static/global data, for when --global-base is
-      // not specified on the command line.  The precise value of 1024 is
-      // somewhat arbitrary, and pre-dates wasm-ld (Its the value that
-      // emscripten used prior to wasm-ld).
-      config->globalBase = 1024;
-    }
     memoryPtr = config->globalBase;
   }
 
   log("mem: global base = " + Twine(memoryPtr));
   if (WasmSym::globalBase)
     WasmSym::globalBase->setVA(memoryPtr);
 
   uint64_t dataStart = memoryPtr;
void Writer::createSyntheticSectionsPostLayout() {
   out.linkingSec = make<LinkingSection>(initFunctions, segments);
   out.nameSec = make<NameSection>(segments);
 }
 
 void Writer::run() {
   // For PIC code the table base is assigned dynamically by the loader.
   // For non-PIC, we start at 1 so that accessing table index 0 always traps.
   if (!config->isPic) {
-    config->tableBase = 1;
     if (WasmSym::definedTableBase)
       WasmSym::definedTableBase->setVA(config->tableBase);
     if (WasmSym::definedTableBase32)
       WasmSym::definedTableBase32->setVA(config->tableBase);
   }
 
   log("-- createOutputSegments");
   createOutputSegments();