[project @ 2003-05-30 22:29:41 by wolfgang]
[ghc-hetmet.git] / ghc / compiler / main / DriverPipeline.hs
index 8f70de4..2482aaa 100644 (file)
 
 module DriverPipeline (
 
-       -- interfaces for the batch-mode driver
-   genPipeline, runPipeline, pipeLoop,
+       -- Interfaces for the batch-mode driver
+   genPipeline, runPipeline, pipeLoop, staticLink,
 
-       -- interfaces for the compilation manager (interpreted/batch-mode)
-   preprocess, compile, CompResult(..),
+       -- Interfaces for the compilation manager (interpreted/batch-mode)
+   preprocess, 
+   compile, CompResult(..), 
+   link, 
 
-       -- batch-mode linking interface
-   doLink,
         -- DLL building
    doMkDLL
   ) where
@@ -25,7 +25,6 @@ module DriverPipeline (
 #include "HsVersions.h"
 
 import Packages
-import CmTypes
 import GetImports
 import DriverState
 import DriverUtil
@@ -44,27 +43,271 @@ import CmdLineOpts
 import Config
 import Panic
 import Util
+import BasicTypes      ( SuccessFlag(..) )
 import Maybes          ( expectJust )
 
 import ParserCoreUtils ( getCoreModuleName )
 
+import EXCEPTION
+import DATA_IOREF      ( readIORef, writeIORef )
+
 #ifdef GHCI
 import Time            ( getClockTime )
 #endif
 import Directory
 import System
-import IOExts
-import Exception
-
 import IO
 import Monad
 import Maybe
 
-import PackedString
 
------------------------------------------------------------------------------
--- genPipeline
+-- ---------------------------------------------------------------------------
+-- Pre-process
+
+-- Just preprocess a file, put the result in a temp. file (used by the
+-- compilation manager during the summary phase).
+
+preprocess :: FilePath -> IO FilePath
+preprocess filename =
+  ASSERT(haskellish_src_file filename) 
+  do restoreDynFlags   -- Restore to state of last save
+     let fInfo = (filename, getFileSuffix filename)
+     pipeline <- genPipeline (StopBefore Hsc) ("preprocess") False 
+                            defaultHscLang fInfo
+     (fn,_)   <- runPipeline pipeline fInfo
+                            False{-no linking-} False{-no -o flag-}
+     return fn
+
+-- ---------------------------------------------------------------------------
+-- Compile
+
+-- Compile a single module, under the control of the compilation manager.
 --
+-- This is the interface between the compilation manager and the
+-- compiler proper (hsc), where we deal with tedious details like
+-- reading the OPTIONS pragma from the source file, and passing the
+-- output of hsc through the C compiler.
+
+-- The driver sits between 'compile' and 'hscMain', translating calls
+-- to the former into calls to the latter, and results from the latter
+-- into results from the former.  It does things like preprocessing
+-- the .hs file if necessary, and compiling up the .stub_c files to
+-- generate Linkables.
+
+-- NB.  No old interface can also mean that the source has changed.
+
+compile :: GhciMode                -- distinguish batch from interactive
+       -> Module
+       -> ModLocation
+       -> Bool                    -- True <=> source unchanged
+       -> Bool                    -- True <=> have object
+        -> Maybe ModIface          -- old interface, if available
+        -> HomePackageTable        -- For home-module stuff
+        -> PersistentCompilerState -- persistent compiler state
+        -> IO CompResult
+
+data CompResult
+   = CompOK   PersistentCompilerState  -- Updated PCS
+              ModDetails               -- New details
+              ModIface                 -- New iface
+              (Maybe Linkable) -- New code; Nothing => compilation was not reqd
+                               --                      (old code is still valid)
+
+   | CompErrs PersistentCompilerState  -- Updated PCS
+
+
+compile ghci_mode this_mod location
+       source_unchanged have_object 
+       old_iface hpt pcs = do 
+
+   dyn_flags <- restoreDynFlags                -- Restore to the state of the last save
+
+   showPass dyn_flags 
+       (showSDoc (text "Compiling" <+> ppr this_mod))
+
+   let verb      = verbosity dyn_flags
+   let input_fn   = expectJust "compile:hs" (ml_hs_file location) 
+   let input_fnpp = expectJust "compile:hspp" (ml_hspp_file location)
+   let mod_name   = moduleName this_mod
+
+   when (verb >= 2) (hPutStrLn stderr ("compile: input file " ++ input_fnpp))
+
+   opts <- getOptionsFromSource input_fnpp
+   processArgs dynamic_flags opts []
+   dyn_flags <- getDynFlags
+
+   let hsc_lang      = hscLang dyn_flags
+       (basename, _) = splitFilename input_fn
+       
+   keep_hc <- readIORef v_Keep_hc_files
+#ifdef ILX
+   keep_il <- readIORef v_Keep_il_files
+#endif
+   keep_s  <- readIORef v_Keep_s_files
+
+   output_fn <- 
+       case hsc_lang of
+          HscAsm  | keep_s    -> return (basename ++ '.':phaseInputExt As)
+                  | otherwise -> newTempName (phaseInputExt As)
+          HscC    | keep_hc   -> return (basename ++ '.':phaseInputExt HCc)
+                  | otherwise -> newTempName (phaseInputExt HCc)
+           HscJava             -> newTempName "java" -- ToDo
+#ifdef ILX
+          HscILX  | keep_il   -> return (basename ++ '.':phaseInputExt Ilasm)
+                   | otherwise -> newTempName (phaseInputExt Ilx2Il)   
+#endif
+          HscInterpreted      -> return (error "no output file")
+           HscNothing         -> return (error "no output file")
+
+   let dyn_flags' = dyn_flags { hscOutName = output_fn,
+                               hscStubCOutName = basename ++ "_stub.c",
+                               hscStubHOutName = basename ++ "_stub.h",
+                               extCoreName = basename ++ ".hcr" }
+
+   -- -no-recomp should also work with --make
+   do_recomp <- readIORef v_Recomp
+   let source_unchanged' = source_unchanged && do_recomp
+       hsc_env = HscEnv { hsc_mode = ghci_mode,
+                         hsc_dflags = dyn_flags',
+                         hsc_HPT    = hpt }
+
+   -- run the compiler
+   hsc_result <- hscMain hsc_env pcs this_mod location
+                        source_unchanged' have_object old_iface
+
+   case hsc_result of
+      HscFail pcs -> return (CompErrs pcs)
+
+      HscNoRecomp pcs details iface -> return (CompOK pcs details iface Nothing)
+
+      HscRecomp pcs details iface
+       stub_h_exists stub_c_exists maybe_interpreted_code -> do
+          let 
+          maybe_stub_o <- compileStub dyn_flags' stub_c_exists
+          let stub_unlinked = case maybe_stub_o of
+                                 Nothing -> []
+                                 Just stub_o -> [ DotO stub_o ]
+
+          (hs_unlinked, unlinked_time) <-
+            case hsc_lang of
+
+               -- in interpreted mode, just return the compiled code
+               -- as our "unlinked" object.
+               HscInterpreted -> 
+                   case maybe_interpreted_code of
+#ifdef GHCI
+                      Just comp_bc -> do tm <- getClockTime 
+                                          return ([BCOs comp_bc], tm)
+#endif
+                      Nothing -> panic "compile: no interpreted code"
+
+               -- we're in batch mode: finish the compilation pipeline.
+               _other -> do pipe <- genPipeline (StopBefore Ln) "" True 
+                                       hsc_lang (output_fn, getFileSuffix output_fn)
+                             -- runPipeline takes input_fn so it can split off 
+                             -- the base name and use it as the base of 
+                             -- the output object file.
+                             let (basename, suffix) = splitFilename input_fn
+                            (o_file,_) <- 
+                                pipeLoop pipe (output_fn, getFileSuffix output_fn)
+                                              False False 
+                                               basename suffix
+                             o_time <- getModificationTime o_file
+                            return ([DotO o_file], o_time)
+
+          let linkable = LM unlinked_time mod_name
+                            (hs_unlinked ++ stub_unlinked)
+
+          return (CompOK pcs details iface (Just linkable))
+
+-----------------------------------------------------------------------------
+-- stub .h and .c files (for foreign export support)
+
+compileStub dflags stub_c_exists
+  | not stub_c_exists = return Nothing
+  | stub_c_exists = do
+       -- compile the _stub.c file w/ gcc
+       let stub_c = hscStubCOutName dflags
+       pipeline   <- genPipeline (StopBefore Ln) "" True defaultHscLang (stub_c,"c")
+       (stub_o,_) <- runPipeline pipeline (stub_c,"c") False{-no linking-} 
+                                 False{-no -o option-}
+       return (Just stub_o)
+
+
+-- ---------------------------------------------------------------------------
+-- Link
+
+link :: GhciMode               -- interactive or batch
+     -> DynFlags               -- dynamic flags
+     -> Bool                   -- attempt linking in batch mode?
+     -> HomePackageTable       -- what to link
+     -> IO SuccessFlag
+
+-- For the moment, in the batch linker, we don't bother to tell doLink
+-- which packages to link -- it just tries all that are available.
+-- batch_attempt_linking should only be *looked at* in batch mode.  It
+-- should only be True if the upsweep was successful and someone
+-- exports main, i.e., we have good reason to believe that linking
+-- will succeed.
+
+#ifdef GHCI
+link Interactive dflags batch_attempt_linking hpt
+    = do -- Not Linking...(demand linker will do the job)
+        return Succeeded
+#endif
+
+link Batch dflags batch_attempt_linking hpt
+   | batch_attempt_linking
+   = do 
+       let 
+           home_mod_infos = moduleEnvElts hpt
+
+           -- the packages we depend on
+           pkg_deps  = concatMap (dep_pkgs . mi_deps . hm_iface) home_mod_infos
+
+           -- the linkables to link
+           linkables = map hm_linkable home_mod_infos
+
+        when (verb >= 3) $ do
+            hPutStrLn stderr "link: linkables are ..."
+             hPutStrLn stderr (showSDoc (vcat (map ppr linkables)))
+
+       -- check for the -no-link flag
+       omit_linking <- readIORef v_NoLink
+       if omit_linking 
+         then do when (verb >= 3) $
+                   hPutStrLn stderr "link(batch): linking omitted (-no-link flag given)."
+                 return Succeeded
+         else do
+
+       when (verb >= 1) $
+             hPutStrLn stderr "Linking ..."
+
+       let getOfiles (LM _ _ us) = map nameOfObject (filter isObject us)
+           obj_files = concatMap getOfiles linkables
+
+       -- Don't showPass in Batch mode; doLink will do that for us.
+        staticLink obj_files pkg_deps
+
+        when (verb >= 3) (hPutStrLn stderr "link: done")
+
+       -- staticLink only returns if it succeeds
+        return Succeeded
+
+   | otherwise
+   = do when (verb >= 3) $ do
+           hPutStrLn stderr "link(batch): upsweep (partially) failed OR"
+            hPutStrLn stderr "   Main.main not exported; not linking."
+        return Succeeded
+   where
+      verb = verbosity dflags
+      
+
+
+
+-- --------------------------------------------------------------------------
+-- genPipeline: Pipeline construction
+
 -- Herein is all the magic about which phases to run in which order, whether
 -- the intermediate files should be in TMPDIR or in the current directory,
 -- what the suffix of the intermediate files should be, etc.
@@ -155,11 +398,6 @@ genPipeline todo stop_flag persistent_output lang (filename,suffix)
                | split           -> not_valid
                | otherwise       -> [ Hsc, HCc, As ]
 
-       HscCore | split && mangle -> [ Hsc, HCc, Mangle, SplitMangle, SplitAs ]
-               | mangle          -> [ Hsc, HCc, Mangle, As ]
-               | split           -> not_valid
-               | otherwise       -> [ Hsc, HCc, As ]
-
        HscAsm  | split           -> [ Hsc, SplitMangle, SplitAs ]
                | otherwise       -> [ Hsc, As ]
 
@@ -206,9 +444,9 @@ genPipeline todo stop_flag persistent_output lang (filename,suffix)
                     ++ filename ++ "'" ++ show pipeline ++ show stop_phase)))
    let
        -- .o and .hc suffixes can be overriden by command-line options:
-      myPhaseInputExt Ln  | Just s <- osuf  = s
       myPhaseInputExt HCc | Just s <- hcsuf = s
-      myPhaseInputExt other                 = phaseInputExt other
+      myPhaseInputExt Ln    = osuf
+      myPhaseInputExt other = phaseInputExt other
 
       annotatePipeline
         :: [Phase]             -- raw pipeline
@@ -371,7 +609,8 @@ run_phase Cpp basename suff input_fn output_fn
                    hs_src_cpp_opts <- readIORef v_Hs_source_cpp_opts
 
            cmdline_include_paths <- readIORef v_Include_paths
-           pkg_include_dirs <- getPackageIncludePath
+
+           pkg_include_dirs <- getPackageIncludePath []
            let include_paths = foldr (\ x xs -> "-I" : x : xs) []
                                  (cmdline_include_paths ++ pkg_include_dirs)
 
@@ -401,12 +640,9 @@ run_phase Cpp basename suff input_fn output_fn
 
 -------------------------------------------------------------------------------
 -- HsPp phase 
-run_phase HsPp basename suff input_fn output_fn
-  = do src_opts <- getOptionsFromSource input_fn
-       unhandled_flags <- processArgs dynamic_flags src_opts []
-       checkProcessArgsResult unhandled_flags basename suff
 
-       let orig_fn = basename ++ '.':suff
+run_phase HsPp basename suff input_fn output_fn
+  = do let orig_fn = basename ++ '.':suff
        do_pp   <- dynFlag ppFlag
        if not do_pp then
            -- no need to preprocess, just pass input file along
@@ -435,10 +671,7 @@ run_phase MkDependHS basename suff input_fn output_fn
       deps_normals <- mapM (findDependency False orig_fn) import_normals
       let deps = deps_sources ++ deps_normals
 
-      osuf_opt <- readIORef v_Object_suf
-      let osuf = case osuf_opt of
-                  Nothing -> phaseInputExt Ln
-                  Just s  -> s
+      osuf <- readIORef v_Object_suf
 
       extra_suffixes <- readIORef v_Dep_suffixes
       let suffixes = osuf : map (++ ('_':osuf)) extra_suffixes
@@ -497,27 +730,13 @@ run_phase Hsc basename suff input_fn output_fn
   -- we add the current directory (i.e. the directory in which
   -- the .hs files resides) to the import path, since this is
   -- what gcc does, and it's probably what you want.
-       let current_dir = getdir basename
+       let current_dir = directoryOf basename
        
        paths <- readIORef v_Include_paths
        writeIORef v_Include_paths (current_dir : paths)
        
-  -- figure out which header files to #include in a generated .hc file
-       c_includes <- getPackageCIncludes
-       cmdline_includes <- dynFlag cmdlineHcIncludes -- -#include options
-
-       let cc_injects = unlines (map mk_include 
-                                (c_includes ++ reverse cmdline_includes))
-           mk_include h_file = 
-               case h_file of 
-                  '"':_{-"-} -> "#include "++h_file
-                  '<':_      -> "#include "++h_file
-                  _          -> "#include \""++h_file++"\""
-
-       writeIORef v_HCHeader cc_injects
-
   -- gather the imports and module name
-        (srcimps,imps,mod_name) <- 
+        (_,_,mod_name) <- 
             if extcoreish_suffix suff
             then do
                -- no explicit imports in ExtCore input.
@@ -526,9 +745,9 @@ run_phase Hsc basename suff input_fn output_fn
             else 
               getImportsFromFile input_fn
 
-  -- build a ModuleLocation to pass to hscMain.
-       (mod, location')
-          <- mkHomeModuleLocn mod_name basename (basename ++ '.':suff)
+  -- build a ModLocation to pass to hscMain.
+       let (path,file) = splitFilenameDir basename
+       (mod, location') <- mkHomeModLocation mod_name True path file suff
 
   -- take -ohi into account if present
        ohi <- readIORef v_Output_hi
@@ -552,7 +771,7 @@ run_phase Hsc basename suff input_fn output_fn
                   -- THIS COMPILATION, then use that to determine if the 
                   -- source is unchanged.
                | Just x <- expl_o_file, todo == StopBefore Ln  =  x
-               | otherwise = expectJust "source_unchanged" (ml_obj_file location)
+               | otherwise = ml_obj_file location
 
        source_unchanged <- 
           if not (do_recomp && ( todo == DoLink || todo == StopBefore Ln ))
@@ -573,18 +792,18 @@ run_phase Hsc basename suff input_fn output_fn
                                     hscStubCOutName = basename ++ "_stub.c",
                                     hscStubHOutName = basename ++ "_stub.h",
                                     extCoreName = basename ++ ".hcr" }
+           hsc_env = HscEnv { hsc_mode = OneShot,
+                              hsc_dflags = dyn_flags',
+                              hsc_HPT    = emptyHomePackageTable }
+                       
 
   -- run the compiler!
         pcs <- initPersistentCompilerState
-       result <- hscMain OneShot
-                          dyn_flags' mod
+       result <- hscMain hsc_env pcs mod
                          location{ ml_hspp_file=Just input_fn }
                          source_unchanged
                          False
                          Nothing        -- no iface
-                         emptyModuleEnv -- HomeSymbolTable
-                         emptyModuleEnv -- HomeIfaceTable
-                         pcs
 
        case result of {
 
@@ -593,7 +812,7 @@ run_phase Hsc basename suff input_fn output_fn
             HscNoRecomp pcs details iface -> do { SysTools.touch "Touching object file" o_file
                                                ; return Nothing } ;
 
-           HscRecomp pcs details iface stub_h_exists stub_c_exists
+           HscRecomp _pcs _details _iface stub_h_exists stub_c_exists
                      _maybe_interpreted_code -> do
 
                            -- deal with stubs
@@ -619,10 +838,13 @@ run_phase cc_phase basename suff input_fn output_fn
 
         let hcc = cc_phase == HCc
 
-               -- add package include paths even if we're just compiling
-               -- .c files; this is the Value Add(TM) that using
-               -- ghc instead of gcc gives you :)
-        pkg_include_dirs <- getPackageIncludePath
+       -- HC files have the dependent packages stamped into them
+       pkgs <- if hcc then getHCFilePackages input_fn else return []
+
+       -- add package include paths even if we're just compiling .c
+       -- files; this is the Value Add(TM) that using ghc instead of
+       -- gcc gives you :)
+        pkg_include_dirs <- getPackageIncludePath pkgs
         let include_paths = foldr (\ x xs -> "-I" : x : xs) []
                              (cmdline_include_paths ++ pkg_include_dirs)
 
@@ -635,7 +857,7 @@ run_phase cc_phase basename suff input_fn output_fn
        let opt_flag | o2        = "-O2"
                     | otherwise = "-O"
 
-       pkg_extra_cc_opts <- getPackageExtraCcOpts
+       pkg_extra_cc_opts <- getPackageExtraCcOpts pkgs
 
        split_objs <- readIORef v_Split_object_files
        let split_opt | hcc && split_objs = [ "-DUSE_SPLIT_MARKERS" ]
@@ -741,8 +963,9 @@ run_phase SplitAs basename _suff _input_fn output_fn
 
        let assemble_file n
              = do  let input_s  = split_s_prefix ++ "__" ++ show n ++ ".s"
-                   let output_o = newdir real_odir 
+                   let output_o = replaceFilenameDirectory
                                        (basename ++ "__" ++ show n ++ ".o")
+                                        real_odir
                    real_o <- osuf_ify output_o
                    SysTools.runAs (map SysTools.Option as_opts ++
                                    [ SysTools.Option "-c"
@@ -790,7 +1013,7 @@ run_phase Ilasm _basename _suff input_fn output_fn
 -- wrapper script calling the binary. Currently, we need this only in 
 -- a parallel way (i.e. in GUM), because PVM expects the binary in a
 -- central directory.
--- This is called from doLink below, after linking. I haven't made it
+-- This is called from staticLink below, after linking. I haven't made it
 -- a separate phase to minimise interfering with other modules, and
 -- we don't need the generality of a phase (MoveBinary is always
 -- done after linking and makes only sense in a parallel setup)   -- HWL
@@ -873,65 +1096,85 @@ mk_pvm_wrapper_script pvm_executable pvm_executable_base sysMan = unlines $
 
 checkProcessArgsResult flags basename suff
   = do when (notNull flags) (throwDyn (ProgramError (
-           basename ++ "." ++ suff 
-           ++ ": static flags are not allowed in {-# OPTIONS #-} pragmas:\n\t" 
-           ++ unwords flags)) (ExitFailure 1))
+         showSDoc (hang (text basename <> text ('.':suff) <> char ':')
+                     4 (text "unknown flags in  {-# OPTIONS #-} pragma:" <+>
+                         hsep (map text flags)))
+       )))
 
 -----------------------------------------------------------------------------
--- Linking
+-- Look for the /* GHC_PACKAGES ... */ comment at the top of a .hc file
+
+getHCFilePackages :: FilePath -> IO [PackageName]
+getHCFilePackages filename =
+  EXCEPTION.bracket (openFile filename ReadMode) hClose $ \h -> do
+    l <- hGetLine h
+    case l of
+      '/':'*':' ':'G':'H':'C':'_':'P':'A':'C':'K':'A':'G':'E':'S':rest ->
+         return (map mkPackageName (words rest))
+      _other ->
+         return []
+
+-----------------------------------------------------------------------------
+-- Static linking, of .o files
+
+-- The list of packages passed to link is the list of packages on
+-- which this program depends, as discovered by the compilation
+-- manager.  It is combined with the list of packages that the user
+-- specifies on the command line with -package flags.  
+--
+-- In one-shot linking mode, we can't discover the package
+-- dependencies (because we haven't actually done any compilation or
+-- read any interface files), so the user must explicitly specify all
+-- the packages.
 
-doLink :: [String] -> IO ()
-doLink o_files = do
+staticLink :: [FilePath] -> [PackageName] -> IO ()
+staticLink o_files dep_packages = do
     verb       <- getVerbFlag
     static     <- readIORef v_Static
     no_hs_main <- readIORef v_NoHsMain
 
+    -- get the full list of packages to link with, by combining the
+    -- explicit packages with the auto packages and all of their
+    -- dependencies, and eliminating duplicates.
+
     o_file <- readIORef v_Output_file
     let output_fn = case o_file of { Just s -> s; Nothing -> "a.out"; }
 
-    pkg_lib_paths <- getPackageLibraryPath
+    pkg_lib_paths <- getPackageLibraryPath dep_packages
     let pkg_lib_path_opts = map ("-L"++) pkg_lib_paths
 
     lib_paths <- readIORef v_Library_paths
     let lib_path_opts = map ("-L"++) lib_paths
 
-    pkg_libs <- getPackageLibraries
-    let imp         = if static then "" else "_imp"
-        pkg_lib_opts = map (\lib -> "-l" ++ lib ++ imp) pkg_libs
-
-    libs <- readIORef v_Cmdline_libraries
-    let lib_opts = map ("-l"++) (reverse libs)
-        -- reverse because they're added in reverse order from the cmd line
+    pkg_link_opts <- getPackageLinkOpts dep_packages
 
 #ifdef darwin_TARGET_OS
-    pkg_framework_paths <- getPackageFrameworkPath
+    pkg_framework_paths <- getPackageFrameworkPath dep_packages
     let pkg_framework_path_opts = map ("-F"++) pkg_framework_paths
 
     framework_paths <- readIORef v_Framework_paths
     let framework_path_opts = map ("-F"++) framework_paths
 
-    pkg_frameworks <- getPackageFrameworks
-    let pkg_framework_opts = map ("-framework " ++) pkg_frameworks
+    pkg_frameworks <- getPackageFrameworks dep_packages
+    let pkg_framework_opts = concat [ ["-framework", fw] | fw <- pkg_frameworks ]
 
     frameworks <- readIORef v_Cmdline_frameworks
-    let framework_opts = map ("-framework "++) (reverse frameworks)
+    let framework_opts = concat [ ["-framework", fw] | fw <- reverse frameworks ]
         -- reverse because they're added in reverse order from the cmd line
 #endif
 
-    pkg_extra_ld_opts <- getPackageExtraLdOpts
-
        -- probably _stub.o files
     extra_ld_inputs <- readIORef v_Ld_inputs
 
-       -- opts from -optl-<blah>
+       -- opts from -optl-<blah> (including -l<blah> options)
     extra_ld_opts <- getStaticOpts v_Opt_l
 
-    rts_pkg <- getPackageDetails ["rts"]
-    std_pkg <- getPackageDetails ["std"]
+    [rts_pkg, std_pkg] <- getPackageDetails [rtsPackage, basePackage]
+
     let extra_os = if static || no_hs_main
                    then []
-                   else [ head (library_dirs (head rts_pkg)) ++ "/Main.dll_o",
-                          head (library_dirs (head std_pkg)) ++ "/PrelMain.dll_o" ]
+                   else [ head (library_dirs rts_pkg) ++ "/Main.dll_o",
+                          head (library_dirs std_pkg) ++ "/PrelMain.dll_o" ]
 
     (md_c_flags, _) <- machdepCCOpts
     SysTools.runLink ( [ SysTools.Option verb
@@ -944,19 +1187,17 @@ doLink o_files = do
                      ++ extra_os
                      ++ extra_ld_inputs
                      ++ lib_path_opts
-                     ++ lib_opts
+                     ++ extra_ld_opts
 #ifdef darwin_TARGET_OS
                      ++ framework_path_opts
                      ++ framework_opts
 #endif
                      ++ pkg_lib_path_opts
-                     ++ pkg_lib_opts
+                     ++ pkg_link_opts
 #ifdef darwin_TARGET_OS
                      ++ pkg_framework_path_opts
                      ++ pkg_framework_opts
 #endif
-                     ++ pkg_extra_ld_opts
-                     ++ extra_ld_opts
                      ++ if static && not no_hs_main then
                            [ "-u", prefixUnderscore "Main_zdmain_closure"] 
                         else []))
@@ -980,21 +1221,13 @@ doMkDLL o_files = do
     o_file <- readIORef v_Output_file
     let output_fn = case o_file of { Just s -> s; Nothing -> "HSdll.dll"; }
 
-    pkg_lib_paths <- getPackageLibraryPath
+    pkg_lib_paths <- getPackageLibraryPath []
     let pkg_lib_path_opts = map ("-L"++) pkg_lib_paths
 
     lib_paths <- readIORef v_Library_paths
     let lib_path_opts = map ("-L"++) lib_paths
 
-    pkg_libs <- getPackageLibraries
-    let imp = if static then "" else "_imp"
-        pkg_lib_opts = map (\lib -> "-l" ++ lib ++ imp) pkg_libs
-
-    libs <- readIORef v_Cmdline_libraries
-    let lib_opts = map ("-l"++) (reverse libs)
-        -- reverse because they're added in reverse order from the cmd line
-
-    pkg_extra_ld_opts <- getPackageExtraLdOpts
+    pkg_link_opts <- getPackageLinkOpts []
 
        -- probably _stub.o files
     extra_ld_inputs <- readIORef v_Ld_inputs
@@ -1002,13 +1235,12 @@ doMkDLL o_files = do
        -- opts from -optdll-<blah>
     extra_ld_opts <- getStaticOpts v_Opt_dll
 
-    rts_pkg <- getPackageDetails ["rts"]
-    std_pkg <- getPackageDetails ["std"]
+    [rts_pkg, std_pkg] <- getPackageDetails [rtsPackage, basePackage]
 
     let extra_os = if static || no_hs_main
                    then []
-                   else [ head (library_dirs (head rts_pkg)) ++ "/Main.dll_o",
-                          head (library_dirs (head std_pkg)) ++ "/PrelMain.dll_o" ]
+                   else [ head (library_dirs rts_pkg) ++ "/Main.dll_o",
+                          head (library_dirs std_pkg) ++ "/PrelMain.dll_o" ]
 
     (md_c_flags, _) <- machdepCCOpts
     SysTools.runMkDLL
@@ -1023,193 +1255,10 @@ doMkDLL o_files = do
         ++ [ "--target=i386-mingw32" ]
         ++ extra_ld_inputs
         ++ lib_path_opts
-        ++ lib_opts
+        ++ extra_ld_opts
         ++ pkg_lib_path_opts
-        ++ pkg_lib_opts
-        ++ pkg_extra_ld_opts
+        ++ pkg_link_opts
          ++ (if "--def" `elem` (concatMap words extra_ld_opts)
               then [ "" ]
                else [ "--export-all" ])
-        ++ extra_ld_opts
        ))
-
------------------------------------------------------------------------------
--- Just preprocess a file, put the result in a temp. file (used by the
--- compilation manager during the summary phase).
-
-preprocess :: FilePath -> IO FilePath
-preprocess filename =
-  ASSERT(haskellish_src_file filename) 
-  do restoreDynFlags   -- Restore to state of last save
-     let fInfo = (filename, getFileSuffix filename)
-     pipeline <- genPipeline (StopBefore Hsc) ("preprocess") False 
-                            defaultHscLang fInfo
-     (fn,_)   <- runPipeline pipeline fInfo
-                            False{-no linking-} False{-no -o flag-}
-     return fn
-
------------------------------------------------------------------------------
--- Compile a single module, under the control of the compilation manager.
---
--- This is the interface between the compilation manager and the
--- compiler proper (hsc), where we deal with tedious details like
--- reading the OPTIONS pragma from the source file, and passing the
--- output of hsc through the C compiler.
-
--- The driver sits between 'compile' and 'hscMain', translating calls
--- to the former into calls to the latter, and results from the latter
--- into results from the former.  It does things like preprocessing
--- the .hs file if necessary, and compiling up the .stub_c files to
--- generate Linkables.
-
--- NB.  No old interface can also mean that the source has changed.
-
-compile :: GhciMode                -- distinguish batch from interactive
-        -> ModSummary              -- summary, including source
-       -> Bool                    -- True <=> source unchanged
-       -> Bool                    -- True <=> have object
-        -> Maybe ModIface          -- old interface, if available
-        -> HomeSymbolTable         -- for home module ModDetails
-       -> HomeIfaceTable          -- for home module Ifaces
-        -> PersistentCompilerState -- persistent compiler state
-        -> IO CompResult
-
-data CompResult
-   = CompOK   PersistentCompilerState  -- updated PCS
-              ModDetails  -- new details (HST additions)
-              ModIface    -- new iface   (HIT additions)
-              (Maybe Linkable)
-                       -- new code; Nothing => compilation was not reqd
-                       -- (old code is still valid)
-
-   | CompErrs PersistentCompilerState  -- updated PCS
-
-
-compile ghci_mode summary source_unchanged have_object 
-       old_iface hst hit pcs = do 
-   dyn_flags <- restoreDynFlags                -- Restore to the state of the last save
-
-
-   showPass dyn_flags 
-       (showSDoc (text "Compiling" <+> ppr (modSummaryName summary)))
-
-   let verb      = verbosity dyn_flags
-   let location   = ms_location summary
-   let input_fn   = expectJust "compile:hs" (ml_hs_file location) 
-   let input_fnpp = expectJust "compile:hspp" (ml_hspp_file location)
-
-   when (verb >= 2) (hPutStrLn stderr ("compile: input file " ++ input_fnpp))
-
-   opts <- getOptionsFromSource input_fnpp
-   processArgs dynamic_flags opts []
-   dyn_flags <- getDynFlags
-
-   let hsc_lang      = hscLang dyn_flags
-       (basename, _) = splitFilename input_fn
-       
-   keep_hc <- readIORef v_Keep_hc_files
-#ifdef ILX
-   keep_il <- readIORef v_Keep_il_files
-#endif
-   keep_s  <- readIORef v_Keep_s_files
-
-   output_fn <- 
-       case hsc_lang of
-          HscAsm  | keep_s    -> return (basename ++ '.':phaseInputExt As)
-                  | otherwise -> newTempName (phaseInputExt As)
-          HscC    | keep_hc   -> return (basename ++ '.':phaseInputExt HCc)
-                  | otherwise -> newTempName (phaseInputExt HCc)
-           HscJava             -> newTempName "java" -- ToDo
-#ifdef ILX
-          HscILX  | keep_il   -> return (basename ++ '.':phaseInputExt Ilasm)
-                   | otherwise -> newTempName (phaseInputExt Ilx2Il)   
-#endif
-          HscInterpreted      -> return (error "no output file")
-           HscNothing         -> return (error "no output file")
-
-   let dyn_flags' = dyn_flags { hscOutName = output_fn,
-                               hscStubCOutName = basename ++ "_stub.c",
-                               hscStubHOutName = basename ++ "_stub.h",
-                               extCoreName = basename ++ ".hcr" }
-
-   -- figure out which header files to #include in a generated .hc file
-   c_includes <- getPackageCIncludes
-   cmdline_includes <- dynFlag cmdlineHcIncludes -- -#include options
-
-   let cc_injects = unlines (map mk_include 
-                                 (c_includes ++ reverse cmdline_includes))
-       mk_include h_file = 
-       case h_file of 
-           '"':_{-"-} -> "#include "++h_file
-           '<':_      -> "#include "++h_file
-           _          -> "#include \""++h_file++"\""
-
-   writeIORef v_HCHeader cc_injects
-
-   -- -no-recomp should also work with --make
-   do_recomp <- readIORef v_Recomp
-   let source_unchanged' = source_unchanged && do_recomp
-
-   -- run the compiler
-   hsc_result <- hscMain ghci_mode dyn_flags'
-                        (ms_mod summary) location
-                        source_unchanged' have_object old_iface hst hit pcs
-
-   case hsc_result of
-      HscFail pcs -> return (CompErrs pcs)
-
-      HscNoRecomp pcs details iface -> return (CompOK pcs details iface Nothing)
-
-      HscRecomp pcs details iface
-       stub_h_exists stub_c_exists maybe_interpreted_code -> do
-          let 
-          maybe_stub_o <- compileStub dyn_flags' stub_c_exists
-          let stub_unlinked = case maybe_stub_o of
-                                 Nothing -> []
-                                 Just stub_o -> [ DotO stub_o ]
-
-          (hs_unlinked, unlinked_time) <-
-            case hsc_lang of
-
-               -- in interpreted mode, just return the compiled code
-               -- as our "unlinked" object.
-               HscInterpreted -> 
-                   case maybe_interpreted_code of
-#ifdef GHCI
-                      Just (bcos,itbl_env) -> do tm <- getClockTime 
-                                                  return ([BCOs bcos itbl_env], tm)
-#endif
-                      Nothing -> panic "compile: no interpreted code"
-
-               -- we're in batch mode: finish the compilation pipeline.
-               _other -> do pipe <- genPipeline (StopBefore Ln) "" True 
-                                       hsc_lang (output_fn, getFileSuffix output_fn)
-                             -- runPipeline takes input_fn so it can split off 
-                             -- the base name and use it as the base of 
-                             -- the output object file.
-                             let (basename, suffix) = splitFilename input_fn
-                            (o_file,_) <- 
-                                pipeLoop pipe (output_fn, getFileSuffix output_fn)
-                                              False False 
-                                               basename suffix
-                             o_time <- getModificationTime o_file
-                            return ([DotO o_file], o_time)
-
-          let linkable = LM unlinked_time (modSummaryName summary)
-                            (hs_unlinked ++ stub_unlinked)
-
-          return (CompOK pcs details iface (Just linkable))
-
-
------------------------------------------------------------------------------
--- stub .h and .c files (for foreign export support)
-
-compileStub dflags stub_c_exists
-  | not stub_c_exists = return Nothing
-  | stub_c_exists = do
-       -- compile the _stub.c file w/ gcc
-       let stub_c = hscStubCOutName dflags
-       pipeline   <- genPipeline (StopBefore Ln) "" True defaultHscLang (stub_c,"c")
-       (stub_o,_) <- runPipeline pipeline (stub_c,"c") False{-no linking-} 
-                                 False{-no -o option-}
-       return (Just stub_o)