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       tree saved_chain;
 527
 528       /* Clear TREE_CHAIN to avoid blindly recursing into the rest
 529          of the list.  */
 530       saved_chain = TREE_CHAIN (t);
 531       TREE_CHAIN (t) = NULL_TREE;
 532
 533       /* We avoid outputting external vars or functions by reference
 534          to the global decls section as we do not want to have them
 535          enter decl merging.  This is, of course, only for the call
 536          for streaming BLOCK_VARS, but other callers are safe.  */
 537       /* ???  FIXME wrt SCC streaming.  Drop these for now.  */
 538       if (VAR_OR_FUNCTION_DECL_P (t)
 539           && DECL_EXTERNAL (t))
 540         ; /* stream_write_tree_shallow_non_ref (ob, t, ref_p); */
 541       else
 542         stream_write_tree (ob, t, ref_p);
 543
 544       TREE_CHAIN (t) = saved_chain;
 545       t = TREE_CHAIN (t);
 546     }
 547
 548   /* Write a sentinel to terminate the chain.  */
 549   stream_write_tree (ob, NULL_TREE, ref_p);
 550 }
 551
 552
 553 /* Write all pointer fields in the TS_COMMON structure of EXPR to output
 554    block OB.  If REF_P is true, write a reference to EXPR's pointer
 555    fields.  */
 556
 557 static void
 558 write_ts_common_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 559 {
 560   if (TREE_CODE (expr) != IDENTIFIER_NODE)
 561     stream_write_tree (ob, TREE_TYPE (expr), ref_p);
 562 }
 563
 564
 565 /* Write all pointer fields in the TS_VECTOR structure of EXPR to output
 566    block OB.  If REF_P is true, write a reference to EXPR's pointer
 567    fields.  */
 568
 569 static void
 570 write_ts_vector_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 571 {
 572   unsigned i;
 573   /* Note that the number of elements for EXPR has already been emitted
 574      in EXPR's header (see streamer_write_tree_header).  */
 575   for (i = 0; i < VECTOR_CST_NELTS (expr); ++i)
 576     stream_write_tree (ob, VECTOR_CST_ELT (expr, i), ref_p);
 577 }
 578
 579
 580 /* Write all pointer fields in the TS_COMPLEX structure of EXPR to output
 581    block OB.  If REF_P is true, write a reference to EXPR's pointer
 582    fields.  */
 583
 584 static void
 585 write_ts_complex_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 586 {
 587   stream_write_tree (ob, TREE_REALPART (expr), ref_p);
 588   stream_write_tree (ob, TREE_IMAGPART (expr), ref_p);
 589 }
 590
 591
 592 /* Write all pointer fields in the TS_DECL_MINIMAL structure of EXPR
 593    to output block OB.  If REF_P is true, write a reference to EXPR's
 594    pointer fields.  */
 595
 596 static void
 597 write_ts_decl_minimal_tree_pointers (struct output_block *ob, tree expr,
 598                                      bool ref_p)
 599 {
 600   /* Drop names that were created for anonymous entities.  */
 601   if (DECL_NAME (expr)
 602       && TREE_CODE (DECL_NAME (expr)) == IDENTIFIER_NODE
 603       && ANON_AGGRNAME_P (DECL_NAME (expr)))
 604     stream_write_tree (ob, NULL_TREE, ref_p);
 605   else
 606     stream_write_tree (ob, DECL_NAME (expr), ref_p);
 607   stream_write_tree (ob, DECL_CONTEXT (expr), ref_p);
 608 }
 609
 610
 611 /* Write all pointer fields in the TS_DECL_COMMON structure of EXPR to
 612    output block OB.  If REF_P is true, write a reference to EXPR's
 613    pointer fields.  */
 614
 615 static void
 616 write_ts_decl_common_tree_pointers (struct output_block *ob, tree expr,
 617                                     bool ref_p)
 618 {
 619   stream_write_tree (ob, DECL_SIZE (expr), ref_p);
 620   stream_write_tree (ob, DECL_SIZE_UNIT (expr), ref_p);
 621
 622   /* Note, DECL_INITIAL is not handled here.  Since DECL_INITIAL needs
 623      special handling in LTO, it must be handled by streamer hooks.  */
 624
 625   stream_write_tree (ob, DECL_ATTRIBUTES (expr), ref_p);
 626
 627   /* Do not stream DECL_ABSTRACT_ORIGIN.  We cannot handle debug information
 628      for early inlining so drop it on the floor instead of ICEing in
 629      dwarf2out.c.  */
 630
 631   if ((TREE_CODE (expr) == VAR_DECL
 632        || TREE_CODE (expr) == PARM_DECL)
 633       && DECL_HAS_VALUE_EXPR_P (expr))
 634     stream_write_tree (ob, DECL_VALUE_EXPR (expr), ref_p);
 635
 636   if (TREE_CODE (expr) == VAR_DECL)
 637     stream_write_tree (ob, DECL_DEBUG_EXPR (expr), ref_p);
 638 }
 639
 640
 641 /* Write all pointer fields in the TS_DECL_NON_COMMON structure of
 642    EXPR to output block OB.  If REF_P is true, write a reference to EXPR's
 643    pointer fields.  */
 644
 645 static void
 646 write_ts_decl_non_common_tree_pointers (struct output_block *ob, tree expr,
 647                                         bool ref_p)
 648 {
 649   if (TREE_CODE (expr) == TYPE_DECL)
 650     stream_write_tree (ob, DECL_ORIGINAL_TYPE (expr), ref_p);
 651   stream_write_tree (ob, DECL_VINDEX (expr), ref_p);
 652 }
 653
 654
 655 /* Write all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
 656    to output block OB.  If REF_P is true, write a reference to EXPR's
 657    pointer fields.  */
 658
 659 static void
 660 write_ts_decl_with_vis_tree_pointers (struct output_block *ob, tree expr,
 661                                       bool ref_p)
 662 {
 663   /* Make sure we don't inadvertently set the assembler name.  */
 664   if (DECL_ASSEMBLER_NAME_SET_P (expr))
 665     stream_write_tree (ob, DECL_ASSEMBLER_NAME (expr), ref_p);
 666   else
 667     stream_write_tree (ob, NULL_TREE, false);
 668
 669   stream_write_tree (ob, DECL_SECTION_NAME (expr), ref_p);
 670   stream_write_tree (ob, DECL_COMDAT_GROUP (expr), ref_p);
 671 }
 672
 673
 674 /* Write all pointer fields in the TS_FIELD_DECL structure of EXPR to
 675    output block OB.  If REF_P is true, write a reference to EXPR's
 676    pointer fields.  */
 677
 678 static void
 679 write_ts_field_decl_tree_pointers (struct output_block *ob, tree expr,
 680                                    bool ref_p)
 681 {
 682   stream_write_tree (ob, DECL_FIELD_OFFSET (expr), ref_p);
 683   stream_write_tree (ob, DECL_BIT_FIELD_TYPE (expr), ref_p);
 684   stream_write_tree (ob, DECL_BIT_FIELD_REPRESENTATIVE (expr), ref_p);
 685   stream_write_tree (ob, DECL_FIELD_BIT_OFFSET (expr), ref_p);
 686   stream_write_tree (ob, DECL_FCONTEXT (expr), ref_p);
 687 }
 688
 689
 690 /* Write all pointer fields in the TS_FUNCTION_DECL structure of EXPR
 691    to output block OB.  If REF_P is true, write a reference to EXPR's
 692    pointer fields.  */
 693
 694 static void
 695 write_ts_function_decl_tree_pointers (struct output_block *ob, tree expr,
 696                                       bool ref_p)
 697 {
 698   /* DECL_STRUCT_FUNCTION is handled by lto_output_function.  FIXME lto,
 699      maybe it should be handled here?  */
 700   stream_write_tree (ob, DECL_FUNCTION_PERSONALITY (expr), ref_p);
 701   /* DECL_FUNCTION_SPECIFIC_TARGET is regenerated.  */
 702   stream_write_tree (ob, DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr), ref_p);
 703 }
 704
 705
 706 /* Write all pointer fields in the TS_TYPE_COMMON structure of EXPR to
 707    output block OB.  If REF_P is true, write a reference to EXPR's
 708    pointer fields.  */
 709
 710 static void
 711 write_ts_type_common_tree_pointers (struct output_block *ob, tree expr,
 712                                     bool ref_p)
 713 {
 714   stream_write_tree (ob, TYPE_SIZE (expr), ref_p);
 715   stream_write_tree (ob, TYPE_SIZE_UNIT (expr), ref_p);
 716   stream_write_tree (ob, TYPE_ATTRIBUTES (expr), ref_p);
 717   stream_write_tree (ob, TYPE_NAME (expr), ref_p);
 718   /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO.  They will be
 719      reconstructed during fixup.  */
 720   /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
 721      during fixup.  */
 722   stream_write_tree (ob, TYPE_MAIN_VARIANT (expr), ref_p);
 723   stream_write_tree (ob, TYPE_CONTEXT (expr), ref_p);
 724   /* TYPE_CANONICAL is re-computed during type merging, so no need
 725      to stream it here.  */
 726   stream_write_tree (ob, TYPE_STUB_DECL (expr), ref_p);
 727 }
 728
 729 /* Write all pointer fields in the TS_TYPE_NON_COMMON structure of EXPR
 730    to output block OB.  If REF_P is true, write a reference to EXPR's
 731    pointer fields.  */
 732
 733 static void
 734 write_ts_type_non_common_tree_pointers (struct output_block *ob, tree expr,
 735                                         bool ref_p)
 736 {
 737   if (TREE_CODE (expr) == ENUMERAL_TYPE)
 738     stream_write_tree (ob, TYPE_VALUES (expr), ref_p);
 739   else if (TREE_CODE (expr) == ARRAY_TYPE)
 740     stream_write_tree (ob, TYPE_DOMAIN (expr), ref_p);
 741   else if (RECORD_OR_UNION_TYPE_P (expr))
 742     streamer_write_chain (ob, TYPE_FIELDS (expr), ref_p);
 743   else if (TREE_CODE (expr) == FUNCTION_TYPE
 744            || TREE_CODE (expr) == METHOD_TYPE)
 745     stream_write_tree (ob, TYPE_ARG_TYPES (expr), ref_p);
 746
 747   if (!POINTER_TYPE_P (expr))
 748     stream_write_tree (ob, TYPE_MINVAL (expr), ref_p);
 749   stream_write_tree (ob, TYPE_MAXVAL (expr), ref_p);
 750   if (RECORD_OR_UNION_TYPE_P (expr))
 751     stream_write_tree (ob, TYPE_BINFO (expr), ref_p);
 752 }
 753
 754
 755 /* Write all pointer fields in the TS_LIST structure of EXPR to output
 756    block OB.  If REF_P is true, write a reference to EXPR's pointer
 757    fields.  */
 758
 759 static void
 760 write_ts_list_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 761 {
 762   stream_write_tree (ob, TREE_PURPOSE (expr), ref_p);
 763   stream_write_tree (ob, TREE_VALUE (expr), ref_p);
 764   stream_write_tree (ob, TREE_CHAIN (expr), ref_p);
 765 }
 766
 767
 768 /* Write all pointer fields in the TS_VEC structure of EXPR to output
 769    block OB.  If REF_P is true, write a reference to EXPR's pointer
 770    fields.  */
 771
 772 static void
 773 write_ts_vec_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 774 {
 775   int i;
 776
 777   /* Note that the number of slots for EXPR has already been emitted
 778      in EXPR's header (see streamer_write_tree_header).  */
 779   for (i = 0; i < TREE_VEC_LENGTH (expr); i++)
 780     stream_write_tree (ob, TREE_VEC_ELT (expr, i), ref_p);
 781 }
 782
 783
 784 /* Write all pointer fields in the TS_EXP structure of EXPR to output
 785    block OB.  If REF_P is true, write a reference to EXPR's pointer
 786    fields.  */
 787
 788 static void
 789 write_ts_exp_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 790 {
 791   int i;
 792
 793   for (i = 0; i < TREE_OPERAND_LENGTH (expr); i++)
 794     stream_write_tree (ob, TREE_OPERAND (expr, i), ref_p);
 795   stream_write_tree (ob, TREE_BLOCK (expr), ref_p);
 796 }
 797
 798
 799 /* Write all pointer fields in the TS_BLOCK structure of EXPR to output
 800    block OB.  If REF_P is true, write a reference to EXPR's pointer
 801    fields.  */
 802
 803 static void
 804 write_ts_block_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 805 {
 806   streamer_write_chain (ob, BLOCK_VARS (expr), ref_p);
 807
 808   stream_write_tree (ob, BLOCK_SUPERCONTEXT (expr), ref_p);
 809
 810   /* Stream BLOCK_ABSTRACT_ORIGIN for the limited cases we can handle - those
 811      that represent inlined function scopes.
 812      For the rest them on the floor instead of ICEing in dwarf2out.c.  */
 813   if (inlined_function_outer_scope_p (expr))
 814     {
 815       tree ultimate_origin = block_ultimate_origin (expr);
 816       stream_write_tree (ob, ultimate_origin, ref_p);
 817     }
 818   else
 819     stream_write_tree (ob, NULL_TREE, ref_p);
 820   /* Do not stream BLOCK_NONLOCALIZED_VARS.  We cannot handle debug information
 821      for early inlined BLOCKs so drop it on the floor instead of ICEing in
 822      dwarf2out.c.  */
 823
 824   /* BLOCK_FRAGMENT_ORIGIN and BLOCK_FRAGMENT_CHAIN is not live at LTO
 825      streaming time.  */
 826
 827   /* Do not output BLOCK_SUBBLOCKS.  Instead on streaming-in this
 828      list is re-constructed from BLOCK_SUPERCONTEXT.  */
 829 }
 830
 831
 832 /* Write all pointer fields in the TS_BINFO structure of EXPR to output
 833    block OB.  If REF_P is true, write a reference to EXPR's pointer
 834    fields.  */
 835
 836 static void
 837 write_ts_binfo_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 838 {
 839   unsigned i;
 840   tree t;
 841
 842   /* Note that the number of BINFO slots has already been emitted in
 843      EXPR's header (see streamer_write_tree_header) because this length
 844      is needed to build the empty BINFO node on the reader side.  */
 845   FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (expr), i, t)
 846     stream_write_tree (ob, t, ref_p);
 847   stream_write_tree (ob, NULL_TREE, false);
 848
 849   stream_write_tree (ob, BINFO_OFFSET (expr), ref_p);
 850   stream_write_tree (ob, BINFO_VTABLE (expr), ref_p);
 851   stream_write_tree (ob, BINFO_VPTR_FIELD (expr), ref_p);
 852
 853   /* The number of BINFO_BASE_ACCESSES has already been emitted in
 854      EXPR's bitfield section.  */
 855   FOR_EACH_VEC_SAFE_ELT (BINFO_BASE_ACCESSES (expr), i, t)
 856     stream_write_tree (ob, t, ref_p);
 857
 858   /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX
 859      and BINFO_VPTR_INDEX; these are used by C++ FE only.  */
 860 }
 861
 862
 863 /* Write all pointer fields in the TS_CONSTRUCTOR structure of EXPR to
 864    output block OB.  If REF_P is true, write a reference to EXPR's
 865    pointer fields.  */
 866
 867 static void
 868 write_ts_constructor_tree_pointers (struct output_block *ob, tree expr,
 869                                     bool ref_p)
 870 {
 871   unsigned i;
 872   tree index, value;
 873
 874   FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (expr), i, index, value)
 875     {
 876       stream_write_tree (ob, index, ref_p);
 877       stream_write_tree (ob, value, ref_p);
 878     }
 879 }
 880
 881
 882 /* Write all pointer fields in the TS_OMP_CLAUSE structure of EXPR
 883    to output block OB.  If REF_P is true, write a reference to EXPR's
 884    pointer fields.  */
 885
 886 static void
 887 write_ts_omp_clause_tree_pointers (struct output_block *ob, tree expr,
 888                                    bool ref_p)
 889 {
 890   int i;
 891   for (i = 0; i < omp_clause_num_ops[OMP_CLAUSE_CODE (expr)]; i++)
 892     stream_write_tree (ob, OMP_CLAUSE_OPERAND (expr, i), ref_p);
 893   if (OMP_CLAUSE_CODE (expr) == OMP_CLAUSE_REDUCTION)
 894     {
 895       /* We don't stream these right now, handle it if streaming
 896          of them is needed.  */
 897       gcc_assert (OMP_CLAUSE_REDUCTION_GIMPLE_INIT (expr) == NULL);
 898       gcc_assert (OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (expr) == NULL);
 899     }
 900   stream_write_tree (ob, OMP_CLAUSE_CHAIN (expr), ref_p);
 901 }
 902
 903
 904 /* Write all pointer fields in EXPR to output block OB.  If REF_P is true,
 905    the leaves of EXPR are emitted as references.  */
 906
 907 void
 908 streamer_write_tree_body (struct output_block *ob, tree expr, bool ref_p)
 909 {
 910   enum tree_code code;
 911
 912   lto_stats.num_tree_bodies_output++;
 913
 914   code = TREE_CODE (expr);
 915
 916   if (CODE_CONTAINS_STRUCT (code, TS_TYPED))
 917     write_ts_common_tree_pointers (ob, expr, ref_p);
 918
 919   if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
 920     write_ts_vector_tree_pointers (ob, expr, ref_p);
 921
 922   if (CODE_CONTAINS_STRUCT (code, TS_COMPLEX))
 923     write_ts_complex_tree_pointers (ob, expr, ref_p);
 924
 925   if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
 926     write_ts_decl_minimal_tree_pointers (ob, expr, ref_p);
 927
 928   if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
 929     write_ts_decl_common_tree_pointers (ob, expr, ref_p);
 930
 931   if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
 932     write_ts_decl_non_common_tree_pointers (ob, expr, ref_p);
 933
 934   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
 935     write_ts_decl_with_vis_tree_pointers (ob, expr, ref_p);
 936
 937   if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL))
 938     write_ts_field_decl_tree_pointers (ob, expr, ref_p);
 939
 940   if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
 941     write_ts_function_decl_tree_pointers (ob, expr, ref_p);
 942
 943   if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
 944     write_ts_type_common_tree_pointers (ob, expr, ref_p);
 945
 946   if (CODE_CONTAINS_STRUCT (code, TS_TYPE_NON_COMMON))
 947     write_ts_type_non_common_tree_pointers (ob, expr, ref_p);
 948
 949   if (CODE_CONTAINS_STRUCT (code, TS_LIST))
 950     write_ts_list_tree_pointers (ob, expr, ref_p);
 951
 952   if (CODE_CONTAINS_STRUCT (code, TS_VEC))
 953     write_ts_vec_tree_pointers (ob, expr, ref_p);
 954
 955   if (CODE_CONTAINS_STRUCT (code, TS_EXP))
 956     write_ts_exp_tree_pointers (ob, expr, ref_p);
 957
 958   if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
 959     write_ts_block_tree_pointers (ob, expr, ref_p);
 960
 961   if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
 962     write_ts_binfo_tree_pointers (ob, expr, ref_p);
 963
 964   if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
 965     write_ts_constructor_tree_pointers (ob, expr, ref_p);
 966
 967   if (code == OMP_CLAUSE)
 968     write_ts_omp_clause_tree_pointers (ob, expr, ref_p);
 969 }
 970
 971
 972 /* Emit header information for tree EXPR to output block OB.  The header
 973    contains everything needed to instantiate an empty skeleton for
 974    EXPR on the reading side.  IX is the index into the streamer cache
 975    where EXPR is stored.  */
 976
 977 void
 978 streamer_write_tree_header (struct output_block *ob, tree expr)
 979 {
 980   enum LTO_tags tag;
 981   enum tree_code code;
 982
 983   /* We should not see any tree nodes not handled by the streamer.  */
 984   code = TREE_CODE (expr);
 985
 986   /* The header of a tree node consists of its tag, the size of
 987      the node, and any other information needed to instantiate
 988      EXPR on the reading side (such as the number of slots in
 989      variable sized nodes).  */
 990   tag = lto_tree_code_to_tag (code);
 991   streamer_write_record_start (ob, tag);
 992
 993   /* The following will cause bootstrap miscomparisons.  Enable with care.  */
 994 #ifdef LTO_STREAMER_DEBUG
 995   /* This is used mainly for debugging purposes.  When the reader
 996      and the writer do not agree on a streamed node, the pointer
 997      value for EXPR can be used to track down the differences in
 998      the debugger.  */
 999   gcc_assert ((HOST_WIDEST_INT) (intptr_t) expr == (intptr_t) expr);
1000   streamer_write_hwi (ob, (HOST_WIDEST_INT) (intptr_t) expr);
1001 #endif
1002
1003   /* The text in strings and identifiers are completely emitted in
1004      the header.  */
1005   if (CODE_CONTAINS_STRUCT (code, TS_STRING))
1006     streamer_write_string_cst (ob, ob->main_stream, expr);
1007   else if (CODE_CONTAINS_STRUCT (code, TS_IDENTIFIER))
1008     write_identifier (ob, ob->main_stream, expr);
1009   else if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
1010     streamer_write_hwi (ob, VECTOR_CST_NELTS (expr));
1011   else if (CODE_CONTAINS_STRUCT (code, TS_VEC))
1012     streamer_write_hwi (ob, TREE_VEC_LENGTH (expr));
1013   else if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
1014     streamer_write_uhwi (ob, BINFO_N_BASE_BINFOS (expr));
1015   else if (TREE_CODE (expr) == CALL_EXPR)
1016     streamer_write_uhwi (ob, call_expr_nargs (expr));
1017   else if (TREE_CODE (expr) == OMP_CLAUSE)
1018     streamer_write_uhwi (ob, OMP_CLAUSE_CODE (expr));
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   gcc_assert (!TREE_OVERFLOW (cst));
1029   streamer_write_record_start (ob, LTO_integer_cst);
1030   stream_write_tree (ob, TREE_TYPE (cst), ref_p);
1031   streamer_write_uhwi (ob, TREE_INT_CST_LOW (cst));
1032   streamer_write_hwi (ob, TREE_INT_CST_HIGH (cst));
1033 }