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