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