* cse.c (CHEAP_REGNO): Redefine using REGNO_PTR_FRAME_P and

	HARD_REGISTER_NUM_P.

	* cselib.c (new_cselib_val): Make comment correct and more detailed.
	* flow.c (mark_set_1): Likewise.

	* except.c (duplicate_eh_region_1, duplicate_eh_region_2,
	duplicate_eh_regions): Remove.
	* except.h (duplicate_eh_regions): Remove prototype.
	* integrate.c (get_label_from_map, copy_rtx_and_substitute,
	global_const_equiv_varray): Remove.
	* integrate.h (get_label_from_map, copy_rtx_and_substitute,
	global_const_equiv_varray, set_label_in_map): Remove prototypes,
	extern declaration, and #define.
	(MAYBE_EXTEND_CONST_EQUIV_VARRAY, SET_CONST_EQUIV_DATA): Remove.
	(struct inline_remap): Remove.
	* varray.c (struct element): Remove entry for const_equiv_data.
	* varray.h (struct const_equiv_data): Remove.
	(enum varray_data_enum) <VARRAY_DATA_CONST_EQUIV>: Remove.
	(union varray_data_tag) <const_equiv>: Remove.
	(VARRAY_CONST_EQUIV_INIT, VARRAY_CONST_EQUIV,
	VARRAY_PUSH_CONST_EQUIV, VARRAY_TOP_CONST_EQUIV): Remove.

	* regstack.c (record_label_references): Remove unused function.

	* rtl.def (VALUE): Update comment.
	(LABEL_REF): Remove unused operand 2.
	* rtl.h (struct rtx_def): Update for removed accessor macros.
	(XCADVFLAGS, INSN_DEAD_CODE_P, LINE_NUMBER, CONTAINING_INSN,
	REG_LOOP_TEST_P): Remove.
	(ADDR_DIFF_VEC_FLAGS, CSELIB_VAL_PTR, LABEL_NEXTREF): Add comments.
	* web.c (entry_register): Don't copy REG_LOOP_TEST_P.
	* doc/rtl.texi (INSN_DEAD_CODE_P, REG_LOOP_TEST_P): Remove.


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

1 files changed, 0 insertions, 420 deletions

diff --git a/gcc/integrate.c b/gcc/integrate.c
index 2202e22f910..e4a9ddd9d71 100644
--- a/gcc/integrate.c
+++ b/gcc/integrate.c
@@ -64,21 +64,6 @@ typedef struct initial_value_struct GTY(()) {
 static void set_block_origin_self (tree);
 static void set_block_abstract_flags (tree, int);
 
-/* Returns the Ith entry in the label_map contained in MAP.  If the
-   Ith entry has not yet been set, return a fresh label.  This function
-   performs a lazy initialization of label_map, thereby avoiding huge memory
-   explosions when the label_map gets very large.  */
-
-rtx
-get_label_from_map (struct inline_remap *map, int i)
-{
-  rtx x = map->label_map[i];
-
-  if (x == NULL_RTX)
-    x = map->label_map[i] = gen_label_rtx ();
-
-  return x;
-}
 
 /* Return false if the function FNDECL cannot be inlined on account of its
    attributes, true otherwise.  */
@@ -174,412 +159,7 @@ copy_decl_for_inlining (tree decl, tree from_fn, tree to_fn)
 
   return copy;
 }
-
-/* Unfortunately, we need a global copy of const_equiv map for communication
-   with a function called from note_stores.  Be *very* careful that this
-   is used properly in the presence of recursion.  */
-
-varray_type global_const_equiv_varray;
-
-/* Create a new copy of an rtx. Recursively copies the operands of the rtx,
-   except for those few rtx codes that are sharable.
-
-   We always return an rtx that is similar to that incoming rtx, with the
-   exception of possibly changing a REG to a SUBREG or vice versa.  No
-   rtl is ever emitted.
-
-   If FOR_LHS is nonzero, if means we are processing something that will
-   be the LHS of a SET.
-
-   Handle constants that need to be placed in the constant pool by
-   calling `force_const_mem'.  */
-
-rtx
-copy_rtx_and_substitute (rtx orig, struct inline_remap *map, int for_lhs)
-{
-  rtx copy, temp;
-  int i, j;
-  RTX_CODE code;
-  enum machine_mode mode;
-  const char *format_ptr;
-  int regno;
-
-  if (orig == 0)
-    return 0;
-
-  code = GET_CODE (orig);
-  mode = GET_MODE (orig);
-
-  switch (code)
-    {
-    case REG:
-      /* If the stack pointer register shows up, it must be part of
-	 stack-adjustments (*not* because we eliminated the frame pointer!).
-	 Small hard registers are returned as-is.  Pseudo-registers
-	 go through their `reg_map'.  */
-      regno = REGNO (orig);
-      if (regno <= LAST_VIRTUAL_REGISTER)
-	{
-	  /* Some hard registers are also mapped,
-	     but others are not translated.  */
-	  if (map->reg_map[regno] != 0)
-	    return map->reg_map[regno];
-
-	  /* If this is the virtual frame pointer, make space in current
-	     function's stack frame for the stack frame of the inline function.
-
-	     Copy the address of this area into a pseudo.  Map
-	     virtual_stack_vars_rtx to this pseudo and set up a constant
-	     equivalence for it to be the address.  This will substitute the
-	     address into insns where it can be substituted and use the new
-	     pseudo where it can't.  */
-	  else if (regno == VIRTUAL_STACK_VARS_REGNUM)
-	    {
-	      rtx loc, seq;
-	      int size
-		= get_func_frame_size (DECL_STRUCT_FUNCTION (map->fndecl));
-#ifdef FRAME_GROWS_DOWNWARD
-	      int alignment
-		= (DECL_STRUCT_FUNCTION (map->fndecl)->stack_alignment_needed
-		   / BITS_PER_UNIT);
-
-	      /* In this case, virtual_stack_vars_rtx points to one byte
-		 higher than the top of the frame area.  So make sure we
-		 allocate a big enough chunk to keep the frame pointer
-		 aligned like a real one.  */
-	      if (alignment)
-		size = CEIL_ROUND (size, alignment);
-#endif
-	      start_sequence ();
-	      loc = assign_stack_temp (BLKmode, size, 1);
-	      loc = XEXP (loc, 0);
-#ifdef FRAME_GROWS_DOWNWARD
-	      /* In this case, virtual_stack_vars_rtx points to one byte
-		 higher than the top of the frame area.  So compute the offset
-		 to one byte higher than our substitute frame.  */
-	      loc = plus_constant (loc, size);
-#endif
-	      map->reg_map[regno] = temp
-		= force_reg (Pmode, force_operand (loc, NULL_RTX));
-
-#ifdef STACK_BOUNDARY
-	      mark_reg_pointer (map->reg_map[regno], STACK_BOUNDARY);
-#endif
-
-	      SET_CONST_EQUIV_DATA (map, temp, loc, CONST_AGE_PARM);
-
-	      seq = get_insns ();
-	      end_sequence ();
-	      emit_insn_after (seq, map->insns_at_start);
-	      return temp;
-	    }
-	  else if (regno == VIRTUAL_INCOMING_ARGS_REGNUM)
-	    {
-	      /* Do the same for a block to contain any arguments referenced
-		 in memory.  */
-	      rtx loc, seq;
-	      int size = DECL_STRUCT_FUNCTION (map->fndecl)->args_size;
-
-	      start_sequence ();
-	      loc = assign_stack_temp (BLKmode, size, 1);
-	      loc = XEXP (loc, 0);
-	      /* When arguments grow downward, the virtual incoming
-		 args pointer points to the top of the argument block,
-		 so the remapped location better do the same.  */
-#ifdef ARGS_GROW_DOWNWARD
-	      loc = plus_constant (loc, size);
-#endif
-	      map->reg_map[regno] = temp
-		= force_reg (Pmode, force_operand (loc, NULL_RTX));
-
-#ifdef STACK_BOUNDARY
-	      mark_reg_pointer (map->reg_map[regno], STACK_BOUNDARY);
-#endif
-
-	      SET_CONST_EQUIV_DATA (map, temp, loc, CONST_AGE_PARM);
-
-	      seq = get_insns ();
-	      end_sequence ();
-	      emit_insn_after (seq, map->insns_at_start);
-	      return temp;
-	    }
-	  else
-	    return orig;
-
-	  abort ();
-	}
-      if (map->reg_map[regno] == NULL)
-	{
-	  map->reg_map[regno] = gen_reg_rtx (mode);
-	  REG_USERVAR_P (map->reg_map[regno]) = REG_USERVAR_P (orig);
-	  REG_LOOP_TEST_P (map->reg_map[regno]) = REG_LOOP_TEST_P (orig);
-	  /* A reg with REG_FUNCTION_VALUE_P true will never reach here.  */
-
-	  if (REG_POINTER (map->x_regno_reg_rtx[regno]))
-	    mark_reg_pointer (map->reg_map[regno],
-			      map->regno_pointer_align[regno]);
-	}
-      return map->reg_map[regno];
-
-    case SUBREG:
-      copy = copy_rtx_and_substitute (SUBREG_REG (orig), map, for_lhs);
-      return simplify_gen_subreg (GET_MODE (orig), copy,
-				  GET_MODE (SUBREG_REG (orig)),
-				  SUBREG_BYTE (orig));
-
-    case USE:
-    case CLOBBER:
-      /* USE and CLOBBER are ordinary, but we convert (use (subreg foo))
-	 to (use foo) if the original insn didn't have a subreg.
-	 Removing the subreg distorts the VAX movmemhi pattern
-	 by changing the mode of an operand.  */
-      copy = copy_rtx_and_substitute (XEXP (orig, 0), map, code == CLOBBER);
-      if (GET_CODE (copy) == SUBREG && GET_CODE (XEXP (orig, 0)) != SUBREG)
-	copy = SUBREG_REG (copy);
-      return gen_rtx_fmt_e (code, VOIDmode, copy);
-
-    /* We need to handle "deleted" labels that appear in the DECL_RTL
-       of a LABEL_DECL.  */
-    case NOTE:
-      if (NOTE_LINE_NUMBER (orig) != NOTE_INSN_DELETED_LABEL)
-	break;
-
-      /* Fall through.  */
-    case CODE_LABEL:
-      LABEL_PRESERVE_P (get_label_from_map (map, CODE_LABEL_NUMBER (orig)))
-	= LABEL_PRESERVE_P (orig);
-      return get_label_from_map (map, CODE_LABEL_NUMBER (orig));
-
-    case LABEL_REF:
-      copy
-	= gen_rtx_LABEL_REF
-	  (mode,
-	   LABEL_REF_NONLOCAL_P (orig) ? XEXP (orig, 0)
-	   : get_label_from_map (map, CODE_LABEL_NUMBER (XEXP (orig, 0))));
-
-      LABEL_OUTSIDE_LOOP_P (copy) = LABEL_OUTSIDE_LOOP_P (orig);
-
-      /* The fact that this label was previously nonlocal does not mean
-	 it still is, so we must check if it is within the range of
-	 this function's labels.  */
-      LABEL_REF_NONLOCAL_P (copy)
-	= (LABEL_REF_NONLOCAL_P (orig)
-	   && ! (CODE_LABEL_NUMBER (XEXP (copy, 0)) >= get_first_label_num ()
-		 && CODE_LABEL_NUMBER (XEXP (copy, 0)) < max_label_num ()));
-
-      return copy;
-
-    case PC:
-    case CC0:
-    case CONST_INT:
-    case CONST_VECTOR:
-      return orig;
-
-    case SYMBOL_REF:
-      /* Symbols which represent the address of a label stored in the constant
-	 pool must be modified to point to a constant pool entry for the
-	 remapped label.  Otherwise, symbols are returned unchanged.  */
-      if (CONSTANT_POOL_ADDRESS_P (orig))
-	{
-	  struct function *f = cfun;
-	  rtx constant = get_pool_constant_for_function (f, orig);
-	  if (GET_CODE (constant) == LABEL_REF)
-	    return XEXP (force_const_mem
-			 (GET_MODE (orig),
-			  copy_rtx_and_substitute (constant, map, for_lhs)),
-			 0);
-	}
-      return orig;
-
-    case CONST_DOUBLE:
-      /* We have to make a new copy of this CONST_DOUBLE because don't want
-	 to use the old value of CONST_DOUBLE_MEM.  Also, this may be a
-	 duplicate of a CONST_DOUBLE we have already seen.  */
-      if (GET_MODE_CLASS (GET_MODE (orig)) == MODE_FLOAT)
-	{
-	  REAL_VALUE_TYPE d;
-
-	  REAL_VALUE_FROM_CONST_DOUBLE (d, orig);
-	  return CONST_DOUBLE_FROM_REAL_VALUE (d, GET_MODE (orig));
-	}
-      else
-	return immed_double_const (CONST_DOUBLE_LOW (orig),
-				   CONST_DOUBLE_HIGH (orig), VOIDmode);
-
-    case CONST:
-      break;
-
-    case ASM_OPERANDS:
-      /* If a single asm insn contains multiple output operands then
-	 it contains multiple ASM_OPERANDS rtx's that share the input
-	 and constraint vecs.  We must make sure that the copied insn
-	 continues to share it.  */
-      if (map->orig_asm_operands_vector == ASM_OPERANDS_INPUT_VEC (orig))
-	{
-	  copy = rtx_alloc (ASM_OPERANDS);
-	  RTX_FLAG (copy, volatil) = RTX_FLAG (orig, volatil);
-	  PUT_MODE (copy, GET_MODE (orig));
-	  ASM_OPERANDS_TEMPLATE (copy) = ASM_OPERANDS_TEMPLATE (orig);
-	  ASM_OPERANDS_OUTPUT_CONSTRAINT (copy)
-	    = ASM_OPERANDS_OUTPUT_CONSTRAINT (orig);
-	  ASM_OPERANDS_OUTPUT_IDX (copy) = ASM_OPERANDS_OUTPUT_IDX (orig);
-	  ASM_OPERANDS_INPUT_VEC (copy) = map->copy_asm_operands_vector;
-	  ASM_OPERANDS_INPUT_CONSTRAINT_VEC (copy)
-	    = map->copy_asm_constraints_vector;
-#ifdef USE_MAPPED_LOCATION
-	  ASM_OPERANDS_SOURCE_LOCATION (copy)
-	    = ASM_OPERANDS_SOURCE_LOCATION (orig);
-#else
-	  ASM_OPERANDS_SOURCE_FILE (copy) = ASM_OPERANDS_SOURCE_FILE (orig);
-	  ASM_OPERANDS_SOURCE_LINE (copy) = ASM_OPERANDS_SOURCE_LINE (orig);
-#endif
-	  return copy;
-	}
-      break;
-
-    case CALL:
-      /* This is given special treatment because the first
-	 operand of a CALL is a (MEM ...) which may get
-	 forced into a register for cse.  This is undesirable
-	 if function-address cse isn't wanted or if we won't do cse.  */
-#ifndef NO_FUNCTION_CSE
-      if (! (optimize && ! flag_no_function_cse))
-#endif
-	{
-	  rtx copy
-	    = gen_rtx_MEM (GET_MODE (XEXP (orig, 0)),
-			   copy_rtx_and_substitute (XEXP (XEXP (orig, 0), 0),
-						    map, 0));
-
-	  MEM_COPY_ATTRIBUTES (copy, XEXP (orig, 0));
-
-	  return
-	    gen_rtx_CALL (GET_MODE (orig), copy,
-			  copy_rtx_and_substitute (XEXP (orig, 1), map, 0));
-	}
-      break;
-
-#if 0
-    /* Must be ifdefed out for loop unrolling to work.  */
-    /* ??? Is this for the old or the new unroller?  */
-    case RETURN:
-      abort ();
-#endif
 
-    case SET:
-      /* If this is setting fp or ap, it means that we have a nonlocal goto.
-	 Adjust the setting by the offset of the area we made.
-	 If the nonlocal goto is into the current function,
-	 this will result in unnecessarily bad code, but should work.  */
-      if (SET_DEST (orig) == virtual_stack_vars_rtx
-	  || SET_DEST (orig) == virtual_incoming_args_rtx)
-	{
-	  /* In case a translation hasn't occurred already, make one now.  */
-	  rtx equiv_reg;
-	  rtx equiv_loc;
-	  HOST_WIDE_INT loc_offset;
-
-	  copy_rtx_and_substitute (SET_DEST (orig), map, for_lhs);
-	  equiv_reg = map->reg_map[REGNO (SET_DEST (orig))];
-	  equiv_loc = VARRAY_CONST_EQUIV (map->const_equiv_varray,
-					  REGNO (equiv_reg)).rtx;
-	  loc_offset
-	    = REG_P (equiv_loc) ? 0 : INTVAL (XEXP (equiv_loc, 1));
-
-	  return gen_rtx_SET (VOIDmode, SET_DEST (orig),
-			      force_operand
-			      (plus_constant
-			       (copy_rtx_and_substitute (SET_SRC (orig),
-							 map, 0),
-				- loc_offset),
-			       NULL_RTX));
-	}
-      else
-	return gen_rtx_SET (VOIDmode,
-			    copy_rtx_and_substitute (SET_DEST (orig), map, 1),
-			    copy_rtx_and_substitute (SET_SRC (orig), map, 0));
-      break;
-
-    case MEM:
-      copy = gen_rtx_MEM (mode, copy_rtx_and_substitute (XEXP (orig, 0),
-							 map, 0));
-      MEM_COPY_ATTRIBUTES (copy, orig);
-      return copy;
-
-    default:
-      break;
-    }
-
-  copy = rtx_alloc (code);
-  PUT_MODE (copy, mode);
-  RTX_FLAG (copy, in_struct) = RTX_FLAG (orig, in_struct);
-  RTX_FLAG (copy, volatil) = RTX_FLAG (orig, volatil);
-  RTX_FLAG (copy, unchanging) = RTX_FLAG (orig, unchanging);
-
-  format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
-
-  for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
-    {
-      switch (*format_ptr++)
-	{
-	case '0':
-	  X0ANY (copy, i) = X0ANY (orig, i);
-	  break;
-
-	case 'e':
-	  XEXP (copy, i)
-	    = copy_rtx_and_substitute (XEXP (orig, i), map, for_lhs);
-	  break;
-
-	case 'u':
-	  /* Change any references to old-insns to point to the
-	     corresponding copied insns.  */
-	  XEXP (copy, i) = map->insn_map[INSN_UID (XEXP (orig, i))];
-	  break;
-
-	case 'E':
-	  XVEC (copy, i) = XVEC (orig, i);
-	  if (XVEC (orig, i) != NULL && XVECLEN (orig, i) != 0)
-	    {
-	      XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
-	      for (j = 0; j < XVECLEN (copy, i); j++)
-		XVECEXP (copy, i, j)
-		  = copy_rtx_and_substitute (XVECEXP (orig, i, j),
-					     map, for_lhs);
-	    }
-	  break;
-
-	case 'w':
-	  XWINT (copy, i) = XWINT (orig, i);
-	  break;
-
-	case 'i':
-	  XINT (copy, i) = XINT (orig, i);
-	  break;
-
-	case 's':
-	  XSTR (copy, i) = XSTR (orig, i);
-	  break;
-
-	case 't':
-	  XTREE (copy, i) = XTREE (orig, i);
-	  break;
-
-	default:
-	  abort ();
-	}
-    }
-
-  if (code == ASM_OPERANDS && map->orig_asm_operands_vector == 0)
-    {
-      map->orig_asm_operands_vector = ASM_OPERANDS_INPUT_VEC (orig);
-      map->copy_asm_operands_vector = ASM_OPERANDS_INPUT_VEC (copy);
-      map->copy_asm_constraints_vector
-	= ASM_OPERANDS_INPUT_CONSTRAINT_VEC (copy);
-    }
-
-  return copy;
-}
 
 /* Given a pointer to some BLOCK node, if the BLOCK_ABSTRACT_ORIGIN for the
    given BLOCK node is NULL, set the BLOCK_ABSTRACT_ORIGIN for the node so