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