Example as code, documentation template for sphinx build
[kvmfornfv.git] / qemu / 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 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 <stdlib.h>
20 #include <stdio.h>
21 #include <stdarg.h>
22
23 #include "qemu.h"
24 #include "exec/user/thunk.h"
25
26 //#define DEBUG
27
28 static unsigned int max_struct_entries;
29 StructEntry *struct_entries;
30
31 static const argtype *thunk_type_next_ptr(const argtype *type_ptr);
32
33 static inline const argtype *thunk_type_next(const argtype *type_ptr)
34 {
35     int type;
36
37     type = *type_ptr++;
38     switch(type) {
39     case TYPE_CHAR:
40     case TYPE_SHORT:
41     case TYPE_INT:
42     case TYPE_LONGLONG:
43     case TYPE_ULONGLONG:
44     case TYPE_LONG:
45     case TYPE_ULONG:
46     case TYPE_PTRVOID:
47     case TYPE_OLDDEVT:
48         return type_ptr;
49     case TYPE_PTR:
50         return thunk_type_next_ptr(type_ptr);
51     case TYPE_ARRAY:
52         return thunk_type_next_ptr(type_ptr + 1);
53     case TYPE_STRUCT:
54         return type_ptr + 1;
55     default:
56         return NULL;
57     }
58 }
59
60 static const argtype *thunk_type_next_ptr(const argtype *type_ptr)
61 {
62     return thunk_type_next(type_ptr);
63 }
64
65 void thunk_register_struct(int id, const char *name, const argtype *types)
66 {
67     const argtype *type_ptr;
68     StructEntry *se;
69     int nb_fields, offset, max_align, align, size, i, j;
70
71     assert(id < max_struct_entries);
72     se = struct_entries + id;
73
74     /* first we count the number of fields */
75     type_ptr = types;
76     nb_fields = 0;
77     while (*type_ptr != TYPE_NULL) {
78         type_ptr = thunk_type_next(type_ptr);
79         nb_fields++;
80     }
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 < 2; i++) {
91         offset = 0;
92         max_align = 1;
93         se->field_offsets[i] = malloc(nb_fields * sizeof(int));
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 /* from em86 */
276
277 /* Utility function: Table-driven functions to translate bitmasks
278  * between X86 and Alpha formats...
279  */
280 unsigned int target_to_host_bitmask(unsigned int x86_mask,
281                                     const bitmask_transtbl * trans_tbl)
282 {
283     const bitmask_transtbl *btp;
284     unsigned int        alpha_mask = 0;
285
286     for(btp = trans_tbl; btp->x86_mask && btp->alpha_mask; btp++) {
287         if((x86_mask & btp->x86_mask) == btp->x86_bits) {
288             alpha_mask |= btp->alpha_bits;
289         }
290     }
291     return(alpha_mask);
292 }
293
294 unsigned int host_to_target_bitmask(unsigned int alpha_mask,
295                                     const bitmask_transtbl * trans_tbl)
296 {
297     const bitmask_transtbl *btp;
298     unsigned int        x86_mask = 0;
299
300     for(btp = trans_tbl; btp->x86_mask && btp->alpha_mask; btp++) {
301         if((alpha_mask & btp->alpha_mask) == btp->alpha_bits) {
302             x86_mask |= btp->x86_bits;
303         }
304     }
305     return(x86_mask);
306 }
307
308 #ifndef NO_THUNK_TYPE_SIZE
309 int thunk_type_size_array(const argtype *type_ptr, int is_host)
310 {
311     return thunk_type_size(type_ptr, is_host);
312 }
313
314 int thunk_type_align_array(const argtype *type_ptr, int is_host)
315 {
316     return thunk_type_align(type_ptr, is_host);
317 }
318 #endif /* ndef NO_THUNK_TYPE_SIZE */
319
320 void thunk_init(unsigned int max_structs)
321 {
322     max_struct_entries = max_structs;
323     struct_entries = g_new0(StructEntry, max_structs);
324 }