1 /* GIMPLE lowering pass. Converts High GIMPLE into Low GIMPLE.
3 Copyright (C) 2003-2013 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
27 #include "tree-iterator.h"
28 #include "tree-inline.h"
31 #include "diagnostic-core.h"
32 #include "tree-pass.h"
33 #include "langhooks.h"
34 #include "gimple-low.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
;
61 /* Block the current statement belongs to. */
64 /* A vector of label and return statements to be moved to the end
66 vec
<return_statements_t
> return_statements
;
68 /* True if the current statement cannot fall through. */
71 /* True if the function calls __builtin_setjmp. */
72 bool calls_builtin_setjmp
;
75 static void lower_stmt (gimple_stmt_iterator
*, struct lower_data
*);
76 static void lower_gimple_bind (gimple_stmt_iterator
*, struct lower_data
*);
77 static void lower_try_catch (gimple_stmt_iterator
*, struct lower_data
*);
78 static void lower_gimple_return (gimple_stmt_iterator
*, struct lower_data
*);
79 static void lower_builtin_setjmp (gimple_stmt_iterator
*);
82 /* Lower the body of current_function_decl from High GIMPLE into Low
86 lower_function_body (void)
88 struct lower_data data
;
89 gimple_seq body
= gimple_body (current_function_decl
);
90 gimple_seq lowered_body
;
91 gimple_stmt_iterator i
;
96 /* The gimplifier should've left a body of exactly one statement,
97 namely a GIMPLE_BIND. */
98 gcc_assert (gimple_seq_first (body
) == gimple_seq_last (body
)
99 && gimple_code (gimple_seq_first_stmt (body
)) == GIMPLE_BIND
);
101 memset (&data
, 0, sizeof (data
));
102 data
.block
= DECL_INITIAL (current_function_decl
);
103 BLOCK_SUBBLOCKS (data
.block
) = NULL_TREE
;
104 BLOCK_CHAIN (data
.block
) = NULL_TREE
;
105 TREE_ASM_WRITTEN (data
.block
) = 1;
106 data
.return_statements
.create (8);
108 bind
= gimple_seq_first_stmt (body
);
110 gimple_seq_add_stmt (&lowered_body
, bind
);
111 i
= gsi_start (lowered_body
);
112 lower_gimple_bind (&i
, &data
);
114 i
= gsi_last (lowered_body
);
116 /* If the function falls off the end, we need a null return statement.
117 If we've already got one in the return_statements vector, we don't
118 need to do anything special. Otherwise build one by hand. */
119 if (gimple_seq_may_fallthru (lowered_body
)
120 && (data
.return_statements
.is_empty ()
121 || (gimple_return_retval (data
.return_statements
.last().stmt
)
124 x
= gimple_build_return (NULL
);
125 gimple_set_location (x
, cfun
->function_end_locus
);
126 gimple_set_block (x
, DECL_INITIAL (current_function_decl
));
127 gsi_insert_after (&i
, x
, GSI_CONTINUE_LINKING
);
130 /* If we lowered any return statements, emit the representative
131 at the end of the function. */
132 while (!data
.return_statements
.is_empty ())
134 return_statements_t t
= data
.return_statements
.pop ();
135 x
= gimple_build_label (t
.label
);
136 gsi_insert_after (&i
, x
, GSI_CONTINUE_LINKING
);
137 gsi_insert_after (&i
, t
.stmt
, GSI_CONTINUE_LINKING
);
140 /* If the function calls __builtin_setjmp, we need to emit the computed
141 goto that will serve as the unique dispatcher for all the receivers. */
142 if (data
.calls_builtin_setjmp
)
144 tree disp_label
, disp_var
, arg
;
146 /* Build 'DISP_LABEL:' and insert. */
147 disp_label
= create_artificial_label (cfun
->function_end_locus
);
148 /* This mark will create forward edges from every call site. */
149 DECL_NONLOCAL (disp_label
) = 1;
150 cfun
->has_nonlocal_label
= 1;
151 x
= gimple_build_label (disp_label
);
152 gsi_insert_after (&i
, x
, GSI_CONTINUE_LINKING
);
154 /* Build 'DISP_VAR = __builtin_setjmp_dispatcher (DISP_LABEL);'
156 disp_var
= create_tmp_var (ptr_type_node
, "setjmpvar");
157 arg
= build_addr (disp_label
, current_function_decl
);
158 t
= builtin_decl_implicit (BUILT_IN_SETJMP_DISPATCHER
);
159 x
= gimple_build_call (t
, 1, arg
);
160 gimple_call_set_lhs (x
, disp_var
);
162 /* Build 'goto DISP_VAR;' and insert. */
163 gsi_insert_after (&i
, x
, GSI_CONTINUE_LINKING
);
164 x
= gimple_build_goto (disp_var
);
165 gsi_insert_after (&i
, x
, GSI_CONTINUE_LINKING
);
168 /* Once the old body has been lowered, replace it with the new
170 gimple_set_body (current_function_decl
, lowered_body
);
172 gcc_assert (data
.block
== DECL_INITIAL (current_function_decl
));
173 BLOCK_SUBBLOCKS (data
.block
)
174 = blocks_nreverse (BLOCK_SUBBLOCKS (data
.block
));
176 clear_block_marks (data
.block
);
177 data
.return_statements
.release ();
183 const pass_data pass_data_lower_cf
=
185 GIMPLE_PASS
, /* type */
187 OPTGROUP_NONE
, /* optinfo_flags */
188 false, /* has_gate */
189 true, /* has_execute */
191 PROP_gimple_any
, /* properties_required */
192 PROP_gimple_lcf
, /* properties_provided */
193 0, /* properties_destroyed */
194 0, /* todo_flags_start */
195 0, /* todo_flags_finish */
198 class pass_lower_cf
: public gimple_opt_pass
201 pass_lower_cf (gcc::context
*ctxt
)
202 : gimple_opt_pass (pass_data_lower_cf
, ctxt
)
205 /* opt_pass methods: */
206 unsigned int execute () { return lower_function_body (); }
208 }; // class pass_lower_cf
213 make_pass_lower_cf (gcc::context
*ctxt
)
215 return new pass_lower_cf (ctxt
);
218 /* Lower sequence SEQ. Unlike gimplification the statements are not relowered
219 when they are changed -- if this has to be done, the lowering routine must
220 do it explicitly. DATA is passed through the recursion. */
223 lower_sequence (gimple_seq
*seq
, struct lower_data
*data
)
225 gimple_stmt_iterator gsi
;
227 for (gsi
= gsi_start (*seq
); !gsi_end_p (gsi
); )
228 lower_stmt (&gsi
, data
);
232 /* Lower the OpenMP directive statement pointed by GSI. DATA is
233 passed through the recursion. */
236 lower_omp_directive (gimple_stmt_iterator
*gsi
, struct lower_data
*data
)
240 stmt
= gsi_stmt (*gsi
);
242 lower_sequence (gimple_omp_body_ptr (stmt
), data
);
243 gsi_insert_seq_after (gsi
, gimple_omp_body (stmt
), GSI_CONTINUE_LINKING
);
244 gimple_omp_set_body (stmt
, NULL
);
249 /* Lower statement GSI. DATA is passed through the recursion. We try to
250 track the fallthruness of statements and get rid of unreachable return
251 statements in order to prevent the EH lowering pass from adding useless
252 edges that can cause bogus warnings to be issued later; this guess need
253 not be 100% accurate, simply be conservative and reset cannot_fallthru
254 to false if we don't know. */
257 lower_stmt (gimple_stmt_iterator
*gsi
, struct lower_data
*data
)
259 gimple stmt
= gsi_stmt (*gsi
);
261 gimple_set_block (stmt
, data
->block
);
263 switch (gimple_code (stmt
))
266 lower_gimple_bind (gsi
, data
);
267 /* Propagate fallthruness. */
273 data
->cannot_fallthru
= true;
278 if (data
->cannot_fallthru
)
280 gsi_remove (gsi
, false);
281 /* Propagate fallthruness. */
285 lower_gimple_return (gsi
, data
);
286 data
->cannot_fallthru
= true;
291 if (gimple_try_kind (stmt
) == GIMPLE_TRY_CATCH
)
292 lower_try_catch (gsi
, data
);
295 /* It must be a GIMPLE_TRY_FINALLY. */
296 bool cannot_fallthru
;
297 lower_sequence (gimple_try_eval_ptr (stmt
), data
);
298 cannot_fallthru
= data
->cannot_fallthru
;
300 /* The finally clause is always executed after the try clause,
301 so if it does not fall through, then the try-finally will not
302 fall through. Otherwise, if the try clause does not fall
303 through, then when the finally clause falls through it will
304 resume execution wherever the try clause was going. So the
305 whole try-finally will only fall through if both the try
306 clause and the finally clause fall through. */
307 data
->cannot_fallthru
= false;
308 lower_sequence (gimple_try_cleanup_ptr (stmt
), data
);
309 data
->cannot_fallthru
|= cannot_fallthru
;
315 lower_sequence (gimple_eh_else_n_body_ptr (stmt
), data
);
316 lower_sequence (gimple_eh_else_e_body_ptr (stmt
), data
);
324 case GIMPLE_EH_MUST_NOT_THROW
:
326 case GIMPLE_OMP_SECTIONS
:
327 case GIMPLE_OMP_SECTIONS_SWITCH
:
328 case GIMPLE_OMP_SECTION
:
329 case GIMPLE_OMP_SINGLE
:
330 case GIMPLE_OMP_MASTER
:
331 case GIMPLE_OMP_TASKGROUP
:
332 case GIMPLE_OMP_ORDERED
:
333 case GIMPLE_OMP_CRITICAL
:
334 case GIMPLE_OMP_RETURN
:
335 case GIMPLE_OMP_ATOMIC_LOAD
:
336 case GIMPLE_OMP_ATOMIC_STORE
:
337 case GIMPLE_OMP_CONTINUE
:
342 tree decl
= gimple_call_fndecl (stmt
);
345 for (i
= 0; i
< gimple_call_num_args (stmt
); i
++)
347 tree arg
= gimple_call_arg (stmt
, i
);
349 TREE_SET_BLOCK (arg
, data
->block
);
353 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
354 && DECL_FUNCTION_CODE (decl
) == BUILT_IN_SETJMP
)
356 lower_builtin_setjmp (gsi
);
357 data
->cannot_fallthru
= false;
358 data
->calls_builtin_setjmp
= true;
362 if (decl
&& (flags_from_decl_or_type (decl
) & ECF_NORETURN
))
364 data
->cannot_fallthru
= true;
371 case GIMPLE_OMP_PARALLEL
:
372 case GIMPLE_OMP_TASK
:
373 case GIMPLE_OMP_TARGET
:
374 case GIMPLE_OMP_TEAMS
:
375 data
->cannot_fallthru
= false;
376 lower_omp_directive (gsi
, data
);
377 data
->cannot_fallthru
= false;
380 case GIMPLE_TRANSACTION
:
381 lower_sequence (gimple_transaction_body_ptr (stmt
), data
);
388 data
->cannot_fallthru
= false;
392 /* Lower a bind_expr TSI. DATA is passed through the recursion. */
395 lower_gimple_bind (gimple_stmt_iterator
*gsi
, struct lower_data
*data
)
397 tree old_block
= data
->block
;
398 gimple stmt
= gsi_stmt (*gsi
);
399 tree new_block
= gimple_bind_block (stmt
);
403 if (new_block
== old_block
)
405 /* The outermost block of the original function may not be the
406 outermost statement chain of the gimplified function. So we
407 may see the outermost block just inside the function. */
408 gcc_assert (new_block
== DECL_INITIAL (current_function_decl
));
413 /* We do not expect to handle duplicate blocks. */
414 gcc_assert (!TREE_ASM_WRITTEN (new_block
));
415 TREE_ASM_WRITTEN (new_block
) = 1;
417 /* Block tree may get clobbered by inlining. Normally this would
418 be fixed in rest_of_decl_compilation using block notes, but
419 since we are not going to emit them, it is up to us. */
420 BLOCK_CHAIN (new_block
) = BLOCK_SUBBLOCKS (old_block
);
421 BLOCK_SUBBLOCKS (old_block
) = new_block
;
422 BLOCK_SUBBLOCKS (new_block
) = NULL_TREE
;
423 BLOCK_SUPERCONTEXT (new_block
) = old_block
;
425 data
->block
= new_block
;
429 record_vars (gimple_bind_vars (stmt
));
430 lower_sequence (gimple_bind_body_ptr (stmt
), data
);
434 gcc_assert (data
->block
== new_block
);
436 BLOCK_SUBBLOCKS (new_block
)
437 = blocks_nreverse (BLOCK_SUBBLOCKS (new_block
));
438 data
->block
= old_block
;
441 /* The GIMPLE_BIND no longer carries any useful information -- kill it. */
442 gsi_insert_seq_before (gsi
, gimple_bind_body (stmt
), GSI_SAME_STMT
);
443 gsi_remove (gsi
, false);
446 /* Same as above, but for a GIMPLE_TRY_CATCH. */
449 lower_try_catch (gimple_stmt_iterator
*gsi
, struct lower_data
*data
)
451 bool cannot_fallthru
;
452 gimple stmt
= gsi_stmt (*gsi
);
453 gimple_stmt_iterator i
;
455 /* We don't handle GIMPLE_TRY_FINALLY. */
456 gcc_assert (gimple_try_kind (stmt
) == GIMPLE_TRY_CATCH
);
458 lower_sequence (gimple_try_eval_ptr (stmt
), data
);
459 cannot_fallthru
= data
->cannot_fallthru
;
461 i
= gsi_start (*gimple_try_cleanup_ptr (stmt
));
462 switch (gimple_code (gsi_stmt (i
)))
465 /* We expect to see a sequence of GIMPLE_CATCH stmts, each with a
466 catch expression and a body. The whole try/catch may fall
467 through iff any of the catch bodies falls through. */
468 for (; !gsi_end_p (i
); gsi_next (&i
))
470 data
->cannot_fallthru
= false;
471 lower_sequence (gimple_catch_handler_ptr (gsi_stmt (i
)), data
);
472 if (!data
->cannot_fallthru
)
473 cannot_fallthru
= false;
477 case GIMPLE_EH_FILTER
:
478 /* The exception filter expression only matters if there is an
479 exception. If the exception does not match EH_FILTER_TYPES,
480 we will execute EH_FILTER_FAILURE, and we will fall through
481 if that falls through. If the exception does match
482 EH_FILTER_TYPES, the stack unwinder will continue up the
483 stack, so we will not fall through. We don't know whether we
484 will throw an exception which matches EH_FILTER_TYPES or not,
485 so we just ignore EH_FILTER_TYPES and assume that we might
486 throw an exception which doesn't match. */
487 data
->cannot_fallthru
= false;
488 lower_sequence (gimple_eh_filter_failure_ptr (gsi_stmt (i
)), data
);
489 if (!data
->cannot_fallthru
)
490 cannot_fallthru
= false;
494 /* This case represents statements to be executed when an
495 exception occurs. Those statements are implicitly followed
496 by a GIMPLE_RESX to resume execution after the exception. So
497 in this case the try/catch never falls through. */
498 data
->cannot_fallthru
= false;
499 lower_sequence (gimple_try_cleanup_ptr (stmt
), data
);
503 data
->cannot_fallthru
= cannot_fallthru
;
508 /* Try to determine whether a TRY_CATCH expression can fall through.
509 This is a subroutine of gimple_stmt_may_fallthru. */
512 gimple_try_catch_may_fallthru (gimple stmt
)
514 gimple_stmt_iterator i
;
516 /* We don't handle GIMPLE_TRY_FINALLY. */
517 gcc_assert (gimple_try_kind (stmt
) == GIMPLE_TRY_CATCH
);
519 /* If the TRY block can fall through, the whole TRY_CATCH can
521 if (gimple_seq_may_fallthru (gimple_try_eval (stmt
)))
524 i
= gsi_start (*gimple_try_cleanup_ptr (stmt
));
525 switch (gimple_code (gsi_stmt (i
)))
528 /* We expect to see a sequence of GIMPLE_CATCH stmts, each with a
529 catch expression and a body. The whole try/catch may fall
530 through iff any of the catch bodies falls through. */
531 for (; !gsi_end_p (i
); gsi_next (&i
))
533 if (gimple_seq_may_fallthru (gimple_catch_handler (gsi_stmt (i
))))
538 case GIMPLE_EH_FILTER
:
539 /* The exception filter expression only matters if there is an
540 exception. If the exception does not match EH_FILTER_TYPES,
541 we will execute EH_FILTER_FAILURE, and we will fall through
542 if that falls through. If the exception does match
543 EH_FILTER_TYPES, the stack unwinder will continue up the
544 stack, so we will not fall through. We don't know whether we
545 will throw an exception which matches EH_FILTER_TYPES or not,
546 so we just ignore EH_FILTER_TYPES and assume that we might
547 throw an exception which doesn't match. */
548 return gimple_seq_may_fallthru (gimple_eh_filter_failure (gsi_stmt (i
)));
551 /* This case represents statements to be executed when an
552 exception occurs. Those statements are implicitly followed
553 by a GIMPLE_RESX to resume execution after the exception. So
554 in this case the try/catch never falls through. */
560 /* Try to determine if we can continue executing the statement
561 immediately following STMT. This guess need not be 100% accurate;
562 simply be conservative and return true if we don't know. This is
563 used only to avoid stupidly generating extra code. If we're wrong,
564 we'll just delete the extra code later. */
567 gimple_stmt_may_fallthru (gimple stmt
)
572 switch (gimple_code (stmt
))
577 /* Easy cases. If the last statement of the seq implies
578 control transfer, then we can't fall through. */
582 /* Switch has already been lowered and represents a branch
583 to a selected label and hence can't fall through. */
587 /* GIMPLE_COND's are already lowered into a two-way branch. They
588 can't fall through. */
592 return gimple_seq_may_fallthru (gimple_bind_body (stmt
));
595 if (gimple_try_kind (stmt
) == GIMPLE_TRY_CATCH
)
596 return gimple_try_catch_may_fallthru (stmt
);
598 /* It must be a GIMPLE_TRY_FINALLY. */
600 /* The finally clause is always executed after the try clause,
601 so if it does not fall through, then the try-finally will not
602 fall through. Otherwise, if the try clause does not fall
603 through, then when the finally clause falls through it will
604 resume execution wherever the try clause was going. So the
605 whole try-finally will only fall through if both the try
606 clause and the finally clause fall through. */
607 return (gimple_seq_may_fallthru (gimple_try_eval (stmt
))
608 && gimple_seq_may_fallthru (gimple_try_cleanup (stmt
)));
611 return (gimple_seq_may_fallthru (gimple_eh_else_n_body (stmt
))
612 || gimple_seq_may_fallthru (gimple_eh_else_e_body (stmt
)));
615 /* Functions that do not return do not fall through. */
616 return (gimple_call_flags (stmt
) & ECF_NORETURN
) == 0;
624 /* Same as gimple_stmt_may_fallthru, but for the gimple sequence SEQ. */
627 gimple_seq_may_fallthru (gimple_seq seq
)
629 return gimple_stmt_may_fallthru (gimple_seq_last_stmt (seq
));
633 /* Lower a GIMPLE_RETURN GSI. DATA is passed through the recursion. */
636 lower_gimple_return (gimple_stmt_iterator
*gsi
, struct lower_data
*data
)
638 gimple stmt
= gsi_stmt (*gsi
);
641 return_statements_t tmp_rs
;
643 /* Match this up with an existing return statement that's been created. */
644 for (i
= data
->return_statements
.length () - 1;
647 tmp_rs
= data
->return_statements
[i
];
649 if (gimple_return_retval (stmt
) == gimple_return_retval (tmp_rs
.stmt
))
651 /* Remove the line number from the representative return statement.
652 It now fills in for many such returns. Failure to remove this
653 will result in incorrect results for coverage analysis. */
654 gimple_set_location (tmp_rs
.stmt
, UNKNOWN_LOCATION
);
660 /* Not found. Create a new label and record the return statement. */
661 tmp_rs
.label
= create_artificial_label (cfun
->function_end_locus
);
663 data
->return_statements
.safe_push (tmp_rs
);
665 /* Generate a goto statement and remove the return statement. */
667 /* When not optimizing, make sure user returns are preserved. */
668 if (!optimize
&& gimple_has_location (stmt
))
669 DECL_ARTIFICIAL (tmp_rs
.label
) = 0;
670 t
= gimple_build_goto (tmp_rs
.label
);
671 gimple_set_location (t
, gimple_location (stmt
));
672 gimple_set_block (t
, gimple_block (stmt
));
673 gsi_insert_before (gsi
, t
, GSI_SAME_STMT
);
674 gsi_remove (gsi
, false);
677 /* Lower a __builtin_setjmp GSI.
679 __builtin_setjmp is passed a pointer to an array of five words (not
680 all will be used on all machines). It operates similarly to the C
681 library function of the same name, but is more efficient.
683 It is lowered into 3 other builtins, namely __builtin_setjmp_setup,
684 __builtin_setjmp_dispatcher and __builtin_setjmp_receiver, but with
685 __builtin_setjmp_dispatcher shared among all the instances; that's
686 why it is only emitted at the end by lower_function_body.
688 After full lowering, the body of the function should look like:
697 __builtin_setjmp_setup (&buf, &<D1847>);
701 __builtin_setjmp_receiver (&<D1847>);
704 if (D.1844 == 0) goto <D1848>; else goto <D1849>;
708 __builtin_setjmp_setup (&buf, &<D2847>);
712 __builtin_setjmp_receiver (&<D2847>);
715 if (D.2844 == 0) goto <D2848>; else goto <D2849>;
721 <D3853>: [non-local];
722 setjmpvar.0 = __builtin_setjmp_dispatcher (&<D3853>);
726 The dispatcher block will be both the unique destination of all the
727 abnormal call edges and the unique source of all the abnormal edges
728 to the receivers, thus keeping the complexity explosion localized. */
731 lower_builtin_setjmp (gimple_stmt_iterator
*gsi
)
733 gimple stmt
= gsi_stmt (*gsi
);
734 location_t loc
= gimple_location (stmt
);
735 tree cont_label
= create_artificial_label (loc
);
736 tree next_label
= create_artificial_label (loc
);
740 /* NEXT_LABEL is the label __builtin_longjmp will jump to. Its address is
741 passed to both __builtin_setjmp_setup and __builtin_setjmp_receiver. */
742 FORCED_LABEL (next_label
) = 1;
744 dest
= gimple_call_lhs (stmt
);
746 /* Build '__builtin_setjmp_setup (BUF, NEXT_LABEL)' and insert. */
747 arg
= build_addr (next_label
, current_function_decl
);
748 t
= builtin_decl_implicit (BUILT_IN_SETJMP_SETUP
);
749 g
= gimple_build_call (t
, 2, gimple_call_arg (stmt
, 0), arg
);
750 gimple_set_location (g
, loc
);
751 gimple_set_block (g
, gimple_block (stmt
));
752 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
754 /* Build 'DEST = 0' and insert. */
757 g
= gimple_build_assign (dest
, build_zero_cst (TREE_TYPE (dest
)));
758 gimple_set_location (g
, loc
);
759 gimple_set_block (g
, gimple_block (stmt
));
760 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
763 /* Build 'goto CONT_LABEL' and insert. */
764 g
= gimple_build_goto (cont_label
);
765 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
767 /* Build 'NEXT_LABEL:' and insert. */
768 g
= gimple_build_label (next_label
);
769 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
771 /* Build '__builtin_setjmp_receiver (NEXT_LABEL)' and insert. */
772 arg
= build_addr (next_label
, current_function_decl
);
773 t
= builtin_decl_implicit (BUILT_IN_SETJMP_RECEIVER
);
774 g
= gimple_build_call (t
, 1, arg
);
775 gimple_set_location (g
, loc
);
776 gimple_set_block (g
, gimple_block (stmt
));
777 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
779 /* Build 'DEST = 1' and insert. */
782 g
= gimple_build_assign (dest
, fold_convert_loc (loc
, TREE_TYPE (dest
),
784 gimple_set_location (g
, loc
);
785 gimple_set_block (g
, gimple_block (stmt
));
786 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
789 /* Build 'CONT_LABEL:' and insert. */
790 g
= gimple_build_label (cont_label
);
791 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
793 /* Remove the call to __builtin_setjmp. */
794 gsi_remove (gsi
, false);
798 /* Record the variables in VARS into function FN. */
801 record_vars_into (tree vars
, tree fn
)
803 bool change_cfun
= fn
!= current_function_decl
;
806 push_cfun (DECL_STRUCT_FUNCTION (fn
));
808 for (; vars
; vars
= DECL_CHAIN (vars
))
812 /* BIND_EXPRs contains also function/type/constant declarations
813 we don't need to care about. */
814 if (TREE_CODE (var
) != VAR_DECL
)
817 /* Nothing to do in this case. */
818 if (DECL_EXTERNAL (var
))
821 /* Record the variable. */
822 add_local_decl (cfun
, var
);
830 /* Record the variables in VARS into current_function_decl. */
833 record_vars (tree vars
)
835 record_vars_into (vars
, current_function_decl
);