1 /* Input functions for reading LTO sections.
3 Copyright 2009 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"
34 #include "basic-block.h"
35 #include "tree-flow.h"
39 #include "diagnostic.h"
44 #include "lto-streamer.h"
45 #include "lto-compress.h"
47 /* Section names. These must correspond to the values of
48 enum lto_section_type. */
49 const char *lto_section_name[LTO_N_SECTION_TYPES] =
64 lto_input_1_unsigned (struct lto_input_block *ib)
67 internal_error ("bytecode stream: trying to read %d bytes "
68 "after the end of the input buffer", ib->p - ib->len);
70 return (ib->data[ib->p++]);
74 /* Read an ULEB128 Number of IB. */
76 unsigned HOST_WIDE_INT
77 lto_input_uleb128 (struct lto_input_block *ib)
79 unsigned HOST_WIDE_INT result = 0;
81 unsigned HOST_WIDE_INT byte;
85 byte = lto_input_1_unsigned (ib);
86 result |= (byte & 0x7f) << shift;
88 if ((byte & 0x80) == 0)
93 /* HOST_WIDEST_INT version of lto_input_uleb128. IB is as in
96 unsigned HOST_WIDEST_INT
97 lto_input_widest_uint_uleb128 (struct lto_input_block *ib)
99 unsigned HOST_WIDEST_INT result = 0;
101 unsigned HOST_WIDEST_INT byte;
105 byte = lto_input_1_unsigned (ib);
106 result |= (byte & 0x7f) << shift;
108 if ((byte & 0x80) == 0)
113 /* Read an SLEB128 Number of IB. */
116 lto_input_sleb128 (struct lto_input_block *ib)
118 HOST_WIDE_INT result = 0;
120 unsigned HOST_WIDE_INT byte;
124 byte = lto_input_1_unsigned (ib);
125 result |= (byte & 0x7f) << shift;
127 if ((byte & 0x80) == 0)
129 if ((shift < HOST_BITS_PER_WIDE_INT) && (byte & 0x40))
130 result |= - ((HOST_WIDE_INT)1 << shift);
138 /* Hooks so that the ipa passes can call into the lto front end to get
141 static struct lto_file_decl_data ** file_decl_data;
142 static lto_get_section_data_f* get_section_f;
143 static lto_free_section_data_f* free_section_f;
146 /* This is called from the lto front end to set up the hooks that are
147 used by the ipa passes to get the data that they will
151 lto_set_in_hooks (struct lto_file_decl_data ** data,
152 lto_get_section_data_f* get_f,
153 lto_free_section_data_f* free_f)
155 file_decl_data = data;
156 get_section_f = get_f;
157 free_section_f = free_f;
161 /* Return an array of file decl datas for all of the files passed to
164 struct lto_file_decl_data **
165 lto_get_file_decl_data (void)
167 gcc_assert (file_decl_data);
168 return file_decl_data;
171 /* Buffer structure for accumulating data from compression callbacks. */
179 /* Compression callback, append LENGTH bytes from DATA to the buffer pointed
183 lto_append_data (const char *data, unsigned length, void *opaque)
185 struct lto_buffer *buffer = (struct lto_buffer *) opaque;
187 buffer->data = (char *) xrealloc (buffer->data, buffer->length + length);
188 memcpy (buffer->data + buffer->length, data, length);
189 buffer->length += length;
192 /* Header placed in returned uncompressed data streams. Allows the
193 uncompressed allocated data to be mapped back to the underlying
194 compressed data for use with free_section_f. */
196 struct lto_data_header
202 /* Return a char pointer to the start of a data stream for an LTO pass
203 or function. FILE_DATA indicates where to obtain the data.
204 SECTION_TYPE is the type of information to be obtained. NAME is
205 the name of the function and is only used when finding a function
206 body; otherwise it is NULL. LEN is the size of the data
210 lto_get_section_data (struct lto_file_decl_data *file_data,
211 enum lto_section_type section_type,
215 const char *data = (get_section_f) (file_data, section_type, name, len);
216 const size_t header_length = sizeof (struct lto_data_header);
217 struct lto_data_header *header;
218 struct lto_buffer buffer;
219 struct lto_compression_stream *stream;
220 lto_stats.section_size[section_type] += *len;
225 /* FIXME lto: WPA mode does not write compressed sections, so for now
226 suppress uncompression if flag_ltrans. */
230 /* Create a mapping header containing the underlying data and length,
231 and prepend this to the uncompression buffer. The uncompressed data
232 then follows, and a pointer to the start of the uncompressed data is
234 header = (struct lto_data_header *) xmalloc (header_length);
238 buffer.data = (char *) header;
239 buffer.length = header_length;
241 stream = lto_start_uncompression (lto_append_data, &buffer);
242 lto_uncompress_block (stream, data, *len);
243 lto_end_uncompression (stream);
245 *len = buffer.length - header_length;
246 return buffer.data + header_length;
250 /* Free the data found from the above call. The first three
251 parameters are the same as above. DATA is the data to be freed and
252 LEN is the length of that data. */
255 lto_free_section_data (struct lto_file_decl_data *file_data,
256 enum lto_section_type section_type,
261 const size_t header_length = sizeof (struct lto_data_header);
262 const char *real_data = data - header_length;
263 const struct lto_data_header *header
264 = (const struct lto_data_header *) real_data;
266 gcc_assert (free_section_f);
268 /* FIXME lto: WPA mode does not write compressed sections, so for now
269 suppress uncompression mapping if flag_ltrans. */
272 (free_section_f) (file_data, section_type, name, data, len);
276 /* The underlying data address has been extracted from the mapping header.
277 Free that, then free the allocated uncompression buffer. */
278 (free_section_f) (file_data, section_type, name, header->data, header->len);
279 free (CONST_CAST (char *, real_data));
283 /* Load a section of type SECTION_TYPE from FILE_DATA, parse the
284 header and then return an input block pointing to the section. The
285 raw pointer to the section is returned in DATAR and LEN. These are
286 used to free the section. Return NULL if the section is not present. */
288 struct lto_input_block *
289 lto_create_simple_input_block (struct lto_file_decl_data *file_data,
290 enum lto_section_type section_type,
291 const char **datar, size_t *len)
293 const char *data = lto_get_section_data (file_data, section_type, NULL, len);
294 const struct lto_simple_header * header
295 = (const struct lto_simple_header *) data;
297 struct lto_input_block* ib_main;
298 int32_t main_offset = sizeof (struct lto_simple_header);
303 ib_main = XNEW (struct lto_input_block);
306 LTO_INIT_INPUT_BLOCK_PTR (ib_main, data + main_offset,
307 0, header->main_size);
313 /* Close the section returned from a call to
314 LTO_CREATE_SIMPLE_INPUT_BLOCK. IB is the input block returned from
315 that call. The FILE_DATA and SECTION_TYPE are the same as what was
316 passed to that call and the DATA and LEN are what was returned from
320 lto_destroy_simple_input_block (struct lto_file_decl_data *file_data,
321 enum lto_section_type section_type,
322 struct lto_input_block *ib,
323 const char *data, size_t len)
326 lto_free_section_data (file_data, section_type, NULL, data, len);
329 /*****************************************************************************/
330 /* Record renamings of static declarations */
331 /*****************************************************************************/
333 struct lto_renaming_slot
335 const char *old_name;
336 const char *new_name;
339 /* Returns a hash code for P. */
342 hash_name (const void *p)
344 const struct lto_renaming_slot *ds = (const struct lto_renaming_slot *) p;
345 return (hashval_t) htab_hash_string (ds->new_name);
348 /* Returns nonzero if P1 and P2 are equal. */
351 eq_name (const void *p1, const void *p2)
353 const struct lto_renaming_slot *s1 =
354 (const struct lto_renaming_slot *) p1;
355 const struct lto_renaming_slot *s2 =
356 (const struct lto_renaming_slot *) p2;
358 return strcmp (s1->new_name, s2->new_name) == 0;
361 /* Free a renaming table entry. */
364 renaming_slot_free (void *slot)
366 struct lto_renaming_slot *s = (struct lto_renaming_slot *) slot;
368 free (CONST_CAST (void *, (const void *) s->old_name));
369 free (CONST_CAST (void *, (const void *) s->new_name));
373 /* Create an empty hash table for recording declaration renamings. */
376 lto_create_renaming_table (void)
378 return htab_create (37, hash_name, eq_name, renaming_slot_free);
381 /* Record a declaration name mapping OLD_NAME -> NEW_NAME. DECL_DATA
382 holds the renaming hash table to use. */
385 lto_record_renamed_decl (struct lto_file_decl_data *decl_data,
386 const char *old_name, const char *new_name)
389 struct lto_renaming_slot r_slot;
391 r_slot.new_name = new_name;
392 slot = htab_find_slot (decl_data->renaming_hash_table, &r_slot, INSERT);
395 struct lto_renaming_slot *new_slot = XNEW (struct lto_renaming_slot);
396 new_slot->old_name = xstrdup (old_name);
397 new_slot->new_name = xstrdup (new_name);
405 /* Given a string NAME, return the string that it has been mapped to
406 by lto_record_renamed_decl. If NAME was not renamed, it is
407 returned unchanged. DECL_DATA holds the renaming hash table to use. */
410 lto_get_decl_name_mapping (struct lto_file_decl_data *decl_data,
413 htab_t renaming_hash_table = decl_data->renaming_hash_table;
414 struct lto_renaming_slot *slot;
415 struct lto_renaming_slot r_slot;
417 r_slot.new_name = name;
418 slot = (struct lto_renaming_slot *) htab_find (renaming_hash_table, &r_slot);
420 return slot->old_name;
425 /*****************************************************************************/
426 /* Input decl state object. */
427 /*****************************************************************************/
429 /* Return a newly created in-decl state object. */
431 struct lto_in_decl_state *
432 lto_new_in_decl_state (void)
434 struct lto_in_decl_state *state;
436 state = ((struct lto_in_decl_state *) xmalloc (sizeof (*state)));
437 memset (state, 0, sizeof (*state));
441 /* Delete STATE and its components. */
444 lto_delete_in_decl_state (struct lto_in_decl_state *state)
448 for (i = 0; i < LTO_N_DECL_STREAMS; i++)
449 if (state->streams[i].trees)
450 free (state->streams[i].trees);
454 /* Hashtable helpers. lto_in_decl_states are hash by their function decls. */
457 lto_hash_in_decl_state (const void *p)
459 const struct lto_in_decl_state *state = (const struct lto_in_decl_state *) p;
460 return htab_hash_pointer (state->fn_decl);
463 /* Return true if the fn_decl field of the lto_in_decl_state pointed to by
464 P1 equals to the function decl P2. */
467 lto_eq_in_decl_state (const void *p1, const void *p2)
469 const struct lto_in_decl_state *state1 =
470 (const struct lto_in_decl_state *) p1;
471 const struct lto_in_decl_state *state2 =
472 (const struct lto_in_decl_state *) p2;
473 return state1->fn_decl == state2->fn_decl;
477 /* Search the in-decl state of a function FUNC contained in the file
478 associated with FILE_DATA. Return NULL if not found. */
480 struct lto_in_decl_state*
481 lto_get_function_in_decl_state (struct lto_file_decl_data *file_data,
484 struct lto_in_decl_state temp;
488 slot = htab_find_slot (file_data->function_decl_states, &temp, NO_INSERT);
489 return slot? ((struct lto_in_decl_state*) *slot) : NULL;