gcc/opts.c

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