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