gcc/lto-streamer.h

   1 /* Data structures and declarations used for reading and writing
   2    GIMPLE to a file stream.
   3
   4    Copyright (C) 2009 Free Software Foundation, Inc.
   5    Contributed by Doug Kwan <dougkwan@google.com>
   6
   7 This file is part of GCC.
   8
   9 GCC is free software; you can redistribute it and/or modify it under
  10 the terms of the GNU General Public License as published by the Free
  11 Software Foundation; either version 3, or (at your option) any later
  12 version.
  13
  14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  16 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  17 for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GCC; see the file COPYING3.  If not see
  21 <http://www.gnu.org/licenses/>.  */
  22
  23 #ifndef GCC_LTO_STREAMER_H
  24 #define GCC_LTO_STREAMER_H
  25
  26 #include "plugin-api.h"
  27 #include "tree.h"
  28 #include "gimple.h"
  29 #include "target.h"
  30 #include "cgraph.h"
  31 #include "vec.h"
  32 #include "vecprim.h"
  33
  34 /* Define when debugging the LTO streamer.  This causes the writer
  35    to output the numeric value for the memory address of the tree node
  36    being emitted.  When debugging a problem in the reader, check the
  37    original address that the writer was emitting using lto_orig_address_get.
  38    With this value, set a breakpoint in the writer (e.g., lto_output_tree)
  39    to trace how the faulty node is being emitted.  */
  40 /* #define LTO_STREAMER_DEBUG   1  */
  41
  42 /* The encoding for a function consists of the following sections:
  43
  44    1)    The header.
  45    2)    FIELD_DECLS.
  46    3)    FUNCTION_DECLS.
  47    4)    global VAR_DECLS.
  48    5)    type_decls
  49    6)    types.
  50    7)    Names for the labels that have names
  51    8)    The SSA names.
  52    9)    The control flow graph.
  53    10-11)Gimple for local decls.
  54    12)   Gimple for the function.
  55    13)   Strings.
  56
  57    1) THE HEADER.
  58    2-6) THE GLOBAL DECLS AND TYPES.
  59
  60       The global decls and types are encoded in the same way.  For each
  61       entry, there is word with the offset within the section to the
  62       entry.
  63
  64    7) THE LABEL NAMES.
  65
  66       Since most labels do not have names, this section my be of zero
  67       length.  It consists of an array of string table references, one
  68       per label.  In the lto code, the labels are given either
  69       positive or negative indexes.  the positive ones have names and
  70       the negative ones do not.  The positive index can be used to
  71       find the name in this array.
  72
  73    9) THE CFG.
  74
  75    10) Index into the local decls.  Since local decls can have local
  76       decls inside them, they must be read in randomly in order to
  77       properly restore them.
  78
  79    11-12) GIMPLE FOR THE LOCAL DECLS AND THE FUNCTION BODY.
  80
  81      The gimple consists of a set of records.
  82
  83      THE FUNCTION
  84
  85      At the top level of (8) is the function. It consists of five
  86      pieces:
  87
  88      LTO_function     - The tag.
  89      eh tree          - This is all of the exception handling regions
  90                         put out in a post order traversial of the
  91                         tree.  Siblings are output as lists terminated
  92                         by a 0.  The set of fields matches the fields
  93                         defined in except.c.
  94
  95      last_basic_block - in uleb128 form.
  96
  97      basic blocks     - This is the set of basic blocks.
  98
  99      zero             - The termination of the basic blocks.
 100
 101      BASIC BLOCKS
 102
 103      There are two forms of basic blocks depending on if they are
 104      empty or not.
 105
 106      The basic block consists of:
 107
 108      LTO_bb1 or LTO_bb0 - The tag.
 109
 110      bb->index          - the index in uleb128 form.
 111
 112      #succs             - The number of successors un uleb128 form.
 113
 114      the successors     - For each edge, a pair.  The first of the
 115                           pair is the index of the successor in
 116                           uleb128 form and the second are the flags in
 117                           uleb128 form.
 118
 119      the statements     - A gimple tree, as described above.
 120                           These are only present for LTO_BB1.
 121                           Following each statement is an optional
 122                           exception handling record LTO_eh_region
 123                           which contains the region number (for
 124                           regions >= 0).
 125
 126      zero               - This is only present for LTO_BB1 and is used
 127                           to terminate the statements and exception
 128                           regions within this block.
 129
 130    12) STRINGS
 131
 132      String are represented in the table as pairs, a length in ULEB128
 133      form followed by the data for the string.  */
 134
 135 /* The string that is the prefix on the section names we make for lto.
 136    For decls the DECL_ASSEMBLER_NAME is appended to make the section
 137    name for the functions and static_initializers.  For other types of
 138    sections a '.' and the section type are appended.  */
 139 #define LTO_SECTION_NAME_PREFIX         ".gnu.lto_"
 140
 141 #define LTO_major_version 1
 142 #define LTO_minor_version 0
 143
 144 typedef unsigned char   lto_decl_flags_t;
 145
 146
 147 /* Data structures used to pack values and bitflags into a vector of
 148    words.  Used to stream values of a fixed number of bits in a space
 149    efficient way.  */
 150 static unsigned const BITS_PER_BITPACK_WORD = HOST_BITS_PER_WIDE_INT;
 151
 152 typedef unsigned HOST_WIDE_INT bitpack_word_t;
 153 DEF_VEC_I(bitpack_word_t);
 154 DEF_VEC_ALLOC_I(bitpack_word_t, heap);
 155
 156 struct bitpack_d
 157 {
 158   /* Total number of bits packed/unpacked so far.  */
 159   size_t num_bits;
 160
 161   /* Values are stored contiguously, so there may be internal
 162      fragmentation (words with unused bits).  Therefore, we need to
 163      keep track of the first available bit in the last word of the
 164      bitpack.  */
 165   size_t first_unused_bit;
 166
 167   /* Vector of words holding the packed values.  */
 168   VEC(bitpack_word_t, heap) *values;
 169 };
 170
 171 /* Tags representing the various IL objects written to the bytecode file
 172    (GIMPLE statements, basic blocks, EH regions, tree nodes, etc).
 173
 174    NOTE, when adding new LTO tags, also update lto_tag_name.  */
 175 enum LTO_tags
 176 {
 177   LTO_null = 0,
 178
 179   /* Reserve enough entries to fit all the tree and gimple codes handled
 180      by the streamer.  This guarantees that:
 181
 182      1- Given a tree code C:
 183                 enum LTO_tags tag == C + 1
 184
 185      2- Given a gimple code C:
 186                 enum LTO_tags tag == C + NUM_TREE_CODES + 1
 187
 188      Conversely, to map between LTO tags and tree/gimple codes, the
 189      reverse operation must be applied.  */
 190   LTO_bb0 = 1 + NUM_TREE_CODES + LAST_AND_UNUSED_GIMPLE_CODE,
 191   LTO_bb1,
 192
 193   /* EH region holding the previous statement.  */
 194   LTO_eh_region,
 195
 196   /* An MD or NORMAL builtin.  Only the code and class are streamed out.  */
 197   LTO_builtin_decl,
 198
 199   /* Function body.  */
 200   LTO_function,
 201
 202   /* EH table.  */
 203   LTO_eh_table,
 204
 205   /* EH region types.  These mirror enum eh_region_type.  */
 206   LTO_ert_cleanup,
 207   LTO_ert_try,
 208   LTO_ert_allowed_exceptions,
 209   LTO_ert_must_not_throw,
 210
 211   /* EH landing pad.  */
 212   LTO_eh_landing_pad,
 213
 214   /* EH try/catch node.  */
 215   LTO_eh_catch,
 216
 217   /* Special for global streamer. Reference to previously-streamed node.  */
 218   LTO_tree_pickle_reference,
 219
 220   /* References to indexable tree nodes.  These objects are stored in
 221      tables that are written separately from the function bodies that
 222      reference them.  This way they can be instantiated even when the
 223      referencing functions aren't (e.g., during WPA) and it also allows
 224      functions to be copied from one file to another without having
 225      to unpickle the body first (the references are location
 226      independent).
 227
 228      NOTE, do not regroup these values as the grouping is exposed
 229      in the range checks done in lto_input_tree.  */
 230   LTO_field_decl_ref,                   /* Do not change.  */
 231   LTO_function_decl_ref,
 232   LTO_label_decl_ref,
 233   LTO_namespace_decl_ref,
 234   LTO_result_decl_ref,
 235   LTO_ssa_name_ref,
 236   LTO_type_decl_ref,
 237   LTO_type_ref,
 238   LTO_const_decl_ref,
 239   LTO_imported_decl_ref,
 240   LTO_global_decl_ref,                  /* Do not change.  */
 241
 242   /* This tag must always be last.  */
 243   LTO_NUM_TAGS
 244 };
 245
 246
 247 /* Set of section types that are in an LTO file.  This list will grow
 248    as the number of IPA passes grows since each IPA pass will need its
 249    own section type to store its summary information.
 250
 251    When adding a new section type, you must also extend the
 252    LTO_SECTION_NAME array in lto-section-in.c.  */
 253 enum lto_section_type
 254 {
 255   LTO_section_decls = 0,
 256   LTO_section_function_body,
 257   LTO_section_static_initializer,
 258   LTO_section_cgraph,
 259   LTO_section_ipa_pure_const,
 260   LTO_section_ipa_reference,
 261   LTO_section_symtab,
 262   LTO_section_wpa_fixup,
 263   LTO_section_opts,
 264   LTO_N_SECTION_TYPES           /* Must be last.  */
 265 };
 266
 267 /* Indices to the various function, type and symbol streams. */
 268 typedef enum
 269 {
 270   LTO_DECL_STREAM_TYPE = 0,             /* Must be first. */
 271   LTO_DECL_STREAM_FIELD_DECL,
 272   LTO_DECL_STREAM_FN_DECL,
 273   LTO_DECL_STREAM_VAR_DECL,
 274   LTO_DECL_STREAM_TYPE_DECL,
 275   LTO_DECL_STREAM_NAMESPACE_DECL,
 276   LTO_DECL_STREAM_LABEL_DECL,
 277   LTO_N_DECL_STREAMS
 278 } lto_decl_stream_e_t;
 279
 280 typedef enum ld_plugin_symbol_resolution ld_plugin_symbol_resolution_t;
 281 DEF_VEC_I(ld_plugin_symbol_resolution_t);
 282 DEF_VEC_ALLOC_I(ld_plugin_symbol_resolution_t, heap);
 283
 284
 285 /* Macro to define convenience functions for type and decl streams
 286    in lto_file_decl_data.  */
 287 #define DEFINE_DECL_STREAM_FUNCS(UPPER_NAME, name) \
 288 static inline tree \
 289 lto_file_decl_data_get_ ## name (struct lto_file_decl_data *data, \
 290                                  unsigned int idx) \
 291 { \
 292   struct lto_in_decl_state *state = data->current_decl_state; \
 293   gcc_assert (idx < state->streams[LTO_DECL_STREAM_## UPPER_NAME].size); \
 294   return state->streams[LTO_DECL_STREAM_## UPPER_NAME].trees[idx]; \
 295 } \
 296 \
 297 static inline unsigned int \
 298 lto_file_decl_data_num_ ## name ## s (struct lto_file_decl_data *data) \
 299 { \
 300   struct lto_in_decl_state *state = data->current_decl_state; \
 301   return state->streams[LTO_DECL_STREAM_## UPPER_NAME].size; \
 302 }
 303
 304
 305 /* Return a char pointer to the start of a data stream for an lto pass
 306    or function.  The first parameter is the file data that contains
 307    the information.  The second parameter is the type of information
 308    to be obtained.  The third parameter is the name of the function
 309    and is only used when finding a function body; otherwise it is
 310    NULL.  The fourth parameter is the length of the data returned.  */
 311 typedef const char* (lto_get_section_data_f) (struct lto_file_decl_data *,
 312                                               enum lto_section_type,
 313                                               const char *,
 314                                               size_t *);
 315
 316 /* Return the data found from the above call.  The first three
 317    parameters are the same as above.  The fourth parameter is the data
 318    itself and the fifth is the lenght of the data. */
 319 typedef void (lto_free_section_data_f) (struct lto_file_decl_data *,
 320                                         enum lto_section_type,
 321                                         const char *,
 322                                         const char *,
 323                                         size_t);
 324
 325 /* Cache of pickled nodes.  Used to avoid writing the same node more
 326    than once.  The first time a tree node is streamed out, it is
 327    entered in this cache.  Subsequent references to the same node are
 328    resolved by looking it up in this cache.
 329
 330    This is used in two ways:
 331
 332    - On the writing side, the first time T is added to STREAMER_CACHE,
 333      a new reference index is created for T and T is emitted on the
 334      stream.  If T needs to be emitted again to the stream, instead of
 335      pickling it again, the reference index is emitted.
 336
 337    - On the reading side, the first time T is read from the stream, it
 338      is reconstructed in memory and a new reference index created for
 339      T.  The reconstructed T is inserted in some array so that when
 340      the reference index for T is found in the input stream, it can be
 341      used to look up into the array to get the reconstructed T.  */
 342 struct lto_streamer_cache_d
 343 {
 344   /* The mapping between tree nodes and slots into the nodes array.  */
 345   htab_t node_map;
 346
 347   /* Next available slot in the nodes and offsets arrays.  */
 348   unsigned next_slot;
 349
 350   /* The nodes pickled so far.  */
 351   VEC(tree,gc) *nodes;
 352
 353   /* Offset into the stream where the nodes have been written.  */
 354   VEC(unsigned,heap) *offsets;
 355 };
 356
 357
 358 /* Structure used as buffer for reading an LTO file.  */
 359 struct lto_input_block
 360 {
 361   const char *data;
 362   unsigned int p;
 363   unsigned int len;
 364 };
 365
 366 #define LTO_INIT_INPUT_BLOCK(BASE,D,P,L)   \
 367   do {                                     \
 368     BASE.data = D;                         \
 369     BASE.p = P;                            \
 370     BASE.len = L;                          \
 371   } while (0)
 372
 373 #define LTO_INIT_INPUT_BLOCK_PTR(BASE,D,P,L) \
 374   do {                                       \
 375     BASE->data = D;                          \
 376     BASE->p = P;                             \
 377     BASE->len = L;                           \
 378   } while (0)
 379
 380
 381 /* The is the first part of the record for a function or constructor
 382    in the .o file.  */
 383 struct lto_header
 384 {
 385   int16_t major_version;
 386   int16_t minor_version;
 387   enum lto_section_type section_type;
 388 };
 389
 390 /* The header for a function body.  */
 391 struct lto_function_header
 392 {
 393   /* The header for all types of sections. */
 394   struct lto_header lto_header;
 395
 396   /* Number of labels with names.  */
 397   int32_t num_named_labels;
 398
 399   /* Number of labels without names.  */
 400   int32_t num_unnamed_labels;
 401
 402   /* Size compressed or 0 if not compressed.  */
 403   int32_t compressed_size;
 404
 405   /* Size of names for named labels.  */
 406   int32_t named_label_size;
 407
 408   /* Size of the cfg.  */
 409   int32_t cfg_size;
 410
 411   /* Size of main gimple body of function.  */
 412   int32_t main_size;
 413
 414   /* Size of the string table.  */
 415   int32_t string_size;
 416 };
 417
 418
 419 /* Structure describing a symbol section.  */
 420 struct lto_decl_header
 421 {
 422   /* The header for all types of sections. */
 423   struct lto_header lto_header;
 424
 425   /* Size of region for decl state. */
 426   int32_t decl_state_size;
 427
 428   /* Number of nodes in globals stream.  */
 429   int32_t num_nodes;
 430
 431   /* Size of region for expressions, decls, types, etc. */
 432   int32_t main_size;
 433
 434   /* Size of the string table.  */
 435   int32_t string_size;
 436 };
 437
 438
 439 /* Statistics gathered during LTO, WPA and LTRANS.  */
 440 struct lto_stats_d
 441 {
 442   unsigned HOST_WIDE_INT num_input_cgraph_nodes;
 443   unsigned HOST_WIDE_INT num_output_cgraph_nodes;
 444   unsigned HOST_WIDE_INT num_input_files;
 445   unsigned HOST_WIDE_INT num_output_files;
 446   unsigned HOST_WIDE_INT num_cgraph_partitions;
 447   unsigned HOST_WIDE_INT section_size[LTO_N_SECTION_TYPES];
 448   unsigned HOST_WIDE_INT num_function_bodies;
 449   unsigned HOST_WIDE_INT num_trees[NUM_TREE_CODES];
 450   unsigned HOST_WIDE_INT num_output_il_bytes;
 451   unsigned HOST_WIDE_INT num_compressed_il_bytes;
 452   unsigned HOST_WIDE_INT num_input_il_bytes;
 453   unsigned HOST_WIDE_INT num_uncompressed_il_bytes;
 454 };
 455
 456 /* Encoder data structure used to stream callgraph nodes.  */
 457 struct lto_cgraph_encoder_d
 458 {
 459   /* Map nodes to reference number. */
 460   struct pointer_map_t *map;
 461
 462   /* Map reference number to node. */
 463   VEC(cgraph_node_ptr,heap) *nodes;
 464 };
 465
 466 typedef struct lto_cgraph_encoder_d *lto_cgraph_encoder_t;
 467
 468 /* Mapping from indices to trees.  */
 469 struct lto_tree_ref_table
 470 {
 471   /* Array of referenced trees . */
 472   tree *trees;
 473
 474   /* Size of array. */
 475   unsigned int size;
 476 };
 477
 478
 479 /* Mapping between trees and slots in an array.  */
 480 struct lto_decl_slot
 481 {
 482   tree t;
 483   int slot_num;
 484 };
 485
 486
 487 /* The lto_tree_ref_encoder struct is used to encode trees into indices. */
 488
 489 struct lto_tree_ref_encoder
 490 {
 491   htab_t tree_hash_table;       /* Maps pointers to indices. */
 492   unsigned int next_index;      /* Next available index. */
 493   VEC(tree,heap) *trees;        /* Maps indices to pointers. */
 494 };
 495
 496
 497 /* Structure to hold states of input scope.  */
 498 struct lto_in_decl_state
 499 {
 500   /* Array of lto_in_decl_buffers to store type and decls streams. */
 501   struct lto_tree_ref_table streams[LTO_N_DECL_STREAMS];
 502
 503   /* If this in-decl state is associated with a function. FN_DECL
 504      point to the FUNCTION_DECL. */
 505   tree fn_decl;
 506 };
 507
 508 typedef struct lto_in_decl_state *lto_in_decl_state_ptr;
 509
 510
 511 /* The structure that holds all of the vectors of global types,
 512    decls and cgraph nodes used in the serialization of this file.  */
 513 struct lto_out_decl_state
 514 {
 515   /* The buffers contain the sets of decls of various kinds and types we have
 516      seen so far and the indexes assigned to them.  */
 517   struct lto_tree_ref_encoder streams[LTO_N_DECL_STREAMS];
 518
 519   /* Encoder for cgraph nodes.  */
 520   lto_cgraph_encoder_t cgraph_node_encoder;
 521
 522   /* If this out-decl state belongs to a function, fn_decl points to that
 523      function.  Otherwise, it is NULL. */
 524   tree fn_decl;
 525 };
 526
 527 typedef struct lto_out_decl_state *lto_out_decl_state_ptr;
 528
 529 DEF_VEC_P(lto_out_decl_state_ptr);
 530 DEF_VEC_ALLOC_P(lto_out_decl_state_ptr, heap);
 531
 532 /* One of these is allocated for each object file that being compiled
 533    by lto.  This structure contains the tables that are needed by the
 534    serialized functions and ipa passes to connect themselves to the
 535    global types and decls as they are reconstituted.  */
 536 struct lto_file_decl_data
 537 {
 538   /* Decl state currently used. */
 539   struct lto_in_decl_state *current_decl_state;
 540
 541   /* Decl state corresponding to regions outside of any functions
 542      in the compilation unit. */
 543   struct lto_in_decl_state *global_decl_state;
 544
 545   /* Table of cgraph nodes present in this file.  */
 546   lto_cgraph_encoder_t cgraph_node_encoder;
 547
 548   /* Hash table maps lto-related section names to location in file.  */
 549   htab_t function_decl_states;
 550
 551   /* The .o file that these offsets relate to.  */
 552   const char *file_name;
 553
 554   /* Nonzero if this file should be recompiled with LTRANS.  */
 555   unsigned needs_ltrans_p : 1;
 556
 557   /* If the file is open, this is the fd of the mapped section.  This
 558      is -1 if the file has not yet been opened.  */
 559   int fd;
 560
 561   /* Hash table maps lto-related section names to location in file.  */
 562   htab_t section_hash_table;
 563
 564   /* Hash new name of renamed global declaration to its original name.  */
 565   htab_t renaming_hash_table;
 566 };
 567
 568 struct lto_char_ptr_base
 569 {
 570   char *ptr;
 571 };
 572
 573 /* An incore byte stream to buffer the various parts of the function.
 574    The entire structure should be zeroed when created.  The record
 575    consists of a set of blocks.  The first sizeof (ptr) bytes are used
 576    as a chain, and the rest store the bytes to be written.  */
 577 struct lto_output_stream
 578 {
 579   /* The pointer to the first block in the stream.  */
 580   struct lto_char_ptr_base * first_block;
 581
 582   /* The pointer to the last and current block in the stream.  */
 583   struct lto_char_ptr_base * current_block;
 584
 585   /* The pointer to where the next char should be written.  */
 586   char * current_pointer;
 587
 588   /* The number of characters left in the current block.  */
 589   unsigned int left_in_block;
 590
 591   /* The block size of the last block allocated.  */
 592   unsigned int block_size;
 593
 594   /* The total number of characters written.  */
 595   unsigned int total_size;
 596 };
 597
 598 /* The is the first part of the record in an LTO file for many of the
 599    IPA passes.  */
 600 struct lto_simple_header
 601 {
 602   /* The header for all types of sections. */
 603   struct lto_header lto_header;
 604
 605   /* Size of main gimple body of function.  */
 606   int32_t main_size;
 607
 608   /* Size of main stream when compressed.  */
 609   int32_t compressed_size;
 610 };
 611
 612 /* A simple output block.  This can be used for simple IPA passes that
 613    do not need more than one stream.  */
 614 struct lto_simple_output_block
 615 {
 616   enum lto_section_type section_type;
 617   struct lto_out_decl_state *decl_state;
 618
 619   /* The stream that the main tree codes are written to.  */
 620   struct lto_output_stream *main_stream;
 621 };
 622
 623 /* Data structure holding all the data and descriptors used when writing
 624    an LTO file.  */
 625 struct output_block
 626 {
 627   enum lto_section_type section_type;
 628   struct lto_out_decl_state *decl_state;
 629
 630   /* The stream that the main tree codes are written to.  */
 631   struct lto_output_stream *main_stream;
 632
 633   /* The stream that contains the string table.  */
 634   struct lto_output_stream *string_stream;
 635
 636   /* The stream that contains the cfg.  */
 637   struct lto_output_stream *cfg_stream;
 638
 639   /* The hash table that contains the set of strings we have seen so
 640      far and the indexes assigned to them.  */
 641   htab_t string_hash_table;
 642
 643   /* The current cgraph_node that we are currently serializing.  Null
 644      if we are serializing something else.  */
 645   struct cgraph_node *cgraph_node;
 646
 647   /* These are the last file and line that were seen in the stream.
 648      If the current node differs from these, it needs to insert
 649      something into the stream and fix these up.  */
 650   const char *current_file;
 651   int current_line;
 652   int current_col;
 653
 654   /* True if writing globals and types.  */
 655   bool global;
 656
 657   /* Cache of nodes written in this section.  */
 658   struct lto_streamer_cache_d *writer_cache;
 659 };
 660
 661
 662 /* Data and descriptors used when reading from an LTO file.  */
 663 struct data_in
 664 {
 665   /* The global decls and types.  */
 666   struct lto_file_decl_data *file_data;
 667
 668   /* All of the labels.  */
 669   tree *labels;
 670
 671   /* The string table.  */
 672   const char *strings;
 673
 674   /* The length of the string table.  */
 675   unsigned int strings_len;
 676
 677   /* Number of named labels.  Used to find the index of unnamed labels
 678      since they share space with the named labels.  */
 679   unsigned int num_named_labels;
 680
 681   /* Number of unnamed labels.  */
 682   unsigned int num_unnamed_labels;
 683
 684   const char *current_file;
 685   int current_line;
 686   int current_col;
 687
 688   /* Maps each reference number to the resolution done by the linker. */
 689   VEC(ld_plugin_symbol_resolution_t,heap) *globals_resolution;
 690
 691   /* Cache of pickled nodes.  */
 692   struct lto_streamer_cache_d *reader_cache;
 693 };
 694
 695
 696 /* In lto-section-in.c  */
 697 extern struct lto_input_block * lto_create_simple_input_block (
 698                                struct lto_file_decl_data *,
 699                                enum lto_section_type, const char **, size_t *);
 700 extern void
 701 lto_destroy_simple_input_block (struct lto_file_decl_data *,
 702                                 enum lto_section_type,
 703                                 struct lto_input_block *, const char *, size_t);
 704 extern void lto_set_in_hooks (struct lto_file_decl_data **,
 705                               lto_get_section_data_f *,
 706                               lto_free_section_data_f *);
 707 extern struct lto_file_decl_data **lto_get_file_decl_data (void);
 708 extern const char *lto_get_section_data (struct lto_file_decl_data *,
 709                                          enum lto_section_type,
 710                                          const char *, size_t *);
 711 extern void lto_free_section_data (struct lto_file_decl_data *,
 712                                    enum lto_section_type,
 713                                    const char *, const char *, size_t);
 714 extern unsigned char lto_input_1_unsigned (struct lto_input_block *);
 715 extern unsigned HOST_WIDE_INT lto_input_uleb128 (struct lto_input_block *);
 716 extern unsigned HOST_WIDEST_INT lto_input_widest_uint_uleb128 (
 717                                                 struct lto_input_block *);
 718 extern HOST_WIDE_INT lto_input_sleb128 (struct lto_input_block *);
 719 extern htab_t lto_create_renaming_table (void);
 720 extern void lto_record_renamed_decl (struct lto_file_decl_data *,
 721                                      const char *, const char *);
 722 extern const char *lto_get_decl_name_mapping (struct lto_file_decl_data *,
 723                                               const char *);
 724 extern struct lto_in_decl_state *lto_new_in_decl_state (void);
 725 extern void lto_delete_in_decl_state (struct lto_in_decl_state *);
 726 extern hashval_t lto_hash_in_decl_state (const void *);
 727 extern int lto_eq_in_decl_state (const void *, const void *);
 728 extern struct lto_in_decl_state *lto_get_function_in_decl_state (
 729                                       struct lto_file_decl_data *, tree);
 730
 731 /* In lto-section-out.c  */
 732 extern hashval_t lto_hash_decl_slot_node (const void *);
 733 extern int lto_eq_decl_slot_node (const void *, const void *);
 734 extern hashval_t lto_hash_type_slot_node (const void *);
 735 extern int lto_eq_type_slot_node (const void *, const void *);
 736 extern void lto_begin_section (const char *, bool);
 737 extern void lto_end_section (void);
 738 extern void lto_write_stream (struct lto_output_stream *);
 739 extern void lto_output_1_stream (struct lto_output_stream *, char);
 740 extern void lto_output_data_stream (struct lto_output_stream *, const void *,
 741                                     size_t);
 742 extern void lto_output_uleb128_stream (struct lto_output_stream *,
 743                                        unsigned HOST_WIDE_INT);
 744 extern void lto_output_widest_uint_uleb128_stream (struct lto_output_stream *,
 745                                                    unsigned HOST_WIDEST_INT);
 746 extern void lto_output_sleb128_stream (struct lto_output_stream *,
 747                                        HOST_WIDE_INT);
 748 extern bool lto_output_decl_index (struct lto_output_stream *,
 749                             struct lto_tree_ref_encoder *,
 750                             tree, unsigned int *);
 751 extern void lto_output_field_decl_index (struct lto_out_decl_state *,
 752                                   struct lto_output_stream *, tree);
 753 extern void lto_output_fn_decl_index (struct lto_out_decl_state *,
 754                                struct lto_output_stream *, tree);
 755 extern void lto_output_namespace_decl_index (struct lto_out_decl_state *,
 756                                       struct lto_output_stream *, tree);
 757 extern void lto_output_var_decl_index (struct lto_out_decl_state *,
 758                                 struct lto_output_stream *, tree);
 759 extern void lto_output_type_decl_index (struct lto_out_decl_state *,
 760                                  struct lto_output_stream *, tree);
 761 extern void lto_output_type_ref_index (struct lto_out_decl_state *,
 762                                 struct lto_output_stream *, tree);
 763 extern struct lto_simple_output_block *lto_create_simple_output_block (
 764                                 enum lto_section_type);
 765 extern void lto_destroy_simple_output_block (struct lto_simple_output_block *);
 766 extern struct lto_out_decl_state *lto_new_out_decl_state (void);
 767 extern void lto_delete_out_decl_state (struct lto_out_decl_state *);
 768 extern struct lto_out_decl_state *lto_get_out_decl_state (void);
 769 extern void lto_push_out_decl_state (struct lto_out_decl_state *);
 770 extern struct lto_out_decl_state *lto_pop_out_decl_state (void);
 771 extern void lto_record_function_out_decl_state (tree,
 772                                                 struct lto_out_decl_state *);
 773 extern void lto_new_extern_inline_states (void);
 774 extern void lto_delete_extern_inline_states (void);
 775 extern void lto_force_functions_extern_inline (bitmap decls);
 776 extern bool lto_forced_extern_inline_p (tree fn_decl);
 777
 778
 779 /* In lto-streamer.c.  */
 780 extern const char *lto_tag_name (enum LTO_tags);
 781 extern bitmap lto_bitmap_alloc (void);
 782 extern void lto_bitmap_free (bitmap);
 783 extern char *lto_get_section_name (int, const char *);
 784 extern void print_lto_report (void);
 785 extern struct bitpack_d *bitpack_create (void);
 786 extern void bitpack_delete (struct bitpack_d *);
 787 extern void bp_pack_value (struct bitpack_d *, bitpack_word_t, unsigned);
 788 extern bitpack_word_t bp_unpack_value (struct bitpack_d *, unsigned);
 789 extern bool lto_streamer_cache_insert (struct lto_streamer_cache_d *, tree,
 790                                        int *, unsigned *);
 791 extern bool lto_streamer_cache_insert_at (struct lto_streamer_cache_d *, tree,
 792                                           int);
 793 extern bool lto_streamer_cache_lookup (struct lto_streamer_cache_d *, tree,
 794                                        int *);
 795 extern tree lto_streamer_cache_get (struct lto_streamer_cache_d *, int);
 796 extern struct lto_streamer_cache_d *lto_streamer_cache_create (void);
 797 extern void lto_streamer_cache_delete (struct lto_streamer_cache_d *);
 798 extern void lto_streamer_init (void);
 799 extern bool gate_lto_out (void);
 800 #ifdef LTO_STREAMER_DEBUG
 801 extern void lto_orig_address_map (tree, intptr_t);
 802 extern intptr_t lto_orig_address_get (tree);
 803 extern void lto_orig_address_remove (tree);
 804 #endif
 805 extern void lto_check_version (int, int);
 806
 807
 808 /* In lto-streamer-in.c */
 809 extern void lto_input_function_body (struct lto_file_decl_data *, tree,
 810                                      const char *);
 811 extern void lto_input_constructors_and_inits (struct lto_file_decl_data *,
 812                                               const char *);
 813 extern void lto_input_cgraph (struct lto_file_decl_data *, const char *);
 814 extern void lto_init_reader (void);
 815 extern tree lto_input_tree (struct lto_input_block *, struct data_in *);
 816 extern void lto_input_function_body (struct lto_file_decl_data *, tree,
 817                                      const char *);
 818 extern void lto_input_constructors_and_inits (struct lto_file_decl_data *,
 819                                               const char *);
 820 extern struct bitpack_d *lto_input_bitpack (struct lto_input_block *);
 821 extern void lto_init_reader (void);
 822 extern struct data_in *lto_data_in_create (struct lto_file_decl_data *,
 823                                     const char *, unsigned,
 824                                     VEC(ld_plugin_symbol_resolution_t,heap) *);
 825 extern void lto_data_in_delete (struct data_in *);
 826
 827
 828 /* In lto-streamer-out.c  */
 829 extern void lto_register_decl_definition (tree, struct lto_file_decl_data *);
 830 extern struct output_block *create_output_block (enum lto_section_type);
 831 extern void destroy_output_block (struct output_block *);
 832 extern void lto_output_tree (struct output_block *, tree, bool);
 833 extern void lto_output_bitpack (struct lto_output_stream *, struct bitpack_d *);
 834
 835
 836 /* In lto-cgraph.c  */
 837 struct cgraph_node *lto_cgraph_encoder_deref (lto_cgraph_encoder_t, int);
 838 int lto_cgraph_encoder_lookup (lto_cgraph_encoder_t, struct cgraph_node *);
 839 lto_cgraph_encoder_t lto_cgraph_encoder_new (void);
 840 int lto_cgraph_encoder_encode (lto_cgraph_encoder_t, struct cgraph_node *);
 841 void lto_cgraph_encoder_delete (lto_cgraph_encoder_t encoder);
 842 void output_cgraph (cgraph_node_set);
 843 void input_cgraph (void);
 844
 845
 846 /* In lto-symtab.c.  */
 847 extern void lto_symtab_register_decl (tree, ld_plugin_symbol_resolution_t,
 848                                       struct lto_file_decl_data *);
 849 extern void lto_symtab_merge_decls (void);
 850 extern tree lto_symtab_prevailing_decl (tree decl);
 851 extern enum ld_plugin_symbol_resolution lto_symtab_get_resolution (tree decl);
 852 extern void lto_symtab_clear_resolution (tree decl);
 853
 854
 855 /* In lto-opts.c.  */
 856 extern void lto_register_user_option (size_t, const char *, int, int);
 857 extern void lto_read_file_options (struct lto_file_decl_data *);
 858 extern void lto_write_options (void);
 859 extern void lto_reissue_options (void);
 860 void lto_clear_user_options (void);
 861 void lto_clear_file_options (void);
 862
 863
 864 /* In lto-wpa-fixup.c  */
 865 void lto_mark_nothrow_fndecl (tree);
 866 void lto_fixup_nothrow_decls (void);
 867
 868
 869 /* Statistics gathered during LTO, WPA and LTRANS.  */
 870 extern struct lto_stats_d lto_stats;
 871
 872 /* Section names corresponding to the values of enum lto_section_type.  */
 873 extern const char *lto_section_name[];
 874
 875 /* Holds all the out decl states of functions output so far in the
 876    current output file.  */
 877 extern VEC(lto_out_decl_state_ptr, heap) *lto_function_decl_states;
 878
 879 /* Return true if LTO tag TAG corresponds to a tree code.  */
 880 static inline bool
 881 lto_tag_is_tree_code_p (enum LTO_tags tag)
 882 {
 883   return tag > LTO_null && (unsigned) tag <= NUM_TREE_CODES;
 884 }
 885
 886
 887 /* Return true if LTO tag TAG corresponds to a gimple code.  */
 888 static inline bool
 889 lto_tag_is_gimple_code_p (enum LTO_tags tag)
 890 {
 891   return (unsigned) tag >= NUM_TREE_CODES + 1
 892          && (unsigned) tag < 1 + NUM_TREE_CODES + LAST_AND_UNUSED_GIMPLE_CODE;
 893 }
 894
 895
 896 /* Return the LTO tag corresponding to gimple code CODE.  See enum
 897    LTO_tags for details on the conversion.  */
 898 static inline enum LTO_tags
 899 lto_gimple_code_to_tag (enum gimple_code code)
 900 {
 901   return (enum LTO_tags) ((unsigned) code + NUM_TREE_CODES + 1);
 902 }
 903
 904
 905 /* Return the GIMPLE code corresponding to TAG.  See enum LTO_tags for
 906    details on the conversion.  */
 907 static inline enum gimple_code
 908 lto_tag_to_gimple_code (enum LTO_tags tag)
 909 {
 910   gcc_assert (lto_tag_is_gimple_code_p (tag));
 911   return (enum gimple_code) ((unsigned) tag - NUM_TREE_CODES - 1);
 912 }
 913
 914
 915 /* Return the LTO tag corresponding to tree code CODE.  See enum
 916    LTO_tags for details on the conversion.  */
 917 static inline enum LTO_tags
 918 lto_tree_code_to_tag (enum tree_code code)
 919 {
 920   return (enum LTO_tags) ((unsigned) code + 1);
 921 }
 922
 923
 924 /* Return the tree code corresponding to TAG.  See enum LTO_tags for
 925    details on the conversion.  */
 926 static inline enum tree_code
 927 lto_tag_to_tree_code (enum LTO_tags tag)
 928 {
 929   gcc_assert (lto_tag_is_tree_code_p (tag));
 930   return (enum tree_code) ((unsigned) tag - 1);
 931 }
 932
 933
 934 /* Return true if FILE needs to be compiled with LTRANS.  */
 935 static inline bool
 936 lto_file_needs_ltrans_p (struct lto_file_decl_data *file)
 937 {
 938   return file->needs_ltrans_p != 0;
 939 }
 940
 941
 942 /* Mark FILE to be compiled with LTRANS.  */
 943 static inline void
 944 lto_mark_file_for_ltrans (struct lto_file_decl_data *file)
 945 {
 946   file->needs_ltrans_p = 1;
 947 }
 948
 949
 950 /* Return true if any files in node set SET need to be compiled
 951    with LTRANS.  */
 952 static inline bool
 953 cgraph_node_set_needs_ltrans_p (cgraph_node_set set)
 954 {
 955   cgraph_node_set_iterator csi;
 956
 957   for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
 958     if (lto_file_needs_ltrans_p (csi_node (csi)->local.lto_file_data))
 959       return true;
 960
 961   return false;
 962 }
 963
 964
 965 /* Initialize an lto_out_decl_buffer ENCODER.  */
 966 static inline void
 967 lto_init_tree_ref_encoder (struct lto_tree_ref_encoder *encoder,
 968                            htab_hash hash_fn, htab_eq eq_fn)
 969 {
 970   encoder->tree_hash_table = htab_create (37, hash_fn, eq_fn, free);
 971   encoder->next_index = 0;
 972   encoder->trees = NULL;
 973 }
 974
 975
 976 /* Destory an lto_tree_ref_encoder ENCODER by freeing its contents.  The
 977    memory used by ENCODER is not freed by this function.  */
 978 static inline void
 979 lto_destroy_tree_ref_encoder (struct lto_tree_ref_encoder *encoder)
 980 {
 981   /* Hash table may be delete already.  */
 982   if (encoder->tree_hash_table)
 983     htab_delete (encoder->tree_hash_table);
 984   VEC_free (tree, heap, encoder->trees);
 985 }
 986
 987 /* Return the number of trees encoded in ENCODER. */
 988 static inline unsigned int
 989 lto_tree_ref_encoder_size (struct lto_tree_ref_encoder *encoder)
 990 {
 991   return VEC_length (tree, encoder->trees);
 992 }
 993
 994 /* Return the IDX-th tree in ENCODER. */
 995 static inline tree
 996 lto_tree_ref_encoder_get_tree (struct lto_tree_ref_encoder *encoder,
 997                                unsigned int idx)
 998 {
 999   return VEC_index (tree, encoder->trees, idx);
1000 }
1001
1002
1003 /* Return true if LABEL should be emitted in the global context.  */
1004 static inline bool
1005 emit_label_in_global_context_p (tree label)
1006 {
1007   return DECL_NONLOCAL (label) || FORCED_LABEL (label);
1008 }
1009
1010 /* Return true if tree node EXPR should be streamed as a builtin.  For
1011    these nodes, we just emit the class and function code.  */
1012 static inline bool
1013 lto_stream_as_builtin_p (tree expr)
1014 {
1015   return (TREE_CODE (expr) == FUNCTION_DECL
1016           && DECL_IS_BUILTIN (expr)
1017           && (DECL_BUILT_IN_CLASS (expr) == BUILT_IN_NORMAL
1018               || DECL_BUILT_IN_CLASS (expr) == BUILT_IN_MD));
1019 }
1020
1021 /* Return true if EXPR is a tree node that can be written to disk.  */
1022 static inline bool
1023 lto_is_streamable (tree expr)
1024 {
1025   enum tree_code code = TREE_CODE (expr);
1026
1027   /* Notice that we reject SSA_NAMEs as well.  We only emit the SSA
1028      name version in lto_output_tree_ref (see output_ssa_names).  */
1029   return !is_lang_specific (expr)
1030          && code != SSA_NAME
1031          && code != CALL_EXPR
1032          && code != LANG_TYPE
1033          && code != MODIFY_EXPR
1034          && code != INIT_EXPR
1035          && code != TARGET_EXPR
1036          && code != BIND_EXPR
1037          && code != WITH_CLEANUP_EXPR
1038          && code != STATEMENT_LIST
1039          && (code == CASE_LABEL_EXPR
1040              || code == DECL_EXPR
1041              || TREE_CODE_CLASS (code) != tcc_statement);
1042 }
1043
1044 DEFINE_DECL_STREAM_FUNCS (TYPE, type)
1045 DEFINE_DECL_STREAM_FUNCS (FIELD_DECL, field_decl)
1046 DEFINE_DECL_STREAM_FUNCS (FN_DECL, fn_decl)
1047 DEFINE_DECL_STREAM_FUNCS (VAR_DECL, var_decl)
1048 DEFINE_DECL_STREAM_FUNCS (TYPE_DECL, type_decl)
1049 DEFINE_DECL_STREAM_FUNCS (NAMESPACE_DECL, namespace_decl)
1050 DEFINE_DECL_STREAM_FUNCS (LABEL_DECL, label_decl)
1051
1052 #endif /* GCC_LTO_STREAMER_H  */