iropt.c 179 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>
Boris Boesler's avatar
added    
Boris Boesler committed
29

Michael Beck's avatar
Michael Beck committed
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
#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"
#include "irvrfy.h"
#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 "archop.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"
Christian Schäfer's avatar
Christian Schäfer committed
51

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

55
56
57
58
59
60
61
62
63
64
65
66
/**
 * Returns the tarval of a Const node or tarval_bad for all other nodes.
 */
static tarval *default_value_of(const ir_node *n) {
	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
67
/* * Set a new value_of function. */
68
69
70
71
72
73
74
void set_value_of_func(value_of_func func) {
	if (func != NULL)
		value_of_ptr = func;
	else
		value_of_ptr = default_value_of;
}

75
/**
76
 * Return the value of a Constant.
77
 */
Michael Beck's avatar
Michael Beck committed
78
static tarval *computed_value_Const(const ir_node *n) {
Michael Beck's avatar
Michael Beck committed
79
	return get_Const_tarval(n);
80
}  /* computed_value_Const */
Christian Schäfer's avatar
Christian Schäfer committed
81

82
/**
Michael Beck's avatar
Michael Beck committed
83
 * Return the value of a 'sizeof', 'alignof' or 'offsetof' SymConst.
84
 */
Michael Beck's avatar
Michael Beck committed
85
static tarval *computed_value_SymConst(const ir_node *n) {
Michael Beck's avatar
Michael Beck committed
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
	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;
110
}  /* computed_value_SymConst */
Christian Schäfer's avatar
Christian Schäfer committed
111

Michael Beck's avatar
Michael Beck committed
112
/**
113
 * Return the value of an Add.
Michael Beck's avatar
Michael Beck committed
114
 */
Michael Beck's avatar
Michael Beck committed
115
static tarval *computed_value_Add(const ir_node *n) {
Michael Beck's avatar
Michael Beck committed
116
117
	ir_node *a = get_Add_left(n);
	ir_node *b = get_Add_right(n);
Christian Schäfer's avatar
Christian Schäfer committed
118

Michael Beck's avatar
Michael Beck committed
119
120
	tarval *ta = value_of(a);
	tarval *tb = value_of(b);
121

122
	if ((ta != tarval_bad) && (tb != tarval_bad))
Michael Beck's avatar
Michael Beck committed
123
		return tarval_add(ta, tb);
124

Michael Beck's avatar
Michael Beck committed
125
	return tarval_bad;
126
}  /* computed_value_Add */
Christian Schäfer's avatar
Christian Schäfer committed
127

Michael Beck's avatar
Michael Beck committed
128
/**
129
 * Return the value of a Sub.
Michael Beck's avatar
Michael Beck committed
130
131
 * Special case: a - a
 */
Michael Beck's avatar
Michael Beck committed
132
static tarval *computed_value_Sub(const ir_node *n) {
133
134
135
136
137
	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
138

139
140
141
142
143
144
	/* 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
145

Michael Beck's avatar
Michael Beck committed
146
147
	ta = value_of(a);
	tb = value_of(b);
148

149
150
	if ((ta != tarval_bad) && (tb != tarval_bad))
		return tarval_sub(ta, tb, mode);
151

Michael Beck's avatar
Michael Beck committed
152
	return tarval_bad;
153
}  /* computed_value_Sub */
154

155
/**
156
 * Return the value of a Carry.
157
158
 * Special : a op 0, 0 op b
 */
Michael Beck's avatar
Michael Beck committed
159
static tarval *computed_value_Carry(const ir_node *n) {
Michael Beck's avatar
Michael Beck committed
160
161
162
163
164
165
166
167
168
169
170
	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 {
171
		if (tarval_is_null(ta) || tarval_is_null(tb))
Michael Beck's avatar
Michael Beck committed
172
173
174
			return get_mode_null(m);
	}
	return tarval_bad;
175
}  /* computed_value_Carry */
176
177

/**
178
 * Return the value of a Borrow.
179
180
 * Special : a op 0
 */
Michael Beck's avatar
Michael Beck committed
181
static tarval *computed_value_Borrow(const ir_node *n) {
Michael Beck's avatar
Michael Beck committed
182
183
184
185
186
187
188
189
190
	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);
191
	} else if (tarval_is_null(ta)) {
Michael Beck's avatar
Michael Beck committed
192
193
194
		return get_mode_null(m);
	}
	return tarval_bad;
195
}  /* computed_value_Borrow */
196

Michael Beck's avatar
Michael Beck committed
197
/**
198
 * Return the value of an unary Minus.
Michael Beck's avatar
Michael Beck committed
199
 */
Michael Beck's avatar
Michael Beck committed
200
static tarval *computed_value_Minus(const ir_node *n) {
Michael Beck's avatar
Michael Beck committed
201
202
	ir_node *a = get_Minus_op(n);
	tarval *ta = value_of(a);
203

Michael Beck's avatar
Michael Beck committed
204
	if (ta != tarval_bad)
Michael Beck's avatar
Michael Beck committed
205
		return tarval_neg(ta);
206

Michael Beck's avatar
Michael Beck committed
207
	return tarval_bad;
208
}  /* computed_value_Minus */
209

Michael Beck's avatar
Michael Beck committed
210
/**
211
 * Return the value of a Mul.
Michael Beck's avatar
Michael Beck committed
212
 */
Michael Beck's avatar
Michael Beck committed
213
static tarval *computed_value_Mul(const ir_node *n) {
Michael Beck's avatar
Michael Beck committed
214
215
	ir_node *a = get_Mul_left(n);
	ir_node *b = get_Mul_right(n);
Michael Beck's avatar
Michael Beck committed
216
	ir_mode *mode;
Michael Beck's avatar
Michael Beck committed
217
218
219
220

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

Michael Beck's avatar
Michael Beck committed
221
222
223
224
225
226
227
228
	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
229
230
		return tarval_mul(ta, tb);
	} else {
231
232
233
234
235
236
237
238
		/* 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
239
240
	}
	return tarval_bad;
241
}  /* computed_value_Mul */
242

Michael Beck's avatar
Michael Beck committed
243
/**
244
 * Return the value of an Abs.
Michael Beck's avatar
Michael Beck committed
245
 */
Michael Beck's avatar
Michael Beck committed
246
static tarval *computed_value_Abs(const ir_node *n) {
Michael Beck's avatar
Michael Beck committed
247
248
	ir_node *a = get_Abs_op(n);
	tarval *ta = value_of(a);
249

Michael Beck's avatar
Michael Beck committed
250
251
	if (ta != tarval_bad)
		return tarval_abs(ta);
252

Michael Beck's avatar
Michael Beck committed
253
	return tarval_bad;
254
}  /* computed_value_Abs */
255

Michael Beck's avatar
Michael Beck committed
256
/**
257
 * Return the value of an And.
Michael Beck's avatar
Michael Beck committed
258
259
 * Special case: a & 0, 0 & b
 */
Michael Beck's avatar
Michael Beck committed
260
static tarval *computed_value_And(const ir_node *n) {
Michael Beck's avatar
Michael Beck committed
261
262
263
264
265
266
267
268
269
	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 {
270
271
		if (tarval_is_null(ta)) return ta;
		if (tarval_is_null(tb)) return tb;
Michael Beck's avatar
Michael Beck committed
272
273
	}
	return tarval_bad;
274
}  /* computed_value_And */
275

Michael Beck's avatar
Michael Beck committed
276
/**
277
 * Return the value of an Or.
Michael Beck's avatar
Michael Beck committed
278
279
 * Special case: a | 1...1, 1...1 | b
 */
Michael Beck's avatar
Michael Beck committed
280
static tarval *computed_value_Or(const ir_node *n) {
Michael Beck's avatar
Michael Beck committed
281
282
283
284
285
286
287
288
289
	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 {
290
291
		if (tarval_is_all_one(ta)) return ta;
		if (tarval_is_all_one(tb)) return tb;
Michael Beck's avatar
Michael Beck committed
292
293
	}
	return tarval_bad;
294
}  /* computed_value_Or */
295

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

Michael Beck's avatar
Michael Beck committed
303
	tarval *ta, *tb;
Michael Beck's avatar
Michael Beck committed
304

Michael Beck's avatar
Michael Beck committed
305
306
	if (a == b)
		return get_mode_null(get_irn_mode(n));
Michael Beck's avatar
Michael Beck committed
307

Michael Beck's avatar
Michael Beck committed
308
309
	ta = value_of(a);
	tb = value_of(b);
310

Michael Beck's avatar
Michael Beck committed
311
312
313
314
	if ((ta != tarval_bad) && (tb != tarval_bad)) {
		return tarval_eor (ta, tb);
	}
	return tarval_bad;
315
}  /* computed_value_Eor */
316

Michael Beck's avatar
Michael Beck committed
317
/**
318
 * Return the value of a Not.
Michael Beck's avatar
Michael Beck committed
319
 */
Michael Beck's avatar
Michael Beck committed
320
static tarval *computed_value_Not(const ir_node *n) {
Michael Beck's avatar
Michael Beck committed
321
322
	ir_node *a = get_Not_op(n);
	tarval *ta = value_of(a);
323

Michael Beck's avatar
Michael Beck committed
324
325
	if (ta != tarval_bad)
		return tarval_not(ta);
326

Michael Beck's avatar
Michael Beck committed
327
	return tarval_bad;
328
}  /* computed_value_Not */
329

Michael Beck's avatar
Michael Beck committed
330
/**
331
 * Return the value of a Shl.
Michael Beck's avatar
Michael Beck committed
332
 */
Michael Beck's avatar
Michael Beck committed
333
static tarval *computed_value_Shl(const ir_node *n) {
Michael Beck's avatar
Michael Beck committed
334
335
	ir_node *a = get_Shl_left(n);
	ir_node *b = get_Shl_right(n);
336

Michael Beck's avatar
Michael Beck committed
337
338
	tarval *ta = value_of(a);
	tarval *tb = value_of(b);
339

Michael Beck's avatar
Michael Beck committed
340
341
342
343
	if ((ta != tarval_bad) && (tb != tarval_bad)) {
		return tarval_shl (ta, tb);
	}
	return tarval_bad;
344
}  /* computed_value_Shl */
345

Michael Beck's avatar
Michael Beck committed
346
/**
347
 * Return the value of a Shr.
Michael Beck's avatar
Michael Beck committed
348
 */
Michael Beck's avatar
Michael Beck committed
349
static tarval *computed_value_Shr(const ir_node *n) {
Michael Beck's avatar
Michael Beck committed
350
351
	ir_node *a = get_Shr_left(n);
	ir_node *b = get_Shr_right(n);
352

Michael Beck's avatar
Michael Beck committed
353
354
	tarval *ta = value_of(a);
	tarval *tb = value_of(b);
355

Michael Beck's avatar
Michael Beck committed
356
357
358
359
	if ((ta != tarval_bad) && (tb != tarval_bad)) {
		return tarval_shr (ta, tb);
	}
	return tarval_bad;
360
}  /* computed_value_Shr */
361

Michael Beck's avatar
Michael Beck committed
362
/**
363
 * Return the value of a Shrs.
Michael Beck's avatar
Michael Beck committed
364
 */
Michael Beck's avatar
Michael Beck committed
365
static tarval *computed_value_Shrs(const ir_node *n) {
Michael Beck's avatar
Michael Beck committed
366
367
	ir_node *a = get_Shrs_left(n);
	ir_node *b = get_Shrs_right(n);
368

Michael Beck's avatar
Michael Beck committed
369
370
	tarval *ta = value_of(a);
	tarval *tb = value_of(b);
371

Michael Beck's avatar
Michael Beck committed
372
373
374
375
	if ((ta != tarval_bad) && (tb != tarval_bad)) {
		return tarval_shrs (ta, tb);
	}
	return tarval_bad;
376
}  /* computed_value_Shrs */
377

Michael Beck's avatar
Michael Beck committed
378
/**
379
 * Return the value of a Rotl.
Michael Beck's avatar
Michael Beck committed
380
 */
Michael Beck's avatar
Michael Beck committed
381
static tarval *computed_value_Rotl(const ir_node *n) {
382
383
	ir_node *a = get_Rotl_left(n);
	ir_node *b = get_Rotl_right(n);
384

Michael Beck's avatar
Michael Beck committed
385
386
	tarval *ta = value_of(a);
	tarval *tb = value_of(b);
387

Michael Beck's avatar
Michael Beck committed
388
	if ((ta != tarval_bad) && (tb != tarval_bad)) {
389
		return tarval_rotl(ta, tb);
Michael Beck's avatar
Michael Beck committed
390
391
	}
	return tarval_bad;
392
}  /* computed_value_Rotl */
393

Michael Beck's avatar
Michael Beck committed
394
/**
395
 * Return the value of a Conv.
Michael Beck's avatar
Michael Beck committed
396
 */
Michael Beck's avatar
Michael Beck committed
397
static tarval *computed_value_Conv(const ir_node *n) {
Michael Beck's avatar
Michael Beck committed
398
399
	ir_node *a = get_Conv_op(n);
	tarval *ta = value_of(a);
400

Michael Beck's avatar
Michael Beck committed
401
402
	if (ta != tarval_bad)
		return tarval_convert_to(ta, get_irn_mode(n));
403

Michael Beck's avatar
Michael Beck committed
404
	return tarval_bad;
405
}  /* computed_value_Conv */
406

Michael Beck's avatar
Michael Beck committed
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
/**
 * Calculate the value of a Mux: can be evaluated, if the
 * sel and the right input are known.
 */
static tarval *computed_value_Mux(const ir_node *n) {
	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).
 */
static tarval *computed_value_Confirm(const ir_node *n) {
	/*
	 * Beware: we might produce Phi(Confirm(x == true), Confirm(x == false)).
	 * Do NOT optimize them away (CondEval wants them), so wait until
	 * remove_confirm is activated.
	 */
	if (get_opt_remove_confirm()) {
		if (get_Confirm_cmp(n) == pn_Cmp_Eq) {
			tarval *tv = value_of(get_Confirm_bound(n));
			if (tv != tarval_bad)
				return tv;
		}
	}
	return value_of(get_Confirm_value(n));
}  /* computed_value_Confirm */

446
/**
447
 * Return the value of a Proj(Cmp).
448
449
450
451
452
453
454
 *
 * 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.
 */
Michael Beck's avatar
Michael Beck committed
455
static tarval *computed_value_Proj_Cmp(const ir_node *n) {
Michael Beck's avatar
Michael Beck committed
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
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
519
520
521
522
523
524
525
526
527
528
529
	ir_node *a   = get_Proj_pred(n);
	ir_node *aa  = get_Cmp_left(a);
	ir_node *ab  = get_Cmp_right(a);
	long proj_nr = get_Proj_proj(n);

	/*
	 * BEWARE: a == a is NOT always True for floating Point values, as
	 * NaN != NaN is defined, so we must check this here.
	 */
	if (aa == ab && (
		!mode_is_float(get_irn_mode(aa)) || proj_nr == pn_Cmp_Lt ||  proj_nr == pn_Cmp_Gt)
		) { /* 1.: */

		/* This is a trick with the bits used for encoding the Cmp
		   Proj numbers, the following statement is not the same:
		return new_tarval_from_long (proj_nr == pn_Cmp_Eq, mode_b) */
		return new_tarval_from_long (proj_nr & pn_Cmp_Eq, mode_b);
	}
	else {
		tarval *taa = value_of(aa);
		tarval *tab = value_of(ab);
		ir_mode *mode = get_irn_mode(aa);

		/*
		 * The predecessors of Cmp are target values.  We can evaluate
		 * the Cmp.
		 */
		if ((taa != tarval_bad) && (tab != tarval_bad)) {
			/* strange checks... */
			pn_Cmp flags = tarval_cmp(taa, tab);
			if (flags != pn_Cmp_False) {
				return new_tarval_from_long (proj_nr & flags, mode_b);
			}
		}
		/* for integer values, we can check against MIN/MAX */
		else if (mode_is_int(mode)) {
			/* MIN <=/> x.  This results in true/false. */
			if (taa == get_mode_min(mode)) {
				/* a compare with the MIN value */
				if (proj_nr == pn_Cmp_Le)
					return get_tarval_b_true();
				else if (proj_nr == pn_Cmp_Gt)
					return get_tarval_b_false();
			}
			/* x >=/< MIN.  This results in true/false. */
			else
				if (tab == get_mode_min(mode)) {
					/* a compare with the MIN value */
					if (proj_nr == pn_Cmp_Ge)
						return get_tarval_b_true();
					else if (proj_nr == pn_Cmp_Lt)
						return get_tarval_b_false();
				}
				/* MAX >=/< x.  This results in true/false. */
				else if (taa == get_mode_max(mode)) {
					if (proj_nr == pn_Cmp_Ge)
						return get_tarval_b_true();
					else if (proj_nr == pn_Cmp_Lt)
						return get_tarval_b_false();
				}
				/* x <=/> MAX.  This results in true/false. */
				else if (tab == get_mode_max(mode)) {
					if (proj_nr == pn_Cmp_Le)
						return get_tarval_b_true();
					else if (proj_nr == pn_Cmp_Gt)
						return get_tarval_b_false();
				}
		}
		/*
		 * The predecessors are Allocs or (void*)(0) constants.  Allocs never
		 * return NULL, they raise an exception.   Therefore we can predict
		 * the Cmp result.
		 */
		else {
530
531
			ir_node *aaa = skip_Proj(aa);
			ir_node *aba = skip_Proj(ab);
Michael Beck's avatar
Michael Beck committed
532
533

			if (   (   (/* aa is ProjP and aaa is Alloc */
534
535
536
			               is_Proj(aa)
			            && mode_is_reference(get_irn_mode(aa))
			            && is_Alloc(aaa))
Michael Beck's avatar
Michael Beck committed
537
			        && (   (/* ab is NULL */
538
539
			                mode_is_reference(get_irn_mode(ab))
			                && tarval_is_null(tab))
Michael Beck's avatar
Michael Beck committed
540
			            || (/* ab is other Alloc */
541
542
543
			                   is_Proj(ab)
			                && mode_is_reference(get_irn_mode(ab))
			                && is_Alloc(aba)
Michael Beck's avatar
Michael Beck committed
544
545
			                && (aaa != aba))))
			    || (/* aa is NULL and aba is Alloc */
546
547
			        mode_is_reference(get_irn_mode(aa))
			        && tarval_is_null(taa)
548
549
550
			        && is_Proj(ab)
			        && mode_is_reference(get_irn_mode(ab))
			        && is_Alloc(aba)))
Michael Beck's avatar
Michael Beck committed
551
				/* 3.: */
552
			return new_tarval_from_long(proj_nr & pn_Cmp_Lg, mode_b);
Michael Beck's avatar
Michael Beck committed
553
554
555
		}
	}
	return computed_value_Cmp_Confirm(a, aa, ab, proj_nr);
556
}  /* computed_value_Proj_Cmp */
557

558
559
560
/**
 * Return the value of a floating point Quot.
 */
Michael Beck's avatar
Michael Beck committed
561
static tarval *do_computed_value_Quot(const ir_node *a, const ir_node *b) {
562
563
564
565
566
567
568
569
570
571
572
573
574
	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
 */
Michael Beck's avatar
Michael Beck committed
575
static tarval *do_computed_value_Div(const ir_node *a, const ir_node *b) {
Michael Beck's avatar
Michael Beck committed
576
577
578
	tarval        *ta = value_of(a);
	tarval        *tb;
	const ir_node *dummy;
579
580
581
582
583
584
585
586
587
588
589
590
591
592

	/* 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
 */
Michael Beck's avatar
Michael Beck committed
593
static tarval *do_computed_value_Mod(const ir_node *a, const ir_node *b) {
594
595
596
597
598
599
	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
600
	if (ta != tarval_bad && tb != tarval_bad)
601
602
603
604
		return tarval_mod(ta, tb);
	return tarval_bad;
}  /* do_computed_value_Mod */

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

Michael Beck's avatar
Michael Beck committed
611
612
613
614
615
616
617
618
619
620
	/* 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
621

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

Michael Beck's avatar
Michael Beck committed
628
629
630
	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
631
632
	}
	return tarval_bad;
Michael Beck's avatar
Michael Beck committed
633
}  /* computed_value_Proj_Div */
634

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

Michael Beck's avatar
Michael Beck committed
641
642
643
	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
644
645
	}
	return tarval_bad;
Michael Beck's avatar
Michael Beck committed
646
}  /* computed_value_Proj_Mod */
647

Michael Beck's avatar
BugFix:    
Michael Beck committed
648
/**
Michael Beck's avatar
Michael Beck committed
649
 * Return the value of a Proj(Quot).
Michael Beck's avatar
BugFix:    
Michael Beck committed
650
 */
Michael Beck's avatar
Michael Beck committed
651
652
653
654
655
656
657
static tarval *computed_value_Proj_Quot(const ir_node *n) {
	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
 */
Michael Beck's avatar
Michael Beck committed
664
665
666
667
668
669
670
static tarval *computed_value_Proj(const ir_node *proj) {
	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
671

672
673
674
/**
 * If the parameter n can be computed, return its value, else tarval_bad.
 * Performs constant folding.
675
676
 *
 * @param n  The node this should be evaluated
677
 */
Michael Beck's avatar
Michael Beck committed
678
tarval *computed_value(const ir_node *n) {
Michael Beck's avatar
Michael Beck committed
679
680
681
	if (n->op->ops.computed_value)
		return n->op->ops.computed_value(n);
	return tarval_bad;
682
}  /* computed_value */
Christian Schäfer's avatar
Christian Schäfer committed
683

684
/**
685
 * Set the default computed_value evaluator in an ir_op_ops.
Michael Beck's avatar
Michael Beck committed
686
687
688
689
690
691
 *
 * @param code   the opcode for the default operation
 * @param ops    the operations initialized
 *
 * @return
 *    The operations.
692
 */
693
694
static ir_op_ops *firm_set_default_computed_value(ir_opcode code, ir_op_ops *ops)
{
Michael Beck's avatar
Michael Beck committed
695
696
697
698
699
700
701
#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
702
703
704
705
706
707
708
		break

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

	return ops;
Michael Beck's avatar
Michael Beck committed
736
#undef CASE_PROJ
737
#undef CASE
738
}  /* firm_set_default_computed_value */
Christian Schäfer's avatar
Christian Schäfer committed
739

Michael Beck's avatar
Michael Beck committed
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
/**
 * 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).
 */
756
757
static ir_node *equivalent_node_Block(ir_node *n)
{
Michael Beck's avatar
Michael Beck committed
758
	ir_node *oldn = n;
759
	int     n_preds;
Michael Beck's avatar
Michael Beck committed
760

761
762
763
764
765
766
767
768
	/* don't optimize dead blocks */
	if (is_Block_dead(n))
		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
769
770
771
772
773
774
775
776
	assert(get_Block_matured(n));

	/* 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
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
	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);
			} else if (get_opt_control_flow_straightening()) {
				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
797
798
799
800
801
802
803
804
805
806
		}
	} else if ((n_preds == 2) &&
	           (get_opt_control_flow_weak_simplification())) {
		/* 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
807
808
809
810
811
812
813
814
815
816
		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
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
		}
	} else if (get_opt_unreachable_code() &&
	           (n != get_irg_start_block(current_ir_graph)) &&
	           (n != get_irg_end_block(current_ir_graph))    ) {
		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;
847
}  /* equivalent_node_Block */
848

849
850
/**
 * Returns a equivalent node for a Jmp, a Bad :-)
851
 * Of course this only happens if the Block of the Jmp is dead.
852
 */
853
static ir_node *equivalent_node_Jmp(ir_node *n) {
Michael Beck's avatar
Michael Beck committed
854
	ir_node *oldn = n;
855

Michael Beck's avatar
Michael Beck committed
856
857
858
859
860
	/* unreachable code elimination */
	if (is_Block_dead(get_nodes_block(n))) {
		n = get_irg_bad(current_ir_graph);
		DBG_OPT_DEAD_BLOCK(oldn, n);
	}
Michael Beck's avatar
Michael Beck committed
861
	return n;
862
}  /* equivalent_node_Jmp */
863

864
/** Raise is handled in the same way as Jmp. */
865
866
867
#define equivalent_node_Raise   equivalent_node_Jmp


868
869
/* We do not evaluate Cond here as we replace it by a new node, a Jmp.
   See transform_node_Proj_Cond(). */
870

871
/**
872
 * Optimize operations that are commutative and have neutral 0,
873
 * so a op 0 = 0 op a = a.
874
 */
Michael Beck's avatar
Michael Beck committed
875
static ir_node *equivalent_node_neutral_zero(ir_node *n) {
Michael Beck's avatar
Michael Beck committed
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
	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.
	 */
900
901
	if (tarval_is_null(tv) && get_irn_mode(on) == get_irn_mode(n)) {
		n = on;
Michael Beck's avatar
Michael Beck committed
902

903
		DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_NEUTRAL_0);
Michael Beck's avatar
Michael Beck committed
904
905
906
	}

	return n;
907
}  /* equivalent_node_neutral_zero */
908

909
910
911
/**
 * Eor is commutative and has neutral 0.
 */
Michael Beck's avatar
Michael Beck committed
912
static ir_node *equivalent_node_Eor(ir_node *n) {
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
	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
930
			DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_EOR_A_B_A);
Michael Beck's avatar
Michael Beck committed
931
			return n;
932
933
934
		} else if (ab == b) {
			/* (a ^ b) ^ b -> a */
			n = aa;
Michael Beck's avatar
Michael Beck committed
935
			DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_EOR_A_B_A);
Michael Beck's avatar
Michael Beck committed
936
			return n;
937
		}
938
939
	}
	if (is_Eor(b)) {
940
941
942
943
944
945
		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
946
			DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_EOR_A_B_A);
Michael Beck's avatar
Michael Beck committed
947
			return n;
948
949
950
		} else if (bb == a) {
			/* a ^ (b ^ a) -> b */
			n = ba;
Michael Beck's avatar
Michael Beck committed
951
			DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_EOR_A_B_A);
Michael Beck's avatar
Michael Beck committed
952
			return n;
953
954
955
956
		}
	}
	return n;
}
957

958
959
960
961
962
/*
 * 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 :-).
963
964
965
 *
 * 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.
966
 */
Michael Beck's avatar
Michael Beck committed
967
968
969
970
971
972
973
974
975
static ir_node *equivalent_node_Add(ir_node *n) {
	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;

976
977
978
979
	/* for FP these optimizations are only allowed if fp_strict_algebraic is disabled */
	if (mode_is_float(mode) && (get_irg_fp_model(current_ir_graph) & fp_strict_algebraic))
		return n;

Michael Beck's avatar
Michael Beck committed
980
981
982
	left  = get_Add_left(n);
	right = get_Add_right(n);

983
	if (is_Sub(left)) {
Michael Beck's avatar
Michael Beck committed
984
985
986
987
988
989
990
991
992
993
		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;
			}
		}
	}
994
	if (is_Sub(right)) {
Michael Beck's avatar
Michael Beck committed
995
996
997
998
999
1000
1001
1002
1003
1004
1005
		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;
1006
}  /* equivalent_node_Add */
1007

1008
/**
1009
1010
 * optimize operations that are not commutative but have neutral 0 on left,
 * so a op 0 = a.
1011
 */
1012
static ir_node *equivalent_node_left_zero(ir_node *n) {
Michael Beck's avatar
Michael Beck committed
1013
	ir_node *oldn = n;
1014

1015
1016
1017
	ir_node *a  = get_binop_left(n);
	ir_node *b  = get_binop_right(n);
	tarval  *tb = value_of(b);
1018

1019
	if (tarval_is_null(tb)) {
Michael Beck's avatar
Michael Beck committed
1020
		n = a;
1021

Michael Beck's avatar
Michael Beck committed
1022
1023
1024
		DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_NEUTRAL_0);
	}
	return n;
1025
}  /* equivalent_node_left_zero */
1026

1027
1028
1029
#define equivalent_node_Shl   equivalent_node_left_zero
#define equivalent_node_Shr   equivalent_node_left_zero
#define equivalent_node_Shrs  equivalent_node_left_zero
1030
#define equivalent_node_Rotl  equivalent_node_left_zero
1031

1032
1033
1034
1035
1036
/**
 * 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 :-).
1037
1038
1039
 *
 * 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.
1040
 */
Michael Beck's avatar
Michael Beck committed
1041
1042
static ir_node *equivalent_node_Sub(ir_node *n) {
	ir_node *oldn = n;
1043
	ir_node *b;
Michael Beck's avatar
Michael Beck committed
1044
	ir_mode *mode = get_irn_mode(n);
1045
	tarval  *tb;
Michael Beck's avatar
Michael Beck committed
1046
1047
1048
1049
1050

	/* for FP these optimizations are only allowed if fp_strict_algebraic is disabled */
	if (mode_is_float(mode) && (get_irg_fp_model(current_ir_graph) & fp_strict_algebraic))
		return n;

1051
1052
	b  = get_Sub_right(n);
	tb = value_of(b);
Michael Beck's avatar
Michael Beck committed
1053
1054

	/* Beware: modes might be different */
1055
	if (tarval_is_null(tb)) {
1056
		ir_node *a = get_Sub_left(n);
Michael Beck's avatar
Michael Beck committed
1057
1058
1059
1060
1061
1062
1063
		if (mode == get_irn_mode(a)) {
			n = a;

			DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_NEUTRAL_0);
		}
	}
	return n;
1064
}  /* equivalent_node_Sub */
1065
1066


1067
/**
Christoph Mallon's avatar
Christoph Mallon committed
1068
 * Optimize an "self-inverse unary op", ie op(op(n)) = n.
1069
 *
1070
1071
1072
1073
 * @todo
 *   -(-a) == a, but might overflow two times.
 *   We handle it anyway here but the better way would be a
 *   flag. This would be needed for Pascal for instance.
1074
 */
Michael Beck's avatar
Michael Beck committed
1075
1076
1077
static ir_node *equivalent_node_idempotent_unop(ir_node *n) {
	ir_node *oldn = n;
	ir_node *pred = get_unop_op(n);
1078

Michael Beck's avatar
Michael Beck committed
1079
1080
1081
	/* optimize symmetric unop */
	if (get_irn_op(pred) == get_irn_op(n)) {
		n = get_unop_op(pred);
1082
		DBG_OPT_ALGSIM2(oldn, pred, n, FS_OPT_IDEM_UNARY);
Michael Beck's avatar
Michael Beck committed
1083
1084
	}
	return n;
1085
}  /* equivalent_node_idempotent_unop */
1086

1087
/** Optimize Not(Not(x)) == x. */
Michael Beck's avatar
Michael Beck committed
1088
#define equivalent_node_Not    equivalent_node_idempotent_unop
1089

Christoph Mallon's avatar
Christoph Mallon committed
1090
/** -(-x) == x       ??? Is this possible or can --x raise an
1091
                       out of bounds exception if min =! max? */
Michael Beck's avatar
Michael Beck committed
1092
#define equivalent_node_Minus  equivalent_node_idempotent_unop