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