contrib/gcc/regclass.c

212 /* Maximum cost of moving from a register in one class to a register in
218    of the second so in that case the cost is zero.  */
223    of the second so in that case the cost is zero.  */
490   /* Initialize the move cost table.  Find every subset of each class
491      and take the maximum cost of moving any subset to any other.  */
500 		int cost;
511 		    cost = REGISTER_MOVE_COST (m, i, j);
517 			cost = MAX (cost, move_cost [m][i][*p2]);
523 			cost = MAX (cost, move_cost [m][*p1][j]);
525 		    move_cost[m][i][j] = cost;
530 		      may_move_in_cost[m][i][j] = cost;
535 		      may_move_out_cost[m][i][j] = cost;
603 /* Compute extra cost of moving registers to/from memory due to reloads.
803 /* The `costs' struct records the cost of using a hard register of each class
809   int cost[N_REG_CLASSES];
830 /* Record the cost of each class for each pseudo.  */
834 /* Initialized once, and used to initialize cost values for each insn.  */
919     init_cost.cost[i] = 10000;
953 		     costs[i].cost[(enum reg_class) class]);
1059      it represents a savings, rather than a cost, if the
1141   /* Now add the cost for each operand to the total costs for
1153 	  p->cost[j] += q->cost[j] * frequency;
1240       /* Zero out our accumulation of the cost of each class for each reg.  */
1314 	      else if (p->cost[class] < best_cost)
1316 		  best_cost = p->cost[class];
1319 	      else if (p->cost[class] == best_cost)
1336 	      if (p->cost[class] < p->mem_cost
1381 /* Record the cost of using memory or registers of various classes for
1397    register class and calculate the cost of using that alternative.  Then
1398    we compute for each operand that is a pseudo-register, the cost of
1400    alternative.  To this cost is added the cost of the alternative.
1402    The cost of each class for this insn is its lowest cost among all the
1415   /* Process each alternative, each time minimizing an operand's cost with
1416      the cost for each operand in that alternative.  */
1462 		 alternative.  Then perform any needed cost computations
1471 		     cost and we win.  */
1476 		     the cost of this alternative the cost to copy this
1496 		  /* Otherwise, add to the cost of this alternative the cost
1513 		    pp->cost[class]
1534 		     first pass, add a cost to this alternative corresponding
1548 		  /* This is in place of ordinary cost computation
1739 		    pp->cost[class]
1760 		     first pass, add a cost to this alternative corresponding
1774 	     the proper class, there is no cost for this alternative.  */
1781 	  /* If registers are valid, the cost of this alternative includes
1819 	      pp->cost[class] = MIN (pp->cost[class],
1820 				     (qq->cost[class] + alt_cost) * scale);
1827      we may want to adjust the cost of that register class to -1.
1834      is expensive (ten times the cost of a default copy is considered
1858 		op_costs[i].cost[(unsigned char) pref] = -1;
1866 		    op_costs[i].cost[class] = -1;
1877 			op_costs[i].cost[class] = -1;
1884 /* Compute the cost of loading X into (if TO_P is nonzero) or from (if
1906      cost is that to load the input into the intermediate register, then
1918   /* For memory, use the memory move cost, for (hard) registers, use the
1919      cost to move between the register classes, and use 2 for everything
1945    SCALE is twice the amount to multiply the cost by (it is twice so we
1946    can represent half-cost adjustments).  */
2115 	  pp->cost[i] += (may_move_in_cost[Pmode][i][(int) class] * scale) / 2;