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