gcc/lto-section-in.c

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