← Back to branch summary

~ubuntu-branches/ubuntu/wily/qemu-kvm-spice/wily

« back to all changes in this revision

Viewing changes to thunk.h

  • Committer: Bazaar Package Importer
  • Author(s): Serge Hallyn
  • Date: 2011-10-19 10:44:56 UTC
  • Revision ID: james.westby@ubuntu.com-20111019104456-xgvskumk3sxi97f4
Tags: upstream-0.15.0+noroms
Import upstream version 0.15.0+noroms

Show diffs side-by-side

added added

removed removed

Lines of Context:
thunk.h
 
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
 
 
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
 
 
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