%
% (c) The University of Glasgow 2006
% (c) The AQUA Project, Glasgow University, 1994-1998
%

Desugaring foreign calls

\begin{code}
module DsCCall 
	( dsCCall
	, mkFCall
	, unboxArg
	, boxResult
	, unboxResult
	, resultWrapper
	) where

#include "HsVersions.h"


import CoreSyn

import DsMonad

import CoreUtils
import Id
import MkId
import Maybes
import ForeignCall
import DataCon

import TcType
import Type
import Coercion
import FamInstEnv
import PrimOp
import TysPrim
import TyCon
import TysWiredIn
import BasicTypes
import Literal
import PrelNames
import VarSet
import Constants ( wORD_SIZE )
import Outputable
import DynFlags ( hscTarget, HscTarget(..) )
#ifdef DEBUG
import TypeRep
#endif

\end{code}

Desugaring of @ccall@s consists of adding some state manipulation,
unboxing any boxed primitive arguments and boxing the result if
desired.

The state stuff just consists of adding in
@PrimIO (\ s -> case s of { S# s# -> ... })@ in an appropriate place.

The unboxing is straightforward, as all information needed to unbox is
available from the type.  For each boxed-primitive argument, we
transform:
\begin{verbatim}
   _ccall_ foo [ r, t1, ... tm ] e1 ... em
   |
   |
   V
   case e1 of { T1# x1# ->
   ...
   case em of { Tm# xm# -> xm#
   ccall# foo [ r, t1#, ... tm# ] x1# ... xm#
   } ... }
\end{verbatim}

The reboxing of a @_ccall_@ result is a bit tricker: the types don't
contain information about the state-pairing functions so we have to
keep a list of \tr{(type, s-p-function)} pairs.  We transform as
follows:
\begin{verbatim}
   ccall# foo [ r, t1#, ... tm# ] e1# ... em#
   |
   |
   V
   \ s# -> case (ccall# foo [ r, t1#, ... tm# ] s# e1# ... em#) of
	  (StateAnd<r># result# state#) -> (R# result#, realWorld#)
\end{verbatim}

\begin{code}
dsCCall :: CLabelString	-- C routine to invoke
	-> [CoreExpr]	-- Arguments (desugared)
	-> Safety	-- Safety of the call
	-> Type		-- Type of the result: IO t
	-> DsM CoreExpr	-- Result, of type ???

dsCCall lbl args may_gc result_ty
  = mapAndUnzipDs unboxArg args	       `thenDs` \ (unboxed_args, arg_wrappers) ->
    boxResult id Nothing result_ty  `thenDs` \ (ccall_result_ty, res_wrapper) ->
    newUnique			       `thenDs` \ uniq ->
    let
	target = 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)

mkFCall :: Unique -> ForeignCall 
	-> [CoreExpr] 	-- Args
	-> Type 	-- Result type
	-> CoreExpr
-- Construct the ccall.  The only tricky bit is that the ccall Id should have
-- no free vars, so if any of the arg tys do we must give it a polymorphic type.
-- 	[I forget *why* it should have no free vars!]
-- For example:
--	mkCCall ... [s::StablePtr (a->b), x::Addr, c::Char]
--
-- Here we build a ccall thus
--	(ccallid::(forall a b.  StablePtr (a -> b) -> Addr -> Char -> IO Addr))
--			a b s x c
mkFCall uniq the_fcall val_args res_ty
  = mkApps (mkVarApps (Var the_fcall_id) tyvars) val_args
  where
    arg_tys = map exprType val_args
    body_ty = (mkFunTys arg_tys res_ty)
    tyvars  = varSetElems (tyVarsOfType body_ty)
    ty 	    = mkForAllTys tyvars body_ty
    the_fcall_id = mkFCallId uniq the_fcall ty
\end{code}

\begin{code}
unboxArg :: CoreExpr			-- The supplied argument
	 -> DsM (CoreExpr,		-- To pass as the actual argument
		 CoreExpr -> CoreExpr	-- Wrapper to unbox the arg
		)
-- Example: if the arg is e::Int, unboxArg will return
--	(x#::Int#, \W. case x of I# x# -> W)
-- where W is a CoreExpr that probably mentions x#

unboxArg arg
  -- Primtive types: nothing to unbox, but we evaluate lifted types
  | isPrimitiveType arg_ty
  = if isUnLiftedType arg_ty
      then returnDs (arg, \body -> body)
      else newSysLocalDs boolPrimTy     `thenDs` \ arg' ->
           return (Var arg', \body -> Case arg arg' (exprType body) [(DEFAULT,[],body)])
        
  -- The unit type (only for foreign export result)
  | Just (tc,_) <- splitTyConApp_maybe arg_ty, tc `hasKey` unitTyConKey
  = returnDs (Var voidPrimId
             ,\body -> Case arg (mkWildId unitTy) (exprType body) [(DataAlt unitDataCon,[],body)])
  
  -- Recursive newtypes
  | Just (rep_ty, co) <- splitNewTypeRepCo_maybe arg_ty
  = unboxArg (mkCoerce co arg)
  
  -- Family types
  | Just (tc,_) <- splitTyConApp_maybe arg_ty, isOpenTyCon tc
  = getFamInstEnvsDs	`thenDs` \fam_envs ->
    let (_, co) = expectJust "unboxArg" (splitOpenTypeRepCo_maybe fam_envs arg_ty) in
    unboxArg (mkCoerce co arg)
      
  -- Booleans
  | Just (tc,_) <- splitTyConApp_maybe arg_ty, 
    tc `hasKey` boolTyConKey
  = newSysLocalDs boolPrimTy		`thenDs` \ prim_arg ->
    returnDs (Var prim_arg,
	      \ body -> Case (Case arg (mkWildId arg_ty) boolPrimTy
  		                       [(DataAlt falseDataCon,[],Lit (MachInteger 0 boolPrimTyCon)),
	                                (DataAlt trueDataCon, [],Lit (MachInteger 1 boolPrimTyCon))])
					-- In increasing tag order!
                             prim_arg
                             (exprType body) 
			     [(DEFAULT,[],body)])

  -- Data types with a single constructor, which has a single, primitive-typed arg
  -- This deals with Int, Float etc; also Ptr, ForeignPtr
  | Just (_,_,data_con,[data_con_arg_ty1]) <- splitProductType_maybe arg_ty 
  = ASSERT2(isPrimitiveType data_con_arg_ty1, pprType arg_ty)
			-- Typechecker ensures this
    newSysLocalDs arg_ty		`thenDs` \ case_bndr ->
    newSysLocalDs data_con_arg_ty1	`thenDs` \ prim_arg ->
    returnDs (Var prim_arg,
	      \ body -> Case arg case_bndr (exprType body) [(DataAlt data_con,[prim_arg],body)]
    )

  -- 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)
  | Just (_,_,data_con,data_con_arg_tys@[_,_,data_con_arg_ty3]) <- splitProductType_maybe arg_ty
  = ASSERT2(isPrimitiveType data_con_arg_ty3, pprType arg_ty)
			-- Typechecker ensures this
    newSysLocalDs arg_ty		`thenDs` \ case_bndr ->
    newSysLocalsDs data_con_arg_tys	`thenDs` \ vars@[l_var, r_var, arr_cts_var] ->
    returnDs (Var arr_cts_var,
	      \ body -> Case arg case_bndr (exprType body) [(DataAlt data_con,vars,body)]
    )

  | Just (tc, [arg_ty]) <- splitTyConApp_maybe arg_ty,
    tc == listTyCon,
    Just (cc,[]) <- splitTyConApp_maybe arg_ty,
    cc == charTyCon
    -- String; dotnet only
  = dsLookupGlobalId marshalStringName `thenDs` \ unpack_id ->
    newSysLocalDs addrPrimTy	       `thenDs` \ prim_string ->
    returnDs (Var prim_string,
    	      \ body ->
	        let
		 io_ty = exprType body
		 Just (_,io_arg) = tcSplitIOType_maybe io_ty
		in
	      	mkApps (Var unpack_id)
		       [ Type io_arg
		       , arg
		       , Lam prim_string body
		       ])
  | Just (tc, [arg_ty]) <- splitTyConApp_maybe arg_ty,
    tyConName tc == objectTyConName
    -- Object; dotnet only
  = dsLookupGlobalId marshalObjectName `thenDs` \ unpack_id ->
    newSysLocalDs addrPrimTy	       `thenDs` \ prim_obj  ->
    returnDs (Var prim_obj,
    	      \ body ->
	        let
		 io_ty = exprType body
		 Just (_,io_arg) = tcSplitIOType_maybe io_ty
		in
	      	mkApps (Var unpack_id)
		       [ Type io_arg
		       , arg
		       , Lam prim_obj body
		       ])

  | otherwise
  = getSrcSpanDs `thenDs` \ l ->
    pprPanic "unboxArg: " (ppr l <+> ppr arg_ty)
  where
    arg_ty					= exprType arg
\end{code}


\begin{code}
boxResult :: ((Type, CoreExpr -> CoreExpr) -> (Type, CoreExpr -> CoreExpr))
	  -> Maybe Id
	  -> Type
	  -> DsM (Type, CoreExpr -> CoreExpr)

-- Takes the result of the user-level ccall: 
--	either (IO t), 
--	or maybe just t for an side-effect-free call
-- Returns a wrapper for the primitive ccall itself, along with the
-- type of the result of the primitive ccall.  This result type
-- will be of the form  
--	State# RealWorld -> (# State# RealWorld, t' #)
-- where t' is the unwrapped form of t.
--
-- The gruesome 'augment' and 'mbTopCon' are to do with .NET foreign calls
-- It looks a mess: I wonder if it could be refactored.

boxResult augment mbTopCon result_ty
  | Just (io_tycon, io_res_ty) <- tcSplitIOType_maybe result_ty
	-- isIOType_maybe handles the case where the type is a 
	-- simple wrapping of IO.  E.g.
	-- 	newtype Wrap a = W (IO a)
	-- No coercion necessay because its a non-recursive newtype
	-- (If we wanted to handle a *recursive* newtype too, we'd need
	-- another case, and a coercion.)
  = 	-- The result is IO t, so wrap the result in an IO constructor
	
    resultWrapper io_res_ty             `thenDs` \ res ->
    let aug_res          = augment res
        extra_result_tys = case aug_res of
			     (ty,_) 
			       | isUnboxedTupleType ty 
			       -> let (Just (_, ls)) = splitTyConApp_maybe ty in tail ls
			     _ -> []

        return_result state anss
	  = mkConApp (tupleCon Unboxed (2 + length extra_result_tys))
	             (map Type (realWorldStatePrimTy : io_res_ty : extra_result_tys)
		      ++ (state : anss)) 
    in
    mk_alt return_result aug_res 	`thenDs` \ (ccall_res_ty, the_alt) ->
    newSysLocalDs realWorldStatePrimTy	`thenDs` \ state_id ->
    let
	io_data_con = head (tyConDataCons io_tycon)
	toIOCon = case mbTopCon of
			Nothing -> dataConWrapId io_data_con
			Just x  -> x
	wrap = \ the_call -> mkApps (Var toIOCon)
				    [ Type io_res_ty, 
				      Lam state_id $
				       Case (App the_call (Var state_id))
				    	   (mkWildId ccall_res_ty)
                                            (coreAltType the_alt) 
				    	   [the_alt]
				    ]
    in
    returnDs (realWorldStatePrimTy `mkFunTy` ccall_res_ty, wrap)

boxResult augment mbTopCon result_ty
  = 	-- It isn't IO, so do unsafePerformIO
	-- It's not conveniently available, so we inline it
    resultWrapper result_ty            `thenDs` \ res ->
    mk_alt return_result (augment res) `thenDs` \ (ccall_res_ty, the_alt) ->
    let
	wrap = \ the_call -> Case (App the_call (Var realWorldPrimId)) 
					      (mkWildId ccall_res_ty)
                                              (coreAltType the_alt)
					      [the_alt]
    in
    returnDs (realWorldStatePrimTy `mkFunTy` ccall_res_ty, wrap)
  where
    return_result state [ans] = ans
    return_result _ _ = panic "return_result: expected single result"


mk_alt return_result (prim_res_ty, wrap_result)
  | isUnboxedTupleType prim_res_ty
  = let
	Just (_, ls) = splitTyConApp_maybe prim_res_ty
	arity = 1 + length ls
    in
    mappM newSysLocalDs ls 		`thenDs` \ args_ids@(result_id:as) ->
    newSysLocalDs realWorldStatePrimTy	`thenDs` \ state_id ->
    let
	the_rhs = return_result (Var state_id) 
				(wrap_result (Var result_id) : map Var as)
	ccall_res_ty = mkTyConApp (tupleTyCon Unboxed arity)
				  (realWorldStatePrimTy : ls)
	the_alt	     = ( DataAlt (tupleCon Unboxed arity)
		       , (state_id : args_ids)
		       , the_rhs
		       )
    in
    returnDs (ccall_res_ty, the_alt)

  | otherwise
  = newSysLocalDs prim_res_ty 		`thenDs` \ result_id ->
    newSysLocalDs realWorldStatePrimTy	`thenDs` \ state_id ->
    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)


unboxResult :: Type -> DsM (Type, CoreExpr -> CoreExpr)
unboxResult result_ty
  | Just (io_tycon, io_res_ty) <- tcSplitIOType_maybe result_ty
  = newSysLocalDs io_res_ty                              `thenDs` \ result_id ->
    unboxArg (Var result_id)                             `thenDs` \ (res_expr, res_wrapper) ->
    newSysLocalDs realWorldStatePrimTy                   `thenDs` \ state_id ->
    newSysLocalDs realWorldStatePrimTy                   `thenDs` \ state_id' ->
    let
        co_con      = maybe (pprPanic "unboxResult" (ppr io_tycon)) id (newTyConCo_maybe io_tycon)
        call_res_ty = mkTyConApp unboxedPairTyCon [realWorldStatePrimTy,io_res_ty]
        res_ty      = mkTyConApp unboxedPairTyCon [realWorldStatePrimTy,exprType res_expr]
        wrap        = 
            \the_call -> Lam state_id $ Case 
                (App (mkCoerce (mkTyConApp co_con [io_res_ty]) the_call) (Var state_id))
                (mkWildId call_res_ty)
                res_ty
                [(DataAlt unboxedPairDataCon
                 ,[state_id', result_id]
                 ,(mkConApp unboxedPairDataCon 
                     [Type realWorldStatePrimTy, Type (exprType res_expr)
                     ,Var state_id',res_wrapper res_expr]))]
    in
    returnDs (realWorldStatePrimTy `mkFunTy` res_ty, wrap)
  | otherwise
  = newSysLocalDs result_ty                              `thenDs` \ result_id ->
    unboxArg (Var result_id)                             `thenDs` \ (res_expr, res_wrapper) ->
    newSysLocalDs realWorldStatePrimTy                   `thenDs` \ state_id ->
    let
        res_ty = mkTyConApp unboxedPairTyCon [realWorldStatePrimTy,exprType res_expr]
        wrap   =
            \the_call -> Lam state_id $ bindNonRec result_id the_call 
                (mkConApp unboxedPairDataCon 
                    [Type realWorldStatePrimTy, Type (exprType res_expr)
                    ,Var state_id, res_wrapper res_expr])
    in
    returnDs (realWorldStatePrimTy `mkFunTy` res_ty, wrap)
    

resultWrapper :: Type
   	      -> DsM (Type,		        -- Type of the expected result
		      CoreExpr -> CoreExpr)	-- Wrapper for the result 
resultWrapper result_ty
  -- Base case 1: primitive types
  | isPrimitiveType result_ty
  = returnDs (result_ty, \e -> e)

  -- Base case 2: the unit type ()
  | Just (tc,_) <- maybe_tc_app, tc `hasKey` unitTyConKey
  = returnDs (voidPrimTy, \e -> Var unitDataConId)

  -- Base case 3: the boolean type
  | Just (tc,_) <- maybe_tc_app, tc `hasKey` boolTyConKey
  = returnDs
     (boolPrimTy, \e -> Case e (mkWildId boolPrimTy)
                                   boolTy
	                           [(DEFAULT             ,[],Var trueDataConId ),
				    (LitAlt (MachInteger 0 boolPrimTyCon),[],Var falseDataConId)])

  -- Recursive newtypes
  | Just (rep_ty, co) <- splitNewTypeRepCo_maybe result_ty
  = resultWrapper rep_ty `thenDs` \ (ty, wrapper) ->
    returnDs (ty, \e -> mkCoerce (mkSymCoercion co) (wrapper e))
    
  -- Family types
  | Just (tc, _) <- splitTyConApp_maybe result_ty, isOpenTyCon tc
  = getFamInstEnvsDs	`thenDs` \fam_envs ->
    let Just (rep_ty, co) = splitOpenTypeRepCo_maybe fam_envs result_ty in
    resultWrapper rep_ty `thenDs` \ (ty, wrapper) ->
    returnDs (ty, \e -> mkCoerce (mkSymCoercion co) (wrapper e))

  -- The type might contain foralls (eg. for dummy type arguments,
  -- referring to 'Ptr a' is legal).
  | Just (tyvar, rest) <- splitForAllTy_maybe result_ty
  = resultWrapper rest `thenDs` \ (ty, wrapper) ->
    returnDs (ty, \e -> Lam tyvar (wrapper e))

  -- Data types with a single constructor, which has a single arg
  -- This includes types like Ptr and ForeignPtr
  | Just (tycon, tycon_arg_tys, data_con, [unwrap_res_ty]) <- splitProductType_maybe result_ty
  = ASSERT2(isPrimitiveType unwrap_res_ty, pprType result_ty)
			-- Typechecker ensures this
    returnDs
      (unwrap_res_ty, \e -> mkApps (Var (dataConWorkId data_con)) 
			      (map Type tycon_arg_tys ++ [e]))

  -- 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)
  | Just (tycon, tycon_arg_tys, data_con, [ix1,ix2,unwrap_res_ty]) <- splitProductType_maybe result_ty
  , let Just (tc,[elem_ty]) = splitTyConApp_maybe unwrap_res_ty
  = ASSERT2(isIntTy ix1 && isIntTy ix2, pprType result_ty)
    ASSERT2(tc == mutableUArrayPrimTyCon || tc == uArrayPrimTyCon, pprType result_ty)    
			-- Typechecker ensures this
    resultWrapper unwrap_res_ty `thenDs` \ (maybe_ty, wrapper) ->
    returnDs
      (unwrap_res_ty, \e -> mkApps (Var (dataConWrapId data_con)) 
			      (map Type tycon_arg_tys ++ 
			          [mkConApp intDataCon [mkIntLit 0]
			          ,mkConApp intDataCon 
			              [mkApps (Var (mkPrimOpId IntSubOp))
			                  [mkApps (Var (mkPrimOpId 
			                      (if tc == mutableUArrayPrimTyCon 
			                          then MutableUArrayLengthOp
			                          else UArrayLengthOp))) [Type elem_ty,e]
                                          ,mkIntLit 1]]
                                  ,e]))

    -- Strings; 'dotnet' only.
  | Just (tc, [arg_ty]) <- maybe_tc_app,               tc == listTyCon,
    Just (cc,[])        <- splitTyConApp_maybe arg_ty, cc == charTyCon
  = dsLookupGlobalId unmarshalStringName	`thenDs` \ pack_id ->
    returnDs (addrPrimTy,
    	      \ e -> App (Var pack_id) e)

    -- Objects; 'dotnet' only.
  | Just (tc, [arg_ty]) <- maybe_tc_app, 
    tyConName tc == objectTyConName
  = dsLookupGlobalId unmarshalObjectName	`thenDs` \ pack_id ->
    returnDs (addrPrimTy,
    	      \ e -> App (Var pack_id) e)

  | otherwise
  = pprPanic "resultWrapper" (ppr result_ty)
  where
    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.

{-
-- This should happen in the code generator now that we have Int8# and friends
-- Brian Alliet <bja8464@cs.rit.edu>
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}