gcc/lto-section-in.cc

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