This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
[19/27] Use target structures for init_ira_costs
- From: Richard Sandiford <rdsandiford at googlemail dot com>
- To: gcc-patches at gcc dot gnu dot org
- Date: Wed, 07 Jul 2010 22:17:30 +0100
- Subject: [19/27] Use target structures for init_ira_costs
- References: <87d3v2oqyt.fsf@firetop.home>
The only non-mechanical change here is that some functions passed
the global variable op_costs around as a like-named parameter,
which doesn't work now that op_costs is a macro. There doesn't
seem any need to pass it around, so I just made the functions
use the global version instead.
Richard
gcc/
* ira-int.h (target_ira_int): Add x_max_struct_costs_size, x_init_cost,
x_temp_costs, x_op_costs, x_this_op_costs and x_cost_classes.
* ira-costs.c (max_struct_costs_size, init_cost, temp_costs, op_costs)
(this_op_costs, costs_classes): Redefine as macros.
(record_reg_classes): Don't take op_costs as a parameter.
(record_operand_costs): Likewise. Update calls to record_reg_classes.
(scan_one_insn): Update call to record_operand_costs.
Index: gcc/ira-int.h
===================================================================
--- gcc/ira-int.h 2010-07-04 11:27:49.000000000 +0100
+++ gcc/ira-int.h 2010-07-04 11:56:23.000000000 +0100
@@ -715,6 +715,26 @@ #define FOR_EACH_BIT_IN_MINMAX_SET(VEC,
minmax_set_iter_next (&(ITER)))
struct target_ira_int {
+ /* Initialized once. It is a maximal possible size of the allocated
+ struct costs. */
+ int x_max_struct_costs_size;
+
+ /* Allocated and initialized once, and used to initialize cost values
+ for each insn. */
+ struct costs *x_init_cost;
+
+ /* Allocated once, and used for temporary purposes. */
+ struct costs *x_temp_costs;
+
+ /* Allocated once, and used for the cost calculation. */
+ struct costs *x_op_costs[MAX_RECOG_OPERANDS];
+ struct costs *x_this_op_costs[MAX_RECOG_OPERANDS];
+
+ /* Classes used for cost calculation. They may be different on
+ different iterations of the cost calculations or in different
+ optimization modes. */
+ enum reg_class *x_cost_classes;
+
/* Hard registers that can not be used for the register allocator for
all functions of the current compilation unit. */
HARD_REG_SET x_no_unit_alloc_regs;
Index: gcc/ira-costs.c
===================================================================
--- gcc/ira-costs.c 2010-07-04 11:10:22.000000000 +0100
+++ gcc/ira-costs.c 2010-07-04 11:37:29.000000000 +0100
@@ -67,20 +67,18 @@ struct costs
int cost[1];
};
-/* Initialized once. It is a maximal possible size of the allocated
- struct costs. */
-static int max_struct_costs_size;
-
-/* Allocated and initialized once, and used to initialize cost values
- for each insn. */
-static struct costs *init_cost;
-
-/* Allocated once, and used for temporary purposes. */
-static struct costs *temp_costs;
-
-/* Allocated once, and used for the cost calculation. */
-static struct costs *op_costs[MAX_RECOG_OPERANDS];
-static struct costs *this_op_costs[MAX_RECOG_OPERANDS];
+#define max_struct_costs_size \
+ (this_target_ira_int->x_max_struct_costs_size)
+#define init_cost \
+ (this_target_ira_int->x_init_cost)
+#define temp_costs \
+ (this_target_ira_int->x_temp_costs)
+#define op_costs \
+ (this_target_ira_int->x_op_costs)
+#define this_op_costs \
+ (this_target_ira_int->x_this_op_costs)
+#define cost_classes \
+ (this_target_ira_int->x_cost_classes)
/* Costs of each class for each allocno or pseudo. */
static struct costs *costs;
@@ -88,11 +86,6 @@ struct costs
/* Accumulated costs of each class for each allocno. */
static struct costs *total_allocno_costs;
-/* Classes used for cost calculation. They may be different on
- different iterations of the cost calculations or in different
- optimization modes. */
-static enum reg_class *cost_classes;
-
/* The size of the previous array. */
static int cost_classes_num;
@@ -209,8 +202,7 @@ copy_cost (rtx x, enum machine_mode mode
static void
record_reg_classes (int n_alts, int n_ops, rtx *ops,
enum machine_mode *modes, const char **constraints,
- rtx insn, struct costs **op_costs,
- enum reg_class *pref)
+ rtx insn, enum reg_class *pref)
{
int alt;
int i, j, k;
@@ -944,7 +936,7 @@ record_address_regs (enum machine_mode m
/* Calculate the costs of insn operands. */
static void
-record_operand_costs (rtx insn, struct costs **op_costs, enum reg_class *pref)
+record_operand_costs (rtx insn, enum reg_class *pref)
{
const char *constraints[MAX_RECOG_OPERANDS];
enum machine_mode modes[MAX_RECOG_OPERANDS];
@@ -997,11 +989,11 @@ record_operand_costs (rtx insn, struct c
xconstraints[i+1] = constraints[i];
record_reg_classes (recog_data.n_alternatives, recog_data.n_operands,
recog_data.operand, modes,
- xconstraints, insn, op_costs, pref);
+ xconstraints, insn, pref);
}
record_reg_classes (recog_data.n_alternatives, recog_data.n_operands,
recog_data.operand, modes,
- constraints, insn, op_costs, pref);
+ constraints, insn, pref);
}
@@ -1046,7 +1038,7 @@ scan_one_insn (rtx insn)
0, MEM, SCRATCH, frequency * 2);
}
- record_operand_costs (insn, op_costs, pref);
+ record_operand_costs (insn, pref);
/* Now add the cost for each operand to the total costs for its
allocno. */