deriving (Eq)

 -- | Should a data in this section be considered constant at runtime

     Text                    -> ReadOnlySection

     ReadOnlyData            -> ReadOnlySection

     RelocatableReadOnlyData -> WriteProtectedSection

 module GHC.Cmm.InitFini

     ( InitOrFini(..)

     , isInitOrFiniArray

     ) where

 import GHC.Prelude

 data InitOrFini = IsInitArray | IsFiniArray

 isInitOrFiniArray :: RawCmmDecl -> Maybe (InitOrFini, [CLabel])

   = Just (initOrFini, map get_label lits)

   where

     get_label :: CmmStatic -> CLabel

     get_label static = pprPanic "isInitOrFiniArray: invalid entry" (ppr static)

 isInitOrFiniArray _ = Nothing

 isInitOrFiniSection _                     = Nothing

 import GHC.Cmm.BlockId

 import GHC.Cmm.CLabel

 import GHC.Types.Unique ( pprUniqueAlways, getUnique )

 import GHC.Platform

 pprNatCmmDecl :: IsDoc doc => NCGConfig -> NatCmmDecl RawCmmStatics Instr -> doc

 pprNatCmmDecl config (CmmData section dats) =

 pprNatCmmDecl config proc@(CmmProc top_info lbl _ (ListGraph blocks)) =

   let platform = ncgPlatform config

 --     .balign 8

 --

 pprSectionAlign :: IsDoc doc => NCGConfig -> Section -> doc

     line (pprSectionHeader config sec)

     $$ pprAlignForSection (ncgPlatform config) seg

 -- | Output the ELF .size directive.

 pprSizeDecl :: IsDoc doc => Platform -> CLabel -> doc

       (l@LOCATION{} : _) -> pprInstr platform l

       _other             -> empty

 -- See Note [emit-time elimination of static indirections] in "GHC.Cmm.CLabel".

   | lbl == mkIndStaticInfoLabel

   , let labelInd (CmmLabelOff l _) = Just l

         labelInd (CmmLabel l) = Just l

         labelInd _ = Nothing

   , Just ind' <- labelInd ind

   , alias `mayRedirectTo` ind'

   = pprGloblDecl platform alias

     $$ line (text ".equiv" <+> pprAsmLabel platform alias <> comma <> pprAsmLabel platform ind')

   = vcat (pprLabel platform lbl : map (pprData platform) dats)

 pprData :: IsDoc doc => Platform -> CmmStatic -> doc

 pprData _platform (CmmString str) = line (pprString str)

 {-# LANGUAGE MagicHash #-}

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

 --

         pprASCII,

         pprString,

         pprFileEmbed,

         pprSectionHeader

 )

 import GHC.Utils.Asm

 import GHC.Cmm.CLabel

 import GHC.Cmm

 import GHC.CmmToAsm.Config

 import GHC.Utils.Outputable as SDoc

                     | otherwise -> text ".rodata"

       RelocatableReadOnlyData | OSMinGW32 <- platformOS platform

                                 -- Concept does not exist on Windows,

                               | otherwise -> text ".data.rel.ro"

       UninitialisedData -> text ".bss"

       InitArray

         | OSMinGW32 <- platformOS platform

                     -> text ".rdata"

         | otherwise -> text ".ipe"

 {-# SPECIALIZE pprGNUSectionHeader :: NCGConfig -> SectionType -> CLabel -> SDoc #-}

 {-# SPECIALIZE pprGNUSectionHeader :: NCGConfig -> SectionType -> CLabel -> HLine #-} -- see Note [SPECIALIZE to HDoc] in GHC.Utils.Outputable

 -- XCOFF doesn't support relocating label-differences, so we place all

 -- RO sections into .text[PR] sections

 pprXcoffSectionHeader :: IsLine doc => SectionType -> doc

 -- | Calculate a data section's kind, see haddock docs of

 -- 'DataSectionKind' for more explanation.

 dataSectionKindFromCmmSection :: Section -> DataSectionKind

   ReadWriteSection -> SectionData

   _ -> SectionROData

 import GHC.Cmm.Dataflow.Label

 import GHC.Cmm.BlockId

 import GHC.Cmm.CLabel

 import GHC.Cmm.DebugBlock (pprUnwindTable)

 import GHC.Types.Basic (Alignment, mkAlignment, alignmentBytes)

         labelInd _ = Nothing

   , Just ind' <- labelInd ind

   , alias `mayRedirectTo` ind'

   = pprGloblDecl (ncgPlatform config) alias

     $$ line (text ".equiv" <+> pprAsmLabel (ncgPlatform config) alias <> comma <> pprAsmLabel (ncgPlatform config) ind')

 pprDatas config (align, (CmmStaticsRaw lbl dats))

  = vcat (pprAlign platform align : pprLabel platform lbl : map (pprData config) dats)

 -- | Print section header and appropriate alignment for that section.

 pprSectionAlign :: IsDoc doc => NCGConfig -> Section -> doc

     line (pprSectionHeader config sec) $$

     pprAlignForSection (ncgPlatform config) seg

 -- | Print appropriate alignment for the given section type.

 pprAlignForSection :: IsDoc doc => Platform -> SectionType -> doc

     pprDataExterns platform lits $$

     pprWordArray platform (isSecConstant section) lbl lits

   where

       ReadOnlySection -> True

       WriteProtectedSection -> True

       _ -> False

                 IsFiniArray -> fsLit "llvm.global_dtors"

     in genGlobalLabelArray var clbls

     label <- strCLabel_llvm lbl

     static <- mapM genData xs

     lmsec <- llvmSection sec

                                                     then Just 2 else Just 1

                             Section Data _    -> Just $ platformWordSizeInBytes platform

                             _                 -> Nothing

                             then Constant else Global

         varDef         = LMGlobalVar label tyAlias link lmsec align const

         globDef        = LMGlobal varDef struct

 A list of all supported language extensions can be obtained by invoking

 ``ghc --supported-extensions`` (see :ghc-flag:`--supported-extensions`).

 .. _options-pragma:

 Overview of all language extensions

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

                        , 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

             ]