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"
33 #include "basic-block.h"
34 #include "tree-flow.h"
35 #include "tree-pass.h"
39 #include "diagnostic-core.h"
42 #include "lto-symtab.h"
43 #include "lto-streamer.h"
44 #include "data-streamer.h"
45 #include "gimple-streamer.h"
46 #include "tree-streamer.h"
47 #include "streamer-hooks.h"
50 /* Clear the line info stored in DATA_IN. */
53 clear_line_info (struct output_block
*ob
)
55 ob
->current_file
= NULL
;
61 /* Create the output block and return it. SECTION_TYPE is
62 LTO_section_function_body or LTO_static_initializer. */
65 create_output_block (enum lto_section_type section_type
)
67 struct output_block
*ob
= XCNEW (struct output_block
);
69 ob
->section_type
= section_type
;
70 ob
->decl_state
= lto_get_out_decl_state ();
71 ob
->main_stream
= XCNEW (struct lto_output_stream
);
72 ob
->string_stream
= XCNEW (struct lto_output_stream
);
73 ob
->writer_cache
= streamer_tree_cache_create ();
75 if (section_type
== LTO_section_function_body
)
76 ob
->cfg_stream
= XCNEW (struct lto_output_stream
);
80 ob
->string_hash_table
= htab_create (37, hash_string_slot_node
,
81 eq_string_slot_node
, NULL
);
82 gcc_obstack_init (&ob
->obstack
);
88 /* Destroy the output block OB. */
91 destroy_output_block (struct output_block
*ob
)
93 enum lto_section_type section_type
= ob
->section_type
;
95 htab_delete (ob
->string_hash_table
);
97 free (ob
->main_stream
);
98 free (ob
->string_stream
);
99 if (section_type
== LTO_section_function_body
)
100 free (ob
->cfg_stream
);
102 streamer_tree_cache_delete (ob
->writer_cache
);
103 obstack_free (&ob
->obstack
, NULL
);
109 /* Look up NODE in the type table and write the index for it to OB. */
112 output_type_ref (struct output_block
*ob
, tree node
)
114 streamer_write_record_start (ob
, LTO_type_ref
);
115 lto_output_type_ref_index (ob
->decl_state
, ob
->main_stream
, node
);
119 /* Return true if tree node T is written to various tables. For these
120 nodes, we sometimes want to write their phyiscal representation
121 (via lto_output_tree), and sometimes we need to emit an index
122 reference into a table (via lto_output_tree_ref). */
125 tree_is_indexable (tree t
)
127 if (TREE_CODE (t
) == PARM_DECL
)
129 else if (TREE_CODE (t
) == VAR_DECL
&& decl_function_context (t
)
133 return (TYPE_P (t
) || DECL_P (t
) || TREE_CODE (t
) == SSA_NAME
);
137 /* Output info about new location into bitpack BP.
138 After outputting bitpack, lto_output_location_data has
139 to be done to output actual data. */
142 lto_output_location_bitpack (struct bitpack_d
*bp
,
143 struct output_block
*ob
,
146 expanded_location xloc
;
148 bp_pack_value (bp
, loc
== UNKNOWN_LOCATION
, 1);
149 if (loc
== UNKNOWN_LOCATION
)
152 xloc
= expand_location (loc
);
154 bp_pack_value (bp
, ob
->current_file
!= xloc
.file
, 1);
155 if (ob
->current_file
!= xloc
.file
)
156 bp_pack_var_len_unsigned (bp
,
157 streamer_string_index (ob
, xloc
.file
,
158 strlen (xloc
.file
) + 1,
160 ob
->current_file
= xloc
.file
;
162 bp_pack_value (bp
, ob
->current_line
!= xloc
.line
, 1);
163 if (ob
->current_line
!= xloc
.line
)
164 bp_pack_var_len_unsigned (bp
, xloc
.line
);
165 ob
->current_line
= xloc
.line
;
167 bp_pack_value (bp
, ob
->current_col
!= xloc
.column
, 1);
168 if (ob
->current_col
!= xloc
.column
)
169 bp_pack_var_len_unsigned (bp
, xloc
.column
);
170 ob
->current_col
= xloc
.column
;
174 /* Emit location LOC to output block OB.
175 When bitpack is handy, it is more space effecient to call
176 lto_output_location_bitpack with existing bitpack. */
179 lto_output_location (struct output_block
*ob
, location_t loc
)
181 struct bitpack_d bp
= bitpack_create (ob
->main_stream
);
182 lto_output_location_bitpack (&bp
, ob
, loc
);
183 streamer_write_bitpack (&bp
);
187 /* If EXPR is an indexable tree node, output a reference to it to
188 output block OB. Otherwise, output the physical representation of
192 lto_output_tree_ref (struct output_block
*ob
, tree expr
)
198 output_type_ref (ob
, expr
);
202 code
= TREE_CODE (expr
);
206 streamer_write_record_start (ob
, LTO_ssa_name_ref
);
207 streamer_write_uhwi (ob
, SSA_NAME_VERSION (expr
));
211 streamer_write_record_start (ob
, LTO_field_decl_ref
);
212 lto_output_field_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
216 streamer_write_record_start (ob
, LTO_function_decl_ref
);
217 lto_output_fn_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
221 case DEBUG_EXPR_DECL
:
222 gcc_assert (decl_function_context (expr
) == NULL
|| TREE_STATIC (expr
));
223 streamer_write_record_start (ob
, LTO_global_decl_ref
);
224 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
228 streamer_write_record_start (ob
, LTO_const_decl_ref
);
229 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
233 gcc_assert (decl_function_context (expr
) == NULL
);
234 streamer_write_record_start (ob
, LTO_imported_decl_ref
);
235 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
239 streamer_write_record_start (ob
, LTO_type_decl_ref
);
240 lto_output_type_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
244 streamer_write_record_start (ob
, LTO_namespace_decl_ref
);
245 lto_output_namespace_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
249 streamer_write_record_start (ob
, LTO_label_decl_ref
);
250 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
254 streamer_write_record_start (ob
, LTO_result_decl_ref
);
255 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
258 case TRANSLATION_UNIT_DECL
:
259 streamer_write_record_start (ob
, LTO_translation_unit_decl_ref
);
260 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
264 /* No other node is indexable, so it should have been handled by
271 /* Return true if EXPR is a tree node that can be written to disk. */
274 lto_is_streamable (tree expr
)
276 enum tree_code code
= TREE_CODE (expr
);
278 /* Notice that we reject SSA_NAMEs as well. We only emit the SSA
279 name version in lto_output_tree_ref (see output_ssa_names). */
280 return !is_lang_specific (expr
)
284 && code
!= MODIFY_EXPR
286 && code
!= TARGET_EXPR
288 && code
!= WITH_CLEANUP_EXPR
289 && code
!= STATEMENT_LIST
290 && code
!= OMP_CLAUSE
291 && code
!= OPTIMIZATION_NODE
292 && (code
== CASE_LABEL_EXPR
294 || TREE_CODE_CLASS (code
) != tcc_statement
);
298 /* Write a physical representation of tree node EXPR to output block
299 OB. If REF_P is true, the leaves of EXPR are emitted as references
300 via lto_output_tree_ref. IX is the index into the streamer cache
301 where EXPR is stored. */
304 lto_write_tree (struct output_block
*ob
, tree expr
, bool ref_p
)
308 if (!lto_is_streamable (expr
))
309 internal_error ("tree code %qs is not supported in LTO streams",
310 tree_code_name
[TREE_CODE (expr
)]);
312 /* Write the header, containing everything needed to materialize
313 EXPR on the reading side. */
314 streamer_write_tree_header (ob
, expr
);
316 /* Pack all the non-pointer fields in EXPR into a bitpack and write
317 the resulting bitpack. */
318 bp
= bitpack_create (ob
->main_stream
);
319 streamer_pack_tree_bitfields (&bp
, expr
);
320 streamer_write_bitpack (&bp
);
322 /* Write all the pointer fields in EXPR. */
323 streamer_write_tree_body (ob
, expr
, ref_p
);
325 /* Write any LTO-specific data to OB. */
327 && TREE_CODE (expr
) != FUNCTION_DECL
328 && TREE_CODE (expr
) != TRANSLATION_UNIT_DECL
)
330 /* Handle DECL_INITIAL for symbols. */
331 tree initial
= DECL_INITIAL (expr
);
332 if (TREE_CODE (expr
) == VAR_DECL
333 && (TREE_STATIC (expr
) || DECL_EXTERNAL (expr
))
336 lto_varpool_encoder_t varpool_encoder
;
337 struct varpool_node
*vnode
;
339 varpool_encoder
= ob
->decl_state
->varpool_node_encoder
;
340 vnode
= varpool_get_node (expr
);
342 initial
= error_mark_node
;
343 else if (!lto_varpool_encoder_encode_initializer_p (varpool_encoder
,
348 stream_write_tree (ob
, initial
, ref_p
);
351 /* Mark the end of EXPR. */
352 streamer_write_zero (ob
);
356 /* Emit the physical representation of tree node EXPR to output block
357 OB. If REF_P is true, the leaves of EXPR are emitted as references
358 via lto_output_tree_ref. */
361 lto_output_tree (struct output_block
*ob
, tree expr
, bool ref_p
)
366 if (expr
== NULL_TREE
)
368 streamer_write_record_start (ob
, LTO_null
);
372 if (ref_p
&& tree_is_indexable (expr
))
374 lto_output_tree_ref (ob
, expr
);
378 /* INTEGER_CST nodes are special because they need their original type
379 to be materialized by the reader (to implement TYPE_CACHED_VALUES). */
380 if (TREE_CODE (expr
) == INTEGER_CST
)
382 streamer_write_integer_cst (ob
, expr
, ref_p
);
386 existed_p
= streamer_tree_cache_insert (ob
->writer_cache
, expr
, &ix
);
389 /* If a node has already been streamed out, make sure that
390 we don't write it more than once. Otherwise, the reader
391 will instantiate two different nodes for the same object. */
392 streamer_write_record_start (ob
, LTO_tree_pickle_reference
);
393 streamer_write_uhwi (ob
, ix
);
394 streamer_write_enum (ob
->main_stream
, LTO_tags
, LTO_NUM_TAGS
,
395 lto_tree_code_to_tag (TREE_CODE (expr
)));
397 else if (streamer_handle_as_builtin_p (expr
))
399 /* MD and NORMAL builtins do not need to be written out
400 completely as they are always instantiated by the
401 compiler on startup. The only builtins that need to
402 be written out are BUILT_IN_FRONTEND. For all other
403 builtins, we simply write the class and code. */
404 streamer_write_builtin (ob
, expr
);
408 /* This is the first time we see EXPR, write its fields
410 lto_write_tree (ob
, expr
, ref_p
);
415 /* Output to OB a list of try/catch handlers starting with FIRST. */
418 output_eh_try_list (struct output_block
*ob
, eh_catch first
)
422 for (n
= first
; n
; n
= n
->next_catch
)
424 streamer_write_record_start (ob
, LTO_eh_catch
);
425 stream_write_tree (ob
, n
->type_list
, true);
426 stream_write_tree (ob
, n
->filter_list
, true);
427 stream_write_tree (ob
, n
->label
, true);
430 streamer_write_record_start (ob
, LTO_null
);
434 /* Output EH region R in function FN to OB. CURR_RN is the slot index
435 that is being emitted in FN->EH->REGION_ARRAY. This is used to
436 detect EH region sharing. */
439 output_eh_region (struct output_block
*ob
, eh_region r
)
445 streamer_write_record_start (ob
, LTO_null
);
449 if (r
->type
== ERT_CLEANUP
)
450 tag
= LTO_ert_cleanup
;
451 else if (r
->type
== ERT_TRY
)
453 else if (r
->type
== ERT_ALLOWED_EXCEPTIONS
)
454 tag
= LTO_ert_allowed_exceptions
;
455 else if (r
->type
== ERT_MUST_NOT_THROW
)
456 tag
= LTO_ert_must_not_throw
;
460 streamer_write_record_start (ob
, tag
);
461 streamer_write_hwi (ob
, r
->index
);
464 streamer_write_hwi (ob
, r
->outer
->index
);
466 streamer_write_zero (ob
);
469 streamer_write_hwi (ob
, r
->inner
->index
);
471 streamer_write_zero (ob
);
474 streamer_write_hwi (ob
, r
->next_peer
->index
);
476 streamer_write_zero (ob
);
478 if (r
->type
== ERT_TRY
)
480 output_eh_try_list (ob
, r
->u
.eh_try
.first_catch
);
482 else if (r
->type
== ERT_ALLOWED_EXCEPTIONS
)
484 stream_write_tree (ob
, r
->u
.allowed
.type_list
, true);
485 stream_write_tree (ob
, r
->u
.allowed
.label
, true);
486 streamer_write_uhwi (ob
, r
->u
.allowed
.filter
);
488 else if (r
->type
== ERT_MUST_NOT_THROW
)
490 stream_write_tree (ob
, r
->u
.must_not_throw
.failure_decl
, true);
491 lto_output_location (ob
, r
->u
.must_not_throw
.failure_loc
);
495 streamer_write_hwi (ob
, r
->landing_pads
->index
);
497 streamer_write_zero (ob
);
501 /* Output landing pad LP to OB. */
504 output_eh_lp (struct output_block
*ob
, eh_landing_pad lp
)
508 streamer_write_record_start (ob
, LTO_null
);
512 streamer_write_record_start (ob
, LTO_eh_landing_pad
);
513 streamer_write_hwi (ob
, lp
->index
);
515 streamer_write_hwi (ob
, lp
->next_lp
->index
);
517 streamer_write_zero (ob
);
520 streamer_write_hwi (ob
, lp
->region
->index
);
522 streamer_write_zero (ob
);
524 stream_write_tree (ob
, lp
->post_landing_pad
, true);
528 /* Output the existing eh_table to OB. */
531 output_eh_regions (struct output_block
*ob
, struct function
*fn
)
533 if (fn
->eh
&& fn
->eh
->region_tree
)
540 streamer_write_record_start (ob
, LTO_eh_table
);
542 /* Emit the index of the root of the EH region tree. */
543 streamer_write_hwi (ob
, fn
->eh
->region_tree
->index
);
545 /* Emit all the EH regions in the region array. */
546 streamer_write_hwi (ob
, VEC_length (eh_region
, fn
->eh
->region_array
));
547 FOR_EACH_VEC_ELT (eh_region
, fn
->eh
->region_array
, i
, eh
)
548 output_eh_region (ob
, eh
);
550 /* Emit all landing pads. */
551 streamer_write_hwi (ob
, VEC_length (eh_landing_pad
, fn
->eh
->lp_array
));
552 FOR_EACH_VEC_ELT (eh_landing_pad
, fn
->eh
->lp_array
, i
, lp
)
553 output_eh_lp (ob
, lp
);
555 /* Emit all the runtime type data. */
556 streamer_write_hwi (ob
, VEC_length (tree
, fn
->eh
->ttype_data
));
557 FOR_EACH_VEC_ELT (tree
, fn
->eh
->ttype_data
, i
, ttype
)
558 stream_write_tree (ob
, ttype
, true);
560 /* Emit the table of action chains. */
561 if (targetm
.arm_eabi_unwinder
)
564 streamer_write_hwi (ob
, VEC_length (tree
,
565 fn
->eh
->ehspec_data
.arm_eabi
));
566 FOR_EACH_VEC_ELT (tree
, fn
->eh
->ehspec_data
.arm_eabi
, i
, t
)
567 stream_write_tree (ob
, t
, true);
572 streamer_write_hwi (ob
, VEC_length (uchar
,
573 fn
->eh
->ehspec_data
.other
));
574 FOR_EACH_VEC_ELT (uchar
, fn
->eh
->ehspec_data
.other
, i
, c
)
575 streamer_write_char_stream (ob
->main_stream
, c
);
579 /* The LTO_null either terminates the record or indicates that there
580 are no eh_records at all. */
581 streamer_write_record_start (ob
, LTO_null
);
585 /* Output all of the active ssa names to the ssa_names stream. */
588 output_ssa_names (struct output_block
*ob
, struct function
*fn
)
592 len
= VEC_length (tree
, SSANAMES (fn
));
593 streamer_write_uhwi (ob
, len
);
595 for (i
= 1; i
< len
; i
++)
597 tree ptr
= VEC_index (tree
, SSANAMES (fn
), i
);
600 || SSA_NAME_IN_FREE_LIST (ptr
)
601 || !is_gimple_reg (ptr
))
604 streamer_write_uhwi (ob
, i
);
605 streamer_write_char_stream (ob
->main_stream
,
606 SSA_NAME_IS_DEFAULT_DEF (ptr
));
607 stream_write_tree (ob
, SSA_NAME_VAR (ptr
), true);
610 streamer_write_zero (ob
);
614 /* Output the cfg. */
617 output_cfg (struct output_block
*ob
, struct function
*fn
)
619 struct lto_output_stream
*tmp_stream
= ob
->main_stream
;
622 ob
->main_stream
= ob
->cfg_stream
;
624 streamer_write_enum (ob
->main_stream
, profile_status_d
, PROFILE_LAST
,
625 profile_status_for_function (fn
));
627 /* Output the number of the highest basic block. */
628 streamer_write_uhwi (ob
, last_basic_block_for_function (fn
));
630 FOR_ALL_BB_FN (bb
, fn
)
635 streamer_write_hwi (ob
, bb
->index
);
637 /* Output the successors and the edge flags. */
638 streamer_write_uhwi (ob
, EDGE_COUNT (bb
->succs
));
639 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
641 streamer_write_uhwi (ob
, e
->dest
->index
);
642 streamer_write_hwi (ob
, e
->probability
);
643 streamer_write_hwi (ob
, e
->count
);
644 streamer_write_uhwi (ob
, e
->flags
);
648 streamer_write_hwi (ob
, -1);
650 bb
= ENTRY_BLOCK_PTR
;
653 streamer_write_hwi (ob
, bb
->next_bb
->index
);
657 streamer_write_hwi (ob
, -1);
659 ob
->main_stream
= tmp_stream
;
663 /* Create the header in the file using OB. If the section type is for
664 a function, set FN to the decl for that function. */
667 produce_asm (struct output_block
*ob
, tree fn
)
669 enum lto_section_type section_type
= ob
->section_type
;
670 struct lto_function_header header
;
672 struct lto_output_stream
*header_stream
;
674 if (section_type
== LTO_section_function_body
)
676 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fn
));
677 section_name
= lto_get_section_name (section_type
, name
, NULL
);
680 section_name
= lto_get_section_name (section_type
, NULL
, NULL
);
682 lto_begin_section (section_name
, !flag_wpa
);
685 /* The entire header is stream computed here. */
686 memset (&header
, 0, sizeof (struct lto_function_header
));
688 /* Write the header. */
689 header
.lto_header
.major_version
= LTO_major_version
;
690 header
.lto_header
.minor_version
= LTO_minor_version
;
691 header
.lto_header
.section_type
= section_type
;
693 header
.compressed_size
= 0;
695 if (section_type
== LTO_section_function_body
)
696 header
.cfg_size
= ob
->cfg_stream
->total_size
;
697 header
.main_size
= ob
->main_stream
->total_size
;
698 header
.string_size
= ob
->string_stream
->total_size
;
700 header_stream
= XCNEW (struct lto_output_stream
);
701 lto_output_data_stream (header_stream
, &header
, sizeof header
);
702 lto_write_stream (header_stream
);
703 free (header_stream
);
705 /* Put all of the gimple and the string table out the asm file as a
707 if (section_type
== LTO_section_function_body
)
708 lto_write_stream (ob
->cfg_stream
);
709 lto_write_stream (ob
->main_stream
);
710 lto_write_stream (ob
->string_stream
);
716 /* Output the body of function NODE->DECL. */
719 output_function (struct cgraph_node
*node
)
725 struct output_block
*ob
;
729 function
= node
->decl
;
730 fn
= DECL_STRUCT_FUNCTION (function
);
731 ob
= create_output_block (LTO_section_function_body
);
733 clear_line_info (ob
);
734 ob
->cgraph_node
= node
;
736 gcc_assert (current_function_decl
== NULL_TREE
&& cfun
== NULL
);
738 /* Set current_function_decl and cfun. */
739 current_function_decl
= function
;
742 /* Make string 0 be a NULL string. */
743 streamer_write_char_stream (ob
->string_stream
, 0);
745 streamer_write_record_start (ob
, LTO_function
);
747 /* Write all the attributes for FN. */
748 bp
= bitpack_create (ob
->main_stream
);
749 bp_pack_value (&bp
, fn
->is_thunk
, 1);
750 bp_pack_value (&bp
, fn
->has_local_explicit_reg_vars
, 1);
751 bp_pack_value (&bp
, fn
->after_tree_profile
, 1);
752 bp_pack_value (&bp
, fn
->returns_pcc_struct
, 1);
753 bp_pack_value (&bp
, fn
->returns_struct
, 1);
754 bp_pack_value (&bp
, fn
->can_throw_non_call_exceptions
, 1);
755 bp_pack_value (&bp
, fn
->always_inline_functions_inlined
, 1);
756 bp_pack_value (&bp
, fn
->after_inlining
, 1);
757 bp_pack_value (&bp
, fn
->stdarg
, 1);
758 bp_pack_value (&bp
, fn
->has_nonlocal_label
, 1);
759 bp_pack_value (&bp
, fn
->calls_alloca
, 1);
760 bp_pack_value (&bp
, fn
->calls_setjmp
, 1);
761 bp_pack_value (&bp
, fn
->va_list_fpr_size
, 8);
762 bp_pack_value (&bp
, fn
->va_list_gpr_size
, 8);
763 streamer_write_bitpack (&bp
);
765 /* Output the function start and end loci. */
766 lto_output_location (ob
, fn
->function_start_locus
);
767 lto_output_location (ob
, fn
->function_end_locus
);
769 /* Output current IL state of the function. */
770 streamer_write_uhwi (ob
, fn
->curr_properties
);
772 /* Output the static chain and non-local goto save area. */
773 stream_write_tree (ob
, fn
->static_chain_decl
, true);
774 stream_write_tree (ob
, fn
->nonlocal_goto_save_area
, true);
776 /* Output all the local variables in the function. */
777 streamer_write_hwi (ob
, VEC_length (tree
, fn
->local_decls
));
778 FOR_EACH_VEC_ELT (tree
, fn
->local_decls
, i
, t
)
779 stream_write_tree (ob
, t
, true);
781 /* Output the head of the arguments list. */
782 stream_write_tree (ob
, DECL_ARGUMENTS (function
), true);
784 /* Output all the SSA names used in the function. */
785 output_ssa_names (ob
, fn
);
787 /* Output any exception handling regions. */
788 output_eh_regions (ob
, fn
);
790 /* Output DECL_INITIAL for the function, which contains the tree of
792 stream_write_tree (ob
, DECL_INITIAL (function
), true);
794 /* We will renumber the statements. The code that does this uses
795 the same ordering that we use for serializing them so we can use
796 the same code on the other end and not have to write out the
797 statement numbers. We do not assign UIDs to PHIs here because
798 virtual PHIs get re-computed on-the-fly which would make numbers
800 set_gimple_stmt_max_uid (cfun
, 0);
803 gimple_stmt_iterator gsi
;
804 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
806 gimple stmt
= gsi_stmt (gsi
);
807 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
811 /* Output the code for the function. */
812 FOR_ALL_BB_FN (bb
, fn
)
813 output_bb (ob
, bb
, fn
);
815 /* The terminator for this function. */
816 streamer_write_record_start (ob
, LTO_null
);
820 /* Create a section to hold the pickled output of this function. */
821 produce_asm (ob
, function
);
823 destroy_output_block (ob
);
825 current_function_decl
= NULL
;
830 /* Used to pass data to trivally_defined_alias callback. */
833 varpool_node_set vset
;
837 /* Return true if alias pair P belongs to the set of cgraph nodes in
838 SET. If P is a an alias for a VAR_DECL, it can always be emitted.
839 However, for FUNCTION_DECL aliases, we should only output the pair
840 if it belongs to a function whose cgraph node is in SET.
841 Otherwise, the LTRANS phase will get into trouble when finalizing
842 aliases because the alias will refer to a function not defined in
843 the file processed by LTRANS. */
846 trivally_defined_alias (tree decl ATTRIBUTE_UNUSED
,
847 tree target
, void *data
)
849 struct sets
*set
= (struct sets
*) data
;
850 struct cgraph_node
*fnode
= NULL
;
851 struct varpool_node
*vnode
= NULL
;
853 fnode
= cgraph_node_for_asm (target
);
855 return cgraph_node_in_set_p (fnode
, set
->set
);
856 vnode
= varpool_node_for_asm (target
);
857 return vnode
&& varpool_node_in_set_p (vnode
, set
->vset
);
860 /* Return true if alias pair P should be output in the current
861 partition contains cgrpah nodes SET and varpool nodes VSET.
862 DEFINED is set of all aliases whose targets are defined in
865 Normal aliases are output when they are defined, while WEAKREF
866 aliases are output when they are used. */
869 output_alias_pair_p (alias_pair
*p
, symbol_alias_set_t
*defined
,
870 cgraph_node_set set
, varpool_node_set vset
)
872 struct cgraph_node
*node
;
873 struct varpool_node
*vnode
;
875 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (p
->decl
)))
877 if (TREE_CODE (p
->decl
) == VAR_DECL
)
879 vnode
= varpool_get_node (p
->decl
);
881 && referenced_from_this_partition_p (&vnode
->ref_list
, set
, vset
));
883 node
= cgraph_get_node (p
->decl
);
885 && (referenced_from_this_partition_p (&node
->ref_list
, set
, vset
)
886 || reachable_from_this_partition_p (node
, set
)));
889 return symbol_alias_set_contains (defined
, p
->decl
);
892 /* Output any unreferenced global symbol defined in SET, alias pairs
896 output_unreferenced_globals (cgraph_node_set set
, varpool_node_set vset
)
898 struct output_block
*ob
;
901 symbol_alias_set_t
*defined
;
907 ob
= create_output_block (LTO_section_static_initializer
);
908 ob
->cgraph_node
= NULL
;
910 clear_line_info (ob
);
912 /* Make string 0 be a NULL string. */
913 streamer_write_char_stream (ob
->string_stream
, 0);
915 /* We really need to propagate in both directoins:
916 for normal aliases we propagate from first defined alias to
917 all aliases defined based on it. For weakrefs we propagate in
918 the oposite direction. */
919 defined
= propagate_aliases_backward (trivally_defined_alias
, &setdata
);
921 /* Emit the alias pairs for the nodes in SET. */
922 FOR_EACH_VEC_ELT (alias_pair
, alias_pairs
, i
, p
)
923 if (output_alias_pair_p (p
, defined
, set
, vset
))
925 stream_write_tree (ob
, p
->decl
, true);
926 stream_write_tree (ob
, p
->target
, true);
928 symbol_alias_set_destroy (defined
);
930 streamer_write_record_start (ob
, LTO_null
);
932 produce_asm (ob
, NULL
);
933 destroy_output_block (ob
);
937 /* Emit toplevel asms. */
940 lto_output_toplevel_asms (void)
942 struct output_block
*ob
;
943 struct cgraph_asm_node
*can
;
945 struct lto_output_stream
*header_stream
;
946 struct lto_asm_header header
;
948 if (! cgraph_asm_nodes
)
951 ob
= create_output_block (LTO_section_asm
);
953 /* Make string 0 be a NULL string. */
954 streamer_write_char_stream (ob
->string_stream
, 0);
956 for (can
= cgraph_asm_nodes
; can
; can
= can
->next
)
957 streamer_write_string_cst (ob
, ob
->main_stream
, can
->asm_str
);
959 streamer_write_string_cst (ob
, ob
->main_stream
, NULL_TREE
);
961 section_name
= lto_get_section_name (LTO_section_asm
, NULL
, NULL
);
962 lto_begin_section (section_name
, !flag_wpa
);
965 /* The entire header stream is computed here. */
966 memset (&header
, 0, sizeof (header
));
968 /* Write the header. */
969 header
.lto_header
.major_version
= LTO_major_version
;
970 header
.lto_header
.minor_version
= LTO_minor_version
;
971 header
.lto_header
.section_type
= LTO_section_asm
;
973 header
.main_size
= ob
->main_stream
->total_size
;
974 header
.string_size
= ob
->string_stream
->total_size
;
976 header_stream
= XCNEW (struct lto_output_stream
);
977 lto_output_data_stream (header_stream
, &header
, sizeof (header
));
978 lto_write_stream (header_stream
);
979 free (header_stream
);
981 /* Put all of the gimple and the string table out the asm file as a
983 lto_write_stream (ob
->main_stream
);
984 lto_write_stream (ob
->string_stream
);
988 destroy_output_block (ob
);
992 /* Copy the function body of NODE without deserializing. */
995 copy_function (struct cgraph_node
*node
)
997 tree function
= node
->decl
;
998 struct lto_file_decl_data
*file_data
= node
->local
.lto_file_data
;
999 struct lto_output_stream
*output_stream
= XCNEW (struct lto_output_stream
);
1002 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (function
));
1003 char *section_name
=
1004 lto_get_section_name (LTO_section_function_body
, name
, NULL
);
1006 struct lto_in_decl_state
*in_state
;
1007 struct lto_out_decl_state
*out_state
= lto_get_out_decl_state ();
1009 lto_begin_section (section_name
, !flag_wpa
);
1010 free (section_name
);
1012 /* We may have renamed the declaration, e.g., a static function. */
1013 name
= lto_get_decl_name_mapping (file_data
, name
);
1015 data
= lto_get_section_data (file_data
, LTO_section_function_body
,
1019 /* Do a bit copy of the function body. */
1020 lto_output_data_stream (output_stream
, data
, len
);
1021 lto_write_stream (output_stream
);
1025 lto_get_function_in_decl_state (node
->local
.lto_file_data
, function
);
1026 gcc_assert (in_state
);
1028 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
1030 size_t n
= in_state
->streams
[i
].size
;
1031 tree
*trees
= in_state
->streams
[i
].trees
;
1032 struct lto_tree_ref_encoder
*encoder
= &(out_state
->streams
[i
]);
1034 /* The out state must have the same indices and the in state.
1035 So just copy the vector. All the encoders in the in state
1036 must be empty where we reach here. */
1037 gcc_assert (lto_tree_ref_encoder_size (encoder
) == 0);
1038 for (j
= 0; j
< n
; j
++)
1039 VEC_safe_push (tree
, heap
, encoder
->trees
, trees
[j
]);
1040 encoder
->next_index
= n
;
1043 lto_free_section_data (file_data
, LTO_section_function_body
, name
,
1045 free (output_stream
);
1050 /* Main entry point from the pass manager. */
1053 lto_output (cgraph_node_set set
, varpool_node_set vset
)
1055 struct cgraph_node
*node
;
1056 struct lto_out_decl_state
*decl_state
;
1057 #ifdef ENABLE_CHECKING
1058 bitmap output
= lto_bitmap_alloc ();
1061 lto_cgraph_encoder_t encoder
= lto_get_out_decl_state ()->cgraph_node_encoder
;
1063 /* Initialize the streamer. */
1064 lto_streamer_init ();
1066 n_nodes
= lto_cgraph_encoder_size (encoder
);
1067 /* Process only the functions with bodies. */
1068 for (i
= 0; i
< n_nodes
; i
++)
1070 node
= lto_cgraph_encoder_deref (encoder
, i
);
1071 if (lto_cgraph_encoder_encode_body_p (encoder
, node
)
1073 && !node
->thunk
.thunk_p
)
1075 #ifdef ENABLE_CHECKING
1076 gcc_assert (!bitmap_bit_p (output
, DECL_UID (node
->decl
)));
1077 bitmap_set_bit (output
, DECL_UID (node
->decl
));
1079 decl_state
= lto_new_out_decl_state ();
1080 lto_push_out_decl_state (decl_state
);
1081 if (gimple_has_body_p (node
->decl
))
1082 output_function (node
);
1084 copy_function (node
);
1085 gcc_assert (lto_get_out_decl_state () == decl_state
);
1086 lto_pop_out_decl_state ();
1087 lto_record_function_out_decl_state (node
->decl
, decl_state
);
1091 /* Emit the callgraph after emitting function bodies. This needs to
1092 be done now to make sure that all the statements in every function
1093 have been renumbered so that edges can be associated with call
1094 statements using the statement UIDs. */
1095 output_cgraph (set
, vset
);
1097 #ifdef ENABLE_CHECKING
1098 lto_bitmap_free (output
);
1102 struct ipa_opt_pass_d pass_ipa_lto_gimple_out
=
1106 "lto_gimple_out", /* name */
1107 gate_lto_out
, /* gate */
1111 0, /* static_pass_number */
1112 TV_IPA_LTO_GIMPLE_OUT
, /* tv_id */
1113 0, /* properties_required */
1114 0, /* properties_provided */
1115 0, /* properties_destroyed */
1116 0, /* todo_flags_start */
1117 0 /* todo_flags_finish */
1119 NULL
, /* generate_summary */
1120 lto_output
, /* write_summary */
1121 NULL
, /* read_summary */
1122 lto_output
, /* write_optimization_summary */
1123 NULL
, /* read_optimization_summary */
1124 NULL
, /* stmt_fixup */
1126 NULL
, /* function_transform */
1127 NULL
/* variable_transform */
1131 /* Write each node in encoded by ENCODER to OB, as well as those reachable
1132 from it and required for correct representation of its semantics.
1133 Each node in ENCODER must be a global declaration or a type. A node
1134 is written only once, even if it appears multiple times in the
1135 vector. Certain transitively-reachable nodes, such as those
1136 representing expressions, may be duplicated, but such nodes
1137 must not appear in ENCODER itself. */
1140 write_global_stream (struct output_block
*ob
,
1141 struct lto_tree_ref_encoder
*encoder
)
1145 const size_t size
= lto_tree_ref_encoder_size (encoder
);
1147 for (index
= 0; index
< size
; index
++)
1149 t
= lto_tree_ref_encoder_get_tree (encoder
, index
);
1150 if (!streamer_tree_cache_lookup (ob
->writer_cache
, t
, NULL
))
1151 stream_write_tree (ob
, t
, false);
1156 /* Write a sequence of indices into the globals vector corresponding
1157 to the trees in ENCODER. These are used by the reader to map the
1158 indices used to refer to global entities within function bodies to
1162 write_global_references (struct output_block
*ob
,
1163 struct lto_output_stream
*ref_stream
,
1164 struct lto_tree_ref_encoder
*encoder
)
1168 const uint32_t size
= lto_tree_ref_encoder_size (encoder
);
1170 /* Write size as 32-bit unsigned. */
1171 lto_output_data_stream (ref_stream
, &size
, sizeof (int32_t));
1173 for (index
= 0; index
< size
; index
++)
1177 t
= lto_tree_ref_encoder_get_tree (encoder
, index
);
1178 streamer_tree_cache_lookup (ob
->writer_cache
, t
, &slot_num
);
1179 gcc_assert (slot_num
!= (unsigned)-1);
1180 lto_output_data_stream (ref_stream
, &slot_num
, sizeof slot_num
);
1185 /* Write all the streams in an lto_out_decl_state STATE using
1186 output block OB and output stream OUT_STREAM. */
1189 lto_output_decl_state_streams (struct output_block
*ob
,
1190 struct lto_out_decl_state
*state
)
1194 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
1195 write_global_stream (ob
, &state
->streams
[i
]);
1199 /* Write all the references in an lto_out_decl_state STATE using
1200 output block OB and output stream OUT_STREAM. */
1203 lto_output_decl_state_refs (struct output_block
*ob
,
1204 struct lto_output_stream
*out_stream
,
1205 struct lto_out_decl_state
*state
)
1211 /* Write reference to FUNCTION_DECL. If there is not function,
1212 write reference to void_type_node. */
1213 decl
= (state
->fn_decl
) ? state
->fn_decl
: void_type_node
;
1214 streamer_tree_cache_lookup (ob
->writer_cache
, decl
, &ref
);
1215 gcc_assert (ref
!= (unsigned)-1);
1216 lto_output_data_stream (out_stream
, &ref
, sizeof (uint32_t));
1218 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
1219 write_global_references (ob
, out_stream
, &state
->streams
[i
]);
1223 /* Return the written size of STATE. */
1226 lto_out_decl_state_written_size (struct lto_out_decl_state
*state
)
1231 size
= sizeof (int32_t); /* fn_ref. */
1232 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
1234 size
+= sizeof (int32_t); /* vector size. */
1235 size
+= (lto_tree_ref_encoder_size (&state
->streams
[i
])
1236 * sizeof (int32_t));
1242 /* Write symbol T into STREAM in CACHE. SEEN specifies symbols we wrote
1246 write_symbol (struct streamer_tree_cache_d
*cache
,
1247 struct lto_output_stream
*stream
,
1248 tree t
, struct pointer_set_t
*seen
, bool alias
)
1251 enum gcc_plugin_symbol_kind kind
;
1252 enum gcc_plugin_symbol_visibility visibility
;
1258 /* None of the following kinds of symbols are needed in the
1260 if (!TREE_PUBLIC (t
)
1261 || is_builtin_fn (t
)
1262 || DECL_ABSTRACT (t
)
1263 || TREE_CODE (t
) == RESULT_DECL
)
1266 gcc_assert (TREE_CODE (t
) == VAR_DECL
1267 || TREE_CODE (t
) == FUNCTION_DECL
);
1269 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (t
));
1271 /* This behaves like assemble_name_raw in varasm.c, performing the
1272 same name manipulations that ASM_OUTPUT_LABELREF does. */
1273 name
= IDENTIFIER_POINTER ((*targetm
.asm_out
.mangle_assembler_name
) (name
));
1275 if (pointer_set_contains (seen
, name
))
1277 pointer_set_insert (seen
, name
);
1279 streamer_tree_cache_lookup (cache
, t
, &slot_num
);
1280 gcc_assert (slot_num
!= (unsigned)-1);
1282 if (DECL_EXTERNAL (t
))
1285 kind
= GCCPK_WEAKUNDEF
;
1292 kind
= GCCPK_WEAKDEF
;
1293 else if (DECL_COMMON (t
))
1294 kind
= GCCPK_COMMON
;
1298 /* When something is defined, it should have node attached. */
1299 gcc_assert (alias
|| TREE_CODE (t
) != VAR_DECL
1300 || varpool_get_node (t
)->finalized
);
1301 gcc_assert (alias
|| TREE_CODE (t
) != FUNCTION_DECL
1302 || (cgraph_get_node (t
)
1303 && cgraph_get_node (t
)->analyzed
));
1306 /* Imitate what default_elf_asm_output_external do.
1307 When symbol is external, we need to output it with DEFAULT visibility
1308 when compiling with -fvisibility=default, while with HIDDEN visibility
1309 when symbol has attribute (visibility("hidden")) specified.
1310 targetm.binds_local_p check DECL_VISIBILITY_SPECIFIED and gets this
1313 if (DECL_EXTERNAL (t
)
1314 && !targetm
.binds_local_p (t
))
1315 visibility
= GCCPV_DEFAULT
;
1317 switch (DECL_VISIBILITY(t
))
1319 case VISIBILITY_DEFAULT
:
1320 visibility
= GCCPV_DEFAULT
;
1322 case VISIBILITY_PROTECTED
:
1323 visibility
= GCCPV_PROTECTED
;
1325 case VISIBILITY_HIDDEN
:
1326 visibility
= GCCPV_HIDDEN
;
1328 case VISIBILITY_INTERNAL
:
1329 visibility
= GCCPV_INTERNAL
;
1333 if (kind
== GCCPK_COMMON
1335 && TREE_CODE (DECL_SIZE (t
)) == INTEGER_CST
)
1337 size
= (HOST_BITS_PER_WIDE_INT
>= 64)
1338 ? (uint64_t) int_size_in_bytes (TREE_TYPE (t
))
1339 : (((uint64_t) TREE_INT_CST_HIGH (DECL_SIZE_UNIT (t
))) << 32)
1340 | TREE_INT_CST_LOW (DECL_SIZE_UNIT (t
));
1345 if (DECL_ONE_ONLY (t
))
1346 comdat
= IDENTIFIER_POINTER (DECL_COMDAT_GROUP (t
));
1350 lto_output_data_stream (stream
, name
, strlen (name
) + 1);
1351 lto_output_data_stream (stream
, comdat
, strlen (comdat
) + 1);
1352 c
= (unsigned char) kind
;
1353 lto_output_data_stream (stream
, &c
, 1);
1354 c
= (unsigned char) visibility
;
1355 lto_output_data_stream (stream
, &c
, 1);
1356 lto_output_data_stream (stream
, &size
, 8);
1357 lto_output_data_stream (stream
, &slot_num
, 4);
1361 /* Write an IL symbol table to OB.
1362 SET and VSET are cgraph/varpool node sets we are outputting. */
1365 produce_symtab (struct output_block
*ob
,
1366 cgraph_node_set set
, varpool_node_set vset
)
1368 struct streamer_tree_cache_d
*cache
= ob
->writer_cache
;
1369 char *section_name
= lto_get_section_name (LTO_section_symtab
, NULL
, NULL
);
1370 struct pointer_set_t
*seen
;
1371 struct cgraph_node
*node
;
1372 struct varpool_node
*vnode
;
1373 struct lto_output_stream stream
;
1374 lto_varpool_encoder_t varpool_encoder
= ob
->decl_state
->varpool_node_encoder
;
1375 lto_cgraph_encoder_t encoder
= ob
->decl_state
->cgraph_node_encoder
;
1378 struct sets setdata
;
1379 symbol_alias_set_t
*defined
;
1382 setdata
.vset
= vset
;
1384 lto_begin_section (section_name
, false);
1385 free (section_name
);
1387 seen
= pointer_set_create ();
1388 memset (&stream
, 0, sizeof (stream
));
1390 /* Write all functions.
1391 First write all defined functions and then write all used functions.
1392 This is done so only to handle duplicated symbols in cgraph. */
1393 for (i
= 0; i
< lto_cgraph_encoder_size (encoder
); i
++)
1395 node
= lto_cgraph_encoder_deref (encoder
, i
);
1396 if (DECL_EXTERNAL (node
->decl
))
1398 if (DECL_COMDAT (node
->decl
)
1399 && cgraph_comdat_can_be_unshared_p (node
))
1401 if ((node
->alias
&& !node
->thunk
.alias
) || node
->global
.inlined_to
)
1403 write_symbol (cache
, &stream
, node
->decl
, seen
, false);
1405 for (i
= 0; i
< lto_cgraph_encoder_size (encoder
); i
++)
1407 node
= lto_cgraph_encoder_deref (encoder
, i
);
1408 if (!DECL_EXTERNAL (node
->decl
))
1410 /* We keep around unused extern inlines in order to be able to inline
1411 them indirectly or via vtables. Do not output them to symbol
1412 table: they end up being undefined and just consume space. */
1413 if (!node
->address_taken
&& !node
->callers
)
1415 gcc_assert (node
->analyzed
);
1416 gcc_assert (DECL_DECLARED_INLINE_P (node
->decl
));
1419 if (DECL_COMDAT (node
->decl
)
1420 && cgraph_comdat_can_be_unshared_p (node
))
1422 if ((node
->alias
&& !node
->thunk
.alias
) || node
->global
.inlined_to
)
1424 write_symbol (cache
, &stream
, node
->decl
, seen
, false);
1427 /* Write all variables. */
1428 for (i
= 0; i
< lto_varpool_encoder_size (varpool_encoder
); i
++)
1430 vnode
= lto_varpool_encoder_deref (varpool_encoder
, i
);
1431 if (DECL_EXTERNAL (vnode
->decl
))
1433 /* COMDAT virtual tables can be unshared. Do not declare them
1434 in the LTO symbol table to prevent linker from forcing them
1436 if (DECL_COMDAT (vnode
->decl
)
1437 && !vnode
->force_output
1439 && DECL_VIRTUAL_P (vnode
->decl
))
1441 if (vnode
->alias
&& !vnode
->alias_of
)
1443 write_symbol (cache
, &stream
, vnode
->decl
, seen
, false);
1445 for (i
= 0; i
< lto_varpool_encoder_size (varpool_encoder
); i
++)
1447 vnode
= lto_varpool_encoder_deref (varpool_encoder
, i
);
1448 if (!DECL_EXTERNAL (vnode
->decl
))
1450 if (DECL_COMDAT (vnode
->decl
)
1451 && !vnode
->force_output
1453 && DECL_VIRTUAL_P (vnode
->decl
))
1455 if (vnode
->alias
&& !vnode
->alias_of
)
1457 write_symbol (cache
, &stream
, vnode
->decl
, seen
, false);
1460 /* Write all aliases. */
1461 defined
= propagate_aliases_backward (trivally_defined_alias
, &setdata
);
1462 FOR_EACH_VEC_ELT (alias_pair
, alias_pairs
, i
, p
)
1463 if (output_alias_pair_p (p
, defined
, set
, vset
))
1464 write_symbol (cache
, &stream
, p
->decl
, seen
, true);
1465 symbol_alias_set_destroy (defined
);
1467 lto_write_stream (&stream
);
1468 pointer_set_destroy (seen
);
1474 /* This pass is run after all of the functions are serialized and all
1475 of the IPA passes have written their serialized forms. This pass
1476 causes the vector of all of the global decls and types used from
1477 this file to be written in to a section that can then be read in to
1478 recover these on other side. */
1481 produce_asm_for_decls (cgraph_node_set set
, varpool_node_set vset
)
1483 struct lto_out_decl_state
*out_state
;
1484 struct lto_out_decl_state
*fn_out_state
;
1485 struct lto_decl_header header
;
1487 struct output_block
*ob
;
1488 struct lto_output_stream
*header_stream
, *decl_state_stream
;
1489 unsigned idx
, num_fns
;
1490 size_t decl_state_size
;
1491 int32_t num_decl_states
;
1493 ob
= create_output_block (LTO_section_decls
);
1496 /* Write out unreferenced globals, alias pairs and labels. We defer
1497 doing this until now so that we can write out only what is
1499 output_unreferenced_globals (set
, vset
);
1501 memset (&header
, 0, sizeof (struct lto_decl_header
));
1503 section_name
= lto_get_section_name (LTO_section_decls
, NULL
, NULL
);
1504 lto_begin_section (section_name
, !flag_wpa
);
1505 free (section_name
);
1507 /* Make string 0 be a NULL string. */
1508 streamer_write_char_stream (ob
->string_stream
, 0);
1510 /* Write the global symbols. */
1511 out_state
= lto_get_out_decl_state ();
1512 num_fns
= VEC_length (lto_out_decl_state_ptr
, lto_function_decl_states
);
1513 lto_output_decl_state_streams (ob
, out_state
);
1514 for (idx
= 0; idx
< num_fns
; idx
++)
1517 VEC_index (lto_out_decl_state_ptr
, lto_function_decl_states
, idx
);
1518 lto_output_decl_state_streams (ob
, fn_out_state
);
1521 header
.lto_header
.major_version
= LTO_major_version
;
1522 header
.lto_header
.minor_version
= LTO_minor_version
;
1523 header
.lto_header
.section_type
= LTO_section_decls
;
1525 /* Currently not used. This field would allow us to preallocate
1526 the globals vector, so that it need not be resized as it is extended. */
1527 header
.num_nodes
= -1;
1529 /* Compute the total size of all decl out states. */
1530 decl_state_size
= sizeof (int32_t);
1531 decl_state_size
+= lto_out_decl_state_written_size (out_state
);
1532 for (idx
= 0; idx
< num_fns
; idx
++)
1535 VEC_index (lto_out_decl_state_ptr
, lto_function_decl_states
, idx
);
1536 decl_state_size
+= lto_out_decl_state_written_size (fn_out_state
);
1538 header
.decl_state_size
= decl_state_size
;
1540 header
.main_size
= ob
->main_stream
->total_size
;
1541 header
.string_size
= ob
->string_stream
->total_size
;
1543 header_stream
= XCNEW (struct lto_output_stream
);
1544 lto_output_data_stream (header_stream
, &header
, sizeof header
);
1545 lto_write_stream (header_stream
);
1546 free (header_stream
);
1548 /* Write the main out-decl state, followed by out-decl states of
1550 decl_state_stream
= ((struct lto_output_stream
*)
1551 xcalloc (1, sizeof (struct lto_output_stream
)));
1552 num_decl_states
= num_fns
+ 1;
1553 lto_output_data_stream (decl_state_stream
, &num_decl_states
,
1554 sizeof (num_decl_states
));
1555 lto_output_decl_state_refs (ob
, decl_state_stream
, out_state
);
1556 for (idx
= 0; idx
< num_fns
; idx
++)
1559 VEC_index (lto_out_decl_state_ptr
, lto_function_decl_states
, idx
);
1560 lto_output_decl_state_refs (ob
, decl_state_stream
, fn_out_state
);
1562 lto_write_stream (decl_state_stream
);
1563 free(decl_state_stream
);
1565 lto_write_stream (ob
->main_stream
);
1566 lto_write_stream (ob
->string_stream
);
1570 /* Write the symbol table. It is used by linker to determine dependencies
1571 and thus we can skip it for WPA. */
1573 produce_symtab (ob
, set
, vset
);
1575 /* Write command line opts. */
1576 lto_write_options ();
1578 /* Deallocate memory and clean up. */
1579 for (idx
= 0; idx
< num_fns
; idx
++)
1582 VEC_index (lto_out_decl_state_ptr
, lto_function_decl_states
, idx
);
1583 lto_delete_out_decl_state (fn_out_state
);
1585 lto_cgraph_encoder_delete (ob
->decl_state
->cgraph_node_encoder
);
1586 lto_varpool_encoder_delete (ob
->decl_state
->varpool_node_encoder
);
1587 VEC_free (lto_out_decl_state_ptr
, heap
, lto_function_decl_states
);
1588 lto_function_decl_states
= NULL
;
1589 destroy_output_block (ob
);
1593 struct ipa_opt_pass_d pass_ipa_lto_finish_out
=
1597 "lto_decls_out", /* name */
1598 gate_lto_out
, /* gate */
1602 0, /* static_pass_number */
1603 TV_IPA_LTO_DECL_OUT
, /* tv_id */
1604 0, /* properties_required */
1605 0, /* properties_provided */
1606 0, /* properties_destroyed */
1607 0, /* todo_flags_start */
1608 0 /* todo_flags_finish */
1610 NULL
, /* generate_summary */
1611 produce_asm_for_decls
, /* write_summary */
1612 NULL
, /* read_summary */
1613 produce_asm_for_decls
, /* write_optimization_summary */
1614 NULL
, /* read_optimization_summary */
1615 NULL
, /* stmt_fixup */
1617 NULL
, /* function_transform */
1618 NULL
/* variable_transform */