Merge branch 'master' of git@github.com:atgreen/libffi
[libffi.git] / 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 #define @TARGET@
61
62 /* ---- System configuration information --------------------------------- */
63
64 #include <ffitarget.h>
65
66 #ifndef LIBFFI_ASM
67
68 #ifdef _MSC_VER
69 #define __attribute__(X)
70 #endif
71
72 #include <stddef.h>
73 #include <limits.h>
74
75 /* LONG_LONG_MAX is not always defined (not if STRICT_ANSI, for example).
76 But we can find it either under the correct ANSI name, or under GNU
77 C's internal name. */
78 #ifdef LONG_LONG_MAX
79 # define FFI_LONG_LONG_MAX LONG_LONG_MAX
80 #else
81 # ifdef LLONG_MAX
82 # define FFI_LONG_LONG_MAX LLONG_MAX
83 # else
84 # ifdef __GNUC__
85 # define FFI_LONG_LONG_MAX __LONG_LONG_MAX__
86 # endif
87 # endif
88 #endif
89
90 /* The closure code assumes that this works on pointers, i.e. a size_t */
91 /* can hold a pointer. */
92
93 typedef struct _ffi_type
94 {
95 size_t size;
96 unsigned short alignment;
97 unsigned short type;
98 struct _ffi_type **elements;
99 } ffi_type;
100
101 #ifndef LIBFFI_HIDE_BASIC_TYPES
102 #if SCHAR_MAX == 127
103 # define ffi_type_uchar ffi_type_uint8
104 # define ffi_type_schar ffi_type_sint8
105 #else
106 #error "char size not supported"
107 #endif
108
109 #if SHRT_MAX == 32767
110 # define ffi_type_ushort ffi_type_uint16
111 # define ffi_type_sshort ffi_type_sint16
112 #elif SHRT_MAX == 2147483647
113 # define ffi_type_ushort ffi_type_uint32
114 # define ffi_type_sshort ffi_type_sint32
115 #else
116 #error "short size not supported"
117 #endif
118
119 #if INT_MAX == 32767
120 # define ffi_type_uint ffi_type_uint16
121 # define ffi_type_sint ffi_type_sint16
122 #elif INT_MAX == 2147483647
123 # define ffi_type_uint ffi_type_uint32
124 # define ffi_type_sint ffi_type_sint32
125 #elif INT_MAX == 9223372036854775807
126 # define ffi_type_uint ffi_type_uint64
127 # define ffi_type_sint ffi_type_sint64
128 #else
129 #error "int size not supported"
130 #endif
131
132 #if LONG_MAX == 2147483647
133 # if FFI_LONG_LONG_MAX != 9223372036854775807
134 #error "no 64-bit data type supported"
135 # endif
136 #elif LONG_MAX != 9223372036854775807
137 #error "long size not supported"
138 #endif
139
140 #if LONG_MAX == 2147483647
141 # define ffi_type_ulong ffi_type_uint32
142 # define ffi_type_slong ffi_type_sint32
143 #elif LONG_MAX == 9223372036854775807
144 # define ffi_type_ulong ffi_type_uint64
145 # define ffi_type_slong ffi_type_sint64
146 #else
147 #error "long size not supported"
148 #endif
149
150 /* These are defined in types.c */
151 extern ffi_type ffi_type_void;
152 extern ffi_type ffi_type_uint8;
153 extern ffi_type ffi_type_sint8;
154 extern ffi_type ffi_type_uint16;
155 extern ffi_type ffi_type_sint16;
156 extern ffi_type ffi_type_uint32;
157 extern ffi_type ffi_type_sint32;
158 extern ffi_type ffi_type_uint64;
159 extern ffi_type ffi_type_sint64;
160 extern ffi_type ffi_type_float;
161 extern ffi_type ffi_type_double;
162 extern ffi_type ffi_type_pointer;
163
164 #if @HAVE_LONG_DOUBLE@
165 extern ffi_type ffi_type_longdouble;
166 #else
167 #define ffi_type_longdouble ffi_type_double
168 #endif
169 #endif /* LIBFFI_HIDE_BASIC_TYPES */
170
171 typedef enum {
172 FFI_OK = 0,
173 FFI_BAD_TYPEDEF,
174 FFI_BAD_ABI
175 } ffi_status;
176
177 typedef unsigned FFI_TYPE;
178
179 typedef struct {
180 ffi_abi abi;
181 unsigned nargs;
182 ffi_type **arg_types;
183 ffi_type *rtype;
184 unsigned bytes;
185 unsigned flags;
186 #ifdef FFI_EXTRA_CIF_FIELDS
187 FFI_EXTRA_CIF_FIELDS;
188 #endif
189 } ffi_cif;
190
191 /* ---- Definitions for the raw API -------------------------------------- */
192
193 #ifndef FFI_SIZEOF_ARG
194 # if LONG_MAX == 2147483647
195 # define FFI_SIZEOF_ARG 4
196 # elif LONG_MAX == 9223372036854775807
197 # define FFI_SIZEOF_ARG 8
198 # endif
199 #endif
200
201 #ifndef FFI_SIZEOF_JAVA_RAW
202 # define FFI_SIZEOF_JAVA_RAW FFI_SIZEOF_ARG
203 #endif
204
205 typedef union {
206 ffi_sarg sint;
207 ffi_arg uint;
208 float flt;
209 char data[FFI_SIZEOF_ARG];
210 void* ptr;
211 } ffi_raw;
212
213 #if FFI_SIZEOF_JAVA_RAW == 4 && FFI_SIZEOF_ARG == 8
214 /* This is a special case for mips64/n32 ABI (and perhaps others) where
215 sizeof(void *) is 4 and FFI_SIZEOF_ARG is 8. */
216 typedef union {
217 signed int sint;
218 unsigned int uint;
219 float flt;
220 char data[FFI_SIZEOF_JAVA_RAW];
221 void* ptr;
222 } ffi_java_raw;
223 #else
224 typedef ffi_raw ffi_java_raw;
225 #endif
226
227
228 void ffi_raw_call (ffi_cif *cif,
229 void (*fn)(void),
230 void *rvalue,
231 ffi_raw *avalue);
232
233 void ffi_ptrarray_to_raw (ffi_cif *cif, void **args, ffi_raw *raw);
234 void ffi_raw_to_ptrarray (ffi_cif *cif, ffi_raw *raw, void **args);
235 size_t ffi_raw_size (ffi_cif *cif);
236
237 /* This is analogous to the raw API, except it uses Java parameter */
238 /* packing, even on 64-bit machines. I.e. on 64-bit machines */
239 /* longs and doubles are followed by an empty 64-bit word. */
240
241 void ffi_java_raw_call (ffi_cif *cif,
242 void (*fn)(void),
243 void *rvalue,
244 ffi_java_raw *avalue);
245
246 void ffi_java_ptrarray_to_raw (ffi_cif *cif, void **args, ffi_java_raw *raw);
247 void ffi_java_raw_to_ptrarray (ffi_cif *cif, ffi_java_raw *raw, void **args);
248 size_t ffi_java_raw_size (ffi_cif *cif);
249
250 /* ---- Definitions for closures ----------------------------------------- */
251
252 #if FFI_CLOSURES
253
254 typedef struct {
255 char tramp[FFI_TRAMPOLINE_SIZE];
256 ffi_cif *cif;
257 void (*fun)(ffi_cif*,void*,void**,void*);
258 void *user_data;
259 } ffi_closure __attribute__((aligned (8)));
260
261 void *ffi_closure_alloc (size_t size, void **code);
262 void ffi_closure_free (void *);
263
264 ffi_status
265 ffi_prep_closure (ffi_closure*,
266 ffi_cif *,
267 void (*fun)(ffi_cif*,void*,void**,void*),
268 void *user_data);
269
270 ffi_status
271 ffi_prep_closure_loc (ffi_closure*,
272 ffi_cif *,
273 void (*fun)(ffi_cif*,void*,void**,void*),
274 void *user_data,
275 void*codeloc);
276
277 typedef struct {
278 char tramp[FFI_TRAMPOLINE_SIZE];
279
280 ffi_cif *cif;
281
282 #if !FFI_NATIVE_RAW_API
283
284 /* if this is enabled, then a raw closure has the same layout
285 as a regular closure. We use this to install an intermediate
286 handler to do the transaltion, void** -> ffi_raw*. */
287
288 void (*translate_args)(ffi_cif*,void*,void**,void*);
289 void *this_closure;
290
291 #endif
292
293 void (*fun)(ffi_cif*,void*,ffi_raw*,void*);
294 void *user_data;
295
296 } ffi_raw_closure;
297
298 typedef struct {
299 char tramp[FFI_TRAMPOLINE_SIZE];
300
301 ffi_cif *cif;
302
303 #if !FFI_NATIVE_RAW_API
304
305 /* if this is enabled, then a raw closure has the same layout
306 as a regular closure. We use this to install an intermediate
307 handler to do the transaltion, void** -> ffi_raw*. */
308
309 void (*translate_args)(ffi_cif*,void*,void**,void*);
310 void *this_closure;
311
312 #endif
313
314 void (*fun)(ffi_cif*,void*,ffi_java_raw*,void*);
315 void *user_data;
316
317 } ffi_java_raw_closure;
318
319 ffi_status
320 ffi_prep_raw_closure (ffi_raw_closure*,
321 ffi_cif *cif,
322 void (*fun)(ffi_cif*,void*,ffi_raw*,void*),
323 void *user_data);
324
325 ffi_status
326 ffi_prep_raw_closure_loc (ffi_raw_closure*,
327 ffi_cif *cif,
328 void (*fun)(ffi_cif*,void*,ffi_raw*,void*),
329 void *user_data,
330 void *codeloc);
331
332 ffi_status
333 ffi_prep_java_raw_closure (ffi_java_raw_closure*,
334 ffi_cif *cif,
335 void (*fun)(ffi_cif*,void*,ffi_java_raw*,void*),
336 void *user_data);
337
338 ffi_status
339 ffi_prep_java_raw_closure_loc (ffi_java_raw_closure*,
340 ffi_cif *cif,
341 void (*fun)(ffi_cif*,void*,ffi_java_raw*,void*),
342 void *user_data,
343 void *codeloc);
344
345 #endif /* FFI_CLOSURES */
346
347 /* ---- Public interface definition -------------------------------------- */
348
349 ffi_status ffi_prep_cif(ffi_cif *cif,
350 ffi_abi abi,
351 unsigned int nargs,
352 ffi_type *rtype,
353 ffi_type **atypes);
354
355 void ffi_call(ffi_cif *cif,
356 void (*fn)(void),
357 void *rvalue,
358 void **avalue);
359
360 /* Useful for eliminating compiler warnings */
361 #define FFI_FN(f) ((void (*)(void))f)
362
363 /* ---- Definitions shared with assembly code ---------------------------- */
364
365 #endif
366
367 /* If these change, update src/mips/ffitarget.h. */
368 #define FFI_TYPE_VOID 0
369 #define FFI_TYPE_INT 1
370 #define FFI_TYPE_FLOAT 2
371 #define FFI_TYPE_DOUBLE 3
372 #if @HAVE_LONG_DOUBLE@
373 #define FFI_TYPE_LONGDOUBLE 4
374 #else
375 #define FFI_TYPE_LONGDOUBLE FFI_TYPE_DOUBLE
376 #endif
377 #define FFI_TYPE_UINT8 5
378 #define FFI_TYPE_SINT8 6
379 #define FFI_TYPE_UINT16 7
380 #define FFI_TYPE_SINT16 8
381 #define FFI_TYPE_UINT32 9
382 #define FFI_TYPE_SINT32 10
383 #define FFI_TYPE_UINT64 11
384 #define FFI_TYPE_SINT64 12
385 #define FFI_TYPE_STRUCT 13
386 #define FFI_TYPE_POINTER 14
387
388 /* This should always refer to the last type code (for sanity checks) */
389 #define FFI_TYPE_LAST FFI_TYPE_POINTER
390
391 #ifdef __cplusplus
392 }
393 #endif
394
395 #endif