mirror/gcc
2
0
Fork 0
mirror of git://gcc.gnu.org/git/gcc.git synced 2025-02-22 15:10:12 +08:00
Code Issues Packages Projects Releases Wiki Activity

rtl.h (global_rtx_index): New enum.

Browse Source 
* rtl.h (global_rtx_index): New enum.
        (global_rtl): Change to array of rtx.
        (pc_rtx, cc0_rtx): Redefine accordingly.
        (cc0_rtx, stack_pointer_rtx, frame_pointer_rtx): Likewise.
        (hard_frame_pointer_rtx, arg_pointer_rtx): Likewise.
        (virtual_incoming_args_rtx, virtual_stack_vars_rtx): Likewise.
        (virtual_outgoing_args_rtx, virtual_cfa): Likewise.
        (const_int_rtx): Change to array of rtx.
        (const0_rtx, const1_rtx, const2_rtx, constm1_rtx): Redefine
        accordingly.
        * emit-rtl.c (global_rtl): Change to array of rtx.
        (const_int_rtx): Change to aray of rtx.
        (gen_rtx_CONST_INT): Redefine accordingly.
        (init_emit_once): Allocate and initialize global_rtl.  Likewise
        for const_int_rtx.  Add both as GC roots.
        * genattrtab.c (global_rtl): Update declaration.

From-SVN: r29500
This commit is contained in:
Alex Samuel 1999-09-18 18:16:44 +00:00 committed by Richard Henderson
parent 711b552c22
commit 5da077de9b
4 changed files with 194 additions and 191 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
gcc/ChangeLog
View File

@ -1,3 +1,22 @@
Sat Sep 18 11:15:58 1999 Alex Samuel <samuel@codesourcery.com>
* rtl.h (global_rtx_index): New enum.
(global_rtl): Change to array of rtx.
(pc_rtx, cc0_rtx): Redefine accordingly.
(cc0_rtx, stack_pointer_rtx, frame_pointer_rtx): Likewise.
(hard_frame_pointer_rtx, arg_pointer_rtx): Likewise.
(virtual_incoming_args_rtx, virtual_stack_vars_rtx): Likewise.
(virtual_outgoing_args_rtx, virtual_cfa): Likewise.
(const_int_rtx): Change to array of rtx.
(const0_rtx, const1_rtx, const2_rtx, constm1_rtx): Redefine
accordingly.
* emit-rtl.c (global_rtl): Change to array of rtx.
(const_int_rtx): Change to aray of rtx.
(gen_rtx_CONST_INT): Redefine accordingly.
(init_emit_once): Allocate and initialize global_rtl. Likewise
for const_int_rtx. Add both as GC roots.
* genattrtab.c (global_rtl): Update declaration.
1999-09-17 Ulrich Drepper <drepper@cygnus.com>
* Makefile (USER_H): Add iso646.h back.

245
gcc/emit-rtl.c
View File

@ -84,28 +84,7 @@ static int no_line_numbers;
All of these except perhaps the floating-point CONST_DOUBLEs
are unique; no other rtx-object will be equal to any of these. */
/* Avoid warnings by initializing the `fld' field. Since its a union,
bypass problems with KNR compilers by only doing so when __GNUC__. */
#ifdef __GNUC__
#define FLDI , {{0}}
#else
#define FLDI
#endif
struct _global_rtl global_rtl =
{
{PC, VOIDmode, 0, 0, 0, 0, 0, 0, 0, 0, 0 FLDI }, /* pc_rtx */
{CC0, VOIDmode, 0, 0, 0, 0, 0, 0, 0, 0, 0 FLDI }, /* cc0_rtx */
{REG, VOIDmode, 0, 0, 0, 0, 0, 0, 0, 0, 0 FLDI }, /* stack_pointer_rtx */
{REG, VOIDmode, 0, 0, 0, 0, 0, 0, 0, 0, 0 FLDI }, /* frame_pointer_rtx */
{REG, VOIDmode, 0, 0, 0, 0, 0, 0, 0, 0, 0 FLDI }, /* hard_frame_pointer_rtx */
{REG, VOIDmode, 0, 0, 0, 0, 0, 0, 0, 0, 0 FLDI }, /* arg_pointer_rtx */
{REG, VOIDmode, 0, 0, 0, 0, 0, 0, 0, 0, 0 FLDI }, /* virtual_incoming_args_rtx */
{REG, VOIDmode, 0, 0, 0, 0, 0, 0, 0, 0, 0 FLDI }, /* virtual_stack_vars_rtx */
{REG, VOIDmode, 0, 0, 0, 0, 0, 0, 0, 0, 0 FLDI }, /* virtual_stack_dynamic_rtx */
{REG, VOIDmode, 0, 0, 0, 0, 0, 0, 0, 0, 0 FLDI }, /* virtual_outgoing_args_rtx */
{REG, VOIDmode, 0, 0, 0, 0, 0, 0, 0, 0, 0 FLDI }, /* virtual_cfa_rtx */
};
rtx global_rtl[GR_MAX];
/* We record floating-point CONST_DOUBLEs in each floating-point mode for
the values of 0, 1, and 2. For the integer entries and VOIDmode, we
@ -153,7 +132,7 @@ rtx return_address_pointer_rtx; /* (REG:Pmode RETURN_ADDRESS_POINTER_REGNUM) */
to save space during the compilation and simplify comparisons of
integers. */
struct rtx_def const_int_rtx[MAX_SAVED_CONST_INT * 2 + 1];
rtx const_int_rtx[MAX_SAVED_CONST_INT * 2 + 1];
/* start_sequence and gen_sequence can make a lot of rtx expressions which are
shortly thrown away. We use two mechanisms to prevent this waste:
@ -197,7 +176,7 @@ gen_rtx_CONST_INT (mode, arg)
HOST_WIDE_INT arg;
{
if (arg >= - MAX_SAVED_CONST_INT && arg <= MAX_SAVED_CONST_INT)
return &const_int_rtx[arg + MAX_SAVED_CONST_INT];
return const_int_rtx[arg + MAX_SAVED_CONST_INT];
#if STORE_FLAG_VALUE != 1 && STORE_FLAG_VALUE != -1
if (const_true_rtx && arg == STORE_FLAG_VALUE)
@ -3515,121 +3494,32 @@ init_emit_once (line_numbers)
no_line_numbers = ! line_numbers;
/* Compute the word and byte modes. */
byte_mode = VOIDmode;
word_mode = VOIDmode;
double_mode = VOIDmode;
for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
mode = GET_MODE_WIDER_MODE (mode))
{
if (GET_MODE_BITSIZE (mode) == BITS_PER_UNIT
&& byte_mode == VOIDmode)
byte_mode = mode;
if (GET_MODE_BITSIZE (mode) == BITS_PER_WORD
&& word_mode == VOIDmode)
word_mode = mode;
}
#ifndef DOUBLE_TYPE_SIZE
#define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
#endif
for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT); mode != VOIDmode;
mode = GET_MODE_WIDER_MODE (mode))
{
if (GET_MODE_BITSIZE (mode) == DOUBLE_TYPE_SIZE
&& double_mode == VOIDmode)
double_mode = mode;
}
ptr_mode = mode_for_size (POINTER_SIZE, GET_MODE_CLASS (Pmode), 0);
/* Create the unique rtx's for certain rtx codes and operand values. */
/* Don't use gen_rtx here since gen_rtx in this case
tries to use these variables. */
for (i = - MAX_SAVED_CONST_INT; i <= MAX_SAVED_CONST_INT; i++)
{
PUT_CODE (&const_int_rtx[i + MAX_SAVED_CONST_INT], CONST_INT);
PUT_MODE (&const_int_rtx[i + MAX_SAVED_CONST_INT], VOIDmode);
INTVAL (&const_int_rtx[i + MAX_SAVED_CONST_INT]) = i;
}
if (STORE_FLAG_VALUE >= - MAX_SAVED_CONST_INT
&& STORE_FLAG_VALUE <= MAX_SAVED_CONST_INT)
const_true_rtx = &const_int_rtx[STORE_FLAG_VALUE + MAX_SAVED_CONST_INT];
else
const_true_rtx = gen_rtx_CONST_INT (VOIDmode, STORE_FLAG_VALUE);
dconst0 = REAL_VALUE_ATOF ("0", double_mode);
dconst1 = REAL_VALUE_ATOF ("1", double_mode);
dconst2 = REAL_VALUE_ATOF ("2", double_mode);
dconstm1 = REAL_VALUE_ATOF ("-1", double_mode);
for (i = 0; i <= 2; i++)
{
for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT); mode != VOIDmode;
mode = GET_MODE_WIDER_MODE (mode))
{
rtx tem = rtx_alloc (CONST_DOUBLE);
union real_extract u;
bzero ((char *) &u, sizeof u); /* Zero any holes in a structure. */
u.d = i == 0 ? dconst0 : i == 1 ? dconst1 : dconst2;
bcopy ((char *) &u, (char *) &CONST_DOUBLE_LOW (tem), sizeof u);
CONST_DOUBLE_MEM (tem) = cc0_rtx;
PUT_MODE (tem, mode);
const_tiny_rtx[i][(int) mode] = tem;
}
const_tiny_rtx[i][(int) VOIDmode] = GEN_INT (i);
for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
mode = GET_MODE_WIDER_MODE (mode))
const_tiny_rtx[i][(int) mode] = GEN_INT (i);
for (mode = GET_CLASS_NARROWEST_MODE (MODE_PARTIAL_INT);
mode != VOIDmode;
mode = GET_MODE_WIDER_MODE (mode))
const_tiny_rtx[i][(int) mode] = GEN_INT (i);
}
for (mode = CCmode; mode < MAX_MACHINE_MODE; ++mode)
if (GET_MODE_CLASS (mode) == MODE_CC)
const_tiny_rtx[0][(int) mode] = const0_rtx;
/* Assign register numbers to the globally defined register rtx.
This must be done at runtime because the register number field
is in a union and some compilers can't initialize unions. */
REGNO (stack_pointer_rtx) = STACK_POINTER_REGNUM;
PUT_MODE (stack_pointer_rtx, Pmode);
REGNO (frame_pointer_rtx) = FRAME_POINTER_REGNUM;
PUT_MODE (frame_pointer_rtx, Pmode);
#if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
REGNO (hard_frame_pointer_rtx) = HARD_FRAME_POINTER_REGNUM;
PUT_MODE (hard_frame_pointer_rtx, Pmode);
#endif
#if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM && HARD_FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
REGNO (arg_pointer_rtx) = ARG_POINTER_REGNUM;
PUT_MODE (arg_pointer_rtx, Pmode);
#endif
pc_rtx = gen_rtx (PC, VOIDmode);
cc0_rtx = gen_rtx (CC0, VOIDmode);
stack_pointer_rtx = gen_rtx_raw_REG (Pmode, STACK_POINTER_REGNUM);
frame_pointer_rtx = gen_rtx_raw_REG (Pmode, FRAME_POINTER_REGNUM);
if (hard_frame_pointer_rtx == 0)
hard_frame_pointer_rtx = gen_rtx_raw_REG (Pmode,
HARD_FRAME_POINTER_REGNUM);
if (arg_pointer_rtx == 0)
arg_pointer_rtx = gen_rtx_raw_REG (Pmode, ARG_POINTER_REGNUM);
virtual_incoming_args_rtx =
gen_rtx_raw_REG (Pmode, VIRTUAL_INCOMING_ARGS_REGNUM);
virtual_stack_vars_rtx =
gen_rtx_raw_REG (Pmode, VIRTUAL_STACK_VARS_REGNUM);
virtual_stack_dynamic_rtx =
gen_rtx_raw_REG (Pmode, VIRTUAL_STACK_DYNAMIC_REGNUM);
virtual_outgoing_args_rtx =
gen_rtx_raw_REG (Pmode, VIRTUAL_OUTGOING_ARGS_REGNUM);
virtual_cfa_rtx = gen_rtx_raw_REG (Pmode, VIRTUAL_CFA_REGNUM);
REGNO (virtual_incoming_args_rtx) = VIRTUAL_INCOMING_ARGS_REGNUM;
PUT_MODE (virtual_incoming_args_rtx, Pmode);
REGNO (virtual_stack_vars_rtx) = VIRTUAL_STACK_VARS_REGNUM;
PUT_MODE (virtual_stack_vars_rtx, Pmode);
REGNO (virtual_stack_dynamic_rtx) = VIRTUAL_STACK_DYNAMIC_REGNUM;
PUT_MODE (virtual_stack_dynamic_rtx, Pmode);
REGNO (virtual_outgoing_args_rtx) = VIRTUAL_OUTGOING_ARGS_REGNUM;
PUT_MODE (virtual_outgoing_args_rtx, Pmode);
REGNO (virtual_cfa_rtx) = VIRTUAL_CFA_REGNUM;
PUT_MODE (virtual_cfa_rtx, Pmode);
/* These rtx must be roots if GC is enabled. */
if (ggc_p)
ggc_add_rtx_root (global_rtl, GR_MAX);
#ifdef RETURN_ADDRESS_POINTER_REGNUM
return_address_pointer_rtx
@ -3687,6 +3577,93 @@ init_emit_once (line_numbers)
INIT_EXPANDERS;
#endif
/* Compute the word and byte modes. */
byte_mode = VOIDmode;
word_mode = VOIDmode;
double_mode = VOIDmode;
for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
mode = GET_MODE_WIDER_MODE (mode))
{
if (GET_MODE_BITSIZE (mode) == BITS_PER_UNIT
&& byte_mode == VOIDmode)
byte_mode = mode;
if (GET_MODE_BITSIZE (mode) == BITS_PER_WORD
&& word_mode == VOIDmode)
word_mode = mode;
}
#ifndef DOUBLE_TYPE_SIZE
#define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
#endif
for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT); mode != VOIDmode;
mode = GET_MODE_WIDER_MODE (mode))
{
if (GET_MODE_BITSIZE (mode) == DOUBLE_TYPE_SIZE
&& double_mode == VOIDmode)
double_mode = mode;
}
ptr_mode = mode_for_size (POINTER_SIZE, GET_MODE_CLASS (Pmode), 0);
/* Create the unique rtx's for certain rtx codes and operand values. */
/* Don't use gen_rtx here since gen_rtx in this case
tries to use these variables. */
for (i = - MAX_SAVED_CONST_INT; i <= MAX_SAVED_CONST_INT; i++)
const_int_rtx[i + MAX_SAVED_CONST_INT] =
gen_rtx_raw_CONST_INT (VOIDmode, i);
if (ggc_p)
ggc_add_rtx_root (const_int_rtx, 2 * MAX_SAVED_CONST_INT + 1);
if (STORE_FLAG_VALUE >= - MAX_SAVED_CONST_INT
&& STORE_FLAG_VALUE <= MAX_SAVED_CONST_INT)
const_true_rtx = const_int_rtx[STORE_FLAG_VALUE + MAX_SAVED_CONST_INT];
else
const_true_rtx = gen_rtx_CONST_INT (VOIDmode, STORE_FLAG_VALUE);
dconst0 = REAL_VALUE_ATOF ("0", double_mode);
dconst1 = REAL_VALUE_ATOF ("1", double_mode);
dconst2 = REAL_VALUE_ATOF ("2", double_mode);
dconstm1 = REAL_VALUE_ATOF ("-1", double_mode);
for (i = 0; i <= 2; i++)
{
for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT); mode != VOIDmode;
mode = GET_MODE_WIDER_MODE (mode))
{
rtx tem = rtx_alloc (CONST_DOUBLE);
union real_extract u;
bzero ((char *) &u, sizeof u); /* Zero any holes in a structure. */
u.d = i == 0 ? dconst0 : i == 1 ? dconst1 : dconst2;
bcopy ((char *) &u, (char *) &CONST_DOUBLE_LOW (tem), sizeof u);
CONST_DOUBLE_MEM (tem) = cc0_rtx;
PUT_MODE (tem, mode);
const_tiny_rtx[i][(int) mode] = tem;
}
const_tiny_rtx[i][(int) VOIDmode] = GEN_INT (i);
for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
mode = GET_MODE_WIDER_MODE (mode))
const_tiny_rtx[i][(int) mode] = GEN_INT (i);
for (mode = GET_CLASS_NARROWEST_MODE (MODE_PARTIAL_INT);
mode != VOIDmode;
mode = GET_MODE_WIDER_MODE (mode))
const_tiny_rtx[i][(int) mode] = GEN_INT (i);
}
for (mode = CCmode; mode < MAX_MACHINE_MODE; ++mode)
if (GET_MODE_CLASS (mode) == MODE_CC)
const_tiny_rtx[0][(int) mode] = const0_rtx;
ggc_add_rtx_root (&const_tiny_rtx[0][0], sizeof(const_tiny_rtx)/sizeof(rtx));
ggc_add_rtx_root (&const_true_rtx, 1);

2
gcc/genattrtab.c
View File

@ -354,7 +354,7 @@ int optimize = 0;
/* These are referenced by rtlanal.c and hence need to be defined somewhere.
They won't actually be used. */
struct _global_rtl global_rtl;
rtx global_rtl[GR_MAX];
rtx pic_offset_table_rtx;
static void attr_hash_add_rtx PROTO((int, rtx));

119
gcc/rtl.h
View File

@ -1167,17 +1167,13 @@ extern rtx get_first_nonparm_insn PROTO((void));
extern void split_block_insns PROTO((int, int));
extern void update_flow_info PROTO((rtx, rtx, rtx, rtx));
/* Standard pieces of rtx, to be substituted directly into things. */
#define pc_rtx (&global_rtl.pc_val)
#define cc0_rtx (&global_rtl.cc0_val)
#define MAX_SAVED_CONST_INT 64
extern struct rtx_def const_int_rtx[MAX_SAVED_CONST_INT * 2 + 1];
extern rtx const_int_rtx[MAX_SAVED_CONST_INT * 2 + 1];
#define const0_rtx (&const_int_rtx[MAX_SAVED_CONST_INT])
#define const1_rtx (&const_int_rtx[MAX_SAVED_CONST_INT+1])
#define const2_rtx (&const_int_rtx[MAX_SAVED_CONST_INT+2])
#define constm1_rtx (&const_int_rtx[MAX_SAVED_CONST_INT-1])
#define const0_rtx (const_int_rtx[MAX_SAVED_CONST_INT])
#define const1_rtx (const_int_rtx[MAX_SAVED_CONST_INT+1])
#define const2_rtx (const_int_rtx[MAX_SAVED_CONST_INT+2])
#define constm1_rtx (const_int_rtx[MAX_SAVED_CONST_INT-1])
extern rtx const_true_rtx;
extern rtx const_tiny_rtx[3][(int) MAX_MACHINE_MODE];
@ -1192,24 +1188,64 @@ extern rtx const_tiny_rtx[3][(int) MAX_MACHINE_MODE];
#define CONST1_RTX(MODE) (const_tiny_rtx[1][(int) (MODE)])
#define CONST2_RTX(MODE) (const_tiny_rtx[2][(int) (MODE)])
extern struct _global_rtl
/* If HARD_FRAME_POINTER_REGNUM is defined, then a special dummy reg
is used to represent the frame pointer. This is because the
hard frame pointer and the automatic variables are separated by an amount
that cannot be determined until after register allocation. We can assume
that in this case ELIMINABLE_REGS will be defined, one action of which
will be to eliminate FRAME_POINTER_REGNUM into HARD_FRAME_POINTER_REGNUM. */
#ifndef HARD_FRAME_POINTER_REGNUM
#define HARD_FRAME_POINTER_REGNUM FRAME_POINTER_REGNUM
#endif
/* Index labels for global_rtl. */
enum global_rtl_index
{
struct rtx_def pc_val, cc0_val;
struct rtx_def stack_pointer_val, frame_pointer_val;
struct rtx_def hard_frame_pointer_val;
struct rtx_def arg_pointer_val;
struct rtx_def virtual_incoming_args_val;
struct rtx_def virtual_stack_vars_val;
struct rtx_def virtual_stack_dynamic_val;
struct rtx_def virtual_outgoing_args_val;
struct rtx_def virtual_cfa_val;
} global_rtl;
GR_PC,
GR_CC0,
GR_STACK_POINTER,
GR_FRAME_POINTER,
/* For register elimination to work properly these hard_frame_pointer_rtx,
frame_pointer_rtx, and arg_pointer_rtx must be the same if they refer to
the same register. */
#if FRAME_POINTER_REGNUM == ARG_POINTER_REGNUM
GR_ARG_POINTER = GR_FRAME_POINTER,
#endif
#if HARD_FRAME_POINTER_REGNUM == FRAME_POINTER_REGNUM
GR_HARD_FRAME_POINTER = GR_FRAME_POINTER,
#else
GR_HARD_FRAME_POINTER,
#endif
#if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
#if HARD_FRAME_POINTER_REGNUM == ARG_POINTER_REGNUM
GR_ARG_POINTER = GR_HARD_FRAME_POINTER,
#else
GR_ARG_POINTER,
#endif
#endif
GR_VIRTUAL_INCOMING_ARGS,
GR_VIRTUAL_STACK_ARGS,
GR_VIRTUAL_STACK_DYNAMIC,
GR_VIRTUAL_OUTGOING_ARGS,
GR_VIRTUAL_CFA,
GR_MAX
};
/* Pointers to standard pieces of rtx are stored here. */
extern rtx global_rtl[GR_MAX];
/* Standard pieces of rtx, to be substituted directly into things. */
#define pc_rtx (global_rtl[GR_PC])
#define cc0_rtx (global_rtl[GR_CC0])
/* All references to certain hard regs, except those created
by allocating pseudo regs into them (when that's possible),
go through these unique rtx objects. */
#define stack_pointer_rtx (&global_rtl.stack_pointer_val)
#define frame_pointer_rtx (&global_rtl.frame_pointer_val)
#define stack_pointer_rtx (global_rtl[GR_STACK_POINTER])
#define frame_pointer_rtx (global_rtl[GR_FRAME_POINTER])
#define hard_frame_pointer_rtx (global_rtl[GR_HARD_FRAME_POINTER])
#define arg_pointer_rtx (global_rtl[GR_ARG_POINTER])
extern rtx pic_offset_table_rtx;
extern rtx struct_value_rtx;
@ -1239,35 +1275,6 @@ extern rtx gen_rtx_MEM PROTO((enum machine_mode, rtx));
and without prototypes. */
#define GEN_INT(N) gen_rtx_CONST_INT (VOIDmode, (HOST_WIDE_INT) (N))
/* If HARD_FRAME_POINTER_REGNUM is defined, then a special dummy reg
is used to represent the frame pointer. This is because the
hard frame pointer and the automatic variables are separated by an amount
that cannot be determined until after register allocation. We can assume
that in this case ELIMINABLE_REGS will be defined, one action of which
will be to eliminate FRAME_POINTER_REGNUM into HARD_FRAME_POINTER_REGNUM. */
#ifndef HARD_FRAME_POINTER_REGNUM
#define HARD_FRAME_POINTER_REGNUM FRAME_POINTER_REGNUM
#endif
/* For register elimination to work properly these hard_frame_pointer_rtx,
frame_pointer_rtx, and arg_pointer_rtx must be the same if they refer to
the same register. */
#if HARD_FRAME_POINTER_REGNUM == FRAME_POINTER_REGNUM
#define hard_frame_pointer_rtx (&global_rtl.frame_pointer_val)
#else
#define hard_frame_pointer_rtx (&global_rtl.hard_frame_pointer_val)
#endif
#if FRAME_POINTER_REGNUM == ARG_POINTER_REGNUM
#define arg_pointer_rtx (&global_rtl.frame_pointer_val)
#else
#if HARD_FRAME_POINTER_REGNUM == ARG_POINTER_REGNUM
#define arg_pointer_rtx (&global_rtl.hard_frame_pointer_val)
#else
#define arg_pointer_rtx (&global_rtl.arg_pointer_val)
#endif
#endif
/* Virtual registers are used during RTL generation to refer to locations into
the stack frame when the actual location isn't known until RTL generation
is complete. The routine instantiate_virtual_regs replaces these with
@ -1280,7 +1287,7 @@ extern rtx gen_rtx_MEM PROTO((enum machine_mode, rtx));
either by the caller or by the callee when pretending it was passed by the
caller. */
#define virtual_incoming_args_rtx (&global_rtl.virtual_incoming_args_val)
#define virtual_incoming_args_rtx (global_rtl[GR_VIRTUAL_INCOMING_ARGS])
#define VIRTUAL_INCOMING_ARGS_REGNUM (FIRST_VIRTUAL_REGISTER)
@ -1288,7 +1295,7 @@ extern rtx gen_rtx_MEM PROTO((enum machine_mode, rtx));
variable on the stack. Otherwise, it points to the first variable on
the stack. */
#define virtual_stack_vars_rtx (&global_rtl.virtual_stack_vars_val)
#define virtual_stack_vars_rtx (global_rtl[GR_VIRTUAL_STACK_ARGS])
#define VIRTUAL_STACK_VARS_REGNUM ((FIRST_VIRTUAL_REGISTER) + 1)
@ -1296,7 +1303,7 @@ extern rtx gen_rtx_MEM PROTO((enum machine_mode, rtx));
immediately after the stack pointer has been adjusted by the amount
desired. */
#define virtual_stack_dynamic_rtx (&global_rtl.virtual_stack_dynamic_val)
#define virtual_stack_dynamic_rtx (global_rtl[GR_VIRTUAL_STACK_DYNAMIC])
#define VIRTUAL_STACK_DYNAMIC_REGNUM ((FIRST_VIRTUAL_REGISTER) + 2)
@ -1304,7 +1311,7 @@ extern rtx gen_rtx_MEM PROTO((enum machine_mode, rtx));
be written when the stack is pre-pushed (arguments pushed using push
insns always use sp). */
#define virtual_outgoing_args_rtx (&global_rtl.virtual_outgoing_args_val)
#define virtual_outgoing_args_rtx (global_rtl[GR_VIRTUAL_OUTGOING_ARGS])
#define VIRTUAL_OUTGOING_ARGS_REGNUM ((FIRST_VIRTUAL_REGISTER) + 3)
@ -1314,7 +1321,7 @@ extern rtx gen_rtx_MEM PROTO((enum machine_mode, rtx));
frame pointer nor stack pointer are necessarily fixed relative to
the CFA until after reload. */
#define virtual_cfa_rtx (&global_rtl.virtual_cfa_val)
#define virtual_cfa_rtx (global_rtl[GR_VIRTUAL_CFA])
#define VIRTUAL_CFA_REGNUM ((FIRST_VIRTUAL_REGISTER) + 4)