with

    out_of_line = True

    Addr# -> State# s -> (# State# s, a #)

      unlifted data constructor (identified by its info table). }

    with

    effect = ReadWriteEffect

 assembleBCOs

   :: Profile

   -> FlatBag (ProtoBCO Name)

   -> [TyCon]

   -> [(Name, ByteString)]

   -> Maybe InternalModBreaks

   -> PkgsLoaded

   -> LinkerEnv

   -> LinkedBreaks

   -> NameEnv Int -- Named BCOs

   -> UnlinkedBCO

   -> IO ResolvedBCO

   -> PkgsLoaded

   -> LinkerEnv

   -> LinkedBreaks

   -> NameEnv Int -- Named BCOs

   -> BCOPtr

   -> IO ResolvedBCOPtr

 resolvePtr interp pkgs_loaded le lb udc_ix bco_ix ptr = case ptr of

   BCOPtrName nm

     -> return (ResolvedBCORefUnlifted ix)

     | Just ix <- lookupNameEnv bco_ix nm -- ref to another BCO in this group

   , RegBitmap(..)

   , NativeCallType(..), NativeCallInfo(..), voidTupleReturnInfo, voidPrimCallInfo

   , ByteOff(..), WordOff(..), HalfWord(..)

   , UnlinkedBCO(..), BCOPtr(..), BCONPtr(..)

   , ItblEnv, ItblPtr(..)

   , AddrEnv, AddrPtr(..)

   { bc_bcos   :: FlatBag UnlinkedBCO

     -- ^ Bunch of interpretable bindings

   , bc_itbls  :: [(Name, ConInfoTable)]

     -- ^ Mapping from DataCons to their info tables

 {- |

 Named reference to an unlifted data constructor

 -}

    }

 {-

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

 linkSomeBCOs interp pkgs_loaded le lb mods = foldr fun do_link mods []

  where

   fun CompiledByteCode{..} inner accum =

     inner ((Foldable.toList bc_udcs, Foldable.toList bc_bcos) : accum)

   do_link [] = return []

   do_link mods = do

         flat_BCOs = [ bco | (_, bcos) <- mods, bco <- bcos ]

         names_BCOs = map unlinkedBCOName flat_BCOs

         index_BCO = mkNameEnv (zip names_BCOs [0 ..])

     hvrefs <- createBCOs interp resolved_BCOs

     return (zip names_BCOs hvrefs)

 import Control.Monad.Trans.State  (StateT(..))

 import Data.Bifunctor (Bifunctor(..))

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

 -- Compile code for the right-hand side of a top-level binding

 schemeTopBind (id, rhs)

   | isUnliftedType (varType id), StgRhsCon _ dCon conNo _ _ _ <- rhs = do

         profile <- getProfile

               Numbered i -> i

               NoNumber   -> 0 -- This defaulting seems unsafe?

         pure . finalizer $ ConInfoTable

             tables_next_to_code

   DataToTagSmallOp -> alwaysExternal

   DataToTagLargeOp -> alwaysExternal

   MkApUpd0_Op -> alwaysExternal

   NewBCOOp -> alwaysExternal

   UnpackClosureOp -> alwaysExternal

   ListThreadsOp -> alwaysExternal

   GetSparkOp                        -> unhandledPrimop op

   AnyToAddrOp                       -> unhandledPrimop op

   MkApUpd0_Op                       -> unhandledPrimop op

   NewBCOOp                          -> unhandledPrimop op

   UnpackClosureOp                   -> unhandledPrimop op

   ClosureSizeOp                     -> unhandledPrimop op

 --

 -- | Create real byte-code objects from 'ResolvedBCO's and 'NullaryDataConApp's.

 import Prelude -- See note [Why do we import Prelude here?]

 import GHCi.BreakArray

 import Foreign hiding (newArray)

 import Unsafe.Coerce (unsafeCoerce)

 import GHC.Arr          ( Array(..) )

 import GHC.IO

 import GHC.Exts.Heap ( StgInfoTable )

 import Control.Exception ( ErrorCall(..) )

   let !(Ptr !addr#) = fromRemotePtr infoTablePtr

 createBCOs :: [ResolvedBCO] -> IO [HValueRef]

 createBCOs bcos = do

   -- see Note [Parallelize CreateBCOs serialization]

   CreateBCOs :: [ResolvedBCO] -> Message [HValueRef]

   -- | Release 'HValueRef's

   FreeHValueRefs :: [HValueRef] -> Message ()

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

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

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

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

 putMessage :: Message a -> Put

   ResumeSeq a                 -> putWord8 38 >> put a

   LookupSymbolInDLL dll str   -> putWord8 39 >> put dll >> put str

   WhereFrom a                 -> putWord8 40 >> put a

 {-

 Note [Parallelize CreateBCOs serialization]

 module GHCi.ResolvedBCO

   ( ResolvedBCO(..)

   , ResolvedBCOPtr(..)

   , isLittleEndian

   , BCOByteArray(..)

   , mkBCOByteArray

 instance NFData ConInfoTable

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

 -- | A 'ResolvedBCO' is one in which all the 'Name' references have been

 -- resolved to actual addresses or 'RemoteHValues'.

    }

    deriving (Generic, Show)

 -- a (potentially unlifted) data constructor.

    }

    deriving (Binary, Generic, NFData, Show)

   MkConInfoTable infoTable -> convertInfoTable infoTable

   ResolveObjs -> resolveObjs

   FindSystemLibrary str -> findSystemLibrary str

   CreateBCOs bcos -> createBCOs bcos

   LookupClosure str -> lookupClosure str

 #endif

         GHCi.Utils

     Build-Depends:

         array            == 0.5.*,

         base             >= 4.8 && < 4.23,

         binary           == 0.8.*,

         ghc-heap         >= 9.10.1 && <=@ProjectVersionMunged@,

         ghc-internal     >= 9.1001.0 && <=@ProjectVersionForLib@.0,

         ghc-prim         >= 0.5.0 && < 0.14,

         transformers     >= 0.5 && < 0.7

     if flag(bootstrap)

    Bytecode object primitives

    -------------------------------------------------------------------------  */

 {

     W_ p;

     ALLOC_PRIM(SIZEOF_StgHeader);