Fix vm state save/load
[qemu-kvm/fedora.git] / tcg / tcg-op.h
blobbc6be8537eb32967b3091aae12b1e6ab40c73a74
1 /*
2 * Tiny Code Generator for QEMU
4 * Copyright (c) 2008 Fabrice Bellard
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
24 #include "tcg.h"
26 #ifdef CONFIG_DYNGEN_OP
27 /* legacy dyngen operations */
28 #include "gen-op.h"
29 #endif
31 int gen_new_label(void);
33 static inline void tcg_gen_op1(int opc, TCGv arg1)
35 *gen_opc_ptr++ = opc;
36 *gen_opparam_ptr++ = GET_TCGV(arg1);
39 static inline void tcg_gen_op1i(int opc, TCGArg arg1)
41 *gen_opc_ptr++ = opc;
42 *gen_opparam_ptr++ = arg1;
45 static inline void tcg_gen_op2(int opc, TCGv arg1, TCGv arg2)
47 *gen_opc_ptr++ = opc;
48 *gen_opparam_ptr++ = GET_TCGV(arg1);
49 *gen_opparam_ptr++ = GET_TCGV(arg2);
52 static inline void tcg_gen_op2i(int opc, TCGv arg1, TCGArg arg2)
54 *gen_opc_ptr++ = opc;
55 *gen_opparam_ptr++ = GET_TCGV(arg1);
56 *gen_opparam_ptr++ = arg2;
59 static inline void tcg_gen_op2ii(int opc, TCGArg arg1, TCGArg arg2)
61 *gen_opc_ptr++ = opc;
62 *gen_opparam_ptr++ = arg1;
63 *gen_opparam_ptr++ = arg2;
66 static inline void tcg_gen_op3(int opc, TCGv arg1, TCGv arg2, TCGv arg3)
68 *gen_opc_ptr++ = opc;
69 *gen_opparam_ptr++ = GET_TCGV(arg1);
70 *gen_opparam_ptr++ = GET_TCGV(arg2);
71 *gen_opparam_ptr++ = GET_TCGV(arg3);
74 static inline void tcg_gen_op3i(int opc, TCGv arg1, TCGv arg2, TCGArg arg3)
76 *gen_opc_ptr++ = opc;
77 *gen_opparam_ptr++ = GET_TCGV(arg1);
78 *gen_opparam_ptr++ = GET_TCGV(arg2);
79 *gen_opparam_ptr++ = arg3;
82 static inline void tcg_gen_op4(int opc, TCGv arg1, TCGv arg2, TCGv arg3,
83 TCGv arg4)
85 *gen_opc_ptr++ = opc;
86 *gen_opparam_ptr++ = GET_TCGV(arg1);
87 *gen_opparam_ptr++ = GET_TCGV(arg2);
88 *gen_opparam_ptr++ = GET_TCGV(arg3);
89 *gen_opparam_ptr++ = GET_TCGV(arg4);
92 static inline void tcg_gen_op4i(int opc, TCGv arg1, TCGv arg2, TCGv arg3,
93 TCGArg arg4)
95 *gen_opc_ptr++ = opc;
96 *gen_opparam_ptr++ = GET_TCGV(arg1);
97 *gen_opparam_ptr++ = GET_TCGV(arg2);
98 *gen_opparam_ptr++ = GET_TCGV(arg3);
99 *gen_opparam_ptr++ = arg4;
102 static inline void tcg_gen_op4ii(int opc, TCGv arg1, TCGv arg2, TCGArg arg3,
103 TCGArg arg4)
105 *gen_opc_ptr++ = opc;
106 *gen_opparam_ptr++ = GET_TCGV(arg1);
107 *gen_opparam_ptr++ = GET_TCGV(arg2);
108 *gen_opparam_ptr++ = arg3;
109 *gen_opparam_ptr++ = arg4;
112 static inline void tcg_gen_op5(int opc, TCGv arg1, TCGv arg2,
113 TCGv arg3, TCGv arg4,
114 TCGv arg5)
116 *gen_opc_ptr++ = opc;
117 *gen_opparam_ptr++ = GET_TCGV(arg1);
118 *gen_opparam_ptr++ = GET_TCGV(arg2);
119 *gen_opparam_ptr++ = GET_TCGV(arg3);
120 *gen_opparam_ptr++ = GET_TCGV(arg4);
121 *gen_opparam_ptr++ = GET_TCGV(arg5);
124 static inline void tcg_gen_op5i(int opc, TCGv arg1, TCGv arg2,
125 TCGv arg3, TCGv arg4,
126 TCGArg arg5)
128 *gen_opc_ptr++ = opc;
129 *gen_opparam_ptr++ = GET_TCGV(arg1);
130 *gen_opparam_ptr++ = GET_TCGV(arg2);
131 *gen_opparam_ptr++ = GET_TCGV(arg3);
132 *gen_opparam_ptr++ = GET_TCGV(arg4);
133 *gen_opparam_ptr++ = arg5;
136 static inline void tcg_gen_op6(int opc, TCGv arg1, TCGv arg2,
137 TCGv arg3, TCGv arg4,
138 TCGv arg5, TCGv arg6)
140 *gen_opc_ptr++ = opc;
141 *gen_opparam_ptr++ = GET_TCGV(arg1);
142 *gen_opparam_ptr++ = GET_TCGV(arg2);
143 *gen_opparam_ptr++ = GET_TCGV(arg3);
144 *gen_opparam_ptr++ = GET_TCGV(arg4);
145 *gen_opparam_ptr++ = GET_TCGV(arg5);
146 *gen_opparam_ptr++ = GET_TCGV(arg6);
149 static inline void tcg_gen_op6ii(int opc, TCGv arg1, TCGv arg2,
150 TCGv arg3, TCGv arg4,
151 TCGArg arg5, TCGArg arg6)
153 *gen_opc_ptr++ = opc;
154 *gen_opparam_ptr++ = GET_TCGV(arg1);
155 *gen_opparam_ptr++ = GET_TCGV(arg2);
156 *gen_opparam_ptr++ = GET_TCGV(arg3);
157 *gen_opparam_ptr++ = GET_TCGV(arg4);
158 *gen_opparam_ptr++ = arg5;
159 *gen_opparam_ptr++ = arg6;
162 static inline void gen_set_label(int n)
164 tcg_gen_op1i(INDEX_op_set_label, n);
167 static inline void tcg_gen_br(int label)
169 tcg_gen_op1i(INDEX_op_br, label);
172 static inline void tcg_gen_mov_i32(TCGv ret, TCGv arg)
174 if (GET_TCGV(ret) != GET_TCGV(arg))
175 tcg_gen_op2(INDEX_op_mov_i32, ret, arg);
178 static inline void tcg_gen_movi_i32(TCGv ret, int32_t arg)
180 tcg_gen_op2i(INDEX_op_movi_i32, ret, arg);
183 /* helper calls */
184 #define TCG_HELPER_CALL_FLAGS 0
186 static inline void tcg_gen_helper_0_0(void *func)
188 TCGv t0;
189 t0 = tcg_const_ptr((tcg_target_long)func);
190 tcg_gen_call(&tcg_ctx,
191 t0, TCG_HELPER_CALL_FLAGS,
192 0, NULL, 0, NULL);
193 tcg_temp_free(t0);
196 static inline void tcg_gen_helper_0_1(void *func, TCGv arg)
198 TCGv t0;
199 t0 = tcg_const_ptr((tcg_target_long)func);
200 tcg_gen_call(&tcg_ctx,
201 t0, TCG_HELPER_CALL_FLAGS,
202 0, NULL, 1, &arg);
203 tcg_temp_free(t0);
206 static inline void tcg_gen_helper_0_2(void *func, TCGv arg1, TCGv arg2)
208 TCGv args[2];
209 TCGv t0;
210 args[0] = arg1;
211 args[1] = arg2;
212 t0 = tcg_const_ptr((tcg_target_long)func);
213 tcg_gen_call(&tcg_ctx,
214 t0, TCG_HELPER_CALL_FLAGS,
215 0, NULL, 2, args);
216 tcg_temp_free(t0);
219 static inline void tcg_gen_helper_0_3(void *func,
220 TCGv arg1, TCGv arg2, TCGv arg3)
222 TCGv args[3];
223 TCGv t0;
224 args[0] = arg1;
225 args[1] = arg2;
226 args[2] = arg3;
227 t0 = tcg_const_ptr((tcg_target_long)func);
228 tcg_gen_call(&tcg_ctx,
229 t0, TCG_HELPER_CALL_FLAGS,
230 0, NULL, 3, args);
231 tcg_temp_free(t0);
234 static inline void tcg_gen_helper_0_4(void *func, TCGv arg1, TCGv arg2,
235 TCGv arg3, TCGv arg4)
237 TCGv args[4];
238 TCGv t0;
239 args[0] = arg1;
240 args[1] = arg2;
241 args[2] = arg3;
242 args[3] = arg4;
243 t0 = tcg_const_ptr((tcg_target_long)func);
244 tcg_gen_call(&tcg_ctx,
245 t0, TCG_HELPER_CALL_FLAGS,
246 0, NULL, 4, args);
247 tcg_temp_free(t0);
250 static inline void tcg_gen_helper_1_0(void *func, TCGv ret)
252 TCGv t0;
253 t0 = tcg_const_ptr((tcg_target_long)func);
254 tcg_gen_call(&tcg_ctx,
255 t0, TCG_HELPER_CALL_FLAGS,
256 1, &ret, 0, NULL);
257 tcg_temp_free(t0);
260 static inline void tcg_gen_helper_1_1(void *func, TCGv ret, TCGv arg1)
262 TCGv t0;
263 t0 = tcg_const_ptr((tcg_target_long)func);
264 tcg_gen_call(&tcg_ctx,
265 t0, TCG_HELPER_CALL_FLAGS,
266 1, &ret, 1, &arg1);
267 tcg_temp_free(t0);
270 static inline void tcg_gen_helper_1_2(void *func, TCGv ret,
271 TCGv arg1, TCGv arg2)
273 TCGv args[2];
274 TCGv t0;
275 args[0] = arg1;
276 args[1] = arg2;
277 t0 = tcg_const_ptr((tcg_target_long)func);
278 tcg_gen_call(&tcg_ctx,
279 t0, TCG_HELPER_CALL_FLAGS,
280 1, &ret, 2, args);
281 tcg_temp_free(t0);
284 static inline void tcg_gen_helper_1_3(void *func, TCGv ret,
285 TCGv arg1, TCGv arg2, TCGv arg3)
287 TCGv args[3];
288 TCGv t0;
289 args[0] = arg1;
290 args[1] = arg2;
291 args[2] = arg3;
292 t0 = tcg_const_ptr((tcg_target_long)func);
293 tcg_gen_call(&tcg_ctx,
294 t0, TCG_HELPER_CALL_FLAGS,
295 1, &ret, 3, args);
296 tcg_temp_free(t0);
299 static inline void tcg_gen_helper_1_4(void *func, TCGv ret,
300 TCGv arg1, TCGv arg2, TCGv arg3,
301 TCGv arg4)
303 TCGv args[4];
304 TCGv t0;
305 args[0] = arg1;
306 args[1] = arg2;
307 args[2] = arg3;
308 args[3] = arg4;
309 t0 = tcg_const_ptr((tcg_target_long)func);
310 tcg_gen_call(&tcg_ctx,
311 t0, TCG_HELPER_CALL_FLAGS,
312 1, &ret, 4, args);
313 tcg_temp_free(t0);
316 /* 32 bit ops */
318 static inline void tcg_gen_ld8u_i32(TCGv ret, TCGv arg2, tcg_target_long offset)
320 tcg_gen_op3i(INDEX_op_ld8u_i32, ret, arg2, offset);
323 static inline void tcg_gen_ld8s_i32(TCGv ret, TCGv arg2, tcg_target_long offset)
325 tcg_gen_op3i(INDEX_op_ld8s_i32, ret, arg2, offset);
328 static inline void tcg_gen_ld16u_i32(TCGv ret, TCGv arg2, tcg_target_long offset)
330 tcg_gen_op3i(INDEX_op_ld16u_i32, ret, arg2, offset);
333 static inline void tcg_gen_ld16s_i32(TCGv ret, TCGv arg2, tcg_target_long offset)
335 tcg_gen_op3i(INDEX_op_ld16s_i32, ret, arg2, offset);
338 static inline void tcg_gen_ld_i32(TCGv ret, TCGv arg2, tcg_target_long offset)
340 tcg_gen_op3i(INDEX_op_ld_i32, ret, arg2, offset);
343 static inline void tcg_gen_st8_i32(TCGv arg1, TCGv arg2, tcg_target_long offset)
345 tcg_gen_op3i(INDEX_op_st8_i32, arg1, arg2, offset);
348 static inline void tcg_gen_st16_i32(TCGv arg1, TCGv arg2, tcg_target_long offset)
350 tcg_gen_op3i(INDEX_op_st16_i32, arg1, arg2, offset);
353 static inline void tcg_gen_st_i32(TCGv arg1, TCGv arg2, tcg_target_long offset)
355 tcg_gen_op3i(INDEX_op_st_i32, arg1, arg2, offset);
358 static inline void tcg_gen_add_i32(TCGv ret, TCGv arg1, TCGv arg2)
360 tcg_gen_op3(INDEX_op_add_i32, ret, arg1, arg2);
363 static inline void tcg_gen_addi_i32(TCGv ret, TCGv arg1, int32_t arg2)
365 /* some cases can be optimized here */
366 if (arg2 == 0) {
367 tcg_gen_mov_i32(ret, arg1);
368 } else {
369 TCGv t0 = tcg_const_i32(arg2);
370 tcg_gen_add_i32(ret, arg1, t0);
371 tcg_temp_free(t0);
375 static inline void tcg_gen_sub_i32(TCGv ret, TCGv arg1, TCGv arg2)
377 tcg_gen_op3(INDEX_op_sub_i32, ret, arg1, arg2);
380 static inline void tcg_gen_subi_i32(TCGv ret, TCGv arg1, int32_t arg2)
382 /* some cases can be optimized here */
383 if (arg2 == 0) {
384 tcg_gen_mov_i32(ret, arg1);
385 } else {
386 TCGv t0 = tcg_const_i32(arg2);
387 tcg_gen_sub_i32(ret, arg1, t0);
388 tcg_temp_free(t0);
392 static inline void tcg_gen_and_i32(TCGv ret, TCGv arg1, TCGv arg2)
394 tcg_gen_op3(INDEX_op_and_i32, ret, arg1, arg2);
397 static inline void tcg_gen_andi_i32(TCGv ret, TCGv arg1, int32_t arg2)
399 /* some cases can be optimized here */
400 if (arg2 == 0) {
401 tcg_gen_movi_i32(ret, 0);
402 } else if (arg2 == 0xffffffff) {
403 tcg_gen_mov_i32(ret, arg1);
404 } else {
405 TCGv t0 = tcg_const_i32(arg2);
406 tcg_gen_and_i32(ret, arg1, t0);
407 tcg_temp_free(t0);
411 static inline void tcg_gen_or_i32(TCGv ret, TCGv arg1, TCGv arg2)
413 tcg_gen_op3(INDEX_op_or_i32, ret, arg1, arg2);
416 static inline void tcg_gen_ori_i32(TCGv ret, TCGv arg1, int32_t arg2)
418 /* some cases can be optimized here */
419 if (arg2 == 0xffffffff) {
420 tcg_gen_movi_i32(ret, 0xffffffff);
421 } else if (arg2 == 0) {
422 tcg_gen_mov_i32(ret, arg1);
423 } else {
424 TCGv t0 = tcg_const_i32(arg2);
425 tcg_gen_or_i32(ret, arg1, t0);
426 tcg_temp_free(t0);
430 static inline void tcg_gen_xor_i32(TCGv ret, TCGv arg1, TCGv arg2)
432 tcg_gen_op3(INDEX_op_xor_i32, ret, arg1, arg2);
435 static inline void tcg_gen_xori_i32(TCGv ret, TCGv arg1, int32_t arg2)
437 /* some cases can be optimized here */
438 if (arg2 == 0) {
439 tcg_gen_mov_i32(ret, arg1);
440 } else {
441 TCGv t0 = tcg_const_i32(arg2);
442 tcg_gen_xor_i32(ret, arg1, t0);
443 tcg_temp_free(t0);
447 static inline void tcg_gen_shl_i32(TCGv ret, TCGv arg1, TCGv arg2)
449 tcg_gen_op3(INDEX_op_shl_i32, ret, arg1, arg2);
452 static inline void tcg_gen_shli_i32(TCGv ret, TCGv arg1, int32_t arg2)
454 if (arg2 == 0) {
455 tcg_gen_mov_i32(ret, arg1);
456 } else {
457 TCGv t0 = tcg_const_i32(arg2);
458 tcg_gen_shl_i32(ret, arg1, t0);
459 tcg_temp_free(t0);
463 static inline void tcg_gen_shr_i32(TCGv ret, TCGv arg1, TCGv arg2)
465 tcg_gen_op3(INDEX_op_shr_i32, ret, arg1, arg2);
468 static inline void tcg_gen_shri_i32(TCGv ret, TCGv arg1, int32_t arg2)
470 if (arg2 == 0) {
471 tcg_gen_mov_i32(ret, arg1);
472 } else {
473 TCGv t0 = tcg_const_i32(arg2);
474 tcg_gen_shr_i32(ret, arg1, t0);
475 tcg_temp_free(t0);
479 static inline void tcg_gen_sar_i32(TCGv ret, TCGv arg1, TCGv arg2)
481 tcg_gen_op3(INDEX_op_sar_i32, ret, arg1, arg2);
484 static inline void tcg_gen_sari_i32(TCGv ret, TCGv arg1, int32_t arg2)
486 if (arg2 == 0) {
487 tcg_gen_mov_i32(ret, arg1);
488 } else {
489 TCGv t0 = tcg_const_i32(arg2);
490 tcg_gen_sar_i32(ret, arg1, t0);
491 tcg_temp_free(t0);
495 static inline void tcg_gen_brcond_i32(int cond, TCGv arg1, TCGv arg2,
496 int label_index)
498 tcg_gen_op4ii(INDEX_op_brcond_i32, arg1, arg2, cond, label_index);
501 static inline void tcg_gen_brcondi_i32(int cond, TCGv arg1, int32_t arg2,
502 int label_index)
504 TCGv t0 = tcg_const_i32(arg2);
505 tcg_gen_brcond_i32(cond, arg1, t0, label_index);
506 tcg_temp_free(t0);
509 static inline void tcg_gen_mul_i32(TCGv ret, TCGv arg1, TCGv arg2)
511 tcg_gen_op3(INDEX_op_mul_i32, ret, arg1, arg2);
514 static inline void tcg_gen_muli_i32(TCGv ret, TCGv arg1, int32_t arg2)
516 TCGv t0 = tcg_const_i32(arg2);
517 tcg_gen_mul_i32(ret, arg1, t0);
518 tcg_temp_free(t0);
521 #ifdef TCG_TARGET_HAS_div_i32
522 static inline void tcg_gen_div_i32(TCGv ret, TCGv arg1, TCGv arg2)
524 tcg_gen_op3(INDEX_op_div_i32, ret, arg1, arg2);
527 static inline void tcg_gen_rem_i32(TCGv ret, TCGv arg1, TCGv arg2)
529 tcg_gen_op3(INDEX_op_rem_i32, ret, arg1, arg2);
532 static inline void tcg_gen_divu_i32(TCGv ret, TCGv arg1, TCGv arg2)
534 tcg_gen_op3(INDEX_op_divu_i32, ret, arg1, arg2);
537 static inline void tcg_gen_remu_i32(TCGv ret, TCGv arg1, TCGv arg2)
539 tcg_gen_op3(INDEX_op_remu_i32, ret, arg1, arg2);
541 #else
542 static inline void tcg_gen_div_i32(TCGv ret, TCGv arg1, TCGv arg2)
544 TCGv t0;
545 t0 = tcg_temp_new(TCG_TYPE_I32);
546 tcg_gen_sari_i32(t0, arg1, 31);
547 tcg_gen_op5(INDEX_op_div2_i32, ret, t0, arg1, t0, arg2);
548 tcg_temp_free(t0);
551 static inline void tcg_gen_rem_i32(TCGv ret, TCGv arg1, TCGv arg2)
553 TCGv t0;
554 t0 = tcg_temp_new(TCG_TYPE_I32);
555 tcg_gen_sari_i32(t0, arg1, 31);
556 tcg_gen_op5(INDEX_op_div2_i32, t0, ret, arg1, t0, arg2);
557 tcg_temp_free(t0);
560 static inline void tcg_gen_divu_i32(TCGv ret, TCGv arg1, TCGv arg2)
562 TCGv t0;
563 t0 = tcg_temp_new(TCG_TYPE_I32);
564 tcg_gen_movi_i32(t0, 0);
565 tcg_gen_op5(INDEX_op_divu2_i32, ret, t0, arg1, t0, arg2);
566 tcg_temp_free(t0);
569 static inline void tcg_gen_remu_i32(TCGv ret, TCGv arg1, TCGv arg2)
571 TCGv t0;
572 t0 = tcg_temp_new(TCG_TYPE_I32);
573 tcg_gen_movi_i32(t0, 0);
574 tcg_gen_op5(INDEX_op_divu2_i32, t0, ret, arg1, t0, arg2);
575 tcg_temp_free(t0);
577 #endif
579 #if TCG_TARGET_REG_BITS == 32
581 static inline void tcg_gen_mov_i64(TCGv ret, TCGv arg)
583 if (GET_TCGV(ret) != GET_TCGV(arg)) {
584 tcg_gen_mov_i32(ret, arg);
585 tcg_gen_mov_i32(TCGV_HIGH(ret), TCGV_HIGH(arg));
589 static inline void tcg_gen_movi_i64(TCGv ret, int64_t arg)
591 tcg_gen_movi_i32(ret, arg);
592 tcg_gen_movi_i32(TCGV_HIGH(ret), arg >> 32);
595 static inline void tcg_gen_ld8u_i64(TCGv ret, TCGv arg2, tcg_target_long offset)
597 tcg_gen_ld8u_i32(ret, arg2, offset);
598 tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
601 static inline void tcg_gen_ld8s_i64(TCGv ret, TCGv arg2, tcg_target_long offset)
603 tcg_gen_ld8s_i32(ret, arg2, offset);
604 tcg_gen_sari_i32(TCGV_HIGH(ret), ret, 31);
607 static inline void tcg_gen_ld16u_i64(TCGv ret, TCGv arg2, tcg_target_long offset)
609 tcg_gen_ld16u_i32(ret, arg2, offset);
610 tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
613 static inline void tcg_gen_ld16s_i64(TCGv ret, TCGv arg2, tcg_target_long offset)
615 tcg_gen_ld16s_i32(ret, arg2, offset);
616 tcg_gen_sari_i32(TCGV_HIGH(ret), ret, 31);
619 static inline void tcg_gen_ld32u_i64(TCGv ret, TCGv arg2, tcg_target_long offset)
621 tcg_gen_ld_i32(ret, arg2, offset);
622 tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
625 static inline void tcg_gen_ld32s_i64(TCGv ret, TCGv arg2, tcg_target_long offset)
627 tcg_gen_ld_i32(ret, arg2, offset);
628 tcg_gen_sari_i32(TCGV_HIGH(ret), ret, 31);
631 static inline void tcg_gen_ld_i64(TCGv ret, TCGv arg2, tcg_target_long offset)
633 /* since arg2 and ret have different types, they cannot be the
634 same temporary */
635 #ifdef TCG_TARGET_WORDS_BIGENDIAN
636 tcg_gen_ld_i32(TCGV_HIGH(ret), arg2, offset);
637 tcg_gen_ld_i32(ret, arg2, offset + 4);
638 #else
639 tcg_gen_ld_i32(ret, arg2, offset);
640 tcg_gen_ld_i32(TCGV_HIGH(ret), arg2, offset + 4);
641 #endif
644 static inline void tcg_gen_st8_i64(TCGv arg1, TCGv arg2, tcg_target_long offset)
646 tcg_gen_st8_i32(arg1, arg2, offset);
649 static inline void tcg_gen_st16_i64(TCGv arg1, TCGv arg2, tcg_target_long offset)
651 tcg_gen_st16_i32(arg1, arg2, offset);
654 static inline void tcg_gen_st32_i64(TCGv arg1, TCGv arg2, tcg_target_long offset)
656 tcg_gen_st_i32(arg1, arg2, offset);
659 static inline void tcg_gen_st_i64(TCGv arg1, TCGv arg2, tcg_target_long offset)
661 #ifdef TCG_TARGET_WORDS_BIGENDIAN
662 tcg_gen_st_i32(TCGV_HIGH(arg1), arg2, offset);
663 tcg_gen_st_i32(arg1, arg2, offset + 4);
664 #else
665 tcg_gen_st_i32(arg1, arg2, offset);
666 tcg_gen_st_i32(TCGV_HIGH(arg1), arg2, offset + 4);
667 #endif
670 static inline void tcg_gen_add_i64(TCGv ret, TCGv arg1, TCGv arg2)
672 tcg_gen_op6(INDEX_op_add2_i32, ret, TCGV_HIGH(ret),
673 arg1, TCGV_HIGH(arg1), arg2, TCGV_HIGH(arg2));
676 static inline void tcg_gen_addi_i64(TCGv ret, TCGv arg1, int64_t arg2)
678 TCGv t0 = tcg_const_i64(arg2);
679 tcg_gen_add_i64(ret, arg1, t0);
680 tcg_temp_free(t0);
683 static inline void tcg_gen_sub_i64(TCGv ret, TCGv arg1, TCGv arg2)
685 tcg_gen_op6(INDEX_op_sub2_i32, ret, TCGV_HIGH(ret),
686 arg1, TCGV_HIGH(arg1), arg2, TCGV_HIGH(arg2));
689 static inline void tcg_gen_subi_i64(TCGv ret, TCGv arg1, int64_t arg2)
691 TCGv t0 = tcg_const_i64(arg2);
692 tcg_gen_sub_i64(ret, arg1, t0);
693 tcg_temp_free(t0);
696 static inline void tcg_gen_and_i64(TCGv ret, TCGv arg1, TCGv arg2)
698 tcg_gen_and_i32(ret, arg1, arg2);
699 tcg_gen_and_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), TCGV_HIGH(arg2));
702 static inline void tcg_gen_andi_i64(TCGv ret, TCGv arg1, int64_t arg2)
704 tcg_gen_andi_i32(ret, arg1, arg2);
705 tcg_gen_andi_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), arg2 >> 32);
708 static inline void tcg_gen_or_i64(TCGv ret, TCGv arg1, TCGv arg2)
710 tcg_gen_or_i32(ret, arg1, arg2);
711 tcg_gen_or_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), TCGV_HIGH(arg2));
714 static inline void tcg_gen_ori_i64(TCGv ret, TCGv arg1, int64_t arg2)
716 tcg_gen_ori_i32(ret, arg1, arg2);
717 tcg_gen_ori_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), arg2 >> 32);
720 static inline void tcg_gen_xor_i64(TCGv ret, TCGv arg1, TCGv arg2)
722 tcg_gen_xor_i32(ret, arg1, arg2);
723 tcg_gen_xor_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), TCGV_HIGH(arg2));
726 static inline void tcg_gen_xori_i64(TCGv ret, TCGv arg1, int64_t arg2)
728 tcg_gen_xori_i32(ret, arg1, arg2);
729 tcg_gen_xori_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), arg2 >> 32);
732 /* XXX: use generic code when basic block handling is OK or CPU
733 specific code (x86) */
734 static inline void tcg_gen_shl_i64(TCGv ret, TCGv arg1, TCGv arg2)
736 tcg_gen_helper_1_2(tcg_helper_shl_i64, ret, arg1, arg2);
739 static inline void tcg_gen_shli_i64(TCGv ret, TCGv arg1, int64_t arg2)
741 tcg_gen_shifti_i64(ret, arg1, arg2, 0, 0);
744 static inline void tcg_gen_shr_i64(TCGv ret, TCGv arg1, TCGv arg2)
746 tcg_gen_helper_1_2(tcg_helper_shr_i64, ret, arg1, arg2);
749 static inline void tcg_gen_shri_i64(TCGv ret, TCGv arg1, int64_t arg2)
751 tcg_gen_shifti_i64(ret, arg1, arg2, 1, 0);
754 static inline void tcg_gen_sar_i64(TCGv ret, TCGv arg1, TCGv arg2)
756 tcg_gen_helper_1_2(tcg_helper_sar_i64, ret, arg1, arg2);
759 static inline void tcg_gen_sari_i64(TCGv ret, TCGv arg1, int64_t arg2)
761 tcg_gen_shifti_i64(ret, arg1, arg2, 1, 1);
764 static inline void tcg_gen_brcond_i64(int cond, TCGv arg1, TCGv arg2,
765 int label_index)
767 tcg_gen_op6ii(INDEX_op_brcond2_i32,
768 arg1, TCGV_HIGH(arg1), arg2, TCGV_HIGH(arg2),
769 cond, label_index);
772 static inline void tcg_gen_mul_i64(TCGv ret, TCGv arg1, TCGv arg2)
774 TCGv t0, t1;
776 t0 = tcg_temp_new(TCG_TYPE_I64);
777 t1 = tcg_temp_new(TCG_TYPE_I32);
779 tcg_gen_op4(INDEX_op_mulu2_i32, t0, TCGV_HIGH(t0), arg1, arg2);
781 tcg_gen_mul_i32(t1, arg1, TCGV_HIGH(arg2));
782 tcg_gen_add_i32(TCGV_HIGH(t0), TCGV_HIGH(t0), t1);
783 tcg_gen_mul_i32(t1, TCGV_HIGH(arg1), arg2);
784 tcg_gen_add_i32(TCGV_HIGH(t0), TCGV_HIGH(t0), t1);
786 tcg_gen_mov_i64(ret, t0);
787 tcg_temp_free(t0);
788 tcg_temp_free(t1);
791 static inline void tcg_gen_muli_i64(TCGv ret, TCGv arg1, int64_t arg2)
793 TCGv t0 = tcg_const_i64(arg2);
794 tcg_gen_mul_i64(ret, arg1, t0);
795 tcg_temp_free(t0);
798 static inline void tcg_gen_div_i64(TCGv ret, TCGv arg1, TCGv arg2)
800 tcg_gen_helper_1_2(tcg_helper_div_i64, ret, arg1, arg2);
803 static inline void tcg_gen_rem_i64(TCGv ret, TCGv arg1, TCGv arg2)
805 tcg_gen_helper_1_2(tcg_helper_rem_i64, ret, arg1, arg2);
808 static inline void tcg_gen_divu_i64(TCGv ret, TCGv arg1, TCGv arg2)
810 tcg_gen_helper_1_2(tcg_helper_divu_i64, ret, arg1, arg2);
813 static inline void tcg_gen_remu_i64(TCGv ret, TCGv arg1, TCGv arg2)
815 tcg_gen_helper_1_2(tcg_helper_remu_i64, ret, arg1, arg2);
818 #else
820 static inline void tcg_gen_mov_i64(TCGv ret, TCGv arg)
822 if (GET_TCGV(ret) != GET_TCGV(arg))
823 tcg_gen_op2(INDEX_op_mov_i64, ret, arg);
826 static inline void tcg_gen_movi_i64(TCGv ret, int64_t arg)
828 tcg_gen_op2i(INDEX_op_movi_i64, ret, arg);
831 static inline void tcg_gen_ld8u_i64(TCGv ret, TCGv arg2,
832 tcg_target_long offset)
834 tcg_gen_op3i(INDEX_op_ld8u_i64, ret, arg2, offset);
837 static inline void tcg_gen_ld8s_i64(TCGv ret, TCGv arg2,
838 tcg_target_long offset)
840 tcg_gen_op3i(INDEX_op_ld8s_i64, ret, arg2, offset);
843 static inline void tcg_gen_ld16u_i64(TCGv ret, TCGv arg2,
844 tcg_target_long offset)
846 tcg_gen_op3i(INDEX_op_ld16u_i64, ret, arg2, offset);
849 static inline void tcg_gen_ld16s_i64(TCGv ret, TCGv arg2,
850 tcg_target_long offset)
852 tcg_gen_op3i(INDEX_op_ld16s_i64, ret, arg2, offset);
855 static inline void tcg_gen_ld32u_i64(TCGv ret, TCGv arg2,
856 tcg_target_long offset)
858 tcg_gen_op3i(INDEX_op_ld32u_i64, ret, arg2, offset);
861 static inline void tcg_gen_ld32s_i64(TCGv ret, TCGv arg2,
862 tcg_target_long offset)
864 tcg_gen_op3i(INDEX_op_ld32s_i64, ret, arg2, offset);
867 static inline void tcg_gen_ld_i64(TCGv ret, TCGv arg2, tcg_target_long offset)
869 tcg_gen_op3i(INDEX_op_ld_i64, ret, arg2, offset);
872 static inline void tcg_gen_st8_i64(TCGv arg1, TCGv arg2,
873 tcg_target_long offset)
875 tcg_gen_op3i(INDEX_op_st8_i64, arg1, arg2, offset);
878 static inline void tcg_gen_st16_i64(TCGv arg1, TCGv arg2,
879 tcg_target_long offset)
881 tcg_gen_op3i(INDEX_op_st16_i64, arg1, arg2, offset);
884 static inline void tcg_gen_st32_i64(TCGv arg1, TCGv arg2,
885 tcg_target_long offset)
887 tcg_gen_op3i(INDEX_op_st32_i64, arg1, arg2, offset);
890 static inline void tcg_gen_st_i64(TCGv arg1, TCGv arg2, tcg_target_long offset)
892 tcg_gen_op3i(INDEX_op_st_i64, arg1, arg2, offset);
895 static inline void tcg_gen_add_i64(TCGv ret, TCGv arg1, TCGv arg2)
897 tcg_gen_op3(INDEX_op_add_i64, ret, arg1, arg2);
900 static inline void tcg_gen_addi_i64(TCGv ret, TCGv arg1, int64_t arg2)
902 TCGv t0 = tcg_const_i64(arg2);
903 tcg_gen_add_i64(ret, arg1, t0);
904 tcg_temp_free(t0);
907 static inline void tcg_gen_sub_i64(TCGv ret, TCGv arg1, TCGv arg2)
909 tcg_gen_op3(INDEX_op_sub_i64, ret, arg1, arg2);
912 static inline void tcg_gen_subi_i64(TCGv ret, TCGv arg1, int64_t arg2)
914 TCGv t0 = tcg_const_i64(arg2);
915 tcg_gen_sub_i64(ret, arg1, t0);
916 tcg_temp_free(t0);
919 static inline void tcg_gen_and_i64(TCGv ret, TCGv arg1, TCGv arg2)
921 tcg_gen_op3(INDEX_op_and_i64, ret, arg1, arg2);
924 static inline void tcg_gen_andi_i64(TCGv ret, TCGv arg1, int64_t arg2)
926 TCGv t0 = tcg_const_i64(arg2);
927 tcg_gen_and_i64(ret, arg1, t0);
928 tcg_temp_free(t0);
931 static inline void tcg_gen_or_i64(TCGv ret, TCGv arg1, TCGv arg2)
933 tcg_gen_op3(INDEX_op_or_i64, ret, arg1, arg2);
936 static inline void tcg_gen_ori_i64(TCGv ret, TCGv arg1, int64_t arg2)
938 TCGv t0 = tcg_const_i64(arg2);
939 tcg_gen_or_i64(ret, arg1, t0);
940 tcg_temp_free(t0);
943 static inline void tcg_gen_xor_i64(TCGv ret, TCGv arg1, TCGv arg2)
945 tcg_gen_op3(INDEX_op_xor_i64, ret, arg1, arg2);
948 static inline void tcg_gen_xori_i64(TCGv ret, TCGv arg1, int64_t arg2)
950 TCGv t0 = tcg_const_i64(arg2);
951 tcg_gen_xor_i64(ret, arg1, t0);
952 tcg_temp_free(t0);
955 static inline void tcg_gen_shl_i64(TCGv ret, TCGv arg1, TCGv arg2)
957 tcg_gen_op3(INDEX_op_shl_i64, ret, arg1, arg2);
960 static inline void tcg_gen_shli_i64(TCGv ret, TCGv arg1, int64_t arg2)
962 if (arg2 == 0) {
963 tcg_gen_mov_i64(ret, arg1);
964 } else {
965 TCGv t0 = tcg_const_i64(arg2);
966 tcg_gen_shl_i64(ret, arg1, t0);
967 tcg_temp_free(t0);
971 static inline void tcg_gen_shr_i64(TCGv ret, TCGv arg1, TCGv arg2)
973 tcg_gen_op3(INDEX_op_shr_i64, ret, arg1, arg2);
976 static inline void tcg_gen_shri_i64(TCGv ret, TCGv arg1, int64_t arg2)
978 if (arg2 == 0) {
979 tcg_gen_mov_i64(ret, arg1);
980 } else {
981 TCGv t0 = tcg_const_i64(arg2);
982 tcg_gen_shr_i64(ret, arg1, t0);
983 tcg_temp_free(t0);
987 static inline void tcg_gen_sar_i64(TCGv ret, TCGv arg1, TCGv arg2)
989 tcg_gen_op3(INDEX_op_sar_i64, ret, arg1, arg2);
992 static inline void tcg_gen_sari_i64(TCGv ret, TCGv arg1, int64_t arg2)
994 if (arg2 == 0) {
995 tcg_gen_mov_i64(ret, arg1);
996 } else {
997 TCGv t0 = tcg_const_i64(arg2);
998 tcg_gen_sar_i64(ret, arg1, t0);
999 tcg_temp_free(t0);
1003 static inline void tcg_gen_brcond_i64(int cond, TCGv arg1, TCGv arg2,
1004 int label_index)
1006 tcg_gen_op4ii(INDEX_op_brcond_i64, arg1, arg2, cond, label_index);
1009 static inline void tcg_gen_mul_i64(TCGv ret, TCGv arg1, TCGv arg2)
1011 tcg_gen_op3(INDEX_op_mul_i64, ret, arg1, arg2);
1014 static inline void tcg_gen_muli_i64(TCGv ret, TCGv arg1, int64_t arg2)
1016 TCGv t0 = tcg_const_i64(arg2);
1017 tcg_gen_mul_i64(ret, arg1, t0);
1018 tcg_temp_free(t0);
1021 #ifdef TCG_TARGET_HAS_div_i64
1022 static inline void tcg_gen_div_i64(TCGv ret, TCGv arg1, TCGv arg2)
1024 tcg_gen_op3(INDEX_op_div_i64, ret, arg1, arg2);
1027 static inline void tcg_gen_rem_i64(TCGv ret, TCGv arg1, TCGv arg2)
1029 tcg_gen_op3(INDEX_op_rem_i64, ret, arg1, arg2);
1032 static inline void tcg_gen_divu_i64(TCGv ret, TCGv arg1, TCGv arg2)
1034 tcg_gen_op3(INDEX_op_divu_i64, ret, arg1, arg2);
1037 static inline void tcg_gen_remu_i64(TCGv ret, TCGv arg1, TCGv arg2)
1039 tcg_gen_op3(INDEX_op_remu_i64, ret, arg1, arg2);
1041 #else
1042 static inline void tcg_gen_div_i64(TCGv ret, TCGv arg1, TCGv arg2)
1044 TCGv t0;
1045 t0 = tcg_temp_new(TCG_TYPE_I64);
1046 tcg_gen_sari_i64(t0, arg1, 63);
1047 tcg_gen_op5(INDEX_op_div2_i64, ret, t0, arg1, t0, arg2);
1048 tcg_temp_free(t0);
1051 static inline void tcg_gen_rem_i64(TCGv ret, TCGv arg1, TCGv arg2)
1053 TCGv t0;
1054 t0 = tcg_temp_new(TCG_TYPE_I64);
1055 tcg_gen_sari_i64(t0, arg1, 63);
1056 tcg_gen_op5(INDEX_op_div2_i64, t0, ret, arg1, t0, arg2);
1057 tcg_temp_free(t0);
1060 static inline void tcg_gen_divu_i64(TCGv ret, TCGv arg1, TCGv arg2)
1062 TCGv t0;
1063 t0 = tcg_temp_new(TCG_TYPE_I64);
1064 tcg_gen_movi_i64(t0, 0);
1065 tcg_gen_op5(INDEX_op_divu2_i64, ret, t0, arg1, t0, arg2);
1066 tcg_temp_free(t0);
1069 static inline void tcg_gen_remu_i64(TCGv ret, TCGv arg1, TCGv arg2)
1071 TCGv t0;
1072 t0 = tcg_temp_new(TCG_TYPE_I64);
1073 tcg_gen_movi_i64(t0, 0);
1074 tcg_gen_op5(INDEX_op_divu2_i64, t0, ret, arg1, t0, arg2);
1075 tcg_temp_free(t0);
1077 #endif
1079 #endif
1081 static inline void tcg_gen_brcondi_i64(int cond, TCGv arg1, int64_t arg2,
1082 int label_index)
1084 TCGv t0 = tcg_const_i64(arg2);
1085 tcg_gen_brcond_i64(cond, arg1, t0, label_index);
1086 tcg_temp_free(t0);
1089 /***************************************/
1090 /* optional operations */
1092 static inline void tcg_gen_ext8s_i32(TCGv ret, TCGv arg)
1094 #ifdef TCG_TARGET_HAS_ext8s_i32
1095 tcg_gen_op2(INDEX_op_ext8s_i32, ret, arg);
1096 #else
1097 tcg_gen_shli_i32(ret, arg, 24);
1098 tcg_gen_sari_i32(ret, ret, 24);
1099 #endif
1102 static inline void tcg_gen_ext16s_i32(TCGv ret, TCGv arg)
1104 #ifdef TCG_TARGET_HAS_ext16s_i32
1105 tcg_gen_op2(INDEX_op_ext16s_i32, ret, arg);
1106 #else
1107 tcg_gen_shli_i32(ret, arg, 16);
1108 tcg_gen_sari_i32(ret, ret, 16);
1109 #endif
1112 /* These are currently just for convenience.
1113 We assume a target will recognise these automatically . */
1114 static inline void tcg_gen_ext8u_i32(TCGv ret, TCGv arg)
1116 tcg_gen_andi_i32(ret, arg, 0xffu);
1119 static inline void tcg_gen_ext16u_i32(TCGv ret, TCGv arg)
1121 tcg_gen_andi_i32(ret, arg, 0xffffu);
1124 /* Note: we assume the two high bytes are set to zero */
1125 static inline void tcg_gen_bswap16_i32(TCGv ret, TCGv arg)
1127 #ifdef TCG_TARGET_HAS_bswap16_i32
1128 tcg_gen_op2(INDEX_op_bswap16_i32, ret, arg);
1129 #else
1130 TCGv t0, t1;
1131 t0 = tcg_temp_new(TCG_TYPE_I32);
1132 t1 = tcg_temp_new(TCG_TYPE_I32);
1134 tcg_gen_shri_i32(t0, arg, 8);
1135 tcg_gen_andi_i32(t1, arg, 0x000000ff);
1136 tcg_gen_shli_i32(t1, t1, 8);
1137 tcg_gen_or_i32(ret, t0, t1);
1138 tcg_temp_free(t0);
1139 tcg_temp_free(t1);
1140 #endif
1143 static inline void tcg_gen_bswap_i32(TCGv ret, TCGv arg)
1145 #ifdef TCG_TARGET_HAS_bswap_i32
1146 tcg_gen_op2(INDEX_op_bswap_i32, ret, arg);
1147 #else
1148 TCGv t0, t1;
1149 t0 = tcg_temp_new(TCG_TYPE_I32);
1150 t1 = tcg_temp_new(TCG_TYPE_I32);
1152 tcg_gen_shli_i32(t0, arg, 24);
1154 tcg_gen_andi_i32(t1, arg, 0x0000ff00);
1155 tcg_gen_shli_i32(t1, t1, 8);
1156 tcg_gen_or_i32(t0, t0, t1);
1158 tcg_gen_shri_i32(t1, arg, 8);
1159 tcg_gen_andi_i32(t1, t1, 0x0000ff00);
1160 tcg_gen_or_i32(t0, t0, t1);
1162 tcg_gen_shri_i32(t1, arg, 24);
1163 tcg_gen_or_i32(ret, t0, t1);
1164 tcg_temp_free(t0);
1165 tcg_temp_free(t1);
1166 #endif
1169 #if TCG_TARGET_REG_BITS == 32
1170 static inline void tcg_gen_ext8s_i64(TCGv ret, TCGv arg)
1172 tcg_gen_ext8s_i32(ret, arg);
1173 tcg_gen_sari_i32(TCGV_HIGH(ret), ret, 31);
1176 static inline void tcg_gen_ext16s_i64(TCGv ret, TCGv arg)
1178 tcg_gen_ext16s_i32(ret, arg);
1179 tcg_gen_sari_i32(TCGV_HIGH(ret), ret, 31);
1182 static inline void tcg_gen_ext32s_i64(TCGv ret, TCGv arg)
1184 tcg_gen_mov_i32(ret, arg);
1185 tcg_gen_sari_i32(TCGV_HIGH(ret), ret, 31);
1188 static inline void tcg_gen_ext8u_i64(TCGv ret, TCGv arg)
1190 tcg_gen_ext8u_i32(ret, arg);
1191 tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
1194 static inline void tcg_gen_ext16u_i64(TCGv ret, TCGv arg)
1196 tcg_gen_ext16u_i32(ret, arg);
1197 tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
1200 static inline void tcg_gen_ext32u_i64(TCGv ret, TCGv arg)
1202 tcg_gen_mov_i32(ret, arg);
1203 tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
1206 static inline void tcg_gen_trunc_i64_i32(TCGv ret, TCGv arg)
1208 tcg_gen_mov_i32(ret, arg);
1211 static inline void tcg_gen_extu_i32_i64(TCGv ret, TCGv arg)
1213 tcg_gen_mov_i32(ret, arg);
1214 tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
1217 static inline void tcg_gen_ext_i32_i64(TCGv ret, TCGv arg)
1219 tcg_gen_mov_i32(ret, arg);
1220 tcg_gen_sari_i32(TCGV_HIGH(ret), ret, 31);
1223 static inline void tcg_gen_bswap_i64(TCGv ret, TCGv arg)
1225 TCGv t0, t1;
1226 t0 = tcg_temp_new(TCG_TYPE_I32);
1227 t1 = tcg_temp_new(TCG_TYPE_I32);
1229 tcg_gen_bswap_i32(t0, arg);
1230 tcg_gen_bswap_i32(t1, TCGV_HIGH(arg));
1231 tcg_gen_mov_i32(ret, t1);
1232 tcg_gen_mov_i32(TCGV_HIGH(ret), t0);
1233 tcg_temp_free(t0);
1234 tcg_temp_free(t1);
1236 #else
1238 static inline void tcg_gen_ext8s_i64(TCGv ret, TCGv arg)
1240 #ifdef TCG_TARGET_HAS_ext8s_i64
1241 tcg_gen_op2(INDEX_op_ext8s_i64, ret, arg);
1242 #else
1243 tcg_gen_shli_i64(ret, arg, 56);
1244 tcg_gen_sari_i64(ret, ret, 56);
1245 #endif
1248 static inline void tcg_gen_ext16s_i64(TCGv ret, TCGv arg)
1250 #ifdef TCG_TARGET_HAS_ext16s_i64
1251 tcg_gen_op2(INDEX_op_ext16s_i64, ret, arg);
1252 #else
1253 tcg_gen_shli_i64(ret, arg, 48);
1254 tcg_gen_sari_i64(ret, ret, 48);
1255 #endif
1258 static inline void tcg_gen_ext32s_i64(TCGv ret, TCGv arg)
1260 #ifdef TCG_TARGET_HAS_ext32s_i64
1261 tcg_gen_op2(INDEX_op_ext32s_i64, ret, arg);
1262 #else
1263 tcg_gen_shli_i64(ret, arg, 32);
1264 tcg_gen_sari_i64(ret, ret, 32);
1265 #endif
1268 static inline void tcg_gen_ext8u_i64(TCGv ret, TCGv arg)
1270 tcg_gen_andi_i64(ret, arg, 0xffu);
1273 static inline void tcg_gen_ext16u_i64(TCGv ret, TCGv arg)
1275 tcg_gen_andi_i64(ret, arg, 0xffffu);
1278 static inline void tcg_gen_ext32u_i64(TCGv ret, TCGv arg)
1280 tcg_gen_andi_i64(ret, arg, 0xffffffffu);
1283 /* Note: we assume the target supports move between 32 and 64 bit
1284 registers. This will probably break MIPS64 targets. */
1285 static inline void tcg_gen_trunc_i64_i32(TCGv ret, TCGv arg)
1287 tcg_gen_mov_i32(ret, arg);
1290 /* Note: we assume the target supports move between 32 and 64 bit
1291 registers */
1292 static inline void tcg_gen_extu_i32_i64(TCGv ret, TCGv arg)
1294 tcg_gen_andi_i64(ret, arg, 0xffffffffu);
1297 /* Note: we assume the target supports move between 32 and 64 bit
1298 registers */
1299 static inline void tcg_gen_ext_i32_i64(TCGv ret, TCGv arg)
1301 tcg_gen_ext32s_i64(ret, arg);
1304 static inline void tcg_gen_bswap_i64(TCGv ret, TCGv arg)
1306 #ifdef TCG_TARGET_HAS_bswap_i64
1307 tcg_gen_op2(INDEX_op_bswap_i64, ret, arg);
1308 #else
1309 TCGv t0, t1;
1310 t0 = tcg_temp_new(TCG_TYPE_I32);
1311 t1 = tcg_temp_new(TCG_TYPE_I32);
1313 tcg_gen_shli_i64(t0, arg, 56);
1315 tcg_gen_andi_i64(t1, arg, 0x0000ff00);
1316 tcg_gen_shli_i64(t1, t1, 40);
1317 tcg_gen_or_i64(t0, t0, t1);
1319 tcg_gen_andi_i64(t1, arg, 0x00ff0000);
1320 tcg_gen_shli_i64(t1, t1, 24);
1321 tcg_gen_or_i64(t0, t0, t1);
1323 tcg_gen_andi_i64(t1, arg, 0xff000000);
1324 tcg_gen_shli_i64(t1, t1, 8);
1325 tcg_gen_or_i64(t0, t0, t1);
1327 tcg_gen_shri_i64(t1, arg, 8);
1328 tcg_gen_andi_i64(t1, t1, 0xff000000);
1329 tcg_gen_or_i64(t0, t0, t1);
1331 tcg_gen_shri_i64(t1, arg, 24);
1332 tcg_gen_andi_i64(t1, t1, 0x00ff0000);
1333 tcg_gen_or_i64(t0, t0, t1);
1335 tcg_gen_shri_i64(t1, arg, 40);
1336 tcg_gen_andi_i64(t1, t1, 0x0000ff00);
1337 tcg_gen_or_i64(t0, t0, t1);
1339 tcg_gen_shri_i64(t1, arg, 56);
1340 tcg_gen_or_i64(ret, t0, t1);
1341 tcg_temp_free(t0);
1342 tcg_temp_free(t1);
1343 #endif
1346 #endif
1348 static inline void tcg_gen_neg_i32(TCGv ret, TCGv arg)
1350 #ifdef TCG_TARGET_HAS_neg_i32
1351 tcg_gen_op2(INDEX_op_neg_i32, ret, arg);
1352 #else
1353 TCGv t0 = tcg_const_i32(0);
1354 tcg_gen_sub_i32(ret, t0, arg);
1355 tcg_temp_free(t0);
1356 #endif
1359 static inline void tcg_gen_neg_i64(TCGv ret, TCGv arg)
1361 #ifdef TCG_TARGET_HAS_neg_i64
1362 tcg_gen_op2(INDEX_op_neg_i64, ret, arg);
1363 #else
1364 TCGv t0 = tcg_const_i64(0);
1365 tcg_gen_sub_i64(ret, t0, arg);
1366 tcg_temp_free(t0);
1367 #endif
1370 static inline void tcg_gen_not_i32(TCGv ret, TCGv arg)
1372 tcg_gen_xori_i32(ret, arg, -1);
1375 static inline void tcg_gen_not_i64(TCGv ret, TCGv arg)
1377 tcg_gen_xori_i64(ret, arg, -1);
1380 static inline void tcg_gen_discard_i32(TCGv arg)
1382 tcg_gen_op1(INDEX_op_discard, arg);
1385 #if TCG_TARGET_REG_BITS == 32
1386 static inline void tcg_gen_discard_i64(TCGv arg)
1388 tcg_gen_discard_i32(arg);
1389 tcg_gen_discard_i32(TCGV_HIGH(arg));
1391 #else
1392 static inline void tcg_gen_discard_i64(TCGv arg)
1394 tcg_gen_op1(INDEX_op_discard, arg);
1396 #endif
1398 /***************************************/
1399 /* QEMU specific operations. Their type depend on the QEMU CPU
1400 type. */
1401 #ifndef TARGET_LONG_BITS
1402 #error must include QEMU headers
1403 #endif
1405 /* debug info: write the PC of the corresponding QEMU CPU instruction */
1406 static inline void tcg_gen_debug_insn_start(uint64_t pc)
1408 /* XXX: must really use a 32 bit size for TCGArg in all cases */
1409 #if TARGET_LONG_BITS > TCG_TARGET_REG_BITS
1410 tcg_gen_op2ii(INDEX_op_debug_insn_start,
1411 (uint32_t)(pc), (uint32_t)(pc >> 32));
1412 #else
1413 tcg_gen_op1i(INDEX_op_debug_insn_start, pc);
1414 #endif
1417 static inline void tcg_gen_exit_tb(tcg_target_long val)
1419 tcg_gen_op1i(INDEX_op_exit_tb, val);
1422 static inline void tcg_gen_goto_tb(int idx)
1424 tcg_gen_op1i(INDEX_op_goto_tb, idx);
1427 #if TCG_TARGET_REG_BITS == 32
1428 static inline void tcg_gen_qemu_ld8u(TCGv ret, TCGv addr, int mem_index)
1430 #if TARGET_LONG_BITS == 32
1431 tcg_gen_op3i(INDEX_op_qemu_ld8u, ret, addr, mem_index);
1432 #else
1433 tcg_gen_op4i(INDEX_op_qemu_ld8u, ret, addr, TCGV_HIGH(addr), mem_index);
1434 tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
1435 #endif
1438 static inline void tcg_gen_qemu_ld8s(TCGv ret, TCGv addr, int mem_index)
1440 #if TARGET_LONG_BITS == 32
1441 tcg_gen_op3i(INDEX_op_qemu_ld8s, ret, addr, mem_index);
1442 #else
1443 tcg_gen_op4i(INDEX_op_qemu_ld8s, ret, addr, TCGV_HIGH(addr), mem_index);
1444 tcg_gen_sari_i32(TCGV_HIGH(ret), ret, 31);
1445 #endif
1448 static inline void tcg_gen_qemu_ld16u(TCGv ret, TCGv addr, int mem_index)
1450 #if TARGET_LONG_BITS == 32
1451 tcg_gen_op3i(INDEX_op_qemu_ld16u, ret, addr, mem_index);
1452 #else
1453 tcg_gen_op4i(INDEX_op_qemu_ld16u, ret, addr, TCGV_HIGH(addr), mem_index);
1454 tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
1455 #endif
1458 static inline void tcg_gen_qemu_ld16s(TCGv ret, TCGv addr, int mem_index)
1460 #if TARGET_LONG_BITS == 32
1461 tcg_gen_op3i(INDEX_op_qemu_ld16s, ret, addr, mem_index);
1462 #else
1463 tcg_gen_op4i(INDEX_op_qemu_ld16s, ret, addr, TCGV_HIGH(addr), mem_index);
1464 tcg_gen_sari_i32(TCGV_HIGH(ret), ret, 31);
1465 #endif
1468 static inline void tcg_gen_qemu_ld32u(TCGv ret, TCGv addr, int mem_index)
1470 #if TARGET_LONG_BITS == 32
1471 tcg_gen_op3i(INDEX_op_qemu_ld32u, ret, addr, mem_index);
1472 #else
1473 tcg_gen_op4i(INDEX_op_qemu_ld32u, ret, addr, TCGV_HIGH(addr), mem_index);
1474 tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
1475 #endif
1478 static inline void tcg_gen_qemu_ld32s(TCGv ret, TCGv addr, int mem_index)
1480 #if TARGET_LONG_BITS == 32
1481 tcg_gen_op3i(INDEX_op_qemu_ld32u, ret, addr, mem_index);
1482 #else
1483 tcg_gen_op4i(INDEX_op_qemu_ld32u, ret, addr, TCGV_HIGH(addr), mem_index);
1484 tcg_gen_sari_i32(TCGV_HIGH(ret), ret, 31);
1485 #endif
1488 static inline void tcg_gen_qemu_ld64(TCGv ret, TCGv addr, int mem_index)
1490 #if TARGET_LONG_BITS == 32
1491 tcg_gen_op4i(INDEX_op_qemu_ld64, ret, TCGV_HIGH(ret), addr, mem_index);
1492 #else
1493 tcg_gen_op5i(INDEX_op_qemu_ld64, ret, TCGV_HIGH(ret),
1494 addr, TCGV_HIGH(addr), mem_index);
1495 #endif
1498 static inline void tcg_gen_qemu_st8(TCGv arg, TCGv addr, int mem_index)
1500 #if TARGET_LONG_BITS == 32
1501 tcg_gen_op3i(INDEX_op_qemu_st8, arg, addr, mem_index);
1502 #else
1503 tcg_gen_op4i(INDEX_op_qemu_st8, arg, addr, TCGV_HIGH(addr), mem_index);
1504 #endif
1507 static inline void tcg_gen_qemu_st16(TCGv arg, TCGv addr, int mem_index)
1509 #if TARGET_LONG_BITS == 32
1510 tcg_gen_op3i(INDEX_op_qemu_st16, arg, addr, mem_index);
1511 #else
1512 tcg_gen_op4i(INDEX_op_qemu_st16, arg, addr, TCGV_HIGH(addr), mem_index);
1513 #endif
1516 static inline void tcg_gen_qemu_st32(TCGv arg, TCGv addr, int mem_index)
1518 #if TARGET_LONG_BITS == 32
1519 tcg_gen_op3i(INDEX_op_qemu_st32, arg, addr, mem_index);
1520 #else
1521 tcg_gen_op4i(INDEX_op_qemu_st32, arg, addr, TCGV_HIGH(addr), mem_index);
1522 #endif
1525 static inline void tcg_gen_qemu_st64(TCGv arg, TCGv addr, int mem_index)
1527 #if TARGET_LONG_BITS == 32
1528 tcg_gen_op4i(INDEX_op_qemu_st64, arg, TCGV_HIGH(arg), addr, mem_index);
1529 #else
1530 tcg_gen_op5i(INDEX_op_qemu_st64, arg, TCGV_HIGH(arg),
1531 addr, TCGV_HIGH(addr), mem_index);
1532 #endif
1535 #define tcg_gen_ld_ptr tcg_gen_ld_i32
1536 #define tcg_gen_discard_ptr tcg_gen_discard_i32
1538 #else /* TCG_TARGET_REG_BITS == 32 */
1540 static inline void tcg_gen_qemu_ld8u(TCGv ret, TCGv addr, int mem_index)
1542 tcg_gen_op3i(INDEX_op_qemu_ld8u, ret, addr, mem_index);
1545 static inline void tcg_gen_qemu_ld8s(TCGv ret, TCGv addr, int mem_index)
1547 tcg_gen_op3i(INDEX_op_qemu_ld8s, ret, addr, mem_index);
1550 static inline void tcg_gen_qemu_ld16u(TCGv ret, TCGv addr, int mem_index)
1552 tcg_gen_op3i(INDEX_op_qemu_ld16u, ret, addr, mem_index);
1555 static inline void tcg_gen_qemu_ld16s(TCGv ret, TCGv addr, int mem_index)
1557 tcg_gen_op3i(INDEX_op_qemu_ld16s, ret, addr, mem_index);
1560 static inline void tcg_gen_qemu_ld32u(TCGv ret, TCGv addr, int mem_index)
1562 tcg_gen_op3i(INDEX_op_qemu_ld32u, ret, addr, mem_index);
1565 static inline void tcg_gen_qemu_ld32s(TCGv ret, TCGv addr, int mem_index)
1567 tcg_gen_op3i(INDEX_op_qemu_ld32s, ret, addr, mem_index);
1570 static inline void tcg_gen_qemu_ld64(TCGv ret, TCGv addr, int mem_index)
1572 tcg_gen_op3i(INDEX_op_qemu_ld64, ret, addr, mem_index);
1575 static inline void tcg_gen_qemu_st8(TCGv arg, TCGv addr, int mem_index)
1577 tcg_gen_op3i(INDEX_op_qemu_st8, arg, addr, mem_index);
1580 static inline void tcg_gen_qemu_st16(TCGv arg, TCGv addr, int mem_index)
1582 tcg_gen_op3i(INDEX_op_qemu_st16, arg, addr, mem_index);
1585 static inline void tcg_gen_qemu_st32(TCGv arg, TCGv addr, int mem_index)
1587 tcg_gen_op3i(INDEX_op_qemu_st32, arg, addr, mem_index);
1590 static inline void tcg_gen_qemu_st64(TCGv arg, TCGv addr, int mem_index)
1592 tcg_gen_op3i(INDEX_op_qemu_st64, arg, addr, mem_index);
1595 #define tcg_gen_ld_ptr tcg_gen_ld_i64
1596 #define tcg_gen_discard_ptr tcg_gen_discard_i64
1598 #endif /* TCG_TARGET_REG_BITS != 32 */
1600 #if TARGET_LONG_BITS == 64
1601 #define TCG_TYPE_TL TCG_TYPE_I64
1602 #define tcg_gen_movi_tl tcg_gen_movi_i64
1603 #define tcg_gen_mov_tl tcg_gen_mov_i64
1604 #define tcg_gen_ld8u_tl tcg_gen_ld8u_i64
1605 #define tcg_gen_ld8s_tl tcg_gen_ld8s_i64
1606 #define tcg_gen_ld16u_tl tcg_gen_ld16u_i64
1607 #define tcg_gen_ld16s_tl tcg_gen_ld16s_i64
1608 #define tcg_gen_ld32u_tl tcg_gen_ld32u_i64
1609 #define tcg_gen_ld32s_tl tcg_gen_ld32s_i64
1610 #define tcg_gen_ld_tl tcg_gen_ld_i64
1611 #define tcg_gen_st8_tl tcg_gen_st8_i64
1612 #define tcg_gen_st16_tl tcg_gen_st16_i64
1613 #define tcg_gen_st32_tl tcg_gen_st32_i64
1614 #define tcg_gen_st_tl tcg_gen_st_i64
1615 #define tcg_gen_add_tl tcg_gen_add_i64
1616 #define tcg_gen_addi_tl tcg_gen_addi_i64
1617 #define tcg_gen_sub_tl tcg_gen_sub_i64
1618 #define tcg_gen_neg_tl tcg_gen_neg_i64
1619 #define tcg_gen_subi_tl tcg_gen_subi_i64
1620 #define tcg_gen_and_tl tcg_gen_and_i64
1621 #define tcg_gen_andi_tl tcg_gen_andi_i64
1622 #define tcg_gen_or_tl tcg_gen_or_i64
1623 #define tcg_gen_ori_tl tcg_gen_ori_i64
1624 #define tcg_gen_xor_tl tcg_gen_xor_i64
1625 #define tcg_gen_xori_tl tcg_gen_xori_i64
1626 #define tcg_gen_not_tl tcg_gen_not_i64
1627 #define tcg_gen_shl_tl tcg_gen_shl_i64
1628 #define tcg_gen_shli_tl tcg_gen_shli_i64
1629 #define tcg_gen_shr_tl tcg_gen_shr_i64
1630 #define tcg_gen_shri_tl tcg_gen_shri_i64
1631 #define tcg_gen_sar_tl tcg_gen_sar_i64
1632 #define tcg_gen_sari_tl tcg_gen_sari_i64
1633 #define tcg_gen_brcond_tl tcg_gen_brcond_i64
1634 #define tcg_gen_brcondi_tl tcg_gen_brcondi_i64
1635 #define tcg_gen_mul_tl tcg_gen_mul_i64
1636 #define tcg_gen_muli_tl tcg_gen_muli_i64
1637 #define tcg_gen_discard_tl tcg_gen_discard_i64
1638 #define tcg_gen_trunc_tl_i32 tcg_gen_trunc_i64_i32
1639 #define tcg_gen_trunc_i64_tl tcg_gen_mov_i64
1640 #define tcg_gen_extu_i32_tl tcg_gen_extu_i32_i64
1641 #define tcg_gen_ext_i32_tl tcg_gen_ext_i32_i64
1642 #define tcg_gen_extu_tl_i64 tcg_gen_mov_i64
1643 #define tcg_gen_ext_tl_i64 tcg_gen_mov_i64
1644 #define tcg_gen_ext8u_tl tcg_gen_ext8u_i64
1645 #define tcg_gen_ext8s_tl tcg_gen_ext8s_i64
1646 #define tcg_gen_ext16u_tl tcg_gen_ext16u_i64
1647 #define tcg_gen_ext16s_tl tcg_gen_ext16s_i64
1648 #define tcg_gen_ext32u_tl tcg_gen_ext32u_i64
1649 #define tcg_gen_ext32s_tl tcg_gen_ext32s_i64
1650 #define tcg_const_tl tcg_const_i64
1651 #else
1652 #define TCG_TYPE_TL TCG_TYPE_I32
1653 #define tcg_gen_movi_tl tcg_gen_movi_i32
1654 #define tcg_gen_mov_tl tcg_gen_mov_i32
1655 #define tcg_gen_ld8u_tl tcg_gen_ld8u_i32
1656 #define tcg_gen_ld8s_tl tcg_gen_ld8s_i32
1657 #define tcg_gen_ld16u_tl tcg_gen_ld16u_i32
1658 #define tcg_gen_ld16s_tl tcg_gen_ld16s_i32
1659 #define tcg_gen_ld32u_tl tcg_gen_ld_i32
1660 #define tcg_gen_ld32s_tl tcg_gen_ld_i32
1661 #define tcg_gen_ld_tl tcg_gen_ld_i32
1662 #define tcg_gen_st8_tl tcg_gen_st8_i32
1663 #define tcg_gen_st16_tl tcg_gen_st16_i32
1664 #define tcg_gen_st32_tl tcg_gen_st_i32
1665 #define tcg_gen_st_tl tcg_gen_st_i32
1666 #define tcg_gen_add_tl tcg_gen_add_i32
1667 #define tcg_gen_addi_tl tcg_gen_addi_i32
1668 #define tcg_gen_sub_tl tcg_gen_sub_i32
1669 #define tcg_gen_neg_tl tcg_gen_neg_i32
1670 #define tcg_gen_subi_tl tcg_gen_subi_i32
1671 #define tcg_gen_and_tl tcg_gen_and_i32
1672 #define tcg_gen_andi_tl tcg_gen_andi_i32
1673 #define tcg_gen_or_tl tcg_gen_or_i32
1674 #define tcg_gen_ori_tl tcg_gen_ori_i32
1675 #define tcg_gen_xor_tl tcg_gen_xor_i32
1676 #define tcg_gen_xori_tl tcg_gen_xori_i32
1677 #define tcg_gen_not_tl tcg_gen_not_i32
1678 #define tcg_gen_shl_tl tcg_gen_shl_i32
1679 #define tcg_gen_shli_tl tcg_gen_shli_i32
1680 #define tcg_gen_shr_tl tcg_gen_shr_i32
1681 #define tcg_gen_shri_tl tcg_gen_shri_i32
1682 #define tcg_gen_sar_tl tcg_gen_sar_i32
1683 #define tcg_gen_sari_tl tcg_gen_sari_i32
1684 #define tcg_gen_brcond_tl tcg_gen_brcond_i32
1685 #define tcg_gen_brcondi_tl tcg_gen_brcondi_i32
1686 #define tcg_gen_mul_tl tcg_gen_mul_i32
1687 #define tcg_gen_muli_tl tcg_gen_muli_i32
1688 #define tcg_gen_discard_tl tcg_gen_discard_i32
1689 #define tcg_gen_trunc_tl_i32 tcg_gen_mov_i32
1690 #define tcg_gen_trunc_i64_tl tcg_gen_trunc_i64_i32
1691 #define tcg_gen_extu_i32_tl tcg_gen_mov_i32
1692 #define tcg_gen_ext_i32_tl tcg_gen_mov_i32
1693 #define tcg_gen_extu_tl_i64 tcg_gen_extu_i32_i64
1694 #define tcg_gen_ext_tl_i64 tcg_gen_ext_i32_i64
1695 #define tcg_gen_ext8u_tl tcg_gen_ext8u_i32
1696 #define tcg_gen_ext8s_tl tcg_gen_ext8s_i32
1697 #define tcg_gen_ext16u_tl tcg_gen_ext16u_i32
1698 #define tcg_gen_ext16s_tl tcg_gen_ext16s_i32
1699 #define tcg_gen_ext32u_tl tcg_gen_mov_i32
1700 #define tcg_gen_ext32s_tl tcg_gen_mov_i32
1701 #define tcg_const_tl tcg_const_i32
1702 #endif
1704 #if TCG_TARGET_REG_BITS == 32
1705 #define tcg_gen_add_ptr tcg_gen_add_i32
1706 #define tcg_gen_addi_ptr tcg_gen_addi_i32
1707 #define tcg_gen_ext_i32_ptr tcg_gen_mov_i32
1708 #else /* TCG_TARGET_REG_BITS == 32 */
1709 #define tcg_gen_add_ptr tcg_gen_add_i64
1710 #define tcg_gen_addi_ptr tcg_gen_addi_i64
1711 #define tcg_gen_ext_i32_ptr tcg_gen_ext_i32_i64
1712 #endif /* TCG_TARGET_REG_BITS != 32 */