CbC/CbC_gcc: gcc/function.c comparison

comparison gcc/function.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	1b10fe6932e1 04ced10e8804

comparison

equal deleted inserted replaced

-:65488c3d617d
+:f6334be47118
 /* Expands front end tree to back end RTL for GCC.
 Copyright (C) 1987, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
-2010  Free Software Foundation, Inc.
+2010, 2011  Free Software Foundation, Inc.
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free
 #include "config.h"
 #include "system.h"
 #include "coretypes.h"
 #include "tm.h"
-#include "rtl.h"
+#include "rtl-error.h"
 #include "tree.h"
 #include "flags.h"
 #include "except.h"
 #include "function.h"
 #include "expr.h"
 #include "hard-reg-set.h"
 #include "insn-config.h"
 #include "recog.h"
 #include "output.h"
 #include "basic-block.h"
-#include "toplev.h"
 #include "hashtab.h"
 #include "ggc.h"
 #include "tm_p.h"
 #include "integrate.h"
 #include "langhooks.h"
 static GTY((if_marked ("ggc_marked_p"), param_is (struct rtx_def)))
 htab_t epilogue_insn_hash;
 htab_t types_used_by_vars_hash = NULL;
-tree types_used_by_cur_var_decl = NULL;
+VEC(tree,gc) *types_used_by_cur_var_decl;
 /* Forward declarations.  */
 static struct temp_slot *find_temp_slot_from_address (rtx);
 static void pad_to_arg_alignment (struct args_size *, int, struct args_size *);
 function's frame_space_list.  */
 static void
 add_frame_space (HOST_WIDE_INT start, HOST_WIDE_INT end)
 {
-struct frame_space *space = GGC_NEW (struct frame_space);
+struct frame_space *space = ggc_alloc_frame_space ();
 space->next = crtl->frame_space_list;
 crtl->frame_space_list = space;
 space->start = start;
 space->length = end - start;
 }
 0 means according to MODE,
 -1 means use BIGGEST_ALIGNMENT and round size to multiple of that,
 -2 means use BITS_PER_UNIT,
 positive specifies alignment boundary in bits.
-If REDUCE_ALIGNMENT_OK is true, it is OK to reduce alignment.
+KIND has ASLK_REDUCE_ALIGN bit set if it is OK to reduce
+alignment and ASLK_RECORD_PAD bit set if we should remember
+extra space we allocated for alignment purposes.  When we are
+called from assign_stack_temp_for_type, it is not set so we don't
+track the same stack slot in two independent lists.
 We do not round to stack_boundary here.  */
 rtx
 assign_stack_local_1 (enum machine_mode mode, HOST_WIDE_INT size,
-		      int align,
+		      int align, int kind)
-		      bool reduce_alignment_ok ATTRIBUTE_UNUSED)
 {
 rtx x, addr;
 int bigend_correction = 0;
-HOST_WIDE_INT slot_offset, old_frame_offset;
+HOST_WIDE_INT slot_offset = 0, old_frame_offset;
 unsigned int alignment, alignment_in_bits;
 if (align == 0)
 {
 alignment = get_stack_local_alignment (NULL, mode);
 	      if (!crtl->stack_realign_needed)
 		{
 		  /* It is OK to reduce the alignment as long as the
 		     requested size is 0 or the estimated stack
 		     alignment >= mode alignment.  */
-		  gcc_assert (reduce_alignment_ok
+		  gcc_assert ((kind & ASLK_REDUCE_ALIGN)
 		              || size == 0
 			      || (crtl->stack_alignment_estimated
 				  >= GET_MODE_ALIGNMENT (mode)));
 		  alignment_in_bits = crtl->stack_alignment_estimated;
 		  alignment = alignment_in_bits / BITS_PER_UNIT;
 if (crtl->max_used_stack_slot_alignment < alignment_in_bits)
 crtl->max_used_stack_slot_alignment = alignment_in_bits;
 if (mode != BLKmode || size != 0)
 {
-struct frame_space **psp;
+if (kind & ASLK_RECORD_PAD)
+	{
-for (psp = &crtl->frame_space_list; *psp; psp = &(*psp)->next)
+	  struct frame_space **psp;
-	{
-	  struct frame_space *space = *psp;
+	  for (psp = &crtl->frame_space_list; *psp; psp = &(*psp)->next)
-	  if (!try_fit_stack_local (space->start, space->length, size,
+	    {
-				    alignment, &slot_offset))
+	      struct frame_space *space = *psp;
-	    continue;
+	      if (!try_fit_stack_local (space->start, space->length, size,
-	  *psp = space->next;
+					alignment, &slot_offset))
-	  if (slot_offset > space->start)
+		continue;
-	    add_frame_space (space->start, slot_offset);
+	      *psp = space->next;
-	  if (slot_offset + size < space->start + space->length)
+	      if (slot_offset > space->start)
-	    add_frame_space (slot_offset + size,
+		add_frame_space (space->start, slot_offset);
-			     space->start + space->length);
+	      if (slot_offset + size < space->start + space->length)
-	  goto found_space;
+		add_frame_space (slot_offset + size,
+				 space->start + space->length);
+	      goto found_space;
+	    }
 	}
 }
 else if (!STACK_ALIGNMENT_NEEDED)
 {
 slot_offset = frame_offset;
 if (FRAME_GROWS_DOWNWARD)
 {
 frame_offset -= size;
 try_fit_stack_local (frame_offset, size, size, alignment, &slot_offset);
-if (slot_offset > frame_offset)
+if (kind & ASLK_RECORD_PAD)
-	add_frame_space (frame_offset, slot_offset);
+	{
-if (slot_offset + size < old_frame_offset)
+	  if (slot_offset > frame_offset)
-	add_frame_space (slot_offset + size, old_frame_offset);
+	    add_frame_space (frame_offset, slot_offset);
+	  if (slot_offset + size < old_frame_offset)
+	    add_frame_space (slot_offset + size, old_frame_offset);
+	}
 }
 else
 {
 frame_offset += size;
 try_fit_stack_local (old_frame_offset, size, size, alignment, &slot_offset);
-if (slot_offset > old_frame_offset)
+if (kind & ASLK_RECORD_PAD)
-	add_frame_space (old_frame_offset, slot_offset);
+	{
-if (slot_offset + size < frame_offset)
+	  if (slot_offset > old_frame_offset)
-	add_frame_space (slot_offset + size, frame_offset);
+	    add_frame_space (old_frame_offset, slot_offset);
+	  if (slot_offset + size < frame_offset)
+	    add_frame_space (slot_offset + size, frame_offset);
+	}
 }
 found_space:
 /* On a big-endian machine, if we are allocating more space than we will use,
 use the least significant bytes of those that are allocated.  */
 /* Wrap up assign_stack_local_1 with last parameter as false.  */
 rtx
 assign_stack_local (enum machine_mode mode, HOST_WIDE_INT size, int align)
 {
-return assign_stack_local_1 (mode, size, align, false);
+return assign_stack_local_1 (mode, size, align, ASLK_RECORD_PAD);
 }
 /* In order to evaluate some expressions, such as function calls returning
 structures in memory, we need to temporarily allocate stack locations.
 /* Add ADDRESS as an alias of TEMP_SLOT to the addess -> temp slot mapping.  */
 static void
 insert_temp_slot_address (rtx address, struct temp_slot *temp_slot)
 {
 void **slot;
-struct temp_slot_address_entry *t = GGC_NEW (struct temp_slot_address_entry);
+struct temp_slot_address_entry *t = ggc_alloc_temp_slot_address_entry ();
 t->address = address;
 t->temp_slot = temp_slot;
 t->hash = temp_slot_address_compute_hash (t);
 slot = htab_find_slot_with_hash (temp_slot_address_table, t, t->hash, INSERT);
 *slot = t;
 	  int alignment = best_p->align / BITS_PER_UNIT;
 	  HOST_WIDE_INT rounded_size = CEIL_ROUND (size, alignment);
 	  if (best_p->size - rounded_size >= alignment)
 	    {
-	      p = GGC_NEW (struct temp_slot);
+	      p = ggc_alloc_temp_slot ();
 	      p->in_use = p->addr_taken = 0;
 	      p->size = best_p->size - rounded_size;
 	      p->base_offset = best_p->base_offset + rounded_size;
 	      p->full_size = best_p->full_size - rounded_size;
 	      p->slot = adjust_address_nv (best_p->slot, BLKmode, rounded_size);
 /* If we still didn't find one, make a new temporary.  */
 if (selected == 0)
 {
 HOST_WIDE_INT frame_offset_old = frame_offset;
-p = GGC_NEW (struct temp_slot);
+p = ggc_alloc_temp_slot ();
 /* We are passing an explicit alignment request to assign_stack_local.
 	 One side effect of that is assign_stack_local will not round SIZE
 	 to ensure the frame offset remains suitably aligned.
 	 So for requests which depended on the rounding of SIZE, we go ahead
 	 and round it now.  We also make sure ALIGNMENT is at least
 	 BIGGEST_ALIGNMENT.  */
 gcc_assert (mode != BLKmode || align == BIGGEST_ALIGNMENT);
-p->slot = assign_stack_local (mode,
+p->slot = assign_stack_local_1 (mode,
-				    (mode == BLKmode
+				      (mode == BLKmode
-				     ? CEIL_ROUND (size, (int) align / BITS_PER_UNIT)
+				       ? CEIL_ROUND (size,
-				     : size),
+						     (int) align
-				    align);
+						     / BITS_PER_UNIT)
+				       : size),
+				      align, 0);
 p->align = align;
 /* The following slot size computation is necessary because we don't
 	 know the actual size of the temporary slot until assign_stack_local
 /* If a type is specified, set the relevant flags.  */
 if (type != 0)
 {
 MEM_VOLATILE_P (slot) = TYPE_VOLATILE (type);
-MEM_SET_IN_STRUCT_P (slot, (AGGREGATE_TYPE_P (type)
+gcc_checking_assert (!MEM_SCALAR_P (slot) && !MEM_IN_STRUCT_P (slot));
-				  || TREE_CODE (type) == COMPLEX_TYPE));
+if (AGGREGATE_TYPE_P (type) || TREE_CODE (type) == COMPLEX_TYPE)
+	MEM_IN_STRUCT_P (slot) = 1;
+else
+	MEM_SCALAR_P (slot) = 1;
 }
 MEM_NOTRAP_P (slot) = 1;
 return slot;
 }
 new_rtx = frame_pointer_rtx;
 #else
 new_rtx = arg_pointer_rtx;
 #endif
 offset = cfa_offset;
+}
+else if (x == virtual_preferred_stack_boundary_rtx)
+{
+new_rtx = GEN_INT (crtl->preferred_stack_boundary / BITS_PER_UNIT);
+offset = 0;
 }
 else
 return NULL_RTX;
 *poffset = offset;
 {
 tree t = *tp;
 if (! EXPR_P (t))
 {
 *walk_subtrees = 0;
-if (DECL_P (t) && DECL_RTL_SET_P (t))
+if (DECL_P (t))
-	instantiate_decl_rtl (DECL_RTL (t));
+	{
+	  if (DECL_RTL_SET_P (t))
+	    instantiate_decl_rtl (DECL_RTL (t));
+	  if (TREE_CODE (t) == PARM_DECL && DECL_NAMELESS (t)
+	      && DECL_INCOMING_RTL (t))
+	    instantiate_decl_rtl (DECL_INCOMING_RTL (t));
+	  if ((TREE_CODE (t) == VAR_DECL
+	       || TREE_CODE (t) == RESULT_DECL)
+	      && DECL_HAS_VALUE_EXPR_P (t))
+	    {
+	      tree v = DECL_VALUE_EXPR (t);
+	      walk_tree (&v, instantiate_expr, NULL, NULL);
+	    }
+	}
 }
 return NULL;
 }
 /* Subroutine of instantiate_decls: Process all decls in the given
 static void
 instantiate_decls_1 (tree let)
 {
 tree t;
-for (t = BLOCK_VARS (let); t; t = TREE_CHAIN (t))
+for (t = BLOCK_VARS (let); t; t = DECL_CHAIN (t))
 {
 if (DECL_RTL_SET_P (t))
 	instantiate_decl_rtl (DECL_RTL (t));
 if (TREE_CODE (t) == VAR_DECL && DECL_HAS_VALUE_EXPR_P (t))
 	{
 all virtual registers in their DECL_RTL's.  */
 static void
 instantiate_decls (tree fndecl)
 {
-tree decl, t, next;
+tree decl;
+unsigned ix;
 /* Process all parameters of the function.  */
-for (decl = DECL_ARGUMENTS (fndecl); decl; decl = TREE_CHAIN (decl))
+for (decl = DECL_ARGUMENTS (fndecl); decl; decl = DECL_CHAIN (decl))
 {
 instantiate_decl_rtl (DECL_RTL (decl));
 instantiate_decl_rtl (DECL_INCOMING_RTL (decl));
 if (DECL_HAS_VALUE_EXPR_P (decl))
 	{
 	  tree v = DECL_VALUE_EXPR (decl);
 	  walk_tree (&v, instantiate_expr, NULL, NULL);
 	}
 }
+if ((decl = DECL_RESULT (fndecl))
+&& TREE_CODE (decl) == RESULT_DECL)
+{
+if (DECL_RTL_SET_P (decl))
+	instantiate_decl_rtl (DECL_RTL (decl));
+if (DECL_HAS_VALUE_EXPR_P (decl))
+	{
+	  tree v = DECL_VALUE_EXPR (decl);
+	  walk_tree (&v, instantiate_expr, NULL, NULL);
+	}
+}
 /* Now process all variables defined in the function or its subblocks.  */
 instantiate_decls_1 (DECL_INITIAL (fndecl));
-t = cfun->local_decls;
+FOR_EACH_LOCAL_DECL (cfun, ix, decl)
-cfun->local_decls = NULL_TREE;
+if (DECL_RTL_SET_P (decl))
-for (; t; t = next)
+instantiate_decl_rtl (DECL_RTL (decl));
-{
+VEC_free (tree, gc, cfun->local_decls);
-next = TREE_CHAIN (t);
-decl = TREE_VALUE (t);
-if (DECL_RTL_SET_P (decl))
-	instantiate_decl_rtl (DECL_RTL (decl));
-ggc_free (t);
-}
 }
 /* Pass through the INSNS of function FNDECL and convert virtual register
 references to hard register references.  */
 targetm.instantiate_decls ();
 /* Indicate that, from now on, assign_stack_local should use
 frame_pointer_rtx.  */
 virtuals_instantiated = 1;
+/* See allocate_dynamic_stack_space for the rationale.  */
+#ifdef SETJMP_VIA_SAVE_AREA
+if (flag_stack_usage && cfun->calls_setjmp)
+{
+int align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
+dynamic_offset = (dynamic_offset + align - 1) / align * align;
+current_function_dynamic_stack_size
+	+= current_function_dynamic_alloc_count * dynamic_offset;
+}
+#endif
 return 0;
 }
 struct rtl_opt_pass pass_instantiate_virtual_regs =
 {
 split_complex_args (VEC(tree, heap) **args)
 {
 unsigned i;
 tree p;
-for (i = 0; VEC_iterate (tree, *args, i, p); ++i)
+FOR_EACH_VEC_ELT (tree, *args, i, p)
 {
 tree type = TREE_TYPE (p);
 if (TREE_CODE (type) == COMPLEX_TYPE
 	  && targetm.calls.split_complex_arg (type))
 	{
 tree fndecl = current_function_decl;
 tree fntype = TREE_TYPE (fndecl);
 VEC(tree, heap) *fnargs = NULL;
 tree arg;
-for (arg = DECL_ARGUMENTS (fndecl); arg; arg = TREE_CHAIN (arg))
+for (arg = DECL_ARGUMENTS (fndecl); arg; arg = DECL_CHAIN (arg))
 VEC_safe_push (tree, heap, fnargs, arg);
 all->orig_fnargs = DECL_ARGUMENTS (fndecl);
 /* If struct value address is treated as the first argument, make it so.  */
 {
 tree type = build_pointer_type (TREE_TYPE (fntype));
 tree decl;
 decl = build_decl (DECL_SOURCE_LOCATION (fndecl),
-			 PARM_DECL, NULL_TREE, type);
+			 PARM_DECL, get_identifier (".result_ptr"), type);
 DECL_ARG_TYPE (decl) = type;
 DECL_ARTIFICIAL (decl) = 1;
-DECL_IGNORED_P (decl) = 1;
+DECL_NAMELESS (decl) = 1;
+TREE_CONSTANT (decl) = 1;
-TREE_CHAIN (decl) = all->orig_fnargs;
+DECL_CHAIN (decl) = all->orig_fnargs;
 all->orig_fnargs = decl;
 VEC_safe_insert (tree, heap, fnargs, 0, decl);
 all->function_result_decl = decl;
 }
 memset (data, 0, sizeof (*data));
 /* NAMED_ARG is a misnomer.  We really mean 'non-variadic'. */
 if (!cfun->stdarg)
 data->named_arg = 1;  /* No variadic parms.  */
-else if (TREE_CHAIN (parm))
+else if (DECL_CHAIN (parm))
 data->named_arg = 1;  /* Not the last non-variadic parm. */
 else if (targetm.calls.strict_argument_naming (&all->args_so_far))
 data->named_arg = 1;  /* Only variadic ones are unnamed.  */
 else
 data->named_arg = 0;  /* Treat as variadic.  */
 {
 data->entry_parm = data->stack_parm = const0_rtx;
 return;
 }
-#ifdef FUNCTION_INCOMING_ARG
+entry_parm = targetm.calls.function_incoming_arg (&all->args_so_far,
-entry_parm = FUNCTION_INCOMING_ARG (all->args_so_far, data->promoted_mode,
+						    data->promoted_mode,
-				      data->passed_type, data->named_arg);
+						    data->passed_type,
-#else
+						    data->named_arg);
-entry_parm = FUNCTION_ARG (all->args_so_far, data->promoted_mode,
-			     data->passed_type, data->named_arg);
-#endif
 if (entry_parm == 0)
 data->promoted_mode = data->passed_mode;
 /* Determine parm's home in the stack, in case it arrives in the stack
 if (!in_regs && !data->named_arg)
 {
 if (targetm.calls.pretend_outgoing_varargs_named (&all->args_so_far))
 	{
 	  rtx tem;
-#ifdef FUNCTION_INCOMING_ARG
+	  tem = targetm.calls.function_incoming_arg (&all->args_so_far,
-	  tem = FUNCTION_INCOMING_ARG (all->args_so_far, data->promoted_mode,
+						     data->promoted_mode,
-				       data->passed_type, true);
+						     data->passed_type, true);
-#else
-	  tem = FUNCTION_ARG (all->args_so_far, data->promoted_mode,
-			      data->passed_type, true);
-#endif
 	  in_regs = tem != NULL;
 	}
 }
 /* If this parameter was passed both in registers and in the stack, use
 boundary = data->locate.boundary;
 align = BITS_PER_UNIT;
 /* If we're padding upward, we know that the alignment of the slot
-is FUNCTION_ARG_BOUNDARY.  If we're using slot_offset, we're
+is TARGET_FUNCTION_ARG_BOUNDARY.  If we're using slot_offset, we're
 intentionally forcing upward padding.  Otherwise we have to come
 up with a guess at the alignment based on OFFSET_RTX.  */
 if (data->locate.where_pad != downward || data->entry_parm)
 align = boundary;
 else if (CONST_INT_P (offset_rtx))
 data->stack_parm = stack_parm;
 SET_DECL_RTL (parm, stack_parm);
 }
+/* A subroutine of assign_parm_setup_reg, called through note_stores.
+This collects sets and clobbers of hard registers in a HARD_REG_SET,
+which is pointed to by DATA.  */
+static void
+record_hard_reg_sets (rtx x, const_rtx pat ATTRIBUTE_UNUSED, void *data)
+{
+HARD_REG_SET *pset = (HARD_REG_SET *)data;
+if (REG_P (x) && REGNO (x) < FIRST_PSEUDO_REGISTER)
+{
+int nregs = hard_regno_nregs[REGNO (x)][GET_MODE (x)];
+while (nregs-- > 0)
+	SET_HARD_REG_BIT (*pset, REGNO (x) + nregs);
+}
+}
 /* A subroutine of assign_parms.  Allocate a pseudo to hold the current
 parameter.  Get it there.  Perform all ABI specified conversions.  */
 static void
 assign_parm_setup_reg (struct assign_parm_data_all *all, tree parm,
 		       struct assign_parm_data_one *data)
 {
-rtx parmreg;
+rtx parmreg, validated_mem;
+rtx equiv_stack_parm;
 enum machine_mode promoted_nominal_mode;
 int unsignedp = TYPE_UNSIGNED (TREE_TYPE (parm));
 bool did_conversion = false;
+bool need_conversion, moved;
 /* Store the parm in a pseudoregister during the function, but we may
 need to do it in a wider mode.  Using 2 here makes the result
 consistent with promote_decl_mode and thus expand_expr_real_1.  */
 promoted_nominal_mode
 assign_parm_remove_parallels (data);
 /* Copy the value into the register, thus bridging between
 assign_parm_find_data_types and expand_expr_real_1.  */
-if (data->nominal_mode != data->passed_mode
-|| promoted_nominal_mode != data->promoted_mode)
+equiv_stack_parm = data->stack_parm;
-{
+validated_mem = validize_mem (data->entry_parm);
-int save_tree_used;
+need_conversion = (data->nominal_mode != data->passed_mode
+		     || promoted_nominal_mode != data->promoted_mode);
+moved = false;
+if (need_conversion
+&& GET_MODE_CLASS (data->nominal_mode) == MODE_INT
+&& data->nominal_mode == data->passed_mode
+&& data->nominal_mode == GET_MODE (data->entry_parm))
+{
 /* ENTRY_PARM has been converted to PROMOTED_MODE, its
 	 mode, by the caller.  We now have to convert it to
 	 NOMINAL_MODE, if different.  However, PARMREG may be in
 	 a different mode than NOMINAL_MODE if it is being stored
 	 promoted.
 	 occurs when the calling sequence allow such misaligned
 	 usages.
 	 In addition, the conversion may involve a call, which could
 	 clobber parameters which haven't been copied to pseudo
-	 registers yet.  Therefore, we must first copy the parm to
+	 registers yet.
-	 a pseudo reg here, and save the conversion until after all
+	 First, we try to emit an insn which performs the necessary
+	 conversion.  We verify that this insn does not clobber any
+	 hard registers.  */
+enum insn_code icode;
+rtx op0, op1;
+icode = can_extend_p (promoted_nominal_mode, data->passed_mode,
+			    unsignedp);
+op0 = parmreg;
+op1 = validated_mem;
+if (icode != CODE_FOR_nothing
+	  && insn_data[icode].operand[0].predicate (op0, promoted_nominal_mode)
+	  && insn_data[icode].operand[1].predicate (op1, data->passed_mode))
+	{
+	  enum rtx_code code = unsignedp ? ZERO_EXTEND : SIGN_EXTEND;
+	  rtx insn, insns;
+	  HARD_REG_SET hardregs;
+	  start_sequence ();
+	  insn = gen_extend_insn (op0, op1, promoted_nominal_mode,
+				  data->passed_mode, unsignedp);
+	  emit_insn (insn);
+	  insns = get_insns ();
+	  moved = true;
+	  CLEAR_HARD_REG_SET (hardregs);
+	  for (insn = insns; insn && moved; insn = NEXT_INSN (insn))
+	    {
+	      if (INSN_P (insn))
+		note_stores (PATTERN (insn), record_hard_reg_sets,
+			     &hardregs);
+	      if (!hard_reg_set_empty_p (hardregs))
+		moved = false;
+	    }
+	  end_sequence ();
+	  if (moved)
+	    {
+	      emit_insn (insns);
+	      if (equiv_stack_parm != NULL_RTX)
+		equiv_stack_parm = gen_rtx_fmt_e (code, GET_MODE (parmreg),
+						  equiv_stack_parm);
+	    }
+	}
+}
+if (moved)
+/* Nothing to do.  */
+;
+else if (need_conversion)
+{
+/* We did not have an insn to convert directly, or the sequence
+	 generated appeared unsafe.  We must first copy the parm to a
+	 pseudo reg, and save the conversion until after all
 	 parameters have been moved.  */
+int save_tree_used;
 rtx tempreg = gen_reg_rtx (GET_MODE (data->entry_parm));
-emit_move_insn (tempreg, validize_mem (data->entry_parm));
+emit_move_insn (tempreg, validated_mem);
 push_to_sequence2 (all->first_conversion_insn, all->last_conversion_insn);
 tempreg = convert_to_mode (data->nominal_mode, tempreg, unsignedp);
 if (GET_CODE (tempreg) == SUBREG
 end_sequence ();
 did_conversion = true;
 }
 else
-emit_move_insn (parmreg, validize_mem (data->entry_parm));
+emit_move_insn (parmreg, validated_mem);
 /* If we were passed a pointer but the actual value can safely live
 in a register, put it in one.  */
 if (data->passed_pointer
 && TYPE_MODE (TREE_TYPE (parm)) != BLKmode
 		set_unique_reg_note (sinsn, REG_EQUIV, stackr);
 	    }
 	}
 else if ((set = single_set (linsn)) != 0
 	       && SET_DEST (set) == parmreg)
-	set_unique_reg_note (linsn, REG_EQUIV, data->stack_parm);
+	set_unique_reg_note (linsn, REG_EQUIV, equiv_stack_parm);
 }
 /* For pointer data type, suggest pointer register.  */
 if (POINTER_TYPE_P (TREE_TYPE (parm)))
 mark_reg_pointer (parmreg,
 = targetm.calls.internal_arg_pointer ();
 assign_parms_initialize_all (&all);
 fnargs = assign_parms_augmented_arg_list (&all);
-for (i = 0; VEC_iterate (tree, fnargs, i, parm); ++i)
+FOR_EACH_VEC_ELT (tree, fnargs, i, parm)
 {
 struct assign_parm_data_one data;
 /* Extract the type of PARM; adjust it according to ABI.  */
 assign_parm_find_data_types (&all, parm, &data);
 	}
 /* Estimate stack alignment from parameter alignment.  */
 if (SUPPORTS_STACK_ALIGNMENT)
 {
-unsigned int align = FUNCTION_ARG_BOUNDARY (data.promoted_mode,
+unsigned int align
-						      data.passed_type);
+	    = targetm.calls.function_arg_boundary (data.promoted_mode,
+						   data.passed_type);
 	  align = MINIMUM_ALIGNMENT (data.passed_type, data.promoted_mode,
 				     align);
 	  if (TYPE_ALIGN (data.nominal_type) > align)
 	    align = MINIMUM_ALIGNMENT (data.nominal_type,
 				       TYPE_MODE (data.nominal_type),
 	      gcc_assert (!crtl->stack_realign_processed);
 	      crtl->stack_alignment_estimated = align;
 	    }
 	}
-if (cfun->stdarg && !TREE_CHAIN (parm))
+if (cfun->stdarg && !DECL_CHAIN (parm))
 	assign_parms_setup_varargs (&all, &data, false);
 /* Find out where the parameter arrives in this function.  */
 assign_parm_find_entry_rtl (&all, &data);
 /* Record permanently how this parm was passed.  */
 set_decl_incoming_rtl (parm, data.entry_parm, data.passed_pointer);
 /* Update info on where next arg arrives in registers.  */
-FUNCTION_ARG_ADVANCE (all.args_so_far, data.promoted_mode,
+targetm.calls.function_arg_advance (&all.args_so_far, data.promoted_mode,
-			    data.passed_type, data.named_arg);
+					  data.passed_type, data.named_arg);
 assign_parm_adjust_stack_rtl (&data);
 if (assign_parm_setup_block_p (&data))
 	assign_parm_setup_block (&all, parm, &data);
 tree result = DECL_RESULT (current_function_decl);
 rtx addr = DECL_RTL (all.function_result_decl);
 rtx x;
 if (DECL_BY_REFERENCE (result))
-	x = addr;
+	{
+	  SET_DECL_VALUE_EXPR (result, all.function_result_decl);
+	  x = addr;
+	}
 else
 	{
+	  SET_DECL_VALUE_EXPR (result,
+			       build1 (INDIRECT_REF, TREE_TYPE (result),
+				       all.function_result_decl));
 	  addr = convert_memory_address (Pmode, addr);
 	  x = gen_rtx_MEM (DECL_MODE (result), addr);
 	  set_mem_attributes (x, result, 1);
 	}
+DECL_HAS_VALUE_EXPR_P (result) = 1;
 SET_DECL_RTL (result, x);
 }
 /* We have aligned all the args, so add space for the pretend args.  */
 crtl->args.pretend_args_size = all.pretend_args_size;
 #endif
 /* See how many bytes, if any, of its args a function should try to pop
 on return.  */
-crtl->args.pops_args = RETURN_POPS_ARGS (fndecl, TREE_TYPE (fndecl),
+crtl->args.pops_args = targetm.calls.return_pops_args (fndecl,
-						 crtl->args.size);
+							 TREE_TYPE (fndecl),
+							 crtl->args.size);
 /* For stdarg.h function, save info about
 regs and stack space used by the named args.  */
 crtl->args.info = all.args_so_far;
 unsigned i;
 assign_parms_initialize_all (&all);
 fnargs = assign_parms_augmented_arg_list (&all);
-for (i = 0; VEC_iterate (tree, fnargs, i, parm); ++i)
+FOR_EACH_VEC_ELT (tree, fnargs, i, parm)
 {
 struct assign_parm_data_one data;
 /* Extract the type of PARM; adjust it according to ABI.  */
 assign_parm_find_data_types (&all, parm, &data);
 /* Early out for errors and void parameters.  */
 if (data.passed_mode == VOIDmode || DECL_SIZE (parm) == NULL)
 	continue;
 /* Update info on where next arg arrives in registers.  */
-FUNCTION_ARG_ADVANCE (all.args_so_far, data.promoted_mode,
+targetm.calls.function_arg_advance (&all.args_so_far, data.promoted_mode,
-			    data.passed_type, data.named_arg);
+					  data.passed_type, data.named_arg);
 /* ??? Once upon a time variable_size stuffed parameter list
 	 SAVE_EXPRs (amongst others) onto a pending sizes list.  This
 	 turned out to be less than manageable in the gimple world.
 	 Now we have to hunt them down ourselves.  */
 	      if (TREE_CODE (DECL_SIZE_UNIT (parm)) == INTEGER_CST
 		  && !(flag_stack_check == GENERIC_STACK_CHECK
 		       && compare_tree_int (DECL_SIZE_UNIT (parm),
 					    STACK_CHECK_MAX_VAR_SIZE) > 0))
 		{
-		  local = create_tmp_var (type, get_name (parm));
+		  local = create_tmp_reg (type, get_name (parm));
 		  DECL_IGNORED_P (local) = 0;
 		  /* If PARM was addressable, move that flag over
 		     to the local copy, as its address will be taken,
-		     not the PARMs.  */
+		     not the PARMs.  Keep the parms address taken
+		     as we'll query that flag during gimplification.  */
 		  if (TREE_ADDRESSABLE (parm))
-		    {
+		    TREE_ADDRESSABLE (local) = 1;
-		      TREE_ADDRESSABLE (parm) = 0;
-		      TREE_ADDRESSABLE (local) = 1;
-		    }
 		}
 	      else
 		{
 		  tree ptr_type, addr;
 		  ptr_type = build_pointer_type (type);
-		  addr = create_tmp_var (ptr_type, get_name (parm));
+		  addr = create_tmp_reg (ptr_type, get_name (parm));
 		  DECL_IGNORED_P (addr) = 0;
 		  local = build_fold_indirect_ref (addr);
 		  t = built_in_decls[BUILT_IN_ALLOCA];
 		  t = build_call_expr (t, 1, DECL_SIZE_UNIT (parm));
+		  /* The call has been built for a variable-sized object.  */
+		  ALLOCA_FOR_VAR_P (t) = 1;
 		  t = fold_convert (ptr_type, t);
 		  t = build2 (MODIFY_EXPR, TREE_TYPE (addr), addr, t);
 		  gimplify_and_add (t, &stmts);
 		}
 never be set if REG_PARM_STACK_SPACE is not defined.
 FNDECL is the function in which the argument was defined.
 There are two types of rounding that are done.  The first, controlled by
-FUNCTION_ARG_BOUNDARY, forces the offset from the start of the argument
+TARGET_FUNCTION_ARG_BOUNDARY, forces the offset from the start of the
-list to be aligned to the specific boundary (in bits).  This rounding
+argument list to be aligned to the specific boundary (in bits).  This
-affects the initial and starting offsets, but not the argument size.
+rounding affects the initial and starting offsets, but not the argument
+size.
 The second, controlled by FUNCTION_ARG_PADDING and PARM_BOUNDARY,
 optionally rounds the size of the parm to PARM_BOUNDARY.  The
 initial offset is not affected by this rounding, while the size always
 is and the starting offset may be.  */
 part_size_in_regs = (reg_parm_stack_space == 0 ? partial : 0);
 sizetree
 = type ? size_in_bytes (type) : size_int (GET_MODE_SIZE (passed_mode));
 where_pad = FUNCTION_ARG_PADDING (passed_mode, type);
-boundary = FUNCTION_ARG_BOUNDARY (passed_mode, type);
+boundary = targetm.calls.function_arg_boundary (passed_mode, type);
 locate->where_pad = where_pad;
 /* Alignment can't exceed MAX_SUPPORTED_STACK_ALIGNMENT.  */
 if (boundary > MAX_SUPPORTED_STACK_ALIGNMENT)
 boundary = MAX_SUPPORTED_STACK_ALIGNMENT;
 static void
 setjmp_vars_warning (bitmap setjmp_crosses, tree block)
 {
 tree decl, sub;
-for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl))
+for (decl = BLOCK_VARS (block); decl; decl = DECL_CHAIN (decl))
 {
 if (TREE_CODE (decl) == VAR_DECL
 	  && DECL_RTL_SET_P (decl)
 	  && REG_P (DECL_RTL (decl))
 	  && regno_clobbered_at_setjmp (setjmp_crosses, REGNO (DECL_RTL (decl))))
 static void
 setjmp_args_warning (bitmap setjmp_crosses)
 {
 tree decl;
 for (decl = DECL_ARGUMENTS (current_function_decl);
-decl; decl = TREE_CHAIN (decl))
+decl; decl = DECL_CHAIN (decl))
 if (DECL_RTL (decl) != 0
 	&& REG_P (DECL_RTL (decl))
 	&& regno_clobbered_at_setjmp (setjmp_crosses, REGNO (DECL_RTL (decl))))
 warning (OPT_Wclobbered,
 "argument %q+D might be clobbered by %<longjmp%> or %<vfork%>",
 setjmp_vars_warning (setjmp_crosses, DECL_INITIAL (current_function_decl));
 setjmp_args_warning (setjmp_crosses);
 }
+/* Reverse the order of elements in the fragment chain T of blocks,
+and return the new head of the chain (old last element).  */
+static tree
+block_fragments_nreverse (tree t)
+{
+tree prev = 0, block, next;
+for (block = t; block; block = next)
+{
+next = BLOCK_FRAGMENT_CHAIN (block);
+BLOCK_FRAGMENT_CHAIN (block) = prev;
+prev = block;
+}
+return prev;
+}
+/* Reverse the order of elements in the chain T of blocks,
+and return the new head of the chain (old last element).
+Also do the same on subblocks and reverse the order of elements
+in BLOCK_FRAGMENT_CHAIN as well.  */
+static tree
+blocks_nreverse_all (tree t)
+{
+tree prev = 0, block, next;
+for (block = t; block; block = next)
+{
+next = BLOCK_CHAIN (block);
+BLOCK_CHAIN (block) = prev;
+BLOCK_SUBBLOCKS (block) = blocks_nreverse_all (BLOCK_SUBBLOCKS (block));
+if (BLOCK_FRAGMENT_CHAIN (block)
+	  && BLOCK_FRAGMENT_ORIGIN (block) == NULL_TREE)
+	BLOCK_FRAGMENT_CHAIN (block)
+	  = block_fragments_nreverse (BLOCK_FRAGMENT_CHAIN (block));
+prev = block;
+}
+return prev;
+}
 /* Identify BLOCKs referenced by more than one NOTE_INSN_BLOCK_{BEG,END},
 and create duplicate blocks.  */
 /* ??? Need an option to either create block fragments or to create
 abstract origin duplicates of a source block.  It really depends
 on what optimization has been performed.  */
 BLOCK_SUBBLOCKS (block) = NULL_TREE;
 BLOCK_CHAIN (block) = NULL_TREE;
 /* Recreate the block tree from the note nesting.  */
 reorder_blocks_1 (get_insns (), block, &block_stack);
-BLOCK_SUBBLOCKS (block) = blocks_nreverse (BLOCK_SUBBLOCKS (block));
+BLOCK_SUBBLOCKS (block) = blocks_nreverse_all (BLOCK_SUBBLOCKS (block));
 VEC_free (tree, heap, block_stack);
 }
 /* Helper function for reorder_blocks.  Reset TREE_ASM_WRITTEN.  */
 	  if (NOTE_KIND (insn) == NOTE_INSN_BLOCK_BEG)
 	    {
 	      tree block = NOTE_BLOCK (insn);
 	      tree origin;
-	      origin = (BLOCK_FRAGMENT_ORIGIN (block)
+	      gcc_assert (BLOCK_FRAGMENT_ORIGIN (block) == NULL_TREE);
-			? BLOCK_FRAGMENT_ORIGIN (block)
+	      origin = block;
-			: block);
 	      /* If we have seen this block before, that means it now
 		 spans multiple address regions.  Create a new fragment.  */
 	      if (TREE_ASM_WRITTEN (block))
 		{
 	      VEC_safe_push (tree, heap, *p_block_stack, block);
 	    }
 	  else if (NOTE_KIND (insn) == NOTE_INSN_BLOCK_END)
 	    {
 	      NOTE_BLOCK (insn) = VEC_pop (tree, *p_block_stack);
-	      BLOCK_SUBBLOCKS (current_block)
-		= blocks_nreverse (BLOCK_SUBBLOCKS (current_block));
 	      current_block = BLOCK_SUPERCONTEXT (current_block);
 	    }
 	}
 }
 }
 and return the new head of the chain (old last element).  */
 tree
 blocks_nreverse (tree t)
 {
-tree prev = 0, decl, next;
+tree prev = 0, block, next;
-for (decl = t; decl; decl = next)
+for (block = t; block; block = next)
 {
-next = BLOCK_CHAIN (decl);
+next = BLOCK_CHAIN (block);
-BLOCK_CHAIN (decl) = prev;
+BLOCK_CHAIN (block) = prev;
-prev = decl;
+prev = block;
 }
 return prev;
 }
 /* Count the subblocks of the list starting with BLOCK.  If VECTOR is
 return;
 }
 /* If VAR is present in a subblock of BLOCK, return the subblock.  */
-tree
+DEBUG_FUNCTION tree
 debug_find_var_in_block_tree (tree var, tree block)
 {
 tree t;
 for (t = BLOCK_VARS (block); t; t = TREE_CHAIN (t))
 /* Change optimization options if needed.  */
 if (optimization_current_node != opts)
 	{
 	  optimization_current_node = opts;
-	  cl_optimization_restore (TREE_OPTIMIZATION (opts));
+	  cl_optimization_restore (&global_options, TREE_OPTIMIZATION (opts));
 	}
 targetm.set_current_function (fndecl);
 }
 }
 allocate_struct_function (tree fndecl, bool abstract_p)
 {
 tree result;
 tree fntype = fndecl ? TREE_TYPE (fndecl) : NULL_TREE;
-cfun = GGC_CNEW (struct function);
+cfun = ggc_alloc_cleared_function ();
 init_eh_for_function ();
 if (init_machine_status)
 cfun->machine = (*init_machine_status) ();
 	  cfun->returns_pcc_struct = 1;
 #endif
 	  cfun->returns_struct = 1;
 	}
-cfun->stdarg
+cfun->stdarg = stdarg_p (fntype);
-	= (fntype
-	   && TYPE_ARG_TYPES (fntype) != 0
-	   && (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype)))
-	       != void_type_node));
 /* Assume all registers in stdarg functions need to be saved.  */
 cfun->va_list_gpr_size = VA_LIST_MAX_GPR_SIZE;
 cfun->va_list_fpr_size = VA_LIST_MAX_FPR_SIZE;
+/* ??? This could be set on a per-function basis by the front-end
+but is this worth the hassle?  */
+cfun->can_throw_non_call_exceptions = flag_non_call_exceptions;
 }
 }
 /* This is like allocate_struct_function, but pushes a new cfun for FNDECL
 instead of just setting it.  */
 {
 VEC_safe_push (function_p, heap, cfun_stack, cfun);
 allocate_struct_function (fndecl, false);
 }
-/* Reset cfun, and other non-struct-function variables to defaults as
+/* Reset crtl and other non-struct-function variables to defaults as
 appropriate for emitting rtl at the start of a function.  */
 static void
 prepare_function_start (void)
 {
 init_temp_slots ();
 init_emit ();
 init_varasm_status ();
 init_expr ();
 default_rtl_profile ();
+if (flag_stack_usage)
+{
+cfun->su = ggc_alloc_cleared_stack_usage ();
+cfun->su->static_stack_size = -1;
+}
 cse_not_expected = ! optimize;
 /* Caller save not needed yet.  */
 caller_save_needed = 0;
 do_warn_unused_parameter (tree fn)
 {
 tree decl;
 for (decl = DECL_ARGUMENTS (fn);
-decl; decl = TREE_CHAIN (decl))
+decl; decl = DECL_CHAIN (decl))
 if (!TREE_USED (decl) && TREE_CODE (decl) == PARM_DECL
 	&& DECL_NAME (decl) && !DECL_ARTIFICIAL (decl)
 	&& !TREE_NO_WARNING (decl))
 warning (OPT_Wunused_parameter, "unused parameter %q+D", decl);
 }
 	      anti_adjust_stack_and_probe (max_frame_size, true);
 	    else
 	      probe_stack_range (STACK_OLD_CHECK_PROTECT, max_frame_size);
 	    seq = get_insns ();
 	    end_sequence ();
+	    set_insn_locators (seq, prologue_locator);
 	    emit_insn_before (seq, stack_check_probe_note);
 	    break;
 	  }
 }
 clobber_after = get_last_insn ();
 /* Output the label for the actual return from the function.  */
 emit_label (return_label);
-if (USING_SJLJ_EXCEPTIONS)
+if (targetm.except_unwind_info (&global_options) == UI_SJLJ)
 {
 /* Let except.c know where it should emit the call to unregister
 	 the function context for sjlj exceptions.  */
 if (flag_exceptions)
 	sjlj_emit_function_exit_after (get_last_insn ());
 else
 {
 /* We want to ensure that instructions that may trap are not
 	 moved into the epilogue by scheduling, because we don't
 	 always emit unwind information for the epilogue.  */
-if (flag_non_call_exceptions)
+if (cfun->can_throw_non_call_exceptions)
 	emit_insn (gen_blockage ());
 }
 /* If this is an implementation of throw, do what's necessary to
 communicate between __builtin_eh_return and the epilogue.  */
 emit_label (naked_return_label);
 /* @@@ This is a kludge.  We want to ensure that instructions that
 may trap are not moved into the epilogue by scheduling, because
 we don't always emit unwind information for the epilogue.  */
-if (! USING_SJLJ_EXCEPTIONS && flag_non_call_exceptions)
+if (cfun->can_throw_non_call_exceptions
+&& targetm.except_unwind_info (&global_options) != UI_SJLJ)
 emit_insn (gen_blockage ());
 /* If stack protection is enabled for this function, check the guard.  */
 if (crtl->stack_protect_guard)
 stack_protect_epilogue ();
 an accurate stack pointer to exit the function,
 insert some code to save and restore the stack pointer.  */
 if (! EXIT_IGNORE_STACK
 && cfun->calls_alloca)
 {
-rtx tem = 0;
+rtx tem = 0, seq;
-emit_stack_save (SAVE_FUNCTION, &tem, parm_birth_insn);
+start_sequence ();
-emit_stack_restore (SAVE_FUNCTION, tem, NULL_RTX);
+emit_stack_save (SAVE_FUNCTION, &tem);
+seq = get_insns ();
+end_sequence ();
+emit_insn_before (seq, parm_birth_insn);
+emit_stack_restore (SAVE_FUNCTION, tem);
 }
 /* ??? This should no longer be necessary since stupid is no longer with
 us, but there are some parts of the compiler (eg reload_combine, and
 sh mach_dep_reorg) that still try and compute their own lifetime info
 end_sequence ();
 push_topmost_sequence ();
 emit_insn_after (seq, entry_of_function ());
 pop_topmost_sequence ();
+crtl->arg_pointer_save_area_init = true;
 }
 return ret;
 }
 gcc_assert (*slot == NULL);
 *slot = tmp;
 }
 }
-/* INSN has been duplicated as COPY, as part of duping a basic block.
+/* INSN has been duplicated or replaced by as COPY, perhaps by duplicating a
-If INSN is an epilogue insn, then record COPY as epilogue as well.  */
+basic block, splitting or peepholes.  If INSN is a prologue or epilogue
+insn, then record COPY as well.  */
 void
-maybe_copy_epilogue_insn (rtx insn, rtx copy)
+maybe_copy_prologue_epilogue_insn (rtx insn, rtx copy)
 {
+htab_t hash;
 void **slot;
-if (epilogue_insn_hash == NULL
+hash = epilogue_insn_hash;
-|| htab_find (epilogue_insn_hash, insn) == NULL)
+if (!hash || !htab_find (hash, insn))
-return;
+{
+hash = prologue_insn_hash;
-slot = htab_find_slot (epilogue_insn_hash, copy, INSERT);
+if (!hash || !htab_find (hash, insn))
+	return;
+}
+slot = htab_find_slot (hash, copy, INSERT);
 gcc_assert (*slot == NULL);
 *slot = copy;
 }
 /* Set the locator of the insn chain starting at INSN to LOC.  */
 the epilogue begins.  Update the basic block information when possible.  */
 static void
 thread_prologue_and_epilogue_insns (void)
 {
-int inserted = 0;
+bool inserted;
+rtx seq ATTRIBUTE_UNUSED, epilogue_end ATTRIBUTE_UNUSED;
+edge entry_edge ATTRIBUTE_UNUSED;
 edge e;
-#if defined (HAVE_sibcall_epilogue) || defined (HAVE_epilogue) || defined (HAVE_return) || defined (HAVE_prologue)
+edge_iterator ei;
-rtx seq;
+rtl_profile_for_bb (ENTRY_BLOCK_PTR);
+inserted = false;
+seq = NULL_RTX;
+epilogue_end = NULL_RTX;
+/* Can't deal with multiple successors of the entry block at the
+moment.  Function should always have at least one entry
+point.  */
+gcc_assert (single_succ_p (ENTRY_BLOCK_PTR));
+entry_edge = single_succ_edge (ENTRY_BLOCK_PTR);
+if (flag_split_stack
+&& (lookup_attribute ("no_split_stack", DECL_ATTRIBUTES (cfun->decl))
+	  == NULL))
+{
+#ifndef HAVE_split_stack_prologue
+gcc_unreachable ();
+#else
+gcc_assert (HAVE_split_stack_prologue);
+start_sequence ();
+emit_insn (gen_split_stack_prologue ());
+seq = get_insns ();
+end_sequence ();
+record_insns (seq, NULL, &prologue_insn_hash);
+set_insn_locators (seq, prologue_locator);
+/* This relies on the fact that committing the edge insertion
+	 will look for basic blocks within the inserted instructions,
+	 which in turn relies on the fact that we are not in CFG
+	 layout mode here.  */
+insert_insn_on_edge (seq, entry_edge);
+inserted = true;
 #endif
-#if defined (HAVE_epilogue) || defined(HAVE_return)
+}
-rtx epilogue_end = NULL_RTX;
-#endif
-edge_iterator ei;
-rtl_profile_for_bb (ENTRY_BLOCK_PTR);
 #ifdef HAVE_prologue
 if (HAVE_prologue)
 {
 start_sequence ();
 seq = gen_prologue ();
 /* Retain a map of the prologue insns.  */
 record_insns (seq, NULL, &prologue_insn_hash);
 emit_note (NOTE_INSN_PROLOGUE_END);
-#ifndef PROFILE_BEFORE_PROLOGUE
 /* Ensure that instructions are not moved into the prologue when
 	 profiling is on.  The call to the profiling routine can be
 	 emitted within the live range of a call-clobbered register.  */
-if (crtl->profile)
+if (!targetm.profile_before_prologue () && crtl->profile)
 emit_insn (gen_blockage ());
-#endif
 seq = get_insns ();
 end_sequence ();
 set_insn_locators (seq, prologue_locator);
-/* Can't deal with multiple successors of the entry block
+insert_insn_on_edge (seq, entry_edge);
-at the moment.  Function should always have at least one
+inserted = true;
-entry point.  */
-gcc_assert (single_succ_p (ENTRY_BLOCK_PTR));
-insert_insn_on_edge (seq, single_succ_edge (ENTRY_BLOCK_PTR));
-inserted = 1;
 }
 #endif
 /* If the exit block has no non-fake predecessors, we don't need
 an epilogue.  */
 	 emit (conditional) return instructions.  */
 basic_block last;
 rtx label;
-FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds)
+e = find_fallthru_edge (EXIT_BLOCK_PTR->preds);
-	if (e->flags & EDGE_FALLTHRU)
-	  break;
 if (e == NULL)
 	goto epilogue_done;
 last = e->src;
 /* Verify that there are no active instructions in the last block.  */
 /* Find the edge that falls through to EXIT.  Other edges may exist
 due to RETURN instructions, but those don't need epilogues.
 There really shouldn't be a mixture -- either all should have
 been converted or none, however...  */
-FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds)
+e = find_fallthru_edge (EXIT_BLOCK_PTR->preds);
-if (e->flags & EDGE_FALLTHRU)
-break;
 if (e == NULL)
 goto epilogue_done;
 #ifdef HAVE_epilogue
 if (HAVE_epilogue)
 {
 start_sequence ();
 epilogue_end = emit_note (NOTE_INSN_EPILOGUE_BEG);
 seq = gen_epilogue ();
-emit_jump_insn (seq);
+if (seq)
+	emit_jump_insn (seq);
 /* Retain a map of the epilogue insns.  */
 record_insns (seq, NULL, &epilogue_insn_hash);
 set_insn_locators (seq, epilogue_locator);
 seq = get_insns ();
 end_sequence ();
 insert_insn_on_edge (seq, e);
-inserted = 1;
+inserted = true;
 }
 else
 #endif
 {
 basic_block cur_bb;
 while (POINTER_TYPE_P (t) || TREE_CODE (t) == ARRAY_TYPE)
 if (TYPE_NAME (t))
 break;
 else
 t = TREE_TYPE (t);
+if (TREE_CODE (t) == ERROR_MARK)
+return;
 if (TYPE_NAME (t) == NULL_TREE
 || TYPE_NAME (t) == TYPE_NAME (TYPE_MAIN_VARIANT (t)))
 t = TYPE_MAIN_VARIANT (t);
 if (debug_info_level > DINFO_LEVEL_NONE)
 {
 	used_types_insert_helper (t, cfun);
 else
 	/* So this might be a type referenced by a global variable.
 	   Record that type so that we can later decide to emit its debug
 	   information.  */
-	types_used_by_cur_var_decl =
+VEC_safe_push (tree, gc, types_used_by_cur_var_decl, t);
-	  tree_cons (t, NULL, types_used_by_cur_var_decl);
 }
 }
 /* Helper to Hash a struct types_used_by_vars_entry.  */
 slot = htab_find_slot_with_hash (types_used_by_vars_hash, &e,
 				       hash_types_used_by_vars_entry (&e), INSERT);
 if (*slot == NULL)
 	{
 	  struct types_used_by_vars_entry *entry;
-	  entry = (struct types_used_by_vars_entry*) ggc_alloc
+	  entry = ggc_alloc_types_used_by_vars_entry ();
-		    (sizeof (struct types_used_by_vars_entry));
 	  entry->type = type;
 	  entry->var_decl = var_decl;
 	  *slot = entry;
 	}
 }
 static unsigned int
 rest_of_handle_thread_prologue_and_epilogue (void)
 {
 if (optimize)
 cleanup_cfg (CLEANUP_EXPENSIVE);
 /* On some machines, the prologue and epilogue code, or parts thereof,
 can be represented as RTL.  Doing so lets us schedule insns between
 it and the rest of the code and also allows delayed branch
 scheduling to operate in the epilogue.  */
 thread_prologue_and_epilogue_insns ();
+/* The stack usage info is finalized during prologue expansion.  */
+if (flag_stack_usage)
+output_stack_usage ();
 return 0;
 }
 struct rtl_opt_pass pass_thread_prologue_and_epilogue =
 {

Mercurial > hg > CbC > CbC_gcc

comparison gcc/function.c @ 67:f6334be47118