flow.c (mark_set_1, [...]): compute REG_FREQ using bb->frequency.

	* flow.c (mark_set_1, attempt_auto_inc, mark_used_reg,
	try_pre_increment_1): compute REG_FREQ using bb->frequency.

	* regclass.c (loop_cost): Kill.
	(frequency): New global variable.
	(record_operand_costs): Replace loop_cost by frequency.
	(scan_one_insn): Likewise.
	(regclass): Likewise; set frequency according to bb->frequency.

	* flow.c (split_edge): Set frequency.

From-SVN: r43523

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 48cffe464051531a07310f26e76160615dc0777a..8afeccb9004632b3a5522b24a4f5468ce78046ae 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,16 @@
+Sat Jun 23 01:23:59 CEST 2001  Jan Hubicka  <jh@suse.cz>
+
+       * flow.c (mark_set_1, attempt_auto_inc, mark_used_reg,
+       try_pre_increment_1): compute REG_FREQ using bb->frequency.
+
+       * regclass.c (loop_cost): Kill.
+       (frequency): New global variable.
+       (record_operand_costs): Replace loop_cost by frequency.
+       (scan_one_insn): Likewise.
+       (regclass): Likewise; set frequency according to bb->frequency.
+
+       * flow.c (split_edge): Set frequency.
+
 Sat Jun 23 01:16:42 CEST 2001  Jan Hubicka  <jh@suse.cz>
 
        * predict.c (block_info_def): Add nvisited.

diff --git a/gcc/flow.c b/gcc/flow.c
index 5c0c6d72ad40cae6b9e384a629d0146a7a34affe..2db6d20c000b254e350eca136ecb62a8ea2edaad 100644 (file)
--- a/gcc/flow.c
+++ b/gcc/flow.c
@@ -1627,7 +1627,8 @@ split_edge (edge_in)
   bb->pred = edge_in;
   bb->succ = edge_out;
   bb->count = edge_in->count;
-  /* ??? Set bb->frequency.  */
+  bb->frequency = (edge_in->probability * edge_in->src->frequency
+                  / REG_BR_PROB_BASE);
 
   edge_in->dest = bb;
   edge_in->flags &= ~EDGE_CRITICAL;
@@ -4857,7 +4858,8 @@ mark_set_1 (pbi, code, reg, cond, insn, flags)
                     register twice if it is modified, but that is correct.  */
                  REG_N_SETS (i) += 1;
                  REG_N_REFS (i) += 1;
-                 REG_FREQ (i) += (optimize_size ? 1 : pbi->bb->loop_depth + 1);
+                 REG_FREQ (i) += (optimize_size || !pbi->bb->frequency
+                                  ? 1 : pbi->bb->frequency);
 
                  /* The insns where a reg is live are normally counted
                     elsewhere, but we want the count to include the insn
@@ -5524,7 +5526,8 @@ attempt_auto_inc (pbi, inc, insn, mem, incr, incr_reg)
       /* Count an extra reference to the reg.  When a reg is
         incremented, spilling it is worse, so we want to make
         that less likely.  */
-      REG_FREQ (regno) += (optimize_size ? 1 : pbi->bb->loop_depth + 1);
+      REG_FREQ (regno) += (optimize_size || !phi->bb->frequency
+                          ? 1 : pbi->bb->frequency);
 
       /* Count the increment as a setting of the register,
         even though it isn't a SET in rtl.  */
@@ -5690,7 +5693,7 @@ mark_used_reg (pbi, reg, cond, insn)
 
          /* Count (weighted) number of uses of each reg.  */
          REG_FREQ (regno_first)
-           += (optimize_size ? 1 : pbi->bb->loop_depth + 1);
+           += (optimize_size || !pbi->bb->frequency ? 1 : pbi->bb->frequency);
          REG_N_REFS (regno_first)++;
        }
     }
@@ -6112,7 +6115,8 @@ try_pre_increment_1 (pbi, insn)
         so we want to make that less likely.  */
       if (regno >= FIRST_PSEUDO_REGISTER)
        {
-         REG_FREQ (regno) += (optimize_size ? 1 : pbi->bb->loop_depth + 1);
+         REG_FREQ (regno) += (optimize_size || !phi->bb->frequency
+                              ? 1 : pbi->bb->frequency);
          REG_N_SETS (regno)++;
        }
 

diff --git a/gcc/regclass.c b/gcc/regclass.c
index 35f0e09fb02e3a68d0184267bea8d46188580544..0af5328effef7f5bb90796e15ba966e0e5be214e 100644 (file)
--- a/gcc/regclass.c
+++ b/gcc/regclass.c
@@ -794,10 +794,9 @@ static struct reg_pref *reg_pref;
 
 static struct reg_pref *reg_pref_buffer;
 
-/* Account for the fact that insns within a loop are executed very commonly,
-   but don't keep doing this as loops go too deep.  */
+/* Frequency of executions of current insn.  */
 
-static int loop_cost;
+static int frequency;
 
 static rtx scan_one_insn       PARAMS ((rtx, int));
 static void record_operand_costs PARAMS ((rtx, struct costs *, struct reg_pref *));
@@ -928,10 +927,10 @@ record_operand_costs (insn, op_costs, reg_pref)
 
       if (GET_CODE (recog_data.operand[i]) == MEM)
        record_address_regs (XEXP (recog_data.operand[i], 0),
-                            BASE_REG_CLASS, loop_cost * 2);
+                            BASE_REG_CLASS, frequency * 2);
       else if (constraints[i][0] == 'p')
        record_address_regs (recog_data.operand[i],
-                            BASE_REG_CLASS, loop_cost * 2);
+                            BASE_REG_CLASS, frequency * 2);
     }
 
   /* Check for commutative in a separate loop so everything will
@@ -1007,9 +1006,9 @@ scan_one_insn (insn, pass)
       costs[REGNO (SET_DEST (set))].mem_cost
        -= (MEMORY_MOVE_COST (GET_MODE (SET_DEST (set)),
                              GENERAL_REGS, 1)
-           * loop_cost);
+           * frequency);
       record_address_regs (XEXP (SET_SRC (set), 0),
-                          BASE_REG_CLASS, loop_cost * 2);
+                          BASE_REG_CLASS, frequency * 2);
       return insn;
     }
 
@@ -1059,17 +1058,17 @@ scan_one_insn (insn, pass)
       /* This makes one more setting of new insns's dest.  */
       REG_N_SETS (REGNO (recog_data.operand[0]))++;
       REG_N_REFS (REGNO (recog_data.operand[0]))++;
-      REG_FREQ (REGNO (recog_data.operand[0])) += loop_cost;
+      REG_FREQ (REGNO (recog_data.operand[0])) += frequency;
 
       *recog_data.operand_loc[1] = recog_data.operand[0];
       REG_N_REFS (REGNO (recog_data.operand[0]))++;
-      REG_FREQ (REGNO (recog_data.operand[0])) += loop_cost;
+      REG_FREQ (REGNO (recog_data.operand[0])) += frequency;
       for (i = recog_data.n_dups - 1; i >= 0; i--)
        if (recog_data.dup_num[i] == 1)
          {
            *recog_data.dup_loc[i] = recog_data.operand[0];
            REG_N_REFS (REGNO (recog_data.operand[0]))++;
-           REG_FREQ (REGNO (recog_data.operand[0])) += loop_cost;
+           REG_FREQ (REGNO (recog_data.operand[0])) += frequency;
          }
 
       return PREV_INSN (newinsn);
@@ -1087,9 +1086,9 @@ scan_one_insn (insn, pass)
        int regno = REGNO (recog_data.operand[i]);
        struct costs *p = &costs[regno], *q = &op_costs[i];
 
-       p->mem_cost += q->mem_cost * loop_cost;
+       p->mem_cost += q->mem_cost * frequency;
        for (j = 0; j < N_REG_CLASSES; j++)
-         p->cost[j] += q->cost[j] * loop_cost;
+         p->cost[j] += q->cost[j] * frequency;
       }
 
   return insn;
@@ -1195,7 +1194,7 @@ regclass (f, nregs, dump)
 
       if (!optimize)
        {
-         loop_cost = 1;
+         frequency = 1;
          for (insn = f; insn; insn = NEXT_INSN (insn))
            insn = scan_one_insn (insn, pass);
        }
@@ -1209,9 +1208,9 @@ regclass (f, nregs, dump)
               aggressive than the assumptions made elsewhere and is being
               tried as an experiment.  */
            if (optimize_size)
-             loop_cost = 1;
+             frequency = 1;
            else
-             loop_cost = 1 << (2 * MIN (bb->loop_depth, 5));
+             frequency = bb->frequency ? bb->frequency : 1;
            for (insn = bb->head; ; insn = NEXT_INSN (insn))
              {
                insn = scan_one_insn (insn, pass);