-codeGen :: FAST_STRING -- module name
- -> ([CostCentre], -- local cost-centres needing declaring/registering
- [CostCentre]) -- "extern" cost-centres needing declaring
- -> [Module] -- import names
- -> [TyCon] -- tycons with data constructors to convert
- -> FiniteMap TyCon [(Bool, [Maybe Type])]
- -- tycon specialisation info
- -> [StgBinding] -- bindings to convert
- -> AbstractC -- output
-
-codeGen mod_name (local_CCs, extern_CCs) import_names gen_tycons tycon_specs stg_pgm
- = let
- doing_profiling = opt_SccProfilingOn
- compiling_prelude = opt_CompilingPrelude
- maybe_split = if maybeToBool (opt_EnsureSplittableC)
- then CSplitMarker
- else AbsCNop
-
- cinfo = MkCompInfo mod_name
- in
- if not doing_profiling then
- mkAbstractCs [
- genStaticConBits cinfo gen_tycons tycon_specs,
- initC cinfo (cgTopBindings maybe_split stg_pgm) ]
-
- else -- yes, cost-centre profiling:
- -- Besides the usual stuff, we must produce:
- --
- -- * Declarations for the cost-centres defined in this module;
- -- * Code to participate in "registering" all the cost-centres
- -- in the program (done at startup time when the pgm is run).
- --
- -- (The local cost-centres involved in this are passed
- -- into the code-generator, as are the imported-modules' names.)
- --
- -- Note: we don't register/etc if compiling Prelude bits.
-
- mkAbstractCs [
- if compiling_prelude
- then AbsCNop
- else mkAbstractCs [mkAbstractCs (map (CCostCentreDecl True) local_CCs),
- mkAbstractCs (map (CCostCentreDecl False) extern_CCs),
- mkCcRegister local_CCs import_names],
-
- genStaticConBits cinfo gen_tycons tycon_specs,
- initC cinfo (cgTopBindings maybe_split stg_pgm) ]
+codeGen :: DynFlags
+ -> Module
+ -> TypeEnv
+ -> ForeignStubs
+ -> [Module] -- directly-imported modules
+ -> CollectedCCs -- (Local/global) cost-centres needing declaring/registering.
+ -> [(StgBinding,[(Id,[Id])])] -- Bindings to convert, with SRTs
+ -> IO [Cmm] -- Output
+
+codeGen dflags this_mod type_env foreign_stubs imported_mods
+ cost_centre_info stg_binds
+ = do
+ { showPass dflags "CodeGen"
+ ; way <- readIORef v_Build_tag
+ ; mb_main_mod <- readIORef v_MainModIs
+
+ ; let tycons = typeEnvTyCons type_env
+ data_tycons = filter isDataTyCon tycons
+
+-- Why?
+-- ; mapM_ (\x -> seq x (return ())) data_tycons
+
+ ; code_stuff <- initC this_mod $ do
+ { cmm_binds <- mapM (getCmm . cgTopBinding) stg_binds
+ ; cmm_tycons <- mapM cgTyCon data_tycons
+ ; cmm_init <- getCmm (mkModuleInit way cost_centre_info
+ this_mod mb_main_mod
+ foreign_stubs imported_mods)
+ ; return (cmm_binds ++ concat cmm_tycons ++ [cmm_init])
+ }
+ -- Put datatype_stuff after code_stuff, because the
+ -- datatype closure table (for enumeration types) to
+ -- (say) PrelBase_True_closure, which is defined in
+ -- code_stuff
+
+ ; dumpIfSet_dyn dflags Opt_D_dump_cmm "Cmm" (pprCmms code_stuff)
+
+ ; return code_stuff }
+\end{code}
+
+%************************************************************************
+%* *
+\subsection[codegen-init]{Module initialisation code}
+%* *
+%************************************************************************
+
+/* -----------------------------------------------------------------------------
+ Module initialisation
+
+ The module initialisation code looks like this, roughly:
+
+ FN(__stginit_Foo) {
+ JMP_(__stginit_Foo_1_p)
+ }
+
+ FN(__stginit_Foo_1_p) {
+ ...
+ }
+
+ We have one version of the init code with a module version and the
+ 'way' attached to it. The version number helps to catch cases
+ where modules are not compiled in dependency order before being
+ linked: if a module has been compiled since any modules which depend on
+ it, then the latter modules will refer to a different version in their
+ init blocks and a link error will ensue.
+
+ The 'way' suffix helps to catch cases where modules compiled in different
+ ways are linked together (eg. profiled and non-profiled).
+
+ We provide a plain, unadorned, version of the module init code
+ which just jumps to the version with the label and way attached. The
+ reason for this is that when using foreign exports, the caller of
+ startupHaskell() must supply the name of the init function for the "top"
+ module in the program, and we don't want to require that this name
+ has the version and way info appended to it.
+ -------------------------------------------------------------------------- */
+
+We initialise the module tree by keeping a work-stack,
+ * pointed to by Sp
+ * that grows downward
+ * Sp points to the last occupied slot
+
+
+\begin{code}
+mkModuleInit
+ :: String -- the "way"
+ -> CollectedCCs -- cost centre info
+ -> Module
+ -> Maybe String -- Just m ==> we have flag: -main-is Foo.baz
+ -> ForeignStubs
+ -> [Module]
+ -> Code
+mkModuleInit way cost_centre_info this_mod mb_main_mod foreign_stubs imported_mods
+ = do {
+
+ -- Allocate the static boolean that records if this
+ -- module has been registered already
+ ; emitData Data [CmmDataLabel moduleRegdLabel,
+ CmmStaticLit zeroCLit]
+
+ ; emitSimpleProc real_init_lbl $ do
+ { -- The return-code pops the work stack by
+ -- incrementing Sp, and then jumpd to the popped item
+ ret_blk <- forkLabelledCode $ stmtsC
+ [ CmmAssign spReg (cmmRegOffW spReg 1)
+ , CmmJump (CmmLoad (cmmRegOffW spReg (-1)) wordRep) [] ]
+
+ ; init_blk <- forkLabelledCode $ do
+ { mod_init_code; stmtC (CmmBranch ret_blk) }
+
+ ; stmtC (CmmCondBranch (cmmNeWord (CmmLit zeroCLit) mod_reg_val)
+ ret_blk)
+ ; stmtC (CmmBranch init_blk)
+ }
+
+
+ -- Make the "plain" procedure jump to the "real" init procedure
+ ; emitSimpleProc plain_init_lbl jump_to_init
+
+ -- When compiling the module in which the 'main' function lives,
+ -- (that is, Module.moduleName this_mod == main_mod_name)
+ -- we inject an extra stg_init procedure for stg_init_ZCMain, for the
+ -- RTS to invoke. We must consult the -main-is flag in case the
+ -- user specified a different function to Main.main
+ ; whenC (Module.moduleName this_mod == main_mod_name)
+ (emitSimpleProc plain_main_init_lbl jump_to_init)
+ }
+ where
+ plain_init_lbl = mkPlainModuleInitLabel this_mod
+ real_init_lbl = mkModuleInitLabel this_mod way
+ plain_main_init_lbl = mkPlainModuleInitLabel rOOT_MAIN
+
+ jump_to_init = stmtC (CmmJump (mkLblExpr real_init_lbl) [])
+
+ mod_reg_val = CmmLoad (mkLblExpr moduleRegdLabel) wordRep
+
+ main_mod_name = case mb_main_mod of
+ Just mod_name -> mkModuleName mod_name
+ Nothing -> mAIN_Name
+
+ -- Main refers to GHC.TopHandler.runIO, so make sure we call the
+ -- init function for GHC.TopHandler.
+ extra_imported_mods
+ | Module.moduleName this_mod == main_mod_name = [pREL_TOP_HANDLER]
+ | otherwise = []
+
+ mod_init_code = do
+ { -- Set mod_reg to 1 to record that we've been here
+ stmtC (CmmStore (mkLblExpr moduleRegdLabel) (CmmLit (mkIntCLit 1)))
+
+ -- Now do local stuff
+ ; registerForeignExports foreign_stubs
+ ; initCostCentres cost_centre_info
+ ; mapCs (registerModuleImport way) (imported_mods++extra_imported_mods)
+ }
+
+
+-----------------------
+registerModuleImport :: String -> Module -> Code
+registerModuleImport way mod
+ | mod == gHC_PRIM
+ = nopC
+ | otherwise -- Push the init procedure onto the work stack
+ = stmtsC [ CmmAssign spReg (cmmRegOffW spReg (-1))
+ , CmmStore (CmmReg spReg) (mkLblExpr (mkModuleInitLabel mod way)) ]
+
+-----------------------
+registerForeignExports :: ForeignStubs -> Code
+registerForeignExports NoStubs
+ = nopC
+registerForeignExports (ForeignStubs _ _ _ fe_bndrs)
+ = mapM_ mk_export_register fe_bndrs
projects / ghc-hetmet.git / blobdiff