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