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