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, 2004 Free Software Foundation, Inc.
5 Written by Benjamin Chelf (chelf@codesourcery.com).
6
7 This file is part of GCC.
8
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
12 version.
13
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
17 for more details.
18
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
22 02111-1307, USA. */
23
24 #include "config.h"
25 #include "system.h"
26 #include "coretypes.h"
27 #include "tm.h"
28 #include "tree.h"
29 #include "function.h"
30 #include "splay-tree.h"
31 #include "varray.h"
32 #include "c-common.h"
33 #include "except.h"
34 /* In order for the format checking to accept the C frontend
35 diagnostic framework extensions, you must define this token before
36 including toplev.h. */
37 #define GCC_DIAG_STYLE __gcc_cdiag__
38 #include "toplev.h"
39 #include "flags.h"
40 #include "ggc.h"
41 #include "rtl.h"
42 #include "expr.h"
43 #include "output.h"
44 #include "timevar.h"
45 #include "predict.h"
46 #include "tree-inline.h"
47
48 /* If non-NULL, the address of a language-specific function for
49 expanding statements. */
50 void (*lang_expand_stmt) (tree);
51
52 /* If non-NULL, the address of a language-specific function for
53 expanding a DECL_STMT. After the language-independent cases are
54 handled, this function will be called. If this function is not
55 defined, it is assumed that declarations other than those for
56 variables and labels do not require any RTL generation. */
57 void (*lang_expand_decl_stmt) (tree);
58
59 static tree find_reachable_label_1 (tree *, int *, void *);
60 static tree find_reachable_label (tree);
61 static bool expand_unreachable_if_stmt (tree);
62 static tree expand_unreachable_stmt (tree, int);
63 static void genrtl_do_stmt_1 (tree, tree);
64
65 /* Create an empty statement tree rooted at T. */
66
67 void
begin_stmt_tree(tree * t)68 begin_stmt_tree (tree *t)
69 {
70 /* We create a trivial EXPR_STMT so that last_tree is never NULL in
71 what follows. We remove the extraneous statement in
72 finish_stmt_tree. */
73 *t = build_nt (EXPR_STMT, void_zero_node);
74 last_tree = *t;
75 last_expr_type = NULL_TREE;
76 last_expr_filename = input_filename;
77 }
78
79 /* T is a statement. Add it to the statement-tree. */
80
81 tree
add_stmt(tree t)82 add_stmt (tree t)
83 {
84 if (input_filename != last_expr_filename)
85 {
86 /* If the filename has changed, also add in a FILE_STMT. Do a string
87 compare first, though, as it might be an equivalent string. */
88 int add = (strcmp (input_filename, last_expr_filename) != 0);
89 last_expr_filename = input_filename;
90 if (add)
91 {
92 tree pos = build_nt (FILE_STMT, get_identifier (input_filename));
93 add_stmt (pos);
94 }
95 }
96
97 /* Add T to the statement-tree. */
98 TREE_CHAIN (last_tree) = t;
99 last_tree = t;
100
101 /* When we expand a statement-tree, we must know whether or not the
102 statements are full-expressions. We record that fact here. */
103 STMT_IS_FULL_EXPR_P (last_tree) = stmts_are_full_exprs_p ();
104
105 return t;
106 }
107
108 /* Create a declaration statement for the declaration given by the
109 DECL. */
110
111 void
add_decl_stmt(tree decl)112 add_decl_stmt (tree decl)
113 {
114 tree decl_stmt;
115
116 /* We need the type to last until instantiation time. */
117 decl_stmt = build_stmt (DECL_STMT, decl);
118 add_stmt (decl_stmt);
119 }
120
121 /* Add a scope-statement to the statement-tree. BEGIN_P indicates
122 whether this statements opens or closes a scope. PARTIAL_P is true
123 for a partial scope, i.e, the scope that begins after a label when
124 an object that needs a cleanup is created. If BEGIN_P is nonzero,
125 returns a new TREE_LIST representing the top of the SCOPE_STMT
126 stack. The TREE_PURPOSE is the new SCOPE_STMT. If BEGIN_P is
127 zero, returns a TREE_LIST whose TREE_VALUE is the new SCOPE_STMT,
128 and whose TREE_PURPOSE is the matching SCOPE_STMT with
129 SCOPE_BEGIN_P set. */
130
131 tree
add_scope_stmt(int begin_p,int partial_p)132 add_scope_stmt (int begin_p, int partial_p)
133 {
134 tree *stack_ptr = current_scope_stmt_stack ();
135 tree ss;
136 tree top = *stack_ptr;
137
138 /* Build the statement. */
139 ss = build_stmt (SCOPE_STMT, NULL_TREE);
140 SCOPE_BEGIN_P (ss) = begin_p;
141 SCOPE_PARTIAL_P (ss) = partial_p;
142
143 /* Keep the scope stack up to date. */
144 if (begin_p)
145 {
146 top = tree_cons (ss, NULL_TREE, top);
147 *stack_ptr = top;
148 }
149 else
150 {
151 if (partial_p != SCOPE_PARTIAL_P (TREE_PURPOSE (top)))
152 abort ();
153 TREE_VALUE (top) = ss;
154 *stack_ptr = TREE_CHAIN (top);
155 }
156
157 /* Add the new statement to the statement-tree. */
158 add_stmt (ss);
159
160 return top;
161 }
162
163 /* Finish the statement tree rooted at T. */
164
165 void
finish_stmt_tree(tree * t)166 finish_stmt_tree (tree *t)
167 {
168 tree stmt;
169
170 /* Remove the fake extra statement added in begin_stmt_tree. */
171 stmt = TREE_CHAIN (*t);
172 *t = stmt;
173 last_tree = NULL_TREE;
174
175 if (cfun && stmt)
176 {
177 /* The line-number recorded in the outermost statement in a function
178 is the line number of the end of the function. */
179 STMT_LINENO (stmt) = input_line;
180 STMT_LINENO_FOR_FN_P (stmt) = 1;
181 }
182 }
183
184 /* Build a generic statement based on the given type of node and
185 arguments. Similar to `build_nt', except that we set
186 STMT_LINENO to be the current line number. */
187 /* ??? This should be obsolete with the lineno_stmt productions
188 in the grammar. */
189
190 tree
build_stmt(enum tree_code code,...)191 build_stmt (enum tree_code code, ...)
192 {
193 tree t;
194 int length;
195 int i;
196 va_list p;
197
198 va_start (p, code);
199
200 t = make_node (code);
201 length = TREE_CODE_LENGTH (code);
202 STMT_LINENO (t) = input_line;
203
204 for (i = 0; i < length; i++)
205 TREE_OPERAND (t, i) = va_arg (p, tree);
206
207 va_end (p);
208 return t;
209 }
210
211 /* Some statements, like for-statements or if-statements, require a
212 condition. This condition can be a declaration. If T is such a
213 declaration it is processed, and an expression appropriate to use
214 as the condition is returned. Otherwise, T itself is returned. */
215
216 tree
expand_cond(tree t)217 expand_cond (tree t)
218 {
219 if (t && TREE_CODE (t) == TREE_LIST)
220 {
221 expand_stmt (TREE_PURPOSE (t));
222 return TREE_VALUE (t);
223 }
224 else
225 return t;
226 }
227
228 /* Create RTL for the local static variable DECL. */
229
230 void
make_rtl_for_local_static(tree decl)231 make_rtl_for_local_static (tree decl)
232 {
233 const char *asmspec = NULL;
234
235 /* If we inlined this variable, we could see it's declaration
236 again. */
237 if (TREE_ASM_WRITTEN (decl))
238 return;
239
240 /* If the DECL_ASSEMBLER_NAME is not the same as the DECL_NAME, then
241 either we already created RTL for this DECL (and since it was a
242 local variable, its DECL_ASSEMBLER_NAME got hacked up to prevent
243 clashes with other local statics with the same name by a previous
244 call to make_decl_rtl), or the user explicitly requested a
245 particular assembly name for this variable, using the GNU
246 extension for this purpose:
247
248 int i asm ("j");
249
250 There's no way to know which case we're in, here. But, it turns
251 out we're safe. If there's already RTL, then
252 rest_of_decl_compilation ignores the ASMSPEC parameter, so we
253 may as well not pass it in. If there isn't RTL, then we didn't
254 already create RTL, which means that the modification to
255 DECL_ASSEMBLER_NAME came only via the explicit extension. */
256 if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl)
257 && !DECL_RTL_SET_P (decl))
258 asmspec = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
259
260 rest_of_decl_compilation (decl, asmspec, /*top_level=*/0, /*at_end=*/0);
261 }
262
263 /* Let the back-end know about DECL. */
264
265 void
emit_local_var(tree decl)266 emit_local_var (tree decl)
267 {
268 /* Create RTL for this variable. */
269 if (!DECL_RTL_SET_P (decl))
270 {
271 if (DECL_C_HARD_REGISTER (decl))
272 /* The user specified an assembler name for this variable.
273 Set that up now. */
274 rest_of_decl_compilation
275 (decl, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
276 /*top_level=*/0, /*at_end=*/0);
277 else
278 expand_decl (decl);
279 }
280
281 if (DECL_INITIAL (decl))
282 {
283 /* Actually do the initialization. */
284 if (stmts_are_full_exprs_p ())
285 expand_start_target_temps ();
286
287 expand_decl_init (decl);
288
289 if (stmts_are_full_exprs_p ())
290 expand_end_target_temps ();
291 }
292 }
293
294 /* Helper for generating the RTL at the beginning of a scope. */
295
296 void
genrtl_do_pushlevel(void)297 genrtl_do_pushlevel (void)
298 {
299 emit_line_note (input_location);
300 clear_last_expr ();
301 }
302
303 /* Generate the RTL for DESTINATION, which is a GOTO_STMT. */
304
305 void
genrtl_goto_stmt(tree destination)306 genrtl_goto_stmt (tree destination)
307 {
308 if (TREE_CODE (destination) == IDENTIFIER_NODE)
309 abort ();
310
311 /* We warn about unused labels with -Wunused. That means we have to
312 mark the used labels as used. */
313 if (TREE_CODE (destination) == LABEL_DECL)
314 TREE_USED (destination) = 1;
315
316 emit_line_note (input_location);
317
318 if (TREE_CODE (destination) == LABEL_DECL)
319 {
320 label_rtx (destination);
321 expand_goto (destination);
322 }
323 else
324 expand_computed_goto (destination);
325 }
326
327 /* Generate the RTL for EXPR, which is an EXPR_STMT. Provided just
328 for backward compatibility. genrtl_expr_stmt_value() should be
329 used for new code. */
330
331 void
genrtl_expr_stmt(tree expr)332 genrtl_expr_stmt (tree expr)
333 {
334 genrtl_expr_stmt_value (expr, -1, 1);
335 }
336
337 /* Generate the RTL for EXPR, which is an EXPR_STMT. WANT_VALUE tells
338 whether to (1) save the value of the expression, (0) discard it or
339 (-1) use expr_stmts_for_value to tell. The use of -1 is
340 deprecated, and retained only for backward compatibility.
341 MAYBE_LAST is nonzero if this EXPR_STMT might be the last statement
342 in expression statement. */
343
344 void
genrtl_expr_stmt_value(tree expr,int want_value,int maybe_last)345 genrtl_expr_stmt_value (tree expr, int want_value, int maybe_last)
346 {
347 if (expr != NULL_TREE)
348 {
349 emit_line_note (input_location);
350
351 if (stmts_are_full_exprs_p ())
352 expand_start_target_temps ();
353
354 if (expr != error_mark_node)
355 expand_expr_stmt_value (expr, want_value, maybe_last);
356
357 if (stmts_are_full_exprs_p ())
358 expand_end_target_temps ();
359 }
360 }
361
362 /* Generate the RTL for T, which is a DECL_STMT. */
363
364 void
genrtl_decl_stmt(tree t)365 genrtl_decl_stmt (tree t)
366 {
367 tree decl;
368 emit_line_note (input_location);
369 decl = DECL_STMT_DECL (t);
370 /* If this is a declaration for an automatic local
371 variable, initialize it. Note that we might also see a
372 declaration for a namespace-scope object (declared with
373 `extern'). We don't have to handle the initialization
374 of those objects here; they can only be declarations,
375 rather than definitions. */
376 if (TREE_CODE (decl) == VAR_DECL
377 && !TREE_STATIC (decl)
378 && !DECL_EXTERNAL (decl))
379 {
380 /* Let the back-end know about this variable. */
381 if (!anon_aggr_type_p (TREE_TYPE (decl)))
382 emit_local_var (decl);
383 else
384 expand_anon_union_decl (decl, NULL_TREE,
385 DECL_ANON_UNION_ELEMS (decl));
386 }
387 else if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
388 make_rtl_for_local_static (decl);
389 else if (TREE_CODE (decl) == LABEL_DECL
390 && C_DECLARED_LABEL_FLAG (decl))
391 declare_nonlocal_label (decl);
392 else if (lang_expand_decl_stmt)
393 (*lang_expand_decl_stmt) (t);
394 }
395
396 /* Generate the RTL for T, which is an IF_STMT. */
397
398 void
genrtl_if_stmt(tree t)399 genrtl_if_stmt (tree t)
400 {
401 tree cond;
402 genrtl_do_pushlevel ();
403 cond = expand_cond (IF_COND (t));
404 emit_line_note (input_location);
405 expand_start_cond (cond, 0);
406 if (THEN_CLAUSE (t))
407 {
408 tree nextt = THEN_CLAUSE (t);
409
410 if (cond && integer_zerop (cond))
411 nextt = expand_unreachable_stmt (nextt, warn_notreached);
412 expand_stmt (nextt);
413 }
414
415 if (ELSE_CLAUSE (t))
416 {
417 tree nextt = ELSE_CLAUSE (t);
418 expand_start_else ();
419 if (cond && integer_nonzerop (cond))
420 nextt = expand_unreachable_stmt (nextt, warn_notreached);
421 expand_stmt (nextt);
422 }
423 expand_end_cond ();
424 }
425
426 /* Generate the RTL for T, which is a WHILE_STMT. */
427
428 void
genrtl_while_stmt(tree t)429 genrtl_while_stmt (tree t)
430 {
431 tree cond = WHILE_COND (t);
432
433 emit_line_note (input_location);
434 expand_start_loop (1);
435 genrtl_do_pushlevel ();
436
437 if (cond && !integer_nonzerop (cond))
438 {
439 cond = expand_cond (cond);
440 emit_line_note (input_location);
441 expand_exit_loop_top_cond (0, cond);
442 genrtl_do_pushlevel ();
443 }
444
445 expand_stmt (WHILE_BODY (t));
446
447 expand_end_loop ();
448 }
449
450 /* Generate the RTL for a DO_STMT with condition COND and loop BODY
451 body. This is reused for expanding unreachable WHILE_STMTS. */
452
453 static void
genrtl_do_stmt_1(tree cond,tree body)454 genrtl_do_stmt_1 (tree cond, tree body)
455 {
456 /* Recognize the common special-case of do { ... } while (0) and do
457 not emit the loop widgetry in this case. In particular this
458 avoids cluttering the rtl with dummy loop notes, which can affect
459 alignment of adjacent labels. COND can be NULL due to parse
460 errors. */
461 if (!cond || integer_zerop (cond))
462 {
463 expand_start_null_loop ();
464 expand_stmt (body);
465 expand_end_null_loop ();
466 }
467 else if (integer_nonzerop (cond))
468 {
469 emit_line_note (input_location);
470 expand_start_loop (1);
471
472 expand_stmt (body);
473
474 emit_line_note (input_location);
475 expand_end_loop ();
476 }
477 else
478 {
479 emit_line_note (input_location);
480 expand_start_loop_continue_elsewhere (1);
481
482 expand_stmt (body);
483
484 expand_loop_continue_here ();
485 cond = expand_cond (cond);
486 emit_line_note (input_location);
487 expand_exit_loop_if_false (0, cond);
488 expand_end_loop ();
489 }
490 }
491
492 /* Generate the RTL for T, which is a DO_STMT. */
493
494 void
genrtl_do_stmt(tree t)495 genrtl_do_stmt (tree t)
496 {
497 genrtl_do_stmt_1 (DO_COND (t), DO_BODY (t));
498 }
499
500 /* Build the node for a return statement and return it. */
501
502 tree
build_return_stmt(tree expr)503 build_return_stmt (tree expr)
504 {
505 return (build_stmt (RETURN_STMT, expr));
506 }
507
508 /* Generate the RTL for STMT, which is a RETURN_STMT. */
509
510 void
genrtl_return_stmt(tree stmt)511 genrtl_return_stmt (tree stmt)
512 {
513 tree expr;
514
515 expr = RETURN_STMT_EXPR (stmt);
516
517 emit_line_note (input_location);
518 if (!expr)
519 expand_null_return ();
520 else
521 {
522 expand_start_target_temps ();
523 expand_return (expr);
524 expand_end_target_temps ();
525 }
526 }
527
528 /* Generate the RTL for T, which is a FOR_STMT. */
529
530 void
genrtl_for_stmt(tree t)531 genrtl_for_stmt (tree t)
532 {
533 tree cond = FOR_COND (t);
534 location_t saved_loc;
535
536 if (NEW_FOR_SCOPE_P (t))
537 genrtl_do_pushlevel ();
538
539 expand_stmt (FOR_INIT_STMT (t));
540
541 /* Expand the initialization. */
542 emit_line_note (input_location);
543 if (FOR_EXPR (t))
544 expand_start_loop_continue_elsewhere (1);
545 else
546 expand_start_loop (1);
547 genrtl_do_pushlevel ();
548
549 /* Save the filename and line number so that we expand the FOR_EXPR
550 we can reset them back to the saved values. */
551 saved_loc = input_location;
552
553 /* Expand the condition. */
554 if (cond && !integer_nonzerop (cond))
555 {
556 cond = expand_cond (cond);
557 emit_line_note (input_location);
558 expand_exit_loop_top_cond (0, cond);
559 genrtl_do_pushlevel ();
560 }
561
562 /* Expand the body. */
563 expand_stmt (FOR_BODY (t));
564
565 /* Expand the increment expression. */
566 input_location = saved_loc;
567 emit_line_note (input_location);
568 if (FOR_EXPR (t))
569 {
570 expand_loop_continue_here ();
571 genrtl_expr_stmt (FOR_EXPR (t));
572 }
573 expand_end_loop ();
574 }
575
576 /* Build a break statement node and return it. */
577
578 tree
build_break_stmt(void)579 build_break_stmt (void)
580 {
581 return (build_stmt (BREAK_STMT));
582 }
583
584 /* Generate the RTL for a BREAK_STMT. */
585
586 void
genrtl_break_stmt(void)587 genrtl_break_stmt (void)
588 {
589 emit_line_note (input_location);
590 if ( ! expand_exit_something ())
591 abort ();
592 }
593
594 /* Build a continue statement node and return it. */
595
596 tree
build_continue_stmt(void)597 build_continue_stmt (void)
598 {
599 return (build_stmt (CONTINUE_STMT));
600 }
601
602 /* Generate the RTL for a CONTINUE_STMT. */
603
604 void
genrtl_continue_stmt(void)605 genrtl_continue_stmt (void)
606 {
607 emit_line_note (input_location);
608 if (! expand_continue_loop (0))
609 abort ();
610 }
611
612 /* Generate the RTL for T, which is a SCOPE_STMT. */
613
614 void
genrtl_scope_stmt(tree t)615 genrtl_scope_stmt (tree t)
616 {
617 tree block = SCOPE_STMT_BLOCK (t);
618
619 if (!SCOPE_NO_CLEANUPS_P (t))
620 {
621 if (SCOPE_BEGIN_P (t))
622 expand_start_bindings_and_block (2 * SCOPE_NULLIFIED_P (t), block);
623 else if (SCOPE_END_P (t))
624 expand_end_bindings (NULL_TREE, !SCOPE_NULLIFIED_P (t), 0);
625 }
626 else if (!SCOPE_NULLIFIED_P (t))
627 {
628 rtx note = emit_note (SCOPE_BEGIN_P (t)
629 ? NOTE_INSN_BLOCK_BEG : NOTE_INSN_BLOCK_END);
630 NOTE_BLOCK (note) = block;
631 }
632
633 /* If we're at the end of a scope that contains inlined nested
634 functions, we have to decide whether or not to write them out. */
635 if (block && SCOPE_END_P (t))
636 {
637 tree fn;
638
639 for (fn = BLOCK_VARS (block); fn; fn = TREE_CHAIN (fn))
640 {
641 if (TREE_CODE (fn) == FUNCTION_DECL
642 && DECL_CONTEXT (fn) == current_function_decl
643 && DECL_SAVED_INSNS (fn)
644 && DECL_SAVED_INSNS (fn)->saved_for_inline
645 && !TREE_ASM_WRITTEN (fn)
646 && TREE_ADDRESSABLE (fn))
647 {
648 push_function_context ();
649 output_inline_function (fn);
650 pop_function_context ();
651 }
652 }
653 }
654 }
655
656 /* Generate the RTL for T, which is a SWITCH_STMT. */
657
658 void
genrtl_switch_stmt(tree t)659 genrtl_switch_stmt (tree t)
660 {
661 tree cond;
662 genrtl_do_pushlevel ();
663
664 cond = expand_cond (SWITCH_COND (t));
665 if (cond == error_mark_node)
666 /* The code is in error, but we don't want expand_end_case to
667 crash. */
668 cond = truthvalue_false_node;
669
670 emit_line_note (input_location);
671 expand_start_case (1, cond, TREE_TYPE (cond), "switch statement");
672 expand_stmt (expand_unreachable_stmt (SWITCH_BODY (t), warn_notreached));
673 expand_end_case_type (cond, SWITCH_TYPE (t));
674 }
675
676 /* Create a CASE_LABEL tree node and return it. */
677
678 tree
build_case_label(tree low_value,tree high_value,tree label_decl)679 build_case_label (tree low_value, tree high_value, tree label_decl)
680 {
681 return build_stmt (CASE_LABEL, low_value, high_value, label_decl);
682 }
683
684
685 /* Generate the RTL for a CASE_LABEL. */
686
687 void
genrtl_case_label(tree case_label)688 genrtl_case_label (tree case_label)
689 {
690 tree duplicate;
691 tree cleanup;
692
693 cleanup = last_cleanup_this_contour ();
694 if (cleanup)
695 {
696 static int explained = 0;
697 warning ("destructor needed for `%D'", (TREE_PURPOSE (cleanup)));
698 warning ("where case label appears here");
699 if (!explained)
700 {
701 warning ("(enclose actions of previous case statements requiring destructors in their own scope.)");
702 explained = 1;
703 }
704 }
705
706 add_case_node (CASE_LOW (case_label), CASE_HIGH (case_label),
707 CASE_LABEL_DECL (case_label), &duplicate);
708 }
709
710 /* Generate the RTL for T, which is a COMPOUND_STMT. */
711
712 void
genrtl_compound_stmt(tree t)713 genrtl_compound_stmt (tree t)
714 {
715 #ifdef ENABLE_CHECKING
716 struct nesting *n = current_nesting_level ();
717 #endif
718
719 expand_stmt (COMPOUND_BODY (t));
720
721 #ifdef ENABLE_CHECKING
722 /* Make sure that we've pushed and popped the same number of levels. */
723 if (!COMPOUND_STMT_NO_SCOPE (t) && n != current_nesting_level ())
724 abort ();
725 #endif
726 }
727
728 /* Generate the RTL for an ASM_STMT. */
729
730 void
genrtl_asm_stmt(tree cv_qualifier,tree string,tree output_operands,tree input_operands,tree clobbers,int asm_input_p)731 genrtl_asm_stmt (tree cv_qualifier, tree string, tree output_operands,
732 tree input_operands, tree clobbers, int asm_input_p)
733 {
734 if (cv_qualifier != NULL_TREE
735 && cv_qualifier != ridpointers[(int) RID_VOLATILE])
736 {
737 warning ("%s qualifier ignored on asm",
738 IDENTIFIER_POINTER (cv_qualifier));
739 cv_qualifier = NULL_TREE;
740 }
741
742 emit_line_note (input_location);
743 if (asm_input_p)
744 expand_asm (string, cv_qualifier != NULL_TREE);
745 else
746 c_expand_asm_operands (string, output_operands, input_operands,
747 clobbers, cv_qualifier != NULL_TREE,
748 input_location);
749 }
750
751 /* Generate the RTL for a CLEANUP_STMT. */
752
753 void
genrtl_cleanup_stmt(tree t)754 genrtl_cleanup_stmt (tree t)
755 {
756 tree decl = CLEANUP_DECL (t);
757 if (!decl || !DECL_P (decl)
758 || (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node))
759 expand_decl_cleanup_eh (decl, CLEANUP_EXPR (t), CLEANUP_EH_ONLY (t));
760 }
761
762 /* We're about to expand T, a statement. Set up appropriate context
763 for the substitution. */
764
765 void
prep_stmt(tree t)766 prep_stmt (tree t)
767 {
768 if (!STMT_LINENO_FOR_FN_P (t))
769 input_line = STMT_LINENO (t);
770 current_stmt_tree ()->stmts_are_full_exprs_p = STMT_IS_FULL_EXPR_P (t);
771 }
772
773 /* Generate the RTL for the statement T, its substatements, and any
774 other statements at its nesting level. */
775
776 void
expand_stmt(tree t)777 expand_stmt (tree t)
778 {
779 while (t && t != error_mark_node)
780 {
781 int saved_stmts_are_full_exprs_p;
782
783 /* Set up context appropriately for handling this statement. */
784 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
785 prep_stmt (t);
786
787 switch (TREE_CODE (t))
788 {
789 case FILE_STMT:
790 input_filename = FILE_STMT_FILENAME (t);
791 break;
792
793 case RETURN_STMT:
794 genrtl_return_stmt (t);
795 t = expand_unreachable_stmt (TREE_CHAIN (t), warn_notreached);
796 goto process_t;
797
798 case EXPR_STMT:
799 genrtl_expr_stmt_value (EXPR_STMT_EXPR (t), TREE_ADDRESSABLE (t),
800 TREE_CHAIN (t) == NULL
801 || (TREE_CODE (TREE_CHAIN (t)) == SCOPE_STMT
802 && TREE_CHAIN (TREE_CHAIN (t)) == NULL));
803 break;
804
805 case DECL_STMT:
806 genrtl_decl_stmt (t);
807 break;
808
809 case FOR_STMT:
810 genrtl_for_stmt (t);
811 break;
812
813 case WHILE_STMT:
814 genrtl_while_stmt (t);
815 break;
816
817 case DO_STMT:
818 genrtl_do_stmt (t);
819 break;
820
821 case IF_STMT:
822 genrtl_if_stmt (t);
823 break;
824
825 case COMPOUND_STMT:
826 genrtl_compound_stmt (t);
827 break;
828
829 case BREAK_STMT:
830 genrtl_break_stmt ();
831 t = expand_unreachable_stmt (TREE_CHAIN (t), warn_notreached);
832 goto process_t;
833
834 case CONTINUE_STMT:
835 genrtl_continue_stmt ();
836 t = expand_unreachable_stmt (TREE_CHAIN (t), warn_notreached);
837 goto process_t;
838
839 case SWITCH_STMT:
840 genrtl_switch_stmt (t);
841 break;
842
843 case CASE_LABEL:
844 genrtl_case_label (t);
845 break;
846
847 case LABEL_STMT:
848 expand_label (LABEL_STMT_LABEL (t));
849 break;
850
851 case GOTO_STMT:
852 /* Emit information for branch prediction. */
853 if (!GOTO_FAKE_P (t)
854 && TREE_CODE (GOTO_DESTINATION (t)) == LABEL_DECL
855 && flag_guess_branch_prob)
856 {
857 rtx note = emit_note (NOTE_INSN_PREDICTION);
858
859 NOTE_PREDICTION (note) = NOTE_PREDICT (PRED_GOTO, NOT_TAKEN);
860 }
861 genrtl_goto_stmt (GOTO_DESTINATION (t));
862 t = expand_unreachable_stmt (TREE_CHAIN (t), warn_notreached);
863 goto process_t;
864
865 case ASM_STMT:
866 genrtl_asm_stmt (ASM_CV_QUAL (t), ASM_STRING (t),
867 ASM_OUTPUTS (t), ASM_INPUTS (t),
868 ASM_CLOBBERS (t), ASM_INPUT_P (t));
869 break;
870
871 case SCOPE_STMT:
872 genrtl_scope_stmt (t);
873 break;
874
875 case CLEANUP_STMT:
876 genrtl_cleanup_stmt (t);
877 break;
878
879 default:
880 if (lang_expand_stmt)
881 (*lang_expand_stmt) (t);
882 else
883 abort ();
884 break;
885 }
886
887 /* Go on to the next statement in this scope. */
888 t = TREE_CHAIN (t);
889
890 process_t:
891 /* Restore saved state. */
892 current_stmt_tree ()->stmts_are_full_exprs_p
893 = saved_stmts_are_full_exprs_p;
894 }
895 }
896
897 /* If *TP is a potentially reachable label, return nonzero. */
898
899 static tree
find_reachable_label_1(tree * tp,int * walk_subtrees ATTRIBUTE_UNUSED,void * data ATTRIBUTE_UNUSED)900 find_reachable_label_1 (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
901 void *data ATTRIBUTE_UNUSED)
902 {
903 switch (TREE_CODE (*tp))
904 {
905 case LABEL_STMT:
906 case CASE_LABEL:
907 return *tp;
908
909 default:
910 break;
911 }
912 return NULL_TREE;
913 }
914
915 /* Determine whether expression EXP contains a potentially
916 reachable label. */
917 static tree
find_reachable_label(tree exp)918 find_reachable_label (tree exp)
919 {
920 location_t saved_loc = input_location;
921 tree ret = walk_tree_without_duplicates
922 (&exp, find_reachable_label_1, NULL);
923 input_location = saved_loc;
924 return ret;
925 }
926
927 /* Expand an unreachable if statement, T. This function returns
928 true if the IF_STMT contains a potentially reachable code_label. */
929 static bool
expand_unreachable_if_stmt(tree t)930 expand_unreachable_if_stmt (tree t)
931 {
932 tree n;
933
934 if (find_reachable_label (IF_COND (t)) != NULL_TREE)
935 {
936 genrtl_if_stmt (t);
937 return true;
938 }
939
940 if (THEN_CLAUSE (t) && ELSE_CLAUSE (t))
941 {
942 n = expand_unreachable_stmt (THEN_CLAUSE (t), 0);
943
944 if (n != NULL_TREE)
945 {
946 rtx label;
947 expand_stmt (n);
948 label = gen_label_rtx ();
949 emit_jump (label);
950 expand_stmt (expand_unreachable_stmt (ELSE_CLAUSE (t), 0));
951 emit_label (label);
952 return true;
953 }
954 else
955 n = expand_unreachable_stmt (ELSE_CLAUSE (t), 0);
956 }
957 else if (THEN_CLAUSE (t))
958 n = expand_unreachable_stmt (THEN_CLAUSE (t), 0);
959 else if (ELSE_CLAUSE (t))
960 n = expand_unreachable_stmt (ELSE_CLAUSE (t), 0);
961 else
962 n = NULL_TREE;
963
964 expand_stmt (n);
965
966 return n != NULL_TREE;
967 }
968
969 /* Expand an unreachable statement list. This function skips all
970 statements preceding the first potentially reachable label and
971 then returns the label (or, in same cases, the statement after
972 one containing the label). This function returns NULL_TREE if
973 the end of the given statement list is unreachable, and a
974 non-NULL value, possibly error_mark_node, otherwise. */
975 static tree
expand_unreachable_stmt(tree t,int warn)976 expand_unreachable_stmt (tree t, int warn)
977 {
978 int saved;
979
980 while (t && t != error_mark_node)
981 {
982 if (warn)
983 switch (TREE_CODE (t))
984 {
985 case BREAK_STMT:
986 case CONTINUE_STMT:
987 case EXPR_STMT:
988 case GOTO_STMT:
989 case IF_STMT:
990 case RETURN_STMT:
991 if (!STMT_LINENO_FOR_FN_P (t))
992 input_line = STMT_LINENO (t);
993 warning("will never be executed");
994 warn = false;
995 break;
996
997 default:
998 break;
999 }
1000
1001 switch (TREE_CODE (t))
1002 {
1003 case GOTO_STMT:
1004 case CONTINUE_STMT:
1005 case BREAK_STMT:
1006 break;
1007
1008 case FILE_STMT:
1009 input_filename = FILE_STMT_FILENAME (t);
1010 break;
1011
1012 case RETURN_STMT:
1013 if (find_reachable_label (RETURN_STMT_EXPR (t)) != NULL_TREE)
1014 return t;
1015 break;
1016
1017 case EXPR_STMT:
1018 if (find_reachable_label (EXPR_STMT_EXPR (t)) != NULL_TREE)
1019 return t;
1020 break;
1021
1022 case IF_STMT:
1023 if (expand_unreachable_if_stmt (t))
1024 return TREE_CHAIN (t) ? TREE_CHAIN (t) : error_mark_node;
1025 break;
1026
1027 case WHILE_STMT:
1028 /* If the start of a while statement is unreachable, there is
1029 no need to rotate the loop, instead the WHILE_STMT can be
1030 expanded like a DO_STMT. */
1031 genrtl_do_stmt_1 (WHILE_COND (t), WHILE_BODY (t));
1032 return TREE_CHAIN (t) ? TREE_CHAIN (t) : error_mark_node;
1033
1034 case COMPOUND_STMT:
1035 {
1036 tree n;
1037 n = expand_unreachable_stmt (COMPOUND_BODY (t), warn);
1038 if (n != NULL_TREE)
1039 {
1040 expand_stmt (n);
1041 return TREE_CHAIN (t) ? TREE_CHAIN (t) : error_mark_node;
1042 }
1043 warn = false;
1044 break;
1045 }
1046
1047 case SCOPE_STMT:
1048 saved = stmts_are_full_exprs_p ();
1049 prep_stmt (t);
1050 genrtl_scope_stmt (t);
1051 current_stmt_tree ()->stmts_are_full_exprs_p = saved;
1052 break;
1053
1054 default:
1055 return t;
1056 }
1057 t = TREE_CHAIN (t);
1058 }
1059 return NULL_TREE;
1060 }
1061