gcc/lto-section-in.c

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