gcc/
[official-gcc.git] / gcc / gimple-low.c
blobc8a6e6b57fbe50a8e9cb8dd4fe1b2848ee05704c
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
10 version.
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
15 for more details.
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/>. */
21 #include "config.h"
22 #include "system.h"
23 #include "coretypes.h"
24 #include "tm.h"
25 #include "tree.h"
26 #include "tree-nested.h"
27 #include "calls.h"
28 #include "basic-block.h"
29 #include "tree-ssa-alias.h"
30 #include "internal-fn.h"
31 #include "gimple-expr.h"
32 #include "is-a.h"
33 #include "gimple.h"
34 #include "gimple-iterator.h"
35 #include "tree-iterator.h"
36 #include "tree-inline.h"
37 #include "flags.h"
38 #include "function.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
46 following:
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
62 tree label;
63 gimple stmt;
65 typedef struct return_statements_t return_statements_t;
68 struct lower_data
70 /* Block the current statement belongs to. */
71 tree block;
73 /* A vector of label and return statements to be moved to the end
74 of the function. */
75 vec<return_statements_t> return_statements;
77 /* True if the current statement cannot fall through. */
78 bool cannot_fallthru;
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
90 GIMPLE. */
92 static unsigned int
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;
99 gimple bind;
100 gimple x;
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);
115 lowered_body = NULL;
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)
128 != NULL)))
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
147 lowered sequence. */
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 ();
156 return 0;
159 namespace {
161 const pass_data pass_data_lower_cf =
163 GIMPLE_PASS, /* type */
164 "lower", /* name */
165 OPTGROUP_NONE, /* optinfo_flags */
166 TV_NONE, /* tv_id */
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
176 public:
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
186 } // anon namespace
188 gimple_opt_pass *
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. */
198 static void
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. */
211 static void
212 lower_omp_directive (gimple_stmt_iterator *gsi, struct lower_data *data)
214 gimple stmt;
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);
221 gsi_next (gsi);
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. */
232 static void
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))
241 case GIMPLE_BIND:
242 lower_gimple_bind (gsi, data);
243 /* Propagate fallthruness. */
244 return;
246 case GIMPLE_COND:
247 case GIMPLE_GOTO:
248 case GIMPLE_SWITCH:
249 data->cannot_fallthru = true;
250 gsi_next (gsi);
251 return;
253 case GIMPLE_RETURN:
254 if (data->cannot_fallthru)
256 gsi_remove (gsi, false);
257 /* Propagate fallthruness. */
259 else
261 lower_gimple_return (gsi, data);
262 data->cannot_fallthru = true;
264 return;
266 case GIMPLE_TRY:
267 if (gimple_try_kind (stmt) == GIMPLE_TRY_CATCH)
268 lower_try_catch (gsi, data);
269 else
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;
286 gsi_next (gsi);
288 return;
290 case GIMPLE_EH_ELSE:
291 lower_sequence (gimple_eh_else_n_body_ptr (stmt), data);
292 lower_sequence (gimple_eh_else_e_body_ptr (stmt), data);
293 break;
295 case GIMPLE_NOP:
296 case GIMPLE_ASM:
297 case GIMPLE_ASSIGN:
298 case GIMPLE_PREDICT:
299 case GIMPLE_LABEL:
300 case GIMPLE_EH_MUST_NOT_THROW:
301 case GIMPLE_OMP_FOR:
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:
314 break;
316 case GIMPLE_CALL:
318 tree decl = gimple_call_fndecl (stmt);
319 unsigned i;
321 for (i = 0; i < gimple_call_num_args (stmt); i++)
323 tree arg = gimple_call_arg (stmt, i);
324 if (EXPR_P (arg))
325 TREE_SET_BLOCK (arg, data->block);
328 if (decl
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;
335 return;
337 else if (DECL_FUNCTION_CODE (decl) == BUILT_IN_POSIX_MEMALIGN
338 && flag_tree_bit_ccp)
340 lower_builtin_posix_memalign (gsi);
341 return;
345 if (decl && (flags_from_decl_or_type (decl) & ECF_NORETURN))
347 data->cannot_fallthru = true;
348 gsi_next (gsi);
349 return;
352 break;
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;
361 return;
363 case GIMPLE_TRANSACTION:
364 lower_sequence (gimple_transaction_body_ptr (stmt), data);
365 break;
367 default:
368 gcc_unreachable ();
371 data->cannot_fallthru = false;
372 gsi_next (gsi);
375 /* Lower a bind_expr TSI. DATA is passed through the recursion. */
377 static void
378 lower_gimple_bind (gimple_stmt_iterator *gsi, struct lower_data *data)
380 tree old_block = data->block;
381 gimple stmt = gsi_stmt (*gsi);
382 tree new_block = gimple_bind_block (stmt);
384 if (new_block)
386 if (new_block == old_block)
388 /* The outermost block of the original function may not be the
389 outermost statement chain of the gimplified function. So we
390 may see the outermost block just inside the function. */
391 gcc_assert (new_block == DECL_INITIAL (current_function_decl));
392 new_block = NULL;
394 else
396 /* We do not expect to handle duplicate blocks. */
397 gcc_assert (!TREE_ASM_WRITTEN (new_block));
398 TREE_ASM_WRITTEN (new_block) = 1;
400 /* Block tree may get clobbered by inlining. Normally this would
401 be fixed in rest_of_decl_compilation using block notes, but
402 since we are not going to emit them, it is up to us. */
403 BLOCK_CHAIN (new_block) = BLOCK_SUBBLOCKS (old_block);
404 BLOCK_SUBBLOCKS (old_block) = new_block;
405 BLOCK_SUBBLOCKS (new_block) = NULL_TREE;
406 BLOCK_SUPERCONTEXT (new_block) = old_block;
408 data->block = new_block;
412 record_vars (gimple_bind_vars (stmt));
413 lower_sequence (gimple_bind_body_ptr (stmt), data);
415 if (new_block)
417 gcc_assert (data->block == new_block);
419 BLOCK_SUBBLOCKS (new_block)
420 = blocks_nreverse (BLOCK_SUBBLOCKS (new_block));
421 data->block = old_block;
424 /* The GIMPLE_BIND no longer carries any useful information -- kill it. */
425 gsi_insert_seq_before (gsi, gimple_bind_body (stmt), GSI_SAME_STMT);
426 gsi_remove (gsi, false);
429 /* Same as above, but for a GIMPLE_TRY_CATCH. */
431 static void
432 lower_try_catch (gimple_stmt_iterator *gsi, struct lower_data *data)
434 bool cannot_fallthru;
435 gimple stmt = gsi_stmt (*gsi);
436 gimple_stmt_iterator i;
438 /* We don't handle GIMPLE_TRY_FINALLY. */
439 gcc_assert (gimple_try_kind (stmt) == GIMPLE_TRY_CATCH);
441 lower_sequence (gimple_try_eval_ptr (stmt), data);
442 cannot_fallthru = data->cannot_fallthru;
444 i = gsi_start (*gimple_try_cleanup_ptr (stmt));
445 switch (gimple_code (gsi_stmt (i)))
447 case GIMPLE_CATCH:
448 /* We expect to see a sequence of GIMPLE_CATCH stmts, each with a
449 catch expression and a body. The whole try/catch may fall
450 through iff any of the catch bodies falls through. */
451 for (; !gsi_end_p (i); gsi_next (&i))
453 data->cannot_fallthru = false;
454 lower_sequence (gimple_catch_handler_ptr (gsi_stmt (i)), data);
455 if (!data->cannot_fallthru)
456 cannot_fallthru = false;
458 break;
460 case GIMPLE_EH_FILTER:
461 /* The exception filter expression only matters if there is an
462 exception. If the exception does not match EH_FILTER_TYPES,
463 we will execute EH_FILTER_FAILURE, and we will fall through
464 if that falls through. If the exception does match
465 EH_FILTER_TYPES, the stack unwinder will continue up the
466 stack, so we will not fall through. We don't know whether we
467 will throw an exception which matches EH_FILTER_TYPES or not,
468 so we just ignore EH_FILTER_TYPES and assume that we might
469 throw an exception which doesn't match. */
470 data->cannot_fallthru = false;
471 lower_sequence (gimple_eh_filter_failure_ptr (gsi_stmt (i)), data);
472 if (!data->cannot_fallthru)
473 cannot_fallthru = false;
474 break;
476 default:
477 /* This case represents statements to be executed when an
478 exception occurs. Those statements are implicitly followed
479 by a GIMPLE_RESX to resume execution after the exception. So
480 in this case the try/catch never falls through. */
481 data->cannot_fallthru = false;
482 lower_sequence (gimple_try_cleanup_ptr (stmt), data);
483 break;
486 data->cannot_fallthru = cannot_fallthru;
487 gsi_next (gsi);
491 /* Try to determine whether a TRY_CATCH expression can fall through.
492 This is a subroutine of gimple_stmt_may_fallthru. */
494 static bool
495 gimple_try_catch_may_fallthru (gimple stmt)
497 gimple_stmt_iterator i;
499 /* We don't handle GIMPLE_TRY_FINALLY. */
500 gcc_assert (gimple_try_kind (stmt) == GIMPLE_TRY_CATCH);
502 /* If the TRY block can fall through, the whole TRY_CATCH can
503 fall through. */
504 if (gimple_seq_may_fallthru (gimple_try_eval (stmt)))
505 return true;
507 i = gsi_start (*gimple_try_cleanup_ptr (stmt));
508 switch (gimple_code (gsi_stmt (i)))
510 case GIMPLE_CATCH:
511 /* We expect to see a sequence of GIMPLE_CATCH stmts, each with a
512 catch expression and a body. The whole try/catch may fall
513 through iff any of the catch bodies falls through. */
514 for (; !gsi_end_p (i); gsi_next (&i))
516 if (gimple_seq_may_fallthru (gimple_catch_handler (gsi_stmt (i))))
517 return true;
519 return false;
521 case GIMPLE_EH_FILTER:
522 /* The exception filter expression only matters if there is an
523 exception. If the exception does not match EH_FILTER_TYPES,
524 we will execute EH_FILTER_FAILURE, and we will fall through
525 if that falls through. If the exception does match
526 EH_FILTER_TYPES, the stack unwinder will continue up the
527 stack, so we will not fall through. We don't know whether we
528 will throw an exception which matches EH_FILTER_TYPES or not,
529 so we just ignore EH_FILTER_TYPES and assume that we might
530 throw an exception which doesn't match. */
531 return gimple_seq_may_fallthru (gimple_eh_filter_failure (gsi_stmt (i)));
533 default:
534 /* This case represents statements to be executed when an
535 exception occurs. Those statements are implicitly followed
536 by a GIMPLE_RESX to resume execution after the exception. So
537 in this case the try/catch never falls through. */
538 return false;
543 /* Try to determine if we can continue executing the statement
544 immediately following STMT. This guess need not be 100% accurate;
545 simply be conservative and return true if we don't know. This is
546 used only to avoid stupidly generating extra code. If we're wrong,
547 we'll just delete the extra code later. */
549 bool
550 gimple_stmt_may_fallthru (gimple stmt)
552 if (!stmt)
553 return true;
555 switch (gimple_code (stmt))
557 case GIMPLE_GOTO:
558 case GIMPLE_RETURN:
559 case GIMPLE_RESX:
560 /* Easy cases. If the last statement of the seq implies
561 control transfer, then we can't fall through. */
562 return false;
564 case GIMPLE_SWITCH:
565 /* Switch has already been lowered and represents a branch
566 to a selected label and hence can't fall through. */
567 return false;
569 case GIMPLE_COND:
570 /* GIMPLE_COND's are already lowered into a two-way branch. They
571 can't fall through. */
572 return false;
574 case GIMPLE_BIND:
575 return gimple_seq_may_fallthru (gimple_bind_body (stmt));
577 case GIMPLE_TRY:
578 if (gimple_try_kind (stmt) == GIMPLE_TRY_CATCH)
579 return gimple_try_catch_may_fallthru (stmt);
581 /* It must be a GIMPLE_TRY_FINALLY. */
583 /* The finally clause is always executed after the try clause,
584 so if it does not fall through, then the try-finally will not
585 fall through. Otherwise, if the try clause does not fall
586 through, then when the finally clause falls through it will
587 resume execution wherever the try clause was going. So the
588 whole try-finally will only fall through if both the try
589 clause and the finally clause fall through. */
590 return (gimple_seq_may_fallthru (gimple_try_eval (stmt))
591 && gimple_seq_may_fallthru (gimple_try_cleanup (stmt)));
593 case GIMPLE_EH_ELSE:
594 return (gimple_seq_may_fallthru (gimple_eh_else_n_body (stmt))
595 || gimple_seq_may_fallthru (gimple_eh_else_e_body (stmt)));
597 case GIMPLE_CALL:
598 /* Functions that do not return do not fall through. */
599 return (gimple_call_flags (stmt) & ECF_NORETURN) == 0;
601 default:
602 return true;
607 /* Same as gimple_stmt_may_fallthru, but for the gimple sequence SEQ. */
609 bool
610 gimple_seq_may_fallthru (gimple_seq seq)
612 return gimple_stmt_may_fallthru (gimple_seq_last_stmt (seq));
616 /* Lower a GIMPLE_RETURN GSI. DATA is passed through the recursion. */
618 static void
619 lower_gimple_return (gimple_stmt_iterator *gsi, struct lower_data *data)
621 gimple stmt = gsi_stmt (*gsi);
622 gimple t;
623 int i;
624 return_statements_t tmp_rs;
626 /* Match this up with an existing return statement that's been created. */
627 for (i = data->return_statements.length () - 1;
628 i >= 0; i--)
630 tmp_rs = data->return_statements[i];
632 if (gimple_return_retval (stmt) == gimple_return_retval (tmp_rs.stmt))
634 /* Remove the line number from the representative return statement.
635 It now fills in for many such returns. Failure to remove this
636 will result in incorrect results for coverage analysis. */
637 gimple_set_location (tmp_rs.stmt, UNKNOWN_LOCATION);
639 goto found;
643 /* Not found. Create a new label and record the return statement. */
644 tmp_rs.label = create_artificial_label (cfun->function_end_locus);
645 tmp_rs.stmt = stmt;
646 data->return_statements.safe_push (tmp_rs);
648 /* Generate a goto statement and remove the return statement. */
649 found:
650 /* When not optimizing, make sure user returns are preserved. */
651 if (!optimize && gimple_has_location (stmt))
652 DECL_ARTIFICIAL (tmp_rs.label) = 0;
653 t = gimple_build_goto (tmp_rs.label);
654 gimple_set_location (t, gimple_location (stmt));
655 gimple_set_block (t, gimple_block (stmt));
656 gsi_insert_before (gsi, t, GSI_SAME_STMT);
657 gsi_remove (gsi, false);
660 /* Lower a __builtin_setjmp GSI.
662 __builtin_setjmp is passed a pointer to an array of five words (not
663 all will be used on all machines). It operates similarly to the C
664 library function of the same name, but is more efficient.
666 It is lowered into 2 other builtins, namely __builtin_setjmp_setup,
667 __builtin_setjmp_receiver.
669 After full lowering, the body of the function should look like:
672 int D.1844;
673 int D.2844;
675 [...]
677 __builtin_setjmp_setup (&buf, &<D1847>);
678 D.1844 = 0;
679 goto <D1846>;
680 <D1847>:;
681 __builtin_setjmp_receiver (&<D1847>);
682 D.1844 = 1;
683 <D1846>:;
684 if (D.1844 == 0) goto <D1848>; else goto <D1849>;
686 [...]
688 __builtin_setjmp_setup (&buf, &<D2847>);
689 D.2844 = 0;
690 goto <D2846>;
691 <D2847>:;
692 __builtin_setjmp_receiver (&<D2847>);
693 D.2844 = 1;
694 <D2846>:;
695 if (D.2844 == 0) goto <D2848>; else goto <D2849>;
697 [...]
699 <D3850>:;
700 return;
703 During cfg creation an extra per-function (or per-OpenMP region)
704 block with ABNORMAL_DISPATCHER internal call will be added, unique
705 destination of all the abnormal call edges and the unique source of
706 all the abnormal edges to the receivers, thus keeping the complexity
707 explosion localized. */
709 static void
710 lower_builtin_setjmp (gimple_stmt_iterator *gsi)
712 gimple stmt = gsi_stmt (*gsi);
713 location_t loc = gimple_location (stmt);
714 tree cont_label = create_artificial_label (loc);
715 tree next_label = create_artificial_label (loc);
716 tree dest, t, arg;
717 gimple g;
719 /* __builtin_setjmp_{setup,receiver} aren't ECF_RETURNS_TWICE and for RTL
720 these builtins are modelled as non-local label jumps to the label
721 that is passed to these two builtins, so pretend we have a non-local
722 label during GIMPLE passes too. See PR60003. */
723 cfun->has_nonlocal_label = 1;
725 /* NEXT_LABEL is the label __builtin_longjmp will jump to. Its address is
726 passed to both __builtin_setjmp_setup and __builtin_setjmp_receiver. */
727 FORCED_LABEL (next_label) = 1;
729 dest = gimple_call_lhs (stmt);
731 /* Build '__builtin_setjmp_setup (BUF, NEXT_LABEL)' and insert. */
732 arg = build_addr (next_label, current_function_decl);
733 t = builtin_decl_implicit (BUILT_IN_SETJMP_SETUP);
734 g = gimple_build_call (t, 2, gimple_call_arg (stmt, 0), arg);
735 gimple_set_location (g, loc);
736 gimple_set_block (g, gimple_block (stmt));
737 gsi_insert_before (gsi, g, GSI_SAME_STMT);
739 /* Build 'DEST = 0' and insert. */
740 if (dest)
742 g = gimple_build_assign (dest, build_zero_cst (TREE_TYPE (dest)));
743 gimple_set_location (g, loc);
744 gimple_set_block (g, gimple_block (stmt));
745 gsi_insert_before (gsi, g, GSI_SAME_STMT);
748 /* Build 'goto CONT_LABEL' and insert. */
749 g = gimple_build_goto (cont_label);
750 gsi_insert_before (gsi, g, GSI_SAME_STMT);
752 /* Build 'NEXT_LABEL:' and insert. */
753 g = gimple_build_label (next_label);
754 gsi_insert_before (gsi, g, GSI_SAME_STMT);
756 /* Build '__builtin_setjmp_receiver (NEXT_LABEL)' and insert. */
757 arg = build_addr (next_label, current_function_decl);
758 t = builtin_decl_implicit (BUILT_IN_SETJMP_RECEIVER);
759 g = gimple_build_call (t, 1, arg);
760 gimple_set_location (g, loc);
761 gimple_set_block (g, gimple_block (stmt));
762 gsi_insert_before (gsi, g, GSI_SAME_STMT);
764 /* Build 'DEST = 1' and insert. */
765 if (dest)
767 g = gimple_build_assign (dest, fold_convert_loc (loc, TREE_TYPE (dest),
768 integer_one_node));
769 gimple_set_location (g, loc);
770 gimple_set_block (g, gimple_block (stmt));
771 gsi_insert_before (gsi, g, GSI_SAME_STMT);
774 /* Build 'CONT_LABEL:' and insert. */
775 g = gimple_build_label (cont_label);
776 gsi_insert_before (gsi, g, GSI_SAME_STMT);
778 /* Remove the call to __builtin_setjmp. */
779 gsi_remove (gsi, false);
782 /* Lower calls to posix_memalign to
783 res = posix_memalign (ptr, align, size);
784 if (res == 0)
785 *ptr = __builtin_assume_aligned (*ptr, align);
786 or to
787 void *tem;
788 res = posix_memalign (&tem, align, size);
789 if (res == 0)
790 ptr = __builtin_assume_aligned (tem, align);
791 in case the first argument was &ptr. That way we can get at the
792 alignment of the heap pointer in CCP. */
794 static void
795 lower_builtin_posix_memalign (gimple_stmt_iterator *gsi)
797 gimple stmt, call = gsi_stmt (*gsi);
798 tree pptr = gimple_call_arg (call, 0);
799 tree align = gimple_call_arg (call, 1);
800 tree res = gimple_call_lhs (call);
801 tree ptr = create_tmp_reg (ptr_type_node, NULL);
802 if (TREE_CODE (pptr) == ADDR_EXPR)
804 tree tem = create_tmp_var (ptr_type_node, NULL);
805 TREE_ADDRESSABLE (tem) = 1;
806 gimple_call_set_arg (call, 0, build_fold_addr_expr (tem));
807 stmt = gimple_build_assign (ptr, tem);
809 else
810 stmt = gimple_build_assign (ptr,
811 fold_build2 (MEM_REF, ptr_type_node, pptr,
812 build_int_cst (ptr_type_node, 0)));
813 if (res == NULL_TREE)
815 res = create_tmp_reg (integer_type_node, NULL);
816 gimple_call_set_lhs (call, res);
818 tree align_label = create_artificial_label (UNKNOWN_LOCATION);
819 tree noalign_label = create_artificial_label (UNKNOWN_LOCATION);
820 gimple cond = gimple_build_cond (EQ_EXPR, res, integer_zero_node,
821 align_label, noalign_label);
822 gsi_insert_after (gsi, cond, GSI_NEW_STMT);
823 gsi_insert_after (gsi, gimple_build_label (align_label), GSI_NEW_STMT);
824 gsi_insert_after (gsi, stmt, GSI_NEW_STMT);
825 stmt = gimple_build_call (builtin_decl_implicit (BUILT_IN_ASSUME_ALIGNED),
826 2, ptr, align);
827 gimple_call_set_lhs (stmt, ptr);
828 gsi_insert_after (gsi, stmt, GSI_NEW_STMT);
829 stmt = gimple_build_assign (fold_build2 (MEM_REF, ptr_type_node, pptr,
830 build_int_cst (ptr_type_node, 0)),
831 ptr);
832 gsi_insert_after (gsi, stmt, GSI_NEW_STMT);
833 gsi_insert_after (gsi, gimple_build_label (noalign_label), GSI_NEW_STMT);
837 /* Record the variables in VARS into function FN. */
839 void
840 record_vars_into (tree vars, tree fn)
842 for (; vars; vars = DECL_CHAIN (vars))
844 tree var = vars;
846 /* BIND_EXPRs contains also function/type/constant declarations
847 we don't need to care about. */
848 if (TREE_CODE (var) != VAR_DECL)
849 continue;
851 /* Nothing to do in this case. */
852 if (DECL_EXTERNAL (var))
853 continue;
855 /* Record the variable. */
856 add_local_decl (DECL_STRUCT_FUNCTION (fn), var);
861 /* Record the variables in VARS into current_function_decl. */
863 void
864 record_vars (tree vars)
866 record_vars_into (vars, current_function_decl);