X-Git-Url: http://git.megacz.com/?p=ghc-hetmet.git;a=blobdiff_plain;f=compiler%2Fiface%2FMkIface.lhs;h=2aa614cde7816dac154852098bdc46c10a18b154;hp=a46e82374b977ce9d0ba0c546b18fb8f269f1888;hb=66579ff945831c5fc9a17c58c722ff01f2268d76;hpb=526c3af1dc98987b6949f4df73c0debccf9875bd diff --git a/compiler/iface/MkIface.lhs b/compiler/iface/MkIface.lhs index a46e823..2aa614c 100644 --- a/compiler/iface/MkIface.lhs +++ b/compiler/iface/MkIface.lhs @@ -1,5 +1,5 @@ % -% (c) The University of Glasgow 2006 +% (c) The University of Glasgow 2006-2008 % (c) The GRASP/AQUA Project, Glasgow University, 1993-1998 % @@ -22,28 +22,19 @@ module MkIface ( \end{code} ----------------------------------------------- - MkIface.lhs deals with versioning + Recompilation checking ----------------------------------------------- -Here's the fingerprint-related info in an interface file +A complete description of how recompilation checking works can be +found in the wiki commentary: - module Foo xxxxxxxxxxxxxxxx -- module fingerprint - yyyyyyyyyyyyyyyy -- export list fingerprint - zzzzzzzzzzzzzzzz -- rule fingerprint - Usages: -- Version info for what this compilation of Foo imported - Baz xxxxxxxxxxxxxxxx -- Module version - [yyyyyyyyyyyyyyyy] -- The export-list version - -- ( if Foo depended on it) - (g,zzzzzzzzzzzzzzzz) -- Function and its version - (T,wwwwwwwwwwwwwwww) -- Type and its version + http://hackage.haskell.org/trac/ghc/wiki/Commentary/Compiler/RecompilationAvoidance - f :: Int -> Int {- Unfolding: \x -> Wib.t x -} - - ----------------------------------------------- - Basic idea - ----------------------------------------------- +Please read the above page for a top-down description of how this all +works. Notes below cover specific issues related to the implementation. Basic idea: + * In the mi_usages information in an interface, we record the fingerprint of each free variable of the module @@ -56,128 +47,6 @@ Basic idea: * In checkOldIface we compare the mi_usages for the module with the actual fingerprint for all each thing recorded in mi_usages -Fixities -~~~~~~~~ -We count A.f as changing if its fixity changes - -Rules -~~~~~ -If a rule changes, we want to recompile any module that might be -affected by that rule. For non-orphan rules, this is relatively easy. -If module M defines f, and a rule for f, just arrange that the fingerprint -for M.f changes if any of the rules for M.f change. Any module -that does not depend on M.f can't be affected by the rule-change -either. - -Orphan rules (ones whose 'head function' is not defined in M) are -harder. Here's what we do. - - * We have a per-module orphan-rule fingerprint which changes if - any orphan rule changes. (It's unaffected by non-orphan rules.) - - * We record usage info for any orphan module 'below' this one, - giving the orphan-rule fingerprint. We recompile if this - changes. - -The net effect is that if an orphan rule changes, we recompile every -module above it. That's very conservative, but it's devilishly hard -to know what it might affect, so we just have to be conservative. - -Instance decls -~~~~~~~~~~~~~~ -In an iface file we have - module A where - instance Eq a => Eq [a] = dfun29 - dfun29 :: ... - -We have a fingerprint for dfun29, covering its unfolding -etc. Suppose we are compiling a module M that imports A only -indirectly. If typechecking M uses this instance decl, we record the -dependency on A.dfun29 as if it were a free variable of the module -(via the tcg_inst_usages accumulator). That means that A will appear -in M's usage list. If the shape of the instance declaration changes, -then so will dfun29's fingerprint, triggering a recompilation. - -Adding an instance declaration, or changing an instance decl that is -not currently used, is more tricky. (This really only makes a -difference when we have overlapping instance decls, because then the -new instance decl might kick in to override the old one.) We handle -this in a very similar way that we handle rules above. - - * For non-orphan instance decls, identify one locally-defined tycon/class - mentioned in the decl. Treat the instance decl as part of the defn of that - tycon/class, so that if the shape of the instance decl changes, so does the - tycon/class; that in turn will force recompilation of anything that uses - that tycon/class. - - * For orphan instance decls, act the same way as for orphan rules. - Indeed, we use the same global orphan-rule version number. - -mkUsageInfo -~~~~~~~~~~~ -mkUsageInfo figures out what the ``usage information'' for this -moudule is; that is, what it must record in its interface file as the -things it uses. - -We produce a line for every module B below the module, A, currently being -compiled: - import B ; -to record the fact that A does import B indirectly. This is used to decide -to look for B.hi rather than B.hi-boot when compiling a module that -imports A. This line says that A imports B, but uses nothing in it. -So we'll get an early bale-out when compiling A if B's fingerprint changes. - -The usage information records: - -\begin{itemize} -\item (a) anything reachable from its body code -\item (b) any module exported with a @module Foo@ -\item (c) anything reachable from an exported item -\end{itemize} - -Why (b)? Because if @Foo@ changes then this module's export list -will change, so we must recompile this module at least as far as -making a new interface file --- but in practice that means complete -recompilation. - -Why (c)? Consider this: -\begin{verbatim} - module A( f, g ) where | module B( f ) where - import B( f ) | f = h 3 - g = ... | h = ... -\end{verbatim} - -Here, @B.f@ isn't used in A. Should we nevertheless record @B.f@ in -@A@'s usages? Our idea is that we aren't going to touch A.hi if it is -*identical* to what it was before. If anything about @B.f@ changes -than anyone who imports @A@ should be recompiled in case they use -@B.f@ (they'll get an early exit if they don't). So, if anything -about @B.f@ changes we'd better make sure that something in A.hi -changes, and the convenient way to do that is to record the version -number @B.f@ in A.hi in the usage list. If B.f changes that'll force a -complete recompiation of A, which is overkill but it's the only way to -write a new, slightly different, A.hi. - -But the example is tricker. Even if @B.f@ doesn't change at all, -@B.h@ may do so, and this change may not be reflected in @f@'s version -number. But with -O, a module that imports A must be recompiled if -@B.h@ changes! So A must record a dependency on @B.h@. So we treat -the occurrence of @B.f@ in the export list *just as if* it were in the -code of A, and thereby haul in all the stuff reachable from it. - - *** Conclusion: if A mentions B.f in its export list, - behave just as if A mentioned B.f in its source code, - and slurp in B.f and all its transitive closure *** - -[NB: If B was compiled with -O, but A isn't, we should really *still* -haul in all the unfoldings for B, in case the module that imports A *is* -compiled with -O. I think this is the case.] - -SimonM [30/11/2007]: I believe the above is all out of date; the -current implementation doesn't do it this way. Instead, when any of -the dependencies of a declaration changes, the version of the -declaration itself changes. - \begin{code} #include "HsVersions.h" @@ -223,12 +92,14 @@ import Maybes import ListSetOps import Binary import Fingerprint +import Bag import Panic import Control.Monad import Data.List import Data.IORef import System.FilePath +import System.Exit ( exitWith, ExitCode(..) ) \end{code} @@ -257,11 +128,11 @@ mkIface hsc_env maybe_old_fingerprint mod_details mg_dir_imps = dir_imp_mods, mg_rdr_env = rdr_env, mg_fix_env = fix_env, - mg_deprecs = deprecs, + mg_warns = warns, mg_hpc_info = hpc_info } = mkIface_ hsc_env maybe_old_fingerprint this_mod is_boot used_names deps rdr_env - fix_env deprecs hpc_info dir_imp_mods mod_details + fix_env warns hpc_info dir_imp_mods mod_details -- | make an interface from the results of typechecking only. Useful -- for non-optimising compilation, or where we aren't generating any @@ -278,7 +149,7 @@ mkIfaceTc hsc_env maybe_old_fingerprint mod_details tcg_imports = imports, tcg_rdr_env = rdr_env, tcg_fix_env = fix_env, - tcg_deprecs = deprecs, + tcg_warns = warns, tcg_hpc = other_hpc_info } = do @@ -287,7 +158,7 @@ mkIfaceTc hsc_env maybe_old_fingerprint mod_details let hpc_info = emptyHpcInfo other_hpc_info mkIface_ hsc_env maybe_old_fingerprint this_mod (isHsBoot hsc_src) used_names deps rdr_env - fix_env deprecs hpc_info (imp_mods imports) mod_details + fix_env warns hpc_info (imp_mods imports) mod_details mkUsedNames :: TcGblEnv -> IO NameSet @@ -339,12 +210,12 @@ mkDependencies mkIface_ :: HscEnv -> Maybe Fingerprint -> Module -> IsBootInterface -> NameSet -> Dependencies -> GlobalRdrEnv - -> NameEnv FixItem -> Deprecations -> HpcInfo + -> NameEnv FixItem -> Warnings -> HpcInfo -> ImportedMods -> ModDetails -> IO (ModIface, Bool) mkIface_ hsc_env maybe_old_fingerprint - this_mod is_boot used_names deps rdr_env fix_env src_deprecs hpc_info + this_mod is_boot used_names deps rdr_env fix_env src_warns hpc_info dir_imp_mods ModDetails{ md_insts = insts, md_fam_insts = fam_insts, @@ -371,7 +242,7 @@ mkIface_ hsc_env maybe_old_fingerprint -- Sigh: see Note [Root-main Id] in TcRnDriver ; fixities = [(occ,fix) | FixItem occ fix <- nameEnvElts fix_env] - ; deprecs = src_deprecs + ; warns = src_warns ; iface_rules = map (coreRuleToIfaceRule this_mod) rules ; iface_insts = map instanceToIfaceInst insts ; iface_fam_insts = map famInstToIfaceFamInst fam_insts @@ -393,7 +264,7 @@ mkIface_ hsc_env maybe_old_fingerprint mi_vect_info = iface_vect_info, mi_fixities = fixities, - mi_deprecs = deprecs, + mi_warns = warns, mi_globals = Just rdr_env, -- Left out deliberately: filled in by addVersionInfo @@ -409,21 +280,36 @@ mkIface_ hsc_env maybe_old_fingerprint mi_hpc = isHpcUsed hpc_info, -- And build the cached values - mi_dep_fn = mkIfaceDepCache deprecs, + mi_warn_fn = mkIfaceWarnCache warns, mi_fix_fn = mkIfaceFixCache fixities } } - ; (new_iface, no_change_at_all, pp_orphs) + ; (new_iface, no_change_at_all) <- {-# SCC "versioninfo" #-} addFingerprints hsc_env maybe_old_fingerprint intermediate_iface decls - -- Debug printing - ; when (isJust pp_orphs && dopt Opt_WarnOrphans dflags) - (printDump (expectJust "mkIface" pp_orphs)) + -- Warn about orphans + ; let orph_warnings --- Laziness means no work done unless -fwarn-orphans + | dopt Opt_WarnOrphans dflags = rule_warns `unionBags` inst_warns + | otherwise = emptyBag + errs_and_warns = (orph_warnings, emptyBag) + unqual = mkPrintUnqualified dflags rdr_env + inst_warns = listToBag [ instOrphWarn unqual d + | (d,i) <- insts `zip` iface_insts + , isNothing (ifInstOrph i) ] + rule_warns = listToBag [ ruleOrphWarn unqual this_mod r + | r <- iface_rules + , isNothing (ifRuleOrph r) ] + + ; when (not (isEmptyBag orph_warnings)) + (do { printErrorsAndWarnings dflags errs_and_warns -- XXX + ; when (errorsFound dflags errs_and_warns) + (exitWith (ExitFailure 1)) }) -- XXX ; when (dopt Opt_D_dump_hi_diffs dflags) (printDump pp_diffs) - + + -- Debug printing ; dumpIfSet_dyn dflags Opt_D_dump_hi "FINAL INTERFACE" (pprModIface new_iface) @@ -484,7 +370,7 @@ mkHashFun mkHashFun hsc_env eps = \name -> let - mod = nameModule name + mod = ASSERT2( isExternalName name, ppr name ) nameModule name occ = nameOccName name iface = lookupIfaceByModule (hsc_dflags hsc_env) hpt pit mod `orElse` pprPanic "lookupVers2" (ppr mod <+> ppr occ) @@ -504,9 +390,8 @@ addFingerprints -> ModIface -- The new interface (lacking decls) -> [IfaceDecl] -- The new decls -> IO (ModIface, -- Updated interface - Bool, -- True <=> no changes at all; + Bool) -- True <=> no changes at all; -- no need to write Iface - Maybe SDoc) -- Warnings about orphans addFingerprints hsc_env mb_old_fingerprint iface0 new_decls = do @@ -526,8 +411,9 @@ addFingerprints hsc_env mb_old_fingerprint iface0 new_decls , let out = localOccs $ freeNamesDeclABI abi ] + name_module n = ASSERT( isExternalName n ) nameModule n localOccs = map (getUnique . getParent . getOccName) - . filter ((== this_mod) . nameModule) + . filter ((== this_mod) . name_module) . nameSetToList where getParent occ = lookupOccEnv parent_map occ `orElse` occ @@ -541,7 +427,7 @@ addFingerprints hsc_env mb_old_fingerprint iface0 new_decls where n = ifName d -- strongly-connected groups of declarations, in dependency order - groups = stronglyConnComp edges + groups = stronglyConnCompFromEdgedVertices edges global_hash_fn = mkHashFun hsc_env eps @@ -557,11 +443,19 @@ addFingerprints hsc_env mb_old_fingerprint iface0 new_decls | isWiredInName name = putNameLiterally bh name -- wired-in names don't have fingerprints | otherwise - = let hash | nameModule name /= this_mod = global_hash_fn name + = ASSERT( isExternalName name ) + let hash | nameModule name /= this_mod = global_hash_fn name | otherwise = snd (lookupOccEnv local_env (getOccName name) `orElse` pprPanic "urk! lookup local fingerprint" (ppr name)) -- (undefined,fingerprint0)) + -- This panic indicates that we got the dependency + -- analysis wrong, because we needed a fingerprint for + -- an entity that wasn't in the environment. To debug + -- it, turn the panic into a trace, uncomment the + -- pprTraces below, run the compile again, and inspect + -- the output and the generated .hi file with + -- --show-iface. in put_ bh hash @@ -609,15 +503,19 @@ addFingerprints hsc_env mb_old_fingerprint iface0 new_decls (local_env, decls_w_hashes) <- foldM fingerprint_group (emptyOccEnv, []) groups + -- when calculating fingerprints, we always need to use canonical + -- ordering for lists of things. In particular, the mi_deps has various + -- lists of modules and suchlike, so put these all in canonical order: + let sorted_deps = sortDependencies (mi_deps iface0) + -- the export hash of a module depends on the orphan hashes of the -- orphan modules below us in the dependeny tree. This is the way -- that changes in orphans get propagated all the way up the -- dependency tree. We only care about orphan modules in the current -- package, because changes to orphans outside this package will be -- tracked by the usage on the ABI hash of package modules that we import. - let orph_mods = sortBy (compare `on` (moduleNameFS.moduleName)) - . filter ((== this_pkg) . modulePackageId) - $ dep_orphs (mi_deps iface0) + let orph_mods = filter ((== this_pkg) . modulePackageId) + $ dep_orphs sorted_deps dep_orphan_hashes <- getOrphanHashes hsc_env orph_mods orphan_hash <- computeFingerprint dflags (mk_put_name local_env) @@ -642,7 +540,7 @@ addFingerprints hsc_env mb_old_fingerprint iface0 new_decls (map fst sorted_decls, export_hash, orphan_hash, - mi_deprecs iface0) + mi_warns iface0) -- The interface hash depends on: -- - the ABI hash, plus @@ -652,7 +550,7 @@ addFingerprints hsc_env mb_old_fingerprint iface0 new_decls iface_hash <- computeFingerprint dflags putNameLiterally (mod_hash, mi_usages iface0, - mi_deps iface0, + sorted_deps, mi_hpc iface0) let @@ -668,7 +566,7 @@ addFingerprints hsc_env mb_old_fingerprint iface0 new_decls mi_decls = sorted_decls, mi_hash_fn = lookupOccEnv local_env } -- - return (final_iface, no_change_at_all, pp_orphs) + return (final_iface, no_change_at_all) where this_mod = mi_module iface0 @@ -680,7 +578,6 @@ addFingerprints hsc_env mb_old_fingerprint iface0 new_decls -- non-orphans? fam_insts = mi_fam_insts iface0 fix_fn = mi_fix_fn iface0 - pp_orphs = pprOrphans orph_insts orph_rules getOrphanHashes :: HscEnv -> [Module] -> IO [Fingerprint] @@ -698,6 +595,13 @@ getOrphanHashes hsc_env mods = do return (map get_orph_hash mods) +sortDependencies :: Dependencies -> Dependencies +sortDependencies d + = Deps { dep_mods = sortBy (compare `on` (moduleNameFS.fst)) (dep_mods d), + dep_pkgs = sortBy (compare `on` packageIdFS) (dep_pkgs d), + dep_orphs = sortBy stableModuleCmp (dep_orphs d), + dep_finsts = sortBy stableModuleCmp (dep_finsts d) } + -- The ABI of a declaration consists of: -- the full name of the identifier (inc. module and package, because -- these are used to construct the symbol name by which the @@ -775,11 +679,12 @@ declExtras fix_fn rule_env inst_env decl n = ifName decl id_extras occ = (fix_fn occ, lookupOccEnvL rule_env occ) --- When hashing an instance, we omit the DFun. This is because if a --- DFun is used it will already have a separate entry in the usages --- list, and we don't want changes to the DFun to cause the hash of --- the instnace to change - that would cause unnecessary changes to --- orphans, for example. +-- +-- When hashing an instance, we hash only its structure, not the +-- fingerprints of the things it mentions. See the section on instances +-- in the commentary, +-- http://hackage.haskell.org/trac/ghc/wiki/Commentary/Compiler/RecompilationAvoidance +-- newtype IfaceInstABI = IfaceInstABI IfaceInst instance Binary IfaceInstABI where @@ -795,9 +700,9 @@ lookupOccEnvL env k = lookupOccEnv env k `orElse` [] -- used when we want to fingerprint a structure without depending on the -- fingerprints of external Names that it refers to. putNameLiterally :: BinHandle -> Name -> IO () -putNameLiterally bh name = do - put_ bh $! nameModule name - put_ bh $! nameOccName name +putNameLiterally bh name = ASSERT( isExternalName name ) + do { put_ bh $! nameModule name + ; put_ bh $! nameOccName name } computeFingerprint :: Binary a => DynFlags @@ -832,18 +737,19 @@ oldMD5 dflags bh = do return $! readHexFingerprint hash_str -} -pprOrphans :: [IfaceInst] -> [IfaceRule] -> Maybe SDoc -pprOrphans insts rules - | null insts && null rules = Nothing - | otherwise - = Just $ vcat [ - if null insts then empty else - hang (ptext (sLit "Warning: orphan instances:")) - 2 (vcat (map ppr insts)), - if null rules then empty else - hang (ptext (sLit "Warning: orphan rules:")) - 2 (vcat (map ppr rules)) - ] +instOrphWarn :: PrintUnqualified -> Instance -> WarnMsg +instOrphWarn unqual inst + = mkWarnMsg (getSrcSpan inst) unqual $ + hang (ptext (sLit "Warning: orphan instance:")) 2 (pprInstanceHdr inst) + +ruleOrphWarn :: PrintUnqualified -> Module -> IfaceRule -> WarnMsg +ruleOrphWarn unqual mod rule + = mkWarnMsg silly_loc unqual $ + ptext (sLit "Orphan rule:") <+> ppr rule + where + silly_loc = srcLocSpan (mkSrcLoc (moduleNameFS (moduleName mod)) 1 0) + -- We don't have a decent SrcSpan for a Rule, not even the CoreRule + -- Could readily be fixed by adding a SrcSpan to CoreRule, if we wanted to ---------------------- -- mkOrphMap partitions instance decls or rules into @@ -1023,10 +929,12 @@ mkIfaceExports exports -- else the plusFM will simply discard one! They -- should have been combined by now. add env (Avail n) - = add_one env (nameModule n) (Avail (nameOccName n)) + = ASSERT( isExternalName n ) + add_one env (nameModule n) (Avail (nameOccName n)) add env (AvailTC tc ns) - = foldl add_for_mod env mods + = ASSERT( all isExternalName ns ) + foldl add_for_mod env mods where tc_occ = nameOccName tc mods = nub (map nameModule ns) @@ -1228,13 +1136,13 @@ needInterface mod continue -- Instead, get an Either back which we can test case mb_iface of - Failed _ -> (out_of_date (sep [ptext (sLit "Couldn't load interface for module"), - ppr mod])); - -- Couldn't find or parse a module mentioned in the - -- old interface file. Don't complain: it might - -- just be that the current module doesn't need that - -- import and it's been deleted - Succeeded iface -> continue iface + Failed _ -> (out_of_date (sep [ptext (sLit "Couldn't load interface for module"), + ppr mod])) + -- Couldn't find or parse a module mentioned in the + -- old interface file. Don't complain: it might + -- just be that the current module doesn't need that + -- import and it's been deleted + Succeeded iface -> continue iface checkModUsage :: PackageId ->Usage -> IfG RecompileRequired @@ -1386,8 +1294,8 @@ tyThingToIfaceDecl (ATyCon tycon) | isSynTyCon tycon = IfaceSyn { ifName = getOccName tycon, ifTyVars = toIfaceTvBndrs tyvars, - ifOpenSyn = syn_isOpen, - ifSynRhs = toIfaceType syn_tyki, + ifSynRhs = syn_rhs, + ifSynKind = syn_ki, ifFamInst = famInstToIface (tyConFamInst_maybe tycon) } @@ -1408,9 +1316,10 @@ tyThingToIfaceDecl (ATyCon tycon) | otherwise = pprPanic "toIfaceDecl" (ppr tycon) where tyvars = tyConTyVars tycon - (syn_isOpen, syn_tyki) = case synTyConRhs tycon of - OpenSynTyCon ki _ -> (True , ki) - SynonymTyCon ty -> (False, ty) + (syn_rhs, syn_ki) + = case synTyConRhs tycon of + OpenSynTyCon ki _ -> (Nothing, toIfaceType ki) + SynonymTyCon ty -> (Just (toIfaceType ty), toIfaceType (typeKind ty)) ifaceConDecls (NewTyCon { data_con = con }) = IfNewTyCon (ifaceConDecl con) @@ -1463,7 +1372,7 @@ instanceToIfaceInst (Instance { is_dfun = dfun_id, is_flag = oflag, do_rough (Just n) = Just (toIfaceTyCon_name n) dfun_name = idName dfun_id - mod = nameModule dfun_name + mod = ASSERT( isExternalName dfun_name ) nameModule dfun_name is_local name = nameIsLocalOrFrom mod name -- Compute orphanhood. See Note [Orphans] in IfaceSyn