1 /* Write the GIMPLE representation to a file stream.
3 Copyright 2009 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"
35 #include "basic-block.h"
36 #include "tree-flow.h"
37 #include "tree-pass.h"
41 #include "diagnostic.h"
44 #include "lto-symtab.h"
45 #include "lto-streamer.h"
52 unsigned int slot_num
;
56 /* Returns a hash code for P. */
59 hash_string_slot_node (const void *p
)
61 const struct string_slot
*ds
= (const struct string_slot
*) p
;
62 return (hashval_t
) htab_hash_string (ds
->s
);
66 /* Returns nonzero if P1 and P2 are equal. */
69 eq_string_slot_node (const void *p1
, const void *p2
)
71 const struct string_slot
*ds1
= (const struct string_slot
*) p1
;
72 const struct string_slot
*ds2
= (const struct string_slot
*) p2
;
74 if (ds1
->len
== ds2
->len
)
77 for (i
= 0; i
< ds1
->len
; i
++)
78 if (ds1
->s
[i
] != ds2
->s
[i
])
87 /* Free the string slot pointed-to by P. */
90 string_slot_free (void *p
)
92 struct string_slot
*slot
= (struct string_slot
*) p
;
93 free (CONST_CAST (void *, (const void *) slot
->s
));
98 /* Clear the line info stored in DATA_IN. */
101 clear_line_info (struct output_block
*ob
)
103 ob
->current_file
= NULL
;
104 ob
->current_line
= 0;
109 /* Create the output block and return it. SECTION_TYPE is
110 LTO_section_function_body or LTO_static_initializer. */
112 struct output_block
*
113 create_output_block (enum lto_section_type section_type
)
115 struct output_block
*ob
= XCNEW (struct output_block
);
117 ob
->section_type
= section_type
;
118 ob
->decl_state
= lto_get_out_decl_state ();
119 ob
->main_stream
= XCNEW (struct lto_output_stream
);
120 ob
->string_stream
= XCNEW (struct lto_output_stream
);
121 ob
->writer_cache
= lto_streamer_cache_create ();
123 if (section_type
== LTO_section_function_body
)
124 ob
->cfg_stream
= XCNEW (struct lto_output_stream
);
126 clear_line_info (ob
);
128 ob
->string_hash_table
= htab_create (37, hash_string_slot_node
,
129 eq_string_slot_node
, string_slot_free
);
135 /* Destroy the output block OB. */
138 destroy_output_block (struct output_block
*ob
)
140 enum lto_section_type section_type
= ob
->section_type
;
142 htab_delete (ob
->string_hash_table
);
144 free (ob
->main_stream
);
145 free (ob
->string_stream
);
146 if (section_type
== LTO_section_function_body
)
147 free (ob
->cfg_stream
);
149 lto_streamer_cache_delete (ob
->writer_cache
);
155 /* Output bitpack BP to output stream S. */
158 lto_output_bitpack (struct lto_output_stream
*s
, struct bitpack_d
*bp
)
163 lto_output_uleb128_stream (s
, VEC_length (bitpack_word_t
, bp
->values
));
164 for (i
= 0; VEC_iterate (bitpack_word_t
, bp
->values
, i
, v
); i
++)
165 lto_output_uleb128_stream (s
, v
);
169 /* Output STRING of LEN characters to the string
170 table in OB. The string might or might not include a trailing '\0'.
171 Then put the index onto the INDEX_STREAM. */
174 output_string_with_length (struct output_block
*ob
,
175 struct lto_output_stream
*index_stream
,
179 struct string_slot
**slot
;
180 struct string_slot s_slot
;
181 char *string
= (char *) xmalloc (len
+ 1);
182 memcpy (string
, s
, len
);
189 slot
= (struct string_slot
**) htab_find_slot (ob
->string_hash_table
,
193 struct lto_output_stream
*string_stream
= ob
->string_stream
;
194 unsigned int start
= string_stream
->total_size
;
195 struct string_slot
*new_slot
196 = (struct string_slot
*) xmalloc (sizeof (struct string_slot
));
199 new_slot
->s
= string
;
201 new_slot
->slot_num
= start
;
203 lto_output_uleb128_stream (index_stream
, start
);
204 lto_output_uleb128_stream (string_stream
, len
);
205 for (i
= 0; i
< len
; i
++)
206 lto_output_1_stream (string_stream
, string
[i
]);
210 struct string_slot
*old_slot
= (struct string_slot
*)*slot
;
211 lto_output_uleb128_stream (index_stream
, old_slot
->slot_num
);
216 /* Output the '\0' terminated STRING to the string
217 table in OB. Then put the index onto the INDEX_STREAM. */
220 output_string (struct output_block
*ob
,
221 struct lto_output_stream
*index_stream
,
226 lto_output_uleb128_stream (index_stream
, 0);
227 output_string_with_length (ob
, index_stream
, string
, strlen (string
) + 1);
230 lto_output_uleb128_stream (index_stream
, 1);
234 /* Output the STRING constant to the string
235 table in OB. Then put the index onto the INDEX_STREAM. */
238 output_string_cst (struct output_block
*ob
,
239 struct lto_output_stream
*index_stream
,
244 lto_output_uleb128_stream (index_stream
, 0);
245 output_string_with_length (ob
, index_stream
,
246 TREE_STRING_POINTER (string
),
247 TREE_STRING_LENGTH (string
));
250 lto_output_uleb128_stream (index_stream
, 1);
254 /* Output the identifier ID to the string
255 table in OB. Then put the index onto the INDEX_STREAM. */
258 output_identifier (struct output_block
*ob
,
259 struct lto_output_stream
*index_stream
,
264 lto_output_uleb128_stream (index_stream
, 0);
265 output_string_with_length (ob
, index_stream
,
266 IDENTIFIER_POINTER (id
),
267 IDENTIFIER_LENGTH (id
));
270 lto_output_uleb128_stream (index_stream
, 1);
273 /* Write a zero to the output stream. */
276 output_zero (struct output_block
*ob
)
278 lto_output_1_stream (ob
->main_stream
, 0);
282 /* Output an unsigned LEB128 quantity to OB->main_stream. */
285 output_uleb128 (struct output_block
*ob
, unsigned HOST_WIDE_INT work
)
287 lto_output_uleb128_stream (ob
->main_stream
, work
);
291 /* Output a signed LEB128 quantity to OB->main_stream. */
294 output_sleb128 (struct output_block
*ob
, HOST_WIDE_INT work
)
296 lto_output_sleb128_stream (ob
->main_stream
, work
);
300 /* Output the start of a record with TAG to output block OB. */
303 output_record_start (struct output_block
*ob
, enum LTO_tags tag
)
305 /* Make sure TAG fits inside an unsigned int. */
306 gcc_assert (tag
== (enum LTO_tags
) (unsigned) tag
);
307 output_uleb128 (ob
, tag
);
311 /* Look up NODE in the type table and write the index for it to OB. */
314 output_type_ref (struct output_block
*ob
, tree node
)
316 output_record_start (ob
, LTO_type_ref
);
317 lto_output_type_ref_index (ob
->decl_state
, ob
->main_stream
, node
);
321 /* Pack all the non-pointer fields of the TS_BASE structure of
322 expression EXPR into bitpack BP. */
325 pack_ts_base_value_fields (struct bitpack_d
*bp
, tree expr
)
327 bp_pack_value (bp
, TREE_CODE (expr
), 16);
330 bp_pack_value (bp
, TREE_SIDE_EFFECTS (expr
), 1);
331 bp_pack_value (bp
, TREE_CONSTANT (expr
), 1);
332 bp_pack_value (bp
, TREE_READONLY (expr
), 1);
334 /* TREE_PUBLIC is used on types to indicate that the type
335 has a TYPE_CACHED_VALUES vector. This is not streamed out,
336 so we skip it here. */
337 bp_pack_value (bp
, TREE_PUBLIC (expr
), 1);
339 bp_pack_value (bp
, TREE_ADDRESSABLE (expr
), 1);
340 bp_pack_value (bp
, TREE_THIS_VOLATILE (expr
), 1);
342 bp_pack_value (bp
, DECL_UNSIGNED (expr
), 1);
343 else if (TYPE_P (expr
))
344 bp_pack_value (bp
, TYPE_UNSIGNED (expr
), 1);
345 /* We write debug info two times, do not confuse the second one. */
346 bp_pack_value (bp
, TYPE_P (expr
) ? 0 : TREE_ASM_WRITTEN (expr
), 1);
347 bp_pack_value (bp
, TREE_NO_WARNING (expr
), 1);
348 bp_pack_value (bp
, TREE_USED (expr
), 1);
349 bp_pack_value (bp
, TREE_NOTHROW (expr
), 1);
350 bp_pack_value (bp
, TREE_STATIC (expr
), 1);
351 bp_pack_value (bp
, TREE_PRIVATE (expr
), 1);
352 bp_pack_value (bp
, TREE_PROTECTED (expr
), 1);
353 bp_pack_value (bp
, TREE_DEPRECATED (expr
), 1);
355 bp_pack_value (bp
, TYPE_SATURATING (expr
), 1);
356 if (TREE_CODE (expr
) == SSA_NAME
)
357 bp_pack_value (bp
, SSA_NAME_IS_DEFAULT_DEF (expr
), 1);
361 /* Pack all the non-pointer fields of the TS_REAL_CST structure of
362 expression EXPR into bitpack BP. */
365 pack_ts_real_cst_value_fields (struct bitpack_d
*bp
, tree expr
)
370 r
= TREE_REAL_CST (expr
);
371 bp_pack_value (bp
, r
.cl
, 2);
372 bp_pack_value (bp
, r
.decimal
, 1);
373 bp_pack_value (bp
, r
.sign
, 1);
374 bp_pack_value (bp
, r
.signalling
, 1);
375 bp_pack_value (bp
, r
.canonical
, 1);
376 bp_pack_value (bp
, r
.uexp
, EXP_BITS
);
377 for (i
= 0; i
< SIGSZ
; i
++)
378 bp_pack_value (bp
, r
.sig
[i
], HOST_BITS_PER_LONG
);
382 /* Pack all the non-pointer fields of the TS_FIXED_CST structure of
383 expression EXPR into bitpack BP. */
386 pack_ts_fixed_cst_value_fields (struct bitpack_d
*bp
, tree expr
)
388 struct fixed_value fv
= TREE_FIXED_CST (expr
);
389 bp_pack_value (bp
, fv
.data
.low
, HOST_BITS_PER_WIDE_INT
);
390 bp_pack_value (bp
, fv
.data
.high
, HOST_BITS_PER_WIDE_INT
);
394 /* Pack all the non-pointer fields of the TS_DECL_COMMON structure
395 of expression EXPR into bitpack BP. */
398 pack_ts_decl_common_value_fields (struct bitpack_d
*bp
, tree expr
)
400 bp_pack_value (bp
, DECL_MODE (expr
), 8);
401 bp_pack_value (bp
, DECL_NONLOCAL (expr
), 1);
402 bp_pack_value (bp
, DECL_VIRTUAL_P (expr
), 1);
403 bp_pack_value (bp
, DECL_IGNORED_P (expr
), 1);
404 bp_pack_value (bp
, DECL_ABSTRACT (expr
), 1);
405 bp_pack_value (bp
, DECL_ARTIFICIAL (expr
), 1);
406 bp_pack_value (bp
, DECL_USER_ALIGN (expr
), 1);
407 bp_pack_value (bp
, DECL_PRESERVE_P (expr
), 1);
408 bp_pack_value (bp
, DECL_DEBUG_EXPR_IS_FROM (expr
), 1);
409 bp_pack_value (bp
, DECL_EXTERNAL (expr
), 1);
410 bp_pack_value (bp
, DECL_GIMPLE_REG_P (expr
), 1);
411 bp_pack_value (bp
, DECL_ALIGN (expr
), HOST_BITS_PER_INT
);
413 if (TREE_CODE (expr
) == LABEL_DECL
)
415 /* Note that we do not write LABEL_DECL_UID. The reader will
416 always assume an initial value of -1 so that the
417 label_to_block_map is recreated by gimple_set_bb. */
418 bp_pack_value (bp
, DECL_ERROR_ISSUED (expr
), 1);
419 bp_pack_value (bp
, EH_LANDING_PAD_NR (expr
), HOST_BITS_PER_INT
);
422 if (TREE_CODE (expr
) == FIELD_DECL
)
424 bp_pack_value (bp
, DECL_PACKED (expr
), 1);
425 bp_pack_value (bp
, DECL_NONADDRESSABLE_P (expr
), 1);
426 bp_pack_value (bp
, DECL_OFFSET_ALIGN (expr
), 8);
429 if (TREE_CODE (expr
) == RESULT_DECL
430 || TREE_CODE (expr
) == PARM_DECL
431 || TREE_CODE (expr
) == VAR_DECL
)
433 bp_pack_value (bp
, DECL_BY_REFERENCE (expr
), 1);
434 if (TREE_CODE (expr
) == VAR_DECL
435 || TREE_CODE (expr
) == PARM_DECL
)
436 bp_pack_value (bp
, DECL_HAS_VALUE_EXPR_P (expr
), 1);
437 bp_pack_value (bp
, DECL_RESTRICTED_P (expr
), 1);
442 /* Pack all the non-pointer fields of the TS_DECL_WRTL structure
443 of expression EXPR into bitpack BP. */
446 pack_ts_decl_wrtl_value_fields (struct bitpack_d
*bp
, tree expr
)
448 bp_pack_value (bp
, DECL_REGISTER (expr
), 1);
452 /* Pack all the non-pointer fields of the TS_DECL_WITH_VIS structure
453 of expression EXPR into bitpack BP. */
456 pack_ts_decl_with_vis_value_fields (struct bitpack_d
*bp
, tree expr
)
458 bp_pack_value (bp
, DECL_DEFER_OUTPUT (expr
), 1);
459 bp_pack_value (bp
, DECL_COMMON (expr
), 1);
460 bp_pack_value (bp
, DECL_DLLIMPORT_P (expr
), 1);
461 bp_pack_value (bp
, DECL_WEAK (expr
), 1);
462 bp_pack_value (bp
, DECL_SEEN_IN_BIND_EXPR_P (expr
), 1);
463 bp_pack_value (bp
, DECL_COMDAT (expr
), 1);
464 bp_pack_value (bp
, DECL_VISIBILITY (expr
), 2);
465 bp_pack_value (bp
, DECL_VISIBILITY_SPECIFIED (expr
), 1);
467 if (TREE_CODE (expr
) == VAR_DECL
)
469 bp_pack_value (bp
, DECL_HARD_REGISTER (expr
), 1);
470 bp_pack_value (bp
, DECL_IN_TEXT_SECTION (expr
), 1);
471 bp_pack_value (bp
, DECL_TLS_MODEL (expr
), 3);
474 if (VAR_OR_FUNCTION_DECL_P (expr
))
475 bp_pack_value (bp
, DECL_INIT_PRIORITY (expr
), HOST_BITS_PER_SHORT
);
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_value (bp
, DECL_FUNCTION_CODE (expr
), 11);
490 bp_pack_value (bp
, DECL_BUILT_IN_CLASS (expr
), 2);
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);
510 /* Pack all the non-pointer fields of the TS_TYPE structure
511 of expression EXPR into bitpack BP. */
514 pack_ts_type_value_fields (struct bitpack_d
*bp
, tree expr
)
516 bp_pack_value (bp
, TYPE_PRECISION (expr
), 9);
517 bp_pack_value (bp
, TYPE_MODE (expr
), 7);
518 bp_pack_value (bp
, TYPE_STRING_FLAG (expr
), 1);
519 bp_pack_value (bp
, TYPE_NO_FORCE_BLK (expr
), 1);
520 bp_pack_value (bp
, TYPE_NEEDS_CONSTRUCTING(expr
), 1);
521 if (TREE_CODE (expr
) == UNION_TYPE
)
522 bp_pack_value (bp
, TYPE_TRANSPARENT_UNION (expr
), 1);
523 bp_pack_value (bp
, TYPE_PACKED (expr
), 1);
524 bp_pack_value (bp
, TYPE_RESTRICT (expr
), 1);
525 bp_pack_value (bp
, TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr
), 2);
526 bp_pack_value (bp
, TYPE_USER_ALIGN (expr
), 1);
527 bp_pack_value (bp
, TYPE_READONLY (expr
), 1);
528 bp_pack_value (bp
, TYPE_ALIGN (expr
), HOST_BITS_PER_INT
);
529 bp_pack_value (bp
, TYPE_ALIAS_SET (expr
) == 0 ? 0 : -1, HOST_BITS_PER_INT
);
533 /* Pack all the non-pointer fields of the TS_BLOCK structure
534 of expression EXPR into bitpack BP. */
537 pack_ts_block_value_fields (struct bitpack_d
*bp
, tree expr
)
539 bp_pack_value (bp
, BLOCK_ABSTRACT (expr
), 1);
540 bp_pack_value (bp
, BLOCK_NUMBER (expr
), 31);
544 /* Pack all the non-pointer fields in EXPR into a bit pack. */
546 static struct bitpack_d
*
547 pack_value_fields (tree expr
)
550 struct bitpack_d
*bp
;
552 code
= TREE_CODE (expr
);
553 bp
= bitpack_create ();
555 /* Note that all these functions are highly sensitive to changes in
556 the types and sizes of each of the fields being packed. */
557 pack_ts_base_value_fields (bp
, expr
);
559 if (CODE_CONTAINS_STRUCT (code
, TS_REAL_CST
))
560 pack_ts_real_cst_value_fields (bp
, expr
);
562 if (CODE_CONTAINS_STRUCT (code
, TS_FIXED_CST
))
563 pack_ts_fixed_cst_value_fields (bp
, expr
);
565 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
566 pack_ts_decl_common_value_fields (bp
, expr
);
568 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WRTL
))
569 pack_ts_decl_wrtl_value_fields (bp
, expr
);
571 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
572 pack_ts_decl_with_vis_value_fields (bp
, expr
);
574 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
575 pack_ts_function_decl_value_fields (bp
, expr
);
577 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE
))
578 pack_ts_type_value_fields (bp
, expr
);
580 if (CODE_CONTAINS_STRUCT (code
, TS_BLOCK
))
581 pack_ts_block_value_fields (bp
, expr
);
583 if (CODE_CONTAINS_STRUCT (code
, TS_SSA_NAME
))
585 /* We only stream the version number of SSA names. */
589 if (CODE_CONTAINS_STRUCT (code
, TS_STATEMENT_LIST
))
591 /* This is only used by GENERIC. */
595 if (CODE_CONTAINS_STRUCT (code
, TS_OMP_CLAUSE
))
597 /* This is only used by High GIMPLE. */
605 /* Emit location LOC to output block OB. */
608 lto_output_location (struct output_block
*ob
, location_t loc
)
610 expanded_location xloc
;
612 if (loc
== UNKNOWN_LOCATION
)
614 output_string (ob
, ob
->main_stream
, NULL
);
618 xloc
= expand_location (loc
);
620 output_string (ob
, ob
->main_stream
, xloc
.file
);
621 output_sleb128 (ob
, xloc
.line
);
622 output_sleb128 (ob
, xloc
.column
);
623 output_sleb128 (ob
, xloc
.sysp
);
625 ob
->current_file
= xloc
.file
;
626 ob
->current_line
= xloc
.line
;
627 ob
->current_col
= xloc
.column
;
631 /* Return true if tree node T is written to various tables. For these
632 nodes, we sometimes want to write their phyiscal representation
633 (via lto_output_tree), and sometimes we need to emit an index
634 reference into a table (via lto_output_tree_ref). */
637 tree_is_indexable (tree t
)
639 if (TREE_CODE (t
) == PARM_DECL
)
641 else if (TREE_CODE (t
) == VAR_DECL
&& decl_function_context (t
))
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 output_record_start (ob
, LTO_global_decl_ref
);
699 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
703 output_record_start (ob
, LTO_const_decl_ref
);
704 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
708 gcc_assert (decl_function_context (expr
) == NULL
);
709 output_record_start (ob
, LTO_imported_decl_ref
);
710 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
714 output_record_start (ob
, LTO_type_decl_ref
);
715 lto_output_type_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
719 output_record_start (ob
, LTO_namespace_decl_ref
);
720 lto_output_namespace_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
724 output_record_start (ob
, LTO_label_decl_ref
);
725 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
729 output_record_start (ob
, LTO_result_decl_ref
);
730 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
734 /* No other node is indexable, so it should have been handled
735 by lto_output_tree. */
741 /* If REF_P is true, emit a reference to EXPR in output block OB,
742 otherwise emit the physical representation of EXPR in OB. */
745 lto_output_tree_or_ref (struct output_block
*ob
, tree expr
, bool ref_p
)
748 lto_output_tree_ref (ob
, expr
);
750 lto_output_tree (ob
, expr
, false);
754 /* Emit the chain of tree nodes starting at T. OB is the output block
755 to write to. REF_P is true if chain elements should be emitted
759 lto_output_chain (struct output_block
*ob
, tree t
, bool ref_p
)
763 count
= list_length (t
);
764 output_sleb128 (ob
, count
);
765 for (i
= 0; i
< count
; i
++)
769 /* Clear TREE_CHAIN to avoid blindly recursing into the rest
771 saved_chain
= TREE_CHAIN (t
);
772 TREE_CHAIN (t
) = NULL_TREE
;
774 lto_output_tree_or_ref (ob
, t
, ref_p
);
776 TREE_CHAIN (t
) = saved_chain
;
782 /* Write all pointer fields in the TS_COMMON structure of EXPR to output
783 block OB. If REF_P is true, write a reference to EXPR's pointer
787 lto_output_ts_common_tree_pointers (struct output_block
*ob
, tree expr
,
790 lto_output_tree_or_ref (ob
, TREE_TYPE (expr
), ref_p
);
794 /* Write all pointer fields in the TS_VECTOR structure of EXPR to output
795 block OB. If REF_P is true, write a reference to EXPR's pointer
799 lto_output_ts_vector_tree_pointers (struct output_block
*ob
, tree expr
,
802 lto_output_chain (ob
, TREE_VECTOR_CST_ELTS (expr
), ref_p
);
806 /* Write all pointer fields in the TS_COMPLEX structure of EXPR to output
807 block OB. If REF_P is true, write a reference to EXPR's pointer
811 lto_output_ts_complex_tree_pointers (struct output_block
*ob
, tree expr
,
814 lto_output_tree_or_ref (ob
, TREE_REALPART (expr
), ref_p
);
815 lto_output_tree_or_ref (ob
, TREE_IMAGPART (expr
), ref_p
);
819 /* Write all pointer fields in the TS_DECL_MINIMAL structure of EXPR
820 to output block OB. If REF_P is true, write a reference to EXPR's
824 lto_output_ts_decl_minimal_tree_pointers (struct output_block
*ob
, tree expr
,
827 lto_output_tree_or_ref (ob
, DECL_NAME (expr
), ref_p
);
828 lto_output_tree_or_ref (ob
, DECL_CONTEXT (expr
), ref_p
);
829 lto_output_location (ob
, DECL_SOURCE_LOCATION (expr
));
833 /* Write all pointer fields in the TS_DECL_COMMON structure of EXPR to
834 output block OB. If REF_P is true, write a reference to EXPR's
838 lto_output_ts_decl_common_tree_pointers (struct output_block
*ob
, tree expr
,
841 lto_output_tree_or_ref (ob
, DECL_SIZE (expr
), ref_p
);
842 lto_output_tree_or_ref (ob
, DECL_SIZE_UNIT (expr
), ref_p
);
844 if (TREE_CODE (expr
) != FUNCTION_DECL
)
845 lto_output_tree_or_ref (ob
, DECL_INITIAL (expr
), ref_p
);
847 lto_output_tree_or_ref (ob
, DECL_ATTRIBUTES (expr
), ref_p
);
848 lto_output_tree_or_ref (ob
, DECL_ABSTRACT_ORIGIN (expr
), ref_p
);
850 if (TREE_CODE (expr
) == PARM_DECL
)
851 lto_output_chain (ob
, TREE_CHAIN (expr
), ref_p
);
853 if ((TREE_CODE (expr
) == VAR_DECL
854 || TREE_CODE (expr
) == PARM_DECL
)
855 && DECL_HAS_VALUE_EXPR_P (expr
))
856 lto_output_tree_or_ref (ob
, DECL_VALUE_EXPR (expr
), ref_p
);
860 /* Write all pointer fields in the TS_DECL_NON_COMMON structure of
861 EXPR to output block OB. If REF_P is true, write a reference to EXPR's
865 lto_output_ts_decl_non_common_tree_pointers (struct output_block
*ob
,
866 tree expr
, bool ref_p
)
868 if (TREE_CODE (expr
) == FUNCTION_DECL
)
870 /* DECL_SAVED_TREE holds the GENERIC representation for DECL.
871 At this point, it should not exist. Either because it was
872 converted to gimple or because DECL didn't have a GENERIC
873 representation in this TU. */
874 gcc_assert (DECL_SAVED_TREE (expr
) == NULL_TREE
);
875 lto_output_tree_or_ref (ob
, DECL_ARGUMENTS (expr
), ref_p
);
876 lto_output_tree_or_ref (ob
, DECL_RESULT (expr
), ref_p
);
878 lto_output_tree_or_ref (ob
, DECL_VINDEX (expr
), ref_p
);
882 /* Write all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
883 to output block OB. If REF_P is true, write a reference to EXPR's
887 lto_output_ts_decl_with_vis_tree_pointers (struct output_block
*ob
, tree expr
,
890 /* Make sure we don't inadvertently set the assembler name. */
891 if (DECL_ASSEMBLER_NAME_SET_P (expr
))
892 lto_output_tree_or_ref (ob
, DECL_ASSEMBLER_NAME (expr
), ref_p
);
896 lto_output_tree_or_ref (ob
, DECL_SECTION_NAME (expr
), ref_p
);
897 lto_output_tree_or_ref (ob
, DECL_COMDAT_GROUP (expr
), ref_p
);
901 /* Write all pointer fields in the TS_FIELD_DECL structure of EXPR to
902 output block OB. If REF_P is true, write a reference to EXPR's
906 lto_output_ts_field_decl_tree_pointers (struct output_block
*ob
, tree expr
,
909 lto_output_tree_or_ref (ob
, DECL_FIELD_OFFSET (expr
), ref_p
);
910 lto_output_tree_or_ref (ob
, DECL_BIT_FIELD_TYPE (expr
), ref_p
);
911 lto_output_tree_or_ref (ob
, DECL_QUALIFIER (expr
), ref_p
);
912 lto_output_tree_or_ref (ob
, DECL_FIELD_BIT_OFFSET (expr
), ref_p
);
913 lto_output_tree_or_ref (ob
, DECL_FCONTEXT (expr
), ref_p
);
914 lto_output_chain (ob
, TREE_CHAIN (expr
), ref_p
);
918 /* Write all pointer fields in the TS_FUNCTION_DECL structure of EXPR
919 to output block OB. If REF_P is true, write a reference to EXPR's
923 lto_output_ts_function_decl_tree_pointers (struct output_block
*ob
, tree expr
,
926 /* DECL_STRUCT_FUNCTION is handled by lto_output_function. FIXME lto,
927 maybe it should be handled here? */
928 lto_output_tree_or_ref (ob
, DECL_FUNCTION_PERSONALITY (expr
), ref_p
);
929 lto_output_tree_or_ref (ob
, DECL_FUNCTION_SPECIFIC_TARGET (expr
), ref_p
);
930 lto_output_tree_or_ref (ob
, DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr
),
935 /* Write all pointer fields in the TS_TYPE structure of EXPR to output
936 block OB. If REF_P is true, write a reference to EXPR's pointer
940 lto_output_ts_type_tree_pointers (struct output_block
*ob
, tree expr
,
943 if (TREE_CODE (expr
) == ENUMERAL_TYPE
)
944 lto_output_tree_or_ref (ob
, TYPE_VALUES (expr
), ref_p
);
945 else if (TREE_CODE (expr
) == ARRAY_TYPE
)
946 lto_output_tree_or_ref (ob
, TYPE_DOMAIN (expr
), ref_p
);
947 else if (TREE_CODE (expr
) == RECORD_TYPE
|| TREE_CODE (expr
) == UNION_TYPE
)
948 lto_output_tree_or_ref (ob
, TYPE_FIELDS (expr
), ref_p
);
949 else if (TREE_CODE (expr
) == FUNCTION_TYPE
|| TREE_CODE (expr
) == METHOD_TYPE
)
950 lto_output_tree_or_ref (ob
, TYPE_ARG_TYPES (expr
), ref_p
);
951 else if (TREE_CODE (expr
) == VECTOR_TYPE
)
952 lto_output_tree_or_ref (ob
, TYPE_DEBUG_REPRESENTATION_TYPE (expr
), ref_p
);
954 lto_output_tree_or_ref (ob
, TYPE_SIZE (expr
), ref_p
);
955 lto_output_tree_or_ref (ob
, TYPE_SIZE_UNIT (expr
), ref_p
);
956 lto_output_tree_or_ref (ob
, TYPE_ATTRIBUTES (expr
), ref_p
);
957 lto_output_tree_or_ref (ob
, TYPE_NAME (expr
), ref_p
);
958 /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO nor
959 TYPE_NEXT_PTR_TO or TYPE_NEXT_REF_TO. */
960 if (!POINTER_TYPE_P (expr
))
961 lto_output_tree_or_ref (ob
, TYPE_MINVAL (expr
), ref_p
);
962 lto_output_tree_or_ref (ob
, TYPE_MAXVAL (expr
), ref_p
);
963 lto_output_tree_or_ref (ob
, TYPE_MAIN_VARIANT (expr
), ref_p
);
964 /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
966 if (TREE_CODE (expr
) == RECORD_TYPE
|| TREE_CODE (expr
) == UNION_TYPE
)
967 lto_output_tree_or_ref (ob
, TYPE_BINFO (expr
), ref_p
);
968 lto_output_tree_or_ref (ob
, TYPE_CONTEXT (expr
), ref_p
);
969 lto_output_tree_or_ref (ob
, TYPE_CANONICAL (expr
), ref_p
);
970 lto_output_tree_or_ref (ob
, TYPE_STUB_DECL (expr
), ref_p
);
974 /* Write all pointer fields in the TS_LIST structure of EXPR to output
975 block OB. If REF_P is true, write a reference to EXPR's pointer
979 lto_output_ts_list_tree_pointers (struct output_block
*ob
, tree expr
,
982 lto_output_tree_or_ref (ob
, TREE_PURPOSE (expr
), ref_p
);
983 lto_output_tree_or_ref (ob
, TREE_VALUE (expr
), ref_p
);
984 lto_output_chain (ob
, TREE_CHAIN (expr
), ref_p
);
988 /* Write all pointer fields in the TS_VEC structure of EXPR to output
989 block OB. If REF_P is true, write a reference to EXPR's pointer
993 lto_output_ts_vec_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
997 /* Note that the number of slots for EXPR has already been emitted
998 in EXPR's header (see lto_output_tree_header). */
999 for (i
= 0; i
< TREE_VEC_LENGTH (expr
); i
++)
1000 lto_output_tree_or_ref (ob
, TREE_VEC_ELT (expr
, i
), ref_p
);
1004 /* Write all pointer fields in the TS_EXP structure of EXPR to output
1005 block OB. If REF_P is true, write a reference to EXPR's pointer
1009 lto_output_ts_exp_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
1013 output_sleb128 (ob
, TREE_OPERAND_LENGTH (expr
));
1014 for (i
= 0; i
< TREE_OPERAND_LENGTH (expr
); i
++)
1015 lto_output_tree_or_ref (ob
, TREE_OPERAND (expr
, i
), ref_p
);
1016 lto_output_location (ob
, EXPR_LOCATION (expr
));
1017 lto_output_tree_or_ref (ob
, TREE_BLOCK (expr
), ref_p
);
1021 /* Write all pointer fields in the TS_BLOCK structure of EXPR to output
1022 block OB. If REF_P is true, write a reference to EXPR's pointer
1026 lto_output_ts_block_tree_pointers (struct output_block
*ob
, tree expr
,
1032 lto_output_location (ob
, BLOCK_SOURCE_LOCATION (expr
));
1033 lto_output_chain (ob
, BLOCK_VARS (expr
), ref_p
);
1035 output_uleb128 (ob
, VEC_length (tree
, BLOCK_NONLOCALIZED_VARS (expr
)));
1036 for (i
= 0; VEC_iterate (tree
, BLOCK_NONLOCALIZED_VARS (expr
), i
, t
); i
++)
1037 lto_output_tree_or_ref (ob
, t
, ref_p
);
1039 lto_output_tree_or_ref (ob
, BLOCK_SUPERCONTEXT (expr
), ref_p
);
1040 lto_output_tree_or_ref (ob
, BLOCK_ABSTRACT_ORIGIN (expr
), ref_p
);
1041 lto_output_tree_or_ref (ob
, BLOCK_FRAGMENT_ORIGIN (expr
), ref_p
);
1042 lto_output_tree_or_ref (ob
, BLOCK_FRAGMENT_CHAIN (expr
), ref_p
);
1043 lto_output_chain (ob
, BLOCK_SUBBLOCKS (expr
), ref_p
);
1047 /* Write all pointer fields in the TS_BINFO structure of EXPR to output
1048 block OB. If REF_P is true, write a reference to EXPR's pointer
1052 lto_output_ts_binfo_tree_pointers (struct output_block
*ob
, tree expr
,
1058 /* Note that the number of BINFO slots has already been emitted in
1059 EXPR's header (see lto_output_tree_header) because this length
1060 is needed to build the empty BINFO node on the reader side. */
1061 for (i
= 0; VEC_iterate (tree
, BINFO_BASE_BINFOS (expr
), i
, t
); i
++)
1062 lto_output_tree_or_ref (ob
, t
, ref_p
);
1065 lto_output_tree_or_ref (ob
, BINFO_OFFSET (expr
), ref_p
);
1066 lto_output_tree_or_ref (ob
, BINFO_VTABLE (expr
), ref_p
);
1067 lto_output_tree_or_ref (ob
, BINFO_VIRTUALS (expr
), ref_p
);
1068 lto_output_tree_or_ref (ob
, BINFO_VPTR_FIELD (expr
), ref_p
);
1070 output_uleb128 (ob
, VEC_length (tree
, BINFO_BASE_ACCESSES (expr
)));
1071 for (i
= 0; VEC_iterate (tree
, BINFO_BASE_ACCESSES (expr
), i
, t
); i
++)
1072 lto_output_tree_or_ref (ob
, t
, ref_p
);
1074 lto_output_tree_or_ref (ob
, BINFO_INHERITANCE_CHAIN (expr
), ref_p
);
1075 lto_output_tree_or_ref (ob
, BINFO_SUBVTT_INDEX (expr
), ref_p
);
1076 lto_output_tree_or_ref (ob
, BINFO_VPTR_INDEX (expr
), ref_p
);
1080 /* Write all pointer fields in the TS_CONSTRUCTOR structure of EXPR to
1081 output block OB. If REF_P is true, write a reference to EXPR's
1085 lto_output_ts_constructor_tree_pointers (struct output_block
*ob
, tree expr
,
1091 output_uleb128 (ob
, CONSTRUCTOR_NELTS (expr
));
1092 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (expr
), i
, index
, value
)
1094 lto_output_tree_or_ref (ob
, index
, ref_p
);
1095 lto_output_tree_or_ref (ob
, value
, ref_p
);
1100 /* Helper for lto_output_tree. Write all pointer fields in EXPR to output
1101 block OB. If REF_P is true, the leaves of EXPR are emitted as
1105 lto_output_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
1107 enum tree_code code
;
1109 code
= TREE_CODE (expr
);
1111 if (CODE_CONTAINS_STRUCT (code
, TS_COMMON
))
1112 lto_output_ts_common_tree_pointers (ob
, expr
, ref_p
);
1114 if (CODE_CONTAINS_STRUCT (code
, TS_VECTOR
))
1115 lto_output_ts_vector_tree_pointers (ob
, expr
, ref_p
);
1117 if (CODE_CONTAINS_STRUCT (code
, TS_COMPLEX
))
1118 lto_output_ts_complex_tree_pointers (ob
, expr
, ref_p
);
1120 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
1121 lto_output_ts_decl_minimal_tree_pointers (ob
, expr
, ref_p
);
1123 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
1124 lto_output_ts_decl_common_tree_pointers (ob
, expr
, ref_p
);
1126 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_NON_COMMON
))
1127 lto_output_ts_decl_non_common_tree_pointers (ob
, expr
, ref_p
);
1129 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
1130 lto_output_ts_decl_with_vis_tree_pointers (ob
, expr
, ref_p
);
1132 if (CODE_CONTAINS_STRUCT (code
, TS_FIELD_DECL
))
1133 lto_output_ts_field_decl_tree_pointers (ob
, expr
, ref_p
);
1135 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
1136 lto_output_ts_function_decl_tree_pointers (ob
, expr
, ref_p
);
1138 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE
))
1139 lto_output_ts_type_tree_pointers (ob
, expr
, ref_p
);
1141 if (CODE_CONTAINS_STRUCT (code
, TS_LIST
))
1142 lto_output_ts_list_tree_pointers (ob
, expr
, ref_p
);
1144 if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
1145 lto_output_ts_vec_tree_pointers (ob
, expr
, ref_p
);
1147 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
1148 lto_output_ts_exp_tree_pointers (ob
, expr
, ref_p
);
1150 if (CODE_CONTAINS_STRUCT (code
, TS_SSA_NAME
))
1152 /* We only stream the version number of SSA names. */
1156 if (CODE_CONTAINS_STRUCT (code
, TS_BLOCK
))
1157 lto_output_ts_block_tree_pointers (ob
, expr
, ref_p
);
1159 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
1160 lto_output_ts_binfo_tree_pointers (ob
, expr
, ref_p
);
1162 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
1163 lto_output_ts_constructor_tree_pointers (ob
, expr
, ref_p
);
1165 if (CODE_CONTAINS_STRUCT (code
, TS_STATEMENT_LIST
))
1167 /* This should only appear in GENERIC. */
1171 if (CODE_CONTAINS_STRUCT (code
, TS_OMP_CLAUSE
))
1173 /* This should only appear in High GIMPLE. */
1177 if (CODE_CONTAINS_STRUCT (code
, TS_OPTIMIZATION
))
1178 sorry ("gimple bytecode streams do not support the optimization attribute");
1180 if (CODE_CONTAINS_STRUCT (code
, TS_TARGET_OPTION
))
1181 sorry ("gimple bytecode streams do not support the target attribute");
1185 /* Emit header information for tree EXPR to output block OB. The header
1186 contains everything needed to instantiate an empty skeleton for
1187 EXPR on the reading side. IX is the index into the streamer cache
1188 where EXPR is stored. REF_P is as in lto_output_tree. */
1191 lto_output_tree_header (struct output_block
*ob
, tree expr
, int ix
)
1194 enum tree_code code
;
1196 /* We should not see any non-GIMPLE tree nodes here. */
1197 code
= TREE_CODE (expr
);
1198 if (!lto_is_streamable (expr
))
1199 internal_error ("tree code %qs is not supported in gimple streams",
1200 tree_code_name
[code
]);
1202 /* The header of a tree node consists of its tag, the size of
1203 the node, and any other information needed to instantiate
1204 EXPR on the reading side (such as the number of slots in
1205 variable sized nodes). */
1206 tag
= lto_tree_code_to_tag (code
);
1207 output_record_start (ob
, tag
);
1208 output_sleb128 (ob
, ix
);
1210 /* The following will cause bootstrap miscomparisons. Enable with care. */
1211 #ifdef LTO_STREAMER_DEBUG
1212 /* This is used mainly for debugging purposes. When the reader
1213 and the writer do not agree on a streamed node, the pointer
1214 value for EXPR can be used to track down the differences in
1216 gcc_assert ((HOST_WIDEST_INT
) (intptr_t) expr
== (intptr_t) expr
);
1217 output_sleb128 (ob
, (HOST_WIDEST_INT
) (intptr_t) expr
);
1220 /* The text in strings and identifiers are completely emitted in
1222 if (CODE_CONTAINS_STRUCT (code
, TS_STRING
))
1223 output_string_cst (ob
, ob
->main_stream
, expr
);
1224 else if (CODE_CONTAINS_STRUCT (code
, TS_IDENTIFIER
))
1225 output_identifier (ob
, ob
->main_stream
, expr
);
1226 else if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
1227 output_sleb128 (ob
, TREE_VEC_LENGTH (expr
));
1228 else if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
1229 output_uleb128 (ob
, BINFO_N_BASE_BINFOS (expr
));
1233 /* Write the code and class of builtin EXPR to output block OB. IX is
1234 the index into the streamer cache where EXPR is stored.*/
1237 lto_output_builtin_tree (struct output_block
*ob
, tree expr
, int ix
)
1239 gcc_assert (lto_stream_as_builtin_p (expr
));
1241 if (DECL_BUILT_IN_CLASS (expr
) == BUILT_IN_MD
1242 && !targetm
.builtin_decl
)
1243 sorry ("gimple bytecode streams do not support machine specific builtin "
1244 "functions on this target");
1246 output_record_start (ob
, LTO_builtin_decl
);
1247 output_uleb128 (ob
, DECL_BUILT_IN_CLASS (expr
));
1248 output_uleb128 (ob
, DECL_FUNCTION_CODE (expr
));
1249 output_sleb128 (ob
, ix
);
1251 if (DECL_ASSEMBLER_NAME_SET_P (expr
))
1253 /* When the assembler name of a builtin gets a user name,
1254 the new name is always prefixed with '*' by
1255 set_builtin_user_assembler_name. So, to prevent the
1256 reader side from adding a second '*', we omit it here. */
1257 const char *str
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (expr
));
1258 if (strlen (str
) > 1 && str
[0] == '*')
1259 output_string (ob
, ob
->main_stream
, &str
[1]);
1261 output_string (ob
, ob
->main_stream
, NULL
);
1264 output_string (ob
, ob
->main_stream
, NULL
);
1268 /* Write a physical representation of tree node EXPR to output block
1269 OB. If REF_P is true, the leaves of EXPR are emitted as references
1270 via lto_output_tree_ref. IX is the index into the streamer cache
1271 where EXPR is stored. */
1274 lto_write_tree (struct output_block
*ob
, tree expr
, bool ref_p
, int ix
)
1276 struct bitpack_d
*bp
;
1278 /* Write the header, containing everything needed to materialize
1279 EXPR on the reading side. */
1280 lto_output_tree_header (ob
, expr
, ix
);
1282 /* Pack all the non-pointer fields in EXPR into a bitpack and write
1283 the resulting bitpack. */
1284 bp
= pack_value_fields (expr
);
1285 lto_output_bitpack (ob
->main_stream
, bp
);
1286 bitpack_delete (bp
);
1288 /* Write all the pointer fields in EXPR. */
1289 lto_output_tree_pointers (ob
, expr
, ref_p
);
1291 /* Mark the end of EXPR. */
1296 /* Emit the integer constant CST to output block OB. If REF_P is true,
1297 CST's type will be emitted as a reference. */
1300 lto_output_integer_cst (struct output_block
*ob
, tree cst
, bool ref_p
)
1302 output_record_start (ob
, lto_tree_code_to_tag (INTEGER_CST
));
1303 lto_output_tree_or_ref (ob
, TREE_TYPE (cst
), ref_p
);
1304 lto_output_1_stream (ob
->main_stream
, TREE_OVERFLOW_P (cst
));
1305 output_uleb128 (ob
, TREE_INT_CST_LOW (cst
));
1306 output_uleb128 (ob
, TREE_INT_CST_HIGH (cst
));
1310 /* Emit the physical representation of tree node EXPR to output block
1311 OB. If REF_P is true, the leaves of EXPR are emitted as references
1312 via lto_output_tree_ref. */
1315 lto_output_tree (struct output_block
*ob
, tree expr
, bool ref_p
)
1321 if (expr
== NULL_TREE
)
1327 /* INTEGER_CST nodes are special because they need their original type
1328 to be materialized by the reader (to implement TYPE_CACHED_VALUES). */
1329 if (TREE_CODE (expr
) == INTEGER_CST
)
1331 lto_output_integer_cst (ob
, expr
, ref_p
);
1335 /* Determine the offset in the stream where EXPR will be written.
1336 This is used when emitting pickle references so the reader knows
1337 where to reconstruct the pickled object from. This allows
1338 circular and forward references within the same stream. */
1339 offset
= ob
->main_stream
->total_size
;
1341 existed_p
= lto_streamer_cache_insert (ob
->writer_cache
, expr
, &ix
, &offset
);
1344 /* If a node has already been streamed out, make sure that
1345 we don't write it more than once. Otherwise, the reader
1346 will instantiate two different nodes for the same object. */
1347 output_record_start (ob
, LTO_tree_pickle_reference
);
1348 output_sleb128 (ob
, ix
);
1349 output_uleb128 (ob
, lto_tree_code_to_tag (TREE_CODE (expr
)));
1350 output_uleb128 (ob
, offset
);
1352 else if (lto_stream_as_builtin_p (expr
))
1354 /* MD and NORMAL builtins do not need to be written out
1355 completely as they are always instantiated by the
1356 compiler on startup. The only builtins that need to
1357 be written out are BUILT_IN_FRONTEND. For all other
1358 builtins, we simply write the class and code. */
1359 lto_output_builtin_tree (ob
, expr
, ix
);
1363 /* This is the first time we see EXPR, write its fields
1365 lto_write_tree (ob
, expr
, ref_p
, ix
);
1370 /* Output to OB a list of try/catch handlers starting with FIRST. */
1373 output_eh_try_list (struct output_block
*ob
, eh_catch first
)
1377 for (n
= first
; n
; n
= n
->next_catch
)
1379 output_record_start (ob
, LTO_eh_catch
);
1380 lto_output_tree_ref (ob
, n
->type_list
);
1381 lto_output_tree_ref (ob
, n
->filter_list
);
1382 lto_output_tree_ref (ob
, n
->label
);
1389 /* Output EH region R in function FN to OB. CURR_RN is the slot index
1390 that is being emitted in FN->EH->REGION_ARRAY. This is used to
1391 detect EH region sharing. */
1394 output_eh_region (struct output_block
*ob
, eh_region r
)
1404 if (r
->type
== ERT_CLEANUP
)
1405 tag
= LTO_ert_cleanup
;
1406 else if (r
->type
== ERT_TRY
)
1408 else if (r
->type
== ERT_ALLOWED_EXCEPTIONS
)
1409 tag
= LTO_ert_allowed_exceptions
;
1410 else if (r
->type
== ERT_MUST_NOT_THROW
)
1411 tag
= LTO_ert_must_not_throw
;
1415 output_record_start (ob
, tag
);
1416 output_sleb128 (ob
, r
->index
);
1419 output_sleb128 (ob
, r
->outer
->index
);
1424 output_sleb128 (ob
, r
->inner
->index
);
1429 output_sleb128 (ob
, r
->next_peer
->index
);
1433 if (r
->type
== ERT_TRY
)
1435 output_eh_try_list (ob
, r
->u
.eh_try
.first_catch
);
1437 else if (r
->type
== ERT_ALLOWED_EXCEPTIONS
)
1439 lto_output_tree_ref (ob
, r
->u
.allowed
.type_list
);
1440 lto_output_tree_ref (ob
, r
->u
.allowed
.label
);
1441 output_uleb128 (ob
, r
->u
.allowed
.filter
);
1443 else if (r
->type
== ERT_MUST_NOT_THROW
)
1445 lto_output_tree_ref (ob
, r
->u
.must_not_throw
.failure_decl
);
1446 lto_output_location (ob
, r
->u
.must_not_throw
.failure_loc
);
1449 if (r
->landing_pads
)
1450 output_sleb128 (ob
, r
->landing_pads
->index
);
1456 /* Output landing pad LP to OB. */
1459 output_eh_lp (struct output_block
*ob
, eh_landing_pad lp
)
1467 output_record_start (ob
, LTO_eh_landing_pad
);
1468 output_sleb128 (ob
, lp
->index
);
1470 output_sleb128 (ob
, lp
->next_lp
->index
);
1475 output_sleb128 (ob
, lp
->region
->index
);
1479 lto_output_tree_ref (ob
, lp
->post_landing_pad
);
1483 /* Output the existing eh_table to OB. */
1486 output_eh_regions (struct output_block
*ob
, struct function
*fn
)
1488 if (fn
->eh
&& fn
->eh
->region_tree
)
1495 output_record_start (ob
, LTO_eh_table
);
1497 /* Emit the index of the root of the EH region tree. */
1498 output_sleb128 (ob
, fn
->eh
->region_tree
->index
);
1500 /* Emit all the EH regions in the region array. */
1501 output_sleb128 (ob
, VEC_length (eh_region
, fn
->eh
->region_array
));
1502 for (i
= 0; VEC_iterate (eh_region
, fn
->eh
->region_array
, i
, eh
); i
++)
1503 output_eh_region (ob
, eh
);
1505 /* Emit all landing pads. */
1506 output_sleb128 (ob
, VEC_length (eh_landing_pad
, fn
->eh
->lp_array
));
1507 for (i
= 0; VEC_iterate (eh_landing_pad
, fn
->eh
->lp_array
, i
, lp
); i
++)
1508 output_eh_lp (ob
, lp
);
1510 /* Emit all the runtime type data. */
1511 output_sleb128 (ob
, VEC_length (tree
, fn
->eh
->ttype_data
));
1512 for (i
= 0; VEC_iterate (tree
, fn
->eh
->ttype_data
, i
, ttype
); i
++)
1513 lto_output_tree_ref (ob
, ttype
);
1515 /* Emit the table of action chains. */
1516 if (targetm
.arm_eabi_unwinder
)
1519 output_sleb128 (ob
, VEC_length (tree
, fn
->eh
->ehspec_data
.arm_eabi
));
1521 VEC_iterate (tree
, fn
->eh
->ehspec_data
.arm_eabi
, i
, t
);
1523 lto_output_tree_ref (ob
, t
);
1528 output_sleb128 (ob
, VEC_length (uchar
, fn
->eh
->ehspec_data
.other
));
1529 for (i
= 0; VEC_iterate (uchar
, fn
->eh
->ehspec_data
.other
, i
, c
); i
++)
1530 lto_output_1_stream (ob
->main_stream
, c
);
1534 /* The 0 either terminates the record or indicates that there are no
1535 eh_records at all. */
1540 /* Output all of the active ssa names to the ssa_names stream. */
1543 output_ssa_names (struct output_block
*ob
, struct function
*fn
)
1545 unsigned int i
, len
;
1547 len
= VEC_length (tree
, SSANAMES (fn
));
1548 output_uleb128 (ob
, len
);
1550 for (i
= 1; i
< len
; i
++)
1552 tree ptr
= VEC_index (tree
, SSANAMES (fn
), i
);
1554 if (ptr
== NULL_TREE
1555 || SSA_NAME_IN_FREE_LIST (ptr
)
1556 || !is_gimple_reg (ptr
))
1559 output_uleb128 (ob
, i
);
1560 lto_output_1_stream (ob
->main_stream
, SSA_NAME_IS_DEFAULT_DEF (ptr
));
1561 lto_output_tree_ref (ob
, SSA_NAME_VAR (ptr
));
1568 /* Output the cfg. */
1571 output_cfg (struct output_block
*ob
, struct function
*fn
)
1573 struct lto_output_stream
*tmp_stream
= ob
->main_stream
;
1576 ob
->main_stream
= ob
->cfg_stream
;
1578 output_uleb128 (ob
, profile_status_for_function (fn
));
1580 /* Output the number of the highest basic block. */
1581 output_uleb128 (ob
, last_basic_block_for_function (fn
));
1583 FOR_ALL_BB_FN (bb
, fn
)
1588 output_sleb128 (ob
, bb
->index
);
1590 /* Output the successors and the edge flags. */
1591 output_uleb128 (ob
, EDGE_COUNT (bb
->succs
));
1592 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
1594 output_uleb128 (ob
, e
->dest
->index
);
1595 output_sleb128 (ob
, e
->probability
);
1596 output_sleb128 (ob
, e
->count
);
1597 output_uleb128 (ob
, e
->flags
);
1601 output_sleb128 (ob
, -1);
1603 bb
= ENTRY_BLOCK_PTR
;
1606 output_sleb128 (ob
, bb
->next_bb
->index
);
1610 output_sleb128 (ob
, -1);
1612 ob
->main_stream
= tmp_stream
;
1616 /* Output PHI function PHI to the main stream in OB. */
1619 output_phi (struct output_block
*ob
, gimple phi
)
1621 unsigned i
, len
= gimple_phi_num_args (phi
);
1623 output_record_start (ob
, lto_gimple_code_to_tag (GIMPLE_PHI
));
1624 output_uleb128 (ob
, SSA_NAME_VERSION (PHI_RESULT (phi
)));
1626 for (i
= 0; i
< len
; i
++)
1628 lto_output_tree_ref (ob
, gimple_phi_arg_def (phi
, i
));
1629 output_uleb128 (ob
, gimple_phi_arg_edge (phi
, i
)->src
->index
);
1630 lto_output_location (ob
, gimple_phi_arg_location (phi
, i
));
1635 /* Emit statement STMT on the main stream of output block OB. */
1638 output_gimple_stmt (struct output_block
*ob
, gimple stmt
)
1641 enum gimple_code code
;
1643 struct bitpack_d
*bp
;
1645 /* Emit identifying tag. */
1646 code
= gimple_code (stmt
);
1647 tag
= lto_gimple_code_to_tag (code
);
1648 output_record_start (ob
, tag
);
1650 /* Emit the tuple header. */
1651 bp
= bitpack_create ();
1652 bp_pack_value (bp
, gimple_num_ops (stmt
), sizeof (unsigned) * 8);
1653 bp_pack_value (bp
, gimple_no_warning_p (stmt
), 1);
1654 if (is_gimple_assign (stmt
))
1655 bp_pack_value (bp
, gimple_assign_nontemporal_move_p (stmt
), 1);
1656 bp_pack_value (bp
, gimple_has_volatile_ops (stmt
), 1);
1657 bp_pack_value (bp
, stmt
->gsbase
.subcode
, 16);
1658 lto_output_bitpack (ob
->main_stream
, bp
);
1659 bitpack_delete (bp
);
1661 /* Emit location information for the statement. */
1662 lto_output_location (ob
, gimple_location (stmt
));
1664 /* Emit the lexical block holding STMT. */
1665 lto_output_tree (ob
, gimple_block (stmt
), true);
1667 /* Emit the operands. */
1668 switch (gimple_code (stmt
))
1671 output_sleb128 (ob
, gimple_resx_region (stmt
));
1674 case GIMPLE_EH_MUST_NOT_THROW
:
1675 lto_output_tree_ref (ob
, gimple_eh_must_not_throw_fndecl (stmt
));
1678 case GIMPLE_EH_DISPATCH
:
1679 output_sleb128 (ob
, gimple_eh_dispatch_region (stmt
));
1683 lto_output_uleb128_stream (ob
->main_stream
, gimple_asm_ninputs (stmt
));
1684 lto_output_uleb128_stream (ob
->main_stream
, gimple_asm_noutputs (stmt
));
1685 lto_output_uleb128_stream (ob
->main_stream
, gimple_asm_nclobbers (stmt
));
1686 output_string (ob
, ob
->main_stream
, gimple_asm_string (stmt
));
1697 for (i
= 0; i
< gimple_num_ops (stmt
); i
++)
1699 tree op
= gimple_op (stmt
, i
);
1700 lto_output_tree_ref (ob
, op
);
1705 case GIMPLE_PREDICT
:
1714 /* Output a basic block BB to the main stream in OB for this FN. */
1717 output_bb (struct output_block
*ob
, basic_block bb
, struct function
*fn
)
1719 gimple_stmt_iterator bsi
= gsi_start_bb (bb
);
1721 output_record_start (ob
,
1722 (!gsi_end_p (bsi
)) || phi_nodes (bb
)
1726 output_uleb128 (ob
, bb
->index
);
1727 output_sleb128 (ob
, bb
->count
);
1728 output_sleb128 (ob
, bb
->loop_depth
);
1729 output_sleb128 (ob
, bb
->frequency
);
1730 output_sleb128 (ob
, bb
->flags
);
1732 if (!gsi_end_p (bsi
) || phi_nodes (bb
))
1734 /* Output the statements. The list of statements is terminated
1736 for (bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
1739 gimple stmt
= gsi_stmt (bsi
);
1741 output_gimple_stmt (ob
, stmt
);
1743 /* Emit the EH region holding STMT. */
1744 region
= lookup_stmt_eh_lp_fn (fn
, stmt
);
1747 output_record_start (ob
, LTO_eh_region
);
1748 output_sleb128 (ob
, region
);
1756 for (bsi
= gsi_start_phis (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
1758 gimple phi
= gsi_stmt (bsi
);
1760 /* Only emit PHIs for gimple registers. PHI nodes for .MEM
1761 will be filled in on reading when the SSA form is
1763 if (is_gimple_reg (gimple_phi_result (phi
)))
1764 output_phi (ob
, phi
);
1771 /* Create the header in the file using OB. If the section type is for
1772 a function, set FN to the decl for that function. */
1775 produce_asm (struct output_block
*ob
, tree fn
)
1777 enum lto_section_type section_type
= ob
->section_type
;
1778 struct lto_function_header header
;
1780 struct lto_output_stream
*header_stream
;
1782 if (section_type
== LTO_section_function_body
)
1784 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fn
));
1785 section_name
= lto_get_section_name (section_type
, name
);
1788 section_name
= lto_get_section_name (section_type
, NULL
);
1790 lto_begin_section (section_name
, !flag_wpa
);
1791 free (section_name
);
1793 /* The entire header is stream computed here. */
1794 memset (&header
, 0, sizeof (struct lto_function_header
));
1796 /* Write the header. */
1797 header
.lto_header
.major_version
= LTO_major_version
;
1798 header
.lto_header
.minor_version
= LTO_minor_version
;
1799 header
.lto_header
.section_type
= section_type
;
1801 header
.compressed_size
= 0;
1803 if (section_type
== LTO_section_function_body
)
1804 header
.cfg_size
= ob
->cfg_stream
->total_size
;
1805 header
.main_size
= ob
->main_stream
->total_size
;
1806 header
.string_size
= ob
->string_stream
->total_size
;
1808 header_stream
= XCNEW (struct lto_output_stream
);
1809 lto_output_data_stream (header_stream
, &header
, sizeof header
);
1810 lto_write_stream (header_stream
);
1811 free (header_stream
);
1813 /* Put all of the gimple and the string table out the asm file as a
1815 if (section_type
== LTO_section_function_body
)
1816 lto_write_stream (ob
->cfg_stream
);
1817 lto_write_stream (ob
->main_stream
);
1818 lto_write_stream (ob
->string_stream
);
1824 /* Output the body of function NODE->DECL. */
1827 output_function (struct cgraph_node
*node
)
1829 struct bitpack_d
*bp
;
1831 struct function
*fn
;
1833 struct output_block
*ob
;
1835 function
= node
->decl
;
1836 fn
= DECL_STRUCT_FUNCTION (function
);
1837 ob
= create_output_block (LTO_section_function_body
);
1839 clear_line_info (ob
);
1840 ob
->cgraph_node
= node
;
1842 gcc_assert (current_function_decl
== NULL_TREE
&& cfun
== NULL
);
1844 /* Set current_function_decl and cfun. */
1845 current_function_decl
= function
;
1848 /* Make string 0 be a NULL string. */
1849 lto_output_1_stream (ob
->string_stream
, 0);
1851 output_record_start (ob
, LTO_function
);
1853 /* Write all the attributes for FN. */
1854 bp
= bitpack_create ();
1855 bp_pack_value (bp
, fn
->is_thunk
, 1);
1856 bp_pack_value (bp
, fn
->has_local_explicit_reg_vars
, 1);
1857 bp_pack_value (bp
, fn
->after_tree_profile
, 1);
1858 bp_pack_value (bp
, fn
->returns_pcc_struct
, 1);
1859 bp_pack_value (bp
, fn
->returns_struct
, 1);
1860 bp_pack_value (bp
, fn
->always_inline_functions_inlined
, 1);
1861 bp_pack_value (bp
, fn
->after_inlining
, 1);
1862 bp_pack_value (bp
, fn
->dont_save_pending_sizes_p
, 1);
1863 bp_pack_value (bp
, fn
->stdarg
, 1);
1864 bp_pack_value (bp
, fn
->has_nonlocal_label
, 1);
1865 bp_pack_value (bp
, fn
->calls_alloca
, 1);
1866 bp_pack_value (bp
, fn
->calls_setjmp
, 1);
1867 bp_pack_value (bp
, fn
->function_frequency
, 2);
1868 bp_pack_value (bp
, fn
->va_list_fpr_size
, 8);
1869 bp_pack_value (bp
, fn
->va_list_gpr_size
, 8);
1870 lto_output_bitpack (ob
->main_stream
, bp
);
1871 bitpack_delete (bp
);
1873 /* Output the static chain and non-local goto save area. */
1874 lto_output_tree_ref (ob
, fn
->static_chain_decl
);
1875 lto_output_tree_ref (ob
, fn
->nonlocal_goto_save_area
);
1877 /* Output all the local variables in the function. */
1878 lto_output_tree_ref (ob
, fn
->local_decls
);
1880 /* Output the head of the arguments list. */
1881 lto_output_tree_ref (ob
, DECL_ARGUMENTS (function
));
1883 /* Output all the SSA names used in the function. */
1884 output_ssa_names (ob
, fn
);
1886 /* Output any exception handling regions. */
1887 output_eh_regions (ob
, fn
);
1889 /* Output DECL_INITIAL for the function, which contains the tree of
1891 lto_output_tree (ob
, DECL_INITIAL (function
), true);
1893 /* We will renumber the statements. The code that does this uses
1894 the same ordering that we use for serializing them so we can use
1895 the same code on the other end and not have to write out the
1896 statement numbers. */
1897 renumber_gimple_stmt_uids ();
1899 /* Output the code for the function. */
1900 FOR_ALL_BB_FN (bb
, fn
)
1901 output_bb (ob
, bb
, fn
);
1903 /* The terminator for this function. */
1906 output_cfg (ob
, fn
);
1908 /* Create a section to hold the pickled output of this function. */
1909 produce_asm (ob
, function
);
1911 destroy_output_block (ob
);
1913 current_function_decl
= NULL
;
1918 /* Return true if alias pair P belongs to the set of cgraph nodes in
1919 SET. If P is a an alias for a VAR_DECL, it can always be emitted.
1920 However, for FUNCTION_DECL aliases, we should only output the pair
1921 if it belongs to a function whose cgraph node is in SET.
1922 Otherwise, the LTRANS phase will get into trouble when finalizing
1923 aliases because the alias will refer to a function not defined in
1924 the file processed by LTRANS. */
1927 output_alias_pair_p (alias_pair
*p
, cgraph_node_set set
)
1929 cgraph_node_set_iterator csi
;
1930 struct cgraph_node
*target_node
;
1932 /* Always emit VAR_DECLs. FIXME lto, we should probably only emit
1933 those VAR_DECLs that are instantiated in this file partition, but
1934 we have no easy way of knowing this based on SET. */
1935 if (TREE_CODE (p
->decl
) == VAR_DECL
)
1938 /* Check if the assembler name for P->TARGET has its cgraph node in SET. */
1939 gcc_assert (TREE_CODE (p
->decl
) == FUNCTION_DECL
);
1940 target_node
= cgraph_node_for_asm (p
->target
);
1941 csi
= cgraph_node_set_find (set
, target_node
);
1942 return (!csi_end_p (csi
));
1946 /* Output any unreferenced global symbol defined in SET, alias pairs
1950 output_unreferenced_globals (cgraph_node_set set
)
1952 struct output_block
*ob
;
1955 struct varpool_node
*vnode
;
1957 ob
= create_output_block (LTO_section_static_initializer
);
1958 ob
->cgraph_node
= NULL
;
1960 clear_line_info (ob
);
1962 /* Make string 0 be a NULL string. */
1963 lto_output_1_stream (ob
->string_stream
, 0);
1965 /* Emit references for all the global symbols. If a global symbol
1966 was never referenced in any of the functions of this file, it
1967 would not be emitted otherwise. This will result in unreferenced
1968 symbols at link time if a file defines a global symbol but
1969 never references it. */
1970 FOR_EACH_STATIC_VARIABLE (vnode
)
1972 tree var
= vnode
->decl
;
1974 if (TREE_CODE (var
) == VAR_DECL
&& TREE_PUBLIC (var
))
1975 lto_output_tree_ref (ob
, var
);
1980 /* Emit the alias pairs for the nodes in SET. */
1981 for (i
= 0; VEC_iterate (alias_pair
, alias_pairs
, i
, p
); i
++)
1983 if (output_alias_pair_p (p
, set
))
1985 lto_output_tree_ref (ob
, p
->decl
);
1986 lto_output_tree_ref (ob
, p
->target
);
1992 produce_asm (ob
, NULL
);
1993 destroy_output_block (ob
);
1997 /* Copy the function body of NODE without deserializing. */
2000 copy_function (struct cgraph_node
*node
)
2002 tree function
= node
->decl
;
2003 struct lto_file_decl_data
*file_data
= node
->local
.lto_file_data
;
2004 struct lto_output_stream
*output_stream
= XCNEW (struct lto_output_stream
);
2007 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (function
));
2008 char *section_name
=
2009 lto_get_section_name (LTO_section_function_body
, name
);
2011 struct lto_in_decl_state
*in_state
;
2012 struct lto_out_decl_state
*out_state
= lto_get_out_decl_state ();
2014 lto_begin_section (section_name
, !flag_wpa
);
2015 free (section_name
);
2017 /* We may have renamed the declaration, e.g., a static function. */
2018 name
= lto_get_decl_name_mapping (file_data
, name
);
2020 data
= lto_get_section_data (file_data
, LTO_section_function_body
,
2024 /* Do a bit copy of the function body. */
2025 lto_output_data_stream (output_stream
, data
, len
);
2026 lto_write_stream (output_stream
);
2030 lto_get_function_in_decl_state (node
->local
.lto_file_data
, function
);
2031 gcc_assert (in_state
);
2033 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2035 size_t n
= in_state
->streams
[i
].size
;
2036 tree
*trees
= in_state
->streams
[i
].trees
;
2037 struct lto_tree_ref_encoder
*encoder
= &(out_state
->streams
[i
]);
2039 /* The out state must have the same indices and the in state.
2040 So just copy the vector. All the encoders in the in state
2041 must be empty where we reach here. */
2042 gcc_assert (lto_tree_ref_encoder_size (encoder
) == 0);
2043 for (j
= 0; j
< n
; j
++)
2044 VEC_safe_push (tree
, heap
, encoder
->trees
, trees
[j
]);
2045 encoder
->next_index
= n
;
2048 lto_free_section_data (file_data
, LTO_section_function_body
, name
,
2050 free (output_stream
);
2055 /* Initialize the LTO writer. */
2058 lto_writer_init (void)
2060 lto_streamer_init ();
2064 /* Main entry point from the pass manager. */
2067 lto_output (cgraph_node_set set
)
2069 struct cgraph_node
*node
;
2070 struct lto_out_decl_state
*decl_state
;
2071 cgraph_node_set_iterator csi
;
2072 bitmap output
= lto_bitmap_alloc ();
2076 /* Process only the functions with bodies. */
2077 for (csi
= csi_start (set
); !csi_end_p (csi
); csi_next (&csi
))
2079 node
= csi_node (csi
);
2080 if (node
->analyzed
&& !bitmap_bit_p (output
, DECL_UID (node
->decl
)))
2082 bitmap_set_bit (output
, DECL_UID (node
->decl
));
2083 decl_state
= lto_new_out_decl_state ();
2084 lto_push_out_decl_state (decl_state
);
2086 output_function (node
);
2088 copy_function (node
);
2089 gcc_assert (lto_get_out_decl_state () == decl_state
);
2090 lto_pop_out_decl_state ();
2091 lto_record_function_out_decl_state (node
->decl
, decl_state
);
2095 /* Emit the callgraph after emitting function bodies. This needs to
2096 be done now to make sure that all the statements in every function
2097 have been renumbered so that edges can be associated with call
2098 statements using the statement UIDs. */
2099 output_cgraph (set
);
2101 lto_bitmap_free (output
);
2104 struct ipa_opt_pass_d pass_ipa_lto_gimple_out
=
2108 "lto_gimple_out", /* name */
2109 gate_lto_out
, /* gate */
2113 0, /* static_pass_number */
2114 TV_IPA_LTO_GIMPLE_IO
, /* tv_id */
2115 0, /* properties_required */
2116 0, /* properties_provided */
2117 0, /* properties_destroyed */
2118 0, /* todo_flags_start */
2119 TODO_dump_func
/* todo_flags_finish */
2121 NULL
, /* generate_summary */
2122 lto_output
, /* write_summary */
2123 NULL
, /* read_summary */
2124 NULL
, /* function_read_summary */
2125 NULL
, /* stmt_fixup */
2127 NULL
, /* function_transform */
2128 NULL
/* variable_transform */
2132 /* Write each node in encoded by ENCODER to OB, as well as those reachable
2133 from it and required for correct representation of its semantics.
2134 Each node in ENCODER must be a global declaration or a type. A node
2135 is written only once, even if it appears multiple times in the
2136 vector. Certain transitively-reachable nodes, such as those
2137 representing expressions, may be duplicated, but such nodes
2138 must not appear in ENCODER itself. */
2141 write_global_stream (struct output_block
*ob
,
2142 struct lto_tree_ref_encoder
*encoder
)
2146 const size_t size
= lto_tree_ref_encoder_size (encoder
);
2148 for (index
= 0; index
< size
; index
++)
2150 t
= lto_tree_ref_encoder_get_tree (encoder
, index
);
2151 if (!lto_streamer_cache_lookup (ob
->writer_cache
, t
, NULL
))
2152 lto_output_tree (ob
, t
, false);
2156 /* In WPA we should not emit multiple definitions of the
2157 same symbol to all the files in the link set. If
2158 T had already been emitted as the pervailing definition
2159 in one file, do not emit it in the others. */
2160 /* FIXME lto. We should check if T belongs to the
2161 file we are writing to. */
2162 if (TREE_CODE (t
) == VAR_DECL
2164 && !DECL_EXTERNAL (t
))
2165 TREE_ASM_WRITTEN (t
) = 1;
2171 /* Write a sequence of indices into the globals vector corresponding
2172 to the trees in ENCODER. These are used by the reader to map the
2173 indices used to refer to global entities within function bodies to
2177 write_global_references (struct output_block
*ob
,
2178 struct lto_output_stream
*ref_stream
,
2179 struct lto_tree_ref_encoder
*encoder
)
2183 const int32_t size
= lto_tree_ref_encoder_size (encoder
);
2185 /* Write size as 32-bit unsigned. */
2186 lto_output_data_stream (ref_stream
, &size
, sizeof (int32_t));
2188 for (index
= 0; index
< size
; index
++)
2192 t
= lto_tree_ref_encoder_get_tree (encoder
, index
);
2193 lto_streamer_cache_lookup (ob
->writer_cache
, t
, &slot_num
);
2194 gcc_assert (slot_num
>= 0);
2195 lto_output_data_stream (ref_stream
, &slot_num
, sizeof slot_num
);
2200 /* Write all the streams in an lto_out_decl_state STATE using
2201 output block OB and output stream OUT_STREAM. */
2204 lto_output_decl_state_streams (struct output_block
*ob
,
2205 struct lto_out_decl_state
*state
)
2209 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2210 write_global_stream (ob
, &state
->streams
[i
]);
2214 /* Write all the references in an lto_out_decl_state STATE using
2215 output block OB and output stream OUT_STREAM. */
2218 lto_output_decl_state_refs (struct output_block
*ob
,
2219 struct lto_output_stream
*out_stream
,
2220 struct lto_out_decl_state
*state
)
2226 /* Write reference to FUNCTION_DECL. If there is not function,
2227 write reference to void_type_node. */
2228 decl
= (state
->fn_decl
) ? state
->fn_decl
: void_type_node
;
2229 lto_streamer_cache_lookup (ob
->writer_cache
, decl
, &ref
);
2230 gcc_assert (ref
>= 0);
2231 lto_output_data_stream (out_stream
, &ref
, sizeof (int32_t));
2233 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2234 write_global_references (ob
, out_stream
, &state
->streams
[i
]);
2238 /* Return the written size of STATE. */
2241 lto_out_decl_state_written_size (struct lto_out_decl_state
*state
)
2246 size
= sizeof (int32_t); /* fn_ref. */
2247 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2249 size
+= sizeof (int32_t); /* vector size. */
2250 size
+= (lto_tree_ref_encoder_size (&state
->streams
[i
])
2251 * sizeof (int32_t));
2257 /* Helper function of write_symbols_of_kind. CACHE is the streamer
2258 cache with all the pickled nodes. STREAM is the stream where to
2259 write the table. V is a vector with the DECLs that should be on
2260 the table. SEEN is a bitmap of symbols written so far. */
2263 write_symbol_vec (struct lto_streamer_cache_d
*cache
,
2264 struct lto_output_stream
*stream
,
2265 VEC(tree
,heap
) *v
, bitmap seen
)
2270 for (index
= 0; VEC_iterate(tree
, v
, index
, t
); index
++)
2273 enum gcc_plugin_symbol_kind kind
;
2274 enum gcc_plugin_symbol_visibility visibility
;
2279 /* None of the following kinds of symbols are needed in the
2281 if (!TREE_PUBLIC (t
)
2282 || is_builtin_fn (t
)
2283 || DECL_ABSTRACT (t
)
2284 || TREE_CODE (t
) == RESULT_DECL
)
2287 gcc_assert (TREE_CODE (t
) == VAR_DECL
2288 || TREE_CODE (t
) == FUNCTION_DECL
);
2290 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (t
));
2292 /* FIXME lto: this is from assemble_name_raw in varasm.c. For some
2293 architectures we might have to do the same name manipulations that
2294 ASM_OUTPUT_LABELREF does. */
2298 lto_streamer_cache_lookup (cache
, t
, &slot_num
);
2299 gcc_assert (slot_num
>= 0);
2301 /* Avoid duplicate symbols. */
2302 if (bitmap_bit_p (seen
, slot_num
))
2305 bitmap_set_bit (seen
, slot_num
);
2307 if (DECL_EXTERNAL (t
))
2310 kind
= GCCPK_WEAKUNDEF
;
2317 kind
= GCCPK_WEAKDEF
;
2318 else if (DECL_COMMON (t
))
2319 kind
= GCCPK_COMMON
;
2324 switch (DECL_VISIBILITY(t
))
2326 case VISIBILITY_DEFAULT
:
2327 visibility
= GCCPV_DEFAULT
;
2329 case VISIBILITY_PROTECTED
:
2330 visibility
= GCCPV_PROTECTED
;
2332 case VISIBILITY_HIDDEN
:
2333 visibility
= GCCPV_HIDDEN
;
2335 case VISIBILITY_INTERNAL
:
2336 visibility
= GCCPV_INTERNAL
;
2340 if (kind
== GCCPK_COMMON
2342 && TREE_CODE (DECL_SIZE (t
)) == INTEGER_CST
)
2343 size
= (((uint64_t) TREE_INT_CST_HIGH (DECL_SIZE (t
))) << 32)
2344 | TREE_INT_CST_LOW (DECL_SIZE (t
));
2348 if (DECL_ONE_ONLY (t
))
2349 comdat
= IDENTIFIER_POINTER (DECL_COMDAT_GROUP (t
));
2353 lto_output_data_stream (stream
, name
, strlen (name
) + 1);
2354 lto_output_data_stream (stream
, comdat
, strlen (comdat
) + 1);
2355 lto_output_data_stream (stream
, &kind
, 1);
2356 lto_output_data_stream (stream
, &visibility
, 1);
2357 lto_output_data_stream (stream
, &size
, 8);
2358 lto_output_data_stream (stream
, &slot_num
, 4);
2363 /* Write IL symbols of KIND. CACHE is the streamer cache with all the
2364 pickled nodes. SEEN is a bitmap of symbols written so far. */
2367 write_symbols_of_kind (lto_decl_stream_e_t kind
,
2368 struct lto_streamer_cache_d
*cache
, bitmap seen
)
2370 struct lto_out_decl_state
*out_state
;
2371 struct lto_output_stream stream
;
2373 VEC_length (lto_out_decl_state_ptr
, lto_function_decl_states
);
2376 memset (&stream
, 0, sizeof (stream
));
2377 out_state
= lto_get_out_decl_state ();
2378 write_symbol_vec (cache
, &stream
, out_state
->streams
[kind
].trees
, seen
);
2380 for (idx
= 0; idx
< num_fns
; idx
++)
2383 VEC_index (lto_out_decl_state_ptr
, lto_function_decl_states
, idx
);
2384 write_symbol_vec (cache
, &stream
, out_state
->streams
[kind
].trees
, seen
);
2387 lto_write_stream (&stream
);
2391 /* Write an IL symbol table. CACHE is the streamer cache with all the
2395 produce_symtab (struct lto_streamer_cache_d
*cache
)
2397 char *section_name
= lto_get_section_name (LTO_section_symtab
, NULL
);
2400 lto_begin_section (section_name
, false);
2401 free (section_name
);
2403 seen
= lto_bitmap_alloc ();
2404 write_symbols_of_kind (LTO_DECL_STREAM_FN_DECL
, cache
, seen
);
2405 write_symbols_of_kind (LTO_DECL_STREAM_VAR_DECL
, cache
, seen
);
2406 lto_bitmap_free (seen
);
2412 /* This pass is run after all of the functions are serialized and all
2413 of the IPA passes have written their serialized forms. This pass
2414 causes the vector of all of the global decls and types used from
2415 this file to be written in to a section that can then be read in to
2416 recover these on other side. */
2419 produce_asm_for_decls (cgraph_node_set set
)
2421 struct lto_out_decl_state
*out_state
;
2422 struct lto_out_decl_state
*fn_out_state
;
2423 struct lto_decl_header header
;
2425 struct output_block
*ob
;
2426 struct lto_output_stream
*header_stream
, *decl_state_stream
;
2427 unsigned idx
, num_fns
;
2428 size_t decl_state_size
;
2429 int32_t num_decl_states
;
2431 ob
= create_output_block (LTO_section_decls
);
2434 /* Write out unreferenced globals, alias pairs and labels. We defer
2435 doing this until now so that we can write out only what is
2437 output_unreferenced_globals (set
);
2439 memset (&header
, 0, sizeof (struct lto_decl_header
));
2441 section_name
= lto_get_section_name (LTO_section_decls
, NULL
);
2442 lto_begin_section (section_name
, !flag_wpa
);
2443 free (section_name
);
2445 /* Make string 0 be a NULL string. */
2446 lto_output_1_stream (ob
->string_stream
, 0);
2448 /* Write the global symbols. */
2449 out_state
= lto_get_out_decl_state ();
2450 num_fns
= VEC_length (lto_out_decl_state_ptr
, lto_function_decl_states
);
2451 lto_output_decl_state_streams (ob
, out_state
);
2452 for (idx
= 0; idx
< num_fns
; idx
++)
2455 VEC_index (lto_out_decl_state_ptr
, lto_function_decl_states
, idx
);
2456 lto_output_decl_state_streams (ob
, fn_out_state
);
2459 header
.lto_header
.major_version
= LTO_major_version
;
2460 header
.lto_header
.minor_version
= LTO_minor_version
;
2461 header
.lto_header
.section_type
= LTO_section_decls
;
2463 /* Currently not used. This field would allow us to preallocate
2464 the globals vector, so that it need not be resized as it is extended. */
2465 header
.num_nodes
= -1;
2467 /* Compute the total size of all decl out states. */
2468 decl_state_size
= sizeof (int32_t);
2469 decl_state_size
+= lto_out_decl_state_written_size (out_state
);
2470 for (idx
= 0; idx
< num_fns
; idx
++)
2473 VEC_index (lto_out_decl_state_ptr
, lto_function_decl_states
, idx
);
2474 decl_state_size
+= lto_out_decl_state_written_size (fn_out_state
);
2476 header
.decl_state_size
= decl_state_size
;
2478 header
.main_size
= ob
->main_stream
->total_size
;
2479 header
.string_size
= ob
->string_stream
->total_size
;
2481 header_stream
= XCNEW (struct lto_output_stream
);
2482 lto_output_data_stream (header_stream
, &header
, sizeof header
);
2483 lto_write_stream (header_stream
);
2484 free (header_stream
);
2486 /* Write the main out-decl state, followed by out-decl states of
2488 decl_state_stream
= ((struct lto_output_stream
*)
2489 xcalloc (1, sizeof (struct lto_output_stream
)));
2490 num_decl_states
= num_fns
+ 1;
2491 lto_output_data_stream (decl_state_stream
, &num_decl_states
,
2492 sizeof (num_decl_states
));
2493 lto_output_decl_state_refs (ob
, decl_state_stream
, out_state
);
2494 for (idx
= 0; idx
< num_fns
; idx
++)
2497 VEC_index (lto_out_decl_state_ptr
, lto_function_decl_states
, idx
);
2498 lto_output_decl_state_refs (ob
, decl_state_stream
, fn_out_state
);
2500 lto_write_stream (decl_state_stream
);
2501 free(decl_state_stream
);
2503 lto_write_stream (ob
->main_stream
);
2504 lto_write_stream (ob
->string_stream
);
2508 /* Write the symbol table. */
2509 produce_symtab (ob
->writer_cache
);
2511 /* Write command line opts. */
2512 lto_write_options ();
2514 /* Deallocate memory and clean up. */
2515 lto_cgraph_encoder_delete (ob
->decl_state
->cgraph_node_encoder
);
2516 VEC_free (lto_out_decl_state_ptr
, heap
, lto_function_decl_states
);
2517 lto_function_decl_states
= NULL
;
2518 destroy_output_block (ob
);
2522 struct ipa_opt_pass_d pass_ipa_lto_finish_out
=
2526 "lto_decls_out", /* name */
2527 gate_lto_out
, /* gate */
2531 0, /* static_pass_number */
2532 TV_IPA_LTO_DECL_IO
, /* tv_id */
2533 0, /* properties_required */
2534 0, /* properties_provided */
2535 0, /* properties_destroyed */
2536 0, /* todo_flags_start */
2537 0 /* todo_flags_finish */
2539 NULL
, /* generate_summary */
2540 produce_asm_for_decls
, /* write_summary */
2541 NULL
, /* read_summary */
2542 NULL
, /* function_read_summary */
2543 NULL
, /* stmt_fixup */
2545 NULL
, /* function_transform */
2546 NULL
/* variable_transform */