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