1 /* Data flow functions for trees.
2 Copyright (C) 2001-2013 Free Software Foundation, Inc.
3 Contributed by Diego Novillo <dnovillo@redhat.com>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License 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/>. */
23 #include "coretypes.h"
26 #include "pointer-set.h"
29 #include "basic-block.h"
31 #include "langhooks.h"
34 #include "tree-pretty-print.h"
36 #include "gimple-iterator.h"
37 #include "gimple-walk.h"
38 #include "gimple-ssa.h"
39 #include "tree-phinodes.h"
40 #include "ssa-iterators.h"
41 #include "tree-ssanames.h"
43 #include "tree-inline.h"
44 #include "tree-pass.h"
48 /* Build and maintain data flow information for trees. */
50 /* Counters used to display DFA and SSA statistics. */
57 size_t max_num_phi_args
;
63 /* Local functions. */
64 static void collect_dfa_stats (struct dfa_stats_d
*);
67 /*---------------------------------------------------------------------------
68 Dataflow analysis (DFA) routines
69 ---------------------------------------------------------------------------*/
71 /* Renumber all of the gimple stmt uids. */
74 renumber_gimple_stmt_uids (void)
78 set_gimple_stmt_max_uid (cfun
, 0);
81 gimple_stmt_iterator bsi
;
82 for (bsi
= gsi_start_phis (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
84 gimple stmt
= gsi_stmt (bsi
);
85 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
87 for (bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
89 gimple stmt
= gsi_stmt (bsi
);
90 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
95 /* Like renumber_gimple_stmt_uids, but only do work on the basic blocks
96 in BLOCKS, of which there are N_BLOCKS. Also renumbers PHIs. */
99 renumber_gimple_stmt_uids_in_blocks (basic_block
*blocks
, int n_blocks
)
103 set_gimple_stmt_max_uid (cfun
, 0);
104 for (i
= 0; i
< n_blocks
; i
++)
106 basic_block bb
= blocks
[i
];
107 gimple_stmt_iterator bsi
;
108 for (bsi
= gsi_start_phis (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
110 gimple stmt
= gsi_stmt (bsi
);
111 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
113 for (bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
115 gimple stmt
= gsi_stmt (bsi
);
116 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
123 /*---------------------------------------------------------------------------
125 ---------------------------------------------------------------------------*/
127 /* Dump variable VAR and its may-aliases to FILE. */
130 dump_variable (FILE *file
, tree var
)
132 if (TREE_CODE (var
) == SSA_NAME
)
134 if (POINTER_TYPE_P (TREE_TYPE (var
)))
135 dump_points_to_info_for (file
, var
);
136 var
= SSA_NAME_VAR (var
);
139 if (var
== NULL_TREE
)
141 fprintf (file
, "<nil>");
145 print_generic_expr (file
, var
, dump_flags
);
147 fprintf (file
, ", UID D.%u", (unsigned) DECL_UID (var
));
148 if (DECL_PT_UID (var
) != DECL_UID (var
))
149 fprintf (file
, ", PT-UID D.%u", (unsigned) DECL_PT_UID (var
));
151 fprintf (file
, ", ");
152 print_generic_expr (file
, TREE_TYPE (var
), dump_flags
);
154 if (TREE_ADDRESSABLE (var
))
155 fprintf (file
, ", is addressable");
157 if (is_global_var (var
))
158 fprintf (file
, ", is global");
160 if (TREE_THIS_VOLATILE (var
))
161 fprintf (file
, ", is volatile");
163 if (cfun
&& ssa_default_def (cfun
, var
))
165 fprintf (file
, ", default def: ");
166 print_generic_expr (file
, ssa_default_def (cfun
, var
), dump_flags
);
169 if (DECL_INITIAL (var
))
171 fprintf (file
, ", initial: ");
172 print_generic_expr (file
, DECL_INITIAL (var
), dump_flags
);
175 fprintf (file
, "\n");
179 /* Dump variable VAR and its may-aliases to stderr. */
182 debug_variable (tree var
)
184 dump_variable (stderr
, var
);
188 /* Dump various DFA statistics to FILE. */
191 dump_dfa_stats (FILE *file
)
193 struct dfa_stats_d dfa_stats
;
195 unsigned long size
, total
= 0;
196 const char * const fmt_str
= "%-30s%-13s%12s\n";
197 const char * const fmt_str_1
= "%-30s%13lu%11lu%c\n";
198 const char * const fmt_str_3
= "%-43s%11lu%c\n";
200 = lang_hooks
.decl_printable_name (current_function_decl
, 2);
202 collect_dfa_stats (&dfa_stats
);
204 fprintf (file
, "\nDFA Statistics for %s\n\n", funcname
);
206 fprintf (file
, "---------------------------------------------------------\n");
207 fprintf (file
, fmt_str
, "", " Number of ", "Memory");
208 fprintf (file
, fmt_str
, "", " instances ", "used ");
209 fprintf (file
, "---------------------------------------------------------\n");
211 size
= dfa_stats
.num_uses
* sizeof (tree
*);
213 fprintf (file
, fmt_str_1
, "USE operands", dfa_stats
.num_uses
,
214 SCALE (size
), LABEL (size
));
216 size
= dfa_stats
.num_defs
* sizeof (tree
*);
218 fprintf (file
, fmt_str_1
, "DEF operands", dfa_stats
.num_defs
,
219 SCALE (size
), LABEL (size
));
221 size
= dfa_stats
.num_vuses
* sizeof (tree
*);
223 fprintf (file
, fmt_str_1
, "VUSE operands", dfa_stats
.num_vuses
,
224 SCALE (size
), LABEL (size
));
226 size
= dfa_stats
.num_vdefs
* sizeof (tree
*);
228 fprintf (file
, fmt_str_1
, "VDEF operands", dfa_stats
.num_vdefs
,
229 SCALE (size
), LABEL (size
));
231 size
= dfa_stats
.num_phis
* sizeof (struct gimple_statement_phi
);
233 fprintf (file
, fmt_str_1
, "PHI nodes", dfa_stats
.num_phis
,
234 SCALE (size
), LABEL (size
));
236 size
= dfa_stats
.num_phi_args
* sizeof (struct phi_arg_d
);
238 fprintf (file
, fmt_str_1
, "PHI arguments", dfa_stats
.num_phi_args
,
239 SCALE (size
), LABEL (size
));
241 fprintf (file
, "---------------------------------------------------------\n");
242 fprintf (file
, fmt_str_3
, "Total memory used by DFA/SSA data", SCALE (total
),
244 fprintf (file
, "---------------------------------------------------------\n");
245 fprintf (file
, "\n");
247 if (dfa_stats
.num_phis
)
248 fprintf (file
, "Average number of arguments per PHI node: %.1f (max: %ld)\n",
249 (float) dfa_stats
.num_phi_args
/ (float) dfa_stats
.num_phis
,
250 (long) dfa_stats
.max_num_phi_args
);
252 fprintf (file
, "\n");
256 /* Dump DFA statistics on stderr. */
259 debug_dfa_stats (void)
261 dump_dfa_stats (stderr
);
265 /* Collect DFA statistics and store them in the structure pointed to by
269 collect_dfa_stats (struct dfa_stats_d
*dfa_stats_p ATTRIBUTE_UNUSED
)
273 gcc_assert (dfa_stats_p
);
275 memset ((void *)dfa_stats_p
, 0, sizeof (struct dfa_stats_d
));
277 /* Walk all the statements in the function counting references. */
280 gimple_stmt_iterator si
;
282 for (si
= gsi_start_phis (bb
); !gsi_end_p (si
); gsi_next (&si
))
284 gimple phi
= gsi_stmt (si
);
285 dfa_stats_p
->num_phis
++;
286 dfa_stats_p
->num_phi_args
+= gimple_phi_num_args (phi
);
287 if (gimple_phi_num_args (phi
) > dfa_stats_p
->max_num_phi_args
)
288 dfa_stats_p
->max_num_phi_args
= gimple_phi_num_args (phi
);
291 for (si
= gsi_start_bb (bb
); !gsi_end_p (si
); gsi_next (&si
))
293 gimple stmt
= gsi_stmt (si
);
294 dfa_stats_p
->num_defs
+= NUM_SSA_OPERANDS (stmt
, SSA_OP_DEF
);
295 dfa_stats_p
->num_uses
+= NUM_SSA_OPERANDS (stmt
, SSA_OP_USE
);
296 dfa_stats_p
->num_vdefs
+= gimple_vdef (stmt
) ? 1 : 0;
297 dfa_stats_p
->num_vuses
+= gimple_vuse (stmt
) ? 1 : 0;
303 /*---------------------------------------------------------------------------
304 Miscellaneous helpers
305 ---------------------------------------------------------------------------*/
307 /* Lookup VAR UID in the default_defs hashtable and return the associated
311 ssa_default_def (struct function
*fn
, tree var
)
313 struct tree_decl_minimal ind
;
314 struct tree_ssa_name in
;
315 gcc_assert (TREE_CODE (var
) == VAR_DECL
316 || TREE_CODE (var
) == PARM_DECL
317 || TREE_CODE (var
) == RESULT_DECL
);
319 ind
.uid
= DECL_UID (var
);
320 return (tree
) htab_find_with_hash (DEFAULT_DEFS (fn
), &in
, DECL_UID (var
));
323 /* Insert the pair VAR's UID, DEF into the default_defs hashtable
327 set_ssa_default_def (struct function
*fn
, tree var
, tree def
)
329 struct tree_decl_minimal ind
;
330 struct tree_ssa_name in
;
333 gcc_assert (TREE_CODE (var
) == VAR_DECL
334 || TREE_CODE (var
) == PARM_DECL
335 || TREE_CODE (var
) == RESULT_DECL
);
337 ind
.uid
= DECL_UID (var
);
340 loc
= htab_find_slot_with_hash (DEFAULT_DEFS (fn
), &in
,
341 DECL_UID (var
), NO_INSERT
);
344 SSA_NAME_IS_DEFAULT_DEF (*(tree
*)loc
) = false;
345 htab_clear_slot (DEFAULT_DEFS (fn
), loc
);
349 gcc_assert (TREE_CODE (def
) == SSA_NAME
&& SSA_NAME_VAR (def
) == var
);
350 loc
= htab_find_slot_with_hash (DEFAULT_DEFS (fn
), &in
,
351 DECL_UID (var
), INSERT
);
353 /* Default definition might be changed by tail call optimization. */
355 SSA_NAME_IS_DEFAULT_DEF (*(tree
*) loc
) = false;
357 /* Mark DEF as the default definition for VAR. */
359 SSA_NAME_IS_DEFAULT_DEF (def
) = true;
362 /* Retrieve or create a default definition for VAR. */
365 get_or_create_ssa_default_def (struct function
*fn
, tree var
)
367 tree ddef
= ssa_default_def (fn
, var
);
368 if (ddef
== NULL_TREE
)
370 ddef
= make_ssa_name_fn (fn
, var
, gimple_build_nop ());
371 set_ssa_default_def (fn
, var
, ddef
);
377 /* If EXP is a handled component reference for a structure, return the
378 base variable. The access range is delimited by bit positions *POFFSET and
379 *POFFSET + *PMAX_SIZE. The access size is *PSIZE bits. If either
380 *PSIZE or *PMAX_SIZE is -1, they could not be determined. If *PSIZE
381 and *PMAX_SIZE are equal, the access is non-variable. */
384 get_ref_base_and_extent (tree exp
, HOST_WIDE_INT
*poffset
,
385 HOST_WIDE_INT
*psize
,
386 HOST_WIDE_INT
*pmax_size
)
388 HOST_WIDE_INT bitsize
= -1;
389 HOST_WIDE_INT maxsize
= -1;
390 tree size_tree
= NULL_TREE
;
391 double_int bit_offset
= double_int_zero
;
392 HOST_WIDE_INT hbit_offset
;
393 bool seen_variable_array_ref
= false;
395 /* First get the final access size from just the outermost expression. */
396 if (TREE_CODE (exp
) == COMPONENT_REF
)
397 size_tree
= DECL_SIZE (TREE_OPERAND (exp
, 1));
398 else if (TREE_CODE (exp
) == BIT_FIELD_REF
)
399 size_tree
= TREE_OPERAND (exp
, 1);
400 else if (!VOID_TYPE_P (TREE_TYPE (exp
)))
402 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (exp
));
404 size_tree
= TYPE_SIZE (TREE_TYPE (exp
));
406 bitsize
= GET_MODE_BITSIZE (mode
);
408 if (size_tree
!= NULL_TREE
)
410 if (! tree_fits_uhwi_p (size_tree
))
413 bitsize
= TREE_INT_CST_LOW (size_tree
);
416 /* Initially, maxsize is the same as the accessed element size.
417 In the following it will only grow (or become -1). */
420 /* Compute cumulative bit-offset for nested component-refs and array-refs,
421 and find the ultimate containing object. */
424 switch (TREE_CODE (exp
))
427 bit_offset
+= tree_to_double_int (TREE_OPERAND (exp
, 2));
432 tree field
= TREE_OPERAND (exp
, 1);
433 tree this_offset
= component_ref_field_offset (exp
);
435 if (this_offset
&& TREE_CODE (this_offset
) == INTEGER_CST
)
437 double_int doffset
= tree_to_double_int (this_offset
);
438 doffset
= doffset
.lshift (BITS_PER_UNIT
== 8
439 ? 3 : exact_log2 (BITS_PER_UNIT
));
440 doffset
+= tree_to_double_int (DECL_FIELD_BIT_OFFSET (field
));
441 bit_offset
= bit_offset
+ doffset
;
443 /* If we had seen a variable array ref already and we just
444 referenced the last field of a struct or a union member
445 then we have to adjust maxsize by the padding at the end
447 if (seen_variable_array_ref
&& maxsize
!= -1)
449 tree stype
= TREE_TYPE (TREE_OPERAND (exp
, 0));
450 tree next
= DECL_CHAIN (field
);
451 while (next
&& TREE_CODE (next
) != FIELD_DECL
)
452 next
= DECL_CHAIN (next
);
454 || TREE_CODE (stype
) != RECORD_TYPE
)
456 tree fsize
= DECL_SIZE_UNIT (field
);
457 tree ssize
= TYPE_SIZE_UNIT (stype
);
458 if (tree_fits_shwi_p (fsize
)
459 && tree_fits_shwi_p (ssize
)
460 && doffset
.fits_shwi ())
461 maxsize
+= ((TREE_INT_CST_LOW (ssize
)
462 - TREE_INT_CST_LOW (fsize
))
464 - doffset
.to_shwi ());
472 tree csize
= TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
473 /* We need to adjust maxsize to the whole structure bitsize.
474 But we can subtract any constant offset seen so far,
475 because that would get us out of the structure otherwise. */
478 && tree_fits_uhwi_p (csize
)
479 && bit_offset
.fits_shwi ())
480 maxsize
= TREE_INT_CST_LOW (csize
)
481 - bit_offset
.to_shwi ();
489 case ARRAY_RANGE_REF
:
491 tree index
= TREE_OPERAND (exp
, 1);
492 tree low_bound
, unit_size
;
494 /* If the resulting bit-offset is constant, track it. */
495 if (TREE_CODE (index
) == INTEGER_CST
496 && (low_bound
= array_ref_low_bound (exp
),
497 TREE_CODE (low_bound
) == INTEGER_CST
)
498 && (unit_size
= array_ref_element_size (exp
),
499 TREE_CODE (unit_size
) == INTEGER_CST
))
502 = (TREE_INT_CST (index
) - TREE_INT_CST (low_bound
))
503 .sext (TYPE_PRECISION (TREE_TYPE (index
)));
504 doffset
*= tree_to_double_int (unit_size
);
505 doffset
= doffset
.lshift (BITS_PER_UNIT
== 8
506 ? 3 : exact_log2 (BITS_PER_UNIT
));
507 bit_offset
= bit_offset
+ doffset
;
509 /* An array ref with a constant index up in the structure
510 hierarchy will constrain the size of any variable array ref
511 lower in the access hierarchy. */
512 seen_variable_array_ref
= false;
516 tree asize
= TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
517 /* We need to adjust maxsize to the whole array bitsize.
518 But we can subtract any constant offset seen so far,
519 because that would get us outside of the array otherwise. */
522 && tree_fits_uhwi_p (asize
)
523 && bit_offset
.fits_shwi ())
524 maxsize
= TREE_INT_CST_LOW (asize
)
525 - bit_offset
.to_shwi ();
529 /* Remember that we have seen an array ref with a variable
531 seen_variable_array_ref
= true;
540 bit_offset
+= double_int::from_uhwi (bitsize
);
543 case VIEW_CONVERT_EXPR
:
547 /* Via the variable index or index2 we can reach the
548 whole object. Still hand back the decl here. */
549 if (TREE_CODE (TMR_BASE (exp
)) == ADDR_EXPR
550 && (TMR_INDEX (exp
) || TMR_INDEX2 (exp
)))
552 exp
= TREE_OPERAND (TMR_BASE (exp
), 0);
553 bit_offset
= double_int_zero
;
559 /* We need to deal with variable arrays ending structures such as
560 struct { int length; int a[1]; } x; x.a[d]
561 struct { struct { int a; int b; } a[1]; } x; x.a[d].a
562 struct { struct { int a[1]; } a[1]; } x; x.a[0][d], x.a[d][0]
563 struct { int len; union { int a[1]; struct X x; } u; } x; x.u.a[d]
564 where we do not know maxsize for variable index accesses to
565 the array. The simplest way to conservatively deal with this
566 is to punt in the case that offset + maxsize reaches the
567 base type boundary. This needs to include possible trailing
568 padding that is there for alignment purposes. */
569 if (seen_variable_array_ref
571 && (!bit_offset
.fits_shwi ()
572 || !tree_fits_uhwi_p (TYPE_SIZE (TREE_TYPE (exp
)))
573 || (bit_offset
.to_shwi () + maxsize
574 == (HOST_WIDE_INT
) TREE_INT_CST_LOW
575 (TYPE_SIZE (TREE_TYPE (exp
))))))
578 /* Hand back the decl for MEM[&decl, off]. */
579 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == ADDR_EXPR
)
581 if (integer_zerop (TREE_OPERAND (exp
, 1)))
582 exp
= TREE_OPERAND (TREE_OPERAND (exp
, 0), 0);
585 double_int off
= mem_ref_offset (exp
);
586 off
= off
.lshift (BITS_PER_UNIT
== 8
587 ? 3 : exact_log2 (BITS_PER_UNIT
));
589 if (off
.fits_shwi ())
592 exp
= TREE_OPERAND (TREE_OPERAND (exp
, 0), 0);
602 exp
= TREE_OPERAND (exp
, 0);
605 /* We need to deal with variable arrays ending structures. */
606 if (seen_variable_array_ref
608 && (!bit_offset
.fits_shwi ()
609 || !tree_fits_uhwi_p (TYPE_SIZE (TREE_TYPE (exp
)))
610 || (bit_offset
.to_shwi () + maxsize
611 == (HOST_WIDE_INT
) TREE_INT_CST_LOW
612 (TYPE_SIZE (TREE_TYPE (exp
))))))
616 if (!bit_offset
.fits_shwi ())
625 hbit_offset
= bit_offset
.to_shwi ();
627 /* In case of a decl or constant base object we can do better. */
631 /* If maxsize is unknown adjust it according to the size of the
634 && tree_fits_uhwi_p (DECL_SIZE (exp
)))
635 maxsize
= TREE_INT_CST_LOW (DECL_SIZE (exp
)) - hbit_offset
;
637 else if (CONSTANT_CLASS_P (exp
))
639 /* If maxsize is unknown adjust it according to the size of the
640 base type constant. */
642 && tree_fits_uhwi_p (TYPE_SIZE (TREE_TYPE (exp
))))
643 maxsize
= TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (exp
))) - hbit_offset
;
646 /* ??? Due to negative offsets in ARRAY_REF we can end up with
647 negative bit_offset here. We might want to store a zero offset
649 *poffset
= hbit_offset
;
651 *pmax_size
= maxsize
;
656 /* Returns the base object and a constant BITS_PER_UNIT offset in *POFFSET that
657 denotes the starting address of the memory access EXP.
658 Returns NULL_TREE if the offset is not constant or any component
659 is not BITS_PER_UNIT-aligned. */
662 get_addr_base_and_unit_offset (tree exp
, HOST_WIDE_INT
*poffset
)
664 return get_addr_base_and_unit_offset_1 (exp
, poffset
, NULL
);
667 /* Returns true if STMT references an SSA_NAME that has
668 SSA_NAME_OCCURS_IN_ABNORMAL_PHI set, otherwise false. */
671 stmt_references_abnormal_ssa_name (gimple stmt
)
676 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, oi
, SSA_OP_USE
)
678 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (USE_FROM_PTR (use_p
)))
685 /* Pair of tree and a sorting index, for dump_enumerated_decls. */
686 struct GTY(()) numbered_tree_d
691 typedef struct numbered_tree_d numbered_tree
;
694 /* Compare two declarations references by their DECL_UID / sequence number.
698 compare_decls_by_uid (const void *pa
, const void *pb
)
700 const numbered_tree
*nt_a
= ((const numbered_tree
*)pa
);
701 const numbered_tree
*nt_b
= ((const numbered_tree
*)pb
);
703 if (DECL_UID (nt_a
->t
) != DECL_UID (nt_b
->t
))
704 return DECL_UID (nt_a
->t
) - DECL_UID (nt_b
->t
);
705 return nt_a
->num
- nt_b
->num
;
708 /* Called via walk_gimple_stmt / walk_gimple_op by dump_enumerated_decls. */
710 dump_enumerated_decls_push (tree
*tp
, int *walk_subtrees
, void *data
)
712 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
713 vec
<numbered_tree
> *list
= (vec
<numbered_tree
> *) wi
->info
;
719 nt
.num
= list
->length ();
720 list
->safe_push (nt
);
725 /* Find all the declarations used by the current function, sort them by uid,
726 and emit the sorted list. Each declaration is tagged with a sequence
727 number indicating when it was found during statement / tree walking,
728 so that TDF_NOUID comparisons of anonymous declarations are still
729 meaningful. Where a declaration was encountered more than once, we
730 emit only the sequence number of the first encounter.
731 FILE is the dump file where to output the list and FLAGS is as in
732 print_generic_expr. */
734 dump_enumerated_decls (FILE *file
, int flags
)
737 struct walk_stmt_info wi
;
738 stack_vec
<numbered_tree
, 40> decl_list
;
740 memset (&wi
, '\0', sizeof (wi
));
741 wi
.info
= (void *) &decl_list
;
744 gimple_stmt_iterator gsi
;
746 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
747 if (!is_gimple_debug (gsi_stmt (gsi
)))
748 walk_gimple_stmt (&gsi
, NULL
, dump_enumerated_decls_push
, &wi
);
750 decl_list
.qsort (compare_decls_by_uid
);
751 if (decl_list
.length ())
755 tree last
= NULL_TREE
;
757 fprintf (file
, "Declarations used by %s, sorted by DECL_UID:\n",
758 current_function_name ());
759 FOR_EACH_VEC_ELT (decl_list
, ix
, ntp
)
763 fprintf (file
, "%d: ", ntp
->num
);
764 print_generic_decl (file
, ntp
->t
, flags
);
765 fprintf (file
, "\n");