1 /* Write the GIMPLE representation to a file stream.
3 Copyright 2009, 2010 Free Software Foundation, Inc.
4 Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>
5 Re-implemented by Diego Novillo <dnovillo@google.com>
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 3, or (at your option) any later
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
25 #include "coretypes.h"
34 #include "basic-block.h"
35 #include "tree-flow.h"
36 #include "tree-pass.h"
40 #include "diagnostic.h"
43 #include "lto-symtab.h"
44 #include "lto-streamer.h"
51 unsigned int slot_num;
55 /* Returns a hash code for P. */
58 hash_string_slot_node (const void *p)
60 const struct string_slot *ds = (const struct string_slot *) p;
61 return (hashval_t) htab_hash_string (ds->s);
65 /* Returns nonzero if P1 and P2 are equal. */
68 eq_string_slot_node (const void *p1, const void *p2)
70 const struct string_slot *ds1 = (const struct string_slot *) p1;
71 const struct string_slot *ds2 = (const struct string_slot *) p2;
73 if (ds1->len == ds2->len)
76 for (i = 0; i < ds1->len; i++)
77 if (ds1->s[i] != ds2->s[i])
86 /* Free the string slot pointed-to by P. */
89 string_slot_free (void *p)
91 struct string_slot *slot = (struct string_slot *) p;
92 free (CONST_CAST (void *, (const void *) slot->s));
97 /* Clear the line info stored in DATA_IN. */
100 clear_line_info (struct output_block *ob)
102 ob->current_file = NULL;
103 ob->current_line = 0;
108 /* Create the output block and return it. SECTION_TYPE is
109 LTO_section_function_body or LTO_static_initializer. */
111 struct output_block *
112 create_output_block (enum lto_section_type section_type)
114 struct output_block *ob = XCNEW (struct output_block);
116 ob->section_type = section_type;
117 ob->decl_state = lto_get_out_decl_state ();
118 ob->main_stream = XCNEW (struct lto_output_stream);
119 ob->string_stream = XCNEW (struct lto_output_stream);
120 ob->writer_cache = lto_streamer_cache_create ();
122 if (section_type == LTO_section_function_body)
123 ob->cfg_stream = XCNEW (struct lto_output_stream);
125 clear_line_info (ob);
127 ob->string_hash_table = htab_create (37, hash_string_slot_node,
128 eq_string_slot_node, string_slot_free);
134 /* Destroy the output block OB. */
137 destroy_output_block (struct output_block *ob)
139 enum lto_section_type section_type = ob->section_type;
141 htab_delete (ob->string_hash_table);
143 free (ob->main_stream);
144 free (ob->string_stream);
145 if (section_type == LTO_section_function_body)
146 free (ob->cfg_stream);
148 lto_streamer_cache_delete (ob->writer_cache);
154 /* Output bitpack BP to output stream S. */
157 lto_output_bitpack (struct lto_output_stream *s, struct bitpack_d *bp)
162 lto_output_uleb128_stream (s, VEC_length (bitpack_word_t, bp->values));
163 for (i = 0; VEC_iterate (bitpack_word_t, bp->values, i, v); i++)
164 lto_output_uleb128_stream (s, v);
168 /* Output STRING of LEN characters to the string
169 table in OB. The string might or might not include a trailing '\0'.
170 Then put the index onto the INDEX_STREAM. */
173 output_string_with_length (struct output_block *ob,
174 struct lto_output_stream *index_stream,
178 struct string_slot **slot;
179 struct string_slot s_slot;
180 char *string = (char *) xmalloc (len + 1);
181 memcpy (string, s, len);
188 slot = (struct string_slot **) htab_find_slot (ob->string_hash_table,
192 struct lto_output_stream *string_stream = ob->string_stream;
193 unsigned int start = string_stream->total_size;
194 struct string_slot *new_slot
195 = (struct string_slot *) xmalloc (sizeof (struct string_slot));
198 new_slot->s = string;
200 new_slot->slot_num = start;
202 lto_output_uleb128_stream (index_stream, start);
203 lto_output_uleb128_stream (string_stream, len);
204 for (i = 0; i < len; i++)
205 lto_output_1_stream (string_stream, string[i]);
209 struct string_slot *old_slot = (struct string_slot *)*slot;
210 lto_output_uleb128_stream (index_stream, old_slot->slot_num);
215 /* Output the '\0' terminated STRING to the string
216 table in OB. Then put the index onto the INDEX_STREAM. */
219 output_string (struct output_block *ob,
220 struct lto_output_stream *index_stream,
225 lto_output_uleb128_stream (index_stream, 0);
226 output_string_with_length (ob, index_stream, string, strlen (string) + 1);
229 lto_output_uleb128_stream (index_stream, 1);
233 /* Output the STRING constant to the string
234 table in OB. Then put the index onto the INDEX_STREAM. */
237 output_string_cst (struct output_block *ob,
238 struct lto_output_stream *index_stream,
243 lto_output_uleb128_stream (index_stream, 0);
244 output_string_with_length (ob, index_stream,
245 TREE_STRING_POINTER (string),
246 TREE_STRING_LENGTH (string));
249 lto_output_uleb128_stream (index_stream, 1);
253 /* Output the identifier ID to the string
254 table in OB. Then put the index onto the INDEX_STREAM. */
257 output_identifier (struct output_block *ob,
258 struct lto_output_stream *index_stream,
263 lto_output_uleb128_stream (index_stream, 0);
264 output_string_with_length (ob, index_stream,
265 IDENTIFIER_POINTER (id),
266 IDENTIFIER_LENGTH (id));
269 lto_output_uleb128_stream (index_stream, 1);
272 /* Write a zero to the output stream. */
275 output_zero (struct output_block *ob)
277 lto_output_1_stream (ob->main_stream, 0);
281 /* Output an unsigned LEB128 quantity to OB->main_stream. */
284 output_uleb128 (struct output_block *ob, unsigned HOST_WIDE_INT work)
286 lto_output_uleb128_stream (ob->main_stream, work);
290 /* Output a signed LEB128 quantity to OB->main_stream. */
293 output_sleb128 (struct output_block *ob, HOST_WIDE_INT work)
295 lto_output_sleb128_stream (ob->main_stream, work);
299 /* Output the start of a record with TAG to output block OB. */
302 output_record_start (struct output_block *ob, enum LTO_tags tag)
304 /* Make sure TAG fits inside an unsigned int. */
305 gcc_assert (tag == (enum LTO_tags) (unsigned) tag);
306 output_uleb128 (ob, tag);
310 /* Look up NODE in the type table and write the index for it to OB. */
313 output_type_ref (struct output_block *ob, tree node)
315 output_record_start (ob, LTO_type_ref);
316 lto_output_type_ref_index (ob->decl_state, ob->main_stream, node);
320 /* Pack all the non-pointer fields of the TS_BASE structure of
321 expression EXPR into bitpack BP. */
324 pack_ts_base_value_fields (struct bitpack_d *bp, tree expr)
326 bp_pack_value (bp, TREE_CODE (expr), 16);
329 bp_pack_value (bp, TREE_SIDE_EFFECTS (expr), 1);
330 bp_pack_value (bp, TREE_CONSTANT (expr), 1);
331 bp_pack_value (bp, TREE_READONLY (expr), 1);
333 /* TREE_PUBLIC is used on types to indicate that the type
334 has a TYPE_CACHED_VALUES vector. This is not streamed out,
335 so we skip it here. */
336 bp_pack_value (bp, TREE_PUBLIC (expr), 1);
338 bp_pack_value (bp, TREE_ADDRESSABLE (expr), 1);
339 bp_pack_value (bp, TREE_THIS_VOLATILE (expr), 1);
341 bp_pack_value (bp, DECL_UNSIGNED (expr), 1);
342 else if (TYPE_P (expr))
343 bp_pack_value (bp, TYPE_UNSIGNED (expr), 1);
344 /* We write debug info two times, do not confuse the second one. */
345 bp_pack_value (bp, TYPE_P (expr) ? 0 : 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);
436 bp_pack_value (bp, DECL_RESTRICTED_P (expr), 1);
441 /* Pack all the non-pointer fields of the TS_DECL_WRTL structure
442 of expression EXPR into bitpack BP. */
445 pack_ts_decl_wrtl_value_fields (struct bitpack_d *bp, tree expr)
447 bp_pack_value (bp, DECL_REGISTER (expr), 1);
451 /* Pack all the non-pointer fields of the TS_DECL_WITH_VIS structure
452 of expression EXPR into bitpack BP. */
455 pack_ts_decl_with_vis_value_fields (struct bitpack_d *bp, tree expr)
457 bp_pack_value (bp, DECL_DEFER_OUTPUT (expr), 1);
458 bp_pack_value (bp, DECL_COMMON (expr), 1);
459 bp_pack_value (bp, DECL_DLLIMPORT_P (expr), 1);
460 bp_pack_value (bp, DECL_WEAK (expr), 1);
461 bp_pack_value (bp, DECL_SEEN_IN_BIND_EXPR_P (expr), 1);
462 bp_pack_value (bp, DECL_COMDAT (expr), 1);
463 bp_pack_value (bp, DECL_VISIBILITY (expr), 2);
464 bp_pack_value (bp, DECL_VISIBILITY_SPECIFIED (expr), 1);
466 if (TREE_CODE (expr) == VAR_DECL)
468 bp_pack_value (bp, DECL_HARD_REGISTER (expr), 1);
469 bp_pack_value (bp, DECL_IN_TEXT_SECTION (expr), 1);
470 bp_pack_value (bp, DECL_IN_CONSTANT_POOL (expr), 1);
471 bp_pack_value (bp, DECL_TLS_MODEL (expr), 3);
474 if (VAR_OR_FUNCTION_DECL_P (expr))
475 bp_pack_value (bp, DECL_INIT_PRIORITY (expr), HOST_BITS_PER_SHORT);
479 /* Pack all the non-pointer fields of the TS_FUNCTION_DECL structure
480 of expression EXPR into bitpack BP. */
483 pack_ts_function_decl_value_fields (struct bitpack_d *bp, tree expr)
485 /* For normal/md builtins we only write the class and code, so they
486 should never be handled here. */
487 gcc_assert (!lto_stream_as_builtin_p (expr));
489 bp_pack_value (bp, DECL_FUNCTION_CODE (expr), 11);
490 bp_pack_value (bp, DECL_BUILT_IN_CLASS (expr), 2);
491 bp_pack_value (bp, DECL_STATIC_CONSTRUCTOR (expr), 1);
492 bp_pack_value (bp, DECL_STATIC_DESTRUCTOR (expr), 1);
493 bp_pack_value (bp, DECL_UNINLINABLE (expr), 1);
494 bp_pack_value (bp, DECL_POSSIBLY_INLINED (expr), 1);
495 bp_pack_value (bp, DECL_IS_NOVOPS (expr), 1);
496 bp_pack_value (bp, DECL_IS_RETURNS_TWICE (expr), 1);
497 bp_pack_value (bp, DECL_IS_MALLOC (expr), 1);
498 bp_pack_value (bp, DECL_IS_OPERATOR_NEW (expr), 1);
499 bp_pack_value (bp, DECL_DECLARED_INLINE_P (expr), 1);
500 bp_pack_value (bp, DECL_STATIC_CHAIN (expr), 1);
501 bp_pack_value (bp, DECL_NO_INLINE_WARNING_P (expr), 1);
502 bp_pack_value (bp, DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (expr), 1);
503 bp_pack_value (bp, DECL_NO_LIMIT_STACK (expr), 1);
504 bp_pack_value (bp, DECL_DISREGARD_INLINE_LIMITS (expr), 1);
505 bp_pack_value (bp, DECL_PURE_P (expr), 1);
506 bp_pack_value (bp, DECL_LOOPING_CONST_OR_PURE_P (expr), 1);
510 /* Pack all the non-pointer fields of the TS_TYPE structure
511 of expression EXPR into bitpack BP. */
514 pack_ts_type_value_fields (struct bitpack_d *bp, tree expr)
516 bp_pack_value (bp, TYPE_PRECISION (expr), 9);
517 bp_pack_value (bp, TYPE_MODE (expr), 7);
518 bp_pack_value (bp, TYPE_STRING_FLAG (expr), 1);
519 bp_pack_value (bp, TYPE_NO_FORCE_BLK (expr), 1);
520 bp_pack_value (bp, TYPE_NEEDS_CONSTRUCTING (expr), 1);
521 if (RECORD_OR_UNION_TYPE_P (expr))
522 bp_pack_value (bp, TYPE_TRANSPARENT_AGGR (expr), 1);
523 bp_pack_value (bp, TYPE_PACKED (expr), 1);
524 bp_pack_value (bp, TYPE_RESTRICT (expr), 1);
525 bp_pack_value (bp, TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr), 2);
526 bp_pack_value (bp, TYPE_USER_ALIGN (expr), 1);
527 bp_pack_value (bp, TYPE_READONLY (expr), 1);
528 bp_pack_value (bp, TYPE_ALIGN (expr), HOST_BITS_PER_INT);
529 bp_pack_value (bp, TYPE_ALIAS_SET (expr) == 0 ? 0 : -1, HOST_BITS_PER_INT);
533 /* Pack all the non-pointer fields of the TS_BLOCK structure
534 of expression EXPR into bitpack BP. */
537 pack_ts_block_value_fields (struct bitpack_d *bp, tree expr)
539 bp_pack_value (bp, BLOCK_ABSTRACT (expr), 1);
540 bp_pack_value (bp, BLOCK_NUMBER (expr), 31);
544 /* Pack all the non-pointer fields in EXPR into a bit pack. */
546 static struct bitpack_d *
547 pack_value_fields (tree expr)
550 struct bitpack_d *bp;
552 code = TREE_CODE (expr);
553 bp = bitpack_create ();
555 /* Note that all these functions are highly sensitive to changes in
556 the types and sizes of each of the fields being packed. */
557 pack_ts_base_value_fields (bp, expr);
559 if (CODE_CONTAINS_STRUCT (code, TS_REAL_CST))
560 pack_ts_real_cst_value_fields (bp, expr);
562 if (CODE_CONTAINS_STRUCT (code, TS_FIXED_CST))
563 pack_ts_fixed_cst_value_fields (bp, expr);
565 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
566 pack_ts_decl_common_value_fields (bp, expr);
568 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL))
569 pack_ts_decl_wrtl_value_fields (bp, expr);
571 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
572 pack_ts_decl_with_vis_value_fields (bp, expr);
574 if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
575 pack_ts_function_decl_value_fields (bp, expr);
577 if (CODE_CONTAINS_STRUCT (code, TS_TYPE))
578 pack_ts_type_value_fields (bp, expr);
580 if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
581 pack_ts_block_value_fields (bp, expr);
583 if (CODE_CONTAINS_STRUCT (code, TS_SSA_NAME))
585 /* We only stream the version number of SSA names. */
589 if (CODE_CONTAINS_STRUCT (code, TS_STATEMENT_LIST))
591 /* This is only used by GENERIC. */
595 if (CODE_CONTAINS_STRUCT (code, TS_OMP_CLAUSE))
597 /* This is only used by High GIMPLE. */
605 /* Emit location LOC to output block OB. */
608 lto_output_location (struct output_block *ob, location_t loc)
610 expanded_location xloc;
612 if (loc == UNKNOWN_LOCATION)
614 output_string (ob, ob->main_stream, NULL);
618 xloc = expand_location (loc);
620 output_string (ob, ob->main_stream, xloc.file);
621 output_sleb128 (ob, xloc.line);
622 output_sleb128 (ob, xloc.column);
623 output_sleb128 (ob, xloc.sysp);
625 ob->current_file = xloc.file;
626 ob->current_line = xloc.line;
627 ob->current_col = xloc.column;
631 /* Return true if tree node T is written to various tables. For these
632 nodes, we sometimes want to write their phyiscal representation
633 (via lto_output_tree), and sometimes we need to emit an index
634 reference into a table (via lto_output_tree_ref). */
637 tree_is_indexable (tree t)
639 if (TREE_CODE (t) == PARM_DECL)
641 else if (TREE_CODE (t) == VAR_DECL && decl_function_context (t)
645 return (TYPE_P (t) || DECL_P (t) || TREE_CODE (t) == SSA_NAME);
649 /* If EXPR is an indexable tree node, output a reference to it to
650 output block OB. Otherwise, output the physical representation of
654 lto_output_tree_ref (struct output_block *ob, tree expr)
658 if (expr == NULL_TREE)
664 if (!tree_is_indexable (expr))
666 /* Even though we are emitting the physical representation of
667 EXPR, its leaves must be emitted as references. */
668 lto_output_tree (ob, expr, true);
674 output_type_ref (ob, expr);
678 code = TREE_CODE (expr);
682 output_record_start (ob, LTO_ssa_name_ref);
683 output_uleb128 (ob, SSA_NAME_VERSION (expr));
687 output_record_start (ob, LTO_field_decl_ref);
688 lto_output_field_decl_index (ob->decl_state, ob->main_stream, expr);
692 output_record_start (ob, LTO_function_decl_ref);
693 lto_output_fn_decl_index (ob->decl_state, ob->main_stream, expr);
697 case DEBUG_EXPR_DECL:
698 gcc_assert (decl_function_context (expr) == NULL
699 || TREE_STATIC (expr));
700 output_record_start (ob, LTO_global_decl_ref);
701 lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr);
705 output_record_start (ob, LTO_const_decl_ref);
706 lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr);
710 gcc_assert (decl_function_context (expr) == NULL);
711 output_record_start (ob, LTO_imported_decl_ref);
712 lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr);
716 output_record_start (ob, LTO_type_decl_ref);
717 lto_output_type_decl_index (ob->decl_state, ob->main_stream, expr);
721 output_record_start (ob, LTO_namespace_decl_ref);
722 lto_output_namespace_decl_index (ob->decl_state, ob->main_stream, expr);
726 output_record_start (ob, LTO_label_decl_ref);
727 lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr);
731 output_record_start (ob, LTO_result_decl_ref);
732 lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr);
736 /* No other node is indexable, so it should have been handled
737 by lto_output_tree. */
743 /* If REF_P is true, emit a reference to EXPR in output block OB,
744 otherwise emit the physical representation of EXPR in OB. */
747 lto_output_tree_or_ref (struct output_block *ob, tree expr, bool ref_p)
750 lto_output_tree_ref (ob, expr);
752 lto_output_tree (ob, expr, false);
756 /* Emit the chain of tree nodes starting at T. OB is the output block
757 to write to. REF_P is true if chain elements should be emitted
761 lto_output_chain (struct output_block *ob, tree t, bool ref_p)
765 count = list_length (t);
766 output_sleb128 (ob, count);
767 for (i = 0; i < count; i++)
771 /* Clear TREE_CHAIN to avoid blindly recursing into the rest
773 saved_chain = TREE_CHAIN (t);
774 TREE_CHAIN (t) = NULL_TREE;
776 lto_output_tree_or_ref (ob, t, ref_p);
778 TREE_CHAIN (t) = saved_chain;
784 /* Write all pointer fields in the TS_COMMON structure of EXPR to output
785 block OB. If REF_P is true, write a reference to EXPR's pointer
789 lto_output_ts_common_tree_pointers (struct output_block *ob, tree expr,
792 lto_output_tree_or_ref (ob, TREE_TYPE (expr), ref_p);
796 /* Write all pointer fields in the TS_VECTOR structure of EXPR to output
797 block OB. If REF_P is true, write a reference to EXPR's pointer
801 lto_output_ts_vector_tree_pointers (struct output_block *ob, tree expr,
804 lto_output_chain (ob, TREE_VECTOR_CST_ELTS (expr), ref_p);
808 /* Write all pointer fields in the TS_COMPLEX structure of EXPR to output
809 block OB. If REF_P is true, write a reference to EXPR's pointer
813 lto_output_ts_complex_tree_pointers (struct output_block *ob, tree expr,
816 lto_output_tree_or_ref (ob, TREE_REALPART (expr), ref_p);
817 lto_output_tree_or_ref (ob, TREE_IMAGPART (expr), ref_p);
821 /* Write all pointer fields in the TS_DECL_MINIMAL structure of EXPR
822 to output block OB. If REF_P is true, write a reference to EXPR's
826 lto_output_ts_decl_minimal_tree_pointers (struct output_block *ob, tree expr,
829 lto_output_tree_or_ref (ob, DECL_NAME (expr), ref_p);
830 lto_output_tree_or_ref (ob, DECL_CONTEXT (expr), ref_p);
831 lto_output_location (ob, DECL_SOURCE_LOCATION (expr));
835 /* Write all pointer fields in the TS_DECL_COMMON structure of EXPR to
836 output block OB. If REF_P is true, write a reference to EXPR's
840 lto_output_ts_decl_common_tree_pointers (struct output_block *ob, tree expr,
843 lto_output_tree_or_ref (ob, DECL_SIZE (expr), ref_p);
844 lto_output_tree_or_ref (ob, DECL_SIZE_UNIT (expr), ref_p);
846 if (TREE_CODE (expr) != FUNCTION_DECL)
848 tree initial = DECL_INITIAL (expr);
849 if (TREE_CODE (expr) == VAR_DECL
850 && (TREE_STATIC (expr) || DECL_EXTERNAL (expr))
853 lto_varpool_encoder_t varpool_encoder = ob->decl_state->varpool_node_encoder;
854 struct varpool_node *vnode = varpool_get_node (expr);
856 initial = error_mark_node;
857 else if (!lto_varpool_encoder_encode_initializer_p (varpool_encoder,
862 lto_output_tree_or_ref (ob, initial, ref_p);
865 lto_output_tree_or_ref (ob, DECL_ATTRIBUTES (expr), ref_p);
866 lto_output_tree_or_ref (ob, DECL_ABSTRACT_ORIGIN (expr), ref_p);
868 if (TREE_CODE (expr) == PARM_DECL)
869 lto_output_chain (ob, TREE_CHAIN (expr), ref_p);
871 if ((TREE_CODE (expr) == VAR_DECL
872 || TREE_CODE (expr) == PARM_DECL)
873 && DECL_HAS_VALUE_EXPR_P (expr))
874 lto_output_tree_or_ref (ob, DECL_VALUE_EXPR (expr), ref_p);
878 /* Write all pointer fields in the TS_DECL_NON_COMMON structure of
879 EXPR to output block OB. If REF_P is true, write a reference to EXPR's
883 lto_output_ts_decl_non_common_tree_pointers (struct output_block *ob,
884 tree expr, bool ref_p)
886 if (TREE_CODE (expr) == FUNCTION_DECL)
888 /* DECL_SAVED_TREE holds the GENERIC representation for DECL.
889 At this point, it should not exist. Either because it was
890 converted to gimple or because DECL didn't have a GENERIC
891 representation in this TU. */
892 gcc_assert (DECL_SAVED_TREE (expr) == NULL_TREE);
893 lto_output_tree_or_ref (ob, DECL_ARGUMENTS (expr), ref_p);
894 lto_output_tree_or_ref (ob, DECL_RESULT (expr), ref_p);
896 lto_output_tree_or_ref (ob, DECL_VINDEX (expr), ref_p);
900 /* Write all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
901 to output block OB. If REF_P is true, write a reference to EXPR's
905 lto_output_ts_decl_with_vis_tree_pointers (struct output_block *ob, tree expr,
908 /* Make sure we don't inadvertently set the assembler name. */
909 if (DECL_ASSEMBLER_NAME_SET_P (expr))
910 lto_output_tree_or_ref (ob, DECL_ASSEMBLER_NAME (expr), ref_p);
914 lto_output_tree_or_ref (ob, DECL_SECTION_NAME (expr), ref_p);
915 lto_output_tree_or_ref (ob, DECL_COMDAT_GROUP (expr), ref_p);
919 /* Write all pointer fields in the TS_FIELD_DECL structure of EXPR to
920 output block OB. If REF_P is true, write a reference to EXPR's
924 lto_output_ts_field_decl_tree_pointers (struct output_block *ob, tree expr,
927 lto_output_tree_or_ref (ob, DECL_FIELD_OFFSET (expr), ref_p);
928 lto_output_tree_or_ref (ob, DECL_BIT_FIELD_TYPE (expr), ref_p);
929 lto_output_tree_or_ref (ob, DECL_QUALIFIER (expr), ref_p);
930 lto_output_tree_or_ref (ob, DECL_FIELD_BIT_OFFSET (expr), ref_p);
931 lto_output_tree_or_ref (ob, DECL_FCONTEXT (expr), ref_p);
932 lto_output_chain (ob, TREE_CHAIN (expr), ref_p);
936 /* Write all pointer fields in the TS_FUNCTION_DECL structure of EXPR
937 to output block OB. If REF_P is true, write a reference to EXPR's
941 lto_output_ts_function_decl_tree_pointers (struct output_block *ob, tree expr,
944 /* DECL_STRUCT_FUNCTION is handled by lto_output_function. FIXME lto,
945 maybe it should be handled here? */
946 lto_output_tree_or_ref (ob, DECL_FUNCTION_PERSONALITY (expr), ref_p);
947 lto_output_tree_or_ref (ob, DECL_FUNCTION_SPECIFIC_TARGET (expr), ref_p);
948 lto_output_tree_or_ref (ob, DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr),
953 /* Write all pointer fields in the TS_TYPE structure of EXPR to output
954 block OB. If REF_P is true, write a reference to EXPR's pointer
958 lto_output_ts_type_tree_pointers (struct output_block *ob, tree expr,
961 if (TREE_CODE (expr) == ENUMERAL_TYPE)
962 lto_output_tree_or_ref (ob, TYPE_VALUES (expr), ref_p);
963 else if (TREE_CODE (expr) == ARRAY_TYPE)
964 lto_output_tree_or_ref (ob, TYPE_DOMAIN (expr), ref_p);
965 else if (RECORD_OR_UNION_TYPE_P (expr))
966 lto_output_tree_or_ref (ob, TYPE_FIELDS (expr), ref_p);
967 else if (TREE_CODE (expr) == FUNCTION_TYPE
968 || TREE_CODE (expr) == METHOD_TYPE)
969 lto_output_tree_or_ref (ob, TYPE_ARG_TYPES (expr), ref_p);
970 else if (TREE_CODE (expr) == VECTOR_TYPE)
971 lto_output_tree_or_ref (ob, TYPE_DEBUG_REPRESENTATION_TYPE (expr), ref_p);
973 lto_output_tree_or_ref (ob, TYPE_SIZE (expr), ref_p);
974 lto_output_tree_or_ref (ob, TYPE_SIZE_UNIT (expr), ref_p);
975 lto_output_tree_or_ref (ob, TYPE_ATTRIBUTES (expr), ref_p);
976 lto_output_tree_or_ref (ob, TYPE_NAME (expr), ref_p);
977 /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO nor
978 TYPE_NEXT_PTR_TO or TYPE_NEXT_REF_TO. */
979 if (!POINTER_TYPE_P (expr))
980 lto_output_tree_or_ref (ob, TYPE_MINVAL (expr), ref_p);
981 lto_output_tree_or_ref (ob, TYPE_MAXVAL (expr), ref_p);
982 lto_output_tree_or_ref (ob, TYPE_MAIN_VARIANT (expr), ref_p);
983 /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
985 if (RECORD_OR_UNION_TYPE_P (expr))
986 lto_output_tree_or_ref (ob, TYPE_BINFO (expr), ref_p);
987 lto_output_tree_or_ref (ob, TYPE_CONTEXT (expr), ref_p);
988 lto_output_tree_or_ref (ob, TYPE_CANONICAL (expr), ref_p);
989 lto_output_tree_or_ref (ob, TYPE_STUB_DECL (expr), ref_p);
993 /* Write all pointer fields in the TS_LIST structure of EXPR to output
994 block OB. If REF_P is true, write a reference to EXPR's pointer
998 lto_output_ts_list_tree_pointers (struct output_block *ob, tree expr,
1001 lto_output_tree_or_ref (ob, TREE_PURPOSE (expr), ref_p);
1002 lto_output_tree_or_ref (ob, TREE_VALUE (expr), ref_p);
1003 lto_output_chain (ob, TREE_CHAIN (expr), ref_p);
1007 /* Write all pointer fields in the TS_VEC structure of EXPR to output
1008 block OB. If REF_P is true, write a reference to EXPR's pointer
1012 lto_output_ts_vec_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
1016 /* Note that the number of slots for EXPR has already been emitted
1017 in EXPR's header (see lto_output_tree_header). */
1018 for (i = 0; i < TREE_VEC_LENGTH (expr); i++)
1019 lto_output_tree_or_ref (ob, TREE_VEC_ELT (expr, i), ref_p);
1023 /* Write all pointer fields in the TS_EXP structure of EXPR to output
1024 block OB. If REF_P is true, write a reference to EXPR's pointer
1028 lto_output_ts_exp_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
1032 output_sleb128 (ob, TREE_OPERAND_LENGTH (expr));
1033 for (i = 0; i < TREE_OPERAND_LENGTH (expr); i++)
1034 lto_output_tree_or_ref (ob, TREE_OPERAND (expr, i), ref_p);
1035 lto_output_location (ob, EXPR_LOCATION (expr));
1036 lto_output_tree_or_ref (ob, TREE_BLOCK (expr), ref_p);
1040 /* Write all pointer fields in the TS_BLOCK structure of EXPR to output
1041 block OB. If REF_P is true, write a reference to EXPR's pointer
1045 lto_output_ts_block_tree_pointers (struct output_block *ob, tree expr,
1051 lto_output_location (ob, BLOCK_SOURCE_LOCATION (expr));
1052 lto_output_chain (ob, BLOCK_VARS (expr), ref_p);
1054 output_uleb128 (ob, VEC_length (tree, BLOCK_NONLOCALIZED_VARS (expr)));
1055 for (i = 0; VEC_iterate (tree, BLOCK_NONLOCALIZED_VARS (expr), i, t); i++)
1056 lto_output_tree_or_ref (ob, t, ref_p);
1058 lto_output_tree_or_ref (ob, BLOCK_SUPERCONTEXT (expr), ref_p);
1059 lto_output_tree_or_ref (ob, BLOCK_ABSTRACT_ORIGIN (expr), ref_p);
1060 lto_output_tree_or_ref (ob, BLOCK_FRAGMENT_ORIGIN (expr), ref_p);
1061 lto_output_tree_or_ref (ob, BLOCK_FRAGMENT_CHAIN (expr), ref_p);
1062 lto_output_chain (ob, BLOCK_SUBBLOCKS (expr), ref_p);
1066 /* Write all pointer fields in the TS_BINFO structure of EXPR to output
1067 block OB. If REF_P is true, write a reference to EXPR's pointer
1071 lto_output_ts_binfo_tree_pointers (struct output_block *ob, tree expr,
1077 /* Note that the number of BINFO slots has already been emitted in
1078 EXPR's header (see lto_output_tree_header) because this length
1079 is needed to build the empty BINFO node on the reader side. */
1080 for (i = 0; VEC_iterate (tree, BINFO_BASE_BINFOS (expr), i, t); i++)
1081 lto_output_tree_or_ref (ob, t, ref_p);
1084 lto_output_tree_or_ref (ob, BINFO_OFFSET (expr), ref_p);
1085 lto_output_tree_or_ref (ob, BINFO_VTABLE (expr), ref_p);
1086 lto_output_tree_or_ref (ob, BINFO_VIRTUALS (expr), ref_p);
1087 lto_output_tree_or_ref (ob, BINFO_VPTR_FIELD (expr), ref_p);
1089 output_uleb128 (ob, VEC_length (tree, BINFO_BASE_ACCESSES (expr)));
1090 for (i = 0; VEC_iterate (tree, BINFO_BASE_ACCESSES (expr), i, t); i++)
1091 lto_output_tree_or_ref (ob, t, ref_p);
1093 lto_output_tree_or_ref (ob, BINFO_INHERITANCE_CHAIN (expr), ref_p);
1094 lto_output_tree_or_ref (ob, BINFO_SUBVTT_INDEX (expr), ref_p);
1095 lto_output_tree_or_ref (ob, BINFO_VPTR_INDEX (expr), ref_p);
1099 /* Write all pointer fields in the TS_CONSTRUCTOR structure of EXPR to
1100 output block OB. If REF_P is true, write a reference to EXPR's
1104 lto_output_ts_constructor_tree_pointers (struct output_block *ob, tree expr,
1110 output_uleb128 (ob, CONSTRUCTOR_NELTS (expr));
1111 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (expr), i, index, value)
1113 lto_output_tree_or_ref (ob, index, ref_p);
1114 lto_output_tree_or_ref (ob, value, ref_p);
1119 /* Helper for lto_output_tree. Write all pointer fields in EXPR to output
1120 block OB. If REF_P is true, the leaves of EXPR are emitted as
1124 lto_output_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
1126 enum tree_code code;
1128 code = TREE_CODE (expr);
1130 if (CODE_CONTAINS_STRUCT (code, TS_COMMON))
1131 lto_output_ts_common_tree_pointers (ob, expr, ref_p);
1133 if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
1134 lto_output_ts_vector_tree_pointers (ob, expr, ref_p);
1136 if (CODE_CONTAINS_STRUCT (code, TS_COMPLEX))
1137 lto_output_ts_complex_tree_pointers (ob, expr, ref_p);
1139 if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
1140 lto_output_ts_decl_minimal_tree_pointers (ob, expr, ref_p);
1142 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
1143 lto_output_ts_decl_common_tree_pointers (ob, expr, ref_p);
1145 if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
1146 lto_output_ts_decl_non_common_tree_pointers (ob, expr, ref_p);
1148 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
1149 lto_output_ts_decl_with_vis_tree_pointers (ob, expr, ref_p);
1151 if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL))
1152 lto_output_ts_field_decl_tree_pointers (ob, expr, ref_p);
1154 if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
1155 lto_output_ts_function_decl_tree_pointers (ob, expr, ref_p);
1157 if (CODE_CONTAINS_STRUCT (code, TS_TYPE))
1158 lto_output_ts_type_tree_pointers (ob, expr, ref_p);
1160 if (CODE_CONTAINS_STRUCT (code, TS_LIST))
1161 lto_output_ts_list_tree_pointers (ob, expr, ref_p);
1163 if (CODE_CONTAINS_STRUCT (code, TS_VEC))
1164 lto_output_ts_vec_tree_pointers (ob, expr, ref_p);
1166 if (CODE_CONTAINS_STRUCT (code, TS_EXP))
1167 lto_output_ts_exp_tree_pointers (ob, expr, ref_p);
1169 if (CODE_CONTAINS_STRUCT (code, TS_SSA_NAME))
1171 /* We only stream the version number of SSA names. */
1175 if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
1176 lto_output_ts_block_tree_pointers (ob, expr, ref_p);
1178 if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
1179 lto_output_ts_binfo_tree_pointers (ob, expr, ref_p);
1181 if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
1182 lto_output_ts_constructor_tree_pointers (ob, expr, ref_p);
1184 if (CODE_CONTAINS_STRUCT (code, TS_STATEMENT_LIST))
1186 /* This should only appear in GENERIC. */
1190 if (CODE_CONTAINS_STRUCT (code, TS_OMP_CLAUSE))
1192 /* This should only appear in High GIMPLE. */
1196 if (CODE_CONTAINS_STRUCT (code, TS_OPTIMIZATION))
1197 sorry ("gimple bytecode streams do not support the optimization attribute");
1199 if (CODE_CONTAINS_STRUCT (code, TS_TARGET_OPTION))
1200 sorry ("gimple bytecode streams do not support the target attribute");
1204 /* Emit header information for tree EXPR to output block OB. The header
1205 contains everything needed to instantiate an empty skeleton for
1206 EXPR on the reading side. IX is the index into the streamer cache
1207 where EXPR is stored. REF_P is as in lto_output_tree. */
1210 lto_output_tree_header (struct output_block *ob, tree expr, int ix)
1213 enum tree_code code;
1215 /* We should not see any non-GIMPLE tree nodes here. */
1216 code = TREE_CODE (expr);
1217 if (!lto_is_streamable (expr))
1218 internal_error ("tree code %qs is not supported in gimple streams",
1219 tree_code_name[code]);
1221 /* The header of a tree node consists of its tag, the size of
1222 the node, and any other information needed to instantiate
1223 EXPR on the reading side (such as the number of slots in
1224 variable sized nodes). */
1225 tag = lto_tree_code_to_tag (code);
1226 output_record_start (ob, tag);
1227 output_sleb128 (ob, ix);
1229 /* The following will cause bootstrap miscomparisons. Enable with care. */
1230 #ifdef LTO_STREAMER_DEBUG
1231 /* This is used mainly for debugging purposes. When the reader
1232 and the writer do not agree on a streamed node, the pointer
1233 value for EXPR can be used to track down the differences in
1235 gcc_assert ((HOST_WIDEST_INT) (intptr_t) expr == (intptr_t) expr);
1236 output_sleb128 (ob, (HOST_WIDEST_INT) (intptr_t) expr);
1239 /* The text in strings and identifiers are completely emitted in
1241 if (CODE_CONTAINS_STRUCT (code, TS_STRING))
1242 output_string_cst (ob, ob->main_stream, expr);
1243 else if (CODE_CONTAINS_STRUCT (code, TS_IDENTIFIER))
1244 output_identifier (ob, ob->main_stream, expr);
1245 else if (CODE_CONTAINS_STRUCT (code, TS_VEC))
1246 output_sleb128 (ob, TREE_VEC_LENGTH (expr));
1247 else if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
1248 output_uleb128 (ob, BINFO_N_BASE_BINFOS (expr));
1252 /* Write the code and class of builtin EXPR to output block OB. IX is
1253 the index into the streamer cache where EXPR is stored.*/
1256 lto_output_builtin_tree (struct output_block *ob, tree expr, int ix)
1258 gcc_assert (lto_stream_as_builtin_p (expr));
1260 if (DECL_BUILT_IN_CLASS (expr) == BUILT_IN_MD
1261 && !targetm.builtin_decl)
1262 sorry ("gimple bytecode streams do not support machine specific builtin "
1263 "functions on this target");
1265 output_record_start (ob, LTO_builtin_decl);
1266 output_uleb128 (ob, DECL_BUILT_IN_CLASS (expr));
1267 output_uleb128 (ob, DECL_FUNCTION_CODE (expr));
1268 output_sleb128 (ob, ix);
1270 if (DECL_ASSEMBLER_NAME_SET_P (expr))
1272 /* When the assembler name of a builtin gets a user name,
1273 the new name is always prefixed with '*' by
1274 set_builtin_user_assembler_name. So, to prevent the
1275 reader side from adding a second '*', we omit it here. */
1276 const char *str = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (expr));
1277 if (strlen (str) > 1 && str[0] == '*')
1278 output_string (ob, ob->main_stream, &str[1]);
1280 output_string (ob, ob->main_stream, NULL);
1283 output_string (ob, ob->main_stream, NULL);
1287 /* Write a physical representation of tree node EXPR to output block
1288 OB. If REF_P is true, the leaves of EXPR are emitted as references
1289 via lto_output_tree_ref. IX is the index into the streamer cache
1290 where EXPR is stored. */
1293 lto_write_tree (struct output_block *ob, tree expr, bool ref_p, int ix)
1295 struct bitpack_d *bp;
1297 /* Write the header, containing everything needed to materialize
1298 EXPR on the reading side. */
1299 lto_output_tree_header (ob, expr, ix);
1301 /* Pack all the non-pointer fields in EXPR into a bitpack and write
1302 the resulting bitpack. */
1303 bp = pack_value_fields (expr);
1304 lto_output_bitpack (ob->main_stream, bp);
1305 bitpack_delete (bp);
1307 /* Write all the pointer fields in EXPR. */
1308 lto_output_tree_pointers (ob, expr, ref_p);
1310 /* Mark the end of EXPR. */
1315 /* Emit the integer constant CST to output block OB. If REF_P is true,
1316 CST's type will be emitted as a reference. */
1319 lto_output_integer_cst (struct output_block *ob, tree cst, bool ref_p)
1321 output_record_start (ob, lto_tree_code_to_tag (INTEGER_CST));
1322 lto_output_tree_or_ref (ob, TREE_TYPE (cst), ref_p);
1323 lto_output_1_stream (ob->main_stream, TREE_OVERFLOW_P (cst));
1324 output_uleb128 (ob, TREE_INT_CST_LOW (cst));
1325 output_uleb128 (ob, TREE_INT_CST_HIGH (cst));
1329 /* Emit the physical representation of tree node EXPR to output block
1330 OB. If REF_P is true, the leaves of EXPR are emitted as references
1331 via lto_output_tree_ref. */
1334 lto_output_tree (struct output_block *ob, tree expr, bool ref_p)
1340 if (expr == NULL_TREE)
1346 /* INTEGER_CST nodes are special because they need their original type
1347 to be materialized by the reader (to implement TYPE_CACHED_VALUES). */
1348 if (TREE_CODE (expr) == INTEGER_CST)
1350 lto_output_integer_cst (ob, expr, ref_p);
1354 /* Determine the offset in the stream where EXPR will be written.
1355 This is used when emitting pickle references so the reader knows
1356 where to reconstruct the pickled object from. This allows
1357 circular and forward references within the same stream. */
1358 offset = ob->main_stream->total_size;
1360 existed_p = lto_streamer_cache_insert (ob->writer_cache, expr, &ix, &offset);
1363 /* If a node has already been streamed out, make sure that
1364 we don't write it more than once. Otherwise, the reader
1365 will instantiate two different nodes for the same object. */
1366 output_record_start (ob, LTO_tree_pickle_reference);
1367 output_sleb128 (ob, ix);
1368 output_uleb128 (ob, lto_tree_code_to_tag (TREE_CODE (expr)));
1369 output_uleb128 (ob, offset);
1371 else if (lto_stream_as_builtin_p (expr))
1373 /* MD and NORMAL builtins do not need to be written out
1374 completely as they are always instantiated by the
1375 compiler on startup. The only builtins that need to
1376 be written out are BUILT_IN_FRONTEND. For all other
1377 builtins, we simply write the class and code. */
1378 lto_output_builtin_tree (ob, expr, ix);
1382 /* This is the first time we see EXPR, write its fields
1384 lto_write_tree (ob, expr, ref_p, ix);
1389 /* Output to OB a list of try/catch handlers starting with FIRST. */
1392 output_eh_try_list (struct output_block *ob, eh_catch first)
1396 for (n = first; n; n = n->next_catch)
1398 output_record_start (ob, LTO_eh_catch);
1399 lto_output_tree_ref (ob, n->type_list);
1400 lto_output_tree_ref (ob, n->filter_list);
1401 lto_output_tree_ref (ob, n->label);
1408 /* Output EH region R in function FN to OB. CURR_RN is the slot index
1409 that is being emitted in FN->EH->REGION_ARRAY. This is used to
1410 detect EH region sharing. */
1413 output_eh_region (struct output_block *ob, eh_region r)
1423 if (r->type == ERT_CLEANUP)
1424 tag = LTO_ert_cleanup;
1425 else if (r->type == ERT_TRY)
1427 else if (r->type == ERT_ALLOWED_EXCEPTIONS)
1428 tag = LTO_ert_allowed_exceptions;
1429 else if (r->type == ERT_MUST_NOT_THROW)
1430 tag = LTO_ert_must_not_throw;
1434 output_record_start (ob, tag);
1435 output_sleb128 (ob, r->index);
1438 output_sleb128 (ob, r->outer->index);
1443 output_sleb128 (ob, r->inner->index);
1448 output_sleb128 (ob, r->next_peer->index);
1452 if (r->type == ERT_TRY)
1454 output_eh_try_list (ob, r->u.eh_try.first_catch);
1456 else if (r->type == ERT_ALLOWED_EXCEPTIONS)
1458 lto_output_tree_ref (ob, r->u.allowed.type_list);
1459 lto_output_tree_ref (ob, r->u.allowed.label);
1460 output_uleb128 (ob, r->u.allowed.filter);
1462 else if (r->type == ERT_MUST_NOT_THROW)
1464 lto_output_tree_ref (ob, r->u.must_not_throw.failure_decl);
1465 lto_output_location (ob, r->u.must_not_throw.failure_loc);
1468 if (r->landing_pads)
1469 output_sleb128 (ob, r->landing_pads->index);
1475 /* Output landing pad LP to OB. */
1478 output_eh_lp (struct output_block *ob, eh_landing_pad lp)
1486 output_record_start (ob, LTO_eh_landing_pad);
1487 output_sleb128 (ob, lp->index);
1489 output_sleb128 (ob, lp->next_lp->index);
1494 output_sleb128 (ob, lp->region->index);
1498 lto_output_tree_ref (ob, lp->post_landing_pad);
1502 /* Output the existing eh_table to OB. */
1505 output_eh_regions (struct output_block *ob, struct function *fn)
1507 if (fn->eh && fn->eh->region_tree)
1514 output_record_start (ob, LTO_eh_table);
1516 /* Emit the index of the root of the EH region tree. */
1517 output_sleb128 (ob, fn->eh->region_tree->index);
1519 /* Emit all the EH regions in the region array. */
1520 output_sleb128 (ob, VEC_length (eh_region, fn->eh->region_array));
1521 for (i = 0; VEC_iterate (eh_region, fn->eh->region_array, i, eh); i++)
1522 output_eh_region (ob, eh);
1524 /* Emit all landing pads. */
1525 output_sleb128 (ob, VEC_length (eh_landing_pad, fn->eh->lp_array));
1526 for (i = 0; VEC_iterate (eh_landing_pad, fn->eh->lp_array, i, lp); i++)
1527 output_eh_lp (ob, lp);
1529 /* Emit all the runtime type data. */
1530 output_sleb128 (ob, VEC_length (tree, fn->eh->ttype_data));
1531 for (i = 0; VEC_iterate (tree, fn->eh->ttype_data, i, ttype); i++)
1532 lto_output_tree_ref (ob, ttype);
1534 /* Emit the table of action chains. */
1535 if (targetm.arm_eabi_unwinder)
1538 output_sleb128 (ob, VEC_length (tree, fn->eh->ehspec_data.arm_eabi));
1540 VEC_iterate (tree, fn->eh->ehspec_data.arm_eabi, i, t);
1542 lto_output_tree_ref (ob, t);
1547 output_sleb128 (ob, VEC_length (uchar, fn->eh->ehspec_data.other));
1548 for (i = 0; VEC_iterate (uchar, fn->eh->ehspec_data.other, i, c); i++)
1549 lto_output_1_stream (ob->main_stream, c);
1553 /* The 0 either terminates the record or indicates that there are no
1554 eh_records at all. */
1559 /* Output all of the active ssa names to the ssa_names stream. */
1562 output_ssa_names (struct output_block *ob, struct function *fn)
1564 unsigned int i, len;
1566 len = VEC_length (tree, SSANAMES (fn));
1567 output_uleb128 (ob, len);
1569 for (i = 1; i < len; i++)
1571 tree ptr = VEC_index (tree, SSANAMES (fn), i);
1573 if (ptr == NULL_TREE
1574 || SSA_NAME_IN_FREE_LIST (ptr)
1575 || !is_gimple_reg (ptr))
1578 output_uleb128 (ob, i);
1579 lto_output_1_stream (ob->main_stream, SSA_NAME_IS_DEFAULT_DEF (ptr));
1580 lto_output_tree_ref (ob, SSA_NAME_VAR (ptr));
1587 /* Output the cfg. */
1590 output_cfg (struct output_block *ob, struct function *fn)
1592 struct lto_output_stream *tmp_stream = ob->main_stream;
1595 ob->main_stream = ob->cfg_stream;
1597 output_uleb128 (ob, profile_status_for_function (fn));
1599 /* Output the number of the highest basic block. */
1600 output_uleb128 (ob, last_basic_block_for_function (fn));
1602 FOR_ALL_BB_FN (bb, fn)
1607 output_sleb128 (ob, bb->index);
1609 /* Output the successors and the edge flags. */
1610 output_uleb128 (ob, EDGE_COUNT (bb->succs));
1611 FOR_EACH_EDGE (e, ei, bb->succs)
1613 output_uleb128 (ob, e->dest->index);
1614 output_sleb128 (ob, e->probability);
1615 output_sleb128 (ob, e->count);
1616 output_uleb128 (ob, e->flags);
1620 output_sleb128 (ob, -1);
1622 bb = ENTRY_BLOCK_PTR;
1625 output_sleb128 (ob, bb->next_bb->index);
1629 output_sleb128 (ob, -1);
1631 ob->main_stream = tmp_stream;
1635 /* Output PHI function PHI to the main stream in OB. */
1638 output_phi (struct output_block *ob, gimple phi)
1640 unsigned i, len = gimple_phi_num_args (phi);
1642 output_record_start (ob, lto_gimple_code_to_tag (GIMPLE_PHI));
1643 output_uleb128 (ob, SSA_NAME_VERSION (PHI_RESULT (phi)));
1645 for (i = 0; i < len; i++)
1647 lto_output_tree_ref (ob, gimple_phi_arg_def (phi, i));
1648 output_uleb128 (ob, gimple_phi_arg_edge (phi, i)->src->index);
1649 lto_output_location (ob, gimple_phi_arg_location (phi, i));
1654 /* Emit statement STMT on the main stream of output block OB. */
1657 output_gimple_stmt (struct output_block *ob, gimple stmt)
1660 enum gimple_code code;
1662 struct bitpack_d *bp;
1664 /* Emit identifying tag. */
1665 code = gimple_code (stmt);
1666 tag = lto_gimple_code_to_tag (code);
1667 output_record_start (ob, tag);
1669 /* Emit the tuple header. */
1670 bp = bitpack_create ();
1671 bp_pack_value (bp, gimple_num_ops (stmt), sizeof (unsigned) * 8);
1672 bp_pack_value (bp, gimple_no_warning_p (stmt), 1);
1673 if (is_gimple_assign (stmt))
1674 bp_pack_value (bp, gimple_assign_nontemporal_move_p (stmt), 1);
1675 bp_pack_value (bp, gimple_has_volatile_ops (stmt), 1);
1676 bp_pack_value (bp, stmt->gsbase.subcode, 16);
1677 lto_output_bitpack (ob->main_stream, bp);
1678 bitpack_delete (bp);
1680 /* Emit location information for the statement. */
1681 lto_output_location (ob, gimple_location (stmt));
1683 /* Emit the lexical block holding STMT. */
1684 lto_output_tree (ob, gimple_block (stmt), true);
1686 /* Emit the operands. */
1687 switch (gimple_code (stmt))
1690 output_sleb128 (ob, gimple_resx_region (stmt));
1693 case GIMPLE_EH_MUST_NOT_THROW:
1694 lto_output_tree_ref (ob, gimple_eh_must_not_throw_fndecl (stmt));
1697 case GIMPLE_EH_DISPATCH:
1698 output_sleb128 (ob, gimple_eh_dispatch_region (stmt));
1702 lto_output_uleb128_stream (ob->main_stream, gimple_asm_ninputs (stmt));
1703 lto_output_uleb128_stream (ob->main_stream, gimple_asm_noutputs (stmt));
1704 lto_output_uleb128_stream (ob->main_stream, gimple_asm_nclobbers (stmt));
1705 output_string (ob, ob->main_stream, gimple_asm_string (stmt));
1716 for (i = 0; i < gimple_num_ops (stmt); i++)
1718 tree op = gimple_op (stmt, i);
1719 lto_output_tree_ref (ob, op);
1724 case GIMPLE_PREDICT:
1733 /* Output a basic block BB to the main stream in OB for this FN. */
1736 output_bb (struct output_block *ob, basic_block bb, struct function *fn)
1738 gimple_stmt_iterator bsi = gsi_start_bb (bb);
1740 output_record_start (ob,
1741 (!gsi_end_p (bsi)) || phi_nodes (bb)
1745 output_uleb128 (ob, bb->index);
1746 output_sleb128 (ob, bb->count);
1747 output_sleb128 (ob, bb->loop_depth);
1748 output_sleb128 (ob, bb->frequency);
1749 output_sleb128 (ob, bb->flags);
1751 if (!gsi_end_p (bsi) || phi_nodes (bb))
1753 /* Output the statements. The list of statements is terminated
1755 for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
1758 gimple stmt = gsi_stmt (bsi);
1760 output_gimple_stmt (ob, stmt);
1762 /* Emit the EH region holding STMT. */
1763 region = lookup_stmt_eh_lp_fn (fn, stmt);
1766 output_record_start (ob, LTO_eh_region);
1767 output_sleb128 (ob, region);
1775 for (bsi = gsi_start_phis (bb); !gsi_end_p (bsi); gsi_next (&bsi))
1777 gimple phi = gsi_stmt (bsi);
1779 /* Only emit PHIs for gimple registers. PHI nodes for .MEM
1780 will be filled in on reading when the SSA form is
1782 if (is_gimple_reg (gimple_phi_result (phi)))
1783 output_phi (ob, phi);
1790 /* Create the header in the file using OB. If the section type is for
1791 a function, set FN to the decl for that function. */
1794 produce_asm (struct output_block *ob, tree fn)
1796 enum lto_section_type section_type = ob->section_type;
1797 struct lto_function_header header;
1799 struct lto_output_stream *header_stream;
1801 if (section_type == LTO_section_function_body)
1803 const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fn));
1804 section_name = lto_get_section_name (section_type, name);
1807 section_name = lto_get_section_name (section_type, NULL);
1809 lto_begin_section (section_name, !flag_wpa);
1810 free (section_name);
1812 /* The entire header is stream computed here. */
1813 memset (&header, 0, sizeof (struct lto_function_header));
1815 /* Write the header. */
1816 header.lto_header.major_version = LTO_major_version;
1817 header.lto_header.minor_version = LTO_minor_version;
1818 header.lto_header.section_type = section_type;
1820 header.compressed_size = 0;
1822 if (section_type == LTO_section_function_body)
1823 header.cfg_size = ob->cfg_stream->total_size;
1824 header.main_size = ob->main_stream->total_size;
1825 header.string_size = ob->string_stream->total_size;
1827 header_stream = XCNEW (struct lto_output_stream);
1828 lto_output_data_stream (header_stream, &header, sizeof header);
1829 lto_write_stream (header_stream);
1830 free (header_stream);
1832 /* Put all of the gimple and the string table out the asm file as a
1834 if (section_type == LTO_section_function_body)
1835 lto_write_stream (ob->cfg_stream);
1836 lto_write_stream (ob->main_stream);
1837 lto_write_stream (ob->string_stream);
1843 /* Output the body of function NODE->DECL. */
1846 output_function (struct cgraph_node *node)
1848 struct bitpack_d *bp;
1850 struct function *fn;
1852 struct output_block *ob;
1854 function = node->decl;
1855 fn = DECL_STRUCT_FUNCTION (function);
1856 ob = create_output_block (LTO_section_function_body);
1858 clear_line_info (ob);
1859 ob->cgraph_node = node;
1861 gcc_assert (current_function_decl == NULL_TREE && cfun == NULL);
1863 /* Set current_function_decl and cfun. */
1864 current_function_decl = function;
1867 /* Make string 0 be a NULL string. */
1868 lto_output_1_stream (ob->string_stream, 0);
1870 output_record_start (ob, LTO_function);
1872 /* Write all the attributes for FN. */
1873 bp = bitpack_create ();
1874 bp_pack_value (bp, fn->is_thunk, 1);
1875 bp_pack_value (bp, fn->has_local_explicit_reg_vars, 1);
1876 bp_pack_value (bp, fn->after_tree_profile, 1);
1877 bp_pack_value (bp, fn->returns_pcc_struct, 1);
1878 bp_pack_value (bp, fn->returns_struct, 1);
1879 bp_pack_value (bp, fn->always_inline_functions_inlined, 1);
1880 bp_pack_value (bp, fn->after_inlining, 1);
1881 bp_pack_value (bp, fn->dont_save_pending_sizes_p, 1);
1882 bp_pack_value (bp, fn->stdarg, 1);
1883 bp_pack_value (bp, fn->has_nonlocal_label, 1);
1884 bp_pack_value (bp, fn->calls_alloca, 1);
1885 bp_pack_value (bp, fn->calls_setjmp, 1);
1886 bp_pack_value (bp, fn->va_list_fpr_size, 8);
1887 bp_pack_value (bp, fn->va_list_gpr_size, 8);
1888 lto_output_bitpack (ob->main_stream, bp);
1889 bitpack_delete (bp);
1891 /* Output current IL state of the function. */
1892 output_uleb128 (ob, fn->curr_properties);
1894 /* Output the static chain and non-local goto save area. */
1895 lto_output_tree_ref (ob, fn->static_chain_decl);
1896 lto_output_tree_ref (ob, fn->nonlocal_goto_save_area);
1898 /* Output all the local variables in the function. */
1899 lto_output_tree_ref (ob, fn->local_decls);
1901 /* Output the head of the arguments list. */
1902 lto_output_tree_ref (ob, DECL_ARGUMENTS (function));
1904 /* Output all the SSA names used in the function. */
1905 output_ssa_names (ob, fn);
1907 /* Output any exception handling regions. */
1908 output_eh_regions (ob, fn);
1910 /* Output DECL_INITIAL for the function, which contains the tree of
1912 lto_output_tree (ob, DECL_INITIAL (function), true);
1914 /* We will renumber the statements. The code that does this uses
1915 the same ordering that we use for serializing them so we can use
1916 the same code on the other end and not have to write out the
1917 statement numbers. */
1918 renumber_gimple_stmt_uids ();
1920 /* Output the code for the function. */
1921 FOR_ALL_BB_FN (bb, fn)
1922 output_bb (ob, bb, fn);
1924 /* The terminator for this function. */
1927 output_cfg (ob, fn);
1929 /* Create a section to hold the pickled output of this function. */
1930 produce_asm (ob, function);
1932 destroy_output_block (ob);
1934 current_function_decl = NULL;
1939 /* Return true if alias pair P belongs to the set of cgraph nodes in
1940 SET. If P is a an alias for a VAR_DECL, it can always be emitted.
1941 However, for FUNCTION_DECL aliases, we should only output the pair
1942 if it belongs to a function whose cgraph node is in SET.
1943 Otherwise, the LTRANS phase will get into trouble when finalizing
1944 aliases because the alias will refer to a function not defined in
1945 the file processed by LTRANS. */
1948 output_alias_pair_p (alias_pair *p, cgraph_node_set set, varpool_node_set vset)
1950 if (TREE_CODE (p->decl) == VAR_DECL)
1951 return varpool_node_in_set_p (varpool_node_for_asm (p->target), vset);
1953 /* Check if the assembler name for P->TARGET has its cgraph node in SET. */
1954 gcc_assert (TREE_CODE (p->decl) == FUNCTION_DECL);
1955 return cgraph_node_in_set_p (cgraph_node_for_asm (p->target), set);
1959 /* Output any unreferenced global symbol defined in SET, alias pairs
1963 output_unreferenced_globals (cgraph_node_set set, varpool_node_set vset)
1965 struct output_block *ob;
1968 struct varpool_node *vnode;
1970 ob = create_output_block (LTO_section_static_initializer);
1971 ob->cgraph_node = NULL;
1973 clear_line_info (ob);
1975 /* Make string 0 be a NULL string. */
1976 lto_output_1_stream (ob->string_stream, 0);
1978 /* Emit references for all the global symbols. If a global symbol
1979 was never referenced in any of the functions of this file, it
1980 would not be emitted otherwise. This will result in unreferenced
1981 symbols at link time if a file defines a global symbol but
1982 never references it. */
1983 FOR_EACH_STATIC_VARIABLE (vnode)
1984 if (vnode->needed && varpool_node_in_set_p (vnode, vset))
1986 tree var = vnode->decl;
1988 if (TREE_CODE (var) == VAR_DECL)
1990 /* Output the object in order to output references used in the
1992 lto_output_tree (ob, var, true);
1994 /* If it is public we also need a reference to the object itself. */
1995 if (TREE_PUBLIC (var))
1996 lto_output_tree_ref (ob, var);
2002 /* Emit the alias pairs for the nodes in SET. */
2003 for (i = 0; VEC_iterate (alias_pair, alias_pairs, i, p); i++)
2005 if (output_alias_pair_p (p, set, vset))
2007 lto_output_tree_ref (ob, p->decl);
2008 lto_output_tree_ref (ob, p->target);
2014 produce_asm (ob, NULL);
2015 destroy_output_block (ob);
2019 /* Copy the function body of NODE without deserializing. */
2022 copy_function (struct cgraph_node *node)
2024 tree function = node->decl;
2025 struct lto_file_decl_data *file_data = node->local.lto_file_data;
2026 struct lto_output_stream *output_stream = XCNEW (struct lto_output_stream);
2029 const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (function));
2030 char *section_name =
2031 lto_get_section_name (LTO_section_function_body, name);
2033 struct lto_in_decl_state *in_state;
2034 struct lto_out_decl_state *out_state = lto_get_out_decl_state ();
2036 lto_begin_section (section_name, !flag_wpa);
2037 free (section_name);
2039 /* We may have renamed the declaration, e.g., a static function. */
2040 name = lto_get_decl_name_mapping (file_data, name);
2042 data = lto_get_section_data (file_data, LTO_section_function_body,
2046 /* Do a bit copy of the function body. */
2047 lto_output_data_stream (output_stream, data, len);
2048 lto_write_stream (output_stream);
2052 lto_get_function_in_decl_state (node->local.lto_file_data, function);
2053 gcc_assert (in_state);
2055 for (i = 0; i < LTO_N_DECL_STREAMS; i++)
2057 size_t n = in_state->streams[i].size;
2058 tree *trees = in_state->streams[i].trees;
2059 struct lto_tree_ref_encoder *encoder = &(out_state->streams[i]);
2061 /* The out state must have the same indices and the in state.
2062 So just copy the vector. All the encoders in the in state
2063 must be empty where we reach here. */
2064 gcc_assert (lto_tree_ref_encoder_size (encoder) == 0);
2065 for (j = 0; j < n; j++)
2066 VEC_safe_push (tree, heap, encoder->trees, trees[j]);
2067 encoder->next_index = n;
2070 lto_free_section_data (file_data, LTO_section_function_body, name,
2072 free (output_stream);
2077 /* Initialize the LTO writer. */
2080 lto_writer_init (void)
2082 lto_streamer_init ();
2086 /* Main entry point from the pass manager. */
2089 lto_output (cgraph_node_set set, varpool_node_set vset)
2091 struct cgraph_node *node;
2092 struct lto_out_decl_state *decl_state;
2093 #ifdef ENABLE_CHECKING
2094 bitmap output = lto_bitmap_alloc ();
2097 lto_cgraph_encoder_t encoder = lto_get_out_decl_state ()->cgraph_node_encoder;
2101 n_nodes = lto_cgraph_encoder_size (encoder);
2102 /* Process only the functions with bodies. */
2103 for (i = 0; i < n_nodes; i++)
2105 node = lto_cgraph_encoder_deref (encoder, i);
2106 if (lto_cgraph_encoder_encode_body_p (encoder, node))
2108 #ifdef ENABLE_CHECKING
2109 gcc_assert (!bitmap_bit_p (output, DECL_UID (node->decl)));
2110 bitmap_set_bit (output, DECL_UID (node->decl));
2112 decl_state = lto_new_out_decl_state ();
2113 lto_push_out_decl_state (decl_state);
2115 output_function (node);
2117 copy_function (node);
2118 gcc_assert (lto_get_out_decl_state () == decl_state);
2119 lto_pop_out_decl_state ();
2120 lto_record_function_out_decl_state (node->decl, decl_state);
2124 /* Emit the callgraph after emitting function bodies. This needs to
2125 be done now to make sure that all the statements in every function
2126 have been renumbered so that edges can be associated with call
2127 statements using the statement UIDs. */
2128 output_cgraph (set, vset);
2130 #ifdef ENABLE_CHECKING
2131 lto_bitmap_free (output);
2135 struct ipa_opt_pass_d pass_ipa_lto_gimple_out =
2139 "lto_gimple_out", /* name */
2140 gate_lto_out, /* gate */
2144 0, /* static_pass_number */
2145 TV_IPA_LTO_GIMPLE_IO, /* tv_id */
2146 0, /* properties_required */
2147 0, /* properties_provided */
2148 0, /* properties_destroyed */
2149 0, /* todo_flags_start */
2150 TODO_dump_func /* todo_flags_finish */
2152 NULL, /* generate_summary */
2153 lto_output, /* write_summary */
2154 NULL, /* read_summary */
2155 lto_output, /* write_optimization_summary */
2156 NULL, /* read_optimization_summary */
2157 NULL, /* stmt_fixup */
2159 NULL, /* function_transform */
2160 NULL /* variable_transform */
2164 /* Write each node in encoded by ENCODER to OB, as well as those reachable
2165 from it and required for correct representation of its semantics.
2166 Each node in ENCODER must be a global declaration or a type. A node
2167 is written only once, even if it appears multiple times in the
2168 vector. Certain transitively-reachable nodes, such as those
2169 representing expressions, may be duplicated, but such nodes
2170 must not appear in ENCODER itself. */
2173 write_global_stream (struct output_block *ob,
2174 struct lto_tree_ref_encoder *encoder)
2178 const size_t size = lto_tree_ref_encoder_size (encoder);
2180 for (index = 0; index < size; index++)
2182 t = lto_tree_ref_encoder_get_tree (encoder, index);
2183 if (!lto_streamer_cache_lookup (ob->writer_cache, t, NULL))
2184 lto_output_tree (ob, t, false);
2189 /* Write a sequence of indices into the globals vector corresponding
2190 to the trees in ENCODER. These are used by the reader to map the
2191 indices used to refer to global entities within function bodies to
2195 write_global_references (struct output_block *ob,
2196 struct lto_output_stream *ref_stream,
2197 struct lto_tree_ref_encoder *encoder)
2201 const int32_t size = lto_tree_ref_encoder_size (encoder);
2203 /* Write size as 32-bit unsigned. */
2204 lto_output_data_stream (ref_stream, &size, sizeof (int32_t));
2206 for (index = 0; index < size; index++)
2210 t = lto_tree_ref_encoder_get_tree (encoder, index);
2211 lto_streamer_cache_lookup (ob->writer_cache, t, &slot_num);
2212 gcc_assert (slot_num >= 0);
2213 lto_output_data_stream (ref_stream, &slot_num, sizeof slot_num);
2218 /* Write all the streams in an lto_out_decl_state STATE using
2219 output block OB and output stream OUT_STREAM. */
2222 lto_output_decl_state_streams (struct output_block *ob,
2223 struct lto_out_decl_state *state)
2227 for (i = 0; i < LTO_N_DECL_STREAMS; i++)
2228 write_global_stream (ob, &state->streams[i]);
2232 /* Write all the references in an lto_out_decl_state STATE using
2233 output block OB and output stream OUT_STREAM. */
2236 lto_output_decl_state_refs (struct output_block *ob,
2237 struct lto_output_stream *out_stream,
2238 struct lto_out_decl_state *state)
2244 /* Write reference to FUNCTION_DECL. If there is not function,
2245 write reference to void_type_node. */
2246 decl = (state->fn_decl) ? state->fn_decl : void_type_node;
2247 lto_streamer_cache_lookup (ob->writer_cache, decl, &ref);
2248 gcc_assert (ref >= 0);
2249 lto_output_data_stream (out_stream, &ref, sizeof (int32_t));
2251 for (i = 0; i < LTO_N_DECL_STREAMS; i++)
2252 write_global_references (ob, out_stream, &state->streams[i]);
2256 /* Return the written size of STATE. */
2259 lto_out_decl_state_written_size (struct lto_out_decl_state *state)
2264 size = sizeof (int32_t); /* fn_ref. */
2265 for (i = 0; i < LTO_N_DECL_STREAMS; i++)
2267 size += sizeof (int32_t); /* vector size. */
2268 size += (lto_tree_ref_encoder_size (&state->streams[i])
2269 * sizeof (int32_t));
2275 /* Helper function of write_symbols_of_kind. CACHE is the streamer
2276 cache with all the pickled nodes. STREAM is the stream where to
2277 write the table. V is a vector with the DECLs that should be on
2278 the table. SEEN is a bitmap of symbols written so far. */
2281 write_symbol_vec (struct lto_streamer_cache_d *cache,
2282 struct lto_output_stream *stream,
2283 VEC(tree,heap) *v, bitmap seen)
2288 for (index = 0; VEC_iterate(tree, v, index, t); index++)
2291 enum gcc_plugin_symbol_kind kind;
2292 enum gcc_plugin_symbol_visibility visibility;
2297 /* None of the following kinds of symbols are needed in the
2299 if (!TREE_PUBLIC (t)
2300 || is_builtin_fn (t)
2301 || DECL_ABSTRACT (t)
2302 || TREE_CODE (t) == RESULT_DECL)
2305 gcc_assert (TREE_CODE (t) == VAR_DECL
2306 || TREE_CODE (t) == FUNCTION_DECL);
2308 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (t));
2310 /* FIXME lto: this is from assemble_name_raw in varasm.c. For some
2311 architectures we might have to do the same name manipulations that
2312 ASM_OUTPUT_LABELREF does. */
2316 lto_streamer_cache_lookup (cache, t, &slot_num);
2317 gcc_assert (slot_num >= 0);
2319 /* Avoid duplicate symbols. */
2320 if (bitmap_bit_p (seen, slot_num))
2323 bitmap_set_bit (seen, slot_num);
2325 if (DECL_EXTERNAL (t))
2328 kind = GCCPK_WEAKUNDEF;
2335 kind = GCCPK_WEAKDEF;
2336 else if (DECL_COMMON (t))
2337 kind = GCCPK_COMMON;
2342 switch (DECL_VISIBILITY(t))
2344 case VISIBILITY_DEFAULT:
2345 visibility = GCCPV_DEFAULT;
2347 case VISIBILITY_PROTECTED:
2348 visibility = GCCPV_PROTECTED;
2350 case VISIBILITY_HIDDEN:
2351 visibility = GCCPV_HIDDEN;
2353 case VISIBILITY_INTERNAL:
2354 visibility = GCCPV_INTERNAL;
2358 if (kind == GCCPK_COMMON
2360 && TREE_CODE (DECL_SIZE (t)) == INTEGER_CST)
2361 size = (((uint64_t) TREE_INT_CST_HIGH (DECL_SIZE (t))) << 32)
2362 | TREE_INT_CST_LOW (DECL_SIZE (t));
2366 if (DECL_ONE_ONLY (t))
2367 comdat = IDENTIFIER_POINTER (DECL_COMDAT_GROUP (t));
2371 lto_output_data_stream (stream, name, strlen (name) + 1);
2372 lto_output_data_stream (stream, comdat, strlen (comdat) + 1);
2373 lto_output_data_stream (stream, &kind, 1);
2374 lto_output_data_stream (stream, &visibility, 1);
2375 lto_output_data_stream (stream, &size, 8);
2376 lto_output_data_stream (stream, &slot_num, 4);
2381 /* Write IL symbols of KIND. CACHE is the streamer cache with all the
2382 pickled nodes. SEEN is a bitmap of symbols written so far. */
2385 write_symbols_of_kind (lto_decl_stream_e_t kind,
2386 struct lto_streamer_cache_d *cache, bitmap seen)
2388 struct lto_out_decl_state *out_state;
2389 struct lto_output_stream stream;
2391 VEC_length (lto_out_decl_state_ptr, lto_function_decl_states);
2394 memset (&stream, 0, sizeof (stream));
2395 out_state = lto_get_out_decl_state ();
2396 write_symbol_vec (cache, &stream, out_state->streams[kind].trees, seen);
2398 for (idx = 0; idx < num_fns; idx++)
2401 VEC_index (lto_out_decl_state_ptr, lto_function_decl_states, idx);
2402 write_symbol_vec (cache, &stream, out_state->streams[kind].trees, seen);
2405 lto_write_stream (&stream);
2409 /* Write an IL symbol table. CACHE is the streamer cache with all the
2413 produce_symtab (struct lto_streamer_cache_d *cache)
2415 char *section_name = lto_get_section_name (LTO_section_symtab, NULL);
2418 lto_begin_section (section_name, false);
2419 free (section_name);
2421 seen = lto_bitmap_alloc ();
2422 write_symbols_of_kind (LTO_DECL_STREAM_FN_DECL, cache, seen);
2423 write_symbols_of_kind (LTO_DECL_STREAM_VAR_DECL, cache, seen);
2424 lto_bitmap_free (seen);
2430 /* This pass is run after all of the functions are serialized and all
2431 of the IPA passes have written their serialized forms. This pass
2432 causes the vector of all of the global decls and types used from
2433 this file to be written in to a section that can then be read in to
2434 recover these on other side. */
2437 produce_asm_for_decls (cgraph_node_set set, varpool_node_set vset)
2439 struct lto_out_decl_state *out_state;
2440 struct lto_out_decl_state *fn_out_state;
2441 struct lto_decl_header header;
2443 struct output_block *ob;
2444 struct lto_output_stream *header_stream, *decl_state_stream;
2445 unsigned idx, num_fns;
2446 size_t decl_state_size;
2447 int32_t num_decl_states;
2449 ob = create_output_block (LTO_section_decls);
2452 /* Write out unreferenced globals, alias pairs and labels. We defer
2453 doing this until now so that we can write out only what is
2455 output_unreferenced_globals (set, vset);
2457 memset (&header, 0, sizeof (struct lto_decl_header));
2459 section_name = lto_get_section_name (LTO_section_decls, NULL);
2460 lto_begin_section (section_name, !flag_wpa);
2461 free (section_name);
2463 /* Make string 0 be a NULL string. */
2464 lto_output_1_stream (ob->string_stream, 0);
2466 /* Write the global symbols. */
2467 out_state = lto_get_out_decl_state ();
2468 num_fns = VEC_length (lto_out_decl_state_ptr, lto_function_decl_states);
2469 lto_output_decl_state_streams (ob, out_state);
2470 for (idx = 0; idx < num_fns; idx++)
2473 VEC_index (lto_out_decl_state_ptr, lto_function_decl_states, idx);
2474 lto_output_decl_state_streams (ob, fn_out_state);
2477 header.lto_header.major_version = LTO_major_version;
2478 header.lto_header.minor_version = LTO_minor_version;
2479 header.lto_header.section_type = LTO_section_decls;
2481 /* Currently not used. This field would allow us to preallocate
2482 the globals vector, so that it need not be resized as it is extended. */
2483 header.num_nodes = -1;
2485 /* Compute the total size of all decl out states. */
2486 decl_state_size = sizeof (int32_t);
2487 decl_state_size += lto_out_decl_state_written_size (out_state);
2488 for (idx = 0; idx < num_fns; idx++)
2491 VEC_index (lto_out_decl_state_ptr, lto_function_decl_states, idx);
2492 decl_state_size += lto_out_decl_state_written_size (fn_out_state);
2494 header.decl_state_size = decl_state_size;
2496 header.main_size = ob->main_stream->total_size;
2497 header.string_size = ob->string_stream->total_size;
2499 header_stream = XCNEW (struct lto_output_stream);
2500 lto_output_data_stream (header_stream, &header, sizeof header);
2501 lto_write_stream (header_stream);
2502 free (header_stream);
2504 /* Write the main out-decl state, followed by out-decl states of
2506 decl_state_stream = ((struct lto_output_stream *)
2507 xcalloc (1, sizeof (struct lto_output_stream)));
2508 num_decl_states = num_fns + 1;
2509 lto_output_data_stream (decl_state_stream, &num_decl_states,
2510 sizeof (num_decl_states));
2511 lto_output_decl_state_refs (ob, decl_state_stream, out_state);
2512 for (idx = 0; idx < num_fns; idx++)
2515 VEC_index (lto_out_decl_state_ptr, lto_function_decl_states, idx);
2516 lto_output_decl_state_refs (ob, decl_state_stream, fn_out_state);
2518 lto_write_stream (decl_state_stream);
2519 free(decl_state_stream);
2521 lto_write_stream (ob->main_stream);
2522 lto_write_stream (ob->string_stream);
2526 /* Write the symbol table. */
2527 produce_symtab (ob->writer_cache);
2529 /* Write command line opts. */
2530 lto_write_options ();
2532 /* Deallocate memory and clean up. */
2533 for (idx = 0; idx < num_fns; idx++)
2536 VEC_index (lto_out_decl_state_ptr, lto_function_decl_states, idx);
2537 lto_delete_out_decl_state (fn_out_state);
2539 lto_cgraph_encoder_delete (ob->decl_state->cgraph_node_encoder);
2540 lto_varpool_encoder_delete (ob->decl_state->varpool_node_encoder);
2541 VEC_free (lto_out_decl_state_ptr, heap, lto_function_decl_states);
2542 lto_function_decl_states = NULL;
2543 destroy_output_block (ob);
2547 struct ipa_opt_pass_d pass_ipa_lto_finish_out =
2551 "lto_decls_out", /* name */
2552 gate_lto_out, /* gate */
2556 0, /* static_pass_number */
2557 TV_IPA_LTO_DECL_IO, /* tv_id */
2558 0, /* properties_required */
2559 0, /* properties_provided */
2560 0, /* properties_destroyed */
2561 0, /* todo_flags_start */
2562 0 /* todo_flags_finish */
2564 NULL, /* generate_summary */
2565 produce_asm_for_decls, /* write_summary */
2566 NULL, /* read_summary */
2567 produce_asm_for_decls, /* write_optimization_summary */
2568 NULL, /* read_optimization_summary */
2569 NULL, /* stmt_fixup */
2571 NULL, /* function_transform */
2572 NULL /* variable_transform */