X-Git-Url: http://git.megacz.com/?p=ghc-hetmet.git;a=blobdiff_plain;f=compiler%2FbasicTypes%2FMkId.lhs;h=d7cd8cd5c953611b93784dcd6ac4e71f79e749e7;hp=7060c803060a0f74bdad35849aa040cbe8dbe9fa;hb=5e3c9a59c4827b1fbde59461076b4839d57efd7c;hpb=291f2adda098f7e275db3720ed07e7dc77c821c4 diff --git a/compiler/basicTypes/MkId.lhs b/compiler/basicTypes/MkId.lhs index 7060c80..d7cd8cd 100644 --- a/compiler/basicTypes/MkId.lhs +++ b/compiler/basicTypes/MkId.lhs @@ -12,13 +12,6 @@ have a standard form, namely: - primitive operations \begin{code} -{-# OPTIONS -fno-warn-missing-signatures #-} --- The above warning supression flag is a temporary kludge. --- While working on this module you are encouraged to remove it and fix --- any warnings in the module. See --- --- for details - module MkId ( mkDictFunId, mkDefaultMethodId, mkDictSelId, @@ -65,7 +58,7 @@ import DataCon import Id import Var ( Var, TyVar, mkCoVar, mkExportedLocalVar ) import IdInfo -import NewDemand +import Demand import CoreSyn import Unique import PrelNames @@ -244,9 +237,9 @@ mkDataConIds wrap_name wkr_name data_con | isNewTyCon tycon -- Newtype, only has a worker = DCIds Nothing nt_work_id - | any isMarkedStrict all_strict_marks -- Algebraic, needs wrapper - || not (null eq_spec) -- NB: LoadIface.ifaceDeclSubBndrs - || isFamInstTyCon tycon -- depends on this test + | any isBanged all_strict_marks -- Algebraic, needs wrapper + || not (null eq_spec) -- NB: LoadIface.ifaceDeclSubBndrs + || isFamInstTyCon tycon -- depends on this test = DCIds (Just alg_wrap_id) wrk_id | otherwise -- Algebraic, no wrapper @@ -265,7 +258,7 @@ mkDataConIds wrap_name wkr_name data_con wkr_arity = dataConRepArity data_con wkr_info = noCafIdInfo `setArityInfo` wkr_arity - `setAllStrictnessInfo` Just wkr_sig + `setStrictnessInfo` Just wkr_sig `setUnfoldingInfo` evaldUnfolding -- Record that it's evaluated, -- even if arity = 0 @@ -329,13 +322,13 @@ mkDataConIds wrap_name wkr_name data_con -- It's important to specify the arity, so that partial -- applications are treated as values `setUnfoldingInfo` wrap_unf - `setAllStrictnessInfo` Just wrap_sig + `setStrictnessInfo` Just wrap_sig all_strict_marks = dataConExStricts data_con ++ dataConStrictMarks data_con wrap_sig = mkStrictSig (mkTopDmdType arg_dmds cpr_info) arg_dmds = map mk_dmd all_strict_marks - mk_dmd str | isMarkedStrict str = evalDmd - | otherwise = lazyDmd + mk_dmd str | isBanged str = evalDmd + | otherwise = lazyDmd -- The Cpr info can be important inside INLINE rhss, where the -- wrapper constructor isn't inlined. -- And the argument strictness can be important too; we @@ -345,8 +338,8 @@ mkDataConIds wrap_name wkr_name data_con -- ...(let w = C x in ...(w p q)...)... -- we want to see that w is strict in its two arguments - wrap_unf = mkImplicitUnfolding $ Note InlineMe $ - mkLams wrap_tvs $ + wrap_unf = mkInlineRule wrap_rhs (Just (length dict_args + length id_args)) + wrap_rhs = mkLams wrap_tvs $ mkLams eq_args $ mkLams dict_args $ mkLams id_args $ foldr mk_case con_app @@ -372,23 +365,21 @@ mkDataConIds wrap_name wkr_name data_con in (y:ys,j) mk_case - :: (Id, StrictnessMark) -- Arg, strictness + :: (Id, HsBang) -- Arg, strictness -> (Int -> [Id] -> CoreExpr) -- Body -> Int -- Next rep arg id -> [Id] -- Rep args so far, reversed -> CoreExpr mk_case (arg,strict) body i rep_args = case strict of - NotMarkedStrict -> body i (arg:rep_args) - MarkedStrict - | isUnLiftedType (idType arg) -> body i (arg:rep_args) - | otherwise -> - Case (Var arg) arg res_ty [(DEFAULT,[], body i (arg:rep_args))] - - MarkedUnboxed - -> unboxProduct i (Var arg) (idType arg) the_body + HsNoBang -> body i (arg:rep_args) + HsUnpack -> unboxProduct i (Var arg) (idType arg) the_body where the_body i con_args = body i (reverse con_args ++ rep_args) + _other -- HsUnpackFailed and HsStrict + | isUnLiftedType (idType arg) -> body i (arg:rep_args) + | otherwise -> Case (Var arg) arg res_ty + [(DEFAULT,[], body i (arg:rep_args))] mAX_CPR_SIZE :: Arity mAX_CPR_SIZE = 10 @@ -401,6 +392,7 @@ mAX_CPR_SIZE = 10 -- by the caller. So doing CPR for them may in fact make -- things worse. +mkLocals :: Int -> [Type] -> ([Id], Int) mkLocals i tys = (zipWith mkTemplateLocal [i..i+n-1] tys, i+n) where n = length tys @@ -457,34 +449,53 @@ mkDictSelId no_unf name clas -- But it's type must expose the representation of the dictionary -- to get (say) C a -> (a -> a) - info = noCafIdInfo - `setArityInfo` 1 - `setAllStrictnessInfo` Just strict_sig - `setUnfoldingInfo` (if no_unf then noUnfolding - else mkImplicitUnfolding rhs) - - -- We no longer use 'must-inline' on record selectors. They'll - -- inline like crazy if they scrutinise a constructor + base_info = noCafIdInfo + `setArityInfo` 1 + `setStrictnessInfo` Just strict_sig + `setUnfoldingInfo` (if no_unf then noUnfolding + else mkImplicitUnfolding rhs) + -- In module where class op is defined, we must add + -- the unfolding, even though it'll never be inlined + -- becuase we use that to generate a top-level binding + -- for the ClassOp + + info = base_info `setSpecInfo` mkSpecInfo [rule] + `setInlinePragInfo` neverInlinePragma + -- Add a magic BuiltinRule, and never inline it + -- so that the rule is always available to fire. + -- See Note [ClassOp/DFun selection] in TcInstDcls + + n_ty_args = length tyvars + + -- This is the built-in rule that goes + -- op (dfT d1 d2) ---> opT d1 d2 + rule = BuiltinRule { ru_name = fsLit "Class op " `appendFS` + occNameFS (getOccName name) + , ru_fn = name + , ru_nargs = n_ty_args + 1 + , ru_try = dictSelRule index n_ty_args } -- The strictness signature is of the form U(AAAVAAAA) -> T -- where the V depends on which item we are selecting -- It's worth giving one, so that absence info etc is generated -- even if the selector isn't inlined strict_sig = mkStrictSig (mkTopDmdType [arg_dmd] TopRes) - arg_dmd | isNewTyCon tycon = evalDmd - | otherwise = Eval (Prod [ if the_arg_id == id then evalDmd else Abs - | id <- arg_ids ]) + arg_dmd | new_tycon = evalDmd + | otherwise = Eval (Prod [ if the_arg_id == id then evalDmd else Abs + | id <- arg_ids ]) tycon = classTyCon clas + new_tycon = isNewTyCon tycon [data_con] = tyConDataCons tycon tyvars = dataConUnivTyVars data_con arg_tys = {- ASSERT( isVanillaDataCon data_con ) -} dataConRepArgTys data_con eq_theta = dataConEqTheta data_con - the_arg_id = assoc "MkId.mkDictSelId" (map idName (classSelIds clas) `zip` arg_ids) name + index = assoc "MkId.mkDictSelId" (map idName (classSelIds clas) `zip` [0..]) name + the_arg_id = arg_ids !! index pred = mkClassPred clas (mkTyVarTys tyvars) - dict_id = mkTemplateLocal 1 $ mkPredTy pred - (eq_ids,n) = mkCoVarLocals 2 $ mkPredTys eq_theta + dict_id = mkTemplateLocal 1 $ mkPredTy pred + (eq_ids,n) = mkCoVarLocals 2 $ mkPredTys eq_theta arg_ids = mkTemplateLocalsNum n arg_tys mkCoVarLocals i [] = ([],i) @@ -493,9 +504,23 @@ mkDictSelId no_unf name clas in (y:ys,j) rhs = mkLams tyvars (Lam dict_id rhs_body) - rhs_body | isNewTyCon tycon = unwrapNewTypeBody tycon (map mkTyVarTy tyvars) (Var dict_id) - | otherwise = Case (Var dict_id) dict_id (idType the_arg_id) - [(DataAlt data_con, eq_ids ++ arg_ids, Var the_arg_id)] + rhs_body | new_tycon = unwrapNewTypeBody tycon (map mkTyVarTy tyvars) (Var dict_id) + | otherwise = Case (Var dict_id) dict_id (idType the_arg_id) + [(DataAlt data_con, eq_ids ++ arg_ids, Var the_arg_id)] + +dictSelRule :: Int -> Arity -> IdUnfoldingFun -> [CoreExpr] -> Maybe CoreExpr +-- Oh, very clever +-- op_i t1..tk (df s1..sn d1..dm) = op_i_helper s1..sn d1..dm +-- op_i t1..tk (D t1..tk op1 ... opm) = opi +-- +-- NB: the data constructor has the same number of type args as the class op + +dictSelRule index n_ty_args id_unf args + | (dict_arg : _) <- drop n_ty_args args + , Just (_, _, val_args) <- exprIsConApp_maybe id_unf dict_arg + = Just (val_args !! index) + | otherwise + = Nothing \end{code} @@ -726,7 +751,7 @@ mkPrimOpId prim_op info = noCafIdInfo `setSpecInfo` mkSpecInfo (primOpRules prim_op name) `setArityInfo` arity - `setAllStrictnessInfo` Just strict_sig + `setStrictnessInfo` Just strict_sig -- For each ccall we manufacture a separate CCallOpId, giving it -- a fresh unique, a type that is correct for this particular ccall, @@ -752,7 +777,7 @@ mkFCallId uniq fcall ty info = noCafIdInfo `setArityInfo` arity - `setAllStrictnessInfo` Just strict_sig + `setStrictnessInfo` Just strict_sig (_, tau) = tcSplitForAllTys ty (arg_tys, _) = tcSplitFunTys tau @@ -775,6 +800,7 @@ mkBreakPointOpId :: Unique -> Module -> TickBoxId -> Id mkBreakPointOpId uniq mod ix = mkTickBox' uniq mod ix ty where ty = mkSigmaTy [openAlphaTyVar] [] openAlphaTy +mkTickBox' :: Unique -> Module -> TickBoxId -> Type -> Id mkTickBox' uniq mod ix ty = mkGlobalId (TickBoxOpId tickbox) name ty info where tickbox = TickBox mod ix @@ -815,7 +841,10 @@ BUT make sure they are *exported* LocalIds (mkExportedLocalId) so that they aren't discarded by the occurrence analyser. \begin{code} -mkDefaultMethodId dm_name ty = mkExportedLocalId dm_name ty +mkDefaultMethodId :: Id -- Selector Id + -> Name -- Default method name + -> Id -- Default method Id +mkDefaultMethodId sel_id dm_name = mkExportedLocalId dm_name (idType sel_id) mkDictFunId :: Name -- Name to use for the dict fun; -> [TyVar] @@ -825,8 +854,9 @@ mkDictFunId :: Name -- Name to use for the dict fun; -> Id mkDictFunId dfun_name inst_tyvars dfun_theta clas inst_tys - = mkExportedLocalVar DFunId dfun_name dfun_ty vanillaIdInfo + = mkExportedLocalVar (DFunId is_nt) dfun_name dfun_ty vanillaIdInfo where + is_nt = isNewTyCon (classTyCon clas) dfun_ty = mkSigmaTy inst_tyvars dfun_theta (mkDictTy clas inst_tys) \end{code} @@ -853,9 +883,14 @@ they can unify with both unlifted and lifted types. Hence we provide another gun with which to shoot yourself in the foot. \begin{code} +mkWiredInIdName :: Module -> FastString -> Unique -> Id -> Name mkWiredInIdName mod fs uniq id = mkWiredInName mod (mkOccNameFS varName fs) uniq (AnId id) UserSyntax +unsafeCoerceName, nullAddrName, seqName, realWorldName :: Name +lazyIdName, errorName, recSelErrorName, runtimeErrorName :: Name +irrefutPatErrorName, recConErrorName, patErrorName :: Name +nonExhaustiveGuardsErrorName, noMethodBindingErrorName :: Name unsafeCoerceName = mkWiredInIdName gHC_PRIM (fsLit "unsafeCoerce#") unsafeCoerceIdKey unsafeCoerceId nullAddrName = mkWiredInIdName gHC_PRIM (fsLit "nullAddr#") nullAddrIdKey nullAddrId seqName = mkWiredInIdName gHC_PRIM (fsLit "seq") seqIdKey seqId @@ -878,17 +913,18 @@ nonExhaustiveGuardsErrorName \begin{code} ------------------------------------------------ -- unsafeCoerce# :: forall a b. a -> b +unsafeCoerceId :: Id unsafeCoerceId = pcMiscPrelId unsafeCoerceName ty info where info = noCafIdInfo `setUnfoldingInfo` mkCompulsoryUnfolding rhs - ty = mkForAllTys [openAlphaTyVar,openBetaTyVar] - (mkFunTy openAlphaTy openBetaTy) - [x] = mkTemplateLocals [openAlphaTy] - rhs = mkLams [openAlphaTyVar,openBetaTyVar,x] $ - Cast (Var x) (mkUnsafeCoercion openAlphaTy openBetaTy) + ty = mkForAllTys [argAlphaTyVar,openBetaTyVar] + (mkFunTy argAlphaTy openBetaTy) + [x] = mkTemplateLocals [argAlphaTy] + rhs = mkLams [argAlphaTyVar,openBetaTyVar,x] $ + Cast (Var x) (mkUnsafeCoercion argAlphaTy openBetaTy) ------------------------------------------------ nullAddrId :: Id @@ -905,6 +941,7 @@ seqId :: Id -- See Note [seqId magic] seqId = pcMiscPrelId seqName ty info where info = noCafIdInfo `setUnfoldingInfo` mkCompulsoryUnfolding rhs + `setSpecInfo` mkSpecInfo [seq_cast_rule] ty = mkForAllTys [alphaTyVar,openBetaTyVar] @@ -912,6 +949,20 @@ seqId = pcMiscPrelId seqName ty info [x,y] = mkTemplateLocals [alphaTy, openBetaTy] rhs = mkLams [alphaTyVar,openBetaTyVar,x,y] (Case (Var x) x openBetaTy [(DEFAULT, [], Var y)]) + -- See Note [Built-in RULES for seq] + seq_cast_rule = BuiltinRule { ru_name = fsLit "seq of cast" + , ru_fn = seqName + , ru_nargs = 4 + , ru_try = match_seq_of_cast + } + +match_seq_of_cast :: IdUnfoldingFun -> [CoreExpr] -> Maybe CoreExpr + -- See Note [Built-in RULES for seq] +match_seq_of_cast _ [Type _, Type res_ty, Cast scrut co, expr] + = Just (Var seqId `mkApps` [Type (fst (coercionKind co)), Type res_ty, + scrut, expr]) +match_seq_of_cast _ _ = Nothing + ------------------------------------------------ lazyId :: Id -- See Note [lazyId magic] lazyId = pcMiscPrelId lazyIdName ty info @@ -932,10 +983,10 @@ b) Its fixity is set in LoadIface.ghcPrimIface c) It has quite a bit of desugaring magic. See DsUtils.lhs Note [Desugaring seq (1)] and (2) and (3) -d) There is some special rule handing: Note [RULES for seq] +d) There is some special rule handing: Note [User-defined RULES for seq] -Note [Rules for seq] -~~~~~~~~~~~~~~~~~~~~ +Note [User-defined RULES for seq] +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Roman found situations where he had case (f n) of _ -> e where he knew that f (which was strict in n) would terminate if n did. @@ -957,6 +1008,20 @@ To make this work, we need to be careful that the magical desugaring done in Note [seqId magic] item (c) is *not* done on the LHS of a rule. Or rather, we arrange to un-do it, in DsBinds.decomposeRuleLhs. +Note [Built-in RULES for seq] +~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +We also have the following built-in rule for seq + + seq (x `cast` co) y = seq x y + +This eliminates unnecessary casts and also allows other seq rules to +match more often. Notably, + + seq (f x `cast` co) y --> seq (f x) y + +and now a user-defined rule for seq (see Note [User-defined RULES for seq]) +may fire. + Note [lazyId magic] ~~~~~~~~~~~~~~~~~~~ @@ -990,6 +1055,7 @@ E.g. This comes up in strictness analysis \begin{code} +realWorldPrimId :: Id realWorldPrimId -- :: State# RealWorld = pcMiscPrelId realWorldName realWorldStatePrimTy (noCafIdInfo `setUnfoldingInfo` evaldUnfolding) @@ -1042,6 +1108,8 @@ mkImpossibleExpr :: Type -> CoreExpr mkImpossibleExpr res_ty = mkRuntimeErrorApp rUNTIME_ERROR_ID res_ty "Impossible case alternative" +rEC_SEL_ERROR_ID, rUNTIME_ERROR_ID, iRREFUT_PAT_ERROR_ID, rEC_CON_ERROR_ID :: Id +pAT_ERROR_ID, nO_METHOD_BINDING_ERROR_ID, nON_EXHAUSTIVE_GUARDS_ERROR_ID :: Id rEC_SEL_ERROR_ID = mkRuntimeErrorId recSelErrorName rUNTIME_ERROR_ID = mkRuntimeErrorId runtimeErrorName iRREFUT_PAT_ERROR_ID = mkRuntimeErrorId irrefutPatErrorName @@ -1060,6 +1128,7 @@ runtimeErrorTy = mkSigmaTy [openAlphaTyVar] [] (mkFunTy addrPrimTy openAlphaTy) \end{code} \begin{code} +eRROR_ID :: Id eRROR_ID = pc_bottoming_Id errorName errorTy errorTy :: Type @@ -1091,7 +1160,7 @@ pc_bottoming_Id :: Name -> Type -> Id pc_bottoming_Id name ty = pcMiscPrelId name ty bottoming_info where - bottoming_info = vanillaIdInfo `setAllStrictnessInfo` Just strict_sig + bottoming_info = vanillaIdInfo `setStrictnessInfo` Just strict_sig `setArityInfo` 1 -- Make arity and strictness agree