gcc/opts.c

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