--
-----------------------------------------------------------------------------
-#include "../includes/config.h"
+#include "../includes/ghcconfig.h"
module DriverPipeline (
-- Interfaces for the batch-mode driver
- genPipeline, runPipeline, pipeLoop, staticLink,
+ runPipeline, staticLink,
-- Interfaces for the compilation manager (interpreted/batch-mode)
preprocess,
import ErrUtils
import CmdLineOpts
import Config
+import RdrName ( GlobalRdrEnv )
import Panic
import Util
import BasicTypes ( SuccessFlag(..) )
import EXCEPTION
import DATA_IOREF ( readIORef, writeIORef )
-#ifdef GHCI
-import Time ( getClockTime )
-#endif
+import Time ( ClockTime )
import Directory
import System
import IO
preprocess :: FilePath -> IO FilePath
preprocess filename =
- ASSERT(haskellish_src_file filename)
+ ASSERT(isHaskellSrcFilename 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
+ runPipeline (StopBefore Hsc) ("preprocess")
+ False{-temporary output file-}
+ Nothing{-no specific output file-}
+ filename
+ Nothing{-no ModLocation-}
-- ---------------------------------------------------------------------------
-- Compile
-- NB. No old interface can also mean that the source has changed.
-compile :: GhciMode -- distinguish batch from interactive
+compile :: HscEnv
-> Module
-> ModLocation
+ -> ClockTime -- timestamp of original source file
-> 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
+ = CompOK ModDetails -- New details
+ (Maybe GlobalRdrEnv) -- Lexical environment for the module
+ -- (Maybe because we may have loaded it from
+ -- its precompiled interface)
ModIface -- New iface
(Maybe Linkable) -- New code; Nothing => compilation was not reqd
-- (old code is still valid)
- | CompErrs PersistentCompilerState -- Updated PCS
+ | CompErrs
-compile ghci_mode this_mod location
+compile hsc_env this_mod location src_timestamp
source_unchanged have_object
- old_iface hpt pcs = do
+ old_iface = do
dyn_flags <- restoreDynFlags -- Restore to the state of the last save
processArgs dynamic_flags opts []
dyn_flags <- getDynFlags
- let hsc_lang = hscLang dyn_flags
- (basename, _) = splitFilename input_fn
+ let (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,
+ -- We add the directory in which the .hs files resides) to the import path.
+ -- This is needed when we try to compile the .hc file later, if it
+ -- imports a _stub.h file that we created here.
+ let current_dir = directoryOf basename
+ old_paths <- readIORef v_Include_paths
+ writeIORef v_Include_paths (current_dir : old_paths)
+ -- put back the old include paths afterward.
+ later (writeIORef v_Include_paths old_paths) $ do
+
+ -- figure out what lang we're generating
+ hsc_lang <- hscMaybeAdjustLang (hscLang dyn_flags)
+ -- figure out what the next phase should be
+ next_phase <- hscNextPhase hsc_lang
+ -- figure out what file to generate the output into
+ get_output_fn <- genOutputFilenameFunc False Nothing next_phase basename
+ output_fn <- get_output_fn next_phase (Just location)
+
+ let dyn_flags' = dyn_flags { hscLang = hsc_lang,
+ 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 }
+ hsc_env' = hsc_env { hsc_dflags = dyn_flags' }
-- run the compiler
- hsc_result <- hscMain hsc_env pcs this_mod location
+ hsc_result <- hscMain hsc_env' printErrorsAndWarnings this_mod location
source_unchanged' have_object old_iface
case hsc_result of
- HscFail pcs -> return (CompErrs pcs)
+ HscFail -> return CompErrs
- HscNoRecomp pcs details iface -> return (CompOK pcs details iface Nothing)
+ HscNoRecomp details iface -> return (CompOK details Nothing iface Nothing)
- HscRecomp pcs details iface
+ HscRecomp details rdr_env iface
stub_h_exists stub_c_exists maybe_interpreted_code -> do
let
maybe_stub_o <- compileStub dyn_flags' stub_c_exists
HscInterpreted ->
case maybe_interpreted_code of
#ifdef GHCI
- Just comp_bc -> do tm <- getClockTime
- return ([BCOs comp_bc], tm)
+ Just comp_bc -> return ([BCOs comp_bc], src_timestamp)
+ -- Why do we use the timestamp of the source file here,
+ -- rather than the current time? This works better in
+ -- the case where the local clock is out of sync
+ -- with the filesystem's clock. It's just as accurate:
+ -- if the source is modified, then the linkable will
+ -- be out of date.
#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)
+ _other -> do
+ let object_filename = ml_obj_file location
+
+ runPipeline (StopBefore Ln) ""
+ True Nothing output_fn (Just location)
+ -- the object filename comes from the ModLocation
+
+ o_time <- getModificationTime object_filename
+ return ([DotO object_filename], o_time)
let linkable = LM unlinked_time mod_name
(hs_unlinked ++ stub_unlinked)
- return (CompOK pcs details iface (Just linkable))
+ return (CompOK details rdr_env iface (Just linkable))
-----------------------------------------------------------------------------
-- stub .h and .c files (for foreign export support)
| 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-}
+ stub_o <- runPipeline (StopBefore Ln) "stub-compile"
+ True{-persistent output-}
+ Nothing{-no specific output file-}
+ stub_c
+ Nothing{-no ModLocation-}
return (Just stub_o)
where
verb = verbosity dflags
+-- ---------------------------------------------------------------------------
+-- Run a compilation pipeline, consisting of multiple phases.
+runPipeline
+ :: GhcMode -- when to stop
+ -> String -- "stop after" flag
+ -> Bool -- final output is persistent?
+ -> Maybe FilePath -- where to put the output, optionally
+ -> FilePath -- input filename
+ -> Maybe ModLocation -- a ModLocation for this module, if we have one
+ -> IO FilePath -- output filename
+
+runPipeline todo stop_flag keep_output maybe_output_filename input_fn maybe_loc
+ = do
+ split <- readIORef v_Split_object_files
+ let (basename, suffix) = splitFilename input_fn
+ start_phase = startPhase suffix
+ stop_phase = case todo of
+ StopBefore As | split -> SplitAs
+ StopBefore phase -> phase
+ DoMkDependHS -> Ln
+ DoLink -> Ln
+ DoMkDLL -> Ln
--- --------------------------------------------------------------------------
--- 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.
-
--- The following compilation pipeline algorithm is fairly hacky. A
--- better way to do this would be to express the whole compilation as a
--- data flow DAG, where the nodes are the intermediate files and the
--- edges are the compilation phases. This framework would also work
--- nicely if a haskell dependency generator was included in the
--- driver.
-
--- It would also deal much more cleanly with compilation phases that
--- generate multiple intermediates, (eg. hsc generates .hc, .hi, and
--- possibly stub files), where some of the output files need to be
--- processed further (eg. the stub files need to be compiled by the C
--- compiler).
-
--- A cool thing to do would then be to execute the data flow graph
--- concurrently, automatically taking advantage of extra processors on
--- the host machine. For example, when compiling two Haskell files
--- where one depends on the other, the data flow graph would determine
--- that the C compiler from the first compilation can be overlapped
--- with the hsc compilation for the second file.
-
-data IntermediateFileType
- = Temporary
- | Persistent
- deriving (Eq, Show)
-
-genPipeline
- :: GhcMode -- when to stop
- -> String -- "stop after" flag (for error messages)
- -> Bool -- True => output is persistent
- -> HscLang -- preferred output language for hsc
- -> (FilePath, String) -- original filename & its suffix
- -> IO [ -- list of phases to run for this file
- (Phase,
- IntermediateFileType, -- keep the output from this phase?
- String) -- output file suffix
- ]
-
-genPipeline todo stop_flag persistent_output lang (filename,suffix)
+ -- 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
+ -- end.
+ --
+ -- There is a partial ordering on phases, where A < B iff A occurs
+ -- before B in a normal compilation pipeline.
+ --
+ when (not (start_phase `happensBefore` stop_phase)) $
+ throwDyn (UsageError
+ ("flag `" ++ stop_flag
+ ++ "' is incompatible with source file `"
+ ++ input_fn ++ "'"))
+
+ -- generate a function which will be used to calculate output file names
+ -- as we go along.
+ get_output_fn <- genOutputFilenameFunc keep_output maybe_output_filename
+ stop_phase basename
+
+ -- and execute the pipeline...
+ (output_fn, maybe_loc) <-
+ pipeLoop start_phase stop_phase input_fn basename suffix
+ get_output_fn maybe_loc
+
+ -- 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.
+ if keep_output
+ then do final_fn <- get_output_fn stop_phase maybe_loc
+ when (final_fn /= output_fn) $
+ copy ("Copying `" ++ output_fn ++ "' to `" ++ final_fn
+ ++ "'") output_fn final_fn
+ return final_fn
+ else
+ return output_fn
+
+
+pipeLoop :: Phase -> Phase -> FilePath -> String -> Suffix
+ -> (Phase -> Maybe ModLocation -> IO FilePath)
+ -> Maybe ModLocation -> IO (FilePath, Maybe ModLocation)
+
+pipeLoop phase stop_phase input_fn orig_basename orig_suff
+ get_output_fn maybe_loc
+
+ | phase == stop_phase = return (input_fn, maybe_loc) -- all done
+
+ | not (phase `happensBefore` stop_phase) =
+ -- Something has gone wrong. We'll try to cover all the cases when
+ -- this could happen, so if we reach here it is a panic.
+ -- eg. it might happen if the -C flag is used on a source file that
+ -- has {-# OPTIONS -fasm #-}.
+ panic ("pipeLoop: at phase " ++ show phase ++
+ " but I wanted to stop at phase " ++ show stop_phase)
+
+ | otherwise = do
+ maybe_next_phase <- runPhase phase orig_basename orig_suff input_fn
+ get_output_fn maybe_loc
+ case maybe_next_phase of
+ (Nothing, maybe_loc, output_fn) -> do
+ -- we stopped early, but return the *final* filename
+ -- (it presumably already exists)
+ final_fn <- get_output_fn stop_phase maybe_loc
+ return (final_fn, maybe_loc)
+ (Just next_phase, maybe_loc, output_fn) ->
+ pipeLoop next_phase stop_phase output_fn
+ orig_basename orig_suff get_output_fn maybe_loc
+
+
+genOutputFilenameFunc :: Bool -> Maybe FilePath -> Phase -> String
+ -> IO (Phase{-next phase-} -> Maybe ModLocation -> IO FilePath)
+genOutputFilenameFunc keep_final_output maybe_output_filename
+ stop_phase basename
= do
- split <- readIORef v_Split_object_files
- mangle <- readIORef v_Do_asm_mangling
+ hcsuf <- readIORef v_HC_suf
+ odir <- readIORef v_Output_dir
+ osuf <- readIORef v_Object_suf
keep_hc <- readIORef v_Keep_hc_files
#ifdef ILX
keep_il <- readIORef v_Keep_il_files
#endif
keep_raw_s <- readIORef v_Keep_raw_s_files
keep_s <- readIORef v_Keep_s_files
- osuf <- readIORef v_Object_suf
- hcsuf <- readIORef v_HC_suf
-
let
- ----------- ----- ---- --- -- -- - - -
- start = startPhase suffix
-
- -- special case for mkdependHS: .hspp files go through MkDependHS
- start_phase | todo == DoMkDependHS && start == Hsc = MkDependHS
- | otherwise = start
-
- haskellish = haskellish_suffix suffix
- cish = cish_suffix suffix
+ myPhaseInputExt HCc | Just s <- hcsuf = s
+ myPhaseInputExt Ln = osuf
+ myPhaseInputExt other = phaseInputExt other
- -- for a .hc file we need to force lang to HscC
- real_lang | start_phase == HCc || start_phase == Mangle = HscC
- | otherwise = lang
+ func next_phase maybe_location
+ | is_last_phase, Just f <- maybe_output_filename = return f
+ | is_last_phase && keep_final_output = persistent_fn
+ | keep_this_output = persistent_fn
+ | otherwise = newTempName suffix
- let
- ----------- ----- ---- --- -- -- - - -
- pipeline = preprocess ++ compile
-
- preprocess
- | haskellish = [ Unlit, Cpp, HsPp ]
- | otherwise = [ ]
+ where
+ is_last_phase = next_phase == stop_phase
- compile
- | todo == DoMkDependHS = [ MkDependHS ]
+ -- sometimes, we keep output from intermediate stages
+ keep_this_output =
+ case next_phase of
+ Ln -> True
+ Mangle | keep_raw_s -> True
+ As | keep_s -> True
+ HCc | keep_hc -> True
+ _other -> False
- | cish = [ Cc, As ]
+ suffix = myPhaseInputExt next_phase
- | haskellish =
- case real_lang of
- HscC | split && mangle -> [ Hsc, HCc, Mangle, SplitMangle, SplitAs ]
- | mangle -> [ Hsc, HCc, Mangle, As ]
- | split -> not_valid
- | otherwise -> [ Hsc, HCc, As ]
+ -- persistent object files get put in odir
+ persistent_fn
+ | Ln <- next_phase = return odir_persistent
+ | otherwise = return persistent
- HscAsm | split -> [ Hsc, SplitMangle, SplitAs ]
- | otherwise -> [ Hsc, As ]
+ persistent = basename ++ '.':suffix
- HscJava | split -> not_valid
- | otherwise -> error "not implemented: compiling via Java"
-#ifdef ILX
- HscILX | split -> not_valid
- | otherwise -> [ Hsc, Ilx2Il, Ilasm ]
-#endif
- HscNothing -> [ Hsc, HCc ] -- HCc is a dummy stop phase
+ odir_persistent
+ | Just loc <- maybe_location = ml_obj_file loc
+ | Just d <- odir = replaceFilenameDirectory persistent d
+ | otherwise = persistent
- | otherwise = [ ] -- just pass this file through to the linker
+ return func
- -- ToDo: this is somewhat cryptic
- not_valid = throwDyn (UsageError ("invalid option combination"))
- stop_phase = case todo of
- StopBefore As | split -> SplitAs
-#ifdef ILX
- | real_lang == HscILX -> Ilasm
-#endif
- StopBefore phase -> phase
- DoMkDependHS -> Ln
- DoLink -> Ln
- DoMkDLL -> Ln
- ----------- ----- ---- --- -- -- - - -
-
- -- this shouldn't happen.
- when (start_phase /= Ln && start_phase `notElem` pipeline)
- (throwDyn (CmdLineError ("can't find starting phase for "
- ++ filename)))
- -- if we can't find the phase we're supposed to stop before,
- -- something has gone wrong. This test carefully avoids the
- -- case where we aren't supposed to do any compilation, because the file
- -- is already in linkable form (for example).
--- hPutStrLn stderr (show ((start_phase `elem` pipeline,stop_phase /= Ln,stop_phase `notElem` pipeline), start_phase, stop_phase, pipeline,todo))
--- hFlush stderr
- when (start_phase `elem` pipeline &&
- (stop_phase /= Ln && stop_phase `notElem` pipeline))
- (do
- throwDyn (UsageError
- ("flag `" ++ stop_flag
- ++ "' is incompatible with source file `"
- ++ filename ++ "'" ++ show pipeline ++ show stop_phase)))
- let
- -- .o and .hc suffixes can be overriden by command-line options:
- myPhaseInputExt HCc | Just s <- hcsuf = s
- myPhaseInputExt Ln = osuf
- myPhaseInputExt other = phaseInputExt other
-
- annotatePipeline
- :: [Phase] -- raw pipeline
- -> Phase -- phase to stop before
- -> [(Phase, IntermediateFileType, String{-file extension-})]
- annotatePipeline [] _ = []
- annotatePipeline (Ln:_) _ = []
- annotatePipeline (phase:next_phase:ps) stop =
- (phase, keep_this_output, myPhaseInputExt next_phase)
- : annotatePipeline (next_phase:ps) stop
- where
- keep_this_output
- | next_phase == stop
- = if persistent_output then Persistent else Temporary
- | otherwise
- = case next_phase of
- Ln -> Persistent
- Mangle | keep_raw_s -> Persistent
- As | keep_s -> Persistent
- HCc | keep_hc -> Persistent
-#ifdef ILX
- Ilx2Il | keep_ilx -> Persistent
- Ilasm | keep_il -> Persistent
-#endif
- _other -> Temporary
-
- -- add information about output files to the pipeline
- -- the suffix on an output file is determined by the next phase
- -- in the pipeline, so we add linking to the end of the pipeline
- -- to force the output from the final phase to be a .o file.
-
- annotated_pipeline = annotatePipeline (pipeline ++ [Ln]) stop_phase
-
- phase_ne p (p1,_,_) = (p1 /= p)
- ----------- ----- ---- --- -- -- - - -
-
- return (
- takeWhile (phase_ne stop_phase ) $
- dropWhile (phase_ne start_phase) $
- annotated_pipeline
- )
-
-
-runPipeline
- :: [ (Phase, IntermediateFileType, String) ] -- phases to run
- -> (String,String) -- input file
- -> Bool -- doing linking afterward?
- -> Bool -- take into account -o when generating output?
- -> IO (String, String) -- return final filename
-
-runPipeline pipeline (input_fn,suffix) do_linking use_ofile
- = pipeLoop pipeline (input_fn,suffix) do_linking use_ofile basename suffix
- where (basename, _) = splitFilename input_fn
-
-pipeLoop [] input_fn _ _ _ _ = return input_fn
-pipeLoop (all_phases@((phase, keep, o_suffix):phases))
- (input_fn,real_suff) do_linking use_ofile orig_basename orig_suffix
- = do
+-- -----------------------------------------------------------------------------
+-- Each phase in the pipeline returns the next phase to execute, and the
+-- name of the file in which the output was placed.
+--
+-- We must do things dynamically this way, because we often don't know
+-- what the rest of the phases will be until part-way through the
+-- compilation: for example, an {-# OPTIONS -fasm #-} at the beginning
+-- of a source file can change the latter stages of the pipeline from
+-- taking the via-C route to using the native code generator.
+
+runPhase :: Phase
+ -> String -- basename of original input source
+ -> String -- its extension
+ -> FilePath -- name of file which contains the input to this phase.
+ -> (Phase -> Maybe ModLocation -> IO FilePath)
+ -- how to calculate the output filename
+ -> Maybe ModLocation -- the ModLocation, if we have one
+ -> IO (Maybe Phase, -- next phase
+ Maybe ModLocation, -- the ModLocation, if we have one
+ FilePath) -- output filename
- output_fn <- outputFileName (null phases) keep o_suffix
-
- mbCarryOn <- run_phase phase orig_basename orig_suffix
- input_fn output_fn
- -- sometimes we bail out early, eg. when the compiler's recompilation
- -- checker has determined that recompilation isn't necessary.
- case mbCarryOn of
- Nothing -> do
- let (_,keep,final_suffix) = last all_phases
- ofile <- outputFileName True keep final_suffix
- return (ofile, final_suffix)
- -- carry on ...
- Just fn -> do
- {-
- Check to see whether we've reached the end of the
- pipeline, but did so with an ineffective last stage.
- (i.e., it returned the input_fn as the output filename).
-
- If we did and the output is persistent, copy the contents
- of input_fn into the file where the pipeline's output is
- expected to end up.
- -}
- atEnd <- finalStage (null phases)
- when (atEnd && fn == input_fn)
- (copy "Saving away compilation pipeline's output"
- input_fn
- output_fn)
- {-
- Notice that in order to keep the invariant that we can
- determine a compilation pipeline's 'start phase' just
- by looking at the input filename, the input filename
- to the next stage/phase is associated here with the suffix
- of the output file, *even* if it does not have that
- suffix in reality.
-
- Why is this important? Because we may run a compilation
- pipeline in stages (cf. Main.main.compileFile's two stages),
- so when generating the next stage we need to be precise
- about what kind of file (=> suffix) is given as input.
-
- [Not having to generate a pipeline in stages seems like
- the right way to go, but I've punted on this for now --sof]
-
- -}
- pipeLoop phases (fn, o_suffix) do_linking use_ofile
- orig_basename orig_suffix
- where
- finalStage lastPhase = do
- o_file <- readIORef v_Output_file
- return (lastPhase && not do_linking && use_ofile && isJust o_file)
-
- outputFileName last_phase keep suffix
- = do o_file <- readIORef v_Output_file
- atEnd <- finalStage last_phase
- if atEnd
- then case o_file of
- Just s -> return s
- Nothing -> error "outputFileName"
- else if keep == Persistent
- then odir_ify (orig_basename ++ '.':suffix)
- else newTempName suffix
-
-run_phase :: Phase
- -> String -- basename of original input source
- -> String -- its extension
- -> FilePath -- name of file which contains the input to this phase.
- -> FilePath -- where to stick the result.
- -> IO (Maybe FilePath)
- -- Nothing => stop the compilation pipeline
- -- Just fn => the result of this phase can be found in 'fn'
- -- (this can either be 'input_fn' or 'output_fn').
-------------------------------------------------------------------------------
-- Unlit phase
-run_phase Unlit _basename _suff input_fn output_fn
+runPhase Unlit _basename _suff input_fn get_output_fn maybe_loc
= do unlit_flags <- getOpts opt_L
-- The -h option passes the file name for unlit to put in a #line directive
+ output_fn <- get_output_fn Cpp maybe_loc
+
SysTools.runUnlit (map SysTools.Option unlit_flags ++
[ SysTools.Option "-h"
, SysTools.Option input_fn
, SysTools.FileOption "" input_fn
, SysTools.FileOption "" output_fn
])
- return (Just output_fn)
+
+ return (Just Cpp, maybe_loc, output_fn)
-------------------------------------------------------------------------------
-- Cpp phase
-run_phase Cpp basename suff input_fn output_fn
+runPhase Cpp basename suff input_fn get_output_fn maybe_loc
= do src_opts <- getOptionsFromSource input_fn
unhandled_flags <- processArgs dynamic_flags src_opts []
checkProcessArgsResult unhandled_flags basename suff
if not do_cpp then
-- no need to preprocess CPP, just pass input file along
-- to the next phase of the pipeline.
- return (Just input_fn)
+ return (Just HsPp, maybe_loc, input_fn)
else do
- hscpp_opts <- getOpts opt_P
- hs_src_cpp_opts <- readIORef v_Hs_source_cpp_opts
-
- cmdline_include_paths <- readIORef v_Include_paths
-
- pkg_include_dirs <- getPackageIncludePath []
- let include_paths = foldr (\ x xs -> "-I" : x : xs) []
- (cmdline_include_paths ++ pkg_include_dirs)
-
- verb <- getVerbFlag
- (md_c_flags, _) <- machdepCCOpts
-
- SysTools.runCpp ([SysTools.Option verb]
- ++ map SysTools.Option include_paths
- ++ map SysTools.Option hs_src_cpp_opts
- ++ map SysTools.Option hscpp_opts
- ++ map SysTools.Option md_c_flags
- ++ [ SysTools.Option "-x"
- , SysTools.Option "c"
- , SysTools.Option input_fn
- -- We hackily use Option instead of FileOption here, so that the file
- -- name is not back-slashed on Windows. cpp is capable of
- -- dealing with / in filenames, so it works fine. Furthermore
- -- if we put in backslashes, cpp outputs #line directives
- -- with *double* backslashes. And that in turn means that
- -- our error messages get double backslashes in them.
- -- In due course we should arrange that the lexer deals
- -- with these \\ escapes properly.
- , SysTools.Option "-o"
- , SysTools.FileOption "" output_fn
- ])
- return (Just output_fn)
+ output_fn <- get_output_fn HsPp maybe_loc
+ doCpp True{-raw-} False{-no CC opts-} input_fn output_fn
+ return (Just HsPp, maybe_loc, output_fn)
-------------------------------------------------------------------------------
-- HsPp phase
-run_phase HsPp basename suff input_fn output_fn
- = do let orig_fn = basename ++ '.':suff
- do_pp <- dynFlag ppFlag
+runPhase HsPp basename suff input_fn get_output_fn maybe_loc
+ = do do_pp <- dynFlag ppFlag
if not do_pp then
-- no need to preprocess, just pass input file along
-- to the next phase of the pipeline.
- return (Just input_fn)
+ return (Just Hsc, maybe_loc, input_fn)
else do
hspp_opts <- getOpts opt_F
hs_src_pp_opts <- readIORef v_Hs_source_pp_opts
+ let orig_fn = basename ++ '.':suff
+ output_fn <- get_output_fn Hsc maybe_loc
SysTools.runPp ( [ SysTools.Option orig_fn
, SysTools.Option input_fn
, SysTools.FileOption "" output_fn
map SysTools.Option hs_src_pp_opts ++
map SysTools.Option hspp_opts
)
- return (Just output_fn)
-
------------------------------------------------------------------------------
--- MkDependHS phase
-
-run_phase MkDependHS basename suff input_fn output_fn
- = do src <- readFile input_fn
- let (import_sources, import_normals, _) = getImports src
- let orig_fn = basename ++ '.':suff
- deps_sources <- mapM (findDependency True orig_fn) import_sources
- deps_normals <- mapM (findDependency False orig_fn) import_normals
- let deps = deps_sources ++ deps_normals
-
- osuf <- readIORef v_Object_suf
-
- extra_suffixes <- readIORef v_Dep_suffixes
- let suffixes = osuf : map (++ ('_':osuf)) extra_suffixes
- ofiles = map (\suf -> basename ++ '.':suf) suffixes
-
- objs <- mapM odir_ify ofiles
-
- -- Handle for file that accumulates dependencies
- hdl <- readIORef v_Dep_tmp_hdl
-
- -- std dependency of the object(s) on the source file
- hPutStrLn hdl (unwords (map escapeSpaces objs) ++ " : " ++
- escapeSpaces (basename ++ '.':suff))
-
- let genDep (dep, False {- not an hi file -}) =
- hPutStrLn hdl (unwords (map escapeSpaces objs) ++ " : " ++
- escapeSpaces dep)
- genDep (dep, True {- is an hi file -}) = do
- hisuf <- readIORef v_Hi_suf
- let dep_base = remove_suffix '.' dep
- deps = (dep_base ++ hisuf)
- : map (\suf -> dep_base ++ suf ++ '_':hisuf) extra_suffixes
- -- length objs should be == length deps
- sequence_ (zipWith (\o d -> hPutStrLn hdl (escapeSpaces o ++ " : " ++ escapeSpaces d)) objs deps)
-
- sequence_ (map genDep [ d | Just d <- deps ])
- return (Just output_fn)
-
--- add the lines to dep_makefile:
- -- always:
- -- this.o : this.hs
-
- -- if the dependency is on something other than a .hi file:
- -- this.o this.p_o ... : dep
- -- otherwise
- -- if the import is {-# SOURCE #-}
- -- this.o this.p_o ... : dep.hi-boot[-$vers]
-
- -- else
- -- this.o ... : dep.hi
- -- this.p_o ... : dep.p_hi
- -- ...
-
- -- (where .o is $osuf, and the other suffixes come from
- -- the cmdline -s options).
-
+ return (Just Hsc, maybe_loc, output_fn)
-----------------------------------------------------------------------------
-- Hsc phase
-- Compilation of a single module, in "legacy" mode (_not_ under
-- the direction of the compilation manager).
-run_phase Hsc basename suff input_fn output_fn
- = do
-
+runPhase Hsc basename suff input_fn get_output_fn _maybe_loc = do
+ todo <- readIORef v_GhcMode
+ if todo == DoMkDependHS then do
+ locn <- doMkDependHSPhase basename suff input_fn
+ return (Nothing, Just locn, input_fn) -- Ln is a dummy stop phase
+
+ else do
+ -- normal Hsc mode, not mkdependHS
+
-- 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.
writeIORef v_Include_paths (current_dir : paths)
-- gather the imports and module name
- (srcimps,imps,mod_name) <-
- if extcoreish_suffix suff
+ (_,_,mod_name) <-
+ if isExtCoreFilename ('.':suff)
then do
-- no explicit imports in ExtCore input.
m <- getCoreModuleName input_fn
getImportsFromFile input_fn
-- build a ModLocation to pass to hscMain.
- let (path,file) = splitFilenameDir basename
- (mod, location') <- mkHomeModLocation mod_name True path file suff
+ (mod, location') <- mkHomeModLocation mod_name (basename ++ '.':suff)
-- take -ohi into account if present
ohi <- readIORef v_Output_hi
-- Setting source_unchanged to False tells the compiler that M.o is out of
-- date wrt M.hs (or M.o doesn't exist) so we must recompile regardless.
do_recomp <- readIORef v_Recomp
- todo <- readIORef v_GhcMode
expl_o_file <- readIORef v_Output_file
let o_file -- if the -o option is given and IT IS THE OBJECT FILE FOR
-- 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 ))
-- get the DynFlags
dyn_flags <- getDynFlags
+ hsc_lang <- hscMaybeAdjustLang (hscLang dyn_flags)
+ next_phase <- hscNextPhase hsc_lang
+ output_fn <- get_output_fn next_phase (Just location)
- let dyn_flags' = dyn_flags { hscOutName = output_fn,
+ let dyn_flags' = dyn_flags { hscLang = hsc_lang,
+ hscOutName = 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 }
-
+ hsc_env <- newHscEnv OneShot dyn_flags'
-- run the compiler!
- pcs <- initPersistentCompilerState
- result <- hscMain hsc_env pcs mod
+ result <- hscMain hsc_env printErrorsAndWarnings mod
location{ ml_hspp_file=Just input_fn }
source_unchanged
False
Nothing -- no iface
- case result of {
+ case result of
- HscFail pcs -> throwDyn (PhaseFailed "hsc" (ExitFailure 1));
+ HscFail -> throwDyn (PhaseFailed "hsc" (ExitFailure 1))
- HscNoRecomp pcs details iface -> do { SysTools.touch "Touching object file" o_file
- ; return Nothing } ;
+ HscNoRecomp details iface -> do
+ SysTools.touch "Touching object file" o_file
+ return (Nothing, Just location, output_fn)
- HscRecomp pcs details iface stub_h_exists stub_c_exists
+ HscRecomp _details _rdr_env _iface
+ stub_h_exists stub_c_exists
_maybe_interpreted_code -> do
- -- deal with stubs
- maybe_stub_o <- compileStub dyn_flags' stub_c_exists
- case maybe_stub_o of
- Nothing -> return ()
- Just stub_o -> add v_Ld_inputs stub_o
- case hscLang dyn_flags of
- HscNothing -> return Nothing
- _ -> return (Just output_fn)
- }
+ -- deal with stubs
+ maybe_stub_o <- compileStub dyn_flags' stub_c_exists
+ case maybe_stub_o of
+ Nothing -> return ()
+ Just stub_o -> add v_Ld_inputs stub_o
+ case hscLang dyn_flags of
+ HscNothing -> return (Nothing, Just location, output_fn)
+ _ -> return (Just next_phase, Just location, output_fn)
+
+-----------------------------------------------------------------------------
+-- Cmm phase
+
+runPhase CmmCpp basename suff input_fn get_output_fn maybe_loc
+ = do
+ output_fn <- get_output_fn Cmm maybe_loc
+ doCpp False{-not raw-} True{-include CC opts-} input_fn output_fn
+ return (Just Cmm, maybe_loc, output_fn)
+
+runPhase Cmm basename suff input_fn get_output_fn maybe_loc
+ = do
+ dyn_flags <- getDynFlags
+ hsc_lang <- hscMaybeAdjustLang (hscLang dyn_flags)
+ next_phase <- hscNextPhase hsc_lang
+ output_fn <- get_output_fn next_phase maybe_loc
+
+ let dyn_flags' = dyn_flags { hscLang = hsc_lang,
+ hscOutName = output_fn,
+ hscStubCOutName = basename ++ "_stub.c",
+ hscStubHOutName = basename ++ "_stub.h",
+ extCoreName = basename ++ ".hcr" }
+
+ ok <- hscCmmFile dyn_flags' input_fn
+
+ when (not ok) $ throwDyn (PhaseFailed "cmm" (ExitFailure 1))
+
+ return (Just next_phase, maybe_loc, output_fn)
-----------------------------------------------------------------------------
-- Cc phase
-- we don't support preprocessing .c files (with -E) now. Doing so introduces
-- way too many hacks, and I can't say I've ever used it anyway.
-run_phase cc_phase basename suff input_fn output_fn
+runPhase cc_phase basename suff input_fn get_output_fn maybe_loc
| cc_phase == Cc || cc_phase == HCc
- = do cc_opts <- getOpts opt_c
+ = do cc_opts <- getOpts opt_c
cmdline_include_paths <- readIORef v_Include_paths
+ split <- readIORef v_Split_object_files
+ mangle <- readIORef v_Do_asm_mangling
+
let hcc = cc_phase == HCc
+ next_phase
+ | hcc && mangle = Mangle
+ | otherwise = As
+
+ output_fn <- get_output_fn next_phase maybe_loc
+
-- HC files have the dependent packages stamped into them
pkgs <- if hcc then getHCFilePackages input_fn else return []
verb <- getVerbFlag
- o2 <- readIORef v_minus_o2_for_C
- let opt_flag | o2 = "-O2"
- | otherwise = "-O"
-
pkg_extra_cc_opts <- getPackageExtraCcOpts pkgs
split_objs <- readIORef v_Split_object_files
++ (if cc_phase == HCc && mangle
then md_regd_c_flags
else [])
- ++ [ verb, "-S", "-Wimplicit", opt_flag ]
+ ++ [ verb, "-S", "-Wimplicit", "-O" ]
++ [ "-D__GLASGOW_HASKELL__="++cProjectVersionInt ]
++ cc_opts
++ split_opt
++ include_paths
++ pkg_extra_cc_opts
))
- return (Just output_fn)
+
+ return (Just next_phase, maybe_loc, output_fn)
-- ToDo: postprocess the output from gcc
-----------------------------------------------------------------------------
-- Mangle phase
-run_phase Mangle _basename _suff input_fn output_fn
- = do mangler_opts <- getOpts opt_m
- machdep_opts <- if (prefixMatch "i386" cTARGETPLATFORM)
- then do n_regs <- dynFlag stolen_x86_regs
- return [ show n_regs ]
- else return []
+runPhase Mangle _basename _suff input_fn get_output_fn maybe_loc
+ = do mangler_opts <- getOpts opt_m
+ machdep_opts <- if (prefixMatch "i386" cTARGETPLATFORM)
+ then do n_regs <- dynFlag stolen_x86_regs
+ return [ show n_regs ]
+ else return []
- SysTools.runMangle (map SysTools.Option mangler_opts
+ split <- readIORef v_Split_object_files
+ let next_phase
+ | split = SplitMangle
+ | otherwise = As
+ output_fn <- get_output_fn next_phase maybe_loc
+
+ SysTools.runMangle (map SysTools.Option mangler_opts
++ [ SysTools.FileOption "" input_fn
, SysTools.FileOption "" output_fn
]
++ map SysTools.Option machdep_opts)
- return (Just output_fn)
+
+ return (Just next_phase, maybe_loc, output_fn)
-----------------------------------------------------------------------------
-- Splitting phase
-run_phase SplitMangle _basename _suff input_fn output_fn
+runPhase SplitMangle _basename _suff input_fn get_output_fn maybe_loc
= do -- tmp_pfx is the prefix used for the split .s files
-- We also use it as the file to contain the no. of split .s files (sigh)
split_s_prefix <- SysTools.newTempName "split"
addFilesToClean [ split_s_prefix ++ "__" ++ show n ++ ".s"
| n <- [1..n_files]]
- return (Just output_fn)
+ return (Just SplitAs, maybe_loc, "**splitmangle**")
+ -- we don't use the filename
-----------------------------------------------------------------------------
-- As phase
-run_phase As _basename _suff input_fn output_fn
+runPhase As _basename _suff input_fn get_output_fn maybe_loc
= do as_opts <- getOpts opt_a
cmdline_include_paths <- readIORef v_Include_paths
+ output_fn <- get_output_fn Ln maybe_loc
+
+ -- we create directories for the object file, because it
+ -- might be a hierarchical module.
+ createDirectoryHierarchy (directoryOf output_fn)
+
SysTools.runAs (map SysTools.Option as_opts
++ [ SysTools.Option ("-I" ++ p) | p <- cmdline_include_paths ]
++ [ SysTools.Option "-c"
, SysTools.Option "-o"
, SysTools.FileOption "" output_fn
])
- return (Just output_fn)
-run_phase SplitAs basename _suff _input_fn output_fn
+ return (Just Ln, maybe_loc, output_fn)
+
+
+runPhase SplitAs basename _suff _input_fn get_output_fn maybe_loc
= do as_opts <- getOpts opt_a
(split_s_prefix, n) <- readIORef v_Split_info
])
mapM_ assemble_file [1..n]
- return (Just output_fn)
+
+ output_fn <- get_output_fn Ln maybe_loc
+ return (Just Ln, maybe_loc, output_fn)
#ifdef ILX
-----------------------------------------------------------------------------
-- Ilx2Il phase
-- Run ilx2il over the ILX output, getting an IL file
-run_phase Ilx2Il _basename _suff input_fn output_fn
+runPhase Ilx2Il _basename _suff input_fn get_output_fn maybe_loc
= do ilx2il_opts <- getOpts opt_I
SysTools.runIlx2il (map SysTools.Option ilx2il_opts
++ [ SysTools.Option "--no-add-suffix-to-assembly",
SysTools.Option "-o",
SysTools.FileOption "" output_fn,
SysTools.FileOption "" input_fn ])
- return (Just output_fn)
+ return True
-----------------------------------------------------------------------------
-- Ilasm phase
-- Run ilasm over the IL, getting a DLL
-run_phase Ilasm _basename _suff input_fn output_fn
+runPhase Ilasm _basename _suff input_fn get_output_fn maybe_loc
= do ilasm_opts <- getOpts opt_i
SysTools.runIlasm (map SysTools.Option ilasm_opts
++ [ SysTools.Option "/QUIET",
SysTools.Option "/DLL",
SysTools.FileOption "/OUT=" output_fn,
SysTools.FileOption "" input_fn ])
- return (Just output_fn)
+ return True
-#endif -- ILX
+#endif /* ILX */
-----------------------------------------------------------------------------
-- MoveBinary sort-of-phase
-- we don't need the generality of a phase (MoveBinary is always
-- done after linking and makes only sense in a parallel setup) -- HWL
-run_phase_MoveBinary input_fn
+runPhase_MoveBinary input_fn
= do
sysMan <- getSysMan
pvm_root <- getEnv "PVM_ROOT"
-- dependencies, and eliminating duplicates.
o_file <- readIORef v_Output_file
+#if defined(mingw32_HOST_OS)
+ let output_fn = case o_file of { Just s -> s; Nothing -> "main.exe"; }
+#else
let output_fn = case o_file of { Just s -> s; Nothing -> "a.out"; }
+#endif
pkg_lib_paths <- getPackageLibraryPath dep_packages
let pkg_lib_path_opts = map ("-L"++) pkg_lib_paths
let framework_path_opts = map ("-F"++) framework_paths
pkg_frameworks <- getPackageFrameworks dep_packages
- let pkg_framework_opts = map ("-framework " ++) pkg_frameworks
+ 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
[rts_pkg, std_pkg] <- getPackageDetails [rtsPackage, basePackage]
+ ways <- readIORef v_Ways
+
+ -- Here are some libs that need to be linked at the *end* of
+ -- the command line, because they contain symbols that are referred to
+ -- by the RTS. We can't therefore use the ordinary way opts for these.
+ let
+ debug_opts | WayDebug `elem` ways = [
+#if defined(HAVE_LIBBFD)
+ "-lbfd", "-liberty"
+#endif
+ ]
+ | otherwise = []
+
+ let
+ thread_opts | WayThreaded `elem` ways = [
+#if !defined(mingw32_TARGET_OS) && !defined(freebsd_TARGET_OS)
+ "-lpthread"
+#endif
+#if defined(osf3_TARGET_OS)
+ , "-lexc"
+#endif
+ ]
+ | otherwise = []
+
let extra_os = if static || no_hs_main
then []
else [ head (library_dirs rts_pkg) ++ "/Main.dll_o",
++ pkg_framework_path_opts
++ pkg_framework_opts
#endif
- ++ if static && not no_hs_main then
- [ "-u", prefixUnderscore "Main_zdmain_closure"]
- else []))
+ ++ debug_opts
+ ++ thread_opts
+ ))
-- parallel only: move binary to another dir -- HWL
ways_ <- readIORef v_Ways
when (WayPar `elem` ways_)
- (do success <- run_phase_MoveBinary output_fn
+ (do success <- runPhase_MoveBinary output_fn
if success then return ()
else throwDyn (InstallationError ("cannot move binary to PVM dir")))
-----------------------------------------------------------------------------
-- Making a DLL (only for Win32)
-doMkDLL :: [String] -> IO ()
-doMkDLL o_files = do
+doMkDLL :: [String] -> [PackageName] -> IO ()
+doMkDLL o_files dep_packages = do
verb <- getVerbFlag
static <- readIORef v_Static
no_hs_main <- readIORef v_NoHsMain
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 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_link_opts <- getPackageLinkOpts []
+ pkg_link_opts <- getPackageLinkOpts dep_packages
-- probably _stub.o files
extra_ld_inputs <- readIORef v_Ld_inputs
then [ "" ]
else [ "--export-all" ])
))
+
+-- -----------------------------------------------------------------------------
+-- Misc.
+
+doCpp :: Bool -> Bool -> FilePath -> FilePath -> IO ()
+doCpp raw include_cc_opts input_fn output_fn = do
+ hscpp_opts <- getOpts opt_P
+
+ cmdline_include_paths <- readIORef v_Include_paths
+
+ pkg_include_dirs <- getPackageIncludePath []
+ let include_paths = foldr (\ x xs -> "-I" : x : xs) []
+ (cmdline_include_paths ++ pkg_include_dirs)
+
+ verb <- getVerbFlag
+
+ cc_opts <- if not include_cc_opts
+ then return []
+ else do optc <- getOpts opt_c
+ (md_c_flags, _) <- machdepCCOpts
+ return (optc ++ md_c_flags)
+
+ let cpp_prog args | raw = SysTools.runCpp args
+ | otherwise = SysTools.runCc (SysTools.Option "-E" : args)
+
+ let target_defs =
+ [ "-D" ++ cTARGETOS ++ "_TARGET_OS=1",
+ "-D" ++ cTARGETARCH ++ "_TARGET_ARCH=1" ]
+
+ cpp_prog ([SysTools.Option verb]
+ ++ map SysTools.Option include_paths
+ ++ map SysTools.Option hsSourceCppOpts
+ ++ map SysTools.Option hscpp_opts
+ ++ map SysTools.Option cc_opts
+ ++ map SysTools.Option target_defs
+ ++ [ SysTools.Option "-x"
+ , SysTools.Option "c"
+ , SysTools.Option input_fn
+ -- We hackily use Option instead of FileOption here, so that the file
+ -- name is not back-slashed on Windows. cpp is capable of
+ -- dealing with / in filenames, so it works fine. Furthermore
+ -- if we put in backslashes, cpp outputs #line directives
+ -- with *double* backslashes. And that in turn means that
+ -- our error messages get double backslashes in them.
+ -- In due course we should arrange that the lexer deals
+ -- with these \\ escapes properly.
+ , SysTools.Option "-o"
+ , SysTools.FileOption "" output_fn
+ ])
+
+-- -----------------------------------------------------------------------------
+-- Misc.
+
+hscNextPhase :: HscLang -> IO Phase
+hscNextPhase hsc_lang = do
+ split <- readIORef v_Split_object_files
+ return (case hsc_lang of
+ HscC -> HCc
+ HscAsm | split -> SplitMangle
+ | otherwise -> As
+ HscNothing -> HCc -- dummy (no output will be generated)
+ HscInterpreted -> HCc -- "" ""
+ _other -> HCc -- "" ""
+ )
+
+hscMaybeAdjustLang :: HscLang -> IO HscLang
+hscMaybeAdjustLang current_hsc_lang = do
+ todo <- readIORef v_GhcMode
+ keep_hc <- readIORef v_Keep_hc_files
+ let hsc_lang
+ -- don't change the lang if we're interpreting
+ | current_hsc_lang == HscInterpreted = current_hsc_lang
+ -- force -fvia-C if we are being asked for a .hc file
+ | todo == StopBefore HCc || keep_hc = HscC
+ -- otherwise, stick to the plan
+ | otherwise = current_hsc_lang
+ return hsc_lang
projects / ghc-hetmet.git / blobdiff