blob: bc6e5c16a9146215ebe00fd297793fedaf361676 [file] [log] [blame]
Kirill Batuzov8f2e8c02011-07-07 16:37:12 +04001/*
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
Kirill Batuzov8f2e8c02011-07-07 16:37:12 +040034#define CASE_OP_32_64(x) \
35 glue(glue(case INDEX_op_, x), _i32): \
36 glue(glue(case INDEX_op_, x), _i64)
Kirill Batuzov8f2e8c02011-07-07 16:37:12 +040037
Kirill Batuzov22613af2011-07-07 16:37:13 +040038typedef enum {
39 TCG_TEMP_UNDEF = 0,
40 TCG_TEMP_CONST,
41 TCG_TEMP_COPY,
Kirill Batuzov22613af2011-07-07 16:37:13 +040042} 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;
Paolo Bonzini3a9d8b12013-01-11 15:42:52 -080049 tcg_target_ulong mask;
Kirill Batuzov22613af2011-07-07 16:37:13 +040050};
51
52static struct tcg_temp_info temps[TCG_MAX_TEMPS];
53
Aurelien Jarnoe590d4e2012-09-11 12:31:21 +020054/* 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)
Kirill Batuzov22613af2011-07-07 16:37:13 +040057{
Aurelien Jarnoe590d4e2012-09-11 12:31:21 +020058 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;
Kirill Batuzov22613af2011-07-07 16:37:13 +040064 }
Kirill Batuzov22613af2011-07-07 16:37:13 +040065 }
Aurelien Jarno48b56ce2012-09-10 23:51:42 +020066 temps[temp].state = TCG_TEMP_UNDEF;
Paolo Bonzini3a9d8b12013-01-11 15:42:52 -080067 temps[temp].mask = -1;
Kirill Batuzov22613af2011-07-07 16:37:13 +040068}
69
Paolo Bonzinid193a142013-01-11 15:42:51 -080070/* 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;
Paolo Bonzini3a9d8b12013-01-11 15:42:52 -080076 temps[i].mask = -1;
Paolo Bonzinid193a142013-01-11 15:42:51 -080077 }
78}
79
Blue Swirlfe0de7a2011-07-30 19:18:32 +000080static int op_bits(TCGOpcode op)
Kirill Batuzov22613af2011-07-07 16:37:13 +040081{
Richard Henderson8399ad52011-08-17 14:11:45 -070082 const TCGOpDef *def = &tcg_op_defs[op];
83 return def->flags & TCG_OPF_64BIT ? 64 : 32;
Kirill Batuzov22613af2011-07-07 16:37:13 +040084}
85
Blue Swirlfe0de7a2011-07-30 19:18:32 +000086static TCGOpcode op_to_movi(TCGOpcode op)
Kirill Batuzov22613af2011-07-07 16:37:13 +040087{
88 switch (op_bits(op)) {
89 case 32:
90 return INDEX_op_movi_i32;
Kirill Batuzov22613af2011-07-07 16:37:13 +040091 case 64:
92 return INDEX_op_movi_i64;
Kirill Batuzov22613af2011-07-07 16:37:13 +040093 default:
94 fprintf(stderr, "op_to_movi: unexpected return value of "
95 "function op_bits.\n");
96 tcg_abort();
97 }
98}
99
Aurelien Jarnoe590d4e2012-09-11 12:31:21 +0200100static 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
Aurelien Jarnob80bb012012-09-11 12:26:23 +0200151static void tcg_opt_gen_mov(TCGContext *s, TCGArg *gen_args,
152 TCGArg dst, TCGArg src)
Kirill Batuzov22613af2011-07-07 16:37:13 +0400153{
Paolo Bonzini3a9d8b12013-01-11 15:42:52 -0800154 reset_temp(dst);
155 temps[dst].mask = temps[src].mask;
156 assert(temps[src].state != TCG_TEMP_CONST);
Aurelien Jarnoe590d4e2012-09-11 12:31:21 +0200157
Paolo Bonzini3a9d8b12013-01-11 15:42:52 -0800158 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;
Kirill Batuzov22613af2011-07-07 16:37:13 +0400163 }
Paolo Bonzini3a9d8b12013-01-11 15:42:52 -0800164 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 }
Aurelien Jarnoe590d4e2012-09-11 12:31:21 +0200170
Paolo Bonzini3a9d8b12013-01-11 15:42:52 -0800171 gen_args[0] = dst;
172 gen_args[1] = src;
Kirill Batuzov22613af2011-07-07 16:37:13 +0400173}
174
Aurelien Jarnoe590d4e2012-09-11 12:31:21 +0200175static void tcg_opt_gen_movi(TCGArg *gen_args, TCGArg dst, TCGArg val)
Kirill Batuzov22613af2011-07-07 16:37:13 +0400176{
Paolo Bonzini3a9d8b12013-01-11 15:42:52 -0800177 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;
Kirill Batuzov22613af2011-07-07 16:37:13 +0400183}
184
Blue Swirlfe0de7a2011-07-30 19:18:32 +0000185static TCGOpcode op_to_mov(TCGOpcode op)
Kirill Batuzov53108fb2011-07-07 16:37:14 +0400186{
187 switch (op_bits(op)) {
188 case 32:
189 return INDEX_op_mov_i32;
Kirill Batuzov53108fb2011-07-07 16:37:14 +0400190 case 64:
191 return INDEX_op_mov_i64;
Kirill Batuzov53108fb2011-07-07 16:37:14 +0400192 default:
193 fprintf(stderr, "op_to_mov: unexpected return value of "
194 "function op_bits.\n");
195 tcg_abort();
196 }
197}
198
Blue Swirlfe0de7a2011-07-30 19:18:32 +0000199static TCGArg do_constant_folding_2(TCGOpcode op, TCGArg x, TCGArg y)
Kirill Batuzov53108fb2011-07-07 16:37:14 +0400200{
201 switch (op) {
202 CASE_OP_32_64(add):
203 return x + y;
204
205 CASE_OP_32_64(sub):
206 return x - y;
207
208 CASE_OP_32_64(mul):
209 return x * y;
210
Kirill Batuzov9a810902011-07-07 16:37:15 +0400211 CASE_OP_32_64(and):
212 return x & y;
213
214 CASE_OP_32_64(or):
215 return x | y;
216
217 CASE_OP_32_64(xor):
218 return x ^ y;
219
Kirill Batuzov55c09752011-07-07 16:37:16 +0400220 case INDEX_op_shl_i32:
221 return (uint32_t)x << (uint32_t)y;
222
Kirill Batuzov55c09752011-07-07 16:37:16 +0400223 case INDEX_op_shl_i64:
224 return (uint64_t)x << (uint64_t)y;
Kirill Batuzov55c09752011-07-07 16:37:16 +0400225
226 case INDEX_op_shr_i32:
227 return (uint32_t)x >> (uint32_t)y;
228
Kirill Batuzov55c09752011-07-07 16:37:16 +0400229 case INDEX_op_shr_i64:
230 return (uint64_t)x >> (uint64_t)y;
Kirill Batuzov55c09752011-07-07 16:37:16 +0400231
232 case INDEX_op_sar_i32:
233 return (int32_t)x >> (int32_t)y;
234
Kirill Batuzov55c09752011-07-07 16:37:16 +0400235 case INDEX_op_sar_i64:
236 return (int64_t)x >> (int64_t)y;
Kirill Batuzov55c09752011-07-07 16:37:16 +0400237
238 case INDEX_op_rotr_i32:
Richard Henderson25c4d9c2011-08-17 14:11:46 -0700239 x = ((uint32_t)x << (32 - y)) | ((uint32_t)x >> y);
Kirill Batuzov55c09752011-07-07 16:37:16 +0400240 return x;
241
Kirill Batuzov55c09752011-07-07 16:37:16 +0400242 case INDEX_op_rotr_i64:
Richard Henderson25c4d9c2011-08-17 14:11:46 -0700243 x = ((uint64_t)x << (64 - y)) | ((uint64_t)x >> y);
Kirill Batuzov55c09752011-07-07 16:37:16 +0400244 return x;
Kirill Batuzov55c09752011-07-07 16:37:16 +0400245
246 case INDEX_op_rotl_i32:
Richard Henderson25c4d9c2011-08-17 14:11:46 -0700247 x = ((uint32_t)x << y) | ((uint32_t)x >> (32 - y));
Kirill Batuzov55c09752011-07-07 16:37:16 +0400248 return x;
249
Kirill Batuzov55c09752011-07-07 16:37:16 +0400250 case INDEX_op_rotl_i64:
Richard Henderson25c4d9c2011-08-17 14:11:46 -0700251 x = ((uint64_t)x << y) | ((uint64_t)x >> (64 - y));
Kirill Batuzov55c09752011-07-07 16:37:16 +0400252 return x;
Kirill Batuzov55c09752011-07-07 16:37:16 +0400253
Richard Henderson25c4d9c2011-08-17 14:11:46 -0700254 CASE_OP_32_64(not):
Kirill Batuzova640f032011-07-07 16:37:17 +0400255 return ~x;
256
Richard Hendersoncb25c802011-08-17 14:11:47 -0700257 CASE_OP_32_64(neg):
258 return -x;
259
260 CASE_OP_32_64(andc):
261 return x & ~y;
262
263 CASE_OP_32_64(orc):
264 return x | ~y;
265
266 CASE_OP_32_64(eqv):
267 return ~(x ^ y);
268
269 CASE_OP_32_64(nand):
270 return ~(x & y);
271
272 CASE_OP_32_64(nor):
273 return ~(x | y);
274
Richard Henderson25c4d9c2011-08-17 14:11:46 -0700275 CASE_OP_32_64(ext8s):
Kirill Batuzova640f032011-07-07 16:37:17 +0400276 return (int8_t)x;
277
Richard Henderson25c4d9c2011-08-17 14:11:46 -0700278 CASE_OP_32_64(ext16s):
Kirill Batuzova640f032011-07-07 16:37:17 +0400279 return (int16_t)x;
280
Richard Henderson25c4d9c2011-08-17 14:11:46 -0700281 CASE_OP_32_64(ext8u):
Kirill Batuzova640f032011-07-07 16:37:17 +0400282 return (uint8_t)x;
283
Richard Henderson25c4d9c2011-08-17 14:11:46 -0700284 CASE_OP_32_64(ext16u):
Kirill Batuzova640f032011-07-07 16:37:17 +0400285 return (uint16_t)x;
286
Kirill Batuzova640f032011-07-07 16:37:17 +0400287 case INDEX_op_ext32s_i64:
288 return (int32_t)x;
289
290 case INDEX_op_ext32u_i64:
291 return (uint32_t)x;
Kirill Batuzova640f032011-07-07 16:37:17 +0400292
Kirill Batuzov53108fb2011-07-07 16:37:14 +0400293 default:
294 fprintf(stderr,
295 "Unrecognized operation %d in do_constant_folding.\n", op);
296 tcg_abort();
297 }
298}
299
Blue Swirlfe0de7a2011-07-30 19:18:32 +0000300static TCGArg do_constant_folding(TCGOpcode op, TCGArg x, TCGArg y)
Kirill Batuzov53108fb2011-07-07 16:37:14 +0400301{
302 TCGArg res = do_constant_folding_2(op, x, y);
Kirill Batuzov53108fb2011-07-07 16:37:14 +0400303 if (op_bits(op) == 32) {
304 res &= 0xffffffff;
305 }
Kirill Batuzov53108fb2011-07-07 16:37:14 +0400306 return res;
307}
308
Richard Henderson9519da72012-10-02 11:32:26 -0700309static bool do_constant_folding_cond_32(uint32_t x, uint32_t y, TCGCond c)
310{
311 switch (c) {
312 case TCG_COND_EQ:
313 return x == y;
314 case TCG_COND_NE:
315 return x != y;
316 case TCG_COND_LT:
317 return (int32_t)x < (int32_t)y;
318 case TCG_COND_GE:
319 return (int32_t)x >= (int32_t)y;
320 case TCG_COND_LE:
321 return (int32_t)x <= (int32_t)y;
322 case TCG_COND_GT:
323 return (int32_t)x > (int32_t)y;
324 case TCG_COND_LTU:
325 return x < y;
326 case TCG_COND_GEU:
327 return x >= y;
328 case TCG_COND_LEU:
329 return x <= y;
330 case TCG_COND_GTU:
331 return x > y;
332 default:
333 tcg_abort();
334 }
335}
336
337static bool do_constant_folding_cond_64(uint64_t x, uint64_t y, TCGCond c)
338{
339 switch (c) {
340 case TCG_COND_EQ:
341 return x == y;
342 case TCG_COND_NE:
343 return x != y;
344 case TCG_COND_LT:
345 return (int64_t)x < (int64_t)y;
346 case TCG_COND_GE:
347 return (int64_t)x >= (int64_t)y;
348 case TCG_COND_LE:
349 return (int64_t)x <= (int64_t)y;
350 case TCG_COND_GT:
351 return (int64_t)x > (int64_t)y;
352 case TCG_COND_LTU:
353 return x < y;
354 case TCG_COND_GEU:
355 return x >= y;
356 case TCG_COND_LEU:
357 return x <= y;
358 case TCG_COND_GTU:
359 return x > y;
360 default:
361 tcg_abort();
362 }
363}
364
365static bool do_constant_folding_cond_eq(TCGCond c)
366{
367 switch (c) {
368 case TCG_COND_GT:
369 case TCG_COND_LTU:
370 case TCG_COND_LT:
371 case TCG_COND_GTU:
372 case TCG_COND_NE:
373 return 0;
374 case TCG_COND_GE:
375 case TCG_COND_GEU:
376 case TCG_COND_LE:
377 case TCG_COND_LEU:
378 case TCG_COND_EQ:
379 return 1;
380 default:
381 tcg_abort();
382 }
383}
384
Aurelien Jarnob336ceb2012-09-18 19:37:00 +0200385/* Return 2 if the condition can't be simplified, and the result
386 of the condition (0 or 1) if it can */
Aurelien Jarnof8dd19e2012-09-06 16:47:14 +0200387static TCGArg do_constant_folding_cond(TCGOpcode op, TCGArg x,
388 TCGArg y, TCGCond c)
389{
Aurelien Jarnob336ceb2012-09-18 19:37:00 +0200390 if (temps[x].state == TCG_TEMP_CONST && temps[y].state == TCG_TEMP_CONST) {
391 switch (op_bits(op)) {
392 case 32:
Richard Henderson9519da72012-10-02 11:32:26 -0700393 return do_constant_folding_cond_32(temps[x].val, temps[y].val, c);
Aurelien Jarnob336ceb2012-09-18 19:37:00 +0200394 case 64:
Richard Henderson9519da72012-10-02 11:32:26 -0700395 return do_constant_folding_cond_64(temps[x].val, temps[y].val, c);
396 default:
397 tcg_abort();
Aurelien Jarnof8dd19e2012-09-06 16:47:14 +0200398 }
Aurelien Jarnob336ceb2012-09-18 19:37:00 +0200399 } else if (temps_are_copies(x, y)) {
Richard Henderson9519da72012-10-02 11:32:26 -0700400 return do_constant_folding_cond_eq(c);
Aurelien Jarnob336ceb2012-09-18 19:37:00 +0200401 } else if (temps[y].state == TCG_TEMP_CONST && temps[y].val == 0) {
402 switch (c) {
403 case TCG_COND_LTU:
404 return 0;
405 case TCG_COND_GEU:
406 return 1;
407 default:
408 return 2;
409 }
410 } else {
411 return 2;
Aurelien Jarnof8dd19e2012-09-06 16:47:14 +0200412 }
Aurelien Jarnof8dd19e2012-09-06 16:47:14 +0200413}
414
Richard Henderson6c4382f2012-10-02 11:32:27 -0700415/* Return 2 if the condition can't be simplified, and the result
416 of the condition (0 or 1) if it can */
417static TCGArg do_constant_folding_cond2(TCGArg *p1, TCGArg *p2, TCGCond c)
418{
419 TCGArg al = p1[0], ah = p1[1];
420 TCGArg bl = p2[0], bh = p2[1];
421
422 if (temps[bl].state == TCG_TEMP_CONST
423 && temps[bh].state == TCG_TEMP_CONST) {
424 uint64_t b = ((uint64_t)temps[bh].val << 32) | (uint32_t)temps[bl].val;
425
426 if (temps[al].state == TCG_TEMP_CONST
427 && temps[ah].state == TCG_TEMP_CONST) {
428 uint64_t a;
429 a = ((uint64_t)temps[ah].val << 32) | (uint32_t)temps[al].val;
430 return do_constant_folding_cond_64(a, b, c);
431 }
432 if (b == 0) {
433 switch (c) {
434 case TCG_COND_LTU:
435 return 0;
436 case TCG_COND_GEU:
437 return 1;
438 default:
439 break;
440 }
441 }
442 }
443 if (temps_are_copies(al, bl) && temps_are_copies(ah, bh)) {
444 return do_constant_folding_cond_eq(c);
445 }
446 return 2;
447}
448
Richard Henderson24c9ae42012-10-02 11:32:21 -0700449static bool swap_commutative(TCGArg dest, TCGArg *p1, TCGArg *p2)
450{
451 TCGArg a1 = *p1, a2 = *p2;
452 int sum = 0;
453 sum += temps[a1].state == TCG_TEMP_CONST;
454 sum -= temps[a2].state == TCG_TEMP_CONST;
455
456 /* Prefer the constant in second argument, and then the form
457 op a, a, b, which is better handled on non-RISC hosts. */
458 if (sum > 0 || (sum == 0 && dest == a2)) {
459 *p1 = a2;
460 *p2 = a1;
461 return true;
462 }
463 return false;
464}
465
Richard Henderson0bfcb862012-10-02 11:32:23 -0700466static bool swap_commutative2(TCGArg *p1, TCGArg *p2)
467{
468 int sum = 0;
469 sum += temps[p1[0]].state == TCG_TEMP_CONST;
470 sum += temps[p1[1]].state == TCG_TEMP_CONST;
471 sum -= temps[p2[0]].state == TCG_TEMP_CONST;
472 sum -= temps[p2[1]].state == TCG_TEMP_CONST;
473 if (sum > 0) {
474 TCGArg t;
475 t = p1[0], p1[0] = p2[0], p2[0] = t;
476 t = p1[1], p1[1] = p2[1], p2[1] = t;
477 return true;
478 }
479 return false;
480}
481
Kirill Batuzov22613af2011-07-07 16:37:13 +0400482/* Propagate constants and copies, fold constant expressions. */
Kirill Batuzov8f2e8c02011-07-07 16:37:12 +0400483static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
484 TCGArg *args, TCGOpDef *tcg_op_defs)
485{
Blue Swirlfe0de7a2011-07-30 19:18:32 +0000486 int i, nb_ops, op_index, nb_temps, nb_globals, nb_call_args;
Paolo Bonzini633f6502013-01-11 15:42:53 -0800487 tcg_target_ulong mask, affected;
Blue Swirlfe0de7a2011-07-30 19:18:32 +0000488 TCGOpcode op;
Kirill Batuzov8f2e8c02011-07-07 16:37:12 +0400489 const TCGOpDef *def;
490 TCGArg *gen_args;
Kirill Batuzov53108fb2011-07-07 16:37:14 +0400491 TCGArg tmp;
Richard Henderson5d8f5362012-09-21 10:13:38 -0700492
Kirill Batuzov22613af2011-07-07 16:37:13 +0400493 /* Array VALS has an element for each temp.
494 If this temp holds a constant then its value is kept in VALS' element.
Aurelien Jarnoe590d4e2012-09-11 12:31:21 +0200495 If this temp is a copy of other ones then the other copies are
496 available through the doubly linked circular list. */
Kirill Batuzov8f2e8c02011-07-07 16:37:12 +0400497
498 nb_temps = s->nb_temps;
499 nb_globals = s->nb_globals;
Paolo Bonzinid193a142013-01-11 15:42:51 -0800500 reset_all_temps(nb_temps);
Kirill Batuzov8f2e8c02011-07-07 16:37:12 +0400501
Evgeny Voevodin92414b32012-11-12 13:27:47 +0400502 nb_ops = tcg_opc_ptr - s->gen_opc_buf;
Kirill Batuzov8f2e8c02011-07-07 16:37:12 +0400503 gen_args = args;
504 for (op_index = 0; op_index < nb_ops; op_index++) {
Evgeny Voevodin92414b32012-11-12 13:27:47 +0400505 op = s->gen_opc_buf[op_index];
Kirill Batuzov8f2e8c02011-07-07 16:37:12 +0400506 def = &tcg_op_defs[op];
Kirill Batuzov22613af2011-07-07 16:37:13 +0400507 /* Do copy propagation */
Aurelien Jarno1ff8c542012-09-11 16:18:49 +0200508 if (op == INDEX_op_call) {
509 int nb_oargs = args[0] >> 16;
510 int nb_iargs = args[0] & 0xffff;
511 for (i = nb_oargs + 1; i < nb_oargs + nb_iargs + 1; i++) {
512 if (temps[args[i]].state == TCG_TEMP_COPY) {
513 args[i] = find_better_copy(s, args[i]);
514 }
515 }
516 } else {
Kirill Batuzov22613af2011-07-07 16:37:13 +0400517 for (i = def->nb_oargs; i < def->nb_oargs + def->nb_iargs; i++) {
518 if (temps[args[i]].state == TCG_TEMP_COPY) {
Aurelien Jarnoe590d4e2012-09-11 12:31:21 +0200519 args[i] = find_better_copy(s, args[i]);
Kirill Batuzov22613af2011-07-07 16:37:13 +0400520 }
521 }
522 }
523
Kirill Batuzov53108fb2011-07-07 16:37:14 +0400524 /* For commutative operations make constant second argument */
525 switch (op) {
526 CASE_OP_32_64(add):
527 CASE_OP_32_64(mul):
Kirill Batuzov9a810902011-07-07 16:37:15 +0400528 CASE_OP_32_64(and):
529 CASE_OP_32_64(or):
530 CASE_OP_32_64(xor):
Richard Hendersoncb25c802011-08-17 14:11:47 -0700531 CASE_OP_32_64(eqv):
532 CASE_OP_32_64(nand):
533 CASE_OP_32_64(nor):
Richard Henderson24c9ae42012-10-02 11:32:21 -0700534 swap_commutative(args[0], &args[1], &args[2]);
Kirill Batuzov53108fb2011-07-07 16:37:14 +0400535 break;
Aurelien Jarno65a7cce2012-09-06 16:47:14 +0200536 CASE_OP_32_64(brcond):
Richard Henderson24c9ae42012-10-02 11:32:21 -0700537 if (swap_commutative(-1, &args[0], &args[1])) {
Aurelien Jarno65a7cce2012-09-06 16:47:14 +0200538 args[2] = tcg_swap_cond(args[2]);
539 }
540 break;
541 CASE_OP_32_64(setcond):
Richard Henderson24c9ae42012-10-02 11:32:21 -0700542 if (swap_commutative(args[0], &args[1], &args[2])) {
Aurelien Jarno65a7cce2012-09-06 16:47:14 +0200543 args[3] = tcg_swap_cond(args[3]);
544 }
545 break;
Richard Hendersonfa01a202012-09-21 10:13:37 -0700546 CASE_OP_32_64(movcond):
Richard Henderson24c9ae42012-10-02 11:32:21 -0700547 if (swap_commutative(-1, &args[1], &args[2])) {
548 args[5] = tcg_swap_cond(args[5]);
Richard Hendersonfa01a202012-09-21 10:13:37 -0700549 }
Richard Henderson5d8f5362012-09-21 10:13:38 -0700550 /* For movcond, we canonicalize the "false" input reg to match
551 the destination reg so that the tcg backend can implement
552 a "move if true" operation. */
Richard Henderson24c9ae42012-10-02 11:32:21 -0700553 if (swap_commutative(args[0], &args[4], &args[3])) {
554 args[5] = tcg_invert_cond(args[5]);
Richard Henderson5d8f5362012-09-21 10:13:38 -0700555 }
Richard Henderson1e484e62012-10-02 11:32:22 -0700556 break;
Richard Hendersond7156f72013-02-19 23:51:52 -0800557 CASE_OP_32_64(add2):
Richard Henderson1e484e62012-10-02 11:32:22 -0700558 swap_commutative(args[0], &args[2], &args[4]);
559 swap_commutative(args[1], &args[3], &args[5]);
560 break;
Richard Hendersond7156f72013-02-19 23:51:52 -0800561 CASE_OP_32_64(mulu2):
Richard Henderson4d3203f2013-02-19 23:51:53 -0800562 CASE_OP_32_64(muls2):
Richard Henderson14149682012-10-02 11:32:30 -0700563 swap_commutative(args[0], &args[2], &args[3]);
564 break;
Richard Henderson0bfcb862012-10-02 11:32:23 -0700565 case INDEX_op_brcond2_i32:
566 if (swap_commutative2(&args[0], &args[2])) {
567 args[4] = tcg_swap_cond(args[4]);
568 }
569 break;
570 case INDEX_op_setcond2_i32:
571 if (swap_commutative2(&args[1], &args[3])) {
572 args[5] = tcg_swap_cond(args[5]);
573 }
574 break;
Kirill Batuzov53108fb2011-07-07 16:37:14 +0400575 default:
576 break;
577 }
578
Aurelien Jarno01ee5282012-09-06 16:47:14 +0200579 /* Simplify expressions for "shift/rot r, 0, a => movi r, 0" */
580 switch (op) {
581 CASE_OP_32_64(shl):
582 CASE_OP_32_64(shr):
583 CASE_OP_32_64(sar):
584 CASE_OP_32_64(rotl):
585 CASE_OP_32_64(rotr):
586 if (temps[args[1]].state == TCG_TEMP_CONST
587 && temps[args[1]].val == 0) {
Evgeny Voevodin92414b32012-11-12 13:27:47 +0400588 s->gen_opc_buf[op_index] = op_to_movi(op);
Aurelien Jarnoe590d4e2012-09-11 12:31:21 +0200589 tcg_opt_gen_movi(gen_args, args[0], 0);
Aurelien Jarno01ee5282012-09-06 16:47:14 +0200590 args += 3;
591 gen_args += 2;
592 continue;
593 }
594 break;
595 default:
596 break;
597 }
598
Aurelien Jarno56e49432012-09-06 16:47:13 +0200599 /* Simplify expression for "op r, a, 0 => mov r, a" cases */
Kirill Batuzov53108fb2011-07-07 16:37:14 +0400600 switch (op) {
601 CASE_OP_32_64(add):
602 CASE_OP_32_64(sub):
Kirill Batuzov55c09752011-07-07 16:37:16 +0400603 CASE_OP_32_64(shl):
604 CASE_OP_32_64(shr):
605 CASE_OP_32_64(sar):
Richard Henderson25c4d9c2011-08-17 14:11:46 -0700606 CASE_OP_32_64(rotl):
607 CASE_OP_32_64(rotr):
Aurelien Jarno38ee1882012-09-06 16:47:14 +0200608 CASE_OP_32_64(or):
609 CASE_OP_32_64(xor):
Kirill Batuzov53108fb2011-07-07 16:37:14 +0400610 if (temps[args[1]].state == TCG_TEMP_CONST) {
611 /* Proceed with possible constant folding. */
612 break;
613 }
614 if (temps[args[2]].state == TCG_TEMP_CONST
615 && temps[args[2]].val == 0) {
Aurelien Jarnoe590d4e2012-09-11 12:31:21 +0200616 if (temps_are_copies(args[0], args[1])) {
Evgeny Voevodin92414b32012-11-12 13:27:47 +0400617 s->gen_opc_buf[op_index] = INDEX_op_nop;
Kirill Batuzov53108fb2011-07-07 16:37:14 +0400618 } else {
Evgeny Voevodin92414b32012-11-12 13:27:47 +0400619 s->gen_opc_buf[op_index] = op_to_mov(op);
Aurelien Jarnob80bb012012-09-11 12:26:23 +0200620 tcg_opt_gen_mov(s, gen_args, args[0], args[1]);
Kirill Batuzov53108fb2011-07-07 16:37:14 +0400621 gen_args += 2;
Kirill Batuzov53108fb2011-07-07 16:37:14 +0400622 }
Aurelien Jarnofedc0da2012-09-07 12:24:32 +0200623 args += 3;
Kirill Batuzov53108fb2011-07-07 16:37:14 +0400624 continue;
625 }
626 break;
Aurelien Jarno56e49432012-09-06 16:47:13 +0200627 default:
628 break;
629 }
630
Paolo Bonzini3a9d8b12013-01-11 15:42:52 -0800631 /* Simplify using known-zero bits */
632 mask = -1;
Paolo Bonzini633f6502013-01-11 15:42:53 -0800633 affected = -1;
Paolo Bonzini3a9d8b12013-01-11 15:42:52 -0800634 switch (op) {
635 CASE_OP_32_64(ext8s):
636 if ((temps[args[1]].mask & 0x80) != 0) {
637 break;
638 }
639 CASE_OP_32_64(ext8u):
640 mask = 0xff;
641 goto and_const;
642 CASE_OP_32_64(ext16s):
643 if ((temps[args[1]].mask & 0x8000) != 0) {
644 break;
645 }
646 CASE_OP_32_64(ext16u):
647 mask = 0xffff;
648 goto and_const;
649 case INDEX_op_ext32s_i64:
650 if ((temps[args[1]].mask & 0x80000000) != 0) {
651 break;
652 }
653 case INDEX_op_ext32u_i64:
654 mask = 0xffffffffU;
655 goto and_const;
656
657 CASE_OP_32_64(and):
658 mask = temps[args[2]].mask;
659 if (temps[args[2]].state == TCG_TEMP_CONST) {
660 and_const:
Paolo Bonzini633f6502013-01-11 15:42:53 -0800661 affected = temps[args[1]].mask & ~mask;
Paolo Bonzini3a9d8b12013-01-11 15:42:52 -0800662 }
663 mask = temps[args[1]].mask & mask;
664 break;
665
666 CASE_OP_32_64(sar):
667 if (temps[args[2]].state == TCG_TEMP_CONST) {
668 mask = ((tcg_target_long)temps[args[1]].mask
669 >> temps[args[2]].val);
670 }
671 break;
672
673 CASE_OP_32_64(shr):
674 if (temps[args[2]].state == TCG_TEMP_CONST) {
675 mask = temps[args[1]].mask >> temps[args[2]].val;
676 }
677 break;
678
679 CASE_OP_32_64(shl):
680 if (temps[args[2]].state == TCG_TEMP_CONST) {
681 mask = temps[args[1]].mask << temps[args[2]].val;
682 }
683 break;
684
685 CASE_OP_32_64(neg):
686 /* Set to 1 all bits to the left of the rightmost. */
687 mask = -(temps[args[1]].mask & -temps[args[1]].mask);
688 break;
689
690 CASE_OP_32_64(deposit):
691 tmp = ((1ull << args[4]) - 1);
692 mask = ((temps[args[1]].mask & ~(tmp << args[3]))
693 | ((temps[args[2]].mask & tmp) << args[3]));
694 break;
695
696 CASE_OP_32_64(or):
697 CASE_OP_32_64(xor):
698 mask = temps[args[1]].mask | temps[args[2]].mask;
699 break;
700
701 CASE_OP_32_64(setcond):
702 mask = 1;
703 break;
704
705 CASE_OP_32_64(movcond):
706 mask = temps[args[3]].mask | temps[args[4]].mask;
707 break;
708
709 default:
710 break;
711 }
712
Paolo Bonzini633f6502013-01-11 15:42:53 -0800713 if (mask == 0) {
714 assert(def->nb_oargs == 1);
715 s->gen_opc_buf[op_index] = op_to_movi(op);
716 tcg_opt_gen_movi(gen_args, args[0], 0);
717 args += def->nb_oargs + def->nb_iargs + def->nb_cargs;
718 gen_args += 2;
719 continue;
720 }
721 if (affected == 0) {
722 assert(def->nb_oargs == 1);
723 if (temps_are_copies(args[0], args[1])) {
724 s->gen_opc_buf[op_index] = INDEX_op_nop;
725 } else if (temps[args[1]].state != TCG_TEMP_CONST) {
726 s->gen_opc_buf[op_index] = op_to_mov(op);
727 tcg_opt_gen_mov(s, gen_args, args[0], args[1]);
728 gen_args += 2;
729 } else {
730 s->gen_opc_buf[op_index] = op_to_movi(op);
731 tcg_opt_gen_movi(gen_args, args[0], temps[args[1]].val);
732 gen_args += 2;
733 }
734 args += def->nb_iargs + 1;
735 continue;
736 }
737
Aurelien Jarno56e49432012-09-06 16:47:13 +0200738 /* Simplify expression for "op r, a, 0 => movi r, 0" cases */
739 switch (op) {
Aurelien Jarno61251c02012-09-06 16:47:14 +0200740 CASE_OP_32_64(and):
Kirill Batuzov53108fb2011-07-07 16:37:14 +0400741 CASE_OP_32_64(mul):
742 if ((temps[args[2]].state == TCG_TEMP_CONST
743 && temps[args[2]].val == 0)) {
Evgeny Voevodin92414b32012-11-12 13:27:47 +0400744 s->gen_opc_buf[op_index] = op_to_movi(op);
Aurelien Jarnoe590d4e2012-09-11 12:31:21 +0200745 tcg_opt_gen_movi(gen_args, args[0], 0);
Kirill Batuzov53108fb2011-07-07 16:37:14 +0400746 args += 3;
747 gen_args += 2;
748 continue;
749 }
750 break;
Aurelien Jarno56e49432012-09-06 16:47:13 +0200751 default:
752 break;
753 }
754
755 /* Simplify expression for "op r, a, a => mov r, a" cases */
756 switch (op) {
Kirill Batuzov9a810902011-07-07 16:37:15 +0400757 CASE_OP_32_64(or):
758 CASE_OP_32_64(and):
Aurelien Jarno0aba1c72012-09-18 19:11:32 +0200759 if (temps_are_copies(args[1], args[2])) {
Aurelien Jarnoe590d4e2012-09-11 12:31:21 +0200760 if (temps_are_copies(args[0], args[1])) {
Evgeny Voevodin92414b32012-11-12 13:27:47 +0400761 s->gen_opc_buf[op_index] = INDEX_op_nop;
Kirill Batuzov9a810902011-07-07 16:37:15 +0400762 } else {
Evgeny Voevodin92414b32012-11-12 13:27:47 +0400763 s->gen_opc_buf[op_index] = op_to_mov(op);
Aurelien Jarnob80bb012012-09-11 12:26:23 +0200764 tcg_opt_gen_mov(s, gen_args, args[0], args[1]);
Kirill Batuzov9a810902011-07-07 16:37:15 +0400765 gen_args += 2;
Kirill Batuzov9a810902011-07-07 16:37:15 +0400766 }
Aurelien Jarnofedc0da2012-09-07 12:24:32 +0200767 args += 3;
Kirill Batuzov9a810902011-07-07 16:37:15 +0400768 continue;
769 }
770 break;
Blue Swirlfe0de7a2011-07-30 19:18:32 +0000771 default:
772 break;
Kirill Batuzov53108fb2011-07-07 16:37:14 +0400773 }
774
Aurelien Jarno3c941932012-09-18 19:12:36 +0200775 /* Simplify expression for "op r, a, a => movi r, 0" cases */
776 switch (op) {
777 CASE_OP_32_64(sub):
778 CASE_OP_32_64(xor):
779 if (temps_are_copies(args[1], args[2])) {
Evgeny Voevodin92414b32012-11-12 13:27:47 +0400780 s->gen_opc_buf[op_index] = op_to_movi(op);
Aurelien Jarno3c941932012-09-18 19:12:36 +0200781 tcg_opt_gen_movi(gen_args, args[0], 0);
782 gen_args += 2;
783 args += 3;
784 continue;
785 }
786 break;
787 default:
788 break;
789 }
790
Kirill Batuzov22613af2011-07-07 16:37:13 +0400791 /* Propagate constants through copy operations and do constant
792 folding. Constants will be substituted to arguments by register
793 allocator where needed and possible. Also detect copies. */
Kirill Batuzov8f2e8c02011-07-07 16:37:12 +0400794 switch (op) {
Kirill Batuzov22613af2011-07-07 16:37:13 +0400795 CASE_OP_32_64(mov):
Aurelien Jarnoe590d4e2012-09-11 12:31:21 +0200796 if (temps_are_copies(args[0], args[1])) {
Kirill Batuzov22613af2011-07-07 16:37:13 +0400797 args += 2;
Evgeny Voevodin92414b32012-11-12 13:27:47 +0400798 s->gen_opc_buf[op_index] = INDEX_op_nop;
Kirill Batuzov22613af2011-07-07 16:37:13 +0400799 break;
800 }
801 if (temps[args[1]].state != TCG_TEMP_CONST) {
Aurelien Jarnob80bb012012-09-11 12:26:23 +0200802 tcg_opt_gen_mov(s, gen_args, args[0], args[1]);
Kirill Batuzov22613af2011-07-07 16:37:13 +0400803 gen_args += 2;
804 args += 2;
805 break;
806 }
807 /* Source argument is constant. Rewrite the operation and
808 let movi case handle it. */
809 op = op_to_movi(op);
Evgeny Voevodin92414b32012-11-12 13:27:47 +0400810 s->gen_opc_buf[op_index] = op;
Kirill Batuzov22613af2011-07-07 16:37:13 +0400811 args[1] = temps[args[1]].val;
812 /* fallthrough */
813 CASE_OP_32_64(movi):
Aurelien Jarnoe590d4e2012-09-11 12:31:21 +0200814 tcg_opt_gen_movi(gen_args, args[0], args[1]);
Kirill Batuzov22613af2011-07-07 16:37:13 +0400815 gen_args += 2;
816 args += 2;
817 break;
Richard Henderson6e14e912012-10-02 11:32:24 -0700818
Kirill Batuzova640f032011-07-07 16:37:17 +0400819 CASE_OP_32_64(not):
Richard Hendersoncb25c802011-08-17 14:11:47 -0700820 CASE_OP_32_64(neg):
Richard Henderson25c4d9c2011-08-17 14:11:46 -0700821 CASE_OP_32_64(ext8s):
822 CASE_OP_32_64(ext8u):
823 CASE_OP_32_64(ext16s):
824 CASE_OP_32_64(ext16u):
Kirill Batuzova640f032011-07-07 16:37:17 +0400825 case INDEX_op_ext32s_i64:
826 case INDEX_op_ext32u_i64:
Kirill Batuzova640f032011-07-07 16:37:17 +0400827 if (temps[args[1]].state == TCG_TEMP_CONST) {
Evgeny Voevodin92414b32012-11-12 13:27:47 +0400828 s->gen_opc_buf[op_index] = op_to_movi(op);
Kirill Batuzova640f032011-07-07 16:37:17 +0400829 tmp = do_constant_folding(op, temps[args[1]].val, 0);
Aurelien Jarnoe590d4e2012-09-11 12:31:21 +0200830 tcg_opt_gen_movi(gen_args, args[0], tmp);
Richard Henderson6e14e912012-10-02 11:32:24 -0700831 gen_args += 2;
832 args += 2;
833 break;
Kirill Batuzova640f032011-07-07 16:37:17 +0400834 }
Richard Henderson6e14e912012-10-02 11:32:24 -0700835 goto do_default;
836
Kirill Batuzov53108fb2011-07-07 16:37:14 +0400837 CASE_OP_32_64(add):
838 CASE_OP_32_64(sub):
839 CASE_OP_32_64(mul):
Kirill Batuzov9a810902011-07-07 16:37:15 +0400840 CASE_OP_32_64(or):
841 CASE_OP_32_64(and):
842 CASE_OP_32_64(xor):
Kirill Batuzov55c09752011-07-07 16:37:16 +0400843 CASE_OP_32_64(shl):
844 CASE_OP_32_64(shr):
845 CASE_OP_32_64(sar):
Richard Henderson25c4d9c2011-08-17 14:11:46 -0700846 CASE_OP_32_64(rotl):
847 CASE_OP_32_64(rotr):
Richard Hendersoncb25c802011-08-17 14:11:47 -0700848 CASE_OP_32_64(andc):
849 CASE_OP_32_64(orc):
850 CASE_OP_32_64(eqv):
851 CASE_OP_32_64(nand):
852 CASE_OP_32_64(nor):
Kirill Batuzov53108fb2011-07-07 16:37:14 +0400853 if (temps[args[1]].state == TCG_TEMP_CONST
854 && temps[args[2]].state == TCG_TEMP_CONST) {
Evgeny Voevodin92414b32012-11-12 13:27:47 +0400855 s->gen_opc_buf[op_index] = op_to_movi(op);
Kirill Batuzov53108fb2011-07-07 16:37:14 +0400856 tmp = do_constant_folding(op, temps[args[1]].val,
857 temps[args[2]].val);
Aurelien Jarnoe590d4e2012-09-11 12:31:21 +0200858 tcg_opt_gen_movi(gen_args, args[0], tmp);
Kirill Batuzov53108fb2011-07-07 16:37:14 +0400859 gen_args += 2;
Richard Henderson6e14e912012-10-02 11:32:24 -0700860 args += 3;
861 break;
Kirill Batuzov53108fb2011-07-07 16:37:14 +0400862 }
Richard Henderson6e14e912012-10-02 11:32:24 -0700863 goto do_default;
864
Aurelien Jarno7ef55fc2012-09-21 11:07:29 +0200865 CASE_OP_32_64(deposit):
866 if (temps[args[1]].state == TCG_TEMP_CONST
867 && temps[args[2]].state == TCG_TEMP_CONST) {
Evgeny Voevodin92414b32012-11-12 13:27:47 +0400868 s->gen_opc_buf[op_index] = op_to_movi(op);
Aurelien Jarno7ef55fc2012-09-21 11:07:29 +0200869 tmp = ((1ull << args[4]) - 1);
870 tmp = (temps[args[1]].val & ~(tmp << args[3]))
871 | ((temps[args[2]].val & tmp) << args[3]);
872 tcg_opt_gen_movi(gen_args, args[0], tmp);
873 gen_args += 2;
Richard Henderson6e14e912012-10-02 11:32:24 -0700874 args += 5;
875 break;
Aurelien Jarno7ef55fc2012-09-21 11:07:29 +0200876 }
Richard Henderson6e14e912012-10-02 11:32:24 -0700877 goto do_default;
878
Aurelien Jarnof8dd19e2012-09-06 16:47:14 +0200879 CASE_OP_32_64(setcond):
Aurelien Jarnob336ceb2012-09-18 19:37:00 +0200880 tmp = do_constant_folding_cond(op, args[1], args[2], args[3]);
881 if (tmp != 2) {
Evgeny Voevodin92414b32012-11-12 13:27:47 +0400882 s->gen_opc_buf[op_index] = op_to_movi(op);
Aurelien Jarnoe590d4e2012-09-11 12:31:21 +0200883 tcg_opt_gen_movi(gen_args, args[0], tmp);
Aurelien Jarnof8dd19e2012-09-06 16:47:14 +0200884 gen_args += 2;
Richard Henderson6e14e912012-10-02 11:32:24 -0700885 args += 4;
886 break;
Aurelien Jarnof8dd19e2012-09-06 16:47:14 +0200887 }
Richard Henderson6e14e912012-10-02 11:32:24 -0700888 goto do_default;
889
Aurelien Jarnofbeaa262012-09-06 16:47:14 +0200890 CASE_OP_32_64(brcond):
Aurelien Jarnob336ceb2012-09-18 19:37:00 +0200891 tmp = do_constant_folding_cond(op, args[0], args[1], args[2]);
892 if (tmp != 2) {
893 if (tmp) {
Paolo Bonzinid193a142013-01-11 15:42:51 -0800894 reset_all_temps(nb_temps);
Evgeny Voevodin92414b32012-11-12 13:27:47 +0400895 s->gen_opc_buf[op_index] = INDEX_op_br;
Aurelien Jarnofbeaa262012-09-06 16:47:14 +0200896 gen_args[0] = args[3];
897 gen_args += 1;
Aurelien Jarnofbeaa262012-09-06 16:47:14 +0200898 } else {
Evgeny Voevodin92414b32012-11-12 13:27:47 +0400899 s->gen_opc_buf[op_index] = INDEX_op_nop;
Aurelien Jarnofbeaa262012-09-06 16:47:14 +0200900 }
Richard Henderson6e14e912012-10-02 11:32:24 -0700901 args += 4;
902 break;
Aurelien Jarnofbeaa262012-09-06 16:47:14 +0200903 }
Richard Henderson6e14e912012-10-02 11:32:24 -0700904 goto do_default;
905
Richard Hendersonfa01a202012-09-21 10:13:37 -0700906 CASE_OP_32_64(movcond):
Aurelien Jarnob336ceb2012-09-18 19:37:00 +0200907 tmp = do_constant_folding_cond(op, args[1], args[2], args[5]);
908 if (tmp != 2) {
Aurelien Jarnoe590d4e2012-09-11 12:31:21 +0200909 if (temps_are_copies(args[0], args[4-tmp])) {
Evgeny Voevodin92414b32012-11-12 13:27:47 +0400910 s->gen_opc_buf[op_index] = INDEX_op_nop;
Richard Hendersonfa01a202012-09-21 10:13:37 -0700911 } else if (temps[args[4-tmp]].state == TCG_TEMP_CONST) {
Evgeny Voevodin92414b32012-11-12 13:27:47 +0400912 s->gen_opc_buf[op_index] = op_to_movi(op);
Aurelien Jarnoe590d4e2012-09-11 12:31:21 +0200913 tcg_opt_gen_movi(gen_args, args[0], temps[args[4-tmp]].val);
Richard Hendersonfa01a202012-09-21 10:13:37 -0700914 gen_args += 2;
915 } else {
Evgeny Voevodin92414b32012-11-12 13:27:47 +0400916 s->gen_opc_buf[op_index] = op_to_mov(op);
Aurelien Jarnoe590d4e2012-09-11 12:31:21 +0200917 tcg_opt_gen_mov(s, gen_args, args[0], args[4-tmp]);
Richard Hendersonfa01a202012-09-21 10:13:37 -0700918 gen_args += 2;
919 }
Richard Henderson6e14e912012-10-02 11:32:24 -0700920 args += 6;
921 break;
Richard Hendersonfa01a202012-09-21 10:13:37 -0700922 }
Richard Henderson6e14e912012-10-02 11:32:24 -0700923 goto do_default;
924
Richard Henderson212c3282012-10-02 11:32:28 -0700925 case INDEX_op_add2_i32:
926 case INDEX_op_sub2_i32:
927 if (temps[args[2]].state == TCG_TEMP_CONST
928 && temps[args[3]].state == TCG_TEMP_CONST
929 && temps[args[4]].state == TCG_TEMP_CONST
930 && temps[args[5]].state == TCG_TEMP_CONST) {
931 uint32_t al = temps[args[2]].val;
932 uint32_t ah = temps[args[3]].val;
933 uint32_t bl = temps[args[4]].val;
934 uint32_t bh = temps[args[5]].val;
935 uint64_t a = ((uint64_t)ah << 32) | al;
936 uint64_t b = ((uint64_t)bh << 32) | bl;
937 TCGArg rl, rh;
938
939 if (op == INDEX_op_add2_i32) {
940 a += b;
941 } else {
942 a -= b;
943 }
944
945 /* We emit the extra nop when we emit the add2/sub2. */
Evgeny Voevodin92414b32012-11-12 13:27:47 +0400946 assert(s->gen_opc_buf[op_index + 1] == INDEX_op_nop);
Richard Henderson212c3282012-10-02 11:32:28 -0700947
948 rl = args[0];
949 rh = args[1];
Evgeny Voevodin92414b32012-11-12 13:27:47 +0400950 s->gen_opc_buf[op_index] = INDEX_op_movi_i32;
951 s->gen_opc_buf[++op_index] = INDEX_op_movi_i32;
Richard Henderson212c3282012-10-02 11:32:28 -0700952 tcg_opt_gen_movi(&gen_args[0], rl, (uint32_t)a);
953 tcg_opt_gen_movi(&gen_args[2], rh, (uint32_t)(a >> 32));
954 gen_args += 4;
955 args += 6;
956 break;
957 }
958 goto do_default;
959
Richard Henderson14149682012-10-02 11:32:30 -0700960 case INDEX_op_mulu2_i32:
961 if (temps[args[2]].state == TCG_TEMP_CONST
962 && temps[args[3]].state == TCG_TEMP_CONST) {
963 uint32_t a = temps[args[2]].val;
964 uint32_t b = temps[args[3]].val;
965 uint64_t r = (uint64_t)a * b;
966 TCGArg rl, rh;
967
968 /* We emit the extra nop when we emit the mulu2. */
Evgeny Voevodin92414b32012-11-12 13:27:47 +0400969 assert(s->gen_opc_buf[op_index + 1] == INDEX_op_nop);
Richard Henderson14149682012-10-02 11:32:30 -0700970
971 rl = args[0];
972 rh = args[1];
Evgeny Voevodin92414b32012-11-12 13:27:47 +0400973 s->gen_opc_buf[op_index] = INDEX_op_movi_i32;
974 s->gen_opc_buf[++op_index] = INDEX_op_movi_i32;
Richard Henderson14149682012-10-02 11:32:30 -0700975 tcg_opt_gen_movi(&gen_args[0], rl, (uint32_t)r);
976 tcg_opt_gen_movi(&gen_args[2], rh, (uint32_t)(r >> 32));
977 gen_args += 4;
978 args += 4;
979 break;
980 }
981 goto do_default;
982
Richard Hendersonbc1473e2012-10-02 11:32:25 -0700983 case INDEX_op_brcond2_i32:
Richard Henderson6c4382f2012-10-02 11:32:27 -0700984 tmp = do_constant_folding_cond2(&args[0], &args[2], args[4]);
985 if (tmp != 2) {
986 if (tmp) {
Paolo Bonzinid193a142013-01-11 15:42:51 -0800987 reset_all_temps(nb_temps);
Evgeny Voevodin92414b32012-11-12 13:27:47 +0400988 s->gen_opc_buf[op_index] = INDEX_op_br;
Richard Henderson6c4382f2012-10-02 11:32:27 -0700989 gen_args[0] = args[5];
990 gen_args += 1;
991 } else {
Evgeny Voevodin92414b32012-11-12 13:27:47 +0400992 s->gen_opc_buf[op_index] = INDEX_op_nop;
Richard Henderson6c4382f2012-10-02 11:32:27 -0700993 }
994 } else if ((args[4] == TCG_COND_LT || args[4] == TCG_COND_GE)
995 && temps[args[2]].state == TCG_TEMP_CONST
996 && temps[args[3]].state == TCG_TEMP_CONST
997 && temps[args[2]].val == 0
998 && temps[args[3]].val == 0) {
999 /* Simplify LT/GE comparisons vs zero to a single compare
1000 vs the high word of the input. */
Paolo Bonzinid193a142013-01-11 15:42:51 -08001001 reset_all_temps(nb_temps);
Evgeny Voevodin92414b32012-11-12 13:27:47 +04001002 s->gen_opc_buf[op_index] = INDEX_op_brcond_i32;
Richard Hendersonbc1473e2012-10-02 11:32:25 -07001003 gen_args[0] = args[1];
1004 gen_args[1] = args[3];
1005 gen_args[2] = args[4];
1006 gen_args[3] = args[5];
1007 gen_args += 4;
Richard Henderson6c4382f2012-10-02 11:32:27 -07001008 } else {
1009 goto do_default;
Richard Hendersonbc1473e2012-10-02 11:32:25 -07001010 }
Richard Henderson6c4382f2012-10-02 11:32:27 -07001011 args += 6;
1012 break;
Richard Hendersonbc1473e2012-10-02 11:32:25 -07001013
1014 case INDEX_op_setcond2_i32:
Richard Henderson6c4382f2012-10-02 11:32:27 -07001015 tmp = do_constant_folding_cond2(&args[1], &args[3], args[5]);
1016 if (tmp != 2) {
Evgeny Voevodin92414b32012-11-12 13:27:47 +04001017 s->gen_opc_buf[op_index] = INDEX_op_movi_i32;
Richard Henderson6c4382f2012-10-02 11:32:27 -07001018 tcg_opt_gen_movi(gen_args, args[0], tmp);
1019 gen_args += 2;
1020 } else if ((args[5] == TCG_COND_LT || args[5] == TCG_COND_GE)
1021 && temps[args[3]].state == TCG_TEMP_CONST
1022 && temps[args[4]].state == TCG_TEMP_CONST
1023 && temps[args[3]].val == 0
1024 && temps[args[4]].val == 0) {
1025 /* Simplify LT/GE comparisons vs zero to a single compare
1026 vs the high word of the input. */
Evgeny Voevodin92414b32012-11-12 13:27:47 +04001027 s->gen_opc_buf[op_index] = INDEX_op_setcond_i32;
Richard Hendersonbc1473e2012-10-02 11:32:25 -07001028 gen_args[0] = args[0];
1029 gen_args[1] = args[2];
1030 gen_args[2] = args[4];
1031 gen_args[3] = args[5];
1032 gen_args += 4;
Richard Henderson6c4382f2012-10-02 11:32:27 -07001033 } else {
1034 goto do_default;
Richard Hendersonbc1473e2012-10-02 11:32:25 -07001035 }
Richard Henderson6c4382f2012-10-02 11:32:27 -07001036 args += 6;
1037 break;
Richard Hendersonbc1473e2012-10-02 11:32:25 -07001038
Kirill Batuzov8f2e8c02011-07-07 16:37:12 +04001039 case INDEX_op_call:
Kirill Batuzov22613af2011-07-07 16:37:13 +04001040 nb_call_args = (args[0] >> 16) + (args[0] & 0xffff);
Aurelien Jarno78505272012-10-09 21:53:08 +02001041 if (!(args[nb_call_args + 1] & (TCG_CALL_NO_READ_GLOBALS |
1042 TCG_CALL_NO_WRITE_GLOBALS))) {
Kirill Batuzov22613af2011-07-07 16:37:13 +04001043 for (i = 0; i < nb_globals; i++) {
Aurelien Jarnoe590d4e2012-09-11 12:31:21 +02001044 reset_temp(i);
Kirill Batuzov22613af2011-07-07 16:37:13 +04001045 }
1046 }
1047 for (i = 0; i < (args[0] >> 16); i++) {
Aurelien Jarnoe590d4e2012-09-11 12:31:21 +02001048 reset_temp(args[i + 1]);
Kirill Batuzov22613af2011-07-07 16:37:13 +04001049 }
1050 i = nb_call_args + 3;
Kirill Batuzov8f2e8c02011-07-07 16:37:12 +04001051 while (i) {
1052 *gen_args = *args;
1053 args++;
1054 gen_args++;
1055 i--;
1056 }
1057 break;
Richard Henderson6e14e912012-10-02 11:32:24 -07001058
Kirill Batuzov8f2e8c02011-07-07 16:37:12 +04001059 default:
Richard Henderson6e14e912012-10-02 11:32:24 -07001060 do_default:
1061 /* Default case: we know nothing about operation (or were unable
1062 to compute the operation result) so no propagation is done.
1063 We trash everything if the operation is the end of a basic
Paolo Bonzini3a9d8b12013-01-11 15:42:52 -08001064 block, otherwise we only trash the output args. "mask" is
1065 the non-zero bits mask for the first output arg. */
Aurelien Jarnoa2550662012-09-19 21:40:30 +02001066 if (def->flags & TCG_OPF_BB_END) {
Paolo Bonzinid193a142013-01-11 15:42:51 -08001067 reset_all_temps(nb_temps);
Aurelien Jarnoa2550662012-09-19 21:40:30 +02001068 } else {
1069 for (i = 0; i < def->nb_oargs; i++) {
Aurelien Jarnoe590d4e2012-09-11 12:31:21 +02001070 reset_temp(args[i]);
Aurelien Jarnoa2550662012-09-19 21:40:30 +02001071 }
Kirill Batuzov22613af2011-07-07 16:37:13 +04001072 }
Kirill Batuzov8f2e8c02011-07-07 16:37:12 +04001073 for (i = 0; i < def->nb_args; i++) {
1074 gen_args[i] = args[i];
1075 }
1076 args += def->nb_args;
1077 gen_args += def->nb_args;
1078 break;
1079 }
1080 }
1081
1082 return gen_args;
1083}
1084
1085TCGArg *tcg_optimize(TCGContext *s, uint16_t *tcg_opc_ptr,
1086 TCGArg *args, TCGOpDef *tcg_op_defs)
1087{
1088 TCGArg *res;
1089 res = tcg_constant_folding(s, tcg_opc_ptr, args, tcg_op_defs);
1090 return res;
1091}