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_gimple_return (gimple_stmt_iterator
*, struct lower_data
*);
80 static void lower_builtin_setjmp (gimple_stmt_iterator
*);
83 /* Lower the body of current_function_decl from High GIMPLE into Low
87 lower_function_body (void)
89 struct lower_data data
;
90 gimple_seq body
= gimple_body (current_function_decl
);
91 gimple_seq lowered_body
;
92 gimple_stmt_iterator i
;
97 /* The gimplifier should've left a body of exactly one statement,
98 namely a GIMPLE_BIND. */
99 gcc_assert (gimple_seq_first (body
) == gimple_seq_last (body
)
100 && gimple_code (gimple_seq_first_stmt (body
)) == GIMPLE_BIND
);
102 memset (&data
, 0, sizeof (data
));
103 data
.block
= DECL_INITIAL (current_function_decl
);
104 BLOCK_SUBBLOCKS (data
.block
) = NULL_TREE
;
105 BLOCK_CHAIN (data
.block
) = NULL_TREE
;
106 TREE_ASM_WRITTEN (data
.block
) = 1;
107 data
.return_statements
= VEC_alloc (return_statements_t
, heap
, 8);
109 bind
= gimple_seq_first_stmt (body
);
111 gimple_seq_add_stmt (&lowered_body
, bind
);
112 i
= gsi_start (lowered_body
);
113 lower_gimple_bind (&i
, &data
);
115 /* Once the old body has been lowered, replace it with the new
117 gimple_set_body (current_function_decl
, lowered_body
);
119 i
= gsi_last (lowered_body
);
121 /* If the function falls off the end, we need a null return statement.
122 If we've already got one in the return_statements vector, we don't
123 need to do anything special. Otherwise build one by hand. */
124 if (gimple_seq_may_fallthru (lowered_body
)
125 && (VEC_empty (return_statements_t
, data
.return_statements
)
126 || gimple_return_retval (VEC_last (return_statements_t
,
127 data
.return_statements
)->stmt
) != NULL
))
129 x
= gimple_build_return (NULL
);
130 gimple_set_location (x
, cfun
->function_end_locus
);
131 gimple_set_block (x
, DECL_INITIAL (current_function_decl
));
132 gsi_insert_after (&i
, x
, GSI_CONTINUE_LINKING
);
135 /* If we lowered any return statements, emit the representative
136 at the end of the function. */
137 while (!VEC_empty (return_statements_t
, data
.return_statements
))
139 return_statements_t t
;
141 /* Unfortunately, we can't use VEC_pop because it returns void for
143 t
= *VEC_last (return_statements_t
, data
.return_statements
);
144 VEC_truncate (return_statements_t
,
145 data
.return_statements
,
146 VEC_length (return_statements_t
,
147 data
.return_statements
) - 1);
149 x
= gimple_build_label (t
.label
);
150 gsi_insert_after (&i
, x
, GSI_CONTINUE_LINKING
);
151 gsi_insert_after (&i
, t
.stmt
, GSI_CONTINUE_LINKING
);
154 /* If the function calls __builtin_setjmp, we need to emit the computed
155 goto that will serve as the unique dispatcher for all the receivers. */
156 if (data
.calls_builtin_setjmp
)
158 tree disp_label
, disp_var
, arg
;
160 /* Build 'DISP_LABEL:' and insert. */
161 disp_label
= create_artificial_label (cfun
->function_end_locus
);
162 /* This mark will create forward edges from every call site. */
163 DECL_NONLOCAL (disp_label
) = 1;
164 cfun
->has_nonlocal_label
= 1;
165 x
= gimple_build_label (disp_label
);
166 gsi_insert_after (&i
, x
, GSI_CONTINUE_LINKING
);
168 /* Build 'DISP_VAR = __builtin_setjmp_dispatcher (DISP_LABEL);'
170 disp_var
= create_tmp_var (ptr_type_node
, "setjmpvar");
171 arg
= build_addr (disp_label
, current_function_decl
);
172 t
= implicit_built_in_decls
[BUILT_IN_SETJMP_DISPATCHER
];
173 x
= gimple_build_call (t
, 1, arg
);
174 gimple_call_set_lhs (x
, disp_var
);
176 /* Build 'goto DISP_VAR;' and insert. */
177 gsi_insert_after (&i
, x
, GSI_CONTINUE_LINKING
);
178 x
= gimple_build_goto (disp_var
);
179 gsi_insert_after (&i
, x
, GSI_CONTINUE_LINKING
);
182 gcc_assert (data
.block
== DECL_INITIAL (current_function_decl
));
183 BLOCK_SUBBLOCKS (data
.block
)
184 = blocks_nreverse (BLOCK_SUBBLOCKS (data
.block
));
186 clear_block_marks (data
.block
);
187 VEC_free(return_statements_t
, heap
, data
.return_statements
);
191 struct gimple_opt_pass pass_lower_cf
=
197 lower_function_body
, /* execute */
200 0, /* static_pass_number */
202 PROP_gimple_any
, /* properties_required */
203 PROP_gimple_lcf
, /* properties_provided */
204 0, /* properties_destroyed */
205 0, /* todo_flags_start */
206 TODO_dump_func
/* todo_flags_finish */
211 /* Verify if the type of the argument matches that of the function
212 declaration. If we cannot verify this or there is a mismatch,
216 gimple_check_call_args (gimple stmt
)
218 tree fndecl
, parms
, p
;
219 unsigned int i
, nargs
;
221 nargs
= gimple_call_num_args (stmt
);
223 /* Get argument types for verification. */
224 fndecl
= gimple_call_fndecl (stmt
);
227 parms
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
228 else if (POINTER_TYPE_P (TREE_TYPE (gimple_call_fn (stmt
))))
229 parms
= TYPE_ARG_TYPES (TREE_TYPE (TREE_TYPE (gimple_call_fn (stmt
))));
231 /* Verify if the type of the argument matches that of the function
232 declaration. If we cannot verify this or there is a mismatch,
234 if (fndecl
&& DECL_ARGUMENTS (fndecl
))
236 for (i
= 0, p
= DECL_ARGUMENTS (fndecl
);
238 i
++, p
= DECL_CHAIN (p
))
240 /* We cannot distinguish a varargs function from the case
241 of excess parameters, still deferring the inlining decision
242 to the callee is possible. */
245 if (p
== error_mark_node
246 || gimple_call_arg (stmt
, i
) == error_mark_node
247 || !fold_convertible_p (DECL_ARG_TYPE (p
),
248 gimple_call_arg (stmt
, i
)))
254 for (i
= 0, p
= parms
; i
< nargs
; i
++, p
= TREE_CHAIN (p
))
256 /* If this is a varargs function defer inlining decision
260 if (TREE_VALUE (p
) == error_mark_node
261 || gimple_call_arg (stmt
, i
) == error_mark_node
262 || TREE_CODE (TREE_VALUE (p
)) == VOID_TYPE
263 || !fold_convertible_p (TREE_VALUE (p
),
264 gimple_call_arg (stmt
, i
)))
277 /* Lower sequence SEQ. Unlike gimplification the statements are not relowered
278 when they are changed -- if this has to be done, the lowering routine must
279 do it explicitly. DATA is passed through the recursion. */
282 lower_sequence (gimple_seq seq
, struct lower_data
*data
)
284 gimple_stmt_iterator gsi
;
286 for (gsi
= gsi_start (seq
); !gsi_end_p (gsi
); )
287 lower_stmt (&gsi
, data
);
291 /* Lower the OpenMP directive statement pointed by GSI. DATA is
292 passed through the recursion. */
295 lower_omp_directive (gimple_stmt_iterator
*gsi
, struct lower_data
*data
)
299 stmt
= gsi_stmt (*gsi
);
301 lower_sequence (gimple_omp_body (stmt
), data
);
302 gsi_insert_before (gsi
, stmt
, GSI_SAME_STMT
);
303 gsi_insert_seq_before (gsi
, gimple_omp_body (stmt
), GSI_SAME_STMT
);
304 gimple_omp_set_body (stmt
, NULL
);
305 gsi_remove (gsi
, false);
309 /* Lower statement GSI. DATA is passed through the recursion. We try to
310 track the fallthruness of statements and get rid of unreachable return
311 statements in order to prevent the EH lowering pass from adding useless
312 edges that can cause bogus warnings to be issued later; this guess need
313 not be 100% accurate, simply be conservative and reset cannot_fallthru
314 to false if we don't know. */
317 lower_stmt (gimple_stmt_iterator
*gsi
, struct lower_data
*data
)
319 gimple stmt
= gsi_stmt (*gsi
);
321 gimple_set_block (stmt
, data
->block
);
323 switch (gimple_code (stmt
))
326 lower_gimple_bind (gsi
, data
);
327 /* Propagate fallthruness. */
333 data
->cannot_fallthru
= true;
338 if (data
->cannot_fallthru
)
340 gsi_remove (gsi
, false);
341 /* Propagate fallthruness. */
345 lower_gimple_return (gsi
, data
);
346 data
->cannot_fallthru
= true;
352 bool try_cannot_fallthru
;
353 lower_sequence (gimple_try_eval (stmt
), data
);
354 try_cannot_fallthru
= data
->cannot_fallthru
;
355 data
->cannot_fallthru
= false;
356 lower_sequence (gimple_try_cleanup (stmt
), data
);
357 /* See gimple_stmt_may_fallthru for the rationale. */
358 if (gimple_try_kind (stmt
) == GIMPLE_TRY_FINALLY
)
360 data
->cannot_fallthru
|= try_cannot_fallthru
;
368 data
->cannot_fallthru
= false;
369 lower_sequence (gimple_catch_handler (stmt
), data
);
372 case GIMPLE_EH_FILTER
:
373 data
->cannot_fallthru
= false;
374 lower_sequence (gimple_eh_filter_failure (stmt
), data
);
382 case GIMPLE_EH_MUST_NOT_THROW
:
384 case GIMPLE_OMP_SECTIONS
:
385 case GIMPLE_OMP_SECTIONS_SWITCH
:
386 case GIMPLE_OMP_SECTION
:
387 case GIMPLE_OMP_SINGLE
:
388 case GIMPLE_OMP_MASTER
:
389 case GIMPLE_OMP_ORDERED
:
390 case GIMPLE_OMP_CRITICAL
:
391 case GIMPLE_OMP_RETURN
:
392 case GIMPLE_OMP_ATOMIC_LOAD
:
393 case GIMPLE_OMP_ATOMIC_STORE
:
394 case GIMPLE_OMP_CONTINUE
:
399 tree decl
= gimple_call_fndecl (stmt
);
402 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
403 && DECL_FUNCTION_CODE (decl
) == BUILT_IN_SETJMP
)
405 lower_builtin_setjmp (gsi
);
406 data
->cannot_fallthru
= false;
407 data
->calls_builtin_setjmp
= true;
411 if (decl
&& (flags_from_decl_or_type (decl
) & ECF_NORETURN
))
413 data
->cannot_fallthru
= true;
420 case GIMPLE_OMP_PARALLEL
:
421 case GIMPLE_OMP_TASK
:
422 data
->cannot_fallthru
= false;
423 lower_omp_directive (gsi
, data
);
424 data
->cannot_fallthru
= false;
431 data
->cannot_fallthru
= false;
435 /* Lower a bind_expr TSI. DATA is passed through the recursion. */
438 lower_gimple_bind (gimple_stmt_iterator
*gsi
, struct lower_data
*data
)
440 tree old_block
= data
->block
;
441 gimple stmt
= gsi_stmt (*gsi
);
442 tree new_block
= gimple_bind_block (stmt
);
446 if (new_block
== old_block
)
448 /* The outermost block of the original function may not be the
449 outermost statement chain of the gimplified function. So we
450 may see the outermost block just inside the function. */
451 gcc_assert (new_block
== DECL_INITIAL (current_function_decl
));
456 /* We do not expect to handle duplicate blocks. */
457 gcc_assert (!TREE_ASM_WRITTEN (new_block
));
458 TREE_ASM_WRITTEN (new_block
) = 1;
460 /* Block tree may get clobbered by inlining. Normally this would
461 be fixed in rest_of_decl_compilation using block notes, but
462 since we are not going to emit them, it is up to us. */
463 BLOCK_CHAIN (new_block
) = BLOCK_SUBBLOCKS (old_block
);
464 BLOCK_SUBBLOCKS (old_block
) = new_block
;
465 BLOCK_SUBBLOCKS (new_block
) = NULL_TREE
;
466 BLOCK_SUPERCONTEXT (new_block
) = old_block
;
468 data
->block
= new_block
;
472 record_vars (gimple_bind_vars (stmt
));
473 lower_sequence (gimple_bind_body (stmt
), data
);
477 gcc_assert (data
->block
== new_block
);
479 BLOCK_SUBBLOCKS (new_block
)
480 = blocks_nreverse (BLOCK_SUBBLOCKS (new_block
));
481 data
->block
= old_block
;
484 /* The GIMPLE_BIND no longer carries any useful information -- kill it. */
485 gsi_insert_seq_before (gsi
, gimple_bind_body (stmt
), GSI_SAME_STMT
);
486 gsi_remove (gsi
, false);
489 /* Try to determine whether a TRY_CATCH expression can fall through.
490 This is a subroutine of block_may_fallthru. */
493 try_catch_may_fallthru (const_tree stmt
)
495 tree_stmt_iterator i
;
497 /* If the TRY block can fall through, the whole TRY_CATCH can
499 if (block_may_fallthru (TREE_OPERAND (stmt
, 0)))
502 i
= tsi_start (TREE_OPERAND (stmt
, 1));
503 switch (TREE_CODE (tsi_stmt (i
)))
506 /* We expect to see a sequence of CATCH_EXPR trees, each with a
507 catch expression and a body. The whole TRY_CATCH may fall
508 through iff any of the catch bodies falls through. */
509 for (; !tsi_end_p (i
); tsi_next (&i
))
511 if (block_may_fallthru (CATCH_BODY (tsi_stmt (i
))))
517 /* The exception filter expression only matters if there is an
518 exception. If the exception does not match EH_FILTER_TYPES,
519 we will execute EH_FILTER_FAILURE, and we will fall through
520 if that falls through. If the exception does match
521 EH_FILTER_TYPES, the stack unwinder will continue up the
522 stack, so we will not fall through. We don't know whether we
523 will throw an exception which matches EH_FILTER_TYPES or not,
524 so we just ignore EH_FILTER_TYPES and assume that we might
525 throw an exception which doesn't match. */
526 return block_may_fallthru (EH_FILTER_FAILURE (tsi_stmt (i
)));
529 /* This case represents statements to be executed when an
530 exception occurs. Those statements are implicitly followed
531 by a RESX statement to resume execution after the exception.
532 So in this case the TRY_CATCH never falls through. */
538 /* Same as above, but for a GIMPLE_TRY_CATCH. */
541 gimple_try_catch_may_fallthru (gimple stmt
)
543 gimple_stmt_iterator i
;
545 /* We don't handle GIMPLE_TRY_FINALLY. */
546 gcc_assert (gimple_try_kind (stmt
) == GIMPLE_TRY_CATCH
);
548 /* If the TRY block can fall through, the whole TRY_CATCH can
550 if (gimple_seq_may_fallthru (gimple_try_eval (stmt
)))
553 i
= gsi_start (gimple_try_cleanup (stmt
));
554 switch (gimple_code (gsi_stmt (i
)))
557 /* We expect to see a sequence of GIMPLE_CATCH stmts, each with a
558 catch expression and a body. The whole try/catch may fall
559 through iff any of the catch bodies falls through. */
560 for (; !gsi_end_p (i
); gsi_next (&i
))
562 if (gimple_seq_may_fallthru (gimple_catch_handler (gsi_stmt (i
))))
567 case GIMPLE_EH_FILTER
:
568 /* The exception filter expression only matters if there is an
569 exception. If the exception does not match EH_FILTER_TYPES,
570 we will execute EH_FILTER_FAILURE, and we will fall through
571 if that falls through. If the exception does match
572 EH_FILTER_TYPES, the stack unwinder will continue up the
573 stack, so we will not fall through. We don't know whether we
574 will throw an exception which matches EH_FILTER_TYPES or not,
575 so we just ignore EH_FILTER_TYPES and assume that we might
576 throw an exception which doesn't match. */
577 return gimple_seq_may_fallthru (gimple_eh_filter_failure (gsi_stmt (i
)));
580 /* This case represents statements to be executed when an
581 exception occurs. Those statements are implicitly followed
582 by a GIMPLE_RESX to resume execution after the exception. So
583 in this case the try/catch never falls through. */
589 /* Try to determine if we can fall out of the bottom of BLOCK. This guess
590 need not be 100% accurate; simply be conservative and return true if we
591 don't know. This is used only to avoid stupidly generating extra code.
592 If we're wrong, we'll just delete the extra code later. */
595 block_may_fallthru (const_tree block
)
597 /* This CONST_CAST is okay because expr_last returns its argument
598 unmodified and we assign it to a const_tree. */
599 const_tree stmt
= expr_last (CONST_CAST_TREE(block
));
601 switch (stmt
? TREE_CODE (stmt
) : ERROR_MARK
)
605 /* Easy cases. If the last statement of the block implies
606 control transfer, then we can't fall through. */
610 /* If SWITCH_LABELS is set, this is lowered, and represents a
611 branch to a selected label and hence can not fall through.
612 Otherwise SWITCH_BODY is set, and the switch can fall
614 return SWITCH_LABELS (stmt
) == NULL_TREE
;
617 if (block_may_fallthru (COND_EXPR_THEN (stmt
)))
619 return block_may_fallthru (COND_EXPR_ELSE (stmt
));
622 return block_may_fallthru (BIND_EXPR_BODY (stmt
));
625 return try_catch_may_fallthru (stmt
);
627 case TRY_FINALLY_EXPR
:
628 /* The finally clause is always executed after the try clause,
629 so if it does not fall through, then the try-finally will not
630 fall through. Otherwise, if the try clause does not fall
631 through, then when the finally clause falls through it will
632 resume execution wherever the try clause was going. So the
633 whole try-finally will only fall through if both the try
634 clause and the finally clause fall through. */
635 return (block_may_fallthru (TREE_OPERAND (stmt
, 0))
636 && block_may_fallthru (TREE_OPERAND (stmt
, 1)));
639 if (TREE_CODE (TREE_OPERAND (stmt
, 1)) == CALL_EXPR
)
640 stmt
= TREE_OPERAND (stmt
, 1);
646 /* Functions that do not return do not fall through. */
647 return (call_expr_flags (stmt
) & ECF_NORETURN
) == 0;
649 case CLEANUP_POINT_EXPR
:
650 return block_may_fallthru (TREE_OPERAND (stmt
, 0));
658 /* Try to determine if we can continue executing the statement
659 immediately following STMT. This guess need not be 100% accurate;
660 simply be conservative and return true if we don't know. This is
661 used only to avoid stupidly generating extra code. If we're wrong,
662 we'll just delete the extra code later. */
665 gimple_stmt_may_fallthru (gimple stmt
)
670 switch (gimple_code (stmt
))
675 /* Easy cases. If the last statement of the seq implies
676 control transfer, then we can't fall through. */
680 /* Switch has already been lowered and represents a branch
681 to a selected label and hence can't fall through. */
685 /* GIMPLE_COND's are already lowered into a two-way branch. They
686 can't fall through. */
690 return gimple_seq_may_fallthru (gimple_bind_body (stmt
));
693 if (gimple_try_kind (stmt
) == GIMPLE_TRY_CATCH
)
694 return gimple_try_catch_may_fallthru (stmt
);
696 /* It must be a GIMPLE_TRY_FINALLY. */
698 /* The finally clause is always executed after the try clause,
699 so if it does not fall through, then the try-finally will not
700 fall through. Otherwise, if the try clause does not fall
701 through, then when the finally clause falls through it will
702 resume execution wherever the try clause was going. So the
703 whole try-finally will only fall through if both the try
704 clause and the finally clause fall through. */
705 return (gimple_seq_may_fallthru (gimple_try_eval (stmt
))
706 && gimple_seq_may_fallthru (gimple_try_cleanup (stmt
)));
709 /* Functions that do not return do not fall through. */
710 return (gimple_call_flags (stmt
) & ECF_NORETURN
) == 0;
718 /* Same as gimple_stmt_may_fallthru, but for the gimple sequence SEQ. */
721 gimple_seq_may_fallthru (gimple_seq seq
)
723 return gimple_stmt_may_fallthru (gimple_seq_last_stmt (seq
));
727 /* Lower a GIMPLE_RETURN GSI. DATA is passed through the recursion. */
730 lower_gimple_return (gimple_stmt_iterator
*gsi
, struct lower_data
*data
)
732 gimple stmt
= gsi_stmt (*gsi
);
735 return_statements_t tmp_rs
;
737 /* Match this up with an existing return statement that's been created. */
738 for (i
= VEC_length (return_statements_t
, data
->return_statements
) - 1;
741 tmp_rs
= *VEC_index (return_statements_t
, data
->return_statements
, i
);
743 if (gimple_return_retval (stmt
) == gimple_return_retval (tmp_rs
.stmt
))
745 /* Remove the line number from the representative return statement.
746 It now fills in for many such returns. Failure to remove this
747 will result in incorrect results for coverage analysis. */
748 gimple_set_location (tmp_rs
.stmt
, UNKNOWN_LOCATION
);
754 /* Not found. Create a new label and record the return statement. */
755 tmp_rs
.label
= create_artificial_label (cfun
->function_end_locus
);
757 VEC_safe_push (return_statements_t
, heap
, data
->return_statements
, &tmp_rs
);
759 /* Generate a goto statement and remove the return statement. */
761 t
= gimple_build_goto (tmp_rs
.label
);
762 gimple_set_location (t
, gimple_location (stmt
));
763 gimple_set_block (t
, gimple_block (stmt
));
764 gsi_insert_before (gsi
, t
, GSI_SAME_STMT
);
765 gsi_remove (gsi
, false);
768 /* Lower a __builtin_setjmp GSI.
770 __builtin_setjmp is passed a pointer to an array of five words (not
771 all will be used on all machines). It operates similarly to the C
772 library function of the same name, but is more efficient.
774 It is lowered into 3 other builtins, namely __builtin_setjmp_setup,
775 __builtin_setjmp_dispatcher and __builtin_setjmp_receiver, but with
776 __builtin_setjmp_dispatcher shared among all the instances; that's
777 why it is only emitted at the end by lower_function_body.
779 After full lowering, the body of the function should look like:
788 __builtin_setjmp_setup (&buf, &<D1847>);
792 __builtin_setjmp_receiver (&<D1847>);
795 if (D.1844 == 0) goto <D1848>; else goto <D1849>;
799 __builtin_setjmp_setup (&buf, &<D2847>);
803 __builtin_setjmp_receiver (&<D2847>);
806 if (D.2844 == 0) goto <D2848>; else goto <D2849>;
812 <D3853>: [non-local];
813 setjmpvar.0 = __builtin_setjmp_dispatcher (&<D3853>);
817 The dispatcher block will be both the unique destination of all the
818 abnormal call edges and the unique source of all the abnormal edges
819 to the receivers, thus keeping the complexity explosion localized. */
822 lower_builtin_setjmp (gimple_stmt_iterator
*gsi
)
824 gimple stmt
= gsi_stmt (*gsi
);
825 location_t loc
= gimple_location (stmt
);
826 tree cont_label
= create_artificial_label (loc
);
827 tree next_label
= create_artificial_label (loc
);
831 /* NEXT_LABEL is the label __builtin_longjmp will jump to. Its address is
832 passed to both __builtin_setjmp_setup and __builtin_setjmp_receiver. */
833 FORCED_LABEL (next_label
) = 1;
835 dest
= gimple_call_lhs (stmt
);
837 /* Build '__builtin_setjmp_setup (BUF, NEXT_LABEL)' and insert. */
838 arg
= build_addr (next_label
, current_function_decl
);
839 t
= implicit_built_in_decls
[BUILT_IN_SETJMP_SETUP
];
840 g
= gimple_build_call (t
, 2, gimple_call_arg (stmt
, 0), arg
);
841 gimple_set_location (g
, loc
);
842 gimple_set_block (g
, gimple_block (stmt
));
843 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
845 /* Build 'DEST = 0' and insert. */
848 g
= gimple_build_assign (dest
, build_zero_cst (TREE_TYPE (dest
)));
849 gimple_set_location (g
, loc
);
850 gimple_set_block (g
, gimple_block (stmt
));
851 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
854 /* Build 'goto CONT_LABEL' and insert. */
855 g
= gimple_build_goto (cont_label
);
856 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
858 /* Build 'NEXT_LABEL:' and insert. */
859 g
= gimple_build_label (next_label
);
860 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
862 /* Build '__builtin_setjmp_receiver (NEXT_LABEL)' and insert. */
863 arg
= build_addr (next_label
, current_function_decl
);
864 t
= implicit_built_in_decls
[BUILT_IN_SETJMP_RECEIVER
];
865 g
= gimple_build_call (t
, 1, arg
);
866 gimple_set_location (g
, loc
);
867 gimple_set_block (g
, gimple_block (stmt
));
868 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
870 /* Build 'DEST = 1' and insert. */
873 g
= gimple_build_assign (dest
, fold_convert_loc (loc
, TREE_TYPE (dest
),
875 gimple_set_location (g
, loc
);
876 gimple_set_block (g
, gimple_block (stmt
));
877 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
880 /* Build 'CONT_LABEL:' and insert. */
881 g
= gimple_build_label (cont_label
);
882 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
884 /* Remove the call to __builtin_setjmp. */
885 gsi_remove (gsi
, false);
889 /* Record the variables in VARS into function FN. */
892 record_vars_into (tree vars
, tree fn
)
894 if (fn
!= current_function_decl
)
895 push_cfun (DECL_STRUCT_FUNCTION (fn
));
897 for (; vars
; vars
= DECL_CHAIN (vars
))
901 /* BIND_EXPRs contains also function/type/constant declarations
902 we don't need to care about. */
903 if (TREE_CODE (var
) != VAR_DECL
)
906 /* Nothing to do in this case. */
907 if (DECL_EXTERNAL (var
))
910 /* Record the variable. */
911 add_local_decl (cfun
, var
);
912 if (gimple_referenced_vars (cfun
))
913 add_referenced_var (var
);
916 if (fn
!= current_function_decl
)
921 /* Record the variables in VARS into current_function_decl. */
924 record_vars (tree vars
)
926 record_vars_into (vars
, current_function_decl
);