compiler+rts: port #181 wasm32 cross-target + per-target-settings stack

angerman · angerman · commit d89d51e12f89 · 2026-06-15T23:11:32.000+09:00
Ports the two GHC-source commits #181 (feat/wasm-cross-ghcup) carries but the stable-ghc-9.14 / #188 base lacks, which are the real fix for the stage3-wasm ghc-internal link failure ([GHC-74335] "-dynamic ignored when linking binaries on WASM" -> mismatched interface profile tag): - 7396909 "rts+compiler: wasm32 cross-target patches" (GHC/Linker/Dynamic.hs wasm dynamic-link handling, Driver/Session.hs, Runtime/Interpreter/Wasm.hs, rts/linker/elf_got.c, rts/RtsStartup.c) - 4d84ace "compiler: per-target settings drive GHC Dynamic / Profiled" (Platform/Settings/Settings.IO/Driver.Session: platformMisc_targetIsDynamic et al., defaulting True so the wasm target is dynamic-capable) compiler/Setup.hs + libraries/ghc-boot/Setup.hs were KEPT at the modern-pin VerbosityHandles form (7396's pre-split Setup.hs revert was discarded — it's incompatible with the post-split cabal pin).
diff --git a/compiler/GHC/Driver/Session.hs b/compiler/GHC/Driver/Session.hs
@@ -132,6 +132,10 @@ module GHC.Driver.Session (
         sGhcWithInterpreter,
         sLibFFI,
         sTargetRTSLinkerOnlySupportsSharedLibs,
+        sTargetIsDynamic,
+        sTargetShipsDynLibs,
+        sTargetIsProfiled,
+        sTargetShipsProfLibs,
         GhcNameVersion(..),
         FileSettings(..),
         PlatformMisc(..),
@@ -3548,8 +3552,16 @@ compilerInfo dflags
        ("Have native code generator",  showBool $ platformNcgSupported platform),
        ("target has RTS linker",       showBool $ platformHasRTSLinker platform),
        ("Target default backend",      show     $ platformDefaultBackend platform),
-       -- Whether or not we support @-dynamic-too@
-       ("Support dynamic-too",         showBool $ not isWindows),
+       -- Whether or not we support @-dynamic-too@ for this target.
+       -- Historically `not isWindows` (Windows tooling couldn't do
+       -- it). Now also gated on the per-target `sTargetIsDynamic`
+       -- dial — if the target isn't dynamic-capable, -dynamic-too
+       -- is meaningless. Keep the Windows guard as defence in depth
+       -- for pre-this-patch bindists on Windows that lack the key
+       -- and so default sTargetIsDynamic=True (the AND would
+       -- otherwise regress them).
+       ("Support dynamic-too",         showBool $ not isWindows
+                                              && sTargetIsDynamic (settings dflags)),
        -- Whether or not we support the @-j@ flag with @--make@.
        ("Support parallel --make",     "YES"),
        -- Whether or not we support "Foo from foo-0.1-XXX:Foo" syntax in
@@ -3569,10 +3581,27 @@ compilerInfo dflags
        ("Uses package keys",           "YES"),
        -- Whether or not we support the @-this-unit-id@ flag
        ("Uses unit IDs",               "YES"),
-       -- Whether or not GHC was compiled using -dynamic
-       ("GHC Dynamic",                 showBool hostIsDynamic),
-       -- Whether or not GHC was compiled using -prof
-       ("GHC Profiled",                showBool hostIsProfiled),
+       -- Reported as YES iff *both* per-target settings dials say so:
+       --   `target is dynamic`               — the GHC for this target
+       --                                       can produce dynamic output
+       --   `target ships dynamic libraries`  — the lib tree actually has
+       --                                       .dyn_hi / .so artifacts
+       -- cabal-install reads this to decide whether to enable
+       -- @library-dynamic@ by default. The target's per-target settings
+       -- file completely controls this value — no host-RTS dependency,
+       -- so on a multi-target bindist with one shared stage2 GHC binary
+       -- different targets can correctly disagree. Both keys default to
+       -- True if absent (matches pre-this-change behaviour).
+       ("GHC Dynamic",                 showBool (sTargetIsDynamic (settings dflags)
+                                              && sTargetShipsDynLibs (settings dflags))),
+       -- Profiling-way analogue of `GHC Dynamic`. Per-target dials
+       -- via `target is profiled` + `target ships profiling libraries`
+       -- settings keys. Drops the historical `hostIsProfiled` RTS-
+       -- baked-in for the same reason the dyn pair did: on a multi-
+       -- target bindist the shared stage2 GHC binary's prof-ness is
+       -- fixed but the lib trees can disagree per target.
+       ("GHC Profiled",                showBool (sTargetIsProfiled (settings dflags)
+                                              && sTargetShipsProfLibs (settings dflags))),
        ("Debug on",                    showBool debugIsOn),
        ("LibDir",                      topDir dflags),
        -- This is always an absolute path, unlike "Relative Global Package DB" which is
@@ -3782,18 +3811,26 @@ makeDynFlagsConsistent dflags
     = let warn = "-dynamic is ignored when using -staticlib"
       in loop dflags{targetWays_ = removeWay WayDyn (targetWays_ dflags)} warn
  -- For the wasm target, when ghc is invoked with -dynamic,
- -- when linking the final .wasm binary we must still ensure
- -- the static archives are selected. Otherwise wasm-ld would
- -- fail to find and link the .so library dependencies. wasm-ld
- -- can link PIC objects into static .wasm binaries fine, so we
- -- only adjust the ways in the final linking step, and only
- -- when linking .wasm binary (which is supposed to be fully
- -- static), not when linking .so shared libraries.
- | LinkExecutable _ <- ghcLink dflags
- , ArchWasm32 <- arch
- , ways dflags `hasWay` WayDyn
-    = let warn = "-dynamic is ignored when linking binaries on WASM"
-      in loop dflags{targetWays_ = removeWay WayDyn (targetWays_ dflags)} warn
+ -- (DISABLED Phase 6.5, 2026-05-26) — the original rule below was meant
+ -- to strip WayDyn only when linking the final .wasm binary, but the
+ -- default `ghcLink` in `defaultDynFlags` is `LinkExecutable Dynamic`, so
+ -- the rule fired for EVERY --make invocation that didn't override it.
+ -- That broke cabal library builds with `shared:True, library-vanilla:False`
+ -- (the rule stripped WayDyn mid-compile, then GHC looked for vanilla .hi
+ -- files that don't exist since only .dyn_hi was produced).
+ --
+ -- The wasm linker (wasm-ld) silently handles -dynamic without issue —
+ -- wasm binaries are inherently single-file artifacts, and PIC objects
+ -- link fine into them. Removing the strip lets WayDyn flow through to
+ -- the actual link step, where wasm-ld does the right thing.
+ -- (If a future regression surfaces, narrow the rule to fire ONLY in the
+ -- actual link phase, not at flag-consistency time.)
+ --
+ -- | LinkExecutable _ <- ghcLink dflags
+ -- , ArchWasm32 <- arch
+ -- , ways dflags `hasWay` WayDyn
+ --    = let warn = "-dynamic is ignored when linking binaries on WASM"
+ --      in loop dflags{targetWays_ = removeWay WayDyn (targetWays_ dflags)} warn
 
  | LinkInMemory <- ghcLink dflags
  , not (gopt Opt_ExternalInterpreter dflags)
diff --git a/compiler/GHC/Linker/Dynamic.hs b/compiler/GHC/Linker/Dynamic.hs
@@ -16,6 +16,7 @@ import GHC.SysTools.Tasks
 
 import GHC.Driver.Config.Linker
 import GHC.Driver.Session
+import GHC.Driver.DynFlags (rtsWayUnitId)
 
 import GHC.Unit.Env
 import GHC.Unit.Types
@@ -52,7 +53,27 @@ linkDynLib logger tmpfs dflags0 unit_env o_files dep_packages
         verbFlags = getVerbFlags dflags
         o_file = outputFile_ dflags
 
-    pkgs_with_rts <- mayThrowUnitErr (preloadUnitsInfo' unit_env dep_packages)
+    pkgs_with_rts <- do
+      pkgs0 <- mayThrowUnitErr (preloadUnitsInfo' unit_env dep_packages)
+      -- On wasm32, every Haskell .so must declare the current way's rts in
+      -- its `dylink.0/needed_dynlibs` section, otherwise the runtime dyld
+      -- can load it ahead of rts and the .so's `_initialize` references
+      -- unresolved rts symbols (e.g. `registerForeignExports`) — see
+      -- ghc-internal, which is built with `-no-rts` to bypass mkUnitState's
+      -- sanity check (compiler/GHC/Unit/State.hs:1652) but consequently has
+      -- cabal omit rts from its --depends list. wasm-ld populates
+      -- needed_dynlibs from the resolved `-l` flags, so we must inject the
+      -- current way's rts here whenever it isn't already present, even if
+      -- `-no-rts` is in effect. Other targets either link rts statically at
+      -- exe-link time or rely on host symbol resolution; on wasm32 the .so
+      -- itself carries the dependency.
+      let rts_uid = rtsWayUnitId dflags
+      pure $ case arch of
+        ArchWasm32
+          | not (any ((== rts_uid) . unitId) pkgs0)
+          , Just rts_info <- lookupUnitId (ue_units unit_env) rts_uid
+          -> rts_info : pkgs0
+        _ -> pkgs0
 
     let pkg_lib_paths = collectLibraryDirs (ways dflags) pkgs_with_rts
     let pkg_lib_path_opts = concatMap get_pkg_lib_path_opts pkg_lib_paths
@@ -84,7 +105,10 @@ linkDynLib logger tmpfs dflags0 unit_env o_files dep_packages
     --   * if -flink-rts is used, we link with the rts.
     --
     --   * on wasm we need to ensure libHSrts*.so is listed in
-    --   WASM_DYLINK_NEEDED, otherwise dyld can't load it.
+    --   WASM_DYLINK_NEEDED, otherwise dyld can't load it. We force the
+    --   current way's rts into `pkgs_with_rts` above so that even .so
+    --   files whose package was built with `-no-rts` (e.g. ghc-internal)
+    --   still declare the rts dependency.
     --
     --
     let pkgs_without_rts = filter ((/= PackageName (fsLit "rts")) . unitPackageName) pkgs_with_rts
diff --git a/compiler/GHC/Platform.hs b/compiler/GHC/Platform.hs
@@ -291,6 +291,33 @@ data PlatformMisc = PlatformMisc
   , platformMisc_libFFI               :: Bool
   , platformMisc_llvmTarget           :: String
   , platformMisc_targetRTSLinkerOnlySupportsSharedLibs :: Bool
+    -- | Is the GHC for this target capable of producing dynamic
+    -- output (i.e. can it honour @-dynamic@ / @-dynamic-too@)?
+    -- Per-target settings key @"target is dynamic"@ in
+    -- @lib/targets/\<triple\>/lib/settings@. On a multi-target bindist
+    -- the shared stage2 GHC binary's RTS-baked-in dynamic-ness is
+    -- not a per-target proxy — different targets in one binary may
+    -- need to disagree (e.g. a JS target whose iserv runs vanilla
+    -- and whose lib tree has no dyn artifacts). Combined with
+    -- 'platformMisc_targetShipsDynLibs' to drive @ghc --info@'s
+    -- @GHC Dynamic@ value, which cabal-install reads.
+  , platformMisc_targetIsDynamic      :: Bool
+    -- | Does the target's installed library tree ship @.dyn_hi@ /
+    -- @.so@ files? Per-target settings key
+    -- @"target ships dynamic libraries"@. Set independently of
+    -- 'platformMisc_targetIsDynamic' so a target can be dynamic-
+    -- capable but not currently ship dyn artifacts (or vice versa).
+  , platformMisc_targetShipsDynLibs   :: Bool
+    -- | Profiling-way analogue of 'platformMisc_targetIsDynamic'.
+    -- Per-target settings key @"target is profiled"@. Drives
+    -- @ghc --info@'s @GHC Profiled@ — cabal-install reads that to
+    -- decide whether to enable @library-profiling@.
+  , platformMisc_targetIsProfiled     :: Bool
+    -- | Profiling-way analogue of 'platformMisc_targetShipsDynLibs'.
+    -- Per-target settings key @"target ships profiling libraries"@.
+    -- Combined with 'platformMisc_targetIsProfiled' for the
+    -- @GHC Profiled@ report.
+  , platformMisc_targetShipsProfLibs  :: Bool
   }
 
 platformSOName :: Platform -> FilePath -> FilePath
diff --git a/compiler/GHC/Runtime/Interpreter/Wasm.hs b/compiler/GHC/Runtime/Interpreter/Wasm.hs
@@ -10,11 +10,13 @@ import GHC.Runtime.Interpreter.Types
 #if !defined(mingw32_HOST_OS)
 
 import Control.Concurrent.MVar
+import Control.Exception (throwIO)
 import Data.Maybe
 import GHC.Data.FastString
 import qualified GHC.Data.ShortText as ST
 import GHC.Platform
 import GHC.Unit
+import GHC.Utils.Panic (GhcException (InstallationError))
 import GHCi.Message
 import System.Directory
 import System.Environment.Blank
@@ -34,6 +36,21 @@ spawnWasmInterp :: WasmInterpConfig -> IO (ExtInterpInstance ())
 
 -- See Note [The Wasm Dynamic Linker] for details
 spawnWasmInterp WasmInterpConfig {..} = do
+  -- Pre-flight: dyld.mjs (the wasm dynamic linker) has a
+  -- `#!/usr/bin/env -S node` shebang and needs `node` on $PATH. Without
+  -- it the iserv child exits with code 127, which the generic
+  -- "External interpreter terminated (127)" message in
+  -- Process.hs:129 doesn't explain. Emit a clear, actionable error
+  -- here instead.
+  mb_node <- findExecutable "node"
+  case mb_node of
+    Just _ -> pure ()
+    Nothing -> throwIO . InstallationError $
+      "Template Haskell evaluation on the wasm32 backend requires `node` "
+        ++ "(Node.js) on PATH. The wasm dynamic linker shim ("
+        ++ wasmInterpDyLD
+        ++ ") is a Node script. Install Node.js and ensure `node` is "
+        ++ "reachable, then retry."
   let Just ghci_unit_id =
         lookupPackageName
           wasmInterpUnitState
diff --git a/compiler/GHC/Settings.hs b/compiler/GHC/Settings.hs
@@ -67,6 +67,10 @@ module GHC.Settings
   , sGhcWithInterpreter
   , sLibFFI
   , sTargetRTSLinkerOnlySupportsSharedLibs
+  , sTargetIsDynamic
+  , sTargetShipsDynLibs
+  , sTargetIsProfiled
+  , sTargetShipsProfLibs
   ) where
 
 import GHC.Prelude
@@ -314,3 +318,26 @@ sLibFFI = platformMisc_libFFI . sPlatformMisc
 
 sTargetRTSLinkerOnlySupportsSharedLibs :: Settings -> Bool
 sTargetRTSLinkerOnlySupportsSharedLibs = platformMisc_targetRTSLinkerOnlySupportsSharedLibs . sPlatformMisc
+
+-- | Is the GHC for this target capable of producing dynamic output?
+-- Read from the per-target settings file key @"target is dynamic"@.
+-- Combined with 'sTargetShipsDynLibs' to drive @ghc --info@'s
+-- @GHC Dynamic@ value — the target's settings file completely
+-- controls that, no host-RTS dependency.
+sTargetIsDynamic :: Settings -> Bool
+sTargetIsDynamic = platformMisc_targetIsDynamic . sPlatformMisc
+
+-- | Does this target's installed library tree ship .dyn_hi / .so files?
+-- Per-target settings key @"target ships dynamic libraries"@.
+sTargetShipsDynLibs :: Settings -> Bool
+sTargetShipsDynLibs = platformMisc_targetShipsDynLibs . sPlatformMisc
+
+-- | Profiling-way analogue of 'sTargetIsDynamic'. Per-target settings
+-- key @"target is profiled"@.
+sTargetIsProfiled :: Settings -> Bool
+sTargetIsProfiled = platformMisc_targetIsProfiled . sPlatformMisc
+
+-- | Profiling-way analogue of 'sTargetShipsDynLibs'. Per-target settings
+-- key @"target ships profiling libraries"@.
+sTargetShipsProfLibs :: Settings -> Bool
+sTargetShipsProfLibs = platformMisc_targetShipsProfLibs . sPlatformMisc
diff --git a/compiler/GHC/Settings/IO.hs b/compiler/GHC/Settings/IO.hs
@@ -185,6 +185,34 @@ initSettings top_dir = do
   ghcWithInterpreter <- getBooleanSetting "Use interpreter"
   useLibFFI <- getBooleanSetting "Use LibFFI"
 
+  -- Per-target dial #1: is the GHC for THIS target capable of
+  -- producing dynamic output (i.e. honouring -dynamic /
+  -- -dynamic-too)? On a multi-target bindist with one shared stage2
+  -- GHC binary, this can't be derived from the binary's compile-
+  -- time `hostIsDynamic`. Default True for backward compatibility
+  -- with older bindist settings files that predate the key.
+  targetIsDynamic <- either (const $ pure True) pure $
+    getRawBooleanSetting settingsFile mySettings "target is dynamic"
+
+  -- Per-target dial #2: does this target's installed lib tree
+  -- actually ship .dyn_hi / .so files? Independent of
+  -- `target is dynamic` so a dynamic-capable target can still
+  -- truthfully say it doesn't ship artifacts (e.g. a slimmed
+  -- bindist). cabal-install combines both via GHC Dynamic to
+  -- decide whether to enable library-dynamic by default.
+  targetShipsDynLibs <- either (const $ pure True) pure $
+    getRawBooleanSetting settingsFile mySettings "target ships dynamic libraries"
+
+  -- Profiling-way analogues of the two dyn dials above. Drive
+  -- `GHC Profiled` the same way (sTargetIsProfiled && sTargetShipsProfLibs).
+  -- Defaults to True for backward compatibility with bindists that
+  -- predate the keys — matches the historical hostIsProfiled
+  -- behaviour when GHC was prof-built.
+  targetIsProfiled <- either (const $ pure True) pure $
+    getRawBooleanSetting settingsFile mySettings "target is profiled"
+  targetShipsProfLibs <- either (const $ pure True) pure $
+    getRawBooleanSetting settingsFile mySettings "target ships profiling libraries"
+
   baseUnitId <- getSetting_raw "base unit-id"
 
   return $ Settings
@@ -267,6 +295,10 @@ initSettings top_dir = do
       , platformMisc_libFFI = useLibFFI
       , platformMisc_llvmTarget = llvmTarget
       , platformMisc_targetRTSLinkerOnlySupportsSharedLibs = targetRTSLinkerOnlySupportsSharedLibs
+      , platformMisc_targetIsDynamic = targetIsDynamic
+      , platformMisc_targetShipsDynLibs = targetShipsDynLibs
+      , platformMisc_targetIsProfiled = targetIsProfiled
+      , platformMisc_targetShipsProfLibs = targetShipsProfLibs
       }
 
     , sRawSettings    = settingsList
diff --git a/rts/RtsStartup.c b/rts/RtsStartup.c
@@ -424,14 +424,11 @@ hs_init_ghc(int *argc, char **argv[], RtsConfig rts_config)
 
     init_ghc_hs_iface();
 
-/* Must match the definition's #if at line 108: wasm32 is excluded there
- * (promoteBootLibrariesToGlobal uses dladdr/dlopen, unavailable on wasm),
- * but wasm DOES define RTLD_NOLOAD, so without the wasm32 exclusion here the
- * call fires against an undefined function ("call to undeclared function
- * 'promoteBootLibrariesToGlobal'"). */
 #if !defined(mingw32_HOST_OS) && !defined(wasm32_HOST_ARCH) && defined(RTLD_NOLOAD)
     /* Promote boot libraries to RTLD_GLOBAL for dynamic code loading.
      * See Note [Promoting Boot Libraries to RTLD_GLOBAL] */
+    /* NOTE: matches the function definition's #if at line 108 — wasm32 needs
+     * to be excluded here too (the function is undefined for wasm). */
     promoteBootLibrariesToGlobal();
 #endif
 
diff --git a/rts/linker/elf_got.c b/rts/linker/elf_got.c
@@ -5,6 +5,51 @@
 #include <string.h>
 
 #if defined(OBJFORMAT_ELF)
+
+/*
+ * Check whether a symbol (identified by its symbol table section index and
+ * its index within that table) is referenced by any relocation whose type
+ * is not R_*_NONE (type 0).  R_*_NONE is a no-op relocation for every ELF
+ * architecture, so symbols referenced exclusively by NONE relocations need
+ * not be resolved.
+ *
+ * This is used by fillGot() to avoid hard failures on undefined symbols that
+ * the assembler emitted NONE relocations for (e.g. zero-length arrays
+ * optimised away by the compiler but still present in the symbol table).
+ */
+static bool
+symbolHasNonNoneRelocation(ObjectCode *oc, unsigned symTabIndex,
+                           size_t symIdx)
+{
+    /* Scan REL relocation tables */
+    for (ElfRelocationTable *relTab = oc->info->relTable;
+         relTab != NULL; relTab = relTab->next) {
+        if (relTab->sectionHeader->sh_link == symTabIndex) {
+            for (size_t i = 0; i < relTab->n_relocations; i++) {
+                Elf_Rel *rel = &relTab->relocations[i];
+                if (ELF_R_SYM(rel->r_info) == symIdx
+                    && ELF_R_TYPE(rel->r_info) != 0) {
+                    return true;
+                }
+            }
+        }
+    }
+    /* Scan RELA relocation tables */
+    for (ElfRelocationATable *relaTab = oc->info->relaTable;
+         relaTab != NULL; relaTab = relaTab->next) {
+        if (relaTab->sectionHeader->sh_link == symTabIndex) {
+            for (size_t i = 0; i < relaTab->n_relocations; i++) {
+                Elf_Rela *rel = &relaTab->relocations[i];
+                if (ELF_R_SYM(rel->r_info) == symIdx
+                    && ELF_R_TYPE(rel->r_info) != 0) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+
 /*
  * Check if we need a global offset table slot for a
  * given symbol
@@ -96,6 +141,21 @@ fillGot(ObjectCode * oc) {
                         if(0x0 == symbol->addr) {
                             if(0 == strncmp(symbol->name,"_GLOBAL_OFFSET_TABLE_",21)) {
                                 symbol->addr = oc->info->got_start;
+                            } else if (!symbolHasNonNoneRelocation(oc, symTab->index, i)) {
+                                /* Symbol is only referenced by R_*_NONE
+                                 * (type 0) relocations, which are no-ops.
+                                 * This can happen when e.g. a zero-length
+                                 * array is optimised away by the compiler
+                                 * but the assembler still emits NONE relocs
+                                 * against the (now undefined) symbol.
+                                 * Assign a dummy address so the GOT slot is
+                                 * filled; it will never be dereferenced. */
+                                IF_DEBUG(linker,
+                                    debugBelch("Skipping unresolvable symbol"
+                                              " '%s' (only referenced by"
+                                              " NONE relocations)\n",
+                                              symbol->name));
+                                symbol->addr = (void*)0xDEAD0000;
                             } else {
                                 errorBelch("Failed to lookup symbol: %s,"
                                            " you might consider using --optimistic-linking\n",
diff --git a/utils/jsffi/dyld.mjs b/utils/jsffi/dyld.mjs
