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