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