gcc/opts.c

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