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