import Data.Traversable

 import GHC.Utils.Logger

 import GHC.Linker.Types

 -- | The on-disk representation of a bytecode object

 data OnDiskByteCodeObject = OnDiskByteCodeObject { odbco_module :: Module

         pure $ BinName nm

       1 -> do

         occ <- mkVarOccFS <$> get bh

         fmap BinName $ atomicModifyIORef' env_ref $ \env ->

           case lookupOccEnv env occ of

             Just nm -> (env, nm)

       _ -> panic "Binary BinName: invalid byte"

 -- Note [Serializing Names in bytecode]

     env <- getBkpEnv

     src_hash <- liftIO $ getFileHash (bkp_filename env)

     let loc = srcLocSpan (mkSrcLoc (mkFastString (bkp_filename env)) 1 1)

     let fc = hsc_FC hsc_env

                                 HsSrcFile  -> os "hs")

                              hsc_src

     -- This duplicates a pile of logic in GHC.Driver.Make

     -- Also copied from 'getImports'

     let (src_idecls, ord_idecls) = partition ((== IsBoot) . ideclSource . unLoc) imps

   | ms_hs_hash old_summary == src_hash &&

       not (gopt Opt_ForceRecomp (hsc_dflags hsc_env)) = do

            -- update the object-file timestamp

            -- We have to repopulate the Finder's cache for file targets

            -- because the file might not even be on the regular search path

                hsc_src = ms_hsc_src old_summary

            addModuleToFinder fc mod location hsc_src

            return $ Right

              ( old_summary

 makeNewModSummary :: HscEnv -> MakeNewModSummary -> IO ModSummary

 makeNewModSummary hsc_env MakeNewModSummary{..} = do

   let PreprocessedImports{..} = nms_preimps

   extra_sig_imports <- findExtraSigImports hsc_env nms_hsc_src pi_mod_name

   (implicit_sigs, _inst_deps) <- implicitRequirementsShallow (hscSetActiveUnitId (moduleUnitId nms_mod) hsc_env) pi_theimps

       linkable $ pure $ BCOs $ (ByteCodeObject (mi_module iface) bcos fos)

     linkable parts = do

       time <- maybe getCurrentTime pure if_time

       return $! Linkable time (mi_module iface) parts

       linkable $ NE.singleton (BCOs (ByteCodeObject (mi_module iface) bcos fos))

     linkable parts = do

       time <- maybe getCurrentTime pure if_time

       return $!Linkable time (mi_module iface) parts

   -- Either, get the same time as the .gbc file if it exists, or just the current time.

   -- It's important the time of the linkable matches the time of the .gbc file for recompilation

   -- checking.

   loadByteCodeObjectLinkable bco_time bco_object

 mkByteCodeObject :: HscEnv -> Module -> ModLocation -> CgInteractiveGuts -> IO ByteCodeObject

   -- the object file for one module.)

   -- Note the nasty duplication with the same computation in compileFile above

   location <- mkOneShotModLocation pipe_env dflags src_flavour mod_name

   src_hash <- getFileHash (basename <.> suff)

   hi_date <- modificationTimeIfExists hi_file

   hie_date <- modificationTimeIfExists hie_file

   o_mod <- modificationTimeIfExists o_file

   dyn_o_mod <- modificationTimeIfExists dyn_o_file

   -- Tell the finder cache about this module

   mod <- do

 findBytecodeLinkableMaybe :: HscEnv -> Module -> ModLocation -> IO (Maybe Linkable)

 findBytecodeLinkableMaybe hsc_env mod locn = do

   maybe_bytecode_time <- modificationTimeIfExists bytecode_fn

   case maybe_bytecode_time of

     Nothing -> return Nothing

       _ <- initIfaceLoad hsc_env $

              loadInterface (text "get_reachable_nodes" <+> parens (ppr mod))

                  mod ImportBySystem

       Just <$> loadByteCodeObjectLinkable bytecode_time bco

 get_reachable_nodes :: HscEnv -> [Module] -> IO ([Module], UniqDSet UnitId)

 findObjectLinkableMaybe :: Module -> ModLocation -> IO (Maybe Linkable)

 findObjectLinkableMaybe mod locn

    = do let obj_fn = ml_obj_file locn

         case maybe_obj_time of

           Nothing -> return Nothing

           Just obj_time -> liftM Just (findObjectLinkable mod obj_fn obj_time)

 import Control.Monad.IO.Class ( MonadIO, liftIO )

 import System.IO.Error as IO ( isDoesNotExistError )

 import System.Directory ( doesDirectoryExist, getModificationTime, renameFile )

 import System.FilePath

 import Data.Bifunctor   ( first, second )

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

 -- check existence & modification time at the same time

 modificationTimeIfExists f =

         `catchIO` \e -> if isDoesNotExistError e

                         then return Nothing

                         else ioError e