1 /*
2 * Copyright (c) 2013 Miodrag Vallat. <miod@openbsd.org>
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining
5 * a copy of this software and associated documentation files (the
6 * ``Software''), to deal in the Software without restriction, including
7 * without limitation the rights to use, copy, modify, merge, publish,
8 * distribute, sublicense, and/or sell copies of the Software, and to
9 * permit persons to whom the Software is furnished to do so, subject to
10 * the following conditions:
11 *
12 * The above copyright notice and this permission notice shall be included
13 * in all copies or substantial portions of the Software.
14 *
15 * THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
16 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
17 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
18 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
19 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
20 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
21 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
22 */
23
24 /*
25 * vax Foreign Function Interface
26 *
27 * This file attempts to provide all the FFI entry points which can reliably
28 * be implemented in C.
29 */
30
31 #include <ffi.h>
32 #include <ffi_common.h>
33
34 #include <stdlib.h>
35 #include <unistd.h>
36
37 #define CIF_FLAGS_CHAR 1 /* for struct only */
38 #define CIF_FLAGS_SHORT 2 /* for struct only */
39 #define CIF_FLAGS_INT 4
40 #define CIF_FLAGS_DINT 8
41
42 /*
43 * Foreign Function Interface API
44 */
45
46 void ffi_call_elfbsd (extended_cif *, unsigned, unsigned, void *,
47 void (*) ());
48 void *ffi_prep_args (extended_cif *ecif, void *stack);
49
50 void *
51 ffi_prep_args (extended_cif *ecif, void *stack)
52 {
53 unsigned int i;
54 void **p_argv;
55 char *argp;
56 ffi_type **p_arg;
57 void *struct_value_ptr;
58
59 argp = stack;
60
61 if (ecif->cif->rtype->type == FFI_TYPE_STRUCT
62 && !ecif->cif->flags)
63 struct_value_ptr = ecif->rvalue;
64 else
65 struct_value_ptr = NULL;
66
67 p_argv = ecif->avalue;
68
69 for (i = ecif->cif->nargs, p_arg = ecif->cif->arg_types;
70 i != 0;
71 i--, p_arg++)
72 {
73 size_t z;
74
75 z = (*p_arg)->size;
76 if (z < sizeof (int))
77 {
78 switch ((*p_arg)->type)
79 {
80 case FFI_TYPE_SINT8:
81 *(signed int *) argp = (signed int) *(SINT8 *) *p_argv;
82 break;
83
84 case FFI_TYPE_UINT8:
85 *(unsigned int *) argp = (unsigned int) *(UINT8 *) *p_argv;
86 break;
87
88 case FFI_TYPE_SINT16:
89 *(signed int *) argp = (signed int) *(SINT16 *) *p_argv;
90 break;
91
92 case FFI_TYPE_UINT16:
93 *(unsigned int *) argp = (unsigned int) *(UINT16 *) *p_argv;
94 break;
95
96 case FFI_TYPE_STRUCT:
97 memcpy (argp, *p_argv, z);
98 break;
99
100 default:
101 FFI_ASSERT (0);
102 }
103 z = sizeof (int);
104 }
105 else
106 {
107 memcpy (argp, *p_argv, z);
108
109 /* Align if necessary. */
110 if ((sizeof(int) - 1) & z)
111 z = FFI_ALIGN(z, sizeof(int));
112 }
113
114 p_argv++;
115 argp += z;
116 }
117
118 return struct_value_ptr;
119 }
120
121 ffi_status
122 ffi_prep_cif_machdep (ffi_cif *cif)
123 {
124 /* Set the return type flag */
125 switch (cif->rtype->type)
126 {
127 case FFI_TYPE_VOID:
128 cif->flags = 0;
129 break;
130
131 case FFI_TYPE_STRUCT:
132 if (cif->rtype->elements[0]->type == FFI_TYPE_STRUCT &&
133 cif->rtype->elements[1])
134 {
135 cif->flags = 0;
136 break;
137 }
138
139 if (cif->rtype->size == sizeof (char))
140 cif->flags = CIF_FLAGS_CHAR;
141 else if (cif->rtype->size == sizeof (short))
142 cif->flags = CIF_FLAGS_SHORT;
143 else if (cif->rtype->size == sizeof (int))
144 cif->flags = CIF_FLAGS_INT;
145 else if (cif->rtype->size == 2 * sizeof (int))
146 cif->flags = CIF_FLAGS_DINT;
147 else
148 cif->flags = 0;
149 break;
150
151 default:
152 if (cif->rtype->size <= sizeof (int))
153 cif->flags = CIF_FLAGS_INT;
154 else
155 cif->flags = CIF_FLAGS_DINT;
156 break;
157 }
158
159 return FFI_OK;
160 }
161
162 void
163 ffi_call (ffi_cif *cif, void (*fn) (), void *rvalue, void **avalue)
164 {
165 extended_cif ecif;
166
167 ecif.cif = cif;
168 ecif.avalue = avalue;
169
170 /* If the return value is a struct and we don't have a return value
171 address then we need to make one. */
172
173 if (rvalue == NULL
174 && cif->rtype->type == FFI_TYPE_STRUCT
175 && cif->flags == 0)
176 ecif.rvalue = alloca (cif->rtype->size);
177 else
178 ecif.rvalue = rvalue;
179
180 switch (cif->abi)
181 {
182 case FFI_ELFBSD:
183 ffi_call_elfbsd (&ecif, cif->bytes, cif->flags, ecif.rvalue, fn);
184 break;
185
186 default:
187 FFI_ASSERT (0);
188 break;
189 }
190 }
191
192 /*
193 * Closure API
194 */
195
196 void ffi_closure_elfbsd (void);
197 void ffi_closure_struct_elfbsd (void);
198 unsigned int ffi_closure_elfbsd_inner (ffi_closure *, void *, char *);
199
200 static void
201 ffi_prep_closure_elfbsd (ffi_cif *cif, void **avalue, char *stackp)
202 {
203 unsigned int i;
204 void **p_argv;
205 ffi_type **p_arg;
206
207 p_argv = avalue;
208
209 for (i = cif->nargs, p_arg = cif->arg_types; i != 0; i--, p_arg++)
210 {
211 size_t z;
212
213 z = (*p_arg)->size;
214 *p_argv = stackp;
215
216 /* Align if necessary */
217 if ((sizeof (int) - 1) & z)
218 z = FFI_ALIGN(z, sizeof (int));
219
220 p_argv++;
221 stackp += z;
222 }
223 }
224
225 unsigned int
226 ffi_closure_elfbsd_inner (ffi_closure *closure, void *resp, char *stack)
227 {
228 ffi_cif *cif;
229 void **arg_area;
230
231 cif = closure->cif;
232 arg_area = (void **) alloca (cif->nargs * sizeof (void *));
233
234 ffi_prep_closure_elfbsd (cif, arg_area, stack);
235
236 (closure->fun) (cif, resp, arg_area, closure->user_data);
237
238 return cif->flags;
239 }
240
241 ffi_status
242 ffi_prep_closure_loc (ffi_closure *closure, ffi_cif *cif,
243 void (*fun)(ffi_cif *, void *, void **, void *),
244 void *user_data, void *codeloc)
245 {
246 char *tramp = (char *) codeloc;
247 void *fn;
248
249 FFI_ASSERT (cif->abi == FFI_ELFBSD);
250
251 /* entry mask */
252 *(unsigned short *)(tramp + 0) = 0x0000;
253 /* movl #closure, r0 */
254 tramp[2] = 0xd0;
255 tramp[3] = 0x8f;
256 *(unsigned int *)(tramp + 4) = (unsigned int) closure;
257 tramp[8] = 0x50;
258
259 if (cif->rtype->type == FFI_TYPE_STRUCT
260 && !cif->flags)
261 fn = &ffi_closure_struct_elfbsd;
262 else
263 fn = &ffi_closure_elfbsd;
264
265 /* jmpl #fn */
266 tramp[9] = 0x17;
267 tramp[10] = 0xef;
268 *(unsigned int *)(tramp + 11) = (unsigned int)fn + 2 -
269 (unsigned int)tramp - 9 - 6;
270
271 closure->cif = cif;
272 closure->user_data = user_data;
273 closure->fun = fun;
274
275 return FFI_OK;
276 }