1 /* GIMPLE lowering pass. Converts High GIMPLE into Low GIMPLE.
3 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
28 #include "tree-iterator.h"
29 #include "tree-inline.h"
30 #include "tree-flow.h"
33 #include "diagnostic-core.h"
34 #include "tree-pass.h"
36 /* The differences between High GIMPLE and Low GIMPLE are the
39 1- Lexical scopes are removed (i.e., GIMPLE_BIND disappears).
41 2- GIMPLE_TRY and GIMPLE_CATCH are converted to abnormal control
42 flow and exception regions are built as an on-the-side region
43 hierarchy (See tree-eh.c:lower_eh_constructs).
45 3- Multiple identical return statements are grouped into a single
46 return and gotos to the unique return site. */
48 /* Match a return statement with a label. During lowering, we identify
49 identical return statements and replace duplicates with a jump to
50 the corresponding label. */
51 struct return_statements_t
56 typedef struct return_statements_t return_statements_t
;
58 DEF_VEC_O(return_statements_t
);
59 DEF_VEC_ALLOC_O(return_statements_t
,heap
);
63 /* Block the current statement belongs to. */
66 /* A vector of label and return statements to be moved to the end
68 VEC(return_statements_t
,heap
) *return_statements
;
70 /* True if the current statement cannot fall through. */
73 /* True if the function calls __builtin_setjmp. */
74 bool calls_builtin_setjmp
;
77 static void lower_stmt (gimple_stmt_iterator
*, struct lower_data
*);
78 static void lower_gimple_bind (gimple_stmt_iterator
*, struct lower_data
*);
79 static void lower_try_catch (gimple_stmt_iterator
*, struct lower_data
*);
80 static void lower_gimple_return (gimple_stmt_iterator
*, struct lower_data
*);
81 static void lower_builtin_setjmp (gimple_stmt_iterator
*);
84 /* Lower the body of current_function_decl from High GIMPLE into Low
88 lower_function_body (void)
90 struct lower_data data
;
91 gimple_seq body
= gimple_body (current_function_decl
);
92 gimple_seq lowered_body
;
93 gimple_stmt_iterator i
;
98 /* The gimplifier should've left a body of exactly one statement,
99 namely a GIMPLE_BIND. */
100 gcc_assert (gimple_seq_first (body
) == gimple_seq_last (body
)
101 && gimple_code (gimple_seq_first_stmt (body
)) == GIMPLE_BIND
);
103 memset (&data
, 0, sizeof (data
));
104 data
.block
= DECL_INITIAL (current_function_decl
);
105 BLOCK_SUBBLOCKS (data
.block
) = NULL_TREE
;
106 BLOCK_CHAIN (data
.block
) = NULL_TREE
;
107 TREE_ASM_WRITTEN (data
.block
) = 1;
108 data
.return_statements
= VEC_alloc (return_statements_t
, heap
, 8);
110 bind
= gimple_seq_first_stmt (body
);
112 gimple_seq_add_stmt (&lowered_body
, bind
);
113 i
= gsi_start (lowered_body
);
114 lower_gimple_bind (&i
, &data
);
116 i
= gsi_last (lowered_body
);
118 /* If the function falls off the end, we need a null return statement.
119 If we've already got one in the return_statements vector, we don't
120 need to do anything special. Otherwise build one by hand. */
121 if (gimple_seq_may_fallthru (lowered_body
)
122 && (VEC_empty (return_statements_t
, data
.return_statements
)
123 || gimple_return_retval (VEC_last (return_statements_t
,
124 data
.return_statements
).stmt
) != NULL
))
126 x
= gimple_build_return (NULL
);
127 gimple_set_location (x
, cfun
->function_end_locus
);
128 gimple_set_block (x
, DECL_INITIAL (current_function_decl
));
129 gsi_insert_after (&i
, x
, GSI_CONTINUE_LINKING
);
132 /* If we lowered any return statements, emit the representative
133 at the end of the function. */
134 while (!VEC_empty (return_statements_t
, data
.return_statements
))
136 return_statements_t t
;
138 /* Unfortunately, we can't use VEC_pop because it returns void for
140 t
= VEC_last (return_statements_t
, data
.return_statements
);
141 VEC_truncate (return_statements_t
,
142 data
.return_statements
,
143 VEC_length (return_statements_t
,
144 data
.return_statements
) - 1);
146 x
= gimple_build_label (t
.label
);
147 gsi_insert_after (&i
, x
, GSI_CONTINUE_LINKING
);
148 gsi_insert_after (&i
, t
.stmt
, GSI_CONTINUE_LINKING
);
151 /* If the function calls __builtin_setjmp, we need to emit the computed
152 goto that will serve as the unique dispatcher for all the receivers. */
153 if (data
.calls_builtin_setjmp
)
155 tree disp_label
, disp_var
, arg
;
157 /* Build 'DISP_LABEL:' and insert. */
158 disp_label
= create_artificial_label (cfun
->function_end_locus
);
159 /* This mark will create forward edges from every call site. */
160 DECL_NONLOCAL (disp_label
) = 1;
161 cfun
->has_nonlocal_label
= 1;
162 x
= gimple_build_label (disp_label
);
163 gsi_insert_after (&i
, x
, GSI_CONTINUE_LINKING
);
165 /* Build 'DISP_VAR = __builtin_setjmp_dispatcher (DISP_LABEL);'
167 disp_var
= create_tmp_var (ptr_type_node
, "setjmpvar");
168 arg
= build_addr (disp_label
, current_function_decl
);
169 t
= builtin_decl_implicit (BUILT_IN_SETJMP_DISPATCHER
);
170 x
= gimple_build_call (t
, 1, arg
);
171 gimple_call_set_lhs (x
, disp_var
);
173 /* Build 'goto DISP_VAR;' and insert. */
174 gsi_insert_after (&i
, x
, GSI_CONTINUE_LINKING
);
175 x
= gimple_build_goto (disp_var
);
176 gsi_insert_after (&i
, x
, GSI_CONTINUE_LINKING
);
179 /* Once the old body has been lowered, replace it with the new
181 gimple_set_body (current_function_decl
, lowered_body
);
183 gcc_assert (data
.block
== DECL_INITIAL (current_function_decl
));
184 BLOCK_SUBBLOCKS (data
.block
)
185 = blocks_nreverse (BLOCK_SUBBLOCKS (data
.block
));
187 clear_block_marks (data
.block
);
188 VEC_free(return_statements_t
, heap
, data
.return_statements
);
192 struct gimple_opt_pass pass_lower_cf
=
198 lower_function_body
, /* execute */
201 0, /* static_pass_number */
203 PROP_gimple_any
, /* properties_required */
204 PROP_gimple_lcf
, /* properties_provided */
205 0, /* properties_destroyed */
206 0, /* todo_flags_start */
207 0 /* todo_flags_finish */
213 /* Verify if the type of the argument matches that of the function
214 declaration. If we cannot verify this or there is a mismatch,
218 gimple_check_call_args (gimple stmt
, tree fndecl
)
221 unsigned int i
, nargs
;
223 /* Calls to internal functions always match their signature. */
224 if (gimple_call_internal_p (stmt
))
227 nargs
= gimple_call_num_args (stmt
);
229 /* Get argument types for verification. */
231 parms
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
233 parms
= TYPE_ARG_TYPES (gimple_call_fntype (stmt
));
235 /* Verify if the type of the argument matches that of the function
236 declaration. If we cannot verify this or there is a mismatch,
238 if (fndecl
&& DECL_ARGUMENTS (fndecl
))
240 for (i
= 0, p
= DECL_ARGUMENTS (fndecl
);
242 i
++, p
= DECL_CHAIN (p
))
245 /* We cannot distinguish a varargs function from the case
246 of excess parameters, still deferring the inlining decision
247 to the callee is possible. */
250 arg
= gimple_call_arg (stmt
, i
);
251 if (p
== error_mark_node
252 || arg
== error_mark_node
253 || (!types_compatible_p (DECL_ARG_TYPE (p
), TREE_TYPE (arg
))
254 && !fold_convertible_p (DECL_ARG_TYPE (p
), arg
)))
260 for (i
= 0, p
= parms
; i
< nargs
; i
++, p
= TREE_CHAIN (p
))
263 /* If this is a varargs function defer inlining decision
267 arg
= gimple_call_arg (stmt
, i
);
268 if (TREE_VALUE (p
) == error_mark_node
269 || arg
== error_mark_node
270 || TREE_CODE (TREE_VALUE (p
)) == VOID_TYPE
271 || (!types_compatible_p (TREE_VALUE (p
), TREE_TYPE (arg
))
272 && !fold_convertible_p (TREE_VALUE (p
), arg
)))
284 /* Verify if the type of the argument and lhs of CALL_STMT matches
285 that of the function declaration CALLEE.
286 If we cannot verify this or there is a mismatch, return false. */
289 gimple_check_call_matching_types (gimple call_stmt
, tree callee
)
293 if ((DECL_RESULT (callee
)
294 && !DECL_BY_REFERENCE (DECL_RESULT (callee
))
295 && (lhs
= gimple_call_lhs (call_stmt
)) != NULL_TREE
296 && !useless_type_conversion_p (TREE_TYPE (DECL_RESULT (callee
)),
298 && !fold_convertible_p (TREE_TYPE (DECL_RESULT (callee
)), lhs
))
299 || !gimple_check_call_args (call_stmt
, callee
))
304 /* Lower sequence SEQ. Unlike gimplification the statements are not relowered
305 when they are changed -- if this has to be done, the lowering routine must
306 do it explicitly. DATA is passed through the recursion. */
309 lower_sequence (gimple_seq
*seq
, struct lower_data
*data
)
311 gimple_stmt_iterator gsi
;
313 for (gsi
= gsi_start (*seq
); !gsi_end_p (gsi
); )
314 lower_stmt (&gsi
, data
);
318 /* Lower the OpenMP directive statement pointed by GSI. DATA is
319 passed through the recursion. */
322 lower_omp_directive (gimple_stmt_iterator
*gsi
, struct lower_data
*data
)
326 stmt
= gsi_stmt (*gsi
);
328 lower_sequence (gimple_omp_body_ptr (stmt
), data
);
329 gsi_insert_seq_after (gsi
, gimple_omp_body (stmt
), GSI_CONTINUE_LINKING
);
330 gimple_omp_set_body (stmt
, NULL
);
335 /* Lower statement GSI. DATA is passed through the recursion. We try to
336 track the fallthruness of statements and get rid of unreachable return
337 statements in order to prevent the EH lowering pass from adding useless
338 edges that can cause bogus warnings to be issued later; this guess need
339 not be 100% accurate, simply be conservative and reset cannot_fallthru
340 to false if we don't know. */
343 lower_stmt (gimple_stmt_iterator
*gsi
, struct lower_data
*data
)
345 gimple stmt
= gsi_stmt (*gsi
);
347 gimple_set_block (stmt
, data
->block
);
349 switch (gimple_code (stmt
))
352 lower_gimple_bind (gsi
, data
);
353 /* Propagate fallthruness. */
359 data
->cannot_fallthru
= true;
364 if (data
->cannot_fallthru
)
366 gsi_remove (gsi
, false);
367 /* Propagate fallthruness. */
371 lower_gimple_return (gsi
, data
);
372 data
->cannot_fallthru
= true;
377 if (gimple_try_kind (stmt
) == GIMPLE_TRY_CATCH
)
378 lower_try_catch (gsi
, data
);
381 /* It must be a GIMPLE_TRY_FINALLY. */
382 bool cannot_fallthru
;
383 lower_sequence (gimple_try_eval_ptr (stmt
), data
);
384 cannot_fallthru
= data
->cannot_fallthru
;
386 /* The finally clause is always executed after the try clause,
387 so if it does not fall through, then the try-finally will not
388 fall through. Otherwise, if the try clause does not fall
389 through, then when the finally clause falls through it will
390 resume execution wherever the try clause was going. So the
391 whole try-finally will only fall through if both the try
392 clause and the finally clause fall through. */
393 data
->cannot_fallthru
= false;
394 lower_sequence (gimple_try_cleanup_ptr (stmt
), data
);
395 data
->cannot_fallthru
|= cannot_fallthru
;
401 lower_sequence (gimple_eh_else_n_body_ptr (stmt
), data
);
402 lower_sequence (gimple_eh_else_e_body_ptr (stmt
), data
);
410 case GIMPLE_EH_MUST_NOT_THROW
:
412 case GIMPLE_OMP_SECTIONS
:
413 case GIMPLE_OMP_SECTIONS_SWITCH
:
414 case GIMPLE_OMP_SECTION
:
415 case GIMPLE_OMP_SINGLE
:
416 case GIMPLE_OMP_MASTER
:
417 case GIMPLE_OMP_ORDERED
:
418 case GIMPLE_OMP_CRITICAL
:
419 case GIMPLE_OMP_RETURN
:
420 case GIMPLE_OMP_ATOMIC_LOAD
:
421 case GIMPLE_OMP_ATOMIC_STORE
:
422 case GIMPLE_OMP_CONTINUE
:
427 tree decl
= gimple_call_fndecl (stmt
);
430 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
431 && DECL_FUNCTION_CODE (decl
) == BUILT_IN_SETJMP
)
433 lower_builtin_setjmp (gsi
);
434 data
->cannot_fallthru
= false;
435 data
->calls_builtin_setjmp
= true;
439 if (decl
&& (flags_from_decl_or_type (decl
) & ECF_NORETURN
))
441 data
->cannot_fallthru
= true;
448 case GIMPLE_OMP_PARALLEL
:
449 case GIMPLE_OMP_TASK
:
450 data
->cannot_fallthru
= false;
451 lower_omp_directive (gsi
, data
);
452 data
->cannot_fallthru
= false;
455 case GIMPLE_TRANSACTION
:
456 lower_sequence (gimple_transaction_body_ptr (stmt
), data
);
463 data
->cannot_fallthru
= false;
467 /* Lower a bind_expr TSI. DATA is passed through the recursion. */
470 lower_gimple_bind (gimple_stmt_iterator
*gsi
, struct lower_data
*data
)
472 tree old_block
= data
->block
;
473 gimple stmt
= gsi_stmt (*gsi
);
474 tree new_block
= gimple_bind_block (stmt
);
478 if (new_block
== old_block
)
480 /* The outermost block of the original function may not be the
481 outermost statement chain of the gimplified function. So we
482 may see the outermost block just inside the function. */
483 gcc_assert (new_block
== DECL_INITIAL (current_function_decl
));
488 /* We do not expect to handle duplicate blocks. */
489 gcc_assert (!TREE_ASM_WRITTEN (new_block
));
490 TREE_ASM_WRITTEN (new_block
) = 1;
492 /* Block tree may get clobbered by inlining. Normally this would
493 be fixed in rest_of_decl_compilation using block notes, but
494 since we are not going to emit them, it is up to us. */
495 BLOCK_CHAIN (new_block
) = BLOCK_SUBBLOCKS (old_block
);
496 BLOCK_SUBBLOCKS (old_block
) = new_block
;
497 BLOCK_SUBBLOCKS (new_block
) = NULL_TREE
;
498 BLOCK_SUPERCONTEXT (new_block
) = old_block
;
500 data
->block
= new_block
;
504 record_vars (gimple_bind_vars (stmt
));
505 lower_sequence (gimple_bind_body_ptr (stmt
), data
);
509 gcc_assert (data
->block
== new_block
);
511 BLOCK_SUBBLOCKS (new_block
)
512 = blocks_nreverse (BLOCK_SUBBLOCKS (new_block
));
513 data
->block
= old_block
;
516 /* The GIMPLE_BIND no longer carries any useful information -- kill it. */
517 gsi_insert_seq_before (gsi
, gimple_bind_body (stmt
), GSI_SAME_STMT
);
518 gsi_remove (gsi
, false);
521 /* Same as above, but for a GIMPLE_TRY_CATCH. */
524 lower_try_catch (gimple_stmt_iterator
*gsi
, struct lower_data
*data
)
526 bool cannot_fallthru
;
527 gimple stmt
= gsi_stmt (*gsi
);
528 gimple_stmt_iterator i
;
530 /* We don't handle GIMPLE_TRY_FINALLY. */
531 gcc_assert (gimple_try_kind (stmt
) == GIMPLE_TRY_CATCH
);
533 lower_sequence (gimple_try_eval_ptr (stmt
), data
);
534 cannot_fallthru
= data
->cannot_fallthru
;
536 i
= gsi_start (*gimple_try_cleanup_ptr (stmt
));
537 switch (gimple_code (gsi_stmt (i
)))
540 /* We expect to see a sequence of GIMPLE_CATCH stmts, each with a
541 catch expression and a body. The whole try/catch may fall
542 through iff any of the catch bodies falls through. */
543 for (; !gsi_end_p (i
); gsi_next (&i
))
545 data
->cannot_fallthru
= false;
546 lower_sequence (gimple_catch_handler_ptr (gsi_stmt (i
)), data
);
547 if (!data
->cannot_fallthru
)
548 cannot_fallthru
= false;
552 case GIMPLE_EH_FILTER
:
553 /* The exception filter expression only matters if there is an
554 exception. If the exception does not match EH_FILTER_TYPES,
555 we will execute EH_FILTER_FAILURE, and we will fall through
556 if that falls through. If the exception does match
557 EH_FILTER_TYPES, the stack unwinder will continue up the
558 stack, so we will not fall through. We don't know whether we
559 will throw an exception which matches EH_FILTER_TYPES or not,
560 so we just ignore EH_FILTER_TYPES and assume that we might
561 throw an exception which doesn't match. */
562 data
->cannot_fallthru
= false;
563 lower_sequence (gimple_eh_filter_failure_ptr (gsi_stmt (i
)), data
);
564 if (!data
->cannot_fallthru
)
565 cannot_fallthru
= false;
569 /* This case represents statements to be executed when an
570 exception occurs. Those statements are implicitly followed
571 by a GIMPLE_RESX to resume execution after the exception. So
572 in this case the try/catch never falls through. */
573 data
->cannot_fallthru
= false;
574 lower_sequence (gimple_try_cleanup_ptr (stmt
), data
);
578 data
->cannot_fallthru
= cannot_fallthru
;
582 /* Try to determine whether a TRY_CATCH expression can fall through.
583 This is a subroutine of block_may_fallthru. */
586 try_catch_may_fallthru (const_tree stmt
)
588 tree_stmt_iterator i
;
590 /* If the TRY block can fall through, the whole TRY_CATCH can
592 if (block_may_fallthru (TREE_OPERAND (stmt
, 0)))
595 i
= tsi_start (TREE_OPERAND (stmt
, 1));
596 switch (TREE_CODE (tsi_stmt (i
)))
599 /* We expect to see a sequence of CATCH_EXPR trees, each with a
600 catch expression and a body. The whole TRY_CATCH may fall
601 through iff any of the catch bodies falls through. */
602 for (; !tsi_end_p (i
); tsi_next (&i
))
604 if (block_may_fallthru (CATCH_BODY (tsi_stmt (i
))))
610 /* The exception filter expression only matters if there is an
611 exception. If the exception does not match EH_FILTER_TYPES,
612 we will execute EH_FILTER_FAILURE, and we will fall through
613 if that falls through. If the exception does match
614 EH_FILTER_TYPES, the stack unwinder will continue up the
615 stack, so we will not fall through. We don't know whether we
616 will throw an exception which matches EH_FILTER_TYPES or not,
617 so we just ignore EH_FILTER_TYPES and assume that we might
618 throw an exception which doesn't match. */
619 return block_may_fallthru (EH_FILTER_FAILURE (tsi_stmt (i
)));
622 /* This case represents statements to be executed when an
623 exception occurs. Those statements are implicitly followed
624 by a RESX statement to resume execution after the exception.
625 So in this case the TRY_CATCH never falls through. */
631 /* Same as above, but for a GIMPLE_TRY_CATCH. */
634 gimple_try_catch_may_fallthru (gimple stmt
)
636 gimple_stmt_iterator i
;
638 /* We don't handle GIMPLE_TRY_FINALLY. */
639 gcc_assert (gimple_try_kind (stmt
) == GIMPLE_TRY_CATCH
);
641 /* If the TRY block can fall through, the whole TRY_CATCH can
643 if (gimple_seq_may_fallthru (gimple_try_eval (stmt
)))
646 i
= gsi_start (*gimple_try_cleanup_ptr (stmt
));
647 switch (gimple_code (gsi_stmt (i
)))
650 /* We expect to see a sequence of GIMPLE_CATCH stmts, each with a
651 catch expression and a body. The whole try/catch may fall
652 through iff any of the catch bodies falls through. */
653 for (; !gsi_end_p (i
); gsi_next (&i
))
655 if (gimple_seq_may_fallthru (gimple_catch_handler (gsi_stmt (i
))))
660 case GIMPLE_EH_FILTER
:
661 /* The exception filter expression only matters if there is an
662 exception. If the exception does not match EH_FILTER_TYPES,
663 we will execute EH_FILTER_FAILURE, and we will fall through
664 if that falls through. If the exception does match
665 EH_FILTER_TYPES, the stack unwinder will continue up the
666 stack, so we will not fall through. We don't know whether we
667 will throw an exception which matches EH_FILTER_TYPES or not,
668 so we just ignore EH_FILTER_TYPES and assume that we might
669 throw an exception which doesn't match. */
670 return gimple_seq_may_fallthru (gimple_eh_filter_failure (gsi_stmt (i
)));
673 /* This case represents statements to be executed when an
674 exception occurs. Those statements are implicitly followed
675 by a GIMPLE_RESX to resume execution after the exception. So
676 in this case the try/catch never falls through. */
682 /* Try to determine if we can fall out of the bottom of BLOCK. This guess
683 need not be 100% accurate; simply be conservative and return true if we
684 don't know. This is used only to avoid stupidly generating extra code.
685 If we're wrong, we'll just delete the extra code later. */
688 block_may_fallthru (const_tree block
)
690 /* This CONST_CAST is okay because expr_last returns its argument
691 unmodified and we assign it to a const_tree. */
692 const_tree stmt
= expr_last (CONST_CAST_TREE(block
));
694 switch (stmt
? TREE_CODE (stmt
) : ERROR_MARK
)
698 /* Easy cases. If the last statement of the block implies
699 control transfer, then we can't fall through. */
703 /* If SWITCH_LABELS is set, this is lowered, and represents a
704 branch to a selected label and hence can not fall through.
705 Otherwise SWITCH_BODY is set, and the switch can fall
707 return SWITCH_LABELS (stmt
) == NULL_TREE
;
710 if (block_may_fallthru (COND_EXPR_THEN (stmt
)))
712 return block_may_fallthru (COND_EXPR_ELSE (stmt
));
715 return block_may_fallthru (BIND_EXPR_BODY (stmt
));
718 return try_catch_may_fallthru (stmt
);
720 case TRY_FINALLY_EXPR
:
721 /* The finally clause is always executed after the try clause,
722 so if it does not fall through, then the try-finally will not
723 fall through. Otherwise, if the try clause does not fall
724 through, then when the finally clause falls through it will
725 resume execution wherever the try clause was going. So the
726 whole try-finally will only fall through if both the try
727 clause and the finally clause fall through. */
728 return (block_may_fallthru (TREE_OPERAND (stmt
, 0))
729 && block_may_fallthru (TREE_OPERAND (stmt
, 1)));
732 if (TREE_CODE (TREE_OPERAND (stmt
, 1)) == CALL_EXPR
)
733 stmt
= TREE_OPERAND (stmt
, 1);
739 /* Functions that do not return do not fall through. */
740 return (call_expr_flags (stmt
) & ECF_NORETURN
) == 0;
742 case CLEANUP_POINT_EXPR
:
743 return block_may_fallthru (TREE_OPERAND (stmt
, 0));
751 /* Try to determine if we can continue executing the statement
752 immediately following STMT. This guess need not be 100% accurate;
753 simply be conservative and return true if we don't know. This is
754 used only to avoid stupidly generating extra code. If we're wrong,
755 we'll just delete the extra code later. */
758 gimple_stmt_may_fallthru (gimple stmt
)
763 switch (gimple_code (stmt
))
768 /* Easy cases. If the last statement of the seq implies
769 control transfer, then we can't fall through. */
773 /* Switch has already been lowered and represents a branch
774 to a selected label and hence can't fall through. */
778 /* GIMPLE_COND's are already lowered into a two-way branch. They
779 can't fall through. */
783 return gimple_seq_may_fallthru (gimple_bind_body (stmt
));
786 if (gimple_try_kind (stmt
) == GIMPLE_TRY_CATCH
)
787 return gimple_try_catch_may_fallthru (stmt
);
789 /* It must be a GIMPLE_TRY_FINALLY. */
791 /* The finally clause is always executed after the try clause,
792 so if it does not fall through, then the try-finally will not
793 fall through. Otherwise, if the try clause does not fall
794 through, then when the finally clause falls through it will
795 resume execution wherever the try clause was going. So the
796 whole try-finally will only fall through if both the try
797 clause and the finally clause fall through. */
798 return (gimple_seq_may_fallthru (gimple_try_eval (stmt
))
799 && gimple_seq_may_fallthru (gimple_try_cleanup (stmt
)));
802 return (gimple_seq_may_fallthru (gimple_eh_else_n_body (stmt
))
803 || gimple_seq_may_fallthru (gimple_eh_else_e_body (stmt
)));
806 /* Functions that do not return do not fall through. */
807 return (gimple_call_flags (stmt
) & ECF_NORETURN
) == 0;
815 /* Same as gimple_stmt_may_fallthru, but for the gimple sequence SEQ. */
818 gimple_seq_may_fallthru (gimple_seq seq
)
820 return gimple_stmt_may_fallthru (gimple_seq_last_stmt (seq
));
824 /* Lower a GIMPLE_RETURN GSI. DATA is passed through the recursion. */
827 lower_gimple_return (gimple_stmt_iterator
*gsi
, struct lower_data
*data
)
829 gimple stmt
= gsi_stmt (*gsi
);
832 return_statements_t tmp_rs
;
834 /* Match this up with an existing return statement that's been created. */
835 for (i
= VEC_length (return_statements_t
, data
->return_statements
) - 1;
838 tmp_rs
= VEC_index (return_statements_t
, data
->return_statements
, i
);
840 if (gimple_return_retval (stmt
) == gimple_return_retval (tmp_rs
.stmt
))
842 /* Remove the line number from the representative return statement.
843 It now fills in for many such returns. Failure to remove this
844 will result in incorrect results for coverage analysis. */
845 gimple_set_location (tmp_rs
.stmt
, UNKNOWN_LOCATION
);
851 /* Not found. Create a new label and record the return statement. */
852 tmp_rs
.label
= create_artificial_label (cfun
->function_end_locus
);
854 VEC_safe_push (return_statements_t
, heap
, data
->return_statements
, tmp_rs
);
856 /* Generate a goto statement and remove the return statement. */
858 /* When not optimizing, make sure user returns are preserved. */
859 if (!optimize
&& gimple_has_location (stmt
))
860 DECL_ARTIFICIAL (tmp_rs
.label
) = 0;
861 t
= gimple_build_goto (tmp_rs
.label
);
862 gimple_set_location (t
, gimple_location (stmt
));
863 gimple_set_block (t
, gimple_block (stmt
));
864 gsi_insert_before (gsi
, t
, GSI_SAME_STMT
);
865 gsi_remove (gsi
, false);
868 /* Lower a __builtin_setjmp GSI.
870 __builtin_setjmp is passed a pointer to an array of five words (not
871 all will be used on all machines). It operates similarly to the C
872 library function of the same name, but is more efficient.
874 It is lowered into 3 other builtins, namely __builtin_setjmp_setup,
875 __builtin_setjmp_dispatcher and __builtin_setjmp_receiver, but with
876 __builtin_setjmp_dispatcher shared among all the instances; that's
877 why it is only emitted at the end by lower_function_body.
879 After full lowering, the body of the function should look like:
888 __builtin_setjmp_setup (&buf, &<D1847>);
892 __builtin_setjmp_receiver (&<D1847>);
895 if (D.1844 == 0) goto <D1848>; else goto <D1849>;
899 __builtin_setjmp_setup (&buf, &<D2847>);
903 __builtin_setjmp_receiver (&<D2847>);
906 if (D.2844 == 0) goto <D2848>; else goto <D2849>;
912 <D3853>: [non-local];
913 setjmpvar.0 = __builtin_setjmp_dispatcher (&<D3853>);
917 The dispatcher block will be both the unique destination of all the
918 abnormal call edges and the unique source of all the abnormal edges
919 to the receivers, thus keeping the complexity explosion localized. */
922 lower_builtin_setjmp (gimple_stmt_iterator
*gsi
)
924 gimple stmt
= gsi_stmt (*gsi
);
925 location_t loc
= gimple_location (stmt
);
926 tree cont_label
= create_artificial_label (loc
);
927 tree next_label
= create_artificial_label (loc
);
931 /* NEXT_LABEL is the label __builtin_longjmp will jump to. Its address is
932 passed to both __builtin_setjmp_setup and __builtin_setjmp_receiver. */
933 FORCED_LABEL (next_label
) = 1;
935 dest
= gimple_call_lhs (stmt
);
937 /* Build '__builtin_setjmp_setup (BUF, NEXT_LABEL)' and insert. */
938 arg
= build_addr (next_label
, current_function_decl
);
939 t
= builtin_decl_implicit (BUILT_IN_SETJMP_SETUP
);
940 g
= gimple_build_call (t
, 2, gimple_call_arg (stmt
, 0), arg
);
941 gimple_set_location (g
, loc
);
942 gimple_set_block (g
, gimple_block (stmt
));
943 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
945 /* Build 'DEST = 0' and insert. */
948 g
= gimple_build_assign (dest
, build_zero_cst (TREE_TYPE (dest
)));
949 gimple_set_location (g
, loc
);
950 gimple_set_block (g
, gimple_block (stmt
));
951 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
954 /* Build 'goto CONT_LABEL' and insert. */
955 g
= gimple_build_goto (cont_label
);
956 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
958 /* Build 'NEXT_LABEL:' and insert. */
959 g
= gimple_build_label (next_label
);
960 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
962 /* Build '__builtin_setjmp_receiver (NEXT_LABEL)' and insert. */
963 arg
= build_addr (next_label
, current_function_decl
);
964 t
= builtin_decl_implicit (BUILT_IN_SETJMP_RECEIVER
);
965 g
= gimple_build_call (t
, 1, arg
);
966 gimple_set_location (g
, loc
);
967 gimple_set_block (g
, gimple_block (stmt
));
968 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
970 /* Build 'DEST = 1' and insert. */
973 g
= gimple_build_assign (dest
, fold_convert_loc (loc
, TREE_TYPE (dest
),
975 gimple_set_location (g
, loc
);
976 gimple_set_block (g
, gimple_block (stmt
));
977 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
980 /* Build 'CONT_LABEL:' and insert. */
981 g
= gimple_build_label (cont_label
);
982 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
984 /* Remove the call to __builtin_setjmp. */
985 gsi_remove (gsi
, false);
989 /* Record the variables in VARS into function FN. */
992 record_vars_into (tree vars
, tree fn
)
994 bool change_cfun
= fn
!= current_function_decl
;
997 push_cfun (DECL_STRUCT_FUNCTION (fn
));
999 for (; vars
; vars
= DECL_CHAIN (vars
))
1003 /* BIND_EXPRs contains also function/type/constant declarations
1004 we don't need to care about. */
1005 if (TREE_CODE (var
) != VAR_DECL
)
1008 /* Nothing to do in this case. */
1009 if (DECL_EXTERNAL (var
))
1012 /* Record the variable. */
1013 add_local_decl (cfun
, var
);
1021 /* Record the variables in VARS into current_function_decl. */
1024 record_vars (tree vars
)
1026 record_vars_into (vars
, current_function_decl
);