--
-----------------------------------------------------------------------------
-{-# OPTIONS -w #-}
--- The above warning supression flag is a temporary kludge.
--- While working on this module you are encouraged to remove it and fix
--- any warnings in the module. See
--- http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#Warnings
--- for details
-
module DriverPipeline (
-- Run a series of compilation steps in a pipeline, for a
-- collection of source files.
-- Interfaces for the compilation manager (interpreted/batch-mode)
preprocess,
- compile, CompResult(..),
+ compile,
link,
) where
-- NB. No old interface can also mean that the source has changed.
compile :: HscEnv
- -> ModSummary
- -> Maybe Linkable -- Just linkable <=> source unchanged
- -> Maybe ModIface -- Old interface, if available
- -> Int -> Int
- -> IO CompResult
-
-data CompResult
- = CompOK ModDetails -- New details
- ModIface -- New iface
- (Maybe Linkable) -- a Maybe, for the same reasons as hm_linkable
-
- | CompErrs
-
-
-compile hsc_env mod_summary maybe_old_linkable old_iface mod_index nmods = do
-
- let dflags0 = ms_hspp_opts mod_summary
- this_mod = ms_mod mod_summary
- src_flavour = ms_hsc_src mod_summary
-
- have_object
- | Just l <- maybe_old_linkable, isObjectLinkable l = True
- | otherwise = False
-
- -- FIXME: We need to know whether or not we're recompiling the file. Move this to HscMain?
- --showPass dflags0 ("Compiling " ++ showModMsg have_object mod_summary)
-
- let location = ms_location mod_summary
- let input_fn = expectJust "compile:hs" (ml_hs_file location)
- let input_fnpp = ms_hspp_file mod_summary
+ -> ModSummary -- summary for module being compiled
+ -> Int -> Int -- module N of M
+ -> Maybe ModIface -- old interface, if we have one
+ -> Maybe Linkable -- old linkable, if we have one
+ -> IO (Maybe HomeModInfo) -- the complete HomeModInfo, if successful
+
+compile hsc_env summary mod_index nmods mb_old_iface maybe_old_linkable
+ = do
+ let dflags0 = ms_hspp_opts summary
+ this_mod = ms_mod summary
+ src_flavour = ms_hsc_src summary
+ location = ms_location summary
+ input_fn = expectJust "compile:hs" (ml_hs_file location)
+ input_fnpp = ms_hspp_file summary
debugTraceMsg dflags0 2 (text "compile: input file" <+> text input_fnpp)
= do stub_o <- compileStub dflags' this_mod location
return [ DotO stub_o ]
- handleBatch (HscNoRecomp, iface, details)
+ handleBatch HscNoRecomp
= ASSERT (isJust maybe_old_linkable)
- return (CompOK details iface maybe_old_linkable)
- handleBatch (HscRecomp hasStub, iface, details)
+ return maybe_old_linkable
+
+ handleBatch (HscRecomp hasStub)
| isHsBoot src_flavour
- = do SysTools.touch dflags' "Touching object file"
+ = do when (isObjectTarget hsc_lang) $ -- interpreted reaches here too
+ SysTools.touch dflags' "Touching object file"
object_filename
- return (CompOK details iface Nothing)
+ return maybe_old_linkable
+
| otherwise
= do stub_unlinked <- getStubLinkable hasStub
(hs_unlinked, unlinked_time) <-
case hsc_lang of
HscNothing
- -> return ([], ms_hs_date mod_summary)
+ -> return ([], ms_hs_date summary)
-- We're in --make mode: finish the compilation pipeline.
_other
-> do runPipeline StopLn dflags (output_fn,Nothing)
return ([DotO object_filename], o_time)
let linkable = LM unlinked_time this_mod
(hs_unlinked ++ stub_unlinked)
- return (CompOK details iface (Just linkable))
+ return (Just linkable)
- handleInterpreted (InteractiveNoRecomp, iface, details)
+ handleInterpreted InteractiveNoRecomp
= ASSERT (isJust maybe_old_linkable)
- return (CompOK details iface maybe_old_linkable)
- handleInterpreted (InteractiveRecomp hasStub comp_bc, iface, details)
+ return maybe_old_linkable
+ handleInterpreted (InteractiveRecomp hasStub comp_bc modBreaks)
= do stub_unlinked <- getStubLinkable hasStub
- let hs_unlinked = [BCOs comp_bc]
- unlinked_time = ms_hs_date mod_summary
+ let hs_unlinked = [BCOs comp_bc modBreaks]
+ unlinked_time = ms_hs_date summary
-- 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
-- be out of date.
let linkable = LM unlinked_time this_mod
(hs_unlinked ++ stub_unlinked)
- return (CompOK details iface (Just linkable))
+ return (Just linkable)
- let runCompiler compiler handle
- = do mbResult <- compiler hsc_env' mod_summary
- source_unchanged old_iface
+ let -- runCompiler :: Compiler result -> (result -> Maybe Linkable)
+ -- -> IO (Maybe HomeModInfo)
+ runCompiler compiler handle
+ = do mbResult <- compiler hsc_env' summary source_unchanged mb_old_iface
(Just (mod_index, nmods))
case mbResult of
- Nothing -> return CompErrs
- Just result -> handle result
+ Nothing -> return Nothing
+ Just (result, iface, details) -> do
+ linkable <- handle result
+ return (Just HomeModInfo{ hm_details = details,
+ hm_iface = iface,
+ hm_linkable = linkable })
-- run the compiler
case hsc_lang of
- HscInterpreted | not (isHsBoot src_flavour) -- We can't compile boot files to
- -- bytecode so don't even try.
- -> runCompiler hscCompileInteractive handleInterpreted
- HscNothing
- -> runCompiler hscCompileNothing handleBatch
- _other
- -> runCompiler hscCompileBatch handleBatch
+ HscInterpreted
+ | isHsBoot src_flavour ->
+ runCompiler hscCompileNothing handleBatch
+ | otherwise ->
+ runCompiler hscCompileInteractive handleInterpreted
+ HscNothing ->
+ runCompiler hscCompileNothing handleBatch
+ _other ->
+ runCompiler hscCompileBatch handleBatch
-----------------------------------------------------------------------------
-- stub .h and .c files (for foreign export support)
stub_o = o_base ++ "_stub" `joinFileExt` o_ext
-- compile the _stub.c file w/ gcc
- let (stub_c,_) = mkStubPaths dflags (moduleName mod) location
+ let (stub_c,_,_) = mkStubPaths dflags (moduleName mod) location
runPipeline StopLn dflags (stub_c,Nothing) Nothing
(SpecificFile stub_o) Nothing{-no ModLocation-}
-- ---------------------------------------------------------------------------
-- Link
-link :: GhcLink -- interactive or batch
- -> DynFlags -- dynamic flags
- -> Bool -- attempt linking in batch mode?
- -> HomePackageTable -- what to link
+link :: GhcLink -- 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
-- will succeed.
#ifdef GHCI
-link LinkInMemory dflags batch_attempt_linking hpt
+link LinkInMemory _ _ _
= do -- Not Linking...(demand linker will do the job)
- return Succeeded
+ return Succeeded
#endif
-link NoLink dflags batch_attempt_linking hpt
+link NoLink _ _ _
= return Succeeded
link LinkBinary dflags batch_attempt_linking hpt
| batch_attempt_linking
- = do
- let
- home_mod_infos = eltsUFM hpt
+ = do
+ let
+ home_mod_infos = eltsUFM hpt
- -- the packages we depend on
- pkg_deps = concatMap (dep_pkgs . mi_deps . hm_iface) home_mod_infos
+ -- the packages we depend on
+ pkg_deps = concatMap (dep_pkgs . mi_deps . hm_iface) home_mod_infos
- -- the linkables to link
- linkables = map (expectJust "link".hm_linkable) home_mod_infos
+ -- the linkables to link
+ linkables = map (expectJust "link".hm_linkable) home_mod_infos
debugTraceMsg dflags 3 (text "link: linkables are ..." $$ vcat (map ppr linkables))
- -- check for the -no-link flag
- if isNoLink (ghcLink dflags)
- then do debugTraceMsg dflags 3 (text "link(batch): linking omitted (-c flag given).")
- return Succeeded
- else do
-
- let getOfiles (LM _ _ us) = map nameOfObject (filter isObject us)
- obj_files = concatMap getOfiles linkables
-
- exe_file = exeFileName dflags
-
- -- if the modification time on the executable is later than the
- -- modification times on all of the objects, then omit linking
- -- (unless the -no-recomp flag was given).
- e_exe_time <- IO.try $ getModificationTime exe_file
- let linking_needed
- | Left _ <- e_exe_time = True
- | Right t <- e_exe_time =
- any (t <) (map linkableTime linkables)
-
- 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
-
- debugTraceMsg dflags 1 (ptext SLIT("Linking") <+> text exe_file
- <+> text "...")
-
- -- Don't showPass in Batch mode; doLink will do that for us.
- let link = case ghcLink dflags of
- LinkBinary -> linkBinary
- LinkDynLib -> linkDynLib
- link dflags obj_files pkg_deps
+ -- check for the -no-link flag
+ if isNoLink (ghcLink dflags)
+ then do debugTraceMsg dflags 3 (text "link(batch): linking omitted (-c flag given).")
+ return Succeeded
+ else do
+
+ let getOfiles (LM _ _ us) = map nameOfObject (filter isObject us)
+ obj_files = concatMap getOfiles linkables
+
+ exe_file = exeFileName dflags
+
+ -- if the modification time on the executable is later than the
+ -- modification times on all of the objects, then omit linking
+ -- (unless the -no-recomp flag was given).
+ e_exe_time <- IO.try $ getModificationTime exe_file
+ extra_ld_inputs <- readIORef v_Ld_inputs
+ extra_times <- mapM (IO.try . getModificationTime) extra_ld_inputs
+ let other_times = map linkableTime linkables
+ ++ [ t' | Right t' <- extra_times ]
+ linking_needed = case e_exe_time of
+ Left _ -> True
+ Right t -> any (t <) other_times
+
+ 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
+
+ debugTraceMsg dflags 1 (ptext SLIT("Linking") <+> text exe_file
+ <+> text "...")
+
+ -- Don't showPass in Batch mode; doLink will do that for us.
+ let link = case ghcLink dflags of
+ LinkBinary -> linkBinary
+ LinkDynLib -> linkDynLib
+ other -> panicBadLink other
+ link dflags obj_files pkg_deps
debugTraceMsg dflags 3 (text "link: done")
- -- linkBinary only returns if it succeeds
+ -- linkBinary only returns if it succeeds
return Succeeded
| otherwise
= do debugTraceMsg dflags 3 (text "link(batch): upsweep (partially) failed OR" $$
text " Main.main not exported; not linking.")
return Succeeded
-
+
+-- warning suppression
+link other _ _ _ = panicBadLink other
+
+panicBadLink :: GhcLink -> a
+panicBadLink other = panic ("link: GHC not built to link this way: " ++
+ show other)
-- -----------------------------------------------------------------------------
-- Compile files in one-shot mode.
stop_phase' = case stop_phase of
As | split -> SplitAs
- other -> stop_phase
+ _ -> stop_phase
(_, out_file) <- runPipeline stop_phase' dflags
(src, mb_phase) Nothing output
NoLink -> return ()
LinkBinary -> linkBinary dflags o_files link_pkgs
LinkDynLib -> linkDynLib dflags o_files []
+ other -> panicBadLink other
where
-- Always link in the haskell98 package for static linking. Other
-- packages have to be specified via the -package flag.
= 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
+ -- the .hs files resides) to the include path, since this is
-- what gcc does, and it's probably what you want.
let current_dir = directoryOf basename
; m <- getCoreModuleName input_fn
; return (Nothing, mkModuleName m, [], []) }
- other -> do { buf <- hGetStringBuffer input_fn
- ; (src_imps,imps,L _ mod_name) <- getImports dflags buf input_fn
+ _ -> do { buf <- hGetStringBuffer input_fn
+ ; (src_imps,imps,L _ mod_name) <- getImports dflags buf input_fn (basename `joinFileExt` suff)
; return (Just buf, mod_name, imps, src_imps) }
-- Build a ModLocation to pass to hscMain.
-- Make the ModSummary to hand to hscMain
let
- unused_field = panic "runPhase:ModSummary field"
- -- Some fields are not looked at by hscMain
mod_summary = ModSummary { ms_mod = mod,
ms_hsc_src = src_flavour,
ms_hspp_file = input_fn,
-----------------------------------------------------------------------------
-- Cmm phase
-runPhase CmmCpp stop dflags basename suff input_fn get_output_fn maybe_loc
+runPhase CmmCpp _stop dflags _basename _suff input_fn get_output_fn maybe_loc
= do
output_fn <- get_output_fn dflags Cmm maybe_loc
doCpp dflags False{-not raw-} True{-include CC opts-} input_fn output_fn
return (Cmm, dflags, maybe_loc, output_fn)
-runPhase Cmm stop dflags basename suff input_fn get_output_fn maybe_loc
+runPhase Cmm stop dflags basename _ input_fn get_output_fn maybe_loc
= do
let hsc_lang = hscMaybeAdjustTarget dflags stop HsSrcFile (hscTarget dflags)
let next_phase = hscNextPhase dflags HsSrcFile hsc_lang
-- 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.
-runPhase cc_phase stop dflags basename suff input_fn get_output_fn maybe_loc
+runPhase cc_phase _stop dflags _basename _suff input_fn get_output_fn maybe_loc
| 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
-----------------------------------------------------------------------------
-- Mangle phase
-runPhase Mangle stop dflags _basename _suff input_fn get_output_fn maybe_loc
+runPhase Mangle _stop dflags _basename _suff input_fn get_output_fn maybe_loc
= do let mangler_opts = getOpts dflags opt_m
#if i386_TARGET_ARCH
-----------------------------------------------------------------------------
-- Splitting phase
-runPhase SplitMangle stop dflags _basename _suff input_fn get_output_fn maybe_loc
+runPhase SplitMangle _stop dflags _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 dflags "split"
-----------------------------------------------------------------------------
-- As phase
-runPhase As stop dflags _basename _suff input_fn get_output_fn maybe_loc
+runPhase As _stop dflags _basename _suff input_fn get_output_fn maybe_loc
= do let as_opts = getOpts dflags opt_a
let cmdline_include_paths = includePaths dflags
return (StopLn, dflags, maybe_loc, output_fn)
-runPhase SplitAs stop dflags basename _suff _input_fn get_output_fn maybe_loc
+runPhase SplitAs _stop dflags _basename _suff _input_fn get_output_fn maybe_loc
= do
output_fn <- get_output_fn dflags StopLn maybe_loc
return (StopLn, dflags, maybe_loc, output_fn)
-
+-- warning suppression
+runPhase other _stop _dflags _basename _suff _input_fn _get_output_fn _maybe_loc =
+ panic ("runPhase: don't know how to run phase " ++ show other)
-----------------------------------------------------------------------------
-- MoveBinary sort-of-phase
-- After having produced a binary, move it somewhere else and generate a
-- we don't need the generality of a phase (MoveBinary is always
-- done after linking and makes only sense in a parallel setup) -- HWL
+runPhase_MoveBinary :: DynFlags -> FilePath -> IO Bool
runPhase_MoveBinary dflags input_fn
= do
let sysMan = pgm_sysman dflags
-----------------------------------------------------------------------------
-- Complain about non-dynamic flags in OPTIONS pragmas
+checkProcessArgsResult :: [String] -> FilePath -> IO ()
checkProcessArgsResult flags filename
= do when (notNull flags) (throwDyn (ProgramError (
showSDoc (hang (text filename <> char ':')
:: DynFlags
-> FilePath -- filename of executable
-> IO [FilePath] -- extra objects to embed, maybe
-maybeCreateManifest dflags exe_filename = do
#ifndef mingw32_TARGET_OS
+maybeCreateManifest _ _ = do
return []
#else
+maybeCreateManifest dflags exe_filename = do
if not (dopt Opt_GenManifest dflags) then return [] else do
let manifest_filename = exe_filename `joinFileExt` "manifest"
" </trustInfo>\n"++
"</assembly>\n"
- -- Windows will fine the manifest file if it is named foo.exe.manifest.
+ -- Windows will find the manifest file if it is named foo.exe.manifest.
-- However, for extra robustness, and so that we can move the binary around,
-- we can embed the manifest in the binary itself using windres:
if not (dopt Opt_EmbedManifest dflags) then return [] else do
rc_obj_filename <- newTempName dflags (objectSuf dflags)
writeFile rc_filename $
- "1 24 MOVEABLE PURE \"" ++ manifest_filename ++ "\"\n"
+ "1 24 MOVEABLE PURE " ++ show manifest_filename ++ "\n"
-- magic numbers :-)
+ -- show is a bit hackish above, but we need to escape the
+ -- backslashes in the path.
let wr_opts = getOpts dflags opt_windres
runWindres dflags $ map SysTools.Option $
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
pkg_lib_paths <- getPackageLibraryPath dflags dep_packages
, SysTools.Option "-o"
, SysTools.FileOption "" output_fn
, SysTools.Option "-shared"
- , SysTools.Option "-Wl,--export-all-symbols"
, SysTools.FileOption "-Wl,--out-implib=" (output_fn ++ ".a")
]
++ map (SysTools.FileOption "") o_files
, SysTools.FileOption "" output_fn
])
+cHaskell1Version :: String
cHaskell1Version = "5" -- i.e., Haskell 98
+hsSourceCppOpts :: [String]
-- Default CPP defines in Haskell source
hsSourceCppOpts =
[ "-D__HASKELL1__="++cHaskell1Version
-- Misc.
hscNextPhase :: DynFlags -> HscSource -> HscTarget -> Phase
-hscNextPhase dflags HsBootFile hsc_lang = StopLn
-hscNextPhase dflags other hsc_lang =
+hscNextPhase _ HsBootFile _ = StopLn
+hscNextPhase dflags _ hsc_lang =
case hsc_lang of
HscC -> HCc
HscAsm | dopt Opt_SplitObjs dflags -> SplitMangle
hscMaybeAdjustTarget :: DynFlags -> Phase -> HscSource -> HscTarget -> HscTarget
-hscMaybeAdjustTarget dflags stop other current_hsc_lang
+hscMaybeAdjustTarget dflags stop _ current_hsc_lang
= hsc_lang
where
keep_hc = dopt Opt_KeepHcFiles dflags
-- otherwise, stick to the plan
| otherwise = current_hsc_lang
+v_Split_info :: IORef (String, Int)
GLOBAL_VAR(v_Split_info, ("",0), (String,Int))
-- The split prefix and number of files
projects / ghc-hetmet.git / blobdiff