return $ HscRecompNeeded $ fmap mi_iface_hash mb_checked_iface

       UpToDateItem checked_iface -> do

         let lcl_dflags = ms_hspp_opts mod_summary

         if | not (backendGeneratesCode (backend lcl_dflags)) -> do

                -- No need for a linkable, we're good to go

                msg UpToDate

            | not (backendGeneratesCodeForHsBoot (backend lcl_dflags))

            , IsBoot <- isBootSummary mod_summary -> do

                msg UpToDate

            -- Always recompile with the JS backend when TH is enabled until

            -- #23013 is fixed.

                -- 2. The bytecode object file

                bc_obj_linkable <- checkByteCodeFromObject hsc_env mod_summary

                -- 3. Bytecode from an interface whole core bindings.

                -- 4. The object file.

                obj_linkable <- liftIO $ checkObjects lcl_dflags (homeMod_object old_linkable) mod_summary

                trace_if (hsc_logger hsc_env)

                let just_o  = justObjects  <$> obj_linkable

                                (UpToDateItem bc, UpToDateItem o) -> UpToDateItem (bytecodeAndObjects bc o)

                                -- If missing object code, just say we need to recompile because of object code.

                                (_, OutOfDateItem reason _) -> OutOfDateItem reason Nothing

                    definitely_bc =  bc_obj_linkable `prefer` bc_in_memory_linkable

                    -- If not -fwrite-byte-code, then we could use core bindings or object code if that's available.

 --               pprTraceM "recomp" (ppr just_bc <+> ppr just_o)

                -- 2. Decide which of the products we will need

                let recomp_linkable_result = case () of

                      _ | backendCanReuseLoadedCode (backend lcl_dflags) ->

                         -- Need object files for making object files

                         | backendWritesFiles (backend lcl_dflags) ->

                            if gopt Opt_ByteCodeAndObjectCode lcl_dflags

                case recomp_linkable_result of

                  UpToDateItem linkable -> do

                    msg $ UpToDate

                  OutOfDateItem reason _ -> do

                    msg $ NeedsRecompile reason

                    return $ HscRecompNeeded $ Just $ mi_iface_hash $ checked_iface

 -- | Attempt to load bytecode from whole core bindings in the interface if they exist.

 -- This is a legacy code-path, these days it should be preferred to use the bytecode object linkable.

     let

       this_mod   = ms_mod mod_sum

       if_date    = fromJust $ ms_iface_date mod_sum

     case iface_core_bindings iface (ms_location mod_sum) of

       Just fi -> do

       _ -> return $ outOfDateItemBecause MissingBytecode Nothing

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

 -- Compilers

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

    status <- hscRecompStatus mHscMessage plugin_hsc_env upd_summary

                 mb_old_iface mb_old_linkable (mod_index, nmods)

    let pipeline = hscPipeline pipe_env (setDumpPrefix pipe_env plugin_hsc_env, upd_summary, status)

    -- See Note [ModDetails and --make mode]

  where lcl_dflags  = ms_hspp_opts summary

        location    = ms_location summary

            $ phaseIfFlag hsc_env flag def action

 -- | The complete compilation pipeline, from start to finish

 fullPipeline pipe_env hsc_env pp_fn src_flavour = do

   (dflags, input_fn) <- preprocessPipeline pipe_env hsc_env pp_fn

   let hsc_env' = hscSetFlags dflags hsc_env

   hscPipeline pipe_env (hsc_env_with_plugins, mod_sum, hsc_recomp_status)

 -- | Everything after preprocess

 hscPipeline pipe_env (hsc_env_with_plugins, mod_sum, hsc_recomp_status) = do

   case hsc_recomp_status of

     HscRecompNeeded mb_old_hash -> do

       (tc_result, warnings) <- use (T_Hsc hsc_env_with_plugins mod_sum)

       hscBackendAction <- use (T_HscPostTc hsc_env_with_plugins mod_sum tc_result warnings mb_old_hash )

       (iface, linkable) <-hscBackendPipeline pipe_env hsc_env_with_plugins mod_sum hscBackendAction

 hscBackendPipeline :: P m => PipeEnv -> HscEnv -> ModSummary -> HscBackendAction -> m (ModIface, HomeModLinkable)

 hscBackendPipeline pipe_env hsc_env mod_sum result =

                         liftIO (showPass logger msg)

                         liftIO (copyWithHeader line_prag out_fn final_fn)

                       return Nothing

    c :: P m => Phase -> m (Maybe FilePath)

    c phase = viaCPipeline phase pipe_env hsc_env Nothing input_fn

    as :: P m => Bool -> m (Maybe FilePath)

 -- | Status of a module in incremental compilation

 data HscRecompStatus

     -- | Nothing to do because code already exists.

     -- | Recompilation of module, or update of interface is required. Optionally

     -- pass the old interface hash to avoid updating the existing interface when

     -- it has not changed.

 # -----

 def valid_way( way: WayName ) -> bool:

         return config.have_RTS_linker

     return True

 def extra_ways( ways: List[WayName] ):

       -- begin initialize

       df0 <- GHC.getSessionDynFlags

       let df1 = df0{GHC.ghcMode    = GHC.CompManager,

                     GHC.ghcLink    = GHC.LinkInMemory,

                     GHC.verbosity  = 0}

       _ <- GHC.setSessionDynFlags df1

       logger <- getLogger

       (dflags1, _leftover, _warns) <- parseDynamicFlags logger dflags0 flags

       let dflags2 = dflags1 {

             , ghcLink   = LinkInMemory

             , verbosity = 1

             }

  = do { [libdir] <- getArgs

       ; runGhc (Just libdir) $ do

            flags <- getSessionDynFlags

            target <- guessTarget "T8639_api_a.hs" Nothing Nothing

            setTargets [target]

            load LoadAllTargets

     prn "target nothing: ok"

     dflags <- getSessionDynFlags

     ok <- load LoadAllTargets

     when (failed ok) $ error "Couldn't load A.hs in interpreted mode"

     prn "target interpreted: ok"

   where ghc action libdir = GHC.runGhc (Just libdir) (init >> action)

         init = do df <- GHC.getSessionDynFlags

                   GHC.setSessionDynFlags df{GHC.ghcMode    = GHC.CompManager,

                                             GHC.ghcLink    = GHC.LinkInMemory,

                                             GHC.verbosity  = 0}

      [ extra_files(['Obj.hs', 'ByteCode.hs', 'Types.hs', 'Common.hs-incl']),

        req_interp,

        req_bco,

      ],

      compile_and_run,

      ['']

 test('UnboxedTuples',

      [ extra_files(['Obj.hs', 'ByteCode.hs', 'Common.hs-incl']),

        req_interp,

        req_bco,

      ],

      compile_and_run,

      ['']

      [ extra_files(['Obj.hs', 'ByteCode.hs', 'Types.hs', 'Common.hs-incl']),

        req_interp,

        req_bco,

      ],

      compile_and_run,

      ['']