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 "thunk.h"
  25
  26 //#define DEBUG
  27
  28 #define MAX_STRUCTS 128
  29
  30 /* XXX: make it dynamic */
  31 StructEntry struct_entries[MAX_STRUCTS];
  32
  33 static const argtype *thunk_type_next_ptr(const argtype *type_ptr);
  34
  35 static 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
  61 static const argtype *thunk_type_next_ptr(const argtype *type_ptr)
  62 {
  63     return thunk_type_next(type_ptr);
  64 }
  65
  66 void 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
 115 void 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 */
 126 const 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  */
 250 unsigned 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
 264 unsigned 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
 279 int thunk_type_size_array(const argtype *type_ptr, int is_host)
 280 {
 281     return thunk_type_size(type_ptr, is_host);
 282 }
 283
 284 int 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 */