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 "thunk.h"
25
26//#define DEBUG
27
28#define MAX_STRUCTS 128
29
30/* XXX: make it dynamic */
31StructEntry struct_entries[MAX_STRUCTS];
32
33static const argtype *thunk_type_next_ptr(const argtype *type_ptr);
34
35static inline const argtype *thunk_type_next(const argtype *type_ptr)
36{
37    int type;
38
39    type = *type_ptr++;
40    switch(type) {
41    case TYPE_CHAR:
42    case TYPE_SHORT:
43    case TYPE_INT:
44    case TYPE_LONGLONG:
45    case TYPE_ULONGLONG:
46    case TYPE_LONG:
47    case TYPE_ULONG:
48    case TYPE_PTRVOID:
49        return type_ptr;
50    case TYPE_PTR:
51        return thunk_type_next_ptr(type_ptr);
52    case TYPE_ARRAY:
53        return thunk_type_next_ptr(type_ptr + 1);
54    case TYPE_STRUCT:
55        return type_ptr + 1;
56    default:
57        return NULL;
58    }
59}
60
61static const argtype *thunk_type_next_ptr(const argtype *type_ptr)
62{
63    return thunk_type_next(type_ptr);
64}
65
66void thunk_register_struct(int id, const char *name, const argtype *types)
67{
68    const argtype *type_ptr;
69    StructEntry *se;
70    int nb_fields, offset, max_align, align, size, i, j;
71
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
115void thunk_register_struct_direct(int id, const char *name,
116                                  const 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 */
126const argtype *thunk_convert(void *dst, const void *src,
127                             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;
146#if HOST_LONG_BITS == 32 && TARGET_ABI_BITS == 32
147    case TYPE_LONG:
148    case TYPE_ULONG:
149    case TYPE_PTRVOID:
150        *(uint32_t *)dst = tswap32(*(uint32_t *)src);
151        break;
152#elif HOST_LONG_BITS == 64 && TARGET_ABI_BITS == 32
153    case TYPE_LONG:
154    case TYPE_ULONG:
155    case TYPE_PTRVOID:
156        if (to_host) {
157            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            }
163        } else {
164            *(uint32_t *)dst = tswap32(*(uint64_t *)src & 0xffffffff);
165        }
166        break;
167#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;
188#else
189#warning unsupported conversion
190#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;
218
219            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++) {
231                    field_types = thunk_convert(d + dst_offsets[i],
232                                                s + src_offsets[i],
233                                                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 */
250unsigned int target_to_host_bitmask(unsigned int x86_mask,
251                                    const bitmask_transtbl * trans_tbl)
252{
253    const 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
264unsigned int host_to_target_bitmask(unsigned int alpha_mask,
265                                    const bitmask_transtbl * trans_tbl)
266{
267    const 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) {
272	    x86_mask |= btp->x86_bits;
273	}
274    }
275    return(x86_mask);
276}
277
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 */
289