("target word size", query $ show . wordSize2Bytes . tgtWordSize),

        ("target word big endian", queryBool $ (\case BigEndian -> True; LittleEndian -> False) . tgtEndianness),

        ("target has GNU nonexec stack", queryBool tgtSupportsGnuNonexecStack),

        ("target has .ident directive", queryBool tgtSupportsIdentDirective),

        ("target has subsections via symbols", queryBool tgtSupportsSubsectionsViaSymbols),

        ("Unregisterised", queryBool tgtUnregisterised),

       getTool :: (Target -> Program) -> (String, [String])

       getTool key = (getToolPath key, getToolFlags key)

   let

     (cc_prog, cc_args0)  = getTool (ccProgram . tgtCCompiler)

     (cxx_prog, cxx_args) = getTool (cxxProgram . tgtCxxCompiler)

     (js_cpp_prog, js_cpp_args) = getTool (maybe (Program "" []) jsCppProgram . tgtJsCPreprocessor)

     (cmmCpp_prog, cmmCpp_args) = getTool (cmmCppProgram . tgtCmmCPreprocessor)

     unreg_cc_args = if platformUnregisterised platform

                     then ["-DNO_REGS", "-DUSE_MINIINTERPRETER"]

     , sRawTarget      = target

     }

     { platformArchOS    = tgtArchOs

     , platformWordSize  = case tgtWordSize of WS4 -> PW4

                                               WS8 -> PW8

     , platformIsCrossCompiling = not tgtLocallyExecutable

     , platformLeadingUnderscore = tgtSymbolsHaveLeadingUnderscore

     , platformTablesNextToCode  = tgtTablesNextToCode

     , platform_constants = Nothing -- will be filled later when loading (or building) the RTS unit

     }

 # N.B. this is duplicated from includes/ghc.mk.

 lib/settings : config.mk

 	@rm -f $@

 	@echo ',("target RTS linker only supports shared libraries", "$(TargetRTSLinkerOnlySupportsSharedLibs)")' >> $@

 	@echo ',("Use interpreter", "$(GhcWithInterpreter)")' >> $@

 	@echo ',("Support SMP", "$(GhcWithSMP)")' >> $@

 , tgtUnregisterised = False

 , tgtTablesNextToCode = True

 , tgtUseLibffiForAdjustors = True

 , tgtCCompiler = Cc {ccProgram = Program {prgPath = "@CC_STAGE0@", prgFlags = @CONF_CC_OPTS_STAGE0List@}}

 , tgtCxxCompiler = Cxx {cxxProgram = Program {prgPath = "@CC_STAGE0@", prgFlags = @CONF_CXX_OPTS_STAGE0List@}}

 , tgtCPreprocessor = Cpp {cppProgram = Program {prgPath = "@CPPCmd_STAGE0@", prgFlags = @CONF_CPP_OPTS_STAGE0List@}}

 , tgtUnregisterised = @UnregisterisedBool@

 , tgtTablesNextToCode = @TablesNextToCodeBool@

 , tgtUseLibffiForAdjustors = @UseLibffiForAdjustorsBool@

 , tgtCCompiler = Cc {ccProgram = Program {prgPath = "@CC@", prgFlags = @CONF_CC_OPTS_STAGE2List@}}

 , tgtCxxCompiler = Cxx {cxxProgram = Program {prgPath = "@CXX@", prgFlags = @CONF_CXX_OPTS_STAGE2List@}}

 , tgtCPreprocessor = Cpp {cppProgram = Program {prgPath = "@CPPCmd@", prgFlags = @CONF_CPP_OPTS_STAGE2List@}}

 # See Note [tooldir: How GHC finds mingw on Windows]

 settings-use-distro-mingw = @EnableDistroToolchain@

 # Include and library directories:

 #=================================

     , interpolateSetting "ProjectVersion" ProjectVersion

     , interpolateVar "EnableDistroToolchain" $ lookupSystemConfig "settings-use-distro-mingw"

     , interpolateVar "TablesNextToCode" $ yesNo <$> getTarget tgtTablesNextToCode

     , interpolateVar "TargetPlatform" $ getTarget targetPlatformTriple

     , interpolateVar "TargetWordBigEndian" $ getTarget isBigEndian

     , interpolateVar "TargetWordSize" $ getTarget wordSize

     settings <- traverse sequence $

         [ ("unlit command", ("$topdir/../bin/" <>) <$> expr (programName (ctx { Context.package = unlit })))

         , ("target RTS linker only supports shared libraries", expr $ yesNo <$> targetRTSLinkerOnlySupportsSharedLibs)

         , ("Use interpreter", expr $ yesNo <$> ghcWithInterpreter (predStage stage))

         , ("Support SMP", expr $ yesNo <$> targetSupportsSMP)

     PREP_BOOLEAN([Unregisterised])

     PREP_BOOLEAN([TablesNextToCode])

     PREP_BOOLEAN([UseLibffiForAdjustors])

     PREP_BOOLEAN([ArIsGNUAr])

     PREP_BOOLEAN([ArNeedsRanLib])

     PREP_NOT_BOOLEAN([CrossCompiling])

     tgtSupportsSubsectionsViaSymbols <- checkSubsectionsViaSymbols archOs cc

     tgtSupportsIdentDirective <- checkIdentDirective cc

     tgtSupportsGnuNonexecStack <- checkGnuNonexecStack archOs cc

     -- code generator configuration

     tgtUnregisterised <- determineUnregisterised archOs (optUnregisterised opts)

                    , tgtUnregisterised

                    , tgtTablesNextToCode

                    , tgtUseLibffiForAdjustors = tgtUseLibffi

                    , tgtSymbolsHaveLeadingUnderscore

                    , tgtSupportsSubsectionsViaSymbols

                    , tgtSupportsIdentDirective

     , checkSubsectionsViaSymbols

     , checkIdentDirective

     , checkGnuNonexecStack

     ) where

 import Data.List (isInfixOf)

         , "#endif"

         ]

 checkLeadingUnderscore :: Cc -> Nm -> M Bool

 checkLeadingUnderscore cc nm = checking ctxt $ withTempDir $ \dir -> do

     let test_o = dir </> "test.o"

                    , asmStmt ".section .text"

                    ]

 asmStmt :: String -> String

 asmStmt s = "__asm__(\"" ++ foldMap escape s ++ "\");"

   where

     , tgtUseLibffiForAdjustors :: Bool

     -- ^ We need to know whether or not to include libffi headers, and generate additional code for it

       -- C toolchain

     , tgtCCompiler :: Cc

     , tgtCxxCompiler :: Cxx

     , ", tgtUnregisterised = " ++ show tgtUnregisterised

     , ", tgtTablesNextToCode = " ++ show tgtTablesNextToCode

     , ", tgtUseLibffiForAdjustors = " ++ show tgtUseLibffiForAdjustors

     , ", tgtCCompiler = " ++ show tgtCCompiler

     , ", tgtCxxCompiler = " ++ show tgtCxxCompiler

     , ", tgtCPreprocessor = " ++ show tgtCPreprocessor