gcc/opts.c

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