{-# LANGUAGE TupleSections #-} {-# LANGUAGE CPP #-} ----------------------------------------------------------------------------- -- -- Stg to C--: code generation for constructors -- -- This module provides the support code for StgToCmm to deal with -- constructors on the RHSs of let(rec)s. -- -- (c) The University of Glasgow 2004-2006 -- ----------------------------------------------------------------------------- module GHC.StgToCmm.DataCon ( cgTopRhsCon, buildDynCon, bindConArgs ) where #include "HsVersions.h" import GHC.Prelude import GHC.Platform import GHC.Platform.Profile import GHC.Stg.Syntax import GHC.Core ( AltCon(..) ) import GHC.StgToCmm.Monad import GHC.StgToCmm.Env import GHC.StgToCmm.Heap import GHC.StgToCmm.Layout import GHC.StgToCmm.Utils import GHC.StgToCmm.Closure import GHC.Cmm.Expr import GHC.Cmm.Utils import GHC.Cmm.CLabel import GHC.Cmm.Graph import GHC.Runtime.Heap.Layout import GHC.Types.CostCentre import GHC.Unit import GHC.Core.DataCon import GHC.Driver.Session import GHC.Data.FastString import GHC.Types.Id import GHC.Types.Id.Info( CafInfo( NoCafRefs ) ) import GHC.Types.Name (isInternalName) import GHC.Types.RepType (countConRepArgs) import GHC.Types.Literal import GHC.Builtin.Utils import GHC.Utils.Panic import GHC.Utils.Misc import GHC.Utils.Monad (mapMaybeM) import Control.Monad import Data.Char --------------------------------------------------------------- -- Top-level constructors --------------------------------------------------------------- cgTopRhsCon :: DynFlags -> Id -- Name of thing bound to this RHS -> DataCon -- Id -> ConstructorNumber -> [NonVoid StgArg] -- Args -> (CgIdInfo, FCode ()) cgTopRhsCon dflags id con mn args | Just static_info <- precomputedStaticConInfo_maybe dflags id con args , let static_code | isInternalName name = pure () | otherwise = gen_code = -- There is a pre-allocated static closure available; use it -- See Note [Precomputed static closures]. -- For External bindings we must keep the binding, -- since importing modules will refer to it by name; -- but for Internal ones we can drop it altogether -- See Note [About the NameSorts] in "GHC.Types.Name" for Internal/External (static_info, static_code) -- Otherwise generate a closure for the constructor. | otherwise = (id_Info, gen_code) where platform = targetPlatform dflags id_Info = litIdInfo platform id (mkConLFInfo con) (CmmLabel closure_label) name = idName id caffy = idCafInfo id -- any stgArgHasCafRefs args closure_label = mkClosureLabel name caffy gen_code = do { profile <- getProfile ; this_mod <- getModuleName ; when (platformOS platform == OSMinGW32) $ -- Windows DLLs have a problem with static cross-DLL refs. MASSERT( not (isDllConApp dflags this_mod con (map fromNonVoid args)) ) ; ASSERT( args `lengthIs` countConRepArgs con ) return () -- LAY IT OUT ; let (tot_wds, -- #ptr_wds + #nonptr_wds ptr_wds, -- #ptr_wds nv_args_w_offsets) = mkVirtHeapOffsetsWithPadding profile StdHeader (addArgReps args) ; let -- Decompose padding into units of length 8, 4, 2, or 1 bytes to -- allow the implementation of mk_payload to use widthFromBytes, -- which only handles these cases. fix_padding (x@(Padding n off) : rest) | n == 0 = fix_padding rest | n `elem` [1,2,4,8] = x : fix_padding rest | n > 8 = add_pad 8 | n > 4 = add_pad 4 | n > 2 = add_pad 2 | otherwise = add_pad 1 where add_pad m = Padding m off : fix_padding (Padding (n-m) (off+m) : rest) fix_padding (x : rest) = x : fix_padding rest fix_padding [] = [] mk_payload (Padding len _) = return (CmmInt 0 (widthFromBytes len)) mk_payload (FieldOff arg _) = do amode <- getArgAmode arg case amode of CmmLit lit -> return lit _ -> panic "GHC.StgToCmm.DataCon.cgTopRhsCon" nonptr_wds = tot_wds - ptr_wds -- we're not really going to emit an info table, so having -- to make a CmmInfoTable is a bit overkill, but mkStaticClosureFields -- needs to poke around inside it. info_tbl = mkDataConInfoTable profile con (addModuleLoc this_mod mn) True ptr_wds nonptr_wds ; payload <- mapM mk_payload (fix_padding nv_args_w_offsets) -- NB1: nv_args_w_offsets is sorted into ptrs then non-ptrs -- NB2: all the amodes should be Lits! -- TODO (osa): Why? -- BUILD THE OBJECT -- -- We're generating info tables, so we don't know and care about -- what the actual arguments are. Using () here as the place holder. ; emitDataCon closure_label info_tbl dontCareCCS payload } addModuleLoc :: Module -> ConstructorNumber -> ConInfoTableLocation addModuleLoc this_mod mn = do case mn of NoNumber -> DefinitionSite Numbered n -> UsageSite this_mod n --------------------------------------------------------------- -- Lay out and allocate non-top-level constructors --------------------------------------------------------------- buildDynCon :: Id -- Name of the thing to which this constr will -- be bound -> ConstructorNumber -> Bool -- is it genuinely bound to that name, or just -- for profiling? -> CostCentreStack -- Where to grab cost centre from; -- current CCS if currentOrSubsumedCCS -> DataCon -- The data constructor -> [NonVoid StgArg] -- Its args -> FCode (CgIdInfo, FCode CmmAGraph) -- Return details about how to find it and initialization code buildDynCon binder mn actually_bound cc con args = do dflags <- getDynFlags buildDynCon' dflags binder mn actually_bound cc con args buildDynCon' :: DynFlags -> Id -> ConstructorNumber -> Bool -> CostCentreStack -> DataCon -> [NonVoid StgArg] -> FCode (CgIdInfo, FCode CmmAGraph) {- We used to pass a boolean indicating whether all the args were of size zero, so we could use a static constructor; but I concluded that it just isn't worth it. Now I/O uses unboxed tuples there just aren't any constructors with all size-zero args. The reason for having a separate argument, rather than looking at the addr modes of the args is that we may be in a "knot", and premature looking at the args will cause the compiler to black-hole! -} buildDynCon' dflags binder _ _ _cc con args | Just cgInfo <- precomputedStaticConInfo_maybe dflags binder con args -- , pprTrace "noCodeLocal:" (ppr (binder,con,args,cgInfo)) True = return (cgInfo, return mkNop) -------- buildDynCon': the general case ----------- buildDynCon' _ binder mn actually_bound ccs con args = do { (id_info, reg) <- rhsIdInfo binder lf_info ; return (id_info, gen_code reg) } where lf_info = mkConLFInfo con gen_code reg = do { modu <- getModuleName ; profile <- getProfile ; let platform = profilePlatform profile (tot_wds, ptr_wds, args_w_offsets) = mkVirtConstrOffsets profile (addArgReps args) nonptr_wds = tot_wds - ptr_wds info_tbl = mkDataConInfoTable profile con (addModuleLoc modu mn) False ptr_wds nonptr_wds ; let ticky_name | actually_bound = Just binder | otherwise = Nothing ; hp_plus_n <- allocDynClosure ticky_name info_tbl lf_info use_cc blame_cc args_w_offsets ; return (mkRhsInit platform reg lf_info hp_plus_n) } where use_cc -- cost-centre to stick in the object | isCurrentCCS ccs = cccsExpr | otherwise = panic "buildDynCon: non-current CCS not implemented" blame_cc = use_cc -- cost-centre on which to blame the alloc (same) {- Note [Precomputed static closures] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ For Char/Int closures there are some value closures built into the RTS. This is the case for all values in the range mINT_INTLIKE .. mAX_INTLIKE (or CHARLIKE). See Note [CHARLIKE and INTLIKE closures.] in the RTS code. Similarly zero-arity constructors have a closure in their defining Module we can use. If possible we prefer to refer to those existing closure instead of building new ones. This is true at compile time where we do this replacement in this module. But also at runtime where the GC does the same (but only for INT/CHAR closures). `precomputedStaticConInfo_maybe` checks if a given constructor application can be replaced with a reference to a existing static closure. If so the code will reference the existing closure when accessing the binding. Unless the binding is visible to other modules we also generate no code for the binding itself. We can do this since then we can always reference the existing closure. See Note [About the NameSorts] for the definition of external names. For external bindings we must still generate a closure, but won't use it inside this module. This can sometimes reduce cache pressure. Since: * If somebody uses the exported binding: + This module will reference the existing closure. + GC will reference the existing closure. + The importing module will reference the built closure. * If nobody uses the exported binding: + This module will reference the RTS closures. + GC references the RTS closures In the later case we avoided loading the built closure into the cache which is what we optimize for here. Consider this example using Ints. module M(externalInt, foo, bar) where externalInt = 1 :: Int internalInt = 1 :: Int { -# NOINLINE foo #- } foo = Just internalInt :: Maybe Int bar = Just externalInt ==================== STG: ==================== externalInt = I#! [1#]; bar = Just! [externalInt]; internalInt_rc = I#! [2#]; foo = Just! [internalInt_rc]; For externally visible bindings we must generate closures since those may be referenced by their symbol `<name>_closure` when imported. `externalInt` is visible to other modules so we generate a closure: [section ""data" . M.externalInt_closure" { M.externalInt_closure: const GHC.Types.I#_con_info; const 1; }] It will be referenced inside this module via `M.externalInt_closure+1` `internalInt` is however a internal name. As such we generate no code for it. References to it are replaced with references to the static closure as we can see in the closure built for `foo`: [section ""data" . M.foo_closure" { M.foo_closure: const GHC.Maybe.Just_con_info; const stg_INTLIKE_closure+289; // == I# 2 const 3; }] This holds for both local and top level bindings. We don't support this optimization when compiling into Windows DLLs yet because they don't support cross package data references well. -} -- (precomputedStaticConInfo_maybe dflags id con args) -- returns (Just cg_id_info) -- if there is a precomputed static closure for (con args). -- In that case, cg_id_info addresses it. -- See Note [Precomputed static closures] precomputedStaticConInfo_maybe :: DynFlags -> Id -> DataCon -> [NonVoid StgArg] -> Maybe CgIdInfo precomputedStaticConInfo_maybe dflags binder con [] -- Nullary constructors | isNullaryRepDataCon con = Just $ litIdInfo (targetPlatform dflags) binder (mkConLFInfo con) (CmmLabel (mkClosureLabel (dataConName con) NoCafRefs)) precomputedStaticConInfo_maybe dflags binder con [arg] -- Int/Char values with existing closures in the RTS | intClosure || charClosure , platformOS platform /= OSMinGW32 || not (positionIndependent dflags) , Just val <- getClosurePayload arg , inRange val = let intlike_lbl = mkCmmClosureLabel rtsUnitId (fsLit label) val_int = fromIntegral val :: Int offsetW = (val_int - (fromIntegral min_static_range)) * (fixedHdrSizeW profile + 1) -- INTLIKE/CHARLIKE closures consist of a header and one word payload static_amode = cmmLabelOffW platform intlike_lbl offsetW in Just $ litIdInfo platform binder (mkConLFInfo con) static_amode where profile = targetProfile dflags platform = profilePlatform profile intClosure = maybeIntLikeCon con charClosure = maybeCharLikeCon con getClosurePayload (NonVoid (StgLitArg (LitNumber LitNumInt val))) = Just val getClosurePayload (NonVoid (StgLitArg (LitChar val))) = Just $ (fromIntegral . ord $ val) getClosurePayload _ = Nothing -- Avoid over/underflow by comparisons at type Integer! inRange :: Integer -> Bool inRange val = val >= min_static_range && val <= max_static_range constants = platformConstants platform min_static_range :: Integer min_static_range | intClosure = fromIntegral (pc_MIN_INTLIKE constants) | charClosure = fromIntegral (pc_MIN_CHARLIKE constants) | otherwise = panic "precomputedStaticConInfo_maybe: Unknown closure type" max_static_range | intClosure = fromIntegral (pc_MAX_INTLIKE constants) | charClosure = fromIntegral (pc_MAX_CHARLIKE constants) | otherwise = panic "precomputedStaticConInfo_maybe: Unknown closure type" label | intClosure = "stg_INTLIKE" | charClosure = "stg_CHARLIKE" | otherwise = panic "precomputedStaticConInfo_maybe: Unknown closure type" precomputedStaticConInfo_maybe _ _ _ _ = Nothing --------------------------------------------------------------- -- Binding constructor arguments --------------------------------------------------------------- bindConArgs :: AltCon -> LocalReg -> [NonVoid Id] -> FCode [LocalReg] -- bindConArgs is called from cgAlt of a case -- (bindConArgs con args) augments the environment with bindings for the -- binders args, assuming that we have just returned from a 'case' which -- found a con bindConArgs (DataAlt con) base args = ASSERT(not (isUnboxedTupleDataCon con)) do profile <- getProfile platform <- getPlatform let (_, _, args_w_offsets) = mkVirtConstrOffsets profile (addIdReps args) tag = tagForCon platform con -- The binding below forces the masking out of the tag bits -- when accessing the constructor field. bind_arg :: (NonVoid Id, ByteOff) -> FCode (Maybe LocalReg) bind_arg (arg@(NonVoid b), offset) | isDeadBinder b -- See Note [Dead-binder optimisation] in GHC.StgToCmm.Expr = return Nothing | otherwise = do { emit $ mkTaggedObjectLoad platform (idToReg platform arg) base offset tag ; Just <$> bindArgToReg arg } mapMaybeM bind_arg args_w_offsets bindConArgs _other_con _base args = ASSERT( null args ) return []