Update version for v7.1.0-rc3 release
[qemu.git] / linux-user / thunk.c
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(unsigned int target_mask,
440 const bitmask_transtbl * trans_tbl)
441 {
442 const bitmask_transtbl *btp;
443 unsigned int host_mask = 0;
444
445 for (btp = trans_tbl; btp->target_mask && btp->host_mask; btp++) {
446 if ((target_mask & btp->target_mask) == btp->target_bits) {
447 host_mask |= btp->host_bits;
448 }
449 }
450 return host_mask;
451 }
452
453 unsigned int host_to_target_bitmask(unsigned int host_mask,
454 const bitmask_transtbl * trans_tbl)
455 {
456 const bitmask_transtbl *btp;
457 unsigned int target_mask = 0;
458
459 for (btp = trans_tbl; btp->target_mask && btp->host_mask; btp++) {
460 if ((host_mask & btp->host_mask) == btp->host_bits) {
461 target_mask |= btp->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 }