1 /* Command line option handling.
2 Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
3 Free Software Foundation, Inc.
4 Contributed by Neil Booth.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
25 #include "coretypes.h"
32 #include "langhooks.h"
38 #include "diagnostic.h"
39 #include "opts-diagnostic.h"
40 #include "tm_p.h" /* For OPTIMIZATION_OPTIONS. */
41 #include "insn-attr.h" /* For INSN_SCHEDULING. */
43 #include "tree-pass.h"
48 #include "lto-streamer.h"
50 /* Value of the -G xx switch, and whether it was passed or not. */
51 unsigned HOST_WIDE_INT g_switch_value;
54 /* Same for selective scheduling. */
55 bool sel_sched_switch_set;
57 /* True if we should exit after parsing options. */
58 bool exit_after_options;
60 /* True to warn about any objects definitions whose size is larger
61 than N bytes. Also want about function definitions whose returned
62 values are larger than N bytes, where N is `larger_than_size'. */
63 bool warn_larger_than;
64 HOST_WIDE_INT larger_than_size;
66 /* True to warn about any function whose frame size is larger
68 bool warn_frame_larger_than;
69 HOST_WIDE_INT frame_larger_than_size;
71 /* Type(s) of debugging information we are producing (if any). See
72 flags.h for the definitions of the different possible types of
73 debugging information. */
74 enum debug_info_type write_symbols = NO_DEBUG;
76 /* Level of debugging information we are producing. See flags.h for
77 the definitions of the different possible levels. */
78 enum debug_info_level debug_info_level = DINFO_LEVEL_NONE;
80 /* A major contribution to object and executable size is debug
81 information size. A major contribution to debug information size
82 is struct descriptions replicated in several object files. The
83 following flags attempt to reduce this information. The basic
84 idea is to not emit struct debugging information in the current
85 compilation unit when that information will be generated by
86 another compilation unit.
88 Debug information for a struct defined in the current source
89 file should be generated in the object file. Likewise the
90 debug information for a struct defined in a header should be
91 generated in the object file of the corresponding source file.
92 Both of these case are handled when the base name of the file of
93 the struct definition matches the base name of the source file
94 of the current compilation unit. This matching emits minimal
95 struct debugging information.
97 The base file name matching rule above will fail to emit debug
98 information for structs defined in system headers. So a second
99 category of files includes system headers in addition to files
102 The remaining types of files are library headers and application
103 headers. We cannot currently distinguish these two types. */
105 enum debug_struct_file
107 DINFO_STRUCT_FILE_NONE, /* Debug no structs. */
108 DINFO_STRUCT_FILE_BASE, /* Debug structs defined in files with the
109 same base name as the compilation unit. */
110 DINFO_STRUCT_FILE_SYS, /* Also debug structs defined in system
112 DINFO_STRUCT_FILE_ANY /* Debug structs defined in all files. */
115 /* Generic structs (e.g. templates not explicitly specialized)
116 may not have a compilation unit associated with them, and so
117 may need to be treated differently from ordinary structs.
119 Structs only handled by reference (indirectly), will also usually
120 not need as much debugging information. */
122 static enum debug_struct_file debug_struct_ordinary[DINFO_USAGE_NUM_ENUMS]
123 = { DINFO_STRUCT_FILE_ANY, DINFO_STRUCT_FILE_ANY, DINFO_STRUCT_FILE_ANY };
124 static enum debug_struct_file debug_struct_generic[DINFO_USAGE_NUM_ENUMS]
125 = { DINFO_STRUCT_FILE_ANY, DINFO_STRUCT_FILE_ANY, DINFO_STRUCT_FILE_ANY };
127 /* Parse the -femit-struct-debug-detailed option value
128 and set the flag variables. */
130 #define MATCH( prefix, string ) \
131 ((strncmp (prefix, string, sizeof prefix - 1) == 0) \
132 ? ((string += sizeof prefix - 1), 1) : 0)
135 set_struct_debug_option (const char *spec)
137 /* various labels for comparison */
138 static char dfn_lbl[] = "dfn:", dir_lbl[] = "dir:", ind_lbl[] = "ind:";
139 static char ord_lbl[] = "ord:", gen_lbl[] = "gen:";
140 static char none_lbl[] = "none", any_lbl[] = "any";
141 static char base_lbl[] = "base", sys_lbl[] = "sys";
143 enum debug_struct_file files = DINFO_STRUCT_FILE_ANY;
144 /* Default is to apply to as much as possible. */
145 enum debug_info_usage usage = DINFO_USAGE_NUM_ENUMS;
146 int ord = 1, gen = 1;
149 if (MATCH (dfn_lbl, spec))
150 usage = DINFO_USAGE_DFN;
151 else if (MATCH (dir_lbl, spec))
152 usage = DINFO_USAGE_DIR_USE;
153 else if (MATCH (ind_lbl, spec))
154 usage = DINFO_USAGE_IND_USE;
156 /* Generics or not? */
157 if (MATCH (ord_lbl, spec))
159 else if (MATCH (gen_lbl, spec))
162 /* What allowable environment? */
163 if (MATCH (none_lbl, spec))
164 files = DINFO_STRUCT_FILE_NONE;
165 else if (MATCH (any_lbl, spec))
166 files = DINFO_STRUCT_FILE_ANY;
167 else if (MATCH (sys_lbl, spec))
168 files = DINFO_STRUCT_FILE_SYS;
169 else if (MATCH (base_lbl, spec))
170 files = DINFO_STRUCT_FILE_BASE;
172 error ("argument %qs to %<-femit-struct-debug-detailed%> not recognized",
175 /* Effect the specification. */
176 if (usage == DINFO_USAGE_NUM_ENUMS)
180 debug_struct_ordinary[DINFO_USAGE_DFN] = files;
181 debug_struct_ordinary[DINFO_USAGE_DIR_USE] = files;
182 debug_struct_ordinary[DINFO_USAGE_IND_USE] = files;
186 debug_struct_generic[DINFO_USAGE_DFN] = files;
187 debug_struct_generic[DINFO_USAGE_DIR_USE] = files;
188 debug_struct_generic[DINFO_USAGE_IND_USE] = files;
194 debug_struct_ordinary[usage] = files;
196 debug_struct_generic[usage] = files;
200 set_struct_debug_option (spec+1);
203 /* No more -femit-struct-debug-detailed specifications.
206 error ("argument %qs to %<-femit-struct-debug-detailed%> unknown",
208 if (debug_struct_ordinary[DINFO_USAGE_DIR_USE]
209 < debug_struct_ordinary[DINFO_USAGE_IND_USE]
210 || debug_struct_generic[DINFO_USAGE_DIR_USE]
211 < debug_struct_generic[DINFO_USAGE_IND_USE])
212 error ("%<-femit-struct-debug-detailed=dir:...%> must allow at least"
213 " as much as %<-femit-struct-debug-detailed=ind:...%>");
217 /* Find the base name of a path, stripping off both directories and
218 a single final extension. */
220 base_of_path (const char *path, const char **base_out)
222 const char *base = path;
224 const char *p = path;
228 if (IS_DIR_SEPARATOR(c))
243 /* Match the base name of a file to the base name of a compilation unit. */
245 static const char *main_input_basename;
246 static int main_input_baselength;
249 matches_main_base (const char *path)
251 /* Cache the last query. */
252 static const char *last_path = NULL;
253 static int last_match = 0;
254 if (path != last_path)
257 int length = base_of_path (path, &base);
259 last_match = (length == main_input_baselength
260 && memcmp (base, main_input_basename, length) == 0);
265 #ifdef DEBUG_DEBUG_STRUCT
268 dump_struct_debug (tree type, enum debug_info_usage usage,
269 enum debug_struct_file criterion, int generic,
270 int matches, int result)
272 /* Find the type name. */
273 tree type_decl = TYPE_STUB_DECL (type);
275 const char *name = 0;
276 if (TREE_CODE (t) == TYPE_DECL)
279 name = IDENTIFIER_POINTER (t);
281 fprintf (stderr, " struct %d %s %s %s %s %d %p %s\n",
283 DECL_IN_SYSTEM_HEADER (type_decl) ? "sys" : "usr",
284 matches ? "bas" : "hdr",
285 generic ? "gen" : "ord",
286 usage == DINFO_USAGE_DFN ? ";" :
287 usage == DINFO_USAGE_DIR_USE ? "." : "*",
289 (void*) type_decl, name);
292 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
293 dump_struct_debug (type, usage, criterion, generic, matches, result)
297 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
304 should_emit_struct_debug (tree type, enum debug_info_usage usage)
306 enum debug_struct_file criterion;
308 bool generic = lang_hooks.types.generic_p (type);
311 criterion = debug_struct_generic[usage];
313 criterion = debug_struct_ordinary[usage];
315 if (criterion == DINFO_STRUCT_FILE_NONE)
316 return DUMP_GSTRUCT (type, usage, criterion, generic, false, false);
317 if (criterion == DINFO_STRUCT_FILE_ANY)
318 return DUMP_GSTRUCT (type, usage, criterion, generic, false, true);
320 type_decl = TYPE_STUB_DECL (type);
322 if (criterion == DINFO_STRUCT_FILE_SYS && DECL_IN_SYSTEM_HEADER (type_decl))
323 return DUMP_GSTRUCT (type, usage, criterion, generic, false, true);
325 if (matches_main_base (DECL_SOURCE_FILE (type_decl)))
326 return DUMP_GSTRUCT (type, usage, criterion, generic, true, true);
327 return DUMP_GSTRUCT (type, usage, criterion, generic, false, false);
330 /* Nonzero means use GNU-only extensions in the generated symbolic
331 debugging information. Currently, this only has an effect when
332 write_symbols is set to DBX_DEBUG, XCOFF_DEBUG, or DWARF_DEBUG. */
333 bool use_gnu_debug_info_extensions;
335 /* The default visibility for all symbols (unless overridden) */
336 enum symbol_visibility default_visibility = VISIBILITY_DEFAULT;
338 /* Global visibility options. */
339 struct visibility_flags visibility_options;
341 /* What to print when a switch has no documentation. */
342 static const char undocumented_msg[] = N_("This switch lacks documentation");
344 /* Used for bookkeeping on whether user set these flags so
345 -fprofile-use/-fprofile-generate does not use them. */
346 static bool profile_arc_flag_set, flag_profile_values_set;
347 static bool flag_unroll_loops_set, flag_tracer_set;
348 static bool flag_value_profile_transformations_set;
349 static bool flag_peel_loops_set, flag_branch_probabilities_set;
350 static bool flag_inline_functions_set, flag_ipa_cp_set, flag_ipa_cp_clone_set;
351 static bool flag_predictive_commoning_set, flag_unswitch_loops_set, flag_gcse_after_reload_set;
353 /* Functions excluded from profiling. */
355 typedef char *char_p; /* For DEF_VEC_P. */
357 DEF_VEC_ALLOC_P(char_p,heap);
359 static VEC(char_p,heap) *flag_instrument_functions_exclude_functions;
360 static VEC(char_p,heap) *flag_instrument_functions_exclude_files;
362 typedef const char *const_char_p; /* For DEF_VEC_P. */
363 DEF_VEC_P(const_char_p);
364 DEF_VEC_ALLOC_P(const_char_p,heap);
366 static VEC(const_char_p,heap) *ignored_options;
368 /* Language specific warning pass for unused results. */
369 bool flag_warn_unused_result = false;
371 /* Input file names. */
372 const char **in_fnames;
373 unsigned num_in_fnames;
375 static int common_handle_option (size_t scode, const char *arg, int value,
376 unsigned int lang_mask, int kind);
377 static void handle_param (const char *);
378 static char *write_langs (unsigned int lang_mask);
379 static void complain_wrong_lang (const char *, const struct cl_option *,
380 unsigned int lang_mask);
381 static void set_debug_level (enum debug_info_type type, int extended,
384 /* Return a malloced slash-separated list of languages in MASK. */
386 write_langs (unsigned int mask)
388 unsigned int n = 0, len = 0;
389 const char *lang_name;
392 for (n = 0; (lang_name = lang_names[n]) != 0; n++)
393 if (mask & (1U << n))
394 len += strlen (lang_name) + 1;
396 result = XNEWVEC (char, len);
398 for (n = 0; (lang_name = lang_names[n]) != 0; n++)
399 if (mask & (1U << n))
403 strcpy (result + len, lang_name);
404 len += strlen (lang_name);
412 /* Complain that switch OPT_INDEX does not apply to this front end. */
414 complain_wrong_lang (const char *text, const struct cl_option *option,
415 unsigned int lang_mask)
417 char *ok_langs, *bad_lang;
419 /* The LTO front end inherits all the options from the first front
420 end that was used. However, not all the original front end
421 options make sense in LTO.
423 A real solution would be to filter this in collect2, but collect2
424 does not have access to all the option attributes to know what to
425 filter. So, in lto1 we silently accept inherited flags and do
427 if (lang_mask & CL_LTO)
430 ok_langs = write_langs (option->flags);
431 bad_lang = write_langs (lang_mask);
433 /* Eventually this should become a hard error IMO. */
434 warning (0, "command line option \"%s\" is valid for %s but not for %s",
435 text, ok_langs, bad_lang);
441 /* Buffer the unknown option described by the string OPT. Currently,
442 we only complain about unknown -Wno-* options if they may have
443 prevented a diagnostic. Otherwise, we just ignore them.
444 Note that if we do complain, it is only as a warning, not an error;
445 passing the compiler an unrecognised -Wno-* option should never
446 change whether the compilation succeeds or fails. */
448 static void postpone_unknown_option_warning(const char *opt)
450 VEC_safe_push (const_char_p, heap, ignored_options, opt);
453 /* Produce a warning for each option previously buffered. */
455 void print_ignored_options (void)
457 location_t saved_loc = input_location;
461 while (!VEC_empty (const_char_p, ignored_options))
464 opt = VEC_pop (const_char_p, ignored_options);
465 warning (0, "unrecognized command line option \"%s\"", opt);
468 input_location = saved_loc;
472 /* Handle option OPT_INDEX, and argument ARG, for the language
473 indicated by LANG_MASK. VALUE is true, unless no- form of an -f or
474 -W option was given. KIND is the diagnostic_t if this is a
475 diagnostics option, DK_UNSPECIFIED otherwise. Returns false if the
476 switch was invalid. */
478 handle_option (int opt_index, int value, const char *arg,
479 unsigned int lang_mask, int kind)
481 const struct cl_option *option = &cl_options[opt_index];
483 if (option->flag_var)
484 set_option (opt_index, value, arg, kind);
486 if (option->flags & lang_mask)
488 if (lang_hooks.handle_option (opt_index, arg, value, kind) == 0)
492 lto_register_user_option (opt_index, arg, value, lang_mask);
496 if (option->flags & CL_COMMON)
498 if (common_handle_option (opt_index, arg, value, lang_mask, kind) == 0)
502 lto_register_user_option (opt_index, arg, value, CL_COMMON);
506 if (option->flags & CL_TARGET)
508 if (!targetm.handle_option (opt_index, arg, value))
512 lto_register_user_option (opt_index, arg, value, CL_TARGET);
518 /* Handle the switch DECODED for the language indicated by
521 read_cmdline_option (struct cl_decoded_option *decoded,
522 unsigned int lang_mask)
524 const struct cl_option *option;
527 if (decoded->opt_index == OPT_SPECIAL_unknown)
531 if (opt[1] == 'W' && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-')
532 /* We don't generate warnings for unknown -Wno-* options
533 unless we issue diagnostics. */
534 postpone_unknown_option_warning (opt);
536 error ("unrecognized command line option %qs", opt);
540 option = &cl_options[decoded->opt_index];
541 opt = decoded->orig_option_with_args_text;
543 if (decoded->errors & CL_ERR_DISABLED)
545 error ("command line option %qs"
546 " is not supported by this configuration", opt);
550 if (decoded->errors & CL_ERR_WRONG_LANG)
552 complain_wrong_lang (opt, option, lang_mask);
556 if (decoded->errors & CL_ERR_MISSING_ARG)
558 if (!lang_hooks.missing_argument (opt, decoded->opt_index))
559 error ("missing argument to %qs", opt);
563 if (decoded->errors & CL_ERR_UINT_ARG)
565 error ("argument to %qs should be a non-negative integer",
570 gcc_assert (!decoded->errors);
572 if (!handle_option (decoded->opt_index, decoded->value, decoded->arg,
573 lang_mask, DK_UNSPECIFIED))
574 error ("unrecognized command line option %qs", opt);
577 /* Handle FILENAME from the command line. */
579 add_input_filename (const char *filename)
582 in_fnames = XRESIZEVEC (const char *, in_fnames, num_in_fnames);
583 in_fnames[num_in_fnames - 1] = filename;
586 /* Add comma-separated strings to a char_p vector. */
589 add_comma_separated_to_vector (VEC(char_p,heap) **pvec, const char* arg)
596 /* We never free this string. */
609 VEC_safe_push (char_p, heap, *pvec, token_start);
612 if (*r == '\\' && r[1] == ',')
620 if (*token_start != '\0')
621 VEC_safe_push (char_p, heap, *pvec, token_start);
624 /* Return whether we should exclude FNDECL from instrumentation. */
627 flag_instrument_functions_exclude_p (tree fndecl)
629 if (VEC_length (char_p, flag_instrument_functions_exclude_functions) > 0)
635 name = lang_hooks.decl_printable_name (fndecl, 0);
637 VEC_iterate (char_p, flag_instrument_functions_exclude_functions,
641 if (strstr (name, s) != NULL)
646 if (VEC_length (char_p, flag_instrument_functions_exclude_files) > 0)
652 name = DECL_SOURCE_FILE (fndecl);
654 VEC_iterate (char_p, flag_instrument_functions_exclude_files, i, s);
657 if (strstr (name, s) != NULL)
666 /* Handle the vector of command line options. LANG_MASK
667 contains has a single bit set representing the current
670 read_cmdline_options (struct cl_decoded_option *decoded_options,
671 unsigned int decoded_options_count,
672 unsigned int lang_mask)
676 for (i = 1; i < decoded_options_count; i++)
678 if (decoded_options[i].opt_index == OPT_SPECIAL_input_file)
680 if (main_input_filename == NULL)
682 main_input_filename = decoded_options[i].arg;
683 main_input_baselength
684 = base_of_path (main_input_filename, &main_input_basename);
686 add_input_filename (decoded_options[i].arg);
690 read_cmdline_option (decoded_options + i, lang_mask);
694 /* Parse command line options and set default flag values. Do minimal
695 options processing. The decoded options are placed in *DECODED_OPTIONS
696 and *DECODED_OPTIONS_COUNT. */
698 decode_options (unsigned int argc, const char **argv,
699 struct cl_decoded_option **decoded_options,
700 unsigned int *decoded_options_count)
702 static bool first_time_p = true;
703 static int initial_min_crossjump_insns;
704 static int initial_max_fields_for_field_sensitive;
705 static int initial_loop_invariant_max_bbs_in_loop;
706 static unsigned int initial_lang_mask;
708 unsigned int i, lang_mask;
717 /* Perform language-specific options initialization. */
718 initial_lang_mask = lang_mask = lang_hooks.init_options (argc, argv);
720 lang_hooks.initialize_diagnostics (global_dc);
722 /* Save initial values of parameters we reset. */
723 initial_min_crossjump_insns
724 = compiler_params[PARAM_MIN_CROSSJUMP_INSNS].value;
725 initial_max_fields_for_field_sensitive
726 = compiler_params[PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE].value;
727 initial_loop_invariant_max_bbs_in_loop
728 = compiler_params[PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP].value;
731 lang_mask = initial_lang_mask;
733 decode_cmdline_options_to_array (argc, argv, lang_mask,
734 decoded_options, decoded_options_count);
736 /* Scan to see what optimization level has been specified. That will
737 determine the default value of many flags. */
738 for (i = 1; i < *decoded_options_count; i++)
740 struct cl_decoded_option *opt = &(*decoded_options)[i];
741 switch (opt->opt_index)
744 if (*opt->arg == '\0')
752 const int optimize_val = integral_argument (opt->arg);
753 if (optimize_val == -1)
754 error ("argument to %qs should be a non-negative integer",
758 optimize = optimize_val;
759 if ((unsigned int) optimize > 255)
770 /* Optimizing for size forces optimize to be 2. */
776 /* -Ofast only adds flags to -O3. */
783 /* Ignore other options in this prescan. */
788 /* Use priority coloring if cover classes is not defined for the
790 if (targetm.ira_cover_classes == NULL)
791 flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
793 /* -O1 optimizations. */
794 opt1 = (optimize >= 1);
795 flag_defer_pop = opt1;
797 flag_delayed_branch = opt1;
799 #ifdef CAN_DEBUG_WITHOUT_FP
800 flag_omit_frame_pointer = opt1;
802 flag_guess_branch_prob = opt1;
803 flag_cprop_registers = opt1;
804 flag_forward_propagate = opt1;
805 flag_if_conversion = opt1;
806 flag_if_conversion2 = opt1;
807 flag_ipa_pure_const = opt1;
808 flag_ipa_reference = opt1;
809 flag_ipa_profile = opt1;
810 flag_merge_constants = opt1;
811 flag_split_wide_types = opt1;
812 flag_tree_ccp = opt1;
813 flag_tree_dce = opt1;
814 flag_tree_dom = opt1;
815 flag_tree_dse = opt1;
816 flag_tree_ter = opt1;
817 flag_tree_sra = opt1;
818 flag_tree_copyrename = opt1;
819 flag_tree_fre = opt1;
820 flag_tree_copy_prop = opt1;
821 flag_tree_sink = opt1;
824 /* -O2 optimizations. */
825 opt2 = (optimize >= 2);
826 flag_inline_small_functions = opt2;
827 flag_indirect_inlining = opt2;
828 flag_thread_jumps = opt2;
829 flag_crossjumping = opt2;
830 flag_optimize_sibling_calls = opt2;
831 flag_cse_follow_jumps = opt2;
833 flag_expensive_optimizations = opt2;
834 flag_rerun_cse_after_loop = opt2;
835 flag_caller_saves = opt2;
836 flag_peephole2 = opt2;
837 #ifdef INSN_SCHEDULING
838 /* Only run the pre-regalloc scheduling pass if optimizing for speed. */
839 flag_schedule_insns = opt2 && ! optimize_size;
840 flag_schedule_insns_after_reload = opt2;
843 flag_strict_aliasing = opt2;
844 flag_strict_overflow = opt2;
845 flag_reorder_blocks = opt2;
846 flag_reorder_functions = opt2;
847 flag_tree_vrp = opt2;
848 flag_tree_builtin_call_dce = opt2;
849 flag_tree_pre = opt2;
850 flag_tree_switch_conversion = opt2;
854 /* Track fields in field-sensitive alias analysis. */
855 set_param_value ("max-fields-for-field-sensitive",
856 (opt2) ? 100 : initial_max_fields_for_field_sensitive);
858 /* For -O1 only do loop invariant motion for very small loops. */
859 set_param_value ("loop-invariant-max-bbs-in-loop",
860 (opt2) ? initial_loop_invariant_max_bbs_in_loop : 1000);
862 /* -O3 optimizations. */
863 opt3 = (optimize >= 3);
864 flag_predictive_commoning = opt3;
865 flag_inline_functions = opt3;
866 flag_unswitch_loops = opt3;
867 flag_gcse_after_reload = opt3;
868 flag_tree_vectorize = opt3;
869 flag_ipa_cp_clone = opt3;
870 if (flag_ipa_cp_clone)
873 /* Just -O1/-O0 optimizations. */
874 opt1_max = (optimize <= 1);
875 align_loops = opt1_max;
876 align_jumps = opt1_max;
877 align_labels = opt1_max;
878 align_functions = opt1_max;
882 /* Inlining of functions reducing size is a good idea regardless of them
883 being declared inline. */
884 flag_inline_functions = 1;
886 /* Basic optimization options. */
891 /* We want to crossjump as much as possible. */
892 set_param_value ("min-crossjump-insns", 1);
895 set_param_value ("min-crossjump-insns", initial_min_crossjump_insns);
897 /* -Ofast adds optimizations to -O3. */
900 /* Which is -ffast-math for now. */
901 set_fast_math_flags (1);
902 /* Allow targets to enable extra options with -Ofast
903 before general options processing so disabling them
904 again afterwards works. */
905 targetm.handle_ofast ();
908 /* Enable -Werror=coverage-mismatch by default */
909 enable_warning_as_error("coverage-mismatch", 1, lang_mask);
913 /* Initialize whether `char' is signed. */
914 flag_signed_char = DEFAULT_SIGNED_CHAR;
915 /* Set this to a special "uninitialized" value. The actual default is
916 set after target options have been processed. */
917 flag_short_enums = 2;
919 /* Initialize target_flags before OPTIMIZATION_OPTIONS so the latter can
921 target_flags = targetm.default_target_flags;
923 /* Some targets have ABI-specified unwind tables. */
924 flag_unwind_tables = targetm.unwind_tables_default;
928 /* Clear any options currently held for LTO. */
929 lto_clear_user_options ();
932 #ifdef OPTIMIZATION_OPTIONS
933 /* Allow default optimizations to be specified on a per-machine basis. */
934 OPTIMIZATION_OPTIONS (optimize, optimize_size);
937 read_cmdline_options (*decoded_options, *decoded_options_count, lang_mask);
939 if (dump_base_name && ! IS_ABSOLUTE_PATH (dump_base_name))
941 /* First try to make DUMP_BASE_NAME relative to the DUMP_DIR_NAME
942 directory. Then try to make DUMP_BASE_NAME relative to the
943 AUX_BASE_NAME directory, typically the directory to contain
946 dump_base_name = concat (dump_dir_name, dump_base_name, NULL);
947 else if (aux_base_name)
949 const char *aux_base;
951 base_of_path (aux_base_name, &aux_base);
952 if (aux_base_name != aux_base)
954 int dir_len = aux_base - aux_base_name;
955 char *new_dump_base_name =
956 XNEWVEC (char, strlen(dump_base_name) + dir_len + 1);
958 /* Copy directory component from AUX_BASE_NAME. */
959 memcpy (new_dump_base_name, aux_base_name, dir_len);
960 /* Append existing DUMP_BASE_NAME. */
961 strcpy (new_dump_base_name + dir_len, dump_base_name);
962 dump_base_name = new_dump_base_name;
967 /* Handle related options for unit-at-a-time, toplevel-reorder, and
969 if (!flag_unit_at_a_time)
971 if (flag_section_anchors == 1)
972 error ("Section anchors must be disabled when unit-at-a-time "
974 flag_section_anchors = 0;
975 if (flag_toplevel_reorder == 1)
976 error ("Toplevel reorder must be disabled when unit-at-a-time "
978 flag_toplevel_reorder = 0;
981 /* -Wmissing-noreturn is alias for -Wsuggest-attribute=noreturn. */
982 if (warn_missing_noreturn)
983 warn_suggest_attribute_noreturn = true;
985 /* Unless the user has asked for section anchors, we disable toplevel
986 reordering at -O0 to disable transformations that might be surprising
987 to end users and to get -fno-toplevel-reorder tested. */
988 if (!optimize && flag_toplevel_reorder == 2 && flag_section_anchors != 1)
990 flag_toplevel_reorder = 0;
991 flag_section_anchors = 0;
993 if (!flag_toplevel_reorder)
995 if (flag_section_anchors == 1)
996 error ("section anchors must be disabled when toplevel reorder"
998 flag_section_anchors = 0;
1004 flag_pic = flag_pie;
1005 if (flag_pic && !flag_pie)
1007 first_time_p = false;
1012 /* Inlining does not work if not optimizing,
1013 so force it not to be done. */
1018 /* The optimization to partition hot and cold basic blocks into separate
1019 sections of the .o and executable files does not work (currently)
1020 with exception handling. This is because there is no support for
1021 generating unwind info. If flag_exceptions is turned on we need to
1022 turn off the partitioning optimization. */
1024 if (flag_exceptions && flag_reorder_blocks_and_partition
1025 && (USING_SJLJ_EXCEPTIONS
1026 #ifdef TARGET_UNWIND_INFO
1031 inform (input_location,
1032 "-freorder-blocks-and-partition does not work with exceptions on this architecture");
1033 flag_reorder_blocks_and_partition = 0;
1034 flag_reorder_blocks = 1;
1037 /* If user requested unwind info, then turn off the partitioning
1040 if (flag_unwind_tables && ! targetm.unwind_tables_default
1041 && flag_reorder_blocks_and_partition
1042 && (USING_SJLJ_EXCEPTIONS
1043 #ifdef TARGET_UNWIND_INFO
1048 inform (input_location,
1049 "-freorder-blocks-and-partition does not support unwind info on this architecture");
1050 flag_reorder_blocks_and_partition = 0;
1051 flag_reorder_blocks = 1;
1054 /* If the target requested unwind info, then turn off the partitioning
1055 optimization with a different message. Likewise, if the target does not
1056 support named sections. */
1058 if (flag_reorder_blocks_and_partition
1059 && (!targetm.have_named_sections
1060 || (flag_unwind_tables && targetm.unwind_tables_default
1061 && (USING_SJLJ_EXCEPTIONS
1062 #ifdef TARGET_UNWIND_INFO
1067 inform (input_location,
1068 "-freorder-blocks-and-partition does not work on this architecture");
1069 flag_reorder_blocks_and_partition = 0;
1070 flag_reorder_blocks = 1;
1073 /* Pipelining of outer loops is only possible when general pipelining
1074 capabilities are requested. */
1075 if (!flag_sel_sched_pipelining)
1076 flag_sel_sched_pipelining_outer_loops = 0;
1078 if (!targetm.ira_cover_classes
1079 && flag_ira_algorithm == IRA_ALGORITHM_CB)
1081 inform (input_location,
1082 "-fira-algorithm=CB does not work on this architecture");
1083 flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
1086 if (flag_conserve_stack)
1088 if (!PARAM_SET_P (PARAM_LARGE_STACK_FRAME))
1089 PARAM_VALUE (PARAM_LARGE_STACK_FRAME) = 100;
1090 if (!PARAM_SET_P (PARAM_STACK_FRAME_GROWTH))
1091 PARAM_VALUE (PARAM_STACK_FRAME_GROWTH) = 40;
1093 if (flag_wpa || flag_ltrans)
1095 /* These passes are not WHOPR compatible yet. */
1097 flag_ipa_struct_reorg = 0;
1100 if (flag_lto || flag_whopr)
1103 flag_generate_lto = 1;
1105 /* When generating IL, do not operate in whole-program mode.
1106 Otherwise, symbols will be privatized too early, causing link
1108 flag_whole_program = 0;
1110 error ("LTO support has not been enabled in this configuration");
1114 /* Reconcile -flto and -fwhopr. Set additional flags as appropriate and
1115 check option consistency. */
1116 if (flag_lto && flag_whopr)
1117 error ("-flto and -fwhopr are mutually exclusive");
1120 #define LEFT_COLUMN 27
1122 /* Output ITEM, of length ITEM_WIDTH, in the left column,
1123 followed by word-wrapped HELP in a second column. */
1125 wrap_help (const char *help,
1127 unsigned int item_width,
1128 unsigned int columns)
1130 unsigned int col_width = LEFT_COLUMN;
1131 unsigned int remaining, room, len;
1133 remaining = strlen (help);
1137 room = columns - 3 - MAX (col_width, item_width);
1146 for (i = 0; help[i]; i++)
1148 if (i >= room && len != remaining)
1152 else if ((help[i] == '-' || help[i] == '/')
1153 && help[i + 1] != ' '
1154 && i > 0 && ISALPHA (help[i - 1]))
1159 printf( " %-*.*s %.*s\n", col_width, item_width, item, len, help);
1161 while (help[len] == ' ')
1169 /* Print help for a specific front-end, etc. */
1171 print_filtered_help (unsigned int include_flags,
1172 unsigned int exclude_flags,
1173 unsigned int any_flags,
1174 unsigned int columns)
1178 static char *printed = NULL;
1180 bool displayed = false;
1182 if (include_flags == CL_PARAMS)
1184 for (i = 0; i < LAST_PARAM; i++)
1186 const char *param = compiler_params[i].option;
1188 help = compiler_params[i].help;
1189 if (help == NULL || *help == '\0')
1191 if (exclude_flags & CL_UNDOCUMENTED)
1193 help = undocumented_msg;
1196 /* Get the translation. */
1199 wrap_help (help, param, strlen (param), columns);
1206 printed = XCNEWVAR (char, cl_options_count);
1208 for (i = 0; i < cl_options_count; i++)
1210 static char new_help[128];
1211 const struct cl_option *option = cl_options + i;
1216 if (include_flags == 0
1217 || ((option->flags & include_flags) != include_flags))
1219 if ((option->flags & any_flags) == 0)
1223 /* Skip unwanted switches. */
1224 if ((option->flags & exclude_flags) != 0)
1228 /* Skip switches that have already been printed. */
1234 help = option->help;
1237 if (exclude_flags & CL_UNDOCUMENTED)
1239 help = undocumented_msg;
1242 /* Get the translation. */
1245 /* Find the gap between the name of the
1246 option and its descriptive text. */
1247 tab = strchr (help, '\t');
1256 opt = option->opt_text;
1260 /* With the -Q option enabled we change the descriptive text associated
1261 with an option to be an indication of its current setting. */
1264 if (len < (LEFT_COLUMN + 2))
1265 strcpy (new_help, "\t\t");
1267 strcpy (new_help, "\t");
1269 if (option->flag_var != NULL)
1271 if (option->flags & CL_JOINED)
1273 if (option->var_type == CLVC_STRING)
1275 if (* (const char **) option->flag_var != NULL)
1276 snprintf (new_help + strlen (new_help),
1277 sizeof (new_help) - strlen (new_help),
1278 * (const char **) option->flag_var);
1281 sprintf (new_help + strlen (new_help),
1282 "%#x", * (int *) option->flag_var);
1285 strcat (new_help, option_enabled (i)
1286 ? _("[enabled]") : _("[disabled]"));
1292 wrap_help (help, opt, len, columns);
1298 unsigned int langs = include_flags & CL_LANG_ALL;
1301 printf (_(" No options with the desired characteristics were found\n"));
1306 /* PR 31349: Tell the user how to see all of the
1307 options supported by a specific front end. */
1308 for (i = 0; (1U << i) < CL_LANG_ALL; i ++)
1309 if ((1U << i) & langs)
1310 printf (_(" None found. Use --help=%s to show *all* the options supported by the %s front-end\n"),
1311 lang_names[i], lang_names[i]);
1315 else if (! displayed)
1316 printf (_(" All options with the desired characteristics have already been displayed\n"));
1321 /* Display help for a specified type of option.
1322 The options must have ALL of the INCLUDE_FLAGS set
1323 ANY of the flags in the ANY_FLAGS set
1324 and NONE of the EXCLUDE_FLAGS set. */
1326 print_specific_help (unsigned int include_flags,
1327 unsigned int exclude_flags,
1328 unsigned int any_flags)
1330 unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
1331 const char * description = NULL;
1332 const char * descrip_extra = "";
1335 static unsigned int columns = 0;
1337 /* Sanity check: Make sure that we do not have more
1338 languages than we have bits available to enumerate them. */
1339 gcc_assert ((1U << cl_lang_count) < CL_MIN_OPTION_CLASS);
1341 /* If we have not done so already, obtain
1342 the desired maximum width of the output. */
1347 GET_ENVIRONMENT (p, "COLUMNS");
1350 int value = atoi (p);
1357 /* Use a reasonable default. */
1361 /* Decide upon the title for the options that we are going to display. */
1362 for (i = 0, flag = 1; flag <= CL_MAX_OPTION_CLASS; flag <<= 1, i ++)
1364 switch (flag & include_flags)
1370 description = _("The following options are target specific");
1373 description = _("The following options control compiler warning messages");
1375 case CL_OPTIMIZATION:
1376 description = _("The following options control optimizations");
1379 description = _("The following options are language-independent");
1382 description = _("The --param option recognizes the following as parameters");
1385 if (i >= cl_lang_count)
1387 if (exclude_flags & all_langs_mask)
1388 description = _("The following options are specific to just the language ");
1390 description = _("The following options are supported by the language ");
1391 descrip_extra = lang_names [i];
1396 if (description == NULL)
1400 if (include_flags & CL_UNDOCUMENTED)
1401 description = _("The following options are not documented");
1402 else if (include_flags & CL_SEPARATE)
1403 description = _("The following options take separate arguments");
1404 else if (include_flags & CL_JOINED)
1405 description = _("The following options take joined arguments");
1408 internal_error ("unrecognized include_flags 0x%x passed to print_specific_help",
1415 if (any_flags & all_langs_mask)
1416 description = _("The following options are language-related");
1418 description = _("The following options are language-independent");
1422 printf ("%s%s:\n", description, descrip_extra);
1423 print_filtered_help (include_flags, exclude_flags, any_flags, columns);
1426 /* Handle target- and language-independent options. Return zero to
1427 generate an "unknown option" message. Only options that need
1428 extra handling need to be listed here; if you simply want
1429 VALUE assigned to a variable, it happens automatically. */
1432 common_handle_option (size_t scode, const char *arg, int value,
1433 unsigned int lang_mask, int kind ATTRIBUTE_UNUSED)
1435 static bool verbose = false;
1436 enum opt_code code = (enum opt_code) scode;
1451 unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
1452 unsigned int undoc_mask;
1455 undoc_mask = (verbose | extra_warnings) ? 0 : CL_UNDOCUMENTED;
1456 /* First display any single language specific options. */
1457 for (i = 0; i < cl_lang_count; i++)
1459 (1U << i, (all_langs_mask & (~ (1U << i))) | undoc_mask, 0);
1460 /* Next display any multi language specific options. */
1461 print_specific_help (0, undoc_mask, all_langs_mask);
1462 /* Then display any remaining, non-language options. */
1463 for (i = CL_MIN_OPTION_CLASS; i <= CL_MAX_OPTION_CLASS; i <<= 1)
1464 print_specific_help (i, undoc_mask, 0);
1465 exit_after_options = true;
1469 case OPT_ftarget_help:
1470 case OPT__target_help:
1471 print_specific_help (CL_TARGET, CL_UNDOCUMENTED, 0);
1472 exit_after_options = true;
1474 /* Allow the target a chance to give the user some additional information. */
1475 if (targetm.target_help)
1476 targetm.target_help ();
1482 const char * a = arg;
1483 unsigned int include_flags = 0;
1484 /* Note - by default we include undocumented options when listing
1485 specific classes. If you only want to see documented options
1486 then add ",^undocumented" to the --help= option. E.g.:
1488 --help=target,^undocumented */
1489 unsigned int exclude_flags = 0;
1491 /* Walk along the argument string, parsing each word in turn.
1493 arg = [^]{word}[,{arg}]
1494 word = {optimizers|target|warnings|undocumented|
1495 params|common|<language>} */
1500 const char * string;
1505 { "optimizers", CL_OPTIMIZATION },
1506 { "target", CL_TARGET },
1507 { "warnings", CL_WARNING },
1508 { "undocumented", CL_UNDOCUMENTED },
1509 { "params", CL_PARAMS },
1510 { "joined", CL_JOINED },
1511 { "separate", CL_SEPARATE },
1512 { "common", CL_COMMON },
1515 unsigned int * pflags;
1517 unsigned int lang_flag, specific_flag;
1524 pflags = & exclude_flags;
1527 pflags = & include_flags;
1529 comma = strchr (a, ',');
1540 /* Check to see if the string matches an option class name. */
1541 for (i = 0, specific_flag = 0; specifics[i].string != NULL; i++)
1542 if (strncasecmp (a, specifics[i].string, len) == 0)
1544 specific_flag = specifics[i].flag;
1548 /* Check to see if the string matches a language name.
1549 Note - we rely upon the alpha-sorted nature of the entries in
1550 the lang_names array, specifically that shorter names appear
1551 before their longer variants. (i.e. C before C++). That way
1552 when we are attempting to match --help=c for example we will
1553 match with C first and not C++. */
1554 for (i = 0, lang_flag = 0; i < cl_lang_count; i++)
1555 if (strncasecmp (a, lang_names[i], len) == 0)
1557 lang_flag = 1U << i;
1561 if (specific_flag != 0)
1564 * pflags |= specific_flag;
1567 /* The option's argument matches both the start of a
1568 language name and the start of an option class name.
1569 We have a special case for when the user has
1570 specified "--help=c", but otherwise we have to issue
1572 if (strncasecmp (a, "c", len) == 0)
1573 * pflags |= lang_flag;
1576 "warning: --help argument %.*s is ambiguous, please be more specific\n",
1580 else if (lang_flag != 0)
1581 * pflags |= lang_flag;
1584 "warning: unrecognized argument to --help= option: %.*s\n",
1593 print_specific_help (include_flags, exclude_flags, 0);
1594 exit_after_options = true;
1600 exit_after_options = true;
1604 g_switch_value = value;
1605 g_switch_set = true;
1611 /* Currently handled in a prescan. */
1615 enable_warning_as_error (arg, value, lang_mask);
1618 case OPT_Wlarger_than_:
1619 /* This form corresponds to -Wlarger-than-.
1620 Kept for backward compatibility.
1621 Don't use it as the first argument of warning(). */
1623 case OPT_Wlarger_than_eq:
1624 larger_than_size = value;
1625 warn_larger_than = value != -1;
1628 case OPT_Wfatal_errors:
1629 global_dc->fatal_errors = value;
1632 case OPT_Wframe_larger_than_:
1633 frame_larger_than_size = value;
1634 warn_frame_larger_than = value != -1;
1637 case OPT_Wstrict_aliasing:
1638 set_Wstrict_aliasing (value);
1641 case OPT_Wstrict_aliasing_:
1642 warn_strict_aliasing = value;
1645 case OPT_Wstrict_overflow:
1646 warn_strict_overflow = (value
1647 ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
1651 case OPT_Wstrict_overflow_:
1652 warn_strict_overflow = value;
1655 case OPT_Wsystem_headers:
1656 global_dc->warn_system_headers = value;
1660 warn_unused = value;
1665 aux_info_file_name = arg;
1666 flag_gen_aux_info = 1;
1670 aux_base_name = arg;
1673 case OPT_auxbase_strip:
1675 char *tmp = xstrdup (arg);
1676 strip_off_ending (tmp, strlen (tmp));
1678 aux_base_name = tmp;
1683 decode_d_option (arg);
1687 dump_base_name = arg;
1691 dump_dir_name = arg;
1694 case OPT_falign_functions_:
1695 align_functions = value;
1698 case OPT_falign_jumps_:
1699 align_jumps = value;
1702 case OPT_falign_labels_:
1703 align_labels = value;
1706 case OPT_falign_loops_:
1707 align_loops = value;
1710 case OPT_fbranch_probabilities:
1711 flag_branch_probabilities_set = true;
1714 case OPT_fcall_used_:
1715 fix_register (arg, 0, 1);
1718 case OPT_fcall_saved_:
1719 fix_register (arg, 0, 0);
1723 dbg_cnt_process_opt (arg);
1726 case OPT_fdbg_cnt_list:
1727 dbg_cnt_list_all_counters ();
1730 case OPT_fdebug_prefix_map_:
1731 add_debug_prefix_map (arg);
1734 case OPT_fdiagnostics_show_location_:
1735 if (!strcmp (arg, "once"))
1736 diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
1737 else if (!strcmp (arg, "every-line"))
1738 diagnostic_prefixing_rule (global_dc)
1739 = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE;
1744 case OPT_fdiagnostics_show_option:
1745 global_dc->show_option_requested = value;
1749 if (!dump_switch_p (arg))
1753 case OPT_fexcess_precision_:
1754 if (!strcmp (arg, "fast"))
1755 flag_excess_precision_cmdline = EXCESS_PRECISION_FAST;
1756 else if (!strcmp (arg, "standard"))
1757 flag_excess_precision_cmdline = EXCESS_PRECISION_STANDARD;
1759 error ("unknown excess precision style \"%s\"", arg);
1762 case OPT_ffast_math:
1763 set_fast_math_flags (value);
1766 case OPT_funsafe_math_optimizations:
1767 set_unsafe_math_optimizations_flags (value);
1771 fix_register (arg, 1, 1);
1774 case OPT_finline_limit_:
1775 case OPT_finline_limit_eq:
1776 set_param_value ("max-inline-insns-single", value / 2);
1777 set_param_value ("max-inline-insns-auto", value / 2);
1780 case OPT_finstrument_functions_exclude_function_list_:
1781 add_comma_separated_to_vector
1782 (&flag_instrument_functions_exclude_functions, arg);
1785 case OPT_finstrument_functions_exclude_file_list_:
1786 add_comma_separated_to_vector
1787 (&flag_instrument_functions_exclude_files, arg);
1790 case OPT_fmessage_length_:
1791 pp_set_line_maximum_length (global_dc->printer, value);
1794 case OPT_fpack_struct_:
1795 if (value <= 0 || (value & (value - 1)) || value > 16)
1796 error ("structure alignment must be a small power of two, not %d", value);
1799 initial_max_fld_align = value;
1800 maximum_field_alignment = value * BITS_PER_UNIT;
1804 case OPT_fpeel_loops:
1805 flag_peel_loops_set = true;
1809 #ifdef ENABLE_PLUGIN
1810 add_new_plugin (arg);
1812 error ("Plugin support is disabled. Configure with --enable-plugin.");
1816 case OPT_fplugin_arg_:
1817 #ifdef ENABLE_PLUGIN
1818 parse_plugin_arg_opt (arg);
1820 error ("Plugin support is disabled. Configure with --enable-plugin.");
1824 case OPT_fprofile_arcs:
1825 profile_arc_flag_set = true;
1828 case OPT_finline_functions:
1829 flag_inline_functions_set = true;
1832 case OPT_fprofile_dir_:
1833 profile_data_prefix = xstrdup (arg);
1836 case OPT_fprofile_use_:
1837 profile_data_prefix = xstrdup (arg);
1838 flag_profile_use = true;
1840 /* No break here - do -fprofile-use processing. */
1841 case OPT_fprofile_use:
1842 if (!flag_branch_probabilities_set)
1843 flag_branch_probabilities = value;
1844 if (!flag_profile_values_set)
1845 flag_profile_values = value;
1846 if (!flag_unroll_loops_set)
1847 flag_unroll_loops = value;
1848 if (!flag_peel_loops_set)
1849 flag_peel_loops = value;
1850 if (!flag_tracer_set)
1851 flag_tracer = value;
1852 if (!flag_value_profile_transformations_set)
1853 flag_value_profile_transformations = value;
1854 if (!flag_inline_functions_set)
1855 flag_inline_functions = value;
1856 if (!flag_ipa_cp_set)
1857 flag_ipa_cp = value;
1858 if (!flag_ipa_cp_clone_set
1859 && value && flag_ipa_cp)
1860 flag_ipa_cp_clone = value;
1861 if (!flag_predictive_commoning_set)
1862 flag_predictive_commoning = value;
1863 if (!flag_unswitch_loops_set)
1864 flag_unswitch_loops = value;
1865 if (!flag_gcse_after_reload_set)
1866 flag_gcse_after_reload = value;
1869 case OPT_fprofile_generate_:
1870 profile_data_prefix = xstrdup (arg);
1872 /* No break here - do -fprofile-generate processing. */
1873 case OPT_fprofile_generate:
1874 if (!profile_arc_flag_set)
1875 profile_arc_flag = value;
1876 if (!flag_profile_values_set)
1877 flag_profile_values = value;
1878 if (!flag_value_profile_transformations_set)
1879 flag_value_profile_transformations = value;
1880 if (!flag_inline_functions_set)
1881 flag_inline_functions = value;
1884 case OPT_fprofile_values:
1885 flag_profile_values_set = true;
1888 case OPT_fshow_column:
1889 global_dc->show_column = value;
1892 case OPT_fvisibility_:
1894 if (!strcmp(arg, "default"))
1895 default_visibility = VISIBILITY_DEFAULT;
1896 else if (!strcmp(arg, "internal"))
1897 default_visibility = VISIBILITY_INTERNAL;
1898 else if (!strcmp(arg, "hidden"))
1899 default_visibility = VISIBILITY_HIDDEN;
1900 else if (!strcmp(arg, "protected"))
1901 default_visibility = VISIBILITY_PROTECTED;
1903 error ("unrecognized visibility value \"%s\"", arg);
1908 flag_value_profile_transformations_set = true;
1911 case OPT_frandom_seed:
1912 /* The real switch is -fno-random-seed. */
1915 set_random_seed (NULL);
1918 case OPT_frandom_seed_:
1919 set_random_seed (arg);
1922 case OPT_fselective_scheduling:
1923 case OPT_fselective_scheduling2:
1924 sel_sched_switch_set = true;
1927 case OPT_fsched_verbose_:
1928 #ifdef INSN_SCHEDULING
1929 fix_sched_param ("verbose", arg);
1935 case OPT_fsched_stalled_insns_:
1936 flag_sched_stalled_insns = value;
1937 if (flag_sched_stalled_insns == 0)
1938 flag_sched_stalled_insns = -1;
1941 case OPT_fsched_stalled_insns_dep_:
1942 flag_sched_stalled_insns_dep = value;
1945 case OPT_fstack_check_:
1946 if (!strcmp (arg, "no"))
1947 flag_stack_check = NO_STACK_CHECK;
1948 else if (!strcmp (arg, "generic"))
1949 /* This is the old stack checking method. */
1950 flag_stack_check = STACK_CHECK_BUILTIN
1951 ? FULL_BUILTIN_STACK_CHECK
1952 : GENERIC_STACK_CHECK;
1953 else if (!strcmp (arg, "specific"))
1954 /* This is the new stack checking method. */
1955 flag_stack_check = STACK_CHECK_BUILTIN
1956 ? FULL_BUILTIN_STACK_CHECK
1957 : STACK_CHECK_STATIC_BUILTIN
1958 ? STATIC_BUILTIN_STACK_CHECK
1959 : GENERIC_STACK_CHECK;
1961 warning (0, "unknown stack check parameter \"%s\"", arg);
1964 case OPT_fstack_check:
1965 /* This is the same as the "specific" mode above. */
1967 flag_stack_check = STACK_CHECK_BUILTIN
1968 ? FULL_BUILTIN_STACK_CHECK
1969 : STACK_CHECK_STATIC_BUILTIN
1970 ? STATIC_BUILTIN_STACK_CHECK
1971 : GENERIC_STACK_CHECK;
1973 flag_stack_check = NO_STACK_CHECK;
1976 case OPT_fstack_limit:
1977 /* The real switch is -fno-stack-limit. */
1980 stack_limit_rtx = NULL_RTX;
1983 case OPT_fstack_limit_register_:
1985 int reg = decode_reg_name (arg);
1987 error ("unrecognized register name \"%s\"", arg);
1989 stack_limit_rtx = gen_rtx_REG (Pmode, reg);
1993 case OPT_fstack_limit_symbol_:
1994 stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (arg));
1997 case OPT_ftree_vectorizer_verbose_:
1998 vect_set_verbosity_level (arg);
2001 case OPT_ftls_model_:
2002 if (!strcmp (arg, "global-dynamic"))
2003 flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
2004 else if (!strcmp (arg, "local-dynamic"))
2005 flag_tls_default = TLS_MODEL_LOCAL_DYNAMIC;
2006 else if (!strcmp (arg, "initial-exec"))
2007 flag_tls_default = TLS_MODEL_INITIAL_EXEC;
2008 else if (!strcmp (arg, "local-exec"))
2009 flag_tls_default = TLS_MODEL_LOCAL_EXEC;
2011 warning (0, "unknown tls-model \"%s\"", arg);
2014 case OPT_fira_algorithm_:
2015 if (!strcmp (arg, "CB"))
2016 flag_ira_algorithm = IRA_ALGORITHM_CB;
2017 else if (!strcmp (arg, "priority"))
2018 flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
2020 warning (0, "unknown ira algorithm \"%s\"", arg);
2023 case OPT_fira_region_:
2024 if (!strcmp (arg, "one"))
2025 flag_ira_region = IRA_REGION_ONE;
2026 else if (!strcmp (arg, "all"))
2027 flag_ira_region = IRA_REGION_ALL;
2028 else if (!strcmp (arg, "mixed"))
2029 flag_ira_region = IRA_REGION_MIXED;
2031 warning (0, "unknown ira region \"%s\"", arg);
2034 case OPT_fira_verbose_:
2035 flag_ira_verbose = value;
2039 flag_tracer_set = true;
2043 flag_ipa_cp_set = true;
2046 case OPT_fipa_cp_clone:
2047 flag_ipa_cp_clone_set = true;
2050 case OPT_fpredictive_commoning:
2051 flag_predictive_commoning_set = true;
2054 case OPT_funswitch_loops:
2055 flag_unswitch_loops_set = true;
2058 case OPT_fgcse_after_reload:
2059 flag_gcse_after_reload_set = true;
2062 case OPT_funroll_loops:
2063 flag_unroll_loops_set = true;
2067 set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg);
2071 set_debug_level (SDB_DEBUG, false, arg);
2075 if (value < 2 || value > 4)
2076 error ("dwarf version %d is not supported", value);
2078 dwarf_version = value;
2079 set_debug_level (DWARF2_DEBUG, false, "");
2083 set_debug_level (NO_DEBUG, 2, arg);
2088 set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg);
2092 set_debug_level (VMS_DEBUG, false, arg);
2097 set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg);
2101 asm_file_name = arg;
2104 case OPT_pedantic_errors:
2105 flag_pedantic_errors = pedantic = 1;
2106 global_dc->pedantic_errors = 1;
2114 global_dc->inhibit_warnings = true;
2118 case OPT_fcse_skip_blocks:
2119 case OPT_floop_optimize:
2120 case OPT_frerun_loop_opt:
2121 case OPT_fsched2_use_traces:
2122 case OPT_fstrength_reduce:
2123 case OPT_ftree_store_copy_prop:
2124 case OPT_fforce_addr:
2125 case OPT_ftree_salias:
2126 case OPT_ftree_store_ccp:
2127 case OPT_Wunreachable_code:
2128 case OPT_fargument_alias:
2129 case OPT_fargument_noalias:
2130 case OPT_fargument_noalias_anything:
2131 case OPT_fargument_noalias_global:
2132 /* These are no-ops, preserved for backward compatibility. */
2135 case OPT_fuse_linker_plugin:
2136 /* No-op. Used by the driver and passed to us because it starts with f.*/
2140 /* If the flag was handled in a standard way, assume the lack of
2141 processing here is intentional. */
2142 gcc_assert (cl_options[scode].flag_var);
2149 /* Handle --param NAME=VALUE. */
2151 handle_param (const char *carg)
2156 arg = xstrdup (carg);
2157 equal = strchr (arg, '=');
2159 error ("%s: --param arguments should be of the form NAME=VALUE", arg);
2162 value = integral_argument (equal + 1);
2164 error ("invalid --param value %qs", equal + 1);
2168 set_param_value (arg, value);
2175 /* Used to set the level of strict aliasing warnings,
2176 when no level is specified (i.e., when -Wstrict-aliasing, and not
2177 -Wstrict-aliasing=level was given).
2178 ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
2179 and 0 otherwise. After calling this function, wstrict_aliasing will be
2180 set to the default value of -Wstrict_aliasing=level, currently 3. */
2182 set_Wstrict_aliasing (int onoff)
2184 gcc_assert (onoff == 0 || onoff == 1);
2186 warn_strict_aliasing = 3;
2188 warn_strict_aliasing = 0;
2191 /* The following routines are useful in setting all the flags that
2192 -ffast-math and -fno-fast-math imply. */
2194 set_fast_math_flags (int set)
2196 flag_unsafe_math_optimizations = set;
2197 set_unsafe_math_optimizations_flags (set);
2198 flag_finite_math_only = set;
2199 flag_errno_math = !set;
2202 flag_signaling_nans = 0;
2203 flag_rounding_math = 0;
2204 flag_cx_limited_range = 1;
2208 /* When -funsafe-math-optimizations is set the following
2209 flags are set as well. */
2211 set_unsafe_math_optimizations_flags (int set)
2213 flag_trapping_math = !set;
2214 flag_signed_zeros = !set;
2215 flag_associative_math = set;
2216 flag_reciprocal_math = set;
2219 /* Return true iff flags are set as if -ffast-math. */
2221 fast_math_flags_set_p (void)
2223 return (!flag_trapping_math
2224 && flag_unsafe_math_optimizations
2225 && flag_finite_math_only
2226 && !flag_signed_zeros
2227 && !flag_errno_math);
2230 /* Return true iff flags are set as if -ffast-math but using the flags stored
2231 in the struct cl_optimization structure. */
2233 fast_math_flags_struct_set_p (struct cl_optimization *opt)
2235 return (!opt->flag_trapping_math
2236 && opt->flag_unsafe_math_optimizations
2237 && opt->flag_finite_math_only
2238 && !opt->flag_signed_zeros
2239 && !opt->flag_errno_math);
2242 /* Handle a debug output -g switch. EXTENDED is true or false to support
2243 extended output (2 is special and means "-ggdb" was given). */
2245 set_debug_level (enum debug_info_type type, int extended, const char *arg)
2247 static bool type_explicit;
2249 use_gnu_debug_info_extensions = extended;
2251 if (type == NO_DEBUG)
2253 if (write_symbols == NO_DEBUG)
2255 write_symbols = PREFERRED_DEBUGGING_TYPE;
2259 #ifdef DWARF2_DEBUGGING_INFO
2260 write_symbols = DWARF2_DEBUG;
2261 #elif defined DBX_DEBUGGING_INFO
2262 write_symbols = DBX_DEBUG;
2266 if (write_symbols == NO_DEBUG)
2267 warning (0, "target system does not support debug output");
2272 /* Does it conflict with an already selected type? */
2273 if (type_explicit && write_symbols != NO_DEBUG && type != write_symbols)
2274 error ("debug format \"%s\" conflicts with prior selection",
2275 debug_type_names[type]);
2276 write_symbols = type;
2277 type_explicit = true;
2280 /* A debug flag without a level defaults to level 2. */
2283 if (!debug_info_level)
2284 debug_info_level = DINFO_LEVEL_NORMAL;
2288 int argval = integral_argument (arg);
2290 error ("unrecognised debug output level \"%s\"", arg);
2291 else if (argval > 3)
2292 error ("debug output level %s is too high", arg);
2294 debug_info_level = (enum debug_info_level) argval;
2298 /* Return 1 if OPTION is enabled, 0 if it is disabled, or -1 if it isn't
2299 a simple on-off switch. */
2302 option_enabled (int opt_idx)
2304 const struct cl_option *option = &(cl_options[opt_idx]);
2306 if (option->flag_var)
2307 switch (option->var_type)
2310 return *(int *) option->flag_var != 0;
2313 return *(int *) option->flag_var == option->var_value;
2315 case CLVC_BIT_CLEAR:
2316 return (*(int *) option->flag_var & option->var_value) == 0;
2319 return (*(int *) option->flag_var & option->var_value) != 0;
2327 /* Fill STATE with the current state of option OPTION. Return true if
2328 there is some state to store. */
2331 get_option_state (int option, struct cl_option_state *state)
2333 if (cl_options[option].flag_var == 0)
2336 switch (cl_options[option].var_type)
2340 state->data = cl_options[option].flag_var;
2341 state->size = sizeof (int);
2344 case CLVC_BIT_CLEAR:
2346 state->ch = option_enabled (option);
2347 state->data = &state->ch;
2352 state->data = *(const char **) cl_options[option].flag_var;
2353 if (state->data == 0)
2355 state->size = strlen ((const char *) state->data) + 1;
2361 /* Set *OPTION according to VALUE and ARG. */
2364 set_option (int opt_index, int value, const char *arg, int kind)
2366 const struct cl_option *option = &cl_options[opt_index];
2368 if (!option->flag_var)
2371 switch (option->var_type)
2374 *(int *) option->flag_var = value;
2378 *(int *) option->flag_var = (value
2380 : !option->var_value);
2383 case CLVC_BIT_CLEAR:
2385 if ((value != 0) == (option->var_type == CLVC_BIT_SET))
2386 *(int *) option->flag_var |= option->var_value;
2388 *(int *) option->flag_var &= ~option->var_value;
2389 if (option->flag_var == &target_flags)
2390 target_flags_explicit |= option->var_value;
2394 *(const char **) option->flag_var = arg;
2398 if ((diagnostic_t)kind != DK_UNSPECIFIED)
2399 diagnostic_classify_diagnostic (global_dc, opt_index, (diagnostic_t)kind);
2403 /* Callback function, called when -Werror= enables a warning. */
2405 static void (*warning_as_error_callback) (int) = NULL;
2407 /* Register a callback for enable_warning_as_error calls. */
2410 register_warning_as_error_callback (void (*callback) (int))
2412 gcc_assert (warning_as_error_callback == NULL || callback == NULL);
2413 warning_as_error_callback = callback;
2416 /* Enable a warning option as an error. This is used by -Werror= and
2417 also by legacy Werror-implicit-function-declaration. */
2420 enable_warning_as_error (const char *arg, int value, unsigned int lang_mask)
2425 new_option = XNEWVEC (char, strlen (arg) + 2);
2426 new_option[0] = 'W';
2427 strcpy (new_option + 1, arg);
2428 option_index = find_opt (new_option, lang_mask);
2429 if (option_index == OPT_SPECIAL_unknown)
2431 error ("-Werror=%s: No option -%s", arg, new_option);
2435 const diagnostic_t kind = value ? DK_ERROR : DK_WARNING;
2437 diagnostic_classify_diagnostic (global_dc, option_index, kind);
2438 if (kind == DK_ERROR)
2440 const struct cl_option * const option = cl_options + option_index;
2442 /* -Werror=foo implies -Wfoo. */
2443 if (option->var_type == CLVC_BOOLEAN)
2444 handle_option (option_index, value, arg, lang_mask, (int)kind);
2446 if (warning_as_error_callback)
2447 warning_as_error_callback (option_index);
2453 /* Return malloced memory for the name of the option OPTION_INDEX
2454 which enabled a diagnostic (context CONTEXT), originally of type
2455 ORIG_DIAG_KIND but possibly converted to DIAG_KIND by options such
2459 option_name (diagnostic_context *context, int option_index,
2460 diagnostic_t orig_diag_kind, diagnostic_t diag_kind)
2464 /* A warning classified as an error. */
2465 if ((orig_diag_kind == DK_WARNING || orig_diag_kind == DK_PEDWARN)
2466 && diag_kind == DK_ERROR)
2467 return concat (cl_options[OPT_Werror_].opt_text,
2468 /* Skip over "-W". */
2469 cl_options[option_index].opt_text + 2,
2471 /* A warning with option. */
2473 return xstrdup (cl_options[option_index].opt_text);
2475 /* A warning without option classified as an error. */
2476 else if (orig_diag_kind == DK_WARNING || orig_diag_kind == DK_PEDWARN
2477 || diag_kind == DK_WARNING)
2479 if (context->warning_as_error_requested)
2480 return xstrdup (cl_options[OPT_Werror].opt_text);
2482 return xstrdup (_("enabled by default"));