OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [lto-streamer.h] - Blame information for rev 280

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 280 jeremybenn
/* Data structures and declarations used for reading and writing
2
   GIMPLE to a file stream.
3
 
4
   Copyright (C) 2009, 2010 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
  /* A decl which exists only to provide an extra symbol for another var.  */
221
  LTO_var_decl_alias,
222
 
223
  /* References to indexable tree nodes.  These objects are stored in
224
     tables that are written separately from the function bodies that
225
     reference them.  This way they can be instantiated even when the
226
     referencing functions aren't (e.g., during WPA) and it also allows
227
     functions to be copied from one file to another without having
228
     to unpickle the body first (the references are location
229
     independent).
230
 
231
     NOTE, do not regroup these values as the grouping is exposed
232
     in the range checks done in lto_input_tree.  */
233
  LTO_field_decl_ref,                   /* Do not change.  */
234
  LTO_function_decl_ref,
235
  LTO_label_decl_ref,
236
  LTO_namespace_decl_ref,
237
  LTO_result_decl_ref,
238
  LTO_ssa_name_ref,
239
  LTO_type_decl_ref,
240
  LTO_type_ref,
241
  LTO_const_decl_ref,
242
  LTO_imported_decl_ref,
243
  LTO_global_decl_ref,                  /* Do not change.  */
244
 
245
  /* This tag must always be last.  */
246
  LTO_NUM_TAGS
247
};
248
 
249
 
250
/* Set of section types that are in an LTO file.  This list will grow
251
   as the number of IPA passes grows since each IPA pass will need its
252
   own section type to store its summary information.
253
 
254
   When adding a new section type, you must also extend the
255
   LTO_SECTION_NAME array in lto-section-in.c.  */
256
enum lto_section_type
257
{
258
  LTO_section_decls = 0,
259
  LTO_section_function_body,
260
  LTO_section_static_initializer,
261
  LTO_section_cgraph,
262
  LTO_section_jump_functions,
263
  LTO_section_ipa_pure_const,
264
  LTO_section_ipa_reference,
265
  LTO_section_symtab,
266
  LTO_section_wpa_fixup,
267
  LTO_section_opts,
268
  LTO_N_SECTION_TYPES           /* Must be last.  */
269
};
270
 
271
/* Indices to the various function, type and symbol streams. */
272
typedef enum
273
{
274
  LTO_DECL_STREAM_TYPE = 0,              /* Must be first. */
275
  LTO_DECL_STREAM_FIELD_DECL,
276
  LTO_DECL_STREAM_FN_DECL,
277
  LTO_DECL_STREAM_VAR_DECL,
278
  LTO_DECL_STREAM_TYPE_DECL,
279
  LTO_DECL_STREAM_NAMESPACE_DECL,
280
  LTO_DECL_STREAM_LABEL_DECL,
281
  LTO_N_DECL_STREAMS
282
} lto_decl_stream_e_t;
283
 
284
typedef enum ld_plugin_symbol_resolution ld_plugin_symbol_resolution_t;
285
DEF_VEC_I(ld_plugin_symbol_resolution_t);
286
DEF_VEC_ALLOC_I(ld_plugin_symbol_resolution_t, heap);
287
 
288
 
289
/* Macro to define convenience functions for type and decl streams
290
   in lto_file_decl_data.  */
291
#define DEFINE_DECL_STREAM_FUNCS(UPPER_NAME, name) \
292
static inline tree \
293
lto_file_decl_data_get_ ## name (struct lto_file_decl_data *data, \
294
                                 unsigned int idx) \
295
{ \
296
  struct lto_in_decl_state *state = data->current_decl_state; \
297
  gcc_assert (idx < state->streams[LTO_DECL_STREAM_## UPPER_NAME].size); \
298
  return state->streams[LTO_DECL_STREAM_## UPPER_NAME].trees[idx]; \
299
} \
300
\
301
static inline unsigned int \
302
lto_file_decl_data_num_ ## name ## s (struct lto_file_decl_data *data) \
303
{ \
304
  struct lto_in_decl_state *state = data->current_decl_state; \
305
  return state->streams[LTO_DECL_STREAM_## UPPER_NAME].size; \
306
}
307
 
308
 
309
/* Return a char pointer to the start of a data stream for an lto pass
310
   or function.  The first parameter is the file data that contains
311
   the information.  The second parameter is the type of information
312
   to be obtained.  The third parameter is the name of the function
313
   and is only used when finding a function body; otherwise it is
314
   NULL.  The fourth parameter is the length of the data returned.  */
315
typedef const char* (lto_get_section_data_f) (struct lto_file_decl_data *,
316
                                              enum lto_section_type,
317
                                              const char *,
318
                                              size_t *);
319
 
320
/* Return the data found from the above call.  The first three
321
   parameters are the same as above.  The fourth parameter is the data
322
   itself and the fifth is the lenght of the data. */
323
typedef void (lto_free_section_data_f) (struct lto_file_decl_data *,
324
                                        enum lto_section_type,
325
                                        const char *,
326
                                        const char *,
327
                                        size_t);
328
 
329
/* Cache of pickled nodes.  Used to avoid writing the same node more
330
   than once.  The first time a tree node is streamed out, it is
331
   entered in this cache.  Subsequent references to the same node are
332
   resolved by looking it up in this cache.
333
 
334
   This is used in two ways:
335
 
336
   - On the writing side, the first time T is added to STREAMER_CACHE,
337
     a new reference index is created for T and T is emitted on the
338
     stream.  If T needs to be emitted again to the stream, instead of
339
     pickling it again, the reference index is emitted.
340
 
341
   - On the reading side, the first time T is read from the stream, it
342
     is reconstructed in memory and a new reference index created for
343
     T.  The reconstructed T is inserted in some array so that when
344
     the reference index for T is found in the input stream, it can be
345
     used to look up into the array to get the reconstructed T.  */
346
struct lto_streamer_cache_d
347
{
348
  /* The mapping between tree nodes and slots into the nodes array.  */
349
  htab_t node_map;
350
 
351
  /* Next available slot in the nodes and offsets arrays.  */
352
  unsigned next_slot;
353
 
354
  /* The nodes pickled so far.  */
355
  VEC(tree,gc) *nodes;
356
 
357
  /* Offset into the stream where the nodes have been written.  */
358
  VEC(unsigned,heap) *offsets;
359
};
360
 
361
 
362
/* Structure used as buffer for reading an LTO file.  */
363
struct lto_input_block
364
{
365
  const char *data;
366
  unsigned int p;
367
  unsigned int len;
368
};
369
 
370
#define LTO_INIT_INPUT_BLOCK(BASE,D,P,L)   \
371
  do {                                     \
372
    BASE.data = D;                         \
373
    BASE.p = P;                            \
374
    BASE.len = L;                          \
375
  } while (0)
376
 
377
#define LTO_INIT_INPUT_BLOCK_PTR(BASE,D,P,L) \
378
  do {                                       \
379
    BASE->data = D;                          \
380
    BASE->p = P;                             \
381
    BASE->len = L;                           \
382
  } while (0)
383
 
384
 
385
/* The is the first part of the record for a function or constructor
386
   in the .o file.  */
387
struct lto_header
388
{
389
  int16_t major_version;
390
  int16_t minor_version;
391
  enum lto_section_type section_type;
392
};
393
 
394
/* The header for a function body.  */
395
struct lto_function_header
396
{
397
  /* The header for all types of sections. */
398
  struct lto_header lto_header;
399
 
400
  /* Number of labels with names.  */
401
  int32_t num_named_labels;
402
 
403
  /* Number of labels without names.  */
404
  int32_t num_unnamed_labels;
405
 
406
  /* Size compressed or 0 if not compressed.  */
407
  int32_t compressed_size;
408
 
409
  /* Size of names for named labels.  */
410
  int32_t named_label_size;
411
 
412
  /* Size of the cfg.  */
413
  int32_t cfg_size;
414
 
415
  /* Size of main gimple body of function.  */
416
  int32_t main_size;
417
 
418
  /* Size of the string table.  */
419
  int32_t string_size;
420
};
421
 
422
 
423
/* Structure describing a symbol section.  */
424
struct lto_decl_header
425
{
426
  /* The header for all types of sections. */
427
  struct lto_header lto_header;
428
 
429
  /* Size of region for decl state. */
430
  int32_t decl_state_size;
431
 
432
  /* Number of nodes in globals stream.  */
433
  int32_t num_nodes;
434
 
435
  /* Size of region for expressions, decls, types, etc. */
436
  int32_t main_size;
437
 
438
  /* Size of the string table.  */
439
  int32_t string_size;
440
};
441
 
442
 
443
/* Statistics gathered during LTO, WPA and LTRANS.  */
444
struct lto_stats_d
445
{
446
  unsigned HOST_WIDE_INT num_input_cgraph_nodes;
447
  unsigned HOST_WIDE_INT num_output_cgraph_nodes;
448
  unsigned HOST_WIDE_INT num_input_files;
449
  unsigned HOST_WIDE_INT num_output_files;
450
  unsigned HOST_WIDE_INT num_cgraph_partitions;
451
  unsigned HOST_WIDE_INT section_size[LTO_N_SECTION_TYPES];
452
  unsigned HOST_WIDE_INT num_function_bodies;
453
  unsigned HOST_WIDE_INT num_trees[NUM_TREE_CODES];
454
  unsigned HOST_WIDE_INT num_output_il_bytes;
455
  unsigned HOST_WIDE_INT num_compressed_il_bytes;
456
  unsigned HOST_WIDE_INT num_input_il_bytes;
457
  unsigned HOST_WIDE_INT num_uncompressed_il_bytes;
458
};
459
 
460
/* Encoder data structure used to stream callgraph nodes.  */
461
struct lto_cgraph_encoder_d
462
{
463
  /* Map nodes to reference number. */
464
  struct pointer_map_t *map;
465
 
466
  /* Map reference number to node. */
467
  VEC(cgraph_node_ptr,heap) *nodes;
468
};
469
 
470
typedef struct lto_cgraph_encoder_d *lto_cgraph_encoder_t;
471
 
472
/* Mapping from indices to trees.  */
473
struct lto_tree_ref_table
474
{
475
  /* Array of referenced trees . */
476
  tree *trees;
477
 
478
  /* Size of array. */
479
  unsigned int size;
480
};
481
 
482
 
483
/* Mapping between trees and slots in an array.  */
484
struct lto_decl_slot
485
{
486
  tree t;
487
  int slot_num;
488
};
489
 
490
 
491
/* The lto_tree_ref_encoder struct is used to encode trees into indices. */
492
 
493
struct lto_tree_ref_encoder
494
{
495
  htab_t tree_hash_table;       /* Maps pointers to indices. */
496
  unsigned int next_index;      /* Next available index. */
497
  VEC(tree,heap) *trees;        /* Maps indices to pointers. */
498
};
499
 
500
 
501
/* Structure to hold states of input scope.  */
502
struct lto_in_decl_state
503
{
504
  /* Array of lto_in_decl_buffers to store type and decls streams. */
505
  struct lto_tree_ref_table streams[LTO_N_DECL_STREAMS];
506
 
507
  /* If this in-decl state is associated with a function. FN_DECL
508
     point to the FUNCTION_DECL. */
509
  tree fn_decl;
510
};
511
 
512
typedef struct lto_in_decl_state *lto_in_decl_state_ptr;
513
 
514
 
515
/* The structure that holds all of the vectors of global types,
516
   decls and cgraph nodes used in the serialization of this file.  */
517
struct lto_out_decl_state
518
{
519
  /* The buffers contain the sets of decls of various kinds and types we have
520
     seen so far and the indexes assigned to them.  */
521
  struct lto_tree_ref_encoder streams[LTO_N_DECL_STREAMS];
522
 
523
  /* Encoder for cgraph nodes.  */
524
  lto_cgraph_encoder_t cgraph_node_encoder;
525
 
526
  /* If this out-decl state belongs to a function, fn_decl points to that
527
     function.  Otherwise, it is NULL. */
528
  tree fn_decl;
529
};
530
 
531
typedef struct lto_out_decl_state *lto_out_decl_state_ptr;
532
 
533
DEF_VEC_P(lto_out_decl_state_ptr);
534
DEF_VEC_ALLOC_P(lto_out_decl_state_ptr, heap);
535
 
536
/* One of these is allocated for each object file that being compiled
537
   by lto.  This structure contains the tables that are needed by the
538
   serialized functions and ipa passes to connect themselves to the
539
   global types and decls as they are reconstituted.  */
540
struct lto_file_decl_data
541
{
542
  /* Decl state currently used. */
543
  struct lto_in_decl_state *current_decl_state;
544
 
545
  /* Decl state corresponding to regions outside of any functions
546
     in the compilation unit. */
547
  struct lto_in_decl_state *global_decl_state;
548
 
549
  /* Table of cgraph nodes present in this file.  */
550
  lto_cgraph_encoder_t cgraph_node_encoder;
551
 
552
  /* Hash table maps lto-related section names to location in file.  */
553
  htab_t function_decl_states;
554
 
555
  /* The .o file that these offsets relate to.  */
556
  const char *file_name;
557
 
558
  /* Nonzero if this file should be recompiled with LTRANS.  */
559
  unsigned needs_ltrans_p : 1;
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_cgraph (struct lto_file_decl_data *, const char *);
810
extern void lto_init_reader (void);
811
extern tree lto_input_tree (struct lto_input_block *, struct data_in *);
812
extern void lto_input_function_body (struct lto_file_decl_data *, tree,
813
                                     const char *);
814
extern void lto_input_constructors_and_inits (struct lto_file_decl_data *,
815
                                              const char *);
816
extern struct bitpack_d *lto_input_bitpack (struct lto_input_block *);
817
extern void lto_init_reader (void);
818
extern struct data_in *lto_data_in_create (struct lto_file_decl_data *,
819
                                    const char *, unsigned,
820
                                    VEC(ld_plugin_symbol_resolution_t,heap) *);
821
extern void lto_data_in_delete (struct data_in *);
822
 
823
 
824
/* In lto-streamer-out.c  */
825
extern void lto_register_decl_definition (tree, struct lto_file_decl_data *);
826
extern struct output_block *create_output_block (enum lto_section_type);
827
extern void destroy_output_block (struct output_block *);
828
extern void lto_output_tree (struct output_block *, tree, bool);
829
extern void lto_output_bitpack (struct lto_output_stream *, struct bitpack_d *);
830
extern void produce_asm (struct output_block *ob, tree fn);
831
 
832
 
833
/* In lto-cgraph.c  */
834
struct cgraph_node *lto_cgraph_encoder_deref (lto_cgraph_encoder_t, int);
835
int lto_cgraph_encoder_lookup (lto_cgraph_encoder_t, struct cgraph_node *);
836
lto_cgraph_encoder_t lto_cgraph_encoder_new (void);
837
int lto_cgraph_encoder_encode (lto_cgraph_encoder_t, struct cgraph_node *);
838
void lto_cgraph_encoder_delete (lto_cgraph_encoder_t encoder);
839
void output_cgraph (cgraph_node_set);
840
void input_cgraph (void);
841
 
842
 
843
/* In lto-symtab.c.  */
844
extern void lto_symtab_register_decl (tree, ld_plugin_symbol_resolution_t,
845
                                      struct lto_file_decl_data *);
846
extern void lto_symtab_merge_decls (void);
847
extern void lto_symtab_merge_cgraph_nodes (void);
848
extern tree lto_symtab_prevailing_decl (tree decl);
849
extern enum ld_plugin_symbol_resolution lto_symtab_get_resolution (tree decl);
850
 
851
 
852
/* In lto-opts.c.  */
853
extern void lto_register_user_option (size_t, const char *, int, int);
854
extern void lto_read_file_options (struct lto_file_decl_data *);
855
extern void lto_write_options (void);
856
extern void lto_reissue_options (void);
857
void lto_clear_user_options (void);
858
void lto_clear_file_options (void);
859
 
860
 
861
/* In lto-wpa-fixup.c  */
862
void lto_mark_nothrow_fndecl (tree);
863
void lto_fixup_nothrow_decls (void);
864
 
865
 
866
/* Statistics gathered during LTO, WPA and LTRANS.  */
867
extern struct lto_stats_d lto_stats;
868
 
869
/* Section names corresponding to the values of enum lto_section_type.  */
870
extern const char *lto_section_name[];
871
 
872
/* Holds all the out decl states of functions output so far in the
873
   current output file.  */
874
extern VEC(lto_out_decl_state_ptr, heap) *lto_function_decl_states;
875
 
876
/* Return true if LTO tag TAG corresponds to a tree code.  */
877
static inline bool
878
lto_tag_is_tree_code_p (enum LTO_tags tag)
879
{
880
  return tag > LTO_null && (unsigned) tag <= NUM_TREE_CODES;
881
}
882
 
883
 
884
/* Return true if LTO tag TAG corresponds to a gimple code.  */
885
static inline bool
886
lto_tag_is_gimple_code_p (enum LTO_tags tag)
887
{
888
  return (unsigned) tag >= NUM_TREE_CODES + 1
889
         && (unsigned) tag < 1 + NUM_TREE_CODES + LAST_AND_UNUSED_GIMPLE_CODE;
890
}
891
 
892
 
893
/* Return the LTO tag corresponding to gimple code CODE.  See enum
894
   LTO_tags for details on the conversion.  */
895
static inline enum LTO_tags
896
lto_gimple_code_to_tag (enum gimple_code code)
897
{
898
  return (enum LTO_tags) ((unsigned) code + NUM_TREE_CODES + 1);
899
}
900
 
901
 
902
/* Return the GIMPLE code corresponding to TAG.  See enum LTO_tags for
903
   details on the conversion.  */
904
static inline enum gimple_code
905
lto_tag_to_gimple_code (enum LTO_tags tag)
906
{
907
  gcc_assert (lto_tag_is_gimple_code_p (tag));
908
  return (enum gimple_code) ((unsigned) tag - NUM_TREE_CODES - 1);
909
}
910
 
911
 
912
/* Return the LTO tag corresponding to tree code CODE.  See enum
913
   LTO_tags for details on the conversion.  */
914
static inline enum LTO_tags
915
lto_tree_code_to_tag (enum tree_code code)
916
{
917
  return (enum LTO_tags) ((unsigned) code + 1);
918
}
919
 
920
 
921
/* Return the tree code corresponding to TAG.  See enum LTO_tags for
922
   details on the conversion.  */
923
static inline enum tree_code
924
lto_tag_to_tree_code (enum LTO_tags tag)
925
{
926
  gcc_assert (lto_tag_is_tree_code_p (tag));
927
  return (enum tree_code) ((unsigned) tag - 1);
928
}
929
 
930
 
931
/* Return true if FILE needs to be compiled with LTRANS.  */
932
static inline bool
933
lto_file_needs_ltrans_p (struct lto_file_decl_data *file)
934
{
935
  return file->needs_ltrans_p != 0;
936
}
937
 
938
 
939
/* Mark FILE to be compiled with LTRANS.  */
940
static inline void
941
lto_mark_file_for_ltrans (struct lto_file_decl_data *file)
942
{
943
  file->needs_ltrans_p = 1;
944
}
945
 
946
 
947
/* Return true if any files in node set SET need to be compiled
948
   with LTRANS.  */
949
static inline bool
950
cgraph_node_set_needs_ltrans_p (cgraph_node_set set)
951
{
952
  cgraph_node_set_iterator csi;
953
 
954
  for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
955
    if (lto_file_needs_ltrans_p (csi_node (csi)->local.lto_file_data))
956
      return true;
957
 
958
  return false;
959
}
960
 
961
 
962
/* Initialize an lto_out_decl_buffer ENCODER.  */
963
static inline void
964
lto_init_tree_ref_encoder (struct lto_tree_ref_encoder *encoder,
965
                           htab_hash hash_fn, htab_eq eq_fn)
966
{
967
  encoder->tree_hash_table = htab_create (37, hash_fn, eq_fn, free);
968
  encoder->next_index = 0;
969
  encoder->trees = NULL;
970
}
971
 
972
 
973
/* Destory an lto_tree_ref_encoder ENCODER by freeing its contents.  The
974
   memory used by ENCODER is not freed by this function.  */
975
static inline void
976
lto_destroy_tree_ref_encoder (struct lto_tree_ref_encoder *encoder)
977
{
978
  /* Hash table may be delete already.  */
979
  if (encoder->tree_hash_table)
980
    htab_delete (encoder->tree_hash_table);
981
  VEC_free (tree, heap, encoder->trees);
982
}
983
 
984
/* Return the number of trees encoded in ENCODER. */
985
static inline unsigned int
986
lto_tree_ref_encoder_size (struct lto_tree_ref_encoder *encoder)
987
{
988
  return VEC_length (tree, encoder->trees);
989
}
990
 
991
/* Return the IDX-th tree in ENCODER. */
992
static inline tree
993
lto_tree_ref_encoder_get_tree (struct lto_tree_ref_encoder *encoder,
994
                               unsigned int idx)
995
{
996
  return VEC_index (tree, encoder->trees, idx);
997
}
998
 
999
 
1000
/* Return true if LABEL should be emitted in the global context.  */
1001
static inline bool
1002
emit_label_in_global_context_p (tree label)
1003
{
1004
  return DECL_NONLOCAL (label) || FORCED_LABEL (label);
1005
}
1006
 
1007
/* Return true if tree node EXPR should be streamed as a builtin.  For
1008
   these nodes, we just emit the class and function code.  */
1009
static inline bool
1010
lto_stream_as_builtin_p (tree expr)
1011
{
1012
  return (TREE_CODE (expr) == FUNCTION_DECL
1013
          && DECL_IS_BUILTIN (expr)
1014
          && (DECL_BUILT_IN_CLASS (expr) == BUILT_IN_NORMAL
1015
              || DECL_BUILT_IN_CLASS (expr) == BUILT_IN_MD));
1016
}
1017
 
1018
/* Return true if EXPR is a tree node that can be written to disk.  */
1019
static inline bool
1020
lto_is_streamable (tree expr)
1021
{
1022
  enum tree_code code = TREE_CODE (expr);
1023
 
1024
  /* Notice that we reject SSA_NAMEs as well.  We only emit the SSA
1025
     name version in lto_output_tree_ref (see output_ssa_names).  */
1026
  return !is_lang_specific (expr)
1027
         && code != SSA_NAME
1028
         && code != CALL_EXPR
1029
         && code != LANG_TYPE
1030
         && code != MODIFY_EXPR
1031
         && code != INIT_EXPR
1032
         && code != TARGET_EXPR
1033
         && code != BIND_EXPR
1034
         && code != WITH_CLEANUP_EXPR
1035
         && code != STATEMENT_LIST
1036
         && (code == CASE_LABEL_EXPR
1037
             || code == DECL_EXPR
1038
             || TREE_CODE_CLASS (code) != tcc_statement);
1039
}
1040
 
1041
DEFINE_DECL_STREAM_FUNCS (TYPE, type)
1042
DEFINE_DECL_STREAM_FUNCS (FIELD_DECL, field_decl)
1043
DEFINE_DECL_STREAM_FUNCS (FN_DECL, fn_decl)
1044
DEFINE_DECL_STREAM_FUNCS (VAR_DECL, var_decl)
1045
DEFINE_DECL_STREAM_FUNCS (TYPE_DECL, type_decl)
1046
DEFINE_DECL_STREAM_FUNCS (NAMESPACE_DECL, namespace_decl)
1047
DEFINE_DECL_STREAM_FUNCS (LABEL_DECL, label_decl)
1048
 
1049
#endif /* GCC_LTO_STREAMER_H  */

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.