import GHC.IfaceToCore  ( typecheckIface, typecheckWholeCoreBindings )

 import GHC.Iface.Make

 import GHC.Iface.Recomp

 import GHC.Iface.Tidy

         -- so we need to call 'getModuleInterface' to load from disk

         case iface of

             Just _  -> return iface

 -- | Check the list of packages are trusted.

 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

    = 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

 #endif

         -- After loading all the DLLs, we can load the static objects.

         -- Ordering isn't important here, because we do one final link

         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

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

   * Ensure that `rationalToFloat` and `rationalToDouble` always inline in the end. ([CLC proposal #356](https://github.com/haskell/core-libraries-committee/issues/356))

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

   * Add `thenA` and `thenM`. ([CLC proposal #351](https://github.com/haskell/core-libraries-committee/issues/351))

   * Fix bug where `naturalAndNot` was incorrectly truncating results ([CLC proposal #350](github.com/haskell/core-libraries-committee/issues/350))

   * Remove extra laziness from `Data.Bifunctor.Bifunctor` instances for all tuples to have the same laziness as their `Data.Functor.Functor` counterparts (i.e. they became more strict than before) ([CLC proposal #339](https://github.com/haskell/core-libraries-committee/issues/339))

       * `GHC.TypeNats.Internal`

       * `GHC.ExecutionStack.Internal`.

   * Deprecate `GHC.JS.Prim.Internal.Build`, as per [CLC #329](https://github.com/haskell/core-libraries-committee/issues/329)

   * Fix incorrect results of `integerPowMod` when the base is 0 and the exponent is negative, and `integerRecipMod` when the modulus is zero ([#26017](https://gitlab.haskell.org/ghc/ghc/-/issues/26017)).

   * Fix the rewrite rule for `scanl'` not being strict in the first element of the output list ([#26143](https://gitlab.haskell.org/ghc/ghc/-/issues/26143)).

   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 GHCi.Message (LoadedDLL)

 import Control.Exception (throwIO, ErrorCall(..))

 import Control.Monad    ( when )

 import Foreign.C

 import Foreign.Marshal.Alloc ( alloca, free )

 import Foreign          ( nullPtr, peek )

 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

 #include "linker/MMap.h"

 ExecPage *allocateExecPage(void) {

     ExecPage *page = (ExecPage *) mmapAnon(getPageSize());

     return page;

 }

 void freezeExecPage(ExecPage *page) {

     mprotectForLinker(page, getPageSize(), MEM_READ_EXECUTE);

     flushExec(getPageSize(), page);

 }

 void freeExecPage(ExecPage *page) {

     munmapForLinker(page, getPageSize(), "freeExecPage");

 }

 #define SIZED_BIN_OP_TY_INT(op,ty)                                      \

 {                                                                       \

     if(sizeof(ty) > sizeof(StgWord)) {                                  \

         Sp_addW(1);                                                     \

         SpW64(0) = (StgWord64) r;                                       \

     } else {                                                            \

         Sp_addW(1);                                                     \

         SpW(0) = (StgWord) r;                                           \

     };                                                                  \

 #include "Threads.h"

 #include "sm/Sanity.h"

 #if defined(__wasm_reference_types__)

 extern HsBool rts_JSFFI_flag;

 extern StgClosure ghczminternal_GHCziInternalziWasmziPrimziImports_raiseJSException_closure;

 extern StgClosure ghczminternal_GHCziInternalziWasmziPrimziConcziInternal_threadDelay_closure;

 // Note [JSFFI initialization]

 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~

 // by the GHC codegen, and priority 102 to the initialization logic

 // here to ensure hs_init_ghc() sees everything it needs to see.

 __attribute__((constructor(102))) static void __ghc_wasm_jsffi_init(void) {

 }

 typedef __externref_t HsJSVal;

 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("/");