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 };
  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     {
 158       /* Create a mapping header containing the underlying data and length,
 159          and prepend this to the uncompression buffer.  The uncompressed data
 160          then follows, and a pointer to the start of the uncompressed data is
 161          returned.  */
 162       header = (struct lto_data_header *) xmalloc (header_length);
 163       header->data = data;
 164       header->len = *len;
 165
 166       buffer.data = (char *) header;
 167       buffer.length = header_length;
 168
 169       stream = lto_start_uncompression (lto_append_data, &buffer);
 170       lto_uncompress_block (stream, data, *len);
 171       lto_end_uncompression (stream);
 172
 173       *len = buffer.length - header_length;
 174       data = buffer.data + header_length;
 175     }
 176
 177   lto_check_version (((const lto_header *)data)->major_version,
 178                      ((const lto_header *)data)->minor_version);
 179   return data;
 180 }
 181
 182
 183 /* Free the data found from the above call.  The first three
 184    parameters are the same as above.  DATA is the data to be freed and
 185    LEN is the length of that data.  */
 186
 187 void
 188 lto_free_section_data (struct lto_file_decl_data *file_data,
 189                        enum lto_section_type section_type,
 190                        const char *name,
 191                        const char *data,
 192                        size_t len)
 193 {
 194   const size_t header_length = sizeof (struct lto_data_header);
 195   const char *real_data = data - header_length;
 196   const struct lto_data_header *header
 197     = (const struct lto_data_header *) real_data;
 198
 199   gcc_assert (free_section_f);
 200
 201   /* FIXME lto: WPA mode does not write compressed sections, so for now
 202      suppress uncompression mapping if flag_ltrans.  */
 203   if (flag_ltrans)
 204     {
 205       (free_section_f) (file_data, section_type, name, data, len);
 206       return;
 207     }
 208
 209   /* The underlying data address has been extracted from the mapping header.
 210      Free that, then free the allocated uncompression buffer.  */
 211   (free_section_f) (file_data, section_type, name, header->data, header->len);
 212   free (CONST_CAST (char *, real_data));
 213 }
 214
 215
 216 /* Load a section of type SECTION_TYPE from FILE_DATA, parse the
 217    header and then return an input block pointing to the section.  The
 218    raw pointer to the section is returned in DATAR and LEN.  These are
 219    used to free the section.  Return NULL if the section is not present.  */
 220
 221 struct lto_input_block *
 222 lto_create_simple_input_block (struct lto_file_decl_data *file_data,
 223                                enum lto_section_type section_type,
 224                                const char **datar, size_t *len)
 225 {
 226   const char *data = lto_get_section_data (file_data, section_type, NULL, len);
 227   const struct lto_simple_header * header
 228     = (const struct lto_simple_header *) data;
 229
 230   struct lto_input_block* ib_main;
 231   int main_offset = sizeof (struct lto_simple_header);
 232
 233   if (!data)
 234     return NULL;
 235
 236   ib_main = XNEW (struct lto_input_block);
 237
 238   *datar = data;
 239   LTO_INIT_INPUT_BLOCK_PTR (ib_main, data + main_offset,
 240                             0, header->main_size);
 241
 242   return ib_main;
 243 }
 244
 245
 246 /* Close the section returned from a call to
 247    LTO_CREATE_SIMPLE_INPUT_BLOCK.  IB is the input block returned from
 248    that call.  The FILE_DATA and SECTION_TYPE are the same as what was
 249    passed to that call and the DATA and LEN are what was returned from
 250    that call.  */
 251
 252 void
 253 lto_destroy_simple_input_block (struct lto_file_decl_data *file_data,
 254                                 enum lto_section_type section_type,
 255                                 struct lto_input_block *ib,
 256                                 const char *data, size_t len)
 257 {
 258   free (ib);
 259   lto_free_section_data (file_data, section_type, NULL, data, len);
 260 }
 261
 262 /*****************************************************************************/
 263 /* Record renamings of static declarations                                   */
 264 /*****************************************************************************/
 265
 266 struct lto_renaming_slot
 267 {
 268   const char *old_name;
 269   const char *new_name;
 270 };
 271
 272 /* Returns a hash code for P.  */
 273
 274 static hashval_t
 275 hash_name (const void *p)
 276 {
 277   const struct lto_renaming_slot *ds = (const struct lto_renaming_slot *) p;
 278   return (hashval_t) htab_hash_string (ds->new_name);
 279 }
 280
 281 /* Returns nonzero if P1 and P2 are equal.  */
 282
 283 static int
 284 eq_name (const void *p1, const void *p2)
 285 {
 286   const struct lto_renaming_slot *s1 =
 287     (const struct lto_renaming_slot *) p1;
 288   const struct lto_renaming_slot *s2 =
 289     (const struct lto_renaming_slot *) p2;
 290
 291   return strcmp (s1->new_name, s2->new_name) == 0;
 292 }
 293
 294 /* Free a renaming table entry.  */
 295
 296 static void
 297 renaming_slot_free (void *slot)
 298 {
 299   struct lto_renaming_slot *s = (struct lto_renaming_slot *) slot;
 300
 301   free (CONST_CAST (void *, (const void *) s->old_name));
 302   free (CONST_CAST (void *, (const void *) s->new_name));
 303   free ((void *) s);
 304 }
 305
 306 /* Create an empty hash table for recording declaration renamings.  */
 307
 308 htab_t
 309 lto_create_renaming_table (void)
 310 {
 311   return htab_create (37, hash_name, eq_name, renaming_slot_free);
 312 }
 313
 314 /* Record a declaration name mapping OLD_NAME -> NEW_NAME.  DECL_DATA
 315    holds the renaming hash table to use.  */
 316
 317 void
 318 lto_record_renamed_decl (struct lto_file_decl_data *decl_data,
 319                          const char *old_name, const char *new_name)
 320 {
 321   void **slot;
 322   struct lto_renaming_slot r_slot;
 323
 324   r_slot.new_name = new_name;
 325   slot = htab_find_slot (decl_data->renaming_hash_table, &r_slot, INSERT);
 326   if (*slot == NULL)
 327     {
 328       struct lto_renaming_slot *new_slot = XNEW (struct lto_renaming_slot);
 329       new_slot->old_name = xstrdup (old_name);
 330       new_slot->new_name = xstrdup (new_name);
 331       *slot = new_slot;
 332     }
 333   else
 334     gcc_unreachable ();
 335 }
 336
 337
 338 /* Given a string NAME, return the string that it has been mapped to
 339    by lto_record_renamed_decl.  If NAME was not renamed, it is
 340    returned unchanged.  DECL_DATA holds the renaming hash table to use.  */
 341
 342 const char *
 343 lto_get_decl_name_mapping (struct lto_file_decl_data *decl_data,
 344                            const char *name)
 345 {
 346   htab_t renaming_hash_table = decl_data->renaming_hash_table;
 347   struct lto_renaming_slot *slot;
 348   struct lto_renaming_slot r_slot;
 349
 350   r_slot.new_name = name;
 351   slot = (struct lto_renaming_slot *) htab_find (renaming_hash_table, &r_slot);
 352   if (slot)
 353     return slot->old_name;
 354   else
 355     return name;
 356 }
 357
 358 /*****************************************************************************/
 359 /* Input decl state object.                                                  */
 360 /*****************************************************************************/
 361
 362 /* Return a newly created in-decl state object. */
 363
 364 struct lto_in_decl_state *
 365 lto_new_in_decl_state (void)
 366 {
 367   return ggc_cleared_alloc<lto_in_decl_state> ();
 368 }
 369
 370 /* Delete STATE and its components. */
 371
 372 void
 373 lto_delete_in_decl_state (struct lto_in_decl_state *state)
 374 {
 375   int i;
 376
 377   for (i = 0; i < LTO_N_DECL_STREAMS; i++)
 378     if (state->streams[i].trees)
 379       ggc_free (state->streams[i].trees);
 380   ggc_free (state);
 381 }
 382
 383 /* Hashtable helpers. lto_in_decl_states are hash by their function decls. */
 384
 385 hashval_t
 386 lto_hash_in_decl_state (const void *p)
 387 {
 388   const struct lto_in_decl_state *state = (const struct lto_in_decl_state *) p;
 389   return htab_hash_pointer (state->fn_decl);
 390 }
 391
 392 /* Return true if the fn_decl field of the lto_in_decl_state pointed to by
 393    P1 equals to the function decl P2. */
 394
 395 int
 396 lto_eq_in_decl_state (const void *p1, const void *p2)
 397 {
 398   const struct lto_in_decl_state *state1 =
 399    (const struct lto_in_decl_state *) p1;
 400   const struct lto_in_decl_state *state2 =
 401    (const struct lto_in_decl_state *) p2;
 402   return state1->fn_decl == state2->fn_decl;
 403 }
 404
 405
 406 /* Search the in-decl state of a function FUNC contained in the file
 407    associated with FILE_DATA.  Return NULL if not found.  */
 408
 409 struct lto_in_decl_state*
 410 lto_get_function_in_decl_state (struct lto_file_decl_data *file_data,
 411                                 tree func)
 412 {
 413   struct lto_in_decl_state temp;
 414   void **slot;
 415
 416   temp.fn_decl = func;
 417   slot = htab_find_slot (file_data->function_decl_states, &temp, NO_INSERT);
 418   return slot? ((struct lto_in_decl_state*) *slot) : NULL;
 419 }
 420
 421 /* Free decl_states.  */
 422
 423 void
 424 lto_free_function_in_decl_state (struct lto_in_decl_state *state)
 425 {
 426   int i;
 427   for (i = 0; i < LTO_N_DECL_STREAMS; i++)
 428     ggc_free (state->streams[i].trees);
 429   ggc_free (state);
 430 }
 431
 432 /* Free decl_states associated with NODE.  This makes it possible to furhter
 433    release trees needed by the NODE's body.  */
 434
 435 void
 436 lto_free_function_in_decl_state_for_node (symtab_node *node)
 437 {
 438   struct lto_in_decl_state temp;
 439   void **slot;
 440
 441   if (!node->lto_file_data)
 442     return;
 443
 444   temp.fn_decl = node->decl;
 445   slot = htab_find_slot (node->lto_file_data->function_decl_states,
 446                          &temp, NO_INSERT);
 447   if (slot && *slot)
 448     {
 449       lto_free_function_in_decl_state ((struct lto_in_decl_state*) *slot);
 450       htab_clear_slot (node->lto_file_data->function_decl_states,
 451                        slot);
 452     }
 453   node->lto_file_data = NULL;
 454 }
 455
 456
 457 /* Report read pass end of the section.  */
 458
 459 void
 460 lto_section_overrun (struct lto_input_block *ib)
 461 {
 462   fatal_error ("bytecode stream: trying to read %d bytes "
 463                "after the end of the input buffer", ib->p - ib->len);
 464 }
 465
 466 /* Report out of range value.  */
 467
 468 void
 469 lto_value_range_error (const char *purpose, HOST_WIDE_INT val,
 470                        HOST_WIDE_INT min, HOST_WIDE_INT max)
 471 {
 472   fatal_error ("%s out of range: Range is %i to %i, value is %i",
 473                purpose, (int)min, (int)max, (int)val);
 474 }