Extract fp-vrp analysis part into ir/ana/

ir/ana/fp-vrp.c

+/*
+ * This file is part of libFirm.
+ * Copyright (C) 2012 University of Karlsruhe.
+ */
+
+/**
+ * @file
+ * @brief   Data-flow driven minimal fixpoint value range analysis
+ * @author  Christoph Mallon
+ */
+#include "config.h"
+
+#include <assert.h>
+#include <stdbool.h>
+
+#include "adt/pdeq.h"
+#include "adt/obst.h"
+#include "adt/xmalloc.h"
+#include "debug.h"
+#include "ircons.h"
+#include "irdom.h"
+#include "iredges.h"
+#include "irgmod.h"
+#include "irgraph_t.h"
+#include "irgwalk.h"
+#include "irnode_t.h"
+#include "iroptimize.h"
+#include "tv.h"
+#include "irpass.h"
+#include "irmemory.h"
+#include "fp-vrp.h"
+
+/* TODO:
+ * - Implement cleared/set bit calculation for Add, Sub, Minus, Mul, Div, Mod, Shl, Shr, Shrs, Rotl
+ * - Implement min/max calculation for And, Eor, Or, Not, Conv, Shl, Shr, Shrs, Rotl, Mux
+ * - Implement min/max calculation for Add, Sub, Minus, Mul, Div, Mod, Conv, Shl, Shr, Shrs, Rotl, Mux
+ */
+
+/* Tables of the cleared/set bit lattice
+ *
+ * Encoding of the lattice
+ * zo
+ * 00 0 zero
+ * 01 - impossible state, is zero /and/ one
+ * 10 T top, may be either zero or one
+ * 11 1 one
+ *
+ * S = Sum
+ * c = Carry
+ * D = Difference
+ * b = Borrow
+ *
+ * Not
+ * A ~
+ * 0 1
+ * 1 0
+ * T T
+ *
+ * Half adder, half subtractor, and, xor, or, Mux
+ * AB  Sc  Db  &  ^  |  M
+ * 00  00  00  0  0  0  0
+ * 01  10  11  0  1  1  T
+ * 0T  T0  TT  0  T  T  T
+ * 10  10  10  0  1  1  T
+ * 11  01  00  1  0  1  1
+ * 1T  TT  T0  T  T  1  T
+ * T0  T0  T0  0  T  T  T
+ * T1  TT  TT  T  T  1  T
+ * TT  TT  TT  T  T  T  T
+ *
+ * Full adder, full subtractor
+ * ABc-1  Sc  Db
+ * 000    00  00
+ * 001    10  11
+ * 00T    T0  TT
+ * 010    10  11
+ * 011    01  01
+ * 01T    TT  T1
+ * 0T0    T0  TT
+ * 0T1    TT  T1
+ * 0TT    TT  TT
+ * 100    10  10
+ * 101    01  00
+ * 10T    TT  T0
+ * 110    01  00
+ * 111    11  11
+ * 11T    T1  TT
+ * 1T0    TT  T0
+ * 1T1    T1  TT
+ * 1TT    TT  TT
+ * T00    T0  T0
+ * T01    TT  TT
+ * T0T    TT  TT
+ * T10    TT  TT
+ * T11    T1  T1
+ * T1T    TT  TT
+ * TT0    TT  TT
+ * TT1    TT  TT
+ * TTT    TT  TT
+ *
+ *
+ * Assume: Xmin <= Xmax and no overflow
+ * A + B = (Amin + Bmin, Amax + Bmax)
+ *    -A = (-Amax, -Amin)
+ * A - B = A + -B = (Amin (-B)min, Amax + (-B)max) = (Amin - Bmax, Amax - Bmin)
+ */
+
+DEBUG_ONLY(static firm_dbg_module_t *dbg;)
+
+static struct obstack *obst;
+
+typedef struct vrp_bitinfo bitinfo;
+
+static bool is_undefined(bitinfo const* const b)
+{
+	return tarval_is_null(b->z) && tarval_is_all_one(b->o);
+}
+
+inline bitinfo* get_bitinfo(ir_node const* const irn)
+{
+	return (bitinfo*)get_irn_link(irn);
+}
+
+int set_bitinfo(ir_node* const irn, ir_tarval* const z, ir_tarval* const o)
+{
+	bitinfo* b = get_bitinfo(irn);
+	if (b == NULL) {
+		b = OALLOCZ(obst, bitinfo);
+		set_irn_link(irn, b);
+	} else if (z == b->z && o == b->o) {
+		return 0;
+	} else {
+		/* Assert monotonicity. */
+		assert(tarval_is_null(tarval_andnot(b->z, z)));
+		assert(tarval_is_null(tarval_andnot(o, b->o)));
+	}
+	b->z = z;
+	b->o = o;
+	DB((dbg, LEVEL_3, "%+F: 0:%T 1:%T\n", irn, z, o));
+	return 1;
+}
+
+static int mode_is_intb(ir_mode const* const m)
+{
+	return mode_is_int(m) || m == mode_b;
+}
+
+static int transfer(ir_node* const irn)
+{
+	ir_tarval* const f = get_tarval_b_false();
+	ir_tarval* const t = get_tarval_b_true();
+	ir_mode*   const m = get_irn_mode(irn);
+	ir_tarval*       z;
+	ir_tarval*       o;
+
+	if (is_Bad(irn)) return 0;
+
+	if (m == mode_X) {
+		bitinfo* const b = get_bitinfo(get_nodes_block(irn));
+
+		DB((dbg, LEVEL_3, "transfer %+F\n", irn));
+
+		/* Unreachble blocks might have no bitinfo. */
+		if (b == NULL || b->z == f) {
+unreachable_X:
+			z = f;
+			o = t;
+		} else switch (get_irn_opcode(irn)) {
+			case iro_Proj: {
+				ir_node* const pred = get_Proj_pred(irn);
+				if (is_Start(pred)) {
+					goto result_unknown_X;
+				} else if (is_Cond(pred)) {
+					ir_node*   const selector = get_Cond_selector(pred);
+					bitinfo*   const b        = get_bitinfo(selector);
+					if (is_undefined(b))
+						goto unreachable_X;
+					if (b->z == b->o) {
+						if ((b->z == t) == get_Proj_proj(irn)) {
+							z = o = t;
+						} else {
+							z = o = f;
+						}
+					} else {
+						goto result_unknown_X;
+					}
+				} else if (is_Switch(pred)) {
+					ir_node* const selector = get_Switch_selector(pred);
+					bitinfo* const b        = get_bitinfo(selector);
+					if (is_undefined(b))
+						goto unreachable_X;
+					/* TODO */
+					goto cannot_analyse_X;
+				} else {
+					goto cannot_analyse_X;
+				}
+				break;
+			}
+
+			case iro_Jmp:
+				goto result_unknown_X;
+
+			default:
+cannot_analyse_X:
+				DB((dbg, LEVEL_4, "cannot analyse %+F\n", irn));
+result_unknown_X:
+				z = t;
+				o = f;
+				break;
+		}
+	} else if (is_Block(irn)) {
+		int       reachable = 0;
+		int const arity     = get_Block_n_cfgpreds(irn);
+		int       i;
+
+		DB((dbg, LEVEL_3, "transfer %+F\n", irn));
+		for (i = 0; i != arity; ++i) {
+			bitinfo* const b = get_bitinfo(get_Block_cfgpred(irn, i));
+			if (b != NULL && b->z == t) {
+				reachable = 1;
+				break;
+			}
+		}
+
+		if (!reachable) {
+			ir_graph *const irg = get_Block_irg(irn);
+			reachable =
+				irn == get_irg_start_block(irg) ||
+				irn == get_irg_end_block(irg);
+		}
+
+		if (reachable) {
+			z = t;
+			o = f;
+		} else {
+			z = f;
+			o = t;
+		}
+	} else if (mode_is_intb(m)) {
+		bitinfo* const b = get_bitinfo(get_nodes_block(irn));
+
+		DB((dbg, LEVEL_3, "transfer %+F\n", irn));
+
+		if (b == NULL || b->z == f) {
+undefined:
+			z = get_tarval_null(m);
+			o = get_tarval_all_one(m);
+		} else if (is_Phi(irn)) {
+			ir_node* const block = get_nodes_block(irn);
+			int      const arity = get_Phi_n_preds(irn);
+			int            i;
+
+			z = get_tarval_null(m);
+			o = get_tarval_all_one(m);
+			for (i = 0; i != arity; ++i) {
+				bitinfo* const b_cfg = get_bitinfo(get_Block_cfgpred(block, i));
+				if (b_cfg != NULL && b_cfg->z != f) {
+					bitinfo* const b = get_bitinfo(get_Phi_pred(irn, i));
+					/* Only use input if it's not undefined. */
+					if (!is_undefined(b)) {
+						z = tarval_or( z, b->z);
+						o = tarval_and(o, b->o);
+					}
+				}
+			}
+		} else {
+			int const arity = get_irn_arity(irn);
+			int       i;
+
+			/* Undefined if any input is undefined. */
+			for (i = 0; i != arity; ++i) {
+				ir_node* const pred   = get_irn_n(irn, i);
+				bitinfo* const pred_b = get_bitinfo(pred);
+				if (pred_b != NULL && is_undefined(pred_b))
+					goto undefined;
+			}
+
+			switch (get_irn_opcode(irn)) {
+				case iro_Const: {
+					z = o = get_Const_tarval(irn);
+					break;
+				}
+
+				case iro_Confirm: {
+					ir_node* const v = get_Confirm_value(irn);
+					bitinfo* const b = get_bitinfo(v);
+					/* TODO Use bound and relation. */
+					z = b->z;
+					o = b->o;
+					if ((get_Confirm_relation(irn) & ~ir_relation_unordered) == ir_relation_equal) {
+						bitinfo* const bound_b = get_bitinfo(get_Confirm_bound(irn));
+						z = tarval_and(z, bound_b->z);
+						o = tarval_or( o, bound_b->o);
+					}
+					break;
+				}
+
+				case iro_Shl: {
+					bitinfo*   const l  = get_bitinfo(get_Shl_left(irn));
+					bitinfo*   const r  = get_bitinfo(get_Shl_right(irn));
+					ir_tarval* const rz = r->z;
+					if (rz == r->o) {
+						z = tarval_shl(l->z, rz);
+						o = tarval_shl(l->o, rz);
+					} else {
+						goto cannot_analyse;
+					}
+					break;
+				}
+
+				case iro_Shr: {
+					bitinfo*   const l  = get_bitinfo(get_Shr_left(irn));
+					bitinfo*   const r  = get_bitinfo(get_Shr_right(irn));
+					ir_tarval* const rz = r->z;
+					if (rz == r->o) {
+						z = tarval_shr(l->z, rz);
+						o = tarval_shr(l->o, rz);
+					} else {
+						goto cannot_analyse;
+					}
+					break;
+				}
+
+				case iro_Shrs: {
+					bitinfo*   const l  = get_bitinfo(get_Shrs_left(irn));
+					bitinfo*   const r  = get_bitinfo(get_Shrs_right(irn));
+					ir_tarval* const rz = r->z;
+					if (rz == r->o) {
+						z = tarval_shrs(l->z, rz);
+						o = tarval_shrs(l->o, rz);
+					} else {
+						goto cannot_analyse;
+					}
+					break;
+				}
+
+				case iro_Rotl: {
+					bitinfo*   const l  = get_bitinfo(get_Rotl_left(irn));
+					bitinfo*   const r  = get_bitinfo(get_Rotl_right(irn));
+					ir_tarval* const rz = r->z;
+					if (rz == r->o) {
+						z = tarval_rotl(l->z, rz);
+						o = tarval_rotl(l->o, rz);
+					} else {
+						goto cannot_analyse;
+					}
+					break;
+				}
+
+				case iro_Add: {
+					bitinfo*   const l  = get_bitinfo(get_Add_left(irn));
+					bitinfo*   const r  = get_bitinfo(get_Add_right(irn));
+					ir_tarval* const lz = l->z;
+					ir_tarval* const lo = l->o;
+					ir_tarval* const rz = r->z;
+					ir_tarval* const ro = r->o;
+					if (lz == lo && rz == ro) {
+						z = o = tarval_add(lz, rz);
+					} else {
+						// TODO improve: can only do lower disjoint bits
+						/* Determine where any of the operands has zero bits, i.e. where no
+						 * carry out is generated if there is not carry in */
+						ir_tarval* const no_c_in_no_c_out = tarval_and(lz, rz);
+						/* Generate a mask of the lower consecutive zeroes: x | -x.  In this
+						 * range the addition is disjoint and therefore Add behaves like Or.
+						 */
+						ir_tarval* const low_zero_mask = tarval_or(no_c_in_no_c_out, tarval_neg(no_c_in_no_c_out));
+						ir_tarval* const low_one_mask  = tarval_not(low_zero_mask);
+						z = tarval_or( tarval_or(lz, rz), low_zero_mask);
+						o = tarval_and(tarval_or(lo, ro), low_one_mask);
+					}
+					break;
+				}
+
+				case iro_Sub: {
+					bitinfo* const l = get_bitinfo(get_Sub_left(irn));
+					bitinfo* const r = get_bitinfo(get_Sub_right(irn));
+					if (l != NULL && r != NULL) { // Sub might subtract pointers.
+						ir_tarval* const lz = l->z;
+						ir_tarval* const lo = l->o;
+						ir_tarval* const rz = r->z;
+						ir_tarval* const ro = r->o;
+						if (lz == lo && rz == ro) {
+							z = o = tarval_sub(lz, rz, NULL);
+						} else if (tarval_is_null(tarval_andnot(rz, lo))) {
+							/* Every possible one of the subtrahend is backed by a safe one of the
+							 * minuend, i.e. there are no borrows. */
+							// TODO extend no-borrow like carry for Add above
+							z = tarval_andnot(lz, ro);
+							o = tarval_andnot(lo, rz);
+						} else {
+							goto cannot_analyse;
+						}
+					} else {
+						goto cannot_analyse;
+					}
+					break;
+				}
+
+				case iro_Mul: {
+					bitinfo*   const l  = get_bitinfo(get_Mul_left(irn));
+					bitinfo*   const r  = get_bitinfo(get_Mul_right(irn));
+					ir_tarval* const lz = l->z;
+					ir_tarval* const lo = l->o;
+					ir_tarval* const rz = r->z;
+					ir_tarval* const ro = r->o;
+					if (lz == lo && rz == ro) {
+						z = o = tarval_mul(lz, rz);
+					} else {
+						// TODO improve
+						// Determine safe lower zeroes: x | -x.
+						ir_tarval* const lzn = tarval_or(lz, tarval_neg(lz));
+						ir_tarval* const rzn = tarval_or(rz, tarval_neg(rz));
+						// Concatenate safe lower zeroes.
+						if (tarval_cmp(lzn, rzn) == ir_relation_less) {
+							z = tarval_mul(tarval_eor(lzn, tarval_shl_unsigned(lzn, 1)), rzn);
+						} else {
+							z = tarval_mul(tarval_eor(rzn, tarval_shl_unsigned(rzn, 1)), lzn);
+						}
+						o = get_tarval_null(m);
+					}
+					break;
+				}
+
+				case iro_Minus: {
+					bitinfo* const b = get_bitinfo(get_Minus_op(irn));
+					if (b->z == b->o) {
+						z = o = tarval_neg(b->z);
+					} else {
+						goto cannot_analyse;
+					}
+					break;
+				}
+
+				case iro_And: {
+					bitinfo* const l = get_bitinfo(get_And_left(irn));
+					bitinfo* const r = get_bitinfo(get_And_right(irn));
+					z = tarval_and(l->z, r->z);
+					o = tarval_and(l->o, r->o);
+					break;
+				}
+
+				case iro_Or: {
+					bitinfo* const l = get_bitinfo(get_Or_left(irn));
+					bitinfo* const r = get_bitinfo(get_Or_right(irn));
+					z = tarval_or(l->z, r->z);
+					o = tarval_or(l->o, r->o);
+					break;
+				}
+
+				case iro_Eor: {
+					bitinfo*   const l  = get_bitinfo(get_Eor_left(irn));
+					bitinfo*   const r  = get_bitinfo(get_Eor_right(irn));
+					ir_tarval* const lz = l->z;
+					ir_tarval* const lo = l->o;
+					ir_tarval* const rz = r->z;
+					ir_tarval* const ro = r->o;
+					z = tarval_or(tarval_andnot(lz, ro), tarval_andnot(rz, lo));
+					o = tarval_or(tarval_andnot(ro, lz), tarval_andnot(lo, rz));
+					break;
+				}
+
+				case iro_Not: {
+					bitinfo* const b = get_bitinfo(get_Not_op(irn));
+					z = tarval_not(b->o);
+					o = tarval_not(b->z);
+					break;
+				}
+
+				case iro_Conv: {
+					bitinfo* const b = get_bitinfo(get_Conv_op(irn));
+					if (b == NULL) // Happens when converting from float values.
+						goto result_unknown;
+					z = tarval_convert_to(b->z, m);
+					o = tarval_convert_to(b->o, m);
+					break;
+				}
+
+				case iro_Mux: {
+					bitinfo* const bf = get_bitinfo(get_Mux_false(irn));
+					bitinfo* const bt = get_bitinfo(get_Mux_true(irn));
+					bitinfo* const c  = get_bitinfo(get_Mux_sel(irn));
+					if (c->o == t) {
+						z = bt->z;
+						o = bt->o;
+					} else if (c->z == f) {
+						z = bf->z;
+						o = bf->o;
+					} else {
+						z = tarval_or( bf->z, bt->z);
+						o = tarval_and(bf->o, bt->o);
+					}
+					break;
+				}
+
+				case iro_Cmp: {
+					bitinfo* const l = get_bitinfo(get_Cmp_left(irn));
+					bitinfo* const r = get_bitinfo(get_Cmp_right(irn));
+					if (l == NULL || r == NULL) {
+						goto result_unknown; // Cmp compares something we cannot evaluate.
+					} else {
+						ir_tarval*  const lz       = l->z;
+						ir_tarval*  const lo       = l->o;
+						ir_tarval*  const rz       = r->z;
+						ir_tarval*  const ro       = r->o;
+						ir_relation const relation = get_Cmp_relation(irn);
+						switch (relation) {
+							case ir_relation_less_greater:
+								if (!tarval_is_null(tarval_andnot(ro, lz)) ||
+										!tarval_is_null(tarval_andnot(lo, rz))) {
+									// At least one bit differs.
+									z = o = t;
+								} else if (lz == lo && rz == ro && lz == rz) {
+									z = o = f;
+								} else {
+									goto result_unknown;
+								}
+								break;
+
+							case ir_relation_equal:
+								if (!tarval_is_null(tarval_andnot(ro, lz)) ||
+										!tarval_is_null(tarval_andnot(lo, rz))) {
+									// At least one bit differs.
+									z = o = f;
+								} else if (lz == lo && rz == ro && lz == rz) {
+									z = o = t;
+								} else {
+									goto result_unknown;
+								}
+								break;
+
+							case ir_relation_less_equal:
+							case ir_relation_less:
+								/* TODO handle negative values */
+								if (tarval_is_negative(lz) || tarval_is_negative(lo) ||
+										tarval_is_negative(rz) || tarval_is_negative(ro))
+									goto result_unknown;
+
+								if (tarval_cmp(lz, ro) & relation) {
+									/* Left upper bound is smaller(/equal) than right lower bound. */
+									z = o = t;
+								} else if (!(tarval_cmp(lo, rz) & relation)) {
+									/* Left lower bound is not smaller(/equal) than right upper bound. */
+									z = o = f;
+								} else {
+									goto result_unknown;
+								}
+								break;
+
+							case ir_relation_greater_equal:
+							case ir_relation_greater:
+								/* TODO handle negative values */
+								if (tarval_is_negative(lz) || tarval_is_negative(lo) ||
+										tarval_is_negative(rz) || tarval_is_negative(ro))
+									goto result_unknown;
+
+								if (!(tarval_cmp(lz, ro) & relation)) {
+									/* Left upper bound is not greater(/equal) than right lower bound. */
+									z = o = f;
+								} else if (tarval_cmp(lo, rz) & relation) {
+									/* Left lower bound is greater(/equal) than right upper bound. */
+									z = o = t;
+								} else {
+									goto result_unknown;
+								}
+								break;
+
+							default:
+								goto cannot_analyse;
+						}
+					}
+					break;
+				}
+
+				default: {
+cannot_analyse:
+					DB((dbg, LEVEL_4, "cannot analyse %+F\n", irn));
+result_unknown:
+					z = get_tarval_all_one(m);
+					o = get_tarval_null(m);
+					break;
+				}
+			}
+		}
+	} else {
+		return 0;
+	}
+
+	return set_bitinfo(irn, z, o);
+}
+
+static void first_round(ir_node* const irn, void* const env)
+{
+	pdeq* const q = (pdeq*)env;
+
+	transfer(irn);
+	if (is_Phi(irn) || is_Block(irn)) {
+		/* Only Phis (and their users) need another round, if we did not have
+		 * information about all their inputs in the first round, i.e. in loops. */
+		/* TODO inserts all Phis, should only insert Phis, which did no have all
+		 * predecessors available */
+		pdeq_putr(q, irn);
+	}
+}
+
+static void queue_users(pdeq* const q, ir_node* const n)
+{
+	if (get_irn_mode(n) == mode_X) {
+		/* When the state of a control flow node changes, not only queue its
+		 * successor blocks, but also the Phis in these blocks, because the Phis
+		 * must reconsider this input path. */
+		foreach_out_edge(n, e) {
+			ir_node*  const  src = get_edge_src_irn(e);
+			pdeq_putr(q, src);
+			/* should always be a block */
+			if (is_Block(src)) {
+				ir_node *phi;
+				for (phi = get_Block_phis(src); phi; phi = get_Phi_next(phi))
+					pdeq_putr(q, phi);
+			}
+		}
+	} else {
+		foreach_out_edge(n, e) {
+			ir_node* const src