rtl.h (global_rtl): New variable, replacing separate variables for commonly used rtl.

        * rtl.h (global_rtl): New variable, replacing separate variables for
        commonly used rtl.
        (const_int_rtx): Now array of rtx_def, not rtx.
        * emit-rtl.c: Update for new rtl data structures.
        * genattrtab.c: Define global_rtl.

From-SVN: r17049

4 files changed, 112 insertions, 94 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 171940a..8d44e4f 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,11 @@
+Thu Dec 11 17:23:48 1997  John F. Carr  <jfc@mit.edu>
+
+	* rtl.h (global_rtl): New variable, replacing separate variables for
+	commonly used rtl.
+	(const_int_rtx): Now array of rtx_def, not rtx.
+	* emit-rtl.c: Update for new rtl data structures.
+	* genattrtab.c: Define global_rtl.
+
 Thu Dec 11 15:50:29 1997 David Edelsohn  <edelsohn@mhpcc.edu>
 
 	* configure.in ({rs6000,powerpc}-*-*): Enable Haifa scheduler by
diff --git a/gcc/emit-rtl.c b/gcc/emit-rtl.c
index 941c9d0..c8ee89c 100644
--- a/gcc/emit-rtl.c
+++ b/gcc/emit-rtl.c
@@ -111,14 +111,19 @@ 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.  */
 
-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
@@ -126,6 +131,8 @@ rtx const_true_rtx;		/* (CONST_INT STORE_FLAG_VALUE) */
 
 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;
@@ -149,10 +156,6 @@ REAL_VALUE_TYPE dconstm1;
 
    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) */
@@ -163,19 +166,12 @@ rtx pic_offset_table_rtx;	/* (REG:Pmode PIC_OFFSET_TABLE_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.
@@ -314,10 +310,12 @@ gen_rtx VPROTO((enum rtx_code code, enum machine_mode mode, ...))
       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;
@@ -340,16 +338,16 @@ gen_rtx VPROTO((enum rtx_code code, enum machine_mode mode, ...))
 	 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
@@ -358,7 +356,7 @@ gen_rtx VPROTO((enum rtx_code code, enum machine_mode mode, ...))
 	  && 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
@@ -3360,26 +3358,18 @@ init_emit_once (line_numbers)
 
   /* 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);
@@ -3420,40 +3410,34 @@ init_emit_once (line_numbers)
        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
diff --git a/gcc/genattrtab.c b/gcc/genattrtab.c
index 025c61f7..ac5cf0a 100644
--- a/gcc/genattrtab.c
+++ b/gcc/genattrtab.c
@@ -366,8 +366,7 @@ static char *alternative_name;
 /* These are referenced by rtlanal.c and hence need to be defined somewhere.
    They won't actually be used.  */
 
-rtx frame_pointer_rtx, hard_frame_pointer_rtx, stack_pointer_rtx;
-rtx arg_pointer_rtx;
+struct _global_rtl global_rtl;
 
 static rtx attr_rtx		PVPROTO((enum rtx_code, ...));
 #ifdef HAVE_VPRINTF
@@ -493,8 +492,6 @@ struct attr_hash *attr_hash_table[RTL_HASH_SIZE];
    codes are made.  */
 #define RTL_HASH(RTL) ((HOST_WIDE_INT) (RTL) & 0777777)
 
-rtx pc_rtx;
-
 /* Add an entry to the hash table for RTL with hash code HASHCODE.  */
 
 static void
@@ -5620,11 +5617,6 @@ main (argc, argv)
 
   init_rtl ();
 
-  /* We don't use this, but it is referenced in rtlanal.c. 
-     Set it up correctly just in case someone tries to use it someday.  */
-  pc_rtx = rtx_alloc (PC);
-  PUT_MODE (pc_rtx, VOIDmode);
-
   /* Set up true and false rtx's */
   true_rtx = rtx_alloc (CONST_INT);
   XWINT (true_rtx, 0) = 1;
diff --git a/gcc/rtl.h b/gcc/rtl.h
index 47cc556..667cab7 100644
--- a/gcc/rtl.h
+++ b/gcc/rtl.h
@@ -886,12 +886,16 @@ extern enum reg_class reg_alternate_class PROTO((int));
 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];
@@ -906,13 +910,24 @@ 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;
@@ -929,6 +944,25 @@ extern rtx static_chain_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
@@ -941,7 +975,7 @@ extern rtx static_chain_incoming_rtx;
    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)
 
@@ -949,7 +983,7 @@ extern rtx virtual_incoming_args_rtx;
    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)
 
@@ -957,7 +991,7 @@ extern rtx virtual_stack_vars_rtx;
    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)
 
@@ -965,7 +999,7 @@ extern rtx virtual_stack_dynamic_rtx;
    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)
 
@@ -1015,8 +1049,8 @@ extern int cse_not_expected;
    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]