gcc/lto-opts.c

   1 /* LTO IL options.
   2
   3    Copyright 2009, 2010, 2011 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 "common/common-target.h"
  34 #include "diagnostic.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_EACH_VEC_ELT (opt_t, *opts_p, i, o)
 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 /* Return a string from IB.  The string is allocated, and the caller is
 166    responsible for freeing it.  */
 167
 168 static char *
 169 input_string_block (struct lto_input_block *ib)
 170 {
 171   bool flag;
 172
 173   lto_input_data_block (ib, &flag, sizeof (flag));
 174   if (flag)
 175     {
 176       size_t length;
 177       char *string;
 178
 179       lto_input_data_block (ib, &length, sizeof (length));
 180       string = (char *) xcalloc (1, length + 1);
 181       lto_input_data_block (ib, string, length);
 182
 183       return string;
 184     }
 185   else
 186     return NULL;
 187 }
 188
 189 /* Return true if this option is one we need to save in LTO output files.
 190    At present, we pass along all target options, and common options that
 191    involve position independent code.
 192
 193    TODO This list of options requires expansion and rationalization.
 194    Among others, optimization options may well be appropriate here.  */
 195
 196 static bool
 197 register_user_option_p (size_t code, unsigned int type)
 198 {
 199   if (type == CL_TARGET)
 200     return true;
 201   else if (type == CL_COMMON)
 202     {
 203       return (code == OPT_fPIC
 204               || code == OPT_fpic
 205               || code == OPT_fPIE
 206               || code == OPT_fpie
 207               || code == OPT_fcommon
 208               || code == OPT_fexceptions);
 209     }
 210
 211   return false;
 212 }
 213
 214 /* Note command line option with the given TYPE and CODE, ARG, and VALUE.
 215    If relevant to LTO, save it in the user options vector.  */
 216
 217 void
 218 lto_register_user_option (size_t code, const char *arg, int value,
 219                           unsigned int type)
 220 {
 221   if (register_user_option_p (code, type))
 222     {
 223       opt_t o;
 224
 225       o.type = type;
 226       o.code = code;
 227       if (arg != NULL)
 228         {
 229           o.arg = (char *) xmalloc (strlen (arg) + 1);
 230           strcpy (o.arg, arg);
 231         }
 232       else
 233         o.arg = NULL;
 234       o.value = value;
 235       VEC_safe_push (opt_t, heap, user_options, &o);
 236     }
 237 }
 238
 239 /* Empty the saved user options vector.  */
 240
 241 void
 242 lto_clear_user_options (void)
 243 {
 244   clear_options (&user_options);
 245 }
 246
 247 /* Empty the saved file options vector.  */
 248
 249 void
 250 lto_clear_file_options (void)
 251 {
 252   clear_options (&file_options);
 253 }
 254
 255 /* Concatenate the user options and any file options read from an LTO IL
 256    file, and serialize them to STREAM.  File options precede user options
 257    so that the latter override the former when reissued.  */
 258
 259 static void
 260 output_options (struct lto_output_stream *stream)
 261 {
 262   VEC(opt_t, heap) *opts = concatenate_options (file_options, user_options);
 263   const size_t length = VEC_length (opt_t, opts);
 264   int i;
 265   opt_t *o;
 266
 267   output_data_stream (stream, &length, sizeof (length));
 268
 269   FOR_EACH_VEC_ELT (opt_t, opts, i, o)
 270     {
 271       output_data_stream (stream, &o->type, sizeof (o->type));
 272       output_data_stream (stream, &o->code, sizeof (o->code));
 273       output_string_stream (stream, o->arg);
 274       output_data_stream (stream, &o->value, sizeof (o->value));
 275     }
 276
 277   VEC_free (opt_t, heap, opts);
 278 }
 279
 280 /* Write currently held options to an LTO IL section.  */
 281
 282 void
 283 lto_write_options (void)
 284 {
 285   char *const section_name = lto_get_section_name (LTO_section_opts, NULL, NULL);
 286   struct lto_output_stream stream;
 287   struct lto_simple_header header;
 288   struct lto_output_stream *header_stream;
 289
 290   /* Targets and languages can provide defaults for -fexceptions but
 291      we only process user options from the command-line.  Until we
 292      serialize out a white list of options from the new global state
 293      explicitly append important options as user options here.  */
 294   if (flag_exceptions)
 295     lto_register_user_option (OPT_fexceptions, NULL, 1, CL_COMMON);
 296
 297   lto_begin_section (section_name, !flag_wpa);
 298   free (section_name);
 299
 300   memset (&stream, 0, sizeof (stream));
 301   output_options (&stream);
 302
 303   memset (&header, 0, sizeof (header));
 304   header.lto_header.major_version = LTO_major_version;
 305   header.lto_header.minor_version = LTO_minor_version;
 306   header.lto_header.section_type = LTO_section_opts;
 307
 308   header.compressed_size = 0;
 309   header.main_size = stream.total_size;
 310
 311   header_stream = ((struct lto_output_stream *)
 312                    xcalloc (1, sizeof (*header_stream)));
 313   lto_output_data_stream (header_stream, &header, sizeof (header));
 314   lto_write_stream (header_stream);
 315   free (header_stream);
 316
 317   lto_write_stream (&stream);
 318   lto_end_section ();
 319 }
 320
 321 /* Unserialize an options vector from IB, and append to file_options.  */
 322
 323 static void
 324 input_options (struct lto_input_block *ib)
 325 {
 326   size_t length, i;
 327
 328   lto_input_data_block (ib, &length, sizeof (length));
 329
 330   for (i = 0; i < length; i++)
 331     {
 332       opt_t o;
 333
 334       lto_input_data_block (ib, &o.type, sizeof (o.type));
 335       lto_input_data_block (ib, &o.code, sizeof (o.code));
 336       o.arg = input_string_block (ib);
 337       lto_input_data_block (ib, &o.value, sizeof (o.value));
 338       VEC_safe_push (opt_t, heap, file_options, &o);
 339     }
 340 }
 341
 342 /* Read options from an LTO IL section.  */
 343
 344 void
 345 lto_read_file_options (struct lto_file_decl_data *file_data)
 346 {
 347   size_t len, l, skip;
 348   const char *data, *p;
 349   const struct lto_simple_header *header;
 350   int32_t opts_offset;
 351   struct lto_input_block ib;
 352
 353   data = lto_get_section_data (file_data, LTO_section_opts, NULL, &len);
 354   if (!data)
 355           return;
 356
 357   /* Option could be multiple sections merged (through ld -r)
 358      Keep reading all options.  This is ok right now because
 359      the options just get mashed together anyways.
 360      This will have to be done differently once lto-opts knows
 361      how to associate options with different files. */
 362   l = len;
 363   p = data;
 364   do
 365     {
 366       header = (const struct lto_simple_header *) p;
 367       opts_offset = sizeof (*header);
 368
 369       lto_check_version (header->lto_header.major_version,
 370                          header->lto_header.minor_version);
 371
 372       LTO_INIT_INPUT_BLOCK (ib, p + opts_offset, 0, header->main_size);
 373       input_options (&ib);
 374
 375       skip = header->main_size + opts_offset;
 376       l -= skip;
 377       p += skip;
 378     }
 379   while (l > 0);
 380
 381   lto_free_section_data (file_data, LTO_section_opts, 0, data, len);
 382 }
 383
 384 /* Concatenate the user options and any file options read from an LTO IL
 385    file, and reissue them as if all had just been read in from the command
 386    line.  As with serialization, file options precede user options.  */
 387
 388 void
 389 lto_reissue_options (void)
 390 {
 391   VEC(opt_t, heap) *opts = concatenate_options (file_options, user_options);
 392   int i;
 393   opt_t *o;
 394
 395   FOR_EACH_VEC_ELT (opt_t, opts, i, o)
 396     {
 397       void *flag_var = option_flag_var (o->code, &global_options);
 398
 399       if (flag_var)
 400         set_option (&global_options, &global_options_set,
 401                     o->code, o->value, o->arg,
 402                     DK_UNSPECIFIED, UNKNOWN_LOCATION, global_dc);
 403
 404       if (o->type == CL_TARGET)
 405         {
 406           struct cl_decoded_option decoded;
 407           generate_option (o->code, o->arg, o->value, CL_TARGET, &decoded);
 408           targetm_common.handle_option (&global_options, &global_options_set,
 409                                         &decoded, UNKNOWN_LOCATION);
 410         }
 411       else if (o->type == CL_COMMON)
 412         gcc_assert (flag_var);
 413       else
 414         gcc_unreachable ();
 415     }
 416
 417   /* Flag_shlib is usually set by finish_options, but we are issuing flag_pic
 418      too late.  */
 419   if (flag_pic && !flag_pie)
 420     flag_shlib = 1;
 421   VEC_free (opt_t, heap, opts);
 422 }