gcc/lto-section-in.c

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