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, isPrimitiveType,
- isNewType, repType, isUnLiftedType, mkFunTy, mkTyConApp,
- Type
+
+import TcType ( tcSplitTyConApp_maybe )
+import Type ( Type, isUnLiftedType, mkFunTys, mkFunTy,
+ tyVarsOfType, mkForAllTys, mkTyConApp,
+ isPrimitiveType, eqType,
+ splitTyConApp_maybe, splitNewType_maybe
)
+
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 )
-import PrelNames ( Unique, hasKey, ioTyConKey )
+import PrelNames ( Unique, hasKey, ioTyConKey, boolTyConKey, unitTyConKey )
import VarSet ( varSetElems )
import Outputable
\end{code}
| isPrimitiveType arg_ty
= returnDs (arg, \body -> body)
- -- Newtypes
- | isNewType arg_ty
- = unboxArg (mkCoerce (repType arg_ty) arg_ty arg)
+ -- Recursive newtypes
+ | Just rep_ty <- splitNewType_maybe arg_ty
+ = unboxArg (mkCoerce rep_ty arg_ty arg)
-- Booleans
- | arg_ty == boolTy
+ | Just (tc,_) <- splitTyConApp_maybe arg_ty,
+ tc `hasKey` boolTyConKey
= newSysLocalDs intPrimTy `thenDs` \ prim_arg ->
returnDs (Var prim_arg,
\ body -> Case (Case arg (mkWildId arg_ty)
)
-- Byte-arrays, both mutable and otherwise; hack warning
+ -- We're looking for values of type ByteArray, MutableByteArray
+ -- data ByteArray ix = ByteArray ix ix ByteArray#
+ -- data MutableByteArray s ix = MutableByteArray ix ix (MutableByteArray# s)
| is_product_type &&
data_con_arity == 3 &&
maybeToBool maybe_arg3_tycon &&
= getSrcLocDs `thenDs` \ l ->
pprPanic "unboxArg: " (ppr l <+> ppr arg_ty)
where
- arg_ty = exprType arg
+ arg_ty = exprType arg
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 tcSplitTyConApp_maybe result_ty of
+ -- This split absolutely has to be a tcSplit, because we must
+ -- see the IO type; and it's a newtype which is transparent to splitTyConApp.
-- 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,
| isPrimitiveType result_ty
= (Just result_ty, \e -> e)
- -- Base case 1: the unit type ()
- | result_ty == unitTy
+ -- Base case 2: the unit type ()
+ | Just (tc,_) <- maybe_tc_app, tc `hasKey` unitTyConKey
= (Nothing, \e -> Var unitDataConId)
- | result_ty == boolTy
+ -- Base case 3: the boolean type
+ | Just (tc,_) <- maybe_tc_app, tc `hasKey` boolTyConKey
= (Just intPrimTy, \e -> Case e (mkWildId intPrimTy)
- [(LitAlt (mkMachInt 0),[],Var falseDataConId),
- (DEFAULT ,[],Var trueDataConId )])
+ [(DEFAULT ,[],Var trueDataConId ),
+ (LitAlt (mkMachInt 0),[],Var falseDataConId)])
+
+ -- Recursive newtypes
+ | Just rep_ty <- splitNewType_maybe result_ty
+ = let
+ (maybe_ty, wrapper) = resultWrapper rep_ty
+ in
+ (maybe_ty, \e -> mkCoerce result_ty rep_ty (wrapper e))
-- 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,
+ 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
+ maybe_tc_app = splitTyConApp_maybe result_ty
\end{code}