feat: Complete multi-target support and compiler enhancements

This commit completes the multi-target support infrastructure with
comprehensive changes across the compiler, build system, and runtime
components. These changes enable GHC to efficiently target multiple
platforms including native, JavaScript, and cross-compilation scenarios.

Core Compiler Changes:
- GHC.Driver.DynFlags: Multi-target configuration support
- GHC.Driver.Session: Enhanced session management for targets
- GHC.Driver.Make: Updated build orchestration for stages
- GHC.Driver.Downsweep: Improved module dependency handling
- GHC.ByteCode.Asm: Cross-platform bytecode assembly
- GHC.Iface.Load: Added Hooks parameter for interface loading
- GHC.Unit.State: Multi-target package database handling

LLVM Integration:
- GHC.CmmToLlvm.*: Refactored LLVM backend configuration
- Removed Version/Bounds.hs.in template
- Dynamic LLVM version detection
- Improved LLVM toolchain integration

JavaScript Backend:
- GHC.Driver.Config.StgToJS: JavaScript code generation config
- Enhanced JavaScript runtime support
- Integration with multi-stage build system

Linker and Code Generation:
- GHC.Linker.Dynamic: Cross-platform dynamic linking
- GHC.Linker.Static: Static linking improvements
- GHC.Linker.ExtraObj: Object file handling
- GHC.Driver.CodeOutput: Multi-target code emission
- CodeGen.Platform.h: Platform-specific code generation

Build System:
- ghc-pkg: Added --target flag support
- deriveConstants: Cross-compilation aware
- genprimopcode: Target-specific primop generation
- Setup.hs files: Updated for new build infrastructure
- packages: Updated submodule references

Libraries:
- system-cxx-std-lib: New C++ standard library wrapper
- ghc-internal: Updated configuration
- ghc-boot: Build system adjustments
- ghc-prim: Cross-compilation support

Testing Infrastructure:
- Updated test driver for multi-target scenarios
- Fixed platform-specific tests
- Adjusted test expectations for new architecture
- Added T10279h.hs test helper

External Dependencies:
- Removed libffi-tarballs (using system packages)
- Updated Cabal submodule
- Updated hsc2hs for cross-compilation

Utilities:
- unlit: Cross-platform compatibility
- ghc-toolchain: Target detection improvements
- config.guess/config.sub: GNU config files for RTS
- Added .envrc for development environment
- Added configure script for build configuration

Contributors:
- Moritz Angermann: Multi-target architecture and cross-compilation
- Sylvain Henry: JavaScript backend integration
- Andrea Bedini: Build system improvements
- Julian Ospald: Testing infrastructure and utilities

This completes the foundational work for GHC's multi-target support,
enabling efficient compilation for diverse platforms while maintaining
backward compatibility and build reproducibility.

Author: Stable Haskell Team

.envrc

@@ -0,0 +1,7 @@
+# Check if nix-direnv is already loaded; if not, source it
+if ! has nix_direnv_reload; then
+  source_url "https://raw.githubusercontent.com/nix-community/nix-direnv/3.0.7/direnvrc" "sha256-bn8WANE5a91RusFmRI7kS751ApelG02nMcwRekC/qzc="
+fi
+
+# Use the specified flake to enter the Nix development environment
+use flake github:input-output-hk/devx#ghc98-minimal-ghc

.gitmodules

@@ -8,8 +8,9 @@
 	ignore = untracked
 [submodule "libraries/Cabal"]
 	path = libraries/Cabal
-	url = https://gitlab.haskell.org/ghc/packages/Cabal.git
+	url = https://github.com/stable-haskell/Cabal.git
 	ignore = untracked
+	branch = stable-haskell/feature/cross-compile
 [submodule "libraries/containers"]
 	path = libraries/containers
 	url = https://gitlab.haskell.org/ghc/packages/containers.git
@@ -99,10 +100,6 @@
 	path = utils/hsc2hs
 	url = https://gitlab.haskell.org/ghc/hsc2hs.git
 	ignore = untracked
-[submodule "libffi-tarballs"]
-	path = libffi-tarballs
-	url = https://gitlab.haskell.org/ghc/libffi-tarballs.git
-	ignore = untracked
 [submodule "gmp-tarballs"]
 	path = libraries/ghc-internal/gmp/gmp-tarballs
 	url = https://gitlab.haskell.org/ghc/gmp-tarballs.git

compiler/CodeGen.Platform.h

@@ -7,7 +7,7 @@ import GHC.Utils.Panic.Plain
 #endif
 import GHC.Platform.Reg
 
-#include "MachRegs.h"
+#include "stg/MachRegs.h"
 
 #if defined(MACHREGS_i386) || defined(MACHREGS_x86_64)
 

compiler/GHC/Builtin/PrimOps.hs

@@ -25,7 +25,9 @@ module GHC.Builtin.PrimOps (
 
         getPrimOpResultInfo,  isComparisonPrimOp, PrimOpResultInfo(..),
 
-        PrimCall(..)
+        PrimCall(..),
+
+        primOpPrimModule, primOpWrappersModule
     ) where
 
 import GHC.Prelude
@@ -171,6 +173,12 @@ primOpDocs :: [(FastString, String)]
 primOpDeprecations :: [(OccName, FastString)]
 #include "primop-deprecations.hs-incl"
 
+primOpPrimModule :: String
+#include "primop-prim-module.hs-incl"
+
+primOpWrappersModule :: String
+#include "primop-wrappers-module.hs-incl"
+
 {-
 ************************************************************************
 *                                                                      *

compiler/GHC/ByteCode/Asm.hs

@@ -532,7 +532,7 @@ countSmall big x = count big False x
 
 
 -- Bring in all the bci_ bytecode constants.
-#include "Bytecodes.h"
+#include "rts/Bytecodes.h"
 
 largeArgInstr :: Word16 -> Word16
 largeArgInstr bci = bci_FLAG_LARGE_ARGS .|. bci

compiler/GHC/CmmToLlvm.hs

@@ -38,8 +38,8 @@ import GHC.Utils.Panic
 import GHC.Utils.Logger
 import qualified GHC.Data.Stream as Stream
 
-import Control.Monad ( when, forM_ )
-import Data.Maybe ( fromMaybe, catMaybes, isNothing )
+import Control.Monad ( forM_ )
+import Data.Maybe ( catMaybes )
 import System.IO
 
 -- -----------------------------------------------------------------------------
@@ -57,36 +57,8 @@ llvmCodeGen logger cfg h dus cmm_stream
        -- Pass header
        showPass logger "LLVM CodeGen"
 
-       -- get llvm version, cache for later use
-       let mb_ver = llvmCgLlvmVersion cfg
-
-       -- warn if unsupported
-       forM_ mb_ver $ \ver -> do
-         debugTraceMsg logger 2
-              (text "Using LLVM version:" <+> text (llvmVersionStr ver))
-         let doWarn = llvmCgDoWarn cfg
-         when (not (llvmVersionSupported ver) && doWarn) $ putMsg logger $
-           "You are using an unsupported version of LLVM!" $$
-           "Currently only" <+> text (llvmVersionStr supportedLlvmVersionLowerBound) <+>
-           "up to" <+> text (llvmVersionStr supportedLlvmVersionUpperBound) <+> "(non inclusive) is supported." <+>
-           "System LLVM version: " <> text (llvmVersionStr ver) $$
-           "We will try though..."
-
-       when (isNothing mb_ver) $ do
-         let doWarn = llvmCgDoWarn cfg
-         when doWarn $ putMsg logger $
-           "Failed to detect LLVM version!" $$
-           "Make sure LLVM is installed correctly." $$
-           "We will try though..."
-
-       -- HACK: the Nothing case here is potentially wrong here but we
-       -- currently don't use the LLVM version to guide code generation
-       -- so this is okay.
-       let llvm_ver :: LlvmVersion
-           llvm_ver = fromMaybe supportedLlvmVersionLowerBound mb_ver
-
        -- run code generation
-       (a, _) <- runLlvm logger cfg llvm_ver bufh dus $
+       (a, _) <- runLlvm logger cfg bufh dus $
          llvmCodeGen' cfg cmm_stream
 
        bFlush bufh

compiler/GHC/CmmToLlvm/Base.hs

@@ -18,7 +18,7 @@ module GHC.CmmToLlvm.Base (
         LlvmM,
         runLlvm, withClearVars, varLookup, varInsert,
         markStackReg, checkStackReg,
-        funLookup, funInsert, getLlvmVer,
+        funLookup, funInsert,
         dumpIfSetLlvm, renderLlvm, markUsedVar, getUsedVars,
         ghcInternalFunctions, getPlatform, getConfig,
 
@@ -277,8 +277,7 @@ llvmPtrBits platform = widthInBits $ typeWidth $ gcWord platform
 --
 
 data LlvmEnv = LlvmEnv
-  { envVersion   :: LlvmVersion      -- ^ LLVM version
-  , envConfig    :: !LlvmCgConfig    -- ^ Configuration for LLVM code gen
+  { envConfig    :: !LlvmCgConfig    -- ^ Configuration for LLVM code gen
   , envLogger    :: !Logger          -- ^ Logger
   , envOutput    :: BufHandle        -- ^ Output buffer
   , envTag       :: !Char            -- ^ Tag for creating unique values
@@ -331,16 +330,15 @@ liftUDSMT m = LlvmM $ \env -> do x <- m
                                  return (x, env)
 
 -- | Get initial Llvm environment.
-runLlvm :: Logger -> LlvmCgConfig -> LlvmVersion -> BufHandle -> DSM.DUniqSupply -> LlvmM a -> IO (a, DSM.DUniqSupply)
-runLlvm logger cfg ver out us m = do
+runLlvm :: Logger -> LlvmCgConfig -> BufHandle -> DSM.DUniqSupply -> LlvmM a -> IO (a, DSM.DUniqSupply)
+runLlvm logger cfg out us m = do
     ((a, _), us') <- DSM.runUDSMT us $ runLlvmM m env
     return (a, us')
   where env = LlvmEnv { envFunMap    = emptyUFM
                       , envVarMap    = emptyUFM
                       , envStackRegs = []
                       , envUsedVars  = []
                       , envAliases   = emptyUniqSet
-                      , envVersion   = ver
                       , envConfig    = cfg
                       , envLogger    = logger
                       , envOutput    = out
@@ -388,10 +386,6 @@ getMetaUniqueId :: LlvmM MetaId
 getMetaUniqueId = LlvmM $ \env ->
     return (envFreshMeta env, env { envFreshMeta = succ $ envFreshMeta env })
 
--- | Get the LLVM version we are generating code for
-getLlvmVer :: LlvmM LlvmVersion
-getLlvmVer = getEnv envVersion
-
 -- | Dumps the document if the corresponding flag has been set by the user
 dumpIfSetLlvm :: DumpFlag -> String -> DumpFormat -> Outp.SDoc -> LlvmM ()
 dumpIfSetLlvm flag hdr fmt doc = do

compiler/GHC/CmmToLlvm/Config.hs

@@ -25,7 +25,6 @@ data LlvmCgConfig = LlvmCgConfig
   , llvmCgAvxEnabled        :: !Bool
   , llvmCgBmiVersion        :: Maybe BmiVersion  -- ^ (x86) BMI instructions
   , llvmCgLlvmVersion       :: Maybe LlvmVersion -- ^ version of Llvm we're using
-  , llvmCgDoWarn            :: !Bool         -- ^ True ==> warn unsupported Llvm version
   , llvmCgLlvmTarget        :: !String       -- ^ target triple passed to LLVM
   , llvmCgLlvmConfig        :: !LlvmConfig   -- ^ Supported LLVM configurations.
                                              -- see Note [LLVM configuration]

compiler/GHC/CmmToLlvm/Version.hs

@@ -1,9 +1,6 @@
 module GHC.CmmToLlvm.Version
   ( LlvmVersion(..)
-  , supportedLlvmVersionLowerBound
-  , supportedLlvmVersionUpperBound
   , parseLlvmVersion
-  , llvmVersionSupported
   , llvmVersionStr
   , llvmVersionList
   )
@@ -12,7 +9,6 @@ where
 import GHC.Prelude
 
 import GHC.CmmToLlvm.Version.Type
-import GHC.CmmToLlvm.Version.Bounds
 
 import Data.Char (isDigit)
 import Data.List (intercalate)
@@ -32,10 +28,6 @@ parseLlvmVersion =
       where
         (ver_str, rest) = span isDigit s
 
-llvmVersionSupported :: LlvmVersion -> Bool
-llvmVersionSupported v =
-  v >= supportedLlvmVersionLowerBound && v < supportedLlvmVersionUpperBound
-
 llvmVersionStr :: LlvmVersion -> String
 llvmVersionStr = intercalate "." . map show . llvmVersionList