packageOneOf :: [Package] -> Predicate

 packageOneOf ps = (`elem` ps) <$> getPackage

 -- | This type class allows the user to construct both precise builder

 -- predicates, such as @builder (Ghc CompileHs Stage1)@, as well as predicates

 -- covering a set of similar builders. For example, @builder (Ghc CompileHs)@

       forM_ wayPats $ \wayPat -> ( root -/- ("**/build/**/*." ++ wayPat ++ "dyn_o") :& root -/- ("**/build/**/*." ++ wayPat ++ "dyn_hi") :& Nil )

         &%> \ ( dyn_o :& _dyn_hi :& _ ) -> do

             <- parsePath (parseBuildObject root) "<object file path parser>" dyn_o

           p <- targetSupportsSharedLibs stage

           if p

             then do

                let ctx = objectContext b

                    way = removeWayUnit Dynamic $ C.way ctx

                -- We `need` ".o/.hi" because GHC is called with `-dynamic-too`

     ) where

 import Development.Shake.FilePath

 import Base

 import qualified Context

 import Expression

 import Oracles.Flag hiding (arSupportsAtFile, arSupportsDashL)

 import Oracles.ModuleFiles

 import Oracles.Setting

 import Hadrian.Haskell.Cabal.Type (PackageData(version))

 import Hadrian.Haskell.Cabal

 import Hadrian.Oracles.Cabal (readPackageData)

 import GHC.Toolchain as Toolchain hiding (HsCpp(HsCpp))

 import GHC.Platform.ArchOS

 import UserSettings (finalStage)

 -- | Track this file to rebuild generated files whenever it changes.

     hp2ps_path <- expr $ getTestExePath testGhc hp2ps

     hpc_path <- expr $ getTestExePath testGhc hpc

     -- the testsuite driver will itself tell us if we need to generate the docs target

     -- So we always pass the haddock path if the hadrian configuration allows us to build

     -- docs

 splitSectionsArgs :: Args

 splitSectionsArgs = do

   pkg <- getPackage

   notSt0 <- notStage0

   flav <- expr flavour

   if ( ghcSplitSections flav

          -- Flavour enables split-sections

     && not osx

          -- OS X doesn't support split sections

          -- Disable for stage 0 because we aren't going to ship

          -- the resulting binaries and consequently there is no

     && (pkg /= ghc)

          -- Disable section splitting for the GHC library.

          -- It takes too long and there is little benefit.

   , hsc2hs

   , compareSizes

   , deriveConstants

   , genprimopcode

   , unlit

   ]

 -- | Packages built in 'Stage0' by default. You can change this in "UserSettings".

       mconcat

       [ pure [vanilla]

       , notStage0 ? pure [profiling]

       ]

 -- | Default build ways for the RTS.

         Set.fromList

             <$> mconcat

                 [ pure [vanilla]

                 ]

     }

 module Settings.Flavours.Validate (validateFlavour, slowValidateFlavour,

                                     quickValidateFlavour) where

 import Expression

 import Flavour

 import {-# SOURCE #-} Settings.Default

 module Settings.Packages (packageArgs) where

 import Expression

 import Flavour

 import Oracles.Setting

 import Packages

 import Settings

 import Settings.Builders.Common (wayCcArgs)

 import qualified GHC.Toolchain.Library as Lib

 import GHC.Toolchain.Target

 import GHC.Platform.ArchOS

 -- | Package-specific command-line arguments.

 packageArgs :: Args

                   predStage stage

                  else

                   stage

     -- Arguments passed to GHC when compiling C and .cmm sources.

     let ghcArgs = mconcat

             --

             -- In particular, we **do not** pass -mavx when compiling

             -- AutoApply_V16.cmm, as that would lock out targets with SSE2 but not AVX.

           ]

     let cArgs = mconcat

           , inputs ["**/Evac.c", "**/Evac_thr.c"] ? arg "-funroll-loops"

             -- See Note [AutoApply.cmm for vectors] in genapply/Main.hs

           -- emits warnings about call-clobbered registers on x86_64

           , inputs [ "**/StgCRun.c"

 import Base

 import Context

 import Oracles.Flavour

 import Packages

 import GHC.Platform.ArchOS

           notStage0 (Stage0 {}) = False

           notStage0 _ = True

 ghcWithInterpreter :: Stage -> Action Bool

 ghcWithInterpreter stage = do

     goodOs <- anyTargetOs stage [ OSMinGW32, OSLinux, OSSolaris2

                           , OSFreeBSD, OSDragonFly, OSNetBSD, OSOpenBSD

                           , OSDarwin, OSKFreeBSD

     -- fall back on dynamic linking:

     dynamicGhcProgs <- askDynGhcPrograms stage