contrib/gcc-8.0/gcc/lto-section-in.c

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