1/* -----------------------------------------------------------------*-C-*-
2   libffi @VERSION@ - Copyright (c) 1996-2003  Red Hat, Inc.
3
4   Permission is hereby granted, free of charge, to any person obtaining
5   a copy of this software and associated documentation files (the
6   ``Software''), to deal in the Software without restriction, including
7   without limitation the rights to use, copy, modify, merge, publish,
8   distribute, sublicense, and/or sell copies of the Software, and to
9   permit persons to whom the Software is furnished to do so, subject to
10   the following conditions:
11
12   The above copyright notice and this permission notice shall be included
13   in all copies or substantial portions of the Software.
14
15   THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, EXPRESS
16   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
17   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
18   IN NO EVENT SHALL CYGNUS SOLUTIONS BE LIABLE FOR ANY CLAIM, DAMAGES OR
19   OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
20   ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
21   OTHER DEALINGS IN THE SOFTWARE.
22
23   ----------------------------------------------------------------------- */
24
25/* -------------------------------------------------------------------
26   The basic API is described in the README file.
27
28   The raw API is designed to bypass some of the argument packing
29   and unpacking on architectures for which it can be avoided.
30
31   The closure API allows interpreted functions to be packaged up
32   inside a C function pointer, so that they can be called as C functions,
33   with no understanding on the client side that they are interpreted.
34   It can also be used in other cases in which it is necessary to package
35   up a user specified parameter and a function pointer as a single
36   function pointer.
37
38   The closure API must be implemented in order to get its functionality,
39   e.g. for use by gij.  Routines are provided to emulate the raw API
40   if the underlying platform doesn't allow faster implementation.
41
42   More details on the raw and cloure API can be found in:
43
44   http://gcc.gnu.org/ml/java/1999-q3/msg00138.html
45
46   and
47
48   http://gcc.gnu.org/ml/java/1999-q3/msg00174.html
49   -------------------------------------------------------------------- */
50
51#ifndef LIBFFI_H
52#define LIBFFI_H
53
54#ifdef __cplusplus
55extern "C" {
56#endif
57
58/* Specify which architecture libffi is configured for. */
59#define @TARGET@
60
61/* ---- System configuration information --------------------------------- */
62
63#include <ffitarget.h>
64
65#ifndef LIBFFI_ASM
66
67#include <stddef.h>
68#include <limits.h>
69
70/* LONG_LONG_MAX is not always defined (not if STRICT_ANSI, for example).
71   But we can find it either under the correct ANSI name, or under GNU
72   C's internal name.  */
73#ifdef LONG_LONG_MAX
74# define FFI_LONG_LONG_MAX LONG_LONG_MAX
75#else
76# ifdef LLONG_MAX
77#  define FFI_LONG_LONG_MAX LLONG_MAX
78# else
79#  ifdef __GNUC__
80#   define FFI_LONG_LONG_MAX __LONG_LONG_MAX__
81#  endif
82# endif
83#endif
84
85#if SCHAR_MAX == 127
86# define ffi_type_uchar                ffi_type_uint8
87# define ffi_type_schar                ffi_type_sint8
88#else
89 #error "char size not supported"
90#endif
91
92#if SHRT_MAX == 32767
93# define ffi_type_ushort       ffi_type_uint16
94# define ffi_type_sshort       ffi_type_sint16
95#elif SHRT_MAX == 2147483647
96# define ffi_type_ushort       ffi_type_uint32
97# define ffi_type_sshort       ffi_type_sint32
98#else
99 #error "short size not supported"
100#endif
101
102#if INT_MAX == 32767
103# define ffi_type_uint         ffi_type_uint16
104# define ffi_type_sint         ffi_type_sint16
105#elif INT_MAX == 2147483647
106# define ffi_type_uint         ffi_type_uint32
107# define ffi_type_sint         ffi_type_sint32
108#elif INT_MAX == 9223372036854775807
109# define ffi_type_uint         ffi_type_uint64
110# define ffi_type_sint         ffi_type_sint64
111#else
112 #error "int size not supported"
113#endif
114
115#define ffi_type_ulong         ffi_type_uint64
116#define ffi_type_slong         ffi_type_sint64
117#if LONG_MAX == 2147483647
118
119#ifdef COMMENT
120# if FFI_LONG_LONG_MAX != 9223372036854775807
121  #error "no 64-bit data type supported"
122# endif
123#endif
124
125#elif LONG_MAX != 9223372036854775807
126 #error "long size not supported"
127#endif
128
129/* The closure code assumes that this works on pointers, i.e. a size_t	*/
130/* can hold a pointer.							*/
131
132typedef struct _ffi_type
133{
134  size_t size;
135  unsigned short alignment;
136  unsigned short type;
137  /*@null@*/ struct _ffi_type **elements;
138} ffi_type;
139
140/* These are defined in types.c */
141extern ffi_type ffi_type_void;
142extern ffi_type ffi_type_uint8;
143extern ffi_type ffi_type_sint8;
144extern ffi_type ffi_type_uint16;
145extern ffi_type ffi_type_sint16;
146extern ffi_type ffi_type_uint32;
147extern ffi_type ffi_type_sint32;
148extern ffi_type ffi_type_uint64;
149extern ffi_type ffi_type_sint64;
150extern ffi_type ffi_type_float;
151extern ffi_type ffi_type_double;
152extern ffi_type ffi_type_longdouble;
153extern ffi_type ffi_type_pointer;
154
155
156typedef enum {
157  FFI_OK = 0,
158  FFI_BAD_TYPEDEF,
159  FFI_BAD_ABI
160} ffi_status;
161
162typedef unsigned FFI_TYPE;
163
164typedef struct {
165  ffi_abi abi;
166  unsigned nargs;
167  /*@dependent@*/ ffi_type **arg_types;
168  /*@dependent@*/ ffi_type *rtype;
169  unsigned bytes;
170  unsigned flags;
171#ifdef FFI_EXTRA_CIF_FIELDS
172  FFI_EXTRA_CIF_FIELDS;
173#endif
174} ffi_cif;
175
176/* ---- Definitions for the raw API -------------------------------------- */
177
178#ifndef FFI_SIZEOF_ARG
179# if LONG_MAX == 2147483647
180#  define FFI_SIZEOF_ARG        4
181# elif LONG_MAX == 9223372036854775807
182#  define FFI_SIZEOF_ARG        8
183# endif
184#endif
185
186typedef union {
187  ffi_sarg  sint;
188  ffi_arg   uint;
189  float	    flt;
190  char      data[FFI_SIZEOF_ARG];
191  void*     ptr;
192} ffi_raw;
193
194void ffi_raw_call (/*@dependent@*/ ffi_cif *cif,
195		   void (*fn)(void),
196		   /*@out@*/ void *rvalue,
197		   /*@dependent@*/ ffi_raw *avalue);
198
199void ffi_ptrarray_to_raw (ffi_cif *cif, void **args, ffi_raw *raw);
200void ffi_raw_to_ptrarray (ffi_cif *cif, ffi_raw *raw, void **args);
201size_t ffi_raw_size (ffi_cif *cif);
202
203/* This is analogous to the raw API, except it uses Java parameter	*/
204/* packing, even on 64-bit machines.  I.e. on 64-bit machines		*/
205/* longs and doubles are followed by an empty 64-bit word.		*/
206
207void ffi_java_raw_call (/*@dependent@*/ ffi_cif *cif,
208		        void (*fn)(void),
209		        /*@out@*/ void *rvalue,
210		        /*@dependent@*/ ffi_raw *avalue);
211
212void ffi_java_ptrarray_to_raw (ffi_cif *cif, void **args, ffi_raw *raw);
213void ffi_java_raw_to_ptrarray (ffi_cif *cif, ffi_raw *raw, void **args);
214size_t ffi_java_raw_size (ffi_cif *cif);
215
216/* ---- Definitions for closures ----------------------------------------- */
217
218#if FFI_CLOSURES
219
220typedef struct {
221  char tramp[FFI_TRAMPOLINE_SIZE];
222  ffi_cif   *cif;
223  void     (*fun)(ffi_cif*,void*,void**,void*);
224  void      *user_data;
225} ffi_closure __attribute__((aligned (8)));
226
227ffi_status
228ffi_prep_closure (ffi_closure*,
229		  ffi_cif *,
230		  void (*fun)(ffi_cif*,void*,void**,void*),
231		  void *user_data);
232
233typedef struct {
234  char tramp[FFI_TRAMPOLINE_SIZE];
235
236  ffi_cif   *cif;
237
238#if !FFI_NATIVE_RAW_API
239
240  /* if this is enabled, then a raw closure has the same layout
241     as a regular closure.  We use this to install an intermediate
242     handler to do the transaltion, void** -> ffi_raw*. */
243
244  void     (*translate_args)(ffi_cif*,void*,void**,void*);
245  void      *this_closure;
246
247#endif
248
249  void     (*fun)(ffi_cif*,void*,ffi_raw*,void*);
250  void      *user_data;
251
252} ffi_raw_closure;
253
254ffi_status
255ffi_prep_raw_closure (ffi_raw_closure*,
256		      ffi_cif *cif,
257		      void (*fun)(ffi_cif*,void*,ffi_raw*,void*),
258		      void *user_data);
259
260ffi_status
261ffi_prep_java_raw_closure (ffi_raw_closure*,
262		           ffi_cif *cif,
263		           void (*fun)(ffi_cif*,void*,ffi_raw*,void*),
264		           void *user_data);
265
266#endif /* FFI_CLOSURES */
267
268/* ---- Public interface definition -------------------------------------- */
269
270ffi_status ffi_prep_cif(/*@out@*/ /*@partial@*/ ffi_cif *cif,
271			ffi_abi abi,
272			unsigned int nargs,
273			/*@dependent@*/ /*@out@*/ /*@partial@*/ ffi_type *rtype,
274			/*@dependent@*/ ffi_type **atypes);
275
276void ffi_call(/*@dependent@*/ ffi_cif *cif,
277	      void (*fn)(void),
278	      /*@out@*/ void *rvalue,
279	      /*@dependent@*/ void **avalue);
280
281/* Useful for eliminating compiler warnings */
282#define FFI_FN(f) ((void (*)())f)
283
284/* ---- Definitions shared with assembly code ---------------------------- */
285
286#endif
287
288/* If these change, update src/mips/ffitarget.h. */
289#define FFI_TYPE_VOID       0
290#define FFI_TYPE_INT        1
291#define FFI_TYPE_FLOAT      2
292#define FFI_TYPE_DOUBLE     3
293#if @HAVE_LONG_DOUBLE@
294#define FFI_TYPE_LONGDOUBLE 4
295#else
296#define FFI_TYPE_LONGDOUBLE FFI_TYPE_DOUBLE
297#endif
298#define FFI_TYPE_UINT8      5
299#define FFI_TYPE_SINT8      6
300#define FFI_TYPE_UINT16     7
301#define FFI_TYPE_SINT16     8
302#define FFI_TYPE_UINT32     9
303#define FFI_TYPE_SINT32     10
304#define FFI_TYPE_UINT64     11
305#define FFI_TYPE_SINT64     12
306#define FFI_TYPE_STRUCT     13
307#define FFI_TYPE_POINTER    14
308
309/* This should always refer to the last type code (for sanity checks) */
310#define FFI_TYPE_LAST       FFI_TYPE_POINTER
311
312#ifdef __cplusplus
313}
314#endif
315
316#endif
317
318