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