gcc/lto-opts.c

   1 /* LTO IL options.
   2
   3    Copyright 2009 Free Software Foundation, Inc.
   4    Contributed by Simon Baldwin <simonb@google.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 "tree.h"
  26 #include "hashtab.h"
  27 #include "ggc.h"
  28 #include "vec.h"
  29 #include "bitmap.h"
  30 #include "flags.h"
  31 #include "opts.h"
  32 #include "options.h"
  33 #include "target.h"
  34 #include "toplev.h"
  35 #include "lto-streamer.h"
  36
  37 /* When a file is initially compiled, the options used when generating
  38    the IL are not necessarily the same as those used when linking the
  39    objects into the final executable.  In general, most build systems
  40    will proceed with something along the lines of:
  41
  42         $ gcc <cc-flags> -flto -c f1.c -o f1.o
  43         $ gcc <cc-flags> -flto -c f2.c -o f2.o
  44         ...
  45         $ gcc <cc-flags> -flto -c fN.c -o fN.o
  46
  47    And the final link may or may not include the same <cc-flags> used
  48    to generate the initial object files:
  49
  50         $ gcc <ld-flags> -flto -o prog f1.o ... fN.o
  51
  52    Since we will be generating final code during the link step, some
  53    of the flags used during the compile step need to be re-applied
  54    during the link step.  For instance, flags in the -m family.
  55
  56    The idea is to save a selected set of <cc-flags> in a special
  57    section of the initial object files.  This section is then read
  58    during linking and the options re-applied.
  59
  60    FIXME lto.  Currently the scheme is limited in that only the
  61    options saved on the first object file (f1.o) are read back during
  62    the link step.  This means that the options used to compile f1.o
  63    will be applied to ALL the object files in the final link step.
  64    More work needs to be done to implement a merging and validation
  65    mechanism, as this will not be enough for all cases.  */
  66
  67 /* Saved options hold the type of the option (currently CL_TARGET or
  68    CL_COMMON), and the code, argument, and value.  */
  69
  70 typedef struct GTY(()) opt_d
  71 {
  72   unsigned int type;
  73   size_t code;
  74   char *arg;
  75   int value;
  76 } opt_t;
  77
  78 DEF_VEC_O (opt_t);
  79 DEF_VEC_ALLOC_O (opt_t, heap);
  80
  81
  82 /* Options are held in two vectors, one for those registered by
  83    command line handling code, and the other for those read in from
  84    any LTO IL input.  */
  85 static VEC(opt_t, heap) *user_options = NULL;
  86 static VEC(opt_t, heap) *file_options = NULL;
  87
  88 /* Iterate FROM in reverse, writing option codes not yet in CODES into *TO.
  89    Mark each new option code encountered in CODES.  */
  90
  91 static void
  92 reverse_iterate_options (VEC(opt_t, heap) *from, VEC(opt_t, heap) **to,
  93                          bitmap codes)
  94 {
  95   int i;
  96
  97   for (i = VEC_length (opt_t, from); i > 0; i--)
  98     {
  99       const opt_t *const o = VEC_index (opt_t, from, i - 1);
 100
 101       if (bitmap_set_bit (codes, o->code))
 102         VEC_safe_push (opt_t, heap, *to, o);
 103     }
 104 }
 105
 106 /* Concatenate options vectors FIRST and SECOND, rationalize so that only the
 107    final of any given option remains, and return the result.  */
 108
 109 static VEC(opt_t, heap) *
 110 concatenate_options (VEC(opt_t, heap) *first, VEC(opt_t, heap) *second)
 111 {
 112   VEC(opt_t, heap) *results = NULL;
 113   bitmap codes = lto_bitmap_alloc ();
 114
 115   reverse_iterate_options (second, &results, codes);
 116   reverse_iterate_options (first, &results, codes);
 117
 118   lto_bitmap_free (codes);
 119   return results;
 120 }
 121
 122 /* Clear the options vector in *OPTS_P and set it to NULL.  */
 123
 124 static void
 125 clear_options (VEC(opt_t, heap) **opts_p)
 126 {
 127   int i;
 128   opt_t *o;
 129
 130   for (i = 0; VEC_iterate (opt_t, *opts_p, i, o); i++)
 131     free (o->arg);
 132
 133   VEC_free (opt_t, heap, *opts_p);
 134 }
 135
 136 /* Write LENGTH bytes from ADDR to STREAM.  */
 137
 138 static void
 139 output_data_stream (struct lto_output_stream *stream,
 140                     const void *addr, size_t length)
 141 {
 142   lto_output_data_stream (stream, addr, length);
 143 }
 144
 145 /* Write string STRING to STREAM.  */
 146
 147 static void
 148 output_string_stream (struct lto_output_stream *stream, const char *string)
 149 {
 150   bool flag = false;
 151
 152   if (string != NULL)
 153     {
 154       const size_t length = strlen (string);
 155
 156       flag = true;
 157       output_data_stream (stream, &flag, sizeof (flag));
 158       output_data_stream (stream, &length, sizeof (length));
 159       output_data_stream (stream, string, length);
 160     }
 161   else
 162     output_data_stream (stream, &flag, sizeof (flag));
 163 }
 164
 165 /* Read LENGTH bytes from STREAM to ADDR.  */
 166
 167 static void
 168 input_data_block (struct lto_input_block *ib, void *addr, size_t length)
 169 {
 170   size_t i;
 171   unsigned char *const buffer = (unsigned char *const) addr;
 172
 173   for (i = 0; i < length; i++)
 174     buffer[i] = lto_input_1_unsigned (ib);
 175 }
 176
 177 /* Return a string from IB.  The string is allocated, and the caller is
 178    responsible for freeing it.  */
 179
 180 static char *
 181 input_string_block (struct lto_input_block *ib)
 182 {
 183   bool flag;
 184
 185   input_data_block (ib, &flag, sizeof (flag));
 186   if (flag)
 187     {
 188       size_t length;
 189       char *string;
 190
 191       input_data_block (ib, &length, sizeof (length));
 192       string = (char *) xcalloc (1, length + 1);
 193       input_data_block (ib, string, length);
 194
 195       return string;
 196     }
 197   else
 198     return NULL;
 199 }
 200
 201 /* Return true if this option is one we need to save in LTO output files.
 202    At present, we pass along all target options, and common options that
 203    involve position independent code.
 204
 205    TODO This list of options requires expansion and rationalization.
 206    Among others, optimization options may well be appropriate here.  */
 207
 208 static bool
 209 register_user_option_p (size_t code, int type)
 210 {
 211   return type == CL_TARGET
 212          || (type == CL_COMMON
 213              && (code == OPT_fPIC
 214                  || code == OPT_fcommon));
 215 }
 216
 217 /* Note command line option with the given TYPE and CODE, ARG, and VALUE.
 218    If relevant to LTO, save it in the user options vector.  */
 219
 220 void
 221 lto_register_user_option (size_t code, const char *arg, int value, int type)
 222 {
 223   if (register_user_option_p (code, type))
 224     {
 225       opt_t o;
 226
 227       o.type = type;
 228       o.code = code;
 229       if (arg != NULL)
 230         {
 231           o.arg = (char *) xmalloc (strlen (arg) + 1);
 232           strcpy (o.arg, arg);
 233         }
 234       else
 235         o.arg = NULL;
 236       o.value = value;
 237       VEC_safe_push (opt_t, heap, user_options, &o);
 238     }
 239 }
 240
 241 /* Empty the saved user options vector.  */
 242
 243 void
 244 lto_clear_user_options (void)
 245 {
 246   clear_options (&user_options);
 247 }
 248
 249 /* Empty the saved file options vector.  */
 250
 251 void
 252 lto_clear_file_options (void)
 253 {
 254   clear_options (&file_options);
 255 }
 256
 257 /* Concatenate the user options and any file options read from an LTO IL
 258    file, and serialize them to STREAM.  File options precede user options
 259    so that the latter override the former when reissued.  */
 260
 261 static void
 262 output_options (struct lto_output_stream *stream)
 263 {
 264   VEC(opt_t, heap) *opts = concatenate_options (file_options, user_options);
 265   const size_t length = VEC_length (opt_t, opts);
 266   int i;
 267   opt_t *o;
 268
 269   output_data_stream (stream, &length, sizeof (length));
 270
 271   for (i = 0; VEC_iterate (opt_t, opts, i, o); i++)
 272     {
 273       output_data_stream (stream, &o->type, sizeof (o->type));
 274       output_data_stream (stream, &o->code, sizeof (o->code));
 275       output_string_stream (stream, o->arg);
 276       output_data_stream (stream, &o->value, sizeof (o->value));
 277     }
 278
 279   VEC_free (opt_t, heap, opts);
 280 }
 281
 282 /* Write currently held options to an LTO IL section.  */
 283
 284 void
 285 lto_write_options (void)
 286 {
 287   char *const section_name = lto_get_section_name (LTO_section_opts, NULL);
 288   struct lto_output_stream stream;
 289   struct lto_simple_header header;
 290   struct lto_output_stream *header_stream;
 291
 292   lto_begin_section (section_name, !flag_wpa);
 293   free (section_name);
 294
 295   memset (&stream, 0, sizeof (stream));
 296   output_options (&stream);
 297
 298   memset (&header, 0, sizeof (header));
 299   header.lto_header.major_version = LTO_major_version;
 300   header.lto_header.minor_version = LTO_minor_version;
 301   header.lto_header.section_type = LTO_section_opts;
 302
 303   header.compressed_size = 0;
 304   header.main_size = stream.total_size;
 305
 306   header_stream = ((struct lto_output_stream *)
 307                    xcalloc (1, sizeof (*header_stream)));
 308   lto_output_data_stream (header_stream, &header, sizeof (header));
 309   lto_write_stream (header_stream);
 310   free (header_stream);
 311
 312   lto_write_stream (&stream);
 313   lto_end_section ();
 314 }
 315
 316 /* Unserialize an options vector from IB, and append to file_options.  */
 317
 318 static void
 319 input_options (struct lto_input_block *ib)
 320 {
 321   size_t length, i;
 322
 323   input_data_block (ib, &length, sizeof (length));
 324
 325   for (i = 0; i < length; i++)
 326     {
 327       opt_t o;
 328
 329       input_data_block (ib, &o.type, sizeof (o.type));
 330       input_data_block (ib, &o.code, sizeof (o.code));
 331       o.arg = input_string_block (ib);
 332       input_data_block (ib, &o.value, sizeof (o.value));
 333       VEC_safe_push (opt_t, heap, file_options, &o);
 334     }
 335 }
 336
 337 /* Read options from an LTO IL section.  */
 338
 339 void
 340 lto_read_file_options (struct lto_file_decl_data *file_data)
 341 {
 342   size_t len;
 343   const char *data;
 344   const struct lto_simple_header *header;
 345   int32_t opts_offset;
 346   struct lto_input_block ib;
 347
 348   data = lto_get_section_data (file_data, LTO_section_opts, NULL, &len);
 349   header = (const struct lto_simple_header *) data;
 350   opts_offset = sizeof (*header);
 351
 352   lto_check_version (header->lto_header.major_version,
 353                      header->lto_header.minor_version);
 354
 355   LTO_INIT_INPUT_BLOCK (ib, data + opts_offset, 0, header->main_size);
 356   input_options (&ib);
 357
 358   lto_free_section_data (file_data, LTO_section_opts, 0, data, len);
 359 }
 360
 361 /* Re-handle option with type TYPE and CODE, ARG, and VALUE.  Logic extracted
 362    from common_handle_option() in opts.c.
 363
 364    FIXME lto. This section is not complete.  If extended to handle
 365    optimization options, note that changing these after opts.c prescan may
 366    involve also adjusting other options that were defaulted from initial
 367    optimization option values.  */
 368
 369 static void
 370 handle_common_option (size_t code, const char *arg ATTRIBUTE_UNUSED, int value)
 371 {
 372   switch (code)
 373     {
 374     case OPT_fPIC:
 375       flag_pic = !!value;
 376       break;
 377
 378     case OPT_fcommon:
 379       flag_no_common = !value;
 380       break;
 381
 382     default:
 383       gcc_unreachable ();
 384     }
 385 }
 386
 387 /* Concatenate the user options and any file options read from an LTO IL
 388    file, and reissue them as if all had just been read in from the command
 389    line.  As with serialization, file options precede user options.  */
 390
 391 void
 392 lto_reissue_options (void)
 393 {
 394   VEC(opt_t, heap) *opts = concatenate_options (file_options, user_options);
 395   int i;
 396   opt_t *o;
 397
 398   for (i = 0; VEC_iterate (opt_t, opts, i, o); i++)
 399     {
 400       if (o->type == CL_TARGET)
 401         targetm.handle_option (o->code, o->arg, o->value);
 402       else if (o->type == CL_COMMON)
 403         handle_common_option (o->code, o->arg, o->value);
 404       else
 405         gcc_unreachable ();
 406     }
 407
 408   VEC_free (opt_t, heap, opts);
 409 }