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