TODO

+Get rid of all the ToolchainSettings in Hadrian still (e.g. settings-clang-command)

compiler/GHC/Platform.hs

@@ -180,11 +180,6 @@ platformOS :: Platform -> OS
 platformOS platform = case platformArchOS platform of
    ArchOS _ os -> os
 
-isARM :: Arch -> Bool
-isARM (ArchARM {}) = True
-isARM ArchAArch64  = True
-isARM _ = False
-
 -- | This predicate tells us whether the platform is 32-bit.
 target32Bit :: Platform -> Bool
 target32Bit p =
@@ -192,11 +187,6 @@ target32Bit p =
       PW4 -> True
       PW8 -> False
 
--- | This predicate tells us whether the OS support Mach-O shared libraries.
-osMachOTarget :: OS -> Bool
-osMachOTarget OSDarwin = True
-osMachOTarget _ = False
-
 osUsesFrameworks :: OS -> Bool
 osUsesFrameworks OSDarwin = True
 osUsesFrameworks _        = False

configure.ac

@@ -643,7 +643,6 @@ dnl CONF_CC_OPTS_STAGE[012] accordingly.
 FP_CC_SUPPORTS_TARGET([$CC_STAGE0], [CONF_CC_OPTS_STAGE0], [CONF_CXX_OPTS_STAGE0], [CONF_GCC_LINKER_OPTS_STAGE0])
 FP_CC_SUPPORTS_TARGET([$CC], [CONF_CC_OPTS_STAGE1], [CONF_CXX_OPTS_STAGE1], [CONF_GCC_LINKER_OPTS_STAGE1])
 FP_CC_SUPPORTS_TARGET([$CC], [CONF_CC_OPTS_STAGE2], [CONF_CXX_OPTS_STAGE2], [CONF_GCC_LINKER_OPTS_STAGE2])
-FIND_GHC_TOOLCHAIN
 
 dnl Pass -Qunused-arguments or otherwise GHC will have very noisy invocations of Clang
 dnl TODO: Do we need -Qunused-arguments in CXX and GCC linker too?
@@ -1180,6 +1179,10 @@ checkMake380() {
 checkMake380 make
 checkMake380 gmake
 
+# Toolchain target files
+PREP_TARGET_FILE
+FIND_GHC_TOOLCHAIN
+
 AC_CONFIG_FILES(
 [ mk/project.mk
   hadrian/cfg/system.config
@@ -1188,6 +1191,7 @@ AC_CONFIG_FILES(
   hadrian/ghci-stack
   docs/users_guide/ghc_config.py
   distrib/configure.ac
+  default.target
 ])
 
 dnl Create the VERSION file, satisfying #22322.
@@ -1301,3 +1305,6 @@ mk/build.mk.sample to mk/build.mk, and edit the settings in there.
 For more information on how to configure your GHC build, see
    https://gitlab.haskell.org/ghc/ghc/wikis/building
 "]
+
+VALIDATE_GHC_TOOLCHAIN
+

default.target.in

+Target
+{ tgtArchOs = ArchOS {archOS_arch = @HaskellHostArch@, archOS_OS = @HaskellHostOs@}
+, tgtVendor = @HostVendor_CPPMaybeStr@
+, tgtSupportsGnuNonexecStack = @TargetHasGnuNonexecStackBool@
+, tgtSupportsSubsectionsViaSymbols = @TargetHasSubsectionsViaSymbolsBool@
+, tgtSupportsIdentDirective = @TargetHasIdentDirectiveBool@
+, tgtWordSize = WS@TargetWordSize@
+, tgtEndianness = @TargetEndianness@
+, tgtSymbolsHaveLeadingUnderscore = @LeadingUnderscoreBool@
+, tgtLlvmTarget = "@LlvmTarget@"
+, tgtUnregisterised = @UnregisterisedBool@
+, tgtTablesNextToCode = @TablesNextToCodeBool@
+, tgtUseLibffiForAdjustors = @UseLibffiForAdjustorsBool@
+, tgtCCompiler = Cc {ccProgram = Program {prgPath = "@SettingsCCompilerCommand@", prgFlags = @SettingsCCompilerFlagsList@}}
+, tgtCxxCompiler = Cxx {cxxProgram = Program {prgPath = "@SettingsCxxCompilerCommand@", prgFlags = @SettingsCxxCompilerFlagsList@}}
+, tgtCPreprocessor = Cpp {cppProgram = Program {prgPath = "@CPPCmd@", prgFlags = @CONF_CPP_OPTS_STAGE1List@}}
+, tgtHsCPreprocessor = HsCpp {hsCppProgram = Program {prgPath = "@HaskellCPPCmd@", prgFlags = @HaskellCPPArgsList@}}
+, tgtCCompilerLink = CcLink
+{ ccLinkProgram = Program {prgPath = "@SettingsCCompilerCommand@", prgFlags = @SettingsCCompilerLinkFlagsList@}
+, ccLinkSupportsNoPie = @SettingsCCompilerSupportsNoPieBool@
+, ccLinkSupportsCompactUnwind = @LdHasNoCompactUnwindBool@
+, ccLinkSupportsFilelist = @LdHasFilelistBool@
+, ccLinkIsGnu = @LdIsGNULdBool@
+}
+
+, tgtAr = Ar
+{ arMkArchive = Program {prgPath = "@AR@", prgFlags = @ArArgsList@}
+, arIsGnu = @ArIsGNUArBool@
+, arSupportsAtFile = @ArSupportsAtFileBool@
+, arSupportsDashL = @ArSupportsDashLBool@
+, arNeedsRanlib = @ArNeedsRanLibBool@
+}
+
+, tgtRanlib = Just (Ranlib {ranlibProgram = Program {prgPath = "@REAL_RANLIB_CMD@", prgFlags = []}})
+, tgtNm = Nm {nmProgram = Program {prgPath = "@NmCmd@", prgFlags = []}}
+, tgtMergeObjs = Just (MergeObjs {mergeObjsProgram = Program {prgPath = "@SettingsMergeObjectsCommand@", prgFlags = @SettingsMergeObjectsFlagsList@}, mergeObjsSupportsResponseFiles = @MergeObjsSupportsResponseFilesBool@})
+, tgtDllwrap = @SettingsDllWrapCommandMaybeProg@
+, tgtWindres = @SettingsWindresCommandMaybeProg@
+}

distrib/configure.ac.in

@@ -57,10 +57,12 @@ if test "$target" != "$host" ; then
                           #   configure: error: cannot run C compiled programs.
                           #   If you meant to cross compile, use `--host'.
 fi
+LeadingUnderscore="@LeadingUnderscore@"
 CrossCompilePrefix="@CrossCompilePrefix@"
 TargetPlatformFull="${target}"
 TablesNextToCode="@TablesNextToCode@"
 
+AC_SUBST(LeadingUnderscore)
 AC_SUBST(CrossCompiling)
 AC_SUBST(CrossCompilePrefix)
 AC_SUBST(TargetPlatformFull)
@@ -285,6 +287,7 @@ AC_SUBST(UseLibdw)
 FP_SETTINGS
 
 AC_CONFIG_FILES([config.mk])
+AC_CONFIG_FILES([default.target])
 AC_OUTPUT
 
 # We get caught by
@@ -306,6 +309,11 @@ checkMake380() {
 checkMake380 make
 checkMake380 gmake
 
+# Toolchain target files
+PREP_TARGET_FILE
+FIND_GHC_TOOLCHAIN
+VALIDATE_GHC_TOOLCHAIN
+
 echo "****************************************************"
 echo "Configuration done, ready to 'make install'"
 echo "(see README and INSTALL files for more info.)"

hadrian/bindist/Makefile

 MAKEFLAGS += --no-builtin-rules
 .SUFFIXES:
 
+# Configuration from the source distribution's configure script.
 include ./mk/project.mk
+
+# Configuration from the binary distribution's configure script.
 include ./config.mk
 
 .PHONY: default

hadrian/bindist/config.mk.in

@@ -254,6 +254,8 @@ TargetHasIdentDirective = @TargetHasIdentDirective@
 TargetHasSubsectionsViaSymbols = @TargetHasSubsectionsViaSymbols@
 TargetHasLibm = @TargetHasLibm@
 TablesNextToCode = @TablesNextToCode@
+LeadingUnderscore = @LeadingUnderscore@
+LlvmTarget = @LlvmTarget@
 
 SettingsCCompilerCommand = @SettingsCCompilerCommand@
 SettingsCxxCompilerCommand = @SettingsCxxCompilerCommand@

hadrian/cabal.project

 packages: ./
           ../utils/ghc-toolchain/
+          ../libraries/ghc-platform/
 
 -- This essentially freezes the build plan for hadrian
 index-state: 2023-03-30T10:00:00Z

hadrian/cfg/system.config.in

@@ -42,12 +42,10 @@ ghc-source-path      = @hardtop@
 # Information about build, host and target systems:
 #==================================================
 
-# Is the *-platform information available in the target?
-build-platform        = @BuildPlatform@
-
-host-platform         = @HostPlatform@
-
-target-platform       = @TargetPlatform@
+# Q: Is the *-platform information available in the target?
+# A: Yes, it is. We pass @BuildPlatform@ and @HostPlatform@ and @TargetPlatform@ to ghc-toolchain using --target=that
+#     And we can reconstruct the platform info using targetPlatformTriple
+# Q: What is TargetPlatformFull?
 target-platform-full  = @TargetPlatformFull@
 
 # ROMES:TODO: Drop cross-compiling, when we configure all 3 targets based on configure flags

hadrian/hadrian.cabal

@@ -166,8 +166,8 @@ executable hadrian
                        , text                 >= 1.2     && < 3
                        , cryptohash-sha256    >= 0.11    && < 0.12
                        , base16-bytestring    >= 0.1.1 && < 1.1.0.0
+                       , ghc-platform
                        , ghc-toolchain
-                       , ghc-boot
     ghc-options:       -Wall
                        -Wincomplete-record-updates
                        -Wredundant-constraints

hadrian/src/Base.hs

@@ -31,7 +31,7 @@ module Base (
     -- * Paths
     hadrianPath, configPath, configFile, sourcePath, shakeFilesDir,
     stageBinPath, stageLibPath, templateHscPath,
-    hostTargetFile, targetTargetFile,
+    buildTargetFile, hostTargetFile, targetTargetFile,
     ghcBinDeps, ghcLibDeps, haddockDeps,
     relativePackageDbPath, packageDbPath, packageDbStamp, mingwStamp,
     systemCxxStdLibConf, systemCxxStdLibConfPath
@@ -81,12 +81,17 @@ configFile :: FilePath
 configFile = configPath -/- "system.config"
 
 -- | The target configuration file generated by ghc-toolchain for the
--- compilation host
+-- compilation build platform
+buildTargetFile :: FilePath
+buildTargetFile = "default.target" -- ROMES:TODO: Not hardcode this value?
+
+-- | The target configuration file generated by ghc-toolchain for the
+-- compilation host platform
 hostTargetFile :: FilePath
 hostTargetFile = "default.target" -- ROMES:TODO: Not hardcode this value?
 
 -- | The target configuration file generated by ghc-toolchain for the
--- compilation target
+-- compilation target platform
 targetTargetFile :: FilePath
 targetTargetFile = "default.target" -- ROMES:TODO: Not hardcode this value, depends on target
 

hadrian/src/Builder.hs

@@ -471,16 +471,16 @@ systemBuilderPath builder = case builder of
 
     -- Get program from the host's target configuration
     fromHostTC keyname key = do
-        path <- queryHostTargetConfig (prgPath . key)
+        path <- queryHostTarget (prgPath . key)
         validate keyname path
 
     -- Get program from the target's target configuration
     fromTargetTC keyname key = do
-        path <- queryTargetTargetConfig (prgPath . key)
+        path <- queryTargetTarget (prgPath . key)
         validate keyname path
 
     validate keyname path = do
-        target <- getTargetTargetConfig
+        target <- getTargetTarget
         if null path
         then do
             unless (isOptional target builder) . error $ "Non optional builder "

hadrian/src/Context.hs

@@ -3,7 +3,7 @@ module Context (
     Context (..), vanillaContext, stageContext,
 
     -- * Expressions
-    getStage, getPackage, getWay, getBuildPath, getPackageDbLoc, getStagedTargetConfig,
+    getStage, getPackage, getWay, getBuildPath, getPackageDbLoc, getStagedTarget,
 
     -- * Paths
     contextDir, buildPath, buildDir, pkgInplaceConfig, pkgSetupConfigFile, pkgSetupConfigDir,
@@ -19,7 +19,9 @@ import Context.Type
 import Hadrian.Expression
 import Hadrian.Haskell.Cabal
 import Oracles.Setting
-import GHC.Toolchain.Target (Target)
+import GHC.Toolchain.Target (Target(..))
+import Hadrian.Oracles.TextFile
+import GHC.Platform.ArchOS
 
 -- | Most targets are built only one way, hence the notion of 'vanillaContext'.
 vanillaContext :: Stage -> Package -> Context
@@ -49,8 +51,8 @@ getWay :: Expr Context b Way
 getWay = way <$> getContext
 
 -- | Get the 'Target' configuration of the current stage
-getStagedTargetConfig :: Expr Context b Target
-getStagedTargetConfig = expr . targetConfigStage =<< getStage
+getStagedTarget :: Expr Context b Target
+getStagedTarget = expr . targetStage =<< getStage
 
 -- | Path to the directory containing the final artifact in a given 'Context'.
 libPath :: Context -> Action FilePath
@@ -63,12 +65,12 @@ libPath Context {..} = buildRoot <&> (-/- (stageString stage -/- "lib"))
 -- conventions (see 'cabalOsString' and 'cabalArchString').
 distDir :: Stage -> Action FilePath
 distDir st = do
-    let (os,arch) = case st of
-            Stage0 {} -> (HostOs , HostArch)
-            _      -> (TargetOs, TargetArch)
+    let queryStageTarget = case st of
+            Stage0 {} -> queryBuildTarget
+            _         -> queryHostTarget
     version        <- ghcVersionStage st
-    hostOs         <- cabalOsString <$> setting os
-    hostArch       <- cabalArchString <$> setting arch
+    hostOs         <- cabalOsString <$> queryStageTarget (stringEncodeOS . archOS_OS . tgtArchOs)
+    hostArch       <- cabalArchString <$> queryStageTarget (stringEncodeArch . archOS_arch . tgtArchOs)
     return $ hostArch ++ "-" ++ hostOs ++ "-ghc-" ++ version
 
 pkgFileName :: Context -> Package -> String -> String -> Action FilePath

hadrian/src/Flavour.hs

@@ -37,7 +37,6 @@ import Text.Parsec.Combinator as P
 import Text.Parsec.Char as P
 import Control.Monad.Except
 import UserSettings
-import Oracles.Flag
 
 
 flavourTransformers :: Map String (Flavour -> Flavour)

hadrian/src/Hadrian/Haskell/Hash.hs

@@ -129,7 +129,7 @@ pkgHashOracle = void $ addOracleCache $ \(PkgHashKey (stag, pkg)) -> do
   flav <- flavour
   let flavourArgs = extraArgs flav
 
-  targetOs       <- setting TargetOs
+  targetOs       <- queryTargetTarget queryOS
   projectVersion <- setting ProjectVersion
   let pkgHashCompilerId = "ghc-" ++ projectVersion
       pkgHashPlatform = targetOs

hadrian/src/Hadrian/Oracles/TextFile.hs

@@ -15,8 +15,8 @@
 module Hadrian.Oracles.TextFile (
     lookupValue, lookupValueOrEmpty, lookupValueOrError, lookupSystemConfig, lookupValues,
     lookupValuesOrEmpty, lookupValuesOrError, lookupDependencies, textFileOracle,
-    getHostTargetConfig, getTargetTargetConfig,
-    queryHostTargetConfig, queryTargetTargetConfig
+    getBuildTarget, getHostTarget, getTargetTarget,
+    queryBuildTarget, queryHostTarget, queryTargetTarget
     ) where
 
 import Control.Monad
@@ -90,22 +90,28 @@ lookupDependencies depFile file = do
 getTargetConfig :: FilePath -> Action Toolchain.Target
 getTargetConfig file = askOracle $ TargetFile file
 
--- | Get the host's target configuration through 'getTarget'
--- ROMES:TODO: Rename HOST to BUILD
-getHostTargetConfig :: Action Toolchain.Target
-getHostTargetConfig = getTargetConfig hostTargetFile
+-- | Get the build target configuration through 'getTargetConfig'
+getBuildTarget :: Action Toolchain.Target
+getBuildTarget = getTargetConfig buildTargetFile
+
+-- | Get the host target configuration through 'getTargetConfig'
+getHostTarget :: Action Toolchain.Target
+getHostTarget = getTargetConfig hostTargetFile
   -- where
   --   msg = "The host's target configuration file " ++ quote hostTargetFile ++ " does not exist! ghc-toolchain might have failed to generate it."
 
--- | Get the target's target configuration through 'getTarget'
-getTargetTargetConfig :: Action Toolchain.Target
-getTargetTargetConfig = getTargetConfig targetTargetFile
+-- | Get the target target configuration through 'getTargetConfig'
+getTargetTarget :: Action Toolchain.Target
+getTargetTarget = getTargetConfig targetTargetFile
+
+queryBuildTarget :: (Toolchain.Target -> a) -> Action a
+queryBuildTarget f = f <$> getBuildTarget
 
-queryHostTargetConfig :: (Toolchain.Target -> String) -> Action String
-queryHostTargetConfig f = f <$> getHostTargetConfig
+queryHostTarget :: (Toolchain.Target -> a) -> Action a
+queryHostTarget f = f <$> getHostTarget
 
-queryTargetTargetConfig :: (Toolchain.Target -> String) -> Action String
-queryTargetTargetConfig f = f <$> getTargetTargetConfig
+queryTargetTarget :: (Toolchain.Target -> a) -> Action a
+queryTargetTarget f = f <$> getTargetTarget
 
 newtype KeyValue = KeyValue (FilePath, String)
     deriving (Binary, Eq, Hashable, NFData, Show, Typeable)
@@ -164,5 +170,5 @@ instance Hashable Toolchain.Target where
   hashWithSalt s = hashWithSalt s . show
 
 instance NFData Toolchain.Target where
-  rnf = flip seq () -- ROMES:TODO: Would be better to do this well, but it isn't easy to make instances for Target
+  rnf = flip seq () -- ROMES:TODO: Would be better to have a correct instance, perhaps we could instance NFData in ghc-toolchain?
 

hadrian/src/Oracles/Flag.hs

@@ -19,25 +19,15 @@ import Oracles.Setting
 
 import GHC.Toolchain.Target (Target(..))
 import qualified GHC.Toolchain as Toolchain
+import GHC.Platform.ArchOS
 
--- romes:todo: there's a bit overlap between the toolchain configuration and
--- some flags.  I wonder to what extent we should delete those Flag
--- constructors in favour of querying the toolchain directly
-data Flag = ArSupportsAtFile
-          | ArSupportsDashL
-          | SystemArSupportsAtFile
-          | SystemArSupportsDashL
-          | CrossCompiling
+data Flag = CrossCompiling -- what is cross compiling
           | CcLlvmBackend
-          | GhcUnregisterised
-          | TablesNextToCode
           | GmpInTree
           | GmpFrameworkPref
-          | LeadingUnderscore
           | UseSystemFfi
           | BootstrapThreadedRts
           | BootstrapEventLoggingRts
-          | UseLibffiForAdjustors
           | UseLibdw
           | UseLibnuma
           | UseLibzstd
@@ -49,55 +39,32 @@ data Flag = ArSupportsAtFile
           | UseLibpthread
           | NeedLibatomic
 
-data FlagKey = SystemConfigKey String
-              | HostTargetKey (Toolchain.Target -> Bool)
-              | TargetTargetKey (Toolchain.Target -> Bool)
-
 -- Note, if a flag is set to empty string we treat it as set to NO. This seems
 -- fragile, but some flags do behave like this.
 flag :: Flag -> Action Bool
 flag f = do
-    -- ROMES:TODO: Use queryToolchainConfig directly, which perhaps allows us
-    -- to get rid of the Oracle for the whole toolchain, which requires weak
-    -- orphan instances.
-    let flagkey :: FlagKey = case f of
-            ArSupportsAtFile     -> TargetTargetKey (Toolchain.arSupportsAtFile . tgtAr)
-            ArSupportsDashL      -> TargetTargetKey (Toolchain.arSupportsDashL  . tgtAr)
-            SystemArSupportsAtFile-> HostTargetKey  (Toolchain.arSupportsAtFile . tgtAr)
-            SystemArSupportsDashL-> HostTargetKey   (Toolchain.arSupportsDashL  . tgtAr)
-            CrossCompiling       -> SystemConfigKey "cross-compiling"
-            CcLlvmBackend        -> SystemConfigKey "cc-llvm-backend"
-            GhcUnregisterised    -> TargetTargetKey tgtUnregisterised
-            TablesNextToCode     -> TargetTargetKey tgtTablesNextToCode
-            GmpInTree            -> SystemConfigKey "intree-gmp"
-            GmpFrameworkPref     -> SystemConfigKey "gmp-framework-preferred"
-            LeadingUnderscore    -> TargetTargetKey tgtSymbolsHaveLeadingUnderscore
-            UseSystemFfi         -> SystemConfigKey "use-system-ffi"
-            BootstrapThreadedRts -> SystemConfigKey "bootstrap-threaded-rts"
-            BootstrapEventLoggingRts -> SystemConfigKey "bootstrap-event-logging-rts"
-            UseLibffiForAdjustors -> HostTargetKey tgtUseLibffiForAdjustors
-            UseLibdw             -> SystemConfigKey "use-lib-dw"
-            UseLibnuma           -> SystemConfigKey "use-lib-numa"
-            UseLibzstd           -> SystemConfigKey "use-lib-zstd"
-            StaticLibzstd        -> SystemConfigKey "static-lib-zstd"
-            UseLibm              -> SystemConfigKey "use-lib-m"
-            UseLibrt             -> SystemConfigKey "use-lib-rt"
-            UseLibdl             -> SystemConfigKey "use-lib-dl"
-            UseLibbfd            -> SystemConfigKey "use-lib-bfd"
-            UseLibpthread        -> SystemConfigKey "use-lib-pthread"
-            NeedLibatomic        -> SystemConfigKey "need-libatomic"
-    case flagkey of
-      SystemConfigKey key -> do
-        value <- lookupSystemConfig key
-        when (value `notElem` ["YES", "NO", ""]) . error $ "Configuration flag "
-            ++ quote (key ++ " = " ++ value) ++ " cannot be parsed."
-        return $ value == "YES"
-      HostTargetKey key -> do
-        value <- key <$> getHostTargetConfig
-        return value
-      TargetTargetKey key -> do
-        value <- key <$> getTargetTargetConfig
-        return value
+    let key = case f of
+            CrossCompiling       -> "cross-compiling"
+            CcLlvmBackend        -> "cc-llvm-backend"
+            GmpInTree            -> "intree-gmp"
+            GmpFrameworkPref     -> "gmp-framework-preferred"
+            UseSystemFfi         -> "use-system-ffi"
+            BootstrapThreadedRts -> "bootstrap-threaded-rts"
+            BootstrapEventLoggingRts -> "bootstrap-event-logging-rts"
+            UseLibdw             -> "use-lib-dw"
+            UseLibnuma           -> "use-lib-numa"
+            UseLibzstd           -> "use-lib-zstd"
+            StaticLibzstd        -> "static-lib-zstd"
+            UseLibm              -> "use-lib-m"
+            UseLibrt             -> "use-lib-rt"
+            UseLibdl             -> "use-lib-dl"
+            UseLibbfd            -> "use-lib-bfd"
+            UseLibpthread        -> "use-lib-pthread"
+            NeedLibatomic        -> "need-libatomic"
+    value <- lookupSystemConfig key
+    when (value `notElem` ["YES", "NO", ""]) . error $ "Configuration flag "
+        ++ quote (key ++ " = " ++ value) ++ " cannot be parsed."
+    return $ value == "YES"
 
 -- | Get a configuration setting.
 getFlag :: Flag -> Expr c b Bool
@@ -105,48 +72,50 @@ getFlag = expr . flag
 
 -- | Does the platform support object merging (and therefore we can build GHCi objects
 -- when appropriate).
+--
+-- ROMES:TODO: Which platform? Target?
 platformSupportsGhciObjects :: Action Bool
-platformSupportsGhciObjects =
-    not . null <$> settingsFileSetting ToolchainSetting_MergeObjectsCommand
+platformSupportsGhciObjects = isJust <$> queryTargetTarget tgtMergeObjs
 
 arSupportsDashL :: Stage -> Action Bool
-arSupportsDashL (Stage0 {}) = flag SystemArSupportsDashL
-arSupportsDashL _           = flag ArSupportsDashL
+-- ROMES:TODO: Build vs Host vs Target, is it Build and Host or Host and Target here?
+arSupportsDashL (Stage0 {}) = queryBuildTarget (Toolchain.arSupportsDashL . tgtAr)
+arSupportsDashL _           = queryHostTarget (Toolchain.arSupportsDashL . tgtAr)
 
 arSupportsAtFile :: Stage -> Action Bool
-arSupportsAtFile (Stage0 {}) = flag SystemArSupportsAtFile
-arSupportsAtFile _           = flag ArSupportsAtFile
+arSupportsAtFile (Stage0 {}) = queryBuildTarget (Toolchain.arSupportsAtFile . tgtAr)
+arSupportsAtFile _           = queryHostTarget (Toolchain.arSupportsAtFile . tgtAr)
 
 platformSupportsSharedLibs :: Action Bool
 platformSupportsSharedLibs = do
     windows       <- isWinTarget
-    wasm          <- anyTargetArch [ "wasm32" ]
+    wasm          <- anyTargetArch [ ArchWasm32 ]
     ppc_linux     <- anyTargetPlatform [ "powerpc-unknown-linux" ]
     solaris       <- anyTargetPlatform [ "i386-unknown-solaris2" ]
-    javascript    <- anyTargetArch     [ "javascript" ]
+    javascript    <- anyTargetArch     [ ArchJavaScript ]
     return $ not (windows || wasm || javascript || ppc_linux || solaris)
 
 -- | Does the target support threaded RTS?
 targetSupportsThreadedRts :: Action Bool
 targetSupportsThreadedRts = do
-    bad_arch <- anyTargetArch [ "wasm32", "javascript" ]
+    bad_arch <- anyTargetArch [ ArchWasm32, ArchJavaScript ]
     return $ not bad_arch
 
 -- | Does the target support the -N RTS flag?
 targetSupportsSMP :: Action Bool
 targetSupportsSMP = do
-  unreg <- flag GhcUnregisterised
+  unreg <- queryTargetTarget tgtUnregisterised
   armVer <- targetArmVersion
-  goodArch <- anyTargetArch ["i386"
-                            , "x86_64"
-                            , "powerpc"
-                            , "powerpc64"
-                            , "powerpc64le"
-                            , "arm"
-                            , "aarch64"
-                            , "s390x"
-                            , "riscv64"
-                            , "loongarch64"]
+  goodArch <- (||) <$>
+              anyTargetArch [ ArchX86
+                            , ArchX86_64
+                            , ArchPPC
+                            , ArchPPC_64 ELF_V1
+                            , ArchPPC_64 ELF_V2
+                            , ArchAArch64
+                            , ArchS390X
+                            , ArchRISCV64
+                            , ArchLoongArch64 ] <*> isArmTarget
   if   -- The THREADED_RTS requires `BaseReg` to be in a register and the
        -- Unregisterised mode doesn't allow that.
      | unreg                -> return False
@@ -157,4 +126,4 @@ targetSupportsSMP = do
      | otherwise            -> return False
 
 useLibffiForAdjustors :: Action Bool
-useLibffiForAdjustors = flag UseLibffiForAdjustors
+useLibffiForAdjustors = queryTargetTarget tgtUseLibffiForAdjustors

hadrian/src/Oracles/Setting.hs

@@ -6,12 +6,11 @@ module Oracles.Setting (
 
     -- * Helpers
     ghcCanonVersion, cmdLineLengthLimit, hostSupportsRPaths, topDirectory,
-    libsuf, ghcVersionStage, bashPath, targetConfigStage,
+    libsuf, ghcVersionStage, bashPath, targetStage,
 
     -- ** Target platform things
     anyTargetPlatform, anyTargetOs, anyTargetArch, anyHostOs,
-    isElfTarget, isOsxTarget, isWinTarget, isJsTarget,
-    ArmVersion(..),
+    isElfTarget, isOsxTarget, isWinTarget, isJsTarget, isArmTarget,
     targetArmVersion,
     ghcWithInterpreter
     ) where
@@ -21,11 +20,12 @@ import System.Info.Extra
 import Hadrian.Expression
 import Hadrian.Oracles.TextFile
 import Hadrian.Oracles.Path
+import Control.Monad.Trans (lift)
+import Control.Monad.Trans.Maybe (runMaybeT)
 
 import Base
 
 import GHC.Toolchain
-import GHC.Toolchain.Program
 import GHC.Platform.ArchOS
 
 -- | Each 'Setting' comes from the file @hadrian/cfg/system.config@, generated
@@ -38,12 +38,11 @@ import GHC.Platform.ArchOS
 -- looks up the value of the setting and returns the string @"mingw32"@,
 -- tracking the result in the Shake database.
 --
--- romes:TODO: Some (not much) overlap with Toolchain Target. Consider dropping duplicate things
-data Setting = BuildArch
-             | BuildOs
-             | BuildPlatform
-             | BuildVendor
-             | CursesIncludeDir
+-- ROMES:TODO: *Platform are passed to ghc-toolchain in --target
+-- We can reconstruct the *Platform information from the toolchain (targetPlatformTriple)
+--
+-- * How to handle target-platform-full?
+data Setting = CursesIncludeDir
              | CursesLibDir
              | DynamicExtension
              | FfiIncludeDir
@@ -55,12 +54,6 @@ data Setting = BuildArch
              | GhcSourcePath
              | GmpIncludeDir
              | GmpLibDir
-             | HostArch
-             | HostOs
-             | HostPlatform
-             | HostVendor
-             | HostArchHaskell
-             | HostOsHaskell
              | IconvIncludeDir
              | IconvLibDir
              | LibdwIncludeDir
@@ -69,7 +62,6 @@ data Setting = BuildArch
              | LibnumaLibDir
              | LibZstdIncludeDir
              | LibZstdLibDir
-             | LlvmTarget
              | ProjectGitCommitId
              | ProjectName
              | ProjectVersion
@@ -79,15 +71,7 @@ data Setting = BuildArch
              | ProjectPatchLevel1
              | ProjectPatchLevel2
              | SystemGhc
-             | TargetArch
-             | TargetOs
-             | TargetPlatform
              | TargetPlatformFull
-             | TargetVendor
-             | TargetArchHaskell
-             | TargetOsHaskell
-             | TargetArmVersion
-             | TargetWordSize
              | BourneShell
 
 -- TODO compute solely in Hadrian, removing these variables' definitions
@@ -97,32 +81,14 @@ data Setting = BuildArch
 -- | All 'ToolchainSetting's are computed by the ghc-toolchain utility for configuring toolchains.
 -- This used to be defined by 'FP_SETTINGS' in aclocal.m4.
 --
--- romes:todo: almost all the ToolchainSetting's are available per toolchain
--- target. Consider dropping this in favour of a more uniform way to query the
--- target.
+-- TODO: We should be able to drop this completely, after moving all the toolchain settings to ghc-toolchain
 data ToolchainSetting
-    = ToolchainSetting_CCompilerCommand
-    | ToolchainSetting_CxxCompilerCommand
-    | ToolchainSetting_CPPCommand
-    | ToolchainSetting_CPPFlags
-    | ToolchainSetting_HaskellCPPCommand
-    | ToolchainSetting_HaskellCPPFlags
-    | ToolchainSetting_CCompilerFlags
-    | ToolchainSetting_CxxCompilerFlags
-    | ToolchainSetting_CCompilerLinkFlags
-    | ToolchainSetting_CCompilerSupportsNoPie
-    | ToolchainSetting_MergeObjectsCommand
-    | ToolchainSetting_MergeObjectsFlags
-    | ToolchainSetting_ArCommand
-    | ToolchainSetting_RanlibCommand
-    | ToolchainSetting_OtoolCommand
+    = ToolchainSetting_OtoolCommand
     | ToolchainSetting_InstallNameToolCommand
-    | ToolchainSetting_DllWrapCommand
-    | ToolchainSetting_WindresCommand
     | ToolchainSetting_TouchCommand
-    | ToolchainSetting_ClangCommand
     | ToolchainSetting_LlcCommand
     | ToolchainSetting_OptCommand
+    | ToolchainSetting_ClangCommand
     | ToolchainSetting_DistroMinGW
 
 -- | Look up the value of a 'Setting' in @cfg/system.config@, tracking the
@@ -130,99 +96,54 @@ data ToolchainSetting
 -- ROMES:TODO: Things that are gotten from the toolchain configs will no longer
 -- be part of settings, so they should be moved out.
 setting :: Setting -> Action String
-setting key = case key of
-    BuildArch          -> hostConf archStr -- ROMES:TODO: This is only correct while we assume BUILD=HOST=TARGET
-    BuildOs            -> hostConf osStr   -- This too.
-    BuildPlatform      -> systemConf "build-platform"
-    BuildVendor        -> hostConf tgtVendor -- ROMES:TODO: buildConf
-    CursesIncludeDir   -> systemConf "curses-include-dir"
-    CursesLibDir       -> systemConf "curses-lib-dir"
-    DynamicExtension   -> systemConf "dynamic-extension"
-    FfiIncludeDir      -> systemConf "ffi-include-dir"
-    FfiLibDir          -> systemConf "ffi-lib-dir"
-    GhcMajorVersion    -> systemConf "ghc-major-version"
-    GhcMinorVersion    -> systemConf "ghc-minor-version"
-    GhcPatchLevel      -> systemConf "ghc-patch-level"
-    GhcVersion         -> systemConf "ghc-version"
-    GhcSourcePath      -> systemConf "ghc-source-path"
-    GmpIncludeDir      -> systemConf "gmp-include-dir"
-    GmpLibDir          -> systemConf "gmp-lib-dir"
-    HostArch           -> hostConf archStr
-    HostOs             -> hostConf osStr
-    HostPlatform       -> systemConf "host-platform"
-    HostVendor         -> hostConf tgtVendor
-    HostArchHaskell    -> hostConf (show . archHaskell)
-    HostOsHaskell      -> hostConf (show . osHaskell)
-    IconvIncludeDir    -> systemConf "iconv-include-dir"
-    IconvLibDir        -> systemConf "iconv-lib-dir"
-    LibdwIncludeDir    -> systemConf "libdw-include-dir"
-    LibdwLibDir        -> systemConf "libdw-lib-dir"
-    LibnumaIncludeDir  -> systemConf "libnuma-include-dir"
-    LibnumaLibDir      -> systemConf "libnuma-lib-dir"
-    LibZstdIncludeDir  -> systemConf "libzstd-include-dir"
-    LibZstdLibDir      -> systemConf "libzstd-lib-dir"
-    LlvmTarget         -> targetConf tgtLlvmTarget
-    ProjectGitCommitId -> systemConf "project-git-commit-id"
-    ProjectName        -> systemConf "project-name"
-    ProjectVersion     -> systemConf "project-version"
-    ProjectVersionMunged -> systemConf "project-version-munged"
-    ProjectVersionInt  -> systemConf "project-version-int"
-    ProjectPatchLevel  -> systemConf "project-patch-level"
-    ProjectPatchLevel1 -> systemConf "project-patch-level1"
-    ProjectPatchLevel2 -> systemConf "project-patch-level2"
-    SystemGhc          -> systemConf "system-ghc"
-    TargetArch         -> targetConf archStr
-    TargetArmVersion   -> systemConf "target-arm-version"
-    TargetOs           -> targetConf osStr
-    TargetPlatform     -> systemConf "target-platform"
-    TargetPlatformFull -> systemConf "target-platform-full"
-    TargetVendor       -> targetConf tgtVendor
-    TargetArchHaskell  -> targetConf (show . archHaskell)
-    TargetOsHaskell    -> targetConf (show . osHaskell)
-    TargetWordSize     -> targetConf (show . wordSize2Bytes . tgtWordSize)
-    BourneShell        -> systemConf "bourne-shell"
-  where
-    systemConf = lookupSystemConfig
-    targetConf = queryTargetTargetConfig
-    hostConf   = queryHostTargetConfig
-    archStr     = stringEncodeArch . archHaskell
-    osStr       = stringEncodeOS   . osHaskell
-    archHaskell = archOS_arch . tgtArchOs
-    osHaskell   = archOS_OS   . tgtArchOs
+setting key = lookupSystemConfig $ case key of
+    CursesIncludeDir   -> "curses-include-dir"
+    CursesLibDir       -> "curses-lib-dir"
+    DynamicExtension   -> "dynamic-extension"
+    FfiIncludeDir      -> "ffi-include-dir"
+    FfiLibDir          -> "ffi-lib-dir"
+    GhcMajorVersion    -> "ghc-major-version"
+    GhcMinorVersion    -> "ghc-minor-version"
+    GhcPatchLevel      -> "ghc-patch-level"
+    GhcVersion         -> "ghc-version"
+    GhcSourcePath      -> "ghc-source-path"
+    GmpIncludeDir      -> "gmp-include-dir"
+    GmpLibDir          -> "gmp-lib-dir"
+    IconvIncludeDir    -> "iconv-include-dir"
+    IconvLibDir        -> "iconv-lib-dir"
+    LibdwIncludeDir    -> "libdw-include-dir"
+    LibdwLibDir        -> "libdw-lib-dir"
+    LibnumaIncludeDir  -> "libnuma-include-dir"
+    LibnumaLibDir      -> "libnuma-lib-dir"
+    LibZstdIncludeDir  -> "libzstd-include-dir"
+    LibZstdLibDir      -> "libzstd-lib-dir"
+    ProjectGitCommitId -> "project-git-commit-id"
+    ProjectName        -> "project-name"
+    ProjectVersion     -> "project-version"
+    ProjectVersionMunged -> "project-version-munged"
+    ProjectVersionInt  -> "project-version-int"
+    ProjectPatchLevel  -> "project-patch-level"
+    ProjectPatchLevel1 -> "project-patch-level1"
+    ProjectPatchLevel2 -> "project-patch-level2"
+    SystemGhc          -> "system-ghc"
+    TargetPlatformFull -> "target-platform-full"
+    BourneShell        -> "bourne-shell"
 
 -- | Look up the value of a 'SettingList' in @cfg/system.config@, tracking the
 -- result.
 -- See Note [tooldir: How GHC finds mingw on Windows]
 -- ROMES:TODO: This should be queryTargetTargetConfig
 settingsFileSetting :: ToolchainSetting -> Action String
-settingsFileSetting key = case key of
-    ToolchainSetting_CCompilerCommand       -> queryHostTargetConfig (cmd . ccProgram . tgtCCompiler)
-    ToolchainSetting_CxxCompilerCommand     -> queryHostTargetConfig (cmd . cxxProgram . tgtCxxCompiler)
-    ToolchainSetting_CPPCommand             -> queryHostTargetConfig (cmd . cppProgram . tgtCPreprocessor)
-    ToolchainSetting_CPPFlags               -> queryHostTargetConfig (flags . cppProgram . tgtCPreprocessor)
-    ToolchainSetting_HaskellCPPCommand      -> queryHostTargetConfig (cmd . hsCppProgram . tgtHsCPreprocessor)
-    ToolchainSetting_HaskellCPPFlags        -> queryHostTargetConfig (flags . hsCppProgram . tgtHsCPreprocessor)
-    ToolchainSetting_CCompilerFlags         -> queryHostTargetConfig (flags . ccProgram . tgtCCompiler)
-    ToolchainSetting_CxxCompilerFlags       -> queryHostTargetConfig (flags . cxxProgram . tgtCxxCompiler)
-    ToolchainSetting_CCompilerLinkFlags     -> queryHostTargetConfig (flags . ccLinkProgram . tgtCCompilerLink)
-    ToolchainSetting_CCompilerSupportsNoPie -> queryHostTargetConfig (yesNo . ccLinkSupportsNoPie . tgtCCompilerLink)
-    ToolchainSetting_MergeObjectsCommand    -> queryHostTargetConfig (maybe "" (cmd . mergeObjsProgram) . tgtMergeObjs)
-    ToolchainSetting_MergeObjectsFlags      -> queryHostTargetConfig (maybe "" (flags . mergeObjsProgram) . tgtMergeObjs)
-    ToolchainSetting_ArCommand              -> queryHostTargetConfig (cmd . arMkArchive . tgtAr)
-    ToolchainSetting_RanlibCommand          -> queryHostTargetConfig (maybe "" (cmd . ranlibProgram) . tgtRanlib)
-    ToolchainSetting_OtoolCommand           -> lookupSystemConfig "settings-otool-command"
-    ToolchainSetting_InstallNameToolCommand -> lookupSystemConfig "settings-install_name_tool-command"
-    ToolchainSetting_DllWrapCommand         -> queryHostTargetConfig (maybe "" cmd . tgtDllwrap)
-    ToolchainSetting_WindresCommand         -> queryHostTargetConfig (maybe "" cmd . tgtWindres)
-    ToolchainSetting_TouchCommand           -> lookupSystemConfig "settings-touch-command"
-    ToolchainSetting_ClangCommand           -> lookupSystemConfig "settings-clang-command"
-    ToolchainSetting_LlcCommand             -> lookupSystemConfig "settings-llc-command"
-    ToolchainSetting_OptCommand             -> lookupSystemConfig "settings-opt-command"
-    -- ROMES:TODO: affter handling DistroMinGW and aboves in ghc-toolchain, factor queryHostTargetConfig out
-    ToolchainSetting_DistroMinGW            -> lookupSystemConfig "settings-use-distro-mingw" -- ROMES:TODO: This option doesn't seem to be in ghc-toolchain yet
-    where
-      flags = unwords . prgFlags
-      cmd   = prgPath
+settingsFileSetting key = lookupSystemConfig $ case key of
+    ToolchainSetting_OtoolCommand           -> "settings-otool-command"
+    ToolchainSetting_InstallNameToolCommand -> "settings-install_name_tool-command"
+    ToolchainSetting_TouchCommand           -> "settings-touch-command"
+    -- TODO DELETE:
+    ToolchainSetting_ClangCommand           -> "settings-clang-command"
+    ToolchainSetting_LlcCommand             -> "settings-llc-command"
+    ToolchainSetting_OptCommand             -> "settings-opt-command"
+    -- ROMES:TODO: after handling DistroMinGW and aboves in ghc-toolchain, factor queryHostTargetConfig out
+    ToolchainSetting_DistroMinGW            -> "settings-use-distro-mingw" -- ROMES:TODO: This option doesn't seem to be in ghc-toolchain yet
 
 -- | An expression that looks up the value of a 'Setting' in @cfg/system.config@,
 -- tracking the result.
@@ -241,74 +162,65 @@ matchSetting key values = (`elem` values) <$> setting key
 anyTargetPlatform :: [String] -> Action Bool
 anyTargetPlatform = matchSetting TargetPlatformFull
 
--- | Check whether the target OS setting matches one of the given strings.
-anyTargetOs :: [String] -> Action Bool
-anyTargetOs = matchSetting TargetOs
-
 isWinTarget :: Action Bool
-isWinTarget = anyTargetOs ["mingw32"]
+isWinTarget = anyTargetOs [OSMinGW32]
 
 isJsTarget :: Action Bool
-isJsTarget = anyTargetArch ["javascript"]
+isJsTarget = anyTargetArch [ArchJavaScript]
 
 isOsxTarget :: Action Bool
-isOsxTarget = anyTargetOs ["darwin"]
+isOsxTarget = anyTargetOs [OSDarwin]
 
--- | Check whether the target architecture setting matches one of the given
--- strings.
-anyTargetArch :: [String] -> Action Bool
-anyTargetArch = matchSetting TargetArch
+isArmTarget :: Action Bool
+isArmTarget = queryTargetTarget (isARM . archOS_arch . tgtArchOs)
 
 -- | Check whether the host OS setting matches one of the given strings.
-anyHostOs :: [String] -> Action Bool
-anyHostOs = matchSetting HostOs
+anyHostOs :: [OS] -> Action Bool
+anyHostOs oss = (`elem` oss) <$> queryHostTarget (archOS_OS . tgtArchOs)
 
--- | List of OSes that use the ELF object format.
-elfOSes :: [String]
-elfOSes =
-    [ "linux", "freebsd", "dragonfly", "openbsd", "netbsd", "solaris2", "kfreebsdgnu"
-    , "haiku", "linux-android"
-    ]
+-- | Check whether the target architecture setting matches one of the given
+-- strings.
+anyTargetArch :: [Arch] -> Action Bool
+anyTargetArch archs = (`elem` archs) <$> queryTargetTarget (archOS_arch . tgtArchOs)
 
--- | List of OSes that use the Mach-O object format.
-machoOSes :: [String]
-machoOSes = [ "darwin" ]
+-- | Check whether the target OS setting matches one of the given strings.
+anyTargetOs :: [OS] -> Action Bool
+anyTargetOs oss = (`elem` oss) <$> queryTargetTarget (archOS_OS . tgtArchOs)
 
 -- | Check whether the target OS uses the ELF object format.
 isElfTarget :: Action Bool
-isElfTarget = anyTargetOs elfOSes
+isElfTarget = queryTargetTarget (osElfTarget . archOS_OS . tgtArchOs)
 
 -- | Check whether the host OS supports the @-rpath@ linker option when
 -- using dynamic linking.
 --
+-- ROMES:TODO: Whether supports -rpath should be determined by ghc-toolchain
+--
 -- TODO: Windows supports lazy binding (but GHC doesn't currently support
 --       dynamic way on Windows anyways).
 hostSupportsRPaths :: Action Bool
-hostSupportsRPaths = anyHostOs (elfOSes ++ machoOSes)
+hostSupportsRPaths = queryHostTarget (\t -> let os = archOS_OS (tgtArchOs t)
+                                             in osElfTarget os || osMachOTarget os)
 
 -- | Check whether the target supports GHCi.
 ghcWithInterpreter :: Action Bool
 ghcWithInterpreter = do
-    goodOs <- anyTargetOs [ "mingw32", "cygwin32", "linux", "solaris2"
-                          , "freebsd", "dragonfly", "netbsd", "openbsd"
-                          , "darwin", "kfreebsdgnu" ]
-    goodArch <- anyTargetArch [ "i386", "x86_64", "powerpc"
-                              , "arm", "aarch64", "s390x"
-                              , "powerpc64", "powerpc64le" ]
+    goodOs <- anyTargetOs [ OSMinGW32, OSLinux, OSSolaris2 -- TODO "cygwin32"?,
+                          , OSFreeBSD, OSDragonFly, OSNetBSD, OSOpenBSD
+                          , OSDarwin, OSKFreeBSD ]
+    goodArch <- (||) <$>
+                anyTargetArch [ ArchX86, ArchX86_64, ArchPPC
+                              , ArchAArch64, ArchS390X
+                              , ArchPPC_64 ELF_V1, ArchPPC_64 ELF_V2 ]
+                              <*> isArmTarget
     return $ goodOs && goodArch
 
--- | Variants of the ARM architecture.
-data ArmVersion = ARMv5 | ARMv6 | ARMv7
-                deriving (Eq, Ord, Show, Read)
-
 -- | Which variant of the ARM architecture is the target (or 'Nothing' if not
 -- ARM)?
-targetArmVersion :: Action (Maybe ArmVersion)
-targetArmVersion = do
-  isArm <- anyTargetArch [ "arm" ]
-  if isArm
-    then Just . read <$> setting TargetArmVersion
-    else return Nothing
+targetArmVersion :: Action (Maybe ArmISA)
+targetArmVersion = runMaybeT $ do
+    ArchARM isa _ _ <- lift $ queryTargetTarget (archOS_arch . tgtArchOs)
+    return isa
 
 -- | Canonicalised GHC version number, used for integer version comparisons. We
 -- expand 'GhcMinorVersion' to two digits by adding a leading zero if necessary.
@@ -350,10 +262,11 @@ libsuf st way
         let suffix = waySuffix (removeWayUnit Dynamic way)
         return (suffix ++ "-ghc" ++ version ++ extension)
 
-targetConfigStage :: Stage -> Action Target
+targetStage :: Stage -> Action Target
 -- ROMES:TODO: First iteration, only make it work for BUILD=HOST=TARGET
-targetConfigStage (Stage0 {}) = getHostTargetConfig
-targetConfigStage (Stage1 {}) = getHostTargetConfig
-targetConfigStage (Stage2 {}) = getHostTargetConfig
-targetConfigStage (Stage3 {}) = getHostTargetConfig
+-- What are the correct targets here?
+targetStage (Stage0 {}) = getBuildTarget
+targetStage (Stage1 {}) = getHostTarget
+targetStage (Stage2 {}) = getHostTarget
+targetStage (Stage3 {}) = getTargetTarget
 

hadrian/src/Packages.hs

@@ -4,7 +4,7 @@ module Packages (
     array, base, binary, bytestring, cabal, cabalSyntax, checkPpr,
     checkExact, countDeps,
     compareSizes, compiler, containers, deepseq, deriveConstants, directory,
-    exceptions, filepath, genapply, genprimopcode, ghc, ghcBignum, ghcBoot, ghcBootTh,
+    exceptions, filepath, genapply, genprimopcode, ghc, ghcBignum, ghcBoot, ghcBootTh, ghcPlatform,
     ghcCompact, ghcConfig, ghcHeap, ghci, ghciWrapper, ghcPkg, ghcPrim, haddock, haskeline,
     hsc2hs, hp2ps, hpc, hpcBin, integerGmp, integerSimple, iserv, iservProxy,
     libffi, mtl, parsec, pretty, primitive, process, remoteIserv, rts,
@@ -36,7 +36,7 @@ ghcPackages :: [Package]
 ghcPackages =
     [ array, base, binary, bytestring, cabalSyntax, cabal, checkPpr, checkExact, countDeps
     , compareSizes, compiler, containers, deepseq, deriveConstants, directory
-    , exceptions, filepath, genapply, genprimopcode, ghc, ghcBignum, ghcBoot, ghcBootTh
+    , exceptions, filepath, genapply, genprimopcode, ghc, ghcBignum, ghcBoot, ghcBootTh, ghcPlatform
     , ghcCompact, ghcConfig, ghcHeap, ghci, ghciWrapper, ghcPkg, ghcPrim, haddock, haskeline, hsc2hs
     , hp2ps, hpc, hpcBin, integerGmp, integerSimple, iserv, libffi, mtl
     , parsec, pretty, process, rts, runGhc, stm, semaphoreCompat, templateHaskell
@@ -52,7 +52,7 @@ isGhcPackage = (`elem` ghcPackages)
 -- | Package definitions, see 'Package'.
 array, base, binary, bytestring, cabalSyntax, cabal, checkPpr, checkExact, countDeps,
   compareSizes, compiler, containers, deepseq, deriveConstants, directory,
-  exceptions, filepath, genapply, genprimopcode, ghc, ghcBignum, ghcBoot, ghcBootTh,
+  exceptions, filepath, genapply, genprimopcode, ghc, ghcBignum, ghcBoot, ghcBootTh, ghcPlatform,
   ghcCompact, ghcConfig, ghcHeap, ghci, ghciWrapper, ghcPkg, ghcPrim, haddock, haskeline, hsc2hs,
   hp2ps, hpc, hpcBin, integerGmp, integerSimple, iserv, iservProxy, remoteIserv, libffi, mtl,
   parsec, pretty, primitive, process, rts, runGhc, semaphoreCompat, stm, templateHaskell,
@@ -83,6 +83,7 @@ ghc                 = prg  "ghc-bin"         `setPath` "ghc"
 ghcBignum           = lib  "ghc-bignum"
 ghcBoot             = lib  "ghc-boot"
 ghcBootTh           = lib  "ghc-boot-th"
+ghcPlatform         = lib  "ghc-platform"
 ghcCompact          = lib  "ghc-compact"
 ghcConfig           = prg  "ghc-config"      `setPath` "testsuite/ghc-config"
 ghcHeap             = lib  "ghc-heap"

hadrian/src/Rules/BinaryDist.hs

@@ -258,6 +258,7 @@ bindistRules = do
           need $ map (bindistFilesDir -/-)
                     (["configure", "Makefile"] ++ bindistInstallFiles)
           copyFile ("hadrian" -/- "bindist" -/- "config.mk.in") (bindistFilesDir -/- "config.mk.in")
+          copyFile ("default.target.in") (bindistFilesDir -/- "default.target.in")
           forM_ bin_targets $ \(pkg, _) -> do
             needed_wrappers <- pkgToWrappers pkg
             forM_ needed_wrappers $ \wrapper_name -> do
@@ -420,8 +421,8 @@ commonWrapper = pure $ "exec \"$executablename\" ${1+\"$@\"}\n"
 -- echo 'HSC2HS_EXTRA="$(addprefix --cflag=,$(CONF_CC_OPTS_STAGE1)) $(addprefix --lflag=,$(CONF_GCC_LINKER_OPTS_STAGE1))"' >> "$(WRAPPER)"
 hsc2hsWrapper :: Action String
 hsc2hsWrapper = do
-  ccArgs <- map ("--cflag=" <>) . prgFlags . ccProgram . tgtCCompiler <$> targetConfigStage Stage1
-  linkFlags <- map ("--lflag=" <>) . prgFlags . ccLinkProgram . tgtCCompilerLink <$> targetConfigStage Stage1
+  ccArgs <- map ("--cflag=" <>) . prgFlags . ccProgram . tgtCCompiler <$> targetStage Stage1
+  linkFlags <- map ("--lflag=" <>) . prgFlags . ccLinkProgram . tgtCCompilerLink <$> targetStage Stage1
   wrapper <- drop 4 . lines <$> liftIO (readFile "utils/hsc2hs/hsc2hs.wrapper")
   return $ unlines
     ( "HSC2HS_EXTRA=\"" <> unwords (ccArgs ++ linkFlags) <> "\""