DsForeign.lhs 18.3 KB
Newer Older
sof's avatar
sof committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
%
% (c) The AQUA Project, Glasgow University, 1998
%
\section[DsCCall]{Desugaring \tr{foreign} declarations}

Expanding out @foreign import@ and @foreign export@ declarations.

\begin{code}
module DsForeign ( dsForeigns ) where

#include "HsVersions.h"

import CoreSyn

15
import DsCCall		( dsCCall, mkFCall, boxResult, unboxArg, resultWrapper )
sof's avatar
sof committed
16
17
import DsMonad

chak's avatar
chak committed
18
19
import HsSyn		( ForeignDecl(..), ForeignExport(..),
			  ForeignImport(..), CImportSpec(..) )
20
import TcHsSyn		( TypecheckedForeignDecl )
21
import CoreUtils	( exprType, mkInlineMe )
22
import Id		( Id, idType, idName, mkVanillaGlobal, mkSysLocal,
23
			  setInlinePragma )
24
import IdInfo		( vanillaIdInfo )
25
import Literal		( Literal(..) )
sof's avatar
sof committed
26
import Module		( Module, moduleUserString )
27
import Name		( mkGlobalName, nameModule, nameOccName, getOccString, 
sof's avatar
sof committed
28
			  mkForeignExportOcc, isLocalName,
29
			  NamedThing(..),
30
			)
31
32
33
34
import Type		( repType, eqType )
import TcType		( Type, mkFunTys, mkForAllTys, mkTyConApp,
			  mkFunTy, applyTy, 
			  tcSplitForAllTys, tcSplitFunTys, tcTyConAppArgs,
sof's avatar
sof committed
35
36
37
			  tcSplitTyConApp_maybe, tcSplitAppTy,
			  tcFunResultTy
			)
38

39
40
import ForeignCall	( ForeignCall(..), CCallSpec(..), 
			  Safety(..), playSafe,
41
			  CExportSpec(..),
sof's avatar
sof committed
42
43
			  CCallConv(..), ccallConvToInt,
			  ccallConvAttribute
44
			)
45
import CStrings		( CLabelString )
46
import TysWiredIn	( addrTy, unitTy, stablePtrTyCon )
47
import TysPrim		( addrPrimTy )
48
49
import PrelNames	( hasKey, ioTyConKey, deRefStablePtrName, newStablePtrName,
			  bindIOName, returnIOName
50
			)
51
import BasicTypes	( Activation( NeverActive ) )
chak's avatar
chak committed
52
import ErrUtils         ( addShortWarnLocLine )
sof's avatar
sof committed
53
import Outputable
54
import Maybe 		( fromJust )
sof's avatar
sof committed
55
56
57
58
\end{code}

Desugaring of @foreign@ declarations is naturally split up into
parts, an @import@ and an @export@  part. A @foreign import@ 
59
60
declaration
\begin{verbatim}
sof's avatar
sof committed
61
  foreign import cc nm f :: prim_args -> IO prim_res
62
\end{verbatim}
sof's avatar
sof committed
63
is the same as
64
\begin{verbatim}
sof's avatar
sof committed
65
66
  f :: prim_args -> IO prim_res
  f a1 ... an = _ccall_ nm cc a1 ... an
67
\end{verbatim}
sof's avatar
sof committed
68
69
70
so we reuse the desugaring code in @DsCCall@ to deal with these.

\begin{code}
71
72
73
type Binding = (Id, CoreExpr)	-- No rec/nonrec structure;
				-- the occurrence analyser will sort it all out

sof's avatar
sof committed
74
75
dsForeigns :: Module
           -> [TypecheckedForeignDecl] 
76
77
78
	   -> DsM ( [Id]		-- Foreign-exported binders; 
					-- we have to generate code to register these
		  , [Binding]
79
80
81
82
		  , SDoc	      -- Header file prototypes for
                                      -- "foreign exported" functions.
		  , SDoc 	      -- C stubs to use when calling
                                      -- "foreign exported" functions.
chak's avatar
chak committed
83
84
		  , [FAST_STRING]     -- headers that need to be included
				      -- into C code generated for this module
sof's avatar
sof committed
85
		  )
86
dsForeigns mod_name fos
chak's avatar
chak committed
87
  = foldlDs combine ([], [], empty, empty, []) fos
sof's avatar
sof committed
88
 where
chak's avatar
chak committed
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
  combine (acc_feb, acc_f, acc_h, acc_c, acc_header) 
	  (ForeignImport id _ spec depr loc)
    = dsFImport mod_name id spec	           `thenDs` \(bs, h, c, hd) -> 
      warnDepr depr loc				   `thenDs` \_              ->
      returnDs (acc_feb, bs ++ acc_f, h $$ acc_h, c $$ acc_c, hd ++ acc_header)

  combine (acc_feb, acc_f, acc_h, acc_c, acc_header) 
	  (ForeignExport id _ (CExport (CExportStatic ext_nm cconv)) depr loc)
    = dsFExport mod_name id (idType id) 
		ext_nm cconv False                 `thenDs` \(feb, b, h, c) ->
      warnDepr depr loc				   `thenDs` \_              ->
      returnDs (feb:acc_feb, b : acc_f, h $$ acc_h, c $$ acc_c, acc_header)

  warnDepr False _   = returnDs ()
  warnDepr True  loc = dsWarn (addShortWarnLocLine loc msg)
   where
    msg = ptext SLIT("foreign declaration uses deprecated non-standard syntax")
sof's avatar
sof committed
106
107
\end{code}

108
109
110
111
112
113
114

%************************************************************************
%*									*
\subsection{Foreign import}
%*									*
%************************************************************************

sof's avatar
sof committed
115
116
Desugaring foreign imports is just the matter of creating a binding
that on its RHS unboxes its arguments, performs the external call
117
(using the @CCallOp@ primop), before boxing the result up and returning it.
sof's avatar
sof committed
118

119
120
121
122
123
124
125
126
127
128
129
130
131
132
However, we create a worker/wrapper pair, thus:

	foreign import f :: Int -> IO Int
==>
	f x = IO ( \s -> case x of { I# x# ->
			 case fw s x# of { (# s1, y# #) ->
			 (# s1, I# y# #)}})

	fw s x# = ccall f s x#

The strictness/CPR analyser won't do this automatically because it doesn't look
inside returned tuples; but inlining this wrapper is a Really Good Idea 
because it exposes the boxing to the call site.

sof's avatar
sof committed
133
\begin{code}
134
135
dsFImport :: Module
	  -> Id
chak's avatar
chak committed
136
137
	  -> ForeignImport
	  -> DsM ([Binding], SDoc, SDoc, [FAST_STRING])
138
139
140
dsFImport modName id (CImport cconv safety header lib spec)
  = dsCImport modName id spec cconv safety	  `thenDs` \(ids, h, c) ->
    returnDs (ids, h, c, if _NULL_ header then [] else [header])
chak's avatar
chak committed
141
142
143
  -- FIXME: the `lib' field is needed for .NET ILX generation when invoking
  --	    routines that are external to the .NET runtime, but GHC doesn't
  --	    support such calls yet; if `_NULL_ lib', the value was not given
144
145
146
dsFImport modName id (DNImport spec)
  = dsFCall modName id (DNCall spec)	          `thenDs` \(ids, h, c) ->
    returnDs (ids, h, c, [])
chak's avatar
chak committed
147
148
149
150
151
152

dsCImport :: Module
	  -> Id
	  -> CImportSpec
	  -> CCallConv
	  -> Safety
153
	  -> DsM ([Binding], SDoc, SDoc)
154
155
156
dsCImport modName id (CLabel cid)       _     _
 = ASSERT(fromJust resTy `eqType` addrPrimTy)    -- typechecker ensures this
   returnDs ([(id, rhs)], empty, empty)
157
 where
chak's avatar
chak committed
158
159
   (resTy, foRhs) = resultWrapper (idType id)
   rhs		  = foRhs (mkLit (MachLabel cid))
160
161
162
163
dsCImport modName id (CFunction target) cconv safety
  = dsFCall modName id (CCall (CCallSpec target cconv safety))
dsCImport modName id CWrapper           cconv _
  = dsFExportDynamic modName id cconv
164
165
166
167
168
169
170
171
172
173
174
\end{code}


%************************************************************************
%*									*
\subsection{Foreign calls}
%*									*
%************************************************************************

\begin{code}
dsFCall mod_Name fn_id fcall
175
  = let
176
	ty		     = idType fn_id
sof's avatar
sof committed
177
178
	(tvs, fun_ty)        = tcSplitForAllTys ty
	(arg_tys, io_res_ty) = tcSplitFunTys fun_ty
179
180
		-- Must use tcSplit* functions because we want to 
		-- see that (IO t) in the corner
sof's avatar
sof committed
181
    in
182
    newSysLocalsDs arg_tys  			`thenDs` \ args ->
183
    mapAndUnzipDs unboxArg (map Var args)	`thenDs` \ (val_args, arg_wrappers) ->
184

185
186
187
    let
	work_arg_ids  = [v | Var v <- val_args]	-- All guaranteed to be vars

188
	-- These are the ids we pass to boxResult, which are used to decide
189
190
	-- whether to touch# an argument after the call (used to keep
	-- ForeignObj#s live across a 'safe' foreign import).
191
192
	maybe_arg_ids | unsafe_call fcall = work_arg_ids
		      | otherwise	  = []
193
    in
194
    boxResult maybe_arg_ids io_res_ty  		`thenDs` \ (ccall_result_ty, res_wrapper) ->
195
196
197

    getUniqueDs					`thenDs` \ ccall_uniq ->
    getUniqueDs					`thenDs` \ work_uniq ->
sof's avatar
sof committed
198
    let
199
200
	-- Build the worker
	worker_ty     = mkForAllTys tvs (mkFunTys (map idType work_arg_ids) ccall_result_ty)
201
 	the_ccall_app = mkFCall ccall_uniq fcall val_args ccall_result_ty
202
	work_rhs      = mkLams tvs (mkLams work_arg_ids the_ccall_app)
203
	work_id       = mkSysLocal SLIT("$wccall") work_uniq worker_ty
204
205
206
207

	-- Build the wrapper
	work_app     = mkApps (mkVarApps (Var work_id) tvs) val_args
	wrapper_body = foldr ($) (res_wrapper work_app) arg_wrappers
208
        wrap_rhs     = mkInlineMe (mkLams (tvs ++ args) wrapper_body)
sof's avatar
sof committed
209
    in
210
211
212
213
    returnDs ([(work_id, work_rhs), (fn_id, wrap_rhs)], empty, empty)

unsafe_call (CCall (CCallSpec _ _ safety)) = playSafe safety
unsafe_call (DNCall _)			   = False
214
215
\end{code}

sof's avatar
sof committed
216

217
218
219
220
221
%************************************************************************
%*									*
\subsection{Foreign export}
%*									*
%************************************************************************
sof's avatar
sof committed
222

223
224
The function that does most of the work for `@foreign export@' declarations.
(see below for the boilerplate code a `@foreign export@' declaration expands
225
 into.)
sof's avatar
sof committed
226

227
228
229
230
231
232
For each `@foreign export foo@' in a module M we generate:
\begin{itemize}
\item a C function `@foo@', which calls
\item a Haskell stub `@M.$ffoo@', which calls
\end{itemize}
the user-written Haskell function `@M.foo@'.
233

sof's avatar
sof committed
234
\begin{code}
235
236
237
238
239
dsFExport :: Module
	  -> Id			-- Either the exported Id, 
				-- or the foreign-export-dynamic constructor
	  -> Type		-- The type of the thing callable from C
	  -> CLabelString	-- The name to export to C land
240
	  -> CCallConv
241
242
243
	  -> Bool		-- True => foreign export dynamic
				-- 	   so invoke IO action that's hanging off 
				-- 	   the first argument's stable pointer
244
245
	  -> DsM ( Id		-- The foreign-exported Id
		 , Binding
246
247
248
		 , SDoc
		 , SDoc
		 )
249
dsFExport mod_name fn_id ty ext_name cconv isDyn
250
251
252
253
  = 	-- BUILD THE returnIO WRAPPER, if necessary
	-- Look at the result type of the exported function, orig_res_ty
	-- If it's IO t, return		(\x.x,	        IO t, t)
	-- If it's plain t, return	(\x.returnIO x, IO t, t)
sof's avatar
sof committed
254
     (case tcSplitTyConApp_maybe orig_res_ty of
255
256
257
	-- We must use tcSplit here so that we see the (IO t) in
	-- the type.  [IO t is transparent to plain splitTyConApp.]

258
	Just (ioTyCon, [res_ty])
259
	      -> ASSERT( ioTyCon `hasKey` ioTyConKey )
260
261
262
263
			-- 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
264
		 dsLookupGlobalValue returnIOName	`thenDs` \ retIOId ->
265
	         returnDs (\body -> mkApps (Var retIOId) [Type orig_res_ty, body],
sof's avatar
sof committed
266
		           tcFunResultTy (applyTy (idType retIOId) orig_res_ty), 
267
268
269
270
271
272
273
274
275
				-- We don't have ioTyCon conveniently to hand
			   orig_res_ty)

     )		`thenDs` \ (return_io_wrapper, 	-- Either identity or returnIO
			    io_res_ty, 		-- IO t
			    res_ty) ->		-- t


	-- BUILD THE deRefStablePtr WRAPPER, if necessary
sof's avatar
sof committed
276
277
     (if isDyn then 
        newSysLocalDs stbl_ptr_ty			`thenDs` \ stbl_ptr ->
278
	newSysLocalDs stbl_ptr_to_ty			`thenDs` \ stbl_value ->
279
280
	dsLookupGlobalValue deRefStablePtrName		`thenDs` \ deRefStablePtrId ->
        dsLookupGlobalValue bindIOName			`thenDs` \ bindIOId ->
sof's avatar
sof committed
281
	let
282
283
	 the_deref_app = mkApps (Var deRefStablePtrId)
				[ Type stbl_ptr_to_ty, Var stbl_ptr ]
284

285
286
287
288
289
	 stbl_app cont = mkApps (Var bindIOId)
				[ Type stbl_ptr_to_ty
				, Type res_ty
				, the_deref_app
				, mkLams [stbl_value] cont]
290
291
        in
	returnDs (stbl_value, stbl_app, stbl_ptr)
sof's avatar
sof committed
292
      else
293
        returnDs (fn_id, 
sof's avatar
sof committed
294
295
	          \ body -> body,
		  panic "stbl_ptr"  -- should never be touched.
296
		  ))			`thenDs` \ (i, getFun_wrapper, stbl_ptr) ->
sof's avatar
sof committed
297
298


299
	-- BUILD THE HELPER
300
     getModuleDs			`thenDs` \ mod -> 
301
     getUniqueDs			`thenDs` \ uniq ->
302
303
     getSrcLocDs			`thenDs` \ src_loc ->
     newSysLocalsDs fe_arg_tys		`thenDs` \ fe_args ->
sof's avatar
sof committed
304
     let
305
306
        wrapper_args | isDyn      = stbl_ptr:fe_args
		     | otherwise  = fe_args
sof's avatar
sof committed
307

308
309
310
311
312
313
        wrapper_arg_tys | isDyn      = stbl_ptr_ty:fe_arg_tys
		        | otherwise  = fe_arg_tys

	helper_ty =  mkForAllTys tvs $
		     mkFunTys wrapper_arg_tys io_res_ty

314
	f_helper_glob = mkVanillaGlobal helper_name helper_ty vanillaIdInfo
315
		      where
316
			name	            = idName fn_id
317
318
319
320
321
			mod	
			 | isLocalName name = mod_name
			 | otherwise        = nameModule name

			occ	            = mkForeignExportOcc (nameOccName name)
322
			helper_name         = mkGlobalName uniq mod occ src_loc
323
324
325
326
327

      	the_app = getFun_wrapper (return_io_wrapper (mkVarApps (Var i) (tvs ++ fe_args)))
      	the_body = mkLams (tvs ++ wrapper_args) the_app
  
      	(h_stub, c_stub) = fexportEntry (moduleUserString mod)
328
329
      				      	ext_name f_helper_glob
                                      	wrapper_arg_tys res_ty cconv isDyn
sof's avatar
sof committed
330
     in
331
     returnDs (f_helper_glob, (f_helper_glob, the_body), h_stub, c_stub)
332

sof's avatar
sof committed
333
  where
sof's avatar
sof committed
334
335
   (tvs,sans_foralls)		= tcSplitForAllTys ty
   (fe_arg_tys', orig_res_ty)	= tcSplitFunTys sans_foralls
336
337
	-- We must use tcSplits here, because we want to see 
	-- the (IO t) in the corner of the type!
sof's avatar
sof committed
338

339
340
341
342
343
   fe_arg_tys | isDyn	  = tail fe_arg_tys'
	      | otherwise = fe_arg_tys'

   stbl_ptr_ty | isDyn     = head fe_arg_tys'
	       | otherwise = error "stbl_ptr_ty"
344
345
346
347
348

   (_, stbl_ptr_ty')		= tcSplitForAllTys stbl_ptr_ty
   (_, stbl_ptr_to_ty)		= tcSplitAppTy stbl_ptr_ty'
	-- Again, stable pointers are just newtypes, 
	-- so we must see them!  Hence tcSplit*
sof's avatar
sof committed
349
350
\end{code}

351
@foreign export dynamic@ lets you dress up Haskell IO actions
sof's avatar
sof committed
352
353
354
355
of some fixed type behind an externally callable interface (i.e.,
as a C function pointer). Useful for callbacks and stuff.

\begin{verbatim}
356
foreign export dynamic f :: (Addr -> Int -> IO Int) -> IO Addr
sof's avatar
sof committed
357

358
359
-- Haskell-visible constructor, which is generated from the above:
-- SUP: No check for NULL from createAdjustor anymore???
sof's avatar
sof committed
360
361

f :: (Addr -> Int -> IO Int) -> IO Addr
362
f cback =
363
   bindIO (newStablePtr cback)
364
365
366
          (\StablePtr sp# -> IO (\s1# ->
              case _ccall_ createAdjustor cconv sp# ``f_helper'' s1# of
                 (# s2#, a# #) -> (# s2#, A# a# #)))
sof's avatar
sof committed
367
368
369
370
371
372
373

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
-- first argument.
\end{verbatim}

\begin{code}
374
375
dsFExportDynamic :: Module
		 -> Id
376
		 -> CCallConv
377
378
379
		 -> DsM ([Binding], SDoc, SDoc)
dsFExportDynamic mod_name id cconv
  =  newSysLocalDs ty					 `thenDs` \ fe_id ->
sof's avatar
sof committed
380
381
     let 
        -- hack: need to get at the name of the C stub we're about to generate.
382
       fe_nm	   = _PK_ (moduleUserString mod_name ++ "_" ++ toCName fe_id)
sof's avatar
sof committed
383
     in
384
385
386
     dsFExport mod_name id export_ty fe_nm cconv True  	`thenDs` \ (feb, fe, h_code, c_code) ->
     newSysLocalDs arg_ty				`thenDs` \ cback ->
     dsLookupGlobalValue newStablePtrName		`thenDs` \ newStablePtrId ->
sof's avatar
sof committed
387
     let
388
	mk_stbl_ptr_app    = mkApps (Var newStablePtrId) [ Type arg_ty, Var cback ]
sof's avatar
sof committed
389
     in
390
     dsLookupGlobalValue bindIOName		        `thenDs` \ bindIOId ->
391
     newSysLocalDs (mkTyConApp stablePtrTyCon [arg_ty]) `thenDs` \ stbl_value ->
sof's avatar
sof committed
392
     let
393
394
395
396
397
398
399
      stbl_app cont ret_ty 
	= mkApps (Var bindIOId)
		 [ Type (mkTyConApp stablePtrTyCon [arg_ty])
		 , Type ret_ty
		 , mk_stbl_ptr_app
		 , cont
		 ]
400
401
402
403
404
405
406
407

       {-
        The arguments to the external function which will
	create a little bit of (template) code on the fly
	for allowing the (stable pointed) Haskell closure
	to be entered using an external calling convention
	(stdcall, ccall).
       -}
408
      adj_args      = [ mkIntLitInt (ccallConvToInt cconv)
409
		      , Var stbl_value
410
		      , mkLit (MachLabel fe_nm)
411
412
413
414
415
		      ]
        -- name of external entry point providing these services.
	-- (probably in the RTS.) 
      adjustor	    = SLIT("createAdjustor")
     in
416
417
     dsCCall adjustor adj_args PlayRisky False io_res_ty	`thenDs` \ ccall_adj ->
	-- PlayRisky: the adjustor doesn't allocate in the Haskell heap or do a callback
418
     let ccall_adj_ty = exprType ccall_adj
419
         ccall_io_adj = mkLams [stbl_value]		     $
420
			Note (Coerce io_res_ty ccall_adj_ty)
421
			     ccall_adj
422
         io_app = mkLams tvs	 $
423
		  mkLams [cback] $
424
		  stbl_app ccall_io_adj res_ty
425
	 fed = (id `setInlinePragma` NeverActive, io_app)
426
427
		-- Never inline the f.e.d. function, because the litlit
		-- might not be in scope in other modules.
428
     in
429
     returnDs ([fed, fe], h_code, c_code)
430

sof's avatar
sof committed
431
 where
432
433
434
435
436
437
  ty			= idType id
  (tvs,sans_foralls)	= tcSplitForAllTys ty
  ([arg_ty], io_res_ty)	= tcSplitFunTys sans_foralls
  [res_ty]		= tcTyConAppArgs io_res_ty
	-- Must use tcSplit* to see the (IO t), which is a newtype
  export_ty		= mkFunTy (mkTyConApp stablePtrTyCon [arg_ty]) arg_ty
sof's avatar
sof committed
438
439
440
441
442
443
444
445
446
447
448

toCName :: Id -> String
toCName i = showSDoc (pprCode CStyle (ppr (idName i)))
\end{code}

%*
%
\subsection{Generating @foreign export@ stubs}
%
%*

449
450
451
For each @foreign export@ function, a C stub function is generated.
The C stub constructs the application of the exported Haskell function 
using the hugs/ghc rts invocation API.
sof's avatar
sof committed
452
453

\begin{code}
sof's avatar
sof committed
454
455
fexportEntry :: String
	     -> FAST_STRING
sof's avatar
sof committed
456
457
	     -> Id 
	     -> [Type] 
458
	     -> Type 
459
	     -> CCallConv 
sof's avatar
sof committed
460
461
	     -> Bool
	     -> (SDoc, SDoc)
462
fexportEntry mod_nm c_nm helper args res_ty cc isDyn = (header_bits, c_bits)
sof's avatar
sof committed
463
464
 where
   -- name of the (Haskell) helper function generated by the desugarer.
465
466
467
  h_nm	    = ppr helper <> text "_closure"
   -- prototype for the exported function.
  header_bits = ptext SLIT("extern") <+> fun_proto <> semi
sof's avatar
sof committed
468

469
  fun_proto = cResType <+> pprCconv <+> ptext c_nm <>
sof's avatar
sof committed
470
	      parens (hsep (punctuate comma (zipWith (<+>) cParamTypes proto_args)))
sof's avatar
sof committed
471

472
473
474
  c_bits =
    externDecl $$
    fun_proto  $$
sof's avatar
sof committed
475
    vcat 
476
477
478
479
480
481
     [ lbrace
     ,   text "SchedulerStatus rc;"
     ,   declareResult
	  -- create the application + perform it.
     ,   text "rc=rts_evalIO" <> 
                  parens (foldl appArg (text "(StgClosure*)&" <> h_nm) (zip args c_args) <> comma <> text "&ret") <> semi
482
     ,   text "rts_checkSchedStatus" <> parens (doubleQuotes (ptext c_nm)
483
484
						<> comma <> text "rc") <> semi
     ,   text "return" <> return_what <> semi
485
486
     , rbrace
     ]
sof's avatar
sof committed
487

488
489
  appArg acc (a,c_a) =
     text "rts_apply" <> parens (acc <> comma <> mkHObj a <> parens c_a)
sof's avatar
sof committed
490

sof's avatar
sof committed
491
  cParamTypes  = map showStgType real_args
sof's avatar
sof committed
492

493
  res_ty_is_unit = res_ty `eqType` unitTy	-- Look through any newtypes
494
495
496

  cResType | res_ty_is_unit = text "void"
	   | otherwise	    = showStgType res_ty
sof's avatar
sof committed
497

498
499
  pprCconv = case cc of
		CCallConv   -> empty
sof's avatar
sof committed
500
		StdCallConv -> text (ccallConvAttribute cc)
sof's avatar
sof committed
501
     
502
  declareResult  = text "HaskellObj ret;"
sof's avatar
sof committed
503

504
  externDecl     = mkExtern (text "HaskellObj") h_nm
sof's avatar
sof committed
505

506
  mkExtern ty nm = text "extern" <+> ty <+> nm <> semi
sof's avatar
sof committed
507

508
509
  return_what | res_ty_is_unit = empty
	      | otherwise      = parens (unpackHObj res_ty <> parens (text "ret"))
sof's avatar
sof committed
510

sof's avatar
sof committed
511
512
513
514
515
516
517
518
519
520
  c_args = mkCArgNames 0 args

  {-
   If we're generating an entry point for a 'foreign export ccall dynamic',
   then we receive the return address of the C function that wants to
   invoke a Haskell function as any other C function, as second arg.
   This arg is unused within the body of the generated C stub, but
   needed by the Adjustor.c code to get the stack cleanup right.
  -}
  (proto_args, real_args)
521
522
523
524
    = case cc of
	CCallConv | isDyn -> ( text "a0" : text "a_" : mkCArgNames 1 (tail args)
			     , head args : addrTy : tail args)
        other		  -> (mkCArgNames 0 args, args)
sof's avatar
sof committed
525

sof's avatar
sof committed
526
527
mkCArgNames :: Int -> [a] -> [SDoc]
mkCArgNames n as = zipWith (\ _ n -> text ('a':show n)) as [n..] 
sof's avatar
sof committed
528

529
mkHObj :: Type -> SDoc
sof's avatar
sof committed
530
mkHObj t = text "rts_mk" <> text (showFFIType t)
sof's avatar
sof committed
531

532
unpackHObj :: Type -> SDoc
sof's avatar
sof committed
533
unpackHObj t = text "rts_get" <> text (showFFIType t)
534
535

showStgType :: Type -> SDoc
536
showStgType t = text "Hs" <> text (showFFIType t)
sof's avatar
sof committed
537

sof's avatar
sof committed
538
showFFIType :: Type -> String
539
540
showFFIType t = getOccString (getName tc)
 where
541
  tc = case tcSplitTyConApp_maybe (repType t) of
542
543
	    Just (tc,_) -> tc
	    Nothing	-> pprPanic "showFFIType" (ppr t)
544
\end{code}