contrib/gcc/tree-ssa-reassoc.c

60     they are in proper rank order.
71     binary expressions whose operands are the same rank (or
81     rank in parentheses), with opcode PLUS_EXPR:
89     You want to first merge all leaves of the same rank, as much as
97     be exposed to redundancy elimination as a rank 1 operand.
100     consider it to now be a rank two operand, and merge it with d and e,
140     same rank.  If so, you know to order it
149     If all three are of the same rank, you can't expose them all in a
169 /* Operator, rank pair.  */
172   unsigned int rank;
179 /* Starting rank number for a given basic block, so that we can rank
184 /* Operand->rank hashtable.  */
188 /* Look up the operand rank structure for expression E.  */
203 /* Insert {E,RANK} into the operand rank hashtable.  */
206 insert_operand_rank (tree e, unsigned int rank)
212   new_pair->rank = rank;
218 /* Return the hash value for a operand rank structure  */
227 /* Return true if two operand rank structures are equal.  */
237 /* Given an expression E, return the rank of the expression.  */
244   /* Constants have rank 0.  */
248   /* SSA_NAME's have the rank of the expression they are the result
250      For globals and uninitialized values, the rank is 0.
251      For function arguments, use the pre-setup rank.
252      For PHI nodes, stores, asm statements, etc, we use the rank of
254      For simple operations, the rank is the maximum rank of any of
263       unsigned int rank, maxrank;
268 	return find_operand_rank (e)->rank;
278       /* If we already have a rank for this expression, use that.  */
281 	return vr->rank;
283       /* Otherwise, find the maximum rank for the operands, or the bb
284 	 rank, whichever is less.   */
285       rank = 0;
289 	rank = MAX (rank, get_rank (rhs));
295 		 && rank != maxrank;
297 	    rank = MAX(rank, get_rank (TREE_OPERAND (rhs, i)));
304 	  fprintf (dump_file, " is %d\n", (rank + 1));
307       /* Note the rank in the hashtable so we don't recompute it.  */
308       insert_operand_rank (e, (rank + 1));
309       return (rank + 1);
312   /* Globals, etc,  are rank 0 */
338 /* qsort comparison function to sort operand entries PA and PB by rank
339    so that the sorted array is ordered by rank in decreasing order.  */
348      other.  Since all constants have rank 0, order them by type.  */
349   if (oeb->rank == 0 &&  oea->rank == 0)
354   if ((oeb->rank - oea->rank == 0)
359   return oeb->rank - oea->rank;
370   oe->rank = get_rank (op);
506   /* Any non-negated version will have a rank that is one less than
507      the current rank.  So once we hit those ranks, if we don't find
512        && oe->rank >= curr->rank - 1 ;
564   /* Any non-not version will have a rank that is one less than
565      the current rank.  So once we hit those ranks, if we don't find
570        && oe->rank >= curr->rank - 1;
621   if (oelast->rank == 0 && INTEGRAL_TYPE_P (TREE_TYPE (oelast->op)))
751   if (oelast->rank == 0 && is_gimple_min_invariant (oelast->op))
755       if (oelm1->rank == 0
835    match those in OPS[OPINDEX], putting the computation in rank
846      that gets the double binary op are the ones with the same rank.
867       if ((oe1->rank == oe2->rank
868 	   && oe2->rank != oe3->rank)
875 	  oe3->rank = oe1->rank;
877 	  oe1->rank= temp.rank;
1392       fprintf (file, "Op %d -> rank: %d, tree: ", i, oe->rank);
1418   unsigned int rank = 2;
1435   /* Give each argument a distinct rank.   */
1443 	  insert_operand_rank (def, ++rank);
1447   /* Give the chain decl a distinct rank. */
1452 	insert_operand_rank (def, ++rank);
1455   /* Set up rank for each BB  */
1457     bb_rank[bbs[i]] = ++rank  << 16;