blob: 7331aeb477d7f8fe124317e221fc3199b171d9ba [file] [log] [blame]
bellard31e31b82003-02-18 22:55:36 +00001/*
2 * Generic thunking code to convert data between host and target CPU
ths5fafdf22007-09-16 21:08:06 +00003 *
bellard31e31b82003-02-18 22:55:36 +00004 * Copyright (c) 2003 Fabrice Bellard
5 *
bellard3ef693a2003-03-23 20:17:16 +00006 * 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 of the License, or (at your option) any later version.
bellard31e31b82003-02-18 22:55:36 +000010 *
bellard3ef693a2003-03-23 20:17:16 +000011 * 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.
bellard31e31b82003-02-18 22:55:36 +000015 *
bellard3ef693a2003-03-23 20:17:16 +000016 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
bellard31e31b82003-02-18 22:55:36 +000019 */
20#include <stdlib.h>
21#include <stdio.h>
22#include <stdarg.h>
23
bellard3ef693a2003-03-23 20:17:16 +000024#include "qemu.h"
bellard31e31b82003-02-18 22:55:36 +000025#include "thunk.h"
26
27//#define DEBUG
28
29#define MAX_STRUCTS 128
30
31/* XXX: make it dynamic */
bellard24374902003-06-15 19:52:54 +000032StructEntry struct_entries[MAX_STRUCTS];
bellard31e31b82003-02-18 22:55:36 +000033
j_mayer26553112007-11-19 01:06:24 +000034static const argtype *thunk_type_next_ptr(const argtype *type_ptr);
35
bellard31e31b82003-02-18 22:55:36 +000036static inline const argtype *thunk_type_next(const argtype *type_ptr)
37{
38 int type;
39
40 type = *type_ptr++;
41 switch(type) {
42 case TYPE_CHAR:
43 case TYPE_SHORT:
44 case TYPE_INT:
45 case TYPE_LONGLONG:
46 case TYPE_ULONGLONG:
47 case TYPE_LONG:
48 case TYPE_ULONG:
49 case TYPE_PTRVOID:
50 return type_ptr;
51 case TYPE_PTR:
j_mayer26553112007-11-19 01:06:24 +000052 return thunk_type_next_ptr(type_ptr);
bellard31e31b82003-02-18 22:55:36 +000053 case TYPE_ARRAY:
j_mayer26553112007-11-19 01:06:24 +000054 return thunk_type_next_ptr(type_ptr + 1);
bellard31e31b82003-02-18 22:55:36 +000055 case TYPE_STRUCT:
56 return type_ptr + 1;
57 default:
58 return NULL;
59 }
60}
61
j_mayer26553112007-11-19 01:06:24 +000062static const argtype *thunk_type_next_ptr(const argtype *type_ptr)
63{
64 return thunk_type_next(type_ptr);
65}
66
bellard31e31b82003-02-18 22:55:36 +000067void thunk_register_struct(int id, const char *name, const argtype *types)
68{
69 const argtype *type_ptr;
70 StructEntry *se;
71 int nb_fields, offset, max_align, align, size, i, j;
72
73 se = struct_entries + id;
ths3b46e622007-09-17 08:09:54 +000074
bellard31e31b82003-02-18 22:55:36 +000075 /* first we count the number of fields */
76 type_ptr = types;
77 nb_fields = 0;
78 while (*type_ptr != TYPE_NULL) {
79 type_ptr = thunk_type_next(type_ptr);
80 nb_fields++;
81 }
82 se->field_types = types;
83 se->nb_fields = nb_fields;
84 se->name = name;
85#ifdef DEBUG
ths5fafdf22007-09-16 21:08:06 +000086 printf("struct %s: id=%d nb_fields=%d\n",
bellard31e31b82003-02-18 22:55:36 +000087 se->name, id, se->nb_fields);
88#endif
89 /* now we can alloc the data */
90
91 for(i = 0;i < 2; i++) {
92 offset = 0;
93 max_align = 1;
94 se->field_offsets[i] = malloc(nb_fields * sizeof(int));
95 type_ptr = se->field_types;
96 for(j = 0;j < nb_fields; j++) {
97 size = thunk_type_size(type_ptr, i);
98 align = thunk_type_align(type_ptr, i);
99 offset = (offset + align - 1) & ~(align - 1);
100 se->field_offsets[i][j] = offset;
101 offset += size;
102 if (align > max_align)
103 max_align = align;
bellard24374902003-06-15 19:52:54 +0000104 type_ptr = thunk_type_next(type_ptr);
bellard31e31b82003-02-18 22:55:36 +0000105 }
106 offset = (offset + max_align - 1) & ~(max_align - 1);
107 se->size[i] = offset;
108 se->align[i] = max_align;
109#ifdef DEBUG
ths5fafdf22007-09-16 21:08:06 +0000110 printf("%s: size=%d align=%d\n",
bellard31e31b82003-02-18 22:55:36 +0000111 i == THUNK_HOST ? "host" : "target", offset, max_align);
112#endif
113 }
114}
115
116void thunk_register_struct_direct(int id, const char *name, StructEntry *se1)
117{
118 StructEntry *se;
119 se = struct_entries + id;
120 *se = *se1;
121 se->name = name;
122}
123
124
125/* now we can define the main conversion functions */
ths5fafdf22007-09-16 21:08:06 +0000126const argtype *thunk_convert(void *dst, const void *src,
bellard31e31b82003-02-18 22:55:36 +0000127 const argtype *type_ptr, int to_host)
128{
129 int type;
130
131 type = *type_ptr++;
132 switch(type) {
133 case TYPE_CHAR:
134 *(uint8_t *)dst = *(uint8_t *)src;
135 break;
136 case TYPE_SHORT:
137 *(uint16_t *)dst = tswap16(*(uint16_t *)src);
138 break;
139 case TYPE_INT:
140 *(uint32_t *)dst = tswap32(*(uint32_t *)src);
141 break;
142 case TYPE_LONGLONG:
143 case TYPE_ULONGLONG:
144 *(uint64_t *)dst = tswap64(*(uint64_t *)src);
145 break;
blueswir1992f48a2007-10-14 16:27:31 +0000146#if HOST_LONG_BITS == 32 && TARGET_ABI_BITS == 32
bellard31e31b82003-02-18 22:55:36 +0000147 case TYPE_LONG:
148 case TYPE_ULONG:
149 case TYPE_PTRVOID:
150 *(uint32_t *)dst = tswap32(*(uint32_t *)src);
151 break;
blueswir1992f48a2007-10-14 16:27:31 +0000152#elif HOST_LONG_BITS == 64 && TARGET_ABI_BITS == 32
bellard31e31b82003-02-18 22:55:36 +0000153 case TYPE_LONG:
154 case TYPE_ULONG:
155 case TYPE_PTRVOID:
bellardd0cd3b82003-04-07 21:35:13 +0000156 if (to_host) {
bellard70499c92007-11-11 19:31:34 +0000157 if (type == TYPE_LONG) {
158 /* sign extension */
159 *(uint64_t *)dst = (int32_t)tswap32(*(uint32_t *)src);
160 } else {
161 *(uint64_t *)dst = tswap32(*(uint32_t *)src);
162 }
bellard31e31b82003-02-18 22:55:36 +0000163 } else {
164 *(uint32_t *)dst = tswap32(*(uint64_t *)src & 0xffffffff);
165 }
166 break;
bellard70499c92007-11-11 19:31:34 +0000167#elif HOST_LONG_BITS == 64 && TARGET_ABI_BITS == 64
168 case TYPE_LONG:
169 case TYPE_ULONG:
170 case TYPE_PTRVOID:
171 *(uint64_t *)dst = tswap64(*(uint64_t *)src);
172 break;
173#elif HOST_LONG_BITS == 32 && TARGET_ABI_BITS == 64
174 case TYPE_LONG:
175 case TYPE_ULONG:
176 case TYPE_PTRVOID:
177 if (to_host) {
178 *(uint32_t *)dst = tswap64(*(uint64_t *)src);
179 } else {
180 if (type == TYPE_LONG) {
181 /* sign extension */
182 *(uint64_t *)dst = tswap64(*(int32_t *)src);
183 } else {
184 *(uint64_t *)dst = tswap64(*(uint32_t *)src);
185 }
186 }
187 break;
bellard31e31b82003-02-18 22:55:36 +0000188#else
bellard64b3ab22005-01-30 22:43:42 +0000189#warning unsupported conversion
bellard31e31b82003-02-18 22:55:36 +0000190#endif
191 case TYPE_ARRAY:
192 {
193 int array_length, i, dst_size, src_size;
194 const uint8_t *s;
195 uint8_t *d;
196
197 array_length = *type_ptr++;
198 dst_size = thunk_type_size(type_ptr, to_host);
199 src_size = thunk_type_size(type_ptr, 1 - to_host);
200 d = dst;
201 s = src;
202 for(i = 0;i < array_length; i++) {
203 thunk_convert(d, s, type_ptr, to_host);
204 d += dst_size;
205 s += src_size;
206 }
207 type_ptr = thunk_type_next(type_ptr);
208 }
209 break;
210 case TYPE_STRUCT:
211 {
212 int i;
213 const StructEntry *se;
214 const uint8_t *s;
215 uint8_t *d;
216 const argtype *field_types;
217 const int *dst_offsets, *src_offsets;
ths3b46e622007-09-17 08:09:54 +0000218
bellard31e31b82003-02-18 22:55:36 +0000219 se = struct_entries + *type_ptr++;
220 if (se->convert[0] != NULL) {
221 /* specific conversion is needed */
222 (*se->convert[to_host])(dst, src);
223 } else {
224 /* standard struct conversion */
225 field_types = se->field_types;
226 dst_offsets = se->field_offsets[to_host];
227 src_offsets = se->field_offsets[1 - to_host];
228 d = dst;
229 s = src;
230 for(i = 0;i < se->nb_fields; i++) {
ths5fafdf22007-09-16 21:08:06 +0000231 field_types = thunk_convert(d + dst_offsets[i],
232 s + src_offsets[i],
bellard31e31b82003-02-18 22:55:36 +0000233 field_types, to_host);
234 }
235 }
236 }
237 break;
238 default:
239 fprintf(stderr, "Invalid type 0x%x\n", type);
240 break;
241 }
242 return type_ptr;
243}
244
245/* from em86 */
246
247/* Utility function: Table-driven functions to translate bitmasks
248 * between X86 and Alpha formats...
249 */
ths5fafdf22007-09-16 21:08:06 +0000250unsigned int target_to_host_bitmask(unsigned int x86_mask,
bellard31e31b82003-02-18 22:55:36 +0000251 bitmask_transtbl * trans_tbl)
252{
253 bitmask_transtbl * btp;
254 unsigned int alpha_mask = 0;
255
256 for(btp = trans_tbl; btp->x86_mask && btp->alpha_mask; btp++) {
257 if((x86_mask & btp->x86_mask) == btp->x86_bits) {
258 alpha_mask |= btp->alpha_bits;
259 }
260 }
261 return(alpha_mask);
262}
263
ths5fafdf22007-09-16 21:08:06 +0000264unsigned int host_to_target_bitmask(unsigned int alpha_mask,
bellard31e31b82003-02-18 22:55:36 +0000265 bitmask_transtbl * trans_tbl)
266{
267 bitmask_transtbl * btp;
268 unsigned int x86_mask = 0;
269
270 for(btp = trans_tbl; btp->x86_mask && btp->alpha_mask; btp++) {
271 if((alpha_mask & btp->alpha_mask) == btp->alpha_bits) {
bellard7a987122004-11-09 22:08:48 +0000272 x86_mask |= btp->x86_bits;
bellard31e31b82003-02-18 22:55:36 +0000273 }
274 }
275 return(x86_mask);
276}
j_mayer26553112007-11-19 01:06:24 +0000277
278#ifndef NO_THUNK_TYPE_SIZE
279int thunk_type_size_array(const argtype *type_ptr, int is_host)
280{
281 return thunk_type_size(type_ptr, is_host);
282}
283
284int thunk_type_align_array(const argtype *type_ptr, int is_host)
285{
286 return thunk_type_align(type_ptr, is_host);
287}
288#endif /* ndef NO_THUNK_TYPE_SIZE */