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