import DsMonad
-import CoreUtils ( exprType )
-import Id ( Id, mkWildId, idType )
+import CoreUtils ( exprType, mkCoerce2 )
+import Id ( Id, mkWildId )
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 TcType ( Type, isUnLiftedType, mkFunTys, mkFunTy,
+import TcType ( tcSplitTyConApp_maybe )
+import Type ( Type, isUnLiftedType, mkFunTys, mkFunTy,
tyVarsOfType, mkForAllTys, mkTyConApp,
- isBoolTy, isUnitTy, isPrimitiveType
+ isPrimitiveType, splitTyConApp_maybe, splitNewType_maybe
)
-import Type ( splitTyConApp_maybe, repType, eqType ) -- Sees the representation type
-import PrimOp ( PrimOp(TouchOp) )
-import TysPrim ( realWorldStatePrimTy,
- byteArrayPrimTyCon, mutableByteArrayPrimTyCon,
- intPrimTy, foreignObjPrimTy
+
+import PrimOp ( PrimOp(..) )
+import TysPrim ( realWorldStatePrimTy, intPrimTy,
+ byteArrayPrimTyCon, mutableByteArrayPrimTyCon
)
-import TyCon ( tyConDataCons )
+import TyCon ( TyCon, tyConDataCons )
import TysWiredIn ( unitDataConId,
unboxedSingletonDataCon, unboxedPairDataCon,
unboxedSingletonTyCon, unboxedPairTyCon,
)
import Literal ( mkMachInt )
import CStrings ( CLabelString )
-import PrelNames ( Unique, hasKey, ioTyConKey )
+import PrelNames ( Unique, hasKey, ioTyConKey, boolTyConKey, unitTyConKey,
+ int8TyConKey, int16TyConKey, int32TyConKey,
+ word8TyConKey, word16TyConKey, word32TyConKey
+ )
import VarSet ( varSetElems )
+import Constants ( wORD_SIZE)
import Outputable
\end{code}
| isPrimitiveType arg_ty
= returnDs (arg, \body -> body)
+ -- Recursive newtypes
+ | Just rep_ty <- splitNewType_maybe arg_ty
+ = unboxArg (mkCoerce2 rep_ty arg_ty arg)
+
-- Booleans
- | isBoolTy arg_ty
+ | 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)
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
)
-- 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 = repType (exprType arg)
- -- The repType looks through any newtype or
- -- implicit-parameter wrappings on the argument.
+ 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 result type will be
-- State# RealWorld -> (# State# RealWorld #)
--- Here is where we arrange that ForeignPtrs which are passed to a 'safe'
--- foreign import don't get finalized until the call returns. For each
--- argument of type ForeignObj# we arrange to touch# the argument after
--- the call. The arg_ids passed in are the Ids passed to the actual ccall.
-
boxResult arg_ids result_ty
- = case splitTyConApp_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_tycon `hasKey` ioTyConKey
where
mk_alt return_result (Nothing, wrap_result)
= -- The ccall returns ()
- let
- rhs_fun state_id = return_result (Var state_id)
- (wrap_result (panic "boxResult"))
- in
newSysLocalDs realWorldStatePrimTy `thenDs` \ state_id ->
- mkTouches arg_ids state_id rhs_fun `thenDs` \ the_rhs ->
let
+ the_rhs = return_result (Var state_id)
+ (wrap_result (panic "boxResult"))
+
ccall_res_ty = mkTyConApp unboxedSingletonTyCon [realWorldStatePrimTy]
the_alt = (DataAlt unboxedSingletonDataCon, [state_id], the_rhs)
in
mk_alt return_result (Just prim_res_ty, wrap_result)
= -- The ccall returns a non-() value
newSysLocalDs prim_res_ty `thenDs` \ result_id ->
- let
- rhs_fun state_id = return_result (Var state_id)
- (wrap_result (Var result_id))
- in
newSysLocalDs realWorldStatePrimTy `thenDs` \ state_id ->
- mkTouches arg_ids state_id rhs_fun `thenDs` \ the_rhs ->
let
+ the_rhs = return_result (Var state_id)
+ (wrap_result (Var result_id))
+
ccall_res_ty = mkTyConApp unboxedPairTyCon [realWorldStatePrimTy, prim_res_ty]
the_alt = (DataAlt unboxedPairDataCon, [state_id, result_id], the_rhs)
in
returnDs (ccall_res_ty, the_alt)
-touchzh = mkPrimOpId TouchOp
-
-mkTouches [] s cont = returnDs (cont s)
-mkTouches (v: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,
- Var v, Var s]) s'
- [(DEFAULT, [], rest)])
resultWrapper :: Type
-> (Maybe Type, -- Type of the expected result, if any
CoreExpr -> CoreExpr) -- Wrapper for the result
resultWrapper result_ty
-- Base case 1: primitive types
- | isPrimitiveType result_ty_rep
+ | isPrimitiveType result_ty
= (Just result_ty, \e -> e)
-- Base case 2: the unit type ()
- | isUnitTy result_ty_rep
+ | Just (tc,_) <- maybe_tc_app, tc `hasKey` unitTyConKey
= (Nothing, \e -> Var unitDataConId)
- -- Base case 3: the boolean type ()
- | isBoolTy result_ty_rep
+ -- Base case 3: the boolean type
+ | Just (tc,_) <- maybe_tc_app, tc `hasKey` boolTyConKey
= (Just intPrimTy, \e -> Case e (mkWildId intPrimTy)
[(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 -> mkCoerce2 result_ty rep_ty (wrapper e))
+
-- Data types with a single constructor, which has a single arg
- | Just (_, tycon_arg_tys, data_con, data_con_arg_tys) <- splitProductType_maybe result_ty_rep,
+ | Just (tycon, 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
+ narrow_wrapper = maybeNarrow tycon
in
(maybe_ty, \e -> mkApps (Var (dataConWrapId data_con))
- (map Type tycon_arg_tys ++ [wrapper e]))
+ (map Type tycon_arg_tys ++ [wrapper (narrow_wrapper e)]))
| otherwise
= pprPanic "resultWrapper" (ppr result_ty)
where
- result_ty_rep = repType result_ty
+ maybe_tc_app = splitTyConApp_maybe result_ty
+
+-- When the result of a foreign call is smaller than the word size, we
+-- need to sign- or zero-extend the result up to the word size. The C
+-- standard appears to say that this is the responsibility of the
+-- caller, not the callee.
+
+maybeNarrow :: TyCon -> (CoreExpr -> CoreExpr)
+maybeNarrow tycon
+ | tycon `hasKey` int8TyConKey = \e -> App (Var (mkPrimOpId Narrow8IntOp)) e
+ | tycon `hasKey` int16TyConKey = \e -> App (Var (mkPrimOpId Narrow16IntOp)) e
+ | tycon `hasKey` int32TyConKey
+ && wORD_SIZE > 4 = \e -> App (Var (mkPrimOpId Narrow32IntOp)) e
+
+ | tycon `hasKey` word8TyConKey = \e -> App (Var (mkPrimOpId Narrow8WordOp)) e
+ | tycon `hasKey` word16TyConKey = \e -> App (Var (mkPrimOpId Narrow16WordOp)) e
+ | tycon `hasKey` word32TyConKey
+ && wORD_SIZE > 4 = \e -> App (Var (mkPrimOpId Narrow32WordOp)) e
+ | otherwise = id
\end{code}
projects / ghc-hetmet.git / blobdiff