gcc/opts-global.c

   1 /* Command line option handling.  Code involving global state that
   2    should not be shared with the driver.
   3    Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
   4    Free Software Foundation, Inc.
   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 "diagnostic.h"
  26 #include "opts.h"
  27 #include "flags.h"
  28 #include "ggc.h"
  29 #include "tree.h" /* Required by langhooks.h.  */
  30 #include "langhooks.h"
  31 #include "tm.h" /* Required by rtl.h.  */
  32 #include "rtl.h"
  33 #include "dbgcnt.h"
  34 #include "debug.h"
  35 #include "lto-streamer.h"
  36 #include "output.h"
  37 #include "plugin.h"
  38 #include "toplev.h"
  39 #include "tree-pass.h"
  40
  41 typedef const char *const_char_p; /* For DEF_VEC_P.  */
  42 DEF_VEC_P(const_char_p);
  43 DEF_VEC_ALLOC_P(const_char_p,heap);
  44
  45 static VEC(const_char_p,heap) *ignored_options;
  46
  47 /* Input file names.  */
  48 const char **in_fnames;
  49 unsigned num_in_fnames;
  50
  51 /* Return a malloced slash-separated list of languages in MASK.  */
  52
  53 static char *
  54 write_langs (unsigned int mask)
  55 {
  56   unsigned int n = 0, len = 0;
  57   const char *lang_name;
  58   char *result;
  59
  60   for (n = 0; (lang_name = lang_names[n]) != 0; n++)
  61     if (mask & (1U << n))
  62       len += strlen (lang_name) + 1;
  63
  64   result = XNEWVEC (char, len);
  65   len = 0;
  66   for (n = 0; (lang_name = lang_names[n]) != 0; n++)
  67     if (mask & (1U << n))
  68       {
  69         if (len)
  70           result[len++] = '/';
  71         strcpy (result + len, lang_name);
  72         len += strlen (lang_name);
  73       }
  74
  75   result[len] = 0;
  76
  77   return result;
  78 }
  79
  80 /* Complain that switch DECODED does not apply to this front end (mask
  81    LANG_MASK).  */
  82
  83 static void
  84 complain_wrong_lang (const struct cl_decoded_option *decoded,
  85                      unsigned int lang_mask)
  86 {
  87   const struct cl_option *option = &cl_options[decoded->opt_index];
  88   const char *text = decoded->orig_option_with_args_text;
  89   char *ok_langs = NULL, *bad_lang = NULL;
  90   unsigned int opt_flags = option->flags;
  91
  92   if (!lang_hooks.complain_wrong_lang_p (option))
  93     return;
  94
  95   opt_flags &= ((1U << cl_lang_count) - 1) | CL_DRIVER;
  96   if (opt_flags != CL_DRIVER)
  97     ok_langs = write_langs (opt_flags);
  98   if (lang_mask != CL_DRIVER)
  99     bad_lang = write_langs (lang_mask);
 100
 101   if (opt_flags == CL_DRIVER)
 102     error ("command line option %qs is valid for the driver but not for %s",
 103            text, bad_lang);
 104   else if (lang_mask == CL_DRIVER)
 105     gcc_unreachable ();
 106   else
 107     /* Eventually this should become a hard error IMO.  */
 108     warning (0, "command line option %qs is valid for %s but not for %s",
 109              text, ok_langs, bad_lang);
 110
 111   free (ok_langs);
 112   free (bad_lang);
 113 }
 114
 115 /* Buffer the unknown option described by the string OPT.  Currently,
 116    we only complain about unknown -Wno-* options if they may have
 117    prevented a diagnostic. Otherwise, we just ignore them.  Note that
 118    if we do complain, it is only as a warning, not an error; passing
 119    the compiler an unrecognised -Wno-* option should never change
 120    whether the compilation succeeds or fails.  */
 121
 122 static void
 123 postpone_unknown_option_warning (const char *opt)
 124 {
 125   VEC_safe_push (const_char_p, heap, ignored_options, opt);
 126 }
 127
 128 /* Produce a warning for each option previously buffered.  */
 129
 130 void
 131 print_ignored_options (void)
 132 {
 133   while (!VEC_empty (const_char_p, ignored_options))
 134     {
 135       const char *opt;
 136
 137       opt = VEC_pop (const_char_p, ignored_options);
 138       warning_at (UNKNOWN_LOCATION, 0,
 139                   "unrecognized command line option \"%s\"", opt);
 140     }
 141 }
 142
 143 /* Handle an unknown option DECODED, returning true if an error should
 144    be given.  */
 145
 146 static bool
 147 unknown_option_callback (const struct cl_decoded_option *decoded)
 148 {
 149   const char *opt = decoded->arg;
 150
 151   if (opt[1] == 'W' && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-'
 152       && !(decoded->errors & CL_ERR_NEGATIVE))
 153     {
 154       /* We don't generate warnings for unknown -Wno-* options unless
 155          we issue diagnostics.  */
 156       postpone_unknown_option_warning (opt);
 157       return false;
 158     }
 159   else
 160     return true;
 161 }
 162
 163 /* Handle a front-end option; arguments and return value as for
 164    handle_option.  */
 165
 166 static bool
 167 lang_handle_option (struct gcc_options *opts,
 168                     struct gcc_options *opts_set,
 169                     const struct cl_decoded_option *decoded,
 170                     unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
 171                     location_t loc,
 172                     const struct cl_option_handlers *handlers,
 173                     diagnostic_context *dc)
 174 {
 175   gcc_assert (opts == &global_options);
 176   gcc_assert (opts_set == &global_options_set);
 177   gcc_assert (dc == global_dc);
 178   gcc_assert (decoded->canonical_option_num_elements <= 2);
 179   return lang_hooks.handle_option (decoded->opt_index, decoded->arg,
 180                                    decoded->value, kind, loc, handlers);
 181 }
 182
 183 /* Handle FILENAME from the command line.  */
 184
 185 static void
 186 add_input_filename (const char *filename)
 187 {
 188   num_in_fnames++;
 189   in_fnames = XRESIZEVEC (const char *, in_fnames, num_in_fnames);
 190   in_fnames[num_in_fnames - 1] = filename;
 191 }
 192
 193 /* Handle the vector of command line options (located at LOC), storing
 194    the results of processing DECODED_OPTIONS and DECODED_OPTIONS_COUNT
 195    in OPTS and OPTS_SET and using DC for diagnostic state.  LANG_MASK
 196    contains has a single bit set representing the current language.
 197    HANDLERS describes what functions to call for the options.  */
 198
 199 static void
 200 read_cmdline_options (struct gcc_options *opts, struct gcc_options *opts_set,
 201                       struct cl_decoded_option *decoded_options,
 202                       unsigned int decoded_options_count,
 203                       location_t loc,
 204                       unsigned int lang_mask,
 205                       const struct cl_option_handlers *handlers,
 206                       diagnostic_context *dc)
 207 {
 208   unsigned int i;
 209
 210   for (i = 1; i < decoded_options_count; i++)
 211     {
 212       if (decoded_options[i].opt_index == OPT_SPECIAL_input_file)
 213         {
 214           /* Input files should only ever appear on the main command
 215              line.  */
 216           gcc_assert (opts == &global_options);
 217           gcc_assert (opts_set == &global_options_set);
 218
 219           if (opts->x_main_input_filename == NULL)
 220             {
 221               opts->x_main_input_filename = decoded_options[i].arg;
 222               opts->x_main_input_baselength
 223                 = base_of_path (opts->x_main_input_filename,
 224                                 &opts->x_main_input_basename);
 225             }
 226           add_input_filename (decoded_options[i].arg);
 227           continue;
 228         }
 229
 230       read_cmdline_option (opts, opts_set,
 231                            decoded_options + i, loc, lang_mask, handlers,
 232                            dc);
 233     }
 234 }
 235
 236 /* Language mask determined at initialization.  */
 237 static unsigned int initial_lang_mask;
 238
 239 /* Initialize global options-related settings at start-up.  */
 240
 241 void
 242 init_options_once (void)
 243 {
 244   /* Perform language-specific options initialization.  */
 245   initial_lang_mask = lang_hooks.option_lang_mask ();
 246
 247   lang_hooks.initialize_diagnostics (global_dc);
 248 }
 249
 250 /* Decode command-line options to an array, like
 251    decode_cmdline_options_to_array and with the same arguments but
 252    using the default lang_mask.  */
 253
 254 void
 255 decode_cmdline_options_to_array_default_mask (unsigned int argc,
 256                                               const char **argv,
 257                                               struct cl_decoded_option **decoded_options,
 258                                               unsigned int *decoded_options_count)
 259 {
 260   decode_cmdline_options_to_array (argc, argv,
 261                                    initial_lang_mask | CL_COMMON | CL_TARGET,
 262                                    decoded_options, decoded_options_count);
 263 }
 264
 265 /* Set *HANDLERS to the default set of option handlers for use in the
 266    compilers proper (not the driver).  */
 267 void
 268 set_default_handlers (struct cl_option_handlers *handlers)
 269 {
 270   handlers->unknown_option_callback = unknown_option_callback;
 271   handlers->wrong_lang_callback = complain_wrong_lang;
 272   handlers->num_handlers = 3;
 273   handlers->handlers[0].handler = lang_handle_option;
 274   handlers->handlers[0].mask = initial_lang_mask;
 275   handlers->handlers[1].handler = common_handle_option;
 276   handlers->handlers[1].mask = CL_COMMON;
 277   handlers->handlers[2].handler = target_handle_option;
 278   handlers->handlers[2].mask = CL_TARGET;
 279 }
 280
 281 /* Parse command line options and set default flag values.  Do minimal
 282    options processing.  The decoded options are in *DECODED_OPTIONS
 283    and *DECODED_OPTIONS_COUNT; settings go in OPTS, OPTS_SET and DC;
 284    the options are located at LOC.  */
 285 void
 286 decode_options (struct gcc_options *opts, struct gcc_options *opts_set,
 287                 struct cl_decoded_option *decoded_options,
 288                 unsigned int decoded_options_count,
 289                 location_t loc, diagnostic_context *dc)
 290 {
 291   struct cl_option_handlers handlers;
 292
 293   unsigned int lang_mask;
 294
 295   lang_mask = initial_lang_mask;
 296
 297   set_default_handlers (&handlers);
 298
 299   default_options_optimization (opts, opts_set,
 300                                 decoded_options, decoded_options_count,
 301                                 loc, lang_mask, &handlers, dc);
 302
 303   read_cmdline_options (opts, opts_set,
 304                         decoded_options, decoded_options_count,
 305                         loc, lang_mask,
 306                         &handlers, dc);
 307
 308   finish_options (opts, opts_set, loc);
 309 }
 310
 311 /* Process common options that have been deferred until after the
 312    handlers have been called for all options.  */
 313
 314 void
 315 handle_common_deferred_options (void)
 316 {
 317   unsigned int i;
 318   cl_deferred_option *opt;
 319   VEC(cl_deferred_option,heap) *vec
 320     = (VEC(cl_deferred_option,heap) *) common_deferred_options;
 321
 322   if (flag_dump_all_passed)
 323     enable_rtl_dump_file ();
 324
 325   FOR_EACH_VEC_ELT (cl_deferred_option, vec, i, opt)
 326     {
 327       switch (opt->opt_index)
 328         {
 329         case OPT_fcall_used_:
 330           fix_register (opt->arg, 0, 1);
 331           break;
 332
 333         case OPT_fcall_saved_:
 334           fix_register (opt->arg, 0, 0);
 335           break;
 336
 337         case OPT_fdbg_cnt_:
 338           dbg_cnt_process_opt (opt->arg);
 339           break;
 340
 341         case OPT_fdbg_cnt_list:
 342           dbg_cnt_list_all_counters ();
 343           break;
 344
 345         case OPT_fdebug_prefix_map_:
 346           add_debug_prefix_map (opt->arg);
 347           break;
 348
 349         case OPT_fdump_:
 350           if (!dump_switch_p (opt->arg))
 351             error ("unrecognized command line option %<-fdump-%s%>", opt->arg);
 352           break;
 353
 354         case OPT_fenable_:
 355         case OPT_fdisable_:
 356           if (opt->opt_index == OPT_fenable_)
 357             enable_pass (opt->arg);
 358           else
 359             disable_pass (opt->arg);
 360           break;
 361
 362         case OPT_ffixed_:
 363           /* Deferred.  */
 364           fix_register (opt->arg, 1, 1);
 365           break;
 366
 367         case OPT_fplugin_:
 368 #ifdef ENABLE_PLUGIN
 369           add_new_plugin (opt->arg);
 370 #else
 371           error ("plugin support is disabled; configure with --enable-plugin");
 372 #endif
 373           break;
 374
 375         case OPT_fplugin_arg_:
 376 #ifdef ENABLE_PLUGIN
 377           parse_plugin_arg_opt (opt->arg);
 378 #else
 379           error ("plugin support is disabled; configure with --enable-plugin");
 380 #endif
 381           break;
 382
 383         case OPT_frandom_seed:
 384           /* The real switch is -fno-random-seed.  */
 385           if (!opt->value)
 386             set_random_seed (NULL);
 387           break;
 388
 389         case OPT_frandom_seed_:
 390           set_random_seed (opt->arg);
 391           break;
 392
 393         case OPT_fstack_limit:
 394           /* The real switch is -fno-stack-limit.  */
 395           if (!opt->value)
 396             stack_limit_rtx = NULL_RTX;
 397           break;
 398
 399         case OPT_fstack_limit_register_:
 400           {
 401             int reg = decode_reg_name (opt->arg);
 402             if (reg < 0)
 403               error ("unrecognized register name %qs", opt->arg);
 404             else
 405               stack_limit_rtx = gen_rtx_REG (Pmode, reg);
 406           }
 407           break;
 408
 409         case OPT_fstack_limit_symbol_:
 410           stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (opt->arg));
 411           break;
 412
 413         default:
 414           gcc_unreachable ();
 415         }
 416     }
 417 }