gcc/opts.c

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