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 gcc_assert (decl_function_context (expr) == NULL);
694 output_record_start (ob, LTO_global_decl_ref);
695 lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr);
699 output_record_start (ob, LTO_const_decl_ref);
700 lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr);
704 gcc_assert (decl_function_context (expr) == NULL);
705 output_record_start (ob, LTO_imported_decl_ref);
706 lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr);
710 output_record_start (ob, LTO_type_decl_ref);
711 lto_output_type_decl_index (ob->decl_state, ob->main_stream, expr);
715 output_record_start (ob, LTO_namespace_decl_ref);
716 lto_output_namespace_decl_index (ob->decl_state, ob->main_stream, expr);
720 output_record_start (ob, LTO_label_decl_ref);
721 lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr);
725 output_record_start (ob, LTO_result_decl_ref);
726 lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr);
730 /* No other node is indexable, so it should have been handled
731 by lto_output_tree. */
737 /* If REF_P is true, emit a reference to EXPR in output block OB,
738 otherwise emit the physical representation of EXPR in OB. */
741 lto_output_tree_or_ref (struct output_block *ob, tree expr, bool ref_p)
744 lto_output_tree_ref (ob, expr);
746 lto_output_tree (ob, expr, false);
750 /* Emit the chain of tree nodes starting at T. OB is the output block
751 to write to. REF_P is true if chain elements should be emitted
755 lto_output_chain (struct output_block *ob, tree t, bool ref_p)
759 count = list_length (t);
760 output_sleb128 (ob, count);
761 for (i = 0; i < count; i++)
765 /* Clear TREE_CHAIN to avoid blindly recursing into the rest
767 saved_chain = TREE_CHAIN (t);
768 TREE_CHAIN (t) = NULL_TREE;
770 lto_output_tree_or_ref (ob, t, ref_p);
772 TREE_CHAIN (t) = saved_chain;
778 /* Write all pointer fields in the TS_COMMON structure of EXPR to output
779 block OB. If REF_P is true, write a reference to EXPR's pointer
783 lto_output_ts_common_tree_pointers (struct output_block *ob, tree expr,
786 lto_output_tree_or_ref (ob, TREE_TYPE (expr), ref_p);
790 /* Write all pointer fields in the TS_VECTOR structure of EXPR to output
791 block OB. If REF_P is true, write a reference to EXPR's pointer
795 lto_output_ts_vector_tree_pointers (struct output_block *ob, tree expr,
798 lto_output_chain (ob, TREE_VECTOR_CST_ELTS (expr), ref_p);
802 /* Write all pointer fields in the TS_COMPLEX structure of EXPR to output
803 block OB. If REF_P is true, write a reference to EXPR's pointer
807 lto_output_ts_complex_tree_pointers (struct output_block *ob, tree expr,
810 lto_output_tree_or_ref (ob, TREE_REALPART (expr), ref_p);
811 lto_output_tree_or_ref (ob, TREE_IMAGPART (expr), ref_p);
815 /* Write all pointer fields in the TS_DECL_MINIMAL structure of EXPR
816 to output block OB. If REF_P is true, write a reference to EXPR's
820 lto_output_ts_decl_minimal_tree_pointers (struct output_block *ob, tree expr,
823 lto_output_tree_or_ref (ob, DECL_NAME (expr), ref_p);
824 lto_output_tree_or_ref (ob, DECL_CONTEXT (expr), ref_p);
825 lto_output_location (ob, DECL_SOURCE_LOCATION (expr));
829 /* Write all pointer fields in the TS_DECL_COMMON structure of EXPR to
830 output block OB. If REF_P is true, write a reference to EXPR's
834 lto_output_ts_decl_common_tree_pointers (struct output_block *ob, tree expr,
837 lto_output_tree_or_ref (ob, DECL_SIZE (expr), ref_p);
838 lto_output_tree_or_ref (ob, DECL_SIZE_UNIT (expr), ref_p);
840 if (TREE_CODE (expr) != FUNCTION_DECL)
841 lto_output_tree_or_ref (ob, DECL_INITIAL (expr), ref_p);
843 lto_output_tree_or_ref (ob, DECL_ATTRIBUTES (expr), ref_p);
844 lto_output_tree_or_ref (ob, DECL_ABSTRACT_ORIGIN (expr), ref_p);
846 if (TREE_CODE (expr) == PARM_DECL)
847 lto_output_chain (ob, TREE_CHAIN (expr), ref_p);
851 /* Write all pointer fields in the TS_DECL_NON_COMMON structure of
852 EXPR to output block OB. If REF_P is true, write a reference to EXPR's
856 lto_output_ts_decl_non_common_tree_pointers (struct output_block *ob,
857 tree expr, bool ref_p)
859 if (TREE_CODE (expr) == FUNCTION_DECL)
861 /* DECL_SAVED_TREE holds the GENERIC representation for DECL.
862 At this point, it should not exist. Either because it was
863 converted to gimple or because DECL didn't have a GENERIC
864 representation in this TU. */
865 gcc_assert (DECL_SAVED_TREE (expr) == NULL_TREE);
866 lto_output_tree_or_ref (ob, DECL_ARGUMENTS (expr), ref_p);
867 lto_output_tree_or_ref (ob, DECL_RESULT (expr), ref_p);
869 lto_output_tree_or_ref (ob, DECL_VINDEX (expr), ref_p);
873 /* Write all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
874 to output block OB. If REF_P is true, write a reference to EXPR's
878 lto_output_ts_decl_with_vis_tree_pointers (struct output_block *ob, tree expr,
881 /* Make sure we don't inadvertently set the assembler name. */
882 if (DECL_ASSEMBLER_NAME_SET_P (expr))
883 lto_output_tree_or_ref (ob, DECL_ASSEMBLER_NAME (expr), ref_p);
887 lto_output_tree_or_ref (ob, DECL_SECTION_NAME (expr), ref_p);
888 lto_output_tree_or_ref (ob, DECL_COMDAT_GROUP (expr), ref_p);
892 /* Write all pointer fields in the TS_FIELD_DECL structure of EXPR to
893 output block OB. If REF_P is true, write a reference to EXPR's
897 lto_output_ts_field_decl_tree_pointers (struct output_block *ob, tree expr,
900 lto_output_tree_or_ref (ob, DECL_FIELD_OFFSET (expr), ref_p);
901 lto_output_tree_or_ref (ob, DECL_BIT_FIELD_TYPE (expr), ref_p);
902 lto_output_tree_or_ref (ob, DECL_QUALIFIER (expr), ref_p);
903 lto_output_tree_or_ref (ob, DECL_FIELD_BIT_OFFSET (expr), ref_p);
904 lto_output_tree_or_ref (ob, DECL_FCONTEXT (expr), ref_p);
905 lto_output_chain (ob, TREE_CHAIN (expr), ref_p);
909 /* Write all pointer fields in the TS_FUNCTION_DECL structure of EXPR
910 to output block OB. If REF_P is true, write a reference to EXPR's
914 lto_output_ts_function_decl_tree_pointers (struct output_block *ob, tree expr,
917 /* DECL_STRUCT_FUNCTION is handled by lto_output_function. FIXME lto,
918 maybe it should be handled here? */
919 lto_output_tree_or_ref (ob, DECL_FUNCTION_PERSONALITY (expr), ref_p);
920 lto_output_tree_or_ref (ob, DECL_FUNCTION_SPECIFIC_TARGET (expr), ref_p);
921 lto_output_tree_or_ref (ob, DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr),
926 /* Write all pointer fields in the TS_TYPE structure of EXPR to output
927 block OB. If REF_P is true, write a reference to EXPR's pointer
931 lto_output_ts_type_tree_pointers (struct output_block *ob, tree expr,
934 if (TREE_CODE (expr) == ENUMERAL_TYPE)
935 lto_output_tree_or_ref (ob, TYPE_VALUES (expr), ref_p);
936 else if (TREE_CODE (expr) == ARRAY_TYPE)
937 lto_output_tree_or_ref (ob, TYPE_DOMAIN (expr), ref_p);
938 else if (TREE_CODE (expr) == RECORD_TYPE || TREE_CODE (expr) == UNION_TYPE)
939 lto_output_tree_or_ref (ob, TYPE_FIELDS (expr), ref_p);
940 else if (TREE_CODE (expr) == FUNCTION_TYPE || TREE_CODE (expr) == METHOD_TYPE)
941 lto_output_tree_or_ref (ob, TYPE_ARG_TYPES (expr), ref_p);
942 else if (TREE_CODE (expr) == VECTOR_TYPE)
943 lto_output_tree_or_ref (ob, TYPE_DEBUG_REPRESENTATION_TYPE (expr), ref_p);
945 lto_output_tree_or_ref (ob, TYPE_SIZE (expr), ref_p);
946 lto_output_tree_or_ref (ob, TYPE_SIZE_UNIT (expr), ref_p);
947 lto_output_tree_or_ref (ob, TYPE_ATTRIBUTES (expr), ref_p);
948 lto_output_tree_or_ref (ob, TYPE_NAME (expr), ref_p);
949 /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO nor
950 TYPE_NEXT_PTR_TO or TYPE_NEXT_REF_TO. */
951 if (!POINTER_TYPE_P (expr))
952 lto_output_tree_or_ref (ob, TYPE_MINVAL (expr), ref_p);
953 lto_output_tree_or_ref (ob, TYPE_MAXVAL (expr), ref_p);
954 lto_output_tree_or_ref (ob, TYPE_MAIN_VARIANT (expr), ref_p);
955 /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
957 if (TREE_CODE (expr) == RECORD_TYPE || TREE_CODE (expr) == UNION_TYPE)
958 lto_output_tree_or_ref (ob, TYPE_BINFO (expr), ref_p);
959 lto_output_tree_or_ref (ob, TYPE_CONTEXT (expr), ref_p);
960 lto_output_tree_or_ref (ob, TYPE_CANONICAL (expr), ref_p);
964 /* Write all pointer fields in the TS_LIST structure of EXPR to output
965 block OB. If REF_P is true, write a reference to EXPR's pointer
969 lto_output_ts_list_tree_pointers (struct output_block *ob, tree expr,
972 lto_output_tree_or_ref (ob, TREE_PURPOSE (expr), ref_p);
973 lto_output_tree_or_ref (ob, TREE_VALUE (expr), ref_p);
974 lto_output_chain (ob, TREE_CHAIN (expr), ref_p);
978 /* Write all pointer fields in the TS_VEC structure of EXPR to output
979 block OB. If REF_P is true, write a reference to EXPR's pointer
983 lto_output_ts_vec_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
987 /* Note that the number of slots for EXPR has already been emitted
988 in EXPR's header (see lto_output_tree_header). */
989 for (i = 0; i < TREE_VEC_LENGTH (expr); i++)
990 lto_output_tree_or_ref (ob, TREE_VEC_ELT (expr, i), ref_p);
994 /* Write all pointer fields in the TS_EXP structure of EXPR to output
995 block OB. If REF_P is true, write a reference to EXPR's pointer
999 lto_output_ts_exp_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
1003 output_sleb128 (ob, TREE_OPERAND_LENGTH (expr));
1004 for (i = 0; i < TREE_OPERAND_LENGTH (expr); i++)
1005 lto_output_tree_or_ref (ob, TREE_OPERAND (expr, i), ref_p);
1006 lto_output_location (ob, EXPR_LOCATION (expr));
1007 lto_output_tree_or_ref (ob, TREE_BLOCK (expr), ref_p);
1011 /* Write all pointer fields in the TS_BLOCK structure of EXPR to output
1012 block OB. If REF_P is true, write a reference to EXPR's pointer
1016 lto_output_ts_block_tree_pointers (struct output_block *ob, tree expr,
1022 lto_output_location (ob, BLOCK_SOURCE_LOCATION (expr));
1023 lto_output_chain (ob, BLOCK_VARS (expr), ref_p);
1025 output_uleb128 (ob, VEC_length (tree, BLOCK_NONLOCALIZED_VARS (expr)));
1026 for (i = 0; VEC_iterate (tree, BLOCK_NONLOCALIZED_VARS (expr), i, t); i++)
1027 lto_output_tree_or_ref (ob, t, ref_p);
1029 lto_output_tree_or_ref (ob, BLOCK_SUPERCONTEXT (expr), ref_p);
1030 lto_output_tree_or_ref (ob, BLOCK_ABSTRACT_ORIGIN (expr), ref_p);
1031 lto_output_tree_or_ref (ob, BLOCK_FRAGMENT_ORIGIN (expr), ref_p);
1032 lto_output_tree_or_ref (ob, BLOCK_FRAGMENT_CHAIN (expr), ref_p);
1033 lto_output_chain (ob, BLOCK_SUBBLOCKS (expr), ref_p);
1037 /* Write all pointer fields in the TS_BINFO structure of EXPR to output
1038 block OB. If REF_P is true, write a reference to EXPR's pointer
1042 lto_output_ts_binfo_tree_pointers (struct output_block *ob, tree expr,
1048 /* Note that the number of BINFO slots has already been emitted in
1049 EXPR's header (see lto_output_tree_header) because this length
1050 is needed to build the empty BINFO node on the reader side. */
1051 for (i = 0; VEC_iterate (tree, BINFO_BASE_BINFOS (expr), i, t); i++)
1052 lto_output_tree_or_ref (ob, t, ref_p);
1055 lto_output_tree_or_ref (ob, BINFO_OFFSET (expr), ref_p);
1056 lto_output_tree_or_ref (ob, BINFO_VTABLE (expr), ref_p);
1057 lto_output_tree_or_ref (ob, BINFO_VIRTUALS (expr), ref_p);
1058 lto_output_tree_or_ref (ob, BINFO_VPTR_FIELD (expr), ref_p);
1060 output_uleb128 (ob, VEC_length (tree, BINFO_BASE_ACCESSES (expr)));
1061 for (i = 0; VEC_iterate (tree, BINFO_BASE_ACCESSES (expr), i, t); i++)
1062 lto_output_tree_or_ref (ob, t, ref_p);
1064 lto_output_tree_or_ref (ob, BINFO_INHERITANCE_CHAIN (expr), ref_p);
1065 lto_output_tree_or_ref (ob, BINFO_SUBVTT_INDEX (expr), ref_p);
1066 lto_output_tree_or_ref (ob, BINFO_VPTR_INDEX (expr), ref_p);
1070 /* Write all pointer fields in the TS_CONSTRUCTOR structure of EXPR to
1071 output block OB. If REF_P is true, write a reference to EXPR's
1075 lto_output_ts_constructor_tree_pointers (struct output_block *ob, tree expr,
1081 output_uleb128 (ob, CONSTRUCTOR_NELTS (expr));
1082 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (expr), i, index, value)
1084 lto_output_tree_or_ref (ob, index, ref_p);
1085 lto_output_tree_or_ref (ob, value, ref_p);
1090 /* Helper for lto_output_tree. Write all pointer fields in EXPR to output
1091 block OB. If REF_P is true, the leaves of EXPR are emitted as
1095 lto_output_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
1097 enum tree_code code;
1099 code = TREE_CODE (expr);
1101 if (CODE_CONTAINS_STRUCT (code, TS_COMMON))
1102 lto_output_ts_common_tree_pointers (ob, expr, ref_p);
1104 if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
1105 lto_output_ts_vector_tree_pointers (ob, expr, ref_p);
1107 if (CODE_CONTAINS_STRUCT (code, TS_COMPLEX))
1108 lto_output_ts_complex_tree_pointers (ob, expr, ref_p);
1110 if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
1111 lto_output_ts_decl_minimal_tree_pointers (ob, expr, ref_p);
1113 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
1114 lto_output_ts_decl_common_tree_pointers (ob, expr, ref_p);
1116 if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
1117 lto_output_ts_decl_non_common_tree_pointers (ob, expr, ref_p);
1119 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
1120 lto_output_ts_decl_with_vis_tree_pointers (ob, expr, ref_p);
1122 if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL))
1123 lto_output_ts_field_decl_tree_pointers (ob, expr, ref_p);
1125 if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
1126 lto_output_ts_function_decl_tree_pointers (ob, expr, ref_p);
1128 if (CODE_CONTAINS_STRUCT (code, TS_TYPE))
1129 lto_output_ts_type_tree_pointers (ob, expr, ref_p);
1131 if (CODE_CONTAINS_STRUCT (code, TS_LIST))
1132 lto_output_ts_list_tree_pointers (ob, expr, ref_p);
1134 if (CODE_CONTAINS_STRUCT (code, TS_VEC))
1135 lto_output_ts_vec_tree_pointers (ob, expr, ref_p);
1137 if (CODE_CONTAINS_STRUCT (code, TS_EXP))
1138 lto_output_ts_exp_tree_pointers (ob, expr, ref_p);
1140 if (CODE_CONTAINS_STRUCT (code, TS_SSA_NAME))
1142 /* We only stream the version number of SSA names. */
1146 if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
1147 lto_output_ts_block_tree_pointers (ob, expr, ref_p);
1149 if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
1150 lto_output_ts_binfo_tree_pointers (ob, expr, ref_p);
1152 if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
1153 lto_output_ts_constructor_tree_pointers (ob, expr, ref_p);
1155 if (CODE_CONTAINS_STRUCT (code, TS_STATEMENT_LIST))
1157 /* This should only appear in GENERIC. */
1161 if (CODE_CONTAINS_STRUCT (code, TS_OMP_CLAUSE))
1163 /* This should only appear in High GIMPLE. */
1167 if (CODE_CONTAINS_STRUCT (code, TS_OPTIMIZATION))
1168 sorry ("gimple bytecode streams do not support the optimization attribute");
1170 if (CODE_CONTAINS_STRUCT (code, TS_TARGET_OPTION))
1171 sorry ("gimple bytecode streams do not support the target attribute");
1175 /* Emit header information for tree EXPR to output block OB. The header
1176 contains everything needed to instantiate an empty skeleton for
1177 EXPR on the reading side. IX is the index into the streamer cache
1178 where EXPR is stored. REF_P is as in lto_output_tree. */
1181 lto_output_tree_header (struct output_block *ob, tree expr, int ix)
1184 enum tree_code code;
1186 /* We should not see any non-GIMPLE tree nodes here. */
1187 code = TREE_CODE (expr);
1188 if (!lto_is_streamable (expr))
1189 internal_error ("tree code %qs is not supported in gimple streams",
1190 tree_code_name[code]);
1192 /* The header of a tree node consists of its tag, the size of
1193 the node, and any other information needed to instantiate
1194 EXPR on the reading side (such as the number of slots in
1195 variable sized nodes). */
1196 tag = lto_tree_code_to_tag (code);
1197 output_record_start (ob, tag);
1198 output_sleb128 (ob, ix);
1200 /* The following will cause bootstrap miscomparisons. Enable with care. */
1201 #ifdef LTO_STREAMER_DEBUG
1202 /* This is used mainly for debugging purposes. When the reader
1203 and the writer do not agree on a streamed node, the pointer
1204 value for EXPR can be used to track down the differences in
1206 gcc_assert ((HOST_WIDEST_INT) (intptr_t) expr == (intptr_t) expr);
1207 output_sleb128 (ob, (HOST_WIDEST_INT) (intptr_t) expr);
1210 /* The text in strings and identifiers are completely emitted in
1212 if (CODE_CONTAINS_STRUCT (code, TS_STRING))
1213 output_string_cst (ob, ob->main_stream, expr);
1214 else if (CODE_CONTAINS_STRUCT (code, TS_IDENTIFIER))
1215 output_identifier (ob, ob->main_stream, expr);
1216 else if (CODE_CONTAINS_STRUCT (code, TS_VEC))
1217 output_sleb128 (ob, TREE_VEC_LENGTH (expr));
1218 else if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
1219 output_uleb128 (ob, BINFO_N_BASE_BINFOS (expr));
1223 /* Write the code and class of builtin EXPR to output block OB. IX is
1224 the index into the streamer cache where EXPR is stored.*/
1227 lto_output_builtin_tree (struct output_block *ob, tree expr, int ix)
1229 gcc_assert (lto_stream_as_builtin_p (expr));
1231 if (DECL_BUILT_IN_CLASS (expr) == BUILT_IN_MD
1232 && !targetm.builtin_decl)
1233 sorry ("gimple bytecode streams do not support machine specific builtin "
1234 "functions on this target");
1236 output_record_start (ob, LTO_builtin_decl);
1237 output_uleb128 (ob, DECL_BUILT_IN_CLASS (expr));
1238 output_uleb128 (ob, DECL_FUNCTION_CODE (expr));
1239 output_sleb128 (ob, ix);
1241 if (DECL_ASSEMBLER_NAME_SET_P (expr))
1243 /* When the assembler name of a builtin gets a user name,
1244 the new name is always prefixed with '*' by
1245 set_builtin_user_assembler_name. So, to prevent the
1246 reader side from adding a second '*', we omit it here. */
1247 const char *str = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (expr));
1248 if (strlen (str) > 1 && str[0] == '*')
1249 output_string (ob, ob->main_stream, &str[1]);
1251 output_string (ob, ob->main_stream, NULL);
1254 output_string (ob, ob->main_stream, NULL);
1258 /* Write a physical representation of tree node EXPR to output block
1259 OB. If REF_P is true, the leaves of EXPR are emitted as references
1260 via lto_output_tree_ref. IX is the index into the streamer cache
1261 where EXPR is stored. */
1264 lto_write_tree (struct output_block *ob, tree expr, bool ref_p, int ix)
1266 struct bitpack_d *bp;
1268 /* Write the header, containing everything needed to materialize
1269 EXPR on the reading side. */
1270 lto_output_tree_header (ob, expr, ix);
1272 /* Pack all the non-pointer fields in EXPR into a bitpack and write
1273 the resulting bitpack. */
1274 bp = pack_value_fields (expr);
1275 lto_output_bitpack (ob->main_stream, bp);
1276 bitpack_delete (bp);
1278 /* Write all the pointer fields in EXPR. */
1279 lto_output_tree_pointers (ob, expr, ref_p);
1281 /* Mark the end of EXPR. */
1286 /* Emit the integer constant CST to output block OB. If REF_P is true,
1287 CST's type will be emitted as a reference. */
1290 lto_output_integer_cst (struct output_block *ob, tree cst, bool ref_p)
1292 output_record_start (ob, lto_tree_code_to_tag (INTEGER_CST));
1293 lto_output_tree_or_ref (ob, TREE_TYPE (cst), ref_p);
1294 lto_output_1_stream (ob->main_stream, TREE_OVERFLOW_P (cst));
1295 output_uleb128 (ob, TREE_INT_CST_LOW (cst));
1296 output_uleb128 (ob, TREE_INT_CST_HIGH (cst));
1300 /* Emit the physical representation of tree node EXPR to output block
1301 OB. If REF_P is true, the leaves of EXPR are emitted as references
1302 via lto_output_tree_ref. */
1305 lto_output_tree (struct output_block *ob, tree expr, bool ref_p)
1311 if (expr == NULL_TREE)
1317 /* INTEGER_CST nodes are special because they need their original type
1318 to be materialized by the reader (to implement TYPE_CACHED_VALUES). */
1319 if (TREE_CODE (expr) == INTEGER_CST)
1321 lto_output_integer_cst (ob, expr, ref_p);
1325 /* Determine the offset in the stream where EXPR will be written.
1326 This is used when emitting pickle references so the reader knows
1327 where to reconstruct the pickled object from. This allows
1328 circular and forward references within the same stream. */
1329 offset = ob->main_stream->total_size;
1331 existed_p = lto_streamer_cache_insert (ob->writer_cache, expr, &ix, &offset);
1334 /* If a node has already been streamed out, make sure that
1335 we don't write it more than once. Otherwise, the reader
1336 will instantiate two different nodes for the same object. */
1337 output_record_start (ob, LTO_tree_pickle_reference);
1338 output_sleb128 (ob, ix);
1339 output_uleb128 (ob, lto_tree_code_to_tag (TREE_CODE (expr)));
1340 output_uleb128 (ob, offset);
1342 else if (lto_stream_as_builtin_p (expr))
1344 /* MD and NORMAL builtins do not need to be written out
1345 completely as they are always instantiated by the
1346 compiler on startup. The only builtins that need to
1347 be written out are BUILT_IN_FRONTEND. For all other
1348 builtins, we simply write the class and code. */
1349 lto_output_builtin_tree (ob, expr, ix);
1353 /* This is the first time we see EXPR, write its fields
1355 lto_write_tree (ob, expr, ref_p, ix);
1360 /* Output to OB a list of try/catch handlers starting with FIRST. */
1363 output_eh_try_list (struct output_block *ob, eh_catch first)
1367 for (n = first; n; n = n->next_catch)
1369 output_record_start (ob, LTO_eh_catch);
1370 lto_output_tree_ref (ob, n->type_list);
1371 lto_output_tree_ref (ob, n->filter_list);
1372 lto_output_tree_ref (ob, n->label);
1379 /* Output EH region R in function FN to OB. CURR_RN is the slot index
1380 that is being emitted in FN->EH->REGION_ARRAY. This is used to
1381 detect EH region sharing. */
1384 output_eh_region (struct output_block *ob, eh_region r)
1394 if (r->type == ERT_CLEANUP)
1395 tag = LTO_ert_cleanup;
1396 else if (r->type == ERT_TRY)
1398 else if (r->type == ERT_ALLOWED_EXCEPTIONS)
1399 tag = LTO_ert_allowed_exceptions;
1400 else if (r->type == ERT_MUST_NOT_THROW)
1401 tag = LTO_ert_must_not_throw;
1405 output_record_start (ob, tag);
1406 output_sleb128 (ob, r->index);
1409 output_sleb128 (ob, r->outer->index);
1414 output_sleb128 (ob, r->inner->index);
1419 output_sleb128 (ob, r->next_peer->index);
1423 if (r->type == ERT_TRY)
1425 output_eh_try_list (ob, r->u.eh_try.first_catch);
1427 else if (r->type == ERT_ALLOWED_EXCEPTIONS)
1429 lto_output_tree_ref (ob, r->u.allowed.type_list);
1430 lto_output_tree_ref (ob, r->u.allowed.label);
1431 output_uleb128 (ob, r->u.allowed.filter);
1433 else if (r->type == ERT_MUST_NOT_THROW)
1435 lto_output_tree_ref (ob, r->u.must_not_throw.failure_decl);
1436 lto_output_location (ob, r->u.must_not_throw.failure_loc);
1439 if (r->landing_pads)
1440 output_sleb128 (ob, r->landing_pads->index);
1446 /* Output landing pad LP to OB. */
1449 output_eh_lp (struct output_block *ob, eh_landing_pad lp)
1457 output_record_start (ob, LTO_eh_landing_pad);
1458 output_sleb128 (ob, lp->index);
1460 output_sleb128 (ob, lp->next_lp->index);
1465 output_sleb128 (ob, lp->region->index);
1469 lto_output_tree_ref (ob, lp->post_landing_pad);
1473 /* Output the existing eh_table to OB. */
1476 output_eh_regions (struct output_block *ob, struct function *fn)
1478 if (fn->eh && fn->eh->region_tree)
1485 output_record_start (ob, LTO_eh_table);
1487 /* Emit the index of the root of the EH region tree. */
1488 output_sleb128 (ob, fn->eh->region_tree->index);
1490 /* Emit all the EH regions in the region array. */
1491 output_sleb128 (ob, VEC_length (eh_region, fn->eh->region_array));
1492 for (i = 0; VEC_iterate (eh_region, fn->eh->region_array, i, eh); i++)
1493 output_eh_region (ob, eh);
1495 /* Emit all landing pads. */
1496 output_sleb128 (ob, VEC_length (eh_landing_pad, fn->eh->lp_array));
1497 for (i = 0; VEC_iterate (eh_landing_pad, fn->eh->lp_array, i, lp); i++)
1498 output_eh_lp (ob, lp);
1500 /* Emit all the runtime type data. */
1501 output_sleb128 (ob, VEC_length (tree, fn->eh->ttype_data));
1502 for (i = 0; VEC_iterate (tree, fn->eh->ttype_data, i, ttype); i++)
1503 lto_output_tree_ref (ob, ttype);
1505 /* Emit the table of action chains. */
1506 if (targetm.arm_eabi_unwinder)
1509 output_sleb128 (ob, VEC_length (tree, fn->eh->ehspec_data.arm_eabi));
1511 VEC_iterate (tree, fn->eh->ehspec_data.arm_eabi, i, t);
1513 lto_output_tree_ref (ob, t);
1518 output_sleb128 (ob, VEC_length (uchar, fn->eh->ehspec_data.other));
1519 for (i = 0; VEC_iterate (uchar, fn->eh->ehspec_data.other, i, c); i++)
1520 lto_output_1_stream (ob->main_stream, c);
1524 /* The 0 either terminates the record or indicates that there are no
1525 eh_records at all. */
1530 /* Output all of the active ssa names to the ssa_names stream. */
1533 output_ssa_names (struct output_block *ob, struct function *fn)
1535 unsigned int i, len;
1537 len = VEC_length (tree, SSANAMES (fn));
1538 output_uleb128 (ob, len);
1540 for (i = 1; i < len; i++)
1542 tree ptr = VEC_index (tree, SSANAMES (fn), i);
1544 if (ptr == NULL_TREE
1545 || SSA_NAME_IN_FREE_LIST (ptr)
1546 || !is_gimple_reg (ptr))
1549 output_uleb128 (ob, i);
1550 lto_output_1_stream (ob->main_stream, SSA_NAME_IS_DEFAULT_DEF (ptr));
1551 lto_output_tree_ref (ob, SSA_NAME_VAR (ptr));
1558 /* Output the cfg. */
1561 output_cfg (struct output_block *ob, struct function *fn)
1563 struct lto_output_stream *tmp_stream = ob->main_stream;
1566 ob->main_stream = ob->cfg_stream;
1568 output_uleb128 (ob, profile_status_for_function (fn));
1570 /* Output the number of the highest basic block. */
1571 output_uleb128 (ob, last_basic_block_for_function (fn));
1573 FOR_ALL_BB_FN (bb, fn)
1578 output_sleb128 (ob, bb->index);
1580 /* Output the successors and the edge flags. */
1581 output_uleb128 (ob, EDGE_COUNT (bb->succs));
1582 FOR_EACH_EDGE (e, ei, bb->succs)
1584 output_uleb128 (ob, e->dest->index);
1585 output_sleb128 (ob, e->probability);
1586 output_sleb128 (ob, e->count);
1587 output_uleb128 (ob, e->flags);
1591 output_sleb128 (ob, -1);
1593 bb = ENTRY_BLOCK_PTR;
1596 output_sleb128 (ob, bb->next_bb->index);
1600 output_sleb128 (ob, -1);
1602 ob->main_stream = tmp_stream;
1606 /* Output PHI function PHI to the main stream in OB. */
1609 output_phi (struct output_block *ob, gimple phi)
1611 unsigned i, len = gimple_phi_num_args (phi);
1613 output_record_start (ob, lto_gimple_code_to_tag (GIMPLE_PHI));
1614 output_uleb128 (ob, SSA_NAME_VERSION (PHI_RESULT (phi)));
1616 for (i = 0; i < len; i++)
1618 lto_output_tree_ref (ob, gimple_phi_arg_def (phi, i));
1619 output_uleb128 (ob, gimple_phi_arg_edge (phi, i)->src->index);
1620 lto_output_location (ob, gimple_phi_arg_location (phi, i));
1625 /* Emit statement STMT on the main stream of output block OB. */
1628 output_gimple_stmt (struct output_block *ob, gimple stmt)
1631 enum gimple_code code;
1633 struct bitpack_d *bp;
1635 /* Emit identifying tag. */
1636 code = gimple_code (stmt);
1637 tag = lto_gimple_code_to_tag (code);
1638 output_record_start (ob, tag);
1640 /* Emit the tuple header. */
1641 bp = bitpack_create ();
1642 bp_pack_value (bp, gimple_num_ops (stmt), sizeof (unsigned) * 8);
1643 bp_pack_value (bp, gimple_no_warning_p (stmt), 1);
1644 if (is_gimple_assign (stmt))
1645 bp_pack_value (bp, gimple_assign_nontemporal_move_p (stmt), 1);
1646 bp_pack_value (bp, gimple_has_volatile_ops (stmt), 1);
1647 bp_pack_value (bp, stmt->gsbase.subcode, 16);
1648 lto_output_bitpack (ob->main_stream, bp);
1649 bitpack_delete (bp);
1651 /* Emit location information for the statement. */
1652 lto_output_location (ob, gimple_location (stmt));
1654 /* Emit the lexical block holding STMT. */
1655 lto_output_tree (ob, gimple_block (stmt), true);
1657 /* Emit the operands. */
1658 switch (gimple_code (stmt))
1661 output_sleb128 (ob, gimple_resx_region (stmt));
1664 case GIMPLE_EH_MUST_NOT_THROW:
1665 lto_output_tree_ref (ob, gimple_eh_must_not_throw_fndecl (stmt));
1668 case GIMPLE_EH_DISPATCH:
1669 output_sleb128 (ob, gimple_eh_dispatch_region (stmt));
1673 lto_output_uleb128_stream (ob->main_stream, gimple_asm_ninputs (stmt));
1674 lto_output_uleb128_stream (ob->main_stream, gimple_asm_noutputs (stmt));
1675 lto_output_uleb128_stream (ob->main_stream, gimple_asm_nclobbers (stmt));
1676 output_string (ob, ob->main_stream, gimple_asm_string (stmt));
1687 for (i = 0; i < gimple_num_ops (stmt); i++)
1689 tree op = gimple_op (stmt, i);
1690 lto_output_tree_ref (ob, op);
1695 case GIMPLE_PREDICT:
1704 /* Output a basic block BB to the main stream in OB for this FN. */
1707 output_bb (struct output_block *ob, basic_block bb, struct function *fn)
1709 gimple_stmt_iterator bsi = gsi_start_bb (bb);
1711 output_record_start (ob,
1712 (!gsi_end_p (bsi)) || phi_nodes (bb)
1716 output_uleb128 (ob, bb->index);
1717 output_sleb128 (ob, bb->count);
1718 output_sleb128 (ob, bb->loop_depth);
1719 output_sleb128 (ob, bb->frequency);
1720 output_sleb128 (ob, bb->flags);
1722 if (!gsi_end_p (bsi) || phi_nodes (bb))
1724 /* Output the statements. The list of statements is terminated
1726 for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
1729 gimple stmt = gsi_stmt (bsi);
1731 output_gimple_stmt (ob, stmt);
1733 /* Emit the EH region holding STMT. */
1734 region = lookup_stmt_eh_lp_fn (fn, stmt);
1737 output_record_start (ob, LTO_eh_region);
1738 output_sleb128 (ob, region);
1746 for (bsi = gsi_start_phis (bb); !gsi_end_p (bsi); gsi_next (&bsi))
1748 gimple phi = gsi_stmt (bsi);
1750 /* Only emit PHIs for gimple registers. PHI nodes for .MEM
1751 will be filled in on reading when the SSA form is
1753 if (is_gimple_reg (gimple_phi_result (phi)))
1754 output_phi (ob, phi);
1761 /* Create the header in the file using OB. If the section type is for
1762 a function, set FN to the decl for that function. */
1765 produce_asm (struct output_block *ob, tree fn)
1767 enum lto_section_type section_type = ob->section_type;
1768 struct lto_function_header header;
1770 struct lto_output_stream *header_stream;
1772 if (section_type == LTO_section_function_body)
1774 const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fn));
1775 section_name = lto_get_section_name (section_type, name);
1778 section_name = lto_get_section_name (section_type, NULL);
1780 lto_begin_section (section_name, !flag_wpa);
1781 free (section_name);
1783 /* The entire header is stream computed here. */
1784 memset (&header, 0, sizeof (struct lto_function_header));
1786 /* Write the header. */
1787 header.lto_header.major_version = LTO_major_version;
1788 header.lto_header.minor_version = LTO_minor_version;
1789 header.lto_header.section_type = section_type;
1791 header.compressed_size = 0;
1793 if (section_type == LTO_section_function_body)
1794 header.cfg_size = ob->cfg_stream->total_size;
1795 header.main_size = ob->main_stream->total_size;
1796 header.string_size = ob->string_stream->total_size;
1798 header_stream = XCNEW (struct lto_output_stream);
1799 lto_output_data_stream (header_stream, &header, sizeof header);
1800 lto_write_stream (header_stream);
1801 free (header_stream);
1803 /* Put all of the gimple and the string table out the asm file as a
1805 if (section_type == LTO_section_function_body)
1806 lto_write_stream (ob->cfg_stream);
1807 lto_write_stream (ob->main_stream);
1808 lto_write_stream (ob->string_stream);
1814 /* Output the body of function NODE->DECL. */
1817 output_function (struct cgraph_node *node)
1819 struct bitpack_d *bp;
1821 struct function *fn;
1823 struct output_block *ob;
1825 function = node->decl;
1826 fn = DECL_STRUCT_FUNCTION (function);
1827 ob = create_output_block (LTO_section_function_body);
1829 clear_line_info (ob);
1830 ob->cgraph_node = node;
1832 gcc_assert (current_function_decl == NULL_TREE && cfun == NULL);
1834 /* Set current_function_decl and cfun. */
1835 current_function_decl = function;
1838 /* Make string 0 be a NULL string. */
1839 lto_output_1_stream (ob->string_stream, 0);
1841 output_record_start (ob, LTO_function);
1843 /* Write all the attributes for FN. */
1844 bp = bitpack_create ();
1845 bp_pack_value (bp, fn->is_thunk, 1);
1846 bp_pack_value (bp, fn->has_local_explicit_reg_vars, 1);
1847 bp_pack_value (bp, fn->after_tree_profile, 1);
1848 bp_pack_value (bp, fn->returns_pcc_struct, 1);
1849 bp_pack_value (bp, fn->returns_struct, 1);
1850 bp_pack_value (bp, fn->always_inline_functions_inlined, 1);
1851 bp_pack_value (bp, fn->after_inlining, 1);
1852 bp_pack_value (bp, fn->dont_save_pending_sizes_p, 1);
1853 bp_pack_value (bp, fn->stdarg, 1);
1854 bp_pack_value (bp, fn->has_nonlocal_label, 1);
1855 bp_pack_value (bp, fn->calls_alloca, 1);
1856 bp_pack_value (bp, fn->calls_setjmp, 1);
1857 bp_pack_value (bp, fn->function_frequency, 2);
1858 bp_pack_value (bp, fn->va_list_fpr_size, 8);
1859 bp_pack_value (bp, fn->va_list_gpr_size, 8);
1860 lto_output_bitpack (ob->main_stream, bp);
1861 bitpack_delete (bp);
1863 /* Output the static chain and non-local goto save area. */
1864 lto_output_tree_ref (ob, fn->static_chain_decl);
1865 lto_output_tree_ref (ob, fn->nonlocal_goto_save_area);
1867 /* Output all the local variables in the function. */
1868 lto_output_tree_ref (ob, fn->local_decls);
1870 /* Output all the SSA names used in the function. */
1871 output_ssa_names (ob, fn);
1873 /* Output any exception handling regions. */
1874 output_eh_regions (ob, fn);
1876 /* Output DECL_INITIAL for the function, which contains the tree of
1878 lto_output_tree (ob, DECL_INITIAL (function), true);
1880 /* Output the head of the arguments list. */
1881 lto_output_tree_ref (ob, DECL_ARGUMENTS (function));
1883 /* We will renumber the statements. The code that does this uses
1884 the same ordering that we use for serializing them so we can use
1885 the same code on the other end and not have to write out the
1886 statement numbers. */
1887 renumber_gimple_stmt_uids ();
1889 /* Output the code for the function. */
1890 FOR_ALL_BB_FN (bb, fn)
1891 output_bb (ob, bb, fn);
1893 /* The terminator for this function. */
1896 output_cfg (ob, fn);
1898 /* Create a section to hold the pickled output of this function. */
1899 produce_asm (ob, function);
1901 destroy_output_block (ob);
1903 current_function_decl = NULL;
1908 /* Return true if alias pair P belongs to the set of cgraph nodes in
1909 SET. If P is a an alias for a VAR_DECL, it can always be emitted.
1910 However, for FUNCTION_DECL aliases, we should only output the pair
1911 if it belongs to a function whose cgraph node is in SET.
1912 Otherwise, the LTRANS phase will get into trouble when finalizing
1913 aliases because the alias will refer to a function not defined in
1914 the file processed by LTRANS. */
1917 output_alias_pair_p (alias_pair *p, cgraph_node_set set)
1919 cgraph_node_set_iterator csi;
1920 struct cgraph_node *target_node;
1922 /* Always emit VAR_DECLs. FIXME lto, we should probably only emit
1923 those VAR_DECLs that are instantiated in this file partition, but
1924 we have no easy way of knowing this based on SET. */
1925 if (TREE_CODE (p->decl) == VAR_DECL)
1928 /* Check if the assembler name for P->TARGET has its cgraph node in SET. */
1929 gcc_assert (TREE_CODE (p->decl) == FUNCTION_DECL);
1930 target_node = cgraph_node_for_asm (p->target);
1931 csi = cgraph_node_set_find (set, target_node);
1932 return (!csi_end_p (csi));
1936 /* Output any unreferenced global symbol defined in SET, alias pairs
1940 output_unreferenced_globals (cgraph_node_set set)
1942 struct output_block *ob;
1945 struct varpool_node *vnode;
1947 ob = create_output_block (LTO_section_static_initializer);
1948 ob->cgraph_node = NULL;
1950 clear_line_info (ob);
1952 /* Make string 0 be a NULL string. */
1953 lto_output_1_stream (ob->string_stream, 0);
1955 /* Emit references for all the global symbols. If a global symbol
1956 was never referenced in any of the functions of this file, it
1957 would not be emitted otherwise. This will result in unreferenced
1958 symbols at link time if a file defines a global symbol but
1959 never references it. */
1960 FOR_EACH_STATIC_VARIABLE (vnode)
1962 tree var = vnode->decl;
1964 if (TREE_CODE (var) == VAR_DECL && TREE_PUBLIC (var))
1965 lto_output_tree_ref (ob, var);
1970 /* Emit the alias pairs for the nodes in SET. */
1971 for (i = 0; VEC_iterate (alias_pair, alias_pairs, i, p); i++)
1973 if (output_alias_pair_p (p, set))
1975 lto_output_tree_ref (ob, p->decl);
1976 lto_output_tree_ref (ob, p->target);
1982 produce_asm (ob, NULL);
1983 destroy_output_block (ob);
1987 /* Copy the function body of NODE without deserializing. */
1990 copy_function (struct cgraph_node *node)
1992 tree function = node->decl;
1993 struct lto_file_decl_data *file_data = node->local.lto_file_data;
1994 struct lto_output_stream *output_stream = XCNEW (struct lto_output_stream);
1997 const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (function));
1998 char *section_name =
1999 lto_get_section_name (LTO_section_function_body, name);
2001 struct lto_in_decl_state *in_state;
2002 struct lto_out_decl_state *out_state = lto_get_out_decl_state ();
2004 lto_begin_section (section_name, !flag_wpa);
2005 free (section_name);
2007 /* We may have renamed the declaration, e.g., a static function. */
2008 name = lto_get_decl_name_mapping (file_data, name);
2010 data = lto_get_section_data (file_data, LTO_section_function_body,
2014 /* Do a bit copy of the function body. */
2015 lto_output_data_stream (output_stream, data, len);
2016 lto_write_stream (output_stream);
2020 lto_get_function_in_decl_state (node->local.lto_file_data, function);
2021 gcc_assert (in_state);
2023 for (i = 0; i < LTO_N_DECL_STREAMS; i++)
2025 size_t n = in_state->streams[i].size;
2026 tree *trees = in_state->streams[i].trees;
2027 struct lto_tree_ref_encoder *encoder = &(out_state->streams[i]);
2029 /* The out state must have the same indices and the in state.
2030 So just copy the vector. All the encoders in the in state
2031 must be empty where we reach here. */
2032 gcc_assert (lto_tree_ref_encoder_size (encoder) == 0);
2033 for (j = 0; j < n; j++)
2034 VEC_safe_push (tree, heap, encoder->trees, trees[j]);
2035 encoder->next_index = n;
2038 lto_free_section_data (file_data, LTO_section_function_body, name,
2040 free (output_stream);
2045 /* Initialize the LTO writer. */
2048 lto_writer_init (void)
2050 lto_streamer_init ();
2054 /* Main entry point from the pass manager. */
2057 lto_output (cgraph_node_set set)
2059 struct cgraph_node *node;
2060 struct lto_out_decl_state *decl_state;
2061 cgraph_node_set_iterator csi;
2062 bitmap output = lto_bitmap_alloc ();
2066 /* Process only the functions with bodies. */
2067 for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
2069 node = csi_node (csi);
2070 if (node->analyzed && !bitmap_bit_p (output, DECL_UID (node->decl)))
2072 bitmap_set_bit (output, DECL_UID (node->decl));
2073 decl_state = lto_new_out_decl_state ();
2074 lto_push_out_decl_state (decl_state);
2076 output_function (node);
2078 copy_function (node);
2079 gcc_assert (lto_get_out_decl_state () == decl_state);
2080 lto_pop_out_decl_state ();
2081 lto_record_function_out_decl_state (node->decl, decl_state);
2085 /* Emit the callgraph after emitting function bodies. This needs to
2086 be done now to make sure that all the statements in every function
2087 have been renumbered so that edges can be associated with call
2088 statements using the statement UIDs. */
2089 output_cgraph (set);
2091 lto_bitmap_free (output);
2094 struct ipa_opt_pass_d pass_ipa_lto_gimple_out =
2098 "lto_gimple_out", /* name */
2099 gate_lto_out, /* gate */
2103 0, /* static_pass_number */
2104 TV_IPA_LTO_GIMPLE_IO, /* tv_id */
2105 0, /* properties_required */
2106 0, /* properties_provided */
2107 0, /* properties_destroyed */
2108 0, /* todo_flags_start */
2109 TODO_dump_func /* todo_flags_finish */
2111 NULL, /* generate_summary */
2112 lto_output, /* write_summary */
2113 NULL, /* read_summary */
2114 NULL, /* function_read_summary */
2116 NULL, /* function_transform */
2117 NULL /* variable_transform */
2121 /* Write each node in encoded by ENCODER to OB, as well as those reachable
2122 from it and required for correct representation of its semantics.
2123 Each node in ENCODER must be a global declaration or a type. A node
2124 is written only once, even if it appears multiple times in the
2125 vector. Certain transitively-reachable nodes, such as those
2126 representing expressions, may be duplicated, but such nodes
2127 must not appear in ENCODER itself. */
2130 write_global_stream (struct output_block *ob,
2131 struct lto_tree_ref_encoder *encoder)
2135 const size_t size = lto_tree_ref_encoder_size (encoder);
2137 for (index = 0; index < size; index++)
2139 t = lto_tree_ref_encoder_get_tree (encoder, index);
2140 if (!lto_streamer_cache_lookup (ob->writer_cache, t, NULL))
2144 /* In WPA we should not emit multiple definitions of the
2145 same symbol to all the files in the link set. If
2146 T had already been emitted as the pervailing definition
2147 in one file, emit it as an external reference in the
2149 /* FIXME lto. We should check if T belongs to the
2150 file we are writing to. */
2151 if (TREE_CODE (t) == VAR_DECL
2153 && !DECL_EXTERNAL (t))
2155 /* FIXME lto. Make DECLS_ALREADY_EMITTED an argument
2156 to this function so it can be freed up afterwards.
2157 Alternately, assign global symbols to cgraph
2159 static struct pointer_set_t *decls_already_emitted = NULL;
2161 if (decls_already_emitted == NULL)
2162 decls_already_emitted = pointer_set_create ();
2164 if (pointer_set_insert (decls_already_emitted, t))
2165 make_decl_one_only (t, DECL_ASSEMBLER_NAME (t));
2169 lto_output_tree (ob, t, false);
2175 /* Write a sequence of indices into the globals vector corresponding
2176 to the trees in ENCODER. These are used by the reader to map the
2177 indices used to refer to global entities within function bodies to
2181 write_global_references (struct output_block *ob,
2182 struct lto_output_stream *ref_stream,
2183 struct lto_tree_ref_encoder *encoder)
2187 const int32_t size = lto_tree_ref_encoder_size (encoder);
2189 /* Write size as 32-bit unsigned. */
2190 lto_output_data_stream (ref_stream, &size, sizeof (int32_t));
2192 for (index = 0; index < size; index++)
2196 t = lto_tree_ref_encoder_get_tree (encoder, index);
2197 lto_streamer_cache_lookup (ob->writer_cache, t, &slot_num);
2198 gcc_assert (slot_num >= 0);
2199 lto_output_data_stream (ref_stream, &slot_num, sizeof slot_num);
2204 /* Write all the streams in an lto_out_decl_state STATE using
2205 output block OB and output stream OUT_STREAM. */
2208 lto_output_decl_state_streams (struct output_block *ob,
2209 struct lto_out_decl_state *state)
2213 for (i = 0; i < LTO_N_DECL_STREAMS; i++)
2214 write_global_stream (ob, &state->streams[i]);
2218 /* Write all the references in an lto_out_decl_state STATE using
2219 output block OB and output stream OUT_STREAM. */
2222 lto_output_decl_state_refs (struct output_block *ob,
2223 struct lto_output_stream *out_stream,
2224 struct lto_out_decl_state *state)
2230 /* Write reference to FUNCTION_DECL. If there is not function,
2231 write reference to void_type_node. */
2232 decl = (state->fn_decl) ? state->fn_decl : void_type_node;
2233 lto_streamer_cache_lookup (ob->writer_cache, decl, &ref);
2234 gcc_assert (ref >= 0);
2235 lto_output_data_stream (out_stream, &ref, sizeof (int32_t));
2237 for (i = 0; i < LTO_N_DECL_STREAMS; i++)
2238 write_global_references (ob, out_stream, &state->streams[i]);
2242 /* Return the written size of STATE. */
2245 lto_out_decl_state_written_size (struct lto_out_decl_state *state)
2250 size = sizeof (int32_t); /* fn_ref. */
2251 for (i = 0; i < LTO_N_DECL_STREAMS; i++)
2253 size += sizeof (int32_t); /* vector size. */
2254 size += (lto_tree_ref_encoder_size (&state->streams[i])
2255 * sizeof (int32_t));
2261 /* Helper function of write_symbols_of_kind. CACHE is the streamer
2262 cache with all the pickled nodes. STREAM is the stream where to
2263 write the table. V is a vector with the DECLs that should be on
2264 the table. SEEN is a bitmap of symbols written so far. */
2267 write_symbol_vec (struct lto_streamer_cache_d *cache,
2268 struct lto_output_stream *stream,
2269 VEC(tree,heap) *v, bitmap seen)
2274 for (index = 0; VEC_iterate(tree, v, index, t); index++)
2277 enum gcc_plugin_symbol_kind kind;
2278 enum gcc_plugin_symbol_visibility visibility;
2283 /* None of the following kinds of symbols are needed in the
2285 if (!TREE_PUBLIC (t)
2286 || is_builtin_fn (t)
2287 || DECL_ABSTRACT (t)
2288 || TREE_CODE (t) == RESULT_DECL)
2291 gcc_assert (TREE_CODE (t) == VAR_DECL
2292 || TREE_CODE (t) == FUNCTION_DECL);
2294 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (t));
2296 /* FIXME lto: this is from assemble_name_raw in varasm.c. For some
2297 architectures we might have to do the same name manipulations that
2298 ASM_OUTPUT_LABELREF does. */
2302 lto_streamer_cache_lookup (cache, t, &slot_num);
2303 gcc_assert (slot_num >= 0);
2305 /* Avoid duplicate symbols. */
2306 if (bitmap_bit_p (seen, slot_num))
2309 bitmap_set_bit (seen, slot_num);
2311 if (DECL_EXTERNAL (t))
2314 kind = GCCPK_WEAKUNDEF;
2321 kind = GCCPK_WEAKDEF;
2322 else if (DECL_COMMON (t))
2323 kind = GCCPK_COMMON;
2328 switch (DECL_VISIBILITY(t))
2330 case VISIBILITY_DEFAULT:
2331 visibility = GCCPV_DEFAULT;
2333 case VISIBILITY_PROTECTED:
2334 visibility = GCCPV_PROTECTED;
2336 case VISIBILITY_HIDDEN:
2337 visibility = GCCPV_HIDDEN;
2339 case VISIBILITY_INTERNAL:
2340 visibility = GCCPV_INTERNAL;
2344 if (kind == GCCPK_COMMON && DECL_SIZE (t))
2345 size = (((uint64_t) TREE_INT_CST_HIGH (DECL_SIZE (t))) << 32)
2346 | TREE_INT_CST_LOW (DECL_SIZE (t));
2350 if (DECL_ONE_ONLY (t))
2351 comdat = IDENTIFIER_POINTER (DECL_COMDAT_GROUP (t));
2355 lto_output_data_stream (stream, name, strlen (name) + 1);
2356 lto_output_data_stream (stream, comdat, strlen (comdat) + 1);
2357 lto_output_data_stream (stream, &kind, 1);
2358 lto_output_data_stream (stream, &visibility, 1);
2359 lto_output_data_stream (stream, &size, 8);
2360 lto_output_data_stream (stream, &slot_num, 4);
2365 /* Write IL symbols of KIND. CACHE is the streamer cache with all the
2366 pickled nodes. SEEN is a bitmap of symbols written so far. */
2369 write_symbols_of_kind (lto_decl_stream_e_t kind,
2370 struct lto_streamer_cache_d *cache, bitmap seen)
2372 struct lto_out_decl_state *out_state;
2373 struct lto_output_stream stream;
2375 VEC_length (lto_out_decl_state_ptr, lto_function_decl_states);
2378 memset (&stream, 0, sizeof (stream));
2379 out_state = lto_get_out_decl_state ();
2380 write_symbol_vec (cache, &stream, out_state->streams[kind].trees, seen);
2382 for (idx = 0; idx < num_fns; idx++)
2385 VEC_index (lto_out_decl_state_ptr, lto_function_decl_states, idx);
2386 write_symbol_vec (cache, &stream, out_state->streams[kind].trees, seen);
2389 lto_write_stream (&stream);
2393 /* Write an IL symbol table. CACHE is the streamer cache with all the
2397 produce_symtab (struct lto_streamer_cache_d *cache)
2399 char *section_name = lto_get_section_name (LTO_section_symtab, NULL);
2402 lto_begin_section (section_name, false);
2403 free (section_name);
2405 seen = lto_bitmap_alloc ();
2406 write_symbols_of_kind (LTO_DECL_STREAM_FN_DECL, cache, seen);
2407 write_symbols_of_kind (LTO_DECL_STREAM_VAR_DECL, cache, seen);
2408 lto_bitmap_free (seen);
2414 /* This pass is run after all of the functions are serialized and all
2415 of the IPA passes have written their serialized forms. This pass
2416 causes the vector of all of the global decls and types used from
2417 this file to be written in to a section that can then be read in to
2418 recover these on other side. */
2421 produce_asm_for_decls (cgraph_node_set set)
2423 struct lto_out_decl_state *out_state;
2424 struct lto_out_decl_state *fn_out_state;
2425 struct lto_decl_header header;
2427 struct output_block *ob;
2428 struct lto_output_stream *header_stream, *decl_state_stream;
2429 unsigned idx, num_fns;
2430 size_t decl_state_size;
2431 int32_t num_decl_states;
2433 ob = create_output_block (LTO_section_decls);
2436 /* Write out unreferenced globals, alias pairs and labels. We defer
2437 doing this until now so that we can write out only what is
2439 output_unreferenced_globals (set);
2441 memset (&header, 0, sizeof (struct lto_decl_header));
2443 section_name = lto_get_section_name (LTO_section_decls, NULL);
2444 lto_begin_section (section_name, !flag_wpa);
2445 free (section_name);
2447 /* Make string 0 be a NULL string. */
2448 lto_output_1_stream (ob->string_stream, 0);
2450 /* Write the global symbols. */
2451 out_state = lto_get_out_decl_state ();
2452 num_fns = VEC_length (lto_out_decl_state_ptr, lto_function_decl_states);
2453 lto_output_decl_state_streams (ob, out_state);
2454 for (idx = 0; idx < num_fns; idx++)
2457 VEC_index (lto_out_decl_state_ptr, lto_function_decl_states, idx);
2458 lto_output_decl_state_streams (ob, fn_out_state);
2461 header.lto_header.major_version = LTO_major_version;
2462 header.lto_header.minor_version = LTO_minor_version;
2463 header.lto_header.section_type = LTO_section_decls;
2465 /* Currently not used. This field would allow us to preallocate
2466 the globals vector, so that it need not be resized as it is extended. */
2467 header.num_nodes = -1;
2469 /* Compute the total size of all decl out states. */
2470 decl_state_size = sizeof (int32_t);
2471 decl_state_size += lto_out_decl_state_written_size (out_state);
2472 for (idx = 0; idx < num_fns; idx++)
2475 VEC_index (lto_out_decl_state_ptr, lto_function_decl_states, idx);
2476 decl_state_size += lto_out_decl_state_written_size (fn_out_state);
2478 header.decl_state_size = decl_state_size;
2480 header.main_size = ob->main_stream->total_size;
2481 header.string_size = ob->string_stream->total_size;
2483 header_stream = XCNEW (struct lto_output_stream);
2484 lto_output_data_stream (header_stream, &header, sizeof header);
2485 lto_write_stream (header_stream);
2486 free (header_stream);
2488 /* Write the main out-decl state, followed by out-decl states of
2490 decl_state_stream = ((struct lto_output_stream *)
2491 xcalloc (1, sizeof (struct lto_output_stream)));
2492 num_decl_states = num_fns + 1;
2493 lto_output_data_stream (decl_state_stream, &num_decl_states,
2494 sizeof (num_decl_states));
2495 lto_output_decl_state_refs (ob, decl_state_stream, out_state);
2496 for (idx = 0; idx < num_fns; idx++)
2499 VEC_index (lto_out_decl_state_ptr, lto_function_decl_states, idx);
2500 lto_output_decl_state_refs (ob, decl_state_stream, fn_out_state);
2502 lto_write_stream (decl_state_stream);
2503 free(decl_state_stream);
2505 lto_write_stream (ob->main_stream);
2506 lto_write_stream (ob->string_stream);
2510 /* Write the symbol table. */
2511 produce_symtab (ob->writer_cache);
2513 /* Write command line opts. */
2514 lto_write_options ();
2516 /* Deallocate memory and clean up. */
2517 lto_cgraph_encoder_delete (ob->decl_state->cgraph_node_encoder);
2518 VEC_free (lto_out_decl_state_ptr, heap, lto_function_decl_states);
2519 lto_function_decl_states = NULL;
2520 destroy_output_block (ob);
2524 struct ipa_opt_pass_d pass_ipa_lto_finish_out =
2528 "lto_decls_out", /* name */
2529 gate_lto_out, /* gate */
2533 0, /* static_pass_number */
2534 TV_IPA_LTO_DECL_IO, /* tv_id */
2535 0, /* properties_required */
2536 0, /* properties_provided */
2537 0, /* properties_destroyed */
2538 0, /* todo_flags_start */
2539 0 /* todo_flags_finish */
2541 NULL, /* generate_summary */
2542 produce_asm_for_decls, /* write_summary */
2543 NULL, /* read_summary */
2544 NULL, /* function_read_summary */
2546 NULL, /* function_transform */
2547 NULL /* variable_transform */