* function.h (emit_status): Delete member regno_pointer_flag and

	rename regno_pointer_flag_length to regno_pointer_align_length.
	Delete define for REGNO_POINTER_FLAG.
	* integrate.h (inline_remap): Delete member regno_pointer_flag.
	Add member x_regno_reg_rtx.
	* rtl.h (rtx_def): Use frame_related bit to indicate register is
	a pointer in REG expressions.  Define REG_POINTER macro.
	* alias.c (find_base_value, find_base_term): Use REG_POINTER
	instead of REGNO_POINTER_FLAG.
	* combine.c (nonzero_bits, num_sign_bit_copies): Likewise.
	* emit-rtl.c (gen_reg_rtx): Use regno_pointer_align_length instead
	of regno_pointer_flag_length.  Remove code which refers to
	regno_pointer_flag.
	(mark_reg_pointer): Use REG_POINTER.
	(free_emit_status): Remove code which refers to regno_pointer_flag.
	(init_emit, mark_emit_status): Likewise.
	* flow.c (dump_flow_info): Likewise.
	* function.c (preserve_temp_slots): Likewise.
	* integrate.c (expand_inline_function, copy_rtx_and_substitute):
	Use x_regno_reg_rtx instead of regno_pointer_flag for function
	pointer determination in map.
	* loop.c (strength_reduce, maybe_eliminate_biv_1): Use REG_POINTER.
	* predict.c (estimate_probability): Likewise.
	* regclass.c (record_address_regs, reg_scan_mark_refs): Likewise.
	* unroll.c (unroll_loop): Use x_regno_reg_rtx instead of
	regno_pointer_flag for function pointer determination in map.
	* convex.h (RTX_COSTS): Don't test regno_pointer_flag and use
	REG_POINTER.
	* pa.c (hppa_legitimize_address, emit_move_sequence, basereg_operand):
	Use REG_POINTER.
	(restore_unscaled_index_insn_codes): Revise comment.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@37863 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 11 insertions, 11 deletions

diff --git a/gcc/regclass.c b/gcc/regclass.c
index b9817a27174..078bf9ecf56 100644
--- a/gcc/regclass.c
+++ b/gcc/regclass.c
@@ -1847,10 +1847,10 @@ record_address_regs (x, class, scale)
       /* When we have an address that is a sum,
 	 we must determine whether registers are "base" or "index" regs.
 	 If there is a sum of two registers, we must choose one to be
-	 the "base".  Luckily, we can use the REGNO_POINTER_FLAG
-	 to make a good choice most of the time.  We only need to do this
-	 on machines that can have two registers in an address and where
-	 the base and index register classes are different.
+	 the "base".  Luckily, we can use the REG_POINTER to make a good
+	 choice most of the time.  We only need to do this on machines
+	 that can have two registers in an address and where the base
+	 and index register classes are different.
 
 	 ??? This code used to set REGNO_POINTER_FLAG in some cases, but
 	 that seems bogus since it should only be set when we are sure
@@ -1923,13 +1923,13 @@ record_address_regs (x, class, scale)
 	   with the other operand the index.  Likewise if the other operand
 	   is a MULT.  */
 
-	else if ((code0 == REG && REGNO_POINTER_FLAG (REGNO (arg0)))
+	else if ((code0 == REG && REG_POINTER (arg0))
 		 || code1 == MULT)
 	  {
 	    record_address_regs (arg0, BASE_REG_CLASS, scale);
 	    record_address_regs (arg1, INDEX_REG_CLASS, scale);
 	  }
-	else if ((code1 == REG && REGNO_POINTER_FLAG (REGNO (arg1)))
+	else if ((code1 == REG && REG_POINTER (arg1))
 		 || code0 == MULT)
 	  {
 	    record_address_regs (arg0, INDEX_REG_CLASS, scale);
@@ -2331,18 +2331,18 @@ reg_scan_mark_refs (x, insn, note_flag, min_regno)
 	  /* If the destination pseudo is set more than once, then other
 	     sets might not be to a pointer value (consider access to a
 	     union in two threads of control in the presense of global
-	     optimizations).  So only set REGNO_POINTER_FLAG on the destination
+	     optimizations).  So only set REG_POINTER on the destination
 	     pseudo if this is the only set of that pseudo.  */
 	  && REG_N_SETS (REGNO (SET_DEST (x))) == 1
 	  && ! REG_USERVAR_P (SET_DEST (x))
-	  && ! REGNO_POINTER_FLAG (REGNO (SET_DEST (x)))
+	  && ! REG_POINTER (SET_DEST (x))
 	  && ((GET_CODE (SET_SRC (x)) == REG
-	       && REGNO_POINTER_FLAG (REGNO (SET_SRC (x))))
+	       && REG_POINTER (SET_SRC (x)))
 	      || ((GET_CODE (SET_SRC (x)) == PLUS
 		   || GET_CODE (SET_SRC (x)) == LO_SUM)
 		  && GET_CODE (XEXP (SET_SRC (x), 1)) == CONST_INT
 		  && GET_CODE (XEXP (SET_SRC (x), 0)) == REG
-		  && REGNO_POINTER_FLAG (REGNO (XEXP (SET_SRC (x), 0))))
+		  && REG_POINTER (XEXP (SET_SRC (x), 0)))
 	      || GET_CODE (SET_SRC (x)) == CONST
 	      || GET_CODE (SET_SRC (x)) == SYMBOL_REF
 	      || GET_CODE (SET_SRC (x)) == LABEL_REF
@@ -2359,7 +2359,7 @@ reg_scan_mark_refs (x, insn, note_flag, min_regno)
 		  && (GET_CODE (XEXP (note, 0)) == CONST
 		      || GET_CODE (XEXP (note, 0)) == SYMBOL_REF
 		      || GET_CODE (XEXP (note, 0)) == LABEL_REF))))
-	REGNO_POINTER_FLAG (REGNO (SET_DEST (x))) = 1;
+	REG_POINTER (SET_DEST (x)) = 1;
 
       /* ... fall through ...  */