316 lines
8.4 KiB
C
316 lines
8.4 KiB
C
|
/*
|
||
|
* Generic thunking code to convert data between host and target CPU
|
||
|
*
|
||
|
* Copyright (c) 2003 Fabrice Bellard
|
||
|
*
|
||
|
* This program is free software; you can redistribute it and/or modify
|
||
|
* it under the terms of the GNU General Public License as published by
|
||
|
* the Free Software Foundation; either version 2 of the License, or
|
||
|
* (at your option) any later version.
|
||
|
*
|
||
|
* This program is distributed in the hope that it will be useful,
|
||
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
|
* GNU General Public License for more details.
|
||
|
*
|
||
|
* You should have received a copy of the GNU General Public License
|
||
|
* along with this program; if not, write to the Free Software
|
||
|
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||
|
*/
|
||
|
#include <stdlib.h>
|
||
|
#include <stdio.h>
|
||
|
#include <stdarg.h>
|
||
|
|
||
|
#include "gemu.h"
|
||
|
#include "thunk.h"
|
||
|
|
||
|
//#define DEBUG
|
||
|
|
||
|
#define MAX_STRUCTS 128
|
||
|
|
||
|
/* XXX: make it dynamic */
|
||
|
static StructEntry struct_entries[MAX_STRUCTS];
|
||
|
|
||
|
static inline int thunk_type_size(const argtype *type_ptr, int is_host)
|
||
|
{
|
||
|
int type, size;
|
||
|
const StructEntry *se;
|
||
|
|
||
|
type = *type_ptr;
|
||
|
switch(type) {
|
||
|
case TYPE_CHAR:
|
||
|
return 1;
|
||
|
case TYPE_SHORT:
|
||
|
return 2;
|
||
|
case TYPE_INT:
|
||
|
return 4;
|
||
|
case TYPE_LONGLONG:
|
||
|
case TYPE_ULONGLONG:
|
||
|
return 8;
|
||
|
case TYPE_LONG:
|
||
|
case TYPE_ULONG:
|
||
|
case TYPE_PTRVOID:
|
||
|
case TYPE_PTR:
|
||
|
if (is_host) {
|
||
|
return HOST_LONG_SIZE;
|
||
|
} else {
|
||
|
return TARGET_LONG_SIZE;
|
||
|
}
|
||
|
break;
|
||
|
case TYPE_ARRAY:
|
||
|
size = type_ptr[1];
|
||
|
return size * thunk_type_size(type_ptr + 2, is_host);
|
||
|
case TYPE_STRUCT:
|
||
|
se = struct_entries + type_ptr[1];
|
||
|
return se->size[is_host];
|
||
|
default:
|
||
|
return -1;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
static inline int thunk_type_align(const argtype *type_ptr, int is_host)
|
||
|
{
|
||
|
int type;
|
||
|
const StructEntry *se;
|
||
|
|
||
|
type = *type_ptr;
|
||
|
switch(type) {
|
||
|
case TYPE_CHAR:
|
||
|
return 1;
|
||
|
case TYPE_SHORT:
|
||
|
return 2;
|
||
|
case TYPE_INT:
|
||
|
return 4;
|
||
|
case TYPE_LONGLONG:
|
||
|
case TYPE_ULONGLONG:
|
||
|
return 8;
|
||
|
case TYPE_LONG:
|
||
|
case TYPE_ULONG:
|
||
|
case TYPE_PTRVOID:
|
||
|
case TYPE_PTR:
|
||
|
if (is_host) {
|
||
|
return HOST_LONG_SIZE;
|
||
|
} else {
|
||
|
return TARGET_LONG_SIZE;
|
||
|
}
|
||
|
break;
|
||
|
case TYPE_ARRAY:
|
||
|
return thunk_type_align(type_ptr + 2, is_host);
|
||
|
case TYPE_STRUCT:
|
||
|
se = struct_entries + type_ptr[1];
|
||
|
return se->align[is_host];
|
||
|
default:
|
||
|
return -1;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
static inline const argtype *thunk_type_next(const argtype *type_ptr)
|
||
|
{
|
||
|
int type;
|
||
|
|
||
|
type = *type_ptr++;
|
||
|
switch(type) {
|
||
|
case TYPE_CHAR:
|
||
|
case TYPE_SHORT:
|
||
|
case TYPE_INT:
|
||
|
case TYPE_LONGLONG:
|
||
|
case TYPE_ULONGLONG:
|
||
|
case TYPE_LONG:
|
||
|
case TYPE_ULONG:
|
||
|
case TYPE_PTRVOID:
|
||
|
return type_ptr;
|
||
|
case TYPE_PTR:
|
||
|
return thunk_type_next(type_ptr);
|
||
|
case TYPE_ARRAY:
|
||
|
return thunk_type_next(type_ptr + 1);
|
||
|
case TYPE_STRUCT:
|
||
|
return type_ptr + 1;
|
||
|
default:
|
||
|
return NULL;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void thunk_register_struct(int id, const char *name, const argtype *types)
|
||
|
{
|
||
|
const argtype *type_ptr;
|
||
|
StructEntry *se;
|
||
|
int nb_fields, offset, max_align, align, size, i, j;
|
||
|
|
||
|
se = struct_entries + id;
|
||
|
|
||
|
/* first we count the number of fields */
|
||
|
type_ptr = types;
|
||
|
nb_fields = 0;
|
||
|
while (*type_ptr != TYPE_NULL) {
|
||
|
type_ptr = thunk_type_next(type_ptr);
|
||
|
nb_fields++;
|
||
|
}
|
||
|
se->field_types = types;
|
||
|
se->nb_fields = nb_fields;
|
||
|
se->name = name;
|
||
|
#ifdef DEBUG
|
||
|
printf("struct %s: id=%d nb_fields=%d\n",
|
||
|
se->name, id, se->nb_fields);
|
||
|
#endif
|
||
|
/* now we can alloc the data */
|
||
|
|
||
|
for(i = 0;i < 2; i++) {
|
||
|
offset = 0;
|
||
|
max_align = 1;
|
||
|
se->field_offsets[i] = malloc(nb_fields * sizeof(int));
|
||
|
type_ptr = se->field_types;
|
||
|
for(j = 0;j < nb_fields; j++) {
|
||
|
size = thunk_type_size(type_ptr, i);
|
||
|
align = thunk_type_align(type_ptr, i);
|
||
|
offset = (offset + align - 1) & ~(align - 1);
|
||
|
se->field_offsets[i][j] = offset;
|
||
|
offset += size;
|
||
|
if (align > max_align)
|
||
|
max_align = align;
|
||
|
}
|
||
|
offset = (offset + max_align - 1) & ~(max_align - 1);
|
||
|
se->size[i] = offset;
|
||
|
se->align[i] = max_align;
|
||
|
#ifdef DEBUG
|
||
|
printf("%s: size=%d align=%d\n",
|
||
|
i == THUNK_HOST ? "host" : "target", offset, max_align);
|
||
|
#endif
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void thunk_register_struct_direct(int id, const char *name, StructEntry *se1)
|
||
|
{
|
||
|
StructEntry *se;
|
||
|
se = struct_entries + id;
|
||
|
*se = *se1;
|
||
|
se->name = name;
|
||
|
}
|
||
|
|
||
|
|
||
|
/* now we can define the main conversion functions */
|
||
|
const argtype *thunk_convert(void *dst, const void *src,
|
||
|
const argtype *type_ptr, int to_host)
|
||
|
{
|
||
|
int type;
|
||
|
|
||
|
type = *type_ptr++;
|
||
|
switch(type) {
|
||
|
case TYPE_CHAR:
|
||
|
*(uint8_t *)dst = *(uint8_t *)src;
|
||
|
break;
|
||
|
case TYPE_SHORT:
|
||
|
*(uint16_t *)dst = tswap16(*(uint16_t *)src);
|
||
|
break;
|
||
|
case TYPE_INT:
|
||
|
*(uint32_t *)dst = tswap32(*(uint32_t *)src);
|
||
|
break;
|
||
|
case TYPE_LONGLONG:
|
||
|
case TYPE_ULONGLONG:
|
||
|
*(uint64_t *)dst = tswap64(*(uint64_t *)src);
|
||
|
break;
|
||
|
#if HOST_LONG_BITS == 32 && TARGET_LONG_BITS == 32
|
||
|
case TYPE_LONG:
|
||
|
case TYPE_ULONG:
|
||
|
case TYPE_PTRVOID:
|
||
|
*(uint32_t *)dst = tswap32(*(uint32_t *)src);
|
||
|
break;
|
||
|
#elif HOST_LONG_BITS == 64 && TARGET_LONG_BITS == 32
|
||
|
case TYPE_LONG:
|
||
|
case TYPE_ULONG:
|
||
|
case TYPE_PTRVOID:
|
||
|
if (target_to_host) {
|
||
|
*(uint64_t *)dst = tswap32(*(uint32_t *)src);
|
||
|
} else {
|
||
|
*(uint32_t *)dst = tswap32(*(uint64_t *)src & 0xffffffff);
|
||
|
}
|
||
|
break;
|
||
|
#else
|
||
|
#error unsupported conversion
|
||
|
#endif
|
||
|
case TYPE_ARRAY:
|
||
|
{
|
||
|
int array_length, i, dst_size, src_size;
|
||
|
const uint8_t *s;
|
||
|
uint8_t *d;
|
||
|
|
||
|
array_length = *type_ptr++;
|
||
|
dst_size = thunk_type_size(type_ptr, to_host);
|
||
|
src_size = thunk_type_size(type_ptr, 1 - to_host);
|
||
|
d = dst;
|
||
|
s = src;
|
||
|
for(i = 0;i < array_length; i++) {
|
||
|
thunk_convert(d, s, type_ptr, to_host);
|
||
|
d += dst_size;
|
||
|
s += src_size;
|
||
|
}
|
||
|
type_ptr = thunk_type_next(type_ptr);
|
||
|
}
|
||
|
break;
|
||
|
case TYPE_STRUCT:
|
||
|
{
|
||
|
int i;
|
||
|
const StructEntry *se;
|
||
|
const uint8_t *s;
|
||
|
uint8_t *d;
|
||
|
const argtype *field_types;
|
||
|
const int *dst_offsets, *src_offsets;
|
||
|
|
||
|
se = struct_entries + *type_ptr++;
|
||
|
if (se->convert[0] != NULL) {
|
||
|
/* specific conversion is needed */
|
||
|
(*se->convert[to_host])(dst, src);
|
||
|
} else {
|
||
|
/* standard struct conversion */
|
||
|
field_types = se->field_types;
|
||
|
dst_offsets = se->field_offsets[to_host];
|
||
|
src_offsets = se->field_offsets[1 - to_host];
|
||
|
d = dst;
|
||
|
s = src;
|
||
|
for(i = 0;i < se->nb_fields; i++) {
|
||
|
field_types = thunk_convert(d + dst_offsets[i],
|
||
|
s + src_offsets[i],
|
||
|
field_types, to_host);
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
break;
|
||
|
default:
|
||
|
fprintf(stderr, "Invalid type 0x%x\n", type);
|
||
|
break;
|
||
|
}
|
||
|
return type_ptr;
|
||
|
}
|
||
|
|
||
|
/* from em86 */
|
||
|
|
||
|
/* Utility function: Table-driven functions to translate bitmasks
|
||
|
* between X86 and Alpha formats...
|
||
|
*/
|
||
|
unsigned int target_to_host_bitmask(unsigned int x86_mask,
|
||
|
bitmask_transtbl * trans_tbl)
|
||
|
{
|
||
|
bitmask_transtbl * btp;
|
||
|
unsigned int alpha_mask = 0;
|
||
|
|
||
|
for(btp = trans_tbl; btp->x86_mask && btp->alpha_mask; btp++) {
|
||
|
if((x86_mask & btp->x86_mask) == btp->x86_bits) {
|
||
|
alpha_mask |= btp->alpha_bits;
|
||
|
}
|
||
|
}
|
||
|
return(alpha_mask);
|
||
|
}
|
||
|
|
||
|
unsigned int host_to_target_bitmask(unsigned int alpha_mask,
|
||
|
bitmask_transtbl * trans_tbl)
|
||
|
{
|
||
|
bitmask_transtbl * btp;
|
||
|
unsigned int x86_mask = 0;
|
||
|
|
||
|
for(btp = trans_tbl; btp->x86_mask && btp->alpha_mask; btp++) {
|
||
|
if((alpha_mask & btp->alpha_mask) == btp->alpha_bits) {
|
||
|
x86_mask |= btp->x86_mask;
|
||
|
}
|
||
|
}
|
||
|
return(x86_mask);
|
||
|
}
|