2 * Generic thunking code to convert data between host and target CPU
4 * Copyright (c) 2003 Fabrice Bellard
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.
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.
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., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301 USA
29 #define MAX_STRUCTS 128
31 /* XXX: make it dynamic */
32 StructEntry struct_entries
[MAX_STRUCTS
];
34 static const argtype
*thunk_type_next_ptr(const argtype
*type_ptr
);
36 static inline const argtype
*thunk_type_next(const argtype
*type_ptr
)
52 return thunk_type_next_ptr(type_ptr
);
54 return thunk_type_next_ptr(type_ptr
+ 1);
62 static const argtype
*thunk_type_next_ptr(const argtype
*type_ptr
)
64 return thunk_type_next(type_ptr
);
67 void thunk_register_struct(int id
, const char *name
, const argtype
*types
)
69 const argtype
*type_ptr
;
71 int nb_fields
, offset
, max_align
, align
, size
, i
, j
;
73 se
= struct_entries
+ id
;
75 /* first we count the number of fields */
78 while (*type_ptr
!= TYPE_NULL
) {
79 type_ptr
= thunk_type_next(type_ptr
);
82 se
->field_types
= types
;
83 se
->nb_fields
= nb_fields
;
86 printf("struct %s: id=%d nb_fields=%d\n",
87 se
->name
, id
, se
->nb_fields
);
89 /* now we can alloc the data */
91 for(i
= 0;i
< 2; i
++) {
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
;
102 if (align
> max_align
)
104 type_ptr
= thunk_type_next(type_ptr
);
106 offset
= (offset
+ max_align
- 1) & ~(max_align
- 1);
107 se
->size
[i
] = offset
;
108 se
->align
[i
] = max_align
;
110 printf("%s: size=%d align=%d\n",
111 i
== THUNK_HOST
? "host" : "target", offset
, max_align
);
116 void thunk_register_struct_direct(int id
, const char *name
,
117 const StructEntry
*se1
)
120 se
= struct_entries
+ id
;
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
)
135 *(uint8_t *)dst
= *(uint8_t *)src
;
138 *(uint16_t *)dst
= tswap16(*(uint16_t *)src
);
141 *(uint32_t *)dst
= tswap32(*(uint32_t *)src
);
145 *(uint64_t *)dst
= tswap64(*(uint64_t *)src
);
147 #if HOST_LONG_BITS == 32 && TARGET_ABI_BITS == 32
151 *(uint32_t *)dst
= tswap32(*(uint32_t *)src
);
153 #elif HOST_LONG_BITS == 64 && TARGET_ABI_BITS == 32
158 if (type
== TYPE_LONG
) {
160 *(uint64_t *)dst
= (int32_t)tswap32(*(uint32_t *)src
);
162 *(uint64_t *)dst
= tswap32(*(uint32_t *)src
);
165 *(uint32_t *)dst
= tswap32(*(uint64_t *)src
& 0xffffffff);
168 #elif HOST_LONG_BITS == 64 && TARGET_ABI_BITS == 64
172 *(uint64_t *)dst
= tswap64(*(uint64_t *)src
);
174 #elif HOST_LONG_BITS == 32 && TARGET_ABI_BITS == 64
179 *(uint32_t *)dst
= tswap64(*(uint64_t *)src
);
181 if (type
== TYPE_LONG
) {
183 *(uint64_t *)dst
= tswap64(*(int32_t *)src
);
185 *(uint64_t *)dst
= tswap64(*(uint32_t *)src
);
190 #warning unsupported conversion
194 int array_length
, i
, dst_size
, src_size
;
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
);
203 for(i
= 0;i
< array_length
; i
++) {
204 thunk_convert(d
, s
, type_ptr
, to_host
);
208 type_ptr
= thunk_type_next(type_ptr
);
214 const StructEntry
*se
;
217 const argtype
*field_types
;
218 const int *dst_offsets
, *src_offsets
;
220 se
= struct_entries
+ *type_ptr
++;
221 if (se
->convert
[0] != NULL
) {
222 /* specific conversion is needed */
223 (*se
->convert
[to_host
])(dst
, src
);
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
];
231 for(i
= 0;i
< se
->nb_fields
; i
++) {
232 field_types
= thunk_convert(d
+ dst_offsets
[i
],
234 field_types
, to_host
);
240 fprintf(stderr
, "Invalid type 0x%x\n", type
);
248 /* Utility function: Table-driven functions to translate bitmasks
249 * between X86 and Alpha formats...
251 unsigned int target_to_host_bitmask(unsigned int x86_mask
,
252 const bitmask_transtbl
* trans_tbl
)
254 const bitmask_transtbl
*btp
;
255 unsigned int alpha_mask
= 0;
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
;
265 unsigned int host_to_target_bitmask(unsigned int alpha_mask
,
266 const bitmask_transtbl
* trans_tbl
)
268 const bitmask_transtbl
*btp
;
269 unsigned int x86_mask
= 0;
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
;
279 #ifndef NO_THUNK_TYPE_SIZE
280 int thunk_type_size_array(const argtype
*type_ptr
, int is_host
)
282 return thunk_type_size(type_ptr
, is_host
);
285 int thunk_type_align_array(const argtype
*type_ptr
, int is_host
)
287 return thunk_type_align(type_ptr
, is_host
);
289 #endif /* ndef NO_THUNK_TYPE_SIZE */