module GHC.Linker.Deps

   ( LinkDepsOpts (..)

   , LinkDeps (..)

   , getLinkDeps

   )

 where

 data LinkDeps = LinkDeps

   { ldNeededLinkables :: [Linkable]

   , ldAllLinkables    :: [Linkable]

   , ldAllUnits        :: UniqDSet UnitId

   }

 -- | Find all the packages and linkables that a set of modules depends on

 --

 -- Return the module and package dependencies for the needed modules.

         link_mods =

           listToUDFM [(moduleName (mi_module (hm_iface m)), m) | m <- mmods]

         link_libs =

       pure $

         LinkModules (LinkHomeModule <$> link_mods) :

     -- This code is used in `--make` mode to calculate the home package and unit dependencies

     -- for a set of modules.

     -- It is also a matter of correctness to use the module graph so that dependencies between home units

     -- is resolved correctly.

     make_deps_loop found [] = found

     make_deps_loop found@(found_units, found_mods) (nk:nexts)

       | NodeKey_Module nk `Set.member` found_mods = make_deps_loop found nexts

         case fmap mkNodeKey <$> mgReachable mod_graph (NodeKey_Module nk) of

           Nothing ->

               let (ModNodeKeyWithUid _ uid) = nk

           Just trans_deps ->

             let deps = Set.insert (NodeKey_Module nk) (Set.fromList trans_deps)

                 -- See #936 and the ghci.prog007 test for why we have to continue traversing through

             in make_deps_loop (found_units, deps `Set.union` found_mods) (todo_boot_mods ++ nexts)

     mkNk m = ModNodeKeyWithUid (GWIB (moduleName m) NotBoot) (moduleUnitId m)

     all_home_mods = [with_uid | NodeKey_Module with_uid <- Set.toList all_deps]

           let iface = hm_iface hmi

           case mi_hsc_src iface of

             HsBootFile -> throwProgramError opts $ link_boot_mod_error (mi_module iface)

         Nothing -> throwProgramError opts $

           text "getLinkDeps: Home module not loaded" <+> ppr (gwib_mod gwib) <+> ppr uid

 data LinkDep =

   LinkModules (UniqDFM ModuleName LinkModule)

   |

 instance Outputable LinkDep where

   ppr = \case

     LinkModules mods -> text "modules:" <+> ppr (eltsUDFM mods)

 data OneshotError =

   NoLocation Module

     already_seen

       | Just (LinkModules mods) <- mod_dep

       = elemUDFM mod_name mods

       = True

       | otherwise

       = False

       | otherwise

       = add_library

     add_module iface lmod =

       (addListToUDFM with_mod (direct_pkgs iface), new_deps iface)

       | bytecode

       = []

       | otherwise

     new_deps iface

       | bytecode

       text "due to use of Template Haskell"

     bytecode = ldUseByteCode opts

     mb_home = ue_homeUnit (ldUnitEnv opts)

 link_boot_mod_error :: Module -> SDoc

 classify_deps ::

   LoaderState ->

   [LinkDep] ->

 classify_deps pls deps =

   (loaded_modules, needed_modules, all_packages, needed_packages)

   where

       partitionWith loaded_or_needed (concatMap eltsUDFM modules)

     needed_packages =

       LinkModules mods -> Left mods

     loaded_or_needed lm =

       maybe (Right lm) Left (loaded_linkable (mi_module (link_module_iface lm)))

 import qualified Data.Set as Set

 import Data.Char (isSpace)

 import Data.IORef

 import Data.Maybe

 import Control.Concurrent.MVar

 import qualified Control.Monad.Catch as MC

 #endif

 import GHC.Utils.Exception

 -- Note [Linkers and loaders]

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

   --

   -- The linker's symbol table is populated with RTS symbols using an

   -- explicit list.  See rts/Linker.c for details.

 extendLoadedEnv :: Interp -> [(Name,ForeignHValue)] -> IO ()

 extendLoadedEnv interp new_bindings =

       -- (a) initialise the C dynamic linker

       initObjLinker interp

       -- (b) Load packages from the command-line (Note [preload packages])

       -- steps (c), (d) and (e)

       loadCmdLineLibs' interp hsc_env pls

     -- link all "loaded packages" so symbols in those can be resolved

     -- Note: We are loading packages with local scope, so to see the

     -- symbols in this link we must link all loaded packages again.

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

     changeTempFilesLifetime tmpfs TFL_GhcSession [soFile]

   where

     msg = "GHC.Linker.Loader.dynLoadObjs: Loading temp shared object failed"

 rmDupLinkables :: LinkableSet    -- Already loaded

                -> [Linkable]    -- New linkables

                -> (LinkableSet,  -- New loaded set (including new ones)

   -- a lock.

   initLoaderState interp hsc_env

   modifyLoaderState_ interp $ \pls ->

     pkgs' <- link (pkgs_loaded pls) new_pks

     return $! pls { pkgs_loaded = pkgs'

                   }

   where

      link pkgs new_pkgs =

          foldM link_one pkgs new_pkgs

         = return pkgs

         = do { let deps = unitDepends pkg_cfg

                -- Link dependents first

                 -- Now link the package itself

              ; (hs_cls, extra_cls, loaded_dlls) <- loadPackage interp hsc_env pkg_cfg

              ; let trans_deps = unionManyUniqDSets [ addOneToUniqDSet (loaded_pkg_trans_deps loaded_pkg_info) dep_pkg

                                                    | dep_pkg <- deps

                                                    , Just loaded_pkg_info <- pure (lookupUDFM pkgs' dep_pkg)

                                                    ]

         | otherwise

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

 data LoadedPkgInfo

   = LoadedPkgInfo

   { loaded_pkg_uid         :: !UnitId

   , loaded_pkg_hs_objs     :: ![LibrarySpec]

   , loaded_pkg_non_hs_objs :: ![LibrarySpec]

   , loaded_pkg_hs_dlls     :: ![RemotePtr LoadedDLL]

   }

 instance Outputable LoadedPkgInfo where

          , ppr hs_objs

          , ppr non_hs_objs

          , ppr trans_deps ]