git
/
gcc
mirror of git://gcc.gnu.org/git/gcc.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

ira-int.h (target_ira_int): Rename x_move_cost to x_ira_register_move_cost... 

gcc/
	* ira-int.h (target_ira_int): Rename x_move_cost to
	x_ira_register_move_cost, x_may_move_in_cost to
	x_ira_may_move_in_cost and x_may_move_out_cost to
	x_ira_may_move_out_cost.  Delete the old fields with
	those names and also x_ira_max_register_move_cost,
	x_ira_max_may_move_in_cost and x_ira_max_may_move_out_cost.
	(move_cost, may_move_in_cost, may_move_out_cost)
	(ira_max_register_move_cost, ira_max_may_move_in_cost)
	(ira_max_may_move_out_cost): Delete.
	* ira.c (init_move_cost): Rename to...
	(ira_init_register_move_cost): ...this, deleting the old
	function with that name.  Apply above variable renamings.
	Retain asserts for null fields.
	(ira_init_once): Don't initialize register move costs here.
	(free_register_move_costs): Apply above variable renamings.
	Remove code for deleted fields.

From-SVN: r188047
This commit is contained in:
Richard Sandiford 2012-05-31 05:30:31 +00:00 committed by Richard Sandiford
parent 48e3d6e9de
commit 7cc61ee413
3 changed files with 66 additions and 183 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
gcc/ChangeLog
View File

@ -1,3 +1,22 @@
2012-05-31 Richard Sandiford <rdsandiford@googlemail.com>
* ira-int.h (target_ira_int): Rename x_move_cost to
x_ira_register_move_cost, x_may_move_in_cost to
x_ira_may_move_in_cost and x_may_move_out_cost to
x_ira_may_move_out_cost. Delete the old fields with
those names and also x_ira_max_register_move_cost,
x_ira_max_may_move_in_cost and x_ira_max_may_move_out_cost.
(move_cost, may_move_in_cost, may_move_out_cost)
(ira_max_register_move_cost, ira_max_may_move_in_cost)
(ira_max_may_move_out_cost): Delete.
* ira.c (init_move_cost): Rename to...
(ira_init_register_move_cost): ...this, deleting the old
function with that name. Apply above variable renamings.
Retain asserts for null fields.
(ira_init_once): Don't initialize register move costs here.
(free_register_move_costs): Apply above variable renamings.
Remove code for deleted fields.
2012-05-31 Richard Sandiford <rdsandiford@googlemail.com>
* ira.c (init_move_cost): Adjust choice of subclasses to match

48
gcc/ira-int.h
View File

@ -771,48 +771,22 @@ struct target_ira_int {
/* Maximum cost of moving from a register in one class to a register
in another class. Based on TARGET_REGISTER_MOVE_COST. */
move_table *x_move_cost[MAX_MACHINE_MODE];
move_table *x_ira_register_move_cost[MAX_MACHINE_MODE];
/* Similar, but here we don't have to move if the first index is a
subset of the second so in that case the cost is zero. */
move_table *x_may_move_in_cost[MAX_MACHINE_MODE];
move_table *x_ira_may_move_in_cost[MAX_MACHINE_MODE];
/* Similar, but here we don't have to move if the first index is a
superset of the second so in that case the cost is zero. */
move_table *x_may_move_out_cost[MAX_MACHINE_MODE];
move_table *x_ira_may_move_out_cost[MAX_MACHINE_MODE];
/* Keep track of the last mode we initialized move costs for. */
int x_last_mode_for_init_move_cost;
/* Array based on TARGET_REGISTER_MOVE_COST. Don't use
ira_register_move_cost directly. Use function of
ira_get_may_move_cost instead. */
move_table *x_ira_register_move_cost[MAX_MACHINE_MODE];
/* Array analogs of the macros MEMORY_MOVE_COST and
REGISTER_MOVE_COST but they contain maximal cost not minimal as
the previous two ones do. */
/* Array analog of the macro MEMORY_MOVE_COST but they contain maximal
cost not minimal. */
short int x_ira_max_memory_move_cost[MAX_MACHINE_MODE][N_REG_CLASSES][2];
move_table *x_ira_max_register_move_cost[MAX_MACHINE_MODE];
/* Similar to may_move_in_cost but it is calculated in IRA instead of
regclass. Another difference we take only available hard registers
into account to figure out that one register class is a subset of
the another one. Don't use it directly. Use function of
ira_get_may_move_cost instead. */
move_table *x_ira_may_move_in_cost[MAX_MACHINE_MODE];
/* Similar to may_move_out_cost but it is calculated in IRA instead of
regclass. Another difference we take only available hard registers
into account to figure out that one register class is a subset of
the another one. Don't use it directly. Use function of
ira_get_may_move_cost instead. */
move_table *x_ira_may_move_out_cost[MAX_MACHINE_MODE];
/* Similar to ira_may_move_in_cost and ira_may_move_out_cost but they
return maximal cost. */
move_table *x_ira_max_may_move_in_cost[MAX_MACHINE_MODE];
move_table *x_ira_max_may_move_out_cost[MAX_MACHINE_MODE];
/* Map class->true if class is a possible allocno class, false
otherwise. */
@ -905,26 +879,14 @@ extern struct target_ira_int *this_target_ira_int;
#define ira_reg_mode_hard_regset \
(this_target_ira_int->x_ira_reg_mode_hard_regset)
#define move_cost \
(this_target_ira_int->x_move_cost)
#define may_move_in_cost \
(this_target_ira_int->x_may_move_in_cost)
#define may_move_out_cost \
(this_target_ira_int->x_may_move_out_cost)
#define ira_register_move_cost \
(this_target_ira_int->x_ira_register_move_cost)
#define ira_max_memory_move_cost \
(this_target_ira_int->x_ira_max_memory_move_cost)
#define ira_max_register_move_cost \
(this_target_ira_int->x_ira_max_register_move_cost)
#define ira_may_move_in_cost \
(this_target_ira_int->x_ira_may_move_in_cost)
#define ira_may_move_out_cost \
(this_target_ira_int->x_ira_may_move_out_cost)
#define ira_max_may_move_in_cost \
(this_target_ira_int->x_ira_max_may_move_in_cost)
#define ira_max_may_move_out_cost \
(this_target_ira_int->x_ira_max_may_move_out_cost)
#define ira_reg_allocno_class_p \
(this_target_ira_int->x_ira_reg_allocno_class_p)
#define ira_reg_pressure_class_p \

182
gcc/ira.c
View File

@ -1451,15 +1451,18 @@ clarify_prohibited_class_mode_regs (void)
}
}
/* Initialize may_move_cost and friends for mode M. */
static void
init_move_cost (enum machine_mode mode)
/* Allocate and initialize IRA_REGISTER_MOVE_COST, IRA_MAY_MOVE_IN_COST
and IRA_MAY_MOVE_OUT_COST for MODE. */
void
ira_init_register_move_cost (enum machine_mode mode)
{
static unsigned short last_move_cost[N_REG_CLASSES][N_REG_CLASSES];
bool all_match = true;
unsigned int cl1, cl2;
ira_assert (ira_register_move_cost[mode] == NULL
&& ira_may_move_in_cost[mode] == NULL
&& ira_may_move_out_cost[mode] == NULL);
ira_assert (have_regs_of_mode[mode]);
for (cl1 = 0; cl1 < N_REG_CLASSES; cl1++)
if (contains_reg_of_mode[cl1][mode])
@ -1479,18 +1482,18 @@ init_move_cost (enum machine_mode mode)
}
if (all_match && last_mode_for_init_move_cost != -1)
{
move_cost[mode] = move_cost[last_mode_for_init_move_cost];
may_move_in_cost[mode] = may_move_in_cost[last_mode_for_init_move_cost];
may_move_out_cost[mode] = may_move_out_cost[last_mode_for_init_move_cost];
ira_register_move_cost[mode]
= ira_register_move_cost[last_mode_for_init_move_cost];
ira_may_move_in_cost[mode]
= ira_may_move_in_cost[last_mode_for_init_move_cost];
ira_may_move_out_cost[mode]
= ira_may_move_out_cost[last_mode_for_init_move_cost];
return;
}
last_mode_for_init_move_cost = mode;
move_cost[mode] = (move_table *)xmalloc (sizeof (move_table)
* N_REG_CLASSES);
may_move_in_cost[mode] = (move_table *)xmalloc (sizeof (move_table)
* N_REG_CLASSES);
may_move_out_cost[mode] = (move_table *)xmalloc (sizeof (move_table)
* N_REG_CLASSES);
ira_register_move_cost[mode] = XNEWVEC (move_table, N_REG_CLASSES);
ira_may_move_in_cost[mode] = XNEWVEC (move_table, N_REG_CLASSES);
ira_may_move_out_cost[mode] = XNEWVEC (move_table, N_REG_CLASSES);
for (cl1 = 0; cl1 < N_REG_CLASSES; cl1++)
if (contains_reg_of_mode[cl1][mode])
for (cl2 = 0; cl2 < N_REG_CLASSES; cl2++)
@ -1500,9 +1503,9 @@ init_move_cost (enum machine_mode mode)
if (last_move_cost[cl1][cl2] == 65535)
{
move_cost[mode][cl1][cl2] = 65535;
may_move_in_cost[mode][cl1][cl2] = 65535;
may_move_out_cost[mode][cl1][cl2] = 65535;
ira_register_move_cost[mode][cl1][cl2] = 65535;
ira_may_move_in_cost[mode][cl1][cl2] = 65535;
ira_may_move_out_cost[mode][cl1][cl2] = 65535;
}
else
{
@ -1513,115 +1516,37 @@ init_move_cost (enum machine_mode mode)
if (ira_class_hard_regs_num[*p2] > 0
&& (ira_reg_class_max_nregs[*p2][mode]
<= ira_class_hard_regs_num[*p2]))
cost = MAX (cost, move_cost[mode][cl1][*p2]);
cost = MAX (cost, ira_register_move_cost[mode][cl1][*p2]);
for (p1 = &reg_class_subclasses[cl1][0];
*p1 != LIM_REG_CLASSES; p1++)
if (ira_class_hard_regs_num[*p1] > 0
&& (ira_reg_class_max_nregs[*p1][mode]
<= ira_class_hard_regs_num[*p1]))
cost = MAX (cost, move_cost[mode][*p1][cl2]);
cost = MAX (cost, ira_register_move_cost[mode][*p1][cl2]);
ira_assert (cost <= 65535);
move_cost[mode][cl1][cl2] = cost;
ira_register_move_cost[mode][cl1][cl2] = cost;
if (ira_class_subset_p[cl1][cl2])
may_move_in_cost[mode][cl1][cl2] = 0;
ira_may_move_in_cost[mode][cl1][cl2] = 0;
else
may_move_in_cost[mode][cl1][cl2] = cost;
ira_may_move_in_cost[mode][cl1][cl2] = cost;
if (ira_class_subset_p[cl2][cl1])
may_move_out_cost[mode][cl1][cl2] = 0;
ira_may_move_out_cost[mode][cl1][cl2] = 0;
else
may_move_out_cost[mode][cl1][cl2] = cost;
ira_may_move_out_cost[mode][cl1][cl2] = cost;
}
}
else
for (cl2 = 0; cl2 < N_REG_CLASSES; cl2++)
{
move_cost[mode][cl1][cl2] = 65535;
may_move_in_cost[mode][cl1][cl2] = 65535;
may_move_out_cost[mode][cl1][cl2] = 65535;
ira_register_move_cost[mode][cl1][cl2] = 65535;
ira_may_move_in_cost[mode][cl1][cl2] = 65535;
ira_may_move_out_cost[mode][cl1][cl2] = 65535;
}
}
/* Allocate and initialize IRA_REGISTER_MOVE_COST,
IRA_MAX_REGISTER_MOVE_COST, IRA_MAY_MOVE_IN_COST,
IRA_MAY_MOVE_OUT_COST, IRA_MAX_MAY_MOVE_IN_COST, and
IRA_MAX_MAY_MOVE_OUT_COST for MODE if it is not done yet. */
void
ira_init_register_move_cost (enum machine_mode mode)
{
int cl1, cl2, cl3;
ira_assert (ira_register_move_cost[mode] == NULL
&& ira_max_register_move_cost[mode] == NULL
&& ira_may_move_in_cost[mode] == NULL
&& ira_may_move_out_cost[mode] == NULL
&& ira_max_may_move_in_cost[mode] == NULL
&& ira_max_may_move_out_cost[mode] == NULL);
if (move_cost[mode] == NULL)
init_move_cost (mode);
ira_register_move_cost[mode] = move_cost[mode];
/* Don't use ira_allocate because the tables exist out of scope of a
IRA call. */
ira_max_register_move_cost[mode]
= (move_table *) xmalloc (sizeof (move_table) * N_REG_CLASSES);
memcpy (ira_max_register_move_cost[mode], ira_register_move_cost[mode],
sizeof (move_table) * N_REG_CLASSES);
for (cl1 = 0; cl1 < N_REG_CLASSES; cl1++)
/* Some subclasses are to small to have enough registers to hold
a value of MODE. Just ignore them. */
if (ira_class_hard_regs_num[cl1] > 0
&& ira_reg_class_max_nregs[cl1][mode] <= ira_class_hard_regs_num[cl1])
for (cl2 = 0; cl2 < N_REG_CLASSES; cl2++)
if (hard_reg_set_subset_p (reg_class_contents[cl1],
reg_class_contents[cl2]))
for (cl3 = 0; cl3 < N_REG_CLASSES; cl3++)
{
gcc_assert (ira_register_move_cost[mode][cl2][cl3]
>= ira_register_move_cost[mode][cl1][cl3]);
gcc_assert (ira_register_move_cost[mode][cl3][cl2]
>= ira_register_move_cost[mode][cl3][cl1]);
}
ira_may_move_in_cost[mode]
= (move_table *) xmalloc (sizeof (move_table) * N_REG_CLASSES);
memcpy (ira_may_move_in_cost[mode], may_move_in_cost[mode],
sizeof (move_table) * N_REG_CLASSES);
ira_may_move_out_cost[mode]
= (move_table *) xmalloc (sizeof (move_table) * N_REG_CLASSES);
memcpy (ira_may_move_out_cost[mode], may_move_out_cost[mode],
sizeof (move_table) * N_REG_CLASSES);
ira_max_may_move_in_cost[mode]
= (move_table *) xmalloc (sizeof (move_table) * N_REG_CLASSES);
memcpy (ira_max_may_move_in_cost[mode], ira_max_register_move_cost[mode],
sizeof (move_table) * N_REG_CLASSES);
ira_max_may_move_out_cost[mode]
= (move_table *) xmalloc (sizeof (move_table) * N_REG_CLASSES);
memcpy (ira_max_may_move_out_cost[mode], ira_max_register_move_cost[mode],
sizeof (move_table) * N_REG_CLASSES);
for (cl1 = 0; cl1 < N_REG_CLASSES; cl1++)
if (contains_reg_of_mode[cl1][mode])
for (cl2 = 0; cl2 < N_REG_CLASSES; cl2++)
{
if (!contains_reg_of_mode[cl2][mode]
|| ira_class_hard_regs_num[cl2] == 0)
continue;
if (ira_class_subset_p[cl1][cl2])
gcc_assert (ira_may_move_in_cost[mode][cl1][cl2] == 0);
if (ira_class_subset_p[cl2][cl1])
gcc_assert (ira_may_move_out_cost[mode][cl1][cl2] == 0);
if (ira_class_subset_p[cl1][cl2])
ira_max_may_move_in_cost[mode][cl1][cl2] = 0;
if (ira_class_subset_p[cl2][cl1])
ira_max_may_move_out_cost[mode][cl1][cl2] = 0;
gcc_assert (ira_may_move_in_cost[mode][cl1][cl2]
== ira_max_may_move_in_cost[mode][cl1][cl2]);
gcc_assert (ira_may_move_out_cost[mode][cl1][cl2]
== ira_max_may_move_out_cost[mode][cl1][cl2]);
}
}
/* This is called once during compiler work. It sets up
@ -1630,23 +1555,11 @@ ira_init_register_move_cost (enum machine_mode mode)
void
ira_init_once (void)
{
int mode;
for (mode = 0; mode < MAX_MACHINE_MODE; mode++)
{
ira_register_move_cost[mode] = NULL;
ira_max_register_move_cost[mode] = NULL;
ira_may_move_in_cost[mode] = NULL;
ira_may_move_out_cost[mode] = NULL;
ira_max_may_move_in_cost[mode] = NULL;
ira_max_may_move_out_cost[mode] = NULL;
}
ira_init_costs_once ();
}
/* Free ira_max_register_move_cost, ira_may_move_in_cost,
ira_may_move_out_cost, ira_max_may_move_in_cost, and
ira_max_may_move_out_cost for each mode. */
/* Free ira_max_register_move_cost, ira_may_move_in_cost and
ira_may_move_out_cost for each mode. */
static void
free_register_move_costs (void)
{
@ -1655,35 +1568,24 @@ free_register_move_costs (void)
/* Reset move_cost and friends, making sure we only free shared
table entries once. */
for (mode = 0; mode < MAX_MACHINE_MODE; mode++)
if (move_cost[mode])
if (ira_register_move_cost[mode])
{
for (i = 0; i < mode && move_cost[i] != move_cost[mode]; i++)
for (i = 0;
i < mode && (ira_register_move_cost[i]
!= ira_register_move_cost[mode]);
i++)
;
if (i == mode)
{
free (move_cost[mode]);
free (may_move_in_cost[mode]);
free (may_move_out_cost[mode]);
free (ira_register_move_cost[mode]);
free (ira_may_move_in_cost[mode]);
free (ira_may_move_out_cost[mode]);
}
}
memset (move_cost, 0, sizeof move_cost);
memset (may_move_in_cost, 0, sizeof may_move_in_cost);
memset (may_move_out_cost, 0, sizeof may_move_out_cost);
memset (ira_register_move_cost, 0, sizeof ira_register_move_cost);
memset (ira_may_move_in_cost, 0, sizeof ira_may_move_in_cost);
memset (ira_may_move_out_cost, 0, sizeof ira_may_move_out_cost);
last_mode_for_init_move_cost = -1;
for (mode = 0; mode < MAX_MACHINE_MODE; mode++)
{
free (ira_max_register_move_cost[mode]);
free (ira_may_move_in_cost[mode]);
free (ira_may_move_out_cost[mode]);
free (ira_max_may_move_in_cost[mode]);
free (ira_max_may_move_out_cost[mode]);
ira_register_move_cost[mode] = NULL;
ira_max_register_move_cost[mode] = NULL;
ira_may_move_in_cost[mode] = NULL;
ira_may_move_out_cost[mode] = NULL;
ira_max_may_move_in_cost[mode] = NULL;
ira_max_may_move_out_cost[mode] = NULL;
}
}
/* This is called every time when register related information is