Python code coverage for Modules/_ctypes/libffi/src/alpha/ffi.c

#	count	content
1	n/a	/* -----------------------------------------------------------------------
2	n/a	ffi.c - Copyright (c) 2012 Anthony Green
3	n/a	Copyright (c) 1998, 2001, 2007, 2008 Red Hat, Inc.
4	n/a
5	n/a	Alpha Foreign Function Interface
6	n/a
7	n/a	Permission is hereby granted, free of charge, to any person obtaining
8	n/a	a copy of this software and associated documentation files (the
9	n/a	``Software''), to deal in the Software without restriction, including
10	n/a	without limitation the rights to use, copy, modify, merge, publish,
11	n/a	distribute, sublicense, and/or sell copies of the Software, and to
12	n/a	permit persons to whom the Software is furnished to do so, subject to
13	n/a	the following conditions:
14	n/a
15	n/a	The above copyright notice and this permission notice shall be included
16	n/a	in all copies or substantial portions of the Software.
17	n/a
18	n/a	THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
19	n/a	EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20	n/a	MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
21	n/a	NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
22	n/a	HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
23	n/a	WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24	n/a	OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
25	n/a	DEALINGS IN THE SOFTWARE.
26	n/a	----------------------------------------------------------------------- */
27	n/a
28	n/a	#include <ffi.h>
29	n/a	#include <ffi_common.h>
30	n/a	#include <stdlib.h>
31	n/a
32	n/a	/* Force FFI_TYPE_LONGDOUBLE to be different than FFI_TYPE_DOUBLE;
33	n/a	all further uses in this file will refer to the 128-bit type. */
34	n/a	#if defined(__LONG_DOUBLE_128__)
35	n/a	# if FFI_TYPE_LONGDOUBLE != 4
36	n/a	# error FFI_TYPE_LONGDOUBLE out of date
37	n/a	# endif
38	n/a	#else
39	n/a	# undef FFI_TYPE_LONGDOUBLE
40	n/a	# define FFI_TYPE_LONGDOUBLE 4
41	n/a	#endif
42	n/a
43	n/a	extern void ffi_call_osf(void , unsigned long, unsigned, void , void (*)(void))
44	n/a	FFI_HIDDEN;
45	n/a	extern void ffi_closure_osf(void) FFI_HIDDEN;
46	n/a
47	n/a
48	n/a	ffi_status
49	n/a	ffi_prep_cif_machdep(ffi_cif *cif)
50	n/a	{
51	n/a	/* Adjust cif->bytes to represent a minimum 6 words for the temporary
52	n/a	register argument loading area. */
53	n/a	if (cif->bytes < 6*FFI_SIZEOF_ARG)
54	n/a	cif->bytes = 6*FFI_SIZEOF_ARG;
55	n/a
56	n/a	/* Set the return type flag */
57	n/a	switch (cif->rtype->type)
58	n/a	{
59	n/a	case FFI_TYPE_STRUCT:
60	n/a	case FFI_TYPE_FLOAT:
61	n/a	case FFI_TYPE_DOUBLE:
62	n/a	cif->flags = cif->rtype->type;
63	n/a	break;
64	n/a
65	n/a	case FFI_TYPE_LONGDOUBLE:
66	n/a	/* 128-bit long double is returned in memory, like a struct. */
67	n/a	cif->flags = FFI_TYPE_STRUCT;
68	n/a	break;
69	n/a
70	n/a	default:
71	n/a	cif->flags = FFI_TYPE_INT;
72	n/a	break;
73	n/a	}
74	n/a
75	n/a	return FFI_OK;
76	n/a	}
77	n/a
78	n/a
79	n/a	void
80	n/a	ffi_call(ffi_cif cif, void (fn)(void), void rvalue, void *avalue)
81	n/a	{
82	n/a	unsigned long stack, argp;
83	n/a	long i, avn;
84	n/a	ffi_type **arg_types;
85	n/a
86	n/a	/* If the return value is a struct and we don't have a return
87	n/a	value address then we need to make one. */
88	n/a	if (rvalue == NULL && cif->flags == FFI_TYPE_STRUCT)
89	n/a	rvalue = alloca(cif->rtype->size);
90	n/a
91	n/a	/* Allocate the space for the arguments, plus 4 words of temp
92	n/a	space for ffi_call_osf. */
93	n/a	argp = stack = alloca(cif->bytes + 4*FFI_SIZEOF_ARG);
94	n/a
95	n/a	if (cif->flags == FFI_TYPE_STRUCT)
96	n/a	(void *) argp++ = rvalue;
97	n/a
98	n/a	i = 0;
99	n/a	avn = cif->nargs;
100	n/a	arg_types = cif->arg_types;
101	n/a
102	n/a	while (i < avn)
103	n/a	{
104	n/a	size_t size = (*arg_types)->size;
105	n/a
106	n/a	switch ((*arg_types)->type)
107	n/a	{
108	n/a	case FFI_TYPE_SINT8:
109	n/a	(SINT64 ) argp = (SINT8 )(* avalue);
110	n/a	break;
111	n/a
112	n/a	case FFI_TYPE_UINT8:
113	n/a	(SINT64 ) argp = (UINT8 )(* avalue);
114	n/a	break;
115	n/a
116	n/a	case FFI_TYPE_SINT16:
117	n/a	(SINT64 ) argp = (SINT16 )(* avalue);
118	n/a	break;
119	n/a
120	n/a	case FFI_TYPE_UINT16:
121	n/a	(SINT64 ) argp = (UINT16 )(* avalue);
122	n/a	break;
123	n/a
124	n/a	case FFI_TYPE_SINT32:
125	n/a	case FFI_TYPE_UINT32:
126	n/a	/* Note that unsigned 32-bit quantities are sign extended. */
127	n/a	(SINT64 ) argp = (SINT32 )(* avalue);
128	n/a	break;
129	n/a
130	n/a	case FFI_TYPE_SINT64:
131	n/a	case FFI_TYPE_UINT64:
132	n/a	case FFI_TYPE_POINTER:
133	n/a	(UINT64 ) argp = (UINT64 )(* avalue);
134	n/a	break;
135	n/a
136	n/a	case FFI_TYPE_FLOAT:
137	n/a	if (argp - stack < 6)
138	n/a	{
139	n/a	/* Note the conversion -- all the fp regs are loaded as
140	n/a	doubles. The in-register format is the same. */
141	n/a	(double ) argp = (float )(* avalue);
142	n/a	}
143	n/a	else
144	n/a	(float ) argp = (float )(* avalue);
145	n/a	break;
146	n/a
147	n/a	case FFI_TYPE_DOUBLE:
148	n/a	(double ) argp = (double )(* avalue);
149	n/a	break;
150	n/a
151	n/a	case FFI_TYPE_LONGDOUBLE:
152	n/a	/* 128-bit long double is passed by reference. */
153	n/a	(long double ) argp = (long double )(* avalue);
154	n/a	size = sizeof (long double *);
155	n/a	break;
156	n/a
157	n/a	case FFI_TYPE_STRUCT:
158	n/a	memcpy(argp, avalue, (arg_types)->size);
159	n/a	break;
160	n/a
161	n/a	default:
162	n/a	FFI_ASSERT(0);
163	n/a	}
164	n/a
165	n/a	argp += ALIGN(size, FFI_SIZEOF_ARG) / FFI_SIZEOF_ARG;
166	n/a	i++, arg_types++, avalue++;
167	n/a	}
168	n/a
169	n/a	ffi_call_osf(stack, cif->bytes, cif->flags, rvalue, fn);
170	n/a	}
171	n/a
172	n/a
173	n/a	ffi_status
174	n/a	ffi_prep_closure_loc (ffi_closure* closure,
175	n/a	ffi_cif* cif,
176	n/a	void (fun)(ffi_cif, void, void, void),
177	n/a	void *user_data,
178	n/a	void *codeloc)
179	n/a	{
180	n/a	unsigned int *tramp;
181	n/a
182	n/a	if (cif->abi != FFI_OSF)
183	n/a	return FFI_BAD_ABI;
184	n/a
185	n/a	tramp = (unsigned int *) &closure->tramp[0];
186	n/a	tramp[0] = 0x47fb0401; /* mov $27,$1 */
187	n/a	tramp[1] = 0xa77b0010; /* ldq $27,16($27) */
188	n/a	tramp[2] = 0x6bfb0000; /* jmp $31,($27),0 */
189	n/a	tramp[3] = 0x47ff041f; /* nop */
190	n/a	(void *) &tramp[4] = ffi_closure_osf;
191	n/a
192	n/a	closure->cif = cif;
193	n/a	closure->fun = fun;
194	n/a	closure->user_data = user_data;
195	n/a
196	n/a	/* Flush the Icache.
197	n/a
198	n/a	Tru64 UNIX as doesn't understand the imb mnemonic, so use call_pal
199	n/a	instead, since both Compaq as and gas can handle it.
200	n/a
201	n/a	0x86 is PAL_imb in Tru64 UNIX <alpha/pal.h>. */
202	n/a	asm volatile ("call_pal 0x86" : : : "memory");
203	n/a
204	n/a	return FFI_OK;
205	n/a	}
206	n/a
207	n/a
208	n/a	long FFI_HIDDEN
209	n/a	ffi_closure_osf_inner(ffi_closure closure, void rvalue, unsigned long *argp)
210	n/a	{
211	n/a	ffi_cif *cif;
212	n/a	void **avalue;
213	n/a	ffi_type **arg_types;
214	n/a	long i, avn, argn;
215	n/a
216	n/a	cif = closure->cif;
217	n/a	avalue = alloca(cif->nargs * sizeof(void *));
218	n/a
219	n/a	argn = 0;
220	n/a
221	n/a	/* Copy the caller's structure return address to that the closure
222	n/a	returns the data directly to the caller. */
223	n/a	if (cif->flags == FFI_TYPE_STRUCT)
224	n/a	{
225	n/a	rvalue = (void *) argp[0];
226	n/a	argn = 1;
227	n/a	}
228	n/a
229	n/a	i = 0;
230	n/a	avn = cif->nargs;
231	n/a	arg_types = cif->arg_types;
232	n/a
233	n/a	/* Grab the addresses of the arguments from the stack frame. */
234	n/a	while (i < avn)
235	n/a	{
236	n/a	size_t size = arg_types[i]->size;
237	n/a
238	n/a	switch (arg_types[i]->type)
239	n/a	{
240	n/a	case FFI_TYPE_SINT8:
241	n/a	case FFI_TYPE_UINT8:
242	n/a	case FFI_TYPE_SINT16:
243	n/a	case FFI_TYPE_UINT16:
244	n/a	case FFI_TYPE_SINT32:
245	n/a	case FFI_TYPE_UINT32:
246	n/a	case FFI_TYPE_SINT64:
247	n/a	case FFI_TYPE_UINT64:
248	n/a	case FFI_TYPE_POINTER:
249	n/a	case FFI_TYPE_STRUCT:
250	n/a	avalue[i] = &argp[argn];
251	n/a	break;
252	n/a
253	n/a	case FFI_TYPE_FLOAT:
254	n/a	if (argn < 6)
255	n/a	{
256	n/a	/* Floats coming from registers need conversion from double
257	n/a	back to float format. */
258	n/a	(float )&argp[argn - 6] = (double )&argp[argn - 6];
259	n/a	avalue[i] = &argp[argn - 6];
260	n/a	}
261	n/a	else
262	n/a	avalue[i] = &argp[argn];
263	n/a	break;
264	n/a
265	n/a	case FFI_TYPE_DOUBLE:
266	n/a	avalue[i] = &argp[argn - (argn < 6 ? 6 : 0)];
267	n/a	break;
268	n/a
269	n/a	case FFI_TYPE_LONGDOUBLE:
270	n/a	/* 128-bit long double is passed by reference. */
271	n/a	avalue[i] = (long double *) argp[argn];
272	n/a	size = sizeof (long double *);
273	n/a	break;
274	n/a
275	n/a	default:
276	n/a	abort ();
277	n/a	}
278	n/a
279	n/a	argn += ALIGN(size, FFI_SIZEOF_ARG) / FFI_SIZEOF_ARG;
280	n/a	i++;
281	n/a	}
282	n/a
283	n/a	/* Invoke the closure. */
284	n/a	closure->fun (cif, rvalue, avalue, closure->user_data);
285	n/a
286	n/a	/* Tell ffi_closure_osf how to perform return type promotions. */
287	n/a	return cif->rtype->type;
288	n/a	}