1 /* Write the GIMPLE representation to a file stream.
3 Copyright (C) 2009-2013 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
.create (37);
81 gcc_obstack_init (&ob
->obstack
);
87 /* Destroy the output block OB. */
90 destroy_output_block (struct output_block
*ob
)
92 enum lto_section_type section_type
= ob
->section_type
;
94 ob
->string_hash_table
.dispose ();
96 free (ob
->main_stream
);
97 free (ob
->string_stream
);
98 if (section_type
== LTO_section_function_body
)
99 free (ob
->cfg_stream
);
101 streamer_tree_cache_delete (ob
->writer_cache
);
102 obstack_free (&ob
->obstack
, NULL
);
108 /* Look up NODE in the type table and write the index for it to OB. */
111 output_type_ref (struct output_block
*ob
, tree node
)
113 streamer_write_record_start (ob
, LTO_type_ref
);
114 lto_output_type_ref_index (ob
->decl_state
, ob
->main_stream
, node
);
118 /* Return true if tree node T is written to various tables. For these
119 nodes, we sometimes want to write their phyiscal representation
120 (via lto_output_tree), and sometimes we need to emit an index
121 reference into a table (via lto_output_tree_ref). */
124 tree_is_indexable (tree t
)
126 if (TREE_CODE (t
) == PARM_DECL
)
128 else if (TREE_CODE (t
) == VAR_DECL
&& decl_function_context (t
)
131 /* Variably modified types need to be streamed alongside function
132 bodies because they can refer to local entities. Together with
133 them we have to localize their members as well.
134 ??? In theory that includes non-FIELD_DECLs as well. */
136 && variably_modified_type_p (t
, NULL_TREE
))
138 else if (TREE_CODE (t
) == FIELD_DECL
139 && variably_modified_type_p (DECL_CONTEXT (t
), NULL_TREE
))
142 return (TYPE_P (t
) || DECL_P (t
) || TREE_CODE (t
) == SSA_NAME
);
146 /* Output info about new location into bitpack BP.
147 After outputting bitpack, lto_output_location_data has
148 to be done to output actual data. */
151 lto_output_location (struct output_block
*ob
, struct bitpack_d
*bp
,
154 expanded_location xloc
;
156 loc
= LOCATION_LOCUS (loc
);
157 bp_pack_value (bp
, loc
== UNKNOWN_LOCATION
, 1);
158 if (loc
== UNKNOWN_LOCATION
)
161 xloc
= expand_location (loc
);
163 bp_pack_value (bp
, ob
->current_file
!= xloc
.file
, 1);
164 bp_pack_value (bp
, ob
->current_line
!= xloc
.line
, 1);
165 bp_pack_value (bp
, ob
->current_col
!= xloc
.column
, 1);
167 if (ob
->current_file
!= xloc
.file
)
168 bp_pack_var_len_unsigned (bp
,
169 streamer_string_index (ob
, xloc
.file
,
170 strlen (xloc
.file
) + 1,
172 ob
->current_file
= xloc
.file
;
174 if (ob
->current_line
!= xloc
.line
)
175 bp_pack_var_len_unsigned (bp
, xloc
.line
);
176 ob
->current_line
= xloc
.line
;
178 if (ob
->current_col
!= xloc
.column
)
179 bp_pack_var_len_unsigned (bp
, xloc
.column
);
180 ob
->current_col
= xloc
.column
;
184 /* If EXPR is an indexable tree node, output a reference to it to
185 output block OB. Otherwise, output the physical representation of
189 lto_output_tree_ref (struct output_block
*ob
, tree expr
)
195 output_type_ref (ob
, expr
);
199 code
= TREE_CODE (expr
);
203 streamer_write_record_start (ob
, LTO_ssa_name_ref
);
204 streamer_write_uhwi (ob
, SSA_NAME_VERSION (expr
));
208 streamer_write_record_start (ob
, LTO_field_decl_ref
);
209 lto_output_field_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
213 streamer_write_record_start (ob
, LTO_function_decl_ref
);
214 lto_output_fn_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
218 case DEBUG_EXPR_DECL
:
219 gcc_assert (decl_function_context (expr
) == NULL
|| TREE_STATIC (expr
));
221 streamer_write_record_start (ob
, LTO_global_decl_ref
);
222 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
226 streamer_write_record_start (ob
, LTO_const_decl_ref
);
227 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
231 gcc_assert (decl_function_context (expr
) == NULL
);
232 streamer_write_record_start (ob
, LTO_imported_decl_ref
);
233 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
237 streamer_write_record_start (ob
, LTO_type_decl_ref
);
238 lto_output_type_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
242 streamer_write_record_start (ob
, LTO_namespace_decl_ref
);
243 lto_output_namespace_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
247 streamer_write_record_start (ob
, LTO_label_decl_ref
);
248 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
252 streamer_write_record_start (ob
, LTO_result_decl_ref
);
253 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
256 case TRANSLATION_UNIT_DECL
:
257 streamer_write_record_start (ob
, LTO_translation_unit_decl_ref
);
258 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
262 /* No other node is indexable, so it should have been handled by
269 /* Return true if EXPR is a tree node that can be written to disk. */
272 lto_is_streamable (tree expr
)
274 enum tree_code code
= TREE_CODE (expr
);
276 /* Notice that we reject SSA_NAMEs as well. We only emit the SSA
277 name version in lto_output_tree_ref (see output_ssa_names). */
278 return !is_lang_specific (expr
)
282 && code
!= MODIFY_EXPR
284 && code
!= TARGET_EXPR
286 && code
!= WITH_CLEANUP_EXPR
287 && code
!= STATEMENT_LIST
288 && code
!= OMP_CLAUSE
289 && (code
== CASE_LABEL_EXPR
291 || TREE_CODE_CLASS (code
) != tcc_statement
);
295 /* Write a physical representation of tree node EXPR to output block
296 OB. If REF_P is true, the leaves of EXPR are emitted as references
297 via lto_output_tree_ref. IX is the index into the streamer cache
298 where EXPR is stored. */
301 lto_write_tree (struct output_block
*ob
, tree expr
, bool ref_p
)
305 if (!lto_is_streamable (expr
))
306 internal_error ("tree code %qs is not supported in LTO streams",
307 tree_code_name
[TREE_CODE (expr
)]);
309 /* Write the header, containing everything needed to materialize
310 EXPR on the reading side. */
311 streamer_write_tree_header (ob
, expr
);
313 /* Pack all the non-pointer fields in EXPR into a bitpack and write
314 the resulting bitpack. */
315 bp
= bitpack_create (ob
->main_stream
);
316 streamer_pack_tree_bitfields (ob
, &bp
, expr
);
317 streamer_write_bitpack (&bp
);
319 /* Write all the pointer fields in EXPR. */
320 streamer_write_tree_body (ob
, expr
, ref_p
);
322 /* Write any LTO-specific data to OB. */
324 && TREE_CODE (expr
) != FUNCTION_DECL
325 && TREE_CODE (expr
) != TRANSLATION_UNIT_DECL
)
327 /* Handle DECL_INITIAL for symbols. */
328 tree initial
= DECL_INITIAL (expr
);
329 if (TREE_CODE (expr
) == VAR_DECL
330 && (TREE_STATIC (expr
) || DECL_EXTERNAL (expr
))
331 && !DECL_IN_CONSTANT_POOL (expr
)
334 lto_symtab_encoder_t encoder
;
335 struct varpool_node
*vnode
;
337 encoder
= ob
->decl_state
->symtab_node_encoder
;
338 vnode
= varpool_get_node (expr
);
340 || !lto_symtab_encoder_encode_initializer_p (encoder
,
342 initial
= error_mark_node
;
345 stream_write_tree (ob
, initial
, ref_p
);
348 /* Mark the end of EXPR. */
349 streamer_write_zero (ob
);
353 /* Emit the physical representation of tree node EXPR to output block
354 OB. If THIS_REF_P is true, the leaves of EXPR are emitted as references
355 via lto_output_tree_ref. REF_P is used for streaming siblings of EXPR. */
358 lto_output_tree (struct output_block
*ob
, tree expr
,
359 bool ref_p
, bool this_ref_p
)
364 if (expr
== NULL_TREE
)
366 streamer_write_record_start (ob
, LTO_null
);
370 if (this_ref_p
&& tree_is_indexable (expr
))
372 lto_output_tree_ref (ob
, expr
);
376 /* Shared INTEGER_CST nodes are special because they need their original type
377 to be materialized by the reader (to implement TYPE_CACHED_VALUES). */
378 if (TREE_CODE (expr
) == INTEGER_CST
379 && !TREE_OVERFLOW (expr
))
381 streamer_write_integer_cst (ob
, expr
, ref_p
);
385 existed_p
= streamer_tree_cache_insert (ob
->writer_cache
, expr
, &ix
);
388 /* If a node has already been streamed out, make sure that
389 we don't write it more than once. Otherwise, the reader
390 will instantiate two different nodes for the same object. */
391 streamer_write_record_start (ob
, LTO_tree_pickle_reference
);
392 streamer_write_uhwi (ob
, ix
);
393 streamer_write_enum (ob
->main_stream
, LTO_tags
, LTO_NUM_TAGS
,
394 lto_tree_code_to_tag (TREE_CODE (expr
)));
396 else if (streamer_handle_as_builtin_p (expr
))
398 /* MD and NORMAL builtins do not need to be written out
399 completely as they are always instantiated by the
400 compiler on startup. The only builtins that need to
401 be written out are BUILT_IN_FRONTEND. For all other
402 builtins, we simply write the class and code. */
403 streamer_write_builtin (ob
, expr
);
407 /* This is the first time we see EXPR, write its fields
409 lto_write_tree (ob
, expr
, ref_p
);
414 /* Output to OB a list of try/catch handlers starting with FIRST. */
417 output_eh_try_list (struct output_block
*ob
, eh_catch first
)
421 for (n
= first
; n
; n
= n
->next_catch
)
423 streamer_write_record_start (ob
, LTO_eh_catch
);
424 stream_write_tree (ob
, n
->type_list
, true);
425 stream_write_tree (ob
, n
->filter_list
, true);
426 stream_write_tree (ob
, n
->label
, true);
429 streamer_write_record_start (ob
, LTO_null
);
433 /* Output EH region R in function FN to OB. CURR_RN is the slot index
434 that is being emitted in FN->EH->REGION_ARRAY. This is used to
435 detect EH region sharing. */
438 output_eh_region (struct output_block
*ob
, eh_region r
)
444 streamer_write_record_start (ob
, LTO_null
);
448 if (r
->type
== ERT_CLEANUP
)
449 tag
= LTO_ert_cleanup
;
450 else if (r
->type
== ERT_TRY
)
452 else if (r
->type
== ERT_ALLOWED_EXCEPTIONS
)
453 tag
= LTO_ert_allowed_exceptions
;
454 else if (r
->type
== ERT_MUST_NOT_THROW
)
455 tag
= LTO_ert_must_not_throw
;
459 streamer_write_record_start (ob
, tag
);
460 streamer_write_hwi (ob
, r
->index
);
463 streamer_write_hwi (ob
, r
->outer
->index
);
465 streamer_write_zero (ob
);
468 streamer_write_hwi (ob
, r
->inner
->index
);
470 streamer_write_zero (ob
);
473 streamer_write_hwi (ob
, r
->next_peer
->index
);
475 streamer_write_zero (ob
);
477 if (r
->type
== ERT_TRY
)
479 output_eh_try_list (ob
, r
->u
.eh_try
.first_catch
);
481 else if (r
->type
== ERT_ALLOWED_EXCEPTIONS
)
483 stream_write_tree (ob
, r
->u
.allowed
.type_list
, true);
484 stream_write_tree (ob
, r
->u
.allowed
.label
, true);
485 streamer_write_uhwi (ob
, r
->u
.allowed
.filter
);
487 else if (r
->type
== ERT_MUST_NOT_THROW
)
489 stream_write_tree (ob
, r
->u
.must_not_throw
.failure_decl
, true);
490 bitpack_d bp
= bitpack_create (ob
->main_stream
);
491 stream_output_location (ob
, &bp
, r
->u
.must_not_throw
.failure_loc
);
492 streamer_write_bitpack (&bp
);
496 streamer_write_hwi (ob
, r
->landing_pads
->index
);
498 streamer_write_zero (ob
);
502 /* Output landing pad LP to OB. */
505 output_eh_lp (struct output_block
*ob
, eh_landing_pad lp
)
509 streamer_write_record_start (ob
, LTO_null
);
513 streamer_write_record_start (ob
, LTO_eh_landing_pad
);
514 streamer_write_hwi (ob
, lp
->index
);
516 streamer_write_hwi (ob
, lp
->next_lp
->index
);
518 streamer_write_zero (ob
);
521 streamer_write_hwi (ob
, lp
->region
->index
);
523 streamer_write_zero (ob
);
525 stream_write_tree (ob
, lp
->post_landing_pad
, true);
529 /* Output the existing eh_table to OB. */
532 output_eh_regions (struct output_block
*ob
, struct function
*fn
)
534 if (fn
->eh
&& fn
->eh
->region_tree
)
541 streamer_write_record_start (ob
, LTO_eh_table
);
543 /* Emit the index of the root of the EH region tree. */
544 streamer_write_hwi (ob
, fn
->eh
->region_tree
->index
);
546 /* Emit all the EH regions in the region array. */
547 streamer_write_hwi (ob
, vec_safe_length (fn
->eh
->region_array
));
548 FOR_EACH_VEC_SAFE_ELT (fn
->eh
->region_array
, i
, eh
)
549 output_eh_region (ob
, eh
);
551 /* Emit all landing pads. */
552 streamer_write_hwi (ob
, vec_safe_length (fn
->eh
->lp_array
));
553 FOR_EACH_VEC_SAFE_ELT (fn
->eh
->lp_array
, i
, lp
)
554 output_eh_lp (ob
, lp
);
556 /* Emit all the runtime type data. */
557 streamer_write_hwi (ob
, vec_safe_length (fn
->eh
->ttype_data
));
558 FOR_EACH_VEC_SAFE_ELT (fn
->eh
->ttype_data
, i
, ttype
)
559 stream_write_tree (ob
, ttype
, true);
561 /* Emit the table of action chains. */
562 if (targetm
.arm_eabi_unwinder
)
565 streamer_write_hwi (ob
, vec_safe_length (fn
->eh
->ehspec_data
.arm_eabi
));
566 FOR_EACH_VEC_SAFE_ELT (fn
->eh
->ehspec_data
.arm_eabi
, i
, t
)
567 stream_write_tree (ob
, t
, true);
572 streamer_write_hwi (ob
, vec_safe_length (fn
->eh
->ehspec_data
.other
));
573 FOR_EACH_VEC_SAFE_ELT (fn
->eh
->ehspec_data
.other
, i
, c
)
574 streamer_write_char_stream (ob
->main_stream
, c
);
578 /* The LTO_null either terminates the record or indicates that there
579 are no eh_records at all. */
580 streamer_write_record_start (ob
, LTO_null
);
584 /* Output all of the active ssa names to the ssa_names stream. */
587 output_ssa_names (struct output_block
*ob
, struct function
*fn
)
591 len
= vec_safe_length (SSANAMES (fn
));
592 streamer_write_uhwi (ob
, len
);
594 for (i
= 1; i
< len
; i
++)
596 tree ptr
= (*SSANAMES (fn
))[i
];
599 || SSA_NAME_IN_FREE_LIST (ptr
)
600 || virtual_operand_p (ptr
))
603 streamer_write_uhwi (ob
, i
);
604 streamer_write_char_stream (ob
->main_stream
,
605 SSA_NAME_IS_DEFAULT_DEF (ptr
));
606 if (SSA_NAME_VAR (ptr
))
607 stream_write_tree (ob
, SSA_NAME_VAR (ptr
), true);
609 /* ??? This drops SSA_NAME_IDENTIFIER on the floor. */
610 stream_write_tree (ob
, TREE_TYPE (ptr
), true);
613 streamer_write_zero (ob
);
617 /* Output the cfg. */
620 output_cfg (struct output_block
*ob
, struct function
*fn
)
622 struct lto_output_stream
*tmp_stream
= ob
->main_stream
;
625 ob
->main_stream
= ob
->cfg_stream
;
627 streamer_write_enum (ob
->main_stream
, profile_status_d
, PROFILE_LAST
,
628 profile_status_for_function (fn
));
630 /* Output the number of the highest basic block. */
631 streamer_write_uhwi (ob
, last_basic_block_for_function (fn
));
633 FOR_ALL_BB_FN (bb
, fn
)
638 streamer_write_hwi (ob
, bb
->index
);
640 /* Output the successors and the edge flags. */
641 streamer_write_uhwi (ob
, EDGE_COUNT (bb
->succs
));
642 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
644 streamer_write_uhwi (ob
, e
->dest
->index
);
645 streamer_write_hwi (ob
, e
->probability
);
646 streamer_write_gcov_count (ob
, e
->count
);
647 streamer_write_uhwi (ob
, e
->flags
);
651 streamer_write_hwi (ob
, -1);
653 bb
= ENTRY_BLOCK_PTR
;
656 streamer_write_hwi (ob
, bb
->next_bb
->index
);
660 streamer_write_hwi (ob
, -1);
662 ob
->main_stream
= tmp_stream
;
666 /* Create the header in the file using OB. If the section type is for
667 a function, set FN to the decl for that function. */
670 produce_asm (struct output_block
*ob
, tree fn
)
672 enum lto_section_type section_type
= ob
->section_type
;
673 struct lto_function_header header
;
675 struct lto_output_stream
*header_stream
;
677 if (section_type
== LTO_section_function_body
)
679 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fn
));
680 section_name
= lto_get_section_name (section_type
, name
, NULL
);
683 section_name
= lto_get_section_name (section_type
, NULL
, NULL
);
685 lto_begin_section (section_name
, !flag_wpa
);
688 /* The entire header is stream computed here. */
689 memset (&header
, 0, sizeof (struct lto_function_header
));
691 /* Write the header. */
692 header
.lto_header
.major_version
= LTO_major_version
;
693 header
.lto_header
.minor_version
= LTO_minor_version
;
695 header
.compressed_size
= 0;
697 if (section_type
== LTO_section_function_body
)
698 header
.cfg_size
= ob
->cfg_stream
->total_size
;
699 header
.main_size
= ob
->main_stream
->total_size
;
700 header
.string_size
= ob
->string_stream
->total_size
;
702 header_stream
= XCNEW (struct lto_output_stream
);
703 lto_output_data_stream (header_stream
, &header
, sizeof header
);
704 lto_write_stream (header_stream
);
705 free (header_stream
);
707 /* Put all of the gimple and the string table out the asm file as a
709 if (section_type
== LTO_section_function_body
)
710 lto_write_stream (ob
->cfg_stream
);
711 lto_write_stream (ob
->main_stream
);
712 lto_write_stream (ob
->string_stream
);
718 /* Output the base body of struct function FN using output block OB. */
721 output_struct_function_base (struct output_block
*ob
, struct function
*fn
)
727 /* Output the static chain and non-local goto save area. */
728 stream_write_tree (ob
, fn
->static_chain_decl
, true);
729 stream_write_tree (ob
, fn
->nonlocal_goto_save_area
, true);
731 /* Output all the local variables in the function. */
732 streamer_write_hwi (ob
, vec_safe_length (fn
->local_decls
));
733 FOR_EACH_VEC_SAFE_ELT (fn
->local_decls
, i
, t
)
734 stream_write_tree (ob
, t
, true);
736 /* Output current IL state of the function.
737 ??? We don't stream loops. */
738 streamer_write_uhwi (ob
, fn
->curr_properties
& ~PROP_loops
);
740 /* Write all the attributes for FN. */
741 bp
= bitpack_create (ob
->main_stream
);
742 bp_pack_value (&bp
, fn
->is_thunk
, 1);
743 bp_pack_value (&bp
, fn
->has_local_explicit_reg_vars
, 1);
744 bp_pack_value (&bp
, fn
->returns_pcc_struct
, 1);
745 bp_pack_value (&bp
, fn
->returns_struct
, 1);
746 bp_pack_value (&bp
, fn
->can_throw_non_call_exceptions
, 1);
747 bp_pack_value (&bp
, fn
->can_delete_dead_exceptions
, 1);
748 bp_pack_value (&bp
, fn
->always_inline_functions_inlined
, 1);
749 bp_pack_value (&bp
, fn
->after_inlining
, 1);
750 bp_pack_value (&bp
, fn
->stdarg
, 1);
751 bp_pack_value (&bp
, fn
->has_nonlocal_label
, 1);
752 bp_pack_value (&bp
, fn
->calls_alloca
, 1);
753 bp_pack_value (&bp
, fn
->calls_setjmp
, 1);
754 bp_pack_value (&bp
, fn
->va_list_fpr_size
, 8);
755 bp_pack_value (&bp
, fn
->va_list_gpr_size
, 8);
757 /* Output the function start and end loci. */
758 stream_output_location (ob
, &bp
, fn
->function_start_locus
);
759 stream_output_location (ob
, &bp
, fn
->function_end_locus
);
761 streamer_write_bitpack (&bp
);
765 /* Output the body of function NODE->DECL. */
768 output_function (struct cgraph_node
*node
)
773 struct output_block
*ob
;
775 function
= node
->symbol
.decl
;
776 fn
= DECL_STRUCT_FUNCTION (function
);
777 ob
= create_output_block (LTO_section_function_body
);
779 clear_line_info (ob
);
780 ob
->cgraph_node
= node
;
782 gcc_assert (current_function_decl
== NULL_TREE
&& cfun
== NULL
);
784 /* Set current_function_decl and cfun. */
787 /* Make string 0 be a NULL string. */
788 streamer_write_char_stream (ob
->string_stream
, 0);
790 streamer_write_record_start (ob
, LTO_function
);
792 output_struct_function_base (ob
, fn
);
794 /* Output all the SSA names used in the function. */
795 output_ssa_names (ob
, fn
);
797 /* Output any exception handling regions. */
798 output_eh_regions (ob
, fn
);
800 /* Output DECL_INITIAL for the function, which contains the tree of
802 stream_write_tree (ob
, DECL_INITIAL (function
), true);
804 /* We will renumber the statements. The code that does this uses
805 the same ordering that we use for serializing them so we can use
806 the same code on the other end and not have to write out the
807 statement numbers. We do not assign UIDs to PHIs here because
808 virtual PHIs get re-computed on-the-fly which would make numbers
810 set_gimple_stmt_max_uid (cfun
, 0);
813 gimple_stmt_iterator gsi
;
814 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
816 gimple stmt
= gsi_stmt (gsi
);
817 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
821 /* Output the code for the function. */
822 FOR_ALL_BB_FN (bb
, fn
)
823 output_bb (ob
, bb
, fn
);
825 /* The terminator for this function. */
826 streamer_write_record_start (ob
, LTO_null
);
830 /* Create a section to hold the pickled output of this function. */
831 produce_asm (ob
, function
);
833 destroy_output_block (ob
);
839 /* Emit toplevel asms. */
842 lto_output_toplevel_asms (void)
844 struct output_block
*ob
;
845 struct asm_node
*can
;
847 struct lto_output_stream
*header_stream
;
848 struct lto_asm_header header
;
853 ob
= create_output_block (LTO_section_asm
);
855 /* Make string 0 be a NULL string. */
856 streamer_write_char_stream (ob
->string_stream
, 0);
858 for (can
= asm_nodes
; can
; can
= can
->next
)
860 streamer_write_string_cst (ob
, ob
->main_stream
, can
->asm_str
);
861 streamer_write_hwi (ob
, can
->order
);
864 streamer_write_string_cst (ob
, ob
->main_stream
, NULL_TREE
);
866 section_name
= lto_get_section_name (LTO_section_asm
, NULL
, NULL
);
867 lto_begin_section (section_name
, !flag_wpa
);
870 /* The entire header stream is computed here. */
871 memset (&header
, 0, sizeof (header
));
873 /* Write the header. */
874 header
.lto_header
.major_version
= LTO_major_version
;
875 header
.lto_header
.minor_version
= LTO_minor_version
;
877 header
.main_size
= ob
->main_stream
->total_size
;
878 header
.string_size
= ob
->string_stream
->total_size
;
880 header_stream
= XCNEW (struct lto_output_stream
);
881 lto_output_data_stream (header_stream
, &header
, sizeof (header
));
882 lto_write_stream (header_stream
);
883 free (header_stream
);
885 /* Put all of the gimple and the string table out the asm file as a
887 lto_write_stream (ob
->main_stream
);
888 lto_write_stream (ob
->string_stream
);
892 destroy_output_block (ob
);
896 /* Copy the function body of NODE without deserializing. */
899 copy_function (struct cgraph_node
*node
)
901 tree function
= node
->symbol
.decl
;
902 struct lto_file_decl_data
*file_data
= node
->symbol
.lto_file_data
;
903 struct lto_output_stream
*output_stream
= XCNEW (struct lto_output_stream
);
906 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (function
));
908 lto_get_section_name (LTO_section_function_body
, name
, NULL
);
910 struct lto_in_decl_state
*in_state
;
911 struct lto_out_decl_state
*out_state
= lto_get_out_decl_state ();
913 lto_begin_section (section_name
, !flag_wpa
);
916 /* We may have renamed the declaration, e.g., a static function. */
917 name
= lto_get_decl_name_mapping (file_data
, name
);
919 data
= lto_get_section_data (file_data
, LTO_section_function_body
,
923 /* Do a bit copy of the function body. */
924 lto_output_data_stream (output_stream
, data
, len
);
925 lto_write_stream (output_stream
);
929 lto_get_function_in_decl_state (node
->symbol
.lto_file_data
, function
);
930 gcc_assert (in_state
);
932 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
934 size_t n
= in_state
->streams
[i
].size
;
935 tree
*trees
= in_state
->streams
[i
].trees
;
936 struct lto_tree_ref_encoder
*encoder
= &(out_state
->streams
[i
]);
938 /* The out state must have the same indices and the in state.
939 So just copy the vector. All the encoders in the in state
940 must be empty where we reach here. */
941 gcc_assert (lto_tree_ref_encoder_size (encoder
) == 0);
942 for (j
= 0; j
< n
; j
++)
943 encoder
->trees
.safe_push (trees
[j
]);
944 encoder
->next_index
= n
;
947 lto_free_section_data (file_data
, LTO_section_function_body
, name
,
949 free (output_stream
);
954 /* Main entry point from the pass manager. */
959 struct lto_out_decl_state
*decl_state
;
960 #ifdef ENABLE_CHECKING
961 bitmap output
= lto_bitmap_alloc ();
964 lto_symtab_encoder_t encoder
= lto_get_out_decl_state ()->symtab_node_encoder
;
966 /* Initialize the streamer. */
967 lto_streamer_init ();
969 n_nodes
= lto_symtab_encoder_size (encoder
);
970 /* Process only the functions with bodies. */
971 for (i
= 0; i
< n_nodes
; i
++)
973 symtab_node snode
= lto_symtab_encoder_deref (encoder
, i
);
974 cgraph_node
*node
= dyn_cast
<cgraph_node
> (snode
);
976 && lto_symtab_encoder_encode_body_p (encoder
, node
)
978 && !node
->thunk
.thunk_p
)
980 #ifdef ENABLE_CHECKING
981 gcc_assert (!bitmap_bit_p (output
, DECL_UID (node
->symbol
.decl
)));
982 bitmap_set_bit (output
, DECL_UID (node
->symbol
.decl
));
984 decl_state
= lto_new_out_decl_state ();
985 lto_push_out_decl_state (decl_state
);
986 if (gimple_has_body_p (node
->symbol
.decl
))
987 output_function (node
);
989 copy_function (node
);
990 gcc_assert (lto_get_out_decl_state () == decl_state
);
991 lto_pop_out_decl_state ();
992 lto_record_function_out_decl_state (node
->symbol
.decl
, decl_state
);
996 /* Emit the callgraph after emitting function bodies. This needs to
997 be done now to make sure that all the statements in every function
998 have been renumbered so that edges can be associated with call
999 statements using the statement UIDs. */
1002 #ifdef ENABLE_CHECKING
1003 lto_bitmap_free (output
);
1007 struct ipa_opt_pass_d pass_ipa_lto_gimple_out
=
1011 "lto_gimple_out", /* name */
1012 OPTGROUP_NONE
, /* optinfo_flags */
1013 gate_lto_out
, /* gate */
1017 0, /* static_pass_number */
1018 TV_IPA_LTO_GIMPLE_OUT
, /* tv_id */
1019 0, /* properties_required */
1020 0, /* properties_provided */
1021 0, /* properties_destroyed */
1022 0, /* todo_flags_start */
1023 0 /* todo_flags_finish */
1025 NULL
, /* generate_summary */
1026 lto_output
, /* write_summary */
1027 NULL
, /* read_summary */
1028 lto_output
, /* write_optimization_summary */
1029 NULL
, /* read_optimization_summary */
1030 NULL
, /* stmt_fixup */
1032 NULL
, /* function_transform */
1033 NULL
/* variable_transform */
1037 /* Write each node in encoded by ENCODER to OB, as well as those reachable
1038 from it and required for correct representation of its semantics.
1039 Each node in ENCODER must be a global declaration or a type. A node
1040 is written only once, even if it appears multiple times in the
1041 vector. Certain transitively-reachable nodes, such as those
1042 representing expressions, may be duplicated, but such nodes
1043 must not appear in ENCODER itself. */
1046 write_global_stream (struct output_block
*ob
,
1047 struct lto_tree_ref_encoder
*encoder
)
1051 const size_t size
= lto_tree_ref_encoder_size (encoder
);
1053 for (index
= 0; index
< size
; index
++)
1055 t
= lto_tree_ref_encoder_get_tree (encoder
, index
);
1056 if (!streamer_tree_cache_lookup (ob
->writer_cache
, t
, NULL
))
1057 stream_write_tree (ob
, t
, false);
1062 /* Write a sequence of indices into the globals vector corresponding
1063 to the trees in ENCODER. These are used by the reader to map the
1064 indices used to refer to global entities within function bodies to
1068 write_global_references (struct output_block
*ob
,
1069 struct lto_output_stream
*ref_stream
,
1070 struct lto_tree_ref_encoder
*encoder
)
1074 const uint32_t size
= lto_tree_ref_encoder_size (encoder
);
1076 /* Write size as 32-bit unsigned. */
1077 lto_output_data_stream (ref_stream
, &size
, sizeof (int32_t));
1079 for (index
= 0; index
< size
; index
++)
1083 t
= lto_tree_ref_encoder_get_tree (encoder
, index
);
1084 streamer_tree_cache_lookup (ob
->writer_cache
, t
, &slot_num
);
1085 gcc_assert (slot_num
!= (unsigned)-1);
1086 lto_output_data_stream (ref_stream
, &slot_num
, sizeof slot_num
);
1091 /* Write all the streams in an lto_out_decl_state STATE using
1092 output block OB and output stream OUT_STREAM. */
1095 lto_output_decl_state_streams (struct output_block
*ob
,
1096 struct lto_out_decl_state
*state
)
1100 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
1101 write_global_stream (ob
, &state
->streams
[i
]);
1105 /* Write all the references in an lto_out_decl_state STATE using
1106 output block OB and output stream OUT_STREAM. */
1109 lto_output_decl_state_refs (struct output_block
*ob
,
1110 struct lto_output_stream
*out_stream
,
1111 struct lto_out_decl_state
*state
)
1117 /* Write reference to FUNCTION_DECL. If there is not function,
1118 write reference to void_type_node. */
1119 decl
= (state
->fn_decl
) ? state
->fn_decl
: void_type_node
;
1120 streamer_tree_cache_lookup (ob
->writer_cache
, decl
, &ref
);
1121 gcc_assert (ref
!= (unsigned)-1);
1122 lto_output_data_stream (out_stream
, &ref
, sizeof (uint32_t));
1124 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
1125 write_global_references (ob
, out_stream
, &state
->streams
[i
]);
1129 /* Return the written size of STATE. */
1132 lto_out_decl_state_written_size (struct lto_out_decl_state
*state
)
1137 size
= sizeof (int32_t); /* fn_ref. */
1138 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
1140 size
+= sizeof (int32_t); /* vector size. */
1141 size
+= (lto_tree_ref_encoder_size (&state
->streams
[i
])
1142 * sizeof (int32_t));
1148 /* Write symbol T into STREAM in CACHE. SEEN specifies symbols we wrote
1152 write_symbol (struct streamer_tree_cache_d
*cache
,
1153 struct lto_output_stream
*stream
,
1154 tree t
, struct pointer_set_t
*seen
, bool alias
)
1157 enum gcc_plugin_symbol_kind kind
;
1158 enum gcc_plugin_symbol_visibility visibility
;
1160 unsigned HOST_WIDEST_INT size
;
1164 /* None of the following kinds of symbols are needed in the
1166 if (!TREE_PUBLIC (t
)
1167 || is_builtin_fn (t
)
1168 || DECL_ABSTRACT (t
)
1169 || TREE_CODE (t
) == RESULT_DECL
1170 || (TREE_CODE (t
) == VAR_DECL
&& DECL_HARD_REGISTER (t
)))
1173 gcc_assert (TREE_CODE (t
) == VAR_DECL
1174 || TREE_CODE (t
) == FUNCTION_DECL
);
1176 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (t
));
1178 /* This behaves like assemble_name_raw in varasm.c, performing the
1179 same name manipulations that ASM_OUTPUT_LABELREF does. */
1180 name
= IDENTIFIER_POINTER ((*targetm
.asm_out
.mangle_assembler_name
) (name
));
1182 if (pointer_set_contains (seen
, name
))
1184 pointer_set_insert (seen
, name
);
1186 streamer_tree_cache_lookup (cache
, t
, &slot_num
);
1187 gcc_assert (slot_num
!= (unsigned)-1);
1189 if (DECL_EXTERNAL (t
))
1192 kind
= GCCPK_WEAKUNDEF
;
1199 kind
= GCCPK_WEAKDEF
;
1200 else if (DECL_COMMON (t
))
1201 kind
= GCCPK_COMMON
;
1205 /* When something is defined, it should have node attached. */
1206 gcc_assert (alias
|| TREE_CODE (t
) != VAR_DECL
1207 || varpool_get_node (t
)->finalized
);
1208 gcc_assert (alias
|| TREE_CODE (t
) != FUNCTION_DECL
1209 || (cgraph_get_node (t
)
1210 && cgraph_get_node (t
)->analyzed
));
1213 /* Imitate what default_elf_asm_output_external do.
1214 When symbol is external, we need to output it with DEFAULT visibility
1215 when compiling with -fvisibility=default, while with HIDDEN visibility
1216 when symbol has attribute (visibility("hidden")) specified.
1217 targetm.binds_local_p check DECL_VISIBILITY_SPECIFIED and gets this
1220 if (DECL_EXTERNAL (t
)
1221 && !targetm
.binds_local_p (t
))
1222 visibility
= GCCPV_DEFAULT
;
1224 switch (DECL_VISIBILITY(t
))
1226 case VISIBILITY_DEFAULT
:
1227 visibility
= GCCPV_DEFAULT
;
1229 case VISIBILITY_PROTECTED
:
1230 visibility
= GCCPV_PROTECTED
;
1232 case VISIBILITY_HIDDEN
:
1233 visibility
= GCCPV_HIDDEN
;
1235 case VISIBILITY_INTERNAL
:
1236 visibility
= GCCPV_INTERNAL
;
1240 if (kind
== GCCPK_COMMON
1241 && DECL_SIZE_UNIT (t
)
1242 && TREE_CODE (DECL_SIZE_UNIT (t
)) == INTEGER_CST
)
1243 size
= TREE_INT_CST_LOW (DECL_SIZE_UNIT (t
));
1247 if (DECL_ONE_ONLY (t
))
1248 comdat
= IDENTIFIER_POINTER (DECL_COMDAT_GROUP (t
));
1252 lto_output_data_stream (stream
, name
, strlen (name
) + 1);
1253 lto_output_data_stream (stream
, comdat
, strlen (comdat
) + 1);
1254 c
= (unsigned char) kind
;
1255 lto_output_data_stream (stream
, &c
, 1);
1256 c
= (unsigned char) visibility
;
1257 lto_output_data_stream (stream
, &c
, 1);
1258 lto_output_data_stream (stream
, &size
, 8);
1259 lto_output_data_stream (stream
, &slot_num
, 4);
1262 /* Return true if NODE should appear in the plugin symbol table. */
1265 output_symbol_p (symtab_node node
)
1267 struct cgraph_node
*cnode
;
1268 if (!symtab_real_symbol_p (node
))
1270 /* We keep external functions in symtab for sake of inlining
1271 and devirtualization. We do not want to see them in symbol table as
1272 references unless they are really used. */
1273 cnode
= dyn_cast
<cgraph_node
> (node
);
1274 if (cnode
&& DECL_EXTERNAL (cnode
->symbol
.decl
)
1278 /* Ignore all references from external vars initializers - they are not really
1279 part of the compilation unit until they are used by folding. Some symbols,
1280 like references to external construction vtables can not be referred to at all.
1281 We decide this at can_refer_decl_in_current_unit_p. */
1282 if (DECL_EXTERNAL (node
->symbol
.decl
))
1285 struct ipa_ref
*ref
;
1286 for (i
= 0; ipa_ref_list_referring_iterate (&node
->symbol
.ref_list
,
1289 if (ref
->use
== IPA_REF_ALIAS
)
1291 if (is_a
<cgraph_node
> (ref
->referring
))
1293 if (!DECL_EXTERNAL (ref
->referring
->symbol
.decl
))
1302 /* Write an IL symbol table to OB.
1303 SET and VSET are cgraph/varpool node sets we are outputting. */
1306 produce_symtab (struct output_block
*ob
)
1308 struct streamer_tree_cache_d
*cache
= ob
->writer_cache
;
1309 char *section_name
= lto_get_section_name (LTO_section_symtab
, NULL
, NULL
);
1310 struct pointer_set_t
*seen
;
1311 struct lto_output_stream stream
;
1312 lto_symtab_encoder_t encoder
= ob
->decl_state
->symtab_node_encoder
;
1313 lto_symtab_encoder_iterator lsei
;
1315 lto_begin_section (section_name
, false);
1316 free (section_name
);
1318 seen
= pointer_set_create ();
1319 memset (&stream
, 0, sizeof (stream
));
1321 /* Write the symbol table.
1322 First write everything defined and then all declarations.
1323 This is neccesary to handle cases where we have duplicated symbols. */
1324 for (lsei
= lsei_start (encoder
);
1325 !lsei_end_p (lsei
); lsei_next (&lsei
))
1327 symtab_node node
= lsei_node (lsei
);
1329 if (!output_symbol_p (node
) || DECL_EXTERNAL (node
->symbol
.decl
))
1331 write_symbol (cache
, &stream
, node
->symbol
.decl
, seen
, false);
1333 for (lsei
= lsei_start (encoder
);
1334 !lsei_end_p (lsei
); lsei_next (&lsei
))
1336 symtab_node node
= lsei_node (lsei
);
1338 if (!output_symbol_p (node
) || !DECL_EXTERNAL (node
->symbol
.decl
))
1340 write_symbol (cache
, &stream
, node
->symbol
.decl
, seen
, false);
1343 lto_write_stream (&stream
);
1344 pointer_set_destroy (seen
);
1350 /* This pass is run after all of the functions are serialized and all
1351 of the IPA passes have written their serialized forms. This pass
1352 causes the vector of all of the global decls and types used from
1353 this file to be written in to a section that can then be read in to
1354 recover these on other side. */
1357 produce_asm_for_decls (void)
1359 struct lto_out_decl_state
*out_state
;
1360 struct lto_out_decl_state
*fn_out_state
;
1361 struct lto_decl_header header
;
1363 struct output_block
*ob
;
1364 struct lto_output_stream
*header_stream
, *decl_state_stream
;
1365 unsigned idx
, num_fns
;
1366 size_t decl_state_size
;
1367 int32_t num_decl_states
;
1369 ob
= create_output_block (LTO_section_decls
);
1372 memset (&header
, 0, sizeof (struct lto_decl_header
));
1374 section_name
= lto_get_section_name (LTO_section_decls
, NULL
, NULL
);
1375 lto_begin_section (section_name
, !flag_wpa
);
1376 free (section_name
);
1378 /* Make string 0 be a NULL string. */
1379 streamer_write_char_stream (ob
->string_stream
, 0);
1381 gcc_assert (!alias_pairs
);
1383 /* Write the global symbols. */
1384 out_state
= lto_get_out_decl_state ();
1385 num_fns
= lto_function_decl_states
.length ();
1386 lto_output_decl_state_streams (ob
, out_state
);
1387 for (idx
= 0; idx
< num_fns
; idx
++)
1390 lto_function_decl_states
[idx
];
1391 lto_output_decl_state_streams (ob
, fn_out_state
);
1394 header
.lto_header
.major_version
= LTO_major_version
;
1395 header
.lto_header
.minor_version
= LTO_minor_version
;
1397 /* Currently not used. This field would allow us to preallocate
1398 the globals vector, so that it need not be resized as it is extended. */
1399 header
.num_nodes
= -1;
1401 /* Compute the total size of all decl out states. */
1402 decl_state_size
= sizeof (int32_t);
1403 decl_state_size
+= lto_out_decl_state_written_size (out_state
);
1404 for (idx
= 0; idx
< num_fns
; idx
++)
1407 lto_function_decl_states
[idx
];
1408 decl_state_size
+= lto_out_decl_state_written_size (fn_out_state
);
1410 header
.decl_state_size
= decl_state_size
;
1412 header
.main_size
= ob
->main_stream
->total_size
;
1413 header
.string_size
= ob
->string_stream
->total_size
;
1415 header_stream
= XCNEW (struct lto_output_stream
);
1416 lto_output_data_stream (header_stream
, &header
, sizeof header
);
1417 lto_write_stream (header_stream
);
1418 free (header_stream
);
1420 /* Write the main out-decl state, followed by out-decl states of
1422 decl_state_stream
= XCNEW (struct lto_output_stream
);
1423 num_decl_states
= num_fns
+ 1;
1424 lto_output_data_stream (decl_state_stream
, &num_decl_states
,
1425 sizeof (num_decl_states
));
1426 lto_output_decl_state_refs (ob
, decl_state_stream
, out_state
);
1427 for (idx
= 0; idx
< num_fns
; idx
++)
1430 lto_function_decl_states
[idx
];
1431 lto_output_decl_state_refs (ob
, decl_state_stream
, fn_out_state
);
1433 lto_write_stream (decl_state_stream
);
1434 free(decl_state_stream
);
1436 lto_write_stream (ob
->main_stream
);
1437 lto_write_stream (ob
->string_stream
);
1441 /* Write the symbol table. It is used by linker to determine dependencies
1442 and thus we can skip it for WPA. */
1444 produce_symtab (ob
);
1446 /* Write command line opts. */
1447 lto_write_options ();
1449 /* Deallocate memory and clean up. */
1450 for (idx
= 0; idx
< num_fns
; idx
++)
1453 lto_function_decl_states
[idx
];
1454 lto_delete_out_decl_state (fn_out_state
);
1456 lto_symtab_encoder_delete (ob
->decl_state
->symtab_node_encoder
);
1457 lto_function_decl_states
.release ();
1458 destroy_output_block (ob
);
1462 struct ipa_opt_pass_d pass_ipa_lto_finish_out
=
1466 "lto_decls_out", /* name */
1467 OPTGROUP_NONE
, /* optinfo_flags */
1468 gate_lto_out
, /* gate */
1472 0, /* static_pass_number */
1473 TV_IPA_LTO_DECL_OUT
, /* tv_id */
1474 0, /* properties_required */
1475 0, /* properties_provided */
1476 0, /* properties_destroyed */
1477 0, /* todo_flags_start */
1478 0 /* todo_flags_finish */
1480 NULL
, /* generate_summary */
1481 produce_asm_for_decls
, /* write_summary */
1482 NULL
, /* read_summary */
1483 produce_asm_for_decls
, /* write_optimization_summary */
1484 NULL
, /* read_optimization_summary */
1485 NULL
, /* stmt_fixup */
1487 NULL
, /* function_transform */
1488 NULL
/* variable_transform */