+ return get_irg_bad(current_ir_graph);
+ }
+ }
+ }
+ }
+ }
+ return proj;
+} /* transform_node_Proj_Cond */
+
+/**
+ * Create a 0 constant of given mode.
+ */
+static ir_node *create_zero_const(ir_mode *mode) {
+ tarval *tv = get_mode_null(mode);
+ ir_node *cnst = new_Const(mode, tv);
+
+ return cnst;
+}
+
+/* the order of the values is important! */
+typedef enum const_class {
+ const_const = 0,
+ const_like = 1,
+ const_other = 2
+} const_class;
+
+static const_class classify_const(const ir_node* n)
+{
+ if (is_Const(n)) return const_const;
+ if (is_irn_constlike(n)) return const_like;
+ return const_other;
+}
+
+/**
+ * Determines whether r is more constlike or has a larger index (in that order)
+ * than l.
+ */
+static int operands_are_normalized(const ir_node *l, const ir_node *r)
+{
+ const const_class l_order = classify_const(l);
+ const const_class r_order = classify_const(r);
+ return
+ l_order > r_order ||
+ (l_order == r_order && get_irn_idx(l) <= get_irn_idx(r));
+}
+
+/**
+ * Normalizes and optimizes Cmp nodes.
+ */
+static ir_node *transform_node_Proj_Cmp(ir_node *proj) {
+ ir_node *n = get_Proj_pred(proj);
+ ir_node *left = get_Cmp_left(n);
+ ir_node *right = get_Cmp_right(n);
+ tarval *tv = NULL;
+ int changed = 0;
+ ir_mode *mode = NULL;
+ long proj_nr = get_Proj_proj(proj);
+
+ /* we can evaluate some cases directly */
+ switch (proj_nr) {
+ case pn_Cmp_False:
+ return new_Const(mode_b, get_tarval_b_false());
+ case pn_Cmp_True:
+ return new_Const(mode_b, get_tarval_b_true());
+ case pn_Cmp_Leg:
+ if (!mode_is_float(get_irn_mode(left)))
+ return new_Const(mode_b, get_tarval_b_true());
+ break;
+ default:
+ break;
+ }
+
+ /* remove Casts of both sides */
+ left = skip_Cast(left);
+ right = skip_Cast(right);
+
+ /* Remove unnecessary conversions */
+ /* TODO handle constants */
+ if (is_Conv(left) && is_Conv(right)) {
+ ir_mode *mode = get_irn_mode(left);
+ ir_node *op_left = get_Conv_op(left);
+ ir_node *op_right = get_Conv_op(right);
+ ir_mode *mode_left = get_irn_mode(op_left);
+ ir_mode *mode_right = get_irn_mode(op_right);
+
+ if (smaller_mode(mode_left, mode) && smaller_mode(mode_right, mode)
+ && mode_left != mode_b && mode_right != mode_b) {
+ ir_graph *irg = current_ir_graph;
+ ir_node *block = get_nodes_block(n);
+
+ if (mode_left == mode_right) {
+ left = op_left;
+ right = op_right;
+ changed |= 1;
+ DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_CONV_CONV);
+ } else if (smaller_mode(mode_left, mode_right)) {
+ left = new_r_Conv(irg, block, op_left, mode_right);
+ right = op_right;
+ changed |= 1;
+ DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_CONV);
+ } else if (smaller_mode(mode_right, mode_left)) {
+ left = op_left;
+ right = new_r_Conv(irg, block, op_right, mode_left);
+ changed |= 1;
+ DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_CONV);
+ }
+ }
+ }
+
+ /* remove operation on both sides if possible */
+ if (proj_nr == pn_Cmp_Eq || proj_nr == pn_Cmp_Lg) {
+ /*
+ * The following operations are NOT safe for floating point operations, for instance
+ * 1.0 + inf == 2.0 + inf, =/=> x == y
+ */
+ if (mode_is_int(get_irn_mode(left))) {
+ unsigned lop = get_irn_opcode(left);
+
+ if (lop == get_irn_opcode(right)) {
+ ir_node *ll, *lr, *rl, *rr;
+
+ /* same operation on both sides, try to remove */
+ switch (lop) {
+ case iro_Not:
+ case iro_Minus:
+ /* ~a CMP ~b => a CMP b, -a CMP -b ==> a CMP b */
+ left = get_unop_op(left);
+ right = get_unop_op(right);
+ changed |= 1;
+ DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_OP_OP);
+ break;
+ case iro_Add:
+ ll = get_Add_left(left);
+ lr = get_Add_right(left);
+ rl = get_Add_left(right);
+ rr = get_Add_right(right);
+
+ if (ll == rl) {
+ /* X + a CMP X + b ==> a CMP b */
+ left = lr;
+ right = rr;
+ changed |= 1;
+ DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_OP_OP);
+ } else if (ll == rr) {
+ /* X + a CMP b + X ==> a CMP b */
+ left = lr;
+ right = rl;
+ changed |= 1;
+ DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_OP_OP);
+ } else if (lr == rl) {
+ /* a + X CMP X + b ==> a CMP b */
+ left = ll;
+ right = rr;
+ changed |= 1;
+ DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_OP_OP);
+ } else if (lr == rr) {
+ /* a + X CMP b + X ==> a CMP b */
+ left = ll;
+ right = rl;
+ changed |= 1;
+ DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_OP_OP);
+ }
+ break;
+ case iro_Sub:
+ ll = get_Sub_left(left);
+ lr = get_Sub_right(left);
+ rl = get_Sub_left(right);
+ rr = get_Sub_right(right);
+
+ if (ll == rl) {
+ /* X - a CMP X - b ==> a CMP b */
+ left = lr;
+ right = rr;
+ changed |= 1;
+ DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_OP_OP);
+ } else if (lr == rr) {
+ /* a - X CMP b - X ==> a CMP b */
+ left = ll;
+ right = rl;
+ changed |= 1;
+ DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_OP_OP);
+ }
+ break;
+ case iro_Rotl:
+ if (get_Rotl_right(left) == get_Rotl_right(right)) {
+ /* a ROTL X CMP b ROTL X ==> a CMP b */
+ left = get_Rotl_left(left);
+ right = get_Rotl_left(right);
+ changed |= 1;
+ DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_OP_OP);