BRK_FUN ibi@(InternalBreakpointId info_mod infox) -> do

     p1 <- ptr $ BCOPtrBreakArray info_mod

                     then r

     info_addr        <- lit1 $ BCONPtrFS $ moduleNameFS $ moduleName info_mod

     info_unitid_addr <- lit1 $ BCONPtrFS $ unitIdFS     $ moduleUnitId info_mod

     np               <- lit1 $ BCONPtrCostCentre ibi

     emit_ bci_BRK_FUN [ Op p1, Op info_addr, Op info_unitid_addr

   BRK_ALTS active -> emit_ bci_BRK_ALTS [SmallOp (if active then 1 else 0)]

 loadExternalPluginLib :: FilePath -> IO ()

 loadExternalPluginLib path = do

   -- load library

     Left errmsg -> pprPanic "loadExternalPluginLib"

                      (vcat [ text "Can't load plugin library"

                            , text "  Library path: " <> text path

 {-# LANGUAGE CPP #-}

 {-# LANGUAGE RecordWildCards #-}

 {-# LANGUAGE LambdaCase #-}

 --

 --  (c) The University of Glasgow 2002-2006

       return pls

     DLL dll_unadorned -> do

       case maybe_errstr of

          Right _ -> maybePutStrLn logger "done"

          Left mm | platformOS platform /= OSDarwin ->

            -- since (apparently) some things install that way - see

            -- ticket #8770.

            let libfile = ("lib" ++ dll_unadorned) <.> "so"

            case err2 of

              Right _ -> maybePutStrLn logger "done"

              Left _  -> preloadFailed mm lib_paths lib_spec

       return pls

     DLLPath dll_path -> do

          case maybe_errstr of

             Right _ -> maybePutStrLn logger "done"

             Left mm -> preloadFailed mm lib_paths lib_spec

     -- if we got this far, extend the lifetime of the library file

     changeTempFilesLifetime tmpfs TFL_GhcSession [soFile]

     case m of

       Right _ -> return $! pls { temp_sos = (libPath, libName) : temp_sos }

       Left err -> linkFail msg (text err)

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

 loadPackages' interp hsc_env new_pks pls = do

                   }

   where

 loadPackage :: Interp -> HscEnv -> UnitInfo -> IO ([LibrarySpec], [LibrarySpec], [RemotePtr LoadedDLL])

 loadPackage interp hsc_env pkg

         loadFrameworks interp platform pkg

         -- See Note [Crash early load_dyn and locateLib]

         -- Crash early if can't load any of `known_dlls`

         -- For remaining `dlls` crash early only when there is surely

         -- no package's DLL around ... (not is_dyn)

 #else

         let loaded_dlls = []

 #endif

 -- we have already searched the filesystem; the strings passed to load_dyn

 -- can be passed directly to loadDLL.  They are either fully-qualified

 -- ("/usr/lib/libfoo.so"), or unqualified ("libfoo.so").  In the latter case,

   case r of

     Left err ->

       if crash_early

         then cmdLineErrorIO err

             $ reportDiagnostic logger

                 neverQualify diag_opts

                   noSrcSpan (WarningWithFlag Opt_WarnMissedExtraSharedLib) $ withPprStyle defaultUserStyle (note err)

   where

     diag_opts = initDiagOpts (hsc_dflags hsc_env)

     logger = hsc_logger hsc_env

     --   then  look in library-dirs and inplace GCC for a static library (libfoo.a)

     --   then  try "gcc --print-file-name" to search gcc's search path

     --       for a dynamic library (#5289)

     --

     --   The logic is a bit complicated, but the rationale behind it is that

     --   loading a shared library for us is O(1) while loading an archive is

      -- sorry for the hardcoded paths, I hope they won't change anytime soon:

      defaultFrameworkPaths = ["/Library/Frameworks", "/System/Library/Frameworks"]

      --

      -- See Note [macOS Big Sur dynamic libraries]

      findLoadDLL [] errs =

        -- has no built-in paths for frameworks: give up

        return $ Just errs

      findLoadDLL (p:ps) errs =

           ; case dll of

               Right _  -> return Nothing

               Left err -> findLoadDLL ps ((p ++ ": " ++ err):errs)

    | DLL String         -- "Unadorned" name of a .DLL/.so

                         --  e.g.    On unix     "qt"  denotes "libqt.so"

                         --          On Windows  "burble"  denotes "burble.DLL" or "libburble.dll"

                         --  suffixes platform-dependently

    | DLLPath FilePath   -- Absolute or relative pathname to a dynamic library

   , lookupSymbol

   , lookupSymbolInDLL

   , lookupClosure

   , loadArchive

   , loadObj

   , unloadObj

 purgeLookupSymbolCache :: Interp -> IO ()

 purgeLookupSymbolCache interp = purgeInterpSymbolCache (interpSymbolCache interp)

 -- (i.e. dlopen() on Unix, LoadLibrary() on Windows).  It takes either

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

 loadArchive interp path = do

 fromEvalResult :: EvalResult a -> IO a

 fromEvalResult (EvalException e) = throwIO (fromSerializableException e)

 fromEvalResult (EvalSuccess a) = return a

 # Changelog for [`base` package](http://hackage.haskell.org/package/base)

 ## 4.23.0.0 *TBA*

   * Add `Data.List.NonEmpty.mapMaybe`. ([CLC proposal #337](https://github.com/haskell/core-libraries-committee/issues/337))

   * Fix issues with toRational for types capable to represent infinite and not-a-number values ([CLC proposal #338](https://github.com/haskell/core-libraries-committee/issues/338))

   * Modify the implementation of `Data.List.sortOn` to use `(>)` instead of `compare`. ([CLC proposal #332](https://github.com/haskell/core-libraries-committee/issues/332))

      -- **  Legacy interface for arrays of arrays

      module GHC.Internal.ArrayArray,

      -- *  Primitive operations

      module GHC.Prim,

      module GHC.Prim.Ext,

      -- **  Running 'RealWorld' state thread

   , whereFrom#

   , isByteArrayWeaklyPinned#, isMutableByteArrayWeaklyPinned#

   -- Don't re-export vector FMA instructions

   , fmaddFloatX4#

   , fmsubFloatX4#

   , minWord8X32#

   , minWord8X64#

   )

 import GHC.Prim.Ext

 {-# LANGUAGE UnboxedTuples #-}

 {-# LANGUAGE RecordWildCards #-}

 {-# LANGUAGE CPP #-}

 --

 --  (c) The University of Glasgow 2002-2006

 import Foreign hiding (newArray)

 import Unsafe.Coerce (unsafeCoerce)

 import GHC.Arr          ( Array(..) )

 import GHC.IO

 import Control.Exception ( ErrorCall(..) )

   LookupSymbol :: String -> Message (Maybe (RemotePtr ()))

   LookupSymbolInDLL :: RemotePtr LoadedDLL -> String -> Message (Maybe (RemotePtr ()))

   LookupClosure :: String -> Message (Maybe HValueRef)

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

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

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

 -- that type isn't available here.

 data BreakUnitId

 data LoadedDLL

 -- SomeException can't be serialized because it contains dynamic

       1  -> Msg <$> return InitLinker

       2  -> Msg <$> LookupSymbol <$> get

       3  -> Msg <$> LookupClosure <$> get

       5  -> Msg <$> LoadArchive <$> get

       6  -> Msg <$> LoadObj <$> get

       7  -> Msg <$> UnloadObj <$> get

   InitLinker                  -> putWord8 1

   LookupSymbol str            -> putWord8 2  >> put str

   LookupClosure str           -> putWord8 3  >> put str

   LoadArchive str             -> putWord8 5  >> put str

   LoadObj str                 -> putWord8 6  >> put str

   UnloadObj str               -> putWord8 7  >> put str

 -- dynamic linker.

 module GHCi.ObjLink

   ( initObjLinker, ShouldRetainCAFs(..)

   , loadArchive

   , loadObj

   , unloadObj

 import GHC.Wasm.Prim

 #endif

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

 -- RTS Linker Interface

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

 initObjLinker :: ShouldRetainCAFs -> IO ()

 initObjLinker _ = pure ()

   m `catch` \(err :: JSException) ->

   where

     m = do

 -- See Note [Variable passing in JSFFI] for where

 -- __ghc_wasm_jsffi_dyld comes from

 loadArchive :: String -> IO ()

 loadArchive f = throwIO $ ErrorCall $ "loadArchive: unsupported on wasm for " <> f

    r <- c_resolveObjs

    return (r /= 0)

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

 -- Foreign declarations to RTS entry points which does the real work;

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

 #if defined(javascript_HOST_ARCH)

   LoadObj p                   -> withCString p loadJS

   InitLinker                  -> notSupportedJS m

   LoadArchive {}              -> notSupportedJS m

   UnloadObj {}                -> notSupportedJS m

   AddLibrarySearchPath {}     -> notSupportedJS m

   LookupClosure str           -> lookupJSClosure str

 #else

   InitLinker -> initObjLinker RetainCAFs

   LoadArchive str -> loadArchive str

   LoadObj str -> loadObj str

   UnloadObj str -> unloadObj str

 {-# LANGUAGE ScopedTypeVariables, StandaloneDeriving, DeriveGeneric,

     TupleSections, RecordWildCards, InstanceSigs, CPP #-}

 {-# OPTIONS_GHC -fno-warn-name-shadowing #-}

 -- |

 -- Running TH splices

 import Data.Map (Map)

 import qualified Data.Map as M

 import Data.Maybe

 import qualified GHC.Boot.TH.Syntax as TH

 import Unsafe.Coerce

         rts,

         array            == 0.5.*,

         base             >= 4.8 && < 4.23,

         ghc-prim         >= 0.5.0 && < 0.14,

         binary           == 0.8.*,

         bytestring       >= 0.10 && < 0.13,

          p1           = BCO_GET_LARGE_ARG;

          info_mod     = BCO_GET_LARGE_ARG;

          info_unit_id = BCO_GET_LARGE_ARG;

          np           = BCO_GET_LARGE_ARG;

          debugBelch ("BRK_FUN " );  printPtr( ptrs[p1] );

          debugBelch("%" FMT_Word, literals[info_mod] );

             arg1_brk_array      = BCO_GET_LARGE_ARG;

             /* info_mod_name = */ BCO_GET_LARGE_ARG;

             /* info_mod_id   = */ BCO_GET_LARGE_ARG;

             StgPtr* ptrs = (StgPtr*)(&bco->ptrs->payload[0]);

             StgArrBytes* breakPoints = (StgArrBytes *) BCO_PTR(arg1_brk_array);

             arg1_brk_array      = BCO_GET_LARGE_ARG;

             arg2_info_mod_name  = BCO_GET_LARGE_ARG;

             arg3_info_mod_id    = BCO_GET_LARGE_ARG;

 #if defined(PROFILING)

             arg5_cc             = BCO_GET_LARGE_ARG;

 #else

 main = do

   initObjLinker RetainCAFs

   case result of

     Right _ -> putStrLn (library_name ++ " loaded successfully")

     Left x  -> putStrLn ("error: " ++ x)

 //    iserv (GHCi.Server.defaultServer). This part only runs in

 //    nodejs.

 // 2. Dynamic linker: provide RTS linker interfaces like

 //    part can run in browsers as well.

 //

 // When GHC starts external interpreter for the wasm target, it starts

 //

 // *** What works right now and what doesn't work yet?

 //

 // Profiled dynamic code works. Compiled code and bytecode can all be

 // loaded, though the side effects are constrained to what's supported

 // by wasi preview1: we map the full host filesystem into wasm cause

     return this.#rpc.findSystemLibrary(f);

   }

   // toposorted array of dependencies up to itself, then sequentially

   // load the downsweep result.

   //

   // The rationale of a separate downsweep phase, instead of a simple

   // WebAssembly.compile to a background worker thread pool. To

   // maintain consistent internal linker state, we *must* load each so

   // file sequentially, but it's okay to kick off compilation asap,

   // store the Promise in downsweep result and await for the actual

   // background parallelism.

   async #downsweep(p) {

     const toks = p.split("/");

     return acc;

   }

     for (const {

       memSize,

       memP2Align,

       tableP2Align,

       modp,

       soname,

       const import_obj = {

         wasi_snapshot_preview1: this.#wasi.wasiImport,

         env: {

       rpc,

     });

     await dyld.addLibrarySearchPath(libdir);

     const reader = rpc.readStream.getReader();

     const writer = rpc.writeStream.getWriter();