import Packages
import HeaderInfo
import DriverPhases
-import SysTools ( newTempName, addFilesToClean, copy )
-import qualified SysTools
+import SysTools
import HscMain
import Finder
import HscTypes
import SrcLoc ( unLoc )
import SrcLoc ( Located(..) )
-import EXCEPTION
-import DATA_IOREF ( readIORef, writeIORef, IORef )
-import GLAEXTS ( Int(..) )
-
-import Directory
-import System
-import IO
-import Monad
+import Control.Exception as Exception
+import Data.IORef ( readIORef, writeIORef, IORef )
+import GHC.Exts ( Int(..) )
+import System.Directory
+import System.IO
+import SYSTEM_IO_ERROR as IO
+import Control.Monad
import Data.List ( isSuffixOf )
-import Maybe
-
+import Data.Maybe
+import System.Exit
+import System.Environment
-- ---------------------------------------------------------------------------
-- Pre-process
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
extCoreName = basename ++ ".hcr" }
-- -no-recomp should also work with --make
- let do_recomp = dopt Opt_RecompChecking dflags
- source_unchanged = isJust maybe_old_linkable && do_recomp
+ let force_recomp = dopt Opt_ForceRecomp dflags
+ source_unchanged = isJust maybe_old_linkable && not force_recomp
hsc_env' = hsc_env { hsc_dflags = dflags' }
object_filename = ml_obj_file location
-> 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
| Right t <- e_exe_time =
any (t <) (map linkableTime linkables)
- if dopt Opt_RecompChecking dflags && not linking_needed
+ if not (dopt Opt_ForceRecomp dflags) && not linking_needed
then do debugTraceMsg dflags 2 (text exe_file <+> ptext SLIT("is up to date, linking not required."))
return Succeeded
else do
-- Don't showPass in Batch mode; doLink will do that for us.
let link = case ghcLink dflags of
MkDLL -> doMkDLL
- StaticLink -> staticLink
+ LinkBinary -> staticLink
link dflags obj_files pkg_deps
debugTraceMsg dflags 3 (text "link: done")
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
+ LinkBinary -> staticLink dflags o_files link_pkgs
MkDLL -> doMkDLL dflags o_files link_pkgs
where
-- Always link in the haskell98 package for static linking. Other
:: 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
- | Just x_phase <- mb_phase = x_phase
- | otherwise = startPhase suffix
+ start_phase = fromMaybe (startPhase suffix) mb_phase
-- We want to catch cases of "you can't get there from here" before
-- we start the pipeline, because otherwise it will just run off the
-- 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
-- date wrt M.hs (or M.o doesn't exist) so we must recompile regardless.
src_timestamp <- getModificationTime (basename `joinFileExt` suff)
- let do_recomp = dopt Opt_RecompChecking dflags
+ let force_recomp = dopt Opt_ForceRecomp dflags
source_unchanged <-
- if not do_recomp || not (isStopLn stop)
+ if force_recomp || not (isStopLn stop)
-- Set source_unchanged to False unconditionally if
-- (a) recompilation checker is off, or
-- (b) we aren't going all the way to .o file (e.g. ghc -S)
-- way too many hacks, and I can't say I've ever used it anyway.
runPhase cc_phase stop dflags basename suff input_fn get_output_fn maybe_loc
- | cc_phase `eqPhase` Cc || cc_phase `eqPhase` HCc
+ | cc_phase `eqPhase` Cc || cc_phase `eqPhase` Ccpp || cc_phase `eqPhase` HCc
= do let cc_opts = getOpts dflags opt_c
hcc = cc_phase `eqPhase` HCc
-- compiling .hc files, by adding the -x c option.
-- Also useful for plain .c files, just in case GHC saw a
-- -x c option.
- [ SysTools.Option "-x", SysTools.Option "c"] ++
+ [ SysTools.Option "-x", if cc_phase `eqPhase` Ccpp
+ then SysTools.Option "c++" else SysTools.Option "c"] ++
[ SysTools.FileOption "" input_fn
, SysTools.Option "-o"
, SysTools.FileOption "" output_fn
++ split_opt
++ include_paths
++ pkg_extra_cc_opts
+#ifdef HAVE_GCC_HAS_WRAPV
+ -- We need consistent integer overflow (trac #952)
+ ++ ["-fwrapv"]
+#endif
))
return (next_phase, dflags, maybe_loc, output_fn)
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);",
" }",
"}",
"",
getHCFilePackages :: FilePath -> IO [PackageId]
getHCFilePackages filename =
- EXCEPTION.bracket (openFile filename ReadMode) hClose $ \h -> do
+ 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 ->
projects / ghc-hetmet.git / blobdiff