gcc/opts.c

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