gimple.h (gimple_return_retbnd): Delete.

* gimple.h (gimple_return_retbnd): Delete.
	(gimple_return_set_retbnd): Likewise.
	* cgraphunit.c (cgraph_node::expand_thunk): Remove call to
	gimple_return_set_retbnd.
	* gimple-pretty-print.c (dump_gimple_return): Remove call to
	gimple_return_retbnd and adjust.
	* tree-inline.h (struct copy_body_data): Remove retbnd field.
	* tree-inline.c (remap_gimple_stmt): Remove handling of retbnd.
	Explicitly return NULL in a couple more cases.  Move assertion
	on debug statements and remove unreachable code.
	(reset_debug_binding): Do not test id->retbnd.
	(expand_call_inline): Do not set it.

From-SVN: r262181

gcc/ChangeLog

@@ -1,3 +1,18 @@
+2018-06-27  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* gimple.h (gimple_return_retbnd): Delete.
+	(gimple_return_set_retbnd): Likewise.
+	* cgraphunit.c (cgraph_node::expand_thunk): Remove call to
+	gimple_return_set_retbnd.
+	* gimple-pretty-print.c (dump_gimple_return): Remove call to
+	gimple_return_retbnd and adjust.
+	* tree-inline.h (struct copy_body_data): Remove retbnd field.
+	* tree-inline.c (remap_gimple_stmt): Remove handling of retbnd.
+	Explicitly return NULL in a couple more cases.  Move assertion
+	on debug statements and remove unreachable code.
+	(reset_debug_binding): Do not test id->retbnd.
+	(expand_call_inline): Do not set it.
+
 2018-06-27  Rasmus Villemoes  <rv@rasmusvillemoes.dk>
 
 	* configure.ac: Add --disable-gcov option.

gcc/cgraphunit.c

@@ -1803,7 +1803,6 @@ cgraph_node::expand_thunk (bool output_asm_thunks, bool force_gimple_thunk)
       int i;
       tree resdecl;
       tree restmp = NULL;
-      tree resbnd = NULL;
 
       gcall *call;
       greturn *ret;
@@ -1994,7 +1993,6 @@ cgraph_node::expand_thunk (bool output_asm_thunks, bool force_gimple_thunk)
 	    ret = gimple_build_return (restmp);
 	  else
 	    ret = gimple_build_return (resdecl);
-	  gimple_return_set_retbnd (ret, resbnd);
 
 	  gsi_insert_after (&bsi, ret, GSI_NEW_STMT);
 	}

gcc/gimple-pretty-print.c

@@ -645,12 +645,11 @@ static void
 dump_gimple_return (pretty_printer *buffer, greturn *gs, int spc,
 		    dump_flags_t flags)
 {
-  tree t, t2;
+  tree t;
 
   t = gimple_return_retval (gs);
-  t2 = gimple_return_retbnd (gs);
   if (flags & TDF_RAW)
-    dump_gimple_fmt (buffer, spc, flags, "%G <%T %T>", gs, t, t2);
+    dump_gimple_fmt (buffer, spc, flags, "%G <%T>", gs, t);
   else
     {
       pp_string (buffer, "return");
@@ -659,11 +658,6 @@ dump_gimple_return (pretty_printer *buffer, greturn *gs, int spc,
 	  pp_space (buffer);
 	  dump_generic_node (buffer, t, spc, flags, false);
 	}
-      if (t2)
-	{
-	  pp_string (buffer, ", ");
-	  dump_generic_node (buffer, t2, spc, flags, false);
-	}
       pp_semicolon (buffer);
     }
 }

gcc/gimple.h

@@ -6198,26 +6198,6 @@ gimple_return_set_retval (greturn *gs, tree retval)
 }
 
 
-/* Return the return bounds for GIMPLE_RETURN GS.  */
-
-static inline tree
-gimple_return_retbnd (const gimple *gs)
-{
-  GIMPLE_CHECK (gs, GIMPLE_RETURN);
-  return gimple_op (gs, 1);
-}
-
-
-/* Set RETVAL to be the return bounds for GIMPLE_RETURN GS.  */
-
-static inline void
-gimple_return_set_retbnd (gimple *gs, tree retval)
-{
-  GIMPLE_CHECK (gs, GIMPLE_RETURN);
-  gimple_set_op (gs, 1, retval);
-}
-
-
 /* Returns true when the gimple statement STMT is any of the OMP types.  */
 
 #define CASE_GIMPLE_OMP				\

gcc/tree-inline.c

@@ -1382,35 +1382,24 @@ remap_gimple_stmt (gimple *stmt, copy_body_data *id)
       && (gimple_debug_nonbind_marker_p (stmt)
 	  ? !DECL_STRUCT_FUNCTION (id->dst_fn)->debug_nonbind_markers
 	  : !opt_for_fn (id->dst_fn, flag_var_tracking_assignments)))
-    return stmts;
+    return NULL;
 
   /* Begin by recognizing trees that we'll completely rewrite for the
      inlining context.  Our output for these trees is completely
-     different from out input (e.g. RETURN_EXPR is deleted, and morphs
+     different from our input (e.g. RETURN_EXPR is deleted and morphs
      into an edge).  Further down, we'll handle trees that get
      duplicated and/or tweaked.  */
 
-  /* When requested, GIMPLE_RETURNs should be transformed to just the
+  /* When requested, GIMPLE_RETURN should be transformed to just the
      contained GIMPLE_ASSIGN.  The branch semantics of the return will
      be handled elsewhere by manipulating the CFG rather than the
      statement.  */
   if (gimple_code (stmt) == GIMPLE_RETURN && id->transform_return_to_modify)
     {
       tree retval = gimple_return_retval (as_a <greturn *> (stmt));
-      tree retbnd = gimple_return_retbnd (stmt);
-      tree bndslot = id->retbnd;
-
-      if (retbnd && bndslot)
-	{
-	  gimple *bndcopy = gimple_build_assign (bndslot, retbnd);
-	  memset (&wi, 0, sizeof (wi));
-	  wi.info = id;
-	  walk_gimple_op (bndcopy, remap_gimple_op_r, &wi);
-	  gimple_seq_add_stmt (&stmts, bndcopy);
-	}
 
       /* If we're returning something, just turn that into an
-	 assignment into the equivalent of the original RESULT_DECL.
+	 assignment to the equivalent of the original RESULT_DECL.
 	 If RETVAL is just the result decl, the result decl has
 	 already been set (e.g. a recent "foo (&result_decl, ...)");
 	 just toss the entire GIMPLE_RETURN.  */
@@ -1427,7 +1416,7 @@ remap_gimple_stmt (gimple *stmt, copy_body_data *id)
 	  skip_first = true;
 	}
       else
-	return stmts;
+	return NULL;
     }
   else if (gimple_has_substatements (stmt))
     {
@@ -1668,7 +1657,6 @@ remap_gimple_stmt (gimple *stmt, copy_body_data *id)
 	  gimple_seq_add_stmt (&stmts, copy);
 	  return stmts;
 	}
-      gcc_checking_assert (!is_gimple_debug (stmt));
 
       /* Create a new deep copy of the statement.  */
       copy = gimple_copy (stmt);
@@ -1754,8 +1742,7 @@ remap_gimple_stmt (gimple *stmt, copy_body_data *id)
 	  }
     }
 
-  /* If STMT has a block defined, map it to the newly constructed
-     block.  */
+  /* If STMT has a block defined, map it to the newly constructed block.  */
   if (gimple_block (copy))
     {
       tree *n;
@@ -1764,12 +1751,8 @@ remap_gimple_stmt (gimple *stmt, copy_body_data *id)
       gimple_set_block (copy, *n);
     }
 
-  if (gimple_debug_bind_p (copy) || gimple_debug_source_bind_p (copy)
-      || gimple_debug_nonbind_marker_p (copy))
-    {
-      gimple_seq_add_stmt (&stmts, copy);
-      return stmts;
-    }
+  /* Debug statements ought to be rebuilt and not copied.  */
+  gcc_checking_assert (!is_gimple_debug (copy));
 
   /* Remap all the operands in COPY.  */
   memset (&wi, 0, sizeof (wi));
@@ -4274,7 +4257,7 @@ reset_debug_binding (copy_body_data *id, tree srcvar, gimple_seq *bindings)
   if (!VAR_P (*remappedvarp))
     return;
 
-  if (*remappedvarp == id->retvar || *remappedvarp == id->retbnd)
+  if (*remappedvarp == id->retvar)
     return;
 
   tree tvar = target_for_debug_bind (*remappedvarp);
@@ -4834,7 +4817,6 @@ expand_call_inline (basic_block bb, gimple *stmt, copy_body_data *id)
 
   id->block = NULL_TREE;
   id->retvar = NULL_TREE;
-  id->retbnd = NULL_TREE;
   successfully_inlined = true;
 
  egress:

gcc/tree-inline.h

@@ -63,9 +63,6 @@ struct copy_body_data
   /* The VAR_DECL for the return value.  */
   tree retvar;
 
-  /* The VAR_DECL for the return bounds.  */
-  tree retbnd;
-
   /* Assign statements that need bounds copy.  */
   vec<gimple *> assign_stmts;