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