oneShot, compileFile,
-- Interfaces for the batch-mode driver
- staticLink,
+ linkBinary,
-- Interfaces for the compilation manager (interpreted/batch-mode)
preprocess,
compile, CompResult(..),
link,
- -- DLL building
- doMkDLL,
-
) where
#include "HsVersions.h"
import Packages
import HeaderInfo
import DriverPhases
-import SysTools ( newTempName, addFilesToClean, copy )
-import qualified SysTools
+import SysTools
import HscMain
import Finder
import HscTypes
import UniqFM ( eltsUFM )
import ErrUtils
import DynFlags
-import StaticFlags ( v_Ld_inputs, opt_Static, WayName(..) )
+import StaticFlags ( v_Ld_inputs, opt_Static, opt_HardwireLibPaths, WayName(..) )
import Config
import Panic
import Util
import Data.List ( isSuffixOf )
import Data.Maybe
import System.Exit
-import System.Cmd
import System.Environment
-- ---------------------------------------------------------------------------
preprocess :: DynFlags -> (FilePath, Maybe Phase) -> IO (DynFlags, FilePath)
preprocess dflags (filename, mb_phase) =
ASSERT2(isJust mb_phase || isHaskellSrcFilename filename, text filename)
- runPipeline anyHsc dflags (filename, mb_phase) Temporary Nothing{-no ModLocation-}
+ runPipeline anyHsc dflags (filename, mb_phase)
+ Nothing Temporary Nothing{-no ModLocation-}
-- ---------------------------------------------------------------------------
-- Compile
return (CompOK details iface maybe_old_linkable)
handleBatch (HscRecomp hasStub, iface, details)
| isHsBoot src_flavour
- = return (CompOK details iface Nothing)
+ = do SysTools.touch dflags' "Touching object file"
+ object_filename
+ return (CompOK details iface Nothing)
| otherwise
= do stub_unlinked <- getStubLinkable hasStub
(hs_unlinked, unlinked_time) <-
-> return ([], ms_hs_date mod_summary)
-- We're in --make mode: finish the compilation pipeline.
_other
- -> do runPipeline StopLn dflags (output_fn,Nothing) Persistent
+ -> do runPipeline StopLn dflags (output_fn,Nothing)
+ (Just basename)
+ Persistent
(Just location)
-- The object filename comes from the ModLocation
o_time <- getModificationTime object_filename
-- compile the _stub.c file w/ gcc
let (stub_c,_) = mkStubPaths dflags (moduleName mod) location
- runPipeline StopLn dflags (stub_c,Nothing)
+ runPipeline StopLn dflags (stub_c,Nothing) Nothing
(SpecificFile stub_o) Nothing{-no ModLocation-}
return stub_o
-- ---------------------------------------------------------------------------
-- Link
-link :: GhcMode -- interactive or batch
+link :: GhcLink -- interactive or batch
-> DynFlags -- dynamic flags
-> Bool -- attempt linking in batch mode?
-> HomePackageTable -- what to link
-- will succeed.
#ifdef GHCI
-link Interactive dflags batch_attempt_linking hpt
+link LinkInMemory dflags batch_attempt_linking hpt
= do -- Not Linking...(demand linker will do the job)
return Succeeded
#endif
-link JustTypecheck dflags batch_attempt_linking hpt
+link NoLink dflags batch_attempt_linking hpt
= return Succeeded
-link BatchCompile dflags batch_attempt_linking hpt
+link LinkBinary dflags batch_attempt_linking hpt
| batch_attempt_linking
= do
let
-- Don't showPass in Batch mode; doLink will do that for us.
let link = case ghcLink dflags of
- MkDLL -> doMkDLL
- StaticLink -> staticLink
+ LinkBinary -> linkBinary
+ LinkDynLib -> linkDynLib
link dflags obj_files pkg_deps
debugTraceMsg dflags 3 (text "link: done")
- -- staticLink only returns if it succeeds
+ -- linkBinary only returns if it succeeds
return Succeeded
| otherwise
other -> stop_phase
(_, out_file) <- runPipeline stop_phase' dflags
- (src, mb_phase) output Nothing{-no ModLocation-}
+ (src, mb_phase) Nothing output
+ Nothing{-no ModLocation-}
return out_file
| otherwise
= case ghcLink dflags of
NoLink -> return ()
- StaticLink -> staticLink dflags o_files link_pkgs
- MkDLL -> doMkDLL dflags o_files link_pkgs
+ LinkBinary -> linkBinary dflags o_files link_pkgs
+ LinkDynLib -> linkDynLib dflags o_files []
where
-- Always link in the haskell98 package for static linking. Other
-- packages have to be specified via the -package flag.
:: Phase -- When to stop
-> DynFlags -- Dynamic flags
-> (FilePath,Maybe Phase) -- Input filename (and maybe -x suffix)
+ -> Maybe FilePath -- original basename (if different from ^^^)
-> PipelineOutput -- Output filename
-> Maybe ModLocation -- A ModLocation, if this is a Haskell module
-> IO (DynFlags, FilePath) -- (final flags, output filename)
-runPipeline stop_phase dflags (input_fn, mb_phase) output maybe_loc
+runPipeline stop_phase dflags (input_fn, mb_phase) mb_basename output maybe_loc
= do
- let (basename, suffix) = splitFilename input_fn
+ let (input_basename, suffix) = splitFilename input_fn
+ basename | Just b <- mb_basename = b
+ | otherwise = input_basename
-- If we were given a -x flag, then use that phase to start from
start_phase = fromMaybe (startPhase suffix) mb_phase
-- Sometimes, a compilation phase doesn't actually generate any output
-- (eg. the CPP phase when -fcpp is not turned on). If we end on this
-- stage, but we wanted to keep the output, then we have to explicitly
- -- copy the file.
+ -- copy the file, remembering to prepend a {-# LINE #-} pragma so that
+ -- further compilation stages can tell what the original filename was.
case output of
Temporary ->
return (dflags', output_fn)
_other ->
do final_fn <- get_output_fn dflags' stop_phase maybe_loc
- when (final_fn /= output_fn) $
- copy dflags ("Copying `" ++ output_fn ++ "' to `" ++ final_fn
- ++ "'") output_fn final_fn
+ when (final_fn /= output_fn) $ do
+ let msg = ("Copying `" ++ output_fn ++"' to `" ++ final_fn ++ "'")
+ line_prag = Just ("{-# LINE 1 \"" ++ input_fn ++ "\" #-}\n")
+ copyWithHeader dflags msg line_prag output_fn final_fn
return (dflags', final_fn)
-
+
pipeLoop :: DynFlags -> Phase -> Phase
-- 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 staticLink below, after linking. I haven't made it
+-- This is called from linkBinary 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
pvm_executable_base = "=" ++ input_fn
pvm_executable = pvm_root ++ "/bin/" ++ pvm_arch ++ "/" ++ pvm_executable_base
-- nuke old binary; maybe use configur'ed names for cp and rm?
- system ("rm -f " ++ pvm_executable)
+ Panic.try (removeFile pvm_executable)
-- move the newly created binary into PVM land
- system ("cp -p " ++ input_fn ++ " " ++ pvm_executable)
+ copy dflags "copying PVM executable" input_fn pvm_executable
-- generate a wrapper script for running a parallel prg under PVM
writeFile input_fn (mk_pvm_wrapper_script pvm_executable pvm_executable_base sysMan)
return True
"",
"args: while ($a = shift(@ARGV)) {",
" if ( $a eq '+RTS' ) {",
- " $in_RTS_args = 1;",
+ " $in_RTS_args = 1;",
" } elsif ( $a eq '-RTS' ) {",
- " $in_RTS_args = 0;",
+ " $in_RTS_args = 0;",
" }",
" if ( $a eq '-d' && $in_RTS_args ) {",
- " $debug = '-';",
+ " $debug = '-';",
" } elsif ( $a =~ /^-qN(\\d+)/ && $in_RTS_args ) {",
- " $nprocessors = $1;",
+ " $nprocessors = $1;",
" } elsif ( $a =~ /^-qp(\\d+)/ && $in_RTS_args ) {",
- " $nprocessors = $1;",
+ " $nprocessors = $1;",
" } else {",
- " push(@nonPVM_args, $a);",
+ " push(@nonPVM_args, $a);",
" }",
"}",
"",
-- read any interface files), so the user must explicitly specify all
-- the packages.
-staticLink :: DynFlags -> [FilePath] -> [PackageId] -> IO ()
-staticLink dflags o_files dep_packages = do
+linkBinary :: DynFlags -> [FilePath] -> [PackageId] -> IO ()
+linkBinary dflags o_files dep_packages = do
let verb = getVerbFlag dflags
output_fn = exeFileName dflags
-- dependencies, and eliminating duplicates.
pkg_lib_paths <- getPackageLibraryPath dflags dep_packages
- let pkg_lib_path_opts = map ("-L"++) pkg_lib_paths
+ let pkg_lib_path_opts = concat (map get_pkg_lib_path_opts pkg_lib_paths)
+ get_pkg_lib_path_opts l | opt_HardwireLibPaths && not opt_Static = ["-L" ++ l, "-Wl,-rpath", "-Wl," ++ l]
+ | otherwise = ["-L" ++ l]
let lib_paths = libraryPaths dflags
let lib_path_opts = map ("-L"++) lib_paths
"a.out"
#endif
------------------------------------------------------------------------------
--- Making a DLL (only for Win32)
-
-doMkDLL :: DynFlags -> [String] -> [PackageId] -> IO ()
-doMkDLL dflags o_files dep_packages = do
+linkDynLib :: DynFlags -> [String] -> [PackageId] -> IO ()
+linkDynLib dflags o_files dep_packages = do
let verb = getVerbFlag dflags
let static = opt_Static
let no_hs_main = dopt Opt_NoHsMain dflags
let o_file = outputFile dflags
- let output_fn = case o_file of { Just s -> s; Nothing -> "HSdll.dll"; }
pkg_lib_paths <- getPackageLibraryPath dflags dep_packages
let pkg_lib_path_opts = map ("-L"++) pkg_lib_paths
-- probably _stub.o files
extra_ld_inputs <- readIORef v_Ld_inputs
- -- opts from -optdll-<blah>
+ let (md_c_flags, _) = machdepCCOpts dflags
+#if defined(mingw32_HOST_OS)
+ -----------------------------------------------------------------------------
+ -- Making a DLL
+ -----------------------------------------------------------------------------
+
+ let output_fn = case o_file of { Just s -> s; Nothing -> "HSdll.dll"; }
+
+ -- opts from -optdll-<blah>
let extra_ld_opts = getOpts dflags opt_dll
let pstate = pkgState dflags
then []
else [ head (libraryDirs rts_pkg) ++ "/Main.dll_o",
head (libraryDirs base_pkg) ++ "/PrelMain.dll_o" ]
-
- let (md_c_flags, _) = machdepCCOpts dflags
SysTools.runMkDLL dflags
([ SysTools.Option verb
, SysTools.Option "-o"
then [ "" ]
else [ "--export-all" ])
))
-
+#else
+ -----------------------------------------------------------------------------
+ -- Making a DSO
+ -----------------------------------------------------------------------------
+ -- opts from -optl-<blah>
+ let extra_ld_opts = getOpts dflags opt_l
+ let output_fn = case o_file of { Just s -> s; Nothing -> "a.out"; }
+
+ SysTools.runLink dflags
+ ([ SysTools.Option verb
+ , SysTools.Option "-o"
+ , SysTools.FileOption "" output_fn
+ ]
+ ++ map SysTools.Option (
+ md_c_flags
+ ++ o_files
+ ++ [ "-shared", "-Wl,-Bsymbolic" ] -- we need symbolic linking to resolve non-PIC intra-package-relocations
+ ++ extra_ld_inputs
+ ++ lib_path_opts
+ ++ extra_ld_opts
+ ++ pkg_lib_path_opts
+ ++ pkg_link_opts
+ ))
+#endif
-- -----------------------------------------------------------------------------
-- Running CPP
hscMaybeAdjustTarget :: DynFlags -> Phase -> HscSource -> HscTarget -> HscTarget
-hscMaybeAdjustTarget dflags stop HsBootFile current_hsc_lang
- = HscNothing -- No output (other than Foo.hi-boot) for hs-boot files
hscMaybeAdjustTarget dflags stop other current_hsc_lang
= hsc_lang
where