1 /* Command line option handling.
2 Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
3 Free Software Foundation, Inc.
4 Contributed by Neil Booth.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
25 #include "coretypes.h"
32 #include "langhooks.h"
38 #include "diagnostic.h"
39 #include "opts-diagnostic.h"
40 #include "tm_p.h" /* For OPTIMIZATION_OPTIONS. */
41 #include "insn-attr.h" /* For INSN_SCHEDULING. */
43 #include "tree-pass.h"
48 #include "lto-streamer.h"
50 /* Value of the -G xx switch, and whether it was passed or not. */
51 unsigned HOST_WIDE_INT g_switch_value
;
54 /* Same for selective scheduling. */
55 bool sel_sched_switch_set
;
57 /* True if we should exit after parsing options. */
58 bool exit_after_options
;
60 /* True to warn about any objects definitions whose size is larger
61 than N bytes. Also want about function definitions whose returned
62 values are larger than N bytes, where N is `larger_than_size'. */
63 bool warn_larger_than
;
64 HOST_WIDE_INT larger_than_size
;
66 /* True to warn about any function whose frame size is larger
68 bool warn_frame_larger_than
;
69 HOST_WIDE_INT frame_larger_than_size
;
71 /* Type(s) of debugging information we are producing (if any). See
72 flags.h for the definitions of the different possible types of
73 debugging information. */
74 enum debug_info_type write_symbols
= NO_DEBUG
;
76 /* Level of debugging information we are producing. See flags.h for
77 the definitions of the different possible levels. */
78 enum debug_info_level debug_info_level
= DINFO_LEVEL_NONE
;
80 /* A major contribution to object and executable size is debug
81 information size. A major contribution to debug information size
82 is struct descriptions replicated in several object files. The
83 following flags attempt to reduce this information. The basic
84 idea is to not emit struct debugging information in the current
85 compilation unit when that information will be generated by
86 another compilation unit.
88 Debug information for a struct defined in the current source
89 file should be generated in the object file. Likewise the
90 debug information for a struct defined in a header should be
91 generated in the object file of the corresponding source file.
92 Both of these case are handled when the base name of the file of
93 the struct definition matches the base name of the source file
94 of the current compilation unit. This matching emits minimal
95 struct debugging information.
97 The base file name matching rule above will fail to emit debug
98 information for structs defined in system headers. So a second
99 category of files includes system headers in addition to files
102 The remaining types of files are library headers and application
103 headers. We cannot currently distinguish these two types. */
105 enum debug_struct_file
107 DINFO_STRUCT_FILE_NONE
, /* Debug no structs. */
108 DINFO_STRUCT_FILE_BASE
, /* Debug structs defined in files with the
109 same base name as the compilation unit. */
110 DINFO_STRUCT_FILE_SYS
, /* Also debug structs defined in system
112 DINFO_STRUCT_FILE_ANY
/* Debug structs defined in all files. */
115 /* Generic structs (e.g. templates not explicitly specialized)
116 may not have a compilation unit associated with them, and so
117 may need to be treated differently from ordinary structs.
119 Structs only handled by reference (indirectly), will also usually
120 not need as much debugging information. */
122 static enum debug_struct_file debug_struct_ordinary
[DINFO_USAGE_NUM_ENUMS
]
123 = { DINFO_STRUCT_FILE_ANY
, DINFO_STRUCT_FILE_ANY
, DINFO_STRUCT_FILE_ANY
};
124 static enum debug_struct_file debug_struct_generic
[DINFO_USAGE_NUM_ENUMS
]
125 = { DINFO_STRUCT_FILE_ANY
, DINFO_STRUCT_FILE_ANY
, DINFO_STRUCT_FILE_ANY
};
127 /* Parse the -femit-struct-debug-detailed option value
128 and set the flag variables. */
130 #define MATCH( prefix, string ) \
131 ((strncmp (prefix, string, sizeof prefix - 1) == 0) \
132 ? ((string += sizeof prefix - 1), 1) : 0)
135 set_struct_debug_option (const char *spec
)
137 /* various labels for comparison */
138 static char dfn_lbl
[] = "dfn:", dir_lbl
[] = "dir:", ind_lbl
[] = "ind:";
139 static char ord_lbl
[] = "ord:", gen_lbl
[] = "gen:";
140 static char none_lbl
[] = "none", any_lbl
[] = "any";
141 static char base_lbl
[] = "base", sys_lbl
[] = "sys";
143 enum debug_struct_file files
= DINFO_STRUCT_FILE_ANY
;
144 /* Default is to apply to as much as possible. */
145 enum debug_info_usage usage
= DINFO_USAGE_NUM_ENUMS
;
146 int ord
= 1, gen
= 1;
149 if (MATCH (dfn_lbl
, spec
))
150 usage
= DINFO_USAGE_DFN
;
151 else if (MATCH (dir_lbl
, spec
))
152 usage
= DINFO_USAGE_DIR_USE
;
153 else if (MATCH (ind_lbl
, spec
))
154 usage
= DINFO_USAGE_IND_USE
;
156 /* Generics or not? */
157 if (MATCH (ord_lbl
, spec
))
159 else if (MATCH (gen_lbl
, spec
))
162 /* What allowable environment? */
163 if (MATCH (none_lbl
, spec
))
164 files
= DINFO_STRUCT_FILE_NONE
;
165 else if (MATCH (any_lbl
, spec
))
166 files
= DINFO_STRUCT_FILE_ANY
;
167 else if (MATCH (sys_lbl
, spec
))
168 files
= DINFO_STRUCT_FILE_SYS
;
169 else if (MATCH (base_lbl
, spec
))
170 files
= DINFO_STRUCT_FILE_BASE
;
172 error ("argument %qs to %<-femit-struct-debug-detailed%> not recognized",
175 /* Effect the specification. */
176 if (usage
== DINFO_USAGE_NUM_ENUMS
)
180 debug_struct_ordinary
[DINFO_USAGE_DFN
] = files
;
181 debug_struct_ordinary
[DINFO_USAGE_DIR_USE
] = files
;
182 debug_struct_ordinary
[DINFO_USAGE_IND_USE
] = files
;
186 debug_struct_generic
[DINFO_USAGE_DFN
] = files
;
187 debug_struct_generic
[DINFO_USAGE_DIR_USE
] = files
;
188 debug_struct_generic
[DINFO_USAGE_IND_USE
] = files
;
194 debug_struct_ordinary
[usage
] = files
;
196 debug_struct_generic
[usage
] = files
;
200 set_struct_debug_option (spec
+1);
203 /* No more -femit-struct-debug-detailed specifications.
206 error ("argument %qs to %<-femit-struct-debug-detailed%> unknown",
208 if (debug_struct_ordinary
[DINFO_USAGE_DIR_USE
]
209 < debug_struct_ordinary
[DINFO_USAGE_IND_USE
]
210 || debug_struct_generic
[DINFO_USAGE_DIR_USE
]
211 < debug_struct_generic
[DINFO_USAGE_IND_USE
])
212 error ("%<-femit-struct-debug-detailed=dir:...%> must allow at least"
213 " as much as %<-femit-struct-debug-detailed=ind:...%>");
217 /* Find the base name of a path, stripping off both directories and
218 a single final extension. */
220 base_of_path (const char *path
, const char **base_out
)
222 const char *base
= path
;
224 const char *p
= path
;
228 if (IS_DIR_SEPARATOR(c
))
243 /* Match the base name of a file to the base name of a compilation unit. */
245 static const char *main_input_basename
;
246 static int main_input_baselength
;
249 matches_main_base (const char *path
)
251 /* Cache the last query. */
252 static const char *last_path
= NULL
;
253 static int last_match
= 0;
254 if (path
!= last_path
)
257 int length
= base_of_path (path
, &base
);
259 last_match
= (length
== main_input_baselength
260 && memcmp (base
, main_input_basename
, length
) == 0);
265 #ifdef DEBUG_DEBUG_STRUCT
268 dump_struct_debug (tree type
, enum debug_info_usage usage
,
269 enum debug_struct_file criterion
, int generic
,
270 int matches
, int result
)
272 /* Find the type name. */
273 tree type_decl
= TYPE_STUB_DECL (type
);
275 const char *name
= 0;
276 if (TREE_CODE (t
) == TYPE_DECL
)
279 name
= IDENTIFIER_POINTER (t
);
281 fprintf (stderr
, " struct %d %s %s %s %s %d %p %s\n",
283 DECL_IN_SYSTEM_HEADER (type_decl
) ? "sys" : "usr",
284 matches
? "bas" : "hdr",
285 generic
? "gen" : "ord",
286 usage
== DINFO_USAGE_DFN
? ";" :
287 usage
== DINFO_USAGE_DIR_USE
? "." : "*",
289 (void*) type_decl
, name
);
292 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
293 dump_struct_debug (type, usage, criterion, generic, matches, result)
297 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
304 should_emit_struct_debug (tree type
, enum debug_info_usage usage
)
306 enum debug_struct_file criterion
;
308 bool generic
= lang_hooks
.types
.generic_p (type
);
311 criterion
= debug_struct_generic
[usage
];
313 criterion
= debug_struct_ordinary
[usage
];
315 if (criterion
== DINFO_STRUCT_FILE_NONE
)
316 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, false);
317 if (criterion
== DINFO_STRUCT_FILE_ANY
)
318 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, true);
320 type_decl
= TYPE_STUB_DECL (type
);
322 if (criterion
== DINFO_STRUCT_FILE_SYS
&& DECL_IN_SYSTEM_HEADER (type_decl
))
323 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, true);
325 if (matches_main_base (DECL_SOURCE_FILE (type_decl
)))
326 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, true, true);
327 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, false);
330 /* Nonzero means use GNU-only extensions in the generated symbolic
331 debugging information. Currently, this only has an effect when
332 write_symbols is set to DBX_DEBUG, XCOFF_DEBUG, or DWARF_DEBUG. */
333 bool use_gnu_debug_info_extensions
;
335 /* The default visibility for all symbols (unless overridden) */
336 enum symbol_visibility default_visibility
= VISIBILITY_DEFAULT
;
338 /* Global visibility options. */
339 struct visibility_flags visibility_options
;
341 /* What to print when a switch has no documentation. */
342 static const char undocumented_msg
[] = N_("This switch lacks documentation");
344 /* Used for bookkeeping on whether user set these flags so
345 -fprofile-use/-fprofile-generate does not use them. */
346 static bool profile_arc_flag_set
, flag_profile_values_set
;
347 static bool flag_unroll_loops_set
, flag_tracer_set
;
348 static bool flag_value_profile_transformations_set
;
349 static bool flag_peel_loops_set
, flag_branch_probabilities_set
;
350 static bool flag_inline_functions_set
, flag_ipa_cp_set
, flag_ipa_cp_clone_set
;
351 static bool flag_predictive_commoning_set
, flag_unswitch_loops_set
, flag_gcse_after_reload_set
;
353 /* Functions excluded from profiling. */
355 typedef char *char_p
; /* For DEF_VEC_P. */
357 DEF_VEC_ALLOC_P(char_p
,heap
);
359 static VEC(char_p
,heap
) *flag_instrument_functions_exclude_functions
;
360 static VEC(char_p
,heap
) *flag_instrument_functions_exclude_files
;
362 typedef const char *const_char_p
; /* For DEF_VEC_P. */
363 DEF_VEC_P(const_char_p
);
364 DEF_VEC_ALLOC_P(const_char_p
,heap
);
366 static VEC(const_char_p
,heap
) *ignored_options
;
368 /* Language specific warning pass for unused results. */
369 bool flag_warn_unused_result
= false;
371 /* Input file names. */
372 const char **in_fnames
;
373 unsigned num_in_fnames
;
375 static bool common_handle_option (const struct cl_decoded_option
*decoded
,
376 unsigned int lang_mask
, int kind
,
377 const struct cl_option_handlers
*handlers
);
378 static void handle_param (const char *);
379 static char *write_langs (unsigned int lang_mask
);
380 static void complain_wrong_lang (const struct cl_decoded_option
*,
381 unsigned int lang_mask
);
382 static void set_debug_level (enum debug_info_type type
, int extended
,
385 /* Return a malloced slash-separated list of languages in MASK. */
387 write_langs (unsigned int mask
)
389 unsigned int n
= 0, len
= 0;
390 const char *lang_name
;
393 for (n
= 0; (lang_name
= lang_names
[n
]) != 0; n
++)
394 if (mask
& (1U << n
))
395 len
+= strlen (lang_name
) + 1;
397 result
= XNEWVEC (char, len
);
399 for (n
= 0; (lang_name
= lang_names
[n
]) != 0; n
++)
400 if (mask
& (1U << n
))
404 strcpy (result
+ len
, lang_name
);
405 len
+= strlen (lang_name
);
413 /* Complain that switch DECODED does not apply to this front end (mask
416 complain_wrong_lang (const struct cl_decoded_option
*decoded
,
417 unsigned int lang_mask
)
419 const struct cl_option
*option
= &cl_options
[decoded
->opt_index
];
420 const char *text
= decoded
->orig_option_with_args_text
;
421 char *ok_langs
= NULL
, *bad_lang
= NULL
;
422 unsigned int opt_flags
= option
->flags
;
424 if (!lang_hooks
.complain_wrong_lang_p (option
))
427 opt_flags
&= ((1U << cl_lang_count
) - 1) | CL_DRIVER
;
428 if (opt_flags
!= CL_DRIVER
)
429 ok_langs
= write_langs (opt_flags
);
430 if (lang_mask
!= CL_DRIVER
)
431 bad_lang
= write_langs (lang_mask
);
433 if (opt_flags
== CL_DRIVER
)
434 error ("command line option %qs is valid for the driver but not for %s",
436 else if (lang_mask
== CL_DRIVER
)
439 /* Eventually this should become a hard error IMO. */
440 warning (0, "command line option %qs is valid for %s but not for %s",
441 text
, ok_langs
, bad_lang
);
447 /* Buffer the unknown option described by the string OPT. Currently,
448 we only complain about unknown -Wno-* options if they may have
449 prevented a diagnostic. Otherwise, we just ignore them.
450 Note that if we do complain, it is only as a warning, not an error;
451 passing the compiler an unrecognised -Wno-* option should never
452 change whether the compilation succeeds or fails. */
454 static void postpone_unknown_option_warning(const char *opt
)
456 VEC_safe_push (const_char_p
, heap
, ignored_options
, opt
);
459 /* Produce a warning for each option previously buffered. */
461 void print_ignored_options (void)
463 location_t saved_loc
= input_location
;
467 while (!VEC_empty (const_char_p
, ignored_options
))
470 opt
= VEC_pop (const_char_p
, ignored_options
);
471 warning (0, "unrecognized command line option \"%s\"", opt
);
474 input_location
= saved_loc
;
477 /* Handle an unknown option DECODED, returning true if an error should be
481 unknown_option_callback (const struct cl_decoded_option
*decoded
)
483 const char *opt
= decoded
->arg
;
485 if (opt
[1] == 'W' && opt
[2] == 'n' && opt
[3] == 'o' && opt
[4] == '-'
486 && !(decoded
->errors
& CL_ERR_NEGATIVE
))
488 /* We don't generate warnings for unknown -Wno-* options unless
489 we issue diagnostics. */
490 postpone_unknown_option_warning (opt
);
497 /* Note that an option DECODED has been successfully handled with a
498 handler for mask MASK. */
501 post_handling_callback (const struct cl_decoded_option
*decoded ATTRIBUTE_UNUSED
,
502 unsigned int mask ATTRIBUTE_UNUSED
)
505 lto_register_user_option (decoded
->opt_index
, decoded
->arg
,
506 decoded
->value
, mask
);
510 /* Handle a front-end option; arguments and return value as for
514 lang_handle_option (const struct cl_decoded_option
*decoded
,
515 unsigned int lang_mask ATTRIBUTE_UNUSED
, int kind
,
516 const struct cl_option_handlers
*handlers
)
518 gcc_assert (decoded
->canonical_option_num_elements
<= 2);
519 return lang_hooks
.handle_option (decoded
->opt_index
, decoded
->arg
,
520 decoded
->value
, kind
, handlers
);
523 /* Handle a back-end option; arguments and return value as for
527 target_handle_option (const struct cl_decoded_option
*decoded
,
528 unsigned int lang_mask ATTRIBUTE_UNUSED
, int kind
,
529 const struct cl_option_handlers
*handlers ATTRIBUTE_UNUSED
)
531 gcc_assert (decoded
->canonical_option_num_elements
<= 2);
532 gcc_assert (kind
== DK_UNSPECIFIED
);
533 return targetm
.handle_option (decoded
->opt_index
, decoded
->arg
,
537 /* Handle FILENAME from the command line. */
539 add_input_filename (const char *filename
)
542 in_fnames
= XRESIZEVEC (const char *, in_fnames
, num_in_fnames
);
543 in_fnames
[num_in_fnames
- 1] = filename
;
546 /* Add comma-separated strings to a char_p vector. */
549 add_comma_separated_to_vector (VEC(char_p
,heap
) **pvec
, const char* arg
)
556 /* We never free this string. */
569 VEC_safe_push (char_p
, heap
, *pvec
, token_start
);
572 if (*r
== '\\' && r
[1] == ',')
580 if (*token_start
!= '\0')
581 VEC_safe_push (char_p
, heap
, *pvec
, token_start
);
584 /* Return whether we should exclude FNDECL from instrumentation. */
587 flag_instrument_functions_exclude_p (tree fndecl
)
589 if (VEC_length (char_p
, flag_instrument_functions_exclude_functions
) > 0)
595 name
= lang_hooks
.decl_printable_name (fndecl
, 0);
596 FOR_EACH_VEC_ELT (char_p
, flag_instrument_functions_exclude_functions
,
598 if (strstr (name
, s
) != NULL
)
602 if (VEC_length (char_p
, flag_instrument_functions_exclude_files
) > 0)
608 name
= DECL_SOURCE_FILE (fndecl
);
609 FOR_EACH_VEC_ELT (char_p
, flag_instrument_functions_exclude_files
, i
, s
)
610 if (strstr (name
, s
) != NULL
)
618 /* Handle the vector of command line options. LANG_MASK
619 contains has a single bit set representing the current
620 language. HANDLERS describes what functions to call for the options. */
622 read_cmdline_options (struct cl_decoded_option
*decoded_options
,
623 unsigned int decoded_options_count
,
624 unsigned int lang_mask
,
625 const struct cl_option_handlers
*handlers
)
629 for (i
= 1; i
< decoded_options_count
; i
++)
631 if (decoded_options
[i
].opt_index
== OPT_SPECIAL_input_file
)
633 if (main_input_filename
== NULL
)
635 main_input_filename
= decoded_options
[i
].arg
;
636 main_input_baselength
637 = base_of_path (main_input_filename
, &main_input_basename
);
639 add_input_filename (decoded_options
[i
].arg
);
643 read_cmdline_option (decoded_options
+ i
, lang_mask
, handlers
);
647 /* Parse command line options and set default flag values. Do minimal
648 options processing. The decoded options are placed in *DECODED_OPTIONS
649 and *DECODED_OPTIONS_COUNT. */
651 decode_options (unsigned int argc
, const char **argv
,
652 struct cl_decoded_option
**decoded_options
,
653 unsigned int *decoded_options_count
)
655 static bool first_time_p
= true;
656 static int initial_min_crossjump_insns
;
657 static int initial_max_fields_for_field_sensitive
;
658 static int initial_loop_invariant_max_bbs_in_loop
;
659 static unsigned int initial_lang_mask
;
660 struct cl_option_handlers handlers
;
662 unsigned int i
, lang_mask
;
671 /* Perform language-specific options initialization. */
672 initial_lang_mask
= lang_mask
= lang_hooks
.option_lang_mask ();
674 lang_hooks
.initialize_diagnostics (global_dc
);
676 /* Save initial values of parameters we reset. */
677 initial_min_crossjump_insns
678 = compiler_params
[PARAM_MIN_CROSSJUMP_INSNS
].value
;
679 initial_max_fields_for_field_sensitive
680 = compiler_params
[PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE
].value
;
681 initial_loop_invariant_max_bbs_in_loop
682 = compiler_params
[PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP
].value
;
685 lang_mask
= initial_lang_mask
;
687 decode_cmdline_options_to_array (argc
, argv
,
688 lang_mask
| CL_COMMON
| CL_TARGET
,
689 decoded_options
, decoded_options_count
);
691 /* Perform language-specific options initialization. */
692 lang_hooks
.init_options (*decoded_options_count
, *decoded_options
);
694 handlers
.unknown_option_callback
= unknown_option_callback
;
695 handlers
.wrong_lang_callback
= complain_wrong_lang
;
696 handlers
.post_handling_callback
= post_handling_callback
;
697 handlers
.num_handlers
= 3;
698 handlers
.handlers
[0].handler
= lang_handle_option
;
699 handlers
.handlers
[0].mask
= lang_mask
;
700 handlers
.handlers
[1].handler
= common_handle_option
;
701 handlers
.handlers
[1].mask
= CL_COMMON
;
702 handlers
.handlers
[2].handler
= target_handle_option
;
703 handlers
.handlers
[2].mask
= CL_TARGET
;
705 /* Scan to see what optimization level has been specified. That will
706 determine the default value of many flags. */
707 for (i
= 1; i
< *decoded_options_count
; i
++)
709 struct cl_decoded_option
*opt
= &(*decoded_options
)[i
];
710 switch (opt
->opt_index
)
713 if (*opt
->arg
== '\0')
721 const int optimize_val
= integral_argument (opt
->arg
);
722 if (optimize_val
== -1)
723 error ("argument to %qs should be a non-negative integer",
727 optimize
= optimize_val
;
728 if ((unsigned int) optimize
> 255)
739 /* Optimizing for size forces optimize to be 2. */
745 /* -Ofast only adds flags to -O3. */
752 /* Ignore other options in this prescan. */
757 /* Use priority coloring if cover classes is not defined for the
759 if (targetm
.ira_cover_classes
== NULL
)
760 flag_ira_algorithm
= IRA_ALGORITHM_PRIORITY
;
762 /* -O1 optimizations. */
763 opt1
= (optimize
>= 1);
764 flag_defer_pop
= opt1
;
766 flag_delayed_branch
= opt1
;
768 #ifdef CAN_DEBUG_WITHOUT_FP
769 flag_omit_frame_pointer
= opt1
;
771 flag_guess_branch_prob
= opt1
;
772 flag_cprop_registers
= opt1
;
773 flag_forward_propagate
= opt1
;
774 flag_if_conversion
= opt1
;
775 flag_if_conversion2
= opt1
;
776 flag_ipa_pure_const
= opt1
;
777 flag_ipa_reference
= opt1
;
778 flag_ipa_profile
= opt1
;
779 flag_merge_constants
= opt1
;
780 flag_split_wide_types
= opt1
;
781 flag_tree_ccp
= opt1
;
782 flag_tree_bit_ccp
= opt1
;
783 flag_tree_dce
= opt1
;
784 flag_tree_dom
= opt1
;
785 flag_tree_dse
= opt1
;
786 flag_tree_ter
= opt1
;
787 flag_tree_sra
= opt1
;
788 flag_tree_copyrename
= opt1
;
789 flag_tree_fre
= opt1
;
790 flag_tree_copy_prop
= opt1
;
791 flag_tree_sink
= opt1
;
794 /* -O2 optimizations. */
795 opt2
= (optimize
>= 2);
796 flag_inline_small_functions
= opt2
;
797 flag_indirect_inlining
= opt2
;
798 flag_partial_inlining
= opt2
;
799 flag_thread_jumps
= opt2
;
800 flag_crossjumping
= opt2
;
801 flag_optimize_sibling_calls
= opt2
;
802 flag_cse_follow_jumps
= opt2
;
804 flag_expensive_optimizations
= opt2
;
805 flag_rerun_cse_after_loop
= opt2
;
806 flag_caller_saves
= opt2
;
807 flag_peephole2
= opt2
;
808 #ifdef INSN_SCHEDULING
809 /* Only run the pre-regalloc scheduling pass if optimizing for speed. */
810 flag_schedule_insns
= opt2
&& ! optimize_size
;
811 flag_schedule_insns_after_reload
= opt2
;
814 flag_strict_aliasing
= opt2
;
815 flag_strict_overflow
= opt2
;
816 flag_reorder_blocks
= opt2
;
817 flag_reorder_functions
= opt2
;
818 flag_tree_vrp
= opt2
;
819 flag_tree_builtin_call_dce
= opt2
;
820 flag_tree_pre
= opt2
;
821 flag_tree_switch_conversion
= opt2
;
825 /* Track fields in field-sensitive alias analysis. */
826 set_param_value ("max-fields-for-field-sensitive",
827 (opt2
) ? 100 : initial_max_fields_for_field_sensitive
);
829 /* For -O1 only do loop invariant motion for very small loops. */
830 set_param_value ("loop-invariant-max-bbs-in-loop",
831 (opt2
) ? initial_loop_invariant_max_bbs_in_loop
: 1000);
833 /* -O3 optimizations. */
834 opt3
= (optimize
>= 3);
835 flag_tree_loop_distribute_patterns
= opt3
;
836 flag_predictive_commoning
= opt3
;
837 flag_inline_functions
= opt3
;
838 flag_unswitch_loops
= opt3
;
839 flag_gcse_after_reload
= opt3
;
840 flag_tree_vectorize
= opt3
;
841 flag_ipa_cp_clone
= opt3
;
842 if (flag_ipa_cp_clone
)
845 /* Just -O1/-O0 optimizations. */
846 opt1_max
= (optimize
<= 1);
847 align_loops
= opt1_max
;
848 align_jumps
= opt1_max
;
849 align_labels
= opt1_max
;
850 align_functions
= opt1_max
;
854 /* Inlining of functions reducing size is a good idea regardless of them
855 being declared inline. */
856 flag_inline_functions
= 1;
858 /* Basic optimization options. */
863 /* We want to crossjump as much as possible. */
864 set_param_value ("min-crossjump-insns", 1);
867 set_param_value ("min-crossjump-insns", initial_min_crossjump_insns
);
869 /* -Ofast adds optimizations to -O3. */
872 /* Which is -ffast-math for now. */
873 set_fast_math_flags (1);
874 /* Allow targets to enable extra options with -Ofast
875 before general options processing so disabling them
876 again afterwards works. */
877 targetm
.handle_ofast ();
880 /* Enable -Werror=coverage-mismatch by default */
881 enable_warning_as_error ("coverage-mismatch", 1, lang_mask
, &handlers
);
885 /* Initialize whether `char' is signed. */
886 flag_signed_char
= DEFAULT_SIGNED_CHAR
;
887 /* Set this to a special "uninitialized" value. The actual default is
888 set after target options have been processed. */
889 flag_short_enums
= 2;
891 /* Initialize target_flags before OPTIMIZATION_OPTIONS so the latter can
893 target_flags
= targetm
.default_target_flags
;
895 /* Some targets have ABI-specified unwind tables. */
896 flag_unwind_tables
= targetm
.unwind_tables_default
;
900 /* Clear any options currently held for LTO. */
901 lto_clear_user_options ();
904 #ifdef OPTIMIZATION_OPTIONS
905 /* Allow default optimizations to be specified on a per-machine basis. */
906 OPTIMIZATION_OPTIONS (optimize
, optimize_size
);
909 read_cmdline_options (*decoded_options
, *decoded_options_count
, lang_mask
,
912 if (dump_base_name
&& ! IS_ABSOLUTE_PATH (dump_base_name
))
914 /* First try to make DUMP_BASE_NAME relative to the DUMP_DIR_NAME
915 directory. Then try to make DUMP_BASE_NAME relative to the
916 AUX_BASE_NAME directory, typically the directory to contain
919 dump_base_name
= concat (dump_dir_name
, dump_base_name
, NULL
);
920 else if (aux_base_name
)
922 const char *aux_base
;
924 base_of_path (aux_base_name
, &aux_base
);
925 if (aux_base_name
!= aux_base
)
927 int dir_len
= aux_base
- aux_base_name
;
928 char *new_dump_base_name
=
929 XNEWVEC (char, strlen(dump_base_name
) + dir_len
+ 1);
931 /* Copy directory component from AUX_BASE_NAME. */
932 memcpy (new_dump_base_name
, aux_base_name
, dir_len
);
933 /* Append existing DUMP_BASE_NAME. */
934 strcpy (new_dump_base_name
+ dir_len
, dump_base_name
);
935 dump_base_name
= new_dump_base_name
;
940 /* Handle related options for unit-at-a-time, toplevel-reorder, and
942 if (!flag_unit_at_a_time
)
944 if (flag_section_anchors
== 1)
945 error ("Section anchors must be disabled when unit-at-a-time "
947 flag_section_anchors
= 0;
948 if (flag_toplevel_reorder
== 1)
949 error ("Toplevel reorder must be disabled when unit-at-a-time "
951 flag_toplevel_reorder
= 0;
954 /* -Wmissing-noreturn is alias for -Wsuggest-attribute=noreturn. */
955 if (warn_missing_noreturn
)
956 warn_suggest_attribute_noreturn
= true;
958 /* Unless the user has asked for section anchors, we disable toplevel
959 reordering at -O0 to disable transformations that might be surprising
960 to end users and to get -fno-toplevel-reorder tested. */
961 if (!optimize
&& flag_toplevel_reorder
== 2 && flag_section_anchors
!= 1)
963 flag_toplevel_reorder
= 0;
964 flag_section_anchors
= 0;
966 if (!flag_toplevel_reorder
)
968 if (flag_section_anchors
== 1)
969 error ("section anchors must be disabled when toplevel reorder"
971 flag_section_anchors
= 0;
978 if (flag_pic
&& !flag_pie
)
980 first_time_p
= false;
985 /* Inlining does not work if not optimizing,
986 so force it not to be done. */
991 /* The optimization to partition hot and cold basic blocks into separate
992 sections of the .o and executable files does not work (currently)
993 with exception handling. This is because there is no support for
994 generating unwind info. If flag_exceptions is turned on we need to
995 turn off the partitioning optimization. */
997 if (flag_exceptions
&& flag_reorder_blocks_and_partition
998 && (USING_SJLJ_EXCEPTIONS
999 #ifdef TARGET_UNWIND_INFO
1004 inform (input_location
,
1005 "-freorder-blocks-and-partition does not work with exceptions on this architecture");
1006 flag_reorder_blocks_and_partition
= 0;
1007 flag_reorder_blocks
= 1;
1010 /* If user requested unwind info, then turn off the partitioning
1013 if (flag_unwind_tables
&& ! targetm
.unwind_tables_default
1014 && flag_reorder_blocks_and_partition
1015 && (USING_SJLJ_EXCEPTIONS
1016 #ifdef TARGET_UNWIND_INFO
1021 inform (input_location
,
1022 "-freorder-blocks-and-partition does not support unwind info on this architecture");
1023 flag_reorder_blocks_and_partition
= 0;
1024 flag_reorder_blocks
= 1;
1027 /* If the target requested unwind info, then turn off the partitioning
1028 optimization with a different message. Likewise, if the target does not
1029 support named sections. */
1031 if (flag_reorder_blocks_and_partition
1032 && (!targetm
.have_named_sections
1033 || (flag_unwind_tables
&& targetm
.unwind_tables_default
1034 && (USING_SJLJ_EXCEPTIONS
1035 #ifdef TARGET_UNWIND_INFO
1040 inform (input_location
,
1041 "-freorder-blocks-and-partition does not work on this architecture");
1042 flag_reorder_blocks_and_partition
= 0;
1043 flag_reorder_blocks
= 1;
1046 /* Pipelining of outer loops is only possible when general pipelining
1047 capabilities are requested. */
1048 if (!flag_sel_sched_pipelining
)
1049 flag_sel_sched_pipelining_outer_loops
= 0;
1051 if (!targetm
.ira_cover_classes
1052 && flag_ira_algorithm
== IRA_ALGORITHM_CB
)
1054 inform (input_location
,
1055 "-fira-algorithm=CB does not work on this architecture");
1056 flag_ira_algorithm
= IRA_ALGORITHM_PRIORITY
;
1059 if (flag_conserve_stack
)
1061 if (!PARAM_SET_P (PARAM_LARGE_STACK_FRAME
))
1062 PARAM_VALUE (PARAM_LARGE_STACK_FRAME
) = 100;
1063 if (!PARAM_SET_P (PARAM_STACK_FRAME_GROWTH
))
1064 PARAM_VALUE (PARAM_STACK_FRAME_GROWTH
) = 40;
1066 if (flag_wpa
|| flag_ltrans
)
1068 /* These passes are not WHOPR compatible yet. */
1070 flag_ipa_struct_reorg
= 0;
1073 if (flag_lto
|| flag_whopr
)
1076 flag_generate_lto
= 1;
1078 /* When generating IL, do not operate in whole-program mode.
1079 Otherwise, symbols will be privatized too early, causing link
1081 flag_whole_program
= 0;
1083 error ("LTO support has not been enabled in this configuration");
1087 /* Reconcile -flto and -fwhopr. Set additional flags as appropriate and
1088 check option consistency. */
1089 if (flag_lto
&& flag_whopr
)
1090 error ("-flto and -fwhopr are mutually exclusive");
1093 #define LEFT_COLUMN 27
1095 /* Output ITEM, of length ITEM_WIDTH, in the left column,
1096 followed by word-wrapped HELP in a second column. */
1098 wrap_help (const char *help
,
1100 unsigned int item_width
,
1101 unsigned int columns
)
1103 unsigned int col_width
= LEFT_COLUMN
;
1104 unsigned int remaining
, room
, len
;
1106 remaining
= strlen (help
);
1110 room
= columns
- 3 - MAX (col_width
, item_width
);
1119 for (i
= 0; help
[i
]; i
++)
1121 if (i
>= room
&& len
!= remaining
)
1125 else if ((help
[i
] == '-' || help
[i
] == '/')
1126 && help
[i
+ 1] != ' '
1127 && i
> 0 && ISALPHA (help
[i
- 1]))
1132 printf( " %-*.*s %.*s\n", col_width
, item_width
, item
, len
, help
);
1134 while (help
[len
] == ' ')
1142 /* Print help for a specific front-end, etc. */
1144 print_filtered_help (unsigned int include_flags
,
1145 unsigned int exclude_flags
,
1146 unsigned int any_flags
,
1147 unsigned int columns
)
1151 static char *printed
= NULL
;
1153 bool displayed
= false;
1155 if (include_flags
== CL_PARAMS
)
1157 for (i
= 0; i
< LAST_PARAM
; i
++)
1159 const char *param
= compiler_params
[i
].option
;
1161 help
= compiler_params
[i
].help
;
1162 if (help
== NULL
|| *help
== '\0')
1164 if (exclude_flags
& CL_UNDOCUMENTED
)
1166 help
= undocumented_msg
;
1169 /* Get the translation. */
1172 wrap_help (help
, param
, strlen (param
), columns
);
1179 printed
= XCNEWVAR (char, cl_options_count
);
1181 for (i
= 0; i
< cl_options_count
; i
++)
1183 static char new_help
[128];
1184 const struct cl_option
*option
= cl_options
+ i
;
1189 if (include_flags
== 0
1190 || ((option
->flags
& include_flags
) != include_flags
))
1192 if ((option
->flags
& any_flags
) == 0)
1196 /* Skip unwanted switches. */
1197 if ((option
->flags
& exclude_flags
) != 0)
1200 /* The driver currently prints its own help text. */
1201 if ((option
->flags
& CL_DRIVER
) != 0
1202 && (option
->flags
& (((1U << cl_lang_count
) - 1)
1203 | CL_COMMON
| CL_TARGET
)) == 0)
1207 /* Skip switches that have already been printed. */
1213 help
= option
->help
;
1216 if (exclude_flags
& CL_UNDOCUMENTED
)
1218 help
= undocumented_msg
;
1221 /* Get the translation. */
1224 /* Find the gap between the name of the
1225 option and its descriptive text. */
1226 tab
= strchr (help
, '\t');
1235 opt
= option
->opt_text
;
1239 /* With the -Q option enabled we change the descriptive text associated
1240 with an option to be an indication of its current setting. */
1243 if (len
< (LEFT_COLUMN
+ 2))
1244 strcpy (new_help
, "\t\t");
1246 strcpy (new_help
, "\t");
1248 if (option
->flag_var
!= NULL
)
1250 if (option
->flags
& CL_JOINED
)
1252 if (option
->var_type
== CLVC_STRING
)
1254 if (* (const char **) option
->flag_var
!= NULL
)
1255 snprintf (new_help
+ strlen (new_help
),
1256 sizeof (new_help
) - strlen (new_help
),
1257 * (const char **) option
->flag_var
);
1260 sprintf (new_help
+ strlen (new_help
),
1261 "%#x", * (int *) option
->flag_var
);
1264 strcat (new_help
, option_enabled (i
)
1265 ? _("[enabled]") : _("[disabled]"));
1271 wrap_help (help
, opt
, len
, columns
);
1277 unsigned int langs
= include_flags
& CL_LANG_ALL
;
1280 printf (_(" No options with the desired characteristics were found\n"));
1285 /* PR 31349: Tell the user how to see all of the
1286 options supported by a specific front end. */
1287 for (i
= 0; (1U << i
) < CL_LANG_ALL
; i
++)
1288 if ((1U << i
) & langs
)
1289 printf (_(" None found. Use --help=%s to show *all* the options supported by the %s front-end\n"),
1290 lang_names
[i
], lang_names
[i
]);
1294 else if (! displayed
)
1295 printf (_(" All options with the desired characteristics have already been displayed\n"));
1300 /* Display help for a specified type of option.
1301 The options must have ALL of the INCLUDE_FLAGS set
1302 ANY of the flags in the ANY_FLAGS set
1303 and NONE of the EXCLUDE_FLAGS set. */
1305 print_specific_help (unsigned int include_flags
,
1306 unsigned int exclude_flags
,
1307 unsigned int any_flags
)
1309 unsigned int all_langs_mask
= (1U << cl_lang_count
) - 1;
1310 const char * description
= NULL
;
1311 const char * descrip_extra
= "";
1314 static unsigned int columns
= 0;
1316 /* Sanity check: Make sure that we do not have more
1317 languages than we have bits available to enumerate them. */
1318 gcc_assert ((1U << cl_lang_count
) < CL_MIN_OPTION_CLASS
);
1320 /* If we have not done so already, obtain
1321 the desired maximum width of the output. */
1326 GET_ENVIRONMENT (p
, "COLUMNS");
1329 int value
= atoi (p
);
1336 /* Use a reasonable default. */
1340 /* Decide upon the title for the options that we are going to display. */
1341 for (i
= 0, flag
= 1; flag
<= CL_MAX_OPTION_CLASS
; flag
<<= 1, i
++)
1343 switch (flag
& include_flags
)
1350 description
= _("The following options are target specific");
1353 description
= _("The following options control compiler warning messages");
1355 case CL_OPTIMIZATION
:
1356 description
= _("The following options control optimizations");
1359 description
= _("The following options are language-independent");
1362 description
= _("The --param option recognizes the following as parameters");
1365 if (i
>= cl_lang_count
)
1367 if (exclude_flags
& all_langs_mask
)
1368 description
= _("The following options are specific to just the language ");
1370 description
= _("The following options are supported by the language ");
1371 descrip_extra
= lang_names
[i
];
1376 if (description
== NULL
)
1380 if (include_flags
& CL_UNDOCUMENTED
)
1381 description
= _("The following options are not documented");
1382 else if (include_flags
& CL_SEPARATE
)
1383 description
= _("The following options take separate arguments");
1384 else if (include_flags
& CL_JOINED
)
1385 description
= _("The following options take joined arguments");
1388 internal_error ("unrecognized include_flags 0x%x passed to print_specific_help",
1395 if (any_flags
& all_langs_mask
)
1396 description
= _("The following options are language-related");
1398 description
= _("The following options are language-independent");
1402 printf ("%s%s:\n", description
, descrip_extra
);
1403 print_filtered_help (include_flags
, exclude_flags
, any_flags
, columns
);
1406 /* Handle target- and language-independent options. Return zero to
1407 generate an "unknown option" message. Only options that need
1408 extra handling need to be listed here; if you simply want
1409 DECODED->value assigned to a variable, it happens automatically. */
1412 common_handle_option (const struct cl_decoded_option
*decoded
,
1413 unsigned int lang_mask
, int kind ATTRIBUTE_UNUSED
,
1414 const struct cl_option_handlers
*handlers
)
1416 size_t scode
= decoded
->opt_index
;
1417 const char *arg
= decoded
->arg
;
1418 int value
= decoded
->value
;
1419 static bool verbose
= false;
1420 enum opt_code code
= (enum opt_code
) scode
;
1422 gcc_assert (decoded
->canonical_option_num_elements
<= 2);
1437 unsigned int all_langs_mask
= (1U << cl_lang_count
) - 1;
1438 unsigned int undoc_mask
;
1441 undoc_mask
= (verbose
| extra_warnings
) ? 0 : CL_UNDOCUMENTED
;
1442 /* First display any single language specific options. */
1443 for (i
= 0; i
< cl_lang_count
; i
++)
1445 (1U << i
, (all_langs_mask
& (~ (1U << i
))) | undoc_mask
, 0);
1446 /* Next display any multi language specific options. */
1447 print_specific_help (0, undoc_mask
, all_langs_mask
);
1448 /* Then display any remaining, non-language options. */
1449 for (i
= CL_MIN_OPTION_CLASS
; i
<= CL_MAX_OPTION_CLASS
; i
<<= 1)
1451 print_specific_help (i
, undoc_mask
, 0);
1452 exit_after_options
= true;
1456 case OPT_ftarget_help
:
1457 case OPT__target_help
:
1458 print_specific_help (CL_TARGET
, CL_UNDOCUMENTED
, 0);
1459 exit_after_options
= true;
1461 /* Allow the target a chance to give the user some additional information. */
1469 const char * a
= arg
;
1470 unsigned int include_flags
= 0;
1471 /* Note - by default we include undocumented options when listing
1472 specific classes. If you only want to see documented options
1473 then add ",^undocumented" to the --help= option. E.g.:
1475 --help=target,^undocumented */
1476 unsigned int exclude_flags
= 0;
1478 /* Walk along the argument string, parsing each word in turn.
1480 arg = [^]{word}[,{arg}]
1481 word = {optimizers|target|warnings|undocumented|
1482 params|common|<language>} */
1487 const char * string
;
1492 { "optimizers", CL_OPTIMIZATION
},
1493 { "target", CL_TARGET
},
1494 { "warnings", CL_WARNING
},
1495 { "undocumented", CL_UNDOCUMENTED
},
1496 { "params", CL_PARAMS
},
1497 { "joined", CL_JOINED
},
1498 { "separate", CL_SEPARATE
},
1499 { "common", CL_COMMON
},
1502 unsigned int * pflags
;
1504 unsigned int lang_flag
, specific_flag
;
1511 pflags
= & exclude_flags
;
1514 pflags
= & include_flags
;
1516 comma
= strchr (a
, ',');
1527 /* Check to see if the string matches an option class name. */
1528 for (i
= 0, specific_flag
= 0; specifics
[i
].string
!= NULL
; i
++)
1529 if (strncasecmp (a
, specifics
[i
].string
, len
) == 0)
1531 specific_flag
= specifics
[i
].flag
;
1535 /* Check to see if the string matches a language name.
1536 Note - we rely upon the alpha-sorted nature of the entries in
1537 the lang_names array, specifically that shorter names appear
1538 before their longer variants. (i.e. C before C++). That way
1539 when we are attempting to match --help=c for example we will
1540 match with C first and not C++. */
1541 for (i
= 0, lang_flag
= 0; i
< cl_lang_count
; i
++)
1542 if (strncasecmp (a
, lang_names
[i
], len
) == 0)
1544 lang_flag
= 1U << i
;
1548 if (specific_flag
!= 0)
1551 * pflags
|= specific_flag
;
1554 /* The option's argument matches both the start of a
1555 language name and the start of an option class name.
1556 We have a special case for when the user has
1557 specified "--help=c", but otherwise we have to issue
1559 if (strncasecmp (a
, "c", len
) == 0)
1560 * pflags
|= lang_flag
;
1563 "warning: --help argument %.*s is ambiguous, please be more specific\n",
1567 else if (lang_flag
!= 0)
1568 * pflags
|= lang_flag
;
1571 "warning: unrecognized argument to --help= option: %.*s\n",
1580 print_specific_help (include_flags
, exclude_flags
, 0);
1581 exit_after_options
= true;
1587 exit_after_options
= true;
1593 /* Currently handled in a prescan. */
1597 enable_warning_as_error (arg
, value
, lang_mask
, handlers
);
1600 case OPT_Wlarger_than_
:
1601 /* This form corresponds to -Wlarger-than-.
1602 Kept for backward compatibility.
1603 Don't use it as the first argument of warning(). */
1605 case OPT_Wlarger_than_eq
:
1606 larger_than_size
= value
;
1607 warn_larger_than
= value
!= -1;
1610 case OPT_Wfatal_errors
:
1611 global_dc
->fatal_errors
= value
;
1614 case OPT_Wframe_larger_than_
:
1615 frame_larger_than_size
= value
;
1616 warn_frame_larger_than
= value
!= -1;
1619 case OPT_Wstrict_aliasing
:
1620 set_Wstrict_aliasing (value
);
1623 case OPT_Wstrict_aliasing_
:
1624 warn_strict_aliasing
= value
;
1627 case OPT_Wstrict_overflow
:
1628 warn_strict_overflow
= (value
1629 ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
1633 case OPT_Wstrict_overflow_
:
1634 warn_strict_overflow
= value
;
1637 case OPT_Wsystem_headers
:
1638 global_dc
->warn_system_headers
= value
;
1642 warn_unused
= value
;
1647 aux_info_file_name
= arg
;
1648 flag_gen_aux_info
= 1;
1652 aux_base_name
= arg
;
1655 case OPT_auxbase_strip
:
1657 char *tmp
= xstrdup (arg
);
1658 strip_off_ending (tmp
, strlen (tmp
));
1660 aux_base_name
= tmp
;
1665 decode_d_option (arg
);
1669 dump_base_name
= arg
;
1673 dump_dir_name
= arg
;
1676 case OPT_falign_functions_
:
1677 align_functions
= value
;
1680 case OPT_falign_jumps_
:
1681 align_jumps
= value
;
1684 case OPT_falign_labels_
:
1685 align_labels
= value
;
1688 case OPT_falign_loops_
:
1689 align_loops
= value
;
1692 case OPT_fbranch_probabilities
:
1693 flag_branch_probabilities_set
= true;
1696 case OPT_fcall_used_
:
1697 fix_register (arg
, 0, 1);
1700 case OPT_fcall_saved_
:
1701 fix_register (arg
, 0, 0);
1705 dbg_cnt_process_opt (arg
);
1708 case OPT_fdbg_cnt_list
:
1709 dbg_cnt_list_all_counters ();
1712 case OPT_fdebug_prefix_map_
:
1713 add_debug_prefix_map (arg
);
1716 case OPT_fdiagnostics_show_location_
:
1717 if (!strcmp (arg
, "once"))
1718 diagnostic_prefixing_rule (global_dc
) = DIAGNOSTICS_SHOW_PREFIX_ONCE
;
1719 else if (!strcmp (arg
, "every-line"))
1720 diagnostic_prefixing_rule (global_dc
)
1721 = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE
;
1726 case OPT_fdiagnostics_show_option
:
1727 global_dc
->show_option_requested
= value
;
1731 if (!dump_switch_p (arg
))
1735 case OPT_fexcess_precision_
:
1736 if (!strcmp (arg
, "fast"))
1737 flag_excess_precision_cmdline
= EXCESS_PRECISION_FAST
;
1738 else if (!strcmp (arg
, "standard"))
1739 flag_excess_precision_cmdline
= EXCESS_PRECISION_STANDARD
;
1741 error ("unknown excess precision style \"%s\"", arg
);
1744 case OPT_ffast_math
:
1745 set_fast_math_flags (value
);
1748 case OPT_funsafe_math_optimizations
:
1749 set_unsafe_math_optimizations_flags (value
);
1753 fix_register (arg
, 1, 1);
1756 case OPT_finline_limit_
:
1757 case OPT_finline_limit_eq
:
1758 set_param_value ("max-inline-insns-single", value
/ 2);
1759 set_param_value ("max-inline-insns-auto", value
/ 2);
1762 case OPT_finstrument_functions_exclude_function_list_
:
1763 add_comma_separated_to_vector
1764 (&flag_instrument_functions_exclude_functions
, arg
);
1767 case OPT_finstrument_functions_exclude_file_list_
:
1768 add_comma_separated_to_vector
1769 (&flag_instrument_functions_exclude_files
, arg
);
1772 case OPT_fmessage_length_
:
1773 pp_set_line_maximum_length (global_dc
->printer
, value
);
1776 case OPT_fpack_struct_
:
1777 if (value
<= 0 || (value
& (value
- 1)) || value
> 16)
1778 error ("structure alignment must be a small power of two, not %d", value
);
1781 initial_max_fld_align
= value
;
1782 maximum_field_alignment
= value
* BITS_PER_UNIT
;
1786 case OPT_fpeel_loops
:
1787 flag_peel_loops_set
= true;
1791 #ifdef ENABLE_PLUGIN
1792 add_new_plugin (arg
);
1794 error ("Plugin support is disabled. Configure with --enable-plugin.");
1798 case OPT_fplugin_arg_
:
1799 #ifdef ENABLE_PLUGIN
1800 parse_plugin_arg_opt (arg
);
1802 error ("Plugin support is disabled. Configure with --enable-plugin.");
1806 case OPT_fprofile_arcs
:
1807 profile_arc_flag_set
= true;
1810 case OPT_finline_functions
:
1811 flag_inline_functions_set
= true;
1814 case OPT_fprofile_dir_
:
1815 profile_data_prefix
= xstrdup (arg
);
1818 case OPT_fprofile_use_
:
1819 profile_data_prefix
= xstrdup (arg
);
1820 flag_profile_use
= true;
1822 /* No break here - do -fprofile-use processing. */
1823 case OPT_fprofile_use
:
1824 if (!flag_branch_probabilities_set
)
1825 flag_branch_probabilities
= value
;
1826 if (!flag_profile_values_set
)
1827 flag_profile_values
= value
;
1828 if (!flag_unroll_loops_set
)
1829 flag_unroll_loops
= value
;
1830 if (!flag_peel_loops_set
)
1831 flag_peel_loops
= value
;
1832 if (!flag_tracer_set
)
1833 flag_tracer
= value
;
1834 if (!flag_value_profile_transformations_set
)
1835 flag_value_profile_transformations
= value
;
1836 if (!flag_inline_functions_set
)
1837 flag_inline_functions
= value
;
1838 if (!flag_ipa_cp_set
)
1839 flag_ipa_cp
= value
;
1840 if (!flag_ipa_cp_clone_set
1841 && value
&& flag_ipa_cp
)
1842 flag_ipa_cp_clone
= value
;
1843 if (!flag_predictive_commoning_set
)
1844 flag_predictive_commoning
= value
;
1845 if (!flag_unswitch_loops_set
)
1846 flag_unswitch_loops
= value
;
1847 if (!flag_gcse_after_reload_set
)
1848 flag_gcse_after_reload
= value
;
1851 case OPT_fprofile_generate_
:
1852 profile_data_prefix
= xstrdup (arg
);
1854 /* No break here - do -fprofile-generate processing. */
1855 case OPT_fprofile_generate
:
1856 if (!profile_arc_flag_set
)
1857 profile_arc_flag
= value
;
1858 if (!flag_profile_values_set
)
1859 flag_profile_values
= value
;
1860 if (!flag_value_profile_transformations_set
)
1861 flag_value_profile_transformations
= value
;
1862 if (!flag_inline_functions_set
)
1863 flag_inline_functions
= value
;
1866 case OPT_fprofile_values
:
1867 flag_profile_values_set
= true;
1870 case OPT_fshow_column
:
1871 global_dc
->show_column
= value
;
1874 case OPT_fvisibility_
:
1876 if (!strcmp(arg
, "default"))
1877 default_visibility
= VISIBILITY_DEFAULT
;
1878 else if (!strcmp(arg
, "internal"))
1879 default_visibility
= VISIBILITY_INTERNAL
;
1880 else if (!strcmp(arg
, "hidden"))
1881 default_visibility
= VISIBILITY_HIDDEN
;
1882 else if (!strcmp(arg
, "protected"))
1883 default_visibility
= VISIBILITY_PROTECTED
;
1885 error ("unrecognized visibility value \"%s\"", arg
);
1890 flag_value_profile_transformations_set
= true;
1893 case OPT_frandom_seed
:
1894 /* The real switch is -fno-random-seed. */
1897 set_random_seed (NULL
);
1900 case OPT_frandom_seed_
:
1901 set_random_seed (arg
);
1904 case OPT_fselective_scheduling
:
1905 case OPT_fselective_scheduling2
:
1906 sel_sched_switch_set
= true;
1909 case OPT_fsched_verbose_
:
1910 #ifdef INSN_SCHEDULING
1911 fix_sched_param ("verbose", arg
);
1917 case OPT_fsched_stalled_insns_
:
1918 flag_sched_stalled_insns
= value
;
1919 if (flag_sched_stalled_insns
== 0)
1920 flag_sched_stalled_insns
= -1;
1923 case OPT_fsched_stalled_insns_dep_
:
1924 flag_sched_stalled_insns_dep
= value
;
1927 case OPT_fstack_check_
:
1928 if (!strcmp (arg
, "no"))
1929 flag_stack_check
= NO_STACK_CHECK
;
1930 else if (!strcmp (arg
, "generic"))
1931 /* This is the old stack checking method. */
1932 flag_stack_check
= STACK_CHECK_BUILTIN
1933 ? FULL_BUILTIN_STACK_CHECK
1934 : GENERIC_STACK_CHECK
;
1935 else if (!strcmp (arg
, "specific"))
1936 /* This is the new stack checking method. */
1937 flag_stack_check
= STACK_CHECK_BUILTIN
1938 ? FULL_BUILTIN_STACK_CHECK
1939 : STACK_CHECK_STATIC_BUILTIN
1940 ? STATIC_BUILTIN_STACK_CHECK
1941 : GENERIC_STACK_CHECK
;
1943 warning (0, "unknown stack check parameter \"%s\"", arg
);
1946 case OPT_fstack_check
:
1947 /* This is the same as the "specific" mode above. */
1949 flag_stack_check
= STACK_CHECK_BUILTIN
1950 ? FULL_BUILTIN_STACK_CHECK
1951 : STACK_CHECK_STATIC_BUILTIN
1952 ? STATIC_BUILTIN_STACK_CHECK
1953 : GENERIC_STACK_CHECK
;
1955 flag_stack_check
= NO_STACK_CHECK
;
1958 case OPT_fstack_limit
:
1959 /* The real switch is -fno-stack-limit. */
1962 stack_limit_rtx
= NULL_RTX
;
1965 case OPT_fstack_limit_register_
:
1967 int reg
= decode_reg_name (arg
);
1969 error ("unrecognized register name \"%s\"", arg
);
1971 stack_limit_rtx
= gen_rtx_REG (Pmode
, reg
);
1975 case OPT_fstack_limit_symbol_
:
1976 stack_limit_rtx
= gen_rtx_SYMBOL_REF (Pmode
, ggc_strdup (arg
));
1979 case OPT_ftree_vectorizer_verbose_
:
1980 vect_set_verbosity_level (arg
);
1983 case OPT_ftls_model_
:
1984 if (!strcmp (arg
, "global-dynamic"))
1985 flag_tls_default
= TLS_MODEL_GLOBAL_DYNAMIC
;
1986 else if (!strcmp (arg
, "local-dynamic"))
1987 flag_tls_default
= TLS_MODEL_LOCAL_DYNAMIC
;
1988 else if (!strcmp (arg
, "initial-exec"))
1989 flag_tls_default
= TLS_MODEL_INITIAL_EXEC
;
1990 else if (!strcmp (arg
, "local-exec"))
1991 flag_tls_default
= TLS_MODEL_LOCAL_EXEC
;
1993 warning (0, "unknown tls-model \"%s\"", arg
);
1996 case OPT_fira_algorithm_
:
1997 if (!strcmp (arg
, "CB"))
1998 flag_ira_algorithm
= IRA_ALGORITHM_CB
;
1999 else if (!strcmp (arg
, "priority"))
2000 flag_ira_algorithm
= IRA_ALGORITHM_PRIORITY
;
2002 warning (0, "unknown ira algorithm \"%s\"", arg
);
2005 case OPT_fira_region_
:
2006 if (!strcmp (arg
, "one"))
2007 flag_ira_region
= IRA_REGION_ONE
;
2008 else if (!strcmp (arg
, "all"))
2009 flag_ira_region
= IRA_REGION_ALL
;
2010 else if (!strcmp (arg
, "mixed"))
2011 flag_ira_region
= IRA_REGION_MIXED
;
2013 warning (0, "unknown ira region \"%s\"", arg
);
2016 case OPT_fira_verbose_
:
2017 flag_ira_verbose
= value
;
2021 flag_tracer_set
= true;
2025 flag_ipa_cp_set
= true;
2028 case OPT_fipa_cp_clone
:
2029 flag_ipa_cp_clone_set
= true;
2032 case OPT_fpredictive_commoning
:
2033 flag_predictive_commoning_set
= true;
2036 case OPT_funswitch_loops
:
2037 flag_unswitch_loops_set
= true;
2040 case OPT_fgcse_after_reload
:
2041 flag_gcse_after_reload_set
= true;
2044 case OPT_funroll_loops
:
2045 flag_unroll_loops_set
= true;
2049 set_debug_level (NO_DEBUG
, DEFAULT_GDB_EXTENSIONS
, arg
);
2053 set_debug_level (SDB_DEBUG
, false, arg
);
2057 if (value
< 2 || value
> 4)
2058 error ("dwarf version %d is not supported", value
);
2060 dwarf_version
= value
;
2061 set_debug_level (DWARF2_DEBUG
, false, "");
2065 set_debug_level (NO_DEBUG
, 2, arg
);
2070 set_debug_level (DBX_DEBUG
, code
== OPT_gstabs_
, arg
);
2074 set_debug_level (VMS_DEBUG
, false, arg
);
2079 set_debug_level (XCOFF_DEBUG
, code
== OPT_gxcoff_
, arg
);
2083 asm_file_name
= arg
;
2086 case OPT_pedantic_errors
:
2087 flag_pedantic_errors
= pedantic
= 1;
2088 global_dc
->pedantic_errors
= 1;
2100 global_dc
->inhibit_warnings
= true;
2104 case OPT_fcse_skip_blocks
:
2105 case OPT_floop_optimize
:
2106 case OPT_frerun_loop_opt
:
2107 case OPT_fsched2_use_traces
:
2108 case OPT_fstrength_reduce
:
2109 case OPT_ftree_store_copy_prop
:
2110 case OPT_fforce_addr
:
2111 case OPT_ftree_salias
:
2112 case OPT_ftree_store_ccp
:
2113 case OPT_Wunreachable_code
:
2114 case OPT_fargument_alias
:
2115 case OPT_fargument_noalias
:
2116 case OPT_fargument_noalias_anything
:
2117 case OPT_fargument_noalias_global
:
2118 /* These are no-ops, preserved for backward compatibility. */
2121 case OPT_fuse_linker_plugin
:
2122 /* No-op. Used by the driver and passed to us because it starts with f.*/
2126 /* If the flag was handled in a standard way, assume the lack of
2127 processing here is intentional. */
2128 gcc_assert (cl_options
[scode
].flag_var
);
2135 /* Handle --param NAME=VALUE. */
2137 handle_param (const char *carg
)
2142 arg
= xstrdup (carg
);
2143 equal
= strchr (arg
, '=');
2145 error ("%s: --param arguments should be of the form NAME=VALUE", arg
);
2148 value
= integral_argument (equal
+ 1);
2150 error ("invalid --param value %qs", equal
+ 1);
2154 set_param_value (arg
, value
);
2161 /* Used to set the level of strict aliasing warnings,
2162 when no level is specified (i.e., when -Wstrict-aliasing, and not
2163 -Wstrict-aliasing=level was given).
2164 ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
2165 and 0 otherwise. After calling this function, wstrict_aliasing will be
2166 set to the default value of -Wstrict_aliasing=level, currently 3. */
2168 set_Wstrict_aliasing (int onoff
)
2170 gcc_assert (onoff
== 0 || onoff
== 1);
2172 warn_strict_aliasing
= 3;
2174 warn_strict_aliasing
= 0;
2177 /* The following routines are useful in setting all the flags that
2178 -ffast-math and -fno-fast-math imply. */
2180 set_fast_math_flags (int set
)
2182 flag_unsafe_math_optimizations
= set
;
2183 set_unsafe_math_optimizations_flags (set
);
2184 flag_finite_math_only
= set
;
2185 flag_errno_math
= !set
;
2188 flag_signaling_nans
= 0;
2189 flag_rounding_math
= 0;
2190 flag_cx_limited_range
= 1;
2194 /* When -funsafe-math-optimizations is set the following
2195 flags are set as well. */
2197 set_unsafe_math_optimizations_flags (int set
)
2199 flag_trapping_math
= !set
;
2200 flag_signed_zeros
= !set
;
2201 flag_associative_math
= set
;
2202 flag_reciprocal_math
= set
;
2205 /* Return true iff flags are set as if -ffast-math. */
2207 fast_math_flags_set_p (void)
2209 return (!flag_trapping_math
2210 && flag_unsafe_math_optimizations
2211 && flag_finite_math_only
2212 && !flag_signed_zeros
2213 && !flag_errno_math
);
2216 /* Return true iff flags are set as if -ffast-math but using the flags stored
2217 in the struct cl_optimization structure. */
2219 fast_math_flags_struct_set_p (struct cl_optimization
*opt
)
2221 return (!opt
->flag_trapping_math
2222 && opt
->flag_unsafe_math_optimizations
2223 && opt
->flag_finite_math_only
2224 && !opt
->flag_signed_zeros
2225 && !opt
->flag_errno_math
);
2228 /* Handle a debug output -g switch. EXTENDED is true or false to support
2229 extended output (2 is special and means "-ggdb" was given). */
2231 set_debug_level (enum debug_info_type type
, int extended
, const char *arg
)
2233 static bool type_explicit
;
2235 use_gnu_debug_info_extensions
= extended
;
2237 if (type
== NO_DEBUG
)
2239 if (write_symbols
== NO_DEBUG
)
2241 write_symbols
= PREFERRED_DEBUGGING_TYPE
;
2245 #ifdef DWARF2_DEBUGGING_INFO
2246 write_symbols
= DWARF2_DEBUG
;
2247 #elif defined DBX_DEBUGGING_INFO
2248 write_symbols
= DBX_DEBUG
;
2252 if (write_symbols
== NO_DEBUG
)
2253 warning (0, "target system does not support debug output");
2258 /* Does it conflict with an already selected type? */
2259 if (type_explicit
&& write_symbols
!= NO_DEBUG
&& type
!= write_symbols
)
2260 error ("debug format \"%s\" conflicts with prior selection",
2261 debug_type_names
[type
]);
2262 write_symbols
= type
;
2263 type_explicit
= true;
2266 /* A debug flag without a level defaults to level 2. */
2269 if (!debug_info_level
)
2270 debug_info_level
= DINFO_LEVEL_NORMAL
;
2274 int argval
= integral_argument (arg
);
2276 error ("unrecognised debug output level \"%s\"", arg
);
2277 else if (argval
> 3)
2278 error ("debug output level %s is too high", arg
);
2280 debug_info_level
= (enum debug_info_level
) argval
;
2284 /* Return 1 if OPTION is enabled, 0 if it is disabled, or -1 if it isn't
2285 a simple on-off switch. */
2288 option_enabled (int opt_idx
)
2290 const struct cl_option
*option
= &(cl_options
[opt_idx
]);
2292 if (option
->flag_var
)
2293 switch (option
->var_type
)
2296 return *(int *) option
->flag_var
!= 0;
2299 return *(int *) option
->flag_var
== option
->var_value
;
2301 case CLVC_BIT_CLEAR
:
2302 return (*(int *) option
->flag_var
& option
->var_value
) == 0;
2305 return (*(int *) option
->flag_var
& option
->var_value
) != 0;
2313 /* Fill STATE with the current state of option OPTION. Return true if
2314 there is some state to store. */
2317 get_option_state (int option
, struct cl_option_state
*state
)
2319 if (cl_options
[option
].flag_var
== 0)
2322 switch (cl_options
[option
].var_type
)
2326 state
->data
= cl_options
[option
].flag_var
;
2327 state
->size
= sizeof (int);
2330 case CLVC_BIT_CLEAR
:
2332 state
->ch
= option_enabled (option
);
2333 state
->data
= &state
->ch
;
2338 state
->data
= *(const char **) cl_options
[option
].flag_var
;
2339 if (state
->data
== 0)
2341 state
->size
= strlen ((const char *) state
->data
) + 1;
2347 /* Callback function, called when -Werror= enables a warning. */
2349 static void (*warning_as_error_callback
) (int) = NULL
;
2351 /* Register a callback for enable_warning_as_error calls. */
2354 register_warning_as_error_callback (void (*callback
) (int))
2356 gcc_assert (warning_as_error_callback
== NULL
|| callback
== NULL
);
2357 warning_as_error_callback
= callback
;
2360 /* Enable a warning option as an error. This is used by -Werror= and
2361 also by legacy Werror-implicit-function-declaration. */
2364 enable_warning_as_error (const char *arg
, int value
, unsigned int lang_mask
,
2365 const struct cl_option_handlers
*handlers
)
2370 new_option
= XNEWVEC (char, strlen (arg
) + 2);
2371 new_option
[0] = 'W';
2372 strcpy (new_option
+ 1, arg
);
2373 option_index
= find_opt (new_option
, lang_mask
);
2374 if (option_index
== OPT_SPECIAL_unknown
)
2376 error ("-Werror=%s: No option -%s", arg
, new_option
);
2380 const diagnostic_t kind
= value
? DK_ERROR
: DK_WARNING
;
2382 diagnostic_classify_diagnostic (global_dc
, option_index
, kind
,
2384 if (kind
== DK_ERROR
)
2386 const struct cl_option
* const option
= cl_options
+ option_index
;
2388 /* -Werror=foo implies -Wfoo. */
2389 if (option
->var_type
== CLVC_BOOLEAN
)
2390 handle_generated_option (option_index
, NULL
, value
, lang_mask
,
2391 (int)kind
, handlers
);
2393 if (warning_as_error_callback
)
2394 warning_as_error_callback (option_index
);
2400 /* Return malloced memory for the name of the option OPTION_INDEX
2401 which enabled a diagnostic (context CONTEXT), originally of type
2402 ORIG_DIAG_KIND but possibly converted to DIAG_KIND by options such
2406 option_name (diagnostic_context
*context
, int option_index
,
2407 diagnostic_t orig_diag_kind
, diagnostic_t diag_kind
)
2411 /* A warning classified as an error. */
2412 if ((orig_diag_kind
== DK_WARNING
|| orig_diag_kind
== DK_PEDWARN
)
2413 && diag_kind
== DK_ERROR
)
2414 return concat (cl_options
[OPT_Werror_
].opt_text
,
2415 /* Skip over "-W". */
2416 cl_options
[option_index
].opt_text
+ 2,
2418 /* A warning with option. */
2420 return xstrdup (cl_options
[option_index
].opt_text
);
2422 /* A warning without option classified as an error. */
2423 else if (orig_diag_kind
== DK_WARNING
|| orig_diag_kind
== DK_PEDWARN
2424 || diag_kind
== DK_WARNING
)
2426 if (context
->warning_as_error_requested
)
2427 return xstrdup (cl_options
[OPT_Werror
].opt_text
);
2429 return xstrdup (_("enabled by default"));