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