1 /* -----------------------------------------------------------------------
2 java_raw_api.c - Copyright (c) 1999 Cygnus Solutions
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>
40 #if !defined(NO_JAVA_RAW_API) && !defined(FFI_NO_RAW_API)
43 ffi_java_raw_size (ffi_cif
*cif
)
48 ffi_type
**at
= cif
->arg_types
;
50 for (i
= cif
->nargs
-1; i
>= 0; i
--, at
++)
52 switch((*at
) -> type
) {
56 result
+= 2 * SIZEOF_ARG
;
59 /* No structure parameters in Java. */
71 ffi_java_raw_to_ptrarray (ffi_cif
*cif
, ffi_raw
*raw
, void **args
)
74 ffi_type
**tp
= cif
->arg_types
;
78 for (i
= 0; i
< cif
->nargs
; i
++, tp
++, args
++)
84 *args
= (void*) ((char*)(raw
++) + 3);
89 *args
= (void*) ((char*)(raw
++) + 2);
101 case FFI_TYPE_POINTER
:
102 *args
= (void*) &(raw
++)->ptr
;
107 raw
+= ALIGN ((*tp
)->size
, SIZEOF_ARG
) / SIZEOF_ARG
;
111 #else /* WORDS_BIGENDIAN */
115 /* then assume little endian */
116 for (i
= 0; i
< cif
->nargs
; i
++, tp
++, args
++)
119 switch((*tp
)->type
) {
120 case FFI_TYPE_UINT64
:
121 case FFI_TYPE_SINT64
:
122 case FFI_TYPE_DOUBLE
:
127 *args
= (void*) raw
++;
129 #else /* SIZEOF_ARG != 8 */
131 raw
+= ALIGN ((*tp
)->size
, sizeof (void*)) / sizeof (void*);
132 #endif /* SIZEOF_ARG == 8 */
136 #error "pdp endian not supported"
139 #endif /* WORDS_BIGENDIAN */
143 ffi_java_ptrarray_to_raw (ffi_cif
*cif
, void **args
, ffi_raw
*raw
)
146 ffi_type
**tp
= cif
->arg_types
;
148 for (i
= 0; i
< cif
->nargs
; i
++, tp
++, args
++)
154 *(UINT32
*)(raw
++) = *(UINT8
*) (*args
);
156 (raw
++)->uint
= *(UINT8
*) (*args
);
162 *(SINT32
*)(raw
++) = *(SINT8
*) (*args
);
164 (raw
++)->sint
= *(SINT8
*) (*args
);
168 case FFI_TYPE_UINT16
:
170 *(UINT32
*)(raw
++) = *(UINT16
*) (*args
);
172 (raw
++)->uint
= *(UINT16
*) (*args
);
176 case FFI_TYPE_SINT16
:
178 *(SINT32
*)(raw
++) = *(SINT16
*) (*args
);
180 (raw
++)->sint
= *(SINT16
*) (*args
);
184 case FFI_TYPE_UINT32
:
186 *(UINT32
*)(raw
++) = *(UINT32
*) (*args
);
188 (raw
++)->uint
= *(UINT32
*) (*args
);
192 case FFI_TYPE_SINT32
:
194 *(SINT32
*)(raw
++) = *(SINT32
*) (*args
);
196 (raw
++)->sint
= *(SINT32
*) (*args
);
201 (raw
++)->flt
= *(FLOAT32
*) (*args
);
205 case FFI_TYPE_UINT64
:
206 case FFI_TYPE_SINT64
:
207 case FFI_TYPE_DOUBLE
:
208 raw
->uint
= *(UINT64
*) (*args
);
213 case FFI_TYPE_POINTER
:
214 (raw
++)->ptr
= **(void***) args
;
219 FFI_ASSERT(FALSE
); /* Should have covered all cases */
221 memcpy ((void*) raw
->data
, (void*)*args
, (*tp
)->size
);
222 raw
+= ALIGN ((*tp
)->size
, SIZEOF_ARG
) / SIZEOF_ARG
;
228 #if !FFI_NATIVE_RAW_API
231 ffi_java_rvalue_to_raw (ffi_cif
*cif
, void *rvalue
)
233 #if WORDS_BIGENDIAN && SIZEOF_ARG == 8
234 switch (cif
->rtype
->type
)
237 case FFI_TYPE_UINT16
:
238 case FFI_TYPE_UINT32
:
239 *(UINT64
*)rvalue
<<= 32;
243 case FFI_TYPE_SINT16
:
244 case FFI_TYPE_SINT32
:
246 *(SINT64
*)rvalue
<<= 32;
256 ffi_java_raw_to_rvalue (ffi_cif
*cif
, void *rvalue
)
258 #if WORDS_BIGENDIAN && SIZEOF_ARG == 8
259 switch (cif
->rtype
->type
)
262 case FFI_TYPE_UINT16
:
263 case FFI_TYPE_UINT32
:
264 *(UINT64
*)rvalue
>>= 32;
268 case FFI_TYPE_SINT16
:
269 case FFI_TYPE_SINT32
:
271 *(SINT64
*)rvalue
>>= 32;
280 /* This is a generic definition of ffi_raw_call, to be used if the
281 * native system does not provide a machine-specific implementation.
282 * Having this, allows code to be written for the raw API, without
283 * the need for system-specific code to handle input in that format;
284 * these following couple of functions will handle the translation forth
285 * and back automatically. */
287 void ffi_java_raw_call (/*@dependent@*/ ffi_cif
*cif
,
289 /*@out@*/ void *rvalue
,
290 /*@dependent@*/ ffi_raw
*raw
)
292 void **avalue
= (void**) alloca (cif
->nargs
* sizeof (void*));
293 ffi_java_raw_to_ptrarray (cif
, raw
, avalue
);
294 ffi_call (cif
, fn
, rvalue
, avalue
);
295 ffi_java_rvalue_to_raw (cif
, rvalue
);
298 #if FFI_CLOSURES /* base system provides closures */
301 ffi_java_translate_args (ffi_cif
*cif
, void *rvalue
,
302 void **avalue
, void *user_data
)
304 ffi_raw
*raw
= (ffi_raw
*)alloca (ffi_java_raw_size (cif
));
305 ffi_raw_closure
*cl
= (ffi_raw_closure
*)user_data
;
307 ffi_java_ptrarray_to_raw (cif
, avalue
, raw
);
308 (*cl
->fun
) (cif
, rvalue
, raw
, cl
->user_data
);
309 ffi_java_raw_to_rvalue (cif
, rvalue
);
312 /* Again, here is the generic version of ffi_prep_raw_closure, which
313 * will install an intermediate "hub" for translation of arguments from
314 * the pointer-array format, to the raw format */
317 ffi_prep_java_raw_closure (ffi_raw_closure
* cl
,
319 void (*fun
)(ffi_cif
*,void*,ffi_raw
*,void*),
324 status
= ffi_prep_closure ((ffi_closure
*) cl
,
326 &ffi_java_translate_args
,
328 if (status
== FFI_OK
)
331 cl
->user_data
= user_data
;
337 #endif /* FFI_CLOSURES */
338 #endif /* !FFI_NATIVE_RAW_API */
339 #endif /* !FFI_NO_RAW_API */