gcc/lto-section-in.c

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