gcc/tree-streamer-out.c

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