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-ssa.h"
37 #include "tree-phinodes.h"
38 #include "ssa-iterators.h"
39 #include "tree-ssanames.h"
41 #include "tree-inline.h"
42 #include "tree-pass.h"
46 /* Build and maintain data flow information for trees. */
48 /* Counters used to display DFA and SSA statistics. */
55 size_t max_num_phi_args
;
61 /* Local functions. */
62 static void collect_dfa_stats (struct dfa_stats_d
*);
65 /*---------------------------------------------------------------------------
66 Dataflow analysis (DFA) routines
67 ---------------------------------------------------------------------------*/
69 /* Renumber all of the gimple stmt uids. */
72 renumber_gimple_stmt_uids (void)
76 set_gimple_stmt_max_uid (cfun
, 0);
79 gimple_stmt_iterator bsi
;
80 for (bsi
= gsi_start_phis (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
82 gimple stmt
= gsi_stmt (bsi
);
83 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
85 for (bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
87 gimple stmt
= gsi_stmt (bsi
);
88 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
93 /* Like renumber_gimple_stmt_uids, but only do work on the basic blocks
94 in BLOCKS, of which there are N_BLOCKS. Also renumbers PHIs. */
97 renumber_gimple_stmt_uids_in_blocks (basic_block
*blocks
, int n_blocks
)
101 set_gimple_stmt_max_uid (cfun
, 0);
102 for (i
= 0; i
< n_blocks
; i
++)
104 basic_block bb
= blocks
[i
];
105 gimple_stmt_iterator bsi
;
106 for (bsi
= gsi_start_phis (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
108 gimple stmt
= gsi_stmt (bsi
);
109 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
111 for (bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
113 gimple stmt
= gsi_stmt (bsi
);
114 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
121 /*---------------------------------------------------------------------------
123 ---------------------------------------------------------------------------*/
125 /* Dump variable VAR and its may-aliases to FILE. */
128 dump_variable (FILE *file
, tree var
)
130 if (TREE_CODE (var
) == SSA_NAME
)
132 if (POINTER_TYPE_P (TREE_TYPE (var
)))
133 dump_points_to_info_for (file
, var
);
134 var
= SSA_NAME_VAR (var
);
137 if (var
== NULL_TREE
)
139 fprintf (file
, "<nil>");
143 print_generic_expr (file
, var
, dump_flags
);
145 fprintf (file
, ", UID D.%u", (unsigned) DECL_UID (var
));
146 if (DECL_PT_UID (var
) != DECL_UID (var
))
147 fprintf (file
, ", PT-UID D.%u", (unsigned) DECL_PT_UID (var
));
149 fprintf (file
, ", ");
150 print_generic_expr (file
, TREE_TYPE (var
), dump_flags
);
152 if (TREE_ADDRESSABLE (var
))
153 fprintf (file
, ", is addressable");
155 if (is_global_var (var
))
156 fprintf (file
, ", is global");
158 if (TREE_THIS_VOLATILE (var
))
159 fprintf (file
, ", is volatile");
161 if (cfun
&& ssa_default_def (cfun
, var
))
163 fprintf (file
, ", default def: ");
164 print_generic_expr (file
, ssa_default_def (cfun
, var
), dump_flags
);
167 if (DECL_INITIAL (var
))
169 fprintf (file
, ", initial: ");
170 print_generic_expr (file
, DECL_INITIAL (var
), dump_flags
);
173 fprintf (file
, "\n");
177 /* Dump variable VAR and its may-aliases to stderr. */
180 debug_variable (tree var
)
182 dump_variable (stderr
, var
);
186 /* Dump various DFA statistics to FILE. */
189 dump_dfa_stats (FILE *file
)
191 struct dfa_stats_d dfa_stats
;
193 unsigned long size
, total
= 0;
194 const char * const fmt_str
= "%-30s%-13s%12s\n";
195 const char * const fmt_str_1
= "%-30s%13lu%11lu%c\n";
196 const char * const fmt_str_3
= "%-43s%11lu%c\n";
198 = lang_hooks
.decl_printable_name (current_function_decl
, 2);
200 collect_dfa_stats (&dfa_stats
);
202 fprintf (file
, "\nDFA Statistics for %s\n\n", funcname
);
204 fprintf (file
, "---------------------------------------------------------\n");
205 fprintf (file
, fmt_str
, "", " Number of ", "Memory");
206 fprintf (file
, fmt_str
, "", " instances ", "used ");
207 fprintf (file
, "---------------------------------------------------------\n");
209 size
= dfa_stats
.num_uses
* sizeof (tree
*);
211 fprintf (file
, fmt_str_1
, "USE operands", dfa_stats
.num_uses
,
212 SCALE (size
), LABEL (size
));
214 size
= dfa_stats
.num_defs
* sizeof (tree
*);
216 fprintf (file
, fmt_str_1
, "DEF operands", dfa_stats
.num_defs
,
217 SCALE (size
), LABEL (size
));
219 size
= dfa_stats
.num_vuses
* sizeof (tree
*);
221 fprintf (file
, fmt_str_1
, "VUSE operands", dfa_stats
.num_vuses
,
222 SCALE (size
), LABEL (size
));
224 size
= dfa_stats
.num_vdefs
* sizeof (tree
*);
226 fprintf (file
, fmt_str_1
, "VDEF operands", dfa_stats
.num_vdefs
,
227 SCALE (size
), LABEL (size
));
229 size
= dfa_stats
.num_phis
* sizeof (struct gimple_statement_phi
);
231 fprintf (file
, fmt_str_1
, "PHI nodes", dfa_stats
.num_phis
,
232 SCALE (size
), LABEL (size
));
234 size
= dfa_stats
.num_phi_args
* sizeof (struct phi_arg_d
);
236 fprintf (file
, fmt_str_1
, "PHI arguments", dfa_stats
.num_phi_args
,
237 SCALE (size
), LABEL (size
));
239 fprintf (file
, "---------------------------------------------------------\n");
240 fprintf (file
, fmt_str_3
, "Total memory used by DFA/SSA data", SCALE (total
),
242 fprintf (file
, "---------------------------------------------------------\n");
243 fprintf (file
, "\n");
245 if (dfa_stats
.num_phis
)
246 fprintf (file
, "Average number of arguments per PHI node: %.1f (max: %ld)\n",
247 (float) dfa_stats
.num_phi_args
/ (float) dfa_stats
.num_phis
,
248 (long) dfa_stats
.max_num_phi_args
);
250 fprintf (file
, "\n");
254 /* Dump DFA statistics on stderr. */
257 debug_dfa_stats (void)
259 dump_dfa_stats (stderr
);
263 /* Collect DFA statistics and store them in the structure pointed to by
267 collect_dfa_stats (struct dfa_stats_d
*dfa_stats_p ATTRIBUTE_UNUSED
)
271 gcc_assert (dfa_stats_p
);
273 memset ((void *)dfa_stats_p
, 0, sizeof (struct dfa_stats_d
));
275 /* Walk all the statements in the function counting references. */
278 gimple_stmt_iterator si
;
280 for (si
= gsi_start_phis (bb
); !gsi_end_p (si
); gsi_next (&si
))
282 gimple phi
= gsi_stmt (si
);
283 dfa_stats_p
->num_phis
++;
284 dfa_stats_p
->num_phi_args
+= gimple_phi_num_args (phi
);
285 if (gimple_phi_num_args (phi
) > dfa_stats_p
->max_num_phi_args
)
286 dfa_stats_p
->max_num_phi_args
= gimple_phi_num_args (phi
);
289 for (si
= gsi_start_bb (bb
); !gsi_end_p (si
); gsi_next (&si
))
291 gimple stmt
= gsi_stmt (si
);
292 dfa_stats_p
->num_defs
+= NUM_SSA_OPERANDS (stmt
, SSA_OP_DEF
);
293 dfa_stats_p
->num_uses
+= NUM_SSA_OPERANDS (stmt
, SSA_OP_USE
);
294 dfa_stats_p
->num_vdefs
+= gimple_vdef (stmt
) ? 1 : 0;
295 dfa_stats_p
->num_vuses
+= gimple_vuse (stmt
) ? 1 : 0;
301 /*---------------------------------------------------------------------------
302 Miscellaneous helpers
303 ---------------------------------------------------------------------------*/
305 /* Lookup VAR UID in the default_defs hashtable and return the associated
309 ssa_default_def (struct function
*fn
, tree var
)
311 struct tree_decl_minimal ind
;
312 struct tree_ssa_name in
;
313 gcc_assert (TREE_CODE (var
) == VAR_DECL
314 || TREE_CODE (var
) == PARM_DECL
315 || TREE_CODE (var
) == RESULT_DECL
);
317 ind
.uid
= DECL_UID (var
);
318 return (tree
) htab_find_with_hash (DEFAULT_DEFS (fn
), &in
, DECL_UID (var
));
321 /* Insert the pair VAR's UID, DEF into the default_defs hashtable
325 set_ssa_default_def (struct function
*fn
, tree var
, tree def
)
327 struct tree_decl_minimal ind
;
328 struct tree_ssa_name in
;
331 gcc_assert (TREE_CODE (var
) == VAR_DECL
332 || TREE_CODE (var
) == PARM_DECL
333 || TREE_CODE (var
) == RESULT_DECL
);
335 ind
.uid
= DECL_UID (var
);
338 loc
= htab_find_slot_with_hash (DEFAULT_DEFS (fn
), &in
,
339 DECL_UID (var
), NO_INSERT
);
342 SSA_NAME_IS_DEFAULT_DEF (*(tree
*)loc
) = false;
343 htab_clear_slot (DEFAULT_DEFS (fn
), loc
);
347 gcc_assert (TREE_CODE (def
) == SSA_NAME
&& SSA_NAME_VAR (def
) == var
);
348 loc
= htab_find_slot_with_hash (DEFAULT_DEFS (fn
), &in
,
349 DECL_UID (var
), INSERT
);
351 /* Default definition might be changed by tail call optimization. */
353 SSA_NAME_IS_DEFAULT_DEF (*(tree
*) loc
) = false;
355 /* Mark DEF as the default definition for VAR. */
357 SSA_NAME_IS_DEFAULT_DEF (def
) = true;
360 /* Retrieve or create a default definition for VAR. */
363 get_or_create_ssa_default_def (struct function
*fn
, tree var
)
365 tree ddef
= ssa_default_def (fn
, var
);
366 if (ddef
== NULL_TREE
)
368 ddef
= make_ssa_name_fn (fn
, var
, gimple_build_nop ());
369 set_ssa_default_def (fn
, var
, ddef
);
375 /* If EXP is a handled component reference for a structure, return the
376 base variable. The access range is delimited by bit positions *POFFSET and
377 *POFFSET + *PMAX_SIZE. The access size is *PSIZE bits. If either
378 *PSIZE or *PMAX_SIZE is -1, they could not be determined. If *PSIZE
379 and *PMAX_SIZE are equal, the access is non-variable. */
382 get_ref_base_and_extent (tree exp
, HOST_WIDE_INT
*poffset
,
383 HOST_WIDE_INT
*psize
,
384 HOST_WIDE_INT
*pmax_size
)
386 HOST_WIDE_INT bitsize
= -1;
387 HOST_WIDE_INT maxsize
= -1;
388 tree size_tree
= NULL_TREE
;
389 double_int bit_offset
= double_int_zero
;
390 HOST_WIDE_INT hbit_offset
;
391 bool seen_variable_array_ref
= false;
394 /* First get the final access size from just the outermost expression. */
395 if (TREE_CODE (exp
) == COMPONENT_REF
)
396 size_tree
= DECL_SIZE (TREE_OPERAND (exp
, 1));
397 else if (TREE_CODE (exp
) == BIT_FIELD_REF
)
398 size_tree
= TREE_OPERAND (exp
, 1);
399 else if (!VOID_TYPE_P (TREE_TYPE (exp
)))
401 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (exp
));
403 size_tree
= TYPE_SIZE (TREE_TYPE (exp
));
405 bitsize
= GET_MODE_BITSIZE (mode
);
407 if (size_tree
!= NULL_TREE
)
409 if (! host_integerp (size_tree
, 1))
412 bitsize
= TREE_INT_CST_LOW (size_tree
);
415 /* Initially, maxsize is the same as the accessed element size.
416 In the following it will only grow (or become -1). */
419 /* Compute cumulative bit-offset for nested component-refs and array-refs,
420 and find the ultimate containing object. */
423 base_type
= TREE_TYPE (exp
);
425 switch (TREE_CODE (exp
))
428 bit_offset
+= tree_to_double_int (TREE_OPERAND (exp
, 2));
433 tree field
= TREE_OPERAND (exp
, 1);
434 tree this_offset
= component_ref_field_offset (exp
);
436 if (this_offset
&& TREE_CODE (this_offset
) == INTEGER_CST
)
438 double_int doffset
= tree_to_double_int (this_offset
);
439 doffset
= doffset
.lshift (BITS_PER_UNIT
== 8
440 ? 3 : exact_log2 (BITS_PER_UNIT
));
441 doffset
+= tree_to_double_int (DECL_FIELD_BIT_OFFSET (field
));
442 bit_offset
= bit_offset
+ doffset
;
444 /* If we had seen a variable array ref already and we just
445 referenced the last field of a struct or a union member
446 then we have to adjust maxsize by the padding at the end
448 if (seen_variable_array_ref
&& maxsize
!= -1)
450 tree stype
= TREE_TYPE (TREE_OPERAND (exp
, 0));
451 tree next
= DECL_CHAIN (field
);
452 while (next
&& TREE_CODE (next
) != FIELD_DECL
)
453 next
= DECL_CHAIN (next
);
455 || TREE_CODE (stype
) != RECORD_TYPE
)
457 tree fsize
= DECL_SIZE_UNIT (field
);
458 tree ssize
= TYPE_SIZE_UNIT (stype
);
459 if (host_integerp (fsize
, 0)
460 && host_integerp (ssize
, 0)
461 && doffset
.fits_shwi ())
462 maxsize
+= ((TREE_INT_CST_LOW (ssize
)
463 - TREE_INT_CST_LOW (fsize
))
465 - doffset
.to_shwi ());
473 tree csize
= TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
474 /* We need to adjust maxsize to the whole structure bitsize.
475 But we can subtract any constant offset seen so far,
476 because that would get us out of the structure otherwise. */
479 && host_integerp (csize
, 1)
480 && bit_offset
.fits_shwi ())
481 maxsize
= TREE_INT_CST_LOW (csize
)
482 - bit_offset
.to_shwi ();
490 case ARRAY_RANGE_REF
:
492 tree index
= TREE_OPERAND (exp
, 1);
493 tree low_bound
, unit_size
;
495 /* If the resulting bit-offset is constant, track it. */
496 if (TREE_CODE (index
) == INTEGER_CST
497 && (low_bound
= array_ref_low_bound (exp
),
498 TREE_CODE (low_bound
) == INTEGER_CST
)
499 && (unit_size
= array_ref_element_size (exp
),
500 TREE_CODE (unit_size
) == INTEGER_CST
))
503 = (TREE_INT_CST (index
) - TREE_INT_CST (low_bound
))
504 .sext (TYPE_PRECISION (TREE_TYPE (index
)));
505 doffset
*= tree_to_double_int (unit_size
);
506 doffset
= doffset
.lshift (BITS_PER_UNIT
== 8
507 ? 3 : exact_log2 (BITS_PER_UNIT
));
508 bit_offset
= bit_offset
+ doffset
;
510 /* An array ref with a constant index up in the structure
511 hierarchy will constrain the size of any variable array ref
512 lower in the access hierarchy. */
513 seen_variable_array_ref
= false;
517 tree asize
= TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
518 /* We need to adjust maxsize to the whole array bitsize.
519 But we can subtract any constant offset seen so far,
520 because that would get us outside of the array otherwise. */
523 && host_integerp (asize
, 1)
524 && bit_offset
.fits_shwi ())
525 maxsize
= TREE_INT_CST_LOW (asize
)
526 - bit_offset
.to_shwi ();
530 /* Remember that we have seen an array ref with a variable
532 seen_variable_array_ref
= true;
541 bit_offset
+= double_int::from_uhwi (bitsize
);
544 case VIEW_CONVERT_EXPR
:
548 /* Hand back the decl for MEM[&decl, off]. */
549 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == ADDR_EXPR
)
551 if (integer_zerop (TREE_OPERAND (exp
, 1)))
552 exp
= TREE_OPERAND (TREE_OPERAND (exp
, 0), 0);
555 double_int off
= mem_ref_offset (exp
);
556 off
= off
.lshift (BITS_PER_UNIT
== 8
557 ? 3 : exact_log2 (BITS_PER_UNIT
));
558 off
= off
+ bit_offset
;
559 if (off
.fits_shwi ())
562 exp
= TREE_OPERAND (TREE_OPERAND (exp
, 0), 0);
569 /* Hand back the decl for MEM[&decl, off]. */
570 if (TREE_CODE (TMR_BASE (exp
)) == ADDR_EXPR
)
572 /* Via the variable index or index2 we can reach the
574 if (TMR_INDEX (exp
) || TMR_INDEX2 (exp
))
576 exp
= TREE_OPERAND (TMR_BASE (exp
), 0);
577 bit_offset
= double_int_zero
;
581 if (integer_zerop (TMR_OFFSET (exp
)))
582 exp
= TREE_OPERAND (TMR_BASE (exp
), 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 (TMR_BASE (exp
), 0);
602 exp
= TREE_OPERAND (exp
, 0);
606 if (!bit_offset
.fits_shwi ())
615 hbit_offset
= bit_offset
.to_shwi ();
617 /* We need to deal with variable arrays ending structures such as
618 struct { int length; int a[1]; } x; x.a[d]
619 struct { struct { int a; int b; } a[1]; } x; x.a[d].a
620 struct { struct { int a[1]; } a[1]; } x; x.a[0][d], x.a[d][0]
621 struct { int len; union { int a[1]; struct X x; } u; } x; x.u.a[d]
622 where we do not know maxsize for variable index accesses to
623 the array. The simplest way to conservatively deal with this
624 is to punt in the case that offset + maxsize reaches the
625 base type boundary. This needs to include possible trailing padding
626 that is there for alignment purposes. */
628 if (seen_variable_array_ref
630 && (!host_integerp (TYPE_SIZE (base_type
), 1)
631 || (hbit_offset
+ maxsize
632 == (signed) TREE_INT_CST_LOW (TYPE_SIZE (base_type
)))))
635 /* In case of a decl or constant base object we can do better. */
639 /* If maxsize is unknown adjust it according to the size of the
642 && host_integerp (DECL_SIZE (exp
), 1))
643 maxsize
= TREE_INT_CST_LOW (DECL_SIZE (exp
)) - hbit_offset
;
645 else if (CONSTANT_CLASS_P (exp
))
647 /* If maxsize is unknown adjust it according to the size of the
648 base type constant. */
650 && host_integerp (TYPE_SIZE (TREE_TYPE (exp
)), 1))
651 maxsize
= TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (exp
))) - hbit_offset
;
654 /* ??? Due to negative offsets in ARRAY_REF we can end up with
655 negative bit_offset here. We might want to store a zero offset
657 *poffset
= hbit_offset
;
659 *pmax_size
= maxsize
;
664 /* Returns the base object and a constant BITS_PER_UNIT offset in *POFFSET that
665 denotes the starting address of the memory access EXP.
666 Returns NULL_TREE if the offset is not constant or any component
667 is not BITS_PER_UNIT-aligned. */
670 get_addr_base_and_unit_offset (tree exp
, HOST_WIDE_INT
*poffset
)
672 return get_addr_base_and_unit_offset_1 (exp
, poffset
, NULL
);
675 /* Returns true if STMT references an SSA_NAME that has
676 SSA_NAME_OCCURS_IN_ABNORMAL_PHI set, otherwise false. */
679 stmt_references_abnormal_ssa_name (gimple stmt
)
684 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, oi
, SSA_OP_USE
)
686 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (USE_FROM_PTR (use_p
)))
693 /* Pair of tree and a sorting index, for dump_enumerated_decls. */
694 struct GTY(()) numbered_tree_d
699 typedef struct numbered_tree_d numbered_tree
;
702 /* Compare two declarations references by their DECL_UID / sequence number.
706 compare_decls_by_uid (const void *pa
, const void *pb
)
708 const numbered_tree
*nt_a
= ((const numbered_tree
*)pa
);
709 const numbered_tree
*nt_b
= ((const numbered_tree
*)pb
);
711 if (DECL_UID (nt_a
->t
) != DECL_UID (nt_b
->t
))
712 return DECL_UID (nt_a
->t
) - DECL_UID (nt_b
->t
);
713 return nt_a
->num
- nt_b
->num
;
716 /* Called via walk_gimple_stmt / walk_gimple_op by dump_enumerated_decls. */
718 dump_enumerated_decls_push (tree
*tp
, int *walk_subtrees
, void *data
)
720 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
721 vec
<numbered_tree
> *list
= (vec
<numbered_tree
> *) wi
->info
;
727 nt
.num
= list
->length ();
728 list
->safe_push (nt
);
733 /* Find all the declarations used by the current function, sort them by uid,
734 and emit the sorted list. Each declaration is tagged with a sequence
735 number indicating when it was found during statement / tree walking,
736 so that TDF_NOUID comparisons of anonymous declarations are still
737 meaningful. Where a declaration was encountered more than once, we
738 emit only the sequence number of the first encounter.
739 FILE is the dump file where to output the list and FLAGS is as in
740 print_generic_expr. */
742 dump_enumerated_decls (FILE *file
, int flags
)
745 struct walk_stmt_info wi
;
746 vec
<numbered_tree
> decl_list
;
747 decl_list
.create (40);
749 memset (&wi
, '\0', sizeof (wi
));
750 wi
.info
= (void *) &decl_list
;
753 gimple_stmt_iterator gsi
;
755 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
756 if (!is_gimple_debug (gsi_stmt (gsi
)))
757 walk_gimple_stmt (&gsi
, NULL
, dump_enumerated_decls_push
, &wi
);
759 decl_list
.qsort (compare_decls_by_uid
);
760 if (decl_list
.length ())
764 tree last
= NULL_TREE
;
766 fprintf (file
, "Declarations used by %s, sorted by DECL_UID:\n",
767 current_function_name ());
768 FOR_EACH_VEC_ELT (decl_list
, ix
, ntp
)
772 fprintf (file
, "%d: ", ntp
->num
);
773 print_generic_decl (file
, ntp
->t
, flags
);
774 fprintf (file
, "\n");
778 decl_list
.release ();