1 /* Input functions for reading LTO sections.
3 Copyright (C) 2009-2016 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"
30 #include "lto-streamer.h"
31 #include "lto-compress.h"
33 /* Section names. These must correspond to the values of
34 enum lto_section_type. */
35 const char *lto_section_name
[LTO_N_SECTION_TYPES
] =
59 /* Hooks so that the ipa passes can call into the lto front end to get
62 static struct lto_file_decl_data
** file_decl_data
;
63 static lto_get_section_data_f
* get_section_f
;
64 static lto_free_section_data_f
* free_section_f
;
67 /* This is called from the lto front end to set up the hooks that are
68 used by the ipa passes to get the data that they will
72 lto_set_in_hooks (struct lto_file_decl_data
** data
,
73 lto_get_section_data_f
* get_f
,
74 lto_free_section_data_f
* free_f
)
76 file_decl_data
= data
;
77 get_section_f
= get_f
;
78 free_section_f
= free_f
;
82 /* Return an array of file decl datas for all of the files passed to
85 struct lto_file_decl_data
**
86 lto_get_file_decl_data (void)
88 gcc_assert (file_decl_data
);
89 return file_decl_data
;
92 /* Buffer structure for accumulating data from compression callbacks. */
100 /* Compression callback, append LENGTH bytes from DATA to the buffer pointed
104 lto_append_data (const char *data
, unsigned length
, void *opaque
)
106 struct lto_buffer
*buffer
= (struct lto_buffer
*) opaque
;
108 buffer
->data
= (char *) xrealloc (buffer
->data
, buffer
->length
+ length
);
109 memcpy (buffer
->data
+ buffer
->length
, data
, length
);
110 buffer
->length
+= length
;
113 /* Header placed in returned uncompressed data streams. Allows the
114 uncompressed allocated data to be mapped back to the underlying
115 compressed data for use with free_section_f. */
117 struct lto_data_header
123 /* Return a char pointer to the start of a data stream for an LTO pass
124 or function. FILE_DATA indicates where to obtain the data.
125 SECTION_TYPE is the type of information to be obtained. NAME is
126 the name of the function and is only used when finding a function
127 body; otherwise it is NULL. LEN is the size of the data
131 lto_get_section_data (struct lto_file_decl_data
*file_data
,
132 enum lto_section_type section_type
,
134 size_t *len
, bool decompress
)
136 const char *data
= (get_section_f
) (file_data
, section_type
, name
, len
);
137 const size_t header_length
= sizeof (struct lto_data_header
);
138 struct lto_data_header
*header
;
139 struct lto_buffer buffer
;
140 struct lto_compression_stream
*stream
;
141 lto_stats
.section_size
[section_type
] += *len
;
146 /* WPA->ltrans streams are not compressed with exception of function bodies
147 and variable initializers that has been verbatim copied from earlier
149 if (!flag_ltrans
|| decompress
)
151 /* Create a mapping header containing the underlying data and length,
152 and prepend this to the uncompression buffer. The uncompressed data
153 then follows, and a pointer to the start of the uncompressed data is
155 header
= (struct lto_data_header
*) xmalloc (header_length
);
159 buffer
.data
= (char *) header
;
160 buffer
.length
= header_length
;
162 stream
= lto_start_uncompression (lto_append_data
, &buffer
);
163 lto_uncompress_block (stream
, data
, *len
);
164 lto_end_uncompression (stream
);
166 *len
= buffer
.length
- header_length
;
167 data
= buffer
.data
+ header_length
;
170 lto_check_version (((const lto_header
*)data
)->major_version
,
171 ((const lto_header
*)data
)->minor_version
);
175 /* Get the section data without any header parsing or uncompression. */
178 lto_get_raw_section_data (struct lto_file_decl_data
*file_data
,
179 enum lto_section_type section_type
,
183 return (get_section_f
) (file_data
, section_type
, name
, len
);
186 /* Free the data found from the above call. The first three
187 parameters are the same as above. DATA is the data to be freed and
188 LEN is the length of that data. */
191 lto_free_section_data (struct lto_file_decl_data
*file_data
,
192 enum lto_section_type section_type
,
195 size_t len
, bool decompress
)
197 const size_t header_length
= sizeof (struct lto_data_header
);
198 const char *real_data
= data
- header_length
;
199 const struct lto_data_header
*header
200 = (const struct lto_data_header
*) real_data
;
202 gcc_assert (free_section_f
);
204 if (flag_ltrans
&& !decompress
)
206 (free_section_f
) (file_data
, section_type
, name
, data
, len
);
210 /* The underlying data address has been extracted from the mapping header.
211 Free that, then free the allocated uncompression buffer. */
212 (free_section_f
) (file_data
, section_type
, name
, header
->data
, header
->len
);
213 free (CONST_CAST (char *, real_data
));
216 /* Free data allocated by lto_get_raw_section_data. */
219 lto_free_raw_section_data (struct lto_file_decl_data
*file_data
,
220 enum lto_section_type section_type
,
225 (free_section_f
) (file_data
, section_type
, name
, data
, len
);
228 /* Load a section of type SECTION_TYPE from FILE_DATA, parse the
229 header and then return an input block pointing to the section. The
230 raw pointer to the section is returned in DATAR and LEN. These are
231 used to free the section. Return NULL if the section is not present. */
233 struct lto_input_block
*
234 lto_create_simple_input_block (struct lto_file_decl_data
*file_data
,
235 enum lto_section_type section_type
,
236 const char **datar
, size_t *len
)
238 const char *data
= lto_get_section_data (file_data
, section_type
, NULL
, len
);
239 const struct lto_simple_header
* header
240 = (const struct lto_simple_header
*) data
;
242 int main_offset
= sizeof (struct lto_simple_header
);
248 return new lto_input_block (data
+ main_offset
, header
->main_size
,
249 file_data
->mode_table
);
253 /* Close the section returned from a call to
254 LTO_CREATE_SIMPLE_INPUT_BLOCK. IB is the input block returned from
255 that call. The FILE_DATA and SECTION_TYPE are the same as what was
256 passed to that call and the DATA and LEN are what was returned from
260 lto_destroy_simple_input_block (struct lto_file_decl_data
*file_data
,
261 enum lto_section_type section_type
,
262 struct lto_input_block
*ib
,
263 const char *data
, size_t len
)
266 lto_free_section_data (file_data
, section_type
, NULL
, data
, len
);
269 /*****************************************************************************/
270 /* Record renamings of static declarations */
271 /*****************************************************************************/
273 struct lto_renaming_slot
275 const char *old_name
;
276 const char *new_name
;
279 /* Returns a hash code for P. */
282 hash_name (const void *p
)
284 const struct lto_renaming_slot
*ds
= (const struct lto_renaming_slot
*) p
;
285 return (hashval_t
) htab_hash_string (ds
->new_name
);
288 /* Returns nonzero if P1 and P2 are equal. */
291 eq_name (const void *p1
, const void *p2
)
293 const struct lto_renaming_slot
*s1
=
294 (const struct lto_renaming_slot
*) p1
;
295 const struct lto_renaming_slot
*s2
=
296 (const struct lto_renaming_slot
*) p2
;
298 return strcmp (s1
->new_name
, s2
->new_name
) == 0;
301 /* Free a renaming table entry. */
304 renaming_slot_free (void *slot
)
306 struct lto_renaming_slot
*s
= (struct lto_renaming_slot
*) slot
;
308 free (CONST_CAST (void *, (const void *) s
->old_name
));
309 free (CONST_CAST (void *, (const void *) s
->new_name
));
313 /* Create an empty hash table for recording declaration renamings. */
316 lto_create_renaming_table (void)
318 return htab_create (37, hash_name
, eq_name
, renaming_slot_free
);
321 /* Record a declaration name mapping OLD_NAME -> NEW_NAME. DECL_DATA
322 holds the renaming hash table to use. */
325 lto_record_renamed_decl (struct lto_file_decl_data
*decl_data
,
326 const char *old_name
, const char *new_name
)
329 struct lto_renaming_slot r_slot
;
331 r_slot
.new_name
= new_name
;
332 slot
= htab_find_slot (decl_data
->renaming_hash_table
, &r_slot
, INSERT
);
335 struct lto_renaming_slot
*new_slot
= XNEW (struct lto_renaming_slot
);
336 new_slot
->old_name
= xstrdup (old_name
);
337 new_slot
->new_name
= xstrdup (new_name
);
345 /* Given a string NAME, return the string that it has been mapped to
346 by lto_record_renamed_decl. If NAME was not renamed, it is
347 returned unchanged. DECL_DATA holds the renaming hash table to use. */
350 lto_get_decl_name_mapping (struct lto_file_decl_data
*decl_data
,
353 htab_t renaming_hash_table
= decl_data
->renaming_hash_table
;
354 struct lto_renaming_slot
*slot
;
355 struct lto_renaming_slot r_slot
;
357 r_slot
.new_name
= name
;
358 slot
= (struct lto_renaming_slot
*) htab_find (renaming_hash_table
, &r_slot
);
360 return slot
->old_name
;
365 /*****************************************************************************/
366 /* Input decl state object. */
367 /*****************************************************************************/
369 /* Return a newly created in-decl state object. */
371 struct lto_in_decl_state
*
372 lto_new_in_decl_state (void)
374 return ggc_cleared_alloc
<lto_in_decl_state
> ();
377 /* Delete STATE and its components. */
380 lto_delete_in_decl_state (struct lto_in_decl_state
*state
)
384 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
385 vec_free (state
->streams
[i
]);
389 /* Search the in-decl state of a function FUNC contained in the file
390 associated with FILE_DATA. Return NULL if not found. */
392 struct lto_in_decl_state
*
393 lto_get_function_in_decl_state (struct lto_file_decl_data
*file_data
,
396 struct lto_in_decl_state temp
;
397 lto_in_decl_state
**slot
;
400 slot
= file_data
->function_decl_states
->find_slot (&temp
, NO_INSERT
);
401 return slot
? *slot
: NULL
;
404 /* Free decl_states. */
407 lto_free_function_in_decl_state (struct lto_in_decl_state
*state
)
410 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
411 vec_free (state
->streams
[i
]);
415 /* Free decl_states associated with NODE. This makes it possible to furhter
416 release trees needed by the NODE's body. */
419 lto_free_function_in_decl_state_for_node (symtab_node
*node
)
421 struct lto_in_decl_state temp
;
422 lto_in_decl_state
**slot
;
424 if (!node
->lto_file_data
)
427 temp
.fn_decl
= node
->decl
;
429 = node
->lto_file_data
->function_decl_states
->find_slot (&temp
, NO_INSERT
);
432 lto_free_function_in_decl_state (*slot
);
433 node
->lto_file_data
->function_decl_states
->clear_slot (slot
);
435 node
->lto_file_data
= NULL
;
439 /* Report read pass end of the section. */
442 lto_section_overrun (struct lto_input_block
*ib
)
444 fatal_error (input_location
, "bytecode stream: trying to read %d bytes "
445 "after the end of the input buffer", ib
->p
- ib
->len
);
448 /* Report out of range value. */
451 lto_value_range_error (const char *purpose
, HOST_WIDE_INT val
,
452 HOST_WIDE_INT min
, HOST_WIDE_INT max
)
454 fatal_error (input_location
,
455 "%s out of range: Range is %i to %i, value is %i",
456 purpose
, (int)min
, (int)max
, (int)val
);