|
111
|
1 /* -----------------------------------------------------------------------
|
|
|
2 java_raw_api.c - Copyright (c) 1999, 2007, 2008 Red Hat, Inc.
|
|
|
3
|
|
|
4 Cloned from raw_api.c
|
|
|
5
|
|
|
6 Raw_api.c author: Kresten Krab Thorup <krab@gnu.org>
|
|
|
7 Java_raw_api.c author: Hans-J. Boehm <hboehm@hpl.hp.com>
|
|
|
8
|
|
|
9 $Id $
|
|
|
10
|
|
|
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:
|
|
|
18
|
|
|
19 The above copyright notice and this permission notice shall be included
|
|
|
20 in all copies or substantial portions of the Software.
|
|
|
21
|
|
|
22 THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
|
|
|
23 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
|
24 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
|
25 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|
|
26 HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|
|
27 WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
28 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
|
29 DEALINGS IN THE SOFTWARE.
|
|
|
30 ----------------------------------------------------------------------- */
|
|
|
31
|
|
|
32 /* This defines a Java- and 64-bit specific variant of the raw API. */
|
|
|
33 /* It assumes that "raw" argument blocks look like Java stacks on a */
|
|
|
34 /* 64-bit machine. Arguments that can be stored in a single stack */
|
|
|
35 /* stack slots (longs, doubles) occupy 128 bits, but only the first */
|
|
|
36 /* 64 bits are actually used. */
|
|
|
37
|
|
|
38 #include <ffi.h>
|
|
|
39 #include <ffi_common.h>
|
|
|
40 #include <stdlib.h>
|
|
|
41
|
|
|
42 #if !defined(NO_JAVA_RAW_API)
|
|
|
43
|
|
|
44 size_t
|
|
|
45 ffi_java_raw_size (ffi_cif *cif)
|
|
|
46 {
|
|
|
47 size_t result = 0;
|
|
|
48 int i;
|
|
|
49
|
|
|
50 ffi_type **at = cif->arg_types;
|
|
|
51
|
|
|
52 for (i = cif->nargs-1; i >= 0; i--, at++)
|
|
|
53 {
|
|
|
54 switch((*at) -> type) {
|
|
|
55 case FFI_TYPE_UINT64:
|
|
|
56 case FFI_TYPE_SINT64:
|
|
|
57 case FFI_TYPE_DOUBLE:
|
|
|
58 result += 2 * FFI_SIZEOF_JAVA_RAW;
|
|
|
59 break;
|
|
|
60 case FFI_TYPE_STRUCT:
|
|
|
61 /* No structure parameters in Java. */
|
|
|
62 abort();
|
|
|
63 case FFI_TYPE_COMPLEX:
|
|
|
64 /* Not supported yet. */
|
|
|
65 abort();
|
|
|
66 default:
|
|
|
67 result += FFI_SIZEOF_JAVA_RAW;
|
|
|
68 }
|
|
|
69 }
|
|
|
70
|
|
|
71 return result;
|
|
|
72 }
|
|
|
73
|
|
|
74
|
|
|
75 void
|
|
|
76 ffi_java_raw_to_ptrarray (ffi_cif *cif, ffi_java_raw *raw, void **args)
|
|
|
77 {
|
|
|
78 unsigned i;
|
|
|
79 ffi_type **tp = cif->arg_types;
|
|
|
80
|
|
|
81 #if WORDS_BIGENDIAN
|
|
|
82
|
|
|
83 for (i = 0; i < cif->nargs; i++, tp++, args++)
|
|
|
84 {
|
|
|
85 switch ((*tp)->type)
|
|
|
86 {
|
|
|
87 case FFI_TYPE_UINT8:
|
|
|
88 case FFI_TYPE_SINT8:
|
|
|
89 *args = (void*) ((char*)(raw++) + 3);
|
|
|
90 break;
|
|
|
91
|
|
|
92 case FFI_TYPE_UINT16:
|
|
|
93 case FFI_TYPE_SINT16:
|
|
|
94 *args = (void*) ((char*)(raw++) + 2);
|
|
|
95 break;
|
|
|
96
|
|
|
97 #if FFI_SIZEOF_JAVA_RAW == 8
|
|
|
98 case FFI_TYPE_UINT64:
|
|
|
99 case FFI_TYPE_SINT64:
|
|
|
100 case FFI_TYPE_DOUBLE:
|
|
|
101 *args = (void *)raw;
|
|
|
102 raw += 2;
|
|
|
103 break;
|
|
|
104 #endif
|
|
|
105
|
|
|
106 case FFI_TYPE_POINTER:
|
|
|
107 *args = (void*) &(raw++)->ptr;
|
|
|
108 break;
|
|
|
109
|
|
|
110 case FFI_TYPE_COMPLEX:
|
|
|
111 /* Not supported yet. */
|
|
|
112 abort();
|
|
|
113
|
|
|
114 default:
|
|
|
115 *args = raw;
|
|
|
116 raw +=
|
|
|
117 ALIGN ((*tp)->size, sizeof(ffi_java_raw)) / sizeof(ffi_java_raw);
|
|
|
118 }
|
|
|
119 }
|
|
|
120
|
|
|
121 #else /* WORDS_BIGENDIAN */
|
|
|
122
|
|
|
123 #if !PDP
|
|
|
124
|
|
|
125 /* then assume little endian */
|
|
|
126 for (i = 0; i < cif->nargs; i++, tp++, args++)
|
|
|
127 {
|
|
|
128 #if FFI_SIZEOF_JAVA_RAW == 8
|
|
|
129 switch((*tp)->type) {
|
|
|
130 case FFI_TYPE_UINT64:
|
|
|
131 case FFI_TYPE_SINT64:
|
|
|
132 case FFI_TYPE_DOUBLE:
|
|
|
133 *args = (void*) raw;
|
|
|
134 raw += 2;
|
|
|
135 break;
|
|
|
136 case FFI_TYPE_COMPLEX:
|
|
|
137 /* Not supported yet. */
|
|
|
138 abort();
|
|
|
139 default:
|
|
|
140 *args = (void*) raw++;
|
|
|
141 }
|
|
|
142 #else /* FFI_SIZEOF_JAVA_RAW != 8 */
|
|
|
143 *args = (void*) raw;
|
|
|
144 raw +=
|
|
|
145 ALIGN ((*tp)->size, sizeof(ffi_java_raw)) / sizeof(ffi_java_raw);
|
|
|
146 #endif /* FFI_SIZEOF_JAVA_RAW == 8 */
|
|
|
147 }
|
|
|
148
|
|
|
149 #else
|
|
|
150 #error "pdp endian not supported"
|
|
|
151 #endif /* ! PDP */
|
|
|
152
|
|
|
153 #endif /* WORDS_BIGENDIAN */
|
|
|
154 }
|
|
|
155
|
|
|
156 void
|
|
|
157 ffi_java_ptrarray_to_raw (ffi_cif *cif, void **args, ffi_java_raw *raw)
|
|
|
158 {
|
|
|
159 unsigned i;
|
|
|
160 ffi_type **tp = cif->arg_types;
|
|
|
161
|
|
|
162 for (i = 0; i < cif->nargs; i++, tp++, args++)
|
|
|
163 {
|
|
|
164 switch ((*tp)->type)
|
|
|
165 {
|
|
|
166 case FFI_TYPE_UINT8:
|
|
|
167 #if WORDS_BIGENDIAN
|
|
|
168 *(UINT32*)(raw++) = *(UINT8*) (*args);
|
|
|
169 #else
|
|
|
170 (raw++)->uint = *(UINT8*) (*args);
|
|
|
171 #endif
|
|
|
172 break;
|
|
|
173
|
|
|
174 case FFI_TYPE_SINT8:
|
|
|
175 #if WORDS_BIGENDIAN
|
|
|
176 *(SINT32*)(raw++) = *(SINT8*) (*args);
|
|
|
177 #else
|
|
|
178 (raw++)->sint = *(SINT8*) (*args);
|
|
|
179 #endif
|
|
|
180 break;
|
|
|
181
|
|
|
182 case FFI_TYPE_UINT16:
|
|
|
183 #if WORDS_BIGENDIAN
|
|
|
184 *(UINT32*)(raw++) = *(UINT16*) (*args);
|
|
|
185 #else
|
|
|
186 (raw++)->uint = *(UINT16*) (*args);
|
|
|
187 #endif
|
|
|
188 break;
|
|
|
189
|
|
|
190 case FFI_TYPE_SINT16:
|
|
|
191 #if WORDS_BIGENDIAN
|
|
|
192 *(SINT32*)(raw++) = *(SINT16*) (*args);
|
|
|
193 #else
|
|
|
194 (raw++)->sint = *(SINT16*) (*args);
|
|
|
195 #endif
|
|
|
196 break;
|
|
|
197
|
|
|
198 case FFI_TYPE_UINT32:
|
|
|
199 #if WORDS_BIGENDIAN
|
|
|
200 *(UINT32*)(raw++) = *(UINT32*) (*args);
|
|
|
201 #else
|
|
|
202 (raw++)->uint = *(UINT32*) (*args);
|
|
|
203 #endif
|
|
|
204 break;
|
|
|
205
|
|
|
206 case FFI_TYPE_SINT32:
|
|
|
207 #if WORDS_BIGENDIAN
|
|
|
208 *(SINT32*)(raw++) = *(SINT32*) (*args);
|
|
|
209 #else
|
|
|
210 (raw++)->sint = *(SINT32*) (*args);
|
|
|
211 #endif
|
|
|
212 break;
|
|
|
213
|
|
|
214 case FFI_TYPE_FLOAT:
|
|
|
215 (raw++)->flt = *(FLOAT32*) (*args);
|
|
|
216 break;
|
|
|
217
|
|
|
218 #if FFI_SIZEOF_JAVA_RAW == 8
|
|
|
219 case FFI_TYPE_UINT64:
|
|
|
220 case FFI_TYPE_SINT64:
|
|
|
221 case FFI_TYPE_DOUBLE:
|
|
|
222 raw->uint = *(UINT64*) (*args);
|
|
|
223 raw += 2;
|
|
|
224 break;
|
|
|
225 #endif
|
|
|
226
|
|
|
227 case FFI_TYPE_POINTER:
|
|
|
228 (raw++)->ptr = **(void***) args;
|
|
|
229 break;
|
|
|
230
|
|
|
231 default:
|
|
|
232 #if FFI_SIZEOF_JAVA_RAW == 8
|
|
|
233 FFI_ASSERT(0); /* Should have covered all cases */
|
|
|
234 #else
|
|
|
235 memcpy ((void*) raw->data, (void*)*args, (*tp)->size);
|
|
|
236 raw +=
|
|
|
237 ALIGN ((*tp)->size, sizeof(ffi_java_raw)) / sizeof(ffi_java_raw);
|
|
|
238 #endif
|
|
|
239 }
|
|
|
240 }
|
|
|
241 }
|
|
|
242
|
|
|
243 #if !FFI_NATIVE_RAW_API
|
|
|
244
|
|
|
245 static void
|
|
|
246 ffi_java_rvalue_to_raw (ffi_cif *cif, void *rvalue)
|
|
|
247 {
|
|
|
248 #if WORDS_BIGENDIAN && FFI_SIZEOF_ARG == 8
|
|
|
249 switch (cif->rtype->type)
|
|
|
250 {
|
|
|
251 case FFI_TYPE_UINT8:
|
|
|
252 case FFI_TYPE_UINT16:
|
|
|
253 case FFI_TYPE_UINT32:
|
|
|
254 *(UINT64 *)rvalue <<= 32;
|
|
|
255 break;
|
|
|
256
|
|
|
257 case FFI_TYPE_SINT8:
|
|
|
258 case FFI_TYPE_SINT16:
|
|
|
259 case FFI_TYPE_SINT32:
|
|
|
260 case FFI_TYPE_INT:
|
|
|
261 #if FFI_SIZEOF_JAVA_RAW == 4
|
|
|
262 case FFI_TYPE_POINTER:
|
|
|
263 #endif
|
|
|
264 *(SINT64 *)rvalue <<= 32;
|
|
|
265 break;
|
|
|
266
|
|
|
267 case FFI_TYPE_COMPLEX:
|
|
|
268 /* Not supported yet. */
|
|
|
269 abort();
|
|
|
270
|
|
|
271 default:
|
|
|
272 break;
|
|
|
273 }
|
|
|
274 #endif
|
|
|
275 }
|
|
|
276
|
|
|
277 static void
|
|
|
278 ffi_java_raw_to_rvalue (ffi_cif *cif, void *rvalue)
|
|
|
279 {
|
|
|
280 #if WORDS_BIGENDIAN && FFI_SIZEOF_ARG == 8
|
|
|
281 switch (cif->rtype->type)
|
|
|
282 {
|
|
|
283 case FFI_TYPE_UINT8:
|
|
|
284 case FFI_TYPE_UINT16:
|
|
|
285 case FFI_TYPE_UINT32:
|
|
|
286 *(UINT64 *)rvalue >>= 32;
|
|
|
287 break;
|
|
|
288
|
|
|
289 case FFI_TYPE_SINT8:
|
|
|
290 case FFI_TYPE_SINT16:
|
|
|
291 case FFI_TYPE_SINT32:
|
|
|
292 case FFI_TYPE_INT:
|
|
|
293 *(SINT64 *)rvalue >>= 32;
|
|
|
294 break;
|
|
|
295
|
|
|
296 case FFI_TYPE_COMPLEX:
|
|
|
297 /* Not supported yet. */
|
|
|
298 abort();
|
|
|
299
|
|
|
300 default:
|
|
|
301 break;
|
|
|
302 }
|
|
|
303 #endif
|
|
|
304 }
|
|
|
305
|
|
|
306 /* This is a generic definition of ffi_raw_call, to be used if the
|
|
|
307 * native system does not provide a machine-specific implementation.
|
|
|
308 * Having this, allows code to be written for the raw API, without
|
|
|
309 * the need for system-specific code to handle input in that format;
|
|
|
310 * these following couple of functions will handle the translation forth
|
|
|
311 * and back automatically. */
|
|
|
312
|
|
|
313 void ffi_java_raw_call (ffi_cif *cif, void (*fn)(void), void *rvalue,
|
|
|
314 ffi_java_raw *raw)
|
|
|
315 {
|
|
|
316 void **avalue = (void**) alloca (cif->nargs * sizeof (void*));
|
|
|
317 ffi_java_raw_to_ptrarray (cif, raw, avalue);
|
|
|
318 ffi_call (cif, fn, rvalue, avalue);
|
|
|
319 ffi_java_rvalue_to_raw (cif, rvalue);
|
|
|
320 }
|
|
|
321
|
|
|
322 #if FFI_CLOSURES /* base system provides closures */
|
|
|
323
|
|
|
324 static void
|
|
|
325 ffi_java_translate_args (ffi_cif *cif, void *rvalue,
|
|
|
326 void **avalue, void *user_data)
|
|
|
327 {
|
|
|
328 ffi_java_raw *raw = (ffi_java_raw*)alloca (ffi_java_raw_size (cif));
|
|
|
329 ffi_raw_closure *cl = (ffi_raw_closure*)user_data;
|
|
|
330
|
|
|
331 ffi_java_ptrarray_to_raw (cif, avalue, raw);
|
|
|
332 (*cl->fun) (cif, rvalue, (ffi_raw*)raw, cl->user_data);
|
|
|
333 ffi_java_raw_to_rvalue (cif, rvalue);
|
|
|
334 }
|
|
|
335
|
|
|
336 ffi_status
|
|
|
337 ffi_prep_java_raw_closure_loc (ffi_java_raw_closure* cl,
|
|
|
338 ffi_cif *cif,
|
|
|
339 void (*fun)(ffi_cif*,void*,ffi_java_raw*,void*),
|
|
|
340 void *user_data,
|
|
|
341 void *codeloc)
|
|
|
342 {
|
|
|
343 ffi_status status;
|
|
|
344
|
|
|
345 status = ffi_prep_closure_loc ((ffi_closure*) cl,
|
|
|
346 cif,
|
|
|
347 &ffi_java_translate_args,
|
|
|
348 codeloc,
|
|
|
349 codeloc);
|
|
|
350 if (status == FFI_OK)
|
|
|
351 {
|
|
|
352 cl->fun = fun;
|
|
|
353 cl->user_data = user_data;
|
|
|
354 }
|
|
|
355
|
|
|
356 return status;
|
|
|
357 }
|
|
|
358
|
|
|
359 /* Again, here is the generic version of ffi_prep_raw_closure, which
|
|
|
360 * will install an intermediate "hub" for translation of arguments from
|
|
|
361 * the pointer-array format, to the raw format */
|
|
|
362
|
|
|
363 ffi_status
|
|
|
364 ffi_prep_java_raw_closure (ffi_java_raw_closure* cl,
|
|
|
365 ffi_cif *cif,
|
|
|
366 void (*fun)(ffi_cif*,void*,ffi_java_raw*,void*),
|
|
|
367 void *user_data)
|
|
|
368 {
|
|
|
369 return ffi_prep_java_raw_closure_loc (cl, cif, fun, user_data, cl);
|
|
|
370 }
|
|
|
371
|
|
|
372 #endif /* FFI_CLOSURES */
|
|
|
373 #endif /* !FFI_NATIVE_RAW_API */
|
|
|
374 #endif /* !NO_JAVA_RAW_API */
|
