xref: /illumos-kvm-cmd/thunk.h (revision 68396ea9)
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 #ifndef THUNK_H
20 #define THUNK_H
21 
22 #include <inttypes.h>
23 #include "cpu.h"
24 
25 /* types enums definitions */
26 
27 typedef enum argtype {
28     TYPE_NULL,
29     TYPE_CHAR,
30     TYPE_SHORT,
31     TYPE_INT,
32     TYPE_LONG,
33     TYPE_ULONG,
34     TYPE_PTRVOID, /* pointer on unknown data */
35     TYPE_LONGLONG,
36     TYPE_ULONGLONG,
37     TYPE_PTR,
38     TYPE_ARRAY,
39     TYPE_STRUCT,
40 } argtype;
41 
42 #define MK_PTR(type) TYPE_PTR, type
43 #define MK_ARRAY(type, size) TYPE_ARRAY, size, type
44 #define MK_STRUCT(id) TYPE_STRUCT, id
45 
46 #define THUNK_TARGET 0
47 #define THUNK_HOST   1
48 
49 typedef struct {
50     /* standard struct handling */
51     const argtype *field_types;
52     int nb_fields;
53     int *field_offsets[2];
54     /* special handling */
55     void (*convert[2])(void *dst, const void *src);
56     int size[2];
57     int align[2];
58     const char *name;
59 } StructEntry;
60 
61 /* Translation table for bitmasks... */
62 typedef struct bitmask_transtbl {
63 	unsigned int	x86_mask;
64 	unsigned int	x86_bits;
65 	unsigned int	alpha_mask;
66 	unsigned int	alpha_bits;
67 } bitmask_transtbl;
68 
69 void thunk_register_struct(int id, const char *name, const argtype *types);
70 void thunk_register_struct_direct(int id, const char *name,
71                                   const StructEntry *se1);
72 const argtype *thunk_convert(void *dst, const void *src,
73                              const argtype *type_ptr, int to_host);
74 #ifndef NO_THUNK_TYPE_SIZE
75 
76 extern StructEntry struct_entries[];
77 
78 int thunk_type_size_array(const argtype *type_ptr, int is_host);
79 int thunk_type_align_array(const argtype *type_ptr, int is_host);
80 
thunk_type_size(const argtype * type_ptr,int is_host)81 static inline int thunk_type_size(const argtype *type_ptr, int is_host)
82 {
83     int type, size;
84     const StructEntry *se;
85 
86     type = *type_ptr;
87     switch(type) {
88     case TYPE_CHAR:
89         return 1;
90     case TYPE_SHORT:
91         return 2;
92     case TYPE_INT:
93         return 4;
94     case TYPE_LONGLONG:
95     case TYPE_ULONGLONG:
96         return 8;
97     case TYPE_LONG:
98     case TYPE_ULONG:
99     case TYPE_PTRVOID:
100     case TYPE_PTR:
101         if (is_host) {
102             return HOST_LONG_SIZE;
103         } else {
104             return TARGET_ABI_BITS / 8;
105         }
106         break;
107     case TYPE_ARRAY:
108         size = type_ptr[1];
109         return size * thunk_type_size_array(type_ptr + 2, is_host);
110     case TYPE_STRUCT:
111         se = struct_entries + type_ptr[1];
112         return se->size[is_host];
113     default:
114         return -1;
115     }
116 }
117 
thunk_type_align(const argtype * type_ptr,int is_host)118 static inline int thunk_type_align(const argtype *type_ptr, int is_host)
119 {
120     int type;
121     const StructEntry *se;
122 
123     type = *type_ptr;
124     switch(type) {
125     case TYPE_CHAR:
126         return 1;
127     case TYPE_SHORT:
128         return 2;
129     case TYPE_INT:
130         return 4;
131     case TYPE_LONGLONG:
132     case TYPE_ULONGLONG:
133         return 8;
134     case TYPE_LONG:
135     case TYPE_ULONG:
136     case TYPE_PTRVOID:
137     case TYPE_PTR:
138         if (is_host) {
139             return HOST_LONG_SIZE;
140         } else {
141             return TARGET_ABI_BITS / 8;
142         }
143         break;
144     case TYPE_ARRAY:
145         return thunk_type_align_array(type_ptr + 2, is_host);
146     case TYPE_STRUCT:
147         se = struct_entries + type_ptr[1];
148         return se->align[is_host];
149     default:
150         return -1;
151     }
152 }
153 
154 #endif /* NO_THUNK_TYPE_SIZE */
155 
156 unsigned int target_to_host_bitmask(unsigned int x86_mask,
157                                     const bitmask_transtbl * trans_tbl);
158 unsigned int host_to_target_bitmask(unsigned int alpha_mask,
159                                     const bitmask_transtbl * trans_tbl);
160 
161 #endif
162