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;
393 /* First get the final access size from just the outermost expression. */
394 if (TREE_CODE (exp
) == COMPONENT_REF
)
395 size_tree
= DECL_SIZE (TREE_OPERAND (exp
, 1));
396 else if (TREE_CODE (exp
) == BIT_FIELD_REF
)
397 size_tree
= TREE_OPERAND (exp
, 1);
398 else if (!VOID_TYPE_P (TREE_TYPE (exp
)))
400 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (exp
));
402 size_tree
= TYPE_SIZE (TREE_TYPE (exp
));
404 bitsize
= GET_MODE_BITSIZE (mode
);
406 if (size_tree
!= NULL_TREE
)
408 if (! host_integerp (size_tree
, 1))
411 bitsize
= TREE_INT_CST_LOW (size_tree
);
414 /* Initially, maxsize is the same as the accessed element size.
415 In the following it will only grow (or become -1). */
418 /* Compute cumulative bit-offset for nested component-refs and array-refs,
419 and find the ultimate containing object. */
422 switch (TREE_CODE (exp
))
425 bit_offset
+= tree_to_double_int (TREE_OPERAND (exp
, 2));
430 tree field
= TREE_OPERAND (exp
, 1);
431 tree this_offset
= component_ref_field_offset (exp
);
433 if (this_offset
&& TREE_CODE (this_offset
) == INTEGER_CST
)
435 double_int doffset
= tree_to_double_int (this_offset
);
436 doffset
= doffset
.lshift (BITS_PER_UNIT
== 8
437 ? 3 : exact_log2 (BITS_PER_UNIT
));
438 doffset
+= tree_to_double_int (DECL_FIELD_BIT_OFFSET (field
));
439 bit_offset
= bit_offset
+ doffset
;
441 /* If we had seen a variable array ref already and we just
442 referenced the last field of a struct or a union member
443 then we have to adjust maxsize by the padding at the end
445 if (seen_variable_array_ref
&& maxsize
!= -1)
447 tree stype
= TREE_TYPE (TREE_OPERAND (exp
, 0));
448 tree next
= DECL_CHAIN (field
);
449 while (next
&& TREE_CODE (next
) != FIELD_DECL
)
450 next
= DECL_CHAIN (next
);
452 || TREE_CODE (stype
) != RECORD_TYPE
)
454 tree fsize
= DECL_SIZE_UNIT (field
);
455 tree ssize
= TYPE_SIZE_UNIT (stype
);
456 if (host_integerp (fsize
, 0)
457 && host_integerp (ssize
, 0)
458 && doffset
.fits_shwi ())
459 maxsize
+= ((TREE_INT_CST_LOW (ssize
)
460 - TREE_INT_CST_LOW (fsize
))
462 - doffset
.to_shwi ());
470 tree csize
= TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
471 /* We need to adjust maxsize to the whole structure bitsize.
472 But we can subtract any constant offset seen so far,
473 because that would get us out of the structure otherwise. */
476 && host_integerp (csize
, 1)
477 && bit_offset
.fits_shwi ())
478 maxsize
= TREE_INT_CST_LOW (csize
)
479 - bit_offset
.to_shwi ();
487 case ARRAY_RANGE_REF
:
489 tree index
= TREE_OPERAND (exp
, 1);
490 tree low_bound
, unit_size
;
492 /* If the resulting bit-offset is constant, track it. */
493 if (TREE_CODE (index
) == INTEGER_CST
494 && (low_bound
= array_ref_low_bound (exp
),
495 TREE_CODE (low_bound
) == INTEGER_CST
)
496 && (unit_size
= array_ref_element_size (exp
),
497 TREE_CODE (unit_size
) == INTEGER_CST
))
500 = (TREE_INT_CST (index
) - TREE_INT_CST (low_bound
))
501 .sext (TYPE_PRECISION (TREE_TYPE (index
)));
502 doffset
*= tree_to_double_int (unit_size
);
503 doffset
= doffset
.lshift (BITS_PER_UNIT
== 8
504 ? 3 : exact_log2 (BITS_PER_UNIT
));
505 bit_offset
= bit_offset
+ doffset
;
507 /* An array ref with a constant index up in the structure
508 hierarchy will constrain the size of any variable array ref
509 lower in the access hierarchy. */
510 seen_variable_array_ref
= false;
514 tree asize
= TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
515 /* We need to adjust maxsize to the whole array bitsize.
516 But we can subtract any constant offset seen so far,
517 because that would get us outside of the array otherwise. */
520 && host_integerp (asize
, 1)
521 && bit_offset
.fits_shwi ())
522 maxsize
= TREE_INT_CST_LOW (asize
)
523 - bit_offset
.to_shwi ();
527 /* Remember that we have seen an array ref with a variable
529 seen_variable_array_ref
= true;
538 bit_offset
+= double_int::from_uhwi (bitsize
);
541 case VIEW_CONVERT_EXPR
:
545 /* Via the variable index or index2 we can reach the
546 whole object. Still hand back the decl here. */
547 if (TREE_CODE (TMR_BASE (exp
)) == ADDR_EXPR
548 && (TMR_INDEX (exp
) || TMR_INDEX2 (exp
)))
550 exp
= TREE_OPERAND (TMR_BASE (exp
), 0);
551 bit_offset
= double_int_zero
;
557 /* We need to deal with variable arrays ending structures such as
558 struct { int length; int a[1]; } x; x.a[d]
559 struct { struct { int a; int b; } a[1]; } x; x.a[d].a
560 struct { struct { int a[1]; } a[1]; } x; x.a[0][d], x.a[d][0]
561 struct { int len; union { int a[1]; struct X x; } u; } x; x.u.a[d]
562 where we do not know maxsize for variable index accesses to
563 the array. The simplest way to conservatively deal with this
564 is to punt in the case that offset + maxsize reaches the
565 base type boundary. This needs to include possible trailing
566 padding that is there for alignment purposes. */
567 if (seen_variable_array_ref
569 && (!bit_offset
.fits_shwi ()
570 || !host_integerp (TYPE_SIZE (TREE_TYPE (exp
)), 1)
571 || (bit_offset
.to_shwi () + maxsize
572 == (signed) TREE_INT_CST_LOW
573 (TYPE_SIZE (TREE_TYPE (exp
))))))
576 /* Hand back the decl for MEM[&decl, off]. */
577 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == ADDR_EXPR
)
579 if (integer_zerop (TREE_OPERAND (exp
, 1)))
580 exp
= TREE_OPERAND (TREE_OPERAND (exp
, 0), 0);
583 double_int off
= mem_ref_offset (exp
);
584 off
= off
.lshift (BITS_PER_UNIT
== 8
585 ? 3 : exact_log2 (BITS_PER_UNIT
));
587 if (off
.fits_shwi ())
590 exp
= TREE_OPERAND (TREE_OPERAND (exp
, 0), 0);
600 exp
= TREE_OPERAND (exp
, 0);
603 /* We need to deal with variable arrays ending structures. */
604 if (seen_variable_array_ref
606 && (!bit_offset
.fits_shwi ()
607 || !host_integerp (TYPE_SIZE (TREE_TYPE (exp
)), 1)
608 || (bit_offset
.to_shwi () + maxsize
609 == (signed) TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (exp
))))))
613 if (!bit_offset
.fits_shwi ())
622 hbit_offset
= bit_offset
.to_shwi ();
624 /* In case of a decl or constant base object we can do better. */
628 /* If maxsize is unknown adjust it according to the size of the
631 && host_integerp (DECL_SIZE (exp
), 1))
632 maxsize
= TREE_INT_CST_LOW (DECL_SIZE (exp
)) - hbit_offset
;
634 else if (CONSTANT_CLASS_P (exp
))
636 /* If maxsize is unknown adjust it according to the size of the
637 base type constant. */
639 && host_integerp (TYPE_SIZE (TREE_TYPE (exp
)), 1))
640 maxsize
= TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (exp
))) - hbit_offset
;
643 /* ??? Due to negative offsets in ARRAY_REF we can end up with
644 negative bit_offset here. We might want to store a zero offset
646 *poffset
= hbit_offset
;
648 *pmax_size
= maxsize
;
653 /* Returns the base object and a constant BITS_PER_UNIT offset in *POFFSET that
654 denotes the starting address of the memory access EXP.
655 Returns NULL_TREE if the offset is not constant or any component
656 is not BITS_PER_UNIT-aligned. */
659 get_addr_base_and_unit_offset (tree exp
, HOST_WIDE_INT
*poffset
)
661 return get_addr_base_and_unit_offset_1 (exp
, poffset
, NULL
);
664 /* Returns true if STMT references an SSA_NAME that has
665 SSA_NAME_OCCURS_IN_ABNORMAL_PHI set, otherwise false. */
668 stmt_references_abnormal_ssa_name (gimple stmt
)
673 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, oi
, SSA_OP_USE
)
675 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (USE_FROM_PTR (use_p
)))
682 /* Pair of tree and a sorting index, for dump_enumerated_decls. */
683 struct GTY(()) numbered_tree_d
688 typedef struct numbered_tree_d numbered_tree
;
691 /* Compare two declarations references by their DECL_UID / sequence number.
695 compare_decls_by_uid (const void *pa
, const void *pb
)
697 const numbered_tree
*nt_a
= ((const numbered_tree
*)pa
);
698 const numbered_tree
*nt_b
= ((const numbered_tree
*)pb
);
700 if (DECL_UID (nt_a
->t
) != DECL_UID (nt_b
->t
))
701 return DECL_UID (nt_a
->t
) - DECL_UID (nt_b
->t
);
702 return nt_a
->num
- nt_b
->num
;
705 /* Called via walk_gimple_stmt / walk_gimple_op by dump_enumerated_decls. */
707 dump_enumerated_decls_push (tree
*tp
, int *walk_subtrees
, void *data
)
709 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
710 vec
<numbered_tree
> *list
= (vec
<numbered_tree
> *) wi
->info
;
716 nt
.num
= list
->length ();
717 list
->safe_push (nt
);
722 /* Find all the declarations used by the current function, sort them by uid,
723 and emit the sorted list. Each declaration is tagged with a sequence
724 number indicating when it was found during statement / tree walking,
725 so that TDF_NOUID comparisons of anonymous declarations are still
726 meaningful. Where a declaration was encountered more than once, we
727 emit only the sequence number of the first encounter.
728 FILE is the dump file where to output the list and FLAGS is as in
729 print_generic_expr. */
731 dump_enumerated_decls (FILE *file
, int flags
)
734 struct walk_stmt_info wi
;
735 stack_vec
<numbered_tree
, 40> decl_list
;
737 memset (&wi
, '\0', sizeof (wi
));
738 wi
.info
= (void *) &decl_list
;
741 gimple_stmt_iterator gsi
;
743 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
744 if (!is_gimple_debug (gsi_stmt (gsi
)))
745 walk_gimple_stmt (&gsi
, NULL
, dump_enumerated_decls_push
, &wi
);
747 decl_list
.qsort (compare_decls_by_uid
);
748 if (decl_list
.length ())
752 tree last
= NULL_TREE
;
754 fprintf (file
, "Declarations used by %s, sorted by DECL_UID:\n",
755 current_function_name ());
756 FOR_EACH_VEC_ELT (decl_list
, ix
, ntp
)
760 fprintf (file
, "%d: ", ntp
->num
);
761 print_generic_decl (file
, ntp
->t
, flags
);
762 fprintf (file
, "\n");