-- bother to compile it.
import CgExpr ( {-NOTHING!-} ) -- DO NOT DELETE THIS IMPORT
-import DriverState ( v_Build_tag )
+import DriverState ( v_Build_tag, v_MainModIs )
import StgSyn
import CgMonad
import AbsCSyn
-import PrelNames ( gHC_PRIM )
-import CLabel ( CLabel, mkSRTLabel, mkClosureLabel,
+import PrelNames ( gHC_PRIM, dOLLAR_MAIN, mAIN_Name )
+import CLabel ( mkSRTLabel, mkClosureLabel,
mkPlainModuleInitLabel, mkModuleInitLabel )
import PprAbsC ( dumpRealC )
import AbsCUtils ( mkAbstractCs, flattenAbsC )
import ClosureInfo ( mkClosureLFInfo )
import CmdLineOpts ( DynFlags, DynFlag(..),
opt_SccProfilingOn, opt_EnsureSplittableC )
-import HscTypes ( ModGuts(..), ModGuts, ForeignStubs(..),
- typeEnvTyCons )
+import HscTypes ( ForeignStubs(..), TypeEnv, typeEnvTyCons )
import CostCentre ( CollectedCCs )
import Id ( Id, idName, setIdName )
import Name ( nameSrcLoc, nameOccName, nameUnique, isInternalName, mkExternalName )
import OccName ( mkLocalOcc )
import PrimRep ( PrimRep(..) )
import TyCon ( isDataTyCon )
+import Module ( Module, mkModuleName )
import BasicTypes ( TopLevelFlag(..) )
import UniqSupply ( mkSplitUniqSupply )
import ErrUtils ( dumpIfSet_dyn, showPass )
import Panic ( assertPanic )
+import qualified Module ( moduleName )
#ifdef DEBUG
import Outputable
\begin{code}
codeGen :: DynFlags
- -> ModGuts
+ -> Module
+ -> TypeEnv
+ -> ForeignStubs
+ -> [Module] -- directly-imported modules
-> CollectedCCs -- (Local/global) cost-centres needing declaring/registering.
- -> [(StgBinding,[Id])] -- Bindings to convert, with SRTs
+ -> [(StgBinding,[(Id,[Id])])] -- Bindings to convert, with SRTs
-> IO AbstractC -- Output
-codeGen dflags
- mod_impl@(ModGuts { mg_module = mod_name, mg_types = type_env })
+codeGen dflags this_mod type_env foreign_stubs imported_mods
cost_centre_info stg_binds
= do
showPass dflags "CodeGen"
fl_uniqs <- mkSplitUniqSupply 'f'
way <- readIORef v_Build_tag
+ mb_main_mod <- readIORef v_MainModIs
let
tycons = typeEnvTyCons type_env
data_tycons = filter isDataTyCon tycons
- cinfo = MkCompInfo mod_name
+
+ mapM_ (\x -> seq x (return ())) data_tycons
+
+ let
+
+ cinfo = MkCompInfo this_mod
datatype_stuff = genStaticConBits cinfo data_tycons
code_stuff = initC cinfo (mapCs cgTopBinding stg_binds)
- init_stuff = mkModuleInit way cost_centre_info mod_impl
+ init_stuff = mkModuleInit way cost_centre_info
+ this_mod mb_main_mod
+ foreign_stubs imported_mods
abstractC = mkAbstractCs [ maybeSplitCode,
init_stuff,
mkModuleInit
:: String -- the "way"
-> CollectedCCs -- cost centre info
- -> ModGuts
+ -> Module
+ -> Maybe String -- Just m ==> we have flag: -main-is Foo.baz
+ -> ForeignStubs
+ -> [Module]
-> AbstractC
-mkModuleInit way cost_centre_info
- (ModGuts { mg_module = mod,
- mg_foreign = ForeignStubs _ _ _ fe_binders,
- mg_dir_imps = imported_modules })
+mkModuleInit way cost_centre_info this_mod mb_main_mod foreign_stubs imported_mods
= let
- register_fes =
- map (\f -> CMacroStmt REGISTER_FOREIGN_EXPORT [f]) fe_labels
+ (cc_decls, cc_regs) = mkCostCentreStuff cost_centre_info
- fe_labels =
- map (\f -> CLbl (mkClosureLabel (idName f)) PtrRep) fe_binders
+ register_foreign_exports
+ = case foreign_stubs of
+ NoStubs -> []
+ ForeignStubs _ _ _ fe_bndrs -> map mk_export_register fe_bndrs
- (cc_decls, cc_regs) = mkCostCentreStuff cost_centre_info
+ mk_export_register bndr
+ = CMacroStmt REGISTER_FOREIGN_EXPORT [lbl]
+ where
+ lbl = CLbl (mkClosureLabel (idName bndr)) PtrRep
+ -- we don't want/need to init GHC.Prim, so filter it out
- -- we don't want/need to init GHC.Prim, so filter it out
mk_import_register mod
| mod == gHC_PRIM = AbsCNop
| otherwise = CMacroStmt REGISTER_IMPORT [
CLbl (mkModuleInitLabel mod way) AddrRep
]
- register_imports = map mk_import_register imported_modules
+ register_mod_imports = map mk_import_register imported_mods
+
+ -- When compiling the module in which the 'main' function lives,
+ -- we inject an extra stg_init procedure for stg_init_zdMain, for the
+ -- RTS to invoke. We must consult the -main-is flag in case the
+ -- user specified a different function to Main.main
+ main_mod_name = case mb_main_mod of
+ Just mod_name -> mkModuleName mod_name
+ Nothing -> mAIN_Name
+ main_init_block
+ | Module.moduleName this_mod /= main_mod_name
+ = AbsCNop -- The normal case
+ | otherwise -- this_mod contains the main function
+ = CModuleInitBlock (mkPlainModuleInitLabel dOLLAR_MAIN)
+ (mkModuleInitLabel dOLLAR_MAIN way)
+ (mk_import_register this_mod)
in
mkAbstractCs [
cc_decls,
- CModuleInitBlock (mkPlainModuleInitLabel mod)
- (mkModuleInitLabel mod way)
- (mkAbstractCs (register_fes ++
+ CModuleInitBlock (mkPlainModuleInitLabel this_mod)
+ (mkModuleInitLabel this_mod way)
+ (mkAbstractCs (register_foreign_exports ++
cc_regs :
- register_imports))
+ register_mod_imports)),
+ main_init_block
]
\end{code}
variable.
\begin{code}
-cgTopBinding :: (StgBinding,[Id]) -> Code
-cgTopBinding (StgNonRec srt_info id rhs, srt)
+cgTopBinding :: (StgBinding,[(Id,[Id])]) -> Code
+cgTopBinding (StgNonRec id rhs, srts)
= absC maybeSplitCode `thenC`
- maybeExternaliseId id `thenFC` \ id' ->
- let
- srt_label = mkSRTLabel (idName id')
- in
- mkSRT srt_label srt [] `thenC`
- setSRTLabel srt_label (
- cgTopRhs id' rhs srt_info `thenFC` \ (id, info) ->
- addBindC id info -- Add the un-externalised Id to the envt, so we
- -- find it when we look up occurrences
- )
-
-cgTopBinding (StgRec srt_info pairs, srt)
+ maybeExternaliseId id `thenFC` \ id' ->
+ mapM_ (mkSRT [id']) srts `thenC`
+ cgTopRhs id' rhs `thenFC` \ (id, info) ->
+ addBindC id info `thenC`
+ -- Add the un-externalised Id to the envt, so we
+ -- find it when we look up occurrences
+ nopC
+
+cgTopBinding (StgRec pairs, srts)
= absC maybeSplitCode `thenC`
let
(bndrs, rhss) = unzip pairs
in
- mapFCs maybeExternaliseId bndrs `thenFC` \ bndrs'@(id:_) ->
+ mapFCs maybeExternaliseId bndrs `thenFC` \ bndrs' ->
let
- srt_label = mkSRTLabel (idName id)
- pairs' = zip bndrs' rhss
+ pairs' = zip bndrs' rhss
in
- mkSRT srt_label srt bndrs' `thenC`
- setSRTLabel srt_label (
- fixC (\ new_binds ->
+ mapM_ (mkSRT bndrs') srts `thenC`
+ fixC (\ new_binds ->
addBindsC new_binds `thenC`
- mapFCs ( \ (b,e) -> cgTopRhs b e srt_info ) pairs'
- ) `thenFC` \ new_binds -> nopC
- )
+ mapFCs ( \ (b,e) -> cgTopRhs b e ) pairs'
+ ) `thenFC` \ new_binds ->
+ nopC
-mkSRT :: CLabel -> [Id] -> [Id] -> Code
-mkSRT lbl [] these = nopC
-mkSRT lbl ids these
+mkSRT :: [Id] -> (Id,[Id]) -> Code
+mkSRT these (id,[]) = nopC
+mkSRT these (id,ids)
= mapFCs remap ids `thenFC` \ ids ->
- absC (CSRT lbl (map (mkClosureLabel . idName) ids))
+ remap id `thenFC` \ id ->
+ absC (CSRT (mkSRTLabel (idName id)) (map (mkClosureLabel . idName) ids))
where
-- sigh, better map all the ids against the environment in case they've
-- been externalised (see maybeExternaliseId below).
-- to enclose the listFCs in cgTopBinding, but that tickled the
-- statics "error" call in initC. I DON'T UNDERSTAND WHY!
-cgTopRhs :: Id -> StgRhs -> SRT -> FCode (Id, CgIdInfo)
+cgTopRhs :: Id -> StgRhs -> FCode (Id, CgIdInfo)
-- The Id is passed along for setting up a binding...
-- It's already been externalised if necessary
-cgTopRhs bndr (StgRhsCon cc con args) srt
- = forkStatics (cgTopRhsCon bndr con args srt)
+cgTopRhs bndr (StgRhsCon cc con args)
+ = forkStatics (cgTopRhsCon bndr con args)
-cgTopRhs bndr (StgRhsClosure cc bi fvs upd_flag args body) srt
+cgTopRhs bndr (StgRhsClosure cc bi fvs upd_flag srt args body)
= ASSERT(null fvs) -- There should be no free variables
let
+ srt_label = mkSRTLabel (idName bndr)
lf_info = mkClosureLFInfo bndr TopLevel [{-no fvs-}] upd_flag args
in
- forkStatics (cgTopRhsClosure bndr cc bi srt args body lf_info)
+ setSRTLabel srt_label $
+ forkStatics (cgTopRhsClosure bndr cc bi srt args body lf_info)
\end{code}
projects / ghc-hetmet.git / blobdiff