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