gcc/opts.c

   1 /* Command line option handling.
   2    Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
   3    Free Software Foundation, Inc.
   4    Contributed by Neil Booth.
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 3, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "intl.h"
  25 #include "coretypes.h"
  26 #include "tm.h" /* Needed by rtl.h and used for STACK_CHECK_BUILTIN,
  27                    STACK_CHECK_STATIC_BUILTIN, DEFAULT_GDB_EXTENSIONS,
  28                    DWARF2_DEBUGGING_INFO and DBX_DEBUGGING_INFO.  */
  29 #include "rtl.h" /* Needed by insn-attr.h.  */
  30 #include "opts.h"
  31 #include "options.h"
  32 #include "flags.h"
  33 #include "params.h"
  34 #include "diagnostic.h"
  35 #include "opts-diagnostic.h"
  36 #include "insn-attr.h"          /* For INSN_SCHEDULING and DELAY_SLOTS.  */
  37 #include "common/common-target.h"
  38
  39 /* Parse the -femit-struct-debug-detailed option value
  40    and set the flag variables. */
  41
  42 #define MATCH( prefix, string ) \
  43   ((strncmp (prefix, string, sizeof prefix - 1) == 0) \
  44    ? ((string += sizeof prefix - 1), 1) : 0)
  45
  46 void
  47 set_struct_debug_option (struct gcc_options *opts, location_t loc,
  48                          const char *spec)
  49 {
  50   /* various labels for comparison */
  51   static const char dfn_lbl[] = "dfn:", dir_lbl[] = "dir:", ind_lbl[] = "ind:";
  52   static const char ord_lbl[] = "ord:", gen_lbl[] = "gen:";
  53   static const char none_lbl[] = "none", any_lbl[] = "any";
  54   static const char base_lbl[] = "base", sys_lbl[] = "sys";
  55
  56   enum debug_struct_file files = DINFO_STRUCT_FILE_ANY;
  57   /* Default is to apply to as much as possible. */
  58   enum debug_info_usage usage = DINFO_USAGE_NUM_ENUMS;
  59   int ord = 1, gen = 1;
  60
  61   /* What usage? */
  62   if (MATCH (dfn_lbl, spec))
  63     usage = DINFO_USAGE_DFN;
  64   else if (MATCH (dir_lbl, spec))
  65     usage = DINFO_USAGE_DIR_USE;
  66   else if (MATCH (ind_lbl, spec))
  67     usage = DINFO_USAGE_IND_USE;
  68
  69   /* Generics or not? */
  70   if (MATCH (ord_lbl, spec))
  71     gen = 0;
  72   else if (MATCH (gen_lbl, spec))
  73     ord = 0;
  74
  75   /* What allowable environment? */
  76   if (MATCH (none_lbl, spec))
  77     files = DINFO_STRUCT_FILE_NONE;
  78   else if (MATCH (any_lbl, spec))
  79     files = DINFO_STRUCT_FILE_ANY;
  80   else if (MATCH (sys_lbl, spec))
  81     files = DINFO_STRUCT_FILE_SYS;
  82   else if (MATCH (base_lbl, spec))
  83     files = DINFO_STRUCT_FILE_BASE;
  84   else
  85     error_at (loc,
  86               "argument %qs to %<-femit-struct-debug-detailed%> "
  87               "not recognized",
  88               spec);
  89
  90   /* Effect the specification. */
  91   if (usage == DINFO_USAGE_NUM_ENUMS)
  92     {
  93       if (ord)
  94         {
  95           opts->x_debug_struct_ordinary[DINFO_USAGE_DFN] = files;
  96           opts->x_debug_struct_ordinary[DINFO_USAGE_DIR_USE] = files;
  97           opts->x_debug_struct_ordinary[DINFO_USAGE_IND_USE] = files;
  98         }
  99       if (gen)
 100         {
 101           opts->x_debug_struct_generic[DINFO_USAGE_DFN] = files;
 102           opts->x_debug_struct_generic[DINFO_USAGE_DIR_USE] = files;
 103           opts->x_debug_struct_generic[DINFO_USAGE_IND_USE] = files;
 104         }
 105     }
 106   else
 107     {
 108       if (ord)
 109         opts->x_debug_struct_ordinary[usage] = files;
 110       if (gen)
 111         opts->x_debug_struct_generic[usage] = files;
 112     }
 113
 114   if (*spec == ',')
 115     set_struct_debug_option (opts, loc, spec+1);
 116   else
 117     {
 118       /* No more -femit-struct-debug-detailed specifications.
 119          Do final checks. */
 120       if (*spec != '\0')
 121         error_at (loc,
 122                   "argument %qs to %<-femit-struct-debug-detailed%> unknown",
 123                   spec);
 124       if (opts->x_debug_struct_ordinary[DINFO_USAGE_DIR_USE]
 125                 < opts->x_debug_struct_ordinary[DINFO_USAGE_IND_USE]
 126           || opts->x_debug_struct_generic[DINFO_USAGE_DIR_USE]
 127                 < opts->x_debug_struct_generic[DINFO_USAGE_IND_USE])
 128         error_at (loc,
 129                   "%<-femit-struct-debug-detailed=dir:...%> must allow "
 130                   "at least as much as "
 131                   "%<-femit-struct-debug-detailed=ind:...%>");
 132     }
 133 }
 134
 135 /* Handle -ftree-vectorizer-verbose=VAL for options OPTS.  */
 136
 137 static void
 138 vect_set_verbosity_level (struct gcc_options *opts, int val)
 139 {
 140    if (val < MAX_VERBOSITY_LEVEL)
 141      opts->x_user_vect_verbosity_level = (enum vect_verbosity_levels) val;
 142    else
 143      opts->x_user_vect_verbosity_level
 144       = (enum vect_verbosity_levels) (MAX_VERBOSITY_LEVEL - 1);
 145 }
 146
 147
 148 /* Strip off a legitimate source ending from the input string NAME of
 149    length LEN.  Rather than having to know the names used by all of
 150    our front ends, we strip off an ending of a period followed by
 151    up to five characters.  (Java uses ".class".)  */
 152
 153 void
 154 strip_off_ending (char *name, int len)
 155 {
 156   int i;
 157   for (i = 2; i < 6 && len > i; i++)
 158     {
 159       if (name[len - i] == '.')
 160         {
 161           name[len - i] = '\0';
 162           break;
 163         }
 164     }
 165 }
 166
 167 /* Find the base name of a path, stripping off both directories and
 168    a single final extension. */
 169 int
 170 base_of_path (const char *path, const char **base_out)
 171 {
 172   const char *base = path;
 173   const char *dot = 0;
 174   const char *p = path;
 175   char c = *p;
 176   while (c)
 177     {
 178       if (IS_DIR_SEPARATOR(c))
 179         {
 180           base = p + 1;
 181           dot = 0;
 182         }
 183       else if (c == '.')
 184         dot = p;
 185       c = *++p;
 186     }
 187   if (!dot)
 188     dot = p;
 189   *base_out = base;
 190   return dot - base;
 191 }
 192
 193 /* What to print when a switch has no documentation.  */
 194 static const char undocumented_msg[] = N_("This switch lacks documentation");
 195
 196 typedef char *char_p; /* For DEF_VEC_P.  */
 197 DEF_VEC_P(char_p);
 198 DEF_VEC_ALLOC_P(char_p,heap);
 199
 200 static void handle_param (struct gcc_options *opts,
 201                           struct gcc_options *opts_set, location_t loc,
 202                           const char *carg);
 203 static void set_debug_level (enum debug_info_type type, int extended,
 204                              const char *arg, struct gcc_options *opts,
 205                              struct gcc_options *opts_set,
 206                              location_t loc);
 207 static void set_fast_math_flags (struct gcc_options *opts, int set);
 208 static void decode_d_option (const char *arg, struct gcc_options *opts,
 209                              location_t loc, diagnostic_context *dc);
 210 static void set_unsafe_math_optimizations_flags (struct gcc_options *opts,
 211                                                  int set);
 212 static void enable_warning_as_error (const char *arg, int value,
 213                                      unsigned int lang_mask,
 214                                      const struct cl_option_handlers *handlers,
 215                                      struct gcc_options *opts,
 216                                      struct gcc_options *opts_set,
 217                                      location_t loc,
 218                                      diagnostic_context *dc);
 219
 220 /* Handle a back-end option; arguments and return value as for
 221    handle_option.  */
 222
 223 bool
 224 target_handle_option (struct gcc_options *opts,
 225                       struct gcc_options *opts_set,
 226                       const struct cl_decoded_option *decoded,
 227                       unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
 228                       location_t loc,
 229                       const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED,
 230                       diagnostic_context *dc)
 231 {
 232   gcc_assert (dc == global_dc);
 233   gcc_assert (kind == DK_UNSPECIFIED);
 234   return targetm_common.handle_option (opts, opts_set, decoded, loc);
 235 }
 236
 237 /* Add comma-separated strings to a char_p vector.  */
 238
 239 static void
 240 add_comma_separated_to_vector (void **pvec, const char *arg)
 241 {
 242   char *tmp;
 243   char *r;
 244   char *w;
 245   char *token_start;
 246   VEC(char_p,heap) *vec = (VEC(char_p,heap) *) *pvec;
 247
 248   /* We never free this string.  */
 249   tmp = xstrdup (arg);
 250
 251   r = tmp;
 252   w = tmp;
 253   token_start = tmp;
 254
 255   while (*r != '\0')
 256     {
 257       if (*r == ',')
 258         {
 259           *w++ = '\0';
 260           ++r;
 261           VEC_safe_push (char_p, heap, vec, token_start);
 262           token_start = w;
 263         }
 264       if (*r == '\\' && r[1] == ',')
 265         {
 266           *w++ = ',';
 267           r += 2;
 268         }
 269       else
 270         *w++ = *r++;
 271     }
 272   if (*token_start != '\0')
 273     VEC_safe_push (char_p, heap, vec, token_start);
 274
 275   *pvec = vec;
 276 }
 277
 278 /* Initialize OPTS and OPTS_SET before using them in parsing options.  */
 279
 280 void
 281 init_options_struct (struct gcc_options *opts, struct gcc_options *opts_set)
 282 {
 283   size_t num_params = get_num_compiler_params ();
 284
 285   *opts = global_options_init;
 286   memset (opts_set, 0, sizeof (*opts_set));
 287
 288   opts->x_param_values = XNEWVEC (int, num_params);
 289   opts_set->x_param_values = XCNEWVEC (int, num_params);
 290   init_param_values (opts->x_param_values);
 291
 292   /* Initialize whether `char' is signed.  */
 293   opts->x_flag_signed_char = DEFAULT_SIGNED_CHAR;
 294   /* Set this to a special "uninitialized" value.  The actual default
 295      is set after target options have been processed.  */
 296   opts->x_flag_short_enums = 2;
 297
 298   /* Initialize target_flags before default_options_optimization
 299      so the latter can modify it.  */
 300   opts->x_target_flags = targetm_common.default_target_flags;
 301
 302   /* Some targets have ABI-specified unwind tables.  */
 303   opts->x_flag_unwind_tables = targetm_common.unwind_tables_default;
 304
 305   /* Some targets have other target-specific initialization.  */
 306   targetm_common.option_init_struct (opts);
 307 }
 308
 309 /* If indicated by the optimization level LEVEL (-Os if SIZE is set,
 310    -Ofast if FAST is set), apply the option DEFAULT_OPT to OPTS and
 311    OPTS_SET, diagnostic context DC, location LOC, with language mask
 312    LANG_MASK and option handlers HANDLERS.  */
 313
 314 static void
 315 maybe_default_option (struct gcc_options *opts,
 316                       struct gcc_options *opts_set,
 317                       const struct default_options *default_opt,
 318                       int level, bool size, bool fast,
 319                       unsigned int lang_mask,
 320                       const struct cl_option_handlers *handlers,
 321                       location_t loc,
 322                       diagnostic_context *dc)
 323 {
 324   const struct cl_option *option = &cl_options[default_opt->opt_index];
 325   bool enabled;
 326
 327   if (size)
 328     gcc_assert (level == 2);
 329   if (fast)
 330     gcc_assert (level == 3);
 331
 332   switch (default_opt->levels)
 333     {
 334     case OPT_LEVELS_ALL:
 335       enabled = true;
 336       break;
 337
 338     case OPT_LEVELS_0_ONLY:
 339       enabled = (level == 0);
 340       break;
 341
 342     case OPT_LEVELS_1_PLUS:
 343       enabled = (level >= 1);
 344       break;
 345
 346     case OPT_LEVELS_1_PLUS_SPEED_ONLY:
 347       enabled = (level >= 1 && !size);
 348       break;
 349
 350     case OPT_LEVELS_2_PLUS:
 351       enabled = (level >= 2);
 352       break;
 353
 354     case OPT_LEVELS_2_PLUS_SPEED_ONLY:
 355       enabled = (level >= 2 && !size);
 356       break;
 357
 358     case OPT_LEVELS_3_PLUS:
 359       enabled = (level >= 3);
 360       break;
 361
 362     case OPT_LEVELS_3_PLUS_AND_SIZE:
 363       enabled = (level >= 3 || size);
 364       break;
 365
 366     case OPT_LEVELS_SIZE:
 367       enabled = size;
 368       break;
 369
 370     case OPT_LEVELS_FAST:
 371       enabled = fast;
 372       break;
 373
 374     case OPT_LEVELS_NONE:
 375     default:
 376       gcc_unreachable ();
 377     }
 378
 379   if (enabled)
 380     handle_generated_option (opts, opts_set, default_opt->opt_index,
 381                              default_opt->arg, default_opt->value,
 382                              lang_mask, DK_UNSPECIFIED, loc,
 383                              handlers, dc);
 384   else if (default_opt->arg == NULL
 385            && !option->cl_reject_negative)
 386     handle_generated_option (opts, opts_set, default_opt->opt_index,
 387                              default_opt->arg, !default_opt->value,
 388                              lang_mask, DK_UNSPECIFIED, loc,
 389                              handlers, dc);
 390 }
 391
 392 /* As indicated by the optimization level LEVEL (-Os if SIZE is set,
 393    -Ofast if FAST is set), apply the options in array DEFAULT_OPTS to
 394    OPTS and OPTS_SET, diagnostic context DC, location LOC, with
 395    language mask LANG_MASK and option handlers HANDLERS.  */
 396
 397 static void
 398 maybe_default_options (struct gcc_options *opts,
 399                        struct gcc_options *opts_set,
 400                        const struct default_options *default_opts,
 401                        int level, bool size, bool fast,
 402                        unsigned int lang_mask,
 403                        const struct cl_option_handlers *handlers,
 404                        location_t loc,
 405                        diagnostic_context *dc)
 406 {
 407   size_t i;
 408
 409   for (i = 0; default_opts[i].levels != OPT_LEVELS_NONE; i++)
 410     maybe_default_option (opts, opts_set, &default_opts[i],
 411                           level, size, fast, lang_mask, handlers, loc, dc);
 412 }
 413
 414 /* Table of options enabled by default at different levels.  */
 415
 416 static const struct default_options default_options_table[] =
 417   {
 418     /* -O1 optimizations.  */
 419     { OPT_LEVELS_1_PLUS, OPT_fdefer_pop, NULL, 1 },
 420 #ifdef DELAY_SLOTS
 421     { OPT_LEVELS_1_PLUS, OPT_fdelayed_branch, NULL, 1 },
 422 #endif
 423     { OPT_LEVELS_1_PLUS, OPT_fguess_branch_probability, NULL, 1 },
 424     { OPT_LEVELS_1_PLUS, OPT_fcprop_registers, NULL, 1 },
 425     { OPT_LEVELS_1_PLUS, OPT_fforward_propagate, NULL, 1 },
 426     { OPT_LEVELS_1_PLUS, OPT_fif_conversion, NULL, 1 },
 427     { OPT_LEVELS_1_PLUS, OPT_fif_conversion2, NULL, 1 },
 428     { OPT_LEVELS_1_PLUS, OPT_fipa_pure_const, NULL, 1 },
 429     { OPT_LEVELS_1_PLUS, OPT_fipa_reference, NULL, 1 },
 430     { OPT_LEVELS_1_PLUS, OPT_fipa_profile, NULL, 1 },
 431     { OPT_LEVELS_1_PLUS, OPT_fmerge_constants, NULL, 1 },
 432     { OPT_LEVELS_1_PLUS, OPT_fsplit_wide_types, NULL, 1 },
 433     { OPT_LEVELS_1_PLUS, OPT_ftree_ccp, NULL, 1 },
 434     { OPT_LEVELS_1_PLUS, OPT_ftree_bit_ccp, NULL, 1 },
 435     { OPT_LEVELS_1_PLUS, OPT_ftree_dce, NULL, 1 },
 436     { OPT_LEVELS_1_PLUS, OPT_ftree_dominator_opts, NULL, 1 },
 437     { OPT_LEVELS_1_PLUS, OPT_ftree_dse, NULL, 1 },
 438     { OPT_LEVELS_1_PLUS, OPT_ftree_ter, NULL, 1 },
 439     { OPT_LEVELS_1_PLUS, OPT_ftree_sra, NULL, 1 },
 440     { OPT_LEVELS_1_PLUS, OPT_ftree_copyrename, NULL, 1 },
 441     { OPT_LEVELS_1_PLUS, OPT_ftree_fre, NULL, 1 },
 442     { OPT_LEVELS_1_PLUS, OPT_ftree_copy_prop, NULL, 1 },
 443     { OPT_LEVELS_1_PLUS, OPT_ftree_sink, NULL, 1 },
 444     { OPT_LEVELS_1_PLUS, OPT_ftree_ch, NULL, 1 },
 445     { OPT_LEVELS_1_PLUS, OPT_fcombine_stack_adjustments, NULL, 1 },
 446     { OPT_LEVELS_1_PLUS, OPT_fcompare_elim, NULL, 1 },
 447
 448     /* -O2 optimizations.  */
 449     { OPT_LEVELS_2_PLUS, OPT_finline_small_functions, NULL, 1 },
 450     { OPT_LEVELS_2_PLUS, OPT_findirect_inlining, NULL, 1 },
 451     { OPT_LEVELS_2_PLUS, OPT_fpartial_inlining, NULL, 1 },
 452     { OPT_LEVELS_2_PLUS, OPT_fthread_jumps, NULL, 1 },
 453     { OPT_LEVELS_2_PLUS, OPT_fcrossjumping, NULL, 1 },
 454     { OPT_LEVELS_2_PLUS, OPT_foptimize_sibling_calls, NULL, 1 },
 455     { OPT_LEVELS_2_PLUS, OPT_fcse_follow_jumps, NULL, 1 },
 456     { OPT_LEVELS_2_PLUS, OPT_fgcse, NULL, 1 },
 457     { OPT_LEVELS_2_PLUS, OPT_fexpensive_optimizations, NULL, 1 },
 458     { OPT_LEVELS_2_PLUS, OPT_frerun_cse_after_loop, NULL, 1 },
 459     { OPT_LEVELS_2_PLUS, OPT_fcaller_saves, NULL, 1 },
 460     { OPT_LEVELS_2_PLUS, OPT_fpeephole2, NULL, 1 },
 461 #ifdef INSN_SCHEDULING
 462   /* Only run the pre-regalloc scheduling pass if optimizing for speed.  */
 463     { OPT_LEVELS_2_PLUS_SPEED_ONLY, OPT_fschedule_insns, NULL, 1 },
 464     { OPT_LEVELS_2_PLUS, OPT_fschedule_insns2, NULL, 1 },
 465 #endif
 466     { OPT_LEVELS_2_PLUS, OPT_fregmove, NULL, 1 },
 467     { OPT_LEVELS_2_PLUS, OPT_fstrict_aliasing, NULL, 1 },
 468     { OPT_LEVELS_2_PLUS, OPT_fstrict_overflow, NULL, 1 },
 469     { OPT_LEVELS_2_PLUS, OPT_freorder_blocks, NULL, 1 },
 470     { OPT_LEVELS_2_PLUS, OPT_freorder_functions, NULL, 1 },
 471     { OPT_LEVELS_2_PLUS, OPT_ftree_vrp, NULL, 1 },
 472     { OPT_LEVELS_2_PLUS, OPT_ftree_builtin_call_dce, NULL, 1 },
 473     { OPT_LEVELS_2_PLUS, OPT_ftree_pre, NULL, 1 },
 474     { OPT_LEVELS_2_PLUS, OPT_ftree_switch_conversion, NULL, 1 },
 475     { OPT_LEVELS_2_PLUS, OPT_fipa_cp, NULL, 1 },
 476     { OPT_LEVELS_2_PLUS, OPT_fdevirtualize, NULL, 1 },
 477     { OPT_LEVELS_2_PLUS, OPT_fipa_sra, NULL, 1 },
 478     { OPT_LEVELS_2_PLUS, OPT_falign_loops, NULL, 1 },
 479     { OPT_LEVELS_2_PLUS, OPT_falign_jumps, NULL, 1 },
 480     { OPT_LEVELS_2_PLUS, OPT_falign_labels, NULL, 1 },
 481     { OPT_LEVELS_2_PLUS, OPT_falign_functions, NULL, 1 },
 482
 483     /* -O3 optimizations.  */
 484     { OPT_LEVELS_3_PLUS, OPT_ftree_loop_distribute_patterns, NULL, 1 },
 485     { OPT_LEVELS_3_PLUS, OPT_fpredictive_commoning, NULL, 1 },
 486     /* Inlining of functions reducing size is a good idea with -Os
 487        regardless of them being declared inline.  */
 488     { OPT_LEVELS_3_PLUS_AND_SIZE, OPT_finline_functions, NULL, 1 },
 489     { OPT_LEVELS_1_PLUS, OPT_finline_functions_called_once, NULL, 1 },
 490     { OPT_LEVELS_3_PLUS, OPT_funswitch_loops, NULL, 1 },
 491     { OPT_LEVELS_3_PLUS, OPT_fgcse_after_reload, NULL, 1 },
 492     { OPT_LEVELS_3_PLUS, OPT_ftree_vectorize, NULL, 1 },
 493     { OPT_LEVELS_3_PLUS, OPT_fipa_cp_clone, NULL, 1 },
 494
 495     /* -Ofast adds optimizations to -O3.  */
 496     { OPT_LEVELS_FAST, OPT_ffast_math, NULL, 1 },
 497
 498     { OPT_LEVELS_NONE, 0, NULL, 0 }
 499   };
 500
 501 /* Default the options in OPTS and OPTS_SET based on the optimization
 502    settings in DECODED_OPTIONS and DECODED_OPTIONS_COUNT.  */
 503 void
 504 default_options_optimization (struct gcc_options *opts,
 505                               struct gcc_options *opts_set,
 506                               struct cl_decoded_option *decoded_options,
 507                               unsigned int decoded_options_count,
 508                               location_t loc,
 509                               unsigned int lang_mask,
 510                               const struct cl_option_handlers *handlers,
 511                               diagnostic_context *dc)
 512 {
 513   unsigned int i;
 514   int opt2;
 515
 516   /* Scan to see what optimization level has been specified.  That will
 517      determine the default value of many flags.  */
 518   for (i = 1; i < decoded_options_count; i++)
 519     {
 520       struct cl_decoded_option *opt = &decoded_options[i];
 521       switch (opt->opt_index)
 522         {
 523         case OPT_O:
 524           if (*opt->arg == '\0')
 525             {
 526               opts->x_optimize = 1;
 527               opts->x_optimize_size = 0;
 528               opts->x_optimize_fast = 0;
 529             }
 530           else
 531             {
 532               const int optimize_val = integral_argument (opt->arg);
 533               if (optimize_val == -1)
 534                 error_at (loc,
 535                           "argument to %qs should be a non-negative integer",
 536                           "-O");
 537               else
 538                 {
 539                   opts->x_optimize = optimize_val;
 540                   if ((unsigned int) opts->x_optimize > 255)
 541                     opts->x_optimize = 255;
 542                   opts->x_optimize_size = 0;
 543                   opts->x_optimize_fast = 0;
 544                 }
 545             }
 546           break;
 547
 548         case OPT_Os:
 549           opts->x_optimize_size = 1;
 550
 551           /* Optimizing for size forces optimize to be 2.  */
 552           opts->x_optimize = 2;
 553           opts->x_optimize_fast = 0;
 554           break;
 555
 556         case OPT_Ofast:
 557           /* -Ofast only adds flags to -O3.  */
 558           opts->x_optimize_size = 0;
 559           opts->x_optimize = 3;
 560           opts->x_optimize_fast = 1;
 561           break;
 562
 563         default:
 564           /* Ignore other options in this prescan.  */
 565           break;
 566         }
 567     }
 568
 569   maybe_default_options (opts, opts_set, default_options_table,
 570                          opts->x_optimize, opts->x_optimize_size,
 571                          opts->x_optimize_fast, lang_mask, handlers, loc, dc);
 572
 573   /* -O2 param settings.  */
 574   opt2 = (opts->x_optimize >= 2);
 575
 576   /* Track fields in field-sensitive alias analysis.  */
 577   maybe_set_param_value
 578     (PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE,
 579      opt2 ? 100 : default_param_value (PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE),
 580      opts->x_param_values, opts_set->x_param_values);
 581
 582   /* For -O1 only do loop invariant motion for very small loops.  */
 583   maybe_set_param_value
 584     (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP,
 585      opt2 ? default_param_value (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP) : 1000,
 586      opts->x_param_values, opts_set->x_param_values);
 587
 588   if (opts->x_optimize_size)
 589     /* We want to crossjump as much as possible.  */
 590     maybe_set_param_value (PARAM_MIN_CROSSJUMP_INSNS, 1,
 591                            opts->x_param_values, opts_set->x_param_values);
 592   else
 593     maybe_set_param_value (PARAM_MIN_CROSSJUMP_INSNS,
 594                            default_param_value (PARAM_MIN_CROSSJUMP_INSNS),
 595                            opts->x_param_values, opts_set->x_param_values);
 596
 597   /* Allow default optimizations to be specified on a per-machine basis.  */
 598   maybe_default_options (opts, opts_set,
 599                          targetm_common.option_optimization_table,
 600                          opts->x_optimize, opts->x_optimize_size,
 601                          opts->x_optimize_fast, lang_mask, handlers, loc, dc);
 602 }
 603
 604 /* After all options at LOC have been read into OPTS and OPTS_SET,
 605    finalize settings of those options and diagnose incompatible
 606    combinations.  */
 607 void
 608 finish_options (struct gcc_options *opts, struct gcc_options *opts_set,
 609                 location_t loc)
 610 {
 611   enum unwind_info_type ui_except;
 612
 613   if (opts->x_dump_base_name && ! IS_ABSOLUTE_PATH (opts->x_dump_base_name))
 614     {
 615       /* First try to make OPTS->X_DUMP_BASE_NAME relative to the
 616          OPTS->X_DUMP_DIR_NAME directory.  Then try to make
 617          OPTS->X_DUMP_BASE_NAME relative to the OPTS->X_AUX_BASE_NAME
 618          directory, typically the directory to contain the object
 619          file.  */
 620       if (opts->x_dump_dir_name)
 621         opts->x_dump_base_name = concat (opts->x_dump_dir_name,
 622                                          opts->x_dump_base_name, NULL);
 623       else if (opts->x_aux_base_name
 624                && strcmp (opts->x_aux_base_name, HOST_BIT_BUCKET) != 0)
 625         {
 626           const char *aux_base;
 627
 628           base_of_path (opts->x_aux_base_name, &aux_base);
 629           if (opts->x_aux_base_name != aux_base)
 630             {
 631               int dir_len = aux_base - opts->x_aux_base_name;
 632               char *new_dump_base_name =
 633                 XNEWVEC (char, strlen (opts->x_dump_base_name) + dir_len + 1);
 634
 635               /* Copy directory component from OPTS->X_AUX_BASE_NAME.  */
 636               memcpy (new_dump_base_name, opts->x_aux_base_name, dir_len);
 637               /* Append existing OPTS->X_DUMP_BASE_NAME.  */
 638               strcpy (new_dump_base_name + dir_len, opts->x_dump_base_name);
 639               opts->x_dump_base_name = new_dump_base_name;
 640             }
 641         }
 642     }
 643
 644   /* Handle related options for unit-at-a-time, toplevel-reorder, and
 645      section-anchors.  */
 646   if (!opts->x_flag_unit_at_a_time)
 647     {
 648       if (opts->x_flag_section_anchors && opts_set->x_flag_section_anchors)
 649         error_at (loc, "section anchors must be disabled when unit-at-a-time "
 650                   "is disabled");
 651       opts->x_flag_section_anchors = 0;
 652       if (opts->x_flag_toplevel_reorder == 1)
 653         error_at (loc, "toplevel reorder must be disabled when unit-at-a-time "
 654                   "is disabled");
 655       opts->x_flag_toplevel_reorder = 0;
 656     }
 657
 658   /* -Wmissing-noreturn is alias for -Wsuggest-attribute=noreturn.  */
 659   if (opts->x_warn_missing_noreturn)
 660     opts->x_warn_suggest_attribute_noreturn = true;
 661
 662   /* Unless the user has asked for section anchors, we disable toplevel
 663      reordering at -O0 to disable transformations that might be surprising
 664      to end users and to get -fno-toplevel-reorder tested.  */
 665   if (!opts->x_optimize
 666       && opts->x_flag_toplevel_reorder == 2
 667       && !(opts->x_flag_section_anchors && opts_set->x_flag_section_anchors))
 668     {
 669       opts->x_flag_toplevel_reorder = 0;
 670       opts->x_flag_section_anchors = 0;
 671     }
 672   if (!opts->x_flag_toplevel_reorder)
 673     {
 674       if (opts->x_flag_section_anchors && opts_set->x_flag_section_anchors)
 675         error_at (loc, "section anchors must be disabled when toplevel reorder"
 676                   " is disabled");
 677       opts->x_flag_section_anchors = 0;
 678     }
 679
 680   if (!opts->x_flag_opts_finished)
 681     {
 682       if (opts->x_flag_pie)
 683         opts->x_flag_pic = opts->x_flag_pie;
 684       if (opts->x_flag_pic && !opts->x_flag_pie)
 685         opts->x_flag_shlib = 1;
 686       opts->x_flag_opts_finished = true;
 687     }
 688
 689   if (opts->x_optimize == 0)
 690     {
 691       /* Inlining does not work if not optimizing,
 692          so force it not to be done.  */
 693       opts->x_warn_inline = 0;
 694       opts->x_flag_no_inline = 1;
 695     }
 696
 697   /* The optimization to partition hot and cold basic blocks into separate
 698      sections of the .o and executable files does not work (currently)
 699      with exception handling.  This is because there is no support for
 700      generating unwind info.  If opts->x_flag_exceptions is turned on
 701      we need to turn off the partitioning optimization.  */
 702
 703   ui_except = targetm_common.except_unwind_info (opts);
 704
 705   if (opts->x_flag_exceptions
 706       && opts->x_flag_reorder_blocks_and_partition
 707       && (ui_except == UI_SJLJ || ui_except == UI_TARGET))
 708     {
 709       inform (loc,
 710               "-freorder-blocks-and-partition does not work "
 711               "with exceptions on this architecture");
 712       opts->x_flag_reorder_blocks_and_partition = 0;
 713       opts->x_flag_reorder_blocks = 1;
 714     }
 715
 716   /* If user requested unwind info, then turn off the partitioning
 717      optimization.  */
 718
 719   if (opts->x_flag_unwind_tables
 720       && !targetm_common.unwind_tables_default
 721       && opts->x_flag_reorder_blocks_and_partition
 722       && (ui_except == UI_SJLJ || ui_except == UI_TARGET))
 723     {
 724       inform (loc,
 725               "-freorder-blocks-and-partition does not support "
 726               "unwind info on this architecture");
 727       opts->x_flag_reorder_blocks_and_partition = 0;
 728       opts->x_flag_reorder_blocks = 1;
 729     }
 730
 731   /* If the target requested unwind info, then turn off the partitioning
 732      optimization with a different message.  Likewise, if the target does not
 733      support named sections.  */
 734
 735   if (opts->x_flag_reorder_blocks_and_partition
 736       && (!targetm_common.have_named_sections
 737           || (opts->x_flag_unwind_tables
 738               && targetm_common.unwind_tables_default
 739               && (ui_except == UI_SJLJ || ui_except == UI_TARGET))))
 740     {
 741       inform (loc,
 742               "-freorder-blocks-and-partition does not work "
 743               "on this architecture");
 744       opts->x_flag_reorder_blocks_and_partition = 0;
 745       opts->x_flag_reorder_blocks = 1;
 746     }
 747
 748   if (opts->x_flag_reorder_blocks_and_partition
 749       && !opts_set->x_flag_reorder_functions)
 750     opts->x_flag_reorder_functions = 1;
 751
 752   /* Pipelining of outer loops is only possible when general pipelining
 753      capabilities are requested.  */
 754   if (!opts->x_flag_sel_sched_pipelining)
 755     opts->x_flag_sel_sched_pipelining_outer_loops = 0;
 756
 757   if (opts->x_flag_conserve_stack)
 758     {
 759       maybe_set_param_value (PARAM_LARGE_STACK_FRAME, 100,
 760                              opts->x_param_values, opts_set->x_param_values);
 761       maybe_set_param_value (PARAM_STACK_FRAME_GROWTH, 40,
 762                              opts->x_param_values, opts_set->x_param_values);
 763     }
 764   if (opts->x_flag_wpa || opts->x_flag_ltrans)
 765     {
 766       /* These passes are not WHOPR compatible yet.  */
 767       opts->x_flag_ipa_pta = 0;
 768     }
 769
 770   if (opts->x_flag_lto)
 771     {
 772 #ifdef ENABLE_LTO
 773       opts->x_flag_generate_lto = 1;
 774
 775       /* When generating IL, do not operate in whole-program mode.
 776          Otherwise, symbols will be privatized too early, causing link
 777          errors later.  */
 778       opts->x_flag_whole_program = 0;
 779 #else
 780       error_at (loc, "LTO support has not been enabled in this configuration");
 781 #endif
 782     }
 783   if ((opts->x_flag_lto_partition_balanced != 0) + (opts->x_flag_lto_partition_1to1 != 0)
 784        + (opts->x_flag_lto_partition_none != 0) >= 1)
 785     {
 786       if ((opts->x_flag_lto_partition_balanced != 0)
 787            + (opts->x_flag_lto_partition_1to1 != 0)
 788            + (opts->x_flag_lto_partition_none != 0) > 1)
 789         error_at (loc, "only one -flto-partition value can be specified");
 790     }
 791
 792   /* We initialize opts->x_flag_split_stack to -1 so that targets can set a
 793      default value if they choose based on other options.  */
 794   if (opts->x_flag_split_stack == -1)
 795     opts->x_flag_split_stack = 0;
 796   else if (opts->x_flag_split_stack)
 797     {
 798       if (!targetm_common.supports_split_stack (true, opts))
 799         {
 800           error_at (loc, "%<-fsplit-stack%> is not supported by "
 801                     "this compiler configuration");
 802           opts->x_flag_split_stack = 0;
 803         }
 804     }
 805
 806   /* Set PARAM_MAX_STORES_TO_SINK to 0 if either vectorization or if-conversion
 807      is disabled.  */
 808   if (!opts->x_flag_tree_vectorize || !opts->x_flag_tree_loop_if_convert)
 809     maybe_set_param_value (PARAM_MAX_STORES_TO_SINK, 0,
 810                            opts->x_param_values, opts_set->x_param_values);
 811
 812   /* This replaces set_Wunused.  */
 813   if (opts->x_warn_unused_function == -1)
 814     opts->x_warn_unused_function = opts->x_warn_unused;
 815   if (opts->x_warn_unused_label == -1)
 816     opts->x_warn_unused_label = opts->x_warn_unused;
 817   /* Wunused-parameter is enabled if both -Wunused -Wextra are enabled.  */
 818   if (opts->x_warn_unused_parameter == -1)
 819     opts->x_warn_unused_parameter = (opts->x_warn_unused
 820                                      && opts->x_extra_warnings);
 821   if (opts->x_warn_unused_variable == -1)
 822     opts->x_warn_unused_variable = opts->x_warn_unused;
 823   /* Wunused-but-set-parameter is enabled if both -Wunused -Wextra are
 824      enabled.  */
 825   if (opts->x_warn_unused_but_set_parameter == -1)
 826     opts->x_warn_unused_but_set_parameter = (opts->x_warn_unused
 827                                              && opts->x_extra_warnings);
 828   if (opts->x_warn_unused_but_set_variable == -1)
 829     opts->x_warn_unused_but_set_variable = opts->x_warn_unused;
 830   if (opts->x_warn_unused_value == -1)
 831     opts->x_warn_unused_value = opts->x_warn_unused;
 832
 833   /* This replaces set_Wextra.  */
 834   if (opts->x_warn_uninitialized == -1)
 835     opts->x_warn_uninitialized = opts->x_extra_warnings;
 836 }
 837
 838 #define LEFT_COLUMN     27
 839
 840 /* Output ITEM, of length ITEM_WIDTH, in the left column,
 841    followed by word-wrapped HELP in a second column.  */
 842 static void
 843 wrap_help (const char *help,
 844            const char *item,
 845            unsigned int item_width,
 846            unsigned int columns)
 847 {
 848   unsigned int col_width = LEFT_COLUMN;
 849   unsigned int remaining, room, len;
 850
 851   remaining = strlen (help);
 852
 853   do
 854     {
 855       room = columns - 3 - MAX (col_width, item_width);
 856       if (room > columns)
 857         room = 0;
 858       len = remaining;
 859
 860       if (room < len)
 861         {
 862           unsigned int i;
 863
 864           for (i = 0; help[i]; i++)
 865             {
 866               if (i >= room && len != remaining)
 867                 break;
 868               if (help[i] == ' ')
 869                 len = i;
 870               else if ((help[i] == '-' || help[i] == '/')
 871                        && help[i + 1] != ' '
 872                        && i > 0 && ISALPHA (help[i - 1]))
 873                 len = i + 1;
 874             }
 875         }
 876
 877       printf( "  %-*.*s %.*s\n", col_width, item_width, item, len, help);
 878       item_width = 0;
 879       while (help[len] == ' ')
 880         len++;
 881       help += len;
 882       remaining -= len;
 883     }
 884   while (remaining);
 885 }
 886
 887 /* Print help for a specific front-end, etc.  */
 888 static void
 889 print_filtered_help (unsigned int include_flags,
 890                      unsigned int exclude_flags,
 891                      unsigned int any_flags,
 892                      unsigned int columns,
 893                      struct gcc_options *opts,
 894                      unsigned int lang_mask)
 895 {
 896   unsigned int i;
 897   const char *help;
 898   bool found = false;
 899   bool displayed = false;
 900
 901   if (include_flags == CL_PARAMS)
 902     {
 903       for (i = 0; i < LAST_PARAM; i++)
 904         {
 905           const char *param = compiler_params[i].option;
 906
 907           help = compiler_params[i].help;
 908           if (help == NULL || *help == '\0')
 909             {
 910               if (exclude_flags & CL_UNDOCUMENTED)
 911                 continue;
 912               help = undocumented_msg;
 913             }
 914
 915           /* Get the translation.  */
 916           help = _(help);
 917
 918           wrap_help (help, param, strlen (param), columns);
 919         }
 920       putchar ('\n');
 921       return;
 922     }
 923
 924   if (!opts->x_help_printed)
 925     opts->x_help_printed = XCNEWVAR (char, cl_options_count);
 926
 927   if (!opts->x_help_enum_printed)
 928     opts->x_help_enum_printed = XCNEWVAR (char, cl_enums_count);
 929
 930   for (i = 0; i < cl_options_count; i++)
 931     {
 932       char new_help[128];
 933       const struct cl_option *option = cl_options + i;
 934       unsigned int len;
 935       const char *opt;
 936       const char *tab;
 937
 938       if (include_flags == 0
 939           || ((option->flags & include_flags) != include_flags))
 940         {
 941           if ((option->flags & any_flags) == 0)
 942             continue;
 943         }
 944
 945       /* Skip unwanted switches.  */
 946       if ((option->flags & exclude_flags) != 0)
 947         continue;
 948
 949       /* The driver currently prints its own help text.  */
 950       if ((option->flags & CL_DRIVER) != 0
 951           && (option->flags & (((1U << cl_lang_count) - 1)
 952                                | CL_COMMON | CL_TARGET)) == 0)
 953         continue;
 954
 955       found = true;
 956       /* Skip switches that have already been printed.  */
 957       if (opts->x_help_printed[i])
 958         continue;
 959
 960       opts->x_help_printed[i] = true;
 961
 962       help = option->help;
 963       if (help == NULL)
 964         {
 965           if (exclude_flags & CL_UNDOCUMENTED)
 966             continue;
 967           help = undocumented_msg;
 968         }
 969
 970       /* Get the translation.  */
 971       help = _(help);
 972
 973       /* Find the gap between the name of the
 974          option and its descriptive text.  */
 975       tab = strchr (help, '\t');
 976       if (tab)
 977         {
 978           len = tab - help;
 979           opt = help;
 980           help = tab + 1;
 981         }
 982       else
 983         {
 984           opt = option->opt_text;
 985           len = strlen (opt);
 986         }
 987
 988       /* With the -Q option enabled we change the descriptive text associated
 989          with an option to be an indication of its current setting.  */
 990       if (!quiet_flag)
 991         {
 992           void *flag_var = option_flag_var (i, opts);
 993
 994           if (len < (LEFT_COLUMN + 2))
 995             strcpy (new_help, "\t\t");
 996           else
 997             strcpy (new_help, "\t");
 998
 999           if (flag_var != NULL
1000               && option->var_type != CLVC_DEFER)
1001             {
1002               if (option->flags & CL_JOINED)
1003                 {
1004                   if (option->var_type == CLVC_STRING)
1005                     {
1006                       if (* (const char **) flag_var != NULL)
1007                         snprintf (new_help + strlen (new_help),
1008                                   sizeof (new_help) - strlen (new_help),
1009                                   * (const char **) flag_var);
1010                     }
1011                   else if (option->var_type == CLVC_ENUM)
1012                     {
1013                       const struct cl_enum *e = &cl_enums[option->var_enum];
1014                       int value;
1015                       const char *arg = NULL;
1016
1017                       value = e->get (flag_var);
1018                       enum_value_to_arg (e->values, &arg, value, lang_mask);
1019                       if (arg == NULL)
1020                         arg = _("[default]");
1021                       snprintf (new_help + strlen (new_help),
1022                                 sizeof (new_help) - strlen (new_help),
1023                                 arg);
1024                     }
1025                   else
1026                     sprintf (new_help + strlen (new_help),
1027                              "%#x", * (int *) flag_var);
1028                 }
1029               else
1030                 strcat (new_help, option_enabled (i, opts)
1031                         ? _("[enabled]") : _("[disabled]"));
1032             }
1033
1034           help = new_help;
1035         }
1036
1037       wrap_help (help, opt, len, columns);
1038       displayed = true;
1039
1040       if (option->var_type == CLVC_ENUM
1041           && opts->x_help_enum_printed[option->var_enum] != 2)
1042         opts->x_help_enum_printed[option->var_enum] = 1;
1043     }
1044
1045   if (! found)
1046     {
1047       unsigned int langs = include_flags & CL_LANG_ALL;
1048
1049       if (langs == 0)
1050         printf (_(" No options with the desired characteristics were found\n"));
1051       else
1052         {
1053           unsigned int i;
1054
1055           /* PR 31349: Tell the user how to see all of the
1056              options supported by a specific front end.  */
1057           for (i = 0; (1U << i) < CL_LANG_ALL; i ++)
1058             if ((1U << i) & langs)
1059               printf (_(" None found.  Use --help=%s to show *all* the options supported by the %s front-end\n"),
1060                       lang_names[i], lang_names[i]);
1061         }
1062
1063     }
1064   else if (! displayed)
1065     printf (_(" All options with the desired characteristics have already been displayed\n"));
1066
1067   putchar ('\n');
1068
1069   /* Print details of enumerated option arguments, if those
1070      enumerations have help text headings provided.  If no help text
1071      is provided, presume that the possible values are listed in the
1072      help text for the relevant options.  */
1073   for (i = 0; i < cl_enums_count; i++)
1074     {
1075       unsigned int j, pos;
1076
1077       if (opts->x_help_enum_printed[i] != 1)
1078         continue;
1079       if (cl_enums[i].help == NULL)
1080         continue;
1081       printf ("  %s\n    ", _(cl_enums[i].help));
1082       pos = 4;
1083       for (j = 0; cl_enums[i].values[j].arg != NULL; j++)
1084         {
1085           unsigned int len = strlen (cl_enums[i].values[j].arg);
1086
1087           if (pos > 4 && pos + 1 + len <= columns)
1088             {
1089               printf (" %s", cl_enums[i].values[j].arg);
1090               pos += 1 + len;
1091             }
1092           else
1093             {
1094               if (pos > 4)
1095                 {
1096                   printf ("\n    ");
1097                   pos = 4;
1098                 }
1099               printf ("%s", cl_enums[i].values[j].arg);
1100               pos += len;
1101             }
1102         }
1103       printf ("\n\n");
1104       opts->x_help_enum_printed[i] = 2;
1105     }
1106 }
1107
1108 /* Display help for a specified type of option.
1109    The options must have ALL of the INCLUDE_FLAGS set
1110    ANY of the flags in the ANY_FLAGS set
1111    and NONE of the EXCLUDE_FLAGS set.  The current option state is in
1112    OPTS; LANG_MASK is used for interpreting enumerated option state.  */
1113 static void
1114 print_specific_help (unsigned int include_flags,
1115                      unsigned int exclude_flags,
1116                      unsigned int any_flags,
1117                      struct gcc_options *opts,
1118                      unsigned int lang_mask)
1119 {
1120   unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
1121   const char * description = NULL;
1122   const char * descrip_extra = "";
1123   size_t i;
1124   unsigned int flag;
1125
1126   /* Sanity check: Make sure that we do not have more
1127      languages than we have bits available to enumerate them.  */
1128   gcc_assert ((1U << cl_lang_count) < CL_MIN_OPTION_CLASS);
1129
1130   /* If we have not done so already, obtain
1131      the desired maximum width of the output.  */
1132   if (opts->x_help_columns == 0)
1133     {
1134       const char *p;
1135
1136       p = getenv ("COLUMNS");
1137       if (p != NULL)
1138         {
1139           int value = atoi (p);
1140
1141           if (value > 0)
1142             opts->x_help_columns = value;
1143         }
1144
1145       if (opts->x_help_columns == 0)
1146         /* Use a reasonable default.  */
1147         opts->x_help_columns = 80;
1148     }
1149
1150   /* Decide upon the title for the options that we are going to display.  */
1151   for (i = 0, flag = 1; flag <= CL_MAX_OPTION_CLASS; flag <<= 1, i ++)
1152     {
1153       switch (flag & include_flags)
1154         {
1155         case 0:
1156         case CL_DRIVER:
1157           break;
1158
1159         case CL_TARGET:
1160           description = _("The following options are target specific");
1161           break;
1162         case CL_WARNING:
1163           description = _("The following options control compiler warning messages");
1164           break;
1165         case CL_OPTIMIZATION:
1166           description = _("The following options control optimizations");
1167           break;
1168         case CL_COMMON:
1169           description = _("The following options are language-independent");
1170           break;
1171         case CL_PARAMS:
1172           description = _("The --param option recognizes the following as parameters");
1173           break;
1174         default:
1175           if (i >= cl_lang_count)
1176             break;
1177           if (exclude_flags & all_langs_mask)
1178             description = _("The following options are specific to just the language ");
1179           else
1180             description = _("The following options are supported by the language ");
1181           descrip_extra = lang_names [i];
1182           break;
1183         }
1184     }
1185
1186   if (description == NULL)
1187     {
1188       if (any_flags == 0)
1189         {
1190           if (include_flags & CL_UNDOCUMENTED)
1191             description = _("The following options are not documented");
1192           else if (include_flags & CL_SEPARATE)
1193             description = _("The following options take separate arguments");
1194           else if (include_flags & CL_JOINED)
1195             description = _("The following options take joined arguments");
1196           else
1197             {
1198               internal_error ("unrecognized include_flags 0x%x passed to print_specific_help",
1199                               include_flags);
1200               return;
1201             }
1202         }
1203       else
1204         {
1205           if (any_flags & all_langs_mask)
1206             description = _("The following options are language-related");
1207           else
1208             description = _("The following options are language-independent");
1209         }
1210     }
1211
1212   printf ("%s%s:\n", description, descrip_extra);
1213   print_filtered_help (include_flags, exclude_flags, any_flags,
1214                        opts->x_help_columns, opts, lang_mask);
1215 }
1216
1217 /* Handle target- and language-independent options.  Return zero to
1218    generate an "unknown option" message.  Only options that need
1219    extra handling need to be listed here; if you simply want
1220    DECODED->value assigned to a variable, it happens automatically.  */
1221
1222 bool
1223 common_handle_option (struct gcc_options *opts,
1224                       struct gcc_options *opts_set,
1225                       const struct cl_decoded_option *decoded,
1226                       unsigned int lang_mask, int kind ATTRIBUTE_UNUSED,
1227                       location_t loc,
1228                       const struct cl_option_handlers *handlers,
1229                       diagnostic_context *dc)
1230 {
1231   size_t scode = decoded->opt_index;
1232   const char *arg = decoded->arg;
1233   int value = decoded->value;
1234   enum opt_code code = (enum opt_code) scode;
1235
1236   gcc_assert (decoded->canonical_option_num_elements <= 2);
1237
1238   switch (code)
1239     {
1240     case OPT__param:
1241       handle_param (opts, opts_set, loc, arg);
1242       break;
1243
1244     case OPT__help:
1245       {
1246         unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
1247         unsigned int undoc_mask;
1248         unsigned int i;
1249
1250         undoc_mask = ((opts->x_verbose_flag | opts->x_extra_warnings)
1251                       ? 0
1252                       : CL_UNDOCUMENTED);
1253         /* First display any single language specific options.  */
1254         for (i = 0; i < cl_lang_count; i++)
1255           print_specific_help
1256             (1U << i, (all_langs_mask & (~ (1U << i))) | undoc_mask, 0, opts,
1257              lang_mask);
1258         /* Next display any multi language specific options.  */
1259         print_specific_help (0, undoc_mask, all_langs_mask, opts, lang_mask);
1260         /* Then display any remaining, non-language options.  */
1261         for (i = CL_MIN_OPTION_CLASS; i <= CL_MAX_OPTION_CLASS; i <<= 1)
1262           if (i != CL_DRIVER)
1263             print_specific_help (i, undoc_mask, 0, opts, lang_mask);
1264         opts->x_exit_after_options = true;
1265         break;
1266       }
1267
1268     case OPT__target_help:
1269       print_specific_help (CL_TARGET, CL_UNDOCUMENTED, 0, opts, lang_mask);
1270       opts->x_exit_after_options = true;
1271       break;
1272
1273     case OPT__help_:
1274       {
1275         const char * a = arg;
1276         unsigned int include_flags = 0;
1277         /* Note - by default we include undocumented options when listing
1278            specific classes.  If you only want to see documented options
1279            then add ",^undocumented" to the --help= option.  E.g.:
1280
1281            --help=target,^undocumented  */
1282         unsigned int exclude_flags = 0;
1283
1284         /* Walk along the argument string, parsing each word in turn.
1285            The format is:
1286            arg = [^]{word}[,{arg}]
1287            word = {optimizers|target|warnings|undocumented|
1288                    params|common|<language>}  */
1289         while (* a != 0)
1290           {
1291             static const struct
1292             {
1293               const char * string;
1294               unsigned int flag;
1295             }
1296             specifics[] =
1297             {
1298               { "optimizers", CL_OPTIMIZATION },
1299               { "target", CL_TARGET },
1300               { "warnings", CL_WARNING },
1301               { "undocumented", CL_UNDOCUMENTED },
1302               { "params", CL_PARAMS },
1303               { "joined", CL_JOINED },
1304               { "separate", CL_SEPARATE },
1305               { "common", CL_COMMON },
1306               { NULL, 0 }
1307             };
1308             unsigned int * pflags;
1309             const char * comma;
1310             unsigned int lang_flag, specific_flag;
1311             unsigned int len;
1312             unsigned int i;
1313
1314             if (* a == '^')
1315               {
1316                 ++ a;
1317                 pflags = & exclude_flags;
1318               }
1319             else
1320               pflags = & include_flags;
1321
1322             comma = strchr (a, ',');
1323             if (comma == NULL)
1324               len = strlen (a);
1325             else
1326               len = comma - a;
1327             if (len == 0)
1328               {
1329                 a = comma + 1;
1330                 continue;
1331               }
1332
1333             /* Check to see if the string matches an option class name.  */
1334             for (i = 0, specific_flag = 0; specifics[i].string != NULL; i++)
1335               if (strncasecmp (a, specifics[i].string, len) == 0)
1336                 {
1337                   specific_flag = specifics[i].flag;
1338                   break;
1339                 }
1340
1341             /* Check to see if the string matches a language name.
1342                Note - we rely upon the alpha-sorted nature of the entries in
1343                the lang_names array, specifically that shorter names appear
1344                before their longer variants.  (i.e. C before C++).  That way
1345                when we are attempting to match --help=c for example we will
1346                match with C first and not C++.  */
1347             for (i = 0, lang_flag = 0; i < cl_lang_count; i++)
1348               if (strncasecmp (a, lang_names[i], len) == 0)
1349                 {
1350                   lang_flag = 1U << i;
1351                   break;
1352                 }
1353
1354             if (specific_flag != 0)
1355               {
1356                 if (lang_flag == 0)
1357                   * pflags |= specific_flag;
1358                 else
1359                   {
1360                     /* The option's argument matches both the start of a
1361                        language name and the start of an option class name.
1362                        We have a special case for when the user has
1363                        specified "--help=c", but otherwise we have to issue
1364                        a warning.  */
1365                     if (strncasecmp (a, "c", len) == 0)
1366                       * pflags |= lang_flag;
1367                     else
1368                       warning_at (loc, 0,
1369                                   "--help argument %q.*s is ambiguous, "
1370                                   "please be more specific",
1371                                   len, a);
1372                   }
1373               }
1374             else if (lang_flag != 0)
1375               * pflags |= lang_flag;
1376             else
1377               warning_at (loc, 0,
1378                           "unrecognized argument to --help= option: %q.*s",
1379                           len, a);
1380
1381             if (comma == NULL)
1382               break;
1383             a = comma + 1;
1384           }
1385
1386         if (include_flags)
1387           print_specific_help (include_flags, exclude_flags, 0, opts,
1388                                lang_mask);
1389         opts->x_exit_after_options = true;
1390         break;
1391       }
1392
1393     case OPT__version:
1394       opts->x_exit_after_options = true;
1395       break;
1396
1397     case OPT_O:
1398     case OPT_Os:
1399     case OPT_Ofast:
1400       /* Currently handled in a prescan.  */
1401       break;
1402
1403     case OPT_Werror_:
1404       enable_warning_as_error (arg, value, lang_mask, handlers,
1405                                opts, opts_set, loc, dc);
1406       break;
1407
1408     case OPT_Wlarger_than_:
1409       opts->x_larger_than_size = value;
1410       opts->x_warn_larger_than = value != -1;
1411       break;
1412
1413     case OPT_Wfatal_errors:
1414       dc->fatal_errors = value;
1415       break;
1416
1417     case OPT_Wframe_larger_than_:
1418       opts->x_frame_larger_than_size = value;
1419       opts->x_warn_frame_larger_than = value != -1;
1420       break;
1421
1422     case OPT_Wstack_usage_:
1423       opts->x_warn_stack_usage = value;
1424       opts->x_flag_stack_usage_info = value != -1;
1425       break;
1426
1427     case OPT_Wstrict_aliasing:
1428       set_Wstrict_aliasing (opts, value);
1429       break;
1430
1431     case OPT_Wstrict_overflow:
1432       opts->x_warn_strict_overflow = (value
1433                                       ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
1434                                       : 0);
1435       break;
1436
1437     case OPT_Wsystem_headers:
1438       dc->dc_warn_system_headers = value;
1439       break;
1440
1441     case OPT_aux_info:
1442       opts->x_flag_gen_aux_info = 1;
1443       break;
1444
1445     case OPT_auxbase_strip:
1446       {
1447         char *tmp = xstrdup (arg);
1448         strip_off_ending (tmp, strlen (tmp));
1449         if (tmp[0])
1450           opts->x_aux_base_name = tmp;
1451       }
1452       break;
1453
1454     case OPT_d:
1455       decode_d_option (arg, opts, loc, dc);
1456       break;
1457
1458     case OPT_fcall_used_:
1459     case OPT_fcall_saved_:
1460       /* Deferred.  */
1461       break;
1462
1463     case OPT_fdbg_cnt_:
1464     case OPT_fdbg_cnt_list:
1465       /* Deferred.  */
1466       break;
1467
1468     case OPT_fdebug_prefix_map_:
1469       /* Deferred.  */
1470       break;
1471
1472     case OPT_fdiagnostics_show_location_:
1473       diagnostic_prefixing_rule (dc) = (diagnostic_prefixing_rule_t) value;
1474       break;
1475
1476     case OPT_fdiagnostics_show_option:
1477       dc->show_option_requested = value;
1478       break;
1479
1480     case OPT_fdump_:
1481       /* Deferred.  */
1482       break;
1483
1484     case OPT_ffast_math:
1485       set_fast_math_flags (opts, value);
1486       break;
1487
1488     case OPT_funsafe_math_optimizations:
1489       set_unsafe_math_optimizations_flags (opts, value);
1490       break;
1491
1492     case OPT_ffixed_:
1493       /* Deferred.  */
1494       break;
1495
1496     case OPT_finline_limit_:
1497       set_param_value ("max-inline-insns-single", value / 2,
1498                        opts->x_param_values, opts_set->x_param_values);
1499       set_param_value ("max-inline-insns-auto", value / 2,
1500                        opts->x_param_values, opts_set->x_param_values);
1501       break;
1502
1503     case OPT_finstrument_functions_exclude_function_list_:
1504       add_comma_separated_to_vector
1505         (&opts->x_flag_instrument_functions_exclude_functions, arg);
1506       break;
1507
1508     case OPT_finstrument_functions_exclude_file_list_:
1509       add_comma_separated_to_vector
1510         (&opts->x_flag_instrument_functions_exclude_files, arg);
1511       break;
1512
1513     case OPT_fmessage_length_:
1514       pp_set_line_maximum_length (dc->printer, value);
1515       break;
1516
1517     case OPT_fpack_struct_:
1518       if (value <= 0 || (value & (value - 1)) || value > 16)
1519         error_at (loc,
1520                   "structure alignment must be a small power of two, not %d",
1521                   value);
1522       else
1523         opts->x_initial_max_fld_align = value;
1524       break;
1525
1526     case OPT_fplugin_:
1527     case OPT_fplugin_arg_:
1528       /* Deferred.  */
1529       break;
1530
1531     case OPT_fprofile_use_:
1532       opts->x_profile_data_prefix = xstrdup (arg);
1533       opts->x_flag_profile_use = true;
1534       value = true;
1535       /* No break here - do -fprofile-use processing. */
1536     case OPT_fprofile_use:
1537       if (!opts_set->x_flag_branch_probabilities)
1538         opts->x_flag_branch_probabilities = value;
1539       if (!opts_set->x_flag_profile_values)
1540         opts->x_flag_profile_values = value;
1541       if (!opts_set->x_flag_unroll_loops)
1542         opts->x_flag_unroll_loops = value;
1543       if (!opts_set->x_flag_peel_loops)
1544         opts->x_flag_peel_loops = value;
1545       if (!opts_set->x_flag_tracer)
1546         opts->x_flag_tracer = value;
1547       if (!opts_set->x_flag_value_profile_transformations)
1548         opts->x_flag_value_profile_transformations = value;
1549       if (!opts_set->x_flag_inline_functions)
1550         opts->x_flag_inline_functions = value;
1551       if (!opts_set->x_flag_ipa_cp)
1552         opts->x_flag_ipa_cp = value;
1553       if (!opts_set->x_flag_ipa_cp_clone
1554           && value && opts->x_flag_ipa_cp)
1555         opts->x_flag_ipa_cp_clone = value;
1556       if (!opts_set->x_flag_predictive_commoning)
1557         opts->x_flag_predictive_commoning = value;
1558       if (!opts_set->x_flag_unswitch_loops)
1559         opts->x_flag_unswitch_loops = value;
1560       if (!opts_set->x_flag_gcse_after_reload)
1561         opts->x_flag_gcse_after_reload = value;
1562       break;
1563
1564     case OPT_fprofile_generate_:
1565       opts->x_profile_data_prefix = xstrdup (arg);
1566       value = true;
1567       /* No break here - do -fprofile-generate processing. */
1568     case OPT_fprofile_generate:
1569       if (!opts_set->x_profile_arc_flag)
1570         opts->x_profile_arc_flag = value;
1571       if (!opts_set->x_flag_profile_values)
1572         opts->x_flag_profile_values = value;
1573       if (!opts_set->x_flag_value_profile_transformations)
1574         opts->x_flag_value_profile_transformations = value;
1575       if (!opts_set->x_flag_inline_functions)
1576         opts->x_flag_inline_functions = value;
1577       /* FIXME: Instrumentation we insert makes ipa-reference bitmaps
1578          quadratic.  Disable the pass until better memory representation
1579          is done.  */
1580       if (!opts_set->x_flag_ipa_reference && in_lto_p)
1581         opts->x_flag_ipa_reference = false;
1582       break;
1583
1584     case OPT_fshow_column:
1585       dc->show_column = value;
1586       break;
1587
1588     case OPT_frandom_seed:
1589       /* The real switch is -fno-random-seed.  */
1590       if (value)
1591         return false;
1592       /* Deferred.  */
1593       break;
1594
1595     case OPT_frandom_seed_:
1596       /* Deferred.  */
1597       break;
1598
1599     case OPT_fsched_verbose_:
1600 #ifdef INSN_SCHEDULING
1601       /* Handled with Var in common.opt.  */
1602       break;
1603 #else
1604       return false;
1605 #endif
1606
1607     case OPT_fsched_stalled_insns_:
1608       opts->x_flag_sched_stalled_insns = value;
1609       if (opts->x_flag_sched_stalled_insns == 0)
1610         opts->x_flag_sched_stalled_insns = -1;
1611       break;
1612
1613     case OPT_fsched_stalled_insns_dep_:
1614       opts->x_flag_sched_stalled_insns_dep = value;
1615       break;
1616
1617     case OPT_fstack_check_:
1618       if (!strcmp (arg, "no"))
1619         opts->x_flag_stack_check = NO_STACK_CHECK;
1620       else if (!strcmp (arg, "generic"))
1621         /* This is the old stack checking method.  */
1622         opts->x_flag_stack_check = STACK_CHECK_BUILTIN
1623                            ? FULL_BUILTIN_STACK_CHECK
1624                            : GENERIC_STACK_CHECK;
1625       else if (!strcmp (arg, "specific"))
1626         /* This is the new stack checking method.  */
1627         opts->x_flag_stack_check = STACK_CHECK_BUILTIN
1628                            ? FULL_BUILTIN_STACK_CHECK
1629                            : STACK_CHECK_STATIC_BUILTIN
1630                              ? STATIC_BUILTIN_STACK_CHECK
1631                              : GENERIC_STACK_CHECK;
1632       else
1633         warning_at (loc, 0, "unknown stack check parameter \"%s\"", arg);
1634       break;
1635
1636     case OPT_fstack_limit:
1637       /* The real switch is -fno-stack-limit.  */
1638       if (value)
1639         return false;
1640       /* Deferred.  */
1641       break;
1642
1643     case OPT_fstack_limit_register_:
1644     case OPT_fstack_limit_symbol_:
1645       /* Deferred.  */
1646       break;
1647
1648     case OPT_fstack_usage:
1649       opts->x_flag_stack_usage = value;
1650       opts->x_flag_stack_usage_info = value != 0;
1651       break;
1652
1653     case OPT_ftree_vectorizer_verbose_:
1654       vect_set_verbosity_level (opts, value);
1655       break;
1656
1657     case OPT_g:
1658       set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg, opts, opts_set,
1659                        loc);
1660       break;
1661
1662     case OPT_gcoff:
1663       set_debug_level (SDB_DEBUG, false, arg, opts, opts_set, loc);
1664       break;
1665
1666     case OPT_gdwarf_:
1667       if (value < 2 || value > 4)
1668         error_at (loc, "dwarf version %d is not supported", value);
1669       else
1670         dwarf_version = value;
1671       set_debug_level (DWARF2_DEBUG, false, "", opts, opts_set, loc);
1672       break;
1673
1674     case OPT_ggdb:
1675       set_debug_level (NO_DEBUG, 2, arg, opts, opts_set, loc);
1676       break;
1677
1678     case OPT_gstabs:
1679     case OPT_gstabs_:
1680       set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg, opts, opts_set,
1681                        loc);
1682       break;
1683
1684     case OPT_gvms:
1685       set_debug_level (VMS_DEBUG, false, arg, opts, opts_set, loc);
1686       break;
1687
1688     case OPT_gxcoff:
1689     case OPT_gxcoff_:
1690       set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg, opts, opts_set,
1691                        loc);
1692       break;
1693
1694     case OPT_pedantic_errors:
1695       opts->x_pedantic = 1;
1696       dc->pedantic_errors = 1;
1697       break;
1698
1699     case OPT_flto:
1700       opts->x_flag_lto = value ? "" : NULL;
1701       break;
1702
1703     case OPT_w:
1704       dc->dc_inhibit_warnings = true;
1705       break;
1706
1707     case OPT_fmax_errors_:
1708       dc->max_errors = value;
1709       break;
1710
1711     case OPT_fuse_linker_plugin:
1712       /* No-op. Used by the driver and passed to us because it starts with f.*/
1713       break;
1714
1715     case OPT_Wuninitialized:
1716       /* Also turn on maybe uninitialized warning.  */
1717       warn_maybe_uninitialized = value;
1718       break;
1719
1720     default:
1721       /* If the flag was handled in a standard way, assume the lack of
1722          processing here is intentional.  */
1723       gcc_assert (option_flag_var (scode, opts));
1724       break;
1725     }
1726
1727   return true;
1728 }
1729
1730 /* Handle --param NAME=VALUE.  */
1731 static void
1732 handle_param (struct gcc_options *opts, struct gcc_options *opts_set,
1733               location_t loc, const char *carg)
1734 {
1735   char *equal, *arg;
1736   int value;
1737
1738   arg = xstrdup (carg);
1739   equal = strchr (arg, '=');
1740   if (!equal)
1741     error_at (loc, "%s: --param arguments should be of the form NAME=VALUE",
1742               arg);
1743   else
1744     {
1745       value = integral_argument (equal + 1);
1746       if (value == -1)
1747         error_at (loc, "invalid --param value %qs", equal + 1);
1748       else
1749         {
1750           *equal = '\0';
1751           set_param_value (arg, value,
1752                            opts->x_param_values, opts_set->x_param_values);
1753         }
1754     }
1755
1756   free (arg);
1757 }
1758
1759 /* Used to set the level of strict aliasing warnings in OPTS,
1760    when no level is specified (i.e., when -Wstrict-aliasing, and not
1761    -Wstrict-aliasing=level was given).
1762    ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
1763    and 0 otherwise.  After calling this function, wstrict_aliasing will be
1764    set to the default value of -Wstrict_aliasing=level, currently 3.  */
1765 void
1766 set_Wstrict_aliasing (struct gcc_options *opts, int onoff)
1767 {
1768   gcc_assert (onoff == 0 || onoff == 1);
1769   if (onoff != 0)
1770     opts->x_warn_strict_aliasing = 3;
1771   else
1772     opts->x_warn_strict_aliasing = 0;
1773 }
1774
1775 /* The following routines are useful in setting all the flags that
1776    -ffast-math and -fno-fast-math imply.  */
1777 static void
1778 set_fast_math_flags (struct gcc_options *opts, int set)
1779 {
1780   if (!opts->frontend_set_flag_unsafe_math_optimizations)
1781     {
1782       opts->x_flag_unsafe_math_optimizations = set;
1783       set_unsafe_math_optimizations_flags (opts, set);
1784     }
1785   if (!opts->frontend_set_flag_finite_math_only)
1786     opts->x_flag_finite_math_only = set;
1787   if (!opts->frontend_set_flag_errno_math)
1788     opts->x_flag_errno_math = !set;
1789   if (set)
1790     {
1791       if (!opts->frontend_set_flag_signaling_nans)
1792         opts->x_flag_signaling_nans = 0;
1793       if (!opts->frontend_set_flag_rounding_math)
1794         opts->x_flag_rounding_math = 0;
1795       if (!opts->frontend_set_flag_cx_limited_range)
1796         opts->x_flag_cx_limited_range = 1;
1797     }
1798 }
1799
1800 /* When -funsafe-math-optimizations is set the following
1801    flags are set as well.  */
1802 static void
1803 set_unsafe_math_optimizations_flags (struct gcc_options *opts, int set)
1804 {
1805   if (!opts->frontend_set_flag_trapping_math)
1806     opts->x_flag_trapping_math = !set;
1807   if (!opts->frontend_set_flag_signed_zeros)
1808     opts->x_flag_signed_zeros = !set;
1809   if (!opts->frontend_set_flag_associative_math)
1810     opts->x_flag_associative_math = set;
1811   if (!opts->frontend_set_flag_reciprocal_math)
1812     opts->x_flag_reciprocal_math = set;
1813 }
1814
1815 /* Return true iff flags in OPTS are set as if -ffast-math.  */
1816 bool
1817 fast_math_flags_set_p (const struct gcc_options *opts)
1818 {
1819   return (!opts->x_flag_trapping_math
1820           && opts->x_flag_unsafe_math_optimizations
1821           && opts->x_flag_finite_math_only
1822           && !opts->x_flag_signed_zeros
1823           && !opts->x_flag_errno_math);
1824 }
1825
1826 /* Return true iff flags are set as if -ffast-math but using the flags stored
1827    in the struct cl_optimization structure.  */
1828 bool
1829 fast_math_flags_struct_set_p (struct cl_optimization *opt)
1830 {
1831   return (!opt->x_flag_trapping_math
1832           && opt->x_flag_unsafe_math_optimizations
1833           && opt->x_flag_finite_math_only
1834           && !opt->x_flag_signed_zeros
1835           && !opt->x_flag_errno_math);
1836 }
1837
1838 /* Handle a debug output -g switch for options OPTS
1839    (OPTS_SET->x_write_symbols storing whether a debug type was passed
1840    explicitly), location LOC.  EXTENDED is true or false to support
1841    extended output (2 is special and means "-ggdb" was given).  */
1842 static void
1843 set_debug_level (enum debug_info_type type, int extended, const char *arg,
1844                  struct gcc_options *opts, struct gcc_options *opts_set,
1845                  location_t loc)
1846 {
1847   opts->x_use_gnu_debug_info_extensions = extended;
1848
1849   if (type == NO_DEBUG)
1850     {
1851       if (opts->x_write_symbols == NO_DEBUG)
1852         {
1853           opts->x_write_symbols = PREFERRED_DEBUGGING_TYPE;
1854
1855           if (extended == 2)
1856             {
1857 #ifdef DWARF2_DEBUGGING_INFO
1858               opts->x_write_symbols = DWARF2_DEBUG;
1859 #elif defined DBX_DEBUGGING_INFO
1860               opts->x_write_symbols = DBX_DEBUG;
1861 #endif
1862             }
1863
1864           if (opts->x_write_symbols == NO_DEBUG)
1865             warning_at (loc, 0, "target system does not support debug output");
1866         }
1867     }
1868   else
1869     {
1870       /* Does it conflict with an already selected type?  */
1871       if (opts_set->x_write_symbols != NO_DEBUG
1872           && opts->x_write_symbols != NO_DEBUG
1873           && type != opts->x_write_symbols)
1874         error_at (loc, "debug format \"%s\" conflicts with prior selection",
1875                   debug_type_names[type]);
1876       opts->x_write_symbols = type;
1877       opts_set->x_write_symbols = type;
1878     }
1879
1880   /* A debug flag without a level defaults to level 2.  */
1881   if (*arg == '\0')
1882     {
1883       if (!opts->x_debug_info_level)
1884         opts->x_debug_info_level = DINFO_LEVEL_NORMAL;
1885     }
1886   else
1887     {
1888       int argval = integral_argument (arg);
1889       if (argval == -1)
1890         error_at (loc, "unrecognised debug output level \"%s\"", arg);
1891       else if (argval > 3)
1892         error_at (loc, "debug output level %s is too high", arg);
1893       else
1894         opts->x_debug_info_level = (enum debug_info_levels) argval;
1895     }
1896 }
1897
1898 /* Arrange to dump core on error for diagnostic context DC.  (The
1899    regular error message is still printed first, except in the case of
1900    abort ().)  */
1901
1902 static void
1903 setup_core_dumping (diagnostic_context *dc)
1904 {
1905 #ifdef SIGABRT
1906   signal (SIGABRT, SIG_DFL);
1907 #endif
1908 #if defined(HAVE_SETRLIMIT)
1909   {
1910     struct rlimit rlim;
1911     if (getrlimit (RLIMIT_CORE, &rlim) != 0)
1912       fatal_error ("getting core file size maximum limit: %m");
1913     rlim.rlim_cur = rlim.rlim_max;
1914     if (setrlimit (RLIMIT_CORE, &rlim) != 0)
1915       fatal_error ("setting core file size limit to maximum: %m");
1916   }
1917 #endif
1918   diagnostic_abort_on_error (dc);
1919 }
1920
1921 /* Parse a -d<ARG> command line switch for OPTS, location LOC,
1922    diagnostic context DC.  */
1923
1924 static void
1925 decode_d_option (const char *arg, struct gcc_options *opts,
1926                  location_t loc, diagnostic_context *dc)
1927 {
1928   int c;
1929
1930   while (*arg)
1931     switch (c = *arg++)
1932       {
1933       case 'A':
1934         opts->x_flag_debug_asm = 1;
1935         break;
1936       case 'p':
1937         opts->x_flag_print_asm_name = 1;
1938         break;
1939       case 'P':
1940         opts->x_flag_dump_rtl_in_asm = 1;
1941         opts->x_flag_print_asm_name = 1;
1942         break;
1943       case 'v':
1944         opts->x_graph_dump_format = vcg;
1945         break;
1946       case 'x':
1947         opts->x_rtl_dump_and_exit = 1;
1948         break;
1949       case 'D': /* These are handled by the preprocessor.  */
1950       case 'I':
1951       case 'M':
1952       case 'N':
1953       case 'U':
1954         break;
1955       case 'H':
1956         setup_core_dumping (dc);
1957         break;
1958       case 'a':
1959         opts->x_flag_dump_all_passed = true;
1960         break;
1961
1962       default:
1963           warning_at (loc, 0, "unrecognized gcc debugging option: %c", c);
1964         break;
1965       }
1966 }
1967
1968 /* Enable (or disable if VALUE is 0) a warning option ARG (language
1969    mask LANG_MASK, option handlers HANDLERS) as an error for option
1970    structures OPTS and OPTS_SET, diagnostic context DC (possibly
1971    NULL), location LOC.  This is used by -Werror=.  */
1972
1973 static void
1974 enable_warning_as_error (const char *arg, int value, unsigned int lang_mask,
1975                          const struct cl_option_handlers *handlers,
1976                          struct gcc_options *opts,
1977                          struct gcc_options *opts_set,
1978                          location_t loc, diagnostic_context *dc)
1979 {
1980   char *new_option;
1981   int option_index;
1982
1983   new_option = XNEWVEC (char, strlen (arg) + 2);
1984   new_option[0] = 'W';
1985   strcpy (new_option + 1, arg);
1986   option_index = find_opt (new_option, lang_mask);
1987   if (option_index == OPT_SPECIAL_unknown)
1988     {
1989       error_at (loc, "-Werror=%s: no option -%s", arg, new_option);
1990     }
1991   else
1992     {
1993       const diagnostic_t kind = value ? DK_ERROR : DK_WARNING;
1994
1995       control_warning_option (option_index, (int) kind, value,
1996                               loc, lang_mask,
1997                               handlers, opts, opts_set, dc);
1998       if (option_index == OPT_Wuninitialized)
1999         enable_warning_as_error ("maybe-uninitialized", value, lang_mask,
2000                                  handlers, opts, opts_set, loc, dc);
2001     }
2002   free (new_option);
2003 }
2004
2005 /* Return malloced memory for the name of the option OPTION_INDEX
2006    which enabled a diagnostic (context CONTEXT), originally of type
2007    ORIG_DIAG_KIND but possibly converted to DIAG_KIND by options such
2008    as -Werror.  */
2009
2010 char *
2011 option_name (diagnostic_context *context, int option_index,
2012              diagnostic_t orig_diag_kind, diagnostic_t diag_kind)
2013 {
2014   if (option_index)
2015     {
2016       /* A warning classified as an error.  */
2017       if ((orig_diag_kind == DK_WARNING || orig_diag_kind == DK_PEDWARN)
2018           && diag_kind == DK_ERROR)
2019         return concat (cl_options[OPT_Werror_].opt_text,
2020                        /* Skip over "-W".  */
2021                        cl_options[option_index].opt_text + 2,
2022                        NULL);
2023       /* A warning with option.  */
2024       else
2025         return xstrdup (cl_options[option_index].opt_text);
2026     }
2027   /* A warning without option classified as an error.  */
2028   else if (orig_diag_kind == DK_WARNING || orig_diag_kind == DK_PEDWARN
2029            || diag_kind == DK_WARNING)
2030     {
2031       if (context->warning_as_error_requested)
2032         return xstrdup (cl_options[OPT_Werror].opt_text);
2033       else
2034         return xstrdup (_("enabled by default"));
2035     }
2036   else
2037     return NULL;
2038 }