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
)
73 return memcmp (ds1
->s
, ds2
->s
, ds1
->len
) == 0;
79 /* Free the string slot pointed-to by P. */
82 string_slot_free (void *p
)
84 struct string_slot
*slot
= (struct string_slot
*) p
;
85 free (CONST_CAST (void *, (const void *) slot
->s
));
90 /* Clear the line info stored in DATA_IN. */
93 clear_line_info (struct output_block
*ob
)
95 ob
->current_file
= NULL
;
101 /* Create the output block and return it. SECTION_TYPE is
102 LTO_section_function_body or LTO_static_initializer. */
104 struct output_block
*
105 create_output_block (enum lto_section_type section_type
)
107 struct output_block
*ob
= XCNEW (struct output_block
);
109 ob
->section_type
= section_type
;
110 ob
->decl_state
= lto_get_out_decl_state ();
111 ob
->main_stream
= XCNEW (struct lto_output_stream
);
112 ob
->string_stream
= XCNEW (struct lto_output_stream
);
113 ob
->writer_cache
= lto_streamer_cache_create ();
115 if (section_type
== LTO_section_function_body
)
116 ob
->cfg_stream
= XCNEW (struct lto_output_stream
);
118 clear_line_info (ob
);
120 ob
->string_hash_table
= htab_create (37, hash_string_slot_node
,
121 eq_string_slot_node
, string_slot_free
);
127 /* Destroy the output block OB. */
130 destroy_output_block (struct output_block
*ob
)
132 enum lto_section_type section_type
= ob
->section_type
;
134 htab_delete (ob
->string_hash_table
);
136 free (ob
->main_stream
);
137 free (ob
->string_stream
);
138 if (section_type
== LTO_section_function_body
)
139 free (ob
->cfg_stream
);
141 lto_streamer_cache_delete (ob
->writer_cache
);
147 /* Output STRING of LEN characters to the string
148 table in OB. The string might or might not include a trailing '\0'.
149 Then put the index onto the INDEX_STREAM. */
152 lto_output_string_with_length (struct output_block
*ob
,
153 struct lto_output_stream
*index_stream
,
157 struct string_slot
**slot
;
158 struct string_slot s_slot
;
159 char *string
= (char *) xmalloc (len
+ 1);
160 memcpy (string
, s
, len
);
167 /* Indicate that this is not a NULL string. */
168 lto_output_uleb128_stream (index_stream
, 0);
170 slot
= (struct string_slot
**) htab_find_slot (ob
->string_hash_table
,
174 struct lto_output_stream
*string_stream
= ob
->string_stream
;
175 unsigned int start
= string_stream
->total_size
;
176 struct string_slot
*new_slot
177 = (struct string_slot
*) xmalloc (sizeof (struct string_slot
));
179 new_slot
->s
= string
;
181 new_slot
->slot_num
= start
;
183 lto_output_uleb128_stream (index_stream
, start
);
184 lto_output_uleb128_stream (string_stream
, len
);
185 lto_output_data_stream (string_stream
, string
, len
);
189 struct string_slot
*old_slot
= *slot
;
190 lto_output_uleb128_stream (index_stream
, old_slot
->slot_num
);
195 /* Output the '\0' terminated STRING to the string
196 table in OB. Then put the index onto the INDEX_STREAM. */
199 lto_output_string (struct output_block
*ob
,
200 struct lto_output_stream
*index_stream
,
204 lto_output_string_with_length (ob
, index_stream
, string
,
205 strlen (string
) + 1);
207 lto_output_uleb128_stream (index_stream
, 1);
211 /* Output the STRING constant to the string
212 table in OB. Then put the index onto the INDEX_STREAM. */
215 output_string_cst (struct output_block
*ob
,
216 struct lto_output_stream
*index_stream
,
220 lto_output_string_with_length (ob
, index_stream
,
221 TREE_STRING_POINTER (string
),
222 TREE_STRING_LENGTH (string
));
224 lto_output_uleb128_stream (index_stream
, 1);
228 /* Output the identifier ID to the string
229 table in OB. Then put the index onto the INDEX_STREAM. */
232 output_identifier (struct output_block
*ob
,
233 struct lto_output_stream
*index_stream
,
237 lto_output_string_with_length (ob
, index_stream
,
238 IDENTIFIER_POINTER (id
),
239 IDENTIFIER_LENGTH (id
));
241 lto_output_uleb128_stream (index_stream
, 1);
244 /* Write a zero to the output stream. */
247 output_zero (struct output_block
*ob
)
249 lto_output_1_stream (ob
->main_stream
, 0);
253 /* Output an unsigned LEB128 quantity to OB->main_stream. */
256 output_uleb128 (struct output_block
*ob
, unsigned HOST_WIDE_INT work
)
258 lto_output_uleb128_stream (ob
->main_stream
, work
);
262 /* Output a signed LEB128 quantity to OB->main_stream. */
265 output_sleb128 (struct output_block
*ob
, HOST_WIDE_INT work
)
267 lto_output_sleb128_stream (ob
->main_stream
, work
);
271 /* Output the start of a record with TAG to output block OB. */
274 output_record_start (struct output_block
*ob
, enum LTO_tags tag
)
276 /* Make sure TAG fits inside an unsigned int. */
277 gcc_assert (tag
== (enum LTO_tags
) (unsigned) tag
);
278 output_uleb128 (ob
, tag
);
282 /* Look up NODE in the type table and write the index for it to OB. */
285 output_type_ref (struct output_block
*ob
, tree node
)
287 output_record_start (ob
, LTO_type_ref
);
288 lto_output_type_ref_index (ob
->decl_state
, ob
->main_stream
, node
);
292 /* Pack all the non-pointer fields of the TS_BASE structure of
293 expression EXPR into bitpack BP. */
296 pack_ts_base_value_fields (struct bitpack_d
*bp
, tree expr
)
298 bp_pack_value (bp
, TREE_CODE (expr
), 16);
301 bp_pack_value (bp
, TREE_SIDE_EFFECTS (expr
), 1);
302 bp_pack_value (bp
, TREE_CONSTANT (expr
), 1);
303 bp_pack_value (bp
, TREE_READONLY (expr
), 1);
305 /* TREE_PUBLIC is used on types to indicate that the type
306 has a TYPE_CACHED_VALUES vector. This is not streamed out,
307 so we skip it here. */
308 bp_pack_value (bp
, TREE_PUBLIC (expr
), 1);
311 bp_pack_value (bp
, 0, 4);
312 bp_pack_value (bp
, TREE_ADDRESSABLE (expr
), 1);
313 bp_pack_value (bp
, TREE_THIS_VOLATILE (expr
), 1);
315 bp_pack_value (bp
, DECL_UNSIGNED (expr
), 1);
316 else if (TYPE_P (expr
))
317 bp_pack_value (bp
, TYPE_UNSIGNED (expr
), 1);
319 bp_pack_value (bp
, 0, 1);
320 /* We write debug info two times, do not confuse the second one. */
321 bp_pack_value (bp
, TYPE_P (expr
) ? 0 : TREE_ASM_WRITTEN (expr
), 1);
322 bp_pack_value (bp
, TREE_NO_WARNING (expr
), 1);
323 bp_pack_value (bp
, TREE_USED (expr
), 1);
324 bp_pack_value (bp
, TREE_NOTHROW (expr
), 1);
325 bp_pack_value (bp
, TREE_STATIC (expr
), 1);
326 bp_pack_value (bp
, TREE_PRIVATE (expr
), 1);
327 bp_pack_value (bp
, TREE_PROTECTED (expr
), 1);
328 bp_pack_value (bp
, TREE_DEPRECATED (expr
), 1);
331 bp_pack_value (bp
, TYPE_SATURATING (expr
), 1);
332 bp_pack_value (bp
, TYPE_ADDR_SPACE (expr
), 8);
334 else if (TREE_CODE (expr
) == SSA_NAME
)
335 bp_pack_value (bp
, SSA_NAME_IS_DEFAULT_DEF (expr
), 1);
337 bp_pack_value (bp
, 0, 1);
341 /* Pack all the non-pointer fields of the TS_REAL_CST structure of
342 expression EXPR into bitpack BP. */
345 pack_ts_real_cst_value_fields (struct bitpack_d
*bp
, tree expr
)
350 r
= TREE_REAL_CST (expr
);
351 bp_pack_value (bp
, r
.cl
, 2);
352 bp_pack_value (bp
, r
.decimal
, 1);
353 bp_pack_value (bp
, r
.sign
, 1);
354 bp_pack_value (bp
, r
.signalling
, 1);
355 bp_pack_value (bp
, r
.canonical
, 1);
356 bp_pack_value (bp
, r
.uexp
, EXP_BITS
);
357 for (i
= 0; i
< SIGSZ
; i
++)
358 bp_pack_value (bp
, r
.sig
[i
], HOST_BITS_PER_LONG
);
362 /* Pack all the non-pointer fields of the TS_FIXED_CST structure of
363 expression EXPR into bitpack BP. */
366 pack_ts_fixed_cst_value_fields (struct bitpack_d
*bp
, tree expr
)
368 struct fixed_value fv
= TREE_FIXED_CST (expr
);
369 bp_pack_value (bp
, fv
.data
.low
, HOST_BITS_PER_WIDE_INT
);
370 bp_pack_value (bp
, fv
.data
.high
, HOST_BITS_PER_WIDE_INT
);
371 bp_pack_value (bp
, fv
.mode
, HOST_BITS_PER_INT
);
375 /* Pack all the non-pointer fields of the TS_DECL_COMMON structure
376 of expression EXPR into bitpack BP. */
379 pack_ts_decl_common_value_fields (struct bitpack_d
*bp
, tree expr
)
381 bp_pack_value (bp
, DECL_MODE (expr
), 8);
382 bp_pack_value (bp
, DECL_NONLOCAL (expr
), 1);
383 bp_pack_value (bp
, DECL_VIRTUAL_P (expr
), 1);
384 bp_pack_value (bp
, DECL_IGNORED_P (expr
), 1);
385 bp_pack_value (bp
, DECL_ABSTRACT (expr
), 1);
386 bp_pack_value (bp
, DECL_ARTIFICIAL (expr
), 1);
387 bp_pack_value (bp
, DECL_USER_ALIGN (expr
), 1);
388 bp_pack_value (bp
, DECL_PRESERVE_P (expr
), 1);
389 bp_pack_value (bp
, DECL_DEBUG_EXPR_IS_FROM (expr
), 1);
390 bp_pack_value (bp
, DECL_EXTERNAL (expr
), 1);
391 bp_pack_value (bp
, DECL_GIMPLE_REG_P (expr
), 1);
392 bp_pack_value (bp
, DECL_ALIGN (expr
), HOST_BITS_PER_INT
);
394 if (TREE_CODE (expr
) == LABEL_DECL
)
396 /* Note that we do not write LABEL_DECL_UID. The reader will
397 always assume an initial value of -1 so that the
398 label_to_block_map is recreated by gimple_set_bb. */
399 bp_pack_value (bp
, DECL_ERROR_ISSUED (expr
), 1);
400 bp_pack_value (bp
, EH_LANDING_PAD_NR (expr
), HOST_BITS_PER_INT
);
403 if (TREE_CODE (expr
) == FIELD_DECL
)
405 bp_pack_value (bp
, DECL_PACKED (expr
), 1);
406 bp_pack_value (bp
, DECL_NONADDRESSABLE_P (expr
), 1);
407 bp_pack_value (bp
, DECL_OFFSET_ALIGN (expr
), 8);
410 if (TREE_CODE (expr
) == RESULT_DECL
411 || TREE_CODE (expr
) == PARM_DECL
412 || TREE_CODE (expr
) == VAR_DECL
)
414 bp_pack_value (bp
, DECL_BY_REFERENCE (expr
), 1);
415 if (TREE_CODE (expr
) == VAR_DECL
416 || TREE_CODE (expr
) == PARM_DECL
)
417 bp_pack_value (bp
, DECL_HAS_VALUE_EXPR_P (expr
), 1);
418 bp_pack_value (bp
, DECL_RESTRICTED_P (expr
), 1);
423 /* Pack all the non-pointer fields of the TS_DECL_WRTL structure
424 of expression EXPR into bitpack BP. */
427 pack_ts_decl_wrtl_value_fields (struct bitpack_d
*bp
, tree expr
)
429 bp_pack_value (bp
, DECL_REGISTER (expr
), 1);
433 /* Pack all the non-pointer fields of the TS_DECL_WITH_VIS structure
434 of expression EXPR into bitpack BP. */
437 pack_ts_decl_with_vis_value_fields (struct bitpack_d
*bp
, tree expr
)
439 bp_pack_value (bp
, DECL_DEFER_OUTPUT (expr
), 1);
440 bp_pack_value (bp
, DECL_COMMON (expr
), 1);
441 bp_pack_value (bp
, DECL_DLLIMPORT_P (expr
), 1);
442 bp_pack_value (bp
, DECL_WEAK (expr
), 1);
443 bp_pack_value (bp
, DECL_SEEN_IN_BIND_EXPR_P (expr
), 1);
444 bp_pack_value (bp
, DECL_COMDAT (expr
), 1);
445 bp_pack_value (bp
, DECL_VISIBILITY (expr
), 2);
446 bp_pack_value (bp
, DECL_VISIBILITY_SPECIFIED (expr
), 1);
448 if (TREE_CODE (expr
) == VAR_DECL
)
450 bp_pack_value (bp
, DECL_HARD_REGISTER (expr
), 1);
451 bp_pack_value (bp
, DECL_IN_TEXT_SECTION (expr
), 1);
452 bp_pack_value (bp
, DECL_IN_CONSTANT_POOL (expr
), 1);
453 bp_pack_value (bp
, DECL_TLS_MODEL (expr
), 3);
456 if (VAR_OR_FUNCTION_DECL_P (expr
))
457 bp_pack_value (bp
, DECL_INIT_PRIORITY (expr
), HOST_BITS_PER_SHORT
);
461 /* Pack all the non-pointer fields of the TS_FUNCTION_DECL structure
462 of expression EXPR into bitpack BP. */
465 pack_ts_function_decl_value_fields (struct bitpack_d
*bp
, tree expr
)
467 /* For normal/md builtins we only write the class and code, so they
468 should never be handled here. */
469 gcc_assert (!lto_stream_as_builtin_p (expr
));
471 bp_pack_value (bp
, DECL_FUNCTION_CODE (expr
), 11);
472 bp_pack_value (bp
, DECL_BUILT_IN_CLASS (expr
), 2);
473 bp_pack_value (bp
, DECL_STATIC_CONSTRUCTOR (expr
), 1);
474 bp_pack_value (bp
, DECL_STATIC_DESTRUCTOR (expr
), 1);
475 bp_pack_value (bp
, DECL_UNINLINABLE (expr
), 1);
476 bp_pack_value (bp
, DECL_POSSIBLY_INLINED (expr
), 1);
477 bp_pack_value (bp
, DECL_IS_NOVOPS (expr
), 1);
478 bp_pack_value (bp
, DECL_IS_RETURNS_TWICE (expr
), 1);
479 bp_pack_value (bp
, DECL_IS_MALLOC (expr
), 1);
480 bp_pack_value (bp
, DECL_IS_OPERATOR_NEW (expr
), 1);
481 bp_pack_value (bp
, DECL_DECLARED_INLINE_P (expr
), 1);
482 bp_pack_value (bp
, DECL_STATIC_CHAIN (expr
), 1);
483 bp_pack_value (bp
, DECL_NO_INLINE_WARNING_P (expr
), 1);
484 bp_pack_value (bp
, DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (expr
), 1);
485 bp_pack_value (bp
, DECL_NO_LIMIT_STACK (expr
), 1);
486 bp_pack_value (bp
, DECL_DISREGARD_INLINE_LIMITS (expr
), 1);
487 bp_pack_value (bp
, DECL_PURE_P (expr
), 1);
488 bp_pack_value (bp
, DECL_LOOPING_CONST_OR_PURE_P (expr
), 1);
489 if (DECL_STATIC_DESTRUCTOR (expr
))
490 bp_pack_value (bp
, DECL_FINI_PRIORITY (expr
), HOST_BITS_PER_SHORT
);
494 /* Pack all the non-pointer fields of the TS_TYPE structure
495 of expression EXPR into bitpack BP. */
498 pack_ts_type_value_fields (struct bitpack_d
*bp
, tree expr
)
500 bp_pack_value (bp
, TYPE_PRECISION (expr
), 10);
501 bp_pack_value (bp
, TYPE_MODE (expr
), 8);
502 bp_pack_value (bp
, TYPE_STRING_FLAG (expr
), 1);
503 bp_pack_value (bp
, TYPE_NO_FORCE_BLK (expr
), 1);
504 bp_pack_value (bp
, TYPE_NEEDS_CONSTRUCTING (expr
), 1);
505 if (RECORD_OR_UNION_TYPE_P (expr
))
506 bp_pack_value (bp
, TYPE_TRANSPARENT_AGGR (expr
), 1);
507 bp_pack_value (bp
, TYPE_PACKED (expr
), 1);
508 bp_pack_value (bp
, TYPE_RESTRICT (expr
), 1);
509 bp_pack_value (bp
, TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr
), 2);
510 bp_pack_value (bp
, TYPE_USER_ALIGN (expr
), 1);
511 bp_pack_value (bp
, TYPE_READONLY (expr
), 1);
512 bp_pack_value (bp
, TYPE_ALIGN (expr
), HOST_BITS_PER_INT
);
513 bp_pack_value (bp
, TYPE_ALIAS_SET (expr
) == 0 ? 0 : -1,
514 BITS_PER_BITPACK_WORD
);
518 /* Pack all the non-pointer fields of the TS_BLOCK structure
519 of expression EXPR into bitpack BP. */
522 pack_ts_block_value_fields (struct bitpack_d
*bp
, tree expr
)
524 bp_pack_value (bp
, BLOCK_ABSTRACT (expr
), 1);
525 bp_pack_value (bp
, BLOCK_NUMBER (expr
), 31);
528 /* Pack all the non-pointer fields of the TS_TRANSLATION_UNIT_DECL structure
529 of expression EXPR into bitpack BP. */
532 pack_ts_translation_unit_decl_value_fields (struct bitpack_d
*bp ATTRIBUTE_UNUSED
, tree expr ATTRIBUTE_UNUSED
)
536 /* Pack all the non-pointer fields in EXPR into a bit pack. */
539 pack_value_fields (struct bitpack_d
*bp
, tree expr
)
543 code
= TREE_CODE (expr
);
545 /* Note that all these functions are highly sensitive to changes in
546 the types and sizes of each of the fields being packed. */
547 pack_ts_base_value_fields (bp
, expr
);
549 if (CODE_CONTAINS_STRUCT (code
, TS_REAL_CST
))
550 pack_ts_real_cst_value_fields (bp
, expr
);
552 if (CODE_CONTAINS_STRUCT (code
, TS_FIXED_CST
))
553 pack_ts_fixed_cst_value_fields (bp
, expr
);
555 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
556 pack_ts_decl_common_value_fields (bp
, expr
);
558 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WRTL
))
559 pack_ts_decl_wrtl_value_fields (bp
, expr
);
561 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
562 pack_ts_decl_with_vis_value_fields (bp
, expr
);
564 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
565 pack_ts_function_decl_value_fields (bp
, expr
);
567 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE
))
568 pack_ts_type_value_fields (bp
, expr
);
570 if (CODE_CONTAINS_STRUCT (code
, TS_BLOCK
))
571 pack_ts_block_value_fields (bp
, expr
);
573 if (CODE_CONTAINS_STRUCT (code
, TS_TRANSLATION_UNIT_DECL
))
574 pack_ts_translation_unit_decl_value_fields (bp
, expr
);
576 if (streamer_hooks ()->pack_value_fields
)
577 streamer_hooks ()->pack_value_fields (bp
, expr
);
581 /* Emit location LOC to output block OB. */
584 lto_output_location (struct output_block
*ob
, location_t loc
)
586 expanded_location xloc
;
588 if (loc
== UNKNOWN_LOCATION
)
590 lto_output_string (ob
, ob
->main_stream
, NULL
);
594 xloc
= expand_location (loc
);
596 lto_output_string (ob
, ob
->main_stream
, xloc
.file
);
597 output_sleb128 (ob
, xloc
.line
);
598 output_sleb128 (ob
, xloc
.column
);
599 output_sleb128 (ob
, xloc
.sysp
);
601 ob
->current_file
= xloc
.file
;
602 ob
->current_line
= xloc
.line
;
603 ob
->current_col
= xloc
.column
;
607 /* Return true if tree node T is written to various tables. For these
608 nodes, we sometimes want to write their phyiscal representation
609 (via lto_output_tree), and sometimes we need to emit an index
610 reference into a table (via lto_output_tree_ref). */
613 tree_is_indexable (tree t
)
615 if (TREE_CODE (t
) == PARM_DECL
)
617 else if (TREE_CODE (t
) == VAR_DECL
&& decl_function_context (t
)
621 return (TYPE_P (t
) || DECL_P (t
) || TREE_CODE (t
) == SSA_NAME
);
625 /* If EXPR is an indexable tree node, output a reference to it to
626 output block OB. Otherwise, output the physical representation of
630 lto_output_tree_ref (struct output_block
*ob
, tree expr
)
634 if (expr
== NULL_TREE
)
640 if (!tree_is_indexable (expr
))
642 /* Even though we are emitting the physical representation of
643 EXPR, its leaves must be emitted as references. */
644 lto_output_tree (ob
, expr
, true);
650 output_type_ref (ob
, expr
);
654 code
= TREE_CODE (expr
);
658 output_record_start (ob
, LTO_ssa_name_ref
);
659 output_uleb128 (ob
, SSA_NAME_VERSION (expr
));
663 output_record_start (ob
, LTO_field_decl_ref
);
664 lto_output_field_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
668 output_record_start (ob
, LTO_function_decl_ref
);
669 lto_output_fn_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
673 case DEBUG_EXPR_DECL
:
674 gcc_assert (decl_function_context (expr
) == NULL
675 || TREE_STATIC (expr
));
676 output_record_start (ob
, LTO_global_decl_ref
);
677 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
681 output_record_start (ob
, LTO_const_decl_ref
);
682 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
686 gcc_assert (decl_function_context (expr
) == NULL
);
687 output_record_start (ob
, LTO_imported_decl_ref
);
688 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
692 output_record_start (ob
, LTO_type_decl_ref
);
693 lto_output_type_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
697 output_record_start (ob
, LTO_namespace_decl_ref
);
698 lto_output_namespace_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
702 output_record_start (ob
, LTO_label_decl_ref
);
703 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
707 output_record_start (ob
, LTO_result_decl_ref
);
708 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
711 case TRANSLATION_UNIT_DECL
:
712 output_record_start (ob
, LTO_translation_unit_decl_ref
);
713 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
717 /* See if streamer hooks allows this node to be indexable with
719 if (streamer_hooks ()->indexable_with_decls_p
720 && streamer_hooks ()->indexable_with_decls_p (expr
))
722 output_record_start (ob
, LTO_global_decl_ref
);
723 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
727 /* No other node is indexable, so it should have been
728 handled by lto_output_tree. */
735 /* If REF_P is true, emit a reference to EXPR in output block OB,
736 otherwise emit the physical representation of EXPR in OB. */
739 lto_output_tree_or_ref (struct output_block
*ob
, tree expr
, bool ref_p
)
742 lto_output_tree_ref (ob
, expr
);
744 lto_output_tree (ob
, expr
, false);
748 /* Emit the chain of tree nodes starting at T. OB is the output block
749 to write to. REF_P is true if chain elements should be emitted
753 lto_output_chain (struct output_block
*ob
, tree t
, bool ref_p
)
757 count
= list_length (t
);
758 output_sleb128 (ob
, count
);
759 for (i
= 0; i
< count
; i
++)
763 /* Clear TREE_CHAIN to avoid blindly recursing into the rest
765 saved_chain
= TREE_CHAIN (t
);
766 TREE_CHAIN (t
) = NULL_TREE
;
768 lto_output_tree_or_ref (ob
, t
, ref_p
);
770 TREE_CHAIN (t
) = saved_chain
;
776 /* Write all pointer fields in the TS_COMMON structure of EXPR to output
777 block OB. If REF_P is true, write a reference to EXPR's pointer
781 lto_output_ts_common_tree_pointers (struct output_block
*ob
, tree expr
,
784 if (TREE_CODE (expr
) != IDENTIFIER_NODE
)
785 lto_output_tree_or_ref (ob
, TREE_TYPE (expr
), ref_p
);
789 /* Write all pointer fields in the TS_VECTOR structure of EXPR to output
790 block OB. If REF_P is true, write a reference to EXPR's pointer
794 lto_output_ts_vector_tree_pointers (struct output_block
*ob
, tree expr
,
797 lto_output_chain (ob
, TREE_VECTOR_CST_ELTS (expr
), ref_p
);
801 /* Write all pointer fields in the TS_COMPLEX structure of EXPR to output
802 block OB. If REF_P is true, write a reference to EXPR's pointer
806 lto_output_ts_complex_tree_pointers (struct output_block
*ob
, tree expr
,
809 lto_output_tree_or_ref (ob
, TREE_REALPART (expr
), ref_p
);
810 lto_output_tree_or_ref (ob
, TREE_IMAGPART (expr
), ref_p
);
814 /* Write all pointer fields in the TS_DECL_MINIMAL structure of EXPR
815 to output block OB. If REF_P is true, write a reference to EXPR's
819 lto_output_ts_decl_minimal_tree_pointers (struct output_block
*ob
, tree expr
,
822 lto_output_tree_or_ref (ob
, DECL_NAME (expr
), ref_p
);
823 lto_output_tree_or_ref (ob
, DECL_CONTEXT (expr
), ref_p
);
824 lto_output_location (ob
, DECL_SOURCE_LOCATION (expr
));
828 /* Write all pointer fields in the TS_DECL_COMMON structure of EXPR to
829 output block OB. If REF_P is true, write a reference to EXPR's
833 lto_output_ts_decl_common_tree_pointers (struct output_block
*ob
, tree expr
,
836 lto_output_tree_or_ref (ob
, DECL_SIZE (expr
), ref_p
);
837 lto_output_tree_or_ref (ob
, DECL_SIZE_UNIT (expr
), ref_p
);
839 /* Do not stream DECL_INITIAL. */
841 lto_output_tree_or_ref (ob
, DECL_ATTRIBUTES (expr
), ref_p
);
843 /* Do not stream DECL_ABSTRACT_ORIGIN. We cannot handle debug information
844 for early inlining so drop it on the floor instead of ICEing in
847 if (TREE_CODE (expr
) == PARM_DECL
)
848 lto_output_chain (ob
, TREE_CHAIN (expr
), ref_p
);
850 if ((TREE_CODE (expr
) == VAR_DECL
851 || TREE_CODE (expr
) == PARM_DECL
)
852 && DECL_HAS_VALUE_EXPR_P (expr
))
853 lto_output_tree_or_ref (ob
, DECL_VALUE_EXPR (expr
), ref_p
);
855 if (TREE_CODE (expr
) == VAR_DECL
)
856 lto_output_tree_or_ref (ob
, DECL_DEBUG_EXPR (expr
), ref_p
);
860 /* Write all pointer fields in the TS_DECL_NON_COMMON structure of
861 EXPR to output block OB. If REF_P is true, write a reference to EXPR's
865 lto_output_ts_decl_non_common_tree_pointers (struct output_block
*ob
,
866 tree expr
, bool ref_p
)
868 if (TREE_CODE (expr
) == FUNCTION_DECL
)
870 lto_output_tree_or_ref (ob
, DECL_ARGUMENTS (expr
), ref_p
);
871 lto_output_tree_or_ref (ob
, DECL_RESULT (expr
), ref_p
);
873 lto_output_tree_or_ref (ob
, DECL_VINDEX (expr
), ref_p
);
877 /* Write all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
878 to output block OB. If REF_P is true, write a reference to EXPR's
882 lto_output_ts_decl_with_vis_tree_pointers (struct output_block
*ob
, tree expr
,
885 /* Make sure we don't inadvertently set the assembler name. */
886 if (DECL_ASSEMBLER_NAME_SET_P (expr
))
887 lto_output_tree_or_ref (ob
, DECL_ASSEMBLER_NAME (expr
), ref_p
);
891 lto_output_tree_or_ref (ob
, DECL_SECTION_NAME (expr
), ref_p
);
892 lto_output_tree_or_ref (ob
, DECL_COMDAT_GROUP (expr
), ref_p
);
896 /* Write all pointer fields in the TS_FIELD_DECL structure of EXPR to
897 output block OB. If REF_P is true, write a reference to EXPR's
901 lto_output_ts_field_decl_tree_pointers (struct output_block
*ob
, tree expr
,
904 lto_output_tree_or_ref (ob
, DECL_FIELD_OFFSET (expr
), ref_p
);
905 lto_output_tree_or_ref (ob
, DECL_BIT_FIELD_TYPE (expr
), ref_p
);
906 lto_output_tree_or_ref (ob
, DECL_QUALIFIER (expr
), ref_p
);
907 lto_output_tree_or_ref (ob
, DECL_FIELD_BIT_OFFSET (expr
), ref_p
);
908 lto_output_tree_or_ref (ob
, DECL_FCONTEXT (expr
), ref_p
);
909 lto_output_chain (ob
, TREE_CHAIN (expr
), ref_p
);
913 /* Write all pointer fields in the TS_FUNCTION_DECL structure of EXPR
914 to output block OB. If REF_P is true, write a reference to EXPR's
918 lto_output_ts_function_decl_tree_pointers (struct output_block
*ob
, tree expr
,
921 /* DECL_STRUCT_FUNCTION is handled by lto_output_function. FIXME lto,
922 maybe it should be handled here? */
923 lto_output_tree_or_ref (ob
, DECL_FUNCTION_PERSONALITY (expr
), ref_p
);
924 lto_output_tree_or_ref (ob
, DECL_FUNCTION_SPECIFIC_TARGET (expr
), ref_p
);
925 lto_output_tree_or_ref (ob
, DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr
),
930 /* Write all pointer fields in the TS_TYPE structure of EXPR to output
931 block OB. If REF_P is true, write a reference to EXPR's pointer
935 lto_output_ts_type_tree_pointers (struct output_block
*ob
, tree expr
,
938 if (TREE_CODE (expr
) == ENUMERAL_TYPE
)
939 lto_output_tree_or_ref (ob
, TYPE_VALUES (expr
), ref_p
);
940 else if (TREE_CODE (expr
) == ARRAY_TYPE
)
941 lto_output_tree_or_ref (ob
, TYPE_DOMAIN (expr
), ref_p
);
942 else if (RECORD_OR_UNION_TYPE_P (expr
))
943 lto_output_tree_or_ref (ob
, TYPE_FIELDS (expr
), ref_p
);
944 else if (TREE_CODE (expr
) == FUNCTION_TYPE
945 || TREE_CODE (expr
) == METHOD_TYPE
)
946 lto_output_tree_or_ref (ob
, TYPE_ARG_TYPES (expr
), ref_p
);
948 lto_output_tree_or_ref (ob
, TYPE_SIZE (expr
), ref_p
);
949 lto_output_tree_or_ref (ob
, TYPE_SIZE_UNIT (expr
), ref_p
);
950 lto_output_tree_or_ref (ob
, TYPE_ATTRIBUTES (expr
), ref_p
);
951 lto_output_tree_or_ref (ob
, TYPE_NAME (expr
), ref_p
);
952 /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO nor
953 TYPE_NEXT_PTR_TO or TYPE_NEXT_REF_TO. */
954 if (!POINTER_TYPE_P (expr
))
955 lto_output_tree_or_ref (ob
, TYPE_MINVAL (expr
), ref_p
);
956 lto_output_tree_or_ref (ob
, TYPE_MAXVAL (expr
), ref_p
);
957 lto_output_tree_or_ref (ob
, TYPE_MAIN_VARIANT (expr
), ref_p
);
958 /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
960 if (RECORD_OR_UNION_TYPE_P (expr
))
961 lto_output_tree_or_ref (ob
, TYPE_BINFO (expr
), ref_p
);
962 lto_output_tree_or_ref (ob
, TYPE_CONTEXT (expr
), ref_p
);
963 /* TYPE_CANONICAL is re-computed during type merging, so no need
964 to stream it here. */
965 lto_output_tree_or_ref (ob
, TYPE_STUB_DECL (expr
), ref_p
);
969 /* Write all pointer fields in the TS_LIST structure of EXPR to output
970 block OB. If REF_P is true, write a reference to EXPR's pointer
974 lto_output_ts_list_tree_pointers (struct output_block
*ob
, tree expr
,
977 lto_output_tree_or_ref (ob
, TREE_PURPOSE (expr
), ref_p
);
978 lto_output_tree_or_ref (ob
, TREE_VALUE (expr
), ref_p
);
979 lto_output_chain (ob
, TREE_CHAIN (expr
), ref_p
);
983 /* Write all pointer fields in the TS_VEC structure of EXPR to output
984 block OB. If REF_P is true, write a reference to EXPR's pointer
988 lto_output_ts_vec_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
992 /* Note that the number of slots for EXPR has already been emitted
993 in EXPR's header (see lto_output_tree_header). */
994 for (i
= 0; i
< TREE_VEC_LENGTH (expr
); i
++)
995 lto_output_tree_or_ref (ob
, TREE_VEC_ELT (expr
, i
), ref_p
);
999 /* Write all pointer fields in the TS_EXP structure of EXPR to output
1000 block OB. If REF_P is true, write a reference to EXPR's pointer
1004 lto_output_ts_exp_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
1008 output_sleb128 (ob
, TREE_OPERAND_LENGTH (expr
));
1009 for (i
= 0; i
< TREE_OPERAND_LENGTH (expr
); i
++)
1010 lto_output_tree_or_ref (ob
, TREE_OPERAND (expr
, i
), ref_p
);
1011 lto_output_location (ob
, EXPR_LOCATION (expr
));
1012 lto_output_tree_or_ref (ob
, TREE_BLOCK (expr
), ref_p
);
1016 /* Write all pointer fields in the TS_BLOCK structure of EXPR to output
1017 block OB. If REF_P is true, write a reference to EXPR's pointer
1021 lto_output_ts_block_tree_pointers (struct output_block
*ob
, tree expr
,
1024 /* Do not stream BLOCK_SOURCE_LOCATION. We cannot handle debug information
1025 for early inlining so drop it on the floor instead of ICEing in
1027 lto_output_chain (ob
, BLOCK_VARS (expr
), ref_p
);
1029 /* Do not stream BLOCK_NONLOCALIZED_VARS. We cannot handle debug information
1030 for early inlining so drop it on the floor instead of ICEing in
1033 lto_output_tree_or_ref (ob
, BLOCK_SUPERCONTEXT (expr
), ref_p
);
1034 /* Do not stream BLOCK_ABSTRACT_ORIGIN. We cannot handle debug information
1035 for early inlining so drop it on the floor instead of ICEing in
1037 lto_output_tree_or_ref (ob
, BLOCK_FRAGMENT_ORIGIN (expr
), ref_p
);
1038 lto_output_tree_or_ref (ob
, BLOCK_FRAGMENT_CHAIN (expr
), ref_p
);
1039 /* Do not output BLOCK_SUBBLOCKS. Instead on streaming-in this
1040 list is re-constructed from BLOCK_SUPERCONTEXT. */
1044 /* Write all pointer fields in the TS_BINFO structure of EXPR to output
1045 block OB. If REF_P is true, write a reference to EXPR's pointer
1049 lto_output_ts_binfo_tree_pointers (struct output_block
*ob
, tree expr
,
1055 /* Note that the number of BINFO slots has already been emitted in
1056 EXPR's header (see lto_output_tree_header) because this length
1057 is needed to build the empty BINFO node on the reader side. */
1058 FOR_EACH_VEC_ELT (tree
, BINFO_BASE_BINFOS (expr
), i
, t
)
1059 lto_output_tree_or_ref (ob
, t
, ref_p
);
1062 lto_output_tree_or_ref (ob
, BINFO_OFFSET (expr
), ref_p
);
1063 lto_output_tree_or_ref (ob
, BINFO_VTABLE (expr
), ref_p
);
1064 lto_output_tree_or_ref (ob
, BINFO_VIRTUALS (expr
), ref_p
);
1065 lto_output_tree_or_ref (ob
, BINFO_VPTR_FIELD (expr
), ref_p
);
1067 output_uleb128 (ob
, VEC_length (tree
, BINFO_BASE_ACCESSES (expr
)));
1068 FOR_EACH_VEC_ELT (tree
, BINFO_BASE_ACCESSES (expr
), i
, t
)
1069 lto_output_tree_or_ref (ob
, t
, ref_p
);
1071 lto_output_tree_or_ref (ob
, BINFO_INHERITANCE_CHAIN (expr
), ref_p
);
1072 lto_output_tree_or_ref (ob
, BINFO_SUBVTT_INDEX (expr
), ref_p
);
1073 lto_output_tree_or_ref (ob
, BINFO_VPTR_INDEX (expr
), ref_p
);
1077 /* Write all pointer fields in the TS_CONSTRUCTOR structure of EXPR to
1078 output block OB. If REF_P is true, write a reference to EXPR's
1082 lto_output_ts_constructor_tree_pointers (struct output_block
*ob
, tree expr
,
1088 output_uleb128 (ob
, CONSTRUCTOR_NELTS (expr
));
1089 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (expr
), i
, index
, value
)
1091 lto_output_tree_or_ref (ob
, index
, ref_p
);
1092 lto_output_tree_or_ref (ob
, value
, ref_p
);
1096 /* Write a TS_TARGET_OPTION tree in EXPR to OB. */
1099 lto_output_ts_target_option (struct output_block
*ob
, tree expr
)
1101 struct cl_target_option
*t
= TREE_TARGET_OPTION (expr
);
1102 struct bitpack_d bp
;
1105 /* The cl_target_option is target specific and generated by the options
1106 awk script, so we just recreate a byte-by-byte copy here. */
1108 bp
= bitpack_create (ob
->main_stream
);
1109 len
= sizeof (struct cl_target_option
);
1110 for (i
= 0; i
< len
; i
++)
1111 bp_pack_value (&bp
, ((unsigned char *)t
)[i
], 8);
1112 /* Catch struct size mismatches between reader and writer. */
1113 bp_pack_value (&bp
, 0x12345678, 32);
1114 lto_output_bitpack (&bp
);
1117 /* Write a TS_TRANSLATION_UNIT_DECL tree in EXPR to OB. */
1120 lto_output_ts_translation_unit_decl_tree_pointers (struct output_block
*ob
,
1123 lto_output_string (ob
, ob
->main_stream
, TRANSLATION_UNIT_LANGUAGE (expr
));
1126 /* Helper for lto_output_tree. Write all pointer fields in EXPR to output
1127 block OB. If REF_P is true, the leaves of EXPR are emitted as
1131 lto_output_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
1133 enum tree_code code
;
1135 code
= TREE_CODE (expr
);
1137 if (CODE_CONTAINS_STRUCT (code
, TS_TYPED
))
1138 lto_output_ts_common_tree_pointers (ob
, expr
, ref_p
);
1140 if (CODE_CONTAINS_STRUCT (code
, TS_VECTOR
))
1141 lto_output_ts_vector_tree_pointers (ob
, expr
, ref_p
);
1143 if (CODE_CONTAINS_STRUCT (code
, TS_COMPLEX
))
1144 lto_output_ts_complex_tree_pointers (ob
, expr
, ref_p
);
1146 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
1147 lto_output_ts_decl_minimal_tree_pointers (ob
, expr
, ref_p
);
1149 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
1150 lto_output_ts_decl_common_tree_pointers (ob
, expr
, ref_p
);
1152 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_NON_COMMON
))
1153 lto_output_ts_decl_non_common_tree_pointers (ob
, expr
, ref_p
);
1155 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
1156 lto_output_ts_decl_with_vis_tree_pointers (ob
, expr
, ref_p
);
1158 if (CODE_CONTAINS_STRUCT (code
, TS_FIELD_DECL
))
1159 lto_output_ts_field_decl_tree_pointers (ob
, expr
, ref_p
);
1161 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
1162 lto_output_ts_function_decl_tree_pointers (ob
, expr
, ref_p
);
1164 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE
))
1165 lto_output_ts_type_tree_pointers (ob
, expr
, ref_p
);
1167 if (CODE_CONTAINS_STRUCT (code
, TS_LIST
))
1168 lto_output_ts_list_tree_pointers (ob
, expr
, ref_p
);
1170 if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
1171 lto_output_ts_vec_tree_pointers (ob
, expr
, ref_p
);
1173 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
1174 lto_output_ts_exp_tree_pointers (ob
, expr
, ref_p
);
1176 if (CODE_CONTAINS_STRUCT (code
, TS_BLOCK
))
1177 lto_output_ts_block_tree_pointers (ob
, expr
, ref_p
);
1179 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
1180 lto_output_ts_binfo_tree_pointers (ob
, expr
, ref_p
);
1182 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
1183 lto_output_ts_constructor_tree_pointers (ob
, expr
, ref_p
);
1185 if (CODE_CONTAINS_STRUCT (code
, TS_TARGET_OPTION
))
1186 lto_output_ts_target_option (ob
, expr
);
1188 if (CODE_CONTAINS_STRUCT (code
, TS_TRANSLATION_UNIT_DECL
))
1189 lto_output_ts_translation_unit_decl_tree_pointers (ob
, expr
);
1193 /* Emit header information for tree EXPR to output block OB. The header
1194 contains everything needed to instantiate an empty skeleton for
1195 EXPR on the reading side. IX is the index into the streamer cache
1196 where EXPR is stored. REF_P is as in lto_output_tree. */
1199 lto_output_tree_header (struct output_block
*ob
, tree expr
)
1202 enum tree_code code
;
1203 lto_streamer_hooks
*h
= streamer_hooks ();
1205 /* We should not see any non-GIMPLE tree nodes here. */
1206 code
= TREE_CODE (expr
);
1207 if (h
->is_streamable
&& !h
->is_streamable (expr
))
1208 internal_error ("tree code %qs is not supported in %s streams",
1209 h
->name
, tree_code_name
[code
]);
1211 /* The header of a tree node consists of its tag, the size of
1212 the node, and any other information needed to instantiate
1213 EXPR on the reading side (such as the number of slots in
1214 variable sized nodes). */
1215 tag
= lto_tree_code_to_tag (code
);
1216 gcc_assert ((unsigned) tag
< (unsigned) LTO_NUM_TAGS
);
1217 output_record_start (ob
, tag
);
1219 /* The following will cause bootstrap miscomparisons. Enable with care. */
1220 #ifdef LTO_STREAMER_DEBUG
1221 /* This is used mainly for debugging purposes. When the reader
1222 and the writer do not agree on a streamed node, the pointer
1223 value for EXPR can be used to track down the differences in
1225 gcc_assert ((HOST_WIDEST_INT
) (intptr_t) expr
== (intptr_t) expr
);
1226 output_sleb128 (ob
, (HOST_WIDEST_INT
) (intptr_t) expr
);
1229 /* The text in strings and identifiers are completely emitted in
1231 if (CODE_CONTAINS_STRUCT (code
, TS_STRING
))
1232 output_string_cst (ob
, ob
->main_stream
, expr
);
1233 else if (CODE_CONTAINS_STRUCT (code
, TS_IDENTIFIER
))
1234 output_identifier (ob
, ob
->main_stream
, expr
);
1235 else if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
1236 output_sleb128 (ob
, TREE_VEC_LENGTH (expr
));
1237 else if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
1238 output_uleb128 (ob
, BINFO_N_BASE_BINFOS (expr
));
1240 /* Allow the streamer to write any streamer-specific information
1241 needed to instantiate the node when reading. */
1242 if (streamer_hooks ()->output_tree_header
)
1243 streamer_hooks ()->output_tree_header (ob
, expr
);
1247 /* Write the code and class of builtin EXPR to output block OB. IX is
1248 the index into the streamer cache where EXPR is stored.*/
1251 lto_output_builtin_tree (struct output_block
*ob
, tree expr
)
1253 gcc_assert (lto_stream_as_builtin_p (expr
));
1255 if (DECL_BUILT_IN_CLASS (expr
) == BUILT_IN_MD
1256 && !targetm
.builtin_decl
)
1257 sorry ("gimple bytecode streams do not support machine specific builtin "
1258 "functions on this target");
1260 output_record_start (ob
, LTO_builtin_decl
);
1261 output_uleb128 (ob
, DECL_BUILT_IN_CLASS (expr
));
1262 output_uleb128 (ob
, DECL_FUNCTION_CODE (expr
));
1264 if (DECL_ASSEMBLER_NAME_SET_P (expr
))
1266 /* When the assembler name of a builtin gets a user name,
1267 the new name is always prefixed with '*' by
1268 set_builtin_user_assembler_name. So, to prevent the
1269 reader side from adding a second '*', we omit it here. */
1270 const char *str
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (expr
));
1271 if (strlen (str
) > 1 && str
[0] == '*')
1272 lto_output_string (ob
, ob
->main_stream
, &str
[1]);
1274 lto_output_string (ob
, ob
->main_stream
, NULL
);
1277 lto_output_string (ob
, ob
->main_stream
, NULL
);
1281 /* Write a physical representation of tree node EXPR to output block
1282 OB. If REF_P is true, the leaves of EXPR are emitted as references
1283 via lto_output_tree_ref. IX is the index into the streamer cache
1284 where EXPR is stored. */
1287 lto_write_tree (struct output_block
*ob
, tree expr
, bool ref_p
)
1289 struct bitpack_d bp
;
1291 /* Write the header, containing everything needed to materialize
1292 EXPR on the reading side. */
1293 lto_output_tree_header (ob
, expr
);
1295 /* Pack all the non-pointer fields in EXPR into a bitpack and write
1296 the resulting bitpack. */
1297 bp
= bitpack_create (ob
->main_stream
);
1298 pack_value_fields (&bp
, expr
);
1299 lto_output_bitpack (&bp
);
1301 /* Write all the pointer fields in EXPR. */
1302 lto_output_tree_pointers (ob
, expr
, ref_p
);
1304 /* Call back into the streaming module to see if it needs to write
1305 anything that was not written by the common streamer. */
1306 if (streamer_hooks ()->write_tree
)
1307 streamer_hooks ()->write_tree (ob
, expr
, ref_p
);
1309 /* Mark the end of EXPR. */
1314 /* GIMPLE hook for writing GIMPLE-specific parts of trees. OB, EXPR
1315 and REF_P are as in lto_write_tree. */
1318 gimple_streamer_write_tree (struct output_block
*ob
, tree expr
, bool ref_p
)
1320 if (TREE_CODE (expr
) == FUNCTION_DECL
)
1322 /* DECL_SAVED_TREE holds the GENERIC representation for DECL.
1323 At this point, it should not exist. Either because it was
1324 converted to gimple or because DECL didn't have a GENERIC
1325 representation in this TU. */
1326 gcc_assert (DECL_SAVED_TREE (expr
) == NULL_TREE
);
1330 && TREE_CODE (expr
) != FUNCTION_DECL
1331 && TREE_CODE (expr
) != TRANSLATION_UNIT_DECL
)
1333 /* Handle DECL_INITIAL for symbols. */
1334 tree initial
= DECL_INITIAL (expr
);
1335 if (TREE_CODE (expr
) == VAR_DECL
1336 && (TREE_STATIC (expr
) || DECL_EXTERNAL (expr
))
1339 lto_varpool_encoder_t varpool_encoder
;
1340 struct varpool_node
*vnode
;
1342 varpool_encoder
= ob
->decl_state
->varpool_node_encoder
;
1343 vnode
= varpool_get_node (expr
);
1345 initial
= error_mark_node
;
1346 else if (!lto_varpool_encoder_encode_initializer_p (varpool_encoder
,
1351 lto_output_tree_or_ref (ob
, initial
, ref_p
);
1356 /* Emit the integer constant CST to output block OB. If REF_P is true,
1357 CST's type will be emitted as a reference. */
1360 lto_output_integer_cst (struct output_block
*ob
, tree cst
, bool ref_p
)
1362 output_record_start (ob
, lto_tree_code_to_tag (INTEGER_CST
));
1363 lto_output_tree_or_ref (ob
, TREE_TYPE (cst
), ref_p
);
1364 lto_output_1_stream (ob
->main_stream
, TREE_OVERFLOW_P (cst
));
1365 output_uleb128 (ob
, TREE_INT_CST_LOW (cst
));
1366 output_uleb128 (ob
, TREE_INT_CST_HIGH (cst
));
1370 /* Emit the physical representation of tree node EXPR to output block
1371 OB. If REF_P is true, the leaves of EXPR are emitted as references
1372 via lto_output_tree_ref. */
1375 lto_output_tree (struct output_block
*ob
, tree expr
, bool ref_p
)
1380 if (expr
== NULL_TREE
)
1386 /* INTEGER_CST nodes are special because they need their original type
1387 to be materialized by the reader (to implement TYPE_CACHED_VALUES). */
1388 if (TREE_CODE (expr
) == INTEGER_CST
)
1390 lto_output_integer_cst (ob
, expr
, ref_p
);
1394 existed_p
= lto_streamer_cache_insert (ob
->writer_cache
, expr
, &ix
);
1397 /* If a node has already been streamed out, make sure that
1398 we don't write it more than once. Otherwise, the reader
1399 will instantiate two different nodes for the same object. */
1400 output_record_start (ob
, LTO_tree_pickle_reference
);
1401 output_uleb128 (ob
, ix
);
1402 output_uleb128 (ob
, lto_tree_code_to_tag (TREE_CODE (expr
)));
1404 else if (lto_stream_as_builtin_p (expr
))
1406 /* MD and NORMAL builtins do not need to be written out
1407 completely as they are always instantiated by the
1408 compiler on startup. The only builtins that need to
1409 be written out are BUILT_IN_FRONTEND. For all other
1410 builtins, we simply write the class and code. */
1411 lto_output_builtin_tree (ob
, expr
);
1415 /* This is the first time we see EXPR, write its fields
1417 lto_write_tree (ob
, expr
, ref_p
);
1422 /* Output to OB a list of try/catch handlers starting with FIRST. */
1425 output_eh_try_list (struct output_block
*ob
, eh_catch first
)
1429 for (n
= first
; n
; n
= n
->next_catch
)
1431 output_record_start (ob
, LTO_eh_catch
);
1432 lto_output_tree_ref (ob
, n
->type_list
);
1433 lto_output_tree_ref (ob
, n
->filter_list
);
1434 lto_output_tree_ref (ob
, n
->label
);
1441 /* Output EH region R in function FN to OB. CURR_RN is the slot index
1442 that is being emitted in FN->EH->REGION_ARRAY. This is used to
1443 detect EH region sharing. */
1446 output_eh_region (struct output_block
*ob
, eh_region r
)
1456 if (r
->type
== ERT_CLEANUP
)
1457 tag
= LTO_ert_cleanup
;
1458 else if (r
->type
== ERT_TRY
)
1460 else if (r
->type
== ERT_ALLOWED_EXCEPTIONS
)
1461 tag
= LTO_ert_allowed_exceptions
;
1462 else if (r
->type
== ERT_MUST_NOT_THROW
)
1463 tag
= LTO_ert_must_not_throw
;
1467 output_record_start (ob
, tag
);
1468 output_sleb128 (ob
, r
->index
);
1471 output_sleb128 (ob
, r
->outer
->index
);
1476 output_sleb128 (ob
, r
->inner
->index
);
1481 output_sleb128 (ob
, r
->next_peer
->index
);
1485 if (r
->type
== ERT_TRY
)
1487 output_eh_try_list (ob
, r
->u
.eh_try
.first_catch
);
1489 else if (r
->type
== ERT_ALLOWED_EXCEPTIONS
)
1491 lto_output_tree_ref (ob
, r
->u
.allowed
.type_list
);
1492 lto_output_tree_ref (ob
, r
->u
.allowed
.label
);
1493 output_uleb128 (ob
, r
->u
.allowed
.filter
);
1495 else if (r
->type
== ERT_MUST_NOT_THROW
)
1497 lto_output_tree_ref (ob
, r
->u
.must_not_throw
.failure_decl
);
1498 lto_output_location (ob
, r
->u
.must_not_throw
.failure_loc
);
1501 if (r
->landing_pads
)
1502 output_sleb128 (ob
, r
->landing_pads
->index
);
1508 /* Output landing pad LP to OB. */
1511 output_eh_lp (struct output_block
*ob
, eh_landing_pad lp
)
1519 output_record_start (ob
, LTO_eh_landing_pad
);
1520 output_sleb128 (ob
, lp
->index
);
1522 output_sleb128 (ob
, lp
->next_lp
->index
);
1527 output_sleb128 (ob
, lp
->region
->index
);
1531 lto_output_tree_ref (ob
, lp
->post_landing_pad
);
1535 /* Output the existing eh_table to OB. */
1538 output_eh_regions (struct output_block
*ob
, struct function
*fn
)
1540 if (fn
->eh
&& fn
->eh
->region_tree
)
1547 output_record_start (ob
, LTO_eh_table
);
1549 /* Emit the index of the root of the EH region tree. */
1550 output_sleb128 (ob
, fn
->eh
->region_tree
->index
);
1552 /* Emit all the EH regions in the region array. */
1553 output_sleb128 (ob
, VEC_length (eh_region
, fn
->eh
->region_array
));
1554 FOR_EACH_VEC_ELT (eh_region
, fn
->eh
->region_array
, i
, eh
)
1555 output_eh_region (ob
, eh
);
1557 /* Emit all landing pads. */
1558 output_sleb128 (ob
, VEC_length (eh_landing_pad
, fn
->eh
->lp_array
));
1559 FOR_EACH_VEC_ELT (eh_landing_pad
, fn
->eh
->lp_array
, i
, lp
)
1560 output_eh_lp (ob
, lp
);
1562 /* Emit all the runtime type data. */
1563 output_sleb128 (ob
, VEC_length (tree
, fn
->eh
->ttype_data
));
1564 FOR_EACH_VEC_ELT (tree
, fn
->eh
->ttype_data
, i
, ttype
)
1565 lto_output_tree_ref (ob
, ttype
);
1567 /* Emit the table of action chains. */
1568 if (targetm
.arm_eabi_unwinder
)
1571 output_sleb128 (ob
, VEC_length (tree
, fn
->eh
->ehspec_data
.arm_eabi
));
1572 FOR_EACH_VEC_ELT (tree
, fn
->eh
->ehspec_data
.arm_eabi
, i
, t
)
1573 lto_output_tree_ref (ob
, t
);
1578 output_sleb128 (ob
, VEC_length (uchar
, fn
->eh
->ehspec_data
.other
));
1579 FOR_EACH_VEC_ELT (uchar
, fn
->eh
->ehspec_data
.other
, i
, c
)
1580 lto_output_1_stream (ob
->main_stream
, c
);
1584 /* The 0 either terminates the record or indicates that there are no
1585 eh_records at all. */
1590 /* Output all of the active ssa names to the ssa_names stream. */
1593 output_ssa_names (struct output_block
*ob
, struct function
*fn
)
1595 unsigned int i
, len
;
1597 len
= VEC_length (tree
, SSANAMES (fn
));
1598 output_uleb128 (ob
, len
);
1600 for (i
= 1; i
< len
; i
++)
1602 tree ptr
= VEC_index (tree
, SSANAMES (fn
), i
);
1604 if (ptr
== NULL_TREE
1605 || SSA_NAME_IN_FREE_LIST (ptr
)
1606 || !is_gimple_reg (ptr
))
1609 output_uleb128 (ob
, i
);
1610 lto_output_1_stream (ob
->main_stream
, SSA_NAME_IS_DEFAULT_DEF (ptr
));
1611 lto_output_tree_ref (ob
, SSA_NAME_VAR (ptr
));
1618 /* Output the cfg. */
1621 output_cfg (struct output_block
*ob
, struct function
*fn
)
1623 struct lto_output_stream
*tmp_stream
= ob
->main_stream
;
1626 ob
->main_stream
= ob
->cfg_stream
;
1628 output_uleb128 (ob
, profile_status_for_function (fn
));
1630 /* Output the number of the highest basic block. */
1631 output_uleb128 (ob
, last_basic_block_for_function (fn
));
1633 FOR_ALL_BB_FN (bb
, fn
)
1638 output_sleb128 (ob
, bb
->index
);
1640 /* Output the successors and the edge flags. */
1641 output_uleb128 (ob
, EDGE_COUNT (bb
->succs
));
1642 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
1644 output_uleb128 (ob
, e
->dest
->index
);
1645 output_sleb128 (ob
, e
->probability
);
1646 output_sleb128 (ob
, e
->count
);
1647 output_uleb128 (ob
, e
->flags
);
1651 output_sleb128 (ob
, -1);
1653 bb
= ENTRY_BLOCK_PTR
;
1656 output_sleb128 (ob
, bb
->next_bb
->index
);
1660 output_sleb128 (ob
, -1);
1662 ob
->main_stream
= tmp_stream
;
1666 /* Output PHI function PHI to the main stream in OB. */
1669 output_phi (struct output_block
*ob
, gimple phi
)
1671 unsigned i
, len
= gimple_phi_num_args (phi
);
1673 output_record_start (ob
, lto_gimple_code_to_tag (GIMPLE_PHI
));
1674 output_uleb128 (ob
, SSA_NAME_VERSION (PHI_RESULT (phi
)));
1676 for (i
= 0; i
< len
; i
++)
1678 lto_output_tree_ref (ob
, gimple_phi_arg_def (phi
, i
));
1679 output_uleb128 (ob
, gimple_phi_arg_edge (phi
, i
)->src
->index
);
1680 lto_output_location (ob
, gimple_phi_arg_location (phi
, i
));
1685 /* Emit statement STMT on the main stream of output block OB. */
1688 output_gimple_stmt (struct output_block
*ob
, gimple stmt
)
1691 enum gimple_code code
;
1693 struct bitpack_d bp
;
1695 /* Emit identifying tag. */
1696 code
= gimple_code (stmt
);
1697 tag
= lto_gimple_code_to_tag (code
);
1698 output_record_start (ob
, tag
);
1700 /* Emit the tuple header. */
1701 bp
= bitpack_create (ob
->main_stream
);
1702 bp_pack_value (&bp
, gimple_num_ops (stmt
), sizeof (unsigned) * 8);
1703 bp_pack_value (&bp
, gimple_no_warning_p (stmt
), 1);
1704 if (is_gimple_assign (stmt
))
1705 bp_pack_value (&bp
, gimple_assign_nontemporal_move_p (stmt
), 1);
1706 bp_pack_value (&bp
, gimple_has_volatile_ops (stmt
), 1);
1707 bp_pack_value (&bp
, stmt
->gsbase
.subcode
, 16);
1708 lto_output_bitpack (&bp
);
1710 /* Emit location information for the statement. */
1711 lto_output_location (ob
, gimple_location (stmt
));
1713 /* Emit the lexical block holding STMT. */
1714 lto_output_tree (ob
, gimple_block (stmt
), true);
1716 /* Emit the operands. */
1717 switch (gimple_code (stmt
))
1720 output_sleb128 (ob
, gimple_resx_region (stmt
));
1723 case GIMPLE_EH_MUST_NOT_THROW
:
1724 lto_output_tree_ref (ob
, gimple_eh_must_not_throw_fndecl (stmt
));
1727 case GIMPLE_EH_DISPATCH
:
1728 output_sleb128 (ob
, gimple_eh_dispatch_region (stmt
));
1732 lto_output_uleb128_stream (ob
->main_stream
, gimple_asm_ninputs (stmt
));
1733 lto_output_uleb128_stream (ob
->main_stream
, gimple_asm_noutputs (stmt
));
1734 lto_output_uleb128_stream (ob
->main_stream
, gimple_asm_nclobbers (stmt
));
1735 lto_output_uleb128_stream (ob
->main_stream
, gimple_asm_nlabels (stmt
));
1736 lto_output_string (ob
, ob
->main_stream
, gimple_asm_string (stmt
));
1747 for (i
= 0; i
< gimple_num_ops (stmt
); i
++)
1749 tree op
= gimple_op (stmt
, i
);
1750 /* Wrap all uses of non-automatic variables inside MEM_REFs
1751 so that we do not have to deal with type mismatches on
1752 merged symbols during IL read in. The first operand
1753 of GIMPLE_DEBUG must be a decl, not MEM_REF, though. */
1754 if (op
&& (i
|| !is_gimple_debug (stmt
)))
1757 while (handled_component_p (*basep
))
1758 basep
= &TREE_OPERAND (*basep
, 0);
1759 if (TREE_CODE (*basep
) == VAR_DECL
1760 && !auto_var_in_fn_p (*basep
, current_function_decl
)
1761 && !DECL_REGISTER (*basep
))
1763 bool volatilep
= TREE_THIS_VOLATILE (*basep
);
1764 *basep
= build2 (MEM_REF
, TREE_TYPE (*basep
),
1765 build_fold_addr_expr (*basep
),
1766 build_int_cst (build_pointer_type
1767 (TREE_TYPE (*basep
)), 0));
1768 TREE_THIS_VOLATILE (*basep
) = volatilep
;
1771 lto_output_tree_ref (ob
, op
);
1773 if (is_gimple_call (stmt
))
1774 lto_output_tree_ref (ob
, gimple_call_fntype (stmt
));
1778 case GIMPLE_PREDICT
:
1787 /* Output a basic block BB to the main stream in OB for this FN. */
1790 output_bb (struct output_block
*ob
, basic_block bb
, struct function
*fn
)
1792 gimple_stmt_iterator bsi
= gsi_start_bb (bb
);
1794 output_record_start (ob
,
1795 (!gsi_end_p (bsi
)) || phi_nodes (bb
)
1799 output_uleb128 (ob
, bb
->index
);
1800 output_sleb128 (ob
, bb
->count
);
1801 output_sleb128 (ob
, bb
->loop_depth
);
1802 output_sleb128 (ob
, bb
->frequency
);
1803 output_sleb128 (ob
, bb
->flags
);
1805 if (!gsi_end_p (bsi
) || phi_nodes (bb
))
1807 /* Output the statements. The list of statements is terminated
1809 for (bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
1812 gimple stmt
= gsi_stmt (bsi
);
1814 output_gimple_stmt (ob
, stmt
);
1816 /* Emit the EH region holding STMT. */
1817 region
= lookup_stmt_eh_lp_fn (fn
, stmt
);
1820 output_record_start (ob
, LTO_eh_region
);
1821 output_sleb128 (ob
, region
);
1829 for (bsi
= gsi_start_phis (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
1831 gimple phi
= gsi_stmt (bsi
);
1833 /* Only emit PHIs for gimple registers. PHI nodes for .MEM
1834 will be filled in on reading when the SSA form is
1836 if (is_gimple_reg (gimple_phi_result (phi
)))
1837 output_phi (ob
, phi
);
1844 /* Create the header in the file using OB. If the section type is for
1845 a function, set FN to the decl for that function. */
1848 produce_asm (struct output_block
*ob
, tree fn
)
1850 enum lto_section_type section_type
= ob
->section_type
;
1851 struct lto_function_header header
;
1853 struct lto_output_stream
*header_stream
;
1855 if (section_type
== LTO_section_function_body
)
1857 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fn
));
1858 section_name
= lto_get_section_name (section_type
, name
, NULL
);
1861 section_name
= lto_get_section_name (section_type
, NULL
, NULL
);
1863 lto_begin_section (section_name
, !flag_wpa
);
1864 free (section_name
);
1866 /* The entire header is stream computed here. */
1867 memset (&header
, 0, sizeof (struct lto_function_header
));
1869 /* Write the header. */
1870 header
.lto_header
.major_version
= LTO_major_version
;
1871 header
.lto_header
.minor_version
= LTO_minor_version
;
1872 header
.lto_header
.section_type
= section_type
;
1874 header
.compressed_size
= 0;
1876 if (section_type
== LTO_section_function_body
)
1877 header
.cfg_size
= ob
->cfg_stream
->total_size
;
1878 header
.main_size
= ob
->main_stream
->total_size
;
1879 header
.string_size
= ob
->string_stream
->total_size
;
1881 header_stream
= XCNEW (struct lto_output_stream
);
1882 lto_output_data_stream (header_stream
, &header
, sizeof header
);
1883 lto_write_stream (header_stream
);
1884 free (header_stream
);
1886 /* Put all of the gimple and the string table out the asm file as a
1888 if (section_type
== LTO_section_function_body
)
1889 lto_write_stream (ob
->cfg_stream
);
1890 lto_write_stream (ob
->main_stream
);
1891 lto_write_stream (ob
->string_stream
);
1897 /* Output the body of function NODE->DECL. */
1900 output_function (struct cgraph_node
*node
)
1902 struct bitpack_d bp
;
1904 struct function
*fn
;
1906 struct output_block
*ob
;
1910 function
= node
->decl
;
1911 fn
= DECL_STRUCT_FUNCTION (function
);
1912 ob
= create_output_block (LTO_section_function_body
);
1914 clear_line_info (ob
);
1915 ob
->cgraph_node
= node
;
1917 gcc_assert (current_function_decl
== NULL_TREE
&& cfun
== NULL
);
1919 /* Set current_function_decl and cfun. */
1920 current_function_decl
= function
;
1923 /* Make string 0 be a NULL string. */
1924 lto_output_1_stream (ob
->string_stream
, 0);
1926 output_record_start (ob
, LTO_function
);
1928 /* Write all the attributes for FN. */
1929 bp
= bitpack_create (ob
->main_stream
);
1930 bp_pack_value (&bp
, fn
->is_thunk
, 1);
1931 bp_pack_value (&bp
, fn
->has_local_explicit_reg_vars
, 1);
1932 bp_pack_value (&bp
, fn
->after_tree_profile
, 1);
1933 bp_pack_value (&bp
, fn
->returns_pcc_struct
, 1);
1934 bp_pack_value (&bp
, fn
->returns_struct
, 1);
1935 bp_pack_value (&bp
, fn
->can_throw_non_call_exceptions
, 1);
1936 bp_pack_value (&bp
, fn
->always_inline_functions_inlined
, 1);
1937 bp_pack_value (&bp
, fn
->after_inlining
, 1);
1938 bp_pack_value (&bp
, fn
->dont_save_pending_sizes_p
, 1);
1939 bp_pack_value (&bp
, fn
->stdarg
, 1);
1940 bp_pack_value (&bp
, fn
->has_nonlocal_label
, 1);
1941 bp_pack_value (&bp
, fn
->calls_alloca
, 1);
1942 bp_pack_value (&bp
, fn
->calls_setjmp
, 1);
1943 bp_pack_value (&bp
, fn
->va_list_fpr_size
, 8);
1944 bp_pack_value (&bp
, fn
->va_list_gpr_size
, 8);
1945 lto_output_bitpack (&bp
);
1947 /* Output the function start and end loci. */
1948 lto_output_location (ob
, fn
->function_start_locus
);
1949 lto_output_location (ob
, fn
->function_end_locus
);
1951 /* Output current IL state of the function. */
1952 output_uleb128 (ob
, fn
->curr_properties
);
1954 /* Output the static chain and non-local goto save area. */
1955 lto_output_tree_ref (ob
, fn
->static_chain_decl
);
1956 lto_output_tree_ref (ob
, fn
->nonlocal_goto_save_area
);
1958 /* Output all the local variables in the function. */
1959 output_sleb128 (ob
, VEC_length (tree
, fn
->local_decls
));
1960 FOR_EACH_VEC_ELT (tree
, fn
->local_decls
, i
, t
)
1961 lto_output_tree_ref (ob
, t
);
1963 /* Output the head of the arguments list. */
1964 lto_output_tree_ref (ob
, DECL_ARGUMENTS (function
));
1966 /* Output all the SSA names used in the function. */
1967 output_ssa_names (ob
, fn
);
1969 /* Output any exception handling regions. */
1970 output_eh_regions (ob
, fn
);
1972 /* Output DECL_INITIAL for the function, which contains the tree of
1974 lto_output_tree (ob
, DECL_INITIAL (function
), true);
1976 /* We will renumber the statements. The code that does this uses
1977 the same ordering that we use for serializing them so we can use
1978 the same code on the other end and not have to write out the
1979 statement numbers. We do not assign UIDs to PHIs here because
1980 virtual PHIs get re-computed on-the-fly which would make numbers
1982 set_gimple_stmt_max_uid (cfun
, 0);
1985 gimple_stmt_iterator gsi
;
1986 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1988 gimple stmt
= gsi_stmt (gsi
);
1989 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
1993 /* Output the code for the function. */
1994 FOR_ALL_BB_FN (bb
, fn
)
1995 output_bb (ob
, bb
, fn
);
1997 /* The terminator for this function. */
2000 output_cfg (ob
, fn
);
2002 /* Create a section to hold the pickled output of this function. */
2003 produce_asm (ob
, function
);
2005 destroy_output_block (ob
);
2007 current_function_decl
= NULL
;
2012 /* Used to pass data to trivally_defined_alias callback. */
2014 cgraph_node_set set
;
2015 varpool_node_set vset
;
2019 /* Return true if alias pair P belongs to the set of cgraph nodes in
2020 SET. If P is a an alias for a VAR_DECL, it can always be emitted.
2021 However, for FUNCTION_DECL aliases, we should only output the pair
2022 if it belongs to a function whose cgraph node is in SET.
2023 Otherwise, the LTRANS phase will get into trouble when finalizing
2024 aliases because the alias will refer to a function not defined in
2025 the file processed by LTRANS. */
2028 trivally_defined_alias (tree decl ATTRIBUTE_UNUSED
,
2029 tree target
, void *data
)
2031 struct sets
*set
= (struct sets
*) data
;
2032 struct cgraph_node
*fnode
= NULL
;
2033 struct varpool_node
*vnode
= NULL
;
2035 fnode
= cgraph_node_for_asm (target
);
2037 return cgraph_node_in_set_p (fnode
, set
->set
);
2038 vnode
= varpool_node_for_asm (target
);
2039 return vnode
&& varpool_node_in_set_p (vnode
, set
->vset
);
2042 /* Return true if alias pair P should be output in the current
2043 partition contains cgrpah nodes SET and varpool nodes VSET.
2044 DEFINED is set of all aliases whose targets are defined in
2047 Normal aliases are output when they are defined, while WEAKREF
2048 aliases are output when they are used. */
2051 output_alias_pair_p (alias_pair
*p
, symbol_alias_set_t
*defined
,
2052 cgraph_node_set set
, varpool_node_set vset
)
2054 struct cgraph_node
*node
;
2055 struct varpool_node
*vnode
;
2057 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (p
->decl
)))
2059 if (TREE_CODE (p
->decl
) == VAR_DECL
)
2061 vnode
= varpool_get_node (p
->decl
);
2063 && referenced_from_this_partition_p (&vnode
->ref_list
, set
, vset
));
2065 node
= cgraph_get_node (p
->decl
);
2067 && (referenced_from_this_partition_p (&node
->ref_list
, set
, vset
)
2068 || reachable_from_this_partition_p (node
, set
)));
2071 return symbol_alias_set_contains (defined
, p
->decl
);
2074 /* Output any unreferenced global symbol defined in SET, alias pairs
2078 output_unreferenced_globals (cgraph_node_set set
, varpool_node_set vset
)
2080 struct output_block
*ob
;
2083 symbol_alias_set_t
*defined
;
2084 struct sets setdata
;
2087 setdata
.vset
= vset
;
2089 ob
= create_output_block (LTO_section_static_initializer
);
2090 ob
->cgraph_node
= NULL
;
2092 clear_line_info (ob
);
2094 /* Make string 0 be a NULL string. */
2095 lto_output_1_stream (ob
->string_stream
, 0);
2097 /* We really need to propagate in both directoins:
2098 for normal aliases we propagate from first defined alias to
2099 all aliases defined based on it. For weakrefs we propagate in
2100 the oposite direction. */
2101 defined
= propagate_aliases_backward (trivally_defined_alias
, &setdata
);
2103 /* Emit the alias pairs for the nodes in SET. */
2104 FOR_EACH_VEC_ELT (alias_pair
, alias_pairs
, i
, p
)
2105 if (output_alias_pair_p (p
, defined
, set
, vset
))
2107 lto_output_tree_ref (ob
, p
->decl
);
2108 lto_output_tree_ref (ob
, p
->target
);
2110 symbol_alias_set_destroy (defined
);
2114 produce_asm (ob
, NULL
);
2115 destroy_output_block (ob
);
2119 /* Copy the function body of NODE without deserializing. */
2122 copy_function (struct cgraph_node
*node
)
2124 tree function
= node
->decl
;
2125 struct lto_file_decl_data
*file_data
= node
->local
.lto_file_data
;
2126 struct lto_output_stream
*output_stream
= XCNEW (struct lto_output_stream
);
2129 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (function
));
2130 char *section_name
=
2131 lto_get_section_name (LTO_section_function_body
, name
, NULL
);
2133 struct lto_in_decl_state
*in_state
;
2134 struct lto_out_decl_state
*out_state
= lto_get_out_decl_state ();
2136 lto_begin_section (section_name
, !flag_wpa
);
2137 free (section_name
);
2139 /* We may have renamed the declaration, e.g., a static function. */
2140 name
= lto_get_decl_name_mapping (file_data
, name
);
2142 data
= lto_get_section_data (file_data
, LTO_section_function_body
,
2146 /* Do a bit copy of the function body. */
2147 lto_output_data_stream (output_stream
, data
, len
);
2148 lto_write_stream (output_stream
);
2152 lto_get_function_in_decl_state (node
->local
.lto_file_data
, function
);
2153 gcc_assert (in_state
);
2155 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2157 size_t n
= in_state
->streams
[i
].size
;
2158 tree
*trees
= in_state
->streams
[i
].trees
;
2159 struct lto_tree_ref_encoder
*encoder
= &(out_state
->streams
[i
]);
2161 /* The out state must have the same indices and the in state.
2162 So just copy the vector. All the encoders in the in state
2163 must be empty where we reach here. */
2164 gcc_assert (lto_tree_ref_encoder_size (encoder
) == 0);
2165 for (j
= 0; j
< n
; j
++)
2166 VEC_safe_push (tree
, heap
, encoder
->trees
, trees
[j
]);
2167 encoder
->next_index
= n
;
2170 lto_free_section_data (file_data
, LTO_section_function_body
, name
,
2172 free (output_stream
);
2177 /* Initialize the LTO writer. */
2180 lto_writer_init (void)
2182 lto_streamer_init ();
2183 if (streamer_hooks ()->writer_init
)
2184 streamer_hooks ()->writer_init ();
2188 /* Main entry point from the pass manager. */
2191 lto_output (cgraph_node_set set
, varpool_node_set vset
)
2193 struct cgraph_node
*node
;
2194 struct lto_out_decl_state
*decl_state
;
2195 #ifdef ENABLE_CHECKING
2196 bitmap output
= lto_bitmap_alloc ();
2199 lto_cgraph_encoder_t encoder
= lto_get_out_decl_state ()->cgraph_node_encoder
;
2201 gimple_streamer_hooks_init ();
2204 n_nodes
= lto_cgraph_encoder_size (encoder
);
2205 /* Process only the functions with bodies. */
2206 for (i
= 0; i
< n_nodes
; i
++)
2208 node
= lto_cgraph_encoder_deref (encoder
, i
);
2209 if (lto_cgraph_encoder_encode_body_p (encoder
, node
))
2211 #ifdef ENABLE_CHECKING
2212 gcc_assert (!bitmap_bit_p (output
, DECL_UID (node
->decl
)));
2213 bitmap_set_bit (output
, DECL_UID (node
->decl
));
2215 decl_state
= lto_new_out_decl_state ();
2216 lto_push_out_decl_state (decl_state
);
2217 if (gimple_has_body_p (node
->decl
))
2218 output_function (node
);
2220 copy_function (node
);
2221 gcc_assert (lto_get_out_decl_state () == decl_state
);
2222 lto_pop_out_decl_state ();
2223 lto_record_function_out_decl_state (node
->decl
, decl_state
);
2227 /* Emit the callgraph after emitting function bodies. This needs to
2228 be done now to make sure that all the statements in every function
2229 have been renumbered so that edges can be associated with call
2230 statements using the statement UIDs. */
2231 output_cgraph (set
, vset
);
2233 #ifdef ENABLE_CHECKING
2234 lto_bitmap_free (output
);
2238 struct ipa_opt_pass_d pass_ipa_lto_gimple_out
=
2242 "lto_gimple_out", /* name */
2243 gate_lto_out
, /* gate */
2247 0, /* static_pass_number */
2248 TV_IPA_LTO_GIMPLE_OUT
, /* tv_id */
2249 0, /* properties_required */
2250 0, /* properties_provided */
2251 0, /* properties_destroyed */
2252 0, /* todo_flags_start */
2253 TODO_dump_func
/* todo_flags_finish */
2255 NULL
, /* generate_summary */
2256 lto_output
, /* write_summary */
2257 NULL
, /* read_summary */
2258 lto_output
, /* write_optimization_summary */
2259 NULL
, /* read_optimization_summary */
2260 NULL
, /* stmt_fixup */
2262 NULL
, /* function_transform */
2263 NULL
/* variable_transform */
2267 /* Write each node in encoded by ENCODER to OB, as well as those reachable
2268 from it and required for correct representation of its semantics.
2269 Each node in ENCODER must be a global declaration or a type. A node
2270 is written only once, even if it appears multiple times in the
2271 vector. Certain transitively-reachable nodes, such as those
2272 representing expressions, may be duplicated, but such nodes
2273 must not appear in ENCODER itself. */
2276 write_global_stream (struct output_block
*ob
,
2277 struct lto_tree_ref_encoder
*encoder
)
2281 const size_t size
= lto_tree_ref_encoder_size (encoder
);
2283 for (index
= 0; index
< size
; index
++)
2285 t
= lto_tree_ref_encoder_get_tree (encoder
, index
);
2286 if (!lto_streamer_cache_lookup (ob
->writer_cache
, t
, NULL
))
2287 lto_output_tree (ob
, t
, false);
2292 /* Write a sequence of indices into the globals vector corresponding
2293 to the trees in ENCODER. These are used by the reader to map the
2294 indices used to refer to global entities within function bodies to
2298 write_global_references (struct output_block
*ob
,
2299 struct lto_output_stream
*ref_stream
,
2300 struct lto_tree_ref_encoder
*encoder
)
2304 const uint32_t size
= lto_tree_ref_encoder_size (encoder
);
2306 /* Write size as 32-bit unsigned. */
2307 lto_output_data_stream (ref_stream
, &size
, sizeof (int32_t));
2309 for (index
= 0; index
< size
; index
++)
2313 t
= lto_tree_ref_encoder_get_tree (encoder
, index
);
2314 lto_streamer_cache_lookup (ob
->writer_cache
, t
, &slot_num
);
2315 gcc_assert (slot_num
!= (unsigned)-1);
2316 lto_output_data_stream (ref_stream
, &slot_num
, sizeof slot_num
);
2321 /* Write all the streams in an lto_out_decl_state STATE using
2322 output block OB and output stream OUT_STREAM. */
2325 lto_output_decl_state_streams (struct output_block
*ob
,
2326 struct lto_out_decl_state
*state
)
2330 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2331 write_global_stream (ob
, &state
->streams
[i
]);
2335 /* Write all the references in an lto_out_decl_state STATE using
2336 output block OB and output stream OUT_STREAM. */
2339 lto_output_decl_state_refs (struct output_block
*ob
,
2340 struct lto_output_stream
*out_stream
,
2341 struct lto_out_decl_state
*state
)
2347 /* Write reference to FUNCTION_DECL. If there is not function,
2348 write reference to void_type_node. */
2349 decl
= (state
->fn_decl
) ? state
->fn_decl
: void_type_node
;
2350 lto_streamer_cache_lookup (ob
->writer_cache
, decl
, &ref
);
2351 gcc_assert (ref
!= (unsigned)-1);
2352 lto_output_data_stream (out_stream
, &ref
, sizeof (uint32_t));
2354 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2355 write_global_references (ob
, out_stream
, &state
->streams
[i
]);
2359 /* Return the written size of STATE. */
2362 lto_out_decl_state_written_size (struct lto_out_decl_state
*state
)
2367 size
= sizeof (int32_t); /* fn_ref. */
2368 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2370 size
+= sizeof (int32_t); /* vector size. */
2371 size
+= (lto_tree_ref_encoder_size (&state
->streams
[i
])
2372 * sizeof (int32_t));
2378 /* Write symbol T into STREAM in CACHE. SEEN specifies symbols we wrote
2382 write_symbol (struct lto_streamer_cache_d
*cache
,
2383 struct lto_output_stream
*stream
,
2384 tree t
, struct pointer_set_t
*seen
, bool alias
)
2387 enum gcc_plugin_symbol_kind kind
;
2388 enum gcc_plugin_symbol_visibility visibility
;
2394 /* None of the following kinds of symbols are needed in the
2396 if (!TREE_PUBLIC (t
)
2397 || is_builtin_fn (t
)
2398 || DECL_ABSTRACT (t
)
2399 || TREE_CODE (t
) == RESULT_DECL
)
2402 gcc_assert (TREE_CODE (t
) == VAR_DECL
2403 || TREE_CODE (t
) == FUNCTION_DECL
);
2405 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (t
));
2407 /* This behaves like assemble_name_raw in varasm.c, performing the
2408 same name manipulations that ASM_OUTPUT_LABELREF does. */
2409 name
= IDENTIFIER_POINTER ((*targetm
.asm_out
.mangle_assembler_name
) (name
));
2411 if (pointer_set_contains (seen
, name
))
2413 pointer_set_insert (seen
, name
);
2415 lto_streamer_cache_lookup (cache
, t
, &slot_num
);
2416 gcc_assert (slot_num
!= (unsigned)-1);
2418 if (DECL_EXTERNAL (t
))
2421 kind
= GCCPK_WEAKUNDEF
;
2428 kind
= GCCPK_WEAKDEF
;
2429 else if (DECL_COMMON (t
))
2430 kind
= GCCPK_COMMON
;
2434 /* When something is defined, it should have node attached. */
2435 gcc_assert (alias
|| TREE_CODE (t
) != VAR_DECL
2436 || varpool_get_node (t
)->finalized
);
2437 gcc_assert (alias
|| TREE_CODE (t
) != FUNCTION_DECL
2438 || (cgraph_get_node (t
)
2439 && cgraph_get_node (t
)->analyzed
));
2442 /* Imitate what default_elf_asm_output_external do.
2443 When symbol is external, we need to output it with DEFAULT visibility
2444 when compiling with -fvisibility=default, while with HIDDEN visibility
2445 when symbol has attribute (visibility("hidden")) specified.
2446 targetm.binds_local_p check DECL_VISIBILITY_SPECIFIED and gets this
2449 if (DECL_EXTERNAL (t
)
2450 && !targetm
.binds_local_p (t
))
2451 visibility
= GCCPV_DEFAULT
;
2453 switch (DECL_VISIBILITY(t
))
2455 case VISIBILITY_DEFAULT
:
2456 visibility
= GCCPV_DEFAULT
;
2458 case VISIBILITY_PROTECTED
:
2459 visibility
= GCCPV_PROTECTED
;
2461 case VISIBILITY_HIDDEN
:
2462 visibility
= GCCPV_HIDDEN
;
2464 case VISIBILITY_INTERNAL
:
2465 visibility
= GCCPV_INTERNAL
;
2469 if (kind
== GCCPK_COMMON
2471 && TREE_CODE (DECL_SIZE (t
)) == INTEGER_CST
)
2473 size
= (HOST_BITS_PER_WIDE_INT
>= 64)
2474 ? (uint64_t) int_size_in_bytes (TREE_TYPE (t
))
2475 : (((uint64_t) TREE_INT_CST_HIGH (DECL_SIZE_UNIT (t
))) << 32)
2476 | TREE_INT_CST_LOW (DECL_SIZE_UNIT (t
));
2481 if (DECL_ONE_ONLY (t
))
2482 comdat
= IDENTIFIER_POINTER (DECL_COMDAT_GROUP (t
));
2486 lto_output_data_stream (stream
, name
, strlen (name
) + 1);
2487 lto_output_data_stream (stream
, comdat
, strlen (comdat
) + 1);
2488 c
= (unsigned char) kind
;
2489 lto_output_data_stream (stream
, &c
, 1);
2490 c
= (unsigned char) visibility
;
2491 lto_output_data_stream (stream
, &c
, 1);
2492 lto_output_data_stream (stream
, &size
, 8);
2493 lto_output_data_stream (stream
, &slot_num
, 4);
2497 /* Write an IL symbol table to OB.
2498 SET and VSET are cgraph/varpool node sets we are outputting. */
2501 produce_symtab (struct output_block
*ob
,
2502 cgraph_node_set set
, varpool_node_set vset
)
2504 struct lto_streamer_cache_d
*cache
= ob
->writer_cache
;
2505 char *section_name
= lto_get_section_name (LTO_section_symtab
, NULL
, NULL
);
2506 struct pointer_set_t
*seen
;
2507 struct cgraph_node
*node
, *alias
;
2508 struct varpool_node
*vnode
, *valias
;
2509 struct lto_output_stream stream
;
2510 lto_varpool_encoder_t varpool_encoder
= ob
->decl_state
->varpool_node_encoder
;
2511 lto_cgraph_encoder_t encoder
= ob
->decl_state
->cgraph_node_encoder
;
2514 struct sets setdata
;
2515 symbol_alias_set_t
*defined
;
2518 setdata
.vset
= vset
;
2520 lto_begin_section (section_name
, false);
2521 free (section_name
);
2523 seen
= pointer_set_create ();
2524 memset (&stream
, 0, sizeof (stream
));
2526 /* Write all functions.
2527 First write all defined functions and then write all used functions.
2528 This is done so only to handle duplicated symbols in cgraph. */
2529 for (i
= 0; i
< lto_cgraph_encoder_size (encoder
); i
++)
2531 node
= lto_cgraph_encoder_deref (encoder
, i
);
2532 if (DECL_EXTERNAL (node
->decl
))
2534 if (DECL_COMDAT (node
->decl
)
2535 && cgraph_comdat_can_be_unshared_p (node
))
2537 if (node
->alias
|| node
->global
.inlined_to
)
2539 write_symbol (cache
, &stream
, node
->decl
, seen
, false);
2540 for (alias
= node
->same_body
; alias
; alias
= alias
->next
)
2541 write_symbol (cache
, &stream
, alias
->decl
, seen
, true);
2543 for (i
= 0; i
< lto_cgraph_encoder_size (encoder
); i
++)
2545 node
= lto_cgraph_encoder_deref (encoder
, i
);
2546 if (!DECL_EXTERNAL (node
->decl
))
2548 if (DECL_COMDAT (node
->decl
)
2549 && cgraph_comdat_can_be_unshared_p (node
))
2551 if (node
->alias
|| node
->global
.inlined_to
)
2553 write_symbol (cache
, &stream
, node
->decl
, seen
, false);
2554 for (alias
= node
->same_body
; alias
; alias
= alias
->next
)
2555 write_symbol (cache
, &stream
, alias
->decl
, seen
, true);
2558 /* Write all variables. */
2559 for (i
= 0; i
< lto_varpool_encoder_size (varpool_encoder
); i
++)
2561 vnode
= lto_varpool_encoder_deref (varpool_encoder
, i
);
2562 if (DECL_EXTERNAL (vnode
->decl
))
2564 /* COMDAT virtual tables can be unshared. Do not declare them
2565 in the LTO symbol table to prevent linker from forcing them
2567 if (DECL_COMDAT (vnode
->decl
)
2568 && !vnode
->force_output
2570 && DECL_VIRTUAL_P (vnode
->decl
))
2574 write_symbol (cache
, &stream
, vnode
->decl
, seen
, false);
2575 for (valias
= vnode
->extra_name
; valias
; valias
= valias
->next
)
2576 write_symbol (cache
, &stream
, valias
->decl
, seen
, true);
2578 for (i
= 0; i
< lto_varpool_encoder_size (varpool_encoder
); i
++)
2580 vnode
= lto_varpool_encoder_deref (varpool_encoder
, i
);
2581 if (!DECL_EXTERNAL (vnode
->decl
))
2583 if (DECL_COMDAT (vnode
->decl
)
2584 && !vnode
->force_output
2586 && DECL_VIRTUAL_P (vnode
->decl
))
2590 write_symbol (cache
, &stream
, vnode
->decl
, seen
, false);
2591 for (valias
= vnode
->extra_name
; valias
; valias
= valias
->next
)
2592 write_symbol (cache
, &stream
, valias
->decl
, seen
, true);
2595 /* Write all aliases. */
2596 defined
= propagate_aliases_backward (trivally_defined_alias
, &setdata
);
2597 FOR_EACH_VEC_ELT (alias_pair
, alias_pairs
, i
, p
)
2598 if (output_alias_pair_p (p
, defined
, set
, vset
))
2599 write_symbol (cache
, &stream
, p
->decl
, seen
, true);
2600 symbol_alias_set_destroy (defined
);
2602 lto_write_stream (&stream
);
2603 pointer_set_destroy (seen
);
2609 /* This pass is run after all of the functions are serialized and all
2610 of the IPA passes have written their serialized forms. This pass
2611 causes the vector of all of the global decls and types used from
2612 this file to be written in to a section that can then be read in to
2613 recover these on other side. */
2616 produce_asm_for_decls (cgraph_node_set set
, varpool_node_set vset
)
2618 struct lto_out_decl_state
*out_state
;
2619 struct lto_out_decl_state
*fn_out_state
;
2620 struct lto_decl_header header
;
2622 struct output_block
*ob
;
2623 struct lto_output_stream
*header_stream
, *decl_state_stream
;
2624 unsigned idx
, num_fns
;
2625 size_t decl_state_size
;
2626 int32_t num_decl_states
;
2628 ob
= create_output_block (LTO_section_decls
);
2631 /* Write out unreferenced globals, alias pairs and labels. We defer
2632 doing this until now so that we can write out only what is
2634 output_unreferenced_globals (set
, vset
);
2636 memset (&header
, 0, sizeof (struct lto_decl_header
));
2638 section_name
= lto_get_section_name (LTO_section_decls
, NULL
, NULL
);
2639 lto_begin_section (section_name
, !flag_wpa
);
2640 free (section_name
);
2642 /* Make string 0 be a NULL string. */
2643 lto_output_1_stream (ob
->string_stream
, 0);
2645 /* Write the global symbols. */
2646 out_state
= lto_get_out_decl_state ();
2647 num_fns
= VEC_length (lto_out_decl_state_ptr
, lto_function_decl_states
);
2648 lto_output_decl_state_streams (ob
, out_state
);
2649 for (idx
= 0; idx
< num_fns
; idx
++)
2652 VEC_index (lto_out_decl_state_ptr
, lto_function_decl_states
, idx
);
2653 lto_output_decl_state_streams (ob
, fn_out_state
);
2656 header
.lto_header
.major_version
= LTO_major_version
;
2657 header
.lto_header
.minor_version
= LTO_minor_version
;
2658 header
.lto_header
.section_type
= LTO_section_decls
;
2660 /* Currently not used. This field would allow us to preallocate
2661 the globals vector, so that it need not be resized as it is extended. */
2662 header
.num_nodes
= -1;
2664 /* Compute the total size of all decl out states. */
2665 decl_state_size
= sizeof (int32_t);
2666 decl_state_size
+= lto_out_decl_state_written_size (out_state
);
2667 for (idx
= 0; idx
< num_fns
; idx
++)
2670 VEC_index (lto_out_decl_state_ptr
, lto_function_decl_states
, idx
);
2671 decl_state_size
+= lto_out_decl_state_written_size (fn_out_state
);
2673 header
.decl_state_size
= decl_state_size
;
2675 header
.main_size
= ob
->main_stream
->total_size
;
2676 header
.string_size
= ob
->string_stream
->total_size
;
2678 header_stream
= XCNEW (struct lto_output_stream
);
2679 lto_output_data_stream (header_stream
, &header
, sizeof header
);
2680 lto_write_stream (header_stream
);
2681 free (header_stream
);
2683 /* Write the main out-decl state, followed by out-decl states of
2685 decl_state_stream
= ((struct lto_output_stream
*)
2686 xcalloc (1, sizeof (struct lto_output_stream
)));
2687 num_decl_states
= num_fns
+ 1;
2688 lto_output_data_stream (decl_state_stream
, &num_decl_states
,
2689 sizeof (num_decl_states
));
2690 lto_output_decl_state_refs (ob
, decl_state_stream
, out_state
);
2691 for (idx
= 0; idx
< num_fns
; idx
++)
2694 VEC_index (lto_out_decl_state_ptr
, lto_function_decl_states
, idx
);
2695 lto_output_decl_state_refs (ob
, decl_state_stream
, fn_out_state
);
2697 lto_write_stream (decl_state_stream
);
2698 free(decl_state_stream
);
2700 lto_write_stream (ob
->main_stream
);
2701 lto_write_stream (ob
->string_stream
);
2705 /* Write the symbol table. It is used by linker to determine dependencies
2706 and thus we can skip it for WPA. */
2708 produce_symtab (ob
, set
, vset
);
2710 /* Write command line opts. */
2711 lto_write_options ();
2713 /* Deallocate memory and clean up. */
2714 for (idx
= 0; idx
< num_fns
; idx
++)
2717 VEC_index (lto_out_decl_state_ptr
, lto_function_decl_states
, idx
);
2718 lto_delete_out_decl_state (fn_out_state
);
2720 lto_cgraph_encoder_delete (ob
->decl_state
->cgraph_node_encoder
);
2721 lto_varpool_encoder_delete (ob
->decl_state
->varpool_node_encoder
);
2722 VEC_free (lto_out_decl_state_ptr
, heap
, lto_function_decl_states
);
2723 lto_function_decl_states
= NULL
;
2724 destroy_output_block (ob
);
2728 struct ipa_opt_pass_d pass_ipa_lto_finish_out
=
2732 "lto_decls_out", /* name */
2733 gate_lto_out
, /* gate */
2737 0, /* static_pass_number */
2738 TV_IPA_LTO_DECL_OUT
, /* tv_id */
2739 0, /* properties_required */
2740 0, /* properties_provided */
2741 0, /* properties_destroyed */
2742 0, /* todo_flags_start */
2743 0 /* todo_flags_finish */
2745 NULL
, /* generate_summary */
2746 produce_asm_for_decls
, /* write_summary */
2747 NULL
, /* read_summary */
2748 produce_asm_for_decls
, /* write_optimization_summary */
2749 NULL
, /* read_optimization_summary */
2750 NULL
, /* stmt_fixup */
2752 NULL
, /* function_transform */
2753 NULL
/* variable_transform */