All of these except perhaps the floating-point CONST_DOUBLEs
are unique; no other rtx-object will be equal to any of these. */
-rtx pc_rtx; /* (PC) */
-rtx cc0_rtx; /* (CC0) */
-rtx cc1_rtx; /* (CC1) (not actually used nowadays) */
-rtx const0_rtx; /* (CONST_INT 0) */
-rtx const1_rtx; /* (CONST_INT 1) */
-rtx const2_rtx; /* (CONST_INT 2) */
-rtx constm1_rtx; /* (CONST_INT -1) */
-rtx const_true_rtx; /* (CONST_INT STORE_FLAG_VALUE) */
+struct _global_rtl global_rtl =
+{
+ {PC, VOIDmode}, /* pc_rtx */
+ {CC0, VOIDmode}, /* cc0_rtx */
+ {REG}, /* stack_pointer_rtx */
+ {REG}, /* frame_pointer_rtx */
+ {REG}, /* hard_frame_pointer_rtx */
+ {REG}, /* arg_pointer_rtx */
+ {REG}, /* virtual_incoming_args_rtx */
+ {REG}, /* virtual_stack_vars_rtx */
+ {REG}, /* virtual_stack_dynamic_rtx */
+ {REG}, /* virtual_outgoing_args_rtx */
+};
/* 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
rtx const_tiny_rtx[3][(int) MAX_MACHINE_MODE];
+rtx const_true_rtx;
+
REAL_VALUE_TYPE dconst0;
REAL_VALUE_TYPE dconst1;
REAL_VALUE_TYPE dconst2;
In an inline procedure, the stack and frame pointer rtxs may not be
used for anything else. */
-rtx stack_pointer_rtx; /* (REG:Pmode STACK_POINTER_REGNUM) */
-rtx frame_pointer_rtx; /* (REG:Pmode FRAME_POINTER_REGNUM) */
-rtx hard_frame_pointer_rtx; /* (REG:Pmode HARD_FRAME_POINTER_REGNUM) */
-rtx arg_pointer_rtx; /* (REG:Pmode ARG_POINTER_REGNUM) */
rtx struct_value_rtx; /* (REG:Pmode STRUCT_VALUE_REGNUM) */
rtx struct_value_incoming_rtx; /* (REG:Pmode STRUCT_VALUE_INCOMING_REGNUM) */
rtx static_chain_rtx; /* (REG:Pmode STATIC_CHAIN_REGNUM) */
See for instance the MIPS port. */
rtx return_address_pointer_rtx; /* (REG:Pmode RETURN_ADDRESS_POINTER_REGNUM) */
-rtx virtual_incoming_args_rtx; /* (REG:Pmode VIRTUAL_INCOMING_ARGS_REGNUM) */
-rtx virtual_stack_vars_rtx; /* (REG:Pmode VIRTUAL_STACK_VARS_REGNUM) */
-rtx virtual_stack_dynamic_rtx; /* (REG:Pmode VIRTUAL_STACK_DYNAMIC_REGNUM) */
-rtx virtual_outgoing_args_rtx; /* (REG:Pmode VIRTUAL_OUTGOING_ARGS_REGNUM) */
-
/* We make one copy of (const_int C) where C is in
[- MAX_SAVED_CONST_INT, MAX_SAVED_CONST_INT]
to save space during the compilation and simplify comparisons of
integers. */
-#define MAX_SAVED_CONST_INT 64
-
-static rtx const_int_rtx[MAX_SAVED_CONST_INT * 2 + 1];
+struct rtx_def const_int_rtx[MAX_SAVED_CONST_INT * 2 + 1];
/* The ends of the doubly-linked chain of rtl for the current function.
Both are reset to null at the start of rtl generation for the function.
HOST_WIDE_INT arg = va_arg (p, HOST_WIDE_INT);
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)
return const_true_rtx;
+#endif
rt_val = rtx_alloc (code);
INTVAL (rt_val) = arg;
Also don't do this when we are making new REGs in reload,
since we don't want to get confused with the real pointers. */
- if (frame_pointer_rtx && regno == FRAME_POINTER_REGNUM && mode == Pmode
+ if (regno == FRAME_POINTER_REGNUM && mode == Pmode
&& ! reload_in_progress)
return frame_pointer_rtx;
#if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
- if (hard_frame_pointer_rtx && regno == HARD_FRAME_POINTER_REGNUM
- && mode == Pmode && ! reload_in_progress)
+ if (regno == HARD_FRAME_POINTER_REGNUM && mode == Pmode
+ && ! reload_in_progress)
return hard_frame_pointer_rtx;
#endif
#if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM && HARD_FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
- if (arg_pointer_rtx && regno == ARG_POINTER_REGNUM && mode == Pmode
+ if (regno == ARG_POINTER_REGNUM && mode == Pmode
&& ! reload_in_progress)
return arg_pointer_rtx;
#endif
&& mode == Pmode && ! reload_in_progress)
return return_address_pointer_rtx;
#endif
- if (stack_pointer_rtx && regno == STACK_POINTER_REGNUM && mode == Pmode
+ if (regno == STACK_POINTER_REGNUM && mode == Pmode
&& ! reload_in_progress)
return stack_pointer_rtx;
else
/* Create the unique rtx's for certain rtx codes and operand values. */
- pc_rtx = gen_rtx (PC, VOIDmode);
- cc0_rtx = gen_rtx (CC0, VOIDmode);
-
- /* 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] = rtx_alloc (CONST_INT);
- PUT_MODE (const_int_rtx[i + MAX_SAVED_CONST_INT], VOIDmode);
- INTVAL (const_int_rtx[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;
}
- /* These four calls obtain some of the rtx expressions made above. */
- const0_rtx = GEN_INT (0);
- const1_rtx = GEN_INT (1);
- const2_rtx = GEN_INT (2);
- constm1_rtx = GEN_INT (-1);
-
- /* This will usually be one of the above constants, but may be a new rtx. */
- const_true_rtx = GEN_INT (STORE_FLAG_VALUE);
+ 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", DFmode);
dconst1 = REAL_VALUE_ATOF ("1", DFmode);
mode = GET_MODE_WIDER_MODE (mode))
const_tiny_rtx[0][(int) mode] = const0_rtx;
- stack_pointer_rtx = gen_rtx (REG, Pmode, STACK_POINTER_REGNUM);
- frame_pointer_rtx = gen_rtx (REG, Pmode, FRAME_POINTER_REGNUM);
- if (HARD_FRAME_POINTER_REGNUM == FRAME_POINTER_REGNUM)
- hard_frame_pointer_rtx = frame_pointer_rtx;
- else
- hard_frame_pointer_rtx = gen_rtx (REG, Pmode, HARD_FRAME_POINTER_REGNUM);
-
- if (FRAME_POINTER_REGNUM == ARG_POINTER_REGNUM)
- arg_pointer_rtx = frame_pointer_rtx;
- else if (HARD_FRAME_POINTER_REGNUM == ARG_POINTER_REGNUM)
- arg_pointer_rtx = hard_frame_pointer_rtx;
- else if (STACK_POINTER_REGNUM == ARG_POINTER_REGNUM)
- arg_pointer_rtx = stack_pointer_rtx;
- else
- arg_pointer_rtx = gen_rtx (REG, Pmode, ARG_POINTER_REGNUM);
+ /* 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);
+ REGNO (hard_frame_pointer_rtx) = HARD_FRAME_POINTER_REGNUM;
+ PUT_MODE (hard_frame_pointer_rtx, Pmode);
+ REGNO (arg_pointer_rtx) = ARG_POINTER_REGNUM;
+ PUT_MODE (arg_pointer_rtx, Pmode);
+
+ 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);
#ifdef RETURN_ADDRESS_POINTER_REGNUM
return_address_pointer_rtx = gen_rtx (REG, Pmode,
RETURN_ADDRESS_POINTER_REGNUM);
#endif
- /* Create the virtual registers. Do so here since the following objects
- might reference them. */
-
- virtual_incoming_args_rtx = gen_rtx (REG, Pmode,
- VIRTUAL_INCOMING_ARGS_REGNUM);
- virtual_stack_vars_rtx = gen_rtx (REG, Pmode,
- VIRTUAL_STACK_VARS_REGNUM);
- virtual_stack_dynamic_rtx = gen_rtx (REG, Pmode,
- VIRTUAL_STACK_DYNAMIC_REGNUM);
- virtual_outgoing_args_rtx = gen_rtx (REG, Pmode,
- VIRTUAL_OUTGOING_ARGS_REGNUM);
-
#ifdef STRUCT_VALUE
struct_value_rtx = STRUCT_VALUE;
#else
extern rtx get_first_nonparm_insn PROTO((void));
/* Standard pieces of rtx, to be substituted directly into things. */
-extern rtx pc_rtx;
-extern rtx cc0_rtx;
-extern rtx const0_rtx;
-extern rtx const1_rtx;
-extern rtx const2_rtx;
-extern rtx constm1_rtx;
+#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];
+
+#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];
#define CONST1_RTX(MODE) (const_tiny_rtx[1][(int) (MODE)])
#define CONST2_RTX(MODE) (const_tiny_rtx[2][(int) (MODE)])
+extern struct _global_rtl
+{
+ 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;
+} global_rtl;
+
/* 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. */
-extern rtx stack_pointer_rtx;
-extern rtx frame_pointer_rtx;
-extern rtx hard_frame_pointer_rtx;
-extern rtx arg_pointer_rtx;
+#define stack_pointer_rtx (&global_rtl.stack_pointer_val)
+#define frame_pointer_rtx (&global_rtl.frame_pointer_val)
+
extern rtx pic_offset_table_rtx;
extern rtx struct_value_rtx;
extern rtx struct_value_incoming_rtx;
#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_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
either by the caller or by the callee when pretending it was passed by the
caller. */
-extern rtx virtual_incoming_args_rtx;
+#define virtual_incoming_args_rtx (&global_rtl.virtual_incoming_args_val)
#define VIRTUAL_INCOMING_ARGS_REGNUM (FIRST_VIRTUAL_REGISTER)
variable on the stack. Otherwise, it points to the first variable on
the stack. */
-extern rtx virtual_stack_vars_rtx;
+#define virtual_stack_vars_rtx (&global_rtl.virtual_stack_vars_val)
#define VIRTUAL_STACK_VARS_REGNUM ((FIRST_VIRTUAL_REGISTER) + 1)
immediately after the stack pointer has been adjusted by the amount
desired. */
-extern rtx virtual_stack_dynamic_rtx;
+#define virtual_stack_dynamic_rtx (&global_rtl.virtual_stack_dynamic_val)
#define VIRTUAL_STACK_DYNAMIC_REGNUM ((FIRST_VIRTUAL_REGISTER) + 2)
be written when the stack is pre-pushed (arguments pushed using push
insns always use sp). */
-extern rtx virtual_outgoing_args_rtx;
+#define virtual_outgoing_args_rtx (&global_rtl.virtual_outgoing_args_val)
#define VIRTUAL_OUTGOING_ARGS_REGNUM ((FIRST_VIRTUAL_REGISTER) + 3)
Allocated in parallel with regno_pointer_flag. */
extern rtx *regno_reg_rtx;
-/* Vector indexed by regno; contains the alignment in bytes for a
- register that contains a pointer, if known. */
+/* Vector indexed by regno; contain the alignment in bytes and type
+ pointed to for a register that contains a pointer, if known. */
extern char *regno_pointer_align;
#define REGNO_POINTER_ALIGN(REGNO) regno_pointer_align[REGNO]
projects / gcc.git / commitdiff