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
)
132 /* Variably modified types need to be streamed alongside function
133 bodies because they can refer to local entities. Together with
134 them we have to localize their members as well.
135 ??? In theory that includes non-FIELD_DECLs as well. */
137 && variably_modified_type_p (t
, NULL_TREE
))
139 else if (TREE_CODE (t
) == FIELD_DECL
140 && variably_modified_type_p (DECL_CONTEXT (t
), NULL_TREE
))
143 return (TYPE_P (t
) || DECL_P (t
) || TREE_CODE (t
) == SSA_NAME
);
147 /* Output info about new location into bitpack BP.
148 After outputting bitpack, lto_output_location_data has
149 to be done to output actual data. */
152 lto_output_location (struct output_block
*ob
, struct bitpack_d
*bp
,
155 expanded_location xloc
;
157 loc
= LOCATION_LOCUS (loc
);
158 bp_pack_value (bp
, loc
== UNKNOWN_LOCATION
, 1);
159 if (loc
== UNKNOWN_LOCATION
)
162 xloc
= expand_location (loc
);
164 bp_pack_value (bp
, ob
->current_file
!= xloc
.file
, 1);
165 if (ob
->current_file
!= xloc
.file
)
166 bp_pack_var_len_unsigned (bp
,
167 streamer_string_index (ob
, xloc
.file
,
168 strlen (xloc
.file
) + 1,
170 ob
->current_file
= xloc
.file
;
172 bp_pack_value (bp
, ob
->current_line
!= xloc
.line
, 1);
173 if (ob
->current_line
!= xloc
.line
)
174 bp_pack_var_len_unsigned (bp
, xloc
.line
);
175 ob
->current_line
= xloc
.line
;
177 bp_pack_value (bp
, ob
->current_col
!= xloc
.column
, 1);
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
))
333 lto_symtab_encoder_t encoder
;
334 struct varpool_node
*vnode
;
336 encoder
= ob
->decl_state
->symtab_node_encoder
;
337 vnode
= varpool_get_node (expr
);
339 || !lto_symtab_encoder_encode_initializer_p (encoder
,
341 initial
= error_mark_node
;
344 stream_write_tree (ob
, initial
, ref_p
);
347 /* Mark the end of EXPR. */
348 streamer_write_zero (ob
);
352 /* Emit the physical representation of tree node EXPR to output block
353 OB. If THIS_REF_P is true, the leaves of EXPR are emitted as references
354 via lto_output_tree_ref. REF_P is used for streaming siblings of EXPR. */
357 lto_output_tree (struct output_block
*ob
, tree expr
,
358 bool ref_p
, bool this_ref_p
)
363 if (expr
== NULL_TREE
)
365 streamer_write_record_start (ob
, LTO_null
);
369 if (this_ref_p
&& tree_is_indexable (expr
))
371 lto_output_tree_ref (ob
, expr
);
375 /* INTEGER_CST nodes are special because they need their original type
376 to be materialized by the reader (to implement TYPE_CACHED_VALUES). */
377 if (TREE_CODE (expr
) == INTEGER_CST
)
379 streamer_write_integer_cst (ob
, expr
, ref_p
);
383 existed_p
= streamer_tree_cache_insert (ob
->writer_cache
, expr
, &ix
);
386 /* If a node has already been streamed out, make sure that
387 we don't write it more than once. Otherwise, the reader
388 will instantiate two different nodes for the same object. */
389 streamer_write_record_start (ob
, LTO_tree_pickle_reference
);
390 streamer_write_uhwi (ob
, ix
);
391 streamer_write_enum (ob
->main_stream
, LTO_tags
, LTO_NUM_TAGS
,
392 lto_tree_code_to_tag (TREE_CODE (expr
)));
394 else if (streamer_handle_as_builtin_p (expr
))
396 /* MD and NORMAL builtins do not need to be written out
397 completely as they are always instantiated by the
398 compiler on startup. The only builtins that need to
399 be written out are BUILT_IN_FRONTEND. For all other
400 builtins, we simply write the class and code. */
401 streamer_write_builtin (ob
, expr
);
405 /* This is the first time we see EXPR, write its fields
407 lto_write_tree (ob
, expr
, ref_p
);
412 /* Output to OB a list of try/catch handlers starting with FIRST. */
415 output_eh_try_list (struct output_block
*ob
, eh_catch first
)
419 for (n
= first
; n
; n
= n
->next_catch
)
421 streamer_write_record_start (ob
, LTO_eh_catch
);
422 stream_write_tree (ob
, n
->type_list
, true);
423 stream_write_tree (ob
, n
->filter_list
, true);
424 stream_write_tree (ob
, n
->label
, true);
427 streamer_write_record_start (ob
, LTO_null
);
431 /* Output EH region R in function FN to OB. CURR_RN is the slot index
432 that is being emitted in FN->EH->REGION_ARRAY. This is used to
433 detect EH region sharing. */
436 output_eh_region (struct output_block
*ob
, eh_region r
)
442 streamer_write_record_start (ob
, LTO_null
);
446 if (r
->type
== ERT_CLEANUP
)
447 tag
= LTO_ert_cleanup
;
448 else if (r
->type
== ERT_TRY
)
450 else if (r
->type
== ERT_ALLOWED_EXCEPTIONS
)
451 tag
= LTO_ert_allowed_exceptions
;
452 else if (r
->type
== ERT_MUST_NOT_THROW
)
453 tag
= LTO_ert_must_not_throw
;
457 streamer_write_record_start (ob
, tag
);
458 streamer_write_hwi (ob
, r
->index
);
461 streamer_write_hwi (ob
, r
->outer
->index
);
463 streamer_write_zero (ob
);
466 streamer_write_hwi (ob
, r
->inner
->index
);
468 streamer_write_zero (ob
);
471 streamer_write_hwi (ob
, r
->next_peer
->index
);
473 streamer_write_zero (ob
);
475 if (r
->type
== ERT_TRY
)
477 output_eh_try_list (ob
, r
->u
.eh_try
.first_catch
);
479 else if (r
->type
== ERT_ALLOWED_EXCEPTIONS
)
481 stream_write_tree (ob
, r
->u
.allowed
.type_list
, true);
482 stream_write_tree (ob
, r
->u
.allowed
.label
, true);
483 streamer_write_uhwi (ob
, r
->u
.allowed
.filter
);
485 else if (r
->type
== ERT_MUST_NOT_THROW
)
487 stream_write_tree (ob
, r
->u
.must_not_throw
.failure_decl
, true);
488 bitpack_d bp
= bitpack_create (ob
->main_stream
);
489 stream_output_location (ob
, &bp
, r
->u
.must_not_throw
.failure_loc
);
490 streamer_write_bitpack (&bp
);
494 streamer_write_hwi (ob
, r
->landing_pads
->index
);
496 streamer_write_zero (ob
);
500 /* Output landing pad LP to OB. */
503 output_eh_lp (struct output_block
*ob
, eh_landing_pad lp
)
507 streamer_write_record_start (ob
, LTO_null
);
511 streamer_write_record_start (ob
, LTO_eh_landing_pad
);
512 streamer_write_hwi (ob
, lp
->index
);
514 streamer_write_hwi (ob
, lp
->next_lp
->index
);
516 streamer_write_zero (ob
);
519 streamer_write_hwi (ob
, lp
->region
->index
);
521 streamer_write_zero (ob
);
523 stream_write_tree (ob
, lp
->post_landing_pad
, true);
527 /* Output the existing eh_table to OB. */
530 output_eh_regions (struct output_block
*ob
, struct function
*fn
)
532 if (fn
->eh
&& fn
->eh
->region_tree
)
539 streamer_write_record_start (ob
, LTO_eh_table
);
541 /* Emit the index of the root of the EH region tree. */
542 streamer_write_hwi (ob
, fn
->eh
->region_tree
->index
);
544 /* Emit all the EH regions in the region array. */
545 streamer_write_hwi (ob
, VEC_length (eh_region
, fn
->eh
->region_array
));
546 FOR_EACH_VEC_ELT (eh_region
, fn
->eh
->region_array
, i
, eh
)
547 output_eh_region (ob
, eh
);
549 /* Emit all landing pads. */
550 streamer_write_hwi (ob
, VEC_length (eh_landing_pad
, fn
->eh
->lp_array
));
551 FOR_EACH_VEC_ELT (eh_landing_pad
, fn
->eh
->lp_array
, i
, lp
)
552 output_eh_lp (ob
, lp
);
554 /* Emit all the runtime type data. */
555 streamer_write_hwi (ob
, VEC_length (tree
, fn
->eh
->ttype_data
));
556 FOR_EACH_VEC_ELT (tree
, fn
->eh
->ttype_data
, i
, ttype
)
557 stream_write_tree (ob
, ttype
, true);
559 /* Emit the table of action chains. */
560 if (targetm
.arm_eabi_unwinder
)
563 streamer_write_hwi (ob
, VEC_length (tree
,
564 fn
->eh
->ehspec_data
.arm_eabi
));
565 FOR_EACH_VEC_ELT (tree
, fn
->eh
->ehspec_data
.arm_eabi
, i
, t
)
566 stream_write_tree (ob
, t
, true);
571 streamer_write_hwi (ob
, VEC_length (uchar
,
572 fn
->eh
->ehspec_data
.other
));
573 FOR_EACH_VEC_ELT (uchar
, 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_length (tree
, SSANAMES (fn
));
592 streamer_write_uhwi (ob
, len
);
594 for (i
= 1; i
< len
; i
++)
596 tree ptr
= VEC_index (tree
, 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_hwi (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_length (tree
, fn
->local_decls
));
733 FOR_EACH_VEC_ELT (tree
, fn
->local_decls
, i
, t
)
734 stream_write_tree (ob
, t
, true);
736 /* Output current IL state of the function. */
737 streamer_write_uhwi (ob
, fn
->curr_properties
);
739 /* Write all the attributes for FN. */
740 bp
= bitpack_create (ob
->main_stream
);
741 bp_pack_value (&bp
, fn
->is_thunk
, 1);
742 bp_pack_value (&bp
, fn
->has_local_explicit_reg_vars
, 1);
743 bp_pack_value (&bp
, fn
->returns_pcc_struct
, 1);
744 bp_pack_value (&bp
, fn
->returns_struct
, 1);
745 bp_pack_value (&bp
, fn
->can_throw_non_call_exceptions
, 1);
746 bp_pack_value (&bp
, fn
->can_delete_dead_exceptions
, 1);
747 bp_pack_value (&bp
, fn
->always_inline_functions_inlined
, 1);
748 bp_pack_value (&bp
, fn
->after_inlining
, 1);
749 bp_pack_value (&bp
, fn
->stdarg
, 1);
750 bp_pack_value (&bp
, fn
->has_nonlocal_label
, 1);
751 bp_pack_value (&bp
, fn
->calls_alloca
, 1);
752 bp_pack_value (&bp
, fn
->calls_setjmp
, 1);
753 bp_pack_value (&bp
, fn
->va_list_fpr_size
, 8);
754 bp_pack_value (&bp
, fn
->va_list_gpr_size
, 8);
756 /* Output the function start and end loci. */
757 stream_output_location (ob
, &bp
, fn
->function_start_locus
);
758 stream_output_location (ob
, &bp
, fn
->function_end_locus
);
760 streamer_write_bitpack (&bp
);
764 /* Output the body of function NODE->DECL. */
767 output_function (struct cgraph_node
*node
)
772 struct output_block
*ob
;
774 function
= node
->symbol
.decl
;
775 fn
= DECL_STRUCT_FUNCTION (function
);
776 ob
= create_output_block (LTO_section_function_body
);
778 clear_line_info (ob
);
779 ob
->cgraph_node
= node
;
781 gcc_assert (current_function_decl
== NULL_TREE
&& cfun
== NULL
);
783 /* Set current_function_decl and cfun. */
786 /* Make string 0 be a NULL string. */
787 streamer_write_char_stream (ob
->string_stream
, 0);
789 streamer_write_record_start (ob
, LTO_function
);
791 output_struct_function_base (ob
, fn
);
793 /* Output all the SSA names used in the function. */
794 output_ssa_names (ob
, fn
);
796 /* Output any exception handling regions. */
797 output_eh_regions (ob
, fn
);
799 /* Output DECL_INITIAL for the function, which contains the tree of
801 stream_write_tree (ob
, DECL_INITIAL (function
), true);
803 /* We will renumber the statements. The code that does this uses
804 the same ordering that we use for serializing them so we can use
805 the same code on the other end and not have to write out the
806 statement numbers. We do not assign UIDs to PHIs here because
807 virtual PHIs get re-computed on-the-fly which would make numbers
809 set_gimple_stmt_max_uid (cfun
, 0);
812 gimple_stmt_iterator gsi
;
813 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
815 gimple stmt
= gsi_stmt (gsi
);
816 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
820 /* Output the code for the function. */
821 FOR_ALL_BB_FN (bb
, fn
)
822 output_bb (ob
, bb
, fn
);
824 /* The terminator for this function. */
825 streamer_write_record_start (ob
, LTO_null
);
829 /* Create a section to hold the pickled output of this function. */
830 produce_asm (ob
, function
);
832 destroy_output_block (ob
);
838 /* Emit toplevel asms. */
841 lto_output_toplevel_asms (void)
843 struct output_block
*ob
;
844 struct asm_node
*can
;
846 struct lto_output_stream
*header_stream
;
847 struct lto_asm_header header
;
852 ob
= create_output_block (LTO_section_asm
);
854 /* Make string 0 be a NULL string. */
855 streamer_write_char_stream (ob
->string_stream
, 0);
857 for (can
= asm_nodes
; can
; can
= can
->next
)
859 streamer_write_string_cst (ob
, ob
->main_stream
, can
->asm_str
);
860 streamer_write_hwi (ob
, can
->order
);
863 streamer_write_string_cst (ob
, ob
->main_stream
, NULL_TREE
);
865 section_name
= lto_get_section_name (LTO_section_asm
, NULL
, NULL
);
866 lto_begin_section (section_name
, !flag_wpa
);
869 /* The entire header stream is computed here. */
870 memset (&header
, 0, sizeof (header
));
872 /* Write the header. */
873 header
.lto_header
.major_version
= LTO_major_version
;
874 header
.lto_header
.minor_version
= LTO_minor_version
;
876 header
.main_size
= ob
->main_stream
->total_size
;
877 header
.string_size
= ob
->string_stream
->total_size
;
879 header_stream
= XCNEW (struct lto_output_stream
);
880 lto_output_data_stream (header_stream
, &header
, sizeof (header
));
881 lto_write_stream (header_stream
);
882 free (header_stream
);
884 /* Put all of the gimple and the string table out the asm file as a
886 lto_write_stream (ob
->main_stream
);
887 lto_write_stream (ob
->string_stream
);
891 destroy_output_block (ob
);
895 /* Copy the function body of NODE without deserializing. */
898 copy_function (struct cgraph_node
*node
)
900 tree function
= node
->symbol
.decl
;
901 struct lto_file_decl_data
*file_data
= node
->symbol
.lto_file_data
;
902 struct lto_output_stream
*output_stream
= XCNEW (struct lto_output_stream
);
905 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (function
));
907 lto_get_section_name (LTO_section_function_body
, name
, NULL
);
909 struct lto_in_decl_state
*in_state
;
910 struct lto_out_decl_state
*out_state
= lto_get_out_decl_state ();
912 lto_begin_section (section_name
, !flag_wpa
);
915 /* We may have renamed the declaration, e.g., a static function. */
916 name
= lto_get_decl_name_mapping (file_data
, name
);
918 data
= lto_get_section_data (file_data
, LTO_section_function_body
,
922 /* Do a bit copy of the function body. */
923 lto_output_data_stream (output_stream
, data
, len
);
924 lto_write_stream (output_stream
);
928 lto_get_function_in_decl_state (node
->symbol
.lto_file_data
, function
);
929 gcc_assert (in_state
);
931 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
933 size_t n
= in_state
->streams
[i
].size
;
934 tree
*trees
= in_state
->streams
[i
].trees
;
935 struct lto_tree_ref_encoder
*encoder
= &(out_state
->streams
[i
]);
937 /* The out state must have the same indices and the in state.
938 So just copy the vector. All the encoders in the in state
939 must be empty where we reach here. */
940 gcc_assert (lto_tree_ref_encoder_size (encoder
) == 0);
941 for (j
= 0; j
< n
; j
++)
942 VEC_safe_push (tree
, heap
, encoder
->trees
, trees
[j
]);
943 encoder
->next_index
= n
;
946 lto_free_section_data (file_data
, LTO_section_function_body
, name
,
948 free (output_stream
);
953 /* Main entry point from the pass manager. */
958 struct cgraph_node
*node
;
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 if (!symtab_function_p (snode
))
976 node
= cgraph (snode
);
977 if (lto_symtab_encoder_encode_body_p (encoder
, node
)
979 && !node
->thunk
.thunk_p
)
981 #ifdef ENABLE_CHECKING
982 gcc_assert (!bitmap_bit_p (output
, DECL_UID (node
->symbol
.decl
)));
983 bitmap_set_bit (output
, DECL_UID (node
->symbol
.decl
));
985 decl_state
= lto_new_out_decl_state ();
986 lto_push_out_decl_state (decl_state
);
987 if (gimple_has_body_p (node
->symbol
.decl
))
988 output_function (node
);
990 copy_function (node
);
991 gcc_assert (lto_get_out_decl_state () == decl_state
);
992 lto_pop_out_decl_state ();
993 lto_record_function_out_decl_state (node
->symbol
.decl
, decl_state
);
997 /* Emit the callgraph after emitting function bodies. This needs to
998 be done now to make sure that all the statements in every function
999 have been renumbered so that edges can be associated with call
1000 statements using the statement UIDs. */
1003 #ifdef ENABLE_CHECKING
1004 lto_bitmap_free (output
);
1008 struct ipa_opt_pass_d pass_ipa_lto_gimple_out
=
1012 "lto_gimple_out", /* name */
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
)
1172 gcc_assert (TREE_CODE (t
) == VAR_DECL
1173 || TREE_CODE (t
) == FUNCTION_DECL
);
1175 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (t
));
1177 /* This behaves like assemble_name_raw in varasm.c, performing the
1178 same name manipulations that ASM_OUTPUT_LABELREF does. */
1179 name
= IDENTIFIER_POINTER ((*targetm
.asm_out
.mangle_assembler_name
) (name
));
1181 if (pointer_set_contains (seen
, name
))
1183 pointer_set_insert (seen
, name
);
1185 streamer_tree_cache_lookup (cache
, t
, &slot_num
);
1186 gcc_assert (slot_num
!= (unsigned)-1);
1188 if (DECL_EXTERNAL (t
))
1191 kind
= GCCPK_WEAKUNDEF
;
1198 kind
= GCCPK_WEAKDEF
;
1199 else if (DECL_COMMON (t
))
1200 kind
= GCCPK_COMMON
;
1204 /* When something is defined, it should have node attached. */
1205 gcc_assert (alias
|| TREE_CODE (t
) != VAR_DECL
1206 || varpool_get_node (t
)->finalized
);
1207 gcc_assert (alias
|| TREE_CODE (t
) != FUNCTION_DECL
1208 || (cgraph_get_node (t
)
1209 && cgraph_get_node (t
)->analyzed
));
1212 /* Imitate what default_elf_asm_output_external do.
1213 When symbol is external, we need to output it with DEFAULT visibility
1214 when compiling with -fvisibility=default, while with HIDDEN visibility
1215 when symbol has attribute (visibility("hidden")) specified.
1216 targetm.binds_local_p check DECL_VISIBILITY_SPECIFIED and gets this
1219 if (DECL_EXTERNAL (t
)
1220 && !targetm
.binds_local_p (t
))
1221 visibility
= GCCPV_DEFAULT
;
1223 switch (DECL_VISIBILITY(t
))
1225 case VISIBILITY_DEFAULT
:
1226 visibility
= GCCPV_DEFAULT
;
1228 case VISIBILITY_PROTECTED
:
1229 visibility
= GCCPV_PROTECTED
;
1231 case VISIBILITY_HIDDEN
:
1232 visibility
= GCCPV_HIDDEN
;
1234 case VISIBILITY_INTERNAL
:
1235 visibility
= GCCPV_INTERNAL
;
1239 if (kind
== GCCPK_COMMON
1240 && DECL_SIZE_UNIT (t
)
1241 && TREE_CODE (DECL_SIZE_UNIT (t
)) == INTEGER_CST
)
1242 size
= TREE_INT_CST_LOW (DECL_SIZE_UNIT (t
));
1246 if (DECL_ONE_ONLY (t
))
1247 comdat
= IDENTIFIER_POINTER (DECL_COMDAT_GROUP (t
));
1251 lto_output_data_stream (stream
, name
, strlen (name
) + 1);
1252 lto_output_data_stream (stream
, comdat
, strlen (comdat
) + 1);
1253 c
= (unsigned char) kind
;
1254 lto_output_data_stream (stream
, &c
, 1);
1255 c
= (unsigned char) visibility
;
1256 lto_output_data_stream (stream
, &c
, 1);
1257 lto_output_data_stream (stream
, &size
, 8);
1258 lto_output_data_stream (stream
, &slot_num
, 4);
1262 /* Write an IL symbol table to OB.
1263 SET and VSET are cgraph/varpool node sets we are outputting. */
1266 produce_symtab (struct output_block
*ob
)
1268 struct streamer_tree_cache_d
*cache
= ob
->writer_cache
;
1269 char *section_name
= lto_get_section_name (LTO_section_symtab
, NULL
, NULL
);
1270 struct pointer_set_t
*seen
;
1271 struct lto_output_stream stream
;
1272 lto_symtab_encoder_t encoder
= ob
->decl_state
->symtab_node_encoder
;
1273 lto_symtab_encoder_iterator lsei
;
1275 lto_begin_section (section_name
, false);
1276 free (section_name
);
1278 seen
= pointer_set_create ();
1279 memset (&stream
, 0, sizeof (stream
));
1281 /* Write the symbol table.
1282 First write everything defined and then all declarations.
1283 This is neccesary to handle cases where we have duplicated symbols. */
1284 for (lsei
= lsei_start (encoder
);
1285 !lsei_end_p (lsei
); lsei_next (&lsei
))
1287 symtab_node node
= lsei_node (lsei
);
1289 if (!symtab_real_symbol_p (node
) || DECL_EXTERNAL (node
->symbol
.decl
))
1291 write_symbol (cache
, &stream
, node
->symbol
.decl
, seen
, false);
1293 for (lsei
= lsei_start (encoder
);
1294 !lsei_end_p (lsei
); lsei_next (&lsei
))
1296 symtab_node node
= lsei_node (lsei
);
1298 if (!symtab_real_symbol_p (node
) || !DECL_EXTERNAL (node
->symbol
.decl
))
1300 write_symbol (cache
, &stream
, node
->symbol
.decl
, seen
, false);
1303 lto_write_stream (&stream
);
1304 pointer_set_destroy (seen
);
1310 /* This pass is run after all of the functions are serialized and all
1311 of the IPA passes have written their serialized forms. This pass
1312 causes the vector of all of the global decls and types used from
1313 this file to be written in to a section that can then be read in to
1314 recover these on other side. */
1317 produce_asm_for_decls (void)
1319 struct lto_out_decl_state
*out_state
;
1320 struct lto_out_decl_state
*fn_out_state
;
1321 struct lto_decl_header header
;
1323 struct output_block
*ob
;
1324 struct lto_output_stream
*header_stream
, *decl_state_stream
;
1325 unsigned idx
, num_fns
;
1326 size_t decl_state_size
;
1327 int32_t num_decl_states
;
1329 ob
= create_output_block (LTO_section_decls
);
1332 memset (&header
, 0, sizeof (struct lto_decl_header
));
1334 section_name
= lto_get_section_name (LTO_section_decls
, NULL
, NULL
);
1335 lto_begin_section (section_name
, !flag_wpa
);
1336 free (section_name
);
1338 /* Make string 0 be a NULL string. */
1339 streamer_write_char_stream (ob
->string_stream
, 0);
1341 gcc_assert (!alias_pairs
);
1343 /* Write the global symbols. */
1344 out_state
= lto_get_out_decl_state ();
1345 num_fns
= VEC_length (lto_out_decl_state_ptr
, lto_function_decl_states
);
1346 lto_output_decl_state_streams (ob
, out_state
);
1347 for (idx
= 0; idx
< num_fns
; idx
++)
1350 VEC_index (lto_out_decl_state_ptr
, lto_function_decl_states
, idx
);
1351 lto_output_decl_state_streams (ob
, fn_out_state
);
1354 header
.lto_header
.major_version
= LTO_major_version
;
1355 header
.lto_header
.minor_version
= LTO_minor_version
;
1357 /* Currently not used. This field would allow us to preallocate
1358 the globals vector, so that it need not be resized as it is extended. */
1359 header
.num_nodes
= -1;
1361 /* Compute the total size of all decl out states. */
1362 decl_state_size
= sizeof (int32_t);
1363 decl_state_size
+= lto_out_decl_state_written_size (out_state
);
1364 for (idx
= 0; idx
< num_fns
; idx
++)
1367 VEC_index (lto_out_decl_state_ptr
, lto_function_decl_states
, idx
);
1368 decl_state_size
+= lto_out_decl_state_written_size (fn_out_state
);
1370 header
.decl_state_size
= decl_state_size
;
1372 header
.main_size
= ob
->main_stream
->total_size
;
1373 header
.string_size
= ob
->string_stream
->total_size
;
1375 header_stream
= XCNEW (struct lto_output_stream
);
1376 lto_output_data_stream (header_stream
, &header
, sizeof header
);
1377 lto_write_stream (header_stream
);
1378 free (header_stream
);
1380 /* Write the main out-decl state, followed by out-decl states of
1382 decl_state_stream
= XCNEW (struct lto_output_stream
);
1383 num_decl_states
= num_fns
+ 1;
1384 lto_output_data_stream (decl_state_stream
, &num_decl_states
,
1385 sizeof (num_decl_states
));
1386 lto_output_decl_state_refs (ob
, decl_state_stream
, out_state
);
1387 for (idx
= 0; idx
< num_fns
; idx
++)
1390 VEC_index (lto_out_decl_state_ptr
, lto_function_decl_states
, idx
);
1391 lto_output_decl_state_refs (ob
, decl_state_stream
, fn_out_state
);
1393 lto_write_stream (decl_state_stream
);
1394 free(decl_state_stream
);
1396 lto_write_stream (ob
->main_stream
);
1397 lto_write_stream (ob
->string_stream
);
1401 /* Write the symbol table. It is used by linker to determine dependencies
1402 and thus we can skip it for WPA. */
1404 produce_symtab (ob
);
1406 /* Write command line opts. */
1407 lto_write_options ();
1409 /* Deallocate memory and clean up. */
1410 for (idx
= 0; idx
< num_fns
; idx
++)
1413 VEC_index (lto_out_decl_state_ptr
, lto_function_decl_states
, idx
);
1414 lto_delete_out_decl_state (fn_out_state
);
1416 lto_symtab_encoder_delete (ob
->decl_state
->symtab_node_encoder
);
1417 VEC_free (lto_out_decl_state_ptr
, heap
, lto_function_decl_states
);
1418 lto_function_decl_states
= NULL
;
1419 destroy_output_block (ob
);
1423 struct ipa_opt_pass_d pass_ipa_lto_finish_out
=
1427 "lto_decls_out", /* name */
1428 gate_lto_out
, /* gate */
1432 0, /* static_pass_number */
1433 TV_IPA_LTO_DECL_OUT
, /* tv_id */
1434 0, /* properties_required */
1435 0, /* properties_provided */
1436 0, /* properties_destroyed */
1437 0, /* todo_flags_start */
1438 0 /* todo_flags_finish */
1440 NULL
, /* generate_summary */
1441 produce_asm_for_decls
, /* write_summary */
1442 NULL
, /* read_summary */
1443 produce_asm_for_decls
, /* write_optimization_summary */
1444 NULL
, /* read_optimization_summary */
1445 NULL
, /* stmt_fixup */
1447 NULL
, /* function_transform */
1448 NULL
/* variable_transform */