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