]> git.proxmox.com Git - qemu.git/blame - tcg/optimize.c
projects / qemu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
acpi-build: fix support for glib < 2.22
[qemu.git] / tcg / optimize.c
CommitLineData
8f2e8c07
KB		 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 "config.h"
27
28#include <stdlib.h>
29#include <stdio.h>
30
31#include "qemu-common.h"
32#include "tcg-op.h"
33
8f2e8c07
KB		 34#define CASE_OP_32_64(x) \
35 glue(glue(case INDEX_op_, x), _i32): \
36 glue(glue(case INDEX_op_, x), _i64)
8f2e8c07 37
22613af4
KB		 38typedef enum {
39 TCG_TEMP_UNDEF = 0,
40 TCG_TEMP_CONST,
41 TCG_TEMP_COPY,
22613af4
KB		 42} tcg_temp_state;
43
44struct tcg_temp_info {
45 tcg_temp_state state;
46 uint16_t prev_copy;
47 uint16_t next_copy;
48 tcg_target_ulong val;
3a9d8b17 49 tcg_target_ulong mask;
22613af4
KB		 50};
51
52static struct tcg_temp_info temps[TCG_MAX_TEMPS];
53
e590d4e6
AJ		 54/* Reset TEMP's state to TCG_TEMP_UNDEF. If TEMP only had one copy, remove
55 the copy flag from the left temp. */
56static void reset_temp(TCGArg temp)
22613af4 57{
e590d4e6
AJ		 58 if (temps[temp].state == TCG_TEMP_COPY) {
59 if (temps[temp].prev_copy == temps[temp].next_copy) {
60 temps[temps[temp].next_copy].state = TCG_TEMP_UNDEF;
61 } else {
62 temps[temps[temp].next_copy].prev_copy = temps[temp].prev_copy;
63 temps[temps[temp].prev_copy].next_copy = temps[temp].next_copy;
22613af4 64 }
22613af4 65 }
48b56ce1 66 temps[temp].state = TCG_TEMP_UNDEF;
3a9d8b17 67 temps[temp].mask = -1;
22613af4
KB		 68}
69
d193a14a
PB		 70/* Reset all temporaries, given that there are NB_TEMPS of them. */
71static void reset_all_temps(int nb_temps)
72{
73 int i;
74 for (i = 0; i < nb_temps; i++) {
75 temps[i].state = TCG_TEMP_UNDEF;
3a9d8b17 76 temps[i].mask = -1;
d193a14a
PB		 77 }
78}
79
fe0de7aa 80static int op_bits(TCGOpcode op)
22613af4 81{
8399ad59
RH		 82 const TCGOpDef *def = &tcg_op_defs[op];
83 return def->flags & TCG_OPF_64BIT ? 64 : 32;
22613af4
KB		 84}
85
fe0de7aa 86static TCGOpcode op_to_movi(TCGOpcode op)
22613af4
KB		 87{
88 switch (op_bits(op)) {
89 case 32:
90 return INDEX_op_movi_i32;
22613af4
KB		 91 case 64:
92 return INDEX_op_movi_i64;
22613af4
KB		 93 default:
94 fprintf(stderr, "op_to_movi: unexpected return value of "
95 "function op_bits.\n");
96 tcg_abort();
97 }
98}
99
e590d4e6
AJ		 100static TCGArg find_better_copy(TCGContext *s, TCGArg temp)
101{
102 TCGArg i;
103
104 /* If this is already a global, we can't do better. */
105 if (temp < s->nb_globals) {
106 return temp;
107 }
108
109 /* Search for a global first. */
110 for (i = temps[temp].next_copy ; i != temp ; i = temps[i].next_copy) {
111 if (i < s->nb_globals) {
112 return i;
113 }
114 }
115
116 /* If it is a temp, search for a temp local. */
117 if (!s->temps[temp].temp_local) {
118 for (i = temps[temp].next_copy ; i != temp ; i = temps[i].next_copy) {
119 if (s->temps[i].temp_local) {
120 return i;
121 }
122 }
123 }
124
125 /* Failure to find a better representation, return the same temp. */
126 return temp;
127}
128
129static bool temps_are_copies(TCGArg arg1, TCGArg arg2)
130{
131 TCGArg i;
132
133 if (arg1 == arg2) {
134 return true;
135 }
136
137 if (temps[arg1].state != TCG_TEMP_COPY
138 || temps[arg2].state != TCG_TEMP_COPY) {
139 return false;
140 }
141
142 for (i = temps[arg1].next_copy ; i != arg1 ; i = temps[i].next_copy) {
143 if (i == arg2) {
144 return true;
145 }
146 }
147
148 return false;
149}
150
b80bb016
AJ		 151static void tcg_opt_gen_mov(TCGContext *s, TCGArg *gen_args,
152 TCGArg dst, TCGArg src)
22613af4 153{
3a9d8b17
PB		 154 reset_temp(dst);
155 temps[dst].mask = temps[src].mask;
156 assert(temps[src].state != TCG_TEMP_CONST);
157
158 if (s->temps[src].type == s->temps[dst].type) {
159 if (temps[src].state != TCG_TEMP_COPY) {
160 temps[src].state = TCG_TEMP_COPY;
161 temps[src].next_copy = src;
162 temps[src].prev_copy = src;
22613af4 163 }
3a9d8b17
PB		 164 temps[dst].state = TCG_TEMP_COPY;
165 temps[dst].next_copy = temps[src].next_copy;
166 temps[dst].prev_copy = src;
167 temps[temps[dst].next_copy].prev_copy = dst;
168 temps[src].next_copy = dst;
169 }
e590d4e6 170
3a9d8b17
PB		 171 gen_args[0] = dst;
172 gen_args[1] = src;
22613af4
KB		 173}
174
e590d4e6 175static void tcg_opt_gen_movi(TCGArg *gen_args, TCGArg dst, TCGArg val)
22613af4 176{
3a9d8b17
PB		 177 reset_temp(dst);
178 temps[dst].state = TCG_TEMP_CONST;
179 temps[dst].val = val;
180 temps[dst].mask = val;
181 gen_args[0] = dst;
182 gen_args[1] = val;
22613af4
KB		 183}
184
fe0de7aa 185static TCGOpcode op_to_mov(TCGOpcode op)
53108fb5
KB		 186{
187 switch (op_bits(op)) {
188 case 32:
189 return INDEX_op_mov_i32;
53108fb5
KB		 190 case 64:
191 return INDEX_op_mov_i64;
53108fb5
KB		 192 default:
193 fprintf(stderr, "op_to_mov: unexpected return value of "
194 "function op_bits.\n");
195 tcg_abort();
196 }
197}
198
fe0de7aa 199static TCGArg do_constant_folding_2(TCGOpcode op, TCGArg x, TCGArg y)
53108fb5 200{
03271524
RH		 201 uint64_t l64, h64;
202
53108fb5
KB		 203 switch (op) {
204 CASE_OP_32_64(add):
205 return x + y;
206
207 CASE_OP_32_64(sub):
208 return x - y;
209
210 CASE_OP_32_64(mul):
211 return x * y;
212
9a81090b
KB		 213 CASE_OP_32_64(and):
214 return x & y;
215
216 CASE_OP_32_64(or):
217 return x | y;
218
219 CASE_OP_32_64(xor):
220 return x ^ y;
221
55c0975c
KB		 222 case INDEX_op_shl_i32:
223 return (uint32_t)x << (uint32_t)y;
224
55c0975c
KB		 225 case INDEX_op_shl_i64:
226 return (uint64_t)x << (uint64_t)y;
55c0975c
KB		 227
228 case INDEX_op_shr_i32:
229 return (uint32_t)x >> (uint32_t)y;
230
55c0975c
KB		 231 case INDEX_op_shr_i64:
232 return (uint64_t)x >> (uint64_t)y;
55c0975c
KB		 233
234 case INDEX_op_sar_i32:
235 return (int32_t)x >> (int32_t)y;
236
55c0975c
KB		 237 case INDEX_op_sar_i64:
238 return (int64_t)x >> (int64_t)y;
55c0975c
KB		 239
240 case INDEX_op_rotr_i32:
3df2b8fd 241 return ror32(x, y);
55c0975c 242
55c0975c 243 case INDEX_op_rotr_i64:
3df2b8fd 244 return ror64(x, y);
55c0975c
KB		 245
246 case INDEX_op_rotl_i32:
3df2b8fd 247 return rol32(x, y);
55c0975c 248
55c0975c 249 case INDEX_op_rotl_i64:
3df2b8fd 250 return rol64(x, y);
25c4d9cc
RH		 251
252 CASE_OP_32_64(not):
a640f031 253 return ~x;
25c4d9cc 254
cb25c80a
RH		 255 CASE_OP_32_64(neg):
256 return -x;
257
258 CASE_OP_32_64(andc):
259 return x & ~y;
260
261 CASE_OP_32_64(orc):
262 return x | ~y;
263
264 CASE_OP_32_64(eqv):
265 return ~(x ^ y);
266
267 CASE_OP_32_64(nand):
268 return ~(x & y);
269
270 CASE_OP_32_64(nor):
271 return ~(x | y);
272
25c4d9cc 273 CASE_OP_32_64(ext8s):
a640f031 274 return (int8_t)x;
25c4d9cc
RH		 275
276 CASE_OP_32_64(ext16s):
a640f031 277 return (int16_t)x;
25c4d9cc
RH		 278
279 CASE_OP_32_64(ext8u):
a640f031 280 return (uint8_t)x;
25c4d9cc
RH		 281
282 CASE_OP_32_64(ext16u):
a640f031
KB		 283 return (uint16_t)x;
284
a640f031
KB		 285 case INDEX_op_ext32s_i64:
286 return (int32_t)x;
287
288 case INDEX_op_ext32u_i64:
289 return (uint32_t)x;
a640f031 290
03271524
RH		 291 case INDEX_op_muluh_i32:
292 return ((uint64_t)(uint32_t)x * (uint32_t)y) >> 32;
293 case INDEX_op_mulsh_i32:
294 return ((int64_t)(int32_t)x * (int32_t)y) >> 32;
295
296 case INDEX_op_muluh_i64:
297 mulu64(&l64, &h64, x, y);
298 return h64;
299 case INDEX_op_mulsh_i64:
300 muls64(&l64, &h64, x, y);
301 return h64;
302
01547f7f
RH		 303 case INDEX_op_div_i32:
304 /* Avoid crashing on divide by zero, otherwise undefined. */
305 return (int32_t)x / ((int32_t)y ? : 1);
306 case INDEX_op_divu_i32:
307 return (uint32_t)x / ((uint32_t)y ? : 1);
308 case INDEX_op_div_i64:
309 return (int64_t)x / ((int64_t)y ? : 1);
310 case INDEX_op_divu_i64:
311 return (uint64_t)x / ((uint64_t)y ? : 1);
312
313 case INDEX_op_rem_i32:
314 return (int32_t)x % ((int32_t)y ? : 1);
315 case INDEX_op_remu_i32:
316 return (uint32_t)x % ((uint32_t)y ? : 1);
317 case INDEX_op_rem_i64:
318 return (int64_t)x % ((int64_t)y ? : 1);
319 case INDEX_op_remu_i64:
320 return (uint64_t)x % ((uint64_t)y ? : 1);
321
53108fb5
KB		 322 default:
323 fprintf(stderr,
324 "Unrecognized operation %d in do_constant_folding.\n", op);
325 tcg_abort();
326 }
327}
328
fe0de7aa 329static TCGArg do_constant_folding(TCGOpcode op, TCGArg x, TCGArg y)
53108fb5
KB		 330{
331 TCGArg res = do_constant_folding_2(op, x, y);
53108fb5
KB		 332 if (op_bits(op) == 32) {
333 res &= 0xffffffff;
334 }
53108fb5
KB		 335 return res;
336}
337
9519da7e
RH		 338static bool do_constant_folding_cond_32(uint32_t x, uint32_t y, TCGCond c)
339{
340 switch (c) {
341 case TCG_COND_EQ:
342 return x == y;
343 case TCG_COND_NE:
344 return x != y;
345 case TCG_COND_LT:
346 return (int32_t)x < (int32_t)y;
347 case TCG_COND_GE:
348 return (int32_t)x >= (int32_t)y;
349 case TCG_COND_LE:
350 return (int32_t)x <= (int32_t)y;
351 case TCG_COND_GT:
352 return (int32_t)x > (int32_t)y;
353 case TCG_COND_LTU:
354 return x < y;
355 case TCG_COND_GEU:
356 return x >= y;
357 case TCG_COND_LEU:
358 return x <= y;
359 case TCG_COND_GTU:
360 return x > y;
361 default:
362 tcg_abort();
363 }
364}
365
366static bool do_constant_folding_cond_64(uint64_t x, uint64_t y, TCGCond c)
367{
368 switch (c) {
369 case TCG_COND_EQ:
370 return x == y;
371 case TCG_COND_NE:
372 return x != y;
373 case TCG_COND_LT:
374 return (int64_t)x < (int64_t)y;
375 case TCG_COND_GE:
376 return (int64_t)x >= (int64_t)y;
377 case TCG_COND_LE:
378 return (int64_t)x <= (int64_t)y;
379 case TCG_COND_GT:
380 return (int64_t)x > (int64_t)y;
381 case TCG_COND_LTU:
382 return x < y;
383 case TCG_COND_GEU:
384 return x >= y;
385 case TCG_COND_LEU:
386 return x <= y;
387 case TCG_COND_GTU:
388 return x > y;
389 default:
390 tcg_abort();
391 }
392}
393
394static bool do_constant_folding_cond_eq(TCGCond c)
395{
396 switch (c) {
397 case TCG_COND_GT:
398 case TCG_COND_LTU:
399 case TCG_COND_LT:
400 case TCG_COND_GTU:
401 case TCG_COND_NE:
402 return 0;
403 case TCG_COND_GE:
404 case TCG_COND_GEU:
405 case TCG_COND_LE:
406 case TCG_COND_LEU:
407 case TCG_COND_EQ:
408 return 1;
409 default:
410 tcg_abort();
411 }
412}
413
b336ceb6
AJ		 414/* Return 2 if the condition can't be simplified, and the result
415 of the condition (0 or 1) if it can */
f8dd19e5
AJ		 416static TCGArg do_constant_folding_cond(TCGOpcode op, TCGArg x,
417 TCGArg y, TCGCond c)
418{
b336ceb6
AJ		 419 if (temps[x].state == TCG_TEMP_CONST && temps[y].state == TCG_TEMP_CONST) {
420 switch (op_bits(op)) {
421 case 32:
9519da7e 422 return do_constant_folding_cond_32(temps[x].val, temps[y].val, c);
b336ceb6 423 case 64:
9519da7e 424 return do_constant_folding_cond_64(temps[x].val, temps[y].val, c);
0aed257f 425 default:
9519da7e 426 tcg_abort();
b336ceb6 427 }
9519da7e
RH		 428 } else if (temps_are_copies(x, y)) {
429 return do_constant_folding_cond_eq(c);
b336ceb6
AJ		 430 } else if (temps[y].state == TCG_TEMP_CONST && temps[y].val == 0) {
431 switch (c) {
f8dd19e5 432 case TCG_COND_LTU:
b336ceb6 433 return 0;
f8dd19e5 434 case TCG_COND_GEU:
b336ceb6
AJ		 435 return 1;
436 default:
437 return 2;
f8dd19e5 438 }
b336ceb6
AJ		 439 } else {
440 return 2;
f8dd19e5 441 }
f8dd19e5
AJ		 442}
443
6c4382f8
RH		 444/* Return 2 if the condition can't be simplified, and the result
445 of the condition (0 or 1) if it can */
446static TCGArg do_constant_folding_cond2(TCGArg *p1, TCGArg *p2, TCGCond c)
447{
448 TCGArg al = p1[0], ah = p1[1];
449 TCGArg bl = p2[0], bh = p2[1];
450
451 if (temps[bl].state == TCG_TEMP_CONST
452 && temps[bh].state == TCG_TEMP_CONST) {
453 uint64_t b = ((uint64_t)temps[bh].val << 32) | (uint32_t)temps[bl].val;
454
455 if (temps[al].state == TCG_TEMP_CONST
456 && temps[ah].state == TCG_TEMP_CONST) {
457 uint64_t a;
458 a = ((uint64_t)temps[ah].val << 32) | (uint32_t)temps[al].val;
459 return do_constant_folding_cond_64(a, b, c);
460 }
461 if (b == 0) {
462 switch (c) {
463 case TCG_COND_LTU:
464 return 0;
465 case TCG_COND_GEU:
466 return 1;
467 default:
468 break;
469 }
470 }
471 }
472 if (temps_are_copies(al, bl) && temps_are_copies(ah, bh)) {
473 return do_constant_folding_cond_eq(c);
474 }
475 return 2;
476}
477
24c9ae4e
RH		 478static bool swap_commutative(TCGArg dest, TCGArg *p1, TCGArg *p2)
479{
480 TCGArg a1 = *p1, a2 = *p2;
481 int sum = 0;
482 sum += temps[a1].state == TCG_TEMP_CONST;
483 sum -= temps[a2].state == TCG_TEMP_CONST;
484
485 /* Prefer the constant in second argument, and then the form
486 op a, a, b, which is better handled on non-RISC hosts. */
487 if (sum > 0 || (sum == 0 && dest == a2)) {
488 *p1 = a2;
489 *p2 = a1;
490 return true;
491 }
492 return false;
493}
494
0bfcb865
RH		 495static bool swap_commutative2(TCGArg *p1, TCGArg *p2)
496{
497 int sum = 0;
498 sum += temps[p1[0]].state == TCG_TEMP_CONST;
499 sum += temps[p1[1]].state == TCG_TEMP_CONST;
500 sum -= temps[p2[0]].state == TCG_TEMP_CONST;
501 sum -= temps[p2[1]].state == TCG_TEMP_CONST;
502 if (sum > 0) {
503 TCGArg t;
504 t = p1[0], p1[0] = p2[0], p2[0] = t;
505 t = p1[1], p1[1] = p2[1], p2[1] = t;
506 return true;
507 }
508 return false;
509}
510
22613af4 511/* Propagate constants and copies, fold constant expressions. */
8f2e8c07
KB		 512static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
513 TCGArg *args, TCGOpDef *tcg_op_defs)
514{
fe0de7aa 515 int i, nb_ops, op_index, nb_temps, nb_globals, nb_call_args;
633f6502 516 tcg_target_ulong mask, affected;
fe0de7aa 517 TCGOpcode op;
8f2e8c07
KB		 518 const TCGOpDef *def;
519 TCGArg *gen_args;
53108fb5 520 TCGArg tmp;
5d8f5363 521
22613af4
KB		 522 /* Array VALS has an element for each temp.
523 If this temp holds a constant then its value is kept in VALS' element.
e590d4e6
AJ		 524 If this temp is a copy of other ones then the other copies are
525 available through the doubly linked circular list. */
8f2e8c07
KB		 526
527 nb_temps = s->nb_temps;
528 nb_globals = s->nb_globals;
d193a14a 529 reset_all_temps(nb_temps);
8f2e8c07 530
92414b31 531 nb_ops = tcg_opc_ptr - s->gen_opc_buf;
8f2e8c07
KB		 532 gen_args = args;
533 for (op_index = 0; op_index < nb_ops; op_index++) {
92414b31 534 op = s->gen_opc_buf[op_index];
8f2e8c07 535 def = &tcg_op_defs[op];
22613af4 536 /* Do copy propagation */
1ff8c541
AJ		 537 if (op == INDEX_op_call) {
538 int nb_oargs = args[0] >> 16;
539 int nb_iargs = args[0] & 0xffff;
540 for (i = nb_oargs + 1; i < nb_oargs + nb_iargs + 1; i++) {
541 if (temps[args[i]].state == TCG_TEMP_COPY) {
542 args[i] = find_better_copy(s, args[i]);
543 }
544 }
545 } else {
22613af4
KB		 546 for (i = def->nb_oargs; i < def->nb_oargs + def->nb_iargs; i++) {
547 if (temps[args[i]].state == TCG_TEMP_COPY) {
e590d4e6 548 args[i] = find_better_copy(s, args[i]);
22613af4
KB		 549 }
550 }
551 }
552
53108fb5
KB		 553 /* For commutative operations make constant second argument */
554 switch (op) {
555 CASE_OP_32_64(add):
556 CASE_OP_32_64(mul):
9a81090b
KB		 557 CASE_OP_32_64(and):
558 CASE_OP_32_64(or):
559 CASE_OP_32_64(xor):
cb25c80a
RH		 560 CASE_OP_32_64(eqv):
561 CASE_OP_32_64(nand):
562 CASE_OP_32_64(nor):
03271524
RH		 563 CASE_OP_32_64(muluh):
564 CASE_OP_32_64(mulsh):
24c9ae4e 565 swap_commutative(args[0], &args[1], &args[2]);
53108fb5 566 break;
65a7cce1 567 CASE_OP_32_64(brcond):
24c9ae4e 568 if (swap_commutative(-1, &args[0], &args[1])) {
65a7cce1
AJ		 569 args[2] = tcg_swap_cond(args[2]);
570 }
571 break;
572 CASE_OP_32_64(setcond):
24c9ae4e 573 if (swap_commutative(args[0], &args[1], &args[2])) {
65a7cce1
AJ		 574 args[3] = tcg_swap_cond(args[3]);
575 }
576 break;
fa01a208 577 CASE_OP_32_64(movcond):
24c9ae4e
RH		 578 if (swap_commutative(-1, &args[1], &args[2])) {
579 args[5] = tcg_swap_cond(args[5]);
5d8f5363
RH		 580 }
581 /* For movcond, we canonicalize the "false" input reg to match
582 the destination reg so that the tcg backend can implement
583 a "move if true" operation. */
24c9ae4e
RH		 584 if (swap_commutative(args[0], &args[4], &args[3])) {
585 args[5] = tcg_invert_cond(args[5]);
fa01a208 586 }
1e484e61 587 break;
d7156f7c 588 CASE_OP_32_64(add2):
1e484e61
RH		 589 swap_commutative(args[0], &args[2], &args[4]);
590 swap_commutative(args[1], &args[3], &args[5]);
591 break;
d7156f7c 592 CASE_OP_32_64(mulu2):
4d3203fd 593 CASE_OP_32_64(muls2):
1414968a
RH		 594 swap_commutative(args[0], &args[2], &args[3]);
595 break;
0bfcb865
RH		 596 case INDEX_op_brcond2_i32:
597 if (swap_commutative2(&args[0], &args[2])) {
598 args[4] = tcg_swap_cond(args[4]);
599 }
600 break;
601 case INDEX_op_setcond2_i32:
602 if (swap_commutative2(&args[1], &args[3])) {
603 args[5] = tcg_swap_cond(args[5]);
604 }
605 break;
53108fb5
KB		 606 default:
607 break;
608 }
609
2d497542
RH		 610 /* Simplify expressions for "shift/rot r, 0, a => movi r, 0",
611 and "sub r, 0, a => neg r, a" case. */
01ee5282
AJ		 612 switch (op) {
613 CASE_OP_32_64(shl):
614 CASE_OP_32_64(shr):
615 CASE_OP_32_64(sar):
616 CASE_OP_32_64(rotl):
617 CASE_OP_32_64(rotr):
618 if (temps[args[1]].state == TCG_TEMP_CONST
619 && temps[args[1]].val == 0) {
92414b31 620 s->gen_opc_buf[op_index] = op_to_movi(op);
e590d4e6 621 tcg_opt_gen_movi(gen_args, args[0], 0);
01ee5282
AJ		 622 args += 3;
623 gen_args += 2;
624 continue;
625 }
626 break;
2d497542
RH		 627 CASE_OP_32_64(sub):
628 {
629 TCGOpcode neg_op;
630 bool have_neg;
631
632 if (temps[args[2]].state == TCG_TEMP_CONST) {
633 /* Proceed with possible constant folding. */
634 break;
635 }
636 if (op == INDEX_op_sub_i32) {
637 neg_op = INDEX_op_neg_i32;
638 have_neg = TCG_TARGET_HAS_neg_i32;
639 } else {
640 neg_op = INDEX_op_neg_i64;
641 have_neg = TCG_TARGET_HAS_neg_i64;
642 }
643 if (!have_neg) {
644 break;
645 }
646 if (temps[args[1]].state == TCG_TEMP_CONST
647 && temps[args[1]].val == 0) {
648 s->gen_opc_buf[op_index] = neg_op;
649 reset_temp(args[0]);
650 gen_args[0] = args[0];
651 gen_args[1] = args[2];
652 args += 3;
653 gen_args += 2;
654 continue;
655 }
656 }
657 break;
01ee5282
AJ		 658 default:
659 break;
660 }
661
56e49438 662 /* Simplify expression for "op r, a, 0 => mov r, a" cases */
53108fb5
KB		 663 switch (op) {
664 CASE_OP_32_64(add):
665 CASE_OP_32_64(sub):
55c0975c
KB		 666 CASE_OP_32_64(shl):
667 CASE_OP_32_64(shr):
668 CASE_OP_32_64(sar):
25c4d9cc
RH		 669 CASE_OP_32_64(rotl):
670 CASE_OP_32_64(rotr):
38ee188b
AJ		 671 CASE_OP_32_64(or):
672 CASE_OP_32_64(xor):
53108fb5
KB		 673 if (temps[args[1]].state == TCG_TEMP_CONST) {
674 /* Proceed with possible constant folding. */
675 break;
676 }
677 if (temps[args[2]].state == TCG_TEMP_CONST
678 && temps[args[2]].val == 0) {
e590d4e6 679 if (temps_are_copies(args[0], args[1])) {
92414b31 680 s->gen_opc_buf[op_index] = INDEX_op_nop;
53108fb5 681 } else {
92414b31 682 s->gen_opc_buf[op_index] = op_to_mov(op);
b80bb016 683 tcg_opt_gen_mov(s, gen_args, args[0], args[1]);
53108fb5 684 gen_args += 2;
53108fb5 685 }
fedc0da2 686 args += 3;
53108fb5
KB		 687 continue;
688 }
689 break;
56e49438
AJ		 690 default:
691 break;
692 }
693
3a9d8b17
PB		 694 /* Simplify using known-zero bits */
695 mask = -1;
633f6502 696 affected = -1;
3a9d8b17
PB		 697 switch (op) {
698 CASE_OP_32_64(ext8s):
699 if ((temps[args[1]].mask & 0x80) != 0) {
700 break;
701 }
702 CASE_OP_32_64(ext8u):
703 mask = 0xff;
704 goto and_const;
705 CASE_OP_32_64(ext16s):
706 if ((temps[args[1]].mask & 0x8000) != 0) {
707 break;
708 }
709 CASE_OP_32_64(ext16u):
710 mask = 0xffff;
711 goto and_const;
712 case INDEX_op_ext32s_i64:
713 if ((temps[args[1]].mask & 0x80000000) != 0) {
714 break;
715 }
716 case INDEX_op_ext32u_i64:
717 mask = 0xffffffffU;
718 goto and_const;
719
720 CASE_OP_32_64(and):
721 mask = temps[args[2]].mask;
722 if (temps[args[2]].state == TCG_TEMP_CONST) {
723 and_const:
633f6502 724 affected = temps[args[1]].mask & ~mask;
3a9d8b17
PB		 725 }
726 mask = temps[args[1]].mask & mask;
727 break;
728
729 CASE_OP_32_64(sar):
730 if (temps[args[2]].state == TCG_TEMP_CONST) {
731 mask = ((tcg_target_long)temps[args[1]].mask
732 >> temps[args[2]].val);
733 }
734 break;
735
736 CASE_OP_32_64(shr):
737 if (temps[args[2]].state == TCG_TEMP_CONST) {
738 mask = temps[args[1]].mask >> temps[args[2]].val;
739 }
740 break;
741
742 CASE_OP_32_64(shl):
743 if (temps[args[2]].state == TCG_TEMP_CONST) {
744 mask = temps[args[1]].mask << temps[args[2]].val;
745 }
746 break;
747
748 CASE_OP_32_64(neg):
749 /* Set to 1 all bits to the left of the rightmost. */
750 mask = -(temps[args[1]].mask & -temps[args[1]].mask);
751 break;
752
753 CASE_OP_32_64(deposit):
754 tmp = ((1ull << args[4]) - 1);
755 mask = ((temps[args[1]].mask & ~(tmp << args[3]))
756 | ((temps[args[2]].mask & tmp) << args[3]));
757 break;
758
759 CASE_OP_32_64(or):
760 CASE_OP_32_64(xor):
761 mask = temps[args[1]].mask | temps[args[2]].mask;
762 break;
763
764 CASE_OP_32_64(setcond):
765 mask = 1;
766 break;
767
768 CASE_OP_32_64(movcond):
769 mask = temps[args[3]].mask | temps[args[4]].mask;
770 break;
771
772 default:
773 break;
774 }
775
633f6502
PB		 776 if (mask == 0) {
777 assert(def->nb_oargs == 1);
778 s->gen_opc_buf[op_index] = op_to_movi(op);
779 tcg_opt_gen_movi(gen_args, args[0], 0);
780 args += def->nb_oargs + def->nb_iargs + def->nb_cargs;
781 gen_args += 2;
782 continue;
783 }
784 if (affected == 0) {
785 assert(def->nb_oargs == 1);
786 if (temps_are_copies(args[0], args[1])) {
787 s->gen_opc_buf[op_index] = INDEX_op_nop;
788 } else if (temps[args[1]].state != TCG_TEMP_CONST) {
789 s->gen_opc_buf[op_index] = op_to_mov(op);
790 tcg_opt_gen_mov(s, gen_args, args[0], args[1]);
791 gen_args += 2;
792 } else {
793 s->gen_opc_buf[op_index] = op_to_movi(op);
794 tcg_opt_gen_movi(gen_args, args[0], temps[args[1]].val);
795 gen_args += 2;
796 }
797 args += def->nb_iargs + 1;
798 continue;
799 }
800
56e49438
AJ		 801 /* Simplify expression for "op r, a, 0 => movi r, 0" cases */
802 switch (op) {
61251c0c 803 CASE_OP_32_64(and):
53108fb5 804 CASE_OP_32_64(mul):
03271524
RH		 805 CASE_OP_32_64(muluh):
806 CASE_OP_32_64(mulsh):
53108fb5
KB		 807 if ((temps[args[2]].state == TCG_TEMP_CONST
808 && temps[args[2]].val == 0)) {
92414b31 809 s->gen_opc_buf[op_index] = op_to_movi(op);
e590d4e6 810 tcg_opt_gen_movi(gen_args, args[0], 0);
53108fb5
KB		 811 args += 3;
812 gen_args += 2;
813 continue;
814 }
815 break;
56e49438
AJ		 816 default:
817 break;
818 }
819
820 /* Simplify expression for "op r, a, a => mov r, a" cases */
821 switch (op) {
9a81090b
KB		 822 CASE_OP_32_64(or):
823 CASE_OP_32_64(and):
0aba1c73 824 if (temps_are_copies(args[1], args[2])) {
e590d4e6 825 if (temps_are_copies(args[0], args[1])) {
92414b31 826 s->gen_opc_buf[op_index] = INDEX_op_nop;
9a81090b 827 } else {
92414b31 828 s->gen_opc_buf[op_index] = op_to_mov(op);
b80bb016 829 tcg_opt_gen_mov(s, gen_args, args[0], args[1]);
9a81090b 830 gen_args += 2;
9a81090b 831 }
fedc0da2 832 args += 3;
9a81090b
KB		 833 continue;
834 }
835 break;
fe0de7aa
BS		 836 default:
837 break;
53108fb5
KB		 838 }
839
3c94193e
AJ		 840 /* Simplify expression for "op r, a, a => movi r, 0" cases */
841 switch (op) {
842 CASE_OP_32_64(sub):
843 CASE_OP_32_64(xor):
844 if (temps_are_copies(args[1], args[2])) {
92414b31 845 s->gen_opc_buf[op_index] = op_to_movi(op);
3c94193e
AJ		 846 tcg_opt_gen_movi(gen_args, args[0], 0);
847 gen_args += 2;
848 args += 3;
849 continue;
850 }
851 break;
852 default:
853 break;
854 }
855
22613af4
KB		 856 /* Propagate constants through copy operations and do constant
857 folding. Constants will be substituted to arguments by register
858 allocator where needed and possible. Also detect copies. */
8f2e8c07 859 switch (op) {
22613af4 860 CASE_OP_32_64(mov):
e590d4e6 861 if (temps_are_copies(args[0], args[1])) {
22613af4 862 args += 2;
92414b31 863 s->gen_opc_buf[op_index] = INDEX_op_nop;
22613af4
KB		 864 break;
865 }
866 if (temps[args[1]].state != TCG_TEMP_CONST) {
b80bb016 867 tcg_opt_gen_mov(s, gen_args, args[0], args[1]);
22613af4
KB		 868 gen_args += 2;
869 args += 2;
870 break;
871 }
872 /* Source argument is constant. Rewrite the operation and
873 let movi case handle it. */
874 op = op_to_movi(op);
92414b31 875 s->gen_opc_buf[op_index] = op;
22613af4
KB		 876 args[1] = temps[args[1]].val;
877 /* fallthrough */
878 CASE_OP_32_64(movi):
e590d4e6 879 tcg_opt_gen_movi(gen_args, args[0], args[1]);
22613af4
KB		 880 gen_args += 2;
881 args += 2;
882 break;
6e14e91b 883
a640f031 884 CASE_OP_32_64(not):
cb25c80a 885 CASE_OP_32_64(neg):
25c4d9cc
RH		 886 CASE_OP_32_64(ext8s):
887 CASE_OP_32_64(ext8u):
888 CASE_OP_32_64(ext16s):
889 CASE_OP_32_64(ext16u):
a640f031
KB		 890 case INDEX_op_ext32s_i64:
891 case INDEX_op_ext32u_i64:
a640f031 892 if (temps[args[1]].state == TCG_TEMP_CONST) {
92414b31 893 s->gen_opc_buf[op_index] = op_to_movi(op);
a640f031 894 tmp = do_constant_folding(op, temps[args[1]].val, 0);
e590d4e6 895 tcg_opt_gen_movi(gen_args, args[0], tmp);
6e14e91b
RH		 896 gen_args += 2;
897 args += 2;
898 break;
a640f031 899 }
6e14e91b
RH		 900 goto do_default;
901
53108fb5
KB		 902 CASE_OP_32_64(add):
903 CASE_OP_32_64(sub):
904 CASE_OP_32_64(mul):
9a81090b
KB		 905 CASE_OP_32_64(or):
906 CASE_OP_32_64(and):
907 CASE_OP_32_64(xor):
55c0975c
KB		 908 CASE_OP_32_64(shl):
909 CASE_OP_32_64(shr):
910 CASE_OP_32_64(sar):
25c4d9cc
RH		 911 CASE_OP_32_64(rotl):
912 CASE_OP_32_64(rotr):
cb25c80a
RH		 913 CASE_OP_32_64(andc):
914 CASE_OP_32_64(orc):
915 CASE_OP_32_64(eqv):
916 CASE_OP_32_64(nand):
917 CASE_OP_32_64(nor):
03271524
RH		 918 CASE_OP_32_64(muluh):
919 CASE_OP_32_64(mulsh):
01547f7f
RH		 920 CASE_OP_32_64(div):
921 CASE_OP_32_64(divu):
922 CASE_OP_32_64(rem):
923 CASE_OP_32_64(remu):
53108fb5
KB		 924 if (temps[args[1]].state == TCG_TEMP_CONST
925 && temps[args[2]].state == TCG_TEMP_CONST) {
92414b31 926 s->gen_opc_buf[op_index] = op_to_movi(op);
53108fb5
KB		 927 tmp = do_constant_folding(op, temps[args[1]].val,
928 temps[args[2]].val);
e590d4e6 929 tcg_opt_gen_movi(gen_args, args[0], tmp);
53108fb5 930 gen_args += 2;
6e14e91b
RH		 931 args += 3;
932 break;
53108fb5 933 }
6e14e91b
RH		 934 goto do_default;
935
7ef55fc9
AJ		 936 CASE_OP_32_64(deposit):
937 if (temps[args[1]].state == TCG_TEMP_CONST
938 && temps[args[2]].state == TCG_TEMP_CONST) {
92414b31 939 s->gen_opc_buf[op_index] = op_to_movi(op);
7ef55fc9
AJ		 940 tmp = ((1ull << args[4]) - 1);
941 tmp = (temps[args[1]].val & ~(tmp << args[3]))
942 | ((temps[args[2]].val & tmp) << args[3]);
943 tcg_opt_gen_movi(gen_args, args[0], tmp);
944 gen_args += 2;
6e14e91b
RH		 945 args += 5;
946 break;
7ef55fc9 947 }
6e14e91b
RH		 948 goto do_default;
949
f8dd19e5 950 CASE_OP_32_64(setcond):
b336ceb6
AJ		 951 tmp = do_constant_folding_cond(op, args[1], args[2], args[3]);
952 if (tmp != 2) {
92414b31 953 s->gen_opc_buf[op_index] = op_to_movi(op);
e590d4e6 954 tcg_opt_gen_movi(gen_args, args[0], tmp);
f8dd19e5 955 gen_args += 2;
6e14e91b
RH		 956 args += 4;
957 break;
f8dd19e5 958 }
6e14e91b
RH		 959 goto do_default;
960
fbeaa26c 961 CASE_OP_32_64(brcond):
b336ceb6
AJ		 962 tmp = do_constant_folding_cond(op, args[0], args[1], args[2]);
963 if (tmp != 2) {
964 if (tmp) {
d193a14a 965 reset_all_temps(nb_temps);
92414b31 966 s->gen_opc_buf[op_index] = INDEX_op_br;
fbeaa26c
AJ		 967 gen_args[0] = args[3];
968 gen_args += 1;
fbeaa26c 969 } else {
92414b31 970 s->gen_opc_buf[op_index] = INDEX_op_nop;
fbeaa26c 971 }
6e14e91b
RH		 972 args += 4;
973 break;
fbeaa26c 974 }
6e14e91b
RH		 975 goto do_default;
976
fa01a208 977 CASE_OP_32_64(movcond):
b336ceb6
AJ		 978 tmp = do_constant_folding_cond(op, args[1], args[2], args[5]);
979 if (tmp != 2) {
e590d4e6 980 if (temps_are_copies(args[0], args[4-tmp])) {
92414b31 981 s->gen_opc_buf[op_index] = INDEX_op_nop;
fa01a208 982 } else if (temps[args[4-tmp]].state == TCG_TEMP_CONST) {
92414b31 983 s->gen_opc_buf[op_index] = op_to_movi(op);
e590d4e6 984 tcg_opt_gen_movi(gen_args, args[0], temps[args[4-tmp]].val);
fa01a208
RH		 985 gen_args += 2;
986 } else {
92414b31 987 s->gen_opc_buf[op_index] = op_to_mov(op);
e590d4e6 988 tcg_opt_gen_mov(s, gen_args, args[0], args[4-tmp]);
fa01a208
RH		 989 gen_args += 2;
990 }
6e14e91b
RH		 991 args += 6;
992 break;
fa01a208 993 }
6e14e91b 994 goto do_default;
212c328d
RH		 995
996 case INDEX_op_add2_i32:
997 case INDEX_op_sub2_i32:
998 if (temps[args[2]].state == TCG_TEMP_CONST
999 && temps[args[3]].state == TCG_TEMP_CONST
1000 && temps[args[4]].state == TCG_TEMP_CONST
1001 && temps[args[5]].state == TCG_TEMP_CONST) {
1002 uint32_t al = temps[args[2]].val;
1003 uint32_t ah = temps[args[3]].val;
1004 uint32_t bl = temps[args[4]].val;
1005 uint32_t bh = temps[args[5]].val;
1006 uint64_t a = ((uint64_t)ah << 32) | al;
1007 uint64_t b = ((uint64_t)bh << 32) | bl;
1008 TCGArg rl, rh;
1009
1010 if (op == INDEX_op_add2_i32) {
1011 a += b;
1012 } else {
1013 a -= b;
1014 }
1015
1016 /* We emit the extra nop when we emit the add2/sub2. */
92414b31 1017 assert(s->gen_opc_buf[op_index + 1] == INDEX_op_nop);
212c328d
RH		 1018
1019 rl = args[0];
1020 rh = args[1];
92414b31
EV		 1021 s->gen_opc_buf[op_index] = INDEX_op_movi_i32;
1022 s->gen_opc_buf[++op_index] = INDEX_op_movi_i32;
212c328d
RH		 1023 tcg_opt_gen_movi(&gen_args[0], rl, (uint32_t)a);
1024 tcg_opt_gen_movi(&gen_args[2], rh, (uint32_t)(a >> 32));
1025 gen_args += 4;
1026 args += 6;
1027 break;
1028 }
1029 goto do_default;
1414968a
RH		 1030
1031 case INDEX_op_mulu2_i32:
1032 if (temps[args[2]].state == TCG_TEMP_CONST
1033 && temps[args[3]].state == TCG_TEMP_CONST) {
1034 uint32_t a = temps[args[2]].val;
1035 uint32_t b = temps[args[3]].val;
1036 uint64_t r = (uint64_t)a * b;
1037 TCGArg rl, rh;
1038
1039 /* We emit the extra nop when we emit the mulu2. */
92414b31 1040 assert(s->gen_opc_buf[op_index + 1] == INDEX_op_nop);
1414968a
RH		 1041
1042 rl = args[0];
1043 rh = args[1];
92414b31
EV		 1044 s->gen_opc_buf[op_index] = INDEX_op_movi_i32;
1045 s->gen_opc_buf[++op_index] = INDEX_op_movi_i32;
1414968a
RH		 1046 tcg_opt_gen_movi(&gen_args[0], rl, (uint32_t)r);
1047 tcg_opt_gen_movi(&gen_args[2], rh, (uint32_t)(r >> 32));
1048 gen_args += 4;
1049 args += 4;
1050 break;
1051 }
1052 goto do_default;
6e14e91b 1053
bc1473ef 1054 case INDEX_op_brcond2_i32:
6c4382f8
RH		 1055 tmp = do_constant_folding_cond2(&args[0], &args[2], args[4]);
1056 if (tmp != 2) {
1057 if (tmp) {
d193a14a 1058 reset_all_temps(nb_temps);
92414b31 1059 s->gen_opc_buf[op_index] = INDEX_op_br;
6c4382f8
RH		 1060 gen_args[0] = args[5];
1061 gen_args += 1;
1062 } else {
92414b31 1063 s->gen_opc_buf[op_index] = INDEX_op_nop;
6c4382f8
RH		 1064 }
1065 } else if ((args[4] == TCG_COND_LT || args[4] == TCG_COND_GE)
1066 && temps[args[2]].state == TCG_TEMP_CONST
1067 && temps[args[3]].state == TCG_TEMP_CONST
1068 && temps[args[2]].val == 0
1069 && temps[args[3]].val == 0) {
1070 /* Simplify LT/GE comparisons vs zero to a single compare
1071 vs the high word of the input. */
d193a14a 1072 reset_all_temps(nb_temps);
92414b31 1073 s->gen_opc_buf[op_index] = INDEX_op_brcond_i32;
bc1473ef
RH		 1074 gen_args[0] = args[1];
1075 gen_args[1] = args[3];
1076 gen_args[2] = args[4];
1077 gen_args[3] = args[5];
1078 gen_args += 4;
6c4382f8
RH		 1079 } else {
1080 goto do_default;
bc1473ef 1081 }
6c4382f8
RH		 1082 args += 6;
1083 break;
bc1473ef
RH		 1084
1085 case INDEX_op_setcond2_i32:
6c4382f8
RH		 1086 tmp = do_constant_folding_cond2(&args[1], &args[3], args[5]);
1087 if (tmp != 2) {
92414b31 1088 s->gen_opc_buf[op_index] = INDEX_op_movi_i32;
6c4382f8
RH		 1089 tcg_opt_gen_movi(gen_args, args[0], tmp);
1090 gen_args += 2;
1091 } else if ((args[5] == TCG_COND_LT || args[5] == TCG_COND_GE)
1092 && temps[args[3]].state == TCG_TEMP_CONST
1093 && temps[args[4]].state == TCG_TEMP_CONST
1094 && temps[args[3]].val == 0
1095 && temps[args[4]].val == 0) {
1096 /* Simplify LT/GE comparisons vs zero to a single compare
1097 vs the high word of the input. */
92414b31 1098 s->gen_opc_buf[op_index] = INDEX_op_setcond_i32;
66e61b55 1099 reset_temp(args[0]);
bc1473ef
RH		 1100 gen_args[0] = args[0];
1101 gen_args[1] = args[2];
1102 gen_args[2] = args[4];
1103 gen_args[3] = args[5];
1104 gen_args += 4;
6c4382f8
RH		 1105 } else {
1106 goto do_default;
bc1473ef 1107 }
6c4382f8
RH		 1108 args += 6;
1109 break;
bc1473ef 1110
8f2e8c07 1111 case INDEX_op_call:
22613af4 1112 nb_call_args = (args[0] >> 16) + (args[0] & 0xffff);
78505279
AJ		 1113 if (!(args[nb_call_args + 1] & (TCG_CALL_NO_READ_GLOBALS |
1114 TCG_CALL_NO_WRITE_GLOBALS))) {
22613af4 1115 for (i = 0; i < nb_globals; i++) {
e590d4e6 1116 reset_temp(i);
22613af4
KB		 1117 }
1118 }
1119 for (i = 0; i < (args[0] >> 16); i++) {
e590d4e6 1120 reset_temp(args[i + 1]);
22613af4
KB		 1121 }
1122 i = nb_call_args + 3;
8f2e8c07
KB		 1123 while (i) {
1124 *gen_args = *args;
1125 args++;
1126 gen_args++;
1127 i--;
1128 }
1129 break;
6e14e91b 1130
8f2e8c07 1131 default:
6e14e91b
RH		 1132 do_default:
1133 /* Default case: we know nothing about operation (or were unable
1134 to compute the operation result) so no propagation is done.
1135 We trash everything if the operation is the end of a basic
3a9d8b17
PB		 1136 block, otherwise we only trash the output args. "mask" is
1137 the non-zero bits mask for the first output arg. */
a2550660 1138 if (def->flags & TCG_OPF_BB_END) {
d193a14a 1139 reset_all_temps(nb_temps);
a2550660
AJ		 1140 } else {
1141 for (i = 0; i < def->nb_oargs; i++) {
e590d4e6 1142 reset_temp(args[i]);
a2550660 1143 }
22613af4 1144 }
8f2e8c07
KB		 1145 for (i = 0; i < def->nb_args; i++) {
1146 gen_args[i] = args[i];
1147 }
1148 args += def->nb_args;
1149 gen_args += def->nb_args;
1150 break;
1151 }
1152 }
1153
1154 return gen_args;
1155}
1156
1157TCGArg *tcg_optimize(TCGContext *s, uint16_t *tcg_opc_ptr,
1158 TCGArg *args, TCGOpDef *tcg_op_defs)
1159{
1160 TCGArg *res;
1161 res = tcg_constant_folding(s, tcg_opc_ptr, args, tcg_op_defs);
1162 return res;
1163}
Qemu copy for testing