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