gcc/opts.c

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