c-common.c (lang_gimplify_stmt): Remove next_p argument.

	* c-common.c (lang_gimplify_stmt): Remove next_p argument.
	(if_elt, if_stack, if_stack_space, c_expand_start_cond, c_finish_then,
	c_expand_end_cond, c_expand_start_else, c_finish_else, c_begin_if_stmt,
	c_begin_while_stmt, c_finish_while_stmt_cond): Move to c-typeck.c.
	(finish_fname_decls, fname_decl): Use statement_lists.
	(c_expand_expr_stmt): Don't set last_expr_type.
	(c_type_hash): Fix indentation.
	(c_safe_from_p): Don't follow TREE_CHAIN.
	(c_tree_chain_matters_p): Remove.
	* c-common.def (SCOPE_STMT): Remove.
	(CLEANUP_STMT): Redefine to contain its own body.
	* c-common.h (struct stmt_tree_s): Remove x_last_stmt,
	x_last_expr_type, x_last_expr_filename, x_scope_stmt_stack.
	Add x_cur_stmt_list.
	(last_tree, last_expr_type, last_expr_filename, RECHAIN_STMTS): Remove.
	(cur_stmt_list): New.
	(STATEMENT_LIST_STMT_EXPR): New.
	(SCOPE_BEGIN_P, SCOPE_END_P, SCOPE_STMT_BLOCK, SCOPE_NULLIFIED_P,
	SCOPE_NO_CLEANUPS_P, SCOPE_PARTIAL_P, NEW_FOR_SCOPE_P): Remove.
	(CLEANUP_BODY): New.
	(CLEANUP_DECL): Move to operand 2.
	(c_common_stmt_codes): Remove SCOPE_STMT.
	(COMPOUND_STMT_NO_SCOPE, COMPOUND_STMT_BODY_BLOCK): Remove.
	* c-decl.c (c_scope_stmt_stack, current_scope_stmt_stack): Remove.
	(c_push_function_context, c_pop_function_context): Don't save it.
	(finish_decl): Set TREE_USED on the decl for a cleanup.
	Use push_cleanup.
	(store_parm_decls): Use statement lists.
	(finish_function): Remove compstmt rule workaround.  Use statement
	lists.  Call finish_fname_decls after finalizing the body.
	(c_begin_compound_stmt): Move to c-typeck.c.
	* c-dump.c (c_dump_tree): Remove SCOPE_STMT.
	* c-gimplify.c (gimplify_cleanup_stmt, gimplify_cleanup_stmts): New.
	(c_genericize): Invoke them.
	(c_gimplify_stmt): Don't look through TREE_CHAIN.  Kill SCOPE_STMT.
	(c_build_bind_expr): Export.
	(gimplify_block, gimplify_cleanup): Remove.
	(gimplify_condition): Use gimplify_stmt.
	(gimplify_for_stmt): Remove FOR_INIT_STMT chaining hack.
	(gimplify_if_stmt): Remove recursion hack.
	(c_gimplify_expr): Remove STMT_EXPR handling.
	(stmt_expr_last_stmt, gimplify_stmt_expr): Remove.
	(is_last_stmt_of_scope): Remove.
	* c-lang.c (LANG_HOOKS_TREE_INLINING_TREE_CHAIN_MATTERS_P): Remove.
	* c-mudflap.c (mflang_flush_calls): Use c_begin_compound_stmt,
	c_end_compound_stmt.
	* c-objc-common.c (build_cdtor): Likewise.
	* c-parse.in (primary): Use c_finish_stmt_expr.
	(push_scope, pop_scope): Remove.
	(c99_block_start, compstmt_start): Use c_begin_compound_stmt.
	(c99_block_end, compstmt): Use c_end_compound_stmt.
	(c99_block_lineno_labeled_stmt): Likewise.
	(compstmt_primary_start): Use c_begin_stmt_expr.
	(simple_if, select_or_iter_stmt): Update calls to stmt builders.
	(do_stmt_start): Fill in body directly.
	(lineno_stmt): Avoid setting lineno on constants.
	* c-pretty-print.c (pp_c_statement): Handle STATEMENT_LIST.
	Remove SCOPE_STMT.
	* c-semantics.c (begin_stmt_tree): Remove.
	(push_stmt_list, re_push_stmt_list, pop_stmt_list): New.
	(add_stmt): Use statement lists.
	(add_scope_stmt, finish_stmt_tree): Remove.
	(push_cleanup): New.
	* c-tree.h: Move some decls from c-common.h.
	* c-typeck.c (c_tree_expr_nonnegative_p): Simplify for statement lists.
	(do_case, c_finish_case): Likewise.
	(c_finish_then): Take body for then as argument.
	(c_finish_else): Similarly.
	(c_begin_for_stmt, c_finish_for_stmt_init, c_finish_for_stmt_cond,
	c_finish_for_stmt_incr, c_finish_for_stmt): New.
	(c_begin_stmt_expr, c_finish_stmt_expr): New.
	(c_begin_compound_stmt): Do scope management.
	(c_end_compound_stmt): New.
	* fold-const.c (tree_expr_nonnegative_p): Fix BIND_EXPR.
	* gimplify.c (voidify_wrapper_expr): Accept temporary argument.
	Look through exception handling constructs.
	(gimplify_bind_expr): Accept temporary argument.
	(gimplify_target_expr): Special case BIND_EXPR bodies.
	(gimplify_expr): Handle fallback == fb_none like a statement.
	* langhooks-def.h (LANG_HOOKS_TREE_INLINING_TREE_CHAIN_MATTERS_P): Kill.
	* langhooks.c (lhd_tree_inlining_tree_chain_matters_p): Remove.
	* langhooks.h (tree_chain_matters_p): Remove.
	* stub-objc.c (objc_clear_super_receiver): New.
	* tree-gimple.h (voidify_wrapper_expr): Update decl.
	(append_to_statement_list, append_to_statement_list_force): Move
	to tree-iterator.h.
	* tree-inline.c (expand_call_inline): Update call.
	(clone_body): Use statement lists.
	(walk_tree): Don't check tree_chain_matters_p.
	(copy_tree_r): Likewise.
	* tree-iterator.c (alloc_stmt_list): Clear lang bits.
	(tsi_link_before, tsi_link_after): Set TREE_SIDE_EFFECTS properly.
	* tree-iterator.h (append_to_statement_list,
	append_to_statement_list_force): Moved from tree-gimple.h.
	* tree-pretty-print.c (dump_generic_node): Clean up TARGET_EXPR dump.
	* objc/objc-act.c (build_module_descriptor): Use c_begin_compound_stmt.
	(objc_enter_block): Likewise.
	(objc_exit_block): Use c_end_compound_stmt.
	(objc_build_try_enter_fragment): Add #error and comment for
	rewriting for OBJCPLUS.
	(objc_build_extract_fragment, objc_build_try_epilogue,
	objc_build_catch_stmt, objc_build_finally_prologue,
	objc_build_finally_epilogue): Update for C statement builders.
	* objc/objc-lang.c (LANG_HOOKS_TREE_INLINING_TREE_CHAIN_MATTERS_P):
	Remove.
cp/
	* call.c (initialize_reference): Don't build CLEANUP_STMT here.
	* cp-gimplify.c (cp_gimplify_stmt): Remove next_p argument.
	(genericize_try_block): Use gimplify_stmt.
	(genericize_catch_block, genericize_eh_spec_block): Likewise.
	(cp_gimplify_init_expr): Remove STMT_EXPR special case.
	(gimplify_must_not_throw_expr): Update voidify_wrapper_expr call.
	* cp-lang.c (LANG_HOOKS_TREE_INLINING_TREE_CHAIN_MATTERS_P): Remove.
	(cp_tree_chain_matters_p): Remove.
	* cp-tree.h (COMPOUND_STMT_TRY_BLOCK): New.
	(COMPOUND_STMT_BODY_BLOCK): New.
	(STATEMENT_LIST_NO_SCOPE, STATEMENT_LIST_TRY_BLOCK): New.
	(EXPR_STMT_STMT_EXPR_RESULT): New.
	(building_stmt_tree): Check cur_stmt_list.
	(tf_stmt_expr_cmpd, tf_stmt_expr_body): Remove.
	(BCS_NO_SCOPE, BCS_TRY_BLOCK, BCS_FN_BODY): New.
	* decl.c (poplevel): Use pop_stmt_list for minding cleanups.
	(cp_finish_decl): Use push_cleanup.
	(start_function, finish_function): Use statement lists.
	(finish_stmt): Do nothing.
	* except.c (begin_eh_spec_block): Use statement lists.
	(check_handlers_1, check_handlers): Likewise.
	* init.c (construct_virtual_base): Don't add extra compound stmts.
	(build_vec_init): Likewise.
	* name-lookup.c (maybe_push_cleanup_level): Use statement lists.
	* name-lookup.h (struct cp_binding_level): Add statement_list.
	* parser.c (cp_parser_statement): Take the STMT_EXPR node, not a bool.
	(cp_parser_labeled_statement, cp_parser_expression_statement,
	cp_parser_statement_seq_opt): Likewise.
	(cp_parser_compound_statement): Likewise.  Take bool for try block.
	(cp_parser_selection_statement): Tidy if processing.
	(cp_parser_already_scoped_statement): Rewrite to do what it says.
	* pt.c (tsubst_copy): Move STMT_EXPR to tsubst_expr.
	(tsubst_expr): Rewrite STMT_EXPR processing.  Handle STATEMENT_LIST.
	Mind COMPOUND_STMT_TRY_BLOCK, EXPR_STMT_STMT_EXPR_RESULT.
	* semantics.c (do_poplevel, do_pushlevel): Use statement lists.
	(finish_cond): New, rewritten from FINISH_COND.
	(simplify_loop_decl_cond): New.
	(finish_expr_stmt): Avoid nested EXPR_STMTs.
	(begin_if_stmt, finish_if_stmt_cond, finish_then_clause,
	begin_else_clause, finish_else_clause, finish_if_stmt,
	begin_while_stmt, finish_while_stmt_cond, finish_while_stmt,
	begin_do_stmt, finish_do_body, begin_for_stmt, finish_for_init_stmt,
	finish_for_cond, finish_for_stmt, begin_switch_stmt,
	finish_switch_cond, finish_switch_stmt, begin_try_block,
	finish_try_block, finish_cleanup_try_block, finish_function_try_block,
	finish_handler_sequence, finish_function_handler_sequence,
	begin_handler, finish_handler_parms, finish_handler,
	begin_stmt_expr, finish_stmt_expr_expr, finish_stmt_expr): Rewrite
	using statement lists.
	(begin_compound_stmt): Replace has_no_scope argument with flags.
	Update all callers.  Use statement lists.
	(finish_compound_stmt): Likewise.
	(finish_decl_cleanup, finish_eh_cleanup): Use push_cleanup.
	(current_scope_stmt_stack): Remove.
	(simplify_aggr_init_expr): Don't muck with TREE_CHAIN.
	* typeck2.c (split_nonconstant_init_1, split_nonconstant_init):
	Rewrite with statement lists.
testsuite/
	* g++.dg/ext/stmtexpr1.C: XFAIL.
	* gcc.dg/20030612-1.c: XFAIL.

From-SVN: r83221

1 files changed, 57 insertions, 120 deletions

diff --git a/gcc/c-parse.in b/gcc/c-parse.in
index ad3fb6e..7589e73 100644
--- a/gcc/c-parse.in
+++ b/gcc/c-parse.in
@@ -208,10 +208,10 @@ do {									\
 %type <ttype> maybe_attribute attributes attribute attribute_list attrib
 %type <ttype> any_word
 
-%type <ttype> compstmt compstmt_start compstmt_nostart compstmt_primary_start
-%type <ttype> do_stmt_start pop_scope stmt label
+%type <ttype> compstmt compstmt_start compstmt_primary_start
+%type <ttype> do_stmt_start stmt label
 
-%type <ttype> c99_block_start c99_block_end
+%type <ttype> c99_block_start c99_block_lineno_labeled_stmt
 %type <ttype> declarator
 %type <ttype> notype_declarator after_type_declarator
 %type <ttype> parm_declarator
@@ -650,24 +650,12 @@ primary:
 	| '(' error ')'
 		{ $$ = error_mark_node; }
 	| compstmt_primary_start compstmt_nostart ')'
-                 { tree saved_last_tree;
-
-		   if (pedantic)
-		     pedwarn ("ISO C forbids braced-groups within expressions");
-		  saved_last_tree = COMPOUND_BODY ($1);
-		  RECHAIN_STMTS ($1, COMPOUND_BODY ($1));
-		  last_tree = saved_last_tree;
-		  TREE_CHAIN (last_tree) = NULL_TREE;
-		  if (!last_expr_type)
-		    last_expr_type = void_type_node;
-		  $$ = build1 (STMT_EXPR, last_expr_type, $1);
-		  TREE_SIDE_EFFECTS ($$) = 1;
-		  annotate_with_locus ($$, input_location);
+                { if (pedantic)
+		    pedwarn ("ISO C forbids braced-groups within expressions");
+		  $$ = c_finish_stmt_expr ($1);
 		}
 	| compstmt_primary_start error ')'
-		{
-		  last_tree = COMPOUND_BODY ($1);
-		  TREE_CHAIN (last_tree) = NULL_TREE;
+		{ c_finish_stmt_expr ($1);
 		  $$ = error_mark_node;
 		}
 	| primary '(' exprlist ')'   %prec '.'
@@ -2010,51 +1998,9 @@ lineno_stmt_decl_or_labels:
 errstmt:  error ';'
 	;
 
-push_scope:  /* empty */
-		{ push_scope ();
-		  clear_last_expr ();
-		  add_scope_stmt (/*begin_p=*/1, /*partial_p=*/0);
-		}
-	;
-
-pop_scope:  /* empty */
-                {
-@@ifobjc
-		  if (c_dialect_objc ())
-		    objc_clear_super_receiver ();
-@@end_ifobjc
-		  $$ = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/0);
-		}
-        ;
-
 /* Start and end blocks created for the new scopes of C99.  */
 c99_block_start: /* empty */
-		{ if (flag_isoc99)
-		    {
-		      $$ = c_begin_compound_stmt ();
-		      push_scope ();
-		      clear_last_expr ();
-		      add_scope_stmt (/*begin_p=*/1, /*partial_p=*/0);
-		    }
-		  else
-		    $$ = NULL_TREE;
-		}
-	;
-
-/* Productions using c99_block_start and c99_block_end will need to do what's
-   in compstmt: RECHAIN_STMTS ($1, COMPOUND_BODY ($1)); $$ = $2; where
-   $1 is the value of c99_block_start and $2 of c99_block_end.  */
-c99_block_end: /* empty */
-                { if (flag_isoc99)
-		    {
-		      tree scope_stmt = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/0);
-		      $$ = pop_scope ();
-		      SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmt))
-			= SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmt))
-			= $$;
-		    }
-		  else
-		    $$ = NULL_TREE; }
+		{ $$ = c_begin_compound_stmt (flag_isoc99); }
 	;
 
 /* Read zero or more forward-declarations for labels
@@ -2092,16 +2038,11 @@ compstmt_or_error:
 	;
 
 compstmt_start: '{' { compstmt_count++;
-                      $$ = c_begin_compound_stmt (); }
+                      $$ = c_begin_compound_stmt (true); }
         ;
 
 compstmt_nostart: '}'
-		{ $$ = convert (void_type_node, integer_zero_node); }
-	| push_scope maybe_label_decls compstmt_contents_nonempty '}' pop_scope
-		{ $$ = pop_scope ();
-		  SCOPE_STMT_BLOCK (TREE_PURPOSE ($5))
-		    = SCOPE_STMT_BLOCK (TREE_VALUE ($5))
-		    = $$; }
+	| maybe_label_decls compstmt_contents_nonempty '}'
 	;
 
 compstmt_contents_nonempty:
@@ -2113,30 +2054,24 @@ compstmt_primary_start:
 	'(' '{'
 		{ if (current_function_decl == 0)
 		    {
-		      error ("braced-group within expression allowed only inside a function");
+		      error ("braced-group within expression allowed "
+			     "only inside a function");
 		      YYERROR;
 		    }
-		  /* We must force a BLOCK for this level
-		     so that, if it is not expanded later,
-		     there is a way to turn off the entire subtree of blocks
-		     that are contained in it.  */
-		  keep_next_level ();
 		  compstmt_count++;
-		  $$ = add_stmt (build_stmt (COMPOUND_STMT, last_tree));
-		  last_expr_type = NULL_TREE;
+		  $$ = c_begin_stmt_expr ();
 		}
         ;
 
 compstmt: compstmt_start compstmt_nostart
-		{ RECHAIN_STMTS ($1, COMPOUND_BODY ($1));
-		  last_expr_type = NULL_TREE;
-                  $$ = $1; }
+		{ add_stmt (c_end_compound_stmt ($1, true));
+		  $$ = NULL_TREE; }
 	;
 
 /* Value is number of statements counted as of the closeparen.  */
 simple_if:
 	  if_prefix c99_block_lineno_labeled_stmt
-                { c_finish_then (); }
+                { c_finish_then ($2); }
 /* Make sure c_expand_end_cond is run once
    for each call to c_expand_start_cond.
    Otherwise a crash is likely.  */
@@ -2179,7 +2114,7 @@ do_stmt_start:
 		  DO_COND ($<ttype>$) = error_mark_node; }
 	  c99_block_lineno_labeled_stmt WHILE
 		{ $$ = $<ttype>2;
-		  RECHAIN_STMTS ($$, DO_BODY ($$));
+		  DO_BODY ($$) = $3;
 		  c_in_iteration_stmt--; }
 	;
 
@@ -2200,14 +2135,24 @@ lineno_labeled_stmt:
 
 /* Like lineno_labeled_stmt, but a block in C99.  */
 c99_block_lineno_labeled_stmt:
-	  c99_block_start lineno_labeled_stmt c99_block_end
-		{ if (flag_isoc99)
-		    RECHAIN_STMTS ($1, COMPOUND_BODY ($1)); }
+	  c99_block_start lineno_labeled_stmt
+                { $$ = c_end_compound_stmt ($1, flag_isoc99); }
 	;
 
 lineno_stmt:
 	  save_location stmt
-		{ if ($2)
+		{ 
+		  /* Two cases cannot and do not have line numbers associated:
+		     If stmt is degenerate, such as "2;", then stmt is an 
+		     INTEGER_CST, which cannot hold line numbers.  But that's
+		     ok because the statement will either be changed to a
+		     MODIFY_EXPR during gimplification of the statement expr,
+		     or discarded.  If stmt was compound, but without new
+		     variables, we will have skipped the creation of a BIND
+		     and will have a bare STATEMENT_LIST.  But that's ok
+		     because (recursively) all of the component statments
+		     should already have line numbers assigned.  */
+		  if ($2 && EXPR_P ($2))
 		    {
 		      SET_EXPR_LOCUS ($2, NULL);
 		      annotate_with_locus ($2, $1);
@@ -2230,7 +2175,7 @@ select_or_iter_stmt:
 		{ c_expand_start_else ();
 		  $<itype>1 = stmt_count; }
 	  c99_block_lineno_labeled_stmt
-                { c_finish_else ();
+                { c_finish_else ($4);
 		  c_expand_end_cond ();
 		  if (extra_warnings && stmt_count == $<itype>1)
 		    warning ("empty body in an else-statement"); }
@@ -2261,41 +2206,34 @@ select_or_iter_stmt:
 		  $<ttype>$ = c_begin_while_stmt (); }
 	  '(' expr ')'
                 { c_in_iteration_stmt++;
-		  $4 = lang_hooks.truthvalue_conversion ($4);
-		  c_finish_while_stmt_cond
-		    (lang_hooks.truthvalue_conversion ($4), $<ttype>2);
-		  $<ttype>$ = add_stmt ($<ttype>2); }
+		  c_finish_while_stmt_cond ($4, $<ttype>2); }
 	  c99_block_lineno_labeled_stmt
                 { c_in_iteration_stmt--;
-		  RECHAIN_STMTS ($<ttype>6, WHILE_BODY ($<ttype>6)); }
+		  c_finish_while_stmt ($7, $<ttype>2); }
 	| do_stmt_start
 	  '(' expr ')' ';'
                 { DO_COND ($1) = lang_hooks.truthvalue_conversion ($3); }
 	| do_stmt_start error
 		{ }
 	| FOR
-		{ $<ttype>$ = build_stmt (FOR_STMT, NULL_TREE, NULL_TREE,
-					  NULL_TREE, NULL_TREE);
-		  add_stmt ($<ttype>$); }
+		{ $<ttype>$ = c_begin_for_stmt (); }
 	  '(' for_init_stmt
 		{ stmt_count++;
-		  RECHAIN_STMTS ($<ttype>2, FOR_INIT_STMT ($<ttype>2)); }
+		  c_finish_for_stmt_init ($<ttype>2); }
 	  xexpr ';'
-                { if ($6)
-		    FOR_COND ($<ttype>2)
-		      = lang_hooks.truthvalue_conversion ($6); }
+                { c_finish_for_stmt_cond ($6, $<ttype>2); }
 	  xexpr ')'
                 { c_in_iteration_stmt++;
-		  FOR_EXPR ($<ttype>2) = $9; }
+		  c_finish_for_stmt_incr ($9, $<ttype>2); }
 	  c99_block_lineno_labeled_stmt
-                { RECHAIN_STMTS ($<ttype>2, FOR_BODY ($<ttype>2));
-		  c_in_iteration_stmt--;}
+                { c_finish_for_stmt ($12, $<ttype>2);
+		  c_in_iteration_stmt--; }
 	| SWITCH '(' expr ')'
 		{ stmt_count++;
 		  $<ttype>$ = c_start_case ($3);
 		  c_in_case_stmt++; }
 	  c99_block_lineno_labeled_stmt
-                { c_finish_case ();
+                { c_finish_case ($6);
 		  c_in_case_stmt--; }
 	;
 
@@ -2319,28 +2257,27 @@ stmt:
 	| expr ';'
 		{ stmt_count++;
 		  $$ = c_expand_expr_stmt ($1); }
-	| c99_block_start select_or_iter_stmt c99_block_end
-		{ if (flag_isoc99)
-		    RECHAIN_STMTS ($1, COMPOUND_BODY ($1));
+	| c99_block_start select_or_iter_stmt
+                { add_stmt (c_end_compound_stmt ($1, flag_isoc99));
 		  $$ = NULL_TREE; }
 	| BREAK ';'
 	        { stmt_count++;
-		if (!(c_in_iteration_stmt || c_in_case_stmt))
-		  {
-		    error ("break statement not within loop or switch");
-		    $$ = NULL_TREE;
-		  }
-		else
-		  $$ = add_stmt (build_break_stmt ()); }
+		  if (!(c_in_iteration_stmt || c_in_case_stmt))
+		    {
+		      error ("break statement not within loop or switch");
+		      $$ = NULL_TREE;
+		    }
+		  else
+		    $$ = add_stmt (build_break_stmt ()); }
 	| CONTINUE ';'
                 { stmt_count++;
-		if (!c_in_iteration_stmt)
-		  {
-		    error ("continue statement not within a loop");
-		    $$ = NULL_TREE;
-		  }
-		else
-		  $$ = add_stmt (build_continue_stmt ()); }
+		  if (!c_in_iteration_stmt)
+		    {
+		      error ("continue statement not within a loop");
+		      $$ = NULL_TREE;
+		    }
+		  else
+		    $$ = add_stmt (build_continue_stmt ()); }
 	| RETURN ';'
                 { stmt_count++;
 		  $$ = c_expand_return (NULL_TREE); }