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

#	count	content
1	n/a	/* -----------------------------------------------------------------------
2	n/a	ffi.c - Copyright (c) 2004 Renesas Technology
3	n/a	Copyright (c) 2008 Red Hat, Inc.
4	n/a
5	n/a	M32R 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, EXPRESS
19	n/a	OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20	n/a	MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
21	n/a	IN NO EVENT SHALL RENESAS TECHNOLOGY BE LIABLE FOR ANY CLAIM, DAMAGES OR
22	n/a	OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
23	n/a	ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
24	n/a	OTHER DEALINGS IN THE SOFTWARE.
25	n/a	----------------------------------------------------------------------- */
26	n/a
27	n/a	#include <ffi.h>
28	n/a	#include <ffi_common.h>
29	n/a
30	n/a	#include <stdlib.h>
31	n/a
32	n/a	/* ffi_prep_args is called by the assembly routine once stack
33	n/a	space has been allocated for the function's arguments. */
34	n/a
35	n/a	void ffi_prep_args(char stack, extended_cif ecif)
36	n/a	{
37	n/a	unsigned int i;
38	n/a	int tmp;
39	n/a	unsigned int avn;
40	n/a	void **p_argv;
41	n/a	char *argp;
42	n/a	ffi_type **p_arg;
43	n/a
44	n/a	tmp = 0;
45	n/a	argp = stack;
46	n/a
47	n/a	if (ecif->cif->rtype->type == FFI_TYPE_STRUCT && ecif->cif->rtype->size > 8)
48	n/a	{
49	n/a	(void *) argp = ecif->rvalue;
50	n/a	argp += 4;
51	n/a	}
52	n/a
53	n/a	avn = ecif->cif->nargs;
54	n/a	p_argv = ecif->avalue;
55	n/a
56	n/a	for (i = ecif->cif->nargs, p_arg = ecif->cif->arg_types;
57	n/a	(i != 0) && (avn != 0);
58	n/a	i--, p_arg++)
59	n/a	{
60	n/a	size_t z;
61	n/a
62	n/a	/* Align if necessary. */
63	n/a	if (((*p_arg)->alignment - 1) & (unsigned) argp)
64	n/a	argp = (char ) ALIGN (argp, (p_arg)->alignment);
65	n/a
66	n/a	if (avn != 0)
67	n/a	{
68	n/a	avn--;
69	n/a	z = (*p_arg)->size;
70	n/a	if (z < sizeof (int))
71	n/a	{
72	n/a	z = sizeof (int);
73	n/a
74	n/a	switch ((*p_arg)->type)
75	n/a	{
76	n/a	case FFI_TYPE_SINT8:
77	n/a	(signed int ) argp = (signed int)(SINT8 )(* p_argv);
78	n/a	break;
79	n/a
80	n/a	case FFI_TYPE_UINT8:
81	n/a	(unsigned int ) argp = (unsigned int)(UINT8 )(* p_argv);
82	n/a	break;
83	n/a
84	n/a	case FFI_TYPE_SINT16:
85	n/a	(signed int ) argp = (signed int)(SINT16 )(* p_argv);
86	n/a	break;
87	n/a
88	n/a	case FFI_TYPE_UINT16:
89	n/a	(unsigned int ) argp = (unsigned int)(UINT16 )(* p_argv);
90	n/a	break;
91	n/a
92	n/a	case FFI_TYPE_STRUCT:
93	n/a	z = (*p_arg)->size;
94	n/a	if ((*p_arg)->alignment != 1)
95	n/a	memcpy (argp, *p_argv, z);
96	n/a	else
97	n/a	memcpy (argp + 4 - z, *p_argv, z);
98	n/a	z = sizeof (int);
99	n/a	break;
100	n/a
101	n/a	default:
102	n/a	FFI_ASSERT(0);
103	n/a	}
104	n/a	}
105	n/a	else if (z == sizeof (int))
106	n/a	{
107	n/a	(unsigned int ) argp = (unsigned int)(UINT32 )(* p_argv);
108	n/a	}
109	n/a	else
110	n/a	{
111	n/a	if ((*p_arg)->type == FFI_TYPE_STRUCT)
112	n/a	{
113	n/a	if (z > 8)
114	n/a	{
115	n/a	(unsigned int ) argp = (unsigned int)(void )( p_argv);
116	n/a	z = sizeof(void *);
117	n/a	}
118	n/a	else
119	n/a	{
120	n/a	memcpy(argp, *p_argv, z);
121	n/a	z = 8;
122	n/a	}
123	n/a	}
124	n/a	else
125	n/a	{
126	n/a	/* Double or long long 64bit. */
127	n/a	memcpy (argp, *p_argv, z);
128	n/a	}
129	n/a	}
130	n/a	p_argv++;
131	n/a	argp += z;
132	n/a	}
133	n/a	}
134	n/a
135	n/a	return;
136	n/a	}
137	n/a
138	n/a	/* Perform machine dependent cif processing. */
139	n/a	ffi_status
140	n/a	ffi_prep_cif_machdep(ffi_cif *cif)
141	n/a	{
142	n/a	/* Set the return type flag. */
143	n/a	switch (cif->rtype->type)
144	n/a	{
145	n/a	case FFI_TYPE_VOID:
146	n/a	cif->flags = (unsigned) cif->rtype->type;
147	n/a	break;
148	n/a
149	n/a	case FFI_TYPE_STRUCT:
150	n/a	if (cif->rtype->size <= 4)
151	n/a	cif->flags = FFI_TYPE_INT;
152	n/a
153	n/a	else if (cif->rtype->size <= 8)
154	n/a	cif->flags = FFI_TYPE_DOUBLE;
155	n/a
156	n/a	else
157	n/a	cif->flags = (unsigned) cif->rtype->type;
158	n/a	break;
159	n/a
160	n/a	case FFI_TYPE_SINT64:
161	n/a	case FFI_TYPE_UINT64:
162	n/a	case FFI_TYPE_DOUBLE:
163	n/a	cif->flags = FFI_TYPE_DOUBLE;
164	n/a	break;
165	n/a
166	n/a	case FFI_TYPE_FLOAT:
167	n/a	default:
168	n/a	cif->flags = FFI_TYPE_INT;
169	n/a	break;
170	n/a	}
171	n/a
172	n/a	return FFI_OK;
173	n/a	}
174	n/a
175	n/a	extern void ffi_call_SYSV(void ()(char , extended_cif ), extended_cif ,
176	n/a	unsigned, unsigned, unsigned , void (fn)(void));
177	n/a
178	n/a	void ffi_call(ffi_cif cif, void (fn)(void), void rvalue, void *avalue)
179	n/a	{
180	n/a	extended_cif ecif;
181	n/a
182	n/a	ecif.cif = cif;
183	n/a	ecif.avalue = avalue;
184	n/a
185	n/a	/* If the return value is a struct and we don't have
186	n/a	a return value address then we need to make one. */
187	n/a	if ((rvalue == NULL) &&
188	n/a	(cif->rtype->type == FFI_TYPE_STRUCT))
189	n/a	{
190	n/a	ecif.rvalue = alloca (cif->rtype->size);
191	n/a	}
192	n/a	else
193	n/a	ecif.rvalue = rvalue;
194	n/a
195	n/a	switch (cif->abi)
196	n/a	{
197	n/a	case FFI_SYSV:
198	n/a	ffi_call_SYSV(ffi_prep_args, &ecif, cif->bytes,
199	n/a	cif->flags, ecif.rvalue, fn);
200	n/a	if (cif->rtype->type == FFI_TYPE_STRUCT)
201	n/a	{
202	n/a	int size = cif->rtype->size;
203	n/a	int align = cif->rtype->alignment;
204	n/a
205	n/a	if (size < 4)
206	n/a	{
207	n/a	if (align == 1)
208	n/a	(unsigned long )(ecif.rvalue) <<= (4 - size) * 8;
209	n/a	}
210	n/a	else if (4 < size && size < 8)
211	n/a	{
212	n/a	if (align == 1)
213	n/a	{
214	n/a	memcpy (ecif.rvalue, ecif.rvalue + 8-size, size);
215	n/a	}
216	n/a	else if (align == 2)
217	n/a	{
218	n/a	if (size & 1)
219	n/a	size += 1;
220	n/a
221	n/a	if (size != 8)
222	n/a	memcpy (ecif.rvalue, ecif.rvalue + 8-size, size);
223	n/a	}
224	n/a	}
225	n/a	}
226	n/a	break;
227	n/a
228	n/a	default:
229	n/a	FFI_ASSERT(0);
230	n/a	break;
231	n/a	}
232	n/a	}