gcc/tree-streamer-out.c

   1 /* Routines for emitting trees to a file stream.
   2
   3    Copyright (C) 2011-2014 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_OPTIMIZATION tree in EXPR to BP.  */
 357
 358 static void
 359 pack_ts_optimization (struct bitpack_d *bp, tree expr)
 360 {
 361   struct cl_optimization *t = TREE_OPTIMIZATION (expr);
 362   unsigned i, len;
 363
 364   /* The cl_optimization is generated by the options
 365      awk script, so we just recreate a byte-by-byte copy here. */
 366
 367   len = sizeof (struct cl_optimization);
 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
 375 /* Pack all the non-pointer fields of the TS_OMP_CLAUSE structure
 376    of expression EXPR into bitpack BP.  */
 377
 378 static void
 379 pack_ts_omp_clause_value_fields (struct output_block *ob,
 380                                  struct bitpack_d *bp, tree expr)
 381 {
 382   stream_output_location (ob, bp, OMP_CLAUSE_LOCATION (expr));
 383   switch (OMP_CLAUSE_CODE (expr))
 384     {
 385     case OMP_CLAUSE_DEFAULT:
 386       bp_pack_enum (bp, omp_clause_default_kind, OMP_CLAUSE_DEFAULT_LAST,
 387                     OMP_CLAUSE_DEFAULT_KIND (expr));
 388       break;
 389     case OMP_CLAUSE_SCHEDULE:
 390       bp_pack_enum (bp, omp_clause_schedule_kind, OMP_CLAUSE_SCHEDULE_LAST,
 391                     OMP_CLAUSE_SCHEDULE_KIND (expr));
 392       break;
 393     case OMP_CLAUSE_DEPEND:
 394       bp_pack_enum (bp, omp_clause_depend_kind, OMP_CLAUSE_DEPEND_LAST,
 395                     OMP_CLAUSE_DEPEND_KIND (expr));
 396       break;
 397     case OMP_CLAUSE_MAP:
 398       bp_pack_enum (bp, omp_clause_map_kind, OMP_CLAUSE_MAP_LAST,
 399                     OMP_CLAUSE_MAP_KIND (expr));
 400       break;
 401     case OMP_CLAUSE_PROC_BIND:
 402       bp_pack_enum (bp, omp_clause_proc_bind_kind, OMP_CLAUSE_PROC_BIND_LAST,
 403                     OMP_CLAUSE_PROC_BIND_KIND (expr));
 404       break;
 405     case OMP_CLAUSE_REDUCTION:
 406       bp_pack_enum (bp, tree_code, MAX_TREE_CODES,
 407                     OMP_CLAUSE_REDUCTION_CODE (expr));
 408       break;
 409     default:
 410       break;
 411     }
 412 }
 413
 414
 415 /* Pack all the bitfields in EXPR into a bit pack.  */
 416
 417 void
 418 streamer_pack_tree_bitfields (struct output_block *ob,
 419                               struct bitpack_d *bp, tree expr)
 420 {
 421   enum tree_code code;
 422
 423   code = TREE_CODE (expr);
 424
 425   /* Note that all these functions are highly sensitive to changes in
 426      the types and sizes of each of the fields being packed.  */
 427   pack_ts_base_value_fields (bp, expr);
 428
 429   if (CODE_CONTAINS_STRUCT (code, TS_INT_CST))
 430     pack_ts_int_cst_value_fields (bp, expr);
 431
 432   if (CODE_CONTAINS_STRUCT (code, TS_REAL_CST))
 433     pack_ts_real_cst_value_fields (bp, expr);
 434
 435   if (CODE_CONTAINS_STRUCT (code, TS_FIXED_CST))
 436     pack_ts_fixed_cst_value_fields (bp, expr);
 437
 438   if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
 439     stream_output_location (ob, bp, DECL_SOURCE_LOCATION (expr));
 440
 441   if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
 442     pack_ts_decl_common_value_fields (bp, expr);
 443
 444   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL))
 445     pack_ts_decl_wrtl_value_fields (bp, expr);
 446
 447   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
 448     pack_ts_decl_with_vis_value_fields (bp, expr);
 449
 450   if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
 451     pack_ts_function_decl_value_fields (bp, expr);
 452
 453   if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
 454     pack_ts_type_common_value_fields (bp, expr);
 455
 456   if (CODE_CONTAINS_STRUCT (code, TS_EXP))
 457     stream_output_location (ob, bp, EXPR_LOCATION (expr));
 458
 459   if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
 460     pack_ts_block_value_fields (ob, bp, expr);
 461
 462   if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL))
 463     pack_ts_translation_unit_decl_value_fields (ob, bp, expr);
 464
 465   if (CODE_CONTAINS_STRUCT (code, TS_TARGET_OPTION))
 466     gcc_unreachable ();
 467
 468   if (CODE_CONTAINS_STRUCT (code, TS_OPTIMIZATION))
 469     pack_ts_optimization (bp, expr);
 470
 471   if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
 472     bp_pack_var_len_unsigned (bp, vec_safe_length (BINFO_BASE_ACCESSES (expr)));
 473
 474   if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
 475     bp_pack_var_len_unsigned (bp, CONSTRUCTOR_NELTS (expr));
 476
 477   if (code == OMP_CLAUSE)
 478     pack_ts_omp_clause_value_fields (ob, bp, expr);
 479 }
 480
 481
 482 /* Write the code and class of builtin EXPR to output block OB.  IX is
 483    the index into the streamer cache where EXPR is stored.*/
 484
 485 void
 486 streamer_write_builtin (struct output_block *ob, tree expr)
 487 {
 488   gcc_assert (streamer_handle_as_builtin_p (expr));
 489
 490   if (DECL_BUILT_IN_CLASS (expr) == BUILT_IN_MD
 491       && !targetm.builtin_decl)
 492     sorry ("tree bytecode streams do not support machine specific builtin "
 493            "functions on this target");
 494
 495   streamer_write_record_start (ob, LTO_builtin_decl);
 496   streamer_write_enum (ob->main_stream, built_in_class, BUILT_IN_LAST,
 497                        DECL_BUILT_IN_CLASS (expr));
 498   streamer_write_uhwi (ob, DECL_FUNCTION_CODE (expr));
 499
 500   if (DECL_ASSEMBLER_NAME_SET_P (expr))
 501     {
 502       /* When the assembler name of a builtin gets a user name,
 503          the new name is always prefixed with '*' by
 504          set_builtin_user_assembler_name.  So, to prevent the
 505          reader side from adding a second '*', we omit it here.  */
 506       const char *str = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (expr));
 507       if (strlen (str) > 1 && str[0] == '*')
 508         streamer_write_string (ob, ob->main_stream, &str[1], true);
 509       else
 510         streamer_write_string (ob, ob->main_stream, NULL, true);
 511     }
 512   else
 513     streamer_write_string (ob, ob->main_stream, NULL, true);
 514 }
 515
 516
 517 /* Emit the chain of tree nodes starting at T.  OB is the output block
 518    to write to.  REF_P is true if chain elements should be emitted
 519    as references.  */
 520
 521 void
 522 streamer_write_chain (struct output_block *ob, tree t, bool ref_p)
 523 {
 524   while (t)
 525     {
 526       /* We avoid outputting external vars or functions by reference
 527          to the global decls section as we do not want to have them
 528          enter decl merging.  This is, of course, only for the call
 529          for streaming BLOCK_VARS, but other callers are safe.  */
 530       /* ???  FIXME wrt SCC streaming.  Drop these for now.  */
 531       if (VAR_OR_FUNCTION_DECL_P (t)
 532           && DECL_EXTERNAL (t))
 533         ; /* stream_write_tree_shallow_non_ref (ob, t, ref_p); */
 534       else
 535         stream_write_tree (ob, t, ref_p);
 536
 537       t = TREE_CHAIN (t);
 538     }
 539
 540   /* Write a sentinel to terminate the chain.  */
 541   stream_write_tree (ob, NULL_TREE, ref_p);
 542 }
 543
 544
 545 /* Write all pointer fields in the TS_COMMON structure of EXPR to output
 546    block OB.  If REF_P is true, write a reference to EXPR's pointer
 547    fields.  */
 548
 549 static void
 550 write_ts_common_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 551 {
 552   if (TREE_CODE (expr) != IDENTIFIER_NODE)
 553     stream_write_tree (ob, TREE_TYPE (expr), ref_p);
 554 }
 555
 556
 557 /* Write all pointer fields in the TS_VECTOR structure of EXPR to output
 558    block OB.  If REF_P is true, write a reference to EXPR's pointer
 559    fields.  */
 560
 561 static void
 562 write_ts_vector_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 563 {
 564   unsigned i;
 565   /* Note that the number of elements for EXPR has already been emitted
 566      in EXPR's header (see streamer_write_tree_header).  */
 567   for (i = 0; i < VECTOR_CST_NELTS (expr); ++i)
 568     stream_write_tree (ob, VECTOR_CST_ELT (expr, i), ref_p);
 569 }
 570
 571
 572 /* Write all pointer fields in the TS_COMPLEX structure of EXPR to output
 573    block OB.  If REF_P is true, write a reference to EXPR's pointer
 574    fields.  */
 575
 576 static void
 577 write_ts_complex_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 578 {
 579   stream_write_tree (ob, TREE_REALPART (expr), ref_p);
 580   stream_write_tree (ob, TREE_IMAGPART (expr), ref_p);
 581 }
 582
 583
 584 /* Write all pointer fields in the TS_DECL_MINIMAL structure of EXPR
 585    to output block OB.  If REF_P is true, write a reference to EXPR's
 586    pointer fields.  */
 587
 588 static void
 589 write_ts_decl_minimal_tree_pointers (struct output_block *ob, tree expr,
 590                                      bool ref_p)
 591 {
 592   /* Drop names that were created for anonymous entities.  */
 593   if (DECL_NAME (expr)
 594       && TREE_CODE (DECL_NAME (expr)) == IDENTIFIER_NODE
 595       && ANON_AGGRNAME_P (DECL_NAME (expr)))
 596     stream_write_tree (ob, NULL_TREE, ref_p);
 597   else
 598     stream_write_tree (ob, DECL_NAME (expr), ref_p);
 599   stream_write_tree (ob, DECL_CONTEXT (expr), ref_p);
 600 }
 601
 602
 603 /* Write all pointer fields in the TS_DECL_COMMON structure of EXPR to
 604    output block OB.  If REF_P is true, write a reference to EXPR's
 605    pointer fields.  */
 606
 607 static void
 608 write_ts_decl_common_tree_pointers (struct output_block *ob, tree expr,
 609                                     bool ref_p)
 610 {
 611   stream_write_tree (ob, DECL_SIZE (expr), ref_p);
 612   stream_write_tree (ob, DECL_SIZE_UNIT (expr), ref_p);
 613
 614   /* Note, DECL_INITIAL is not handled here.  Since DECL_INITIAL needs
 615      special handling in LTO, it must be handled by streamer hooks.  */
 616
 617   stream_write_tree (ob, DECL_ATTRIBUTES (expr), ref_p);
 618
 619   /* Do not stream DECL_ABSTRACT_ORIGIN.  We cannot handle debug information
 620      for early inlining so drop it on the floor instead of ICEing in
 621      dwarf2out.c.  */
 622
 623   if ((TREE_CODE (expr) == VAR_DECL
 624        || TREE_CODE (expr) == PARM_DECL)
 625       && DECL_HAS_VALUE_EXPR_P (expr))
 626     stream_write_tree (ob, DECL_VALUE_EXPR (expr), ref_p);
 627
 628   if (TREE_CODE (expr) == VAR_DECL)
 629     stream_write_tree (ob, DECL_DEBUG_EXPR (expr), ref_p);
 630 }
 631
 632
 633 /* Write all pointer fields in the TS_DECL_NON_COMMON structure of
 634    EXPR to output block OB.  If REF_P is true, write a reference to EXPR's
 635    pointer fields.  */
 636
 637 static void
 638 write_ts_decl_non_common_tree_pointers (struct output_block *ob, tree expr,
 639                                         bool ref_p)
 640 {
 641   if (TREE_CODE (expr) == TYPE_DECL)
 642     stream_write_tree (ob, DECL_ORIGINAL_TYPE (expr), ref_p);
 643   stream_write_tree (ob, DECL_VINDEX (expr), ref_p);
 644 }
 645
 646
 647 /* Write all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
 648    to output block OB.  If REF_P is true, write a reference to EXPR's
 649    pointer fields.  */
 650
 651 static void
 652 write_ts_decl_with_vis_tree_pointers (struct output_block *ob, tree expr,
 653                                       bool ref_p)
 654 {
 655   /* Make sure we don't inadvertently set the assembler name.  */
 656   if (DECL_ASSEMBLER_NAME_SET_P (expr))
 657     stream_write_tree (ob, DECL_ASSEMBLER_NAME (expr), ref_p);
 658   else
 659     stream_write_tree (ob, NULL_TREE, false);
 660
 661   stream_write_tree (ob, DECL_SECTION_NAME (expr), ref_p);
 662   stream_write_tree (ob, DECL_COMDAT_GROUP (expr), ref_p);
 663 }
 664
 665
 666 /* Write all pointer fields in the TS_FIELD_DECL structure of EXPR to
 667    output block OB.  If REF_P is true, write a reference to EXPR's
 668    pointer fields.  */
 669
 670 static void
 671 write_ts_field_decl_tree_pointers (struct output_block *ob, tree expr,
 672                                    bool ref_p)
 673 {
 674   stream_write_tree (ob, DECL_FIELD_OFFSET (expr), ref_p);
 675   stream_write_tree (ob, DECL_BIT_FIELD_TYPE (expr), ref_p);
 676   stream_write_tree (ob, DECL_BIT_FIELD_REPRESENTATIVE (expr), ref_p);
 677   stream_write_tree (ob, DECL_FIELD_BIT_OFFSET (expr), ref_p);
 678   stream_write_tree (ob, DECL_FCONTEXT (expr), ref_p);
 679 }
 680
 681
 682 /* Write all pointer fields in the TS_FUNCTION_DECL structure of EXPR
 683    to output block OB.  If REF_P is true, write a reference to EXPR's
 684    pointer fields.  */
 685
 686 static void
 687 write_ts_function_decl_tree_pointers (struct output_block *ob, tree expr,
 688                                       bool ref_p)
 689 {
 690   /* DECL_STRUCT_FUNCTION is handled by lto_output_function.  FIXME lto,
 691      maybe it should be handled here?  */
 692   stream_write_tree (ob, DECL_FUNCTION_PERSONALITY (expr), ref_p);
 693   /* DECL_FUNCTION_SPECIFIC_TARGET is regenerated.  */
 694   stream_write_tree (ob, DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr), ref_p);
 695 }
 696
 697
 698 /* Write all pointer fields in the TS_TYPE_COMMON structure of EXPR to
 699    output block OB.  If REF_P is true, write a reference to EXPR's
 700    pointer fields.  */
 701
 702 static void
 703 write_ts_type_common_tree_pointers (struct output_block *ob, tree expr,
 704                                     bool ref_p)
 705 {
 706   stream_write_tree (ob, TYPE_SIZE (expr), ref_p);
 707   stream_write_tree (ob, TYPE_SIZE_UNIT (expr), ref_p);
 708   stream_write_tree (ob, TYPE_ATTRIBUTES (expr), ref_p);
 709   stream_write_tree (ob, TYPE_NAME (expr), ref_p);
 710   /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO.  They will be
 711      reconstructed during fixup.  */
 712   /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
 713      during fixup.  */
 714   stream_write_tree (ob, TYPE_MAIN_VARIANT (expr), ref_p);
 715   stream_write_tree (ob, TYPE_CONTEXT (expr), ref_p);
 716   /* TYPE_CANONICAL is re-computed during type merging, so no need
 717      to stream it here.  */
 718   stream_write_tree (ob, TYPE_STUB_DECL (expr), ref_p);
 719 }
 720
 721 /* Write all pointer fields in the TS_TYPE_NON_COMMON structure of EXPR
 722    to output block OB.  If REF_P is true, write a reference to EXPR's
 723    pointer fields.  */
 724
 725 static void
 726 write_ts_type_non_common_tree_pointers (struct output_block *ob, tree expr,
 727                                         bool ref_p)
 728 {
 729   if (TREE_CODE (expr) == ENUMERAL_TYPE)
 730     stream_write_tree (ob, TYPE_VALUES (expr), ref_p);
 731   else if (TREE_CODE (expr) == ARRAY_TYPE)
 732     stream_write_tree (ob, TYPE_DOMAIN (expr), ref_p);
 733   else if (RECORD_OR_UNION_TYPE_P (expr))
 734     streamer_write_chain (ob, TYPE_FIELDS (expr), ref_p);
 735   else if (TREE_CODE (expr) == FUNCTION_TYPE
 736            || TREE_CODE (expr) == METHOD_TYPE)
 737     stream_write_tree (ob, TYPE_ARG_TYPES (expr), ref_p);
 738
 739   if (!POINTER_TYPE_P (expr))
 740     stream_write_tree (ob, TYPE_MINVAL (expr), ref_p);
 741   stream_write_tree (ob, TYPE_MAXVAL (expr), ref_p);
 742   if (RECORD_OR_UNION_TYPE_P (expr))
 743     stream_write_tree (ob, TYPE_BINFO (expr), ref_p);
 744 }
 745
 746
 747 /* Write all pointer fields in the TS_LIST structure of EXPR to output
 748    block OB.  If REF_P is true, write a reference to EXPR's pointer
 749    fields.  */
 750
 751 static void
 752 write_ts_list_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 753 {
 754   stream_write_tree (ob, TREE_PURPOSE (expr), ref_p);
 755   stream_write_tree (ob, TREE_VALUE (expr), ref_p);
 756   stream_write_tree (ob, TREE_CHAIN (expr), ref_p);
 757 }
 758
 759
 760 /* Write all pointer fields in the TS_VEC structure of EXPR to output
 761    block OB.  If REF_P is true, write a reference to EXPR's pointer
 762    fields.  */
 763
 764 static void
 765 write_ts_vec_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 766 {
 767   int i;
 768
 769   /* Note that the number of slots for EXPR has already been emitted
 770      in EXPR's header (see streamer_write_tree_header).  */
 771   for (i = 0; i < TREE_VEC_LENGTH (expr); i++)
 772     stream_write_tree (ob, TREE_VEC_ELT (expr, i), ref_p);
 773 }
 774
 775
 776 /* Write all pointer fields in the TS_EXP structure of EXPR to output
 777    block OB.  If REF_P is true, write a reference to EXPR's pointer
 778    fields.  */
 779
 780 static void
 781 write_ts_exp_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 782 {
 783   int i;
 784
 785   for (i = 0; i < TREE_OPERAND_LENGTH (expr); i++)
 786     stream_write_tree (ob, TREE_OPERAND (expr, i), ref_p);
 787   stream_write_tree (ob, TREE_BLOCK (expr), ref_p);
 788 }
 789
 790
 791 /* Write all pointer fields in the TS_BLOCK structure of EXPR to output
 792    block OB.  If REF_P is true, write a reference to EXPR's pointer
 793    fields.  */
 794
 795 static void
 796 write_ts_block_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 797 {
 798   streamer_write_chain (ob, BLOCK_VARS (expr), ref_p);
 799
 800   stream_write_tree (ob, BLOCK_SUPERCONTEXT (expr), ref_p);
 801
 802   /* Stream BLOCK_ABSTRACT_ORIGIN for the limited cases we can handle - those
 803      that represent inlined function scopes.
 804      For the rest them on the floor instead of ICEing in dwarf2out.c.  */
 805   if (inlined_function_outer_scope_p (expr))
 806     {
 807       tree ultimate_origin = block_ultimate_origin (expr);
 808       stream_write_tree (ob, ultimate_origin, ref_p);
 809     }
 810   else
 811     stream_write_tree (ob, NULL_TREE, ref_p);
 812   /* Do not stream BLOCK_NONLOCALIZED_VARS.  We cannot handle debug information
 813      for early inlined BLOCKs so drop it on the floor instead of ICEing in
 814      dwarf2out.c.  */
 815
 816   /* BLOCK_FRAGMENT_ORIGIN and BLOCK_FRAGMENT_CHAIN is not live at LTO
 817      streaming time.  */
 818
 819   /* Do not output BLOCK_SUBBLOCKS.  Instead on streaming-in this
 820      list is re-constructed from BLOCK_SUPERCONTEXT.  */
 821 }
 822
 823
 824 /* Write all pointer fields in the TS_BINFO structure of EXPR to output
 825    block OB.  If REF_P is true, write a reference to EXPR's pointer
 826    fields.  */
 827
 828 static void
 829 write_ts_binfo_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 830 {
 831   unsigned i;
 832   tree t;
 833
 834   /* Note that the number of BINFO slots has already been emitted in
 835      EXPR's header (see streamer_write_tree_header) because this length
 836      is needed to build the empty BINFO node on the reader side.  */
 837   FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (expr), i, t)
 838     stream_write_tree (ob, t, ref_p);
 839   stream_write_tree (ob, NULL_TREE, false);
 840
 841   stream_write_tree (ob, BINFO_OFFSET (expr), ref_p);
 842   stream_write_tree (ob, BINFO_VTABLE (expr), ref_p);
 843   stream_write_tree (ob, BINFO_VPTR_FIELD (expr), ref_p);
 844
 845   /* The number of BINFO_BASE_ACCESSES has already been emitted in
 846      EXPR's bitfield section.  */
 847   FOR_EACH_VEC_SAFE_ELT (BINFO_BASE_ACCESSES (expr), i, t)
 848     stream_write_tree (ob, t, ref_p);
 849
 850   /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX
 851      and BINFO_VPTR_INDEX; these are used by C++ FE only.  */
 852 }
 853
 854
 855 /* Write all pointer fields in the TS_CONSTRUCTOR structure of EXPR to
 856    output block OB.  If REF_P is true, write a reference to EXPR's
 857    pointer fields.  */
 858
 859 static void
 860 write_ts_constructor_tree_pointers (struct output_block *ob, tree expr,
 861                                     bool ref_p)
 862 {
 863   unsigned i;
 864   tree index, value;
 865
 866   FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (expr), i, index, value)
 867     {
 868       stream_write_tree (ob, index, ref_p);
 869       stream_write_tree (ob, value, ref_p);
 870     }
 871 }
 872
 873
 874 /* Write all pointer fields in the TS_OMP_CLAUSE structure of EXPR
 875    to output block OB.  If REF_P is true, write a reference to EXPR's
 876    pointer fields.  */
 877
 878 static void
 879 write_ts_omp_clause_tree_pointers (struct output_block *ob, tree expr,
 880                                    bool ref_p)
 881 {
 882   int i;
 883   for (i = 0; i < omp_clause_num_ops[OMP_CLAUSE_CODE (expr)]; i++)
 884     stream_write_tree (ob, OMP_CLAUSE_OPERAND (expr, i), ref_p);
 885   if (OMP_CLAUSE_CODE (expr) == OMP_CLAUSE_REDUCTION)
 886     {
 887       /* We don't stream these right now, handle it if streaming
 888          of them is needed.  */
 889       gcc_assert (OMP_CLAUSE_REDUCTION_GIMPLE_INIT (expr) == NULL);
 890       gcc_assert (OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (expr) == NULL);
 891     }
 892   stream_write_tree (ob, OMP_CLAUSE_CHAIN (expr), ref_p);
 893 }
 894
 895
 896 /* Write all pointer fields in EXPR to output block OB.  If REF_P is true,
 897    the leaves of EXPR are emitted as references.  */
 898
 899 void
 900 streamer_write_tree_body (struct output_block *ob, tree expr, bool ref_p)
 901 {
 902   enum tree_code code;
 903
 904   lto_stats.num_tree_bodies_output++;
 905
 906   code = TREE_CODE (expr);
 907
 908   if (CODE_CONTAINS_STRUCT (code, TS_TYPED))
 909     write_ts_common_tree_pointers (ob, expr, ref_p);
 910
 911   if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
 912     write_ts_vector_tree_pointers (ob, expr, ref_p);
 913
 914   if (CODE_CONTAINS_STRUCT (code, TS_COMPLEX))
 915     write_ts_complex_tree_pointers (ob, expr, ref_p);
 916
 917   if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
 918     write_ts_decl_minimal_tree_pointers (ob, expr, ref_p);
 919
 920   if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
 921     write_ts_decl_common_tree_pointers (ob, expr, ref_p);
 922
 923   if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
 924     write_ts_decl_non_common_tree_pointers (ob, expr, ref_p);
 925
 926   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
 927     write_ts_decl_with_vis_tree_pointers (ob, expr, ref_p);
 928
 929   if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL))
 930     write_ts_field_decl_tree_pointers (ob, expr, ref_p);
 931
 932   if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
 933     write_ts_function_decl_tree_pointers (ob, expr, ref_p);
 934
 935   if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
 936     write_ts_type_common_tree_pointers (ob, expr, ref_p);
 937
 938   if (CODE_CONTAINS_STRUCT (code, TS_TYPE_NON_COMMON))
 939     write_ts_type_non_common_tree_pointers (ob, expr, ref_p);
 940
 941   if (CODE_CONTAINS_STRUCT (code, TS_LIST))
 942     write_ts_list_tree_pointers (ob, expr, ref_p);
 943
 944   if (CODE_CONTAINS_STRUCT (code, TS_VEC))
 945     write_ts_vec_tree_pointers (ob, expr, ref_p);
 946
 947   if (CODE_CONTAINS_STRUCT (code, TS_EXP))
 948     write_ts_exp_tree_pointers (ob, expr, ref_p);
 949
 950   if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
 951     write_ts_block_tree_pointers (ob, expr, ref_p);
 952
 953   if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
 954     write_ts_binfo_tree_pointers (ob, expr, ref_p);
 955
 956   if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
 957     write_ts_constructor_tree_pointers (ob, expr, ref_p);
 958
 959   if (code == OMP_CLAUSE)
 960     write_ts_omp_clause_tree_pointers (ob, expr, ref_p);
 961 }
 962
 963
 964 /* Emit header information for tree EXPR to output block OB.  The header
 965    contains everything needed to instantiate an empty skeleton for
 966    EXPR on the reading side.  IX is the index into the streamer cache
 967    where EXPR is stored.  */
 968
 969 void
 970 streamer_write_tree_header (struct output_block *ob, tree expr)
 971 {
 972   enum LTO_tags tag;
 973   enum tree_code code;
 974
 975   /* We should not see any tree nodes not handled by the streamer.  */
 976   code = TREE_CODE (expr);
 977
 978   /* The header of a tree node consists of its tag, the size of
 979      the node, and any other information needed to instantiate
 980      EXPR on the reading side (such as the number of slots in
 981      variable sized nodes).  */
 982   tag = lto_tree_code_to_tag (code);
 983   streamer_write_record_start (ob, tag);
 984
 985   /* The following will cause bootstrap miscomparisons.  Enable with care.  */
 986 #ifdef LTO_STREAMER_DEBUG
 987   /* This is used mainly for debugging purposes.  When the reader
 988      and the writer do not agree on a streamed node, the pointer
 989      value for EXPR can be used to track down the differences in
 990      the debugger.  */
 991   gcc_assert ((HOST_WIDEST_INT) (intptr_t) expr == (intptr_t) expr);
 992   streamer_write_hwi (ob, (HOST_WIDEST_INT) (intptr_t) expr);
 993 #endif
 994
 995   /* The text in strings and identifiers are completely emitted in
 996      the header.  */
 997   if (CODE_CONTAINS_STRUCT (code, TS_STRING))
 998     streamer_write_string_cst (ob, ob->main_stream, expr);
 999   else if (CODE_CONTAINS_STRUCT (code, TS_IDENTIFIER))
1000     write_identifier (ob, ob->main_stream, expr);
1001   else if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
1002     streamer_write_hwi (ob, VECTOR_CST_NELTS (expr));
1003   else if (CODE_CONTAINS_STRUCT (code, TS_VEC))
1004     streamer_write_hwi (ob, TREE_VEC_LENGTH (expr));
1005   else if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
1006     streamer_write_uhwi (ob, BINFO_N_BASE_BINFOS (expr));
1007   else if (TREE_CODE (expr) == CALL_EXPR)
1008     streamer_write_uhwi (ob, call_expr_nargs (expr));
1009   else if (TREE_CODE (expr) == OMP_CLAUSE)
1010     streamer_write_uhwi (ob, OMP_CLAUSE_CODE (expr));
1011 }
1012
1013
1014 /* Emit the integer constant CST to output block OB.  If REF_P is true,
1015    CST's type will be emitted as a reference.  */
1016
1017 void
1018 streamer_write_integer_cst (struct output_block *ob, tree cst, bool ref_p)
1019 {
1020   gcc_assert (!TREE_OVERFLOW (cst));
1021   streamer_write_record_start (ob, LTO_integer_cst);
1022   stream_write_tree (ob, TREE_TYPE (cst), ref_p);
1023   streamer_write_uhwi (ob, TREE_INT_CST_LOW (cst));
1024   streamer_write_hwi (ob, TREE_INT_CST_HIGH (cst));
1025 }