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
*);
88 /* Lower the body of current_function_decl from High GIMPLE into Low
92 lower_function_body (void)
94 struct lower_data data
;
95 gimple_seq body
= gimple_body (current_function_decl
);
96 gimple_seq lowered_body
;
97 gimple_stmt_iterator i
;
101 /* The gimplifier should've left a body of exactly one statement,
102 namely a GIMPLE_BIND. */
103 gcc_assert (gimple_seq_first (body
) == gimple_seq_last (body
)
104 && gimple_code (gimple_seq_first_stmt (body
)) == GIMPLE_BIND
);
106 memset (&data
, 0, sizeof (data
));
107 data
.block
= DECL_INITIAL (current_function_decl
);
108 BLOCK_SUBBLOCKS (data
.block
) = NULL_TREE
;
109 BLOCK_CHAIN (data
.block
) = NULL_TREE
;
110 TREE_ASM_WRITTEN (data
.block
) = 1;
111 data
.return_statements
.create (8);
113 bind
= gimple_seq_first_stmt (body
);
115 gimple_seq_add_stmt (&lowered_body
, bind
);
116 i
= gsi_start (lowered_body
);
117 lower_gimple_bind (&i
, &data
);
119 i
= gsi_last (lowered_body
);
121 /* If the function falls off the end, we need a null return statement.
122 If we've already got one in the return_statements vector, we don't
123 need to do anything special. Otherwise build one by hand. */
124 if (gimple_seq_may_fallthru (lowered_body
)
125 && (data
.return_statements
.is_empty ()
126 || (gimple_return_retval (data
.return_statements
.last().stmt
)
129 x
= gimple_build_return (NULL
);
130 gimple_set_location (x
, cfun
->function_end_locus
);
131 gimple_set_block (x
, DECL_INITIAL (current_function_decl
));
132 gsi_insert_after (&i
, x
, GSI_CONTINUE_LINKING
);
135 /* If we lowered any return statements, emit the representative
136 at the end of the function. */
137 while (!data
.return_statements
.is_empty ())
139 return_statements_t t
= data
.return_statements
.pop ();
140 x
= gimple_build_label (t
.label
);
141 gsi_insert_after (&i
, x
, GSI_CONTINUE_LINKING
);
142 gsi_insert_after (&i
, t
.stmt
, GSI_CONTINUE_LINKING
);
145 /* Once the old body has been lowered, replace it with the new
147 gimple_set_body (current_function_decl
, lowered_body
);
149 gcc_assert (data
.block
== DECL_INITIAL (current_function_decl
));
150 BLOCK_SUBBLOCKS (data
.block
)
151 = blocks_nreverse (BLOCK_SUBBLOCKS (data
.block
));
153 clear_block_marks (data
.block
);
154 data
.return_statements
.release ();
160 const pass_data pass_data_lower_cf
=
162 GIMPLE_PASS
, /* type */
164 OPTGROUP_NONE
, /* optinfo_flags */
165 false, /* has_gate */
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 unsigned int execute () { 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
331 && DECL_FUNCTION_CODE (decl
) == BUILT_IN_SETJMP
)
333 lower_builtin_setjmp (gsi
);
334 data
->cannot_fallthru
= false;
338 if (decl
&& (flags_from_decl_or_type (decl
) & ECF_NORETURN
))
340 data
->cannot_fallthru
= true;
347 case GIMPLE_OMP_PARALLEL
:
348 case GIMPLE_OMP_TASK
:
349 case GIMPLE_OMP_TARGET
:
350 case GIMPLE_OMP_TEAMS
:
351 data
->cannot_fallthru
= false;
352 lower_omp_directive (gsi
, data
);
353 data
->cannot_fallthru
= false;
356 case GIMPLE_TRANSACTION
:
357 lower_sequence (gimple_transaction_body_ptr (stmt
), data
);
364 data
->cannot_fallthru
= false;
368 /* Lower a bind_expr TSI. DATA is passed through the recursion. */
371 lower_gimple_bind (gimple_stmt_iterator
*gsi
, struct lower_data
*data
)
373 tree old_block
= data
->block
;
374 gimple stmt
= gsi_stmt (*gsi
);
375 tree new_block
= gimple_bind_block (stmt
);
379 if (new_block
== old_block
)
381 /* The outermost block of the original function may not be the
382 outermost statement chain of the gimplified function. So we
383 may see the outermost block just inside the function. */
384 gcc_assert (new_block
== DECL_INITIAL (current_function_decl
));
389 /* We do not expect to handle duplicate blocks. */
390 gcc_assert (!TREE_ASM_WRITTEN (new_block
));
391 TREE_ASM_WRITTEN (new_block
) = 1;
393 /* Block tree may get clobbered by inlining. Normally this would
394 be fixed in rest_of_decl_compilation using block notes, but
395 since we are not going to emit them, it is up to us. */
396 BLOCK_CHAIN (new_block
) = BLOCK_SUBBLOCKS (old_block
);
397 BLOCK_SUBBLOCKS (old_block
) = new_block
;
398 BLOCK_SUBBLOCKS (new_block
) = NULL_TREE
;
399 BLOCK_SUPERCONTEXT (new_block
) = old_block
;
401 data
->block
= new_block
;
405 record_vars (gimple_bind_vars (stmt
));
406 lower_sequence (gimple_bind_body_ptr (stmt
), data
);
410 gcc_assert (data
->block
== new_block
);
412 BLOCK_SUBBLOCKS (new_block
)
413 = blocks_nreverse (BLOCK_SUBBLOCKS (new_block
));
414 data
->block
= old_block
;
417 /* The GIMPLE_BIND no longer carries any useful information -- kill it. */
418 gsi_insert_seq_before (gsi
, gimple_bind_body (stmt
), GSI_SAME_STMT
);
419 gsi_remove (gsi
, false);
422 /* Same as above, but for a GIMPLE_TRY_CATCH. */
425 lower_try_catch (gimple_stmt_iterator
*gsi
, struct lower_data
*data
)
427 bool cannot_fallthru
;
428 gimple stmt
= gsi_stmt (*gsi
);
429 gimple_stmt_iterator i
;
431 /* We don't handle GIMPLE_TRY_FINALLY. */
432 gcc_assert (gimple_try_kind (stmt
) == GIMPLE_TRY_CATCH
);
434 lower_sequence (gimple_try_eval_ptr (stmt
), data
);
435 cannot_fallthru
= data
->cannot_fallthru
;
437 i
= gsi_start (*gimple_try_cleanup_ptr (stmt
));
438 switch (gimple_code (gsi_stmt (i
)))
441 /* We expect to see a sequence of GIMPLE_CATCH stmts, each with a
442 catch expression and a body. The whole try/catch may fall
443 through iff any of the catch bodies falls through. */
444 for (; !gsi_end_p (i
); gsi_next (&i
))
446 data
->cannot_fallthru
= false;
447 lower_sequence (gimple_catch_handler_ptr (gsi_stmt (i
)), data
);
448 if (!data
->cannot_fallthru
)
449 cannot_fallthru
= false;
453 case GIMPLE_EH_FILTER
:
454 /* The exception filter expression only matters if there is an
455 exception. If the exception does not match EH_FILTER_TYPES,
456 we will execute EH_FILTER_FAILURE, and we will fall through
457 if that falls through. If the exception does match
458 EH_FILTER_TYPES, the stack unwinder will continue up the
459 stack, so we will not fall through. We don't know whether we
460 will throw an exception which matches EH_FILTER_TYPES or not,
461 so we just ignore EH_FILTER_TYPES and assume that we might
462 throw an exception which doesn't match. */
463 data
->cannot_fallthru
= false;
464 lower_sequence (gimple_eh_filter_failure_ptr (gsi_stmt (i
)), data
);
465 if (!data
->cannot_fallthru
)
466 cannot_fallthru
= false;
470 /* This case represents statements to be executed when an
471 exception occurs. Those statements are implicitly followed
472 by a GIMPLE_RESX to resume execution after the exception. So
473 in this case the try/catch never falls through. */
474 data
->cannot_fallthru
= false;
475 lower_sequence (gimple_try_cleanup_ptr (stmt
), data
);
479 data
->cannot_fallthru
= cannot_fallthru
;
484 /* Try to determine whether a TRY_CATCH expression can fall through.
485 This is a subroutine of gimple_stmt_may_fallthru. */
488 gimple_try_catch_may_fallthru (gimple stmt
)
490 gimple_stmt_iterator i
;
492 /* We don't handle GIMPLE_TRY_FINALLY. */
493 gcc_assert (gimple_try_kind (stmt
) == GIMPLE_TRY_CATCH
);
495 /* If the TRY block can fall through, the whole TRY_CATCH can
497 if (gimple_seq_may_fallthru (gimple_try_eval (stmt
)))
500 i
= gsi_start (*gimple_try_cleanup_ptr (stmt
));
501 switch (gimple_code (gsi_stmt (i
)))
504 /* We expect to see a sequence of GIMPLE_CATCH stmts, each with a
505 catch expression and a body. The whole try/catch may fall
506 through iff any of the catch bodies falls through. */
507 for (; !gsi_end_p (i
); gsi_next (&i
))
509 if (gimple_seq_may_fallthru (gimple_catch_handler (gsi_stmt (i
))))
514 case GIMPLE_EH_FILTER
:
515 /* The exception filter expression only matters if there is an
516 exception. If the exception does not match EH_FILTER_TYPES,
517 we will execute EH_FILTER_FAILURE, and we will fall through
518 if that falls through. If the exception does match
519 EH_FILTER_TYPES, the stack unwinder will continue up the
520 stack, so we will not fall through. We don't know whether we
521 will throw an exception which matches EH_FILTER_TYPES or not,
522 so we just ignore EH_FILTER_TYPES and assume that we might
523 throw an exception which doesn't match. */
524 return gimple_seq_may_fallthru (gimple_eh_filter_failure (gsi_stmt (i
)));
527 /* This case represents statements to be executed when an
528 exception occurs. Those statements are implicitly followed
529 by a GIMPLE_RESX to resume execution after the exception. So
530 in this case the try/catch never falls through. */
536 /* Try to determine if we can continue executing the statement
537 immediately following STMT. This guess need not be 100% accurate;
538 simply be conservative and return true if we don't know. This is
539 used only to avoid stupidly generating extra code. If we're wrong,
540 we'll just delete the extra code later. */
543 gimple_stmt_may_fallthru (gimple stmt
)
548 switch (gimple_code (stmt
))
553 /* Easy cases. If the last statement of the seq implies
554 control transfer, then we can't fall through. */
558 /* Switch has already been lowered and represents a branch
559 to a selected label and hence can't fall through. */
563 /* GIMPLE_COND's are already lowered into a two-way branch. They
564 can't fall through. */
568 return gimple_seq_may_fallthru (gimple_bind_body (stmt
));
571 if (gimple_try_kind (stmt
) == GIMPLE_TRY_CATCH
)
572 return gimple_try_catch_may_fallthru (stmt
);
574 /* It must be a GIMPLE_TRY_FINALLY. */
576 /* The finally clause is always executed after the try clause,
577 so if it does not fall through, then the try-finally will not
578 fall through. Otherwise, if the try clause does not fall
579 through, then when the finally clause falls through it will
580 resume execution wherever the try clause was going. So the
581 whole try-finally will only fall through if both the try
582 clause and the finally clause fall through. */
583 return (gimple_seq_may_fallthru (gimple_try_eval (stmt
))
584 && gimple_seq_may_fallthru (gimple_try_cleanup (stmt
)));
587 return (gimple_seq_may_fallthru (gimple_eh_else_n_body (stmt
))
588 || gimple_seq_may_fallthru (gimple_eh_else_e_body (stmt
)));
591 /* Functions that do not return do not fall through. */
592 return (gimple_call_flags (stmt
) & ECF_NORETURN
) == 0;
600 /* Same as gimple_stmt_may_fallthru, but for the gimple sequence SEQ. */
603 gimple_seq_may_fallthru (gimple_seq seq
)
605 return gimple_stmt_may_fallthru (gimple_seq_last_stmt (seq
));
609 /* Lower a GIMPLE_RETURN GSI. DATA is passed through the recursion. */
612 lower_gimple_return (gimple_stmt_iterator
*gsi
, struct lower_data
*data
)
614 gimple stmt
= gsi_stmt (*gsi
);
617 return_statements_t tmp_rs
;
619 /* Match this up with an existing return statement that's been created. */
620 for (i
= data
->return_statements
.length () - 1;
623 tmp_rs
= data
->return_statements
[i
];
625 if (gimple_return_retval (stmt
) == gimple_return_retval (tmp_rs
.stmt
))
627 /* Remove the line number from the representative return statement.
628 It now fills in for many such returns. Failure to remove this
629 will result in incorrect results for coverage analysis. */
630 gimple_set_location (tmp_rs
.stmt
, UNKNOWN_LOCATION
);
636 /* Not found. Create a new label and record the return statement. */
637 tmp_rs
.label
= create_artificial_label (cfun
->function_end_locus
);
639 data
->return_statements
.safe_push (tmp_rs
);
641 /* Generate a goto statement and remove the return statement. */
643 /* When not optimizing, make sure user returns are preserved. */
644 if (!optimize
&& gimple_has_location (stmt
))
645 DECL_ARTIFICIAL (tmp_rs
.label
) = 0;
646 t
= gimple_build_goto (tmp_rs
.label
);
647 gimple_set_location (t
, gimple_location (stmt
));
648 gimple_set_block (t
, gimple_block (stmt
));
649 gsi_insert_before (gsi
, t
, GSI_SAME_STMT
);
650 gsi_remove (gsi
, false);
653 /* Lower a __builtin_setjmp GSI.
655 __builtin_setjmp is passed a pointer to an array of five words (not
656 all will be used on all machines). It operates similarly to the C
657 library function of the same name, but is more efficient.
659 It is lowered into 2 other builtins, namely __builtin_setjmp_setup,
660 __builtin_setjmp_receiver.
662 After full lowering, the body of the function should look like:
670 __builtin_setjmp_setup (&buf, &<D1847>);
674 __builtin_setjmp_receiver (&<D1847>);
677 if (D.1844 == 0) goto <D1848>; else goto <D1849>;
681 __builtin_setjmp_setup (&buf, &<D2847>);
685 __builtin_setjmp_receiver (&<D2847>);
688 if (D.2844 == 0) goto <D2848>; else goto <D2849>;
696 During cfg creation an extra per-function (or per-OpenMP region)
697 block with ABNORMAL_DISPATCHER internal call will be added, unique
698 destination of all the abnormal call edges and the unique source of
699 all the abnormal edges to the receivers, thus keeping the complexity
700 explosion localized. */
703 lower_builtin_setjmp (gimple_stmt_iterator
*gsi
)
705 gimple stmt
= gsi_stmt (*gsi
);
706 location_t loc
= gimple_location (stmt
);
707 tree cont_label
= create_artificial_label (loc
);
708 tree next_label
= create_artificial_label (loc
);
712 /* NEXT_LABEL is the label __builtin_longjmp will jump to. Its address is
713 passed to both __builtin_setjmp_setup and __builtin_setjmp_receiver. */
714 FORCED_LABEL (next_label
) = 1;
716 dest
= gimple_call_lhs (stmt
);
718 /* Build '__builtin_setjmp_setup (BUF, NEXT_LABEL)' and insert. */
719 arg
= build_addr (next_label
, current_function_decl
);
720 t
= builtin_decl_implicit (BUILT_IN_SETJMP_SETUP
);
721 g
= gimple_build_call (t
, 2, gimple_call_arg (stmt
, 0), arg
);
722 gimple_set_location (g
, loc
);
723 gimple_set_block (g
, gimple_block (stmt
));
724 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
726 /* Build 'DEST = 0' and insert. */
729 g
= gimple_build_assign (dest
, build_zero_cst (TREE_TYPE (dest
)));
730 gimple_set_location (g
, loc
);
731 gimple_set_block (g
, gimple_block (stmt
));
732 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
735 /* Build 'goto CONT_LABEL' and insert. */
736 g
= gimple_build_goto (cont_label
);
737 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
739 /* Build 'NEXT_LABEL:' and insert. */
740 g
= gimple_build_label (next_label
);
741 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
743 /* Build '__builtin_setjmp_receiver (NEXT_LABEL)' and insert. */
744 arg
= build_addr (next_label
, current_function_decl
);
745 t
= builtin_decl_implicit (BUILT_IN_SETJMP_RECEIVER
);
746 g
= gimple_build_call (t
, 1, arg
);
747 gimple_set_location (g
, loc
);
748 gimple_set_block (g
, gimple_block (stmt
));
749 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
751 /* Build 'DEST = 1' and insert. */
754 g
= gimple_build_assign (dest
, fold_convert_loc (loc
, TREE_TYPE (dest
),
756 gimple_set_location (g
, loc
);
757 gimple_set_block (g
, gimple_block (stmt
));
758 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
761 /* Build 'CONT_LABEL:' and insert. */
762 g
= gimple_build_label (cont_label
);
763 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
765 /* Remove the call to __builtin_setjmp. */
766 gsi_remove (gsi
, false);
770 /* Record the variables in VARS into function FN. */
773 record_vars_into (tree vars
, tree fn
)
775 bool change_cfun
= fn
!= current_function_decl
;
778 push_cfun (DECL_STRUCT_FUNCTION (fn
));
780 for (; vars
; vars
= DECL_CHAIN (vars
))
784 /* BIND_EXPRs contains also function/type/constant declarations
785 we don't need to care about. */
786 if (TREE_CODE (var
) != VAR_DECL
)
789 /* Nothing to do in this case. */
790 if (DECL_EXTERNAL (var
))
793 /* Record the variable. */
794 add_local_decl (cfun
, var
);
802 /* Record the variables in VARS into current_function_decl. */
805 record_vars (tree vars
)
807 record_vars_into (vars
, current_function_decl
);