import TcHsSyn ( TypecheckedForeignDecl )
import CoreUtils ( exprType, mkInlineMe )
import DataCon ( DataCon, dataConWrapId )
-import Id ( Id, idType, idName, mkWildId, mkVanillaId )
+import Id ( Id, idType, idName, mkWildId, mkVanillaId, mkSysLocal,
+ setInlinePragma )
+import IdInfo ( neverInlinePrag )
import MkId ( mkWorkerId )
import Literal ( Literal(..) )
import Module ( Module, moduleUserString )
mkForeignExportOcc, isLocalName,
NamedThing(..), Provenance(..), ExportFlag(..)
)
-import PrelInfo ( deRefStablePtr_NAME, returnIO_NAME, bindIO_NAME, makeStablePtr_NAME )
-import Type ( unUsgTy,
+import Type ( unUsgTy, repType,
splitTyConApp_maybe, splitFunTys, splitForAllTys,
Type, mkFunTys, mkForAllTys, mkTyConApp,
mkTyVarTy, mkFunTy, splitAppTy, applyTy, funResultTy
)
import PprType ( {- instance Outputable Type -} )
-import PrimOp ( PrimOp(..), CCall(..), CCallTarget(..) )
+import PrimOp ( PrimOp(..), CCall(..), CCallTarget(..), dynamicTarget )
import Var ( TyVar )
import TysPrim ( realWorldStatePrimTy, addrPrimTy )
import TysWiredIn ( unitTy, addrTy, stablePtrTyCon,
- unboxedTupleCon, addrDataCon
+ addrDataCon
)
-import Unique
+import Unique ( Uniquable(..), hasKey,
+ ioTyConKey, deRefStablePtrIdKey, returnIOIdKey,
+ bindIOIdKey, makeStablePtrIdKey
+ )
import Maybes ( maybeToBool )
import Outputable
\end{code}
mapAndUnzipDs unboxArg (map Var args) `thenDs` \ (val_args, arg_wrappers) ->
boxResult io_res_ty `thenDs` \ (ccall_result_ty, res_wrapper) ->
- (case ext_name of
- Dynamic -> getUniqueDs `thenDs` \ u ->
- returnDs (DynamicTarget u)
- ExtName fs _ -> returnDs (StaticTarget fs)) `thenDs` \ lbl ->
-
getUniqueDs `thenDs` \ ccall_uniq ->
getUniqueDs `thenDs` \ work_uniq ->
let
+ lbl = case ext_name of
+ Dynamic -> dynamicTarget
+ ExtName fs _ -> StaticTarget fs
+
-- Build the worker
work_arg_ids = [v | Var v <- val_args] -- All guaranteed to be vars
worker_ty = mkForAllTys tvs (mkFunTys (map idType work_arg_ids) ccall_result_ty)
the_ccall = CCall lbl False (not may_not_gc) cconv
the_ccall_app = mkCCall ccall_uniq the_ccall val_args ccall_result_ty
work_rhs = mkLams tvs (mkLams work_arg_ids the_ccall_app)
- work_id = mkWorkerId work_uniq fn_id worker_ty
+ work_id = mkSysLocal SLIT("$wccall") work_uniq worker_ty
-- Build the wrapper
work_app = mkApps (mkVarApps (Var work_id) tvs) val_args
dsFLabel :: Id -> ExtName -> DsM CoreBind
dsFLabel nm ext_name = returnDs (NonRec nm fo_rhs)
where
- fo_rhs = mkConApp addrDataCon [mkLit (MachLitLit enm addrPrimTy)]
+ fo_rhs = mkConApp addrDataCon [mkLit (MachLitLit addr addrPrimTy)]
enm = extNameStatic ext_name
+ addr = SLIT("(&") _APPEND_ enm _APPEND_ SLIT(")")
\end{code}
The function that does most of the work for `@foreign export@' declarations.
-- If it's plain t, return (\x.returnIO x, IO t, t)
(case splitTyConApp_maybe orig_res_ty of
Just (ioTyCon, [res_ty])
- -> ASSERT( getUnique ioTyCon == ioTyConKey )
+ -> ASSERT( ioTyCon `hasKey` ioTyConKey )
-- The function already returns IO t
returnDs (\body -> body, orig_res_ty, res_ty)
other -> -- The function returns t, so wrap the call in returnIO
- dsLookupGlobalValue returnIO_NAME `thenDs` \ retIOId ->
+ dsLookupGlobalValue returnIOIdKey `thenDs` \ retIOId ->
returnDs (\body -> mkApps (Var retIOId) [Type orig_res_ty, body],
funResultTy (applyTy (idType retIOId) orig_res_ty),
-- We don't have ioTyCon conveniently to hand
(if isDyn then
newSysLocalDs stbl_ptr_ty `thenDs` \ stbl_ptr ->
newSysLocalDs stbl_ptr_to_ty `thenDs` \ stbl_value ->
- dsLookupGlobalValue deRefStablePtr_NAME `thenDs` \ deRefStablePtrId ->
+ dsLookupGlobalValue deRefStablePtrIdKey `thenDs` \ deRefStablePtrId ->
+ dsLookupGlobalValue bindIOIdKey `thenDs` \ bindIOId ->
let
the_deref_app = mkApps (Var deRefStablePtrId)
[ Type stbl_ptr_to_ty, Var stbl_ptr ]
- in
- dsLookupGlobalValue bindIO_NAME `thenDs` \ bindIOId ->
- let
+
stbl_app cont = mkApps (Var bindIOId)
[ Type stbl_ptr_to_ty
, Type res_ty
as a C function pointer). Useful for callbacks and stuff.
\begin{verbatim}
-foreign export stdcall f :: (Addr -> Int -> IO Int) -> IO Addr
+foreign export dynamic f :: (Addr -> Int -> IO Int) -> IO Addr
--- Haskell-visible constructor, which is generated from the
--- above:
+-- Haskell-visible constructor, which is generated from the above:
+-- SUP: No check for NULL from createAdjustor anymore???
f :: (Addr -> Int -> IO Int) -> IO Addr
-f cback = IO ( \ s1# ->
- case makeStablePtr# cback s1# of { StateAndStablePtr# s2# sp# ->
- case _ccall_ "mkAdjustor" sp# ``f_helper'' s2# of
- StateAndAddr# s3# a# ->
- case addr2Int# a# of
- 0# -> IOfail s# err
- _ ->
- let
- a :: Addr
- a = A# a#
- in
- IOok s3# a)
+f cback =
+ bindIO (makeStablePtr cback)
+ (\StablePtr sp# -> IO (\s1# ->
+ case _ccall_ createAdjustor cconv sp# ``f_helper'' s1# of
+ (# s2#, a# #) -> (# s2#, A# a# #)))
foreign export "f_helper" f_helper :: StablePtr (Addr -> Int -> IO Int) -> Addr -> Int -> IO Int
-- `special' foreign export that invokes the closure pointed to by the
dsFExport i export_ty mod_name fe_ext_name cconv True
`thenDs` \ (fe@(NonRec fe_helper fe_expr), h_code, c_code) ->
newSysLocalDs arg_ty `thenDs` \ cback ->
- dsLookupGlobalValue makeStablePtr_NAME `thenDs` \ makeStablePtrId ->
+ dsLookupGlobalValue makeStablePtrIdKey `thenDs` \ makeStablePtrId ->
let
mk_stbl_ptr_app = mkApps (Var makeStablePtrId) [ Type arg_ty, Var cback ]
in
- dsLookupGlobalValue bindIO_NAME `thenDs` \ bindIOId ->
+ dsLookupGlobalValue bindIOIdKey `thenDs` \ bindIOId ->
newSysLocalDs (mkTyConApp stablePtrTyCon [arg_ty]) `thenDs` \ stbl_value ->
let
stbl_app cont ret_ty
mkLams [cback] $
stbl_app ccall_io_adj addrTy
in
- returnDs (NonRec i io_app, fe, h_code, c_code)
+ -- Never inline the f.e.d. function, because the litlit might not be in scope
+ -- in other modules.
+ returnDs (NonRec (i `setInlinePragma` neverInlinePrag) io_app, fe, h_code, c_code)
where
(tvs,sans_foralls) = splitForAllTys ty
showFFIType :: Type -> String
showFFIType t = getOccString (getName tc)
where
- tc = case splitTyConApp_maybe t of
+ tc = case splitTyConApp_maybe (repType t) of
Just (tc,_) -> tc
Nothing -> pprPanic "showFFIType" (ppr t)
\end{code}