contrib/gcc-5.0/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               { "alignment", SANITIZE_ALIGNMENT, sizeof "alignment" - 1 },
1588               { "nonnull-attribute", SANITIZE_NONNULL_ATTRIBUTE,
1589                 sizeof "nonnull-attribute" - 1 },
1590               { "returns-nonnull-attribute",
1591                 SANITIZE_RETURNS_NONNULL_ATTRIBUTE,
1592                 sizeof "returns-nonnull-attribute" - 1 },
1593               { "object-size", SANITIZE_OBJECT_SIZE,
1594                 sizeof "object-size" - 1 },
1595               { "vptr", SANITIZE_VPTR, sizeof "vptr" - 1 },
1596               { "all", ~0, sizeof "all" - 1 },
1597               { NULL, 0, 0 }
1598             };
1599             const char *comma;
1600             size_t len, i;
1601             bool found = false;
1602
1603             comma = strchr (p, ',');
1604             if (comma == NULL)
1605               len = strlen (p);
1606             else
1607               len = comma - p;
1608             if (len == 0)
1609               {
1610                 p = comma + 1;
1611                 continue;
1612               }
1613
1614             /* Check to see if the string matches an option class name.  */
1615             for (i = 0; spec[i].name != NULL; ++i)
1616               if (len == spec[i].len
1617                   && memcmp (p, spec[i].name, len) == 0)
1618                 {
1619                   /* Handle both -fsanitize and -fno-sanitize cases.  */
1620                   if (value && spec[i].flag == ~0U)
1621                     {
1622                       if (code == OPT_fsanitize_)
1623                         error_at (loc, "-fsanitize=all option is not valid");
1624                       else
1625                         *flag |= ~(SANITIZE_USER_ADDRESS | SANITIZE_THREAD
1626                                    | SANITIZE_LEAK);
1627                     }
1628                   else if (value)
1629                     *flag |= spec[i].flag;
1630                   else
1631                     *flag &= ~spec[i].flag;
1632                   found = true;
1633                   break;
1634                 }
1635
1636             if (! found)
1637               error_at (loc,
1638                         "unrecognized argument to -fsanitize%s= option: %q.*s",
1639                         code == OPT_fsanitize_ ? "" : "-recover", (int) len, p);
1640
1641             if (comma == NULL)
1642               break;
1643             p = comma + 1;
1644           }
1645
1646         if (code != OPT_fsanitize_)
1647           break;
1648
1649         /* Kernel ASan implies normal ASan but does not yet support
1650            all features.  */
1651         if (opts->x_flag_sanitize & SANITIZE_KERNEL_ADDRESS)
1652           {
1653             maybe_set_param_value (PARAM_ASAN_INSTRUMENTATION_WITH_CALL_THRESHOLD, 0,
1654                                    opts->x_param_values,
1655                                    opts_set->x_param_values);
1656             maybe_set_param_value (PARAM_ASAN_GLOBALS, 0,
1657                                    opts->x_param_values,
1658                                    opts_set->x_param_values);
1659             maybe_set_param_value (PARAM_ASAN_STACK, 0,
1660                                    opts->x_param_values,
1661                                    opts_set->x_param_values);
1662             maybe_set_param_value (PARAM_ASAN_USE_AFTER_RETURN, 0,
1663                                    opts->x_param_values,
1664                                    opts_set->x_param_values);
1665           }
1666
1667         break;
1668       }
1669
1670     case OPT_fasan_shadow_offset_:
1671       /* Deferred.  */
1672       break;
1673
1674     case OPT_fsanitize_recover:
1675       if (value)
1676         opts->x_flag_sanitize_recover
1677           |= SANITIZE_UNDEFINED | SANITIZE_NONDEFAULT;
1678       else
1679         opts->x_flag_sanitize_recover
1680           &= ~(SANITIZE_UNDEFINED | SANITIZE_NONDEFAULT);
1681       break;
1682
1683     case OPT_O:
1684     case OPT_Os:
1685     case OPT_Ofast:
1686     case OPT_Og:
1687       /* Currently handled in a prescan.  */
1688       break;
1689
1690     case OPT_Werror:
1691       dc->warning_as_error_requested = value;
1692       break;
1693
1694     case OPT_Werror_:
1695       if (lang_mask == CL_DRIVER)
1696         break;
1697
1698       enable_warning_as_error (arg, value, lang_mask, handlers,
1699                                opts, opts_set, loc, dc);
1700       break;
1701
1702     case OPT_Wlarger_than_:
1703       opts->x_larger_than_size = value;
1704       opts->x_warn_larger_than = value != -1;
1705       break;
1706
1707     case OPT_Wfatal_errors:
1708       dc->fatal_errors = value;
1709       break;
1710
1711     case OPT_Wframe_larger_than_:
1712       opts->x_frame_larger_than_size = value;
1713       opts->x_warn_frame_larger_than = value != -1;
1714       break;
1715
1716     case OPT_Wstack_usage_:
1717       opts->x_warn_stack_usage = value;
1718       opts->x_flag_stack_usage_info = value != -1;
1719       break;
1720
1721     case OPT_Wstrict_aliasing:
1722       set_Wstrict_aliasing (opts, value);
1723       break;
1724
1725     case OPT_Wstrict_overflow:
1726       opts->x_warn_strict_overflow = (value
1727                                       ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
1728                                       : 0);
1729       break;
1730
1731     case OPT_Wsystem_headers:
1732       dc->dc_warn_system_headers = value;
1733       break;
1734
1735     case OPT_aux_info:
1736       opts->x_flag_gen_aux_info = 1;
1737       break;
1738
1739     case OPT_auxbase_strip:
1740       {
1741         char *tmp = xstrdup (arg);
1742         strip_off_ending (tmp, strlen (tmp));
1743         if (tmp[0])
1744           opts->x_aux_base_name = tmp;
1745         else
1746           free (tmp);
1747       }
1748       break;
1749
1750     case OPT_d:
1751       decode_d_option (arg, opts, loc, dc);
1752       break;
1753
1754     case OPT_fcall_used_:
1755     case OPT_fcall_saved_:
1756       /* Deferred.  */
1757       break;
1758
1759     case OPT_fdbg_cnt_:
1760     case OPT_fdbg_cnt_list:
1761       /* Deferred.  */
1762       break;
1763
1764     case OPT_fdebug_prefix_map_:
1765       /* Deferred.  */
1766       break;
1767
1768     case OPT_fdiagnostics_show_location_:
1769       diagnostic_prefixing_rule (dc) = (diagnostic_prefixing_rule_t) value;
1770       break;
1771
1772     case OPT_fdiagnostics_show_caret:
1773       dc->show_caret = value;
1774       break;
1775
1776     case OPT_fdiagnostics_color_:
1777       diagnostic_color_init (dc, value);
1778       break;
1779
1780     case OPT_fdiagnostics_show_option:
1781       dc->show_option_requested = value;
1782       break;
1783
1784     case OPT_fdump_:
1785       /* Deferred.  */
1786       break;
1787
1788     case OPT_ffast_math:
1789       set_fast_math_flags (opts, value);
1790       break;
1791
1792     case OPT_funsafe_math_optimizations:
1793       set_unsafe_math_optimizations_flags (opts, value);
1794       break;
1795
1796     case OPT_ffixed_:
1797       /* Deferred.  */
1798       break;
1799
1800     case OPT_finline_limit_:
1801       set_param_value ("max-inline-insns-single", value / 2,
1802                        opts->x_param_values, opts_set->x_param_values);
1803       set_param_value ("max-inline-insns-auto", value / 2,
1804                        opts->x_param_values, opts_set->x_param_values);
1805       break;
1806
1807     case OPT_finstrument_functions_exclude_function_list_:
1808       add_comma_separated_to_vector
1809         (&opts->x_flag_instrument_functions_exclude_functions, arg);
1810       break;
1811
1812     case OPT_finstrument_functions_exclude_file_list_:
1813       add_comma_separated_to_vector
1814         (&opts->x_flag_instrument_functions_exclude_files, arg);
1815       break;
1816
1817     case OPT_fmessage_length_:
1818       pp_set_line_maximum_length (dc->printer, value);
1819       diagnostic_set_caret_max_width (dc, value);
1820       break;
1821
1822     case OPT_fopt_info:
1823     case OPT_fopt_info_:
1824       /* Deferred.  */
1825       break;
1826
1827     case OPT_foffload_:
1828       /* Deferred.  */
1829       break;
1830
1831 #ifndef ACCEL_COMPILER
1832     case OPT_foffload_abi_:
1833       error_at (loc, "-foffload-abi option can be specified only for "
1834                 "offload compiler");
1835       break;
1836 #endif
1837
1838     case OPT_fpack_struct_:
1839       if (value <= 0 || (value & (value - 1)) || value > 16)
1840         error_at (loc,
1841                   "structure alignment must be a small power of two, not %d",
1842                   value);
1843       else
1844         opts->x_initial_max_fld_align = value;
1845       break;
1846
1847     case OPT_fplugin_:
1848     case OPT_fplugin_arg_:
1849       /* Deferred.  */
1850       break;
1851
1852     case OPT_fprofile_use_:
1853       opts->x_profile_data_prefix = xstrdup (arg);
1854       opts->x_flag_profile_use = true;
1855       value = true;
1856       /* No break here - do -fprofile-use processing. */
1857     case OPT_fprofile_use:
1858       enable_fdo_optimizations (opts, opts_set, value);
1859       if (!opts_set->x_flag_profile_reorder_functions)
1860           opts->x_flag_profile_reorder_functions = value;
1861         /* Indirect call profiling should do all useful transformations
1862            speculative devirtualization does.  */
1863       if (!opts_set->x_flag_devirtualize_speculatively
1864           && opts->x_flag_value_profile_transformations)
1865         opts->x_flag_devirtualize_speculatively = false;
1866       break;
1867
1868     case OPT_fauto_profile_:
1869       opts->x_auto_profile_file = xstrdup (arg);
1870       opts->x_flag_auto_profile = true;
1871       value = true;
1872       /* No break here - do -fauto-profile processing. */
1873     case OPT_fauto_profile:
1874       enable_fdo_optimizations (opts, opts_set, value);
1875       if (!opts_set->x_flag_profile_correction)
1876         opts->x_flag_profile_correction = value;
1877       maybe_set_param_value (
1878         PARAM_EARLY_INLINER_MAX_ITERATIONS, 10,
1879         opts->x_param_values, opts_set->x_param_values);
1880       break;
1881
1882     case OPT_fprofile_generate_:
1883       opts->x_profile_data_prefix = xstrdup (arg);
1884       value = true;
1885       /* No break here - do -fprofile-generate processing. */
1886     case OPT_fprofile_generate:
1887       if (!opts_set->x_profile_arc_flag)
1888         opts->x_profile_arc_flag = value;
1889       if (!opts_set->x_flag_profile_values)
1890         opts->x_flag_profile_values = value;
1891       if (!opts_set->x_flag_inline_functions)
1892         opts->x_flag_inline_functions = value;
1893       /* FIXME: Instrumentation we insert makes ipa-reference bitmaps
1894          quadratic.  Disable the pass until better memory representation
1895          is done.  */
1896       if (!opts_set->x_flag_ipa_reference)
1897         opts->x_flag_ipa_reference = false;
1898       break;
1899
1900     case OPT_ftree_vectorize:
1901       if (!opts_set->x_flag_tree_loop_vectorize)
1902         opts->x_flag_tree_loop_vectorize = value;
1903       if (!opts_set->x_flag_tree_slp_vectorize)
1904         opts->x_flag_tree_slp_vectorize = value;
1905       break;
1906     case OPT_fshow_column:
1907       dc->show_column = value;
1908       break;
1909
1910     case OPT_frandom_seed:
1911       /* The real switch is -fno-random-seed.  */
1912       if (value)
1913         return false;
1914       /* Deferred.  */
1915       break;
1916
1917     case OPT_frandom_seed_:
1918       /* Deferred.  */
1919       break;
1920
1921     case OPT_fsched_verbose_:
1922 #ifdef INSN_SCHEDULING
1923       /* Handled with Var in common.opt.  */
1924       break;
1925 #else
1926       return false;
1927 #endif
1928
1929     case OPT_fsched_stalled_insns_:
1930       opts->x_flag_sched_stalled_insns = value;
1931       if (opts->x_flag_sched_stalled_insns == 0)
1932         opts->x_flag_sched_stalled_insns = -1;
1933       break;
1934
1935     case OPT_fsched_stalled_insns_dep_:
1936       opts->x_flag_sched_stalled_insns_dep = value;
1937       break;
1938
1939     case OPT_fstack_check_:
1940       if (!strcmp (arg, "no"))
1941         opts->x_flag_stack_check = NO_STACK_CHECK;
1942       else if (!strcmp (arg, "generic"))
1943         /* This is the old stack checking method.  */
1944         opts->x_flag_stack_check = STACK_CHECK_BUILTIN
1945                            ? FULL_BUILTIN_STACK_CHECK
1946                            : GENERIC_STACK_CHECK;
1947       else if (!strcmp (arg, "specific"))
1948         /* This is the new stack checking method.  */
1949         opts->x_flag_stack_check = STACK_CHECK_BUILTIN
1950                            ? FULL_BUILTIN_STACK_CHECK
1951                            : STACK_CHECK_STATIC_BUILTIN
1952                              ? STATIC_BUILTIN_STACK_CHECK
1953                              : GENERIC_STACK_CHECK;
1954       else
1955         warning_at (loc, 0, "unknown stack check parameter %qs", arg);
1956       break;
1957
1958     case OPT_fstack_limit:
1959       /* The real switch is -fno-stack-limit.  */
1960       if (value)
1961         return false;
1962       /* Deferred.  */
1963       break;
1964
1965     case OPT_fstack_limit_register_:
1966     case OPT_fstack_limit_symbol_:
1967       /* Deferred.  */
1968       break;
1969
1970     case OPT_fstack_usage:
1971       opts->x_flag_stack_usage = value;
1972       opts->x_flag_stack_usage_info = value != 0;
1973       break;
1974
1975     case OPT_g:
1976       set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg, opts, opts_set,
1977                        loc);
1978       break;
1979
1980     case OPT_gcoff:
1981       set_debug_level (SDB_DEBUG, false, arg, opts, opts_set, loc);
1982       break;
1983
1984     case OPT_gdwarf:
1985       if (arg && strlen (arg) != 0)
1986         {
1987           error_at (loc, "%<-gdwarf%s%> is ambiguous; "
1988                     "use %<-gdwarf-%s%> for DWARF version "
1989                     "or %<-gdwarf -g%s%> for debug level", arg, arg, arg);
1990           break;
1991         }
1992       else
1993         value = opts->x_dwarf_version;
1994
1995       /* FALLTHRU */
1996     case OPT_gdwarf_:
1997       if (value < 2 || value > 5)
1998         error_at (loc, "dwarf version %d is not supported", value);
1999       else
2000         opts->x_dwarf_version = value;
2001       set_debug_level (DWARF2_DEBUG, false, "", opts, opts_set, loc);
2002       break;
2003
2004     case OPT_gsplit_dwarf:
2005       set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, "", opts, opts_set,
2006                        loc);
2007       break;
2008
2009     case OPT_ggdb:
2010       set_debug_level (NO_DEBUG, 2, arg, opts, opts_set, loc);
2011       break;
2012
2013     case OPT_gstabs:
2014     case OPT_gstabs_:
2015       set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg, opts, opts_set,
2016                        loc);
2017       break;
2018
2019     case OPT_gvms:
2020       set_debug_level (VMS_DEBUG, false, arg, opts, opts_set, loc);
2021       break;
2022
2023     case OPT_gxcoff:
2024     case OPT_gxcoff_:
2025       set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg, opts, opts_set,
2026                        loc);
2027       break;
2028
2029     case OPT_gz:
2030     case OPT_gz_:
2031       /* Handled completely via specs.  */
2032       break;
2033
2034     case OPT_pedantic_errors:
2035       dc->pedantic_errors = 1;
2036       control_warning_option (OPT_Wpedantic, DK_ERROR, value,
2037                               loc, lang_mask,
2038                               handlers, opts, opts_set,
2039                               dc);
2040       break;
2041
2042     case OPT_flto:
2043       opts->x_flag_lto = value ? "" : NULL;
2044       break;
2045
2046     case OPT_w:
2047       dc->dc_inhibit_warnings = true;
2048       break;
2049
2050     case OPT_fmax_errors_:
2051       dc->max_errors = value;
2052       break;
2053
2054     case OPT_fuse_ld_bfd:
2055     case OPT_fuse_ld_gold:
2056     case OPT_fuse_linker_plugin:
2057       /* No-op. Used by the driver and passed to us because it starts with f.*/
2058       break;
2059
2060     case OPT_fwrapv:
2061       if (value)
2062         opts->x_flag_trapv = 0;
2063       break;
2064
2065     case OPT_ftrapv:
2066       if (value)
2067         opts->x_flag_wrapv = 0;
2068       break;
2069
2070     case OPT_fipa_icf:
2071       opts->x_flag_ipa_icf_functions = value;
2072       opts->x_flag_ipa_icf_variables = value;
2073       break;
2074
2075     default:
2076       /* If the flag was handled in a standard way, assume the lack of
2077          processing here is intentional.  */
2078       gcc_assert (option_flag_var (scode, opts));
2079       break;
2080     }
2081
2082   common_handle_option_auto (opts, opts_set, decoded, lang_mask, kind,
2083                              loc, handlers, dc);
2084   return true;
2085 }
2086
2087 /* Handle --param NAME=VALUE.  */
2088 static void
2089 handle_param (struct gcc_options *opts, struct gcc_options *opts_set,
2090               location_t loc, const char *carg)
2091 {
2092   char *equal, *arg;
2093   int value;
2094
2095   arg = xstrdup (carg);
2096   equal = strchr (arg, '=');
2097   if (!equal)
2098     error_at (loc, "%s: --param arguments should be of the form NAME=VALUE",
2099               arg);
2100   else
2101     {
2102       value = integral_argument (equal + 1);
2103       if (value == -1)
2104         error_at (loc, "invalid --param value %qs", equal + 1);
2105       else
2106         {
2107           *equal = '\0';
2108           set_param_value (arg, value,
2109                            opts->x_param_values, opts_set->x_param_values);
2110         }
2111     }
2112
2113   free (arg);
2114 }
2115
2116 /* Used to set the level of strict aliasing warnings in OPTS,
2117    when no level is specified (i.e., when -Wstrict-aliasing, and not
2118    -Wstrict-aliasing=level was given).
2119    ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
2120    and 0 otherwise.  After calling this function, wstrict_aliasing will be
2121    set to the default value of -Wstrict_aliasing=level, currently 3.  */
2122 static void
2123 set_Wstrict_aliasing (struct gcc_options *opts, int onoff)
2124 {
2125   gcc_assert (onoff == 0 || onoff == 1);
2126   if (onoff != 0)
2127     opts->x_warn_strict_aliasing = 3;
2128   else
2129     opts->x_warn_strict_aliasing = 0;
2130 }
2131
2132 /* The following routines are useful in setting all the flags that
2133    -ffast-math and -fno-fast-math imply.  */
2134 static void
2135 set_fast_math_flags (struct gcc_options *opts, int set)
2136 {
2137   if (!opts->frontend_set_flag_unsafe_math_optimizations)
2138     {
2139       opts->x_flag_unsafe_math_optimizations = set;
2140       set_unsafe_math_optimizations_flags (opts, set);
2141     }
2142   if (!opts->frontend_set_flag_finite_math_only)
2143     opts->x_flag_finite_math_only = set;
2144   if (!opts->frontend_set_flag_errno_math)
2145     opts->x_flag_errno_math = !set;
2146   if (set)
2147     {
2148       if (!opts->frontend_set_flag_signaling_nans)
2149         opts->x_flag_signaling_nans = 0;
2150       if (!opts->frontend_set_flag_rounding_math)
2151         opts->x_flag_rounding_math = 0;
2152       if (!opts->frontend_set_flag_cx_limited_range)
2153         opts->x_flag_cx_limited_range = 1;
2154     }
2155 }
2156
2157 /* When -funsafe-math-optimizations is set the following
2158    flags are set as well.  */
2159 static void
2160 set_unsafe_math_optimizations_flags (struct gcc_options *opts, int set)
2161 {
2162   if (!opts->frontend_set_flag_trapping_math)
2163     opts->x_flag_trapping_math = !set;
2164   if (!opts->frontend_set_flag_signed_zeros)
2165     opts->x_flag_signed_zeros = !set;
2166   if (!opts->frontend_set_flag_associative_math)
2167     opts->x_flag_associative_math = set;
2168   if (!opts->frontend_set_flag_reciprocal_math)
2169     opts->x_flag_reciprocal_math = set;
2170 }
2171
2172 /* Return true iff flags in OPTS are set as if -ffast-math.  */
2173 bool
2174 fast_math_flags_set_p (const struct gcc_options *opts)
2175 {
2176   return (!opts->x_flag_trapping_math
2177           && opts->x_flag_unsafe_math_optimizations
2178           && opts->x_flag_finite_math_only
2179           && !opts->x_flag_signed_zeros
2180           && !opts->x_flag_errno_math);
2181 }
2182
2183 /* Return true iff flags are set as if -ffast-math but using the flags stored
2184    in the struct cl_optimization structure.  */
2185 bool
2186 fast_math_flags_struct_set_p (struct cl_optimization *opt)
2187 {
2188   return (!opt->x_flag_trapping_math
2189           && opt->x_flag_unsafe_math_optimizations
2190           && opt->x_flag_finite_math_only
2191           && !opt->x_flag_signed_zeros
2192           && !opt->x_flag_errno_math);
2193 }
2194
2195 /* Handle a debug output -g switch for options OPTS
2196    (OPTS_SET->x_write_symbols storing whether a debug type was passed
2197    explicitly), location LOC.  EXTENDED is true or false to support
2198    extended output (2 is special and means "-ggdb" was given).  */
2199 static void
2200 set_debug_level (enum debug_info_type type, int extended, const char *arg,
2201                  struct gcc_options *opts, struct gcc_options *opts_set,
2202                  location_t loc)
2203 {
2204   opts->x_use_gnu_debug_info_extensions = extended;
2205
2206   if (type == NO_DEBUG)
2207     {
2208       if (opts->x_write_symbols == NO_DEBUG)
2209         {
2210           opts->x_write_symbols = PREFERRED_DEBUGGING_TYPE;
2211
2212           if (extended == 2)
2213             {
2214 #ifdef DWARF2_DEBUGGING_INFO
2215               opts->x_write_symbols = DWARF2_DEBUG;
2216 #elif defined DBX_DEBUGGING_INFO
2217               opts->x_write_symbols = DBX_DEBUG;
2218 #endif
2219             }
2220
2221           if (opts->x_write_symbols == NO_DEBUG)
2222             warning_at (loc, 0, "target system does not support debug output");
2223         }
2224     }
2225   else
2226     {
2227       /* Does it conflict with an already selected type?  */
2228       if (opts_set->x_write_symbols != NO_DEBUG
2229           && opts->x_write_symbols != NO_DEBUG
2230           && type != opts->x_write_symbols)
2231         error_at (loc, "debug format %qs conflicts with prior selection",
2232                   debug_type_names[type]);
2233       opts->x_write_symbols = type;
2234       opts_set->x_write_symbols = type;
2235     }
2236
2237   /* A debug flag without a level defaults to level 2.
2238      If off or at level 1, set it to level 2, but if already
2239      at level 3, don't lower it.  */
2240   if (*arg == '\0')
2241     {
2242       if (opts->x_debug_info_level < DINFO_LEVEL_NORMAL)
2243         opts->x_debug_info_level = DINFO_LEVEL_NORMAL;
2244     }
2245   else
2246     {
2247       int argval = integral_argument (arg);
2248       if (argval == -1)
2249         error_at (loc, "unrecognised debug output level %qs", arg);
2250       else if (argval > 3)
2251         error_at (loc, "debug output level %qs is too high", arg);
2252       else
2253         opts->x_debug_info_level = (enum debug_info_levels) argval;
2254     }
2255 }
2256
2257 /* Arrange to dump core on error for diagnostic context DC.  (The
2258    regular error message is still printed first, except in the case of
2259    abort ().)  */
2260
2261 static void
2262 setup_core_dumping (diagnostic_context *dc)
2263 {
2264 #ifdef SIGABRT
2265   signal (SIGABRT, SIG_DFL);
2266 #endif
2267 #if defined(HAVE_SETRLIMIT)
2268   {
2269     struct rlimit rlim;
2270     if (getrlimit (RLIMIT_CORE, &rlim) != 0)
2271       fatal_error (input_location, "getting core file size maximum limit: %m");
2272     rlim.rlim_cur = rlim.rlim_max;
2273     if (setrlimit (RLIMIT_CORE, &rlim) != 0)
2274       fatal_error (input_location,
2275                    "setting core file size limit to maximum: %m");
2276   }
2277 #endif
2278   diagnostic_abort_on_error (dc);
2279 }
2280
2281 /* Parse a -d<ARG> command line switch for OPTS, location LOC,
2282    diagnostic context DC.  */
2283
2284 static void
2285 decode_d_option (const char *arg, struct gcc_options *opts,
2286                  location_t loc, diagnostic_context *dc)
2287 {
2288   int c;
2289
2290   while (*arg)
2291     switch (c = *arg++)
2292       {
2293       case 'A':
2294         opts->x_flag_debug_asm = 1;
2295         break;
2296       case 'p':
2297         opts->x_flag_print_asm_name = 1;
2298         break;
2299       case 'P':
2300         opts->x_flag_dump_rtl_in_asm = 1;
2301         opts->x_flag_print_asm_name = 1;
2302         break;
2303       case 'x':
2304         opts->x_rtl_dump_and_exit = 1;
2305         break;
2306       case 'D': /* These are handled by the preprocessor.  */
2307       case 'I':
2308       case 'M':
2309       case 'N':
2310       case 'U':
2311         break;
2312       case 'H':
2313         setup_core_dumping (dc);
2314         break;
2315       case 'a':
2316         opts->x_flag_dump_all_passed = true;
2317         break;
2318
2319       default:
2320           warning_at (loc, 0, "unrecognized gcc debugging option: %c", c);
2321         break;
2322       }
2323 }
2324
2325 /* Enable (or disable if VALUE is 0) a warning option ARG (language
2326    mask LANG_MASK, option handlers HANDLERS) as an error for option
2327    structures OPTS and OPTS_SET, diagnostic context DC (possibly
2328    NULL), location LOC.  This is used by -Werror=.  */
2329
2330 static void
2331 enable_warning_as_error (const char *arg, int value, unsigned int lang_mask,
2332                          const struct cl_option_handlers *handlers,
2333                          struct gcc_options *opts,
2334                          struct gcc_options *opts_set,
2335                          location_t loc, diagnostic_context *dc)
2336 {
2337   char *new_option;
2338   int option_index;
2339
2340   new_option = XNEWVEC (char, strlen (arg) + 2);
2341   new_option[0] = 'W';
2342   strcpy (new_option + 1, arg);
2343   option_index = find_opt (new_option, lang_mask);
2344   if (option_index == OPT_SPECIAL_unknown)
2345     {
2346       error_at (loc, "-Werror=%s: no option -%s", arg, new_option);
2347     }
2348   else
2349     {
2350       const diagnostic_t kind = value ? DK_ERROR : DK_WARNING;
2351
2352       control_warning_option (option_index, (int) kind, value,
2353                               loc, lang_mask,
2354                               handlers, opts, opts_set, dc);
2355     }
2356   free (new_option);
2357 }
2358
2359 /* Return malloced memory for the name of the option OPTION_INDEX
2360    which enabled a diagnostic (context CONTEXT), originally of type
2361    ORIG_DIAG_KIND but possibly converted to DIAG_KIND by options such
2362    as -Werror.  */
2363
2364 char *
2365 option_name (diagnostic_context *context, int option_index,
2366              diagnostic_t orig_diag_kind, diagnostic_t diag_kind)
2367 {
2368   if (option_index)
2369     {
2370       /* A warning classified as an error.  */
2371       if ((orig_diag_kind == DK_WARNING || orig_diag_kind == DK_PEDWARN)
2372           && diag_kind == DK_ERROR)
2373         return concat (cl_options[OPT_Werror_].opt_text,
2374                        /* Skip over "-W".  */
2375                        cl_options[option_index].opt_text + 2,
2376                        NULL);
2377       /* A warning with option.  */
2378       else
2379         return xstrdup (cl_options[option_index].opt_text);
2380     }
2381   /* A warning without option classified as an error.  */
2382   else if ((orig_diag_kind == DK_WARNING || orig_diag_kind == DK_PEDWARN
2383             || diag_kind == DK_WARNING)
2384            && context->warning_as_error_requested)
2385     return xstrdup (cl_options[OPT_Werror].opt_text);
2386   else
2387     return NULL;
2388 }