gcc/opts.c

   1 /* Command line option handling.
   2    Copyright (C) 2002-2013 Free Software Foundation, Inc.
   3    Contributed by Neil Booth.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 3, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING3.  If not see
  19 <http://www.gnu.org/licenses/>.  */
  20
  21 #include "config.h"
  22 #include "system.h"
  23 #include "intl.h"
  24 #include "coretypes.h"
  25 #include "opts.h"
  26 #include "options.h"
  27 #include "tm.h" /* For STACK_CHECK_BUILTIN,
  28                    STACK_CHECK_STATIC_BUILTIN, DEFAULT_GDB_EXTENSIONS,
  29                    DWARF2_DEBUGGING_INFO and DBX_DEBUGGING_INFO.  */
  30 #include "flags.h"
  31 #include "params.h"
  32 #include "diagnostic.h"
  33 #include "diagnostic-color.h"
  34 #include "opts-diagnostic.h"
  35 #include "insn-attr-common.h"
  36 #include "common/common-target.h"
  37
  38 static void set_Wstrict_aliasing (struct gcc_options *opts, int onoff);
  39
  40 /* Indexed by enum debug_info_type.  */
  41 const char *const debug_type_names[] =
  42 {
  43   "none", "stabs", "coff", "dwarf-2", "xcoff", "vms"
  44 };
  45
  46 /* Parse the -femit-struct-debug-detailed option value
  47    and set the flag variables. */
  48
  49 #define MATCH( prefix, string ) \
  50   ((strncmp (prefix, string, sizeof prefix - 1) == 0) \
  51    ? ((string += sizeof prefix - 1), 1) : 0)
  52
  53 void
  54 set_struct_debug_option (struct gcc_options *opts, location_t loc,
  55                          const char *spec)
  56 {
  57   /* various labels for comparison */
  58   static const char dfn_lbl[] = "dfn:", dir_lbl[] = "dir:", ind_lbl[] = "ind:";
  59   static const char ord_lbl[] = "ord:", gen_lbl[] = "gen:";
  60   static const char none_lbl[] = "none", any_lbl[] = "any";
  61   static const char base_lbl[] = "base", sys_lbl[] = "sys";
  62
  63   enum debug_struct_file files = DINFO_STRUCT_FILE_ANY;
  64   /* Default is to apply to as much as possible. */
  65   enum debug_info_usage usage = DINFO_USAGE_NUM_ENUMS;
  66   int ord = 1, gen = 1;
  67
  68   /* What usage? */
  69   if (MATCH (dfn_lbl, spec))
  70     usage = DINFO_USAGE_DFN;
  71   else if (MATCH (dir_lbl, spec))
  72     usage = DINFO_USAGE_DIR_USE;
  73   else if (MATCH (ind_lbl, spec))
  74     usage = DINFO_USAGE_IND_USE;
  75
  76   /* Generics or not? */
  77   if (MATCH (ord_lbl, spec))
  78     gen = 0;
  79   else if (MATCH (gen_lbl, spec))
  80     ord = 0;
  81
  82   /* What allowable environment? */
  83   if (MATCH (none_lbl, spec))
  84     files = DINFO_STRUCT_FILE_NONE;
  85   else if (MATCH (any_lbl, spec))
  86     files = DINFO_STRUCT_FILE_ANY;
  87   else if (MATCH (sys_lbl, spec))
  88     files = DINFO_STRUCT_FILE_SYS;
  89   else if (MATCH (base_lbl, spec))
  90     files = DINFO_STRUCT_FILE_BASE;
  91   else
  92     error_at (loc,
  93               "argument %qs to %<-femit-struct-debug-detailed%> "
  94               "not recognized",
  95               spec);
  96
  97   /* Effect the specification. */
  98   if (usage == DINFO_USAGE_NUM_ENUMS)
  99     {
 100       if (ord)
 101         {
 102           opts->x_debug_struct_ordinary[DINFO_USAGE_DFN] = files;
 103           opts->x_debug_struct_ordinary[DINFO_USAGE_DIR_USE] = files;
 104           opts->x_debug_struct_ordinary[DINFO_USAGE_IND_USE] = files;
 105         }
 106       if (gen)
 107         {
 108           opts->x_debug_struct_generic[DINFO_USAGE_DFN] = files;
 109           opts->x_debug_struct_generic[DINFO_USAGE_DIR_USE] = files;
 110           opts->x_debug_struct_generic[DINFO_USAGE_IND_USE] = files;
 111         }
 112     }
 113   else
 114     {
 115       if (ord)
 116         opts->x_debug_struct_ordinary[usage] = files;
 117       if (gen)
 118         opts->x_debug_struct_generic[usage] = files;
 119     }
 120
 121   if (*spec == ',')
 122     set_struct_debug_option (opts, loc, spec+1);
 123   else
 124     {
 125       /* No more -femit-struct-debug-detailed specifications.
 126          Do final checks. */
 127       if (*spec != '\0')
 128         error_at (loc,
 129                   "argument %qs to %<-femit-struct-debug-detailed%> unknown",
 130                   spec);
 131       if (opts->x_debug_struct_ordinary[DINFO_USAGE_DIR_USE]
 132                 < opts->x_debug_struct_ordinary[DINFO_USAGE_IND_USE]
 133           || opts->x_debug_struct_generic[DINFO_USAGE_DIR_USE]
 134                 < opts->x_debug_struct_generic[DINFO_USAGE_IND_USE])
 135         error_at (loc,
 136                   "%<-femit-struct-debug-detailed=dir:...%> must allow "
 137                   "at least as much as "
 138                   "%<-femit-struct-debug-detailed=ind:...%>");
 139     }
 140 }
 141
 142 /* Strip off a legitimate source ending from the input string NAME of
 143    length LEN.  Rather than having to know the names used by all of
 144    our front ends, we strip off an ending of a period followed by
 145    up to five characters.  (Java uses ".class".)  */
 146
 147 void
 148 strip_off_ending (char *name, int len)
 149 {
 150   int i;
 151   for (i = 2; i < 6 && len > i; i++)
 152     {
 153       if (name[len - i] == '.')
 154         {
 155           name[len - i] = '\0';
 156           break;
 157         }
 158     }
 159 }
 160
 161 /* Find the base name of a path, stripping off both directories and
 162    a single final extension. */
 163 int
 164 base_of_path (const char *path, const char **base_out)
 165 {
 166   const char *base = path;
 167   const char *dot = 0;
 168   const char *p = path;
 169   char c = *p;
 170   while (c)
 171     {
 172       if (IS_DIR_SEPARATOR(c))
 173         {
 174           base = p + 1;
 175           dot = 0;
 176         }
 177       else if (c == '.')
 178         dot = p;
 179       c = *++p;
 180     }
 181   if (!dot)
 182     dot = p;
 183   *base_out = base;
 184   return dot - base;
 185 }
 186
 187 /* What to print when a switch has no documentation.  */
 188 static const char undocumented_msg[] = N_("This switch lacks documentation");
 189
 190 typedef char *char_p; /* For DEF_VEC_P.  */
 191
 192 static void handle_param (struct gcc_options *opts,
 193                           struct gcc_options *opts_set, location_t loc,
 194                           const char *carg);
 195 static void set_debug_level (enum debug_info_type type, int extended,
 196                              const char *arg, struct gcc_options *opts,
 197                              struct gcc_options *opts_set,
 198                              location_t loc);
 199 static void set_fast_math_flags (struct gcc_options *opts, int set);
 200 static void decode_d_option (const char *arg, struct gcc_options *opts,
 201                              location_t loc, diagnostic_context *dc);
 202 static void set_unsafe_math_optimizations_flags (struct gcc_options *opts,
 203                                                  int set);
 204 static void enable_warning_as_error (const char *arg, int value,
 205                                      unsigned int lang_mask,
 206                                      const struct cl_option_handlers *handlers,
 207                                      struct gcc_options *opts,
 208                                      struct gcc_options *opts_set,
 209                                      location_t loc,
 210                                      diagnostic_context *dc);
 211
 212 /* Handle a back-end option; arguments and return value as for
 213    handle_option.  */
 214
 215 bool
 216 target_handle_option (struct gcc_options *opts,
 217                       struct gcc_options *opts_set,
 218                       const struct cl_decoded_option *decoded,
 219                       unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
 220                       location_t loc,
 221                       const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED,
 222                       diagnostic_context *dc)
 223 {
 224   gcc_assert (dc == global_dc);
 225   gcc_assert (kind == DK_UNSPECIFIED);
 226   return targetm_common.handle_option (opts, opts_set, decoded, loc);
 227 }
 228
 229 /* Add comma-separated strings to a char_p vector.  */
 230
 231 static void
 232 add_comma_separated_to_vector (void **pvec, const char *arg)
 233 {
 234   char *tmp;
 235   char *r;
 236   char *w;
 237   char *token_start;
 238   vec<char_p> *v = (vec<char_p> *) *pvec;
 239
 240   vec_check_alloc (v, 1);
 241
 242   /* We never free this string.  */
 243   tmp = xstrdup (arg);
 244
 245   r = tmp;
 246   w = tmp;
 247   token_start = tmp;
 248
 249   while (*r != '\0')
 250     {
 251       if (*r == ',')
 252         {
 253           *w++ = '\0';
 254           ++r;
 255           v->safe_push (token_start);
 256           token_start = w;
 257         }
 258       if (*r == '\\' && r[1] == ',')
 259         {
 260           *w++ = ',';
 261           r += 2;
 262         }
 263       else
 264         *w++ = *r++;
 265     }
 266   if (*token_start != '\0')
 267     v->safe_push (token_start);
 268
 269   *pvec = v;
 270 }
 271
 272 /* Initialize OPTS and OPTS_SET before using them in parsing options.  */
 273
 274 void
 275 init_options_struct (struct gcc_options *opts, struct gcc_options *opts_set)
 276 {
 277   size_t num_params = get_num_compiler_params ();
 278
 279   gcc_obstack_init (&opts_obstack);
 280
 281   *opts = global_options_init;
 282   memset (opts_set, 0, sizeof (*opts_set));
 283
 284   opts->x_param_values = XNEWVEC (int, num_params);
 285   opts_set->x_param_values = XCNEWVEC (int, num_params);
 286   init_param_values (opts->x_param_values);
 287
 288   /* Initialize whether `char' is signed.  */
 289   opts->x_flag_signed_char = DEFAULT_SIGNED_CHAR;
 290   /* Set this to a special "uninitialized" value.  The actual default
 291      is set after target options have been processed.  */
 292   opts->x_flag_short_enums = 2;
 293
 294   /* Initialize target_flags before default_options_optimization
 295      so the latter can modify it.  */
 296   opts->x_target_flags = targetm_common.default_target_flags;
 297
 298   /* Some targets have ABI-specified unwind tables.  */
 299   opts->x_flag_unwind_tables = targetm_common.unwind_tables_default;
 300
 301   /* Some targets have other target-specific initialization.  */
 302   targetm_common.option_init_struct (opts);
 303 }
 304
 305 /* If indicated by the optimization level LEVEL (-Os if SIZE is set,
 306    -Ofast if FAST is set, -Og if DEBUG is set), apply the option DEFAULT_OPT
 307    to OPTS and OPTS_SET, diagnostic context DC, location LOC, with language
 308    mask LANG_MASK and option handlers HANDLERS.  */
 309
 310 static void
 311 maybe_default_option (struct gcc_options *opts,
 312                       struct gcc_options *opts_set,
 313                       const struct default_options *default_opt,
 314                       int level, bool size, bool fast, bool debug,
 315                       unsigned int lang_mask,
 316                       const struct cl_option_handlers *handlers,
 317                       location_t loc,
 318                       diagnostic_context *dc)
 319 {
 320   const struct cl_option *option = &cl_options[default_opt->opt_index];
 321   bool enabled;
 322
 323   if (size)
 324     gcc_assert (level == 2);
 325   if (fast)
 326     gcc_assert (level == 3);
 327   if (debug)
 328     gcc_assert (level == 1);
 329
 330   switch (default_opt->levels)
 331     {
 332     case OPT_LEVELS_ALL:
 333       enabled = true;
 334       break;
 335
 336     case OPT_LEVELS_0_ONLY:
 337       enabled = (level == 0);
 338       break;
 339
 340     case OPT_LEVELS_1_PLUS:
 341       enabled = (level >= 1);
 342       break;
 343
 344     case OPT_LEVELS_1_PLUS_SPEED_ONLY:
 345       enabled = (level >= 1 && !size && !debug);
 346       break;
 347
 348     case OPT_LEVELS_1_PLUS_NOT_DEBUG:
 349       enabled = (level >= 1 && !debug);
 350       break;
 351
 352     case OPT_LEVELS_2_PLUS:
 353       enabled = (level >= 2);
 354       break;
 355
 356     case OPT_LEVELS_2_PLUS_SPEED_ONLY:
 357       enabled = (level >= 2 && !size && !debug);
 358       break;
 359
 360     case OPT_LEVELS_3_PLUS:
 361       enabled = (level >= 3);
 362       break;
 363
 364     case OPT_LEVELS_3_PLUS_AND_SIZE:
 365       enabled = (level >= 3 || size);
 366       break;
 367
 368     case OPT_LEVELS_SIZE:
 369       enabled = size;
 370       break;
 371
 372     case OPT_LEVELS_FAST:
 373       enabled = fast;
 374       break;
 375
 376     case OPT_LEVELS_NONE:
 377     default:
 378       gcc_unreachable ();
 379     }
 380
 381   if (enabled)
 382     handle_generated_option (opts, opts_set, default_opt->opt_index,
 383                              default_opt->arg, default_opt->value,
 384                              lang_mask, DK_UNSPECIFIED, loc,
 385                              handlers, dc);
 386   else if (default_opt->arg == NULL
 387            && !option->cl_reject_negative)
 388     handle_generated_option (opts, opts_set, default_opt->opt_index,
 389                              default_opt->arg, !default_opt->value,
 390                              lang_mask, DK_UNSPECIFIED, loc,
 391                              handlers, dc);
 392 }
 393
 394 /* As indicated by the optimization level LEVEL (-Os if SIZE is set,
 395    -Ofast if FAST is set), apply the options in array DEFAULT_OPTS to
 396    OPTS and OPTS_SET, diagnostic context DC, location LOC, with
 397    language mask LANG_MASK and option handlers HANDLERS.  */
 398
 399 static void
 400 maybe_default_options (struct gcc_options *opts,
 401                        struct gcc_options *opts_set,
 402                        const struct default_options *default_opts,
 403                        int level, bool size, bool fast, bool debug,
 404                        unsigned int lang_mask,
 405                        const struct cl_option_handlers *handlers,
 406                        location_t loc,
 407                        diagnostic_context *dc)
 408 {
 409   size_t i;
 410
 411   for (i = 0; default_opts[i].levels != OPT_LEVELS_NONE; i++)
 412     maybe_default_option (opts, opts_set, &default_opts[i],
 413                           level, size, fast, debug,
 414                           lang_mask, handlers, loc, dc);
 415 }
 416
 417 /* Table of options enabled by default at different levels.  */
 418
 419 static const struct default_options default_options_table[] =
 420   {
 421     /* -O1 optimizations.  */
 422     { OPT_LEVELS_1_PLUS, OPT_fdefer_pop, NULL, 1 },
 423 #ifdef DELAY_SLOTS
 424     { OPT_LEVELS_1_PLUS, OPT_fdelayed_branch, NULL, 1 },
 425 #endif
 426     { OPT_LEVELS_1_PLUS, OPT_fguess_branch_probability, NULL, 1 },
 427     { OPT_LEVELS_1_PLUS, OPT_fcprop_registers, NULL, 1 },
 428     { OPT_LEVELS_1_PLUS, OPT_fforward_propagate, NULL, 1 },
 429     { OPT_LEVELS_1_PLUS, OPT_fif_conversion, NULL, 1 },
 430     { OPT_LEVELS_1_PLUS, OPT_fif_conversion2, NULL, 1 },
 431     { OPT_LEVELS_1_PLUS, OPT_fipa_pure_const, NULL, 1 },
 432     { OPT_LEVELS_1_PLUS, OPT_fipa_reference, NULL, 1 },
 433     { OPT_LEVELS_1_PLUS, OPT_fipa_profile, NULL, 1 },
 434     { OPT_LEVELS_1_PLUS, OPT_fmerge_constants, NULL, 1 },
 435     { OPT_LEVELS_1_PLUS, OPT_fshrink_wrap, NULL, 1 },
 436     { OPT_LEVELS_1_PLUS, OPT_fsplit_wide_types, NULL, 1 },
 437     { OPT_LEVELS_1_PLUS, OPT_ftree_ccp, NULL, 1 },
 438     { OPT_LEVELS_1_PLUS, OPT_ftree_bit_ccp, NULL, 1 },
 439     { OPT_LEVELS_1_PLUS, OPT_ftree_dce, NULL, 1 },
 440     { OPT_LEVELS_1_PLUS, OPT_ftree_dominator_opts, NULL, 1 },
 441     { OPT_LEVELS_1_PLUS, OPT_ftree_dse, NULL, 1 },
 442     { OPT_LEVELS_1_PLUS, OPT_ftree_ter, NULL, 1 },
 443     { OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_ftree_sra, NULL, 1 },
 444     { OPT_LEVELS_1_PLUS, OPT_ftree_copyrename, NULL, 1 },
 445     { OPT_LEVELS_1_PLUS, OPT_ftree_fre, NULL, 1 },
 446     { OPT_LEVELS_1_PLUS, OPT_ftree_copy_prop, NULL, 1 },
 447     { OPT_LEVELS_1_PLUS, OPT_ftree_sink, NULL, 1 },
 448     { OPT_LEVELS_1_PLUS, OPT_ftree_ch, NULL, 1 },
 449     { OPT_LEVELS_1_PLUS, OPT_fcombine_stack_adjustments, NULL, 1 },
 450     { OPT_LEVELS_1_PLUS, OPT_fcompare_elim, NULL, 1 },
 451     { OPT_LEVELS_1_PLUS, OPT_ftree_slsr, NULL, 1 },
 452
 453     /* -O2 optimizations.  */
 454     { OPT_LEVELS_2_PLUS, OPT_finline_small_functions, NULL, 1 },
 455     { OPT_LEVELS_2_PLUS, OPT_findirect_inlining, NULL, 1 },
 456     { OPT_LEVELS_2_PLUS, OPT_fpartial_inlining, NULL, 1 },
 457     { OPT_LEVELS_2_PLUS, OPT_fthread_jumps, NULL, 1 },
 458     { OPT_LEVELS_2_PLUS, OPT_fcrossjumping, NULL, 1 },
 459     { OPT_LEVELS_2_PLUS, OPT_foptimize_sibling_calls, NULL, 1 },
 460     { OPT_LEVELS_2_PLUS, OPT_fcse_follow_jumps, NULL, 1 },
 461     { OPT_LEVELS_2_PLUS, OPT_fgcse, NULL, 1 },
 462     { OPT_LEVELS_2_PLUS, OPT_fexpensive_optimizations, NULL, 1 },
 463     { OPT_LEVELS_2_PLUS, OPT_frerun_cse_after_loop, NULL, 1 },
 464     { OPT_LEVELS_2_PLUS, OPT_fcaller_saves, NULL, 1 },
 465     { OPT_LEVELS_2_PLUS, OPT_fpeephole2, NULL, 1 },
 466 #ifdef INSN_SCHEDULING
 467   /* Only run the pre-regalloc scheduling pass if optimizing for speed.  */
 468     { OPT_LEVELS_2_PLUS_SPEED_ONLY, OPT_fschedule_insns, NULL, 1 },
 469     { OPT_LEVELS_2_PLUS, OPT_fschedule_insns2, NULL, 1 },
 470 #endif
 471     { OPT_LEVELS_2_PLUS, OPT_fregmove, NULL, 1 },
 472     { OPT_LEVELS_2_PLUS, OPT_fstrict_aliasing, NULL, 1 },
 473     { OPT_LEVELS_2_PLUS, OPT_fstrict_overflow, NULL, 1 },
 474     { OPT_LEVELS_2_PLUS, OPT_freorder_blocks, NULL, 1 },
 475     { OPT_LEVELS_2_PLUS, OPT_freorder_functions, NULL, 1 },
 476     { OPT_LEVELS_2_PLUS, OPT_ftree_vrp, NULL, 1 },
 477     { OPT_LEVELS_2_PLUS, OPT_ftree_builtin_call_dce, NULL, 1 },
 478     { OPT_LEVELS_2_PLUS, OPT_ftree_pre, NULL, 1 },
 479     { OPT_LEVELS_2_PLUS, OPT_ftree_switch_conversion, NULL, 1 },
 480     { OPT_LEVELS_2_PLUS, OPT_fipa_cp, NULL, 1 },
 481     { OPT_LEVELS_2_PLUS, OPT_fdevirtualize, NULL, 1 },
 482     { OPT_LEVELS_2_PLUS, OPT_fdevirtualize_speculatively, NULL, 1 },
 483     { OPT_LEVELS_2_PLUS, OPT_fipa_sra, NULL, 1 },
 484     { OPT_LEVELS_2_PLUS, OPT_falign_loops, NULL, 1 },
 485     { OPT_LEVELS_2_PLUS, OPT_falign_jumps, NULL, 1 },
 486     { OPT_LEVELS_2_PLUS, OPT_falign_labels, NULL, 1 },
 487     { OPT_LEVELS_2_PLUS, OPT_falign_functions, NULL, 1 },
 488     { OPT_LEVELS_2_PLUS, OPT_ftree_tail_merge, NULL, 1 },
 489     { OPT_LEVELS_2_PLUS_SPEED_ONLY, OPT_foptimize_strlen, NULL, 1 },
 490     { OPT_LEVELS_2_PLUS, OPT_fhoist_adjacent_loads, NULL, 1 },
 491
 492     /* -O3 optimizations.  */
 493     { OPT_LEVELS_3_PLUS, OPT_ftree_loop_distribute_patterns, NULL, 1 },
 494     { OPT_LEVELS_3_PLUS, OPT_fpredictive_commoning, NULL, 1 },
 495     /* Inlining of functions reducing size is a good idea with -Os
 496        regardless of them being declared inline.  */
 497     { OPT_LEVELS_3_PLUS_AND_SIZE, OPT_finline_functions, NULL, 1 },
 498     { OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_finline_functions_called_once, NULL, 1 },
 499     { OPT_LEVELS_3_PLUS, OPT_funswitch_loops, NULL, 1 },
 500     { OPT_LEVELS_3_PLUS, OPT_fgcse_after_reload, NULL, 1 },
 501     { OPT_LEVELS_3_PLUS, OPT_ftree_loop_vectorize, NULL, 1 },
 502     { OPT_LEVELS_3_PLUS, OPT_ftree_slp_vectorize, NULL, 1 },
 503     { OPT_LEVELS_3_PLUS, OPT_fvect_cost_model, NULL, 1 },
 504     { OPT_LEVELS_3_PLUS, OPT_fipa_cp_clone, NULL, 1 },
 505     { OPT_LEVELS_3_PLUS, OPT_ftree_partial_pre, NULL, 1 },
 506
 507     /* -Ofast adds optimizations to -O3.  */
 508     { OPT_LEVELS_FAST, OPT_ffast_math, NULL, 1 },
 509
 510     { OPT_LEVELS_NONE, 0, NULL, 0 }
 511   };
 512
 513 /* Default the options in OPTS and OPTS_SET based on the optimization
 514    settings in DECODED_OPTIONS and DECODED_OPTIONS_COUNT.  */
 515 void
 516 default_options_optimization (struct gcc_options *opts,
 517                               struct gcc_options *opts_set,
 518                               struct cl_decoded_option *decoded_options,
 519                               unsigned int decoded_options_count,
 520                               location_t loc,
 521                               unsigned int lang_mask,
 522                               const struct cl_option_handlers *handlers,
 523                               diagnostic_context *dc)
 524 {
 525   unsigned int i;
 526   int opt2;
 527
 528   /* Scan to see what optimization level has been specified.  That will
 529      determine the default value of many flags.  */
 530   for (i = 1; i < decoded_options_count; i++)
 531     {
 532       struct cl_decoded_option *opt = &decoded_options[i];
 533       switch (opt->opt_index)
 534         {
 535         case OPT_O:
 536           if (*opt->arg == '\0')
 537             {
 538               opts->x_optimize = 1;
 539               opts->x_optimize_size = 0;
 540               opts->x_optimize_fast = 0;
 541               opts->x_optimize_debug = 0;
 542             }
 543           else
 544             {
 545               const int optimize_val = integral_argument (opt->arg);
 546               if (optimize_val == -1)
 547                 error_at (loc, "argument to %<-O%> should be a non-negative "
 548                                "integer, %<g%>, %<s%> or %<fast%>");
 549               else
 550                 {
 551                   opts->x_optimize = optimize_val;
 552                   if ((unsigned int) opts->x_optimize > 255)
 553                     opts->x_optimize = 255;
 554                   opts->x_optimize_size = 0;
 555                   opts->x_optimize_fast = 0;
 556                   opts->x_optimize_debug = 0;
 557                 }
 558             }
 559           break;
 560
 561         case OPT_Os:
 562           opts->x_optimize_size = 1;
 563
 564           /* Optimizing for size forces optimize to be 2.  */
 565           opts->x_optimize = 2;
 566           opts->x_optimize_fast = 0;
 567           opts->x_optimize_debug = 0;
 568           break;
 569
 570         case OPT_Ofast:
 571           /* -Ofast only adds flags to -O3.  */
 572           opts->x_optimize_size = 0;
 573           opts->x_optimize = 3;
 574           opts->x_optimize_fast = 1;
 575           opts->x_optimize_debug = 0;
 576           break;
 577
 578         case OPT_Og:
 579           /* -Og selects optimization level 1.  */
 580           opts->x_optimize_size = 0;
 581           opts->x_optimize = 1;
 582           opts->x_optimize_fast = 0;
 583           opts->x_optimize_debug = 1;
 584           break;
 585
 586         default:
 587           /* Ignore other options in this prescan.  */
 588           break;
 589         }
 590     }
 591
 592   maybe_default_options (opts, opts_set, default_options_table,
 593                          opts->x_optimize, opts->x_optimize_size,
 594                          opts->x_optimize_fast, opts->x_optimize_debug,
 595                          lang_mask, handlers, loc, dc);
 596
 597   /* -O2 param settings.  */
 598   opt2 = (opts->x_optimize >= 2);
 599
 600   /* Track fields in field-sensitive alias analysis.  */
 601   maybe_set_param_value
 602     (PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE,
 603      opt2 ? 100 : default_param_value (PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE),
 604      opts->x_param_values, opts_set->x_param_values);
 605
 606   /* For -O1 only do loop invariant motion for very small loops.  */
 607   maybe_set_param_value
 608     (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP,
 609      opt2 ? default_param_value (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP) : 1000,
 610      opts->x_param_values, opts_set->x_param_values);
 611
 612   if (opts->x_optimize_size)
 613     /* We want to crossjump as much as possible.  */
 614     maybe_set_param_value (PARAM_MIN_CROSSJUMP_INSNS, 1,
 615                            opts->x_param_values, opts_set->x_param_values);
 616   else
 617     maybe_set_param_value (PARAM_MIN_CROSSJUMP_INSNS,
 618                            default_param_value (PARAM_MIN_CROSSJUMP_INSNS),
 619                            opts->x_param_values, opts_set->x_param_values);
 620
 621   /* Allow default optimizations to be specified on a per-machine basis.  */
 622   maybe_default_options (opts, opts_set,
 623                          targetm_common.option_optimization_table,
 624                          opts->x_optimize, opts->x_optimize_size,
 625                          opts->x_optimize_fast, opts->x_optimize_debug,
 626                          lang_mask, handlers, loc, dc);
 627 }
 628
 629 /* After all options at LOC have been read into OPTS and OPTS_SET,
 630    finalize settings of those options and diagnose incompatible
 631    combinations.  */
 632 void
 633 finish_options (struct gcc_options *opts, struct gcc_options *opts_set,
 634                 location_t loc)
 635 {
 636   enum unwind_info_type ui_except;
 637
 638   if (opts->x_dump_base_name && ! IS_ABSOLUTE_PATH (opts->x_dump_base_name))
 639     {
 640       /* First try to make OPTS->X_DUMP_BASE_NAME relative to the
 641          OPTS->X_DUMP_DIR_NAME directory.  Then try to make
 642          OPTS->X_DUMP_BASE_NAME relative to the OPTS->X_AUX_BASE_NAME
 643          directory, typically the directory to contain the object
 644          file.  */
 645       if (opts->x_dump_dir_name)
 646         opts->x_dump_base_name = opts_concat (opts->x_dump_dir_name,
 647                                               opts->x_dump_base_name, NULL);
 648       else if (opts->x_aux_base_name
 649                && strcmp (opts->x_aux_base_name, HOST_BIT_BUCKET) != 0)
 650         {
 651           const char *aux_base;
 652
 653           base_of_path (opts->x_aux_base_name, &aux_base);
 654           if (opts->x_aux_base_name != aux_base)
 655             {
 656               int dir_len = aux_base - opts->x_aux_base_name;
 657               char *new_dump_base_name
 658                 = XOBNEWVEC (&opts_obstack, char,
 659                              strlen (opts->x_dump_base_name) + dir_len + 1);
 660
 661               /* Copy directory component from OPTS->X_AUX_BASE_NAME.  */
 662               memcpy (new_dump_base_name, opts->x_aux_base_name, dir_len);
 663               /* Append existing OPTS->X_DUMP_BASE_NAME.  */
 664               strcpy (new_dump_base_name + dir_len, opts->x_dump_base_name);
 665               opts->x_dump_base_name = new_dump_base_name;
 666             }
 667         }
 668     }
 669
 670   /* Handle related options for unit-at-a-time, toplevel-reorder, and
 671      section-anchors.  */
 672   if (!opts->x_flag_unit_at_a_time)
 673     {
 674       if (opts->x_flag_section_anchors && opts_set->x_flag_section_anchors)
 675         error_at (loc, "section anchors must be disabled when unit-at-a-time "
 676                   "is disabled");
 677       opts->x_flag_section_anchors = 0;
 678       if (opts->x_flag_toplevel_reorder == 1)
 679         error_at (loc, "toplevel reorder must be disabled when unit-at-a-time "
 680                   "is disabled");
 681       opts->x_flag_toplevel_reorder = 0;
 682     }
 683
 684   if (opts->x_flag_tm && opts->x_flag_non_call_exceptions)
 685     sorry ("transactional memory is not supported with non-call exceptions");
 686
 687   /* Unless the user has asked for section anchors, we disable toplevel
 688      reordering at -O0 to disable transformations that might be surprising
 689      to end users and to get -fno-toplevel-reorder tested.  */
 690   if (!opts->x_optimize
 691       && opts->x_flag_toplevel_reorder == 2
 692       && !(opts->x_flag_section_anchors && opts_set->x_flag_section_anchors))
 693     {
 694       opts->x_flag_toplevel_reorder = 0;
 695       opts->x_flag_section_anchors = 0;
 696     }
 697   if (!opts->x_flag_toplevel_reorder)
 698     {
 699       if (opts->x_flag_section_anchors && opts_set->x_flag_section_anchors)
 700         error_at (loc, "section anchors must be disabled when toplevel reorder"
 701                   " is disabled");
 702       opts->x_flag_section_anchors = 0;
 703     }
 704
 705   if (!opts->x_flag_opts_finished)
 706     {
 707       if (opts->x_flag_pie)
 708         opts->x_flag_pic = opts->x_flag_pie;
 709       if (opts->x_flag_pic && !opts->x_flag_pie)
 710         opts->x_flag_shlib = 1;
 711       opts->x_flag_opts_finished = true;
 712     }
 713
 714   if (opts->x_optimize == 0)
 715     {
 716       /* Inlining does not work if not optimizing,
 717          so force it not to be done.  */
 718       opts->x_warn_inline = 0;
 719       opts->x_flag_no_inline = 1;
 720     }
 721
 722   /* The optimization to partition hot and cold basic blocks into separate
 723      sections of the .o and executable files does not work (currently)
 724      with exception handling.  This is because there is no support for
 725      generating unwind info.  If opts->x_flag_exceptions is turned on
 726      we need to turn off the partitioning optimization.  */
 727
 728   ui_except = targetm_common.except_unwind_info (opts);
 729
 730   if (opts->x_flag_exceptions
 731       && opts->x_flag_reorder_blocks_and_partition
 732       && (ui_except == UI_SJLJ || ui_except >= UI_TARGET))
 733     {
 734       inform (loc,
 735               "-freorder-blocks-and-partition does not work "
 736               "with exceptions on this architecture");
 737       opts->x_flag_reorder_blocks_and_partition = 0;
 738       opts->x_flag_reorder_blocks = 1;
 739     }
 740
 741   /* If user requested unwind info, then turn off the partitioning
 742      optimization.  */
 743
 744   if (opts->x_flag_unwind_tables
 745       && !targetm_common.unwind_tables_default
 746       && opts->x_flag_reorder_blocks_and_partition
 747       && (ui_except == UI_SJLJ || ui_except >= UI_TARGET))
 748     {
 749       inform (loc,
 750               "-freorder-blocks-and-partition does not support "
 751               "unwind info on this architecture");
 752       opts->x_flag_reorder_blocks_and_partition = 0;
 753       opts->x_flag_reorder_blocks = 1;
 754     }
 755
 756   /* If the target requested unwind info, then turn off the partitioning
 757      optimization with a different message.  Likewise, if the target does not
 758      support named sections.  */
 759
 760   if (opts->x_flag_reorder_blocks_and_partition
 761       && (!targetm_common.have_named_sections
 762           || (opts->x_flag_unwind_tables
 763               && targetm_common.unwind_tables_default
 764               && (ui_except == UI_SJLJ || ui_except >= UI_TARGET))))
 765     {
 766       inform (loc,
 767               "-freorder-blocks-and-partition does not work "
 768               "on this architecture");
 769       opts->x_flag_reorder_blocks_and_partition = 0;
 770       opts->x_flag_reorder_blocks = 1;
 771     }
 772
 773   if (opts->x_flag_reorder_blocks_and_partition
 774       && !opts_set->x_flag_reorder_functions)
 775     opts->x_flag_reorder_functions = 1;
 776
 777   /* Pipelining of outer loops is only possible when general pipelining
 778      capabilities are requested.  */
 779   if (!opts->x_flag_sel_sched_pipelining)
 780     opts->x_flag_sel_sched_pipelining_outer_loops = 0;
 781
 782   if (opts->x_flag_conserve_stack)
 783     {
 784       maybe_set_param_value (PARAM_LARGE_STACK_FRAME, 100,
 785                              opts->x_param_values, opts_set->x_param_values);
 786       maybe_set_param_value (PARAM_STACK_FRAME_GROWTH, 40,
 787                              opts->x_param_values, opts_set->x_param_values);
 788     }
 789
 790   if (opts->x_flag_lto)
 791     {
 792 #ifdef ENABLE_LTO
 793       opts->x_flag_generate_lto = 1;
 794
 795       /* When generating IL, do not operate in whole-program mode.
 796          Otherwise, symbols will be privatized too early, causing link
 797          errors later.  */
 798       opts->x_flag_whole_program = 0;
 799 #else
 800       error_at (loc, "LTO support has not been enabled in this configuration");
 801 #endif
 802       if (!opts->x_flag_fat_lto_objects && !HAVE_LTO_PLUGIN)
 803         error_at (loc, "-fno-fat-lto-objects are supported only with linker plugin.");
 804 }
 805   if ((opts->x_flag_lto_partition_balanced != 0) + (opts->x_flag_lto_partition_1to1 != 0)
 806        + (opts->x_flag_lto_partition_none != 0) >= 1)
 807     {
 808       if ((opts->x_flag_lto_partition_balanced != 0)
 809            + (opts->x_flag_lto_partition_1to1 != 0)
 810            + (opts->x_flag_lto_partition_none != 0) > 1)
 811         error_at (loc, "only one -flto-partition value can be specified");
 812     }
 813
 814   /* We initialize opts->x_flag_split_stack to -1 so that targets can set a
 815      default value if they choose based on other options.  */
 816   if (opts->x_flag_split_stack == -1)
 817     opts->x_flag_split_stack = 0;
 818   else if (opts->x_flag_split_stack)
 819     {
 820       if (!targetm_common.supports_split_stack (true, opts))
 821         {
 822           error_at (loc, "%<-fsplit-stack%> is not supported by "
 823                     "this compiler configuration");
 824           opts->x_flag_split_stack = 0;
 825         }
 826     }
 827
 828   /* Set PARAM_MAX_STORES_TO_SINK to 0 if either vectorization or if-conversion
 829      is disabled.  */
 830   if ((!opts->x_flag_tree_loop_vectorize && !opts->x_flag_tree_slp_vectorize)
 831        || !opts->x_flag_tree_loop_if_convert)
 832     maybe_set_param_value (PARAM_MAX_STORES_TO_SINK, 0,
 833                            opts->x_param_values, opts_set->x_param_values);
 834
 835   /* The -gsplit-dwarf option requires -gpubnames.  */
 836   if (opts->x_dwarf_split_debug_info)
 837     opts->x_debug_generate_pub_sections = 1;
 838 }
 839
 840 #define LEFT_COLUMN     27
 841
 842 /* Output ITEM, of length ITEM_WIDTH, in the left column,
 843    followed by word-wrapped HELP in a second column.  */
 844 static void
 845 wrap_help (const char *help,
 846            const char *item,
 847            unsigned int item_width,
 848            unsigned int columns)
 849 {
 850   unsigned int col_width = LEFT_COLUMN;
 851   unsigned int remaining, room, len;
 852
 853   remaining = strlen (help);
 854
 855   do
 856     {
 857       room = columns - 3 - MAX (col_width, item_width);
 858       if (room > columns)
 859         room = 0;
 860       len = remaining;
 861
 862       if (room < len)
 863         {
 864           unsigned int i;
 865
 866           for (i = 0; help[i]; i++)
 867             {
 868               if (i >= room && len != remaining)
 869                 break;
 870               if (help[i] == ' ')
 871                 len = i;
 872               else if ((help[i] == '-' || help[i] == '/')
 873                        && help[i + 1] != ' '
 874                        && i > 0 && ISALPHA (help[i - 1]))
 875                 len = i + 1;
 876             }
 877         }
 878
 879       printf( "  %-*.*s %.*s\n", col_width, item_width, item, len, help);
 880       item_width = 0;
 881       while (help[len] == ' ')
 882         len++;
 883       help += len;
 884       remaining -= len;
 885     }
 886   while (remaining);
 887 }
 888
 889 /* Print help for a specific front-end, etc.  */
 890 static void
 891 print_filtered_help (unsigned int include_flags,
 892                      unsigned int exclude_flags,
 893                      unsigned int any_flags,
 894                      unsigned int columns,
 895                      struct gcc_options *opts,
 896                      unsigned int lang_mask)
 897 {
 898   unsigned int i;
 899   const char *help;
 900   bool found = false;
 901   bool displayed = false;
 902
 903   if (include_flags == CL_PARAMS)
 904     {
 905       for (i = 0; i < LAST_PARAM; i++)
 906         {
 907           const char *param = compiler_params[i].option;
 908
 909           help = compiler_params[i].help;
 910           if (help == NULL || *help == '\0')
 911             {
 912               if (exclude_flags & CL_UNDOCUMENTED)
 913                 continue;
 914               help = undocumented_msg;
 915             }
 916
 917           /* Get the translation.  */
 918           help = _(help);
 919
 920           wrap_help (help, param, strlen (param), columns);
 921         }
 922       putchar ('\n');
 923       return;
 924     }
 925
 926   if (!opts->x_help_printed)
 927     opts->x_help_printed = XCNEWVAR (char, cl_options_count);
 928
 929   if (!opts->x_help_enum_printed)
 930     opts->x_help_enum_printed = XCNEWVAR (char, cl_enums_count);
 931
 932   for (i = 0; i < cl_options_count; i++)
 933     {
 934       char new_help[128];
 935       const struct cl_option *option = cl_options + i;
 936       unsigned int len;
 937       const char *opt;
 938       const char *tab;
 939
 940       if (include_flags == 0
 941           || ((option->flags & include_flags) != include_flags))
 942         {
 943           if ((option->flags & any_flags) == 0)
 944             continue;
 945         }
 946
 947       /* Skip unwanted switches.  */
 948       if ((option->flags & exclude_flags) != 0)
 949         continue;
 950
 951       /* The driver currently prints its own help text.  */
 952       if ((option->flags & CL_DRIVER) != 0
 953           && (option->flags & (((1U << cl_lang_count) - 1)
 954                                | CL_COMMON | CL_TARGET)) == 0)
 955         continue;
 956
 957       found = true;
 958       /* Skip switches that have already been printed.  */
 959       if (opts->x_help_printed[i])
 960         continue;
 961
 962       opts->x_help_printed[i] = true;
 963
 964       help = option->help;
 965       if (help == NULL)
 966         {
 967           if (exclude_flags & CL_UNDOCUMENTED)
 968             continue;
 969           help = undocumented_msg;
 970         }
 971
 972       /* Get the translation.  */
 973       help = _(help);
 974
 975       /* Find the gap between the name of the
 976          option and its descriptive text.  */
 977       tab = strchr (help, '\t');
 978       if (tab)
 979         {
 980           len = tab - help;
 981           opt = help;
 982           help = tab + 1;
 983         }
 984       else
 985         {
 986           opt = option->opt_text;
 987           len = strlen (opt);
 988         }
 989
 990       /* With the -Q option enabled we change the descriptive text associated
 991          with an option to be an indication of its current setting.  */
 992       if (!opts->x_quiet_flag)
 993         {
 994           void *flag_var = option_flag_var (i, opts);
 995
 996           if (len < (LEFT_COLUMN + 2))
 997             strcpy (new_help, "\t\t");
 998           else
 999             strcpy (new_help, "\t");
1000
1001           if (flag_var != NULL
1002               && option->var_type != CLVC_DEFER)
1003             {
1004               if (option->flags & CL_JOINED)
1005                 {
1006                   if (option->var_type == CLVC_STRING)
1007                     {
1008                       if (* (const char **) flag_var != NULL)
1009                         snprintf (new_help + strlen (new_help),
1010                                   sizeof (new_help) - strlen (new_help),
1011                                   * (const char **) flag_var);
1012                     }
1013                   else if (option->var_type == CLVC_ENUM)
1014                     {
1015                       const struct cl_enum *e = &cl_enums[option->var_enum];
1016                       int value;
1017                       const char *arg = NULL;
1018
1019                       value = e->get (flag_var);
1020                       enum_value_to_arg (e->values, &arg, value, lang_mask);
1021                       if (arg == NULL)
1022                         arg = _("[default]");
1023                       snprintf (new_help + strlen (new_help),
1024                                 sizeof (new_help) - strlen (new_help),
1025                                 arg);
1026                     }
1027                   else
1028                     sprintf (new_help + strlen (new_help),
1029                              "%#x", * (int *) flag_var);
1030                 }
1031               else
1032                 strcat (new_help, option_enabled (i, opts)
1033                         ? _("[enabled]") : _("[disabled]"));
1034             }
1035
1036           help = new_help;
1037         }
1038
1039       wrap_help (help, opt, len, columns);
1040       displayed = true;
1041
1042       if (option->var_type == CLVC_ENUM
1043           && opts->x_help_enum_printed[option->var_enum] != 2)
1044         opts->x_help_enum_printed[option->var_enum] = 1;
1045     }
1046
1047   if (! found)
1048     {
1049       unsigned int langs = include_flags & CL_LANG_ALL;
1050
1051       if (langs == 0)
1052         printf (_(" No options with the desired characteristics were found\n"));
1053       else
1054         {
1055           unsigned int i;
1056
1057           /* PR 31349: Tell the user how to see all of the
1058              options supported by a specific front end.  */
1059           for (i = 0; (1U << i) < CL_LANG_ALL; i ++)
1060             if ((1U << i) & langs)
1061               printf (_(" None found.  Use --help=%s to show *all* the options supported by the %s front-end\n"),
1062                       lang_names[i], lang_names[i]);
1063         }
1064
1065     }
1066   else if (! displayed)
1067     printf (_(" All options with the desired characteristics have already been displayed\n"));
1068
1069   putchar ('\n');
1070
1071   /* Print details of enumerated option arguments, if those
1072      enumerations have help text headings provided.  If no help text
1073      is provided, presume that the possible values are listed in the
1074      help text for the relevant options.  */
1075   for (i = 0; i < cl_enums_count; i++)
1076     {
1077       unsigned int j, pos;
1078
1079       if (opts->x_help_enum_printed[i] != 1)
1080         continue;
1081       if (cl_enums[i].help == NULL)
1082         continue;
1083       printf ("  %s\n    ", _(cl_enums[i].help));
1084       pos = 4;
1085       for (j = 0; cl_enums[i].values[j].arg != NULL; j++)
1086         {
1087           unsigned int len = strlen (cl_enums[i].values[j].arg);
1088
1089           if (pos > 4 && pos + 1 + len <= columns)
1090             {
1091               printf (" %s", cl_enums[i].values[j].arg);
1092               pos += 1 + len;
1093             }
1094           else
1095             {
1096               if (pos > 4)
1097                 {
1098                   printf ("\n    ");
1099                   pos = 4;
1100                 }
1101               printf ("%s", cl_enums[i].values[j].arg);
1102               pos += len;
1103             }
1104         }
1105       printf ("\n\n");
1106       opts->x_help_enum_printed[i] = 2;
1107     }
1108 }
1109
1110 /* Display help for a specified type of option.
1111    The options must have ALL of the INCLUDE_FLAGS set
1112    ANY of the flags in the ANY_FLAGS set
1113    and NONE of the EXCLUDE_FLAGS set.  The current option state is in
1114    OPTS; LANG_MASK is used for interpreting enumerated option state.  */
1115 static void
1116 print_specific_help (unsigned int include_flags,
1117                      unsigned int exclude_flags,
1118                      unsigned int any_flags,
1119                      struct gcc_options *opts,
1120                      unsigned int lang_mask)
1121 {
1122   unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
1123   const char * description = NULL;
1124   const char * descrip_extra = "";
1125   size_t i;
1126   unsigned int flag;
1127
1128   /* Sanity check: Make sure that we do not have more
1129      languages than we have bits available to enumerate them.  */
1130   gcc_assert ((1U << cl_lang_count) <= CL_MIN_OPTION_CLASS);
1131
1132   /* If we have not done so already, obtain
1133      the desired maximum width of the output.  */
1134   if (opts->x_help_columns == 0)
1135     {
1136       const char *p;
1137
1138       p = getenv ("COLUMNS");
1139       if (p != NULL)
1140         {
1141           int value = atoi (p);
1142
1143           if (value > 0)
1144             opts->x_help_columns = value;
1145         }
1146
1147       if (opts->x_help_columns == 0)
1148         /* Use a reasonable default.  */
1149         opts->x_help_columns = 80;
1150     }
1151
1152   /* Decide upon the title for the options that we are going to display.  */
1153   for (i = 0, flag = 1; flag <= CL_MAX_OPTION_CLASS; flag <<= 1, i ++)
1154     {
1155       switch (flag & include_flags)
1156         {
1157         case 0:
1158         case CL_DRIVER:
1159           break;
1160
1161         case CL_TARGET:
1162           description = _("The following options are target specific");
1163           break;
1164         case CL_WARNING:
1165           description = _("The following options control compiler warning messages");
1166           break;
1167         case CL_OPTIMIZATION:
1168           description = _("The following options control optimizations");
1169           break;
1170         case CL_COMMON:
1171           description = _("The following options are language-independent");
1172           break;
1173         case CL_PARAMS:
1174           description = _("The --param option recognizes the following as parameters");
1175           break;
1176         default:
1177           if (i >= cl_lang_count)
1178             break;
1179           if (exclude_flags & all_langs_mask)
1180             description = _("The following options are specific to just the language ");
1181           else
1182             description = _("The following options are supported by the language ");
1183           descrip_extra = lang_names [i];
1184           break;
1185         }
1186     }
1187
1188   if (description == NULL)
1189     {
1190       if (any_flags == 0)
1191         {
1192           if (include_flags & CL_UNDOCUMENTED)
1193             description = _("The following options are not documented");
1194           else if (include_flags & CL_SEPARATE)
1195             description = _("The following options take separate arguments");
1196           else if (include_flags & CL_JOINED)
1197             description = _("The following options take joined arguments");
1198           else
1199             {
1200               internal_error ("unrecognized include_flags 0x%x passed to print_specific_help",
1201                               include_flags);
1202               return;
1203             }
1204         }
1205       else
1206         {
1207           if (any_flags & all_langs_mask)
1208             description = _("The following options are language-related");
1209           else
1210             description = _("The following options are language-independent");
1211         }
1212     }
1213
1214   printf ("%s%s:\n", description, descrip_extra);
1215   print_filtered_help (include_flags, exclude_flags, any_flags,
1216                        opts->x_help_columns, opts, lang_mask);
1217 }
1218
1219 /* Handle target- and language-independent options.  Return zero to
1220    generate an "unknown option" message.  Only options that need
1221    extra handling need to be listed here; if you simply want
1222    DECODED->value assigned to a variable, it happens automatically.  */
1223
1224 bool
1225 common_handle_option (struct gcc_options *opts,
1226                       struct gcc_options *opts_set,
1227                       const struct cl_decoded_option *decoded,
1228                       unsigned int lang_mask, int kind ATTRIBUTE_UNUSED,
1229                       location_t loc,
1230                       const struct cl_option_handlers *handlers,
1231                       diagnostic_context *dc)
1232 {
1233   size_t scode = decoded->opt_index;
1234   const char *arg = decoded->arg;
1235   int value = decoded->value;
1236   enum opt_code code = (enum opt_code) scode;
1237
1238   gcc_assert (decoded->canonical_option_num_elements <= 2);
1239
1240   switch (code)
1241     {
1242     case OPT__param:
1243       handle_param (opts, opts_set, loc, arg);
1244       break;
1245
1246     case OPT__help:
1247       {
1248         unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
1249         unsigned int undoc_mask;
1250         unsigned int i;
1251
1252         if (lang_mask == CL_DRIVER)
1253           break;;
1254
1255         undoc_mask = ((opts->x_verbose_flag | opts->x_extra_warnings)
1256                       ? 0
1257                       : CL_UNDOCUMENTED);
1258         /* First display any single language specific options.  */
1259         for (i = 0; i < cl_lang_count; i++)
1260           print_specific_help
1261             (1U << i, (all_langs_mask & (~ (1U << i))) | undoc_mask, 0, opts,
1262              lang_mask);
1263         /* Next display any multi language specific options.  */
1264         print_specific_help (0, undoc_mask, all_langs_mask, opts, lang_mask);
1265         /* Then display any remaining, non-language options.  */
1266         for (i = CL_MIN_OPTION_CLASS; i <= CL_MAX_OPTION_CLASS; i <<= 1)
1267           if (i != CL_DRIVER)
1268             print_specific_help (i, undoc_mask, 0, opts, lang_mask);
1269         opts->x_exit_after_options = true;
1270         break;
1271       }
1272
1273     case OPT__target_help:
1274       if (lang_mask == CL_DRIVER)
1275         break;
1276
1277       print_specific_help (CL_TARGET, CL_UNDOCUMENTED, 0, opts, lang_mask);
1278       opts->x_exit_after_options = true;
1279       break;
1280
1281     case OPT__help_:
1282       {
1283         const char * a = arg;
1284         unsigned int include_flags = 0;
1285         /* Note - by default we include undocumented options when listing
1286            specific classes.  If you only want to see documented options
1287            then add ",^undocumented" to the --help= option.  E.g.:
1288
1289            --help=target,^undocumented  */
1290         unsigned int exclude_flags = 0;
1291
1292         if (lang_mask == CL_DRIVER)
1293           break;
1294
1295         /* Walk along the argument string, parsing each word in turn.
1296            The format is:
1297            arg = [^]{word}[,{arg}]
1298            word = {optimizers|target|warnings|undocumented|
1299                    params|common|<language>}  */
1300         while (* a != 0)
1301           {
1302             static const struct
1303             {
1304               const char * string;
1305               unsigned int flag;
1306             }
1307             specifics[] =
1308             {
1309               { "optimizers", CL_OPTIMIZATION },
1310               { "target", CL_TARGET },
1311               { "warnings", CL_WARNING },
1312               { "undocumented", CL_UNDOCUMENTED },
1313               { "params", CL_PARAMS },
1314               { "joined", CL_JOINED },
1315               { "separate", CL_SEPARATE },
1316               { "common", CL_COMMON },
1317               { NULL, 0 }
1318             };
1319             unsigned int * pflags;
1320             const char * comma;
1321             unsigned int lang_flag, specific_flag;
1322             unsigned int len;
1323             unsigned int i;
1324
1325             if (* a == '^')
1326               {
1327                 ++ a;
1328                 pflags = & exclude_flags;
1329               }
1330             else
1331               pflags = & include_flags;
1332
1333             comma = strchr (a, ',');
1334             if (comma == NULL)
1335               len = strlen (a);
1336             else
1337               len = comma - a;
1338             if (len == 0)
1339               {
1340                 a = comma + 1;
1341                 continue;
1342               }
1343
1344             /* Check to see if the string matches an option class name.  */
1345             for (i = 0, specific_flag = 0; specifics[i].string != NULL; i++)
1346               if (strncasecmp (a, specifics[i].string, len) == 0)
1347                 {
1348                   specific_flag = specifics[i].flag;
1349                   break;
1350                 }
1351
1352             /* Check to see if the string matches a language name.
1353                Note - we rely upon the alpha-sorted nature of the entries in
1354                the lang_names array, specifically that shorter names appear
1355                before their longer variants.  (i.e. C before C++).  That way
1356                when we are attempting to match --help=c for example we will
1357                match with C first and not C++.  */
1358             for (i = 0, lang_flag = 0; i < cl_lang_count; i++)
1359               if (strncasecmp (a, lang_names[i], len) == 0)
1360                 {
1361                   lang_flag = 1U << i;
1362                   break;
1363                 }
1364
1365             if (specific_flag != 0)
1366               {
1367                 if (lang_flag == 0)
1368                   * pflags |= specific_flag;
1369                 else
1370                   {
1371                     /* The option's argument matches both the start of a
1372                        language name and the start of an option class name.
1373                        We have a special case for when the user has
1374                        specified "--help=c", but otherwise we have to issue
1375                        a warning.  */
1376                     if (strncasecmp (a, "c", len) == 0)
1377                       * pflags |= lang_flag;
1378                     else
1379                       warning_at (loc, 0,
1380                                   "--help argument %q.*s is ambiguous, "
1381                                   "please be more specific",
1382                                   len, a);
1383                   }
1384               }
1385             else if (lang_flag != 0)
1386               * pflags |= lang_flag;
1387             else
1388               warning_at (loc, 0,
1389                           "unrecognized argument to --help= option: %q.*s",
1390                           len, a);
1391
1392             if (comma == NULL)
1393               break;
1394             a = comma + 1;
1395           }
1396
1397         if (include_flags)
1398           print_specific_help (include_flags, exclude_flags, 0, opts,
1399                                lang_mask);
1400         opts->x_exit_after_options = true;
1401         break;
1402       }
1403
1404     case OPT__version:
1405       if (lang_mask == CL_DRIVER)
1406         break;
1407
1408       opts->x_exit_after_options = true;
1409       break;
1410
1411     case OPT_fsanitize_:
1412       {
1413         const char *p = arg;
1414         while (*p != 0)
1415           {
1416             static const struct
1417             {
1418               const char *const name;
1419               unsigned int flag;
1420               size_t len;
1421             } spec[] =
1422             {
1423               { "address", SANITIZE_ADDRESS, sizeof "address" - 1 },
1424               { "thread", SANITIZE_THREAD, sizeof "thread" - 1 },
1425               { "shift", SANITIZE_SHIFT, sizeof "shift" - 1 },
1426               { "integer-divide-by-zero", SANITIZE_DIVIDE,
1427                 sizeof "integer-divide-by-zero" - 1 },
1428               { "undefined", SANITIZE_UNDEFINED, sizeof "undefined" - 1 },
1429               { "unreachable", SANITIZE_UNREACHABLE,
1430                 sizeof "unreachable" - 1 },
1431               { NULL, 0, 0 }
1432             };
1433             const char *comma;
1434             size_t len, i;
1435             bool found = false;
1436
1437             comma = strchr (p, ',');
1438             if (comma == NULL)
1439               len = strlen (p);
1440             else
1441               len = comma - p;
1442             if (len == 0)
1443               {
1444                 p = comma + 1;
1445                 continue;
1446               }
1447
1448             /* Check to see if the string matches an option class name.  */
1449             for (i = 0; spec[i].name != NULL; ++i)
1450               if (len == spec[i].len
1451                   && memcmp (p, spec[i].name, len) == 0)
1452                 {
1453                   /* Handle both -fsanitize and -fno-sanitize cases.  */
1454                   if (value)
1455                     flag_sanitize |= spec[i].flag;
1456                   else
1457                     flag_sanitize &= ~spec[i].flag;
1458                   found = true;
1459                   break;
1460                 }
1461
1462             if (! found)
1463               warning_at (loc, 0,
1464                           "unrecognized argument to -fsanitize= option: %q.*s",
1465                           (int) len, p);
1466
1467             if (comma == NULL)
1468               break;
1469             p = comma + 1;
1470           }
1471
1472         break;
1473       }
1474
1475     case OPT_O:
1476     case OPT_Os:
1477     case OPT_Ofast:
1478     case OPT_Og:
1479       /* Currently handled in a prescan.  */
1480       break;
1481
1482     case OPT_Werror:
1483       dc->warning_as_error_requested = value;
1484       break;
1485
1486     case OPT_Werror_:
1487       if (lang_mask == CL_DRIVER)
1488         break;
1489
1490       enable_warning_as_error (arg, value, lang_mask, handlers,
1491                                opts, opts_set, loc, dc);
1492       break;
1493
1494     case OPT_Wlarger_than_:
1495       opts->x_larger_than_size = value;
1496       opts->x_warn_larger_than = value != -1;
1497       break;
1498
1499     case OPT_Wfatal_errors:
1500       dc->fatal_errors = value;
1501       break;
1502
1503     case OPT_Wframe_larger_than_:
1504       opts->x_frame_larger_than_size = value;
1505       opts->x_warn_frame_larger_than = value != -1;
1506       break;
1507
1508     case OPT_Wstack_usage_:
1509       opts->x_warn_stack_usage = value;
1510       opts->x_flag_stack_usage_info = value != -1;
1511       break;
1512
1513     case OPT_Wstrict_aliasing:
1514       set_Wstrict_aliasing (opts, value);
1515       break;
1516
1517     case OPT_Wstrict_overflow:
1518       opts->x_warn_strict_overflow = (value
1519                                       ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
1520                                       : 0);
1521       break;
1522
1523     case OPT_Wsystem_headers:
1524       dc->dc_warn_system_headers = value;
1525       break;
1526
1527     case OPT_aux_info:
1528       opts->x_flag_gen_aux_info = 1;
1529       break;
1530
1531     case OPT_auxbase_strip:
1532       {
1533         char *tmp = xstrdup (arg);
1534         strip_off_ending (tmp, strlen (tmp));
1535         if (tmp[0])
1536           opts->x_aux_base_name = tmp;
1537         else
1538           free (tmp);
1539       }
1540       break;
1541
1542     case OPT_d:
1543       decode_d_option (arg, opts, loc, dc);
1544       break;
1545
1546     case OPT_fcall_used_:
1547     case OPT_fcall_saved_:
1548       /* Deferred.  */
1549       break;
1550
1551     case OPT_fdbg_cnt_:
1552     case OPT_fdbg_cnt_list:
1553       /* Deferred.  */
1554       break;
1555
1556     case OPT_fdebug_prefix_map_:
1557       /* Deferred.  */
1558       break;
1559
1560     case OPT_fdiagnostics_show_location_:
1561       diagnostic_prefixing_rule (dc) = (diagnostic_prefixing_rule_t) value;
1562       break;
1563
1564     case OPT_fdiagnostics_show_caret:
1565       dc->show_caret = value;
1566       break;
1567
1568     case OPT_fdiagnostics_color_:
1569       pp_show_color (dc->printer)
1570         = colorize_init ((diagnostic_color_rule_t) value);
1571       break;
1572
1573     case OPT_fdiagnostics_show_option:
1574       dc->show_option_requested = value;
1575       break;
1576
1577     case OPT_fdump_:
1578       /* Deferred.  */
1579       break;
1580
1581     case OPT_ffast_math:
1582       set_fast_math_flags (opts, value);
1583       break;
1584
1585     case OPT_funsafe_math_optimizations:
1586       set_unsafe_math_optimizations_flags (opts, value);
1587       break;
1588
1589     case OPT_ffixed_:
1590       /* Deferred.  */
1591       break;
1592
1593     case OPT_finline_limit_:
1594       set_param_value ("max-inline-insns-single", value / 2,
1595                        opts->x_param_values, opts_set->x_param_values);
1596       set_param_value ("max-inline-insns-auto", value / 2,
1597                        opts->x_param_values, opts_set->x_param_values);
1598       break;
1599
1600     case OPT_finstrument_functions_exclude_function_list_:
1601       add_comma_separated_to_vector
1602         (&opts->x_flag_instrument_functions_exclude_functions, arg);
1603       break;
1604
1605     case OPT_finstrument_functions_exclude_file_list_:
1606       add_comma_separated_to_vector
1607         (&opts->x_flag_instrument_functions_exclude_files, arg);
1608       break;
1609
1610     case OPT_fmessage_length_:
1611       pp_set_line_maximum_length (dc->printer, value);
1612       diagnostic_set_caret_max_width (dc, value);
1613       break;
1614
1615     case OPT_fopt_info:
1616     case OPT_fopt_info_:
1617       /* Deferred.  */
1618       break;
1619
1620     case OPT_fpack_struct_:
1621       if (value <= 0 || (value & (value - 1)) || value > 16)
1622         error_at (loc,
1623                   "structure alignment must be a small power of two, not %d",
1624                   value);
1625       else
1626         opts->x_initial_max_fld_align = value;
1627       break;
1628
1629     case OPT_fplugin_:
1630     case OPT_fplugin_arg_:
1631       /* Deferred.  */
1632       break;
1633
1634     case OPT_fprofile_use_:
1635       opts->x_profile_data_prefix = xstrdup (arg);
1636       opts->x_flag_profile_use = true;
1637       value = true;
1638       /* No break here - do -fprofile-use processing. */
1639     case OPT_fprofile_use:
1640       if (!opts_set->x_flag_branch_probabilities)
1641         opts->x_flag_branch_probabilities = value;
1642       if (!opts_set->x_flag_profile_values)
1643         opts->x_flag_profile_values = value;
1644       if (!opts_set->x_flag_unroll_loops)
1645         opts->x_flag_unroll_loops = value;
1646       if (!opts_set->x_flag_peel_loops)
1647         opts->x_flag_peel_loops = value;
1648       if (!opts_set->x_flag_tracer)
1649         opts->x_flag_tracer = value;
1650       if (!opts_set->x_flag_value_profile_transformations)
1651         opts->x_flag_value_profile_transformations = value;
1652       if (!opts_set->x_flag_inline_functions)
1653         opts->x_flag_inline_functions = value;
1654       if (!opts_set->x_flag_ipa_cp)
1655         opts->x_flag_ipa_cp = value;
1656       if (!opts_set->x_flag_ipa_cp_clone
1657           && value && opts->x_flag_ipa_cp)
1658         opts->x_flag_ipa_cp_clone = value;
1659       if (!opts_set->x_flag_predictive_commoning)
1660         opts->x_flag_predictive_commoning = value;
1661       if (!opts_set->x_flag_unswitch_loops)
1662         opts->x_flag_unswitch_loops = value;
1663       if (!opts_set->x_flag_gcse_after_reload)
1664         opts->x_flag_gcse_after_reload = value;
1665       if (!opts_set->x_flag_tree_loop_vectorize
1666           && !opts_set->x_flag_tree_vectorize)
1667         opts->x_flag_tree_loop_vectorize = value;
1668       if (!opts_set->x_flag_tree_slp_vectorize
1669           && !opts_set->x_flag_tree_vectorize)
1670         opts->x_flag_tree_slp_vectorize = value;
1671       if (!opts_set->x_flag_vect_cost_model)
1672         opts->x_flag_vect_cost_model = value;
1673       if (!opts_set->x_flag_tree_loop_distribute_patterns)
1674         opts->x_flag_tree_loop_distribute_patterns = value;
1675       /* Indirect call profiling should do all useful transformations
1676          speculative devirutalization does.  */
1677       if (!opts_set->x_flag_devirtualize_speculatively
1678           && opts->x_flag_value_profile_transformations)
1679         opts->x_flag_devirtualize_speculatively = false;
1680       break;
1681
1682     case OPT_fprofile_generate_:
1683       opts->x_profile_data_prefix = xstrdup (arg);
1684       value = true;
1685       /* No break here - do -fprofile-generate processing. */
1686     case OPT_fprofile_generate:
1687       if (!opts_set->x_profile_arc_flag)
1688         opts->x_profile_arc_flag = value;
1689       if (!opts_set->x_flag_profile_values)
1690         opts->x_flag_profile_values = value;
1691       if (!opts_set->x_flag_inline_functions)
1692         opts->x_flag_inline_functions = value;
1693       /* FIXME: Instrumentation we insert makes ipa-reference bitmaps
1694          quadratic.  Disable the pass until better memory representation
1695          is done.  */
1696       if (!opts_set->x_flag_ipa_reference && opts->x_in_lto_p)
1697         opts->x_flag_ipa_reference = false;
1698       break;
1699
1700     case OPT_ftree_vectorize:
1701       if (!opts_set->x_flag_tree_loop_vectorize)
1702         opts->x_flag_tree_loop_vectorize = value;
1703       if (!opts_set->x_flag_tree_slp_vectorize)
1704         opts->x_flag_tree_slp_vectorize = value;
1705       break;
1706     case OPT_fshow_column:
1707       dc->show_column = value;
1708       break;
1709
1710     case OPT_frandom_seed:
1711       /* The real switch is -fno-random-seed.  */
1712       if (value)
1713         return false;
1714       /* Deferred.  */
1715       break;
1716
1717     case OPT_frandom_seed_:
1718       /* Deferred.  */
1719       break;
1720
1721     case OPT_fsched_verbose_:
1722 #ifdef INSN_SCHEDULING
1723       /* Handled with Var in common.opt.  */
1724       break;
1725 #else
1726       return false;
1727 #endif
1728
1729     case OPT_fsched_stalled_insns_:
1730       opts->x_flag_sched_stalled_insns = value;
1731       if (opts->x_flag_sched_stalled_insns == 0)
1732         opts->x_flag_sched_stalled_insns = -1;
1733       break;
1734
1735     case OPT_fsched_stalled_insns_dep_:
1736       opts->x_flag_sched_stalled_insns_dep = value;
1737       break;
1738
1739     case OPT_fstack_check_:
1740       if (!strcmp (arg, "no"))
1741         opts->x_flag_stack_check = NO_STACK_CHECK;
1742       else if (!strcmp (arg, "generic"))
1743         /* This is the old stack checking method.  */
1744         opts->x_flag_stack_check = STACK_CHECK_BUILTIN
1745                            ? FULL_BUILTIN_STACK_CHECK
1746                            : GENERIC_STACK_CHECK;
1747       else if (!strcmp (arg, "specific"))
1748         /* This is the new stack checking method.  */
1749         opts->x_flag_stack_check = STACK_CHECK_BUILTIN
1750                            ? FULL_BUILTIN_STACK_CHECK
1751                            : STACK_CHECK_STATIC_BUILTIN
1752                              ? STATIC_BUILTIN_STACK_CHECK
1753                              : GENERIC_STACK_CHECK;
1754       else
1755         warning_at (loc, 0, "unknown stack check parameter \"%s\"", arg);
1756       break;
1757
1758     case OPT_fstack_limit:
1759       /* The real switch is -fno-stack-limit.  */
1760       if (value)
1761         return false;
1762       /* Deferred.  */
1763       break;
1764
1765     case OPT_fstack_limit_register_:
1766     case OPT_fstack_limit_symbol_:
1767       /* Deferred.  */
1768       break;
1769
1770     case OPT_fstack_usage:
1771       opts->x_flag_stack_usage = value;
1772       opts->x_flag_stack_usage_info = value != 0;
1773       break;
1774
1775     case OPT_ftree_vectorizer_verbose_:
1776       /* -ftree-vectorizer-verbose is deprecated. It is defined in
1777          -terms of fopt-info=N. */
1778       /* Deferred.  */
1779       break;
1780
1781     case OPT_g:
1782       set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg, opts, opts_set,
1783                        loc);
1784       break;
1785
1786     case OPT_gcoff:
1787       set_debug_level (SDB_DEBUG, false, arg, opts, opts_set, loc);
1788       break;
1789
1790     case OPT_gdwarf:
1791       if (arg && strlen (arg) != 0)
1792         {
1793           error_at (loc, "%<-gdwarf%s%> is ambiguous; "
1794                     "use %<-gdwarf-%s%> for DWARF version "
1795                     "or %<-gdwarf -g%s%> for debug level", arg, arg, arg);
1796           break;
1797         }
1798       else
1799         value = opts->x_dwarf_version;
1800
1801       /* FALLTHRU */
1802     case OPT_gdwarf_:
1803       if (value < 2 || value > 4)
1804         error_at (loc, "dwarf version %d is not supported", value);
1805       else
1806         opts->x_dwarf_version = value;
1807       set_debug_level (DWARF2_DEBUG, false, "", opts, opts_set, loc);
1808       break;
1809
1810     case OPT_gsplit_dwarf:
1811       set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, "", opts, opts_set,
1812                        loc);
1813       break;
1814
1815     case OPT_ggdb:
1816       set_debug_level (NO_DEBUG, 2, arg, opts, opts_set, loc);
1817       break;
1818
1819     case OPT_gstabs:
1820     case OPT_gstabs_:
1821       set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg, opts, opts_set,
1822                        loc);
1823       break;
1824
1825     case OPT_gvms:
1826       set_debug_level (VMS_DEBUG, false, arg, opts, opts_set, loc);
1827       break;
1828
1829     case OPT_gxcoff:
1830     case OPT_gxcoff_:
1831       set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg, opts, opts_set,
1832                        loc);
1833       break;
1834
1835     case OPT_pedantic_errors:
1836       dc->pedantic_errors = 1;
1837       control_warning_option (OPT_Wpedantic, DK_ERROR, value,
1838                               loc, lang_mask,
1839                               handlers, opts, opts_set,
1840                               dc);
1841       break;
1842
1843     case OPT_flto:
1844       opts->x_flag_lto = value ? "" : NULL;
1845       break;
1846
1847     case OPT_w:
1848       dc->dc_inhibit_warnings = true;
1849       break;
1850
1851     case OPT_fmax_errors_:
1852       dc->max_errors = value;
1853       break;
1854
1855     case OPT_fuse_ld_bfd:
1856     case OPT_fuse_ld_gold:
1857     case OPT_fuse_linker_plugin:
1858       /* No-op. Used by the driver and passed to us because it starts with f.*/
1859       break;
1860
1861     case OPT_fwrapv:
1862       if (value)
1863         opts->x_flag_trapv = 0;
1864       break;
1865
1866     case OPT_ftrapv:
1867       if (value)
1868         opts->x_flag_wrapv = 0;
1869       break;
1870
1871     default:
1872       /* If the flag was handled in a standard way, assume the lack of
1873          processing here is intentional.  */
1874       gcc_assert (option_flag_var (scode, opts));
1875       break;
1876     }
1877
1878   common_handle_option_auto (opts, opts_set, decoded, lang_mask, kind,
1879                              loc, handlers, dc);
1880   return true;
1881 }
1882
1883 /* Handle --param NAME=VALUE.  */
1884 static void
1885 handle_param (struct gcc_options *opts, struct gcc_options *opts_set,
1886               location_t loc, const char *carg)
1887 {
1888   char *equal, *arg;
1889   int value;
1890
1891   arg = xstrdup (carg);
1892   equal = strchr (arg, '=');
1893   if (!equal)
1894     error_at (loc, "%s: --param arguments should be of the form NAME=VALUE",
1895               arg);
1896   else
1897     {
1898       value = integral_argument (equal + 1);
1899       if (value == -1)
1900         error_at (loc, "invalid --param value %qs", equal + 1);
1901       else
1902         {
1903           *equal = '\0';
1904           set_param_value (arg, value,
1905                            opts->x_param_values, opts_set->x_param_values);
1906         }
1907     }
1908
1909   free (arg);
1910 }
1911
1912 /* Used to set the level of strict aliasing warnings in OPTS,
1913    when no level is specified (i.e., when -Wstrict-aliasing, and not
1914    -Wstrict-aliasing=level was given).
1915    ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
1916    and 0 otherwise.  After calling this function, wstrict_aliasing will be
1917    set to the default value of -Wstrict_aliasing=level, currently 3.  */
1918 static void
1919 set_Wstrict_aliasing (struct gcc_options *opts, int onoff)
1920 {
1921   gcc_assert (onoff == 0 || onoff == 1);
1922   if (onoff != 0)
1923     opts->x_warn_strict_aliasing = 3;
1924   else
1925     opts->x_warn_strict_aliasing = 0;
1926 }
1927
1928 /* The following routines are useful in setting all the flags that
1929    -ffast-math and -fno-fast-math imply.  */
1930 static void
1931 set_fast_math_flags (struct gcc_options *opts, int set)
1932 {
1933   if (!opts->frontend_set_flag_unsafe_math_optimizations)
1934     {
1935       opts->x_flag_unsafe_math_optimizations = set;
1936       set_unsafe_math_optimizations_flags (opts, set);
1937     }
1938   if (!opts->frontend_set_flag_finite_math_only)
1939     opts->x_flag_finite_math_only = set;
1940   if (!opts->frontend_set_flag_errno_math)
1941     opts->x_flag_errno_math = !set;
1942   if (set)
1943     {
1944       if (!opts->frontend_set_flag_signaling_nans)
1945         opts->x_flag_signaling_nans = 0;
1946       if (!opts->frontend_set_flag_rounding_math)
1947         opts->x_flag_rounding_math = 0;
1948       if (!opts->frontend_set_flag_cx_limited_range)
1949         opts->x_flag_cx_limited_range = 1;
1950     }
1951 }
1952
1953 /* When -funsafe-math-optimizations is set the following
1954    flags are set as well.  */
1955 static void
1956 set_unsafe_math_optimizations_flags (struct gcc_options *opts, int set)
1957 {
1958   if (!opts->frontend_set_flag_trapping_math)
1959     opts->x_flag_trapping_math = !set;
1960   if (!opts->frontend_set_flag_signed_zeros)
1961     opts->x_flag_signed_zeros = !set;
1962   if (!opts->frontend_set_flag_associative_math)
1963     opts->x_flag_associative_math = set;
1964   if (!opts->frontend_set_flag_reciprocal_math)
1965     opts->x_flag_reciprocal_math = set;
1966 }
1967
1968 /* Return true iff flags in OPTS are set as if -ffast-math.  */
1969 bool
1970 fast_math_flags_set_p (const struct gcc_options *opts)
1971 {
1972   return (!opts->x_flag_trapping_math
1973           && opts->x_flag_unsafe_math_optimizations
1974           && opts->x_flag_finite_math_only
1975           && !opts->x_flag_signed_zeros
1976           && !opts->x_flag_errno_math);
1977 }
1978
1979 /* Return true iff flags are set as if -ffast-math but using the flags stored
1980    in the struct cl_optimization structure.  */
1981 bool
1982 fast_math_flags_struct_set_p (struct cl_optimization *opt)
1983 {
1984   return (!opt->x_flag_trapping_math
1985           && opt->x_flag_unsafe_math_optimizations
1986           && opt->x_flag_finite_math_only
1987           && !opt->x_flag_signed_zeros
1988           && !opt->x_flag_errno_math);
1989 }
1990
1991 /* Handle a debug output -g switch for options OPTS
1992    (OPTS_SET->x_write_symbols storing whether a debug type was passed
1993    explicitly), location LOC.  EXTENDED is true or false to support
1994    extended output (2 is special and means "-ggdb" was given).  */
1995 static void
1996 set_debug_level (enum debug_info_type type, int extended, const char *arg,
1997                  struct gcc_options *opts, struct gcc_options *opts_set,
1998                  location_t loc)
1999 {
2000   opts->x_use_gnu_debug_info_extensions = extended;
2001
2002   if (type == NO_DEBUG)
2003     {
2004       if (opts->x_write_symbols == NO_DEBUG)
2005         {
2006           opts->x_write_symbols = PREFERRED_DEBUGGING_TYPE;
2007
2008           if (extended == 2)
2009             {
2010 #ifdef DWARF2_DEBUGGING_INFO
2011               opts->x_write_symbols = DWARF2_DEBUG;
2012 #elif defined DBX_DEBUGGING_INFO
2013               opts->x_write_symbols = DBX_DEBUG;
2014 #endif
2015             }
2016
2017           if (opts->x_write_symbols == NO_DEBUG)
2018             warning_at (loc, 0, "target system does not support debug output");
2019         }
2020     }
2021   else
2022     {
2023       /* Does it conflict with an already selected type?  */
2024       if (opts_set->x_write_symbols != NO_DEBUG
2025           && opts->x_write_symbols != NO_DEBUG
2026           && type != opts->x_write_symbols)
2027         error_at (loc, "debug format \"%s\" conflicts with prior selection",
2028                   debug_type_names[type]);
2029       opts->x_write_symbols = type;
2030       opts_set->x_write_symbols = type;
2031     }
2032
2033   /* A debug flag without a level defaults to level 2.  */
2034   if (*arg == '\0')
2035     {
2036       if (!opts->x_debug_info_level)
2037         opts->x_debug_info_level = DINFO_LEVEL_NORMAL;
2038     }
2039   else
2040     {
2041       int argval = integral_argument (arg);
2042       if (argval == -1)
2043         error_at (loc, "unrecognised debug output level \"%s\"", arg);
2044       else if (argval > 3)
2045         error_at (loc, "debug output level %s is too high", arg);
2046       else
2047         opts->x_debug_info_level = (enum debug_info_levels) argval;
2048     }
2049 }
2050
2051 /* Arrange to dump core on error for diagnostic context DC.  (The
2052    regular error message is still printed first, except in the case of
2053    abort ().)  */
2054
2055 static void
2056 setup_core_dumping (diagnostic_context *dc)
2057 {
2058 #ifdef SIGABRT
2059   signal (SIGABRT, SIG_DFL);
2060 #endif
2061 #if defined(HAVE_SETRLIMIT)
2062   {
2063     struct rlimit rlim;
2064     if (getrlimit (RLIMIT_CORE, &rlim) != 0)
2065       fatal_error ("getting core file size maximum limit: %m");
2066     rlim.rlim_cur = rlim.rlim_max;
2067     if (setrlimit (RLIMIT_CORE, &rlim) != 0)
2068       fatal_error ("setting core file size limit to maximum: %m");
2069   }
2070 #endif
2071   diagnostic_abort_on_error (dc);
2072 }
2073
2074 /* Parse a -d<ARG> command line switch for OPTS, location LOC,
2075    diagnostic context DC.  */
2076
2077 static void
2078 decode_d_option (const char *arg, struct gcc_options *opts,
2079                  location_t loc, diagnostic_context *dc)
2080 {
2081   int c;
2082
2083   while (*arg)
2084     switch (c = *arg++)
2085       {
2086       case 'A':
2087         opts->x_flag_debug_asm = 1;
2088         break;
2089       case 'p':
2090         opts->x_flag_print_asm_name = 1;
2091         break;
2092       case 'P':
2093         opts->x_flag_dump_rtl_in_asm = 1;
2094         opts->x_flag_print_asm_name = 1;
2095         break;
2096       case 'x':
2097         opts->x_rtl_dump_and_exit = 1;
2098         break;
2099       case 'D': /* These are handled by the preprocessor.  */
2100       case 'I':
2101       case 'M':
2102       case 'N':
2103       case 'U':
2104         break;
2105       case 'H':
2106         setup_core_dumping (dc);
2107         break;
2108       case 'a':
2109         opts->x_flag_dump_all_passed = true;
2110         break;
2111
2112       default:
2113           warning_at (loc, 0, "unrecognized gcc debugging option: %c", c);
2114         break;
2115       }
2116 }
2117
2118 /* Enable (or disable if VALUE is 0) a warning option ARG (language
2119    mask LANG_MASK, option handlers HANDLERS) as an error for option
2120    structures OPTS and OPTS_SET, diagnostic context DC (possibly
2121    NULL), location LOC.  This is used by -Werror=.  */
2122
2123 static void
2124 enable_warning_as_error (const char *arg, int value, unsigned int lang_mask,
2125                          const struct cl_option_handlers *handlers,
2126                          struct gcc_options *opts,
2127                          struct gcc_options *opts_set,
2128                          location_t loc, diagnostic_context *dc)
2129 {
2130   char *new_option;
2131   int option_index;
2132
2133   new_option = XNEWVEC (char, strlen (arg) + 2);
2134   new_option[0] = 'W';
2135   strcpy (new_option + 1, arg);
2136   option_index = find_opt (new_option, lang_mask);
2137   if (option_index == OPT_SPECIAL_unknown)
2138     {
2139       error_at (loc, "-Werror=%s: no option -%s", arg, new_option);
2140     }
2141   else
2142     {
2143       const diagnostic_t kind = value ? DK_ERROR : DK_WARNING;
2144
2145       control_warning_option (option_index, (int) kind, value,
2146                               loc, lang_mask,
2147                               handlers, opts, opts_set, dc);
2148     }
2149   free (new_option);
2150 }
2151
2152 /* Return malloced memory for the name of the option OPTION_INDEX
2153    which enabled a diagnostic (context CONTEXT), originally of type
2154    ORIG_DIAG_KIND but possibly converted to DIAG_KIND by options such
2155    as -Werror.  */
2156
2157 char *
2158 option_name (diagnostic_context *context, int option_index,
2159              diagnostic_t orig_diag_kind, diagnostic_t diag_kind)
2160 {
2161   if (option_index)
2162     {
2163       /* A warning classified as an error.  */
2164       if ((orig_diag_kind == DK_WARNING || orig_diag_kind == DK_PEDWARN)
2165           && diag_kind == DK_ERROR)
2166         return concat (cl_options[OPT_Werror_].opt_text,
2167                        /* Skip over "-W".  */
2168                        cl_options[option_index].opt_text + 2,
2169                        NULL);
2170       /* A warning with option.  */
2171       else
2172         return xstrdup (cl_options[option_index].opt_text);
2173     }
2174   /* A warning without option classified as an error.  */
2175   else if (orig_diag_kind == DK_WARNING || orig_diag_kind == DK_PEDWARN
2176            || diag_kind == DK_WARNING)
2177     {
2178       if (context->warning_as_error_requested)
2179         return xstrdup (cl_options[OPT_Werror].opt_text);
2180       else
2181         return xstrdup (_("enabled by default"));
2182     }
2183   else
2184     return NULL;
2185 }