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