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