gcc/lto-section-out.c

   1 /* Functions for writing LTO sections.
   2
   3    Copyright (C) 2009-2018 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 "data-streamer.h"
  31 #include "langhooks.h"
  32 #include "lto-compress.h"
  33 #include "print-tree.h"
  34
  35 static vec<lto_out_decl_state_ptr> decl_state_stack;
  36
  37 /* List of out decl states used by functions.  We use this to
  38    generate the decl directory later. */
  39
  40 vec<lto_out_decl_state_ptr> lto_function_decl_states;
  41
  42
  43 /*****************************************************************************
  44    Output routines shared by all of the serialization passes.
  45 *****************************************************************************/
  46
  47
  48 /* Flush compressed stream data function, sends NUM_CHARS from CHARS
  49    to the append lang hook, OPAQUE is currently always NULL.  */
  50
  51 static void
  52 lto_append_data (const char *chars, unsigned int num_chars, void *opaque)
  53 {
  54   gcc_assert (opaque == NULL);
  55   lang_hooks.lto.append_data (chars, num_chars, opaque);
  56 }
  57
  58 /* Pointer to the current compression stream.  */
  59
  60 static struct lto_compression_stream *compression_stream = NULL;
  61
  62 /* Begin a new output section named NAME. If COMPRESS is true, zlib compress
  63    the section. */
  64
  65 void
  66 lto_begin_section (const char *name, bool compress)
  67 {
  68   lang_hooks.lto.begin_section (name);
  69
  70   if (streamer_dump_file)
  71     fprintf (streamer_dump_file, "Creating %ssection %s\n",
  72              compress ? "compressed " : "", name);
  73   gcc_assert (compression_stream == NULL);
  74   if (compress)
  75     compression_stream = lto_start_compression (lto_append_data, NULL);
  76 }
  77
  78
  79 /* End the current output section.  */
  80
  81 void
  82 lto_end_section (void)
  83 {
  84   if (compression_stream)
  85     {
  86       lto_end_compression (compression_stream);
  87       compression_stream = NULL;
  88     }
  89   lang_hooks.lto.end_section ();
  90 }
  91
  92 /* Write SIZE bytes starting at DATA to the assembler.  */
  93
  94 void
  95 lto_write_data (const void *data, unsigned int size)
  96 {
  97   if (compression_stream)
  98     lto_compress_block (compression_stream, (const char *)data, size);
  99   else
 100     lang_hooks.lto.append_data ((const char *)data, size, NULL);
 101 }
 102
 103 /* Write SIZE bytes starting at DATA to the assembler.  */
 104
 105 void
 106 lto_write_raw_data (const void *data, unsigned int size)
 107 {
 108   lang_hooks.lto.append_data ((const char *)data, size, NULL);
 109 }
 110
 111 /* Write all of the chars in OBS to the assembler.  Recycle the blocks
 112    in obs as this is being done.  */
 113
 114 void
 115 lto_write_stream (struct lto_output_stream *obs)
 116 {
 117   unsigned int block_size = 1024;
 118   struct lto_char_ptr_base *block;
 119   struct lto_char_ptr_base *next_block;
 120   if (!obs->first_block)
 121     return;
 122
 123   for (block = obs->first_block; block; block = next_block)
 124     {
 125       const char *base = ((char *)block) + sizeof (struct lto_char_ptr_base);
 126       unsigned int num_chars = block_size - sizeof (struct lto_char_ptr_base);
 127
 128       /* If this is not the last block, it is full.  If it is the last
 129          block, left_in_block indicates how many chars are unoccupied in
 130          this block; subtract from num_chars to obtain occupancy.  */
 131       next_block = (struct lto_char_ptr_base *) block->ptr;
 132       if (!next_block)
 133         num_chars -= obs->left_in_block;
 134
 135       if (compression_stream)
 136         lto_compress_block (compression_stream, base, num_chars);
 137       else
 138         lang_hooks.lto.append_data (base, num_chars, block);
 139       free (block);
 140       block_size *= 2;
 141     }
 142 }
 143
 144
 145 /* Lookup NAME in ENCODER.  If NAME is not found, create a new entry in
 146    ENCODER for NAME with the next available index of ENCODER,  then
 147    print the index to OBS.  True is returned if NAME was added to
 148    ENCODER.  The resulting index is stored in THIS_INDEX.
 149
 150    If OBS is NULL, the only action is to add NAME to the encoder. */
 151
 152 bool
 153 lto_output_decl_index (struct lto_output_stream *obs,
 154                        struct lto_tree_ref_encoder *encoder,
 155                        tree name, unsigned int *this_index)
 156 {
 157   bool new_entry_p = FALSE;
 158   bool existed_p;
 159
 160   unsigned int &index
 161     = encoder->tree_hash_table->get_or_insert (name, &existed_p);
 162   if (!existed_p)
 163     {
 164       index = encoder->trees.length ();
 165       if (streamer_dump_file)
 166         {
 167           print_node_brief (streamer_dump_file, "    Encoding indexable ",
 168                             name, 4);
 169           fprintf (streamer_dump_file, "  as %i \n", index);
 170         }
 171       encoder->trees.safe_push (name);
 172       new_entry_p = TRUE;
 173     }
 174
 175   if (obs)
 176     streamer_write_uhwi_stream (obs, index);
 177   *this_index = index;
 178   return new_entry_p;
 179 }
 180
 181 /* Output a field DECL to OBS.  */
 182
 183 void
 184 lto_output_field_decl_index (struct lto_out_decl_state *decl_state,
 185                              struct lto_output_stream * obs, tree decl)
 186 {
 187   unsigned int index;
 188   lto_output_decl_index (obs, &decl_state->streams[LTO_DECL_STREAM_FIELD_DECL],
 189                          decl, &index);
 190 }
 191
 192 /* Output a function DECL to OBS.  */
 193
 194 void
 195 lto_output_fn_decl_index (struct lto_out_decl_state *decl_state,
 196                           struct lto_output_stream * obs, tree decl)
 197 {
 198   unsigned int index;
 199   lto_output_decl_index (obs, &decl_state->streams[LTO_DECL_STREAM_FN_DECL],
 200                          decl, &index);
 201 }
 202
 203 /* Output a namespace DECL to OBS.  */
 204
 205 void
 206 lto_output_namespace_decl_index (struct lto_out_decl_state *decl_state,
 207                                  struct lto_output_stream * obs, tree decl)
 208 {
 209   unsigned int index;
 210   lto_output_decl_index (obs,
 211                          &decl_state->streams[LTO_DECL_STREAM_NAMESPACE_DECL],
 212                          decl, &index);
 213 }
 214
 215 /* Output a static or extern var DECL to OBS.  */
 216
 217 void
 218 lto_output_var_decl_index (struct lto_out_decl_state *decl_state,
 219                            struct lto_output_stream * obs, tree decl)
 220 {
 221   unsigned int index;
 222   lto_output_decl_index (obs, &decl_state->streams[LTO_DECL_STREAM_VAR_DECL],
 223                          decl, &index);
 224 }
 225
 226 /* Output a type DECL to OBS.  */
 227
 228 void
 229 lto_output_type_decl_index (struct lto_out_decl_state *decl_state,
 230                             struct lto_output_stream * obs, tree decl)
 231 {
 232   unsigned int index;
 233   lto_output_decl_index (obs, &decl_state->streams[LTO_DECL_STREAM_TYPE_DECL],
 234                          decl, &index);
 235 }
 236
 237 /* Output a type REF to OBS.  */
 238
 239 void
 240 lto_output_type_ref_index (struct lto_out_decl_state *decl_state,
 241                            struct lto_output_stream *obs, tree ref)
 242 {
 243   unsigned int index;
 244   lto_output_decl_index (obs, &decl_state->streams[LTO_DECL_STREAM_TYPE],
 245                          ref, &index);
 246 }
 247
 248
 249 /* Create the output block and return it.  */
 250
 251 struct lto_simple_output_block *
 252 lto_create_simple_output_block (enum lto_section_type section_type)
 253 {
 254   struct lto_simple_output_block *ob
 255     = ((struct lto_simple_output_block *)
 256        xcalloc (1, sizeof (struct lto_simple_output_block)));
 257
 258   ob->section_type = section_type;
 259   ob->decl_state = lto_get_out_decl_state ();
 260   ob->main_stream = ((struct lto_output_stream *)
 261                      xcalloc (1, sizeof (struct lto_output_stream)));
 262
 263   return ob;
 264 }
 265
 266
 267 /* Produce a simple section for one of the ipa passes.  */
 268
 269 void
 270 lto_destroy_simple_output_block (struct lto_simple_output_block *ob)
 271 {
 272   char *section_name;
 273   struct lto_simple_header header;
 274
 275   section_name = lto_get_section_name (ob->section_type, NULL, NULL);
 276   lto_begin_section (section_name, !flag_wpa);
 277   free (section_name);
 278
 279   /* Write the header which says how to decode the pieces of the
 280      t.  */
 281   memset (&header, 0, sizeof (struct lto_simple_header));
 282   header.major_version = LTO_major_version;
 283   header.minor_version = LTO_minor_version;
 284   header.main_size = ob->main_stream->total_size;
 285   lto_write_data (&header, sizeof header);
 286
 287   lto_write_stream (ob->main_stream);
 288
 289   /* Put back the assembly section that was there before we started
 290      writing lto info.  */
 291   lto_end_section ();
 292
 293   free (ob->main_stream);
 294   free (ob);
 295 }
 296
 297
 298 /* Return a new lto_out_decl_state. */
 299
 300 struct lto_out_decl_state *
 301 lto_new_out_decl_state (void)
 302 {
 303   struct lto_out_decl_state *state = XCNEW (struct lto_out_decl_state);
 304   int i;
 305
 306   for (i = 0; i < LTO_N_DECL_STREAMS; i++)
 307     lto_init_tree_ref_encoder (&state->streams[i]);
 308
 309   /* At WPA time we do not compress sections by default.  */
 310   state->compressed = !flag_wpa;
 311
 312   return state;
 313 }
 314
 315
 316 /* Delete STATE and components.  */
 317
 318 void
 319 lto_delete_out_decl_state (struct lto_out_decl_state *state)
 320 {
 321   int i;
 322
 323   for (i = 0; i < LTO_N_DECL_STREAMS; i++)
 324     lto_destroy_tree_ref_encoder (&state->streams[i]);
 325
 326   free (state);
 327 }
 328
 329
 330 /* Get the currently used lto_out_decl_state structure. */
 331
 332 struct lto_out_decl_state *
 333 lto_get_out_decl_state (void)
 334 {
 335   return decl_state_stack.last ();
 336 }
 337
 338 /* Push STATE to top of out decl stack. */
 339
 340 void
 341 lto_push_out_decl_state (struct lto_out_decl_state *state)
 342 {
 343   decl_state_stack.safe_push (state);
 344 }
 345
 346 /* Pop the currently used out-decl state from top of stack. */
 347
 348 struct lto_out_decl_state *
 349 lto_pop_out_decl_state (void)
 350 {
 351   return decl_state_stack.pop ();
 352 }
 353
 354 /* Record STATE after it has been used in serializing the body of
 355    FN_DECL.  STATE should no longer be used by the caller.  The ownership
 356    of it is taken over from this point.  */
 357
 358 void
 359 lto_record_function_out_decl_state (tree fn_decl,
 360                                     struct lto_out_decl_state *state)
 361 {
 362   int i;
 363
 364   /* Strip all hash tables to save some memory. */
 365   for (i = 0; i < LTO_N_DECL_STREAMS; i++)
 366     if (state->streams[i].tree_hash_table)
 367       {
 368         delete state->streams[i].tree_hash_table;
 369         state->streams[i].tree_hash_table = NULL;
 370       }
 371   state->fn_decl = fn_decl;
 372   lto_function_decl_states.safe_push (state);
 373 }