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 void **p_argv;
50 char *argp;
51 ffi_type **p_arg;
52
53 argp = stack;
54
55 if (ecif->cif->rtype->type == FFI_TYPE_STRUCT)
56 {
57 *(void **) argp = ecif->rvalue;
58 argp += 4;
59 }
60
61 p_argv = ecif->avalue;
62
63 for (i = ecif->cif->nargs, p_arg = ecif->cif->arg_types;
64 (i != 0); i--, p_arg++)
65 {
66 size_t z;
67 int alignment;
68
69 /* align alignment to 4 */
70 alignment = (((*p_arg)->alignment - 1) | 3) + 1;
71
72 /* Align if necessary. */
73 if ((alignment - 1) & (unsigned) argp)
74 argp = (char *) FFI_ALIGN (argp, alignment);
75
76 z = (*p_arg)->size;
77 if (z < sizeof (int))
78 {
79 z = sizeof (int);
80
81 switch ((*p_arg)->type)
82 {
83 case FFI_TYPE_SINT8:
84 *(signed int *) argp = (signed int) *(SINT8 *) (*p_argv);
85 break;
86
87 case FFI_TYPE_UINT8:
88 *(unsigned int *) argp = (unsigned int) *(UINT8 *) (*p_argv);
89 break;
90
91 case FFI_TYPE_SINT16:
92 *(signed int *) argp = (signed int) *(SINT16 *) (*p_argv);
93 break;
94
95 case FFI_TYPE_UINT16:
96 *(unsigned int *) argp = (unsigned int) *(UINT16 *) (*p_argv);
97 break;
98
99 case FFI_TYPE_STRUCT:
100 memcpy (argp, *p_argv, (*p_arg)->size);
101 break;
102
103 default:
104 FFI_ASSERT (0);
105 }
106 }
107 else if (z == sizeof (int))
108 {
109 *(unsigned int *) argp = (unsigned int) *(UINT32 *) (*p_argv);
110 }
111 else
112 {
113 if ((*p_arg)->type == FFI_TYPE_STRUCT)
114 {
115 memcpy (argp, *p_argv, z);
116 }
117 else
118 {
119 /* Double or long long 64bit. */
120 memcpy (argp, *p_argv, z);
121 }
122 }
123 p_argv++;
124 argp += z;
125 }
126
127 return;
128 }
129
130 /* Perform machine dependent cif processing. */
131 ffi_status
132 ffi_prep_cif_machdep (ffi_cif * cif)
133 {
134 /* Set the return type flag. */
135 switch (cif->rtype->type)
136 {
137 case FFI_TYPE_VOID:
138 cif->flags = (unsigned) cif->rtype->type;
139 break;
140
141 case FFI_TYPE_STRUCT:
142 cif->flags = (unsigned) cif->rtype->type;
143 break;
144
145 case FFI_TYPE_SINT64:
146 case FFI_TYPE_UINT64:
147 case FFI_TYPE_DOUBLE:
148 cif->flags = FFI_TYPE_DOUBLE;
149 break;
150
151 case FFI_TYPE_FLOAT:
152 default:
153 cif->flags = FFI_TYPE_INT;
154 break;
155 }
156
157 return FFI_OK;
158 }
159
160 extern void ffi_call_ARCompact (void (*)(char *, extended_cif *),
161 extended_cif *, unsigned, unsigned,
162 unsigned *, void (*fn) (void));
163
164 void
165 ffi_call (ffi_cif * cif, void (*fn) (void), void *rvalue, void **avalue)
166 {
167 extended_cif ecif;
168
169 ecif.cif = cif;
170 ecif.avalue = avalue;
171
172 /* If the return value is a struct and we don't have
173 a return value address then we need to make one. */
174 if ((rvalue == NULL) && (cif->rtype->type == FFI_TYPE_STRUCT))
175 {
176 ecif.rvalue = alloca (cif->rtype->size);
177 }
178 else
179 ecif.rvalue = rvalue;
180
181 switch (cif->abi)
182 {
183 case FFI_ARCOMPACT:
184 ffi_call_ARCompact (ffi_prep_args, &ecif, cif->bytes,
185 cif->flags, ecif.rvalue, fn);
186 break;
187
188 default:
189 FFI_ASSERT (0);
190 break;
191 }
192 }
193
194 int
195 ffi_closure_inner_ARCompact (ffi_closure * closure, void *rvalue,
196 ffi_arg * args)
197 {
198 void **arg_area, **p_argv;
199 ffi_cif *cif = closure->cif;
200 char *argp = (char *) args;
201 ffi_type **p_argt;
202 int i;
203
204 arg_area = (void **) alloca (cif->nargs * sizeof (void *));
205
206 /* handle hidden argument */
207 if (cif->flags == FFI_TYPE_STRUCT)
208 {
209 rvalue = *(void **) argp;
210 argp += 4;
211 }
212
213 p_argv = arg_area;
214
215 for (i = 0, p_argt = cif->arg_types; i < cif->nargs;
216 i++, p_argt++, p_argv++)
217 {
218 size_t z;
219 int alignment;
220
221 /* align alignment to 4 */
222 alignment = (((*p_argt)->alignment - 1) | 3) + 1;
223
224 /* Align if necessary. */
225 if ((alignment - 1) & (unsigned) argp)
226 argp = (char *) FFI_ALIGN (argp, alignment);
227
228 z = (*p_argt)->size;
229 *p_argv = (void *) argp;
230 argp += z;
231 }
232
233 (closure->fun) (cif, rvalue, arg_area, closure->user_data);
234
235 return cif->flags;
236 }
237
238 extern void ffi_closure_ARCompact (void);
239
240 ffi_status
241 ffi_prep_closure_loc (ffi_closure * closure, ffi_cif * cif,
242 void (*fun) (ffi_cif *, void *, void **, void *),
243 void *user_data, void *codeloc)
244 {
245 uint32_t *tramp = (uint32_t *) & (closure->tramp[0]);
246
247 switch (cif->abi)
248 {
249 case FFI_ARCOMPACT:
250 FFI_ASSERT (tramp == codeloc);
251 tramp[0] = CODE_ENDIAN (0x200a1fc0); /* mov r8, pcl */
252 tramp[1] = CODE_ENDIAN (0x20200f80); /* j [long imm] */
253 tramp[2] = CODE_ENDIAN (ffi_closure_ARCompact);
254 break;
255
256 default:
257 return FFI_BAD_ABI;
258 }
259
260 closure->cif = cif;
261 closure->fun = fun;
262 closure->user_data = user_data;
263 cacheflush (codeloc, FFI_TRAMPOLINE_SIZE, BCACHE);
264
265 return FFI_OK;
266 }