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

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 3604fd87e870d98eb110e181b296a0baaf4b9adf..b9be9d55325714279c014299d82ed4707cf38850 100644 (file)
--- a/gcc/ChangeLog
+++ b/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.

diff --git a/gcc/cgraphunit.c b/gcc/cgraphunit.c
index 7cfb8a0f55929ed18bae105fbcfce70fe1de5106..3c811c412c3f1de221c5fbab811ed0a4fbbac346 100644 (file)
--- a/gcc/cgraphunit.c
+++ b/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);
        }

diff --git a/gcc/gimple-pretty-print.c b/gcc/gimple-pretty-print.c
index bee81ad727154696887f07cdda3dafd66c98633c..19cdb40d73a5226033297f311f7bdeb716c8c07d 100644 (file)
--- a/gcc/gimple-pretty-print.c
+++ b/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);
     }
 }

diff --git a/gcc/gimple.h b/gcc/gimple.h
index ab095f63908940c46031995ec647f8c1a0373e9b..32e1908c534e255dd661630de3c9aac9f6d9071d 100644 (file)
--- a/gcc/gimple.h
+++ b/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                                \

diff --git a/gcc/tree-inline.c b/gcc/tree-inline.c
index fb349d47ba59febf536dff02e1f0f749ce1729cb..c39a8457e001c13ba0d681ccc76171d1cfcd82d5 100644 (file)
--- a/gcc/tree-inline.c
+++ b/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:

diff --git a/gcc/tree-inline.h b/gcc/tree-inline.h
index d0ebbcaa34229d37b91fa38b7044f58b807458bf..faeca2fec3eddcb00479094340c06299bcfbe97f 100644 (file)
--- a/gcc/tree-inline.h
+++ b/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;