ยปCore Development>Code coverage>Modules/_ctypes/libffi/src/java_raw_api.c

Python code coverage for Modules/_ctypes/libffi/src/java_raw_api.c

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