Linker.lhs 46 KB
Newer Older
1
%
2
% (c) The University of Glasgow 2005-2006
3 4
%
\begin{code}
5 6 7 8 9 10
-- | The dynamic linker for GHCi.
--
-- This module deals with the top-level issues of dynamic linking,
-- calling the object-code linker and the byte-code linker where
-- necessary.

11 12 13
{-# OPTIONS -fno-cse #-}
-- -fno-cse is needed for GLOBAL_VAR's to behave properly

mnislaih's avatar
mnislaih committed
14
module Linker ( HValue, getHValue, showLinkerState,
15 16 17
		linkExpr, unload, withExtendedLinkEnv,
                extendLinkEnv, deleteFromLinkEnv,
                extendLoadedPkgs, 
18 19
		linkPackages,initDynLinker,linkModule,
                dataConInfoPtrToName, lessUnsafeCoerce
20
	) where
sof's avatar
sof committed
21

22
#include "HsVersions.h"
23

24
import LoadIface
25 26 27 28
import ObjLink
import ByteCodeLink
import ByteCodeItbls
import ByteCodeAsm
29 30
import CgInfoTbls
import SMRep
31 32
import IfaceEnv
import TcRnMonad
33
import Packages
34 35
import DriverPhases
import Finder
36
import HscTypes
37
import Name
38
import NameEnv
39
import NameSet
40
import qualified OccName
41
import UniqFM
42
import Module
43 44 45
import ListSetOps
import DynFlags
import BasicTypes
46
import Outputable
47 48 49 50 51
import Panic
import Util
import StaticFlags
import ErrUtils
import SrcLoc
52
import qualified Maybes
Simon Marlow's avatar
Simon Marlow committed
53
import UniqSet
54
import Constants
55
import FastString
56
import Config
57

58 59
import GHC.Exts (unsafeCoerce#)

60
-- Standard libraries
61
import Control.Monad
62

63
import Data.Char
64 65
import Data.IORef
import Data.List
66
import qualified Data.Map as Map
67
import Foreign
68
import Control.Concurrent.MVar
69

Ian Lynagh's avatar
Ian Lynagh committed
70
import System.FilePath
71 72
import System.IO
import System.Directory
73

Ian Lynagh's avatar
Ian Lynagh committed
74
import Distribution.Package hiding (depends, PackageId)
Ian Lynagh's avatar
Ian Lynagh committed
75

76
import Exception
77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93
\end{code}


%************************************************************************
%*									*
			The Linker's state
%*									*
%************************************************************************

The persistent linker state *must* match the actual state of the 
C dynamic linker at all times, so we keep it in a private global variable.


The PersistentLinkerState maps Names to actual closures (for
interpreted code only), for use during linking.

\begin{code}
94
GLOBAL_MVAR(v_PersistentLinkerState, panic "Dynamic linker not initialised", PersistentLinkerState)
95
GLOBAL_VAR(v_InitLinkerDone, False, Bool)	-- Set True when dynamic linker is initialised
96 97 98 99 100 101 102 103 104 105 106 107

data PersistentLinkerState
   = PersistentLinkerState {

	-- Current global mapping from Names to their true values
        closure_env :: ClosureEnv,

	-- The current global mapping from RdrNames of DataCons to
	-- info table addresses.
	-- When a new Unlinked is linked into the running image, or an existing
	-- module in the image is replaced, the itbl_env must be updated
	-- appropriately.
108
        itbl_env    :: !ItblEnv,
109 110

	-- The currently loaded interpreted modules (home package)
111
	bcos_loaded :: ![Linkable],
112 113

	-- And the currently-loaded compiled modules (home package)
114
	objs_loaded :: ![Linkable],
115 116 117 118

	-- The currently-loaded packages; always object code
	-- Held, as usual, in dependency order; though I am not sure if
	-- that is really important
119
	pkgs_loaded :: ![PackageId]
120 121
     }

122
emptyPLS :: DynFlags -> PersistentLinkerState
Ian Lynagh's avatar
Ian Lynagh committed
123
emptyPLS _ = PersistentLinkerState { 
124 125 126 127
			closure_env = emptyNameEnv,
			itbl_env    = emptyNameEnv,
			pkgs_loaded = init_pkgs,
			bcos_loaded = [],
128 129
			objs_loaded = [] }
                    
130 131 132 133 134
  -- Packages that don't need loading, because the compiler 
  -- shares them with the interpreted program.
  --
  -- The linker's symbol table is populated with RTS symbols using an
  -- explicit list.  See rts/Linker.c for details.
Simon Marlow's avatar
Simon Marlow committed
135
  where init_pkgs = [rtsPackageId]
136 137 138
\end{code}

\begin{code}
139
extendLoadedPkgs :: [PackageId] -> IO ()
140 141 142
extendLoadedPkgs pkgs =
  modifyMVar_ v_PersistentLinkerState $ \s ->
      return s{ pkgs_loaded = pkgs ++ pkgs_loaded s }
143

144 145
extendLinkEnv :: [(Name,HValue)] -> IO ()
-- Automatically discards shadowed bindings
146 147 148 149
extendLinkEnv new_bindings =
  modifyMVar_ v_PersistentLinkerState $ \pls ->
    let new_closure_env = extendClosureEnv (closure_env pls) new_bindings
    in return pls{ closure_env = new_closure_env }
150

151
deleteFromLinkEnv :: [Name] -> IO ()
152 153 154 155
deleteFromLinkEnv to_remove =
  modifyMVar_ v_PersistentLinkerState $ \pls ->
    let new_closure_env = delListFromNameEnv (closure_env pls) to_remove
    in return pls{ closure_env = new_closure_env }
156

157 158 159 160
-- | Given a data constructor in the heap, find its Name.
--   The info tables for data constructors have a field which records
--   the source name of the constructor as a Ptr Word8 (UTF-8 encoded
--   string). The format is:
161
--
162
--   > Package:Module.Name
163 164 165
--
--   We use this string to lookup the interpreter's internal representation of the name
--   using the lookupOrig.    
166
--
167
dataConInfoPtrToName :: Ptr () -> TcM (Either String Name)
168
dataConInfoPtrToName x = do 
twanvl's avatar
twanvl committed
169
   theString <- liftIO $ do
170
      let ptr = castPtr x :: Ptr StgInfoTable
171
      conDescAddress <- getConDescAddress ptr 
172
      peekArray0 0 conDescAddress  
173
   let (pkg, mod, occ) = parse theString 
174 175 176 177 178
       pkgFS = mkFastStringByteList pkg
       modFS = mkFastStringByteList mod
       occFS = mkFastStringByteList occ
       occName = mkOccNameFS OccName.dataName occFS
       modName = mkModule (fsToPackageId pkgFS) (mkModuleNameFS modFS) 
179 180
   return (Left$ showSDoc$ ppr modName <> dot <> ppr occName ) 
    `recoverM` (Right `fmap` lookupOrig modName occName)
181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223

   where

   {- To find the string in the constructor's info table we need to consider 
      the layout of info tables relative to the entry code for a closure.

      An info table can be next to the entry code for the closure, or it can
      be separate. The former (faster) is used in registerised versions of ghc, 
      and the latter (portable) is for non-registerised versions. 

      The diagrams below show where the string is to be found relative to 
      the normal info table of the closure.

      1) Code next to table:

         --------------
         |            |   <- pointer to the start of the string
         --------------
         |            |   <- the (start of the) info table structure
         |            |
         |            |
         --------------
         | entry code | 
         |    ....    |

         In this case the pointer to the start of the string can be found in
         the memory location _one word before_ the first entry in the normal info 
         table.

      2) Code NOT next to table:

                                 --------------
         info table structure -> |     *------------------> --------------
                                 |            |             | entry code |
                                 |            |             |    ....    | 
                                 --------------
         ptr to start of str ->  |            |   
                                 --------------

         In this case the pointer to the start of the string can be found
         in the memory location: info_table_ptr + info_table_size
   -}

224
   getConDescAddress :: Ptr StgInfoTable -> IO (Ptr Word8)
Ian Lynagh's avatar
Ian Lynagh committed
225 226
   getConDescAddress ptr
    | ghciTablesNextToCode = do
227 228
       offsetToString <- peek $ ptr `plusPtr` (- wORD_SIZE)
       return $ (ptr `plusPtr` stdInfoTableSizeB) `plusPtr` (fromIntegral (offsetToString :: StgWord))
Ian Lynagh's avatar
Ian Lynagh committed
229
    | otherwise =
230
       peek $ intPtrToPtr $ (ptrToIntPtr ptr) + fromIntegral stdInfoTableSizeB
231 232 233 234 235 236 237 238

   -- parsing names is a little bit fiddly because we have a string in the form: 
   -- pkg:A.B.C.foo, and we want to split it into three parts: ("pkg", "A.B.C", "foo").
   -- Thus we split at the leftmost colon and the rightmost occurrence of the dot.
   -- It would be easier if the string was in the form pkg:A.B.C:foo, but alas
   -- this is not the conventional way of writing Haskell names. We stick with
   -- convention, even though it makes the parsing code more troublesome.
   -- Warning: this code assumes that the string is well formed.
239
   parse :: [Word8] -> ([Word8], [Word8], [Word8])
240 241 242
   parse input 
      = ASSERT (all (>0) (map length [pkg, mod, occ])) (pkg, mod, occ)
      where
243 244
      dot = fromIntegral (ord '.')
      (pkg, rest1) = break (== fromIntegral (ord ':')) input 
245
      (mod, occ) 
246
         = (concat $ intersperse [dot] $ reverse modWords, occWord)
247 248
         where
         (modWords, occWord) = ASSERT (length rest1 > 0) (parseModOcc [] (tail rest1))
249
      parseModOcc :: [[Word8]] -> [Word8] -> ([[Word8]], [Word8])
250 251 252 253 254 255 256
      -- We only look for dots if str could start with a module name,
      -- i.e. if it starts with an upper case character.
      -- Otherwise we might think that "X.:->" is the module name in
      -- "X.:->.+", whereas actually "X" is the module name and
      -- ":->.+" is a constructor name.
      parseModOcc acc str@(c : _)
       | isUpper $ chr $ fromIntegral c
257
         = case break (== dot) str of
258
              (top, []) -> (acc, top)
259 260 261
              (top, _ : bot) -> parseModOcc (top : acc) bot
      parseModOcc acc str = (acc, str)

262 263 264 265 266
-- | Get the 'HValue' associated with the given name.
--
-- May cause loading the module that contains the name.
--
-- Throws a 'ProgramError' if loading fails or the name cannot be found.
267 268
getHValue :: HscEnv -> Name -> IO HValue
getHValue hsc_env name = do
269
  initDynLinker (hsc_dflags hsc_env)
270 271 272 273 274 275 276 277
  pls <- modifyMVar v_PersistentLinkerState $ \pls -> do
           if (isExternalName name) then do
             (pls', ok) <- linkDependencies hsc_env pls noSrcSpan [nameModule name]
             if (failed ok) then ghcError (ProgramError "")
                            else return (pls', pls')
            else
             return (pls, pls)
  lookupName (closure_env pls) name
278
        
279 280 281 282
linkDependencies :: HscEnv -> PersistentLinkerState
                 -> SrcSpan -> [Module]
                 -> IO (PersistentLinkerState, SuccessFlag)
linkDependencies hsc_env pls span needed_mods = do
283
--   initDynLinker (hsc_dflags hsc_env)
284 285 286 287 288 289 290 291 292
   let hpt = hsc_HPT hsc_env
       dflags = hsc_dflags hsc_env
	-- The interpreter and dynamic linker can only handle object code built
	-- the "normal" way, i.e. no non-std ways like profiling or ticky-ticky.
	-- So here we check the build tag: if we're building a non-standard way
	-- then we need to find & link object files built the "normal" way.
   maybe_normal_osuf <- checkNonStdWay dflags span

	-- Find what packages and linkables are required
293
   (lnks, pkgs) <- getLinkDeps hsc_env hpt pls
294 295 296
				maybe_normal_osuf span needed_mods

	-- Link the packages and modules required
297 298
   pls1 <- linkPackages' dflags pkgs pls
   linkModules dflags pls1 lnks
299

300

301 302
-- | Temporarily extend the linker state.

303 304
withExtendedLinkEnv :: (MonadIO m, ExceptionMonad m) =>
                       [(Name,HValue)] -> m a -> m a
305
withExtendedLinkEnv new_env action
306
    = gbracket (liftIO $ extendLinkEnv new_env)
307 308
               (\_ -> reset_old_env)
               (\_ -> action)
309
    where
310 311 312 313 314
        -- Remember that the linker state might be side-effected
        -- during the execution of the IO action, and we don't want to
        -- lose those changes (we might have linked a new module or
        -- package), so the reset action only removes the names we
        -- added earlier.
315
          reset_old_env = liftIO $ do
316
            modifyMVar_ v_PersistentLinkerState $ \pls ->
317 318
                let cur = closure_env pls
                    new = delListFromNameEnv cur (map fst new_env)
319
                in return pls{ closure_env = new }
320

321 322 323 324 325 326
-- filterNameMap removes from the environment all entries except 
-- 	those for a given set of modules;
-- Note that this removes all *local* (i.e. non-isExternal) names too 
--	(these are the temporary bindings from the command line).
-- Used to filter both the ClosureEnv and ItblEnv

327
filterNameMap :: [Module] -> NameEnv (Name, a) -> NameEnv (Name, a)
328 329 330 331
filterNameMap mods env 
   = filterNameEnv keep_elt env
   where
     keep_elt (n,_) = isExternalName n 
332
		      && (nameModule n `elem` mods)
333 334 335 336
\end{code}


\begin{code}
337
-- | Display the persistent linker state.
338 339
showLinkerState :: IO ()
showLinkerState
340
  = do pls <- readMVar v_PersistentLinkerState
341 342 343
       printDump (vcat [text "----- Linker state -----",
			text "Pkgs:" <+> ppr (pkgs_loaded pls),
			text "Objs:" <+> ppr (objs_loaded pls),
344
			text "BCOs:" <+> ppr (bcos_loaded pls)])
345 346 347 348
\end{code}
			
	

349 350 351 352 353 354 355 356

%************************************************************************
%*									*
\subsection{Initialisation}
%*									*
%************************************************************************

\begin{code}
357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374
-- | Initialise the dynamic linker.  This entails
--
--  a) Calling the C initialisation procedure,
--
--  b) Loading any packages specified on the command line,
--
--  c) Loading any packages specified on the command line, now held in the
--     @-l@ options in @v_Opt_l@,
--
--  d) Loading any @.o\/.dll@ files specified on the command line, now held
--     in @v_Ld_inputs@,
--
--  e) Loading any MacOS frameworks.
--
-- NOTE: This function is idempotent; if called more than once, it does
-- nothing.  This is useful in Template Haskell, where we call it before
-- trying to link.
--
375
initDynLinker :: DynFlags -> IO ()
376 377 378 379 380 381 382 383 384 385 386
initDynLinker dflags =
  modifyMVar_ v_PersistentLinkerState $ \pls0 -> do
    done <- readIORef v_InitLinkerDone
    if done then return pls0
            else do writeIORef v_InitLinkerDone True
                    reallyInitDynLinker dflags

reallyInitDynLinker :: DynFlags -> IO PersistentLinkerState
reallyInitDynLinker dflags =
    do  {  -- Initialise the linker state
	  let pls0 = emptyPLS dflags
387 388 389 390 391

	 	-- (a) initialise the C dynamic linker
	; initObjLinker 

		-- (b) Load packages from the command-line
392
	; pls <- linkPackages' dflags (preloadPackages (pkgState dflags)) pls0
393 394

	   	-- (c) Link libraries from the command-line
395 396
	; let optl = getOpts dflags opt_l
	; let minus_ls = [ lib | '-':'l':lib <- optl ]
397 398

	   	-- (d) Link .o files from the command-line
399
	; let lib_paths = libraryPaths dflags
400 401
	; cmdline_ld_inputs <- readIORef v_Ld_inputs

402
	; classified_ld_inputs <- mapM classifyLdInput cmdline_ld_inputs
403 404

	   	-- (e) Link any MacOS frameworks
Ian Lynagh's avatar
Ian Lynagh committed
405 406 407 408 409 410
	; let framework_paths
               | isDarwinTarget = frameworkPaths dflags
               | otherwise      = []
	; let frameworks
               | isDarwinTarget = cmdlineFrameworks dflags
               | otherwise      = []
411
		-- Finally do (c),(d),(e)	
412
        ; let cmdline_lib_specs = [ l | Just l <- classified_ld_inputs ]
413 414
			       ++ map DLL       minus_ls 
			       ++ map Framework frameworks
415
	; if null cmdline_lib_specs then return pls
416 417 418 419 420 421 422
				    else do

 	{ mapM_ (preloadLib dflags lib_paths framework_paths) cmdline_lib_specs
	; maybePutStr dflags "final link ... "
	; ok <- resolveObjs

	; if succeeded ok then maybePutStrLn dflags "done"
423
	  else ghcError (ProgramError "linking extra libraries/objects failed")
424 425

        ; return pls
426 427
	}}

428 429 430 431 432 433 434
classifyLdInput :: FilePath -> IO (Maybe LibrarySpec)
classifyLdInput f
  | isObjectFilename f = return (Just (Object f))
  | isDynLibFilename f = return (Just (DLLPath f))
  | otherwise 	       = do
	hPutStrLn stderr ("Warning: ignoring unrecognised input `" ++ f ++ "'")
	return Nothing
435

436 437 438 439 440 441 442
preloadLib :: DynFlags -> [String] -> [String] -> LibrarySpec -> IO ()
preloadLib dflags lib_paths framework_paths lib_spec
  = do maybePutStr dflags ("Loading object " ++ showLS lib_spec ++ " ... ")
       case lib_spec of
          Object static_ish
             -> do b <- preload_static lib_paths static_ish
                   maybePutStrLn dflags (if b  then "done"
443 444 445 446 447 448 449
                                                else "not found")

          Archive static_ish
             -> do b <- preload_static_archive lib_paths static_ish
                   maybePutStrLn dflags (if b  then "done"
                                                else "not found")

450 451 452 453 454
          DLL dll_unadorned
             -> do maybe_errstr <- loadDynamic lib_paths dll_unadorned
                   case maybe_errstr of
                      Nothing -> maybePutStrLn dflags "done"
                      Just mm -> preloadFailed mm lib_paths lib_spec
455 456 457 458 459 460 461

	  DLLPath dll_path
	     -> do maybe_errstr <- loadDLL dll_path
                   case maybe_errstr of
                      Nothing -> maybePutStrLn dflags "done"
                      Just mm -> preloadFailed mm lib_paths lib_spec

462
	  Framework framework
Ian Lynagh's avatar
Ian Lynagh committed
463
           | isDarwinTarget
464 465 466 467
             -> do maybe_errstr <- loadFramework framework_paths framework
                   case maybe_errstr of
                      Nothing -> maybePutStrLn dflags "done"
                      Just mm -> preloadFailed mm framework_paths lib_spec
Ian Lynagh's avatar
Ian Lynagh committed
468 469
           | otherwise -> panic "preloadLib Framework"

470 471 472
  where
    preloadFailed :: String -> [String] -> LibrarySpec -> IO ()
    preloadFailed sys_errmsg paths spec
473 474 475 476 477 478 479 480
       = do maybePutStr dflags "failed.\n"
            ghcError $
	      CmdLineError (
                    "user specified .o/.so/.DLL could not be loaded ("
                    ++ sys_errmsg ++ ")\nWhilst trying to load:  "
                    ++ showLS spec ++ "\nAdditional directories searched:"
                    ++ (if null paths then " (none)" else
                        (concat (intersperse "\n" (map ("   "++) paths)))))
481 482
    
    -- Not interested in the paths in the static case.
Ian Lynagh's avatar
Ian Lynagh committed
483
    preload_static _paths name
484 485 486
       = do b <- doesFileExist name
            if not b then return False
                     else loadObj name >> return True
487 488 489 490
    preload_static_archive _paths name
       = do b <- doesFileExist name
            if not b then return False
                     else loadArchive name >> return True
491 492 493
\end{code}


494 495 496 497 498 499 500
%************************************************************************
%*									*
		Link a byte-code expression
%*									*
%************************************************************************

\begin{code}
501
-- | Link a single expression, /including/ first linking packages and
502 503
-- modules that this expression depends on.
--
504 505
-- Raises an IO exception ('ProgramError') if it can't find a compiled
-- version of the dependents to link.
506
--
507
linkExpr :: HscEnv -> SrcSpan -> UnlinkedBCO -> IO HValue
508
linkExpr hsc_env span root_ul_bco
509
  = do {  
510
	-- Initialise the linker (if it's not been done already)
511 512
     let dflags = hsc_dflags hsc_env
   ; initDynLinker dflags
513

514 515 516
        -- Take lock for the actual work.
   ; modifyMVar v_PersistentLinkerState $ \pls0 -> do {

517
	-- Link the packages and modules required
518
   ; (pls, ok) <- linkDependencies hsc_env pls0 span needed_mods
519
   ; if failed ok then
520
	ghcError (ProgramError "")
521 522 523
     else do {

	-- Link the expression itself
524
     let ie = itbl_env pls
525 526 527
	 ce = closure_env pls

	-- Link the necessary packages and linkables
528
   ; (_, (root_hval:_)) <- linkSomeBCOs False ie ce [root_ul_bco]
529 530
   ; return (pls, root_hval)
   }}}
531
   where
532 533
     free_names = nameSetToList (bcoFreeNames root_ul_bco)

534
     needed_mods :: [Module]
535 536 537 538 539 540 541 542
     needed_mods = [ nameModule n | n <- free_names, 
				    isExternalName n,	 	-- Names from other modules
				    not (isWiredInName n)	-- Exclude wired-in names
		   ]						-- (see note below)
	-- Exclude wired-in names because we may not have read
	-- their interface files, so getLinkDeps will fail
	-- All wired-in names are in the base package, which we link
	-- by default, so we can safely ignore them here.
543
 
Ian Lynagh's avatar
Ian Lynagh committed
544
dieWith :: SrcSpan -> Message -> IO a
545
dieWith span msg = ghcError (ProgramError (showSDoc (mkLocMessage span msg)))
546 547 548 549


checkNonStdWay :: DynFlags -> SrcSpan -> IO (Maybe String)
checkNonStdWay dflags srcspan = do
550
  let tag = buildTag dflags
551 552 553 554 555 556 557 558 559 560
  if null tag {-  || tag == "dyn" -} then return Nothing else do
    -- see #3604: object files compiled for way "dyn" need to link to the
    -- dynamic packages, so we can't load them into a statically-linked GHCi.
    -- we have to treat "dyn" in the same way as "prof".
    --
    -- In the future when GHCi is dynamically linked we should be able to relax
    -- this, but they we may have to make it possible to load either ordinary
    -- .o files or -dynamic .o files into GHCi (currently that's not possible
    -- because the dynamic objects contain refs to e.g. __stginit_base_Prelude_dyn
    -- whereas we have __stginit_base_Prelude_.
561 562 563 564 565
  let default_osuf = phaseInputExt StopLn
  if objectSuf dflags == default_osuf
	then failNonStd srcspan
	else return (Just default_osuf)

Ian Lynagh's avatar
Ian Lynagh committed
566
failNonStd :: SrcSpan -> IO (Maybe String)
567
failNonStd srcspan = dieWith srcspan $
Ian Lynagh's avatar
Ian Lynagh committed
568 569 570
  ptext (sLit "Dynamic linking required, but this is a non-standard build (eg. prof).") $$
  ptext (sLit "You need to build the program twice: once the normal way, and then") $$
  ptext (sLit "in the desired way using -osuf to set the object file suffix.")
571
  
572

573 574
getLinkDeps :: HscEnv -> HomePackageTable
            -> PersistentLinkerState
575 576
	    -> Maybe String			-- the "normal" object suffix
	    -> SrcSpan				-- for error messages
577
	    -> [Module]				-- If you need these
578
	    -> IO ([Linkable], [PackageId])	-- ... then link these first
579
-- Fails with an IO exception if it can't find enough files
580

581
getLinkDeps hsc_env hpt pls maybe_normal_osuf span mods
582
-- Find all the packages and linkables that a set of modules depends on
583
 = do {
584
	-- 1.  Find the dependent home-pkg-modules/packages from each iface
585
        (mods_s, pkgs_s) <- follow_deps mods emptyUniqSet emptyUniqSet;
586

587
	let {
588 589
	-- 2.  Exclude ones already linked
	--	Main reason: avoid findModule calls in get_linkable
Simon Marlow's avatar
Simon Marlow committed
590 591
	    mods_needed = mods_s `minusList` linked_mods     ;
	    pkgs_needed = pkgs_s `minusList` pkgs_loaded pls ;
592

Simon Marlow's avatar
Simon Marlow committed
593 594
	    linked_mods = map (moduleName.linkableModule) 
                                (objs_loaded pls ++ bcos_loaded pls)
595
	} ;
596
	
Simon Marlow's avatar
Simon Marlow committed
597
--        putStrLn (showSDoc (ppr mods_s)) ;
598
	-- 3.  For each dependent module, find its linkable
599 600
	--     This will either be in the HPT or (in the case of one-shot
	--     compilation) we may need to use maybe_getFileLinkable
601
	lnks_needed <- mapM (get_linkable maybe_normal_osuf) mods_needed ;
602

603
	return (lnks_needed, pkgs_needed) }
604
  where
Simon Marlow's avatar
Simon Marlow committed
605 606 607
    dflags = hsc_dflags hsc_env
    this_pkg = thisPackage dflags

Simon Marlow's avatar
Simon Marlow committed
608 609 610 611 612 613 614 615
        -- The ModIface contains the transitive closure of the module dependencies
        -- within the current package, *except* for boot modules: if we encounter
        -- a boot module, we have to find its real interface and discover the
        -- dependencies of that.  Hence we need to traverse the dependency
        -- tree recursively.  See bug #936, testcase ghci/prog007.
    follow_deps :: [Module]             -- modules to follow
                -> UniqSet ModuleName         -- accum. module dependencies
                -> UniqSet PackageId          -- accum. package dependencies
616
                -> IO ([ModuleName], [PackageId]) -- result
Simon Marlow's avatar
Simon Marlow committed
617
    follow_deps []     acc_mods acc_pkgs
618
        = return (uniqSetToList acc_mods, uniqSetToList acc_pkgs)
Simon Marlow's avatar
Simon Marlow committed
619
    follow_deps (mod:mods) acc_mods acc_pkgs
620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639
        = do
          mb_iface <- initIfaceCheck hsc_env $
                        loadInterface msg mod (ImportByUser False)
          iface <- case mb_iface of
        	    Maybes.Failed err      -> ghcError (ProgramError (showSDoc err))
	            Maybes.Succeeded iface -> return iface

          when (mi_boot iface) $ link_boot_mod_error mod

          let
            pkg = modulePackageId mod
            deps  = mi_deps iface

            pkg_deps = dep_pkgs deps
            (boot_deps, mod_deps) = partitionWith is_boot (dep_mods deps)
                    where is_boot (m,True)  = Left m
                          is_boot (m,False) = Right m

            boot_deps' = filter (not . (`elementOfUniqSet` acc_mods)) boot_deps
            acc_mods'  = addListToUniqSet acc_mods (moduleName mod : mod_deps)
640
            acc_pkgs'  = addListToUniqSet acc_pkgs $ map fst pkg_deps
641 642 643 644 645 646 647 648
          --
          if pkg /= this_pkg
             then follow_deps mods acc_mods (addOneToUniqSet acc_pkgs' pkg)
             else follow_deps (map (mkModule this_pkg) boot_deps' ++ mods)
                              acc_mods' acc_pkgs'
        where
            msg = text "need to link module" <+> ppr mod <+>
                  text "due to use of Template Haskell"
Simon Marlow's avatar
Simon Marlow committed
649 650 651


    link_boot_mod_error mod = 
652
        ghcError (ProgramError (showSDoc (
Simon Marlow's avatar
Simon Marlow committed
653 654
            text "module" <+> ppr mod <+> 
            text "cannot be linked; it is only available as a boot module")))
655

656
    no_obj :: Outputable a => a -> IO b
657
    no_obj mod = dieWith span $
Ian Lynagh's avatar
Ian Lynagh committed
658
		     ptext (sLit "cannot find object file for module ") <> 
659 660 661
			quotes (ppr mod) $$
		     while_linking_expr
		
Ian Lynagh's avatar
Ian Lynagh committed
662
    while_linking_expr = ptext (sLit "while linking an interpreted expression")
663

664 665
	-- This one is a build-system bug

666
    get_linkable maybe_normal_osuf mod_name	-- A home-package module
Simon Marlow's avatar
Simon Marlow committed
667
	| Just mod_info <- lookupUFM hpt mod_name 
668
	= adjust_linkable (Maybes.expectJust "getLinkDeps" (hm_linkable mod_info))
669
	| otherwise	
Simon Marlow's avatar
Simon Marlow committed
670
	= do	-- It's not in the HPT because we are in one shot mode, 
671
		-- so use the Finder to get a ModLocation...
Simon Marlow's avatar
Simon Marlow committed
672 673 674
	     mb_stuff <- findHomeModule hsc_env mod_name
	     case mb_stuff of
		  Found loc mod -> found loc mod
675
		  _ -> no_obj mod_name
676 677
        where
            found loc mod = do {
678
		-- ...and then find the linkable for it
Simon Marlow's avatar
Simon Marlow committed
679
	       mb_lnk <- findObjectLinkableMaybe mod loc ;
680
	       case mb_lnk of {
681
		  Nothing  -> no_obj mod ;
682
		  Just lnk -> adjust_linkable lnk
683
	      }}
684 685 686 687 688 689 690 691 692

	    adjust_linkable lnk
		| Just osuf <- maybe_normal_osuf = do
			new_uls <- mapM (adjust_ul osuf) (linkableUnlinked lnk)
        		return lnk{ linkableUnlinked=new_uls }
		| otherwise =
			return lnk

	    adjust_ul osuf (DotO file) = do
Ian Lynagh's avatar
Ian Lynagh committed
693
		let new_file = replaceExtension file osuf
694 695 696
		ok <- doesFileExist new_file
		if (not ok)
		   then dieWith span $
Ian Lynagh's avatar
Ian Lynagh committed
697
			  ptext (sLit "cannot find normal object file ")
698 699
				<> quotes (text new_file) $$ while_linking_expr
		   else return (DotO new_file)
Ian Lynagh's avatar
Ian Lynagh committed
700
	    adjust_ul _ _ = panic "adjust_ul"
701
\end{code}
702

703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734
%************************************************************************
%*									*
              Loading a single module
%*									*
%************************************************************************
\begin{code}

-- | Link a single module
linkModule :: HscEnv -> Module -> IO ()
linkModule hsc_env mod = do
  initDynLinker (hsc_dflags hsc_env)
  modifyMVar v_PersistentLinkerState $ \pls -> do
    (pls', ok) <- linkDependencies hsc_env pls noSrcSpan [mod]
    if (failed ok) then ghcError (ProgramError "could not link module")
      else return (pls',())

-- | Coerce a value as usual, but:
--
-- 1) Evaluate it immediately to get a segfault early if the coercion was wrong
--
-- 2) Wrap it in some debug messages at verbosity 3 or higher so we can see what happened
--    if it /does/ segfault
lessUnsafeCoerce :: DynFlags -> String -> a -> IO b
lessUnsafeCoerce dflags context what = do
    debugTraceMsg dflags 3 $ (ptext $ sLit "Coercing a value in") <+> (text context) <> (ptext $ sLit "...")
    output <- evaluate (unsafeCoerce# what)
    debugTraceMsg dflags 3 $ ptext $ sLit "Successfully evaluated coercion"
    return output



\end{code}
735 736 737 738 739 740 741 742 743 744

%************************************************************************
%*									*
		Link some linkables
	The linkables may consist of a mixture of 
	byte-code modules and object modules
%*									*
%************************************************************************

\begin{code}
745 746 747
linkModules :: DynFlags -> PersistentLinkerState -> [Linkable]
            -> IO (PersistentLinkerState, SuccessFlag)
linkModules dflags pls linkables
748
  = mask_ $ do  -- don't want to be interrupted by ^C in here
749 750 751 752 753
	
	let (objs, bcos) = partition isObjectLinkable 
                              (concatMap partitionLinkable linkables)

		-- Load objects first; they can't depend on BCOs
754
	(pls1, ok_flag) <- dynLinkObjs dflags pls objs
755 756

	if failed ok_flag then 
757
		return (pls1, Failed)
758
	  else do
759 760
		pls2 <- dynLinkBCOs pls1 bcos
		return (pls2, Succeeded)
761 762 763 764 765 766 767 768 769 770
		

-- HACK to support f-x-dynamic in the interpreter; no other purpose
partitionLinkable :: Linkable -> [Linkable]
partitionLinkable li
   = let li_uls = linkableUnlinked li
         li_uls_obj = filter isObject li_uls
         li_uls_bco = filter isInterpretable li_uls
     in 
         case (li_uls_obj, li_uls_bco) of
Ian Lynagh's avatar
Ian Lynagh committed
771 772 773
            (_:_, _:_) -> [li {linkableUnlinked=li_uls_obj},
                           li {linkableUnlinked=li_uls_bco}]
            _ -> [li]
774

775
findModuleLinkable_maybe :: [Linkable] -> Module -> Maybe Linkable
776 777 778 779
findModuleLinkable_maybe lis mod
   = case [LM time nm us | LM time nm us <- lis, nm == mod] of
        []   -> Nothing
        [li] -> Just li
Ian Lynagh's avatar
Ian Lynagh committed
780
        _    -> pprPanic "findModuleLinkable" (ppr mod)
781 782 783

linkableInSet :: Linkable -> [Linkable] -> Bool
linkableInSet l objs_loaded =
784
  case findModuleLinkable_maybe objs_loaded (linkableModule l) of
785 786 787 788 789 790 791 792 793 794 795 796
	Nothing -> False
	Just m  -> linkableTime l == linkableTime m
\end{code}


%************************************************************************
%*									*
\subsection{The object-code linker}
%*									*
%************************************************************************

\begin{code}
797 798 799
dynLinkObjs :: DynFlags -> PersistentLinkerState -> [Linkable]
            -> IO (PersistentLinkerState, SuccessFlag)
dynLinkObjs dflags pls objs = do
800 801 802 803 804
	-- Load the object files and link them
	let (objs_loaded', new_objs) = rmDupLinkables (objs_loaded pls) objs
	    pls1 		     = pls { objs_loaded = objs_loaded' }
	    unlinkeds 		     = concatMap linkableUnlinked new_objs

805
	mapM_ loadObj (map nameOfObject unlinkeds)
806 807 808 809 810 811 812

	-- Link the all together
	ok <- resolveObjs

	-- If resolving failed, unload all our 
	-- object modules and carry on
	if succeeded ok then do
813
		return (pls1, Succeeded)
814 815
	  else do
		pls2 <- unload_wkr dflags [] pls1
816
                return (pls2, Failed)
817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838


rmDupLinkables :: [Linkable] 	-- Already loaded
	       -> [Linkable]	-- New linkables
	       -> ([Linkable],	-- New loaded set (including new ones)
		   [Linkable])	-- New linkables (excluding dups)
rmDupLinkables already ls
  = go already [] ls
  where
    go already extras [] = (already, extras)
    go already extras (l:ls)
	| linkableInSet l already = go already     extras     ls
	| otherwise		  = go (l:already) (l:extras) ls
\end{code}

%************************************************************************
%*									*
\subsection{The byte-code linker}
%*									*
%************************************************************************

\begin{code}
839 840
dynLinkBCOs :: PersistentLinkerState -> [Linkable] -> IO PersistentLinkerState
dynLinkBCOs pls bcos = do
841 842 843 844 845 846 847 848 849 850 851 852 853 854 855

	let (bcos_loaded', new_bcos) = rmDupLinkables (bcos_loaded pls) bcos
	    pls1 		     = pls { bcos_loaded = bcos_loaded' }
	    unlinkeds :: [Unlinked]
	    unlinkeds 		     = concatMap linkableUnlinked new_bcos

	    cbcs :: [CompiledByteCode]
	    cbcs      = map byteCodeOfObject unlinkeds
		      
	    	      
	    ul_bcos    = [b | ByteCode bs _  <- cbcs, b <- bs]
	    ies	       = [ie | ByteCode _ ie <- cbcs]
	    gce	      = closure_env pls
            final_ie  = foldr plusNameEnv (itbl_env pls) ies

Ian Lynagh's avatar
Ian Lynagh committed
856 857
        (final_gce, _linked_bcos) <- linkSomeBCOs True final_ie gce ul_bcos
		-- XXX What happens to these linked_bcos?
858 859 860 861

	let pls2 = pls1 { closure_env = final_gce,
			  itbl_env    = final_ie }

862
	return pls2
863 864 865 866 867 868 869

-- Link a bunch of BCOs and return them + updated closure env.
linkSomeBCOs :: Bool 	-- False <=> add _all_ BCOs to returned closure env
                        -- True  <=> add only toplevel BCOs to closure env
             -> ItblEnv 
             -> ClosureEnv 
             -> [UnlinkedBCO]
870
             -> IO (ClosureEnv, [HValue])
871 872 873 874
			-- The returned HValues are associated 1-1 with
			-- the incoming unlinked BCOs.  Each gives the
			-- value of the corresponding unlinked BCO
					
875
linkSomeBCOs toplevs_only ie ce_in ul_bcos
876
   = do let nms = map unlinkedBCOName ul_bcos
877 878 879 880 881 882 883 884 885 886 887
        hvals <- fixIO 
                    ( \ hvs -> let ce_out = extendClosureEnv ce_in (zipLazy nms hvs)
                               in  mapM (linkBCO ie ce_out) ul_bcos )
        let ce_all_additions = zip nms hvals
            ce_top_additions = filter (isExternalName.fst) ce_all_additions
            ce_additions     = if toplevs_only then ce_top_additions 
                                               else ce_all_additions
            ce_out = -- make sure we're not inserting duplicate names into the 
		     -- closure environment, which leads to trouble.
		     ASSERT (all (not . (`elemNameEnv` ce_in)) (map fst ce_additions))
		     extendClosureEnv ce_in ce_additions
888
        return (ce_out, hvals)
889

890 891 892 893 894 895 896 897 898 899
\end{code}


%************************************************************************
%*									*
		Unload some object modules
%*									*
%************************************************************************

\begin{code}
sof's avatar
sof committed
900
-- ---------------------------------------------------------------------------
901
-- | Unloading old objects ready for a new compilation sweep.
902 903
--
-- The compilation manager provides us with a list of linkables that it
904
-- considers \"stable\", i.e. won't be recompiled this time around.  For
905 906
-- each of the modules current linked in memory,
--
907 908
--   * if the linkable is stable (and it's the same one -- the user may have
--     recompiled the module on the side), we keep it,
909
--
910
--   * otherwise, we unload it.
911
--
912 913 914 915 916
--   * we also implicitly unload all temporary bindings at this point.
--
unload :: DynFlags
       -> [Linkable] -- ^ The linkables to *keep*.
       -> IO ()
917
unload dflags linkables
918
  = mask_ $ do -- mask, so we're safe from Ctrl-C in here
919 920 921
  
	-- Initialise the linker (if it's not been done already)
	initDynLinker dflags
sof's avatar
sof committed
922

923 924 925 926
	new_pls
            <- modifyMVar v_PersistentLinkerState $ \pls -> do
	         pls1 <- unload_wkr dflags linkables pls
                 return (pls1, pls1)
927

928 929 930
	debugTraceMsg dflags 3 (text "unload: retaining objs" <+> ppr (objs_loaded new_pls))
	debugTraceMsg dflags 3 (text "unload: retaining bcos" <+> ppr (bcos_loaded new_pls))
	return ()
931

932 933 934 935 936 937
unload_wkr :: DynFlags
           -> [Linkable]		-- stable linkables
	   -> PersistentLinkerState
           -> IO PersistentLinkerState
-- Does the core unload business
-- (the wrapper blocks exceptions and deals with the PLS get and put)
938

Ian Lynagh's avatar
Ian Lynagh committed
939
unload_wkr _ linkables pls
940 941 942 943 944
  = do	let (objs_to_keep, bcos_to_keep) = partition isObjectLinkable linkables

	objs_loaded' <- filterM (maybeUnload objs_to_keep) (objs_loaded pls)
        bcos_loaded' <- filterM (maybeUnload bcos_to_keep) (bcos_loaded pls)

945
       	let bcos_retained = map linkableModule bcos_loaded'
946 947 948 949 950 951 952 953 954 955 956
	    itbl_env'     = filterNameMap bcos_retained (itbl_env pls)
            closure_env'  = filterNameMap bcos_retained (closure_env pls)
  	    new_pls = pls { itbl_env = itbl_env',
			    closure_env = closure_env',
			    bcos_loaded = bcos_loaded',
			    objs_loaded = objs_loaded' }

	return new_pls
  where
    maybeUnload :: [Linkable] -> Linkable -> IO Bool
    maybeUnload keep_linkables lnk
957
      | linkableInSet lnk keep_linkables = return True
958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983
      | otherwise		    
      = do mapM_ unloadObj [f | DotO f <- linkableUnlinked lnk]
		-- The components of a BCO linkable may contain
		-- dot-o files.  Which is very confusing.
		--
		-- But the BCO parts can be unlinked just by 
		-- letting go of them (plus of course depopulating
		-- the symbol table which is done in the main body)
	   return False
\end{code}


%************************************************************************
%*									*
		Loading packages
%*									*
%************************************************************************


\begin{code}
data LibrarySpec 
   = Object FilePath 	-- Full path name of a .o file, including trailing .o
			-- For dynamic objects only, try to find the object 
			-- file in all the directories specified in 
			-- v_Library_paths before giving up.

984 985
   | Archive FilePath 	-- Full path name of a .a file, including trailing .a

986 987 988 989 990
   | DLL String		-- "Unadorned" name of a .DLL/.so
			--  e.g.    On unix     "qt"  denotes "libqt.so"
			--          On WinDoze  "burble"  denotes "burble.DLL"
			--  loadDLL is platform-specific and adds the lib/.so/.DLL
			--  suffixes platform-dependently
991

992 993 994
   | DLLPath FilePath   -- Absolute or relative pathname to a dynamic library
			-- (ends with .dll or .so).

995
   | Framework String	-- Only used for darwin, but does no harm
996 997 998 999 1000 1001 1002 1003 1004 1005

-- If this package is already part of the GHCi binary, we'll already
-- have the right DLLs for this package loaded, so don't try to
-- load them again.
-- 
-- But on Win32 we must load them 'again'; doing so is a harmless no-op
-- as far as the loader is concerned, but it does initialise the list
-- of DLL handles that rts/Linker.c maintains, and that in turn is 
-- used by lookupSymbol.  So we must call addDLL for each library 
-- just to get the DLL handle into the list.
Ian Lynagh's avatar
Ian Lynagh committed
1006
partOfGHCi :: [PackageName]
1007
partOfGHCi
Ian Lynagh's avatar
Ian Lynagh committed
1008
 | isWindowsTarget || isDarwinTarget = []
Ian Lynagh's avatar
Ian Lynagh committed
1009
 | otherwise = map PackageName
1010
                   ["base", "template-haskell", "editline"]
1011

Ian Lynagh's avatar
Ian Lynagh committed
1012
showLS :: LibrarySpec -> String
1013
showLS (Object nm)    = "(static) " ++ nm
1014
showLS (Archive nm)   = "(static archive) " ++ nm
1015
showLS (DLL nm)       = "(dynamic) " ++ nm
1016
showLS (DLLPath nm)   = "(dynamic) " ++ nm
1017 1018
showLS (Framework nm) = "(framework) " ++ nm

1019 1020 1021 1022
-- | Link exactly the specified packages, and their dependents (unless of
-- course they are already linked).  The dependents are linked
-- automatically, and it doesn't matter what order you specify the input
-- packages.
1023
--
1024
linkPackages :: DynFlags -> [PackageId] -> IO ()
1025
-- NOTE: in fact, since each module tracks all the packages it depends on,
1026 1027
--       we don't really need to use the package-config dependencies.
--
1028 1029 1030 1031
-- However we do need the package-config stuff (to find aux libs etc),
-- and following them lets us load libraries in the right order, which 
-- perhaps makes the error message a bit more localised if we get a link
-- failure.  So the dependency walking code is still here.
1032

1033 1034 1035
linkPackages dflags new_pkgs = do
  -- It's probably not safe to try to load packages concurrently, so we take
  -- a lock.
1036
  initDynLinker dflags
1037 1038
  modifyMVar_ v_PersistentLinkerState $ \pls -> do
    linkPackages' dflags new_pkgs pls
1039

1040 1041 1042
linkPackages' :: DynFlags -> [PackageId] -> PersistentLinkerState
             -> IO PersistentLinkerState
linkPackages' dflags new_pks pls = do
1043
    pkgs' <- link (pkgs_loaded pls) new_pks
1044 1045
    return $! pls { pkgs_loaded = pkgs' }
  where
1046 1047 1048 1049 1050 1051
     pkg_map = pkgIdMap (pkgState dflags)
     ipid_map = installedPackageIdMap (pkgState dflags)

     link :: [PackageId] -> [PackageId] -> IO [PackageId]
     link pkgs new_pkgs =
         foldM link_one pkgs new_pkgs
1052

1053
     link_one pkgs new_pkg
1054 1055 1056
	| new_pkg `elem` pkgs	-- Already linked
	= return pkgs

1057
	| Just pkg_cfg <- lookupPackage pkg_map new_pkg
1058
	= do { 	-- Link dependents first
1059
               pkgs' <- link pkgs [ Maybes.expectJust "link_one" $
1060
                                    Map.lookup ipid ipid_map
1061
                                  | ipid <- depends pkg_cfg ]
1062 1063 1064 1065 1066
		-- Now link the package itself
	     ; linkPackage dflags pkg_cfg
	     ; return (new_pkg : pkgs') }

	| otherwise
1067
	= ghcError (CmdLineError ("unknown package: " ++ packageIdString new_pkg))
1068 1069 1070 1071 1072


linkPackage :: DynFlags -> PackageConfig -> IO ()
linkPackage dflags pkg
   = do 
1073
        let dirs      =  Packages.libraryDirs pkg
1074 1075

        let libs      =  Packages.hsLibraries pkg
1076 1077 1078 1079 1080 1081
            -- The FFI GHCi import lib isn't needed as
            -- compiler/ghci/Linker.lhs + 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.
            libs'     =  filter ("HSffi" /=) libs
1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092
        -- Because of slight differences between the GHC dynamic linker and
        -- the native system linker some packages have to link with a
        -- different list of libraries when using GHCi. Examples include: libs
        -- that are actually gnu ld scripts, and the possability that the .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.
                      ++ (if null (Packages.extraGHCiLibraries pkg)
                            then Packages.extraLibraries pkg
                            else Packages.extraGHCiLibraries pkg)
                      ++ [ lib | '-':'l':lib <- Packages.ldOptions pkg ]
1093
        classifieds   <- mapM (locateOneObj dirs) libs'
1094 1095 1096 1097

        -- Complication: all the .so's must be loaded before any of the .o's.  
	let dlls = [ dll | DLL dll    <- classifieds ]
	    objs = [ obj | Object obj <- classifieds ]
1098
	    archs = [ arch | Archive arch <- classifieds ]
1099

1100
	maybePutStr dflags ("Loading package " ++ display (sourcePackageId pkg) ++ " ... ")
1101 1102

	-- See comments with partOfGHCi
Ian Lynagh's avatar
Ian Lynagh committed
1103
	when (packageName pkg `notElem` partOfGHCi) $ do
1104
	    loadFrameworks pkg
1105 1106 1107 1108 1109 1110 1111
            -- When a library A needs symbols from a library B, the order in
            -- extra_libraries/extra_ld_opts is "-lA -lB", because that's the
            -- way ld expects it for static linking. Dynamic linking is a
            -- different story: When A has no dependency information for B,
            -- dlopen-ing A with RTLD_NOW (see addDLL in Linker.c) will fail
            -- when B has not been loaded before. In a nutshell: Reverse the
            -- order of DLLs for dynamic linking.
1112 1113
	    -- This fixes a problem with the HOpenGL package (see "Compiling
	    -- HOpenGL under recent versions of GHC" on the HOpenGL list).
1114
	    mapM_ (load_dyn dirs) (reverse dlls)
1115 1116
	
	-- After loading all the DLLs, we can load the static objects.
1117 1118
	-- Ordering isn't important here, because we do one final link
	-- step to resolve everything.
1119
	mapM_ loadObj objs
1120
	mapM_ loadArchive archs
1121 1122 1123 1124

        maybePutStr dflags "linking ... "
        ok <- resolveObjs
	if succeeded ok then maybePutStrLn dflags "done."
1125
	      else ghcError (InstallationError ("unable to load package `" ++ display (sourcePackageId pkg) ++ "'"))
1126

Ian Lynagh's avatar
Ian Lynagh committed
1127
load_dyn :: [FilePath] -> FilePath -> IO ()