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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [lto-section-in.c] - Blame information for rev 707

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 684 jeremybenn
/* Input functions for reading LTO sections.
2
 
3
   Copyright 2009, 2010 Free Software Foundation, Inc.
4
   Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>
5
 
6
This file is part of GCC.
7
 
8
GCC is free software; you can redistribute it and/or modify it under
9
the terms of the GNU General Public License as published by the Free
10
Software Foundation; either version 3, or (at your option) any later
11
version.
12
 
13
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14
WARRANTY; without even the implied warranty of MERCHANTABILITY or
15
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
16
for more details.
17
 
18
You should have received a copy of the GNU General Public License
19
along with GCC; see the file COPYING3.  If not see
20
<http://www.gnu.org/licenses/>.  */
21
 
22
#include "config.h"
23
#include "system.h"
24
#include "coretypes.h"
25
#include "tm.h"
26
#include "tree.h"
27
#include "expr.h"
28
#include "flags.h"
29
#include "params.h"
30
#include "input.h"
31
#include "hashtab.h"
32
#include "basic-block.h"
33
#include "tree-flow.h"
34
#include "cgraph.h"
35
#include "function.h"
36
#include "ggc.h"
37
#include "diagnostic-core.h"
38
#include "except.h"
39
#include "vec.h"
40
#include "timevar.h"
41
#include "output.h"
42
#include "lto-streamer.h"
43
#include "lto-compress.h"
44
#include "ggc.h"
45
 
46
/* Section names.  These must correspond to the values of
47
   enum lto_section_type.  */
48
const char *lto_section_name[LTO_N_SECTION_TYPES] =
49
{
50
  "decls",
51
  "function_body",
52
  "statics",
53
  "cgraph",
54
  "vars",
55
  "refs",
56
  "asm",
57
  "jmpfuncs",
58
  "pureconst",
59
  "reference",
60
  "symtab",
61
  "opts",
62
  "cgraphopt",
63
  "inline"
64
};
65
 
66
 
67
/* Hooks so that the ipa passes can call into the lto front end to get
68
   sections.  */
69
 
70
static struct lto_file_decl_data ** file_decl_data;
71
static lto_get_section_data_f* get_section_f;
72
static lto_free_section_data_f* free_section_f;
73
 
74
 
75
/* This is called from the lto front end to set up the hooks that are
76
   used by the ipa passes to get the data that they will
77
   deserialize.  */
78
 
79
void
80
lto_set_in_hooks (struct lto_file_decl_data ** data,
81
                  lto_get_section_data_f* get_f,
82
                  lto_free_section_data_f* free_f)
83
{
84
  file_decl_data = data;
85
  get_section_f = get_f;
86
  free_section_f = free_f;
87
}
88
 
89
 
90
/* Return an array of file decl datas for all of the files passed to
91
   this compilation.  */
92
 
93
struct lto_file_decl_data **
94
lto_get_file_decl_data (void)
95
{
96
  gcc_assert (file_decl_data);
97
  return file_decl_data;
98
}
99
 
100
/* Buffer structure for accumulating data from compression callbacks.  */
101
 
102
struct lto_buffer
103
{
104
  char *data;
105
  size_t length;
106
};
107
 
108
/* Compression callback, append LENGTH bytes from DATA to the buffer pointed
109
   to by OPAQUE.  */
110
 
111
static void
112
lto_append_data (const char *data, unsigned length, void *opaque)
113
{
114
  struct lto_buffer *buffer = (struct lto_buffer *) opaque;
115
 
116
  buffer->data = (char *) xrealloc (buffer->data, buffer->length + length);
117
  memcpy (buffer->data + buffer->length, data, length);
118
  buffer->length += length;
119
}
120
 
121
/* Header placed in returned uncompressed data streams.  Allows the
122
   uncompressed allocated data to be mapped back to the underlying
123
   compressed data for use with free_section_f.  */
124
 
125
struct lto_data_header
126
{
127
  const char *data;
128
  size_t len;
129
};
130
 
131
/* Return a char pointer to the start of a data stream for an LTO pass
132
   or function.  FILE_DATA indicates where to obtain the data.
133
   SECTION_TYPE is the type of information to be obtained.  NAME is
134
   the name of the function and is only used when finding a function
135
   body; otherwise it is NULL.  LEN is the size of the data
136
   returned.  */
137
 
138
const char *
139
lto_get_section_data (struct lto_file_decl_data *file_data,
140
                      enum lto_section_type section_type,
141
                      const char *name,
142
                      size_t *len)
143
{
144
  const char *data = (get_section_f) (file_data, section_type, name, len);
145
  const size_t header_length = sizeof (struct lto_data_header);
146
  struct lto_data_header *header;
147
  struct lto_buffer buffer;
148
  struct lto_compression_stream *stream;
149
  lto_stats.section_size[section_type] += *len;
150
 
151
  if (data == NULL)
152
    return NULL;
153
 
154
  /* FIXME lto: WPA mode does not write compressed sections, so for now
155
     suppress uncompression if flag_ltrans.  */
156
  if (flag_ltrans)
157
    return data;
158
 
159
  /* Create a mapping header containing the underlying data and length,
160
     and prepend this to the uncompression buffer.  The uncompressed data
161
     then follows, and a pointer to the start of the uncompressed data is
162
     returned.  */
163
  header = (struct lto_data_header *) xmalloc (header_length);
164
  header->data = data;
165
  header->len = *len;
166
 
167
  buffer.data = (char *) header;
168
  buffer.length = header_length;
169
 
170
  stream = lto_start_uncompression (lto_append_data, &buffer);
171
  lto_uncompress_block (stream, data, *len);
172
  lto_end_uncompression (stream);
173
 
174
  *len = buffer.length - header_length;
175
  return buffer.data + header_length;
176
}
177
 
178
 
179
/* Free the data found from the above call.  The first three
180
   parameters are the same as above.  DATA is the data to be freed and
181
   LEN is the length of that data.  */
182
 
183
void
184
lto_free_section_data (struct lto_file_decl_data *file_data,
185
                       enum lto_section_type section_type,
186
                       const char *name,
187
                       const char *data,
188
                       size_t len)
189
{
190
  const size_t header_length = sizeof (struct lto_data_header);
191
  const char *real_data = data - header_length;
192
  const struct lto_data_header *header
193
    = (const struct lto_data_header *) real_data;
194
 
195
  gcc_assert (free_section_f);
196
 
197
  /* FIXME lto: WPA mode does not write compressed sections, so for now
198
     suppress uncompression mapping if flag_ltrans.  */
199
  if (flag_ltrans)
200
    {
201
      (free_section_f) (file_data, section_type, name, data, len);
202
      return;
203
    }
204
 
205
  /* The underlying data address has been extracted from the mapping header.
206
     Free that, then free the allocated uncompression buffer.  */
207
  (free_section_f) (file_data, section_type, name, header->data, header->len);
208
  free (CONST_CAST (char *, real_data));
209
}
210
 
211
 
212
/* Load a section of type SECTION_TYPE from FILE_DATA, parse the
213
   header and then return an input block pointing to the section.  The
214
   raw pointer to the section is returned in DATAR and LEN.  These are
215
   used to free the section.  Return NULL if the section is not present.  */
216
 
217
struct lto_input_block *
218
lto_create_simple_input_block (struct lto_file_decl_data *file_data,
219
                               enum lto_section_type section_type,
220
                               const char **datar, size_t *len)
221
{
222
  const char *data = lto_get_section_data (file_data, section_type, NULL, len);
223
  const struct lto_simple_header * header
224
    = (const struct lto_simple_header *) data;
225
 
226
  struct lto_input_block* ib_main;
227
  int main_offset = sizeof (struct lto_simple_header);
228
 
229
  if (!data)
230
    return NULL;
231
 
232
  ib_main = XNEW (struct lto_input_block);
233
 
234
  *datar = data;
235
  LTO_INIT_INPUT_BLOCK_PTR (ib_main, data + main_offset,
236
                            0, header->main_size);
237
 
238
  return ib_main;
239
}
240
 
241
 
242
/* Close the section returned from a call to
243
   LTO_CREATE_SIMPLE_INPUT_BLOCK.  IB is the input block returned from
244
   that call.  The FILE_DATA and SECTION_TYPE are the same as what was
245
   passed to that call and the DATA and LEN are what was returned from
246
   that call.  */
247
 
248
void
249
lto_destroy_simple_input_block (struct lto_file_decl_data *file_data,
250
                                enum lto_section_type section_type,
251
                                struct lto_input_block *ib,
252
                                const char *data, size_t len)
253
{
254
  free (ib);
255
  lto_free_section_data (file_data, section_type, NULL, data, len);
256
}
257
 
258
/*****************************************************************************/
259
/* Record renamings of static declarations                                   */
260
/*****************************************************************************/
261
 
262
struct lto_renaming_slot
263
{
264
  const char *old_name;
265
  const char *new_name;
266
};
267
 
268
/* Returns a hash code for P.  */
269
 
270
static hashval_t
271
hash_name (const void *p)
272
{
273
  const struct lto_renaming_slot *ds = (const struct lto_renaming_slot *) p;
274
  return (hashval_t) htab_hash_string (ds->new_name);
275
}
276
 
277
/* Returns nonzero if P1 and P2 are equal.  */
278
 
279
static int
280
eq_name (const void *p1, const void *p2)
281
{
282
  const struct lto_renaming_slot *s1 =
283
    (const struct lto_renaming_slot *) p1;
284
  const struct lto_renaming_slot *s2 =
285
    (const struct lto_renaming_slot *) p2;
286
 
287
  return strcmp (s1->new_name, s2->new_name) == 0;
288
}
289
 
290
/* Free a renaming table entry.  */
291
 
292
static void
293
renaming_slot_free (void *slot)
294
{
295
  struct lto_renaming_slot *s = (struct lto_renaming_slot *) slot;
296
 
297
  free (CONST_CAST (void *, (const void *) s->old_name));
298
  free (CONST_CAST (void *, (const void *) s->new_name));
299
  free ((void *) s);
300
}
301
 
302
/* Create an empty hash table for recording declaration renamings.  */
303
 
304
htab_t
305
lto_create_renaming_table (void)
306
{
307
  return htab_create (37, hash_name, eq_name, renaming_slot_free);
308
}
309
 
310
/* Record a declaration name mapping OLD_NAME -> NEW_NAME.  DECL_DATA
311
   holds the renaming hash table to use.  */
312
 
313
void
314
lto_record_renamed_decl (struct lto_file_decl_data *decl_data,
315
                         const char *old_name, const char *new_name)
316
{
317
  void **slot;
318
  struct lto_renaming_slot r_slot;
319
 
320
  r_slot.new_name = new_name;
321
  slot = htab_find_slot (decl_data->renaming_hash_table, &r_slot, INSERT);
322
  if (*slot == NULL)
323
    {
324
      struct lto_renaming_slot *new_slot = XNEW (struct lto_renaming_slot);
325
      new_slot->old_name = xstrdup (old_name);
326
      new_slot->new_name = xstrdup (new_name);
327
      *slot = new_slot;
328
    }
329
  else
330
    gcc_unreachable ();
331
}
332
 
333
 
334
/* Given a string NAME, return the string that it has been mapped to
335
   by lto_record_renamed_decl.  If NAME was not renamed, it is
336
   returned unchanged.  DECL_DATA holds the renaming hash table to use.  */
337
 
338
const char *
339
lto_get_decl_name_mapping (struct lto_file_decl_data *decl_data,
340
                           const char *name)
341
{
342
  htab_t renaming_hash_table = decl_data->renaming_hash_table;
343
  struct lto_renaming_slot *slot;
344
  struct lto_renaming_slot r_slot;
345
 
346
  r_slot.new_name = name;
347
  slot = (struct lto_renaming_slot *) htab_find (renaming_hash_table, &r_slot);
348
  if (slot)
349
    return slot->old_name;
350
  else
351
    return name;
352
}
353
 
354
/*****************************************************************************/
355
/* Input decl state object.                                                  */
356
/*****************************************************************************/
357
 
358
/* Return a newly created in-decl state object. */
359
 
360
struct lto_in_decl_state *
361
lto_new_in_decl_state (void)
362
{
363
  return ggc_alloc_cleared_lto_in_decl_state ();
364
}
365
 
366
/* Delete STATE and its components. */
367
 
368
void
369
lto_delete_in_decl_state (struct lto_in_decl_state *state)
370
{
371
  int i;
372
 
373
  for (i = 0; i < LTO_N_DECL_STREAMS; i++)
374
    if (state->streams[i].trees)
375
      ggc_free (state->streams[i].trees);
376
  ggc_free (state);
377
}
378
 
379
/* Hashtable helpers. lto_in_decl_states are hash by their function decls. */
380
 
381
hashval_t
382
lto_hash_in_decl_state (const void *p)
383
{
384
  const struct lto_in_decl_state *state = (const struct lto_in_decl_state *) p;
385
  return htab_hash_pointer (state->fn_decl);
386
}
387
 
388
/* Return true if the fn_decl field of the lto_in_decl_state pointed to by
389
   P1 equals to the function decl P2. */
390
 
391
int
392
lto_eq_in_decl_state (const void *p1, const void *p2)
393
{
394
  const struct lto_in_decl_state *state1 =
395
   (const struct lto_in_decl_state *) p1;
396
  const struct lto_in_decl_state *state2 =
397
   (const struct lto_in_decl_state *) p2;
398
  return state1->fn_decl == state2->fn_decl;
399
}
400
 
401
 
402
/* Search the in-decl state of a function FUNC contained in the file
403
   associated with FILE_DATA.  Return NULL if not found.  */
404
 
405
struct lto_in_decl_state*
406
lto_get_function_in_decl_state (struct lto_file_decl_data *file_data,
407
                                tree func)
408
{
409
  struct lto_in_decl_state temp;
410
  void **slot;
411
 
412
  temp.fn_decl = func;
413
  slot = htab_find_slot (file_data->function_decl_states, &temp, NO_INSERT);
414
  return slot? ((struct lto_in_decl_state*) *slot) : NULL;
415
}
416
 
417
 
418
/* Report read pass end of the section.  */
419
 
420
void
421
lto_section_overrun (struct lto_input_block *ib)
422
{
423
  fatal_error ("bytecode stream: trying to read %d bytes "
424
               "after the end of the input buffer", ib->p - ib->len);
425
}
426
 
427
/* Report out of range value.  */
428
 
429
void
430
lto_value_range_error (const char *purpose, HOST_WIDE_INT val,
431
                       HOST_WIDE_INT min, HOST_WIDE_INT max)
432
{
433
  fatal_error ("%s out of range: Range is %i to %i, value is %i",
434
               purpose, (int)min, (int)max, (int)val);
435
}

powered by: WebSVN 2.1.0

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