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