OSDN Git Service

aea1c1decd479900d3a02c31d6f2e016dc64c66b
[pf3gnuchains/gcc-fork.git] / gcc / lto-section-in.c
1 /* Input functions for reading LTO sections.
2
3    Copyright 2009 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 "toplev.h"
27 #include "tree.h"
28 #include "expr.h"
29 #include "flags.h"
30 #include "params.h"
31 #include "input.h"
32 #include "varray.h"
33 #include "hashtab.h"
34 #include "basic-block.h"
35 #include "tree-flow.h"
36 #include "cgraph.h"
37 #include "function.h"
38 #include "ggc.h"
39 #include "diagnostic.h"
40 #include "except.h"
41 #include "vec.h"
42 #include "timevar.h"
43 #include "output.h"
44 #include "lto-streamer.h"
45 #include "lto-compress.h"
46 #include "ggc.h"
47
48 /* Section names.  These must correspond to the values of
49    enum lto_section_type.  */
50 const char *lto_section_name[LTO_N_SECTION_TYPES] =
51 {
52   "decls",
53   "function_body",
54   "static_initializer",
55   "cgraph",
56   "varpool",
57   "jump_funcs"
58   "ipa_pure_const",
59   "ipa_reference",
60   "symtab",
61   "opts"
62 };
63
64 unsigned char
65 lto_input_1_unsigned (struct lto_input_block *ib)
66 {
67   if (ib->p >= ib->len)
68     internal_error ("bytecode stream: trying to read %d bytes "
69                     "after the end of the input buffer", ib->p - ib->len);
70
71   return (ib->data[ib->p++]);
72 }
73
74
75 /* Read an ULEB128 Number of IB.  */
76
77 unsigned HOST_WIDE_INT
78 lto_input_uleb128 (struct lto_input_block *ib)
79 {
80   unsigned HOST_WIDE_INT result = 0;
81   int shift = 0;
82   unsigned HOST_WIDE_INT byte;
83
84   while (true)
85     {
86       byte = lto_input_1_unsigned (ib);
87       result |= (byte & 0x7f) << shift;
88       shift += 7;
89       if ((byte & 0x80) == 0)
90         return result;
91     }
92 }
93
94 /* HOST_WIDEST_INT version of lto_input_uleb128.  IB is as in
95    lto_input_uleb128.  */
96
97 unsigned HOST_WIDEST_INT
98 lto_input_widest_uint_uleb128 (struct lto_input_block *ib)
99 {
100   unsigned HOST_WIDEST_INT result = 0;
101   int shift = 0;
102   unsigned HOST_WIDEST_INT byte;
103
104   while (true)
105     {
106       byte = lto_input_1_unsigned (ib);
107       result |= (byte & 0x7f) << shift;
108       shift += 7;
109       if ((byte & 0x80) == 0)
110         return result;
111     }
112 }
113
114 /* Read an SLEB128 Number of IB.  */
115
116 HOST_WIDE_INT
117 lto_input_sleb128 (struct lto_input_block *ib)
118 {
119   HOST_WIDE_INT result = 0;
120   int shift = 0;
121   unsigned HOST_WIDE_INT byte;
122
123   while (true)
124     {
125       byte = lto_input_1_unsigned (ib);
126       result |= (byte & 0x7f) << shift;
127       shift += 7;
128       if ((byte & 0x80) == 0)
129         {
130           if ((shift < HOST_BITS_PER_WIDE_INT) && (byte & 0x40))
131             result |= - ((HOST_WIDE_INT)1 << shift);
132
133           return result;
134         }
135     }
136 }
137
138
139 /* Hooks so that the ipa passes can call into the lto front end to get
140    sections.  */
141
142 static struct lto_file_decl_data ** file_decl_data;
143 static lto_get_section_data_f* get_section_f;
144 static lto_free_section_data_f* free_section_f;
145
146
147 /* This is called from the lto front end to set up the hooks that are
148    used by the ipa passes to get the data that they will
149    deserialize.  */
150
151 void
152 lto_set_in_hooks (struct lto_file_decl_data ** data,
153                   lto_get_section_data_f* get_f,
154                   lto_free_section_data_f* free_f)
155 {
156   file_decl_data = data;
157   get_section_f = get_f;
158   free_section_f = free_f;
159 }
160
161
162 /* Return an array of file decl datas for all of the files passed to
163    this compilation.  */
164
165 struct lto_file_decl_data **
166 lto_get_file_decl_data (void)
167 {
168   gcc_assert (file_decl_data);
169   return file_decl_data;
170 }
171
172 /* Buffer structure for accumulating data from compression callbacks.  */
173
174 struct lto_buffer
175 {
176   char *data;
177   size_t length;
178 };
179
180 /* Compression callback, append LENGTH bytes from DATA to the buffer pointed
181    to by OPAQUE.  */
182
183 static void
184 lto_append_data (const char *data, unsigned length, void *opaque)
185 {
186   struct lto_buffer *buffer = (struct lto_buffer *) opaque;
187
188   buffer->data = (char *) xrealloc (buffer->data, buffer->length + length);
189   memcpy (buffer->data + buffer->length, data, length);
190   buffer->length += length;
191 }
192
193 /* Header placed in returned uncompressed data streams.  Allows the
194    uncompressed allocated data to be mapped back to the underlying
195    compressed data for use with free_section_f.  */
196
197 struct lto_data_header
198 {
199   const char *data;
200   size_t len;
201 };
202
203 /* Return a char pointer to the start of a data stream for an LTO pass
204    or function.  FILE_DATA indicates where to obtain the data.
205    SECTION_TYPE is the type of information to be obtained.  NAME is
206    the name of the function and is only used when finding a function
207    body; otherwise it is NULL.  LEN is the size of the data
208    returned.  */
209
210 const char *
211 lto_get_section_data (struct lto_file_decl_data *file_data,
212                       enum lto_section_type section_type,
213                       const char *name,
214                       size_t *len)
215 {
216   const char *data = (get_section_f) (file_data, section_type, name, len);
217   const size_t header_length = sizeof (struct lto_data_header);
218   struct lto_data_header *header;
219   struct lto_buffer buffer;
220   struct lto_compression_stream *stream;
221   lto_stats.section_size[section_type] += *len;
222
223   if (data == NULL)
224     return NULL;
225
226   /* FIXME lto: WPA mode does not write compressed sections, so for now
227      suppress uncompression if flag_ltrans.  */
228   if (flag_ltrans)
229     return data;
230
231   /* Create a mapping header containing the underlying data and length,
232      and prepend this to the uncompression buffer.  The uncompressed data
233      then follows, and a pointer to the start of the uncompressed data is
234      returned.  */
235   header = (struct lto_data_header *) xmalloc (header_length);
236   header->data = data;
237   header->len = *len;
238
239   buffer.data = (char *) header;
240   buffer.length = header_length;
241
242   stream = lto_start_uncompression (lto_append_data, &buffer);
243   lto_uncompress_block (stream, data, *len);
244   lto_end_uncompression (stream);
245
246   *len = buffer.length - header_length;
247   return buffer.data + header_length;
248 }
249
250
251 /* Free the data found from the above call.  The first three
252    parameters are the same as above.  DATA is the data to be freed and
253    LEN is the length of that data.  */
254
255 void
256 lto_free_section_data (struct lto_file_decl_data *file_data,
257                        enum lto_section_type section_type,
258                        const char *name,
259                        const char *data,
260                        size_t len)
261 {
262   const size_t header_length = sizeof (struct lto_data_header);
263   const char *real_data = data - header_length;
264   const struct lto_data_header *header
265     = (const struct lto_data_header *) real_data;
266
267   gcc_assert (free_section_f);
268
269   /* FIXME lto: WPA mode does not write compressed sections, so for now
270      suppress uncompression mapping if flag_ltrans.  */
271   if (flag_ltrans)
272     {
273       (free_section_f) (file_data, section_type, name, data, len);
274       return;
275     }
276
277   /* The underlying data address has been extracted from the mapping header.
278      Free that, then free the allocated uncompression buffer.  */
279   (free_section_f) (file_data, section_type, name, header->data, header->len);
280   free (CONST_CAST (char *, real_data));
281 }
282
283
284 /* Load a section of type SECTION_TYPE from FILE_DATA, parse the
285    header and then return an input block pointing to the section.  The
286    raw pointer to the section is returned in DATAR and LEN.  These are
287    used to free the section.  Return NULL if the section is not present.  */
288
289 struct lto_input_block *
290 lto_create_simple_input_block (struct lto_file_decl_data *file_data,
291                                enum lto_section_type section_type,
292                                const char **datar, size_t *len)
293 {
294   const char *data = lto_get_section_data (file_data, section_type, NULL, len);
295   const struct lto_simple_header * header
296     = (const struct lto_simple_header *) data;
297
298   struct lto_input_block* ib_main;
299   int32_t main_offset = sizeof (struct lto_simple_header);
300
301   if (!data)
302     return NULL;
303
304   ib_main = XNEW (struct lto_input_block);
305
306   *datar = data;
307   LTO_INIT_INPUT_BLOCK_PTR (ib_main, data + main_offset,
308                             0, header->main_size);
309
310   return ib_main;
311 }
312
313
314 /* Close the section returned from a call to
315    LTO_CREATE_SIMPLE_INPUT_BLOCK.  IB is the input block returned from
316    that call.  The FILE_DATA and SECTION_TYPE are the same as what was
317    passed to that call and the DATA and LEN are what was returned from
318    that call.  */
319
320 void
321 lto_destroy_simple_input_block (struct lto_file_decl_data *file_data,
322                                 enum lto_section_type section_type,
323                                 struct lto_input_block *ib,
324                                 const char *data, size_t len)
325 {
326   free (ib);
327   lto_free_section_data (file_data, section_type, NULL, data, len);
328 }
329
330 /*****************************************************************************/
331 /* Record renamings of static declarations                                   */
332 /*****************************************************************************/
333
334 struct lto_renaming_slot
335 {
336   const char *old_name;
337   const char *new_name;
338 };
339
340 /* Returns a hash code for P.  */
341
342 static hashval_t
343 hash_name (const void *p)
344 {
345   const struct lto_renaming_slot *ds = (const struct lto_renaming_slot *) p;
346   return (hashval_t) htab_hash_string (ds->new_name);
347 }
348
349 /* Returns nonzero if P1 and P2 are equal.  */
350
351 static int
352 eq_name (const void *p1, const void *p2)
353 {
354   const struct lto_renaming_slot *s1 =
355     (const struct lto_renaming_slot *) p1;
356   const struct lto_renaming_slot *s2 =
357     (const struct lto_renaming_slot *) p2;
358
359   return strcmp (s1->new_name, s2->new_name) == 0;
360 }
361
362 /* Free a renaming table entry.  */
363
364 static void
365 renaming_slot_free (void *slot)
366 {
367   struct lto_renaming_slot *s = (struct lto_renaming_slot *) slot;
368
369   free (CONST_CAST (void *, (const void *) s->old_name));
370   free (CONST_CAST (void *, (const void *) s->new_name));
371   free ((void *) s);
372 }
373
374 /* Create an empty hash table for recording declaration renamings.  */
375
376 htab_t
377 lto_create_renaming_table (void)
378 {
379   return htab_create (37, hash_name, eq_name, renaming_slot_free);
380 }
381
382 /* Record a declaration name mapping OLD_NAME -> NEW_NAME.  DECL_DATA
383    holds the renaming hash table to use.  */
384
385 void
386 lto_record_renamed_decl (struct lto_file_decl_data *decl_data,
387                          const char *old_name, const char *new_name)
388 {
389   void **slot;
390   struct lto_renaming_slot r_slot;
391
392   r_slot.new_name = new_name;
393   slot = htab_find_slot (decl_data->renaming_hash_table, &r_slot, INSERT);
394   if (*slot == NULL)
395     {
396       struct lto_renaming_slot *new_slot = XNEW (struct lto_renaming_slot);
397       new_slot->old_name = xstrdup (old_name);
398       new_slot->new_name = xstrdup (new_name);
399       *slot = new_slot;
400     }
401   else
402     gcc_unreachable ();
403 }
404
405
406 /* Given a string NAME, return the string that it has been mapped to
407    by lto_record_renamed_decl.  If NAME was not renamed, it is
408    returned unchanged.  DECL_DATA holds the renaming hash table to use.  */
409
410 const char *
411 lto_get_decl_name_mapping (struct lto_file_decl_data *decl_data,
412                            const char *name)
413 {
414   htab_t renaming_hash_table = decl_data->renaming_hash_table;
415   struct lto_renaming_slot *slot;
416   struct lto_renaming_slot r_slot;
417
418   r_slot.new_name = name;
419   slot = (struct lto_renaming_slot *) htab_find (renaming_hash_table, &r_slot);
420   if (slot)
421     return slot->old_name;
422   else
423     return name;
424 }
425
426 /*****************************************************************************/
427 /* Input decl state object.                                                  */
428 /*****************************************************************************/
429
430 /* Return a newly created in-decl state object. */
431
432 struct lto_in_decl_state *
433 lto_new_in_decl_state (void)
434 {
435   struct lto_in_decl_state *state;
436
437   state = ((struct lto_in_decl_state *) ggc_alloc (sizeof (*state)));
438   memset (state, 0, sizeof (*state));
439   return state;
440 }
441
442 /* Delete STATE and its components. */
443
444 void
445 lto_delete_in_decl_state (struct lto_in_decl_state *state)
446 {
447   int i;
448
449   for (i = 0; i < LTO_N_DECL_STREAMS; i++)
450     if (state->streams[i].trees)
451       ggc_free (state->streams[i].trees);
452   ggc_free (state);
453 }
454
455 /* Hashtable helpers. lto_in_decl_states are hash by their function decls. */
456
457 hashval_t
458 lto_hash_in_decl_state (const void *p)
459 {
460   const struct lto_in_decl_state *state = (const struct lto_in_decl_state *) p;
461   return htab_hash_pointer (state->fn_decl);
462 }
463
464 /* Return true if the fn_decl field of the lto_in_decl_state pointed to by
465    P1 equals to the function decl P2. */
466
467 int
468 lto_eq_in_decl_state (const void *p1, const void *p2)
469 {
470   const struct lto_in_decl_state *state1 =
471    (const struct lto_in_decl_state *) p1;
472   const struct lto_in_decl_state *state2 =
473    (const struct lto_in_decl_state *) p2;
474   return state1->fn_decl == state2->fn_decl;
475 }
476
477
478 /* Search the in-decl state of a function FUNC contained in the file
479    associated with FILE_DATA.  Return NULL if not found.  */
480
481 struct lto_in_decl_state*
482 lto_get_function_in_decl_state (struct lto_file_decl_data *file_data,
483                                 tree func)
484 {
485   struct lto_in_decl_state temp;
486   void **slot;
487
488   temp.fn_decl = func;
489   slot = htab_find_slot (file_data->function_decl_states, &temp, NO_INSERT);
490   return slot? ((struct lto_in_decl_state*) *slot) : NULL;
491 }