CbC/CbC_gcc: gcc/var-tracking.c comparison

comparison gcc/var-tracking.c @ 132:d34655255c78

update gcc-8.2

author	mir3636
date	Thu, 25 Oct 2018 10:21:07 +0900
parents	84e7813d76e9
children	1830386684a0

comparison

equal deleted inserted replaced

-:e108057fa461
+:d34655255c78
 /* Variable tracking routines for the GNU compiler.
-Copyright (C) 2002-2017 Free Software Foundation, Inc.
+Copyright (C) 2002-2018 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
 #include "cselib.h"
 #include "params.h"
 #include "tree-pretty-print.h"
 #include "rtl-iter.h"
 #include "fibonacci_heap.h"
+#include "print-rtl.h"
 typedef fibonacci_heap <long, basic_block_def> bb_heap_t;
 typedef fibonacci_node <long, basic_block_def> bb_heap_node_t;
 /* var-tracking.c assumes that tree code with the same value as VALUE rtx code
 };
 /* Pointer to the BB's information specific to variable tracking pass.  */
 #define VTI(BB) ((variable_tracking_info *) (BB)->aux)
-/* Macro to access MEM_OFFSET as an HOST_WIDE_INT.  Evaluates MEM twice.  */
+/* Return MEM_OFFSET (MEM) as a HOST_WIDE_INT, or 0 if we can't.  */
-#define INT_MEM_OFFSET(mem) (MEM_OFFSET_KNOWN_P (mem) ? MEM_OFFSET (mem) : 0)
+static inline HOST_WIDE_INT
+int_mem_offset (const_rtx mem)
+{
+HOST_WIDE_INT offset;
+if (MEM_OFFSET_KNOWN_P (mem) && MEM_OFFSET (mem).is_constant (&offset))
+return offset;
+return 0;
+}
 #if CHECKING_P && (GCC_VERSION >= 2007)
 /* Access VAR's Ith part's offset, checking that it's not a one-part
 variable.  */
 static bool variable_different_p (variable *, variable *);
 static bool dataflow_set_different (dataflow_set *, dataflow_set *);
 static void dataflow_set_destroy (dataflow_set *);
 static bool track_expr_p (tree, bool);
-static bool same_variable_part_p (rtx, tree, HOST_WIDE_INT);
 static void add_uses_1 (rtx *, void *);
 static void add_stores (rtx, const_rtx, void *);
 static bool compute_bb_dataflow (basic_block);
 static bool vt_find_locations (void);
 static void delete_variable_part (dataflow_set *, rtx,
 				  decl_or_value, HOST_WIDE_INT);
 static void emit_notes_in_bb (basic_block, dataflow_set *);
 static void vt_emit_notes (void);
-static bool vt_get_decl_and_offset (rtx, tree *, HOST_WIDE_INT *);
 static void vt_add_function_parameters (void);
 static bool vt_initialize (void);
 static void vt_finalize (void);
 /* Callback for stack_adjust_offset_pre_post, called via for_each_inc_dec.  */
 /* Compute a CFA-based value for an ADJUSTMENT made to stack_pointer_rtx
 or hard_frame_pointer_rtx.  */
 static inline rtx
-compute_cfa_pointer (HOST_WIDE_INT adjustment)
+compute_cfa_pointer (poly_int64 adjustment)
 {
 return plus_constant (Pmode, cfa_base_rtx, adjustment + cfa_base_offset);
 }
 /* Adjustment for hard_frame_pointer_rtx to cfa base reg,
 or -1 if the replacement shouldn't be done.  */
-static HOST_WIDE_INT hard_frame_pointer_adjustment = -1;
+static poly_int64 hard_frame_pointer_adjustment = -1;
 /* Data for adjust_mems callback.  */
 struct adjust_mem_data
 {
 	  case PLUS:
 	  case MINUS:
 	  case MULT:
 	    break;
 	  case ASHIFT:
+	    if (GET_MODE (XEXP (x, 1)) != VOIDmode)
+	      {
+		enum machine_mode mode = GET_MODE (subreg);
+		rtx op1 = XEXP (x, 1);
+		enum machine_mode op1_mode = GET_MODE (op1);
+		if (GET_MODE_PRECISION (as_a <scalar_int_mode> (mode))
+		    < GET_MODE_PRECISION (as_a <scalar_int_mode> (op1_mode)))
+		  {
+		    poly_uint64 byte = subreg_lowpart_offset (mode, op1_mode);
+		    if (GET_CODE (op1) == SUBREG || GET_CODE (op1) == CONCAT)
+		      {
+			if (!simplify_subreg (mode, op1, op1_mode, byte))
+			  return false;
+		      }
+		    else if (!validate_subreg (mode, op1_mode, op1, byte))
+		      return false;
+		  }
+	      }
 	    iter.substitute (XEXP (x, 0));
 	    break;
 	  default:
 	    return false;
 	  }
 struct adjust_mem_data *amd = (struct adjust_mem_data *) data;
 rtx mem, addr = loc, tem;
 machine_mode mem_mode_save;
 bool store_save;
 scalar_int_mode tem_mode, tem_subreg_mode;
+poly_int64 size;
 switch (GET_CODE (loc))
 {
 case REG:
 /* Don't do any sp or fp replacements outside of MEM addresses
 on the LHS.  */
 	  && !frame_pointer_needed
 	  && cfa_base_rtx)
 	return compute_cfa_pointer (amd->stack_adjust);
 else if (loc == hard_frame_pointer_rtx
 	       && frame_pointer_needed
-	       && hard_frame_pointer_adjustment != -1
+	       && maybe_ne (hard_frame_pointer_adjustment, -1)
 	       && cfa_base_rtx)
 	return compute_cfa_pointer (hard_frame_pointer_adjustment);
 gcc_checking_assert (loc != virtual_incoming_args_rtx);
 return loc;
 case MEM:
 if (!amd->store)
 	mem = avoid_constant_pool_reference (mem);
 return mem;
 case PRE_INC:
 case PRE_DEC:
-addr = gen_rtx_PLUS (GET_MODE (loc), XEXP (loc, 0),
+size = GET_MODE_SIZE (amd->mem_mode);
-			   gen_int_mode (GET_CODE (loc) == PRE_INC
+addr = plus_constant (GET_MODE (loc), XEXP (loc, 0),
-					 ? GET_MODE_SIZE (amd->mem_mode)
+			    GET_CODE (loc) == PRE_INC ? size : -size);
-					 : -GET_MODE_SIZE (amd->mem_mode),
-					 GET_MODE (loc)));
 /* FALLTHRU */
 case POST_INC:
 case POST_DEC:
 if (addr == loc)
 	addr = XEXP (loc, 0);
 gcc_assert (amd->mem_mode != VOIDmode && amd->mem_mode != BLKmode);
 addr = simplify_replace_fn_rtx (addr, old_rtx, adjust_mems, data);
-tem = gen_rtx_PLUS (GET_MODE (loc), XEXP (loc, 0),
+size = GET_MODE_SIZE (amd->mem_mode);
-			  gen_int_mode ((GET_CODE (loc) == PRE_INC
+tem = plus_constant (GET_MODE (loc), XEXP (loc, 0),
-					 || GET_CODE (loc) == POST_INC)
+			   (GET_CODE (loc) == PRE_INC
-					? GET_MODE_SIZE (amd->mem_mode)
+			    || GET_CODE (loc) == POST_INC) ? size : -size);
-					: -GET_MODE_SIZE (amd->mem_mode),
-					GET_MODE (loc)));
 store_save = amd->store;
 amd->store = false;
 tem = simplify_replace_fn_rtx (tem, old_rtx, adjust_mems, data);
 amd->store = store_save;
 amd->side_effects.safe_push (gen_rtx_SET (XEXP (loc, 0), tem));
 				 GET_MODE (SUBREG_REG (loc)),
 				 SUBREG_BYTE (loc));
 if (tem == NULL_RTX)
 	tem = gen_rtx_raw_SUBREG (GET_MODE (loc), addr, SUBREG_BYTE (loc));
 finish_subreg:
-if (MAY_HAVE_DEBUG_INSNS
+if (MAY_HAVE_DEBUG_BIND_INSNS
 	  && GET_CODE (tem) == SUBREG
 	  && (GET_CODE (SUBREG_REG (tem)) == PLUS
 	      || GET_CODE (SUBREG_REG (tem)) == MINUS
 	      || GET_CODE (SUBREG_REG (tem)) == MULT
 	      || GET_CODE (SUBREG_REG (tem)) == ASHIFT)
 static inline onepart_enum
 dv_onepart_p (decl_or_value dv)
 {
 tree decl;
-if (!MAY_HAVE_DEBUG_INSNS)
+if (!MAY_HAVE_DEBUG_BIND_INSNS)
 return NOT_ONEPART;
 if (dv_is_value_p (dv))
 return ONEPART_VALUE;
 if (!node)
 attrs_list_insert (&set->regs[REGNO (loc)], dv, offset, loc);
 set_variable_part (set, loc, dv, offset, initialized, set_src, iopt);
 }
+/* Return true if we should track a location that is OFFSET bytes from
+a variable.  Store the constant offset in *OFFSET_OUT if so.  */
+static bool
+track_offset_p (poly_int64 offset, HOST_WIDE_INT *offset_out)
+{
+HOST_WIDE_INT const_offset;
+if (!offset.is_constant (&const_offset)
+|| !IN_RANGE (const_offset, 0, MAX_VAR_PARTS - 1))
+return false;
+*offset_out = const_offset;
+return true;
+}
+/* Return the offset of a register that track_offset_p says we
+should track.  */
+static HOST_WIDE_INT
+get_tracked_reg_offset (rtx loc)
+{
+HOST_WIDE_INT offset;
+if (!track_offset_p (REG_OFFSET (loc), &offset))
+gcc_unreachable ();
+return offset;
+}
 /* Set the register to contain REG_EXPR (LOC), REG_OFFSET (LOC).  */
 static void
 var_reg_set (dataflow_set *set, rtx loc, enum var_init_status initialized,
 	     rtx set_src)
 {
 tree decl = REG_EXPR (loc);
-HOST_WIDE_INT offset = REG_OFFSET (loc);
+HOST_WIDE_INT offset = get_tracked_reg_offset (loc);
 var_reg_decl_set (set, loc, initialized,
 		    dv_from_decl (decl), offset, set_src, INSERT);
 }
 static void
 var_reg_delete_and_set (dataflow_set *set, rtx loc, bool modify,
 			enum var_init_status initialized, rtx set_src)
 {
 tree decl = REG_EXPR (loc);
-HOST_WIDE_INT offset = REG_OFFSET (loc);
+HOST_WIDE_INT offset = get_tracked_reg_offset (loc);
 attrs *node, *next;
 attrs **nextp;
 decl = var_debug_decl (decl);
 var_reg_delete (dataflow_set *set, rtx loc, bool clobber)
 {
 attrs **nextp = &set->regs[REGNO (loc)];
 attrs *node, *next;
-if (clobber)
+HOST_WIDE_INT offset;
+if (clobber && track_offset_p (REG_OFFSET (loc), &offset))
 {
 tree decl = REG_EXPR (loc);
-HOST_WIDE_INT offset = REG_OFFSET (loc);
 decl = var_debug_decl (decl);
 clobber_variable_part (set, NULL, dv_from_decl (decl), offset, NULL);
 }
 change.  */
 static rtx
 vt_canonicalize_addr (dataflow_set *set, rtx oloc)
 {
-HOST_WIDE_INT ofst = 0;
+poly_int64 ofst = 0, term;
 machine_mode mode = GET_MODE (oloc);
 rtx loc = oloc;
 rtx x;
 bool retry = true;
 while (retry)
 {
 while (GET_CODE (loc) == PLUS
-	     && GET_CODE (XEXP (loc, 1)) == CONST_INT)
+	     && poly_int_rtx_p (XEXP (loc, 1), &term))
 	{
-	  ofst += INTVAL (XEXP (loc, 1));
+	  ofst += term;
 	  loc = XEXP (loc, 0);
 	}
 /* Alignment operations can't normally be combined, so just
 	 canonicalize the base and we're done.  We'll normally have
 	    loc = get_addr_from_local_cache (set, loc);
 	  else
 	    loc = get_addr_from_global_cache (loc);
 	  /* Consolidate plus_constants.  */
-	  while (ofst && GET_CODE (loc) == PLUS
+	  while (maybe_ne (ofst, 0)
-		 && GET_CODE (XEXP (loc, 1)) == CONST_INT)
+		 && GET_CODE (loc) == PLUS
+		 && poly_int_rtx_p (XEXP (loc, 1), &term))
 	    {
-	      ofst += INTVAL (XEXP (loc, 1));
+	      ofst += term;
 	      loc = XEXP (loc, 0);
 	    }
 	  retry = false;
 	}
 	  loc = x;
 	}
 }
 /* Add OFST back in.  */
-if (ofst)
+if (maybe_ne (ofst, 0))
 {
 /* Don't build new RTL if we can help it.  */
-if (GET_CODE (oloc) == PLUS
+if (strip_offset (oloc, &term) == loc && known_eq (term, ofst))
-	  && XEXP (oloc, 0) == loc
-	  && INTVAL (XEXP (oloc, 1)) == ofst)
 	return oloc;
 loc = plus_constant (mode, loc, ofst);
 }
 static void
 var_mem_set (dataflow_set *set, rtx loc, enum var_init_status initialized,
 	     rtx set_src)
 {
 tree decl = MEM_EXPR (loc);
-HOST_WIDE_INT offset = INT_MEM_OFFSET (loc);
+HOST_WIDE_INT offset = int_mem_offset (loc);
 var_mem_decl_set (set, loc, initialized,
 		    dv_from_decl (decl), offset, set_src, INSERT);
 }
 static void
 var_mem_delete_and_set (dataflow_set *set, rtx loc, bool modify,
 			enum var_init_status initialized, rtx set_src)
 {
 tree decl = MEM_EXPR (loc);
-HOST_WIDE_INT offset = INT_MEM_OFFSET (loc);
+HOST_WIDE_INT offset = int_mem_offset (loc);
 clobber_overlapping_mems (set, loc);
 decl = var_debug_decl (decl);
 if (initialized == VAR_INIT_STATUS_UNKNOWN)
 static void
 var_mem_delete (dataflow_set *set, rtx loc, bool clobber)
 {
 tree decl = MEM_EXPR (loc);
-HOST_WIDE_INT offset = INT_MEM_OFFSET (loc);
+HOST_WIDE_INT offset = int_mem_offset (loc);
 clobber_overlapping_mems (set, loc);
 decl = var_debug_decl (decl);
 if (clobber)
 clobber_variable_part (set, NULL, dv_from_decl (decl), offset, NULL);
 	else if (XINT (x, i) < XINT (y, i))
 	  return -1;
 	else
 	  return 1;
+case 'p':
+	r = compare_sizes_for_sort (SUBREG_BYTE (x), SUBREG_BYTE (y));
+	if (r != 0)
+	  return r;
+	break;
 case 'V':
 case 'E':
 	/* Compare the vector length first.  */
 	if (XVECLEN (x, i) == XVECLEN (y, i))
 	  /* Compare the vectors elements.  */;
 VALUE_RECURSED_INTO (val) = true;
 for (node = var->var_part[0].loc_chain; node; node = node->next)
 if (MEM_P (node->loc)
 	&& MEM_EXPR (node->loc) == expr
-	&& INT_MEM_OFFSET (node->loc) == 0)
+	&& int_mem_offset (node->loc) == 0)
 {
 	where = node;
 	break;
 }
 else if (GET_CODE (node->loc) == VALUE
 	  for (loc = var->var_part[0].loc_chain; loc; loc = loc->next)
 	    {
 	      /* We want to remove dying MEMs that don't refer to DECL.  */
 	      if (GET_CODE (loc->loc) == MEM
 		  && (MEM_EXPR (loc->loc) != decl
-		      || INT_MEM_OFFSET (loc->loc) != 0)
+		      || int_mem_offset (loc->loc) != 0)
 		  && mem_dies_at_call (loc->loc))
 		break;
 	      /* We want to move here MEMs that do refer to DECL.  */
 	      else if (GET_CODE (loc->loc) == VALUE
 		       && find_mem_expr_in_1pdv (decl, loc->loc,
 		}
 	    }
 	  if (GET_CODE (loc->loc) != MEM
 	      || (MEM_EXPR (loc->loc) == decl
-		  && INT_MEM_OFFSET (loc->loc) == 0)
+		  && int_mem_offset (loc->loc) == 0)
 	      || !mem_dies_at_call (loc->loc))
 	    {
 	      if (old_loc != loc->loc && emit_notes)
 		{
 		  if (old_loc == var->var_part[0].cur_loc)
 			  regs_invalidated_by_call);
 EXECUTE_IF_SET_IN_HARD_REG_SET (invalidated_regs, 0, r, hrsi)
 var_regno_delete (set, r);
-if (MAY_HAVE_DEBUG_INSNS)
+if (MAY_HAVE_DEBUG_BIND_INSNS)
 {
 set->traversed_vars = set->vars;
 shared_hash_htab (set->vars)
 	->traverse <dataflow_set *, dataflow_set_preserve_mem_locs> (set);
 set->traversed_vars = set->vars;
 	{
 	  if (handled_component_p (realdecl)
 	      || (TREE_CODE (realdecl) == MEM_REF
 		  && TREE_CODE (TREE_OPERAND (realdecl, 0)) == ADDR_EXPR))
 	    {
-	      HOST_WIDE_INT bitsize, bitpos, maxsize;
+	      HOST_WIDE_INT bitsize, bitpos;
 	      bool reverse;
 	      tree innerdecl
-		= get_ref_base_and_extent (realdecl, &bitpos, &bitsize,
+		= get_ref_base_and_extent_hwi (realdecl, &bitpos,
-					   &maxsize, &reverse);
+					       &bitsize, &reverse);
-	      if (!DECL_P (innerdecl)
+	      if (!innerdecl
+		  || !DECL_P (innerdecl)
 		  || DECL_IGNORED_P (innerdecl)
 		  /* Do not track declarations for parts of tracked record
 		     parameters since we want to track them as a whole.  */
 		  || tracked_record_parameter_p (innerdecl)
 		  || TREE_STATIC (innerdecl)
-		  || bitsize <= 0
+		  || bitsize == 0
-		  || bitpos + bitsize > 256
+		  || bitpos + bitsize > 256)
-		  || bitsize != maxsize)
 		return 0;
 	      else
 		realdecl = expr;
 	    }
 	  else
 if ((GET_MODE (decl_rtl) == BLKmode
 	   || AGGREGATE_TYPE_P (TREE_TYPE (realdecl)))
 	  && !tracked_record_parameter_p (realdecl))
 	return 0;
 if (MEM_SIZE_KNOWN_P (decl_rtl)
-	  && MEM_SIZE (decl_rtl) > MAX_VAR_PARTS)
+	  && maybe_gt (MEM_SIZE (decl_rtl), MAX_VAR_PARTS))
 	return 0;
 }
 DECL_CHANGED (expr) = 0;
 DECL_CHANGED (realdecl) = 0;
 /* Determine whether a given LOC refers to the same variable part as
 EXPR+OFFSET.  */
 static bool
-same_variable_part_p (rtx loc, tree expr, HOST_WIDE_INT offset)
+same_variable_part_p (rtx loc, tree expr, poly_int64 offset)
 {
 tree expr2;
-HOST_WIDE_INT offset2;
+poly_int64 offset2;
 if (! DECL_P (expr))
 return false;
 if (REG_P (loc))
 offset2 = REG_OFFSET (loc);
 }
 else if (MEM_P (loc))
 {
 expr2 = MEM_EXPR (loc);
-offset2 = INT_MEM_OFFSET (loc);
+offset2 = int_mem_offset (loc);
 }
 else
 return false;
 if (! expr2 || ! DECL_P (expr2))
 return false;
 expr = var_debug_decl (expr);
 expr2 = var_debug_decl (expr2);
-return (expr == expr2 && offset == offset2);
+return (expr == expr2 && known_eq (offset, offset2));
 }
 /* LOC is a REG or MEM that we would like to track if possible.
 If EXPR is null, we don't know what expression LOC refers to,
 otherwise it refers to EXPR + OFFSET.  STORE_REG_P is true if
 is something we can track.  When returning true, store the mode of
 the lowpart we can track in *MODE_OUT (if nonnull) and its offset
 from EXPR in *OFFSET_OUT (if nonnull).  */
 static bool
-track_loc_p (rtx loc, tree expr, HOST_WIDE_INT offset, bool store_reg_p,
+track_loc_p (rtx loc, tree expr, poly_int64 offset, bool store_reg_p,
 	     machine_mode *mode_out, HOST_WIDE_INT *offset_out)
 {
 machine_mode mode;
 if (expr == NULL || !track_expr_p (expr, true))
 hard register.  */
 if ((paradoxical_subreg_p (mode, DECL_MODE (expr))
 || (store_reg_p
 	   && !COMPLEX_MODE_P (DECL_MODE (expr))
 	   && hard_regno_nregs (REGNO (loc), DECL_MODE (expr)) == 1))
-&& offset + byte_lowpart_offset (DECL_MODE (expr), mode) == 0)
+&& known_eq (offset + byte_lowpart_offset (DECL_MODE (expr), mode), 0))
 {
 mode = DECL_MODE (expr);
 offset = 0;
 }
-if (offset < 0 || offset >= MAX_VAR_PARTS)
+HOST_WIDE_INT const_offset;
+if (!track_offset_p (offset, &const_offset))
 return false;
 if (mode_out)
 *mode_out = mode;
 if (offset_out)
-*offset_out = offset;
+*offset_out = const_offset;
 return true;
 }
 /* Return the MODE lowpart of LOC, or null if LOC is not something we
 want to track.  When returning nonnull, make sure that the attributes
 on the returned value are updated.  */
 static rtx
 var_lowpart (machine_mode mode, rtx loc)
 {
-unsigned int offset, reg_offset, regno;
+unsigned int regno;
 if (GET_MODE (loc) == mode)
 return loc;
 if (!REG_P (loc) && !MEM_P (loc))
 return NULL;
-offset = byte_lowpart_offset (mode, GET_MODE (loc));
+poly_uint64 offset = byte_lowpart_offset (mode, GET_MODE (loc));
 if (MEM_P (loc))
 return adjust_address_nv (loc, mode, offset);
-reg_offset = subreg_lowpart_offset (mode, GET_MODE (loc));
+poly_uint64 reg_offset = subreg_lowpart_offset (mode, GET_MODE (loc));
 regno = REGNO (loc) + subreg_regno_offset (REGNO (loc), GET_MODE (loc),
 					     reg_offset, mode);
 return gen_rtx_REG_offset (loc, mode, regno, offset);
 }
 if (!expr)
 	return MO_CLOBBER;
 else if (target_for_debug_bind (var_debug_decl (expr)))
 	return MO_CLOBBER;
-else if (track_loc_p (loc, expr, INT_MEM_OFFSET (loc),
+else if (track_loc_p (loc, expr, int_mem_offset (loc),
 			    false, modep, NULL)
 	       /* Multi-part variables shouldn't refer to one-part
 		  variable names such as VALUEs (never happens) or
 		  DEBUG_EXPRs (only happens in the presence of debug
 		  insns).  */
-	       && (!MAY_HAVE_DEBUG_INSNS
+	       && (!MAY_HAVE_DEBUG_BIND_INSNS
 		   || !rtx_debug_expr_p (XEXP (loc, 0))))
 	return MO_USE;
 else
 	return MO_CLOBBER;
 }
 	  || GET_CODE (expr) == CLOBBER)
 	{
 	  mo.type = MO_CLOBBER;
 	  mo.u.loc = loc;
 	  if (GET_CODE (expr) == SET
-	      && SET_DEST (expr) == loc
+	      && (SET_DEST (expr) == loc
+		  || (GET_CODE (SET_DEST (expr)) == STRICT_LOW_PART
+		      && XEXP (SET_DEST (expr), 0) == loc))
 	      && !unsuitable_loc (SET_SRC (expr))
 	      && find_use_val (loc, mode, cui))
 	    {
 	      gcc_checking_assert (type == MO_VAL_SET);
 	      mo.u.loc = gen_rtx_SET (loc, SET_SRC (expr));
 	  else
 	    {
 	      rtx xexpr = gen_rtx_SET (loc, src);
 	      if (same_variable_part_p (SET_SRC (xexpr),
 					MEM_EXPR (loc),
-					INT_MEM_OFFSET (loc)))
+					int_mem_offset (loc)))
 		mo.type = MO_COPY;
 	      else
 		mo.type = MO_SET;
 	      mo.u.loc = xexpr;
 	    }
 	preserve_value (v);
 goto log_and_return;
 }
 if (loc == stack_pointer_rtx
-&& hard_frame_pointer_adjustment != -1
+&& maybe_ne (hard_frame_pointer_adjustment, -1)
 && preserve)
 cselib_set_value_sp_based (v);
 nloc = replace_expr_with_values (oloc);
 if (nloc)
 dataflow_set_init (&old_out);
 dataflow_set_copy (&old_out, out);
 dataflow_set_copy (out, in);
-if (MAY_HAVE_DEBUG_INSNS)
+if (MAY_HAVE_DEBUG_BIND_INSNS)
 local_get_addr_cache = new hash_map<rtx, rtx>;
 FOR_EACH_VEC_ELT (VTI (bb)->mos, i, mo)
 {
 rtx_insn *insn = mo->insn;
 	    out->stack_adjust += mo->u.adjust;
 	    break;
 	}
 }
-if (MAY_HAVE_DEBUG_INSNS)
+if (MAY_HAVE_DEBUG_BIND_INSNS)
 {
 delete local_get_addr_cache;
 local_get_addr_cache = NULL;
 dataflow_set_equiv_regs (out);
 		    = shared_hash_htab (VTI (bb)->out.vars)->elements ();
 		}
 	      else
 		oldinsz = oldoutsz = 0;
-	      if (MAY_HAVE_DEBUG_INSNS)
+	      if (MAY_HAVE_DEBUG_BIND_INSNS)
 		{
 		  dataflow_set *in = &VTI (bb)->in, *first_out = NULL;
 		  bool first = true, adjust = false;
 		  /* Calculate the IN set as the intersection of
 	      htabsz += shared_hash_htab (VTI (bb)->in.vars)->size ()
 			 + shared_hash_htab (VTI (bb)->out.vars)->size ();
 	      if (htabmax && htabsz > htabmax)
 		{
-		  if (MAY_HAVE_DEBUG_INSNS)
+		  if (MAY_HAVE_DEBUG_BIND_INSNS)
 		    inform (DECL_SOURCE_LOCATION (cfun->decl),
 			    "variable tracking size limit exceeded with "
 			    "-fvar-tracking-assignments, retrying without");
 		  else
 		    inform (DECL_SOURCE_LOCATION (cfun->decl),
 		}
 	    }
 	}
 }
-if (success && MAY_HAVE_DEBUG_INSNS)
+if (success && MAY_HAVE_DEBUG_BIND_INSNS)
 FOR_EACH_BB_FN (bb, cfun)
 gcc_assert (VTI (bb)->flooded);
 free (bb_order);
 delete worklist;
 vt_expand_loc (rtx loc, variable_table_type *vars)
 {
 struct expand_loc_callback_data data;
 rtx result;
-if (!MAY_HAVE_DEBUG_INSNS)
+if (!MAY_HAVE_DEBUG_BIND_INSNS)
 return loc;
 INIT_ELCD (data, vars);
 result = cselib_expand_value_rtx_cb (loc, scratch_regs, EXPR_DEPTH,
 rtx note_vl;
 int i, j, n_var_parts;
 bool complete;
 enum var_init_status initialized = VAR_INIT_STATUS_UNINITIALIZED;
 HOST_WIDE_INT last_limit;
-tree type_size_unit;
 HOST_WIDE_INT offsets[MAX_VAR_PARTS];
 rtx loc[MAX_VAR_PARTS];
 tree decl;
 location_chain *lc;
 	var->var_part[i].cur_loc = var->var_part[i].loc_chain->loc;
 for (i = 0; i < var->n_var_parts; i++)
 {
 machine_mode mode, wider_mode;
 rtx loc2;
-HOST_WIDE_INT offset;
+HOST_WIDE_INT offset, size, wider_size;
 if (i == 0 && var->onepart)
 	{
 	  gcc_checking_assert (var->n_var_parts == 1);
 	  offset = 0;
 	}
 loc[n_var_parts] = loc2;
 mode = GET_MODE (var->var_part[i].cur_loc);
 if (mode == VOIDmode && var->onepart)
 	mode = DECL_MODE (decl);
-last_limit = offsets[n_var_parts] + GET_MODE_SIZE (mode);
+/* We ony track subparts of constant-sized objects, since at present
+	 there's no representation for polynomial pieces.  */
+if (!GET_MODE_SIZE (mode).is_constant (&size))
+	{
+	  complete = false;
+	  continue;
+	}
+last_limit = offsets[n_var_parts] + size;
 /* Attempt to merge adjacent registers or memory.  */
 for (j = i + 1; j < var->n_var_parts; j++)
 	if (last_limit <= VAR_PART_OFFSET (var, j))
 	  break;
 if (j < var->n_var_parts
 	  && GET_MODE_WIDER_MODE (mode).exists (&wider_mode)
+	  && GET_MODE_SIZE (wider_mode).is_constant (&wider_size)
 	  && var->var_part[j].cur_loc
 	  && mode == GET_MODE (var->var_part[j].cur_loc)
 	  && (REG_P (loc[n_var_parts]) || MEM_P (loc[n_var_parts]))
 	  && last_limit == (var->onepart ? 0 : VAR_PART_OFFSET (var, j))
 	  && (loc2 = vt_expand_loc (var->var_part[j].cur_loc, vars))
 	  && GET_CODE (loc[n_var_parts]) == GET_CODE (loc2))
 	{
 	  rtx new_loc = NULL;
+	  poly_int64 offset2;
 	  if (REG_P (loc[n_var_parts])
 	      && hard_regno_nregs (REGNO (loc[n_var_parts]), mode) * 2
 		 == hard_regno_nregs (REGNO (loc[n_var_parts]), wider_mode)
 	      && end_hard_regno (mode, REGNO (loc[n_var_parts]))
 		}
 	    }
 	  else if (MEM_P (loc[n_var_parts])
 		   && GET_CODE (XEXP (loc2, 0)) == PLUS
 		   && REG_P (XEXP (XEXP (loc2, 0), 0))
-		   && CONST_INT_P (XEXP (XEXP (loc2, 0), 1)))
+		   && poly_int_rtx_p (XEXP (XEXP (loc2, 0), 1), &offset2))
 	    {
-	      if ((REG_P (XEXP (loc[n_var_parts], 0))
+	      poly_int64 end1 = size;
-		   && rtx_equal_p (XEXP (loc[n_var_parts], 0),
+	      rtx base1 = strip_offset_and_add (XEXP (loc[n_var_parts], 0),
-				   XEXP (XEXP (loc2, 0), 0))
+						&end1);
-		   && INTVAL (XEXP (XEXP (loc2, 0), 1))
+	      if (rtx_equal_p (base1, XEXP (XEXP (loc2, 0), 0))
-		      == GET_MODE_SIZE (mode))
+		  && known_eq (end1, offset2))
-		  || (GET_CODE (XEXP (loc[n_var_parts], 0)) == PLUS
-		      && CONST_INT_P (XEXP (XEXP (loc[n_var_parts], 0), 1))
-		      && rtx_equal_p (XEXP (XEXP (loc[n_var_parts], 0), 0),
-				      XEXP (XEXP (loc2, 0), 0))
-		      && INTVAL (XEXP (XEXP (loc[n_var_parts], 0), 1))
-			 + GET_MODE_SIZE (mode)
-			 == INTVAL (XEXP (XEXP (loc2, 0), 1))))
 		new_loc = adjust_address_nv (loc[n_var_parts],
 					     wider_mode, 0);
 	    }
 	  if (new_loc)
 	    {
 	      loc[n_var_parts] = new_loc;
 	      mode = wider_mode;
-	      last_limit = offsets[n_var_parts] + GET_MODE_SIZE (mode);
+	      last_limit = offsets[n_var_parts] + wider_size;
 	      i = j;
 	    }
 	}
 ++n_var_parts;
 }
-type_size_unit = TYPE_SIZE_UNIT (TREE_TYPE (decl));
+poly_uint64 type_size_unit
-if ((unsigned HOST_WIDE_INT) last_limit < TREE_INT_CST_LOW (type_size_unit))
+= tree_to_poly_uint64 (TYPE_SIZE_UNIT (TREE_TYPE (decl)));
+if (maybe_lt (poly_uint64 (last_limit), type_size_unit))
 complete = false;
 if (! flag_var_tracking_uninit)
 initialized = VAR_INIT_STATUS_INITIALIZED;
 else
 {
 /* Make sure that the call related notes come first.  */
 while (NEXT_INSN (insn)
 	     && NOTE_P (insn)
-	     && ((NOTE_KIND (insn) == NOTE_INSN_VAR_LOCATION
+	     && NOTE_KIND (insn) == NOTE_INSN_VAR_LOCATION
-		  && NOTE_DURING_CALL_P (insn))
+	     && NOTE_DURING_CALL_P (insn))
-		 || NOTE_KIND (insn) == NOTE_INSN_CALL_ARG_LOCATION))
 	insn = NEXT_INSN (insn);
 if (NOTE_P (insn)
-	  && ((NOTE_KIND (insn) == NOTE_INSN_VAR_LOCATION
+	  && NOTE_KIND (insn) == NOTE_INSN_VAR_LOCATION
-	       && NOTE_DURING_CALL_P (insn))
+	  && NOTE_DURING_CALL_P (insn))
-	      || NOTE_KIND (insn) == NOTE_INSN_CALL_ARG_LOCATION))
 	note = emit_note_after (NOTE_INSN_VAR_LOCATION, insn);
 else
 	note = emit_note_before (NOTE_INSN_VAR_LOCATION, insn);
 }
 NOTE_VAR_LOCATION (note) = note_vl;
 variable_table_type *htab = shared_hash_htab (vars);
 if (!changed_variables->elements ())
 return;
-if (MAY_HAVE_DEBUG_INSNS)
+if (MAY_HAVE_DEBUG_BIND_INSNS)
 process_changed_values (htab);
 data.insn = insn;
 data.where = where;
 data.vars = htab;
 	  case MO_CALL:
 	    dataflow_set_clear_at_call (set, insn);
 	    emit_notes_for_changes (insn, EMIT_NOTE_AFTER_CALL_INSN, set->vars);
 	    {
 	      rtx arguments = mo->u.loc, *p = &arguments;
-	      rtx_note *note;
 	      while (*p)
 		{
 		  XEXP (XEXP (*p, 0), 1)
 		    = vt_expand_loc (XEXP (XEXP (*p, 0), 1),
 				     shared_hash_htab (set->vars));
 		  /* If expansion is successful, keep it in the list.  */
 		  if (XEXP (XEXP (*p, 0), 1))
-		    p = &XEXP (*p, 1);
+		    {
+		      XEXP (XEXP (*p, 0), 1)
+			= copy_rtx_if_shared (XEXP (XEXP (*p, 0), 1));
+		      p = &XEXP (*p, 1);
+		    }
 		  /* Otherwise, if the following item is data_value for it,
 		     drop it too too.  */
 		  else if (XEXP (*p, 1)
 			   && REG_P (XEXP (XEXP (*p, 0), 0))
 			   && MEM_P (XEXP (XEXP (XEXP (*p, 1), 0), 0))
 		    *p = XEXP (XEXP (*p, 1), 1);
 		  /* Just drop this item.  */
 		  else
 		    *p = XEXP (*p, 1);
 		}
-	      note = emit_note_after (NOTE_INSN_CALL_ARG_LOCATION, insn);
+	      add_reg_note (insn, REG_CALL_ARG_LOCATION, arguments);
-	      NOTE_VAR_LOCATION (note) = arguments;
 	    }
 	    break;
 	  case MO_USE:
 	    {
 /* Enable emitting notes by functions (mainly by set_variable_part and
 delete_variable_part).  */
 emit_notes = true;
-if (MAY_HAVE_DEBUG_INSNS)
+if (MAY_HAVE_DEBUG_BIND_INSNS)
-{
+dropped_values = new variable_table_type (cselib_get_next_uid () * 2);
-dropped_values = new variable_table_type (cselib_get_next_uid () * 2);
-}
 dataflow_set_init (&cur);
 FOR_EACH_BB_FN (bb, cfun)
 {
 /* Emit the notes for changes of variable locations between two
 	 subsequent basic blocks.  */
 emit_notes_for_differences (BB_HEAD (bb), &cur, &VTI (bb)->in);
-if (MAY_HAVE_DEBUG_INSNS)
+if (MAY_HAVE_DEBUG_BIND_INSNS)
 	local_get_addr_cache = new hash_map<rtx, rtx>;
 /* Emit the notes for the changes in the basic block itself.  */
 emit_notes_in_bb (bb, &cur);
-if (MAY_HAVE_DEBUG_INSNS)
+if (MAY_HAVE_DEBUG_BIND_INSNS)
 	delete local_get_addr_cache;
 local_get_addr_cache = NULL;
 /* Free memory occupied by the in hash table, we won't need it
 	 again.  */
 ->traverse <variable_table_type *, emit_notes_for_differences_1>
 	(shared_hash_htab (empty_shared_hash));
 dataflow_set_destroy (&cur);
-if (MAY_HAVE_DEBUG_INSNS)
+if (MAY_HAVE_DEBUG_BIND_INSNS)
 delete dropped_values;
 dropped_values = NULL;
 emit_notes = false;
 }
 /* If there is a declaration and offset associated with register/memory RTL
 assign declaration to *DECLP and offset to *OFFSETP, and return true.  */
 static bool
-vt_get_decl_and_offset (rtx rtl, tree *declp, HOST_WIDE_INT *offsetp)
+vt_get_decl_and_offset (rtx rtl, tree *declp, poly_int64 *offsetp)
 {
 if (REG_P (rtl))
 {
 if (REG_ATTRS (rtl))
 	{
 	    break;
 	  if (!decl)
 	    decl = REG_EXPR (reg);
 	  if (REG_EXPR (reg) != decl)
 	    break;
-	  if (REG_OFFSET (reg) < offset)
+	  HOST_WIDE_INT this_offset;
-	    offset = REG_OFFSET (reg);
+	  if (!track_offset_p (REG_OFFSET (reg), &this_offset))
+	    break;
+	  offset = MIN (offset, this_offset);
 	}
 if (i == len)
 	{
 	  *declp = decl;
 else if (MEM_P (rtl))
 {
 if (MEM_ATTRS (rtl))
 	{
 	  *declp = MEM_EXPR (rtl);
-	  *offsetp = INT_MEM_OFFSET (rtl);
+	  *offsetp = int_mem_offset (rtl);
 	  return true;
 	}
 }
 return false;
 }
 {
 rtx decl_rtl = DECL_RTL_IF_SET (parm);
 rtx incoming = DECL_INCOMING_RTL (parm);
 tree decl;
 machine_mode mode;
-HOST_WIDE_INT offset;
+poly_int64 offset;
 dataflow_set *out;
 decl_or_value dv;
+bool incoming_ok = true;
 if (TREE_CODE (parm) != PARM_DECL)
 return;
 if (!decl_rtl || !incoming)
 /* If there is a DRAP register or a pseudo in internal_arg_pointer,
 rewrite the incoming location of parameters passed on the stack
 into MEMs based on the argument pointer, so that incoming doesn't
 depend on a pseudo.  */
+poly_int64 incoming_offset = 0;
 if (MEM_P (incoming)
-&& (XEXP (incoming, 0) == crtl->args.internal_arg_pointer
+&& (strip_offset (XEXP (incoming, 0), &incoming_offset)
-	  || (GET_CODE (XEXP (incoming, 0)) == PLUS
+	  == crtl->args.internal_arg_pointer))
-	      && XEXP (XEXP (incoming, 0), 0)
-		 == crtl->args.internal_arg_pointer
-	      && CONST_INT_P (XEXP (XEXP (incoming, 0), 1)))))
 {
 HOST_WIDE_INT off = -FIRST_PARM_OFFSET (current_function_decl);
-if (GET_CODE (XEXP (incoming, 0)) == PLUS)
-	off += INTVAL (XEXP (XEXP (incoming, 0), 1));
 incoming
 	= replace_equiv_address_nv (incoming,
 				    plus_constant (Pmode,
-						   arg_pointer_rtx, off));
+						   arg_pointer_rtx,
+						   off + incoming_offset));
 }
 #ifdef HAVE_window_save
 /* DECL_INCOMING_RTL uses the INCOMING_REGNO of parameter registers.
 If the target machine has an explicit window save instruction, the
 }
 #endif
 if (!vt_get_decl_and_offset (incoming, &decl, &offset))
 {
+incoming_ok = false;
 if (MEM_P (incoming))
 	{
 	  /* This means argument is passed by invisible reference.  */
 	  offset = 0;
 	  decl = parm;
 if (decl != get_spill_slot_decl (false))
 return;
 offset = 0;
 }
-if (!track_loc_p (incoming, parm, offset, false, &mode, &offset))
+HOST_WIDE_INT const_offset;
+if (!track_loc_p (incoming, parm, offset, false, &mode, &const_offset))
 return;
 out = &VTI (ENTRY_BLOCK_PTR_FOR_FN (cfun))->out;
 dv = dv_from_decl (parm);
 /* ??? We shouldn't ever hit this, but it may happen because
 	 arguments passed by invisible reference aren't dealt with
 	 above: incoming-rtl will have Pmode rather than the
 	 expected mode for the type.  */
-if (offset)
+if (const_offset)
 	return;
 lowpart = var_lowpart (mode, incoming);
 if (!lowpart)
 	return;
 /* ??? Float-typed values in memory are not handled by
 	 cselib.  */
 if (val)
 	{
 	  preserve_value (val);
-	  set_variable_part (out, val->val_rtx, dv, offset,
+	  set_variable_part (out, val->val_rtx, dv, const_offset,
 			     VAR_INIT_STATUS_INITIALIZED, NULL, INSERT);
 	  dv = dv_from_value (val->val_rtx);
 	}
 if (MEM_P (incoming))
 if (REG_P (incoming))
 {
 incoming = var_lowpart (mode, incoming);
 gcc_assert (REGNO (incoming) < FIRST_PSEUDO_REGISTER);
-attrs_list_insert (&out->regs[REGNO (incoming)], dv, offset,
+attrs_list_insert (&out->regs[REGNO (incoming)], dv, const_offset,
 			 incoming);
-set_variable_part (out, incoming, dv, offset,
+set_variable_part (out, incoming, dv, const_offset,
 			 VAR_INIT_STATUS_INITIALIZED, NULL, INSERT);
 if (dv_is_value_p (dv))
 	{
 	  record_entry_value (CSELIB_VAL_PTR (dv_as_value (dv)), incoming);
 	  if (TREE_CODE (TREE_TYPE (parm)) == REFERENCE_TYPE
 }
 else if (GET_CODE (incoming) == PARALLEL && !dv_onepart_p (dv))
 {
 int i;
+/* The following code relies on vt_get_decl_and_offset returning true for
+	 incoming, which might not be always the case.  */
+if (!incoming_ok)
+	return;
 for (i = 0; i < XVECLEN (incoming, 0); i++)
 	{
 	  rtx reg = XEXP (XVECEXP (incoming, 0, i), 0);
-	  offset = REG_OFFSET (reg);
+	  /* vt_get_decl_and_offset has already checked that the offset
+	     is a valid variable part.  */
+	  const_offset = get_tracked_reg_offset (reg);
 	  gcc_assert (REGNO (reg) < FIRST_PSEUDO_REGISTER);
-	  attrs_list_insert (&out->regs[REGNO (reg)], dv, offset, reg);
+	  attrs_list_insert (&out->regs[REGNO (reg)], dv, const_offset, reg);
-	  set_variable_part (out, reg, dv, offset,
+	  set_variable_part (out, reg, dv, const_offset,
 			     VAR_INIT_STATUS_INITIALIZED, NULL, INSERT);
 	}
 }
 else if (MEM_P (incoming))
 {
 incoming = var_lowpart (mode, incoming);
-set_variable_part (out, incoming, dv, offset,
+set_variable_part (out, incoming, dv, const_offset,
 			 VAR_INIT_STATUS_INITIALIZED, NULL, INSERT);
 }
 }
 /* Insert function parameters to IN and OUT sets of ENTRY_BLOCK.  */
 {
 tree parm;
 for (parm = DECL_ARGUMENTS (current_function_decl);
 parm; parm = DECL_CHAIN (parm))
-if (!POINTER_BOUNDS_P (parm))
+vt_add_function_parameter (parm);
-vt_add_function_parameter (parm);
 if (DECL_HAS_VALUE_EXPR_P (DECL_RESULT (current_function_decl)))
 {
 tree vexpr = DECL_VALUE_EXPR (DECL_RESULT (current_function_decl));
 || !fixed_regs[REGNO (cfa_base_rtx)])
 {
 cfa_base_rtx = NULL_RTX;
 return;
 }
-if (!MAY_HAVE_DEBUG_INSNS)
+if (!MAY_HAVE_DEBUG_BIND_INSNS)
 return;
 /* Tell alias analysis that cfa_base_rtx should share
 find_base_term value with stack pointer or hard frame pointer.  */
 if (!frame_pointer_needed)
 				 VOIDmode, get_insns ());
 preserve_value (val);
 cselib_preserve_cfa_base_value (val, REGNO (cfa_base_rtx));
 }
+/* Reemit INSN, a MARKER_DEBUG_INSN, as a note.  */
+static rtx_insn *
+reemit_marker_as_note (rtx_insn *insn)
+{
+gcc_checking_assert (DEBUG_MARKER_INSN_P (insn));
+enum insn_note kind = INSN_DEBUG_MARKER_KIND (insn);
+switch (kind)
+{
+case NOTE_INSN_BEGIN_STMT:
+case NOTE_INSN_INLINE_ENTRY:
+{
+	rtx_insn *note = NULL;
+	if (cfun->debug_nonbind_markers)
+	  {
+	    note = emit_note_before (kind, insn);
+	    NOTE_MARKER_LOCATION (note) = INSN_LOCATION (insn);
+	  }
+	delete_insn (insn);
+	return note;
+}
+default:
+gcc_unreachable ();
+}
+}
 /* Allocate and initialize the data structures for variable tracking
 and parse the RTL to get the micro operations.  */
 static bool
 vt_initialize (void)
 {
 basic_block bb;
-HOST_WIDE_INT fp_cfa_offset = -1;
+poly_int64 fp_cfa_offset = -1;
 alloc_aux_for_blocks (sizeof (variable_tracking_info));
 empty_shared_hash = shared_hash_pool.allocate ();
 empty_shared_hash->refcount = 1;
 dataflow_set_init (&VTI (bb)->in);
 dataflow_set_init (&VTI (bb)->out);
 VTI (bb)->permp = NULL;
 }
-if (MAY_HAVE_DEBUG_INSNS)
+if (MAY_HAVE_DEBUG_BIND_INSNS)
 {
 cselib_init (CSELIB_RECORD_MEMORY | CSELIB_PRESERVE_CONSTANTS);
 scratch_regs = BITMAP_ALLOC (NULL);
 preserved_values.create (256);
 global_get_addr_cache = new hash_map<rtx, rtx>;
 {
 scratch_regs = NULL;
 global_get_addr_cache = NULL;
 }
-if (MAY_HAVE_DEBUG_INSNS)
+if (MAY_HAVE_DEBUG_BIND_INSNS)
 {
 rtx reg, expr;
 int ofst;
 cselib_val *val;
 elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
 if (elim != reg)
 	{
 	  if (GET_CODE (elim) == PLUS)
 	    {
-	      fp_cfa_offset -= INTVAL (XEXP (elim, 1));
+	      fp_cfa_offset -= rtx_to_poly_int64 (XEXP (elim, 1));
 	      elim = XEXP (elim, 0);
 	    }
 	  if (elim != hard_frame_pointer_rtx)
 	    fp_cfa_offset = -1;
 	}
 {
 rtx_insn *insn;
 HOST_WIDE_INT pre, post = 0;
 basic_block first_bb, last_bb;
-if (MAY_HAVE_DEBUG_INSNS)
+if (MAY_HAVE_DEBUG_BIND_INSNS)
 	{
 	  cselib_record_sets_hook = add_with_sets;
 	  if (dump_file && (dump_flags & TDF_DETAILS))
 	    fprintf (dump_file, "first value: %i\n",
 		     cselib_get_next_uid ());
 /* Add the micro-operations to the vector.  */
 FOR_BB_BETWEEN (bb, first_bb, last_bb->next_bb, next_bb)
 	{
 	  HOST_WIDE_INT offset = VTI (bb)->out.stack_adjust;
 	  VTI (bb)->out.stack_adjust = VTI (bb)->in.stack_adjust;
-	  for (insn = BB_HEAD (bb); insn != NEXT_INSN (BB_END (bb));
-	       insn = NEXT_INSN (insn))
+	  rtx_insn *next;
+	  FOR_BB_INSNS_SAFE (bb, insn, next)
 	    {
 	      if (INSN_P (insn))
 		{
 		  if (!frame_pointer_needed)
 		    {
 			  mo.insn = insn;
 			  if (dump_file && (dump_flags & TDF_DETAILS))
 			    log_op_type (PATTERN (insn), bb, insn,
 					 MO_ADJUST, dump_file);
 			  VTI (bb)->mos.safe_push (mo);
-			  VTI (bb)->out.stack_adjust += pre;
 			}
 		    }
 		  cselib_hook_called = false;
 		  adjust_insn (bb, insn);
-		  if (MAY_HAVE_DEBUG_INSNS)
+		  if (!frame_pointer_needed && pre)
+		    VTI (bb)->out.stack_adjust += pre;
+		  if (DEBUG_MARKER_INSN_P (insn))
+		    {
+		      reemit_marker_as_note (insn);
+		      continue;
+		    }
+		  if (MAY_HAVE_DEBUG_BIND_INSNS)
 		    {
 		      if (CALL_P (insn))
 			prepare_call_arguments (bb, insn);
 		      cselib_process_insn (insn);
 		      if (dump_file && (dump_flags & TDF_DETAILS))
 			{
-			  print_rtl_single (dump_file, insn);
+			  if (dump_flags & TDF_SLIM)
+			    dump_insn_slim (dump_file, insn);
+			  else
+			    print_rtl_single (dump_file, insn);
 			  dump_cselib_table (dump_file);
 			}
 		    }
 		  if (!cselib_hook_called)
 		    add_with_sets (insn, 0, 0);
 				     MO_ADJUST, dump_file);
 		      VTI (bb)->mos.safe_push (mo);
 		      VTI (bb)->out.stack_adjust += post;
 		    }
-		  if (fp_cfa_offset != -1
+		  if (maybe_ne (fp_cfa_offset, -1)
-		      && hard_frame_pointer_adjustment == -1
+		      && known_eq (hard_frame_pointer_adjustment, -1)
 		      && fp_setter_insn (insn))
 		    {
 		      vt_init_cfa_base ();
 		      hard_frame_pointer_adjustment = fp_cfa_offset;
 		      /* Disassociate sp from fp now.  */
-		      if (MAY_HAVE_DEBUG_INSNS)
+		      if (MAY_HAVE_DEBUG_BIND_INSNS)
 			{
 			  cselib_val *v;
 			  cselib_invalidate_rtx (stack_pointer_rtx);
 			  v = cselib_lookup (stack_pointer_rtx, Pmode, 1,
 					     VOIDmode);
 	  gcc_assert (offset == VTI (bb)->out.stack_adjust);
 	}
 bb = last_bb;
-if (MAY_HAVE_DEBUG_INSNS)
+if (MAY_HAVE_DEBUG_BIND_INSNS)
 	{
 	  cselib_preserve_only_values ();
 	  cselib_reset_table (cselib_get_next_uid ());
 	  cselib_record_sets_hook = NULL;
 	}
 NOTE_INSN_DELETED_DEBUG_LABEL in the entire compilation
 a unique label number.  */
 static int debug_label_num = 1;
-/* Get rid of all debug insns from the insn stream.  */
+/* Remove from the insn stream a single debug insn used for
+variable tracking at assignments.  */
-static void
-delete_debug_insns (void)
+static inline void
+delete_vta_debug_insn (rtx_insn *insn)
+{
+if (DEBUG_MARKER_INSN_P (insn))
+{
+reemit_marker_as_note (insn);
+return;
+}
+tree decl = INSN_VAR_LOCATION_DECL (insn);
+if (TREE_CODE (decl) == LABEL_DECL
+&& DECL_NAME (decl)
+&& !DECL_RTL_SET_P (decl))
+{
+PUT_CODE (insn, NOTE);
+NOTE_KIND (insn) = NOTE_INSN_DELETED_DEBUG_LABEL;
+NOTE_DELETED_LABEL_NAME (insn)
+	= IDENTIFIER_POINTER (DECL_NAME (decl));
+SET_DECL_RTL (decl, insn);
+CODE_LABEL_NUMBER (insn) = debug_label_num++;
+}
+else
+delete_insn (insn);
+}
+/* Remove from the insn stream all debug insns used for variable
+tracking at assignments.  USE_CFG should be false if the cfg is no
+longer usable.  */
+void
+delete_vta_debug_insns (bool use_cfg)
 {
 basic_block bb;
 rtx_insn *insn, *next;
 if (!MAY_HAVE_DEBUG_INSNS)
 return;
-FOR_EACH_BB_FN (bb, cfun)
+if (use_cfg)
-{
+FOR_EACH_BB_FN (bb, cfun)
-FOR_BB_INSNS_SAFE (bb, insn, next)
+{
+	FOR_BB_INSNS_SAFE (bb, insn, next)
+	  if (DEBUG_INSN_P (insn))
+	    delete_vta_debug_insn (insn);
+}
+else
+for (insn = get_insns (); insn; insn = next)
+{
+	next = NEXT_INSN (insn);
 	if (DEBUG_INSN_P (insn))
-	  {
+	  delete_vta_debug_insn (insn);
-	    tree decl = INSN_VAR_LOCATION_DECL (insn);
+}
-	    if (TREE_CODE (decl) == LABEL_DECL
-		&& DECL_NAME (decl)
-		&& !DECL_RTL_SET_P (decl))
-	      {
-		PUT_CODE (insn, NOTE);
-		NOTE_KIND (insn) = NOTE_INSN_DELETED_DEBUG_LABEL;
-		NOTE_DELETED_LABEL_NAME (insn)
-		  = IDENTIFIER_POINTER (DECL_NAME (decl));
-		SET_DECL_RTL (decl, insn);
-		CODE_LABEL_NUMBER (insn) = debug_label_num++;
-	      }
-	    else
-	      delete_insn (insn);
-	  }
-}
 }
 /* Run a fast, BB-local only version of var tracking, to take care of
 information that we don't do global analysis on, such that not all
 information is lost.  If SKIPPED holds, we're skipping the global
 static void
 vt_debug_insns_local (bool skipped ATTRIBUTE_UNUSED)
 {
 /* ??? Just skip it all for now.  */
-delete_debug_insns ();
+delete_vta_debug_insns (true);
 }
 /* Free the data structures needed for variable tracking.  */
 static void
 attrs_pool.release ();
 var_pool.release ();
 location_chain_pool.release ();
 shared_hash_pool.release ();
-if (MAY_HAVE_DEBUG_INSNS)
+if (MAY_HAVE_DEBUG_BIND_INSNS)
 {
 if (global_get_addr_cache)
 	delete global_get_addr_cache;
 global_get_addr_cache = NULL;
 loc_exp_dep_pool.release ();
 static inline unsigned int
 variable_tracking_main_1 (void)
 {
 bool success;
-if (flag_var_tracking_assignments < 0
+/* We won't be called as a separate pass if flag_var_tracking is not
+set, but final may call us to turn debug markers into notes.  */
+if ((!flag_var_tracking && MAY_HAVE_DEBUG_INSNS)
+|| flag_var_tracking_assignments < 0
 /* Var-tracking right now assumes the IR doesn't contain
 	 any pseudos at this point.  */
 || targetm.no_register_allocation)
 {
-delete_debug_insns ();
+delete_vta_debug_insns (true);
 return 0;
 }
-if (n_basic_blocks_for_fn (cfun) > 500 &&
+if (!flag_var_tracking)
-n_edges_for_fn (cfun) / n_basic_blocks_for_fn (cfun) >= 20)
+return 0;
+if (n_basic_blocks_for_fn (cfun) > 500
+&& n_edges_for_fn (cfun) / n_basic_blocks_for_fn (cfun) >= 20)
 {
 vt_debug_insns_local (true);
 return 0;
 }
 if (!success && flag_var_tracking_assignments > 0)
 {
 vt_finalize ();
-delete_debug_insns ();
+delete_vta_debug_insns (true);
 /* This is later restored by our caller.  */
 flag_var_tracking_assignments = 0;
 success = vt_initialize ();

Mercurial > hg > CbC > CbC_gcc

comparison gcc/var-tracking.c @ 132:d34655255c78