OSDN Git Service

Daily bump.
[pf3gnuchains/gcc-fork.git] / libffi / include / ffi.h.in
1 /* -----------------------------------------------------------------*-C-*-
2    libffi @VERSION@ - Copyright (c) 1996-2003, 2007, 2008  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,
16    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
17    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
18    NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
19    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
20    WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22    DEALINGS IN THE SOFTWARE.
23
24    ----------------------------------------------------------------------- */
25
26 /* -------------------------------------------------------------------
27    The basic API is described in the README file.
28
29    The raw API is designed to bypass some of the argument packing
30    and unpacking on architectures for which it can be avoided.
31
32    The closure API allows interpreted functions to be packaged up
33    inside a C function pointer, so that they can be called as C functions,
34    with no understanding on the client side that they are interpreted.
35    It can also be used in other cases in which it is necessary to package
36    up a user specified parameter and a function pointer as a single
37    function pointer.
38
39    The closure API must be implemented in order to get its functionality,
40    e.g. for use by gij.  Routines are provided to emulate the raw API
41    if the underlying platform doesn't allow faster implementation.
42
43    More details on the raw and cloure API can be found in:
44
45    http://gcc.gnu.org/ml/java/1999-q3/msg00138.html
46
47    and
48
49    http://gcc.gnu.org/ml/java/1999-q3/msg00174.html
50    -------------------------------------------------------------------- */
51
52 #ifndef LIBFFI_H
53 #define LIBFFI_H
54
55 #ifdef __cplusplus
56 extern "C" {
57 #endif
58
59 /* Specify which architecture libffi is configured for. */
60 #ifndef @TARGET@
61 #define @TARGET@
62 #endif
63
64 /* ---- System configuration information --------------------------------- */
65
66 #include <ffitarget.h>
67
68 #ifndef LIBFFI_ASM
69
70 #ifdef _MSC_VER
71 #define __attribute__(X)
72 #endif
73
74 #include <stddef.h>
75 #include <limits.h>
76
77 /* LONG_LONG_MAX is not always defined (not if STRICT_ANSI, for example).
78    But we can find it either under the correct ANSI name, or under GNU
79    C's internal name.  */
80 #ifdef LONG_LONG_MAX
81 # define FFI_LONG_LONG_MAX LONG_LONG_MAX
82 #else
83 # ifdef LLONG_MAX
84 #  define FFI_LONG_LONG_MAX LLONG_MAX
85 # else
86 #  ifdef __GNUC__
87 #   define FFI_LONG_LONG_MAX __LONG_LONG_MAX__
88 #  endif
89 # endif
90 #endif
91
92 /* The closure code assumes that this works on pointers, i.e. a size_t  */
93 /* can hold a pointer.                                                  */
94
95 typedef struct _ffi_type
96 {
97   size_t size;
98   unsigned short alignment;
99   unsigned short type;
100   struct _ffi_type **elements;
101 } ffi_type;
102
103 #ifndef LIBFFI_HIDE_BASIC_TYPES
104 #if SCHAR_MAX == 127
105 # define ffi_type_uchar                ffi_type_uint8
106 # define ffi_type_schar                ffi_type_sint8
107 #else
108  #error "char size not supported"
109 #endif
110
111 #if SHRT_MAX == 32767
112 # define ffi_type_ushort       ffi_type_uint16
113 # define ffi_type_sshort       ffi_type_sint16
114 #elif SHRT_MAX == 2147483647
115 # define ffi_type_ushort       ffi_type_uint32
116 # define ffi_type_sshort       ffi_type_sint32
117 #else
118  #error "short size not supported"
119 #endif
120
121 #if INT_MAX == 32767
122 # define ffi_type_uint         ffi_type_uint16
123 # define ffi_type_sint         ffi_type_sint16
124 #elif INT_MAX == 2147483647
125 # define ffi_type_uint         ffi_type_uint32
126 # define ffi_type_sint         ffi_type_sint32
127 #elif INT_MAX == 9223372036854775807
128 # define ffi_type_uint         ffi_type_uint64
129 # define ffi_type_sint         ffi_type_sint64
130 #else
131  #error "int size not supported"
132 #endif
133
134 #if LONG_MAX == 2147483647
135 # if FFI_LONG_LONG_MAX != 9223372036854775807
136  #error "no 64-bit data type supported"
137 # endif
138 #elif LONG_MAX != 9223372036854775807
139  #error "long size not supported"
140 #endif
141
142 #if LONG_MAX == 2147483647
143 # define ffi_type_ulong        ffi_type_uint32
144 # define ffi_type_slong        ffi_type_sint32
145 #elif LONG_MAX == 9223372036854775807
146 # define ffi_type_ulong        ffi_type_uint64
147 # define ffi_type_slong        ffi_type_sint64
148 #else
149  #error "long size not supported"
150 #endif
151
152 /* These are defined in types.c */
153 extern ffi_type ffi_type_void;
154 extern ffi_type ffi_type_uint8;
155 extern ffi_type ffi_type_sint8;
156 extern ffi_type ffi_type_uint16;
157 extern ffi_type ffi_type_sint16;
158 extern ffi_type ffi_type_uint32;
159 extern ffi_type ffi_type_sint32;
160 extern ffi_type ffi_type_uint64;
161 extern ffi_type ffi_type_sint64;
162 extern ffi_type ffi_type_float;
163 extern ffi_type ffi_type_double;
164 extern ffi_type ffi_type_pointer;
165
166 #if @HAVE_LONG_DOUBLE@
167 extern ffi_type ffi_type_longdouble;
168 #else
169 #define ffi_type_longdouble ffi_type_double
170 #endif
171 #endif /* LIBFFI_HIDE_BASIC_TYPES */
172
173 typedef enum {
174   FFI_OK = 0,
175   FFI_BAD_TYPEDEF,
176   FFI_BAD_ABI
177 } ffi_status;
178
179 typedef unsigned FFI_TYPE;
180
181 typedef struct {
182   ffi_abi abi;
183   unsigned nargs;
184   ffi_type **arg_types;
185   ffi_type *rtype;
186   unsigned bytes;
187   unsigned flags;
188 #ifdef FFI_EXTRA_CIF_FIELDS
189   FFI_EXTRA_CIF_FIELDS;
190 #endif
191 } ffi_cif;
192
193 /* ---- Definitions for the raw API -------------------------------------- */
194
195 #ifndef FFI_SIZEOF_ARG
196 # if LONG_MAX == 2147483647
197 #  define FFI_SIZEOF_ARG        4
198 # elif LONG_MAX == 9223372036854775807
199 #  define FFI_SIZEOF_ARG        8
200 # endif
201 #endif
202
203 #ifndef FFI_SIZEOF_JAVA_RAW
204 #  define FFI_SIZEOF_JAVA_RAW FFI_SIZEOF_ARG
205 #endif
206
207 typedef union {
208   ffi_sarg  sint;
209   ffi_arg   uint;
210   float     flt;
211   char      data[FFI_SIZEOF_ARG];
212   void*     ptr;
213 } ffi_raw;
214
215 #if FFI_SIZEOF_JAVA_RAW == 4 && FFI_SIZEOF_ARG == 8
216 /* This is a special case for mips64/n32 ABI (and perhaps others) where
217    sizeof(void *) is 4 and FFI_SIZEOF_ARG is 8.  */
218 typedef union {
219   signed int    sint;
220   unsigned int  uint;
221   float         flt;
222   char          data[FFI_SIZEOF_JAVA_RAW];
223   void*         ptr;
224 } ffi_java_raw;
225 #else
226 typedef ffi_raw ffi_java_raw;
227 #endif
228
229
230 void ffi_raw_call (ffi_cif *cif,
231                    void (*fn)(void),
232                    void *rvalue,
233                    ffi_raw *avalue);
234
235 void ffi_ptrarray_to_raw (ffi_cif *cif, void **args, ffi_raw *raw);
236 void ffi_raw_to_ptrarray (ffi_cif *cif, ffi_raw *raw, void **args);
237 size_t ffi_raw_size (ffi_cif *cif);
238
239 /* This is analogous to the raw API, except it uses Java parameter      */
240 /* packing, even on 64-bit machines.  I.e. on 64-bit machines           */
241 /* longs and doubles are followed by an empty 64-bit word.              */
242
243 void ffi_java_raw_call (ffi_cif *cif,
244                         void (*fn)(void),
245                         void *rvalue,
246                         ffi_java_raw *avalue);
247
248 void ffi_java_ptrarray_to_raw (ffi_cif *cif, void **args, ffi_java_raw *raw);
249 void ffi_java_raw_to_ptrarray (ffi_cif *cif, ffi_java_raw *raw, void **args);
250 size_t ffi_java_raw_size (ffi_cif *cif);
251
252 /* ---- Definitions for closures ----------------------------------------- */
253
254 #if FFI_CLOSURES
255
256 #ifdef _MSC_VER
257 __declspec(align(8))
258 #endif
259 typedef struct {
260   char tramp[FFI_TRAMPOLINE_SIZE];
261   ffi_cif   *cif;
262   void     (*fun)(ffi_cif*,void*,void**,void*);
263   void      *user_data;
264 #ifdef __GNUC__
265 } ffi_closure __attribute__((aligned (8)));
266 #else
267 } ffi_closure;
268 #endif
269
270 void *ffi_closure_alloc (size_t size, void **code);
271 void ffi_closure_free (void *);
272
273 ffi_status
274 ffi_prep_closure (ffi_closure*,
275                   ffi_cif *,
276                   void (*fun)(ffi_cif*,void*,void**,void*),
277                   void *user_data);
278
279 ffi_status
280 ffi_prep_closure_loc (ffi_closure*,
281                       ffi_cif *,
282                       void (*fun)(ffi_cif*,void*,void**,void*),
283                       void *user_data,
284                       void*codeloc);
285
286 typedef struct {
287   char tramp[FFI_TRAMPOLINE_SIZE];
288
289   ffi_cif   *cif;
290
291 #if !FFI_NATIVE_RAW_API
292
293   /* if this is enabled, then a raw closure has the same layout 
294      as a regular closure.  We use this to install an intermediate 
295      handler to do the transaltion, void** -> ffi_raw*. */
296
297   void     (*translate_args)(ffi_cif*,void*,void**,void*);
298   void      *this_closure;
299
300 #endif
301
302   void     (*fun)(ffi_cif*,void*,ffi_raw*,void*);
303   void      *user_data;
304
305 } ffi_raw_closure;
306
307 typedef struct {
308   char tramp[FFI_TRAMPOLINE_SIZE];
309
310   ffi_cif   *cif;
311
312 #if !FFI_NATIVE_RAW_API
313
314   /* if this is enabled, then a raw closure has the same layout 
315      as a regular closure.  We use this to install an intermediate 
316      handler to do the transaltion, void** -> ffi_raw*. */
317
318   void     (*translate_args)(ffi_cif*,void*,void**,void*);
319   void      *this_closure;
320
321 #endif
322
323   void     (*fun)(ffi_cif*,void*,ffi_java_raw*,void*);
324   void      *user_data;
325
326 } ffi_java_raw_closure;
327
328 ffi_status
329 ffi_prep_raw_closure (ffi_raw_closure*,
330                       ffi_cif *cif,
331                       void (*fun)(ffi_cif*,void*,ffi_raw*,void*),
332                       void *user_data);
333
334 ffi_status
335 ffi_prep_raw_closure_loc (ffi_raw_closure*,
336                           ffi_cif *cif,
337                           void (*fun)(ffi_cif*,void*,ffi_raw*,void*),
338                           void *user_data,
339                           void *codeloc);
340
341 ffi_status
342 ffi_prep_java_raw_closure (ffi_java_raw_closure*,
343                            ffi_cif *cif,
344                            void (*fun)(ffi_cif*,void*,ffi_java_raw*,void*),
345                            void *user_data);
346
347 ffi_status
348 ffi_prep_java_raw_closure_loc (ffi_java_raw_closure*,
349                                ffi_cif *cif,
350                                void (*fun)(ffi_cif*,void*,ffi_java_raw*,void*),
351                                void *user_data,
352                                void *codeloc);
353
354 #endif /* FFI_CLOSURES */
355
356 /* ---- Public interface definition -------------------------------------- */
357
358 ffi_status ffi_prep_cif(ffi_cif *cif,
359                         ffi_abi abi,
360                         unsigned int nargs,
361                         ffi_type *rtype,
362                         ffi_type **atypes);
363
364 void ffi_call(ffi_cif *cif,
365               void (*fn)(void),
366               void *rvalue,
367               void **avalue);
368
369 /* Useful for eliminating compiler warnings */
370 #define FFI_FN(f) ((void (*)(void))f)
371
372 /* ---- Definitions shared with assembly code ---------------------------- */
373
374 #endif
375
376 /* If these change, update src/mips/ffitarget.h. */
377 #define FFI_TYPE_VOID       0    
378 #define FFI_TYPE_INT        1
379 #define FFI_TYPE_FLOAT      2    
380 #define FFI_TYPE_DOUBLE     3
381 #if @HAVE_LONG_DOUBLE@
382 #define FFI_TYPE_LONGDOUBLE 4
383 #else
384 #define FFI_TYPE_LONGDOUBLE FFI_TYPE_DOUBLE
385 #endif
386 #define FFI_TYPE_UINT8      5   
387 #define FFI_TYPE_SINT8      6
388 #define FFI_TYPE_UINT16     7 
389 #define FFI_TYPE_SINT16     8
390 #define FFI_TYPE_UINT32     9
391 #define FFI_TYPE_SINT32     10
392 #define FFI_TYPE_UINT64     11
393 #define FFI_TYPE_SINT64     12
394 #define FFI_TYPE_STRUCT     13
395 #define FFI_TYPE_POINTER    14
396
397 /* This should always refer to the last type code (for sanity checks) */
398 #define FFI_TYPE_LAST       FFI_TYPE_POINTER
399
400 #ifdef __cplusplus
401 }
402 #endif
403
404 #endif