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"
50 unsigned int slot_num
;
54 /* Returns a hash code for P. */
57 hash_string_slot_node (const void *p
)
59 const struct string_slot
*ds
= (const struct string_slot
*) p
;
60 return (hashval_t
) htab_hash_string (ds
->s
);
64 /* Returns nonzero if P1 and P2 are equal. */
67 eq_string_slot_node (const void *p1
, const void *p2
)
69 const struct string_slot
*ds1
= (const struct string_slot
*) p1
;
70 const struct string_slot
*ds2
= (const struct string_slot
*) p2
;
72 if (ds1
->len
== ds2
->len
)
73 return memcmp (ds1
->s
, ds2
->s
, ds1
->len
) == 0;
79 /* Free the string slot pointed-to by P. */
82 string_slot_free (void *p
)
84 struct string_slot
*slot
= (struct string_slot
*) p
;
85 free (CONST_CAST (void *, (const void *) slot
->s
));
90 /* Clear the line info stored in DATA_IN. */
93 clear_line_info (struct output_block
*ob
)
95 ob
->current_file
= NULL
;
101 /* Create the output block and return it. SECTION_TYPE is
102 LTO_section_function_body or LTO_static_initializer. */
104 struct output_block
*
105 create_output_block (enum lto_section_type section_type
)
107 struct output_block
*ob
= XCNEW (struct output_block
);
109 ob
->section_type
= section_type
;
110 ob
->decl_state
= lto_get_out_decl_state ();
111 ob
->main_stream
= XCNEW (struct lto_output_stream
);
112 ob
->string_stream
= XCNEW (struct lto_output_stream
);
113 ob
->writer_cache
= lto_streamer_cache_create ();
115 if (section_type
== LTO_section_function_body
)
116 ob
->cfg_stream
= XCNEW (struct lto_output_stream
);
118 clear_line_info (ob
);
120 ob
->string_hash_table
= htab_create (37, hash_string_slot_node
,
121 eq_string_slot_node
, string_slot_free
);
127 /* Destroy the output block OB. */
130 destroy_output_block (struct output_block
*ob
)
132 enum lto_section_type section_type
= ob
->section_type
;
134 htab_delete (ob
->string_hash_table
);
136 free (ob
->main_stream
);
137 free (ob
->string_stream
);
138 if (section_type
== LTO_section_function_body
)
139 free (ob
->cfg_stream
);
141 lto_streamer_cache_delete (ob
->writer_cache
);
147 /* Output STRING of LEN characters to the string
148 table in OB. The string might or might not include a trailing '\0'.
149 Then put the index onto the INDEX_STREAM. */
152 lto_output_string_with_length (struct output_block
*ob
,
153 struct lto_output_stream
*index_stream
,
157 struct string_slot
**slot
;
158 struct string_slot s_slot
;
159 char *string
= (char *) xmalloc (len
+ 1);
160 memcpy (string
, s
, len
);
167 /* Indicate that this is not a NULL string. */
168 lto_output_uleb128_stream (index_stream
, 0);
170 slot
= (struct string_slot
**) htab_find_slot (ob
->string_hash_table
,
174 struct lto_output_stream
*string_stream
= ob
->string_stream
;
175 unsigned int start
= string_stream
->total_size
;
176 struct string_slot
*new_slot
177 = (struct string_slot
*) xmalloc (sizeof (struct string_slot
));
179 new_slot
->s
= string
;
181 new_slot
->slot_num
= start
;
183 lto_output_uleb128_stream (index_stream
, start
);
184 lto_output_uleb128_stream (string_stream
, len
);
185 lto_output_data_stream (string_stream
, string
, len
);
189 struct string_slot
*old_slot
= *slot
;
190 lto_output_uleb128_stream (index_stream
, old_slot
->slot_num
);
195 /* Output the '\0' terminated STRING to the string
196 table in OB. Then put the index onto the INDEX_STREAM. */
199 lto_output_string (struct output_block
*ob
,
200 struct lto_output_stream
*index_stream
,
204 lto_output_string_with_length (ob
, index_stream
, string
,
205 strlen (string
) + 1);
207 lto_output_uleb128_stream (index_stream
, 1);
211 /* Output the STRING constant to the string
212 table in OB. Then put the index onto the INDEX_STREAM. */
215 output_string_cst (struct output_block
*ob
,
216 struct lto_output_stream
*index_stream
,
220 lto_output_string_with_length (ob
, index_stream
,
221 TREE_STRING_POINTER (string
),
222 TREE_STRING_LENGTH (string
));
224 lto_output_uleb128_stream (index_stream
, 1);
228 /* Output the identifier ID to the string
229 table in OB. Then put the index onto the INDEX_STREAM. */
232 output_identifier (struct output_block
*ob
,
233 struct lto_output_stream
*index_stream
,
237 lto_output_string_with_length (ob
, index_stream
,
238 IDENTIFIER_POINTER (id
),
239 IDENTIFIER_LENGTH (id
));
241 lto_output_uleb128_stream (index_stream
, 1);
244 /* Write a zero to the output stream. */
247 output_zero (struct output_block
*ob
)
249 lto_output_1_stream (ob
->main_stream
, 0);
253 /* Output an unsigned LEB128 quantity to OB->main_stream. */
256 output_uleb128 (struct output_block
*ob
, unsigned HOST_WIDE_INT work
)
258 lto_output_uleb128_stream (ob
->main_stream
, work
);
262 /* Output a signed LEB128 quantity to OB->main_stream. */
265 output_sleb128 (struct output_block
*ob
, HOST_WIDE_INT work
)
267 lto_output_sleb128_stream (ob
->main_stream
, work
);
271 /* Output the start of a record with TAG to output block OB. */
274 output_record_start (struct output_block
*ob
, enum LTO_tags tag
)
276 /* Make sure TAG fits inside an unsigned int. */
277 gcc_assert (tag
== (enum LTO_tags
) (unsigned) tag
);
278 output_uleb128 (ob
, tag
);
282 /* Look up NODE in the type table and write the index for it to OB. */
285 output_type_ref (struct output_block
*ob
, tree node
)
287 output_record_start (ob
, LTO_type_ref
);
288 lto_output_type_ref_index (ob
->decl_state
, ob
->main_stream
, node
);
292 /* Pack all the non-pointer fields of the TS_BASE structure of
293 expression EXPR into bitpack BP. */
296 pack_ts_base_value_fields (struct bitpack_d
*bp
, tree expr
)
298 bp_pack_value (bp
, TREE_CODE (expr
), 16);
301 bp_pack_value (bp
, TREE_SIDE_EFFECTS (expr
), 1);
302 bp_pack_value (bp
, TREE_CONSTANT (expr
), 1);
303 bp_pack_value (bp
, TREE_READONLY (expr
), 1);
305 /* TREE_PUBLIC is used on types to indicate that the type
306 has a TYPE_CACHED_VALUES vector. This is not streamed out,
307 so we skip it here. */
308 bp_pack_value (bp
, TREE_PUBLIC (expr
), 1);
311 bp_pack_value (bp
, 0, 4);
312 bp_pack_value (bp
, TREE_ADDRESSABLE (expr
), 1);
313 bp_pack_value (bp
, TREE_THIS_VOLATILE (expr
), 1);
315 bp_pack_value (bp
, DECL_UNSIGNED (expr
), 1);
316 else if (TYPE_P (expr
))
317 bp_pack_value (bp
, TYPE_UNSIGNED (expr
), 1);
319 bp_pack_value (bp
, 0, 1);
320 /* We write debug info two times, do not confuse the second one. */
321 bp_pack_value (bp
, TYPE_P (expr
) ? 0 : TREE_ASM_WRITTEN (expr
), 1);
322 bp_pack_value (bp
, TREE_NO_WARNING (expr
), 1);
323 bp_pack_value (bp
, TREE_USED (expr
), 1);
324 bp_pack_value (bp
, TREE_NOTHROW (expr
), 1);
325 bp_pack_value (bp
, TREE_STATIC (expr
), 1);
326 bp_pack_value (bp
, TREE_PRIVATE (expr
), 1);
327 bp_pack_value (bp
, TREE_PROTECTED (expr
), 1);
328 bp_pack_value (bp
, TREE_DEPRECATED (expr
), 1);
330 bp_pack_value (bp
, TYPE_SATURATING (expr
), 1);
331 else if (TREE_CODE (expr
) == SSA_NAME
)
332 bp_pack_value (bp
, SSA_NAME_IS_DEFAULT_DEF (expr
), 1);
334 bp_pack_value (bp
, 0, 1);
338 /* Pack all the non-pointer fields of the TS_REAL_CST structure of
339 expression EXPR into bitpack BP. */
342 pack_ts_real_cst_value_fields (struct bitpack_d
*bp
, tree expr
)
347 r
= TREE_REAL_CST (expr
);
348 bp_pack_value (bp
, r
.cl
, 2);
349 bp_pack_value (bp
, r
.decimal
, 1);
350 bp_pack_value (bp
, r
.sign
, 1);
351 bp_pack_value (bp
, r
.signalling
, 1);
352 bp_pack_value (bp
, r
.canonical
, 1);
353 bp_pack_value (bp
, r
.uexp
, EXP_BITS
);
354 for (i
= 0; i
< SIGSZ
; i
++)
355 bp_pack_value (bp
, r
.sig
[i
], HOST_BITS_PER_LONG
);
359 /* Pack all the non-pointer fields of the TS_FIXED_CST structure of
360 expression EXPR into bitpack BP. */
363 pack_ts_fixed_cst_value_fields (struct bitpack_d
*bp
, tree expr
)
365 struct fixed_value fv
= TREE_FIXED_CST (expr
);
366 bp_pack_value (bp
, fv
.data
.low
, HOST_BITS_PER_WIDE_INT
);
367 bp_pack_value (bp
, fv
.data
.high
, HOST_BITS_PER_WIDE_INT
);
368 bp_pack_value (bp
, fv
.mode
, HOST_BITS_PER_INT
);
372 /* Pack all the non-pointer fields of the TS_DECL_COMMON structure
373 of expression EXPR into bitpack BP. */
376 pack_ts_decl_common_value_fields (struct bitpack_d
*bp
, tree expr
)
378 bp_pack_value (bp
, DECL_MODE (expr
), 8);
379 bp_pack_value (bp
, DECL_NONLOCAL (expr
), 1);
380 bp_pack_value (bp
, DECL_VIRTUAL_P (expr
), 1);
381 bp_pack_value (bp
, DECL_IGNORED_P (expr
), 1);
382 bp_pack_value (bp
, DECL_ABSTRACT (expr
), 1);
383 bp_pack_value (bp
, DECL_ARTIFICIAL (expr
), 1);
384 bp_pack_value (bp
, DECL_USER_ALIGN (expr
), 1);
385 bp_pack_value (bp
, DECL_PRESERVE_P (expr
), 1);
386 bp_pack_value (bp
, DECL_DEBUG_EXPR_IS_FROM (expr
), 1);
387 bp_pack_value (bp
, DECL_EXTERNAL (expr
), 1);
388 bp_pack_value (bp
, DECL_GIMPLE_REG_P (expr
), 1);
389 bp_pack_value (bp
, DECL_ALIGN (expr
), HOST_BITS_PER_INT
);
391 if (TREE_CODE (expr
) == LABEL_DECL
)
393 /* Note that we do not write LABEL_DECL_UID. The reader will
394 always assume an initial value of -1 so that the
395 label_to_block_map is recreated by gimple_set_bb. */
396 bp_pack_value (bp
, DECL_ERROR_ISSUED (expr
), 1);
397 bp_pack_value (bp
, EH_LANDING_PAD_NR (expr
), HOST_BITS_PER_INT
);
400 if (TREE_CODE (expr
) == FIELD_DECL
)
402 bp_pack_value (bp
, DECL_PACKED (expr
), 1);
403 bp_pack_value (bp
, DECL_NONADDRESSABLE_P (expr
), 1);
404 bp_pack_value (bp
, DECL_OFFSET_ALIGN (expr
), 8);
407 if (TREE_CODE (expr
) == RESULT_DECL
408 || TREE_CODE (expr
) == PARM_DECL
409 || TREE_CODE (expr
) == VAR_DECL
)
411 bp_pack_value (bp
, DECL_BY_REFERENCE (expr
), 1);
412 if (TREE_CODE (expr
) == VAR_DECL
413 || TREE_CODE (expr
) == PARM_DECL
)
414 bp_pack_value (bp
, DECL_HAS_VALUE_EXPR_P (expr
), 1);
415 bp_pack_value (bp
, DECL_RESTRICTED_P (expr
), 1);
420 /* Pack all the non-pointer fields of the TS_DECL_WRTL structure
421 of expression EXPR into bitpack BP. */
424 pack_ts_decl_wrtl_value_fields (struct bitpack_d
*bp
, tree expr
)
426 bp_pack_value (bp
, DECL_REGISTER (expr
), 1);
430 /* Pack all the non-pointer fields of the TS_DECL_WITH_VIS structure
431 of expression EXPR into bitpack BP. */
434 pack_ts_decl_with_vis_value_fields (struct bitpack_d
*bp
, tree expr
)
436 bp_pack_value (bp
, DECL_DEFER_OUTPUT (expr
), 1);
437 bp_pack_value (bp
, DECL_COMMON (expr
), 1);
438 bp_pack_value (bp
, DECL_DLLIMPORT_P (expr
), 1);
439 bp_pack_value (bp
, DECL_WEAK (expr
), 1);
440 bp_pack_value (bp
, DECL_SEEN_IN_BIND_EXPR_P (expr
), 1);
441 bp_pack_value (bp
, DECL_COMDAT (expr
), 1);
442 bp_pack_value (bp
, DECL_VISIBILITY (expr
), 2);
443 bp_pack_value (bp
, DECL_VISIBILITY_SPECIFIED (expr
), 1);
445 if (TREE_CODE (expr
) == VAR_DECL
)
447 bp_pack_value (bp
, DECL_HARD_REGISTER (expr
), 1);
448 bp_pack_value (bp
, DECL_IN_TEXT_SECTION (expr
), 1);
449 bp_pack_value (bp
, DECL_IN_CONSTANT_POOL (expr
), 1);
450 bp_pack_value (bp
, DECL_TLS_MODEL (expr
), 3);
453 if (VAR_OR_FUNCTION_DECL_P (expr
))
454 bp_pack_value (bp
, DECL_INIT_PRIORITY (expr
), HOST_BITS_PER_SHORT
);
458 /* Pack all the non-pointer fields of the TS_FUNCTION_DECL structure
459 of expression EXPR into bitpack BP. */
462 pack_ts_function_decl_value_fields (struct bitpack_d
*bp
, tree expr
)
464 /* For normal/md builtins we only write the class and code, so they
465 should never be handled here. */
466 gcc_assert (!lto_stream_as_builtin_p (expr
));
468 bp_pack_value (bp
, DECL_FUNCTION_CODE (expr
), 11);
469 bp_pack_value (bp
, DECL_BUILT_IN_CLASS (expr
), 2);
470 bp_pack_value (bp
, DECL_STATIC_CONSTRUCTOR (expr
), 1);
471 bp_pack_value (bp
, DECL_STATIC_DESTRUCTOR (expr
), 1);
472 bp_pack_value (bp
, DECL_UNINLINABLE (expr
), 1);
473 bp_pack_value (bp
, DECL_POSSIBLY_INLINED (expr
), 1);
474 bp_pack_value (bp
, DECL_IS_NOVOPS (expr
), 1);
475 bp_pack_value (bp
, DECL_IS_RETURNS_TWICE (expr
), 1);
476 bp_pack_value (bp
, DECL_IS_MALLOC (expr
), 1);
477 bp_pack_value (bp
, DECL_IS_OPERATOR_NEW (expr
), 1);
478 bp_pack_value (bp
, DECL_DECLARED_INLINE_P (expr
), 1);
479 bp_pack_value (bp
, DECL_STATIC_CHAIN (expr
), 1);
480 bp_pack_value (bp
, DECL_NO_INLINE_WARNING_P (expr
), 1);
481 bp_pack_value (bp
, DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (expr
), 1);
482 bp_pack_value (bp
, DECL_NO_LIMIT_STACK (expr
), 1);
483 bp_pack_value (bp
, DECL_DISREGARD_INLINE_LIMITS (expr
), 1);
484 bp_pack_value (bp
, DECL_PURE_P (expr
), 1);
485 bp_pack_value (bp
, DECL_LOOPING_CONST_OR_PURE_P (expr
), 1);
486 if (DECL_STATIC_DESTRUCTOR (expr
))
487 bp_pack_value (bp
, DECL_FINI_PRIORITY (expr
), HOST_BITS_PER_SHORT
);
491 /* Pack all the non-pointer fields of the TS_TYPE structure
492 of expression EXPR into bitpack BP. */
495 pack_ts_type_value_fields (struct bitpack_d
*bp
, tree expr
)
497 bp_pack_value (bp
, TYPE_PRECISION (expr
), 10);
498 bp_pack_value (bp
, TYPE_MODE (expr
), 8);
499 bp_pack_value (bp
, TYPE_STRING_FLAG (expr
), 1);
500 bp_pack_value (bp
, TYPE_NO_FORCE_BLK (expr
), 1);
501 bp_pack_value (bp
, TYPE_NEEDS_CONSTRUCTING (expr
), 1);
502 if (RECORD_OR_UNION_TYPE_P (expr
))
503 bp_pack_value (bp
, TYPE_TRANSPARENT_AGGR (expr
), 1);
504 bp_pack_value (bp
, TYPE_PACKED (expr
), 1);
505 bp_pack_value (bp
, TYPE_RESTRICT (expr
), 1);
506 bp_pack_value (bp
, TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr
), 2);
507 bp_pack_value (bp
, TYPE_USER_ALIGN (expr
), 1);
508 bp_pack_value (bp
, TYPE_READONLY (expr
), 1);
509 bp_pack_value (bp
, TYPE_ALIGN (expr
), HOST_BITS_PER_INT
);
510 bp_pack_value (bp
, TYPE_ALIAS_SET (expr
) == 0 ? 0 : -1, HOST_BITS_PER_INT
);
514 /* Pack all the non-pointer fields of the TS_BLOCK structure
515 of expression EXPR into bitpack BP. */
518 pack_ts_block_value_fields (struct bitpack_d
*bp
, tree expr
)
520 bp_pack_value (bp
, BLOCK_ABSTRACT (expr
), 1);
521 bp_pack_value (bp
, BLOCK_NUMBER (expr
), 31);
524 /* Pack all the non-pointer fields of the TS_TRANSLATION_UNIT_DECL structure
525 of expression EXPR into bitpack BP. */
528 pack_ts_translation_unit_decl_value_fields (struct bitpack_d
*bp ATTRIBUTE_UNUSED
, tree expr ATTRIBUTE_UNUSED
)
532 /* Pack all the non-pointer fields in EXPR into a bit pack. */
535 pack_value_fields (struct bitpack_d
*bp
, tree expr
)
539 code
= TREE_CODE (expr
);
541 /* Note that all these functions are highly sensitive to changes in
542 the types and sizes of each of the fields being packed. */
543 pack_ts_base_value_fields (bp
, expr
);
545 if (CODE_CONTAINS_STRUCT (code
, TS_REAL_CST
))
546 pack_ts_real_cst_value_fields (bp
, expr
);
548 if (CODE_CONTAINS_STRUCT (code
, TS_FIXED_CST
))
549 pack_ts_fixed_cst_value_fields (bp
, expr
);
551 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
552 pack_ts_decl_common_value_fields (bp
, expr
);
554 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WRTL
))
555 pack_ts_decl_wrtl_value_fields (bp
, expr
);
557 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
558 pack_ts_decl_with_vis_value_fields (bp
, expr
);
560 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
561 pack_ts_function_decl_value_fields (bp
, expr
);
563 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE
))
564 pack_ts_type_value_fields (bp
, expr
);
566 if (CODE_CONTAINS_STRUCT (code
, TS_BLOCK
))
567 pack_ts_block_value_fields (bp
, expr
);
569 if (CODE_CONTAINS_STRUCT (code
, TS_SSA_NAME
))
571 /* We only stream the version number of SSA names. */
575 if (CODE_CONTAINS_STRUCT (code
, TS_STATEMENT_LIST
))
577 /* This is only used by GENERIC. */
581 if (CODE_CONTAINS_STRUCT (code
, TS_OMP_CLAUSE
))
583 /* This is only used by High GIMPLE. */
587 if (CODE_CONTAINS_STRUCT (code
, TS_TRANSLATION_UNIT_DECL
))
588 pack_ts_translation_unit_decl_value_fields (bp
, expr
);
592 /* Emit location LOC to output block OB. */
595 lto_output_location (struct output_block
*ob
, location_t loc
)
597 expanded_location xloc
;
599 if (loc
== UNKNOWN_LOCATION
)
601 lto_output_string (ob
, ob
->main_stream
, NULL
);
605 xloc
= expand_location (loc
);
607 lto_output_string (ob
, ob
->main_stream
, xloc
.file
);
608 output_sleb128 (ob
, xloc
.line
);
609 output_sleb128 (ob
, xloc
.column
);
610 output_sleb128 (ob
, xloc
.sysp
);
612 ob
->current_file
= xloc
.file
;
613 ob
->current_line
= xloc
.line
;
614 ob
->current_col
= xloc
.column
;
618 /* Return true if tree node T is written to various tables. For these
619 nodes, we sometimes want to write their phyiscal representation
620 (via lto_output_tree), and sometimes we need to emit an index
621 reference into a table (via lto_output_tree_ref). */
624 tree_is_indexable (tree t
)
626 if (TREE_CODE (t
) == PARM_DECL
)
628 else if (TREE_CODE (t
) == VAR_DECL
&& decl_function_context (t
)
632 return (TYPE_P (t
) || DECL_P (t
) || TREE_CODE (t
) == SSA_NAME
);
636 /* If EXPR is an indexable tree node, output a reference to it to
637 output block OB. Otherwise, output the physical representation of
641 lto_output_tree_ref (struct output_block
*ob
, tree expr
)
645 if (expr
== NULL_TREE
)
651 if (!tree_is_indexable (expr
))
653 /* Even though we are emitting the physical representation of
654 EXPR, its leaves must be emitted as references. */
655 lto_output_tree (ob
, expr
, true);
661 output_type_ref (ob
, expr
);
665 code
= TREE_CODE (expr
);
669 output_record_start (ob
, LTO_ssa_name_ref
);
670 output_uleb128 (ob
, SSA_NAME_VERSION (expr
));
674 output_record_start (ob
, LTO_field_decl_ref
);
675 lto_output_field_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
679 output_record_start (ob
, LTO_function_decl_ref
);
680 lto_output_fn_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
684 case DEBUG_EXPR_DECL
:
685 gcc_assert (decl_function_context (expr
) == NULL
686 || TREE_STATIC (expr
));
687 output_record_start (ob
, LTO_global_decl_ref
);
688 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
692 output_record_start (ob
, LTO_const_decl_ref
);
693 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
697 gcc_assert (decl_function_context (expr
) == NULL
);
698 output_record_start (ob
, LTO_imported_decl_ref
);
699 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
703 output_record_start (ob
, LTO_type_decl_ref
);
704 lto_output_type_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
708 output_record_start (ob
, LTO_namespace_decl_ref
);
709 lto_output_namespace_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
713 output_record_start (ob
, LTO_label_decl_ref
);
714 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
718 output_record_start (ob
, LTO_result_decl_ref
);
719 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
722 case TRANSLATION_UNIT_DECL
:
723 output_record_start (ob
, LTO_translation_unit_decl_ref
);
724 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
728 /* No other node is indexable, so it should have been handled
729 by lto_output_tree. */
735 /* If REF_P is true, emit a reference to EXPR in output block OB,
736 otherwise emit the physical representation of EXPR in OB. */
739 lto_output_tree_or_ref (struct output_block
*ob
, tree expr
, bool ref_p
)
742 lto_output_tree_ref (ob
, expr
);
744 lto_output_tree (ob
, expr
, false);
748 /* Emit the chain of tree nodes starting at T. OB is the output block
749 to write to. REF_P is true if chain elements should be emitted
753 lto_output_chain (struct output_block
*ob
, tree t
, bool ref_p
)
757 count
= list_length (t
);
758 output_sleb128 (ob
, count
);
759 for (i
= 0; i
< count
; i
++)
763 /* Clear TREE_CHAIN to avoid blindly recursing into the rest
765 saved_chain
= TREE_CHAIN (t
);
766 TREE_CHAIN (t
) = NULL_TREE
;
768 lto_output_tree_or_ref (ob
, t
, ref_p
);
770 TREE_CHAIN (t
) = saved_chain
;
776 /* Write all pointer fields in the TS_COMMON structure of EXPR to output
777 block OB. If REF_P is true, write a reference to EXPR's pointer
781 lto_output_ts_common_tree_pointers (struct output_block
*ob
, tree expr
,
784 if (TREE_CODE (expr
) != IDENTIFIER_NODE
)
785 lto_output_tree_or_ref (ob
, TREE_TYPE (expr
), ref_p
);
789 /* Write all pointer fields in the TS_VECTOR structure of EXPR to output
790 block OB. If REF_P is true, write a reference to EXPR's pointer
794 lto_output_ts_vector_tree_pointers (struct output_block
*ob
, tree expr
,
797 lto_output_chain (ob
, TREE_VECTOR_CST_ELTS (expr
), ref_p
);
801 /* Write all pointer fields in the TS_COMPLEX structure of EXPR to output
802 block OB. If REF_P is true, write a reference to EXPR's pointer
806 lto_output_ts_complex_tree_pointers (struct output_block
*ob
, tree expr
,
809 lto_output_tree_or_ref (ob
, TREE_REALPART (expr
), ref_p
);
810 lto_output_tree_or_ref (ob
, TREE_IMAGPART (expr
), ref_p
);
814 /* Write all pointer fields in the TS_DECL_MINIMAL structure of EXPR
815 to output block OB. If REF_P is true, write a reference to EXPR's
819 lto_output_ts_decl_minimal_tree_pointers (struct output_block
*ob
, tree expr
,
822 lto_output_tree_or_ref (ob
, DECL_NAME (expr
), ref_p
);
823 lto_output_tree_or_ref (ob
, DECL_CONTEXT (expr
), ref_p
);
824 lto_output_location (ob
, DECL_SOURCE_LOCATION (expr
));
828 /* Write all pointer fields in the TS_DECL_COMMON structure of EXPR to
829 output block OB. If REF_P is true, write a reference to EXPR's
833 lto_output_ts_decl_common_tree_pointers (struct output_block
*ob
, tree expr
,
836 lto_output_tree_or_ref (ob
, DECL_SIZE (expr
), ref_p
);
837 lto_output_tree_or_ref (ob
, DECL_SIZE_UNIT (expr
), ref_p
);
839 if (TREE_CODE (expr
) != FUNCTION_DECL
840 && TREE_CODE (expr
) != TRANSLATION_UNIT_DECL
)
842 tree initial
= DECL_INITIAL (expr
);
843 if (TREE_CODE (expr
) == VAR_DECL
844 && (TREE_STATIC (expr
) || DECL_EXTERNAL (expr
))
847 lto_varpool_encoder_t varpool_encoder
= ob
->decl_state
->varpool_node_encoder
;
848 struct varpool_node
*vnode
= varpool_get_node (expr
);
850 initial
= error_mark_node
;
851 else if (!lto_varpool_encoder_encode_initializer_p (varpool_encoder
,
856 lto_output_tree_or_ref (ob
, initial
, ref_p
);
859 lto_output_tree_or_ref (ob
, DECL_ATTRIBUTES (expr
), ref_p
);
860 /* Do not stream DECL_ABSTRACT_ORIGIN. We cannot handle debug information
861 for early inlining so drop it on the floor instead of ICEing in
864 if (TREE_CODE (expr
) == PARM_DECL
)
865 lto_output_chain (ob
, TREE_CHAIN (expr
), ref_p
);
867 if ((TREE_CODE (expr
) == VAR_DECL
868 || TREE_CODE (expr
) == PARM_DECL
)
869 && DECL_HAS_VALUE_EXPR_P (expr
))
870 lto_output_tree_or_ref (ob
, DECL_VALUE_EXPR (expr
), ref_p
);
872 if (TREE_CODE (expr
) == VAR_DECL
)
873 lto_output_tree_or_ref (ob
, DECL_DEBUG_EXPR (expr
), ref_p
);
877 /* Write all pointer fields in the TS_DECL_NON_COMMON structure of
878 EXPR to output block OB. If REF_P is true, write a reference to EXPR's
882 lto_output_ts_decl_non_common_tree_pointers (struct output_block
*ob
,
883 tree expr
, bool ref_p
)
885 if (TREE_CODE (expr
) == FUNCTION_DECL
)
887 /* DECL_SAVED_TREE holds the GENERIC representation for DECL.
888 At this point, it should not exist. Either because it was
889 converted to gimple or because DECL didn't have a GENERIC
890 representation in this TU. */
891 gcc_assert (DECL_SAVED_TREE (expr
) == NULL_TREE
);
892 lto_output_tree_or_ref (ob
, DECL_ARGUMENTS (expr
), ref_p
);
893 lto_output_tree_or_ref (ob
, DECL_RESULT (expr
), ref_p
);
895 lto_output_tree_or_ref (ob
, DECL_VINDEX (expr
), ref_p
);
899 /* Write all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
900 to output block OB. If REF_P is true, write a reference to EXPR's
904 lto_output_ts_decl_with_vis_tree_pointers (struct output_block
*ob
, tree expr
,
907 /* Make sure we don't inadvertently set the assembler name. */
908 if (DECL_ASSEMBLER_NAME_SET_P (expr
))
909 lto_output_tree_or_ref (ob
, DECL_ASSEMBLER_NAME (expr
), ref_p
);
913 lto_output_tree_or_ref (ob
, DECL_SECTION_NAME (expr
), ref_p
);
914 lto_output_tree_or_ref (ob
, DECL_COMDAT_GROUP (expr
), ref_p
);
918 /* Write all pointer fields in the TS_FIELD_DECL structure of EXPR to
919 output block OB. If REF_P is true, write a reference to EXPR's
923 lto_output_ts_field_decl_tree_pointers (struct output_block
*ob
, tree expr
,
926 lto_output_tree_or_ref (ob
, DECL_FIELD_OFFSET (expr
), ref_p
);
927 lto_output_tree_or_ref (ob
, DECL_BIT_FIELD_TYPE (expr
), ref_p
);
928 lto_output_tree_or_ref (ob
, DECL_QUALIFIER (expr
), ref_p
);
929 lto_output_tree_or_ref (ob
, DECL_FIELD_BIT_OFFSET (expr
), ref_p
);
930 lto_output_tree_or_ref (ob
, DECL_FCONTEXT (expr
), ref_p
);
931 lto_output_chain (ob
, TREE_CHAIN (expr
), ref_p
);
935 /* Write all pointer fields in the TS_FUNCTION_DECL structure of EXPR
936 to output block OB. If REF_P is true, write a reference to EXPR's
940 lto_output_ts_function_decl_tree_pointers (struct output_block
*ob
, tree expr
,
943 /* DECL_STRUCT_FUNCTION is handled by lto_output_function. FIXME lto,
944 maybe it should be handled here? */
945 lto_output_tree_or_ref (ob
, DECL_FUNCTION_PERSONALITY (expr
), ref_p
);
946 lto_output_tree_or_ref (ob
, DECL_FUNCTION_SPECIFIC_TARGET (expr
), ref_p
);
947 lto_output_tree_or_ref (ob
, DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr
),
952 /* Write all pointer fields in the TS_TYPE structure of EXPR to output
953 block OB. If REF_P is true, write a reference to EXPR's pointer
957 lto_output_ts_type_tree_pointers (struct output_block
*ob
, tree expr
,
960 if (TREE_CODE (expr
) == ENUMERAL_TYPE
)
961 lto_output_tree_or_ref (ob
, TYPE_VALUES (expr
), ref_p
);
962 else if (TREE_CODE (expr
) == ARRAY_TYPE
)
963 lto_output_tree_or_ref (ob
, TYPE_DOMAIN (expr
), ref_p
);
964 else if (RECORD_OR_UNION_TYPE_P (expr
))
965 lto_output_tree_or_ref (ob
, TYPE_FIELDS (expr
), ref_p
);
966 else if (TREE_CODE (expr
) == FUNCTION_TYPE
967 || TREE_CODE (expr
) == METHOD_TYPE
)
968 lto_output_tree_or_ref (ob
, TYPE_ARG_TYPES (expr
), ref_p
);
970 lto_output_tree_or_ref (ob
, TYPE_SIZE (expr
), ref_p
);
971 lto_output_tree_or_ref (ob
, TYPE_SIZE_UNIT (expr
), ref_p
);
972 lto_output_tree_or_ref (ob
, TYPE_ATTRIBUTES (expr
), ref_p
);
973 lto_output_tree_or_ref (ob
, TYPE_NAME (expr
), ref_p
);
974 /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO nor
975 TYPE_NEXT_PTR_TO or TYPE_NEXT_REF_TO. */
976 if (!POINTER_TYPE_P (expr
))
977 lto_output_tree_or_ref (ob
, TYPE_MINVAL (expr
), ref_p
);
978 lto_output_tree_or_ref (ob
, TYPE_MAXVAL (expr
), ref_p
);
979 lto_output_tree_or_ref (ob
, TYPE_MAIN_VARIANT (expr
), ref_p
);
980 /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
982 if (RECORD_OR_UNION_TYPE_P (expr
))
983 lto_output_tree_or_ref (ob
, TYPE_BINFO (expr
), ref_p
);
984 lto_output_tree_or_ref (ob
, TYPE_CONTEXT (expr
), ref_p
);
985 /* TYPE_CANONICAL is re-computed during type merging, so no need
986 to stream it here. */
987 lto_output_tree_or_ref (ob
, TYPE_STUB_DECL (expr
), ref_p
);
991 /* Write all pointer fields in the TS_LIST structure of EXPR to output
992 block OB. If REF_P is true, write a reference to EXPR's pointer
996 lto_output_ts_list_tree_pointers (struct output_block
*ob
, tree expr
,
999 lto_output_tree_or_ref (ob
, TREE_PURPOSE (expr
), ref_p
);
1000 lto_output_tree_or_ref (ob
, TREE_VALUE (expr
), ref_p
);
1001 lto_output_chain (ob
, TREE_CHAIN (expr
), ref_p
);
1005 /* Write all pointer fields in the TS_VEC structure of EXPR to output
1006 block OB. If REF_P is true, write a reference to EXPR's pointer
1010 lto_output_ts_vec_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
1014 /* Note that the number of slots for EXPR has already been emitted
1015 in EXPR's header (see lto_output_tree_header). */
1016 for (i
= 0; i
< TREE_VEC_LENGTH (expr
); i
++)
1017 lto_output_tree_or_ref (ob
, TREE_VEC_ELT (expr
, i
), ref_p
);
1021 /* Write all pointer fields in the TS_EXP structure of EXPR to output
1022 block OB. If REF_P is true, write a reference to EXPR's pointer
1026 lto_output_ts_exp_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
1030 output_sleb128 (ob
, TREE_OPERAND_LENGTH (expr
));
1031 for (i
= 0; i
< TREE_OPERAND_LENGTH (expr
); i
++)
1032 lto_output_tree_or_ref (ob
, TREE_OPERAND (expr
, i
), ref_p
);
1033 lto_output_location (ob
, EXPR_LOCATION (expr
));
1034 lto_output_tree_or_ref (ob
, TREE_BLOCK (expr
), ref_p
);
1038 /* Write all pointer fields in the TS_BLOCK structure of EXPR to output
1039 block OB. If REF_P is true, write a reference to EXPR's pointer
1043 lto_output_ts_block_tree_pointers (struct output_block
*ob
, tree expr
,
1046 /* Do not stream BLOCK_SOURCE_LOCATION. We cannot handle debug information
1047 for early inlining so drop it on the floor instead of ICEing in
1049 lto_output_chain (ob
, BLOCK_VARS (expr
), ref_p
);
1051 /* Do not stream BLOCK_NONLOCALIZED_VARS. We cannot handle debug information
1052 for early inlining so drop it on the floor instead of ICEing in
1055 lto_output_tree_or_ref (ob
, BLOCK_SUPERCONTEXT (expr
), ref_p
);
1056 /* Do not stream BLOCK_ABSTRACT_ORIGIN. We cannot handle debug information
1057 for early inlining so drop it on the floor instead of ICEing in
1059 lto_output_tree_or_ref (ob
, BLOCK_FRAGMENT_ORIGIN (expr
), ref_p
);
1060 lto_output_tree_or_ref (ob
, BLOCK_FRAGMENT_CHAIN (expr
), ref_p
);
1061 /* Do not output BLOCK_SUBBLOCKS. Instead on streaming-in this
1062 list is re-constructed from BLOCK_SUPERCONTEXT. */
1066 /* Write all pointer fields in the TS_BINFO structure of EXPR to output
1067 block OB. If REF_P is true, write a reference to EXPR's pointer
1071 lto_output_ts_binfo_tree_pointers (struct output_block
*ob
, tree expr
,
1077 /* Note that the number of BINFO slots has already been emitted in
1078 EXPR's header (see lto_output_tree_header) because this length
1079 is needed to build the empty BINFO node on the reader side. */
1080 FOR_EACH_VEC_ELT (tree
, BINFO_BASE_BINFOS (expr
), i
, t
)
1081 lto_output_tree_or_ref (ob
, t
, ref_p
);
1084 lto_output_tree_or_ref (ob
, BINFO_OFFSET (expr
), ref_p
);
1085 lto_output_tree_or_ref (ob
, BINFO_VTABLE (expr
), ref_p
);
1086 lto_output_tree_or_ref (ob
, BINFO_VIRTUALS (expr
), ref_p
);
1087 lto_output_tree_or_ref (ob
, BINFO_VPTR_FIELD (expr
), ref_p
);
1089 output_uleb128 (ob
, VEC_length (tree
, BINFO_BASE_ACCESSES (expr
)));
1090 FOR_EACH_VEC_ELT (tree
, BINFO_BASE_ACCESSES (expr
), i
, t
)
1091 lto_output_tree_or_ref (ob
, t
, ref_p
);
1093 lto_output_tree_or_ref (ob
, BINFO_INHERITANCE_CHAIN (expr
), ref_p
);
1094 lto_output_tree_or_ref (ob
, BINFO_SUBVTT_INDEX (expr
), ref_p
);
1095 lto_output_tree_or_ref (ob
, BINFO_VPTR_INDEX (expr
), ref_p
);
1099 /* Write all pointer fields in the TS_CONSTRUCTOR structure of EXPR to
1100 output block OB. If REF_P is true, write a reference to EXPR's
1104 lto_output_ts_constructor_tree_pointers (struct output_block
*ob
, tree expr
,
1110 output_uleb128 (ob
, CONSTRUCTOR_NELTS (expr
));
1111 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (expr
), i
, index
, value
)
1113 lto_output_tree_or_ref (ob
, index
, ref_p
);
1114 lto_output_tree_or_ref (ob
, value
, ref_p
);
1118 /* Write a TS_TARGET_OPTION tree in EXPR to OB. */
1121 lto_output_ts_target_option (struct output_block
*ob
, tree expr
)
1123 struct cl_target_option
*t
= TREE_TARGET_OPTION (expr
);
1124 struct bitpack_d bp
;
1127 /* The cl_target_option is target specific and generated by the options
1128 awk script, so we just recreate a byte-by-byte copy here. */
1130 bp
= bitpack_create (ob
->main_stream
);
1131 len
= sizeof (struct cl_target_option
);
1132 for (i
= 0; i
< len
; i
++)
1133 bp_pack_value (&bp
, ((unsigned char *)t
)[i
], 8);
1134 /* Catch struct size mismatches between reader and writer. */
1135 bp_pack_value (&bp
, 0x12345678, 32);
1136 lto_output_bitpack (&bp
);
1139 /* Write a TS_TRANSLATION_UNIT_DECL tree in EXPR to OB. */
1142 lto_output_ts_translation_unit_decl_tree_pointers (struct output_block
*ob
,
1145 lto_output_string (ob
, ob
->main_stream
, TRANSLATION_UNIT_LANGUAGE (expr
));
1148 /* Helper for lto_output_tree. Write all pointer fields in EXPR to output
1149 block OB. If REF_P is true, the leaves of EXPR are emitted as
1153 lto_output_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
1155 enum tree_code code
;
1157 code
= TREE_CODE (expr
);
1159 if (CODE_CONTAINS_STRUCT (code
, TS_TYPED
))
1160 lto_output_ts_common_tree_pointers (ob
, expr
, ref_p
);
1162 if (CODE_CONTAINS_STRUCT (code
, TS_VECTOR
))
1163 lto_output_ts_vector_tree_pointers (ob
, expr
, ref_p
);
1165 if (CODE_CONTAINS_STRUCT (code
, TS_COMPLEX
))
1166 lto_output_ts_complex_tree_pointers (ob
, expr
, ref_p
);
1168 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
1169 lto_output_ts_decl_minimal_tree_pointers (ob
, expr
, ref_p
);
1171 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
1172 lto_output_ts_decl_common_tree_pointers (ob
, expr
, ref_p
);
1174 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_NON_COMMON
))
1175 lto_output_ts_decl_non_common_tree_pointers (ob
, expr
, ref_p
);
1177 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
1178 lto_output_ts_decl_with_vis_tree_pointers (ob
, expr
, ref_p
);
1180 if (CODE_CONTAINS_STRUCT (code
, TS_FIELD_DECL
))
1181 lto_output_ts_field_decl_tree_pointers (ob
, expr
, ref_p
);
1183 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
1184 lto_output_ts_function_decl_tree_pointers (ob
, expr
, ref_p
);
1186 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE
))
1187 lto_output_ts_type_tree_pointers (ob
, expr
, ref_p
);
1189 if (CODE_CONTAINS_STRUCT (code
, TS_LIST
))
1190 lto_output_ts_list_tree_pointers (ob
, expr
, ref_p
);
1192 if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
1193 lto_output_ts_vec_tree_pointers (ob
, expr
, ref_p
);
1195 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
1196 lto_output_ts_exp_tree_pointers (ob
, expr
, ref_p
);
1198 if (CODE_CONTAINS_STRUCT (code
, TS_SSA_NAME
))
1200 /* We only stream the version number of SSA names. */
1204 if (CODE_CONTAINS_STRUCT (code
, TS_BLOCK
))
1205 lto_output_ts_block_tree_pointers (ob
, expr
, ref_p
);
1207 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
1208 lto_output_ts_binfo_tree_pointers (ob
, expr
, ref_p
);
1210 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
1211 lto_output_ts_constructor_tree_pointers (ob
, expr
, ref_p
);
1213 if (CODE_CONTAINS_STRUCT (code
, TS_STATEMENT_LIST
))
1215 /* This should only appear in GENERIC. */
1219 if (CODE_CONTAINS_STRUCT (code
, TS_OMP_CLAUSE
))
1221 /* This should only appear in High GIMPLE. */
1225 if (CODE_CONTAINS_STRUCT (code
, TS_OPTIMIZATION
))
1226 sorry ("gimple bytecode streams do not support the optimization attribute");
1228 if (CODE_CONTAINS_STRUCT (code
, TS_TARGET_OPTION
))
1229 lto_output_ts_target_option (ob
, expr
);
1231 if (CODE_CONTAINS_STRUCT (code
, TS_TRANSLATION_UNIT_DECL
))
1232 lto_output_ts_translation_unit_decl_tree_pointers (ob
, expr
);
1236 /* Emit header information for tree EXPR to output block OB. The header
1237 contains everything needed to instantiate an empty skeleton for
1238 EXPR on the reading side. IX is the index into the streamer cache
1239 where EXPR is stored. REF_P is as in lto_output_tree. */
1242 lto_output_tree_header (struct output_block
*ob
, tree expr
)
1245 enum tree_code code
;
1247 /* We should not see any non-GIMPLE tree nodes here. */
1248 code
= TREE_CODE (expr
);
1249 if (!lto_is_streamable (expr
))
1250 internal_error ("tree code %qs is not supported in gimple streams",
1251 tree_code_name
[code
]);
1253 /* The header of a tree node consists of its tag, the size of
1254 the node, and any other information needed to instantiate
1255 EXPR on the reading side (such as the number of slots in
1256 variable sized nodes). */
1257 tag
= lto_tree_code_to_tag (code
);
1258 output_record_start (ob
, tag
);
1260 /* The following will cause bootstrap miscomparisons. Enable with care. */
1261 #ifdef LTO_STREAMER_DEBUG
1262 /* This is used mainly for debugging purposes. When the reader
1263 and the writer do not agree on a streamed node, the pointer
1264 value for EXPR can be used to track down the differences in
1266 gcc_assert ((HOST_WIDEST_INT
) (intptr_t) expr
== (intptr_t) expr
);
1267 output_sleb128 (ob
, (HOST_WIDEST_INT
) (intptr_t) expr
);
1270 /* The text in strings and identifiers are completely emitted in
1272 if (CODE_CONTAINS_STRUCT (code
, TS_STRING
))
1273 output_string_cst (ob
, ob
->main_stream
, expr
);
1274 else if (CODE_CONTAINS_STRUCT (code
, TS_IDENTIFIER
))
1275 output_identifier (ob
, ob
->main_stream
, expr
);
1276 else if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
1277 output_sleb128 (ob
, TREE_VEC_LENGTH (expr
));
1278 else if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
1279 output_uleb128 (ob
, BINFO_N_BASE_BINFOS (expr
));
1283 /* Write the code and class of builtin EXPR to output block OB. IX is
1284 the index into the streamer cache where EXPR is stored.*/
1287 lto_output_builtin_tree (struct output_block
*ob
, tree expr
)
1289 gcc_assert (lto_stream_as_builtin_p (expr
));
1291 if (DECL_BUILT_IN_CLASS (expr
) == BUILT_IN_MD
1292 && !targetm
.builtin_decl
)
1293 sorry ("gimple bytecode streams do not support machine specific builtin "
1294 "functions on this target");
1296 output_record_start (ob
, LTO_builtin_decl
);
1297 output_uleb128 (ob
, DECL_BUILT_IN_CLASS (expr
));
1298 output_uleb128 (ob
, DECL_FUNCTION_CODE (expr
));
1300 if (DECL_ASSEMBLER_NAME_SET_P (expr
))
1302 /* When the assembler name of a builtin gets a user name,
1303 the new name is always prefixed with '*' by
1304 set_builtin_user_assembler_name. So, to prevent the
1305 reader side from adding a second '*', we omit it here. */
1306 const char *str
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (expr
));
1307 if (strlen (str
) > 1 && str
[0] == '*')
1308 lto_output_string (ob
, ob
->main_stream
, &str
[1]);
1310 lto_output_string (ob
, ob
->main_stream
, NULL
);
1313 lto_output_string (ob
, ob
->main_stream
, NULL
);
1317 /* Write a physical representation of tree node EXPR to output block
1318 OB. If REF_P is true, the leaves of EXPR are emitted as references
1319 via lto_output_tree_ref. IX is the index into the streamer cache
1320 where EXPR is stored. */
1323 lto_write_tree (struct output_block
*ob
, tree expr
, bool ref_p
)
1325 struct bitpack_d bp
;
1327 /* Write the header, containing everything needed to materialize
1328 EXPR on the reading side. */
1329 lto_output_tree_header (ob
, expr
);
1331 /* Pack all the non-pointer fields in EXPR into a bitpack and write
1332 the resulting bitpack. */
1333 bp
= bitpack_create (ob
->main_stream
);
1334 pack_value_fields (&bp
, expr
);
1335 lto_output_bitpack (&bp
);
1337 /* Write all the pointer fields in EXPR. */
1338 lto_output_tree_pointers (ob
, expr
, ref_p
);
1340 /* Mark the end of EXPR. */
1345 /* Emit the integer constant CST to output block OB. If REF_P is true,
1346 CST's type will be emitted as a reference. */
1349 lto_output_integer_cst (struct output_block
*ob
, tree cst
, bool ref_p
)
1351 output_record_start (ob
, lto_tree_code_to_tag (INTEGER_CST
));
1352 lto_output_tree_or_ref (ob
, TREE_TYPE (cst
), ref_p
);
1353 lto_output_1_stream (ob
->main_stream
, TREE_OVERFLOW_P (cst
));
1354 output_uleb128 (ob
, TREE_INT_CST_LOW (cst
));
1355 output_uleb128 (ob
, TREE_INT_CST_HIGH (cst
));
1359 /* Emit the physical representation of tree node EXPR to output block
1360 OB. If REF_P is true, the leaves of EXPR are emitted as references
1361 via lto_output_tree_ref. */
1364 lto_output_tree (struct output_block
*ob
, tree expr
, bool ref_p
)
1369 if (expr
== NULL_TREE
)
1375 /* INTEGER_CST nodes are special because they need their original type
1376 to be materialized by the reader (to implement TYPE_CACHED_VALUES). */
1377 if (TREE_CODE (expr
) == INTEGER_CST
)
1379 lto_output_integer_cst (ob
, expr
, ref_p
);
1383 existed_p
= lto_streamer_cache_insert (ob
->writer_cache
, expr
, &ix
);
1386 /* If a node has already been streamed out, make sure that
1387 we don't write it more than once. Otherwise, the reader
1388 will instantiate two different nodes for the same object. */
1389 output_record_start (ob
, LTO_tree_pickle_reference
);
1390 output_uleb128 (ob
, ix
);
1391 output_uleb128 (ob
, lto_tree_code_to_tag (TREE_CODE (expr
)));
1393 else if (lto_stream_as_builtin_p (expr
))
1395 /* MD and NORMAL builtins do not need to be written out
1396 completely as they are always instantiated by the
1397 compiler on startup. The only builtins that need to
1398 be written out are BUILT_IN_FRONTEND. For all other
1399 builtins, we simply write the class and code. */
1400 lto_output_builtin_tree (ob
, expr
);
1404 /* This is the first time we see EXPR, write its fields
1406 lto_write_tree (ob
, expr
, ref_p
);
1411 /* Output to OB a list of try/catch handlers starting with FIRST. */
1414 output_eh_try_list (struct output_block
*ob
, eh_catch first
)
1418 for (n
= first
; n
; n
= n
->next_catch
)
1420 output_record_start (ob
, LTO_eh_catch
);
1421 lto_output_tree_ref (ob
, n
->type_list
);
1422 lto_output_tree_ref (ob
, n
->filter_list
);
1423 lto_output_tree_ref (ob
, n
->label
);
1430 /* Output EH region R in function FN to OB. CURR_RN is the slot index
1431 that is being emitted in FN->EH->REGION_ARRAY. This is used to
1432 detect EH region sharing. */
1435 output_eh_region (struct output_block
*ob
, eh_region r
)
1445 if (r
->type
== ERT_CLEANUP
)
1446 tag
= LTO_ert_cleanup
;
1447 else if (r
->type
== ERT_TRY
)
1449 else if (r
->type
== ERT_ALLOWED_EXCEPTIONS
)
1450 tag
= LTO_ert_allowed_exceptions
;
1451 else if (r
->type
== ERT_MUST_NOT_THROW
)
1452 tag
= LTO_ert_must_not_throw
;
1456 output_record_start (ob
, tag
);
1457 output_sleb128 (ob
, r
->index
);
1460 output_sleb128 (ob
, r
->outer
->index
);
1465 output_sleb128 (ob
, r
->inner
->index
);
1470 output_sleb128 (ob
, r
->next_peer
->index
);
1474 if (r
->type
== ERT_TRY
)
1476 output_eh_try_list (ob
, r
->u
.eh_try
.first_catch
);
1478 else if (r
->type
== ERT_ALLOWED_EXCEPTIONS
)
1480 lto_output_tree_ref (ob
, r
->u
.allowed
.type_list
);
1481 lto_output_tree_ref (ob
, r
->u
.allowed
.label
);
1482 output_uleb128 (ob
, r
->u
.allowed
.filter
);
1484 else if (r
->type
== ERT_MUST_NOT_THROW
)
1486 lto_output_tree_ref (ob
, r
->u
.must_not_throw
.failure_decl
);
1487 lto_output_location (ob
, r
->u
.must_not_throw
.failure_loc
);
1490 if (r
->landing_pads
)
1491 output_sleb128 (ob
, r
->landing_pads
->index
);
1497 /* Output landing pad LP to OB. */
1500 output_eh_lp (struct output_block
*ob
, eh_landing_pad lp
)
1508 output_record_start (ob
, LTO_eh_landing_pad
);
1509 output_sleb128 (ob
, lp
->index
);
1511 output_sleb128 (ob
, lp
->next_lp
->index
);
1516 output_sleb128 (ob
, lp
->region
->index
);
1520 lto_output_tree_ref (ob
, lp
->post_landing_pad
);
1524 /* Output the existing eh_table to OB. */
1527 output_eh_regions (struct output_block
*ob
, struct function
*fn
)
1529 if (fn
->eh
&& fn
->eh
->region_tree
)
1536 output_record_start (ob
, LTO_eh_table
);
1538 /* Emit the index of the root of the EH region tree. */
1539 output_sleb128 (ob
, fn
->eh
->region_tree
->index
);
1541 /* Emit all the EH regions in the region array. */
1542 output_sleb128 (ob
, VEC_length (eh_region
, fn
->eh
->region_array
));
1543 FOR_EACH_VEC_ELT (eh_region
, fn
->eh
->region_array
, i
, eh
)
1544 output_eh_region (ob
, eh
);
1546 /* Emit all landing pads. */
1547 output_sleb128 (ob
, VEC_length (eh_landing_pad
, fn
->eh
->lp_array
));
1548 FOR_EACH_VEC_ELT (eh_landing_pad
, fn
->eh
->lp_array
, i
, lp
)
1549 output_eh_lp (ob
, lp
);
1551 /* Emit all the runtime type data. */
1552 output_sleb128 (ob
, VEC_length (tree
, fn
->eh
->ttype_data
));
1553 FOR_EACH_VEC_ELT (tree
, fn
->eh
->ttype_data
, i
, ttype
)
1554 lto_output_tree_ref (ob
, ttype
);
1556 /* Emit the table of action chains. */
1557 if (targetm
.arm_eabi_unwinder
)
1560 output_sleb128 (ob
, VEC_length (tree
, fn
->eh
->ehspec_data
.arm_eabi
));
1561 FOR_EACH_VEC_ELT (tree
, fn
->eh
->ehspec_data
.arm_eabi
, i
, t
)
1562 lto_output_tree_ref (ob
, t
);
1567 output_sleb128 (ob
, VEC_length (uchar
, fn
->eh
->ehspec_data
.other
));
1568 FOR_EACH_VEC_ELT (uchar
, fn
->eh
->ehspec_data
.other
, i
, c
)
1569 lto_output_1_stream (ob
->main_stream
, c
);
1573 /* The 0 either terminates the record or indicates that there are no
1574 eh_records at all. */
1579 /* Output all of the active ssa names to the ssa_names stream. */
1582 output_ssa_names (struct output_block
*ob
, struct function
*fn
)
1584 unsigned int i
, len
;
1586 len
= VEC_length (tree
, SSANAMES (fn
));
1587 output_uleb128 (ob
, len
);
1589 for (i
= 1; i
< len
; i
++)
1591 tree ptr
= VEC_index (tree
, SSANAMES (fn
), i
);
1593 if (ptr
== NULL_TREE
1594 || SSA_NAME_IN_FREE_LIST (ptr
)
1595 || !is_gimple_reg (ptr
))
1598 output_uleb128 (ob
, i
);
1599 lto_output_1_stream (ob
->main_stream
, SSA_NAME_IS_DEFAULT_DEF (ptr
));
1600 lto_output_tree_ref (ob
, SSA_NAME_VAR (ptr
));
1607 /* Output the cfg. */
1610 output_cfg (struct output_block
*ob
, struct function
*fn
)
1612 struct lto_output_stream
*tmp_stream
= ob
->main_stream
;
1615 ob
->main_stream
= ob
->cfg_stream
;
1617 output_uleb128 (ob
, profile_status_for_function (fn
));
1619 /* Output the number of the highest basic block. */
1620 output_uleb128 (ob
, last_basic_block_for_function (fn
));
1622 FOR_ALL_BB_FN (bb
, fn
)
1627 output_sleb128 (ob
, bb
->index
);
1629 /* Output the successors and the edge flags. */
1630 output_uleb128 (ob
, EDGE_COUNT (bb
->succs
));
1631 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
1633 output_uleb128 (ob
, e
->dest
->index
);
1634 output_sleb128 (ob
, e
->probability
);
1635 output_sleb128 (ob
, e
->count
);
1636 output_uleb128 (ob
, e
->flags
);
1640 output_sleb128 (ob
, -1);
1642 bb
= ENTRY_BLOCK_PTR
;
1645 output_sleb128 (ob
, bb
->next_bb
->index
);
1649 output_sleb128 (ob
, -1);
1651 ob
->main_stream
= tmp_stream
;
1655 /* Output PHI function PHI to the main stream in OB. */
1658 output_phi (struct output_block
*ob
, gimple phi
)
1660 unsigned i
, len
= gimple_phi_num_args (phi
);
1662 output_record_start (ob
, lto_gimple_code_to_tag (GIMPLE_PHI
));
1663 output_uleb128 (ob
, SSA_NAME_VERSION (PHI_RESULT (phi
)));
1665 for (i
= 0; i
< len
; i
++)
1667 lto_output_tree_ref (ob
, gimple_phi_arg_def (phi
, i
));
1668 output_uleb128 (ob
, gimple_phi_arg_edge (phi
, i
)->src
->index
);
1669 lto_output_location (ob
, gimple_phi_arg_location (phi
, i
));
1674 /* Emit statement STMT on the main stream of output block OB. */
1677 output_gimple_stmt (struct output_block
*ob
, gimple stmt
)
1680 enum gimple_code code
;
1682 struct bitpack_d bp
;
1684 /* Emit identifying tag. */
1685 code
= gimple_code (stmt
);
1686 tag
= lto_gimple_code_to_tag (code
);
1687 output_record_start (ob
, tag
);
1689 /* Emit the tuple header. */
1690 bp
= bitpack_create (ob
->main_stream
);
1691 bp_pack_value (&bp
, gimple_num_ops (stmt
), sizeof (unsigned) * 8);
1692 bp_pack_value (&bp
, gimple_no_warning_p (stmt
), 1);
1693 if (is_gimple_assign (stmt
))
1694 bp_pack_value (&bp
, gimple_assign_nontemporal_move_p (stmt
), 1);
1695 bp_pack_value (&bp
, gimple_has_volatile_ops (stmt
), 1);
1696 bp_pack_value (&bp
, stmt
->gsbase
.subcode
, 16);
1697 lto_output_bitpack (&bp
);
1699 /* Emit location information for the statement. */
1700 lto_output_location (ob
, gimple_location (stmt
));
1702 /* Emit the lexical block holding STMT. */
1703 lto_output_tree (ob
, gimple_block (stmt
), true);
1705 /* Emit the operands. */
1706 switch (gimple_code (stmt
))
1709 output_sleb128 (ob
, gimple_resx_region (stmt
));
1712 case GIMPLE_EH_MUST_NOT_THROW
:
1713 lto_output_tree_ref (ob
, gimple_eh_must_not_throw_fndecl (stmt
));
1716 case GIMPLE_EH_DISPATCH
:
1717 output_sleb128 (ob
, gimple_eh_dispatch_region (stmt
));
1721 lto_output_uleb128_stream (ob
->main_stream
, gimple_asm_ninputs (stmt
));
1722 lto_output_uleb128_stream (ob
->main_stream
, gimple_asm_noutputs (stmt
));
1723 lto_output_uleb128_stream (ob
->main_stream
, gimple_asm_nclobbers (stmt
));
1724 lto_output_uleb128_stream (ob
->main_stream
, gimple_asm_nlabels (stmt
));
1725 lto_output_string (ob
, ob
->main_stream
, gimple_asm_string (stmt
));
1736 for (i
= 0; i
< gimple_num_ops (stmt
); i
++)
1738 tree op
= gimple_op (stmt
, i
);
1739 /* Wrap all uses of non-automatic variables inside MEM_REFs
1740 so that we do not have to deal with type mismatches on
1741 merged symbols during IL read in. The first operand
1742 of GIMPLE_DEBUG must be a decl, not MEM_REF, though. */
1743 if (op
&& (i
|| !is_gimple_debug (stmt
)))
1746 while (handled_component_p (*basep
))
1747 basep
= &TREE_OPERAND (*basep
, 0);
1748 if (TREE_CODE (*basep
) == VAR_DECL
1749 && !auto_var_in_fn_p (*basep
, current_function_decl
)
1750 && !DECL_REGISTER (*basep
))
1752 bool volatilep
= TREE_THIS_VOLATILE (*basep
);
1753 *basep
= build2 (MEM_REF
, TREE_TYPE (*basep
),
1754 build_fold_addr_expr (*basep
),
1755 build_int_cst (build_pointer_type
1756 (TREE_TYPE (*basep
)), 0));
1757 TREE_THIS_VOLATILE (*basep
) = volatilep
;
1760 lto_output_tree_ref (ob
, op
);
1762 if (is_gimple_call (stmt
))
1763 lto_output_tree_ref (ob
, gimple_call_fntype (stmt
));
1767 case GIMPLE_PREDICT
:
1776 /* Output a basic block BB to the main stream in OB for this FN. */
1779 output_bb (struct output_block
*ob
, basic_block bb
, struct function
*fn
)
1781 gimple_stmt_iterator bsi
= gsi_start_bb (bb
);
1783 output_record_start (ob
,
1784 (!gsi_end_p (bsi
)) || phi_nodes (bb
)
1788 output_uleb128 (ob
, bb
->index
);
1789 output_sleb128 (ob
, bb
->count
);
1790 output_sleb128 (ob
, bb
->loop_depth
);
1791 output_sleb128 (ob
, bb
->frequency
);
1792 output_sleb128 (ob
, bb
->flags
);
1794 if (!gsi_end_p (bsi
) || phi_nodes (bb
))
1796 /* Output the statements. The list of statements is terminated
1798 for (bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
1801 gimple stmt
= gsi_stmt (bsi
);
1803 output_gimple_stmt (ob
, stmt
);
1805 /* Emit the EH region holding STMT. */
1806 region
= lookup_stmt_eh_lp_fn (fn
, stmt
);
1809 output_record_start (ob
, LTO_eh_region
);
1810 output_sleb128 (ob
, region
);
1818 for (bsi
= gsi_start_phis (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
1820 gimple phi
= gsi_stmt (bsi
);
1822 /* Only emit PHIs for gimple registers. PHI nodes for .MEM
1823 will be filled in on reading when the SSA form is
1825 if (is_gimple_reg (gimple_phi_result (phi
)))
1826 output_phi (ob
, phi
);
1833 /* Create the header in the file using OB. If the section type is for
1834 a function, set FN to the decl for that function. */
1837 produce_asm (struct output_block
*ob
, tree fn
)
1839 enum lto_section_type section_type
= ob
->section_type
;
1840 struct lto_function_header header
;
1842 struct lto_output_stream
*header_stream
;
1844 if (section_type
== LTO_section_function_body
)
1846 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fn
));
1847 section_name
= lto_get_section_name (section_type
, name
, NULL
);
1850 section_name
= lto_get_section_name (section_type
, NULL
, NULL
);
1852 lto_begin_section (section_name
, !flag_wpa
);
1853 free (section_name
);
1855 /* The entire header is stream computed here. */
1856 memset (&header
, 0, sizeof (struct lto_function_header
));
1858 /* Write the header. */
1859 header
.lto_header
.major_version
= LTO_major_version
;
1860 header
.lto_header
.minor_version
= LTO_minor_version
;
1861 header
.lto_header
.section_type
= section_type
;
1863 header
.compressed_size
= 0;
1865 if (section_type
== LTO_section_function_body
)
1866 header
.cfg_size
= ob
->cfg_stream
->total_size
;
1867 header
.main_size
= ob
->main_stream
->total_size
;
1868 header
.string_size
= ob
->string_stream
->total_size
;
1870 header_stream
= XCNEW (struct lto_output_stream
);
1871 lto_output_data_stream (header_stream
, &header
, sizeof header
);
1872 lto_write_stream (header_stream
);
1873 free (header_stream
);
1875 /* Put all of the gimple and the string table out the asm file as a
1877 if (section_type
== LTO_section_function_body
)
1878 lto_write_stream (ob
->cfg_stream
);
1879 lto_write_stream (ob
->main_stream
);
1880 lto_write_stream (ob
->string_stream
);
1886 /* Output the body of function NODE->DECL. */
1889 output_function (struct cgraph_node
*node
)
1891 struct bitpack_d bp
;
1893 struct function
*fn
;
1895 struct output_block
*ob
;
1899 function
= node
->decl
;
1900 fn
= DECL_STRUCT_FUNCTION (function
);
1901 ob
= create_output_block (LTO_section_function_body
);
1903 clear_line_info (ob
);
1904 ob
->cgraph_node
= node
;
1906 gcc_assert (current_function_decl
== NULL_TREE
&& cfun
== NULL
);
1908 /* Set current_function_decl and cfun. */
1909 current_function_decl
= function
;
1912 /* Make string 0 be a NULL string. */
1913 lto_output_1_stream (ob
->string_stream
, 0);
1915 output_record_start (ob
, LTO_function
);
1917 /* Write all the attributes for FN. */
1918 bp
= bitpack_create (ob
->main_stream
);
1919 bp_pack_value (&bp
, fn
->is_thunk
, 1);
1920 bp_pack_value (&bp
, fn
->has_local_explicit_reg_vars
, 1);
1921 bp_pack_value (&bp
, fn
->after_tree_profile
, 1);
1922 bp_pack_value (&bp
, fn
->returns_pcc_struct
, 1);
1923 bp_pack_value (&bp
, fn
->returns_struct
, 1);
1924 bp_pack_value (&bp
, fn
->can_throw_non_call_exceptions
, 1);
1925 bp_pack_value (&bp
, fn
->always_inline_functions_inlined
, 1);
1926 bp_pack_value (&bp
, fn
->after_inlining
, 1);
1927 bp_pack_value (&bp
, fn
->dont_save_pending_sizes_p
, 1);
1928 bp_pack_value (&bp
, fn
->stdarg
, 1);
1929 bp_pack_value (&bp
, fn
->has_nonlocal_label
, 1);
1930 bp_pack_value (&bp
, fn
->calls_alloca
, 1);
1931 bp_pack_value (&bp
, fn
->calls_setjmp
, 1);
1932 bp_pack_value (&bp
, fn
->va_list_fpr_size
, 8);
1933 bp_pack_value (&bp
, fn
->va_list_gpr_size
, 8);
1934 lto_output_bitpack (&bp
);
1936 /* Output the function start and end loci. */
1937 lto_output_location (ob
, fn
->function_start_locus
);
1938 lto_output_location (ob
, fn
->function_end_locus
);
1940 /* Output current IL state of the function. */
1941 output_uleb128 (ob
, fn
->curr_properties
);
1943 /* Output the static chain and non-local goto save area. */
1944 lto_output_tree_ref (ob
, fn
->static_chain_decl
);
1945 lto_output_tree_ref (ob
, fn
->nonlocal_goto_save_area
);
1947 /* Output all the local variables in the function. */
1948 output_sleb128 (ob
, VEC_length (tree
, fn
->local_decls
));
1949 FOR_EACH_VEC_ELT (tree
, fn
->local_decls
, i
, t
)
1950 lto_output_tree_ref (ob
, t
);
1952 /* Output the head of the arguments list. */
1953 lto_output_tree_ref (ob
, DECL_ARGUMENTS (function
));
1955 /* Output all the SSA names used in the function. */
1956 output_ssa_names (ob
, fn
);
1958 /* Output any exception handling regions. */
1959 output_eh_regions (ob
, fn
);
1961 /* Output DECL_INITIAL for the function, which contains the tree of
1963 lto_output_tree (ob
, DECL_INITIAL (function
), true);
1965 /* We will renumber the statements. The code that does this uses
1966 the same ordering that we use for serializing them so we can use
1967 the same code on the other end and not have to write out the
1968 statement numbers. We do not assign UIDs to PHIs here because
1969 virtual PHIs get re-computed on-the-fly which would make numbers
1971 set_gimple_stmt_max_uid (cfun
, 0);
1974 gimple_stmt_iterator gsi
;
1975 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1977 gimple stmt
= gsi_stmt (gsi
);
1978 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
1982 /* Output the code for the function. */
1983 FOR_ALL_BB_FN (bb
, fn
)
1984 output_bb (ob
, bb
, fn
);
1986 /* The terminator for this function. */
1989 output_cfg (ob
, fn
);
1991 /* Create a section to hold the pickled output of this function. */
1992 produce_asm (ob
, function
);
1994 destroy_output_block (ob
);
1996 current_function_decl
= NULL
;
2001 /* Used to pass data to trivally_defined_alias callback. */
2003 cgraph_node_set set
;
2004 varpool_node_set vset
;
2008 /* Return true if alias pair P belongs to the set of cgraph nodes in
2009 SET. If P is a an alias for a VAR_DECL, it can always be emitted.
2010 However, for FUNCTION_DECL aliases, we should only output the pair
2011 if it belongs to a function whose cgraph node is in SET.
2012 Otherwise, the LTRANS phase will get into trouble when finalizing
2013 aliases because the alias will refer to a function not defined in
2014 the file processed by LTRANS. */
2017 trivally_defined_alias (tree decl ATTRIBUTE_UNUSED
,
2018 tree target
, void *data
)
2020 struct sets
*set
= (struct sets
*) data
;
2021 struct cgraph_node
*fnode
= NULL
;
2022 struct varpool_node
*vnode
= NULL
;
2024 fnode
= cgraph_node_for_asm (target
);
2026 return cgraph_node_in_set_p (fnode
, set
->set
);
2027 vnode
= varpool_node_for_asm (target
);
2028 return vnode
&& varpool_node_in_set_p (vnode
, set
->vset
);
2031 /* Return true if alias pair P should be output in the current
2032 partition contains cgrpah nodes SET and varpool nodes VSET.
2033 DEFINED is set of all aliases whose targets are defined in
2036 Normal aliases are output when they are defined, while WEAKREF
2037 aliases are output when they are used. */
2040 output_alias_pair_p (alias_pair
*p
, symbol_alias_set_t
*defined
,
2041 cgraph_node_set set
, varpool_node_set vset
)
2043 struct cgraph_node
*node
;
2044 struct varpool_node
*vnode
;
2046 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (p
->decl
)))
2048 if (TREE_CODE (p
->decl
) == VAR_DECL
)
2050 vnode
= varpool_get_node (p
->decl
);
2052 && referenced_from_this_partition_p (&vnode
->ref_list
, set
, vset
));
2054 node
= cgraph_get_node (p
->decl
);
2056 && (referenced_from_this_partition_p (&node
->ref_list
, set
, vset
)
2057 || reachable_from_this_partition_p (node
, set
)));
2060 return symbol_alias_set_contains (defined
, p
->decl
);
2063 /* Output any unreferenced global symbol defined in SET, alias pairs
2067 output_unreferenced_globals (cgraph_node_set set
, varpool_node_set vset
)
2069 struct output_block
*ob
;
2072 symbol_alias_set_t
*defined
;
2073 struct sets setdata
;
2076 setdata
.vset
= vset
;
2078 ob
= create_output_block (LTO_section_static_initializer
);
2079 ob
->cgraph_node
= NULL
;
2081 clear_line_info (ob
);
2083 /* Make string 0 be a NULL string. */
2084 lto_output_1_stream (ob
->string_stream
, 0);
2086 /* We really need to propagate in both directoins:
2087 for normal aliases we propagate from first defined alias to
2088 all aliases defined based on it. For weakrefs we propagate in
2089 the oposite direction. */
2090 defined
= propagate_aliases_backward (trivally_defined_alias
, &setdata
);
2092 /* Emit the alias pairs for the nodes in SET. */
2093 FOR_EACH_VEC_ELT (alias_pair
, alias_pairs
, i
, p
)
2094 if (output_alias_pair_p (p
, defined
, set
, vset
))
2096 lto_output_tree_ref (ob
, p
->decl
);
2097 lto_output_tree_ref (ob
, p
->target
);
2099 symbol_alias_set_destroy (defined
);
2103 produce_asm (ob
, NULL
);
2104 destroy_output_block (ob
);
2108 /* Copy the function body of NODE without deserializing. */
2111 copy_function (struct cgraph_node
*node
)
2113 tree function
= node
->decl
;
2114 struct lto_file_decl_data
*file_data
= node
->local
.lto_file_data
;
2115 struct lto_output_stream
*output_stream
= XCNEW (struct lto_output_stream
);
2118 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (function
));
2119 char *section_name
=
2120 lto_get_section_name (LTO_section_function_body
, name
, NULL
);
2122 struct lto_in_decl_state
*in_state
;
2123 struct lto_out_decl_state
*out_state
= lto_get_out_decl_state ();
2125 lto_begin_section (section_name
, !flag_wpa
);
2126 free (section_name
);
2128 /* We may have renamed the declaration, e.g., a static function. */
2129 name
= lto_get_decl_name_mapping (file_data
, name
);
2131 data
= lto_get_section_data (file_data
, LTO_section_function_body
,
2135 /* Do a bit copy of the function body. */
2136 lto_output_data_stream (output_stream
, data
, len
);
2137 lto_write_stream (output_stream
);
2141 lto_get_function_in_decl_state (node
->local
.lto_file_data
, function
);
2142 gcc_assert (in_state
);
2144 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2146 size_t n
= in_state
->streams
[i
].size
;
2147 tree
*trees
= in_state
->streams
[i
].trees
;
2148 struct lto_tree_ref_encoder
*encoder
= &(out_state
->streams
[i
]);
2150 /* The out state must have the same indices and the in state.
2151 So just copy the vector. All the encoders in the in state
2152 must be empty where we reach here. */
2153 gcc_assert (lto_tree_ref_encoder_size (encoder
) == 0);
2154 for (j
= 0; j
< n
; j
++)
2155 VEC_safe_push (tree
, heap
, encoder
->trees
, trees
[j
]);
2156 encoder
->next_index
= n
;
2159 lto_free_section_data (file_data
, LTO_section_function_body
, name
,
2161 free (output_stream
);
2166 /* Initialize the LTO writer. */
2169 lto_writer_init (void)
2171 lto_streamer_init ();
2175 /* Main entry point from the pass manager. */
2178 lto_output (cgraph_node_set set
, varpool_node_set vset
)
2180 struct cgraph_node
*node
;
2181 struct lto_out_decl_state
*decl_state
;
2182 #ifdef ENABLE_CHECKING
2183 bitmap output
= lto_bitmap_alloc ();
2186 lto_cgraph_encoder_t encoder
= lto_get_out_decl_state ()->cgraph_node_encoder
;
2190 n_nodes
= lto_cgraph_encoder_size (encoder
);
2191 /* Process only the functions with bodies. */
2192 for (i
= 0; i
< n_nodes
; i
++)
2194 node
= lto_cgraph_encoder_deref (encoder
, i
);
2195 if (lto_cgraph_encoder_encode_body_p (encoder
, node
))
2197 #ifdef ENABLE_CHECKING
2198 gcc_assert (!bitmap_bit_p (output
, DECL_UID (node
->decl
)));
2199 bitmap_set_bit (output
, DECL_UID (node
->decl
));
2201 decl_state
= lto_new_out_decl_state ();
2202 lto_push_out_decl_state (decl_state
);
2203 if (gimple_has_body_p (node
->decl
))
2204 output_function (node
);
2206 copy_function (node
);
2207 gcc_assert (lto_get_out_decl_state () == decl_state
);
2208 lto_pop_out_decl_state ();
2209 lto_record_function_out_decl_state (node
->decl
, decl_state
);
2213 /* Emit the callgraph after emitting function bodies. This needs to
2214 be done now to make sure that all the statements in every function
2215 have been renumbered so that edges can be associated with call
2216 statements using the statement UIDs. */
2217 output_cgraph (set
, vset
);
2219 #ifdef ENABLE_CHECKING
2220 lto_bitmap_free (output
);
2224 struct ipa_opt_pass_d pass_ipa_lto_gimple_out
=
2228 "lto_gimple_out", /* name */
2229 gate_lto_out
, /* gate */
2233 0, /* static_pass_number */
2234 TV_IPA_LTO_GIMPLE_OUT
, /* tv_id */
2235 0, /* properties_required */
2236 0, /* properties_provided */
2237 0, /* properties_destroyed */
2238 0, /* todo_flags_start */
2239 TODO_dump_func
/* todo_flags_finish */
2241 NULL
, /* generate_summary */
2242 lto_output
, /* write_summary */
2243 NULL
, /* read_summary */
2244 lto_output
, /* write_optimization_summary */
2245 NULL
, /* read_optimization_summary */
2246 NULL
, /* stmt_fixup */
2248 NULL
, /* function_transform */
2249 NULL
/* variable_transform */
2253 /* Write each node in encoded by ENCODER to OB, as well as those reachable
2254 from it and required for correct representation of its semantics.
2255 Each node in ENCODER must be a global declaration or a type. A node
2256 is written only once, even if it appears multiple times in the
2257 vector. Certain transitively-reachable nodes, such as those
2258 representing expressions, may be duplicated, but such nodes
2259 must not appear in ENCODER itself. */
2262 write_global_stream (struct output_block
*ob
,
2263 struct lto_tree_ref_encoder
*encoder
)
2267 const size_t size
= lto_tree_ref_encoder_size (encoder
);
2269 for (index
= 0; index
< size
; index
++)
2271 t
= lto_tree_ref_encoder_get_tree (encoder
, index
);
2272 if (!lto_streamer_cache_lookup (ob
->writer_cache
, t
, NULL
))
2273 lto_output_tree (ob
, t
, false);
2278 /* Write a sequence of indices into the globals vector corresponding
2279 to the trees in ENCODER. These are used by the reader to map the
2280 indices used to refer to global entities within function bodies to
2284 write_global_references (struct output_block
*ob
,
2285 struct lto_output_stream
*ref_stream
,
2286 struct lto_tree_ref_encoder
*encoder
)
2290 const uint32_t size
= lto_tree_ref_encoder_size (encoder
);
2292 /* Write size as 32-bit unsigned. */
2293 lto_output_data_stream (ref_stream
, &size
, sizeof (int32_t));
2295 for (index
= 0; index
< size
; index
++)
2299 t
= lto_tree_ref_encoder_get_tree (encoder
, index
);
2300 lto_streamer_cache_lookup (ob
->writer_cache
, t
, &slot_num
);
2301 gcc_assert (slot_num
!= (unsigned)-1);
2302 lto_output_data_stream (ref_stream
, &slot_num
, sizeof slot_num
);
2307 /* Write all the streams in an lto_out_decl_state STATE using
2308 output block OB and output stream OUT_STREAM. */
2311 lto_output_decl_state_streams (struct output_block
*ob
,
2312 struct lto_out_decl_state
*state
)
2316 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2317 write_global_stream (ob
, &state
->streams
[i
]);
2321 /* Write all the references in an lto_out_decl_state STATE using
2322 output block OB and output stream OUT_STREAM. */
2325 lto_output_decl_state_refs (struct output_block
*ob
,
2326 struct lto_output_stream
*out_stream
,
2327 struct lto_out_decl_state
*state
)
2333 /* Write reference to FUNCTION_DECL. If there is not function,
2334 write reference to void_type_node. */
2335 decl
= (state
->fn_decl
) ? state
->fn_decl
: void_type_node
;
2336 lto_streamer_cache_lookup (ob
->writer_cache
, decl
, &ref
);
2337 gcc_assert (ref
!= (unsigned)-1);
2338 lto_output_data_stream (out_stream
, &ref
, sizeof (uint32_t));
2340 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2341 write_global_references (ob
, out_stream
, &state
->streams
[i
]);
2345 /* Return the written size of STATE. */
2348 lto_out_decl_state_written_size (struct lto_out_decl_state
*state
)
2353 size
= sizeof (int32_t); /* fn_ref. */
2354 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2356 size
+= sizeof (int32_t); /* vector size. */
2357 size
+= (lto_tree_ref_encoder_size (&state
->streams
[i
])
2358 * sizeof (int32_t));
2364 /* Write symbol T into STREAM in CACHE. SEEN specifies symbols we wrote
2368 write_symbol (struct lto_streamer_cache_d
*cache
,
2369 struct lto_output_stream
*stream
,
2370 tree t
, struct pointer_set_t
*seen
, bool alias
)
2373 enum gcc_plugin_symbol_kind kind
;
2374 enum gcc_plugin_symbol_visibility visibility
;
2380 /* None of the following kinds of symbols are needed in the
2382 if (!TREE_PUBLIC (t
)
2383 || is_builtin_fn (t
)
2384 || DECL_ABSTRACT (t
)
2385 || TREE_CODE (t
) == RESULT_DECL
)
2388 gcc_assert (TREE_CODE (t
) == VAR_DECL
2389 || TREE_CODE (t
) == FUNCTION_DECL
);
2391 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (t
));
2393 /* This behaves like assemble_name_raw in varasm.c, performing the
2394 same name manipulations that ASM_OUTPUT_LABELREF does. */
2395 name
= IDENTIFIER_POINTER ((*targetm
.asm_out
.mangle_assembler_name
) (name
));
2397 if (pointer_set_contains (seen
, name
))
2399 pointer_set_insert (seen
, name
);
2401 lto_streamer_cache_lookup (cache
, t
, &slot_num
);
2402 gcc_assert (slot_num
!= (unsigned)-1);
2404 if (DECL_EXTERNAL (t
))
2407 kind
= GCCPK_WEAKUNDEF
;
2414 kind
= GCCPK_WEAKDEF
;
2415 else if (DECL_COMMON (t
))
2416 kind
= GCCPK_COMMON
;
2420 /* When something is defined, it should have node attached. */
2421 gcc_assert (alias
|| TREE_CODE (t
) != VAR_DECL
2422 || varpool_get_node (t
)->finalized
);
2423 gcc_assert (alias
|| TREE_CODE (t
) != FUNCTION_DECL
2424 || (cgraph_get_node (t
)
2425 && cgraph_get_node (t
)->analyzed
));
2428 /* Imitate what default_elf_asm_output_external do.
2429 When symbol is external, we need to output it with DEFAULT visibility
2430 when compiling with -fvisibility=default, while with HIDDEN visibility
2431 when symbol has attribute (visibility("hidden")) specified.
2432 targetm.binds_local_p check DECL_VISIBILITY_SPECIFIED and gets this
2435 if (DECL_EXTERNAL (t
)
2436 && !targetm
.binds_local_p (t
))
2437 visibility
= GCCPV_DEFAULT
;
2439 switch (DECL_VISIBILITY(t
))
2441 case VISIBILITY_DEFAULT
:
2442 visibility
= GCCPV_DEFAULT
;
2444 case VISIBILITY_PROTECTED
:
2445 visibility
= GCCPV_PROTECTED
;
2447 case VISIBILITY_HIDDEN
:
2448 visibility
= GCCPV_HIDDEN
;
2450 case VISIBILITY_INTERNAL
:
2451 visibility
= GCCPV_INTERNAL
;
2455 if (kind
== GCCPK_COMMON
2457 && TREE_CODE (DECL_SIZE (t
)) == INTEGER_CST
)
2459 size
= (HOST_BITS_PER_WIDE_INT
>= 64)
2460 ? (uint64_t) int_size_in_bytes (TREE_TYPE (t
))
2461 : (((uint64_t) TREE_INT_CST_HIGH (DECL_SIZE_UNIT (t
))) << 32)
2462 | TREE_INT_CST_LOW (DECL_SIZE_UNIT (t
));
2467 if (DECL_ONE_ONLY (t
))
2468 comdat
= IDENTIFIER_POINTER (DECL_COMDAT_GROUP (t
));
2472 lto_output_data_stream (stream
, name
, strlen (name
) + 1);
2473 lto_output_data_stream (stream
, comdat
, strlen (comdat
) + 1);
2474 c
= (unsigned char) kind
;
2475 lto_output_data_stream (stream
, &c
, 1);
2476 c
= (unsigned char) visibility
;
2477 lto_output_data_stream (stream
, &c
, 1);
2478 lto_output_data_stream (stream
, &size
, 8);
2479 lto_output_data_stream (stream
, &slot_num
, 4);
2483 /* Write an IL symbol table to OB.
2484 SET and VSET are cgraph/varpool node sets we are outputting. */
2487 produce_symtab (struct output_block
*ob
,
2488 cgraph_node_set set
, varpool_node_set vset
)
2490 struct lto_streamer_cache_d
*cache
= ob
->writer_cache
;
2491 char *section_name
= lto_get_section_name (LTO_section_symtab
, NULL
, NULL
);
2492 struct pointer_set_t
*seen
;
2493 struct cgraph_node
*node
, *alias
;
2494 struct varpool_node
*vnode
, *valias
;
2495 struct lto_output_stream stream
;
2496 lto_varpool_encoder_t varpool_encoder
= ob
->decl_state
->varpool_node_encoder
;
2497 lto_cgraph_encoder_t encoder
= ob
->decl_state
->cgraph_node_encoder
;
2500 struct sets setdata
;
2501 symbol_alias_set_t
*defined
;
2504 setdata
.vset
= vset
;
2506 lto_begin_section (section_name
, false);
2507 free (section_name
);
2509 seen
= pointer_set_create ();
2510 memset (&stream
, 0, sizeof (stream
));
2512 /* Write all functions.
2513 First write all defined functions and then write all used functions.
2514 This is done so only to handle duplicated symbols in cgraph. */
2515 for (i
= 0; i
< lto_cgraph_encoder_size (encoder
); i
++)
2517 node
= lto_cgraph_encoder_deref (encoder
, i
);
2518 if (DECL_EXTERNAL (node
->decl
))
2520 if (DECL_COMDAT (node
->decl
)
2521 && cgraph_comdat_can_be_unshared_p (node
))
2523 if (node
->alias
|| node
->global
.inlined_to
)
2525 write_symbol (cache
, &stream
, node
->decl
, seen
, false);
2526 for (alias
= node
->same_body
; alias
; alias
= alias
->next
)
2527 write_symbol (cache
, &stream
, alias
->decl
, seen
, true);
2529 for (i
= 0; i
< lto_cgraph_encoder_size (encoder
); i
++)
2531 node
= lto_cgraph_encoder_deref (encoder
, i
);
2532 if (!DECL_EXTERNAL (node
->decl
))
2534 if (DECL_COMDAT (node
->decl
)
2535 && cgraph_comdat_can_be_unshared_p (node
))
2537 if (node
->alias
|| node
->global
.inlined_to
)
2539 write_symbol (cache
, &stream
, node
->decl
, seen
, false);
2540 for (alias
= node
->same_body
; alias
; alias
= alias
->next
)
2541 write_symbol (cache
, &stream
, alias
->decl
, seen
, true);
2544 /* Write all variables. */
2545 for (i
= 0; i
< lto_varpool_encoder_size (varpool_encoder
); i
++)
2547 vnode
= lto_varpool_encoder_deref (varpool_encoder
, i
);
2548 if (DECL_EXTERNAL (vnode
->decl
))
2550 /* COMDAT virtual tables can be unshared. Do not declare them
2551 in the LTO symbol table to prevent linker from forcing them
2553 if (DECL_COMDAT (vnode
->decl
)
2554 && !vnode
->force_output
2556 && DECL_VIRTUAL_P (vnode
->decl
))
2560 write_symbol (cache
, &stream
, vnode
->decl
, seen
, false);
2561 for (valias
= vnode
->extra_name
; valias
; valias
= valias
->next
)
2562 write_symbol (cache
, &stream
, valias
->decl
, seen
, true);
2564 for (i
= 0; i
< lto_varpool_encoder_size (varpool_encoder
); i
++)
2566 vnode
= lto_varpool_encoder_deref (varpool_encoder
, i
);
2567 if (!DECL_EXTERNAL (vnode
->decl
))
2569 if (DECL_COMDAT (vnode
->decl
)
2570 && !vnode
->force_output
2572 && DECL_VIRTUAL_P (vnode
->decl
))
2576 write_symbol (cache
, &stream
, vnode
->decl
, seen
, false);
2577 for (valias
= vnode
->extra_name
; valias
; valias
= valias
->next
)
2578 write_symbol (cache
, &stream
, valias
->decl
, seen
, true);
2581 /* Write all aliases. */
2582 defined
= propagate_aliases_backward (trivally_defined_alias
, &setdata
);
2583 FOR_EACH_VEC_ELT (alias_pair
, alias_pairs
, i
, p
)
2584 if (output_alias_pair_p (p
, defined
, set
, vset
))
2585 write_symbol (cache
, &stream
, p
->decl
, seen
, true);
2586 symbol_alias_set_destroy (defined
);
2588 lto_write_stream (&stream
);
2589 pointer_set_destroy (seen
);
2595 /* This pass is run after all of the functions are serialized and all
2596 of the IPA passes have written their serialized forms. This pass
2597 causes the vector of all of the global decls and types used from
2598 this file to be written in to a section that can then be read in to
2599 recover these on other side. */
2602 produce_asm_for_decls (cgraph_node_set set
, varpool_node_set vset
)
2604 struct lto_out_decl_state
*out_state
;
2605 struct lto_out_decl_state
*fn_out_state
;
2606 struct lto_decl_header header
;
2608 struct output_block
*ob
;
2609 struct lto_output_stream
*header_stream
, *decl_state_stream
;
2610 unsigned idx
, num_fns
;
2611 size_t decl_state_size
;
2612 int32_t num_decl_states
;
2614 ob
= create_output_block (LTO_section_decls
);
2617 /* Write out unreferenced globals, alias pairs and labels. We defer
2618 doing this until now so that we can write out only what is
2620 output_unreferenced_globals (set
, vset
);
2622 memset (&header
, 0, sizeof (struct lto_decl_header
));
2624 section_name
= lto_get_section_name (LTO_section_decls
, NULL
, NULL
);
2625 lto_begin_section (section_name
, !flag_wpa
);
2626 free (section_name
);
2628 /* Make string 0 be a NULL string. */
2629 lto_output_1_stream (ob
->string_stream
, 0);
2631 /* Write the global symbols. */
2632 out_state
= lto_get_out_decl_state ();
2633 num_fns
= VEC_length (lto_out_decl_state_ptr
, lto_function_decl_states
);
2634 lto_output_decl_state_streams (ob
, out_state
);
2635 for (idx
= 0; idx
< num_fns
; idx
++)
2638 VEC_index (lto_out_decl_state_ptr
, lto_function_decl_states
, idx
);
2639 lto_output_decl_state_streams (ob
, fn_out_state
);
2642 header
.lto_header
.major_version
= LTO_major_version
;
2643 header
.lto_header
.minor_version
= LTO_minor_version
;
2644 header
.lto_header
.section_type
= LTO_section_decls
;
2646 /* Currently not used. This field would allow us to preallocate
2647 the globals vector, so that it need not be resized as it is extended. */
2648 header
.num_nodes
= -1;
2650 /* Compute the total size of all decl out states. */
2651 decl_state_size
= sizeof (int32_t);
2652 decl_state_size
+= lto_out_decl_state_written_size (out_state
);
2653 for (idx
= 0; idx
< num_fns
; idx
++)
2656 VEC_index (lto_out_decl_state_ptr
, lto_function_decl_states
, idx
);
2657 decl_state_size
+= lto_out_decl_state_written_size (fn_out_state
);
2659 header
.decl_state_size
= decl_state_size
;
2661 header
.main_size
= ob
->main_stream
->total_size
;
2662 header
.string_size
= ob
->string_stream
->total_size
;
2664 header_stream
= XCNEW (struct lto_output_stream
);
2665 lto_output_data_stream (header_stream
, &header
, sizeof header
);
2666 lto_write_stream (header_stream
);
2667 free (header_stream
);
2669 /* Write the main out-decl state, followed by out-decl states of
2671 decl_state_stream
= ((struct lto_output_stream
*)
2672 xcalloc (1, sizeof (struct lto_output_stream
)));
2673 num_decl_states
= num_fns
+ 1;
2674 lto_output_data_stream (decl_state_stream
, &num_decl_states
,
2675 sizeof (num_decl_states
));
2676 lto_output_decl_state_refs (ob
, decl_state_stream
, out_state
);
2677 for (idx
= 0; idx
< num_fns
; idx
++)
2680 VEC_index (lto_out_decl_state_ptr
, lto_function_decl_states
, idx
);
2681 lto_output_decl_state_refs (ob
, decl_state_stream
, fn_out_state
);
2683 lto_write_stream (decl_state_stream
);
2684 free(decl_state_stream
);
2686 lto_write_stream (ob
->main_stream
);
2687 lto_write_stream (ob
->string_stream
);
2691 /* Write the symbol table. It is used by linker to determine dependencies
2692 and thus we can skip it for WPA. */
2694 produce_symtab (ob
, set
, vset
);
2696 /* Write command line opts. */
2697 lto_write_options ();
2699 /* Deallocate memory and clean up. */
2700 for (idx
= 0; idx
< num_fns
; idx
++)
2703 VEC_index (lto_out_decl_state_ptr
, lto_function_decl_states
, idx
);
2704 lto_delete_out_decl_state (fn_out_state
);
2706 lto_cgraph_encoder_delete (ob
->decl_state
->cgraph_node_encoder
);
2707 lto_varpool_encoder_delete (ob
->decl_state
->varpool_node_encoder
);
2708 VEC_free (lto_out_decl_state_ptr
, heap
, lto_function_decl_states
);
2709 lto_function_decl_states
= NULL
;
2710 destroy_output_block (ob
);
2714 struct ipa_opt_pass_d pass_ipa_lto_finish_out
=
2718 "lto_decls_out", /* name */
2719 gate_lto_out
, /* gate */
2723 0, /* static_pass_number */
2724 TV_IPA_LTO_DECL_OUT
, /* tv_id */
2725 0, /* properties_required */
2726 0, /* properties_provided */
2727 0, /* properties_destroyed */
2728 0, /* todo_flags_start */
2729 0 /* todo_flags_finish */
2731 NULL
, /* generate_summary */
2732 produce_asm_for_decls
, /* write_summary */
2733 NULL
, /* read_summary */
2734 produce_asm_for_decls
, /* write_optimization_summary */
2735 NULL
, /* read_optimization_summary */
2736 NULL
, /* stmt_fixup */
2738 NULL
, /* function_transform */
2739 NULL
/* variable_transform */