root / include / qemu / bswap.h @ 2e40134b
History | View | Annotate | Download (8.1 kB)
1 | ab93bbe2 | bellard | #ifndef BSWAP_H
|
---|---|---|---|
2 | ab93bbe2 | bellard | #define BSWAP_H
|
3 | ab93bbe2 | bellard | |
4 | ab93bbe2 | bellard | #include "config-host.h" |
5 | ab93bbe2 | bellard | #include <inttypes.h> |
6 | 91107fdf | Richard Henderson | #include <limits.h> |
7 | ea44910e | Alexey Kardashevskiy | #include <string.h> |
8 | 6b4c305c | Paolo Bonzini | #include "fpu/softfloat.h" |
9 | ab93bbe2 | bellard | |
10 | 5735147e | Juan Quintela | #ifdef CONFIG_MACHINE_BSWAP_H
|
11 | cdfe2851 | Richard Henderson | # include <sys/endian.h> |
12 | cdfe2851 | Richard Henderson | # include <sys/types.h> |
13 | cdfe2851 | Richard Henderson | # include <machine/bswap.h> |
14 | cdfe2851 | Richard Henderson | #elif defined(CONFIG_BYTESWAP_H)
|
15 | cdfe2851 | Richard Henderson | # include <byteswap.h> |
16 | ab93bbe2 | bellard | |
17 | ab93bbe2 | bellard | static inline uint16_t bswap16(uint16_t x) |
18 | ab93bbe2 | bellard | { |
19 | ab93bbe2 | bellard | return bswap_16(x);
|
20 | ab93bbe2 | bellard | } |
21 | ab93bbe2 | bellard | |
22 | 5fafdf24 | ths | static inline uint32_t bswap32(uint32_t x) |
23 | ab93bbe2 | bellard | { |
24 | ab93bbe2 | bellard | return bswap_32(x);
|
25 | ab93bbe2 | bellard | } |
26 | ab93bbe2 | bellard | |
27 | 5fafdf24 | ths | static inline uint64_t bswap64(uint64_t x) |
28 | ab93bbe2 | bellard | { |
29 | ab93bbe2 | bellard | return bswap_64(x);
|
30 | ab93bbe2 | bellard | } |
31 | cdfe2851 | Richard Henderson | # else
|
32 | cdfe2851 | Richard Henderson | static inline uint16_t bswap16(uint16_t x) |
33 | cdfe2851 | Richard Henderson | { |
34 | cdfe2851 | Richard Henderson | return (((x & 0x00ff) << 8) | |
35 | cdfe2851 | Richard Henderson | ((x & 0xff00) >> 8)); |
36 | cdfe2851 | Richard Henderson | } |
37 | ab93bbe2 | bellard | |
38 | cdfe2851 | Richard Henderson | static inline uint32_t bswap32(uint32_t x) |
39 | cdfe2851 | Richard Henderson | { |
40 | cdfe2851 | Richard Henderson | return (((x & 0x000000ffU) << 24) | |
41 | cdfe2851 | Richard Henderson | ((x & 0x0000ff00U) << 8) | |
42 | cdfe2851 | Richard Henderson | ((x & 0x00ff0000U) >> 8) | |
43 | cdfe2851 | Richard Henderson | ((x & 0xff000000U) >> 24)); |
44 | cdfe2851 | Richard Henderson | } |
45 | cdfe2851 | Richard Henderson | |
46 | cdfe2851 | Richard Henderson | static inline uint64_t bswap64(uint64_t x) |
47 | cdfe2851 | Richard Henderson | { |
48 | cdfe2851 | Richard Henderson | return (((x & 0x00000000000000ffULL) << 56) | |
49 | cdfe2851 | Richard Henderson | ((x & 0x000000000000ff00ULL) << 40) | |
50 | cdfe2851 | Richard Henderson | ((x & 0x0000000000ff0000ULL) << 24) | |
51 | cdfe2851 | Richard Henderson | ((x & 0x00000000ff000000ULL) << 8) | |
52 | cdfe2851 | Richard Henderson | ((x & 0x000000ff00000000ULL) >> 8) | |
53 | cdfe2851 | Richard Henderson | ((x & 0x0000ff0000000000ULL) >> 24) | |
54 | cdfe2851 | Richard Henderson | ((x & 0x00ff000000000000ULL) >> 40) | |
55 | cdfe2851 | Richard Henderson | ((x & 0xff00000000000000ULL) >> 56)); |
56 | cdfe2851 | Richard Henderson | } |
57 | 5735147e | Juan Quintela | #endif /* ! CONFIG_MACHINE_BSWAP_H */ |
58 | 1360677c | blueswir1 | |
59 | ab93bbe2 | bellard | static inline void bswap16s(uint16_t *s) |
60 | ab93bbe2 | bellard | { |
61 | ab93bbe2 | bellard | *s = bswap16(*s); |
62 | ab93bbe2 | bellard | } |
63 | ab93bbe2 | bellard | |
64 | ab93bbe2 | bellard | static inline void bswap32s(uint32_t *s) |
65 | ab93bbe2 | bellard | { |
66 | ab93bbe2 | bellard | *s = bswap32(*s); |
67 | ab93bbe2 | bellard | } |
68 | ab93bbe2 | bellard | |
69 | ab93bbe2 | bellard | static inline void bswap64s(uint64_t *s) |
70 | ab93bbe2 | bellard | { |
71 | ab93bbe2 | bellard | *s = bswap64(*s); |
72 | ab93bbe2 | bellard | } |
73 | ab93bbe2 | bellard | |
74 | e2542fe2 | Juan Quintela | #if defined(HOST_WORDS_BIGENDIAN)
|
75 | af8ffdfd | bellard | #define be_bswap(v, size) (v)
|
76 | a4cbfe24 | Blue Swirl | #define le_bswap(v, size) glue(bswap, size)(v)
|
77 | af8ffdfd | bellard | #define be_bswaps(v, size)
|
78 | a4cbfe24 | Blue Swirl | #define le_bswaps(p, size) do { *p = glue(bswap, size)(*p); } while(0) |
79 | af8ffdfd | bellard | #else
|
80 | af8ffdfd | bellard | #define le_bswap(v, size) (v)
|
81 | a4cbfe24 | Blue Swirl | #define be_bswap(v, size) glue(bswap, size)(v)
|
82 | af8ffdfd | bellard | #define le_bswaps(v, size)
|
83 | a4cbfe24 | Blue Swirl | #define be_bswaps(p, size) do { *p = glue(bswap, size)(*p); } while(0) |
84 | af8ffdfd | bellard | #endif
|
85 | af8ffdfd | bellard | |
86 | af8ffdfd | bellard | #define CPU_CONVERT(endian, size, type)\
|
87 | af8ffdfd | bellard | static inline type endian ## size ## _to_cpu(type v)\ |
88 | af8ffdfd | bellard | {\ |
89 | a4cbfe24 | Blue Swirl | return glue(endian, _bswap)(v, size);\
|
90 | af8ffdfd | bellard | }\ |
91 | af8ffdfd | bellard | \ |
92 | af8ffdfd | bellard | static inline type cpu_to_ ## endian ## size(type v)\ |
93 | af8ffdfd | bellard | {\ |
94 | a4cbfe24 | Blue Swirl | return glue(endian, _bswap)(v, size);\
|
95 | af8ffdfd | bellard | }\ |
96 | af8ffdfd | bellard | \ |
97 | af8ffdfd | bellard | static inline void endian ## size ## _to_cpus(type *p)\ |
98 | af8ffdfd | bellard | {\ |
99 | a4cbfe24 | Blue Swirl | glue(endian, _bswaps)(p, size);\ |
100 | af8ffdfd | bellard | }\ |
101 | af8ffdfd | bellard | \ |
102 | af8ffdfd | bellard | static inline void cpu_to_ ## endian ## size ## s(type *p)\ |
103 | af8ffdfd | bellard | {\ |
104 | a4cbfe24 | Blue Swirl | glue(endian, _bswaps)(p, size);\ |
105 | af8ffdfd | bellard | }\ |
106 | af8ffdfd | bellard | \ |
107 | af8ffdfd | bellard | static inline type endian ## size ## _to_cpup(const type *p)\ |
108 | af8ffdfd | bellard | {\ |
109 | a4cbfe24 | Blue Swirl | return glue(glue(endian, size), _to_cpu)(*p);\
|
110 | af8ffdfd | bellard | }\ |
111 | af8ffdfd | bellard | \ |
112 | af8ffdfd | bellard | static inline void cpu_to_ ## endian ## size ## w(type *p, type v)\ |
113 | af8ffdfd | bellard | {\ |
114 | a4cbfe24 | Blue Swirl | *p = glue(glue(cpu_to_, endian), size)(v);\ |
115 | af8ffdfd | bellard | } |
116 | af8ffdfd | bellard | |
117 | af8ffdfd | bellard | CPU_CONVERT(be, 16, uint16_t)
|
118 | af8ffdfd | bellard | CPU_CONVERT(be, 32, uint32_t)
|
119 | af8ffdfd | bellard | CPU_CONVERT(be, 64, uint64_t)
|
120 | af8ffdfd | bellard | |
121 | af8ffdfd | bellard | CPU_CONVERT(le, 16, uint16_t)
|
122 | af8ffdfd | bellard | CPU_CONVERT(le, 32, uint32_t)
|
123 | af8ffdfd | bellard | CPU_CONVERT(le, 64, uint64_t)
|
124 | af8ffdfd | bellard | |
125 | e73d6e3a | Michael S. Tsirkin | /* len must be one of 1, 2, 4 */
|
126 | e73d6e3a | Michael S. Tsirkin | static inline uint32_t qemu_bswap_len(uint32_t value, int len) |
127 | e73d6e3a | Michael S. Tsirkin | { |
128 | e73d6e3a | Michael S. Tsirkin | return bswap32(value) >> (32 - 8 * len); |
129 | e73d6e3a | Michael S. Tsirkin | } |
130 | e73d6e3a | Michael S. Tsirkin | |
131 | 7db2145a | Richard Henderson | /* Unions for reinterpreting between floats and integers. */
|
132 | 7db2145a | Richard Henderson | |
133 | cbbab922 | Paolo Bonzini | typedef union { |
134 | cbbab922 | Paolo Bonzini | float32 f; |
135 | cbbab922 | Paolo Bonzini | uint32_t l; |
136 | cbbab922 | Paolo Bonzini | } CPU_FloatU; |
137 | cbbab922 | Paolo Bonzini | |
138 | cbbab922 | Paolo Bonzini | typedef union { |
139 | cbbab922 | Paolo Bonzini | float64 d; |
140 | cbbab922 | Paolo Bonzini | #if defined(HOST_WORDS_BIGENDIAN)
|
141 | cbbab922 | Paolo Bonzini | struct {
|
142 | cbbab922 | Paolo Bonzini | uint32_t upper; |
143 | cbbab922 | Paolo Bonzini | uint32_t lower; |
144 | cbbab922 | Paolo Bonzini | } l; |
145 | cbbab922 | Paolo Bonzini | #else
|
146 | cbbab922 | Paolo Bonzini | struct {
|
147 | cbbab922 | Paolo Bonzini | uint32_t lower; |
148 | cbbab922 | Paolo Bonzini | uint32_t upper; |
149 | cbbab922 | Paolo Bonzini | } l; |
150 | cbbab922 | Paolo Bonzini | #endif
|
151 | cbbab922 | Paolo Bonzini | uint64_t ll; |
152 | cbbab922 | Paolo Bonzini | } CPU_DoubleU; |
153 | cbbab922 | Paolo Bonzini | |
154 | cbbab922 | Paolo Bonzini | typedef union { |
155 | cbbab922 | Paolo Bonzini | floatx80 d; |
156 | cbbab922 | Paolo Bonzini | struct {
|
157 | cbbab922 | Paolo Bonzini | uint64_t lower; |
158 | cbbab922 | Paolo Bonzini | uint16_t upper; |
159 | cbbab922 | Paolo Bonzini | } l; |
160 | cbbab922 | Paolo Bonzini | } CPU_LDoubleU; |
161 | cbbab922 | Paolo Bonzini | |
162 | cbbab922 | Paolo Bonzini | typedef union { |
163 | cbbab922 | Paolo Bonzini | float128 q; |
164 | cbbab922 | Paolo Bonzini | #if defined(HOST_WORDS_BIGENDIAN)
|
165 | cbbab922 | Paolo Bonzini | struct {
|
166 | cbbab922 | Paolo Bonzini | uint32_t upmost; |
167 | cbbab922 | Paolo Bonzini | uint32_t upper; |
168 | cbbab922 | Paolo Bonzini | uint32_t lower; |
169 | cbbab922 | Paolo Bonzini | uint32_t lowest; |
170 | cbbab922 | Paolo Bonzini | } l; |
171 | cbbab922 | Paolo Bonzini | struct {
|
172 | cbbab922 | Paolo Bonzini | uint64_t upper; |
173 | cbbab922 | Paolo Bonzini | uint64_t lower; |
174 | cbbab922 | Paolo Bonzini | } ll; |
175 | cbbab922 | Paolo Bonzini | #else
|
176 | cbbab922 | Paolo Bonzini | struct {
|
177 | cbbab922 | Paolo Bonzini | uint32_t lowest; |
178 | cbbab922 | Paolo Bonzini | uint32_t lower; |
179 | cbbab922 | Paolo Bonzini | uint32_t upper; |
180 | cbbab922 | Paolo Bonzini | uint32_t upmost; |
181 | cbbab922 | Paolo Bonzini | } l; |
182 | cbbab922 | Paolo Bonzini | struct {
|
183 | cbbab922 | Paolo Bonzini | uint64_t lower; |
184 | cbbab922 | Paolo Bonzini | uint64_t upper; |
185 | cbbab922 | Paolo Bonzini | } ll; |
186 | cbbab922 | Paolo Bonzini | #endif
|
187 | cbbab922 | Paolo Bonzini | } CPU_QuadU; |
188 | cbbab922 | Paolo Bonzini | |
189 | cbbab922 | Paolo Bonzini | /* unaligned/endian-independent pointer access */
|
190 | cbbab922 | Paolo Bonzini | |
191 | cbbab922 | Paolo Bonzini | /*
|
192 | cbbab922 | Paolo Bonzini | * the generic syntax is:
|
193 | cbbab922 | Paolo Bonzini | *
|
194 | cbbab922 | Paolo Bonzini | * load: ld{type}{sign}{size}{endian}_p(ptr)
|
195 | cbbab922 | Paolo Bonzini | *
|
196 | cbbab922 | Paolo Bonzini | * store: st{type}{size}{endian}_p(ptr, val)
|
197 | cbbab922 | Paolo Bonzini | *
|
198 | cbbab922 | Paolo Bonzini | * Note there are small differences with the softmmu access API!
|
199 | cbbab922 | Paolo Bonzini | *
|
200 | cbbab922 | Paolo Bonzini | * type is:
|
201 | cbbab922 | Paolo Bonzini | * (empty): integer access
|
202 | cbbab922 | Paolo Bonzini | * f : float access
|
203 | cbbab922 | Paolo Bonzini | *
|
204 | cbbab922 | Paolo Bonzini | * sign is:
|
205 | cbbab922 | Paolo Bonzini | * (empty): for floats or 32 bit size
|
206 | cbbab922 | Paolo Bonzini | * u : unsigned
|
207 | cbbab922 | Paolo Bonzini | * s : signed
|
208 | cbbab922 | Paolo Bonzini | *
|
209 | cbbab922 | Paolo Bonzini | * size is:
|
210 | cbbab922 | Paolo Bonzini | * b: 8 bits
|
211 | cbbab922 | Paolo Bonzini | * w: 16 bits
|
212 | cbbab922 | Paolo Bonzini | * l: 32 bits
|
213 | cbbab922 | Paolo Bonzini | * q: 64 bits
|
214 | cbbab922 | Paolo Bonzini | *
|
215 | cbbab922 | Paolo Bonzini | * endian is:
|
216 | 7db2145a | Richard Henderson | * (empty): host endian
|
217 | cbbab922 | Paolo Bonzini | * be : big endian
|
218 | cbbab922 | Paolo Bonzini | * le : little endian
|
219 | cbbab922 | Paolo Bonzini | */
|
220 | c732a52d | Richard Henderson | |
221 | cbbab922 | Paolo Bonzini | static inline int ldub_p(const void *ptr) |
222 | cbbab922 | Paolo Bonzini | { |
223 | cbbab922 | Paolo Bonzini | return *(uint8_t *)ptr;
|
224 | cbbab922 | Paolo Bonzini | } |
225 | cbbab922 | Paolo Bonzini | |
226 | cbbab922 | Paolo Bonzini | static inline int ldsb_p(const void *ptr) |
227 | cbbab922 | Paolo Bonzini | { |
228 | cbbab922 | Paolo Bonzini | return *(int8_t *)ptr;
|
229 | cbbab922 | Paolo Bonzini | } |
230 | cbbab922 | Paolo Bonzini | |
231 | cbbab922 | Paolo Bonzini | static inline void stb_p(void *ptr, int v) |
232 | cbbab922 | Paolo Bonzini | { |
233 | cbbab922 | Paolo Bonzini | *(uint8_t *)ptr = v; |
234 | cbbab922 | Paolo Bonzini | } |
235 | cbbab922 | Paolo Bonzini | |
236 | 7db2145a | Richard Henderson | /* Any compiler worth its salt will turn these memcpy into native unaligned
|
237 | 7db2145a | Richard Henderson | operations. Thus we don't need to play games with packed attributes, or
|
238 | 7db2145a | Richard Henderson | inline byte-by-byte stores. */
|
239 | 7db2145a | Richard Henderson | |
240 | 7db2145a | Richard Henderson | static inline int lduw_p(const void *ptr) |
241 | 7db2145a | Richard Henderson | { |
242 | 7db2145a | Richard Henderson | uint16_t r; |
243 | 7db2145a | Richard Henderson | memcpy(&r, ptr, sizeof(r));
|
244 | 7db2145a | Richard Henderson | return r;
|
245 | 7db2145a | Richard Henderson | } |
246 | 7db2145a | Richard Henderson | |
247 | 7db2145a | Richard Henderson | static inline int ldsw_p(const void *ptr) |
248 | 7db2145a | Richard Henderson | { |
249 | 7db2145a | Richard Henderson | int16_t r; |
250 | 7db2145a | Richard Henderson | memcpy(&r, ptr, sizeof(r));
|
251 | 7db2145a | Richard Henderson | return r;
|
252 | 7db2145a | Richard Henderson | } |
253 | 7db2145a | Richard Henderson | |
254 | 7db2145a | Richard Henderson | static inline void stw_p(void *ptr, uint16_t v) |
255 | 7db2145a | Richard Henderson | { |
256 | 7db2145a | Richard Henderson | memcpy(ptr, &v, sizeof(v));
|
257 | 7db2145a | Richard Henderson | } |
258 | 7db2145a | Richard Henderson | |
259 | 7db2145a | Richard Henderson | static inline int ldl_p(const void *ptr) |
260 | 7db2145a | Richard Henderson | { |
261 | 7db2145a | Richard Henderson | int32_t r; |
262 | 7db2145a | Richard Henderson | memcpy(&r, ptr, sizeof(r));
|
263 | 7db2145a | Richard Henderson | return r;
|
264 | 7db2145a | Richard Henderson | } |
265 | 7db2145a | Richard Henderson | |
266 | 7db2145a | Richard Henderson | static inline void stl_p(void *ptr, uint32_t v) |
267 | 7db2145a | Richard Henderson | { |
268 | 7db2145a | Richard Henderson | memcpy(ptr, &v, sizeof(v));
|
269 | 7db2145a | Richard Henderson | } |
270 | 7db2145a | Richard Henderson | |
271 | 7db2145a | Richard Henderson | static inline uint64_t ldq_p(const void *ptr) |
272 | 7db2145a | Richard Henderson | { |
273 | 7db2145a | Richard Henderson | uint64_t r; |
274 | 7db2145a | Richard Henderson | memcpy(&r, ptr, sizeof(r));
|
275 | 7db2145a | Richard Henderson | return r;
|
276 | 7db2145a | Richard Henderson | } |
277 | 7db2145a | Richard Henderson | |
278 | 7db2145a | Richard Henderson | static inline void stq_p(void *ptr, uint64_t v) |
279 | 7db2145a | Richard Henderson | { |
280 | 7db2145a | Richard Henderson | memcpy(ptr, &v, sizeof(v));
|
281 | 7db2145a | Richard Henderson | } |
282 | 7db2145a | Richard Henderson | |
283 | cbbab922 | Paolo Bonzini | static inline int lduw_le_p(const void *ptr) |
284 | cbbab922 | Paolo Bonzini | { |
285 | 612d590e | Richard Henderson | return (uint16_t)le_bswap(lduw_p(ptr), 16); |
286 | cbbab922 | Paolo Bonzini | } |
287 | cbbab922 | Paolo Bonzini | |
288 | cbbab922 | Paolo Bonzini | static inline int ldsw_le_p(const void *ptr) |
289 | cbbab922 | Paolo Bonzini | { |
290 | 612d590e | Richard Henderson | return (int16_t)le_bswap(lduw_p(ptr), 16); |
291 | cbbab922 | Paolo Bonzini | } |
292 | cbbab922 | Paolo Bonzini | |
293 | cbbab922 | Paolo Bonzini | static inline int ldl_le_p(const void *ptr) |
294 | cbbab922 | Paolo Bonzini | { |
295 | 612d590e | Richard Henderson | return le_bswap(ldl_p(ptr), 32); |
296 | cbbab922 | Paolo Bonzini | } |
297 | cbbab922 | Paolo Bonzini | |
298 | cbbab922 | Paolo Bonzini | static inline uint64_t ldq_le_p(const void *ptr) |
299 | cbbab922 | Paolo Bonzini | { |
300 | 612d590e | Richard Henderson | return le_bswap(ldq_p(ptr), 64); |
301 | cbbab922 | Paolo Bonzini | } |
302 | cbbab922 | Paolo Bonzini | |
303 | cbbab922 | Paolo Bonzini | static inline void stw_le_p(void *ptr, int v) |
304 | cbbab922 | Paolo Bonzini | { |
305 | 612d590e | Richard Henderson | stw_p(ptr, le_bswap(v, 16));
|
306 | cbbab922 | Paolo Bonzini | } |
307 | cbbab922 | Paolo Bonzini | |
308 | cbbab922 | Paolo Bonzini | static inline void stl_le_p(void *ptr, int v) |
309 | cbbab922 | Paolo Bonzini | { |
310 | 612d590e | Richard Henderson | stl_p(ptr, le_bswap(v, 32));
|
311 | cbbab922 | Paolo Bonzini | } |
312 | cbbab922 | Paolo Bonzini | |
313 | cbbab922 | Paolo Bonzini | static inline void stq_le_p(void *ptr, uint64_t v) |
314 | cbbab922 | Paolo Bonzini | { |
315 | 612d590e | Richard Henderson | stq_p(ptr, le_bswap(v, 64));
|
316 | cbbab922 | Paolo Bonzini | } |
317 | cbbab922 | Paolo Bonzini | |
318 | cbbab922 | Paolo Bonzini | /* float access */
|
319 | cbbab922 | Paolo Bonzini | |
320 | cbbab922 | Paolo Bonzini | static inline float32 ldfl_le_p(const void *ptr) |
321 | cbbab922 | Paolo Bonzini | { |
322 | 612d590e | Richard Henderson | CPU_FloatU u; |
323 | 612d590e | Richard Henderson | u.l = ldl_le_p(ptr); |
324 | cbbab922 | Paolo Bonzini | return u.f;
|
325 | cbbab922 | Paolo Bonzini | } |
326 | cbbab922 | Paolo Bonzini | |
327 | cbbab922 | Paolo Bonzini | static inline void stfl_le_p(void *ptr, float32 v) |
328 | cbbab922 | Paolo Bonzini | { |
329 | 612d590e | Richard Henderson | CPU_FloatU u; |
330 | cbbab922 | Paolo Bonzini | u.f = v; |
331 | 612d590e | Richard Henderson | stl_le_p(ptr, u.l); |
332 | cbbab922 | Paolo Bonzini | } |
333 | cbbab922 | Paolo Bonzini | |
334 | cbbab922 | Paolo Bonzini | static inline float64 ldfq_le_p(const void *ptr) |
335 | cbbab922 | Paolo Bonzini | { |
336 | cbbab922 | Paolo Bonzini | CPU_DoubleU u; |
337 | 612d590e | Richard Henderson | u.ll = ldq_le_p(ptr); |
338 | cbbab922 | Paolo Bonzini | return u.d;
|
339 | cbbab922 | Paolo Bonzini | } |
340 | cbbab922 | Paolo Bonzini | |
341 | cbbab922 | Paolo Bonzini | static inline void stfq_le_p(void *ptr, float64 v) |
342 | cbbab922 | Paolo Bonzini | { |
343 | cbbab922 | Paolo Bonzini | CPU_DoubleU u; |
344 | cbbab922 | Paolo Bonzini | u.d = v; |
345 | 612d590e | Richard Henderson | stq_le_p(ptr, u.ll); |
346 | cbbab922 | Paolo Bonzini | } |
347 | cbbab922 | Paolo Bonzini | |
348 | cbbab922 | Paolo Bonzini | static inline int lduw_be_p(const void *ptr) |
349 | cbbab922 | Paolo Bonzini | { |
350 | 612d590e | Richard Henderson | return (uint16_t)be_bswap(lduw_p(ptr), 16); |
351 | cbbab922 | Paolo Bonzini | } |
352 | cbbab922 | Paolo Bonzini | |
353 | cbbab922 | Paolo Bonzini | static inline int ldsw_be_p(const void *ptr) |
354 | cbbab922 | Paolo Bonzini | { |
355 | 612d590e | Richard Henderson | return (int16_t)be_bswap(lduw_p(ptr), 16); |
356 | cbbab922 | Paolo Bonzini | } |
357 | cbbab922 | Paolo Bonzini | |
358 | cbbab922 | Paolo Bonzini | static inline int ldl_be_p(const void *ptr) |
359 | cbbab922 | Paolo Bonzini | { |
360 | 612d590e | Richard Henderson | return be_bswap(ldl_p(ptr), 32); |
361 | cbbab922 | Paolo Bonzini | } |
362 | cbbab922 | Paolo Bonzini | |
363 | cbbab922 | Paolo Bonzini | static inline uint64_t ldq_be_p(const void *ptr) |
364 | cbbab922 | Paolo Bonzini | { |
365 | 612d590e | Richard Henderson | return be_bswap(ldq_p(ptr), 64); |
366 | cbbab922 | Paolo Bonzini | } |
367 | cbbab922 | Paolo Bonzini | |
368 | cbbab922 | Paolo Bonzini | static inline void stw_be_p(void *ptr, int v) |
369 | cbbab922 | Paolo Bonzini | { |
370 | 612d590e | Richard Henderson | stw_p(ptr, be_bswap(v, 16));
|
371 | cbbab922 | Paolo Bonzini | } |
372 | cbbab922 | Paolo Bonzini | |
373 | cbbab922 | Paolo Bonzini | static inline void stl_be_p(void *ptr, int v) |
374 | cbbab922 | Paolo Bonzini | { |
375 | 612d590e | Richard Henderson | stl_p(ptr, be_bswap(v, 32));
|
376 | cbbab922 | Paolo Bonzini | } |
377 | cbbab922 | Paolo Bonzini | |
378 | cbbab922 | Paolo Bonzini | static inline void stq_be_p(void *ptr, uint64_t v) |
379 | cbbab922 | Paolo Bonzini | { |
380 | 612d590e | Richard Henderson | stq_p(ptr, be_bswap(v, 64));
|
381 | cbbab922 | Paolo Bonzini | } |
382 | cbbab922 | Paolo Bonzini | |
383 | cbbab922 | Paolo Bonzini | /* float access */
|
384 | cbbab922 | Paolo Bonzini | |
385 | cbbab922 | Paolo Bonzini | static inline float32 ldfl_be_p(const void *ptr) |
386 | cbbab922 | Paolo Bonzini | { |
387 | 612d590e | Richard Henderson | CPU_FloatU u; |
388 | 612d590e | Richard Henderson | u.l = ldl_be_p(ptr); |
389 | cbbab922 | Paolo Bonzini | return u.f;
|
390 | cbbab922 | Paolo Bonzini | } |
391 | cbbab922 | Paolo Bonzini | |
392 | cbbab922 | Paolo Bonzini | static inline void stfl_be_p(void *ptr, float32 v) |
393 | cbbab922 | Paolo Bonzini | { |
394 | 612d590e | Richard Henderson | CPU_FloatU u; |
395 | cbbab922 | Paolo Bonzini | u.f = v; |
396 | 612d590e | Richard Henderson | stl_be_p(ptr, u.l); |
397 | cbbab922 | Paolo Bonzini | } |
398 | cbbab922 | Paolo Bonzini | |
399 | cbbab922 | Paolo Bonzini | static inline float64 ldfq_be_p(const void *ptr) |
400 | cbbab922 | Paolo Bonzini | { |
401 | cbbab922 | Paolo Bonzini | CPU_DoubleU u; |
402 | 612d590e | Richard Henderson | u.ll = ldq_be_p(ptr); |
403 | cbbab922 | Paolo Bonzini | return u.d;
|
404 | cbbab922 | Paolo Bonzini | } |
405 | cbbab922 | Paolo Bonzini | |
406 | cbbab922 | Paolo Bonzini | static inline void stfq_be_p(void *ptr, float64 v) |
407 | cbbab922 | Paolo Bonzini | { |
408 | cbbab922 | Paolo Bonzini | CPU_DoubleU u; |
409 | cbbab922 | Paolo Bonzini | u.d = v; |
410 | 612d590e | Richard Henderson | stq_be_p(ptr, u.ll); |
411 | cbbab922 | Paolo Bonzini | } |
412 | cbbab922 | Paolo Bonzini | |
413 | c732a52d | Richard Henderson | static inline unsigned long leul_to_cpu(unsigned long v) |
414 | c732a52d | Richard Henderson | { |
415 | 91107fdf | Richard Henderson | /* In order to break an include loop between here and
|
416 | 91107fdf | Richard Henderson | qemu-common.h, don't rely on HOST_LONG_BITS. */
|
417 | 91107fdf | Richard Henderson | #if ULONG_MAX == UINT32_MAX
|
418 | 91107fdf | Richard Henderson | return le_bswap(v, 32); |
419 | 91107fdf | Richard Henderson | #elif ULONG_MAX == UINT64_MAX
|
420 | 91107fdf | Richard Henderson | return le_bswap(v, 64); |
421 | 91107fdf | Richard Henderson | #else
|
422 | 91107fdf | Richard Henderson | # error Unknown sizeof long |
423 | 91107fdf | Richard Henderson | #endif
|
424 | c732a52d | Richard Henderson | } |
425 | c732a52d | Richard Henderson | |
426 | 612d590e | Richard Henderson | #undef le_bswap
|
427 | 612d590e | Richard Henderson | #undef be_bswap
|
428 | 612d590e | Richard Henderson | #undef le_bswaps
|
429 | 612d590e | Richard Henderson | #undef be_bswaps
|
430 | cbbab922 | Paolo Bonzini | |
431 | ab93bbe2 | bellard | #endif /* BSWAP_H */ |