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