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"
34 #include "basic-block.h"
35 #include "tree-flow.h"
36 #include "tree-pass.h"
40 #include "diagnostic-core.h"
43 #include "lto-symtab.h"
44 #include "lto-streamer.h"
51 unsigned int slot_num
;
55 /* Returns a hash code for P. */
58 hash_string_slot_node (const void *p
)
60 const struct string_slot
*ds
= (const struct string_slot
*) p
;
61 return (hashval_t
) htab_hash_string (ds
->s
);
65 /* Returns nonzero if P1 and P2 are equal. */
68 eq_string_slot_node (const void *p1
, const void *p2
)
70 const struct string_slot
*ds1
= (const struct string_slot
*) p1
;
71 const struct string_slot
*ds2
= (const struct string_slot
*) p2
;
73 if (ds1
->len
== ds2
->len
)
76 for (i
= 0; i
< ds1
->len
; i
++)
77 if (ds1
->s
[i
] != ds2
->s
[i
])
86 /* Free the string slot pointed-to by P. */
89 string_slot_free (void *p
)
91 struct string_slot
*slot
= (struct string_slot
*) p
;
92 free (CONST_CAST (void *, (const void *) slot
->s
));
97 /* Clear the line info stored in DATA_IN. */
100 clear_line_info (struct output_block
*ob
)
102 ob
->current_file
= NULL
;
103 ob
->current_line
= 0;
108 /* Create the output block and return it. SECTION_TYPE is
109 LTO_section_function_body or LTO_static_initializer. */
111 struct output_block
*
112 create_output_block (enum lto_section_type section_type
)
114 struct output_block
*ob
= XCNEW (struct output_block
);
116 ob
->section_type
= section_type
;
117 ob
->decl_state
= lto_get_out_decl_state ();
118 ob
->main_stream
= XCNEW (struct lto_output_stream
);
119 ob
->string_stream
= XCNEW (struct lto_output_stream
);
120 ob
->writer_cache
= lto_streamer_cache_create ();
122 if (section_type
== LTO_section_function_body
)
123 ob
->cfg_stream
= XCNEW (struct lto_output_stream
);
125 clear_line_info (ob
);
127 ob
->string_hash_table
= htab_create (37, hash_string_slot_node
,
128 eq_string_slot_node
, string_slot_free
);
134 /* Destroy the output block OB. */
137 destroy_output_block (struct output_block
*ob
)
139 enum lto_section_type section_type
= ob
->section_type
;
141 htab_delete (ob
->string_hash_table
);
143 free (ob
->main_stream
);
144 free (ob
->string_stream
);
145 if (section_type
== LTO_section_function_body
)
146 free (ob
->cfg_stream
);
148 lto_streamer_cache_delete (ob
->writer_cache
);
154 /* Output STRING of LEN characters to the string
155 table in OB. The string might or might not include a trailing '\0'.
156 Then put the index onto the INDEX_STREAM. */
159 output_string_with_length (struct output_block
*ob
,
160 struct lto_output_stream
*index_stream
,
164 struct string_slot
**slot
;
165 struct string_slot s_slot
;
166 char *string
= (char *) xmalloc (len
+ 1);
167 memcpy (string
, s
, len
);
174 slot
= (struct string_slot
**) htab_find_slot (ob
->string_hash_table
,
178 struct lto_output_stream
*string_stream
= ob
->string_stream
;
179 unsigned int start
= string_stream
->total_size
;
180 struct string_slot
*new_slot
181 = (struct string_slot
*) xmalloc (sizeof (struct string_slot
));
184 new_slot
->s
= string
;
186 new_slot
->slot_num
= start
;
188 lto_output_uleb128_stream (index_stream
, start
);
189 lto_output_uleb128_stream (string_stream
, len
);
190 for (i
= 0; i
< len
; i
++)
191 lto_output_1_stream (string_stream
, string
[i
]);
195 struct string_slot
*old_slot
= (struct string_slot
*)*slot
;
196 lto_output_uleb128_stream (index_stream
, old_slot
->slot_num
);
201 /* Output the '\0' terminated STRING to the string
202 table in OB. Then put the index onto the INDEX_STREAM. */
205 output_string (struct output_block
*ob
,
206 struct lto_output_stream
*index_stream
,
211 lto_output_uleb128_stream (index_stream
, 0);
212 output_string_with_length (ob
, index_stream
, string
, strlen (string
) + 1);
215 lto_output_uleb128_stream (index_stream
, 1);
219 /* Output the STRING constant to the string
220 table in OB. Then put the index onto the INDEX_STREAM. */
223 output_string_cst (struct output_block
*ob
,
224 struct lto_output_stream
*index_stream
,
229 lto_output_uleb128_stream (index_stream
, 0);
230 output_string_with_length (ob
, index_stream
,
231 TREE_STRING_POINTER (string
),
232 TREE_STRING_LENGTH (string
));
235 lto_output_uleb128_stream (index_stream
, 1);
239 /* Output the identifier ID to the string
240 table in OB. Then put the index onto the INDEX_STREAM. */
243 output_identifier (struct output_block
*ob
,
244 struct lto_output_stream
*index_stream
,
249 lto_output_uleb128_stream (index_stream
, 0);
250 output_string_with_length (ob
, index_stream
,
251 IDENTIFIER_POINTER (id
),
252 IDENTIFIER_LENGTH (id
));
255 lto_output_uleb128_stream (index_stream
, 1);
258 /* Write a zero to the output stream. */
261 output_zero (struct output_block
*ob
)
263 lto_output_1_stream (ob
->main_stream
, 0);
267 /* Output an unsigned LEB128 quantity to OB->main_stream. */
270 output_uleb128 (struct output_block
*ob
, unsigned HOST_WIDE_INT work
)
272 lto_output_uleb128_stream (ob
->main_stream
, work
);
276 /* Output a signed LEB128 quantity to OB->main_stream. */
279 output_sleb128 (struct output_block
*ob
, HOST_WIDE_INT work
)
281 lto_output_sleb128_stream (ob
->main_stream
, work
);
285 /* Output the start of a record with TAG to output block OB. */
288 output_record_start (struct output_block
*ob
, enum LTO_tags tag
)
290 /* Make sure TAG fits inside an unsigned int. */
291 gcc_assert (tag
== (enum LTO_tags
) (unsigned) tag
);
292 output_uleb128 (ob
, tag
);
296 /* Look up NODE in the type table and write the index for it to OB. */
299 output_type_ref (struct output_block
*ob
, tree node
)
301 output_record_start (ob
, LTO_type_ref
);
302 lto_output_type_ref_index (ob
->decl_state
, ob
->main_stream
, node
);
306 /* Pack all the non-pointer fields of the TS_BASE structure of
307 expression EXPR into bitpack BP. */
310 pack_ts_base_value_fields (struct bitpack_d
*bp
, tree expr
)
312 bp_pack_value (bp
, TREE_CODE (expr
), 16);
315 bp_pack_value (bp
, TREE_SIDE_EFFECTS (expr
), 1);
316 bp_pack_value (bp
, TREE_CONSTANT (expr
), 1);
317 bp_pack_value (bp
, TREE_READONLY (expr
), 1);
319 /* TREE_PUBLIC is used on types to indicate that the type
320 has a TYPE_CACHED_VALUES vector. This is not streamed out,
321 so we skip it here. */
322 bp_pack_value (bp
, TREE_PUBLIC (expr
), 1);
325 bp_pack_value (bp
, 0, 4);
326 bp_pack_value (bp
, TREE_ADDRESSABLE (expr
), 1);
327 bp_pack_value (bp
, TREE_THIS_VOLATILE (expr
), 1);
329 bp_pack_value (bp
, DECL_UNSIGNED (expr
), 1);
330 else if (TYPE_P (expr
))
331 bp_pack_value (bp
, TYPE_UNSIGNED (expr
), 1);
333 bp_pack_value (bp
, 0, 1);
334 /* We write debug info two times, do not confuse the second one. */
335 bp_pack_value (bp
, TYPE_P (expr
) ? 0 : TREE_ASM_WRITTEN (expr
), 1);
336 bp_pack_value (bp
, TREE_NO_WARNING (expr
), 1);
337 bp_pack_value (bp
, TREE_USED (expr
), 1);
338 bp_pack_value (bp
, TREE_NOTHROW (expr
), 1);
339 bp_pack_value (bp
, TREE_STATIC (expr
), 1);
340 bp_pack_value (bp
, TREE_PRIVATE (expr
), 1);
341 bp_pack_value (bp
, TREE_PROTECTED (expr
), 1);
342 bp_pack_value (bp
, TREE_DEPRECATED (expr
), 1);
344 bp_pack_value (bp
, TYPE_SATURATING (expr
), 1);
345 else if (TREE_CODE (expr
) == SSA_NAME
)
346 bp_pack_value (bp
, SSA_NAME_IS_DEFAULT_DEF (expr
), 1);
348 bp_pack_value (bp
, 0, 1);
352 /* Pack all the non-pointer fields of the TS_REAL_CST structure of
353 expression EXPR into bitpack BP. */
356 pack_ts_real_cst_value_fields (struct bitpack_d
*bp
, tree expr
)
361 r
= TREE_REAL_CST (expr
);
362 bp_pack_value (bp
, r
.cl
, 2);
363 bp_pack_value (bp
, r
.decimal
, 1);
364 bp_pack_value (bp
, r
.sign
, 1);
365 bp_pack_value (bp
, r
.signalling
, 1);
366 bp_pack_value (bp
, r
.canonical
, 1);
367 bp_pack_value (bp
, r
.uexp
, EXP_BITS
);
368 for (i
= 0; i
< SIGSZ
; i
++)
369 bp_pack_value (bp
, r
.sig
[i
], HOST_BITS_PER_LONG
);
373 /* Pack all the non-pointer fields of the TS_FIXED_CST structure of
374 expression EXPR into bitpack BP. */
377 pack_ts_fixed_cst_value_fields (struct bitpack_d
*bp
, tree expr
)
379 struct fixed_value fv
= TREE_FIXED_CST (expr
);
380 bp_pack_value (bp
, fv
.data
.low
, HOST_BITS_PER_WIDE_INT
);
381 bp_pack_value (bp
, fv
.data
.high
, HOST_BITS_PER_WIDE_INT
);
382 bp_pack_value (bp
, fv
.mode
, HOST_BITS_PER_INT
);
386 /* Pack all the non-pointer fields of the TS_DECL_COMMON structure
387 of expression EXPR into bitpack BP. */
390 pack_ts_decl_common_value_fields (struct bitpack_d
*bp
, tree expr
)
392 bp_pack_value (bp
, DECL_MODE (expr
), 8);
393 bp_pack_value (bp
, DECL_NONLOCAL (expr
), 1);
394 bp_pack_value (bp
, DECL_VIRTUAL_P (expr
), 1);
395 bp_pack_value (bp
, DECL_IGNORED_P (expr
), 1);
396 bp_pack_value (bp
, DECL_ABSTRACT (expr
), 1);
397 bp_pack_value (bp
, DECL_ARTIFICIAL (expr
), 1);
398 bp_pack_value (bp
, DECL_USER_ALIGN (expr
), 1);
399 bp_pack_value (bp
, DECL_PRESERVE_P (expr
), 1);
400 bp_pack_value (bp
, DECL_DEBUG_EXPR_IS_FROM (expr
), 1);
401 bp_pack_value (bp
, DECL_EXTERNAL (expr
), 1);
402 bp_pack_value (bp
, DECL_GIMPLE_REG_P (expr
), 1);
403 bp_pack_value (bp
, DECL_ALIGN (expr
), HOST_BITS_PER_INT
);
405 if (TREE_CODE (expr
) == LABEL_DECL
)
407 /* Note that we do not write LABEL_DECL_UID. The reader will
408 always assume an initial value of -1 so that the
409 label_to_block_map is recreated by gimple_set_bb. */
410 bp_pack_value (bp
, DECL_ERROR_ISSUED (expr
), 1);
411 bp_pack_value (bp
, EH_LANDING_PAD_NR (expr
), HOST_BITS_PER_INT
);
414 if (TREE_CODE (expr
) == FIELD_DECL
)
416 bp_pack_value (bp
, DECL_PACKED (expr
), 1);
417 bp_pack_value (bp
, DECL_NONADDRESSABLE_P (expr
), 1);
418 bp_pack_value (bp
, DECL_OFFSET_ALIGN (expr
), 8);
421 if (TREE_CODE (expr
) == RESULT_DECL
422 || TREE_CODE (expr
) == PARM_DECL
423 || TREE_CODE (expr
) == VAR_DECL
)
425 bp_pack_value (bp
, DECL_BY_REFERENCE (expr
), 1);
426 if (TREE_CODE (expr
) == VAR_DECL
427 || TREE_CODE (expr
) == PARM_DECL
)
428 bp_pack_value (bp
, DECL_HAS_VALUE_EXPR_P (expr
), 1);
429 bp_pack_value (bp
, DECL_RESTRICTED_P (expr
), 1);
434 /* Pack all the non-pointer fields of the TS_DECL_WRTL structure
435 of expression EXPR into bitpack BP. */
438 pack_ts_decl_wrtl_value_fields (struct bitpack_d
*bp
, tree expr
)
440 bp_pack_value (bp
, DECL_REGISTER (expr
), 1);
444 /* Pack all the non-pointer fields of the TS_DECL_WITH_VIS structure
445 of expression EXPR into bitpack BP. */
448 pack_ts_decl_with_vis_value_fields (struct bitpack_d
*bp
, tree expr
)
450 bp_pack_value (bp
, DECL_DEFER_OUTPUT (expr
), 1);
451 bp_pack_value (bp
, DECL_COMMON (expr
), 1);
452 bp_pack_value (bp
, DECL_DLLIMPORT_P (expr
), 1);
453 bp_pack_value (bp
, DECL_WEAK (expr
), 1);
454 bp_pack_value (bp
, DECL_SEEN_IN_BIND_EXPR_P (expr
), 1);
455 bp_pack_value (bp
, DECL_COMDAT (expr
), 1);
456 bp_pack_value (bp
, DECL_VISIBILITY (expr
), 2);
457 bp_pack_value (bp
, DECL_VISIBILITY_SPECIFIED (expr
), 1);
459 if (TREE_CODE (expr
) == VAR_DECL
)
461 bp_pack_value (bp
, DECL_HARD_REGISTER (expr
), 1);
462 bp_pack_value (bp
, DECL_IN_TEXT_SECTION (expr
), 1);
463 bp_pack_value (bp
, DECL_IN_CONSTANT_POOL (expr
), 1);
464 bp_pack_value (bp
, DECL_TLS_MODEL (expr
), 3);
467 if (VAR_OR_FUNCTION_DECL_P (expr
))
468 bp_pack_value (bp
, DECL_INIT_PRIORITY (expr
), HOST_BITS_PER_SHORT
);
472 /* Pack all the non-pointer fields of the TS_FUNCTION_DECL structure
473 of expression EXPR into bitpack BP. */
476 pack_ts_function_decl_value_fields (struct bitpack_d
*bp
, tree expr
)
478 /* For normal/md builtins we only write the class and code, so they
479 should never be handled here. */
480 gcc_assert (!lto_stream_as_builtin_p (expr
));
482 bp_pack_value (bp
, DECL_FUNCTION_CODE (expr
), 11);
483 bp_pack_value (bp
, DECL_BUILT_IN_CLASS (expr
), 2);
484 bp_pack_value (bp
, DECL_STATIC_CONSTRUCTOR (expr
), 1);
485 bp_pack_value (bp
, DECL_STATIC_DESTRUCTOR (expr
), 1);
486 bp_pack_value (bp
, DECL_UNINLINABLE (expr
), 1);
487 bp_pack_value (bp
, DECL_POSSIBLY_INLINED (expr
), 1);
488 bp_pack_value (bp
, DECL_IS_NOVOPS (expr
), 1);
489 bp_pack_value (bp
, DECL_IS_RETURNS_TWICE (expr
), 1);
490 bp_pack_value (bp
, DECL_IS_MALLOC (expr
), 1);
491 bp_pack_value (bp
, DECL_IS_OPERATOR_NEW (expr
), 1);
492 bp_pack_value (bp
, DECL_DECLARED_INLINE_P (expr
), 1);
493 bp_pack_value (bp
, DECL_STATIC_CHAIN (expr
), 1);
494 bp_pack_value (bp
, DECL_NO_INLINE_WARNING_P (expr
), 1);
495 bp_pack_value (bp
, DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (expr
), 1);
496 bp_pack_value (bp
, DECL_NO_LIMIT_STACK (expr
), 1);
497 bp_pack_value (bp
, DECL_DISREGARD_INLINE_LIMITS (expr
), 1);
498 bp_pack_value (bp
, DECL_PURE_P (expr
), 1);
499 bp_pack_value (bp
, DECL_LOOPING_CONST_OR_PURE_P (expr
), 1);
503 /* Pack all the non-pointer fields of the TS_TYPE structure
504 of expression EXPR into bitpack BP. */
507 pack_ts_type_value_fields (struct bitpack_d
*bp
, tree expr
)
509 bp_pack_value (bp
, TYPE_PRECISION (expr
), 10);
510 bp_pack_value (bp
, TYPE_MODE (expr
), 8);
511 bp_pack_value (bp
, TYPE_STRING_FLAG (expr
), 1);
512 bp_pack_value (bp
, TYPE_NO_FORCE_BLK (expr
), 1);
513 bp_pack_value (bp
, TYPE_NEEDS_CONSTRUCTING (expr
), 1);
514 if (RECORD_OR_UNION_TYPE_P (expr
))
515 bp_pack_value (bp
, TYPE_TRANSPARENT_AGGR (expr
), 1);
516 bp_pack_value (bp
, TYPE_PACKED (expr
), 1);
517 bp_pack_value (bp
, TYPE_RESTRICT (expr
), 1);
518 bp_pack_value (bp
, TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr
), 2);
519 bp_pack_value (bp
, TYPE_USER_ALIGN (expr
), 1);
520 bp_pack_value (bp
, TYPE_READONLY (expr
), 1);
521 bp_pack_value (bp
, TYPE_ALIGN (expr
), HOST_BITS_PER_INT
);
522 bp_pack_value (bp
, TYPE_ALIAS_SET (expr
) == 0 ? 0 : -1, HOST_BITS_PER_INT
);
526 /* Pack all the non-pointer fields of the TS_BLOCK structure
527 of expression EXPR into bitpack BP. */
530 pack_ts_block_value_fields (struct bitpack_d
*bp
, tree expr
)
532 bp_pack_value (bp
, BLOCK_ABSTRACT (expr
), 1);
533 bp_pack_value (bp
, BLOCK_NUMBER (expr
), 31);
536 /* Pack all the non-pointer fields of the TS_TRANSLATION_UNIT_DECL structure
537 of expression EXPR into bitpack BP. */
540 pack_ts_translation_unit_decl_value_fields (struct bitpack_d
*bp ATTRIBUTE_UNUSED
, tree expr ATTRIBUTE_UNUSED
)
544 /* Pack all the non-pointer fields in EXPR into a bit pack. */
547 pack_value_fields (struct bitpack_d
*bp
, tree expr
)
551 code
= TREE_CODE (expr
);
553 /* Note that all these functions are highly sensitive to changes in
554 the types and sizes of each of the fields being packed. */
555 pack_ts_base_value_fields (bp
, expr
);
557 if (CODE_CONTAINS_STRUCT (code
, TS_REAL_CST
))
558 pack_ts_real_cst_value_fields (bp
, expr
);
560 if (CODE_CONTAINS_STRUCT (code
, TS_FIXED_CST
))
561 pack_ts_fixed_cst_value_fields (bp
, expr
);
563 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
564 pack_ts_decl_common_value_fields (bp
, expr
);
566 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WRTL
))
567 pack_ts_decl_wrtl_value_fields (bp
, expr
);
569 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
570 pack_ts_decl_with_vis_value_fields (bp
, expr
);
572 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
573 pack_ts_function_decl_value_fields (bp
, expr
);
575 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE
))
576 pack_ts_type_value_fields (bp
, expr
);
578 if (CODE_CONTAINS_STRUCT (code
, TS_BLOCK
))
579 pack_ts_block_value_fields (bp
, expr
);
581 if (CODE_CONTAINS_STRUCT (code
, TS_SSA_NAME
))
583 /* We only stream the version number of SSA names. */
587 if (CODE_CONTAINS_STRUCT (code
, TS_STATEMENT_LIST
))
589 /* This is only used by GENERIC. */
593 if (CODE_CONTAINS_STRUCT (code
, TS_OMP_CLAUSE
))
595 /* This is only used by High GIMPLE. */
599 if (CODE_CONTAINS_STRUCT (code
, TS_TRANSLATION_UNIT_DECL
))
600 pack_ts_translation_unit_decl_value_fields (bp
, expr
);
604 /* Emit location LOC to output block OB. */
607 lto_output_location (struct output_block
*ob
, location_t loc
)
609 expanded_location xloc
;
611 if (loc
== UNKNOWN_LOCATION
)
613 output_string (ob
, ob
->main_stream
, NULL
);
617 xloc
= expand_location (loc
);
619 output_string (ob
, ob
->main_stream
, xloc
.file
);
620 output_sleb128 (ob
, xloc
.line
);
621 output_sleb128 (ob
, xloc
.column
);
622 output_sleb128 (ob
, xloc
.sysp
);
624 ob
->current_file
= xloc
.file
;
625 ob
->current_line
= xloc
.line
;
626 ob
->current_col
= xloc
.column
;
630 /* Return true if tree node T is written to various tables. For these
631 nodes, we sometimes want to write their phyiscal representation
632 (via lto_output_tree), and sometimes we need to emit an index
633 reference into a table (via lto_output_tree_ref). */
636 tree_is_indexable (tree t
)
638 if (TREE_CODE (t
) == PARM_DECL
)
640 else if (TREE_CODE (t
) == VAR_DECL
&& decl_function_context (t
)
644 return (TYPE_P (t
) || DECL_P (t
) || TREE_CODE (t
) == SSA_NAME
);
648 /* If EXPR is an indexable tree node, output a reference to it to
649 output block OB. Otherwise, output the physical representation of
653 lto_output_tree_ref (struct output_block
*ob
, tree expr
)
657 if (expr
== NULL_TREE
)
663 if (!tree_is_indexable (expr
))
665 /* Even though we are emitting the physical representation of
666 EXPR, its leaves must be emitted as references. */
667 lto_output_tree (ob
, expr
, true);
673 output_type_ref (ob
, expr
);
677 code
= TREE_CODE (expr
);
681 output_record_start (ob
, LTO_ssa_name_ref
);
682 output_uleb128 (ob
, SSA_NAME_VERSION (expr
));
686 output_record_start (ob
, LTO_field_decl_ref
);
687 lto_output_field_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
691 output_record_start (ob
, LTO_function_decl_ref
);
692 lto_output_fn_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
696 case DEBUG_EXPR_DECL
:
697 gcc_assert (decl_function_context (expr
) == NULL
698 || TREE_STATIC (expr
));
699 output_record_start (ob
, LTO_global_decl_ref
);
700 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
704 output_record_start (ob
, LTO_const_decl_ref
);
705 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
709 gcc_assert (decl_function_context (expr
) == NULL
);
710 output_record_start (ob
, LTO_imported_decl_ref
);
711 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
715 output_record_start (ob
, LTO_type_decl_ref
);
716 lto_output_type_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
720 output_record_start (ob
, LTO_namespace_decl_ref
);
721 lto_output_namespace_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
725 output_record_start (ob
, LTO_label_decl_ref
);
726 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
730 output_record_start (ob
, LTO_result_decl_ref
);
731 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
734 case TRANSLATION_UNIT_DECL
:
735 output_record_start (ob
, LTO_translation_unit_decl_ref
);
736 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
740 /* No other node is indexable, so it should have been handled
741 by lto_output_tree. */
747 /* If REF_P is true, emit a reference to EXPR in output block OB,
748 otherwise emit the physical representation of EXPR in OB. */
751 lto_output_tree_or_ref (struct output_block
*ob
, tree expr
, bool ref_p
)
754 lto_output_tree_ref (ob
, expr
);
756 lto_output_tree (ob
, expr
, false);
760 /* Emit the chain of tree nodes starting at T. OB is the output block
761 to write to. REF_P is true if chain elements should be emitted
765 lto_output_chain (struct output_block
*ob
, tree t
, bool ref_p
)
769 count
= list_length (t
);
770 output_sleb128 (ob
, count
);
771 for (i
= 0; i
< count
; i
++)
775 /* Clear TREE_CHAIN to avoid blindly recursing into the rest
777 saved_chain
= TREE_CHAIN (t
);
778 TREE_CHAIN (t
) = NULL_TREE
;
780 lto_output_tree_or_ref (ob
, t
, ref_p
);
782 TREE_CHAIN (t
) = saved_chain
;
788 /* Write all pointer fields in the TS_COMMON structure of EXPR to output
789 block OB. If REF_P is true, write a reference to EXPR's pointer
793 lto_output_ts_common_tree_pointers (struct output_block
*ob
, tree expr
,
796 lto_output_tree_or_ref (ob
, TREE_TYPE (expr
), ref_p
);
800 /* Write all pointer fields in the TS_VECTOR structure of EXPR to output
801 block OB. If REF_P is true, write a reference to EXPR's pointer
805 lto_output_ts_vector_tree_pointers (struct output_block
*ob
, tree expr
,
808 lto_output_chain (ob
, TREE_VECTOR_CST_ELTS (expr
), ref_p
);
812 /* Write all pointer fields in the TS_COMPLEX structure of EXPR to output
813 block OB. If REF_P is true, write a reference to EXPR's pointer
817 lto_output_ts_complex_tree_pointers (struct output_block
*ob
, tree expr
,
820 lto_output_tree_or_ref (ob
, TREE_REALPART (expr
), ref_p
);
821 lto_output_tree_or_ref (ob
, TREE_IMAGPART (expr
), ref_p
);
825 /* Write all pointer fields in the TS_DECL_MINIMAL structure of EXPR
826 to output block OB. If REF_P is true, write a reference to EXPR's
830 lto_output_ts_decl_minimal_tree_pointers (struct output_block
*ob
, tree expr
,
833 lto_output_tree_or_ref (ob
, DECL_NAME (expr
), ref_p
);
834 lto_output_tree_or_ref (ob
, DECL_CONTEXT (expr
), ref_p
);
835 lto_output_location (ob
, DECL_SOURCE_LOCATION (expr
));
839 /* Write all pointer fields in the TS_DECL_COMMON structure of EXPR to
840 output block OB. If REF_P is true, write a reference to EXPR's
844 lto_output_ts_decl_common_tree_pointers (struct output_block
*ob
, tree expr
,
847 lto_output_tree_or_ref (ob
, DECL_SIZE (expr
), ref_p
);
848 lto_output_tree_or_ref (ob
, DECL_SIZE_UNIT (expr
), ref_p
);
850 if (TREE_CODE (expr
) != FUNCTION_DECL
)
852 tree initial
= DECL_INITIAL (expr
);
853 if (TREE_CODE (expr
) == VAR_DECL
854 && (TREE_STATIC (expr
) || DECL_EXTERNAL (expr
))
857 lto_varpool_encoder_t varpool_encoder
= ob
->decl_state
->varpool_node_encoder
;
858 struct varpool_node
*vnode
= varpool_get_node (expr
);
860 initial
= error_mark_node
;
861 else if (!lto_varpool_encoder_encode_initializer_p (varpool_encoder
,
866 lto_output_tree_or_ref (ob
, initial
, ref_p
);
869 lto_output_tree_or_ref (ob
, DECL_ATTRIBUTES (expr
), ref_p
);
870 lto_output_tree_or_ref (ob
, DECL_ABSTRACT_ORIGIN (expr
), ref_p
);
872 if (TREE_CODE (expr
) == PARM_DECL
)
873 lto_output_chain (ob
, TREE_CHAIN (expr
), ref_p
);
875 if ((TREE_CODE (expr
) == VAR_DECL
876 || TREE_CODE (expr
) == PARM_DECL
)
877 && DECL_HAS_VALUE_EXPR_P (expr
))
878 lto_output_tree_or_ref (ob
, DECL_VALUE_EXPR (expr
), ref_p
);
880 if (TREE_CODE (expr
) == VAR_DECL
)
881 lto_output_tree_or_ref (ob
, DECL_DEBUG_EXPR (expr
), ref_p
);
885 /* Write all pointer fields in the TS_DECL_NON_COMMON structure of
886 EXPR to output block OB. If REF_P is true, write a reference to EXPR's
890 lto_output_ts_decl_non_common_tree_pointers (struct output_block
*ob
,
891 tree expr
, bool ref_p
)
893 if (TREE_CODE (expr
) == FUNCTION_DECL
)
895 /* DECL_SAVED_TREE holds the GENERIC representation for DECL.
896 At this point, it should not exist. Either because it was
897 converted to gimple or because DECL didn't have a GENERIC
898 representation in this TU. */
899 gcc_assert (DECL_SAVED_TREE (expr
) == NULL_TREE
);
900 lto_output_tree_or_ref (ob
, DECL_ARGUMENTS (expr
), ref_p
);
901 lto_output_tree_or_ref (ob
, DECL_RESULT (expr
), ref_p
);
903 lto_output_tree_or_ref (ob
, DECL_VINDEX (expr
), ref_p
);
907 /* Write all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
908 to output block OB. If REF_P is true, write a reference to EXPR's
912 lto_output_ts_decl_with_vis_tree_pointers (struct output_block
*ob
, tree expr
,
915 /* Make sure we don't inadvertently set the assembler name. */
916 if (DECL_ASSEMBLER_NAME_SET_P (expr
))
917 lto_output_tree_or_ref (ob
, DECL_ASSEMBLER_NAME (expr
), ref_p
);
921 lto_output_tree_or_ref (ob
, DECL_SECTION_NAME (expr
), ref_p
);
922 lto_output_tree_or_ref (ob
, DECL_COMDAT_GROUP (expr
), ref_p
);
926 /* Write all pointer fields in the TS_FIELD_DECL structure of EXPR to
927 output block OB. If REF_P is true, write a reference to EXPR's
931 lto_output_ts_field_decl_tree_pointers (struct output_block
*ob
, tree expr
,
934 lto_output_tree_or_ref (ob
, DECL_FIELD_OFFSET (expr
), ref_p
);
935 lto_output_tree_or_ref (ob
, DECL_BIT_FIELD_TYPE (expr
), ref_p
);
936 lto_output_tree_or_ref (ob
, DECL_QUALIFIER (expr
), ref_p
);
937 lto_output_tree_or_ref (ob
, DECL_FIELD_BIT_OFFSET (expr
), ref_p
);
938 lto_output_tree_or_ref (ob
, DECL_FCONTEXT (expr
), ref_p
);
939 lto_output_chain (ob
, TREE_CHAIN (expr
), ref_p
);
943 /* Write all pointer fields in the TS_FUNCTION_DECL structure of EXPR
944 to output block OB. If REF_P is true, write a reference to EXPR's
948 lto_output_ts_function_decl_tree_pointers (struct output_block
*ob
, tree expr
,
951 /* DECL_STRUCT_FUNCTION is handled by lto_output_function. FIXME lto,
952 maybe it should be handled here? */
953 lto_output_tree_or_ref (ob
, DECL_FUNCTION_PERSONALITY (expr
), ref_p
);
954 lto_output_tree_or_ref (ob
, DECL_FUNCTION_SPECIFIC_TARGET (expr
), ref_p
);
955 lto_output_tree_or_ref (ob
, DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr
),
960 /* Write all pointer fields in the TS_TYPE structure of EXPR to output
961 block OB. If REF_P is true, write a reference to EXPR's pointer
965 lto_output_ts_type_tree_pointers (struct output_block
*ob
, tree expr
,
968 if (TREE_CODE (expr
) == ENUMERAL_TYPE
)
969 lto_output_tree_or_ref (ob
, TYPE_VALUES (expr
), ref_p
);
970 else if (TREE_CODE (expr
) == ARRAY_TYPE
)
971 lto_output_tree_or_ref (ob
, TYPE_DOMAIN (expr
), ref_p
);
972 else if (RECORD_OR_UNION_TYPE_P (expr
))
973 lto_output_tree_or_ref (ob
, TYPE_FIELDS (expr
), ref_p
);
974 else if (TREE_CODE (expr
) == FUNCTION_TYPE
975 || TREE_CODE (expr
) == METHOD_TYPE
)
976 lto_output_tree_or_ref (ob
, TYPE_ARG_TYPES (expr
), ref_p
);
978 lto_output_tree_or_ref (ob
, TYPE_SIZE (expr
), ref_p
);
979 lto_output_tree_or_ref (ob
, TYPE_SIZE_UNIT (expr
), ref_p
);
980 lto_output_tree_or_ref (ob
, TYPE_ATTRIBUTES (expr
), ref_p
);
981 lto_output_tree_or_ref (ob
, TYPE_NAME (expr
), ref_p
);
982 /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO nor
983 TYPE_NEXT_PTR_TO or TYPE_NEXT_REF_TO. */
984 if (!POINTER_TYPE_P (expr
))
985 lto_output_tree_or_ref (ob
, TYPE_MINVAL (expr
), ref_p
);
986 lto_output_tree_or_ref (ob
, TYPE_MAXVAL (expr
), ref_p
);
987 lto_output_tree_or_ref (ob
, TYPE_MAIN_VARIANT (expr
), ref_p
);
988 /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
990 if (RECORD_OR_UNION_TYPE_P (expr
))
991 lto_output_tree_or_ref (ob
, TYPE_BINFO (expr
), ref_p
);
992 lto_output_tree_or_ref (ob
, TYPE_CONTEXT (expr
), ref_p
);
993 /* TYPE_CANONICAL is re-computed during type merging, so no need
994 to stream it here. */
995 lto_output_tree_or_ref (ob
, TYPE_STUB_DECL (expr
), ref_p
);
999 /* Write all pointer fields in the TS_LIST structure of EXPR to output
1000 block OB. If REF_P is true, write a reference to EXPR's pointer
1004 lto_output_ts_list_tree_pointers (struct output_block
*ob
, tree expr
,
1007 lto_output_tree_or_ref (ob
, TREE_PURPOSE (expr
), ref_p
);
1008 lto_output_tree_or_ref (ob
, TREE_VALUE (expr
), ref_p
);
1009 lto_output_chain (ob
, TREE_CHAIN (expr
), ref_p
);
1013 /* Write all pointer fields in the TS_VEC structure of EXPR to output
1014 block OB. If REF_P is true, write a reference to EXPR's pointer
1018 lto_output_ts_vec_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
1022 /* Note that the number of slots for EXPR has already been emitted
1023 in EXPR's header (see lto_output_tree_header). */
1024 for (i
= 0; i
< TREE_VEC_LENGTH (expr
); i
++)
1025 lto_output_tree_or_ref (ob
, TREE_VEC_ELT (expr
, i
), ref_p
);
1029 /* Write all pointer fields in the TS_EXP structure of EXPR to output
1030 block OB. If REF_P is true, write a reference to EXPR's pointer
1034 lto_output_ts_exp_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
1038 output_sleb128 (ob
, TREE_OPERAND_LENGTH (expr
));
1039 for (i
= 0; i
< TREE_OPERAND_LENGTH (expr
); i
++)
1040 lto_output_tree_or_ref (ob
, TREE_OPERAND (expr
, i
), ref_p
);
1041 lto_output_location (ob
, EXPR_LOCATION (expr
));
1042 lto_output_tree_or_ref (ob
, TREE_BLOCK (expr
), ref_p
);
1046 /* Write all pointer fields in the TS_BLOCK structure of EXPR to output
1047 block OB. If REF_P is true, write a reference to EXPR's pointer
1051 lto_output_ts_block_tree_pointers (struct output_block
*ob
, tree expr
,
1057 lto_output_location (ob
, BLOCK_SOURCE_LOCATION (expr
));
1058 lto_output_chain (ob
, BLOCK_VARS (expr
), ref_p
);
1060 output_uleb128 (ob
, VEC_length (tree
, BLOCK_NONLOCALIZED_VARS (expr
)));
1061 FOR_EACH_VEC_ELT (tree
, BLOCK_NONLOCALIZED_VARS (expr
), i
, t
)
1062 lto_output_tree_or_ref (ob
, t
, ref_p
);
1064 lto_output_tree_or_ref (ob
, BLOCK_SUPERCONTEXT (expr
), ref_p
);
1065 lto_output_tree_or_ref (ob
, BLOCK_ABSTRACT_ORIGIN (expr
), ref_p
);
1066 lto_output_tree_or_ref (ob
, BLOCK_FRAGMENT_ORIGIN (expr
), ref_p
);
1067 lto_output_tree_or_ref (ob
, BLOCK_FRAGMENT_CHAIN (expr
), ref_p
);
1068 /* Do not output BLOCK_SUBBLOCKS. Instead on streaming-in this
1069 list is re-constructed from BLOCK_SUPERCONTEXT. */
1073 /* Write all pointer fields in the TS_BINFO structure of EXPR to output
1074 block OB. If REF_P is true, write a reference to EXPR's pointer
1078 lto_output_ts_binfo_tree_pointers (struct output_block
*ob
, tree expr
,
1084 /* Note that the number of BINFO slots has already been emitted in
1085 EXPR's header (see lto_output_tree_header) because this length
1086 is needed to build the empty BINFO node on the reader side. */
1087 FOR_EACH_VEC_ELT (tree
, BINFO_BASE_BINFOS (expr
), i
, t
)
1088 lto_output_tree_or_ref (ob
, t
, ref_p
);
1091 lto_output_tree_or_ref (ob
, BINFO_OFFSET (expr
), ref_p
);
1092 lto_output_tree_or_ref (ob
, BINFO_VTABLE (expr
), ref_p
);
1093 lto_output_tree_or_ref (ob
, BINFO_VIRTUALS (expr
), ref_p
);
1094 lto_output_tree_or_ref (ob
, BINFO_VPTR_FIELD (expr
), ref_p
);
1096 output_uleb128 (ob
, VEC_length (tree
, BINFO_BASE_ACCESSES (expr
)));
1097 FOR_EACH_VEC_ELT (tree
, BINFO_BASE_ACCESSES (expr
), i
, t
)
1098 lto_output_tree_or_ref (ob
, t
, ref_p
);
1100 lto_output_tree_or_ref (ob
, BINFO_INHERITANCE_CHAIN (expr
), ref_p
);
1101 lto_output_tree_or_ref (ob
, BINFO_SUBVTT_INDEX (expr
), ref_p
);
1102 lto_output_tree_or_ref (ob
, BINFO_VPTR_INDEX (expr
), ref_p
);
1106 /* Write all pointer fields in the TS_CONSTRUCTOR structure of EXPR to
1107 output block OB. If REF_P is true, write a reference to EXPR's
1111 lto_output_ts_constructor_tree_pointers (struct output_block
*ob
, tree expr
,
1117 output_uleb128 (ob
, CONSTRUCTOR_NELTS (expr
));
1118 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (expr
), i
, index
, value
)
1120 lto_output_tree_or_ref (ob
, index
, ref_p
);
1121 lto_output_tree_or_ref (ob
, value
, ref_p
);
1125 /* Write a TS_TARGET_OPTION tree in EXPR to OB. */
1128 lto_output_ts_target_option (struct output_block
*ob
, tree expr
)
1130 struct cl_target_option
*t
= TREE_TARGET_OPTION (expr
);
1131 struct bitpack_d bp
;
1134 /* The cl_target_option is target specific and generated by the options
1135 awk script, so we just recreate a byte-by-byte copy here. */
1137 bp
= bitpack_create (ob
->main_stream
);
1138 len
= sizeof (struct cl_target_option
);
1139 for (i
= 0; i
< len
; i
++)
1140 bp_pack_value (&bp
, ((unsigned char *)t
)[i
], 8);
1141 /* Catch struct size mismatches between reader and writer. */
1142 bp_pack_value (&bp
, 0x12345678, 32);
1143 lto_output_bitpack (&bp
);
1146 /* Write a TS_TRANSLATION_UNIT_DECL tree in EXPR to OB. */
1149 lto_output_ts_translation_unit_decl_tree_pointers (struct output_block
*ob
,
1152 output_string (ob
, ob
->main_stream
, TRANSLATION_UNIT_LANGUAGE (expr
));
1155 /* Helper for lto_output_tree. Write all pointer fields in EXPR to output
1156 block OB. If REF_P is true, the leaves of EXPR are emitted as
1160 lto_output_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
1162 enum tree_code code
;
1164 code
= TREE_CODE (expr
);
1166 if (CODE_CONTAINS_STRUCT (code
, TS_COMMON
))
1167 lto_output_ts_common_tree_pointers (ob
, expr
, ref_p
);
1169 if (CODE_CONTAINS_STRUCT (code
, TS_VECTOR
))
1170 lto_output_ts_vector_tree_pointers (ob
, expr
, ref_p
);
1172 if (CODE_CONTAINS_STRUCT (code
, TS_COMPLEX
))
1173 lto_output_ts_complex_tree_pointers (ob
, expr
, ref_p
);
1175 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
1176 lto_output_ts_decl_minimal_tree_pointers (ob
, expr
, ref_p
);
1178 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
1179 lto_output_ts_decl_common_tree_pointers (ob
, expr
, ref_p
);
1181 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_NON_COMMON
))
1182 lto_output_ts_decl_non_common_tree_pointers (ob
, expr
, ref_p
);
1184 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
1185 lto_output_ts_decl_with_vis_tree_pointers (ob
, expr
, ref_p
);
1187 if (CODE_CONTAINS_STRUCT (code
, TS_FIELD_DECL
))
1188 lto_output_ts_field_decl_tree_pointers (ob
, expr
, ref_p
);
1190 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
1191 lto_output_ts_function_decl_tree_pointers (ob
, expr
, ref_p
);
1193 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE
))
1194 lto_output_ts_type_tree_pointers (ob
, expr
, ref_p
);
1196 if (CODE_CONTAINS_STRUCT (code
, TS_LIST
))
1197 lto_output_ts_list_tree_pointers (ob
, expr
, ref_p
);
1199 if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
1200 lto_output_ts_vec_tree_pointers (ob
, expr
, ref_p
);
1202 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
1203 lto_output_ts_exp_tree_pointers (ob
, expr
, ref_p
);
1205 if (CODE_CONTAINS_STRUCT (code
, TS_SSA_NAME
))
1207 /* We only stream the version number of SSA names. */
1211 if (CODE_CONTAINS_STRUCT (code
, TS_BLOCK
))
1212 lto_output_ts_block_tree_pointers (ob
, expr
, ref_p
);
1214 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
1215 lto_output_ts_binfo_tree_pointers (ob
, expr
, ref_p
);
1217 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
1218 lto_output_ts_constructor_tree_pointers (ob
, expr
, ref_p
);
1220 if (CODE_CONTAINS_STRUCT (code
, TS_STATEMENT_LIST
))
1222 /* This should only appear in GENERIC. */
1226 if (CODE_CONTAINS_STRUCT (code
, TS_OMP_CLAUSE
))
1228 /* This should only appear in High GIMPLE. */
1232 if (CODE_CONTAINS_STRUCT (code
, TS_OPTIMIZATION
))
1233 sorry ("gimple bytecode streams do not support the optimization attribute");
1235 if (CODE_CONTAINS_STRUCT (code
, TS_TARGET_OPTION
))
1236 lto_output_ts_target_option (ob
, expr
);
1238 if (CODE_CONTAINS_STRUCT (code
, TS_TRANSLATION_UNIT_DECL
))
1239 lto_output_ts_translation_unit_decl_tree_pointers (ob
, expr
);
1243 /* Emit header information for tree EXPR to output block OB. The header
1244 contains everything needed to instantiate an empty skeleton for
1245 EXPR on the reading side. IX is the index into the streamer cache
1246 where EXPR is stored. REF_P is as in lto_output_tree. */
1249 lto_output_tree_header (struct output_block
*ob
, tree expr
, int ix
)
1252 enum tree_code code
;
1254 /* We should not see any non-GIMPLE tree nodes here. */
1255 code
= TREE_CODE (expr
);
1256 if (!lto_is_streamable (expr
))
1257 internal_error ("tree code %qs is not supported in gimple streams",
1258 tree_code_name
[code
]);
1260 /* The header of a tree node consists of its tag, the size of
1261 the node, and any other information needed to instantiate
1262 EXPR on the reading side (such as the number of slots in
1263 variable sized nodes). */
1264 tag
= lto_tree_code_to_tag (code
);
1265 output_record_start (ob
, tag
);
1266 output_sleb128 (ob
, ix
);
1268 /* The following will cause bootstrap miscomparisons. Enable with care. */
1269 #ifdef LTO_STREAMER_DEBUG
1270 /* This is used mainly for debugging purposes. When the reader
1271 and the writer do not agree on a streamed node, the pointer
1272 value for EXPR can be used to track down the differences in
1274 gcc_assert ((HOST_WIDEST_INT
) (intptr_t) expr
== (intptr_t) expr
);
1275 output_sleb128 (ob
, (HOST_WIDEST_INT
) (intptr_t) expr
);
1278 /* The text in strings and identifiers are completely emitted in
1280 if (CODE_CONTAINS_STRUCT (code
, TS_STRING
))
1281 output_string_cst (ob
, ob
->main_stream
, expr
);
1282 else if (CODE_CONTAINS_STRUCT (code
, TS_IDENTIFIER
))
1283 output_identifier (ob
, ob
->main_stream
, expr
);
1284 else if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
1285 output_sleb128 (ob
, TREE_VEC_LENGTH (expr
));
1286 else if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
1287 output_uleb128 (ob
, BINFO_N_BASE_BINFOS (expr
));
1291 /* Write the code and class of builtin EXPR to output block OB. IX is
1292 the index into the streamer cache where EXPR is stored.*/
1295 lto_output_builtin_tree (struct output_block
*ob
, tree expr
, int ix
)
1297 gcc_assert (lto_stream_as_builtin_p (expr
));
1299 if (DECL_BUILT_IN_CLASS (expr
) == BUILT_IN_MD
1300 && !targetm
.builtin_decl
)
1301 sorry ("gimple bytecode streams do not support machine specific builtin "
1302 "functions on this target");
1304 output_record_start (ob
, LTO_builtin_decl
);
1305 output_uleb128 (ob
, DECL_BUILT_IN_CLASS (expr
));
1306 output_uleb128 (ob
, DECL_FUNCTION_CODE (expr
));
1307 output_sleb128 (ob
, ix
);
1309 if (DECL_ASSEMBLER_NAME_SET_P (expr
))
1311 /* When the assembler name of a builtin gets a user name,
1312 the new name is always prefixed with '*' by
1313 set_builtin_user_assembler_name. So, to prevent the
1314 reader side from adding a second '*', we omit it here. */
1315 const char *str
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (expr
));
1316 if (strlen (str
) > 1 && str
[0] == '*')
1317 output_string (ob
, ob
->main_stream
, &str
[1]);
1319 output_string (ob
, ob
->main_stream
, NULL
);
1322 output_string (ob
, ob
->main_stream
, NULL
);
1326 /* Write a physical representation of tree node EXPR to output block
1327 OB. If REF_P is true, the leaves of EXPR are emitted as references
1328 via lto_output_tree_ref. IX is the index into the streamer cache
1329 where EXPR is stored. */
1332 lto_write_tree (struct output_block
*ob
, tree expr
, bool ref_p
, int ix
)
1334 struct bitpack_d bp
;
1336 /* Write the header, containing everything needed to materialize
1337 EXPR on the reading side. */
1338 lto_output_tree_header (ob
, expr
, ix
);
1340 /* Pack all the non-pointer fields in EXPR into a bitpack and write
1341 the resulting bitpack. */
1342 bp
= bitpack_create (ob
->main_stream
);
1343 pack_value_fields (&bp
, expr
);
1344 lto_output_bitpack (&bp
);
1346 /* Write all the pointer fields in EXPR. */
1347 lto_output_tree_pointers (ob
, expr
, ref_p
);
1349 /* Mark the end of EXPR. */
1354 /* Emit the integer constant CST to output block OB. If REF_P is true,
1355 CST's type will be emitted as a reference. */
1358 lto_output_integer_cst (struct output_block
*ob
, tree cst
, bool ref_p
)
1360 output_record_start (ob
, lto_tree_code_to_tag (INTEGER_CST
));
1361 lto_output_tree_or_ref (ob
, TREE_TYPE (cst
), ref_p
);
1362 lto_output_1_stream (ob
->main_stream
, TREE_OVERFLOW_P (cst
));
1363 output_uleb128 (ob
, TREE_INT_CST_LOW (cst
));
1364 output_uleb128 (ob
, TREE_INT_CST_HIGH (cst
));
1368 /* Emit the physical representation of tree node EXPR to output block
1369 OB. If REF_P is true, the leaves of EXPR are emitted as references
1370 via lto_output_tree_ref. */
1373 lto_output_tree (struct output_block
*ob
, tree expr
, bool ref_p
)
1379 if (expr
== NULL_TREE
)
1385 /* INTEGER_CST nodes are special because they need their original type
1386 to be materialized by the reader (to implement TYPE_CACHED_VALUES). */
1387 if (TREE_CODE (expr
) == INTEGER_CST
)
1389 lto_output_integer_cst (ob
, expr
, ref_p
);
1393 /* Determine the offset in the stream where EXPR will be written.
1394 This is used when emitting pickle references so the reader knows
1395 where to reconstruct the pickled object from. This allows
1396 circular and forward references within the same stream. */
1397 offset
= ob
->main_stream
->total_size
;
1399 existed_p
= lto_streamer_cache_insert (ob
->writer_cache
, expr
, &ix
, &offset
);
1402 /* If a node has already been streamed out, make sure that
1403 we don't write it more than once. Otherwise, the reader
1404 will instantiate two different nodes for the same object. */
1405 output_record_start (ob
, LTO_tree_pickle_reference
);
1406 output_sleb128 (ob
, ix
);
1407 output_uleb128 (ob
, lto_tree_code_to_tag (TREE_CODE (expr
)));
1408 output_uleb128 (ob
, offset
);
1410 else if (lto_stream_as_builtin_p (expr
))
1412 /* MD and NORMAL builtins do not need to be written out
1413 completely as they are always instantiated by the
1414 compiler on startup. The only builtins that need to
1415 be written out are BUILT_IN_FRONTEND. For all other
1416 builtins, we simply write the class and code. */
1417 lto_output_builtin_tree (ob
, expr
, ix
);
1421 /* This is the first time we see EXPR, write its fields
1423 lto_write_tree (ob
, expr
, ref_p
, ix
);
1428 /* Output to OB a list of try/catch handlers starting with FIRST. */
1431 output_eh_try_list (struct output_block
*ob
, eh_catch first
)
1435 for (n
= first
; n
; n
= n
->next_catch
)
1437 output_record_start (ob
, LTO_eh_catch
);
1438 lto_output_tree_ref (ob
, n
->type_list
);
1439 lto_output_tree_ref (ob
, n
->filter_list
);
1440 lto_output_tree_ref (ob
, n
->label
);
1447 /* Output EH region R in function FN to OB. CURR_RN is the slot index
1448 that is being emitted in FN->EH->REGION_ARRAY. This is used to
1449 detect EH region sharing. */
1452 output_eh_region (struct output_block
*ob
, eh_region r
)
1462 if (r
->type
== ERT_CLEANUP
)
1463 tag
= LTO_ert_cleanup
;
1464 else if (r
->type
== ERT_TRY
)
1466 else if (r
->type
== ERT_ALLOWED_EXCEPTIONS
)
1467 tag
= LTO_ert_allowed_exceptions
;
1468 else if (r
->type
== ERT_MUST_NOT_THROW
)
1469 tag
= LTO_ert_must_not_throw
;
1473 output_record_start (ob
, tag
);
1474 output_sleb128 (ob
, r
->index
);
1477 output_sleb128 (ob
, r
->outer
->index
);
1482 output_sleb128 (ob
, r
->inner
->index
);
1487 output_sleb128 (ob
, r
->next_peer
->index
);
1491 if (r
->type
== ERT_TRY
)
1493 output_eh_try_list (ob
, r
->u
.eh_try
.first_catch
);
1495 else if (r
->type
== ERT_ALLOWED_EXCEPTIONS
)
1497 lto_output_tree_ref (ob
, r
->u
.allowed
.type_list
);
1498 lto_output_tree_ref (ob
, r
->u
.allowed
.label
);
1499 output_uleb128 (ob
, r
->u
.allowed
.filter
);
1501 else if (r
->type
== ERT_MUST_NOT_THROW
)
1503 lto_output_tree_ref (ob
, r
->u
.must_not_throw
.failure_decl
);
1504 lto_output_location (ob
, r
->u
.must_not_throw
.failure_loc
);
1507 if (r
->landing_pads
)
1508 output_sleb128 (ob
, r
->landing_pads
->index
);
1514 /* Output landing pad LP to OB. */
1517 output_eh_lp (struct output_block
*ob
, eh_landing_pad lp
)
1525 output_record_start (ob
, LTO_eh_landing_pad
);
1526 output_sleb128 (ob
, lp
->index
);
1528 output_sleb128 (ob
, lp
->next_lp
->index
);
1533 output_sleb128 (ob
, lp
->region
->index
);
1537 lto_output_tree_ref (ob
, lp
->post_landing_pad
);
1541 /* Output the existing eh_table to OB. */
1544 output_eh_regions (struct output_block
*ob
, struct function
*fn
)
1546 if (fn
->eh
&& fn
->eh
->region_tree
)
1553 output_record_start (ob
, LTO_eh_table
);
1555 /* Emit the index of the root of the EH region tree. */
1556 output_sleb128 (ob
, fn
->eh
->region_tree
->index
);
1558 /* Emit all the EH regions in the region array. */
1559 output_sleb128 (ob
, VEC_length (eh_region
, fn
->eh
->region_array
));
1560 FOR_EACH_VEC_ELT (eh_region
, fn
->eh
->region_array
, i
, eh
)
1561 output_eh_region (ob
, eh
);
1563 /* Emit all landing pads. */
1564 output_sleb128 (ob
, VEC_length (eh_landing_pad
, fn
->eh
->lp_array
));
1565 FOR_EACH_VEC_ELT (eh_landing_pad
, fn
->eh
->lp_array
, i
, lp
)
1566 output_eh_lp (ob
, lp
);
1568 /* Emit all the runtime type data. */
1569 output_sleb128 (ob
, VEC_length (tree
, fn
->eh
->ttype_data
));
1570 FOR_EACH_VEC_ELT (tree
, fn
->eh
->ttype_data
, i
, ttype
)
1571 lto_output_tree_ref (ob
, ttype
);
1573 /* Emit the table of action chains. */
1574 if (targetm
.arm_eabi_unwinder
)
1577 output_sleb128 (ob
, VEC_length (tree
, fn
->eh
->ehspec_data
.arm_eabi
));
1578 FOR_EACH_VEC_ELT (tree
, fn
->eh
->ehspec_data
.arm_eabi
, i
, t
)
1579 lto_output_tree_ref (ob
, t
);
1584 output_sleb128 (ob
, VEC_length (uchar
, fn
->eh
->ehspec_data
.other
));
1585 FOR_EACH_VEC_ELT (uchar
, fn
->eh
->ehspec_data
.other
, i
, c
)
1586 lto_output_1_stream (ob
->main_stream
, c
);
1590 /* The 0 either terminates the record or indicates that there are no
1591 eh_records at all. */
1596 /* Output all of the active ssa names to the ssa_names stream. */
1599 output_ssa_names (struct output_block
*ob
, struct function
*fn
)
1601 unsigned int i
, len
;
1603 len
= VEC_length (tree
, SSANAMES (fn
));
1604 output_uleb128 (ob
, len
);
1606 for (i
= 1; i
< len
; i
++)
1608 tree ptr
= VEC_index (tree
, SSANAMES (fn
), i
);
1610 if (ptr
== NULL_TREE
1611 || SSA_NAME_IN_FREE_LIST (ptr
)
1612 || !is_gimple_reg (ptr
))
1615 output_uleb128 (ob
, i
);
1616 lto_output_1_stream (ob
->main_stream
, SSA_NAME_IS_DEFAULT_DEF (ptr
));
1617 lto_output_tree_ref (ob
, SSA_NAME_VAR (ptr
));
1624 /* Output the cfg. */
1627 output_cfg (struct output_block
*ob
, struct function
*fn
)
1629 struct lto_output_stream
*tmp_stream
= ob
->main_stream
;
1632 ob
->main_stream
= ob
->cfg_stream
;
1634 output_uleb128 (ob
, profile_status_for_function (fn
));
1636 /* Output the number of the highest basic block. */
1637 output_uleb128 (ob
, last_basic_block_for_function (fn
));
1639 FOR_ALL_BB_FN (bb
, fn
)
1644 output_sleb128 (ob
, bb
->index
);
1646 /* Output the successors and the edge flags. */
1647 output_uleb128 (ob
, EDGE_COUNT (bb
->succs
));
1648 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
1650 output_uleb128 (ob
, e
->dest
->index
);
1651 output_sleb128 (ob
, e
->probability
);
1652 output_sleb128 (ob
, e
->count
);
1653 output_uleb128 (ob
, e
->flags
);
1657 output_sleb128 (ob
, -1);
1659 bb
= ENTRY_BLOCK_PTR
;
1662 output_sleb128 (ob
, bb
->next_bb
->index
);
1666 output_sleb128 (ob
, -1);
1668 ob
->main_stream
= tmp_stream
;
1672 /* Output PHI function PHI to the main stream in OB. */
1675 output_phi (struct output_block
*ob
, gimple phi
)
1677 unsigned i
, len
= gimple_phi_num_args (phi
);
1679 output_record_start (ob
, lto_gimple_code_to_tag (GIMPLE_PHI
));
1680 output_uleb128 (ob
, SSA_NAME_VERSION (PHI_RESULT (phi
)));
1682 for (i
= 0; i
< len
; i
++)
1684 lto_output_tree_ref (ob
, gimple_phi_arg_def (phi
, i
));
1685 output_uleb128 (ob
, gimple_phi_arg_edge (phi
, i
)->src
->index
);
1686 lto_output_location (ob
, gimple_phi_arg_location (phi
, i
));
1691 /* Emit statement STMT on the main stream of output block OB. */
1694 output_gimple_stmt (struct output_block
*ob
, gimple stmt
)
1697 enum gimple_code code
;
1699 struct bitpack_d bp
;
1701 /* Emit identifying tag. */
1702 code
= gimple_code (stmt
);
1703 tag
= lto_gimple_code_to_tag (code
);
1704 output_record_start (ob
, tag
);
1706 /* Emit the tuple header. */
1707 bp
= bitpack_create (ob
->main_stream
);
1708 bp_pack_value (&bp
, gimple_num_ops (stmt
), sizeof (unsigned) * 8);
1709 bp_pack_value (&bp
, gimple_no_warning_p (stmt
), 1);
1710 if (is_gimple_assign (stmt
))
1711 bp_pack_value (&bp
, gimple_assign_nontemporal_move_p (stmt
), 1);
1712 bp_pack_value (&bp
, gimple_has_volatile_ops (stmt
), 1);
1713 bp_pack_value (&bp
, stmt
->gsbase
.subcode
, 16);
1714 lto_output_bitpack (&bp
);
1716 /* Emit location information for the statement. */
1717 lto_output_location (ob
, gimple_location (stmt
));
1719 /* Emit the lexical block holding STMT. */
1720 lto_output_tree (ob
, gimple_block (stmt
), true);
1722 /* Emit the operands. */
1723 switch (gimple_code (stmt
))
1726 output_sleb128 (ob
, gimple_resx_region (stmt
));
1729 case GIMPLE_EH_MUST_NOT_THROW
:
1730 lto_output_tree_ref (ob
, gimple_eh_must_not_throw_fndecl (stmt
));
1733 case GIMPLE_EH_DISPATCH
:
1734 output_sleb128 (ob
, gimple_eh_dispatch_region (stmt
));
1738 lto_output_uleb128_stream (ob
->main_stream
, gimple_asm_ninputs (stmt
));
1739 lto_output_uleb128_stream (ob
->main_stream
, gimple_asm_noutputs (stmt
));
1740 lto_output_uleb128_stream (ob
->main_stream
, gimple_asm_nclobbers (stmt
));
1741 lto_output_uleb128_stream (ob
->main_stream
, gimple_asm_nlabels (stmt
));
1742 output_string (ob
, ob
->main_stream
, gimple_asm_string (stmt
));
1753 for (i
= 0; i
< gimple_num_ops (stmt
); i
++)
1755 tree op
= gimple_op (stmt
, i
);
1756 /* Wrap all uses of non-automatic variables inside MEM_REFs
1757 so that we do not have to deal with type mismatches on
1758 merged symbols during IL read in. */
1762 if (handled_component_p (*basep
))
1763 basep
= &TREE_OPERAND (*basep
, 0);
1764 if (TREE_CODE (*basep
) == VAR_DECL
1765 && !auto_var_in_fn_p (*basep
, current_function_decl
))
1767 bool volatilep
= TREE_THIS_VOLATILE (*basep
);
1768 *basep
= build2 (MEM_REF
, TREE_TYPE (*basep
),
1769 build_fold_addr_expr (*basep
),
1770 build_int_cst (build_pointer_type
1771 (TREE_TYPE (*basep
)), 0));
1772 TREE_THIS_VOLATILE (*basep
) = volatilep
;
1775 lto_output_tree_ref (ob
, op
);
1780 case GIMPLE_PREDICT
:
1789 /* Output a basic block BB to the main stream in OB for this FN. */
1792 output_bb (struct output_block
*ob
, basic_block bb
, struct function
*fn
)
1794 gimple_stmt_iterator bsi
= gsi_start_bb (bb
);
1796 output_record_start (ob
,
1797 (!gsi_end_p (bsi
)) || phi_nodes (bb
)
1801 output_uleb128 (ob
, bb
->index
);
1802 output_sleb128 (ob
, bb
->count
);
1803 output_sleb128 (ob
, bb
->loop_depth
);
1804 output_sleb128 (ob
, bb
->frequency
);
1805 output_sleb128 (ob
, bb
->flags
);
1807 if (!gsi_end_p (bsi
) || phi_nodes (bb
))
1809 /* Output the statements. The list of statements is terminated
1811 for (bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
1814 gimple stmt
= gsi_stmt (bsi
);
1816 output_gimple_stmt (ob
, stmt
);
1818 /* Emit the EH region holding STMT. */
1819 region
= lookup_stmt_eh_lp_fn (fn
, stmt
);
1822 output_record_start (ob
, LTO_eh_region
);
1823 output_sleb128 (ob
, region
);
1831 for (bsi
= gsi_start_phis (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
1833 gimple phi
= gsi_stmt (bsi
);
1835 /* Only emit PHIs for gimple registers. PHI nodes for .MEM
1836 will be filled in on reading when the SSA form is
1838 if (is_gimple_reg (gimple_phi_result (phi
)))
1839 output_phi (ob
, phi
);
1846 /* Create the header in the file using OB. If the section type is for
1847 a function, set FN to the decl for that function. */
1850 produce_asm (struct output_block
*ob
, tree fn
)
1852 enum lto_section_type section_type
= ob
->section_type
;
1853 struct lto_function_header header
;
1855 struct lto_output_stream
*header_stream
;
1857 if (section_type
== LTO_section_function_body
)
1859 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fn
));
1860 section_name
= lto_get_section_name (section_type
, name
, NULL
);
1863 section_name
= lto_get_section_name (section_type
, NULL
, NULL
);
1865 lto_begin_section (section_name
, !flag_wpa
);
1866 free (section_name
);
1868 /* The entire header is stream computed here. */
1869 memset (&header
, 0, sizeof (struct lto_function_header
));
1871 /* Write the header. */
1872 header
.lto_header
.major_version
= LTO_major_version
;
1873 header
.lto_header
.minor_version
= LTO_minor_version
;
1874 header
.lto_header
.section_type
= section_type
;
1876 header
.compressed_size
= 0;
1878 if (section_type
== LTO_section_function_body
)
1879 header
.cfg_size
= ob
->cfg_stream
->total_size
;
1880 header
.main_size
= ob
->main_stream
->total_size
;
1881 header
.string_size
= ob
->string_stream
->total_size
;
1883 header_stream
= XCNEW (struct lto_output_stream
);
1884 lto_output_data_stream (header_stream
, &header
, sizeof header
);
1885 lto_write_stream (header_stream
);
1886 free (header_stream
);
1888 /* Put all of the gimple and the string table out the asm file as a
1890 if (section_type
== LTO_section_function_body
)
1891 lto_write_stream (ob
->cfg_stream
);
1892 lto_write_stream (ob
->main_stream
);
1893 lto_write_stream (ob
->string_stream
);
1899 /* Output the body of function NODE->DECL. */
1902 output_function (struct cgraph_node
*node
)
1904 struct bitpack_d bp
;
1906 struct function
*fn
;
1908 struct output_block
*ob
;
1912 function
= node
->decl
;
1913 fn
= DECL_STRUCT_FUNCTION (function
);
1914 ob
= create_output_block (LTO_section_function_body
);
1916 clear_line_info (ob
);
1917 ob
->cgraph_node
= node
;
1919 gcc_assert (current_function_decl
== NULL_TREE
&& cfun
== NULL
);
1921 /* Set current_function_decl and cfun. */
1922 current_function_decl
= function
;
1925 /* Make string 0 be a NULL string. */
1926 lto_output_1_stream (ob
->string_stream
, 0);
1928 output_record_start (ob
, LTO_function
);
1930 /* Write all the attributes for FN. */
1931 bp
= bitpack_create (ob
->main_stream
);
1932 bp_pack_value (&bp
, fn
->is_thunk
, 1);
1933 bp_pack_value (&bp
, fn
->has_local_explicit_reg_vars
, 1);
1934 bp_pack_value (&bp
, fn
->after_tree_profile
, 1);
1935 bp_pack_value (&bp
, fn
->returns_pcc_struct
, 1);
1936 bp_pack_value (&bp
, fn
->returns_struct
, 1);
1937 bp_pack_value (&bp
, fn
->can_throw_non_call_exceptions
, 1);
1938 bp_pack_value (&bp
, fn
->always_inline_functions_inlined
, 1);
1939 bp_pack_value (&bp
, fn
->after_inlining
, 1);
1940 bp_pack_value (&bp
, fn
->dont_save_pending_sizes_p
, 1);
1941 bp_pack_value (&bp
, fn
->stdarg
, 1);
1942 bp_pack_value (&bp
, fn
->has_nonlocal_label
, 1);
1943 bp_pack_value (&bp
, fn
->calls_alloca
, 1);
1944 bp_pack_value (&bp
, fn
->calls_setjmp
, 1);
1945 bp_pack_value (&bp
, fn
->va_list_fpr_size
, 8);
1946 bp_pack_value (&bp
, fn
->va_list_gpr_size
, 8);
1947 lto_output_bitpack (&bp
);
1949 /* Output the function start and end loci. */
1950 lto_output_location (ob
, fn
->function_start_locus
);
1951 lto_output_location (ob
, fn
->function_end_locus
);
1953 /* Output current IL state of the function. */
1954 output_uleb128 (ob
, fn
->curr_properties
);
1956 /* Output the static chain and non-local goto save area. */
1957 lto_output_tree_ref (ob
, fn
->static_chain_decl
);
1958 lto_output_tree_ref (ob
, fn
->nonlocal_goto_save_area
);
1960 /* Output all the local variables in the function. */
1961 output_sleb128 (ob
, VEC_length (tree
, fn
->local_decls
));
1962 FOR_EACH_VEC_ELT (tree
, fn
->local_decls
, i
, t
)
1963 lto_output_tree_ref (ob
, t
);
1965 /* Output the head of the arguments list. */
1966 lto_output_tree_ref (ob
, DECL_ARGUMENTS (function
));
1968 /* Output all the SSA names used in the function. */
1969 output_ssa_names (ob
, fn
);
1971 /* Output any exception handling regions. */
1972 output_eh_regions (ob
, fn
);
1974 /* Output DECL_INITIAL for the function, which contains the tree of
1976 lto_output_tree (ob
, DECL_INITIAL (function
), true);
1978 /* We will renumber the statements. The code that does this uses
1979 the same ordering that we use for serializing them so we can use
1980 the same code on the other end and not have to write out the
1981 statement numbers. */
1982 renumber_gimple_stmt_uids ();
1984 /* Output the code for the function. */
1985 FOR_ALL_BB_FN (bb
, fn
)
1986 output_bb (ob
, bb
, fn
);
1988 /* The terminator for this function. */
1991 output_cfg (ob
, fn
);
1993 /* Create a section to hold the pickled output of this function. */
1994 produce_asm (ob
, function
);
1996 destroy_output_block (ob
);
1998 current_function_decl
= NULL
;
2003 /* Return true if alias pair P belongs to the set of cgraph nodes in
2004 SET. If P is a an alias for a VAR_DECL, it can always be emitted.
2005 However, for FUNCTION_DECL aliases, we should only output the pair
2006 if it belongs to a function whose cgraph node is in SET.
2007 Otherwise, the LTRANS phase will get into trouble when finalizing
2008 aliases because the alias will refer to a function not defined in
2009 the file processed by LTRANS. */
2012 output_alias_pair_p (alias_pair
*p
, cgraph_node_set set
, varpool_node_set vset
)
2014 if (TREE_CODE (p
->decl
) == VAR_DECL
)
2015 return varpool_node_in_set_p (varpool_node_for_asm (p
->target
), vset
);
2017 /* Check if the assembler name for P->TARGET has its cgraph node in SET. */
2018 gcc_assert (TREE_CODE (p
->decl
) == FUNCTION_DECL
);
2019 return cgraph_node_in_set_p (cgraph_node_for_asm (p
->target
), set
);
2023 /* Output any unreferenced global symbol defined in SET, alias pairs
2027 output_unreferenced_globals (cgraph_node_set set
, varpool_node_set vset
)
2029 struct output_block
*ob
;
2032 struct varpool_node
*vnode
;
2034 ob
= create_output_block (LTO_section_static_initializer
);
2035 ob
->cgraph_node
= NULL
;
2037 clear_line_info (ob
);
2039 /* Make string 0 be a NULL string. */
2040 lto_output_1_stream (ob
->string_stream
, 0);
2042 /* Emit references for all the global symbols. If a global symbol
2043 was never referenced in any of the functions of this file, it
2044 would not be emitted otherwise. This will result in unreferenced
2045 symbols at link time if a file defines a global symbol but
2046 never references it. */
2047 FOR_EACH_STATIC_VARIABLE (vnode
)
2048 if (vnode
->needed
&& varpool_node_in_set_p (vnode
, vset
))
2050 tree var
= vnode
->decl
;
2052 if (TREE_CODE (var
) == VAR_DECL
)
2054 /* Output the object in order to output references used in the
2056 lto_output_tree (ob
, var
, true);
2058 /* If it is public we also need a reference to the object itself. */
2059 if (TREE_PUBLIC (var
))
2060 lto_output_tree_ref (ob
, var
);
2066 /* Emit the alias pairs for the nodes in SET. */
2067 FOR_EACH_VEC_ELT (alias_pair
, alias_pairs
, i
, p
)
2069 if (output_alias_pair_p (p
, set
, vset
))
2071 lto_output_tree_ref (ob
, p
->decl
);
2072 lto_output_tree_ref (ob
, p
->target
);
2078 produce_asm (ob
, NULL
);
2079 destroy_output_block (ob
);
2083 /* Copy the function body of NODE without deserializing. */
2086 copy_function (struct cgraph_node
*node
)
2088 tree function
= node
->decl
;
2089 struct lto_file_decl_data
*file_data
= node
->local
.lto_file_data
;
2090 struct lto_output_stream
*output_stream
= XCNEW (struct lto_output_stream
);
2093 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (function
));
2094 char *section_name
=
2095 lto_get_section_name (LTO_section_function_body
, name
, NULL
);
2097 struct lto_in_decl_state
*in_state
;
2098 struct lto_out_decl_state
*out_state
= lto_get_out_decl_state ();
2100 lto_begin_section (section_name
, !flag_wpa
);
2101 free (section_name
);
2103 /* We may have renamed the declaration, e.g., a static function. */
2104 name
= lto_get_decl_name_mapping (file_data
, name
);
2106 data
= lto_get_section_data (file_data
, LTO_section_function_body
,
2110 /* Do a bit copy of the function body. */
2111 lto_output_data_stream (output_stream
, data
, len
);
2112 lto_write_stream (output_stream
);
2116 lto_get_function_in_decl_state (node
->local
.lto_file_data
, function
);
2117 gcc_assert (in_state
);
2119 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2121 size_t n
= in_state
->streams
[i
].size
;
2122 tree
*trees
= in_state
->streams
[i
].trees
;
2123 struct lto_tree_ref_encoder
*encoder
= &(out_state
->streams
[i
]);
2125 /* The out state must have the same indices and the in state.
2126 So just copy the vector. All the encoders in the in state
2127 must be empty where we reach here. */
2128 gcc_assert (lto_tree_ref_encoder_size (encoder
) == 0);
2129 for (j
= 0; j
< n
; j
++)
2130 VEC_safe_push (tree
, heap
, encoder
->trees
, trees
[j
]);
2131 encoder
->next_index
= n
;
2134 lto_free_section_data (file_data
, LTO_section_function_body
, name
,
2136 free (output_stream
);
2141 /* Initialize the LTO writer. */
2144 lto_writer_init (void)
2146 lto_streamer_init ();
2150 /* Main entry point from the pass manager. */
2153 lto_output (cgraph_node_set set
, varpool_node_set vset
)
2155 struct cgraph_node
*node
;
2156 struct lto_out_decl_state
*decl_state
;
2157 #ifdef ENABLE_CHECKING
2158 bitmap output
= lto_bitmap_alloc ();
2161 lto_cgraph_encoder_t encoder
= lto_get_out_decl_state ()->cgraph_node_encoder
;
2165 n_nodes
= lto_cgraph_encoder_size (encoder
);
2166 /* Process only the functions with bodies. */
2167 for (i
= 0; i
< n_nodes
; i
++)
2169 node
= lto_cgraph_encoder_deref (encoder
, i
);
2170 if (lto_cgraph_encoder_encode_body_p (encoder
, node
))
2172 #ifdef ENABLE_CHECKING
2173 gcc_assert (!bitmap_bit_p (output
, DECL_UID (node
->decl
)));
2174 bitmap_set_bit (output
, DECL_UID (node
->decl
));
2176 decl_state
= lto_new_out_decl_state ();
2177 lto_push_out_decl_state (decl_state
);
2178 if (gimple_has_body_p (node
->decl
))
2179 output_function (node
);
2181 copy_function (node
);
2182 gcc_assert (lto_get_out_decl_state () == decl_state
);
2183 lto_pop_out_decl_state ();
2184 lto_record_function_out_decl_state (node
->decl
, decl_state
);
2188 /* Emit the callgraph after emitting function bodies. This needs to
2189 be done now to make sure that all the statements in every function
2190 have been renumbered so that edges can be associated with call
2191 statements using the statement UIDs. */
2192 output_cgraph (set
, vset
);
2194 #ifdef ENABLE_CHECKING
2195 lto_bitmap_free (output
);
2199 struct ipa_opt_pass_d pass_ipa_lto_gimple_out
=
2203 "lto_gimple_out", /* name */
2204 gate_lto_out
, /* gate */
2208 0, /* static_pass_number */
2209 TV_IPA_LTO_GIMPLE_OUT
, /* tv_id */
2210 0, /* properties_required */
2211 0, /* properties_provided */
2212 0, /* properties_destroyed */
2213 0, /* todo_flags_start */
2214 TODO_dump_func
/* todo_flags_finish */
2216 NULL
, /* generate_summary */
2217 lto_output
, /* write_summary */
2218 NULL
, /* read_summary */
2219 lto_output
, /* write_optimization_summary */
2220 NULL
, /* read_optimization_summary */
2221 NULL
, /* stmt_fixup */
2223 NULL
, /* function_transform */
2224 NULL
/* variable_transform */
2228 /* Write each node in encoded by ENCODER to OB, as well as those reachable
2229 from it and required for correct representation of its semantics.
2230 Each node in ENCODER must be a global declaration or a type. A node
2231 is written only once, even if it appears multiple times in the
2232 vector. Certain transitively-reachable nodes, such as those
2233 representing expressions, may be duplicated, but such nodes
2234 must not appear in ENCODER itself. */
2237 write_global_stream (struct output_block
*ob
,
2238 struct lto_tree_ref_encoder
*encoder
)
2242 const size_t size
= lto_tree_ref_encoder_size (encoder
);
2244 for (index
= 0; index
< size
; index
++)
2246 t
= lto_tree_ref_encoder_get_tree (encoder
, index
);
2247 if (!lto_streamer_cache_lookup (ob
->writer_cache
, t
, NULL
))
2248 lto_output_tree (ob
, t
, false);
2253 /* Write a sequence of indices into the globals vector corresponding
2254 to the trees in ENCODER. These are used by the reader to map the
2255 indices used to refer to global entities within function bodies to
2259 write_global_references (struct output_block
*ob
,
2260 struct lto_output_stream
*ref_stream
,
2261 struct lto_tree_ref_encoder
*encoder
)
2265 const int32_t size
= lto_tree_ref_encoder_size (encoder
);
2267 /* Write size as 32-bit unsigned. */
2268 lto_output_data_stream (ref_stream
, &size
, sizeof (int32_t));
2270 for (index
= 0; index
< size
; index
++)
2274 t
= lto_tree_ref_encoder_get_tree (encoder
, index
);
2275 lto_streamer_cache_lookup (ob
->writer_cache
, t
, &slot_num
);
2276 gcc_assert (slot_num
>= 0);
2277 lto_output_data_stream (ref_stream
, &slot_num
, sizeof slot_num
);
2282 /* Write all the streams in an lto_out_decl_state STATE using
2283 output block OB and output stream OUT_STREAM. */
2286 lto_output_decl_state_streams (struct output_block
*ob
,
2287 struct lto_out_decl_state
*state
)
2291 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2292 write_global_stream (ob
, &state
->streams
[i
]);
2296 /* Write all the references in an lto_out_decl_state STATE using
2297 output block OB and output stream OUT_STREAM. */
2300 lto_output_decl_state_refs (struct output_block
*ob
,
2301 struct lto_output_stream
*out_stream
,
2302 struct lto_out_decl_state
*state
)
2308 /* Write reference to FUNCTION_DECL. If there is not function,
2309 write reference to void_type_node. */
2310 decl
= (state
->fn_decl
) ? state
->fn_decl
: void_type_node
;
2311 lto_streamer_cache_lookup (ob
->writer_cache
, decl
, &ref
);
2312 gcc_assert (ref
>= 0);
2313 lto_output_data_stream (out_stream
, &ref
, sizeof (int32_t));
2315 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2316 write_global_references (ob
, out_stream
, &state
->streams
[i
]);
2320 /* Return the written size of STATE. */
2323 lto_out_decl_state_written_size (struct lto_out_decl_state
*state
)
2328 size
= sizeof (int32_t); /* fn_ref. */
2329 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2331 size
+= sizeof (int32_t); /* vector size. */
2332 size
+= (lto_tree_ref_encoder_size (&state
->streams
[i
])
2333 * sizeof (int32_t));
2339 /* Write symbol T into STREAM in CACHE. SEEN specify symbols we wrote so
2343 write_symbol (struct lto_streamer_cache_d
*cache
,
2344 struct lto_output_stream
*stream
,
2345 tree t
, bitmap seen
, bool alias
)
2348 enum gcc_plugin_symbol_kind kind
;
2349 enum gcc_plugin_symbol_visibility visibility
;
2354 /* None of the following kinds of symbols are needed in the
2356 if (!TREE_PUBLIC (t
)
2357 || is_builtin_fn (t
)
2358 || DECL_ABSTRACT (t
)
2359 || TREE_CODE (t
) == RESULT_DECL
)
2362 gcc_assert (TREE_CODE (t
) == VAR_DECL
2363 || TREE_CODE (t
) == FUNCTION_DECL
);
2365 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (t
));
2367 /* FIXME lto: this is from assemble_name_raw in varasm.c. For some
2368 architectures we might have to do the same name manipulations that
2369 ASM_OUTPUT_LABELREF does. */
2373 lto_streamer_cache_lookup (cache
, t
, &slot_num
);
2374 gcc_assert (slot_num
>= 0);
2376 /* Avoid duplicate symbols. */
2377 if (!bitmap_set_bit (seen
, slot_num
))
2380 if (DECL_EXTERNAL (t
))
2383 kind
= GCCPK_WEAKUNDEF
;
2390 kind
= GCCPK_WEAKDEF
;
2391 else if (DECL_COMMON (t
))
2392 kind
= GCCPK_COMMON
;
2396 /* When something is defined, it should have a node attached.
2397 FIXME: For fortran this is still not the case since wrapup global
2398 decls is done after streaming. */
2399 gcc_assert (alias
|| TREE_CODE (t
) != FUNCTION_DECL
2400 || (cgraph_get_node (t
)
2401 && cgraph_get_node (t
)->analyzed
));
2404 /* Imitate what default_elf_asm_output_external do.
2405 When symbol is external, we need to output it with DEFAULT visibility
2406 when compiling with -fvisibility=default, while with HIDDEN visibility
2407 when symbol has attribute (visibility("hidden")) specified.
2408 targetm.binds_local_p check DECL_VISIBILITY_SPECIFIED and gets this
2411 if (DECL_EXTERNAL (t
)
2412 && !targetm
.binds_local_p (t
))
2413 visibility
= GCCPV_DEFAULT
;
2415 switch (DECL_VISIBILITY(t
))
2417 case VISIBILITY_DEFAULT
:
2418 visibility
= GCCPV_DEFAULT
;
2420 case VISIBILITY_PROTECTED
:
2421 visibility
= GCCPV_PROTECTED
;
2423 case VISIBILITY_HIDDEN
:
2424 visibility
= GCCPV_HIDDEN
;
2426 case VISIBILITY_INTERNAL
:
2427 visibility
= GCCPV_INTERNAL
;
2431 if (kind
== GCCPK_COMMON
2433 && TREE_CODE (DECL_SIZE (t
)) == INTEGER_CST
)
2434 size
= (((uint64_t) TREE_INT_CST_HIGH (DECL_SIZE (t
))) << 32)
2435 | TREE_INT_CST_LOW (DECL_SIZE (t
));
2439 if (DECL_ONE_ONLY (t
))
2440 comdat
= IDENTIFIER_POINTER (DECL_COMDAT_GROUP (t
));
2444 lto_output_data_stream (stream
, name
, strlen (name
) + 1);
2445 lto_output_data_stream (stream
, comdat
, strlen (comdat
) + 1);
2446 lto_output_data_stream (stream
, &kind
, 1);
2447 lto_output_data_stream (stream
, &visibility
, 1);
2448 lto_output_data_stream (stream
, &size
, 8);
2449 lto_output_data_stream (stream
, &slot_num
, 4);
2453 /* Write an IL symbol table to OB.
2454 SET and VSET are cgraph/varpool node sets we are outputting. */
2457 produce_symtab (struct output_block
*ob
,
2458 cgraph_node_set set
, varpool_node_set vset
)
2460 struct lto_streamer_cache_d
*cache
= ob
->writer_cache
;
2461 char *section_name
= lto_get_section_name (LTO_section_symtab
, NULL
, NULL
);
2463 struct cgraph_node
*node
, *alias
;
2464 struct varpool_node
*vnode
, *valias
;
2465 struct lto_output_stream stream
;
2466 lto_varpool_encoder_t varpool_encoder
= ob
->decl_state
->varpool_node_encoder
;
2467 lto_cgraph_encoder_t encoder
= ob
->decl_state
->cgraph_node_encoder
;
2471 lto_begin_section (section_name
, false);
2472 free (section_name
);
2474 seen
= lto_bitmap_alloc ();
2475 memset (&stream
, 0, sizeof (stream
));
2477 /* Write all functions. */
2478 for (i
= 0; i
< lto_cgraph_encoder_size (encoder
); i
++)
2480 node
= lto_cgraph_encoder_deref (encoder
, i
);
2483 write_symbol (cache
, &stream
, node
->decl
, seen
, false);
2484 for (alias
= node
->same_body
; alias
; alias
= alias
->next
)
2485 write_symbol (cache
, &stream
, alias
->decl
, seen
, true);
2488 /* Write all variables. */
2489 for (i
= 0; i
< lto_varpool_encoder_size (varpool_encoder
); i
++)
2491 vnode
= lto_varpool_encoder_deref (varpool_encoder
, i
);
2494 write_symbol (cache
, &stream
, vnode
->decl
, seen
, false);
2495 for (valias
= vnode
->extra_name
; valias
; valias
= valias
->next
)
2496 write_symbol (cache
, &stream
, valias
->decl
, seen
, true);
2499 /* Write all aliases. */
2500 FOR_EACH_VEC_ELT (alias_pair
, alias_pairs
, i
, p
)
2501 if (output_alias_pair_p (p
, set
, vset
))
2502 write_symbol (cache
, &stream
, p
->decl
, seen
, true);
2504 lto_write_stream (&stream
);
2505 lto_bitmap_free (seen
);
2511 /* This pass is run after all of the functions are serialized and all
2512 of the IPA passes have written their serialized forms. This pass
2513 causes the vector of all of the global decls and types used from
2514 this file to be written in to a section that can then be read in to
2515 recover these on other side. */
2518 produce_asm_for_decls (cgraph_node_set set
, varpool_node_set vset
)
2520 struct lto_out_decl_state
*out_state
;
2521 struct lto_out_decl_state
*fn_out_state
;
2522 struct lto_decl_header header
;
2524 struct output_block
*ob
;
2525 struct lto_output_stream
*header_stream
, *decl_state_stream
;
2526 unsigned idx
, num_fns
;
2527 size_t decl_state_size
;
2528 int32_t num_decl_states
;
2530 ob
= create_output_block (LTO_section_decls
);
2533 /* Write out unreferenced globals, alias pairs and labels. We defer
2534 doing this until now so that we can write out only what is
2536 output_unreferenced_globals (set
, vset
);
2538 memset (&header
, 0, sizeof (struct lto_decl_header
));
2540 section_name
= lto_get_section_name (LTO_section_decls
, NULL
, NULL
);
2541 lto_begin_section (section_name
, !flag_wpa
);
2542 free (section_name
);
2544 /* Make string 0 be a NULL string. */
2545 lto_output_1_stream (ob
->string_stream
, 0);
2547 /* Write the global symbols. */
2548 out_state
= lto_get_out_decl_state ();
2549 num_fns
= VEC_length (lto_out_decl_state_ptr
, lto_function_decl_states
);
2550 lto_output_decl_state_streams (ob
, out_state
);
2551 for (idx
= 0; idx
< num_fns
; idx
++)
2554 VEC_index (lto_out_decl_state_ptr
, lto_function_decl_states
, idx
);
2555 lto_output_decl_state_streams (ob
, fn_out_state
);
2558 header
.lto_header
.major_version
= LTO_major_version
;
2559 header
.lto_header
.minor_version
= LTO_minor_version
;
2560 header
.lto_header
.section_type
= LTO_section_decls
;
2562 /* Currently not used. This field would allow us to preallocate
2563 the globals vector, so that it need not be resized as it is extended. */
2564 header
.num_nodes
= -1;
2566 /* Compute the total size of all decl out states. */
2567 decl_state_size
= sizeof (int32_t);
2568 decl_state_size
+= lto_out_decl_state_written_size (out_state
);
2569 for (idx
= 0; idx
< num_fns
; idx
++)
2572 VEC_index (lto_out_decl_state_ptr
, lto_function_decl_states
, idx
);
2573 decl_state_size
+= lto_out_decl_state_written_size (fn_out_state
);
2575 header
.decl_state_size
= decl_state_size
;
2577 header
.main_size
= ob
->main_stream
->total_size
;
2578 header
.string_size
= ob
->string_stream
->total_size
;
2580 header_stream
= XCNEW (struct lto_output_stream
);
2581 lto_output_data_stream (header_stream
, &header
, sizeof header
);
2582 lto_write_stream (header_stream
);
2583 free (header_stream
);
2585 /* Write the main out-decl state, followed by out-decl states of
2587 decl_state_stream
= ((struct lto_output_stream
*)
2588 xcalloc (1, sizeof (struct lto_output_stream
)));
2589 num_decl_states
= num_fns
+ 1;
2590 lto_output_data_stream (decl_state_stream
, &num_decl_states
,
2591 sizeof (num_decl_states
));
2592 lto_output_decl_state_refs (ob
, decl_state_stream
, out_state
);
2593 for (idx
= 0; idx
< num_fns
; idx
++)
2596 VEC_index (lto_out_decl_state_ptr
, lto_function_decl_states
, idx
);
2597 lto_output_decl_state_refs (ob
, decl_state_stream
, fn_out_state
);
2599 lto_write_stream (decl_state_stream
);
2600 free(decl_state_stream
);
2602 lto_write_stream (ob
->main_stream
);
2603 lto_write_stream (ob
->string_stream
);
2607 /* Write the symbol table. It is used by linker to determine dependencies
2608 and thus we can skip it for WPA. */
2610 produce_symtab (ob
, set
, vset
);
2612 /* Write command line opts. */
2613 lto_write_options ();
2615 /* Deallocate memory and clean up. */
2616 for (idx
= 0; idx
< num_fns
; idx
++)
2619 VEC_index (lto_out_decl_state_ptr
, lto_function_decl_states
, idx
);
2620 lto_delete_out_decl_state (fn_out_state
);
2622 lto_cgraph_encoder_delete (ob
->decl_state
->cgraph_node_encoder
);
2623 lto_varpool_encoder_delete (ob
->decl_state
->varpool_node_encoder
);
2624 VEC_free (lto_out_decl_state_ptr
, heap
, lto_function_decl_states
);
2625 lto_function_decl_states
= NULL
;
2626 destroy_output_block (ob
);
2630 struct ipa_opt_pass_d pass_ipa_lto_finish_out
=
2634 "lto_decls_out", /* name */
2635 gate_lto_out
, /* gate */
2639 0, /* static_pass_number */
2640 TV_IPA_LTO_DECL_OUT
, /* tv_id */
2641 0, /* properties_required */
2642 0, /* properties_provided */
2643 0, /* properties_destroyed */
2644 0, /* todo_flags_start */
2645 0 /* todo_flags_finish */
2647 NULL
, /* generate_summary */
2648 produce_asm_for_decls
, /* write_summary */
2649 NULL
, /* read_summary */
2650 produce_asm_for_decls
, /* write_optimization_summary */
2651 NULL
, /* read_optimization_summary */
2652 NULL
, /* stmt_fixup */
2654 NULL
, /* function_transform */
2655 NULL
/* variable_transform */