gcc/opts.c

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