CbC/CbC_gcc: gcc/cfgexpand.c comparison

comparison gcc/cfgexpand.c @ 69:1b10fe6932e1

merge 69

author	Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
date	Sun, 21 Aug 2011 07:53:12 +0900
parents	326d9e06c2e3 f6334be47118
children	b81903832de2

comparison

equal deleted inserted replaced

-:b362627d71ba
+:1b10fe6932e1
 /* A pass for lowering trees to RTL.
-Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009
+Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
 Free Software Foundation, Inc.
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify
 #include "tree-dump.h"
 #include "tree-pass.h"
 #include "except.h"
 #include "flags.h"
 #include "diagnostic.h"
+#include "tree-pretty-print.h"
+#include "gimple-pretty-print.h"
 #include "toplev.h"
 #include "debug.h"
 #include "params.h"
 #include "tree-inline.h"
 #include "value-prof.h"
 #include "target.h"
 #ifndef noCbC
 #include "cbc-tree.h"
 #endif
 #include "ssaexpand.h"
+#include "bitmap.h"
+#include "sbitmap.h"
+#include "insn-attr.h" /* For INSN_SCHEDULING.  */
 /* This variable holds information helping the rewriting of SSA trees
 into RTL.  */
 struct ssaexpand SA;
 tree t;
 enum gimple_rhs_class grhs_class;
 grhs_class = get_gimple_rhs_class (gimple_expr_code (stmt));
-if (grhs_class == GIMPLE_BINARY_RHS)
+if (grhs_class == GIMPLE_TERNARY_RHS)
+t = build3 (gimple_assign_rhs_code (stmt),
+		TREE_TYPE (gimple_assign_lhs (stmt)),
+		gimple_assign_rhs1 (stmt),
+		gimple_assign_rhs2 (stmt),
+		gimple_assign_rhs3 (stmt));
+else if (grhs_class == GIMPLE_BINARY_RHS)
 t = build2 (gimple_assign_rhs_code (stmt),
 TREE_TYPE (gimple_assign_lhs (stmt)),
 gimple_assign_rhs1 (stmt),
 gimple_assign_rhs2 (stmt));
 else if (grhs_class == GIMPLE_UNARY_RHS)
 gimple_assign_rhs1 (stmt));
 else if (grhs_class == GIMPLE_SINGLE_RHS)
 {
 t = gimple_assign_rhs1 (stmt);
 /* Avoid modifying this tree in place below.  */
-if (gimple_has_location (stmt) && CAN_HAVE_LOCATION_P (t)
+if ((gimple_has_location (stmt) && CAN_HAVE_LOCATION_P (t)
-&& gimple_location (stmt) != EXPR_LOCATION (t))
+	   && gimple_location (stmt) != EXPR_LOCATION (t))
-t = copy_node (t);
+	  || (gimple_block (stmt)
+	      && currently_expanding_to_rtl
+	      && EXPR_P (t)
+	      && gimple_block (stmt) != TREE_BLOCK (t)))
+	t = copy_node (t);
 }
 else
 gcc_unreachable ();
+if (gimple_has_location (stmt) && CAN_HAVE_LOCATION_P (t))
+SET_EXPR_LOCATION (t, gimple_location (stmt));
+if (gimple_block (stmt) && currently_expanding_to_rtl && EXPR_P (t))
+TREE_BLOCK (t) = gimple_block (stmt);
 return t;
-}
-/* Verify that there is exactly single jump instruction since last and attach
-REG_BR_PROB note specifying probability.
-??? We really ought to pass the probability down to RTL expanders and let it
-re-distribute it when the conditional expands into multiple conditionals.
-This is however difficult to do.  */
-void
-add_reg_br_prob_note (rtx last, int probability)
-{
-if (profile_status == PROFILE_ABSENT)
-return;
-for (last = NEXT_INSN (last); last && NEXT_INSN (last); last = NEXT_INSN (last))
-if (JUMP_P (last))
-{
-/* It is common to emit condjump-around-jump sequence when we don't know
-how to reverse the conditional.  Special case this.  */
-if (!any_condjump_p (last)
-|| !JUMP_P (NEXT_INSN (last))
-|| !simplejump_p (NEXT_INSN (last))
-|| !NEXT_INSN (NEXT_INSN (last))
-|| !BARRIER_P (NEXT_INSN (NEXT_INSN (last)))
-|| !NEXT_INSN (NEXT_INSN (NEXT_INSN (last)))
-|| !LABEL_P (NEXT_INSN (NEXT_INSN (NEXT_INSN (last))))
-|| NEXT_INSN (NEXT_INSN (NEXT_INSN (NEXT_INSN (last)))))
-goto failed;
-gcc_assert (!find_reg_note (last, REG_BR_PROB, 0));
-add_reg_note (last, REG_BR_PROB,
-GEN_INT (REG_BR_PROB_BASE - probability));
-return;
-}
-if (!last || !JUMP_P (last) || !any_condjump_p (last))
-goto failed;
-gcc_assert (!find_reg_note (last, REG_BR_PROB, 0));
-add_reg_note (last, REG_BR_PROB, GEN_INT (probability));
-return;
-failed:
-if (dump_file)
-fprintf (dump_file, "Failed to add probability note\n");
 }
 #ifndef STACK_ALIGNMENT_NEEDED
 #define STACK_ALIGNMENT_NEEDED 1
 we can't do with expected alignment of the stack boundary.  */
 static unsigned int
 get_decl_align_unit (tree decl)
 {
-unsigned int align;
+unsigned int align = LOCAL_DECL_ALIGNMENT (decl);
-align = LOCAL_DECL_ALIGNMENT (decl);
-if (align > MAX_SUPPORTED_STACK_ALIGNMENT)
-align = MAX_SUPPORTED_STACK_ALIGNMENT;
-if (SUPPORTS_STACK_ALIGNMENT)
-{
-if (crtl->stack_alignment_estimated < align)
-{
-gcc_assert(!crtl->stack_realign_processed);
-crtl->stack_alignment_estimated = align;
-}
-}
-/* stack_alignment_needed > PREFERRED_STACK_BOUNDARY is permitted.
-So here we only make sure stack_alignment_needed >= align.  */
-if (crtl->stack_alignment_needed < align)
-crtl->stack_alignment_needed = align;
-if (crtl->max_used_stack_slot_alignment < align)
-crtl->max_used_stack_slot_alignment = align;
 return align / BITS_PER_UNIT;
 }
 /* Allocate SIZE bytes at byte alignment ALIGN from the stack frame.
 Return the frame offset.  */
 static HOST_WIDE_INT
-alloc_stack_frame_space (HOST_WIDE_INT size, HOST_WIDE_INT align)
+alloc_stack_frame_space (HOST_WIDE_INT size, unsigned HOST_WIDE_INT align)
 {
 HOST_WIDE_INT offset, new_frame_offset;
 new_frame_offset = frame_offset;
 if (FRAME_GROWS_DOWNWARD)
 /* Accumulate DECL into STACK_VARS.  */
 static void
 add_stack_var (tree decl)
 {
+struct stack_var *v;
 if (stack_vars_num >= stack_vars_alloc)
 {
 if (stack_vars_alloc)
 stack_vars_alloc = stack_vars_alloc * 3 / 2;
 else
 stack_vars_alloc = 32;
 stack_vars
 = XRESIZEVEC (struct stack_var, stack_vars, stack_vars_alloc);
 }
-stack_vars[stack_vars_num].decl = decl;
+v = &stack_vars[stack_vars_num];
-stack_vars[stack_vars_num].offset = 0;
-stack_vars[stack_vars_num].size = tree_low_cst (DECL_SIZE_UNIT (SSAVAR (decl)), 1);
+v->decl = decl;
-stack_vars[stack_vars_num].alignb = get_decl_align_unit (SSAVAR (decl));
+v->offset = 0;
+v->size = tree_low_cst (DECL_SIZE_UNIT (SSAVAR (decl)), 1);
+/* Ensure that all variables have size, so that &a != &b for any two
+variables that are simultaneously live.  */
+if (v->size == 0)
+v->size = 1;
+v->alignb = get_decl_align_unit (SSAVAR (decl));
 /* All variables are initially in their own partition.  */
-stack_vars[stack_vars_num].representative = stack_vars_num;
+v->representative = stack_vars_num;
-stack_vars[stack_vars_num].next = EOC;
+v->next = EOC;
 /* All variables initially conflict with no other.  */
-stack_vars[stack_vars_num].conflicts = NULL;
+v->conflicts = NULL;
 /* Ensure that this decl doesn't get put onto the list twice.  */
 set_rtl (decl, pc_rtx);
 stack_vars_num++;
 if (TREE_CODE (type) == ARRAY_TYPE)
 return aggregate_contains_union_type (TREE_TYPE (type));
 if (TREE_CODE (type) != RECORD_TYPE)
 return false;
-for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
+for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
 if (TREE_CODE (field) == FIELD_DECL)
 if (aggregate_contains_union_type (TREE_TYPE (field)))
 return true;
 return false;
 }
 }
 }
 /* A subroutine of partition_stack_vars.  A comparison function for qsort,
-sorting an array of indices by the size and type of the object.  */
+sorting an array of indices by the properties of the object.  */
 static int
-stack_var_size_cmp (const void *a, const void *b)
+stack_var_cmp (const void *a, const void *b)
 {
-HOST_WIDE_INT sa = stack_vars[*(const size_t *)a].size;
+size_t ia = *(const size_t *)a;
-HOST_WIDE_INT sb = stack_vars[*(const size_t *)b].size;
+size_t ib = *(const size_t *)b;
-tree decla, declb;
+unsigned int aligna = stack_vars[ia].alignb;
+unsigned int alignb = stack_vars[ib].alignb;
+HOST_WIDE_INT sizea = stack_vars[ia].size;
+HOST_WIDE_INT sizeb = stack_vars[ib].size;
+tree decla = stack_vars[ia].decl;
+tree declb = stack_vars[ib].decl;
+bool largea, largeb;
 unsigned int uida, uidb;
-if (sa < sb)
+/* Primary compare on "large" alignment.  Large comes first.  */
+largea = (aligna * BITS_PER_UNIT > MAX_SUPPORTED_STACK_ALIGNMENT);
+largeb = (alignb * BITS_PER_UNIT > MAX_SUPPORTED_STACK_ALIGNMENT);
+if (largea != largeb)
+return (int)largeb - (int)largea;
+/* Secondary compare on size, decreasing  */
+if (sizea < sizeb)
 return -1;
-if (sa > sb)
+if (sizea > sizeb)
 return 1;
-decla = stack_vars[*(const size_t *)a].decl;
-declb = stack_vars[*(const size_t *)b].decl;
+/* Tertiary compare on true alignment, decreasing.  */
-/* For stack variables of the same size use and id of the decls
+if (aligna < alignb)
-to make the sort stable.  Two SSA names are compared by their
+return -1;
-version, SSA names come before non-SSA names, and two normal
+if (aligna > alignb)
-decls are compared by their DECL_UID.  */
+return 1;
+/* Final compare on ID for sort stability, increasing.
+Two SSA names are compared by their version, SSA names come before
+non-SSA names, and two normal decls are compared by their DECL_UID.  */
 if (TREE_CODE (decla) == SSA_NAME)
 {
 if (TREE_CODE (declb) == SSA_NAME)
 uida = SSA_NAME_VERSION (decla), uidb = SSA_NAME_VERSION (declb);
 else
 else if (TREE_CODE (declb) == SSA_NAME)
 return 1;
 else
 uida = DECL_UID (decla), uidb = DECL_UID (declb);
 if (uida < uidb)
+return 1;
+if (uida > uidb)
 return -1;
-if (uida > uidb)
-return 1;
 return 0;
 }
 /* If the points-to solution *PI points to variables that are in a partition
 /* Create bitmaps representing partitions.  They will be used for
 points-to sets later, so use GGC alloc.  */
 part = BITMAP_GGC_ALLOC ();
 for (j = i; j != EOC; j = stack_vars[j].next)
-{
+	{
-tree decl = stack_vars[j].decl;
+	  tree decl = stack_vars[j].decl;
-unsigned int uid = DECL_UID (decl);
+	  unsigned int uid = DECL_PT_UID (decl);
-/* We should never end up partitioning SSA names (though they
+	  /* We should never end up partitioning SSA names (though they
-may end up on the stack).  Neither should we allocate stack
+	     may end up on the stack).  Neither should we allocate stack
-space to something that is unused and thus unreferenced.  */
+	     space to something that is unused and thus unreferenced, except
-gcc_assert (DECL_P (decl)
+	     for -O0 where we are preserving even unreferenced variables.  */
-&& referenced_var_lookup (uid));
+	  gcc_assert (DECL_P (decl)
-bitmap_set_bit (part, uid);
+		      && (!optimize
-*((bitmap *) pointer_map_insert (decls_to_partitions,
+			  || referenced_var_lookup (cfun, DECL_UID (decl))));
-(void *)(size_t) uid)) = part;
+	  bitmap_set_bit (part, uid);
-*((tree *) pointer_map_insert (cfun->gimple_df->decls_to_pointers,
+	  *((bitmap *) pointer_map_insert (decls_to_partitions,
-decl)) = name;
+					   (void *)(size_t) uid)) = part;
-}
+	  *((tree *) pointer_map_insert (cfun->gimple_df->decls_to_pointers,
+					 decl)) = name;
+	}
 /* Make the SSA name point to all partition members.  */
 pi = get_ptr_info (name);
-pt_solution_set (&pi->pt, part);
+pt_solution_set (&pi->pt, part, false, false);
 }
 /* Make all points-to sets that contain one member of a partition
 contain all members of the partition.  */
 if (decls_to_partitions)
 add_partitioned_vars_to_ptset (&pi->pt, decls_to_partitions,
 visited, temp);
 }
 add_partitioned_vars_to_ptset (&cfun->gimple_df->escaped,
-decls_to_partitions, visited, temp);
+				     decls_to_partitions, visited, temp);
-add_partitioned_vars_to_ptset (&cfun->gimple_df->callused,
-decls_to_partitions, visited, temp);
 pointer_set_destroy (visited);
 pointer_map_destroy (decls_to_partitions);
 BITMAP_FREE (temp);
 }
 stack_vars_sorted[si] = si;
 if (n == 1)
 return;
-qsort (stack_vars_sorted, n, sizeof (size_t), stack_var_size_cmp);
+qsort (stack_vars_sorted, n, sizeof (size_t), stack_var_cmp);
 for (si = 0; si < n; ++si)
 {
 size_t i = stack_vars_sorted[si];
 HOST_WIDE_INT isize = stack_vars[i].size;
+unsigned int ialign = stack_vars[i].alignb;
 HOST_WIDE_INT offset = 0;
 for (sj = si; sj-- > 0; )
-{
+	{
-size_t j = stack_vars_sorted[sj];
+	  size_t j = stack_vars_sorted[sj];
-HOST_WIDE_INT jsize = stack_vars[j].size;
+	  HOST_WIDE_INT jsize = stack_vars[j].size;
-unsigned int jalign = stack_vars[j].alignb;
+	  unsigned int jalign = stack_vars[j].alignb;
-/* Ignore objects that aren't partition representatives.  */
+	  /* Ignore objects that aren't partition representatives.  */
-if (stack_vars[j].representative != j)
+	  if (stack_vars[j].representative != j)
-continue;
+	    continue;
-/* Ignore objects too large for the remaining space.  */
+	  /* Ignore objects too large for the remaining space.  */
-if (isize < jsize)
+	  if (isize < jsize)
-continue;
+	    continue;
-/* Ignore conflicting objects.  */
+	  /* Ignore conflicting objects.  */
-if (stack_var_conflict_p (i, j))
+	  if (stack_var_conflict_p (i, j))
-continue;
+	    continue;
-/* Refine the remaining space check to include alignment.  */
+	  /* Do not mix objects of "small" (supported) alignment
-if (offset & (jalign - 1))
+	     and "large" (unsupported) alignment.  */
-{
+	  if ((ialign * BITS_PER_UNIT <= MAX_SUPPORTED_STACK_ALIGNMENT)
-HOST_WIDE_INT toff = offset;
+	      != (jalign * BITS_PER_UNIT <= MAX_SUPPORTED_STACK_ALIGNMENT))
-toff += jalign - 1;
+	    continue;
-toff &= -(HOST_WIDE_INT)jalign;
-if (isize - (toff - offset) < jsize)
+	  /* Refine the remaining space check to include alignment.  */
-continue;
+	  if (offset & (jalign - 1))
+	    {
-isize -= toff - offset;
+	      HOST_WIDE_INT toff = offset;
-offset = toff;
+	      toff += jalign - 1;
-}
+	      toff &= -(HOST_WIDE_INT)jalign;
+	      if (isize - (toff - offset) < jsize)
-/* UNION the objects, placing J at OFFSET.  */
+		continue;
-union_stack_vars (i, j, offset);
+	      isize -= toff - offset;
-isize -= jsize;
+	      offset = toff;
-if (isize == 0)
+	    }
-break;
-}
+	  /* UNION the objects, placing J at OFFSET.  */
-}
+	  union_stack_vars (i, j, offset);
-if (optimize)
+	  isize -= jsize;
-update_alias_info_with_stack_vars ();
+	  if (isize == 0)
+	    break;
+	}
+}
+update_alias_info_with_stack_vars ();
 }
 /* A debugging aid for expand_used_vars.  Dump the generated partitions.  */
 static void
 stack_vars[j].offset);
 }
 }
 }
-/* Assign rtl to DECL at frame offset OFFSET.  */
+/* Assign rtl to DECL at BASE + OFFSET.  */
 static void
-expand_one_stack_var_at (tree decl, HOST_WIDE_INT offset)
+expand_one_stack_var_at (tree decl, rtx base, unsigned base_align,
-{
+			 HOST_WIDE_INT offset)
-/* Alignment is unsigned.   */
+{
-unsigned HOST_WIDE_INT align;
+unsigned align;
 rtx x;
 /* If this fails, we've overflowed the stack frame.  Error nicely?  */
 gcc_assert (offset == trunc_int_for_mode (offset, Pmode));
-x = plus_constant (virtual_stack_vars_rtx, offset);
+x = plus_constant (base, offset);
 x = gen_rtx_MEM (DECL_MODE (SSAVAR (decl)), x);
 if (TREE_CODE (decl) != SSA_NAME)
 {
 /* Set alignment we actually gave this decl if it isn't an SSA name.
 If it is we generate stack slots only accidentally so it isn't as
-important, we'll simply use the alignment that is already set.  */
+	 important, we'll simply use the alignment that is already set.  */
-offset -= frame_phase;
+if (base == virtual_stack_vars_rtx)
+	offset -= frame_phase;
 align = offset & -offset;
 align *= BITS_PER_UNIT;
-if (align == 0)
+if (align == 0 || align > base_align)
-align = STACK_BOUNDARY;
+	align = base_align;
-else if (align > MAX_SUPPORTED_STACK_ALIGNMENT)
-align = MAX_SUPPORTED_STACK_ALIGNMENT;
+/* One would think that we could assert that we're not decreasing
+	 alignment here, but (at least) the i386 port does exactly this
+	 via the MINIMUM_ALIGNMENT hook.  */
 DECL_ALIGN (decl) = align;
 DECL_USER_ALIGN (decl) = 0;
 }
 static void
 expand_stack_vars (bool (*pred) (tree))
 {
 size_t si, i, j, n = stack_vars_num;
+HOST_WIDE_INT large_size = 0, large_alloc = 0;
+rtx large_base = NULL;
+unsigned large_align = 0;
+tree decl;
+/* Determine if there are any variables requiring "large" alignment.
+Since these are dynamically allocated, we only process these if
+no predicate involved.  */
+large_align = stack_vars[stack_vars_sorted[0]].alignb * BITS_PER_UNIT;
+if (pred == NULL && large_align > MAX_SUPPORTED_STACK_ALIGNMENT)
+{
+/* Find the total size of these variables.  */
+for (si = 0; si < n; ++si)
+	{
+	  unsigned alignb;
+	  i = stack_vars_sorted[si];
+	  alignb = stack_vars[i].alignb;
+	  /* Stop when we get to the first decl with "small" alignment.  */
+	  if (alignb * BITS_PER_UNIT <= MAX_SUPPORTED_STACK_ALIGNMENT)
+	    break;
+	  /* Skip variables that aren't partition representatives.  */
+	  if (stack_vars[i].representative != i)
+	    continue;
+	  /* Skip variables that have already had rtl assigned.  See also
+	     add_stack_var where we perpetrate this pc_rtx hack.  */
+	  decl = stack_vars[i].decl;
+	  if ((TREE_CODE (decl) == SSA_NAME
+	      ? SA.partition_to_pseudo[var_to_partition (SA.map, decl)]
+	      : DECL_RTL (decl)) != pc_rtx)
+	    continue;
+	  large_size += alignb - 1;
+	  large_size &= -(HOST_WIDE_INT)alignb;
+	  large_size += stack_vars[i].size;
+	}
+/* If there were any, allocate space.  */
+if (large_size > 0)
+	large_base = allocate_dynamic_stack_space (GEN_INT (large_size), 0,
+						   large_align, true);
+}
 for (si = 0; si < n; ++si)
 {
+rtx base;
+unsigned base_align, alignb;
 HOST_WIDE_INT offset;
 i = stack_vars_sorted[si];
 /* Skip variables that aren't partition representatives, for now.  */
 if (stack_vars[i].representative != i)
 continue;
 /* Skip variables that have already had rtl assigned.  See also
-add_stack_var where we perpetrate this pc_rtx hack.  */
+	 add_stack_var where we perpetrate this pc_rtx hack.  */
-if ((TREE_CODE (stack_vars[i].decl) == SSA_NAME
+decl = stack_vars[i].decl;
-? SA.partition_to_pseudo[var_to_partition (SA.map, stack_vars[i].decl)]
+if ((TREE_CODE (decl) == SSA_NAME
-: DECL_RTL (stack_vars[i].decl)) != pc_rtx)
+	   ? SA.partition_to_pseudo[var_to_partition (SA.map, decl)]
-continue;
+	   : DECL_RTL (decl)) != pc_rtx)
+	continue;
 /* Check the predicate to see whether this variable should be
-allocated in this pass.  */
+	 allocated in this pass.  */
-if (pred && !pred (stack_vars[i].decl))
+if (pred && !pred (decl))
-continue;
+	continue;
-offset = alloc_stack_frame_space (stack_vars[i].size,
+alignb = stack_vars[i].alignb;
-stack_vars[i].alignb);
+if (alignb * BITS_PER_UNIT <= MAX_SUPPORTED_STACK_ALIGNMENT)
+	{
+	  offset = alloc_stack_frame_space (stack_vars[i].size, alignb);
+	  base = virtual_stack_vars_rtx;
+	  base_align = crtl->max_used_stack_slot_alignment;
+	}
+else
+	{
+	  /* Large alignment is only processed in the last pass.  */
+	  if (pred)
+	    continue;
+	  gcc_assert (large_base != NULL);
+	  large_alloc += alignb - 1;
+	  large_alloc &= -(HOST_WIDE_INT)alignb;
+	  offset = large_alloc;
+	  large_alloc += stack_vars[i].size;
+	  base = large_base;
+	  base_align = large_align;
+	}
 /* Create rtl for each variable based on their location within the
 partition.  */
 for (j = i; j != EOC; j = stack_vars[j].next)
-{
+	{
-gcc_assert (stack_vars[j].offset <= stack_vars[i].size);
+	  gcc_assert (stack_vars[j].offset <= stack_vars[i].size);
-expand_one_stack_var_at (stack_vars[j].decl,
+	  expand_one_stack_var_at (stack_vars[j].decl,
-stack_vars[j].offset + offset);
+				   base, base_align,
-}
+				   stack_vars[j].offset + offset);
-}
+	}
+}
+gcc_assert (large_alloc == large_size);
 }
 /* Take into account all sizes of partitions and reset DECL_RTLs.  */
 static HOST_WIDE_INT
 account_stack_vars (void)
 to a variable to be allocated in the stack frame.  */
 static void
 expand_one_stack_var (tree var)
 {
-HOST_WIDE_INT size, offset, align;
+HOST_WIDE_INT size, offset;
+unsigned byte_align;
 size = tree_low_cst (DECL_SIZE_UNIT (SSAVAR (var)), 1);
-align = get_decl_align_unit (SSAVAR (var));
+byte_align = get_decl_align_unit (SSAVAR (var));
-offset = alloc_stack_frame_space (size, align);
+/* We handle highly aligned variables in expand_stack_vars.  */
-expand_one_stack_var_at (var, offset);
+gcc_assert (byte_align * BITS_PER_UNIT <= MAX_SUPPORTED_STACK_ALIGNMENT);
+offset = alloc_stack_frame_space (size, byte_align);
+expand_one_stack_var_at (var, virtual_stack_vars_rtx,
+			   crtl->max_used_stack_slot_alignment, offset);
 }
 /* A subroutine of expand_one_var.  Called to assign rtl to a VAR_DECL
 that will reside in a hard register.  */
 defer_stack_allocation (tree var, bool toplevel)
 {
 /* If stack protection is enabled, *all* stack variables must be deferred,
 so that we can re-order the strings to the top of the frame.  */
 if (flag_stack_protect)
+return true;
+/* We handle "large" alignment via dynamic allocation.  We want to handle
+this extra complication in only one place, so defer them.  */
+if (DECL_ALIGN (var) > MAX_SUPPORTED_STACK_ALIGNMENT)
 return true;
 /* Variables in the outermost scope automatically conflict with
 every other variable.  The only reason to want to defer them
 at all is that, after sorting, we can more efficiently pack
 */
 static HOST_WIDE_INT
 expand_one_var (tree var, bool toplevel, bool really_expand)
 {
+unsigned int align = BITS_PER_UNIT;
 tree origvar = var;
 var = SSAVAR (var);
-if (SUPPORTS_STACK_ALIGNMENT
+if (TREE_TYPE (var) != error_mark_node && TREE_CODE (var) == VAR_DECL)
-&& TREE_TYPE (var) != error_mark_node
+{
-&& TREE_CODE (var) == VAR_DECL)
-{
-unsigned int align;
 /* Because we don't know if VAR will be in register or on stack,
 we conservatively assume it will be on stack even if VAR is
 eventually put into register after RA pass.  For non-automatic
 variables, which won't be on stack, we collect alignment of
 type and ignore user specified alignment.  */
 if (TREE_STATIC (var) || DECL_EXTERNAL (var))
-align = MINIMUM_ALIGNMENT (TREE_TYPE (var),
+	align = MINIMUM_ALIGNMENT (TREE_TYPE (var),
-TYPE_MODE (TREE_TYPE (var)),
+				   TYPE_MODE (TREE_TYPE (var)),
-TYPE_ALIGN (TREE_TYPE (var)));
+				   TYPE_ALIGN (TREE_TYPE (var)));
+else if (DECL_HAS_VALUE_EXPR_P (var)
+	       || (DECL_RTL_SET_P (var) && MEM_P (DECL_RTL (var))))
+	/* Don't consider debug only variables with DECL_HAS_VALUE_EXPR_P set
+	   or variables which were assigned a stack slot already by
+	   expand_one_stack_var_at - in the latter case DECL_ALIGN has been
+	   changed from the offset chosen to it.  */
+	align = crtl->stack_alignment_estimated;
 else
 align = MINIMUM_ALIGNMENT (var, DECL_MODE (var), DECL_ALIGN (var));
-if (crtl->stack_alignment_estimated < align)
+/* If the variable alignment is very large we'll dynamicaly allocate
-{
+	 it, which means that in-frame portion is just a pointer.  */
-/* stack_alignment_estimated shouldn't change after stack
+if (align > MAX_SUPPORTED_STACK_ALIGNMENT)
-realign decision made */
+	align = POINTER_SIZE;
-gcc_assert(!crtl->stack_realign_processed);
+}
+if (SUPPORTS_STACK_ALIGNMENT
+&& crtl->stack_alignment_estimated < align)
+{
+/* stack_alignment_estimated shouldn't change after stack
+realign decision made */
+gcc_assert(!crtl->stack_realign_processed);
 crtl->stack_alignment_estimated = align;
 }
-}
+/* stack_alignment_needed > PREFERRED_STACK_BOUNDARY is permitted.
+So here we only make sure stack_alignment_needed >= align.  */
+if (crtl->stack_alignment_needed < align)
+crtl->stack_alignment_needed = align;
+if (crtl->max_used_stack_slot_alignment < align)
+crtl->max_used_stack_slot_alignment = align;
 if (TREE_CODE (origvar) == SSA_NAME)
 {
 gcc_assert (TREE_CODE (var) != VAR_DECL
 || (!DECL_EXTERNAL (var)
 else if (use_register_for_decl (var))
 {
 if (really_expand)
 expand_one_register_var (origvar);
 }
+else if (!host_integerp (DECL_SIZE_UNIT (var), 1))
+{
+if (really_expand)
+	{
+	  error ("size of variable %q+D is too large", var);
+	  expand_one_error_var (var);
+	}
+}
 else if (defer_stack_allocation (var, toplevel))
 add_stack_var (origvar);
 else
 {
 if (really_expand)
 tree t;
 old_sv_num = toplevel ? 0 : stack_vars_num;
 /* Expand all variables at this level.  */
-for (t = BLOCK_VARS (block); t ; t = TREE_CHAIN (t))
+for (t = BLOCK_VARS (block); t ; t = DECL_CHAIN (t))
 if (TREE_USED (t))
 expand_one_var (t, toplevel, true);
 this_sv_num = stack_vars_num;
 static void
 clear_tree_used (tree block)
 {
 tree t;
-for (t = BLOCK_VARS (block); t ; t = TREE_CHAIN (t))
+for (t = BLOCK_VARS (block); t ; t = DECL_CHAIN (t))
 /* if (!TREE_STATIC (t) && !DECL_EXTERNAL (t)) */
 TREE_USED (t) = 0;
 for (t = BLOCK_SUBBLOCKS (block); t ; t = BLOCK_CHAIN (t))
 clear_tree_used (t);
 TREE_USED (guard) = 1;
 expand_one_stack_var (guard);
 crtl->stack_protect_guard = guard;
 }
-/* A subroutine of expand_used_vars.  Walk down through the BLOCK tree
-expanding variables.  Those variables that can be put into registers
-are allocated pseudos; those that can't are put on the stack.
-TOPLEVEL is true if this is the outermost BLOCK.  */
-static HOST_WIDE_INT
-account_used_vars_for_block (tree block, bool toplevel)
-{
-tree t;
-HOST_WIDE_INT size = 0;
-/* Expand all variables at this level.  */
-for (t = BLOCK_VARS (block); t ; t = TREE_CHAIN (t))
-if (TREE_USED (t))
-size += expand_one_var (t, toplevel, false);
-/* Expand all variables at containing levels.  */
-for (t = BLOCK_SUBBLOCKS (block); t ; t = BLOCK_CHAIN (t))
-size += account_used_vars_for_block (t, false);
-return size;
-}
 /* Prepare for expanding variables.  */
 static void
 init_vars_expansion (void)
 {
 tree t;
+unsigned ix;
 /* Set TREE_USED on all variables in the local_decls.  */
-for (t = cfun->local_decls; t; t = TREE_CHAIN (t))
+FOR_EACH_LOCAL_DECL (cfun, ix, t)
-TREE_USED (TREE_VALUE (t)) = 1;
+TREE_USED (t) = 1;
 /* Clear TREE_USED on all variables associated with a block scope.  */
 clear_tree_used (DECL_INITIAL (current_function_decl));
 /* Initialize local stack smashing state.  */
 XDELETEVEC (stack_vars_sorted);
 stack_vars = NULL;
 stack_vars_alloc = stack_vars_num = 0;
 }
-/* Make a fair guess for the size of the stack frame of the current
+/* Make a fair guess for the size of the stack frame of the function
-function.  This doesn't have to be exact, the result is only used
+in NODE.  This doesn't have to be exact, the result is only used in
-in the inline heuristics.  So we don't want to run the full stack
+the inline heuristics.  So we don't want to run the full stack var
-var packing algorithm (which is quadratic in the number of stack
+packing algorithm (which is quadratic in the number of stack vars).
-vars).  Instead, we calculate the total size of all stack vars.
+Instead, we calculate the total size of all stack vars.  This turns
-This turns out to be a pretty fair estimate -- packing of stack
+out to be a pretty fair estimate -- packing of stack vars doesn't
-vars doesn't happen very often.  */
+happen very often.  */
 HOST_WIDE_INT
-estimated_stack_frame_size (void)
+estimated_stack_frame_size (struct cgraph_node *node)
 {
 HOST_WIDE_INT size = 0;
 size_t i;
-tree t, outer_block = DECL_INITIAL (current_function_decl);
+tree var;
+tree old_cur_fun_decl = current_function_decl;
-init_vars_expansion ();
+referenced_var_iterator rvi;
+struct function *fn = DECL_STRUCT_FUNCTION (node->decl);
-for (t = cfun->local_decls; t; t = TREE_CHAIN (t))
-{
+current_function_decl = node->decl;
-tree var = TREE_VALUE (t);
+push_cfun (fn);
-if (TREE_USED (var))
+gcc_checking_assert (gimple_referenced_vars (fn));
-size += expand_one_var (var, true, false);
+FOR_EACH_REFERENCED_VAR (fn, var, rvi)
-TREE_USED (var) = 1;
+size += expand_one_var (var, true, false);
-}
-size += account_used_vars_for_block (outer_block, true);
 if (stack_vars_num > 0)
 {
 /* Fake sorting the stack vars for account_stack_vars ().  */
 stack_vars_sorted = XNEWVEC (size_t, stack_vars_num);
 for (i = 0; i < stack_vars_num; ++i)
 stack_vars_sorted[i] = i;
 size += account_stack_vars ();
 fini_vars_expansion ();
 }
+pop_cfun ();
+current_function_decl = old_cur_fun_decl;
 return size;
 }
 /* Expand all variables used in the function.  */
 static void
 expand_used_vars (void)
 {
-tree t, next, outer_block = DECL_INITIAL (current_function_decl);
+tree var, outer_block = DECL_INITIAL (current_function_decl);
+VEC(tree,heap) *maybe_local_decls = NULL;
 unsigned i;
+unsigned len;
 /* Compute the phase of the stack frame for this function.  */
 {
 int align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
 int off = STARTING_FRAME_OFFSET % align;
 }
 }
 /* At this point all variables on the local_decls with TREE_USED
 set are not associated with any block scope.  Lay them out.  */
-t = cfun->local_decls;
-cfun->local_decls = NULL_TREE;
+len = VEC_length (tree, cfun->local_decls);
-for (; t; t = next)
+FOR_EACH_LOCAL_DECL (cfun, i, var)
 {
-tree var = TREE_VALUE (t);
 bool expand_now = false;
-next = TREE_CHAIN (t);
 /* Expanded above already.  */
 if (is_gimple_reg (var))
-{
+	{
-TREE_USED (var) = 0;
+	  TREE_USED (var) = 0;
-ggc_free (t);
+	  goto next;
-continue;
+	}
-}
 /* We didn't set a block for static or extern because it's hard
 to tell the difference between a global variable (re)declared
 in a local scope, and one that's really declared there to
 begin with.  And it doesn't really matter much, since we're
 not giving them stack space.  Expand them now.  */
 /* Finally, mark all variables on the list as used.  We'll use
 this in a moment when we expand those associated with scopes.  */
 TREE_USED (var) = 1;
 if (expand_now)
-{
+	expand_one_var (var, true, true);
-expand_one_var (var, true, true);
+next:
 if (DECL_ARTIFICIAL (var) && !DECL_IGNORED_P (var))
-{
+	{
-rtx rtl = DECL_RTL_IF_SET (var);
+	  rtx rtl = DECL_RTL_IF_SET (var);
-/* Keep artificial non-ignored vars in cfun->local_decls
+	  /* Keep artificial non-ignored vars in cfun->local_decls
-chain until instantiate_decls.  */
+	     chain until instantiate_decls.  */
-if (rtl && (MEM_P (rtl) || GET_CODE (rtl) == CONCAT))
+	  if (rtl && (MEM_P (rtl) || GET_CODE (rtl) == CONCAT))
-{
+	    add_local_decl (cfun, var);
-TREE_CHAIN (t) = cfun->local_decls;
+	  else if (rtl == NULL_RTX)
-cfun->local_decls = t;
+	    /* If rtl isn't set yet, which can happen e.g. with
-continue;
+	       -fstack-protector, retry before returning from this
-}
+	       function.  */
-}
+	    VEC_safe_push (tree, heap, maybe_local_decls, var);
-}
+	}
+}
-ggc_free (t);
-}
+/* We duplicated some of the decls in CFUN->LOCAL_DECLS.
++-----------------+-----------------+
+| ...processed... | ...duplicates...|
++-----------------+-----------------+
+^
+		       +-- LEN points here.
+We just want the duplicates, as those are the artificial
+non-ignored vars that we want to keep until instantiate_decls.
+Move them down and truncate the array.  */
+if (!VEC_empty (tree, cfun->local_decls))
+VEC_block_remove (tree, cfun->local_decls, 0, len);
 /* At this point, all variables within the block tree with TREE_USED
 set are actually used by the optimized function.  Lay them out.  */
 expand_used_vars_for_block (outer_block, true);
 expand_stack_vars (NULL);
 fini_vars_expansion ();
 }
+/* If there were any artificial non-ignored vars without rtl
+found earlier, see if deferred stack allocation hasn't assigned
+rtl to them.  */
+FOR_EACH_VEC_ELT_REVERSE (tree, maybe_local_decls, i, var)
+{
+rtx rtl = DECL_RTL_IF_SET (var);
+/* Keep artificial non-ignored vars in cfun->local_decls
+	 chain until instantiate_decls.  */
+if (rtl && (MEM_P (rtl) || GET_CODE (rtl) == CONCAT))
+	add_local_decl (cfun, var);
+}
+VEC_free (tree, heap, maybe_local_decls);
 /* If the target requires that FRAME_OFFSET be aligned, do it.  */
 if (STACK_ALIGNMENT_NEEDED)
 {
 HOST_WIDE_INT align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
 insn = PREV_INSN (get_last_insn ());
 /* Make sure we have an unconditional jump.  Otherwise we're
 confused.  */
 gcc_assert (JUMP_P (insn) && !any_condjump_p (insn));
 for (insn = PREV_INSN (insn); insn != last;)
-{
+	{
-insn = PREV_INSN (insn);
+	  insn = PREV_INSN (insn);
-if (JUMP_P (NEXT_INSN (insn)))
+	  if (JUMP_P (NEXT_INSN (insn)))
-delete_insn (NEXT_INSN (insn));
+	    {
-}
+	      if (!any_condjump_p (NEXT_INSN (insn)))
+		{
+		  gcc_assert (BARRIER_P (NEXT_INSN (NEXT_INSN (insn))));
+		  delete_insn (NEXT_INSN (NEXT_INSN (insn)));
+		}
+	      delete_insn (NEXT_INSN (insn));
+	    }
+	}
 }
 }
 /* A subroutine of expand_gimple_basic_block.  Expand one GIMPLE_COND.
 Returns a new basic block if we've terminated the current basic
 /* We can either have a pure conditional jump with one fallthru edge or
 two-way jump that needs to be decomposed into two basic blocks.  */
 if (false_edge->dest == bb->next_bb)
 {
-jumpif_1 (code, op0, op1, label_rtx_for_bb (true_edge->dest));
+jumpif_1 (code, op0, op1, label_rtx_for_bb (true_edge->dest),
-add_reg_br_prob_note (last, true_edge->probability);
+		true_edge->probability);
 maybe_dump_rtl_for_gimple_stmt (stmt, last);
 if (true_edge->goto_locus)
 {
 set_curr_insn_source_location (true_edge->goto_locus);
 set_curr_insn_block (true_edge->goto_block);
 maybe_cleanup_end_of_block (false_edge, last);
 return NULL;
 }
 if (true_edge->dest == bb->next_bb)
 {
-jumpifnot_1 (code, op0, op1, label_rtx_for_bb (false_edge->dest));
+jumpifnot_1 (code, op0, op1, label_rtx_for_bb (false_edge->dest),
-add_reg_br_prob_note (last, false_edge->probability);
+		   false_edge->probability);
 maybe_dump_rtl_for_gimple_stmt (stmt, last);
 if (false_edge->goto_locus)
 {
 set_curr_insn_source_location (false_edge->goto_locus);
 set_curr_insn_block (false_edge->goto_block);
 true_edge->flags |= EDGE_FALLTHRU;
 maybe_cleanup_end_of_block (true_edge, last);
 return NULL;
 }
-jumpif_1 (code, op0, op1, label_rtx_for_bb (true_edge->dest));
+jumpif_1 (code, op0, op1, label_rtx_for_bb (true_edge->dest),
-add_reg_br_prob_note (last, true_edge->probability);
+	    true_edge->probability);
 last = get_last_insn ();
 if (false_edge->goto_locus)
 {
 set_curr_insn_source_location (false_edge->goto_locus);
 set_curr_insn_block (false_edge->goto_block);
 expand_call_stmt (gimple stmt)
 {
 tree exp;
 tree lhs = gimple_call_lhs (stmt);
 size_t i;
+bool builtin_p;
+tree decl;
 exp = build_vl_exp (CALL_EXPR, gimple_call_num_args (stmt) + 3);
 CALL_EXPR_FN (exp) = gimple_call_fn (stmt);
+decl = gimple_call_fndecl (stmt);
+builtin_p = decl && DECL_BUILT_IN (decl);
 TREE_TYPE (exp) = gimple_call_return_type (stmt);
 CALL_EXPR_STATIC_CHAIN (exp) = gimple_call_chain (stmt);
 for (i = 0; i < gimple_call_num_args (stmt); i++)
-CALL_EXPR_ARG (exp, i) = gimple_call_arg (stmt, i);
+{
+tree arg = gimple_call_arg (stmt, i);
+gimple def;
+/* TER addresses into arguments of builtin functions so we have a
+	 chance to infer more correct alignment information.  See PR39954.  */
+if (builtin_p
+	  && TREE_CODE (arg) == SSA_NAME
+	  && (def = get_gimple_for_ssa_name (arg))
+	  && gimple_assign_rhs_code (def) == ADDR_EXPR)
+	arg = gimple_assign_rhs1 (def);
+CALL_EXPR_ARG (exp, i) = arg;
+}
 if (gimple_has_side_effects (stmt))
 TREE_SIDE_EFFECTS (exp) = 1;
 if (gimple_call_nothrow_p (stmt))
 expand_return (op0);
 break;
 case GIMPLE_ASSIGN:
 {
-tree lhs = gimple_assign_lhs (stmt);
+	tree lhs = gimple_assign_lhs (stmt);
-/* Tree expand used to fiddle with |= and &= of two bitfield
+	/* Tree expand used to fiddle with |= and &= of two bitfield
-COMPONENT_REFs here.  This can't happen with gimple, the LHS
+	   COMPONENT_REFs here.  This can't happen with gimple, the LHS
-of binary assigns must be a gimple reg.  */
+	   of binary assigns must be a gimple reg.  */
-if (TREE_CODE (lhs) != SSA_NAME
+	if (TREE_CODE (lhs) != SSA_NAME
-|| get_gimple_rhs_class (gimple_expr_code (stmt))
+	    || get_gimple_rhs_class (gimple_expr_code (stmt))
-== GIMPLE_SINGLE_RHS)
+	       == GIMPLE_SINGLE_RHS)
-{
+	  {
-tree rhs = gimple_assign_rhs1 (stmt);
+	    tree rhs = gimple_assign_rhs1 (stmt);
-gcc_assert (get_gimple_rhs_class (gimple_expr_code (stmt))
+	    gcc_assert (get_gimple_rhs_class (gimple_expr_code (stmt))
-== GIMPLE_SINGLE_RHS);
+			== GIMPLE_SINGLE_RHS);
-if (gimple_has_location (stmt) && CAN_HAVE_LOCATION_P (rhs))
+	    if (gimple_has_location (stmt) && CAN_HAVE_LOCATION_P (rhs))
-SET_EXPR_LOCATION (rhs, gimple_location (stmt));
+	      SET_EXPR_LOCATION (rhs, gimple_location (stmt));
-expand_assignment (lhs, rhs,
+	    expand_assignment (lhs, rhs,
-gimple_assign_nontemporal_move_p (stmt));
+			       gimple_assign_nontemporal_move_p (stmt));
-}
+	  }
-else
+	else
-{
+	  {
-rtx target, temp;
+	    rtx target, temp;
-bool nontemporal = gimple_assign_nontemporal_move_p (stmt);
+	    bool nontemporal = gimple_assign_nontemporal_move_p (stmt);
-struct separate_ops ops;
+	    struct separate_ops ops;
-bool promoted = false;
+	    bool promoted = false;
-target = expand_expr (lhs, NULL_RTX, VOIDmode, EXPAND_WRITE);
+	    target = expand_expr (lhs, NULL_RTX, VOIDmode, EXPAND_WRITE);
-if (GET_CODE (target) == SUBREG && SUBREG_PROMOTED_VAR_P (target))
+	    if (GET_CODE (target) == SUBREG && SUBREG_PROMOTED_VAR_P (target))
-promoted = true;
+	      promoted = true;
-ops.code = gimple_assign_rhs_code (stmt);
+	    ops.code = gimple_assign_rhs_code (stmt);
-ops.type = TREE_TYPE (lhs);
+	    ops.type = TREE_TYPE (lhs);
-switch (get_gimple_rhs_class (gimple_expr_code (stmt)))
+	    switch (get_gimple_rhs_class (gimple_expr_code (stmt)))
-{
+	      {
-case GIMPLE_BINARY_RHS:
+		case GIMPLE_TERNARY_RHS:
-ops.op1 = gimple_assign_rhs2 (stmt);
+		  ops.op2 = gimple_assign_rhs3 (stmt);
-/* Fallthru */
+		  /* Fallthru */
-case GIMPLE_UNARY_RHS:
+		case GIMPLE_BINARY_RHS:
-ops.op0 = gimple_assign_rhs1 (stmt);
+		  ops.op1 = gimple_assign_rhs2 (stmt);
-break;
+		  /* Fallthru */
-default:
+		case GIMPLE_UNARY_RHS:
-gcc_unreachable ();
+		  ops.op0 = gimple_assign_rhs1 (stmt);
-}
+		  break;
-ops.location = gimple_location (stmt);
+		default:
+		  gcc_unreachable ();
-/* If we want to use a nontemporal store, force the value to
+	      }
-register first.  If we store into a promoted register,
+	    ops.location = gimple_location (stmt);
-don't directly expand to target.  */
-temp = nontemporal || promoted ? NULL_RTX : target;
+	    /* If we want to use a nontemporal store, force the value to
-temp = expand_expr_real_2 (&ops, temp, GET_MODE (target),
+	       register first.  If we store into a promoted register,
-EXPAND_NORMAL);
+	       don't directly expand to target.  */
+	    temp = nontemporal || promoted ? NULL_RTX : target;
-if (temp == target)
+	    temp = expand_expr_real_2 (&ops, temp, GET_MODE (target),
-;
+				       EXPAND_NORMAL);
-else if (promoted)
-{
+	    if (temp == target)
-int unsignedp = SUBREG_PROMOTED_UNSIGNED_P (target);
+	      ;
-/* If TEMP is a VOIDmode constant, use convert_modes to make
+	    else if (promoted)
-sure that we properly convert it.  */
+	      {
-if (CONSTANT_P (temp) && GET_MODE (temp) == VOIDmode)
+		int unsignedp = SUBREG_PROMOTED_UNSIGNED_P (target);
-{
+		/* If TEMP is a VOIDmode constant, use convert_modes to make
-temp = convert_modes (GET_MODE (target),
+		   sure that we properly convert it.  */
-TYPE_MODE (ops.type),
+		if (CONSTANT_P (temp) && GET_MODE (temp) == VOIDmode)
-temp, unsignedp);
+		  {
-temp = convert_modes (GET_MODE (SUBREG_REG (target)),
+		    temp = convert_modes (GET_MODE (target),
-GET_MODE (target), temp, unsignedp);
+					  TYPE_MODE (ops.type),
-}
+					  temp, unsignedp);
+		    temp = convert_modes (GET_MODE (SUBREG_REG (target)),
-convert_move (SUBREG_REG (target), temp, unsignedp);
+					  GET_MODE (target), temp, unsignedp);
-}
+		  }
-else if (nontemporal && emit_storent_insn (target, temp))
-;
+		convert_move (SUBREG_REG (target), temp, unsignedp);
-else
+	      }
-{
+	    else if (nontemporal && emit_storent_insn (target, temp))
-temp = force_operand (temp, target);
+	      ;
-if (temp != target)
+	    else
-emit_move_insn (target, temp);
+	      {
-}
+		temp = force_operand (temp, target);
-}
+		if (temp != target)
+		  emit_move_insn (target, temp);
+	      }
+	  }
 }
 break;
 default:
 gcc_unreachable ();
 /* Convert X to MODE, that must be Pmode or ptr_mode, without emitting
 any rtl.  */
 static rtx
-convert_debug_memory_address (enum machine_mode mode, rtx x)
+convert_debug_memory_address (enum machine_mode mode, rtx x,
+			      addr_space_t as)
 {
 enum machine_mode xmode = GET_MODE (x);
 #ifndef POINTERS_EXTEND_UNSIGNED
-gcc_assert (mode == Pmode);
+gcc_assert (mode == Pmode
+	      || mode == targetm.addr_space.address_mode (as));
 gcc_assert (xmode == mode || xmode == VOIDmode);
 #else
-gcc_assert (mode == Pmode || mode == ptr_mode);
+rtx temp;
+enum machine_mode address_mode = targetm.addr_space.address_mode (as);
+enum machine_mode pointer_mode = targetm.addr_space.pointer_mode (as);
+gcc_assert (mode == address_mode || mode == pointer_mode);
 if (GET_MODE (x) == mode || GET_MODE (x) == VOIDmode)
 return x;
 if (GET_MODE_BITSIZE (mode) < GET_MODE_BITSIZE (xmode))
 else if (POINTERS_EXTEND_UNSIGNED > 0)
 x = gen_rtx_ZERO_EXTEND (mode, x);
 else if (!POINTERS_EXTEND_UNSIGNED)
 x = gen_rtx_SIGN_EXTEND (mode, x);
 else
-gcc_unreachable ();
+{
+switch (GET_CODE (x))
+	{
+	case SUBREG:
+	  if ((SUBREG_PROMOTED_VAR_P (x)
+	       || (REG_P (SUBREG_REG (x)) && REG_POINTER (SUBREG_REG (x)))
+	       || (GET_CODE (SUBREG_REG (x)) == PLUS
+		   && REG_P (XEXP (SUBREG_REG (x), 0))
+		   && REG_POINTER (XEXP (SUBREG_REG (x), 0))
+		   && CONST_INT_P (XEXP (SUBREG_REG (x), 1))))
+	      && GET_MODE (SUBREG_REG (x)) == mode)
+	    return SUBREG_REG (x);
+	  break;
+	case LABEL_REF:
+	  temp = gen_rtx_LABEL_REF (mode, XEXP (x, 0));
+	  LABEL_REF_NONLOCAL_P (temp) = LABEL_REF_NONLOCAL_P (x);
+	  return temp;
+	case SYMBOL_REF:
+	  temp = shallow_copy_rtx (x);
+	  PUT_MODE (temp, mode);
+	  return temp;
+	case CONST:
+	  temp = convert_debug_memory_address (mode, XEXP (x, 0), as);
+	  if (temp)
+	    temp = gen_rtx_CONST (mode, temp);
+	  return temp;
+	case PLUS:
+	case MINUS:
+	  if (CONST_INT_P (XEXP (x, 1)))
+	    {
+	      temp = convert_debug_memory_address (mode, XEXP (x, 0), as);
+	      if (temp)
+		return gen_rtx_fmt_ee (GET_CODE (x), mode, temp, XEXP (x, 1));
+	    }
+	  break;
+	default:
+	  break;
+	}
+/* Don't know how to express ptr_extend as operation in debug info.  */
+return NULL;
+}
 #endif /* POINTERS_EXTEND_UNSIGNED */
 return x;
 }
 {
 rtx op0 = NULL_RTX, op1 = NULL_RTX, op2 = NULL_RTX;
 enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
 int unsignedp = TYPE_UNSIGNED (TREE_TYPE (exp));
 addr_space_t as;
-enum machine_mode address_mode;
 switch (TREE_CODE_CLASS (TREE_CODE (exp)))
 {
 case tcc_expression:
 switch (TREE_CODE (exp))
-{
+	{
-case COND_EXPR:
+	case COND_EXPR:
-goto ternary;
+	case DOT_PROD_EXPR:
+	case WIDEN_MULT_PLUS_EXPR:
-case TRUTH_ANDIF_EXPR:
+	case WIDEN_MULT_MINUS_EXPR:
-case TRUTH_ORIF_EXPR:
+	case FMA_EXPR:
-case TRUTH_AND_EXPR:
+	  goto ternary;
-case TRUTH_OR_EXPR:
-case TRUTH_XOR_EXPR:
+	case TRUTH_ANDIF_EXPR:
-goto binary;
+	case TRUTH_ORIF_EXPR:
+	case TRUTH_AND_EXPR:
-case TRUTH_NOT_EXPR:
+	case TRUTH_OR_EXPR:
-goto unary;
+	case TRUTH_XOR_EXPR:
+	  goto binary;
-default:
-break;
+	case TRUTH_NOT_EXPR:
-}
+	  goto unary;
+	default:
+	  break;
+	}
 break;
 ternary:
 op2 = expand_debug_expr (TREE_OPERAND (exp, 2));
 if (!op2)
 case RESULT_DECL:
 op0 = DECL_RTL_IF_SET (exp);
 /* This decl was probably optimized away.  */
 if (!op0)
-{
+	{
-if (TREE_CODE (exp) != VAR_DECL
+	  if (TREE_CODE (exp) != VAR_DECL
-|| DECL_EXTERNAL (exp)
+	      || DECL_EXTERNAL (exp)
-|| !TREE_STATIC (exp)
+	      || !TREE_STATIC (exp)
-|| !DECL_NAME (exp)
+	      || !DECL_NAME (exp)
-|| DECL_HARD_REGISTER (exp)
+	      || DECL_HARD_REGISTER (exp)
-|| mode == VOIDmode)
+	      || mode == VOIDmode)
-return NULL;
+	    return NULL;
-op0 = DECL_RTL (exp);
+	  op0 = make_decl_rtl_for_debug (exp);
-SET_DECL_RTL (exp, NULL);
+	  if (!MEM_P (op0)
-if (!MEM_P (op0)
+	      || GET_CODE (XEXP (op0, 0)) != SYMBOL_REF
-|| GET_CODE (XEXP (op0, 0)) != SYMBOL_REF
+	      || SYMBOL_REF_DECL (XEXP (op0, 0)) != exp)
-|| SYMBOL_REF_DECL (XEXP (op0, 0)) != exp)
+	    return NULL;
-return NULL;
+	}
-}
 else
 op0 = copy_rtx (op0);
-if (GET_MODE (op0) == BLKmode)
+if (GET_MODE (op0) == BLKmode
-{
+	  /* If op0 is not BLKmode, but BLKmode is, adjust_mode
-gcc_assert (MEM_P (op0));
+	     below would ICE.  While it is likely a FE bug,
-op0 = adjust_address_nv (op0, mode, 0);
+	     try to be robust here.  See PR43166.  */
-return op0;
+	  || mode == BLKmode
-}
+	  || (mode == VOIDmode && GET_MODE (op0) != VOIDmode))
+	{
+	  gcc_assert (MEM_P (op0));
+	  op0 = adjust_address_nv (op0, mode, 0);
+	  return op0;
+	}
 /* Fall through.  */
 adjust_mode:
 case PAREN_EXPR:
 case NOP_EXPR:
 case CONVERT_EXPR:
 {
-enum machine_mode inner_mode = GET_MODE (op0);
+	enum machine_mode inner_mode = GET_MODE (op0);
-if (mode == inner_mode)
+	if (mode == inner_mode)
-return op0;
+	  return op0;
-if (inner_mode == VOIDmode)
+	if (inner_mode == VOIDmode)
-{
+	  {
-inner_mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
+	    if (TREE_CODE (exp) == SSA_NAME)
-if (mode == inner_mode)
+	      inner_mode = TYPE_MODE (TREE_TYPE (exp));
-return op0;
+	    else
+	      inner_mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
+	    if (mode == inner_mode)
+	      return op0;
+	  }
+	if (FLOAT_MODE_P (mode) && FLOAT_MODE_P (inner_mode))
+	  {
+	    if (GET_MODE_BITSIZE (mode) == GET_MODE_BITSIZE (inner_mode))
+	      op0 = simplify_gen_subreg (mode, op0, inner_mode, 0);
+	    else if (GET_MODE_BITSIZE (mode) < GET_MODE_BITSIZE (inner_mode))
+	      op0 = simplify_gen_unary (FLOAT_TRUNCATE, mode, op0, inner_mode);
+	    else
+	      op0 = simplify_gen_unary (FLOAT_EXTEND, mode, op0, inner_mode);
+	  }
+	else if (FLOAT_MODE_P (mode))
+	  {
+	    gcc_assert (TREE_CODE (exp) != SSA_NAME);
+	    if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))))
+	      op0 = simplify_gen_unary (UNSIGNED_FLOAT, mode, op0, inner_mode);
+	    else
+	      op0 = simplify_gen_unary (FLOAT, mode, op0, inner_mode);
+	  }
+	else if (FLOAT_MODE_P (inner_mode))
+	  {
+	    if (unsignedp)
+	      op0 = simplify_gen_unary (UNSIGNED_FIX, mode, op0, inner_mode);
+	    else
+	      op0 = simplify_gen_unary (FIX, mode, op0, inner_mode);
+	  }
+	else if (CONSTANT_P (op0)
+		 || GET_MODE_BITSIZE (mode) <= GET_MODE_BITSIZE (inner_mode))
+	  op0 = simplify_gen_subreg (mode, op0, inner_mode,
+				     subreg_lowpart_offset (mode,
+							    inner_mode));
+	else if (TREE_CODE_CLASS (TREE_CODE (exp)) == tcc_unary
+		 ? TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0)))
+		 : unsignedp)
+	  op0 = gen_rtx_ZERO_EXTEND (mode, op0);
+	else
+	  op0 = gen_rtx_SIGN_EXTEND (mode, op0);
+	return op0;
 }
-if (FLOAT_MODE_P (mode) && FLOAT_MODE_P (inner_mode))
+case MEM_REF:
-{
+if (!is_gimple_mem_ref_addr (TREE_OPERAND (exp, 0)))
-if (GET_MODE_BITSIZE (mode) == GET_MODE_BITSIZE (inner_mode))
+	{
-op0 = simplify_gen_subreg (mode, op0, inner_mode, 0);
+	  tree newexp = fold_binary (MEM_REF, TREE_TYPE (exp),
-else if (GET_MODE_BITSIZE (mode) < GET_MODE_BITSIZE (inner_mode))
+				     TREE_OPERAND (exp, 0),
-op0 = simplify_gen_unary (FLOAT_TRUNCATE, mode, op0, inner_mode);
+				     TREE_OPERAND (exp, 1));
-else
+	  if (newexp)
-op0 = simplify_gen_unary (FLOAT_EXTEND, mode, op0, inner_mode);
+	    return expand_debug_expr (newexp);
-}
+	}
-else if (FLOAT_MODE_P (mode))
+/* FALLTHROUGH */
-{
-if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))))
-op0 = simplify_gen_unary (UNSIGNED_FLOAT, mode, op0, inner_mode);
-else
-op0 = simplify_gen_unary (FLOAT, mode, op0, inner_mode);
-}
-else if (FLOAT_MODE_P (inner_mode))
-{
-if (unsignedp)
-op0 = simplify_gen_unary (UNSIGNED_FIX, mode, op0, inner_mode);
-else
-op0 = simplify_gen_unary (FIX, mode, op0, inner_mode);
-}
-else if (CONSTANT_P (op0)
-|| GET_MODE_BITSIZE (mode) <= GET_MODE_BITSIZE (inner_mode))
-op0 = simplify_gen_subreg (mode, op0, inner_mode,
-subreg_lowpart_offset (mode,
-inner_mode));
-else if (unsignedp)
-op0 = gen_rtx_ZERO_EXTEND (mode, op0);
-else
-op0 = gen_rtx_SIGN_EXTEND (mode, op0);
-return op0;
-}
 case INDIRECT_REF:
-case ALIGN_INDIRECT_REF:
-case MISALIGNED_INDIRECT_REF:
 op0 = expand_debug_expr (TREE_OPERAND (exp, 0));
 if (!op0)
 return NULL;
+if (TREE_CODE (exp) == MEM_REF)
+	{
+	  if (GET_CODE (op0) == DEBUG_IMPLICIT_PTR
+	      || (GET_CODE (op0) == PLUS
+		  && GET_CODE (XEXP (op0, 0)) == DEBUG_IMPLICIT_PTR))
+	    /* (mem (debug_implicit_ptr)) might confuse aliasing.
+	       Instead just use get_inner_reference.  */
+	    goto component_ref;
+	  op1 = expand_debug_expr (TREE_OPERAND (exp, 1));
+	  if (!op1 || !CONST_INT_P (op1))
+	    return NULL;
+	  op0 = plus_constant (op0, INTVAL (op1));
+	}
 if (POINTER_TYPE_P (TREE_TYPE (exp)))
-{
+	as = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp)));
-as = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp)));
-address_mode = targetm.addr_space.address_mode (as);
-}
 else
-{
+	as = ADDR_SPACE_GENERIC;
-as = ADDR_SPACE_GENERIC;
-address_mode = Pmode;
+op0 = convert_debug_memory_address (targetm.addr_space.address_mode (as),
-}
+					  op0, as);
+if (op0 == NULL_RTX)
-if (TREE_CODE (exp) == ALIGN_INDIRECT_REF)
+	return NULL;
-{
-int align = TYPE_ALIGN_UNIT (TREE_TYPE (exp));
-op0 = gen_rtx_AND (address_mode, op0, GEN_INT (-align));
-}
 op0 = gen_rtx_MEM (mode, op0);
 set_mem_attributes (op0, exp, 0);
+if (TREE_CODE (exp) == MEM_REF
+	  && !is_gimple_mem_ref_addr (TREE_OPERAND (exp, 0)))
+	set_mem_expr (op0, NULL_TREE);
 set_mem_addr_space (op0, as);
 return op0;
 case TARGET_MEM_REF:
-if (TMR_SYMBOL (exp) && !DECL_RTL_SET_P (TMR_SYMBOL (exp)))
+if (TREE_CODE (TMR_BASE (exp)) == ADDR_EXPR
-return NULL;
+	  && !DECL_RTL_SET_P (TREE_OPERAND (TMR_BASE (exp), 0)))
+	return NULL;
 op0 = expand_debug_expr
 (tree_mem_ref_addr (build_pointer_type (TREE_TYPE (exp)), exp));
 if (!op0)
 return NULL;
-as = TYPE_ADDR_SPACE (TREE_TYPE (exp));
+if (POINTER_TYPE_P (TREE_TYPE (exp)))
+	as = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp)));
+else
+	as = ADDR_SPACE_GENERIC;
+op0 = convert_debug_memory_address (targetm.addr_space.address_mode (as),
+					  op0, as);
+if (op0 == NULL_RTX)
+	return NULL;
 op0 = gen_rtx_MEM (mode, op0);
 set_mem_attributes (op0, exp, 0);
 set_mem_addr_space (op0, as);
 return op0;
+component_ref:
 case ARRAY_REF:
 case ARRAY_RANGE_REF:
 case COMPONENT_REF:
 case BIT_FIELD_REF:
 case REALPART_EXPR:
 case IMAGPART_EXPR:
 case VIEW_CONVERT_EXPR:
 {
-enum machine_mode mode1;
+	enum machine_mode mode1;
-HOST_WIDE_INT bitsize, bitpos;
+	HOST_WIDE_INT bitsize, bitpos;
-tree offset;
+	tree offset;
-int volatilep = 0;
+	int volatilep = 0;
-tree tem = get_inner_reference (exp, &bitsize, &bitpos, &offset,
+	tree tem = get_inner_reference (exp, &bitsize, &bitpos, &offset,
-&mode1, &unsignedp, &volatilep, false);
+					&mode1, &unsignedp, &volatilep, false);
-rtx orig_op0;
+	rtx orig_op0;
-if (bitsize == 0)
+	if (bitsize == 0)
-return NULL;
+	  return NULL;
-orig_op0 = op0 = expand_debug_expr (tem);
+	orig_op0 = op0 = expand_debug_expr (tem);
-if (!op0)
+	if (!op0)
-return NULL;
+	  return NULL;
-if (offset)
+	if (offset)
-{
+	  {
-enum machine_mode addrmode, offmode;
+	    enum machine_mode addrmode, offmode;
-gcc_assert (MEM_P (op0));
+	    if (!MEM_P (op0))
+	      return NULL;
-op0 = XEXP (op0, 0);
-addrmode = GET_MODE (op0);
+	    op0 = XEXP (op0, 0);
-if (addrmode == VOIDmode)
+	    addrmode = GET_MODE (op0);
-addrmode = Pmode;
+	    if (addrmode == VOIDmode)
+	      addrmode = Pmode;
-op1 = expand_debug_expr (offset);
-if (!op1)
+	    op1 = expand_debug_expr (offset);
-return NULL;
+	    if (!op1)
+	      return NULL;
-offmode = GET_MODE (op1);
-if (offmode == VOIDmode)
+	    offmode = GET_MODE (op1);
-offmode = TYPE_MODE (TREE_TYPE (offset));
+	    if (offmode == VOIDmode)
+	      offmode = TYPE_MODE (TREE_TYPE (offset));
-if (addrmode != offmode)
-op1 = simplify_gen_subreg (addrmode, op1, offmode,
+	    if (addrmode != offmode)
-subreg_lowpart_offset (addrmode,
+	      op1 = simplify_gen_subreg (addrmode, op1, offmode,
-offmode));
+					 subreg_lowpart_offset (addrmode,
+								offmode));
-/* Don't use offset_address here, we don't need a
-recognizable address, and we don't want to generate
+	    /* Don't use offset_address here, we don't need a
-code.  */
+	       recognizable address, and we don't want to generate
-op0 = gen_rtx_MEM (mode, gen_rtx_PLUS (addrmode, op0, op1));
+	       code.  */
-}
+	    op0 = gen_rtx_MEM (mode, gen_rtx_PLUS (addrmode, op0, op1));
+	  }
-if (MEM_P (op0))
-{
+	if (MEM_P (op0))
-if (mode1 == VOIDmode)
+	  {
-/* Bitfield.  */
+	    if (mode1 == VOIDmode)
-mode1 = smallest_mode_for_size (bitsize, MODE_INT);
+	      /* Bitfield.  */
-if (bitpos >= BITS_PER_UNIT)
+	      mode1 = smallest_mode_for_size (bitsize, MODE_INT);
-{
+	    if (bitpos >= BITS_PER_UNIT)
-op0 = adjust_address_nv (op0, mode1, bitpos / BITS_PER_UNIT);
+	      {
-bitpos %= BITS_PER_UNIT;
+		op0 = adjust_address_nv (op0, mode1, bitpos / BITS_PER_UNIT);
-}
+		bitpos %= BITS_PER_UNIT;
-else if (bitpos < 0)
+	      }
-{
+	    else if (bitpos < 0)
-HOST_WIDE_INT units
+	      {
-= (-bitpos + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
+		HOST_WIDE_INT units
-op0 = adjust_address_nv (op0, mode1, units);
+		  = (-bitpos + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
-bitpos += units * BITS_PER_UNIT;
+		op0 = adjust_address_nv (op0, mode1, units);
-}
+		bitpos += units * BITS_PER_UNIT;
-else if (bitpos == 0 && bitsize == GET_MODE_BITSIZE (mode))
+	      }
-op0 = adjust_address_nv (op0, mode, 0);
+	    else if (bitpos == 0 && bitsize == GET_MODE_BITSIZE (mode))
-else if (GET_MODE (op0) != mode1)
+	      op0 = adjust_address_nv (op0, mode, 0);
-op0 = adjust_address_nv (op0, mode1, 0);
+	    else if (GET_MODE (op0) != mode1)
-else
+	      op0 = adjust_address_nv (op0, mode1, 0);
-op0 = copy_rtx (op0);
+	    else
-if (op0 == orig_op0)
+	      op0 = copy_rtx (op0);
-op0 = shallow_copy_rtx (op0);
+	    if (op0 == orig_op0)
-set_mem_attributes (op0, exp, 0);
+	      op0 = shallow_copy_rtx (op0);
-}
+	    set_mem_attributes (op0, exp, 0);
+	  }
-if (bitpos == 0 && mode == GET_MODE (op0))
-return op0;
+	if (bitpos == 0 && mode == GET_MODE (op0))
+	  return op0;
 if (bitpos < 0)
 return NULL;
-if ((bitpos % BITS_PER_UNIT) == 0
+	if (GET_MODE (op0) == BLKmode)
-&& bitsize == GET_MODE_BITSIZE (mode1))
+	  return NULL;
-{
-enum machine_mode opmode = GET_MODE (op0);
+	if ((bitpos % BITS_PER_UNIT) == 0
+	    && bitsize == GET_MODE_BITSIZE (mode1))
-gcc_assert (opmode != BLKmode);
+	  {
+	    enum machine_mode opmode = GET_MODE (op0);
-if (opmode == VOIDmode)
-opmode = mode1;
+	    if (opmode == VOIDmode)
+	      opmode = TYPE_MODE (TREE_TYPE (tem));
-/* This condition may hold if we're expanding the address
-right past the end of an array that turned out not to
+	    /* This condition may hold if we're expanding the address
-be addressable (i.e., the address was only computed in
+	       right past the end of an array that turned out not to
-debug stmts).  The gen_subreg below would rightfully
+	       be addressable (i.e., the address was only computed in
-crash, and the address doesn't really exist, so just
+	       debug stmts).  The gen_subreg below would rightfully
-drop it.  */
+	       crash, and the address doesn't really exist, so just
-if (bitpos >= GET_MODE_BITSIZE (opmode))
+	       drop it.  */
-return NULL;
+	    if (bitpos >= GET_MODE_BITSIZE (opmode))
+	      return NULL;
-return simplify_gen_subreg (mode, op0, opmode,
-bitpos / BITS_PER_UNIT);
+	    if ((bitpos % GET_MODE_BITSIZE (mode)) == 0)
-}
+	      return simplify_gen_subreg (mode, op0, opmode,
+					  bitpos / BITS_PER_UNIT);
-return simplify_gen_ternary (SCALAR_INT_MODE_P (GET_MODE (op0))
+	  }
-&& TYPE_UNSIGNED (TREE_TYPE (exp))
-? SIGN_EXTRACT
+	return simplify_gen_ternary (SCALAR_INT_MODE_P (GET_MODE (op0))
-: ZERO_EXTRACT, mode,
+				     && TYPE_UNSIGNED (TREE_TYPE (exp))
-GET_MODE (op0) != VOIDmode
+				     ? SIGN_EXTRACT
-? GET_MODE (op0) : mode1,
+				     : ZERO_EXTRACT, mode,
-op0, GEN_INT (bitsize), GEN_INT (bitpos));
+				     GET_MODE (op0) != VOIDmode
+				     ? GET_MODE (op0)
+				     : TYPE_MODE (TREE_TYPE (tem)),
+				     op0, GEN_INT (bitsize), GEN_INT (bitpos));
 }
 case ABS_EXPR:
 return gen_rtx_ABS (mode, op0);
 return gen_rtx_UNSIGNED_FIX (mode, op0);
 else
 return gen_rtx_FIX (mode, op0);
 case POINTER_PLUS_EXPR:
+/* For the rare target where pointers are not the same size as
+	 size_t, we need to check for mis-matched modes and correct
+	 the addend.  */
+if (op0 && op1
+	  && GET_MODE (op0) != VOIDmode && GET_MODE (op1) != VOIDmode
+	  && GET_MODE (op0) != GET_MODE (op1))
+	{
+	  if (GET_MODE_BITSIZE (GET_MODE (op0)) < GET_MODE_BITSIZE (GET_MODE (op1)))
+	    op1 = gen_rtx_TRUNCATE (GET_MODE (op0), op1);
+	  else
+	    /* We always sign-extend, regardless of the signedness of
+	       the operand, because the operand is always unsigned
+	       here even if the original C expression is signed.  */
+	    op1 = gen_rtx_SIGN_EXTEND (GET_MODE (op0), op1);
+	}
+/* Fall through.  */
 case PLUS_EXPR:
 return gen_rtx_PLUS (mode, op0, op1);
 case MINUS_EXPR:
 return gen_rtx_MINUS (mode, op0, op1);
 }
 case ADDR_EXPR:
 op0 = expand_debug_expr (TREE_OPERAND (exp, 0));
 if (!op0 || !MEM_P (op0))
-return NULL;
+	{
+	  if ((TREE_CODE (TREE_OPERAND (exp, 0)) == VAR_DECL
-op0 = convert_debug_memory_address (mode, XEXP (op0, 0));
+	       || TREE_CODE (TREE_OPERAND (exp, 0)) == PARM_DECL
+	       || TREE_CODE (TREE_OPERAND (exp, 0)) == RESULT_DECL)
+	      && !TREE_ADDRESSABLE (TREE_OPERAND (exp, 0)))
+	    return gen_rtx_DEBUG_IMPLICIT_PTR (mode, TREE_OPERAND (exp, 0));
+	  if (handled_component_p (TREE_OPERAND (exp, 0)))
+	    {
+	      HOST_WIDE_INT bitoffset, bitsize, maxsize;
+	      tree decl
+		= get_ref_base_and_extent (TREE_OPERAND (exp, 0),
+					   &bitoffset, &bitsize, &maxsize);
+	      if ((TREE_CODE (decl) == VAR_DECL
+		   || TREE_CODE (decl) == PARM_DECL
+		   || TREE_CODE (decl) == RESULT_DECL)
+		  && !TREE_ADDRESSABLE (decl)
+		  && (bitoffset % BITS_PER_UNIT) == 0
+		  && bitsize > 0
+		  && bitsize == maxsize)
+		return plus_constant (gen_rtx_DEBUG_IMPLICIT_PTR (mode, decl),
+				      bitoffset / BITS_PER_UNIT);
+	    }
+	  return NULL;
+	}
+as = TYPE_ADDR_SPACE (TREE_TYPE (exp));
+op0 = convert_debug_memory_address (mode, XEXP (op0, 0), as);
 return op0;
 case VECTOR_CST:
 exp = build_constructor_from_list (TREE_TYPE (exp),
 TREE_VECTOR_CST_ELTS (exp));
 /* Fall through.  */
 case CONSTRUCTOR:
 if (TREE_CODE (TREE_TYPE (exp)) == VECTOR_TYPE)
-{
+	{
-unsigned i;
+	  unsigned i;
-tree val;
+	  tree val;
-op0 = gen_rtx_CONCATN
+	  op0 = gen_rtx_CONCATN
-(mode, rtvec_alloc (TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp))));
+	    (mode, rtvec_alloc (TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp))));
-FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp), i, val)
+	  FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp), i, val)
-{
+	    {
-op1 = expand_debug_expr (val);
+	      op1 = expand_debug_expr (val);
-if (!op1)
+	      if (!op1)
-return NULL;
+		return NULL;
-XVECEXP (op0, 0, i) = op1;
+	      XVECEXP (op0, 0, i) = op1;
-}
+	    }
-if (i < TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp)))
+	  if (i < TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp)))
-{
+	    {
-op1 = expand_debug_expr
+	      op1 = expand_debug_expr
-(fold_convert (TREE_TYPE (TREE_TYPE (exp)), integer_zero_node));
+		(build_zero_cst (TREE_TYPE (TREE_TYPE (exp))));
-if (!op1)
+	      if (!op1)
-return NULL;
+		return NULL;
-for (; i < TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp)); i++)
+	      for (; i < TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp)); i++)
-XVECEXP (op0, 0, i) = op1;
+		XVECEXP (op0, 0, i) = op1;
-}
+	    }
-return op0;
+	  return op0;
-}
+	}
 else
 goto flag_unsupported;
 case CALL_EXPR:
 /* ??? Maybe handle some builtins?  */
 return NULL;
 case SSA_NAME:
 {
-int part = var_to_partition (SA.map, exp);
+	gimple g = get_gimple_for_ssa_name (exp);
+	if (g)
-if (part == NO_PARTITION)
+	  {
-return NULL;
+	    op0 = expand_debug_expr (gimple_assign_rhs_to_tree (g));
+	    if (!op0)
-gcc_assert (part >= 0 && (unsigned)part < SA.map->num_partitions);
+	      return NULL;
+	  }
-op0 = SA.partition_to_pseudo[part];
+	else
-goto adjust_mode;
+	  {
+	    int part = var_to_partition (SA.map, exp);
+	    if (part == NO_PARTITION)
+	      return NULL;
+	    gcc_assert (part >= 0 && (unsigned)part < SA.map->num_partitions);
+	    op0 = copy_rtx (SA.partition_to_pseudo[part]);
+	  }
+	goto adjust_mode;
 }
 case ERROR_MARK:
 return NULL;
+/* Vector stuff.  For most of the codes we don't have rtl codes.  */
+case REALIGN_LOAD_EXPR:
+case REDUC_MAX_EXPR:
+case REDUC_MIN_EXPR:
+case REDUC_PLUS_EXPR:
+case VEC_COND_EXPR:
+case VEC_EXTRACT_EVEN_EXPR:
+case VEC_EXTRACT_ODD_EXPR:
+case VEC_INTERLEAVE_HIGH_EXPR:
+case VEC_INTERLEAVE_LOW_EXPR:
+case VEC_LSHIFT_EXPR:
+case VEC_PACK_FIX_TRUNC_EXPR:
+case VEC_PACK_SAT_EXPR:
+case VEC_PACK_TRUNC_EXPR:
+case VEC_RSHIFT_EXPR:
+case VEC_UNPACK_FLOAT_HI_EXPR:
+case VEC_UNPACK_FLOAT_LO_EXPR:
+case VEC_UNPACK_HI_EXPR:
+case VEC_UNPACK_LO_EXPR:
+case VEC_WIDEN_MULT_HI_EXPR:
+case VEC_WIDEN_MULT_LO_EXPR:
+return NULL;
+/* Misc codes.  */
+case ADDR_SPACE_CONVERT_EXPR:
+case FIXED_CONVERT_EXPR:
+case OBJ_TYPE_REF:
+case WITH_SIZE_EXPR:
+return NULL;
+case DOT_PROD_EXPR:
+if (SCALAR_INT_MODE_P (GET_MODE (op0))
+	  && SCALAR_INT_MODE_P (mode))
+	{
+	  if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))))
+	    op0 = gen_rtx_ZERO_EXTEND (mode, op0);
+	  else
+	    op0 = gen_rtx_SIGN_EXTEND (mode, op0);
+	  if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 1))))
+	    op1 = gen_rtx_ZERO_EXTEND (mode, op1);
+	  else
+	    op1 = gen_rtx_SIGN_EXTEND (mode, op1);
+	  op0 = gen_rtx_MULT (mode, op0, op1);
+	  return gen_rtx_PLUS (mode, op0, op2);
+	}
+return NULL;
+case WIDEN_MULT_EXPR:
+case WIDEN_MULT_PLUS_EXPR:
+case WIDEN_MULT_MINUS_EXPR:
+if (SCALAR_INT_MODE_P (GET_MODE (op0))
+	  && SCALAR_INT_MODE_P (mode))
+	{
+	  enum machine_mode inner_mode = GET_MODE (op0);
+	  if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))))
+	    op0 = simplify_gen_unary (ZERO_EXTEND, mode, op0, inner_mode);
+	  else
+	    op0 = simplify_gen_unary (SIGN_EXTEND, mode, op0, inner_mode);
+	  if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 1))))
+	    op1 = simplify_gen_unary (ZERO_EXTEND, mode, op1, inner_mode);
+	  else
+	    op1 = simplify_gen_unary (SIGN_EXTEND, mode, op1, inner_mode);
+	  op0 = gen_rtx_MULT (mode, op0, op1);
+	  if (TREE_CODE (exp) == WIDEN_MULT_EXPR)
+	    return op0;
+	  else if (TREE_CODE (exp) == WIDEN_MULT_PLUS_EXPR)
+	    return gen_rtx_PLUS (mode, op0, op2);
+	  else
+	    return gen_rtx_MINUS (mode, op2, op0);
+	}
+return NULL;
+case WIDEN_SUM_EXPR:
+if (SCALAR_INT_MODE_P (GET_MODE (op0))
+	  && SCALAR_INT_MODE_P (mode))
+	{
+	  if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))))
+	    op0 = gen_rtx_ZERO_EXTEND (mode, op0);
+	  else
+	    op0 = gen_rtx_SIGN_EXTEND (mode, op0);
+	  return gen_rtx_PLUS (mode, op0, op1);
+	}
+return NULL;
+case FMA_EXPR:
+return gen_rtx_FMA (mode, op0, op1, op2);
 default:
 flag_unsupported:
 #ifdef ENABLE_CHECKING
 debug_tree (exp);
 for (; !gsi_end_p (gsi); gsi_next (&gsi))
 {
 basic_block new_bb;
 stmt = gsi_stmt (gsi);
+/* If this statement is a non-debug one, and we generate debug
+	 insns, then this one might be the last real use of a TERed
+	 SSA_NAME, but where there are still some debug uses further
+	 down.  Expanding the current SSA name in such further debug
+	 uses by their RHS might lead to wrong debug info, as coalescing
+	 might make the operands of such RHS be placed into the same
+	 pseudo as something else.  Like so:
+	   a_1 = a_0 + 1;   // Assume a_1 is TERed and a_0 is dead
+	   use(a_1);
+	   a_2 = ...
+#DEBUG ... => a_1
+	 As a_0 and a_2 don't overlap in lifetime, assume they are coalesced.
+	 If we now would expand a_1 by it's RHS (a_0 + 1) in the debug use,
+	 the write to a_2 would actually have clobbered the place which
+	 formerly held a_0.
+	 So, instead of that, we recognize the situation, and generate
+	 debug temporaries at the last real use of TERed SSA names:
+	   a_1 = a_0 + 1;
+#DEBUG #D1 => a_1
+	   use(a_1);
+	   a_2 = ...
+#DEBUG ... => #D1
+	 */
+if (MAY_HAVE_DEBUG_INSNS
+	  && SA.values
+	  && !is_gimple_debug (stmt))
+	{
+	  ssa_op_iter iter;
+	  tree op;
+	  gimple def;
+	  location_t sloc = get_curr_insn_source_location ();
+	  tree sblock = get_curr_insn_block ();
+	  /* Look for SSA names that have their last use here (TERed
+	     names always have only one real use).  */
+	  FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_USE)
+	    if ((def = get_gimple_for_ssa_name (op)))
+	      {
+		imm_use_iterator imm_iter;
+		use_operand_p use_p;
+		bool have_debug_uses = false;
+		FOR_EACH_IMM_USE_FAST (use_p, imm_iter, op)
+		  {
+		    if (gimple_debug_bind_p (USE_STMT (use_p)))
+		      {
+			have_debug_uses = true;
+			break;
+		      }
+		  }
+		if (have_debug_uses)
+		  {
+		    /* OP is a TERed SSA name, with DEF it's defining
+		       statement, and where OP is used in further debug
+		       instructions.  Generate a debug temporary, and
+		       replace all uses of OP in debug insns with that
+		       temporary.  */
+		    gimple debugstmt;
+		    tree value = gimple_assign_rhs_to_tree (def);
+		    tree vexpr = make_node (DEBUG_EXPR_DECL);
+		    rtx val;
+		    enum machine_mode mode;
+		    set_curr_insn_source_location (gimple_location (def));
+		    set_curr_insn_block (gimple_block (def));
+		    DECL_ARTIFICIAL (vexpr) = 1;
+		    TREE_TYPE (vexpr) = TREE_TYPE (value);
+		    if (DECL_P (value))
+		      mode = DECL_MODE (value);
+		    else
+		      mode = TYPE_MODE (TREE_TYPE (value));
+		    DECL_MODE (vexpr) = mode;
+		    val = gen_rtx_VAR_LOCATION
+			(mode, vexpr, (rtx)value, VAR_INIT_STATUS_INITIALIZED);
+		    val = emit_debug_insn (val);
+		    FOR_EACH_IMM_USE_STMT (debugstmt, imm_iter, op)
+		      {
+			if (!gimple_debug_bind_p (debugstmt))
+			  continue;
+			FOR_EACH_IMM_USE_ON_STMT (use_p, imm_iter)
+			  SET_USE (use_p, vexpr);
+			update_stmt (debugstmt);
+		      }
+		  }
+	      }
+	  set_curr_insn_source_location (sloc);
+	  set_curr_insn_block (sblock);
+	}
 currently_expanding_gimple_stmt = stmt;
 /* Expand this statement, then evaluate the resulting RTL and
 fixup the CFG accordingly.  */
 if (gimple_code (stmt) == GIMPLE_COND)
 new_bb = expand_gimple_cond (bb, stmt);
 if (new_bb)
 return new_bb;
 }
 else if (gimple_debug_bind_p (stmt))
-{
+	{
-location_t sloc = get_curr_insn_source_location ();
+	  location_t sloc = get_curr_insn_source_location ();
-tree sblock = get_curr_insn_block ();
+	  tree sblock = get_curr_insn_block ();
-gimple_stmt_iterator nsi = gsi;
+	  gimple_stmt_iterator nsi = gsi;
-for (;;)
+	  for (;;)
-{
+	    {
-tree var = gimple_debug_bind_get_var (stmt);
+	      tree var = gimple_debug_bind_get_var (stmt);
-tree value;
+	      tree value;
-rtx val;
+	      rtx val;
-enum machine_mode mode;
+	      enum machine_mode mode;
-if (gimple_debug_bind_has_value_p (stmt))
+	      if (gimple_debug_bind_has_value_p (stmt))
-value = gimple_debug_bind_get_value (stmt);
+		value = gimple_debug_bind_get_value (stmt);
-else
+	      else
-value = NULL_TREE;
+		value = NULL_TREE;
-last = get_last_insn ();
+	      last = get_last_insn ();
-set_curr_insn_source_location (gimple_location (stmt));
+	      set_curr_insn_source_location (gimple_location (stmt));
-set_curr_insn_block (gimple_block (stmt));
+	      set_curr_insn_block (gimple_block (stmt));
-if (DECL_P (var))
+	      if (DECL_P (var))
-mode = DECL_MODE (var);
+		mode = DECL_MODE (var);
-else
+	      else
-mode = TYPE_MODE (TREE_TYPE (var));
+		mode = TYPE_MODE (TREE_TYPE (var));
-val = gen_rtx_VAR_LOCATION
+	      val = gen_rtx_VAR_LOCATION
-(mode, var, (rtx)value, VAR_INIT_STATUS_INITIALIZED);
+		(mode, var, (rtx)value, VAR_INIT_STATUS_INITIALIZED);
-val = emit_debug_insn (val);
+	      val = emit_debug_insn (val);
-if (dump_file && (dump_flags & TDF_DETAILS))
+	      if (dump_file && (dump_flags & TDF_DETAILS))
-{
+		{
-/* We can't dump the insn with a TREE where an RTX
+		  /* We can't dump the insn with a TREE where an RTX
-is expected.  */
+		     is expected.  */
-INSN_VAR_LOCATION_LOC (val) = const0_rtx;
+		  INSN_VAR_LOCATION_LOC (val) = const0_rtx;
-maybe_dump_rtl_for_gimple_stmt (stmt, last);
+		  maybe_dump_rtl_for_gimple_stmt (stmt, last);
-INSN_VAR_LOCATION_LOC (val) = (rtx)value;
+		  INSN_VAR_LOCATION_LOC (val) = (rtx)value;
-}
+		}
-gsi = nsi;
+	      /* In order not to generate too many debug temporaries,
-gsi_next (&nsi);
+	         we delink all uses of debug statements we already expanded.
-if (gsi_end_p (nsi))
+		 Therefore debug statements between definition and real
-break;
+		 use of TERed SSA names will continue to use the SSA name,
-stmt = gsi_stmt (nsi);
+		 and not be replaced with debug temps.  */
-if (!gimple_debug_bind_p (stmt))
+	      delink_stmt_imm_use (stmt);
-break;
-}
+	      gsi = nsi;
+	      gsi_next (&nsi);
-set_curr_insn_source_location (sloc);
+	      if (gsi_end_p (nsi))
-set_curr_insn_block (sblock);
+		break;
-}
+	      stmt = gsi_stmt (nsi);
+	      if (!gimple_debug_bind_p (stmt))
+		break;
+	    }
+	  set_curr_insn_source_location (sloc);
+	  set_curr_insn_block (sblock);
+	}
 else
 {
 if (is_gimple_call (stmt) && gimple_call_tail_p (stmt))
 {
 bool can_fallthru;
 gimple_stmt_iterator gsi;
 FOR_EACH_BB (bb)
 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 {
-gimple stmt = gsi_stmt (gsi);
+	gimple stmt = gsi_stmt (gsi);
-walk_gimple_op (stmt, discover_nonconstant_array_refs_r, NULL);
+	if (!is_gimple_debug (stmt))
+	  walk_gimple_op (stmt, discover_nonconstant_array_refs_r, NULL);
 }
 }
 /* This function sets crtl->args.internal_arg_pointer to a virtual
 register if DRAP is needed.  Local register allocator will replace
 /* Update crtl->stack_alignment_estimated and use it later to align
 stack.  We check PREFERRED_STACK_BOUNDARY if there may be non-call
 exceptions since callgraph doesn't collect incoming stack alignment
 in this case.  */
-if (flag_non_call_exceptions
+if (cfun->can_throw_non_call_exceptions
 && PREFERRED_STACK_BOUNDARY > crtl->preferred_stack_boundary)
 preferred_stack_boundary = PREFERRED_STACK_BOUNDARY;
 else
 preferred_stack_boundary = crtl->preferred_stack_boundary;
 if (preferred_stack_boundary > crtl->stack_alignment_estimated)
 {
 basic_block bb, init_block;
 sbitmap blocks;
 edge_iterator ei;
 edge e;
+rtx var_seq;
 unsigned i;
+timevar_push (TV_OUT_OF_SSA);
 rewrite_out_of_ssa (&SA);
+timevar_pop (TV_OUT_OF_SSA);
 SA.partition_to_pseudo = (rtx *)xcalloc (SA.map->num_partitions,
 sizeof (rtx));
 /* Some backends want to know that we are expanding to RTL.  */
 currently_expanding_to_rtl = 1;
 set_curr_insn_source_location
 (DECL_SOURCE_LOCATION (current_function_decl));
 else
 set_curr_insn_source_location (cfun->function_start_locus);
 }
+else
+set_curr_insn_source_location (UNKNOWN_LOCATION);
 set_curr_insn_block (DECL_INITIAL (current_function_decl));
 prologue_locator = curr_insn_locator ();
+#ifdef INSN_SCHEDULING
+init_sched_attrs ();
+#endif
 /* Make sure first insn is a note even if we don't want linenums.
 This makes sure the first insn will never be deleted.
 Also, final expects a note to appear there.  */
 emit_note (NOTE_INSN_DELETED);
 crtl->max_used_stack_slot_alignment = STACK_BOUNDARY;
 crtl->stack_alignment_estimated = 0;
 crtl->preferred_stack_boundary = STACK_BOUNDARY;
 cfun->cfg->max_jumptable_ents = 0;
+/* Resovle the function section.  Some targets, like ARM EABI rely on knowledge
+of the function section at exapnsion time to predict distance of calls.  */
+resolve_unique_section (current_function_decl, 0, flag_function_sections);
 /* Expand the variables recorded during gimple lowering.  */
+timevar_push (TV_VAR_EXPAND);
+start_sequence ();
 expand_used_vars ();
+var_seq = get_insns ();
+end_sequence ();
+timevar_pop (TV_VAR_EXPAND);
 /* Honor stack protection warnings.  */
 if (warn_stack_protect)
 {
 if (cfun->calls_alloca)
-warning (OPT_Wstack_protector,
+	warning (OPT_Wstack_protector,
-"not protecting local variables: variable length buffer");
+		 "stack protector not protecting local variables: "
+"variable length buffer");
 if (has_short_buffer && !crtl->stack_protect_guard)
-warning (OPT_Wstack_protector,
+	warning (OPT_Wstack_protector,
-"not protecting function: no buffer at least %d bytes long",
+		 "stack protector not protecting function: "
-(int) PARAM_VALUE (PARAM_SSP_BUFFER_SIZE));
+"all local arrays are less than %d bytes long",
+		 (int) PARAM_VALUE (PARAM_SSP_BUFFER_SIZE));
 }
 /* Set up parameters and prepare for return, for the function.  */
 expand_function_start (current_function_decl);
+/* If we emitted any instructions for setting up the variables,
+emit them before the FUNCTION_START note.  */
+if (var_seq)
+{
+emit_insn_before (var_seq, parm_birth_insn);
+/* In expand_function_end we'll insert the alloca save/restore
+	 before parm_birth_insn.  We've just insertted an alloca call.
+	 Adjust the pointer to match.  */
+parm_birth_insn = var_seq;
+}
 /* Now that we also have the parameter RTXs, copy them over to our
 partitions.  */
 for (i = 0; i < SA.map->num_partitions; i++)
 {
 if (MAY_HAVE_DEBUG_INSNS)
 expand_debug_locations ();
 execute_free_datastructures ();
+timevar_push (TV_OUT_OF_SSA);
 finish_out_of_ssa (&SA);
+timevar_pop (TV_OUT_OF_SSA);
+timevar_push (TV_POST_EXPAND);
+/* We are no longer in SSA form.  */
+cfun->gimple_df->in_ssa_p = false;
 /* Expansion is used by optimization passes too, set maybe_hot_insn_p
 conservatively to true until they are all profile aware.  */
 pointer_map_destroy (lab_rtx_for_bb);
 free_histograms ();
 FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR, next_bb)
 {
 edge e;
 edge_iterator ei;
 for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
-{
+	{
-if (e->insns.r)
+	  if (e->insns.r)
-commit_one_edge_insertion (e);
+	    {
-else
+	      /* Avoid putting insns before parm_birth_insn.  */
-ei_next (&ei);
+	      if (e->src == ENTRY_BLOCK_PTR
-}
+		  && single_succ_p (ENTRY_BLOCK_PTR)
+		  && parm_birth_insn)
+		{
+		  rtx insns = e->insns.r;
+		  e->insns.r = NULL_RTX;
+		  emit_insn_after_noloc (insns, parm_birth_insn, e->dest);
+		}
+	      else
+		commit_one_edge_insertion (e);
+	    }
+	  else
+	    ei_next (&ei);
+	}
 }
 /* We're done expanding trees to RTL.  */
 currently_expanding_to_rtl = 0;
 naked_return_label = NULL;
 /* Tag the blocks with a depth number so that change_scope can find
 the common parent easily.  */
 set_block_levels (DECL_INITIAL (cfun->decl), 0);
 default_rtl_profile ();
+timevar_pop (TV_POST_EXPAND);
 return 0;
 }
 struct rtl_opt_pass pass_expand =
 {
 NULL,                                 /* gate */
 gimple_expand_cfg,            /* execute */
 NULL,                                 /* sub */
 NULL,                                 /* next */
 0,                                    /* static_pass_number */
-TV_EXPAND,                /* tv_id */
+TV_EXPAND,				/* tv_id */
-PROP_ssa | PROP_gimple_leh | PROP_cfg,/* properties_required */
+PROP_ssa | PROP_gimple_leh | PROP_cfg
+| PROP_gimple_lcx,			/* properties_required */
 PROP_rtl,                             /* properties_provided */
 PROP_ssa | PROP_trees,        /* properties_destroyed */
 TODO_verify_ssa | TODO_verify_flow
 | TODO_verify_stmts,        /* todo_flags_start */
 TODO_dump_func

Mercurial > hg > CbC > CbC_gcc

comparison gcc/cfgexpand.c @ 69:1b10fe6932e1