1 /* This file contains the definitions and documentation for the common
2 tree codes used in the GNU C and C++ compilers (see c-common.def
3 for the standard codes).
4 Copyright (C) 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
5 Written by Benjamin Chelf (chelf@codesourcery.com).
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 2, or (at your option) any later
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING. If not, write to the Free
21 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
26 #include "coretypes.h"
30 #include "splay-tree.h"
42 #include "tree-inline.h"
44 /* If non-NULL, the address of a language-specific function for
45 expanding statements. */
46 void (*lang_expand_stmt) PARAMS ((tree));
48 /* If non-NULL, the address of a language-specific function for
49 expanding a DECL_STMT. After the language-independent cases are
50 handled, this function will be called. If this function is not
51 defined, it is assumed that declarations other than those for
52 variables and labels do not require any RTL generation. */
53 void (*lang_expand_decl_stmt) PARAMS ((tree));
55 static tree find_reachable_label_1 PARAMS ((tree *, int *, void *));
56 static tree find_reachable_label PARAMS ((tree));
57 static bool expand_unreachable_if_stmt PARAMS ((tree));
58 static tree expand_unreachable_stmt PARAMS ((tree, int));
60 /* Create an empty statement tree rooted at T. */
66 /* We create a trivial EXPR_STMT so that last_tree is never NULL in
67 what follows. We remove the extraneous statement in
69 *t = build_nt (EXPR_STMT, void_zero_node);
71 last_expr_type = NULL_TREE;
72 last_expr_filename = input_filename;
75 /* T is a statement. Add it to the statement-tree. */
81 if (input_filename != last_expr_filename)
83 /* If the filename has changed, also add in a FILE_STMT. Do a string
84 compare first, though, as it might be an equivalent string. */
85 int add = (strcmp (input_filename, last_expr_filename) != 0);
86 last_expr_filename = input_filename;
89 tree pos = build_nt (FILE_STMT, get_identifier (input_filename));
94 /* Add T to the statement-tree. */
95 TREE_CHAIN (last_tree) = t;
98 /* When we expand a statement-tree, we must know whether or not the
99 statements are full-expressions. We record that fact here. */
100 STMT_IS_FULL_EXPR_P (last_tree) = stmts_are_full_exprs_p ();
102 /* Keep track of the number of statements in this function. */
103 if (current_function_decl)
104 ++DECL_NUM_STMTS (current_function_decl);
109 /* Create a declaration statement for the declaration given by the
118 /* We need the type to last until instantiation time. */
119 decl_stmt = build_stmt (DECL_STMT, decl);
120 add_stmt (decl_stmt);
123 /* Add a scope-statement to the statement-tree. BEGIN_P indicates
124 whether this statements opens or closes a scope. PARTIAL_P is true
125 for a partial scope, i.e, the scope that begins after a label when
126 an object that needs a cleanup is created. If BEGIN_P is nonzero,
127 returns a new TREE_LIST representing the top of the SCOPE_STMT
128 stack. The TREE_PURPOSE is the new SCOPE_STMT. If BEGIN_P is
129 zero, returns a TREE_LIST whose TREE_VALUE is the new SCOPE_STMT,
130 and whose TREE_PURPOSE is the matching SCOPE_STMT with
131 SCOPE_BEGIN_P set. */
134 add_scope_stmt (begin_p, partial_p)
138 tree *stack_ptr = current_scope_stmt_stack ();
140 tree top = *stack_ptr;
142 /* Build the statement. */
143 ss = build_stmt (SCOPE_STMT, NULL_TREE);
144 SCOPE_BEGIN_P (ss) = begin_p;
145 SCOPE_PARTIAL_P (ss) = partial_p;
147 /* Keep the scope stack up to date. */
150 top = tree_cons (ss, NULL_TREE, top);
155 if (partial_p != SCOPE_PARTIAL_P (TREE_PURPOSE (top)))
157 TREE_VALUE (top) = ss;
158 *stack_ptr = TREE_CHAIN (top);
161 /* Add the new statement to the statement-tree. */
167 /* Finish the statement tree rooted at T. */
175 /* Remove the fake extra statement added in begin_stmt_tree. */
176 stmt = TREE_CHAIN (*t);
178 last_tree = NULL_TREE;
182 /* The line-number recorded in the outermost statement in a function
183 is the line number of the end of the function. */
184 STMT_LINENO (stmt) = input_line;
185 STMT_LINENO_FOR_FN_P (stmt) = 1;
189 /* Build a generic statement based on the given type of node and
190 arguments. Similar to `build_nt', except that we set
191 STMT_LINENO to be the current line number. */
192 /* ??? This should be obsolete with the lineno_stmt productions
196 build_stmt VPARAMS ((enum tree_code code, ...))
203 VA_FIXEDARG (p, enum tree_code, code);
205 t = make_node (code);
206 length = TREE_CODE_LENGTH (code);
207 STMT_LINENO (t) = input_line;
209 for (i = 0; i < length; i++)
210 TREE_OPERAND (t, i) = va_arg (p, tree);
216 /* Some statements, like for-statements or if-statements, require a
217 condition. This condition can be a declaration. If T is such a
218 declaration it is processed, and an expression appropriate to use
219 as the condition is returned. Otherwise, T itself is returned. */
225 if (t && TREE_CODE (t) == TREE_LIST)
227 expand_stmt (TREE_PURPOSE (t));
228 return TREE_VALUE (t);
234 /* Create RTL for the local static variable DECL. */
237 make_rtl_for_local_static (decl)
240 const char *asmspec = NULL;
242 /* If we inlined this variable, we could see it's declaration
244 if (TREE_ASM_WRITTEN (decl))
247 /* If the DECL_ASSEMBLER_NAME is not the same as the DECL_NAME, then
248 either we already created RTL for this DECL (and since it was a
249 local variable, its DECL_ASSEMBLER_NAME got hacked up to prevent
250 clashes with other local statics with the same name by a previous
251 call to make_decl_rtl), or the user explicitly requested a
252 particular assembly name for this variable, using the GNU
253 extension for this purpose:
257 There's no way to know which case we're in, here. But, it turns
258 out we're safe. If there's already RTL, then
259 rest_of_decl_compilation ignores the ASMSPEC parameter, so we
260 may as well not pass it in. If there isn't RTL, then we didn't
261 already create RTL, which means that the modification to
262 DECL_ASSEMBLER_NAME came only via the explicit extension. */
263 if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl)
264 && !DECL_RTL_SET_P (decl))
265 asmspec = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
267 rest_of_decl_compilation (decl, asmspec, /*top_level=*/0, /*at_end=*/0);
270 /* Let the back-end know about DECL. */
273 emit_local_var (decl)
276 /* Create RTL for this variable. */
277 if (!DECL_RTL_SET_P (decl))
279 if (DECL_C_HARD_REGISTER (decl))
280 /* The user specified an assembler name for this variable.
282 rest_of_decl_compilation
283 (decl, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
284 /*top_level=*/0, /*at_end=*/0);
289 if (DECL_INITIAL (decl))
291 /* Actually do the initialization. */
292 if (stmts_are_full_exprs_p ())
293 expand_start_target_temps ();
295 expand_decl_init (decl);
297 if (stmts_are_full_exprs_p ())
298 expand_end_target_temps ();
302 /* Helper for generating the RTL at the beginning of a scope. */
305 genrtl_do_pushlevel ()
307 emit_line_note (input_filename, input_line);
311 /* Generate the RTL for DESTINATION, which is a GOTO_STMT. */
314 genrtl_goto_stmt (destination)
317 if (TREE_CODE (destination) == IDENTIFIER_NODE)
320 /* We warn about unused labels with -Wunused. That means we have to
321 mark the used labels as used. */
322 if (TREE_CODE (destination) == LABEL_DECL)
323 TREE_USED (destination) = 1;
325 emit_line_note (input_filename, input_line);
327 if (TREE_CODE (destination) == LABEL_DECL)
329 label_rtx (destination);
330 expand_goto (destination);
333 expand_computed_goto (destination);
336 /* Generate the RTL for EXPR, which is an EXPR_STMT. Provided just
337 for backward compatibility. genrtl_expr_stmt_value() should be
338 used for new code. */
341 genrtl_expr_stmt (expr)
344 genrtl_expr_stmt_value (expr, -1, 1);
347 /* Generate the RTL for EXPR, which is an EXPR_STMT. WANT_VALUE tells
348 whether to (1) save the value of the expression, (0) discard it or
349 (-1) use expr_stmts_for_value to tell. The use of -1 is
350 deprecated, and retained only for backward compatibility.
351 MAYBE_LAST is nonzero if this EXPR_STMT might be the last statement
352 in expression statement. */
355 genrtl_expr_stmt_value (expr, want_value, maybe_last)
357 int want_value, maybe_last;
359 if (expr != NULL_TREE)
361 emit_line_note (input_filename, input_line);
363 if (stmts_are_full_exprs_p ())
364 expand_start_target_temps ();
366 if (expr != error_mark_node)
367 expand_expr_stmt_value (expr, want_value, maybe_last);
369 if (stmts_are_full_exprs_p ())
370 expand_end_target_temps ();
374 /* Generate the RTL for T, which is a DECL_STMT. */
381 emit_line_note (input_filename, input_line);
382 decl = DECL_STMT_DECL (t);
383 /* If this is a declaration for an automatic local
384 variable, initialize it. Note that we might also see a
385 declaration for a namespace-scope object (declared with
386 `extern'). We don't have to handle the initialization
387 of those objects here; they can only be declarations,
388 rather than definitions. */
389 if (TREE_CODE (decl) == VAR_DECL
390 && !TREE_STATIC (decl)
391 && !DECL_EXTERNAL (decl))
393 /* Let the back-end know about this variable. */
394 if (!anon_aggr_type_p (TREE_TYPE (decl)))
395 emit_local_var (decl);
397 expand_anon_union_decl (decl, NULL_TREE,
398 DECL_ANON_UNION_ELEMS (decl));
400 else if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
401 make_rtl_for_local_static (decl);
402 else if (TREE_CODE (decl) == LABEL_DECL
403 && C_DECLARED_LABEL_FLAG (decl))
404 declare_nonlocal_label (decl);
405 else if (lang_expand_decl_stmt)
406 (*lang_expand_decl_stmt) (t);
409 /* Generate the RTL for T, which is an IF_STMT. */
416 genrtl_do_pushlevel ();
417 cond = expand_cond (IF_COND (t));
418 emit_line_note (input_filename, input_line);
419 expand_start_cond (cond, 0);
422 tree nextt = THEN_CLAUSE (t);
424 if (cond && integer_zerop (cond))
425 nextt = expand_unreachable_stmt (nextt, warn_notreached);
431 tree nextt = ELSE_CLAUSE (t);
432 expand_start_else ();
433 if (cond && integer_nonzerop (cond))
434 nextt = expand_unreachable_stmt (nextt, warn_notreached);
440 /* Generate the RTL for T, which is a WHILE_STMT. */
443 genrtl_while_stmt (t)
446 tree cond = WHILE_COND (t);
449 emit_line_note (input_filename, input_line);
450 expand_start_loop (1);
451 genrtl_do_pushlevel ();
453 if (cond && !integer_nonzerop (cond))
455 cond = expand_cond (cond);
456 emit_line_note (input_filename, input_line);
457 expand_exit_loop_top_cond (0, cond);
458 genrtl_do_pushlevel ();
461 expand_stmt (WHILE_BODY (t));
466 /* Generate the RTL for T, which is a DO_STMT. */
472 tree cond = DO_COND (t);
474 /* Recognize the common special-case of do { ... } while (0) and do
475 not emit the loop widgetry in this case. In particular this
476 avoids cluttering the rtl with dummy loop notes, which can affect
477 alignment of adjacent labels. COND can be NULL due to parse
479 if (!cond || integer_zerop (cond))
481 expand_start_null_loop ();
482 expand_stmt (DO_BODY (t));
483 expand_end_null_loop ();
485 else if (integer_nonzerop (cond))
488 emit_line_note (input_filename, input_line);
489 expand_start_loop (1);
491 expand_stmt (DO_BODY (t));
493 emit_line_note (input_filename, input_line);
499 emit_line_note (input_filename, input_line);
500 expand_start_loop_continue_elsewhere (1);
502 expand_stmt (DO_BODY (t));
504 expand_loop_continue_here ();
505 cond = expand_cond (cond);
506 emit_line_note (input_filename, input_line);
507 expand_exit_loop_if_false (0, cond);
512 /* Build the node for a return statement and return it. */
515 build_return_stmt (expr)
518 return (build_stmt (RETURN_STMT, expr));
521 /* Generate the RTL for STMT, which is a RETURN_STMT. */
524 genrtl_return_stmt (stmt)
529 expr = RETURN_STMT_EXPR (stmt);
531 emit_line_note (input_filename, input_line);
533 expand_null_return ();
536 expand_start_target_temps ();
537 expand_return (expr);
538 expand_end_target_temps ();
542 /* Generate the RTL for T, which is a FOR_STMT. */
548 tree cond = FOR_COND (t);
549 location_t saved_loc;
551 if (NEW_FOR_SCOPE_P (t))
552 genrtl_do_pushlevel ();
554 expand_stmt (FOR_INIT_STMT (t));
556 /* Expand the initialization. */
558 emit_line_note (input_filename, input_line);
560 expand_start_loop_continue_elsewhere (1);
562 expand_start_loop (1);
563 genrtl_do_pushlevel ();
565 /* Save the filename and line number so that we expand the FOR_EXPR
566 we can reset them back to the saved values. */
567 saved_loc = input_location;
569 /* Expand the condition. */
570 if (cond && !integer_nonzerop (cond))
572 cond = expand_cond (cond);
573 emit_line_note (input_filename, input_line);
574 expand_exit_loop_top_cond (0, cond);
575 genrtl_do_pushlevel ();
578 /* Expand the body. */
579 expand_stmt (FOR_BODY (t));
581 /* Expand the increment expression. */
582 input_location = saved_loc;
583 emit_line_note (input_filename, input_line);
586 expand_loop_continue_here ();
587 genrtl_expr_stmt (FOR_EXPR (t));
592 /* Build a break statement node and return it. */
597 return (build_stmt (BREAK_STMT));
600 /* Generate the RTL for a BREAK_STMT. */
605 emit_line_note (input_filename, input_line);
606 if ( ! expand_exit_something ())
607 error ("break statement not within loop or switch");
610 /* Build a continue statement node and return it. */
613 build_continue_stmt ()
615 return (build_stmt (CONTINUE_STMT));
618 /* Generate the RTL for a CONTINUE_STMT. */
621 genrtl_continue_stmt ()
623 emit_line_note (input_filename, input_line);
624 if (! expand_continue_loop (0))
625 error ("continue statement not within a loop");
628 /* Generate the RTL for T, which is a SCOPE_STMT. */
631 genrtl_scope_stmt (t)
634 tree block = SCOPE_STMT_BLOCK (t);
636 if (!SCOPE_NO_CLEANUPS_P (t))
638 if (SCOPE_BEGIN_P (t))
639 expand_start_bindings_and_block (2 * SCOPE_NULLIFIED_P (t), block);
640 else if (SCOPE_END_P (t))
641 expand_end_bindings (NULL_TREE, !SCOPE_NULLIFIED_P (t), 0);
643 else if (!SCOPE_NULLIFIED_P (t))
645 rtx note = emit_note (NULL,
647 ? NOTE_INSN_BLOCK_BEG
648 : NOTE_INSN_BLOCK_END));
649 NOTE_BLOCK (note) = block;
652 /* If we're at the end of a scope that contains inlined nested
653 functions, we have to decide whether or not to write them out. */
654 if (block && SCOPE_END_P (t))
658 for (fn = BLOCK_VARS (block); fn; fn = TREE_CHAIN (fn))
660 if (TREE_CODE (fn) == FUNCTION_DECL
661 && DECL_CONTEXT (fn) == current_function_decl
662 && DECL_SAVED_INSNS (fn)
663 && !TREE_ASM_WRITTEN (fn)
664 && TREE_ADDRESSABLE (fn))
666 push_function_context ();
667 output_inline_function (fn);
668 pop_function_context ();
674 /* Generate the RTL for T, which is a SWITCH_STMT. */
677 genrtl_switch_stmt (t)
681 genrtl_do_pushlevel ();
683 cond = expand_cond (SWITCH_COND (t));
684 if (cond == error_mark_node)
685 /* The code is in error, but we don't want expand_end_case to
687 cond = boolean_false_node;
689 emit_line_note (input_filename, input_line);
690 expand_start_case (1, cond, TREE_TYPE (cond), "switch statement");
691 expand_stmt (expand_unreachable_stmt (SWITCH_BODY (t), warn_notreached));
692 expand_end_case_type (cond, SWITCH_TYPE (t));
695 /* Create a CASE_LABEL tree node and return it. */
698 build_case_label (low_value, high_value, label_decl)
703 return build_stmt (CASE_LABEL, low_value, high_value, label_decl);
707 /* Generate the RTL for a CASE_LABEL. */
710 genrtl_case_label (case_label)
716 cleanup = last_cleanup_this_contour ();
719 static int explained = 0;
720 warning ("destructor needed for `%#D'", (TREE_PURPOSE (cleanup)));
721 warning ("where case label appears here");
724 warning ("(enclose actions of previous case statements requiring destructors in their own scope.)");
729 add_case_node (CASE_LOW (case_label), CASE_HIGH (case_label),
730 CASE_LABEL_DECL (case_label), &duplicate);
733 /* Generate the RTL for T, which is a COMPOUND_STMT. */
736 genrtl_compound_stmt (t)
739 #ifdef ENABLE_CHECKING
740 struct nesting *n = current_nesting_level ();
743 expand_stmt (COMPOUND_BODY (t));
745 #ifdef ENABLE_CHECKING
746 /* Make sure that we've pushed and popped the same number of levels. */
747 if (!COMPOUND_STMT_NO_SCOPE (t) && n != current_nesting_level ())
752 /* Generate the RTL for an ASM_STMT. */
755 genrtl_asm_stmt (cv_qualifier, string, output_operands,
756 input_operands, clobbers, asm_input_p)
759 tree output_operands;
764 if (cv_qualifier != NULL_TREE
765 && cv_qualifier != ridpointers[(int) RID_VOLATILE])
767 warning ("%s qualifier ignored on asm",
768 IDENTIFIER_POINTER (cv_qualifier));
769 cv_qualifier = NULL_TREE;
772 emit_line_note (input_filename, input_line);
774 expand_asm (string, cv_qualifier != NULL_TREE);
776 c_expand_asm_operands (string, output_operands, input_operands,
777 clobbers, cv_qualifier != NULL_TREE,
778 input_filename, input_line);
781 /* Generate the RTL for a CLEANUP_STMT. */
784 genrtl_cleanup_stmt (t)
787 tree decl = CLEANUP_DECL (t);
788 if (!decl || (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node))
789 expand_decl_cleanup_eh (decl, CLEANUP_EXPR (t), CLEANUP_EH_ONLY (t));
792 /* We're about to expand T, a statement. Set up appropriate context
793 for the substitution. */
799 if (!STMT_LINENO_FOR_FN_P (t))
800 input_line = STMT_LINENO (t);
801 current_stmt_tree ()->stmts_are_full_exprs_p = STMT_IS_FULL_EXPR_P (t);
804 /* Generate the RTL for the statement T, its substatements, and any
805 other statements at its nesting level. */
811 while (t && t != error_mark_node)
813 int saved_stmts_are_full_exprs_p;
815 /* Set up context appropriately for handling this statement. */
816 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
819 switch (TREE_CODE (t))
822 input_filename = FILE_STMT_FILENAME (t);
826 genrtl_return_stmt (t);
827 t = expand_unreachable_stmt (TREE_CHAIN (t), warn_notreached);
831 genrtl_expr_stmt_value (EXPR_STMT_EXPR (t), TREE_ADDRESSABLE (t),
832 TREE_CHAIN (t) == NULL
833 || (TREE_CODE (TREE_CHAIN (t)) == SCOPE_STMT
834 && TREE_CHAIN (TREE_CHAIN (t)) == NULL));
838 genrtl_decl_stmt (t);
846 genrtl_while_stmt (t);
858 genrtl_compound_stmt (t);
862 genrtl_break_stmt ();
863 t = expand_unreachable_stmt (TREE_CHAIN (t), warn_notreached);
867 genrtl_continue_stmt ();
868 t = expand_unreachable_stmt (TREE_CHAIN (t), warn_notreached);
872 genrtl_switch_stmt (t);
876 genrtl_case_label (t);
880 expand_label (LABEL_STMT_LABEL (t));
884 /* Emit information for branch prediction. */
886 && TREE_CODE (GOTO_DESTINATION (t)) == LABEL_DECL
887 && flag_guess_branch_prob)
889 rtx note = emit_note (NULL, NOTE_INSN_PREDICTION);
891 NOTE_PREDICTION (note) = NOTE_PREDICT (PRED_GOTO, NOT_TAKEN);
893 genrtl_goto_stmt (GOTO_DESTINATION (t));
894 t = expand_unreachable_stmt (TREE_CHAIN (t), warn_notreached);
898 genrtl_asm_stmt (ASM_CV_QUAL (t), ASM_STRING (t),
899 ASM_OUTPUTS (t), ASM_INPUTS (t),
900 ASM_CLOBBERS (t), ASM_INPUT_P (t));
904 genrtl_scope_stmt (t);
908 genrtl_cleanup_stmt (t);
912 if (lang_expand_stmt)
913 (*lang_expand_stmt) (t);
919 /* Go on to the next statement in this scope. */
923 /* Restore saved state. */
924 current_stmt_tree ()->stmts_are_full_exprs_p
925 = saved_stmts_are_full_exprs_p;
929 /* If *TP is a potentially reachable label, return nonzero. */
932 find_reachable_label_1 (tp, walk_subtrees, data)
934 int *walk_subtrees ATTRIBUTE_UNUSED;
935 void *data ATTRIBUTE_UNUSED;
937 switch (TREE_CODE (*tp))
949 /* Determine whether expression EXP contains a potentially
952 find_reachable_label (exp)
955 location_t saved_loc = input_location;
956 tree ret = walk_tree (&exp, find_reachable_label_1, NULL, NULL);
957 input_location = saved_loc;
961 /* Expand an unreachable if statement, T. This function returns
962 true if the IF_STMT contains a potentially reachable code_label. */
964 expand_unreachable_if_stmt (t)
969 if (find_reachable_label (IF_COND (t)) != NULL_TREE)
975 if (THEN_CLAUSE (t) && ELSE_CLAUSE (t))
977 n = expand_unreachable_stmt (THEN_CLAUSE (t), 0);
983 label = gen_label_rtx ();
985 expand_stmt (expand_unreachable_stmt (ELSE_CLAUSE (t), 0));
990 n = expand_unreachable_stmt (ELSE_CLAUSE (t), 0);
992 else if (THEN_CLAUSE (t))
993 n = expand_unreachable_stmt (THEN_CLAUSE (t), 0);
994 else if (ELSE_CLAUSE (t))
995 n = expand_unreachable_stmt (ELSE_CLAUSE (t), 0);
1001 return n != NULL_TREE;
1004 /* Expand an unreachable statement list. This function skips all
1005 statements preceding the first potentially reachable label and
1006 then returns the label (or, in same cases, the statement after
1007 one containing the label). */
1009 expand_unreachable_stmt (t, warn)
1015 while (t && t != error_mark_node)
1018 switch (TREE_CODE (t))
1026 if (!STMT_LINENO_FOR_FN_P (t))
1027 input_line = STMT_LINENO (t);
1028 warning("will never be executed");
1036 switch (TREE_CODE (t))
1044 input_filename = FILE_STMT_FILENAME (t);
1048 if (find_reachable_label (RETURN_STMT_EXPR (t)) != NULL_TREE)
1053 if (find_reachable_label (EXPR_STMT_EXPR (t)) != NULL_TREE)
1058 if (expand_unreachable_if_stmt (t))
1059 return TREE_CHAIN (t);
1065 n = expand_unreachable_stmt (COMPOUND_BODY (t), warn);
1069 return TREE_CHAIN (t);
1076 saved = stmts_are_full_exprs_p ();
1078 genrtl_scope_stmt (t);
1079 current_stmt_tree ()->stmts_are_full_exprs_p = saved;