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