import GHC.Utils.Panic

 import GHC.Utils.Misc

 import Data.List (sortOn, sortBy, nub)

 import Data.List.NonEmpty (nonEmpty)

 import qualified Data.List.NonEmpty as NE

         applyEdges :: [CfgEdge] -> FrontierMap -> FrontierMap -> Set.Set (BlockId, BlockId)

                    -> ([BlockChain], Set.Set (BlockId,BlockId))

         applyEdges [] chainEnds _chainFronts combined =

         applyEdges ((CfgEdge from to _w):edges) chainEnds chainFronts combined

             | Just (c1_e,c1) <- mapLookup from chainEnds

             , Just (c2_f,c2) <- mapLookup to chainFronts

 import qualified GHC.Data.EnumSet as EnumSet

 import qualified GHC.Data.ShortText as ST

 import Data.List ( partition )

 import System.Exit

 import Control.Monad

     let inodes = instantiationNodes (homeUnitId $ hsc_home_unit hsc_env) (hsc_units hsc_env)

     -- TODO: Backpack mode does not properly support ExternalPackage nodes yet

     -- Module nodes do not get given package dependencies (see hsModuleToModSummary).

     let graph_nodes = nodes ++ req_nodes ++ (map (uncurry InstantiationNode) $ inodes) ++ pkg_nodes

         key_nodes = map mkNodeKey graph_nodes

         all_nodes = graph_nodes ++ [LinkNode key_nodes (homeUnitId $ hsc_home_unit hsc_env) | do_link]

     -- This error message is not very good but .bkp mode is just for testing so

     -- better to be direct rather than pretty.

     when

       (pprPanic "Duplicate nodes keys in backpack file" (ppr key_nodes))

     -- 3. Return the kaboodle

 import GHC.Types.SrcLoc

 import GHC.Types.SourceError

 import GHC.Utils.Panic

 import GHC.Utils.Outputable as Outputable

 import GHC.Utils.Monad       ( liftIO, mapMaybeM )

 import System.Exit

 import System.FilePath

 import Control.Monad

 import Data.List ( partition, (\\) )

 import qualified Data.Set as Set

 import GHC.Prelude

   where

     uids = map (second homeUnitId_) flags

     duplicate_ids = Set.fromList (map snd uids \\ map snd deduplicated_uids)

     duplicate_flags = filter (flip Set.member duplicate_ids . snd) uids

 import GHC.Data.Maybe

 import GHC.Data.FastString

 import Data.List (sortBy)

 import Data.Map (Map)

 import qualified Data.Map as Map

 -- modules and direct object files for pkg dependencies

 mkObjectUsage :: Plugins -> FinderCache -> [LinkableUsage] -> PkgsLoaded -> IO [Usage]

 mkObjectUsage plugins fc th_links_needed th_pkgs_needed = do

           ds = concatMap loaded_pkg_hs_objs $ eltsUDFM (plusUDFM th_pkgs_needed plugin_pkgs_needed) -- TODO possibly record loaded_pkg_non_hs_objs as well

           (plugins_links_needed, plugin_pkgs_needed) = loadedPluginDeps plugins

       concat <$> sequence (map linkableToUsage ls ++ map librarySpecToUsage ds)

 import GHC.Settings

 import Control.Monad

 import Data.List (nub)

 import Data.Semigroup ( Semigroup(..) )

 import System.Directory

   filterM doesFileExist [ searchPath </> ("lib" ++ lib ++ ".a")

                         | searchPath <- searchPaths

                         , lib <- libs ]

         libs        = unitHsLibs namever ways pc ++ (map ST.unpack . unitExtDepLibsStaticSys $ pc)

 getLibs :: GhcNameVersion -> Ways -> UnitEnv -> [UnitId] -> IO [(String,String)]

 import qualified GHC.LanguageExtensions as LangExt

 import Control.Monad       ( when, ap, guard, unless )

 import Data.Foldable

 import Data.Function       ( on )

 import Data.Functor.Identity ( Identity (..) )

        ; pats' <- rnLPatsAndThen mk pats

        ; let bndrs = collectPatsBinders CollVarTyVarBinders (NE.toList pats')

        ; liftCps $ setSrcSpan loc $ checkErr (null bndrs) $

        ; return (OrPat noExtField pats') }

 rnPatAndThen mk (SumPat _ pat alt arity)

 import GHC.Settings

 import Data.Version

 import Data.Bifunctor

 import Data.List (isPrefixOf, stripPrefix)

 -- | Find all the include directories in the given units

 collectIncludeDirs :: [UnitInfo] -> [FilePath]

 -- | Find all the C-compiler options in the given units

 collectExtraCcOpts :: [UnitInfo] -> [String]

 -- | Find all the library directories in the given units for the given ways

 collectLibraryDirs :: Ways -> [UnitInfo] -> [FilePath]

 -- | Find all the frameworks in the given units

 collectFrameworks :: [UnitInfo] -> [String]

 -- | Find all the package framework paths in these and the preload packages

 collectFrameworksDirs :: [UnitInfo] -> [String]

 -- | Either the 'unitLibraryDirs' or 'unitLibraryDynDirs' as appropriate for the way.

 libraryDirsForWay :: Ways -> UnitInfo -> [String]

 import System.Directory

 import System.FilePath as FilePath

 import Control.Monad

 import Data.Graph (stronglyConnComp, SCC(..))

 import Data.Char ( toUpper )

 import Data.List ( intersperse, partition, sortBy, sortOn, sort )

       basicLinkedUnits = fmap (RealUnit . Definite)

                          $ filter (flip elemUniqMap pkg_db)

                          $ unitConfigAutoLink cfg

   -- Close the preload packages with their dependencies

   dep_preload <- mayThrowUnitErr

         replaceAt, dropTail, capitalise,

         -- * Sorting

         -- * Comparisons

         isEqual,

 nubSort :: Ord a => [a] -> [a]

 nubSort = Set.toAscList . Set.fromList

 {-

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

 *                                                                      *

 import Data.Array

 import qualified Data.ByteString.Char8 as BS

 import Data.Char

 import Data.Function

 import qualified Data.Foldable as Foldable

 import Data.IORef ( IORef, modifyIORef, newIORef, readIORef, writeIORef )

           -- This is mostly for a clear separation of concerns,

           -- to indicate we only care about unit dependencies from package dbs.

           & filter (not . selectHptFlag (HUG.allUnits $ hsc_HUG hsc_env))

         else

           packageFlags dflags0

         prefix =

           longestCommonPrefix stacks

       in

 reportError :: GhciMonad m => GhciCommandMessage -> m ()

 reportError err = do

         processString ('%':'s':xs) =

             liftM2 (<>) (return modules_list) (processString xs)

             where

         processString ('%':'l':xs) =

             liftM2 (<>) (return $ ppr line) (processString xs)

         processString ('%':'d':xs) =

 import GHC.IO.Encoding (getFileSystemEncoding)

 import qualified Data.ByteString as BS

 import qualified GHC.Foreign as GHC

 import GHC.Toolchain (Target(..))

 import qualified GHC.Toolchain as Toolchain

                 Haddock BuildPackage -> runHaddock path buildArgs buildInputs

                 HsCpp    -> captureStdout

                 _  -> cmd' [path] buildArgs buildOptions

 runHaddock :: FilePath    -- ^ path to @haddock@

       -> [String]

       -> [FilePath]  -- ^ input file paths

       -> Action ()

 -- TODO: Some builders are required only on certain platforms. For example,

 -- 'Objdump' is only required on OpenBSD and AIX. Add support for platform

         sorted  = sort [ C.unPackageName p | C.Dependency p _ _ <- allDeps ]

         deps    = nubOrd sorted \\ [name]

         depPkgs = mapMaybe findPackageByName deps

     return $ PackageData name version

                          (C.fromShortText (C.synopsis pd))

                          (C.fromShortText (C.description pd))

   where

     -- Collect an overapproximation of dependencies by ignoring conditionals

     collectDeps :: Maybe (C.CondTree v [C.Dependency] a) -> [C.Dependency]

 configurePackage context@Context {..} = do

     putProgressInfo $ "| Configure package " ++ quote (pkgName package)

     gpd     <- pkgGenericDescription package

     -- Stage packages are those we have in this stage.

     stagePkgs <- stagePackages stage

     -- We'll need those packages in our package database.

     deps <- sequence [ pkgConfFile (context { package = pkg, iplace = forceBaseAfterGhcInternal pkg })

                      | pkg <- depPkgs, pkg `elem` stagePkgs ]

     -- Figure out what hooks we need.

     let configureFile = replaceFileName (pkgCabalFile package) "configure"

     , synopsis                  :: String

     , description               :: String

     , packageDependencies       :: [Package]

     , genericPackageDescription :: GenericPackageDescription

     } deriving (Eq, Generic, Show)

     -- * Paths

     BuildRoot (..), buildRoot, buildRootRules, isGeneratedSource,

     -- * File system operations

     copyFile, copyFileUntracked, createFileLink, fixFile,

 import Development.Shake hiding (Normal)

 import Development.Shake.Classes

 import Development.Shake.FilePath

 import System.Environment (lookupEnv)

 import System.IO (hClose, openTempFile)

 import qualified Data.ByteString        as BS

 import qualified Control.Exception.Base as IO

 import qualified System.Directory.Extra as IO

 import qualified System.Info.Extra      as IO

 import qualified System.IO              as IO

 -- | Extract a value from a singleton list, or terminate with an error message

 -- if the list does not contain exactly one value.

     KeepResponseFiles keep <- userSetting (KeepResponseFiles False)

     return keep

 -- | Run an action with a response file path.

 --

 -- With @--keep-response-files@, the file is left on disk.

     shakeColor <- shouldUseColor

     let options :: ShakeOptions

         options = shakeOptions

             , shakeFiles    = buildRoot -/- Base.shakeFilesDir

             , shakeProgress = Progress.hadrianProgress cwd

             , shakeRebuild  = rebuild

         prefix -/- "html/**"           <~ return "utils/haddock/haddock-api/resources"

         prefix -/- "latex/**"          <~ return "utils/haddock/haddock-api/resources"

 generateRules :: Rules ()

 generateRules = do

 import Base

 import Context

 import Oracles.Setting

 import Hadrian.BuildPath

 import Hadrian.Expression

           isGmp <- (== "gmp") <$> interpretInContext ctx getBignumBackend

           when isGmp $

             need [buildP -/- "include/ghc-gmp.h"]

         Cabal.configurePackage ctx

     root -/- "**/autogen/cabal_macros.h" %> \out -> do

             target (Context stage compiler vanilla iplace) (GhcPkg Recache stage) [] []

         writeFileLines stamp []

     -- Register a package.

     root -/- relativePackageDbPath (PackageDbLoc stage iplace) -/- "*.conf" %> \conf -> do

         historyDisable

         ln++;

     }

     if (ln == NUM_FREE_LISTS) {

 #if 0  /* useful for debugging fragmentation */

         if ((W_)mblocks_allocated * BLOCKS_PER_MBLOCK * BLOCK_SIZE_W

   }

   // coalesce backwards

   if (p != FIRST_BDESCR(MBLOCK_ROUND_DOWN(p)))

   {

       bdescr *prev;

 } free_list;

 static free_list *free_list_head;

 static W_ mblock_high_watermark;

 /*

  * it is quite important that these are in the same cache line as they

  */

 struct mblock_address_range mblock_address_space = { 0, 0, {} };

 static void *getAllocatedMBlock(free_list **start_iter, W_ startingAt)

 {

     free_list *iter;

     W_ p = startingAt;

     for (iter = *start_iter; iter != NULL; iter = iter->next)

     {

         if (p < iter->address)

             break;

         if (p == iter->address)

             p += iter->size;

     }

     *start_iter = iter;

     if (p >= mblock_high_watermark)

         return NULL;

     return getAllocatedMBlock(casted_state, (W_)mblock + MBLOCK_SIZE);

 }

 static void *getReusableMBlocks(uint32_t n)

 {

     struct free_list *iter;

         if (iter->size < size)

             continue;

         addr = (void*)iter->address;

         iter->address += size;

         iter->size -= size;

         if (iter->size == 0) {

     return NULL;

 }

 static void *getFreshMBlocks(uint32_t n)

 {

     W_ size = MBLOCK_SIZE * (W_)n;

     return addr;

 }

 static void *getCommittedMBlocks(uint32_t n)

 {

     void *p;

     return p;

 }

 static void decommitMBlocks(char *addr, uint32_t n)

 {

     struct free_list *iter, *prev;

     osDecommitMemory(addr, size);

     prev = NULL;

     for (iter = free_list_head; iter != NULL; iter = iter->next)

     {

         prev = iter;

         if (iter->address + iter->size < address)

             continue;

         if (iter->address + iter->size == address) {

             iter->size += size;

             if (address + size == mblock_high_watermark) {

                 mblock_high_watermark -= iter->size;

                 if (iter->prev) {

                 return;

             }

             if (iter->next &&

                 iter->next->address == iter->address + iter->size) {

                 struct free_list *next;

                 stgFree(next);

             }

             return;

         } else if (address + size == iter->address) {

             iter->address = address;

             iter->size += size;

                 ASSERT(iter->prev->address + iter->prev->size < iter->address);

             }

             return;

         } else {

             struct free_list *new_iter;

     if (address + size == mblock_high_watermark) {

         mblock_high_watermark -= size;

     } else {

         struct free_list *new_iter;

         new_iter = stgMallocBytes(sizeof(struct free_list), "freeMBlocks");