1/* Routines for emitting trees to a file stream. 2 3 Copyright (C) 2011-2015 Free Software Foundation, Inc. 4 Contributed by Diego Novillo <dnovillo@google.com> 5 6This file is part of GCC. 7 8GCC is free software; you can redistribute it and/or modify it under 9the terms of the GNU General Public License as published by the Free 10Software Foundation; either version 3, or (at your option) any later 11version. 12 13GCC is distributed in the hope that it will be useful, but WITHOUT ANY 14WARRANTY; without even the implied warranty of MERCHANTABILITY or 15FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 16for more details. 17 18You should have received a copy of the GNU General Public License 19along with GCC; see the file COPYING3. If not see 20<http://www.gnu.org/licenses/>. */ 21 22#include "config.h" 23#include "system.h" 24#include "coretypes.h" 25#include "tm.h" 26#include "diagnostic.h" 27#include "hash-set.h" 28#include "machmode.h" 29#include "vec.h" 30#include "double-int.h" 31#include "input.h" 32#include "alias.h" 33#include "symtab.h" 34#include "wide-int.h" 35#include "inchash.h" 36#include "real.h" 37#include "fixed-value.h" 38#include "tree.h" 39#include "fold-const.h" 40#include "stor-layout.h" 41#include "predict.h" 42#include "hard-reg-set.h" 43#include "input.h" 44#include "function.h" 45#include "basic-block.h" 46#include "tree-ssa-alias.h" 47#include "internal-fn.h" 48#include "gimple-expr.h" 49#include "is-a.h" 50#include "gimple.h" 51#include "hash-map.h" 52#include "plugin-api.h" 53#include "ipa-ref.h" 54#include "cgraph.h" 55#include "tree-streamer.h" 56#include "data-streamer.h" 57#include "streamer-hooks.h" 58#include "gomp-constants.h" 59 60 61/* Output the STRING constant to the string 62 table in OB. Then put the index onto the INDEX_STREAM. */ 63 64void 65streamer_write_string_cst (struct output_block *ob, 66 struct lto_output_stream *index_stream, 67 tree string) 68{ 69 streamer_write_string_with_length (ob, index_stream, 70 string ? TREE_STRING_POINTER (string) 71 : NULL, 72 string ? TREE_STRING_LENGTH (string) : 0, 73 true); 74} 75 76 77/* Output the identifier ID to the string 78 table in OB. Then put the index onto the INDEX_STREAM. */ 79 80static void 81write_identifier (struct output_block *ob, 82 struct lto_output_stream *index_stream, 83 tree id) 84{ 85 streamer_write_string_with_length (ob, index_stream, 86 IDENTIFIER_POINTER (id), 87 IDENTIFIER_LENGTH (id), 88 true); 89} 90 91 92/* Pack all the non-pointer fields of the TS_BASE structure of 93 expression EXPR into bitpack BP. */ 94 95static inline void 96pack_ts_base_value_fields (struct bitpack_d *bp, tree expr) 97{ 98 bp_pack_value (bp, TREE_CODE (expr), 16); 99 if (!TYPE_P (expr)) 100 { 101 bp_pack_value (bp, TREE_SIDE_EFFECTS (expr), 1); 102 bp_pack_value (bp, TREE_CONSTANT (expr), 1); 103 bp_pack_value (bp, TREE_READONLY (expr), 1); 104 105 /* TREE_PUBLIC is used on types to indicate that the type 106 has a TYPE_CACHED_VALUES vector. This is not streamed out, 107 so we skip it here. */ 108 bp_pack_value (bp, TREE_PUBLIC (expr), 1); 109 } 110 else 111 bp_pack_value (bp, 0, 4); 112 bp_pack_value (bp, TREE_ADDRESSABLE (expr), 1); 113 bp_pack_value (bp, TREE_THIS_VOLATILE (expr), 1); 114 if (DECL_P (expr)) 115 bp_pack_value (bp, DECL_UNSIGNED (expr), 1); 116 else if (TYPE_P (expr)) 117 bp_pack_value (bp, TYPE_UNSIGNED (expr), 1); 118 else 119 bp_pack_value (bp, 0, 1); 120 /* We write debug info two times, do not confuse the second one. 121 The only relevant TREE_ASM_WRITTEN use is on SSA names. */ 122 bp_pack_value (bp, (TREE_CODE (expr) != SSA_NAME 123 ? 0 : TREE_ASM_WRITTEN (expr)), 1); 124 if (TYPE_P (expr)) 125 bp_pack_value (bp, TYPE_ARTIFICIAL (expr), 1); 126 else 127 bp_pack_value (bp, TREE_NO_WARNING (expr), 1); 128 bp_pack_value (bp, TREE_NOTHROW (expr), 1); 129 bp_pack_value (bp, TREE_STATIC (expr), 1); 130 if (TREE_CODE (expr) != TREE_BINFO) 131 bp_pack_value (bp, TREE_PRIVATE (expr), 1); 132 else 133 bp_pack_value (bp, 0, 1); 134 bp_pack_value (bp, TREE_PROTECTED (expr), 1); 135 bp_pack_value (bp, TREE_DEPRECATED (expr), 1); 136 if (TYPE_P (expr)) 137 { 138 bp_pack_value (bp, TYPE_SATURATING (expr), 1); 139 bp_pack_value (bp, TYPE_ADDR_SPACE (expr), 8); 140 } 141 else if (TREE_CODE (expr) == SSA_NAME) 142 { 143 bp_pack_value (bp, SSA_NAME_IS_DEFAULT_DEF (expr), 1); 144 bp_pack_value (bp, 0, 8); 145 } 146 else 147 bp_pack_value (bp, 0, 9); 148} 149 150 151/* Pack all the non-pointer fields of the TS_INTEGER_CST structure of 152 expression EXPR into bitpack BP. */ 153 154static void 155pack_ts_int_cst_value_fields (struct bitpack_d *bp, tree expr) 156{ 157 int i; 158 /* Note that the number of elements has already been written out in 159 streamer_write_tree_header. */ 160 for (i = 0; i < TREE_INT_CST_EXT_NUNITS (expr); i++) 161 bp_pack_var_len_int (bp, TREE_INT_CST_ELT (expr, i)); 162} 163 164 165/* Pack all the non-pointer fields of the TS_REAL_CST structure of 166 expression EXPR into bitpack BP. */ 167 168static void 169pack_ts_real_cst_value_fields (struct bitpack_d *bp, tree expr) 170{ 171 unsigned i; 172 REAL_VALUE_TYPE r; 173 174 r = TREE_REAL_CST (expr); 175 bp_pack_value (bp, r.cl, 2); 176 bp_pack_value (bp, r.decimal, 1); 177 bp_pack_value (bp, r.sign, 1); 178 bp_pack_value (bp, r.signalling, 1); 179 bp_pack_value (bp, r.canonical, 1); 180 bp_pack_value (bp, r.uexp, EXP_BITS); 181 for (i = 0; i < SIGSZ; i++) 182 bp_pack_value (bp, r.sig[i], HOST_BITS_PER_LONG); 183} 184 185 186/* Pack all the non-pointer fields of the TS_FIXED_CST structure of 187 expression EXPR into bitpack BP. */ 188 189static void 190pack_ts_fixed_cst_value_fields (struct bitpack_d *bp, tree expr) 191{ 192 struct fixed_value fv = TREE_FIXED_CST (expr); 193 bp_pack_machine_mode (bp, fv.mode); 194 bp_pack_var_len_int (bp, fv.data.low); 195 bp_pack_var_len_int (bp, fv.data.high); 196} 197 198/* Pack all the non-pointer fields of the TS_DECL_COMMON structure 199 of expression EXPR into bitpack BP. */ 200 201static void 202pack_ts_decl_common_value_fields (struct bitpack_d *bp, tree expr) 203{ 204 bp_pack_machine_mode (bp, DECL_MODE (expr)); 205 bp_pack_value (bp, DECL_NONLOCAL (expr), 1); 206 bp_pack_value (bp, DECL_VIRTUAL_P (expr), 1); 207 bp_pack_value (bp, DECL_IGNORED_P (expr), 1); 208 bp_pack_value (bp, DECL_ABSTRACT_P (expr), 1); 209 bp_pack_value (bp, DECL_ARTIFICIAL (expr), 1); 210 bp_pack_value (bp, DECL_USER_ALIGN (expr), 1); 211 bp_pack_value (bp, DECL_PRESERVE_P (expr), 1); 212 bp_pack_value (bp, DECL_EXTERNAL (expr), 1); 213 bp_pack_value (bp, DECL_GIMPLE_REG_P (expr), 1); 214 bp_pack_var_len_unsigned (bp, DECL_ALIGN (expr)); 215 216 if (TREE_CODE (expr) == LABEL_DECL) 217 { 218 /* Note that we do not write LABEL_DECL_UID. The reader will 219 always assume an initial value of -1 so that the 220 label_to_block_map is recreated by gimple_set_bb. */ 221 bp_pack_var_len_unsigned (bp, EH_LANDING_PAD_NR (expr)); 222 } 223 224 if (TREE_CODE (expr) == FIELD_DECL) 225 { 226 bp_pack_value (bp, DECL_PACKED (expr), 1); 227 bp_pack_value (bp, DECL_NONADDRESSABLE_P (expr), 1); 228 bp_pack_value (bp, expr->decl_common.off_align, 8); 229 } 230 231 if (TREE_CODE (expr) == VAR_DECL) 232 { 233 bp_pack_value (bp, DECL_HAS_DEBUG_EXPR_P (expr), 1); 234 bp_pack_value (bp, DECL_NONLOCAL_FRAME (expr), 1); 235 } 236 237 if (TREE_CODE (expr) == RESULT_DECL 238 || TREE_CODE (expr) == PARM_DECL 239 || TREE_CODE (expr) == VAR_DECL) 240 { 241 bp_pack_value (bp, DECL_BY_REFERENCE (expr), 1); 242 if (TREE_CODE (expr) == VAR_DECL 243 || TREE_CODE (expr) == PARM_DECL) 244 bp_pack_value (bp, DECL_HAS_VALUE_EXPR_P (expr), 1); 245 } 246} 247 248 249/* Pack all the non-pointer fields of the TS_DECL_WRTL structure 250 of expression EXPR into bitpack BP. */ 251 252static void 253pack_ts_decl_wrtl_value_fields (struct bitpack_d *bp, tree expr) 254{ 255 bp_pack_value (bp, DECL_REGISTER (expr), 1); 256} 257 258 259/* Pack all the non-pointer fields of the TS_DECL_WITH_VIS structure 260 of expression EXPR into bitpack BP. */ 261 262static void 263pack_ts_decl_with_vis_value_fields (struct bitpack_d *bp, tree expr) 264{ 265 bp_pack_value (bp, DECL_COMMON (expr), 1); 266 bp_pack_value (bp, DECL_DLLIMPORT_P (expr), 1); 267 bp_pack_value (bp, DECL_WEAK (expr), 1); 268 bp_pack_value (bp, DECL_SEEN_IN_BIND_EXPR_P (expr), 1); 269 bp_pack_value (bp, DECL_COMDAT (expr), 1); 270 bp_pack_value (bp, DECL_VISIBILITY (expr), 2); 271 bp_pack_value (bp, DECL_VISIBILITY_SPECIFIED (expr), 1); 272 273 if (TREE_CODE (expr) == VAR_DECL) 274 { 275 bp_pack_value (bp, DECL_HARD_REGISTER (expr), 1); 276 /* DECL_IN_TEXT_SECTION is set during final asm output only. */ 277 bp_pack_value (bp, DECL_IN_CONSTANT_POOL (expr), 1); 278 } 279 280 if (TREE_CODE (expr) == FUNCTION_DECL) 281 { 282 bp_pack_value (bp, DECL_FINAL_P (expr), 1); 283 bp_pack_value (bp, DECL_CXX_CONSTRUCTOR_P (expr), 1); 284 bp_pack_value (bp, DECL_CXX_DESTRUCTOR_P (expr), 1); 285 } 286} 287 288 289/* Pack all the non-pointer fields of the TS_FUNCTION_DECL structure 290 of expression EXPR into bitpack BP. */ 291 292static void 293pack_ts_function_decl_value_fields (struct bitpack_d *bp, tree expr) 294{ 295 /* For normal/md builtins we only write the class and code, so they 296 should never be handled here. */ 297 gcc_assert (!streamer_handle_as_builtin_p (expr)); 298 299 bp_pack_enum (bp, built_in_class, BUILT_IN_LAST, 300 DECL_BUILT_IN_CLASS (expr)); 301 bp_pack_value (bp, DECL_STATIC_CONSTRUCTOR (expr), 1); 302 bp_pack_value (bp, DECL_STATIC_DESTRUCTOR (expr), 1); 303 bp_pack_value (bp, DECL_UNINLINABLE (expr), 1); 304 bp_pack_value (bp, DECL_POSSIBLY_INLINED (expr), 1); 305 bp_pack_value (bp, DECL_IS_NOVOPS (expr), 1); 306 bp_pack_value (bp, DECL_IS_RETURNS_TWICE (expr), 1); 307 bp_pack_value (bp, DECL_IS_MALLOC (expr), 1); 308 bp_pack_value (bp, DECL_IS_OPERATOR_NEW (expr), 1); 309 bp_pack_value (bp, DECL_DECLARED_INLINE_P (expr), 1); 310 bp_pack_value (bp, DECL_STATIC_CHAIN (expr), 1); 311 bp_pack_value (bp, DECL_NO_INLINE_WARNING_P (expr), 1); 312 bp_pack_value (bp, DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (expr), 1); 313 bp_pack_value (bp, DECL_NO_LIMIT_STACK (expr), 1); 314 bp_pack_value (bp, DECL_DISREGARD_INLINE_LIMITS (expr), 1); 315 bp_pack_value (bp, DECL_PURE_P (expr), 1); 316 bp_pack_value (bp, DECL_LOOPING_CONST_OR_PURE_P (expr), 1); 317 if (DECL_BUILT_IN_CLASS (expr) != NOT_BUILT_IN) 318 bp_pack_value (bp, DECL_FUNCTION_CODE (expr), 12); 319} 320 321 322/* Pack all the non-pointer fields of the TS_TYPE_COMMON structure 323 of expression EXPR into bitpack BP. */ 324 325static void 326pack_ts_type_common_value_fields (struct bitpack_d *bp, tree expr) 327{ 328 bp_pack_machine_mode (bp, TYPE_MODE (expr)); 329 bp_pack_value (bp, TYPE_STRING_FLAG (expr), 1); 330 bp_pack_value (bp, TYPE_NO_FORCE_BLK (expr), 1); 331 bp_pack_value (bp, TYPE_NEEDS_CONSTRUCTING (expr), 1); 332 if (RECORD_OR_UNION_TYPE_P (expr)) 333 { 334 bp_pack_value (bp, TYPE_TRANSPARENT_AGGR (expr), 1); 335 bp_pack_value (bp, TYPE_FINAL_P (expr), 1); 336 } 337 else if (TREE_CODE (expr) == ARRAY_TYPE) 338 bp_pack_value (bp, TYPE_NONALIASED_COMPONENT (expr), 1); 339 bp_pack_value (bp, TYPE_PACKED (expr), 1); 340 bp_pack_value (bp, TYPE_RESTRICT (expr), 1); 341 bp_pack_value (bp, TYPE_USER_ALIGN (expr), 1); 342 bp_pack_value (bp, TYPE_READONLY (expr), 1); 343 bp_pack_var_len_unsigned (bp, TYPE_PRECISION (expr)); 344 bp_pack_var_len_unsigned (bp, TYPE_ALIGN (expr)); 345 /* Make sure to preserve the fact whether the frontend would assign 346 alias-set zero to this type. */ 347 bp_pack_var_len_int (bp, (TYPE_ALIAS_SET (expr) == 0 348 || (!in_lto_p 349 && get_alias_set (expr) == 0)) ? 0 : -1); 350} 351 352 353/* Pack all the non-pointer fields of the TS_BLOCK structure 354 of expression EXPR into bitpack BP. */ 355 356static void 357pack_ts_block_value_fields (struct output_block *ob, 358 struct bitpack_d *bp, tree expr) 359{ 360 bp_pack_value (bp, BLOCK_ABSTRACT (expr), 1); 361 /* BLOCK_NUMBER is recomputed. */ 362 /* Stream BLOCK_SOURCE_LOCATION for the limited cases we can handle - those 363 that represent inlined function scopes. 364 For the rest them on the floor instead of ICEing in dwarf2out.c. */ 365 if (inlined_function_outer_scope_p (expr)) 366 stream_output_location (ob, bp, BLOCK_SOURCE_LOCATION (expr)); 367 else 368 stream_output_location (ob, bp, UNKNOWN_LOCATION); 369} 370 371/* Pack all the non-pointer fields of the TS_TRANSLATION_UNIT_DECL structure 372 of expression EXPR into bitpack BP. */ 373 374static void 375pack_ts_translation_unit_decl_value_fields (struct output_block *ob, 376 struct bitpack_d *bp, tree expr) 377{ 378 bp_pack_string (ob, bp, TRANSLATION_UNIT_LANGUAGE (expr), true); 379} 380 381 382/* Pack all the non-pointer fields of the TS_OMP_CLAUSE structure 383 of expression EXPR into bitpack BP. */ 384 385static void 386pack_ts_omp_clause_value_fields (struct output_block *ob, 387 struct bitpack_d *bp, tree expr) 388{ 389 stream_output_location (ob, bp, OMP_CLAUSE_LOCATION (expr)); 390 switch (OMP_CLAUSE_CODE (expr)) 391 { 392 case OMP_CLAUSE_DEFAULT: 393 bp_pack_enum (bp, omp_clause_default_kind, OMP_CLAUSE_DEFAULT_LAST, 394 OMP_CLAUSE_DEFAULT_KIND (expr)); 395 break; 396 case OMP_CLAUSE_SCHEDULE: 397 bp_pack_enum (bp, omp_clause_schedule_kind, OMP_CLAUSE_SCHEDULE_LAST, 398 OMP_CLAUSE_SCHEDULE_KIND (expr)); 399 break; 400 case OMP_CLAUSE_DEPEND: 401 bp_pack_enum (bp, omp_clause_depend_kind, OMP_CLAUSE_DEPEND_LAST, 402 OMP_CLAUSE_DEPEND_KIND (expr)); 403 break; 404 case OMP_CLAUSE_MAP: 405 bp_pack_enum (bp, gomp_map_kind, GOMP_MAP_LAST, 406 OMP_CLAUSE_MAP_KIND (expr)); 407 break; 408 case OMP_CLAUSE_PROC_BIND: 409 bp_pack_enum (bp, omp_clause_proc_bind_kind, OMP_CLAUSE_PROC_BIND_LAST, 410 OMP_CLAUSE_PROC_BIND_KIND (expr)); 411 break; 412 case OMP_CLAUSE_REDUCTION: 413 bp_pack_enum (bp, tree_code, MAX_TREE_CODES, 414 OMP_CLAUSE_REDUCTION_CODE (expr)); 415 break; 416 default: 417 break; 418 } 419} 420 421 422/* Pack all the bitfields in EXPR into a bit pack. */ 423 424void 425streamer_write_tree_bitfields (struct output_block *ob, tree expr) 426{ 427 bitpack_d bp = bitpack_create (ob->main_stream); 428 enum tree_code code; 429 430 code = TREE_CODE (expr); 431 432 /* Note that all these functions are highly sensitive to changes in 433 the types and sizes of each of the fields being packed. */ 434 pack_ts_base_value_fields (&bp, expr); 435 436 if (CODE_CONTAINS_STRUCT (code, TS_INT_CST)) 437 pack_ts_int_cst_value_fields (&bp, expr); 438 439 if (CODE_CONTAINS_STRUCT (code, TS_REAL_CST)) 440 pack_ts_real_cst_value_fields (&bp, expr); 441 442 if (CODE_CONTAINS_STRUCT (code, TS_FIXED_CST)) 443 pack_ts_fixed_cst_value_fields (&bp, expr); 444 445 if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL)) 446 stream_output_location (ob, &bp, DECL_SOURCE_LOCATION (expr)); 447 448 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON)) 449 pack_ts_decl_common_value_fields (&bp, expr); 450 451 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL)) 452 pack_ts_decl_wrtl_value_fields (&bp, expr); 453 454 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS)) 455 pack_ts_decl_with_vis_value_fields (&bp, expr); 456 457 if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL)) 458 pack_ts_function_decl_value_fields (&bp, expr); 459 460 if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON)) 461 pack_ts_type_common_value_fields (&bp, expr); 462 463 if (CODE_CONTAINS_STRUCT (code, TS_EXP)) 464 { 465 stream_output_location (ob, &bp, EXPR_LOCATION (expr)); 466 if (code == MEM_REF 467 || code == TARGET_MEM_REF) 468 { 469 bp_pack_value (&bp, MR_DEPENDENCE_CLIQUE (expr), sizeof (short) * 8); 470 if (MR_DEPENDENCE_CLIQUE (expr) != 0) 471 bp_pack_value (&bp, MR_DEPENDENCE_BASE (expr), sizeof (short) * 8); 472 } 473 } 474 475 if (CODE_CONTAINS_STRUCT (code, TS_BLOCK)) 476 pack_ts_block_value_fields (ob, &bp, expr); 477 478 if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL)) 479 pack_ts_translation_unit_decl_value_fields (ob, &bp, expr); 480 481 if (CODE_CONTAINS_STRUCT (code, TS_OPTIMIZATION)) 482 cl_optimization_stream_out (&bp, TREE_OPTIMIZATION (expr)); 483 484 if (CODE_CONTAINS_STRUCT (code, TS_BINFO)) 485 bp_pack_var_len_unsigned (&bp, vec_safe_length (BINFO_BASE_ACCESSES (expr))); 486 487 if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR)) 488 bp_pack_var_len_unsigned (&bp, CONSTRUCTOR_NELTS (expr)); 489 490 if (CODE_CONTAINS_STRUCT (code, TS_TARGET_OPTION) 491 /* Don't stream these when passing things to a different target. */ 492 && !lto_stream_offload_p) 493 cl_target_option_stream_out (ob, &bp, TREE_TARGET_OPTION (expr)); 494 495 if (code == OMP_CLAUSE) 496 pack_ts_omp_clause_value_fields (ob, &bp, expr); 497 498 streamer_write_bitpack (&bp); 499} 500 501 502/* Write the code and class of builtin EXPR to output block OB. IX is 503 the index into the streamer cache where EXPR is stored.*/ 504 505void 506streamer_write_builtin (struct output_block *ob, tree expr) 507{ 508 gcc_assert (streamer_handle_as_builtin_p (expr)); 509 510 if (DECL_BUILT_IN_CLASS (expr) == BUILT_IN_MD 511 && !targetm.builtin_decl) 512 sorry ("tree bytecode streams do not support machine specific builtin " 513 "functions on this target"); 514 515 streamer_write_record_start (ob, LTO_builtin_decl); 516 streamer_write_enum (ob->main_stream, built_in_class, BUILT_IN_LAST, 517 DECL_BUILT_IN_CLASS (expr)); 518 streamer_write_uhwi (ob, DECL_FUNCTION_CODE (expr)); 519 520 if (DECL_ASSEMBLER_NAME_SET_P (expr)) 521 { 522 /* When the assembler name of a builtin gets a user name, 523 the new name is always prefixed with '*' by 524 set_builtin_user_assembler_name. So, to prevent the 525 reader side from adding a second '*', we omit it here. */ 526 const char *str = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (expr)); 527 if (strlen (str) > 1 && str[0] == '*') 528 streamer_write_string (ob, ob->main_stream, &str[1], true); 529 else 530 streamer_write_string (ob, ob->main_stream, NULL, true); 531 } 532 else 533 streamer_write_string (ob, ob->main_stream, NULL, true); 534} 535 536 537/* Emit the chain of tree nodes starting at T. OB is the output block 538 to write to. REF_P is true if chain elements should be emitted 539 as references. */ 540 541void 542streamer_write_chain (struct output_block *ob, tree t, bool ref_p) 543{ 544 while (t) 545 { 546 /* We avoid outputting external vars or functions by reference 547 to the global decls section as we do not want to have them 548 enter decl merging. This is, of course, only for the call 549 for streaming BLOCK_VARS, but other callers are safe. 550 See also lto-streamer-out.c:DFS_write_tree_body. */ 551 if (VAR_OR_FUNCTION_DECL_P (t) 552 && DECL_EXTERNAL (t)) 553 stream_write_tree_shallow_non_ref (ob, t, ref_p); 554 else 555 stream_write_tree (ob, t, ref_p); 556 557 t = TREE_CHAIN (t); 558 } 559 560 /* Write a sentinel to terminate the chain. */ 561 stream_write_tree (ob, NULL_TREE, ref_p); 562} 563 564 565/* Write all pointer fields in the TS_COMMON structure of EXPR to output 566 block OB. If REF_P is true, write a reference to EXPR's pointer 567 fields. */ 568 569static void 570write_ts_common_tree_pointers (struct output_block *ob, tree expr, bool ref_p) 571{ 572 if (TREE_CODE (expr) != IDENTIFIER_NODE) 573 stream_write_tree (ob, TREE_TYPE (expr), ref_p); 574} 575 576 577/* Write all pointer fields in the TS_VECTOR structure of EXPR to output 578 block OB. If REF_P is true, write a reference to EXPR's pointer 579 fields. */ 580 581static void 582write_ts_vector_tree_pointers (struct output_block *ob, tree expr, bool ref_p) 583{ 584 unsigned i; 585 /* Note that the number of elements for EXPR has already been emitted 586 in EXPR's header (see streamer_write_tree_header). */ 587 for (i = 0; i < VECTOR_CST_NELTS (expr); ++i) 588 stream_write_tree (ob, VECTOR_CST_ELT (expr, i), ref_p); 589} 590 591 592/* Write all pointer fields in the TS_COMPLEX structure of EXPR to output 593 block OB. If REF_P is true, write a reference to EXPR's pointer 594 fields. */ 595 596static void 597write_ts_complex_tree_pointers (struct output_block *ob, tree expr, bool ref_p) 598{ 599 stream_write_tree (ob, TREE_REALPART (expr), ref_p); 600 stream_write_tree (ob, TREE_IMAGPART (expr), ref_p); 601} 602 603 604/* Write all pointer fields in the TS_DECL_MINIMAL structure of EXPR 605 to output block OB. If REF_P is true, write a reference to EXPR's 606 pointer fields. */ 607 608static void 609write_ts_decl_minimal_tree_pointers (struct output_block *ob, tree expr, 610 bool ref_p) 611{ 612 /* Drop names that were created for anonymous entities. */ 613 if (DECL_NAME (expr) 614 && TREE_CODE (DECL_NAME (expr)) == IDENTIFIER_NODE 615 && ANON_AGGRNAME_P (DECL_NAME (expr))) 616 stream_write_tree (ob, NULL_TREE, ref_p); 617 else 618 stream_write_tree (ob, DECL_NAME (expr), ref_p); 619 stream_write_tree (ob, DECL_CONTEXT (expr), ref_p); 620} 621 622 623/* Write all pointer fields in the TS_DECL_COMMON structure of EXPR to 624 output block OB. If REF_P is true, write a reference to EXPR's 625 pointer fields. */ 626 627static void 628write_ts_decl_common_tree_pointers (struct output_block *ob, tree expr, 629 bool ref_p) 630{ 631 stream_write_tree (ob, DECL_SIZE (expr), ref_p); 632 stream_write_tree (ob, DECL_SIZE_UNIT (expr), ref_p); 633 634 /* Note, DECL_INITIAL is not handled here. Since DECL_INITIAL needs 635 special handling in LTO, it must be handled by streamer hooks. */ 636 637 stream_write_tree (ob, DECL_ATTRIBUTES (expr), ref_p); 638 639 /* Do not stream DECL_ABSTRACT_ORIGIN. We cannot handle debug information 640 for early inlining so drop it on the floor instead of ICEing in 641 dwarf2out.c. */ 642 643 if ((TREE_CODE (expr) == VAR_DECL 644 || TREE_CODE (expr) == PARM_DECL) 645 && DECL_HAS_VALUE_EXPR_P (expr)) 646 stream_write_tree (ob, DECL_VALUE_EXPR (expr), ref_p); 647 648 if (TREE_CODE (expr) == VAR_DECL) 649 stream_write_tree (ob, DECL_DEBUG_EXPR (expr), ref_p); 650} 651 652 653/* Write all pointer fields in the TS_DECL_NON_COMMON structure of 654 EXPR to output block OB. If REF_P is true, write a reference to EXPR's 655 pointer fields. */ 656 657static void 658write_ts_decl_non_common_tree_pointers (struct output_block *ob, tree expr, 659 bool ref_p) 660{ 661 if (TREE_CODE (expr) == TYPE_DECL) 662 stream_write_tree (ob, DECL_ORIGINAL_TYPE (expr), ref_p); 663} 664 665 666/* Write all pointer fields in the TS_DECL_WITH_VIS structure of EXPR 667 to output block OB. If REF_P is true, write a reference to EXPR's 668 pointer fields. */ 669 670static void 671write_ts_decl_with_vis_tree_pointers (struct output_block *ob, tree expr, 672 bool ref_p) 673{ 674 /* Make sure we don't inadvertently set the assembler name. */ 675 if (DECL_ASSEMBLER_NAME_SET_P (expr)) 676 stream_write_tree (ob, DECL_ASSEMBLER_NAME (expr), ref_p); 677 else 678 stream_write_tree (ob, NULL_TREE, false); 679} 680 681 682/* Write all pointer fields in the TS_FIELD_DECL structure of EXPR to 683 output block OB. If REF_P is true, write a reference to EXPR's 684 pointer fields. */ 685 686static void 687write_ts_field_decl_tree_pointers (struct output_block *ob, tree expr, 688 bool ref_p) 689{ 690 stream_write_tree (ob, DECL_FIELD_OFFSET (expr), ref_p); 691 stream_write_tree (ob, DECL_BIT_FIELD_TYPE (expr), ref_p); 692 stream_write_tree (ob, DECL_BIT_FIELD_REPRESENTATIVE (expr), ref_p); 693 stream_write_tree (ob, DECL_FIELD_BIT_OFFSET (expr), ref_p); 694 stream_write_tree (ob, DECL_FCONTEXT (expr), ref_p); 695} 696 697 698/* Write all pointer fields in the TS_FUNCTION_DECL structure of EXPR 699 to output block OB. If REF_P is true, write a reference to EXPR's 700 pointer fields. */ 701 702static void 703write_ts_function_decl_tree_pointers (struct output_block *ob, tree expr, 704 bool ref_p) 705{ 706 stream_write_tree (ob, DECL_VINDEX (expr), ref_p); 707 /* DECL_STRUCT_FUNCTION is handled by lto_output_function. */ 708 stream_write_tree (ob, DECL_FUNCTION_PERSONALITY (expr), ref_p); 709 /* Don't stream these when passing things to a different target. */ 710 if (!lto_stream_offload_p) 711 stream_write_tree (ob, DECL_FUNCTION_SPECIFIC_TARGET (expr), ref_p); 712 stream_write_tree (ob, DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr), ref_p); 713} 714 715 716/* Write all pointer fields in the TS_TYPE_COMMON structure of EXPR to 717 output block OB. If REF_P is true, write a reference to EXPR's 718 pointer fields. */ 719 720static void 721write_ts_type_common_tree_pointers (struct output_block *ob, tree expr, 722 bool ref_p) 723{ 724 stream_write_tree (ob, TYPE_SIZE (expr), ref_p); 725 stream_write_tree (ob, TYPE_SIZE_UNIT (expr), ref_p); 726 stream_write_tree (ob, TYPE_ATTRIBUTES (expr), ref_p); 727 stream_write_tree (ob, TYPE_NAME (expr), ref_p); 728 /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO. They will be 729 reconstructed during fixup. */ 730 /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists 731 during fixup. */ 732 stream_write_tree (ob, TYPE_MAIN_VARIANT (expr), ref_p); 733 stream_write_tree (ob, TYPE_CONTEXT (expr), ref_p); 734 /* TYPE_CANONICAL is re-computed during type merging, so no need 735 to stream it here. */ 736 stream_write_tree (ob, TYPE_STUB_DECL (expr), ref_p); 737} 738 739/* Write all pointer fields in the TS_TYPE_NON_COMMON structure of EXPR 740 to output block OB. If REF_P is true, write a reference to EXPR's 741 pointer fields. */ 742 743static void 744write_ts_type_non_common_tree_pointers (struct output_block *ob, tree expr, 745 bool ref_p) 746{ 747 if (TREE_CODE (expr) == ENUMERAL_TYPE) 748 stream_write_tree (ob, TYPE_VALUES (expr), ref_p); 749 else if (TREE_CODE (expr) == ARRAY_TYPE) 750 stream_write_tree (ob, TYPE_DOMAIN (expr), ref_p); 751 else if (RECORD_OR_UNION_TYPE_P (expr)) 752 streamer_write_chain (ob, TYPE_FIELDS (expr), ref_p); 753 else if (TREE_CODE (expr) == FUNCTION_TYPE 754 || TREE_CODE (expr) == METHOD_TYPE) 755 stream_write_tree (ob, TYPE_ARG_TYPES (expr), ref_p); 756 757 if (!POINTER_TYPE_P (expr)) 758 stream_write_tree (ob, TYPE_MINVAL (expr), ref_p); 759 stream_write_tree (ob, TYPE_MAXVAL (expr), ref_p); 760 if (RECORD_OR_UNION_TYPE_P (expr)) 761 stream_write_tree (ob, TYPE_BINFO (expr), ref_p); 762} 763 764 765/* Write all pointer fields in the TS_LIST structure of EXPR to output 766 block OB. If REF_P is true, write a reference to EXPR's pointer 767 fields. */ 768 769static void 770write_ts_list_tree_pointers (struct output_block *ob, tree expr, bool ref_p) 771{ 772 stream_write_tree (ob, TREE_PURPOSE (expr), ref_p); 773 stream_write_tree (ob, TREE_VALUE (expr), ref_p); 774 stream_write_tree (ob, TREE_CHAIN (expr), ref_p); 775} 776 777 778/* Write all pointer fields in the TS_VEC structure of EXPR to output 779 block OB. If REF_P is true, write a reference to EXPR's pointer 780 fields. */ 781 782static void 783write_ts_vec_tree_pointers (struct output_block *ob, tree expr, bool ref_p) 784{ 785 int i; 786 787 /* Note that the number of slots for EXPR has already been emitted 788 in EXPR's header (see streamer_write_tree_header). */ 789 for (i = 0; i < TREE_VEC_LENGTH (expr); i++) 790 stream_write_tree (ob, TREE_VEC_ELT (expr, i), ref_p); 791} 792 793 794/* Write all pointer fields in the TS_EXP structure of EXPR to output 795 block OB. If REF_P is true, write a reference to EXPR's pointer 796 fields. */ 797 798static void 799write_ts_exp_tree_pointers (struct output_block *ob, tree expr, bool ref_p) 800{ 801 int i; 802 803 for (i = 0; i < TREE_OPERAND_LENGTH (expr); i++) 804 stream_write_tree (ob, TREE_OPERAND (expr, i), ref_p); 805 stream_write_tree (ob, TREE_BLOCK (expr), ref_p); 806} 807 808 809/* Write all pointer fields in the TS_BLOCK structure of EXPR to output 810 block OB. If REF_P is true, write a reference to EXPR's pointer 811 fields. */ 812 813static void 814write_ts_block_tree_pointers (struct output_block *ob, tree expr, bool ref_p) 815{ 816 streamer_write_chain (ob, BLOCK_VARS (expr), ref_p); 817 818 stream_write_tree (ob, BLOCK_SUPERCONTEXT (expr), ref_p); 819 820 /* Stream BLOCK_ABSTRACT_ORIGIN for the limited cases we can handle - those 821 that represent inlined function scopes. 822 For the rest them on the floor instead of ICEing in dwarf2out.c. */ 823 if (inlined_function_outer_scope_p (expr)) 824 { 825 tree ultimate_origin = block_ultimate_origin (expr); 826 stream_write_tree (ob, ultimate_origin, ref_p); 827 } 828 else 829 stream_write_tree (ob, NULL_TREE, ref_p); 830 /* Do not stream BLOCK_NONLOCALIZED_VARS. We cannot handle debug information 831 for early inlined BLOCKs so drop it on the floor instead of ICEing in 832 dwarf2out.c. */ 833 834 /* BLOCK_FRAGMENT_ORIGIN and BLOCK_FRAGMENT_CHAIN is not live at LTO 835 streaming time. */ 836 837 /* Do not output BLOCK_SUBBLOCKS. Instead on streaming-in this 838 list is re-constructed from BLOCK_SUPERCONTEXT. */ 839} 840 841 842/* Write all pointer fields in the TS_BINFO structure of EXPR to output 843 block OB. If REF_P is true, write a reference to EXPR's pointer 844 fields. */ 845 846static void 847write_ts_binfo_tree_pointers (struct output_block *ob, tree expr, bool ref_p) 848{ 849 unsigned i; 850 tree t; 851 852 /* Note that the number of BINFO slots has already been emitted in 853 EXPR's header (see streamer_write_tree_header) because this length 854 is needed to build the empty BINFO node on the reader side. */ 855 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (expr), i, t) 856 stream_write_tree (ob, t, ref_p); 857 stream_write_tree (ob, NULL_TREE, false); 858 859 stream_write_tree (ob, BINFO_OFFSET (expr), ref_p); 860 stream_write_tree (ob, BINFO_VTABLE (expr), ref_p); 861 stream_write_tree (ob, BINFO_VPTR_FIELD (expr), ref_p); 862 863 /* The number of BINFO_BASE_ACCESSES has already been emitted in 864 EXPR's bitfield section. */ 865 FOR_EACH_VEC_SAFE_ELT (BINFO_BASE_ACCESSES (expr), i, t) 866 stream_write_tree (ob, t, ref_p); 867 868 /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX 869 and BINFO_VPTR_INDEX; these are used by C++ FE only. */ 870} 871 872 873/* Write all pointer fields in the TS_CONSTRUCTOR structure of EXPR to 874 output block OB. If REF_P is true, write a reference to EXPR's 875 pointer fields. */ 876 877static void 878write_ts_constructor_tree_pointers (struct output_block *ob, tree expr, 879 bool ref_p) 880{ 881 unsigned i; 882 tree index, value; 883 884 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (expr), i, index, value) 885 { 886 stream_write_tree (ob, index, ref_p); 887 stream_write_tree (ob, value, ref_p); 888 } 889} 890 891 892/* Write all pointer fields in the TS_OMP_CLAUSE structure of EXPR 893 to output block OB. If REF_P is true, write a reference to EXPR's 894 pointer fields. */ 895 896static void 897write_ts_omp_clause_tree_pointers (struct output_block *ob, tree expr, 898 bool ref_p) 899{ 900 int i; 901 for (i = 0; i < omp_clause_num_ops[OMP_CLAUSE_CODE (expr)]; i++) 902 stream_write_tree (ob, OMP_CLAUSE_OPERAND (expr, i), ref_p); 903 if (OMP_CLAUSE_CODE (expr) == OMP_CLAUSE_REDUCTION) 904 { 905 /* We don't stream these right now, handle it if streaming 906 of them is needed. */ 907 gcc_assert (OMP_CLAUSE_REDUCTION_GIMPLE_INIT (expr) == NULL); 908 gcc_assert (OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (expr) == NULL); 909 } 910 stream_write_tree (ob, OMP_CLAUSE_CHAIN (expr), ref_p); 911} 912 913 914/* Write all pointer fields in EXPR to output block OB. If REF_P is true, 915 the leaves of EXPR are emitted as references. */ 916 917void 918streamer_write_tree_body (struct output_block *ob, tree expr, bool ref_p) 919{ 920 enum tree_code code; 921 922 lto_stats.num_tree_bodies_output++; 923 924 code = TREE_CODE (expr); 925 926 if (CODE_CONTAINS_STRUCT (code, TS_TYPED)) 927 write_ts_common_tree_pointers (ob, expr, ref_p); 928 929 if (CODE_CONTAINS_STRUCT (code, TS_VECTOR)) 930 write_ts_vector_tree_pointers (ob, expr, ref_p); 931 932 if (CODE_CONTAINS_STRUCT (code, TS_COMPLEX)) 933 write_ts_complex_tree_pointers (ob, expr, ref_p); 934 935 if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL)) 936 write_ts_decl_minimal_tree_pointers (ob, expr, ref_p); 937 938 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON)) 939 write_ts_decl_common_tree_pointers (ob, expr, ref_p); 940 941 if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON)) 942 write_ts_decl_non_common_tree_pointers (ob, expr, ref_p); 943 944 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS)) 945 write_ts_decl_with_vis_tree_pointers (ob, expr, ref_p); 946 947 if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL)) 948 write_ts_field_decl_tree_pointers (ob, expr, ref_p); 949 950 if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL)) 951 write_ts_function_decl_tree_pointers (ob, expr, ref_p); 952 953 if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON)) 954 write_ts_type_common_tree_pointers (ob, expr, ref_p); 955 956 if (CODE_CONTAINS_STRUCT (code, TS_TYPE_NON_COMMON)) 957 write_ts_type_non_common_tree_pointers (ob, expr, ref_p); 958 959 if (CODE_CONTAINS_STRUCT (code, TS_LIST)) 960 write_ts_list_tree_pointers (ob, expr, ref_p); 961 962 if (CODE_CONTAINS_STRUCT (code, TS_VEC)) 963 write_ts_vec_tree_pointers (ob, expr, ref_p); 964 965 if (CODE_CONTAINS_STRUCT (code, TS_EXP)) 966 write_ts_exp_tree_pointers (ob, expr, ref_p); 967 968 if (CODE_CONTAINS_STRUCT (code, TS_BLOCK)) 969 write_ts_block_tree_pointers (ob, expr, ref_p); 970 971 if (CODE_CONTAINS_STRUCT (code, TS_BINFO)) 972 write_ts_binfo_tree_pointers (ob, expr, ref_p); 973 974 if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR)) 975 write_ts_constructor_tree_pointers (ob, expr, ref_p); 976 977 if (code == OMP_CLAUSE) 978 write_ts_omp_clause_tree_pointers (ob, expr, ref_p); 979} 980 981 982/* Emit header information for tree EXPR to output block OB. The header 983 contains everything needed to instantiate an empty skeleton for 984 EXPR on the reading side. IX is the index into the streamer cache 985 where EXPR is stored. */ 986 987void 988streamer_write_tree_header (struct output_block *ob, tree expr) 989{ 990 enum LTO_tags tag; 991 enum tree_code code; 992 993 /* We should not see any tree nodes not handled by the streamer. */ 994 code = TREE_CODE (expr); 995 996 /* The header of a tree node consists of its tag, the size of 997 the node, and any other information needed to instantiate 998 EXPR on the reading side (such as the number of slots in 999 variable sized nodes). */ 1000 tag = lto_tree_code_to_tag (code); 1001 streamer_write_record_start (ob, tag); 1002 1003 /* The following will cause bootstrap miscomparisons. Enable with care. */ 1004#ifdef LTO_STREAMER_DEBUG 1005 /* This is used mainly for debugging purposes. When the reader 1006 and the writer do not agree on a streamed node, the pointer 1007 value for EXPR can be used to track down the differences in 1008 the debugger. */ 1009 gcc_assert ((HOST_WIDE_INT) (intptr_t) expr == (intptr_t) expr); 1010 streamer_write_hwi (ob, (HOST_WIDE_INT) (intptr_t) expr); 1011#endif 1012 1013 /* The text in strings and identifiers are completely emitted in 1014 the header. */ 1015 if (CODE_CONTAINS_STRUCT (code, TS_STRING)) 1016 streamer_write_string_cst (ob, ob->main_stream, expr); 1017 else if (CODE_CONTAINS_STRUCT (code, TS_IDENTIFIER)) 1018 write_identifier (ob, ob->main_stream, expr); 1019 else if (CODE_CONTAINS_STRUCT (code, TS_VECTOR)) 1020 streamer_write_hwi (ob, VECTOR_CST_NELTS (expr)); 1021 else if (CODE_CONTAINS_STRUCT (code, TS_VEC)) 1022 streamer_write_hwi (ob, TREE_VEC_LENGTH (expr)); 1023 else if (CODE_CONTAINS_STRUCT (code, TS_BINFO)) 1024 streamer_write_uhwi (ob, BINFO_N_BASE_BINFOS (expr)); 1025 else if (TREE_CODE (expr) == CALL_EXPR) 1026 streamer_write_uhwi (ob, call_expr_nargs (expr)); 1027 else if (TREE_CODE (expr) == OMP_CLAUSE) 1028 streamer_write_uhwi (ob, OMP_CLAUSE_CODE (expr)); 1029 else if (CODE_CONTAINS_STRUCT (code, TS_INT_CST)) 1030 { 1031 gcc_checking_assert (TREE_INT_CST_NUNITS (expr)); 1032 streamer_write_uhwi (ob, TREE_INT_CST_NUNITS (expr)); 1033 streamer_write_uhwi (ob, TREE_INT_CST_EXT_NUNITS (expr)); 1034 } 1035} 1036 1037 1038/* Emit the integer constant CST to output block OB. If REF_P is true, 1039 CST's type will be emitted as a reference. */ 1040 1041void 1042streamer_write_integer_cst (struct output_block *ob, tree cst, bool ref_p) 1043{ 1044 int i; 1045 int len = TREE_INT_CST_NUNITS (cst); 1046 gcc_assert (!TREE_OVERFLOW (cst)); 1047 streamer_write_record_start (ob, LTO_integer_cst); 1048 stream_write_tree (ob, TREE_TYPE (cst), ref_p); 1049 /* We're effectively streaming a non-sign-extended wide_int here, 1050 so there's no need to stream TREE_INT_CST_EXT_NUNITS or any 1051 array members beyond LEN. We'll recreate the tree from the 1052 wide_int and the type. */ 1053 streamer_write_uhwi (ob, len); 1054 for (i = 0; i < len; i++) 1055 streamer_write_hwi (ob, TREE_INT_CST_ELT (cst, i)); 1056} 1057