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 */
167 PROP_gimple_any
, /* properties_required */
168 PROP_gimple_lcf
, /* properties_provided */
169 0, /* properties_destroyed */
170 0, /* todo_flags_start */
171 0, /* todo_flags_finish */
174 class pass_lower_cf
: public gimple_opt_pass
177 pass_lower_cf (gcc::context
*ctxt
)
178 : gimple_opt_pass (pass_data_lower_cf
, ctxt
)
181 /* opt_pass methods: */
182 virtual unsigned int execute (function
*) { return lower_function_body (); }
184 }; // class pass_lower_cf
189 make_pass_lower_cf (gcc::context
*ctxt
)
191 return new pass_lower_cf (ctxt
);
194 /* Lower sequence SEQ. Unlike gimplification the statements are not relowered
195 when they are changed -- if this has to be done, the lowering routine must
196 do it explicitly. DATA is passed through the recursion. */
199 lower_sequence (gimple_seq
*seq
, struct lower_data
*data
)
201 gimple_stmt_iterator gsi
;
203 for (gsi
= gsi_start (*seq
); !gsi_end_p (gsi
); )
204 lower_stmt (&gsi
, data
);
208 /* Lower the OpenMP directive statement pointed by GSI. DATA is
209 passed through the recursion. */
212 lower_omp_directive (gimple_stmt_iterator
*gsi
, struct lower_data
*data
)
216 stmt
= gsi_stmt (*gsi
);
218 lower_sequence (gimple_omp_body_ptr (stmt
), data
);
219 gsi_insert_seq_after (gsi
, gimple_omp_body (stmt
), GSI_CONTINUE_LINKING
);
220 gimple_omp_set_body (stmt
, NULL
);
225 /* Lower statement GSI. DATA is passed through the recursion. We try to
226 track the fallthruness of statements and get rid of unreachable return
227 statements in order to prevent the EH lowering pass from adding useless
228 edges that can cause bogus warnings to be issued later; this guess need
229 not be 100% accurate, simply be conservative and reset cannot_fallthru
230 to false if we don't know. */
233 lower_stmt (gimple_stmt_iterator
*gsi
, struct lower_data
*data
)
235 gimple stmt
= gsi_stmt (*gsi
);
237 gimple_set_block (stmt
, data
->block
);
239 switch (gimple_code (stmt
))
242 lower_gimple_bind (gsi
, data
);
243 /* Propagate fallthruness. */
249 data
->cannot_fallthru
= true;
254 if (data
->cannot_fallthru
)
256 gsi_remove (gsi
, false);
257 /* Propagate fallthruness. */
261 lower_gimple_return (gsi
, data
);
262 data
->cannot_fallthru
= true;
267 if (gimple_try_kind (stmt
) == GIMPLE_TRY_CATCH
)
268 lower_try_catch (gsi
, data
);
271 /* It must be a GIMPLE_TRY_FINALLY. */
272 bool cannot_fallthru
;
273 lower_sequence (gimple_try_eval_ptr (stmt
), data
);
274 cannot_fallthru
= data
->cannot_fallthru
;
276 /* The finally clause is always executed after the try clause,
277 so if it does not fall through, then the try-finally will not
278 fall through. Otherwise, if the try clause does not fall
279 through, then when the finally clause falls through it will
280 resume execution wherever the try clause was going. So the
281 whole try-finally will only fall through if both the try
282 clause and the finally clause fall through. */
283 data
->cannot_fallthru
= false;
284 lower_sequence (gimple_try_cleanup_ptr (stmt
), data
);
285 data
->cannot_fallthru
|= cannot_fallthru
;
291 lower_sequence (gimple_eh_else_n_body_ptr (stmt
), data
);
292 lower_sequence (gimple_eh_else_e_body_ptr (stmt
), data
);
300 case GIMPLE_EH_MUST_NOT_THROW
:
302 case GIMPLE_OMP_SECTIONS
:
303 case GIMPLE_OMP_SECTIONS_SWITCH
:
304 case GIMPLE_OMP_SECTION
:
305 case GIMPLE_OMP_SINGLE
:
306 case GIMPLE_OMP_MASTER
:
307 case GIMPLE_OMP_TASKGROUP
:
308 case GIMPLE_OMP_ORDERED
:
309 case GIMPLE_OMP_CRITICAL
:
310 case GIMPLE_OMP_RETURN
:
311 case GIMPLE_OMP_ATOMIC_LOAD
:
312 case GIMPLE_OMP_ATOMIC_STORE
:
313 case GIMPLE_OMP_CONTINUE
:
318 tree decl
= gimple_call_fndecl (stmt
);
321 for (i
= 0; i
< gimple_call_num_args (stmt
); i
++)
323 tree arg
= gimple_call_arg (stmt
, i
);
325 TREE_SET_BLOCK (arg
, data
->block
);
329 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
331 if (DECL_FUNCTION_CODE (decl
) == BUILT_IN_SETJMP
)
333 lower_builtin_setjmp (gsi
);
334 data
->cannot_fallthru
= false;
337 else if (DECL_FUNCTION_CODE (decl
) == BUILT_IN_POSIX_MEMALIGN
338 && flag_tree_bit_ccp
)
340 lower_builtin_posix_memalign (gsi
);
345 if (decl
&& (flags_from_decl_or_type (decl
) & ECF_NORETURN
))
347 data
->cannot_fallthru
= true;
354 case GIMPLE_OMP_PARALLEL
:
355 case GIMPLE_OMP_TASK
:
356 case GIMPLE_OMP_TARGET
:
357 case GIMPLE_OMP_TEAMS
:
358 data
->cannot_fallthru
= false;
359 lower_omp_directive (gsi
, data
);
360 data
->cannot_fallthru
= false;
363 case GIMPLE_TRANSACTION
:
364 lower_sequence (gimple_transaction_body_ptr (
365 as_a
<gimple_transaction
> (stmt
)),
373 data
->cannot_fallthru
= false;
377 /* Lower a bind_expr TSI. DATA is passed through the recursion. */
380 lower_gimple_bind (gimple_stmt_iterator
*gsi
, struct lower_data
*data
)
382 tree old_block
= data
->block
;
383 gimple_bind stmt
= as_a
<gimple_bind
> (gsi_stmt (*gsi
));
384 tree new_block
= gimple_bind_block (stmt
);
388 if (new_block
== old_block
)
390 /* The outermost block of the original function may not be the
391 outermost statement chain of the gimplified function. So we
392 may see the outermost block just inside the function. */
393 gcc_assert (new_block
== DECL_INITIAL (current_function_decl
));
398 /* We do not expect to handle duplicate blocks. */
399 gcc_assert (!TREE_ASM_WRITTEN (new_block
));
400 TREE_ASM_WRITTEN (new_block
) = 1;
402 /* Block tree may get clobbered by inlining. Normally this would
403 be fixed in rest_of_decl_compilation using block notes, but
404 since we are not going to emit them, it is up to us. */
405 BLOCK_CHAIN (new_block
) = BLOCK_SUBBLOCKS (old_block
);
406 BLOCK_SUBBLOCKS (old_block
) = new_block
;
407 BLOCK_SUBBLOCKS (new_block
) = NULL_TREE
;
408 BLOCK_SUPERCONTEXT (new_block
) = old_block
;
410 data
->block
= new_block
;
414 record_vars (gimple_bind_vars (stmt
));
415 lower_sequence (gimple_bind_body_ptr (stmt
), data
);
419 gcc_assert (data
->block
== new_block
);
421 BLOCK_SUBBLOCKS (new_block
)
422 = blocks_nreverse (BLOCK_SUBBLOCKS (new_block
));
423 data
->block
= old_block
;
426 /* The GIMPLE_BIND no longer carries any useful information -- kill it. */
427 gsi_insert_seq_before (gsi
, gimple_bind_body (stmt
), GSI_SAME_STMT
);
428 gsi_remove (gsi
, false);
431 /* Same as above, but for a GIMPLE_TRY_CATCH. */
434 lower_try_catch (gimple_stmt_iterator
*gsi
, struct lower_data
*data
)
436 bool cannot_fallthru
;
437 gimple stmt
= gsi_stmt (*gsi
);
438 gimple_stmt_iterator i
;
440 /* We don't handle GIMPLE_TRY_FINALLY. */
441 gcc_assert (gimple_try_kind (stmt
) == GIMPLE_TRY_CATCH
);
443 lower_sequence (gimple_try_eval_ptr (stmt
), data
);
444 cannot_fallthru
= data
->cannot_fallthru
;
446 i
= gsi_start (*gimple_try_cleanup_ptr (stmt
));
447 switch (gimple_code (gsi_stmt (i
)))
450 /* We expect to see a sequence of GIMPLE_CATCH stmts, each with a
451 catch expression and a body. The whole try/catch may fall
452 through iff any of the catch bodies falls through. */
453 for (; !gsi_end_p (i
); gsi_next (&i
))
455 data
->cannot_fallthru
= false;
456 lower_sequence (gimple_catch_handler_ptr (
457 as_a
<gimple_catch
> (gsi_stmt (i
))),
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 (
521 as_a
<gimple_catch
> (gsi_stmt (i
)))))
526 case GIMPLE_EH_FILTER
:
527 /* The exception filter expression only matters if there is an
528 exception. If the exception does not match EH_FILTER_TYPES,
529 we will execute EH_FILTER_FAILURE, and we will fall through
530 if that falls through. If the exception does match
531 EH_FILTER_TYPES, the stack unwinder will continue up the
532 stack, so we will not fall through. We don't know whether we
533 will throw an exception which matches EH_FILTER_TYPES or not,
534 so we just ignore EH_FILTER_TYPES and assume that we might
535 throw an exception which doesn't match. */
536 return gimple_seq_may_fallthru (gimple_eh_filter_failure (gsi_stmt (i
)));
539 /* This case represents statements to be executed when an
540 exception occurs. Those statements are implicitly followed
541 by a GIMPLE_RESX to resume execution after the exception. So
542 in this case the try/catch never falls through. */
548 /* Try to determine if we can continue executing the statement
549 immediately following STMT. This guess need not be 100% accurate;
550 simply be conservative and return true if we don't know. This is
551 used only to avoid stupidly generating extra code. If we're wrong,
552 we'll just delete the extra code later. */
555 gimple_stmt_may_fallthru (gimple stmt
)
560 switch (gimple_code (stmt
))
565 /* Easy cases. If the last statement of the seq implies
566 control transfer, then we can't fall through. */
570 /* Switch has already been lowered and represents a branch
571 to a selected label and hence can't fall through. */
575 /* GIMPLE_COND's are already lowered into a two-way branch. They
576 can't fall through. */
580 return gimple_seq_may_fallthru (
581 gimple_bind_body (as_a
<gimple_bind
> (stmt
)));
584 if (gimple_try_kind (stmt
) == GIMPLE_TRY_CATCH
)
585 return gimple_try_catch_may_fallthru (stmt
);
587 /* It must be a GIMPLE_TRY_FINALLY. */
589 /* The finally clause is always executed after the try clause,
590 so if it does not fall through, then the try-finally will not
591 fall through. Otherwise, if the try clause does not fall
592 through, then when the finally clause falls through it will
593 resume execution wherever the try clause was going. So the
594 whole try-finally will only fall through if both the try
595 clause and the finally clause fall through. */
596 return (gimple_seq_may_fallthru (gimple_try_eval (stmt
))
597 && gimple_seq_may_fallthru (gimple_try_cleanup (stmt
)));
600 return (gimple_seq_may_fallthru (gimple_eh_else_n_body (stmt
))
601 || gimple_seq_may_fallthru (gimple_eh_else_e_body (stmt
)));
604 /* Functions that do not return do not fall through. */
605 return (gimple_call_flags (stmt
) & ECF_NORETURN
) == 0;
613 /* Same as gimple_stmt_may_fallthru, but for the gimple sequence SEQ. */
616 gimple_seq_may_fallthru (gimple_seq seq
)
618 return gimple_stmt_may_fallthru (gimple_seq_last_stmt (seq
));
622 /* Lower a GIMPLE_RETURN GSI. DATA is passed through the recursion. */
625 lower_gimple_return (gimple_stmt_iterator
*gsi
, struct lower_data
*data
)
627 gimple_return stmt
= as_a
<gimple_return
> (gsi_stmt (*gsi
));
630 return_statements_t tmp_rs
;
632 /* Match this up with an existing return statement that's been created. */
633 for (i
= data
->return_statements
.length () - 1;
636 tmp_rs
= data
->return_statements
[i
];
638 if (gimple_return_retval (stmt
) == gimple_return_retval (tmp_rs
.stmt
))
640 /* Remove the line number from the representative return statement.
641 It now fills in for many such returns. Failure to remove this
642 will result in incorrect results for coverage analysis. */
643 gimple_set_location (tmp_rs
.stmt
, UNKNOWN_LOCATION
);
649 /* Not found. Create a new label and record the return statement. */
650 tmp_rs
.label
= create_artificial_label (cfun
->function_end_locus
);
652 data
->return_statements
.safe_push (tmp_rs
);
654 /* Generate a goto statement and remove the return statement. */
656 /* When not optimizing, make sure user returns are preserved. */
657 if (!optimize
&& gimple_has_location (stmt
))
658 DECL_ARTIFICIAL (tmp_rs
.label
) = 0;
659 t
= gimple_build_goto (tmp_rs
.label
);
660 gimple_set_location (t
, gimple_location (stmt
));
661 gimple_set_block (t
, gimple_block (stmt
));
662 gsi_insert_before (gsi
, t
, GSI_SAME_STMT
);
663 gsi_remove (gsi
, false);
666 /* Lower a __builtin_setjmp GSI.
668 __builtin_setjmp is passed a pointer to an array of five words (not
669 all will be used on all machines). It operates similarly to the C
670 library function of the same name, but is more efficient.
672 It is lowered into 2 other builtins, namely __builtin_setjmp_setup,
673 __builtin_setjmp_receiver.
675 After full lowering, the body of the function should look like:
683 __builtin_setjmp_setup (&buf, &<D1847>);
687 __builtin_setjmp_receiver (&<D1847>);
690 if (D.1844 == 0) goto <D1848>; else goto <D1849>;
694 __builtin_setjmp_setup (&buf, &<D2847>);
698 __builtin_setjmp_receiver (&<D2847>);
701 if (D.2844 == 0) goto <D2848>; else goto <D2849>;
709 During cfg creation an extra per-function (or per-OpenMP region)
710 block with ABNORMAL_DISPATCHER internal call will be added, unique
711 destination of all the abnormal call edges and the unique source of
712 all the abnormal edges to the receivers, thus keeping the complexity
713 explosion localized. */
716 lower_builtin_setjmp (gimple_stmt_iterator
*gsi
)
718 gimple stmt
= gsi_stmt (*gsi
);
719 location_t loc
= gimple_location (stmt
);
720 tree cont_label
= create_artificial_label (loc
);
721 tree next_label
= create_artificial_label (loc
);
725 /* __builtin_setjmp_{setup,receiver} aren't ECF_RETURNS_TWICE and for RTL
726 these builtins are modelled as non-local label jumps to the label
727 that is passed to these two builtins, so pretend we have a non-local
728 label during GIMPLE passes too. See PR60003. */
729 cfun
->has_nonlocal_label
= 1;
731 /* NEXT_LABEL is the label __builtin_longjmp will jump to. Its address is
732 passed to both __builtin_setjmp_setup and __builtin_setjmp_receiver. */
733 FORCED_LABEL (next_label
) = 1;
735 dest
= gimple_call_lhs (stmt
);
737 /* Build '__builtin_setjmp_setup (BUF, NEXT_LABEL)' and insert. */
738 arg
= build_addr (next_label
, current_function_decl
);
739 t
= builtin_decl_implicit (BUILT_IN_SETJMP_SETUP
);
740 g
= gimple_build_call (t
, 2, gimple_call_arg (stmt
, 0), arg
);
741 gimple_set_location (g
, loc
);
742 gimple_set_block (g
, gimple_block (stmt
));
743 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
745 /* Build 'DEST = 0' and insert. */
748 g
= gimple_build_assign (dest
, build_zero_cst (TREE_TYPE (dest
)));
749 gimple_set_location (g
, loc
);
750 gimple_set_block (g
, gimple_block (stmt
));
751 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
754 /* Build 'goto CONT_LABEL' and insert. */
755 g
= gimple_build_goto (cont_label
);
756 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
758 /* Build 'NEXT_LABEL:' and insert. */
759 g
= gimple_build_label (next_label
);
760 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
762 /* Build '__builtin_setjmp_receiver (NEXT_LABEL)' and insert. */
763 arg
= build_addr (next_label
, current_function_decl
);
764 t
= builtin_decl_implicit (BUILT_IN_SETJMP_RECEIVER
);
765 g
= gimple_build_call (t
, 1, arg
);
766 gimple_set_location (g
, loc
);
767 gimple_set_block (g
, gimple_block (stmt
));
768 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
770 /* Build 'DEST = 1' and insert. */
773 g
= gimple_build_assign (dest
, fold_convert_loc (loc
, TREE_TYPE (dest
),
775 gimple_set_location (g
, loc
);
776 gimple_set_block (g
, gimple_block (stmt
));
777 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
780 /* Build 'CONT_LABEL:' and insert. */
781 g
= gimple_build_label (cont_label
);
782 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
784 /* Remove the call to __builtin_setjmp. */
785 gsi_remove (gsi
, false);
788 /* Lower calls to posix_memalign to
789 res = posix_memalign (ptr, align, size);
791 *ptr = __builtin_assume_aligned (*ptr, align);
794 res = posix_memalign (&tem, align, size);
796 ptr = __builtin_assume_aligned (tem, align);
797 in case the first argument was &ptr. That way we can get at the
798 alignment of the heap pointer in CCP. */
801 lower_builtin_posix_memalign (gimple_stmt_iterator
*gsi
)
803 gimple stmt
, call
= gsi_stmt (*gsi
);
804 tree pptr
= gimple_call_arg (call
, 0);
805 tree align
= gimple_call_arg (call
, 1);
806 tree res
= gimple_call_lhs (call
);
807 tree ptr
= create_tmp_reg (ptr_type_node
, NULL
);
808 if (TREE_CODE (pptr
) == ADDR_EXPR
)
810 tree tem
= create_tmp_var (ptr_type_node
, NULL
);
811 TREE_ADDRESSABLE (tem
) = 1;
812 gimple_call_set_arg (call
, 0, build_fold_addr_expr (tem
));
813 stmt
= gimple_build_assign (ptr
, tem
);
816 stmt
= gimple_build_assign (ptr
,
817 fold_build2 (MEM_REF
, ptr_type_node
, pptr
,
818 build_int_cst (ptr_type_node
, 0)));
819 if (res
== NULL_TREE
)
821 res
= create_tmp_reg (integer_type_node
, NULL
);
822 gimple_call_set_lhs (call
, res
);
824 tree align_label
= create_artificial_label (UNKNOWN_LOCATION
);
825 tree noalign_label
= create_artificial_label (UNKNOWN_LOCATION
);
826 gimple cond
= gimple_build_cond (EQ_EXPR
, res
, integer_zero_node
,
827 align_label
, noalign_label
);
828 gsi_insert_after (gsi
, cond
, GSI_NEW_STMT
);
829 gsi_insert_after (gsi
, gimple_build_label (align_label
), GSI_NEW_STMT
);
830 gsi_insert_after (gsi
, stmt
, GSI_NEW_STMT
);
831 stmt
= gimple_build_call (builtin_decl_implicit (BUILT_IN_ASSUME_ALIGNED
),
833 gimple_call_set_lhs (stmt
, ptr
);
834 gsi_insert_after (gsi
, stmt
, GSI_NEW_STMT
);
835 stmt
= gimple_build_assign (fold_build2 (MEM_REF
, ptr_type_node
, pptr
,
836 build_int_cst (ptr_type_node
, 0)),
838 gsi_insert_after (gsi
, stmt
, GSI_NEW_STMT
);
839 gsi_insert_after (gsi
, gimple_build_label (noalign_label
), GSI_NEW_STMT
);
843 /* Record the variables in VARS into function FN. */
846 record_vars_into (tree vars
, tree fn
)
848 for (; vars
; vars
= DECL_CHAIN (vars
))
852 /* BIND_EXPRs contains also function/type/constant declarations
853 we don't need to care about. */
854 if (TREE_CODE (var
) != VAR_DECL
)
857 /* Nothing to do in this case. */
858 if (DECL_EXTERNAL (var
))
861 /* Record the variable. */
862 add_local_decl (DECL_STRUCT_FUNCTION (fn
), var
);
867 /* Record the variables in VARS into current_function_decl. */
870 record_vars (tree vars
)
872 record_vars_into (vars
, current_function_decl
);