1 /* -----------------------------------------------------------------------
2 java_raw_api.c - Copyright (c) 1999, 2007 Red Hat, Inc.
6 Raw_api.c author: Kresten Krab Thorup <krab@gnu.org>
7 Java_raw_api.c author: Hans-J. Boehm <hboehm@hpl.hp.com>
11 Permission is hereby granted, free of charge, to any person obtaining
12 a copy of this software and associated documentation files (the
13 ``Software''), to deal in the Software without restriction, including
14 without limitation the rights to use, copy, modify, merge, publish,
15 distribute, sublicense, and/or sell copies of the Software, and to
16 permit persons to whom the Software is furnished to do so, subject to
17 the following conditions:
19 The above copyright notice and this permission notice shall be included
20 in all copies or substantial portions of the Software.
22 THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, EXPRESS
23 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
24 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
25 IN NO EVENT SHALL CYGNUS SOLUTIONS BE LIABLE FOR ANY CLAIM, DAMAGES OR
26 OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
27 ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
28 OTHER DEALINGS IN THE SOFTWARE.
29 ----------------------------------------------------------------------- */
31 /* This defines a Java- and 64-bit specific variant of the raw API. */
32 /* It assumes that "raw" argument blocks look like Java stacks on a */
33 /* 64-bit machine. Arguments that can be stored in a single stack */
34 /* stack slots (longs, doubles) occupy 128 bits, but only the first */
35 /* 64 bits are actually used. */
38 #include <ffi_common.h>
41 #if !defined(NO_JAVA_RAW_API) && !defined(FFI_NO_RAW_API)
44 ffi_java_raw_size (ffi_cif
*cif
)
49 ffi_type
**at
= cif
->arg_types
;
51 for (i
= cif
->nargs
-1; i
>= 0; i
--, at
++)
53 switch((*at
) -> type
) {
57 result
+= 2 * FFI_SIZEOF_JAVA_RAW
;
60 /* No structure parameters in Java. */
63 result
+= FFI_SIZEOF_JAVA_RAW
;
72 ffi_java_raw_to_ptrarray (ffi_cif
*cif
, ffi_java_raw
*raw
, void **args
)
75 ffi_type
**tp
= cif
->arg_types
;
79 for (i
= 0; i
< cif
->nargs
; i
++, tp
++, args
++)
85 *args
= (void*) ((char*)(raw
++) + 3);
90 *args
= (void*) ((char*)(raw
++) + 2);
93 #if FFI_SIZEOF_JAVA_RAW == 8
102 case FFI_TYPE_POINTER
:
103 *args
= (void*) &(raw
++)->ptr
;
109 ALIGN ((*tp
)->size
, sizeof(ffi_java_raw
)) / sizeof(ffi_java_raw
);
113 #else /* WORDS_BIGENDIAN */
117 /* then assume little endian */
118 for (i
= 0; i
< cif
->nargs
; i
++, tp
++, args
++)
120 #if FFI_SIZEOF_JAVA_RAW == 8
121 switch((*tp
)->type
) {
122 case FFI_TYPE_UINT64
:
123 case FFI_TYPE_SINT64
:
124 case FFI_TYPE_DOUBLE
:
129 *args
= (void*) raw
++;
131 #else /* FFI_SIZEOF_JAVA_RAW != 8 */
134 ALIGN ((*tp
)->size
, sizeof(ffi_java_raw
)) / sizeof(ffi_java_raw
);
135 #endif /* FFI_SIZEOF_JAVA_RAW == 8 */
139 #error "pdp endian not supported"
142 #endif /* WORDS_BIGENDIAN */
146 ffi_java_ptrarray_to_raw (ffi_cif
*cif
, void **args
, ffi_java_raw
*raw
)
149 ffi_type
**tp
= cif
->arg_types
;
151 for (i
= 0; i
< cif
->nargs
; i
++, tp
++, args
++)
157 *(UINT32
*)(raw
++) = *(UINT8
*) (*args
);
159 (raw
++)->uint
= *(UINT8
*) (*args
);
165 *(SINT32
*)(raw
++) = *(SINT8
*) (*args
);
167 (raw
++)->sint
= *(SINT8
*) (*args
);
171 case FFI_TYPE_UINT16
:
173 *(UINT32
*)(raw
++) = *(UINT16
*) (*args
);
175 (raw
++)->uint
= *(UINT16
*) (*args
);
179 case FFI_TYPE_SINT16
:
181 *(SINT32
*)(raw
++) = *(SINT16
*) (*args
);
183 (raw
++)->sint
= *(SINT16
*) (*args
);
187 case FFI_TYPE_UINT32
:
189 *(UINT32
*)(raw
++) = *(UINT32
*) (*args
);
191 (raw
++)->uint
= *(UINT32
*) (*args
);
195 case FFI_TYPE_SINT32
:
197 *(SINT32
*)(raw
++) = *(SINT32
*) (*args
);
199 (raw
++)->sint
= *(SINT32
*) (*args
);
204 (raw
++)->flt
= *(FLOAT32
*) (*args
);
207 #if FFI_SIZEOF_JAVA_RAW == 8
208 case FFI_TYPE_UINT64
:
209 case FFI_TYPE_SINT64
:
210 case FFI_TYPE_DOUBLE
:
211 raw
->uint
= *(UINT64
*) (*args
);
216 case FFI_TYPE_POINTER
:
217 (raw
++)->ptr
= **(void***) args
;
221 #if FFI_SIZEOF_JAVA_RAW == 8
222 FFI_ASSERT(0); /* Should have covered all cases */
224 memcpy ((void*) raw
->data
, (void*)*args
, (*tp
)->size
);
226 ALIGN ((*tp
)->size
, sizeof(ffi_java_raw
)) / sizeof(ffi_java_raw
);
232 #if !FFI_NATIVE_RAW_API
235 ffi_java_rvalue_to_raw (ffi_cif
*cif
, void *rvalue
)
237 #if WORDS_BIGENDIAN && FFI_SIZEOF_ARG == 8
238 switch (cif
->rtype
->type
)
241 case FFI_TYPE_UINT16
:
242 case FFI_TYPE_UINT32
:
243 *(UINT64
*)rvalue
<<= 32;
247 case FFI_TYPE_SINT16
:
248 case FFI_TYPE_SINT32
:
250 #if FFI_SIZEOF_JAVA_RAW == 4
251 case FFI_TYPE_POINTER
:
253 *(SINT64
*)rvalue
<<= 32;
263 ffi_java_raw_to_rvalue (ffi_cif
*cif
, void *rvalue
)
265 #if WORDS_BIGENDIAN && FFI_SIZEOF_ARG == 8
266 switch (cif
->rtype
->type
)
269 case FFI_TYPE_UINT16
:
270 case FFI_TYPE_UINT32
:
271 *(UINT64
*)rvalue
>>= 32;
275 case FFI_TYPE_SINT16
:
276 case FFI_TYPE_SINT32
:
278 #if FFI_SIZEOF_JAVA_RAW == 4
279 case FFI_TYPE_POINTER
:
281 *(SINT64
*)rvalue
>>= 32;
290 /* This is a generic definition of ffi_raw_call, to be used if the
291 * native system does not provide a machine-specific implementation.
292 * Having this, allows code to be written for the raw API, without
293 * the need for system-specific code to handle input in that format;
294 * these following couple of functions will handle the translation forth
295 * and back automatically. */
297 void ffi_java_raw_call (ffi_cif
*cif
, void (*fn
)(), void *rvalue
,
300 void **avalue
= (void**) alloca (cif
->nargs
* sizeof (void*));
301 ffi_java_raw_to_ptrarray (cif
, raw
, avalue
);
302 ffi_call (cif
, fn
, rvalue
, avalue
);
303 ffi_java_rvalue_to_raw (cif
, rvalue
);
306 #if FFI_CLOSURES /* base system provides closures */
309 ffi_java_translate_args (ffi_cif
*cif
, void *rvalue
,
310 void **avalue
, void *user_data
)
312 ffi_java_raw
*raw
= (ffi_java_raw
*)alloca (ffi_java_raw_size (cif
));
313 ffi_raw_closure
*cl
= (ffi_raw_closure
*)user_data
;
315 ffi_java_ptrarray_to_raw (cif
, avalue
, raw
);
316 (*cl
->fun
) (cif
, rvalue
, raw
, cl
->user_data
);
317 ffi_java_raw_to_rvalue (cif
, rvalue
);
321 ffi_prep_java_raw_closure_loc (ffi_java_raw_closure
* cl
,
323 void (*fun
)(ffi_cif
*,void*,ffi_java_raw
*,void*),
329 status
= ffi_prep_closure_loc ((ffi_closure
*) cl
,
331 &ffi_java_translate_args
,
334 if (status
== FFI_OK
)
337 cl
->user_data
= user_data
;
343 /* Again, here is the generic version of ffi_prep_raw_closure, which
344 * will install an intermediate "hub" for translation of arguments from
345 * the pointer-array format, to the raw format */
348 ffi_prep_java_raw_closure (ffi_java_raw_closure
* cl
,
350 void (*fun
)(ffi_cif
*,void*,ffi_java_raw
*,void*),
353 return ffi_prep_java_raw_closure_loc (cl
, cif
, fun
, user_data
, cl
);
356 #endif /* FFI_CLOSURES */
357 #endif /* !FFI_NATIVE_RAW_API */
358 #endif /* !FFI_NO_RAW_API */