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