case "${CROSS_STAGE:-2}" in

     2) BINDIST_TARGET="binary-dist";;

     # Stage2 cross-compiler bindists are (almost) a byproduct of Stage3

     *) fail "Unknown CROSS_STAGE, must be 2 or 3";;

   esac

           run_hadrian test:all_deps $BINDIST_TARGET

           mv _build/bindist/ghc*.tar.xz "$BIN_DIST_NAME.tar.xz"

           if [[ "${CROSS_STAGE:-2}" == "3" ]]; then

             mv _build/bindist-stage3/ghc*.tar.xz "$BIN_DIST_NAME_STAGE3.tar.xz"

           fi

           ;;

   # If we have set CROSS_EMULATOR, then can't test using normal testsuite.

   elif [ -n "${CROSS_EMULATOR:-}" ] && [[ "${CROSS_TARGET:-}" != *"wasm"* ]]; then

     local instdir="$TOP/_build/install"

     local test_compiler="$instdir/bin/${cross_prefix}ghc$exe"

     install_bindist _build/bindist/ghc-*/ "$instdir"

     echo 'main = putStrLn "hello world"' > expected

     # ---

     # > main = putStrLn "hello world"

     run diff -w expected actual

   elif [[ -n "${REINSTALL_GHC:-}" ]]; then

     run_hadrian \

       test \

   #

   # The exclude list are the artifacts that we do expect to be

   # uploaded. Keep in sync with `jobArtifacts` in

   if [[ "${CI_DISPOSABLE_ENVIRONMENT:-}" != true ]]; then

     git submodule --quiet foreach --recursive git clean -xdfq

     git clean -xdfq \

   *) fail "uname $(uname) is not supported" ;;

 esac

 if [ -n "${CROSS_TARGET:-}" ]; then

   target_triple="$CROSS_TARGET"

 fi

 echo "Branch name ${CI_MERGE_REQUEST_SOURCE_BRANCH_NAME:-}"

                 , withNuma       :: Bool

                 , withZstd       :: Bool

                 , crossTarget    :: Maybe String

                 , crossEmulator  :: CrossEmulator

                 , configureWrapper :: Maybe String

                 , fullyStatic    :: Bool

 staticNativeInt :: BuildConfig

 staticNativeInt = static { bignumBackend = Native }

             -> CrossEmulator -- ^ emulator for testing

             -> Maybe String -- ^ Configure wrapper

             -> BuildConfig

     vanilla { crossTarget = Just triple

             , crossEmulator = emulator

             , configureWrapper = configure_wrapper

             }

       [ opsysVariables arch opsys

       , "TEST_ENV" =: testEnv arch opsys buildConfig

       , "BIN_DIST_NAME" =: binDistName arch opsys buildConfig

             then "BIN_DIST_NAME_STAGE3" =: binDistNameStage3 arch opsys buildConfig

             else mempty

       , "BUILD_FLAVOUR" =: flavourString jobFlavour

       , "INSTALL_CONFIGURE_ARGS" =: "--enable-strict-ghc-toolchain-check"

       , maybe mempty ("CONFIGURE_WRAPPER" =:) (configureWrapper buildConfig)

       , maybe mempty ("CROSS_TARGET" =:) (crossTarget buildConfig)

       , case crossEmulator buildConfig of

           NoEmulator

             -- we need an emulator but it isn't set. Won't run the testsuite

     trim = dropWhileEnd isSpace . dropWhile isSpace

     stage3Artifacts

       | otherwise = []

     -- Keep in sync with the exclude list in `function clean()` in

     jobArtifacts = Artifacts

       { junitReport = "junit.xml"

       , expireIn = "2 weeks"

                         ,"junit.xml"

                         ,"unexpected-test-output.tar.gz"]

       , artifactsWhen = ArtifactsAlways

       }

 cross_jobs :: [JobGroup Job]

 cross_jobs = [

     -- x86 -> aarch64

     -- x86_64 (build) -> riscv64 (host/target)

     -- x86_64 -> loongarch64

     -- Javascript

   , addValidateRule JSBackend (validateBuilds Amd64 (Linux Debian11Js) javascriptConfig)

         (validateBuilds AArch64 (Linux Debian12Wine) (winAarch64Config {llvmBootstrap = True}))

   ]

   where

                          { bignumBackend = Native }

     makeWinArmJobs = modifyJobs

             llvm_prefix = "/opt/llvm-mingw-linux/bin/aarch64-w64-mingw32-"

             cflags = "-fuse-ld=" ++ llvm_prefix ++ "ld --rtlib=compiler-rt"

                          { bignumBackend = Native }

     make_wasm_jobs cfg =

         $ addValidateRule WasmBackend $ validateBuilds Amd64 (Linux AlpineWasm) cfg

     wasm_build_config =

         { hostFullyStatic = True

         , buildFlavour    = Release -- TODO: This needs to be validate but wasm backend doesn't pass yet

         , textWithSIMDUTF = True

     process sel =

       Map.fromListWith combine

       | (sel -> Just j) <- job_groups

       ]

     vs = process v

     "artifacts": {

       "expire_in": "8 weeks",

       "paths": [

         "ghc-x86_64-linux-deb13-riscv-cross_riscv64-linux-gnu-validate.tar.xz",

         "junit.xml",

       ],

       "reports": {

         "junit": "junit.xml"

     "artifacts": {

       "expire_in": "2 weeks",

       "paths": [

         "ghc-x86_64-linux-deb13-riscv-cross_riscv64-linux-gnu-validate.tar.xz",

         "junit.xml",

       ],

       "reports": {

         "junit": "junit.xml"

 import Stage

 import Oracles.Flag

 import Expression

 data BindistConfig = BindistConfig { library_stage :: Stage -- ^ The stage compiler which builds the libraries

                                    , executable_stage :: Stage -- ^ The stage compiler which builds the executables

                                    }

 -- | A bindist for when the host = target, non cross-compilation setting.

 -- Both the libraries and final executables are built with stage1 compiler.

 normalBindist :: BindistConfig

         let cabal_package_db = cwd -/- root -/- "stage-cabal" -/- "dist-newstyle" -/- "packagedb" -/- "ghc-" ++ version

         forM_ bin_targets $ \(bin_pkg,_bin_path) -> do

             let pgmName pkg

                   | pkg == ghc    = "ghc"

                   | pkg == hpcBin = "hpc"

                   | otherwise     = pkgName pkg

             let cabal_bin_out = work_dir -/- "cabal-bin" -/- (pgmName bin_pkg)

             forM_ needed_wrappers $ \wrapper_name -> do

               let wrapper_prefix = unlines

                     ["#!/usr/bin/env sh"

                     ,"export GHC_PACKAGE_PATH="++show cabal_package_db++":"

                     ]

                   output_file = outputDir -/- wrapper_name

               writeFile' output_file (wrapper_prefix ++ wrapper_content)

               makeExecutable output_file

               pure ()

     , interpolateVar "HostOS_CPP" $ fmap cppify $ interp $ queryHost queryOS

     -- constant stage here.

     , interpolateVar "TargetPlatform" $ getTarget Stage2 targetPlatformTriple

     , interpolateVar "TargetPlatform_CPP" $ cppify <$> getTarget Stage2 targetPlatformTriple