* de.po: Update.
[official-gcc.git] / gcc / lto-section-in.c
blob3a861511c160dca0731b33427c9792fb073d20de
1 /* Input functions for reading LTO sections.
3 Copyright (C) 2009-2013 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
11 version.
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.
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/>. */
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 "lto-streamer.h"
42 #include "lto-compress.h"
43 #include "ggc.h"
45 /* Section names. These must correspond to the values of
46 enum lto_section_type. */
47 const char *lto_section_name[LTO_N_SECTION_TYPES] =
49 "decls",
50 "function_body",
51 "statics",
52 "symtab",
53 "refs",
54 "asm",
55 "jmpfuncs",
56 "pureconst",
57 "reference",
58 "symbol_nodes",
59 "opts",
60 "cgraphopt",
61 "inline",
62 "ipcp_trans"
66 /* Hooks so that the ipa passes can call into the lto front end to get
67 sections. */
69 static struct lto_file_decl_data ** file_decl_data;
70 static lto_get_section_data_f* get_section_f;
71 static lto_free_section_data_f* free_section_f;
74 /* This is called from the lto front end to set up the hooks that are
75 used by the ipa passes to get the data that they will
76 deserialize. */
78 void
79 lto_set_in_hooks (struct lto_file_decl_data ** data,
80 lto_get_section_data_f* get_f,
81 lto_free_section_data_f* free_f)
83 file_decl_data = data;
84 get_section_f = get_f;
85 free_section_f = free_f;
89 /* Return an array of file decl datas for all of the files passed to
90 this compilation. */
92 struct lto_file_decl_data **
93 lto_get_file_decl_data (void)
95 gcc_assert (file_decl_data);
96 return file_decl_data;
99 /* Buffer structure for accumulating data from compression callbacks. */
101 struct lto_buffer
103 char *data;
104 size_t length;
107 /* Compression callback, append LENGTH bytes from DATA to the buffer pointed
108 to by OPAQUE. */
110 static void
111 lto_append_data (const char *data, unsigned length, void *opaque)
113 struct lto_buffer *buffer = (struct lto_buffer *) opaque;
115 buffer->data = (char *) xrealloc (buffer->data, buffer->length + length);
116 memcpy (buffer->data + buffer->length, data, length);
117 buffer->length += length;
120 /* Header placed in returned uncompressed data streams. Allows the
121 uncompressed allocated data to be mapped back to the underlying
122 compressed data for use with free_section_f. */
124 struct lto_data_header
126 const char *data;
127 size_t len;
130 /* Return a char pointer to the start of a data stream for an LTO pass
131 or function. FILE_DATA indicates where to obtain the data.
132 SECTION_TYPE is the type of information to be obtained. NAME is
133 the name of the function and is only used when finding a function
134 body; otherwise it is NULL. LEN is the size of the data
135 returned. */
137 const char *
138 lto_get_section_data (struct lto_file_decl_data *file_data,
139 enum lto_section_type section_type,
140 const char *name,
141 size_t *len)
143 const char *data = (get_section_f) (file_data, section_type, name, len);
144 const size_t header_length = sizeof (struct lto_data_header);
145 struct lto_data_header *header;
146 struct lto_buffer buffer;
147 struct lto_compression_stream *stream;
148 lto_stats.section_size[section_type] += *len;
150 if (data == NULL)
151 return NULL;
153 /* FIXME lto: WPA mode does not write compressed sections, so for now
154 suppress uncompression if flag_ltrans. */
155 if (flag_ltrans)
156 return data;
158 /* Create a mapping header containing the underlying data and length,
159 and prepend this to the uncompression buffer. The uncompressed data
160 then follows, and a pointer to the start of the uncompressed data is
161 returned. */
162 header = (struct lto_data_header *) xmalloc (header_length);
163 header->data = data;
164 header->len = *len;
166 buffer.data = (char *) header;
167 buffer.length = header_length;
169 stream = lto_start_uncompression (lto_append_data, &buffer);
170 lto_uncompress_block (stream, data, *len);
171 lto_end_uncompression (stream);
173 *len = buffer.length - header_length;
174 return buffer.data + header_length;
178 /* Free the data found from the above call. The first three
179 parameters are the same as above. DATA is the data to be freed and
180 LEN is the length of that data. */
182 void
183 lto_free_section_data (struct lto_file_decl_data *file_data,
184 enum lto_section_type section_type,
185 const char *name,
186 const char *data,
187 size_t len)
189 const size_t header_length = sizeof (struct lto_data_header);
190 const char *real_data = data - header_length;
191 const struct lto_data_header *header
192 = (const struct lto_data_header *) real_data;
194 gcc_assert (free_section_f);
196 /* FIXME lto: WPA mode does not write compressed sections, so for now
197 suppress uncompression mapping if flag_ltrans. */
198 if (flag_ltrans)
200 (free_section_f) (file_data, section_type, name, data, len);
201 return;
204 /* The underlying data address has been extracted from the mapping header.
205 Free that, then free the allocated uncompression buffer. */
206 (free_section_f) (file_data, section_type, name, header->data, header->len);
207 free (CONST_CAST (char *, real_data));
211 /* Load a section of type SECTION_TYPE from FILE_DATA, parse the
212 header and then return an input block pointing to the section. The
213 raw pointer to the section is returned in DATAR and LEN. These are
214 used to free the section. Return NULL if the section is not present. */
216 struct lto_input_block *
217 lto_create_simple_input_block (struct lto_file_decl_data *file_data,
218 enum lto_section_type section_type,
219 const char **datar, size_t *len)
221 const char *data = lto_get_section_data (file_data, section_type, NULL, len);
222 const struct lto_simple_header * header
223 = (const struct lto_simple_header *) data;
225 struct lto_input_block* ib_main;
226 int main_offset = sizeof (struct lto_simple_header);
228 if (!data)
229 return NULL;
231 ib_main = XNEW (struct lto_input_block);
233 *datar = data;
234 LTO_INIT_INPUT_BLOCK_PTR (ib_main, data + main_offset,
235 0, header->main_size);
237 return ib_main;
241 /* Close the section returned from a call to
242 LTO_CREATE_SIMPLE_INPUT_BLOCK. IB is the input block returned from
243 that call. The FILE_DATA and SECTION_TYPE are the same as what was
244 passed to that call and the DATA and LEN are what was returned from
245 that call. */
247 void
248 lto_destroy_simple_input_block (struct lto_file_decl_data *file_data,
249 enum lto_section_type section_type,
250 struct lto_input_block *ib,
251 const char *data, size_t len)
253 free (ib);
254 lto_free_section_data (file_data, section_type, NULL, data, len);
257 /*****************************************************************************/
258 /* Record renamings of static declarations */
259 /*****************************************************************************/
261 struct lto_renaming_slot
263 const char *old_name;
264 const char *new_name;
267 /* Returns a hash code for P. */
269 static hashval_t
270 hash_name (const void *p)
272 const struct lto_renaming_slot *ds = (const struct lto_renaming_slot *) p;
273 return (hashval_t) htab_hash_string (ds->new_name);
276 /* Returns nonzero if P1 and P2 are equal. */
278 static int
279 eq_name (const void *p1, const void *p2)
281 const struct lto_renaming_slot *s1 =
282 (const struct lto_renaming_slot *) p1;
283 const struct lto_renaming_slot *s2 =
284 (const struct lto_renaming_slot *) p2;
286 return strcmp (s1->new_name, s2->new_name) == 0;
289 /* Free a renaming table entry. */
291 static void
292 renaming_slot_free (void *slot)
294 struct lto_renaming_slot *s = (struct lto_renaming_slot *) slot;
296 free (CONST_CAST (void *, (const void *) s->old_name));
297 free (CONST_CAST (void *, (const void *) s->new_name));
298 free ((void *) s);
301 /* Create an empty hash table for recording declaration renamings. */
303 htab_t
304 lto_create_renaming_table (void)
306 return htab_create (37, hash_name, eq_name, renaming_slot_free);
309 /* Record a declaration name mapping OLD_NAME -> NEW_NAME. DECL_DATA
310 holds the renaming hash table to use. */
312 void
313 lto_record_renamed_decl (struct lto_file_decl_data *decl_data,
314 const char *old_name, const char *new_name)
316 void **slot;
317 struct lto_renaming_slot r_slot;
319 r_slot.new_name = new_name;
320 slot = htab_find_slot (decl_data->renaming_hash_table, &r_slot, INSERT);
321 if (*slot == NULL)
323 struct lto_renaming_slot *new_slot = XNEW (struct lto_renaming_slot);
324 new_slot->old_name = xstrdup (old_name);
325 new_slot->new_name = xstrdup (new_name);
326 *slot = new_slot;
328 else
329 gcc_unreachable ();
333 /* Given a string NAME, return the string that it has been mapped to
334 by lto_record_renamed_decl. If NAME was not renamed, it is
335 returned unchanged. DECL_DATA holds the renaming hash table to use. */
337 const char *
338 lto_get_decl_name_mapping (struct lto_file_decl_data *decl_data,
339 const char *name)
341 htab_t renaming_hash_table = decl_data->renaming_hash_table;
342 struct lto_renaming_slot *slot;
343 struct lto_renaming_slot r_slot;
345 r_slot.new_name = name;
346 slot = (struct lto_renaming_slot *) htab_find (renaming_hash_table, &r_slot);
347 if (slot)
348 return slot->old_name;
349 else
350 return name;
353 /*****************************************************************************/
354 /* Input decl state object. */
355 /*****************************************************************************/
357 /* Return a newly created in-decl state object. */
359 struct lto_in_decl_state *
360 lto_new_in_decl_state (void)
362 return ggc_alloc_cleared_lto_in_decl_state ();
365 /* Delete STATE and its components. */
367 void
368 lto_delete_in_decl_state (struct lto_in_decl_state *state)
370 int i;
372 for (i = 0; i < LTO_N_DECL_STREAMS; i++)
373 if (state->streams[i].trees)
374 ggc_free (state->streams[i].trees);
375 ggc_free (state);
378 /* Hashtable helpers. lto_in_decl_states are hash by their function decls. */
380 hashval_t
381 lto_hash_in_decl_state (const void *p)
383 const struct lto_in_decl_state *state = (const struct lto_in_decl_state *) p;
384 return htab_hash_pointer (state->fn_decl);
387 /* Return true if the fn_decl field of the lto_in_decl_state pointed to by
388 P1 equals to the function decl P2. */
391 lto_eq_in_decl_state (const void *p1, const void *p2)
393 const struct lto_in_decl_state *state1 =
394 (const struct lto_in_decl_state *) p1;
395 const struct lto_in_decl_state *state2 =
396 (const struct lto_in_decl_state *) p2;
397 return state1->fn_decl == state2->fn_decl;
401 /* Search the in-decl state of a function FUNC contained in the file
402 associated with FILE_DATA. Return NULL if not found. */
404 struct lto_in_decl_state*
405 lto_get_function_in_decl_state (struct lto_file_decl_data *file_data,
406 tree func)
408 struct lto_in_decl_state temp;
409 void **slot;
411 temp.fn_decl = func;
412 slot = htab_find_slot (file_data->function_decl_states, &temp, NO_INSERT);
413 return slot? ((struct lto_in_decl_state*) *slot) : NULL;
417 /* Report read pass end of the section. */
419 void
420 lto_section_overrun (struct lto_input_block *ib)
422 fatal_error ("bytecode stream: trying to read %d bytes "
423 "after the end of the input buffer", ib->p - ib->len);
426 /* Report out of range value. */
428 void
429 lto_value_range_error (const char *purpose, HOST_WIDE_INT val,
430 HOST_WIDE_INT min, HOST_WIDE_INT max)
432 fatal_error ("%s out of range: Range is %i to %i, value is %i",
433 purpose, (int)min, (int)max, (int)val);