, ue_namever         = ghcNameVersion dflags1

               , ue_home_unit_graph = home_unit_graph

               , ue_current_unit    = ue_currentUnit old_unit_env

               , ue_eps             = ue_eps old_unit_env

               }

         modifySession $ \h -> hscSetFlags dflags1 h{ hsc_unit_env = unit_env }

             , ue_home_unit_graph = home_unit_graph

             , ue_current_unit    = ue_currentUnit unit_env0

             , ue_eps             = ue_eps unit_env0

             }

       modifySession $ \h ->

         -- hscSetFlags takes care of updating the logger as well.

 --

 invalidateModSummaryCache :: GhcMonad m => m ()

 invalidateModSummaryCache =

  where

   inval ms = ms { ms_hs_hash = fingerprint0 }

   where

     dflags         = hsc_dflags hsc_env

     logger         = hsc_logger hsc_env

     extra_vars     = interactiveInScope (hsc_IC hsc_env)

     home_pkg_rules = hugRulesBelow hsc_env (moduleUnitId mod)

                       (GWIB { gwib_mod = moduleName mod, gwib_isBoot = NotBoot })

     ptc            = initPromotionTickContext dflags

     -- mod: get the module out of the current HscEnv so we can retrieve it from the monad.

     -- This is very convienent for the users of the monad (e.g. plugins do not have to

                     (homeUnitId home_unit)

                     (HUG.mkHomeUnitEnv unit_state (Just dbs) dflags (ue_hpt old_unit_env) (Just home_unit))

           , ue_eps       = ue_eps old_unit_env

           }

     setSession $ hscSetFlags dflags $ hsc_env { hsc_unit_env = unit_env }

 module GHC.Driver.Env

    ( Hsc(..)

    , HscEnv (..)

    , hscUpdateFlags

    , hscSetFlags

    , hsc_home_unit

 hsc_HUG :: HscEnv -> HomeUnitGraph

 hsc_HUG = ue_home_unit_graph . hsc_unit_env

 hsc_all_home_unit_ids :: HscEnv -> Set.Set UnitId

 hsc_all_home_unit_ids = HUG.allUnits . hsc_HUG

 hscUpdateHUG :: (HomeUnitGraph -> HomeUnitGraph) -> HscEnv -> HscEnv

 hscUpdateHUG f hsc_env = hsc_env { hsc_unit_env = updateHug f (hsc_unit_env hsc_env) }

 {-

 Note [Target code interpreter]

 -- | Find all rules in modules that are in the transitive closure of the given

 -- module.

 hugRulesBelow :: HscEnv -> UnitId -> ModuleNameWithIsBoot -> IO RuleBase

 -- | Get annotations from all modules "below" this one (in the dependency

 -- sense) within the home units. If the module is @Nothing@, returns /all/

 -- annotations in the home units.

 hugAnnsBelow :: HscEnv -> UnitId -> ModuleNameWithIsBoot -> IO AnnEnv

 -- | Find all COMPLETE pragmas in modules that are in the transitive closure of the

 -- given module.

   hugSomeThingsBelowUs (md_complete_matches . hm_details) False hsc uid mn

 -- | Find instances visible from the given set of imports

 hugInstancesBelow hsc_env uid mnwib = do

  let mn = gwib_mod mnwib

  (insts, famInsts) <-

                                   -- Don't include instances for the current module

                                   in if moduleName (mi_module (hm_iface mod_info)) == mn

                                        then []

                           True -- Include -hi-boot

                           hsc_env

                           uid

 hugSomeThingsBelowUs :: (HomeModInfo -> [a]) -> Bool -> HscEnv -> UnitId -> ModuleNameWithIsBoot -> IO [[a]]

 -- An explicit check to see if we are in one-shot mode to avoid poking the ModuleGraph thunk

 -- These things are currently stored in the EPS for home packages. (See #25795 for

 -- See Note [Downsweep and the ModuleGraph]

 hugSomeThingsBelowUs _ _ hsc_env _ _ | isOneShot (ghcMode (hsc_dflags hsc_env)) = return []

 hugSomeThingsBelowUs extract include_hi_boot hsc_env uid mn

 import GHC.Types.Target

 import GHC.Types.TypeEnv

 import GHC.Unit.Finder.Types

 import GHC.Unit.Env

 import GHC.Utils.Logger

 import GHC.Utils.TmpFs

         hsc_targets :: [Target],

                 -- ^ The targets (or roots) of the current session

         hsc_IC :: InteractiveContext,

                 -- ^ The context for evaluating interactive statements

         , hsc_llvm_config :: !LlvmConfigCache

                 -- ^ LLVM configuration cache.

  }

     return HscEnv { hsc_dflags         = top_dynflags

                   , hsc_logger         = setLogFlags logger (initLogFlags top_dynflags)

                   , hsc_targets        = []

                   , hsc_IC             = emptyInteractiveContext dflags

                   , hsc_NC             = nc_var

                   , hsc_FC             = fc_var

         all_errs <- liftIO $ HUG.unitEnv_foldWithKey one_unit_messages (return emptyMessages) (hsc_HUG hsc_env)

         logDiagnostics (GhcDriverMessage <$> all_errs)

         pure (emptyMessages, mod_graph)

       else do

         -- We don't have a complete module dependency graph,

         -- The graph may be disconnected and is unusable.

         pure (errs, emptyMG)

     -- for any client who might interact with GHC via load'.

     -- See Note [Timing of plugin initialization]

     initializeSessionPlugins

     guessOutputFile

     hsc_env <- getSession

   -- files. See GHC.Tc.Utils.TcGblEnv.tcg_type_env_var.

   -- See also Note [hsc_type_env_var hack]

   type_env_var <- newIORef emptyNameEnv

          -- oneshot mode does not support backpack

          -- and we want to avoid prodding the hsc_mod_graph thunk

          | isOneShot (ghcMode (hsc_dflags hsc_env)) = False

          | otherwise = False

         pruneHomeUnitEnv hme = do

           -- NB: These are empty HPTs because Iface/Load first consults the HPT

           | otherwise

           = do

             hug' <- traverse pruneHomeUnitEnv (ue_home_unit_graph old_unit_env)

             return old_unit_env

               { ue_home_unit_graph = hug'

               }

       in do

         !unit_env <- unit_env_io

         -- mg_has_holes will be checked again, but nothing else about the module graph

         pure $

           hsc_env

                 {  hsc_targets      = panic "cleanTopEnv: hsc_targets"

                 ,  hsc_IC           = panic "cleanTopEnv: hsc_IC"

                 ,  hsc_type_env_vars = case maybe_type_vars of

                                            Just vars -> vars

 -- We don't need to check the current module, this is done in

 -- tcExtendLocalFamInstEnv.

 -- See Note [The type family instance consistency story].

   = do { (eps, hug) <- getEpsAndHug

        ; traceTc "checkFamInstConsistency" (ppr directlyImpMods)

        ; let { -- Fetch the iface of a given module.  Must succeed as

              -- See Note [Order of type family consistency checks]

              }

        ; debug_consistent_set <- mapM (\x -> (\y -> (x, length y)) <$> modConsistent x) directlyImpMods

        ; traceTc "init_consistent_set" (ppr debug_consistent_set)

        ; let init_consistent_set = map fst (reverse (sortOn snd debug_consistent_set))

 import GHC.Core.TyCo.Tidy( tidyTopType )

 import GHC.Core.FamInstEnv

    ( FamInst, pprFamInst, famInstsRepTyCons, orphNamesOfFamInst

 import GHC.Parser.Header       ( mkPrelImports )

   = do  { (rn_imports, imp_user_spec, rdr_env, imports) <- rnImports import_decls

         -- Get the default declarations for the classes imported by this module

         -- and group them by class.

         ; this_mod <- getModule

         ; gbl_env <- getGblEnv

         ; let unitId = homeUnitId $ hsc_home_unit hsc_env

                 -- filtering also ensures that we don't see instances from

                 -- modules batch (@--make@) compiled before this one, but

                 -- which are not below this one.

                     hugInstancesBelow hsc_env unitId mnwib

                 -- We use 'unsafeInterleaveIO' to avoid redundant memory allocations

                 -- See Note [Lazily loading COMPLETE pragmas] from GHC.HsToCore.Monad

               tcg_rn_imports   = rn_imports,

               tcg_default      = foldMap subsume tc_defaults,

               tcg_inst_env     = tcg_inst_env gbl `unionInstEnv` home_insts,

             }) $ do {

         ; traceRn "rn1" (ppr (imp_direct_dep_mods imports))

                              $ imports }

         ; logger <- getLogger

         ; withTiming logger (text "ConsistencyCheck"<+>brackets (ppr this_mod)) (const ())

         ; traceRn "rn1: } checking family instance consistency" empty

         ; gbl_env <- getGblEnv

 withInteractiveModuleNode :: HscEnv -> TcM a -> TcM a

 withInteractiveModuleNode hsc_env thing_inside = do

   mg <- liftIO $ downsweepInteractiveImports hsc_env (hsc_IC hsc_env)

 runTcInteractive :: HscEnv -> TcRn a -> IO (Messages TcRnMessage, Maybe a)

 -- ┌▽────────────┐    │                     │

 -- │HomeUnitGraph│    │                     │

 -- └┬────────────┘    │                     │

 -- @

 --

 module GHC.Unit.Env

     ( UnitEnv (..)

     , initUnitEnv

 import GHC.Unit.Home.PackageTable

 import GHC.Unit.Home.Graph (HomeUnitGraph, HomeUnitEnv)

 import qualified GHC.Unit.Home.Graph as HUG

 import GHC.Platform

 import GHC.Settings

     , ue_current_unit    :: UnitId

     , ue_home_unit_graph :: !HomeUnitGraph

         -- See Note [Multiple Home Units]

   return $ UnitEnv

     { ue_eps             = eps

     , ue_home_unit_graph = hug

     , ue_current_unit    = cur_unit

     , ue_platform        = platform

     , ue_namever         = namever

   -- * Very important queries

   , allInstances

   , allAnns

   , allCompleteSigs

   go hue = liftA2 (\(a,b) (a',b') -> (a `unionInstEnv` a', b ++ b'))

                   (hptAllInstances (homeUnitEnv_hpt hue))

 allAnns :: HomeUnitGraph -> IO AnnEnv

 allAnns hug = foldr go (pure emptyAnnEnv) hug where

   go hue = liftA2 plusAnnEnv (hptAllAnnotations (homeUnitEnv_hpt hue))

     -- * Queries about home modules

   , hptCompleteSigs

   , hptAllInstances

   , hptAllAnnotations

     -- ** More Traversal-based queries

   let (insts, famInsts) = unzip hits

   return (foldl' unionInstEnv emptyInstEnv insts, concat famInsts)

 -- | All annotations from the HPT

 hptAllAnnotations :: HomePackageTable -> IO AnnEnv

 hptAllAnnotations = fmap mkAnnEnv . concatHpt (md_anns . hm_details)

 dnl We know that `clang` supports `--target` and it is necessary to pass it

 dnl lest we see #25793.

     LlvmAsFlags="--target=$LlvmTarget"

 fi

 AC_SUBST([LlvmAsFlags])

   let pruneHomeUnitEnv hme = liftIO $ do

         emptyHpt <- emptyHomePackageTable

         pure  hme{ homeUnitEnv_hpt = emptyHpt }

   modifySessionM $ \hsc_env -> do

     hug' <- traverse pruneHomeUnitEnv $ hsc_HUG hsc_env

     pure $ discardMG $ discardIC $ hscUpdateHUG (const hug') hsc_env

 , tgtRanlib = Nothing

 , tgtNm = Nm {nmProgram = Program {prgPath = "", prgFlags = []}}

 , tgtMergeObjs = Just (MergeObjs {mergeObjsProgram = Program {prgPath = "@LD_STAGE0@", prgFlags = ["-r"]}, mergeObjsSupportsResponseFiles = False})

 , tgtWindres = Nothing

 }

 , tgtRanlib = Just (Ranlib {ranlibProgram = Program {prgPath = "@RanlibCmd@", prgFlags = []}})

 , tgtNm = Nm {nmProgram = Program {prgPath = "@NmCmd@", prgFlags = []}}

 , tgtMergeObjs = @MergeObjsCmdMaybe@

 , tgtWindres = @WindresCmdMaybeProg@

 }

 # generated by configure, to generated being by the build system. Many of these

 # might become redundant.

 # See Note [tooldir: How GHC finds mingw on Windows]

 settings-use-distro-mingw = @SettingsUseDistroMINGW@

 target-has-libm = @TargetHasLibm@

 import Context

 import Oracles.Flag

 import Oracles.Setting (setting, Setting(..))

 import Packages

 import GHC.IO.Encoding (getFileSystemEncoding)

         Ghc _ st -> do

             root <- buildRoot

             unlitPath  <- builderPath Unlit

             libffi_adjustors <- useLibffiForAdjustors

             use_system_ffi <- flag UseSystemFfi

     configFile,

     -- * Settings

     Setting (..), setting, getSetting,

     -- * Helpers

     ghcCanonVersion, cmdLineLengthLimit, targetSupportsRPaths, topDirectory,

              | BourneShell

              | EmsdkVersion

 -- | Look up the value of a 'Setting' in @cfg/system.config@, tracking the

 -- result.

 setting :: Setting -> Action String

     BourneShell        -> "bourne-shell"

     EmsdkVersion       -> "emsdk-version"

 -- | An expression that looks up the value of a 'Setting' in @cfg/system.config@,

 -- tracking the result.

 getSetting :: Setting -> Expr c b String

     , interpolateSetting "LlvmMinVersion" LlvmMinVersion

     , interpolateVar "LlvmTarget" $ getTarget tgtLlvmTarget

     , interpolateSetting "ProjectVersion" ProjectVersion

     , interpolateVar "TablesNextToCode" $ yesNo <$> getTarget tgtTablesNextToCode

     , interpolateVar "TargetHasLibm" $ lookupSystemConfig "target-has-libm"

     , interpolateVar "TargetPlatform" $ getTarget targetPlatformTriple

         , ("ar flags",            queryTarget arFlags)

         , ("ar supports at file", queryTarget arSupportsAtFile')

         , ("ar supports -L",      queryTarget arSupportsDashL')

         , ("windres command", queryTarget (maybe "/bin/false" prgPath . tgtWindres)) -- TODO: /bin/false is not available on many distributions by default, but we keep it as it were before the ghc-toolchain patch. Fix-me.

         , ("unlit command", ("$topdir/../bin/" <>) <$> expr (programName (ctx { Context.package = unlit })))

         , ("cross compiling", expr $ yesNo <$> flag CrossCompiling)

         , ("target has libm", expr $  lookupSystemConfig "target-has-libm")

         , ("Unregisterised", queryTarget (yesNo . tgtUnregisterised))

         , ("LLVM target", queryTarget tgtLlvmTarget)

         , ("target RTS linker only supports shared libraries", expr $ yesNo <$> targetRTSLinkerOnlySupportsSharedLibs)

         , ("Use interpreter", expr $ yesNo <$> ghcWithInterpreter (predStage stage))

     linkSupportsFilelist        = yesNo . ccLinkSupportsFilelist . tgtCCompilerLink

     linkSupportsCompactUnwind   = yesNo . ccLinkSupportsCompactUnwind . tgtCCompilerLink

     linkIsGnu                   = yesNo . ccLinkIsGnu . tgtCCompilerLink

     arPath  = prgPath . arMkArchive . tgtAr

     arFlags = escapeArgs . prgFlags . arMkArchive . tgtAr

     arSupportsAtFile' = yesNo . arSupportsAtFile . tgtAr

     arSupportsDashL' = yesNo . arSupportsDashL . tgtAr

     ranlibPath  = maybe "" (prgPath . ranlibProgram) . tgtRanlib

     mergeObjsSupportsResponseFiles' = maybe "NO" (yesNo . mergeObjsSupportsResponseFiles) . tgtMergeObjs

     platform    <- queryTargetTarget targetPlatformTriple

     wordsize    <- show @Int . (*8) <$> queryTargetTarget (wordSize2Bytes . tgtWordSize)

     top         <- topDirectory

     fi

     # Mac-only tools

     SettingsOtoolCommand="$OtoolCmd"

     SettingsInstallNameToolCommand="$InstallNameToolCmd"

     SettingsCCompilerSupportsNoPie="$CONF_GCC_SUPPORTS_NO_PIE"

     echo "--merge-objs=$MergeObjsCmd" >> acargs

     echo "--readelf=$READELF" >> acargs

     echo "--windres=$WindresCmd" >> acargs

     if test -n "$USER_LD"; then

       echo "--ld=$USER_LD" >> acargs

 # This toolchain will additionally be used to validate the one generated by

 # ghc-toolchain. See Note [ghc-toolchain consistency checking].

 # PREP_MAYBE_SIMPLE_PROGRAM

 # =========================

 #

     AC_SUBST([$1MaybeProg])

 ])

 # PREP_MAYBE_STRING

 # =========================

 #

     AC_SUBST([Not$1Bool])

 ])

 # Eventually: PREP_BUILD_TARGET_FILE, PREP_HOST_TARGET_FILE, PREP_TARGET_TARGET_FILE

 # Prepares required substitutions to generate the target file

 AC_DEFUN([PREP_TARGET_FILE],[

     PREP_LIST([JavaScriptCPPArgs])

     PREP_LIST([CmmCPPArgs])

     PREP_LIST([CmmCPPArgs_STAGE0])

     PREP_MAYBE_SIMPLE_PROGRAM([WindresCmd])

     PREP_MAYBE_STRING([TargetVendor_CPP])

     PREP_MAYBE_STRING([HostVendor_CPP])

     PREP_LIST([CONF_CPP_OPTS_STAGE2])

 #define DEBUG_LOG(...) IF_DEBUG(linker, debugBelch("loadArchive: " __VA_ARGS__))

 #if defined(darwin_HOST_OS) || defined(ios_HOST_OS)

 /* Read 4 bytes and convert to host byte order */

 static uint32_t read4Bytes(const char buf[static 4])

     return ntohl(*(uint32_t*)buf);

 }

 {

     uint32_t nfat_arch, nfat_offset, cputype, cpusubtype;

 #if defined(i386_HOST_ARCH)

 #error Unknown Darwin architecture

 #endif

     DEBUG_LOG("found a fat archive containing %d architectures\n", nfat_arch);

     nfat_offset = 0;

     for (uint32_t i = 0; i < nfat_arch; i++) {

         /* search for the right arch */

         }

         /* Read the header */

         n = fread(tmp, 1, 8, f);

         if (n != 8) {

             errorBelch("Failed reading header from `%" PATH_FMT "'", path);

 }

 #endif