Revert "C: Implement musttail attribute for returns"

This reverts commit 7db47f7b915c5f5d645fa536547e26b92290afe3.

3 files changed, 16 insertions, 64 deletions

diff --git a/gcc/c/c-parser.cc b/gcc/c/c-parser.cc
index 9b9284b..12c5ed5 100644
--- a/gcc/c/c-parser.cc
+++ b/gcc/c/c-parser.cc
@@ -1621,12 +1621,6 @@ struct omp_for_parse_data {
   bool fail : 1;
 };
 
-struct attr_state
-{
-  /* True if we parsed a musttail attribute for return.  */
-  bool musttail_p;
-};
-
 static bool c_parser_nth_token_starts_std_attributes (c_parser *,
 						      unsigned int);
 static tree c_parser_std_attribute_specifier_sequence (c_parser *);
@@ -1671,8 +1665,7 @@ static location_t c_parser_compound_statement_nostart (c_parser *);
 static void c_parser_label (c_parser *, tree);
 static void c_parser_statement (c_parser *, bool *, location_t * = NULL);
 static void c_parser_statement_after_labels (c_parser *, bool *,
-					     vec<tree> * = NULL,
-					     attr_state = {});
+					     vec<tree> * = NULL);
 static tree c_parser_c99_block_statement (c_parser *, bool *,
 					  location_t * = NULL);
 static void c_parser_if_statement (c_parser *, bool *, vec<tree> *);
@@ -6989,29 +6982,6 @@ c_parser_handle_directive_omp_attributes (tree &attrs,
     }
 }
 
-/* Check if STD_ATTR contains a musttail attribute and remove if it
-   precedes a return.  PARSER is the parser and ATTR is the output
-   attr_state.  */
-
-static tree
-c_parser_handle_musttail (c_parser *parser, tree std_attrs, attr_state &attr)
-{
-  if (c_parser_next_token_is_keyword (parser, RID_RETURN))
-    {
-      if (lookup_attribute ("gnu", "musttail", std_attrs))
-	{
-	  std_attrs = remove_attribute ("gnu", "musttail", std_attrs);
-	  attr.musttail_p = true;
-	}
-      if (lookup_attribute ("clang", "musttail", std_attrs))
-	{
-	  std_attrs = remove_attribute ("clang", "musttail", std_attrs);
-	  attr.musttail_p = true;
-	}
-    }
-  return std_attrs;
-}
-
 /* Parse a compound statement except for the opening brace.  This is
    used for parsing both compound statements and statement expressions
    (which follow different paths to handling the opening).  */
@@ -7028,7 +6998,6 @@ c_parser_compound_statement_nostart (c_parser *parser)
   bool in_omp_loop_block
     = omp_for_parse_state ? omp_for_parse_state->want_nested_loop : false;
   tree sl = NULL_TREE;
-  attr_state a = {};
 
   if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
     {
@@ -7169,10 +7138,7 @@ c_parser_compound_statement_nostart (c_parser *parser)
 	= c_parser_nth_token_starts_std_attributes (parser, 1);
       tree std_attrs = NULL_TREE;
       if (have_std_attrs)
-	{
-	  std_attrs = c_parser_std_attribute_specifier_sequence (parser);
-	  std_attrs = c_parser_handle_musttail (parser, std_attrs, a);
-	}
+	std_attrs = c_parser_std_attribute_specifier_sequence (parser);
       if (c_parser_next_token_is_keyword (parser, RID_CASE)
 	  || c_parser_next_token_is_keyword (parser, RID_DEFAULT)
 	  || (c_parser_next_token_is (parser, CPP_NAME)
@@ -7320,7 +7286,7 @@ c_parser_compound_statement_nostart (c_parser *parser)
 	  last_stmt = true;
 	  mark_valid_location_for_stdc_pragma (false);
 	  if (!omp_for_parse_state)
-	    c_parser_statement_after_labels (parser, NULL, NULL, a);
+	    c_parser_statement_after_labels (parser, NULL);
 	  else
 	    {
 	      /* In canonical loop nest form, nested loops can only appear
@@ -7362,20 +7328,15 @@ c_parser_compound_statement_nostart (c_parser *parser)
 /* Parse all consecutive labels, possibly preceded by standard
    attributes.  In this context, a statement is required, not a
    declaration, so attributes must be followed by a statement that is
-   not just a semicolon.  Returns an attr_state.  */
+   not just a semicolon.  */
 
-static attr_state
+static void
 c_parser_all_labels (c_parser *parser)
 {
-  attr_state attr = {};
   bool have_std_attrs;
   tree std_attrs = NULL;
   if ((have_std_attrs = c_parser_nth_token_starts_std_attributes (parser, 1)))
-    {
-      std_attrs = c_parser_std_attribute_specifier_sequence (parser);
-      std_attrs = c_parser_handle_musttail (parser, std_attrs, attr);
-    }
-
+    std_attrs = c_parser_std_attribute_specifier_sequence (parser);
   while (c_parser_next_token_is_keyword (parser, RID_CASE)
 	 || c_parser_next_token_is_keyword (parser, RID_DEFAULT)
 	 || (c_parser_next_token_is (parser, CPP_NAME)
@@ -7385,10 +7346,7 @@ c_parser_all_labels (c_parser *parser)
       std_attrs = NULL;
       if ((have_std_attrs = c_parser_nth_token_starts_std_attributes (parser,
 								      1)))
-	{
-	  std_attrs = c_parser_std_attribute_specifier_sequence (parser);
-	  std_attrs = c_parser_handle_musttail (parser, std_attrs, attr);
-	}
+	std_attrs = c_parser_std_attribute_specifier_sequence (parser);
     }
   if (std_attrs
       && (!c_parser_handle_statement_omp_attributes (parser, std_attrs, &have_std_attrs)
@@ -7400,7 +7358,6 @@ c_parser_all_labels (c_parser *parser)
     }
   else if (have_std_attrs && c_parser_next_token_is (parser, CPP_SEMICOLON))
     c_parser_error (parser, "expected statement");
-  return attr;
 }
 
 /* Parse a label (C90 6.6.1, C99 6.8.1, C11 6.8.1).
@@ -7644,11 +7601,11 @@ c_parser_label (c_parser *parser, tree std_attrs)
 static void
 c_parser_statement (c_parser *parser, bool *if_p, location_t *loc_after_labels)
 {
-  attr_state a = c_parser_all_labels (parser);
+  c_parser_all_labels (parser);
   if (loc_after_labels)
     *loc_after_labels = c_parser_peek_token (parser)->location;
   parser->omp_attrs_forbidden_p = false;
-  c_parser_statement_after_labels (parser, if_p, NULL, a);
+  c_parser_statement_after_labels (parser, if_p, NULL);
 }
 
 /* Parse a statement, other than a labeled statement.  CHAIN is a vector
@@ -7657,11 +7614,11 @@ c_parser_statement (c_parser *parser, bool *if_p, location_t *loc_after_labels)
 
    IF_P is used to track whether there's a (possibly labeled) if statement
    which is not enclosed in braces and has an else clause.  This is used to
-   implement -Wparentheses.  ASTATE is an earlier parsed attribute state.  */
+   implement -Wparentheses.  */
 
 static void
 c_parser_statement_after_labels (c_parser *parser, bool *if_p,
-				 vec<tree> *chain, attr_state astate)
+				 vec<tree> *chain)
 {
   location_t loc = c_parser_peek_token (parser)->location;
   tree stmt = NULL_TREE;
@@ -7729,8 +7686,7 @@ c_parser_statement_after_labels (c_parser *parser, bool *if_p,
 	  c_parser_consume_token (parser);
 	  if (c_parser_next_token_is (parser, CPP_SEMICOLON))
 	    {
-	      stmt = c_finish_return (loc, NULL_TREE, NULL_TREE,
-				      astate.musttail_p);
+	      stmt = c_finish_return (loc, NULL_TREE, NULL_TREE);
 	      c_parser_consume_token (parser);
 	    }
 	  else
@@ -7739,8 +7695,7 @@ c_parser_statement_after_labels (c_parser *parser, bool *if_p,
 	      struct c_expr expr = c_parser_expression_conv (parser);
 	      mark_exp_read (expr.value);
 	      stmt = c_finish_return (EXPR_LOC_OR_LOC (expr.value, xloc),
-				      expr.value, expr.original_type,
-				      astate.musttail_p);
+				      expr.value, expr.original_type);
 	      goto expect_semicolon;
 	    }
 	  break;
diff --git a/gcc/c/c-tree.h b/gcc/c/c-tree.h
index 3dc6338..15da875 100644
--- a/gcc/c/c-tree.h
+++ b/gcc/c/c-tree.h
@@ -827,7 +827,7 @@ extern tree c_begin_stmt_expr (void);
 extern tree c_finish_stmt_expr (location_t, tree);
 extern tree c_process_expr_stmt (location_t, tree);
 extern tree c_finish_expr_stmt (location_t, tree);
-extern tree c_finish_return (location_t, tree, tree, bool = false);
+extern tree c_finish_return (location_t, tree, tree);
 extern tree c_finish_bc_stmt (location_t, tree, bool);
 extern tree c_finish_goto_label (location_t, tree);
 extern tree c_finish_goto_ptr (location_t, c_expr val);
diff --git a/gcc/c/c-typeck.cc b/gcc/c/c-typeck.cc
index 094e41f..7e0f01e 100644
--- a/gcc/c/c-typeck.cc
+++ b/gcc/c/c-typeck.cc
@@ -11725,11 +11725,10 @@ c_finish_goto_ptr (location_t loc, c_expr val)
    to return, or a null pointer for `return;' with no value.  LOC is
    the location of the return statement, or the location of the expression,
    if the statement has any.  If ORIGTYPE is not NULL_TREE, it
-   is the original type of RETVAL.  MUSTTAIL_P indicates a musttail
-   attribute.  */
+   is the original type of RETVAL.  */
 
 tree
-c_finish_return (location_t loc, tree retval, tree origtype, bool musttail_p)
+c_finish_return (location_t loc, tree retval, tree origtype)
 {
   tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl)), ret_stmt;
   bool no_warning = false;
@@ -11743,8 +11742,6 @@ c_finish_return (location_t loc, tree retval, tree origtype, bool musttail_p)
     warning_at (xloc, 0,
 		"function declared %<noreturn%> has a %<return%> statement");
 
-  set_musttail_on_return (retval, xloc, musttail_p);
-
   if (retval)
     {
       tree semantic_type = NULL_TREE;