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.
55 Shamelessly stollen from libiberty. */
58 hash_string_slot_node (const void *p
)
60 const struct string_slot
*ds
= (const struct string_slot
*) p
;
61 hashval_t r
= ds
->len
;
64 for (i
= 0; i
< ds
->len
; i
++)
65 r
= r
* 67 + (unsigned)ds
->s
[i
] - 113;
70 /* Returns nonzero if P1 and P2 are equal. */
73 eq_string_slot_node (const void *p1
, const void *p2
)
75 const struct string_slot
*ds1
= (const struct string_slot
*) p1
;
76 const struct string_slot
*ds2
= (const struct string_slot
*) p2
;
78 if (ds1
->len
== ds2
->len
)
79 return memcmp (ds1
->s
, ds2
->s
, ds1
->len
) == 0;
85 /* Clear the line info stored in DATA_IN. */
88 clear_line_info (struct output_block
*ob
)
90 ob
->current_file
= NULL
;
96 /* Create the output block and return it. SECTION_TYPE is
97 LTO_section_function_body or LTO_static_initializer. */
100 create_output_block (enum lto_section_type section_type
)
102 struct output_block
*ob
= XCNEW (struct output_block
);
104 ob
->section_type
= section_type
;
105 ob
->decl_state
= lto_get_out_decl_state ();
106 ob
->main_stream
= XCNEW (struct lto_output_stream
);
107 ob
->string_stream
= XCNEW (struct lto_output_stream
);
108 ob
->writer_cache
= lto_streamer_cache_create ();
110 if (section_type
== LTO_section_function_body
)
111 ob
->cfg_stream
= XCNEW (struct lto_output_stream
);
113 clear_line_info (ob
);
115 ob
->string_hash_table
= htab_create (37, hash_string_slot_node
,
116 eq_string_slot_node
, NULL
);
117 gcc_obstack_init (&ob
->obstack
);
123 /* Destroy the output block OB. */
126 destroy_output_block (struct output_block
*ob
)
128 enum lto_section_type section_type
= ob
->section_type
;
130 htab_delete (ob
->string_hash_table
);
132 free (ob
->main_stream
);
133 free (ob
->string_stream
);
134 if (section_type
== LTO_section_function_body
)
135 free (ob
->cfg_stream
);
137 lto_streamer_cache_delete (ob
->writer_cache
);
138 obstack_free (&ob
->obstack
, NULL
);
143 /* Return index used to reference STRING of LEN characters in the string table
144 in OB. The string might or might not include a trailing '\0'.
145 Then put the index onto the INDEX_STREAM.
146 When PERSISTENT is set, the string S is supposed to not change during
147 duration of the OB and thus OB can keep pointer into it. */
150 lto_string_index (struct output_block
*ob
,
155 struct string_slot
**slot
;
156 struct string_slot s_slot
;
162 slot
= (struct string_slot
**) htab_find_slot (ob
->string_hash_table
,
166 struct lto_output_stream
*string_stream
= ob
->string_stream
;
167 unsigned int start
= string_stream
->total_size
;
168 struct string_slot
*new_slot
169 = XOBNEW (&ob
->obstack
, struct string_slot
);
175 string
= tmp
= XOBNEWVEC (&ob
->obstack
, char, len
);
176 memcpy (tmp
, s
, len
);
181 new_slot
->s
= string
;
183 new_slot
->slot_num
= start
;
185 lto_output_uleb128_stream (string_stream
, len
);
186 lto_output_data_stream (string_stream
, string
, len
);
191 struct string_slot
*old_slot
= *slot
;
192 return old_slot
->slot_num
+ 1;
197 /* Output STRING of LEN characters to the string
198 table in OB. The string might or might not include a trailing '\0'.
199 Then put the index onto the INDEX_STREAM.
200 When PERSISTENT is set, the string S is supposed to not change during
201 duration of the OB and thus OB can keep pointer into it. */
204 lto_output_string_with_length (struct output_block
*ob
,
205 struct lto_output_stream
*index_stream
,
211 lto_output_uleb128_stream (index_stream
,
212 lto_string_index (ob
, s
, len
, persistent
));
214 lto_output_1_stream (index_stream
, 0);
217 /* Output the '\0' terminated STRING to the string
218 table in OB. Then put the index onto the INDEX_STREAM.
219 When PERSISTENT is set, the string S is supposed to not change during
220 duration of the OB and thus OB can keep pointer into it. */
223 lto_output_string (struct output_block
*ob
,
224 struct lto_output_stream
*index_stream
,
229 lto_output_string_with_length (ob
, index_stream
, string
,
233 lto_output_1_stream (index_stream
, 0);
237 /* Output the STRING constant to the string
238 table in OB. Then put the index onto the INDEX_STREAM. */
241 output_string_cst (struct output_block
*ob
,
242 struct lto_output_stream
*index_stream
,
245 lto_output_string_with_length (ob
, index_stream
,
246 TREE_STRING_POINTER (string
),
247 TREE_STRING_LENGTH (string
),
252 /* Output the identifier ID to the string
253 table in OB. Then put the index onto the INDEX_STREAM. */
256 output_identifier (struct output_block
*ob
,
257 struct lto_output_stream
*index_stream
,
260 lto_output_string_with_length (ob
, index_stream
,
261 IDENTIFIER_POINTER (id
),
262 IDENTIFIER_LENGTH (id
),
267 /* Write a zero to the output stream. */
270 output_zero (struct output_block
*ob
)
272 lto_output_1_stream (ob
->main_stream
, 0);
276 /* Output an unsigned LEB128 quantity to OB->main_stream. */
279 output_uleb128 (struct output_block
*ob
, unsigned HOST_WIDE_INT work
)
281 lto_output_uleb128_stream (ob
->main_stream
, work
);
285 /* Output a signed LEB128 quantity to OB->main_stream. */
288 output_sleb128 (struct output_block
*ob
, HOST_WIDE_INT work
)
290 lto_output_sleb128_stream (ob
->main_stream
, work
);
294 /* Output the start of a record with TAG to output block OB. */
297 output_record_start (struct output_block
*ob
, enum LTO_tags tag
)
299 lto_output_enum (ob
->main_stream
, LTO_tags
, LTO_NUM_TAGS
, tag
);
303 /* Look up NODE in the type table and write the index for it to OB. */
306 output_type_ref (struct output_block
*ob
, tree node
)
308 output_record_start (ob
, LTO_type_ref
);
309 lto_output_type_ref_index (ob
->decl_state
, ob
->main_stream
, node
);
313 /* Pack all the non-pointer fields of the TS_BASE structure of
314 expression EXPR into bitpack BP. */
317 pack_ts_base_value_fields (struct bitpack_d
*bp
, tree expr
)
319 bp_pack_value (bp
, TREE_CODE (expr
), 16);
322 bp_pack_value (bp
, TREE_SIDE_EFFECTS (expr
), 1);
323 bp_pack_value (bp
, TREE_CONSTANT (expr
), 1);
324 bp_pack_value (bp
, TREE_READONLY (expr
), 1);
326 /* TREE_PUBLIC is used on types to indicate that the type
327 has a TYPE_CACHED_VALUES vector. This is not streamed out,
328 so we skip it here. */
329 bp_pack_value (bp
, TREE_PUBLIC (expr
), 1);
332 bp_pack_value (bp
, 0, 4);
333 bp_pack_value (bp
, TREE_ADDRESSABLE (expr
), 1);
334 bp_pack_value (bp
, TREE_THIS_VOLATILE (expr
), 1);
336 bp_pack_value (bp
, DECL_UNSIGNED (expr
), 1);
337 else if (TYPE_P (expr
))
338 bp_pack_value (bp
, TYPE_UNSIGNED (expr
), 1);
340 bp_pack_value (bp
, 0, 1);
341 /* We write debug info two times, do not confuse the second one. */
342 bp_pack_value (bp
, TYPE_P (expr
) ? 0 : TREE_ASM_WRITTEN (expr
), 1);
343 bp_pack_value (bp
, TREE_NO_WARNING (expr
), 1);
344 bp_pack_value (bp
, TREE_USED (expr
), 1);
345 bp_pack_value (bp
, TREE_NOTHROW (expr
), 1);
346 bp_pack_value (bp
, TREE_STATIC (expr
), 1);
347 bp_pack_value (bp
, TREE_PRIVATE (expr
), 1);
348 bp_pack_value (bp
, TREE_PROTECTED (expr
), 1);
349 bp_pack_value (bp
, TREE_DEPRECATED (expr
), 1);
351 bp_pack_value (bp
, TYPE_SATURATING (expr
), 1);
352 else if (TREE_CODE (expr
) == SSA_NAME
)
353 bp_pack_value (bp
, SSA_NAME_IS_DEFAULT_DEF (expr
), 1);
355 bp_pack_value (bp
, 0, 1);
359 /* Pack all the non-pointer fields of the TS_REAL_CST structure of
360 expression EXPR into bitpack BP. */
363 pack_ts_real_cst_value_fields (struct bitpack_d
*bp
, tree expr
)
368 r
= TREE_REAL_CST (expr
);
369 bp_pack_value (bp
, r
.cl
, 2);
370 bp_pack_value (bp
, r
.decimal
, 1);
371 bp_pack_value (bp
, r
.sign
, 1);
372 bp_pack_value (bp
, r
.signalling
, 1);
373 bp_pack_value (bp
, r
.canonical
, 1);
374 bp_pack_value (bp
, r
.uexp
, EXP_BITS
);
375 for (i
= 0; i
< SIGSZ
; i
++)
376 bp_pack_value (bp
, r
.sig
[i
], HOST_BITS_PER_LONG
);
380 /* Pack all the non-pointer fields of the TS_FIXED_CST structure of
381 expression EXPR into bitpack BP. */
384 pack_ts_fixed_cst_value_fields (struct bitpack_d
*bp
, tree expr
)
386 struct fixed_value fv
= TREE_FIXED_CST (expr
);
387 bp_pack_enum (bp
, machine_mode
, MAX_MACHINE_MODE
, fv
.mode
);
388 bp_pack_var_len_int (bp
, fv
.data
.low
);
389 bp_pack_var_len_int (bp
, fv
.data
.high
);
393 /* Pack all the non-pointer fields of the TS_DECL_COMMON structure
394 of expression EXPR into bitpack BP. */
397 pack_ts_decl_common_value_fields (struct bitpack_d
*bp
, tree expr
)
399 bp_pack_enum (bp
, machine_mode
, MAX_MACHINE_MODE
, DECL_MODE (expr
));
400 bp_pack_value (bp
, DECL_NONLOCAL (expr
), 1);
401 bp_pack_value (bp
, DECL_VIRTUAL_P (expr
), 1);
402 bp_pack_value (bp
, DECL_IGNORED_P (expr
), 1);
403 bp_pack_value (bp
, DECL_ABSTRACT (expr
), 1);
404 bp_pack_value (bp
, DECL_ARTIFICIAL (expr
), 1);
405 bp_pack_value (bp
, DECL_USER_ALIGN (expr
), 1);
406 bp_pack_value (bp
, DECL_PRESERVE_P (expr
), 1);
407 bp_pack_value (bp
, DECL_DEBUG_EXPR_IS_FROM (expr
), 1);
408 bp_pack_value (bp
, DECL_EXTERNAL (expr
), 1);
409 bp_pack_value (bp
, DECL_GIMPLE_REG_P (expr
), 1);
410 bp_pack_var_len_unsigned (bp
, DECL_ALIGN (expr
));
412 if (TREE_CODE (expr
) == LABEL_DECL
)
414 /* Note that we do not write LABEL_DECL_UID. The reader will
415 always assume an initial value of -1 so that the
416 label_to_block_map is recreated by gimple_set_bb. */
417 bp_pack_value (bp
, DECL_ERROR_ISSUED (expr
), 1);
418 bp_pack_var_len_unsigned (bp
, EH_LANDING_PAD_NR (expr
));
421 if (TREE_CODE (expr
) == FIELD_DECL
)
423 bp_pack_value (bp
, DECL_PACKED (expr
), 1);
424 bp_pack_value (bp
, DECL_NONADDRESSABLE_P (expr
), 1);
425 bp_pack_value (bp
, expr
->decl_common
.off_align
, 8);
428 if (TREE_CODE (expr
) == RESULT_DECL
429 || TREE_CODE (expr
) == PARM_DECL
430 || TREE_CODE (expr
) == VAR_DECL
)
432 bp_pack_value (bp
, DECL_BY_REFERENCE (expr
), 1);
433 if (TREE_CODE (expr
) == VAR_DECL
434 || TREE_CODE (expr
) == PARM_DECL
)
435 bp_pack_value (bp
, DECL_HAS_VALUE_EXPR_P (expr
), 1);
436 bp_pack_value (bp
, DECL_RESTRICTED_P (expr
), 1);
441 /* Pack all the non-pointer fields of the TS_DECL_WRTL structure
442 of expression EXPR into bitpack BP. */
445 pack_ts_decl_wrtl_value_fields (struct bitpack_d
*bp
, tree expr
)
447 bp_pack_value (bp
, DECL_REGISTER (expr
), 1);
451 /* Pack all the non-pointer fields of the TS_DECL_WITH_VIS structure
452 of expression EXPR into bitpack BP. */
455 pack_ts_decl_with_vis_value_fields (struct bitpack_d
*bp
, tree expr
)
457 bp_pack_value (bp
, DECL_DEFER_OUTPUT (expr
), 1);
458 bp_pack_value (bp
, DECL_COMMON (expr
), 1);
459 bp_pack_value (bp
, DECL_DLLIMPORT_P (expr
), 1);
460 bp_pack_value (bp
, DECL_WEAK (expr
), 1);
461 bp_pack_value (bp
, DECL_SEEN_IN_BIND_EXPR_P (expr
), 1);
462 bp_pack_value (bp
, DECL_COMDAT (expr
), 1);
463 bp_pack_value (bp
, DECL_VISIBILITY (expr
), 2);
464 bp_pack_value (bp
, DECL_VISIBILITY_SPECIFIED (expr
), 1);
466 if (TREE_CODE (expr
) == VAR_DECL
)
468 bp_pack_value (bp
, DECL_HARD_REGISTER (expr
), 1);
469 bp_pack_value (bp
, DECL_IN_TEXT_SECTION (expr
), 1);
470 bp_pack_value (bp
, DECL_IN_CONSTANT_POOL (expr
), 1);
471 bp_pack_value (bp
, DECL_TLS_MODEL (expr
), 3);
474 if (VAR_OR_FUNCTION_DECL_P (expr
))
475 bp_pack_var_len_unsigned (bp
, DECL_INIT_PRIORITY (expr
));
479 /* Pack all the non-pointer fields of the TS_FUNCTION_DECL structure
480 of expression EXPR into bitpack BP. */
483 pack_ts_function_decl_value_fields (struct bitpack_d
*bp
, tree expr
)
485 /* For normal/md builtins we only write the class and code, so they
486 should never be handled here. */
487 gcc_assert (!lto_stream_as_builtin_p (expr
));
489 bp_pack_enum (bp
, built_in_class
, BUILT_IN_LAST
,
490 DECL_BUILT_IN_CLASS (expr
));
491 bp_pack_value (bp
, DECL_STATIC_CONSTRUCTOR (expr
), 1);
492 bp_pack_value (bp
, DECL_STATIC_DESTRUCTOR (expr
), 1);
493 bp_pack_value (bp
, DECL_UNINLINABLE (expr
), 1);
494 bp_pack_value (bp
, DECL_POSSIBLY_INLINED (expr
), 1);
495 bp_pack_value (bp
, DECL_IS_NOVOPS (expr
), 1);
496 bp_pack_value (bp
, DECL_IS_RETURNS_TWICE (expr
), 1);
497 bp_pack_value (bp
, DECL_IS_MALLOC (expr
), 1);
498 bp_pack_value (bp
, DECL_IS_OPERATOR_NEW (expr
), 1);
499 bp_pack_value (bp
, DECL_DECLARED_INLINE_P (expr
), 1);
500 bp_pack_value (bp
, DECL_STATIC_CHAIN (expr
), 1);
501 bp_pack_value (bp
, DECL_NO_INLINE_WARNING_P (expr
), 1);
502 bp_pack_value (bp
, DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (expr
), 1);
503 bp_pack_value (bp
, DECL_NO_LIMIT_STACK (expr
), 1);
504 bp_pack_value (bp
, DECL_DISREGARD_INLINE_LIMITS (expr
), 1);
505 bp_pack_value (bp
, DECL_PURE_P (expr
), 1);
506 bp_pack_value (bp
, DECL_LOOPING_CONST_OR_PURE_P (expr
), 1);
507 if (DECL_BUILT_IN_CLASS (expr
) != NOT_BUILT_IN
)
508 bp_pack_value (bp
, DECL_FUNCTION_CODE (expr
), 11);
509 if (DECL_STATIC_DESTRUCTOR (expr
))
510 bp_pack_var_len_unsigned (bp
, DECL_FINI_PRIORITY (expr
));
514 /* Pack all the non-pointer fields of the TS_TYPE_COMMON structure
515 of expression EXPR into bitpack BP. */
518 pack_ts_type_common_value_fields (struct bitpack_d
*bp
, tree expr
)
520 bp_pack_enum (bp
, machine_mode
, MAX_MACHINE_MODE
, TYPE_MODE (expr
));
521 bp_pack_value (bp
, TYPE_STRING_FLAG (expr
), 1);
522 bp_pack_value (bp
, TYPE_NO_FORCE_BLK (expr
), 1);
523 bp_pack_value (bp
, TYPE_NEEDS_CONSTRUCTING (expr
), 1);
524 if (RECORD_OR_UNION_TYPE_P (expr
))
525 bp_pack_value (bp
, TYPE_TRANSPARENT_AGGR (expr
), 1);
526 bp_pack_value (bp
, TYPE_PACKED (expr
), 1);
527 bp_pack_value (bp
, TYPE_RESTRICT (expr
), 1);
528 bp_pack_value (bp
, TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr
), 2);
529 bp_pack_value (bp
, TYPE_USER_ALIGN (expr
), 1);
530 bp_pack_value (bp
, TYPE_READONLY (expr
), 1);
531 bp_pack_var_len_unsigned (bp
, TYPE_PRECISION (expr
));
532 bp_pack_var_len_unsigned (bp
, TYPE_ALIGN (expr
));
533 bp_pack_var_len_int (bp
, TYPE_ALIAS_SET (expr
) == 0 ? 0 : -1);
537 /* Pack all the non-pointer fields of the TS_BLOCK structure
538 of expression EXPR into bitpack BP. */
541 pack_ts_block_value_fields (struct bitpack_d
*bp
, tree expr
)
543 bp_pack_value (bp
, BLOCK_ABSTRACT (expr
), 1);
544 /* BLOCK_NUMBER is recomputed. */
547 /* Pack all the non-pointer fields of the TS_TRANSLATION_UNIT_DECL structure
548 of expression EXPR into bitpack BP. */
551 pack_ts_translation_unit_decl_value_fields (struct bitpack_d
*bp ATTRIBUTE_UNUSED
, tree expr ATTRIBUTE_UNUSED
)
555 /* Pack all the non-pointer fields in EXPR into a bit pack. */
558 pack_value_fields (struct bitpack_d
*bp
, tree expr
)
562 code
= TREE_CODE (expr
);
564 /* Note that all these functions are highly sensitive to changes in
565 the types and sizes of each of the fields being packed. */
566 pack_ts_base_value_fields (bp
, expr
);
568 if (CODE_CONTAINS_STRUCT (code
, TS_REAL_CST
))
569 pack_ts_real_cst_value_fields (bp
, expr
);
571 if (CODE_CONTAINS_STRUCT (code
, TS_FIXED_CST
))
572 pack_ts_fixed_cst_value_fields (bp
, expr
);
574 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
575 pack_ts_decl_common_value_fields (bp
, expr
);
577 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WRTL
))
578 pack_ts_decl_wrtl_value_fields (bp
, expr
);
580 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
581 pack_ts_decl_with_vis_value_fields (bp
, expr
);
583 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
584 pack_ts_function_decl_value_fields (bp
, expr
);
586 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
587 pack_ts_type_common_value_fields (bp
, expr
);
589 if (CODE_CONTAINS_STRUCT (code
, TS_BLOCK
))
590 pack_ts_block_value_fields (bp
, expr
);
592 if (CODE_CONTAINS_STRUCT (code
, TS_SSA_NAME
))
594 /* We only stream the version number of SSA names. */
598 if (CODE_CONTAINS_STRUCT (code
, TS_STATEMENT_LIST
))
600 /* This is only used by GENERIC. */
604 if (CODE_CONTAINS_STRUCT (code
, TS_OMP_CLAUSE
))
606 /* This is only used by High GIMPLE. */
610 if (CODE_CONTAINS_STRUCT (code
, TS_TRANSLATION_UNIT_DECL
))
611 pack_ts_translation_unit_decl_value_fields (bp
, expr
);
615 /* Output info about new location into bitpack BP.
616 After outputting bitpack, lto_output_location_data has
617 to be done to output actual data. */
620 lto_output_location_bitpack (struct bitpack_d
*bp
,
621 struct output_block
*ob
,
624 expanded_location xloc
;
626 bp_pack_value (bp
, loc
== UNKNOWN_LOCATION
, 1);
627 if (loc
== UNKNOWN_LOCATION
)
630 xloc
= expand_location (loc
);
632 bp_pack_value (bp
, ob
->current_file
!= xloc
.file
, 1);
633 if (ob
->current_file
!= xloc
.file
)
634 bp_pack_var_len_unsigned (bp
, lto_string_index (ob
,
636 strlen (xloc
.file
) + 1,
638 ob
->current_file
= xloc
.file
;
640 bp_pack_value (bp
, ob
->current_line
!= xloc
.line
, 1);
641 if (ob
->current_line
!= xloc
.line
)
642 bp_pack_var_len_unsigned (bp
, xloc
.line
);
643 ob
->current_line
= xloc
.line
;
645 bp_pack_value (bp
, ob
->current_col
!= xloc
.column
, 1);
646 if (ob
->current_col
!= xloc
.column
)
647 bp_pack_var_len_unsigned (bp
, xloc
.column
);
648 ob
->current_col
= xloc
.column
;
652 /* Emit location LOC to output block OB.
653 When bitpack is handy, it is more space effecient to call
654 lto_output_location_bitpack with existing bitpack. */
657 lto_output_location (struct output_block
*ob
, location_t loc
)
659 struct bitpack_d bp
= bitpack_create (ob
->main_stream
);
660 lto_output_location_bitpack (&bp
, ob
, loc
);
661 lto_output_bitpack (&bp
);
665 /* Return true if tree node T is written to various tables. For these
666 nodes, we sometimes want to write their phyiscal representation
667 (via lto_output_tree), and sometimes we need to emit an index
668 reference into a table (via lto_output_tree_ref). */
671 tree_is_indexable (tree t
)
673 if (TREE_CODE (t
) == PARM_DECL
)
675 else if (TREE_CODE (t
) == VAR_DECL
&& decl_function_context (t
)
679 return (TYPE_P (t
) || DECL_P (t
) || TREE_CODE (t
) == SSA_NAME
);
683 /* If EXPR is an indexable tree node, output a reference to it to
684 output block OB. Otherwise, output the physical representation of
688 lto_output_tree_ref (struct output_block
*ob
, tree expr
)
692 if (expr
== NULL_TREE
)
694 output_record_start (ob
, LTO_null
);
698 if (!tree_is_indexable (expr
))
700 /* Even though we are emitting the physical representation of
701 EXPR, its leaves must be emitted as references. */
702 lto_output_tree (ob
, expr
, true);
708 output_type_ref (ob
, expr
);
712 code
= TREE_CODE (expr
);
716 output_record_start (ob
, LTO_ssa_name_ref
);
717 output_uleb128 (ob
, SSA_NAME_VERSION (expr
));
721 output_record_start (ob
, LTO_field_decl_ref
);
722 lto_output_field_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
726 output_record_start (ob
, LTO_function_decl_ref
);
727 lto_output_fn_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
731 case DEBUG_EXPR_DECL
:
732 gcc_assert (decl_function_context (expr
) == NULL
733 || TREE_STATIC (expr
));
734 output_record_start (ob
, LTO_global_decl_ref
);
735 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
739 output_record_start (ob
, LTO_const_decl_ref
);
740 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
744 gcc_assert (decl_function_context (expr
) == NULL
);
745 output_record_start (ob
, LTO_imported_decl_ref
);
746 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
750 output_record_start (ob
, LTO_type_decl_ref
);
751 lto_output_type_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
755 output_record_start (ob
, LTO_namespace_decl_ref
);
756 lto_output_namespace_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
760 output_record_start (ob
, LTO_label_decl_ref
);
761 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
765 output_record_start (ob
, LTO_result_decl_ref
);
766 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
769 case TRANSLATION_UNIT_DECL
:
770 output_record_start (ob
, LTO_translation_unit_decl_ref
);
771 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
775 /* No other node is indexable, so it should have been handled
776 by lto_output_tree. */
782 /* If REF_P is true, emit a reference to EXPR in output block OB,
783 otherwise emit the physical representation of EXPR in OB. */
786 lto_output_tree_or_ref (struct output_block
*ob
, tree expr
, bool ref_p
)
789 lto_output_tree_ref (ob
, expr
);
791 lto_output_tree (ob
, expr
, false);
795 /* Emit the chain of tree nodes starting at T. OB is the output block
796 to write to. REF_P is true if chain elements should be emitted
800 lto_output_chain (struct output_block
*ob
, tree t
, bool ref_p
)
804 count
= list_length (t
);
805 output_sleb128 (ob
, count
);
806 for (i
= 0; i
< count
; i
++)
810 /* Clear TREE_CHAIN to avoid blindly recursing into the rest
812 saved_chain
= TREE_CHAIN (t
);
813 TREE_CHAIN (t
) = NULL_TREE
;
815 lto_output_tree_or_ref (ob
, t
, ref_p
);
817 TREE_CHAIN (t
) = saved_chain
;
823 /* Write all pointer fields in the TS_COMMON structure of EXPR to output
824 block OB. If REF_P is true, write a reference to EXPR's pointer
828 lto_output_ts_common_tree_pointers (struct output_block
*ob
, tree expr
,
831 if (TREE_CODE (expr
) != IDENTIFIER_NODE
)
832 lto_output_tree_or_ref (ob
, TREE_TYPE (expr
), ref_p
);
836 /* Write all pointer fields in the TS_VECTOR structure of EXPR to output
837 block OB. If REF_P is true, write a reference to EXPR's pointer
841 lto_output_ts_vector_tree_pointers (struct output_block
*ob
, tree expr
,
844 lto_output_chain (ob
, TREE_VECTOR_CST_ELTS (expr
), ref_p
);
848 /* Write all pointer fields in the TS_COMPLEX structure of EXPR to output
849 block OB. If REF_P is true, write a reference to EXPR's pointer
853 lto_output_ts_complex_tree_pointers (struct output_block
*ob
, tree expr
,
856 lto_output_tree_or_ref (ob
, TREE_REALPART (expr
), ref_p
);
857 lto_output_tree_or_ref (ob
, TREE_IMAGPART (expr
), ref_p
);
861 /* Write all pointer fields in the TS_DECL_MINIMAL structure of EXPR
862 to output block OB. If REF_P is true, write a reference to EXPR's
866 lto_output_ts_decl_minimal_tree_pointers (struct output_block
*ob
, tree expr
,
869 lto_output_tree_or_ref (ob
, DECL_NAME (expr
), ref_p
);
870 lto_output_tree_or_ref (ob
, DECL_CONTEXT (expr
), ref_p
);
871 lto_output_location (ob
, DECL_SOURCE_LOCATION (expr
));
875 /* Write all pointer fields in the TS_DECL_COMMON structure of EXPR to
876 output block OB. If REF_P is true, write a reference to EXPR's
880 lto_output_ts_decl_common_tree_pointers (struct output_block
*ob
, tree expr
,
883 lto_output_tree_or_ref (ob
, DECL_SIZE (expr
), ref_p
);
884 lto_output_tree_or_ref (ob
, DECL_SIZE_UNIT (expr
), ref_p
);
886 if (TREE_CODE (expr
) != FUNCTION_DECL
887 && TREE_CODE (expr
) != TRANSLATION_UNIT_DECL
)
889 tree initial
= DECL_INITIAL (expr
);
890 if (TREE_CODE (expr
) == VAR_DECL
891 && (TREE_STATIC (expr
) || DECL_EXTERNAL (expr
))
894 lto_varpool_encoder_t varpool_encoder
= ob
->decl_state
->varpool_node_encoder
;
895 struct varpool_node
*vnode
= varpool_get_node (expr
);
897 initial
= error_mark_node
;
898 else if (!lto_varpool_encoder_encode_initializer_p (varpool_encoder
,
903 lto_output_tree_or_ref (ob
, initial
, ref_p
);
906 lto_output_tree_or_ref (ob
, DECL_ATTRIBUTES (expr
), ref_p
);
907 /* Do not stream DECL_ABSTRACT_ORIGIN. We cannot handle debug information
908 for early inlining so drop it on the floor instead of ICEing in
911 if (TREE_CODE (expr
) == PARM_DECL
)
912 lto_output_chain (ob
, TREE_CHAIN (expr
), ref_p
);
914 if ((TREE_CODE (expr
) == VAR_DECL
915 || TREE_CODE (expr
) == PARM_DECL
)
916 && DECL_HAS_VALUE_EXPR_P (expr
))
917 lto_output_tree_or_ref (ob
, DECL_VALUE_EXPR (expr
), ref_p
);
919 if (TREE_CODE (expr
) == VAR_DECL
)
920 lto_output_tree_or_ref (ob
, DECL_DEBUG_EXPR (expr
), ref_p
);
924 /* Write all pointer fields in the TS_DECL_NON_COMMON structure of
925 EXPR to output block OB. If REF_P is true, write a reference to EXPR's
929 lto_output_ts_decl_non_common_tree_pointers (struct output_block
*ob
,
930 tree expr
, bool ref_p
)
932 if (TREE_CODE (expr
) == FUNCTION_DECL
)
934 lto_output_tree_or_ref (ob
, DECL_ARGUMENTS (expr
), ref_p
);
935 lto_output_tree_or_ref (ob
, DECL_RESULT (expr
), ref_p
);
937 lto_output_tree_or_ref (ob
, DECL_VINDEX (expr
), ref_p
);
941 /* Write all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
942 to output block OB. If REF_P is true, write a reference to EXPR's
946 lto_output_ts_decl_with_vis_tree_pointers (struct output_block
*ob
, tree expr
,
949 /* Make sure we don't inadvertently set the assembler name. */
950 if (DECL_ASSEMBLER_NAME_SET_P (expr
))
951 lto_output_tree_or_ref (ob
, DECL_ASSEMBLER_NAME (expr
), ref_p
);
953 output_record_start (ob
, LTO_null
);
955 lto_output_tree_or_ref (ob
, DECL_SECTION_NAME (expr
), ref_p
);
956 lto_output_tree_or_ref (ob
, DECL_COMDAT_GROUP (expr
), ref_p
);
960 /* Write all pointer fields in the TS_FIELD_DECL structure of EXPR to
961 output block OB. If REF_P is true, write a reference to EXPR's
965 lto_output_ts_field_decl_tree_pointers (struct output_block
*ob
, tree expr
,
968 lto_output_tree_or_ref (ob
, DECL_FIELD_OFFSET (expr
), ref_p
);
969 lto_output_tree_or_ref (ob
, DECL_BIT_FIELD_TYPE (expr
), ref_p
);
970 lto_output_tree_or_ref (ob
, DECL_QUALIFIER (expr
), ref_p
);
971 lto_output_tree_or_ref (ob
, DECL_FIELD_BIT_OFFSET (expr
), ref_p
);
972 lto_output_tree_or_ref (ob
, DECL_FCONTEXT (expr
), ref_p
);
973 lto_output_chain (ob
, TREE_CHAIN (expr
), ref_p
);
977 /* Write all pointer fields in the TS_FUNCTION_DECL structure of EXPR
978 to output block OB. If REF_P is true, write a reference to EXPR's
982 lto_output_ts_function_decl_tree_pointers (struct output_block
*ob
, tree expr
,
985 /* DECL_STRUCT_FUNCTION is handled by lto_output_function. FIXME lto,
986 maybe it should be handled here? */
987 lto_output_tree_or_ref (ob
, DECL_FUNCTION_PERSONALITY (expr
), ref_p
);
988 lto_output_tree_or_ref (ob
, DECL_FUNCTION_SPECIFIC_TARGET (expr
), ref_p
);
989 lto_output_tree_or_ref (ob
, DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr
),
994 /* Write all pointer fields in the TS_TYPE_COMMON structure of EXPR to
995 output block OB. If REF_P is true, write a reference to EXPR's
999 lto_output_ts_type_common_tree_pointers (struct output_block
*ob
, tree expr
,
1002 lto_output_tree_or_ref (ob
, TYPE_SIZE (expr
), ref_p
);
1003 lto_output_tree_or_ref (ob
, TYPE_SIZE_UNIT (expr
), ref_p
);
1004 lto_output_tree_or_ref (ob
, TYPE_ATTRIBUTES (expr
), ref_p
);
1005 lto_output_tree_or_ref (ob
, TYPE_NAME (expr
), ref_p
);
1006 /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO. They will be
1007 reconstructed during fixup. */
1008 /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
1010 lto_output_tree_or_ref (ob
, TYPE_MAIN_VARIANT (expr
), ref_p
);
1011 lto_output_tree_or_ref (ob
, TYPE_CONTEXT (expr
), ref_p
);
1012 /* TYPE_CANONICAL is re-computed during type merging, so no need
1013 to stream it here. */
1014 lto_output_tree_or_ref (ob
, TYPE_STUB_DECL (expr
), ref_p
);
1017 /* Write all pointer fields in the TS_TYPE_NON_COMMON structure of EXPR
1018 to output block OB. If REF_P is true, write a reference to EXPR's
1022 lto_output_ts_type_non_common_tree_pointers (struct output_block
*ob
,
1023 tree expr
, bool ref_p
)
1025 if (TREE_CODE (expr
) == ENUMERAL_TYPE
)
1026 lto_output_tree_or_ref (ob
, TYPE_VALUES (expr
), ref_p
);
1027 else if (TREE_CODE (expr
) == ARRAY_TYPE
)
1028 lto_output_tree_or_ref (ob
, TYPE_DOMAIN (expr
), ref_p
);
1029 else if (RECORD_OR_UNION_TYPE_P (expr
))
1030 lto_output_tree_or_ref (ob
, TYPE_FIELDS (expr
), ref_p
);
1031 else if (TREE_CODE (expr
) == FUNCTION_TYPE
1032 || TREE_CODE (expr
) == METHOD_TYPE
)
1033 lto_output_tree_or_ref (ob
, TYPE_ARG_TYPES (expr
), ref_p
);
1035 if (!POINTER_TYPE_P (expr
))
1036 lto_output_tree_or_ref (ob
, TYPE_MINVAL (expr
), ref_p
);
1037 lto_output_tree_or_ref (ob
, TYPE_MAXVAL (expr
), ref_p
);
1038 if (RECORD_OR_UNION_TYPE_P (expr
))
1039 lto_output_tree_or_ref (ob
, TYPE_BINFO (expr
), ref_p
);
1043 /* Write all pointer fields in the TS_LIST structure of EXPR to output
1044 block OB. If REF_P is true, write a reference to EXPR's pointer
1048 lto_output_ts_list_tree_pointers (struct output_block
*ob
, tree expr
,
1051 lto_output_tree_or_ref (ob
, TREE_PURPOSE (expr
), ref_p
);
1052 lto_output_tree_or_ref (ob
, TREE_VALUE (expr
), ref_p
);
1053 lto_output_chain (ob
, TREE_CHAIN (expr
), ref_p
);
1057 /* Write all pointer fields in the TS_VEC structure of EXPR to output
1058 block OB. If REF_P is true, write a reference to EXPR's pointer
1062 lto_output_ts_vec_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
1066 /* Note that the number of slots for EXPR has already been emitted
1067 in EXPR's header (see lto_output_tree_header). */
1068 for (i
= 0; i
< TREE_VEC_LENGTH (expr
); i
++)
1069 lto_output_tree_or_ref (ob
, TREE_VEC_ELT (expr
, i
), ref_p
);
1073 /* Write all pointer fields in the TS_EXP structure of EXPR to output
1074 block OB. If REF_P is true, write a reference to EXPR's pointer
1078 lto_output_ts_exp_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
1082 output_sleb128 (ob
, TREE_OPERAND_LENGTH (expr
));
1083 for (i
= 0; i
< TREE_OPERAND_LENGTH (expr
); i
++)
1084 lto_output_tree_or_ref (ob
, TREE_OPERAND (expr
, i
), ref_p
);
1085 lto_output_location (ob
, EXPR_LOCATION (expr
));
1086 lto_output_tree_or_ref (ob
, TREE_BLOCK (expr
), ref_p
);
1090 /* Write all pointer fields in the TS_BLOCK structure of EXPR to output
1091 block OB. If REF_P is true, write a reference to EXPR's pointer
1095 lto_output_ts_block_tree_pointers (struct output_block
*ob
, tree expr
,
1098 /* Do not stream BLOCK_SOURCE_LOCATION. We cannot handle debug information
1099 for early inlining so drop it on the floor instead of ICEing in
1101 lto_output_chain (ob
, BLOCK_VARS (expr
), ref_p
);
1103 /* Do not stream BLOCK_NONLOCALIZED_VARS. We cannot handle debug information
1104 for early inlining so drop it on the floor instead of ICEing in
1107 lto_output_tree_or_ref (ob
, BLOCK_SUPERCONTEXT (expr
), ref_p
);
1108 /* Do not stream BLOCK_ABSTRACT_ORIGIN. We cannot handle debug information
1109 for early inlining so drop it on the floor instead of ICEing in
1111 lto_output_tree_or_ref (ob
, BLOCK_FRAGMENT_ORIGIN (expr
), ref_p
);
1112 lto_output_tree_or_ref (ob
, BLOCK_FRAGMENT_CHAIN (expr
), ref_p
);
1113 /* Do not output BLOCK_SUBBLOCKS. Instead on streaming-in this
1114 list is re-constructed from BLOCK_SUPERCONTEXT. */
1118 /* Write all pointer fields in the TS_BINFO structure of EXPR to output
1119 block OB. If REF_P is true, write a reference to EXPR's pointer
1123 lto_output_ts_binfo_tree_pointers (struct output_block
*ob
, tree expr
,
1129 /* Note that the number of BINFO slots has already been emitted in
1130 EXPR's header (see lto_output_tree_header) because this length
1131 is needed to build the empty BINFO node on the reader side. */
1132 FOR_EACH_VEC_ELT (tree
, BINFO_BASE_BINFOS (expr
), i
, t
)
1133 lto_output_tree_or_ref (ob
, t
, ref_p
);
1134 output_record_start (ob
, LTO_null
);
1136 lto_output_tree_or_ref (ob
, BINFO_OFFSET (expr
), ref_p
);
1137 lto_output_tree_or_ref (ob
, BINFO_VTABLE (expr
), ref_p
);
1138 lto_output_tree_or_ref (ob
, BINFO_VIRTUALS (expr
), ref_p
);
1139 lto_output_tree_or_ref (ob
, BINFO_VPTR_FIELD (expr
), ref_p
);
1141 output_uleb128 (ob
, VEC_length (tree
, BINFO_BASE_ACCESSES (expr
)));
1142 FOR_EACH_VEC_ELT (tree
, BINFO_BASE_ACCESSES (expr
), i
, t
)
1143 lto_output_tree_or_ref (ob
, t
, ref_p
);
1145 lto_output_tree_or_ref (ob
, BINFO_INHERITANCE_CHAIN (expr
), ref_p
);
1146 lto_output_tree_or_ref (ob
, BINFO_SUBVTT_INDEX (expr
), ref_p
);
1147 lto_output_tree_or_ref (ob
, BINFO_VPTR_INDEX (expr
), ref_p
);
1151 /* Write all pointer fields in the TS_CONSTRUCTOR structure of EXPR to
1152 output block OB. If REF_P is true, write a reference to EXPR's
1156 lto_output_ts_constructor_tree_pointers (struct output_block
*ob
, tree expr
,
1162 output_uleb128 (ob
, CONSTRUCTOR_NELTS (expr
));
1163 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (expr
), i
, index
, value
)
1165 lto_output_tree_or_ref (ob
, index
, ref_p
);
1166 lto_output_tree_or_ref (ob
, value
, ref_p
);
1170 /* Write a TS_TARGET_OPTION tree in EXPR to OB. */
1173 lto_output_ts_target_option (struct output_block
*ob
, tree expr
)
1175 struct cl_target_option
*t
= TREE_TARGET_OPTION (expr
);
1176 struct bitpack_d bp
;
1179 /* The cl_target_option is target specific and generated by the options
1180 awk script, so we just recreate a byte-by-byte copy here. */
1182 bp
= bitpack_create (ob
->main_stream
);
1183 len
= sizeof (struct cl_target_option
);
1184 for (i
= 0; i
< len
; i
++)
1185 bp_pack_value (&bp
, ((unsigned char *)t
)[i
], 8);
1186 /* Catch struct size mismatches between reader and writer. */
1187 bp_pack_value (&bp
, 0x12345678, 32);
1188 lto_output_bitpack (&bp
);
1191 /* Write a TS_TRANSLATION_UNIT_DECL tree in EXPR to OB. */
1194 lto_output_ts_translation_unit_decl_tree_pointers (struct output_block
*ob
,
1197 lto_output_string (ob
, ob
->main_stream
,
1198 TRANSLATION_UNIT_LANGUAGE (expr
), true);
1201 /* Helper for lto_output_tree. Write all pointer fields in EXPR to output
1202 block OB. If REF_P is true, the leaves of EXPR are emitted as
1206 lto_output_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
1208 enum tree_code code
;
1210 code
= TREE_CODE (expr
);
1212 if (CODE_CONTAINS_STRUCT (code
, TS_TYPED
))
1213 lto_output_ts_common_tree_pointers (ob
, expr
, ref_p
);
1215 if (CODE_CONTAINS_STRUCT (code
, TS_VECTOR
))
1216 lto_output_ts_vector_tree_pointers (ob
, expr
, ref_p
);
1218 if (CODE_CONTAINS_STRUCT (code
, TS_COMPLEX
))
1219 lto_output_ts_complex_tree_pointers (ob
, expr
, ref_p
);
1221 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
1222 lto_output_ts_decl_minimal_tree_pointers (ob
, expr
, ref_p
);
1224 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
1225 lto_output_ts_decl_common_tree_pointers (ob
, expr
, ref_p
);
1227 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_NON_COMMON
))
1228 lto_output_ts_decl_non_common_tree_pointers (ob
, expr
, ref_p
);
1230 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
1231 lto_output_ts_decl_with_vis_tree_pointers (ob
, expr
, ref_p
);
1233 if (CODE_CONTAINS_STRUCT (code
, TS_FIELD_DECL
))
1234 lto_output_ts_field_decl_tree_pointers (ob
, expr
, ref_p
);
1236 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
1237 lto_output_ts_function_decl_tree_pointers (ob
, expr
, ref_p
);
1239 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
1240 lto_output_ts_type_common_tree_pointers (ob
, expr
, ref_p
);
1242 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_NON_COMMON
))
1243 lto_output_ts_type_non_common_tree_pointers (ob
, expr
, ref_p
);
1245 if (CODE_CONTAINS_STRUCT (code
, TS_LIST
))
1246 lto_output_ts_list_tree_pointers (ob
, expr
, ref_p
);
1248 if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
1249 lto_output_ts_vec_tree_pointers (ob
, expr
, ref_p
);
1251 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
1252 lto_output_ts_exp_tree_pointers (ob
, expr
, ref_p
);
1254 if (CODE_CONTAINS_STRUCT (code
, TS_SSA_NAME
))
1256 /* We only stream the version number of SSA names. */
1260 if (CODE_CONTAINS_STRUCT (code
, TS_BLOCK
))
1261 lto_output_ts_block_tree_pointers (ob
, expr
, ref_p
);
1263 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
1264 lto_output_ts_binfo_tree_pointers (ob
, expr
, ref_p
);
1266 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
1267 lto_output_ts_constructor_tree_pointers (ob
, expr
, ref_p
);
1269 if (CODE_CONTAINS_STRUCT (code
, TS_STATEMENT_LIST
))
1271 /* This should only appear in GENERIC. */
1275 if (CODE_CONTAINS_STRUCT (code
, TS_OMP_CLAUSE
))
1277 /* This should only appear in High GIMPLE. */
1281 if (CODE_CONTAINS_STRUCT (code
, TS_OPTIMIZATION
))
1282 sorry ("gimple bytecode streams do not support the optimization attribute");
1284 if (CODE_CONTAINS_STRUCT (code
, TS_TARGET_OPTION
))
1285 lto_output_ts_target_option (ob
, expr
);
1287 if (CODE_CONTAINS_STRUCT (code
, TS_TRANSLATION_UNIT_DECL
))
1288 lto_output_ts_translation_unit_decl_tree_pointers (ob
, expr
);
1292 /* Emit header information for tree EXPR to output block OB. The header
1293 contains everything needed to instantiate an empty skeleton for
1294 EXPR on the reading side. IX is the index into the streamer cache
1295 where EXPR is stored. REF_P is as in lto_output_tree. */
1298 lto_output_tree_header (struct output_block
*ob
, tree expr
)
1301 enum tree_code code
;
1303 /* We should not see any non-GIMPLE tree nodes here. */
1304 code
= TREE_CODE (expr
);
1305 if (!lto_is_streamable (expr
))
1306 internal_error ("tree code %qs is not supported in gimple streams",
1307 tree_code_name
[code
]);
1309 /* The header of a tree node consists of its tag, the size of
1310 the node, and any other information needed to instantiate
1311 EXPR on the reading side (such as the number of slots in
1312 variable sized nodes). */
1313 tag
= lto_tree_code_to_tag (code
);
1314 output_record_start (ob
, tag
);
1316 /* The following will cause bootstrap miscomparisons. Enable with care. */
1317 #ifdef LTO_STREAMER_DEBUG
1318 /* This is used mainly for debugging purposes. When the reader
1319 and the writer do not agree on a streamed node, the pointer
1320 value for EXPR can be used to track down the differences in
1322 gcc_assert ((HOST_WIDEST_INT
) (intptr_t) expr
== (intptr_t) expr
);
1323 output_sleb128 (ob
, (HOST_WIDEST_INT
) (intptr_t) expr
);
1326 /* The text in strings and identifiers are completely emitted in
1328 if (CODE_CONTAINS_STRUCT (code
, TS_STRING
))
1329 output_string_cst (ob
, ob
->main_stream
, expr
);
1330 else if (CODE_CONTAINS_STRUCT (code
, TS_IDENTIFIER
))
1331 output_identifier (ob
, ob
->main_stream
, expr
);
1332 else if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
1333 output_sleb128 (ob
, TREE_VEC_LENGTH (expr
));
1334 else if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
1335 output_uleb128 (ob
, BINFO_N_BASE_BINFOS (expr
));
1339 /* Write the code and class of builtin EXPR to output block OB. IX is
1340 the index into the streamer cache where EXPR is stored.*/
1343 lto_output_builtin_tree (struct output_block
*ob
, tree expr
)
1345 gcc_assert (lto_stream_as_builtin_p (expr
));
1347 if (DECL_BUILT_IN_CLASS (expr
) == BUILT_IN_MD
1348 && !targetm
.builtin_decl
)
1349 sorry ("gimple bytecode streams do not support machine specific builtin "
1350 "functions on this target");
1352 output_record_start (ob
, LTO_builtin_decl
);
1353 lto_output_enum (ob
->main_stream
, built_in_class
, BUILT_IN_LAST
,
1354 DECL_BUILT_IN_CLASS (expr
));
1355 output_uleb128 (ob
, DECL_FUNCTION_CODE (expr
));
1357 if (DECL_ASSEMBLER_NAME_SET_P (expr
))
1359 /* When the assembler name of a builtin gets a user name,
1360 the new name is always prefixed with '*' by
1361 set_builtin_user_assembler_name. So, to prevent the
1362 reader side from adding a second '*', we omit it here. */
1363 const char *str
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (expr
));
1364 if (strlen (str
) > 1 && str
[0] == '*')
1365 lto_output_string (ob
, ob
->main_stream
, &str
[1], true);
1367 lto_output_string (ob
, ob
->main_stream
, NULL
, true);
1370 lto_output_string (ob
, ob
->main_stream
, NULL
, true);
1374 /* Write a physical representation of tree node EXPR to output block
1375 OB. If REF_P is true, the leaves of EXPR are emitted as references
1376 via lto_output_tree_ref. IX is the index into the streamer cache
1377 where EXPR is stored. */
1380 lto_write_tree (struct output_block
*ob
, tree expr
, bool ref_p
)
1382 struct bitpack_d bp
;
1384 /* Write the header, containing everything needed to materialize
1385 EXPR on the reading side. */
1386 lto_output_tree_header (ob
, expr
);
1388 /* Pack all the non-pointer fields in EXPR into a bitpack and write
1389 the resulting bitpack. */
1390 bp
= bitpack_create (ob
->main_stream
);
1391 pack_value_fields (&bp
, expr
);
1392 lto_output_bitpack (&bp
);
1394 /* Write all the pointer fields in EXPR. */
1395 lto_output_tree_pointers (ob
, expr
, ref_p
);
1397 /* Mark the end of EXPR. */
1402 /* Emit the integer constant CST to output block OB. If REF_P is true,
1403 CST's type will be emitted as a reference. */
1406 lto_output_integer_cst (struct output_block
*ob
, tree cst
, bool ref_p
)
1408 output_record_start (ob
, lto_tree_code_to_tag (INTEGER_CST
));
1409 lto_output_tree_or_ref (ob
, TREE_TYPE (cst
), ref_p
);
1410 lto_output_1_stream (ob
->main_stream
, TREE_OVERFLOW_P (cst
));
1411 output_uleb128 (ob
, TREE_INT_CST_LOW (cst
));
1412 output_uleb128 (ob
, TREE_INT_CST_HIGH (cst
));
1416 /* Emit the physical representation of tree node EXPR to output block
1417 OB. If REF_P is true, the leaves of EXPR are emitted as references
1418 via lto_output_tree_ref. */
1421 lto_output_tree (struct output_block
*ob
, tree expr
, bool ref_p
)
1426 if (expr
== NULL_TREE
)
1428 output_record_start (ob
, LTO_null
);
1432 /* INTEGER_CST nodes are special because they need their original type
1433 to be materialized by the reader (to implement TYPE_CACHED_VALUES). */
1434 if (TREE_CODE (expr
) == INTEGER_CST
)
1436 lto_output_integer_cst (ob
, expr
, ref_p
);
1440 existed_p
= lto_streamer_cache_insert (ob
->writer_cache
, expr
, &ix
);
1443 /* If a node has already been streamed out, make sure that
1444 we don't write it more than once. Otherwise, the reader
1445 will instantiate two different nodes for the same object. */
1446 output_record_start (ob
, LTO_tree_pickle_reference
);
1447 output_uleb128 (ob
, ix
);
1448 lto_output_enum (ob
->main_stream
, LTO_tags
, LTO_NUM_TAGS
,
1449 lto_tree_code_to_tag (TREE_CODE (expr
)));
1451 else if (lto_stream_as_builtin_p (expr
))
1453 /* MD and NORMAL builtins do not need to be written out
1454 completely as they are always instantiated by the
1455 compiler on startup. The only builtins that need to
1456 be written out are BUILT_IN_FRONTEND. For all other
1457 builtins, we simply write the class and code. */
1458 lto_output_builtin_tree (ob
, expr
);
1462 /* This is the first time we see EXPR, write its fields
1464 lto_write_tree (ob
, expr
, ref_p
);
1469 /* Output to OB a list of try/catch handlers starting with FIRST. */
1472 output_eh_try_list (struct output_block
*ob
, eh_catch first
)
1476 for (n
= first
; n
; n
= n
->next_catch
)
1478 output_record_start (ob
, LTO_eh_catch
);
1479 lto_output_tree_ref (ob
, n
->type_list
);
1480 lto_output_tree_ref (ob
, n
->filter_list
);
1481 lto_output_tree_ref (ob
, n
->label
);
1484 output_record_start (ob
, LTO_null
);
1488 /* Output EH region R in function FN to OB. CURR_RN is the slot index
1489 that is being emitted in FN->EH->REGION_ARRAY. This is used to
1490 detect EH region sharing. */
1493 output_eh_region (struct output_block
*ob
, eh_region r
)
1499 output_record_start (ob
, LTO_null
);
1503 if (r
->type
== ERT_CLEANUP
)
1504 tag
= LTO_ert_cleanup
;
1505 else if (r
->type
== ERT_TRY
)
1507 else if (r
->type
== ERT_ALLOWED_EXCEPTIONS
)
1508 tag
= LTO_ert_allowed_exceptions
;
1509 else if (r
->type
== ERT_MUST_NOT_THROW
)
1510 tag
= LTO_ert_must_not_throw
;
1514 output_record_start (ob
, tag
);
1515 output_sleb128 (ob
, r
->index
);
1518 output_sleb128 (ob
, r
->outer
->index
);
1523 output_sleb128 (ob
, r
->inner
->index
);
1528 output_sleb128 (ob
, r
->next_peer
->index
);
1532 if (r
->type
== ERT_TRY
)
1534 output_eh_try_list (ob
, r
->u
.eh_try
.first_catch
);
1536 else if (r
->type
== ERT_ALLOWED_EXCEPTIONS
)
1538 lto_output_tree_ref (ob
, r
->u
.allowed
.type_list
);
1539 lto_output_tree_ref (ob
, r
->u
.allowed
.label
);
1540 output_uleb128 (ob
, r
->u
.allowed
.filter
);
1542 else if (r
->type
== ERT_MUST_NOT_THROW
)
1544 lto_output_tree_ref (ob
, r
->u
.must_not_throw
.failure_decl
);
1545 lto_output_location (ob
, r
->u
.must_not_throw
.failure_loc
);
1548 if (r
->landing_pads
)
1549 output_sleb128 (ob
, r
->landing_pads
->index
);
1555 /* Output landing pad LP to OB. */
1558 output_eh_lp (struct output_block
*ob
, eh_landing_pad lp
)
1562 output_record_start (ob
, LTO_null
);
1566 output_record_start (ob
, LTO_eh_landing_pad
);
1567 output_sleb128 (ob
, lp
->index
);
1569 output_sleb128 (ob
, lp
->next_lp
->index
);
1574 output_sleb128 (ob
, lp
->region
->index
);
1578 lto_output_tree_ref (ob
, lp
->post_landing_pad
);
1582 /* Output the existing eh_table to OB. */
1585 output_eh_regions (struct output_block
*ob
, struct function
*fn
)
1587 if (fn
->eh
&& fn
->eh
->region_tree
)
1594 output_record_start (ob
, LTO_eh_table
);
1596 /* Emit the index of the root of the EH region tree. */
1597 output_sleb128 (ob
, fn
->eh
->region_tree
->index
);
1599 /* Emit all the EH regions in the region array. */
1600 output_sleb128 (ob
, VEC_length (eh_region
, fn
->eh
->region_array
));
1601 FOR_EACH_VEC_ELT (eh_region
, fn
->eh
->region_array
, i
, eh
)
1602 output_eh_region (ob
, eh
);
1604 /* Emit all landing pads. */
1605 output_sleb128 (ob
, VEC_length (eh_landing_pad
, fn
->eh
->lp_array
));
1606 FOR_EACH_VEC_ELT (eh_landing_pad
, fn
->eh
->lp_array
, i
, lp
)
1607 output_eh_lp (ob
, lp
);
1609 /* Emit all the runtime type data. */
1610 output_sleb128 (ob
, VEC_length (tree
, fn
->eh
->ttype_data
));
1611 FOR_EACH_VEC_ELT (tree
, fn
->eh
->ttype_data
, i
, ttype
)
1612 lto_output_tree_ref (ob
, ttype
);
1614 /* Emit the table of action chains. */
1615 if (targetm
.arm_eabi_unwinder
)
1618 output_sleb128 (ob
, VEC_length (tree
, fn
->eh
->ehspec_data
.arm_eabi
));
1619 FOR_EACH_VEC_ELT (tree
, fn
->eh
->ehspec_data
.arm_eabi
, i
, t
)
1620 lto_output_tree_ref (ob
, t
);
1625 output_sleb128 (ob
, VEC_length (uchar
, fn
->eh
->ehspec_data
.other
));
1626 FOR_EACH_VEC_ELT (uchar
, fn
->eh
->ehspec_data
.other
, i
, c
)
1627 lto_output_1_stream (ob
->main_stream
, c
);
1631 /* The LTO_null either terminates the record or indicates that there
1632 are no eh_records at all. */
1633 output_record_start (ob
, LTO_null
);
1637 /* Output all of the active ssa names to the ssa_names stream. */
1640 output_ssa_names (struct output_block
*ob
, struct function
*fn
)
1642 unsigned int i
, len
;
1644 len
= VEC_length (tree
, SSANAMES (fn
));
1645 output_uleb128 (ob
, len
);
1647 for (i
= 1; i
< len
; i
++)
1649 tree ptr
= VEC_index (tree
, SSANAMES (fn
), i
);
1651 if (ptr
== NULL_TREE
1652 || SSA_NAME_IN_FREE_LIST (ptr
)
1653 || !is_gimple_reg (ptr
))
1656 output_uleb128 (ob
, i
);
1657 lto_output_1_stream (ob
->main_stream
, SSA_NAME_IS_DEFAULT_DEF (ptr
));
1658 lto_output_tree_ref (ob
, SSA_NAME_VAR (ptr
));
1665 /* Output the cfg. */
1668 output_cfg (struct output_block
*ob
, struct function
*fn
)
1670 struct lto_output_stream
*tmp_stream
= ob
->main_stream
;
1673 ob
->main_stream
= ob
->cfg_stream
;
1675 lto_output_enum (ob
->main_stream
, profile_status_d
, PROFILE_LAST
,
1676 profile_status_for_function (fn
));
1678 /* Output the number of the highest basic block. */
1679 output_uleb128 (ob
, last_basic_block_for_function (fn
));
1681 FOR_ALL_BB_FN (bb
, fn
)
1686 output_sleb128 (ob
, bb
->index
);
1688 /* Output the successors and the edge flags. */
1689 output_uleb128 (ob
, EDGE_COUNT (bb
->succs
));
1690 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
1692 output_uleb128 (ob
, e
->dest
->index
);
1693 output_sleb128 (ob
, e
->probability
);
1694 output_sleb128 (ob
, e
->count
);
1695 output_uleb128 (ob
, e
->flags
);
1699 output_sleb128 (ob
, -1);
1701 bb
= ENTRY_BLOCK_PTR
;
1704 output_sleb128 (ob
, bb
->next_bb
->index
);
1708 output_sleb128 (ob
, -1);
1710 ob
->main_stream
= tmp_stream
;
1714 /* Output PHI function PHI to the main stream in OB. */
1717 output_phi (struct output_block
*ob
, gimple phi
)
1719 unsigned i
, len
= gimple_phi_num_args (phi
);
1721 output_record_start (ob
, lto_gimple_code_to_tag (GIMPLE_PHI
));
1722 output_uleb128 (ob
, SSA_NAME_VERSION (PHI_RESULT (phi
)));
1724 for (i
= 0; i
< len
; i
++)
1726 lto_output_tree_ref (ob
, gimple_phi_arg_def (phi
, i
));
1727 output_uleb128 (ob
, gimple_phi_arg_edge (phi
, i
)->src
->index
);
1728 lto_output_location (ob
, gimple_phi_arg_location (phi
, i
));
1733 /* Emit statement STMT on the main stream of output block OB. */
1736 output_gimple_stmt (struct output_block
*ob
, gimple stmt
)
1739 enum gimple_code code
;
1741 struct bitpack_d bp
;
1743 /* Emit identifying tag. */
1744 code
= gimple_code (stmt
);
1745 tag
= lto_gimple_code_to_tag (code
);
1746 output_record_start (ob
, tag
);
1748 /* Emit the tuple header. */
1749 bp
= bitpack_create (ob
->main_stream
);
1750 bp_pack_var_len_unsigned (&bp
, gimple_num_ops (stmt
));
1751 bp_pack_value (&bp
, gimple_no_warning_p (stmt
), 1);
1752 if (is_gimple_assign (stmt
))
1753 bp_pack_value (&bp
, gimple_assign_nontemporal_move_p (stmt
), 1);
1754 bp_pack_value (&bp
, gimple_has_volatile_ops (stmt
), 1);
1755 bp_pack_var_len_unsigned (&bp
, stmt
->gsbase
.subcode
);
1756 lto_output_bitpack (&bp
);
1758 /* Emit location information for the statement. */
1759 lto_output_location (ob
, gimple_location (stmt
));
1761 /* Emit the lexical block holding STMT. */
1762 lto_output_tree (ob
, gimple_block (stmt
), true);
1764 /* Emit the operands. */
1765 switch (gimple_code (stmt
))
1768 output_sleb128 (ob
, gimple_resx_region (stmt
));
1771 case GIMPLE_EH_MUST_NOT_THROW
:
1772 lto_output_tree_ref (ob
, gimple_eh_must_not_throw_fndecl (stmt
));
1775 case GIMPLE_EH_DISPATCH
:
1776 output_sleb128 (ob
, gimple_eh_dispatch_region (stmt
));
1780 lto_output_uleb128_stream (ob
->main_stream
, gimple_asm_ninputs (stmt
));
1781 lto_output_uleb128_stream (ob
->main_stream
, gimple_asm_noutputs (stmt
));
1782 lto_output_uleb128_stream (ob
->main_stream
, gimple_asm_nclobbers (stmt
));
1783 lto_output_uleb128_stream (ob
->main_stream
, gimple_asm_nlabels (stmt
));
1784 lto_output_string (ob
, ob
->main_stream
, gimple_asm_string (stmt
), true);
1795 for (i
= 0; i
< gimple_num_ops (stmt
); i
++)
1797 tree op
= gimple_op (stmt
, i
);
1798 /* Wrap all uses of non-automatic variables inside MEM_REFs
1799 so that we do not have to deal with type mismatches on
1800 merged symbols during IL read in. The first operand
1801 of GIMPLE_DEBUG must be a decl, not MEM_REF, though. */
1802 if (op
&& (i
|| !is_gimple_debug (stmt
)))
1805 while (handled_component_p (*basep
))
1806 basep
= &TREE_OPERAND (*basep
, 0);
1807 if (TREE_CODE (*basep
) == VAR_DECL
1808 && !auto_var_in_fn_p (*basep
, current_function_decl
)
1809 && !DECL_REGISTER (*basep
))
1811 bool volatilep
= TREE_THIS_VOLATILE (*basep
);
1812 *basep
= build2 (MEM_REF
, TREE_TYPE (*basep
),
1813 build_fold_addr_expr (*basep
),
1814 build_int_cst (build_pointer_type
1815 (TREE_TYPE (*basep
)), 0));
1816 TREE_THIS_VOLATILE (*basep
) = volatilep
;
1819 lto_output_tree_ref (ob
, op
);
1821 if (is_gimple_call (stmt
))
1823 if (gimple_call_internal_p (stmt
))
1824 lto_output_enum (ob
->main_stream
, internal_fn
,
1825 IFN_LAST
, gimple_call_internal_fn (stmt
));
1827 lto_output_tree_ref (ob
, gimple_call_fntype (stmt
));
1832 case GIMPLE_PREDICT
:
1841 /* Output a basic block BB to the main stream in OB for this FN. */
1844 output_bb (struct output_block
*ob
, basic_block bb
, struct function
*fn
)
1846 gimple_stmt_iterator bsi
= gsi_start_bb (bb
);
1848 output_record_start (ob
,
1849 (!gsi_end_p (bsi
)) || phi_nodes (bb
)
1853 output_uleb128 (ob
, bb
->index
);
1854 output_sleb128 (ob
, bb
->count
);
1855 output_sleb128 (ob
, bb
->loop_depth
);
1856 output_sleb128 (ob
, bb
->frequency
);
1857 output_sleb128 (ob
, bb
->flags
);
1859 if (!gsi_end_p (bsi
) || phi_nodes (bb
))
1861 /* Output the statements. The list of statements is terminated
1863 for (bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
1866 gimple stmt
= gsi_stmt (bsi
);
1868 output_gimple_stmt (ob
, stmt
);
1870 /* Emit the EH region holding STMT. */
1871 region
= lookup_stmt_eh_lp_fn (fn
, stmt
);
1874 output_record_start (ob
, LTO_eh_region
);
1875 output_sleb128 (ob
, region
);
1878 output_record_start (ob
, LTO_null
);
1881 output_record_start (ob
, LTO_null
);
1883 for (bsi
= gsi_start_phis (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
1885 gimple phi
= gsi_stmt (bsi
);
1887 /* Only emit PHIs for gimple registers. PHI nodes for .MEM
1888 will be filled in on reading when the SSA form is
1890 if (is_gimple_reg (gimple_phi_result (phi
)))
1891 output_phi (ob
, phi
);
1894 output_record_start (ob
, LTO_null
);
1898 /* Create the header in the file using OB. If the section type is for
1899 a function, set FN to the decl for that function. */
1902 produce_asm (struct output_block
*ob
, tree fn
)
1904 enum lto_section_type section_type
= ob
->section_type
;
1905 struct lto_function_header header
;
1907 struct lto_output_stream
*header_stream
;
1909 if (section_type
== LTO_section_function_body
)
1911 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fn
));
1912 section_name
= lto_get_section_name (section_type
, name
, NULL
);
1915 section_name
= lto_get_section_name (section_type
, NULL
, NULL
);
1917 lto_begin_section (section_name
, !flag_wpa
);
1918 free (section_name
);
1920 /* The entire header is stream computed here. */
1921 memset (&header
, 0, sizeof (struct lto_function_header
));
1923 /* Write the header. */
1924 header
.lto_header
.major_version
= LTO_major_version
;
1925 header
.lto_header
.minor_version
= LTO_minor_version
;
1926 header
.lto_header
.section_type
= section_type
;
1928 header
.compressed_size
= 0;
1930 if (section_type
== LTO_section_function_body
)
1931 header
.cfg_size
= ob
->cfg_stream
->total_size
;
1932 header
.main_size
= ob
->main_stream
->total_size
;
1933 header
.string_size
= ob
->string_stream
->total_size
;
1935 header_stream
= XCNEW (struct lto_output_stream
);
1936 lto_output_data_stream (header_stream
, &header
, sizeof header
);
1937 lto_write_stream (header_stream
);
1938 free (header_stream
);
1940 /* Put all of the gimple and the string table out the asm file as a
1942 if (section_type
== LTO_section_function_body
)
1943 lto_write_stream (ob
->cfg_stream
);
1944 lto_write_stream (ob
->main_stream
);
1945 lto_write_stream (ob
->string_stream
);
1951 /* Output the body of function NODE->DECL. */
1954 output_function (struct cgraph_node
*node
)
1956 struct bitpack_d bp
;
1958 struct function
*fn
;
1960 struct output_block
*ob
;
1964 function
= node
->decl
;
1965 fn
= DECL_STRUCT_FUNCTION (function
);
1966 ob
= create_output_block (LTO_section_function_body
);
1968 clear_line_info (ob
);
1969 ob
->cgraph_node
= node
;
1971 gcc_assert (current_function_decl
== NULL_TREE
&& cfun
== NULL
);
1973 /* Set current_function_decl and cfun. */
1974 current_function_decl
= function
;
1977 /* Make string 0 be a NULL string. */
1978 lto_output_1_stream (ob
->string_stream
, 0);
1980 output_record_start (ob
, LTO_function
);
1982 /* Write all the attributes for FN. */
1983 bp
= bitpack_create (ob
->main_stream
);
1984 bp_pack_value (&bp
, fn
->is_thunk
, 1);
1985 bp_pack_value (&bp
, fn
->has_local_explicit_reg_vars
, 1);
1986 bp_pack_value (&bp
, fn
->after_tree_profile
, 1);
1987 bp_pack_value (&bp
, fn
->returns_pcc_struct
, 1);
1988 bp_pack_value (&bp
, fn
->returns_struct
, 1);
1989 bp_pack_value (&bp
, fn
->can_throw_non_call_exceptions
, 1);
1990 bp_pack_value (&bp
, fn
->always_inline_functions_inlined
, 1);
1991 bp_pack_value (&bp
, fn
->after_inlining
, 1);
1992 bp_pack_value (&bp
, fn
->stdarg
, 1);
1993 bp_pack_value (&bp
, fn
->has_nonlocal_label
, 1);
1994 bp_pack_value (&bp
, fn
->calls_alloca
, 1);
1995 bp_pack_value (&bp
, fn
->calls_setjmp
, 1);
1996 bp_pack_value (&bp
, fn
->va_list_fpr_size
, 8);
1997 bp_pack_value (&bp
, fn
->va_list_gpr_size
, 8);
1998 lto_output_bitpack (&bp
);
2000 /* Output the function start and end loci. */
2001 lto_output_location (ob
, fn
->function_start_locus
);
2002 lto_output_location (ob
, fn
->function_end_locus
);
2004 /* Output current IL state of the function. */
2005 output_uleb128 (ob
, fn
->curr_properties
);
2007 /* Output the static chain and non-local goto save area. */
2008 lto_output_tree_ref (ob
, fn
->static_chain_decl
);
2009 lto_output_tree_ref (ob
, fn
->nonlocal_goto_save_area
);
2011 /* Output all the local variables in the function. */
2012 output_sleb128 (ob
, VEC_length (tree
, fn
->local_decls
));
2013 FOR_EACH_VEC_ELT (tree
, fn
->local_decls
, i
, t
)
2014 lto_output_tree_ref (ob
, t
);
2016 /* Output the head of the arguments list. */
2017 lto_output_tree_ref (ob
, DECL_ARGUMENTS (function
));
2019 /* Output all the SSA names used in the function. */
2020 output_ssa_names (ob
, fn
);
2022 /* Output any exception handling regions. */
2023 output_eh_regions (ob
, fn
);
2025 /* Output DECL_INITIAL for the function, which contains the tree of
2027 lto_output_tree (ob
, DECL_INITIAL (function
), true);
2029 /* We will renumber the statements. The code that does this uses
2030 the same ordering that we use for serializing them so we can use
2031 the same code on the other end and not have to write out the
2032 statement numbers. We do not assign UIDs to PHIs here because
2033 virtual PHIs get re-computed on-the-fly which would make numbers
2035 set_gimple_stmt_max_uid (cfun
, 0);
2038 gimple_stmt_iterator gsi
;
2039 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
2041 gimple stmt
= gsi_stmt (gsi
);
2042 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
2046 /* Output the code for the function. */
2047 FOR_ALL_BB_FN (bb
, fn
)
2048 output_bb (ob
, bb
, fn
);
2050 /* The terminator for this function. */
2051 output_record_start (ob
, LTO_null
);
2053 output_cfg (ob
, fn
);
2055 /* Create a section to hold the pickled output of this function. */
2056 produce_asm (ob
, function
);
2058 destroy_output_block (ob
);
2060 current_function_decl
= NULL
;
2065 /* Used to pass data to trivally_defined_alias callback. */
2067 cgraph_node_set set
;
2068 varpool_node_set vset
;
2072 /* Return true if alias pair P belongs to the set of cgraph nodes in
2073 SET. If P is a an alias for a VAR_DECL, it can always be emitted.
2074 However, for FUNCTION_DECL aliases, we should only output the pair
2075 if it belongs to a function whose cgraph node is in SET.
2076 Otherwise, the LTRANS phase will get into trouble when finalizing
2077 aliases because the alias will refer to a function not defined in
2078 the file processed by LTRANS. */
2081 trivally_defined_alias (tree decl ATTRIBUTE_UNUSED
,
2082 tree target
, void *data
)
2084 struct sets
*set
= (struct sets
*) data
;
2085 struct cgraph_node
*fnode
= NULL
;
2086 struct varpool_node
*vnode
= NULL
;
2088 fnode
= cgraph_node_for_asm (target
);
2090 return cgraph_node_in_set_p (fnode
, set
->set
);
2091 vnode
= varpool_node_for_asm (target
);
2092 return vnode
&& varpool_node_in_set_p (vnode
, set
->vset
);
2095 /* Return true if alias pair P should be output in the current
2096 partition contains cgrpah nodes SET and varpool nodes VSET.
2097 DEFINED is set of all aliases whose targets are defined in
2100 Normal aliases are output when they are defined, while WEAKREF
2101 aliases are output when they are used. */
2104 output_alias_pair_p (alias_pair
*p
, symbol_alias_set_t
*defined
,
2105 cgraph_node_set set
, varpool_node_set vset
)
2107 struct cgraph_node
*node
;
2108 struct varpool_node
*vnode
;
2110 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (p
->decl
)))
2112 if (TREE_CODE (p
->decl
) == VAR_DECL
)
2114 vnode
= varpool_get_node (p
->decl
);
2116 && referenced_from_this_partition_p (&vnode
->ref_list
, set
, vset
));
2118 node
= cgraph_get_node (p
->decl
);
2120 && (referenced_from_this_partition_p (&node
->ref_list
, set
, vset
)
2121 || reachable_from_this_partition_p (node
, set
)));
2124 return symbol_alias_set_contains (defined
, p
->decl
);
2127 /* Output any unreferenced global symbol defined in SET, alias pairs
2131 output_unreferenced_globals (cgraph_node_set set
, varpool_node_set vset
)
2133 struct output_block
*ob
;
2136 symbol_alias_set_t
*defined
;
2137 struct sets setdata
;
2140 setdata
.vset
= vset
;
2142 ob
= create_output_block (LTO_section_static_initializer
);
2143 ob
->cgraph_node
= NULL
;
2145 clear_line_info (ob
);
2147 /* Make string 0 be a NULL string. */
2148 lto_output_1_stream (ob
->string_stream
, 0);
2150 /* We really need to propagate in both directoins:
2151 for normal aliases we propagate from first defined alias to
2152 all aliases defined based on it. For weakrefs we propagate in
2153 the oposite direction. */
2154 defined
= propagate_aliases_backward (trivally_defined_alias
, &setdata
);
2156 /* Emit the alias pairs for the nodes in SET. */
2157 FOR_EACH_VEC_ELT (alias_pair
, alias_pairs
, i
, p
)
2158 if (output_alias_pair_p (p
, defined
, set
, vset
))
2160 lto_output_tree_ref (ob
, p
->decl
);
2161 lto_output_tree_ref (ob
, p
->target
);
2163 symbol_alias_set_destroy (defined
);
2165 output_record_start (ob
, LTO_null
);
2167 produce_asm (ob
, NULL
);
2168 destroy_output_block (ob
);
2172 /* Copy the function body of NODE without deserializing. */
2175 copy_function (struct cgraph_node
*node
)
2177 tree function
= node
->decl
;
2178 struct lto_file_decl_data
*file_data
= node
->local
.lto_file_data
;
2179 struct lto_output_stream
*output_stream
= XCNEW (struct lto_output_stream
);
2182 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (function
));
2183 char *section_name
=
2184 lto_get_section_name (LTO_section_function_body
, name
, NULL
);
2186 struct lto_in_decl_state
*in_state
;
2187 struct lto_out_decl_state
*out_state
= lto_get_out_decl_state ();
2189 lto_begin_section (section_name
, !flag_wpa
);
2190 free (section_name
);
2192 /* We may have renamed the declaration, e.g., a static function. */
2193 name
= lto_get_decl_name_mapping (file_data
, name
);
2195 data
= lto_get_section_data (file_data
, LTO_section_function_body
,
2199 /* Do a bit copy of the function body. */
2200 lto_output_data_stream (output_stream
, data
, len
);
2201 lto_write_stream (output_stream
);
2205 lto_get_function_in_decl_state (node
->local
.lto_file_data
, function
);
2206 gcc_assert (in_state
);
2208 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2210 size_t n
= in_state
->streams
[i
].size
;
2211 tree
*trees
= in_state
->streams
[i
].trees
;
2212 struct lto_tree_ref_encoder
*encoder
= &(out_state
->streams
[i
]);
2214 /* The out state must have the same indices and the in state.
2215 So just copy the vector. All the encoders in the in state
2216 must be empty where we reach here. */
2217 gcc_assert (lto_tree_ref_encoder_size (encoder
) == 0);
2218 for (j
= 0; j
< n
; j
++)
2219 VEC_safe_push (tree
, heap
, encoder
->trees
, trees
[j
]);
2220 encoder
->next_index
= n
;
2223 lto_free_section_data (file_data
, LTO_section_function_body
, name
,
2225 free (output_stream
);
2230 /* Initialize the LTO writer. */
2233 lto_writer_init (void)
2235 lto_streamer_init ();
2239 /* Main entry point from the pass manager. */
2242 lto_output (cgraph_node_set set
, varpool_node_set vset
)
2244 struct cgraph_node
*node
;
2245 struct lto_out_decl_state
*decl_state
;
2246 #ifdef ENABLE_CHECKING
2247 bitmap output
= lto_bitmap_alloc ();
2250 lto_cgraph_encoder_t encoder
= lto_get_out_decl_state ()->cgraph_node_encoder
;
2254 n_nodes
= lto_cgraph_encoder_size (encoder
);
2255 /* Process only the functions with bodies. */
2256 for (i
= 0; i
< n_nodes
; i
++)
2258 node
= lto_cgraph_encoder_deref (encoder
, i
);
2259 if (lto_cgraph_encoder_encode_body_p (encoder
, node
)
2260 && !node
->thunk
.thunk_p
)
2262 #ifdef ENABLE_CHECKING
2263 gcc_assert (!bitmap_bit_p (output
, DECL_UID (node
->decl
)));
2264 bitmap_set_bit (output
, DECL_UID (node
->decl
));
2266 decl_state
= lto_new_out_decl_state ();
2267 lto_push_out_decl_state (decl_state
);
2268 if (gimple_has_body_p (node
->decl
))
2269 output_function (node
);
2271 copy_function (node
);
2272 gcc_assert (lto_get_out_decl_state () == decl_state
);
2273 lto_pop_out_decl_state ();
2274 lto_record_function_out_decl_state (node
->decl
, decl_state
);
2278 /* Emit the callgraph after emitting function bodies. This needs to
2279 be done now to make sure that all the statements in every function
2280 have been renumbered so that edges can be associated with call
2281 statements using the statement UIDs. */
2282 output_cgraph (set
, vset
);
2284 #ifdef ENABLE_CHECKING
2285 lto_bitmap_free (output
);
2289 struct ipa_opt_pass_d pass_ipa_lto_gimple_out
=
2293 "lto_gimple_out", /* name */
2294 gate_lto_out
, /* gate */
2298 0, /* static_pass_number */
2299 TV_IPA_LTO_GIMPLE_OUT
, /* tv_id */
2300 0, /* properties_required */
2301 0, /* properties_provided */
2302 0, /* properties_destroyed */
2303 0, /* todo_flags_start */
2304 TODO_dump_func
/* todo_flags_finish */
2306 NULL
, /* generate_summary */
2307 lto_output
, /* write_summary */
2308 NULL
, /* read_summary */
2309 lto_output
, /* write_optimization_summary */
2310 NULL
, /* read_optimization_summary */
2311 NULL
, /* stmt_fixup */
2313 NULL
, /* function_transform */
2314 NULL
/* variable_transform */
2318 /* Write each node in encoded by ENCODER to OB, as well as those reachable
2319 from it and required for correct representation of its semantics.
2320 Each node in ENCODER must be a global declaration or a type. A node
2321 is written only once, even if it appears multiple times in the
2322 vector. Certain transitively-reachable nodes, such as those
2323 representing expressions, may be duplicated, but such nodes
2324 must not appear in ENCODER itself. */
2327 write_global_stream (struct output_block
*ob
,
2328 struct lto_tree_ref_encoder
*encoder
)
2332 const size_t size
= lto_tree_ref_encoder_size (encoder
);
2334 for (index
= 0; index
< size
; index
++)
2336 t
= lto_tree_ref_encoder_get_tree (encoder
, index
);
2337 if (!lto_streamer_cache_lookup (ob
->writer_cache
, t
, NULL
))
2338 lto_output_tree (ob
, t
, false);
2343 /* Write a sequence of indices into the globals vector corresponding
2344 to the trees in ENCODER. These are used by the reader to map the
2345 indices used to refer to global entities within function bodies to
2349 write_global_references (struct output_block
*ob
,
2350 struct lto_output_stream
*ref_stream
,
2351 struct lto_tree_ref_encoder
*encoder
)
2355 const uint32_t size
= lto_tree_ref_encoder_size (encoder
);
2357 /* Write size as 32-bit unsigned. */
2358 lto_output_data_stream (ref_stream
, &size
, sizeof (int32_t));
2360 for (index
= 0; index
< size
; index
++)
2364 t
= lto_tree_ref_encoder_get_tree (encoder
, index
);
2365 lto_streamer_cache_lookup (ob
->writer_cache
, t
, &slot_num
);
2366 gcc_assert (slot_num
!= (unsigned)-1);
2367 lto_output_data_stream (ref_stream
, &slot_num
, sizeof slot_num
);
2372 /* Write all the streams in an lto_out_decl_state STATE using
2373 output block OB and output stream OUT_STREAM. */
2376 lto_output_decl_state_streams (struct output_block
*ob
,
2377 struct lto_out_decl_state
*state
)
2381 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2382 write_global_stream (ob
, &state
->streams
[i
]);
2386 /* Write all the references in an lto_out_decl_state STATE using
2387 output block OB and output stream OUT_STREAM. */
2390 lto_output_decl_state_refs (struct output_block
*ob
,
2391 struct lto_output_stream
*out_stream
,
2392 struct lto_out_decl_state
*state
)
2398 /* Write reference to FUNCTION_DECL. If there is not function,
2399 write reference to void_type_node. */
2400 decl
= (state
->fn_decl
) ? state
->fn_decl
: void_type_node
;
2401 lto_streamer_cache_lookup (ob
->writer_cache
, decl
, &ref
);
2402 gcc_assert (ref
!= (unsigned)-1);
2403 lto_output_data_stream (out_stream
, &ref
, sizeof (uint32_t));
2405 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2406 write_global_references (ob
, out_stream
, &state
->streams
[i
]);
2410 /* Return the written size of STATE. */
2413 lto_out_decl_state_written_size (struct lto_out_decl_state
*state
)
2418 size
= sizeof (int32_t); /* fn_ref. */
2419 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2421 size
+= sizeof (int32_t); /* vector size. */
2422 size
+= (lto_tree_ref_encoder_size (&state
->streams
[i
])
2423 * sizeof (int32_t));
2429 /* Write symbol T into STREAM in CACHE. SEEN specifies symbols we wrote
2433 write_symbol (struct lto_streamer_cache_d
*cache
,
2434 struct lto_output_stream
*stream
,
2435 tree t
, struct pointer_set_t
*seen
, bool alias
)
2438 enum gcc_plugin_symbol_kind kind
;
2439 enum gcc_plugin_symbol_visibility visibility
;
2445 /* None of the following kinds of symbols are needed in the
2447 if (!TREE_PUBLIC (t
)
2448 || is_builtin_fn (t
)
2449 || DECL_ABSTRACT (t
)
2450 || TREE_CODE (t
) == RESULT_DECL
)
2453 gcc_assert (TREE_CODE (t
) == VAR_DECL
2454 || TREE_CODE (t
) == FUNCTION_DECL
);
2456 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (t
));
2458 /* This behaves like assemble_name_raw in varasm.c, performing the
2459 same name manipulations that ASM_OUTPUT_LABELREF does. */
2460 name
= IDENTIFIER_POINTER ((*targetm
.asm_out
.mangle_assembler_name
) (name
));
2462 if (pointer_set_contains (seen
, name
))
2464 pointer_set_insert (seen
, name
);
2466 lto_streamer_cache_lookup (cache
, t
, &slot_num
);
2467 gcc_assert (slot_num
!= (unsigned)-1);
2469 if (DECL_EXTERNAL (t
))
2472 kind
= GCCPK_WEAKUNDEF
;
2479 kind
= GCCPK_WEAKDEF
;
2480 else if (DECL_COMMON (t
))
2481 kind
= GCCPK_COMMON
;
2485 /* When something is defined, it should have node attached. */
2486 gcc_assert (alias
|| TREE_CODE (t
) != VAR_DECL
2487 || varpool_get_node (t
)->finalized
);
2488 gcc_assert (alias
|| TREE_CODE (t
) != FUNCTION_DECL
2489 || (cgraph_get_node (t
)
2490 && cgraph_get_node (t
)->analyzed
));
2493 /* Imitate what default_elf_asm_output_external do.
2494 When symbol is external, we need to output it with DEFAULT visibility
2495 when compiling with -fvisibility=default, while with HIDDEN visibility
2496 when symbol has attribute (visibility("hidden")) specified.
2497 targetm.binds_local_p check DECL_VISIBILITY_SPECIFIED and gets this
2500 if (DECL_EXTERNAL (t
)
2501 && !targetm
.binds_local_p (t
))
2502 visibility
= GCCPV_DEFAULT
;
2504 switch (DECL_VISIBILITY(t
))
2506 case VISIBILITY_DEFAULT
:
2507 visibility
= GCCPV_DEFAULT
;
2509 case VISIBILITY_PROTECTED
:
2510 visibility
= GCCPV_PROTECTED
;
2512 case VISIBILITY_HIDDEN
:
2513 visibility
= GCCPV_HIDDEN
;
2515 case VISIBILITY_INTERNAL
:
2516 visibility
= GCCPV_INTERNAL
;
2520 if (kind
== GCCPK_COMMON
2522 && TREE_CODE (DECL_SIZE (t
)) == INTEGER_CST
)
2524 size
= (HOST_BITS_PER_WIDE_INT
>= 64)
2525 ? (uint64_t) int_size_in_bytes (TREE_TYPE (t
))
2526 : (((uint64_t) TREE_INT_CST_HIGH (DECL_SIZE_UNIT (t
))) << 32)
2527 | TREE_INT_CST_LOW (DECL_SIZE_UNIT (t
));
2532 if (DECL_ONE_ONLY (t
))
2533 comdat
= IDENTIFIER_POINTER (DECL_COMDAT_GROUP (t
));
2537 lto_output_data_stream (stream
, name
, strlen (name
) + 1);
2538 lto_output_data_stream (stream
, comdat
, strlen (comdat
) + 1);
2539 c
= (unsigned char) kind
;
2540 lto_output_data_stream (stream
, &c
, 1);
2541 c
= (unsigned char) visibility
;
2542 lto_output_data_stream (stream
, &c
, 1);
2543 lto_output_data_stream (stream
, &size
, 8);
2544 lto_output_data_stream (stream
, &slot_num
, 4);
2548 /* Write an IL symbol table to OB.
2549 SET and VSET are cgraph/varpool node sets we are outputting. */
2552 produce_symtab (struct output_block
*ob
,
2553 cgraph_node_set set
, varpool_node_set vset
)
2555 struct lto_streamer_cache_d
*cache
= ob
->writer_cache
;
2556 char *section_name
= lto_get_section_name (LTO_section_symtab
, NULL
, NULL
);
2557 struct pointer_set_t
*seen
;
2558 struct cgraph_node
*node
, *alias
;
2559 struct varpool_node
*vnode
, *valias
;
2560 struct lto_output_stream stream
;
2561 lto_varpool_encoder_t varpool_encoder
= ob
->decl_state
->varpool_node_encoder
;
2562 lto_cgraph_encoder_t encoder
= ob
->decl_state
->cgraph_node_encoder
;
2565 struct sets setdata
;
2566 symbol_alias_set_t
*defined
;
2569 setdata
.vset
= vset
;
2571 lto_begin_section (section_name
, false);
2572 free (section_name
);
2574 seen
= pointer_set_create ();
2575 memset (&stream
, 0, sizeof (stream
));
2577 /* Write all functions.
2578 First write all defined functions and then write all used functions.
2579 This is done so only to handle duplicated symbols in cgraph. */
2580 for (i
= 0; i
< lto_cgraph_encoder_size (encoder
); i
++)
2582 node
= lto_cgraph_encoder_deref (encoder
, i
);
2583 if (DECL_EXTERNAL (node
->decl
))
2585 if (DECL_COMDAT (node
->decl
)
2586 && cgraph_comdat_can_be_unshared_p (node
))
2588 if (node
->alias
|| node
->global
.inlined_to
)
2590 write_symbol (cache
, &stream
, node
->decl
, seen
, false);
2591 for (alias
= node
->same_body
; alias
; alias
= alias
->next
)
2592 write_symbol (cache
, &stream
, alias
->decl
, seen
, true);
2594 for (i
= 0; i
< lto_cgraph_encoder_size (encoder
); i
++)
2596 node
= lto_cgraph_encoder_deref (encoder
, i
);
2597 if (!DECL_EXTERNAL (node
->decl
))
2599 if (DECL_COMDAT (node
->decl
)
2600 && cgraph_comdat_can_be_unshared_p (node
))
2602 if (node
->alias
|| node
->global
.inlined_to
)
2604 write_symbol (cache
, &stream
, node
->decl
, seen
, false);
2605 for (alias
= node
->same_body
; alias
; alias
= alias
->next
)
2606 write_symbol (cache
, &stream
, alias
->decl
, seen
, true);
2609 /* Write all variables. */
2610 for (i
= 0; i
< lto_varpool_encoder_size (varpool_encoder
); i
++)
2612 vnode
= lto_varpool_encoder_deref (varpool_encoder
, i
);
2613 if (DECL_EXTERNAL (vnode
->decl
))
2615 /* COMDAT virtual tables can be unshared. Do not declare them
2616 in the LTO symbol table to prevent linker from forcing them
2618 if (DECL_COMDAT (vnode
->decl
)
2619 && !vnode
->force_output
2621 && DECL_VIRTUAL_P (vnode
->decl
))
2625 write_symbol (cache
, &stream
, vnode
->decl
, seen
, false);
2626 for (valias
= vnode
->extra_name
; valias
; valias
= valias
->next
)
2627 write_symbol (cache
, &stream
, valias
->decl
, seen
, true);
2629 for (i
= 0; i
< lto_varpool_encoder_size (varpool_encoder
); i
++)
2631 vnode
= lto_varpool_encoder_deref (varpool_encoder
, i
);
2632 if (!DECL_EXTERNAL (vnode
->decl
))
2634 if (DECL_COMDAT (vnode
->decl
)
2635 && !vnode
->force_output
2637 && DECL_VIRTUAL_P (vnode
->decl
))
2641 write_symbol (cache
, &stream
, vnode
->decl
, seen
, false);
2642 for (valias
= vnode
->extra_name
; valias
; valias
= valias
->next
)
2643 write_symbol (cache
, &stream
, valias
->decl
, seen
, true);
2646 /* Write all aliases. */
2647 defined
= propagate_aliases_backward (trivally_defined_alias
, &setdata
);
2648 FOR_EACH_VEC_ELT (alias_pair
, alias_pairs
, i
, p
)
2649 if (output_alias_pair_p (p
, defined
, set
, vset
))
2650 write_symbol (cache
, &stream
, p
->decl
, seen
, true);
2651 symbol_alias_set_destroy (defined
);
2653 lto_write_stream (&stream
);
2654 pointer_set_destroy (seen
);
2660 /* This pass is run after all of the functions are serialized and all
2661 of the IPA passes have written their serialized forms. This pass
2662 causes the vector of all of the global decls and types used from
2663 this file to be written in to a section that can then be read in to
2664 recover these on other side. */
2667 produce_asm_for_decls (cgraph_node_set set
, varpool_node_set vset
)
2669 struct lto_out_decl_state
*out_state
;
2670 struct lto_out_decl_state
*fn_out_state
;
2671 struct lto_decl_header header
;
2673 struct output_block
*ob
;
2674 struct lto_output_stream
*header_stream
, *decl_state_stream
;
2675 unsigned idx
, num_fns
;
2676 size_t decl_state_size
;
2677 int32_t num_decl_states
;
2679 ob
= create_output_block (LTO_section_decls
);
2682 /* Write out unreferenced globals, alias pairs and labels. We defer
2683 doing this until now so that we can write out only what is
2685 output_unreferenced_globals (set
, vset
);
2687 memset (&header
, 0, sizeof (struct lto_decl_header
));
2689 section_name
= lto_get_section_name (LTO_section_decls
, NULL
, NULL
);
2690 lto_begin_section (section_name
, !flag_wpa
);
2691 free (section_name
);
2693 /* Make string 0 be a NULL string. */
2694 lto_output_1_stream (ob
->string_stream
, 0);
2696 /* Write the global symbols. */
2697 out_state
= lto_get_out_decl_state ();
2698 num_fns
= VEC_length (lto_out_decl_state_ptr
, lto_function_decl_states
);
2699 lto_output_decl_state_streams (ob
, out_state
);
2700 for (idx
= 0; idx
< num_fns
; idx
++)
2703 VEC_index (lto_out_decl_state_ptr
, lto_function_decl_states
, idx
);
2704 lto_output_decl_state_streams (ob
, fn_out_state
);
2707 header
.lto_header
.major_version
= LTO_major_version
;
2708 header
.lto_header
.minor_version
= LTO_minor_version
;
2709 header
.lto_header
.section_type
= LTO_section_decls
;
2711 /* Currently not used. This field would allow us to preallocate
2712 the globals vector, so that it need not be resized as it is extended. */
2713 header
.num_nodes
= -1;
2715 /* Compute the total size of all decl out states. */
2716 decl_state_size
= sizeof (int32_t);
2717 decl_state_size
+= lto_out_decl_state_written_size (out_state
);
2718 for (idx
= 0; idx
< num_fns
; idx
++)
2721 VEC_index (lto_out_decl_state_ptr
, lto_function_decl_states
, idx
);
2722 decl_state_size
+= lto_out_decl_state_written_size (fn_out_state
);
2724 header
.decl_state_size
= decl_state_size
;
2726 header
.main_size
= ob
->main_stream
->total_size
;
2727 header
.string_size
= ob
->string_stream
->total_size
;
2729 header_stream
= XCNEW (struct lto_output_stream
);
2730 lto_output_data_stream (header_stream
, &header
, sizeof header
);
2731 lto_write_stream (header_stream
);
2732 free (header_stream
);
2734 /* Write the main out-decl state, followed by out-decl states of
2736 decl_state_stream
= ((struct lto_output_stream
*)
2737 xcalloc (1, sizeof (struct lto_output_stream
)));
2738 num_decl_states
= num_fns
+ 1;
2739 lto_output_data_stream (decl_state_stream
, &num_decl_states
,
2740 sizeof (num_decl_states
));
2741 lto_output_decl_state_refs (ob
, decl_state_stream
, out_state
);
2742 for (idx
= 0; idx
< num_fns
; idx
++)
2745 VEC_index (lto_out_decl_state_ptr
, lto_function_decl_states
, idx
);
2746 lto_output_decl_state_refs (ob
, decl_state_stream
, fn_out_state
);
2748 lto_write_stream (decl_state_stream
);
2749 free(decl_state_stream
);
2751 lto_write_stream (ob
->main_stream
);
2752 lto_write_stream (ob
->string_stream
);
2756 /* Write the symbol table. It is used by linker to determine dependencies
2757 and thus we can skip it for WPA. */
2759 produce_symtab (ob
, set
, vset
);
2761 /* Write command line opts. */
2762 lto_write_options ();
2764 /* Deallocate memory and clean up. */
2765 for (idx
= 0; idx
< num_fns
; idx
++)
2768 VEC_index (lto_out_decl_state_ptr
, lto_function_decl_states
, idx
);
2769 lto_delete_out_decl_state (fn_out_state
);
2771 lto_cgraph_encoder_delete (ob
->decl_state
->cgraph_node_encoder
);
2772 lto_varpool_encoder_delete (ob
->decl_state
->varpool_node_encoder
);
2773 VEC_free (lto_out_decl_state_ptr
, heap
, lto_function_decl_states
);
2774 lto_function_decl_states
= NULL
;
2775 destroy_output_block (ob
);
2779 struct ipa_opt_pass_d pass_ipa_lto_finish_out
=
2783 "lto_decls_out", /* name */
2784 gate_lto_out
, /* gate */
2788 0, /* static_pass_number */
2789 TV_IPA_LTO_DECL_OUT
, /* tv_id */
2790 0, /* properties_required */
2791 0, /* properties_provided */
2792 0, /* properties_destroyed */
2793 0, /* todo_flags_start */
2794 0 /* todo_flags_finish */
2796 NULL
, /* generate_summary */
2797 produce_asm_for_decls
, /* write_summary */
2798 NULL
, /* read_summary */
2799 produce_asm_for_decls
, /* write_optimization_summary */
2800 NULL
, /* read_optimization_summary */
2801 NULL
, /* stmt_fixup */
2803 NULL
, /* function_transform */
2804 NULL
/* variable_transform */