1/* Input functions for reading LTO sections.
2
3 Copyright (C) 2009-2023 Free Software Foundation, Inc.
4 Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>
5
6This file is part of GCC.
7
8GCC is free software; you can redistribute it and/or modify it under
9the terms of the GNU General Public License as published by the Free
10Software Foundation; either version 3, or (at your option) any later
11version.
12
13GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14WARRANTY; without even the implied warranty of MERCHANTABILITY or
15FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16for more details.
17
18You should have received a copy of the GNU General Public License
19along 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 "backend.h"
26#include "rtl.h"
27#include "tree.h"
28#include "gimple.h"
29#include "cgraph.h"
30#include "lto-streamer.h"
31#include "lto-compress.h"
32
33/* Section names. These must correspond to the values of
34 enum lto_section_type. */
35const char *lto_section_name[LTO_N_SECTION_TYPES] =
36{
37 "decls",
38 "function_body",
39 "statics",
40 "symtab",
41 "ext_symtab",
42 "refs",
43 "asm",
44 "jmpfuncs",
45 "pureconst",
46 "reference",
47 "profile",
48 "symbol_nodes",
49 "opts",
50 "cgraphopt",
51 "inline",
52 "ipcp_trans",
53 "icf",
54 "offload_table",
55 "mode_table",
56 "lto",
57 "ipa_sra",
58 "odr_types",
59 "ipa_modref",
60};
61
62/* Hooks so that the ipa passes can call into the lto front end to get
63 sections. */
64
65static struct lto_file_decl_data ** file_decl_data;
66static lto_get_section_data_f* get_section_f;
67static lto_free_section_data_f* free_section_f;
68
69
70/* This is called from the lto front end to set up the hooks that are
71 used by the ipa passes to get the data that they will
72 deserialize. */
73
74void
75lto_set_in_hooks (struct lto_file_decl_data ** data,
76 lto_get_section_data_f* get_f,
77 lto_free_section_data_f* free_f)
78{
79 file_decl_data = data;
80 get_section_f = get_f;
81 free_section_f = free_f;
82}
83
84
85/* Return an array of file decl datas for all of the files passed to
86 this compilation. */
87
88struct lto_file_decl_data **
89lto_get_file_decl_data (void)
90{
91 gcc_assert (file_decl_data);
92 return file_decl_data;
93}
94
95/* Buffer structure for accumulating data from compression callbacks. */
96
97struct lto_buffer
98{
99 char *data;
100 size_t length;
101};
102
103/* Compression callback, append LENGTH bytes from DATA to the buffer pointed
104 to by OPAQUE. */
105
106static void
107lto_append_data (const char *data, unsigned length, void *opaque)
108{
109 struct lto_buffer *buffer = (struct lto_buffer *) opaque;
110
111 buffer->data = (char *) xrealloc (buffer->data, buffer->length + length);
112 memcpy (dest: buffer->data + buffer->length, src: data, n: length);
113 buffer->length += length;
114}
115
116/* Header placed in returned uncompressed data streams. Allows the
117 uncompressed allocated data to be mapped back to the underlying
118 compressed data for use with free_section_f. */
119
120struct lto_data_header
121{
122 const char *data;
123 size_t len;
124};
125
126/* Return a char pointer to the start of a data stream for an LTO pass
127 or function. FILE_DATA indicates where to obtain the data.
128 SECTION_TYPE is the type of information to be obtained. NAME is
129 the name of the function and is only used when finding a function
130 body; otherwise it is NULL. LEN is the size of the data
131 returned. */
132
133const char *
134lto_get_section_data (struct lto_file_decl_data *file_data,
135 enum lto_section_type section_type,
136 const char *name, int order,
137 size_t *len, bool decompress)
138{
139 const char *data = (get_section_f) (file_data, section_type, name, order,
140 len);
141 const size_t header_length = sizeof (struct lto_data_header);
142 struct lto_data_header *header;
143 struct lto_buffer buffer;
144 struct lto_compression_stream *stream;
145 lto_stats.section_size[section_type] += *len;
146
147 if (data == NULL)
148 return NULL;
149
150 /* WPA->ltrans streams are not compressed with exception of function bodies
151 and variable initializers that has been verbatim copied from earlier
152 compilations. */
153 if ((!flag_ltrans || decompress) && section_type != LTO_section_lto)
154 {
155 /* Create a mapping header containing the underlying data and length,
156 and prepend this to the uncompression buffer. The uncompressed data
157 then follows, and a pointer to the start of the uncompressed data is
158 returned. */
159 header = (struct lto_data_header *) xmalloc (header_length);
160 header->data = data;
161 header->len = *len;
162
163 buffer.data = (char *) header;
164 buffer.length = header_length;
165
166 stream = lto_start_uncompression (callback: lto_append_data, opaque: &buffer);
167 lto_uncompress_block (stream, base: data, num_chars: *len);
168 lto_end_uncompression (stream,
169 compression: file_data->lto_section_header.get_compression ());
170
171 *len = buffer.length - header_length;
172 data = buffer.data + header_length;
173 }
174
175 return data;
176}
177
178/* Return a char pointer to the start of a data stream for an LTO pass.
179 FILE_DATA indicates where to obtain the data.
180 SECTION_TYPE is the type of information to be obtained.
181 LEN is the size of the data returned. */
182
183const char *
184lto_get_summary_section_data (struct lto_file_decl_data *file_data,
185 enum lto_section_type section_type, size_t *len)
186{
187 return lto_get_section_data (file_data, section_type, NULL, order: 0, len);
188}
189
190/* Get the section data without any header parsing or uncompression. */
191
192const char *
193lto_get_raw_section_data (struct lto_file_decl_data *file_data,
194 enum lto_section_type section_type,
195 const char *name, int order,
196 size_t *len)
197{
198 return (get_section_f) (file_data, section_type, name, order, len);
199}
200
201/* Free the data found from the above call. The first three
202 parameters are the same as above. DATA is the data to be freed and
203 LEN is the length of that data. */
204
205void
206lto_free_section_data (struct lto_file_decl_data *file_data,
207 enum lto_section_type section_type,
208 const char *name,
209 const char *data,
210 size_t len, bool decompress)
211{
212 const size_t header_length = sizeof (struct lto_data_header);
213 const char *real_data = data - header_length;
214 const struct lto_data_header *header
215 = (const struct lto_data_header *) real_data;
216
217 gcc_assert (free_section_f);
218
219 if (flag_ltrans && !decompress)
220 {
221 (free_section_f) (file_data, section_type, name, data, len);
222 return;
223 }
224
225 /* The underlying data address has been extracted from the mapping header.
226 Free that, then free the allocated uncompression buffer. */
227 (free_section_f) (file_data, section_type, name, header->data, header->len);
228 free (CONST_CAST (char *, real_data));
229}
230
231/* Free data allocated by lto_get_raw_section_data. */
232
233void
234lto_free_raw_section_data (struct lto_file_decl_data *file_data,
235 enum lto_section_type section_type,
236 const char *name,
237 const char *data,
238 size_t len)
239{
240 (free_section_f) (file_data, section_type, name, data, len);
241}
242
243/* Load a section of type SECTION_TYPE from FILE_DATA, parse the
244 header and then return an input block pointing to the section. The
245 raw pointer to the section is returned in DATAR and LEN. These are
246 used to free the section. Return NULL if the section is not present. */
247
248class lto_input_block *
249lto_create_simple_input_block (struct lto_file_decl_data *file_data,
250 enum lto_section_type section_type,
251 const char **datar, size_t *len)
252{
253 const char *data = lto_get_section_data (file_data, section_type, NULL, order: 0,
254 len);
255 const struct lto_simple_header * header
256 = (const struct lto_simple_header *) data;
257
258 int main_offset = sizeof (struct lto_simple_header);
259
260 if (!data)
261 return NULL;
262
263 *datar = data;
264 return new lto_input_block (data + main_offset, header->main_size,
265 file_data);
266}
267
268
269/* Close the section returned from a call to
270 LTO_CREATE_SIMPLE_INPUT_BLOCK. IB is the input block returned from
271 that call. The FILE_DATA and SECTION_TYPE are the same as what was
272 passed to that call and the DATA and LEN are what was returned from
273 that call. */
274
275void
276lto_destroy_simple_input_block (struct lto_file_decl_data *file_data,
277 enum lto_section_type section_type,
278 class lto_input_block *ib,
279 const char *data, size_t len)
280{
281 delete ib;
282 lto_free_section_data (file_data, section_type, NULL, data, len);
283}
284
285/*****************************************************************************/
286/* Record renamings of static declarations */
287/*****************************************************************************/
288
289struct lto_renaming_slot
290{
291 const char *old_name;
292 const char *new_name;
293};
294
295/* Returns a hash code for P. */
296
297static hashval_t
298hash_name (const void *p)
299{
300 const struct lto_renaming_slot *ds = (const struct lto_renaming_slot *) p;
301 return (hashval_t) htab_hash_string (ds->new_name);
302}
303
304/* Returns nonzero if P1 and P2 are equal. */
305
306static int
307eq_name (const void *p1, const void *p2)
308{
309 const struct lto_renaming_slot *s1 =
310 (const struct lto_renaming_slot *) p1;
311 const struct lto_renaming_slot *s2 =
312 (const struct lto_renaming_slot *) p2;
313
314 return strcmp (s1: s1->new_name, s2: s2->new_name) == 0;
315}
316
317/* Free a renaming table entry. */
318
319static void
320renaming_slot_free (void *slot)
321{
322 struct lto_renaming_slot *s = (struct lto_renaming_slot *) slot;
323
324 free (CONST_CAST (void *, (const void *) s->old_name));
325 free (CONST_CAST (void *, (const void *) s->new_name));
326 free (ptr: (void *) s);
327}
328
329/* Create an empty hash table for recording declaration renamings. */
330
331htab_t
332lto_create_renaming_table (void)
333{
334 return htab_create (37, hash_name, eq_name, renaming_slot_free);
335}
336
337/* Record a declaration name mapping OLD_NAME -> NEW_NAME. DECL_DATA
338 holds the renaming hash table to use. */
339
340void
341lto_record_renamed_decl (struct lto_file_decl_data *decl_data,
342 const char *old_name, const char *new_name)
343{
344 void **slot;
345 struct lto_renaming_slot r_slot;
346
347 r_slot.new_name = new_name;
348 slot = htab_find_slot (decl_data->renaming_hash_table, &r_slot, INSERT);
349 if (*slot == NULL)
350 {
351 struct lto_renaming_slot *new_slot = XNEW (struct lto_renaming_slot);
352 new_slot->old_name = xstrdup (old_name);
353 new_slot->new_name = xstrdup (new_name);
354 *slot = new_slot;
355 }
356 else
357 gcc_unreachable ();
358}
359
360
361/* Given a string NAME, return the string that it has been mapped to
362 by lto_record_renamed_decl. If NAME was not renamed, it is
363 returned unchanged. DECL_DATA holds the renaming hash table to use. */
364
365const char *
366lto_get_decl_name_mapping (struct lto_file_decl_data *decl_data,
367 const char *name)
368{
369 htab_t renaming_hash_table = decl_data->renaming_hash_table;
370 struct lto_renaming_slot *slot;
371 struct lto_renaming_slot r_slot;
372
373 r_slot.new_name = name;
374 slot = (struct lto_renaming_slot *) htab_find (renaming_hash_table, &r_slot);
375 if (slot)
376 return slot->old_name;
377 else
378 return name;
379}
380
381/*****************************************************************************/
382/* Input decl state object. */
383/*****************************************************************************/
384
385/* Return a newly created in-decl state object. */
386
387struct lto_in_decl_state *
388lto_new_in_decl_state (void)
389{
390 return ggc_cleared_alloc<lto_in_decl_state> ();
391}
392
393/* Delete STATE and its components. */
394
395void
396lto_delete_in_decl_state (struct lto_in_decl_state *state)
397{
398 int i;
399
400 for (i = 0; i < LTO_N_DECL_STREAMS; i++)
401 vec_free (v&: state->streams[i]);
402 ggc_free (state);
403}
404
405/* Search the in-decl state of a function FUNC contained in the file
406 associated with FILE_DATA. Return NULL if not found. */
407
408struct lto_in_decl_state*
409lto_get_function_in_decl_state (struct lto_file_decl_data *file_data,
410 tree func)
411{
412 struct lto_in_decl_state temp;
413 lto_in_decl_state **slot;
414
415 temp.fn_decl = func;
416 slot = file_data->function_decl_states->find_slot (value: &temp, insert: NO_INSERT);
417 return slot? *slot : NULL;
418}
419
420/* Free decl_states. */
421
422void
423lto_free_function_in_decl_state (struct lto_in_decl_state *state)
424{
425 int i;
426 for (i = 0; i < LTO_N_DECL_STREAMS; i++)
427 vec_free (v&: state->streams[i]);
428 ggc_free (state);
429}
430
431/* Free decl_states associated with NODE. This makes it possible to furhter
432 release trees needed by the NODE's body. */
433
434void
435lto_free_function_in_decl_state_for_node (symtab_node *node)
436{
437 struct lto_in_decl_state temp;
438 lto_in_decl_state **slot;
439
440 if (!node->lto_file_data)
441 return;
442
443 temp.fn_decl = node->decl;
444 slot
445 = node->lto_file_data->function_decl_states->find_slot (value: &temp, insert: NO_INSERT);
446 if (slot && *slot)
447 {
448 lto_free_function_in_decl_state (state: *slot);
449 node->lto_file_data->function_decl_states->clear_slot (slot);
450 }
451 node->lto_file_data = NULL;
452}
453
454
455/* Report read pass end of the section. */
456
457void
458lto_section_overrun (class lto_input_block *ib)
459{
460 fatal_error (input_location, "bytecode stream: trying to read %d bytes "
461 "after the end of the input buffer", ib->p - ib->len);
462}
463
464/* Report out of range value. */
465
466void
467lto_value_range_error (const char *purpose, HOST_WIDE_INT val,
468 HOST_WIDE_INT min, HOST_WIDE_INT max)
469{
470 fatal_error (input_location,
471 "%s out of range: Range is %i to %i, value is %i",
472 purpose, (int)min, (int)max, (int)val);
473}
474

source code of gcc/lto-section-in.cc