Skip to content

R
riscv-gcc-1
Commit 6642445b by Richard Sandiford Committed by Richard Sandiford
Options

hard-reg-set.h (target_hard_regs): New structure. 

gcc/
	* hard-reg-set.h (target_hard_regs): New structure.
	(default_target_hard_regs): Declare.
	(this_target_hard_regs): Declare as a variable or define as a macro.
	(fixed_regs, fixed_reg_set, call_used_regs, call_really_used_regs)
	(call_used_reg_set, call_fixed_reg_set, regs_invalidated_by_call)
	(reg_alloc_order, inv_reg_alloc_order, reg_class_contents)
	(reg_class_size, reg_class_subclasses, reg_class_subunion)
	(reg_class_superunion, reg_names): Redefine as macros.
	* reginfo.c (fixed_regs, fixed_reg_set, call_used_regs)
	(call_used_reg_set, call_really_used_regs, call_fixed_reg_set)
	(regs_invalidated_by_call, reg_alloc_order, inv_reg_alloc_order)
	(reg_class_contents, reg_class_size, reg_class_subclasses)
	(reg_class_subunion, reg_class_superunion, reg_names): Delete.
	(default_target_hard_regs): New variable
	(this_target_hard_regs, initial_call_really_used_regs)
	(initial_reg_alloc_order): New conditional variables.
	(initial_reg_names): New variable.
	(init_reg_sets): Assert that initial_call_really_used_regs,
	initial_reg_alloc_order and initial_reg_names
	are all the same size as their variable counterparts.  Use them to
	initialize those counterparts.
	* target-globals.h (this_target_hard_regs): Declare.
	(target_globals): Add a hard_regs field.
	(restore_target_globals): Copy the hard_regs field to
	this_target_hard_regs.
	* target-globals.c: Include hard-reg-set.h.
	(default_target_globals): Initialize the hard_regs field.
	(save_target_globals): Likewise.

From-SVN: r162089
parent 5fb0e246
Showing with 152 additions and 137 deletions
gcc/ChangeLog
2010-07-12 Richard Sandiford <rdsandiford@googlemail.com>
* hard-reg-set.h (target_hard_regs): New structure.
(default_target_hard_regs): Declare.
(this_target_hard_regs): Declare as a variable or define as a macro.
(fixed_regs, fixed_reg_set, call_used_regs, call_really_used_regs)
(call_used_reg_set, call_fixed_reg_set, regs_invalidated_by_call)
(reg_alloc_order, inv_reg_alloc_order, reg_class_contents)
(reg_class_size, reg_class_subclasses, reg_class_subunion)
(reg_class_superunion, reg_names): Redefine as macros.
* reginfo.c (fixed_regs, fixed_reg_set, call_used_regs)
(call_used_reg_set, call_really_used_regs, call_fixed_reg_set)
(regs_invalidated_by_call, reg_alloc_order, inv_reg_alloc_order)
(reg_class_contents, reg_class_size, reg_class_subclasses)
(reg_class_subunion, reg_class_superunion, reg_names): Delete.
(default_target_hard_regs): New variable
(this_target_hard_regs, initial_call_really_used_regs)
(initial_reg_alloc_order): New conditional variables.
(initial_reg_names): New variable.
(init_reg_sets): Assert that initial_call_really_used_regs,
initial_reg_alloc_order and initial_reg_names
are all the same size as their variable counterparts. Use them to
initialize those counterparts.
* target-globals.h (this_target_hard_regs): Declare.
(target_globals): Add a hard_regs field.
(restore_target_globals): Copy the hard_regs field to
this_target_hard_regs.
* target-globals.c: Include hard-reg-set.h.
(default_target_globals): Initialize the hard_regs field.
(save_target_globals): Likewise.
2010-07-12 Richard Sandiford <rdsandiford@googlemail.com>
* Makefile.in (target-globals.o): Depend on $(RTL_H).
* rtl.h: (target_rtl): New structure.
(default_target_rtl): Declare.
......
gcc/hard-reg-set.h
......@@ -576,98 +576,122 @@ hard_reg_set_iter_next (hard_reg_set_iterator *iter, unsigned *regno)
/* Define some standard sets of registers. */
/* Indexed by hard register number, contains 1 for registers
that are fixed use (stack pointer, pc, frame pointer, etc.).
These are the registers that cannot be used to allocate
a pseudo reg whose life does not cross calls. */
extern char fixed_regs[FIRST_PSEUDO_REGISTER];
/* The same info as a HARD_REG_SET. */
extern HARD_REG_SET fixed_reg_set;
/* Indexed by hard register number, contains 1 for registers
that are fixed use or are clobbered by function calls.
These are the registers that cannot be used to allocate
a pseudo reg whose life crosses calls. */
extern char call_used_regs[FIRST_PSEUDO_REGISTER];
#ifdef CALL_REALLY_USED_REGISTERS
extern char call_really_used_regs[];
#endif
/* The same info as a HARD_REG_SET. */
extern HARD_REG_SET call_used_reg_set;
/* Contains registers that are fixed use -- i.e. in fixed_reg_set -- or
a function value return register or TARGET_STRUCT_VALUE_RTX or
STATIC_CHAIN_REGNUM. These are the registers that cannot hold quantities
across calls even if we are willing to save and restore them. */
extern HARD_REG_SET call_fixed_reg_set;
/* Indexed by hard register number, contains 1 for registers
that are being used for global register decls.
These must be exempt from ordinary flow analysis
and are also considered fixed. */
extern char global_regs[FIRST_PSEUDO_REGISTER];
/* Contains 1 for registers that are set or clobbered by calls. */
/* ??? Ideally, this would be just call_used_regs plus global_regs, but
for someone's bright idea to have call_used_regs strictly include
fixed_regs. Which leaves us guessing as to the set of fixed_regs
that are actually preserved. We know for sure that those associated
with the local stack frame are safe, but scant others. */
extern HARD_REG_SET regs_invalidated_by_call;
/* Call used hard registers which can not be saved because there is no
insn for this. */
extern HARD_REG_SET no_caller_save_reg_set;
#ifdef REG_ALLOC_ORDER
/* Table of register numbers in the order in which to try to use them. */
struct target_hard_regs {
/* Indexed by hard register number, contains 1 for registers
that are fixed use (stack pointer, pc, frame pointer, etc.;.
These are the registers that cannot be used to allocate
a pseudo reg whose life does not cross calls. */
char x_fixed_regs[FIRST_PSEUDO_REGISTER];
extern int reg_alloc_order[FIRST_PSEUDO_REGISTER];
/* The same info as a HARD_REG_SET. */
HARD_REG_SET x_fixed_reg_set;
/* The inverse of reg_alloc_order. */
/* Indexed by hard register number, contains 1 for registers
that are fixed use or are clobbered by function calls.
These are the registers that cannot be used to allocate
a pseudo reg whose life crosses calls. */
char x_call_used_regs[FIRST_PSEUDO_REGISTER];
extern int inv_reg_alloc_order[FIRST_PSEUDO_REGISTER];
#endif
char x_call_really_used_regs[FIRST_PSEUDO_REGISTER];
/* The same info as a HARD_REG_SET. */
HARD_REG_SET x_call_used_reg_set;
/* For each reg class, a HARD_REG_SET saying which registers are in it. */
/* Contains registers that are fixed use -- i.e. in fixed_reg_set -- or
a function value return register or TARGET_STRUCT_VALUE_RTX or
STATIC_CHAIN_REGNUM. These are the registers that cannot hold quantities
across calls even if we are willing to save and restore them. */
HARD_REG_SET x_call_fixed_reg_set;
extern HARD_REG_SET reg_class_contents[N_REG_CLASSES];
/* Contains 1 for registers that are set or clobbered by calls. */
/* ??? Ideally, this would be just call_used_regs plus global_regs, but
for someone's bright idea to have call_used_regs strictly include
fixed_regs. Which leaves us guessing as to the set of fixed_regs
that are actually preserved. We know for sure that those associated
with the local stack frame are safe, but scant others. */
HARD_REG_SET x_regs_invalidated_by_call;
/* For each reg class, a boolean saying whether the class contains only
fixed registers. */
extern bool class_only_fixed_regs[N_REG_CLASSES];
/* Table of register numbers in the order in which to try to use them. */
int x_reg_alloc_order[FIRST_PSEUDO_REGISTER];
/* For each reg class, number of regs it contains. */
/* The inverse of reg_alloc_order. */
int x_inv_reg_alloc_order[FIRST_PSEUDO_REGISTER];
extern unsigned int reg_class_size[N_REG_CLASSES];
/* For each reg class, a HARD_REG_SET saying which registers are in it. */
HARD_REG_SET x_reg_class_contents[N_REG_CLASSES];
/* For each reg class, table listing all the classes contained in it. */
/* For each reg class, a boolean saying whether the class contains only
fixed registers. */
bool x_class_only_fixed_regs[N_REG_CLASSES];
extern enum reg_class reg_class_subclasses[N_REG_CLASSES][N_REG_CLASSES];
/* For each reg class, number of regs it contains. */
unsigned int x_reg_class_size[N_REG_CLASSES];
/* For each pair of reg classes,
a largest reg class contained in their union. */
/* For each reg class, table listing all the classes contained in it. */
enum reg_class x_reg_class_subclasses[N_REG_CLASSES][N_REG_CLASSES];
extern enum reg_class reg_class_subunion[N_REG_CLASSES][N_REG_CLASSES];
/* For each pair of reg classes,
a largest reg class contained in their union. */
enum reg_class x_reg_class_subunion[N_REG_CLASSES][N_REG_CLASSES];
/* For each pair of reg classes,
the smallest reg class that contains their union. */
/* For each pair of reg classes,
the smallest reg class that contains their union. */
enum reg_class x_reg_class_superunion[N_REG_CLASSES][N_REG_CLASSES];
extern enum reg_class reg_class_superunion[N_REG_CLASSES][N_REG_CLASSES];
/* Vector indexed by hardware reg giving its name. */
const char *x_reg_names[FIRST_PSEUDO_REGISTER];
};
/* Vector indexed by hardware reg giving its name. */
extern struct target_hard_regs default_target_hard_regs;
#if SWITCHABLE_TARGET
extern struct target_hard_regs *this_target_hard_regs;
#else
#define this_target_hard_regs (&default_target_hard_regs)
#endif
extern const char * reg_names[FIRST_PSEUDO_REGISTER];
#define fixed_regs \
(this_target_hard_regs->x_fixed_regs)
#define fixed_reg_set \
(this_target_hard_regs->x_fixed_reg_set)
#define call_used_regs \
(this_target_hard_regs->x_call_used_regs)
#define call_really_used_regs \
(this_target_hard_regs->x_call_really_used_regs)
#define call_used_reg_set \
(this_target_hard_regs->x_call_used_reg_set)
#define call_fixed_reg_set \
(this_target_hard_regs->x_call_fixed_reg_set)
#define regs_invalidated_by_call \
(this_target_hard_regs->x_regs_invalidated_by_call)
#define reg_alloc_order \
(this_target_hard_regs->x_reg_alloc_order)
#define inv_reg_alloc_order \
(this_target_hard_regs->x_inv_reg_alloc_order)
#define reg_class_contents \
(this_target_hard_regs->x_reg_class_contents)
#define class_only_fixed_regs \
(this_target_hard_regs->x_class_only_fixed_regs)
#define reg_class_size \
(this_target_hard_regs->x_reg_class_size)
#define reg_class_subclasses \
(this_target_hard_regs->x_reg_class_subclasses)
#define reg_class_subunion \
(this_target_hard_regs->x_reg_class_subunion)
#define reg_class_superunion \
(this_target_hard_regs->x_reg_class_superunion)
#define reg_names \
(this_target_hard_regs->x_reg_names)
/* Vector indexed by reg class giving its name. */
......
gcc/reginfo.c
......@@ -59,44 +59,22 @@ along with GCC; see the file COPYING3. If not see
int max_regno;
struct target_hard_regs default_target_hard_regs;
struct target_regs default_target_regs;
#if SWITCHABLE_TARGET
struct target_hard_regs *this_target_hard_regs = &default_target_hard_regs;
struct target_regs *this_target_regs = &default_target_regs;
#endif
/* Register tables used by many passes. */
/* Indexed by hard register number, contains 1 for registers
that are fixed use (stack pointer, pc, frame pointer, etc.).
These are the registers that cannot be used to allocate
a pseudo reg for general use. */
char fixed_regs[FIRST_PSEUDO_REGISTER];
/* Same info as a HARD_REG_SET. */
HARD_REG_SET fixed_reg_set;
/* Data for initializing the above. */
/* Data for initializing fixed_regs. */
static const char initial_fixed_regs[] = FIXED_REGISTERS;
/* Indexed by hard register number, contains 1 for registers
that are fixed use or are clobbered by function calls.
These are the registers that cannot be used to allocate
a pseudo reg whose life crosses calls unless we are able
to save/restore them across the calls. */
char call_used_regs[FIRST_PSEUDO_REGISTER];
/* Same info as a HARD_REG_SET. */
HARD_REG_SET call_used_reg_set;
/* Data for initializing the above. */
/* Data for initializing call_used_regs. */
static const char initial_call_used_regs[] = CALL_USED_REGISTERS;
/* This is much like call_used_regs, except it doesn't have to
be a superset of FIXED_REGISTERS. This vector indicates
what is really call clobbered, and is used when defining
regs_invalidated_by_call. */
#ifdef CALL_REALLY_USED_REGISTERS
char call_really_used_regs[] = CALL_REALLY_USED_REGISTERS;
/* Data for initializing call_really_used_regs. */
static const char initial_call_really_used_regs[] = CALL_REALLY_USED_REGISTERS;
#endif
#ifdef CALL_REALLY_USED_REGISTERS
......@@ -105,28 +83,12 @@ char call_really_used_regs[] = CALL_REALLY_USED_REGISTERS;
#define CALL_REALLY_USED_REGNO_P(X) call_used_regs[X]
#endif
/* Contains registers that are fixed use -- i.e. in fixed_reg_set -- or
a function value return register or TARGET_STRUCT_VALUE_RTX or
STATIC_CHAIN_REGNUM. These are the registers that cannot hold quantities
across calls even if we are willing to save and restore them. */
HARD_REG_SET call_fixed_reg_set;
/* Indexed by hard register number, contains 1 for registers
that are being used for global register decls.
These must be exempt from ordinary flow analysis
and are also considered fixed. */
char global_regs[FIRST_PSEUDO_REGISTER];
/* Contains 1 for registers that are set or clobbered by calls. */
/* ??? Ideally, this would be just call_used_regs plus global_regs, but
for someone's bright idea to have call_used_regs strictly include
fixed_regs. Which leaves us guessing as to the set of fixed_regs
that are actually preserved. We know for sure that those associated
with the local stack frame are safe, but scant others. */
HARD_REG_SET regs_invalidated_by_call;
/* Same information as REGS_INVALIDATED_BY_CALL but in regset form to be used
in dataflow more conveniently. */
regset regs_invalidated_by_call_regset;
......@@ -135,21 +97,11 @@ regset regs_invalidated_by_call_regset;
should not be reset after each function is compiled. */
static bitmap_obstack persistent_obstack;
/* Table of register numbers in the order in which to try to use them. */
/* Used to initialize reg_alloc_order. */
#ifdef REG_ALLOC_ORDER
int reg_alloc_order[FIRST_PSEUDO_REGISTER] = REG_ALLOC_ORDER;
/* The inverse of reg_alloc_order. */
int inv_reg_alloc_order[FIRST_PSEUDO_REGISTER];
static int initial_reg_alloc_order[FIRST_PSEUDO_REGISTER] = REG_ALLOC_ORDER;
#endif
/* For each reg class, a HARD_REG_SET saying which registers are in it. */
HARD_REG_SET reg_class_contents[N_REG_CLASSES];
/* For each reg class, a boolean saying whether the class contains only
fixed registers. */
bool class_only_fixed_regs[N_REG_CLASSES];
/* The same information, but as an array of unsigned ints. We copy from
these unsigned ints to the table above. We do this so the tm.h files
do not have to be aware of the wordsize for machines with <= 64 regs.
......@@ -160,22 +112,8 @@ bool class_only_fixed_regs[N_REG_CLASSES];
static const unsigned int_reg_class_contents[N_REG_CLASSES][N_REG_INTS]
= REG_CLASS_CONTENTS;
/* For each reg class, number of regs it contains. */
unsigned int reg_class_size[N_REG_CLASSES];
/* For each reg class, table listing all the classes contained in it. */
enum reg_class reg_class_subclasses[N_REG_CLASSES][N_REG_CLASSES];
/* For each pair of reg classes,
a largest reg class contained in their union. */
enum reg_class reg_class_subunion[N_REG_CLASSES][N_REG_CLASSES];
/* For each pair of reg classes,
the smallest reg class containing their union. */
enum reg_class reg_class_superunion[N_REG_CLASSES][N_REG_CLASSES];
/* Array containing all of the register names. */
const char * reg_names[] = REGISTER_NAMES;
static const char *const initial_reg_names[] = REGISTER_NAMES;
/* Array containing all of the register class names. */
const char * reg_class_names[] = REG_CLASS_NAMES;
......@@ -251,9 +189,25 @@ init_reg_sets (void)
CALL_USED_REGISTERS had the right number of initializers. */
gcc_assert (sizeof fixed_regs == sizeof initial_fixed_regs);
gcc_assert (sizeof call_used_regs == sizeof initial_call_used_regs);
#ifdef CALL_REALLY_USED_REGISTERS
gcc_assert (sizeof call_really_used_regs
== sizeof initial_call_really_used_regs);
#endif
#ifdef REG_ALLOC_ORDER
gcc_assert (sizeof reg_alloc_order == sizeof initial_reg_alloc_order);
#endif
gcc_assert (sizeof reg_names == sizeof initial_reg_names);
memcpy (fixed_regs, initial_fixed_regs, sizeof fixed_regs);
memcpy (call_used_regs, initial_call_used_regs, sizeof call_used_regs);
#ifdef CALL_REALLY_USED_REGISTERS
memcpy (call_really_used_regs, initial_call_really_used_regs,
sizeof call_really_used_regs);
#endif
#ifdef REG_ALLOC_ORDER
memcpy (reg_alloc_order, initial_reg_alloc_order, sizeof reg_alloc_order);
#endif
memcpy (reg_names, initial_reg_names, sizeof reg_names);
memset (global_regs, 0, sizeof global_regs);
}
......
gcc/target-globals.c
......@@ -29,12 +29,14 @@ along with GCC; see the file COPYING3. If not see
#include "flags.h"
#include "regs.h"
#include "rtl.h"
#include "hard-reg-set.h"
#if SWITCHABLE_TARGET
struct target_globals default_target_globals = {
&default_target_flag_state,
&default_target_regs,
&default_target_rtl
&default_target_rtl,
&default_target_hard_regs
};
struct target_globals *
......@@ -46,6 +48,7 @@ save_target_globals (void)
g->flag_state = XCNEW (struct target_flag_state);
g->regs = XCNEW (struct target_regs);
g->rtl = ggc_alloc_cleared_target_rtl ();
g->hard_regs = XCNEW (struct target_hard_regs);
restore_target_globals (g);
target_reinit ();
return g;
......
gcc/target-globals.h
......@@ -24,11 +24,13 @@ along with GCC; see the file COPYING3. If not see
extern struct target_flag_state *this_target_flag_state;
extern struct target_regs *this_target_regs;
extern struct target_rtl *this_target_rtl;
extern struct target_hard_regs *this_target_hard_regs;
struct GTY(()) target_globals {
struct target_flag_state *GTY((skip)) flag_state;
struct target_regs *GTY((skip)) regs;
struct target_rtl *rtl;
struct target_hard_regs *GTY((skip)) hard_regs;
};
extern struct target_globals default_target_globals;
......@@ -41,6 +43,7 @@ restore_target_globals (struct target_globals *g)
this_target_flag_state = g->flag_state;
this_target_regs = g->regs;
this_target_rtl = g->rtl;
this_target_hard_regs = g->hard_regs;
}
#endif
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment