Linker.lhs 44.2 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, 
mnislaih's avatar
mnislaih committed
18
		linkPackages,initDynLinker,
19
                dataConInfoPtrToName
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

-- Standard libraries
59
import Control.Monad
60

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

Ian Lynagh's avatar
Ian Lynagh committed
68
import System.FilePath
69 70
import System.IO
import System.Directory
71

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

74
import Exception
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91
\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}
92
GLOBAL_MVAR(v_PersistentLinkerState, panic "Dynamic linker not initialised", PersistentLinkerState)
93
GLOBAL_VAR(v_InitLinkerDone, False, Bool)	-- Set True when dynamic linker is initialised
94 95 96 97 98 99 100 101 102 103 104 105

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.
106
        itbl_env    :: !ItblEnv,
107 108

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

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

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

120
emptyPLS :: DynFlags -> PersistentLinkerState
Ian Lynagh's avatar
Ian Lynagh committed
121
emptyPLS _ = PersistentLinkerState { 
122 123 124 125
			closure_env = emptyNameEnv,
			itbl_env    = emptyNameEnv,
			pkgs_loaded = init_pkgs,
			bcos_loaded = [],
126 127
			objs_loaded = [] }
                    
128 129 130 131 132
  -- 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
133
  where init_pkgs = [rtsPackageId]
134 135 136
\end{code}

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

142 143
extendLinkEnv :: [(Name,HValue)] -> IO ()
-- Automatically discards shadowed bindings
144 145 146 147
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 }
148

149
deleteFromLinkEnv :: [Name] -> IO ()
150 151 152 153
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 }
154

155 156 157 158
-- | 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:
159
--
160
--   > Package:Module.Name
161 162 163
--
--   We use this string to lookup the interpreter's internal representation of the name
--   using the lookupOrig.    
164
--
165
dataConInfoPtrToName :: Ptr () -> TcM (Either String Name)
166
dataConInfoPtrToName x = do 
twanvl's avatar
twanvl committed
167
   theString <- liftIO $ do
168
      let ptr = castPtr x :: Ptr StgInfoTable
169
      conDescAddress <- getConDescAddress ptr 
170
      peekArray0 0 conDescAddress  
171
   let (pkg, mod, occ) = parse theString 
172 173 174 175 176
       pkgFS = mkFastStringByteList pkg
       modFS = mkFastStringByteList mod
       occFS = mkFastStringByteList occ
       occName = mkOccNameFS OccName.dataName occFS
       modName = mkModule (fsToPackageId pkgFS) (mkModuleNameFS modFS) 
177 178
   return (Left$ showSDoc$ ppr modName <> dot <> ppr occName ) 
    `recoverM` (Right `fmap` lookupOrig modName occName)
179 180 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

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

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

   -- 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.
237
   parse :: [Word8] -> ([Word8], [Word8], [Word8])
238 239 240
   parse input 
      = ASSERT (all (>0) (map length [pkg, mod, occ])) (pkg, mod, occ)
      where
241 242
      dot = fromIntegral (ord '.')
      (pkg, rest1) = break (== fromIntegral (ord ':')) input 
243
      (mod, occ) 
244
         = (concat $ intersperse [dot] $ reverse modWords, occWord)
245 246
         where
         (modWords, occWord) = ASSERT (length rest1 > 0) (parseModOcc [] (tail rest1))
247
      parseModOcc :: [[Word8]] -> [Word8] -> ([[Word8]], [Word8])
248
      parseModOcc acc str
249
         = case break (== dot) str of
250
              (top, []) -> (acc, top)
251
              (top, _:bot) -> parseModOcc (top : acc) bot
252
       
253 254 255 256 257
-- | 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.
258 259
getHValue :: HscEnv -> Name -> IO HValue
getHValue hsc_env name = do
260 261 262 263 264 265 266 267
  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
268
        
269 270 271 272
linkDependencies :: HscEnv -> PersistentLinkerState
                 -> SrcSpan -> [Module]
                 -> IO (PersistentLinkerState, SuccessFlag)
linkDependencies hsc_env pls span needed_mods = do
273 274 275 276 277 278 279 280 281
   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
282
   (lnks, pkgs) <- getLinkDeps hsc_env hpt pls
283 284 285
				maybe_normal_osuf span needed_mods

	-- Link the packages and modules required
286 287
   pls1 <- linkPackages' dflags pkgs pls
   linkModules dflags pls1 lnks
288

289

290 291
-- | Temporarily extend the linker state.

292 293
withExtendedLinkEnv :: (MonadIO m, ExceptionMonad m) =>
                       [(Name,HValue)] -> m a -> m a
294
withExtendedLinkEnv new_env action
295
    = gbracket (liftIO $ extendLinkEnv new_env)
296 297
               (\_ -> reset_old_env)
               (\_ -> action)
298
    where
299 300 301 302 303
        -- 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.
304
          reset_old_env = liftIO $ do
305
            modifyMVar_ v_PersistentLinkerState $ \pls ->
306 307
                let cur = closure_env pls
                    new = delListFromNameEnv cur (map fst new_env)
308
                in return pls{ closure_env = new }
309

310 311 312 313 314 315
-- 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

316
filterNameMap :: [Module] -> NameEnv (Name, a) -> NameEnv (Name, a)
317 318 319 320
filterNameMap mods env 
   = filterNameEnv keep_elt env
   where
     keep_elt (n,_) = isExternalName n 
321
		      && (nameModule n `elem` mods)
322 323 324 325
\end{code}


\begin{code}
326
-- | Display the persistent linker state.
327 328
showLinkerState :: IO ()
showLinkerState
329
  = do pls <- readMVar v_PersistentLinkerState
330 331 332
       printDump (vcat [text "----- Linker state -----",
			text "Pkgs:" <+> ppr (pkgs_loaded pls),
			text "Objs:" <+> ppr (objs_loaded pls),
333
			text "BCOs:" <+> ppr (bcos_loaded pls)])
334 335 336 337
\end{code}
			
	

338 339 340 341 342 343 344 345

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

\begin{code}
346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363
-- | 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.
--
364
initDynLinker :: DynFlags -> IO ()
365 366 367 368 369 370 371 372 373 374 375
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
376 377 378 379 380

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

		-- (b) Load packages from the command-line
381
	; pls <- linkPackages' dflags (preloadPackages (pkgState dflags)) pls0
382 383

	   	-- (c) Link libraries from the command-line
384 385
	; let optl = getOpts dflags opt_l
	; let minus_ls = [ lib | '-':'l':lib <- optl ]
386 387

	   	-- (d) Link .o files from the command-line
388
	; let lib_paths = libraryPaths dflags
389 390
	; cmdline_ld_inputs <- readIORef v_Ld_inputs

391
	; classified_ld_inputs <- mapM classifyLdInput cmdline_ld_inputs
392 393

	   	-- (e) Link any MacOS frameworks
Ian Lynagh's avatar
Ian Lynagh committed
394 395 396 397 398 399
	; let framework_paths
               | isDarwinTarget = frameworkPaths dflags
               | otherwise      = []
	; let frameworks
               | isDarwinTarget = cmdlineFrameworks dflags
               | otherwise      = []
400
		-- Finally do (c),(d),(e)	
401
        ; let cmdline_lib_specs = [ l | Just l <- classified_ld_inputs ]
402 403
			       ++ map DLL       minus_ls 
			       ++ map Framework frameworks
404
	; if null cmdline_lib_specs then return pls
405 406 407 408 409 410 411
				    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"
412
	  else ghcError (ProgramError "linking extra libraries/objects failed")
413 414

        ; return pls
415 416
	}}

417 418 419 420 421 422 423
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
424

425 426 427 428 429 430 431
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"
432 433 434 435 436 437 438
                                                else "not found")

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

439 440 441 442 443
          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
444 445 446 447 448 449 450

	  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

451
	  Framework framework
Ian Lynagh's avatar
Ian Lynagh committed
452
           | isDarwinTarget
453 454 455 456
             -> 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
457 458
           | otherwise -> panic "preloadLib Framework"

459 460 461
  where
    preloadFailed :: String -> [String] -> LibrarySpec -> IO ()
    preloadFailed sys_errmsg paths spec
462 463 464 465 466 467 468 469
       = 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)))))
470 471
    
    -- Not interested in the paths in the static case.
Ian Lynagh's avatar
Ian Lynagh committed
472
    preload_static _paths name
473 474 475
       = do b <- doesFileExist name
            if not b then return False
                     else loadObj name >> return True
476 477 478 479
    preload_static_archive _paths name
       = do b <- doesFileExist name
            if not b then return False
                     else loadArchive name >> return True
480 481 482
\end{code}


483 484 485 486 487 488 489
%************************************************************************
%*									*
		Link a byte-code expression
%*									*
%************************************************************************

\begin{code}
490
-- | Link a single expression, /including/ first linking packages and
491 492
-- modules that this expression depends on.
--
493 494
-- Raises an IO exception ('ProgramError') if it can't find a compiled
-- version of the dependents to link.
495
--
496
linkExpr :: HscEnv -> SrcSpan -> UnlinkedBCO -> IO HValue
497
linkExpr hsc_env span root_ul_bco
498
  = do {  
499
	-- Initialise the linker (if it's not been done already)
500 501
     let dflags = hsc_dflags hsc_env
   ; initDynLinker dflags
502

503 504 505
        -- Take lock for the actual work.
   ; modifyMVar v_PersistentLinkerState $ \pls0 -> do {

506
	-- Link the packages and modules required
507
   ; (pls, ok) <- linkDependencies hsc_env pls0 span needed_mods
508
   ; if failed ok then
509
	ghcError (ProgramError "")
510 511 512
     else do {

	-- Link the expression itself
513
     let ie = itbl_env pls
514 515 516
	 ce = closure_env pls

	-- Link the necessary packages and linkables
517
   ; (_, (root_hval:_)) <- linkSomeBCOs False ie ce [root_ul_bco]
518 519
   ; return (pls, root_hval)
   }}}
520
   where
521 522
     free_names = nameSetToList (bcoFreeNames root_ul_bco)

523
     needed_mods :: [Module]
524 525 526 527 528 529 530 531
     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.
532
 
Ian Lynagh's avatar
Ian Lynagh committed
533
dieWith :: SrcSpan -> Message -> IO a
534
dieWith span msg = ghcError (ProgramError (showSDoc (mkLocMessage span msg)))
535 536 537 538


checkNonStdWay :: DynFlags -> SrcSpan -> IO (Maybe String)
checkNonStdWay dflags srcspan = do
539
  let tag = buildTag dflags
540 541 542 543 544 545 546 547 548 549
  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_.
550 551 552 553 554
  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
555
failNonStd :: SrcSpan -> IO (Maybe String)
556
failNonStd srcspan = dieWith srcspan $
Ian Lynagh's avatar
Ian Lynagh committed
557 558 559
  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.")
560
  
561

562 563
getLinkDeps :: HscEnv -> HomePackageTable
            -> PersistentLinkerState
564 565
	    -> Maybe String			-- the "normal" object suffix
	    -> SrcSpan				-- for error messages
566
	    -> [Module]				-- If you need these
567
	    -> IO ([Linkable], [PackageId])	-- ... then link these first
568
-- Fails with an IO exception if it can't find enough files
569

570
getLinkDeps hsc_env hpt pls maybe_normal_osuf span mods
571
-- Find all the packages and linkables that a set of modules depends on
572
 = do {
573
	-- 1.  Find the dependent home-pkg-modules/packages from each iface
574
        (mods_s, pkgs_s) <- follow_deps mods emptyUniqSet emptyUniqSet;
575

576
	let {
577 578
	-- 2.  Exclude ones already linked
	--	Main reason: avoid findModule calls in get_linkable
Simon Marlow's avatar
Simon Marlow committed
579 580
	    mods_needed = mods_s `minusList` linked_mods     ;
	    pkgs_needed = pkgs_s `minusList` pkgs_loaded pls ;
581

Simon Marlow's avatar
Simon Marlow committed
582 583
	    linked_mods = map (moduleName.linkableModule) 
                                (objs_loaded pls ++ bcos_loaded pls)
584
	} ;
585
	
Simon Marlow's avatar
Simon Marlow committed
586
--        putStrLn (showSDoc (ppr mods_s)) ;
587
	-- 3.  For each dependent module, find its linkable
588 589
	--     This will either be in the HPT or (in the case of one-shot
	--     compilation) we may need to use maybe_getFileLinkable
590
	lnks_needed <- mapM (get_linkable maybe_normal_osuf) mods_needed ;
591

592
	return (lnks_needed, pkgs_needed) }
593
  where
Simon Marlow's avatar
Simon Marlow committed
594 595 596
    dflags = hsc_dflags hsc_env
    this_pkg = thisPackage dflags

Simon Marlow's avatar
Simon Marlow committed
597 598 599 600 601 602 603 604
        -- 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
605
                -> IO ([ModuleName], [PackageId]) -- result
Simon Marlow's avatar
Simon Marlow committed
606
    follow_deps []     acc_mods acc_pkgs
607
        = return (uniqSetToList acc_mods, uniqSetToList acc_pkgs)
Simon Marlow's avatar
Simon Marlow committed
608
    follow_deps (mod:mods) acc_mods acc_pkgs
609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637
        = 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)
            acc_pkgs'  = addListToUniqSet acc_pkgs pkg_deps
          --
          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
638 639 640


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

645
    no_obj :: Outputable a => a -> IO b
646
    no_obj mod = dieWith span $
Ian Lynagh's avatar
Ian Lynagh committed
647
		     ptext (sLit "cannot find object file for module ") <> 
648 649 650
			quotes (ppr mod) $$
		     while_linking_expr
		
Ian Lynagh's avatar
Ian Lynagh committed
651
    while_linking_expr = ptext (sLit "while linking an interpreted expression")
652

653 654
	-- This one is a build-system bug

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

	    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
682
		let new_file = replaceExtension file osuf
683 684 685
		ok <- doesFileExist new_file
		if (not ok)
		   then dieWith span $
Ian Lynagh's avatar
Ian Lynagh committed
686
			  ptext (sLit "cannot find normal object file ")
687 688
				<> quotes (text new_file) $$ while_linking_expr
		   else return (DotO new_file)
Ian Lynagh's avatar
Ian Lynagh committed
689
	    adjust_ul _ _ = panic "adjust_ul"
690
\end{code}
691 692 693 694 695 696 697 698 699 700 701


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

\begin{code}
702 703 704
linkModules :: DynFlags -> PersistentLinkerState -> [Linkable]
            -> IO (PersistentLinkerState, SuccessFlag)
linkModules dflags pls linkables
705
  = mask_ $ do  -- don't want to be interrupted by ^C in here
706 707 708 709 710
	
	let (objs, bcos) = partition isObjectLinkable 
                              (concatMap partitionLinkable linkables)

		-- Load objects first; they can't depend on BCOs
711
	(pls1, ok_flag) <- dynLinkObjs dflags pls objs
712 713

	if failed ok_flag then 
714
		return (pls1, Failed)
715
	  else do
716 717
		pls2 <- dynLinkBCOs pls1 bcos
		return (pls2, Succeeded)
718 719 720 721 722 723 724 725 726 727
		

-- 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
728 729 730
            (_:_, _:_) -> [li {linkableUnlinked=li_uls_obj},
                           li {linkableUnlinked=li_uls_bco}]
            _ -> [li]
731

732
findModuleLinkable_maybe :: [Linkable] -> Module -> Maybe Linkable
733 734 735 736
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
737
        _    -> pprPanic "findModuleLinkable" (ppr mod)
738 739 740

linkableInSet :: Linkable -> [Linkable] -> Bool
linkableInSet l objs_loaded =
741
  case findModuleLinkable_maybe objs_loaded (linkableModule l) of
742 743 744 745 746 747 748 749 750 751 752 753
	Nothing -> False
	Just m  -> linkableTime l == linkableTime m
\end{code}


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

\begin{code}
754 755 756
dynLinkObjs :: DynFlags -> PersistentLinkerState -> [Linkable]
            -> IO (PersistentLinkerState, SuccessFlag)
dynLinkObjs dflags pls objs = do
757 758 759 760 761
	-- 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

762
	mapM_ loadObj (map nameOfObject unlinkeds)
763 764 765 766 767 768 769

	-- Link the all together
	ok <- resolveObjs

	-- If resolving failed, unload all our 
	-- object modules and carry on
	if succeeded ok then do
770
		return (pls1, Succeeded)
771 772
	  else do
		pls2 <- unload_wkr dflags [] pls1
773
                return (pls2, Failed)
774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795


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}
796 797
dynLinkBCOs :: PersistentLinkerState -> [Linkable] -> IO PersistentLinkerState
dynLinkBCOs pls bcos = do
798 799 800 801 802 803 804 805 806 807 808 809 810 811 812

	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
813 814
        (final_gce, _linked_bcos) <- linkSomeBCOs True final_ie gce ul_bcos
		-- XXX What happens to these linked_bcos?
815 816 817 818

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

819
	return pls2
820 821 822 823 824 825 826

-- 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]
827
             -> IO (ClosureEnv, [HValue])
828 829 830 831
			-- The returned HValues are associated 1-1 with
			-- the incoming unlinked BCOs.  Each gives the
			-- value of the corresponding unlinked BCO
					
832
linkSomeBCOs toplevs_only ie ce_in ul_bcos
833
   = do let nms = map unlinkedBCOName ul_bcos
834 835 836 837 838 839 840 841 842 843 844
        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
845
        return (ce_out, hvals)
846

847 848 849 850 851 852 853 854 855 856
\end{code}


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

\begin{code}
sof's avatar
sof committed
857
-- ---------------------------------------------------------------------------
858
-- | Unloading old objects ready for a new compilation sweep.
859 860
--
-- The compilation manager provides us with a list of linkables that it
861
-- considers \"stable\", i.e. won't be recompiled this time around.  For
862 863
-- each of the modules current linked in memory,
--
864 865
--   * if the linkable is stable (and it's the same one -- the user may have
--     recompiled the module on the side), we keep it,
866
--
867
--   * otherwise, we unload it.
868
--
869 870 871 872 873
--   * we also implicitly unload all temporary bindings at this point.
--
unload :: DynFlags
       -> [Linkable] -- ^ The linkables to *keep*.
       -> IO ()
874
unload dflags linkables
875
  = mask_ $ do -- mask, so we're safe from Ctrl-C in here
876 877 878
  
	-- Initialise the linker (if it's not been done already)
	initDynLinker dflags
sof's avatar
sof committed
879

880 881 882 883
	new_pls
            <- modifyMVar v_PersistentLinkerState $ \pls -> do
	         pls1 <- unload_wkr dflags linkables pls
                 return (pls1, pls1)
884

885 886 887
	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 ()
888

889 890 891 892 893 894
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)
895

Ian Lynagh's avatar
Ian Lynagh committed
896
unload_wkr _ linkables pls
897 898 899 900 901
  = 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)

902
       	let bcos_retained = map linkableModule bcos_loaded'
903 904 905 906 907 908 909 910 911 912 913
	    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
914
      | linkableInSet lnk keep_linkables = return True
915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940
      | 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.

941 942
   | Archive FilePath 	-- Full path name of a .a file, including trailing .a

943 944 945 946 947
   | 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
948

949 950 951
   | DLLPath FilePath   -- Absolute or relative pathname to a dynamic library
			-- (ends with .dll or .so).

952
   | Framework String	-- Only used for darwin, but does no harm
953 954 955 956 957 958 959 960 961 962

-- 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
963
partOfGHCi :: [PackageName]
964
partOfGHCi
Ian Lynagh's avatar
Ian Lynagh committed
965
 | isWindowsTarget || isDarwinTarget = []
Ian Lynagh's avatar
Ian Lynagh committed
966
 | otherwise = map PackageName
967
                   ["base", "template-haskell", "editline"]
968

Ian Lynagh's avatar
Ian Lynagh committed
969
showLS :: LibrarySpec -> String
970
showLS (Object nm)    = "(static) " ++ nm
971
showLS (Archive nm)   = "(static archive) " ++ nm
972
showLS (DLL nm)       = "(dynamic) " ++ nm
973
showLS (DLLPath nm)   = "(dynamic) " ++ nm
974 975
showLS (Framework nm) = "(framework) " ++ nm

976 977 978 979
-- | 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.
980
--
981
linkPackages :: DynFlags -> [PackageId] -> IO ()
982
-- NOTE: in fact, since each module tracks all the packages it depends on,
983 984
--       we don't really need to use the package-config dependencies.
--
985 986 987 988
-- 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.
989

990 991 992 993 994
linkPackages dflags new_pkgs = do
  -- It's probably not safe to try to load packages concurrently, so we take
  -- a lock.
  modifyMVar_ v_PersistentLinkerState $ \pls -> do
    linkPackages' dflags new_pkgs pls
995

996 997 998
linkPackages' :: DynFlags -> [PackageId] -> PersistentLinkerState
             -> IO PersistentLinkerState
linkPackages' dflags new_pks pls = do
999
    pkgs' <- link (pkgs_loaded pls) new_pks
1000 1001
    return $! pls { pkgs_loaded = pkgs' }
  where
1002 1003 1004 1005 1006 1007
     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
1008

1009
     link_one pkgs new_pkg
1010 1011 1012
	| new_pkg `elem` pkgs	-- Already linked
	= return pkgs

1013
	| Just pkg_cfg <- lookupPackage pkg_map new_pkg
1014
	= do { 	-- Link dependents first
1015
               pkgs' <- link pkgs [ Maybes.expectJust "link_one" $
1016
                                    Map.lookup ipid ipid_map
1017
                                  | ipid <- depends pkg_cfg ]
1018 1019 1020 1021 1022
		-- Now link the package itself
	     ; linkPackage dflags pkg_cfg
	     ; return (new_pkg : pkgs') }

	| otherwise
1023
	= ghcError (CmdLineError ("unknown package: " ++ packageIdString new_pkg))
1024 1025 1026 1027 1028


linkPackage :: DynFlags -> PackageConfig -> IO ()
linkPackage dflags pkg
   = do 
1029
        let dirs      =  Packages.libraryDirs pkg
1030 1031

        let libs      =  Packages.hsLibraries pkg
1032 1033 1034 1035 1036 1037
            -- 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
1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048
        -- 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 ]
1049
        classifieds   <- mapM (locateOneObj dirs) libs'
1050 1051 1052 1053

        -- 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 ]
1054
	    archs = [ arch | Archive arch <- classifieds ]
1055

1056
	maybePutStr dflags ("Loading package " ++ display (sourcePackageId pkg) ++ " ... ")
1057 1058

	-- See comments with partOfGHCi
Ian Lynagh's avatar
Ian Lynagh committed
1059
	when (packageName pkg `notElem` partOfGHCi) $ do
1060
	    loadFrameworks pkg
1061 1062 1063 1064 1065 1066 1067
            -- 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.
1068 1069
	    -- This fixes a problem with the HOpenGL package (see "Compiling
	    -- HOpenGL under recent versions of GHC" on the HOpenGL list).
1070
	    mapM_ (load_dyn dirs) (reverse dlls)
1071 1072
	
	-- After loading all the DLLs, we can load the static objects.
1073 1074
	-- Ordering isn't important here, because we do one final link
	-- step to resolve everything.
1075
	mapM_ loadObj objs
Ian Lynagh's avatar