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