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
20#ifndef THUNK_H
21#define THUNK_H
22
23#include "cpu.h"
24#include "exec/user/abitypes.h"
25
26/* types enums definitions */
27
28typedef enum argtype {
29 TYPE_NULL,
30 TYPE_CHAR,
31 TYPE_SHORT,
32 TYPE_INT,
33 TYPE_LONG,
34 TYPE_ULONG,
35 TYPE_PTRVOID, /* pointer on unknown data */
36 TYPE_LONGLONG,
37 TYPE_ULONGLONG,
38 TYPE_PTR,
39 TYPE_ARRAY,
40 TYPE_STRUCT,
41 TYPE_OLDDEVT,
42} argtype;
43
44#define MK_PTR(type) TYPE_PTR, type
45#define MK_ARRAY(type, size) TYPE_ARRAY, size, type
46#define MK_STRUCT(id) TYPE_STRUCT, id
47
48#define THUNK_TARGET 0
49#define THUNK_HOST 1
50
51typedef struct {
52 /* standard struct handling */
53 const argtype *field_types;
54 int nb_fields;
55 int *field_offsets[2];
56 /* special handling */
57 void (*convert[2])(void *dst, const void *src);
58 int size[2];
59 int align[2];
60 const char *name;
61} StructEntry;
62
63/* Translation table for bitmasks... */
64typedef struct bitmask_transtbl {
65 unsigned int target_mask;
66 unsigned int target_bits;
67 unsigned int host_mask;
68 unsigned int host_bits;
69} bitmask_transtbl;
70
71void thunk_register_struct(int id, const char *name, const argtype *types);
72void thunk_register_struct_direct(int id, const char *name,
73 const StructEntry *se1);
74const argtype *thunk_convert(void *dst, const void *src,
75 const argtype *type_ptr, int to_host);
76
77extern StructEntry *struct_entries;
78
79int thunk_type_size_array(const argtype *type_ptr, int is_host);
80int thunk_type_align_array(const argtype *type_ptr, int is_host);
81
82static inline int thunk_type_size(const argtype *type_ptr, int is_host)
83{
84 int type, size;
85 const StructEntry *se;
86
87 type = *type_ptr;
88 switch(type) {
89 case TYPE_CHAR:
90 return 1;
91 case TYPE_SHORT:
92 return 2;
93 case TYPE_INT:
94 return 4;
95 case TYPE_LONGLONG:
96 case TYPE_ULONGLONG:
97 return 8;
98 case TYPE_LONG:
99 case TYPE_ULONG:
100 case TYPE_PTRVOID:
101 case TYPE_PTR:
102 if (is_host) {
103 return sizeof(void *);
104 } else {
105 return TARGET_ABI_BITS / 8;
106 }
107 break;
108 case TYPE_OLDDEVT:
109 if (is_host) {
110#if defined(HOST_X86_64)
111 return 8;
112#elif defined(HOST_ALPHA) || defined(HOST_IA64) || defined(HOST_MIPS) || \
113 defined(HOST_PARISC) || defined(HOST_SPARC64)
114 return 4;
115#elif defined(HOST_PPC)
116 return sizeof(void *);
117#else
118 return 2;
119#endif
120 } else {
121#if defined(TARGET_X86_64)
122 return 8;
123#elif defined(TARGET_ALPHA) || defined(TARGET_IA64) || defined(TARGET_MIPS) || \
124 defined(TARGET_PARISC) || defined(TARGET_SPARC64)
125 return 4;
126#elif defined(TARGET_PPC)
127 return TARGET_ABI_BITS / 8;
128#else
129 return 2;
130#endif
131 }
132 break;
133 case TYPE_ARRAY:
134 size = type_ptr[1];
135 return size * thunk_type_size_array(type_ptr + 2, is_host);
136 case TYPE_STRUCT:
137 se = struct_entries + type_ptr[1];
138 return se->size[is_host];
139 default:
140 g_assert_not_reached();
141 }
142}
143
144static inline int thunk_type_align(const argtype *type_ptr, int is_host)
145{
146 int type;
147 const StructEntry *se;
148
149 type = *type_ptr;
150 switch(type) {
151 case TYPE_CHAR:
152 return 1;
153 case TYPE_SHORT:
154 if (is_host) {
155 return __alignof__(short);
156 } else {
157 return ABI_SHORT_ALIGNMENT;
158 }
159 case TYPE_INT:
160 if (is_host) {
161 return __alignof__(int);
162 } else {
163 return ABI_INT_ALIGNMENT;
164 }
165 case TYPE_LONGLONG:
166 case TYPE_ULONGLONG:
167 if (is_host) {
168 return __alignof__(long long);
169 } else {
170 return ABI_LLONG_ALIGNMENT;
171 }
172 case TYPE_LONG:
173 case TYPE_ULONG:
174 case TYPE_PTRVOID:
175 case TYPE_PTR:
176 if (is_host) {
177 return __alignof__(long);
178 } else {
179 return ABI_LONG_ALIGNMENT;
180 }
181 break;
182 case TYPE_OLDDEVT:
183 return thunk_type_size(type_ptr, is_host);
184 case TYPE_ARRAY:
185 return thunk_type_align_array(type_ptr + 2, is_host);
186 case TYPE_STRUCT:
187 se = struct_entries + type_ptr[1];
188 return se->align[is_host];
189 default:
190 g_assert_not_reached();
191 }
192}
193
194unsigned int target_to_host_bitmask(unsigned int target_mask,
195 const bitmask_transtbl * trans_tbl);
196unsigned int host_to_target_bitmask(unsigned int host_mask,
197 const bitmask_transtbl * trans_tbl);
198
199void thunk_init(unsigned int max_structs);
200
201#endif
202