contrib/gcc-5.0/gcc/opts.c

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