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_OACC_KERNELS
:
355 case GIMPLE_OACC_PARALLEL
:
356 case GIMPLE_OMP_PARALLEL
:
357 case GIMPLE_OMP_TASK
:
358 case GIMPLE_OMP_TARGET
:
359 case GIMPLE_OMP_TEAMS
:
360 data
->cannot_fallthru
= false;
361 lower_omp_directive (gsi
, data
);
362 data
->cannot_fallthru
= false;
365 case GIMPLE_TRANSACTION
:
366 lower_sequence (gimple_transaction_body_ptr (stmt
), data
);
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 stmt
= 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 (gsi_stmt (i
)), data
);
457 if (!data
->cannot_fallthru
)
458 cannot_fallthru
= false;
462 case GIMPLE_EH_FILTER
:
463 /* The exception filter expression only matters if there is an
464 exception. If the exception does not match EH_FILTER_TYPES,
465 we will execute EH_FILTER_FAILURE, and we will fall through
466 if that falls through. If the exception does match
467 EH_FILTER_TYPES, the stack unwinder will continue up the
468 stack, so we will not fall through. We don't know whether we
469 will throw an exception which matches EH_FILTER_TYPES or not,
470 so we just ignore EH_FILTER_TYPES and assume that we might
471 throw an exception which doesn't match. */
472 data
->cannot_fallthru
= false;
473 lower_sequence (gimple_eh_filter_failure_ptr (gsi_stmt (i
)), data
);
474 if (!data
->cannot_fallthru
)
475 cannot_fallthru
= false;
479 /* This case represents statements to be executed when an
480 exception occurs. Those statements are implicitly followed
481 by a GIMPLE_RESX to resume execution after the exception. So
482 in this case the try/catch never falls through. */
483 data
->cannot_fallthru
= false;
484 lower_sequence (gimple_try_cleanup_ptr (stmt
), data
);
488 data
->cannot_fallthru
= cannot_fallthru
;
493 /* Try to determine whether a TRY_CATCH expression can fall through.
494 This is a subroutine of gimple_stmt_may_fallthru. */
497 gimple_try_catch_may_fallthru (gimple stmt
)
499 gimple_stmt_iterator i
;
501 /* We don't handle GIMPLE_TRY_FINALLY. */
502 gcc_assert (gimple_try_kind (stmt
) == GIMPLE_TRY_CATCH
);
504 /* If the TRY block can fall through, the whole TRY_CATCH can
506 if (gimple_seq_may_fallthru (gimple_try_eval (stmt
)))
509 i
= gsi_start (*gimple_try_cleanup_ptr (stmt
));
510 switch (gimple_code (gsi_stmt (i
)))
513 /* We expect to see a sequence of GIMPLE_CATCH stmts, each with a
514 catch expression and a body. The whole try/catch may fall
515 through iff any of the catch bodies falls through. */
516 for (; !gsi_end_p (i
); gsi_next (&i
))
518 if (gimple_seq_may_fallthru (gimple_catch_handler (gsi_stmt (i
))))
523 case GIMPLE_EH_FILTER
:
524 /* The exception filter expression only matters if there is an
525 exception. If the exception does not match EH_FILTER_TYPES,
526 we will execute EH_FILTER_FAILURE, and we will fall through
527 if that falls through. If the exception does match
528 EH_FILTER_TYPES, the stack unwinder will continue up the
529 stack, so we will not fall through. We don't know whether we
530 will throw an exception which matches EH_FILTER_TYPES or not,
531 so we just ignore EH_FILTER_TYPES and assume that we might
532 throw an exception which doesn't match. */
533 return gimple_seq_may_fallthru (gimple_eh_filter_failure (gsi_stmt (i
)));
536 /* This case represents statements to be executed when an
537 exception occurs. Those statements are implicitly followed
538 by a GIMPLE_RESX to resume execution after the exception. So
539 in this case the try/catch never falls through. */
545 /* Try to determine if we can continue executing the statement
546 immediately following STMT. This guess need not be 100% accurate;
547 simply be conservative and return true if we don't know. This is
548 used only to avoid stupidly generating extra code. If we're wrong,
549 we'll just delete the extra code later. */
552 gimple_stmt_may_fallthru (gimple stmt
)
557 switch (gimple_code (stmt
))
562 /* Easy cases. If the last statement of the seq implies
563 control transfer, then we can't fall through. */
567 /* Switch has already been lowered and represents a branch
568 to a selected label and hence can't fall through. */
572 /* GIMPLE_COND's are already lowered into a two-way branch. They
573 can't fall through. */
577 return gimple_seq_may_fallthru (gimple_bind_body (stmt
));
580 if (gimple_try_kind (stmt
) == GIMPLE_TRY_CATCH
)
581 return gimple_try_catch_may_fallthru (stmt
);
583 /* It must be a GIMPLE_TRY_FINALLY. */
585 /* The finally clause is always executed after the try clause,
586 so if it does not fall through, then the try-finally will not
587 fall through. Otherwise, if the try clause does not fall
588 through, then when the finally clause falls through it will
589 resume execution wherever the try clause was going. So the
590 whole try-finally will only fall through if both the try
591 clause and the finally clause fall through. */
592 return (gimple_seq_may_fallthru (gimple_try_eval (stmt
))
593 && gimple_seq_may_fallthru (gimple_try_cleanup (stmt
)));
596 return (gimple_seq_may_fallthru (gimple_eh_else_n_body (stmt
))
597 || gimple_seq_may_fallthru (gimple_eh_else_e_body (stmt
)));
600 /* Functions that do not return do not fall through. */
601 return (gimple_call_flags (stmt
) & ECF_NORETURN
) == 0;
609 /* Same as gimple_stmt_may_fallthru, but for the gimple sequence SEQ. */
612 gimple_seq_may_fallthru (gimple_seq seq
)
614 return gimple_stmt_may_fallthru (gimple_seq_last_stmt (seq
));
618 /* Lower a GIMPLE_RETURN GSI. DATA is passed through the recursion. */
621 lower_gimple_return (gimple_stmt_iterator
*gsi
, struct lower_data
*data
)
623 gimple stmt
= gsi_stmt (*gsi
);
626 return_statements_t tmp_rs
;
628 /* Match this up with an existing return statement that's been created. */
629 for (i
= data
->return_statements
.length () - 1;
632 tmp_rs
= data
->return_statements
[i
];
634 if (gimple_return_retval (stmt
) == gimple_return_retval (tmp_rs
.stmt
))
636 /* Remove the line number from the representative return statement.
637 It now fills in for many such returns. Failure to remove this
638 will result in incorrect results for coverage analysis. */
639 gimple_set_location (tmp_rs
.stmt
, UNKNOWN_LOCATION
);
645 /* Not found. Create a new label and record the return statement. */
646 tmp_rs
.label
= create_artificial_label (cfun
->function_end_locus
);
648 data
->return_statements
.safe_push (tmp_rs
);
650 /* Generate a goto statement and remove the return statement. */
652 /* When not optimizing, make sure user returns are preserved. */
653 if (!optimize
&& gimple_has_location (stmt
))
654 DECL_ARTIFICIAL (tmp_rs
.label
) = 0;
655 t
= gimple_build_goto (tmp_rs
.label
);
656 gimple_set_location (t
, gimple_location (stmt
));
657 gimple_set_block (t
, gimple_block (stmt
));
658 gsi_insert_before (gsi
, t
, GSI_SAME_STMT
);
659 gsi_remove (gsi
, false);
662 /* Lower a __builtin_setjmp GSI.
664 __builtin_setjmp is passed a pointer to an array of five words (not
665 all will be used on all machines). It operates similarly to the C
666 library function of the same name, but is more efficient.
668 It is lowered into 2 other builtins, namely __builtin_setjmp_setup,
669 __builtin_setjmp_receiver.
671 After full lowering, the body of the function should look like:
679 __builtin_setjmp_setup (&buf, &<D1847>);
683 __builtin_setjmp_receiver (&<D1847>);
686 if (D.1844 == 0) goto <D1848>; else goto <D1849>;
690 __builtin_setjmp_setup (&buf, &<D2847>);
694 __builtin_setjmp_receiver (&<D2847>);
697 if (D.2844 == 0) goto <D2848>; else goto <D2849>;
705 During cfg creation an extra per-function (or per-OpenMP region)
706 block with ABNORMAL_DISPATCHER internal call will be added, unique
707 destination of all the abnormal call edges and the unique source of
708 all the abnormal edges to the receivers, thus keeping the complexity
709 explosion localized. */
712 lower_builtin_setjmp (gimple_stmt_iterator
*gsi
)
714 gimple stmt
= gsi_stmt (*gsi
);
715 location_t loc
= gimple_location (stmt
);
716 tree cont_label
= create_artificial_label (loc
);
717 tree next_label
= create_artificial_label (loc
);
721 /* __builtin_setjmp_{setup,receiver} aren't ECF_RETURNS_TWICE and for RTL
722 these builtins are modelled as non-local label jumps to the label
723 that is passed to these two builtins, so pretend we have a non-local
724 label during GIMPLE passes too. See PR60003. */
725 cfun
->has_nonlocal_label
= 1;
727 /* NEXT_LABEL is the label __builtin_longjmp will jump to. Its address is
728 passed to both __builtin_setjmp_setup and __builtin_setjmp_receiver. */
729 FORCED_LABEL (next_label
) = 1;
731 dest
= gimple_call_lhs (stmt
);
733 /* Build '__builtin_setjmp_setup (BUF, NEXT_LABEL)' and insert. */
734 arg
= build_addr (next_label
, current_function_decl
);
735 t
= builtin_decl_implicit (BUILT_IN_SETJMP_SETUP
);
736 g
= gimple_build_call (t
, 2, gimple_call_arg (stmt
, 0), arg
);
737 gimple_set_location (g
, loc
);
738 gimple_set_block (g
, gimple_block (stmt
));
739 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
741 /* Build 'DEST = 0' and insert. */
744 g
= gimple_build_assign (dest
, build_zero_cst (TREE_TYPE (dest
)));
745 gimple_set_location (g
, loc
);
746 gimple_set_block (g
, gimple_block (stmt
));
747 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
750 /* Build 'goto CONT_LABEL' and insert. */
751 g
= gimple_build_goto (cont_label
);
752 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
754 /* Build 'NEXT_LABEL:' and insert. */
755 g
= gimple_build_label (next_label
);
756 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
758 /* Build '__builtin_setjmp_receiver (NEXT_LABEL)' and insert. */
759 arg
= build_addr (next_label
, current_function_decl
);
760 t
= builtin_decl_implicit (BUILT_IN_SETJMP_RECEIVER
);
761 g
= gimple_build_call (t
, 1, arg
);
762 gimple_set_location (g
, loc
);
763 gimple_set_block (g
, gimple_block (stmt
));
764 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
766 /* Build 'DEST = 1' and insert. */
769 g
= gimple_build_assign (dest
, fold_convert_loc (loc
, TREE_TYPE (dest
),
771 gimple_set_location (g
, loc
);
772 gimple_set_block (g
, gimple_block (stmt
));
773 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
776 /* Build 'CONT_LABEL:' and insert. */
777 g
= gimple_build_label (cont_label
);
778 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
780 /* Remove the call to __builtin_setjmp. */
781 gsi_remove (gsi
, false);
784 /* Lower calls to posix_memalign to
785 res = posix_memalign (ptr, align, size);
787 *ptr = __builtin_assume_aligned (*ptr, align);
790 res = posix_memalign (&tem, align, size);
792 ptr = __builtin_assume_aligned (tem, align);
793 in case the first argument was &ptr. That way we can get at the
794 alignment of the heap pointer in CCP. */
797 lower_builtin_posix_memalign (gimple_stmt_iterator
*gsi
)
799 gimple stmt
, call
= gsi_stmt (*gsi
);
800 tree pptr
= gimple_call_arg (call
, 0);
801 tree align
= gimple_call_arg (call
, 1);
802 tree res
= gimple_call_lhs (call
);
803 tree ptr
= create_tmp_reg (ptr_type_node
, NULL
);
804 if (TREE_CODE (pptr
) == ADDR_EXPR
)
806 tree tem
= create_tmp_var (ptr_type_node
, NULL
);
807 TREE_ADDRESSABLE (tem
) = 1;
808 gimple_call_set_arg (call
, 0, build_fold_addr_expr (tem
));
809 stmt
= gimple_build_assign (ptr
, tem
);
812 stmt
= gimple_build_assign (ptr
,
813 fold_build2 (MEM_REF
, ptr_type_node
, pptr
,
814 build_int_cst (ptr_type_node
, 0)));
815 if (res
== NULL_TREE
)
817 res
= create_tmp_reg (integer_type_node
, NULL
);
818 gimple_call_set_lhs (call
, res
);
820 tree align_label
= create_artificial_label (UNKNOWN_LOCATION
);
821 tree noalign_label
= create_artificial_label (UNKNOWN_LOCATION
);
822 gimple cond
= gimple_build_cond (EQ_EXPR
, res
, integer_zero_node
,
823 align_label
, noalign_label
);
824 gsi_insert_after (gsi
, cond
, GSI_NEW_STMT
);
825 gsi_insert_after (gsi
, gimple_build_label (align_label
), GSI_NEW_STMT
);
826 gsi_insert_after (gsi
, stmt
, GSI_NEW_STMT
);
827 stmt
= gimple_build_call (builtin_decl_implicit (BUILT_IN_ASSUME_ALIGNED
),
829 gimple_call_set_lhs (stmt
, ptr
);
830 gsi_insert_after (gsi
, stmt
, GSI_NEW_STMT
);
831 stmt
= gimple_build_assign (fold_build2 (MEM_REF
, ptr_type_node
, pptr
,
832 build_int_cst (ptr_type_node
, 0)),
834 gsi_insert_after (gsi
, stmt
, GSI_NEW_STMT
);
835 gsi_insert_after (gsi
, gimple_build_label (noalign_label
), GSI_NEW_STMT
);
839 /* Record the variables in VARS into function FN. */
842 record_vars_into (tree vars
, tree fn
)
844 for (; vars
; vars
= DECL_CHAIN (vars
))
848 /* BIND_EXPRs contains also function/type/constant declarations
849 we don't need to care about. */
850 if (TREE_CODE (var
) != VAR_DECL
)
853 /* Nothing to do in this case. */
854 if (DECL_EXTERNAL (var
))
857 /* Record the variable. */
858 add_local_decl (DECL_STRUCT_FUNCTION (fn
), var
);
863 /* Record the variables in VARS into current_function_decl. */
866 record_vars (tree vars
)
868 record_vars_into (vars
, current_function_decl
);