1 /* GIMPLE lowering pass. Converts High GIMPLE into Low GIMPLE.
3 Copyright (C) 2003-2014 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"
26 #include "tree-nested.h"
28 #include "basic-block.h"
29 #include "tree-ssa-alias.h"
30 #include "internal-fn.h"
31 #include "gimple-expr.h"
34 #include "gimple-iterator.h"
35 #include "tree-iterator.h"
36 #include "tree-inline.h"
39 #include "diagnostic-core.h"
40 #include "tree-pass.h"
41 #include "langhooks.h"
42 #include "gimple-low.h"
43 #include "tree-nested.h"
45 /* The differences between High GIMPLE and Low GIMPLE are the
48 1- Lexical scopes are removed (i.e., GIMPLE_BIND disappears).
50 2- GIMPLE_TRY and GIMPLE_CATCH are converted to abnormal control
51 flow and exception regions are built as an on-the-side region
52 hierarchy (See tree-eh.c:lower_eh_constructs).
54 3- Multiple identical return statements are grouped into a single
55 return and gotos to the unique return site. */
57 /* Match a return statement with a label. During lowering, we identify
58 identical return statements and replace duplicates with a jump to
59 the corresponding label. */
60 struct return_statements_t
65 typedef struct return_statements_t return_statements_t
;
70 /* Block the current statement belongs to. */
73 /* A vector of label and return statements to be moved to the end
75 vec
<return_statements_t
> return_statements
;
77 /* True if the current statement cannot fall through. */
81 static void lower_stmt (gimple_stmt_iterator
*, struct lower_data
*);
82 static void lower_gimple_bind (gimple_stmt_iterator
*, struct lower_data
*);
83 static void lower_try_catch (gimple_stmt_iterator
*, struct lower_data
*);
84 static void lower_gimple_return (gimple_stmt_iterator
*, struct lower_data
*);
85 static void lower_builtin_setjmp (gimple_stmt_iterator
*);
86 static void lower_builtin_posix_memalign (gimple_stmt_iterator
*);
89 /* Lower the body of current_function_decl from High GIMPLE into Low
93 lower_function_body (void)
95 struct lower_data data
;
96 gimple_seq body
= gimple_body (current_function_decl
);
97 gimple_seq lowered_body
;
98 gimple_stmt_iterator i
;
102 /* The gimplifier should've left a body of exactly one statement,
103 namely a GIMPLE_BIND. */
104 gcc_assert (gimple_seq_first (body
) == gimple_seq_last (body
)
105 && gimple_code (gimple_seq_first_stmt (body
)) == GIMPLE_BIND
);
107 memset (&data
, 0, sizeof (data
));
108 data
.block
= DECL_INITIAL (current_function_decl
);
109 BLOCK_SUBBLOCKS (data
.block
) = NULL_TREE
;
110 BLOCK_CHAIN (data
.block
) = NULL_TREE
;
111 TREE_ASM_WRITTEN (data
.block
) = 1;
112 data
.return_statements
.create (8);
114 bind
= gimple_seq_first_stmt (body
);
116 gimple_seq_add_stmt (&lowered_body
, bind
);
117 i
= gsi_start (lowered_body
);
118 lower_gimple_bind (&i
, &data
);
120 i
= gsi_last (lowered_body
);
122 /* If the function falls off the end, we need a null return statement.
123 If we've already got one in the return_statements vector, we don't
124 need to do anything special. Otherwise build one by hand. */
125 if (gimple_seq_may_fallthru (lowered_body
)
126 && (data
.return_statements
.is_empty ()
127 || (gimple_return_retval (data
.return_statements
.last().stmt
)
130 x
= gimple_build_return (NULL
);
131 gimple_set_location (x
, cfun
->function_end_locus
);
132 gimple_set_block (x
, DECL_INITIAL (current_function_decl
));
133 gsi_insert_after (&i
, x
, GSI_CONTINUE_LINKING
);
136 /* If we lowered any return statements, emit the representative
137 at the end of the function. */
138 while (!data
.return_statements
.is_empty ())
140 return_statements_t t
= data
.return_statements
.pop ();
141 x
= gimple_build_label (t
.label
);
142 gsi_insert_after (&i
, x
, GSI_CONTINUE_LINKING
);
143 gsi_insert_after (&i
, t
.stmt
, GSI_CONTINUE_LINKING
);
146 /* Once the old body has been lowered, replace it with the new
148 gimple_set_body (current_function_decl
, lowered_body
);
150 gcc_assert (data
.block
== DECL_INITIAL (current_function_decl
));
151 BLOCK_SUBBLOCKS (data
.block
)
152 = blocks_nreverse (BLOCK_SUBBLOCKS (data
.block
));
154 clear_block_marks (data
.block
);
155 data
.return_statements
.release ();
161 const pass_data pass_data_lower_cf
=
163 GIMPLE_PASS
, /* type */
165 OPTGROUP_NONE
, /* optinfo_flags */
166 false, /* has_gate */
167 true, /* has_execute */
169 PROP_gimple_any
, /* properties_required */
170 PROP_gimple_lcf
, /* properties_provided */
171 0, /* properties_destroyed */
172 0, /* todo_flags_start */
173 0, /* todo_flags_finish */
176 class pass_lower_cf
: public gimple_opt_pass
179 pass_lower_cf (gcc::context
*ctxt
)
180 : gimple_opt_pass (pass_data_lower_cf
, ctxt
)
183 /* opt_pass methods: */
184 unsigned int execute () { return lower_function_body (); }
186 }; // class pass_lower_cf
191 make_pass_lower_cf (gcc::context
*ctxt
)
193 return new pass_lower_cf (ctxt
);
196 /* Lower sequence SEQ. Unlike gimplification the statements are not relowered
197 when they are changed -- if this has to be done, the lowering routine must
198 do it explicitly. DATA is passed through the recursion. */
201 lower_sequence (gimple_seq
*seq
, struct lower_data
*data
)
203 gimple_stmt_iterator gsi
;
205 for (gsi
= gsi_start (*seq
); !gsi_end_p (gsi
); )
206 lower_stmt (&gsi
, data
);
210 /* Lower the OpenMP directive statement pointed by GSI. DATA is
211 passed through the recursion. */
214 lower_omp_directive (gimple_stmt_iterator
*gsi
, struct lower_data
*data
)
218 stmt
= gsi_stmt (*gsi
);
220 lower_sequence (gimple_omp_body_ptr (stmt
), data
);
221 gsi_insert_seq_after (gsi
, gimple_omp_body (stmt
), GSI_CONTINUE_LINKING
);
222 gimple_omp_set_body (stmt
, NULL
);
227 /* Lower statement GSI. DATA is passed through the recursion. We try to
228 track the fallthruness of statements and get rid of unreachable return
229 statements in order to prevent the EH lowering pass from adding useless
230 edges that can cause bogus warnings to be issued later; this guess need
231 not be 100% accurate, simply be conservative and reset cannot_fallthru
232 to false if we don't know. */
235 lower_stmt (gimple_stmt_iterator
*gsi
, struct lower_data
*data
)
237 gimple stmt
= gsi_stmt (*gsi
);
239 gimple_set_block (stmt
, data
->block
);
241 switch (gimple_code (stmt
))
244 lower_gimple_bind (gsi
, data
);
245 /* Propagate fallthruness. */
251 data
->cannot_fallthru
= true;
256 if (data
->cannot_fallthru
)
258 gsi_remove (gsi
, false);
259 /* Propagate fallthruness. */
263 lower_gimple_return (gsi
, data
);
264 data
->cannot_fallthru
= true;
269 if (gimple_try_kind (stmt
) == GIMPLE_TRY_CATCH
)
270 lower_try_catch (gsi
, data
);
273 /* It must be a GIMPLE_TRY_FINALLY. */
274 bool cannot_fallthru
;
275 lower_sequence (gimple_try_eval_ptr (stmt
), data
);
276 cannot_fallthru
= data
->cannot_fallthru
;
278 /* The finally clause is always executed after the try clause,
279 so if it does not fall through, then the try-finally will not
280 fall through. Otherwise, if the try clause does not fall
281 through, then when the finally clause falls through it will
282 resume execution wherever the try clause was going. So the
283 whole try-finally will only fall through if both the try
284 clause and the finally clause fall through. */
285 data
->cannot_fallthru
= false;
286 lower_sequence (gimple_try_cleanup_ptr (stmt
), data
);
287 data
->cannot_fallthru
|= cannot_fallthru
;
293 lower_sequence (gimple_eh_else_n_body_ptr (stmt
), data
);
294 lower_sequence (gimple_eh_else_e_body_ptr (stmt
), data
);
302 case GIMPLE_EH_MUST_NOT_THROW
:
304 case GIMPLE_OMP_SECTIONS
:
305 case GIMPLE_OMP_SECTIONS_SWITCH
:
306 case GIMPLE_OMP_SECTION
:
307 case GIMPLE_OMP_SINGLE
:
308 case GIMPLE_OMP_MASTER
:
309 case GIMPLE_OMP_TASKGROUP
:
310 case GIMPLE_OMP_ORDERED
:
311 case GIMPLE_OMP_CRITICAL
:
312 case GIMPLE_OMP_RETURN
:
313 case GIMPLE_OMP_ATOMIC_LOAD
:
314 case GIMPLE_OMP_ATOMIC_STORE
:
315 case GIMPLE_OMP_CONTINUE
:
320 tree decl
= gimple_call_fndecl (stmt
);
323 for (i
= 0; i
< gimple_call_num_args (stmt
); i
++)
325 tree arg
= gimple_call_arg (stmt
, i
);
327 TREE_SET_BLOCK (arg
, data
->block
);
331 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
333 if (DECL_FUNCTION_CODE (decl
) == BUILT_IN_SETJMP
)
335 lower_builtin_setjmp (gsi
);
336 data
->cannot_fallthru
= false;
339 else if (DECL_FUNCTION_CODE (decl
) == BUILT_IN_POSIX_MEMALIGN
340 && flag_tree_bit_ccp
)
342 lower_builtin_posix_memalign (gsi
);
347 if (decl
&& (flags_from_decl_or_type (decl
) & ECF_NORETURN
))
349 data
->cannot_fallthru
= true;
356 case GIMPLE_OACC_KERNELS
:
357 case GIMPLE_OACC_PARALLEL
:
358 case GIMPLE_OMP_PARALLEL
:
359 case GIMPLE_OMP_TASK
:
360 case GIMPLE_OMP_TARGET
:
361 case GIMPLE_OMP_TEAMS
:
362 data
->cannot_fallthru
= false;
363 lower_omp_directive (gsi
, data
);
364 data
->cannot_fallthru
= false;
367 case GIMPLE_TRANSACTION
:
368 lower_sequence (gimple_transaction_body_ptr (stmt
), data
);
375 data
->cannot_fallthru
= false;
379 /* Lower a bind_expr TSI. DATA is passed through the recursion. */
382 lower_gimple_bind (gimple_stmt_iterator
*gsi
, struct lower_data
*data
)
384 tree old_block
= data
->block
;
385 gimple stmt
= gsi_stmt (*gsi
);
386 tree new_block
= gimple_bind_block (stmt
);
390 if (new_block
== old_block
)
392 /* The outermost block of the original function may not be the
393 outermost statement chain of the gimplified function. So we
394 may see the outermost block just inside the function. */
395 gcc_assert (new_block
== DECL_INITIAL (current_function_decl
));
400 /* We do not expect to handle duplicate blocks. */
401 gcc_assert (!TREE_ASM_WRITTEN (new_block
));
402 TREE_ASM_WRITTEN (new_block
) = 1;
404 /* Block tree may get clobbered by inlining. Normally this would
405 be fixed in rest_of_decl_compilation using block notes, but
406 since we are not going to emit them, it is up to us. */
407 BLOCK_CHAIN (new_block
) = BLOCK_SUBBLOCKS (old_block
);
408 BLOCK_SUBBLOCKS (old_block
) = new_block
;
409 BLOCK_SUBBLOCKS (new_block
) = NULL_TREE
;
410 BLOCK_SUPERCONTEXT (new_block
) = old_block
;
412 data
->block
= new_block
;
416 record_vars (gimple_bind_vars (stmt
));
417 lower_sequence (gimple_bind_body_ptr (stmt
), data
);
421 gcc_assert (data
->block
== new_block
);
423 BLOCK_SUBBLOCKS (new_block
)
424 = blocks_nreverse (BLOCK_SUBBLOCKS (new_block
));
425 data
->block
= old_block
;
428 /* The GIMPLE_BIND no longer carries any useful information -- kill it. */
429 gsi_insert_seq_before (gsi
, gimple_bind_body (stmt
), GSI_SAME_STMT
);
430 gsi_remove (gsi
, false);
433 /* Same as above, but for a GIMPLE_TRY_CATCH. */
436 lower_try_catch (gimple_stmt_iterator
*gsi
, struct lower_data
*data
)
438 bool cannot_fallthru
;
439 gimple stmt
= gsi_stmt (*gsi
);
440 gimple_stmt_iterator i
;
442 /* We don't handle GIMPLE_TRY_FINALLY. */
443 gcc_assert (gimple_try_kind (stmt
) == GIMPLE_TRY_CATCH
);
445 lower_sequence (gimple_try_eval_ptr (stmt
), data
);
446 cannot_fallthru
= data
->cannot_fallthru
;
448 i
= gsi_start (*gimple_try_cleanup_ptr (stmt
));
449 switch (gimple_code (gsi_stmt (i
)))
452 /* We expect to see a sequence of GIMPLE_CATCH stmts, each with a
453 catch expression and a body. The whole try/catch may fall
454 through iff any of the catch bodies falls through. */
455 for (; !gsi_end_p (i
); gsi_next (&i
))
457 data
->cannot_fallthru
= false;
458 lower_sequence (gimple_catch_handler_ptr (gsi_stmt (i
)), data
);
459 if (!data
->cannot_fallthru
)
460 cannot_fallthru
= false;
464 case GIMPLE_EH_FILTER
:
465 /* The exception filter expression only matters if there is an
466 exception. If the exception does not match EH_FILTER_TYPES,
467 we will execute EH_FILTER_FAILURE, and we will fall through
468 if that falls through. If the exception does match
469 EH_FILTER_TYPES, the stack unwinder will continue up the
470 stack, so we will not fall through. We don't know whether we
471 will throw an exception which matches EH_FILTER_TYPES or not,
472 so we just ignore EH_FILTER_TYPES and assume that we might
473 throw an exception which doesn't match. */
474 data
->cannot_fallthru
= false;
475 lower_sequence (gimple_eh_filter_failure_ptr (gsi_stmt (i
)), data
);
476 if (!data
->cannot_fallthru
)
477 cannot_fallthru
= false;
481 /* This case represents statements to be executed when an
482 exception occurs. Those statements are implicitly followed
483 by a GIMPLE_RESX to resume execution after the exception. So
484 in this case the try/catch never falls through. */
485 data
->cannot_fallthru
= false;
486 lower_sequence (gimple_try_cleanup_ptr (stmt
), data
);
490 data
->cannot_fallthru
= cannot_fallthru
;
495 /* Try to determine whether a TRY_CATCH expression can fall through.
496 This is a subroutine of gimple_stmt_may_fallthru. */
499 gimple_try_catch_may_fallthru (gimple stmt
)
501 gimple_stmt_iterator i
;
503 /* We don't handle GIMPLE_TRY_FINALLY. */
504 gcc_assert (gimple_try_kind (stmt
) == GIMPLE_TRY_CATCH
);
506 /* If the TRY block can fall through, the whole TRY_CATCH can
508 if (gimple_seq_may_fallthru (gimple_try_eval (stmt
)))
511 i
= gsi_start (*gimple_try_cleanup_ptr (stmt
));
512 switch (gimple_code (gsi_stmt (i
)))
515 /* We expect to see a sequence of GIMPLE_CATCH stmts, each with a
516 catch expression and a body. The whole try/catch may fall
517 through iff any of the catch bodies falls through. */
518 for (; !gsi_end_p (i
); gsi_next (&i
))
520 if (gimple_seq_may_fallthru (gimple_catch_handler (gsi_stmt (i
))))
525 case GIMPLE_EH_FILTER
:
526 /* The exception filter expression only matters if there is an
527 exception. If the exception does not match EH_FILTER_TYPES,
528 we will execute EH_FILTER_FAILURE, and we will fall through
529 if that falls through. If the exception does match
530 EH_FILTER_TYPES, the stack unwinder will continue up the
531 stack, so we will not fall through. We don't know whether we
532 will throw an exception which matches EH_FILTER_TYPES or not,
533 so we just ignore EH_FILTER_TYPES and assume that we might
534 throw an exception which doesn't match. */
535 return gimple_seq_may_fallthru (gimple_eh_filter_failure (gsi_stmt (i
)));
538 /* This case represents statements to be executed when an
539 exception occurs. Those statements are implicitly followed
540 by a GIMPLE_RESX to resume execution after the exception. So
541 in this case the try/catch never falls through. */
547 /* Try to determine if we can continue executing the statement
548 immediately following STMT. This guess need not be 100% accurate;
549 simply be conservative and return true if we don't know. This is
550 used only to avoid stupidly generating extra code. If we're wrong,
551 we'll just delete the extra code later. */
554 gimple_stmt_may_fallthru (gimple stmt
)
559 switch (gimple_code (stmt
))
564 /* Easy cases. If the last statement of the seq implies
565 control transfer, then we can't fall through. */
569 /* Switch has already been lowered and represents a branch
570 to a selected label and hence can't fall through. */
574 /* GIMPLE_COND's are already lowered into a two-way branch. They
575 can't fall through. */
579 return gimple_seq_may_fallthru (gimple_bind_body (stmt
));
582 if (gimple_try_kind (stmt
) == GIMPLE_TRY_CATCH
)
583 return gimple_try_catch_may_fallthru (stmt
);
585 /* It must be a GIMPLE_TRY_FINALLY. */
587 /* The finally clause is always executed after the try clause,
588 so if it does not fall through, then the try-finally will not
589 fall through. Otherwise, if the try clause does not fall
590 through, then when the finally clause falls through it will
591 resume execution wherever the try clause was going. So the
592 whole try-finally will only fall through if both the try
593 clause and the finally clause fall through. */
594 return (gimple_seq_may_fallthru (gimple_try_eval (stmt
))
595 && gimple_seq_may_fallthru (gimple_try_cleanup (stmt
)));
598 return (gimple_seq_may_fallthru (gimple_eh_else_n_body (stmt
))
599 || gimple_seq_may_fallthru (gimple_eh_else_e_body (stmt
)));
602 /* Functions that do not return do not fall through. */
603 return (gimple_call_flags (stmt
) & ECF_NORETURN
) == 0;
611 /* Same as gimple_stmt_may_fallthru, but for the gimple sequence SEQ. */
614 gimple_seq_may_fallthru (gimple_seq seq
)
616 return gimple_stmt_may_fallthru (gimple_seq_last_stmt (seq
));
620 /* Lower a GIMPLE_RETURN GSI. DATA is passed through the recursion. */
623 lower_gimple_return (gimple_stmt_iterator
*gsi
, struct lower_data
*data
)
625 gimple stmt
= gsi_stmt (*gsi
);
628 return_statements_t tmp_rs
;
630 /* Match this up with an existing return statement that's been created. */
631 for (i
= data
->return_statements
.length () - 1;
634 tmp_rs
= data
->return_statements
[i
];
636 if (gimple_return_retval (stmt
) == gimple_return_retval (tmp_rs
.stmt
))
638 /* Remove the line number from the representative return statement.
639 It now fills in for many such returns. Failure to remove this
640 will result in incorrect results for coverage analysis. */
641 gimple_set_location (tmp_rs
.stmt
, UNKNOWN_LOCATION
);
647 /* Not found. Create a new label and record the return statement. */
648 tmp_rs
.label
= create_artificial_label (cfun
->function_end_locus
);
650 data
->return_statements
.safe_push (tmp_rs
);
652 /* Generate a goto statement and remove the return statement. */
654 /* When not optimizing, make sure user returns are preserved. */
655 if (!optimize
&& gimple_has_location (stmt
))
656 DECL_ARTIFICIAL (tmp_rs
.label
) = 0;
657 t
= gimple_build_goto (tmp_rs
.label
);
658 gimple_set_location (t
, gimple_location (stmt
));
659 gimple_set_block (t
, gimple_block (stmt
));
660 gsi_insert_before (gsi
, t
, GSI_SAME_STMT
);
661 gsi_remove (gsi
, false);
664 /* Lower a __builtin_setjmp GSI.
666 __builtin_setjmp is passed a pointer to an array of five words (not
667 all will be used on all machines). It operates similarly to the C
668 library function of the same name, but is more efficient.
670 It is lowered into 2 other builtins, namely __builtin_setjmp_setup,
671 __builtin_setjmp_receiver.
673 After full lowering, the body of the function should look like:
681 __builtin_setjmp_setup (&buf, &<D1847>);
685 __builtin_setjmp_receiver (&<D1847>);
688 if (D.1844 == 0) goto <D1848>; else goto <D1849>;
692 __builtin_setjmp_setup (&buf, &<D2847>);
696 __builtin_setjmp_receiver (&<D2847>);
699 if (D.2844 == 0) goto <D2848>; else goto <D2849>;
707 During cfg creation an extra per-function (or per-OpenMP region)
708 block with ABNORMAL_DISPATCHER internal call will be added, unique
709 destination of all the abnormal call edges and the unique source of
710 all the abnormal edges to the receivers, thus keeping the complexity
711 explosion localized. */
714 lower_builtin_setjmp (gimple_stmt_iterator
*gsi
)
716 gimple stmt
= gsi_stmt (*gsi
);
717 location_t loc
= gimple_location (stmt
);
718 tree cont_label
= create_artificial_label (loc
);
719 tree next_label
= create_artificial_label (loc
);
723 /* __builtin_setjmp_{setup,receiver} aren't ECF_RETURNS_TWICE and for RTL
724 these builtins are modelled as non-local label jumps to the label
725 that is passed to these two builtins, so pretend we have a non-local
726 label during GIMPLE passes too. See PR60003. */
727 cfun
->has_nonlocal_label
= true;
729 /* NEXT_LABEL is the label __builtin_longjmp will jump to. Its address is
730 passed to both __builtin_setjmp_setup and __builtin_setjmp_receiver. */
731 FORCED_LABEL (next_label
) = 1;
733 dest
= gimple_call_lhs (stmt
);
735 /* Build '__builtin_setjmp_setup (BUF, NEXT_LABEL)' and insert. */
736 arg
= build_addr (next_label
, current_function_decl
);
737 t
= builtin_decl_implicit (BUILT_IN_SETJMP_SETUP
);
738 g
= gimple_build_call (t
, 2, gimple_call_arg (stmt
, 0), arg
);
739 gimple_set_location (g
, loc
);
740 gimple_set_block (g
, gimple_block (stmt
));
741 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
743 /* Build 'DEST = 0' and insert. */
746 g
= gimple_build_assign (dest
, build_zero_cst (TREE_TYPE (dest
)));
747 gimple_set_location (g
, loc
);
748 gimple_set_block (g
, gimple_block (stmt
));
749 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
752 /* Build 'goto CONT_LABEL' and insert. */
753 g
= gimple_build_goto (cont_label
);
754 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
756 /* Build 'NEXT_LABEL:' and insert. */
757 g
= gimple_build_label (next_label
);
758 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
760 /* Build '__builtin_setjmp_receiver (NEXT_LABEL)' and insert. */
761 arg
= build_addr (next_label
, current_function_decl
);
762 t
= builtin_decl_implicit (BUILT_IN_SETJMP_RECEIVER
);
763 g
= gimple_build_call (t
, 1, arg
);
764 gimple_set_location (g
, loc
);
765 gimple_set_block (g
, gimple_block (stmt
));
766 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
768 /* Build 'DEST = 1' and insert. */
771 g
= gimple_build_assign (dest
, fold_convert_loc (loc
, TREE_TYPE (dest
),
773 gimple_set_location (g
, loc
);
774 gimple_set_block (g
, gimple_block (stmt
));
775 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
778 /* Build 'CONT_LABEL:' and insert. */
779 g
= gimple_build_label (cont_label
);
780 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
782 /* Remove the call to __builtin_setjmp. */
783 gsi_remove (gsi
, false);
786 /* Lower calls to posix_memalign to
787 res = posix_memalign (ptr, align, size);
789 *ptr = __builtin_assume_aligned (*ptr, align);
792 res = posix_memalign (&tem, align, size);
794 ptr = __builtin_assume_aligned (tem, align);
795 in case the first argument was &ptr. That way we can get at the
796 alignment of the heap pointer in CCP. */
799 lower_builtin_posix_memalign (gimple_stmt_iterator
*gsi
)
801 gimple stmt
, call
= gsi_stmt (*gsi
);
802 tree pptr
= gimple_call_arg (call
, 0);
803 tree align
= gimple_call_arg (call
, 1);
804 tree res
= gimple_call_lhs (call
);
805 tree ptr
= create_tmp_reg (ptr_type_node
, NULL
);
806 if (TREE_CODE (pptr
) == ADDR_EXPR
)
808 tree tem
= create_tmp_var (ptr_type_node
, NULL
);
809 TREE_ADDRESSABLE (tem
) = 1;
810 gimple_call_set_arg (call
, 0, build_fold_addr_expr (tem
));
811 stmt
= gimple_build_assign (ptr
, tem
);
814 stmt
= gimple_build_assign (ptr
,
815 fold_build2 (MEM_REF
, ptr_type_node
, pptr
,
816 build_int_cst (ptr_type_node
, 0)));
817 if (res
== NULL_TREE
)
819 res
= create_tmp_reg (integer_type_node
, NULL
);
820 gimple_call_set_lhs (call
, res
);
822 tree align_label
= create_artificial_label (UNKNOWN_LOCATION
);
823 tree noalign_label
= create_artificial_label (UNKNOWN_LOCATION
);
824 gimple cond
= gimple_build_cond (EQ_EXPR
, res
, integer_zero_node
,
825 align_label
, noalign_label
);
826 gsi_insert_after (gsi
, cond
, GSI_NEW_STMT
);
827 gsi_insert_after (gsi
, gimple_build_label (align_label
), GSI_NEW_STMT
);
828 gsi_insert_after (gsi
, stmt
, GSI_NEW_STMT
);
829 stmt
= gimple_build_call (builtin_decl_implicit (BUILT_IN_ASSUME_ALIGNED
),
831 gimple_call_set_lhs (stmt
, ptr
);
832 gsi_insert_after (gsi
, stmt
, GSI_NEW_STMT
);
833 stmt
= gimple_build_assign (fold_build2 (MEM_REF
, ptr_type_node
, pptr
,
834 build_int_cst (ptr_type_node
, 0)),
836 gsi_insert_after (gsi
, stmt
, GSI_NEW_STMT
);
837 gsi_insert_after (gsi
, gimple_build_label (noalign_label
), GSI_NEW_STMT
);
841 /* Record the variables in VARS into function FN. */
844 record_vars_into (tree vars
, tree fn
)
846 bool change_cfun
= fn
!= current_function_decl
;
849 push_cfun (DECL_STRUCT_FUNCTION (fn
));
851 for (; vars
; vars
= DECL_CHAIN (vars
))
855 /* BIND_EXPRs contains also function/type/constant declarations
856 we don't need to care about. */
857 if (TREE_CODE (var
) != VAR_DECL
)
860 /* Nothing to do in this case. */
861 if (DECL_EXTERNAL (var
))
864 /* Record the variable. */
865 add_local_decl (cfun
, var
);
873 /* Record the variables in VARS into current_function_decl. */
876 record_vars (tree vars
)
878 record_vars_into (vars
, current_function_decl
);