1 /* Command line option handling.
2 Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007
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"
31 #include "langhooks.h"
37 #include "diagnostic.h"
38 #include "tm_p.h" /* For OPTIMIZATION_OPTIONS. */
39 #include "insn-attr.h" /* For INSN_SCHEDULING. */
41 #include "tree-pass.h"
45 /* Value of the -G xx switch, and whether it was passed or not. */
46 unsigned HOST_WIDE_INT g_switch_value;
49 /* True if we should exit after parsing options. */
50 bool exit_after_options;
52 /* Print various extra warnings. -W/-Wextra. */
55 /* True to warn about any objects definitions whose size is larger
56 than N bytes. Also want about function definitions whose returned
57 values are larger than N bytes, where N is `larger_than_size'. */
58 bool warn_larger_than;
59 HOST_WIDE_INT larger_than_size;
61 /* Nonzero means warn about constructs which might not be
62 strict-aliasing safe. */
63 int warn_strict_aliasing;
65 /* Nonzero means warn about optimizations which rely on undefined
67 int warn_strict_overflow;
69 /* Hack for cooperation between set_Wunused and set_Wextra. */
70 static bool maybe_warn_unused_parameter;
72 /* Type(s) of debugging information we are producing (if any). See
73 flags.h for the definitions of the different possible types of
74 debugging information. */
75 enum debug_info_type write_symbols = NO_DEBUG;
77 /* Level of debugging information we are producing. See flags.h for
78 the definitions of the different possible levels. */
79 enum debug_info_level debug_info_level = DINFO_LEVEL_NONE;
81 /* A major contribution to object and executable size is debug
82 information size. A major contribution to debug information size
83 is struct descriptions replicated in several object files. The
84 following flags attempt to reduce this information. The basic
85 idea is to not emit struct debugging information in the current
86 compilation unit when that information will be generated by
87 another compilation unit.
89 Debug information for a struct defined in the current source
90 file should be generated in the object file. Likewise the
91 debug information for a struct defined in a header should be
92 generated in the object file of the corresponding source file.
93 Both of these case are handled when the base name of the file of
94 the struct definition matches the base name of the source file
95 of the current compilation unit. This matching emits minimal
96 struct debugging information.
98 The base file name matching rule above will fail to emit debug
99 information for structs defined in system headers. So a second
100 category of files includes system headers in addition to files
103 The remaining types of files are library headers and application
104 headers. We cannot currently distinguish these two types. */
106 enum debug_struct_file
108 DINFO_STRUCT_FILE_NONE, /* Debug no structs. */
109 DINFO_STRUCT_FILE_BASE, /* Debug structs defined in files with the
110 same base name as the compilation unit. */
111 DINFO_STRUCT_FILE_SYS, /* Also debug structs defined in system
113 DINFO_STRUCT_FILE_ANY /* Debug structs defined in all files. */
116 /* Generic structs (e.g. templates not explicitly specialized)
117 may not have a compilation unit associated with them, and so
118 may need to be treated differently from ordinary structs.
120 Structs only handled by reference (indirectly), will also usually
121 not need as much debugging information. */
123 static enum debug_struct_file debug_struct_ordinary[DINFO_USAGE_NUM_ENUMS]
124 = { DINFO_STRUCT_FILE_ANY, DINFO_STRUCT_FILE_ANY, DINFO_STRUCT_FILE_ANY };
125 static enum debug_struct_file debug_struct_generic[DINFO_USAGE_NUM_ENUMS]
126 = { DINFO_STRUCT_FILE_ANY, DINFO_STRUCT_FILE_ANY, DINFO_STRUCT_FILE_ANY };
128 /* Parse the -femit-struct-debug-detailed option value
129 and set the flag variables. */
131 #define MATCH( prefix, string ) \
132 ((strncmp (prefix, string, sizeof prefix - 1) == 0) \
133 ? ((string += sizeof prefix - 1), 1) : 0)
136 set_struct_debug_option (const char *spec)
138 /* various labels for comparison */
139 static char dfn_lbl[] = "dfn:", dir_lbl[] = "dir:", ind_lbl[] = "ind:";
140 static char ord_lbl[] = "ord:", gen_lbl[] = "gen:";
141 static char none_lbl[] = "none", any_lbl[] = "any";
142 static char base_lbl[] = "base", sys_lbl[] = "sys";
144 enum debug_struct_file files = DINFO_STRUCT_FILE_ANY;
145 /* Default is to apply to as much as possible. */
146 enum debug_info_usage usage = DINFO_USAGE_NUM_ENUMS;
147 int ord = 1, gen = 1;
150 if (MATCH (dfn_lbl, spec))
151 usage = DINFO_USAGE_DFN;
152 else if (MATCH (dir_lbl, spec))
153 usage = DINFO_USAGE_DIR_USE;
154 else if (MATCH (ind_lbl, spec))
155 usage = DINFO_USAGE_IND_USE;
157 /* Generics or not? */
158 if (MATCH (ord_lbl, spec))
160 else if (MATCH (gen_lbl, spec))
163 /* What allowable environment? */
164 if (MATCH (none_lbl, spec))
165 files = DINFO_STRUCT_FILE_NONE;
166 else if (MATCH (any_lbl, spec))
167 files = DINFO_STRUCT_FILE_ANY;
168 else if (MATCH (sys_lbl, spec))
169 files = DINFO_STRUCT_FILE_SYS;
170 else if (MATCH (base_lbl, spec))
171 files = DINFO_STRUCT_FILE_BASE;
173 error ("argument %qs to %<-femit-struct-debug-detailed%> not recognized",
176 /* Effect the specification. */
177 if (usage == DINFO_USAGE_NUM_ENUMS)
181 debug_struct_ordinary[DINFO_USAGE_DFN] = files;
182 debug_struct_ordinary[DINFO_USAGE_DIR_USE] = files;
183 debug_struct_ordinary[DINFO_USAGE_IND_USE] = files;
187 debug_struct_generic[DINFO_USAGE_DFN] = files;
188 debug_struct_generic[DINFO_USAGE_DIR_USE] = files;
189 debug_struct_generic[DINFO_USAGE_IND_USE] = files;
195 debug_struct_ordinary[usage] = files;
197 debug_struct_generic[usage] = files;
201 set_struct_debug_option (spec+1);
204 /* No more -femit-struct-debug-detailed specifications.
207 error ("argument %qs to %<-femit-struct-debug-detailed%> unknown",
209 if (debug_struct_ordinary[DINFO_USAGE_DIR_USE]
210 < debug_struct_ordinary[DINFO_USAGE_IND_USE]
211 || debug_struct_generic[DINFO_USAGE_DIR_USE]
212 < debug_struct_generic[DINFO_USAGE_IND_USE])
213 error ("%<-femit-struct-debug-detailed=dir:...%> must allow at least"
214 " as much as %<-femit-struct-debug-detailed=ind:...%>");
218 /* Find the base name of a path, stripping off both directories and
219 a single final extension. */
221 base_of_path (const char *path, const char **base_out)
223 const char *base = path;
225 const char *p = path;
229 if (IS_DIR_SEPARATOR(c))
244 /* Match the base name of a file to the base name of a compilation unit. */
246 static const char *main_input_basename;
247 static int main_input_baselength;
250 matches_main_base (const char *path)
252 /* Cache the last query. */
253 static const char *last_path = NULL;
254 static int last_match = 0;
255 if (path != last_path)
258 int length = base_of_path (path, &base);
260 last_match = (length == main_input_baselength
261 && memcmp (base, main_input_basename, length) == 0);
266 #ifdef DEBUG_DEBUG_STRUCT
269 dump_struct_debug (tree type, enum debug_info_usage usage,
270 enum debug_struct_file criterion, int generic,
271 int matches, int result)
273 /* Find the type name. */
274 tree type_decl = TYPE_STUB_DECL (type);
276 const char *name = 0;
277 if (TREE_CODE (t) == TYPE_DECL)
280 name = IDENTIFIER_POINTER (t);
282 fprintf (stderr, " struct %d %s %s %s %s %d %p %s\n",
284 DECL_IN_SYSTEM_HEADER (type_decl) ? "sys" : "usr",
285 matches ? "bas" : "hdr",
286 generic ? "gen" : "ord",
287 usage == DINFO_USAGE_DFN ? ";" :
288 usage == DINFO_USAGE_DIR_USE ? "." : "*",
290 (void*) type_decl, name);
293 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
294 dump_struct_debug (type, usage, criterion, generic, matches, result)
298 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
305 should_emit_struct_debug (tree type, enum debug_info_usage usage)
307 enum debug_struct_file criterion;
309 bool generic = lang_hooks.types.generic_p (type);
312 criterion = debug_struct_generic[usage];
314 criterion = debug_struct_ordinary[usage];
316 if (criterion == DINFO_STRUCT_FILE_NONE)
317 return DUMP_GSTRUCT (type, usage, criterion, generic, false, false);
318 if (criterion == DINFO_STRUCT_FILE_ANY)
319 return DUMP_GSTRUCT (type, usage, criterion, generic, false, true);
321 type_decl = TYPE_STUB_DECL (type);
323 if (criterion == DINFO_STRUCT_FILE_SYS && DECL_IN_SYSTEM_HEADER (type_decl))
324 return DUMP_GSTRUCT (type, usage, criterion, generic, false, true);
326 if (matches_main_base (DECL_SOURCE_FILE (type_decl)))
327 return DUMP_GSTRUCT (type, usage, criterion, generic, true, true);
328 return DUMP_GSTRUCT (type, usage, criterion, generic, false, false);
331 /* Nonzero means use GNU-only extensions in the generated symbolic
332 debugging information. Currently, this only has an effect when
333 write_symbols is set to DBX_DEBUG, XCOFF_DEBUG, or DWARF_DEBUG. */
334 bool use_gnu_debug_info_extensions;
336 /* The default visibility for all symbols (unless overridden) */
337 enum symbol_visibility default_visibility = VISIBILITY_DEFAULT;
339 /* Disable unit-at-a-time for frontends that might be still broken in this
342 bool no_unit_at_a_time_default;
344 /* Global visibility options. */
345 struct visibility_flags visibility_options;
347 /* What to print when a switch has no documentation. */
348 static const char undocumented_msg[] = N_("This switch lacks documentation");
350 /* Used for bookkeeping on whether user set these flags so
351 -fprofile-use/-fprofile-generate does not use them. */
352 static bool profile_arc_flag_set, flag_profile_values_set;
353 static bool flag_unroll_loops_set, flag_tracer_set;
354 static bool flag_value_profile_transformations_set;
355 static bool flag_peel_loops_set, flag_branch_probabilities_set;
356 static bool flag_inline_functions_set;
358 /* Functions excluded from profiling. */
360 typedef char *char_p; /* For DEF_VEC_P. */
362 DEF_VEC_ALLOC_P(char_p,heap);
364 static VEC(char_p,heap) *flag_instrument_functions_exclude_functions;
365 static VEC(char_p,heap) *flag_instrument_functions_exclude_files;
367 /* Input file names. */
368 const char **in_fnames;
369 unsigned num_in_fnames;
371 static int common_handle_option (size_t scode, const char *arg, int value,
372 unsigned int lang_mask);
373 static void handle_param (const char *);
374 static void set_Wextra (int);
375 static unsigned int handle_option (const char **argv, unsigned int lang_mask);
376 static char *write_langs (unsigned int lang_mask);
377 static void complain_wrong_lang (const char *, const struct cl_option *,
378 unsigned int lang_mask);
379 static void handle_options (unsigned int, const char **, unsigned int);
380 static void set_debug_level (enum debug_info_type type, int extended,
383 /* If ARG is a non-negative integer made up solely of digits, return its
384 value, otherwise return -1. */
386 integral_argument (const char *arg)
390 while (*p && ISDIGIT (*p))
399 /* Return a malloced slash-separated list of languages in MASK. */
401 write_langs (unsigned int mask)
403 unsigned int n = 0, len = 0;
404 const char *lang_name;
407 for (n = 0; (lang_name = lang_names[n]) != 0; n++)
408 if (mask & (1U << n))
409 len += strlen (lang_name) + 1;
411 result = XNEWVEC (char, len);
413 for (n = 0; (lang_name = lang_names[n]) != 0; n++)
414 if (mask & (1U << n))
418 strcpy (result + len, lang_name);
419 len += strlen (lang_name);
427 /* Complain that switch OPT_INDEX does not apply to this front end. */
429 complain_wrong_lang (const char *text, const struct cl_option *option,
430 unsigned int lang_mask)
432 char *ok_langs, *bad_lang;
434 ok_langs = write_langs (option->flags);
435 bad_lang = write_langs (lang_mask);
437 /* Eventually this should become a hard error IMO. */
438 warning (0, "command line option \"%s\" is valid for %s but not for %s",
439 text, ok_langs, bad_lang);
445 /* Handle the switch beginning at ARGV for the language indicated by
446 LANG_MASK. Returns the number of switches consumed. */
448 handle_option (const char **argv, unsigned int lang_mask)
451 const char *opt, *arg = 0;
454 unsigned int result = 0;
455 const struct cl_option *option;
459 opt_index = find_opt (opt + 1, lang_mask | CL_COMMON | CL_TARGET);
460 if (opt_index == cl_options_count
461 && (opt[1] == 'W' || opt[1] == 'f' || opt[1] == 'm')
462 && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-')
464 /* Drop the "no-" from negative switches. */
465 size_t len = strlen (opt) - 3;
467 dup = XNEWVEC (char, len + 1);
470 memcpy (dup + 2, opt + 5, len - 2 + 1);
473 opt_index = find_opt (opt + 1, lang_mask | CL_COMMON | CL_TARGET);
476 if (opt_index == cl_options_count)
479 option = &cl_options[opt_index];
481 /* Reject negative form of switches that don't take negatives as
483 if (!value && (option->flags & CL_REJECT_NEGATIVE))
486 /* We've recognized this switch. */
489 /* Check to see if the option is disabled for this configuration. */
490 if (option->flags & CL_DISABLED)
492 error ("command line option %qs"
493 " is not supported by this configuration", opt);
497 /* Sort out any argument the switch takes. */
498 if (option->flags & CL_JOINED)
500 /* Have arg point to the original switch. This is because
501 some code, such as disable_builtin_function, expects its
502 argument to be persistent until the program exits. */
503 arg = argv[0] + cl_options[opt_index].opt_len + 1;
505 arg += strlen ("no-");
507 if (*arg == '\0' && !(option->flags & CL_MISSING_OK))
509 if (option->flags & CL_SEPARATE)
515 /* Missing argument. */
519 else if (option->flags & CL_SEPARATE)
525 /* Now we've swallowed any potential argument, complain if this
526 is a switch for a different front end. */
527 if (!(option->flags & (lang_mask | CL_COMMON | CL_TARGET)))
529 complain_wrong_lang (argv[0], option, lang_mask);
532 else if ((option->flags & CL_TARGET)
533 && (option->flags & CL_LANG_ALL)
534 && !(option->flags & lang_mask))
536 /* Complain for target flag language mismatches if any languages
538 complain_wrong_lang (argv[0], option, lang_mask);
542 if (arg == NULL && (option->flags & (CL_JOINED | CL_SEPARATE)))
544 if (!lang_hooks.missing_argument (opt, opt_index))
545 error ("missing argument to \"%s\"", opt);
549 /* If the switch takes an integer, convert it. */
550 if (arg && (option->flags & CL_UINTEGER))
552 value = integral_argument (arg);
555 error ("argument to \"%s\" should be a non-negative integer",
561 if (option->flag_var)
562 switch (option->var_type)
565 *(int *) option->flag_var = value;
569 *(int *) option->flag_var = (value
571 : !option->var_value);
576 if ((value != 0) == (option->var_type == CLVC_BIT_SET))
577 *(int *) option->flag_var |= option->var_value;
579 *(int *) option->flag_var &= ~option->var_value;
580 if (option->flag_var == &target_flags)
581 target_flags_explicit |= option->var_value;
585 *(const char **) option->flag_var = arg;
589 if (option->flags & lang_mask)
590 if (lang_hooks.handle_option (opt_index, arg, value) == 0)
593 if (result && (option->flags & CL_COMMON))
594 if (common_handle_option (opt_index, arg, value, lang_mask) == 0)
597 if (result && (option->flags & CL_TARGET))
598 if (!targetm.handle_option (opt_index, arg, value))
607 /* Handle FILENAME from the command line. */
609 add_input_filename (const char *filename)
612 in_fnames = xrealloc (in_fnames, num_in_fnames * sizeof (in_fnames[0]));
613 in_fnames[num_in_fnames - 1] = filename;
616 /* Add functions or file names to a vector of names to exclude from
620 add_instrument_functions_exclude_list (VEC(char_p,heap) **pvec,
628 /* We never free this string. */
641 VEC_safe_push (char_p, heap, *pvec, token_start);
644 if (*r == '\\' && r[1] == ',')
652 if (*token_start != '\0')
653 VEC_safe_push (char_p, heap, *pvec, token_start);
656 /* Return whether we should exclude FNDECL from instrumentation. */
659 flag_instrument_functions_exclude_p (tree fndecl)
661 if (VEC_length (char_p, flag_instrument_functions_exclude_functions) > 0)
667 name = lang_hooks.decl_printable_name (fndecl, 0);
669 VEC_iterate (char_p, flag_instrument_functions_exclude_functions,
673 if (strstr (name, s) != NULL)
678 if (VEC_length (char_p, flag_instrument_functions_exclude_files) > 0)
684 name = DECL_SOURCE_FILE (fndecl);
686 VEC_iterate (char_p, flag_instrument_functions_exclude_files, i, s);
689 if (strstr (name, s) != NULL)
697 /* Decode and handle the vector of command line options. LANG_MASK
698 contains has a single bit set representing the current
701 handle_options (unsigned int argc, const char **argv, unsigned int lang_mask)
705 for (i = 1; i < argc; i += n)
707 const char *opt = argv[i];
709 /* Interpret "-" or a non-switch as a file name. */
710 if (opt[0] != '-' || opt[1] == '\0')
712 if (main_input_filename == NULL)
714 main_input_filename = opt;
715 main_input_baselength
716 = base_of_path (main_input_filename, &main_input_basename);
718 add_input_filename (opt);
723 n = handle_option (argv + i, lang_mask);
728 error ("unrecognized command line option \"%s\"", opt);
733 /* Parse command line options and set default flag values. Do minimal
734 options processing. */
736 decode_options (unsigned int argc, const char **argv)
738 unsigned int i, lang_mask;
740 /* Perform language-specific options initialization. */
741 lang_mask = lang_hooks.init_options (argc, argv);
743 lang_hooks.initialize_diagnostics (global_dc);
745 /* Scan to see what optimization level has been specified. That will
746 determine the default value of many flags. */
747 for (i = 1; i < argc; i++)
749 if (!strcmp (argv[i], "-O"))
754 else if (argv[i][0] == '-' && argv[i][1] == 'O')
756 /* Handle -Os, -O2, -O3, -O69, ... */
757 const char *p = &argv[i][2];
759 if ((p[0] == 's') && (p[1] == 0))
763 /* Optimizing for size forces optimize to be 2. */
768 const int optimize_val = read_integral_parameter (p, p - 2, -1);
769 if (optimize_val != -1)
771 optimize = optimize_val;
780 flag_merge_constants = 0;
787 flag_delayed_branch = 1;
789 #ifdef CAN_DEBUG_WITHOUT_FP
790 flag_omit_frame_pointer = 1;
792 flag_guess_branch_prob = 1;
793 flag_cprop_registers = 1;
794 flag_if_conversion = 1;
795 flag_if_conversion2 = 1;
796 flag_ipa_pure_const = 1;
797 flag_ipa_reference = 1;
798 flag_split_wide_types = 1;
805 flag_tree_copyrename = 1;
807 flag_tree_copy_prop = 1;
809 flag_tree_salias = 1;
810 if (!no_unit_at_a_time_default)
811 flag_unit_at_a_time = 1;
815 /* Loop header copying usually increases size of the code. This used
816 not to be true, since quite often it is possible to verify that
817 the condition is satisfied in the first iteration and therefore
818 to eliminate it. Jump threading handles these cases now. */
825 flag_inline_small_functions = 1;
826 flag_thread_jumps = 1;
827 flag_crossjumping = 1;
828 flag_optimize_sibling_calls = 1;
829 flag_forward_propagate = 1;
830 flag_cse_follow_jumps = 1;
832 flag_expensive_optimizations = 1;
833 flag_rerun_cse_after_loop = 1;
834 flag_caller_saves = 1;
836 #ifdef INSN_SCHEDULING
837 flag_schedule_insns = 1;
838 flag_schedule_insns_after_reload = 1;
841 flag_strict_aliasing = 1;
842 flag_strict_overflow = 1;
843 flag_delete_null_pointer_checks = 1;
844 flag_reorder_blocks = 1;
845 flag_reorder_functions = 1;
846 flag_tree_store_ccp = 1;
851 /* PRE tends to generate bigger code. */
855 /* Allow more virtual operators to increase alias precision. */
856 set_param_value ("max-aliased-vops", 500);
861 flag_predictive_commoning = 1;
862 flag_inline_functions = 1;
863 flag_unswitch_loops = 1;
864 flag_gcse_after_reload = 1;
865 flag_tree_vectorize = 1;
867 /* Allow even more virtual operators. */
868 set_param_value ("max-aliased-vops", 1000);
869 set_param_value ("avg-aliased-vops", 3);
872 if (optimize < 2 || optimize_size)
879 /* Don't reorder blocks when optimizing for size because extra
880 jump insns may be created; also barrier may create extra padding.
882 More correctly we should have a block reordering mode that tried
883 to minimize the combined size of all the jumps. This would more
884 or less automatically remove extra jumps, but would also try to
885 use more short jumps instead of long jumps. */
886 flag_reorder_blocks = 0;
887 flag_reorder_blocks_and_partition = 0;
892 /* Inlining of functions reducing size is a good idea regardless
893 of them being declared inline. */
894 flag_inline_functions = 1;
896 /* We want to crossjump as much as possible. */
897 set_param_value ("min-crossjump-insns", 1);
900 /* Initialize whether `char' is signed. */
901 flag_signed_char = DEFAULT_SIGNED_CHAR;
902 /* Set this to a special "uninitialized" value. The actual default is set
903 after target options have been processed. */
904 flag_short_enums = 2;
906 /* Initialize target_flags before OPTIMIZATION_OPTIONS so the latter can
908 target_flags = targetm.default_target_flags;
910 /* Some tagets have ABI-specified unwind tables. */
911 flag_unwind_tables = targetm.unwind_tables_default;
913 #ifdef OPTIMIZATION_OPTIONS
914 /* Allow default optimizations to be specified on a per-machine basis. */
915 OPTIMIZATION_OPTIONS (optimize, optimize_size);
918 handle_options (argc, argv, lang_mask);
922 if (flag_pic && !flag_pie)
925 if (flag_no_inline == 2)
928 flag_really_no_inline = flag_no_inline;
930 /* Set flag_no_inline before the post_options () hook. The C front
931 ends use it to determine tree inlining defaults. FIXME: such
932 code should be lang-independent when all front ends use tree
933 inlining, in which case it, and this condition, should be moved
934 to the top of process_options() instead. */
937 /* Inlining does not work if not optimizing,
938 so force it not to be done. */
942 /* The c_decode_option function and decode_option hook set
943 this to `2' if -Wall is used, so we can avoid giving out
944 lots of errors for people who don't realize what -Wall does. */
945 if (warn_uninitialized == 1)
946 warning (OPT_Wuninitialized,
947 "-Wuninitialized is not supported without -O");
950 if (flag_really_no_inline == 2)
951 flag_really_no_inline = flag_no_inline;
953 /* Inlining of functions called just once will only work if we can look
954 at the complete translation unit. */
955 if (flag_inline_functions_called_once && !flag_unit_at_a_time)
957 flag_inline_functions_called_once = 0;
958 warning (OPT_Wdisabled_optimization,
959 "-funit-at-a-time is required for inlining of functions "
960 "that are only called once");
963 /* The optimization to partition hot and cold basic blocks into separate
964 sections of the .o and executable files does not work (currently)
965 with exception handling. This is because there is no support for
966 generating unwind info. If flag_exceptions is turned on we need to
967 turn off the partitioning optimization. */
969 if (flag_exceptions && flag_reorder_blocks_and_partition)
972 ("-freorder-blocks-and-partition does not work with exceptions");
973 flag_reorder_blocks_and_partition = 0;
974 flag_reorder_blocks = 1;
977 /* If user requested unwind info, then turn off the partitioning
980 if (flag_unwind_tables && ! targetm.unwind_tables_default
981 && flag_reorder_blocks_and_partition)
983 inform ("-freorder-blocks-and-partition does not support unwind info");
984 flag_reorder_blocks_and_partition = 0;
985 flag_reorder_blocks = 1;
988 /* If the target requested unwind info, then turn off the partitioning
989 optimization with a different message. Likewise, if the target does not
990 support named sections. */
992 if (flag_reorder_blocks_and_partition
993 && (!targetm.have_named_sections
994 || (flag_unwind_tables && targetm.unwind_tables_default)))
997 ("-freorder-blocks-and-partition does not work on this architecture");
998 flag_reorder_blocks_and_partition = 0;
999 flag_reorder_blocks = 1;
1003 #define LEFT_COLUMN 27
1005 /* Output ITEM, of length ITEM_WIDTH, in the left column,
1006 followed by word-wrapped HELP in a second column. */
1008 wrap_help (const char *help,
1010 unsigned int item_width,
1011 unsigned int columns)
1013 unsigned int col_width = LEFT_COLUMN;
1014 unsigned int remaining, room, len;
1016 remaining = strlen (help);
1020 room = columns - 3 - MAX (col_width, item_width);
1029 for (i = 0; help[i]; i++)
1031 if (i >= room && len != remaining)
1035 else if ((help[i] == '-' || help[i] == '/')
1036 && help[i + 1] != ' '
1037 && i > 0 && ISALPHA (help[i - 1]))
1042 printf( " %-*.*s %.*s\n", col_width, item_width, item, len, help);
1044 while (help[len] == ' ')
1052 /* Print help for a specific front-end, etc. */
1054 print_filtered_help (unsigned int include_flags,
1055 unsigned int exclude_flags,
1056 unsigned int any_flags,
1057 unsigned int columns)
1061 static char *printed = NULL;
1063 bool displayed = false;
1065 if (include_flags == CL_PARAMS)
1067 for (i = 0; i < LAST_PARAM; i++)
1069 const char *param = compiler_params[i].option;
1071 help = compiler_params[i].help;
1072 if (help == NULL || *help == '\0')
1074 if (exclude_flags & CL_UNDOCUMENTED)
1076 help = undocumented_msg;
1079 /* Get the translation. */
1082 wrap_help (help, param, strlen (param), columns);
1089 printed = xcalloc (1, cl_options_count);
1091 for (i = 0; i < cl_options_count; i++)
1093 static char new_help[128];
1094 const struct cl_option *option = cl_options + i;
1099 if (include_flags == 0
1100 || ((option->flags & include_flags) != include_flags))
1102 if ((option->flags & any_flags) == 0)
1106 /* Skip unwanted switches. */
1107 if ((option->flags & exclude_flags) != 0)
1111 /* Skip switches that have already been printed. */
1117 help = option->help;
1120 if (exclude_flags & CL_UNDOCUMENTED)
1122 help = undocumented_msg;
1125 /* Get the translation. */
1128 /* Find the gap between the name of the
1129 option and its descriptive text. */
1130 tab = strchr (help, '\t');
1139 opt = option->opt_text;
1143 /* With the -Q option enabled we change the descriptive text associated
1144 with an option to be an indication of its current setting. */
1147 if (len < (LEFT_COLUMN + 2))
1148 strcpy (new_help, "\t\t");
1150 strcpy (new_help, "\t");
1152 if (option->flag_var != NULL)
1154 if (option->flags & CL_JOINED)
1156 if (option->var_type == CLVC_STRING)
1158 if (* (const char **) option->flag_var != NULL)
1159 snprintf (new_help + strlen (new_help),
1160 sizeof (new_help) - strlen (new_help),
1161 * (const char **) option->flag_var);
1164 sprintf (new_help + strlen (new_help),
1165 "%#x", * (int *) option->flag_var);
1168 strcat (new_help, option_enabled (i)
1169 ? _("[enabled]") : _("[disabled]"));
1175 wrap_help (help, opt, len, columns);
1180 printf (_(" No options with the desired characteristics were found\n"));
1181 else if (! displayed)
1182 printf (_(" All options with the desired characteristics have already been displayed\n"));
1187 /* Display help for a specified type of option.
1188 The options must have ALL of the INCLUDE_FLAGS set
1189 ANY of the flags in the ANY_FLAGS set
1190 and NONE of the EXCLUDE_FLAGS set. */
1192 print_specific_help (unsigned int include_flags,
1193 unsigned int exclude_flags,
1194 unsigned int any_flags)
1196 unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
1197 const char * description = NULL;
1198 const char * descrip_extra = "";
1201 static unsigned int columns = 0;
1203 /* Sanity check: Make sure that we do not have more
1204 languages than we have bits available to enumerate them. */
1205 gcc_assert ((1U << cl_lang_count) < CL_MIN_OPTION_CLASS);
1207 /* If we have not done so already, obtain
1208 the desired maximum width of the output. */
1213 GET_ENVIRONMENT (p, "COLUMNS");
1216 int value = atoi (p);
1223 /* Use a reasonable default. */
1227 /* Decide upon the title for the options that we are going to display. */
1228 for (i = 0, flag = 1; flag <= CL_MAX_OPTION_CLASS; flag <<= 1, i ++)
1230 switch (flag & include_flags)
1236 description = _("The following options are target specific");
1239 description = _("The following options control compiler warning messages");
1241 case CL_OPTIMIZATION:
1242 description = _("The following options control optimizations");
1245 description = _("The following options are language-independent");
1248 description = _("The --param option recognizes the following as parameters");
1251 if (i >= cl_lang_count)
1253 if ((exclude_flags & ((1U << cl_lang_count) - 1)) != 0)
1255 description = _("The following options are specific to the language ");
1256 descrip_extra = lang_names [i];
1259 description = _("The following options are supported by the language ");
1260 descrip_extra = lang_names [i];
1265 if (description == NULL)
1269 if (include_flags == CL_UNDOCUMENTED)
1270 description = _("The following options are not documented");
1273 internal_error ("unrecognized include_flags 0x%x passed to print_specific_help",
1280 if (any_flags & all_langs_mask)
1281 description = _("The following options are language-related");
1283 description = _("The following options are language-independent");
1287 printf ("%s%s:\n", description, descrip_extra);
1288 print_filtered_help (include_flags, exclude_flags, any_flags, columns);
1291 /* Handle target- and language-independent options. Return zero to
1292 generate an "unknown option" message. Only options that need
1293 extra handling need to be listed here; if you simply want
1294 VALUE assigned to a variable, it happens automatically. */
1297 common_handle_option (size_t scode, const char *arg, int value,
1298 unsigned int lang_mask)
1300 enum opt_code code = (enum opt_code) scode;
1311 unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
1312 unsigned int undoc_mask;
1315 undoc_mask = extra_warnings ? 0 : CL_UNDOCUMENTED;
1316 /* First display any single language specific options. */
1317 for (i = 0; i < cl_lang_count; i++)
1319 (1U << i, (all_langs_mask & (~ (1U << i))) | undoc_mask, 0);
1320 /* Next display any multi language specific options. */
1321 print_specific_help (0, undoc_mask, all_langs_mask);
1322 /* Then display any remaining, non-language options. */
1323 for (i = CL_MIN_OPTION_CLASS; i <= CL_MAX_OPTION_CLASS; i <<= 1)
1324 print_specific_help (i, undoc_mask, 0);
1325 exit_after_options = true;
1329 case OPT_ftarget_help:
1330 case OPT__target_help:
1331 print_specific_help (CL_TARGET, CL_UNDOCUMENTED, 0);
1332 exit_after_options = true;
1334 /* Allow the target a chance to give the user some additional information. */
1335 if (targetm.target_help)
1336 targetm.target_help ();
1342 const char * a = arg;
1343 unsigned int include_flags = 0;
1344 /* Note - by default we include undocumented options when listing
1345 specific classes. If you only want to see documented options
1346 then add ",^undocumented" to the --help= option. e.g.:
1348 --help=target,^undocumented */
1349 unsigned int exclude_flags = 0;
1351 /* Walk along the argument string, parsing each word in turn.
1353 arg = [^]{word}[,{arg}]
1354 word = {optimizers|target|warnings|undocumented|
1355 params|common|<language>} */
1360 const char * string;
1365 { "optimizers", CL_OPTIMIZATION },
1366 { "target", CL_TARGET },
1367 { "warnings", CL_WARNING },
1368 { "undocumented", CL_UNDOCUMENTED },
1369 { "params", CL_PARAMS },
1370 { "joined", CL_JOINED },
1371 { "separate", CL_SEPARATE },
1372 { "common", CL_COMMON },
1375 unsigned int * pflags;
1383 pflags = & exclude_flags;
1386 pflags = & include_flags;
1388 comma = strchr (a, ',');
1394 for (i = 0; specifics[i].string != NULL; i++)
1395 if (strncasecmp (a, specifics[i].string, len) == 0)
1397 * pflags |= specifics[i].flag;
1401 if (specifics[i].string == NULL)
1403 /* Check to see if the string matches a language name. */
1404 for (i = 0; i < cl_lang_count; i++)
1405 if (strncasecmp (a, lang_names[i], len) == 0)
1407 * pflags |= 1U << i;
1411 if (i == cl_lang_count)
1413 "warning: unrecognized argument to --help= switch: %.*s\n",
1423 print_specific_help (include_flags, exclude_flags, 0);
1424 exit_after_options = true;
1429 print_version (stderr, "");
1430 exit_after_options = true;
1434 g_switch_value = value;
1435 g_switch_set = true;
1440 /* Currently handled in a prescan. */
1444 /* For backward compatibility, -W is the same as -Wextra. */
1449 enable_warning_as_error (arg, value, lang_mask);
1456 case OPT_Wlarger_than_:
1457 larger_than_size = value;
1458 warn_larger_than = value != -1;
1461 case OPT_Wstrict_aliasing:
1462 set_Wstrict_aliasing (value);
1465 case OPT_Wstrict_aliasing_:
1466 warn_strict_aliasing = value;
1469 case OPT_Wstrict_overflow:
1470 warn_strict_overflow = (value
1471 ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
1475 case OPT_Wstrict_overflow_:
1476 warn_strict_overflow = value;
1480 set_Wunused (value);
1485 aux_info_file_name = arg;
1486 flag_gen_aux_info = 1;
1490 aux_base_name = arg;
1493 case OPT_auxbase_strip:
1495 char *tmp = xstrdup (arg);
1496 strip_off_ending (tmp, strlen (tmp));
1498 aux_base_name = tmp;
1503 decode_d_option (arg);
1507 dump_base_name = arg;
1510 case OPT_falign_functions_:
1511 align_functions = value;
1514 case OPT_falign_jumps_:
1515 align_jumps = value;
1518 case OPT_falign_labels_:
1519 align_labels = value;
1522 case OPT_falign_loops_:
1523 align_loops = value;
1526 case OPT_fbranch_probabilities:
1527 flag_branch_probabilities_set = true;
1530 case OPT_fcall_used_:
1531 fix_register (arg, 0, 1);
1534 case OPT_fcall_saved_:
1535 fix_register (arg, 0, 0);
1539 dbg_cnt_process_opt (arg);
1542 case OPT_fdbg_cnt_list:
1543 dbg_cnt_list_all_counters ();
1546 case OPT_fdebug_prefix_map_:
1547 add_debug_prefix_map (arg);
1550 case OPT_fdiagnostics_show_location_:
1551 if (!strcmp (arg, "once"))
1552 diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
1553 else if (!strcmp (arg, "every-line"))
1554 diagnostic_prefixing_rule (global_dc)
1555 = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE;
1560 case OPT_fdiagnostics_show_option:
1561 global_dc->show_option_requested = true;
1565 if (!dump_switch_p (arg))
1569 case OPT_ffast_math:
1570 set_fast_math_flags (value);
1573 case OPT_funsafe_math_optimizations:
1574 set_unsafe_math_optimizations_flags (value);
1578 fix_register (arg, 1, 1);
1581 case OPT_finline_limit_:
1582 case OPT_finline_limit_eq:
1583 set_param_value ("max-inline-insns-single", value / 2);
1584 set_param_value ("max-inline-insns-auto", value / 2);
1587 case OPT_finstrument_functions_exclude_function_list_:
1588 add_instrument_functions_exclude_list
1589 (&flag_instrument_functions_exclude_functions, arg);
1592 case OPT_finstrument_functions_exclude_file_list_:
1593 add_instrument_functions_exclude_list
1594 (&flag_instrument_functions_exclude_files, arg);
1597 case OPT_fmessage_length_:
1598 pp_set_line_maximum_length (global_dc->printer, value);
1601 case OPT_fpack_struct_:
1602 if (value <= 0 || (value & (value - 1)) || value > 16)
1603 error ("structure alignment must be a small power of two, not %d", value);
1606 initial_max_fld_align = value;
1607 maximum_field_alignment = value * BITS_PER_UNIT;
1611 case OPT_fpeel_loops:
1612 flag_peel_loops_set = true;
1615 case OPT_fprofile_arcs:
1616 profile_arc_flag_set = true;
1619 case OPT_finline_functions:
1620 flag_inline_functions_set = true;
1623 case OPT_fprofile_use:
1624 if (!flag_branch_probabilities_set)
1625 flag_branch_probabilities = value;
1626 if (!flag_profile_values_set)
1627 flag_profile_values = value;
1628 if (!flag_unroll_loops_set)
1629 flag_unroll_loops = value;
1630 if (!flag_peel_loops_set)
1631 flag_peel_loops = value;
1632 if (!flag_tracer_set)
1633 flag_tracer = value;
1634 if (!flag_value_profile_transformations_set)
1635 flag_value_profile_transformations = value;
1636 if (!flag_inline_functions_set)
1637 flag_inline_functions = value;
1640 case OPT_fprofile_generate:
1641 if (!profile_arc_flag_set)
1642 profile_arc_flag = value;
1643 if (!flag_profile_values_set)
1644 flag_profile_values = value;
1645 if (!flag_value_profile_transformations_set)
1646 flag_value_profile_transformations = value;
1647 if (!flag_inline_functions_set)
1648 flag_inline_functions = value;
1651 case OPT_fprofile_values:
1652 flag_profile_values_set = true;
1655 case OPT_fvisibility_:
1657 if (!strcmp(arg, "default"))
1658 default_visibility = VISIBILITY_DEFAULT;
1659 else if (!strcmp(arg, "internal"))
1660 default_visibility = VISIBILITY_INTERNAL;
1661 else if (!strcmp(arg, "hidden"))
1662 default_visibility = VISIBILITY_HIDDEN;
1663 else if (!strcmp(arg, "protected"))
1664 default_visibility = VISIBILITY_PROTECTED;
1666 error ("unrecognized visibility value \"%s\"", arg);
1671 flag_value_profile_transformations_set = true;
1674 case OPT_frandom_seed:
1675 /* The real switch is -fno-random-seed. */
1678 set_random_seed (NULL);
1681 case OPT_frandom_seed_:
1682 set_random_seed (arg);
1685 case OPT_fsched_verbose_:
1686 #ifdef INSN_SCHEDULING
1687 fix_sched_param ("verbose", arg);
1693 case OPT_fsched_stalled_insns_:
1694 flag_sched_stalled_insns = value;
1695 if (flag_sched_stalled_insns == 0)
1696 flag_sched_stalled_insns = -1;
1699 case OPT_fsched_stalled_insns_dep_:
1700 flag_sched_stalled_insns_dep = value;
1703 case OPT_fstack_limit:
1704 /* The real switch is -fno-stack-limit. */
1707 stack_limit_rtx = NULL_RTX;
1710 case OPT_fstack_limit_register_:
1712 int reg = decode_reg_name (arg);
1714 error ("unrecognized register name \"%s\"", arg);
1716 stack_limit_rtx = gen_rtx_REG (Pmode, reg);
1720 case OPT_fstack_limit_symbol_:
1721 stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (arg));
1724 case OPT_ftree_vectorizer_verbose_:
1725 vect_set_verbosity_level (arg);
1728 case OPT_ftls_model_:
1729 if (!strcmp (arg, "global-dynamic"))
1730 flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
1731 else if (!strcmp (arg, "local-dynamic"))
1732 flag_tls_default = TLS_MODEL_LOCAL_DYNAMIC;
1733 else if (!strcmp (arg, "initial-exec"))
1734 flag_tls_default = TLS_MODEL_INITIAL_EXEC;
1735 else if (!strcmp (arg, "local-exec"))
1736 flag_tls_default = TLS_MODEL_LOCAL_EXEC;
1738 warning (0, "unknown tls-model \"%s\"", arg);
1742 flag_tracer_set = true;
1745 case OPT_funroll_loops:
1746 flag_unroll_loops_set = true;
1750 set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg);
1754 set_debug_level (SDB_DEBUG, false, arg);
1758 set_debug_level (DWARF2_DEBUG, false, arg);
1762 set_debug_level (NO_DEBUG, 2, arg);
1767 set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg);
1771 set_debug_level (VMS_DEBUG, false, arg);
1776 set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg);
1780 asm_file_name = arg;
1783 case OPT_pedantic_errors:
1784 flag_pedantic_errors = pedantic = 1;
1787 case OPT_floop_optimize:
1788 case OPT_frerun_loop_opt:
1789 case OPT_fstrength_reduce:
1790 case OPT_ftree_store_copy_prop:
1791 case OPT_fforce_addr:
1792 /* These are no-ops, preserved for backward compatibility. */
1796 /* If the flag was handled in a standard way, assume the lack of
1797 processing here is intentional. */
1798 gcc_assert (cl_options[scode].flag_var);
1805 /* Handle --param NAME=VALUE. */
1807 handle_param (const char *carg)
1812 arg = xstrdup (carg);
1813 equal = strchr (arg, '=');
1815 error ("%s: --param arguments should be of the form NAME=VALUE", arg);
1818 value = integral_argument (equal + 1);
1820 error ("invalid --param value %qs", equal + 1);
1824 set_param_value (arg, value);
1831 /* Handle -W and -Wextra. */
1833 set_Wextra (int setting)
1835 extra_warnings = setting;
1836 warn_unused_parameter = (setting && maybe_warn_unused_parameter);
1838 /* We save the value of warn_uninitialized, since if they put
1839 -Wuninitialized on the command line, we need to generate a
1840 warning about not using it without also specifying -O. */
1842 warn_uninitialized = 0;
1843 else if (warn_uninitialized != 1)
1844 warn_uninitialized = 2;
1847 /* Initialize unused warning flags. */
1849 set_Wunused (int setting)
1851 warn_unused_function = setting;
1852 warn_unused_label = setting;
1853 /* Unused function parameter warnings are reported when either
1854 ``-Wextra -Wunused'' or ``-Wunused-parameter'' is specified.
1855 Thus, if -Wextra has already been seen, set warn_unused_parameter;
1856 otherwise set maybe_warn_extra_parameter, which will be picked up
1858 maybe_warn_unused_parameter = setting;
1859 warn_unused_parameter = (setting && extra_warnings);
1860 warn_unused_variable = setting;
1861 warn_unused_value = setting;
1864 /* Used to set the level of strict aliasing warnings,
1865 when no level is specified (i.e., when -Wstrict-aliasing, and not
1866 -Wstrict-aliasing=level was given).
1867 ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
1868 and 0 otherwise. After calling this function, wstrict_aliasing will be
1869 set to the default value of -Wstrict_aliasing=level, currently 3. */
1871 set_Wstrict_aliasing (int onoff)
1873 gcc_assert (onoff == 0 || onoff == 1);
1875 warn_strict_aliasing = 3;
1878 /* The following routines are useful in setting all the flags that
1879 -ffast-math and -fno-fast-math imply. */
1881 set_fast_math_flags (int set)
1883 flag_unsafe_math_optimizations = set;
1884 set_unsafe_math_optimizations_flags (set);
1885 flag_finite_math_only = set;
1886 flag_errno_math = !set;
1889 flag_signaling_nans = 0;
1890 flag_rounding_math = 0;
1891 flag_cx_limited_range = 1;
1895 /* When -funsafe-math-optimizations is set the following
1896 flags are set as well. */
1898 set_unsafe_math_optimizations_flags (int set)
1900 flag_trapping_math = !set;
1901 flag_signed_zeros = !set;
1902 flag_associative_math = set;
1903 flag_reciprocal_math = set;
1906 /* Return true iff flags are set as if -ffast-math. */
1908 fast_math_flags_set_p (void)
1910 return (!flag_trapping_math
1911 && flag_unsafe_math_optimizations
1912 && flag_finite_math_only
1913 && !flag_signed_zeros
1914 && !flag_errno_math);
1917 /* Handle a debug output -g switch. EXTENDED is true or false to support
1918 extended output (2 is special and means "-ggdb" was given). */
1920 set_debug_level (enum debug_info_type type, int extended, const char *arg)
1922 static bool type_explicit;
1924 use_gnu_debug_info_extensions = extended;
1926 if (type == NO_DEBUG)
1928 if (write_symbols == NO_DEBUG)
1930 write_symbols = PREFERRED_DEBUGGING_TYPE;
1934 #ifdef DWARF2_DEBUGGING_INFO
1935 write_symbols = DWARF2_DEBUG;
1936 #elif defined DBX_DEBUGGING_INFO
1937 write_symbols = DBX_DEBUG;
1941 if (write_symbols == NO_DEBUG)
1942 warning (0, "target system does not support debug output");
1947 /* Does it conflict with an already selected type? */
1948 if (type_explicit && write_symbols != NO_DEBUG && type != write_symbols)
1949 error ("debug format \"%s\" conflicts with prior selection",
1950 debug_type_names[type]);
1951 write_symbols = type;
1952 type_explicit = true;
1955 /* A debug flag without a level defaults to level 2. */
1958 if (!debug_info_level)
1959 debug_info_level = 2;
1963 debug_info_level = integral_argument (arg);
1964 if (debug_info_level == (unsigned int) -1)
1965 error ("unrecognised debug output level \"%s\"", arg);
1966 else if (debug_info_level > 3)
1967 error ("debug output level %s is too high", arg);
1971 /* Return 1 if OPTION is enabled, 0 if it is disabled, or -1 if it isn't
1972 a simple on-off switch. */
1975 option_enabled (int opt_idx)
1977 const struct cl_option *option = &(cl_options[opt_idx]);
1979 if (option->flag_var)
1980 switch (option->var_type)
1983 return *(int *) option->flag_var != 0;
1986 return *(int *) option->flag_var == option->var_value;
1988 case CLVC_BIT_CLEAR:
1989 return (*(int *) option->flag_var & option->var_value) == 0;
1992 return (*(int *) option->flag_var & option->var_value) != 0;
2000 /* Fill STATE with the current state of option OPTION. Return true if
2001 there is some state to store. */
2004 get_option_state (int option, struct cl_option_state *state)
2006 if (cl_options[option].flag_var == 0)
2009 switch (cl_options[option].var_type)
2013 state->data = cl_options[option].flag_var;
2014 state->size = sizeof (int);
2017 case CLVC_BIT_CLEAR:
2019 state->ch = option_enabled (option);
2020 state->data = &state->ch;
2025 state->data = *(const char **) cl_options[option].flag_var;
2026 if (state->data == 0)
2028 state->size = strlen (state->data) + 1;
2034 /* Enable a warning option as an error. This is used by -Werror= and
2035 also by legacy Werror-implicit-function-declaration. */
2038 enable_warning_as_error (const char *arg, int value, unsigned int lang_mask)
2043 new_option = XNEWVEC (char, strlen (arg) + 2);
2044 new_option[0] = 'W';
2045 strcpy (new_option + 1, arg);
2046 option_index = find_opt (new_option, lang_mask);
2047 if (option_index == N_OPTS)
2049 error ("-Werror=%s: No option -%s", arg, new_option);
2053 int kind = value ? DK_ERROR : DK_WARNING;
2054 diagnostic_classify_diagnostic (global_dc, option_index, kind);
2056 /* -Werror=foo implies -Wfoo. */
2057 if (cl_options[option_index].var_type == CLVC_BOOLEAN
2058 && cl_options[option_index].flag_var
2059 && kind == DK_ERROR)
2060 *(int *) cl_options[option_index].flag_var = 1;