import CmTypes
import HscTypes
import Module ( Module, ModuleName, moduleName, isHomeModule,
- mkHomeModule, mkModuleName, moduleNameUserString )
+ mkModuleName, moduleNameUserString )
import CmStaticInfo ( GhciMode(..) )
import DriverPipeline
import GetImports
import Outputable
import Panic
import CmdLineOpts ( DynFlags(..) )
+import IOExts
#ifdef GHCI
import Interpreter ( HValue )
import IO
import Monad
import List ( nub )
-import Maybe ( catMaybes, fromMaybe, maybeToList )
+import Maybe ( catMaybes, fromMaybe, isJust )
\end{code}
#ifdef GHCI
cmGetExpr :: CmState
-> DynFlags
- -> ModuleName
+ -> Bool -- True <=> wrap in 'print' to get an IO-typed result
+ -> Module
-> String
- -> Bool
-> IO (CmState, Maybe (HValue, PrintUnqualified, Type))
-cmGetExpr cmstate dflags modname expr wrap_print
+cmGetExpr cmstate dflags wrap_io mod expr
= do (new_pcs, maybe_stuff) <-
- hscExpr dflags hst hit pcs (mkHomeModule modname) expr wrap_print
+ hscExpr dflags wrap_io hst hit pcs mod expr
case maybe_stuff of
Nothing -> return (cmstate{ pcs=new_pcs }, Nothing)
Just (bcos, print_unqual, ty) -> do
-- ToDo: check that the module we passed in is sane/exists?
where
- CmState{ pcs=pcs, pcms=pcms, pls=pls } = cmstate
- PersistentCMState{ hst=hst, hit=hit } = pcms
+ CmState{ hst=hst, hit=hit, pcs=pcs, pls=pls } = cmstate
-- The HValue should represent a value of type IO () (Perhaps IO a?)
cmRunExpr :: HValue -> IO ()
-- putStrLn "done."
#endif
--- Persistent state just for CM, excluding link & compile subsystems
-data PersistentCMState
- = PersistentCMState {
- hst :: HomeSymbolTable, -- home symbol table
- hit :: HomeIfaceTable, -- home interface table
- ui :: UnlinkedImage, -- the unlinked images
- mg :: ModuleGraph, -- the module graph
- gmode :: GhciMode -- NEVER CHANGES
- }
-
-emptyPCMS :: GhciMode -> PersistentCMState
-emptyPCMS gmode
- = PersistentCMState { hst = emptyHST, hit = emptyHIT,
- ui = emptyUI, mg = emptyMG,
- gmode = gmode }
-
emptyHIT :: HomeIfaceTable
emptyHIT = emptyUFM
emptyHST :: HomeSymbolTable
emptyHST = emptyUFM
-
-
-- Persistent state for the entire system
data CmState
= CmState {
- pcms :: PersistentCMState, -- CM's persistent state
+ hst :: HomeSymbolTable, -- home symbol table
+ hit :: HomeIfaceTable, -- home interface table
+ ui :: UnlinkedImage, -- the unlinked images
+ mg :: ModuleGraph, -- the module graph
+ gmode :: GhciMode, -- NEVER CHANGES
+
pcs :: PersistentCompilerState, -- compile's persistent state
pls :: PersistentLinkerState -- link's persistent state
}
emptyCmState :: GhciMode -> IO CmState
emptyCmState gmode
- = do let pcms = emptyPCMS gmode
- pcs <- initPersistentCompilerState
+ = do pcs <- initPersistentCompilerState
pls <- emptyPLS
- return (CmState { pcms = pcms,
+ return (CmState { hst = emptyHST,
+ hit = emptyHIT,
+ ui = emptyUI,
+ mg = emptyMG,
+ gmode = gmode,
pcs = pcs,
pls = pls })
= do -- Throw away the old home dir cache
emptyHomeDirCache
-- Throw away the HIT and the HST
- return state{ pcms=pcms{ hst=new_hst, hit=new_hit } }
+ return state{ hst=new_hst, hit=new_hit, ui=emptyUI }
where
- CmState{ pcms=pcms } = state
- PersistentCMState{ hst=hst, hit=hit } = pcms
- (new_hst, new_hit,[]) = retainInTopLevelEnvs [] (hst,hit,[])
+ CmState{ hst=hst, hit=hit } = state
+ (new_hst, new_hit) = retainInTopLevelEnvs [] (hst,hit)
\end{code}
The real business of the compilation manager: given a system state and
-> FilePath
-> IO (CmState, -- new state
Bool, -- was successful
- [ModuleName]) -- list of modules loaded
+ [Module]) -- list of modules loaded
cmLoadModule cmstate1 rootname
= do -- version 1's are the original, before downsweep
- let pcms1 = pcms cmstate1
let pls1 = pls cmstate1
let pcs1 = pcs cmstate1
- -- mg1 is the complete (home) set of summaries from the
- -- previous pass of cmLoadModule, if there was one.
- let mg1 = mg pcms1
- let hst1 = hst pcms1
- let hit1 = hit pcms1
+ let hst1 = hst cmstate1
+ let hit1 = hit cmstate1
-- similarly, ui1 is the (complete) set of linkables from
-- the previous pass, if any.
- let ui1 = ui pcms1
+ let ui1 = ui cmstate1
- let ghci_mode = gmode pcms1 -- this never changes
+ let ghci_mode = gmode cmstate1 -- this never changes
-- Do the downsweep to reestablish the module graph
-- then generate version 2's by retaining in HIT,HST,UI a
-- reachable_from follows source as well as normal imports
let reachable_from :: ModuleName -> [ModuleName]
reachable_from = downwards_closure_of_module mg2unsorted
-
+
-- should be cycle free; ignores 'import source's
let mg2 = topological_sort False mg2unsorted
-- ... whereas this takes them into account. Used for
-- not in strict downwards closure, during calls to compile.
let mg2_with_srcimps = topological_sort True mg2unsorted
+ -- Sort out which linkables we wish to keep in the unlinked image.
+ -- For each module, we take:
+ --
+ -- - the old in-core linkable, if available
+ -- - an on-disk linkable, if available
+ --
+ -- and we take the youngest of these, provided it is younger than the
+ -- source file.
+ --
+ -- If a module has a valid linkable, then it may be STABLE (see below),
+ -- and it is classified as SOURCE UNCHANGED for the purposes of calling
+ -- compile.
+ valid_linkables <- getValidLinkables ui1 mg2unsorted
+
-- Figure out a stable set of modules which can be retained
-- the top level envs, to avoid upsweeping them. Goes to a
-- bit of trouble to avoid upsweeping module cycles.
-- Travel upwards, over the sccified graph. For each scc
-- of modules ms, add ms to S only if:
-- 1. All home imports of ms are either in ms or S
- -- 2. All m <- ms satisfy P, where
- -- P | interactive = have old summary for m and it indicates
- -- that the source is unchanged
- -- | batch = linkable exists on disk, and is younger
- -- than source.
+ -- 2. A valid linkable exists for each module in ms
+
+ stable_mods
+ <- preUpsweep valid_linkables mg2unsorted_names [] mg2_with_srcimps
- (stable_mods, linkables_for_stable_mods)
- <- preUpsweep ghci_mode ui1 mg1 mg2unsorted_names [] [] mg2_with_srcimps
- let stable_old_summaries
- = concatMap (findInSummaries mg1) stable_mods
+ let stable_summaries
+ = concatMap (findInSummaries mg2unsorted) stable_mods
when (verb >= 2) $
putStrLn (showSDoc (text "STABLE MODULES:"
<+> sep (map (text.moduleNameUserString) stable_mods)))
-
- let (hst2, hit2, [])
- = retainInTopLevelEnvs stable_mods (hst1, hit1, [])
- ui2
- = linkables_for_stable_mods
-
- -- Now hst2, hit2, ui2 now hold the 'reduced system', just the set of
- -- modules which are stable.
-
-- We could at this point detect cycles which aren't broken by
- -- a source-import, and complain immediately, but it seems better
- -- to let upsweep_mods do this, so at least some useful work gets
+ -- a source-import, and complain immediately, but it seems better
+ -- to let upsweep_mods do this, so at least some useful work gets
-- done before the upsweep is abandoned.
let upsweep_these
= filter (\scc -> any (`notElem` stable_mods)
-- Now do the upsweep, calling compile for each module in
-- turn. Final result is version 3 of everything.
- let threaded2 = CmThreaded pcs1 hst2 hit2
+ let threaded2 = CmThreaded pcs1 hst1 hit1
(upsweep_complete_success, threaded3, modsUpswept, newLis)
- <- upsweep_mods ghci_mode dflags ui2 reachable_from
+ <- upsweep_mods ghci_mode dflags valid_linkables reachable_from
threaded2 upsweep_these
- let ui3 = add_to_ui ui2 newLis
+ let ui3 = add_to_ui valid_linkables newLis
let (CmThreaded pcs3 hst3 hit3) = threaded3
-- At this point, modsUpswept and newLis should have the same
-- with some object on disk ???)
-- Get in in a roughly top .. bottom order (hence reverse).
- let modsDone = reverse modsUpswept ++ stable_old_summaries
+ let modsDone = reverse modsUpswept ++ stable_summaries
-- Try and do linking in some form, depending on whether the
-- upsweep was completely or only partially successful.
LinkErrs _ _
-> panic "cmLoadModule: link failed (1)"
LinkOK pls3
- -> do let pcms3 = PersistentCMState { hst=hst3, hit=hit3,
- ui=ui3, mg=modsDone,
- gmode=ghci_mode }
- let cmstate3
- = CmState { pcms=pcms3, pcs=pcs3, pls=pls3 }
+ -> do let cmstate3
+ = CmState { hst=hst3, hit=hit3,
+ ui=ui3, mg=modsDone,
+ gmode=ghci_mode,
+ pcs=pcs3, pls=pls3 }
return (cmstate3, True,
- map name_of_summary modsDone)
+ map ms_mod modsDone)
else
-- Tricky. We need to back out the effects of compiling any
LinkErrs _ _
-> panic "cmLoadModule: link failed (2)"
LinkOK pls4
- -> do let pcms4 = PersistentCMState { hst=hst4, hit=hit4,
- ui=ui4, mg=mods_to_keep,
- gmode=ghci_mode }
- let cmstate4
- = CmState { pcms=pcms4, pcs=pcs3, pls=pls4 }
+ -> do let cmstate4
+ = CmState { hst=hst4, hit=hit4,
+ ui=ui4, mg=mods_to_keep,
+ gmode=ghci_mode, pcs=pcs3, pls=pls4 }
return (cmstate4, False,
- mods_to_keep_names)
+ map ms_mod mods_to_keep)
+
+
+-----------------------------------------------------------------------------
+-- getValidLinkables
+
+getValidLinkables
+ :: [Linkable] -- old linkables
+ -> [ModSummary] -- all modules in the program
+ -> IO [Linkable] -- still-valid linkables
+getValidLinkables old_linkables summaries
+ = do lis <- mapM (getValidLinkable old_linkables) summaries
+ return (concat lis)
+
+getValidLinkable old_linkables summary
+ = do let mod_name = moduleName (ms_mod summary)
+ maybe_disk_linkable
+ <- case ml_obj_file (ms_location summary) of
+ Nothing -> return Nothing
+ Just obj_fn -> maybe_getFileLinkable mod_name obj_fn
+
+ -- find an old in-core linkable if we have one. (forget about
+ -- on-disk linkables for now, we'll check again whether there's
+ -- one here below, just in case a new one has popped up recently).
+ let old_linkable = findModuleLinkable_maybe old_linkables mod_name
+ maybe_old_linkable =
+ case old_linkable of
+ Just (LM _ _ ls) | all isInterpretable ls -> old_linkable
+ _ -> Nothing
+
+ -- The most recent of the old UI linkable or whatever we could
+ -- find on disk is returned as the linkable if compile
+ -- doesn't think we need to recompile.
+ let linkable_list
+ = case (maybe_old_linkable, maybe_disk_linkable) of
+ (Nothing, Nothing) -> []
+ (Nothing, Just di) -> [di]
+ (Just ui, Nothing) -> [ui]
+ (Just ui, Just di)
+ | linkableTime ui >= linkableTime di -> [ui]
+ | otherwise -> [di]
+ -- only linkables newer than the source code are valid
+ let maybe_src_date = ms_hs_date summary
+ valid_linkable_list
+ = case maybe_src_date of
+ Nothing -> panic "valid_linkable_list"
+ Just src_date
+ -> filter (\li -> linkableTime li > src_date) linkable_list
+
+ return valid_linkable_list
+
+
+
+maybe_getFileLinkable :: ModuleName -> FilePath -> IO (Maybe Linkable)
+maybe_getFileLinkable mod_name obj_fn
+ = do obj_exist <- doesFileExist obj_fn
+ if not obj_exist
+ then return Nothing
+ else
+ do let stub_fn = case splitFilename3 obj_fn of
+ (dir, base, ext) -> dir ++ "/" ++ base ++ ".stub_o"
+ stub_exist <- doesFileExist stub_fn
+ obj_time <- getModificationTime obj_fn
+ if stub_exist
+ then return (Just (LM obj_time mod_name [DotO obj_fn, DotO stub_fn]))
+ else return (Just (LM obj_time mod_name [DotO obj_fn]))
+
+
+-----------------------------------------------------------------------------
-- Do a pre-upsweep without use of "compile", to establish a
-- (downward-closed) set of stable modules which can be retained
-- in the top-level environments. Also return linkables for those
-- modules determined to be stable, since (in Batch mode, at least)
-- there's no other way for them to get into UI.
-preUpsweep :: GhciMode
- -> [Linkable] -- linkables from previous cmLoadModule pass
- -- should be [] in batch mode
- -> [ModSummary] -- summaries from previous cmLoadModule pass
- -- should be [] in batch mode
+
+preUpsweep :: [Linkable] -- valid linkables
-> [ModuleName] -- names of all mods encountered in downsweep
-> [ModuleName] -- accumulating stable modules
- -> [Linkable] -- their linkables, in batch mode
-> [SCC ModSummary] -- scc-ified mod graph, including src imps
- -> IO ([ModuleName], [Linkable])
- -- stable modules and their linkables
+ -> IO [ModuleName] -- stable modules
-preUpsweep ghci_mode old_lis old_summaries all_home_mods stable lis []
- = return (stable, lis)
-preUpsweep ghci_mode old_lis old_summaries all_home_mods stable lis (scc0:sccs)
+preUpsweep valid_lis all_home_mods stable []
+ = return stable
+preUpsweep valid_lis all_home_mods stable (scc0:sccs)
= do let scc = flattenSCC scc0
scc_allhomeimps :: [ModuleName]
scc_allhomeimps
= --trace (showSDoc (text "ISOS" <+> ppr m <+> ppr scc_names <+> ppr stable)) (
m `elem` scc_names || m `elem` stable
--)
- (all_scc_stable, more_lis)
+ all_scc_stable
<- if not all_imports_in_scc_or_stable
then do --putStrLn ("PART1 fail " ++ showSDoc (ppr scc_allhomeimps <+> ppr (filter (not.in_stable_or_scc) scc_allhomeimps)))
- return (False, [])
- else do bools_n_lis
- <- mapM (is_stable ghci_mode old_lis old_summaries) scc
- let (bools, liss) = unzip bools_n_lis
- --when (not (and bools)) (putStrLn ("PART2 fail: " ++ showSDoc (ppr scc_names)))
- return (and bools, concat liss)
+ return False
+ else do --when (not (and bools)) (putStrLn ("PART2 fail: " ++ showSDoc (ppr scc_names)))
+ return (all is_stable scc)
if not all_scc_stable
- then preUpsweep ghci_mode old_lis old_summaries all_home_mods stable lis sccs
- else preUpsweep ghci_mode old_lis old_summaries all_home_mods
- (scc_names++stable) (more_lis++lis) sccs
+ then preUpsweep valid_lis all_home_mods stable sccs
+ else preUpsweep valid_lis all_home_mods (scc_names++stable) sccs
+
+ where is_stable new_summary
+ = isJust (findModuleLinkable_maybe valid_lis (name_of_summary new_summary))
-- Helper for preUpsweep. Assuming that new_summary's imports are all
findInSummaries old_summaries mod_name
= [s | s <- old_summaries, name_of_summary s == mod_name]
-is_stable :: GhciMode
- -> [Linkable] -> [ModSummary] -- OLD lis and summs, in Interactive mode
- -> ModSummary -- this module
- -> IO (Bool, [Linkable])
-
-is_stable Interactive old_lis old_summaries new_summary
- -- Only true if the old summary exists and
- -- the new source date matches the old one.
- = case found_old_summarys of
- [] -> return (False, old_linkable)
- (old_summary:_)
- -> case (ms_hs_date new_summary, ms_hs_date old_summary) of
- (Just d1, Just d2) -> return (d1 == d2, old_linkable)
- (_, _ ) -> return (False, old_linkable)
- where
- old_linkable
- = maybeToList
- (findModuleLinkable_maybe old_lis (name_of_summary new_summary))
- found_old_summarys
- = findInSummaries old_summaries (name_of_summary new_summary)
-
-is_stable Batch [] [] new_summary
- -- Only true if we can find a linkable, and it is younger than
- -- the source time.
- = case ms_hs_date new_summary of
- Nothing -> return (False, []) -- no source date (?!)
- Just hs_time
- -> case ml_obj_file (ms_location new_summary) of
- Nothing -> return (False, []) -- no obj filename
- Just fn
- -> do maybe_li <- maybe_getFileLinkable
- (moduleName (ms_mod new_summary)) fn
- case maybe_li of
- Nothing -> return (False, []) -- no object file on disk
- Just li -> return (linkableTime li >= hs_time, [li])
-
-
-- Return (names of) all those in modsDone who are part of a cycle
-- as defined by theGraph.
else chewed_rest
--- Does this ModDetails export Main.main?
---exports_main :: ModDetails -> Bool
---exports_main md
--- = isJust (lookupNameEnv (md_types md) mainName)
-
-
-- Add the given (LM-form) Linkables to the UI, overwriting previous
-- versions if they exist.
add_to_ui :: UnlinkedImage -> [Linkable] -> UnlinkedImage
add_to_ui ui lis
- = foldr add1 ui lis
+ = filter (not_in lis) ui ++ lis
where
- add1 :: Linkable -> UnlinkedImage -> UnlinkedImage
- add1 li ui
- = li : filter (\li2 -> not (for_same_module li li2)) ui
-
- for_same_module :: Linkable -> Linkable -> Bool
- for_same_module li1 li2
- = not (is_package_linkable li1)
- && not (is_package_linkable li2)
- && modname_of_linkable li1 == modname_of_linkable li2
+ not_in :: [Linkable] -> Linkable -> Bool
+ not_in lis li
+ = all (\l -> modname_of_linkable l /= mod) lis
+ where mod = modname_of_linkable li
data CmThreaded -- stuff threaded through individual module compilations
-- There better had not be any cyclic groups here -- we check for them.
upsweep_mods :: GhciMode
-> DynFlags
- -> UnlinkedImage -- old linkables
+ -> UnlinkedImage -- valid linkables
-> (ModuleName -> [ModuleName]) -- to construct downward closures
-> CmThreaded -- PCS & HST & HIT
-> [SCC ModSummary] -- mods to do (the worklist)
-- Compile a single module. Always produce a Linkable for it if
-- successful. If no compilation happened, return the old Linkable.
-maybe_getFileLinkable :: ModuleName -> FilePath -> IO (Maybe Linkable)
-maybe_getFileLinkable mod_name obj_fn
- = do obj_exist <- doesFileExist obj_fn
- if not obj_exist
- then return Nothing
- else
- do let stub_fn = case splitFilename3 obj_fn of
- (dir, base, ext) -> dir ++ "/" ++ base ++ ".stub_o"
- stub_exist <- doesFileExist stub_fn
- obj_time <- getModificationTime obj_fn
- if stub_exist
- then return (Just (LM obj_time mod_name [DotO obj_fn, DotO stub_fn]))
- else return (Just (LM obj_time mod_name [DotO obj_fn]))
-
-
upsweep_mod :: GhciMode
-> DynFlags
-> UnlinkedImage
let (CmThreaded pcs1 hst1 hit1) = threaded1
let old_iface = lookupUFM hit1 mod_name
- let maybe_oldUI_linkable = findModuleLinkable_maybe oldUI mod_name
- maybe_oldDisk_linkable
- <- case ml_obj_file (ms_location summary1) of
- Nothing -> return Nothing
- Just obj_fn -> maybe_getFileLinkable mod_name obj_fn
+ let maybe_old_linkable = findModuleLinkable_maybe oldUI mod_name
- -- The most recent of the old UI linkable or whatever we could
- -- find on disk. Is returned as the linkable if compile
- -- doesn't think we need to recompile.
- let maybe_old_linkable
- = case (maybe_oldUI_linkable, maybe_oldDisk_linkable) of
- (Nothing, Nothing) -> Nothing
- (Nothing, Just di) -> Just di
- (Just ui, Nothing) -> Just ui
- (Just ui, Just di)
- | linkableTime ui >= linkableTime di -> Just ui
- | otherwise -> Just di
-
- let compilation_mandatory
- = case maybe_old_linkable of
- Nothing -> True
- Just li -> case ms_hs_date summary1 of
- Nothing -> panic "compilation_mandatory:no src date"
- Just src_date -> src_date >= linkableTime li
- source_unchanged
- = not compilation_mandatory
-
- (hst1_strictDC, hit1_strictDC, [])
+ source_unchanged = isJust maybe_old_linkable
+
+ (hst1_strictDC, hit1_strictDC)
= retainInTopLevelEnvs
(filter (/= (name_of_summary summary1)) reachable_from_here)
- (hst1,hit1,[])
+ (hst1,hit1)
old_linkable
= unJust "upsweep_mod:old_linkable" maybe_old_linkable
else
return ()
- when (verb == 1) $ hPutStrLn stderr ""
return (threaded2, Just old_linkable)
-- Compilation really did happen, and succeeded. A new
hit2 = addToUFM hit1 mod_name new_iface
threaded2 = CmThreaded pcs2 hst2 hit2
- when (verb == 1) $ hPutStrLn stderr ""
return (threaded2, Just new_linkable)
-- Compilation failed. compile may still have updated
-- the PCS, tho.
CompErrs pcs2
-> do let threaded2 = CmThreaded pcs2 hst1 hit1
- when (verb == 1) $ hPutStrLn stderr ""
return (threaded2, Nothing)
-- Remove unwanted modules from the top level envs (HST, HIT, UI).
)
retainInTopLevelEnvs :: [ModuleName]
- -> (HomeSymbolTable, HomeIfaceTable, UnlinkedImage)
- -> (HomeSymbolTable, HomeIfaceTable, UnlinkedImage)
-retainInTopLevelEnvs keep_these (hst, hit, ui)
+ -> (HomeSymbolTable, HomeIfaceTable)
+ -> (HomeSymbolTable, HomeIfaceTable)
+retainInTopLevelEnvs keep_these (hst, hit)
= (retainInUFM hst keep_these,
- retainInUFM hit keep_these,
- filterModuleLinkables (`elem` keep_these) ui
+ retainInUFM hit keep_these
)
where
retainInUFM :: Uniquable key => UniqFM elt -> [key] -> UniqFM elt
projects / ghc-hetmet.git / blobdiff