diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 48cffe46405..8afeccb9004 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,16 @@ +Sat Jun 23 01:23:59 CEST 2001 Jan Hubicka + + * 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 * predict.c (block_info_def): Add nvisited. diff --git a/gcc/flow.c b/gcc/flow.c index 5c0c6d72ad4..2db6d20c000 100644 --- 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 35f0e09fb02..0af5328effe 100644 --- 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);