thunk.h 4.9 KB
Newer Older
bellard's avatar
bellard committed
1 2
/*
 *  Generic thunking code to convert data between host and target CPU
3
 *
bellard's avatar
bellard committed
4 5 6 7 8 9 10 11 12 13 14 15 16
 *  Copyright (c) 2003 Fabrice Bellard
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * 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/>.
bellard's avatar
bellard committed
18
 */
19 20 21 22
#ifndef THUNK_H
#define THUNK_H

#include <inttypes.h>
bellard's avatar
bellard committed
23
#include "cpu.h"
bellard's avatar
bellard committed
24

25 26 27 28 29 30 31 32 33 34 35 36 37 38 39
/* types enums definitions */

typedef enum argtype {
    TYPE_NULL,
    TYPE_CHAR,
    TYPE_SHORT,
    TYPE_INT,
    TYPE_LONG,
    TYPE_ULONG,
    TYPE_PTRVOID, /* pointer on unknown data */
    TYPE_LONGLONG,
    TYPE_ULONGLONG,
    TYPE_PTR,
    TYPE_ARRAY,
    TYPE_STRUCT,
40
    TYPE_OLDDEVT,
41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70
} argtype;

#define MK_PTR(type) TYPE_PTR, type
#define MK_ARRAY(type, size) TYPE_ARRAY, size, type
#define MK_STRUCT(id) TYPE_STRUCT, id

#define THUNK_TARGET 0
#define THUNK_HOST   1

typedef struct {
    /* standard struct handling */
    const argtype *field_types;
    int nb_fields;
    int *field_offsets[2];
    /* special handling */
    void (*convert[2])(void *dst, const void *src);
    int size[2];
    int align[2];
    const char *name;
} StructEntry;

/* Translation table for bitmasks... */
typedef struct bitmask_transtbl {
	unsigned int	x86_mask;
	unsigned int	x86_bits;
	unsigned int	alpha_mask;
	unsigned int	alpha_bits;
} bitmask_transtbl;

void thunk_register_struct(int id, const char *name, const argtype *types);
blueswir1's avatar
blueswir1 committed
71 72
void thunk_register_struct_direct(int id, const char *name,
                                  const StructEntry *se1);
73
const argtype *thunk_convert(void *dst, const void *src,
74
                             const argtype *type_ptr, int to_host);
bellard's avatar
bellard committed
75
#ifndef NO_THUNK_TYPE_SIZE
76

77 78
extern StructEntry struct_entries[];

79 80 81
int thunk_type_size_array(const argtype *type_ptr, int is_host);
int thunk_type_align_array(const argtype *type_ptr, int is_host);

82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102
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) {
Stefan Weil's avatar
Stefan Weil committed
103
            return sizeof(void *);
104
        } else {
105
            return TARGET_ABI_BITS / 8;
106 107
        }
        break;
108 109 110 111 112 113 114 115
    case TYPE_OLDDEVT:
        if (is_host) {
#if defined(HOST_X86_64)
            return 8;
#elif defined(HOST_ALPHA) || defined(HOST_IA64) || defined(HOST_MIPS) || \
      defined(HOST_PARISC) || defined(HOST_SPARC64)
            return 4;
#elif defined(HOST_PPC)
116
            return sizeof(void *);
117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132
#else
            return 2;
#endif
        } else {
#if defined(TARGET_X86_64)
            return 8;
#elif defined(TARGET_ALPHA) || defined(TARGET_IA64) || defined(TARGET_MIPS) || \
      defined(TARGET_PARISC) || defined(TARGET_SPARC64)
            return 4;
#elif defined(TARGET_PPC)
            return TARGET_ABI_BITS / 8;
#else
            return 2;
#endif
        }
        break;
133 134
    case TYPE_ARRAY:
        size = type_ptr[1];
135
        return size * thunk_type_size_array(type_ptr + 2, is_host);
136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164
    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) {
Stefan Weil's avatar
Stefan Weil committed
165
            return sizeof(void *);
166
        } else {
167
            return TARGET_ABI_BITS / 8;
168 169
        }
        break;
170 171
    case TYPE_OLDDEVT:
        return thunk_type_size(type_ptr, is_host);
172
    case TYPE_ARRAY:
173
        return thunk_type_align_array(type_ptr + 2, is_host);
174 175 176 177 178 179 180 181
    case TYPE_STRUCT:
        se = struct_entries + type_ptr[1];
        return se->align[is_host];
    default:
        return -1;
    }
}

bellard's avatar
bellard committed
182 183
#endif /* NO_THUNK_TYPE_SIZE */

184
unsigned int target_to_host_bitmask(unsigned int x86_mask,
blueswir1's avatar
blueswir1 committed
185
                                    const bitmask_transtbl * trans_tbl);
186
unsigned int host_to_target_bitmask(unsigned int alpha_mask,
blueswir1's avatar
blueswir1 committed
187
                                    const bitmask_transtbl * trans_tbl);
188 189

#endif