gcc/lto-section-in.c

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