1 /* Input functions for reading LTO sections.
3 Copyright 2009, 2010 Free Software Foundation, Inc.
4 Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>
6 This file is part of GCC.
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
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
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/>. */
24 #include "coretypes.h"
32 #include "basic-block.h"
33 #include "tree-flow.h"
37 #include "diagnostic-core.h"
42 #include "lto-streamer.h"
43 #include "lto-compress.h"
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] =
66 /* Read an ULEB128 Number of IB. */
68 unsigned HOST_WIDE_INT
69 lto_input_uleb128 (struct lto_input_block *ib)
71 unsigned HOST_WIDE_INT result = 0;
73 unsigned HOST_WIDE_INT byte;
77 byte = lto_input_1_unsigned (ib);
78 result |= (byte & 0x7f) << shift;
80 if ((byte & 0x80) == 0)
85 /* HOST_WIDEST_INT version of lto_input_uleb128. IB is as in
88 unsigned HOST_WIDEST_INT
89 lto_input_widest_uint_uleb128 (struct lto_input_block *ib)
91 unsigned HOST_WIDEST_INT result = 0;
93 unsigned HOST_WIDEST_INT byte;
97 byte = lto_input_1_unsigned (ib);
98 result |= (byte & 0x7f) << shift;
100 if ((byte & 0x80) == 0)
105 /* Read an SLEB128 Number of IB. */
108 lto_input_sleb128 (struct lto_input_block *ib)
110 HOST_WIDE_INT result = 0;
112 unsigned HOST_WIDE_INT byte;
116 byte = lto_input_1_unsigned (ib);
117 result |= (byte & 0x7f) << shift;
119 if ((byte & 0x80) == 0)
121 if ((shift < HOST_BITS_PER_WIDE_INT) && (byte & 0x40))
122 result |= - ((HOST_WIDE_INT)1 << shift);
130 /* Hooks so that the ipa passes can call into the lto front end to get
133 static struct lto_file_decl_data ** file_decl_data;
134 static lto_get_section_data_f* get_section_f;
135 static lto_free_section_data_f* free_section_f;
138 /* This is called from the lto front end to set up the hooks that are
139 used by the ipa passes to get the data that they will
143 lto_set_in_hooks (struct lto_file_decl_data ** data,
144 lto_get_section_data_f* get_f,
145 lto_free_section_data_f* free_f)
147 file_decl_data = data;
148 get_section_f = get_f;
149 free_section_f = free_f;
153 /* Return an array of file decl datas for all of the files passed to
156 struct lto_file_decl_data **
157 lto_get_file_decl_data (void)
159 gcc_assert (file_decl_data);
160 return file_decl_data;
163 /* Buffer structure for accumulating data from compression callbacks. */
171 /* Compression callback, append LENGTH bytes from DATA to the buffer pointed
175 lto_append_data (const char *data, unsigned length, void *opaque)
177 struct lto_buffer *buffer = (struct lto_buffer *) opaque;
179 buffer->data = (char *) xrealloc (buffer->data, buffer->length + length);
180 memcpy (buffer->data + buffer->length, data, length);
181 buffer->length += length;
184 /* Header placed in returned uncompressed data streams. Allows the
185 uncompressed allocated data to be mapped back to the underlying
186 compressed data for use with free_section_f. */
188 struct lto_data_header
194 /* Return a char pointer to the start of a data stream for an LTO pass
195 or function. FILE_DATA indicates where to obtain the data.
196 SECTION_TYPE is the type of information to be obtained. NAME is
197 the name of the function and is only used when finding a function
198 body; otherwise it is NULL. LEN is the size of the data
202 lto_get_section_data (struct lto_file_decl_data *file_data,
203 enum lto_section_type section_type,
207 const char *data = (get_section_f) (file_data, section_type, name, len);
208 const size_t header_length = sizeof (struct lto_data_header);
209 struct lto_data_header *header;
210 struct lto_buffer buffer;
211 struct lto_compression_stream *stream;
212 lto_stats.section_size[section_type] += *len;
217 /* FIXME lto: WPA mode does not write compressed sections, so for now
218 suppress uncompression if flag_ltrans. */
222 /* Create a mapping header containing the underlying data and length,
223 and prepend this to the uncompression buffer. The uncompressed data
224 then follows, and a pointer to the start of the uncompressed data is
226 header = (struct lto_data_header *) xmalloc (header_length);
230 buffer.data = (char *) header;
231 buffer.length = header_length;
233 stream = lto_start_uncompression (lto_append_data, &buffer);
234 lto_uncompress_block (stream, data, *len);
235 lto_end_uncompression (stream);
237 *len = buffer.length - header_length;
238 return buffer.data + header_length;
242 /* Free the data found from the above call. The first three
243 parameters are the same as above. DATA is the data to be freed and
244 LEN is the length of that data. */
247 lto_free_section_data (struct lto_file_decl_data *file_data,
248 enum lto_section_type section_type,
253 const size_t header_length = sizeof (struct lto_data_header);
254 const char *real_data = data - header_length;
255 const struct lto_data_header *header
256 = (const struct lto_data_header *) real_data;
258 gcc_assert (free_section_f);
260 /* FIXME lto: WPA mode does not write compressed sections, so for now
261 suppress uncompression mapping if flag_ltrans. */
264 (free_section_f) (file_data, section_type, name, data, len);
268 /* The underlying data address has been extracted from the mapping header.
269 Free that, then free the allocated uncompression buffer. */
270 (free_section_f) (file_data, section_type, name, header->data, header->len);
271 free (CONST_CAST (char *, real_data));
275 /* Load a section of type SECTION_TYPE from FILE_DATA, parse the
276 header and then return an input block pointing to the section. The
277 raw pointer to the section is returned in DATAR and LEN. These are
278 used to free the section. Return NULL if the section is not present. */
280 struct lto_input_block *
281 lto_create_simple_input_block (struct lto_file_decl_data *file_data,
282 enum lto_section_type section_type,
283 const char **datar, size_t *len)
285 const char *data = lto_get_section_data (file_data, section_type, NULL, len);
286 const struct lto_simple_header * header
287 = (const struct lto_simple_header *) data;
289 struct lto_input_block* ib_main;
290 int32_t main_offset = sizeof (struct lto_simple_header);
295 ib_main = XNEW (struct lto_input_block);
298 LTO_INIT_INPUT_BLOCK_PTR (ib_main, data + main_offset,
299 0, header->main_size);
305 /* Close the section returned from a call to
306 LTO_CREATE_SIMPLE_INPUT_BLOCK. IB is the input block returned from
307 that call. The FILE_DATA and SECTION_TYPE are the same as what was
308 passed to that call and the DATA and LEN are what was returned from
312 lto_destroy_simple_input_block (struct lto_file_decl_data *file_data,
313 enum lto_section_type section_type,
314 struct lto_input_block *ib,
315 const char *data, size_t len)
318 lto_free_section_data (file_data, section_type, NULL, data, len);
321 /*****************************************************************************/
322 /* Record renamings of static declarations */
323 /*****************************************************************************/
325 struct lto_renaming_slot
327 const char *old_name;
328 const char *new_name;
331 /* Returns a hash code for P. */
334 hash_name (const void *p)
336 const struct lto_renaming_slot *ds = (const struct lto_renaming_slot *) p;
337 return (hashval_t) htab_hash_string (ds->new_name);
340 /* Returns nonzero if P1 and P2 are equal. */
343 eq_name (const void *p1, const void *p2)
345 const struct lto_renaming_slot *s1 =
346 (const struct lto_renaming_slot *) p1;
347 const struct lto_renaming_slot *s2 =
348 (const struct lto_renaming_slot *) p2;
350 return strcmp (s1->new_name, s2->new_name) == 0;
353 /* Free a renaming table entry. */
356 renaming_slot_free (void *slot)
358 struct lto_renaming_slot *s = (struct lto_renaming_slot *) slot;
360 free (CONST_CAST (void *, (const void *) s->old_name));
361 free (CONST_CAST (void *, (const void *) s->new_name));
365 /* Create an empty hash table for recording declaration renamings. */
368 lto_create_renaming_table (void)
370 return htab_create (37, hash_name, eq_name, renaming_slot_free);
373 /* Record a declaration name mapping OLD_NAME -> NEW_NAME. DECL_DATA
374 holds the renaming hash table to use. */
377 lto_record_renamed_decl (struct lto_file_decl_data *decl_data,
378 const char *old_name, const char *new_name)
381 struct lto_renaming_slot r_slot;
383 r_slot.new_name = new_name;
384 slot = htab_find_slot (decl_data->renaming_hash_table, &r_slot, INSERT);
387 struct lto_renaming_slot *new_slot = XNEW (struct lto_renaming_slot);
388 new_slot->old_name = xstrdup (old_name);
389 new_slot->new_name = xstrdup (new_name);
397 /* Given a string NAME, return the string that it has been mapped to
398 by lto_record_renamed_decl. If NAME was not renamed, it is
399 returned unchanged. DECL_DATA holds the renaming hash table to use. */
402 lto_get_decl_name_mapping (struct lto_file_decl_data *decl_data,
405 htab_t renaming_hash_table = decl_data->renaming_hash_table;
406 struct lto_renaming_slot *slot;
407 struct lto_renaming_slot r_slot;
409 r_slot.new_name = name;
410 slot = (struct lto_renaming_slot *) htab_find (renaming_hash_table, &r_slot);
412 return slot->old_name;
417 /*****************************************************************************/
418 /* Input decl state object. */
419 /*****************************************************************************/
421 /* Return a newly created in-decl state object. */
423 struct lto_in_decl_state *
424 lto_new_in_decl_state (void)
426 return ggc_alloc_cleared_lto_in_decl_state ();
429 /* Delete STATE and its components. */
432 lto_delete_in_decl_state (struct lto_in_decl_state *state)
436 for (i = 0; i < LTO_N_DECL_STREAMS; i++)
437 if (state->streams[i].trees)
438 ggc_free (state->streams[i].trees);
442 /* Hashtable helpers. lto_in_decl_states are hash by their function decls. */
445 lto_hash_in_decl_state (const void *p)
447 const struct lto_in_decl_state *state = (const struct lto_in_decl_state *) p;
448 return htab_hash_pointer (state->fn_decl);
451 /* Return true if the fn_decl field of the lto_in_decl_state pointed to by
452 P1 equals to the function decl P2. */
455 lto_eq_in_decl_state (const void *p1, const void *p2)
457 const struct lto_in_decl_state *state1 =
458 (const struct lto_in_decl_state *) p1;
459 const struct lto_in_decl_state *state2 =
460 (const struct lto_in_decl_state *) p2;
461 return state1->fn_decl == state2->fn_decl;
465 /* Search the in-decl state of a function FUNC contained in the file
466 associated with FILE_DATA. Return NULL if not found. */
468 struct lto_in_decl_state*
469 lto_get_function_in_decl_state (struct lto_file_decl_data *file_data,
472 struct lto_in_decl_state temp;
476 slot = htab_find_slot (file_data->function_decl_states, &temp, NO_INSERT);
477 return slot? ((struct lto_in_decl_state*) *slot) : NULL;
481 /* Report read pass end of the section. */
484 lto_section_overrun (struct lto_input_block *ib)
486 internal_error ("bytecode stream: trying to read %d bytes "
487 "after the end of the input buffer", ib->p - ib->len);