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 /* Unpack VAL from BP in a variant of uleb format.  */
 131
 132 unsigned HOST_WIDE_INT
 133 bp_unpack_var_len_unsigned (struct bitpack_d *bp)
 134 {
 135   unsigned HOST_WIDE_INT result = 0;
 136   int shift = 0;
 137   unsigned HOST_WIDE_INT half_byte;
 138
 139   while (true)
 140     {
 141       half_byte = bp_unpack_value (bp, 4);
 142       result |= (half_byte & 0x7) << shift;
 143       shift += 3;
 144       if ((half_byte & 0x8) == 0)
 145         return result;
 146     }
 147 }
 148
 149
 150 /* Unpack VAL from BP in a variant of sleb format.  */
 151
 152 HOST_WIDE_INT
 153 bp_unpack_var_len_int (struct bitpack_d *bp)
 154 {
 155   HOST_WIDE_INT result = 0;
 156   int shift = 0;
 157   unsigned HOST_WIDE_INT half_byte;
 158
 159   while (true)
 160     {
 161       half_byte = bp_unpack_value (bp, 4);
 162       result |= (half_byte & 0x7) << shift;
 163       shift += 3;
 164       if ((half_byte & 0x8) == 0)
 165         {
 166           if ((shift < HOST_BITS_PER_WIDE_INT) && (half_byte & 0x4))
 167             result |= - ((HOST_WIDE_INT)1 << shift);
 168
 169           return result;
 170         }
 171     }
 172 }
 173
 174
 175 /* Hooks so that the ipa passes can call into the lto front end to get
 176    sections.  */
 177
 178 static struct lto_file_decl_data ** file_decl_data;
 179 static lto_get_section_data_f* get_section_f;
 180 static lto_free_section_data_f* free_section_f;
 181
 182
 183 /* This is called from the lto front end to set up the hooks that are
 184    used by the ipa passes to get the data that they will
 185    deserialize.  */
 186
 187 void
 188 lto_set_in_hooks (struct lto_file_decl_data ** data,
 189                   lto_get_section_data_f* get_f,
 190                   lto_free_section_data_f* free_f)
 191 {
 192   file_decl_data = data;
 193   get_section_f = get_f;
 194   free_section_f = free_f;
 195 }
 196
 197
 198 /* Return an array of file decl datas for all of the files passed to
 199    this compilation.  */
 200
 201 struct lto_file_decl_data **
 202 lto_get_file_decl_data (void)
 203 {
 204   gcc_assert (file_decl_data);
 205   return file_decl_data;
 206 }
 207
 208 /* Buffer structure for accumulating data from compression callbacks.  */
 209
 210 struct lto_buffer
 211 {
 212   char *data;
 213   size_t length;
 214 };
 215
 216 /* Compression callback, append LENGTH bytes from DATA to the buffer pointed
 217    to by OPAQUE.  */
 218
 219 static void
 220 lto_append_data (const char *data, unsigned length, void *opaque)
 221 {
 222   struct lto_buffer *buffer = (struct lto_buffer *) opaque;
 223
 224   buffer->data = (char *) xrealloc (buffer->data, buffer->length + length);
 225   memcpy (buffer->data + buffer->length, data, length);
 226   buffer->length += length;
 227 }
 228
 229 /* Header placed in returned uncompressed data streams.  Allows the
 230    uncompressed allocated data to be mapped back to the underlying
 231    compressed data for use with free_section_f.  */
 232
 233 struct lto_data_header
 234 {
 235   const char *data;
 236   size_t len;
 237 };
 238
 239 /* Return a char pointer to the start of a data stream for an LTO pass
 240    or function.  FILE_DATA indicates where to obtain the data.
 241    SECTION_TYPE is the type of information to be obtained.  NAME is
 242    the name of the function and is only used when finding a function
 243    body; otherwise it is NULL.  LEN is the size of the data
 244    returned.  */
 245
 246 const char *
 247 lto_get_section_data (struct lto_file_decl_data *file_data,
 248                       enum lto_section_type section_type,
 249                       const char *name,
 250                       size_t *len)
 251 {
 252   const char *data = (get_section_f) (file_data, section_type, name, len);
 253   const size_t header_length = sizeof (struct lto_data_header);
 254   struct lto_data_header *header;
 255   struct lto_buffer buffer;
 256   struct lto_compression_stream *stream;
 257   lto_stats.section_size[section_type] += *len;
 258
 259   if (data == NULL)
 260     return NULL;
 261
 262   /* FIXME lto: WPA mode does not write compressed sections, so for now
 263      suppress uncompression if flag_ltrans.  */
 264   if (flag_ltrans)
 265     return data;
 266
 267   /* Create a mapping header containing the underlying data and length,
 268      and prepend this to the uncompression buffer.  The uncompressed data
 269      then follows, and a pointer to the start of the uncompressed data is
 270      returned.  */
 271   header = (struct lto_data_header *) xmalloc (header_length);
 272   header->data = data;
 273   header->len = *len;
 274
 275   buffer.data = (char *) header;
 276   buffer.length = header_length;
 277
 278   stream = lto_start_uncompression (lto_append_data, &buffer);
 279   lto_uncompress_block (stream, data, *len);
 280   lto_end_uncompression (stream);
 281
 282   *len = buffer.length - header_length;
 283   return buffer.data + header_length;
 284 }
 285
 286
 287 /* Free the data found from the above call.  The first three
 288    parameters are the same as above.  DATA is the data to be freed and
 289    LEN is the length of that data.  */
 290
 291 void
 292 lto_free_section_data (struct lto_file_decl_data *file_data,
 293                        enum lto_section_type section_type,
 294                        const char *name,
 295                        const char *data,
 296                        size_t len)
 297 {
 298   const size_t header_length = sizeof (struct lto_data_header);
 299   const char *real_data = data - header_length;
 300   const struct lto_data_header *header
 301     = (const struct lto_data_header *) real_data;
 302
 303   gcc_assert (free_section_f);
 304
 305   /* FIXME lto: WPA mode does not write compressed sections, so for now
 306      suppress uncompression mapping if flag_ltrans.  */
 307   if (flag_ltrans)
 308     {
 309       (free_section_f) (file_data, section_type, name, data, len);
 310       return;
 311     }
 312
 313   /* The underlying data address has been extracted from the mapping header.
 314      Free that, then free the allocated uncompression buffer.  */
 315   (free_section_f) (file_data, section_type, name, header->data, header->len);
 316   free (CONST_CAST (char *, real_data));
 317 }
 318
 319
 320 /* Load a section of type SECTION_TYPE from FILE_DATA, parse the
 321    header and then return an input block pointing to the section.  The
 322    raw pointer to the section is returned in DATAR and LEN.  These are
 323    used to free the section.  Return NULL if the section is not present.  */
 324
 325 struct lto_input_block *
 326 lto_create_simple_input_block (struct lto_file_decl_data *file_data,
 327                                enum lto_section_type section_type,
 328                                const char **datar, size_t *len)
 329 {
 330   const char *data = lto_get_section_data (file_data, section_type, NULL, len);
 331   const struct lto_simple_header * header
 332     = (const struct lto_simple_header *) data;
 333
 334   struct lto_input_block* ib_main;
 335   int32_t main_offset = sizeof (struct lto_simple_header);
 336
 337   if (!data)
 338     return NULL;
 339
 340   ib_main = XNEW (struct lto_input_block);
 341
 342   *datar = data;
 343   LTO_INIT_INPUT_BLOCK_PTR (ib_main, data + main_offset,
 344                             0, header->main_size);
 345
 346   return ib_main;
 347 }
 348
 349
 350 /* Close the section returned from a call to
 351    LTO_CREATE_SIMPLE_INPUT_BLOCK.  IB is the input block returned from
 352    that call.  The FILE_DATA and SECTION_TYPE are the same as what was
 353    passed to that call and the DATA and LEN are what was returned from
 354    that call.  */
 355
 356 void
 357 lto_destroy_simple_input_block (struct lto_file_decl_data *file_data,
 358                                 enum lto_section_type section_type,
 359                                 struct lto_input_block *ib,
 360                                 const char *data, size_t len)
 361 {
 362   free (ib);
 363   lto_free_section_data (file_data, section_type, NULL, data, len);
 364 }
 365
 366 /*****************************************************************************/
 367 /* Record renamings of static declarations                                   */
 368 /*****************************************************************************/
 369
 370 struct lto_renaming_slot
 371 {
 372   const char *old_name;
 373   const char *new_name;
 374 };
 375
 376 /* Returns a hash code for P.  */
 377
 378 static hashval_t
 379 hash_name (const void *p)
 380 {
 381   const struct lto_renaming_slot *ds = (const struct lto_renaming_slot *) p;
 382   return (hashval_t) htab_hash_string (ds->new_name);
 383 }
 384
 385 /* Returns nonzero if P1 and P2 are equal.  */
 386
 387 static int
 388 eq_name (const void *p1, const void *p2)
 389 {
 390   const struct lto_renaming_slot *s1 =
 391     (const struct lto_renaming_slot *) p1;
 392   const struct lto_renaming_slot *s2 =
 393     (const struct lto_renaming_slot *) p2;
 394
 395   return strcmp (s1->new_name, s2->new_name) == 0;
 396 }
 397
 398 /* Free a renaming table entry.  */
 399
 400 static void
 401 renaming_slot_free (void *slot)
 402 {
 403   struct lto_renaming_slot *s = (struct lto_renaming_slot *) slot;
 404
 405   free (CONST_CAST (void *, (const void *) s->old_name));
 406   free (CONST_CAST (void *, (const void *) s->new_name));
 407   free ((void *) s);
 408 }
 409
 410 /* Create an empty hash table for recording declaration renamings.  */
 411
 412 htab_t
 413 lto_create_renaming_table (void)
 414 {
 415   return htab_create (37, hash_name, eq_name, renaming_slot_free);
 416 }
 417
 418 /* Record a declaration name mapping OLD_NAME -> NEW_NAME.  DECL_DATA
 419    holds the renaming hash table to use.  */
 420
 421 void
 422 lto_record_renamed_decl (struct lto_file_decl_data *decl_data,
 423                          const char *old_name, const char *new_name)
 424 {
 425   void **slot;
 426   struct lto_renaming_slot r_slot;
 427
 428   r_slot.new_name = new_name;
 429   slot = htab_find_slot (decl_data->renaming_hash_table, &r_slot, INSERT);
 430   if (*slot == NULL)
 431     {
 432       struct lto_renaming_slot *new_slot = XNEW (struct lto_renaming_slot);
 433       new_slot->old_name = xstrdup (old_name);
 434       new_slot->new_name = xstrdup (new_name);
 435       *slot = new_slot;
 436     }
 437   else
 438     gcc_unreachable ();
 439 }
 440
 441
 442 /* Given a string NAME, return the string that it has been mapped to
 443    by lto_record_renamed_decl.  If NAME was not renamed, it is
 444    returned unchanged.  DECL_DATA holds the renaming hash table to use.  */
 445
 446 const char *
 447 lto_get_decl_name_mapping (struct lto_file_decl_data *decl_data,
 448                            const char *name)
 449 {
 450   htab_t renaming_hash_table = decl_data->renaming_hash_table;
 451   struct lto_renaming_slot *slot;
 452   struct lto_renaming_slot r_slot;
 453
 454   r_slot.new_name = name;
 455   slot = (struct lto_renaming_slot *) htab_find (renaming_hash_table, &r_slot);
 456   if (slot)
 457     return slot->old_name;
 458   else
 459     return name;
 460 }
 461
 462 /*****************************************************************************/
 463 /* Input decl state object.                                                  */
 464 /*****************************************************************************/
 465
 466 /* Return a newly created in-decl state object. */
 467
 468 struct lto_in_decl_state *
 469 lto_new_in_decl_state (void)
 470 {
 471   return ggc_alloc_cleared_lto_in_decl_state ();
 472 }
 473
 474 /* Delete STATE and its components. */
 475
 476 void
 477 lto_delete_in_decl_state (struct lto_in_decl_state *state)
 478 {
 479   int i;
 480
 481   for (i = 0; i < LTO_N_DECL_STREAMS; i++)
 482     if (state->streams[i].trees)
 483       ggc_free (state->streams[i].trees);
 484   ggc_free (state);
 485 }
 486
 487 /* Hashtable helpers. lto_in_decl_states are hash by their function decls. */
 488
 489 hashval_t
 490 lto_hash_in_decl_state (const void *p)
 491 {
 492   const struct lto_in_decl_state *state = (const struct lto_in_decl_state *) p;
 493   return htab_hash_pointer (state->fn_decl);
 494 }
 495
 496 /* Return true if the fn_decl field of the lto_in_decl_state pointed to by
 497    P1 equals to the function decl P2. */
 498
 499 int
 500 lto_eq_in_decl_state (const void *p1, const void *p2)
 501 {
 502   const struct lto_in_decl_state *state1 =
 503    (const struct lto_in_decl_state *) p1;
 504   const struct lto_in_decl_state *state2 =
 505    (const struct lto_in_decl_state *) p2;
 506   return state1->fn_decl == state2->fn_decl;
 507 }
 508
 509
 510 /* Search the in-decl state of a function FUNC contained in the file
 511    associated with FILE_DATA.  Return NULL if not found.  */
 512
 513 struct lto_in_decl_state*
 514 lto_get_function_in_decl_state (struct lto_file_decl_data *file_data,
 515                                 tree func)
 516 {
 517   struct lto_in_decl_state temp;
 518   void **slot;
 519
 520   temp.fn_decl = func;
 521   slot = htab_find_slot (file_data->function_decl_states, &temp, NO_INSERT);
 522   return slot? ((struct lto_in_decl_state*) *slot) : NULL;
 523 }
 524
 525
 526 /* Report read pass end of the section.  */
 527
 528 void
 529 lto_section_overrun (struct lto_input_block *ib)
 530 {
 531   fatal_error ("bytecode stream: trying to read %d bytes "
 532                "after the end of the input buffer", ib->p - ib->len);
 533 }
 534
 535 /* Report out of range value.  */
 536
 537 void
 538 lto_value_range_error (const char *purpose, HOST_WIDE_INT val,
 539                        HOST_WIDE_INT min, HOST_WIDE_INT max)
 540 {
 541   fatal_error ("%s out of range: Range is %i to %i, value is %i",
 542                purpose, (int)min, (int)max, (int)val);
 543 }