xref: /openbmc/qemu/linux-user/thunk.c (revision a05cee93)
1 /*
2  *  Generic thunking code to convert data between host and target CPU
3  *
4  *  Copyright (c) 2003 Fabrice Bellard
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
18  */
19 #include "qemu/osdep.h"
20 #include "qemu/log.h"
21 
22 #include "qemu.h"
23 #include "exec/user/thunk.h"
24 
25 //#define DEBUG
26 
27 static unsigned int max_struct_entries;
28 StructEntry *struct_entries;
29 
30 static const argtype *thunk_type_next_ptr(const argtype *type_ptr);
31 
32 static inline const argtype *thunk_type_next(const argtype *type_ptr)
33 {
34     int type;
35 
36     type = *type_ptr++;
37     switch(type) {
38     case TYPE_CHAR:
39     case TYPE_SHORT:
40     case TYPE_INT:
41     case TYPE_LONGLONG:
42     case TYPE_ULONGLONG:
43     case TYPE_LONG:
44     case TYPE_ULONG:
45     case TYPE_PTRVOID:
46     case TYPE_OLDDEVT:
47         return type_ptr;
48     case TYPE_PTR:
49         return thunk_type_next_ptr(type_ptr);
50     case TYPE_ARRAY:
51         return thunk_type_next_ptr(type_ptr + 1);
52     case TYPE_STRUCT:
53         return type_ptr + 1;
54     default:
55         return NULL;
56     }
57 }
58 
59 static const argtype *thunk_type_next_ptr(const argtype *type_ptr)
60 {
61     return thunk_type_next(type_ptr);
62 }
63 
64 void thunk_register_struct(int id, const char *name, const argtype *types)
65 {
66     const argtype *type_ptr;
67     StructEntry *se;
68     int nb_fields, offset, max_align, align, size, i, j;
69 
70     assert(id < max_struct_entries);
71 
72     /* first we count the number of fields */
73     type_ptr = types;
74     nb_fields = 0;
75     while (*type_ptr != TYPE_NULL) {
76         type_ptr = thunk_type_next(type_ptr);
77         nb_fields++;
78     }
79     assert(nb_fields > 0);
80     se = struct_entries + id;
81     se->field_types = types;
82     se->nb_fields = nb_fields;
83     se->name = name;
84 #ifdef DEBUG
85     printf("struct %s: id=%d nb_fields=%d\n",
86            se->name, id, se->nb_fields);
87 #endif
88     /* now we can alloc the data */
89 
90     for (i = 0; i < ARRAY_SIZE(se->field_offsets); i++) {
91         offset = 0;
92         max_align = 1;
93         se->field_offsets[i] = g_new(int, nb_fields);
94         type_ptr = se->field_types;
95         for(j = 0;j < nb_fields; j++) {
96             size = thunk_type_size(type_ptr, i);
97             align = thunk_type_align(type_ptr, i);
98             offset = (offset + align - 1) & ~(align - 1);
99             se->field_offsets[i][j] = offset;
100             offset += size;
101             if (align > max_align)
102                 max_align = align;
103             type_ptr = thunk_type_next(type_ptr);
104         }
105         offset = (offset + max_align - 1) & ~(max_align - 1);
106         se->size[i] = offset;
107         se->align[i] = max_align;
108 #ifdef DEBUG
109         printf("%s: size=%d align=%d\n",
110                i == THUNK_HOST ? "host" : "target", offset, max_align);
111 #endif
112     }
113 }
114 
115 void thunk_register_struct_direct(int id, const char *name,
116                                   const StructEntry *se1)
117 {
118     StructEntry *se;
119 
120     assert(id < max_struct_entries);
121     se = struct_entries + id;
122     *se = *se1;
123     se->name = name;
124 }
125 
126 
127 /* now we can define the main conversion functions */
128 const argtype *thunk_convert(void *dst, const void *src,
129                              const argtype *type_ptr, int to_host)
130 {
131     int type;
132 
133     type = *type_ptr++;
134     switch(type) {
135     case TYPE_CHAR:
136         *(uint8_t *)dst = *(uint8_t *)src;
137         break;
138     case TYPE_SHORT:
139         *(uint16_t *)dst = tswap16(*(uint16_t *)src);
140         break;
141     case TYPE_INT:
142         *(uint32_t *)dst = tswap32(*(uint32_t *)src);
143         break;
144     case TYPE_LONGLONG:
145     case TYPE_ULONGLONG:
146         *(uint64_t *)dst = tswap64(*(uint64_t *)src);
147         break;
148 #if HOST_LONG_BITS == 32 && TARGET_ABI_BITS == 32
149     case TYPE_LONG:
150     case TYPE_ULONG:
151     case TYPE_PTRVOID:
152         *(uint32_t *)dst = tswap32(*(uint32_t *)src);
153         break;
154 #elif HOST_LONG_BITS == 64 && TARGET_ABI_BITS == 32
155     case TYPE_LONG:
156     case TYPE_ULONG:
157     case TYPE_PTRVOID:
158         if (to_host) {
159             if (type == TYPE_LONG) {
160                 /* sign extension */
161                 *(uint64_t *)dst = (int32_t)tswap32(*(uint32_t *)src);
162             } else {
163                 *(uint64_t *)dst = tswap32(*(uint32_t *)src);
164             }
165         } else {
166             *(uint32_t *)dst = tswap32(*(uint64_t *)src & 0xffffffff);
167         }
168         break;
169 #elif HOST_LONG_BITS == 64 && TARGET_ABI_BITS == 64
170     case TYPE_LONG:
171     case TYPE_ULONG:
172     case TYPE_PTRVOID:
173         *(uint64_t *)dst = tswap64(*(uint64_t *)src);
174         break;
175 #elif HOST_LONG_BITS == 32 && TARGET_ABI_BITS == 64
176     case TYPE_LONG:
177     case TYPE_ULONG:
178     case TYPE_PTRVOID:
179         if (to_host) {
180             *(uint32_t *)dst = tswap64(*(uint64_t *)src);
181         } else {
182             if (type == TYPE_LONG) {
183                 /* sign extension */
184                 *(uint64_t *)dst = tswap64(*(int32_t *)src);
185             } else {
186                 *(uint64_t *)dst = tswap64(*(uint32_t *)src);
187             }
188         }
189         break;
190 #else
191 #warning unsupported conversion
192 #endif
193     case TYPE_OLDDEVT:
194     {
195         uint64_t val = 0;
196         switch (thunk_type_size(type_ptr - 1, !to_host)) {
197         case 2:
198             val = *(uint16_t *)src;
199             break;
200         case 4:
201             val = *(uint32_t *)src;
202             break;
203         case 8:
204             val = *(uint64_t *)src;
205             break;
206         }
207         switch (thunk_type_size(type_ptr - 1, to_host)) {
208         case 2:
209             *(uint16_t *)dst = tswap16(val);
210             break;
211         case 4:
212             *(uint32_t *)dst = tswap32(val);
213             break;
214         case 8:
215             *(uint64_t *)dst = tswap64(val);
216             break;
217         }
218         break;
219     }
220     case TYPE_ARRAY:
221         {
222             int array_length, i, dst_size, src_size;
223             const uint8_t *s;
224             uint8_t  *d;
225 
226             array_length = *type_ptr++;
227             dst_size = thunk_type_size(type_ptr, to_host);
228             src_size = thunk_type_size(type_ptr, 1 - to_host);
229             d = dst;
230             s = src;
231             for(i = 0;i < array_length; i++) {
232                 thunk_convert(d, s, type_ptr, to_host);
233                 d += dst_size;
234                 s += src_size;
235             }
236             type_ptr = thunk_type_next(type_ptr);
237         }
238         break;
239     case TYPE_STRUCT:
240         {
241             int i;
242             const StructEntry *se;
243             const uint8_t *s;
244             uint8_t  *d;
245             const argtype *field_types;
246             const int *dst_offsets, *src_offsets;
247 
248             assert(*type_ptr < max_struct_entries);
249             se = struct_entries + *type_ptr++;
250             if (se->convert[0] != NULL) {
251                 /* specific conversion is needed */
252                 (*se->convert[to_host])(dst, src);
253             } else {
254                 /* standard struct conversion */
255                 field_types = se->field_types;
256                 dst_offsets = se->field_offsets[to_host];
257                 src_offsets = se->field_offsets[1 - to_host];
258                 d = dst;
259                 s = src;
260                 for(i = 0;i < se->nb_fields; i++) {
261                     field_types = thunk_convert(d + dst_offsets[i],
262                                                 s + src_offsets[i],
263                                                 field_types, to_host);
264                 }
265             }
266         }
267         break;
268     default:
269         fprintf(stderr, "Invalid type 0x%x\n", type);
270         break;
271     }
272     return type_ptr;
273 }
274 
275 const argtype *thunk_print(void *arg, const argtype *type_ptr)
276 {
277     int type;
278 
279     type = *type_ptr++;
280 
281     switch (type) {
282     case TYPE_CHAR:
283         qemu_log("%c", *(uint8_t *)arg);
284         break;
285     case TYPE_SHORT:
286         qemu_log("%" PRId16, tswap16(*(uint16_t *)arg));
287         break;
288     case TYPE_INT:
289         qemu_log("%" PRId32, tswap32(*(uint32_t *)arg));
290         break;
291     case TYPE_LONGLONG:
292         qemu_log("%" PRId64, tswap64(*(uint64_t *)arg));
293         break;
294     case TYPE_ULONGLONG:
295         qemu_log("%" PRIu64, tswap64(*(uint64_t *)arg));
296         break;
297 #if HOST_LONG_BITS == 32 && TARGET_ABI_BITS == 32
298     case TYPE_PTRVOID:
299         qemu_log("0x%" PRIx32, tswap32(*(uint32_t *)arg));
300         break;
301     case TYPE_LONG:
302         qemu_log("%" PRId32, tswap32(*(uint32_t *)arg));
303         break;
304     case TYPE_ULONG:
305         qemu_log("%" PRIu32, tswap32(*(uint32_t *)arg));
306         break;
307 #elif HOST_LONG_BITS == 64 && TARGET_ABI_BITS == 32
308     case TYPE_PTRVOID:
309         qemu_log("0x%" PRIx32, tswap32(*(uint64_t *)arg & 0xffffffff));
310         break;
311     case TYPE_LONG:
312         qemu_log("%" PRId32, tswap32(*(uint64_t *)arg & 0xffffffff));
313         break;
314     case TYPE_ULONG:
315         qemu_log("%" PRIu32, tswap32(*(uint64_t *)arg & 0xffffffff));
316         break;
317 #elif HOST_LONG_BITS == 64 && TARGET_ABI_BITS == 64
318     case TYPE_PTRVOID:
319         qemu_log("0x%" PRIx64, tswap64(*(uint64_t *)arg));
320         break;
321     case TYPE_LONG:
322         qemu_log("%" PRId64, tswap64(*(uint64_t *)arg));
323         break;
324     case TYPE_ULONG:
325         qemu_log("%" PRIu64, tswap64(*(uint64_t *)arg));
326         break;
327 #else
328     case TYPE_PTRVOID:
329         qemu_log("0x%" PRIx64, tswap64(*(uint64_t *)arg));
330         break;
331     case TYPE_LONG:
332         qemu_log("%" PRId64, tswap64(*(uint64_t *)arg));
333         break;
334     case TYPE_ULONG:
335         qemu_log("%" PRIu64, tswap64(*(uint64_t *)arg));
336         break;
337 #endif
338     case TYPE_OLDDEVT:
339     {
340         uint64_t val = 0;
341         switch (thunk_type_size(type_ptr - 1, 1)) {
342         case 2:
343             val = *(uint16_t *)arg;
344             break;
345         case 4:
346             val = *(uint32_t *)arg;
347             break;
348         case 8:
349             val = *(uint64_t *)arg;
350             break;
351         }
352         switch (thunk_type_size(type_ptr - 1, 0)) {
353         case 2:
354             qemu_log("%" PRIu16, tswap16(val));
355             break;
356         case 4:
357             qemu_log("%" PRIu32, tswap32(val));
358             break;
359         case 8:
360             qemu_log("%" PRIu64, tswap64(val));
361             break;
362         }
363     }
364     break;
365     case TYPE_ARRAY:
366         {
367             int i, array_length, arg_size;
368             uint8_t *a;
369             int is_string = 0;
370 
371             array_length = *type_ptr++;
372             arg_size = thunk_type_size(type_ptr, 0);
373             a = arg;
374 
375             if (*type_ptr == TYPE_CHAR) {
376                 qemu_log("\"");
377                 is_string = 1;
378             } else {
379                 qemu_log("[");
380             }
381 
382             for (i = 0; i < array_length; i++) {
383                 if (i > 0 && !is_string) {
384                     qemu_log(",");
385                 }
386                 thunk_print(a, type_ptr);
387                 a += arg_size;
388             }
389 
390             if (is_string) {
391                 qemu_log("\"");
392             } else {
393                 qemu_log("]");
394             }
395 
396             type_ptr = thunk_type_next(type_ptr);
397         }
398         break;
399     case TYPE_STRUCT:
400         {
401             int i;
402             const StructEntry *se;
403             uint8_t  *a;
404             const argtype *field_types;
405             const int *arg_offsets;
406 
407             se = struct_entries + *type_ptr++;
408 
409             if (se->print != NULL) {
410                 se->print(arg);
411             } else {
412                 a = arg;
413 
414                 field_types = se->field_types;
415                 arg_offsets = se->field_offsets[0];
416 
417                 qemu_log("{");
418                 for (i = 0; i < se->nb_fields; i++) {
419                     if (i > 0) {
420                         qemu_log(",");
421                     }
422                     field_types = thunk_print(a + arg_offsets[i], field_types);
423                 }
424                 qemu_log("}");
425             }
426         }
427         break;
428     default:
429         g_assert_not_reached();
430     }
431     return type_ptr;
432 }
433 
434 /* from em86 */
435 
436 /* Utility function: Table-driven functions to translate bitmasks
437  * between host and target formats
438  */
439 unsigned int target_to_host_bitmask_len(unsigned int target_mask,
440                                         const bitmask_transtbl *tbl,
441                                         size_t len)
442 {
443     unsigned int host_mask = 0;
444 
445     for (size_t i = 0; i < len; ++i) {
446         if ((target_mask & tbl[i].target_mask) == tbl[i].target_bits) {
447             host_mask |= tbl[i].host_bits;
448         }
449     }
450     return host_mask;
451 }
452 
453 unsigned int host_to_target_bitmask_len(unsigned int host_mask,
454                                         const bitmask_transtbl *tbl,
455                                         size_t len)
456 {
457     unsigned int target_mask = 0;
458 
459     for (size_t i = 0; i < len; ++i) {
460         if ((host_mask & tbl[i].host_mask) == tbl[i].host_bits) {
461             target_mask |= tbl[i].target_bits;
462         }
463     }
464     return target_mask;
465 }
466 
467 int thunk_type_size_array(const argtype *type_ptr, int is_host)
468 {
469     return thunk_type_size(type_ptr, is_host);
470 }
471 
472 int thunk_type_align_array(const argtype *type_ptr, int is_host)
473 {
474     return thunk_type_align(type_ptr, is_host);
475 }
476 
477 void thunk_init(unsigned int max_structs)
478 {
479     max_struct_entries = max_structs;
480     struct_entries = g_new0(StructEntry, max_structs);
481 }
482