1 /* Tree lowering pass. Lowers GIMPLE into unstructured form.
2
3 Copyright (C) 2003, 2005 Free Software Foundation, Inc.
4
5 This file is part of GCC.
6
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 2, or (at your option) any later
10 version.
11
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.
16
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
20 02110-1301, USA. */
21
22 #include "config.h"
23 #include "system.h"
24 #include "coretypes.h"
25 #include "tm.h"
26 #include "tree.h"
27 #include "rtl.h"
28 #include "varray.h"
29 #include "tree-gimple.h"
30 #include "tree-inline.h"
31 #include "diagnostic.h"
32 #include "langhooks.h"
33 #include "langhooks-def.h"
34 #include "tree-flow.h"
35 #include "timevar.h"
36 #include "except.h"
37 #include "hashtab.h"
38 #include "flags.h"
39 #include "function.h"
40 #include "expr.h"
41 #include "toplev.h"
42 #include "tree-pass.h"
43
44 struct lower_data
45 {
46 /* Block the current statement belongs to. */
47 tree block;
48
49 /* A TREE_LIST of label and return statements to be moved to the end
50 of the function. */
51 tree return_statements;
52
53 /* True if the function calls __builtin_setjmp. */
54 bool calls_builtin_setjmp;
55 };
56
57 static void lower_stmt (tree_stmt_iterator *, struct lower_data *);
58 static void lower_bind_expr (tree_stmt_iterator *, struct lower_data *);
59 static void lower_cond_expr (tree_stmt_iterator *, struct lower_data *);
60 static void lower_return_expr (tree_stmt_iterator *, struct lower_data *);
61 static void lower_builtin_setjmp (tree_stmt_iterator *);
62
63 /* Lower the body of current_function_decl. */
64
65 static unsigned int
lower_function_body(void)66 lower_function_body (void)
67 {
68 struct lower_data data;
69 tree *body_p = &DECL_SAVED_TREE (current_function_decl);
70 tree bind = *body_p;
71 tree_stmt_iterator i;
72 tree t, x;
73
74 gcc_assert (TREE_CODE (bind) == BIND_EXPR);
75
76 memset (&data, 0, sizeof (data));
77 data.block = DECL_INITIAL (current_function_decl);
78 BLOCK_SUBBLOCKS (data.block) = NULL_TREE;
79 BLOCK_CHAIN (data.block) = NULL_TREE;
80 TREE_ASM_WRITTEN (data.block) = 1;
81
82 *body_p = alloc_stmt_list ();
83 i = tsi_start (*body_p);
84 tsi_link_after (&i, bind, TSI_NEW_STMT);
85 lower_bind_expr (&i, &data);
86
87 i = tsi_last (*body_p);
88
89 /* If the function falls off the end, we need a null return statement.
90 If we've already got one in the return_statements list, we don't
91 need to do anything special. Otherwise build one by hand. */
92 if (block_may_fallthru (*body_p)
93 && (data.return_statements == NULL
94 || TREE_OPERAND (TREE_VALUE (data.return_statements), 0) != NULL))
95 {
96 x = build1 (RETURN_EXPR, void_type_node, NULL);
97 SET_EXPR_LOCATION (x, cfun->function_end_locus);
98 tsi_link_after (&i, x, TSI_CONTINUE_LINKING);
99 }
100
101 /* If we lowered any return statements, emit the representative
102 at the end of the function. */
103 for (t = data.return_statements ; t ; t = TREE_CHAIN (t))
104 {
105 x = build1 (LABEL_EXPR, void_type_node, TREE_PURPOSE (t));
106 tsi_link_after (&i, x, TSI_CONTINUE_LINKING);
107
108 /* Remove the line number from the representative return statement.
109 It now fills in for many such returns. Failure to remove this
110 will result in incorrect results for coverage analysis. */
111 x = TREE_VALUE (t);
112 #ifdef USE_MAPPED_LOCATION
113 SET_EXPR_LOCATION (x, UNKNOWN_LOCATION);
114 #else
115 SET_EXPR_LOCUS (x, NULL);
116 #endif
117 tsi_link_after (&i, x, TSI_CONTINUE_LINKING);
118 }
119
120 /* If the function calls __builtin_setjmp, we need to emit the computed
121 goto that will serve as the unique dispatcher for all the receivers. */
122 if (data.calls_builtin_setjmp)
123 {
124 tree disp_label, disp_var, arg;
125
126 /* Build 'DISP_LABEL:' and insert. */
127 disp_label = create_artificial_label ();
128 /* This mark will create forward edges from every call site. */
129 DECL_NONLOCAL (disp_label) = 1;
130 current_function_has_nonlocal_label = 1;
131 x = build1 (LABEL_EXPR, void_type_node, disp_label);
132 tsi_link_after (&i, x, TSI_CONTINUE_LINKING);
133
134 /* Build 'DISP_VAR = __builtin_setjmp_dispatcher (DISP_LABEL);'
135 and insert. */
136 disp_var = create_tmp_var (ptr_type_node, "setjmpvar");
137 t = build_addr (disp_label, current_function_decl);
138 arg = tree_cons (NULL, t, NULL);
139 t = implicit_built_in_decls[BUILT_IN_SETJMP_DISPATCHER];
140 t = build_function_call_expr (t,arg);
141 x = build2 (MODIFY_EXPR, void_type_node, disp_var, t);
142
143 /* Build 'goto DISP_VAR;' and insert. */
144 tsi_link_after (&i, x, TSI_CONTINUE_LINKING);
145 x = build1 (GOTO_EXPR, void_type_node, disp_var);
146 tsi_link_after (&i, x, TSI_CONTINUE_LINKING);
147 }
148
149 gcc_assert (data.block == DECL_INITIAL (current_function_decl));
150 BLOCK_SUBBLOCKS (data.block)
151 = blocks_nreverse (BLOCK_SUBBLOCKS (data.block));
152
153 clear_block_marks (data.block);
154 return 0;
155 }
156
157 struct tree_opt_pass pass_lower_cf =
158 {
159 "lower", /* name */
160 NULL, /* gate */
161 lower_function_body, /* execute */
162 NULL, /* sub */
163 NULL, /* next */
164 0, /* static_pass_number */
165 0, /* tv_id */
166 PROP_gimple_any, /* properties_required */
167 PROP_gimple_lcf, /* properties_provided */
168 0, /* properties_destroyed */
169 0, /* todo_flags_start */
170 TODO_dump_func, /* todo_flags_finish */
171 0 /* letter */
172 };
173
174
175 /* Lower the EXPR. Unlike gimplification the statements are not relowered
176 when they are changed -- if this has to be done, the lowering routine must
177 do it explicitly. DATA is passed through the recursion. */
178
179 static void
lower_stmt_body(tree expr,struct lower_data * data)180 lower_stmt_body (tree expr, struct lower_data *data)
181 {
182 tree_stmt_iterator tsi;
183
184 for (tsi = tsi_start (expr); !tsi_end_p (tsi); )
185 lower_stmt (&tsi, data);
186 }
187
188
189 /* Lower the OpenMP directive statement pointed by TSI. DATA is
190 passed through the recursion. */
191
192 static void
lower_omp_directive(tree_stmt_iterator * tsi,struct lower_data * data)193 lower_omp_directive (tree_stmt_iterator *tsi, struct lower_data *data)
194 {
195 tree stmt;
196
197 stmt = tsi_stmt (*tsi);
198
199 lower_stmt_body (OMP_BODY (stmt), data);
200 tsi_link_before (tsi, stmt, TSI_SAME_STMT);
201 tsi_link_before (tsi, OMP_BODY (stmt), TSI_SAME_STMT);
202 OMP_BODY (stmt) = NULL_TREE;
203 tsi_delink (tsi);
204 }
205
206
207 /* Lower statement TSI. DATA is passed through the recursion. */
208
209 static void
lower_stmt(tree_stmt_iterator * tsi,struct lower_data * data)210 lower_stmt (tree_stmt_iterator *tsi, struct lower_data *data)
211 {
212 tree stmt = tsi_stmt (*tsi);
213
214 if (EXPR_HAS_LOCATION (stmt) && data)
215 TREE_BLOCK (stmt) = data->block;
216
217 switch (TREE_CODE (stmt))
218 {
219 case BIND_EXPR:
220 lower_bind_expr (tsi, data);
221 return;
222 case COND_EXPR:
223 lower_cond_expr (tsi, data);
224 return;
225 case RETURN_EXPR:
226 lower_return_expr (tsi, data);
227 return;
228
229 case TRY_FINALLY_EXPR:
230 case TRY_CATCH_EXPR:
231 lower_stmt_body (TREE_OPERAND (stmt, 0), data);
232 lower_stmt_body (TREE_OPERAND (stmt, 1), data);
233 break;
234 case CATCH_EXPR:
235 lower_stmt_body (CATCH_BODY (stmt), data);
236 break;
237 case EH_FILTER_EXPR:
238 lower_stmt_body (EH_FILTER_FAILURE (stmt), data);
239 break;
240
241 case NOP_EXPR:
242 case ASM_EXPR:
243 case GOTO_EXPR:
244 case LABEL_EXPR:
245 case SWITCH_EXPR:
246 case OMP_FOR:
247 case OMP_SECTIONS:
248 case OMP_SECTION:
249 case OMP_SINGLE:
250 case OMP_MASTER:
251 case OMP_ORDERED:
252 case OMP_CRITICAL:
253 case OMP_RETURN:
254 case OMP_CONTINUE:
255 break;
256
257 case MODIFY_EXPR:
258 if (TREE_CODE (TREE_OPERAND (stmt, 1)) == CALL_EXPR)
259 stmt = TREE_OPERAND (stmt, 1);
260 else
261 break;
262 /* FALLTHRU */
263
264 case CALL_EXPR:
265 {
266 tree decl = get_callee_fndecl (stmt);
267 if (decl
268 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
269 && DECL_FUNCTION_CODE (decl) == BUILT_IN_SETJMP)
270 {
271 data->calls_builtin_setjmp = true;
272 lower_builtin_setjmp (tsi);
273 return;
274 }
275 }
276 break;
277
278 case OMP_PARALLEL:
279 lower_omp_directive (tsi, data);
280 return;
281
282 default:
283 gcc_unreachable ();
284 }
285
286 tsi_next (tsi);
287 }
288
289 /* Lower a bind_expr TSI. DATA is passed through the recursion. */
290
291 static void
lower_bind_expr(tree_stmt_iterator * tsi,struct lower_data * data)292 lower_bind_expr (tree_stmt_iterator *tsi, struct lower_data *data)
293 {
294 tree old_block = data->block;
295 tree stmt = tsi_stmt (*tsi);
296 tree new_block = BIND_EXPR_BLOCK (stmt);
297
298 if (new_block)
299 {
300 if (new_block == old_block)
301 {
302 /* The outermost block of the original function may not be the
303 outermost statement chain of the gimplified function. So we
304 may see the outermost block just inside the function. */
305 gcc_assert (new_block == DECL_INITIAL (current_function_decl));
306 new_block = NULL;
307 }
308 else
309 {
310 /* We do not expect to handle duplicate blocks. */
311 gcc_assert (!TREE_ASM_WRITTEN (new_block));
312 TREE_ASM_WRITTEN (new_block) = 1;
313
314 /* Block tree may get clobbered by inlining. Normally this would
315 be fixed in rest_of_decl_compilation using block notes, but
316 since we are not going to emit them, it is up to us. */
317 BLOCK_CHAIN (new_block) = BLOCK_SUBBLOCKS (old_block);
318 BLOCK_SUBBLOCKS (old_block) = new_block;
319 BLOCK_SUBBLOCKS (new_block) = NULL_TREE;
320 BLOCK_SUPERCONTEXT (new_block) = old_block;
321
322 data->block = new_block;
323 }
324 }
325
326 record_vars (BIND_EXPR_VARS (stmt));
327 lower_stmt_body (BIND_EXPR_BODY (stmt), data);
328
329 if (new_block)
330 {
331 gcc_assert (data->block == new_block);
332
333 BLOCK_SUBBLOCKS (new_block)
334 = blocks_nreverse (BLOCK_SUBBLOCKS (new_block));
335 data->block = old_block;
336 }
337
338 /* The BIND_EXPR no longer carries any useful information -- kill it. */
339 tsi_link_before (tsi, BIND_EXPR_BODY (stmt), TSI_SAME_STMT);
340 tsi_delink (tsi);
341 }
342
343 /* Try to determine whether a TRY_CATCH expression can fall through.
344 This is a subroutine of block_may_fallthru. */
345
346 static bool
try_catch_may_fallthru(tree stmt)347 try_catch_may_fallthru (tree stmt)
348 {
349 tree_stmt_iterator i;
350
351 /* If the TRY block can fall through, the whole TRY_CATCH can
352 fall through. */
353 if (block_may_fallthru (TREE_OPERAND (stmt, 0)))
354 return true;
355
356 i = tsi_start (TREE_OPERAND (stmt, 1));
357 switch (TREE_CODE (tsi_stmt (i)))
358 {
359 case CATCH_EXPR:
360 /* We expect to see a sequence of CATCH_EXPR trees, each with a
361 catch expression and a body. The whole TRY_CATCH may fall
362 through iff any of the catch bodies falls through. */
363 for (; !tsi_end_p (i); tsi_next (&i))
364 {
365 if (block_may_fallthru (CATCH_BODY (tsi_stmt (i))))
366 return true;
367 }
368 return false;
369
370 case EH_FILTER_EXPR:
371 /* The exception filter expression only matters if there is an
372 exception. If the exception does not match EH_FILTER_TYPES,
373 we will execute EH_FILTER_FAILURE, and we will fall through
374 if that falls through. If the exception does match
375 EH_FILTER_TYPES, the stack unwinder will continue up the
376 stack, so we will not fall through. We don't know whether we
377 will throw an exception which matches EH_FILTER_TYPES or not,
378 so we just ignore EH_FILTER_TYPES and assume that we might
379 throw an exception which doesn't match. */
380 return block_may_fallthru (EH_FILTER_FAILURE (tsi_stmt (i)));
381
382 default:
383 /* This case represents statements to be executed when an
384 exception occurs. Those statements are implicitly followed
385 by a RESX_EXPR to resume execution after the exception. So
386 in this case the TRY_CATCH never falls through. */
387 return false;
388 }
389 }
390
391 /* Try to determine if we can fall out of the bottom of BLOCK. This guess
392 need not be 100% accurate; simply be conservative and return true if we
393 don't know. This is used only to avoid stupidly generating extra code.
394 If we're wrong, we'll just delete the extra code later. */
395
396 bool
block_may_fallthru(tree block)397 block_may_fallthru (tree block)
398 {
399 tree stmt = expr_last (block);
400
401 switch (stmt ? TREE_CODE (stmt) : ERROR_MARK)
402 {
403 case GOTO_EXPR:
404 case RETURN_EXPR:
405 case RESX_EXPR:
406 /* Easy cases. If the last statement of the block implies
407 control transfer, then we can't fall through. */
408 return false;
409
410 case SWITCH_EXPR:
411 /* If SWITCH_LABELS is set, this is lowered, and represents a
412 branch to a selected label and hence can not fall through.
413 Otherwise SWITCH_BODY is set, and the switch can fall
414 through. */
415 return SWITCH_LABELS (stmt) == NULL_TREE;
416
417 case COND_EXPR:
418 if (block_may_fallthru (COND_EXPR_THEN (stmt)))
419 return true;
420 return block_may_fallthru (COND_EXPR_ELSE (stmt));
421
422 case BIND_EXPR:
423 return block_may_fallthru (BIND_EXPR_BODY (stmt));
424
425 case TRY_CATCH_EXPR:
426 return try_catch_may_fallthru (stmt);
427
428 case TRY_FINALLY_EXPR:
429 /* The finally clause is always executed after the try clause,
430 so if it does not fall through, then the try-finally will not
431 fall through. Otherwise, if the try clause does not fall
432 through, then when the finally clause falls through it will
433 resume execution wherever the try clause was going. So the
434 whole try-finally will only fall through if both the try
435 clause and the finally clause fall through. */
436 return (block_may_fallthru (TREE_OPERAND (stmt, 0))
437 && block_may_fallthru (TREE_OPERAND (stmt, 1)));
438
439 case MODIFY_EXPR:
440 if (TREE_CODE (TREE_OPERAND (stmt, 1)) == CALL_EXPR)
441 stmt = TREE_OPERAND (stmt, 1);
442 else
443 return true;
444 /* FALLTHRU */
445
446 case CALL_EXPR:
447 /* Functions that do not return do not fall through. */
448 return (call_expr_flags (stmt) & ECF_NORETURN) == 0;
449
450 case CLEANUP_POINT_EXPR:
451 return block_may_fallthru (TREE_OPERAND (stmt, 0));
452
453 default:
454 return true;
455 }
456 }
457
458 /* Lower a cond_expr TSI. DATA is passed through the recursion. */
459
460 static void
lower_cond_expr(tree_stmt_iterator * tsi,struct lower_data * data)461 lower_cond_expr (tree_stmt_iterator *tsi, struct lower_data *data)
462 {
463 tree stmt = tsi_stmt (*tsi);
464 bool then_is_goto, else_is_goto;
465 tree then_branch, else_branch;
466 tree then_goto, else_goto;
467
468 then_branch = COND_EXPR_THEN (stmt);
469 else_branch = COND_EXPR_ELSE (stmt);
470
471 lower_stmt_body (then_branch, data);
472 lower_stmt_body (else_branch, data);
473
474 then_goto = expr_only (then_branch);
475 then_is_goto = then_goto && simple_goto_p (then_goto);
476
477 else_goto = expr_only (else_branch);
478 else_is_goto = else_goto && simple_goto_p (else_goto);
479
480 if (!then_is_goto || !else_is_goto)
481 {
482 tree then_label, else_label, end_label, t;
483
484 then_label = NULL_TREE;
485 else_label = NULL_TREE;
486 end_label = NULL_TREE;
487
488 /* Replace the cond_expr with explicit gotos. */
489 if (!then_is_goto)
490 {
491 t = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
492 if (TREE_SIDE_EFFECTS (then_branch))
493 then_label = t;
494 else
495 end_label = t;
496 then_goto = build_and_jump (&LABEL_EXPR_LABEL (t));
497 }
498
499 if (!else_is_goto)
500 {
501 t = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
502 if (TREE_SIDE_EFFECTS (else_branch))
503 else_label = t;
504 else
505 {
506 /* Both THEN and ELSE can be no-ops if one or both contained an
507 empty BIND_EXPR that was associated with the toplevel block
508 of an inlined function. In that case remove_useless_stmts
509 can't have cleaned things up for us; kill the whole
510 conditional now. */
511 if (end_label)
512 {
513 tsi_delink (tsi);
514 return;
515 }
516 else
517 end_label = t;
518 }
519 else_goto = build_and_jump (&LABEL_EXPR_LABEL (t));
520 }
521
522 if (then_label)
523 {
524 bool may_fallthru = block_may_fallthru (then_branch);
525
526 tsi_link_after (tsi, then_label, TSI_CONTINUE_LINKING);
527 tsi_link_after (tsi, then_branch, TSI_CONTINUE_LINKING);
528
529 if (else_label && may_fallthru)
530 {
531 end_label = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
532 t = build_and_jump (&LABEL_EXPR_LABEL (end_label));
533 tsi_link_after (tsi, t, TSI_CONTINUE_LINKING);
534 }
535 }
536
537 if (else_label)
538 {
539 tsi_link_after (tsi, else_label, TSI_CONTINUE_LINKING);
540 tsi_link_after (tsi, else_branch, TSI_CONTINUE_LINKING);
541 }
542
543 if (end_label)
544 tsi_link_after (tsi, end_label, TSI_CONTINUE_LINKING);
545 }
546
547 COND_EXPR_THEN (stmt) = then_goto;
548 COND_EXPR_ELSE (stmt) = else_goto;
549
550 tsi_next (tsi);
551 }
552
553 /* Lower a return_expr TSI. DATA is passed through the recursion. */
554
555 static void
lower_return_expr(tree_stmt_iterator * tsi,struct lower_data * data)556 lower_return_expr (tree_stmt_iterator *tsi, struct lower_data *data)
557 {
558 tree stmt = tsi_stmt (*tsi);
559 tree value, t, label;
560
561 /* Extract the value being returned. */
562 value = TREE_OPERAND (stmt, 0);
563 if (value && TREE_CODE (value) == MODIFY_EXPR)
564 value = TREE_OPERAND (value, 1);
565
566 /* Match this up with an existing return statement that's been created. */
567 for (t = data->return_statements; t ; t = TREE_CHAIN (t))
568 {
569 tree tvalue = TREE_OPERAND (TREE_VALUE (t), 0);
570 if (tvalue && TREE_CODE (tvalue) == MODIFY_EXPR)
571 tvalue = TREE_OPERAND (tvalue, 1);
572
573 if (value == tvalue)
574 {
575 label = TREE_PURPOSE (t);
576 goto found;
577 }
578 }
579
580 /* Not found. Create a new label and record the return statement. */
581 label = create_artificial_label ();
582 data->return_statements = tree_cons (label, stmt, data->return_statements);
583
584 /* Generate a goto statement and remove the return statement. */
585 found:
586 t = build1 (GOTO_EXPR, void_type_node, label);
587 SET_EXPR_LOCUS (t, EXPR_LOCUS (stmt));
588 tsi_link_before (tsi, t, TSI_SAME_STMT);
589 tsi_delink (tsi);
590 }
591
592 /* Lower a __builtin_setjmp TSI.
593
594 __builtin_setjmp is passed a pointer to an array of five words (not
595 all will be used on all machines). It operates similarly to the C
596 library function of the same name, but is more efficient.
597
598 It is lowered into 3 other builtins, namely __builtin_setjmp_setup,
599 __builtin_setjmp_dispatcher and __builtin_setjmp_receiver, but with
600 __builtin_setjmp_dispatcher shared among all the instances; that's
601 why it is only emitted at the end by lower_function_body.
602
603 After full lowering, the body of the function should look like:
604
605 {
606 void * setjmpvar.0;
607 int D.1844;
608 int D.2844;
609
610 [...]
611
612 __builtin_setjmp_setup (&buf, &<D1847>);
613 D.1844 = 0;
614 goto <D1846>;
615 <D1847>:;
616 __builtin_setjmp_receiver (&<D1847>);
617 D.1844 = 1;
618 <D1846>:;
619 if (D.1844 == 0) goto <D1848>; else goto <D1849>;
620
621 [...]
622
623 __builtin_setjmp_setup (&buf, &<D2847>);
624 D.2844 = 0;
625 goto <D2846>;
626 <D2847>:;
627 __builtin_setjmp_receiver (&<D2847>);
628 D.2844 = 1;
629 <D2846>:;
630 if (D.2844 == 0) goto <D2848>; else goto <D2849>;
631
632 [...]
633
634 <D3850>:;
635 return;
636 <D3853>: [non-local];
637 setjmpvar.0 = __builtin_setjmp_dispatcher (&<D3853>);
638 goto setjmpvar.0;
639 }
640
641 The dispatcher block will be both the unique destination of all the
642 abnormal call edges and the unique source of all the abnormal edges
643 to the receivers, thus keeping the complexity explosion localized. */
644
645 static void
lower_builtin_setjmp(tree_stmt_iterator * tsi)646 lower_builtin_setjmp (tree_stmt_iterator *tsi)
647 {
648 tree stmt = tsi_stmt (*tsi);
649 tree cont_label = create_artificial_label ();
650 tree next_label = create_artificial_label ();
651 tree dest, t, arg;
652
653 /* NEXT_LABEL is the label __builtin_longjmp will jump to. Its address is
654 passed to both __builtin_setjmp_setup and __builtin_setjmp_receiver. */
655 FORCED_LABEL (next_label) = 1;
656
657 if (TREE_CODE (stmt) == MODIFY_EXPR)
658 {
659 dest = TREE_OPERAND (stmt, 0);
660 stmt = TREE_OPERAND (stmt, 1);
661 }
662 else
663 dest = NULL_TREE;
664
665 /* Build '__builtin_setjmp_setup (BUF, NEXT_LABEL)' and insert. */
666 t = build_addr (next_label, current_function_decl);
667 arg = tree_cons (NULL, t, NULL);
668 t = TREE_VALUE (TREE_OPERAND (stmt, 1));
669 arg = tree_cons (NULL, t, arg);
670 t = implicit_built_in_decls[BUILT_IN_SETJMP_SETUP];
671 t = build_function_call_expr (t, arg);
672 SET_EXPR_LOCUS (t, EXPR_LOCUS (stmt));
673 tsi_link_before (tsi, t, TSI_SAME_STMT);
674
675 /* Build 'DEST = 0' and insert. */
676 if (dest)
677 {
678 t = build2 (MODIFY_EXPR, void_type_node, dest, integer_zero_node);
679 SET_EXPR_LOCUS (t, EXPR_LOCUS (stmt));
680 tsi_link_before (tsi, t, TSI_SAME_STMT);
681 }
682
683 /* Build 'goto CONT_LABEL' and insert. */
684 t = build1 (GOTO_EXPR, void_type_node, cont_label);
685 tsi_link_before (tsi, t, TSI_SAME_STMT);
686
687 /* Build 'NEXT_LABEL:' and insert. */
688 t = build1 (LABEL_EXPR, void_type_node, next_label);
689 tsi_link_before (tsi, t, TSI_SAME_STMT);
690
691 /* Build '__builtin_setjmp_receiver (NEXT_LABEL)' and insert. */
692 t = build_addr (next_label, current_function_decl);
693 arg = tree_cons (NULL, t, NULL);
694 t = implicit_built_in_decls[BUILT_IN_SETJMP_RECEIVER];
695 t = build_function_call_expr (t, arg);
696 SET_EXPR_LOCUS (t, EXPR_LOCUS (stmt));
697 tsi_link_before (tsi, t, TSI_SAME_STMT);
698
699 /* Build 'DEST = 1' and insert. */
700 if (dest)
701 {
702 t = build2 (MODIFY_EXPR, void_type_node, dest, integer_one_node);
703 SET_EXPR_LOCUS (t, EXPR_LOCUS (stmt));
704 tsi_link_before (tsi, t, TSI_SAME_STMT);
705 }
706
707 /* Build 'CONT_LABEL:' and insert. */
708 t = build1 (LABEL_EXPR, void_type_node, cont_label);
709 tsi_link_before (tsi, t, TSI_SAME_STMT);
710
711 /* Remove the call to __builtin_setjmp. */
712 tsi_delink (tsi);
713 }
714
715
716 /* Record the variables in VARS into function FN. */
717
718 void
record_vars_into(tree vars,tree fn)719 record_vars_into (tree vars, tree fn)
720 {
721 struct function *saved_cfun = cfun;
722
723 if (fn != current_function_decl)
724 cfun = DECL_STRUCT_FUNCTION (fn);
725
726 for (; vars; vars = TREE_CHAIN (vars))
727 {
728 tree var = vars;
729
730 /* BIND_EXPRs contains also function/type/constant declarations
731 we don't need to care about. */
732 if (TREE_CODE (var) != VAR_DECL)
733 continue;
734
735 /* Nothing to do in this case. */
736 if (DECL_EXTERNAL (var))
737 continue;
738
739 /* Record the variable. */
740 cfun->unexpanded_var_list = tree_cons (NULL_TREE, var,
741 cfun->unexpanded_var_list);
742 }
743
744 if (fn != current_function_decl)
745 cfun = saved_cfun;
746 }
747
748
749 /* Record the variables in VARS into current_function_decl. */
750
751 void
record_vars(tree vars)752 record_vars (tree vars)
753 {
754 record_vars_into (vars, current_function_decl);
755 }
756
757
758 /* Mark BLOCK used if it has a used variable in it, then recurse over its
759 subblocks. */
760
761 static void
mark_blocks_with_used_vars(tree block)762 mark_blocks_with_used_vars (tree block)
763 {
764 tree var;
765 tree subblock;
766
767 if (!TREE_USED (block))
768 {
769 for (var = BLOCK_VARS (block);
770 var;
771 var = TREE_CHAIN (var))
772 {
773 if (TREE_USED (var))
774 {
775 TREE_USED (block) = true;
776 break;
777 }
778 }
779 }
780 for (subblock = BLOCK_SUBBLOCKS (block);
781 subblock;
782 subblock = BLOCK_CHAIN (subblock))
783 mark_blocks_with_used_vars (subblock);
784 }
785
786 /* Mark the used attribute on blocks correctly. */
787
788 static unsigned int
mark_used_blocks(void)789 mark_used_blocks (void)
790 {
791 mark_blocks_with_used_vars (DECL_INITIAL (current_function_decl));
792 return 0;
793 }
794
795
796 struct tree_opt_pass pass_mark_used_blocks =
797 {
798 "blocks", /* name */
799 NULL, /* gate */
800 mark_used_blocks, /* execute */
801 NULL, /* sub */
802 NULL, /* next */
803 0, /* static_pass_number */
804 0, /* tv_id */
805 0, /* properties_required */
806 0, /* properties_provided */
807 0, /* properties_destroyed */
808 0, /* todo_flags_start */
809 TODO_dump_func, /* todo_flags_finish */
810 0 /* letter */
811 };
812