, fullyStaticBrokenTests (disableValidate (allowFailureGroup (standardBuildsWithConfig Amd64 (Linux Alpine312) staticNativeInt)))

     -- Dynamically linked build, suitable for building your own static executables on alpine

   , disableValidate (standardBuildsWithConfig Amd64 (Linux Alpine323) (splitSectionsBroken vanilla))

   ]

   where

     -- ghcilink002 broken due to #17869

       ".gitlab/ci.sh clean",

       "cat ci_timings.txt"

     ],

     "artifacts": {

       "expire_in": "2 weeks",

       "paths": [

       ".gitlab/ci.sh clean",

       "cat ci_timings.txt"

     ],

     "artifacts": {

       "expire_in": "8 weeks",

       "paths": [

       ".gitlab/ci.sh clean",

       "cat ci_timings.txt"

     ],

     "artifacts": {

       "expire_in": "1 year",

       "paths": [

                       { interpCreateProcess = createIservProcessHook (hsc_hooks hsc_env)

                       }

   modifySession $ \h -> hscSetFlags dflags

                         h{ hsc_IC = (hsc_IC h){ ic_dflags = dflags }

 we use the 32bit variant to compute the 8/16bit primops.

 To do so we extend/truncate the argument/result around the

 call.

 -}

 genCall (PrimTarget op@(MO_Pdep w)) [dst] args = do

     cfg <- getConfig

           W8   -> fsLit "llvm.x86.bmi.pdep.32"

           W16  -> fsLit "llvm.x86.bmi.pdep.32"

           W32  -> fsLit "llvm.x86.bmi.pdep.32"

       | otherwise -> case w of

           W8   -> fsLit "hs_pdep8"

           W16  -> fsLit "hs_pdep16"

           W32  -> fsLit "hs_pdep32"

           W64  -> fsLit "hs_pdep64"

     MO_Pext w

       | isBmi2Enabled -> case w of

           -- See Note [LLVM PDep/PExt intrinsics]

           W8   -> fsLit "llvm.x86.bmi.pext.32"

           W16  -> fsLit "llvm.x86.bmi.pext.32"

           W32  -> fsLit "llvm.x86.bmi.pext.32"

       | otherwise -> case w of

           W8   -> fsLit "hs_pext8"

           W16  -> fsLit "hs_pext16"

           W32  -> fsLit "hs_pext32"

           W64  -> fsLit "hs_pext64"

     MO_AddIntC w    -> case w of

       W8   -> fsLit "llvm.sadd.with.overflow.i8"

       addEval :: Var -> CoreExpr -> CoreExpr

       addEval arg_id rhs

         -- Argument representing strict field and it's worth passing via cbv

         = Case (Var arg_id)

                (localiseId arg_id)  -- See (SCF1) in Note [SpecConstr and strict fields]

                res_ty

 import GHC.Types.RepType (typePrimRep)

 import GHC.Utils.Panic

 import GHC.Types.Basic (isMarkedCbv, CbvMark (..))

 {-

 ************************************************************************

         isSimplePrimRep _   = False

     mkMark arg

       -- We can only safely use cbv for strict arguments

       | (isStrUsedDmd (idDemandInfo arg))

       , not (isDeadEndId fun_id) = MarkedCbv

         isJoinBind,

         -- * Tag inference

         -- * unsafeEqualityProof

         isUnsafeEqualityCase,

             };

     end Rec }

 simplifier. See Note [Which Ids should be strictified] for details on this.

 -}

 mkStrictFieldSeqs :: [(Id,StrictnessMark)] -> CoreExpr -> (CoreExpr)

 mkStrictFieldSeqs args rhs =

   foldr addEval rhs args

       addEval (arg_id,arg_cbv) (rhs)

         -- Argument representing strict field.

         | isMarkedStrict arg_cbv

         -- Make sure to remove unfoldings here to avoid the simplifier dropping those for OtherCon[] unfoldings.

         = Case (Var $! zapIdUnfolding arg_id) arg_id case_ty ([Alt DEFAULT [] rhs])

         -- Normal argument

 strictify a functions argument:

 1) The argument doesn't exist at runtime.

 2) The argument is a unlifted type.

 3) The argument is absent.

 5) Functions

 -}

 -- When we strictify we want to skip strict args otherwise the logic is the same

 -- Basically returns true if it would be beneficial for runtime to pass this argument

 -- as CBV independent of weither or not it's correct. E.g. it might return true for lazy args

 -- we are not allowed to force.

   -- Must be a runtime var.

   -- See Note [Which Ids should be strictified] point 1)

   | isId v

   , not $ isFunTy ty

   -- If the var is strict already a seq is redundant.

   -- See Note [Which Ids should be strictified] point 4)

   , not (isAbsDmd dmd)

   = True

   | otherwise

         -- * Compiler configuration suitable for display to the user

         compilerInfo,

         wordAlignment,

         setUnsafeGlobalDynFlags,

     queryCmdMaybe p f = expandDirectories (query (maybe "" (prgPath . p) . f))

     queryFlagsMaybe p f = query (maybe "" (unwords . map escapeArg . prgFlags . p) . f)

 -- Note [Special unit-ids]

 -- ~~~~~~~~~~~~~~~~~~~~~~~

 -- Certain units are special to the compiler:

 import GHC.Prelude

 import GHC.Platform

 import GHC.Data.FastString

 import GHC.Utils.Logger

 import GHC.Utils.TmpFs

 import GHC.Unit.Types

 import GHC.Utils.Panic.Plain

 import GHC.Linker.Executable

 import GHC.Linker.Config

 -- | Generate iserv program for the target

   -- get the unit-id of the ghci package. We need this to load the

   -- interpreter code.

   let unit_state = ue_homeUnitState unit_env

           -- must retain CAFs for running interpreted code.

         , leKeepCafs = True

           -- enable all rts options

         , leRtsOptsEnabled = RtsOptsAll

 import GHC.Prelude

 import GHC.Platform

 import GHC.Platform.Ways

 import GHC.Settings

 -- | Initialize code interpreter

 initInterpreter

   -> Logger

   -> Platform

   -> FinderCache

   -> UnitEnv

   -> InterpOpts

   -> IO (Maybe Interp)

   lookup_cache  <- liftIO $ mkInterpSymbolCache

           dynamic  = interpWays opts `hasWay` WayDyn

         prog <- case interpProg opts of

           -- build iserv program if none specified

           _ -> pure (interpProg opts ++ flavour)

             where

               flavour

 Implementation

 --------------

   It attaches its result to /binders/, not occurrence sites.

     (a) a binder x is used to

           * construct a strict field (`SP x y`), or

           * passed as a CBV argument (`$wf x`),

     case x of x' { __ DEFAULT -> SP x' y }.

     case x of x' { __ DEFAULT -> $wf x' }.

   (Recall that the case binder x' is always EPT.)

   This pass also propagates the EPTness from binders to occurrences.

   It is sound to insert evals on strict fields (Note [Strict fields in Core]),

   and on CBV arguments as well (Note [CBV Function Ids]).

   to work across module boundaries.

   NB: The EPT Invariant *must* be upheld, regardless of the optimisation level;

   hence EPTness is practically part of the internal ABI of a strict data

   constructor or CBV function. Note [CBV Function Ids] contains the details.

 Evaluation

 ----------

 getCallMethod cfg name id (LFUnknown might_be_a_function) n_args _cg_locs _self_loop_info

   | n_args == 0

   , Just sig <- idTagSig_maybe id

   -- See Note [Evaluating functions with profiling] in rts/Apply.cmm

   , not (profileIsProfiling (stgToCmmProfile cfg) && might_be_a_function)

   | might_be_a_function = SlowCall

           | otherwise                -> emitReturn [fun]

         -- A value infered to be in WHNF, so we can just return it.

         InferedReturnIt

           | isZeroBitTy (idType fun_id) -> trace >> emitReturn []

           | otherwise                   -> trace >> assertTag >>

     , "fully_static"     =: fullyStatic

     , "host_fully_static" =: hostFullyStatic

     , "collect_timings"  =: collectTimings

     , "debug_ghc"        =: debugGhc Stage2

     , "debug_stage1_ghc" =: debugGhc Stage1

     , "lint"             =: enableLinting

   ? arg "-fprof-late"

 -- | Enable assertions for the stage2 compiler

   where

 -- | Build the stage3 compiler using the non-moving GC.

 enableBootNonmovingGc :: Flavour -> Flavour

 -- TODO: Can we extract this information from Cabal files?

 -- | Some program packages should not be linked with Haskell main function.

 nonHsMainPackage :: Package -> Bool

 {-

                 interpretInContext ctx $

                 mconcat

                     [ getStagedCCFlags

                     -- gmp symbols are only used by bignum logic in

                     -- ghc-internal and shouldn't be exported by the

                     -- ghc-internal shared library.

     libzstdLibraryDir <- getSetting LibZstdLibDir

     stageVersion <- readVersion <$> (expr $ ghcVersionStage stage)

     mconcat

         --------------------------------- base ---------------------------------

         [ package base ? mconcat

         --

         -- The Solaris linker does not support --export-dynamic option. It also

         -- does not need it since it exports all dynamic symbols by default

           ? notM (expr $ anyTargetOs [OSFreeBSD, OSSolaris2])? mconcat

           [ builder (Ghc LinkHs) ? arg "-optl-Wl,--export-dynamic" ]

         -------------------------------- haddock -------------------------------

         , package haddockApi ?

           builder (Cabal Flags) ? arg "in-ghc-tree"

    if test "$HaveFrameworkGMP" = "YES" || test "$HaveLibGmp" = "YES"

    then

        AC_MSG_RESULT([no])

        AC_CHECK_HEADER([gmp.h], , [AC_MSG_ERROR([Cannot find gmp.h])])

    else

        AC_MSG_RESULT([yes])

        HaveSecurePowm=1

    fi

    GMP_INSTALL_INCLUDES="HsIntegerGmp.h ghc-gmp.h"

 AC_SUBST(HaveLibGmp)

 AC_SUBST(HaveFrameworkGMP)

 AC_SUBST(HaveSecurePowm)

 # Compute offsets/sizes used by jsbits/base.js

 if test "$host" = "javascript-ghcjs"

 #pragma once

 /* Whether GMP supports mpz_powm_sec */

 #define HAVE_SECURE_POWM @HaveSecurePowm@

  Unf=OtherCon []]

 T18013.$wmapMaybeRule

   = \ (@a) (@b) (@s) (ww :: s) (ww1 :: s -> a -> IO (Result s b)) ->

       case ww1 of wild { __DEFAULT ->

       T18013a.Rule

         @IO

         @(Maybe a)

         @(Maybe b)

         @s

         ((\ (s2 :: s)

             (a1 :: Maybe a)

             (s1 :: GHC.Internal.Prim.State# GHC.Internal.Prim.RealWorld) ->

               Nothing ->

                 (# s1,

                    T18013a.Result

               Just x ->

                 case ((wild s2 x)

                       `cast` <Co:4> :: IO (Result s b)

 test('T26116', normal, compile, ['-O -ddump-rules'])

 test('T26117', [grep_errmsg(r'==')], compile, ['-O -ddump-simpl -dsuppress-uniques'])

 test('T26349',  normal, compile, ['-O -ddump-rules'])

 build-type: Simple

 cabal-version: >=1.10

 Executable iserv

     Default-Language: Haskell2010

     Main-Is: Main.hs

     Hs-Source-Dirs: src

     include-dirs: .

     Build-Depends: