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