-> [(Name, ByteString)]

   -> Maybe InternalModBreaks

   -> [SptEntry]

   -> IO CompiledByteCode

   -- TODO: the profile should be bundled with the interpreter: the rts ways are

   -- fixed for an interpreter

   let itbls = mkITbls profile tycons

     , bc_strs = top_strs

     , bc_breaks = modbreaks

     , bc_spt_entries = spt_entries

     }

 -- Note [Allocating string literals]

 -- | A bytecode library is a collection of CompiledByteCode objects and a .so file containing the combination of foreign stubs

 data BytecodeLibX a = BytecodeLib {

     bytecodeLibUnitId :: UnitId,

     bytecodeLibForeign :: a -- A library file containing the combination of foreign stubs. (Ie arising from CApiFFI)

 }

       replicateM bc_strs_len $ (,) <$> getViaBinName bh <*> get bh

     bc_breaks <- get bh

     bc_spt_entries <- get bh

     return $

       CompiledByteCode

         { bc_bcos,

           bc_itbls,

           bc_strs,

           bc_breaks,

         }

   put_ bh CompiledByteCode {..} = do

     for_ bc_strs $ \(nm, str) -> putViaBinName bh nm *> put_ bh str

     put_ bh bc_breaks

     put_ bh bc_spt_entries

 instance Binary UnlinkedBCO where

   get bh =

   -- * Mod Breaks

   , ModBreaks (..), BreakpointId(..), BreakTickIndex

   -- * Internal Mod Breaks

   , InternalModBreaks(..), CgBreakInfo(..), seqInternalModBreaks

   -- ** Internal breakpoint identifier

     -- ^ Static pointer table entries which should be loaded along with the

     -- BCOs. See Note [Grand plan for static forms] in

     -- "GHC.Iface.Tidy.StaticPtrTable".

   }

 -- | A libffi ffi_cif function prototype.

      ForeignStubs (CHeader h_code) cstub -> do

         let

             stub_c_output_w = showSDoc dflags stub_c_output_d

             -- Header file protos for "foreign export"ed functions.

             stub_h_output_d = pprCode h_code

             stub_h_output_w = showSDoc dflags stub_h_output_d

         putDumpFileMaybe logger Opt_D_dump_foreign

                       "Foreign export header file"

    cplusplus_hdr = "#if defined(__cplusplus)\nextern \"C\" {\n#endif\n"

    cplusplus_ftr = "#if defined(__cplusplus)\n}\n#endif\n"

 -- It is more than likely that the stubs file will

 -- turn out to be empty, in which case no file should be created.

 outputForeignStubs_help :: FilePath -> String -> String -> String -> IO Bool

 import GHC.Hs.Stats         ( ppSourceStats )

 import GHC.HsToCore

 import GHC.StgToByteCode    ( byteCodeGen )

 import GHC.StgToJS          ( stgToJS )

 import GHC.Types.Error

 import GHC.Types.Fixity.Env

 import GHC.Types.CostCentre

 import GHC.Types.IPE

 import GHC.Types.SourceFile

 import GHC.Types.SrcLoc

 import GHC.Unit.Home.PackageTable

 import GHC.ByteCode.Serialize

 {- **********************************************************************

 %*                                                                      *

     gen_bytecode core_binds stubs foreign_files = do

       let cgi_guts = CgInteractiveGuts wcb_module core_binds

                       (typeEnvTyCons type_env) stubs foreign_files

       trace_if logger (text "Generating ByteCode for" <+> ppr wcb_module)

       mkModuleByteCode hsc_env wcb_module wcb_mod_location cgi_guts

                                            , cgi_foreign_files :: [(ForeignSrcLang, FilePath)]

                                            , cgi_modBreaks ::  Maybe ModBreaks

                                            , cgi_spt_entries :: [SptEntry]

                                            }

 mkCgInteractiveGuts :: CgGuts -> CgInteractiveGuts

 hscInteractive :: HscEnv

                -> CgInteractiveGuts

 hscGenerateByteCode hsc_env cgguts location = do

     let dflags = hsc_dflags hsc_env

     let logger = hsc_logger hsc_env

     let CgInteractiveGuts{ -- This is the last use of the ModGuts in a compilation.

                 -- From now on, we just use the bits we need.

                cgi_module   = this_mod,

                cgi_binds    = core_binds,

                cgi_tycons   = tycons,

                cgi_modBreaks = mod_breaks,

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

     -- ADD IMPLICIT BINDINGS

     let (stg_binds,_stg_deps) = unzip stg_binds_with_deps

     -----------------  Generate byte code ------------------

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

 generateAndWriteByteCode :: HscEnv -> CgInteractiveGuts -> ModLocation -> IO ModuleByteCode

                 []

                 Nothing -- modbreaks

                 [] -- spt entries

       {- load it -}

       bco_time <- getCurrentTime

 module GHC.HsToCore.Coverage

   ( writeMixEntries

   , hpcInitCode

   ) where

 import GHC.Prelude as Prelude

 hpcInitCode platform this_mod (HpcInfo tickCount hashNo)

  = initializerCStub platform fn_name decls body

   where

     decls = text "StgWord64 " <> tickboxes <> brackets (int tickCount) <> semi

     body = text "hs_hpc_module" <>

               parens (hcat (punctuate comma [

                   int tickCount, -- really StgWord32

                   int hashNo,    -- really StgWord32

                   tickboxes

                 ])) <> semi

                           , mg_foreign_files    = foreign_files

                           , mg_modBreaks        = modBreaks

                           , mg_boot_exports     = boot_exports

                           }) = do

   (unfold_env, tidy_occ_env) <- chooseExternalIds opts mod tcs binds imp_rules

                  , cg_dep_pkgs      = S.map snd (dep_direct_pkgs deps)

                  , cg_modBreaks     = modBreaks

                  , cg_spt_entries   = spt_entries

                  }

          , ModDetails { md_types            = tidy_type_env

                       , md_rules            = tidy_rules

   let bytecodeLib' = BytecodeLib {

     bytecodeLibUnitId = homeUnitId_ dflags,

     bytecodeLibForeign = interpreter_foreign_lib

   }

   let output_fn = fromMaybe "a.out" (outputFile dflags)

           return $ Just (InterpreterSharedObject foreign_stub_lib_path foreign_stub_lib_dir foreign_stub_lib_name)

         Nothing -> pure Nothing

     False -> do

 import qualified Data.Map.Strict as M

 import Foreign.Ptr (nullPtr)

 import GHC.ByteCode.Serialize

 -- Note [Linkers and loaders]

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

         let (bcos_loaded', new_bcos) = rmDupLinkables (bcos_loaded pls) bcos

             pls1                     = pls { bcos_loaded = bcos_loaded' }

         in do

           return $! pls1 { bco_loader_state = bco_state }

 dynLinkCompiledByteCode :: Interp

                         -> BytecodeLoaderState

                         -> BytecodeLoaderStateTraverser IO  -- ^ The traverser tells us to update home package bytecode state or external package bytecode state

                         -> KeepModuleLinkableDefinitions

                         -> IO BytecodeLoaderState

         st1 <- traverse_bytecode_state whole_bytecode_state $ \bytecode_state -> do

           let

               le1 = bco_linker_env bytecode_state

           let ce2 = extendClosureEnv (closure_env (bco_linker_env bytecode_state)) new_binds

           -- Add SPT entries

           mapM_ (linkSptEntry interp ce2) (concatMap bc_spt_entries cbcs)

           return $! bytecode_state { bco_linker_env = (bco_linker_env bytecode_state) { closure_env = ce2 } }

 -- | Register SPT entries for this module in the interpreter

     Nothing -> pprPanic "linkSptEntry" (ppr name)

     Just (_, hval) -> addSptEntry interp fpr hval

 -- Link a bunch of BCOs and return references to their values

 linkSomeBCOs :: Interp

        -- ^ Information about bytecode objects from the home package we have loaded into the interpreter.

        , externalPackage_loaded :: BytecodeState

        -- ^ Information about bytecode objects from external packages we have loaded into the interpreter.

        }

 -- | Find a name loaded from bytecode

 lookupNameBytecodeState :: BytecodeLoaderState -> Name -> Maybe (Name, ForeignHValue)

       lookupNameEnv (closure_env (bco_linker_env home_package)) name

   <|> lookupNameEnv (closure_env (bco_linker_env external_package)) name

 -- | Look up a break array in the bytecode loader state.

 lookupBreakArrayBytecodeState :: BytecodeLoaderState -> Module -> Maybe (ForeignRef BreakArray)

   lookupModuleEnv (breakarray_env (bco_linked_breaks home_package)) break_mod

   <|> lookupModuleEnv (breakarray_env (bco_linked_breaks external_package)) break_mod

 -- | Look up an info table in the bytecode loader state.

 lookupInfoTableBytecodeState :: BytecodeLoaderState -> Name -> Maybe (Name, ItblPtr)

   lookupNameEnv (itbl_env (bco_linker_env home_package)) info_mod

   <|> lookupNameEnv (itbl_env (bco_linker_env external_package)) info_mod

 -- | Look up an address in the bytecode loader state.

 lookupAddressBytecodeState :: BytecodeLoaderState -> Name -> Maybe (Name, AddrPtr)

   lookupNameEnv (addr_env (bco_linker_env home_package)) addr_mod

   <|> lookupNameEnv (addr_env (bco_linker_env external_package)) addr_mod

 -- | Look up a cost centre stack in the bytecode loader state.

 lookupCCSBytecodeState :: BytecodeLoaderState -> Module -> Maybe (Array BreakTickIndex (RemotePtr CostCentre))

   lookupModuleEnv (ccs_env (bco_linked_breaks home_package)) ccs_mod

   <|> lookupModuleEnv (ccs_env (bco_linked_breaks external_package)) ccs_mod

 emptyBytecodeLoaderState = BytecodeLoaderState

     { homePackage_loaded = emptyBytecodeState

     , externalPackage_loaded = emptyBytecodeState

     }

 emptyBytecodeState :: BytecodeState

   , mallocData

   , createBCOs

   , addSptEntry

   , mkCostCentres

   , costCentreStackInfo

   , newBreakArray

   withForeignRef ref $ \val ->

     interpCmd interp (AddSptEntry fpr val)

 costCentreStackInfo :: Interp -> RemotePtr CostCentreStack -> IO [String]

 costCentreStackInfo interp ccs =

   interpCmd interp (CostCentreStackInfo ccs)

 import Foreign hiding (shiftL, shiftR)

 import Control.Monad

 import Data.Char

 import GHC.Unit.Module

             -> [TyCon]

             -> Maybe ModBreaks

             -> [SptEntry]

             -> IO CompiledByteCode

    = withTiming logger

                 (text "GHC.StgToByteCode"<+>brackets (ppr this_mod))

                 (const ()) $ do

         let mod_breaks = case mb_modBreaks of

              Nothing -> Nothing

              Just mb -> Just $ mkInternalModBreaks this_mod breakInfo mb

         -- Squash space leaks in the CompiledByteCode.  This is really

         -- important, because when loading a set of modules into GHCi

 emptyHpcInfo :: HpcInfo

 emptyHpcInfo = NoHpcInfo

         cg_dep_pkgs  :: !(Set UnitId),      -- ^ Dependent packages, used to

                                             -- generate #includes for C code gen

         cg_modBreaks :: !(Maybe ModBreaks), -- ^ Module breakpoints

                 -- ^ Static pointer table entries for static forms defined in

                 -- the module.

                 -- See Note [Grand plan for static forms] in "GHC.Iface.Tidy.StaticPtrTable"

     }

   -- | Add entries to the Static Pointer Table

   AddSptEntry :: Fingerprint -> HValueRef -> Message ()

   -- | Malloc some data and return a 'RemotePtr' to it

   MallocData :: ByteString -> 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

   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]

 import GHCi.InfoTable

 #endif

 import qualified GHC.InfoProv as InfoProv

 import GHCi.Debugger

 import GHCi.FFI

     fmap toRemotePtr <$> lookupSymbolInDLL (fromRemotePtr dll) str

   FreeHValueRefs rs -> mapM_ freeRemoteRef rs

   AddSptEntry fpr r -> localRef r >>= sptAddEntry fpr

   EvalStmt opts r -> evalStmt opts r

   ResumeStmt opts r -> resumeStmt opts r

   AbandonStmt r -> abandonStmt r

     if flag(internal-interpreter)

         CPP-Options: -DHAVE_INTERNAL_INTERPRETER

         exposed-modules:

             GHCi.Run

             GHCi.Debugger

             GHCi.CreateBCO

       }

       tmpModule->from_file = false;

   }

 }

 static void

             W_ arg1_ticks_array, arg2_tick_index;

             arg1_ticks_array = BCO_GET_LARGE_ARG;

             arg2_tick_index  = BCO_READ_NEXT_32;

             ((StgWord64*)BCO_LIT(arg1_ticks_array))[arg2_tick_index]++;

             NEXT_INSTRUCTION;