Linker.lhs 43.1 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 LazyUniqFM
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 FiniteMap
55
import Constants
56
import FastString
57
import Config		( cProjectVersion )
58 59

-- Standard libraries
60
import Control.Monad
61

62
import Data.Char
63 64
import Data.IORef
import Data.List
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 106 107 108 109 110 111 112 113 114 115 116

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.
        itbl_env    :: ItblEnv,

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

	-- And the currently-loaded compiled modules (home package)
	objs_loaded :: [Linkable],

	-- 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 432 433 434 435 436 437 438
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"
	 					else "not found")
	 
          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
439 440 441 442 443 444 445

	  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

446
	  Framework framework
Ian Lynagh's avatar
Ian Lynagh committed
447
           | isDarwinTarget
448 449 450 451
             -> 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
452 453
           | otherwise -> panic "preloadLib Framework"

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


474 475 476 477 478 479 480
%************************************************************************
%*									*
		Link a byte-code expression
%*									*
%************************************************************************

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

494 495 496
        -- Take lock for the actual work.
   ; modifyMVar v_PersistentLinkerState $ \pls0 -> do {

497
	-- Link the packages and modules required
498
   ; (pls, ok) <- linkDependencies hsc_env pls0 span needed_mods
499
   ; if failed ok then
500
	ghcError (ProgramError "")
501 502 503
     else do {

	-- Link the expression itself
504
     let ie = itbl_env pls
505 506 507
	 ce = closure_env pls

	-- Link the necessary packages and linkables
508
   ; (_, (root_hval:_)) <- linkSomeBCOs False ie ce [root_ul_bco]
509 510
   ; return (pls, root_hval)
   }}}
511
   where
512 513
     free_names = nameSetToList (bcoFreeNames root_ul_bco)

514
     needed_mods :: [Module]
515 516 517 518 519 520 521 522
     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.
523
 
Ian Lynagh's avatar
Ian Lynagh committed
524
dieWith :: SrcSpan -> Message -> IO a
525
dieWith span msg = ghcError (ProgramError (showSDoc (mkLocMessage span msg)))
526 527 528 529


checkNonStdWay :: DynFlags -> SrcSpan -> IO (Maybe String)
checkNonStdWay dflags srcspan = do
530
  let tag = buildTag dflags
531 532 533 534 535 536 537 538 539 540
  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_.
541 542 543 544 545
  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
546
failNonStd :: SrcSpan -> IO (Maybe String)
547
failNonStd srcspan = dieWith srcspan $
Ian Lynagh's avatar
Ian Lynagh committed
548 549 550
  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.")
551
  
552

553 554
getLinkDeps :: HscEnv -> HomePackageTable
            -> PersistentLinkerState
555 556
	    -> Maybe String			-- the "normal" object suffix
	    -> SrcSpan				-- for error messages
557
	    -> [Module]				-- If you need these
558
	    -> IO ([Linkable], [PackageId])	-- ... then link these first
559
-- Fails with an IO exception if it can't find enough files
560

561
getLinkDeps hsc_env hpt pls maybe_normal_osuf span mods
562
-- Find all the packages and linkables that a set of modules depends on
563
 = do {
564
	-- 1.  Find the dependent home-pkg-modules/packages from each iface
565
        (mods_s, pkgs_s) <- follow_deps mods emptyUniqSet emptyUniqSet;
566

567
	let {
568 569
	-- 2.  Exclude ones already linked
	--	Main reason: avoid findModule calls in get_linkable
Simon Marlow's avatar
Simon Marlow committed
570 571
	    mods_needed = mods_s `minusList` linked_mods     ;
	    pkgs_needed = pkgs_s `minusList` pkgs_loaded pls ;
572

Simon Marlow's avatar
Simon Marlow committed
573 574
	    linked_mods = map (moduleName.linkableModule) 
                                (objs_loaded pls ++ bcos_loaded pls)
575
	} ;
576
	
Simon Marlow's avatar
Simon Marlow committed
577
--        putStrLn (showSDoc (ppr mods_s)) ;
578
	-- 3.  For each dependent module, find its linkable
579 580
	--     This will either be in the HPT or (in the case of one-shot
	--     compilation) we may need to use maybe_getFileLinkable
581
	lnks_needed <- mapM (get_linkable maybe_normal_osuf) mods_needed ;
582

583
	return (lnks_needed, pkgs_needed) }
584
  where
Simon Marlow's avatar
Simon Marlow committed
585 586 587
    dflags = hsc_dflags hsc_env
    this_pkg = thisPackage dflags

Simon Marlow's avatar
Simon Marlow committed
588 589 590 591 592 593 594 595
        -- 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
596
                -> IO ([ModuleName], [PackageId]) -- result
Simon Marlow's avatar
Simon Marlow committed
597
    follow_deps []     acc_mods acc_pkgs
598
        = return (uniqSetToList acc_mods, uniqSetToList acc_pkgs)
Simon Marlow's avatar
Simon Marlow committed
599
    follow_deps (mod:mods) acc_mods acc_pkgs
600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628
        = 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
629 630 631


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

636
    no_obj mod = dieWith span $
Ian Lynagh's avatar
Ian Lynagh committed
637
		     ptext (sLit "cannot find object file for module ") <> 
638 639 640
			quotes (ppr mod) $$
		     while_linking_expr
		
Ian Lynagh's avatar
Ian Lynagh committed
641
    while_linking_expr = ptext (sLit "while linking an interpreted expression")
642

643 644
	-- This one is a build-system bug

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

	    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
672
		let new_file = replaceExtension file osuf
673 674 675
		ok <- doesFileExist new_file
		if (not ok)
		   then dieWith span $
Ian Lynagh's avatar
Ian Lynagh committed
676
			  ptext (sLit "cannot find normal object file ")
677 678
				<> quotes (text new_file) $$ while_linking_expr
		   else return (DotO new_file)
Ian Lynagh's avatar
Ian Lynagh committed
679
	    adjust_ul _ _ = panic "adjust_ul"
680
\end{code}
681 682 683 684 685 686 687 688 689 690 691


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

\begin{code}
692 693 694
linkModules :: DynFlags -> PersistentLinkerState -> [Linkable]
            -> IO (PersistentLinkerState, SuccessFlag)
linkModules dflags pls linkables
695 696 697 698 699 700
  = block $ do  -- don't want to be interrupted by ^C in here
	
	let (objs, bcos) = partition isObjectLinkable 
                              (concatMap partitionLinkable linkables)

		-- Load objects first; they can't depend on BCOs
701
	(pls1, ok_flag) <- dynLinkObjs dflags pls objs
702 703

	if failed ok_flag then 
704
		return (pls1, Failed)
705
	  else do
706 707
		pls2 <- dynLinkBCOs pls1 bcos
		return (pls2, Succeeded)
708 709 710 711 712 713 714 715 716 717
		

-- 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
718 719 720
            (_:_, _:_) -> [li {linkableUnlinked=li_uls_obj},
                           li {linkableUnlinked=li_uls_bco}]
            _ -> [li]
721

722
findModuleLinkable_maybe :: [Linkable] -> Module -> Maybe Linkable
723 724 725 726
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
727
        _    -> pprPanic "findModuleLinkable" (ppr mod)
728 729 730

linkableInSet :: Linkable -> [Linkable] -> Bool
linkableInSet l objs_loaded =
731
  case findModuleLinkable_maybe objs_loaded (linkableModule l) of
732 733 734 735 736 737 738 739 740 741 742 743
	Nothing -> False
	Just m  -> linkableTime l == linkableTime m
\end{code}


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

\begin{code}
744 745 746
dynLinkObjs :: DynFlags -> PersistentLinkerState -> [Linkable]
            -> IO (PersistentLinkerState, SuccessFlag)
dynLinkObjs dflags pls objs = do
747 748 749 750 751
	-- 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

752
	mapM_ loadObj (map nameOfObject unlinkeds)
753 754 755 756 757 758 759

	-- Link the all together
	ok <- resolveObjs

	-- If resolving failed, unload all our 
	-- object modules and carry on
	if succeeded ok then do
760
		return (pls1, Succeeded)
761 762
	  else do
		pls2 <- unload_wkr dflags [] pls1
763
                return (pls2, Failed)
764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785


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}
786 787
dynLinkBCOs :: PersistentLinkerState -> [Linkable] -> IO PersistentLinkerState
dynLinkBCOs pls bcos = do
788 789 790 791 792 793 794 795 796 797 798 799 800 801 802

	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
803 804
        (final_gce, _linked_bcos) <- linkSomeBCOs True final_ie gce ul_bcos
		-- XXX What happens to these linked_bcos?
805 806 807 808

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

809
	return pls2
810 811 812 813 814 815 816

-- 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]
817
             -> IO (ClosureEnv, [HValue])
818 819 820 821
			-- The returned HValues are associated 1-1 with
			-- the incoming unlinked BCOs.  Each gives the
			-- value of the corresponding unlinked BCO
					
822
linkSomeBCOs toplevs_only ie ce_in ul_bcos
823
   = do let nms = map unlinkedBCOName ul_bcos
824 825 826 827 828 829 830 831 832 833 834
        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
835
        return (ce_out, hvals)
836

837 838 839 840 841 842 843 844 845 846
\end{code}


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

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

870 871 872 873
	new_pls
            <- modifyMVar v_PersistentLinkerState $ \pls -> do
	         pls1 <- unload_wkr dflags linkables pls
                 return (pls1, pls1)
874

875 876 877
	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 ()
878

879 880 881 882 883 884
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)
885

Ian Lynagh's avatar
Ian Lynagh committed
886
unload_wkr _ linkables pls
887 888 889 890 891
  = 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)

892
       	let bcos_retained = map linkableModule bcos_loaded'
893 894 895 896 897 898 899 900 901 902 903
	    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
904
      | linkableInSet lnk keep_linkables = return True
905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935
      | 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.

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

937 938 939
   | DLLPath FilePath   -- Absolute or relative pathname to a dynamic library
			-- (ends with .dll or .so).

940
   | Framework String	-- Only used for darwin, but does no harm
941 942 943 944 945 946 947 948 949 950

-- 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
951
partOfGHCi :: [PackageName]
952
partOfGHCi
Ian Lynagh's avatar
Ian Lynagh committed
953
 | isWindowsTarget || isDarwinTarget = []
Ian Lynagh's avatar
Ian Lynagh committed
954 955
 | otherwise = map PackageName
                   ["base", "haskell98", "template-haskell", "editline"]
956

Ian Lynagh's avatar
Ian Lynagh committed
957
showLS :: LibrarySpec -> String
958 959
showLS (Object nm)    = "(static) " ++ nm
showLS (DLL nm)       = "(dynamic) " ++ nm
960
showLS (DLLPath nm)   = "(dynamic) " ++ nm
961 962
showLS (Framework nm) = "(framework) " ++ nm

963 964 965 966
-- | 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.
967
--
968
linkPackages :: DynFlags -> [PackageId] -> IO ()
969
-- NOTE: in fact, since each module tracks all the packages it depends on,
970 971
--       we don't really need to use the package-config dependencies.
--
972 973 974 975
-- 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.
976

977 978 979 980 981
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
982

983 984 985
linkPackages' :: DynFlags -> [PackageId] -> PersistentLinkerState
             -> IO PersistentLinkerState
linkPackages' dflags new_pks pls = do
986
    pkgs' <- link (pkgs_loaded pls) new_pks
987 988
    return $! pls { pkgs_loaded = pkgs' }
  where
989 990 991 992 993 994
     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
995

996
     link_one pkgs new_pkg
997 998 999
	| new_pkg `elem` pkgs	-- Already linked
	= return pkgs

1000
	| Just pkg_cfg <- lookupPackage pkg_map new_pkg
1001
	= do { 	-- Link dependents first
1002 1003 1004
               pkgs' <- link pkgs [ Maybes.expectJust "link_one" $
                                    lookupFM ipid_map ipid
                                  | ipid <- depends pkg_cfg ]
1005 1006 1007 1008 1009
		-- Now link the package itself
	     ; linkPackage dflags pkg_cfg
	     ; return (new_pkg : pkgs') }

	| otherwise
1010
	= ghcError (CmdLineError ("unknown package: " ++ packageIdString new_pkg))
1011 1012 1013 1014 1015


linkPackage :: DynFlags -> PackageConfig -> IO ()
linkPackage dflags pkg
   = do 
1016
        let dirs      =  Packages.libraryDirs pkg
1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029

        let libs      =  Packages.hsLibraries pkg
        -- 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 ]
1030 1031 1032 1033 1034 1035
        classifieds   <- mapM (locateOneObj dirs) libs

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

1036
	maybePutStr dflags ("Loading package " ++ display (sourcePackageId pkg) ++ " ... ")
1037 1038

	-- See comments with partOfGHCi
Ian Lynagh's avatar
Ian Lynagh committed
1039
	when (packageName pkg `notElem` partOfGHCi) $ do
1040
	    loadFrameworks pkg
1041 1042 1043 1044 1045 1046 1047
            -- 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.
1048 1049
	    -- This fixes a problem with the HOpenGL package (see "Compiling
	    -- HOpenGL under recent versions of GHC" on the HOpenGL list).
1050
	    mapM_ (load_dyn dirs) (reverse dlls)
1051 1052
	
	-- After loading all the DLLs, we can load the static objects.
1053 1054
	-- Ordering isn't important here, because we do one final link
	-- step to resolve everything.
1055 1056 1057 1058 1059
	mapM_ loadObj objs

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

Ian Lynagh's avatar
Ian Lynagh committed
1062
load_dyn :: [FilePath] -> FilePath -> IO ()
1063 1064 1065
load_dyn dirs dll = do r <- loadDynamic dirs dll
		       case r of
			 Nothing  -> return ()
1066
			 Just err -> ghcError (CmdLineError ("can't load .so/.DLL for: " 
1067
                                 			      ++ dll ++ " (" ++ err ++ ")" ))
Ian Lynagh's avatar
Ian Lynagh committed
1068

Ian Lynagh's avatar
Ian Lynagh committed
1069
loadFrameworks :: InstalledPackageInfo_ ModuleName -> IO ()
Ian Lynagh's avatar
Ian Lynagh committed
1070 1071 1072
loadFrameworks pkg
 | isDarwinTarget = mapM_ load frameworks
 | otherwise = return ()
1073
  where
1074
    fw_dirs    = Packages.frameworkDirs pkg
ross's avatar
ross committed
1075
    frameworks = Packages.frameworks pkg
1076 1077 1078 1079

    load fw = do  r <- loadFramework fw_dirs fw
		  case r of
		    Nothing  -> return ()
1080
		    Just err -> ghcError (CmdLineError ("can't load framework: " 
1081
                               			        ++ fw ++ " (" ++ err ++ ")" ))
1082 1083 1084 1085 1086

-- Try to find an object file for a given library in the given paths.
-- If it isn't present, we assume it's a dynamic library.
locateOneObj :: [FilePath] -> String -> IO LibrarySpec
locateOneObj dirs lib
1087
  | not isDynamicGhcLib
Ian Lynagh's avatar
Ian Lynagh committed
1088
    -- When the GHC package was not compiled as dynamic library 
1089
    -- (=DYNAMIC not set), we search for .o libraries.
1090 1091 1092
  = do	{ mb_obj_path <- findFile mk_obj_path dirs 
	; case mb_obj_path of
	    Just obj_path -> return (Object obj_path)
1093 1094 1095 1096
	    Nothing	  -> return (DLL lib) }

  | otherwise
    -- When the GHC package was compiled as dynamic library (=DYNAMIC set),
Ian Lynagh's avatar
Ian Lynagh committed
1097
    -- we search for .so libraries first.
1098 1099
  = do	{ mb_lib_path <- findFile mk_dyn_lib_path dirs
	; case mb_lib_path of