CbC/CbC_gcc: gcc/emit-rtl.c comparison

comparison gcc/emit-rtl.c @ 67:f6334be47118

update gcc from gcc-4.6-20100522 to gcc-4.6-20110318

author	nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
date	Tue, 22 Mar 2011 17:18:12 +0900
parents	b7f97abdc517
children	04ced10e8804

comparison

equal deleted inserted replaced

-:65488c3d617d
+:f6334be47118
 #include "config.h"
 #include "system.h"
 #include "coretypes.h"
 #include "tm.h"
-#include "toplev.h"
+#include "diagnostic-core.h"
 #include "rtl.h"
 #include "tree.h"
 #include "tm_p.h"
 #include "flags.h"
 #include "function.h"
 #include "langhooks.h"
 #include "tree-pass.h"
 #include "df.h"
 #include "params.h"
 #include "target.h"
+#include "tree-flow.h"
+struct target_rtl default_target_rtl;
+#if SWITCHABLE_TARGET
+struct target_rtl *this_target_rtl = &default_target_rtl;
+#endif
+#define initial_regno_reg_rtx (this_target_rtl->x_initial_regno_reg_rtx)
 /* Commonly used modes.  */
 enum machine_mode byte_mode;	/* Mode whose width is BITS_PER_UNIT.  */
 enum machine_mode word_mode;	/* Mode whose width is BITS_PER_WORD.  */
 /* This is *not* reset after each function.  It gives each CODE_LABEL
 in the entire compilation a unique label number.  */
 static GTY(()) int label_num = 1;
-/* Commonly used rtx's, so that we only need space for one copy.
-These are initialized once for the entire compilation.
-All of these are unique; no other rtx-object will be equal to any
-of these.  */
-rtx global_rtl[GR_MAX];
-/* Commonly used RTL for hard registers.  These objects are not necessarily
-unique, so we allocate them separately from global_rtl.  They are
-initialized once per compilation unit, then copied into regno_reg_rtx
-at the beginning of each function.  */
-static GTY(()) rtx static_regno_reg_rtx[FIRST_PSEUDO_REGISTER];
 /* 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
 record a copy of const[012]_rtx.  */
 /* Record fixed-point constant 0 and 1.  */
 FIXED_VALUE_TYPE fconst0[MAX_FCONST0];
 FIXED_VALUE_TYPE fconst1[MAX_FCONST1];
-/* All references to the following fixed hard registers go through
-these unique rtl objects.  On machines where the frame-pointer and
-arg-pointer are the same register, they use the same unique object.
-After register allocation, other rtl objects which used to be pseudo-regs
-may be clobbered to refer to the frame-pointer register.
-But references that were originally to the frame-pointer can be
-distinguished from the others because they contain frame_pointer_rtx.
-When to use frame_pointer_rtx and hard_frame_pointer_rtx is a little
-tricky: until register elimination has taken place hard_frame_pointer_rtx
-should be used if it is being set, and frame_pointer_rtx otherwise.  After
-register elimination hard_frame_pointer_rtx should always be used.
-On machines where the two registers are same (most) then these are the
-same.
-In an inline procedure, the stack and frame pointer rtxs may not be
-used for anything else.  */
-rtx pic_offset_table_rtx;	/* (REG:Pmode PIC_OFFSET_TABLE_REGNUM) */
-/* This is used to implement __builtin_return_address for some machines.
-See for instance the MIPS port.  */
-rtx return_address_pointer_rtx;	/* (REG:Pmode RETURN_ADDRESS_POINTER_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.  */
 /* A hash table storing all CONST_FIXEDs.  */
 static GTY ((if_marked ("ggc_marked_p"), param_is (struct rtx_def)))
 htab_t const_fixed_htab;
-#define first_insn (crtl->emit.x_first_insn)
-#define last_insn (crtl->emit.x_last_insn)
 #define cur_insn_uid (crtl->emit.x_cur_insn_uid)
 #define cur_debug_insn_uid (crtl->emit.x_cur_debug_insn_uid)
 #define last_location (crtl->emit.x_last_location)
 #define first_label_num (crtl->emit.x_first_label_num)
 attrs.addrspace = addrspace;
 slot = htab_find_slot (mem_attrs_htab, &attrs, INSERT);
 if (*slot == 0)
 {
-*slot = ggc_alloc (sizeof (mem_attrs));
+*slot = ggc_alloc_mem_attrs ();
 memcpy (*slot, &attrs, sizeof (mem_attrs));
 }
 return (mem_attrs *) *slot;
 }
 static hashval_t
 reg_attrs_htab_hash (const void *x)
 {
 const reg_attrs *const p = (const reg_attrs *) x;
-return ((p->offset * 1000) ^ (long) p->decl);
+return ((p->offset * 1000) ^ (intptr_t) p->decl);
 }
 /* Returns nonzero if the value represented by X (which is really a
 reg_attrs *) is the same as that given by Y (which is also really a
 reg_attrs *).  */
 attrs.offset = offset;
 slot = htab_find_slot (reg_attrs_htab, &attrs, INSERT);
 if (*slot == 0)
 {
-*slot = ggc_alloc (sizeof (reg_attrs));
+*slot = ggc_alloc_reg_attrs ();
 memcpy (*slot, &attrs, sizeof (reg_attrs));
 }
 return (reg_attrs *) *slot;
 }
 if (mode == Pmode && !reload_in_progress)
 {
 if (regno == FRAME_POINTER_REGNUM
 	  && (!reload_completed || frame_pointer_needed))
 	return frame_pointer_rtx;
-#if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
+#if !HARD_FRAME_POINTER_IS_FRAME_POINTER
 if (regno == HARD_FRAME_POINTER_REGNUM
 	  && (!reload_completed || frame_pointer_needed))
 	return hard_frame_pointer_rtx;
 #endif
-#if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM && HARD_FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
+#if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM && !HARD_FRAME_POINTER_IS_ARG_POINTER
 if (regno == ARG_POINTER_REGNUM)
 	return arg_pointer_rtx;
 #endif
 #ifdef RETURN_ADDRESS_POINTER_REGNUM
 if (regno == RETURN_ADDRESS_POINTER_REGNUM)
 	return return_address_pointer_rtx;
 #endif
 if (regno == (unsigned) PIC_OFFSET_TABLE_REGNUM
+	  && PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM
 	  && fixed_regs[PIC_OFFSET_TABLE_REGNUM])
 	return pic_offset_table_rtx;
 if (regno == STACK_POINTER_REGNUM)
 	return stack_pointer_rtx;
 }
 unsigned HOST_WIDE_INT offset;
 /* This function can't use
 if (!MEM_EXPR (mem) || !MEM_OFFSET (mem)
 	 || !CONST_INT_P (MEM_OFFSET (mem))
-	 || (get_object_alignment (MEM_EXPR (mem), MEM_ALIGN (mem), align)
+	 || (MAX (MEM_ALIGN (mem),
+	          get_object_alignment (MEM_EXPR (mem), align))
 	     < align))
 return -1;
 else
 return (- INTVAL (MEM_OFFSET (mem))) & (align / BITS_PER_UNIT - 1);
 for two reasons:
 void
 set_mem_attributes_minus_bitpos (rtx ref, tree t, int objectp,
 				 HOST_WIDE_INT bitpos)
 {
-alias_set_type alias = MEM_ALIAS_SET (ref);
+alias_set_type alias;
-tree expr = MEM_EXPR (ref);
+tree expr = NULL;
-rtx offset = MEM_OFFSET (ref);
+rtx offset = NULL_RTX;
-rtx size = MEM_SIZE (ref);
+rtx size = NULL_RTX;
-unsigned int align = MEM_ALIGN (ref);
+unsigned int align = BITS_PER_UNIT;
 HOST_WIDE_INT apply_bitpos = 0;
 tree type;
 /* It can happen that type_for_mode was given a mode for which there
 is no language-level type.  In which case it returns NULL, which
 if ((objectp || DECL_P (t))
 && ! AGGREGATE_TYPE_P (type)
 && TREE_CODE (type) != COMPLEX_TYPE)
 MEM_SCALAR_P (ref) = 1;
+/* Default values from pre-existing memory attributes if present.  */
+if (MEM_ATTRS (ref))
+{
+/* ??? Can this ever happen?  Calling this routine on a MEM that
+	 already carries memory attributes should probably be invalid.  */
+expr = MEM_EXPR (ref);
+offset = MEM_OFFSET (ref);
+size = MEM_SIZE (ref);
+align = MEM_ALIGN (ref);
+}
+/* Otherwise, default values from the mode of the MEM reference.  */
+else if (GET_MODE (ref) != BLKmode)
+{
+/* Respect mode size.  */
+size = GEN_INT (GET_MODE_SIZE (GET_MODE (ref)));
+/* ??? Is this really necessary?  We probably should always get
+	 the size from the type below.  */
+/* Respect mode alignment for STRICT_ALIGNMENT targets if T is a type;
+if T is an object, always compute the object alignment below.  */
+if (STRICT_ALIGNMENT && TYPE_P (t))
+	align = GET_MODE_ALIGNMENT (GET_MODE (ref));
+/* ??? If T is a type, respecting mode alignment may *also* be wrong
+	 e.g. if the type carries an alignment attribute.  Should we be
+	 able to simply always use TYPE_ALIGN?  */
+}
 /* We can set the alignment from the type if we are making an object,
 this is an INDIRECT_REF, or if TYPE_ALIGN_OK.  */
-if (objectp || TREE_CODE (t) == INDIRECT_REF
+if (objectp || TREE_CODE (t) == INDIRECT_REF || TYPE_ALIGN_OK (type))
-|| TREE_CODE (t) == ALIGN_INDIRECT_REF
-|| TYPE_ALIGN_OK (type))
 align = MAX (align, TYPE_ALIGN (type));
-else
-if (TREE_CODE (t) == MISALIGNED_INDIRECT_REF)
+else if (TREE_CODE (t) == MEM_REF)
 {
-	if (integer_zerop (TREE_OPERAND (t, 1)))
+tree op0 = TREE_OPERAND (t, 0);
-	  /* We don't know anything about the alignment.  */
+if (TREE_CODE (op0) == ADDR_EXPR
-	  align = BITS_PER_UNIT;
+	  && (DECL_P (TREE_OPERAND (op0, 0))
-	else
+	      || CONSTANT_CLASS_P (TREE_OPERAND (op0, 0))))
-	  align = tree_low_cst (TREE_OPERAND (t, 1), 1);
+	{
-}
+	  if (DECL_P (TREE_OPERAND (op0, 0)))
+	    align = DECL_ALIGN (TREE_OPERAND (op0, 0));
+	  else if (CONSTANT_CLASS_P (TREE_OPERAND (op0, 0)))
+	    {
+	      align = TYPE_ALIGN (TREE_TYPE (TREE_OPERAND (op0, 0)));
+#ifdef CONSTANT_ALIGNMENT
+	      align = CONSTANT_ALIGNMENT (TREE_OPERAND (op0, 0), align);
+#endif
+	    }
+	  if (TREE_INT_CST_LOW (TREE_OPERAND (t, 1)) != 0)
+	    {
+	      unsigned HOST_WIDE_INT ioff
+		= TREE_INT_CST_LOW (TREE_OPERAND (t, 1));
+	      unsigned HOST_WIDE_INT aoff = (ioff & -ioff) * BITS_PER_UNIT;
+	      align = MIN (aoff, align);
+	    }
+	}
+else
+	/* ??? This isn't fully correct, we can't set the alignment from the
+	   type in all cases.  */
+	align = MAX (align, TYPE_ALIGN (type));
+}
+else if (TREE_CODE (t) == TARGET_MEM_REF)
+/* ??? This isn't fully correct, we can't set the alignment from the
+type in all cases.  */
+align = MAX (align, TYPE_ALIGN (type));
 /* If the size is known, we can set that.  */
 if (TYPE_SIZE_UNIT (type) && host_integerp (TYPE_SIZE_UNIT (type), 1))
 size = GEN_INT (tree_low_cst (TYPE_SIZE_UNIT (type), 1));
 while (CONVERT_EXPR_P (t)
 	     || TREE_CODE (t) == VIEW_CONVERT_EXPR
 	     || TREE_CODE (t) == SAVE_EXPR)
 	t = TREE_OPERAND (t, 0);
-/* We may look through structure-like accesses for the purposes of
+/* Note whether this expression can trap.  */
-	 examining TREE_THIS_NOTRAP, but not array-like accesses.  */
+MEM_NOTRAP_P (ref) = !tree_could_trap_p (t);
-base = t;
-while (TREE_CODE (base) == COMPONENT_REF
+base = get_base_address (t);
-	     || TREE_CODE (base) == REALPART_EXPR
-	     || TREE_CODE (base) == IMAGPART_EXPR
-	     || TREE_CODE (base) == BIT_FIELD_REF)
-	base = TREE_OPERAND (base, 0);
-if (DECL_P (base))
-	{
-	  if (CODE_CONTAINS_STRUCT (TREE_CODE (base), TS_DECL_WITH_VIS))
-	    MEM_NOTRAP_P (ref) = !DECL_WEAK (base);
-	  else
-	    MEM_NOTRAP_P (ref) = 1;
-	}
-else
-	MEM_NOTRAP_P (ref) = TREE_THIS_NOTRAP (base);
-base = get_base_address (base);
 if (base && DECL_P (base)
 	  && TREE_READONLY (base)
-	  && (TREE_STATIC (base) || DECL_EXTERNAL (base)))
+	  && (TREE_STATIC (base) || DECL_EXTERNAL (base))
-	{
+	  && !TREE_THIS_VOLATILE (base))
-	  tree base_type = TREE_TYPE (base);
+	MEM_READONLY_P (ref) = 1;
-	  gcc_assert (!(base_type && TYPE_NEEDS_CONSTRUCTING (base_type))
-		      || DECL_ARTIFICIAL (base));
-	  MEM_READONLY_P (ref) = 1;
-	}
 /* If this expression uses it's parent's alias set, mark it such
 	 that we won't change it.  */
 if (component_uses_parent_alias_set (t))
 	MEM_KEEP_ALIAS_SET_P (ref) = 1;
 	      /* ??? Any reason the field size would be different than
 		 the size we got from the type?  */
 	    }
 	  /* If this is an indirect reference, record it.  */
-	  else if (TREE_CODE (t) == INDIRECT_REF
+	  else if (TREE_CODE (t) == MEM_REF)
-		   || TREE_CODE (t) == MISALIGNED_INDIRECT_REF)
 	    {
 	      expr = t;
 	      offset = const0_rtx;
 	      apply_bitpos = bitpos;
 	    }
 	}
 /* If this is an indirect reference, record it.  */
-else if (TREE_CODE (t) == INDIRECT_REF
+else if (TREE_CODE (t) == MEM_REF
-	       || TREE_CODE (t) == MISALIGNED_INDIRECT_REF)
+	       || TREE_CODE (t) == TARGET_MEM_REF)
 	{
 	  expr = t;
 	  offset = const0_rtx;
 	  apply_bitpos = bitpos;
 	}
 if (!align_computed && !INDIRECT_REF_P (t))
 	{
-	  unsigned int obj_align
+	  unsigned int obj_align = get_object_alignment (t, BIGGEST_ALIGNMENT);
-	    = get_object_alignment (t, align, BIGGEST_ALIGNMENT);
 	  align = MAX (align, obj_align);
 	}
 }
 /* If we modified OFFSET based on T, then subtract the outstanding
 if (apply_bitpos)
 {
 offset = plus_constant (offset, -(apply_bitpos / BITS_PER_UNIT));
 if (size)
 	size = plus_constant (size, apply_bitpos / BITS_PER_UNIT);
-}
-if (TREE_CODE (t) == ALIGN_INDIRECT_REF)
-{
-/* Force EXPR and OFFSET to NULL, since we don't know exactly what
-	 we're overlapping.  */
-offset = NULL;
-expr = NULL;
 }
 /* Now set the attributes we computed above.  */
 MEM_ATTRS (ref)
 = get_mem_attrs (alias, expr, offset, size, align,
 /* Set the alias set of MEM to SET.  */
 void
 set_mem_alias_set (rtx mem, alias_set_type set)
 {
-#ifdef ENABLE_CHECKING
 /* If the new and old alias sets don't conflict, something is wrong.  */
-gcc_assert (alias_sets_conflict_p (set, MEM_ALIAS_SET (mem)));
+gcc_checking_assert (alias_sets_conflict_p (set, MEM_ALIAS_SET (mem)));
-#endif
 MEM_ATTRS (mem) = get_mem_attrs (set, MEM_EXPR (mem), MEM_OFFSET (mem),
 				   MEM_SIZE (mem), MEM_ALIGN (mem),
 				   MEM_ADDR_SPACE (mem), GET_MODE (mem));
 }
 d = build_decl (DECL_SOURCE_LOCATION (current_function_decl),
 		  VAR_DECL, get_identifier ("%sfp"), void_type_node);
 DECL_ARTIFICIAL (d) = 1;
 DECL_IGNORED_P (d) = 1;
 TREE_USED (d) = 1;
-TREE_THIS_NOTRAP (d) = 1;
 spill_slot_decl = d;
 rd = gen_rtx_MEM (BLKmode, frame_pointer_rtx);
 MEM_NOTRAP_P (rd) = 1;
 MEM_ATTRS (rd) = get_mem_attrs (new_alias_set (), d, const0_rtx,
 void
 set_new_first_and_last_insn (rtx first, rtx last)
 {
 rtx insn;
-first_insn = first;
+set_first_insn (first);
-last_insn = last;
+set_last_insn (last);
 cur_insn_uid = 0;
 if (MIN_NONDEBUG_INSN_UID || MAY_HAVE_DEBUG_INSNS)
 {
 int debug_count = 0;
 /* Make sure that virtual stack slots are not shared.  */
 set_used_decls (DECL_INITIAL (cfun->decl));
 /* Make sure that virtual parameters are not shared.  */
-for (decl = DECL_ARGUMENTS (cfun->decl); decl; decl = TREE_CHAIN (decl))
+for (decl = DECL_ARGUMENTS (cfun->decl); decl; decl = DECL_CHAIN (decl))
 set_used_flags (DECL_RTL (decl));
 reset_used_flags (stack_slot_list);
 unshare_all_rtl_1 (insn);
 }
 /* Go through all the RTL insn bodies and check that there is no unexpected
 sharing in between the subexpressions.  */
-void
+DEBUG_FUNCTION void
 verify_rtl_sharing (void)
 {
 rtx p;
+timevar_push (TV_VERIFY_RTL_SHARING);
 for (p = get_insns (); p; p = NEXT_INSN (p))
 if (INSN_P (p))
 {
 	reset_used_flags (PATTERN (p));
 if (INSN_P (p))
 {
 	verify_rtx_sharing (PATTERN (p), p);
 	verify_rtx_sharing (REG_NOTES (p), p);
 }
+timevar_pop (TV_VERIFY_RTL_SHARING);
 }
 /* Go through all the RTL insn bodies and copy any invalid shared structure.
 Assumes the mark bits are cleared at entry.  */
 set_used_decls (tree blk)
 {
 tree t;
 /* Mark decls.  */
-for (t = BLOCK_VARS (blk); t; t = TREE_CHAIN (t))
+for (t = BLOCK_VARS (blk); t; t = DECL_CHAIN (t))
 if (DECL_RTL_SET_P (t))
 set_used_flags (DECL_RTL (t));
 /* Now process sub-blocks.  */
 for (t = BLOCK_SUBBLOCKS (blk); t; t = BLOCK_CHAIN (t))
 goto repeat;
 }
 return;
 }
-/* Clear all the USED bits in X to allow copy_rtx_if_shared to be used
+/* Set the USED bit in X and its non-shareable subparts to FLAG.  */
-to look for shared sub-parts.  */
+static void
-void
+mark_used_flags (rtx x, int flag)
-reset_used_flags (rtx x)
 {
 int i, j;
 enum rtx_code code;
 const char *format_ptr;
 int length;
 default:
 break;
 }
-RTX_FLAG (x, used) = 0;
+RTX_FLAG (x, used) = flag;
 format_ptr = GET_RTX_FORMAT (code);
 length = GET_RTX_LENGTH (code);
 for (i = 0; i < length; i++)
 if (i == length-1)
 {
 x = XEXP (x, i);
 	      goto repeat;
 }
-	  reset_used_flags (XEXP (x, i));
+	  mark_used_flags (XEXP (x, i), flag);
 	  break;
 	case 'E':
 	  for (j = 0; j < XVECLEN (x, i); j++)
-	    reset_used_flags (XVECEXP (x, i, j));
+	    mark_used_flags (XVECEXP (x, i, j), flag);
 	  break;
 	}
 }
 }
+/* Clear all the USED bits in X to allow copy_rtx_if_shared to be used
+to look for shared sub-parts.  */
+void
+reset_used_flags (rtx x)
+{
+mark_used_flags (x, 0);
+}
 /* Set all the USED bits in X to allow copy_rtx_if_shared to be used
 to look for shared sub-parts.  */
 void
 set_used_flags (rtx x)
 {
-int i, j;
+mark_used_flags (x, 1);
-enum rtx_code code;
-const char *format_ptr;
-if (x == 0)
-return;
-code = GET_CODE (x);
-/* These types may be freely shared so we needn't do any resetting
-for them.  */
-switch (code)
-{
-case REG:
-case DEBUG_EXPR:
-case VALUE:
-case CONST_INT:
-case CONST_DOUBLE:
-case CONST_FIXED:
-case CONST_VECTOR:
-case SYMBOL_REF:
-case CODE_LABEL:
-case PC:
-case CC0:
-return;
-case DEBUG_INSN:
-case INSN:
-case JUMP_INSN:
-case CALL_INSN:
-case NOTE:
-case LABEL_REF:
-case BARRIER:
-/* The chain of insns is not being copied.  */
-return;
-default:
-break;
-}
-RTX_FLAG (x, used) = 1;
-format_ptr = GET_RTX_FORMAT (code);
-for (i = 0; i < GET_RTX_LENGTH (code); i++)
-{
-switch (*format_ptr++)
-	{
-	case 'e':
-	  set_used_flags (XEXP (x, i));
-	  break;
-	case 'E':
-	  for (j = 0; j < XVECLEN (x, i); j++)
-	    set_used_flags (XVECEXP (x, i, j));
-	  break;
-	}
-}
 }
 /* Copy X if necessary so that it won't be altered by changes in OTHER.
 Return X or the rtx for the pseudo reg the value of X was copied into.
 OTHER must be valid as a SET_DEST.  */
 return x;
 }
 /* Emission of insns (adding them to the doubly-linked list).  */
-/* Return the first insn of the current sequence or current function.  */
-rtx
-get_insns (void)
-{
-return first_insn;
-}
-/* Specify a new insn as the first in the chain.  */
-void
-set_first_insn (rtx insn)
-{
-gcc_assert (!PREV_INSN (insn));
-first_insn = insn;
-}
-/* Return the last insn emitted in current sequence or current function.  */
-rtx
-get_last_insn (void)
-{
-return last_insn;
-}
-/* Specify a new insn as the last in the chain.  */
-void
-set_last_insn (rtx insn)
-{
-gcc_assert (!NEXT_INSN (insn));
-last_insn = insn;
-}
 /* Return the last insn emitted, even if it is in a sequence now pushed.  */
 rtx
 get_last_insn_anywhere (void)
 {
 struct sequence_stack *stack;
-if (last_insn)
+if (get_last_insn ())
-return last_insn;
+return get_last_insn ();
 for (stack = seq_stack; stack; stack = stack->next)
 if (stack->last != 0)
 return stack->last;
 return 0;
 }
 function.  This routine looks inside SEQUENCEs.  */
 rtx
 get_first_nonnote_insn (void)
 {
-rtx insn = first_insn;
+rtx insn = get_insns ();
 if (insn)
 {
 if (NOTE_P (insn))
 	for (insn = next_insn (insn);
 function.  This routine looks inside SEQUENCEs.  */
 rtx
 get_last_nonnote_insn (void)
 {
-rtx insn = last_insn;
+rtx insn = get_last_insn ();
 if (insn)
 {
 if (NOTE_P (insn))
 	for (insn = previous_insn (insn);
 }
 return insn;
 }
-/* Return a number larger than any instruction's uid in this function.  */
-int
-get_max_uid (void)
-{
-return cur_insn_uid;
-}
 /* Return the number of actual (non-debug) insns emitted in this
 function.  */
 int
 get_max_insn_count (void)
 {
 while (insn)
 {
 insn = PREV_INSN (insn);
 if (insn == 0 || !DEBUG_INSN_P (insn))
+	break;
+}
+return insn;
+}
+/* Return the next insn after INSN that is not a NOTE nor DEBUG_INSN.
+This routine does not look inside SEQUENCEs.  */
+rtx
+next_nonnote_nondebug_insn (rtx insn)
+{
+while (insn)
+{
+insn = NEXT_INSN (insn);
+if (insn == 0 || (!NOTE_P (insn) && !DEBUG_INSN_P (insn)))
+	break;
+}
+return insn;
+}
+/* Return the previous insn before INSN that is not a NOTE nor DEBUG_INSN.
+This routine does not look inside SEQUENCEs.  */
+rtx
+prev_nonnote_nondebug_insn (rtx insn)
+{
+while (insn)
+{
+insn = PREV_INSN (insn);
+if (insn == 0 || (!NOTE_P (insn) && !DEBUG_INSN_P (insn)))
 	break;
 }
 return insn;
 }
 tem = try_split (PATTERN (tem), tem, 1);
 /* Return either the first or the last insn, depending on which was
 requested.  */
 return last
-? (after ? PREV_INSN (after) : last_insn)
+? (after ? PREV_INSN (after) : get_last_insn ())
 : NEXT_INSN (before);
 }
 /* Make and return an INSN rtx, initializing all its slots.
 Store PATTERN in the pattern slots.  */
 INSN may be an INSN, JUMP_INSN, CALL_INSN, CODE_LABEL, BARRIER or NOTE.  */
 void
 add_insn (rtx insn)
 {
-PREV_INSN (insn) = last_insn;
+PREV_INSN (insn) = get_last_insn();
 NEXT_INSN (insn) = 0;
-if (NULL != last_insn)
+if (NULL != get_last_insn())
-NEXT_INSN (last_insn) = insn;
+NEXT_INSN (get_last_insn ()) = insn;
-if (NULL == first_insn)
+if (NULL == get_insns ())
-first_insn = insn;
+set_first_insn (insn);
-last_insn = insn;
+set_last_insn (insn);
 }
 /* Add INSN into the doubly-linked list after insn AFTER.  This and
 the next should be the only functions called to insert an insn once
 delay slots have been filled since only they know how to update a
 {
 PREV_INSN (next) = insn;
 if (NONJUMP_INSN_P (next) && GET_CODE (PATTERN (next)) == SEQUENCE)
 	PREV_INSN (XVECEXP (PATTERN (next), 0, 0)) = insn;
 }
-else if (last_insn == after)
+else if (get_last_insn () == after)
-last_insn = insn;
+set_last_insn (insn);
 else
 {
 struct sequence_stack *stack = seq_stack;
 /* Scan all pending sequences too.  */
 for (; stack; stack = stack->next)
 	{
 	  rtx sequence = PATTERN (prev);
 	  NEXT_INSN (XVECEXP (sequence, 0, XVECLEN (sequence, 0) - 1)) = insn;
 	}
 }
-else if (first_insn == before)
+else if (get_insns () == before)
-first_insn = insn;
+set_first_insn (insn);
 else
 {
 struct sequence_stack *stack = seq_stack;
 /* Scan all pending sequences too.  */
 for (; stack; stack = stack->next)
 	{
 	  rtx sequence = PATTERN (prev);
 	  NEXT_INSN (XVECEXP (sequence, 0, XVECLEN (sequence, 0) - 1)) = next;
 	}
 }
-else if (first_insn == insn)
+else if (get_insns () == insn)
-first_insn = next;
+{
+if (next)
+PREV_INSN (next) = NULL;
+set_first_insn (next);
+}
 else
 {
 struct sequence_stack *stack = seq_stack;
 /* Scan all pending sequences too.  */
 for (; stack; stack = stack->next)
 {
 PREV_INSN (next) = prev;
 if (NONJUMP_INSN_P (next) && GET_CODE (PATTERN (next)) == SEQUENCE)
 	PREV_INSN (XVECEXP (PATTERN (next), 0, 0)) = prev;
 }
-else if (last_insn == insn)
+else if (get_last_insn () == insn)
-last_insn = prev;
+set_last_insn (prev);
 else
 {
 struct sequence_stack *stack = seq_stack;
 /* Scan all pending sequences too.  */
 for (; stack; stack = stack->next)
 gcc_assert (stack);
 }
 if (!BARRIER_P (insn)
 && (bb = BLOCK_FOR_INSN (insn)))
 {
-if (INSN_P (insn))
+if (NONDEBUG_INSN_P (insn))
 	df_set_bb_dirty (bb);
 if (BB_HEAD (bb) == insn)
 	{
 	  /* Never ever delete the basic block note without deleting whole
 	     basic block.  */
 void
 delete_insns_since (rtx from)
 {
 if (from == 0)
-first_insn = 0;
+set_first_insn (0);
 else
 NEXT_INSN (from) = 0;
-last_insn = from;
+set_last_insn (from);
 }
 /* This function is deprecated, please use sequences instead.
 Move a consecutive bunch of insns to a different place in the chain.
 called after delay-slot filling has been done.  */
 void
 reorder_insns_nobb (rtx from, rtx to, rtx after)
 {
+#ifdef ENABLE_CHECKING
+rtx x;
+for (x = from; x != to; x = NEXT_INSN (x))
+gcc_assert (after != x);
+gcc_assert (after != to);
+#endif
 /* Splice this bunch out of where it is now.  */
 if (PREV_INSN (from))
 NEXT_INSN (PREV_INSN (from)) = NEXT_INSN (to);
 if (NEXT_INSN (to))
 PREV_INSN (NEXT_INSN (to)) = PREV_INSN (from);
-if (last_insn == to)
+if (get_last_insn () == to)
-last_insn = PREV_INSN (from);
+set_last_insn (PREV_INSN (from));
-if (first_insn == from)
+if (get_insns () == from)
-first_insn = NEXT_INSN (to);
+set_first_insn (NEXT_INSN (to));
 /* Make the new neighbors point to it and it to them.  */
 if (NEXT_INSN (after))
 PREV_INSN (NEXT_INSN (after)) = to;
 NEXT_INSN (to) = NEXT_INSN (after);
 PREV_INSN (from) = after;
 NEXT_INSN (after) = from;
-if (after == last_insn)
+if (after == get_last_insn())
-last_insn = to;
+set_last_insn (to);
 }
 /* Same as function above, but take care to update BB boundaries.  */
 void
 reorder_insns (rtx from, rtx to, rtx after)
 PREV_INSN (first) = after;
 NEXT_INSN (last) = after_after;
 if (after_after)
 PREV_INSN (after_after) = last;
-if (after == last_insn)
+if (after == get_last_insn())
-last_insn = last;
+set_last_insn (last);
 return last;
 }
 /* Make X be output after the insn AFTER and set the BB of insn.  If
 Returns the last insn emitted.  */
 rtx
 emit_insn (rtx x)
 {
-rtx last = last_insn;
+rtx last = get_last_insn();
 rtx insn;
 if (x == NULL_RTX)
 return last;
 and add it to the end of the doubly-linked list.  */
 rtx
 emit_debug_insn (rtx x)
 {
-rtx last = last_insn;
+rtx last = get_last_insn();
 rtx insn;
 if (x == NULL_RTX)
 return last;
 {
 tem = free_sequence_stack;
 free_sequence_stack = tem->next;
 }
 else
-tem = GGC_NEW (struct sequence_stack);
+tem = ggc_alloc_sequence_stack ();
 tem->next = seq_stack;
-tem->first = first_insn;
+tem->first = get_insns ();
-tem->last = last_insn;
+tem->last = get_last_insn ();
 seq_stack = tem;
-first_insn = 0;
+set_first_insn (0);
-last_insn = 0;
+set_last_insn (0);
 }
 /* Set up the insn chain starting with FIRST as the current sequence,
 saving the previously current one.  See the documentation for
 start_sequence for more information about how to use this function.  */
 start_sequence ();
 for (last = first; last && NEXT_INSN (last); last = NEXT_INSN (last));
-first_insn = first;
+set_first_insn (first);
-last_insn = last;
+set_last_insn (last);
 }
 /* Like push_to_sequence, but take the last insn as an argument to avoid
 looping through the list.  */
 void
 push_to_sequence2 (rtx first, rtx last)
 {
 start_sequence ();
-first_insn = first;
+set_first_insn (first);
-last_insn = last;
+set_last_insn (last);
 }
 /* Set up the outer-level insn chain
 as the current sequence, saving the previously current one.  */
 start_sequence ();
 for (stack = seq_stack; stack; stack = stack->next)
 top = stack;
-first_insn = top->first;
+set_first_insn (top->first);
-last_insn = top->last;
+set_last_insn (top->last);
 }
 /* After emitting to the outer-level insn chain, update the outer-level
 insn chain, and restore the previous saved state.  */
 struct sequence_stack *stack, *top = NULL;
 for (stack = seq_stack; stack; stack = stack->next)
 top = stack;
-top->first = first_insn;
+top->first = get_insns ();
-top->last = last_insn;
+top->last = get_last_insn ();
 end_sequence ();
 }
 /* After emitting to a sequence, restore previous saved state.
 void
 end_sequence (void)
 {
 struct sequence_stack *tem = seq_stack;
-first_insn = tem->first;
+set_first_insn (tem->first);
-last_insn = tem->last;
+set_last_insn (tem->last);
 seq_stack = tem->next;
 memset (tem, 0, sizeof (*tem));
 tem->next = free_sequence_stack;
 free_sequence_stack = tem;
 regno_reg_rtx[VIRTUAL_INCOMING_ARGS_REGNUM] = virtual_incoming_args_rtx;
 regno_reg_rtx[VIRTUAL_STACK_VARS_REGNUM] = virtual_stack_vars_rtx;
 regno_reg_rtx[VIRTUAL_STACK_DYNAMIC_REGNUM] = virtual_stack_dynamic_rtx;
 regno_reg_rtx[VIRTUAL_OUTGOING_ARGS_REGNUM] = virtual_outgoing_args_rtx;
 regno_reg_rtx[VIRTUAL_CFA_REGNUM] = virtual_cfa_rtx;
+regno_reg_rtx[VIRTUAL_PREFERRED_STACK_BOUNDARY_REGNUM]
+= virtual_preferred_stack_boundary_rtx;
 }
 /* Used by copy_insn_1 to avoid copying SCRATCHes more than once.  */
 static rtx copy_insn_scratch_in[MAX_RECOG_OPERANDS];
 before generating rtl for each function.  */
 void
 init_emit (void)
 {
-first_insn = NULL;
+set_first_insn (NULL);
-last_insn = NULL;
+set_last_insn (NULL);
 if (MIN_NONDEBUG_INSN_UID)
 cur_insn_uid = MIN_NONDEBUG_INSN_UID;
 else
 cur_insn_uid = 1;
 cur_debug_insn_uid = 1;
 crtl->emit.regno_pointer_align_length = LAST_VIRTUAL_REGISTER + 101;
 crtl->emit.regno_pointer_align
 = XCNEWVEC (unsigned char, crtl->emit.regno_pointer_align_length);
-regno_reg_rtx
+regno_reg_rtx = ggc_alloc_vec_rtx (crtl->emit.regno_pointer_align_length);
-= GGC_NEWVEC (rtx, crtl->emit.regno_pointer_align_length);
 /* Put copies of all the hard registers into regno_reg_rtx.  */
 memcpy (regno_reg_rtx,
-	  static_regno_reg_rtx,
+	  initial_regno_reg_rtx,
 	  FIRST_PSEUDO_REGISTER * sizeof (rtx));
 /* Put copies of all the virtual register rtx into regno_reg_rtx.  */
 init_virtual_regs ();
 virtual_stack_dynamic_rtx =
 gen_raw_REG (Pmode, VIRTUAL_STACK_DYNAMIC_REGNUM);
 virtual_outgoing_args_rtx =
 gen_raw_REG (Pmode, VIRTUAL_OUTGOING_ARGS_REGNUM);
 virtual_cfa_rtx = gen_raw_REG (Pmode, VIRTUAL_CFA_REGNUM);
+virtual_preferred_stack_boundary_rtx =
+gen_raw_REG (Pmode, VIRTUAL_PREFERRED_STACK_BOUNDARY_REGNUM);
 /* Initialize RTL for commonly used hard registers.  These are
 copied into regno_reg_rtx as we begin to compile each function.  */
 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
-static_regno_reg_rtx[i] = gen_raw_REG (reg_raw_mode[i], i);
+initial_regno_reg_rtx[i] = gen_raw_REG (reg_raw_mode[i], i);
 #ifdef RETURN_ADDRESS_POINTER_REGNUM
 return_address_pointer_rtx
 = gen_raw_REG (Pmode, RETURN_ADDRESS_POINTER_REGNUM);
 #endif

Mercurial > hg > CbC > CbC_gcc

comparison gcc/emit-rtl.c @ 67:f6334be47118