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