import DsMonad
-import CoreUtils ( exprType, mkCoerce )
+import CoreUtils ( exprType )
import Id ( Id, mkWildId, idType )
import MkId ( mkFCallId, realWorldPrimId, mkPrimOpId )
import Maybes ( maybeToBool )
import ForeignCall ( ForeignCall(..), CCallSpec(..), CCallTarget(..), Safety, CCallConv(..) )
import DataCon ( splitProductType_maybe, dataConSourceArity, dataConWrapId )
import ForeignCall ( ForeignCall, CCallTarget(..) )
-import Type ( isUnLiftedType, splitAlgTyConApp_maybe, mkFunTys,
- splitTyConApp_maybe, tyVarsOfType, mkForAllTys,
- isNewType, repType, isUnLiftedType, mkFunTy, mkTyConApp,
- Type
+
+import TcType ( Type, isUnLiftedType, mkFunTys, mkFunTy,
+ tyVarsOfType, mkForAllTys, mkTyConApp,
+ isBoolTy, isUnitTy, isPrimitiveType
)
+import Type ( splitTyConApp_maybe, repType, eqType ) -- Sees the representation type
import PrimOp ( PrimOp(TouchOp) )
import TysPrim ( realWorldStatePrimTy,
byteArrayPrimTyCon, mutableByteArrayPrimTyCon,
intPrimTy, foreignObjPrimTy
)
+import TyCon ( tyConDataCons )
import TysWiredIn ( unitDataConId,
unboxedSingletonDataCon, unboxedPairDataCon,
unboxedSingletonTyCon, unboxedPairTyCon,
- boolTy, trueDataCon, falseDataCon,
- trueDataConId, falseDataConId, unitTy
+ trueDataCon, falseDataCon,
+ trueDataConId, falseDataConId
)
import Literal ( mkMachInt )
import CStrings ( CLabelString )
boxResult [] result_ty `thenDs` \ (ccall_result_ty, res_wrapper) ->
getUniqueDs `thenDs` \ uniq ->
let
- the_fcall = CCall (CCallSpec (StaticTarget lbl) CCallConv may_gc is_asm)
+ target | is_asm = CasmTarget lbl
+ | otherwise = StaticTarget lbl
+ the_fcall = CCall (CCallSpec target CCallConv may_gc)
the_prim_app = mkFCall uniq the_fcall unboxed_args ccall_result_ty
in
returnDs (foldr ($) (res_wrapper the_prim_app) arg_wrappers)
-- where W is a CoreExpr that probably mentions x#
unboxArg arg
- -- Unlifted types: nothing to unbox
- | isUnLiftedType arg_ty
+ -- Primtive types: nothing to unbox
+ | isPrimitiveType arg_ty
= returnDs (arg, \body -> body)
- -- Newtypes
- | isNewType arg_ty
- = unboxArg (mkCoerce (repType arg_ty) arg_ty arg)
-
-- Booleans
- | arg_ty == boolTy
+ | isBoolTy arg_ty
= newSysLocalDs intPrimTy `thenDs` \ prim_arg ->
returnDs (Var prim_arg,
\ body -> Case (Case arg (mkWildId arg_ty)
prim_arg
[(DEFAULT,[],body)])
+ -- Newtypes
-- Data types with a single constructor, which has a single, primitive-typed arg
-- This deals with Int, Float etc
| is_product_type && data_con_arity == 1
= getSrcLocDs `thenDs` \ l ->
pprPanic "unboxArg: " (ppr l <+> ppr arg_ty)
where
- arg_ty = exprType arg
+ arg_ty = repType (exprType arg)
+ -- The repType looks through any newtype or
+ -- implicit-parameter wrappings on the argument.
maybe_product_type = splitProductType_maybe arg_ty
is_product_type = maybeToBool maybe_product_type
Just (_, _, data_con, data_con_arg_tys) = maybe_product_type
-- the call. The arg_ids passed in are the Ids passed to the actual ccall.
boxResult arg_ids result_ty
- = case splitAlgTyConApp_maybe result_ty of
+ = case splitTyConApp_maybe result_ty of
-- The result is IO t, so wrap the result in an IO constructor
- Just (io_tycon, [io_res_ty], [io_data_con]) | io_tycon `hasKey` ioTyConKey
+ Just (io_tycon, [io_res_ty]) | io_tycon `hasKey` ioTyConKey
-> mk_alt return_result
(resultWrapper io_res_ty) `thenDs` \ (ccall_res_ty, the_alt) ->
newSysLocalDs realWorldStatePrimTy `thenDs` \ state_id ->
let
+ io_data_con = head (tyConDataCons io_tycon)
wrap = \ the_call ->
mkApps (Var (dataConWrapId io_data_con))
[ Type io_res_ty,
mkTouches [] s cont = returnDs (cont s)
mkTouches (v:vs) s cont
- | idType v /= foreignObjPrimTy = mkTouches vs s cont
+ | not (idType v `eqType` foreignObjPrimTy) = mkTouches vs s cont
| otherwise = newSysLocalDs realWorldStatePrimTy `thenDs` \s' ->
mkTouches vs s' cont `thenDs` \ rest ->
returnDs (Case (mkApps (Var touchzh) [Type foreignObjPrimTy,
CoreExpr -> CoreExpr) -- Wrapper for the result
resultWrapper result_ty
-- Base case 1: primitive types
- | isUnLiftedType result_ty
+ | isPrimitiveType result_ty_rep
= (Just result_ty, \e -> e)
- -- Base case 1: the unit type ()
- | result_ty == unitTy
+ -- Base case 2: the unit type ()
+ | isUnitTy result_ty_rep
= (Nothing, \e -> Var unitDataConId)
- | result_ty == boolTy
+ -- Base case 3: the boolean type ()
+ | isBoolTy result_ty_rep
= (Just intPrimTy, \e -> Case e (mkWildId intPrimTy)
- [(LitAlt (mkMachInt 0),[],Var falseDataConId),
- (DEFAULT ,[],Var trueDataConId )])
+ [(DEFAULT ,[],Var trueDataConId ),
+ (LitAlt (mkMachInt 0),[],Var falseDataConId)])
-- Data types with a single constructor, which has a single arg
- | is_product_type && data_con_arity == 1
+ | Just (_, tycon_arg_tys, data_con, data_con_arg_tys) <- splitProductType_maybe result_ty_rep,
+ dataConSourceArity data_con == 1
= let
(maybe_ty, wrapper) = resultWrapper unwrapped_res_ty
(unwrapped_res_ty : _) = data_con_arg_tys
(maybe_ty, \e -> mkApps (Var (dataConWrapId data_con))
(map Type tycon_arg_tys ++ [wrapper e]))
- -- newtypes
- | isNewType result_ty
- = let
- rep_ty = repType result_ty
- (maybe_ty, wrapper) = resultWrapper rep_ty
- in
- (maybe_ty, \e -> mkCoerce result_ty rep_ty (wrapper e))
-
| otherwise
= pprPanic "resultWrapper" (ppr result_ty)
where
- maybe_product_type = splitProductType_maybe result_ty
- is_product_type = maybeToBool maybe_product_type
- Just (_, tycon_arg_tys, data_con, data_con_arg_tys) = maybe_product_type
- data_con_arity = dataConSourceArity data_con
+ result_ty_rep = repType result_ty
\end{code}
projects / ghc-hetmet.git / blobdiff