contrib/gcc/tree-ssa-reassoc.c

75     So the way to do this if we really cared, is to build the new op
77     new op on the end of the worklist, until you are left with one
92     So first build a binary op of
101     but in this case, you then have evicted e from a binary op. So at
104     Then build a binary op of d + e
116     build binary op
138     will be written into a nice single binary op.  If you have 3 ops, a
156     destructive update for the associating op, and keep the destructive
173   tree op;
196   vrd.op = e;
211   new_pair->op = e;
224   return iterative_hash_expr (vr->op, 0);
234   return vr1->op == vr2->op;
350     return constant_type (oeb->op) - constant_type (oea->op);
355       && TREE_CODE (oea->op) == SSA_NAME
356       && TREE_CODE (oeb->op) == SSA_NAME)
357     return SSA_NAME_VERSION (oeb->op) - SSA_NAME_VERSION (oea->op);
365 add_to_ops_vec (VEC(operand_entry_t, heap) **ops, tree op)
369   oe->op = op;
370   oe->rank = get_rank (op);
420   /* If we have two of the same op, and the opcode is & |, min, or max,
422      If we have two of the same op, and the opcode is ^, we can
425   if (last && last->op == curr->op)
436 	      print_generic_expr (dump_file, curr->op, 0);
438 	      print_generic_expr (dump_file, last->op, 0);
440 	      print_generic_stmt (dump_file, last->op, 0);
452 	      print_generic_expr (dump_file, curr->op, 0);
454 	      print_generic_expr (dump_file, last->op, 0);
464 	      add_to_ops_vec (ops, fold_convert (TREE_TYPE (last->op),
499   if (opcode != PLUS_EXPR || TREE_CODE (curr->op) != SSA_NAME)
502   negateop = get_unary_op (curr->op, NEGATE_EXPR);
515       if (oe->op == negateop)
523 	      print_generic_expr (dump_file, oe->op, 0);
528 	  add_to_ops_vec (ops, fold_convert(TREE_TYPE (oe->op),
557       || TREE_CODE (curr->op) != SSA_NAME)
560   notop = get_unary_op (curr->op, BIT_NOT_EXPR);
573       if (oe->op == notop)
583 	      print_generic_expr (dump_file, oe->op, 0);
591 	    oe->op = fold_convert (TREE_TYPE (oe->op), integer_zero_node);
593 	    oe->op = build_low_bits_mask (TREE_TYPE (oe->op),
594 					  TYPE_PRECISION (TREE_TYPE (oe->op)));
621   if (oelast->rank == 0 && INTEGRAL_TYPE_P (TREE_TYPE (oelast->op)))
626 	  if (integer_zerop (oelast->op))
642 	  else if (integer_all_onesp (oelast->op))
654 	  if (integer_all_onesp (oelast->op))
670 	  else if (integer_zerop (oelast->op))
682 	  if (integer_zerop (oelast->op))
697 	  else if (integer_onep (oelast->op))
712 	  if (integer_zerop (oelast->op))
751   if (oelast->rank == 0 && is_gimple_min_invariant (oelast->op))
756 	  && is_gimple_min_invariant (oelm1->op)
757 	  && lang_hooks.types_compatible_p (TREE_TYPE (oelm1->op),
758 					    TREE_TYPE (oelast->op)))
760 	  tree folded = fold_binary (opcode, TREE_TYPE (oelm1->op),
761 				     oelm1->op, oelast->op);
846      that gets the double binary op are the ones with the same rank.
869 	  || (is_phi_for_stmt (stmt, oe3->op)
870 	      && !is_phi_for_stmt (stmt, oe1->op)
871 	      && !is_phi_for_stmt (stmt, oe2->op)))
874 	  oe3->op = oe1->op;
876 	  oe1->op = temp.op;
883      If we had one exactly one op in the entire list to start with, we
893       if (TREE_OPERAND (rhs, 0) != oe1->op
894 	  || TREE_OPERAND (rhs, 1) != oe2->op)
903 	  TREE_OPERAND (rhs, 0) = oe1->op;
904 	  TREE_OPERAND (rhs, 1) = oe2->op;
923   if (oe->op != TREE_OPERAND (rhs, 1))
932       TREE_OPERAND (rhs, 1) = oe->op;
1174       /* We want to make it so the lhs is always the reassociative op,
1354 		  TREE_OPERAND (stmt, 1) = VEC_last (operand_entry_t, ops)->op;
1393       print_generic_stmt (file, oe->op, 0);