Microsoft Visual C port
[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 #ifdef _MSC_VER
255 __declspec(align(8))
256 #endif
257 typedef struct {
258 char tramp[FFI_TRAMPOLINE_SIZE];
259 ffi_cif *cif;
260 void (*fun)(ffi_cif*,void*,void**,void*);
261 void *user_data;
262 #ifdef __GNUC__
263 } ffi_closure __attribute__((aligned (8)));
264 #else
265 } ffi_closure;
266 #endif
267
268 void *ffi_closure_alloc (size_t size, void **code);
269 void ffi_closure_free (void *);
270
271 ffi_status
272 ffi_prep_closure (ffi_closure*,
273 ffi_cif *,
274 void (*fun)(ffi_cif*,void*,void**,void*),
275 void *user_data);
276
277 ffi_status
278 ffi_prep_closure_loc (ffi_closure*,
279 ffi_cif *,
280 void (*fun)(ffi_cif*,void*,void**,void*),
281 void *user_data,
282 void*codeloc);
283
284 typedef struct {
285 char tramp[FFI_TRAMPOLINE_SIZE];
286
287 ffi_cif *cif;
288
289 #if !FFI_NATIVE_RAW_API
290
291 /* if this is enabled, then a raw closure has the same layout
292 as a regular closure. We use this to install an intermediate
293 handler to do the transaltion, void** -> ffi_raw*. */
294
295 void (*translate_args)(ffi_cif*,void*,void**,void*);
296 void *this_closure;
297
298 #endif
299
300 void (*fun)(ffi_cif*,void*,ffi_raw*,void*);
301 void *user_data;
302
303 } ffi_raw_closure;
304
305 typedef struct {
306 char tramp[FFI_TRAMPOLINE_SIZE];
307
308 ffi_cif *cif;
309
310 #if !FFI_NATIVE_RAW_API
311
312 /* if this is enabled, then a raw closure has the same layout
313 as a regular closure. We use this to install an intermediate
314 handler to do the transaltion, void** -> ffi_raw*. */
315
316 void (*translate_args)(ffi_cif*,void*,void**,void*);
317 void *this_closure;
318
319 #endif
320
321 void (*fun)(ffi_cif*,void*,ffi_java_raw*,void*);
322 void *user_data;
323
324 } ffi_java_raw_closure;
325
326 ffi_status
327 ffi_prep_raw_closure (ffi_raw_closure*,
328 ffi_cif *cif,
329 void (*fun)(ffi_cif*,void*,ffi_raw*,void*),
330 void *user_data);
331
332 ffi_status
333 ffi_prep_raw_closure_loc (ffi_raw_closure*,
334 ffi_cif *cif,
335 void (*fun)(ffi_cif*,void*,ffi_raw*,void*),
336 void *user_data,
337 void *codeloc);
338
339 ffi_status
340 ffi_prep_java_raw_closure (ffi_java_raw_closure*,
341 ffi_cif *cif,
342 void (*fun)(ffi_cif*,void*,ffi_java_raw*,void*),
343 void *user_data);
344
345 ffi_status
346 ffi_prep_java_raw_closure_loc (ffi_java_raw_closure*,
347 ffi_cif *cif,
348 void (*fun)(ffi_cif*,void*,ffi_java_raw*,void*),
349 void *user_data,
350 void *codeloc);
351
352 #endif /* FFI_CLOSURES */
353
354 /* ---- Public interface definition -------------------------------------- */
355
356 ffi_status ffi_prep_cif(ffi_cif *cif,
357 ffi_abi abi,
358 unsigned int nargs,
359 ffi_type *rtype,
360 ffi_type **atypes);
361
362 void ffi_call(ffi_cif *cif,
363 void (*fn)(void),
364 void *rvalue,
365 void **avalue);
366
367 /* Useful for eliminating compiler warnings */
368 #define FFI_FN(f) ((void (*)(void))f)
369
370 /* ---- Definitions shared with assembly code ---------------------------- */
371
372 #endif
373
374 /* If these change, update src/mips/ffitarget.h. */
375 #define FFI_TYPE_VOID 0
376 #define FFI_TYPE_INT 1
377 #define FFI_TYPE_FLOAT 2
378 #define FFI_TYPE_DOUBLE 3
379 #if @HAVE_LONG_DOUBLE@
380 #define FFI_TYPE_LONGDOUBLE 4
381 #else
382 #define FFI_TYPE_LONGDOUBLE FFI_TYPE_DOUBLE
383 #endif
384 #define FFI_TYPE_UINT8 5
385 #define FFI_TYPE_SINT8 6
386 #define FFI_TYPE_UINT16 7
387 #define FFI_TYPE_SINT16 8
388 #define FFI_TYPE_UINT32 9
389 #define FFI_TYPE_SINT32 10
390 #define FFI_TYPE_UINT64 11
391 #define FFI_TYPE_SINT64 12
392 #define FFI_TYPE_STRUCT 13
393 #define FFI_TYPE_POINTER 14
394
395 /* This should always refer to the last type code (for sanity checks) */
396 #define FFI_TYPE_LAST FFI_TYPE_POINTER
397
398 #ifdef __cplusplus
399 }
400 #endif
401
402 #endif