gcc/lto-section-in.c

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