loadExternalPluginLib :: FilePath -> IO ()

 loadExternalPluginLib path = do

   -- load library

     Left errmsg -> pprPanic "loadExternalPluginLib"

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

                            , text "  Library path: " <> text path

 import GHC.Prelude

 import GHC.Settings.Utils         ( maybeRead )

 import GHC.Settings.Config        ( cProjectVersion )

 import GHC.Utils.Binary

 import GHC.Types.Name

 import GHC.Types.Name.Cache

 import GHC.Types.SrcLoc as SrcLoc

 import GHC.Types.Unique.FM

 import qualified GHC.Utils.Binary as Binary

 import GHC.Utils.Panic

 import qualified Data.Array        as A

   case hie_name of

     ExternalName mod occ span -> updateNameCache nc mod occ $ \cache -> do

       case lookupOrigNameCache cache mod occ of

         Just name -> pure (cache, name)

         Nothing   -> do

           uniq <- takeUniqFromNameCache nc

       -- don't update the NameCache for local names

       pure $ mkInternalName uniq occ span

 -- ** Reading and writing `HieName`'s

 putHieName :: WriteBinHandle -> HieName -> IO ()

 putHieName bh (LocalName occName span) = do

   putByte bh 1

   put_ bh (occName, BinSrcSpan span)

 getHieName :: ReadBinHandle -> IO HieName

 getHieName bh = do

     1 -> do

       (occ, span) <- get bh

       return $ LocalName occ $ unBinSrcSpan span

     _ -> panic "GHC.Iface.Ext.Binary.getHieName: invalid tag"

 import GHC.Settings.Config

 import GHC.Utils.Binary

 import GHC.Data.FastString

 import GHC.Iface.Type

 import GHC.Unit.Module            ( ModuleName, Module )

 import GHC.Types.Name

 import GHC.Utils.Outputable hiding ( (<>) )

 import GHC.Types.SrcLoc

 import GHC.Types.Avail

 import qualified GHC.Utils.Outputable as O ( (<>) )

 import GHC.Utils.Panic

 import GHC.Core.ConLike           ( ConLike(..) )

 data HieName

   = ExternalName !Module !OccName !SrcSpan

   | LocalName !OccName !SrcSpan

   deriving (Eq)

 instance Ord HieName where

     -- TODO (int-index): Perhaps use RealSrcSpan in HieName?

   compare (LocalName a b) (LocalName c d) = compare a c S.<> leftmost_smallest b d

     -- TODO (int-index): Perhaps use RealSrcSpan in HieName?

   compare ExternalName{} _ = LT

   compare LocalName{} ExternalName{} = GT

 instance Outputable HieName where

   ppr (ExternalName m n sp) = text "ExternalName" <+> ppr m <+> ppr n <+> ppr sp

   ppr (LocalName n sp) = text "LocalName" <+> ppr n <+> ppr sp

 hieNameOcc :: HieName -> OccName

 hieNameOcc (ExternalName _ occ _) = occ

 hieNameOcc (LocalName occ _) = occ

 toHieName :: Name -> HieName

 {- Note [Capture Entity Information]

 -- > static void hs_hpc_init_Main(void) {

 -- >

 -- >   static StgWord64 k0[2] = {16252233372134256ULL,7370534374096082ULL};

 -- >   hs_spt_insert(k0, &Main_r2wb_closure);

 -- >

 -- >   static StgWord64 k1[2] = {12545634534567898ULL,5409674567544151ULL};

 -- >   hs_spt_insert(k1, &Main_r2wc_closure);

 -- >

 -- > }

 --

 -- where the constants are fingerprints produced from the static forms.

 --

 -- declarations. For this to work, the identifiers of static pointers need to be

 -- exported. This is done in 'GHC.Core.Opt.SetLevels.newLvlVar'.

 --

         -- CLabel. Regardless, MayHaveCafRefs/NoCafRefs wouldn't make

         -- any difference here, they would pretty-print to the same

         -- foreign stub content.

            <> (pprCLabel platform $ mkClosureLabel n MayHaveCafRefs) <> semi

         $$ text "hs_spt_insert" <> parens

              (hcat $ punctuate comma

 {-# LANGUAGE CPP #-}

 {-# LANGUAGE RecordWildCards #-}

 {-# LANGUAGE LambdaCase #-}

 --

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

 import Data.ByteString (ByteString)

 import qualified Data.Set as Set

 import Data.Char (isSpace)

 import qualified Data.Foldable as Foldable

 import Data.IORef

 import Data.List (intercalate, isPrefixOf, nub, partition)

       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

    = do

         let dflags    = hsc_dflags hsc_env

         let logger    = hsc_logger hsc_env

             platform  = targetPlatform dflags

             is_dyn    = interpreterDynamic interp

             -- The FFI GHCi import lib isn't needed as

             -- GHC.Linker.Loader + rts/Linker.c link the

             -- interpreted references to FFI to the compiled FFI.

             -- We therefore filter it out so that we don't get

             -- duplicate symbol errors.

         -- Because of slight differences between the GHC dynamic linker and

         -- the native system linker some packages have to link with a

         -- libs do not exactly match the .so/.dll equivalents. So if the

         -- package file provides an "extra-ghci-libraries" field then we use

         -- that instead of the "extra-libraries" field.

                                       then Packages.unitExtDepLibsSys pkg

         -- See Note [Fork/Exec Windows]

         gcc_paths <- getGCCPaths logger dflags (platformOS platform)

         hs_classifieds

         extra_classifieds

         -- Complication: all the .so's must be loaded before any of the .o's.

 #if defined(CAN_LOAD_DLL)

 #endif

         -- Add directories to library search paths

         let dll_paths  = map takeDirectory known_dlls

         all_paths_env <- addEnvPaths "LD_LIBRARY_PATH" all_paths

         pathCache <- mapM (addLibrarySearchPath interp) all_paths_env

         maybePutSDoc logger

 #if defined(CAN_LOAD_DLL)

         -- 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

         if succeeded ok

            then do

              maybePutStrLn logger "done."

                  in throwGhcExceptionIO (InstallationError (showSDoc dflags errmsg))

 {-

 -- 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

   3) Loading of interface files encodes names via Uniques, as detailed in

      Note [Symbol table representation of names] in GHC.Iface.Binary

 -}

 -- | The NameCache makes sure that there is just one Unique assigned for

   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

 main = do

   initObjLinker RetainCAFs

   case result of

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

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

   return ()

 freshNameCache :: IO NameCache

 -- | Read a Haddock (@.haddock@) interface file. Return either an

 -- 'InterfaceFile' or an error message.

 //    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;

   }