|
111
|
1 /* -----------------------------------------------------------------------
|
|
|
2 ffi.c - Copyright (c) 2013 Synopsys, Inc. (www.synopsys.com)
|
|
|
3
|
|
|
4 ARC Foreign Function Interface
|
|
|
5
|
|
|
6 Permission is hereby granted, free of charge, to any person obtaining
|
|
|
7 a copy of this software and associated documentation files (the
|
|
|
8 ``Software''), to deal in the Software without restriction, including
|
|
|
9 without limitation the rights to use, copy, modify, merge, publish,
|
|
|
10 distribute, sublicense, and/or sell copies of the Software, and to
|
|
|
11 permit persons to whom the Software is furnished to do so, subject to
|
|
|
12 the following conditions:
|
|
|
13
|
|
|
14 The above copyright notice and this permission notice shall be included
|
|
|
15 in all copies or substantial portions of the Software.
|
|
|
16
|
|
|
17 THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
|
18 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
|
19 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
|
|
20 IN NO EVENT SHALL RENESAS TECHNOLOGY BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
|
|
21 OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
|
|
22 ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|
|
23 OTHER DEALINGS IN THE SOFTWARE.
|
|
|
24 ----------------------------------------------------------------------- */
|
|
|
25
|
|
|
26 #include <ffi.h>
|
|
|
27 #include <ffi_common.h>
|
|
|
28
|
|
|
29 #include <stdlib.h>
|
|
|
30 #include <stdint.h>
|
|
|
31
|
|
|
32 #include <sys/cachectl.h>
|
|
|
33
|
|
|
34 /* for little endian ARC, the code is in fact stored as mixed endian for
|
|
|
35 performance reasons */
|
|
|
36 #if __BIG_ENDIAN__
|
|
|
37 #define CODE_ENDIAN(x) (x)
|
|
|
38 #else
|
|
|
39 #define CODE_ENDIAN(x) ( (((uint32_t) (x)) << 16) | (((uint32_t) (x)) >> 16))
|
|
|
40 #endif
|
|
|
41
|
|
|
42 /* ffi_prep_args is called by the assembly routine once stack
|
|
|
43 space has been allocated for the function's arguments. */
|
|
|
44
|
|
|
45 void
|
|
|
46 ffi_prep_args (char *stack, extended_cif * ecif)
|
|
|
47 {
|
|
|
48 unsigned int i;
|
|
|
49 int tmp;
|
|
|
50 void **p_argv;
|
|
|
51 char *argp;
|
|
|
52 ffi_type **p_arg;
|
|
|
53
|
|
|
54 tmp = 0;
|
|
|
55 argp = stack;
|
|
|
56
|
|
|
57 if (ecif->cif->rtype->type == FFI_TYPE_STRUCT)
|
|
|
58 {
|
|
|
59 *(void **) argp = ecif->rvalue;
|
|
|
60 argp += 4;
|
|
|
61 }
|
|
|
62
|
|
|
63 p_argv = ecif->avalue;
|
|
|
64
|
|
|
65 for (i = ecif->cif->nargs, p_arg = ecif->cif->arg_types;
|
|
|
66 (i != 0); i--, p_arg++)
|
|
|
67 {
|
|
|
68 size_t z;
|
|
|
69 int alignment;
|
|
|
70
|
|
|
71 /* align alignment to 4 */
|
|
|
72 alignment = (((*p_arg)->alignment - 1) | 3) + 1;
|
|
|
73
|
|
|
74 /* Align if necessary. */
|
|
|
75 if ((alignment - 1) & (unsigned) argp)
|
|
|
76 argp = (char *) ALIGN (argp, alignment);
|
|
|
77
|
|
|
78 z = (*p_arg)->size;
|
|
|
79 if (z < sizeof (int))
|
|
|
80 {
|
|
|
81 z = sizeof (int);
|
|
|
82
|
|
|
83 switch ((*p_arg)->type)
|
|
|
84 {
|
|
|
85 case FFI_TYPE_SINT8:
|
|
|
86 *(signed int *) argp = (signed int) *(SINT8 *) (*p_argv);
|
|
|
87 break;
|
|
|
88
|
|
|
89 case FFI_TYPE_UINT8:
|
|
|
90 *(unsigned int *) argp = (unsigned int) *(UINT8 *) (*p_argv);
|
|
|
91 break;
|
|
|
92
|
|
|
93 case FFI_TYPE_SINT16:
|
|
|
94 *(signed int *) argp = (signed int) *(SINT16 *) (*p_argv);
|
|
|
95 break;
|
|
|
96
|
|
|
97 case FFI_TYPE_UINT16:
|
|
|
98 *(unsigned int *) argp = (unsigned int) *(UINT16 *) (*p_argv);
|
|
|
99 break;
|
|
|
100
|
|
|
101 case FFI_TYPE_STRUCT:
|
|
|
102 memcpy (argp, *p_argv, (*p_arg)->size);
|
|
|
103 break;
|
|
|
104
|
|
|
105 default:
|
|
|
106 FFI_ASSERT (0);
|
|
|
107 }
|
|
|
108 }
|
|
|
109 else if (z == sizeof (int))
|
|
|
110 {
|
|
|
111 *(unsigned int *) argp = (unsigned int) *(UINT32 *) (*p_argv);
|
|
|
112 }
|
|
|
113 else
|
|
|
114 {
|
|
|
115 if ((*p_arg)->type == FFI_TYPE_STRUCT)
|
|
|
116 {
|
|
|
117 memcpy (argp, *p_argv, z);
|
|
|
118 }
|
|
|
119 else
|
|
|
120 {
|
|
|
121 /* Double or long long 64bit. */
|
|
|
122 memcpy (argp, *p_argv, z);
|
|
|
123 }
|
|
|
124 }
|
|
|
125 p_argv++;
|
|
|
126 argp += z;
|
|
|
127 }
|
|
|
128
|
|
|
129 return;
|
|
|
130 }
|
|
|
131
|
|
|
132 /* Perform machine dependent cif processing. */
|
|
|
133 ffi_status
|
|
|
134 ffi_prep_cif_machdep (ffi_cif * cif)
|
|
|
135 {
|
|
|
136 /* Set the return type flag. */
|
|
|
137 switch (cif->rtype->type)
|
|
|
138 {
|
|
|
139 case FFI_TYPE_VOID:
|
|
|
140 cif->flags = (unsigned) cif->rtype->type;
|
|
|
141 break;
|
|
|
142
|
|
|
143 case FFI_TYPE_STRUCT:
|
|
|
144 cif->flags = (unsigned) cif->rtype->type;
|
|
|
145 break;
|
|
|
146
|
|
|
147 case FFI_TYPE_SINT64:
|
|
|
148 case FFI_TYPE_UINT64:
|
|
|
149 case FFI_TYPE_DOUBLE:
|
|
|
150 cif->flags = FFI_TYPE_DOUBLE;
|
|
|
151 break;
|
|
|
152
|
|
|
153 case FFI_TYPE_FLOAT:
|
|
|
154 default:
|
|
|
155 cif->flags = FFI_TYPE_INT;
|
|
|
156 break;
|
|
|
157 }
|
|
|
158
|
|
|
159 return FFI_OK;
|
|
|
160 }
|
|
|
161
|
|
|
162 extern void ffi_call_ARCompact (void (*)(char *, extended_cif *),
|
|
|
163 extended_cif *, unsigned, unsigned,
|
|
|
164 unsigned *, void (*fn) (void));
|
|
|
165
|
|
|
166 void
|
|
|
167 ffi_call (ffi_cif * cif, void (*fn) (void), void *rvalue, void **avalue)
|
|
|
168 {
|
|
|
169 extended_cif ecif;
|
|
|
170
|
|
|
171 ecif.cif = cif;
|
|
|
172 ecif.avalue = avalue;
|
|
|
173
|
|
|
174 /* If the return value is a struct and we don't have
|
|
|
175 a return value address then we need to make one. */
|
|
|
176 if ((rvalue == NULL) && (cif->rtype->type == FFI_TYPE_STRUCT))
|
|
|
177 {
|
|
|
178 ecif.rvalue = alloca (cif->rtype->size);
|
|
|
179 }
|
|
|
180 else
|
|
|
181 ecif.rvalue = rvalue;
|
|
|
182
|
|
|
183 switch (cif->abi)
|
|
|
184 {
|
|
|
185 case FFI_ARCOMPACT:
|
|
|
186 ffi_call_ARCompact (ffi_prep_args, &ecif, cif->bytes,
|
|
|
187 cif->flags, ecif.rvalue, fn);
|
|
|
188 break;
|
|
|
189
|
|
|
190 default:
|
|
|
191 FFI_ASSERT (0);
|
|
|
192 break;
|
|
|
193 }
|
|
|
194 }
|
|
|
195
|
|
|
196 int
|
|
|
197 ffi_closure_inner_ARCompact (ffi_closure * closure, void *rvalue,
|
|
|
198 ffi_arg * args)
|
|
|
199 {
|
|
|
200 void **arg_area, **p_argv;
|
|
|
201 ffi_cif *cif = closure->cif;
|
|
|
202 char *argp = (char *) args;
|
|
|
203 ffi_type **p_argt;
|
|
|
204 int i;
|
|
|
205
|
|
|
206 arg_area = (void **) alloca (cif->nargs * sizeof (void *));
|
|
|
207
|
|
|
208 /* handle hidden argument */
|
|
|
209 if (cif->flags == FFI_TYPE_STRUCT)
|
|
|
210 {
|
|
|
211 rvalue = *(void **) argp;
|
|
|
212 argp += 4;
|
|
|
213 }
|
|
|
214
|
|
|
215 p_argv = arg_area;
|
|
|
216
|
|
|
217 for (i = 0, p_argt = cif->arg_types; i < cif->nargs;
|
|
|
218 i++, p_argt++, p_argv++)
|
|
|
219 {
|
|
|
220 size_t z;
|
|
|
221 int alignment;
|
|
|
222
|
|
|
223 /* align alignment to 4 */
|
|
|
224 alignment = (((*p_argt)->alignment - 1) | 3) + 1;
|
|
|
225
|
|
|
226 /* Align if necessary. */
|
|
|
227 if ((alignment - 1) & (unsigned) argp)
|
|
|
228 argp = (char *) ALIGN (argp, alignment);
|
|
|
229
|
|
|
230 z = (*p_argt)->size;
|
|
|
231 *p_argv = (void *) argp;
|
|
|
232 argp += z;
|
|
|
233 }
|
|
|
234
|
|
|
235 (closure->fun) (cif, rvalue, arg_area, closure->user_data);
|
|
|
236
|
|
|
237 return cif->flags;
|
|
|
238 }
|
|
|
239
|
|
|
240 extern void ffi_closure_ARCompact (void);
|
|
|
241
|
|
|
242 ffi_status
|
|
|
243 ffi_prep_closure_loc (ffi_closure * closure, ffi_cif * cif,
|
|
|
244 void (*fun) (ffi_cif *, void *, void **, void *),
|
|
|
245 void *user_data, void *codeloc)
|
|
|
246 {
|
|
|
247 uint32_t *tramp = (uint32_t *) & (closure->tramp[0]);
|
|
|
248
|
|
|
249 switch (cif->abi)
|
|
|
250 {
|
|
|
251 case FFI_ARCOMPACT:
|
|
|
252 FFI_ASSERT (tramp == codeloc);
|
|
|
253 tramp[0] = CODE_ENDIAN (0x200a1fc0); /* mov r8, pcl */
|
|
|
254 tramp[1] = CODE_ENDIAN (0x20200f80); /* j [long imm] */
|
|
|
255 tramp[2] = CODE_ENDIAN (ffi_closure_ARCompact);
|
|
|
256 break;
|
|
|
257
|
|
|
258 default:
|
|
|
259 return FFI_BAD_ABI;
|
|
|
260 }
|
|
|
261
|
|
|
262 closure->cif = cif;
|
|
|
263 closure->fun = fun;
|
|
|
264 closure->user_data = user_data;
|
|
|
265 cacheflush (codeloc, FFI_TRAMPOLINE_SIZE, BCACHE);
|
|
|
266
|
|
|
267 return FFI_OK;
|
|
|
268 }
|
