CbC/CbC_gcc: gcc/cfgexpand.c comparison

comparison gcc/cfgexpand.c @ 132:d34655255c78

update gcc-8.2

author	mir3636
date	Thu, 25 Oct 2018 10:21:07 +0900
parents	f81c5aa9f14f 84e7813d76e9
children	4e440907fcbf

comparison

equal deleted inserted replaced

-:e108057fa461
+:d34655255c78
 /* A pass for lowering trees to RTL.
-Copyright (C) 2004-2017 Free Software Foundation, Inc.
+Copyright (C) 2004-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 "attribs.h"
 #include "asan.h"
 #include "tree-ssa-address.h"
 #include "output.h"
 #include "builtins.h"
-#include "tree-chkp.h"
-#include "rtl-chkp.h"
 /* Some systems use __main in a way incompatible with its use in gcc, in these
 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
 give the same symbol without quotes for an alternative entry point.  You
 must define both, or neither.  */
 /* The Variable.  */
 tree decl;
 /* Initially, the size of the variable.  Later, the size of the partition,
 if this variable becomes it's partition's representative.  */
-HOST_WIDE_INT size;
+poly_uint64 size;
 /* The *byte* alignment required for this variable.  Or as, with the
 size, the alignment for this partition.  */
 unsigned int alignb;
 }
 /* Allocate SIZE bytes at byte alignment ALIGN from the stack frame.
 Return the frame offset.  */
-static HOST_WIDE_INT
+static poly_int64
-alloc_stack_frame_space (HOST_WIDE_INT size, unsigned HOST_WIDE_INT align)
+alloc_stack_frame_space (poly_int64 size, unsigned HOST_WIDE_INT align)
 {
-HOST_WIDE_INT offset, new_frame_offset;
+poly_int64 offset, new_frame_offset;
 if (FRAME_GROWS_DOWNWARD)
 {
 new_frame_offset
-	= align_base (frame_offset - frame_phase - size,
+	= aligned_lower_bound (frame_offset - frame_phase - size,
-		      align, false) + frame_phase;
+			       align) + frame_phase;
 offset = new_frame_offset;
 }
 else
 {
 new_frame_offset
-	= align_base (frame_offset - frame_phase, align, true) + frame_phase;
+	= aligned_upper_bound (frame_offset - frame_phase,
+			       align) + frame_phase;
 offset = new_frame_offset;
 new_frame_offset += size;
 }
 frame_offset = new_frame_offset;
 v->decl = decl;
 tree size = TREE_CODE (decl) == SSA_NAME
 ? TYPE_SIZE_UNIT (TREE_TYPE (decl))
 : DECL_SIZE_UNIT (decl);
-v->size = tree_to_uhwi (size);
+v->size = tree_to_poly_uint64 (size);
 /* Ensure that all variables have size, so that &a != &b for any two
 variables that are simultaneously live.  */
-if (v->size == 0)
+if (known_eq (v->size, 0U))
 v->size = 1;
 v->alignb = align_local_variable (decl);
 /* An alignment of zero can mightily confuse us later.  */
 gcc_assert (v->alignb != 0);
 {
 size_t ia = *(const size_t *)a;
 size_t ib = *(const size_t *)b;
 unsigned int aligna = stack_vars[ia].alignb;
 unsigned int alignb = stack_vars[ib].alignb;
-HOST_WIDE_INT sizea = stack_vars[ia].size;
+poly_int64 sizea = stack_vars[ia].size;
-HOST_WIDE_INT sizeb = stack_vars[ib].size;
+poly_int64 sizeb = stack_vars[ib].size;
 tree decla = stack_vars[ia].decl;
 tree declb = stack_vars[ib].decl;
 bool largea, largeb;
 unsigned int uida, uidb;
 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)
+int diff = compare_sizes_for_sort (sizeb, sizea);
-return -1;
+if (diff != 0)
-if (sizea < sizeb)
+return diff;
-return 1;
 /* Tertiary compare on true alignment, decreasing.  */
 if (aligna < alignb)
 return -1;
 if (aligna > alignb)
 for (si = 0; si < n; ++si)
 {
 size_t i = stack_vars_sorted[si];
 unsigned int ialign = stack_vars[i].alignb;
-HOST_WIDE_INT isize = stack_vars[i].size;
+poly_int64 isize = stack_vars[i].size;
 /* Ignore objects that aren't partition representatives. If we
 see a var that is not a partition representative, it must
 have been merged earlier.  */
 if (stack_vars[i].representative != i)
 for (sj = si + 1; sj < n; ++sj)
 	{
 	  size_t j = stack_vars_sorted[sj];
 	  unsigned int jalign = stack_vars[j].alignb;
-	  HOST_WIDE_INT jsize = stack_vars[j].size;
+	  poly_int64 jsize = stack_vars[j].size;
 	  /* Ignore objects that aren't partition representatives.  */
 	  if (stack_vars[j].representative != j)
 	    continue;
 	  /* For Address Sanitizer do not mix objects with different
 	     sizes, as the shorter vars wouldn't be adequately protected.
 	     Don't do that for "large" (unsupported) alignment objects,
 	     those aren't protected anyway.  */
-	  if ((asan_sanitize_stack_p ())
+	  if (asan_sanitize_stack_p ()
-	      && isize != jsize
+	      && maybe_ne (isize, jsize)
 	      && ialign * BITS_PER_UNIT <= MAX_SUPPORTED_STACK_ALIGNMENT)
 	    break;
 	  /* Ignore conflicting objects.  */
 	  if (stack_var_conflict_p (i, j))
 /* Skip variables that aren't partition representatives, for now.  */
 if (stack_vars[i].representative != i)
 	continue;
-fprintf (dump_file, "Partition %lu: size " HOST_WIDE_INT_PRINT_DEC
+fprintf (dump_file, "Partition %lu: size ", (unsigned long) i);
-	       " align %u\n", (unsigned long) i, stack_vars[i].size,
+print_dec (stack_vars[i].size, dump_file);
-	       stack_vars[i].alignb);
+fprintf (dump_file, " align %u\n", stack_vars[i].alignb);
 for (j = i; j != EOC; j = stack_vars[j].next)
 	{
 	  fputc ('\t', dump_file);
 	  print_generic_expr (dump_file, stack_vars[j].decl, dump_flags);
 /* Assign rtl to DECL at BASE + OFFSET.  */
 static void
 expand_one_stack_var_at (tree decl, rtx base, unsigned base_align,
-			 HOST_WIDE_INT offset)
+			 poly_int64 offset)
 {
 unsigned align;
 rtx x;
 /* If this fails, we've overflowed the stack frame.  Error nicely?  */
-gcc_assert (offset == trunc_int_for_mode (offset, Pmode));
+gcc_assert (known_eq (offset, trunc_int_for_mode (offset, Pmode)));
 x = plus_constant (Pmode, base, offset);
 x = gen_rtx_MEM (TREE_CODE (decl) == SSA_NAME
 		   ? TYPE_MODE (TREE_TYPE (decl))
 		   : DECL_MODE (SSAVAR (decl)), x);
 /* 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.  */
 if (base == virtual_stack_vars_rtx)
 	offset -= frame_phase;
-align = least_bit_hwi (offset);
+align = known_alignment (offset);
 align *= BITS_PER_UNIT;
 if (align == 0 || align > base_align)
 	align = base_align;
 /* One would think that we could assert that we're not decreasing
 static void
 expand_stack_vars (bool (*pred) (size_t), struct stack_vars_data *data)
 {
 size_t si, i, j, n = stack_vars_num;
-HOST_WIDE_INT large_size = 0, large_alloc = 0;
+poly_uint64 large_size = 0, large_alloc = 0;
 rtx large_base = NULL;
 unsigned large_align = 0;
 bool large_allocation_done = false;
 tree decl;
 	  if (TREE_CODE (decl) == SSA_NAME
 	      ? SA.partition_to_pseudo[var_to_partition (SA.map, decl)] != NULL_RTX
 	      : DECL_RTL (decl) != pc_rtx)
 	    continue;
-	  large_size += alignb - 1;
+	  large_size = aligned_upper_bound (large_size, alignb);
-	  large_size &= -(HOST_WIDE_INT)alignb;
 	  large_size += stack_vars[i].size;
 	}
 }
 for (si = 0; si < n; ++si)
 {
 rtx base;
 unsigned base_align, alignb;
-HOST_WIDE_INT offset;
+poly_int64 offset;
 i = stack_vars_sorted[si];
 /* Skip variables that aren't partition representatives, for now.  */
 if (stack_vars[i].representative != i)
 alignb = stack_vars[i].alignb;
 if (alignb * BITS_PER_UNIT <= MAX_SUPPORTED_STACK_ALIGNMENT)
 	{
 	  base = virtual_stack_vars_rtx;
-	  if ((asan_sanitize_stack_p ())
+	  /* ASAN description strings don't yet have a syntax for expressing
-	      && pred)
+	     polynomial offsets.  */
+	  HOST_WIDE_INT prev_offset;
+	  if (asan_sanitize_stack_p ()
+	      && pred
+	      && frame_offset.is_constant (&prev_offset)
+	      && stack_vars[i].size.is_constant ())
 	    {
-	      HOST_WIDE_INT prev_offset
+	      prev_offset = align_base (prev_offset,
-		= align_base (frame_offset,
+					MAX (alignb, ASAN_RED_ZONE_SIZE),
-			      MAX (alignb, ASAN_RED_ZONE_SIZE),
+					!FRAME_GROWS_DOWNWARD);
-			      !FRAME_GROWS_DOWNWARD);
 	      tree repr_decl = NULL_TREE;
 	      offset
 		= alloc_stack_frame_space (stack_vars[i].size
 					   + ASAN_RED_ZONE_SIZE,
 					   MAX (alignb, ASAN_RED_ZONE_SIZE));
 	      data->asan_vec.safe_push (prev_offset);
-	      data->asan_vec.safe_push (offset + stack_vars[i].size);
+	      /* Allocating a constant amount of space from a constant
+		 starting offset must give a constant result.  */
+	      data->asan_vec.safe_push ((offset + stack_vars[i].size)
+					.to_constant ());
 	      /* Find best representative of the partition.
 		 Prefer those with DECL_NAME, even better
 		 satisfying asan_protect_stack_decl predicate.  */
 	      for (j = i; j != EOC; j = stack_vars[j].next)
 		if (asan_protect_stack_decl (stack_vars[j].decl)
 			 && DECL_NAME (stack_vars[j].decl))
 		  repr_decl = stack_vars[j].decl;
 	      if (repr_decl == NULL_TREE)
 		repr_decl = stack_vars[i].decl;
 	      data->asan_decl_vec.safe_push (repr_decl);
+	      /* Make sure a representative is unpoison if another
+		 variable in the partition is handled by
+		 use-after-scope sanitization.  */
+	      if (asan_handled_variables != NULL
+		  && !asan_handled_variables->contains (repr_decl))
+		{
+		  for (j = i; j != EOC; j = stack_vars[j].next)
+		    if (asan_handled_variables->contains (stack_vars[j].decl))
+		      break;
+		  if (j != EOC)
+		    asan_handled_variables->add (repr_decl);
+		}
 	      data->asan_alignb = MAX (data->asan_alignb, alignb);
 	      if (data->asan_base == NULL)
 		data->asan_base = gen_reg_rtx (Pmode);
 	      base = data->asan_base;
 	  if (pred)
 	    continue;
 	  /* If there were any variables requiring "large" alignment, allocate
 	     space.  */
-	  if (large_size > 0 && ! large_allocation_done)
+	  if (maybe_ne (large_size, 0U) && ! large_allocation_done)
 	    {
-	      HOST_WIDE_INT loffset;
+	      poly_int64 loffset;
 	      rtx large_allocsize;
-	      large_allocsize = GEN_INT (large_size);
+	      large_allocsize = gen_int_mode (large_size, Pmode);
 	      get_dynamic_stack_size (&large_allocsize, 0, large_align, NULL);
 	      loffset = alloc_stack_frame_space
-		(INTVAL (large_allocsize),
+		(rtx_to_poly_int64 (large_allocsize),
 		 PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT);
 	      large_base = get_dynamic_stack_base (loffset, large_align);
 	      large_allocation_done = true;
 	    }
 	  gcc_assert (large_base != NULL);
-	  large_alloc += alignb - 1;
+	  large_alloc = aligned_upper_bound (large_alloc, alignb);
-	  large_alloc &= -(HOST_WIDE_INT)alignb;
 	  offset = large_alloc;
 	  large_alloc += stack_vars[i].size;
 	  base = large_base;
 	  base_align = large_align;
 				   base, base_align,
 				   offset);
 	}
 }
-gcc_assert (large_alloc == large_size);
+gcc_assert (known_eq (large_alloc, large_size));
 }
 /* Take into account all sizes of partitions and reset DECL_RTLs.  */
-static HOST_WIDE_INT
+static poly_uint64
 account_stack_vars (void)
 {
 size_t si, j, i, n = stack_vars_num;
-HOST_WIDE_INT size = 0;
+poly_uint64 size = 0;
 for (si = 0; si < n; ++si)
 {
 i = stack_vars_sorted[si];
 /* If the variable alignment is very large we'll dynamicaly
 	 allocate it, which means that in-frame portion is just a
 	 pointer.  ??? We've got a pseudo for sure here, do we
 	 actually dynamically allocate its spilling area if needed?
-	 ??? Isn't it a problem when POINTER_SIZE also exceeds
+	 ??? Isn't it a problem when Pmode alignment also exceeds
-	 MAX_SUPPORTED_STACK_ALIGNMENT, as on cris and lm32?  */
+	 MAX_SUPPORTED_STACK_ALIGNMENT, as can happen on cris and lm32?  */
 if (align > MAX_SUPPORTED_STACK_ALIGNMENT)
-	align = POINTER_SIZE;
+	align = GET_MODE_ALIGNMENT (Pmode);
 record_alignment_for_reg_var (align);
 }
 tree ssa = ssa_default_def (cfun, parm);
 to a variable to be allocated in the stack frame.  */
 static void
 expand_one_stack_var_1 (tree var)
 {
-HOST_WIDE_INT size, offset;
+poly_uint64 size;
+poly_int64 offset;
 unsigned byte_align;
 if (TREE_CODE (var) == SSA_NAME)
 {
 tree type = TREE_TYPE (var);
-size = tree_to_uhwi (TYPE_SIZE_UNIT (type));
+size = tree_to_poly_uint64 (TYPE_SIZE_UNIT (type));
 byte_align = TYPE_ALIGN_UNIT (type);
 }
 else
 {
-size = tree_to_uhwi (DECL_SIZE_UNIT (var));
+size = tree_to_poly_uint64 (DECL_SIZE_UNIT (var));
 byte_align = align_local_variable (var);
 }
 /* We handle highly aligned variables in expand_stack_vars.  */
 gcc_assert (byte_align * BITS_PER_UNIT <= MAX_SUPPORTED_STACK_ALIGNMENT);
 					  TYPE_ALIGN (TREE_TYPE (var)));
 /* If the variable alignment is very large we'll dynamicaly allocate
 it, which means that in-frame portion is just a pointer.  */
 if (align > MAX_SUPPORTED_STACK_ALIGNMENT)
-align = POINTER_SIZE;
+align = GET_MODE_ALIGNMENT (Pmode);
 record_alignment_for_reg_var (align);
 if (!use_register_for_decl (var))
 {
 defer_stack_allocation (tree var, bool toplevel)
 {
 tree size_unit = TREE_CODE (var) == SSA_NAME
 ? TYPE_SIZE_UNIT (TREE_TYPE (var))
 : DECL_SIZE_UNIT (var);
+poly_uint64 size;
 /* Whether the variable is small enough for immediate allocation not to be
 a problem with regard to the frame size.  */
 bool smallish
-= ((HOST_WIDE_INT) tree_to_uhwi (size_unit)
+= (poly_int_tree_p (size_unit, &size)
-< PARAM_VALUE (PARAM_MIN_SIZE_FOR_STACK_SHARING));
+&& (estimated_poly_value (size)
+	   < PARAM_VALUE (PARAM_MIN_SIZE_FOR_STACK_SHARING)));
 /* 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.
 Similarly for Address Sanitizer.  */
 if (flag_stack_protect || asan_sanitize_stack_p ())
 expanded yet, merely recorded.
 When REALLY_EXPAND is false, only add stack values to be allocated.
 Return stack usage this variable is supposed to take.
 */
-static HOST_WIDE_INT
+static poly_uint64
 expand_one_var (tree var, bool toplevel, bool really_expand)
 {
 unsigned int align = BITS_PER_UNIT;
 tree origvar = var;
 	align = MINIMUM_ALIGNMENT (var, DECL_MODE (var), DECL_ALIGN (var));
 /* If the variable alignment is very large we'll dynamicaly allocate
 	 it, which means that in-frame portion is just a pointer.  */
 if (align > MAX_SUPPORTED_STACK_ALIGNMENT)
-	align = POINTER_SIZE;
+	align = GET_MODE_ALIGNMENT (Pmode);
 }
 record_alignment_for_reg_var (align);
+poly_uint64 size;
 if (TREE_CODE (origvar) == SSA_NAME)
 {
 gcc_assert (!VAR_P (var)
 		  || (!DECL_EXTERNAL (var)
 		      && !DECL_HAS_VALUE_EXPR_P (var)
 else if (use_register_for_decl (var))
 {
 if (really_expand)
 expand_one_register_var (origvar);
 }
-else if (! valid_constant_size_p (DECL_SIZE_UNIT (var)))
+else if (!poly_int_tree_p (DECL_SIZE_UNIT (var), &size)
+	   || !valid_constant_size_p (DECL_SIZE_UNIT (var)))
 {
 /* Reject variables which cover more than half of the address-space.  */
 if (really_expand)
 	{
-	  error ("size of variable %q+D is too large", var);
+	  if (DECL_NONLOCAL_FRAME (var))
+	    error_at (DECL_SOURCE_LOCATION (current_function_decl),
+		      "total size of local objects is too large");
+	  else
+	    error_at (DECL_SOURCE_LOCATION (var),
+		      "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);
 error ("cannot allocate stack for variable %q+D, naked function.",
 var);
 expand_one_stack_var (origvar);
 }
+return size;
-return tree_to_uhwi (DECL_SIZE_UNIT (var));
 }
 return 0;
 }
 /* A subroutine of expand_used_vars.  Walk down through the BLOCK tree
 happen very often.  */
 HOST_WIDE_INT
 estimated_stack_frame_size (struct cgraph_node *node)
 {
-HOST_WIDE_INT size = 0;
+poly_int64 size = 0;
 size_t i;
 tree var;
 struct function *fn = DECL_STRUCT_FUNCTION (node->decl);
 push_cfun (fn);
 size += account_stack_vars ();
 }
 fini_vars_expansion ();
 pop_cfun ();
-return size;
+return estimated_poly_value (size);
 }
 /* Helper routine to check if a record or union contains an array field. */
 static int
 if (asan_sanitize_stack_p ())
 	/* Phase 3, any partitions that need asan protection
 	   in addition to phase 1 and 2.  */
 	expand_stack_vars (asan_decl_phase_3, &data);
-if (!data.asan_vec.is_empty ())
+/* ASAN description strings don't yet have a syntax for expressing
-	{
+	 polynomial offsets.  */
-	  HOST_WIDE_INT prev_offset = frame_offset;
+HOST_WIDE_INT prev_offset;
+if (!data.asan_vec.is_empty ()
+	  && frame_offset.is_constant (&prev_offset))
+	{
 	  HOST_WIDE_INT offset, sz, redzonesz;
 	  redzonesz = ASAN_RED_ZONE_SIZE;
 	  sz = data.asan_vec[0] - prev_offset;
 	  if (data.asan_alignb > ASAN_RED_ZONE_SIZE
 	      && data.asan_alignb <= 4096
 	      && sz + ASAN_RED_ZONE_SIZE >= (int) data.asan_alignb)
 	    redzonesz = ((sz + ASAN_RED_ZONE_SIZE + data.asan_alignb - 1)
 			 & ~(data.asan_alignb - HOST_WIDE_INT_1)) - sz;
-	  offset
+	  /* Allocating a constant amount of space from a constant
-	    = alloc_stack_frame_space (redzonesz, ASAN_RED_ZONE_SIZE);
+	     starting offset must give a constant result.  */
+	  offset = (alloc_stack_frame_space (redzonesz, ASAN_RED_ZONE_SIZE)
+		    .to_constant ());
 	  data.asan_vec.safe_push (prev_offset);
 	  data.asan_vec.safe_push (offset);
 	  /* Leave space for alignment if STRICT_ALIGNMENT.  */
 	  if (STRICT_ALIGNMENT)
 	    alloc_stack_frame_space ((GET_MODE_ALIGNMENT (SImode)
 /* 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;
-if (!FRAME_GROWS_DOWNWARD)
+if (FRAME_GROWS_DOWNWARD)
-	frame_offset += align - 1;
+	frame_offset = aligned_lower_bound (frame_offset, align);
-frame_offset &= -align;
+else
+	frame_offset = aligned_upper_bound (frame_offset, align);
 }
 return var_end_seq;
 }
 		}
 	    }
 	}
 }
+/* Optimize (x % C1) == C2 or (x % C1) != C2 if it is beneficial
+into (x - C2) * C3 < C4.  */
+if ((code == EQ_EXPR || code == NE_EXPR)
+&& TREE_CODE (op0) == SSA_NAME
+&& TREE_CODE (op1) == INTEGER_CST)
+code = maybe_optimize_mod_cmp (code, &op0, &op1);
 last2 = last = get_last_insn ();
 extract_true_false_edges_from_block (bb, &true_edge, &false_edge);
 set_curr_insn_location (gimple_location (stmt));
 new_bb = create_basic_block (NEXT_INSN (last), get_last_insn (), bb);
 dest = false_edge->dest;
 redirect_edge_succ (false_edge, new_bb);
 false_edge->flags |= EDGE_FALLTHRU;
 new_bb->count = false_edge->count ();
-new_bb->frequency = EDGE_FREQUENCY (false_edge);
 loop_p loop = find_common_loop (bb->loop_father, dest->loop_father);
 add_bb_to_loop (new_bb, loop);
 if (loop->latch == bb
 && loop->header == dest)
 loop->latch = new_bb;
 }
 exp = build_vl_exp (CALL_EXPR, gimple_call_num_args (stmt) + 3);
 CALL_EXPR_FN (exp) = gimple_call_fn (stmt);
-builtin_p = decl && DECL_BUILT_IN (decl);
+builtin_p = decl && fndecl_built_in_p (decl);
 /* If this is not a builtin function, the function type through which the
 call is made may be different from the type of the function.  */
 if (!builtin_p)
 CALL_EXPR_FN (exp)
 TREE_SIDE_EFFECTS (exp) = 1;
 if (gimple_call_nothrow_p (stmt))
 TREE_NOTHROW (exp) = 1;
+if (gimple_no_warning_p (stmt))
+TREE_NO_WARNING (exp) = 1;
 CALL_EXPR_TAILCALL (exp) = gimple_call_tail_p (stmt);
 CALL_EXPR_MUST_TAIL_CALL (exp) = gimple_call_must_tail_p (stmt);
 CALL_EXPR_RETURN_SLOT_OPT (exp) = gimple_call_return_slot_opt_p (stmt);
 if (decl
-&& DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
+&& fndecl_built_in_p (decl, BUILT_IN_NORMAL)
 && ALLOCA_FUNCTION_CODE_P (DECL_FUNCTION_CODE (decl)))
 CALL_ALLOCA_FOR_VAR_P (exp) = gimple_call_alloca_for_var_p (stmt);
 else
 CALL_FROM_THUNK_P (exp) = gimple_call_from_thunk_p (stmt);
 CALL_EXPR_VA_ARG_PACK (exp) = gimple_call_va_arg_pack_p (stmt);
 CALL_EXPR_BY_DESCRIPTOR (exp) = gimple_call_by_descriptor_p (stmt);
 SET_EXPR_LOCATION (exp, gimple_location (stmt));
-CALL_WITH_BOUNDS_P (exp) = gimple_call_with_bounds_p (stmt);
 /* Ensure RTL is created for debug args.  */
 if (decl && DECL_HAS_DEBUG_ARGS_P (decl))
 {
 vec<tree, va_gc> **debug_args = decl_debug_args_lookup (decl);
 	 Make the asm insn write into that, then we will copy it to
 	 the real output operand.  Likewise for promoted variables.  */
 generating_concat_p = 0;
-if ((TREE_CODE (val) == INDIRECT_REF
+if ((TREE_CODE (val) == INDIRECT_REF && allows_mem)
-	   && allows_mem)
 	  || (DECL_P (val)
 	      && (allows_mem || REG_P (DECL_RTL (val)))
 	      && ! (REG_P (DECL_RTL (val))
 		    && GET_MODE (DECL_RTL (val)) != TYPE_MODE (type)))
 	  || ! allows_reg
-	  || is_inout)
+	  || is_inout
+	  || TREE_ADDRESSABLE (type))
 	{
 	  op = expand_expr (val, NULL_RTX, VOIDmode,
 			    !allows_reg ? EXPAND_MEMORY : EXPAND_WRITE);
 	  if (MEM_P (op))
 	    op = validize_mem (op);
 	  if (! allows_reg && !MEM_P (op))
 	    error ("output number %d not directly addressable", i);
-	  if ((! allows_mem && MEM_P (op))
+	  if ((! allows_mem && MEM_P (op) && GET_MODE (op) != BLKmode)
 	      || GET_CODE (op) == CONCAT)
 	    {
 	      rtx old_op = op;
 	      op = gen_reg_rtx (GET_MODE (op));
 	  /* If asm goto has any labels in the fallthru basic block, use
 	     a label that we emit immediately after the asm goto.  Expansion
 	     may insert further instructions into the same basic block after
 	     asm goto and if we don't do this, insertion of instructions on
 	     the fallthru edge might misbehave.  See PR58670.  */
-	  if (fallthru_bb && label_to_block_fn (cfun, label) == fallthru_bb)
+	  if (fallthru_bb && label_to_block (cfun, label) == fallthru_bb)
 	    {
 	      if (fallthru_label == NULL_RTX)
 	        fallthru_label = gen_label_rtx ();
 	      r = fallthru_label;
 	    }
 /* Generate RTL to evaluate the expression RETVAL and return it
 from the current function.  */
 static void
-expand_return (tree retval, tree bounds)
+expand_return (tree retval)
 {
 rtx result_rtl;
 rtx val = 0;
 tree retval_rhs;
-rtx bounds_rtl;
 /* If function wants no value, give it none.  */
 if (TREE_CODE (TREE_TYPE (TREE_TYPE (current_function_decl))) == VOID_TYPE)
 {
 expand_normal (retval);
 else
 retval_rhs = retval;
 result_rtl = DECL_RTL (DECL_RESULT (current_function_decl));
-/* Put returned bounds to the right place.  */
-bounds_rtl = DECL_BOUNDS_RTL (DECL_RESULT (current_function_decl));
-if (bounds_rtl)
-{
-rtx addr = NULL;
-rtx bnd = NULL;
-if (bounds && bounds != error_mark_node)
-	{
-	  bnd = expand_normal (bounds);
-	  targetm.calls.store_returned_bounds (bounds_rtl, bnd);
-	}
-else if (REG_P (bounds_rtl))
-	{
-	  if (bounds)
-	    bnd = chkp_expand_zero_bounds ();
-	  else
-	    {
-	      addr = expand_normal (build_fold_addr_expr (retval_rhs));
-	      addr = gen_rtx_MEM (Pmode, addr);
-	      bnd = targetm.calls.load_bounds_for_arg (addr, NULL, NULL);
-	    }
-	  targetm.calls.store_returned_bounds (bounds_rtl, bnd);
-	}
-else
-	{
-	  int n;
-	  gcc_assert (GET_CODE (bounds_rtl) == PARALLEL);
-	  if (bounds)
-	    bnd = chkp_expand_zero_bounds ();
-	  else
-	    {
-	      addr = expand_normal (build_fold_addr_expr (retval_rhs));
-	      addr = gen_rtx_MEM (Pmode, addr);
-	    }
-	  for (n = 0; n < XVECLEN (bounds_rtl, 0); n++)
-	    {
-	      rtx slot = XEXP (XVECEXP (bounds_rtl, 0, n), 0);
-	      if (!bounds)
-		{
-		  rtx offs = XEXP (XVECEXP (bounds_rtl, 0, n), 1);
-		  rtx from = adjust_address (addr, Pmode, INTVAL (offs));
-		  bnd = targetm.calls.load_bounds_for_arg (from, NULL, NULL);
-		}
-	      targetm.calls.store_returned_bounds (slot, bnd);
-	    }
-	}
-}
-else if (chkp_function_instrumented_p (current_function_decl)
-	   && !BOUNDED_P (retval_rhs)
-	   && chkp_type_has_pointer (TREE_TYPE (retval_rhs))
-	   && TREE_CODE (retval_rhs) != RESULT_DECL)
-{
-rtx addr = expand_normal (build_fold_addr_expr (retval_rhs));
-addr = gen_rtx_MEM (Pmode, addr);
-gcc_assert (MEM_P (result_rtl));
-chkp_copy_bounds_for_stack_parm (result_rtl, addr, TREE_TYPE (retval_rhs));
-}
 /* If we are returning the RESULT_DECL, then the value has already
 been stored into it, so we don't have to do anything special.  */
 if (TREE_CODE (retval_rhs) == RESULT_DECL)
 expand_value_return (result_rtl);
 else
 {
 /* No hard reg used; calculate value into hard return reg.  */
 expand_expr (retval, const0_rtx, VOIDmode, EXPAND_NORMAL);
 expand_value_return (result_rtl);
+}
+}
+/* Expand a clobber of LHS.  If LHS is stored it in a multi-part
+register, tell the rtl optimizers that its value is no longer
+needed.  */
+static void
+expand_clobber (tree lhs)
+{
+if (DECL_P (lhs))
+{
+rtx decl_rtl = DECL_RTL_IF_SET (lhs);
+if (decl_rtl && REG_P (decl_rtl))
+	{
+	  machine_mode decl_mode = GET_MODE (decl_rtl);
+	  if (maybe_gt (GET_MODE_SIZE (decl_mode),
+			REGMODE_NATURAL_SIZE (decl_mode)))
+	    emit_clobber (decl_rtl);
+	}
 }
 }
 /* A subroutine of expand_gimple_stmt, expanding one gimple statement
 STMT that doesn't require special handling for outgoing edges.  That
 expand_call_stmt (as_a <gcall *> (stmt));
 break;
 case GIMPLE_RETURN:
 {
-	tree bnd = gimple_return_retbnd (as_a <greturn *> (stmt));
 	op0 = gimple_return_retval (as_a <greturn *> (stmt));
 	if (op0 && op0 != error_mark_node)
 	  {
 	    tree result = DECL_RESULT (current_function_decl);
-	    /* Mark we have return statement with missing bounds.  */
-	    if (!bnd
-		&& chkp_function_instrumented_p (cfun->decl)
-		&& !DECL_P (op0))
-	      bnd = error_mark_node;
 	    /* If we are not returning the current function's RESULT_DECL,
 	       build an assignment to it.  */
 	    if (op0 != result)
 	      {
 	  }
 	if (!op0)
 	  expand_null_return ();
 	else
-	  expand_return (op0, bnd);
+	  expand_return (op0);
 }
 break;
 case GIMPLE_ASSIGN:
 {
 		&& !is_gimple_min_invariant (rhs))
 	      SET_EXPR_LOCATION (rhs, gimple_location (stmt));
 	    if (TREE_CLOBBER_P (rhs))
 	      /* This is a clobber to mark the going out of scope for
 		 this LHS.  */
-	      ;
+	      expand_clobber (lhs);
 	    else
 	      expand_assignment (lhs, rhs,
 				 gimple_assign_nontemporal_move_p (
 				   assign_stmt));
 	  }
 	{
 	  if (! find_reg_note (insn, REG_EH_REGION, NULL_RTX)
 	      /* If we want exceptions for non-call insns, any
 		 may_trap_p instruction may throw.  */
 	      && GET_CODE (PATTERN (insn)) != CLOBBER
+	      && GET_CODE (PATTERN (insn)) != CLOBBER_HIGH
 	      && GET_CODE (PATTERN (insn)) != USE
 	      && insn_could_throw_p (insn))
 	    make_reg_eh_region_note (insn, 0, lp_nr);
 	}
 }
 for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
 {
 if (!(e->flags & (EDGE_ABNORMAL | EDGE_EH)))
 	{
 	  if (e->dest != EXIT_BLOCK_PTR_FOR_FN (cfun))
-	    {
+	    e->dest->count -= e->count ();
-	      e->dest->frequency -= EDGE_FREQUENCY (e);
-	      if (e->dest->frequency < 0)
-		e->dest->frequency = 0;
-	    }
 	  probability += e->probability;
 	  remove_edge (e);
 	}
 else
 	ei_next (&ei);
 	case COND_EXPR:
 	case DOT_PROD_EXPR:
 	case SAD_EXPR:
 	case WIDEN_MULT_PLUS_EXPR:
 	case WIDEN_MULT_MINUS_EXPR:
-	case FMA_EXPR:
 	  goto ternary;
 	case TRUTH_ANDIF_EXPR:
 	case TRUTH_ORIF_EXPR:
 	case TRUTH_AND_EXPR:
 	return NULL_RTX;
 /* Fall through.  */
 binary:
 case tcc_binary:
+if (mode == BLKmode)
+	return NULL_RTX;
 op1 = expand_debug_expr (TREE_OPERAND (exp, 1));
 if (!op1)
 	return NULL_RTX;
 switch (TREE_CODE (exp))
 	{
 	}
 /* Fall through.  */
 unary:
 case tcc_unary:
+if (mode == BLKmode)
+	return NULL_RTX;
 inner_mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
 op0 = expand_debug_expr (TREE_OPERAND (exp, 0));
 if (!op0)
 	return NULL_RTX;
 break;
 case INTEGER_CST:
 case REAL_CST:
 case FIXED_CST:
 op0 = expand_expr (exp, NULL_RTX, mode, EXPAND_INITIALIZER);
 return op0;
+case POLY_INT_CST:
+return immed_wide_int_const (poly_int_cst_value (exp), mode);
 case COMPLEX_CST:
 gcc_assert (COMPLEX_MODE_P (mode));
 op0 = expand_debug_expr (TREE_REALPART (exp));
 op1 = expand_debug_expr (TREE_IMAGPART (exp));
 	    /* (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))
+	  poly_int64 offset;
+	  if (!op1 || !poly_int_rtx_p (op1, &offset))
 	    return NULL;
-	  op0 = plus_constant (inner_mode, op0, INTVAL (op1));
+	  op0 = plus_constant (inner_mode, op0, offset);
 	}
 as = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp, 0))));
 op0 = convert_debug_memory_address (targetm.addr_space.address_mode (as),
 case REALPART_EXPR:
 case IMAGPART_EXPR:
 case VIEW_CONVERT_EXPR:
 {
 	machine_mode mode1;
-	HOST_WIDE_INT bitsize, bitpos;
+	poly_int64 bitsize, bitpos;
 	tree offset;
 	int reversep, volatilep = 0;
 	tree tem
 	  = get_inner_reference (exp, &bitsize, &bitpos, &offset, &mode1,
 				 &unsignedp, &reversep, &volatilep);
 	rtx orig_op0;
-	if (bitsize == 0)
+	if (known_eq (bitsize, 0))
 	  return NULL;
 	orig_op0 = op0 = expand_debug_expr (tem);
 	if (!op0)
 	  }
 	if (MEM_P (op0))
 	  {
 	    if (mode1 == VOIDmode)
-	      /* Bitfield.  */
-	      mode1 = smallest_int_mode_for_size (bitsize);
-	    if (bitpos >= BITS_PER_UNIT)
 	      {
-		op0 = adjust_address_nv (op0, mode1, bitpos / BITS_PER_UNIT);
+		if (maybe_gt (bitsize, MAX_BITSIZE_MODE_ANY_INT))
-		bitpos %= BITS_PER_UNIT;
+		  return NULL;
+		/* Bitfield.  */
+		mode1 = smallest_int_mode_for_size (bitsize);
 	      }
-	    else if (bitpos < 0)
+	    poly_int64 bytepos = bits_to_bytes_round_down (bitpos);
+	    if (maybe_ne (bytepos, 0))
 	      {
-		HOST_WIDE_INT units
+		op0 = adjust_address_nv (op0, mode1, bytepos);
-		  = (-bitpos + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
+		bitpos = num_trailing_bits (bitpos);
-		op0 = adjust_address_nv (op0, mode1, -units);
-		bitpos += units * BITS_PER_UNIT;
 	      }
-	    else if (bitpos == 0 && bitsize == GET_MODE_BITSIZE (mode))
+	    else if (known_eq (bitpos, 0)
+		     && known_eq (bitsize, GET_MODE_BITSIZE (mode)))
 	      op0 = adjust_address_nv (op0, mode, 0);
 	    else if (GET_MODE (op0) != mode1)
 	      op0 = adjust_address_nv (op0, mode1, 0);
 	    else
 	      op0 = copy_rtx (op0);
 	    if (op0 == orig_op0)
 	      op0 = shallow_copy_rtx (op0);
 	    set_mem_attributes (op0, exp, 0);
 	  }
-	if (bitpos == 0 && mode == GET_MODE (op0))
+	if (known_eq (bitpos, 0) && mode == GET_MODE (op0))
 	  return op0;
-if (bitpos < 0)
+	if (maybe_lt (bitpos, 0))
 return NULL;
-	if (GET_MODE (op0) == BLKmode)
+	if (GET_MODE (op0) == BLKmode || mode == BLKmode)
 	  return NULL;
-	if ((bitpos % BITS_PER_UNIT) == 0
+	poly_int64 bytepos;
-	    && bitsize == GET_MODE_BITSIZE (mode1))
+	if (multiple_p (bitpos, BITS_PER_UNIT, &bytepos)
+	    && known_eq (bitsize, GET_MODE_BITSIZE (mode1)))
 	  {
 	    machine_mode opmode = GET_MODE (op0);
 	    if (opmode == VOIDmode)
 	      opmode = TYPE_MODE (TREE_TYPE (tem));
 	       right past the end of an array that turned out not to
 	       be addressable (i.e., the address was only computed in
 	       debug stmts).  The gen_subreg below would rightfully
 	       crash, and the address doesn't really exist, so just
 	       drop it.  */
-	    if (bitpos >= GET_MODE_BITSIZE (opmode))
+	    if (known_ge (bitpos, GET_MODE_BITSIZE (opmode)))
 	      return NULL;
-	    if ((bitpos % GET_MODE_BITSIZE (mode)) == 0)
+	    if (multiple_p (bitpos, GET_MODE_BITSIZE (mode)))
-	      return simplify_gen_subreg (mode, op0, opmode,
+	      return simplify_gen_subreg (mode, op0, opmode, bytepos);
-					  bitpos / BITS_PER_UNIT);
 	  }
 	return simplify_gen_ternary (SCALAR_INT_MODE_P (GET_MODE (op0))
 				     && TYPE_UNSIGNED (TREE_TYPE (exp))
 				     ? SIGN_EXTRACT
 				     : ZERO_EXTRACT, mode,
 				     GET_MODE (op0) != VOIDmode
 				     ? GET_MODE (op0)
 				     : TYPE_MODE (TREE_TYPE (tem)),
-				     op0, GEN_INT (bitsize), GEN_INT (bitpos));
+				     op0, gen_int_mode (bitsize, word_mode),
+				     gen_int_mode (bitpos, word_mode));
 }
 case ABS_EXPR:
+case ABSU_EXPR:
 return simplify_gen_unary (ABS, mode, op0, mode);
 case NEGATE_EXPR:
 return simplify_gen_unary (NEG, mode, op0, mode);
 /* Fall through.  */
 case PLUS_EXPR:
 return simplify_gen_binary (PLUS, mode, op0, op1);
 case MINUS_EXPR:
+case POINTER_DIFF_EXPR:
 return simplify_gen_binary (MINUS, mode, op0, op1);
 case MULT_EXPR:
 return simplify_gen_binary (MULT, mode, op0, op1);
 		  || target_for_debug_bind (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;
+	      poly_int64 bitoffset, bitsize, maxsize, byteoffset;
 	      bool reverse;
 	      tree decl
 		= get_ref_base_and_extent (TREE_OPERAND (exp, 0), &bitoffset,
 					   &bitsize, &maxsize, &reverse);
 	      if ((VAR_P (decl)
 		   || TREE_CODE (decl) == PARM_DECL
 		   || TREE_CODE (decl) == RESULT_DECL)
 		  && (!TREE_ADDRESSABLE (decl)
 		      || target_for_debug_bind (decl))
-		  && (bitoffset % BITS_PER_UNIT) == 0
+		  && multiple_p (bitoffset, BITS_PER_UNIT, &byteoffset)
-		  && bitsize > 0
+		  && known_gt (bitsize, 0)
-		  && bitsize == maxsize)
+		  && known_eq (bitsize, maxsize))
 		{
 		  rtx base = gen_rtx_DEBUG_IMPLICIT_PTR (mode, decl);
-		  return plus_constant (mode, base, bitoffset / BITS_PER_UNIT);
+		  return plus_constant (mode, base, byteoffset);
 		}
 	    }
 	  if (TREE_CODE (TREE_OPERAND (exp, 0)) == MEM_REF
 	      && TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
 			  && GET_CODE (XEXP (op0, 0)) == DEBUG_IMPLICIT_PTR
 			  && CONST_INT_P (XEXP (op0, 1)))))
 		{
 		  op1 = expand_debug_expr (TREE_OPERAND (TREE_OPERAND (exp, 0),
 							 1));
-		  if (!op1 || !CONST_INT_P (op1))
+		  poly_int64 offset;
+		  if (!op1 || !poly_int_rtx_p (op1, &offset))
 		    return NULL;
-		  return plus_constant (mode, op0, INTVAL (op1));
+		  return plus_constant (mode, op0, offset);
 		}
 	    }
 	  return NULL;
 	}
 return op0;
 case VECTOR_CST:
 {
-	unsigned i, nelts;
+	unsigned HOST_WIDE_INT i, nelts;
-	nelts = VECTOR_CST_NELTS (exp);
+	if (!VECTOR_CST_NELTS (exp).is_constant (&nelts))
+	  return NULL;
 	op0 = gen_rtx_CONCATN (mode, rtvec_alloc (nelts));
 	for (i = 0; i < nelts; ++i)
 	  {
 	    op1 = expand_debug_expr (VECTOR_CST_ELT (exp, i));
 if (TREE_CLOBBER_P (exp))
 	return NULL;
 else if (TREE_CODE (TREE_TYPE (exp)) == VECTOR_TYPE)
 	{
 	  unsigned i;
+	  unsigned HOST_WIDE_INT nelts;
 	  tree val;
-	  op0 = gen_rtx_CONCATN
+	  if (!TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp)).is_constant (&nelts))
-	    (mode, rtvec_alloc (TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp))));
+	    goto flag_unsupported;
+	  op0 = gen_rtx_CONCATN (mode, rtvec_alloc (nelts));
 	  FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp), i, val)
 	    {
 	      op1 = expand_debug_expr (val);
 	      if (!op1)
 		return NULL;
 	      XVECEXP (op0, 0, i) = op1;
 	    }
-	  if (i < TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp)))
+	  if (i < nelts)
 	    {
 	      op1 = expand_debug_expr
 		(build_zero_cst (TREE_TYPE (TREE_TYPE (exp))));
 	      if (!op1)
 		return NULL;
-	      for (; i < TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp)); i++)
+	      for (; i < nelts; i++)
 		XVECEXP (op0, 0, i) = op1;
 	    }
 	  return op0;
 	}
 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_PACK_FIX_TRUNC_EXPR:
+case VEC_PACK_FLOAT_EXPR:
 case VEC_PACK_SAT_EXPR:
 case VEC_PACK_TRUNC_EXPR:
+case VEC_UNPACK_FIX_TRUNC_HI_EXPR:
+case VEC_UNPACK_FIX_TRUNC_LO_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_EVEN_EXPR:
 case VEC_WIDEN_MULT_ODD_EXPR:
 case VEC_WIDEN_LSHIFT_HI_EXPR:
 case VEC_WIDEN_LSHIFT_LO_EXPR:
 case VEC_PERM_EXPR:
+case VEC_DUPLICATE_EXPR:
+case VEC_SERIES_EXPR:
 return NULL;
 /* Misc codes.  */
 case ADDR_SPACE_CONVERT_EXPR:
 case FIXED_CONVERT_EXPR:
 	  return simplify_gen_binary (TREE_CODE (exp) == WIDEN_LSHIFT_EXPR
 				      ? ASHIFT : PLUS, mode, op0, op1);
 	}
 return NULL;
-case FMA_EXPR:
-return simplify_gen_ternary (FMA, mode, inner_mode, op0, op1, op2);
 default:
 flag_unsupported:
 if (flag_checking)
 	{
 	  debug_tree (exp);
 rtx op0 = NULL_RTX;
 machine_mode mode = VOIDmode, inner_mode;
 switch (TREE_CODE (exp))
 {
+case VAR_DECL:
+if (DECL_ABSTRACT_ORIGIN (exp))
+	return expand_debug_source_expr (DECL_ABSTRACT_ORIGIN (exp));
+break;
 case PARM_DECL:
 {
 	mode = DECL_MODE (exp);
 	op0 = expand_debug_parm_decl (exp);
 	if (op0)
 -fcompare-debug failures, even though it doesn't bring about any
 codegen changes.  */
 flag_strict_aliasing = 0;
 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
-if (DEBUG_INSN_P (insn))
+if (DEBUG_BIND_INSN_P (insn))
 {
 	tree value = (tree)INSN_VAR_LOCATION_LOC (insn);
 	rtx val;
 	rtx_insn *prev_insn, *insn2;
 	machine_mode mode;
 expand_gimple_basic_block (basic_block bb, bool disable_tail_calls)
 {
 gimple_stmt_iterator gsi;
 gimple_seq stmts;
 gimple *stmt = NULL;
-rtx_note *note;
+rtx_note *note = NULL;
 rtx_insn *last;
 edge e;
 edge_iterator ei;
 if (dump_file)
 rtx_code_label **elt = lab_rtx_for_bb->get (bb);
 if (stmt || elt)
 {
+gcc_checking_assert (!note);
 last = get_last_insn ();
 if (stmt)
 	{
 	  expand_gimple_stmt (stmt);
 	emit_label (*elt);
 BB_HEAD (bb) = NEXT_INSN (last);
 if (NOTE_P (BB_HEAD (bb)))
 	BB_HEAD (bb) = NEXT_INSN (BB_HEAD (bb));
+gcc_assert (LABEL_P (BB_HEAD (bb)));
 note = emit_note_after (NOTE_INSN_BASIC_BLOCK, BB_HEAD (bb));
 maybe_dump_rtl_for_gimple_stmt (stmt, last);
 }
 else
 BB_HEAD (bb) = note = emit_note (NOTE_INSN_BASIC_BLOCK);
-NOTE_BASIC_BLOCK (note) = bb;
+if (note)
+NOTE_BASIC_BLOCK (note) = bb;
 for (; !gsi_end_p (gsi); gsi_next (&gsi))
 {
 basic_block new_bb;
 #DEBUG #D1 => a_1
 	   use(a_1);
 	   a_2 = ...
 #DEBUG ... => #D1
 	 */
-if (MAY_HAVE_DEBUG_INSNS
+if (MAY_HAVE_DEBUG_BIND_INSNS
 	  && SA.values
 	  && !is_gimple_debug (stmt))
 	{
 	  ssa_op_iter iter;
 	  tree op;
 	{
 	  new_bb = expand_gimple_cond (bb, as_a <gcond *> (stmt));
 	  if (new_bb)
 	    return new_bb;
 	}
-else if (gimple_debug_bind_p (stmt))
+else if (is_gimple_debug (stmt))
 	{
 	  location_t sloc = curr_insn_location ();
 	  gimple_stmt_iterator nsi = gsi;
 	  for (;;)
 	    {
-	      tree var = gimple_debug_bind_get_var (stmt);
+	      tree var;
-	      tree value;
+	      tree value = NULL_TREE;
-	      rtx val;
+	      rtx val = NULL_RTX;
 	      machine_mode mode;
-	      if (TREE_CODE (var) != DEBUG_EXPR_DECL
+	      if (!gimple_debug_nonbind_marker_p (stmt))
-		  && TREE_CODE (var) != LABEL_DECL
+		{
-		  && !target_for_debug_bind (var))
+		  if (gimple_debug_bind_p (stmt))
+		    {
+		      var = gimple_debug_bind_get_var (stmt);
+		      if (TREE_CODE (var) != DEBUG_EXPR_DECL
+			  && TREE_CODE (var) != LABEL_DECL
+			  && !target_for_debug_bind (var))
+			goto delink_debug_stmt;
+		      if (DECL_P (var))
+			mode = DECL_MODE (var);
+		      else
+			mode = TYPE_MODE (TREE_TYPE (var));
+		      if (gimple_debug_bind_has_value_p (stmt))
+			value = gimple_debug_bind_get_value (stmt);
+		      val = gen_rtx_VAR_LOCATION
+			(mode, var, (rtx)value, VAR_INIT_STATUS_INITIALIZED);
+		    }
+		  else if (gimple_debug_source_bind_p (stmt))
+		    {
+		      var = gimple_debug_source_bind_get_var (stmt);
+		      value = gimple_debug_source_bind_get_value (stmt);
+		      mode = DECL_MODE (var);
+		      val = gen_rtx_VAR_LOCATION (mode, var, (rtx)value,
+						  VAR_INIT_STATUS_UNINITIALIZED);
+		    }
+		  else
+		    gcc_unreachable ();
+		}
+	      /* If this function was first compiled with markers
+		 enabled, but they're now disable (e.g. LTO), drop
+		 them on the floor.  */
+	      else if (gimple_debug_nonbind_marker_p (stmt)
+		       && !MAY_HAVE_DEBUG_MARKER_INSNS)
 		goto delink_debug_stmt;
+	      else if (gimple_debug_begin_stmt_p (stmt))
-	      if (gimple_debug_bind_has_value_p (stmt))
+		val = GEN_RTX_DEBUG_MARKER_BEGIN_STMT_PAT ();
-		value = gimple_debug_bind_get_value (stmt);
+	      else if (gimple_debug_inline_entry_p (stmt))
+		{
+		  tree block = gimple_block (stmt);
+		  if (block)
+		    val = GEN_RTX_DEBUG_MARKER_INLINE_ENTRY_PAT ();
+		  else
+		    goto delink_debug_stmt;
+		}
 	      else
-		value = NULL_TREE;
+		gcc_unreachable ();
 	      last = get_last_insn ();
 	      set_curr_insn_location (gimple_location (stmt));
-	      if (DECL_P (var))
-		mode = DECL_MODE (var);
-	      else
-		mode = TYPE_MODE (TREE_TYPE (var));
-	      val = gen_rtx_VAR_LOCATION
-		(mode, var, (rtx)value, VAR_INIT_STATUS_INITIALIZED);
 	      emit_debug_insn (val);
 	      if (dump_file && (dump_flags & TDF_DETAILS))
 		{
 		  /* We can't dump the insn with a TREE where an RTX
 		     is expected.  */
-		  PAT_VAR_LOCATION_LOC (val) = const0_rtx;
+		  if (GET_CODE (val) == VAR_LOCATION)
+		    {
+		      gcc_checking_assert (PAT_VAR_LOCATION_LOC (val) == (rtx)value);
+		      PAT_VAR_LOCATION_LOC (val) = const0_rtx;
+		    }
 		  maybe_dump_rtl_for_gimple_stmt (stmt, last);
-		  PAT_VAR_LOCATION_LOC (val) = (rtx)value;
+		  if (GET_CODE (val) == VAR_LOCATION)
+		    PAT_VAR_LOCATION_LOC (val) = (rtx)value;
 		}
 	    delink_debug_stmt:
 	      /* In order not to generate too many debug temporaries,
 	         we delink all uses of debug statements we already expanded.
 	      gsi = nsi;
 	      gsi_next (&nsi);
 	      if (gsi_end_p (nsi))
 		break;
 	      stmt = gsi_stmt (nsi);
-	      if (!gimple_debug_bind_p (stmt))
+	      if (!is_gimple_debug (stmt))
 		break;
-	    }
-	  set_curr_insn_location (sloc);
-	}
-else if (gimple_debug_source_bind_p (stmt))
-	{
-	  location_t sloc = curr_insn_location ();
-	  tree var = gimple_debug_source_bind_get_var (stmt);
-	  tree value = gimple_debug_source_bind_get_value (stmt);
-	  rtx val;
-	  machine_mode mode;
-	  last = get_last_insn ();
-	  set_curr_insn_location (gimple_location (stmt));
-	  mode = DECL_MODE (var);
-	  val = gen_rtx_VAR_LOCATION (mode, var, (rtx)value,
-				      VAR_INIT_STATUS_UNINITIALIZED);
-	  emit_debug_insn (val);
-	  if (dump_file && (dump_flags & TDF_DETAILS))
-	    {
-	      /* We can't dump the insn with a TREE where an RTX
-		 is expected.  */
-	      PAT_VAR_LOCATION_LOC (val) = const0_rtx;
-	      maybe_dump_rtl_for_gimple_stmt (stmt, last);
-	      PAT_VAR_LOCATION_LOC (val) = (rtx)value;
 	    }
 	  set_curr_insn_location (sloc);
 	}
 else
 last = get_last_insn ();
 if (BARRIER_P (last))
 last = PREV_INSN (last);
 if (JUMP_TABLE_DATA_P (last))
 last = PREV_INSN (PREV_INSN (last));
+if (BARRIER_P (last))
+last = PREV_INSN (last);
 BB_END (bb) = last;
 update_bb_for_insn (bb);
 return bb;
 flags = EDGE_FALLTHRU;
 init_block = create_basic_block (NEXT_INSN (get_insns ()),
 				   get_last_insn (),
 				   ENTRY_BLOCK_PTR_FOR_FN (cfun));
-init_block->frequency = ENTRY_BLOCK_PTR_FOR_FN (cfun)->frequency;
 init_block->count = ENTRY_BLOCK_PTR_FOR_FN (cfun)->count;
 add_bb_to_loop (init_block, ENTRY_BLOCK_PTR_FOR_FN (cfun)->loop_father);
 if (e)
 {
 first_block = e->dest;
 block.  */
 BB_END (prev_bb) = orig_end;
 while (NEXT_INSN (head) && NOTE_P (NEXT_INSN (head)))
 head = NEXT_INSN (head);
 /* But make sure exit_block starts with RETURN_LABEL, otherwise the
-bb frequency counting will be confused.  Any instructions before that
+bb count counting will be confused.  Any instructions before that
 label are emitted for the case where PREV_BB falls through into the
 exit block, so append those instructions to prev_bb in that case.  */
 if (NEXT_INSN (head) != return_label)
 {
 while (NEXT_INSN (head) != return_label)
 	    BB_END (prev_bb) = NEXT_INSN (head);
 	  head = NEXT_INSN (head);
 	}
 }
 exit_block = create_basic_block (NEXT_INSN (head), end, prev_bb);
-exit_block->frequency = EXIT_BLOCK_PTR_FOR_FN (cfun)->frequency;
 exit_block->count = EXIT_BLOCK_PTR_FOR_FN (cfun)->count;
 add_bb_to_loop (exit_block, EXIT_BLOCK_PTR_FOR_FN (cfun)->loop_father);
 ix = 0;
 while (ix < EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (cfun)->preds))
 			     EDGE_FALLTHRU);
 FOR_EACH_EDGE (e2, ei, EXIT_BLOCK_PTR_FOR_FN (cfun)->preds)
 if (e2 != e)
 {
 	exit_block->count -= e2->count ();
-	exit_block->frequency -= EDGE_FREQUENCY (e2);
 }
-if (exit_block->frequency < 0)
-exit_block->frequency = 0;
 update_bb_for_insn (exit_block);
 }
 /* Helper function for discover_nonconstant_array_refs.
 Look for ARRAY_REF nodes with non-constant indexes and mark them
 /* stack_realign_drap and drap_rtx must match.  */
 gcc_assert ((stack_realign_drap != 0) == (drap_rtx != NULL));
 /* Do nothing if NULL is returned, which means DRAP is not needed.  */
-if (NULL != drap_rtx)
+if (drap_rtx != NULL)
 {
 crtl->args.internal_arg_pointer = drap_rtx;
 /* Call fixup_tail_calls to clean up REG_EQUIV note if DRAP is
 needed. */
 timevar_push (TV_OUT_OF_SSA);
 rewrite_out_of_ssa (&SA);
 timevar_pop (TV_OUT_OF_SSA);
 SA.partition_to_pseudo = XCNEWVEC (rtx, SA.map->num_partitions);
-if (MAY_HAVE_DEBUG_STMTS && flag_tree_ter)
+if (MAY_HAVE_DEBUG_BIND_STMTS && flag_tree_ter)
 {
 gimple_stmt_iterator gsi;
 FOR_EACH_BB_FN (bb, cfun)
 	for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	  if (gimple_debug_bind_p (gsi_stmt (gsi)))
 currently_expanding_to_rtl = 1;
 /* Dominators are not kept up-to-date as we may create new basic-blocks.  */
 free_dominance_info (CDI_DOMINATORS);
 rtl_profile_for_bb (ENTRY_BLOCK_PTR_FOR_FN (fun));
-if (chkp_function_instrumented_p (current_function_decl))
-chkp_reset_rtl_bounds ();
 insn_locations_init ();
 if (!DECL_IS_BUILTIN (current_function_decl))
 {
 /* Eventually, all FEs should explicitly set function_start_locus.  */
 /* Clear EDGE_EXECUTABLE on the entry edge(s).  It is cleaned from the
 remaining edges later.  */
 FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR_FOR_FN (fun)->succs)
 e->flags &= ~EDGE_EXECUTABLE;
+/* If the function has too many markers, drop them while expanding.  */
+if (cfun->debug_marker_count
+>= PARAM_VALUE (PARAM_MAX_DEBUG_MARKER_COUNT))
+cfun->debug_nonbind_markers = false;
 lab_rtx_for_bb = new hash_map<basic_block, rtx_code_label *>;
 FOR_BB_BETWEEN (bb, init_block->next_bb, EXIT_BLOCK_PTR_FOR_FN (fun),
 		  next_bb)
 bb = expand_gimple_basic_block (bb, var_ret_seq != NULL_RTX);
-if (MAY_HAVE_DEBUG_INSNS)
+if (MAY_HAVE_DEBUG_BIND_INSNS)
 expand_debug_locations ();
 if (deep_ter_debug_map)
 {
 delete deep_ter_debug_map;

Mercurial > hg > CbC > CbC_gcc

comparison gcc/cfgexpand.c @ 132:d34655255c78