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 bp_pack_value (bp, TREE_ASM_WRITTEN (expr), 1);
346 bp_pack_value (bp, TREE_NO_WARNING (expr), 1);
347 bp_pack_value (bp, TREE_USED (expr), 1);
348 bp_pack_value (bp, TREE_NOTHROW (expr), 1);
349 bp_pack_value (bp, TREE_STATIC (expr), 1);
350 bp_pack_value (bp, TREE_PRIVATE (expr), 1);
351 bp_pack_value (bp, TREE_PROTECTED (expr), 1);
352 bp_pack_value (bp, TREE_DEPRECATED (expr), 1);
354 bp_pack_value (bp, TYPE_SATURATING (expr), 1);
355 if (TREE_CODE (expr) == SSA_NAME)
356 bp_pack_value (bp, SSA_NAME_IS_DEFAULT_DEF (expr), 1);
360 /* Pack all the non-pointer fields of the TS_REAL_CST structure of
361 expression EXPR into bitpack BP. */
364 pack_ts_real_cst_value_fields (struct bitpack_d *bp, tree expr)
369 r = TREE_REAL_CST (expr);
370 bp_pack_value (bp, r.cl, 2);
371 bp_pack_value (bp, r.decimal, 1);
372 bp_pack_value (bp, r.sign, 1);
373 bp_pack_value (bp, r.signalling, 1);
374 bp_pack_value (bp, r.canonical, 1);
375 bp_pack_value (bp, r.uexp, EXP_BITS);
376 for (i = 0; i < SIGSZ; i++)
377 bp_pack_value (bp, r.sig[i], HOST_BITS_PER_LONG);
381 /* Pack all the non-pointer fields of the TS_FIXED_CST structure of
382 expression EXPR into bitpack BP. */
385 pack_ts_fixed_cst_value_fields (struct bitpack_d *bp, tree expr)
387 struct fixed_value fv = TREE_FIXED_CST (expr);
388 bp_pack_value (bp, fv.data.low, HOST_BITS_PER_WIDE_INT);
389 bp_pack_value (bp, fv.data.high, HOST_BITS_PER_WIDE_INT);
393 /* Pack all the non-pointer fields of the TS_DECL_COMMON structure
394 of expression EXPR into bitpack BP. */
397 pack_ts_decl_common_value_fields (struct bitpack_d *bp, tree expr)
399 bp_pack_value (bp, DECL_MODE (expr), 8);
400 bp_pack_value (bp, DECL_NONLOCAL (expr), 1);
401 bp_pack_value (bp, DECL_VIRTUAL_P (expr), 1);
402 bp_pack_value (bp, DECL_IGNORED_P (expr), 1);
403 bp_pack_value (bp, DECL_ABSTRACT (expr), 1);
404 bp_pack_value (bp, DECL_ARTIFICIAL (expr), 1);
405 bp_pack_value (bp, DECL_USER_ALIGN (expr), 1);
406 bp_pack_value (bp, DECL_PRESERVE_P (expr), 1);
407 bp_pack_value (bp, DECL_DEBUG_EXPR_IS_FROM (expr), 1);
408 bp_pack_value (bp, DECL_EXTERNAL (expr), 1);
409 bp_pack_value (bp, DECL_GIMPLE_REG_P (expr), 1);
410 bp_pack_value (bp, DECL_ALIGN (expr), HOST_BITS_PER_INT);
412 if (TREE_CODE (expr) == LABEL_DECL)
414 /* Note that we do not write LABEL_DECL_UID. The reader will
415 always assume an initial value of -1 so that the
416 label_to_block_map is recreated by gimple_set_bb. */
417 bp_pack_value (bp, DECL_ERROR_ISSUED (expr), 1);
418 bp_pack_value (bp, EH_LANDING_PAD_NR (expr), HOST_BITS_PER_INT);
421 if (TREE_CODE (expr) == FIELD_DECL)
423 bp_pack_value (bp, DECL_PACKED (expr), 1);
424 bp_pack_value (bp, DECL_NONADDRESSABLE_P (expr), 1);
425 bp_pack_value (bp, DECL_OFFSET_ALIGN (expr), 8);
428 if (TREE_CODE (expr) == RESULT_DECL
429 || TREE_CODE (expr) == PARM_DECL
430 || TREE_CODE (expr) == VAR_DECL)
432 bp_pack_value (bp, DECL_BY_REFERENCE (expr), 1);
433 if (TREE_CODE (expr) == VAR_DECL
434 || TREE_CODE (expr) == PARM_DECL)
435 bp_pack_value (bp, DECL_HAS_VALUE_EXPR_P (expr), 1);
440 /* Pack all the non-pointer fields of the TS_DECL_WRTL structure
441 of expression EXPR into bitpack BP. */
444 pack_ts_decl_wrtl_value_fields (struct bitpack_d *bp, tree expr)
446 bp_pack_value (bp, DECL_REGISTER (expr), 1);
450 /* Pack all the non-pointer fields of the TS_DECL_WITH_VIS structure
451 of expression EXPR into bitpack BP. */
454 pack_ts_decl_with_vis_value_fields (struct bitpack_d *bp, tree expr)
456 bp_pack_value (bp, DECL_DEFER_OUTPUT (expr), 1);
457 bp_pack_value (bp, DECL_COMMON (expr), 1);
458 bp_pack_value (bp, DECL_DLLIMPORT_P (expr), 1);
459 bp_pack_value (bp, DECL_WEAK (expr), 1);
460 bp_pack_value (bp, DECL_SEEN_IN_BIND_EXPR_P (expr), 1);
461 bp_pack_value (bp, DECL_COMDAT (expr), 1);
462 bp_pack_value (bp, DECL_VISIBILITY (expr), 2);
463 bp_pack_value (bp, DECL_VISIBILITY_SPECIFIED (expr), 1);
465 if (TREE_CODE (expr) == VAR_DECL)
467 bp_pack_value (bp, DECL_HARD_REGISTER (expr), 1);
468 bp_pack_value (bp, DECL_IN_TEXT_SECTION (expr), 1);
469 bp_pack_value (bp, DECL_TLS_MODEL (expr), 3);
472 if (VAR_OR_FUNCTION_DECL_P (expr))
473 bp_pack_value (bp, DECL_INIT_PRIORITY (expr), HOST_BITS_PER_SHORT);
477 /* Pack all the non-pointer fields of the TS_FUNCTION_DECL structure
478 of expression EXPR into bitpack BP. */
481 pack_ts_function_decl_value_fields (struct bitpack_d *bp, tree expr)
483 /* For normal/md builtins we only write the class and code, so they
484 should never be handled here. */
485 gcc_assert (!lto_stream_as_builtin_p (expr));
487 bp_pack_value (bp, DECL_FUNCTION_CODE (expr), 11);
488 bp_pack_value (bp, DECL_BUILT_IN_CLASS (expr), 2);
489 bp_pack_value (bp, DECL_STATIC_CONSTRUCTOR (expr), 1);
490 bp_pack_value (bp, DECL_STATIC_DESTRUCTOR (expr), 1);
491 bp_pack_value (bp, DECL_UNINLINABLE (expr), 1);
492 bp_pack_value (bp, DECL_POSSIBLY_INLINED (expr), 1);
493 bp_pack_value (bp, DECL_IS_NOVOPS (expr), 1);
494 bp_pack_value (bp, DECL_IS_RETURNS_TWICE (expr), 1);
495 bp_pack_value (bp, DECL_IS_MALLOC (expr), 1);
496 bp_pack_value (bp, DECL_IS_OPERATOR_NEW (expr), 1);
497 bp_pack_value (bp, DECL_DECLARED_INLINE_P (expr), 1);
498 bp_pack_value (bp, DECL_STATIC_CHAIN (expr), 1);
499 bp_pack_value (bp, DECL_NO_INLINE_WARNING_P (expr), 1);
500 bp_pack_value (bp, DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (expr), 1);
501 bp_pack_value (bp, DECL_NO_LIMIT_STACK (expr), 1);
502 bp_pack_value (bp, DECL_DISREGARD_INLINE_LIMITS (expr), 1);
503 bp_pack_value (bp, DECL_PURE_P (expr), 1);
504 bp_pack_value (bp, DECL_LOOPING_CONST_OR_PURE_P (expr), 1);
508 /* Pack all the non-pointer fields of the TS_TYPE structure
509 of expression EXPR into bitpack BP. */
512 pack_ts_type_value_fields (struct bitpack_d *bp, tree expr)
514 bp_pack_value (bp, TYPE_PRECISION (expr), 9);
515 bp_pack_value (bp, TYPE_MODE (expr), 7);
516 bp_pack_value (bp, TYPE_STRING_FLAG (expr), 1);
517 bp_pack_value (bp, TYPE_NO_FORCE_BLK (expr), 1);
518 bp_pack_value (bp, TYPE_NEEDS_CONSTRUCTING(expr), 1);
519 if (TREE_CODE (expr) == UNION_TYPE)
520 bp_pack_value (bp, TYPE_TRANSPARENT_UNION (expr), 1);
521 bp_pack_value (bp, TYPE_PACKED (expr), 1);
522 bp_pack_value (bp, TYPE_RESTRICT (expr), 1);
523 bp_pack_value (bp, TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr), 2);
524 bp_pack_value (bp, TYPE_USER_ALIGN (expr), 1);
525 bp_pack_value (bp, TYPE_READONLY (expr), 1);
526 bp_pack_value (bp, TYPE_ALIGN (expr), HOST_BITS_PER_INT);
527 bp_pack_value (bp, TYPE_ALIAS_SET (expr) == 0 ? 0 : -1, HOST_BITS_PER_INT);
531 /* Pack all the non-pointer fields of the TS_BLOCK structure
532 of expression EXPR into bitpack BP. */
535 pack_ts_block_value_fields (struct bitpack_d *bp, tree expr)
537 bp_pack_value (bp, BLOCK_ABSTRACT (expr), 1);
538 bp_pack_value (bp, BLOCK_NUMBER (expr), 31);
542 /* Pack all the non-pointer fields in EXPR into a bit pack. */
544 static struct bitpack_d *
545 pack_value_fields (tree expr)
548 struct bitpack_d *bp;
550 code = TREE_CODE (expr);
551 bp = bitpack_create ();
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. */
603 /* Emit location LOC to output block OB. */
606 lto_output_location (struct output_block *ob, location_t loc)
608 expanded_location xloc;
610 if (loc == UNKNOWN_LOCATION)
612 output_string (ob, ob->main_stream, NULL);
616 xloc = expand_location (loc);
618 output_string (ob, ob->main_stream, xloc.file);
619 output_sleb128 (ob, xloc.line);
620 output_sleb128 (ob, xloc.column);
622 ob->current_file = xloc.file;
623 ob->current_line = xloc.line;
624 ob->current_col = xloc.column;
628 /* Return true if tree node T is written to various tables. For these
629 nodes, we sometimes want to write their phyiscal representation
630 (via lto_output_tree), and sometimes we need to emit an index
631 reference into a table (via lto_output_tree_ref). */
634 tree_is_indexable (tree t)
636 if (TREE_CODE (t) == PARM_DECL)
638 else if (TREE_CODE (t) == VAR_DECL && decl_function_context (t))
641 return (TYPE_P (t) || DECL_P (t) || TREE_CODE (t) == SSA_NAME);
645 /* If EXPR is an indexable tree node, output a reference to it to
646 output block OB. Otherwise, output the physical representation of
650 lto_output_tree_ref (struct output_block *ob, tree expr)
654 if (expr == NULL_TREE)
660 if (!tree_is_indexable (expr))
662 /* Even though we are emitting the physical representation of
663 EXPR, its leaves must be emitted as references. */
664 lto_output_tree (ob, expr, true);
670 output_type_ref (ob, expr);
674 code = TREE_CODE (expr);
678 output_record_start (ob, LTO_ssa_name_ref);
679 output_uleb128 (ob, SSA_NAME_VERSION (expr));
683 output_record_start (ob, LTO_field_decl_ref);
684 lto_output_field_decl_index (ob->decl_state, ob->main_stream, expr);
688 output_record_start (ob, LTO_function_decl_ref);
689 lto_output_fn_decl_index (ob->decl_state, ob->main_stream, expr);
693 case DEBUG_EXPR_DECL:
694 gcc_assert (decl_function_context (expr) == NULL);
695 output_record_start (ob, LTO_global_decl_ref);
696 lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr);
700 output_record_start (ob, LTO_const_decl_ref);
701 lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr);
705 gcc_assert (decl_function_context (expr) == NULL);
706 output_record_start (ob, LTO_imported_decl_ref);
707 lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr);
711 output_record_start (ob, LTO_type_decl_ref);
712 lto_output_type_decl_index (ob->decl_state, ob->main_stream, expr);
716 output_record_start (ob, LTO_namespace_decl_ref);
717 lto_output_namespace_decl_index (ob->decl_state, ob->main_stream, expr);
721 output_record_start (ob, LTO_label_decl_ref);
722 lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr);
726 output_record_start (ob, LTO_result_decl_ref);
727 lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr);
731 /* No other node is indexable, so it should have been handled
732 by lto_output_tree. */
738 /* If REF_P is true, emit a reference to EXPR in output block OB,
739 otherwise emit the physical representation of EXPR in OB. */
742 lto_output_tree_or_ref (struct output_block *ob, tree expr, bool ref_p)
745 lto_output_tree_ref (ob, expr);
747 lto_output_tree (ob, expr, false);
751 /* Emit the chain of tree nodes starting at T. OB is the output block
752 to write to. REF_P is true if chain elements should be emitted
756 lto_output_chain (struct output_block *ob, tree t, bool ref_p)
760 count = list_length (t);
761 output_sleb128 (ob, count);
762 for (i = 0; i < count; i++)
766 /* Clear TREE_CHAIN to avoid blindly recursing into the rest
768 saved_chain = TREE_CHAIN (t);
769 TREE_CHAIN (t) = NULL_TREE;
771 lto_output_tree_or_ref (ob, t, ref_p);
773 TREE_CHAIN (t) = saved_chain;
779 /* Write all pointer fields in the TS_COMMON structure of EXPR to output
780 block OB. If REF_P is true, write a reference to EXPR's pointer
784 lto_output_ts_common_tree_pointers (struct output_block *ob, tree expr,
787 lto_output_tree_or_ref (ob, TREE_TYPE (expr), ref_p);
791 /* Write all pointer fields in the TS_VECTOR structure of EXPR to output
792 block OB. If REF_P is true, write a reference to EXPR's pointer
796 lto_output_ts_vector_tree_pointers (struct output_block *ob, tree expr,
799 lto_output_chain (ob, TREE_VECTOR_CST_ELTS (expr), ref_p);
803 /* Write all pointer fields in the TS_COMPLEX structure of EXPR to output
804 block OB. If REF_P is true, write a reference to EXPR's pointer
808 lto_output_ts_complex_tree_pointers (struct output_block *ob, tree expr,
811 lto_output_tree_or_ref (ob, TREE_REALPART (expr), ref_p);
812 lto_output_tree_or_ref (ob, TREE_IMAGPART (expr), ref_p);
816 /* Write all pointer fields in the TS_DECL_MINIMAL structure of EXPR
817 to output block OB. If REF_P is true, write a reference to EXPR's
821 lto_output_ts_decl_minimal_tree_pointers (struct output_block *ob, tree expr,
824 lto_output_tree_or_ref (ob, DECL_NAME (expr), ref_p);
825 lto_output_tree_or_ref (ob, DECL_CONTEXT (expr), ref_p);
826 lto_output_location (ob, DECL_SOURCE_LOCATION (expr));
830 /* Write all pointer fields in the TS_DECL_COMMON structure of EXPR to
831 output block OB. If REF_P is true, write a reference to EXPR's
835 lto_output_ts_decl_common_tree_pointers (struct output_block *ob, tree expr,
838 lto_output_tree_or_ref (ob, DECL_SIZE (expr), ref_p);
839 lto_output_tree_or_ref (ob, DECL_SIZE_UNIT (expr), ref_p);
841 if (TREE_CODE (expr) != FUNCTION_DECL)
842 lto_output_tree_or_ref (ob, DECL_INITIAL (expr), ref_p);
844 lto_output_tree_or_ref (ob, DECL_ATTRIBUTES (expr), ref_p);
845 lto_output_tree_or_ref (ob, DECL_ABSTRACT_ORIGIN (expr), ref_p);
847 if (TREE_CODE (expr) == PARM_DECL)
848 lto_output_chain (ob, TREE_CHAIN (expr), ref_p);
852 /* Write all pointer fields in the TS_DECL_NON_COMMON structure of
853 EXPR to output block OB. If REF_P is true, write a reference to EXPR's
857 lto_output_ts_decl_non_common_tree_pointers (struct output_block *ob,
858 tree expr, bool ref_p)
860 if (TREE_CODE (expr) == FUNCTION_DECL)
862 /* DECL_SAVED_TREE holds the GENERIC representation for DECL.
863 At this point, it should not exist. Either because it was
864 converted to gimple or because DECL didn't have a GENERIC
865 representation in this TU. */
866 gcc_assert (DECL_SAVED_TREE (expr) == NULL_TREE);
867 lto_output_tree_or_ref (ob, DECL_ARGUMENTS (expr), ref_p);
868 lto_output_tree_or_ref (ob, DECL_RESULT (expr), ref_p);
870 lto_output_tree_or_ref (ob, DECL_VINDEX (expr), ref_p);
874 /* Write all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
875 to output block OB. If REF_P is true, write a reference to EXPR's
879 lto_output_ts_decl_with_vis_tree_pointers (struct output_block *ob, tree expr,
882 /* Make sure we don't inadvertently set the assembler name. */
883 if (DECL_ASSEMBLER_NAME_SET_P (expr))
884 lto_output_tree_or_ref (ob, DECL_ASSEMBLER_NAME (expr), ref_p);
888 lto_output_tree_or_ref (ob, DECL_SECTION_NAME (expr), ref_p);
889 lto_output_tree_or_ref (ob, DECL_COMDAT_GROUP (expr), ref_p);
893 /* Write all pointer fields in the TS_FIELD_DECL structure of EXPR to
894 output block OB. If REF_P is true, write a reference to EXPR's
898 lto_output_ts_field_decl_tree_pointers (struct output_block *ob, tree expr,
901 lto_output_tree_or_ref (ob, DECL_FIELD_OFFSET (expr), ref_p);
902 lto_output_tree_or_ref (ob, DECL_BIT_FIELD_TYPE (expr), ref_p);
903 lto_output_tree_or_ref (ob, DECL_QUALIFIER (expr), ref_p);
904 lto_output_tree_or_ref (ob, DECL_FIELD_BIT_OFFSET (expr), ref_p);
905 lto_output_tree_or_ref (ob, DECL_FCONTEXT (expr), ref_p);
906 lto_output_chain (ob, TREE_CHAIN (expr), ref_p);
910 /* Write all pointer fields in the TS_FUNCTION_DECL structure of EXPR
911 to output block OB. If REF_P is true, write a reference to EXPR's
915 lto_output_ts_function_decl_tree_pointers (struct output_block *ob, tree expr,
918 /* DECL_STRUCT_FUNCTION is handled by lto_output_function. FIXME lto,
919 maybe it should be handled here? */
920 lto_output_tree_or_ref (ob, DECL_FUNCTION_PERSONALITY (expr), ref_p);
921 lto_output_tree_or_ref (ob, DECL_FUNCTION_SPECIFIC_TARGET (expr), ref_p);
922 lto_output_tree_or_ref (ob, DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr),
927 /* Write all pointer fields in the TS_TYPE structure of EXPR to output
928 block OB. If REF_P is true, write a reference to EXPR's pointer
932 lto_output_ts_type_tree_pointers (struct output_block *ob, tree expr,
935 if (TREE_CODE (expr) == ENUMERAL_TYPE)
936 lto_output_tree_or_ref (ob, TYPE_VALUES (expr), ref_p);
937 else if (TREE_CODE (expr) == ARRAY_TYPE)
938 lto_output_tree_or_ref (ob, TYPE_DOMAIN (expr), ref_p);
939 else if (TREE_CODE (expr) == RECORD_TYPE || TREE_CODE (expr) == UNION_TYPE)
940 lto_output_tree_or_ref (ob, TYPE_FIELDS (expr), ref_p);
941 else if (TREE_CODE (expr) == FUNCTION_TYPE || TREE_CODE (expr) == METHOD_TYPE)
942 lto_output_tree_or_ref (ob, TYPE_ARG_TYPES (expr), ref_p);
943 else if (TREE_CODE (expr) == VECTOR_TYPE)
944 lto_output_tree_or_ref (ob, TYPE_DEBUG_REPRESENTATION_TYPE (expr), ref_p);
946 lto_output_tree_or_ref (ob, TYPE_SIZE (expr), ref_p);
947 lto_output_tree_or_ref (ob, TYPE_SIZE_UNIT (expr), ref_p);
948 lto_output_tree_or_ref (ob, TYPE_ATTRIBUTES (expr), ref_p);
949 lto_output_tree_or_ref (ob, TYPE_NAME (expr), ref_p);
950 /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO nor
951 TYPE_NEXT_PTR_TO or TYPE_NEXT_REF_TO. */
952 if (!POINTER_TYPE_P (expr))
953 lto_output_tree_or_ref (ob, TYPE_MINVAL (expr), ref_p);
954 lto_output_tree_or_ref (ob, TYPE_MAXVAL (expr), ref_p);
955 lto_output_tree_or_ref (ob, TYPE_MAIN_VARIANT (expr), ref_p);
956 /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
958 if (TREE_CODE (expr) == RECORD_TYPE || TREE_CODE (expr) == UNION_TYPE)
959 lto_output_tree_or_ref (ob, TYPE_BINFO (expr), ref_p);
960 lto_output_tree_or_ref (ob, TYPE_CONTEXT (expr), ref_p);
961 lto_output_tree_or_ref (ob, TYPE_CANONICAL (expr), ref_p);
965 /* Write all pointer fields in the TS_LIST structure of EXPR to output
966 block OB. If REF_P is true, write a reference to EXPR's pointer
970 lto_output_ts_list_tree_pointers (struct output_block *ob, tree expr,
973 lto_output_tree_or_ref (ob, TREE_PURPOSE (expr), ref_p);
974 lto_output_tree_or_ref (ob, TREE_VALUE (expr), ref_p);
975 lto_output_chain (ob, TREE_CHAIN (expr), ref_p);
979 /* Write all pointer fields in the TS_VEC structure of EXPR to output
980 block OB. If REF_P is true, write a reference to EXPR's pointer
984 lto_output_ts_vec_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
988 /* Note that the number of slots for EXPR has already been emitted
989 in EXPR's header (see lto_output_tree_header). */
990 for (i = 0; i < TREE_VEC_LENGTH (expr); i++)
991 lto_output_tree_or_ref (ob, TREE_VEC_ELT (expr, i), ref_p);
995 /* Write all pointer fields in the TS_EXP structure of EXPR to output
996 block OB. If REF_P is true, write a reference to EXPR's pointer
1000 lto_output_ts_exp_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
1004 output_sleb128 (ob, TREE_OPERAND_LENGTH (expr));
1005 for (i = 0; i < TREE_OPERAND_LENGTH (expr); i++)
1006 lto_output_tree_or_ref (ob, TREE_OPERAND (expr, i), ref_p);
1007 lto_output_location (ob, EXPR_LOCATION (expr));
1008 lto_output_tree_or_ref (ob, TREE_BLOCK (expr), ref_p);
1012 /* Write all pointer fields in the TS_BLOCK structure of EXPR to output
1013 block OB. If REF_P is true, write a reference to EXPR's pointer
1017 lto_output_ts_block_tree_pointers (struct output_block *ob, tree expr,
1023 lto_output_location (ob, BLOCK_SOURCE_LOCATION (expr));
1024 lto_output_chain (ob, BLOCK_VARS (expr), ref_p);
1026 output_uleb128 (ob, VEC_length (tree, BLOCK_NONLOCALIZED_VARS (expr)));
1027 for (i = 0; VEC_iterate (tree, BLOCK_NONLOCALIZED_VARS (expr), i, t); i++)
1028 lto_output_tree_or_ref (ob, t, ref_p);
1030 lto_output_tree_or_ref (ob, BLOCK_SUPERCONTEXT (expr), ref_p);
1031 lto_output_tree_or_ref (ob, BLOCK_ABSTRACT_ORIGIN (expr), ref_p);
1032 lto_output_tree_or_ref (ob, BLOCK_FRAGMENT_ORIGIN (expr), ref_p);
1033 lto_output_tree_or_ref (ob, BLOCK_FRAGMENT_CHAIN (expr), ref_p);
1034 lto_output_chain (ob, BLOCK_SUBBLOCKS (expr), ref_p);
1038 /* Write all pointer fields in the TS_BINFO structure of EXPR to output
1039 block OB. If REF_P is true, write a reference to EXPR's pointer
1043 lto_output_ts_binfo_tree_pointers (struct output_block *ob, tree expr,
1049 /* Note that the number of BINFO slots has already been emitted in
1050 EXPR's header (see lto_output_tree_header) because this length
1051 is needed to build the empty BINFO node on the reader side. */
1052 for (i = 0; VEC_iterate (tree, BINFO_BASE_BINFOS (expr), i, t); i++)
1053 lto_output_tree_or_ref (ob, t, ref_p);
1056 lto_output_tree_or_ref (ob, BINFO_OFFSET (expr), ref_p);
1057 lto_output_tree_or_ref (ob, BINFO_VTABLE (expr), ref_p);
1058 lto_output_tree_or_ref (ob, BINFO_VIRTUALS (expr), ref_p);
1059 lto_output_tree_or_ref (ob, BINFO_VPTR_FIELD (expr), ref_p);
1061 output_uleb128 (ob, VEC_length (tree, BINFO_BASE_ACCESSES (expr)));
1062 for (i = 0; VEC_iterate (tree, BINFO_BASE_ACCESSES (expr), i, t); i++)
1063 lto_output_tree_or_ref (ob, t, ref_p);
1065 lto_output_tree_or_ref (ob, BINFO_INHERITANCE_CHAIN (expr), ref_p);
1066 lto_output_tree_or_ref (ob, BINFO_SUBVTT_INDEX (expr), ref_p);
1067 lto_output_tree_or_ref (ob, BINFO_VPTR_INDEX (expr), ref_p);
1071 /* Write all pointer fields in the TS_CONSTRUCTOR structure of EXPR to
1072 output block OB. If REF_P is true, write a reference to EXPR's
1076 lto_output_ts_constructor_tree_pointers (struct output_block *ob, tree expr,
1082 output_uleb128 (ob, CONSTRUCTOR_NELTS (expr));
1083 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (expr), i, index, value)
1085 lto_output_tree_or_ref (ob, index, ref_p);
1086 lto_output_tree_or_ref (ob, value, ref_p);
1091 /* Helper for lto_output_tree. Write all pointer fields in EXPR to output
1092 block OB. If REF_P is true, the leaves of EXPR are emitted as
1096 lto_output_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
1098 enum tree_code code;
1100 code = TREE_CODE (expr);
1102 if (CODE_CONTAINS_STRUCT (code, TS_COMMON))
1103 lto_output_ts_common_tree_pointers (ob, expr, ref_p);
1105 if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
1106 lto_output_ts_vector_tree_pointers (ob, expr, ref_p);
1108 if (CODE_CONTAINS_STRUCT (code, TS_COMPLEX))
1109 lto_output_ts_complex_tree_pointers (ob, expr, ref_p);
1111 if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
1112 lto_output_ts_decl_minimal_tree_pointers (ob, expr, ref_p);
1114 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
1115 lto_output_ts_decl_common_tree_pointers (ob, expr, ref_p);
1117 if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
1118 lto_output_ts_decl_non_common_tree_pointers (ob, expr, ref_p);
1120 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
1121 lto_output_ts_decl_with_vis_tree_pointers (ob, expr, ref_p);
1123 if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL))
1124 lto_output_ts_field_decl_tree_pointers (ob, expr, ref_p);
1126 if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
1127 lto_output_ts_function_decl_tree_pointers (ob, expr, ref_p);
1129 if (CODE_CONTAINS_STRUCT (code, TS_TYPE))
1130 lto_output_ts_type_tree_pointers (ob, expr, ref_p);
1132 if (CODE_CONTAINS_STRUCT (code, TS_LIST))
1133 lto_output_ts_list_tree_pointers (ob, expr, ref_p);
1135 if (CODE_CONTAINS_STRUCT (code, TS_VEC))
1136 lto_output_ts_vec_tree_pointers (ob, expr, ref_p);
1138 if (CODE_CONTAINS_STRUCT (code, TS_EXP))
1139 lto_output_ts_exp_tree_pointers (ob, expr, ref_p);
1141 if (CODE_CONTAINS_STRUCT (code, TS_SSA_NAME))
1143 /* We only stream the version number of SSA names. */
1147 if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
1148 lto_output_ts_block_tree_pointers (ob, expr, ref_p);
1150 if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
1151 lto_output_ts_binfo_tree_pointers (ob, expr, ref_p);
1153 if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
1154 lto_output_ts_constructor_tree_pointers (ob, expr, ref_p);
1156 if (CODE_CONTAINS_STRUCT (code, TS_STATEMENT_LIST))
1158 /* This should only appear in GENERIC. */
1162 if (CODE_CONTAINS_STRUCT (code, TS_OMP_CLAUSE))
1164 /* This should only appear in High GIMPLE. */
1168 if (CODE_CONTAINS_STRUCT (code, TS_OPTIMIZATION))
1169 sorry ("gimple bytecode streams do not support the optimization attribute");
1171 if (CODE_CONTAINS_STRUCT (code, TS_TARGET_OPTION))
1172 sorry ("gimple bytecode streams do not support the target attribute");
1176 /* Emit header information for tree EXPR to output block OB. The header
1177 contains everything needed to instantiate an empty skeleton for
1178 EXPR on the reading side. IX is the index into the streamer cache
1179 where EXPR is stored. REF_P is as in lto_output_tree. */
1182 lto_output_tree_header (struct output_block *ob, tree expr, int ix)
1185 enum tree_code code;
1187 /* We should not see any non-GIMPLE tree nodes here. */
1188 code = TREE_CODE (expr);
1189 if (!lto_is_streamable (expr))
1190 internal_error ("tree code %qs is not supported in gimple streams",
1191 tree_code_name[code]);
1193 /* The header of a tree node consists of its tag, the size of
1194 the node, and any other information needed to instantiate
1195 EXPR on the reading side (such as the number of slots in
1196 variable sized nodes). */
1197 tag = lto_tree_code_to_tag (code);
1198 output_record_start (ob, tag);
1199 output_sleb128 (ob, ix);
1201 /* The following will cause bootstrap miscomparisons. Enable with care. */
1202 #ifdef LTO_STREAMER_DEBUG
1203 /* This is used mainly for debugging purposes. When the reader
1204 and the writer do not agree on a streamed node, the pointer
1205 value for EXPR can be used to track down the differences in
1207 gcc_assert ((HOST_WIDEST_INT) (intptr_t) expr == (intptr_t) expr);
1208 output_sleb128 (ob, (HOST_WIDEST_INT) (intptr_t) expr);
1211 /* The text in strings and identifiers are completely emitted in
1213 if (CODE_CONTAINS_STRUCT (code, TS_STRING))
1214 output_string_cst (ob, ob->main_stream, expr);
1215 else if (CODE_CONTAINS_STRUCT (code, TS_IDENTIFIER))
1216 output_identifier (ob, ob->main_stream, expr);
1217 else if (CODE_CONTAINS_STRUCT (code, TS_VEC))
1218 output_sleb128 (ob, TREE_VEC_LENGTH (expr));
1219 else if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
1220 output_uleb128 (ob, BINFO_N_BASE_BINFOS (expr));
1224 /* Write the code and class of builtin EXPR to output block OB. IX is
1225 the index into the streamer cache where EXPR is stored.*/
1228 lto_output_builtin_tree (struct output_block *ob, tree expr, int ix)
1230 gcc_assert (lto_stream_as_builtin_p (expr));
1232 if (DECL_BUILT_IN_CLASS (expr) == BUILT_IN_MD
1233 && !targetm.builtin_decl)
1234 sorry ("gimple bytecode streams do not support machine specific builtin "
1235 "functions on this target");
1237 output_record_start (ob, LTO_builtin_decl);
1238 output_uleb128 (ob, DECL_BUILT_IN_CLASS (expr));
1239 output_uleb128 (ob, DECL_FUNCTION_CODE (expr));
1240 output_sleb128 (ob, ix);
1242 if (DECL_ASSEMBLER_NAME_SET_P (expr))
1244 /* When the assembler name of a builtin gets a user name,
1245 the new name is always prefixed with '*' by
1246 set_builtin_user_assembler_name. So, to prevent the
1247 reader side from adding a second '*', we omit it here. */
1248 const char *str = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (expr));
1249 if (strlen (str) > 1 && str[0] == '*')
1250 output_string (ob, ob->main_stream, &str[1]);
1252 output_string (ob, ob->main_stream, NULL);
1255 output_string (ob, ob->main_stream, NULL);
1259 /* Write a physical representation of tree node EXPR to output block
1260 OB. If REF_P is true, the leaves of EXPR are emitted as references
1261 via lto_output_tree_ref. IX is the index into the streamer cache
1262 where EXPR is stored. */
1265 lto_write_tree (struct output_block *ob, tree expr, bool ref_p, int ix)
1267 struct bitpack_d *bp;
1269 /* Write the header, containing everything needed to materialize
1270 EXPR on the reading side. */
1271 lto_output_tree_header (ob, expr, ix);
1273 /* Pack all the non-pointer fields in EXPR into a bitpack and write
1274 the resulting bitpack. */
1275 bp = pack_value_fields (expr);
1276 lto_output_bitpack (ob->main_stream, bp);
1277 bitpack_delete (bp);
1279 /* Write all the pointer fields in EXPR. */
1280 lto_output_tree_pointers (ob, expr, ref_p);
1282 /* Mark the end of EXPR. */
1287 /* Emit the integer constant CST to output block OB. If REF_P is true,
1288 CST's type will be emitted as a reference. */
1291 lto_output_integer_cst (struct output_block *ob, tree cst, bool ref_p)
1293 output_record_start (ob, lto_tree_code_to_tag (INTEGER_CST));
1294 lto_output_tree_or_ref (ob, TREE_TYPE (cst), ref_p);
1295 lto_output_1_stream (ob->main_stream, TREE_OVERFLOW_P (cst));
1296 output_uleb128 (ob, TREE_INT_CST_LOW (cst));
1297 output_uleb128 (ob, TREE_INT_CST_HIGH (cst));
1301 /* Emit the physical representation of tree node EXPR to output block
1302 OB. If REF_P is true, the leaves of EXPR are emitted as references
1303 via lto_output_tree_ref. */
1306 lto_output_tree (struct output_block *ob, tree expr, bool ref_p)
1312 if (expr == NULL_TREE)
1318 /* INTEGER_CST nodes are special because they need their original type
1319 to be materialized by the reader (to implement TYPE_CACHED_VALUES). */
1320 if (TREE_CODE (expr) == INTEGER_CST)
1322 lto_output_integer_cst (ob, expr, ref_p);
1326 /* Determine the offset in the stream where EXPR will be written.
1327 This is used when emitting pickle references so the reader knows
1328 where to reconstruct the pickled object from. This allows
1329 circular and forward references within the same stream. */
1330 offset = ob->main_stream->total_size;
1332 existed_p = lto_streamer_cache_insert (ob->writer_cache, expr, &ix, &offset);
1335 /* If a node has already been streamed out, make sure that
1336 we don't write it more than once. Otherwise, the reader
1337 will instantiate two different nodes for the same object. */
1338 output_record_start (ob, LTO_tree_pickle_reference);
1339 output_sleb128 (ob, ix);
1340 output_uleb128 (ob, lto_tree_code_to_tag (TREE_CODE (expr)));
1341 output_uleb128 (ob, offset);
1343 else if (lto_stream_as_builtin_p (expr))
1345 /* MD and NORMAL builtins do not need to be written out
1346 completely as they are always instantiated by the
1347 compiler on startup. The only builtins that need to
1348 be written out are BUILT_IN_FRONTEND. For all other
1349 builtins, we simply write the class and code. */
1350 lto_output_builtin_tree (ob, expr, ix);
1354 /* This is the first time we see EXPR, write its fields
1356 lto_write_tree (ob, expr, ref_p, ix);
1361 /* Output to OB a list of try/catch handlers starting with FIRST. */
1364 output_eh_try_list (struct output_block *ob, eh_catch first)
1368 for (n = first; n; n = n->next_catch)
1370 output_record_start (ob, LTO_eh_catch);
1371 lto_output_tree_ref (ob, n->type_list);
1372 lto_output_tree_ref (ob, n->filter_list);
1373 lto_output_tree_ref (ob, n->label);
1380 /* Output EH region R in function FN to OB. CURR_RN is the slot index
1381 that is being emitted in FN->EH->REGION_ARRAY. This is used to
1382 detect EH region sharing. */
1385 output_eh_region (struct output_block *ob, eh_region r)
1395 if (r->type == ERT_CLEANUP)
1396 tag = LTO_ert_cleanup;
1397 else if (r->type == ERT_TRY)
1399 else if (r->type == ERT_ALLOWED_EXCEPTIONS)
1400 tag = LTO_ert_allowed_exceptions;
1401 else if (r->type == ERT_MUST_NOT_THROW)
1402 tag = LTO_ert_must_not_throw;
1406 output_record_start (ob, tag);
1407 output_sleb128 (ob, r->index);
1410 output_sleb128 (ob, r->outer->index);
1415 output_sleb128 (ob, r->inner->index);
1420 output_sleb128 (ob, r->next_peer->index);
1424 if (r->type == ERT_TRY)
1426 output_eh_try_list (ob, r->u.eh_try.first_catch);
1428 else if (r->type == ERT_ALLOWED_EXCEPTIONS)
1430 lto_output_tree_ref (ob, r->u.allowed.type_list);
1431 lto_output_tree_ref (ob, r->u.allowed.label);
1432 output_uleb128 (ob, r->u.allowed.filter);
1434 else if (r->type == ERT_MUST_NOT_THROW)
1436 lto_output_tree_ref (ob, r->u.must_not_throw.failure_decl);
1437 lto_output_location (ob, r->u.must_not_throw.failure_loc);
1440 if (r->landing_pads)
1441 output_sleb128 (ob, r->landing_pads->index);
1447 /* Output landing pad LP to OB. */
1450 output_eh_lp (struct output_block *ob, eh_landing_pad lp)
1458 output_record_start (ob, LTO_eh_landing_pad);
1459 output_sleb128 (ob, lp->index);
1461 output_sleb128 (ob, lp->next_lp->index);
1466 output_sleb128 (ob, lp->region->index);
1470 lto_output_tree_ref (ob, lp->post_landing_pad);
1474 /* Output the existing eh_table to OB. */
1477 output_eh_regions (struct output_block *ob, struct function *fn)
1479 if (fn->eh && fn->eh->region_tree)
1486 output_record_start (ob, LTO_eh_table);
1488 /* Emit the index of the root of the EH region tree. */
1489 output_sleb128 (ob, fn->eh->region_tree->index);
1491 /* Emit all the EH regions in the region array. */
1492 output_sleb128 (ob, VEC_length (eh_region, fn->eh->region_array));
1493 for (i = 0; VEC_iterate (eh_region, fn->eh->region_array, i, eh); i++)
1494 output_eh_region (ob, eh);
1496 /* Emit all landing pads. */
1497 output_sleb128 (ob, VEC_length (eh_landing_pad, fn->eh->lp_array));
1498 for (i = 0; VEC_iterate (eh_landing_pad, fn->eh->lp_array, i, lp); i++)
1499 output_eh_lp (ob, lp);
1501 /* Emit all the runtime type data. */
1502 output_sleb128 (ob, VEC_length (tree, fn->eh->ttype_data));
1503 for (i = 0; VEC_iterate (tree, fn->eh->ttype_data, i, ttype); i++)
1504 lto_output_tree_ref (ob, ttype);
1506 /* Emit the table of action chains. */
1507 if (targetm.arm_eabi_unwinder)
1510 output_sleb128 (ob, VEC_length (tree, fn->eh->ehspec_data.arm_eabi));
1512 VEC_iterate (tree, fn->eh->ehspec_data.arm_eabi, i, t);
1514 lto_output_tree_ref (ob, t);
1519 output_sleb128 (ob, VEC_length (uchar, fn->eh->ehspec_data.other));
1520 for (i = 0; VEC_iterate (uchar, fn->eh->ehspec_data.other, i, c); i++)
1521 lto_output_1_stream (ob->main_stream, c);
1525 /* The 0 either terminates the record or indicates that there are no
1526 eh_records at all. */
1531 /* Output all of the active ssa names to the ssa_names stream. */
1534 output_ssa_names (struct output_block *ob, struct function *fn)
1536 unsigned int i, len;
1538 len = VEC_length (tree, SSANAMES (fn));
1539 output_uleb128 (ob, len);
1541 for (i = 1; i < len; i++)
1543 tree ptr = VEC_index (tree, SSANAMES (fn), i);
1545 if (ptr == NULL_TREE
1546 || SSA_NAME_IN_FREE_LIST (ptr)
1547 || !is_gimple_reg (ptr))
1550 output_uleb128 (ob, i);
1551 lto_output_1_stream (ob->main_stream, SSA_NAME_IS_DEFAULT_DEF (ptr));
1552 lto_output_tree_ref (ob, SSA_NAME_VAR (ptr));
1559 /* Output the cfg. */
1562 output_cfg (struct output_block *ob, struct function *fn)
1564 struct lto_output_stream *tmp_stream = ob->main_stream;
1567 ob->main_stream = ob->cfg_stream;
1569 output_uleb128 (ob, profile_status_for_function (fn));
1571 /* Output the number of the highest basic block. */
1572 output_uleb128 (ob, last_basic_block_for_function (fn));
1574 FOR_ALL_BB_FN (bb, fn)
1579 output_sleb128 (ob, bb->index);
1581 /* Output the successors and the edge flags. */
1582 output_uleb128 (ob, EDGE_COUNT (bb->succs));
1583 FOR_EACH_EDGE (e, ei, bb->succs)
1585 output_uleb128 (ob, e->dest->index);
1586 output_sleb128 (ob, e->probability);
1587 output_sleb128 (ob, e->count);
1588 output_uleb128 (ob, e->flags);
1592 output_sleb128 (ob, -1);
1594 bb = ENTRY_BLOCK_PTR;
1597 output_sleb128 (ob, bb->next_bb->index);
1601 output_sleb128 (ob, -1);
1603 ob->main_stream = tmp_stream;
1607 /* Output PHI function PHI to the main stream in OB. */
1610 output_phi (struct output_block *ob, gimple phi)
1612 unsigned i, len = gimple_phi_num_args (phi);
1614 output_record_start (ob, lto_gimple_code_to_tag (GIMPLE_PHI));
1615 output_uleb128 (ob, SSA_NAME_VERSION (PHI_RESULT (phi)));
1617 for (i = 0; i < len; i++)
1619 lto_output_tree_ref (ob, gimple_phi_arg_def (phi, i));
1620 output_uleb128 (ob, gimple_phi_arg_edge (phi, i)->src->index);
1621 lto_output_location (ob, gimple_phi_arg_location (phi, i));
1626 /* Emit statement STMT on the main stream of output block OB. */
1629 output_gimple_stmt (struct output_block *ob, gimple stmt)
1632 enum gimple_code code;
1634 struct bitpack_d *bp;
1636 /* Emit identifying tag. */
1637 code = gimple_code (stmt);
1638 tag = lto_gimple_code_to_tag (code);
1639 output_record_start (ob, tag);
1641 /* Emit the tuple header. */
1642 bp = bitpack_create ();
1643 bp_pack_value (bp, gimple_num_ops (stmt), sizeof (unsigned) * 8);
1644 bp_pack_value (bp, gimple_no_warning_p (stmt), 1);
1645 if (is_gimple_assign (stmt))
1646 bp_pack_value (bp, gimple_assign_nontemporal_move_p (stmt), 1);
1647 bp_pack_value (bp, gimple_has_volatile_ops (stmt), 1);
1648 bp_pack_value (bp, stmt->gsbase.subcode, 16);
1649 lto_output_bitpack (ob->main_stream, bp);
1650 bitpack_delete (bp);
1652 /* Emit location information for the statement. */
1653 lto_output_location (ob, gimple_location (stmt));
1655 /* Emit the lexical block holding STMT. */
1656 lto_output_tree (ob, gimple_block (stmt), true);
1658 /* Emit the operands. */
1659 switch (gimple_code (stmt))
1662 output_sleb128 (ob, gimple_resx_region (stmt));
1665 case GIMPLE_EH_MUST_NOT_THROW:
1666 lto_output_tree_ref (ob, gimple_eh_must_not_throw_fndecl (stmt));
1669 case GIMPLE_EH_DISPATCH:
1670 output_sleb128 (ob, gimple_eh_dispatch_region (stmt));
1674 lto_output_uleb128_stream (ob->main_stream, gimple_asm_ninputs (stmt));
1675 lto_output_uleb128_stream (ob->main_stream, gimple_asm_noutputs (stmt));
1676 lto_output_uleb128_stream (ob->main_stream, gimple_asm_nclobbers (stmt));
1677 output_string (ob, ob->main_stream, gimple_asm_string (stmt));
1688 for (i = 0; i < gimple_num_ops (stmt); i++)
1690 tree op = gimple_op (stmt, i);
1691 lto_output_tree_ref (ob, op);
1696 case GIMPLE_PREDICT:
1705 /* Output a basic block BB to the main stream in OB for this FN. */
1708 output_bb (struct output_block *ob, basic_block bb, struct function *fn)
1710 gimple_stmt_iterator bsi = gsi_start_bb (bb);
1712 output_record_start (ob,
1713 (!gsi_end_p (bsi)) || phi_nodes (bb)
1717 output_uleb128 (ob, bb->index);
1718 output_sleb128 (ob, bb->count);
1719 output_sleb128 (ob, bb->loop_depth);
1720 output_sleb128 (ob, bb->frequency);
1721 output_sleb128 (ob, bb->flags);
1723 if (!gsi_end_p (bsi) || phi_nodes (bb))
1725 /* Output the statements. The list of statements is terminated
1727 for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
1730 gimple stmt = gsi_stmt (bsi);
1732 output_gimple_stmt (ob, stmt);
1734 /* Emit the EH region holding STMT. */
1735 region = lookup_stmt_eh_lp_fn (fn, stmt);
1738 output_record_start (ob, LTO_eh_region);
1739 output_sleb128 (ob, region);
1747 for (bsi = gsi_start_phis (bb); !gsi_end_p (bsi); gsi_next (&bsi))
1749 gimple phi = gsi_stmt (bsi);
1751 /* Only emit PHIs for gimple registers. PHI nodes for .MEM
1752 will be filled in on reading when the SSA form is
1754 if (is_gimple_reg (gimple_phi_result (phi)))
1755 output_phi (ob, phi);
1762 /* Create the header in the file using OB. If the section type is for
1763 a function, set FN to the decl for that function. */
1766 produce_asm (struct output_block *ob, tree fn)
1768 enum lto_section_type section_type = ob->section_type;
1769 struct lto_function_header header;
1771 struct lto_output_stream *header_stream;
1773 if (section_type == LTO_section_function_body)
1775 const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fn));
1776 section_name = lto_get_section_name (section_type, name);
1779 section_name = lto_get_section_name (section_type, NULL);
1781 lto_begin_section (section_name, !flag_wpa);
1782 free (section_name);
1784 /* The entire header is stream computed here. */
1785 memset (&header, 0, sizeof (struct lto_function_header));
1787 /* Write the header. */
1788 header.lto_header.major_version = LTO_major_version;
1789 header.lto_header.minor_version = LTO_minor_version;
1790 header.lto_header.section_type = section_type;
1792 header.compressed_size = 0;
1794 if (section_type == LTO_section_function_body)
1795 header.cfg_size = ob->cfg_stream->total_size;
1796 header.main_size = ob->main_stream->total_size;
1797 header.string_size = ob->string_stream->total_size;
1799 header_stream = XCNEW (struct lto_output_stream);
1800 lto_output_data_stream (header_stream, &header, sizeof header);
1801 lto_write_stream (header_stream);
1802 free (header_stream);
1804 /* Put all of the gimple and the string table out the asm file as a
1806 if (section_type == LTO_section_function_body)
1807 lto_write_stream (ob->cfg_stream);
1808 lto_write_stream (ob->main_stream);
1809 lto_write_stream (ob->string_stream);
1815 /* Output the body of function NODE->DECL. */
1818 output_function (struct cgraph_node *node)
1820 struct bitpack_d *bp;
1822 struct function *fn;
1824 struct output_block *ob;
1826 function = node->decl;
1827 fn = DECL_STRUCT_FUNCTION (function);
1828 ob = create_output_block (LTO_section_function_body);
1830 clear_line_info (ob);
1831 ob->cgraph_node = node;
1833 gcc_assert (current_function_decl == NULL_TREE && cfun == NULL);
1835 /* Set current_function_decl and cfun. */
1836 current_function_decl = function;
1839 /* Make string 0 be a NULL string. */
1840 lto_output_1_stream (ob->string_stream, 0);
1842 output_record_start (ob, LTO_function);
1844 /* Write all the attributes for FN. */
1845 bp = bitpack_create ();
1846 bp_pack_value (bp, fn->is_thunk, 1);
1847 bp_pack_value (bp, fn->has_local_explicit_reg_vars, 1);
1848 bp_pack_value (bp, fn->after_tree_profile, 1);
1849 bp_pack_value (bp, fn->returns_pcc_struct, 1);
1850 bp_pack_value (bp, fn->returns_struct, 1);
1851 bp_pack_value (bp, fn->always_inline_functions_inlined, 1);
1852 bp_pack_value (bp, fn->after_inlining, 1);
1853 bp_pack_value (bp, fn->dont_save_pending_sizes_p, 1);
1854 bp_pack_value (bp, fn->stdarg, 1);
1855 bp_pack_value (bp, fn->has_nonlocal_label, 1);
1856 bp_pack_value (bp, fn->calls_alloca, 1);
1857 bp_pack_value (bp, fn->calls_setjmp, 1);
1858 bp_pack_value (bp, fn->function_frequency, 2);
1859 bp_pack_value (bp, fn->va_list_fpr_size, 8);
1860 bp_pack_value (bp, fn->va_list_gpr_size, 8);
1861 lto_output_bitpack (ob->main_stream, bp);
1862 bitpack_delete (bp);
1864 /* Output the static chain and non-local goto save area. */
1865 lto_output_tree_ref (ob, fn->static_chain_decl);
1866 lto_output_tree_ref (ob, fn->nonlocal_goto_save_area);
1868 /* Output all the local variables in the function. */
1869 lto_output_tree_ref (ob, fn->local_decls);
1871 /* Output all the SSA names used in the function. */
1872 output_ssa_names (ob, fn);
1874 /* Output any exception handling regions. */
1875 output_eh_regions (ob, fn);
1877 /* Output DECL_INITIAL for the function, which contains the tree of
1879 lto_output_tree (ob, DECL_INITIAL (function), true);
1881 /* Output the head of the arguments list. */
1882 lto_output_tree_ref (ob, DECL_ARGUMENTS (function));
1884 /* We will renumber the statements. The code that does this uses
1885 the same ordering that we use for serializing them so we can use
1886 the same code on the other end and not have to write out the
1887 statement numbers. */
1888 renumber_gimple_stmt_uids ();
1890 /* Output the code for the function. */
1891 FOR_ALL_BB_FN (bb, fn)
1892 output_bb (ob, bb, fn);
1894 /* The terminator for this function. */
1897 output_cfg (ob, fn);
1899 /* Create a section to hold the pickled output of this function. */
1900 produce_asm (ob, function);
1902 destroy_output_block (ob);
1904 current_function_decl = NULL;
1909 /* Return true if alias pair P belongs to the set of cgraph nodes in
1910 SET. If P is a an alias for a VAR_DECL, it can always be emitted.
1911 However, for FUNCTION_DECL aliases, we should only output the pair
1912 if it belongs to a function whose cgraph node is in SET.
1913 Otherwise, the LTRANS phase will get into trouble when finalizing
1914 aliases because the alias will refer to a function not defined in
1915 the file processed by LTRANS. */
1918 output_alias_pair_p (alias_pair *p, cgraph_node_set set)
1920 cgraph_node_set_iterator csi;
1921 struct cgraph_node *target_node;
1923 /* Always emit VAR_DECLs. FIXME lto, we should probably only emit
1924 those VAR_DECLs that are instantiated in this file partition, but
1925 we have no easy way of knowing this based on SET. */
1926 if (TREE_CODE (p->decl) == VAR_DECL)
1929 /* Check if the assembler name for P->TARGET has its cgraph node in SET. */
1930 gcc_assert (TREE_CODE (p->decl) == FUNCTION_DECL);
1931 target_node = cgraph_node_for_asm (p->target);
1932 csi = cgraph_node_set_find (set, target_node);
1933 return (!csi_end_p (csi));
1937 /* Output any unreferenced global symbol defined in SET, alias pairs
1941 output_unreferenced_globals (cgraph_node_set set)
1943 struct output_block *ob;
1946 struct varpool_node *vnode;
1948 ob = create_output_block (LTO_section_static_initializer);
1949 ob->cgraph_node = NULL;
1951 clear_line_info (ob);
1953 /* Make string 0 be a NULL string. */
1954 lto_output_1_stream (ob->string_stream, 0);
1956 /* Emit references for all the global symbols. If a global symbol
1957 was never referenced in any of the functions of this file, it
1958 would not be emitted otherwise. This will result in unreferenced
1959 symbols at link time if a file defines a global symbol but
1960 never references it. */
1961 FOR_EACH_STATIC_VARIABLE (vnode)
1963 tree var = vnode->decl;
1965 if (TREE_CODE (var) == VAR_DECL && TREE_PUBLIC (var))
1966 lto_output_tree_ref (ob, var);
1971 /* Emit the alias pairs for the nodes in SET. */
1972 for (i = 0; VEC_iterate (alias_pair, alias_pairs, i, p); i++)
1974 if (output_alias_pair_p (p, set))
1976 lto_output_tree_ref (ob, p->decl);
1977 lto_output_tree_ref (ob, p->target);
1983 produce_asm (ob, NULL);
1984 destroy_output_block (ob);
1988 /* Copy the function body of NODE without deserializing. */
1991 copy_function (struct cgraph_node *node)
1993 tree function = node->decl;
1994 struct lto_file_decl_data *file_data = node->local.lto_file_data;
1995 struct lto_output_stream *output_stream = XCNEW (struct lto_output_stream);
1998 const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (function));
1999 char *section_name =
2000 lto_get_section_name (LTO_section_function_body, name);
2002 struct lto_in_decl_state *in_state;
2003 struct lto_out_decl_state *out_state = lto_get_out_decl_state ();
2005 lto_begin_section (section_name, !flag_wpa);
2006 free (section_name);
2008 /* We may have renamed the declaration, e.g., a static function. */
2009 name = lto_get_decl_name_mapping (file_data, name);
2011 data = lto_get_section_data (file_data, LTO_section_function_body,
2015 /* Do a bit copy of the function body. */
2016 lto_output_data_stream (output_stream, data, len);
2017 lto_write_stream (output_stream);
2021 lto_get_function_in_decl_state (node->local.lto_file_data, function);
2022 gcc_assert (in_state);
2024 for (i = 0; i < LTO_N_DECL_STREAMS; i++)
2026 size_t n = in_state->streams[i].size;
2027 tree *trees = in_state->streams[i].trees;
2028 struct lto_tree_ref_encoder *encoder = &(out_state->streams[i]);
2030 /* The out state must have the same indices and the in state.
2031 So just copy the vector. All the encoders in the in state
2032 must be empty where we reach here. */
2033 gcc_assert (lto_tree_ref_encoder_size (encoder) == 0);
2034 for (j = 0; j < n; j++)
2035 VEC_safe_push (tree, heap, encoder->trees, trees[j]);
2036 encoder->next_index = n;
2039 lto_free_section_data (file_data, LTO_section_function_body, name,
2041 free (output_stream);
2046 /* Initialize the LTO writer. */
2049 lto_writer_init (void)
2051 lto_streamer_init ();
2055 /* Main entry point from the pass manager. */
2058 lto_output (cgraph_node_set set)
2060 struct cgraph_node *node;
2061 struct lto_out_decl_state *decl_state;
2062 cgraph_node_set_iterator csi;
2063 bitmap output = lto_bitmap_alloc ();
2067 /* Process only the functions with bodies. */
2068 for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
2070 node = csi_node (csi);
2071 if (node->analyzed && !bitmap_bit_p (output, DECL_UID (node->decl)))
2073 bitmap_set_bit (output, DECL_UID (node->decl));
2074 decl_state = lto_new_out_decl_state ();
2075 lto_push_out_decl_state (decl_state);
2077 output_function (node);
2079 copy_function (node);
2080 gcc_assert (lto_get_out_decl_state () == decl_state);
2081 lto_pop_out_decl_state ();
2082 lto_record_function_out_decl_state (node->decl, decl_state);
2086 /* Emit the callgraph after emitting function bodies. This needs to
2087 be done now to make sure that all the statements in every function
2088 have been renumbered so that edges can be associated with call
2089 statements using the statement UIDs. */
2090 output_cgraph (set);
2092 lto_bitmap_free (output);
2095 struct ipa_opt_pass_d pass_ipa_lto_gimple_out =
2099 "lto_gimple_out", /* name */
2100 gate_lto_out, /* gate */
2104 0, /* static_pass_number */
2105 TV_IPA_LTO_GIMPLE_IO, /* tv_id */
2106 0, /* properties_required */
2107 0, /* properties_provided */
2108 0, /* properties_destroyed */
2109 0, /* todo_flags_start */
2110 TODO_dump_func /* todo_flags_finish */
2112 NULL, /* generate_summary */
2113 lto_output, /* write_summary */
2114 NULL, /* read_summary */
2115 NULL, /* function_read_summary */
2117 NULL, /* function_transform */
2118 NULL /* variable_transform */
2122 /* Write each node in encoded by ENCODER to OB, as well as those reachable
2123 from it and required for correct representation of its semantics.
2124 Each node in ENCODER must be a global declaration or a type. A node
2125 is written only once, even if it appears multiple times in the
2126 vector. Certain transitively-reachable nodes, such as those
2127 representing expressions, may be duplicated, but such nodes
2128 must not appear in ENCODER itself. */
2131 write_global_stream (struct output_block *ob,
2132 struct lto_tree_ref_encoder *encoder)
2136 const size_t size = lto_tree_ref_encoder_size (encoder);
2138 for (index = 0; index < size; index++)
2140 t = lto_tree_ref_encoder_get_tree (encoder, index);
2141 if (!lto_streamer_cache_lookup (ob->writer_cache, t, NULL))
2145 /* In WPA we should not emit multiple definitions of the
2146 same symbol to all the files in the link set. If
2147 T had already been emitted as the pervailing definition
2148 in one file, emit it as an external reference in the
2150 /* FIXME lto. We should check if T belongs to the
2151 file we are writing to. */
2152 if (TREE_CODE (t) == VAR_DECL
2154 && !DECL_EXTERNAL (t))
2156 /* FIXME lto. Make DECLS_ALREADY_EMITTED an argument
2157 to this function so it can be freed up afterwards.
2158 Alternately, assign global symbols to cgraph
2160 static struct pointer_set_t *decls_already_emitted = NULL;
2162 if (decls_already_emitted == NULL)
2163 decls_already_emitted = pointer_set_create ();
2165 if (pointer_set_insert (decls_already_emitted, t))
2166 make_decl_one_only (t, DECL_ASSEMBLER_NAME (t));
2170 lto_output_tree (ob, t, false);
2176 /* Write a sequence of indices into the globals vector corresponding
2177 to the trees in ENCODER. These are used by the reader to map the
2178 indices used to refer to global entities within function bodies to
2182 write_global_references (struct output_block *ob,
2183 struct lto_output_stream *ref_stream,
2184 struct lto_tree_ref_encoder *encoder)
2188 const int32_t size = lto_tree_ref_encoder_size (encoder);
2190 /* Write size as 32-bit unsigned. */
2191 lto_output_data_stream (ref_stream, &size, sizeof (int32_t));
2193 for (index = 0; index < size; index++)
2197 t = lto_tree_ref_encoder_get_tree (encoder, index);
2198 lto_streamer_cache_lookup (ob->writer_cache, t, &slot_num);
2199 gcc_assert (slot_num >= 0);
2200 lto_output_data_stream (ref_stream, &slot_num, sizeof slot_num);
2205 /* Write all the streams in an lto_out_decl_state STATE using
2206 output block OB and output stream OUT_STREAM. */
2209 lto_output_decl_state_streams (struct output_block *ob,
2210 struct lto_out_decl_state *state)
2214 for (i = 0; i < LTO_N_DECL_STREAMS; i++)
2215 write_global_stream (ob, &state->streams[i]);
2219 /* Write all the references in an lto_out_decl_state STATE using
2220 output block OB and output stream OUT_STREAM. */
2223 lto_output_decl_state_refs (struct output_block *ob,
2224 struct lto_output_stream *out_stream,
2225 struct lto_out_decl_state *state)
2231 /* Write reference to FUNCTION_DECL. If there is not function,
2232 write reference to void_type_node. */
2233 decl = (state->fn_decl) ? state->fn_decl : void_type_node;
2234 lto_streamer_cache_lookup (ob->writer_cache, decl, &ref);
2235 gcc_assert (ref >= 0);
2236 lto_output_data_stream (out_stream, &ref, sizeof (int32_t));
2238 for (i = 0; i < LTO_N_DECL_STREAMS; i++)
2239 write_global_references (ob, out_stream, &state->streams[i]);
2243 /* Return the written size of STATE. */
2246 lto_out_decl_state_written_size (struct lto_out_decl_state *state)
2251 size = sizeof (int32_t); /* fn_ref. */
2252 for (i = 0; i < LTO_N_DECL_STREAMS; i++)
2254 size += sizeof (int32_t); /* vector size. */
2255 size += (lto_tree_ref_encoder_size (&state->streams[i])
2256 * sizeof (int32_t));
2262 /* Helper function of write_symbols_of_kind. CACHE is the streamer
2263 cache with all the pickled nodes. STREAM is the stream where to
2264 write the table. V is a vector with the DECLs that should be on
2265 the table. SEEN is a bitmap of symbols written so far. */
2268 write_symbol_vec (struct lto_streamer_cache_d *cache,
2269 struct lto_output_stream *stream,
2270 VEC(tree,heap) *v, bitmap seen)
2275 for (index = 0; VEC_iterate(tree, v, index, t); index++)
2278 enum gcc_plugin_symbol_kind kind;
2279 enum gcc_plugin_symbol_visibility visibility;
2284 /* None of the following kinds of symbols are needed in the
2286 if (!TREE_PUBLIC (t)
2287 || is_builtin_fn (t)
2288 || DECL_ABSTRACT (t)
2289 || TREE_CODE (t) == RESULT_DECL)
2292 gcc_assert (TREE_CODE (t) == VAR_DECL
2293 || TREE_CODE (t) == FUNCTION_DECL);
2295 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (t));
2297 /* FIXME lto: this is from assemble_name_raw in varasm.c. For some
2298 architectures we might have to do the same name manipulations that
2299 ASM_OUTPUT_LABELREF does. */
2303 lto_streamer_cache_lookup (cache, t, &slot_num);
2304 gcc_assert (slot_num >= 0);
2306 /* Avoid duplicate symbols. */
2307 if (bitmap_bit_p (seen, slot_num))
2310 bitmap_set_bit (seen, slot_num);
2312 if (DECL_EXTERNAL (t))
2315 kind = GCCPK_WEAKUNDEF;
2322 kind = GCCPK_WEAKDEF;
2323 else if (DECL_COMMON (t))
2324 kind = GCCPK_COMMON;
2329 switch (DECL_VISIBILITY(t))
2331 case VISIBILITY_DEFAULT:
2332 visibility = GCCPV_DEFAULT;
2334 case VISIBILITY_PROTECTED:
2335 visibility = GCCPV_PROTECTED;
2337 case VISIBILITY_HIDDEN:
2338 visibility = GCCPV_HIDDEN;
2340 case VISIBILITY_INTERNAL:
2341 visibility = GCCPV_INTERNAL;
2345 if (kind == GCCPK_COMMON && DECL_SIZE (t))
2346 size = (((uint64_t) TREE_INT_CST_HIGH (DECL_SIZE (t))) << 32)
2347 | TREE_INT_CST_LOW (DECL_SIZE (t));
2351 if (DECL_ONE_ONLY (t))
2352 comdat = IDENTIFIER_POINTER (DECL_COMDAT_GROUP (t));
2356 lto_output_data_stream (stream, name, strlen (name) + 1);
2357 lto_output_data_stream (stream, comdat, strlen (comdat) + 1);
2358 lto_output_data_stream (stream, &kind, 1);
2359 lto_output_data_stream (stream, &visibility, 1);
2360 lto_output_data_stream (stream, &size, 8);
2361 lto_output_data_stream (stream, &slot_num, 4);
2366 /* Write IL symbols of KIND. CACHE is the streamer cache with all the
2367 pickled nodes. SEEN is a bitmap of symbols written so far. */
2370 write_symbols_of_kind (lto_decl_stream_e_t kind,
2371 struct lto_streamer_cache_d *cache, bitmap seen)
2373 struct lto_out_decl_state *out_state;
2374 struct lto_output_stream stream;
2376 VEC_length (lto_out_decl_state_ptr, lto_function_decl_states);
2379 memset (&stream, 0, sizeof (stream));
2380 out_state = lto_get_out_decl_state ();
2381 write_symbol_vec (cache, &stream, out_state->streams[kind].trees, seen);
2383 for (idx = 0; idx < num_fns; idx++)
2386 VEC_index (lto_out_decl_state_ptr, lto_function_decl_states, idx);
2387 write_symbol_vec (cache, &stream, out_state->streams[kind].trees, seen);
2390 lto_write_stream (&stream);
2394 /* Write an IL symbol table. CACHE is the streamer cache with all the
2398 produce_symtab (struct lto_streamer_cache_d *cache)
2400 char *section_name = lto_get_section_name (LTO_section_symtab, NULL);
2403 lto_begin_section (section_name, false);
2404 free (section_name);
2406 seen = lto_bitmap_alloc ();
2407 write_symbols_of_kind (LTO_DECL_STREAM_FN_DECL, cache, seen);
2408 write_symbols_of_kind (LTO_DECL_STREAM_VAR_DECL, cache, seen);
2409 lto_bitmap_free (seen);
2415 /* This pass is run after all of the functions are serialized and all
2416 of the IPA passes have written their serialized forms. This pass
2417 causes the vector of all of the global decls and types used from
2418 this file to be written in to a section that can then be read in to
2419 recover these on other side. */
2422 produce_asm_for_decls (cgraph_node_set set)
2424 struct lto_out_decl_state *out_state;
2425 struct lto_out_decl_state *fn_out_state;
2426 struct lto_decl_header header;
2428 struct output_block *ob;
2429 struct lto_output_stream *header_stream, *decl_state_stream;
2430 unsigned idx, num_fns;
2431 size_t decl_state_size;
2432 int32_t num_decl_states;
2434 ob = create_output_block (LTO_section_decls);
2437 /* Write out unreferenced globals, alias pairs and labels. We defer
2438 doing this until now so that we can write out only what is
2440 output_unreferenced_globals (set);
2442 memset (&header, 0, sizeof (struct lto_decl_header));
2444 section_name = lto_get_section_name (LTO_section_decls, NULL);
2445 lto_begin_section (section_name, !flag_wpa);
2446 free (section_name);
2448 /* Make string 0 be a NULL string. */
2449 lto_output_1_stream (ob->string_stream, 0);
2451 /* Write the global symbols. */
2452 out_state = lto_get_out_decl_state ();
2453 num_fns = VEC_length (lto_out_decl_state_ptr, lto_function_decl_states);
2454 lto_output_decl_state_streams (ob, out_state);
2455 for (idx = 0; idx < num_fns; idx++)
2458 VEC_index (lto_out_decl_state_ptr, lto_function_decl_states, idx);
2459 lto_output_decl_state_streams (ob, fn_out_state);
2462 header.lto_header.major_version = LTO_major_version;
2463 header.lto_header.minor_version = LTO_minor_version;
2464 header.lto_header.section_type = LTO_section_decls;
2466 /* Currently not used. This field would allow us to preallocate
2467 the globals vector, so that it need not be resized as it is extended. */
2468 header.num_nodes = -1;
2470 /* Compute the total size of all decl out states. */
2471 decl_state_size = sizeof (int32_t);
2472 decl_state_size += lto_out_decl_state_written_size (out_state);
2473 for (idx = 0; idx < num_fns; idx++)
2476 VEC_index (lto_out_decl_state_ptr, lto_function_decl_states, idx);
2477 decl_state_size += lto_out_decl_state_written_size (fn_out_state);
2479 header.decl_state_size = decl_state_size;
2481 header.main_size = ob->main_stream->total_size;
2482 header.string_size = ob->string_stream->total_size;
2484 header_stream = XCNEW (struct lto_output_stream);
2485 lto_output_data_stream (header_stream, &header, sizeof header);
2486 lto_write_stream (header_stream);
2487 free (header_stream);
2489 /* Write the main out-decl state, followed by out-decl states of
2491 decl_state_stream = ((struct lto_output_stream *)
2492 xcalloc (1, sizeof (struct lto_output_stream)));
2493 num_decl_states = num_fns + 1;
2494 lto_output_data_stream (decl_state_stream, &num_decl_states,
2495 sizeof (num_decl_states));
2496 lto_output_decl_state_refs (ob, decl_state_stream, out_state);
2497 for (idx = 0; idx < num_fns; idx++)
2500 VEC_index (lto_out_decl_state_ptr, lto_function_decl_states, idx);
2501 lto_output_decl_state_refs (ob, decl_state_stream, fn_out_state);
2503 lto_write_stream (decl_state_stream);
2504 free(decl_state_stream);
2506 lto_write_stream (ob->main_stream);
2507 lto_write_stream (ob->string_stream);
2511 /* Write the symbol table. */
2512 produce_symtab (ob->writer_cache);
2514 /* Write command line opts. */
2515 lto_write_options ();
2517 /* Deallocate memory and clean up. */
2518 lto_cgraph_encoder_delete (ob->decl_state->cgraph_node_encoder);
2519 VEC_free (lto_out_decl_state_ptr, heap, lto_function_decl_states);
2520 lto_function_decl_states = NULL;
2521 destroy_output_block (ob);
2525 struct ipa_opt_pass_d pass_ipa_lto_finish_out =
2529 "lto_decls_out", /* name */
2530 gate_lto_out, /* gate */
2534 0, /* static_pass_number */
2535 TV_IPA_LTO_DECL_IO, /* tv_id */
2536 0, /* properties_required */
2537 0, /* properties_provided */
2538 0, /* properties_destroyed */
2539 0, /* todo_flags_start */
2540 0 /* todo_flags_finish */
2542 NULL, /* generate_summary */
2543 produce_asm_for_decls, /* write_summary */
2544 NULL, /* read_summary */
2545 NULL, /* function_read_summary */
2547 NULL, /* function_transform */
2548 NULL /* variable_transform */