stubs: Move qemu_fd_register stub to util/main-loop.c
[qemu.git] / tcg / optimize.c
1 /*
2 * Optimizations for Tiny Code Generator for QEMU
3 *
4 * Copyright (c) 2010 Samsung Electronics.
5 * Contributed by Kirill Batuzov <batuzovk@ispras.ru>
6 *
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:
13 *
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
16 *
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
23 * THE SOFTWARE.
24 */
25
26 #include "qemu/osdep.h"
27 #include "tcg/tcg-op.h"
28
29 #define CASE_OP_32_64(x) \
30 glue(glue(case INDEX_op_, x), _i32): \
31 glue(glue(case INDEX_op_, x), _i64)
32
33 #define CASE_OP_32_64_VEC(x) \
34 glue(glue(case INDEX_op_, x), _i32): \
35 glue(glue(case INDEX_op_, x), _i64): \
36 glue(glue(case INDEX_op_, x), _vec)
37
38 struct tcg_temp_info {
39 bool is_const;
40 TCGTemp *prev_copy;
41 TCGTemp *next_copy;
42 tcg_target_ulong val;
43 tcg_target_ulong mask;
44 };
45
46 static inline struct tcg_temp_info *ts_info(TCGTemp *ts)
47 {
48 return ts->state_ptr;
49 }
50
51 static inline struct tcg_temp_info *arg_info(TCGArg arg)
52 {
53 return ts_info(arg_temp(arg));
54 }
55
56 static inline bool ts_is_const(TCGTemp *ts)
57 {
58 return ts_info(ts)->is_const;
59 }
60
61 static inline bool arg_is_const(TCGArg arg)
62 {
63 return ts_is_const(arg_temp(arg));
64 }
65
66 static inline bool ts_is_copy(TCGTemp *ts)
67 {
68 return ts_info(ts)->next_copy != ts;
69 }
70
71 /* Reset TEMP's state, possibly removing the temp for the list of copies. */
72 static void reset_ts(TCGTemp *ts)
73 {
74 struct tcg_temp_info *ti = ts_info(ts);
75 struct tcg_temp_info *pi = ts_info(ti->prev_copy);
76 struct tcg_temp_info *ni = ts_info(ti->next_copy);
77
78 ni->prev_copy = ti->prev_copy;
79 pi->next_copy = ti->next_copy;
80 ti->next_copy = ts;
81 ti->prev_copy = ts;
82 ti->is_const = false;
83 ti->mask = -1;
84 }
85
86 static void reset_temp(TCGArg arg)
87 {
88 reset_ts(arg_temp(arg));
89 }
90
91 /* Initialize and activate a temporary. */
92 static void init_ts_info(struct tcg_temp_info *infos,
93 TCGTempSet *temps_used, TCGTemp *ts)
94 {
95 size_t idx = temp_idx(ts);
96 if (!test_bit(idx, temps_used->l)) {
97 struct tcg_temp_info *ti = &infos[idx];
98
99 ts->state_ptr = ti;
100 ti->next_copy = ts;
101 ti->prev_copy = ts;
102 ti->is_const = false;
103 ti->mask = -1;
104 set_bit(idx, temps_used->l);
105 }
106 }
107
108 static void init_arg_info(struct tcg_temp_info *infos,
109 TCGTempSet *temps_used, TCGArg arg)
110 {
111 init_ts_info(infos, temps_used, arg_temp(arg));
112 }
113
114 static TCGTemp *find_better_copy(TCGContext *s, TCGTemp *ts)
115 {
116 TCGTemp *i;
117
118 /* If this is already a global, we can't do better. */
119 if (ts->temp_global) {
120 return ts;
121 }
122
123 /* Search for a global first. */
124 for (i = ts_info(ts)->next_copy; i != ts; i = ts_info(i)->next_copy) {
125 if (i->temp_global) {
126 return i;
127 }
128 }
129
130 /* If it is a temp, search for a temp local. */
131 if (!ts->temp_local) {
132 for (i = ts_info(ts)->next_copy; i != ts; i = ts_info(i)->next_copy) {
133 if (ts->temp_local) {
134 return i;
135 }
136 }
137 }
138
139 /* Failure to find a better representation, return the same temp. */
140 return ts;
141 }
142
143 static bool ts_are_copies(TCGTemp *ts1, TCGTemp *ts2)
144 {
145 TCGTemp *i;
146
147 if (ts1 == ts2) {
148 return true;
149 }
150
151 if (!ts_is_copy(ts1) || !ts_is_copy(ts2)) {
152 return false;
153 }
154
155 for (i = ts_info(ts1)->next_copy; i != ts1; i = ts_info(i)->next_copy) {
156 if (i == ts2) {
157 return true;
158 }
159 }
160
161 return false;
162 }
163
164 static bool args_are_copies(TCGArg arg1, TCGArg arg2)
165 {
166 return ts_are_copies(arg_temp(arg1), arg_temp(arg2));
167 }
168
169 static void tcg_opt_gen_movi(TCGContext *s, TCGOp *op, TCGArg dst, TCGArg val)
170 {
171 const TCGOpDef *def;
172 TCGOpcode new_op;
173 tcg_target_ulong mask;
174 struct tcg_temp_info *di = arg_info(dst);
175
176 def = &tcg_op_defs[op->opc];
177 if (def->flags & TCG_OPF_VECTOR) {
178 new_op = INDEX_op_dupi_vec;
179 } else if (def->flags & TCG_OPF_64BIT) {
180 new_op = INDEX_op_movi_i64;
181 } else {
182 new_op = INDEX_op_movi_i32;
183 }
184 op->opc = new_op;
185 /* TCGOP_VECL and TCGOP_VECE remain unchanged. */
186 op->args[0] = dst;
187 op->args[1] = val;
188
189 reset_temp(dst);
190 di->is_const = true;
191 di->val = val;
192 mask = val;
193 if (TCG_TARGET_REG_BITS > 32 && new_op == INDEX_op_movi_i32) {
194 /* High bits of the destination are now garbage. */
195 mask |= ~0xffffffffull;
196 }
197 di->mask = mask;
198 }
199
200 static void tcg_opt_gen_mov(TCGContext *s, TCGOp *op, TCGArg dst, TCGArg src)
201 {
202 TCGTemp *dst_ts = arg_temp(dst);
203 TCGTemp *src_ts = arg_temp(src);
204 const TCGOpDef *def;
205 struct tcg_temp_info *di;
206 struct tcg_temp_info *si;
207 tcg_target_ulong mask;
208 TCGOpcode new_op;
209
210 if (ts_are_copies(dst_ts, src_ts)) {
211 tcg_op_remove(s, op);
212 return;
213 }
214
215 reset_ts(dst_ts);
216 di = ts_info(dst_ts);
217 si = ts_info(src_ts);
218 def = &tcg_op_defs[op->opc];
219 if (def->flags & TCG_OPF_VECTOR) {
220 new_op = INDEX_op_mov_vec;
221 } else if (def->flags & TCG_OPF_64BIT) {
222 new_op = INDEX_op_mov_i64;
223 } else {
224 new_op = INDEX_op_mov_i32;
225 }
226 op->opc = new_op;
227 /* TCGOP_VECL and TCGOP_VECE remain unchanged. */
228 op->args[0] = dst;
229 op->args[1] = src;
230
231 mask = si->mask;
232 if (TCG_TARGET_REG_BITS > 32 && new_op == INDEX_op_mov_i32) {
233 /* High bits of the destination are now garbage. */
234 mask |= ~0xffffffffull;
235 }
236 di->mask = mask;
237
238 if (src_ts->type == dst_ts->type) {
239 struct tcg_temp_info *ni = ts_info(si->next_copy);
240
241 di->next_copy = si->next_copy;
242 di->prev_copy = src_ts;
243 ni->prev_copy = dst_ts;
244 si->next_copy = dst_ts;
245 di->is_const = si->is_const;
246 di->val = si->val;
247 }
248 }
249
250 static TCGArg do_constant_folding_2(TCGOpcode op, TCGArg x, TCGArg y)
251 {
252 uint64_t l64, h64;
253
254 switch (op) {
255 CASE_OP_32_64(add):
256 return x + y;
257
258 CASE_OP_32_64(sub):
259 return x - y;
260
261 CASE_OP_32_64(mul):
262 return x * y;
263
264 CASE_OP_32_64(and):
265 return x & y;
266
267 CASE_OP_32_64(or):
268 return x | y;
269
270 CASE_OP_32_64(xor):
271 return x ^ y;
272
273 case INDEX_op_shl_i32:
274 return (uint32_t)x << (y & 31);
275
276 case INDEX_op_shl_i64:
277 return (uint64_t)x << (y & 63);
278
279 case INDEX_op_shr_i32:
280 return (uint32_t)x >> (y & 31);
281
282 case INDEX_op_shr_i64:
283 return (uint64_t)x >> (y & 63);
284
285 case INDEX_op_sar_i32:
286 return (int32_t)x >> (y & 31);
287
288 case INDEX_op_sar_i64:
289 return (int64_t)x >> (y & 63);
290
291 case INDEX_op_rotr_i32:
292 return ror32(x, y & 31);
293
294 case INDEX_op_rotr_i64:
295 return ror64(x, y & 63);
296
297 case INDEX_op_rotl_i32:
298 return rol32(x, y & 31);
299
300 case INDEX_op_rotl_i64:
301 return rol64(x, y & 63);
302
303 CASE_OP_32_64(not):
304 return ~x;
305
306 CASE_OP_32_64(neg):
307 return -x;
308
309 CASE_OP_32_64(andc):
310 return x & ~y;
311
312 CASE_OP_32_64(orc):
313 return x | ~y;
314
315 CASE_OP_32_64(eqv):
316 return ~(x ^ y);
317
318 CASE_OP_32_64(nand):
319 return ~(x & y);
320
321 CASE_OP_32_64(nor):
322 return ~(x | y);
323
324 case INDEX_op_clz_i32:
325 return (uint32_t)x ? clz32(x) : y;
326
327 case INDEX_op_clz_i64:
328 return x ? clz64(x) : y;
329
330 case INDEX_op_ctz_i32:
331 return (uint32_t)x ? ctz32(x) : y;
332
333 case INDEX_op_ctz_i64:
334 return x ? ctz64(x) : y;
335
336 case INDEX_op_ctpop_i32:
337 return ctpop32(x);
338
339 case INDEX_op_ctpop_i64:
340 return ctpop64(x);
341
342 CASE_OP_32_64(ext8s):
343 return (int8_t)x;
344
345 CASE_OP_32_64(ext16s):
346 return (int16_t)x;
347
348 CASE_OP_32_64(ext8u):
349 return (uint8_t)x;
350
351 CASE_OP_32_64(ext16u):
352 return (uint16_t)x;
353
354 CASE_OP_32_64(bswap16):
355 return bswap16(x);
356
357 CASE_OP_32_64(bswap32):
358 return bswap32(x);
359
360 case INDEX_op_bswap64_i64:
361 return bswap64(x);
362
363 case INDEX_op_ext_i32_i64:
364 case INDEX_op_ext32s_i64:
365 return (int32_t)x;
366
367 case INDEX_op_extu_i32_i64:
368 case INDEX_op_extrl_i64_i32:
369 case INDEX_op_ext32u_i64:
370 return (uint32_t)x;
371
372 case INDEX_op_extrh_i64_i32:
373 return (uint64_t)x >> 32;
374
375 case INDEX_op_muluh_i32:
376 return ((uint64_t)(uint32_t)x * (uint32_t)y) >> 32;
377 case INDEX_op_mulsh_i32:
378 return ((int64_t)(int32_t)x * (int32_t)y) >> 32;
379
380 case INDEX_op_muluh_i64:
381 mulu64(&l64, &h64, x, y);
382 return h64;
383 case INDEX_op_mulsh_i64:
384 muls64(&l64, &h64, x, y);
385 return h64;
386
387 case INDEX_op_div_i32:
388 /* Avoid crashing on divide by zero, otherwise undefined. */
389 return (int32_t)x / ((int32_t)y ? : 1);
390 case INDEX_op_divu_i32:
391 return (uint32_t)x / ((uint32_t)y ? : 1);
392 case INDEX_op_div_i64:
393 return (int64_t)x / ((int64_t)y ? : 1);
394 case INDEX_op_divu_i64:
395 return (uint64_t)x / ((uint64_t)y ? : 1);
396
397 case INDEX_op_rem_i32:
398 return (int32_t)x % ((int32_t)y ? : 1);
399 case INDEX_op_remu_i32:
400 return (uint32_t)x % ((uint32_t)y ? : 1);
401 case INDEX_op_rem_i64:
402 return (int64_t)x % ((int64_t)y ? : 1);
403 case INDEX_op_remu_i64:
404 return (uint64_t)x % ((uint64_t)y ? : 1);
405
406 default:
407 fprintf(stderr,
408 "Unrecognized operation %d in do_constant_folding.\n", op);
409 tcg_abort();
410 }
411 }
412
413 static TCGArg do_constant_folding(TCGOpcode op, TCGArg x, TCGArg y)
414 {
415 const TCGOpDef *def = &tcg_op_defs[op];
416 TCGArg res = do_constant_folding_2(op, x, y);
417 if (!(def->flags & TCG_OPF_64BIT)) {
418 res = (int32_t)res;
419 }
420 return res;
421 }
422
423 static bool do_constant_folding_cond_32(uint32_t x, uint32_t y, TCGCond c)
424 {
425 switch (c) {
426 case TCG_COND_EQ:
427 return x == y;
428 case TCG_COND_NE:
429 return x != y;
430 case TCG_COND_LT:
431 return (int32_t)x < (int32_t)y;
432 case TCG_COND_GE:
433 return (int32_t)x >= (int32_t)y;
434 case TCG_COND_LE:
435 return (int32_t)x <= (int32_t)y;
436 case TCG_COND_GT:
437 return (int32_t)x > (int32_t)y;
438 case TCG_COND_LTU:
439 return x < y;
440 case TCG_COND_GEU:
441 return x >= y;
442 case TCG_COND_LEU:
443 return x <= y;
444 case TCG_COND_GTU:
445 return x > y;
446 default:
447 tcg_abort();
448 }
449 }
450
451 static bool do_constant_folding_cond_64(uint64_t x, uint64_t y, TCGCond c)
452 {
453 switch (c) {
454 case TCG_COND_EQ:
455 return x == y;
456 case TCG_COND_NE:
457 return x != y;
458 case TCG_COND_LT:
459 return (int64_t)x < (int64_t)y;
460 case TCG_COND_GE:
461 return (int64_t)x >= (int64_t)y;
462 case TCG_COND_LE:
463 return (int64_t)x <= (int64_t)y;
464 case TCG_COND_GT:
465 return (int64_t)x > (int64_t)y;
466 case TCG_COND_LTU:
467 return x < y;
468 case TCG_COND_GEU:
469 return x >= y;
470 case TCG_COND_LEU:
471 return x <= y;
472 case TCG_COND_GTU:
473 return x > y;
474 default:
475 tcg_abort();
476 }
477 }
478
479 static bool do_constant_folding_cond_eq(TCGCond c)
480 {
481 switch (c) {
482 case TCG_COND_GT:
483 case TCG_COND_LTU:
484 case TCG_COND_LT:
485 case TCG_COND_GTU:
486 case TCG_COND_NE:
487 return 0;
488 case TCG_COND_GE:
489 case TCG_COND_GEU:
490 case TCG_COND_LE:
491 case TCG_COND_LEU:
492 case TCG_COND_EQ:
493 return 1;
494 default:
495 tcg_abort();
496 }
497 }
498
499 /* Return 2 if the condition can't be simplified, and the result
500 of the condition (0 or 1) if it can */
501 static TCGArg do_constant_folding_cond(TCGOpcode op, TCGArg x,
502 TCGArg y, TCGCond c)
503 {
504 tcg_target_ulong xv = arg_info(x)->val;
505 tcg_target_ulong yv = arg_info(y)->val;
506 if (arg_is_const(x) && arg_is_const(y)) {
507 const TCGOpDef *def = &tcg_op_defs[op];
508 tcg_debug_assert(!(def->flags & TCG_OPF_VECTOR));
509 if (def->flags & TCG_OPF_64BIT) {
510 return do_constant_folding_cond_64(xv, yv, c);
511 } else {
512 return do_constant_folding_cond_32(xv, yv, c);
513 }
514 } else if (args_are_copies(x, y)) {
515 return do_constant_folding_cond_eq(c);
516 } else if (arg_is_const(y) && yv == 0) {
517 switch (c) {
518 case TCG_COND_LTU:
519 return 0;
520 case TCG_COND_GEU:
521 return 1;
522 default:
523 return 2;
524 }
525 }
526 return 2;
527 }
528
529 /* Return 2 if the condition can't be simplified, and the result
530 of the condition (0 or 1) if it can */
531 static TCGArg do_constant_folding_cond2(TCGArg *p1, TCGArg *p2, TCGCond c)
532 {
533 TCGArg al = p1[0], ah = p1[1];
534 TCGArg bl = p2[0], bh = p2[1];
535
536 if (arg_is_const(bl) && arg_is_const(bh)) {
537 tcg_target_ulong blv = arg_info(bl)->val;
538 tcg_target_ulong bhv = arg_info(bh)->val;
539 uint64_t b = deposit64(blv, 32, 32, bhv);
540
541 if (arg_is_const(al) && arg_is_const(ah)) {
542 tcg_target_ulong alv = arg_info(al)->val;
543 tcg_target_ulong ahv = arg_info(ah)->val;
544 uint64_t a = deposit64(alv, 32, 32, ahv);
545 return do_constant_folding_cond_64(a, b, c);
546 }
547 if (b == 0) {
548 switch (c) {
549 case TCG_COND_LTU:
550 return 0;
551 case TCG_COND_GEU:
552 return 1;
553 default:
554 break;
555 }
556 }
557 }
558 if (args_are_copies(al, bl) && args_are_copies(ah, bh)) {
559 return do_constant_folding_cond_eq(c);
560 }
561 return 2;
562 }
563
564 static bool swap_commutative(TCGArg dest, TCGArg *p1, TCGArg *p2)
565 {
566 TCGArg a1 = *p1, a2 = *p2;
567 int sum = 0;
568 sum += arg_is_const(a1);
569 sum -= arg_is_const(a2);
570
571 /* Prefer the constant in second argument, and then the form
572 op a, a, b, which is better handled on non-RISC hosts. */
573 if (sum > 0 || (sum == 0 && dest == a2)) {
574 *p1 = a2;
575 *p2 = a1;
576 return true;
577 }
578 return false;
579 }
580
581 static bool swap_commutative2(TCGArg *p1, TCGArg *p2)
582 {
583 int sum = 0;
584 sum += arg_is_const(p1[0]);
585 sum += arg_is_const(p1[1]);
586 sum -= arg_is_const(p2[0]);
587 sum -= arg_is_const(p2[1]);
588 if (sum > 0) {
589 TCGArg t;
590 t = p1[0], p1[0] = p2[0], p2[0] = t;
591 t = p1[1], p1[1] = p2[1], p2[1] = t;
592 return true;
593 }
594 return false;
595 }
596
597 /* Propagate constants and copies, fold constant expressions. */
598 void tcg_optimize(TCGContext *s)
599 {
600 int nb_temps, nb_globals;
601 TCGOp *op, *op_next, *prev_mb = NULL;
602 struct tcg_temp_info *infos;
603 TCGTempSet temps_used;
604
605 /* Array VALS has an element for each temp.
606 If this temp holds a constant then its value is kept in VALS' element.
607 If this temp is a copy of other ones then the other copies are
608 available through the doubly linked circular list. */
609
610 nb_temps = s->nb_temps;
611 nb_globals = s->nb_globals;
612 bitmap_zero(temps_used.l, nb_temps);
613 infos = tcg_malloc(sizeof(struct tcg_temp_info) * nb_temps);
614
615 QTAILQ_FOREACH_SAFE(op, &s->ops, link, op_next) {
616 tcg_target_ulong mask, partmask, affected;
617 int nb_oargs, nb_iargs, i;
618 TCGArg tmp;
619 TCGOpcode opc = op->opc;
620 const TCGOpDef *def = &tcg_op_defs[opc];
621
622 /* Count the arguments, and initialize the temps that are
623 going to be used */
624 if (opc == INDEX_op_call) {
625 nb_oargs = TCGOP_CALLO(op);
626 nb_iargs = TCGOP_CALLI(op);
627 for (i = 0; i < nb_oargs + nb_iargs; i++) {
628 TCGTemp *ts = arg_temp(op->args[i]);
629 if (ts) {
630 init_ts_info(infos, &temps_used, ts);
631 }
632 }
633 } else {
634 nb_oargs = def->nb_oargs;
635 nb_iargs = def->nb_iargs;
636 for (i = 0; i < nb_oargs + nb_iargs; i++) {
637 init_arg_info(infos, &temps_used, op->args[i]);
638 }
639 }
640
641 /* Do copy propagation */
642 for (i = nb_oargs; i < nb_oargs + nb_iargs; i++) {
643 TCGTemp *ts = arg_temp(op->args[i]);
644 if (ts && ts_is_copy(ts)) {
645 op->args[i] = temp_arg(find_better_copy(s, ts));
646 }
647 }
648
649 /* For commutative operations make constant second argument */
650 switch (opc) {
651 CASE_OP_32_64_VEC(add):
652 CASE_OP_32_64_VEC(mul):
653 CASE_OP_32_64_VEC(and):
654 CASE_OP_32_64_VEC(or):
655 CASE_OP_32_64_VEC(xor):
656 CASE_OP_32_64(eqv):
657 CASE_OP_32_64(nand):
658 CASE_OP_32_64(nor):
659 CASE_OP_32_64(muluh):
660 CASE_OP_32_64(mulsh):
661 swap_commutative(op->args[0], &op->args[1], &op->args[2]);
662 break;
663 CASE_OP_32_64(brcond):
664 if (swap_commutative(-1, &op->args[0], &op->args[1])) {
665 op->args[2] = tcg_swap_cond(op->args[2]);
666 }
667 break;
668 CASE_OP_32_64(setcond):
669 if (swap_commutative(op->args[0], &op->args[1], &op->args[2])) {
670 op->args[3] = tcg_swap_cond(op->args[3]);
671 }
672 break;
673 CASE_OP_32_64(movcond):
674 if (swap_commutative(-1, &op->args[1], &op->args[2])) {
675 op->args[5] = tcg_swap_cond(op->args[5]);
676 }
677 /* For movcond, we canonicalize the "false" input reg to match
678 the destination reg so that the tcg backend can implement
679 a "move if true" operation. */
680 if (swap_commutative(op->args[0], &op->args[4], &op->args[3])) {
681 op->args[5] = tcg_invert_cond(op->args[5]);
682 }
683 break;
684 CASE_OP_32_64(add2):
685 swap_commutative(op->args[0], &op->args[2], &op->args[4]);
686 swap_commutative(op->args[1], &op->args[3], &op->args[5]);
687 break;
688 CASE_OP_32_64(mulu2):
689 CASE_OP_32_64(muls2):
690 swap_commutative(op->args[0], &op->args[2], &op->args[3]);
691 break;
692 case INDEX_op_brcond2_i32:
693 if (swap_commutative2(&op->args[0], &op->args[2])) {
694 op->args[4] = tcg_swap_cond(op->args[4]);
695 }
696 break;
697 case INDEX_op_setcond2_i32:
698 if (swap_commutative2(&op->args[1], &op->args[3])) {
699 op->args[5] = tcg_swap_cond(op->args[5]);
700 }
701 break;
702 default:
703 break;
704 }
705
706 /* Simplify expressions for "shift/rot r, 0, a => movi r, 0",
707 and "sub r, 0, a => neg r, a" case. */
708 switch (opc) {
709 CASE_OP_32_64(shl):
710 CASE_OP_32_64(shr):
711 CASE_OP_32_64(sar):
712 CASE_OP_32_64(rotl):
713 CASE_OP_32_64(rotr):
714 if (arg_is_const(op->args[1])
715 && arg_info(op->args[1])->val == 0) {
716 tcg_opt_gen_movi(s, op, op->args[0], 0);
717 continue;
718 }
719 break;
720 CASE_OP_32_64_VEC(sub):
721 {
722 TCGOpcode neg_op;
723 bool have_neg;
724
725 if (arg_is_const(op->args[2])) {
726 /* Proceed with possible constant folding. */
727 break;
728 }
729 if (opc == INDEX_op_sub_i32) {
730 neg_op = INDEX_op_neg_i32;
731 have_neg = TCG_TARGET_HAS_neg_i32;
732 } else if (opc == INDEX_op_sub_i64) {
733 neg_op = INDEX_op_neg_i64;
734 have_neg = TCG_TARGET_HAS_neg_i64;
735 } else if (TCG_TARGET_HAS_neg_vec) {
736 TCGType type = TCGOP_VECL(op) + TCG_TYPE_V64;
737 unsigned vece = TCGOP_VECE(op);
738 neg_op = INDEX_op_neg_vec;
739 have_neg = tcg_can_emit_vec_op(neg_op, type, vece) > 0;
740 } else {
741 break;
742 }
743 if (!have_neg) {
744 break;
745 }
746 if (arg_is_const(op->args[1])
747 && arg_info(op->args[1])->val == 0) {
748 op->opc = neg_op;
749 reset_temp(op->args[0]);
750 op->args[1] = op->args[2];
751 continue;
752 }
753 }
754 break;
755 CASE_OP_32_64_VEC(xor):
756 CASE_OP_32_64(nand):
757 if (!arg_is_const(op->args[1])
758 && arg_is_const(op->args[2])
759 && arg_info(op->args[2])->val == -1) {
760 i = 1;
761 goto try_not;
762 }
763 break;
764 CASE_OP_32_64(nor):
765 if (!arg_is_const(op->args[1])
766 && arg_is_const(op->args[2])
767 && arg_info(op->args[2])->val == 0) {
768 i = 1;
769 goto try_not;
770 }
771 break;
772 CASE_OP_32_64_VEC(andc):
773 if (!arg_is_const(op->args[2])
774 && arg_is_const(op->args[1])
775 && arg_info(op->args[1])->val == -1) {
776 i = 2;
777 goto try_not;
778 }
779 break;
780 CASE_OP_32_64_VEC(orc):
781 CASE_OP_32_64(eqv):
782 if (!arg_is_const(op->args[2])
783 && arg_is_const(op->args[1])
784 && arg_info(op->args[1])->val == 0) {
785 i = 2;
786 goto try_not;
787 }
788 break;
789 try_not:
790 {
791 TCGOpcode not_op;
792 bool have_not;
793
794 if (def->flags & TCG_OPF_VECTOR) {
795 not_op = INDEX_op_not_vec;
796 have_not = TCG_TARGET_HAS_not_vec;
797 } else if (def->flags & TCG_OPF_64BIT) {
798 not_op = INDEX_op_not_i64;
799 have_not = TCG_TARGET_HAS_not_i64;
800 } else {
801 not_op = INDEX_op_not_i32;
802 have_not = TCG_TARGET_HAS_not_i32;
803 }
804 if (!have_not) {
805 break;
806 }
807 op->opc = not_op;
808 reset_temp(op->args[0]);
809 op->args[1] = op->args[i];
810 continue;
811 }
812 default:
813 break;
814 }
815
816 /* Simplify expression for "op r, a, const => mov r, a" cases */
817 switch (opc) {
818 CASE_OP_32_64_VEC(add):
819 CASE_OP_32_64_VEC(sub):
820 CASE_OP_32_64_VEC(or):
821 CASE_OP_32_64_VEC(xor):
822 CASE_OP_32_64_VEC(andc):
823 CASE_OP_32_64(shl):
824 CASE_OP_32_64(shr):
825 CASE_OP_32_64(sar):
826 CASE_OP_32_64(rotl):
827 CASE_OP_32_64(rotr):
828 if (!arg_is_const(op->args[1])
829 && arg_is_const(op->args[2])
830 && arg_info(op->args[2])->val == 0) {
831 tcg_opt_gen_mov(s, op, op->args[0], op->args[1]);
832 continue;
833 }
834 break;
835 CASE_OP_32_64_VEC(and):
836 CASE_OP_32_64_VEC(orc):
837 CASE_OP_32_64(eqv):
838 if (!arg_is_const(op->args[1])
839 && arg_is_const(op->args[2])
840 && arg_info(op->args[2])->val == -1) {
841 tcg_opt_gen_mov(s, op, op->args[0], op->args[1]);
842 continue;
843 }
844 break;
845 default:
846 break;
847 }
848
849 /* Simplify using known-zero bits. Currently only ops with a single
850 output argument is supported. */
851 mask = -1;
852 affected = -1;
853 switch (opc) {
854 CASE_OP_32_64(ext8s):
855 if ((arg_info(op->args[1])->mask & 0x80) != 0) {
856 break;
857 }
858 CASE_OP_32_64(ext8u):
859 mask = 0xff;
860 goto and_const;
861 CASE_OP_32_64(ext16s):
862 if ((arg_info(op->args[1])->mask & 0x8000) != 0) {
863 break;
864 }
865 CASE_OP_32_64(ext16u):
866 mask = 0xffff;
867 goto and_const;
868 case INDEX_op_ext32s_i64:
869 if ((arg_info(op->args[1])->mask & 0x80000000) != 0) {
870 break;
871 }
872 case INDEX_op_ext32u_i64:
873 mask = 0xffffffffU;
874 goto and_const;
875
876 CASE_OP_32_64(and):
877 mask = arg_info(op->args[2])->mask;
878 if (arg_is_const(op->args[2])) {
879 and_const:
880 affected = arg_info(op->args[1])->mask & ~mask;
881 }
882 mask = arg_info(op->args[1])->mask & mask;
883 break;
884
885 case INDEX_op_ext_i32_i64:
886 if ((arg_info(op->args[1])->mask & 0x80000000) != 0) {
887 break;
888 }
889 case INDEX_op_extu_i32_i64:
890 /* We do not compute affected as it is a size changing op. */
891 mask = (uint32_t)arg_info(op->args[1])->mask;
892 break;
893
894 CASE_OP_32_64(andc):
895 /* Known-zeros does not imply known-ones. Therefore unless
896 op->args[2] is constant, we can't infer anything from it. */
897 if (arg_is_const(op->args[2])) {
898 mask = ~arg_info(op->args[2])->mask;
899 goto and_const;
900 }
901 /* But we certainly know nothing outside args[1] may be set. */
902 mask = arg_info(op->args[1])->mask;
903 break;
904
905 case INDEX_op_sar_i32:
906 if (arg_is_const(op->args[2])) {
907 tmp = arg_info(op->args[2])->val & 31;
908 mask = (int32_t)arg_info(op->args[1])->mask >> tmp;
909 }
910 break;
911 case INDEX_op_sar_i64:
912 if (arg_is_const(op->args[2])) {
913 tmp = arg_info(op->args[2])->val & 63;
914 mask = (int64_t)arg_info(op->args[1])->mask >> tmp;
915 }
916 break;
917
918 case INDEX_op_shr_i32:
919 if (arg_is_const(op->args[2])) {
920 tmp = arg_info(op->args[2])->val & 31;
921 mask = (uint32_t)arg_info(op->args[1])->mask >> tmp;
922 }
923 break;
924 case INDEX_op_shr_i64:
925 if (arg_is_const(op->args[2])) {
926 tmp = arg_info(op->args[2])->val & 63;
927 mask = (uint64_t)arg_info(op->args[1])->mask >> tmp;
928 }
929 break;
930
931 case INDEX_op_extrl_i64_i32:
932 mask = (uint32_t)arg_info(op->args[1])->mask;
933 break;
934 case INDEX_op_extrh_i64_i32:
935 mask = (uint64_t)arg_info(op->args[1])->mask >> 32;
936 break;
937
938 CASE_OP_32_64(shl):
939 if (arg_is_const(op->args[2])) {
940 tmp = arg_info(op->args[2])->val & (TCG_TARGET_REG_BITS - 1);
941 mask = arg_info(op->args[1])->mask << tmp;
942 }
943 break;
944
945 CASE_OP_32_64(neg):
946 /* Set to 1 all bits to the left of the rightmost. */
947 mask = -(arg_info(op->args[1])->mask
948 & -arg_info(op->args[1])->mask);
949 break;
950
951 CASE_OP_32_64(deposit):
952 mask = deposit64(arg_info(op->args[1])->mask,
953 op->args[3], op->args[4],
954 arg_info(op->args[2])->mask);
955 break;
956
957 CASE_OP_32_64(extract):
958 mask = extract64(arg_info(op->args[1])->mask,
959 op->args[2], op->args[3]);
960 if (op->args[2] == 0) {
961 affected = arg_info(op->args[1])->mask & ~mask;
962 }
963 break;
964 CASE_OP_32_64(sextract):
965 mask = sextract64(arg_info(op->args[1])->mask,
966 op->args[2], op->args[3]);
967 if (op->args[2] == 0 && (tcg_target_long)mask >= 0) {
968 affected = arg_info(op->args[1])->mask & ~mask;
969 }
970 break;
971
972 CASE_OP_32_64(or):
973 CASE_OP_32_64(xor):
974 mask = arg_info(op->args[1])->mask | arg_info(op->args[2])->mask;
975 break;
976
977 case INDEX_op_clz_i32:
978 case INDEX_op_ctz_i32:
979 mask = arg_info(op->args[2])->mask | 31;
980 break;
981
982 case INDEX_op_clz_i64:
983 case INDEX_op_ctz_i64:
984 mask = arg_info(op->args[2])->mask | 63;
985 break;
986
987 case INDEX_op_ctpop_i32:
988 mask = 32 | 31;
989 break;
990 case INDEX_op_ctpop_i64:
991 mask = 64 | 63;
992 break;
993
994 CASE_OP_32_64(setcond):
995 case INDEX_op_setcond2_i32:
996 mask = 1;
997 break;
998
999 CASE_OP_32_64(movcond):
1000 mask = arg_info(op->args[3])->mask | arg_info(op->args[4])->mask;
1001 break;
1002
1003 CASE_OP_32_64(ld8u):
1004 mask = 0xff;
1005 break;
1006 CASE_OP_32_64(ld16u):
1007 mask = 0xffff;
1008 break;
1009 case INDEX_op_ld32u_i64:
1010 mask = 0xffffffffu;
1011 break;
1012
1013 CASE_OP_32_64(qemu_ld):
1014 {
1015 TCGMemOpIdx oi = op->args[nb_oargs + nb_iargs];
1016 MemOp mop = get_memop(oi);
1017 if (!(mop & MO_SIGN)) {
1018 mask = (2ULL << ((8 << (mop & MO_SIZE)) - 1)) - 1;
1019 }
1020 }
1021 break;
1022
1023 default:
1024 break;
1025 }
1026
1027 /* 32-bit ops generate 32-bit results. For the result is zero test
1028 below, we can ignore high bits, but for further optimizations we
1029 need to record that the high bits contain garbage. */
1030 partmask = mask;
1031 if (!(def->flags & TCG_OPF_64BIT)) {
1032 mask |= ~(tcg_target_ulong)0xffffffffu;
1033 partmask &= 0xffffffffu;
1034 affected &= 0xffffffffu;
1035 }
1036
1037 if (partmask == 0) {
1038 tcg_debug_assert(nb_oargs == 1);
1039 tcg_opt_gen_movi(s, op, op->args[0], 0);
1040 continue;
1041 }
1042 if (affected == 0) {
1043 tcg_debug_assert(nb_oargs == 1);
1044 tcg_opt_gen_mov(s, op, op->args[0], op->args[1]);
1045 continue;
1046 }
1047
1048 /* Simplify expression for "op r, a, 0 => movi r, 0" cases */
1049 switch (opc) {
1050 CASE_OP_32_64_VEC(and):
1051 CASE_OP_32_64_VEC(mul):
1052 CASE_OP_32_64(muluh):
1053 CASE_OP_32_64(mulsh):
1054 if (arg_is_const(op->args[2])
1055 && arg_info(op->args[2])->val == 0) {
1056 tcg_opt_gen_movi(s, op, op->args[0], 0);
1057 continue;
1058 }
1059 break;
1060 default:
1061 break;
1062 }
1063
1064 /* Simplify expression for "op r, a, a => mov r, a" cases */
1065 switch (opc) {
1066 CASE_OP_32_64_VEC(or):
1067 CASE_OP_32_64_VEC(and):
1068 if (args_are_copies(op->args[1], op->args[2])) {
1069 tcg_opt_gen_mov(s, op, op->args[0], op->args[1]);
1070 continue;
1071 }
1072 break;
1073 default:
1074 break;
1075 }
1076
1077 /* Simplify expression for "op r, a, a => movi r, 0" cases */
1078 switch (opc) {
1079 CASE_OP_32_64_VEC(andc):
1080 CASE_OP_32_64_VEC(sub):
1081 CASE_OP_32_64_VEC(xor):
1082 if (args_are_copies(op->args[1], op->args[2])) {
1083 tcg_opt_gen_movi(s, op, op->args[0], 0);
1084 continue;
1085 }
1086 break;
1087 default:
1088 break;
1089 }
1090
1091 /* Propagate constants through copy operations and do constant
1092 folding. Constants will be substituted to arguments by register
1093 allocator where needed and possible. Also detect copies. */
1094 switch (opc) {
1095 CASE_OP_32_64_VEC(mov):
1096 tcg_opt_gen_mov(s, op, op->args[0], op->args[1]);
1097 break;
1098 CASE_OP_32_64(movi):
1099 case INDEX_op_dupi_vec:
1100 tcg_opt_gen_movi(s, op, op->args[0], op->args[1]);
1101 break;
1102
1103 case INDEX_op_dup_vec:
1104 if (arg_is_const(op->args[1])) {
1105 tmp = arg_info(op->args[1])->val;
1106 tmp = dup_const(TCGOP_VECE(op), tmp);
1107 tcg_opt_gen_movi(s, op, op->args[0], tmp);
1108 break;
1109 }
1110 goto do_default;
1111
1112 CASE_OP_32_64(not):
1113 CASE_OP_32_64(neg):
1114 CASE_OP_32_64(ext8s):
1115 CASE_OP_32_64(ext8u):
1116 CASE_OP_32_64(ext16s):
1117 CASE_OP_32_64(ext16u):
1118 CASE_OP_32_64(ctpop):
1119 CASE_OP_32_64(bswap16):
1120 CASE_OP_32_64(bswap32):
1121 case INDEX_op_bswap64_i64:
1122 case INDEX_op_ext32s_i64:
1123 case INDEX_op_ext32u_i64:
1124 case INDEX_op_ext_i32_i64:
1125 case INDEX_op_extu_i32_i64:
1126 case INDEX_op_extrl_i64_i32:
1127 case INDEX_op_extrh_i64_i32:
1128 if (arg_is_const(op->args[1])) {
1129 tmp = do_constant_folding(opc, arg_info(op->args[1])->val, 0);
1130 tcg_opt_gen_movi(s, op, op->args[0], tmp);
1131 break;
1132 }
1133 goto do_default;
1134
1135 CASE_OP_32_64(add):
1136 CASE_OP_32_64(sub):
1137 CASE_OP_32_64(mul):
1138 CASE_OP_32_64(or):
1139 CASE_OP_32_64(and):
1140 CASE_OP_32_64(xor):
1141 CASE_OP_32_64(shl):
1142 CASE_OP_32_64(shr):
1143 CASE_OP_32_64(sar):
1144 CASE_OP_32_64(rotl):
1145 CASE_OP_32_64(rotr):
1146 CASE_OP_32_64(andc):
1147 CASE_OP_32_64(orc):
1148 CASE_OP_32_64(eqv):
1149 CASE_OP_32_64(nand):
1150 CASE_OP_32_64(nor):
1151 CASE_OP_32_64(muluh):
1152 CASE_OP_32_64(mulsh):
1153 CASE_OP_32_64(div):
1154 CASE_OP_32_64(divu):
1155 CASE_OP_32_64(rem):
1156 CASE_OP_32_64(remu):
1157 if (arg_is_const(op->args[1]) && arg_is_const(op->args[2])) {
1158 tmp = do_constant_folding(opc, arg_info(op->args[1])->val,
1159 arg_info(op->args[2])->val);
1160 tcg_opt_gen_movi(s, op, op->args[0], tmp);
1161 break;
1162 }
1163 goto do_default;
1164
1165 CASE_OP_32_64(clz):
1166 CASE_OP_32_64(ctz):
1167 if (arg_is_const(op->args[1])) {
1168 TCGArg v = arg_info(op->args[1])->val;
1169 if (v != 0) {
1170 tmp = do_constant_folding(opc, v, 0);
1171 tcg_opt_gen_movi(s, op, op->args[0], tmp);
1172 } else {
1173 tcg_opt_gen_mov(s, op, op->args[0], op->args[2]);
1174 }
1175 break;
1176 }
1177 goto do_default;
1178
1179 CASE_OP_32_64(deposit):
1180 if (arg_is_const(op->args[1]) && arg_is_const(op->args[2])) {
1181 tmp = deposit64(arg_info(op->args[1])->val,
1182 op->args[3], op->args[4],
1183 arg_info(op->args[2])->val);
1184 tcg_opt_gen_movi(s, op, op->args[0], tmp);
1185 break;
1186 }
1187 goto do_default;
1188
1189 CASE_OP_32_64(extract):
1190 if (arg_is_const(op->args[1])) {
1191 tmp = extract64(arg_info(op->args[1])->val,
1192 op->args[2], op->args[3]);
1193 tcg_opt_gen_movi(s, op, op->args[0], tmp);
1194 break;
1195 }
1196 goto do_default;
1197
1198 CASE_OP_32_64(sextract):
1199 if (arg_is_const(op->args[1])) {
1200 tmp = sextract64(arg_info(op->args[1])->val,
1201 op->args[2], op->args[3]);
1202 tcg_opt_gen_movi(s, op, op->args[0], tmp);
1203 break;
1204 }
1205 goto do_default;
1206
1207 CASE_OP_32_64(extract2):
1208 if (arg_is_const(op->args[1]) && arg_is_const(op->args[2])) {
1209 TCGArg v1 = arg_info(op->args[1])->val;
1210 TCGArg v2 = arg_info(op->args[2])->val;
1211
1212 if (opc == INDEX_op_extract2_i64) {
1213 tmp = (v1 >> op->args[3]) | (v2 << (64 - op->args[3]));
1214 } else {
1215 tmp = (int32_t)(((uint32_t)v1 >> op->args[3]) |
1216 ((uint32_t)v2 << (32 - op->args[3])));
1217 }
1218 tcg_opt_gen_movi(s, op, op->args[0], tmp);
1219 break;
1220 }
1221 goto do_default;
1222
1223 CASE_OP_32_64(setcond):
1224 tmp = do_constant_folding_cond(opc, op->args[1],
1225 op->args[2], op->args[3]);
1226 if (tmp != 2) {
1227 tcg_opt_gen_movi(s, op, op->args[0], tmp);
1228 break;
1229 }
1230 goto do_default;
1231
1232 CASE_OP_32_64(brcond):
1233 tmp = do_constant_folding_cond(opc, op->args[0],
1234 op->args[1], op->args[2]);
1235 if (tmp != 2) {
1236 if (tmp) {
1237 bitmap_zero(temps_used.l, nb_temps);
1238 op->opc = INDEX_op_br;
1239 op->args[0] = op->args[3];
1240 } else {
1241 tcg_op_remove(s, op);
1242 }
1243 break;
1244 }
1245 goto do_default;
1246
1247 CASE_OP_32_64(movcond):
1248 tmp = do_constant_folding_cond(opc, op->args[1],
1249 op->args[2], op->args[5]);
1250 if (tmp != 2) {
1251 tcg_opt_gen_mov(s, op, op->args[0], op->args[4-tmp]);
1252 break;
1253 }
1254 if (arg_is_const(op->args[3]) && arg_is_const(op->args[4])) {
1255 tcg_target_ulong tv = arg_info(op->args[3])->val;
1256 tcg_target_ulong fv = arg_info(op->args[4])->val;
1257 TCGCond cond = op->args[5];
1258 if (fv == 1 && tv == 0) {
1259 cond = tcg_invert_cond(cond);
1260 } else if (!(tv == 1 && fv == 0)) {
1261 goto do_default;
1262 }
1263 op->args[3] = cond;
1264 op->opc = opc = (opc == INDEX_op_movcond_i32
1265 ? INDEX_op_setcond_i32
1266 : INDEX_op_setcond_i64);
1267 nb_iargs = 2;
1268 }
1269 goto do_default;
1270
1271 case INDEX_op_add2_i32:
1272 case INDEX_op_sub2_i32:
1273 if (arg_is_const(op->args[2]) && arg_is_const(op->args[3])
1274 && arg_is_const(op->args[4]) && arg_is_const(op->args[5])) {
1275 uint32_t al = arg_info(op->args[2])->val;
1276 uint32_t ah = arg_info(op->args[3])->val;
1277 uint32_t bl = arg_info(op->args[4])->val;
1278 uint32_t bh = arg_info(op->args[5])->val;
1279 uint64_t a = ((uint64_t)ah << 32) | al;
1280 uint64_t b = ((uint64_t)bh << 32) | bl;
1281 TCGArg rl, rh;
1282 TCGOp *op2 = tcg_op_insert_before(s, op, INDEX_op_movi_i32);
1283
1284 if (opc == INDEX_op_add2_i32) {
1285 a += b;
1286 } else {
1287 a -= b;
1288 }
1289
1290 rl = op->args[0];
1291 rh = op->args[1];
1292 tcg_opt_gen_movi(s, op, rl, (int32_t)a);
1293 tcg_opt_gen_movi(s, op2, rh, (int32_t)(a >> 32));
1294 break;
1295 }
1296 goto do_default;
1297
1298 case INDEX_op_mulu2_i32:
1299 if (arg_is_const(op->args[2]) && arg_is_const(op->args[3])) {
1300 uint32_t a = arg_info(op->args[2])->val;
1301 uint32_t b = arg_info(op->args[3])->val;
1302 uint64_t r = (uint64_t)a * b;
1303 TCGArg rl, rh;
1304 TCGOp *op2 = tcg_op_insert_before(s, op, INDEX_op_movi_i32);
1305
1306 rl = op->args[0];
1307 rh = op->args[1];
1308 tcg_opt_gen_movi(s, op, rl, (int32_t)r);
1309 tcg_opt_gen_movi(s, op2, rh, (int32_t)(r >> 32));
1310 break;
1311 }
1312 goto do_default;
1313
1314 case INDEX_op_brcond2_i32:
1315 tmp = do_constant_folding_cond2(&op->args[0], &op->args[2],
1316 op->args[4]);
1317 if (tmp != 2) {
1318 if (tmp) {
1319 do_brcond_true:
1320 bitmap_zero(temps_used.l, nb_temps);
1321 op->opc = INDEX_op_br;
1322 op->args[0] = op->args[5];
1323 } else {
1324 do_brcond_false:
1325 tcg_op_remove(s, op);
1326 }
1327 } else if ((op->args[4] == TCG_COND_LT
1328 || op->args[4] == TCG_COND_GE)
1329 && arg_is_const(op->args[2])
1330 && arg_info(op->args[2])->val == 0
1331 && arg_is_const(op->args[3])
1332 && arg_info(op->args[3])->val == 0) {
1333 /* Simplify LT/GE comparisons vs zero to a single compare
1334 vs the high word of the input. */
1335 do_brcond_high:
1336 bitmap_zero(temps_used.l, nb_temps);
1337 op->opc = INDEX_op_brcond_i32;
1338 op->args[0] = op->args[1];
1339 op->args[1] = op->args[3];
1340 op->args[2] = op->args[4];
1341 op->args[3] = op->args[5];
1342 } else if (op->args[4] == TCG_COND_EQ) {
1343 /* Simplify EQ comparisons where one of the pairs
1344 can be simplified. */
1345 tmp = do_constant_folding_cond(INDEX_op_brcond_i32,
1346 op->args[0], op->args[2],
1347 TCG_COND_EQ);
1348 if (tmp == 0) {
1349 goto do_brcond_false;
1350 } else if (tmp == 1) {
1351 goto do_brcond_high;
1352 }
1353 tmp = do_constant_folding_cond(INDEX_op_brcond_i32,
1354 op->args[1], op->args[3],
1355 TCG_COND_EQ);
1356 if (tmp == 0) {
1357 goto do_brcond_false;
1358 } else if (tmp != 1) {
1359 goto do_default;
1360 }
1361 do_brcond_low:
1362 bitmap_zero(temps_used.l, nb_temps);
1363 op->opc = INDEX_op_brcond_i32;
1364 op->args[1] = op->args[2];
1365 op->args[2] = op->args[4];
1366 op->args[3] = op->args[5];
1367 } else if (op->args[4] == TCG_COND_NE) {
1368 /* Simplify NE comparisons where one of the pairs
1369 can be simplified. */
1370 tmp = do_constant_folding_cond(INDEX_op_brcond_i32,
1371 op->args[0], op->args[2],
1372 TCG_COND_NE);
1373 if (tmp == 0) {
1374 goto do_brcond_high;
1375 } else if (tmp == 1) {
1376 goto do_brcond_true;
1377 }
1378 tmp = do_constant_folding_cond(INDEX_op_brcond_i32,
1379 op->args[1], op->args[3],
1380 TCG_COND_NE);
1381 if (tmp == 0) {
1382 goto do_brcond_low;
1383 } else if (tmp == 1) {
1384 goto do_brcond_true;
1385 }
1386 goto do_default;
1387 } else {
1388 goto do_default;
1389 }
1390 break;
1391
1392 case INDEX_op_setcond2_i32:
1393 tmp = do_constant_folding_cond2(&op->args[1], &op->args[3],
1394 op->args[5]);
1395 if (tmp != 2) {
1396 do_setcond_const:
1397 tcg_opt_gen_movi(s, op, op->args[0], tmp);
1398 } else if ((op->args[5] == TCG_COND_LT
1399 || op->args[5] == TCG_COND_GE)
1400 && arg_is_const(op->args[3])
1401 && arg_info(op->args[3])->val == 0
1402 && arg_is_const(op->args[4])
1403 && arg_info(op->args[4])->val == 0) {
1404 /* Simplify LT/GE comparisons vs zero to a single compare
1405 vs the high word of the input. */
1406 do_setcond_high:
1407 reset_temp(op->args[0]);
1408 arg_info(op->args[0])->mask = 1;
1409 op->opc = INDEX_op_setcond_i32;
1410 op->args[1] = op->args[2];
1411 op->args[2] = op->args[4];
1412 op->args[3] = op->args[5];
1413 } else if (op->args[5] == TCG_COND_EQ) {
1414 /* Simplify EQ comparisons where one of the pairs
1415 can be simplified. */
1416 tmp = do_constant_folding_cond(INDEX_op_setcond_i32,
1417 op->args[1], op->args[3],
1418 TCG_COND_EQ);
1419 if (tmp == 0) {
1420 goto do_setcond_const;
1421 } else if (tmp == 1) {
1422 goto do_setcond_high;
1423 }
1424 tmp = do_constant_folding_cond(INDEX_op_setcond_i32,
1425 op->args[2], op->args[4],
1426 TCG_COND_EQ);
1427 if (tmp == 0) {
1428 goto do_setcond_high;
1429 } else if (tmp != 1) {
1430 goto do_default;
1431 }
1432 do_setcond_low:
1433 reset_temp(op->args[0]);
1434 arg_info(op->args[0])->mask = 1;
1435 op->opc = INDEX_op_setcond_i32;
1436 op->args[2] = op->args[3];
1437 op->args[3] = op->args[5];
1438 } else if (op->args[5] == TCG_COND_NE) {
1439 /* Simplify NE comparisons where one of the pairs
1440 can be simplified. */
1441 tmp = do_constant_folding_cond(INDEX_op_setcond_i32,
1442 op->args[1], op->args[3],
1443 TCG_COND_NE);
1444 if (tmp == 0) {
1445 goto do_setcond_high;
1446 } else if (tmp == 1) {
1447 goto do_setcond_const;
1448 }
1449 tmp = do_constant_folding_cond(INDEX_op_setcond_i32,
1450 op->args[2], op->args[4],
1451 TCG_COND_NE);
1452 if (tmp == 0) {
1453 goto do_setcond_low;
1454 } else if (tmp == 1) {
1455 goto do_setcond_const;
1456 }
1457 goto do_default;
1458 } else {
1459 goto do_default;
1460 }
1461 break;
1462
1463 case INDEX_op_call:
1464 if (!(op->args[nb_oargs + nb_iargs + 1]
1465 & (TCG_CALL_NO_READ_GLOBALS | TCG_CALL_NO_WRITE_GLOBALS))) {
1466 for (i = 0; i < nb_globals; i++) {
1467 if (test_bit(i, temps_used.l)) {
1468 reset_ts(&s->temps[i]);
1469 }
1470 }
1471 }
1472 goto do_reset_output;
1473
1474 default:
1475 do_default:
1476 /* Default case: we know nothing about operation (or were unable
1477 to compute the operation result) so no propagation is done.
1478 We trash everything if the operation is the end of a basic
1479 block, otherwise we only trash the output args. "mask" is
1480 the non-zero bits mask for the first output arg. */
1481 if (def->flags & TCG_OPF_BB_END) {
1482 bitmap_zero(temps_used.l, nb_temps);
1483 } else {
1484 do_reset_output:
1485 for (i = 0; i < nb_oargs; i++) {
1486 reset_temp(op->args[i]);
1487 /* Save the corresponding known-zero bits mask for the
1488 first output argument (only one supported so far). */
1489 if (i == 0) {
1490 arg_info(op->args[i])->mask = mask;
1491 }
1492 }
1493 }
1494 break;
1495 }
1496
1497 /* Eliminate duplicate and redundant fence instructions. */
1498 if (prev_mb) {
1499 switch (opc) {
1500 case INDEX_op_mb:
1501 /* Merge two barriers of the same type into one,
1502 * or a weaker barrier into a stronger one,
1503 * or two weaker barriers into a stronger one.
1504 * mb X; mb Y => mb X|Y
1505 * mb; strl => mb; st
1506 * ldaq; mb => ld; mb
1507 * ldaq; strl => ld; mb; st
1508 * Other combinations are also merged into a strong
1509 * barrier. This is stricter than specified but for
1510 * the purposes of TCG is better than not optimizing.
1511 */
1512 prev_mb->args[0] |= op->args[0];
1513 tcg_op_remove(s, op);
1514 break;
1515
1516 default:
1517 /* Opcodes that end the block stop the optimization. */
1518 if ((def->flags & TCG_OPF_BB_END) == 0) {
1519 break;
1520 }
1521 /* fallthru */
1522 case INDEX_op_qemu_ld_i32:
1523 case INDEX_op_qemu_ld_i64:
1524 case INDEX_op_qemu_st_i32:
1525 case INDEX_op_qemu_st_i64:
1526 case INDEX_op_call:
1527 /* Opcodes that touch guest memory stop the optimization. */
1528 prev_mb = NULL;
1529 break;
1530 }
1531 } else if (opc == INDEX_op_mb) {
1532 prev_mb = op;
1533 }
1534 }
1535 }