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