iropt.c 184 KB
Newer Older
Christian Würdig's avatar
Christian Würdig committed
1
/*
Michael Beck's avatar
Michael Beck committed
2
 * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
Christian Würdig's avatar
Christian Würdig committed
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 *
 * This file is part of libFirm.
 *
 * This file may be distributed and/or modified under the terms of the
 * GNU General Public License version 2 as published by the Free Software
 * Foundation and appearing in the file LICENSE.GPL included in the
 * packaging of this file.
 *
 * Licensees holding valid libFirm Professional Edition licenses may use
 * this file in accordance with the libFirm Commercial License.
 * Agreement provided with the Software.
 *
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE.
 */

Matthias Braun's avatar
Matthias Braun committed
20
21
22
23
24
/**
 * @file
 * @brief   iropt --- optimizations intertwined with IR construction.
 * @author  Christian Schaefer, Goetz Lindenmaier, Michael Beck
 * @version $Id$
Götz Lindenmaier's avatar
Götz Lindenmaier committed
25
 */
Matthias Braun's avatar
Matthias Braun committed
26
#include "config.h"
Michael Beck's avatar
Michael Beck committed
27
28

#include <string.h>
29
#include <stdbool.h>
Boris Boesler's avatar
added    
Boris Boesler committed
30

Michael Beck's avatar
Michael Beck committed
31
32
33
34
35
36
37
#include "irnode_t.h"
#include "irgraph_t.h"
#include "iredges_t.h"
#include "irmode_t.h"
#include "iropt_t.h"
#include "ircons_t.h"
#include "irgmod.h"
38
#include "irverify.h"
Michael Beck's avatar
Michael Beck committed
39
40
41
42
43
44
45
46
#include "tv_t.h"
#include "dbginfo_t.h"
#include "iropt_dbg.h"
#include "irflag_t.h"
#include "irhooks.h"
#include "irarch.h"
#include "hashptr.h"
#include "opt_confirms.h"
47
#include "opt_polymorphy.h"
Michael Beck's avatar
Michael Beck committed
48
#include "irtools.h"
49
#include "irhooks.h"
50
#include "array_t.h"
51
52
#include "vrp.h"
#include "firm_types.h"
53
#include "bitfiddle.h"
54
#include "be.h"
Christian Schäfer's avatar
Christian Schäfer committed
55

Götz Lindenmaier's avatar
Götz Lindenmaier committed
56
/* Make types visible to allow most efficient access */
57
#include "entity_t.h"
Götz Lindenmaier's avatar
Götz Lindenmaier committed
58

59
60
61
/**
 * Returns the tarval of a Const node or tarval_bad for all other nodes.
 */
62
63
static tarval *default_value_of(const ir_node *n)
{
64
65
66
67
68
69
70
71
	if (is_Const(n))
		return get_Const_tarval(n); /* might return tarval_bad */
	else
		return tarval_bad;
}

value_of_func value_of_ptr = default_value_of;

Michael Beck's avatar
Michael Beck committed
72
/* * Set a new value_of function. */
73
74
void set_value_of_func(value_of_func func)
{
75
76
77
78
79
80
	if (func != NULL)
		value_of_ptr = func;
	else
		value_of_ptr = default_value_of;
}

81
/**
82
 * Return the value of a Constant.
83
 */
84
85
static tarval *computed_value_Const(const ir_node *n)
{
Michael Beck's avatar
Michael Beck committed
86
	return get_Const_tarval(n);
87
}  /* computed_value_Const */
Christian Schäfer's avatar
Christian Schäfer committed
88

89
/**
Michael Beck's avatar
Michael Beck committed
90
 * Return the value of a 'sizeof', 'alignof' or 'offsetof' SymConst.
91
 */
92
93
static tarval *computed_value_SymConst(const ir_node *n)
{
Michael Beck's avatar
Michael Beck committed
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
	ir_type   *type;
	ir_entity *ent;

	switch (get_SymConst_kind(n)) {
	case symconst_type_size:
		type = get_SymConst_type(n);
		if (get_type_state(type) == layout_fixed)
			return new_tarval_from_long(get_type_size_bytes(type), get_irn_mode(n));
		break;
	case symconst_type_align:
		type = get_SymConst_type(n);
		if (get_type_state(type) == layout_fixed)
			return new_tarval_from_long(get_type_alignment_bytes(type), get_irn_mode(n));
		break;
	case symconst_ofs_ent:
		ent  = get_SymConst_entity(n);
		type = get_entity_owner(ent);
		if (get_type_state(type) == layout_fixed)
			return new_tarval_from_long(get_entity_offset(ent), get_irn_mode(n));
		break;
	default:
		break;
	}
	return tarval_bad;
118
}  /* computed_value_SymConst */
Christian Schäfer's avatar
Christian Schäfer committed
119

Michael Beck's avatar
Michael Beck committed
120
/**
121
 * Return the value of an Add.
Michael Beck's avatar
Michael Beck committed
122
 */
123
124
static tarval *computed_value_Add(const ir_node *n)
{
Michael Beck's avatar
Michael Beck committed
125
126
	ir_node *a = get_Add_left(n);
	ir_node *b = get_Add_right(n);
Christian Schäfer's avatar
Christian Schäfer committed
127

Michael Beck's avatar
Michael Beck committed
128
129
	tarval *ta = value_of(a);
	tarval *tb = value_of(b);
130

131
	if ((ta != tarval_bad) && (tb != tarval_bad))
Michael Beck's avatar
Michael Beck committed
132
		return tarval_add(ta, tb);
133

Michael Beck's avatar
Michael Beck committed
134
	return tarval_bad;
135
}  /* computed_value_Add */
Christian Schäfer's avatar
Christian Schäfer committed
136

Michael Beck's avatar
Michael Beck committed
137
/**
138
 * Return the value of a Sub.
Michael Beck's avatar
Michael Beck committed
139
140
 * Special case: a - a
 */
141
142
static tarval *computed_value_Sub(const ir_node *n)
{
143
144
145
146
147
	ir_mode *mode = get_irn_mode(n);
	ir_node *a    = get_Sub_left(n);
	ir_node *b    = get_Sub_right(n);
	tarval  *ta;
	tarval  *tb;
Christian Schäfer's avatar
Christian Schäfer committed
148

149
150
151
152
153
154
	/* NaN - NaN != 0 */
	if (! mode_is_float(mode)) {
		/* a - a = 0 */
		if (a == b)
			return get_mode_null(mode);
	}
Michael Beck's avatar
Michael Beck committed
155

Michael Beck's avatar
Michael Beck committed
156
157
	ta = value_of(a);
	tb = value_of(b);
158

159
160
	if ((ta != tarval_bad) && (tb != tarval_bad))
		return tarval_sub(ta, tb, mode);
161

Michael Beck's avatar
Michael Beck committed
162
	return tarval_bad;
163
}  /* computed_value_Sub */
164

165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
/**
 * Return the value of a Carry.
 * Special : a op 0, 0 op b
 */
static tarval *computed_value_Carry(const ir_node *n)
{
	ir_node *a = get_binop_left(n);
	ir_node *b = get_binop_right(n);
	ir_mode *m = get_irn_mode(n);

	tarval *ta = value_of(a);
	tarval *tb = value_of(b);

	if ((ta != tarval_bad) && (tb != tarval_bad)) {
		tarval_add(ta, tb);
		return tarval_carry() ? get_mode_one(m) : get_mode_null(m);
	} else {
		if (tarval_is_null(ta) || tarval_is_null(tb))
			return get_mode_null(m);
	}
	return tarval_bad;
}  /* computed_value_Carry */

/**
 * Return the value of a Borrow.
 * Special : a op 0
 */
static tarval *computed_value_Borrow(const ir_node *n)
{
	ir_node *a = get_binop_left(n);
	ir_node *b = get_binop_right(n);
	ir_mode *m = get_irn_mode(n);

	tarval *ta = value_of(a);
	tarval *tb = value_of(b);

	if ((ta != tarval_bad) && (tb != tarval_bad)) {
		return tarval_cmp(ta, tb) == pn_Cmp_Lt ? get_mode_one(m) : get_mode_null(m);
	} else if (tarval_is_null(ta)) {
		return get_mode_null(m);
	}
	return tarval_bad;
}  /* computed_value_Borrow */

Michael Beck's avatar
Michael Beck committed
209
/**
210
 * Return the value of an unary Minus.
Michael Beck's avatar
Michael Beck committed
211
 */
212
213
static tarval *computed_value_Minus(const ir_node *n)
{
Michael Beck's avatar
Michael Beck committed
214
215
	ir_node *a = get_Minus_op(n);
	tarval *ta = value_of(a);
216

Michael Beck's avatar
Michael Beck committed
217
	if (ta != tarval_bad)
Michael Beck's avatar
Michael Beck committed
218
		return tarval_neg(ta);
219

Michael Beck's avatar
Michael Beck committed
220
	return tarval_bad;
221
}  /* computed_value_Minus */
222

Michael Beck's avatar
Michael Beck committed
223
/**
224
 * Return the value of a Mul.
Michael Beck's avatar
Michael Beck committed
225
 */
226
227
static tarval *computed_value_Mul(const ir_node *n)
{
Michael Beck's avatar
Michael Beck committed
228
229
	ir_node *a = get_Mul_left(n);
	ir_node *b = get_Mul_right(n);
Michael Beck's avatar
Michael Beck committed
230
	ir_mode *mode;
Michael Beck's avatar
Michael Beck committed
231
232
233
234

	tarval *ta = value_of(a);
	tarval *tb = value_of(b);

Michael Beck's avatar
Michael Beck committed
235
236
237
238
239
240
241
242
	mode = get_irn_mode(n);
	if (mode != get_irn_mode(a)) {
		/* n * n = 2n bit multiplication */
		ta = tarval_convert_to(ta, mode);
		tb = tarval_convert_to(tb, mode);
	}

	if (ta != tarval_bad && tb != tarval_bad) {
Michael Beck's avatar
Michael Beck committed
243
244
		return tarval_mul(ta, tb);
	} else {
245
246
247
248
249
250
251
252
		/* a * 0 != 0 if a == NaN or a == Inf */
		if (!mode_is_float(mode)) {
			/* a*0 = 0 or 0*b = 0 */
			if (ta == get_mode_null(mode))
				return ta;
			if (tb == get_mode_null(mode))
				return tb;
		}
Michael Beck's avatar
Michael Beck committed
253
254
	}
	return tarval_bad;
255
}  /* computed_value_Mul */
256

Michael Beck's avatar
Michael Beck committed
257
/**
258
 * Return the value of an And.
Michael Beck's avatar
Michael Beck committed
259
260
 * Special case: a & 0, 0 & b
 */
261
262
static tarval *computed_value_And(const ir_node *n)
{
Michael Beck's avatar
Michael Beck committed
263
264
265
266
267
268
269
270
271
	ir_node *a = get_And_left(n);
	ir_node *b = get_And_right(n);

	tarval *ta = value_of(a);
	tarval *tb = value_of(b);

	if ((ta != tarval_bad) && (tb != tarval_bad)) {
		return tarval_and (ta, tb);
	} else {
272
273
		if (tarval_is_null(ta)) return ta;
		if (tarval_is_null(tb)) return tb;
Michael Beck's avatar
Michael Beck committed
274
275
	}
	return tarval_bad;
276
}  /* computed_value_And */
277

Michael Beck's avatar
Michael Beck committed
278
/**
279
 * Return the value of an Or.
Michael Beck's avatar
Michael Beck committed
280
281
 * Special case: a | 1...1, 1...1 | b
 */
282
283
static tarval *computed_value_Or(const ir_node *n)
{
Michael Beck's avatar
Michael Beck committed
284
285
286
287
288
289
290
291
292
	ir_node *a = get_Or_left(n);
	ir_node *b = get_Or_right(n);

	tarval *ta = value_of(a);
	tarval *tb = value_of(b);

	if ((ta != tarval_bad) && (tb != tarval_bad)) {
		return tarval_or (ta, tb);
	} else {
293
294
		if (tarval_is_all_one(ta)) return ta;
		if (tarval_is_all_one(tb)) return tb;
Michael Beck's avatar
Michael Beck committed
295
296
	}
	return tarval_bad;
297
}  /* computed_value_Or */
298

Michael Beck's avatar
Michael Beck committed
299
/**
300
 * Return the value of an Eor.
Michael Beck's avatar
Michael Beck committed
301
 */
302
303
static tarval *computed_value_Eor(const ir_node *n)
{
Michael Beck's avatar
Michael Beck committed
304
305
	ir_node *a = get_Eor_left(n);
	ir_node *b = get_Eor_right(n);
306

Michael Beck's avatar
Michael Beck committed
307
	tarval *ta, *tb;
Michael Beck's avatar
Michael Beck committed
308

Michael Beck's avatar
Michael Beck committed
309
310
	if (a == b)
		return get_mode_null(get_irn_mode(n));
Michael Beck's avatar
Michael Beck committed
311

Michael Beck's avatar
Michael Beck committed
312
313
	ta = value_of(a);
	tb = value_of(b);
314

Michael Beck's avatar
Michael Beck committed
315
	if ((ta != tarval_bad) && (tb != tarval_bad)) {
316
		return tarval_eor(ta, tb);
Michael Beck's avatar
Michael Beck committed
317
318
	}
	return tarval_bad;
319
}  /* computed_value_Eor */
320

Michael Beck's avatar
Michael Beck committed
321
/**
322
 * Return the value of a Not.
Michael Beck's avatar
Michael Beck committed
323
 */
324
325
static tarval *computed_value_Not(const ir_node *n)
{
Michael Beck's avatar
Michael Beck committed
326
327
	ir_node *a = get_Not_op(n);
	tarval *ta = value_of(a);
328

Michael Beck's avatar
Michael Beck committed
329
330
	if (ta != tarval_bad)
		return tarval_not(ta);
331

Michael Beck's avatar
Michael Beck committed
332
	return tarval_bad;
333
}  /* computed_value_Not */
334

Michael Beck's avatar
Michael Beck committed
335
/**
336
 * Return the value of a Shl.
Michael Beck's avatar
Michael Beck committed
337
 */
338
339
static tarval *computed_value_Shl(const ir_node *n)
{
Michael Beck's avatar
Michael Beck committed
340
341
	ir_node *a = get_Shl_left(n);
	ir_node *b = get_Shl_right(n);
342

Michael Beck's avatar
Michael Beck committed
343
344
	tarval *ta = value_of(a);
	tarval *tb = value_of(b);
345

Michael Beck's avatar
Michael Beck committed
346
	if ((ta != tarval_bad) && (tb != tarval_bad)) {
347
		return tarval_shl(ta, tb);
Michael Beck's avatar
Michael Beck committed
348
349
	}
	return tarval_bad;
350
}  /* computed_value_Shl */
351

Michael Beck's avatar
Michael Beck committed
352
/**
353
 * Return the value of a Shr.
Michael Beck's avatar
Michael Beck committed
354
 */
355
356
static tarval *computed_value_Shr(const ir_node *n)
{
Michael Beck's avatar
Michael Beck committed
357
358
	ir_node *a = get_Shr_left(n);
	ir_node *b = get_Shr_right(n);
359

Michael Beck's avatar
Michael Beck committed
360
361
	tarval *ta = value_of(a);
	tarval *tb = value_of(b);
362

Michael Beck's avatar
Michael Beck committed
363
	if ((ta != tarval_bad) && (tb != tarval_bad)) {
364
		return tarval_shr(ta, tb);
Michael Beck's avatar
Michael Beck committed
365
366
	}
	return tarval_bad;
367
}  /* computed_value_Shr */
368

Michael Beck's avatar
Michael Beck committed
369
/**
370
 * Return the value of a Shrs.
Michael Beck's avatar
Michael Beck committed
371
 */
372
373
static tarval *computed_value_Shrs(const ir_node *n)
{
Michael Beck's avatar
Michael Beck committed
374
375
	ir_node *a = get_Shrs_left(n);
	ir_node *b = get_Shrs_right(n);
376

Michael Beck's avatar
Michael Beck committed
377
378
	tarval *ta = value_of(a);
	tarval *tb = value_of(b);
379

Michael Beck's avatar
Michael Beck committed
380
	if ((ta != tarval_bad) && (tb != tarval_bad)) {
381
		return tarval_shrs(ta, tb);
Michael Beck's avatar
Michael Beck committed
382
383
	}
	return tarval_bad;
384
}  /* computed_value_Shrs */
385

Michael Beck's avatar
Michael Beck committed
386
/**
387
 * Return the value of a Rotl.
Michael Beck's avatar
Michael Beck committed
388
 */
389
390
static tarval *computed_value_Rotl(const ir_node *n)
{
391
392
	ir_node *a = get_Rotl_left(n);
	ir_node *b = get_Rotl_right(n);
393

Michael Beck's avatar
Michael Beck committed
394
395
	tarval *ta = value_of(a);
	tarval *tb = value_of(b);
396

Michael Beck's avatar
Michael Beck committed
397
	if ((ta != tarval_bad) && (tb != tarval_bad)) {
398
		return tarval_rotl(ta, tb);
Michael Beck's avatar
Michael Beck committed
399
400
	}
	return tarval_bad;
401
}  /* computed_value_Rotl */
402

Michael Beck's avatar
Michael Beck committed
403
/**
404
 * Return the value of a Conv.
Michael Beck's avatar
Michael Beck committed
405
 */
406
407
static tarval *computed_value_Conv(const ir_node *n)
{
Michael Beck's avatar
Michael Beck committed
408
409
	ir_node *a = get_Conv_op(n);
	tarval *ta = value_of(a);
410

Michael Beck's avatar
Michael Beck committed
411
412
	if (ta != tarval_bad)
		return tarval_convert_to(ta, get_irn_mode(n));
413

Michael Beck's avatar
Michael Beck committed
414
	return tarval_bad;
415
}  /* computed_value_Conv */
416

Michael Beck's avatar
Michael Beck committed
417
418
419
420
/**
 * Calculate the value of a Mux: can be evaluated, if the
 * sel and the right input are known.
 */
421
422
static tarval *computed_value_Mux(const ir_node *n)
{
Michael Beck's avatar
Michael Beck committed
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
	ir_node *sel = get_Mux_sel(n);
	tarval *ts = value_of(sel);

	if (ts == get_tarval_b_true()) {
		ir_node *v = get_Mux_true(n);
		return value_of(v);
	}
	else if (ts == get_tarval_b_false()) {
		ir_node *v = get_Mux_false(n);
		return value_of(v);
	}
	return tarval_bad;
}  /* computed_value_Mux */

/**
 * Calculate the value of a Confirm: can be evaluated,
 * if it has the form Confirm(x, '=', Const).
 */
441
442
static tarval *computed_value_Confirm(const ir_node *n)
{
443
444
445
446
	if (get_Confirm_cmp(n) == pn_Cmp_Eq) {
		tarval *tv = value_of(get_Confirm_bound(n));
		if (tv != tarval_bad)
			return tv;
Michael Beck's avatar
Michael Beck committed
447
448
449
450
	}
	return value_of(get_Confirm_value(n));
}  /* computed_value_Confirm */

451
/**
452
 * Return the value of a Proj(Cmp).
453
454
455
456
457
458
459
 *
 * This performs a first step of unreachable code elimination.
 * Proj can not be computed, but folding a Cmp above the Proj here is
 * not as wasteful as folding a Cmp into a Tuple of 16 Consts of which
 * only 1 is used.
 * There are several case where we can evaluate a Cmp node, see later.
 */
460
461
static tarval *computed_value_Proj_Cmp(const ir_node *n)
{
462
463
464
465
466
467
	ir_node *cmp   = get_Proj_pred(n);
	ir_node *left  = get_Cmp_left(cmp);
	ir_node *right = get_Cmp_right(cmp);
	long pn_cmp    = get_Proj_proj(n);
	ir_mode *mode  = get_irn_mode(left);
	tarval *tv_l, *tv_r;
Michael Beck's avatar
Michael Beck committed
468
469
470
471
472

	/*
	 * BEWARE: a == a is NOT always True for floating Point values, as
	 * NaN != NaN is defined, so we must check this here.
	 */
473
	if (left == right && (!mode_is_float(mode) || pn_cmp == pn_Cmp_Lt ||  pn_cmp == pn_Cmp_Gt)) {
Michael Beck's avatar
Michael Beck committed
474
475
		/* This is a trick with the bits used for encoding the Cmp
		   Proj numbers, the following statement is not the same:
476
477
		return new_tarval_from_long(pn_cmp == pn_Cmp_Eq, mode_b) */
		return new_tarval_from_long(pn_cmp & pn_Cmp_Eq, mode_b);
Michael Beck's avatar
Michael Beck committed
478
	}
479
480
481
482
483
484
485
486
487
	tv_l = value_of(left);
	tv_r = value_of(right);

	if ((tv_l != tarval_bad) && (tv_r != tarval_bad)) {
		/*
		 * The predecessors of Cmp are target values.  We can evaluate
		 * the Cmp.
		 */
		pn_Cmp flags = tarval_cmp(tv_l, tv_r);
488
		if (flags != pn_Cmp_False) {
489
			return new_tarval_from_long (pn_cmp & flags, mode_b);
Michael Beck's avatar
Michael Beck committed
490
		}
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
	} else if (mode_is_int(mode)) {
		/* for integer values, we can check against MIN/MAX */
		pn_Cmp cmp_result;

		if (tv_l == get_mode_min(mode)) {
			/* MIN <=/> x.  This results in true/false. */
			if (pn_cmp == pn_Cmp_Le)
				return tarval_b_true;
			else if (pn_cmp == pn_Cmp_Gt)
				return tarval_b_false;
		} else if (tv_r == get_mode_min(mode)) {
			/* x >=/< MIN.  This results in true/false. */
			if (pn_cmp == pn_Cmp_Ge)
				return tarval_b_true;
			else if (pn_cmp == pn_Cmp_Lt)
				return tarval_b_false;
		} else if (tv_l == get_mode_max(mode)) {
			/* MAX >=/< x.  This results in true/false. */
			if (pn_cmp == pn_Cmp_Ge)
				return tarval_b_true;
			else if (pn_cmp == pn_Cmp_Lt)
				return tarval_b_false;
		} else if (tv_r == get_mode_max(mode)) {
			/* x <=/> MAX.  This results in true/false. */
			if (pn_cmp == pn_Cmp_Le)
				return tarval_b_true;
			else if (pn_cmp == pn_Cmp_Gt)
				return tarval_b_false;
519
520
		}

521
		cmp_result = vrp_cmp(left, right);
522
		if (cmp_result != pn_Cmp_False) {
523
			if (cmp_result == pn_Cmp_Lg) {
524
525
526
527
				if (pn_cmp == pn_Cmp_Eq) {
					return tarval_b_false;
				} else if (pn_cmp == pn_Cmp_Lg) {
					return tarval_b_true;
528
529
				}
			} else {
530
				return new_tarval_from_long(cmp_result & pn_cmp, mode_b);
531
			}
Michael Beck's avatar
Michael Beck committed
532
		}
533
534
535
536
537
538
539
540
541
542
543
544
545
546
	} else if (mode_is_reference(mode)) {
		/* pointer compare */
		ir_node *s_l = skip_Proj(left);
		ir_node *s_r = skip_Proj(right);

		if ((is_Alloc(s_l) && tarval_is_null(tv_r)) ||
			(tarval_is_null(tv_l) && is_Alloc(s_r))) {
			/*
			 * The predecessors are Allocs and (void*)(0) constants. In Firm Allocs never
			 * return NULL, they raise an exception. Therefore we can predict
			 * the Cmp result.
			 */
			return new_tarval_from_long(pn_cmp & pn_Cmp_Lg, mode_b);
		}
547
	}
548
	return computed_value_Cmp_Confirm(cmp, left, right, pn_cmp);
549
}  /* computed_value_Proj_Cmp */
550

551
552
553
/**
 * Return the value of a floating point Quot.
 */
554
555
static tarval *do_computed_value_Quot(const ir_node *a, const ir_node *b)
{
556
557
558
559
560
561
562
563
564
565
566
567
568
	tarval  *ta = value_of(a);
	tarval  *tb = value_of(b);

	/* cannot optimize 0 / b = 0 because of NaN */
	if (ta != tarval_bad && tb != tarval_bad)
		return tarval_quo(ta, tb);
	return tarval_bad;
}  /* do_computed_value_Quot */

/**
 * Calculate the value of an integer Div of two nodes.
 * Special case: 0 / b
 */
569
570
static tarval *do_computed_value_Div(const ir_node *a, const ir_node *b)
{
Michael Beck's avatar
Michael Beck committed
571
572
573
	tarval        *ta = value_of(a);
	tarval        *tb;
	const ir_node *dummy;
574
575
576
577
578
579
580
581
582
583
584
585
586
587

	/* Compute c1 / c2 or 0 / a, a != 0 */
	if (tarval_is_null(ta) && value_not_zero(b, &dummy))
		return ta;  /* 0 / b == 0 */
	tb = value_of(b);
	if (ta != tarval_bad && tb != tarval_bad)
		return tarval_div(ta, tb);
	return tarval_bad;
}  /* do_computed_value_Div */

/**
 * Calculate the value of an integer Mod of two nodes.
 * Special case: a % 1
 */
588
589
static tarval *do_computed_value_Mod(const ir_node *a, const ir_node *b)
{
590
591
592
593
594
595
	tarval *ta = value_of(a);
	tarval *tb = value_of(b);

	/* Compute a % 1 or c1 % c2 */
	if (tarval_is_one(tb))
		return get_mode_null(get_irn_mode(a));
Michael Beck's avatar
Michael Beck committed
596
	if (ta != tarval_bad && tb != tarval_bad)
597
598
599
600
		return tarval_mod(ta, tb);
	return tarval_bad;
}  /* do_computed_value_Mod */

Michael Beck's avatar
Michael Beck committed
601
/**
Michael Beck's avatar
Michael Beck committed
602
 * Return the value of a Proj(DivMod).
Michael Beck's avatar
Michael Beck committed
603
 */
604
605
static tarval *computed_value_Proj_DivMod(const ir_node *n)
{
Michael Beck's avatar
Michael Beck committed
606
	long proj_nr = get_Proj_proj(n);
Michael Beck's avatar
Michael Beck committed
607

Michael Beck's avatar
Michael Beck committed
608
609
610
611
612
613
614
615
616
617
	/* compute either the Div or the Mod part */
	if (proj_nr == pn_DivMod_res_div) {
		const ir_node *a = get_Proj_pred(n);
		return do_computed_value_Div(get_DivMod_left(a), get_DivMod_right(a));
	} else if (proj_nr == pn_DivMod_res_mod) {
		const ir_node *a = get_Proj_pred(n);
		return do_computed_value_Mod(get_DivMod_left(a), get_DivMod_right(a));
	}
	return tarval_bad;
}  /* computed_value_Proj_DivMod */
Michael Beck's avatar
Michael Beck committed
618

Michael Beck's avatar
Michael Beck committed
619
620
621
/**
 * Return the value of a Proj(Div).
 */
622
623
static tarval *computed_value_Proj_Div(const ir_node *n)
{
Michael Beck's avatar
Michael Beck committed
624
	long proj_nr = get_Proj_proj(n);
Michael Beck's avatar
Michael Beck committed
625

Michael Beck's avatar
Michael Beck committed
626
627
628
	if (proj_nr == pn_Div_res) {
		const ir_node *a = get_Proj_pred(n);
		return do_computed_value_Div(get_Div_left(a), get_Div_right(a));
Michael Beck's avatar
Michael Beck committed
629
630
	}
	return tarval_bad;
Michael Beck's avatar
Michael Beck committed
631
}  /* computed_value_Proj_Div */
632

633
/**
Michael Beck's avatar
Michael Beck committed
634
 * Return the value of a Proj(Mod).
635
 */
636
637
static tarval *computed_value_Proj_Mod(const ir_node *n)
{
Michael Beck's avatar
Michael Beck committed
638
	long proj_nr = get_Proj_proj(n);
Michael Beck's avatar
Michael Beck committed
639

Michael Beck's avatar
Michael Beck committed
640
641
642
	if (proj_nr == pn_Mod_res) {
		const ir_node *a = get_Proj_pred(n);
		return do_computed_value_Mod(get_Mod_left(a), get_Mod_right(a));
Michael Beck's avatar
Michael Beck committed
643
644
	}
	return tarval_bad;
Michael Beck's avatar
Michael Beck committed
645
}  /* computed_value_Proj_Mod */
646

Michael Beck's avatar
BugFix:    
Michael Beck committed
647
/**
Michael Beck's avatar
Michael Beck committed
648
 * Return the value of a Proj(Quot).
Michael Beck's avatar
BugFix:    
Michael Beck committed
649
 */
650
651
static tarval *computed_value_Proj_Quot(const ir_node *n)
{
Michael Beck's avatar
Michael Beck committed
652
653
654
655
656
657
	long proj_nr = get_Proj_proj(n);

	if (proj_nr == pn_Quot_res) {
		const ir_node *a = get_Proj_pred(n);
		return do_computed_value_Quot(get_Quot_left(a), get_Quot_right(a));
	}
Michael Beck's avatar
Michael Beck committed
658
	return tarval_bad;
Michael Beck's avatar
Michael Beck committed
659
}  /* computed_value_Proj_Quot */
Michael Beck's avatar
BugFix:    
Michael Beck committed
660

Michael Beck's avatar
Michael Beck committed
661
/**
Michael Beck's avatar
Michael Beck committed
662
 * Return the value of a Proj.
Michael Beck's avatar
Michael Beck committed
663
 */
664
665
static tarval *computed_value_Proj(const ir_node *proj)
{
Michael Beck's avatar
Michael Beck committed
666
667
668
669
670
671
	ir_node *n = get_Proj_pred(proj);

	if (n->op->ops.computed_value_Proj != NULL)
		return n->op->ops.computed_value_Proj(proj);
	return tarval_bad;
}  /* computed_value_Proj */
Michael Beck's avatar
Michael Beck committed
672

673
674
675
/**
 * If the parameter n can be computed, return its value, else tarval_bad.
 * Performs constant folding.
676
677
 *
 * @param n  The node this should be evaluated
678
 */
679
680
tarval *computed_value(const ir_node *n)
{
681
	vrp_attr *vrp = vrp_get_info(n);
682
	if (vrp && vrp->valid && tarval_cmp(vrp->bits_set, vrp->bits_not_set) == pn_Cmp_Eq) {
683
		return vrp->bits_set;
684
	}
Michael Beck's avatar
Michael Beck committed
685
686
687
	if (n->op->ops.computed_value)
		return n->op->ops.computed_value(n);
	return tarval_bad;
688
}  /* computed_value */
Christian Schäfer's avatar
Christian Schäfer committed
689

690
/**
691
 * Set the default computed_value evaluator in an ir_op_ops.
Michael Beck's avatar
Michael Beck committed
692
693
694
695
696
697
 *
 * @param code   the opcode for the default operation
 * @param ops    the operations initialized
 *
 * @return
 *    The operations.
698
 */
699
700
static ir_op_ops *firm_set_default_computed_value(ir_opcode code, ir_op_ops *ops)
{
Michael Beck's avatar
Michael Beck committed
701
702
703
704
705
706
707
#define CASE(a)                                        \
	case iro_##a:                                      \
		ops->computed_value      = computed_value_##a; \
		break
#define CASE_PROJ(a)                                        \
	case iro_##a:                                           \
		ops->computed_value_Proj = computed_value_Proj_##a; \
Michael Beck's avatar
Michael Beck committed
708
709
710
711
712
713
714
		break

	switch (code) {
	CASE(Const);
	CASE(SymConst);
	CASE(Add);
	CASE(Sub);
715
716
	CASE(Carry);
	CASE(Borrow);
Michael Beck's avatar
Michael Beck committed
717
718
719
720
721
722
723
724
725
	CASE(Minus);
	CASE(Mul);
	CASE(And);
	CASE(Or);
	CASE(Eor);
	CASE(Not);
	CASE(Shl);
	CASE(Shr);
	CASE(Shrs);
726
	CASE(Rotl);
Michael Beck's avatar
Michael Beck committed
727
728
729
	CASE(Conv);
	CASE(Mux);
	CASE(Confirm);
Michael Beck's avatar
Michael Beck committed
730
731
732
733
734
735
	CASE_PROJ(Cmp);
	CASE_PROJ(DivMod);
	CASE_PROJ(Div);
	CASE_PROJ(Mod);
	CASE_PROJ(Quot);
	CASE(Proj);
Michael Beck's avatar
Michael Beck committed
736
	default:
737
738
		/* leave NULL */
		break;
Michael Beck's avatar
Michael Beck committed
739
740
741
	}

	return ops;
Michael Beck's avatar
Michael Beck committed
742
#undef CASE_PROJ
743
#undef CASE
744
}  /* firm_set_default_computed_value */
Christian Schäfer's avatar
Christian Schäfer committed
745

Michael Beck's avatar
Michael Beck committed
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
/**
 * Returns a equivalent block for another block.
 * If the block has only one predecessor, this is
 * the equivalent one. If the only predecessor of a block is
 * the block itself, this is a dead block.
 *
 * If both predecessors of a block are the branches of a binary
 * Cond, the equivalent block is Cond's block.
 *
 * If all predecessors of a block are bad or lies in a dead
 * block, the current block is dead as well.
 *
 * Note, that blocks are NEVER turned into Bad's, instead
 * the dead_block flag is set. So, never test for is_Bad(block),
 * always use is_dead_Block(block).
 */
762
763
static ir_node *equivalent_node_Block(ir_node *n)
{
Michael Beck's avatar
Michael Beck committed
764
	ir_node *oldn = n;
765
	int     n_preds;
766
	ir_graph *irg;
Michael Beck's avatar
Michael Beck committed
767

768
	/* don't optimize dead or labeled blocks */
769
	if (is_Block_dead(n) || has_Block_entity(n))
770
771
772
773
774
775
		return n;

	n_preds = get_Block_n_cfgpreds(n);

	/* The Block constructor does not call optimize, but mature_immBlock()
	   calls the optimization. */
Michael Beck's avatar
Michael Beck committed
776
777
	assert(get_Block_matured(n));

778
779
	irg = get_irn_irg(n);

Michael Beck's avatar
Michael Beck committed
780
781
782
783
784
785
	/* Straightening: a single entry Block following a single exit Block
	   can be merged, if it is not the Start block. */
	/* !!! Beware, all Phi-nodes of n must have been optimized away.
	   This should be true, as the block is matured before optimize is called.
	   But what about Phi-cycles with the Phi0/Id that could not be resolved?
	   Remaining Phi nodes are just Ids. */
Michael Beck's avatar
Michael Beck committed
786
787
788
789
790
791
792
793
794
	if (n_preds == 1) {
		ir_node *pred = skip_Proj(get_Block_cfgpred(n, 0));

		if (is_Jmp(pred)) {
			ir_node *predblock = get_nodes_block(pred);
			if (predblock == oldn) {
				/* Jmp jumps into the block it is in -- deal self cycle. */
				n = set_Block_dead(n);
				DBG_OPT_DEAD_BLOCK(oldn, n);
795
			} else {
Michael Beck's avatar
Michael Beck committed
796
797
798
799
800
801
802
803
804
805
				n = predblock;
				DBG_OPT_STG(oldn, n);
			}
		} else if (is_Cond(pred)) {
			ir_node *predblock = get_nodes_block(pred);
			if (predblock == oldn) {
				/* Jmp jumps into the block it is in -- deal self cycle. */
				n = set_Block_dead(n);
				DBG_OPT_DEAD_BLOCK(oldn, n);
			}
Michael Beck's avatar
Michael Beck committed
806
		}
807
	} else if (n_preds == 2) {
Michael Beck's avatar
Michael Beck committed
808
809
810
811
812
813
814
		/* Test whether Cond jumps twice to this block
		 * The more general case which more than 2 predecessors is handles
		 * in optimize_cf(), we handle only this special case for speed here.
		 */
		ir_node *a = get_Block_cfgpred(n, 0);
		ir_node *b = get_Block_cfgpred(n, 1);

Michael Beck's avatar
Michael Beck committed
815
816
817
818
819
820
821
822
823
824
		if (is_Proj(a) && is_Proj(b)) {
			ir_node *cond = get_Proj_pred(a);

		    if (cond == get_Proj_pred(b) && is_Cond(cond) &&
		        get_irn_mode(get_Cond_selector(cond)) == mode_b) {
				/* Also a single entry Block following a single exit Block.  Phis have
				   twice the same operand and will be optimized away. */
				n = get_nodes_block(cond);
				DBG_OPT_IFSIM1(oldn, a, b, n);
			}
Michael Beck's avatar
Michael Beck committed
825
826
		}
	} else if (get_opt_unreachable_code() &&
827
828
	           (n != get_irg_start_block(irg)) &&
	           (n != get_irg_end_block(irg))) {
Michael Beck's avatar
Michael Beck committed
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
		int i;

		/* If all inputs are dead, this block is dead too, except if it is
		   the start or end block.  This is one step of unreachable code
		   elimination */
		for (i = get_Block_n_cfgpreds(n) - 1; i >= 0; --i) {
			ir_node *pred = get_Block_cfgpred(n, i);
			ir_node *pred_blk;

			if (is_Bad(pred)) continue;
			pred_blk = get_nodes_block(skip_Proj(pred));

			if (is_Block_dead(pred_blk)) continue;

			if (pred_blk != n) {
				/* really found a living input */
				break;
			}
		}
		if (i < 0) {
			n = set_Block_dead(n);
			DBG_OPT_DEAD_BLOCK(oldn, n);
		}
	}

	return n;
855
}  /* equivalent_node_Block */
856

857
858
/**
 * Returns a equivalent node for a Jmp, a Bad :-)
859
 * Of course this only happens if the Block of the Jmp is dead.
860
 */
861
862
static ir_node *equivalent_node_Jmp(ir_node *n)
{
Michael Beck's avatar
Michael Beck committed
863
	ir_node *oldn = n;
864

Michael Beck's avatar
Michael Beck committed
865
866
	/* unreachable code elimination */
	if (is_Block_dead(get_nodes_block(n))) {
867
868
		ir_graph *irg = get_irn_irg(n);
		n = get_irg_bad(irg);
Michael Beck's avatar
Michael Beck committed
869
870
		DBG_OPT_DEAD_BLOCK(oldn, n);
	}
Michael Beck's avatar
Michael Beck committed
871
	return n;
872
}  /* equivalent_node_Jmp */
873

874
/** Raise is handled in the same way as Jmp. */
875
876
877
#define equivalent_node_Raise   equivalent_node_Jmp


878
879
/* We do not evaluate Cond here as we replace it by a new node, a Jmp.
   See transform_node_Proj_Cond(). */
880

881
/**
882
 * Optimize operations that are commutative and have neutral 0,
883
 * so a op 0 = 0 op a = a.
884
 */
885
886
static ir_node *equivalent_node_neutral_zero(ir_node *n)
{
Michael Beck's avatar
Michael Beck committed
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
	ir_node *oldn = n;

	ir_node *a = get_binop_left(n);
	ir_node *b = get_binop_right(n);

	tarval *tv;
	ir_node *on;

	/* After running compute_node there is only one constant predecessor.
	   Find this predecessors value and remember the other node: */
	if ((tv = value_of(a)) != tarval_bad) {
		on = b;
	} else if ((tv = value_of(b)) != tarval_bad) {
		on = a;
	} else
		return n;

	/* If this predecessors constant value is zero, the operation is
	 * unnecessary. Remove it.
	 *
	 * Beware: If n is a Add, the mode of on and n might be different
	 * which happens in this rare construction: NULL + 3.
	 * Then, a Conv would be needed which we cannot include here.
	 */
911
912
	if (tarval_is_null(tv) && get_irn_mode(on) == get_irn_mode(n)) {
		n = on;
Michael Beck's avatar
Michael Beck committed
913

914
		DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_NEUTRAL_0);
Michael Beck's avatar
Michael Beck committed
915
916
917
	}

	return n;
918
}  /* equivalent_node_neutral_zero */
919

920
921
922
/**
 * Eor is commutative and has neutral 0.
 */
923
924
static ir_node *equivalent_node_Eor(ir_node *n)
{
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
	ir_node *oldn = n;
	ir_node *a;
	ir_node *b;

	n = equivalent_node_neutral_zero(n);
	if (n != oldn) return n;

	a = get_Eor_left(n);
	b = get_Eor_right(n);

	if (is_Eor(a)) {
		ir_node *aa = get_Eor_left(a);
		ir_node *ab = get_Eor_right(a);

		if (aa == b) {
			/* (a ^ b) ^ a -> b */
			n = ab;
Michael Beck's avatar
Michael Beck committed
942
			DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_EOR_A_B_A);
Michael Beck's avatar
Michael Beck committed
943
			return n;
944
945
946
		} else if (ab == b) {
			/* (a ^ b) ^ b -> a */
			n = aa;
Michael Beck's avatar
Michael Beck committed
947
			DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_EOR_A_B_A);
Michael Beck's avatar
Michael Beck committed
948
			return n;
949
		}
950
951
	}
	if (is_Eor(b)) {
952
953
954
955
956
957
		ir_node *ba = get_Eor_left(b);
		ir_node *bb = get_Eor_right(b);

		if (ba == a) {
			/* a ^ (a ^ b) -> b */
			n = bb;
Michael Beck's avatar
Michael Beck committed
958
			DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_EOR_A_B_A);
Michael Beck's avatar
Michael Beck committed
959
			return n;
960
961
962
		} else if (bb == a) {
			/* a ^ (b ^ a) -> b */
			n = ba;
Michael Beck's avatar
Michael Beck committed
963
			DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_EOR_A_B_A);
Michael Beck's avatar
Michael Beck committed
964
			return n;
965
966
967
968
		}
	}
	return n;
}
969

970
971
972
973
974
/*
 * Optimize a - 0 and (a - x) + x (for modes with wrap-around).
 *
 * The second one looks strange, but this construct
 * is used heavily in the LCC sources :-).
975
976
977
 *
 * Beware: The Mode of an Add may be different than the mode of its
 * predecessors, so we could not return a predecessors in all cases.
978
 */
979
980
static ir_node *equivalent_node_Add(ir_node *n)
{
Michael Beck's avatar
Michael Beck committed
981
982
983
984
985
986
987
988
	ir_node *oldn = n;
	ir_node *left, *right;
	ir_mode *mode = get_irn_mode(n);

	n = equivalent_node_neutral_zero(n);
	if (n != oldn)
		return n;

989
	/* for FP these optimizations are only allowed if fp_strict_algebraic is disabled */
990
991
992
993
994
	if (mode_is_float(mode)) {
		ir_graph *irg = get_irn_irg(n);
		if (get_irg_fp_model(irg) & fp_strict_algebraic)
			return n;
	}
995

Michael Beck's avatar
Michael Beck committed
996
997
998
	left  = get_Add_left(n);
	right = get_Add_right(n);

999
	if (is_Sub(left)) {
Michael Beck's avatar
Michael Beck committed
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
		if (get_Sub_right(left) == right) {
			/* (a - x) + x */

			n = get_Sub_left(left);
			if (mode == get_irn_mode(n)) {
				DBG_OPT_ALGSIM1(oldn, left, right, n, FS_OPT_ADD_SUB);
				return n;
			}
		}
	}
1010
	if (is_Sub(right)) {
Michael Beck's avatar
Michael Beck committed
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
		if (get_Sub_right(right) == left) {
			/* x + (a - x) */

			n = get_Sub_left(right);
			if (mode == get_irn_mode(n)) {
				DBG_OPT_ALGSIM1(oldn, left, right, n, FS_OPT_ADD_SUB);
				return n;
			}
		}
	}
	return n;
1022
}  /* equivalent_node_Add */
1023

1024
/**
1025
1026
 * optimize operations that are not commutative but have neutral 0 on left,
 * so a op 0 = a.
1027
 */
1028
1029
static ir_node *equivalent_node_left_zero(ir_node *n)
{
Michael Beck's avatar
Michael Beck committed
1030
	ir_node *oldn = n;
1031

1032
1033
1034
	ir_node *a  = get_binop_left(n);
	ir_node *b  = get_binop_right(n);
	tarval  *tb = value_of(b);
1035

1036
	if (tarval_is_null(tb)) {
Michael Beck's avatar
Michael Beck committed
1037
		n = a;
1038

Michael Beck's avatar
Michael Beck committed
1039
1040
1041
		DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_NEUTRAL_0);
	}
	return n;
1042
}  /* equivalent_node_left_zero */
1043

1044
1045
1046
#define equivalent_node_Shl   equivalent_node_left_zero
#define equivalent_node_Shr   equivalent_node_left_zero
#define equivalent_node_Shrs  equivalent_node_left_zero
1047
#define equivalent_node_Rotl  equivalent_node_left_zero
1048

1049
1050
1051
1052
1053
/**
 * Optimize a - 0 and (a + x) - x (for modes with wrap-around).
 *
 * The second one looks strange, but this construct
 * is used heavily in the LCC sources :-).
1054
1055
1056
 *
 * Beware: The Mode of a Sub may be different than the mode of its
 * predecessors, so we could not return a predecessors in all cases.
1057
 */
1058
1059
static ir_node *equivalent_node_Sub(ir_node *n)
{
Michael Beck's avatar
Michael Beck committed
1060
	ir_node *oldn = n;
1061
	ir_node *b;
Michael Beck's avatar
Michael Beck committed
1062
	ir_mode *mode = get_irn_mode(n);
1063
	tarval  *