2 * Optimizations for Tiny Code Generator for QEMU
4 * Copyright (c) 2010 Samsung Electronics.
5 * Contributed by Kirill Batuzov <batuzovk@ispras.ru>
7 * Permission is hereby granted, free of charge, to any person obtaining a copy
8 * of this software and associated documentation files (the "Software"), to deal
9 * in the Software without restriction, including without limitation the rights
10 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11 * copies of the Software, and to permit persons to whom the Software is
12 * furnished to do so, subject to the following conditions:
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
26 #include "qemu/osdep.h"
27 #include "tcg/tcg-op.h"
28 #include "tcg-internal.h"
30 #define CASE_OP_32_64(x) \
31 glue(glue(case INDEX_op_, x), _i32): \
32 glue(glue(case INDEX_op_, x), _i64)
34 #define CASE_OP_32_64_VEC(x) \
35 glue(glue(case INDEX_op_, x), _i32): \
36 glue(glue(case INDEX_op_, x), _i64): \
37 glue(glue(case INDEX_op_, x), _vec)
39 typedef struct TempOptInfo
{
44 uint64_t z_mask
; /* mask bit is 0 if and only if value bit is 0 */
47 typedef struct OptContext
{
50 TCGTempSet temps_used
;
52 /* In flight values from optimization. */
56 static inline TempOptInfo
*ts_info(TCGTemp
*ts
)
61 static inline TempOptInfo
*arg_info(TCGArg arg
)
63 return ts_info(arg_temp(arg
));
66 static inline bool ts_is_const(TCGTemp
*ts
)
68 return ts_info(ts
)->is_const
;
71 static inline bool arg_is_const(TCGArg arg
)
73 return ts_is_const(arg_temp(arg
));
76 static inline bool ts_is_copy(TCGTemp
*ts
)
78 return ts_info(ts
)->next_copy
!= ts
;
81 /* Reset TEMP's state, possibly removing the temp for the list of copies. */
82 static void reset_ts(TCGTemp
*ts
)
84 TempOptInfo
*ti
= ts_info(ts
);
85 TempOptInfo
*pi
= ts_info(ti
->prev_copy
);
86 TempOptInfo
*ni
= ts_info(ti
->next_copy
);
88 ni
->prev_copy
= ti
->prev_copy
;
89 pi
->next_copy
= ti
->next_copy
;
96 static void reset_temp(TCGArg arg
)
98 reset_ts(arg_temp(arg
));
101 /* Initialize and activate a temporary. */
102 static void init_ts_info(OptContext
*ctx
, TCGTemp
*ts
)
104 size_t idx
= temp_idx(ts
);
107 if (test_bit(idx
, ctx
->temps_used
.l
)) {
110 set_bit(idx
, ctx
->temps_used
.l
);
114 ti
= tcg_malloc(sizeof(TempOptInfo
));
120 if (ts
->kind
== TEMP_CONST
) {
123 ti
->z_mask
= ts
->val
;
124 if (TCG_TARGET_REG_BITS
> 32 && ts
->type
== TCG_TYPE_I32
) {
125 /* High bits of a 32-bit quantity are garbage. */
126 ti
->z_mask
|= ~0xffffffffull
;
129 ti
->is_const
= false;
134 static TCGTemp
*find_better_copy(TCGContext
*s
, TCGTemp
*ts
)
138 /* If this is already readonly, we can't do better. */
139 if (temp_readonly(ts
)) {
144 for (i
= ts_info(ts
)->next_copy
; i
!= ts
; i
= ts_info(i
)->next_copy
) {
145 if (temp_readonly(i
)) {
147 } else if (i
->kind
> ts
->kind
) {
148 if (i
->kind
== TEMP_GLOBAL
) {
150 } else if (i
->kind
== TEMP_LOCAL
) {
156 /* If we didn't find a better representation, return the same temp. */
157 return g
? g
: l
? l
: ts
;
160 static bool ts_are_copies(TCGTemp
*ts1
, TCGTemp
*ts2
)
168 if (!ts_is_copy(ts1
) || !ts_is_copy(ts2
)) {
172 for (i
= ts_info(ts1
)->next_copy
; i
!= ts1
; i
= ts_info(i
)->next_copy
) {
181 static bool args_are_copies(TCGArg arg1
, TCGArg arg2
)
183 return ts_are_copies(arg_temp(arg1
), arg_temp(arg2
));
186 static bool tcg_opt_gen_mov(OptContext
*ctx
, TCGOp
*op
, TCGArg dst
, TCGArg src
)
188 TCGTemp
*dst_ts
= arg_temp(dst
);
189 TCGTemp
*src_ts
= arg_temp(src
);
196 if (ts_are_copies(dst_ts
, src_ts
)) {
197 tcg_op_remove(ctx
->tcg
, op
);
202 di
= ts_info(dst_ts
);
203 si
= ts_info(src_ts
);
204 def
= &tcg_op_defs
[op
->opc
];
205 if (def
->flags
& TCG_OPF_VECTOR
) {
206 new_op
= INDEX_op_mov_vec
;
207 } else if (def
->flags
& TCG_OPF_64BIT
) {
208 new_op
= INDEX_op_mov_i64
;
210 new_op
= INDEX_op_mov_i32
;
213 /* TCGOP_VECL and TCGOP_VECE remain unchanged. */
218 if (TCG_TARGET_REG_BITS
> 32 && new_op
== INDEX_op_mov_i32
) {
219 /* High bits of the destination are now garbage. */
220 z_mask
|= ~0xffffffffull
;
224 if (src_ts
->type
== dst_ts
->type
) {
225 TempOptInfo
*ni
= ts_info(si
->next_copy
);
227 di
->next_copy
= si
->next_copy
;
228 di
->prev_copy
= src_ts
;
229 ni
->prev_copy
= dst_ts
;
230 si
->next_copy
= dst_ts
;
231 di
->is_const
= si
->is_const
;
237 static bool tcg_opt_gen_movi(OptContext
*ctx
, TCGOp
*op
,
238 TCGArg dst
, uint64_t val
)
240 const TCGOpDef
*def
= &tcg_op_defs
[op
->opc
];
244 if (def
->flags
& TCG_OPF_VECTOR
) {
245 type
= TCGOP_VECL(op
) + TCG_TYPE_V64
;
246 } else if (def
->flags
& TCG_OPF_64BIT
) {
252 /* Convert movi to mov with constant temp. */
253 tv
= tcg_constant_internal(type
, val
);
254 init_ts_info(ctx
, tv
);
255 return tcg_opt_gen_mov(ctx
, op
, dst
, temp_arg(tv
));
258 static uint64_t do_constant_folding_2(TCGOpcode op
, uint64_t x
, uint64_t y
)
281 case INDEX_op_shl_i32
:
282 return (uint32_t)x
<< (y
& 31);
284 case INDEX_op_shl_i64
:
285 return (uint64_t)x
<< (y
& 63);
287 case INDEX_op_shr_i32
:
288 return (uint32_t)x
>> (y
& 31);
290 case INDEX_op_shr_i64
:
291 return (uint64_t)x
>> (y
& 63);
293 case INDEX_op_sar_i32
:
294 return (int32_t)x
>> (y
& 31);
296 case INDEX_op_sar_i64
:
297 return (int64_t)x
>> (y
& 63);
299 case INDEX_op_rotr_i32
:
300 return ror32(x
, y
& 31);
302 case INDEX_op_rotr_i64
:
303 return ror64(x
, y
& 63);
305 case INDEX_op_rotl_i32
:
306 return rol32(x
, y
& 31);
308 case INDEX_op_rotl_i64
:
309 return rol64(x
, y
& 63);
332 case INDEX_op_clz_i32
:
333 return (uint32_t)x
? clz32(x
) : y
;
335 case INDEX_op_clz_i64
:
336 return x
? clz64(x
) : y
;
338 case INDEX_op_ctz_i32
:
339 return (uint32_t)x
? ctz32(x
) : y
;
341 case INDEX_op_ctz_i64
:
342 return x
? ctz64(x
) : y
;
344 case INDEX_op_ctpop_i32
:
347 case INDEX_op_ctpop_i64
:
350 CASE_OP_32_64(ext8s
):
353 CASE_OP_32_64(ext16s
):
356 CASE_OP_32_64(ext8u
):
359 CASE_OP_32_64(ext16u
):
362 CASE_OP_32_64(bswap16
):
364 return y
& TCG_BSWAP_OS
? (int16_t)x
: x
;
366 CASE_OP_32_64(bswap32
):
368 return y
& TCG_BSWAP_OS
? (int32_t)x
: x
;
370 case INDEX_op_bswap64_i64
:
373 case INDEX_op_ext_i32_i64
:
374 case INDEX_op_ext32s_i64
:
377 case INDEX_op_extu_i32_i64
:
378 case INDEX_op_extrl_i64_i32
:
379 case INDEX_op_ext32u_i64
:
382 case INDEX_op_extrh_i64_i32
:
383 return (uint64_t)x
>> 32;
385 case INDEX_op_muluh_i32
:
386 return ((uint64_t)(uint32_t)x
* (uint32_t)y
) >> 32;
387 case INDEX_op_mulsh_i32
:
388 return ((int64_t)(int32_t)x
* (int32_t)y
) >> 32;
390 case INDEX_op_muluh_i64
:
391 mulu64(&l64
, &h64
, x
, y
);
393 case INDEX_op_mulsh_i64
:
394 muls64(&l64
, &h64
, x
, y
);
397 case INDEX_op_div_i32
:
398 /* Avoid crashing on divide by zero, otherwise undefined. */
399 return (int32_t)x
/ ((int32_t)y
? : 1);
400 case INDEX_op_divu_i32
:
401 return (uint32_t)x
/ ((uint32_t)y
? : 1);
402 case INDEX_op_div_i64
:
403 return (int64_t)x
/ ((int64_t)y
? : 1);
404 case INDEX_op_divu_i64
:
405 return (uint64_t)x
/ ((uint64_t)y
? : 1);
407 case INDEX_op_rem_i32
:
408 return (int32_t)x
% ((int32_t)y
? : 1);
409 case INDEX_op_remu_i32
:
410 return (uint32_t)x
% ((uint32_t)y
? : 1);
411 case INDEX_op_rem_i64
:
412 return (int64_t)x
% ((int64_t)y
? : 1);
413 case INDEX_op_remu_i64
:
414 return (uint64_t)x
% ((uint64_t)y
? : 1);
418 "Unrecognized operation %d in do_constant_folding.\n", op
);
423 static uint64_t do_constant_folding(TCGOpcode op
, uint64_t x
, uint64_t y
)
425 const TCGOpDef
*def
= &tcg_op_defs
[op
];
426 uint64_t res
= do_constant_folding_2(op
, x
, y
);
427 if (!(def
->flags
& TCG_OPF_64BIT
)) {
433 static bool do_constant_folding_cond_32(uint32_t x
, uint32_t y
, TCGCond c
)
441 return (int32_t)x
< (int32_t)y
;
443 return (int32_t)x
>= (int32_t)y
;
445 return (int32_t)x
<= (int32_t)y
;
447 return (int32_t)x
> (int32_t)y
;
461 static bool do_constant_folding_cond_64(uint64_t x
, uint64_t y
, TCGCond c
)
469 return (int64_t)x
< (int64_t)y
;
471 return (int64_t)x
>= (int64_t)y
;
473 return (int64_t)x
<= (int64_t)y
;
475 return (int64_t)x
> (int64_t)y
;
489 static bool do_constant_folding_cond_eq(TCGCond c
)
510 * Return -1 if the condition can't be simplified,
511 * and the result of the condition (0 or 1) if it can.
513 static int do_constant_folding_cond(TCGOpcode op
, TCGArg x
,
516 uint64_t xv
= arg_info(x
)->val
;
517 uint64_t yv
= arg_info(y
)->val
;
519 if (arg_is_const(x
) && arg_is_const(y
)) {
520 const TCGOpDef
*def
= &tcg_op_defs
[op
];
521 tcg_debug_assert(!(def
->flags
& TCG_OPF_VECTOR
));
522 if (def
->flags
& TCG_OPF_64BIT
) {
523 return do_constant_folding_cond_64(xv
, yv
, c
);
525 return do_constant_folding_cond_32(xv
, yv
, c
);
527 } else if (args_are_copies(x
, y
)) {
528 return do_constant_folding_cond_eq(c
);
529 } else if (arg_is_const(y
) && yv
== 0) {
543 * Return -1 if the condition can't be simplified,
544 * and the result of the condition (0 or 1) if it can.
546 static int do_constant_folding_cond2(TCGArg
*p1
, TCGArg
*p2
, TCGCond c
)
548 TCGArg al
= p1
[0], ah
= p1
[1];
549 TCGArg bl
= p2
[0], bh
= p2
[1];
551 if (arg_is_const(bl
) && arg_is_const(bh
)) {
552 tcg_target_ulong blv
= arg_info(bl
)->val
;
553 tcg_target_ulong bhv
= arg_info(bh
)->val
;
554 uint64_t b
= deposit64(blv
, 32, 32, bhv
);
556 if (arg_is_const(al
) && arg_is_const(ah
)) {
557 tcg_target_ulong alv
= arg_info(al
)->val
;
558 tcg_target_ulong ahv
= arg_info(ah
)->val
;
559 uint64_t a
= deposit64(alv
, 32, 32, ahv
);
560 return do_constant_folding_cond_64(a
, b
, c
);
573 if (args_are_copies(al
, bl
) && args_are_copies(ah
, bh
)) {
574 return do_constant_folding_cond_eq(c
);
579 static bool swap_commutative(TCGArg dest
, TCGArg
*p1
, TCGArg
*p2
)
581 TCGArg a1
= *p1
, a2
= *p2
;
583 sum
+= arg_is_const(a1
);
584 sum
-= arg_is_const(a2
);
586 /* Prefer the constant in second argument, and then the form
587 op a, a, b, which is better handled on non-RISC hosts. */
588 if (sum
> 0 || (sum
== 0 && dest
== a2
)) {
596 static bool swap_commutative2(TCGArg
*p1
, TCGArg
*p2
)
599 sum
+= arg_is_const(p1
[0]);
600 sum
+= arg_is_const(p1
[1]);
601 sum
-= arg_is_const(p2
[0]);
602 sum
-= arg_is_const(p2
[1]);
605 t
= p1
[0], p1
[0] = p2
[0], p2
[0] = t
;
606 t
= p1
[1], p1
[1] = p2
[1], p2
[1] = t
;
612 static void init_arguments(OptContext
*ctx
, TCGOp
*op
, int nb_args
)
614 for (int i
= 0; i
< nb_args
; i
++) {
615 TCGTemp
*ts
= arg_temp(op
->args
[i
]);
617 init_ts_info(ctx
, ts
);
622 static void copy_propagate(OptContext
*ctx
, TCGOp
*op
,
623 int nb_oargs
, int nb_iargs
)
625 TCGContext
*s
= ctx
->tcg
;
627 for (int i
= nb_oargs
; i
< nb_oargs
+ nb_iargs
; i
++) {
628 TCGTemp
*ts
= arg_temp(op
->args
[i
]);
629 if (ts
&& ts_is_copy(ts
)) {
630 op
->args
[i
] = temp_arg(find_better_copy(s
, ts
));
635 static void finish_folding(OptContext
*ctx
, TCGOp
*op
)
637 const TCGOpDef
*def
= &tcg_op_defs
[op
->opc
];
641 * For an opcode that ends a BB, reset all temp data.
642 * We do no cross-BB optimization.
644 if (def
->flags
& TCG_OPF_BB_END
) {
645 memset(&ctx
->temps_used
, 0, sizeof(ctx
->temps_used
));
650 nb_oargs
= def
->nb_oargs
;
651 for (i
= 0; i
< nb_oargs
; i
++) {
652 reset_temp(op
->args
[i
]);
654 * Save the corresponding known-zero bits mask for the
655 * first output argument (only one supported so far).
658 arg_info(op
->args
[i
])->z_mask
= ctx
->z_mask
;
664 * The fold_* functions return true when processing is complete,
665 * usually by folding the operation to a constant or to a copy,
666 * and calling tcg_opt_gen_{mov,movi}. They may do other things,
667 * like collect information about the value produced, for use in
668 * optimizing a subsequent operation.
670 * These first fold_* functions are all helpers, used by other
671 * folders for more specific operations.
674 static bool fold_const1(OptContext
*ctx
, TCGOp
*op
)
676 if (arg_is_const(op
->args
[1])) {
679 t
= arg_info(op
->args
[1])->val
;
680 t
= do_constant_folding(op
->opc
, t
, 0);
681 return tcg_opt_gen_movi(ctx
, op
, op
->args
[0], t
);
686 static bool fold_const2(OptContext
*ctx
, TCGOp
*op
)
688 if (arg_is_const(op
->args
[1]) && arg_is_const(op
->args
[2])) {
689 uint64_t t1
= arg_info(op
->args
[1])->val
;
690 uint64_t t2
= arg_info(op
->args
[2])->val
;
692 t1
= do_constant_folding(op
->opc
, t1
, t2
);
693 return tcg_opt_gen_movi(ctx
, op
, op
->args
[0], t1
);
699 * These outermost fold_<op> functions are sorted alphabetically.
702 static bool fold_add(OptContext
*ctx
, TCGOp
*op
)
704 return fold_const2(ctx
, op
);
707 static bool fold_addsub2_i32(OptContext
*ctx
, TCGOp
*op
, bool add
)
709 if (arg_is_const(op
->args
[2]) && arg_is_const(op
->args
[3]) &&
710 arg_is_const(op
->args
[4]) && arg_is_const(op
->args
[5])) {
711 uint32_t al
= arg_info(op
->args
[2])->val
;
712 uint32_t ah
= arg_info(op
->args
[3])->val
;
713 uint32_t bl
= arg_info(op
->args
[4])->val
;
714 uint32_t bh
= arg_info(op
->args
[5])->val
;
715 uint64_t a
= ((uint64_t)ah
<< 32) | al
;
716 uint64_t b
= ((uint64_t)bh
<< 32) | bl
;
718 TCGOp
*op2
= tcg_op_insert_before(ctx
->tcg
, op
, INDEX_op_mov_i32
);
728 tcg_opt_gen_movi(ctx
, op
, rl
, (int32_t)a
);
729 tcg_opt_gen_movi(ctx
, op2
, rh
, (int32_t)(a
>> 32));
735 static bool fold_add2_i32(OptContext
*ctx
, TCGOp
*op
)
737 return fold_addsub2_i32(ctx
, op
, true);
740 static bool fold_and(OptContext
*ctx
, TCGOp
*op
)
742 return fold_const2(ctx
, op
);
745 static bool fold_andc(OptContext
*ctx
, TCGOp
*op
)
747 return fold_const2(ctx
, op
);
750 static bool fold_brcond(OptContext
*ctx
, TCGOp
*op
)
752 TCGCond cond
= op
->args
[2];
753 int i
= do_constant_folding_cond(op
->opc
, op
->args
[0], op
->args
[1], cond
);
756 tcg_op_remove(ctx
->tcg
, op
);
760 op
->opc
= INDEX_op_br
;
761 op
->args
[0] = op
->args
[3];
766 static bool fold_brcond2(OptContext
*ctx
, TCGOp
*op
)
768 TCGCond cond
= op
->args
[4];
769 int i
= do_constant_folding_cond2(&op
->args
[0], &op
->args
[2], cond
);
770 TCGArg label
= op
->args
[5];
774 goto do_brcond_const
;
781 * Simplify LT/GE comparisons vs zero to a single compare
782 * vs the high word of the input.
784 if (arg_is_const(op
->args
[2]) && arg_info(op
->args
[2])->val
== 0 &&
785 arg_is_const(op
->args
[3]) && arg_info(op
->args
[3])->val
== 0) {
795 * Simplify EQ/NE comparisons where one of the pairs
798 i
= do_constant_folding_cond(INDEX_op_brcond_i32
, op
->args
[0],
802 goto do_brcond_const
;
807 i
= do_constant_folding_cond(INDEX_op_brcond_i32
, op
->args
[1],
811 goto do_brcond_const
;
813 op
->opc
= INDEX_op_brcond_i32
;
814 op
->args
[1] = op
->args
[2];
825 op
->opc
= INDEX_op_brcond_i32
;
826 op
->args
[0] = op
->args
[1];
827 op
->args
[1] = op
->args
[3];
834 tcg_op_remove(ctx
->tcg
, op
);
837 op
->opc
= INDEX_op_br
;
844 static bool fold_call(OptContext
*ctx
, TCGOp
*op
)
846 TCGContext
*s
= ctx
->tcg
;
847 int nb_oargs
= TCGOP_CALLO(op
);
848 int nb_iargs
= TCGOP_CALLI(op
);
851 init_arguments(ctx
, op
, nb_oargs
+ nb_iargs
);
852 copy_propagate(ctx
, op
, nb_oargs
, nb_iargs
);
854 /* If the function reads or writes globals, reset temp data. */
855 flags
= tcg_call_flags(op
);
856 if (!(flags
& (TCG_CALL_NO_READ_GLOBALS
| TCG_CALL_NO_WRITE_GLOBALS
))) {
857 int nb_globals
= s
->nb_globals
;
859 for (i
= 0; i
< nb_globals
; i
++) {
860 if (test_bit(i
, ctx
->temps_used
.l
)) {
861 reset_ts(&ctx
->tcg
->temps
[i
]);
866 /* Reset temp data for outputs. */
867 for (i
= 0; i
< nb_oargs
; i
++) {
868 reset_temp(op
->args
[i
]);
871 /* Stop optimizing MB across calls. */
876 static bool fold_ctpop(OptContext
*ctx
, TCGOp
*op
)
878 return fold_const1(ctx
, op
);
881 static bool fold_divide(OptContext
*ctx
, TCGOp
*op
)
883 return fold_const2(ctx
, op
);
886 static bool fold_eqv(OptContext
*ctx
, TCGOp
*op
)
888 return fold_const2(ctx
, op
);
891 static bool fold_exts(OptContext
*ctx
, TCGOp
*op
)
893 return fold_const1(ctx
, op
);
896 static bool fold_extu(OptContext
*ctx
, TCGOp
*op
)
898 return fold_const1(ctx
, op
);
901 static bool fold_mb(OptContext
*ctx
, TCGOp
*op
)
903 /* Eliminate duplicate and redundant fence instructions. */
906 * Merge two barriers of the same type into one,
907 * or a weaker barrier into a stronger one,
908 * or two weaker barriers into a stronger one.
909 * mb X; mb Y => mb X|Y
912 * ldaq; strl => ld; mb; st
913 * Other combinations are also merged into a strong
914 * barrier. This is stricter than specified but for
915 * the purposes of TCG is better than not optimizing.
917 ctx
->prev_mb
->args
[0] |= op
->args
[0];
918 tcg_op_remove(ctx
->tcg
, op
);
925 static bool fold_mul(OptContext
*ctx
, TCGOp
*op
)
927 return fold_const2(ctx
, op
);
930 static bool fold_mul_highpart(OptContext
*ctx
, TCGOp
*op
)
932 return fold_const2(ctx
, op
);
935 static bool fold_mulu2_i32(OptContext
*ctx
, TCGOp
*op
)
937 if (arg_is_const(op
->args
[2]) && arg_is_const(op
->args
[3])) {
938 uint32_t a
= arg_info(op
->args
[2])->val
;
939 uint32_t b
= arg_info(op
->args
[3])->val
;
940 uint64_t r
= (uint64_t)a
* b
;
942 TCGOp
*op2
= tcg_op_insert_before(ctx
->tcg
, op
, INDEX_op_mov_i32
);
946 tcg_opt_gen_movi(ctx
, op
, rl
, (int32_t)r
);
947 tcg_opt_gen_movi(ctx
, op2
, rh
, (int32_t)(r
>> 32));
953 static bool fold_nand(OptContext
*ctx
, TCGOp
*op
)
955 return fold_const2(ctx
, op
);
958 static bool fold_neg(OptContext
*ctx
, TCGOp
*op
)
960 return fold_const1(ctx
, op
);
963 static bool fold_nor(OptContext
*ctx
, TCGOp
*op
)
965 return fold_const2(ctx
, op
);
968 static bool fold_not(OptContext
*ctx
, TCGOp
*op
)
970 return fold_const1(ctx
, op
);
973 static bool fold_or(OptContext
*ctx
, TCGOp
*op
)
975 return fold_const2(ctx
, op
);
978 static bool fold_orc(OptContext
*ctx
, TCGOp
*op
)
980 return fold_const2(ctx
, op
);
983 static bool fold_qemu_ld(OptContext
*ctx
, TCGOp
*op
)
985 /* Opcodes that touch guest memory stop the mb optimization. */
990 static bool fold_qemu_st(OptContext
*ctx
, TCGOp
*op
)
992 /* Opcodes that touch guest memory stop the mb optimization. */
997 static bool fold_remainder(OptContext
*ctx
, TCGOp
*op
)
999 return fold_const2(ctx
, op
);
1002 static bool fold_setcond(OptContext
*ctx
, TCGOp
*op
)
1004 TCGCond cond
= op
->args
[3];
1005 int i
= do_constant_folding_cond(op
->opc
, op
->args
[1], op
->args
[2], cond
);
1008 return tcg_opt_gen_movi(ctx
, op
, op
->args
[0], i
);
1013 static bool fold_setcond2(OptContext
*ctx
, TCGOp
*op
)
1015 TCGCond cond
= op
->args
[5];
1016 int i
= do_constant_folding_cond2(&op
->args
[1], &op
->args
[3], cond
);
1020 goto do_setcond_const
;
1027 * Simplify LT/GE comparisons vs zero to a single compare
1028 * vs the high word of the input.
1030 if (arg_is_const(op
->args
[3]) && arg_info(op
->args
[3])->val
== 0 &&
1031 arg_is_const(op
->args
[4]) && arg_info(op
->args
[4])->val
== 0) {
1032 goto do_setcond_high
;
1041 * Simplify EQ/NE comparisons where one of the pairs
1042 * can be simplified.
1044 i
= do_constant_folding_cond(INDEX_op_setcond_i32
, op
->args
[1],
1048 goto do_setcond_const
;
1050 goto do_setcond_high
;
1053 i
= do_constant_folding_cond(INDEX_op_setcond_i32
, op
->args
[2],
1057 goto do_setcond_const
;
1059 op
->args
[2] = op
->args
[3];
1061 op
->opc
= INDEX_op_setcond_i32
;
1070 op
->args
[1] = op
->args
[2];
1071 op
->args
[2] = op
->args
[4];
1073 op
->opc
= INDEX_op_setcond_i32
;
1079 return tcg_opt_gen_movi(ctx
, op
, op
->args
[0], i
);
1082 static bool fold_shift(OptContext
*ctx
, TCGOp
*op
)
1084 return fold_const2(ctx
, op
);
1087 static bool fold_sub(OptContext
*ctx
, TCGOp
*op
)
1089 return fold_const2(ctx
, op
);
1092 static bool fold_sub2_i32(OptContext
*ctx
, TCGOp
*op
)
1094 return fold_addsub2_i32(ctx
, op
, false);
1097 static bool fold_xor(OptContext
*ctx
, TCGOp
*op
)
1099 return fold_const2(ctx
, op
);
1102 /* Propagate constants and copies, fold constant expressions. */
1103 void tcg_optimize(TCGContext
*s
)
1106 TCGOp
*op
, *op_next
;
1107 OptContext ctx
= { .tcg
= s
};
1109 /* Array VALS has an element for each temp.
1110 If this temp holds a constant then its value is kept in VALS' element.
1111 If this temp is a copy of other ones then the other copies are
1112 available through the doubly linked circular list. */
1114 nb_temps
= s
->nb_temps
;
1115 for (i
= 0; i
< nb_temps
; ++i
) {
1116 s
->temps
[i
].state_ptr
= NULL
;
1119 QTAILQ_FOREACH_SAFE(op
, &s
->ops
, link
, op_next
) {
1120 uint64_t z_mask
, partmask
, affected
, tmp
;
1121 TCGOpcode opc
= op
->opc
;
1122 const TCGOpDef
*def
;
1125 /* Calls are special. */
1126 if (opc
== INDEX_op_call
) {
1127 fold_call(&ctx
, op
);
1131 def
= &tcg_op_defs
[opc
];
1132 init_arguments(&ctx
, op
, def
->nb_oargs
+ def
->nb_iargs
);
1133 copy_propagate(&ctx
, op
, def
->nb_oargs
, def
->nb_iargs
);
1135 /* For commutative operations make constant second argument */
1137 CASE_OP_32_64_VEC(add
):
1138 CASE_OP_32_64_VEC(mul
):
1139 CASE_OP_32_64_VEC(and):
1140 CASE_OP_32_64_VEC(or):
1141 CASE_OP_32_64_VEC(xor):
1143 CASE_OP_32_64(nand
):
1145 CASE_OP_32_64(muluh
):
1146 CASE_OP_32_64(mulsh
):
1147 swap_commutative(op
->args
[0], &op
->args
[1], &op
->args
[2]);
1149 CASE_OP_32_64(brcond
):
1150 if (swap_commutative(-1, &op
->args
[0], &op
->args
[1])) {
1151 op
->args
[2] = tcg_swap_cond(op
->args
[2]);
1154 CASE_OP_32_64(setcond
):
1155 if (swap_commutative(op
->args
[0], &op
->args
[1], &op
->args
[2])) {
1156 op
->args
[3] = tcg_swap_cond(op
->args
[3]);
1159 CASE_OP_32_64(movcond
):
1160 if (swap_commutative(-1, &op
->args
[1], &op
->args
[2])) {
1161 op
->args
[5] = tcg_swap_cond(op
->args
[5]);
1163 /* For movcond, we canonicalize the "false" input reg to match
1164 the destination reg so that the tcg backend can implement
1165 a "move if true" operation. */
1166 if (swap_commutative(op
->args
[0], &op
->args
[4], &op
->args
[3])) {
1167 op
->args
[5] = tcg_invert_cond(op
->args
[5]);
1170 CASE_OP_32_64(add2
):
1171 swap_commutative(op
->args
[0], &op
->args
[2], &op
->args
[4]);
1172 swap_commutative(op
->args
[1], &op
->args
[3], &op
->args
[5]);
1174 CASE_OP_32_64(mulu2
):
1175 CASE_OP_32_64(muls2
):
1176 swap_commutative(op
->args
[0], &op
->args
[2], &op
->args
[3]);
1178 case INDEX_op_brcond2_i32
:
1179 if (swap_commutative2(&op
->args
[0], &op
->args
[2])) {
1180 op
->args
[4] = tcg_swap_cond(op
->args
[4]);
1183 case INDEX_op_setcond2_i32
:
1184 if (swap_commutative2(&op
->args
[1], &op
->args
[3])) {
1185 op
->args
[5] = tcg_swap_cond(op
->args
[5]);
1192 /* Simplify expressions for "shift/rot r, 0, a => movi r, 0",
1193 and "sub r, 0, a => neg r, a" case. */
1198 CASE_OP_32_64(rotl
):
1199 CASE_OP_32_64(rotr
):
1200 if (arg_is_const(op
->args
[1])
1201 && arg_info(op
->args
[1])->val
== 0) {
1202 tcg_opt_gen_movi(&ctx
, op
, op
->args
[0], 0);
1206 CASE_OP_32_64_VEC(sub
):
1211 if (arg_is_const(op
->args
[2])) {
1212 /* Proceed with possible constant folding. */
1215 if (opc
== INDEX_op_sub_i32
) {
1216 neg_op
= INDEX_op_neg_i32
;
1217 have_neg
= TCG_TARGET_HAS_neg_i32
;
1218 } else if (opc
== INDEX_op_sub_i64
) {
1219 neg_op
= INDEX_op_neg_i64
;
1220 have_neg
= TCG_TARGET_HAS_neg_i64
;
1221 } else if (TCG_TARGET_HAS_neg_vec
) {
1222 TCGType type
= TCGOP_VECL(op
) + TCG_TYPE_V64
;
1223 unsigned vece
= TCGOP_VECE(op
);
1224 neg_op
= INDEX_op_neg_vec
;
1225 have_neg
= tcg_can_emit_vec_op(neg_op
, type
, vece
) > 0;
1232 if (arg_is_const(op
->args
[1])
1233 && arg_info(op
->args
[1])->val
== 0) {
1235 reset_temp(op
->args
[0]);
1236 op
->args
[1] = op
->args
[2];
1241 CASE_OP_32_64_VEC(xor):
1242 CASE_OP_32_64(nand
):
1243 if (!arg_is_const(op
->args
[1])
1244 && arg_is_const(op
->args
[2])
1245 && arg_info(op
->args
[2])->val
== -1) {
1251 if (!arg_is_const(op
->args
[1])
1252 && arg_is_const(op
->args
[2])
1253 && arg_info(op
->args
[2])->val
== 0) {
1258 CASE_OP_32_64_VEC(andc
):
1259 if (!arg_is_const(op
->args
[2])
1260 && arg_is_const(op
->args
[1])
1261 && arg_info(op
->args
[1])->val
== -1) {
1266 CASE_OP_32_64_VEC(orc
):
1268 if (!arg_is_const(op
->args
[2])
1269 && arg_is_const(op
->args
[1])
1270 && arg_info(op
->args
[1])->val
== 0) {
1280 if (def
->flags
& TCG_OPF_VECTOR
) {
1281 not_op
= INDEX_op_not_vec
;
1282 have_not
= TCG_TARGET_HAS_not_vec
;
1283 } else if (def
->flags
& TCG_OPF_64BIT
) {
1284 not_op
= INDEX_op_not_i64
;
1285 have_not
= TCG_TARGET_HAS_not_i64
;
1287 not_op
= INDEX_op_not_i32
;
1288 have_not
= TCG_TARGET_HAS_not_i32
;
1294 reset_temp(op
->args
[0]);
1295 op
->args
[1] = op
->args
[i
];
1302 /* Simplify expression for "op r, a, const => mov r, a" cases */
1304 CASE_OP_32_64_VEC(add
):
1305 CASE_OP_32_64_VEC(sub
):
1306 CASE_OP_32_64_VEC(or):
1307 CASE_OP_32_64_VEC(xor):
1308 CASE_OP_32_64_VEC(andc
):
1312 CASE_OP_32_64(rotl
):
1313 CASE_OP_32_64(rotr
):
1314 if (!arg_is_const(op
->args
[1])
1315 && arg_is_const(op
->args
[2])
1316 && arg_info(op
->args
[2])->val
== 0) {
1317 tcg_opt_gen_mov(&ctx
, op
, op
->args
[0], op
->args
[1]);
1321 CASE_OP_32_64_VEC(and):
1322 CASE_OP_32_64_VEC(orc
):
1324 if (!arg_is_const(op
->args
[1])
1325 && arg_is_const(op
->args
[2])
1326 && arg_info(op
->args
[2])->val
== -1) {
1327 tcg_opt_gen_mov(&ctx
, op
, op
->args
[0], op
->args
[1]);
1335 /* Simplify using known-zero bits. Currently only ops with a single
1336 output argument is supported. */
1340 CASE_OP_32_64(ext8s
):
1341 if ((arg_info(op
->args
[1])->z_mask
& 0x80) != 0) {
1345 CASE_OP_32_64(ext8u
):
1348 CASE_OP_32_64(ext16s
):
1349 if ((arg_info(op
->args
[1])->z_mask
& 0x8000) != 0) {
1353 CASE_OP_32_64(ext16u
):
1356 case INDEX_op_ext32s_i64
:
1357 if ((arg_info(op
->args
[1])->z_mask
& 0x80000000) != 0) {
1361 case INDEX_op_ext32u_i64
:
1362 z_mask
= 0xffffffffU
;
1366 z_mask
= arg_info(op
->args
[2])->z_mask
;
1367 if (arg_is_const(op
->args
[2])) {
1369 affected
= arg_info(op
->args
[1])->z_mask
& ~z_mask
;
1371 z_mask
= arg_info(op
->args
[1])->z_mask
& z_mask
;
1374 case INDEX_op_ext_i32_i64
:
1375 if ((arg_info(op
->args
[1])->z_mask
& 0x80000000) != 0) {
1379 case INDEX_op_extu_i32_i64
:
1380 /* We do not compute affected as it is a size changing op. */
1381 z_mask
= (uint32_t)arg_info(op
->args
[1])->z_mask
;
1384 CASE_OP_32_64(andc
):
1385 /* Known-zeros does not imply known-ones. Therefore unless
1386 op->args[2] is constant, we can't infer anything from it. */
1387 if (arg_is_const(op
->args
[2])) {
1388 z_mask
= ~arg_info(op
->args
[2])->z_mask
;
1391 /* But we certainly know nothing outside args[1] may be set. */
1392 z_mask
= arg_info(op
->args
[1])->z_mask
;
1395 case INDEX_op_sar_i32
:
1396 if (arg_is_const(op
->args
[2])) {
1397 tmp
= arg_info(op
->args
[2])->val
& 31;
1398 z_mask
= (int32_t)arg_info(op
->args
[1])->z_mask
>> tmp
;
1401 case INDEX_op_sar_i64
:
1402 if (arg_is_const(op
->args
[2])) {
1403 tmp
= arg_info(op
->args
[2])->val
& 63;
1404 z_mask
= (int64_t)arg_info(op
->args
[1])->z_mask
>> tmp
;
1408 case INDEX_op_shr_i32
:
1409 if (arg_is_const(op
->args
[2])) {
1410 tmp
= arg_info(op
->args
[2])->val
& 31;
1411 z_mask
= (uint32_t)arg_info(op
->args
[1])->z_mask
>> tmp
;
1414 case INDEX_op_shr_i64
:
1415 if (arg_is_const(op
->args
[2])) {
1416 tmp
= arg_info(op
->args
[2])->val
& 63;
1417 z_mask
= (uint64_t)arg_info(op
->args
[1])->z_mask
>> tmp
;
1421 case INDEX_op_extrl_i64_i32
:
1422 z_mask
= (uint32_t)arg_info(op
->args
[1])->z_mask
;
1424 case INDEX_op_extrh_i64_i32
:
1425 z_mask
= (uint64_t)arg_info(op
->args
[1])->z_mask
>> 32;
1429 if (arg_is_const(op
->args
[2])) {
1430 tmp
= arg_info(op
->args
[2])->val
& (TCG_TARGET_REG_BITS
- 1);
1431 z_mask
= arg_info(op
->args
[1])->z_mask
<< tmp
;
1436 /* Set to 1 all bits to the left of the rightmost. */
1437 z_mask
= -(arg_info(op
->args
[1])->z_mask
1438 & -arg_info(op
->args
[1])->z_mask
);
1441 CASE_OP_32_64(deposit
):
1442 z_mask
= deposit64(arg_info(op
->args
[1])->z_mask
,
1443 op
->args
[3], op
->args
[4],
1444 arg_info(op
->args
[2])->z_mask
);
1447 CASE_OP_32_64(extract
):
1448 z_mask
= extract64(arg_info(op
->args
[1])->z_mask
,
1449 op
->args
[2], op
->args
[3]);
1450 if (op
->args
[2] == 0) {
1451 affected
= arg_info(op
->args
[1])->z_mask
& ~z_mask
;
1454 CASE_OP_32_64(sextract
):
1455 z_mask
= sextract64(arg_info(op
->args
[1])->z_mask
,
1456 op
->args
[2], op
->args
[3]);
1457 if (op
->args
[2] == 0 && (tcg_target_long
)z_mask
>= 0) {
1458 affected
= arg_info(op
->args
[1])->z_mask
& ~z_mask
;
1464 z_mask
= arg_info(op
->args
[1])->z_mask
1465 | arg_info(op
->args
[2])->z_mask
;
1468 case INDEX_op_clz_i32
:
1469 case INDEX_op_ctz_i32
:
1470 z_mask
= arg_info(op
->args
[2])->z_mask
| 31;
1473 case INDEX_op_clz_i64
:
1474 case INDEX_op_ctz_i64
:
1475 z_mask
= arg_info(op
->args
[2])->z_mask
| 63;
1478 case INDEX_op_ctpop_i32
:
1481 case INDEX_op_ctpop_i64
:
1485 CASE_OP_32_64(setcond
):
1486 case INDEX_op_setcond2_i32
:
1490 CASE_OP_32_64(movcond
):
1491 z_mask
= arg_info(op
->args
[3])->z_mask
1492 | arg_info(op
->args
[4])->z_mask
;
1495 CASE_OP_32_64(ld8u
):
1498 CASE_OP_32_64(ld16u
):
1501 case INDEX_op_ld32u_i64
:
1502 z_mask
= 0xffffffffu
;
1505 CASE_OP_32_64(qemu_ld
):
1507 MemOpIdx oi
= op
->args
[def
->nb_oargs
+ def
->nb_iargs
];
1508 MemOp mop
= get_memop(oi
);
1509 if (!(mop
& MO_SIGN
)) {
1510 z_mask
= (2ULL << ((8 << (mop
& MO_SIZE
)) - 1)) - 1;
1515 CASE_OP_32_64(bswap16
):
1516 z_mask
= arg_info(op
->args
[1])->z_mask
;
1517 if (z_mask
<= 0xffff) {
1518 op
->args
[2] |= TCG_BSWAP_IZ
;
1520 z_mask
= bswap16(z_mask
);
1521 switch (op
->args
[2] & (TCG_BSWAP_OZ
| TCG_BSWAP_OS
)) {
1525 z_mask
= (int16_t)z_mask
;
1527 default: /* undefined high bits */
1528 z_mask
|= MAKE_64BIT_MASK(16, 48);
1533 case INDEX_op_bswap32_i64
:
1534 z_mask
= arg_info(op
->args
[1])->z_mask
;
1535 if (z_mask
<= 0xffffffffu
) {
1536 op
->args
[2] |= TCG_BSWAP_IZ
;
1538 z_mask
= bswap32(z_mask
);
1539 switch (op
->args
[2] & (TCG_BSWAP_OZ
| TCG_BSWAP_OS
)) {
1543 z_mask
= (int32_t)z_mask
;
1545 default: /* undefined high bits */
1546 z_mask
|= MAKE_64BIT_MASK(32, 32);
1555 /* 32-bit ops generate 32-bit results. For the result is zero test
1556 below, we can ignore high bits, but for further optimizations we
1557 need to record that the high bits contain garbage. */
1559 if (!(def
->flags
& TCG_OPF_64BIT
)) {
1560 z_mask
|= ~(tcg_target_ulong
)0xffffffffu
;
1561 partmask
&= 0xffffffffu
;
1562 affected
&= 0xffffffffu
;
1564 ctx
.z_mask
= z_mask
;
1566 if (partmask
== 0) {
1567 tcg_opt_gen_movi(&ctx
, op
, op
->args
[0], 0);
1570 if (affected
== 0) {
1571 tcg_opt_gen_mov(&ctx
, op
, op
->args
[0], op
->args
[1]);
1575 /* Simplify expression for "op r, a, 0 => movi r, 0" cases */
1577 CASE_OP_32_64_VEC(and):
1578 CASE_OP_32_64_VEC(mul
):
1579 CASE_OP_32_64(muluh
):
1580 CASE_OP_32_64(mulsh
):
1581 if (arg_is_const(op
->args
[2])
1582 && arg_info(op
->args
[2])->val
== 0) {
1583 tcg_opt_gen_movi(&ctx
, op
, op
->args
[0], 0);
1591 /* Simplify expression for "op r, a, a => mov r, a" cases */
1593 CASE_OP_32_64_VEC(or):
1594 CASE_OP_32_64_VEC(and):
1595 if (args_are_copies(op
->args
[1], op
->args
[2])) {
1596 tcg_opt_gen_mov(&ctx
, op
, op
->args
[0], op
->args
[1]);
1604 /* Simplify expression for "op r, a, a => movi r, 0" cases */
1606 CASE_OP_32_64_VEC(andc
):
1607 CASE_OP_32_64_VEC(sub
):
1608 CASE_OP_32_64_VEC(xor):
1609 if (args_are_copies(op
->args
[1], op
->args
[2])) {
1610 tcg_opt_gen_movi(&ctx
, op
, op
->args
[0], 0);
1618 /* Propagate constants through copy operations and do constant
1619 folding. Constants will be substituted to arguments by register
1620 allocator where needed and possible. Also detect copies. */
1622 CASE_OP_32_64_VEC(mov
):
1623 done
= tcg_opt_gen_mov(&ctx
, op
, op
->args
[0], op
->args
[1]);
1626 case INDEX_op_dup_vec
:
1627 if (arg_is_const(op
->args
[1])) {
1628 tmp
= arg_info(op
->args
[1])->val
;
1629 tmp
= dup_const(TCGOP_VECE(op
), tmp
);
1630 tcg_opt_gen_movi(&ctx
, op
, op
->args
[0], tmp
);
1635 case INDEX_op_dup2_vec
:
1636 assert(TCG_TARGET_REG_BITS
== 32);
1637 if (arg_is_const(op
->args
[1]) && arg_is_const(op
->args
[2])) {
1638 tcg_opt_gen_movi(&ctx
, op
, op
->args
[0],
1639 deposit64(arg_info(op
->args
[1])->val
, 32, 32,
1640 arg_info(op
->args
[2])->val
));
1642 } else if (args_are_copies(op
->args
[1], op
->args
[2])) {
1643 op
->opc
= INDEX_op_dup_vec
;
1644 TCGOP_VECE(op
) = MO_32
;
1648 CASE_OP_32_64(bswap16
):
1649 CASE_OP_32_64(bswap32
):
1650 case INDEX_op_bswap64_i64
:
1651 if (arg_is_const(op
->args
[1])) {
1652 tmp
= do_constant_folding(opc
, arg_info(op
->args
[1])->val
,
1654 tcg_opt_gen_movi(&ctx
, op
, op
->args
[0], tmp
);
1661 if (arg_is_const(op
->args
[1])) {
1662 TCGArg v
= arg_info(op
->args
[1])->val
;
1664 tmp
= do_constant_folding(opc
, v
, 0);
1665 tcg_opt_gen_movi(&ctx
, op
, op
->args
[0], tmp
);
1667 tcg_opt_gen_mov(&ctx
, op
, op
->args
[0], op
->args
[2]);
1673 CASE_OP_32_64(deposit
):
1674 if (arg_is_const(op
->args
[1]) && arg_is_const(op
->args
[2])) {
1675 tmp
= deposit64(arg_info(op
->args
[1])->val
,
1676 op
->args
[3], op
->args
[4],
1677 arg_info(op
->args
[2])->val
);
1678 tcg_opt_gen_movi(&ctx
, op
, op
->args
[0], tmp
);
1683 CASE_OP_32_64(extract
):
1684 if (arg_is_const(op
->args
[1])) {
1685 tmp
= extract64(arg_info(op
->args
[1])->val
,
1686 op
->args
[2], op
->args
[3]);
1687 tcg_opt_gen_movi(&ctx
, op
, op
->args
[0], tmp
);
1692 CASE_OP_32_64(sextract
):
1693 if (arg_is_const(op
->args
[1])) {
1694 tmp
= sextract64(arg_info(op
->args
[1])->val
,
1695 op
->args
[2], op
->args
[3]);
1696 tcg_opt_gen_movi(&ctx
, op
, op
->args
[0], tmp
);
1701 CASE_OP_32_64(extract2
):
1702 if (arg_is_const(op
->args
[1]) && arg_is_const(op
->args
[2])) {
1703 uint64_t v1
= arg_info(op
->args
[1])->val
;
1704 uint64_t v2
= arg_info(op
->args
[2])->val
;
1705 int shr
= op
->args
[3];
1707 if (opc
== INDEX_op_extract2_i64
) {
1708 tmp
= (v1
>> shr
) | (v2
<< (64 - shr
));
1710 tmp
= (int32_t)(((uint32_t)v1
>> shr
) |
1711 ((uint32_t)v2
<< (32 - shr
)));
1713 tcg_opt_gen_movi(&ctx
, op
, op
->args
[0], tmp
);
1718 CASE_OP_32_64(movcond
):
1719 i
= do_constant_folding_cond(opc
, op
->args
[1],
1720 op
->args
[2], op
->args
[5]);
1722 tcg_opt_gen_mov(&ctx
, op
, op
->args
[0], op
->args
[4 - i
]);
1725 if (arg_is_const(op
->args
[3]) && arg_is_const(op
->args
[4])) {
1726 uint64_t tv
= arg_info(op
->args
[3])->val
;
1727 uint64_t fv
= arg_info(op
->args
[4])->val
;
1728 TCGCond cond
= op
->args
[5];
1730 if (fv
== 1 && tv
== 0) {
1731 cond
= tcg_invert_cond(cond
);
1732 } else if (!(tv
== 1 && fv
== 0)) {
1736 op
->opc
= opc
= (opc
== INDEX_op_movcond_i32
1737 ? INDEX_op_setcond_i32
1738 : INDEX_op_setcond_i64
);
1746 /* ---------------------------------------------------------- */
1747 /* Sorted alphabetically by opcode as much as possible. */
1749 CASE_OP_32_64_VEC(add
):
1750 done
= fold_add(&ctx
, op
);
1752 case INDEX_op_add2_i32
:
1753 done
= fold_add2_i32(&ctx
, op
);
1755 CASE_OP_32_64_VEC(and):
1756 done
= fold_and(&ctx
, op
);
1758 CASE_OP_32_64_VEC(andc
):
1759 done
= fold_andc(&ctx
, op
);
1761 CASE_OP_32_64(brcond
):
1762 done
= fold_brcond(&ctx
, op
);
1764 case INDEX_op_brcond2_i32
:
1765 done
= fold_brcond2(&ctx
, op
);
1767 CASE_OP_32_64(ctpop
):
1768 done
= fold_ctpop(&ctx
, op
);
1771 CASE_OP_32_64(divu
):
1772 done
= fold_divide(&ctx
, op
);
1775 done
= fold_eqv(&ctx
, op
);
1777 CASE_OP_32_64(ext8s
):
1778 CASE_OP_32_64(ext16s
):
1779 case INDEX_op_ext32s_i64
:
1780 case INDEX_op_ext_i32_i64
:
1781 done
= fold_exts(&ctx
, op
);
1783 CASE_OP_32_64(ext8u
):
1784 CASE_OP_32_64(ext16u
):
1785 case INDEX_op_ext32u_i64
:
1786 case INDEX_op_extu_i32_i64
:
1787 case INDEX_op_extrl_i64_i32
:
1788 case INDEX_op_extrh_i64_i32
:
1789 done
= fold_extu(&ctx
, op
);
1792 done
= fold_mb(&ctx
, op
);
1795 done
= fold_mul(&ctx
, op
);
1797 CASE_OP_32_64(mulsh
):
1798 CASE_OP_32_64(muluh
):
1799 done
= fold_mul_highpart(&ctx
, op
);
1801 case INDEX_op_mulu2_i32
:
1802 done
= fold_mulu2_i32(&ctx
, op
);
1804 CASE_OP_32_64(nand
):
1805 done
= fold_nand(&ctx
, op
);
1808 done
= fold_neg(&ctx
, op
);
1811 done
= fold_nor(&ctx
, op
);
1813 CASE_OP_32_64_VEC(not):
1814 done
= fold_not(&ctx
, op
);
1816 CASE_OP_32_64_VEC(or):
1817 done
= fold_or(&ctx
, op
);
1819 CASE_OP_32_64_VEC(orc
):
1820 done
= fold_orc(&ctx
, op
);
1822 case INDEX_op_qemu_ld_i32
:
1823 case INDEX_op_qemu_ld_i64
:
1824 done
= fold_qemu_ld(&ctx
, op
);
1826 case INDEX_op_qemu_st_i32
:
1827 case INDEX_op_qemu_st8_i32
:
1828 case INDEX_op_qemu_st_i64
:
1829 done
= fold_qemu_st(&ctx
, op
);
1832 CASE_OP_32_64(remu
):
1833 done
= fold_remainder(&ctx
, op
);
1835 CASE_OP_32_64(rotl
):
1836 CASE_OP_32_64(rotr
):
1840 done
= fold_shift(&ctx
, op
);
1842 CASE_OP_32_64(setcond
):
1843 done
= fold_setcond(&ctx
, op
);
1845 case INDEX_op_setcond2_i32
:
1846 done
= fold_setcond2(&ctx
, op
);
1848 CASE_OP_32_64_VEC(sub
):
1849 done
= fold_sub(&ctx
, op
);
1851 case INDEX_op_sub2_i32
:
1852 done
= fold_sub2_i32(&ctx
, op
);
1854 CASE_OP_32_64_VEC(xor):
1855 done
= fold_xor(&ctx
, op
);
1860 finish_folding(&ctx
, op
);