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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [lto-streamer.h] - Blame information for rev 684

Details | Compare with Previous | View Log

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