OSDN Git Service

2009-10-05 Richard Guenther <rguenther@suse.de>
[pf3gnuchains/gcc-fork.git] / gcc / lto-cgraph.c
1 /* Write and read the cgraph to the memory mapped representation of a
2    .o file.
3
4    Copyright 2009 Free Software Foundation, Inc.
5    Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>
6
7 This file is part of GCC.
8
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 3, or (at your option) any later
12 version.
13
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
17 for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3.  If not see
21 <http://www.gnu.org/licenses/>.  */
22
23 #include "config.h"
24 #include "system.h"
25 #include "coretypes.h"
26 #include "tm.h"
27 #include "toplev.h"
28 #include "tree.h"
29 #include "expr.h"
30 #include "flags.h"
31 #include "params.h"
32 #include "input.h"
33 #include "varray.h"
34 #include "hashtab.h"
35 #include "langhooks.h"
36 #include "basic-block.h"
37 #include "tree-flow.h"
38 #include "cgraph.h"
39 #include "function.h"
40 #include "ggc.h"
41 #include "diagnostic.h"
42 #include "except.h"
43 #include "vec.h"
44 #include "timevar.h"
45 #include "output.h"
46 #include "pointer-set.h"
47 #include "lto-streamer.h"
48
49 /* Create a new cgraph encoder.  */
50
51 lto_cgraph_encoder_t
52 lto_cgraph_encoder_new (void)
53 {
54   lto_cgraph_encoder_t encoder = XCNEW (struct lto_cgraph_encoder_d);
55   encoder->map = pointer_map_create ();
56   encoder->nodes = NULL;
57   return encoder;
58 }
59
60
61 /* Delete ENCODER and its components.  */
62
63 void
64 lto_cgraph_encoder_delete (lto_cgraph_encoder_t encoder)
65 {
66    VEC_free (cgraph_node_ptr, heap, encoder->nodes);
67    pointer_map_destroy (encoder->map);
68    free (encoder);
69 }
70
71
72 /* Return the existing reference number of NODE in the cgraph encoder in
73    output block OB.  Assign a new reference if this is the first time
74    NODE is encoded.  */
75
76 int
77 lto_cgraph_encoder_encode (lto_cgraph_encoder_t encoder,
78                            struct cgraph_node *node)
79 {
80   int ref;
81   void **slot;
82   
83   slot = pointer_map_contains (encoder->map, node);
84   if (!slot)
85     {
86       ref = VEC_length (cgraph_node_ptr, encoder->nodes);
87       slot = pointer_map_insert (encoder->map, node);
88       *slot = (void *) (intptr_t) ref;
89       VEC_safe_push (cgraph_node_ptr, heap, encoder->nodes, node);
90     }
91   else
92     ref = (int) (intptr_t) *slot;
93
94   return ref;
95 }
96
97
98 /* Look up NODE in encoder.  Return NODE's reference if it has been encoded
99    or LCC_NOT_FOUND if it is not there.  */
100
101 int
102 lto_cgraph_encoder_lookup (lto_cgraph_encoder_t encoder,
103                            struct cgraph_node *node)
104 {
105   void **slot = pointer_map_contains (encoder->map, node);
106   return (slot ? (int) (intptr_t) *slot : LCC_NOT_FOUND);
107 }
108
109
110 /* Return the cgraph node corresponding to REF using ENCODER.  */
111
112 struct cgraph_node *
113 lto_cgraph_encoder_deref (lto_cgraph_encoder_t encoder, int ref)
114 {
115   if (ref == LCC_NOT_FOUND)
116     return NULL;
117
118   return VEC_index (cgraph_node_ptr, encoder->nodes, ref); 
119 }
120
121
122 /* Return number of encoded nodes in ENCODER.  */
123
124 static int
125 lto_cgraph_encoder_size (lto_cgraph_encoder_t encoder)
126 {
127   return VEC_length (cgraph_node_ptr, encoder->nodes);
128 }
129
130
131 /* Output the cgraph EDGE to OB using ENCODER.  */
132
133 static void
134 lto_output_edge (struct lto_simple_output_block *ob, struct cgraph_edge *edge,
135                  lto_cgraph_encoder_t encoder)
136 {
137   unsigned int uid;
138   intptr_t ref;
139   struct bitpack_d *bp;
140
141   lto_output_uleb128_stream (ob->main_stream, LTO_cgraph_edge);
142
143   ref = lto_cgraph_encoder_lookup (encoder, edge->caller);
144   gcc_assert (ref != LCC_NOT_FOUND); 
145   lto_output_sleb128_stream (ob->main_stream, ref);
146
147   ref = lto_cgraph_encoder_lookup (encoder, edge->callee);
148   gcc_assert (ref != LCC_NOT_FOUND); 
149   lto_output_sleb128_stream (ob->main_stream, ref);
150
151   lto_output_sleb128_stream (ob->main_stream, edge->count);
152
153   bp = bitpack_create ();
154   uid = flag_wpa ? edge->lto_stmt_uid : gimple_uid (edge->call_stmt);
155   bp_pack_value (bp, uid, HOST_BITS_PER_INT);
156   bp_pack_value (bp, edge->inline_failed, HOST_BITS_PER_INT);
157   bp_pack_value (bp, edge->frequency, HOST_BITS_PER_INT);
158   bp_pack_value (bp, edge->loop_nest, 30);
159   bp_pack_value (bp, edge->indirect_call, 1);
160   bp_pack_value (bp, edge->call_stmt_cannot_inline_p, 1);
161   bp_pack_value (bp, edge->can_throw_external, 1);
162   lto_output_bitpack (ob->main_stream, bp);
163   bitpack_delete (bp);
164 }
165
166
167 /* Output the cgraph NODE to OB.  ENCODER is used to find the
168    reference number of NODE->inlined_to.  SET is the set of nodes we
169    are writing to the current file.  If NODE is not in SET, then NODE
170    is a boundary of a cgraph_node_set and we pretend NODE just has a
171    decl and no callees.  WRITTEN_DECLS is the set of FUNCTION_DECLs
172    that have had their callgraph node written so far.  This is used to
173    determine if NODE is a clone of a previously written node.  */
174
175 static void
176 lto_output_node (struct lto_simple_output_block *ob, struct cgraph_node *node,
177                  lto_cgraph_encoder_t encoder, cgraph_node_set set,
178                  bitmap written_decls)
179 {
180   unsigned int tag;
181   struct bitpack_d *bp;
182   unsigned local, externally_visible, inlinable, analyzed;
183   bool boundary_p, wrote_decl_p;
184   intptr_t ref;
185
186   boundary_p = !cgraph_node_in_set_p (node, set);
187   wrote_decl_p = bitmap_bit_p (written_decls, DECL_UID (node->decl));
188
189   switch (cgraph_function_body_availability (node))
190     {
191     case AVAIL_NOT_AVAILABLE:
192       tag = LTO_cgraph_unavail_node;
193       break;
194
195     case AVAIL_AVAILABLE:
196     case AVAIL_LOCAL:
197       tag = LTO_cgraph_avail_node;
198       break;
199     
200     case AVAIL_OVERWRITABLE:
201       tag = LTO_cgraph_overwritable_node;
202       break;
203       
204     default:
205       gcc_unreachable ();
206     }
207  
208   if (boundary_p)
209     tag = LTO_cgraph_unavail_node;
210
211   lto_output_uleb128_stream (ob->main_stream, tag);
212
213   local = node->local.local;
214   externally_visible = node->local.externally_visible;
215   inlinable = node->local.inlinable;
216   analyzed = node->analyzed;
217
218   /* In WPA mode, we only output part of the call-graph.  Also, we
219      fake cgraph node attributes.  There are two cases that we care.
220
221      Boundary nodes: There are nodes that are not part of SET but are
222      called from within SET.  We artificially make them look like
223      externally visible nodes with no function body. 
224
225      Cherry-picked nodes:  These are nodes we pulled from other
226      translation units into SET during IPA-inlining.  We make them as
227      local static nodes to prevent clashes with other local statics.  */
228   if (boundary_p)
229     {
230       local = 0;
231       externally_visible = 1;
232       inlinable = 0;
233       analyzed = 0;
234     }
235   else if (lto_forced_extern_inline_p (node->decl))
236     {
237       local = 1;
238       externally_visible = 0;
239       inlinable = 1;
240     }
241
242   lto_output_uleb128_stream (ob->main_stream, wrote_decl_p);
243
244   if (!wrote_decl_p)
245     bitmap_set_bit (written_decls, DECL_UID (node->decl));
246
247   lto_output_fn_decl_index (ob->decl_state, ob->main_stream, node->decl);
248   lto_output_sleb128_stream (ob->main_stream, node->count);
249
250   bp = bitpack_create ();
251   bp_pack_value (bp, local, 1);
252   bp_pack_value (bp, externally_visible, 1);
253   bp_pack_value (bp, node->local.finalized, 1);
254   bp_pack_value (bp, inlinable, 1);
255   bp_pack_value (bp, node->local.disregard_inline_limits, 1);
256   bp_pack_value (bp, node->local.redefined_extern_inline, 1);
257   bp_pack_value (bp, node->local.for_functions_valid, 1);
258   bp_pack_value (bp, node->local.vtable_method, 1);
259   bp_pack_value (bp, node->needed, 1);
260   bp_pack_value (bp, node->address_taken, 1);
261   bp_pack_value (bp, node->abstract_and_needed, 1);
262   bp_pack_value (bp, node->reachable, 1);
263   bp_pack_value (bp, node->lowered, 1);
264   bp_pack_value (bp, analyzed, 1);
265   bp_pack_value (bp, node->process, 1);
266   bp_pack_value (bp, node->alias, 1);
267   bp_pack_value (bp, node->finalized_by_frontend, 1);
268   lto_output_bitpack (ob->main_stream, bp);
269   bitpack_delete (bp);
270
271   if (tag != LTO_cgraph_unavail_node)
272     {
273       lto_output_sleb128_stream (ob->main_stream, 
274                                  node->local.inline_summary.estimated_self_stack_size);
275       lto_output_sleb128_stream (ob->main_stream, 
276                                  node->local.inline_summary.self_size);
277       lto_output_sleb128_stream (ob->main_stream, 
278                                  node->local.inline_summary.size_inlining_benefit);
279       lto_output_sleb128_stream (ob->main_stream, 
280                                  node->local.inline_summary.self_time);
281       lto_output_sleb128_stream (ob->main_stream, 
282                                  node->local.inline_summary.time_inlining_benefit);
283     }
284
285   /* FIXME lto: Outputting global info is not neccesary until after
286      inliner was run.  Global structure holds results of propagation
287      done by inliner.  */
288   lto_output_sleb128_stream (ob->main_stream,
289                              node->global.estimated_stack_size);
290   lto_output_sleb128_stream (ob->main_stream,
291                              node->global.stack_frame_offset);
292   if (node->global.inlined_to && !boundary_p)
293     {
294       ref = lto_cgraph_encoder_lookup (encoder, node->global.inlined_to);
295       gcc_assert (ref != LCC_NOT_FOUND);
296     }
297   else
298     ref = LCC_NOT_FOUND;
299   lto_output_sleb128_stream (ob->main_stream, ref);
300
301   lto_output_sleb128_stream (ob->main_stream, node->global.time);
302   lto_output_sleb128_stream (ob->main_stream, node->global.size);
303   lto_output_sleb128_stream (ob->main_stream,
304                              node->global.estimated_growth);
305   lto_output_uleb128_stream (ob->main_stream, node->global.inlined);
306 }
307
308
309 /* Output the part of the cgraph in SET.  */
310
311 void
312 output_cgraph (cgraph_node_set set)
313 {
314   struct cgraph_node *node;
315   struct lto_simple_output_block *ob;
316   cgraph_node_set_iterator csi;
317   struct cgraph_edge *edge;
318   int i, n_nodes;
319   bitmap written_decls;
320   lto_cgraph_encoder_t encoder;
321
322   ob = lto_create_simple_output_block (LTO_section_cgraph);
323
324   /* An encoder for cgraph nodes should have been created by
325      ipa_write_summaries_1.  */
326   gcc_assert (ob->decl_state->cgraph_node_encoder);
327   encoder = ob->decl_state->cgraph_node_encoder;
328
329   /* The FUNCTION_DECLs for which we have written a node.  The first
330      node found is written as the "original" node, the remaining nodes
331      are considered its clones.  */
332   written_decls = lto_bitmap_alloc ();
333
334   /* Go over all the nodes in SET and assign references.  */
335   for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
336     {
337       node = csi_node (csi);
338       lto_cgraph_encoder_encode (encoder, node);
339     }
340
341   /* Go over all the nodes again to include callees that are not in
342      SET.  */
343   for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
344     {
345       node = csi_node (csi);
346       for (edge = node->callees; edge; edge = edge->next_callee)
347         {
348           struct cgraph_node *callee = edge->callee;
349           if (!cgraph_node_in_set_p (callee, set))
350             {
351               /* We should have moved all the inlines.  */
352               gcc_assert (!callee->global.inlined_to);
353               lto_cgraph_encoder_encode (encoder, callee);
354             }
355         }
356     }
357
358   /* Write out the nodes.  */
359   n_nodes = lto_cgraph_encoder_size (encoder);
360   for (i = 0; i < n_nodes; i++)
361     {
362       node = lto_cgraph_encoder_deref (encoder, i);
363       lto_output_node (ob, node, encoder, set, written_decls);
364     }
365
366   lto_bitmap_free (written_decls);
367
368   /* Go over the nodes in SET again to write edges.  */
369   for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
370     {
371       node = csi_node (csi);
372       for (edge = node->callees; edge; edge = edge->next_callee)
373         lto_output_edge (ob, edge, encoder);
374     }
375
376   lto_output_uleb128_stream (ob->main_stream, 0);
377
378   lto_destroy_simple_output_block (ob);
379 }
380
381
382 /* Overwrite the information in NODE based on FILE_DATA, TAG, FLAGS,
383    STACK_SIZE, SELF_TIME and SELF_SIZE.  This is called either to initialize
384    NODE or to replace the values in it, for instance because the first
385    time we saw it, the function body was not available but now it
386    is.  BP is a bitpack with all the bitflags for NODE read from the
387    stream.  */
388
389 static void
390 input_overwrite_node (struct lto_file_decl_data *file_data,
391                       struct cgraph_node *node,
392                       enum LTO_cgraph_tags tag,
393                       struct bitpack_d *bp,
394                       unsigned int stack_size,
395                       unsigned int self_time,
396                       unsigned int time_inlining_benefit,
397                       unsigned int self_size,
398                       unsigned int size_inlining_benefit)
399 {
400   node->aux = (void *) tag;
401   node->local.inline_summary.estimated_self_stack_size = stack_size;
402   node->local.inline_summary.self_time = self_time;
403   node->local.inline_summary.time_inlining_benefit = time_inlining_benefit;
404   node->local.inline_summary.self_size = self_size;
405   node->local.inline_summary.size_inlining_benefit = size_inlining_benefit;
406   node->global.time = self_time;
407   node->global.size = self_size;
408   node->local.lto_file_data = file_data;
409
410   node->local.local = bp_unpack_value (bp, 1);
411   node->local.externally_visible = bp_unpack_value (bp, 1);
412   node->local.finalized = bp_unpack_value (bp, 1);
413   node->local.inlinable = bp_unpack_value (bp, 1);
414   node->local.disregard_inline_limits = bp_unpack_value (bp, 1);
415   node->local.redefined_extern_inline = bp_unpack_value (bp, 1);
416   node->local.for_functions_valid = bp_unpack_value (bp, 1);
417   node->local.vtable_method = bp_unpack_value (bp, 1);
418   node->needed = bp_unpack_value (bp, 1);
419   node->address_taken = bp_unpack_value (bp, 1);
420   node->abstract_and_needed = bp_unpack_value (bp, 1);
421   node->reachable = bp_unpack_value (bp, 1);
422   node->lowered = bp_unpack_value (bp, 1);
423   node->analyzed = bp_unpack_value (bp, 1);
424   node->process = bp_unpack_value (bp, 1);
425   node->alias = bp_unpack_value (bp, 1);
426   node->finalized_by_frontend = bp_unpack_value (bp, 1);
427 }
428
429
430 /* Read a node from input_block IB.  TAG is the node's tag just read. 
431    Return the node read or overwriten.  */
432  
433 static struct cgraph_node *
434 input_node (struct lto_file_decl_data *file_data,
435             struct lto_input_block *ib,
436             enum LTO_cgraph_tags tag)
437 {
438   tree fn_decl;
439   struct cgraph_node *node;
440   struct bitpack_d *bp;
441   int stack_size = 0;
442   unsigned decl_index;
443   bool clone_p;
444   int estimated_stack_size = 0;
445   int stack_frame_offset = 0;
446   int ref = LCC_NOT_FOUND;
447   int estimated_growth = 0;
448   int time = 0;
449   int size = 0;
450   int self_time = 0;
451   int self_size = 0;
452   int time_inlining_benefit = 0;
453   int size_inlining_benefit = 0;
454   bool inlined = false;
455
456   clone_p = (lto_input_uleb128 (ib) != 0);
457
458   decl_index = lto_input_uleb128 (ib);
459   fn_decl = lto_file_decl_data_get_fn_decl (file_data, decl_index);
460
461   if (clone_p)
462     node = cgraph_clone_node (cgraph_node (fn_decl), 0,
463                               CGRAPH_FREQ_BASE, 0, false, NULL);
464
465   else
466     node = cgraph_node (fn_decl);
467
468   node->count = lto_input_sleb128 (ib);
469   bp = lto_input_bitpack (ib);
470   
471   if (tag != LTO_cgraph_unavail_node)
472     {
473       stack_size = lto_input_sleb128 (ib);
474       self_size = lto_input_sleb128 (ib);
475       size_inlining_benefit = lto_input_sleb128 (ib);
476       self_time = lto_input_sleb128 (ib);
477       time_inlining_benefit = lto_input_sleb128 (ib);
478     }
479
480   estimated_stack_size = lto_input_sleb128 (ib);
481   stack_frame_offset = lto_input_sleb128 (ib);
482   ref = lto_input_sleb128 (ib);
483   time = lto_input_sleb128 (ib);
484   size = lto_input_sleb128 (ib);
485   estimated_growth = lto_input_sleb128 (ib);
486   inlined = lto_input_uleb128 (ib);
487
488   /* Make sure that we have not read this node before.  Nodes that
489      have already been read will have their tag stored in the 'aux'
490      field.  Since built-in functions can be referenced in multiple
491      functions, they are expected to be read more than once.  */
492   if (node->aux && !DECL_IS_BUILTIN (node->decl))
493     internal_error ("bytecode stream: found multiple instances of cgraph "
494                     "node %d", node->uid);
495
496   input_overwrite_node (file_data, node, tag, bp, stack_size, self_time,
497                         time_inlining_benefit, self_size,
498                         size_inlining_benefit);
499   bitpack_delete (bp);
500
501   node->global.estimated_stack_size = estimated_stack_size;
502   node->global.stack_frame_offset = stack_frame_offset;
503   node->global.time = time;
504   node->global.size = size;
505
506   /* Store a reference for now, and fix up later to be a pointer.  */
507   node->global.inlined_to = (cgraph_node_ptr) (intptr_t) ref;
508
509   node->global.estimated_growth = estimated_growth;
510   node->global.inlined = inlined;
511
512   return node;
513 }
514
515
516 /* Read an edge from IB.  NODES points to a vector of previously read
517    nodes for decoding caller and callee of the edge to be read.  */
518
519 static void
520 input_edge (struct lto_input_block *ib, VEC(cgraph_node_ptr, heap) *nodes)
521 {
522   struct cgraph_node *caller, *callee;
523   struct cgraph_edge *edge;
524   unsigned int stmt_id;
525   gcov_type count;
526   int freq;
527   unsigned int nest;
528   cgraph_inline_failed_t inline_failed;
529   struct bitpack_d *bp;
530   enum ld_plugin_symbol_resolution caller_resolution;
531
532   caller = VEC_index (cgraph_node_ptr, nodes, lto_input_sleb128 (ib));
533   if (caller == NULL || caller->decl == NULL_TREE)
534     internal_error ("bytecode stream: no caller found while reading edge");
535
536   callee = VEC_index (cgraph_node_ptr, nodes, lto_input_sleb128 (ib));
537   if (callee == NULL || callee->decl == NULL_TREE)
538     internal_error ("bytecode stream: no callee found while reading edge");
539
540   count = (gcov_type) lto_input_sleb128 (ib);
541
542   bp = lto_input_bitpack (ib);
543   stmt_id = (unsigned int) bp_unpack_value (bp, HOST_BITS_PER_INT);
544   inline_failed = (cgraph_inline_failed_t) bp_unpack_value (bp,
545                                                             HOST_BITS_PER_INT);
546   freq = (int) bp_unpack_value (bp, HOST_BITS_PER_INT);
547   nest = (unsigned) bp_unpack_value (bp, 30);
548
549   /* If the caller was preempted, don't create the edge.
550      ???  Should we ever have edges from a preempted caller?  */
551   caller_resolution = lto_symtab_get_resolution (caller->decl);
552   if (caller_resolution == LDPR_PREEMPTED_REG
553       || caller_resolution == LDPR_PREEMPTED_IR)
554     return;
555
556   edge = cgraph_create_edge (caller, callee, NULL, count, freq, nest);
557   edge->lto_stmt_uid = stmt_id;
558   edge->inline_failed = inline_failed;
559   edge->indirect_call = bp_unpack_value (bp, 1);
560   edge->call_stmt_cannot_inline_p = bp_unpack_value (bp, 1);
561   edge->can_throw_external = bp_unpack_value (bp, 1);
562   bitpack_delete (bp);
563 }
564
565
566 /* Read a cgraph from IB using the info in FILE_DATA.  */
567
568 static void
569 input_cgraph_1 (struct lto_file_decl_data *file_data,
570                 struct lto_input_block *ib)
571 {
572   enum LTO_cgraph_tags tag;
573   VEC(cgraph_node_ptr, heap) *nodes = NULL;
574   struct cgraph_node *node;
575   unsigned i;
576
577   tag = (enum LTO_cgraph_tags) lto_input_uleb128 (ib);
578   while (tag)
579     {
580       if (tag == LTO_cgraph_edge)
581         input_edge (ib, nodes);
582       else 
583         {
584           node = input_node (file_data, ib, tag);
585           if (node == NULL || node->decl == NULL_TREE)
586             internal_error ("bytecode stream: found empty cgraph node");
587           VEC_safe_push (cgraph_node_ptr, heap, nodes, node);
588           lto_cgraph_encoder_encode (file_data->cgraph_node_encoder, node);
589         }
590
591       tag = (enum LTO_cgraph_tags) lto_input_uleb128 (ib);
592     }
593
594   for (i = 0; VEC_iterate (cgraph_node_ptr, nodes, i, node); i++)
595     {
596       const int ref = (int) (intptr_t) node->global.inlined_to;
597
598       /* Fixup inlined_to from reference to pointer.  */
599       if (ref != LCC_NOT_FOUND)
600         node->global.inlined_to = VEC_index (cgraph_node_ptr, nodes, ref);
601       else
602         node->global.inlined_to = NULL;
603     }
604
605   VEC_free (cgraph_node_ptr, heap, nodes);
606 }
607
608
609 /* Input and merge the cgraph from each of the .o files passed to
610    lto1.  */
611
612 void
613 input_cgraph (void)
614 {
615   struct lto_file_decl_data **file_data_vec = lto_get_file_decl_data ();
616   struct lto_file_decl_data *file_data;
617   unsigned int j = 0;
618   struct cgraph_node *node;
619
620   while ((file_data = file_data_vec[j++]))
621     {
622       const char *data;
623       size_t len;
624       struct lto_input_block *ib;
625
626       ib = lto_create_simple_input_block (file_data, LTO_section_cgraph, 
627                                           &data, &len);
628       file_data->cgraph_node_encoder = lto_cgraph_encoder_new ();
629       input_cgraph_1 (file_data, ib);
630       lto_destroy_simple_input_block (file_data, LTO_section_cgraph, 
631                                       ib, data, len);
632       
633       /* Assume that every file read needs to be processed by LTRANS.  */
634       if (flag_wpa)
635         lto_mark_file_for_ltrans (file_data);
636     } 
637
638   /* Clear out the aux field that was used to store enough state to
639      tell which nodes should be overwritten.  */
640   for (node = cgraph_nodes; node; node = node->next)
641     {
642       /* Some nodes may have been created by cgraph_node.  This
643          happens when the callgraph contains nested functions.  If the
644          node for the parent function was never emitted to the gimple
645          file, cgraph_node will create a node for it when setting the
646          context of the nested function.  */
647       if (node->local.lto_file_data)
648         node->aux = NULL;
649     }
650 }