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