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