LXR 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 "qemu/osdep.h"
  20
  21#include "qemu.h"
  22#include "exec/user/thunk.h"
  23
  24//#define DEBUG
  25
  26static unsigned int max_struct_entries;
  27StructEntry *struct_entries;
  28
  29static const argtype *thunk_type_next_ptr(const argtype *type_ptr);
  30
  31static inline const argtype *thunk_type_next(const argtype *type_ptr)
  32{
  33    int type;
  34
  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    }
  56}
  57
  58static const argtype *thunk_type_next_ptr(const argtype *type_ptr)
  59{
  60    return thunk_type_next(type_ptr);
  61}
  62
  63void thunk_register_struct(int id, const char *name, const argtype *types)
  64{
  65    const argtype *type_ptr;
  66    StructEntry *se;
  67    int nb_fields, offset, max_align, align, size, i, j;
  68
  69    assert(id < max_struct_entries);
  70    se = struct_entries + id;
  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    se->field_types = types;
  80    se->nb_fields = nb_fields;
  81    se->name = name;
  82#ifdef DEBUG
  83    printf("struct %s: id=%d nb_fields=%d\n",
  84           se->name, id, se->nb_fields);
  85#endif
  86    /* now we can alloc the data */
  87
  88    for(i = 0;i < 2; i++) {
  89        offset = 0;
  90        max_align = 1;
  91        se->field_offsets[i] = malloc(nb_fields * sizeof(int));
  92        type_ptr = se->field_types;
  93        for(j = 0;j < nb_fields; j++) {
  94            size = thunk_type_size(type_ptr, i);
  95            align = thunk_type_align(type_ptr, i);
  96            offset = (offset + align - 1) & ~(align - 1);
  97            se->field_offsets[i][j] = offset;
  98            offset += size;
  99            if (align > max_align)
 100                max_align = align;
 101            type_ptr = thunk_type_next(type_ptr);
 102        }
 103        offset = (offset + max_align - 1) & ~(max_align - 1);
 104        se->size[i] = offset;
 105        se->align[i] = max_align;
 106#ifdef DEBUG
 107        printf("%s: size=%d align=%d\n",
 108               i == THUNK_HOST ? "host" : "target", offset, max_align);
 109#endif
 110    }
 111}
 112
 113void thunk_register_struct_direct(int id, const char *name,
 114                                  const StructEntry *se1)
 115{
 116    StructEntry *se;
 117
 118    assert(id < max_struct_entries);
 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_OLDDEVT:
 192    {
 193        uint64_t val = 0;
 194        switch (thunk_type_size(type_ptr - 1, !to_host)) {
 195        case 2:
 196            val = *(uint16_t *)src;
 197            break;
 198        case 4:
 199            val = *(uint32_t *)src;
 200            break;
 201        case 8:
 202            val = *(uint64_t *)src;
 203            break;
 204        }
 205        switch (thunk_type_size(type_ptr - 1, to_host)) {
 206        case 2:
 207            *(uint16_t *)dst = tswap16(val);
 208            break;
 209        case 4:
 210            *(uint32_t *)dst = tswap32(val);
 211            break;
 212        case 8:
 213            *(uint64_t *)dst = tswap64(val);
 214            break;
 215        }
 216        break;
 217    }
 218    case TYPE_ARRAY:
 219        {
 220            int array_length, i, dst_size, src_size;
 221            const uint8_t *s;
 222            uint8_t  *d;
 223
 224            array_length = *type_ptr++;
 225            dst_size = thunk_type_size(type_ptr, to_host);
 226            src_size = thunk_type_size(type_ptr, 1 - to_host);
 227            d = dst;
 228            s = src;
 229            for(i = 0;i < array_length; i++) {
 230                thunk_convert(d, s, type_ptr, to_host);
 231                d += dst_size;
 232                s += src_size;
 233            }
 234            type_ptr = thunk_type_next(type_ptr);
 235        }
 236        break;
 237    case TYPE_STRUCT:
 238        {
 239            int i;
 240            const StructEntry *se;
 241            const uint8_t *s;
 242            uint8_t  *d;
 243            const argtype *field_types;
 244            const int *dst_offsets, *src_offsets;
 245
 246            assert(*type_ptr < max_struct_entries);
 247            se = struct_entries + *type_ptr++;
 248            if (se->convert[0] != NULL) {
 249                /* specific conversion is needed */
 250                (*se->convert[to_host])(dst, src);
 251            } else {
 252                /* standard struct conversion */
 253                field_types = se->field_types;
 254                dst_offsets = se->field_offsets[to_host];
 255                src_offsets = se->field_offsets[1 - to_host];
 256                d = dst;
 257                s = src;
 258                for(i = 0;i < se->nb_fields; i++) {
 259                    field_types = thunk_convert(d + dst_offsets[i],
 260                                                s + src_offsets[i],
 261                                                field_types, to_host);
 262                }
 263            }
 264        }
 265        break;
 266    default:
 267        fprintf(stderr, "Invalid type 0x%x\n", type);
 268        break;
 269    }
 270    return type_ptr;
 271}
 272
 273/* from em86 */
 274
 275/* Utility function: Table-driven functions to translate bitmasks
 276 * between X86 and Alpha formats...
 277 */
 278unsigned int target_to_host_bitmask(unsigned int x86_mask,
 279                                    const bitmask_transtbl * trans_tbl)
 280{
 281    const bitmask_transtbl *btp;
 282    unsigned int        alpha_mask = 0;
 283
 284    for(btp = trans_tbl; btp->x86_mask && btp->alpha_mask; btp++) {
 285        if((x86_mask & btp->x86_mask) == btp->x86_bits) {
 286            alpha_mask |= btp->alpha_bits;
 287        }
 288    }
 289    return(alpha_mask);
 290}
 291
 292unsigned int host_to_target_bitmask(unsigned int alpha_mask,
 293                                    const bitmask_transtbl * trans_tbl)
 294{
 295    const bitmask_transtbl *btp;
 296    unsigned int        x86_mask = 0;
 297
 298    for(btp = trans_tbl; btp->x86_mask && btp->alpha_mask; btp++) {
 299        if((alpha_mask & btp->alpha_mask) == btp->alpha_bits) {
 300            x86_mask |= btp->x86_bits;
 301        }
 302    }
 303    return(x86_mask);
 304}
 305
 306#ifndef NO_THUNK_TYPE_SIZE
 307int thunk_type_size_array(const argtype *type_ptr, int is_host)
 308{
 309    return thunk_type_size(type_ptr, is_host);
 310}
 311
 312int thunk_type_align_array(const argtype *type_ptr, int is_host)
 313{
 314    return thunk_type_align(type_ptr, is_host);
 315}
 316#endif /* ndef NO_THUNK_TYPE_SIZE */
 317
 318void thunk_init(unsigned int max_structs)
 319{
 320    max_struct_entries = max_structs;
 321    struct_entries = g_new0(StructEntry, max_structs);
 322}
 323