gcc/lto-section-in.c

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