, Settings.Builders.Ar

                        , Settings.Builders.Ld

                        , Settings.Builders.Make

                        , Settings.Builders.SplitSections

                        , Settings.Builders.RunTest

                        , Settings.Builders.Win32Tarballs

              | Ld Stage --- ^ linker

              | Make FilePath

              | Makeinfo

              | Nm

              | Objdump

              | Python

     HsCpp           -> fromTargetTC "hs-cpp" (Toolchain.hsCppProgram . tgtHsCPreprocessor)

     JsCpp           -> fromTargetTC "js-cpp" (maybeProg Toolchain.jsCppProgram . tgtJsCPreprocessor)

     Ld _            -> fromTargetTC "ld" (Toolchain.ccLinkProgram . tgtCCompilerLink)

     Make _          -> fromKey "make"

     Makeinfo        -> fromKey "makeinfo"

     Nm              -> fromTargetTC "nm" (Toolchain.nmProgram . tgtNm)

     -- * Paths

     contextDir, buildPath, buildDir, pkgInplaceConfig, pkgSetupConfigFile, pkgSetupConfigDir,

     pkgHaddockFile, pkgRegisteredLibraryFile, pkgRegisteredLibraryFileName,

     pkgConfFile, pkgStampFile, resourcePath, objectPath, contextPath, getContextPath, libPath, distDir,

     distDynDir,

     haddockStatsFilesDir, ensureConfigured, autogenPath, rtsContext, rtsBuildPath, libffiBuildPath

     extension <- libsuf stage way

     pkgFile context "libHS" extension

 -- | Path to the configuration file of a given 'Context'.

 pkgConfFile :: Context -> Action FilePath

 pkgConfFile Context {..} = do

           , depIncludeDirs     = forDeps Installed.includeDirs

           , depCcOpts          = forDeps Installed.ccOptions

           , depLdOpts          = forDeps Installed.ldOptions

           , frameworks         = map C.getSymbolicPath (C.frameworks buildInfo)

           , packageDescription = pd'

           , contextLibdir        = libdir install_dirs

     , depIncludeDirs     :: [String]

     , depCcOpts          :: [String]

     , depLdOpts          :: [String]

     , frameworks         :: [String]

     , packageDescription :: PackageDescription

        pkgHashVanillaLib          :: Bool,

        pkgHashSharedLib           :: Bool,

        pkgHashDynExe              :: Bool,

        pkgHashProfLib             :: Bool,

        pkgHashProfExe             :: Bool,

        pkgHashSplitObjs           :: Bool,

       pkgHashVanillaLib = vanilla `Set.member` libWays

       pkgHashSharedLib = dynamic `Set.member` libWays

       pkgHashDynExe = dyn_ghc

       pkgHashProfLib = profiling `Set.member` libWays

       pkgHashProfExe = pkg == ghc && ghcProfiled flav stag

       pkgHashSplitObjs = False -- Deprecated

       , opt   "vanilla-lib" True  show pkgHashVanillaLib

       , opt   "shared-lib"  False show pkgHashSharedLib

       , opt   "dynamic-exe" False show pkgHashDynExe

       , opt   "prof-lib"    False show pkgHashProfLib

       , opt   "prof-exe"    False show pkgHashProfExe

       , opt   "split-objs"   False show pkgHashSplitObjs

 module Oracles.Flag (

     Flag (..), flag, getFlag,

     platformSupportsSharedLibs,

     targetRTSLinkerOnlySupportsSharedLibs,

     targetSupportsThreadedRts,

     targetSupportsSMP,

 getFlag :: Flag -> Expr c b Bool

 getFlag = expr . flag

 targetRTSLinkerOnlySupportsSharedLibs :: Action Bool

 targetRTSLinkerOnlySupportsSharedLibs = queryTargetTarget Toolchain.tgtRTSLinkerOnlySupportsSharedLibs

     name stage pkg | isLibrary pkg = return (pkgName pkg)

                    | otherwise     = programName (vanillaContext stage pkg)

 -- | Return the list of targets associated with a given 'Stage' and 'Package'.

     let context = vanillaContext stage pkg

     activePackages <- stagePackages stage

     if pkg `notElem` activePackages

             let pkgWays = if pkg == rts then getRtsWays else getLibraryWays

             ways  <- interpretInContext context pkgWays

             libs  <- mapM (\w -> pkgLibraryFile (Context stage pkg w (error "unused"))) (Set.toList ways)

             setupConfig <- pkgSetupConfigFile context

             return $ [setupConfig] ++ libs ++ more

         else do -- The only target of a program package is the executable.

         root -/- "stage*/lib/**/libHS*-*.so"    %> registerDynamicLib root "so"

         root -/- "stage*/lib/**/libHS*-*.dll"   %> registerDynamicLib root "dll"

         root -/- "stage*/lib/**/*.a"            %> registerStaticLib  root

 -- * 'Action's for building libraries

         (quote pkgname ++ " (" ++ show stage ++ ", way " ++ show way ++ ").")

         dynlibpath synopsis

 {-

 Note [Stamp Files]

   srcs <- hsSources ctx

   gens <- interpretInContext ctx generatedDependencies

   need (srcs ++ gens ++ lib_targets)

 -- * Helpers

 -- | Return all the non-Haskell object files for the given library context

 -- (object files built from C, C-- and sometimes other things).

 nonHsObjects :: Context -> Action [FilePath]

 -- | Coarse-grain 'need': make sure all given libraries are fully built.

 needLibrary :: [Context] -> Action ()

 -- * Library paths types and parsers

 -- | > libHS<pkg name>-<pkg version>-<pkg hash>[_<way suffix>]-ghc<ghc version>.<so|dylib>

 data LibDyn = LibDyn String [Integer] String Way DynLibExt deriving (Eq, Show)

 -- | Get the 'Context' corresponding to the build path for a given static library.

 libAContext :: BuildPath LibA -> Context

 libAContext (BuildPath _ stage pkgpath (LibA pkgname _ _ way)) =

   where

     pkg = library pkgname pkgpath

 -- | Get the 'Context' corresponding to the build path for a given dynamic library.

 libDynContext :: BuildPath LibDyn -> Context

 libDynContext (BuildPath _ stage pkgpath (LibDyn pkgname _ _ way _)) =

 data PkgStamp = PkgStamp String [Integer] String Way deriving (Eq, Show)

 parseStampPath :: FilePath -> Parsec.Parsec String () (BuildPath PkgStamp)

 parseStampPath root = parseBuildPath root parseStamp

 parseBuildLibA root = parseBuildPath root parseLibAFilename

     Parsec.<?> "build path for a static library"

 -- | Parse a path to a dynamic library to be built, making sure the path starts

 -- with the given build root.

 parseBuildLibDyn :: FilePath -> String -> Parsec.Parsec String () (BuildPath LibDyn)

     _ <- Parsec.string ".a"

     return (LibA pkgname pkgver pkghash way)

 -- | Parse the filename of a dynamic library to be built into a 'LibDyn' value.

 parseLibDynFilename :: String -> Parsec.Parsec String () LibDyn

 parseLibDynFilename ext = do

 import Base

 import Context

 import Flavour

 import Oracles.Setting

 import Hadrian.BuildPath

 import Hadrian.Expression

 import Hadrian.Haskell.Cabal

 import Packages

 import Rules.Rts

 import Settings

 import Target

 import Utilities

 import qualified Text.Parsec      as Parsec

 import qualified Data.Set         as Set

 import qualified Data.Char        as Char

 -- | Given a library 'Package' this action computes all of its targets. Needing

 -- all the targets should build the library such that it is ready to be

 -- registered into the package database.

     libFile  <- pkgLibraryFile     context

     extra    <- extraTargets context

     return $ [ libFile ]

           ++ extra

 import Builder

 import Context

 import Packages

 import Settings.Builders.Common

 import qualified Settings.Builders.Common as S

 import Control.Exception (assert)

 import qualified Data.Set as Set

 import GHC.Toolchain (ccLinkProgram, tgtCCompilerLink)

 import GHC.Toolchain.Program (prgFlags)

             ]

 -- TODO: Isn't vanilla always built? If yes, some conditions are redundant.

 -- TODO: should `elem` be `wayUnit`?

 -- This approach still doesn't work. Previously libraries were build only in the

 -- Default flavours and not using context.

 libraryArgs = do

     flavourWays <- getLibraryWays

     contextWay  <- getWay

     let ways = Set.insert contextWay flavourWays

         hasVanilla = vanilla `elem` ways

         hasProfiling = any (wayUnit Profiling) ways

          , if hasProfilingShared

             then "--enable-profiling-shared"

             else "--disable-profiling-shared"

          , if hasDynamic

            then  "--enable-shared"

            else "--disable-shared" ]

         , builder (Ghc CompileCWithGhc) ? arg "-fsplit-sections"

         , builder (Ghc CompileCppWithGhc) ? arg "-fsplit-sections"

         , builder (Cc CompileC) ? arg "-ffunction-sections" <> arg "-fdata-sections"

         ]

     ) else mempty

 import Settings.Builders.Ar

 import Settings.Builders.Ld

 import Settings.Builders.Make

 import Settings.Builders.SplitSections

 import Settings.Builders.RunTest

 import Settings.Builders.Xelatex

     , ldBuilderArgs

     , arBuilderArgs

     , makeBuilderArgs

     , runTestBuilderArgs

     , validateBuilderArgs

     , xelatexBuilderArgs

               pure ["-O0"] ]

           , builder (Cabal Setup) ? mconcat

             , compilerStageOption ghcProfiled ? arg "--ghc-pkg-option=--force"

             , cabalExtraDirs libzstdIncludeDir libzstdLibraryDir

             ]