gcc/lto-opts.c

   1 /* LTO IL options.
   2
   3    Copyright (C) 2009-2014 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 "predict.h"
  27 #include "vec.h"
  28 #include "hashtab.h"
  29 #include "hash-set.h"
  30 #include "machmode.h"
  31 #include "tm.h"
  32 #include "hard-reg-set.h"
  33 #include "input.h"
  34 #include "function.h"
  35 #include "basic-block.h"
  36 #include "tree-ssa-alias.h"
  37 #include "internal-fn.h"
  38 #include "gimple-expr.h"
  39 #include "is-a.h"
  40 #include "gimple.h"
  41 #include "bitmap.h"
  42 #include "flags.h"
  43 #include "opts.h"
  44 #include "options.h"
  45 #include "common/common-target.h"
  46 #include "diagnostic.h"
  47 #include "hash-map.h"
  48 #include "plugin-api.h"
  49 #include "ipa-ref.h"
  50 #include "cgraph.h"
  51 #include "lto-streamer.h"
  52 #include "lto-section-names.h"
  53 #include "toplev.h"
  54
  55 /* Append the option piece OPT to the COLLECT_GCC_OPTIONS string
  56    set up by OB, appropriately quoted and separated by spaces
  57    (if !*FIRST_P).  */
  58
  59 static void
  60 append_to_collect_gcc_options (struct obstack *ob,
  61                                bool *first_p, const char *opt)
  62 {
  63   const char *p, *q = opt;
  64   if (!*first_p)
  65     obstack_grow (ob, " ", 1);
  66   obstack_grow (ob, "'", 1);
  67   while ((p = strchr (q, '\'')))
  68     {
  69       obstack_grow (ob, q, p - q);
  70       obstack_grow (ob, "'\\''", 4);
  71       q = ++p;
  72     }
  73   obstack_grow (ob, q, strlen (q));
  74   obstack_grow (ob, "'", 1);
  75   *first_p = false;
  76 }
  77
  78 /* Write currently held options to an LTO IL section.  */
  79
  80 void
  81 lto_write_options (void)
  82 {
  83   char *section_name;
  84   struct obstack temporary_obstack;
  85   unsigned int i, j;
  86   char *args;
  87   bool first_p = true;
  88
  89   section_name = lto_get_section_name (LTO_section_opts, NULL, NULL);
  90   lto_begin_section (section_name, false);
  91
  92   obstack_init (&temporary_obstack);
  93
  94   /* Output options that affect GIMPLE IL semantics and are implicitly
  95      enabled by the frontend.
  96      This for now includes an explicit set of options that we also handle
  97      explicitly in lto-wrapper.c.  In the end the effects on GIMPLE IL
  98      semantics should be explicitely encoded in the IL or saved per
  99      function rather than per compilation unit.  */
 100   /* -fexceptions causes the EH machinery to be initialized, enabling
 101      generation of unwind data so that explicit throw() calls work.  */
 102   if (!global_options_set.x_flag_exceptions
 103       && global_options.x_flag_exceptions)
 104     append_to_collect_gcc_options (&temporary_obstack, &first_p,
 105                                    "-fexceptions");
 106   /* -fnon-call-exceptions changes the generation of exception
 107       regions.  It is enabled implicitly by the Go frontend.  */
 108   if (!global_options_set.x_flag_non_call_exceptions
 109       && global_options.x_flag_non_call_exceptions)
 110     append_to_collect_gcc_options (&temporary_obstack, &first_p,
 111                                    "-fnon-call-exceptions");
 112   /* The default -ffp-contract changes depending on the language
 113      standard.  Pass thru conservative standard settings.  */
 114   if (!global_options_set.x_flag_fp_contract_mode)
 115     switch (global_options.x_flag_fp_contract_mode)
 116       {
 117       case FP_CONTRACT_OFF:
 118         append_to_collect_gcc_options (&temporary_obstack, &first_p,
 119                                        "-ffp-contract=off");
 120         break;
 121       case FP_CONTRACT_ON:
 122         append_to_collect_gcc_options (&temporary_obstack, &first_p,
 123                                        "-ffp-contract=on");
 124         break;
 125       case FP_CONTRACT_FAST:
 126         /* Nothing.  That merges conservatively and is the default for LTO.  */
 127         break;
 128       default:
 129         gcc_unreachable ();
 130       }
 131   /* The default -fmath-errno, -fsigned-zeros and -ftrapping-math change
 132      depending on the language (they can be disabled by the Ada and Java
 133      front-ends).  Pass thru conservative standard settings.  */
 134   if (!global_options_set.x_flag_errno_math)
 135     append_to_collect_gcc_options (&temporary_obstack, &first_p,
 136                                    global_options.x_flag_errno_math
 137                                    ? "-fmath-errno"
 138                                    : "-fno-math-errno");
 139   if (!global_options_set.x_flag_signed_zeros)
 140     append_to_collect_gcc_options (&temporary_obstack, &first_p,
 141                                    global_options.x_flag_signed_zeros
 142                                    ? "-fsigned-zeros"
 143                                    : "-fno-signed-zeros");
 144   if (!global_options_set.x_flag_trapping_math)
 145     append_to_collect_gcc_options (&temporary_obstack, &first_p,
 146                                    global_options.x_flag_trapping_math
 147                                    ? "-ftrapping-math"
 148                                    : "-fno-trapping-math");
 149   /* We need to merge -f[no-]strict-overflow, -f[no-]wrapv and -f[no-]trapv
 150      conservatively, so stream out their defaults.  */
 151   if (!global_options_set.x_flag_wrapv
 152       && global_options.x_flag_wrapv)
 153     append_to_collect_gcc_options (&temporary_obstack, &first_p, "-fwrapv");
 154   if (!global_options_set.x_flag_trapv
 155       && !global_options.x_flag_trapv)
 156     append_to_collect_gcc_options (&temporary_obstack, &first_p, "-fno-trapv");
 157   if (!global_options_set.x_flag_strict_overflow
 158       && !global_options.x_flag_strict_overflow)
 159     append_to_collect_gcc_options (&temporary_obstack, &first_p,
 160                                "-fno-strict-overflow");
 161
 162   /* Append options from target hook and store them to offload_lto section.  */
 163   if (strcmp (section_name_prefix, OFFLOAD_SECTION_NAME_PREFIX) == 0)
 164     {
 165       char *offload_opts = targetm.offload_options ();
 166       char *offload_ptr = offload_opts;
 167       while (offload_ptr)
 168        {
 169          char *next = strchr (offload_ptr, ' ');
 170          if (next)
 171            *next++ = '\0';
 172          append_to_collect_gcc_options (&temporary_obstack, &first_p,
 173                                         offload_ptr);
 174          offload_ptr = next;
 175        }
 176       free (offload_opts);
 177     }
 178
 179   /* Output explicitly passed options.  */
 180   for (i = 1; i < save_decoded_options_count; ++i)
 181     {
 182       struct cl_decoded_option *option = &save_decoded_options[i];
 183
 184       /* Skip explicitly some common options that we do not need.  */
 185       switch (option->opt_index)
 186       {
 187         case OPT_dumpbase:
 188         case OPT_SPECIAL_unknown:
 189         case OPT_SPECIAL_ignore:
 190         case OPT_SPECIAL_program_name:
 191         case OPT_SPECIAL_input_file:
 192           continue;
 193
 194         default:
 195           break;
 196       }
 197
 198       /* Skip frontend and driver specific options here.  */
 199       if (!(cl_options[option->opt_index].flags & (CL_COMMON|CL_TARGET|CL_LTO)))
 200         continue;
 201
 202       /* Do not store target-specific options in offload_lto section.  */
 203       if ((cl_options[option->opt_index].flags & CL_TARGET)
 204          && strcmp (section_name_prefix, OFFLOAD_SECTION_NAME_PREFIX) == 0)
 205        continue;
 206
 207       /* Drop options created from the gcc driver that will be rejected
 208          when passed on to the driver again.  */
 209       if (cl_options[option->opt_index].cl_reject_driver)
 210         continue;
 211
 212       /* Also drop all options that are handled by the driver as well,
 213          which includes things like -o and -v or -fhelp for example.
 214          We do not need those.  The only exception is -foffload option, if we
 215          write it in offload_lto section.  Also drop all diagnostic options.  */
 216       if ((cl_options[option->opt_index].flags & (CL_DRIVER|CL_WARNING))
 217           && (strcmp (section_name_prefix, OFFLOAD_SECTION_NAME_PREFIX) != 0
 218               || option->opt_index != OPT_foffload_))
 219         continue;
 220
 221       for (j = 0; j < option->canonical_option_num_elements; ++j)
 222         append_to_collect_gcc_options (&temporary_obstack, &first_p,
 223                                        option->canonical_option[j]);
 224     }
 225   obstack_grow (&temporary_obstack, "\0", 1);
 226   args = XOBFINISH (&temporary_obstack, char *);
 227   lto_write_data (args, strlen (args) + 1);
 228   lto_end_section ();
 229
 230   obstack_free (&temporary_obstack, NULL);
 231   free (section_name);
 232 }