Merge remote-tracking branch 'remotes/palmer/tags/riscv-for-master-4.1-sf1-v3' into...
[qemu/ar7.git] / thunk.c
blob7f31cffe0968c87a83d59b27ecab2f1f79e78d99
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 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"
21 #include "qemu.h"
22 #include "exec/user/thunk.h"
24 //#define DEBUG
26 static unsigned int max_struct_entries;
27 StructEntry *struct_entries;
29 static const argtype *thunk_type_next_ptr(const argtype *type_ptr);
31 static inline const argtype *thunk_type_next(const argtype *type_ptr)
33     int type;
35     type = *type_ptr++;
36     switch(type) {
37     case TYPE_CHAR:
38     case TYPE_SHORT:
39     case TYPE_INT:
40     case TYPE_LONGLONG:
41     case TYPE_ULONGLONG:
42     case TYPE_LONG:
43     case TYPE_ULONG:
44     case TYPE_PTRVOID:
45     case TYPE_OLDDEVT:
46         return type_ptr;
47     case TYPE_PTR:
48         return thunk_type_next_ptr(type_ptr);
49     case TYPE_ARRAY:
50         return thunk_type_next_ptr(type_ptr + 1);
51     case TYPE_STRUCT:
52         return type_ptr + 1;
53     default:
54         return NULL;
55     }
58 static const argtype *thunk_type_next_ptr(const argtype *type_ptr)
60     return thunk_type_next(type_ptr);
63 void thunk_register_struct(int id, const char *name, const argtype *types)
65     const argtype *type_ptr;
66     StructEntry *se;
67     int nb_fields, offset, max_align, align, size, i, j;
69     assert(id < max_struct_entries);
71     /* first we count the number of fields */
72     type_ptr = types;
73     nb_fields = 0;
74     while (*type_ptr != TYPE_NULL) {
75         type_ptr = thunk_type_next(type_ptr);
76         nb_fields++;
77     }
78     assert(nb_fields > 0);
79     se = struct_entries + id;
80     se->field_types = types;
81     se->nb_fields = nb_fields;
82     se->name = name;
83 #ifdef DEBUG
84     printf("struct %s: id=%d nb_fields=%d\n",
85            se->name, id, se->nb_fields);
86 #endif
87     /* now we can alloc the data */
89     for (i = 0; i < ARRAY_SIZE(se->field_offsets); i++) {
90         offset = 0;
91         max_align = 1;
92         se->field_offsets[i] = g_new(int, nb_fields);
93         type_ptr = se->field_types;
94         for(j = 0;j < nb_fields; j++) {
95             size = thunk_type_size(type_ptr, i);
96             align = thunk_type_align(type_ptr, i);
97             offset = (offset + align - 1) & ~(align - 1);
98             se->field_offsets[i][j] = offset;
99             offset += size;
100             if (align > max_align)
101                 max_align = align;
102             type_ptr = thunk_type_next(type_ptr);
103         }
104         offset = (offset + max_align - 1) & ~(max_align - 1);
105         se->size[i] = offset;
106         se->align[i] = max_align;
107 #ifdef DEBUG
108         printf("%s: size=%d align=%d\n",
109                i == THUNK_HOST ? "host" : "target", offset, max_align);
110 #endif
111     }
114 void thunk_register_struct_direct(int id, const char *name,
115                                   const StructEntry *se1)
117     StructEntry *se;
119     assert(id < max_struct_entries);
120     se = struct_entries + id;
121     *se = *se1;
122     se->name = name;
126 /* now we can define the main conversion functions */
127 const argtype *thunk_convert(void *dst, const void *src,
128                              const argtype *type_ptr, int to_host)
130     int type;
132     type = *type_ptr++;
133     switch(type) {
134     case TYPE_CHAR:
135         *(uint8_t *)dst = *(uint8_t *)src;
136         break;
137     case TYPE_SHORT:
138         *(uint16_t *)dst = tswap16(*(uint16_t *)src);
139         break;
140     case TYPE_INT:
141         *(uint32_t *)dst = tswap32(*(uint32_t *)src);
142         break;
143     case TYPE_LONGLONG:
144     case TYPE_ULONGLONG:
145         *(uint64_t *)dst = tswap64(*(uint64_t *)src);
146         break;
147 #if HOST_LONG_BITS == 32 && TARGET_ABI_BITS == 32
148     case TYPE_LONG:
149     case TYPE_ULONG:
150     case TYPE_PTRVOID:
151         *(uint32_t *)dst = tswap32(*(uint32_t *)src);
152         break;
153 #elif HOST_LONG_BITS == 64 && TARGET_ABI_BITS == 32
154     case TYPE_LONG:
155     case TYPE_ULONG:
156     case TYPE_PTRVOID:
157         if (to_host) {
158             if (type == TYPE_LONG) {
159                 /* sign extension */
160                 *(uint64_t *)dst = (int32_t)tswap32(*(uint32_t *)src);
161             } else {
162                 *(uint64_t *)dst = tswap32(*(uint32_t *)src);
163             }
164         } else {
165             *(uint32_t *)dst = tswap32(*(uint64_t *)src & 0xffffffff);
166         }
167         break;
168 #elif HOST_LONG_BITS == 64 && TARGET_ABI_BITS == 64
169     case TYPE_LONG:
170     case TYPE_ULONG:
171     case TYPE_PTRVOID:
172         *(uint64_t *)dst = tswap64(*(uint64_t *)src);
173         break;
174 #elif HOST_LONG_BITS == 32 && TARGET_ABI_BITS == 64
175     case TYPE_LONG:
176     case TYPE_ULONG:
177     case TYPE_PTRVOID:
178         if (to_host) {
179             *(uint32_t *)dst = tswap64(*(uint64_t *)src);
180         } else {
181             if (type == TYPE_LONG) {
182                 /* sign extension */
183                 *(uint64_t *)dst = tswap64(*(int32_t *)src);
184             } else {
185                 *(uint64_t *)dst = tswap64(*(uint32_t *)src);
186             }
187         }
188         break;
189 #else
190 #warning unsupported conversion
191 #endif
192     case TYPE_OLDDEVT:
193     {
194         uint64_t val = 0;
195         switch (thunk_type_size(type_ptr - 1, !to_host)) {
196         case 2:
197             val = *(uint16_t *)src;
198             break;
199         case 4:
200             val = *(uint32_t *)src;
201             break;
202         case 8:
203             val = *(uint64_t *)src;
204             break;
205         }
206         switch (thunk_type_size(type_ptr - 1, to_host)) {
207         case 2:
208             *(uint16_t *)dst = tswap16(val);
209             break;
210         case 4:
211             *(uint32_t *)dst = tswap32(val);
212             break;
213         case 8:
214             *(uint64_t *)dst = tswap64(val);
215             break;
216         }
217         break;
218     }
219     case TYPE_ARRAY:
220         {
221             int array_length, i, dst_size, src_size;
222             const uint8_t *s;
223             uint8_t  *d;
225             array_length = *type_ptr++;
226             dst_size = thunk_type_size(type_ptr, to_host);
227             src_size = thunk_type_size(type_ptr, 1 - to_host);
228             d = dst;
229             s = src;
230             for(i = 0;i < array_length; i++) {
231                 thunk_convert(d, s, type_ptr, to_host);
232                 d += dst_size;
233                 s += src_size;
234             }
235             type_ptr = thunk_type_next(type_ptr);
236         }
237         break;
238     case TYPE_STRUCT:
239         {
240             int i;
241             const StructEntry *se;
242             const uint8_t *s;
243             uint8_t  *d;
244             const argtype *field_types;
245             const int *dst_offsets, *src_offsets;
247             assert(*type_ptr < max_struct_entries);
248             se = struct_entries + *type_ptr++;
249             if (se->convert[0] != NULL) {
250                 /* specific conversion is needed */
251                 (*se->convert[to_host])(dst, src);
252             } else {
253                 /* standard struct conversion */
254                 field_types = se->field_types;
255                 dst_offsets = se->field_offsets[to_host];
256                 src_offsets = se->field_offsets[1 - to_host];
257                 d = dst;
258                 s = src;
259                 for(i = 0;i < se->nb_fields; i++) {
260                     field_types = thunk_convert(d + dst_offsets[i],
261                                                 s + src_offsets[i],
262                                                 field_types, to_host);
263                 }
264             }
265         }
266         break;
267     default:
268         fprintf(stderr, "Invalid type 0x%x\n", type);
269         break;
270     }
271     return type_ptr;
274 /* from em86 */
276 /* Utility function: Table-driven functions to translate bitmasks
277  * between host and target formats
278  */
279 unsigned int target_to_host_bitmask(unsigned int target_mask,
280                                     const bitmask_transtbl * trans_tbl)
282     const bitmask_transtbl *btp;
283     unsigned int host_mask = 0;
285     for (btp = trans_tbl; btp->target_mask && btp->host_mask; btp++) {
286         if ((target_mask & btp->target_mask) == btp->target_bits) {
287             host_mask |= btp->host_bits;
288         }
289     }
290     return host_mask;
293 unsigned int host_to_target_bitmask(unsigned int host_mask,
294                                     const bitmask_transtbl * trans_tbl)
296     const bitmask_transtbl *btp;
297     unsigned int target_mask = 0;
299     for (btp = trans_tbl; btp->target_mask && btp->host_mask; btp++) {
300         if ((host_mask & btp->host_mask) == btp->host_bits) {
301             target_mask |= btp->target_bits;
302         }
303     }
304     return target_mask;
307 int thunk_type_size_array(const argtype *type_ptr, int is_host)
309     return thunk_type_size(type_ptr, is_host);
312 int thunk_type_align_array(const argtype *type_ptr, int is_host)
314     return thunk_type_align(type_ptr, is_host);
317 void thunk_init(unsigned int max_structs)
319     max_struct_entries = max_structs;
320     struct_entries = g_new0(StructEntry, max_structs);