gcc/tree-streamer-out.c

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