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" /* For STACK_CHECK_BUILTIN,
  27                    STACK_CHECK_STATIC_BUILTIN, DEFAULT_GDB_EXTENSIONS,
  28                    DWARF2_DEBUGGING_INFO and DBX_DEBUGGING_INFO.  */
  29 #include "opts.h"
  30 #include "options.h"
  31 #include "flags.h"
  32 #include "params.h"
  33 #include "diagnostic.h"
  34 #include "opts-diagnostic.h"
  35 #include "insn-attr-common.h"
  36 #include "common/common-target.h"
  37
  38 /* Indexed by enum debug_info_type.  */
  39 const char *const debug_type_names[] =
  40 {
  41   "none", "stabs", "coff", "dwarf-2", "xcoff", "vms"
  42 };
  43
  44 /* Parse the -femit-struct-debug-detailed option value
  45    and set the flag variables. */
  46
  47 #define MATCH( prefix, string ) \
  48   ((strncmp (prefix, string, sizeof prefix - 1) == 0) \
  49    ? ((string += sizeof prefix - 1), 1) : 0)
  50
  51 void
  52 set_struct_debug_option (struct gcc_options *opts, location_t loc,
  53                          const char *spec)
  54 {
  55   /* various labels for comparison */
  56   static const char dfn_lbl[] = "dfn:", dir_lbl[] = "dir:", ind_lbl[] = "ind:";
  57   static const char ord_lbl[] = "ord:", gen_lbl[] = "gen:";
  58   static const char none_lbl[] = "none", any_lbl[] = "any";
  59   static const char base_lbl[] = "base", sys_lbl[] = "sys";
  60
  61   enum debug_struct_file files = DINFO_STRUCT_FILE_ANY;
  62   /* Default is to apply to as much as possible. */
  63   enum debug_info_usage usage = DINFO_USAGE_NUM_ENUMS;
  64   int ord = 1, gen = 1;
  65
  66   /* What usage? */
  67   if (MATCH (dfn_lbl, spec))
  68     usage = DINFO_USAGE_DFN;
  69   else if (MATCH (dir_lbl, spec))
  70     usage = DINFO_USAGE_DIR_USE;
  71   else if (MATCH (ind_lbl, spec))
  72     usage = DINFO_USAGE_IND_USE;
  73
  74   /* Generics or not? */
  75   if (MATCH (ord_lbl, spec))
  76     gen = 0;
  77   else if (MATCH (gen_lbl, spec))
  78     ord = 0;
  79
  80   /* What allowable environment? */
  81   if (MATCH (none_lbl, spec))
  82     files = DINFO_STRUCT_FILE_NONE;
  83   else if (MATCH (any_lbl, spec))
  84     files = DINFO_STRUCT_FILE_ANY;
  85   else if (MATCH (sys_lbl, spec))
  86     files = DINFO_STRUCT_FILE_SYS;
  87   else if (MATCH (base_lbl, spec))
  88     files = DINFO_STRUCT_FILE_BASE;
  89   else
  90     error_at (loc,
  91               "argument %qs to %<-femit-struct-debug-detailed%> "
  92               "not recognized",
  93               spec);
  94
  95   /* Effect the specification. */
  96   if (usage == DINFO_USAGE_NUM_ENUMS)
  97     {
  98       if (ord)
  99         {
 100           opts->x_debug_struct_ordinary[DINFO_USAGE_DFN] = files;
 101           opts->x_debug_struct_ordinary[DINFO_USAGE_DIR_USE] = files;
 102           opts->x_debug_struct_ordinary[DINFO_USAGE_IND_USE] = files;
 103         }
 104       if (gen)
 105         {
 106           opts->x_debug_struct_generic[DINFO_USAGE_DFN] = files;
 107           opts->x_debug_struct_generic[DINFO_USAGE_DIR_USE] = files;
 108           opts->x_debug_struct_generic[DINFO_USAGE_IND_USE] = files;
 109         }
 110     }
 111   else
 112     {
 113       if (ord)
 114         opts->x_debug_struct_ordinary[usage] = files;
 115       if (gen)
 116         opts->x_debug_struct_generic[usage] = files;
 117     }
 118
 119   if (*spec == ',')
 120     set_struct_debug_option (opts, loc, spec+1);
 121   else
 122     {
 123       /* No more -femit-struct-debug-detailed specifications.
 124          Do final checks. */
 125       if (*spec != '\0')
 126         error_at (loc,
 127                   "argument %qs to %<-femit-struct-debug-detailed%> unknown",
 128                   spec);
 129       if (opts->x_debug_struct_ordinary[DINFO_USAGE_DIR_USE]
 130                 < opts->x_debug_struct_ordinary[DINFO_USAGE_IND_USE]
 131           || opts->x_debug_struct_generic[DINFO_USAGE_DIR_USE]
 132                 < opts->x_debug_struct_generic[DINFO_USAGE_IND_USE])
 133         error_at (loc,
 134                   "%<-femit-struct-debug-detailed=dir:...%> must allow "
 135                   "at least as much as "
 136                   "%<-femit-struct-debug-detailed=ind:...%>");
 137     }
 138 }
 139
 140 /* Handle -ftree-vectorizer-verbose=VAL for options OPTS.  */
 141
 142 static void
 143 vect_set_verbosity_level (struct gcc_options *opts, int val)
 144 {
 145    if (val < MAX_VERBOSITY_LEVEL)
 146      opts->x_user_vect_verbosity_level = (enum vect_verbosity_levels) val;
 147    else
 148      opts->x_user_vect_verbosity_level
 149       = (enum vect_verbosity_levels) (MAX_VERBOSITY_LEVEL - 1);
 150 }
 151
 152
 153 /* Strip off a legitimate source ending from the input string NAME of
 154    length LEN.  Rather than having to know the names used by all of
 155    our front ends, we strip off an ending of a period followed by
 156    up to five characters.  (Java uses ".class".)  */
 157
 158 void
 159 strip_off_ending (char *name, int len)
 160 {
 161   int i;
 162   for (i = 2; i < 6 && len > i; i++)
 163     {
 164       if (name[len - i] == '.')
 165         {
 166           name[len - i] = '\0';
 167           break;
 168         }
 169     }
 170 }
 171
 172 /* Find the base name of a path, stripping off both directories and
 173    a single final extension. */
 174 int
 175 base_of_path (const char *path, const char **base_out)
 176 {
 177   const char *base = path;
 178   const char *dot = 0;
 179   const char *p = path;
 180   char c = *p;
 181   while (c)
 182     {
 183       if (IS_DIR_SEPARATOR(c))
 184         {
 185           base = p + 1;
 186           dot = 0;
 187         }
 188       else if (c == '.')
 189         dot = p;
 190       c = *++p;
 191     }
 192   if (!dot)
 193     dot = p;
 194   *base_out = base;
 195   return dot - base;
 196 }
 197
 198 /* What to print when a switch has no documentation.  */
 199 static const char undocumented_msg[] = N_("This switch lacks documentation");
 200
 201 typedef char *char_p; /* For DEF_VEC_P.  */
 202 DEF_VEC_P(char_p);
 203 DEF_VEC_ALLOC_P(char_p,heap);
 204
 205 static void handle_param (struct gcc_options *opts,
 206                           struct gcc_options *opts_set, location_t loc,
 207                           const char *carg);
 208 static void set_debug_level (enum debug_info_type type, int extended,
 209                              const char *arg, struct gcc_options *opts,
 210                              struct gcc_options *opts_set,
 211                              location_t loc);
 212 static void set_fast_math_flags (struct gcc_options *opts, int set);
 213 static void decode_d_option (const char *arg, struct gcc_options *opts,
 214                              location_t loc, diagnostic_context *dc);
 215 static void set_unsafe_math_optimizations_flags (struct gcc_options *opts,
 216                                                  int set);
 217 static void enable_warning_as_error (const char *arg, int value,
 218                                      unsigned int lang_mask,
 219                                      const struct cl_option_handlers *handlers,
 220                                      struct gcc_options *opts,
 221                                      struct gcc_options *opts_set,
 222                                      location_t loc,
 223                                      diagnostic_context *dc);
 224
 225 /* Handle a back-end option; arguments and return value as for
 226    handle_option.  */
 227
 228 bool
 229 target_handle_option (struct gcc_options *opts,
 230                       struct gcc_options *opts_set,
 231                       const struct cl_decoded_option *decoded,
 232                       unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
 233                       location_t loc,
 234                       const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED,
 235                       diagnostic_context *dc)
 236 {
 237   gcc_assert (dc == global_dc);
 238   gcc_assert (kind == DK_UNSPECIFIED);
 239   return targetm_common.handle_option (opts, opts_set, decoded, loc);
 240 }
 241
 242 /* Add comma-separated strings to a char_p vector.  */
 243
 244 static void
 245 add_comma_separated_to_vector (void **pvec, const char *arg)
 246 {
 247   char *tmp;
 248   char *r;
 249   char *w;
 250   char *token_start;
 251   VEC(char_p,heap) *vec = (VEC(char_p,heap) *) *pvec;
 252
 253   /* We never free this string.  */
 254   tmp = xstrdup (arg);
 255
 256   r = tmp;
 257   w = tmp;
 258   token_start = tmp;
 259
 260   while (*r != '\0')
 261     {
 262       if (*r == ',')
 263         {
 264           *w++ = '\0';
 265           ++r;
 266           VEC_safe_push (char_p, heap, vec, token_start);
 267           token_start = w;
 268         }
 269       if (*r == '\\' && r[1] == ',')
 270         {
 271           *w++ = ',';
 272           r += 2;
 273         }
 274       else
 275         *w++ = *r++;
 276     }
 277   if (*token_start != '\0')
 278     VEC_safe_push (char_p, heap, vec, token_start);
 279
 280   *pvec = vec;
 281 }
 282
 283 /* Initialize OPTS and OPTS_SET before using them in parsing options.  */
 284
 285 void
 286 init_options_struct (struct gcc_options *opts, struct gcc_options *opts_set)
 287 {
 288   size_t num_params = get_num_compiler_params ();
 289
 290   *opts = global_options_init;
 291   memset (opts_set, 0, sizeof (*opts_set));
 292
 293   opts->x_param_values = XNEWVEC (int, num_params);
 294   opts_set->x_param_values = XCNEWVEC (int, num_params);
 295   init_param_values (opts->x_param_values);
 296
 297   /* Initialize whether `char' is signed.  */
 298   opts->x_flag_signed_char = DEFAULT_SIGNED_CHAR;
 299   /* Set this to a special "uninitialized" value.  The actual default
 300      is set after target options have been processed.  */
 301   opts->x_flag_short_enums = 2;
 302
 303   /* Initialize target_flags before default_options_optimization
 304      so the latter can modify it.  */
 305   opts->x_target_flags = targetm_common.default_target_flags;
 306
 307   /* Some targets have ABI-specified unwind tables.  */
 308   opts->x_flag_unwind_tables = targetm_common.unwind_tables_default;
 309
 310   /* Some targets have other target-specific initialization.  */
 311   targetm_common.option_init_struct (opts);
 312 }
 313
 314 /* If indicated by the optimization level LEVEL (-Os if SIZE is set,
 315    -Ofast if FAST is set), apply the option DEFAULT_OPT to OPTS and
 316    OPTS_SET, diagnostic context DC, location LOC, with language mask
 317    LANG_MASK and option handlers HANDLERS.  */
 318
 319 static void
 320 maybe_default_option (struct gcc_options *opts,
 321                       struct gcc_options *opts_set,
 322                       const struct default_options *default_opt,
 323                       int level, bool size, bool fast,
 324                       unsigned int lang_mask,
 325                       const struct cl_option_handlers *handlers,
 326                       location_t loc,
 327                       diagnostic_context *dc)
 328 {
 329   const struct cl_option *option = &cl_options[default_opt->opt_index];
 330   bool enabled;
 331
 332   if (size)
 333     gcc_assert (level == 2);
 334   if (fast)
 335     gcc_assert (level == 3);
 336
 337   switch (default_opt->levels)
 338     {
 339     case OPT_LEVELS_ALL:
 340       enabled = true;
 341       break;
 342
 343     case OPT_LEVELS_0_ONLY:
 344       enabled = (level == 0);
 345       break;
 346
 347     case OPT_LEVELS_1_PLUS:
 348       enabled = (level >= 1);
 349       break;
 350
 351     case OPT_LEVELS_1_PLUS_SPEED_ONLY:
 352       enabled = (level >= 1 && !size);
 353       break;
 354
 355     case OPT_LEVELS_2_PLUS:
 356       enabled = (level >= 2);
 357       break;
 358
 359     case OPT_LEVELS_2_PLUS_SPEED_ONLY:
 360       enabled = (level >= 2 && !size);
 361       break;
 362
 363     case OPT_LEVELS_3_PLUS:
 364       enabled = (level >= 3);
 365       break;
 366
 367     case OPT_LEVELS_3_PLUS_AND_SIZE:
 368       enabled = (level >= 3 || size);
 369       break;
 370
 371     case OPT_LEVELS_SIZE:
 372       enabled = size;
 373       break;
 374
 375     case OPT_LEVELS_FAST:
 376       enabled = fast;
 377       break;
 378
 379     case OPT_LEVELS_NONE:
 380     default:
 381       gcc_unreachable ();
 382     }
 383
 384   if (enabled)
 385     handle_generated_option (opts, opts_set, default_opt->opt_index,
 386                              default_opt->arg, default_opt->value,
 387                              lang_mask, DK_UNSPECIFIED, loc,
 388                              handlers, dc);
 389   else if (default_opt->arg == NULL
 390            && !option->cl_reject_negative)
 391     handle_generated_option (opts, opts_set, default_opt->opt_index,
 392                              default_opt->arg, !default_opt->value,
 393                              lang_mask, DK_UNSPECIFIED, loc,
 394                              handlers, dc);
 395 }
 396
 397 /* As indicated by the optimization level LEVEL (-Os if SIZE is set,
 398    -Ofast if FAST is set), apply the options in array DEFAULT_OPTS to
 399    OPTS and OPTS_SET, diagnostic context DC, location LOC, with
 400    language mask LANG_MASK and option handlers HANDLERS.  */
 401
 402 static void
 403 maybe_default_options (struct gcc_options *opts,
 404                        struct gcc_options *opts_set,
 405                        const struct default_options *default_opts,
 406                        int level, bool size, bool fast,
 407                        unsigned int lang_mask,
 408                        const struct cl_option_handlers *handlers,
 409                        location_t loc,
 410                        diagnostic_context *dc)
 411 {
 412   size_t i;
 413
 414   for (i = 0; default_opts[i].levels != OPT_LEVELS_NONE; i++)
 415     maybe_default_option (opts, opts_set, &default_opts[i],
 416                           level, size, fast, lang_mask, handlers, loc, dc);
 417 }
 418
 419 /* Table of options enabled by default at different levels.  */
 420
 421 static const struct default_options default_options_table[] =
 422   {
 423     /* -O1 optimizations.  */
 424     { OPT_LEVELS_1_PLUS, OPT_fdefer_pop, NULL, 1 },
 425 #ifdef DELAY_SLOTS
 426     { OPT_LEVELS_1_PLUS, OPT_fdelayed_branch, NULL, 1 },
 427 #endif
 428     { OPT_LEVELS_1_PLUS, OPT_fguess_branch_probability, NULL, 1 },
 429     { OPT_LEVELS_1_PLUS, OPT_fcprop_registers, NULL, 1 },
 430     { OPT_LEVELS_1_PLUS, OPT_fforward_propagate, NULL, 1 },
 431     { OPT_LEVELS_1_PLUS, OPT_fif_conversion, NULL, 1 },
 432     { OPT_LEVELS_1_PLUS, OPT_fif_conversion2, NULL, 1 },
 433     { OPT_LEVELS_1_PLUS, OPT_fipa_pure_const, NULL, 1 },
 434     { OPT_LEVELS_1_PLUS, OPT_fipa_reference, NULL, 1 },
 435     { OPT_LEVELS_1_PLUS, OPT_fipa_profile, NULL, 1 },
 436     { OPT_LEVELS_1_PLUS, OPT_fmerge_constants, NULL, 1 },
 437     { OPT_LEVELS_1_PLUS, OPT_fsplit_wide_types, NULL, 1 },
 438     { OPT_LEVELS_1_PLUS, OPT_ftree_ccp, NULL, 1 },
 439     { OPT_LEVELS_1_PLUS, OPT_ftree_bit_ccp, NULL, 1 },
 440     { OPT_LEVELS_1_PLUS, OPT_ftree_dce, NULL, 1 },
 441     { OPT_LEVELS_1_PLUS, OPT_ftree_dominator_opts, NULL, 1 },
 442     { OPT_LEVELS_1_PLUS, OPT_ftree_dse, NULL, 1 },
 443     { OPT_LEVELS_1_PLUS, OPT_ftree_ter, NULL, 1 },
 444     { OPT_LEVELS_1_PLUS, OPT_ftree_sra, NULL, 1 },
 445     { OPT_LEVELS_1_PLUS, OPT_ftree_copyrename, NULL, 1 },
 446     { OPT_LEVELS_1_PLUS, OPT_ftree_fre, NULL, 1 },
 447     { OPT_LEVELS_1_PLUS, OPT_ftree_copy_prop, NULL, 1 },
 448     { OPT_LEVELS_1_PLUS, OPT_ftree_sink, NULL, 1 },
 449     { OPT_LEVELS_1_PLUS, OPT_ftree_ch, NULL, 1 },
 450     { OPT_LEVELS_1_PLUS, OPT_fcombine_stack_adjustments, NULL, 1 },
 451     { OPT_LEVELS_1_PLUS, OPT_fcompare_elim, NULL, 1 },
 452
 453     /* -O2 optimizations.  */
 454     { OPT_LEVELS_2_PLUS, OPT_finline_small_functions, NULL, 1 },
 455     { OPT_LEVELS_2_PLUS, OPT_findirect_inlining, NULL, 1 },
 456     { OPT_LEVELS_2_PLUS, OPT_fpartial_inlining, NULL, 1 },
 457     { OPT_LEVELS_2_PLUS, OPT_fthread_jumps, NULL, 1 },
 458     { OPT_LEVELS_2_PLUS, OPT_fcrossjumping, NULL, 1 },
 459     { OPT_LEVELS_2_PLUS, OPT_foptimize_sibling_calls, NULL, 1 },
 460     { OPT_LEVELS_2_PLUS, OPT_fcse_follow_jumps, NULL, 1 },
 461     { OPT_LEVELS_2_PLUS, OPT_fgcse, NULL, 1 },
 462     { OPT_LEVELS_2_PLUS, OPT_fexpensive_optimizations, NULL, 1 },
 463     { OPT_LEVELS_2_PLUS, OPT_frerun_cse_after_loop, NULL, 1 },
 464     { OPT_LEVELS_2_PLUS, OPT_fcaller_saves, NULL, 1 },
 465     { OPT_LEVELS_2_PLUS, OPT_fpeephole2, NULL, 1 },
 466 #ifdef INSN_SCHEDULING
 467   /* Only run the pre-regalloc scheduling pass if optimizing for speed.  */
 468     { OPT_LEVELS_2_PLUS_SPEED_ONLY, OPT_fschedule_insns, NULL, 1 },
 469     { OPT_LEVELS_2_PLUS, OPT_fschedule_insns2, NULL, 1 },
 470 #endif
 471     { OPT_LEVELS_2_PLUS, OPT_fregmove, NULL, 1 },
 472     { OPT_LEVELS_2_PLUS, OPT_fstrict_aliasing, NULL, 1 },
 473     { OPT_LEVELS_2_PLUS, OPT_fstrict_overflow, NULL, 1 },
 474     { OPT_LEVELS_2_PLUS, OPT_freorder_blocks, NULL, 1 },
 475     { OPT_LEVELS_2_PLUS, OPT_freorder_functions, NULL, 1 },
 476     { OPT_LEVELS_2_PLUS, OPT_ftree_vrp, NULL, 1 },
 477     { OPT_LEVELS_2_PLUS, OPT_ftree_builtin_call_dce, NULL, 1 },
 478     { OPT_LEVELS_2_PLUS, OPT_ftree_pre, NULL, 1 },
 479     { OPT_LEVELS_2_PLUS, OPT_ftree_switch_conversion, NULL, 1 },
 480     { OPT_LEVELS_2_PLUS, OPT_fipa_cp, NULL, 1 },
 481     { OPT_LEVELS_2_PLUS, OPT_fdevirtualize, NULL, 1 },
 482     { OPT_LEVELS_2_PLUS, OPT_fipa_sra, NULL, 1 },
 483     { OPT_LEVELS_2_PLUS, OPT_falign_loops, NULL, 1 },
 484     { OPT_LEVELS_2_PLUS, OPT_falign_jumps, NULL, 1 },
 485     { OPT_LEVELS_2_PLUS, OPT_falign_labels, NULL, 1 },
 486     { OPT_LEVELS_2_PLUS, OPT_falign_functions, NULL, 1 },
 487
 488     /* -O3 optimizations.  */
 489     { OPT_LEVELS_3_PLUS, OPT_ftree_loop_distribute_patterns, NULL, 1 },
 490     { OPT_LEVELS_3_PLUS, OPT_fpredictive_commoning, NULL, 1 },
 491     /* Inlining of functions reducing size is a good idea with -Os
 492        regardless of them being declared inline.  */
 493     { OPT_LEVELS_3_PLUS_AND_SIZE, OPT_finline_functions, NULL, 1 },
 494     { OPT_LEVELS_1_PLUS, OPT_finline_functions_called_once, NULL, 1 },
 495     { OPT_LEVELS_3_PLUS, OPT_funswitch_loops, NULL, 1 },
 496     { OPT_LEVELS_3_PLUS, OPT_fgcse_after_reload, NULL, 1 },
 497     { OPT_LEVELS_3_PLUS, OPT_ftree_vectorize, NULL, 1 },
 498     { OPT_LEVELS_3_PLUS, OPT_fipa_cp_clone, NULL, 1 },
 499
 500     /* -Ofast adds optimizations to -O3.  */
 501     { OPT_LEVELS_FAST, OPT_ffast_math, NULL, 1 },
 502
 503     { OPT_LEVELS_NONE, 0, NULL, 0 }
 504   };
 505
 506 /* Default the options in OPTS and OPTS_SET based on the optimization
 507    settings in DECODED_OPTIONS and DECODED_OPTIONS_COUNT.  */
 508 void
 509 default_options_optimization (struct gcc_options *opts,
 510                               struct gcc_options *opts_set,
 511                               struct cl_decoded_option *decoded_options,
 512                               unsigned int decoded_options_count,
 513                               location_t loc,
 514                               unsigned int lang_mask,
 515                               const struct cl_option_handlers *handlers,
 516                               diagnostic_context *dc)
 517 {
 518   unsigned int i;
 519   int opt2;
 520
 521   /* Scan to see what optimization level has been specified.  That will
 522      determine the default value of many flags.  */
 523   for (i = 1; i < decoded_options_count; i++)
 524     {
 525       struct cl_decoded_option *opt = &decoded_options[i];
 526       switch (opt->opt_index)
 527         {
 528         case OPT_O:
 529           if (*opt->arg == '\0')
 530             {
 531               opts->x_optimize = 1;
 532               opts->x_optimize_size = 0;
 533               opts->x_optimize_fast = 0;
 534             }
 535           else
 536             {
 537               const int optimize_val = integral_argument (opt->arg);
 538               if (optimize_val == -1)
 539                 error_at (loc,
 540                           "argument to %qs should be a non-negative integer",
 541                           "-O");
 542               else
 543                 {
 544                   opts->x_optimize = optimize_val;
 545                   if ((unsigned int) opts->x_optimize > 255)
 546                     opts->x_optimize = 255;
 547                   opts->x_optimize_size = 0;
 548                   opts->x_optimize_fast = 0;
 549                 }
 550             }
 551           break;
 552
 553         case OPT_Os:
 554           opts->x_optimize_size = 1;
 555
 556           /* Optimizing for size forces optimize to be 2.  */
 557           opts->x_optimize = 2;
 558           opts->x_optimize_fast = 0;
 559           break;
 560
 561         case OPT_Ofast:
 562           /* -Ofast only adds flags to -O3.  */
 563           opts->x_optimize_size = 0;
 564           opts->x_optimize = 3;
 565           opts->x_optimize_fast = 1;
 566           break;
 567
 568         default:
 569           /* Ignore other options in this prescan.  */
 570           break;
 571         }
 572     }
 573
 574   maybe_default_options (opts, opts_set, default_options_table,
 575                          opts->x_optimize, opts->x_optimize_size,
 576                          opts->x_optimize_fast, lang_mask, handlers, loc, dc);
 577
 578   /* -O2 param settings.  */
 579   opt2 = (opts->x_optimize >= 2);
 580
 581   /* Track fields in field-sensitive alias analysis.  */
 582   maybe_set_param_value
 583     (PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE,
 584      opt2 ? 100 : default_param_value (PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE),
 585      opts->x_param_values, opts_set->x_param_values);
 586
 587   /* For -O1 only do loop invariant motion for very small loops.  */
 588   maybe_set_param_value
 589     (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP,
 590      opt2 ? default_param_value (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP) : 1000,
 591      opts->x_param_values, opts_set->x_param_values);
 592
 593   if (opts->x_optimize_size)
 594     /* We want to crossjump as much as possible.  */
 595     maybe_set_param_value (PARAM_MIN_CROSSJUMP_INSNS, 1,
 596                            opts->x_param_values, opts_set->x_param_values);
 597   else
 598     maybe_set_param_value (PARAM_MIN_CROSSJUMP_INSNS,
 599                            default_param_value (PARAM_MIN_CROSSJUMP_INSNS),
 600                            opts->x_param_values, opts_set->x_param_values);
 601
 602   /* Allow default optimizations to be specified on a per-machine basis.  */
 603   maybe_default_options (opts, opts_set,
 604                          targetm_common.option_optimization_table,
 605                          opts->x_optimize, opts->x_optimize_size,
 606                          opts->x_optimize_fast, lang_mask, handlers, loc, dc);
 607 }
 608
 609 /* After all options at LOC have been read into OPTS and OPTS_SET,
 610    finalize settings of those options and diagnose incompatible
 611    combinations.  */
 612 void
 613 finish_options (struct gcc_options *opts, struct gcc_options *opts_set,
 614                 location_t loc)
 615 {
 616   enum unwind_info_type ui_except;
 617
 618   if (opts->x_dump_base_name && ! IS_ABSOLUTE_PATH (opts->x_dump_base_name))
 619     {
 620       /* First try to make OPTS->X_DUMP_BASE_NAME relative to the
 621          OPTS->X_DUMP_DIR_NAME directory.  Then try to make
 622          OPTS->X_DUMP_BASE_NAME relative to the OPTS->X_AUX_BASE_NAME
 623          directory, typically the directory to contain the object
 624          file.  */
 625       if (opts->x_dump_dir_name)
 626         opts->x_dump_base_name = concat (opts->x_dump_dir_name,
 627                                          opts->x_dump_base_name, NULL);
 628       else if (opts->x_aux_base_name
 629                && strcmp (opts->x_aux_base_name, HOST_BIT_BUCKET) != 0)
 630         {
 631           const char *aux_base;
 632
 633           base_of_path (opts->x_aux_base_name, &aux_base);
 634           if (opts->x_aux_base_name != aux_base)
 635             {
 636               int dir_len = aux_base - opts->x_aux_base_name;
 637               char *new_dump_base_name =
 638                 XNEWVEC (char, strlen (opts->x_dump_base_name) + dir_len + 1);
 639
 640               /* Copy directory component from OPTS->X_AUX_BASE_NAME.  */
 641               memcpy (new_dump_base_name, opts->x_aux_base_name, dir_len);
 642               /* Append existing OPTS->X_DUMP_BASE_NAME.  */
 643               strcpy (new_dump_base_name + dir_len, opts->x_dump_base_name);
 644               opts->x_dump_base_name = new_dump_base_name;
 645             }
 646         }
 647     }
 648
 649   /* Handle related options for unit-at-a-time, toplevel-reorder, and
 650      section-anchors.  */
 651   if (!opts->x_flag_unit_at_a_time)
 652     {
 653       if (opts->x_flag_section_anchors && opts_set->x_flag_section_anchors)
 654         error_at (loc, "section anchors must be disabled when unit-at-a-time "
 655                   "is disabled");
 656       opts->x_flag_section_anchors = 0;
 657       if (opts->x_flag_toplevel_reorder == 1)
 658         error_at (loc, "toplevel reorder must be disabled when unit-at-a-time "
 659                   "is disabled");
 660       opts->x_flag_toplevel_reorder = 0;
 661     }
 662
 663   /* -Wmissing-noreturn is alias for -Wsuggest-attribute=noreturn.  */
 664   if (opts->x_warn_missing_noreturn)
 665     opts->x_warn_suggest_attribute_noreturn = true;
 666
 667   /* Unless the user has asked for section anchors, we disable toplevel
 668      reordering at -O0 to disable transformations that might be surprising
 669      to end users and to get -fno-toplevel-reorder tested.  */
 670   if (!opts->x_optimize
 671       && opts->x_flag_toplevel_reorder == 2
 672       && !(opts->x_flag_section_anchors && opts_set->x_flag_section_anchors))
 673     {
 674       opts->x_flag_toplevel_reorder = 0;
 675       opts->x_flag_section_anchors = 0;
 676     }
 677   if (!opts->x_flag_toplevel_reorder)
 678     {
 679       if (opts->x_flag_section_anchors && opts_set->x_flag_section_anchors)
 680         error_at (loc, "section anchors must be disabled when toplevel reorder"
 681                   " is disabled");
 682       opts->x_flag_section_anchors = 0;
 683     }
 684
 685   if (!opts->x_flag_opts_finished)
 686     {
 687       if (opts->x_flag_pie)
 688         opts->x_flag_pic = opts->x_flag_pie;
 689       if (opts->x_flag_pic && !opts->x_flag_pie)
 690         opts->x_flag_shlib = 1;
 691       opts->x_flag_opts_finished = true;
 692     }
 693
 694   if (opts->x_optimize == 0)
 695     {
 696       /* Inlining does not work if not optimizing,
 697          so force it not to be done.  */
 698       opts->x_warn_inline = 0;
 699       opts->x_flag_no_inline = 1;
 700     }
 701
 702   /* The optimization to partition hot and cold basic blocks into separate
 703      sections of the .o and executable files does not work (currently)
 704      with exception handling.  This is because there is no support for
 705      generating unwind info.  If opts->x_flag_exceptions is turned on
 706      we need to turn off the partitioning optimization.  */
 707
 708   ui_except = targetm_common.except_unwind_info (opts);
 709
 710   if (opts->x_flag_exceptions
 711       && opts->x_flag_reorder_blocks_and_partition
 712       && (ui_except == UI_SJLJ || ui_except == UI_TARGET))
 713     {
 714       inform (loc,
 715               "-freorder-blocks-and-partition does not work "
 716               "with exceptions on this architecture");
 717       opts->x_flag_reorder_blocks_and_partition = 0;
 718       opts->x_flag_reorder_blocks = 1;
 719     }
 720
 721   /* If user requested unwind info, then turn off the partitioning
 722      optimization.  */
 723
 724   if (opts->x_flag_unwind_tables
 725       && !targetm_common.unwind_tables_default
 726       && opts->x_flag_reorder_blocks_and_partition
 727       && (ui_except == UI_SJLJ || ui_except == UI_TARGET))
 728     {
 729       inform (loc,
 730               "-freorder-blocks-and-partition does not support "
 731               "unwind info on this architecture");
 732       opts->x_flag_reorder_blocks_and_partition = 0;
 733       opts->x_flag_reorder_blocks = 1;
 734     }
 735
 736   /* If the target requested unwind info, then turn off the partitioning
 737      optimization with a different message.  Likewise, if the target does not
 738      support named sections.  */
 739
 740   if (opts->x_flag_reorder_blocks_and_partition
 741       && (!targetm_common.have_named_sections
 742           || (opts->x_flag_unwind_tables
 743               && targetm_common.unwind_tables_default
 744               && (ui_except == UI_SJLJ || ui_except == UI_TARGET))))
 745     {
 746       inform (loc,
 747               "-freorder-blocks-and-partition does not work "
 748               "on this architecture");
 749       opts->x_flag_reorder_blocks_and_partition = 0;
 750       opts->x_flag_reorder_blocks = 1;
 751     }
 752
 753   if (opts->x_flag_reorder_blocks_and_partition
 754       && !opts_set->x_flag_reorder_functions)
 755     opts->x_flag_reorder_functions = 1;
 756
 757   /* Pipelining of outer loops is only possible when general pipelining
 758      capabilities are requested.  */
 759   if (!opts->x_flag_sel_sched_pipelining)
 760     opts->x_flag_sel_sched_pipelining_outer_loops = 0;
 761
 762   if (opts->x_flag_conserve_stack)
 763     {
 764       maybe_set_param_value (PARAM_LARGE_STACK_FRAME, 100,
 765                              opts->x_param_values, opts_set->x_param_values);
 766       maybe_set_param_value (PARAM_STACK_FRAME_GROWTH, 40,
 767                              opts->x_param_values, opts_set->x_param_values);
 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 (!opts->x_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         if (lang_mask == CL_DRIVER)
1251           break;;
1252
1253         undoc_mask = ((opts->x_verbose_flag | opts->x_extra_warnings)
1254                       ? 0
1255                       : CL_UNDOCUMENTED);
1256         /* First display any single language specific options.  */
1257         for (i = 0; i < cl_lang_count; i++)
1258           print_specific_help
1259             (1U << i, (all_langs_mask & (~ (1U << i))) | undoc_mask, 0, opts,
1260              lang_mask);
1261         /* Next display any multi language specific options.  */
1262         print_specific_help (0, undoc_mask, all_langs_mask, opts, lang_mask);
1263         /* Then display any remaining, non-language options.  */
1264         for (i = CL_MIN_OPTION_CLASS; i <= CL_MAX_OPTION_CLASS; i <<= 1)
1265           if (i != CL_DRIVER)
1266             print_specific_help (i, undoc_mask, 0, opts, lang_mask);
1267         opts->x_exit_after_options = true;
1268         break;
1269       }
1270
1271     case OPT__target_help:
1272       if (lang_mask == CL_DRIVER)
1273         break;
1274
1275       print_specific_help (CL_TARGET, CL_UNDOCUMENTED, 0, opts, lang_mask);
1276       opts->x_exit_after_options = true;
1277       break;
1278
1279     case OPT__help_:
1280       {
1281         const char * a = arg;
1282         unsigned int include_flags = 0;
1283         /* Note - by default we include undocumented options when listing
1284            specific classes.  If you only want to see documented options
1285            then add ",^undocumented" to the --help= option.  E.g.:
1286
1287            --help=target,^undocumented  */
1288         unsigned int exclude_flags = 0;
1289
1290         if (lang_mask == CL_DRIVER)
1291           break;
1292
1293         /* Walk along the argument string, parsing each word in turn.
1294            The format is:
1295            arg = [^]{word}[,{arg}]
1296            word = {optimizers|target|warnings|undocumented|
1297                    params|common|<language>}  */
1298         while (* a != 0)
1299           {
1300             static const struct
1301             {
1302               const char * string;
1303               unsigned int flag;
1304             }
1305             specifics[] =
1306             {
1307               { "optimizers", CL_OPTIMIZATION },
1308               { "target", CL_TARGET },
1309               { "warnings", CL_WARNING },
1310               { "undocumented", CL_UNDOCUMENTED },
1311               { "params", CL_PARAMS },
1312               { "joined", CL_JOINED },
1313               { "separate", CL_SEPARATE },
1314               { "common", CL_COMMON },
1315               { NULL, 0 }
1316             };
1317             unsigned int * pflags;
1318             const char * comma;
1319             unsigned int lang_flag, specific_flag;
1320             unsigned int len;
1321             unsigned int i;
1322
1323             if (* a == '^')
1324               {
1325                 ++ a;
1326                 pflags = & exclude_flags;
1327               }
1328             else
1329               pflags = & include_flags;
1330
1331             comma = strchr (a, ',');
1332             if (comma == NULL)
1333               len = strlen (a);
1334             else
1335               len = comma - a;
1336             if (len == 0)
1337               {
1338                 a = comma + 1;
1339                 continue;
1340               }
1341
1342             /* Check to see if the string matches an option class name.  */
1343             for (i = 0, specific_flag = 0; specifics[i].string != NULL; i++)
1344               if (strncasecmp (a, specifics[i].string, len) == 0)
1345                 {
1346                   specific_flag = specifics[i].flag;
1347                   break;
1348                 }
1349
1350             /* Check to see if the string matches a language name.
1351                Note - we rely upon the alpha-sorted nature of the entries in
1352                the lang_names array, specifically that shorter names appear
1353                before their longer variants.  (i.e. C before C++).  That way
1354                when we are attempting to match --help=c for example we will
1355                match with C first and not C++.  */
1356             for (i = 0, lang_flag = 0; i < cl_lang_count; i++)
1357               if (strncasecmp (a, lang_names[i], len) == 0)
1358                 {
1359                   lang_flag = 1U << i;
1360                   break;
1361                 }
1362
1363             if (specific_flag != 0)
1364               {
1365                 if (lang_flag == 0)
1366                   * pflags |= specific_flag;
1367                 else
1368                   {
1369                     /* The option's argument matches both the start of a
1370                        language name and the start of an option class name.
1371                        We have a special case for when the user has
1372                        specified "--help=c", but otherwise we have to issue
1373                        a warning.  */
1374                     if (strncasecmp (a, "c", len) == 0)
1375                       * pflags |= lang_flag;
1376                     else
1377                       warning_at (loc, 0,
1378                                   "--help argument %q.*s is ambiguous, "
1379                                   "please be more specific",
1380                                   len, a);
1381                   }
1382               }
1383             else if (lang_flag != 0)
1384               * pflags |= lang_flag;
1385             else
1386               warning_at (loc, 0,
1387                           "unrecognized argument to --help= option: %q.*s",
1388                           len, a);
1389
1390             if (comma == NULL)
1391               break;
1392             a = comma + 1;
1393           }
1394
1395         if (include_flags)
1396           print_specific_help (include_flags, exclude_flags, 0, opts,
1397                                lang_mask);
1398         opts->x_exit_after_options = true;
1399         break;
1400       }
1401
1402     case OPT__version:
1403       if (lang_mask == CL_DRIVER)
1404         break;
1405
1406       opts->x_exit_after_options = true;
1407       break;
1408
1409     case OPT_O:
1410     case OPT_Os:
1411     case OPT_Ofast:
1412       /* Currently handled in a prescan.  */
1413       break;
1414
1415     case OPT_Werror_:
1416       if (lang_mask == CL_DRIVER)
1417         break;
1418
1419       enable_warning_as_error (arg, value, lang_mask, handlers,
1420                                opts, opts_set, loc, dc);
1421       break;
1422
1423     case OPT_Wlarger_than_:
1424       opts->x_larger_than_size = value;
1425       opts->x_warn_larger_than = value != -1;
1426       break;
1427
1428     case OPT_Wfatal_errors:
1429       dc->fatal_errors = value;
1430       break;
1431
1432     case OPT_Wframe_larger_than_:
1433       opts->x_frame_larger_than_size = value;
1434       opts->x_warn_frame_larger_than = value != -1;
1435       break;
1436
1437     case OPT_Wstack_usage_:
1438       opts->x_warn_stack_usage = value;
1439       opts->x_flag_stack_usage_info = value != -1;
1440       break;
1441
1442     case OPT_Wstrict_aliasing:
1443       set_Wstrict_aliasing (opts, value);
1444       break;
1445
1446     case OPT_Wstrict_overflow:
1447       opts->x_warn_strict_overflow = (value
1448                                       ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
1449                                       : 0);
1450       break;
1451
1452     case OPT_Wsystem_headers:
1453       dc->dc_warn_system_headers = value;
1454       break;
1455
1456     case OPT_aux_info:
1457       opts->x_flag_gen_aux_info = 1;
1458       break;
1459
1460     case OPT_auxbase_strip:
1461       {
1462         char *tmp = xstrdup (arg);
1463         strip_off_ending (tmp, strlen (tmp));
1464         if (tmp[0])
1465           opts->x_aux_base_name = tmp;
1466       }
1467       break;
1468
1469     case OPT_d:
1470       decode_d_option (arg, opts, loc, dc);
1471       break;
1472
1473     case OPT_fcall_used_:
1474     case OPT_fcall_saved_:
1475       /* Deferred.  */
1476       break;
1477
1478     case OPT_fdbg_cnt_:
1479     case OPT_fdbg_cnt_list:
1480       /* Deferred.  */
1481       break;
1482
1483     case OPT_fdebug_prefix_map_:
1484       /* Deferred.  */
1485       break;
1486
1487     case OPT_fdiagnostics_show_location_:
1488       diagnostic_prefixing_rule (dc) = (diagnostic_prefixing_rule_t) value;
1489       break;
1490
1491     case OPT_fdiagnostics_show_option:
1492       dc->show_option_requested = value;
1493       break;
1494
1495     case OPT_fdump_:
1496       /* Deferred.  */
1497       break;
1498
1499     case OPT_ffast_math:
1500       set_fast_math_flags (opts, value);
1501       break;
1502
1503     case OPT_funsafe_math_optimizations:
1504       set_unsafe_math_optimizations_flags (opts, value);
1505       break;
1506
1507     case OPT_ffixed_:
1508       /* Deferred.  */
1509       break;
1510
1511     case OPT_finline_limit_:
1512       set_param_value ("max-inline-insns-single", value / 2,
1513                        opts->x_param_values, opts_set->x_param_values);
1514       set_param_value ("max-inline-insns-auto", value / 2,
1515                        opts->x_param_values, opts_set->x_param_values);
1516       break;
1517
1518     case OPT_finstrument_functions_exclude_function_list_:
1519       add_comma_separated_to_vector
1520         (&opts->x_flag_instrument_functions_exclude_functions, arg);
1521       break;
1522
1523     case OPT_finstrument_functions_exclude_file_list_:
1524       add_comma_separated_to_vector
1525         (&opts->x_flag_instrument_functions_exclude_files, arg);
1526       break;
1527
1528     case OPT_fmessage_length_:
1529       pp_set_line_maximum_length (dc->printer, value);
1530       break;
1531
1532     case OPT_fpack_struct_:
1533       if (value <= 0 || (value & (value - 1)) || value > 16)
1534         error_at (loc,
1535                   "structure alignment must be a small power of two, not %d",
1536                   value);
1537       else
1538         opts->x_initial_max_fld_align = value;
1539       break;
1540
1541     case OPT_fplugin_:
1542     case OPT_fplugin_arg_:
1543       /* Deferred.  */
1544       break;
1545
1546     case OPT_fprofile_use_:
1547       opts->x_profile_data_prefix = xstrdup (arg);
1548       opts->x_flag_profile_use = true;
1549       value = true;
1550       /* No break here - do -fprofile-use processing. */
1551     case OPT_fprofile_use:
1552       if (!opts_set->x_flag_branch_probabilities)
1553         opts->x_flag_branch_probabilities = value;
1554       if (!opts_set->x_flag_profile_values)
1555         opts->x_flag_profile_values = value;
1556       if (!opts_set->x_flag_unroll_loops)
1557         opts->x_flag_unroll_loops = value;
1558       if (!opts_set->x_flag_peel_loops)
1559         opts->x_flag_peel_loops = value;
1560       if (!opts_set->x_flag_tracer)
1561         opts->x_flag_tracer = value;
1562       if (!opts_set->x_flag_value_profile_transformations)
1563         opts->x_flag_value_profile_transformations = value;
1564       if (!opts_set->x_flag_inline_functions)
1565         opts->x_flag_inline_functions = value;
1566       if (!opts_set->x_flag_ipa_cp)
1567         opts->x_flag_ipa_cp = value;
1568       if (!opts_set->x_flag_ipa_cp_clone
1569           && value && opts->x_flag_ipa_cp)
1570         opts->x_flag_ipa_cp_clone = value;
1571       if (!opts_set->x_flag_predictive_commoning)
1572         opts->x_flag_predictive_commoning = value;
1573       if (!opts_set->x_flag_unswitch_loops)
1574         opts->x_flag_unswitch_loops = value;
1575       if (!opts_set->x_flag_gcse_after_reload)
1576         opts->x_flag_gcse_after_reload = value;
1577       break;
1578
1579     case OPT_fprofile_generate_:
1580       opts->x_profile_data_prefix = xstrdup (arg);
1581       value = true;
1582       /* No break here - do -fprofile-generate processing. */
1583     case OPT_fprofile_generate:
1584       if (!opts_set->x_profile_arc_flag)
1585         opts->x_profile_arc_flag = value;
1586       if (!opts_set->x_flag_profile_values)
1587         opts->x_flag_profile_values = value;
1588       if (!opts_set->x_flag_value_profile_transformations)
1589         opts->x_flag_value_profile_transformations = value;
1590       if (!opts_set->x_flag_inline_functions)
1591         opts->x_flag_inline_functions = value;
1592       /* FIXME: Instrumentation we insert makes ipa-reference bitmaps
1593          quadratic.  Disable the pass until better memory representation
1594          is done.  */
1595       if (!opts_set->x_flag_ipa_reference && opts->x_in_lto_p)
1596         opts->x_flag_ipa_reference = false;
1597       break;
1598
1599     case OPT_fshow_column:
1600       dc->show_column = value;
1601       break;
1602
1603     case OPT_frandom_seed:
1604       /* The real switch is -fno-random-seed.  */
1605       if (value)
1606         return false;
1607       /* Deferred.  */
1608       break;
1609
1610     case OPT_frandom_seed_:
1611       /* Deferred.  */
1612       break;
1613
1614     case OPT_fsched_verbose_:
1615 #ifdef INSN_SCHEDULING
1616       /* Handled with Var in common.opt.  */
1617       break;
1618 #else
1619       return false;
1620 #endif
1621
1622     case OPT_fsched_stalled_insns_:
1623       opts->x_flag_sched_stalled_insns = value;
1624       if (opts->x_flag_sched_stalled_insns == 0)
1625         opts->x_flag_sched_stalled_insns = -1;
1626       break;
1627
1628     case OPT_fsched_stalled_insns_dep_:
1629       opts->x_flag_sched_stalled_insns_dep = value;
1630       break;
1631
1632     case OPT_fstack_check_:
1633       if (!strcmp (arg, "no"))
1634         opts->x_flag_stack_check = NO_STACK_CHECK;
1635       else if (!strcmp (arg, "generic"))
1636         /* This is the old stack checking method.  */
1637         opts->x_flag_stack_check = STACK_CHECK_BUILTIN
1638                            ? FULL_BUILTIN_STACK_CHECK
1639                            : GENERIC_STACK_CHECK;
1640       else if (!strcmp (arg, "specific"))
1641         /* This is the new stack checking method.  */
1642         opts->x_flag_stack_check = STACK_CHECK_BUILTIN
1643                            ? FULL_BUILTIN_STACK_CHECK
1644                            : STACK_CHECK_STATIC_BUILTIN
1645                              ? STATIC_BUILTIN_STACK_CHECK
1646                              : GENERIC_STACK_CHECK;
1647       else
1648         warning_at (loc, 0, "unknown stack check parameter \"%s\"", arg);
1649       break;
1650
1651     case OPT_fstack_limit:
1652       /* The real switch is -fno-stack-limit.  */
1653       if (value)
1654         return false;
1655       /* Deferred.  */
1656       break;
1657
1658     case OPT_fstack_limit_register_:
1659     case OPT_fstack_limit_symbol_:
1660       /* Deferred.  */
1661       break;
1662
1663     case OPT_fstack_usage:
1664       opts->x_flag_stack_usage = value;
1665       opts->x_flag_stack_usage_info = value != 0;
1666       break;
1667
1668     case OPT_ftree_vectorizer_verbose_:
1669       vect_set_verbosity_level (opts, value);
1670       break;
1671
1672     case OPT_g:
1673       set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg, opts, opts_set,
1674                        loc);
1675       break;
1676
1677     case OPT_gcoff:
1678       set_debug_level (SDB_DEBUG, false, arg, opts, opts_set, loc);
1679       break;
1680
1681     case OPT_gdwarf_:
1682       if (value < 2 || value > 4)
1683         error_at (loc, "dwarf version %d is not supported", value);
1684       else
1685         opts->x_dwarf_version = value;
1686       set_debug_level (DWARF2_DEBUG, false, "", opts, opts_set, loc);
1687       break;
1688
1689     case OPT_ggdb:
1690       set_debug_level (NO_DEBUG, 2, arg, opts, opts_set, loc);
1691       break;
1692
1693     case OPT_gstabs:
1694     case OPT_gstabs_:
1695       set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg, opts, opts_set,
1696                        loc);
1697       break;
1698
1699     case OPT_gvms:
1700       set_debug_level (VMS_DEBUG, false, arg, opts, opts_set, loc);
1701       break;
1702
1703     case OPT_gxcoff:
1704     case OPT_gxcoff_:
1705       set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg, opts, opts_set,
1706                        loc);
1707       break;
1708
1709     case OPT_pedantic_errors:
1710       opts->x_pedantic = 1;
1711       dc->pedantic_errors = 1;
1712       break;
1713
1714     case OPT_flto:
1715       opts->x_flag_lto = value ? "" : NULL;
1716       break;
1717
1718     case OPT_w:
1719       dc->dc_inhibit_warnings = true;
1720       break;
1721
1722     case OPT_fmax_errors_:
1723       dc->max_errors = value;
1724       break;
1725
1726     case OPT_fuse_linker_plugin:
1727       /* No-op. Used by the driver and passed to us because it starts with f.*/
1728       break;
1729
1730     case OPT_Wuninitialized:
1731       /* Also turn on maybe uninitialized warning.  */
1732       opts->x_warn_maybe_uninitialized = value;
1733       break;
1734
1735     default:
1736       /* If the flag was handled in a standard way, assume the lack of
1737          processing here is intentional.  */
1738       gcc_assert (option_flag_var (scode, opts));
1739       break;
1740     }
1741
1742   return true;
1743 }
1744
1745 /* Handle --param NAME=VALUE.  */
1746 static void
1747 handle_param (struct gcc_options *opts, struct gcc_options *opts_set,
1748               location_t loc, const char *carg)
1749 {
1750   char *equal, *arg;
1751   int value;
1752
1753   arg = xstrdup (carg);
1754   equal = strchr (arg, '=');
1755   if (!equal)
1756     error_at (loc, "%s: --param arguments should be of the form NAME=VALUE",
1757               arg);
1758   else
1759     {
1760       value = integral_argument (equal + 1);
1761       if (value == -1)
1762         error_at (loc, "invalid --param value %qs", equal + 1);
1763       else
1764         {
1765           *equal = '\0';
1766           set_param_value (arg, value,
1767                            opts->x_param_values, opts_set->x_param_values);
1768         }
1769     }
1770
1771   free (arg);
1772 }
1773
1774 /* Used to set the level of strict aliasing warnings in OPTS,
1775    when no level is specified (i.e., when -Wstrict-aliasing, and not
1776    -Wstrict-aliasing=level was given).
1777    ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
1778    and 0 otherwise.  After calling this function, wstrict_aliasing will be
1779    set to the default value of -Wstrict_aliasing=level, currently 3.  */
1780 void
1781 set_Wstrict_aliasing (struct gcc_options *opts, int onoff)
1782 {
1783   gcc_assert (onoff == 0 || onoff == 1);
1784   if (onoff != 0)
1785     opts->x_warn_strict_aliasing = 3;
1786   else
1787     opts->x_warn_strict_aliasing = 0;
1788 }
1789
1790 /* The following routines are useful in setting all the flags that
1791    -ffast-math and -fno-fast-math imply.  */
1792 static void
1793 set_fast_math_flags (struct gcc_options *opts, int set)
1794 {
1795   if (!opts->frontend_set_flag_unsafe_math_optimizations)
1796     {
1797       opts->x_flag_unsafe_math_optimizations = set;
1798       set_unsafe_math_optimizations_flags (opts, set);
1799     }
1800   if (!opts->frontend_set_flag_finite_math_only)
1801     opts->x_flag_finite_math_only = set;
1802   if (!opts->frontend_set_flag_errno_math)
1803     opts->x_flag_errno_math = !set;
1804   if (set)
1805     {
1806       if (!opts->frontend_set_flag_signaling_nans)
1807         opts->x_flag_signaling_nans = 0;
1808       if (!opts->frontend_set_flag_rounding_math)
1809         opts->x_flag_rounding_math = 0;
1810       if (!opts->frontend_set_flag_cx_limited_range)
1811         opts->x_flag_cx_limited_range = 1;
1812     }
1813 }
1814
1815 /* When -funsafe-math-optimizations is set the following
1816    flags are set as well.  */
1817 static void
1818 set_unsafe_math_optimizations_flags (struct gcc_options *opts, int set)
1819 {
1820   if (!opts->frontend_set_flag_trapping_math)
1821     opts->x_flag_trapping_math = !set;
1822   if (!opts->frontend_set_flag_signed_zeros)
1823     opts->x_flag_signed_zeros = !set;
1824   if (!opts->frontend_set_flag_associative_math)
1825     opts->x_flag_associative_math = set;
1826   if (!opts->frontend_set_flag_reciprocal_math)
1827     opts->x_flag_reciprocal_math = set;
1828 }
1829
1830 /* Return true iff flags in OPTS are set as if -ffast-math.  */
1831 bool
1832 fast_math_flags_set_p (const struct gcc_options *opts)
1833 {
1834   return (!opts->x_flag_trapping_math
1835           && opts->x_flag_unsafe_math_optimizations
1836           && opts->x_flag_finite_math_only
1837           && !opts->x_flag_signed_zeros
1838           && !opts->x_flag_errno_math);
1839 }
1840
1841 /* Return true iff flags are set as if -ffast-math but using the flags stored
1842    in the struct cl_optimization structure.  */
1843 bool
1844 fast_math_flags_struct_set_p (struct cl_optimization *opt)
1845 {
1846   return (!opt->x_flag_trapping_math
1847           && opt->x_flag_unsafe_math_optimizations
1848           && opt->x_flag_finite_math_only
1849           && !opt->x_flag_signed_zeros
1850           && !opt->x_flag_errno_math);
1851 }
1852
1853 /* Handle a debug output -g switch for options OPTS
1854    (OPTS_SET->x_write_symbols storing whether a debug type was passed
1855    explicitly), location LOC.  EXTENDED is true or false to support
1856    extended output (2 is special and means "-ggdb" was given).  */
1857 static void
1858 set_debug_level (enum debug_info_type type, int extended, const char *arg,
1859                  struct gcc_options *opts, struct gcc_options *opts_set,
1860                  location_t loc)
1861 {
1862   opts->x_use_gnu_debug_info_extensions = extended;
1863
1864   if (type == NO_DEBUG)
1865     {
1866       if (opts->x_write_symbols == NO_DEBUG)
1867         {
1868           opts->x_write_symbols = PREFERRED_DEBUGGING_TYPE;
1869
1870           if (extended == 2)
1871             {
1872 #ifdef DWARF2_DEBUGGING_INFO
1873               opts->x_write_symbols = DWARF2_DEBUG;
1874 #elif defined DBX_DEBUGGING_INFO
1875               opts->x_write_symbols = DBX_DEBUG;
1876 #endif
1877             }
1878
1879           if (opts->x_write_symbols == NO_DEBUG)
1880             warning_at (loc, 0, "target system does not support debug output");
1881         }
1882     }
1883   else
1884     {
1885       /* Does it conflict with an already selected type?  */
1886       if (opts_set->x_write_symbols != NO_DEBUG
1887           && opts->x_write_symbols != NO_DEBUG
1888           && type != opts->x_write_symbols)
1889         error_at (loc, "debug format \"%s\" conflicts with prior selection",
1890                   debug_type_names[type]);
1891       opts->x_write_symbols = type;
1892       opts_set->x_write_symbols = type;
1893     }
1894
1895   /* A debug flag without a level defaults to level 2.  */
1896   if (*arg == '\0')
1897     {
1898       if (!opts->x_debug_info_level)
1899         opts->x_debug_info_level = DINFO_LEVEL_NORMAL;
1900     }
1901   else
1902     {
1903       int argval = integral_argument (arg);
1904       if (argval == -1)
1905         error_at (loc, "unrecognised debug output level \"%s\"", arg);
1906       else if (argval > 3)
1907         error_at (loc, "debug output level %s is too high", arg);
1908       else
1909         opts->x_debug_info_level = (enum debug_info_levels) argval;
1910     }
1911 }
1912
1913 /* Arrange to dump core on error for diagnostic context DC.  (The
1914    regular error message is still printed first, except in the case of
1915    abort ().)  */
1916
1917 static void
1918 setup_core_dumping (diagnostic_context *dc)
1919 {
1920 #ifdef SIGABRT
1921   signal (SIGABRT, SIG_DFL);
1922 #endif
1923 #if defined(HAVE_SETRLIMIT)
1924   {
1925     struct rlimit rlim;
1926     if (getrlimit (RLIMIT_CORE, &rlim) != 0)
1927       fatal_error ("getting core file size maximum limit: %m");
1928     rlim.rlim_cur = rlim.rlim_max;
1929     if (setrlimit (RLIMIT_CORE, &rlim) != 0)
1930       fatal_error ("setting core file size limit to maximum: %m");
1931   }
1932 #endif
1933   diagnostic_abort_on_error (dc);
1934 }
1935
1936 /* Parse a -d<ARG> command line switch for OPTS, location LOC,
1937    diagnostic context DC.  */
1938
1939 static void
1940 decode_d_option (const char *arg, struct gcc_options *opts,
1941                  location_t loc, diagnostic_context *dc)
1942 {
1943   int c;
1944
1945   while (*arg)
1946     switch (c = *arg++)
1947       {
1948       case 'A':
1949         opts->x_flag_debug_asm = 1;
1950         break;
1951       case 'p':
1952         opts->x_flag_print_asm_name = 1;
1953         break;
1954       case 'P':
1955         opts->x_flag_dump_rtl_in_asm = 1;
1956         opts->x_flag_print_asm_name = 1;
1957         break;
1958       case 'v':
1959         opts->x_graph_dump_format = vcg;
1960         break;
1961       case 'x':
1962         opts->x_rtl_dump_and_exit = 1;
1963         break;
1964       case 'D': /* These are handled by the preprocessor.  */
1965       case 'I':
1966       case 'M':
1967       case 'N':
1968       case 'U':
1969         break;
1970       case 'H':
1971         setup_core_dumping (dc);
1972         break;
1973       case 'a':
1974         opts->x_flag_dump_all_passed = true;
1975         break;
1976
1977       default:
1978           warning_at (loc, 0, "unrecognized gcc debugging option: %c", c);
1979         break;
1980       }
1981 }
1982
1983 /* Enable (or disable if VALUE is 0) a warning option ARG (language
1984    mask LANG_MASK, option handlers HANDLERS) as an error for option
1985    structures OPTS and OPTS_SET, diagnostic context DC (possibly
1986    NULL), location LOC.  This is used by -Werror=.  */
1987
1988 static void
1989 enable_warning_as_error (const char *arg, int value, unsigned int lang_mask,
1990                          const struct cl_option_handlers *handlers,
1991                          struct gcc_options *opts,
1992                          struct gcc_options *opts_set,
1993                          location_t loc, diagnostic_context *dc)
1994 {
1995   char *new_option;
1996   int option_index;
1997
1998   new_option = XNEWVEC (char, strlen (arg) + 2);
1999   new_option[0] = 'W';
2000   strcpy (new_option + 1, arg);
2001   option_index = find_opt (new_option, lang_mask);
2002   if (option_index == OPT_SPECIAL_unknown)
2003     {
2004       error_at (loc, "-Werror=%s: no option -%s", arg, new_option);
2005     }
2006   else
2007     {
2008       const diagnostic_t kind = value ? DK_ERROR : DK_WARNING;
2009
2010       control_warning_option (option_index, (int) kind, value,
2011                               loc, lang_mask,
2012                               handlers, opts, opts_set, dc);
2013       if (option_index == OPT_Wuninitialized)
2014         enable_warning_as_error ("maybe-uninitialized", value, lang_mask,
2015                                  handlers, opts, opts_set, loc, dc);
2016     }
2017   free (new_option);
2018 }
2019
2020 /* Return malloced memory for the name of the option OPTION_INDEX
2021    which enabled a diagnostic (context CONTEXT), originally of type
2022    ORIG_DIAG_KIND but possibly converted to DIAG_KIND by options such
2023    as -Werror.  */
2024
2025 char *
2026 option_name (diagnostic_context *context, int option_index,
2027              diagnostic_t orig_diag_kind, diagnostic_t diag_kind)
2028 {
2029   if (option_index)
2030     {
2031       /* A warning classified as an error.  */
2032       if ((orig_diag_kind == DK_WARNING || orig_diag_kind == DK_PEDWARN)
2033           && diag_kind == DK_ERROR)
2034         return concat (cl_options[OPT_Werror_].opt_text,
2035                        /* Skip over "-W".  */
2036                        cl_options[option_index].opt_text + 2,
2037                        NULL);
2038       /* A warning with option.  */
2039       else
2040         return xstrdup (cl_options[option_index].opt_text);
2041     }
2042   /* A warning without option classified as an error.  */
2043   else if (orig_diag_kind == DK_WARNING || orig_diag_kind == DK_PEDWARN
2044            || diag_kind == DK_WARNING)
2045     {
2046       if (context->warning_as_error_requested)
2047         return xstrdup (cl_options[OPT_Werror].opt_text);
2048       else
2049         return xstrdup (_("enabled by default"));
2050     }
2051   else
2052     return NULL;
2053 }