, writeBytecodeLib

   , readBytecodeLib

   , mkBytecodeLib

   )

 where

 import GHC.Driver.Session

 import GHC.Driver.CodeOutput

 import GHC.Driver.Env

 import GHC.ByteCode.Types

 import GHC.Linker.Types

 import GHC.Platform.Ways

 import GHC.ByteCode.Serialize

 -- | Write foreign sources and foreign stubs to temporary files and compile them.

 outputAndCompileForeign hsc_env mod_name location foreign_files foreign_stubs = do

   let dflags   = hsc_dflags hsc_env

       logger   = hsc_logger hsc_env

     adapt_way want = if want (hscInterp hsc_env) then addWay else removeWay

 -- | Write the foreign sources and foreign stubs of a bytecode object to temporary files and compile them.

                              -> IO (CompiledByteCode, [FilePath])

 loadByteCodeObject hsc_env location (ByteCodeObject mod cbc foreign_srcs foreign_stubs) = do

   fos <- outputAndCompileForeign hsc_env mod location foreign_srcs foreign_stubs

   return (cbc, fos)

 loadByteCodeObjectLinkable hsc_env linkable_time location bco = do

   ~(cbc, fos) <- loadByteCodeObject hsc_env location bco

   return $! Linkable linkable_time (bco_module bco) (BCOs cbc :| [DotO fo ForeignObject | fo <- fos])

                  ViaCCodeOutput -> outputC logger dflags filenm dus1 final_stream pkg_deps

                  LlvmCodeOutput -> outputLlvm logger llvm_config dflags filenm dus1 final_stream

                  JSCodeOutput   -> outputJS logger llvm_config dflags filenm final_stream

         ; return (filenm, stubs_exist, foreign_fps, a)

         }

     -> DynFlags

     -> UnitState

     -> Module

     -> ForeignStubs

     -> IO (Bool,         -- Header file created

            Maybe FilePath) -- C file created

           -- that the one we have on disk would be suitable as well.

           linkable <- unsafeInterleaveIO $ do

             bco <- readBinByteCode hsc_env obj_fn

           return $ UpToDateItem linkable

     _ -> return $ outOfDateItemBecause MissingBytecode Nothing

     let tmpfs  = hsc_tmpfs hsc_env

     ------------------ Create f-x-dynamic C-side stuff -----

     (_istub_h_exists, istub_c_exists)

     return (istub_c_exists, comp_bc)

   -> IO (CompiledByteCode, [FilePath])

 generateByteCode hsc_env cgguts mod_location = do

   comp_bc' <- hscGenerateByteCode hsc_env cgguts mod_location

   pure (comp_bc', fos)

 -- | Generate a byte code object linkable and write it to a file if `-fwrite-bytecode` is enabled.

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

   -- checking.

   bco_time <- maybe getCurrentTime pure =<< modificationTimeIfExists (ml_bytecode_file mod_location)

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

 mkByteCodeObject hsc_env mod mod_location cgguts = do

 generateFreshByteCodeLinkable hsc_env mod_name cgguts mod_location = do

   bco_time <- getCurrentTime

   bco_object <- mkByteCodeObject hsc_env (mkHomeModule (hsc_home_unit hsc_env) mod_name) mod_location cgguts

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

 hscCompileCmmFile :: HscEnv -> FilePath -> FilePath -> FilePath -> IO (Maybe FilePath)

                   return Succeeded

           else do

         let hackyMPtodo l = [ ByteCodeObject (linkableModule l) cbc [] NoStubs | cbc <- linkableBCOs l ]

         let linkObjectLinkable action =

 import qualified Data.Map.Strict as M

 import Foreign.Ptr (nullPtr)

 import GHC.ByteCode.Serialize

 -- Note [Linkers and loaders]

 -- ~~~~~~~~~~~~~~~~~~~~~~~~~~

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

                  mod ImportBySystem

       bco <- readBinByteCode hsc_env bytecode_fn

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

 get_reachable_nodes hsc_env mods

 loadPackages' :: Interp -> HscEnv -> [UnitId] -> LoaderState -> IO LoaderState

 loadPackages' interp hsc_env new_pks pls = do

   where

      link pkgs new_pkgs =

          foldM link_one pkgs new_pkgs

      link_one pkgs new_pkg

         = return pkgs

         | Just pkg_cfg <- lookupUnitId (hsc_units hsc_env) new_pkg

                -- Link dependents first

              ; pkgs' <- link pkgs deps

                 -- Now link the package itself

         | otherwise

         = throwGhcExceptionIO (CmdLineError ("unknown package: " ++ unpackFS (unitIdFS new_pkg)))

    = do

         let dflags    = hsc_dflags hsc_env

         let logger    = hsc_logger hsc_env

         -- step to resolve everything.

         mapM_ (loadObj interp) objs

         mapM_ (loadArchive interp) archs

         maybePutStr logger "linking ... "

         ok <- resolveObjs interp

         if succeeded ok

            then do

              maybePutStrLn logger "done."

            else let errmsg = text "unable to load unit `"

                              <> pprUnitInfoForUser pkg <> text "'"

                  in throwGhcExceptionIO (InstallationError (showSDoc dflags errmsg))

 {-

 Note [Crash early load_dyn and locateLib]

 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

         -- ^ And the currently-loaded compiled modules (home package)

     , pkgs_loaded :: !PkgsLoaded

         -- haskell libraries, system libraries, transitive dependencies

     , temp_sos :: ![(FilePath, String)]

   , loadDLL

   , loadArchive

   , loadObj

   , unloadObj

   , addLibrarySearchPath

   , removeLibrarySearchPath

 import GHCi.ResolvedBCO

 import GHCi.BreakArray (BreakArray)

 import GHC.ByteCode.Breakpoints

 import GHC.ByteCode.Types

 import GHC.Linker.Types

 import GHC.Builtin.Names

 import GHC.Types.Name

 import qualified GHC.Unit.Home.Graph as HUG

 -- Standard libraries

 import GHC.Exts

   path' <- canonicalizePath path -- Note [loadObj and relative paths]

   interpCmd interp (LoadArchive path')

 loadObj :: Interp -> String -> IO ()

 loadObj interp path = do

 mkStubPaths

   :: FinderOpts

   -> ModuleName

   -> Maybe OsPath

   stub_basename <- in_stub_dir <|> src_basename

   pure (stub_basename `mappend` os "_stub" <.> os "h")

   where

     in_stub_dir = (</> mod_basename) <$> (finder_stubDir fopts)

     mod_basename = unsafeEncodeUtf $ moduleNameSlashes mod

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

 -- findLinkable isn't related to the other stuff in here,

   LookupClosure :: String -> Message (Maybe HValueRef)

   LoadDLL :: String -> Message (Either String (RemotePtr LoadedDLL))

   LoadArchive :: String -> Message () -- error?

   LoadObj :: String -> Message () -- error?

   UnloadObj :: String -> Message () -- error?

   AddLibrarySearchPath :: String -> Message (RemotePtr ())

       38 -> Msg <$> (ResumeSeq <$> get)

       39 -> Msg <$> (LookupSymbolInDLL <$> get <*> get)

       40 -> Msg <$> (WhereFrom <$> get)

       _  -> error $ "Unknown Message code " ++ (show b)

 putMessage :: Message a -> Put

 module Bytecode where

 LOCAL_GHC_PKG08 = '$(GHC_PKG)' --no-user-package-db -f $(PKGCONF08)

 pkg_bytecode :

 	$(LOCAL_GHC_PKG08) init $(PKGCONF08)

 	$(LOCAL_GHC_PKG08) register --force bytecode.pkg

 test('ghcpkg07', [extra_files(['test.pkg', 'test7a.pkg', 'test7b.pkg'])], makefile_test, [])

 # Test that we *can* compile a module that also belongs to a package

 # (this was disallowed in GHC 6.4 and earlier)

 author: simonmar@microsoft.com

 exposed: True

 exposed-modules: Bytecode

 include-dirs:

 hs-libraries: testpkg-1.2.3.4-XXX

 testpkg-1.2.3.4: cannot find any of ["libtestpkg-1.2.3.4-XXX.a","libtestpkg-1.2.3.4-XXX_p.a","libtestpkg-1.2.3.4-XXX-ghc9.15.20250811.so","libtestpkg-1.2.3.4-XXX_p-ghc9.15.20250811.so","libtestpkg-1.2.3.4-XXX-ghc9.15.20250811.dylib","libtestpkg-1.2.3.4-XXX_p-ghc9.15.20250811.dylib","testpkg-1.2.3.4-XXX-ghc9.15.20250811.dll","testpkg-1.2.3.4-XXX_p-ghc9.15.20250811.dll"] on library path (ignoring)

 hs_classifieds

   [DLLPath /home/matt/ghc-bytecode/_new/stage1/lib/../lib/x86_64-linux-ghc-9.15.20250811/libHSghc-internal-9.1500.0-inplace-ghc9.15.20250811.so]

 hs_classifieds

 [1 of 2] Compiling Bytecode         ( Bytecode.hs, interpreted )

 [2 of 2] Linking testpkg-1.2.3.4-XXX.bytecode

 GHCi, version 9.15.20250811: https://www.haskell.org/ghc/  :? for help

 ghci> Leaving GHCi.