1 /* Write the GIMPLE representation to a file stream.
3 Copyright 2009, 2010 Free Software Foundation, Inc.
4 Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>
5 Re-implemented by Diego Novillo <dnovillo@google.com>
7 This file is part of GCC.
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
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
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/>. */
25 #include "coretypes.h"
33 #include "basic-block.h"
34 #include "tree-flow.h"
35 #include "tree-pass.h"
39 #include "diagnostic-core.h"
42 #include "lto-symtab.h"
43 #include "lto-streamer.h"
50 unsigned int slot_num
;
54 /* Returns a hash code for P. */
57 hash_string_slot_node (const void *p
)
59 const struct string_slot
*ds
= (const struct string_slot
*) p
;
60 return (hashval_t
) htab_hash_string (ds
->s
);
64 /* Returns nonzero if P1 and P2 are equal. */
67 eq_string_slot_node (const void *p1
, const void *p2
)
69 const struct string_slot
*ds1
= (const struct string_slot
*) p1
;
70 const struct string_slot
*ds2
= (const struct string_slot
*) p2
;
72 if (ds1
->len
== ds2
->len
)
75 for (i
= 0; i
< ds1
->len
; i
++)
76 if (ds1
->s
[i
] != ds2
->s
[i
])
85 /* Free the string slot pointed-to by P. */
88 string_slot_free (void *p
)
90 struct string_slot
*slot
= (struct string_slot
*) p
;
91 free (CONST_CAST (void *, (const void *) slot
->s
));
96 /* Clear the line info stored in DATA_IN. */
99 clear_line_info (struct output_block
*ob
)
101 ob
->current_file
= NULL
;
102 ob
->current_line
= 0;
107 /* Create the output block and return it. SECTION_TYPE is
108 LTO_section_function_body or LTO_static_initializer. */
110 struct output_block
*
111 create_output_block (enum lto_section_type section_type
)
113 struct output_block
*ob
= XCNEW (struct output_block
);
115 ob
->section_type
= section_type
;
116 ob
->decl_state
= lto_get_out_decl_state ();
117 ob
->main_stream
= XCNEW (struct lto_output_stream
);
118 ob
->string_stream
= XCNEW (struct lto_output_stream
);
119 ob
->writer_cache
= lto_streamer_cache_create ();
121 if (section_type
== LTO_section_function_body
)
122 ob
->cfg_stream
= XCNEW (struct lto_output_stream
);
124 clear_line_info (ob
);
126 ob
->string_hash_table
= htab_create (37, hash_string_slot_node
,
127 eq_string_slot_node
, string_slot_free
);
133 /* Destroy the output block OB. */
136 destroy_output_block (struct output_block
*ob
)
138 enum lto_section_type section_type
= ob
->section_type
;
140 htab_delete (ob
->string_hash_table
);
142 free (ob
->main_stream
);
143 free (ob
->string_stream
);
144 if (section_type
== LTO_section_function_body
)
145 free (ob
->cfg_stream
);
147 lto_streamer_cache_delete (ob
->writer_cache
);
153 /* Output STRING of LEN characters to the string
154 table in OB. The string might or might not include a trailing '\0'.
155 Then put the index onto the INDEX_STREAM. */
158 output_string_with_length (struct output_block
*ob
,
159 struct lto_output_stream
*index_stream
,
163 struct string_slot
**slot
;
164 struct string_slot s_slot
;
165 char *string
= (char *) xmalloc (len
+ 1);
166 memcpy (string
, s
, len
);
173 slot
= (struct string_slot
**) htab_find_slot (ob
->string_hash_table
,
177 struct lto_output_stream
*string_stream
= ob
->string_stream
;
178 unsigned int start
= string_stream
->total_size
;
179 struct string_slot
*new_slot
180 = (struct string_slot
*) xmalloc (sizeof (struct string_slot
));
183 new_slot
->s
= string
;
185 new_slot
->slot_num
= start
;
187 lto_output_uleb128_stream (index_stream
, start
);
188 lto_output_uleb128_stream (string_stream
, len
);
189 for (i
= 0; i
< len
; i
++)
190 lto_output_1_stream (string_stream
, string
[i
]);
194 struct string_slot
*old_slot
= (struct string_slot
*)*slot
;
195 lto_output_uleb128_stream (index_stream
, old_slot
->slot_num
);
200 /* Output the '\0' terminated STRING to the string
201 table in OB. Then put the index onto the INDEX_STREAM. */
204 output_string (struct output_block
*ob
,
205 struct lto_output_stream
*index_stream
,
210 lto_output_uleb128_stream (index_stream
, 0);
211 output_string_with_length (ob
, index_stream
, string
, strlen (string
) + 1);
214 lto_output_uleb128_stream (index_stream
, 1);
218 /* Output the STRING constant to the string
219 table in OB. Then put the index onto the INDEX_STREAM. */
222 output_string_cst (struct output_block
*ob
,
223 struct lto_output_stream
*index_stream
,
228 lto_output_uleb128_stream (index_stream
, 0);
229 output_string_with_length (ob
, index_stream
,
230 TREE_STRING_POINTER (string
),
231 TREE_STRING_LENGTH (string
));
234 lto_output_uleb128_stream (index_stream
, 1);
238 /* Output the identifier ID to the string
239 table in OB. Then put the index onto the INDEX_STREAM. */
242 output_identifier (struct output_block
*ob
,
243 struct lto_output_stream
*index_stream
,
248 lto_output_uleb128_stream (index_stream
, 0);
249 output_string_with_length (ob
, index_stream
,
250 IDENTIFIER_POINTER (id
),
251 IDENTIFIER_LENGTH (id
));
254 lto_output_uleb128_stream (index_stream
, 1);
257 /* Write a zero to the output stream. */
260 output_zero (struct output_block
*ob
)
262 lto_output_1_stream (ob
->main_stream
, 0);
266 /* Output an unsigned LEB128 quantity to OB->main_stream. */
269 output_uleb128 (struct output_block
*ob
, unsigned HOST_WIDE_INT work
)
271 lto_output_uleb128_stream (ob
->main_stream
, work
);
275 /* Output a signed LEB128 quantity to OB->main_stream. */
278 output_sleb128 (struct output_block
*ob
, HOST_WIDE_INT work
)
280 lto_output_sleb128_stream (ob
->main_stream
, work
);
284 /* Output the start of a record with TAG to output block OB. */
287 output_record_start (struct output_block
*ob
, enum LTO_tags tag
)
289 /* Make sure TAG fits inside an unsigned int. */
290 gcc_assert (tag
== (enum LTO_tags
) (unsigned) tag
);
291 output_uleb128 (ob
, tag
);
295 /* Look up NODE in the type table and write the index for it to OB. */
298 output_type_ref (struct output_block
*ob
, tree node
)
300 output_record_start (ob
, LTO_type_ref
);
301 lto_output_type_ref_index (ob
->decl_state
, ob
->main_stream
, node
);
305 /* Pack all the non-pointer fields of the TS_BASE structure of
306 expression EXPR into bitpack BP. */
309 pack_ts_base_value_fields (struct bitpack_d
*bp
, tree expr
)
311 bp_pack_value (bp
, TREE_CODE (expr
), 16);
314 bp_pack_value (bp
, TREE_SIDE_EFFECTS (expr
), 1);
315 bp_pack_value (bp
, TREE_CONSTANT (expr
), 1);
316 bp_pack_value (bp
, TREE_READONLY (expr
), 1);
318 /* TREE_PUBLIC is used on types to indicate that the type
319 has a TYPE_CACHED_VALUES vector. This is not streamed out,
320 so we skip it here. */
321 bp_pack_value (bp
, TREE_PUBLIC (expr
), 1);
324 bp_pack_value (bp
, 0, 4);
325 bp_pack_value (bp
, TREE_ADDRESSABLE (expr
), 1);
326 bp_pack_value (bp
, TREE_THIS_VOLATILE (expr
), 1);
328 bp_pack_value (bp
, DECL_UNSIGNED (expr
), 1);
329 else if (TYPE_P (expr
))
330 bp_pack_value (bp
, TYPE_UNSIGNED (expr
), 1);
332 bp_pack_value (bp
, 0, 1);
333 /* We write debug info two times, do not confuse the second one. */
334 bp_pack_value (bp
, TYPE_P (expr
) ? 0 : TREE_ASM_WRITTEN (expr
), 1);
335 bp_pack_value (bp
, TREE_NO_WARNING (expr
), 1);
336 bp_pack_value (bp
, TREE_USED (expr
), 1);
337 bp_pack_value (bp
, TREE_NOTHROW (expr
), 1);
338 bp_pack_value (bp
, TREE_STATIC (expr
), 1);
339 bp_pack_value (bp
, TREE_PRIVATE (expr
), 1);
340 bp_pack_value (bp
, TREE_PROTECTED (expr
), 1);
341 bp_pack_value (bp
, TREE_DEPRECATED (expr
), 1);
343 bp_pack_value (bp
, TYPE_SATURATING (expr
), 1);
344 else if (TREE_CODE (expr
) == SSA_NAME
)
345 bp_pack_value (bp
, SSA_NAME_IS_DEFAULT_DEF (expr
), 1);
347 bp_pack_value (bp
, 0, 1);
351 /* Pack all the non-pointer fields of the TS_REAL_CST structure of
352 expression EXPR into bitpack BP. */
355 pack_ts_real_cst_value_fields (struct bitpack_d
*bp
, tree expr
)
360 r
= TREE_REAL_CST (expr
);
361 bp_pack_value (bp
, r
.cl
, 2);
362 bp_pack_value (bp
, r
.decimal
, 1);
363 bp_pack_value (bp
, r
.sign
, 1);
364 bp_pack_value (bp
, r
.signalling
, 1);
365 bp_pack_value (bp
, r
.canonical
, 1);
366 bp_pack_value (bp
, r
.uexp
, EXP_BITS
);
367 for (i
= 0; i
< SIGSZ
; i
++)
368 bp_pack_value (bp
, r
.sig
[i
], HOST_BITS_PER_LONG
);
372 /* Pack all the non-pointer fields of the TS_FIXED_CST structure of
373 expression EXPR into bitpack BP. */
376 pack_ts_fixed_cst_value_fields (struct bitpack_d
*bp
, tree expr
)
378 struct fixed_value fv
= TREE_FIXED_CST (expr
);
379 bp_pack_value (bp
, fv
.data
.low
, HOST_BITS_PER_WIDE_INT
);
380 bp_pack_value (bp
, fv
.data
.high
, HOST_BITS_PER_WIDE_INT
);
381 bp_pack_value (bp
, fv
.mode
, HOST_BITS_PER_INT
);
385 /* Pack all the non-pointer fields of the TS_DECL_COMMON structure
386 of expression EXPR into bitpack BP. */
389 pack_ts_decl_common_value_fields (struct bitpack_d
*bp
, tree expr
)
391 bp_pack_value (bp
, DECL_MODE (expr
), 8);
392 bp_pack_value (bp
, DECL_NONLOCAL (expr
), 1);
393 bp_pack_value (bp
, DECL_VIRTUAL_P (expr
), 1);
394 bp_pack_value (bp
, DECL_IGNORED_P (expr
), 1);
395 bp_pack_value (bp
, DECL_ABSTRACT (expr
), 1);
396 bp_pack_value (bp
, DECL_ARTIFICIAL (expr
), 1);
397 bp_pack_value (bp
, DECL_USER_ALIGN (expr
), 1);
398 bp_pack_value (bp
, DECL_PRESERVE_P (expr
), 1);
399 bp_pack_value (bp
, DECL_DEBUG_EXPR_IS_FROM (expr
), 1);
400 bp_pack_value (bp
, DECL_EXTERNAL (expr
), 1);
401 bp_pack_value (bp
, DECL_GIMPLE_REG_P (expr
), 1);
402 bp_pack_value (bp
, DECL_ALIGN (expr
), HOST_BITS_PER_INT
);
404 if (TREE_CODE (expr
) == LABEL_DECL
)
406 /* Note that we do not write LABEL_DECL_UID. The reader will
407 always assume an initial value of -1 so that the
408 label_to_block_map is recreated by gimple_set_bb. */
409 bp_pack_value (bp
, DECL_ERROR_ISSUED (expr
), 1);
410 bp_pack_value (bp
, EH_LANDING_PAD_NR (expr
), HOST_BITS_PER_INT
);
413 if (TREE_CODE (expr
) == FIELD_DECL
)
415 bp_pack_value (bp
, DECL_PACKED (expr
), 1);
416 bp_pack_value (bp
, DECL_NONADDRESSABLE_P (expr
), 1);
417 bp_pack_value (bp
, DECL_OFFSET_ALIGN (expr
), 8);
420 if (TREE_CODE (expr
) == RESULT_DECL
421 || TREE_CODE (expr
) == PARM_DECL
422 || TREE_CODE (expr
) == VAR_DECL
)
424 bp_pack_value (bp
, DECL_BY_REFERENCE (expr
), 1);
425 if (TREE_CODE (expr
) == VAR_DECL
426 || TREE_CODE (expr
) == PARM_DECL
)
427 bp_pack_value (bp
, DECL_HAS_VALUE_EXPR_P (expr
), 1);
428 bp_pack_value (bp
, DECL_RESTRICTED_P (expr
), 1);
433 /* Pack all the non-pointer fields of the TS_DECL_WRTL structure
434 of expression EXPR into bitpack BP. */
437 pack_ts_decl_wrtl_value_fields (struct bitpack_d
*bp
, tree expr
)
439 bp_pack_value (bp
, DECL_REGISTER (expr
), 1);
443 /* Pack all the non-pointer fields of the TS_DECL_WITH_VIS structure
444 of expression EXPR into bitpack BP. */
447 pack_ts_decl_with_vis_value_fields (struct bitpack_d
*bp
, tree expr
)
449 bp_pack_value (bp
, DECL_DEFER_OUTPUT (expr
), 1);
450 bp_pack_value (bp
, DECL_COMMON (expr
), 1);
451 bp_pack_value (bp
, DECL_DLLIMPORT_P (expr
), 1);
452 bp_pack_value (bp
, DECL_WEAK (expr
), 1);
453 bp_pack_value (bp
, DECL_SEEN_IN_BIND_EXPR_P (expr
), 1);
454 bp_pack_value (bp
, DECL_COMDAT (expr
), 1);
455 bp_pack_value (bp
, DECL_VISIBILITY (expr
), 2);
456 bp_pack_value (bp
, DECL_VISIBILITY_SPECIFIED (expr
), 1);
458 if (TREE_CODE (expr
) == VAR_DECL
)
460 bp_pack_value (bp
, DECL_HARD_REGISTER (expr
), 1);
461 bp_pack_value (bp
, DECL_IN_TEXT_SECTION (expr
), 1);
462 bp_pack_value (bp
, DECL_IN_CONSTANT_POOL (expr
), 1);
463 bp_pack_value (bp
, DECL_TLS_MODEL (expr
), 3);
466 if (VAR_OR_FUNCTION_DECL_P (expr
))
467 bp_pack_value (bp
, DECL_INIT_PRIORITY (expr
), HOST_BITS_PER_SHORT
);
471 /* Pack all the non-pointer fields of the TS_FUNCTION_DECL structure
472 of expression EXPR into bitpack BP. */
475 pack_ts_function_decl_value_fields (struct bitpack_d
*bp
, tree expr
)
477 /* For normal/md builtins we only write the class and code, so they
478 should never be handled here. */
479 gcc_assert (!lto_stream_as_builtin_p (expr
));
481 bp_pack_value (bp
, DECL_FUNCTION_CODE (expr
), 11);
482 bp_pack_value (bp
, DECL_BUILT_IN_CLASS (expr
), 2);
483 bp_pack_value (bp
, DECL_STATIC_CONSTRUCTOR (expr
), 1);
484 bp_pack_value (bp
, DECL_STATIC_DESTRUCTOR (expr
), 1);
485 bp_pack_value (bp
, DECL_UNINLINABLE (expr
), 1);
486 bp_pack_value (bp
, DECL_POSSIBLY_INLINED (expr
), 1);
487 bp_pack_value (bp
, DECL_IS_NOVOPS (expr
), 1);
488 bp_pack_value (bp
, DECL_IS_RETURNS_TWICE (expr
), 1);
489 bp_pack_value (bp
, DECL_IS_MALLOC (expr
), 1);
490 bp_pack_value (bp
, DECL_IS_OPERATOR_NEW (expr
), 1);
491 bp_pack_value (bp
, DECL_DECLARED_INLINE_P (expr
), 1);
492 bp_pack_value (bp
, DECL_STATIC_CHAIN (expr
), 1);
493 bp_pack_value (bp
, DECL_NO_INLINE_WARNING_P (expr
), 1);
494 bp_pack_value (bp
, DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (expr
), 1);
495 bp_pack_value (bp
, DECL_NO_LIMIT_STACK (expr
), 1);
496 bp_pack_value (bp
, DECL_DISREGARD_INLINE_LIMITS (expr
), 1);
497 bp_pack_value (bp
, DECL_PURE_P (expr
), 1);
498 bp_pack_value (bp
, DECL_LOOPING_CONST_OR_PURE_P (expr
), 1);
499 if (DECL_STATIC_DESTRUCTOR (expr
))
500 bp_pack_value (bp
, DECL_FINI_PRIORITY (expr
), HOST_BITS_PER_SHORT
);
504 /* Pack all the non-pointer fields of the TS_TYPE structure
505 of expression EXPR into bitpack BP. */
508 pack_ts_type_value_fields (struct bitpack_d
*bp
, tree expr
)
510 bp_pack_value (bp
, TYPE_PRECISION (expr
), 10);
511 bp_pack_value (bp
, TYPE_MODE (expr
), 8);
512 bp_pack_value (bp
, TYPE_STRING_FLAG (expr
), 1);
513 bp_pack_value (bp
, TYPE_NO_FORCE_BLK (expr
), 1);
514 bp_pack_value (bp
, TYPE_NEEDS_CONSTRUCTING (expr
), 1);
515 if (RECORD_OR_UNION_TYPE_P (expr
))
516 bp_pack_value (bp
, TYPE_TRANSPARENT_AGGR (expr
), 1);
517 bp_pack_value (bp
, TYPE_PACKED (expr
), 1);
518 bp_pack_value (bp
, TYPE_RESTRICT (expr
), 1);
519 bp_pack_value (bp
, TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr
), 2);
520 bp_pack_value (bp
, TYPE_USER_ALIGN (expr
), 1);
521 bp_pack_value (bp
, TYPE_READONLY (expr
), 1);
522 bp_pack_value (bp
, TYPE_ALIGN (expr
), HOST_BITS_PER_INT
);
523 bp_pack_value (bp
, TYPE_ALIAS_SET (expr
) == 0 ? 0 : -1, HOST_BITS_PER_INT
);
527 /* Pack all the non-pointer fields of the TS_BLOCK structure
528 of expression EXPR into bitpack BP. */
531 pack_ts_block_value_fields (struct bitpack_d
*bp
, tree expr
)
533 bp_pack_value (bp
, BLOCK_ABSTRACT (expr
), 1);
534 bp_pack_value (bp
, BLOCK_NUMBER (expr
), 31);
537 /* Pack all the non-pointer fields of the TS_TRANSLATION_UNIT_DECL structure
538 of expression EXPR into bitpack BP. */
541 pack_ts_translation_unit_decl_value_fields (struct bitpack_d
*bp ATTRIBUTE_UNUSED
, tree expr ATTRIBUTE_UNUSED
)
545 /* Pack all the non-pointer fields in EXPR into a bit pack. */
548 pack_value_fields (struct bitpack_d
*bp
, tree expr
)
552 code
= TREE_CODE (expr
);
554 /* Note that all these functions are highly sensitive to changes in
555 the types and sizes of each of the fields being packed. */
556 pack_ts_base_value_fields (bp
, expr
);
558 if (CODE_CONTAINS_STRUCT (code
, TS_REAL_CST
))
559 pack_ts_real_cst_value_fields (bp
, expr
);
561 if (CODE_CONTAINS_STRUCT (code
, TS_FIXED_CST
))
562 pack_ts_fixed_cst_value_fields (bp
, expr
);
564 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
565 pack_ts_decl_common_value_fields (bp
, expr
);
567 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WRTL
))
568 pack_ts_decl_wrtl_value_fields (bp
, expr
);
570 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
571 pack_ts_decl_with_vis_value_fields (bp
, expr
);
573 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
574 pack_ts_function_decl_value_fields (bp
, expr
);
576 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE
))
577 pack_ts_type_value_fields (bp
, expr
);
579 if (CODE_CONTAINS_STRUCT (code
, TS_BLOCK
))
580 pack_ts_block_value_fields (bp
, expr
);
582 if (CODE_CONTAINS_STRUCT (code
, TS_SSA_NAME
))
584 /* We only stream the version number of SSA names. */
588 if (CODE_CONTAINS_STRUCT (code
, TS_STATEMENT_LIST
))
590 /* This is only used by GENERIC. */
594 if (CODE_CONTAINS_STRUCT (code
, TS_OMP_CLAUSE
))
596 /* This is only used by High GIMPLE. */
600 if (CODE_CONTAINS_STRUCT (code
, TS_TRANSLATION_UNIT_DECL
))
601 pack_ts_translation_unit_decl_value_fields (bp
, expr
);
605 /* Emit location LOC to output block OB. */
608 lto_output_location (struct output_block
*ob
, location_t loc
)
610 expanded_location xloc
;
612 if (loc
== UNKNOWN_LOCATION
)
614 output_string (ob
, ob
->main_stream
, NULL
);
618 xloc
= expand_location (loc
);
620 output_string (ob
, ob
->main_stream
, xloc
.file
);
621 output_sleb128 (ob
, xloc
.line
);
622 output_sleb128 (ob
, xloc
.column
);
623 output_sleb128 (ob
, xloc
.sysp
);
625 ob
->current_file
= xloc
.file
;
626 ob
->current_line
= xloc
.line
;
627 ob
->current_col
= xloc
.column
;
631 /* Return true if tree node T is written to various tables. For these
632 nodes, we sometimes want to write their phyiscal representation
633 (via lto_output_tree), and sometimes we need to emit an index
634 reference into a table (via lto_output_tree_ref). */
637 tree_is_indexable (tree t
)
639 if (TREE_CODE (t
) == PARM_DECL
)
641 else if (TREE_CODE (t
) == VAR_DECL
&& decl_function_context (t
)
645 return (TYPE_P (t
) || DECL_P (t
) || TREE_CODE (t
) == SSA_NAME
);
649 /* If EXPR is an indexable tree node, output a reference to it to
650 output block OB. Otherwise, output the physical representation of
654 lto_output_tree_ref (struct output_block
*ob
, tree expr
)
658 if (expr
== NULL_TREE
)
664 if (!tree_is_indexable (expr
))
666 /* Even though we are emitting the physical representation of
667 EXPR, its leaves must be emitted as references. */
668 lto_output_tree (ob
, expr
, true);
674 output_type_ref (ob
, expr
);
678 code
= TREE_CODE (expr
);
682 output_record_start (ob
, LTO_ssa_name_ref
);
683 output_uleb128 (ob
, SSA_NAME_VERSION (expr
));
687 output_record_start (ob
, LTO_field_decl_ref
);
688 lto_output_field_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
692 output_record_start (ob
, LTO_function_decl_ref
);
693 lto_output_fn_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
697 case DEBUG_EXPR_DECL
:
698 gcc_assert (decl_function_context (expr
) == NULL
699 || TREE_STATIC (expr
));
700 output_record_start (ob
, LTO_global_decl_ref
);
701 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
705 output_record_start (ob
, LTO_const_decl_ref
);
706 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
710 gcc_assert (decl_function_context (expr
) == NULL
);
711 output_record_start (ob
, LTO_imported_decl_ref
);
712 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
716 output_record_start (ob
, LTO_type_decl_ref
);
717 lto_output_type_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
721 output_record_start (ob
, LTO_namespace_decl_ref
);
722 lto_output_namespace_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
726 output_record_start (ob
, LTO_label_decl_ref
);
727 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
731 output_record_start (ob
, LTO_result_decl_ref
);
732 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
735 case TRANSLATION_UNIT_DECL
:
736 output_record_start (ob
, LTO_translation_unit_decl_ref
);
737 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
741 /* No other node is indexable, so it should have been handled
742 by lto_output_tree. */
748 /* If REF_P is true, emit a reference to EXPR in output block OB,
749 otherwise emit the physical representation of EXPR in OB. */
752 lto_output_tree_or_ref (struct output_block
*ob
, tree expr
, bool ref_p
)
755 lto_output_tree_ref (ob
, expr
);
757 lto_output_tree (ob
, expr
, false);
761 /* Emit the chain of tree nodes starting at T. OB is the output block
762 to write to. REF_P is true if chain elements should be emitted
766 lto_output_chain (struct output_block
*ob
, tree t
, bool ref_p
)
770 count
= list_length (t
);
771 output_sleb128 (ob
, count
);
772 for (i
= 0; i
< count
; i
++)
776 /* Clear TREE_CHAIN to avoid blindly recursing into the rest
778 saved_chain
= TREE_CHAIN (t
);
779 TREE_CHAIN (t
) = NULL_TREE
;
781 lto_output_tree_or_ref (ob
, t
, ref_p
);
783 TREE_CHAIN (t
) = saved_chain
;
789 /* Write all pointer fields in the TS_COMMON structure of EXPR to output
790 block OB. If REF_P is true, write a reference to EXPR's pointer
794 lto_output_ts_common_tree_pointers (struct output_block
*ob
, tree expr
,
797 if (TREE_CODE (expr
) != IDENTIFIER_NODE
)
798 lto_output_tree_or_ref (ob
, TREE_TYPE (expr
), ref_p
);
802 /* Write all pointer fields in the TS_VECTOR structure of EXPR to output
803 block OB. If REF_P is true, write a reference to EXPR's pointer
807 lto_output_ts_vector_tree_pointers (struct output_block
*ob
, tree expr
,
810 lto_output_chain (ob
, TREE_VECTOR_CST_ELTS (expr
), ref_p
);
814 /* Write all pointer fields in the TS_COMPLEX structure of EXPR to output
815 block OB. If REF_P is true, write a reference to EXPR's pointer
819 lto_output_ts_complex_tree_pointers (struct output_block
*ob
, tree expr
,
822 lto_output_tree_or_ref (ob
, TREE_REALPART (expr
), ref_p
);
823 lto_output_tree_or_ref (ob
, TREE_IMAGPART (expr
), ref_p
);
827 /* Write all pointer fields in the TS_DECL_MINIMAL structure of EXPR
828 to output block OB. If REF_P is true, write a reference to EXPR's
832 lto_output_ts_decl_minimal_tree_pointers (struct output_block
*ob
, tree expr
,
835 lto_output_tree_or_ref (ob
, DECL_NAME (expr
), ref_p
);
836 lto_output_tree_or_ref (ob
, DECL_CONTEXT (expr
), ref_p
);
837 lto_output_location (ob
, DECL_SOURCE_LOCATION (expr
));
841 /* Write all pointer fields in the TS_DECL_COMMON structure of EXPR to
842 output block OB. If REF_P is true, write a reference to EXPR's
846 lto_output_ts_decl_common_tree_pointers (struct output_block
*ob
, tree expr
,
849 lto_output_tree_or_ref (ob
, DECL_SIZE (expr
), ref_p
);
850 lto_output_tree_or_ref (ob
, DECL_SIZE_UNIT (expr
), ref_p
);
852 if (TREE_CODE (expr
) != FUNCTION_DECL
)
854 tree initial
= DECL_INITIAL (expr
);
855 if (TREE_CODE (expr
) == VAR_DECL
856 && (TREE_STATIC (expr
) || DECL_EXTERNAL (expr
))
859 lto_varpool_encoder_t varpool_encoder
= ob
->decl_state
->varpool_node_encoder
;
860 struct varpool_node
*vnode
= varpool_get_node (expr
);
862 initial
= error_mark_node
;
863 else if (!lto_varpool_encoder_encode_initializer_p (varpool_encoder
,
868 lto_output_tree_or_ref (ob
, initial
, ref_p
);
871 lto_output_tree_or_ref (ob
, DECL_ATTRIBUTES (expr
), ref_p
);
872 lto_output_tree_or_ref (ob
, DECL_ABSTRACT_ORIGIN (expr
), ref_p
);
874 if (TREE_CODE (expr
) == PARM_DECL
)
875 lto_output_chain (ob
, TREE_CHAIN (expr
), ref_p
);
877 if ((TREE_CODE (expr
) == VAR_DECL
878 || TREE_CODE (expr
) == PARM_DECL
)
879 && DECL_HAS_VALUE_EXPR_P (expr
))
880 lto_output_tree_or_ref (ob
, DECL_VALUE_EXPR (expr
), ref_p
);
882 if (TREE_CODE (expr
) == VAR_DECL
)
883 lto_output_tree_or_ref (ob
, DECL_DEBUG_EXPR (expr
), ref_p
);
887 /* Write all pointer fields in the TS_DECL_NON_COMMON structure of
888 EXPR to output block OB. If REF_P is true, write a reference to EXPR's
892 lto_output_ts_decl_non_common_tree_pointers (struct output_block
*ob
,
893 tree expr
, bool ref_p
)
895 if (TREE_CODE (expr
) == FUNCTION_DECL
)
897 /* DECL_SAVED_TREE holds the GENERIC representation for DECL.
898 At this point, it should not exist. Either because it was
899 converted to gimple or because DECL didn't have a GENERIC
900 representation in this TU. */
901 gcc_assert (DECL_SAVED_TREE (expr
) == NULL_TREE
);
902 lto_output_tree_or_ref (ob
, DECL_ARGUMENTS (expr
), ref_p
);
903 lto_output_tree_or_ref (ob
, DECL_RESULT (expr
), ref_p
);
905 lto_output_tree_or_ref (ob
, DECL_VINDEX (expr
), ref_p
);
909 /* Write all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
910 to output block OB. If REF_P is true, write a reference to EXPR's
914 lto_output_ts_decl_with_vis_tree_pointers (struct output_block
*ob
, tree expr
,
917 /* Make sure we don't inadvertently set the assembler name. */
918 if (DECL_ASSEMBLER_NAME_SET_P (expr
))
919 lto_output_tree_or_ref (ob
, DECL_ASSEMBLER_NAME (expr
), ref_p
);
923 lto_output_tree_or_ref (ob
, DECL_SECTION_NAME (expr
), ref_p
);
924 lto_output_tree_or_ref (ob
, DECL_COMDAT_GROUP (expr
), ref_p
);
928 /* Write all pointer fields in the TS_FIELD_DECL structure of EXPR to
929 output block OB. If REF_P is true, write a reference to EXPR's
933 lto_output_ts_field_decl_tree_pointers (struct output_block
*ob
, tree expr
,
936 lto_output_tree_or_ref (ob
, DECL_FIELD_OFFSET (expr
), ref_p
);
937 lto_output_tree_or_ref (ob
, DECL_BIT_FIELD_TYPE (expr
), ref_p
);
938 lto_output_tree_or_ref (ob
, DECL_QUALIFIER (expr
), ref_p
);
939 lto_output_tree_or_ref (ob
, DECL_FIELD_BIT_OFFSET (expr
), ref_p
);
940 lto_output_tree_or_ref (ob
, DECL_FCONTEXT (expr
), ref_p
);
941 lto_output_chain (ob
, TREE_CHAIN (expr
), ref_p
);
945 /* Write all pointer fields in the TS_FUNCTION_DECL structure of EXPR
946 to output block OB. If REF_P is true, write a reference to EXPR's
950 lto_output_ts_function_decl_tree_pointers (struct output_block
*ob
, tree expr
,
953 /* DECL_STRUCT_FUNCTION is handled by lto_output_function. FIXME lto,
954 maybe it should be handled here? */
955 lto_output_tree_or_ref (ob
, DECL_FUNCTION_PERSONALITY (expr
), ref_p
);
956 lto_output_tree_or_ref (ob
, DECL_FUNCTION_SPECIFIC_TARGET (expr
), ref_p
);
957 lto_output_tree_or_ref (ob
, DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr
),
962 /* Write all pointer fields in the TS_TYPE structure of EXPR to output
963 block OB. If REF_P is true, write a reference to EXPR's pointer
967 lto_output_ts_type_tree_pointers (struct output_block
*ob
, tree expr
,
970 if (TREE_CODE (expr
) == ENUMERAL_TYPE
)
971 lto_output_tree_or_ref (ob
, TYPE_VALUES (expr
), ref_p
);
972 else if (TREE_CODE (expr
) == ARRAY_TYPE
)
973 lto_output_tree_or_ref (ob
, TYPE_DOMAIN (expr
), ref_p
);
974 else if (RECORD_OR_UNION_TYPE_P (expr
))
975 lto_output_tree_or_ref (ob
, TYPE_FIELDS (expr
), ref_p
);
976 else if (TREE_CODE (expr
) == FUNCTION_TYPE
977 || TREE_CODE (expr
) == METHOD_TYPE
)
978 lto_output_tree_or_ref (ob
, TYPE_ARG_TYPES (expr
), ref_p
);
980 lto_output_tree_or_ref (ob
, TYPE_SIZE (expr
), ref_p
);
981 lto_output_tree_or_ref (ob
, TYPE_SIZE_UNIT (expr
), ref_p
);
982 lto_output_tree_or_ref (ob
, TYPE_ATTRIBUTES (expr
), ref_p
);
983 lto_output_tree_or_ref (ob
, TYPE_NAME (expr
), ref_p
);
984 /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO nor
985 TYPE_NEXT_PTR_TO or TYPE_NEXT_REF_TO. */
986 if (!POINTER_TYPE_P (expr
))
987 lto_output_tree_or_ref (ob
, TYPE_MINVAL (expr
), ref_p
);
988 lto_output_tree_or_ref (ob
, TYPE_MAXVAL (expr
), ref_p
);
989 lto_output_tree_or_ref (ob
, TYPE_MAIN_VARIANT (expr
), ref_p
);
990 /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
992 if (RECORD_OR_UNION_TYPE_P (expr
))
993 lto_output_tree_or_ref (ob
, TYPE_BINFO (expr
), ref_p
);
994 lto_output_tree_or_ref (ob
, TYPE_CONTEXT (expr
), ref_p
);
995 /* TYPE_CANONICAL is re-computed during type merging, so no need
996 to stream it here. */
997 lto_output_tree_or_ref (ob
, TYPE_STUB_DECL (expr
), ref_p
);
1001 /* Write all pointer fields in the TS_LIST structure of EXPR to output
1002 block OB. If REF_P is true, write a reference to EXPR's pointer
1006 lto_output_ts_list_tree_pointers (struct output_block
*ob
, tree expr
,
1009 lto_output_tree_or_ref (ob
, TREE_PURPOSE (expr
), ref_p
);
1010 lto_output_tree_or_ref (ob
, TREE_VALUE (expr
), ref_p
);
1011 lto_output_chain (ob
, TREE_CHAIN (expr
), ref_p
);
1015 /* Write all pointer fields in the TS_VEC structure of EXPR to output
1016 block OB. If REF_P is true, write a reference to EXPR's pointer
1020 lto_output_ts_vec_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
1024 /* Note that the number of slots for EXPR has already been emitted
1025 in EXPR's header (see lto_output_tree_header). */
1026 for (i
= 0; i
< TREE_VEC_LENGTH (expr
); i
++)
1027 lto_output_tree_or_ref (ob
, TREE_VEC_ELT (expr
, i
), ref_p
);
1031 /* Write all pointer fields in the TS_EXP structure of EXPR to output
1032 block OB. If REF_P is true, write a reference to EXPR's pointer
1036 lto_output_ts_exp_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
1040 output_sleb128 (ob
, TREE_OPERAND_LENGTH (expr
));
1041 for (i
= 0; i
< TREE_OPERAND_LENGTH (expr
); i
++)
1042 lto_output_tree_or_ref (ob
, TREE_OPERAND (expr
, i
), ref_p
);
1043 lto_output_location (ob
, EXPR_LOCATION (expr
));
1044 lto_output_tree_or_ref (ob
, TREE_BLOCK (expr
), ref_p
);
1048 /* Write all pointer fields in the TS_BLOCK structure of EXPR to output
1049 block OB. If REF_P is true, write a reference to EXPR's pointer
1053 lto_output_ts_block_tree_pointers (struct output_block
*ob
, tree expr
,
1059 lto_output_location (ob
, BLOCK_SOURCE_LOCATION (expr
));
1060 lto_output_chain (ob
, BLOCK_VARS (expr
), ref_p
);
1062 output_uleb128 (ob
, VEC_length (tree
, BLOCK_NONLOCALIZED_VARS (expr
)));
1063 FOR_EACH_VEC_ELT (tree
, BLOCK_NONLOCALIZED_VARS (expr
), i
, t
)
1065 gcc_assert (DECL_CONTEXT (t
) != expr
);
1066 lto_output_tree_or_ref (ob
, t
, ref_p
);
1069 lto_output_tree_or_ref (ob
, BLOCK_SUPERCONTEXT (expr
), ref_p
);
1070 lto_output_tree_or_ref (ob
, BLOCK_ABSTRACT_ORIGIN (expr
), ref_p
);
1071 lto_output_tree_or_ref (ob
, BLOCK_FRAGMENT_ORIGIN (expr
), ref_p
);
1072 lto_output_tree_or_ref (ob
, BLOCK_FRAGMENT_CHAIN (expr
), ref_p
);
1073 /* Do not output BLOCK_SUBBLOCKS. Instead on streaming-in this
1074 list is re-constructed from BLOCK_SUPERCONTEXT. */
1078 /* Write all pointer fields in the TS_BINFO structure of EXPR to output
1079 block OB. If REF_P is true, write a reference to EXPR's pointer
1083 lto_output_ts_binfo_tree_pointers (struct output_block
*ob
, tree expr
,
1089 /* Note that the number of BINFO slots has already been emitted in
1090 EXPR's header (see lto_output_tree_header) because this length
1091 is needed to build the empty BINFO node on the reader side. */
1092 FOR_EACH_VEC_ELT (tree
, BINFO_BASE_BINFOS (expr
), i
, t
)
1093 lto_output_tree_or_ref (ob
, t
, ref_p
);
1096 lto_output_tree_or_ref (ob
, BINFO_OFFSET (expr
), ref_p
);
1097 lto_output_tree_or_ref (ob
, BINFO_VTABLE (expr
), ref_p
);
1098 lto_output_tree_or_ref (ob
, BINFO_VIRTUALS (expr
), ref_p
);
1099 lto_output_tree_or_ref (ob
, BINFO_VPTR_FIELD (expr
), ref_p
);
1101 output_uleb128 (ob
, VEC_length (tree
, BINFO_BASE_ACCESSES (expr
)));
1102 FOR_EACH_VEC_ELT (tree
, BINFO_BASE_ACCESSES (expr
), i
, t
)
1103 lto_output_tree_or_ref (ob
, t
, ref_p
);
1105 lto_output_tree_or_ref (ob
, BINFO_INHERITANCE_CHAIN (expr
), ref_p
);
1106 lto_output_tree_or_ref (ob
, BINFO_SUBVTT_INDEX (expr
), ref_p
);
1107 lto_output_tree_or_ref (ob
, BINFO_VPTR_INDEX (expr
), ref_p
);
1111 /* Write all pointer fields in the TS_CONSTRUCTOR structure of EXPR to
1112 output block OB. If REF_P is true, write a reference to EXPR's
1116 lto_output_ts_constructor_tree_pointers (struct output_block
*ob
, tree expr
,
1122 output_uleb128 (ob
, CONSTRUCTOR_NELTS (expr
));
1123 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (expr
), i
, index
, value
)
1125 lto_output_tree_or_ref (ob
, index
, ref_p
);
1126 lto_output_tree_or_ref (ob
, value
, ref_p
);
1130 /* Write a TS_TARGET_OPTION tree in EXPR to OB. */
1133 lto_output_ts_target_option (struct output_block
*ob
, tree expr
)
1135 struct cl_target_option
*t
= TREE_TARGET_OPTION (expr
);
1136 struct bitpack_d bp
;
1139 /* The cl_target_option is target specific and generated by the options
1140 awk script, so we just recreate a byte-by-byte copy here. */
1142 bp
= bitpack_create (ob
->main_stream
);
1143 len
= sizeof (struct cl_target_option
);
1144 for (i
= 0; i
< len
; i
++)
1145 bp_pack_value (&bp
, ((unsigned char *)t
)[i
], 8);
1146 /* Catch struct size mismatches between reader and writer. */
1147 bp_pack_value (&bp
, 0x12345678, 32);
1148 lto_output_bitpack (&bp
);
1151 /* Write a TS_TRANSLATION_UNIT_DECL tree in EXPR to OB. */
1154 lto_output_ts_translation_unit_decl_tree_pointers (struct output_block
*ob
,
1157 output_string (ob
, ob
->main_stream
, TRANSLATION_UNIT_LANGUAGE (expr
));
1160 /* Helper for lto_output_tree. Write all pointer fields in EXPR to output
1161 block OB. If REF_P is true, the leaves of EXPR are emitted as
1165 lto_output_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
1167 enum tree_code code
;
1169 code
= TREE_CODE (expr
);
1171 if (CODE_CONTAINS_STRUCT (code
, TS_COMMON
))
1172 lto_output_ts_common_tree_pointers (ob
, expr
, ref_p
);
1174 if (CODE_CONTAINS_STRUCT (code
, TS_VECTOR
))
1175 lto_output_ts_vector_tree_pointers (ob
, expr
, ref_p
);
1177 if (CODE_CONTAINS_STRUCT (code
, TS_COMPLEX
))
1178 lto_output_ts_complex_tree_pointers (ob
, expr
, ref_p
);
1180 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
1181 lto_output_ts_decl_minimal_tree_pointers (ob
, expr
, ref_p
);
1183 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
1184 lto_output_ts_decl_common_tree_pointers (ob
, expr
, ref_p
);
1186 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_NON_COMMON
))
1187 lto_output_ts_decl_non_common_tree_pointers (ob
, expr
, ref_p
);
1189 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
1190 lto_output_ts_decl_with_vis_tree_pointers (ob
, expr
, ref_p
);
1192 if (CODE_CONTAINS_STRUCT (code
, TS_FIELD_DECL
))
1193 lto_output_ts_field_decl_tree_pointers (ob
, expr
, ref_p
);
1195 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
1196 lto_output_ts_function_decl_tree_pointers (ob
, expr
, ref_p
);
1198 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE
))
1199 lto_output_ts_type_tree_pointers (ob
, expr
, ref_p
);
1201 if (CODE_CONTAINS_STRUCT (code
, TS_LIST
))
1202 lto_output_ts_list_tree_pointers (ob
, expr
, ref_p
);
1204 if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
1205 lto_output_ts_vec_tree_pointers (ob
, expr
, ref_p
);
1207 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
1208 lto_output_ts_exp_tree_pointers (ob
, expr
, ref_p
);
1210 if (CODE_CONTAINS_STRUCT (code
, TS_SSA_NAME
))
1212 /* We only stream the version number of SSA names. */
1216 if (CODE_CONTAINS_STRUCT (code
, TS_BLOCK
))
1217 lto_output_ts_block_tree_pointers (ob
, expr
, ref_p
);
1219 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
1220 lto_output_ts_binfo_tree_pointers (ob
, expr
, ref_p
);
1222 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
1223 lto_output_ts_constructor_tree_pointers (ob
, expr
, ref_p
);
1225 if (CODE_CONTAINS_STRUCT (code
, TS_STATEMENT_LIST
))
1227 /* This should only appear in GENERIC. */
1231 if (CODE_CONTAINS_STRUCT (code
, TS_OMP_CLAUSE
))
1233 /* This should only appear in High GIMPLE. */
1237 if (CODE_CONTAINS_STRUCT (code
, TS_OPTIMIZATION
))
1238 sorry ("gimple bytecode streams do not support the optimization attribute");
1240 if (CODE_CONTAINS_STRUCT (code
, TS_TARGET_OPTION
))
1241 lto_output_ts_target_option (ob
, expr
);
1243 if (CODE_CONTAINS_STRUCT (code
, TS_TRANSLATION_UNIT_DECL
))
1244 lto_output_ts_translation_unit_decl_tree_pointers (ob
, expr
);
1248 /* Emit header information for tree EXPR to output block OB. The header
1249 contains everything needed to instantiate an empty skeleton for
1250 EXPR on the reading side. IX is the index into the streamer cache
1251 where EXPR is stored. REF_P is as in lto_output_tree. */
1254 lto_output_tree_header (struct output_block
*ob
, tree expr
, int ix
)
1257 enum tree_code code
;
1259 /* We should not see any non-GIMPLE tree nodes here. */
1260 code
= TREE_CODE (expr
);
1261 if (!lto_is_streamable (expr
))
1262 internal_error ("tree code %qs is not supported in gimple streams",
1263 tree_code_name
[code
]);
1265 /* The header of a tree node consists of its tag, the size of
1266 the node, and any other information needed to instantiate
1267 EXPR on the reading side (such as the number of slots in
1268 variable sized nodes). */
1269 tag
= lto_tree_code_to_tag (code
);
1270 output_record_start (ob
, tag
);
1271 output_sleb128 (ob
, ix
);
1273 /* The following will cause bootstrap miscomparisons. Enable with care. */
1274 #ifdef LTO_STREAMER_DEBUG
1275 /* This is used mainly for debugging purposes. When the reader
1276 and the writer do not agree on a streamed node, the pointer
1277 value for EXPR can be used to track down the differences in
1279 gcc_assert ((HOST_WIDEST_INT
) (intptr_t) expr
== (intptr_t) expr
);
1280 output_sleb128 (ob
, (HOST_WIDEST_INT
) (intptr_t) expr
);
1283 /* The text in strings and identifiers are completely emitted in
1285 if (CODE_CONTAINS_STRUCT (code
, TS_STRING
))
1286 output_string_cst (ob
, ob
->main_stream
, expr
);
1287 else if (CODE_CONTAINS_STRUCT (code
, TS_IDENTIFIER
))
1288 output_identifier (ob
, ob
->main_stream
, expr
);
1289 else if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
1290 output_sleb128 (ob
, TREE_VEC_LENGTH (expr
));
1291 else if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
1292 output_uleb128 (ob
, BINFO_N_BASE_BINFOS (expr
));
1296 /* Write the code and class of builtin EXPR to output block OB. IX is
1297 the index into the streamer cache where EXPR is stored.*/
1300 lto_output_builtin_tree (struct output_block
*ob
, tree expr
, int ix
)
1302 gcc_assert (lto_stream_as_builtin_p (expr
));
1304 if (DECL_BUILT_IN_CLASS (expr
) == BUILT_IN_MD
1305 && !targetm
.builtin_decl
)
1306 sorry ("gimple bytecode streams do not support machine specific builtin "
1307 "functions on this target");
1309 output_record_start (ob
, LTO_builtin_decl
);
1310 output_uleb128 (ob
, DECL_BUILT_IN_CLASS (expr
));
1311 output_uleb128 (ob
, DECL_FUNCTION_CODE (expr
));
1312 output_sleb128 (ob
, ix
);
1314 if (DECL_ASSEMBLER_NAME_SET_P (expr
))
1316 /* When the assembler name of a builtin gets a user name,
1317 the new name is always prefixed with '*' by
1318 set_builtin_user_assembler_name. So, to prevent the
1319 reader side from adding a second '*', we omit it here. */
1320 const char *str
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (expr
));
1321 if (strlen (str
) > 1 && str
[0] == '*')
1322 output_string (ob
, ob
->main_stream
, &str
[1]);
1324 output_string (ob
, ob
->main_stream
, NULL
);
1327 output_string (ob
, ob
->main_stream
, NULL
);
1331 /* Write a physical representation of tree node EXPR to output block
1332 OB. If REF_P is true, the leaves of EXPR are emitted as references
1333 via lto_output_tree_ref. IX is the index into the streamer cache
1334 where EXPR is stored. */
1337 lto_write_tree (struct output_block
*ob
, tree expr
, bool ref_p
, int ix
)
1339 struct bitpack_d bp
;
1341 /* Write the header, containing everything needed to materialize
1342 EXPR on the reading side. */
1343 lto_output_tree_header (ob
, expr
, ix
);
1345 /* Pack all the non-pointer fields in EXPR into a bitpack and write
1346 the resulting bitpack. */
1347 bp
= bitpack_create (ob
->main_stream
);
1348 pack_value_fields (&bp
, expr
);
1349 lto_output_bitpack (&bp
);
1351 /* Write all the pointer fields in EXPR. */
1352 lto_output_tree_pointers (ob
, expr
, ref_p
);
1354 /* Mark the end of EXPR. */
1359 /* Emit the integer constant CST to output block OB. If REF_P is true,
1360 CST's type will be emitted as a reference. */
1363 lto_output_integer_cst (struct output_block
*ob
, tree cst
, bool ref_p
)
1365 output_record_start (ob
, lto_tree_code_to_tag (INTEGER_CST
));
1366 lto_output_tree_or_ref (ob
, TREE_TYPE (cst
), ref_p
);
1367 lto_output_1_stream (ob
->main_stream
, TREE_OVERFLOW_P (cst
));
1368 output_uleb128 (ob
, TREE_INT_CST_LOW (cst
));
1369 output_uleb128 (ob
, TREE_INT_CST_HIGH (cst
));
1373 /* Emit the physical representation of tree node EXPR to output block
1374 OB. If REF_P is true, the leaves of EXPR are emitted as references
1375 via lto_output_tree_ref. */
1378 lto_output_tree (struct output_block
*ob
, tree expr
, bool ref_p
)
1384 if (expr
== NULL_TREE
)
1390 /* INTEGER_CST nodes are special because they need their original type
1391 to be materialized by the reader (to implement TYPE_CACHED_VALUES). */
1392 if (TREE_CODE (expr
) == INTEGER_CST
)
1394 lto_output_integer_cst (ob
, expr
, ref_p
);
1398 /* Determine the offset in the stream where EXPR will be written.
1399 This is used when emitting pickle references so the reader knows
1400 where to reconstruct the pickled object from. This allows
1401 circular and forward references within the same stream. */
1402 offset
= ob
->main_stream
->total_size
;
1404 existed_p
= lto_streamer_cache_insert (ob
->writer_cache
, expr
, &ix
, &offset
);
1407 /* If a node has already been streamed out, make sure that
1408 we don't write it more than once. Otherwise, the reader
1409 will instantiate two different nodes for the same object. */
1410 output_record_start (ob
, LTO_tree_pickle_reference
);
1411 output_sleb128 (ob
, ix
);
1412 output_uleb128 (ob
, lto_tree_code_to_tag (TREE_CODE (expr
)));
1413 output_uleb128 (ob
, offset
);
1415 else if (lto_stream_as_builtin_p (expr
))
1417 /* MD and NORMAL builtins do not need to be written out
1418 completely as they are always instantiated by the
1419 compiler on startup. The only builtins that need to
1420 be written out are BUILT_IN_FRONTEND. For all other
1421 builtins, we simply write the class and code. */
1422 lto_output_builtin_tree (ob
, expr
, ix
);
1426 /* This is the first time we see EXPR, write its fields
1428 lto_write_tree (ob
, expr
, ref_p
, ix
);
1433 /* Output to OB a list of try/catch handlers starting with FIRST. */
1436 output_eh_try_list (struct output_block
*ob
, eh_catch first
)
1440 for (n
= first
; n
; n
= n
->next_catch
)
1442 output_record_start (ob
, LTO_eh_catch
);
1443 lto_output_tree_ref (ob
, n
->type_list
);
1444 lto_output_tree_ref (ob
, n
->filter_list
);
1445 lto_output_tree_ref (ob
, n
->label
);
1452 /* Output EH region R in function FN to OB. CURR_RN is the slot index
1453 that is being emitted in FN->EH->REGION_ARRAY. This is used to
1454 detect EH region sharing. */
1457 output_eh_region (struct output_block
*ob
, eh_region r
)
1467 if (r
->type
== ERT_CLEANUP
)
1468 tag
= LTO_ert_cleanup
;
1469 else if (r
->type
== ERT_TRY
)
1471 else if (r
->type
== ERT_ALLOWED_EXCEPTIONS
)
1472 tag
= LTO_ert_allowed_exceptions
;
1473 else if (r
->type
== ERT_MUST_NOT_THROW
)
1474 tag
= LTO_ert_must_not_throw
;
1478 output_record_start (ob
, tag
);
1479 output_sleb128 (ob
, r
->index
);
1482 output_sleb128 (ob
, r
->outer
->index
);
1487 output_sleb128 (ob
, r
->inner
->index
);
1492 output_sleb128 (ob
, r
->next_peer
->index
);
1496 if (r
->type
== ERT_TRY
)
1498 output_eh_try_list (ob
, r
->u
.eh_try
.first_catch
);
1500 else if (r
->type
== ERT_ALLOWED_EXCEPTIONS
)
1502 lto_output_tree_ref (ob
, r
->u
.allowed
.type_list
);
1503 lto_output_tree_ref (ob
, r
->u
.allowed
.label
);
1504 output_uleb128 (ob
, r
->u
.allowed
.filter
);
1506 else if (r
->type
== ERT_MUST_NOT_THROW
)
1508 lto_output_tree_ref (ob
, r
->u
.must_not_throw
.failure_decl
);
1509 lto_output_location (ob
, r
->u
.must_not_throw
.failure_loc
);
1512 if (r
->landing_pads
)
1513 output_sleb128 (ob
, r
->landing_pads
->index
);
1519 /* Output landing pad LP to OB. */
1522 output_eh_lp (struct output_block
*ob
, eh_landing_pad lp
)
1530 output_record_start (ob
, LTO_eh_landing_pad
);
1531 output_sleb128 (ob
, lp
->index
);
1533 output_sleb128 (ob
, lp
->next_lp
->index
);
1538 output_sleb128 (ob
, lp
->region
->index
);
1542 lto_output_tree_ref (ob
, lp
->post_landing_pad
);
1546 /* Output the existing eh_table to OB. */
1549 output_eh_regions (struct output_block
*ob
, struct function
*fn
)
1551 if (fn
->eh
&& fn
->eh
->region_tree
)
1558 output_record_start (ob
, LTO_eh_table
);
1560 /* Emit the index of the root of the EH region tree. */
1561 output_sleb128 (ob
, fn
->eh
->region_tree
->index
);
1563 /* Emit all the EH regions in the region array. */
1564 output_sleb128 (ob
, VEC_length (eh_region
, fn
->eh
->region_array
));
1565 FOR_EACH_VEC_ELT (eh_region
, fn
->eh
->region_array
, i
, eh
)
1566 output_eh_region (ob
, eh
);
1568 /* Emit all landing pads. */
1569 output_sleb128 (ob
, VEC_length (eh_landing_pad
, fn
->eh
->lp_array
));
1570 FOR_EACH_VEC_ELT (eh_landing_pad
, fn
->eh
->lp_array
, i
, lp
)
1571 output_eh_lp (ob
, lp
);
1573 /* Emit all the runtime type data. */
1574 output_sleb128 (ob
, VEC_length (tree
, fn
->eh
->ttype_data
));
1575 FOR_EACH_VEC_ELT (tree
, fn
->eh
->ttype_data
, i
, ttype
)
1576 lto_output_tree_ref (ob
, ttype
);
1578 /* Emit the table of action chains. */
1579 if (targetm
.arm_eabi_unwinder
)
1582 output_sleb128 (ob
, VEC_length (tree
, fn
->eh
->ehspec_data
.arm_eabi
));
1583 FOR_EACH_VEC_ELT (tree
, fn
->eh
->ehspec_data
.arm_eabi
, i
, t
)
1584 lto_output_tree_ref (ob
, t
);
1589 output_sleb128 (ob
, VEC_length (uchar
, fn
->eh
->ehspec_data
.other
));
1590 FOR_EACH_VEC_ELT (uchar
, fn
->eh
->ehspec_data
.other
, i
, c
)
1591 lto_output_1_stream (ob
->main_stream
, c
);
1595 /* The 0 either terminates the record or indicates that there are no
1596 eh_records at all. */
1601 /* Output all of the active ssa names to the ssa_names stream. */
1604 output_ssa_names (struct output_block
*ob
, struct function
*fn
)
1606 unsigned int i
, len
;
1608 len
= VEC_length (tree
, SSANAMES (fn
));
1609 output_uleb128 (ob
, len
);
1611 for (i
= 1; i
< len
; i
++)
1613 tree ptr
= VEC_index (tree
, SSANAMES (fn
), i
);
1615 if (ptr
== NULL_TREE
1616 || SSA_NAME_IN_FREE_LIST (ptr
)
1617 || !is_gimple_reg (ptr
))
1620 output_uleb128 (ob
, i
);
1621 lto_output_1_stream (ob
->main_stream
, SSA_NAME_IS_DEFAULT_DEF (ptr
));
1622 lto_output_tree_ref (ob
, SSA_NAME_VAR (ptr
));
1629 /* Output the cfg. */
1632 output_cfg (struct output_block
*ob
, struct function
*fn
)
1634 struct lto_output_stream
*tmp_stream
= ob
->main_stream
;
1637 ob
->main_stream
= ob
->cfg_stream
;
1639 output_uleb128 (ob
, profile_status_for_function (fn
));
1641 /* Output the number of the highest basic block. */
1642 output_uleb128 (ob
, last_basic_block_for_function (fn
));
1644 FOR_ALL_BB_FN (bb
, fn
)
1649 output_sleb128 (ob
, bb
->index
);
1651 /* Output the successors and the edge flags. */
1652 output_uleb128 (ob
, EDGE_COUNT (bb
->succs
));
1653 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
1655 output_uleb128 (ob
, e
->dest
->index
);
1656 output_sleb128 (ob
, e
->probability
);
1657 output_sleb128 (ob
, e
->count
);
1658 output_uleb128 (ob
, e
->flags
);
1662 output_sleb128 (ob
, -1);
1664 bb
= ENTRY_BLOCK_PTR
;
1667 output_sleb128 (ob
, bb
->next_bb
->index
);
1671 output_sleb128 (ob
, -1);
1673 ob
->main_stream
= tmp_stream
;
1677 /* Output PHI function PHI to the main stream in OB. */
1680 output_phi (struct output_block
*ob
, gimple phi
)
1682 unsigned i
, len
= gimple_phi_num_args (phi
);
1684 output_record_start (ob
, lto_gimple_code_to_tag (GIMPLE_PHI
));
1685 output_uleb128 (ob
, SSA_NAME_VERSION (PHI_RESULT (phi
)));
1687 for (i
= 0; i
< len
; i
++)
1689 lto_output_tree_ref (ob
, gimple_phi_arg_def (phi
, i
));
1690 output_uleb128 (ob
, gimple_phi_arg_edge (phi
, i
)->src
->index
);
1691 lto_output_location (ob
, gimple_phi_arg_location (phi
, i
));
1696 /* Emit statement STMT on the main stream of output block OB. */
1699 output_gimple_stmt (struct output_block
*ob
, gimple stmt
)
1702 enum gimple_code code
;
1704 struct bitpack_d bp
;
1706 /* Emit identifying tag. */
1707 code
= gimple_code (stmt
);
1708 tag
= lto_gimple_code_to_tag (code
);
1709 output_record_start (ob
, tag
);
1711 /* Emit the tuple header. */
1712 bp
= bitpack_create (ob
->main_stream
);
1713 bp_pack_value (&bp
, gimple_num_ops (stmt
), sizeof (unsigned) * 8);
1714 bp_pack_value (&bp
, gimple_no_warning_p (stmt
), 1);
1715 if (is_gimple_assign (stmt
))
1716 bp_pack_value (&bp
, gimple_assign_nontemporal_move_p (stmt
), 1);
1717 bp_pack_value (&bp
, gimple_has_volatile_ops (stmt
), 1);
1718 bp_pack_value (&bp
, stmt
->gsbase
.subcode
, 16);
1719 lto_output_bitpack (&bp
);
1721 /* Emit location information for the statement. */
1722 lto_output_location (ob
, gimple_location (stmt
));
1724 /* Emit the lexical block holding STMT. */
1725 lto_output_tree (ob
, gimple_block (stmt
), true);
1727 /* Emit the operands. */
1728 switch (gimple_code (stmt
))
1731 output_sleb128 (ob
, gimple_resx_region (stmt
));
1734 case GIMPLE_EH_MUST_NOT_THROW
:
1735 lto_output_tree_ref (ob
, gimple_eh_must_not_throw_fndecl (stmt
));
1738 case GIMPLE_EH_DISPATCH
:
1739 output_sleb128 (ob
, gimple_eh_dispatch_region (stmt
));
1743 lto_output_uleb128_stream (ob
->main_stream
, gimple_asm_ninputs (stmt
));
1744 lto_output_uleb128_stream (ob
->main_stream
, gimple_asm_noutputs (stmt
));
1745 lto_output_uleb128_stream (ob
->main_stream
, gimple_asm_nclobbers (stmt
));
1746 lto_output_uleb128_stream (ob
->main_stream
, gimple_asm_nlabels (stmt
));
1747 output_string (ob
, ob
->main_stream
, gimple_asm_string (stmt
));
1758 for (i
= 0; i
< gimple_num_ops (stmt
); i
++)
1760 tree op
= gimple_op (stmt
, i
);
1761 /* Wrap all uses of non-automatic variables inside MEM_REFs
1762 so that we do not have to deal with type mismatches on
1763 merged symbols during IL read in. The first operand
1764 of GIMPLE_DEBUG must be a decl, not MEM_REF, though. */
1765 if (op
&& (i
|| !is_gimple_debug (stmt
)))
1768 while (handled_component_p (*basep
))
1769 basep
= &TREE_OPERAND (*basep
, 0);
1770 if (TREE_CODE (*basep
) == VAR_DECL
1771 && !auto_var_in_fn_p (*basep
, current_function_decl
)
1772 && !DECL_REGISTER (*basep
))
1774 bool volatilep
= TREE_THIS_VOLATILE (*basep
);
1775 *basep
= build2 (MEM_REF
, TREE_TYPE (*basep
),
1776 build_fold_addr_expr (*basep
),
1777 build_int_cst (build_pointer_type
1778 (TREE_TYPE (*basep
)), 0));
1779 TREE_THIS_VOLATILE (*basep
) = volatilep
;
1782 lto_output_tree_ref (ob
, op
);
1787 case GIMPLE_PREDICT
:
1796 /* Output a basic block BB to the main stream in OB for this FN. */
1799 output_bb (struct output_block
*ob
, basic_block bb
, struct function
*fn
)
1801 gimple_stmt_iterator bsi
= gsi_start_bb (bb
);
1803 output_record_start (ob
,
1804 (!gsi_end_p (bsi
)) || phi_nodes (bb
)
1808 output_uleb128 (ob
, bb
->index
);
1809 output_sleb128 (ob
, bb
->count
);
1810 output_sleb128 (ob
, bb
->loop_depth
);
1811 output_sleb128 (ob
, bb
->frequency
);
1812 output_sleb128 (ob
, bb
->flags
);
1814 if (!gsi_end_p (bsi
) || phi_nodes (bb
))
1816 /* Output the statements. The list of statements is terminated
1818 for (bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
1821 gimple stmt
= gsi_stmt (bsi
);
1823 output_gimple_stmt (ob
, stmt
);
1825 /* Emit the EH region holding STMT. */
1826 region
= lookup_stmt_eh_lp_fn (fn
, stmt
);
1829 output_record_start (ob
, LTO_eh_region
);
1830 output_sleb128 (ob
, region
);
1838 for (bsi
= gsi_start_phis (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
1840 gimple phi
= gsi_stmt (bsi
);
1842 /* Only emit PHIs for gimple registers. PHI nodes for .MEM
1843 will be filled in on reading when the SSA form is
1845 if (is_gimple_reg (gimple_phi_result (phi
)))
1846 output_phi (ob
, phi
);
1853 /* Create the header in the file using OB. If the section type is for
1854 a function, set FN to the decl for that function. */
1857 produce_asm (struct output_block
*ob
, tree fn
)
1859 enum lto_section_type section_type
= ob
->section_type
;
1860 struct lto_function_header header
;
1862 struct lto_output_stream
*header_stream
;
1864 if (section_type
== LTO_section_function_body
)
1866 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fn
));
1867 section_name
= lto_get_section_name (section_type
, name
, NULL
);
1870 section_name
= lto_get_section_name (section_type
, NULL
, NULL
);
1872 lto_begin_section (section_name
, !flag_wpa
);
1873 free (section_name
);
1875 /* The entire header is stream computed here. */
1876 memset (&header
, 0, sizeof (struct lto_function_header
));
1878 /* Write the header. */
1879 header
.lto_header
.major_version
= LTO_major_version
;
1880 header
.lto_header
.minor_version
= LTO_minor_version
;
1881 header
.lto_header
.section_type
= section_type
;
1883 header
.compressed_size
= 0;
1885 if (section_type
== LTO_section_function_body
)
1886 header
.cfg_size
= ob
->cfg_stream
->total_size
;
1887 header
.main_size
= ob
->main_stream
->total_size
;
1888 header
.string_size
= ob
->string_stream
->total_size
;
1890 header_stream
= XCNEW (struct lto_output_stream
);
1891 lto_output_data_stream (header_stream
, &header
, sizeof header
);
1892 lto_write_stream (header_stream
);
1893 free (header_stream
);
1895 /* Put all of the gimple and the string table out the asm file as a
1897 if (section_type
== LTO_section_function_body
)
1898 lto_write_stream (ob
->cfg_stream
);
1899 lto_write_stream (ob
->main_stream
);
1900 lto_write_stream (ob
->string_stream
);
1906 /* Output the body of function NODE->DECL. */
1909 output_function (struct cgraph_node
*node
)
1911 struct bitpack_d bp
;
1913 struct function
*fn
;
1915 struct output_block
*ob
;
1919 function
= node
->decl
;
1920 fn
= DECL_STRUCT_FUNCTION (function
);
1921 ob
= create_output_block (LTO_section_function_body
);
1923 clear_line_info (ob
);
1924 ob
->cgraph_node
= node
;
1926 gcc_assert (current_function_decl
== NULL_TREE
&& cfun
== NULL
);
1928 /* Set current_function_decl and cfun. */
1929 current_function_decl
= function
;
1932 /* Make string 0 be a NULL string. */
1933 lto_output_1_stream (ob
->string_stream
, 0);
1935 output_record_start (ob
, LTO_function
);
1937 /* Write all the attributes for FN. */
1938 bp
= bitpack_create (ob
->main_stream
);
1939 bp_pack_value (&bp
, fn
->is_thunk
, 1);
1940 bp_pack_value (&bp
, fn
->has_local_explicit_reg_vars
, 1);
1941 bp_pack_value (&bp
, fn
->after_tree_profile
, 1);
1942 bp_pack_value (&bp
, fn
->returns_pcc_struct
, 1);
1943 bp_pack_value (&bp
, fn
->returns_struct
, 1);
1944 bp_pack_value (&bp
, fn
->can_throw_non_call_exceptions
, 1);
1945 bp_pack_value (&bp
, fn
->always_inline_functions_inlined
, 1);
1946 bp_pack_value (&bp
, fn
->after_inlining
, 1);
1947 bp_pack_value (&bp
, fn
->dont_save_pending_sizes_p
, 1);
1948 bp_pack_value (&bp
, fn
->stdarg
, 1);
1949 bp_pack_value (&bp
, fn
->has_nonlocal_label
, 1);
1950 bp_pack_value (&bp
, fn
->calls_alloca
, 1);
1951 bp_pack_value (&bp
, fn
->calls_setjmp
, 1);
1952 bp_pack_value (&bp
, fn
->va_list_fpr_size
, 8);
1953 bp_pack_value (&bp
, fn
->va_list_gpr_size
, 8);
1954 lto_output_bitpack (&bp
);
1956 /* Output the function start and end loci. */
1957 lto_output_location (ob
, fn
->function_start_locus
);
1958 lto_output_location (ob
, fn
->function_end_locus
);
1960 /* Output current IL state of the function. */
1961 output_uleb128 (ob
, fn
->curr_properties
);
1963 /* Output the static chain and non-local goto save area. */
1964 lto_output_tree_ref (ob
, fn
->static_chain_decl
);
1965 lto_output_tree_ref (ob
, fn
->nonlocal_goto_save_area
);
1967 /* Output all the local variables in the function. */
1968 output_sleb128 (ob
, VEC_length (tree
, fn
->local_decls
));
1969 FOR_EACH_VEC_ELT (tree
, fn
->local_decls
, i
, t
)
1970 lto_output_tree_ref (ob
, t
);
1972 /* Output the head of the arguments list. */
1973 lto_output_tree_ref (ob
, DECL_ARGUMENTS (function
));
1975 /* Output all the SSA names used in the function. */
1976 output_ssa_names (ob
, fn
);
1978 /* Output any exception handling regions. */
1979 output_eh_regions (ob
, fn
);
1981 /* Output DECL_INITIAL for the function, which contains the tree of
1983 lto_output_tree (ob
, DECL_INITIAL (function
), true);
1985 /* We will renumber the statements. The code that does this uses
1986 the same ordering that we use for serializing them so we can use
1987 the same code on the other end and not have to write out the
1988 statement numbers. */
1989 renumber_gimple_stmt_uids ();
1991 /* Output the code for the function. */
1992 FOR_ALL_BB_FN (bb
, fn
)
1993 output_bb (ob
, bb
, fn
);
1995 /* The terminator for this function. */
1998 output_cfg (ob
, fn
);
2000 /* Create a section to hold the pickled output of this function. */
2001 produce_asm (ob
, function
);
2003 destroy_output_block (ob
);
2005 current_function_decl
= NULL
;
2010 /* Used to pass data to trivally_defined_alias callback. */
2012 cgraph_node_set set
;
2013 varpool_node_set vset
;
2017 /* Return true if alias pair P belongs to the set of cgraph nodes in
2018 SET. If P is a an alias for a VAR_DECL, it can always be emitted.
2019 However, for FUNCTION_DECL aliases, we should only output the pair
2020 if it belongs to a function whose cgraph node is in SET.
2021 Otherwise, the LTRANS phase will get into trouble when finalizing
2022 aliases because the alias will refer to a function not defined in
2023 the file processed by LTRANS. */
2026 trivally_defined_alias (tree decl ATTRIBUTE_UNUSED
,
2027 tree target
, void *data
)
2029 struct sets
*set
= (struct sets
*) data
;
2030 struct cgraph_node
*fnode
= NULL
;
2031 struct varpool_node
*vnode
= NULL
;
2033 fnode
= cgraph_node_for_asm (target
);
2035 return cgraph_node_in_set_p (fnode
, set
->set
);
2036 vnode
= varpool_node_for_asm (target
);
2037 return vnode
&& varpool_node_in_set_p (vnode
, set
->vset
);
2040 /* Return true if alias pair P should be output in the current
2041 partition contains cgrpah nodes SET and varpool nodes VSET.
2042 DEFINED is set of all aliases whose targets are defined in
2045 Normal aliases are output when they are defined, while WEAKREF
2046 aliases are output when they are used. */
2049 output_alias_pair_p (alias_pair
*p
, symbol_alias_set_t
*defined
,
2050 cgraph_node_set set
, varpool_node_set vset
)
2052 struct cgraph_node
*node
;
2053 struct varpool_node
*vnode
;
2055 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (p
->decl
)))
2057 if (TREE_CODE (p
->decl
) == VAR_DECL
)
2059 vnode
= varpool_get_node (p
->decl
);
2061 && referenced_from_this_partition_p (&vnode
->ref_list
, set
, vset
));
2063 node
= cgraph_get_node (p
->decl
);
2065 && (referenced_from_this_partition_p (&node
->ref_list
, set
, vset
)
2066 || reachable_from_this_partition_p (node
, set
)));
2069 return symbol_alias_set_contains (defined
, p
->decl
);
2072 /* Output any unreferenced global symbol defined in SET, alias pairs
2076 output_unreferenced_globals (cgraph_node_set set
, varpool_node_set vset
)
2078 struct output_block
*ob
;
2081 struct varpool_node
*vnode
;
2082 symbol_alias_set_t
*defined
;
2083 struct sets setdata
;
2086 setdata
.vset
= vset
;
2088 ob
= create_output_block (LTO_section_static_initializer
);
2089 ob
->cgraph_node
= NULL
;
2091 clear_line_info (ob
);
2093 /* Make string 0 be a NULL string. */
2094 lto_output_1_stream (ob
->string_stream
, 0);
2096 /* Emit references for all the global symbols. If a global symbol
2097 was never referenced in any of the functions of this file, it
2098 would not be emitted otherwise. This will result in unreferenced
2099 symbols at link time if a file defines a global symbol but
2100 never references it. */
2101 FOR_EACH_STATIC_VARIABLE (vnode
)
2102 if (vnode
->needed
&& varpool_node_in_set_p (vnode
, vset
))
2104 tree var
= vnode
->decl
;
2106 if (TREE_CODE (var
) == VAR_DECL
)
2108 /* Output the object in order to output references used in the
2110 lto_output_tree (ob
, var
, true);
2112 /* If it is public we also need a reference to the object itself. */
2113 if (TREE_PUBLIC (var
))
2114 lto_output_tree_ref (ob
, var
);
2120 /* We really need to propagate in both directoins:
2121 for normal aliases we propagate from first defined alias to
2122 all aliases defined based on it. For weakrefs we propagate in
2123 the oposite direction. */
2124 defined
= propagate_aliases_backward (trivally_defined_alias
, &setdata
);
2126 /* Emit the alias pairs for the nodes in SET. */
2127 FOR_EACH_VEC_ELT (alias_pair
, alias_pairs
, i
, p
)
2128 if (output_alias_pair_p (p
, defined
, set
, vset
))
2130 lto_output_tree_ref (ob
, p
->decl
);
2131 lto_output_tree_ref (ob
, p
->target
);
2133 symbol_alias_set_destroy (defined
);
2137 produce_asm (ob
, NULL
);
2138 destroy_output_block (ob
);
2142 /* Copy the function body of NODE without deserializing. */
2145 copy_function (struct cgraph_node
*node
)
2147 tree function
= node
->decl
;
2148 struct lto_file_decl_data
*file_data
= node
->local
.lto_file_data
;
2149 struct lto_output_stream
*output_stream
= XCNEW (struct lto_output_stream
);
2152 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (function
));
2153 char *section_name
=
2154 lto_get_section_name (LTO_section_function_body
, name
, NULL
);
2156 struct lto_in_decl_state
*in_state
;
2157 struct lto_out_decl_state
*out_state
= lto_get_out_decl_state ();
2159 lto_begin_section (section_name
, !flag_wpa
);
2160 free (section_name
);
2162 /* We may have renamed the declaration, e.g., a static function. */
2163 name
= lto_get_decl_name_mapping (file_data
, name
);
2165 data
= lto_get_section_data (file_data
, LTO_section_function_body
,
2169 /* Do a bit copy of the function body. */
2170 lto_output_data_stream (output_stream
, data
, len
);
2171 lto_write_stream (output_stream
);
2175 lto_get_function_in_decl_state (node
->local
.lto_file_data
, function
);
2176 gcc_assert (in_state
);
2178 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2180 size_t n
= in_state
->streams
[i
].size
;
2181 tree
*trees
= in_state
->streams
[i
].trees
;
2182 struct lto_tree_ref_encoder
*encoder
= &(out_state
->streams
[i
]);
2184 /* The out state must have the same indices and the in state.
2185 So just copy the vector. All the encoders in the in state
2186 must be empty where we reach here. */
2187 gcc_assert (lto_tree_ref_encoder_size (encoder
) == 0);
2188 for (j
= 0; j
< n
; j
++)
2189 VEC_safe_push (tree
, heap
, encoder
->trees
, trees
[j
]);
2190 encoder
->next_index
= n
;
2193 lto_free_section_data (file_data
, LTO_section_function_body
, name
,
2195 free (output_stream
);
2200 /* Initialize the LTO writer. */
2203 lto_writer_init (void)
2205 lto_streamer_init ();
2209 /* Main entry point from the pass manager. */
2212 lto_output (cgraph_node_set set
, varpool_node_set vset
)
2214 struct cgraph_node
*node
;
2215 struct lto_out_decl_state
*decl_state
;
2216 #ifdef ENABLE_CHECKING
2217 bitmap output
= lto_bitmap_alloc ();
2220 lto_cgraph_encoder_t encoder
= lto_get_out_decl_state ()->cgraph_node_encoder
;
2224 n_nodes
= lto_cgraph_encoder_size (encoder
);
2225 /* Process only the functions with bodies. */
2226 for (i
= 0; i
< n_nodes
; i
++)
2228 node
= lto_cgraph_encoder_deref (encoder
, i
);
2229 if (lto_cgraph_encoder_encode_body_p (encoder
, node
))
2231 #ifdef ENABLE_CHECKING
2232 gcc_assert (!bitmap_bit_p (output
, DECL_UID (node
->decl
)));
2233 bitmap_set_bit (output
, DECL_UID (node
->decl
));
2235 decl_state
= lto_new_out_decl_state ();
2236 lto_push_out_decl_state (decl_state
);
2237 if (gimple_has_body_p (node
->decl
))
2238 output_function (node
);
2240 copy_function (node
);
2241 gcc_assert (lto_get_out_decl_state () == decl_state
);
2242 lto_pop_out_decl_state ();
2243 lto_record_function_out_decl_state (node
->decl
, decl_state
);
2247 /* Emit the callgraph after emitting function bodies. This needs to
2248 be done now to make sure that all the statements in every function
2249 have been renumbered so that edges can be associated with call
2250 statements using the statement UIDs. */
2251 output_cgraph (set
, vset
);
2253 #ifdef ENABLE_CHECKING
2254 lto_bitmap_free (output
);
2258 struct ipa_opt_pass_d pass_ipa_lto_gimple_out
=
2262 "lto_gimple_out", /* name */
2263 gate_lto_out
, /* gate */
2267 0, /* static_pass_number */
2268 TV_IPA_LTO_GIMPLE_OUT
, /* tv_id */
2269 0, /* properties_required */
2270 0, /* properties_provided */
2271 0, /* properties_destroyed */
2272 0, /* todo_flags_start */
2273 TODO_dump_func
/* todo_flags_finish */
2275 NULL
, /* generate_summary */
2276 lto_output
, /* write_summary */
2277 NULL
, /* read_summary */
2278 lto_output
, /* write_optimization_summary */
2279 NULL
, /* read_optimization_summary */
2280 NULL
, /* stmt_fixup */
2282 NULL
, /* function_transform */
2283 NULL
/* variable_transform */
2287 /* Write each node in encoded by ENCODER to OB, as well as those reachable
2288 from it and required for correct representation of its semantics.
2289 Each node in ENCODER must be a global declaration or a type. A node
2290 is written only once, even if it appears multiple times in the
2291 vector. Certain transitively-reachable nodes, such as those
2292 representing expressions, may be duplicated, but such nodes
2293 must not appear in ENCODER itself. */
2296 write_global_stream (struct output_block
*ob
,
2297 struct lto_tree_ref_encoder
*encoder
)
2301 const size_t size
= lto_tree_ref_encoder_size (encoder
);
2303 for (index
= 0; index
< size
; index
++)
2305 t
= lto_tree_ref_encoder_get_tree (encoder
, index
);
2306 if (!lto_streamer_cache_lookup (ob
->writer_cache
, t
, NULL
))
2307 lto_output_tree (ob
, t
, false);
2312 /* Write a sequence of indices into the globals vector corresponding
2313 to the trees in ENCODER. These are used by the reader to map the
2314 indices used to refer to global entities within function bodies to
2318 write_global_references (struct output_block
*ob
,
2319 struct lto_output_stream
*ref_stream
,
2320 struct lto_tree_ref_encoder
*encoder
)
2324 const int32_t size
= lto_tree_ref_encoder_size (encoder
);
2326 /* Write size as 32-bit unsigned. */
2327 lto_output_data_stream (ref_stream
, &size
, sizeof (int32_t));
2329 for (index
= 0; index
< size
; index
++)
2333 t
= lto_tree_ref_encoder_get_tree (encoder
, index
);
2334 lto_streamer_cache_lookup (ob
->writer_cache
, t
, &slot_num
);
2335 gcc_assert (slot_num
>= 0);
2336 lto_output_data_stream (ref_stream
, &slot_num
, sizeof slot_num
);
2341 /* Write all the streams in an lto_out_decl_state STATE using
2342 output block OB and output stream OUT_STREAM. */
2345 lto_output_decl_state_streams (struct output_block
*ob
,
2346 struct lto_out_decl_state
*state
)
2350 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2351 write_global_stream (ob
, &state
->streams
[i
]);
2355 /* Write all the references in an lto_out_decl_state STATE using
2356 output block OB and output stream OUT_STREAM. */
2359 lto_output_decl_state_refs (struct output_block
*ob
,
2360 struct lto_output_stream
*out_stream
,
2361 struct lto_out_decl_state
*state
)
2367 /* Write reference to FUNCTION_DECL. If there is not function,
2368 write reference to void_type_node. */
2369 decl
= (state
->fn_decl
) ? state
->fn_decl
: void_type_node
;
2370 lto_streamer_cache_lookup (ob
->writer_cache
, decl
, &ref
);
2371 gcc_assert (ref
>= 0);
2372 lto_output_data_stream (out_stream
, &ref
, sizeof (int32_t));
2374 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2375 write_global_references (ob
, out_stream
, &state
->streams
[i
]);
2379 /* Return the written size of STATE. */
2382 lto_out_decl_state_written_size (struct lto_out_decl_state
*state
)
2387 size
= sizeof (int32_t); /* fn_ref. */
2388 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2390 size
+= sizeof (int32_t); /* vector size. */
2391 size
+= (lto_tree_ref_encoder_size (&state
->streams
[i
])
2392 * sizeof (int32_t));
2398 /* Write symbol T into STREAM in CACHE. SEEN specifies symbols we wrote
2402 write_symbol (struct lto_streamer_cache_d
*cache
,
2403 struct lto_output_stream
*stream
,
2404 tree t
, struct pointer_set_t
*seen
, bool alias
)
2407 enum gcc_plugin_symbol_kind kind
;
2408 enum gcc_plugin_symbol_visibility visibility
;
2414 /* None of the following kinds of symbols are needed in the
2416 if (!TREE_PUBLIC (t
)
2417 || is_builtin_fn (t
)
2418 || DECL_ABSTRACT (t
)
2419 || TREE_CODE (t
) == RESULT_DECL
)
2422 gcc_assert (TREE_CODE (t
) == VAR_DECL
2423 || TREE_CODE (t
) == FUNCTION_DECL
);
2425 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (t
));
2427 /* This behaves like assemble_name_raw in varasm.c, performing the
2428 same name manipulations that ASM_OUTPUT_LABELREF does. */
2429 name
= IDENTIFIER_POINTER ((*targetm
.asm_out
.mangle_assembler_name
) (name
));
2431 if (pointer_set_contains (seen
, name
))
2433 pointer_set_insert (seen
, name
);
2435 lto_streamer_cache_lookup (cache
, t
, &slot_num
);
2436 gcc_assert (slot_num
>= 0);
2438 if (DECL_EXTERNAL (t
))
2441 kind
= GCCPK_WEAKUNDEF
;
2448 kind
= GCCPK_WEAKDEF
;
2449 else if (DECL_COMMON (t
))
2450 kind
= GCCPK_COMMON
;
2454 /* When something is defined, it should have node attached. */
2455 gcc_assert (alias
|| TREE_CODE (t
) != VAR_DECL
2456 || varpool_get_node (t
)->finalized
);
2457 gcc_assert (alias
|| TREE_CODE (t
) != FUNCTION_DECL
2458 || (cgraph_get_node (t
)
2459 && cgraph_get_node (t
)->analyzed
));
2462 /* Imitate what default_elf_asm_output_external do.
2463 When symbol is external, we need to output it with DEFAULT visibility
2464 when compiling with -fvisibility=default, while with HIDDEN visibility
2465 when symbol has attribute (visibility("hidden")) specified.
2466 targetm.binds_local_p check DECL_VISIBILITY_SPECIFIED and gets this
2469 if (DECL_EXTERNAL (t
)
2470 && !targetm
.binds_local_p (t
))
2471 visibility
= GCCPV_DEFAULT
;
2473 switch (DECL_VISIBILITY(t
))
2475 case VISIBILITY_DEFAULT
:
2476 visibility
= GCCPV_DEFAULT
;
2478 case VISIBILITY_PROTECTED
:
2479 visibility
= GCCPV_PROTECTED
;
2481 case VISIBILITY_HIDDEN
:
2482 visibility
= GCCPV_HIDDEN
;
2484 case VISIBILITY_INTERNAL
:
2485 visibility
= GCCPV_INTERNAL
;
2489 if (kind
== GCCPK_COMMON
2491 && TREE_CODE (DECL_SIZE (t
)) == INTEGER_CST
)
2493 size
= (HOST_BITS_PER_WIDE_INT
>= 64)
2494 ? (uint64_t) int_size_in_bytes (TREE_TYPE (t
))
2495 : (((uint64_t) TREE_INT_CST_HIGH (DECL_SIZE_UNIT (t
))) << 32)
2496 | TREE_INT_CST_LOW (DECL_SIZE_UNIT (t
));
2501 if (DECL_ONE_ONLY (t
))
2502 comdat
= IDENTIFIER_POINTER (DECL_COMDAT_GROUP (t
));
2506 lto_output_data_stream (stream
, name
, strlen (name
) + 1);
2507 lto_output_data_stream (stream
, comdat
, strlen (comdat
) + 1);
2508 c
= (unsigned char) kind
;
2509 lto_output_data_stream (stream
, &c
, 1);
2510 c
= (unsigned char) visibility
;
2511 lto_output_data_stream (stream
, &c
, 1);
2512 lto_output_data_stream (stream
, &size
, 8);
2513 lto_output_data_stream (stream
, &slot_num
, 4);
2517 /* Write an IL symbol table to OB.
2518 SET and VSET are cgraph/varpool node sets we are outputting. */
2521 produce_symtab (struct output_block
*ob
,
2522 cgraph_node_set set
, varpool_node_set vset
)
2524 struct lto_streamer_cache_d
*cache
= ob
->writer_cache
;
2525 char *section_name
= lto_get_section_name (LTO_section_symtab
, NULL
, NULL
);
2526 struct pointer_set_t
*seen
;
2527 struct cgraph_node
*node
, *alias
;
2528 struct varpool_node
*vnode
, *valias
;
2529 struct lto_output_stream stream
;
2530 lto_varpool_encoder_t varpool_encoder
= ob
->decl_state
->varpool_node_encoder
;
2531 lto_cgraph_encoder_t encoder
= ob
->decl_state
->cgraph_node_encoder
;
2534 struct sets setdata
;
2535 symbol_alias_set_t
*defined
;
2538 setdata
.vset
= vset
;
2540 lto_begin_section (section_name
, false);
2541 free (section_name
);
2543 seen
= pointer_set_create ();
2544 memset (&stream
, 0, sizeof (stream
));
2546 /* Write all functions.
2547 First write all defined functions and the write all used functions.
2548 This is done so only to handle duplicated symbols in cgraph. */
2549 for (i
= 0; i
< lto_cgraph_encoder_size (encoder
); i
++)
2551 node
= lto_cgraph_encoder_deref (encoder
, i
);
2552 if (DECL_EXTERNAL (node
->decl
))
2554 if (DECL_COMDAT (node
->decl
)
2555 && cgraph_comdat_can_be_unshared_p (node
))
2557 if (node
->alias
|| node
->global
.inlined_to
)
2559 write_symbol (cache
, &stream
, node
->decl
, seen
, false);
2560 for (alias
= node
->same_body
; alias
; alias
= alias
->next
)
2561 write_symbol (cache
, &stream
, alias
->decl
, seen
, true);
2563 for (i
= 0; i
< lto_cgraph_encoder_size (encoder
); i
++)
2565 node
= lto_cgraph_encoder_deref (encoder
, i
);
2566 if (!DECL_EXTERNAL (node
->decl
))
2568 if (DECL_COMDAT (node
->decl
)
2569 && cgraph_comdat_can_be_unshared_p (node
))
2571 if (node
->alias
|| node
->global
.inlined_to
)
2573 write_symbol (cache
, &stream
, node
->decl
, seen
, false);
2574 for (alias
= node
->same_body
; alias
; alias
= alias
->next
)
2575 write_symbol (cache
, &stream
, alias
->decl
, seen
, true);
2578 /* Write all variables. */
2579 for (i
= 0; i
< lto_varpool_encoder_size (varpool_encoder
); i
++)
2581 vnode
= lto_varpool_encoder_deref (varpool_encoder
, i
);
2582 if (DECL_EXTERNAL (vnode
->decl
))
2584 /* COMDAT virtual tables can be unshared. Do not declare them
2585 in the LTO symbol table to prevent linker from forcing them
2587 if (DECL_COMDAT (vnode
->decl
)
2588 && !vnode
->force_output
2590 && DECL_VIRTUAL_P (vnode
->decl
))
2594 write_symbol (cache
, &stream
, vnode
->decl
, seen
, false);
2595 for (valias
= vnode
->extra_name
; valias
; valias
= valias
->next
)
2596 write_symbol (cache
, &stream
, valias
->decl
, seen
, true);
2598 for (i
= 0; i
< lto_varpool_encoder_size (varpool_encoder
); i
++)
2600 vnode
= lto_varpool_encoder_deref (varpool_encoder
, i
);
2601 if (!DECL_EXTERNAL (vnode
->decl
))
2603 if (DECL_COMDAT (vnode
->decl
)
2604 && !vnode
->force_output
2606 && DECL_VIRTUAL_P (vnode
->decl
))
2610 write_symbol (cache
, &stream
, vnode
->decl
, seen
, false);
2611 for (valias
= vnode
->extra_name
; valias
; valias
= valias
->next
)
2612 write_symbol (cache
, &stream
, valias
->decl
, seen
, true);
2615 /* Write all aliases. */
2616 defined
= propagate_aliases_backward (trivally_defined_alias
, &setdata
);
2617 FOR_EACH_VEC_ELT (alias_pair
, alias_pairs
, i
, p
)
2618 if (output_alias_pair_p (p
, defined
, set
, vset
))
2619 write_symbol (cache
, &stream
, p
->decl
, seen
, true);
2620 symbol_alias_set_destroy (defined
);
2622 lto_write_stream (&stream
);
2623 pointer_set_destroy (seen
);
2629 /* This pass is run after all of the functions are serialized and all
2630 of the IPA passes have written their serialized forms. This pass
2631 causes the vector of all of the global decls and types used from
2632 this file to be written in to a section that can then be read in to
2633 recover these on other side. */
2636 produce_asm_for_decls (cgraph_node_set set
, varpool_node_set vset
)
2638 struct lto_out_decl_state
*out_state
;
2639 struct lto_out_decl_state
*fn_out_state
;
2640 struct lto_decl_header header
;
2642 struct output_block
*ob
;
2643 struct lto_output_stream
*header_stream
, *decl_state_stream
;
2644 unsigned idx
, num_fns
;
2645 size_t decl_state_size
;
2646 int32_t num_decl_states
;
2648 ob
= create_output_block (LTO_section_decls
);
2651 /* Write out unreferenced globals, alias pairs and labels. We defer
2652 doing this until now so that we can write out only what is
2654 output_unreferenced_globals (set
, vset
);
2656 memset (&header
, 0, sizeof (struct lto_decl_header
));
2658 section_name
= lto_get_section_name (LTO_section_decls
, NULL
, NULL
);
2659 lto_begin_section (section_name
, !flag_wpa
);
2660 free (section_name
);
2662 /* Make string 0 be a NULL string. */
2663 lto_output_1_stream (ob
->string_stream
, 0);
2665 /* Write the global symbols. */
2666 out_state
= lto_get_out_decl_state ();
2667 num_fns
= VEC_length (lto_out_decl_state_ptr
, lto_function_decl_states
);
2668 lto_output_decl_state_streams (ob
, out_state
);
2669 for (idx
= 0; idx
< num_fns
; idx
++)
2672 VEC_index (lto_out_decl_state_ptr
, lto_function_decl_states
, idx
);
2673 lto_output_decl_state_streams (ob
, fn_out_state
);
2676 header
.lto_header
.major_version
= LTO_major_version
;
2677 header
.lto_header
.minor_version
= LTO_minor_version
;
2678 header
.lto_header
.section_type
= LTO_section_decls
;
2680 /* Currently not used. This field would allow us to preallocate
2681 the globals vector, so that it need not be resized as it is extended. */
2682 header
.num_nodes
= -1;
2684 /* Compute the total size of all decl out states. */
2685 decl_state_size
= sizeof (int32_t);
2686 decl_state_size
+= lto_out_decl_state_written_size (out_state
);
2687 for (idx
= 0; idx
< num_fns
; idx
++)
2690 VEC_index (lto_out_decl_state_ptr
, lto_function_decl_states
, idx
);
2691 decl_state_size
+= lto_out_decl_state_written_size (fn_out_state
);
2693 header
.decl_state_size
= decl_state_size
;
2695 header
.main_size
= ob
->main_stream
->total_size
;
2696 header
.string_size
= ob
->string_stream
->total_size
;
2698 header_stream
= XCNEW (struct lto_output_stream
);
2699 lto_output_data_stream (header_stream
, &header
, sizeof header
);
2700 lto_write_stream (header_stream
);
2701 free (header_stream
);
2703 /* Write the main out-decl state, followed by out-decl states of
2705 decl_state_stream
= ((struct lto_output_stream
*)
2706 xcalloc (1, sizeof (struct lto_output_stream
)));
2707 num_decl_states
= num_fns
+ 1;
2708 lto_output_data_stream (decl_state_stream
, &num_decl_states
,
2709 sizeof (num_decl_states
));
2710 lto_output_decl_state_refs (ob
, decl_state_stream
, out_state
);
2711 for (idx
= 0; idx
< num_fns
; idx
++)
2714 VEC_index (lto_out_decl_state_ptr
, lto_function_decl_states
, idx
);
2715 lto_output_decl_state_refs (ob
, decl_state_stream
, fn_out_state
);
2717 lto_write_stream (decl_state_stream
);
2718 free(decl_state_stream
);
2720 lto_write_stream (ob
->main_stream
);
2721 lto_write_stream (ob
->string_stream
);
2725 /* Write the symbol table. It is used by linker to determine dependencies
2726 and thus we can skip it for WPA. */
2728 produce_symtab (ob
, set
, vset
);
2730 /* Write command line opts. */
2731 lto_write_options ();
2733 /* Deallocate memory and clean up. */
2734 for (idx
= 0; idx
< num_fns
; idx
++)
2737 VEC_index (lto_out_decl_state_ptr
, lto_function_decl_states
, idx
);
2738 lto_delete_out_decl_state (fn_out_state
);
2740 lto_cgraph_encoder_delete (ob
->decl_state
->cgraph_node_encoder
);
2741 lto_varpool_encoder_delete (ob
->decl_state
->varpool_node_encoder
);
2742 VEC_free (lto_out_decl_state_ptr
, heap
, lto_function_decl_states
);
2743 lto_function_decl_states
= NULL
;
2744 destroy_output_block (ob
);
2748 struct ipa_opt_pass_d pass_ipa_lto_finish_out
=
2752 "lto_decls_out", /* name */
2753 gate_lto_out
, /* gate */
2757 0, /* static_pass_number */
2758 TV_IPA_LTO_DECL_OUT
, /* tv_id */
2759 0, /* properties_required */
2760 0, /* properties_provided */
2761 0, /* properties_destroyed */
2762 0, /* todo_flags_start */
2763 0 /* todo_flags_finish */
2765 NULL
, /* generate_summary */
2766 produce_asm_for_decls
, /* write_summary */
2767 NULL
, /* read_summary */
2768 produce_asm_for_decls
, /* write_optimization_summary */
2769 NULL
, /* read_optimization_summary */
2770 NULL
, /* stmt_fixup */
2772 NULL
, /* function_transform */
2773 NULL
/* variable_transform */