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 true, /* has_execute */
168 PROP_gimple_any
, /* properties_required */
169 PROP_gimple_lcf
, /* properties_provided */
170 0, /* properties_destroyed */
171 0, /* todo_flags_start */
172 0, /* todo_flags_finish */
175 class pass_lower_cf
: public gimple_opt_pass
178 pass_lower_cf (gcc::context
*ctxt
)
179 : gimple_opt_pass (pass_data_lower_cf
, ctxt
)
182 /* opt_pass methods: */
183 virtual unsigned int execute (function
*) { return lower_function_body (); }
185 }; // class pass_lower_cf
190 make_pass_lower_cf (gcc::context
*ctxt
)
192 return new pass_lower_cf (ctxt
);
195 /* Lower sequence SEQ. Unlike gimplification the statements are not relowered
196 when they are changed -- if this has to be done, the lowering routine must
197 do it explicitly. DATA is passed through the recursion. */
200 lower_sequence (gimple_seq
*seq
, struct lower_data
*data
)
202 gimple_stmt_iterator gsi
;
204 for (gsi
= gsi_start (*seq
); !gsi_end_p (gsi
); )
205 lower_stmt (&gsi
, data
);
209 /* Lower the OpenMP directive statement pointed by GSI. DATA is
210 passed through the recursion. */
213 lower_omp_directive (gimple_stmt_iterator
*gsi
, struct lower_data
*data
)
217 stmt
= gsi_stmt (*gsi
);
219 lower_sequence (gimple_omp_body_ptr (stmt
), data
);
220 gsi_insert_seq_after (gsi
, gimple_omp_body (stmt
), GSI_CONTINUE_LINKING
);
221 gimple_omp_set_body (stmt
, NULL
);
226 /* Lower statement GSI. DATA is passed through the recursion. We try to
227 track the fallthruness of statements and get rid of unreachable return
228 statements in order to prevent the EH lowering pass from adding useless
229 edges that can cause bogus warnings to be issued later; this guess need
230 not be 100% accurate, simply be conservative and reset cannot_fallthru
231 to false if we don't know. */
234 lower_stmt (gimple_stmt_iterator
*gsi
, struct lower_data
*data
)
236 gimple stmt
= gsi_stmt (*gsi
);
238 gimple_set_block (stmt
, data
->block
);
240 switch (gimple_code (stmt
))
243 lower_gimple_bind (gsi
, data
);
244 /* Propagate fallthruness. */
250 data
->cannot_fallthru
= true;
255 if (data
->cannot_fallthru
)
257 gsi_remove (gsi
, false);
258 /* Propagate fallthruness. */
262 lower_gimple_return (gsi
, data
);
263 data
->cannot_fallthru
= true;
268 if (gimple_try_kind (stmt
) == GIMPLE_TRY_CATCH
)
269 lower_try_catch (gsi
, data
);
272 /* It must be a GIMPLE_TRY_FINALLY. */
273 bool cannot_fallthru
;
274 lower_sequence (gimple_try_eval_ptr (stmt
), data
);
275 cannot_fallthru
= data
->cannot_fallthru
;
277 /* The finally clause is always executed after the try clause,
278 so if it does not fall through, then the try-finally will not
279 fall through. Otherwise, if the try clause does not fall
280 through, then when the finally clause falls through it will
281 resume execution wherever the try clause was going. So the
282 whole try-finally will only fall through if both the try
283 clause and the finally clause fall through. */
284 data
->cannot_fallthru
= false;
285 lower_sequence (gimple_try_cleanup_ptr (stmt
), data
);
286 data
->cannot_fallthru
|= cannot_fallthru
;
292 lower_sequence (gimple_eh_else_n_body_ptr (stmt
), data
);
293 lower_sequence (gimple_eh_else_e_body_ptr (stmt
), data
);
301 case GIMPLE_EH_MUST_NOT_THROW
:
303 case GIMPLE_OMP_SECTIONS
:
304 case GIMPLE_OMP_SECTIONS_SWITCH
:
305 case GIMPLE_OMP_SECTION
:
306 case GIMPLE_OMP_SINGLE
:
307 case GIMPLE_OMP_MASTER
:
308 case GIMPLE_OMP_TASKGROUP
:
309 case GIMPLE_OMP_ORDERED
:
310 case GIMPLE_OMP_CRITICAL
:
311 case GIMPLE_OMP_RETURN
:
312 case GIMPLE_OMP_ATOMIC_LOAD
:
313 case GIMPLE_OMP_ATOMIC_STORE
:
314 case GIMPLE_OMP_CONTINUE
:
319 tree decl
= gimple_call_fndecl (stmt
);
322 for (i
= 0; i
< gimple_call_num_args (stmt
); i
++)
324 tree arg
= gimple_call_arg (stmt
, i
);
326 TREE_SET_BLOCK (arg
, data
->block
);
330 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
332 if (DECL_FUNCTION_CODE (decl
) == BUILT_IN_SETJMP
)
334 lower_builtin_setjmp (gsi
);
335 data
->cannot_fallthru
= false;
338 else if (DECL_FUNCTION_CODE (decl
) == BUILT_IN_POSIX_MEMALIGN
339 && flag_tree_bit_ccp
)
341 lower_builtin_posix_memalign (gsi
);
346 if (decl
&& (flags_from_decl_or_type (decl
) & ECF_NORETURN
))
348 data
->cannot_fallthru
= true;
355 case GIMPLE_OMP_PARALLEL
:
356 case GIMPLE_OMP_TASK
:
357 case GIMPLE_OMP_TARGET
:
358 case GIMPLE_OMP_TEAMS
:
359 data
->cannot_fallthru
= false;
360 lower_omp_directive (gsi
, data
);
361 data
->cannot_fallthru
= false;
364 case GIMPLE_TRANSACTION
:
365 lower_sequence (gimple_transaction_body_ptr (stmt
), data
);
372 data
->cannot_fallthru
= false;
376 /* Lower a bind_expr TSI. DATA is passed through the recursion. */
379 lower_gimple_bind (gimple_stmt_iterator
*gsi
, struct lower_data
*data
)
381 tree old_block
= data
->block
;
382 gimple stmt
= gsi_stmt (*gsi
);
383 tree new_block
= gimple_bind_block (stmt
);
387 if (new_block
== old_block
)
389 /* The outermost block of the original function may not be the
390 outermost statement chain of the gimplified function. So we
391 may see the outermost block just inside the function. */
392 gcc_assert (new_block
== DECL_INITIAL (current_function_decl
));
397 /* We do not expect to handle duplicate blocks. */
398 gcc_assert (!TREE_ASM_WRITTEN (new_block
));
399 TREE_ASM_WRITTEN (new_block
) = 1;
401 /* Block tree may get clobbered by inlining. Normally this would
402 be fixed in rest_of_decl_compilation using block notes, but
403 since we are not going to emit them, it is up to us. */
404 BLOCK_CHAIN (new_block
) = BLOCK_SUBBLOCKS (old_block
);
405 BLOCK_SUBBLOCKS (old_block
) = new_block
;
406 BLOCK_SUBBLOCKS (new_block
) = NULL_TREE
;
407 BLOCK_SUPERCONTEXT (new_block
) = old_block
;
409 data
->block
= new_block
;
413 record_vars (gimple_bind_vars (stmt
));
414 lower_sequence (gimple_bind_body_ptr (stmt
), data
);
418 gcc_assert (data
->block
== new_block
);
420 BLOCK_SUBBLOCKS (new_block
)
421 = blocks_nreverse (BLOCK_SUBBLOCKS (new_block
));
422 data
->block
= old_block
;
425 /* The GIMPLE_BIND no longer carries any useful information -- kill it. */
426 gsi_insert_seq_before (gsi
, gimple_bind_body (stmt
), GSI_SAME_STMT
);
427 gsi_remove (gsi
, false);
430 /* Same as above, but for a GIMPLE_TRY_CATCH. */
433 lower_try_catch (gimple_stmt_iterator
*gsi
, struct lower_data
*data
)
435 bool cannot_fallthru
;
436 gimple stmt
= gsi_stmt (*gsi
);
437 gimple_stmt_iterator i
;
439 /* We don't handle GIMPLE_TRY_FINALLY. */
440 gcc_assert (gimple_try_kind (stmt
) == GIMPLE_TRY_CATCH
);
442 lower_sequence (gimple_try_eval_ptr (stmt
), data
);
443 cannot_fallthru
= data
->cannot_fallthru
;
445 i
= gsi_start (*gimple_try_cleanup_ptr (stmt
));
446 switch (gimple_code (gsi_stmt (i
)))
449 /* We expect to see a sequence of GIMPLE_CATCH stmts, each with a
450 catch expression and a body. The whole try/catch may fall
451 through iff any of the catch bodies falls through. */
452 for (; !gsi_end_p (i
); gsi_next (&i
))
454 data
->cannot_fallthru
= false;
455 lower_sequence (gimple_catch_handler_ptr (gsi_stmt (i
)), data
);
456 if (!data
->cannot_fallthru
)
457 cannot_fallthru
= false;
461 case GIMPLE_EH_FILTER
:
462 /* The exception filter expression only matters if there is an
463 exception. If the exception does not match EH_FILTER_TYPES,
464 we will execute EH_FILTER_FAILURE, and we will fall through
465 if that falls through. If the exception does match
466 EH_FILTER_TYPES, the stack unwinder will continue up the
467 stack, so we will not fall through. We don't know whether we
468 will throw an exception which matches EH_FILTER_TYPES or not,
469 so we just ignore EH_FILTER_TYPES and assume that we might
470 throw an exception which doesn't match. */
471 data
->cannot_fallthru
= false;
472 lower_sequence (gimple_eh_filter_failure_ptr (gsi_stmt (i
)), data
);
473 if (!data
->cannot_fallthru
)
474 cannot_fallthru
= false;
478 /* This case represents statements to be executed when an
479 exception occurs. Those statements are implicitly followed
480 by a GIMPLE_RESX to resume execution after the exception. So
481 in this case the try/catch never falls through. */
482 data
->cannot_fallthru
= false;
483 lower_sequence (gimple_try_cleanup_ptr (stmt
), data
);
487 data
->cannot_fallthru
= cannot_fallthru
;
492 /* Try to determine whether a TRY_CATCH expression can fall through.
493 This is a subroutine of gimple_stmt_may_fallthru. */
496 gimple_try_catch_may_fallthru (gimple stmt
)
498 gimple_stmt_iterator i
;
500 /* We don't handle GIMPLE_TRY_FINALLY. */
501 gcc_assert (gimple_try_kind (stmt
) == GIMPLE_TRY_CATCH
);
503 /* If the TRY block can fall through, the whole TRY_CATCH can
505 if (gimple_seq_may_fallthru (gimple_try_eval (stmt
)))
508 i
= gsi_start (*gimple_try_cleanup_ptr (stmt
));
509 switch (gimple_code (gsi_stmt (i
)))
512 /* We expect to see a sequence of GIMPLE_CATCH stmts, each with a
513 catch expression and a body. The whole try/catch may fall
514 through iff any of the catch bodies falls through. */
515 for (; !gsi_end_p (i
); gsi_next (&i
))
517 if (gimple_seq_may_fallthru (gimple_catch_handler (gsi_stmt (i
))))
522 case GIMPLE_EH_FILTER
:
523 /* The exception filter expression only matters if there is an
524 exception. If the exception does not match EH_FILTER_TYPES,
525 we will execute EH_FILTER_FAILURE, and we will fall through
526 if that falls through. If the exception does match
527 EH_FILTER_TYPES, the stack unwinder will continue up the
528 stack, so we will not fall through. We don't know whether we
529 will throw an exception which matches EH_FILTER_TYPES or not,
530 so we just ignore EH_FILTER_TYPES and assume that we might
531 throw an exception which doesn't match. */
532 return gimple_seq_may_fallthru (gimple_eh_filter_failure (gsi_stmt (i
)));
535 /* This case represents statements to be executed when an
536 exception occurs. Those statements are implicitly followed
537 by a GIMPLE_RESX to resume execution after the exception. So
538 in this case the try/catch never falls through. */
544 /* Try to determine if we can continue executing the statement
545 immediately following STMT. This guess need not be 100% accurate;
546 simply be conservative and return true if we don't know. This is
547 used only to avoid stupidly generating extra code. If we're wrong,
548 we'll just delete the extra code later. */
551 gimple_stmt_may_fallthru (gimple stmt
)
556 switch (gimple_code (stmt
))
561 /* Easy cases. If the last statement of the seq implies
562 control transfer, then we can't fall through. */
566 /* Switch has already been lowered and represents a branch
567 to a selected label and hence can't fall through. */
571 /* GIMPLE_COND's are already lowered into a two-way branch. They
572 can't fall through. */
576 return gimple_seq_may_fallthru (gimple_bind_body (stmt
));
579 if (gimple_try_kind (stmt
) == GIMPLE_TRY_CATCH
)
580 return gimple_try_catch_may_fallthru (stmt
);
582 /* It must be a GIMPLE_TRY_FINALLY. */
584 /* The finally clause is always executed after the try clause,
585 so if it does not fall through, then the try-finally will not
586 fall through. Otherwise, if the try clause does not fall
587 through, then when the finally clause falls through it will
588 resume execution wherever the try clause was going. So the
589 whole try-finally will only fall through if both the try
590 clause and the finally clause fall through. */
591 return (gimple_seq_may_fallthru (gimple_try_eval (stmt
))
592 && gimple_seq_may_fallthru (gimple_try_cleanup (stmt
)));
595 return (gimple_seq_may_fallthru (gimple_eh_else_n_body (stmt
))
596 || gimple_seq_may_fallthru (gimple_eh_else_e_body (stmt
)));
599 /* Functions that do not return do not fall through. */
600 return (gimple_call_flags (stmt
) & ECF_NORETURN
) == 0;
608 /* Same as gimple_stmt_may_fallthru, but for the gimple sequence SEQ. */
611 gimple_seq_may_fallthru (gimple_seq seq
)
613 return gimple_stmt_may_fallthru (gimple_seq_last_stmt (seq
));
617 /* Lower a GIMPLE_RETURN GSI. DATA is passed through the recursion. */
620 lower_gimple_return (gimple_stmt_iterator
*gsi
, struct lower_data
*data
)
622 gimple stmt
= gsi_stmt (*gsi
);
625 return_statements_t tmp_rs
;
627 /* Match this up with an existing return statement that's been created. */
628 for (i
= data
->return_statements
.length () - 1;
631 tmp_rs
= data
->return_statements
[i
];
633 if (gimple_return_retval (stmt
) == gimple_return_retval (tmp_rs
.stmt
))
635 /* Remove the line number from the representative return statement.
636 It now fills in for many such returns. Failure to remove this
637 will result in incorrect results for coverage analysis. */
638 gimple_set_location (tmp_rs
.stmt
, UNKNOWN_LOCATION
);
644 /* Not found. Create a new label and record the return statement. */
645 tmp_rs
.label
= create_artificial_label (cfun
->function_end_locus
);
647 data
->return_statements
.safe_push (tmp_rs
);
649 /* Generate a goto statement and remove the return statement. */
651 /* When not optimizing, make sure user returns are preserved. */
652 if (!optimize
&& gimple_has_location (stmt
))
653 DECL_ARTIFICIAL (tmp_rs
.label
) = 0;
654 t
= gimple_build_goto (tmp_rs
.label
);
655 gimple_set_location (t
, gimple_location (stmt
));
656 gimple_set_block (t
, gimple_block (stmt
));
657 gsi_insert_before (gsi
, t
, GSI_SAME_STMT
);
658 gsi_remove (gsi
, false);
661 /* Lower a __builtin_setjmp GSI.
663 __builtin_setjmp is passed a pointer to an array of five words (not
664 all will be used on all machines). It operates similarly to the C
665 library function of the same name, but is more efficient.
667 It is lowered into 2 other builtins, namely __builtin_setjmp_setup,
668 __builtin_setjmp_receiver.
670 After full lowering, the body of the function should look like:
678 __builtin_setjmp_setup (&buf, &<D1847>);
682 __builtin_setjmp_receiver (&<D1847>);
685 if (D.1844 == 0) goto <D1848>; else goto <D1849>;
689 __builtin_setjmp_setup (&buf, &<D2847>);
693 __builtin_setjmp_receiver (&<D2847>);
696 if (D.2844 == 0) goto <D2848>; else goto <D2849>;
704 During cfg creation an extra per-function (or per-OpenMP region)
705 block with ABNORMAL_DISPATCHER internal call will be added, unique
706 destination of all the abnormal call edges and the unique source of
707 all the abnormal edges to the receivers, thus keeping the complexity
708 explosion localized. */
711 lower_builtin_setjmp (gimple_stmt_iterator
*gsi
)
713 gimple stmt
= gsi_stmt (*gsi
);
714 location_t loc
= gimple_location (stmt
);
715 tree cont_label
= create_artificial_label (loc
);
716 tree next_label
= create_artificial_label (loc
);
720 /* __builtin_setjmp_{setup,receiver} aren't ECF_RETURNS_TWICE and for RTL
721 these builtins are modelled as non-local label jumps to the label
722 that is passed to these two builtins, so pretend we have a non-local
723 label during GIMPLE passes too. See PR60003. */
724 cfun
->has_nonlocal_label
= true;
726 /* NEXT_LABEL is the label __builtin_longjmp will jump to. Its address is
727 passed to both __builtin_setjmp_setup and __builtin_setjmp_receiver. */
728 FORCED_LABEL (next_label
) = 1;
730 dest
= gimple_call_lhs (stmt
);
732 /* Build '__builtin_setjmp_setup (BUF, NEXT_LABEL)' and insert. */
733 arg
= build_addr (next_label
, current_function_decl
);
734 t
= builtin_decl_implicit (BUILT_IN_SETJMP_SETUP
);
735 g
= gimple_build_call (t
, 2, gimple_call_arg (stmt
, 0), arg
);
736 gimple_set_location (g
, loc
);
737 gimple_set_block (g
, gimple_block (stmt
));
738 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
740 /* Build 'DEST = 0' and insert. */
743 g
= gimple_build_assign (dest
, build_zero_cst (TREE_TYPE (dest
)));
744 gimple_set_location (g
, loc
);
745 gimple_set_block (g
, gimple_block (stmt
));
746 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
749 /* Build 'goto CONT_LABEL' and insert. */
750 g
= gimple_build_goto (cont_label
);
751 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
753 /* Build 'NEXT_LABEL:' and insert. */
754 g
= gimple_build_label (next_label
);
755 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
757 /* Build '__builtin_setjmp_receiver (NEXT_LABEL)' and insert. */
758 arg
= build_addr (next_label
, current_function_decl
);
759 t
= builtin_decl_implicit (BUILT_IN_SETJMP_RECEIVER
);
760 g
= gimple_build_call (t
, 1, arg
);
761 gimple_set_location (g
, loc
);
762 gimple_set_block (g
, gimple_block (stmt
));
763 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
765 /* Build 'DEST = 1' and insert. */
768 g
= gimple_build_assign (dest
, fold_convert_loc (loc
, TREE_TYPE (dest
),
770 gimple_set_location (g
, loc
);
771 gimple_set_block (g
, gimple_block (stmt
));
772 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
775 /* Build 'CONT_LABEL:' and insert. */
776 g
= gimple_build_label (cont_label
);
777 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
779 /* Remove the call to __builtin_setjmp. */
780 gsi_remove (gsi
, false);
783 /* Lower calls to posix_memalign to
784 res = posix_memalign (ptr, align, size);
786 *ptr = __builtin_assume_aligned (*ptr, align);
789 res = posix_memalign (&tem, align, size);
791 ptr = __builtin_assume_aligned (tem, align);
792 in case the first argument was &ptr. That way we can get at the
793 alignment of the heap pointer in CCP. */
796 lower_builtin_posix_memalign (gimple_stmt_iterator
*gsi
)
798 gimple stmt
, call
= gsi_stmt (*gsi
);
799 tree pptr
= gimple_call_arg (call
, 0);
800 tree align
= gimple_call_arg (call
, 1);
801 tree res
= gimple_call_lhs (call
);
802 tree ptr
= create_tmp_reg (ptr_type_node
, NULL
);
803 if (TREE_CODE (pptr
) == ADDR_EXPR
)
805 tree tem
= create_tmp_var (ptr_type_node
, NULL
);
806 TREE_ADDRESSABLE (tem
) = 1;
807 gimple_call_set_arg (call
, 0, build_fold_addr_expr (tem
));
808 stmt
= gimple_build_assign (ptr
, tem
);
811 stmt
= gimple_build_assign (ptr
,
812 fold_build2 (MEM_REF
, ptr_type_node
, pptr
,
813 build_int_cst (ptr_type_node
, 0)));
814 if (res
== NULL_TREE
)
816 res
= create_tmp_reg (integer_type_node
, NULL
);
817 gimple_call_set_lhs (call
, res
);
819 tree align_label
= create_artificial_label (UNKNOWN_LOCATION
);
820 tree noalign_label
= create_artificial_label (UNKNOWN_LOCATION
);
821 gimple cond
= gimple_build_cond (EQ_EXPR
, res
, integer_zero_node
,
822 align_label
, noalign_label
);
823 gsi_insert_after (gsi
, cond
, GSI_NEW_STMT
);
824 gsi_insert_after (gsi
, gimple_build_label (align_label
), GSI_NEW_STMT
);
825 gsi_insert_after (gsi
, stmt
, GSI_NEW_STMT
);
826 stmt
= gimple_build_call (builtin_decl_implicit (BUILT_IN_ASSUME_ALIGNED
),
828 gimple_call_set_lhs (stmt
, ptr
);
829 gsi_insert_after (gsi
, stmt
, GSI_NEW_STMT
);
830 stmt
= gimple_build_assign (fold_build2 (MEM_REF
, ptr_type_node
, pptr
,
831 build_int_cst (ptr_type_node
, 0)),
833 gsi_insert_after (gsi
, stmt
, GSI_NEW_STMT
);
834 gsi_insert_after (gsi
, gimple_build_label (noalign_label
), GSI_NEW_STMT
);
838 /* Record the variables in VARS into function FN. */
841 record_vars_into (tree vars
, tree fn
)
843 for (; vars
; vars
= DECL_CHAIN (vars
))
847 /* BIND_EXPRs contains also function/type/constant declarations
848 we don't need to care about. */
849 if (TREE_CODE (var
) != VAR_DECL
)
852 /* Nothing to do in this case. */
853 if (DECL_EXTERNAL (var
))
856 /* Record the variable. */
857 add_local_decl (DECL_STRUCT_FUNCTION (fn
), var
);
862 /* Record the variables in VARS into current_function_decl. */
865 record_vars (tree vars
)
867 record_vars_into (vars
, current_function_decl
);