From 78dea27f9106c4f47ab4e640659d23b505423cac Mon Sep 17 00:00:00 2001
From: David Malcolm <dmalcolm@redhat.com>
Date: Thu, 19 Dec 2013 15:58:15 -0500
Subject: [PATCH 66/88] Concretize three gimple_return_ accessors

gcc/
	* gimple.h (gimple_return_retval_ptr): Require a const_gimple_return
	rather than a const_gimple.
	(gimple_return_retval): Likewise.
	(gimple_return_set_retval): Require a gimple_return.

	* cfgexpand.c (expand_gimple_stmt_1): Add a checked cast to
	gimple_return.
	(expand_gimple_basic_block): Likewise.
	* tree-complex.c (expand_complex_move): Likewise.
	(expand_complex_comparison): Likewise.
	* tree-inline.c (remap_gimple_stmt): Likewise.
	* tree-sra.c (scan_function): Likewise.
	(sra_modify_function_body): Likewise.
	(ipa_sra_modify_function_body): Likewise.
	* tree-ssa-structalias.c (find_func_aliases): Likewise.

	* gimple-walk.c (walk_stmt_load_store_addr_ops): Replace a check
	for code GIMPLE_RETURN with a dyn_cast and a new local.
	* gimple.c (infer_nonnull_range): Likewise.
	* ipa-split.c (find_return_bb): Likewise.
	(find_retval): Likewise.
	(split_function): Likewise.
	* omp-low.c (ipa_simd_modify_function_body): Likewise.
	* tree-cfg.c (execute_warn_function_return): Likewise.
	* tree-nrv.c (tree_nrv): Likewise.
	* tree-ssa-alias.c (ref_maybe_used_by_stmt_p): Likewise.
	* tree-ssa-dce.c (propagate_necessity): Likewise.
	* tree-ssa-structalias.c (find_func_clobbers): Likewise.
	* tree-tailcall.c (find_tail_calls): Likewise.

	* predict.c (apply_return_prediction): Rework the search for
	return_stmt so that the latter can have type gimple_return.
---
 gcc/cfgexpand.c                |  4 ++--
 gcc/gimple-ssa-isolate-paths.c | 16 ++++++++++------
 gcc/gimple-walk.c              |  4 ++--
 gcc/gimple.c                   | 14 +++++++-------
 gcc/gimple.h                   |  9 +++------
 gcc/ipa-split.c                | 13 +++++++------
 gcc/omp-low.c                  |  4 ++--
 gcc/predict.c                  | 13 ++++++++-----
 gcc/tree-cfg.c                 |  5 +++--
 gcc/tree-complex.c             |  9 ++++++---
 gcc/tree-inline.c              |  2 +-
 gcc/tree-nrv.c                 |  4 ++--
 gcc/tree-sra.c                 |  6 +++---
 gcc/tree-ssa-alias.c           |  4 ++--
 gcc/tree-ssa-dce.c             |  4 ++--
 gcc/tree-ssa-structalias.c     | 12 +++++++-----
 gcc/tree-tailcall.c            |  2 +-
 gcc/ubsan.c                    |  2 +-
 18 files changed, 69 insertions(+), 58 deletions(-)

diff --git a/gcc/cfgexpand.c b/gcc/cfgexpand.c
index 6490004..0ad6fcc 100644
--- a/gcc/cfgexpand.c
+++ b/gcc/cfgexpand.c
@@ -3220,7 +3220,7 @@ expand_gimple_stmt_1 (gimple stmt)
       break;
 
     case GIMPLE_RETURN:
-      op0 = gimple_return_retval (stmt);
+      op0 = gimple_return_retval (as_a <gimple_return> (stmt));
 
       if (op0 && op0 != error_mark_node)
 	{
@@ -4919,7 +4919,7 @@ expand_gimple_basic_block (basic_block bb, bool disable_tail_calls)
   if (!gsi_end_p (gsi)
       && gimple_code (gsi_stmt (gsi)) == GIMPLE_RETURN)
     {
-      gimple ret_stmt = gsi_stmt (gsi);
+      gimple_return ret_stmt = as_a <gimple_return> (gsi_stmt (gsi));
 
       gcc_assert (single_succ_p (bb));
       gcc_assert (single_succ (bb) == EXIT_BLOCK_PTR_FOR_FN (cfun));
diff --git a/gcc/gimple-ssa-isolate-paths.c b/gcc/gimple-ssa-isolate-paths.c
index 528b3eb..49c9086 100644
--- a/gcc/gimple-ssa-isolate-paths.c
+++ b/gcc/gimple-ssa-isolate-paths.c
@@ -205,7 +205,7 @@ isolate_path (basic_block bb, basic_block duplicate,
     {
       if (ret_zero)
 	{
-	  gimple ret = gsi_stmt (si2);
+	  gimple_return ret = as_a <gimple_return> (gsi_stmt (si2));
 	  tree zero = build_zero_cst (TREE_TYPE (gimple_return_retval (ret)));
 	  gimple_return_set_retval (ret, zero);
 	  update_stmt (ret);
@@ -285,8 +285,12 @@ find_implicit_erroneous_behaviour (void)
 		    {
 		      FOR_EACH_IMM_USE_STMT (use_stmt, iter, lhs)
 			{
-			  if (gimple_code (use_stmt) != GIMPLE_RETURN
-			      || gimple_return_retval (use_stmt) != lhs)
+			  gimple_return return_stmt =
+			    dyn_cast <gimple_return> (use_stmt);
+			  if (!return_stmt)
+			    continue;
+
+			  if (gimple_return_retval (return_stmt) != lhs)
 			    continue;
 
 			  if (warning_at (gimple_location (use_stmt),
@@ -399,9 +403,9 @@ find_explicit_erroneous_behaviour (void)
 	  /* Detect returning the address of a local variable.  This only
 	     becomes undefined behavior if the result is used, so we do not
 	     insert a trap and only return NULL instead.  */
-	  if (gimple_code (stmt) == GIMPLE_RETURN)
+	  if (gimple_return return_stmt = dyn_cast <gimple_return> (stmt))
 	    {
-	      tree val = gimple_return_retval (stmt);
+	      tree val = gimple_return_retval (return_stmt);
 	      if (val && TREE_CODE (val) == ADDR_EXPR)
 		{
 		  tree valbase = get_base_address (TREE_OPERAND (val, 0));
@@ -425,7 +429,7 @@ find_explicit_erroneous_behaviour (void)
 				      OPT_Wreturn_local_addr, msg))
 			inform (DECL_SOURCE_LOCATION(valbase), "declared here");
 		      tree zero = build_zero_cst (TREE_TYPE (val));
-		      gimple_return_set_retval (stmt, zero);
+		      gimple_return_set_retval (return_stmt, zero);
 		      update_stmt (stmt);
 		    }
 		}
diff --git a/gcc/gimple-walk.c b/gcc/gimple-walk.c
index bbc5963..57aa780 100644
--- a/gcc/gimple-walk.c
+++ b/gcc/gimple-walk.c
@@ -852,9 +852,9 @@ walk_stmt_load_store_addr_ops (gimple stmt, void *data,
 	      }
 	  }
     }
-  else if (gimple_code (stmt) == GIMPLE_RETURN)
+  else if (gimple_return return_stmt = dyn_cast <gimple_return> (stmt))
     {
-      tree op = gimple_return_retval (stmt);
+      tree op = gimple_return_retval (return_stmt);
       if (op)
 	{
 	  if (visit_addr
diff --git a/gcc/gimple.c b/gcc/gimple.c
index 0fac6b4..a244617 100644
--- a/gcc/gimple.c
+++ b/gcc/gimple.c
@@ -2653,13 +2653,13 @@ infer_nonnull_range (gimple stmt, tree op, bool dereference, bool attribute)
 
   /* If this function is marked as returning non-null, then we can
      infer OP is non-null if it is used in the return statement.  */
-  if (attribute
-      && gimple_code (stmt) == GIMPLE_RETURN
-      && gimple_return_retval (stmt)
-      && operand_equal_p (gimple_return_retval (stmt), op, 0)
-      && lookup_attribute ("returns_nonnull",
-			   TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl))))
-    return true;
+  if (attribute)
+    if (gimple_return return_stmt = dyn_cast <gimple_return> (stmt))
+      if (gimple_return_retval (return_stmt)
+	  && operand_equal_p (gimple_return_retval (return_stmt), op, 0)
+	  && lookup_attribute ("returns_nonnull",
+			       TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl))))
+	return true;
 
   return false;
 }
diff --git a/gcc/gimple.h b/gcc/gimple.h
index 688c375..e1afe99 100644
--- a/gcc/gimple.h
+++ b/gcc/gimple.h
@@ -5513,18 +5513,16 @@ gimple_transaction_set_subcode (gimple_transaction transaction_stmt,
 /* Return a pointer to the return value for GIMPLE_RETURN GS.  */
 
 static inline tree *
-gimple_return_retval_ptr (const_gimple gs)
+gimple_return_retval_ptr (const_gimple_return gs)
 {
-  GIMPLE_CHECK (gs, GIMPLE_RETURN);
   return gimple_op_ptr (gs, 0);
 }
 
 /* Return the return value for GIMPLE_RETURN GS.  */
 
 static inline tree
-gimple_return_retval (const_gimple gs)
+gimple_return_retval (const_gimple_return gs)
 {
-  GIMPLE_CHECK (gs, GIMPLE_RETURN);
   return gimple_op (gs, 0);
 }
 
@@ -5532,9 +5530,8 @@ gimple_return_retval (const_gimple gs)
 /* Set RETVAL to be the return value for GIMPLE_RETURN GS.  */
 
 static inline void
-gimple_return_set_retval (gimple gs, tree retval)
+gimple_return_set_retval (gimple_return gs, tree retval)
 {
-  GIMPLE_CHECK (gs, GIMPLE_RETURN);
   gimple_set_op (gs, 0, retval);
 }
 
diff --git a/gcc/ipa-split.c b/gcc/ipa-split.c
index 59901dc..e5df578 100644
--- a/gcc/ipa-split.c
+++ b/gcc/ipa-split.c
@@ -710,10 +710,10 @@ find_return_bb (void)
 		   || is_gimple_min_invariant (gimple_assign_rhs1 (stmt)))
 	       && retval == gimple_assign_lhs (stmt))
 	;
-      else if (gimple_code (stmt) == GIMPLE_RETURN)
+      else if (gimple_return return_stmt = dyn_cast <gimple_return> (stmt))
 	{
 	  found_return = true;
-	  retval = gimple_return_retval (stmt);
+	  retval = gimple_return_retval (return_stmt);
 	}
       else
 	break;
@@ -731,8 +731,8 @@ find_retval (basic_block return_bb)
 {
   gimple_stmt_iterator bsi;
   for (bsi = gsi_start_bb (return_bb); !gsi_end_p (bsi); gsi_next (&bsi))
-    if (gimple_code (gsi_stmt (bsi)) == GIMPLE_RETURN)
-      return gimple_return_retval (gsi_stmt (bsi));
+    if (gimple_return return_stmt = dyn_cast <gimple_return> (gsi_stmt (bsi)))
+      return gimple_return_retval (return_stmt);
     else if (gimple_code (gsi_stmt (bsi)) == GIMPLE_ASSIGN
 	     && !gimple_clobber_p (gsi_stmt (bsi)))
       return gimple_assign_rhs1 (gsi_stmt (bsi));
@@ -1446,9 +1446,10 @@ split_function (struct split_point *split_point)
 		      gimple_stmt_iterator bsi;
 		      for (bsi = gsi_start_bb (return_bb); !gsi_end_p (bsi);
 			   gsi_next (&bsi))
-			if (gimple_code (gsi_stmt (bsi)) == GIMPLE_RETURN)
+			if (gimple_return return_stmt =
+			      dyn_cast <gimple_return> (gsi_stmt (bsi)))
 			  {
-			    gimple_return_set_retval (gsi_stmt (bsi), retval);
+			    gimple_return_set_retval (return_stmt, retval);
 			    break;
 			  }
 			else if (gimple_code (gsi_stmt (bsi)) == GIMPLE_ASSIGN
diff --git a/gcc/omp-low.c b/gcc/omp-low.c
index 6174c3f..1e1ee1d 100644
--- a/gcc/omp-low.c
+++ b/gcc/omp-low.c
@@ -11951,9 +11951,9 @@ ipa_simd_modify_function_body (struct cgraph_node *node,
 	  wi.info = &info;
 	  walk_gimple_op (stmt, ipa_simd_modify_stmt_ops, &wi);
 
-	  if (gimple_code (stmt) == GIMPLE_RETURN)
+	  if (gimple_return return_stmt = dyn_cast <gimple_return> (stmt))
 	    {
-	      tree retval = gimple_return_retval (stmt);
+	      tree retval = gimple_return_retval (return_stmt);
 	      if (!retval)
 		{
 		  gsi_remove (&gsi, true);
diff --git a/gcc/predict.c b/gcc/predict.c
index 5e8a0e9..c21cc29 100644
--- a/gcc/predict.c
+++ b/gcc/predict.c
@@ -2145,7 +2145,7 @@ return_prediction (tree val, enum prediction *prediction)
 static void
 apply_return_prediction (void)
 {
-  gimple return_stmt = NULL;
+  gimple_return return_stmt = NULL;
   tree return_val;
   edge e;
   gimple_phi phi;
@@ -2156,10 +2156,13 @@ apply_return_prediction (void)
 
   FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR_FOR_FN (cfun)->preds)
     {
-      return_stmt = last_stmt (e->src);
-      if (return_stmt
-	  && gimple_code (return_stmt) == GIMPLE_RETURN)
-	break;
+      gimple last = last_stmt (e->src);
+      if (last
+	  && gimple_code (last) == GIMPLE_RETURN)
+	{
+	  return_stmt = as_a <gimple_return> (last);
+	  break;
+	}
     }
   if (!e)
     return;
diff --git a/gcc/tree-cfg.c b/gcc/tree-cfg.c
index af2f806..e58260e 100644
--- a/gcc/tree-cfg.c
+++ b/gcc/tree-cfg.c
@@ -8334,8 +8334,9 @@ pass_warn_function_return::execute (function *fun)
       FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR_FOR_FN (fun)->preds)
 	{
 	  gimple last = last_stmt (e->src);
-	  if (gimple_code (last) == GIMPLE_RETURN
-	      && gimple_return_retval (last) == NULL
+	  gimple_return return_stmt = dyn_cast <gimple_return> (last);
+	  if (return_stmt
+	      && gimple_return_retval (return_stmt) == NULL
 	      && !gimple_no_warning_p (last))
 	    {
 	      location = gimple_location (last);
diff --git a/gcc/tree-complex.c b/gcc/tree-complex.c
index d2b4f01..a7cbceb 100644
--- a/gcc/tree-complex.c
+++ b/gcc/tree-complex.c
@@ -855,7 +855,7 @@ expand_complex_move (gimple_stmt_iterator *gsi, tree type)
 
 	  stmt = gsi_stmt (*gsi);
 	  gcc_assert (gimple_code (stmt) == GIMPLE_RETURN);
-	  gimple_return_set_retval (stmt, lhs);
+	  gimple_return_set_retval (as_a <gimple_return> (stmt), lhs);
 	}
 
       update_stmt (stmt);
@@ -1391,8 +1391,11 @@ expand_complex_comparison (gimple_stmt_iterator *gsi, tree ar, tree ai,
   switch (gimple_code (stmt))
     {
     case GIMPLE_RETURN:
-      type = TREE_TYPE (gimple_return_retval (stmt));
-      gimple_return_set_retval (stmt, fold_convert (type, cc));
+      {
+	gimple_return return_stmt = as_a <gimple_return> (stmt);
+	type = TREE_TYPE (gimple_return_retval (return_stmt));
+	gimple_return_set_retval (return_stmt, fold_convert (type, cc));
+      }
       break;
 
     case GIMPLE_ASSIGN:
diff --git a/gcc/tree-inline.c b/gcc/tree-inline.c
index 96e3ec4..0c8181f 100644
--- a/gcc/tree-inline.c
+++ b/gcc/tree-inline.c
@@ -1300,7 +1300,7 @@ remap_gimple_stmt (gimple stmt, copy_body_data *id)
      statement.  */
   if (gimple_code (stmt) == GIMPLE_RETURN && id->transform_return_to_modify)
     {
-      tree retval = gimple_return_retval (stmt);
+      tree retval = gimple_return_retval (as_a <gimple_return> (stmt));
 
       /* If we're returning something, just turn that into an
 	 assignment into the equivalent of the original RESULT_DECL.
diff --git a/gcc/tree-nrv.c b/gcc/tree-nrv.c
index e989f91..2047f5e 100644
--- a/gcc/tree-nrv.c
+++ b/gcc/tree-nrv.c
@@ -180,12 +180,12 @@ pass_nrv::execute (function *fun)
 	  gimple stmt = gsi_stmt (gsi);
 	  tree ret_val;
 
-	  if (gimple_code (stmt) == GIMPLE_RETURN)
+	  if (gimple_return return_stmt = dyn_cast <gimple_return> (stmt))
 	    {
 	      /* In a function with an aggregate return value, the
 		 gimplifier has changed all non-empty RETURN_EXPRs to
 		 return the RESULT_DECL.  */
-	      ret_val = gimple_return_retval (stmt);
+	      ret_val = gimple_return_retval (return_stmt);
 	      if (ret_val)
 		gcc_assert (ret_val == result);
 	    }
diff --git a/gcc/tree-sra.c b/gcc/tree-sra.c
index 9f67f6d..50464f1 100644
--- a/gcc/tree-sra.c
+++ b/gcc/tree-sra.c
@@ -1280,7 +1280,7 @@ scan_function (void)
 	  switch (gimple_code (stmt))
 	    {
 	    case GIMPLE_RETURN:
-	      t = gimple_return_retval (stmt);
+	      t = gimple_return_retval (as_a <gimple_return> (stmt));
 	      if (t != NULL_TREE)
 		ret |= build_access_from_expr (t, stmt, false);
 	      if (final_bbs)
@@ -3389,7 +3389,7 @@ sra_modify_function_body (void)
 	  switch (gimple_code (stmt))
 	    {
 	    case GIMPLE_RETURN:
-	      t = gimple_return_retval_ptr (stmt);
+	      t = gimple_return_retval_ptr (as_a <gimple_return> (stmt));
 	      if (*t != NULL_TREE)
 		modified |= sra_modify_expr (t, &gsi, false);
 	      break;
@@ -4652,7 +4652,7 @@ ipa_sra_modify_function_body (ipa_parm_adjustment_vec adjustments)
 	  switch (gimple_code (stmt))
 	    {
 	    case GIMPLE_RETURN:
-	      t = gimple_return_retval_ptr (stmt);
+	      t = gimple_return_retval_ptr (as_a <gimple_return> (stmt));
 	      if (*t != NULL_TREE)
 		modified |= ipa_modify_expr (t, true, adjustments);
 	      break;
diff --git a/gcc/tree-ssa-alias.c b/gcc/tree-ssa-alias.c
index 611b16f..07ecbd1 100644
--- a/gcc/tree-ssa-alias.c
+++ b/gcc/tree-ssa-alias.c
@@ -1826,9 +1826,9 @@ ref_maybe_used_by_stmt_p (gimple stmt, ao_ref *ref)
     }
   else if (is_gimple_call (stmt))
     return ref_maybe_used_by_call_p (as_a <gimple_call> (stmt), ref);
-  else if (gimple_code (stmt) == GIMPLE_RETURN)
+  else if (gimple_return return_stmt = dyn_cast <gimple_return> (stmt))
     {
-      tree retval = gimple_return_retval (stmt);
+      tree retval = gimple_return_retval (return_stmt);
       if (retval
 	  && TREE_CODE (retval) != SSA_NAME
 	  && !is_gimple_min_invariant (retval)
diff --git a/gcc/tree-ssa-dce.c b/gcc/tree-ssa-dce.c
index f853512..aba2d98 100644
--- a/gcc/tree-ssa-dce.c
+++ b/gcc/tree-ssa-dce.c
@@ -868,9 +868,9 @@ propagate_necessity (bool aggressive)
 		    mark_all_reaching_defs_necessary (stmt);
 		}
 	    }
-	  else if (gimple_code (stmt) == GIMPLE_RETURN)
+	  else if (gimple_return return_stmt = dyn_cast <gimple_return> (stmt))
 	    {
-	      tree rhs = gimple_return_retval (stmt);
+	      tree rhs = gimple_return_retval (return_stmt);
 	      /* A return statement may perform a load.  */
 	      if (rhs
 		  && TREE_CODE (rhs) != SSA_NAME
diff --git a/gcc/tree-ssa-structalias.c b/gcc/tree-ssa-structalias.c
index a130268..550bfb4 100644
--- a/gcc/tree-ssa-structalias.c
+++ b/gcc/tree-ssa-structalias.c
@@ -4732,12 +4732,13 @@ find_func_aliases (struct function *fn, gimple origt)
     }
   /* Handle escapes through return.  */
   else if (gimple_code (t) == GIMPLE_RETURN
-	   && gimple_return_retval (t) != NULL_TREE)
+	   && gimple_return_retval (as_a <gimple_return> (t)) != NULL_TREE)
     {
+      gimple_return return_stmt = as_a <gimple_return> (t);
       fi = NULL;
       if (!in_ipa_mode
 	  || !(fi = get_vi_for_tree (fn->decl)))
-	make_escape_constraint (gimple_return_retval (t));
+	make_escape_constraint (gimple_return_retval (return_stmt));
       else if (in_ipa_mode
 	       && fi != NULL)
 	{
@@ -4746,7 +4747,7 @@ find_func_aliases (struct function *fn, gimple origt)
 	  unsigned i;
 
 	  lhs = get_function_part_constraint (fi, fi_result);
-	  get_constraint_for_rhs (gimple_return_retval (t), &rhsc);
+	  get_constraint_for_rhs (gimple_return_retval (return_stmt), &rhsc);
 	  FOR_EACH_VEC_ELT (rhsc, i, rhsp)
 	    process_constraint (new_constraint (lhs, *rhsp));
 	}
@@ -4885,10 +4886,11 @@ find_func_clobbers (struct function *fn, gimple origt)
   /* Account for uses in assigments and returns.  */
   if (gimple_assign_single_p (t)
       || (gimple_code (t) == GIMPLE_RETURN
-	  && gimple_return_retval (t) != NULL_TREE))
+	  && gimple_return_retval (as_a <gimple_return> (t)) != NULL_TREE))
     {
       tree rhs = (gimple_assign_single_p (t)
-		  ? gimple_assign_rhs1 (t) : gimple_return_retval (t));
+		  ? gimple_assign_rhs1 (t)
+		  : gimple_return_retval (as_a <gimple_return> (t)));
       tree tem = rhs;
       while (handled_component_p (tem))
 	tem = TREE_OPERAND (tem, 0);
diff --git a/gcc/tree-tailcall.c b/gcc/tree-tailcall.c
index 5a1763c..9bf3c42 100644
--- a/gcc/tree-tailcall.c
+++ b/gcc/tree-tailcall.c
@@ -586,7 +586,7 @@ find_tail_calls (basic_block bb, struct tailcall **ret)
     }
 
   /* See if this is a tail call we can handle.  */
-  ret_var = gimple_return_retval (stmt);
+  ret_var = gimple_return_retval (as_a <gimple_return> (stmt));
 
   /* We may proceed if there either is no return value, or the return value
      is identical to the call's return.  */
diff --git a/gcc/ubsan.c b/gcc/ubsan.c
index 3d87929..a4de6cb 100644
--- a/gcc/ubsan.c
+++ b/gcc/ubsan.c
@@ -1286,7 +1286,7 @@ instrument_nonnull_arg (gimple_stmt_iterator *gsi)
 static void
 instrument_nonnull_return (gimple_stmt_iterator *gsi)
 {
-  gimple stmt = gsi_stmt (*gsi);
+  gimple_return stmt = as_a <gimple_return> (gsi_stmt (*gsi));
   location_t loc[2];
   tree arg = gimple_return_retval (stmt);
   /* infer_nonnull_range needs flag_delete_null_pointer_checks set,
-- 
1.8.5.3

