gcc/lto-section-in.c

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