1 /* Command line option handling.
2 Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
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 "tm_p.h" /* For OPTIMIZATION_OPTIONS. */
40 #include "insn-attr.h" /* For INSN_SCHEDULING. */
42 #include "tree-pass.h"
46 /* Value of the -G xx switch, and whether it was passed or not. */
47 unsigned HOST_WIDE_INT g_switch_value;
50 /* Same for selective scheduling. */
51 bool sel_sched_switch_set;
53 /* True if we should exit after parsing options. */
54 bool exit_after_options;
56 /* Print various extra warnings. -W/-Wextra. */
59 /* True to warn about any objects definitions whose size is larger
60 than N bytes. Also want about function definitions whose returned
61 values are larger than N bytes, where N is `larger_than_size'. */
62 bool warn_larger_than;
63 HOST_WIDE_INT larger_than_size;
65 /* True to warn about any function whose frame size is larger
67 bool warn_frame_larger_than;
68 HOST_WIDE_INT frame_larger_than_size;
70 /* Type(s) of debugging information we are producing (if any). See
71 flags.h for the definitions of the different possible types of
72 debugging information. */
73 enum debug_info_type write_symbols = NO_DEBUG;
75 /* Level of debugging information we are producing. See flags.h for
76 the definitions of the different possible levels. */
77 enum debug_info_level debug_info_level = DINFO_LEVEL_NONE;
79 /* A major contribution to object and executable size is debug
80 information size. A major contribution to debug information size
81 is struct descriptions replicated in several object files. The
82 following flags attempt to reduce this information. The basic
83 idea is to not emit struct debugging information in the current
84 compilation unit when that information will be generated by
85 another compilation unit.
87 Debug information for a struct defined in the current source
88 file should be generated in the object file. Likewise the
89 debug information for a struct defined in a header should be
90 generated in the object file of the corresponding source file.
91 Both of these case are handled when the base name of the file of
92 the struct definition matches the base name of the source file
93 of the current compilation unit. This matching emits minimal
94 struct debugging information.
96 The base file name matching rule above will fail to emit debug
97 information for structs defined in system headers. So a second
98 category of files includes system headers in addition to files
101 The remaining types of files are library headers and application
102 headers. We cannot currently distinguish these two types. */
104 enum debug_struct_file
106 DINFO_STRUCT_FILE_NONE, /* Debug no structs. */
107 DINFO_STRUCT_FILE_BASE, /* Debug structs defined in files with the
108 same base name as the compilation unit. */
109 DINFO_STRUCT_FILE_SYS, /* Also debug structs defined in system
111 DINFO_STRUCT_FILE_ANY /* Debug structs defined in all files. */
114 /* Generic structs (e.g. templates not explicitly specialized)
115 may not have a compilation unit associated with them, and so
116 may need to be treated differently from ordinary structs.
118 Structs only handled by reference (indirectly), will also usually
119 not need as much debugging information. */
121 static enum debug_struct_file debug_struct_ordinary[DINFO_USAGE_NUM_ENUMS]
122 = { DINFO_STRUCT_FILE_ANY, DINFO_STRUCT_FILE_ANY, DINFO_STRUCT_FILE_ANY };
123 static enum debug_struct_file debug_struct_generic[DINFO_USAGE_NUM_ENUMS]
124 = { DINFO_STRUCT_FILE_ANY, DINFO_STRUCT_FILE_ANY, DINFO_STRUCT_FILE_ANY };
126 /* Parse the -femit-struct-debug-detailed option value
127 and set the flag variables. */
129 #define MATCH( prefix, string ) \
130 ((strncmp (prefix, string, sizeof prefix - 1) == 0) \
131 ? ((string += sizeof prefix - 1), 1) : 0)
134 set_struct_debug_option (const char *spec)
136 /* various labels for comparison */
137 static char dfn_lbl[] = "dfn:", dir_lbl[] = "dir:", ind_lbl[] = "ind:";
138 static char ord_lbl[] = "ord:", gen_lbl[] = "gen:";
139 static char none_lbl[] = "none", any_lbl[] = "any";
140 static char base_lbl[] = "base", sys_lbl[] = "sys";
142 enum debug_struct_file files = DINFO_STRUCT_FILE_ANY;
143 /* Default is to apply to as much as possible. */
144 enum debug_info_usage usage = DINFO_USAGE_NUM_ENUMS;
145 int ord = 1, gen = 1;
148 if (MATCH (dfn_lbl, spec))
149 usage = DINFO_USAGE_DFN;
150 else if (MATCH (dir_lbl, spec))
151 usage = DINFO_USAGE_DIR_USE;
152 else if (MATCH (ind_lbl, spec))
153 usage = DINFO_USAGE_IND_USE;
155 /* Generics or not? */
156 if (MATCH (ord_lbl, spec))
158 else if (MATCH (gen_lbl, spec))
161 /* What allowable environment? */
162 if (MATCH (none_lbl, spec))
163 files = DINFO_STRUCT_FILE_NONE;
164 else if (MATCH (any_lbl, spec))
165 files = DINFO_STRUCT_FILE_ANY;
166 else if (MATCH (sys_lbl, spec))
167 files = DINFO_STRUCT_FILE_SYS;
168 else if (MATCH (base_lbl, spec))
169 files = DINFO_STRUCT_FILE_BASE;
171 error ("argument %qs to %<-femit-struct-debug-detailed%> not recognized",
174 /* Effect the specification. */
175 if (usage == DINFO_USAGE_NUM_ENUMS)
179 debug_struct_ordinary[DINFO_USAGE_DFN] = files;
180 debug_struct_ordinary[DINFO_USAGE_DIR_USE] = files;
181 debug_struct_ordinary[DINFO_USAGE_IND_USE] = files;
185 debug_struct_generic[DINFO_USAGE_DFN] = files;
186 debug_struct_generic[DINFO_USAGE_DIR_USE] = files;
187 debug_struct_generic[DINFO_USAGE_IND_USE] = files;
193 debug_struct_ordinary[usage] = files;
195 debug_struct_generic[usage] = files;
199 set_struct_debug_option (spec+1);
202 /* No more -femit-struct-debug-detailed specifications.
205 error ("argument %qs to %<-femit-struct-debug-detailed%> unknown",
207 if (debug_struct_ordinary[DINFO_USAGE_DIR_USE]
208 < debug_struct_ordinary[DINFO_USAGE_IND_USE]
209 || debug_struct_generic[DINFO_USAGE_DIR_USE]
210 < debug_struct_generic[DINFO_USAGE_IND_USE])
211 error ("%<-femit-struct-debug-detailed=dir:...%> must allow at least"
212 " as much as %<-femit-struct-debug-detailed=ind:...%>");
216 /* Find the base name of a path, stripping off both directories and
217 a single final extension. */
219 base_of_path (const char *path, const char **base_out)
221 const char *base = path;
223 const char *p = path;
227 if (IS_DIR_SEPARATOR(c))
242 /* Match the base name of a file to the base name of a compilation unit. */
244 static const char *main_input_basename;
245 static int main_input_baselength;
248 matches_main_base (const char *path)
250 /* Cache the last query. */
251 static const char *last_path = NULL;
252 static int last_match = 0;
253 if (path != last_path)
256 int length = base_of_path (path, &base);
258 last_match = (length == main_input_baselength
259 && memcmp (base, main_input_basename, length) == 0);
264 #ifdef DEBUG_DEBUG_STRUCT
267 dump_struct_debug (tree type, enum debug_info_usage usage,
268 enum debug_struct_file criterion, int generic,
269 int matches, int result)
271 /* Find the type name. */
272 tree type_decl = TYPE_STUB_DECL (type);
274 const char *name = 0;
275 if (TREE_CODE (t) == TYPE_DECL)
278 name = IDENTIFIER_POINTER (t);
280 fprintf (stderr, " struct %d %s %s %s %s %d %p %s\n",
282 DECL_IN_SYSTEM_HEADER (type_decl) ? "sys" : "usr",
283 matches ? "bas" : "hdr",
284 generic ? "gen" : "ord",
285 usage == DINFO_USAGE_DFN ? ";" :
286 usage == DINFO_USAGE_DIR_USE ? "." : "*",
288 (void*) type_decl, name);
291 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
292 dump_struct_debug (type, usage, criterion, generic, matches, result)
296 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
303 should_emit_struct_debug (tree type, enum debug_info_usage usage)
305 enum debug_struct_file criterion;
307 bool generic = lang_hooks.types.generic_p (type);
310 criterion = debug_struct_generic[usage];
312 criterion = debug_struct_ordinary[usage];
314 if (criterion == DINFO_STRUCT_FILE_NONE)
315 return DUMP_GSTRUCT (type, usage, criterion, generic, false, false);
316 if (criterion == DINFO_STRUCT_FILE_ANY)
317 return DUMP_GSTRUCT (type, usage, criterion, generic, false, true);
319 type_decl = TYPE_STUB_DECL (type);
321 if (criterion == DINFO_STRUCT_FILE_SYS && DECL_IN_SYSTEM_HEADER (type_decl))
322 return DUMP_GSTRUCT (type, usage, criterion, generic, false, true);
324 if (matches_main_base (DECL_SOURCE_FILE (type_decl)))
325 return DUMP_GSTRUCT (type, usage, criterion, generic, true, true);
326 return DUMP_GSTRUCT (type, usage, criterion, generic, false, false);
329 /* Nonzero means use GNU-only extensions in the generated symbolic
330 debugging information. Currently, this only has an effect when
331 write_symbols is set to DBX_DEBUG, XCOFF_DEBUG, or DWARF_DEBUG. */
332 bool use_gnu_debug_info_extensions;
334 /* The default visibility for all symbols (unless overridden) */
335 enum symbol_visibility default_visibility = VISIBILITY_DEFAULT;
337 /* Global visibility options. */
338 struct visibility_flags visibility_options;
340 /* What to print when a switch has no documentation. */
341 #ifdef ENABLE_CHECKING
342 static const char undocumented_msg[] = N_("This switch lacks documentation");
344 static const char undocumented_msg[] = "";
347 /* Used for bookkeeping on whether user set these flags so
348 -fprofile-use/-fprofile-generate does not use them. */
349 static bool profile_arc_flag_set, flag_profile_values_set;
350 static bool flag_unroll_loops_set, flag_tracer_set;
351 static bool flag_value_profile_transformations_set;
352 static bool flag_peel_loops_set, flag_branch_probabilities_set;
353 static bool flag_inline_functions_set, flag_ipa_cp_set, flag_ipa_cp_clone_set;
354 static bool flag_predictive_commoning_set, flag_unswitch_loops_set, flag_gcse_after_reload_set;
356 /* Functions excluded from profiling. */
358 typedef char *char_p; /* For DEF_VEC_P. */
360 DEF_VEC_ALLOC_P(char_p,heap);
362 static VEC(char_p,heap) *flag_instrument_functions_exclude_functions;
363 static VEC(char_p,heap) *flag_instrument_functions_exclude_files;
365 typedef const char *const_char_p; /* For DEF_VEC_P. */
366 DEF_VEC_P(const_char_p);
367 DEF_VEC_ALLOC_P(const_char_p,heap);
369 static VEC(const_char_p,heap) *ignored_options;
371 /* Function calls disallowed under -Wdisallowed-function-list=... */
372 static VEC(char_p,heap) *warning_disallowed_functions;
374 /* If -Wdisallowed-function-list=... */
375 bool warn_disallowed_functions = false;
377 /* Input file names. */
378 const char **in_fnames;
379 unsigned num_in_fnames;
381 static int common_handle_option (size_t scode, const char *arg, int value,
382 unsigned int lang_mask);
383 static void handle_param (const char *);
384 static void set_Wextra (int);
385 static unsigned int handle_option (const char **argv, unsigned int lang_mask);
386 static char *write_langs (unsigned int lang_mask);
387 static void complain_wrong_lang (const char *, const struct cl_option *,
388 unsigned int lang_mask);
389 static void handle_options (unsigned int, const char **, unsigned int);
390 static void set_debug_level (enum debug_info_type type, int extended,
393 /* If ARG is a non-negative integer made up solely of digits, return its
394 value, otherwise return -1. */
396 integral_argument (const char *arg)
400 while (*p && ISDIGIT (*p))
409 /* Return a malloced slash-separated list of languages in MASK. */
411 write_langs (unsigned int mask)
413 unsigned int n = 0, len = 0;
414 const char *lang_name;
417 for (n = 0; (lang_name = lang_names[n]) != 0; n++)
418 if (mask & (1U << n))
419 len += strlen (lang_name) + 1;
421 result = XNEWVEC (char, len);
423 for (n = 0; (lang_name = lang_names[n]) != 0; n++)
424 if (mask & (1U << n))
428 strcpy (result + len, lang_name);
429 len += strlen (lang_name);
437 /* Complain that switch OPT_INDEX does not apply to this front end. */
439 complain_wrong_lang (const char *text, const struct cl_option *option,
440 unsigned int lang_mask)
442 char *ok_langs, *bad_lang;
444 ok_langs = write_langs (option->flags);
445 bad_lang = write_langs (lang_mask);
447 /* Eventually this should become a hard error IMO. */
448 warning (0, "command line option \"%s\" is valid for %s but not for %s",
449 text, ok_langs, bad_lang);
455 /* Buffer the unknown option described by the string OPT. Currently,
456 we only complain about unknown -Wno-* options if they may have
457 prevented a diagnostic. Otherwise, we just ignore them.
458 Note that if we do complain, it is only as a warning, not an error;
459 passing the compiler an unrecognised -Wno-* option should never
460 change whether the compilation succeeds or fails. */
462 static void postpone_unknown_option_warning(const char *opt)
464 VEC_safe_push (const_char_p, heap, ignored_options, opt);
467 /* Produce a warning for each option previously buffered. */
469 void print_ignored_options (void)
471 location_t saved_loc = input_location;
475 while (!VEC_empty (const_char_p, ignored_options))
478 opt = VEC_pop (const_char_p, ignored_options);
479 warning (0, "unrecognized command line option \"%s\"", opt);
482 input_location = saved_loc;
485 /* Handle the switch beginning at ARGV for the language indicated by
486 LANG_MASK. Returns the number of switches consumed. */
488 handle_option (const char **argv, unsigned int lang_mask)
491 const char *opt, *arg = 0;
494 unsigned int result = 0;
495 const struct cl_option *option;
499 opt_index = find_opt (opt + 1, lang_mask | CL_COMMON | CL_TARGET);
500 if (opt_index == cl_options_count
501 && (opt[1] == 'W' || opt[1] == 'f' || opt[1] == 'm')
502 && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-')
504 /* Drop the "no-" from negative switches. */
505 size_t len = strlen (opt) - 3;
507 dup = XNEWVEC (char, len + 1);
510 memcpy (dup + 2, opt + 5, len - 2 + 1);
513 opt_index = find_opt (opt + 1, lang_mask | CL_COMMON | CL_TARGET);
514 if (opt_index == cl_options_count && opt[1] == 'W')
516 /* We don't generate warnings for unknown -Wno-* options
517 unless we issue diagnostics. */
518 postpone_unknown_option_warning (argv[0]);
524 if (opt_index == cl_options_count)
527 option = &cl_options[opt_index];
529 /* Reject negative form of switches that don't take negatives as
531 if (!value && (option->flags & CL_REJECT_NEGATIVE))
534 /* We've recognized this switch. */
537 /* Check to see if the option is disabled for this configuration. */
538 if (option->flags & CL_DISABLED)
540 error ("command line option %qs"
541 " is not supported by this configuration", opt);
545 /* Sort out any argument the switch takes. */
546 if (option->flags & CL_JOINED)
548 /* Have arg point to the original switch. This is because
549 some code, such as disable_builtin_function, expects its
550 argument to be persistent until the program exits. */
551 arg = argv[0] + cl_options[opt_index].opt_len + 1;
553 arg += strlen ("no-");
555 if (*arg == '\0' && !(option->flags & CL_MISSING_OK))
557 if (option->flags & CL_SEPARATE)
563 /* Missing argument. */
567 else if (option->flags & CL_SEPARATE)
573 /* Now we've swallowed any potential argument, complain if this
574 is a switch for a different front end. */
575 if (!(option->flags & (lang_mask | CL_COMMON | CL_TARGET)))
577 complain_wrong_lang (argv[0], option, lang_mask);
580 else if ((option->flags & CL_TARGET)
581 && (option->flags & CL_LANG_ALL)
582 && !(option->flags & lang_mask))
584 /* Complain for target flag language mismatches if any languages
586 complain_wrong_lang (argv[0], option, lang_mask);
590 if (arg == NULL && (option->flags & (CL_JOINED | CL_SEPARATE)))
592 if (!lang_hooks.missing_argument (opt, opt_index))
593 error ("missing argument to \"%s\"", opt);
597 /* If the switch takes an integer, convert it. */
598 if (arg && (option->flags & CL_UINTEGER))
600 value = integral_argument (arg);
603 error ("argument to \"%s\" should be a non-negative integer",
609 if (option->flag_var)
610 switch (option->var_type)
613 *(int *) option->flag_var = value;
617 *(int *) option->flag_var = (value
619 : !option->var_value);
624 if ((value != 0) == (option->var_type == CLVC_BIT_SET))
625 *(int *) option->flag_var |= option->var_value;
627 *(int *) option->flag_var &= ~option->var_value;
628 if (option->flag_var == &target_flags)
629 target_flags_explicit |= option->var_value;
633 *(const char **) option->flag_var = arg;
637 if (option->flags & lang_mask)
638 if (lang_hooks.handle_option (opt_index, arg, value) == 0)
641 if (result && (option->flags & CL_COMMON))
642 if (common_handle_option (opt_index, arg, value, lang_mask) == 0)
645 if (result && (option->flags & CL_TARGET))
646 if (!targetm.handle_option (opt_index, arg, value))
655 /* Handle FILENAME from the command line. */
657 add_input_filename (const char *filename)
660 in_fnames = XRESIZEVEC (const char *, in_fnames, num_in_fnames);
661 in_fnames[num_in_fnames - 1] = filename;
664 /* Add comma-separated strings to a char_p vector. */
667 add_comma_separated_to_vector (VEC(char_p,heap) **pvec, const char* arg)
674 /* We never free this string. */
687 VEC_safe_push (char_p, heap, *pvec, token_start);
690 if (*r == '\\' && r[1] == ',')
698 if (*token_start != '\0')
699 VEC_safe_push (char_p, heap, *pvec, token_start);
702 /* Return whether we should exclude FNDECL from instrumentation. */
705 flag_instrument_functions_exclude_p (tree fndecl)
707 if (VEC_length (char_p, flag_instrument_functions_exclude_functions) > 0)
713 name = lang_hooks.decl_printable_name (fndecl, 0);
715 VEC_iterate (char_p, flag_instrument_functions_exclude_functions,
719 if (strstr (name, s) != NULL)
724 if (VEC_length (char_p, flag_instrument_functions_exclude_files) > 0)
730 name = DECL_SOURCE_FILE (fndecl);
732 VEC_iterate (char_p, flag_instrument_functions_exclude_files, i, s);
735 if (strstr (name, s) != NULL)
744 /* Return whether this function call is disallowed. */
746 warn_if_disallowed_function_p (const_tree exp)
748 if (TREE_CODE(exp) == CALL_EXPR
749 && VEC_length (char_p, warning_disallowed_functions) > 0)
754 IDENTIFIER_POINTER (DECL_NAME (get_callee_fndecl (exp)));
755 for (i = 0; VEC_iterate (char_p, warning_disallowed_functions, i, s);
758 if (strcmp (fnname, s) == 0)
760 warning (OPT_Wdisallowed_function_list_,
761 "disallowed call to %qs", fnname);
768 /* Decode and handle the vector of command line options. LANG_MASK
769 contains has a single bit set representing the current
772 handle_options (unsigned int argc, const char **argv, unsigned int lang_mask)
776 for (i = 1; i < argc; i += n)
778 const char *opt = argv[i];
780 /* Interpret "-" or a non-switch as a file name. */
781 if (opt[0] != '-' || opt[1] == '\0')
783 if (main_input_filename == NULL)
785 main_input_filename = opt;
786 main_input_baselength
787 = base_of_path (main_input_filename, &main_input_basename);
789 add_input_filename (opt);
794 n = handle_option (argv + i, lang_mask);
799 error ("unrecognized command line option \"%s\"", opt);
804 /* Parse command line options and set default flag values. Do minimal
805 options processing. */
807 decode_options (unsigned int argc, const char **argv)
809 static bool first_time_p = true;
810 static int initial_max_aliased_vops;
811 static int initial_avg_aliased_vops;
812 static int initial_min_crossjump_insns;
813 static int initial_max_fields_for_field_sensitive;
814 static int initial_loop_invariant_max_bbs_in_loop;
815 static unsigned int initial_lang_mask;
817 unsigned int i, lang_mask;
825 /* Perform language-specific options initialization. */
826 initial_lang_mask = lang_mask = lang_hooks.init_options (argc, argv);
828 lang_hooks.initialize_diagnostics (global_dc);
830 /* Save initial values of parameters we reset. */
831 initial_max_aliased_vops = MAX_ALIASED_VOPS;
832 initial_avg_aliased_vops = AVG_ALIASED_VOPS;
833 initial_min_crossjump_insns
834 = compiler_params[PARAM_MIN_CROSSJUMP_INSNS].value;
835 initial_max_fields_for_field_sensitive
836 = compiler_params[PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE].value;
837 initial_loop_invariant_max_bbs_in_loop
838 = compiler_params[PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP].value;
841 lang_mask = initial_lang_mask;
843 /* Scan to see what optimization level has been specified. That will
844 determine the default value of many flags. */
845 for (i = 1; i < argc; i++)
847 if (!strcmp (argv[i], "-O"))
852 else if (argv[i][0] == '-' && argv[i][1] == 'O')
854 /* Handle -Os, -O2, -O3, -O69, ... */
855 const char *p = &argv[i][2];
857 if ((p[0] == 's') && (p[1] == 0))
861 /* Optimizing for size forces optimize to be 2. */
866 const int optimize_val = read_integral_parameter (p, p - 2, -1);
867 if (optimize_val != -1)
869 optimize = optimize_val;
876 /* Use priority coloring if cover classes is not defined for the
878 if (targetm.ira_cover_classes == NULL)
879 flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
881 /* -O1 optimizations. */
882 opt1 = (optimize >= 1);
883 flag_defer_pop = opt1;
885 flag_delayed_branch = opt1;
887 #ifdef CAN_DEBUG_WITHOUT_FP
888 flag_omit_frame_pointer = opt1;
890 flag_guess_branch_prob = opt1;
891 flag_cprop_registers = opt1;
892 flag_if_conversion = opt1;
893 flag_if_conversion2 = opt1;
894 flag_ipa_pure_const = opt1;
895 flag_ipa_reference = opt1;
896 flag_merge_constants = opt1;
897 flag_split_wide_types = opt1;
898 flag_tree_ccp = opt1;
899 flag_tree_dce = opt1;
900 flag_tree_dom = opt1;
901 flag_tree_dse = opt1;
902 flag_tree_ter = opt1;
903 flag_tree_sra = opt1;
904 flag_tree_copyrename = opt1;
905 flag_tree_fre = opt1;
906 flag_tree_copy_prop = opt1;
907 flag_tree_sink = opt1;
910 /* -O2 optimizations. */
911 opt2 = (optimize >= 2);
912 flag_inline_small_functions = opt2;
913 flag_indirect_inlining = opt2;
914 flag_thread_jumps = opt2;
915 flag_crossjumping = opt2;
916 flag_optimize_sibling_calls = opt2;
917 flag_forward_propagate = opt2;
918 flag_cse_follow_jumps = opt2;
920 flag_expensive_optimizations = opt2;
921 flag_rerun_cse_after_loop = opt2;
922 flag_caller_saves = opt2;
923 flag_peephole2 = opt2;
924 #ifdef INSN_SCHEDULING
925 flag_schedule_insns = opt2;
926 flag_schedule_insns_after_reload = opt2;
929 flag_strict_aliasing = opt2;
930 flag_strict_overflow = opt2;
931 flag_delete_null_pointer_checks = opt2;
932 flag_reorder_blocks = opt2;
933 flag_reorder_functions = opt2;
934 flag_tree_vrp = opt2;
935 flag_tree_builtin_call_dce = opt2;
936 flag_tree_pre = opt2;
937 flag_tree_switch_conversion = 1;
940 /* Allow more virtual operators to increase alias precision. */
942 set_param_value ("max-aliased-vops",
943 (opt2) ? 500 : initial_max_aliased_vops);
945 /* Track fields in field-sensitive alias analysis. */
946 set_param_value ("max-fields-for-field-sensitive",
947 (opt2) ? 100 : initial_max_fields_for_field_sensitive);
949 /* For -O1 only do loop invariant motion for very small loops. */
950 set_param_value ("loop-invariant-max-bbs-in-loop",
951 (opt2) ? initial_loop_invariant_max_bbs_in_loop : 1000);
953 /* -O3 optimizations. */
954 opt3 = (optimize >= 3);
955 flag_predictive_commoning = opt3;
956 flag_inline_functions = opt3;
957 flag_unswitch_loops = opt3;
958 flag_gcse_after_reload = opt3;
959 flag_tree_vectorize = opt3;
960 flag_ipa_cp_clone = opt3;
961 if (flag_ipa_cp_clone)
964 /* Allow even more virtual operators. Max-aliased-vops was set above for
965 -O2, so don't reset it unless we are at -O3. */
967 set_param_value ("max-aliased-vops", 1000);
969 set_param_value ("avg-aliased-vops", (opt3) ? 3 : initial_avg_aliased_vops);
971 /* Just -O1/-O0 optimizations. */
972 opt1_max = (optimize <= 1);
973 align_loops = opt1_max;
974 align_jumps = opt1_max;
975 align_labels = opt1_max;
976 align_functions = opt1_max;
980 /* Inlining of functions reducing size is a good idea regardless of them
981 being declared inline. */
982 flag_inline_functions = 1;
984 /* Basic optimization options. */
989 /* We want to crossjump as much as possible. */
990 set_param_value ("min-crossjump-insns", 1);
993 set_param_value ("min-crossjump-insns", initial_min_crossjump_insns);
997 /* Initialize whether `char' is signed. */
998 flag_signed_char = DEFAULT_SIGNED_CHAR;
999 /* Set this to a special "uninitialized" value. The actual default is
1000 set after target options have been processed. */
1001 flag_short_enums = 2;
1003 /* Initialize target_flags before OPTIMIZATION_OPTIONS so the latter can
1005 target_flags = targetm.default_target_flags;
1007 /* Some targets have ABI-specified unwind tables. */
1008 flag_unwind_tables = targetm.unwind_tables_default;
1011 #ifdef OPTIMIZATION_OPTIONS
1012 /* Allow default optimizations to be specified on a per-machine basis. */
1013 OPTIMIZATION_OPTIONS (optimize, optimize_size);
1016 handle_options (argc, argv, lang_mask);
1018 /* Handle related options for unit-at-a-time, toplevel-reorder, and
1020 if (!flag_unit_at_a_time)
1022 if (flag_section_anchors == 1)
1023 error ("Section anchors must be disabled when unit-at-a-time "
1025 flag_section_anchors = 0;
1026 if (flag_toplevel_reorder == 1)
1027 error ("Toplevel reorder must be disabled when unit-at-a-time "
1029 flag_toplevel_reorder = 0;
1031 /* Unless the user has asked for section anchors, we disable toplevel
1032 reordering at -O0 to disable transformations that might be surprising
1033 to end users and to get -fno-toplevel-reorder tested. */
1034 if (!optimize && flag_toplevel_reorder == 2 && flag_section_anchors != 1)
1036 flag_toplevel_reorder = 0;
1037 flag_section_anchors = 0;
1039 if (!flag_toplevel_reorder)
1041 if (flag_section_anchors == 1)
1042 error ("section anchors must be disabled when toplevel reorder"
1044 flag_section_anchors = 0;
1050 flag_pic = flag_pie;
1051 if (flag_pic && !flag_pie)
1057 /* Inlining does not work if not optimizing,
1058 so force it not to be done. */
1063 /* The optimization to partition hot and cold basic blocks into separate
1064 sections of the .o and executable files does not work (currently)
1065 with exception handling. This is because there is no support for
1066 generating unwind info. If flag_exceptions is turned on we need to
1067 turn off the partitioning optimization. */
1069 if (flag_exceptions && flag_reorder_blocks_and_partition)
1071 inform (input_location,
1072 "-freorder-blocks-and-partition does not work with exceptions");
1073 flag_reorder_blocks_and_partition = 0;
1074 flag_reorder_blocks = 1;
1077 /* If user requested unwind info, then turn off the partitioning
1080 if (flag_unwind_tables && ! targetm.unwind_tables_default
1081 && flag_reorder_blocks_and_partition)
1083 inform (input_location, "-freorder-blocks-and-partition does not support unwind info");
1084 flag_reorder_blocks_and_partition = 0;
1085 flag_reorder_blocks = 1;
1088 /* If the target requested unwind info, then turn off the partitioning
1089 optimization with a different message. Likewise, if the target does not
1090 support named sections. */
1092 if (flag_reorder_blocks_and_partition
1093 && (!targetm.have_named_sections
1094 || (flag_unwind_tables && targetm.unwind_tables_default)))
1096 inform (input_location,
1097 "-freorder-blocks-and-partition does not work on this architecture");
1098 flag_reorder_blocks_and_partition = 0;
1099 flag_reorder_blocks = 1;
1102 /* Pipelining of outer loops is only possible when general pipelining
1103 capabilities are requested. */
1104 if (!flag_sel_sched_pipelining)
1105 flag_sel_sched_pipelining_outer_loops = 0;
1107 if (!targetm.ira_cover_classes
1108 && flag_ira_algorithm == IRA_ALGORITHM_CB)
1110 inform (input_location,
1111 "-fira-algorithm=CB does not work on this architecture");
1112 flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
1115 /* Save the current optimization options if this is the first call. */
1118 optimization_default_node = build_optimization_node ();
1119 optimization_current_node = optimization_default_node;
1120 first_time_p = false;
1122 if (flag_conserve_stack)
1124 if (!PARAM_SET_P (PARAM_LARGE_STACK_FRAME))
1125 PARAM_VALUE (PARAM_LARGE_STACK_FRAME) = 100;
1126 if (!PARAM_SET_P (PARAM_STACK_FRAME_GROWTH))
1127 PARAM_VALUE (PARAM_STACK_FRAME_GROWTH) = 40;
1132 #define LEFT_COLUMN 27
1134 /* Output ITEM, of length ITEM_WIDTH, in the left column,
1135 followed by word-wrapped HELP in a second column. */
1137 wrap_help (const char *help,
1139 unsigned int item_width,
1140 unsigned int columns)
1142 unsigned int col_width = LEFT_COLUMN;
1143 unsigned int remaining, room, len;
1145 remaining = strlen (help);
1149 room = columns - 3 - MAX (col_width, item_width);
1158 for (i = 0; help[i]; i++)
1160 if (i >= room && len != remaining)
1164 else if ((help[i] == '-' || help[i] == '/')
1165 && help[i + 1] != ' '
1166 && i > 0 && ISALPHA (help[i - 1]))
1171 printf( " %-*.*s %.*s\n", col_width, item_width, item, len, help);
1173 while (help[len] == ' ')
1181 /* Print help for a specific front-end, etc. */
1183 print_filtered_help (unsigned int include_flags,
1184 unsigned int exclude_flags,
1185 unsigned int any_flags,
1186 unsigned int columns)
1190 static char *printed = NULL;
1192 bool displayed = false;
1194 if (include_flags == CL_PARAMS)
1196 for (i = 0; i < LAST_PARAM; i++)
1198 const char *param = compiler_params[i].option;
1200 help = compiler_params[i].help;
1201 if (help == NULL || *help == '\0')
1203 if (exclude_flags & CL_UNDOCUMENTED)
1205 help = undocumented_msg;
1208 /* Get the translation. */
1211 wrap_help (help, param, strlen (param), columns);
1218 printed = XCNEWVAR (char, cl_options_count);
1220 for (i = 0; i < cl_options_count; i++)
1222 static char new_help[128];
1223 const struct cl_option *option = cl_options + i;
1228 if (include_flags == 0
1229 || ((option->flags & include_flags) != include_flags))
1231 if ((option->flags & any_flags) == 0)
1235 /* Skip unwanted switches. */
1236 if ((option->flags & exclude_flags) != 0)
1240 /* Skip switches that have already been printed. */
1246 help = option->help;
1249 if (exclude_flags & CL_UNDOCUMENTED)
1251 help = undocumented_msg;
1254 /* Get the translation. */
1257 /* Find the gap between the name of the
1258 option and its descriptive text. */
1259 tab = strchr (help, '\t');
1268 opt = option->opt_text;
1272 /* With the -Q option enabled we change the descriptive text associated
1273 with an option to be an indication of its current setting. */
1276 if (len < (LEFT_COLUMN + 2))
1277 strcpy (new_help, "\t\t");
1279 strcpy (new_help, "\t");
1281 if (option->flag_var != NULL)
1283 if (option->flags & CL_JOINED)
1285 if (option->var_type == CLVC_STRING)
1287 if (* (const char **) option->flag_var != NULL)
1288 snprintf (new_help + strlen (new_help),
1289 sizeof (new_help) - strlen (new_help),
1290 * (const char **) option->flag_var);
1293 sprintf (new_help + strlen (new_help),
1294 "%#x", * (int *) option->flag_var);
1297 strcat (new_help, option_enabled (i)
1298 ? _("[enabled]") : _("[disabled]"));
1304 wrap_help (help, opt, len, columns);
1310 unsigned int langs = include_flags & CL_LANG_ALL;
1313 printf (_(" No options with the desired characteristics were found\n"));
1318 /* PR 31349: Tell the user how to see all of the
1319 options supported by a specific front end. */
1320 for (i = 0; (1U << i) < CL_LANG_ALL; i ++)
1321 if ((1U << i) & langs)
1322 printf (_(" None found. Use --help=%s to show *all* the options supported by the %s front-end\n"),
1323 lang_names[i], lang_names[i]);
1327 else if (! displayed)
1328 printf (_(" All options with the desired characteristics have already been displayed\n"));
1333 /* Display help for a specified type of option.
1334 The options must have ALL of the INCLUDE_FLAGS set
1335 ANY of the flags in the ANY_FLAGS set
1336 and NONE of the EXCLUDE_FLAGS set. */
1338 print_specific_help (unsigned int include_flags,
1339 unsigned int exclude_flags,
1340 unsigned int any_flags)
1342 unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
1343 const char * description = NULL;
1344 const char * descrip_extra = "";
1347 static unsigned int columns = 0;
1349 /* Sanity check: Make sure that we do not have more
1350 languages than we have bits available to enumerate them. */
1351 gcc_assert ((1U << cl_lang_count) < CL_MIN_OPTION_CLASS);
1353 /* If we have not done so already, obtain
1354 the desired maximum width of the output. */
1359 GET_ENVIRONMENT (p, "COLUMNS");
1362 int value = atoi (p);
1369 /* Use a reasonable default. */
1373 /* Decide upon the title for the options that we are going to display. */
1374 for (i = 0, flag = 1; flag <= CL_MAX_OPTION_CLASS; flag <<= 1, i ++)
1376 switch (flag & include_flags)
1382 description = _("The following options are target specific");
1385 description = _("The following options control compiler warning messages");
1387 case CL_OPTIMIZATION:
1388 description = _("The following options control optimizations");
1391 description = _("The following options are language-independent");
1394 description = _("The --param option recognizes the following as parameters");
1397 if (i >= cl_lang_count)
1399 if ((exclude_flags & ((1U << cl_lang_count) - 1)) != 0)
1400 description = _("The following options are specific to just the language ");
1402 description = _("The following options are supported by the language ");
1403 descrip_extra = lang_names [i];
1408 if (description == NULL)
1412 if (include_flags == CL_UNDOCUMENTED)
1413 description = _("The following options are not documented");
1416 internal_error ("unrecognized include_flags 0x%x passed to print_specific_help",
1423 if (any_flags & all_langs_mask)
1424 description = _("The following options are language-related");
1426 description = _("The following options are language-independent");
1430 printf ("%s%s:\n", description, descrip_extra);
1431 print_filtered_help (include_flags, exclude_flags, any_flags, columns);
1434 /* Handle target- and language-independent options. Return zero to
1435 generate an "unknown option" message. Only options that need
1436 extra handling need to be listed here; if you simply want
1437 VALUE assigned to a variable, it happens automatically. */
1440 common_handle_option (size_t scode, const char *arg, int value,
1441 unsigned int lang_mask)
1443 static bool verbose = false;
1444 enum opt_code code = (enum opt_code) scode;
1459 unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
1460 unsigned int undoc_mask;
1463 undoc_mask = (verbose | extra_warnings) ? 0 : CL_UNDOCUMENTED;
1464 /* First display any single language specific options. */
1465 for (i = 0; i < cl_lang_count; i++)
1467 (1U << i, (all_langs_mask & (~ (1U << i))) | undoc_mask, 0);
1468 /* Next display any multi language specific options. */
1469 print_specific_help (0, undoc_mask, all_langs_mask);
1470 /* Then display any remaining, non-language options. */
1471 for (i = CL_MIN_OPTION_CLASS; i <= CL_MAX_OPTION_CLASS; i <<= 1)
1472 print_specific_help (i, undoc_mask, 0);
1473 exit_after_options = true;
1477 case OPT_ftarget_help:
1478 case OPT__target_help:
1479 print_specific_help (CL_TARGET, CL_UNDOCUMENTED, 0);
1480 exit_after_options = true;
1482 /* Allow the target a chance to give the user some additional information. */
1483 if (targetm.target_help)
1484 targetm.target_help ();
1490 const char * a = arg;
1491 unsigned int include_flags = 0;
1492 /* Note - by default we include undocumented options when listing
1493 specific classes. If you only want to see documented options
1494 then add ",^undocumented" to the --help= option. E.g.:
1496 --help=target,^undocumented */
1497 unsigned int exclude_flags = 0;
1499 /* Walk along the argument string, parsing each word in turn.
1501 arg = [^]{word}[,{arg}]
1502 word = {optimizers|target|warnings|undocumented|
1503 params|common|<language>} */
1508 const char * string;
1513 { "optimizers", CL_OPTIMIZATION },
1514 { "target", CL_TARGET },
1515 { "warnings", CL_WARNING },
1516 { "undocumented", CL_UNDOCUMENTED },
1517 { "params", CL_PARAMS },
1518 { "common", CL_COMMON },
1521 unsigned int * pflags;
1523 unsigned int lang_flag, specific_flag;
1530 pflags = & exclude_flags;
1533 pflags = & include_flags;
1535 comma = strchr (a, ',');
1541 /* Check to see if the string matches an option class name. */
1542 for (i = 0, specific_flag = 0; specifics[i].string != NULL; i++)
1543 if (strncasecmp (a, specifics[i].string, len) == 0)
1545 specific_flag = specifics[i].flag;
1549 /* Check to see if the string matches a language name.
1550 Note - we rely upon the alpha-sorted nature of the entries in
1551 the lang_names array, specifically that shorter names appear
1552 before their longer variants. (i.e. C before C++). That way
1553 when we are attempting to match --help=c for example we will
1554 match with C first and not C++. */
1555 for (i = 0, lang_flag = 0; i < cl_lang_count; i++)
1556 if (strncasecmp (a, lang_names[i], len) == 0)
1558 lang_flag = 1U << i;
1562 if (specific_flag != 0)
1565 * pflags |= specific_flag;
1568 /* The option's argument matches both the start of a
1569 language name and the start of an option class name.
1570 We have a special case for when the user has
1571 specified "--help=c", but otherwise we have to issue
1573 if (strncasecmp (a, "c", len) == 0)
1574 * pflags |= lang_flag;
1577 "warning: --help argument %.*s is ambiguous, please be more specific\n",
1581 else if (lang_flag != 0)
1582 * pflags |= lang_flag;
1585 "warning: unrecognized argument to --help= option: %.*s\n",
1594 print_specific_help (include_flags, exclude_flags, 0);
1595 exit_after_options = true;
1600 print_version (stderr, "");
1601 exit_after_options = true;
1605 g_switch_value = value;
1606 g_switch_set = true;
1611 /* Currently handled in a prescan. */
1615 /* For backward compatibility, -W is the same as -Wextra. */
1619 case OPT_Wdisallowed_function_list_:
1620 warn_disallowed_functions = true;
1621 add_comma_separated_to_vector
1622 (&warning_disallowed_functions, arg);
1626 enable_warning_as_error (arg, value, lang_mask);
1633 case OPT_Wlarger_than_:
1634 /* This form corresponds to -Wlarger-than-.
1635 Kept for backward compatibility.
1636 Don't use it as the first argument of warning(). */
1638 case OPT_Wlarger_than_eq:
1639 larger_than_size = value;
1640 warn_larger_than = value != -1;
1643 case OPT_Wframe_larger_than_:
1644 frame_larger_than_size = value;
1645 warn_frame_larger_than = value != -1;
1648 case OPT_Wstrict_aliasing:
1649 set_Wstrict_aliasing (value);
1652 case OPT_Wstrict_aliasing_:
1653 warn_strict_aliasing = value;
1656 case OPT_Wstrict_overflow:
1657 warn_strict_overflow = (value
1658 ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
1662 case OPT_Wstrict_overflow_:
1663 warn_strict_overflow = value;
1667 warn_unused = value;
1672 aux_info_file_name = arg;
1673 flag_gen_aux_info = 1;
1677 aux_base_name = arg;
1680 case OPT_auxbase_strip:
1682 char *tmp = xstrdup (arg);
1683 strip_off_ending (tmp, strlen (tmp));
1685 aux_base_name = tmp;
1690 decode_d_option (arg);
1694 dump_base_name = arg;
1697 case OPT_falign_functions_:
1698 align_functions = value;
1701 case OPT_falign_jumps_:
1702 align_jumps = value;
1705 case OPT_falign_labels_:
1706 align_labels = value;
1709 case OPT_falign_loops_:
1710 align_loops = value;
1713 case OPT_fbranch_probabilities:
1714 flag_branch_probabilities_set = true;
1717 case OPT_fcall_used_:
1718 fix_register (arg, 0, 1);
1721 case OPT_fcall_saved_:
1722 fix_register (arg, 0, 0);
1726 dbg_cnt_process_opt (arg);
1729 case OPT_fdbg_cnt_list:
1730 dbg_cnt_list_all_counters ();
1733 case OPT_fdebug_prefix_map_:
1734 add_debug_prefix_map (arg);
1737 case OPT_fdiagnostics_show_location_:
1738 if (!strcmp (arg, "once"))
1739 diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
1740 else if (!strcmp (arg, "every-line"))
1741 diagnostic_prefixing_rule (global_dc)
1742 = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE;
1747 case OPT_fdiagnostics_show_option:
1748 global_dc->show_option_requested = true;
1752 if (!dump_switch_p (arg))
1756 case OPT_ffast_math:
1757 set_fast_math_flags (value);
1760 case OPT_funsafe_math_optimizations:
1761 set_unsafe_math_optimizations_flags (value);
1765 fix_register (arg, 1, 1);
1768 case OPT_finline_limit_:
1769 case OPT_finline_limit_eq:
1770 set_param_value ("max-inline-insns-single", value / 2);
1771 set_param_value ("max-inline-insns-auto", value / 2);
1774 case OPT_finstrument_functions_exclude_function_list_:
1775 add_comma_separated_to_vector
1776 (&flag_instrument_functions_exclude_functions, arg);
1779 case OPT_finstrument_functions_exclude_file_list_:
1780 add_comma_separated_to_vector
1781 (&flag_instrument_functions_exclude_files, arg);
1784 case OPT_fmessage_length_:
1785 pp_set_line_maximum_length (global_dc->printer, value);
1788 case OPT_fpack_struct_:
1789 if (value <= 0 || (value & (value - 1)) || value > 16)
1790 error ("structure alignment must be a small power of two, not %d", value);
1793 initial_max_fld_align = value;
1794 maximum_field_alignment = value * BITS_PER_UNIT;
1798 case OPT_fpeel_loops:
1799 flag_peel_loops_set = true;
1802 case OPT_fprofile_arcs:
1803 profile_arc_flag_set = true;
1806 case OPT_finline_functions:
1807 flag_inline_functions_set = true;
1810 case OPT_fprofile_dir_:
1811 profile_data_prefix = xstrdup (arg);
1814 case OPT_fprofile_use_:
1815 profile_data_prefix = xstrdup (arg);
1816 flag_profile_use = true;
1818 /* No break here - do -fprofile-use processing. */
1819 case OPT_fprofile_use:
1820 if (!flag_branch_probabilities_set)
1821 flag_branch_probabilities = value;
1822 if (!flag_profile_values_set)
1823 flag_profile_values = value;
1824 if (!flag_unroll_loops_set)
1825 flag_unroll_loops = value;
1826 if (!flag_peel_loops_set)
1827 flag_peel_loops = value;
1828 if (!flag_tracer_set)
1829 flag_tracer = value;
1830 if (!flag_value_profile_transformations_set)
1831 flag_value_profile_transformations = value;
1832 if (!flag_inline_functions_set)
1833 flag_inline_functions = value;
1834 if (!flag_ipa_cp_set)
1835 flag_ipa_cp = value;
1836 if (!flag_ipa_cp_clone_set
1837 && value && flag_ipa_cp)
1838 flag_ipa_cp_clone = value;
1839 if (!flag_predictive_commoning_set)
1840 flag_predictive_commoning = value;
1841 if (!flag_unswitch_loops_set)
1842 flag_unswitch_loops = value;
1843 if (!flag_gcse_after_reload_set)
1844 flag_gcse_after_reload = value;
1847 case OPT_fprofile_generate_:
1848 profile_data_prefix = xstrdup (arg);
1850 /* No break here - do -fprofile-generate processing. */
1851 case OPT_fprofile_generate:
1852 if (!profile_arc_flag_set)
1853 profile_arc_flag = value;
1854 if (!flag_profile_values_set)
1855 flag_profile_values = value;
1856 if (!flag_value_profile_transformations_set)
1857 flag_value_profile_transformations = value;
1858 if (!flag_inline_functions_set)
1859 flag_inline_functions = value;
1862 case OPT_fprofile_values:
1863 flag_profile_values_set = true;
1866 case OPT_fvisibility_:
1868 if (!strcmp(arg, "default"))
1869 default_visibility = VISIBILITY_DEFAULT;
1870 else if (!strcmp(arg, "internal"))
1871 default_visibility = VISIBILITY_INTERNAL;
1872 else if (!strcmp(arg, "hidden"))
1873 default_visibility = VISIBILITY_HIDDEN;
1874 else if (!strcmp(arg, "protected"))
1875 default_visibility = VISIBILITY_PROTECTED;
1877 error ("unrecognized visibility value \"%s\"", arg);
1882 flag_value_profile_transformations_set = true;
1885 case OPT_frandom_seed:
1886 /* The real switch is -fno-random-seed. */
1889 set_random_seed (NULL);
1892 case OPT_frandom_seed_:
1893 set_random_seed (arg);
1896 case OPT_fselective_scheduling:
1897 case OPT_fselective_scheduling2:
1898 sel_sched_switch_set = true;
1901 case OPT_fsched_verbose_:
1902 #ifdef INSN_SCHEDULING
1903 fix_sched_param ("verbose", arg);
1909 case OPT_fsched_stalled_insns_:
1910 flag_sched_stalled_insns = value;
1911 if (flag_sched_stalled_insns == 0)
1912 flag_sched_stalled_insns = -1;
1915 case OPT_fsched_stalled_insns_dep_:
1916 flag_sched_stalled_insns_dep = value;
1919 case OPT_fstack_check_:
1920 if (!strcmp (arg, "no"))
1921 flag_stack_check = NO_STACK_CHECK;
1922 else if (!strcmp (arg, "generic"))
1923 /* This is the old stack checking method. */
1924 flag_stack_check = STACK_CHECK_BUILTIN
1925 ? FULL_BUILTIN_STACK_CHECK
1926 : GENERIC_STACK_CHECK;
1927 else if (!strcmp (arg, "specific"))
1928 /* This is the new stack checking method. */
1929 flag_stack_check = STACK_CHECK_BUILTIN
1930 ? FULL_BUILTIN_STACK_CHECK
1931 : STACK_CHECK_STATIC_BUILTIN
1932 ? STATIC_BUILTIN_STACK_CHECK
1933 : GENERIC_STACK_CHECK;
1935 warning (0, "unknown stack check parameter \"%s\"", arg);
1938 case OPT_fstack_check:
1939 /* This is the same as the "specific" mode above. */
1941 flag_stack_check = STACK_CHECK_BUILTIN
1942 ? FULL_BUILTIN_STACK_CHECK
1943 : STACK_CHECK_STATIC_BUILTIN
1944 ? STATIC_BUILTIN_STACK_CHECK
1945 : GENERIC_STACK_CHECK;
1947 flag_stack_check = NO_STACK_CHECK;
1950 case OPT_fstack_limit:
1951 /* The real switch is -fno-stack-limit. */
1954 stack_limit_rtx = NULL_RTX;
1957 case OPT_fstack_limit_register_:
1959 int reg = decode_reg_name (arg);
1961 error ("unrecognized register name \"%s\"", arg);
1963 stack_limit_rtx = gen_rtx_REG (Pmode, reg);
1967 case OPT_fstack_limit_symbol_:
1968 stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (arg));
1971 case OPT_ftree_vectorizer_verbose_:
1972 vect_set_verbosity_level (arg);
1975 case OPT_ftls_model_:
1976 if (!strcmp (arg, "global-dynamic"))
1977 flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
1978 else if (!strcmp (arg, "local-dynamic"))
1979 flag_tls_default = TLS_MODEL_LOCAL_DYNAMIC;
1980 else if (!strcmp (arg, "initial-exec"))
1981 flag_tls_default = TLS_MODEL_INITIAL_EXEC;
1982 else if (!strcmp (arg, "local-exec"))
1983 flag_tls_default = TLS_MODEL_LOCAL_EXEC;
1985 warning (0, "unknown tls-model \"%s\"", arg);
1988 case OPT_fira_algorithm_:
1989 if (!strcmp (arg, "CB"))
1990 flag_ira_algorithm = IRA_ALGORITHM_CB;
1991 else if (!strcmp (arg, "priority"))
1992 flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
1994 warning (0, "unknown ira algorithm \"%s\"", arg);
1997 case OPT_fira_region_:
1998 if (!strcmp (arg, "one"))
1999 flag_ira_region = IRA_REGION_ONE;
2000 else if (!strcmp (arg, "all"))
2001 flag_ira_region = IRA_REGION_ALL;
2002 else if (!strcmp (arg, "mixed"))
2003 flag_ira_region = IRA_REGION_MIXED;
2005 warning (0, "unknown ira region \"%s\"", arg);
2008 case OPT_fira_verbose_:
2009 flag_ira_verbose = value;
2013 flag_tracer_set = true;
2017 flag_ipa_cp_set = true;
2020 case OPT_fipa_cp_clone:
2021 flag_ipa_cp_clone_set = true;
2024 case OPT_fpredictive_commoning:
2025 flag_predictive_commoning_set = true;
2028 case OPT_funswitch_loops:
2029 flag_unswitch_loops_set = true;
2032 case OPT_fgcse_after_reload:
2033 flag_gcse_after_reload_set = true;
2036 case OPT_funroll_loops:
2037 flag_unroll_loops_set = true;
2041 set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg);
2045 set_debug_level (SDB_DEBUG, false, arg);
2049 set_debug_level (DWARF2_DEBUG, false, arg);
2053 set_debug_level (NO_DEBUG, 2, arg);
2058 set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg);
2062 set_debug_level (VMS_DEBUG, false, arg);
2067 set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg);
2071 asm_file_name = arg;
2074 case OPT_pedantic_errors:
2075 flag_pedantic_errors = pedantic = 1;
2078 case OPT_floop_optimize:
2079 case OPT_frerun_loop_opt:
2080 case OPT_fstrength_reduce:
2081 case OPT_ftree_store_copy_prop:
2082 case OPT_fforce_addr:
2083 case OPT_ftree_salias:
2084 case OPT_ftree_store_ccp:
2085 /* These are no-ops, preserved for backward compatibility. */
2089 /* If the flag was handled in a standard way, assume the lack of
2090 processing here is intentional. */
2091 gcc_assert (cl_options[scode].flag_var);
2098 /* Handle --param NAME=VALUE. */
2100 handle_param (const char *carg)
2105 arg = xstrdup (carg);
2106 equal = strchr (arg, '=');
2108 error ("%s: --param arguments should be of the form NAME=VALUE", arg);
2111 value = integral_argument (equal + 1);
2113 error ("invalid --param value %qs", equal + 1);
2117 set_param_value (arg, value);
2124 /* Handle -W and -Wextra. */
2126 set_Wextra (int setting)
2128 extra_warnings = setting;
2130 /* We save the value of warn_uninitialized, since if they put
2131 -Wuninitialized on the command line, we need to generate a
2132 warning about not using it without also specifying -O. */
2134 warn_uninitialized = 0;
2135 else if (warn_uninitialized != 1)
2136 warn_uninitialized = 2;
2139 /* Used to set the level of strict aliasing warnings,
2140 when no level is specified (i.e., when -Wstrict-aliasing, and not
2141 -Wstrict-aliasing=level was given).
2142 ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
2143 and 0 otherwise. After calling this function, wstrict_aliasing will be
2144 set to the default value of -Wstrict_aliasing=level, currently 3. */
2146 set_Wstrict_aliasing (int onoff)
2148 gcc_assert (onoff == 0 || onoff == 1);
2150 warn_strict_aliasing = 3;
2152 warn_strict_aliasing = 0;
2155 /* The following routines are useful in setting all the flags that
2156 -ffast-math and -fno-fast-math imply. */
2158 set_fast_math_flags (int set)
2160 flag_unsafe_math_optimizations = set;
2161 set_unsafe_math_optimizations_flags (set);
2162 flag_finite_math_only = set;
2163 flag_errno_math = !set;
2166 flag_signaling_nans = 0;
2167 flag_rounding_math = 0;
2168 flag_cx_limited_range = 1;
2172 /* When -funsafe-math-optimizations is set the following
2173 flags are set as well. */
2175 set_unsafe_math_optimizations_flags (int set)
2177 flag_trapping_math = !set;
2178 flag_signed_zeros = !set;
2179 flag_associative_math = set;
2180 flag_reciprocal_math = set;
2183 /* Return true iff flags are set as if -ffast-math. */
2185 fast_math_flags_set_p (void)
2187 return (!flag_trapping_math
2188 && flag_unsafe_math_optimizations
2189 && flag_finite_math_only
2190 && !flag_signed_zeros
2191 && !flag_errno_math);
2194 /* Return true iff flags are set as if -ffast-math but using the flags stored
2195 in the struct cl_optimization structure. */
2197 fast_math_flags_struct_set_p (struct cl_optimization *opt)
2199 return (!opt->flag_trapping_math
2200 && opt->flag_unsafe_math_optimizations
2201 && opt->flag_finite_math_only
2202 && !opt->flag_signed_zeros
2203 && !opt->flag_errno_math);
2206 /* Handle a debug output -g switch. EXTENDED is true or false to support
2207 extended output (2 is special and means "-ggdb" was given). */
2209 set_debug_level (enum debug_info_type type, int extended, const char *arg)
2211 static bool type_explicit;
2213 use_gnu_debug_info_extensions = extended;
2215 if (type == NO_DEBUG)
2217 if (write_symbols == NO_DEBUG)
2219 write_symbols = PREFERRED_DEBUGGING_TYPE;
2223 #ifdef DWARF2_DEBUGGING_INFO
2224 write_symbols = DWARF2_DEBUG;
2225 #elif defined DBX_DEBUGGING_INFO
2226 write_symbols = DBX_DEBUG;
2230 if (write_symbols == NO_DEBUG)
2231 warning (0, "target system does not support debug output");
2236 /* Does it conflict with an already selected type? */
2237 if (type_explicit && write_symbols != NO_DEBUG && type != write_symbols)
2238 error ("debug format \"%s\" conflicts with prior selection",
2239 debug_type_names[type]);
2240 write_symbols = type;
2241 type_explicit = true;
2244 /* A debug flag without a level defaults to level 2. */
2247 if (!debug_info_level)
2248 debug_info_level = 2;
2252 debug_info_level = integral_argument (arg);
2253 if (debug_info_level == (unsigned int) -1)
2254 error ("unrecognised debug output level \"%s\"", arg);
2255 else if (debug_info_level > 3)
2256 error ("debug output level %s is too high", arg);
2260 /* Return 1 if OPTION is enabled, 0 if it is disabled, or -1 if it isn't
2261 a simple on-off switch. */
2264 option_enabled (int opt_idx)
2266 const struct cl_option *option = &(cl_options[opt_idx]);
2268 if (option->flag_var)
2269 switch (option->var_type)
2272 return *(int *) option->flag_var != 0;
2275 return *(int *) option->flag_var == option->var_value;
2277 case CLVC_BIT_CLEAR:
2278 return (*(int *) option->flag_var & option->var_value) == 0;
2281 return (*(int *) option->flag_var & option->var_value) != 0;
2289 /* Fill STATE with the current state of option OPTION. Return true if
2290 there is some state to store. */
2293 get_option_state (int option, struct cl_option_state *state)
2295 if (cl_options[option].flag_var == 0)
2298 switch (cl_options[option].var_type)
2302 state->data = cl_options[option].flag_var;
2303 state->size = sizeof (int);
2306 case CLVC_BIT_CLEAR:
2308 state->ch = option_enabled (option);
2309 state->data = &state->ch;
2314 state->data = *(const char **) cl_options[option].flag_var;
2315 if (state->data == 0)
2317 state->size = strlen ((const char *) state->data) + 1;
2323 /* Enable a warning option as an error. This is used by -Werror= and
2324 also by legacy Werror-implicit-function-declaration. */
2327 enable_warning_as_error (const char *arg, int value, unsigned int lang_mask)
2332 new_option = XNEWVEC (char, strlen (arg) + 2);
2333 new_option[0] = 'W';
2334 strcpy (new_option + 1, arg);
2335 option_index = find_opt (new_option, lang_mask);
2336 if (option_index == N_OPTS)
2338 error ("-Werror=%s: No option -%s", arg, new_option);
2342 int kind = value ? DK_ERROR : DK_WARNING;
2343 diagnostic_classify_diagnostic (global_dc, option_index, kind);
2345 /* -Werror=foo implies -Wfoo. */
2346 if (cl_options[option_index].var_type == CLVC_BOOLEAN
2347 && cl_options[option_index].flag_var
2348 && kind == DK_ERROR)
2349 *(int *) cl_options[option_index].flag_var = 1;