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