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, write to the Free Software

    18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    19  */

    20 #include <stdlib.h>

    21 #include <stdio.h>

    22 #include <stdarg.h>

    23 

    24 #include "qemu.h"

    25 #include "thunk.h"

    26 

    27 //#define DEBUG

    28 

    29 #define MAX_STRUCTS 128

    30 

    31 /* XXX: make it dynamic */

    32 StructEntry struct_entries[MAX_STRUCTS];

    33 

    34 static const argtype *thunk_type_next_ptr(const argtype *type_ptr);

    35 

    36 static inline const argtype *thunk_type_next(const argtype *type_ptr)

    37 {

    38     int type;

    39 

    40     type = *type_ptr++;

    41     switch(type) {

    42     case TYPE_CHAR:

    43     case TYPE_SHORT:

    44     case TYPE_INT:

    45     case TYPE_LONGLONG:

    46     case TYPE_ULONGLONG:

    47     case TYPE_LONG:

    48     case TYPE_ULONG:

    49     case TYPE_PTRVOID:

    50         return type_ptr;

    51     case TYPE_PTR:

    52         return thunk_type_next_ptr(type_ptr);

    53     case TYPE_ARRAY:

    54         return thunk_type_next_ptr(type_ptr + 1);

    55     case TYPE_STRUCT:

    56         return type_ptr + 1;

    57     default:

    58         return NULL;

    59     }

    60 }

    61 

    62 static const argtype *thunk_type_next_ptr(const argtype *type_ptr)

    63 {

    64     return thunk_type_next(type_ptr);

    65 }

    66 

    67 void thunk_register_struct(int id, const char *name, const argtype *types)

    68 {

    69     const argtype *type_ptr;

    70     StructEntry *se;

    71     int nb_fields, offset, max_align, align, size, i, j;

    72 

    73     se = struct_entries + id;

    74 

    75     /* first we count the number of fields */

    76     type_ptr = types;

    77     nb_fields = 0;

    78     while (*type_ptr != TYPE_NULL) {

    79         type_ptr = thunk_type_next(type_ptr);

    80         nb_fields++;

    81     }

    82     se->field_types = types;

    83     se->nb_fields = nb_fields;

    84     se->name = name;

    85 #ifdef DEBUG

    86     printf("struct %s: id=%d nb_fields=%d\n",

    87            se->name, id, se->nb_fields);

    88 #endif

    89     /* now we can alloc the data */

    90 

    91     for(i = 0;i < 2; i++) {

    92         offset = 0;

    93         max_align = 1;

    94         se->field_offsets[i] = malloc(nb_fields * sizeof(int));

    95         type_ptr = se->field_types;

    96         for(j = 0;j < nb_fields; j++) {

    97             size = thunk_type_size(type_ptr, i);

    98             align = thunk_type_align(type_ptr, i);

    99             offset = (offset + align - 1) & ~(align - 1);

   100             se->field_offsets[i][j] = offset;

   101             offset += size;

   102             if (align > max_align)

   103                 max_align = align;

   104             type_ptr = thunk_type_next(type_ptr);

   105         }

   106         offset = (offset + max_align - 1) & ~(max_align - 1);

   107         se->size[i] = offset;

   108         se->align[i] = max_align;

   109 #ifdef DEBUG

   110         printf("%s: size=%d align=%d\n",

   111                i == THUNK_HOST ? "host" : "target", offset, max_align);

   112 #endif

   113     }

   114 }

   115 

   116 void thunk_register_struct_direct(int id, const char *name,

   117                                   const StructEntry *se1)

   118 {

   119     StructEntry *se;

   120     se = struct_entries + id;

   121     *se = *se1;

   122     se->name = name;

   123 }

   124 

   125 

   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)

   129 {

   130     int type;

   131 

   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_ARRAY:

   193         {

   194             int array_length, i, dst_size, src_size;

   195             const uint8_t *s;

   196             uint8_t  *d;

   197 

   198             array_length = *type_ptr++;

   199             dst_size = thunk_type_size(type_ptr, to_host);

   200             src_size = thunk_type_size(type_ptr, 1 - to_host);

   201             d = dst;

   202             s = src;

   203             for(i = 0;i < array_length; i++) {

   204                 thunk_convert(d, s, type_ptr, to_host);

   205                 d += dst_size;

   206                 s += src_size;

   207             }

   208             type_ptr = thunk_type_next(type_ptr);

   209         }

   210         break;

   211     case TYPE_STRUCT:

   212         {

   213             int i;

   214             const StructEntry *se;

   215             const uint8_t *s;

   216             uint8_t  *d;

   217             const argtype *field_types;

   218             const int *dst_offsets, *src_offsets;

   219 

   220             se = struct_entries + *type_ptr++;

   221             if (se->convert[0] != NULL) {

   222                 /* specific conversion is needed */

   223                 (*se->convert[to_host])(dst, src);

   224             } else {

   225                 /* standard struct conversion */

   226                 field_types = se->field_types;

   227                 dst_offsets = se->field_offsets[to_host];

   228                 src_offsets = se->field_offsets[1 - to_host];

   229                 d = dst;

   230                 s = src;

   231                 for(i = 0;i < se->nb_fields; i++) {

   232                     field_types = thunk_convert(d + dst_offsets[i],

   233                                                 s + src_offsets[i],

   234                                                 field_types, to_host);

   235                 }

   236             }

   237         }

   238         break;

   239     default:

   240         fprintf(stderr, "Invalid type 0x%x\n", type);

   241         break;

   242     }

   243     return type_ptr;

   244 }

   245 

   246 /* from em86 */

   247 

   248 /* Utility function: Table-driven functions to translate bitmasks

   249  * between X86 and Alpha formats...

   250  */

   251 unsigned int target_to_host_bitmask(unsigned int x86_mask,

   252                                     const bitmask_transtbl * trans_tbl)

   253 {

   254     const bitmask_transtbl *btp;

   255     unsigned int	alpha_mask = 0;

   256 

   257     for(btp = trans_tbl; btp->x86_mask && btp->alpha_mask; btp++) {

   258 	if((x86_mask & btp->x86_mask) == btp->x86_bits) {

   259 	    alpha_mask |= btp->alpha_bits;

   260 	}

   261     }

   262     return(alpha_mask);

   263 }

   264 

   265 unsigned int host_to_target_bitmask(unsigned int alpha_mask,

   266                                     const bitmask_transtbl * trans_tbl)

   267 {

   268     const bitmask_transtbl *btp;

   269     unsigned int	x86_mask = 0;

   270 

   271     for(btp = trans_tbl; btp->x86_mask && btp->alpha_mask; btp++) {

   272 	if((alpha_mask & btp->alpha_mask) == btp->alpha_bits) {

   273 	    x86_mask |= btp->x86_bits;

   274 	}

   275     }

   276     return(x86_mask);

   277 }

   278 

   279 #ifndef NO_THUNK_TYPE_SIZE

   280 int thunk_type_size_array(const argtype *type_ptr, int is_host)

   281 {

   282     return thunk_type_size(type_ptr, is_host);

   283 }

   284 

   285 int thunk_type_align_array(const argtype *type_ptr, int is_host)

   286 {

   287     return thunk_type_align(type_ptr, is_host);

   288 }

   289 #endif /* ndef NO_THUNK_TYPE_SIZE */