gcc/opts.c

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