|
0
|
1 /* Command line option handling.
|
|
|
2 Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
|
|
|
3 Free Software Foundation, Inc.
|
|
|
4 Contributed by Neil Booth.
|
|
|
5
|
|
|
6 This file is part of GCC.
|
|
|
7
|
|
|
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
|
|
|
11 version.
|
|
|
12
|
|
|
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
|
|
|
16 for more details.
|
|
|
17
|
|
|
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/>. */
|
|
|
21
|
|
|
22 #include "config.h"
|
|
|
23 #include "system.h"
|
|
|
24 #include "intl.h"
|
|
|
25 #include "coretypes.h"
|
|
|
26 #include "tm.h"
|
|
|
27 #include "tree.h"
|
|
|
28 #include "rtl.h"
|
|
|
29 #include "expr.h"
|
|
|
30 #include "ggc.h"
|
|
|
31 #include "output.h"
|
|
|
32 #include "langhooks.h"
|
|
|
33 #include "opts.h"
|
|
|
34 #include "options.h"
|
|
|
35 #include "flags.h"
|
|
|
36 #include "toplev.h"
|
|
|
37 #include "params.h"
|
|
|
38 #include "diagnostic.h"
|
|
|
39 #include "tm_p.h" /* For OPTIMIZATION_OPTIONS. */
|
|
|
40 #include "insn-attr.h" /* For INSN_SCHEDULING. */
|
|
|
41 #include "target.h"
|
|
|
42 #include "tree-pass.h"
|
|
|
43 #include "dbgcnt.h"
|
|
|
44 #include "debug.h"
|
|
|
45
|
|
|
46 /* Value of the -G xx switch, and whether it was passed or not. */
|
|
|
47 unsigned HOST_WIDE_INT g_switch_value;
|
|
|
48 bool g_switch_set;
|
|
|
49
|
|
|
50 /* Same for selective scheduling. */
|
|
|
51 bool sel_sched_switch_set;
|
|
|
52
|
|
|
53 /* True if we should exit after parsing options. */
|
|
|
54 bool exit_after_options;
|
|
|
55
|
|
|
56 /* Print various extra warnings. -W/-Wextra. */
|
|
|
57 bool extra_warnings;
|
|
|
58
|
|
|
59 /* True to warn about any objects definitions whose size is larger
|
|
|
60 than N bytes. Also want about function definitions whose returned
|
|
|
61 values are larger than N bytes, where N is `larger_than_size'. */
|
|
|
62 bool warn_larger_than;
|
|
|
63 HOST_WIDE_INT larger_than_size;
|
|
|
64
|
|
|
65 /* True to warn about any function whose frame size is larger
|
|
|
66 * than N bytes. */
|
|
|
67 bool warn_frame_larger_than;
|
|
|
68 HOST_WIDE_INT frame_larger_than_size;
|
|
|
69
|
|
|
70 /* Type(s) of debugging information we are producing (if any). See
|
|
|
71 flags.h for the definitions of the different possible types of
|
|
|
72 debugging information. */
|
|
|
73 enum debug_info_type write_symbols = NO_DEBUG;
|
|
|
74
|
|
|
75 /* Level of debugging information we are producing. See flags.h for
|
|
|
76 the definitions of the different possible levels. */
|
|
|
77 enum debug_info_level debug_info_level = DINFO_LEVEL_NONE;
|
|
|
78
|
|
|
79 /* A major contribution to object and executable size is debug
|
|
|
80 information size. A major contribution to debug information size
|
|
|
81 is struct descriptions replicated in several object files. The
|
|
|
82 following flags attempt to reduce this information. The basic
|
|
|
83 idea is to not emit struct debugging information in the current
|
|
|
84 compilation unit when that information will be generated by
|
|
|
85 another compilation unit.
|
|
|
86
|
|
|
87 Debug information for a struct defined in the current source
|
|
|
88 file should be generated in the object file. Likewise the
|
|
|
89 debug information for a struct defined in a header should be
|
|
|
90 generated in the object file of the corresponding source file.
|
|
|
91 Both of these case are handled when the base name of the file of
|
|
|
92 the struct definition matches the base name of the source file
|
|
|
93 of the current compilation unit. This matching emits minimal
|
|
|
94 struct debugging information.
|
|
|
95
|
|
|
96 The base file name matching rule above will fail to emit debug
|
|
|
97 information for structs defined in system headers. So a second
|
|
|
98 category of files includes system headers in addition to files
|
|
|
99 with matching bases.
|
|
|
100
|
|
|
101 The remaining types of files are library headers and application
|
|
|
102 headers. We cannot currently distinguish these two types. */
|
|
|
103
|
|
|
104 enum debug_struct_file
|
|
|
105 {
|
|
|
106 DINFO_STRUCT_FILE_NONE, /* Debug no structs. */
|
|
|
107 DINFO_STRUCT_FILE_BASE, /* Debug structs defined in files with the
|
|
|
108 same base name as the compilation unit. */
|
|
|
109 DINFO_STRUCT_FILE_SYS, /* Also debug structs defined in system
|
|
|
110 header files. */
|
|
|
111 DINFO_STRUCT_FILE_ANY /* Debug structs defined in all files. */
|
|
|
112 };
|
|
|
113
|
|
|
114 /* Generic structs (e.g. templates not explicitly specialized)
|
|
|
115 may not have a compilation unit associated with them, and so
|
|
|
116 may need to be treated differently from ordinary structs.
|
|
|
117
|
|
|
118 Structs only handled by reference (indirectly), will also usually
|
|
|
119 not need as much debugging information. */
|
|
|
120
|
|
|
121 static enum debug_struct_file debug_struct_ordinary[DINFO_USAGE_NUM_ENUMS]
|
|
|
122 = { DINFO_STRUCT_FILE_ANY, DINFO_STRUCT_FILE_ANY, DINFO_STRUCT_FILE_ANY };
|
|
|
123 static enum debug_struct_file debug_struct_generic[DINFO_USAGE_NUM_ENUMS]
|
|
|
124 = { DINFO_STRUCT_FILE_ANY, DINFO_STRUCT_FILE_ANY, DINFO_STRUCT_FILE_ANY };
|
|
|
125
|
|
|
126 /* Parse the -femit-struct-debug-detailed option value
|
|
|
127 and set the flag variables. */
|
|
|
128
|
|
|
129 #define MATCH( prefix, string ) \
|
|
|
130 ((strncmp (prefix, string, sizeof prefix - 1) == 0) \
|
|
|
131 ? ((string += sizeof prefix - 1), 1) : 0)
|
|
|
132
|
|
|
133 void
|
|
|
134 set_struct_debug_option (const char *spec)
|
|
|
135 {
|
|
|
136 /* various labels for comparison */
|
|
|
137 static char dfn_lbl[] = "dfn:", dir_lbl[] = "dir:", ind_lbl[] = "ind:";
|
|
|
138 static char ord_lbl[] = "ord:", gen_lbl[] = "gen:";
|
|
|
139 static char none_lbl[] = "none", any_lbl[] = "any";
|
|
|
140 static char base_lbl[] = "base", sys_lbl[] = "sys";
|
|
|
141
|
|
|
142 enum debug_struct_file files = DINFO_STRUCT_FILE_ANY;
|
|
|
143 /* Default is to apply to as much as possible. */
|
|
|
144 enum debug_info_usage usage = DINFO_USAGE_NUM_ENUMS;
|
|
|
145 int ord = 1, gen = 1;
|
|
|
146
|
|
|
147 /* What usage? */
|
|
|
148 if (MATCH (dfn_lbl, spec))
|
|
|
149 usage = DINFO_USAGE_DFN;
|
|
|
150 else if (MATCH (dir_lbl, spec))
|
|
|
151 usage = DINFO_USAGE_DIR_USE;
|
|
|
152 else if (MATCH (ind_lbl, spec))
|
|
|
153 usage = DINFO_USAGE_IND_USE;
|
|
|
154
|
|
|
155 /* Generics or not? */
|
|
|
156 if (MATCH (ord_lbl, spec))
|
|
|
157 gen = 0;
|
|
|
158 else if (MATCH (gen_lbl, spec))
|
|
|
159 ord = 0;
|
|
|
160
|
|
|
161 /* What allowable environment? */
|
|
|
162 if (MATCH (none_lbl, spec))
|
|
|
163 files = DINFO_STRUCT_FILE_NONE;
|
|
|
164 else if (MATCH (any_lbl, spec))
|
|
|
165 files = DINFO_STRUCT_FILE_ANY;
|
|
|
166 else if (MATCH (sys_lbl, spec))
|
|
|
167 files = DINFO_STRUCT_FILE_SYS;
|
|
|
168 else if (MATCH (base_lbl, spec))
|
|
|
169 files = DINFO_STRUCT_FILE_BASE;
|
|
|
170 else
|
|
|
171 error ("argument %qs to %<-femit-struct-debug-detailed%> not recognized",
|
|
|
172 spec);
|
|
|
173
|
|
|
174 /* Effect the specification. */
|
|
|
175 if (usage == DINFO_USAGE_NUM_ENUMS)
|
|
|
176 {
|
|
|
177 if (ord)
|
|
|
178 {
|
|
|
179 debug_struct_ordinary[DINFO_USAGE_DFN] = files;
|
|
|
180 debug_struct_ordinary[DINFO_USAGE_DIR_USE] = files;
|
|
|
181 debug_struct_ordinary[DINFO_USAGE_IND_USE] = files;
|
|
|
182 }
|
|
|
183 if (gen)
|
|
|
184 {
|
|
|
185 debug_struct_generic[DINFO_USAGE_DFN] = files;
|
|
|
186 debug_struct_generic[DINFO_USAGE_DIR_USE] = files;
|
|
|
187 debug_struct_generic[DINFO_USAGE_IND_USE] = files;
|
|
|
188 }
|
|
|
189 }
|
|
|
190 else
|
|
|
191 {
|
|
|
192 if (ord)
|
|
|
193 debug_struct_ordinary[usage] = files;
|
|
|
194 if (gen)
|
|
|
195 debug_struct_generic[usage] = files;
|
|
|
196 }
|
|
|
197
|
|
|
198 if (*spec == ',')
|
|
|
199 set_struct_debug_option (spec+1);
|
|
|
200 else
|
|
|
201 {
|
|
|
202 /* No more -femit-struct-debug-detailed specifications.
|
|
|
203 Do final checks. */
|
|
|
204 if (*spec != '\0')
|
|
|
205 error ("argument %qs to %<-femit-struct-debug-detailed%> unknown",
|
|
|
206 spec);
|
|
|
207 if (debug_struct_ordinary[DINFO_USAGE_DIR_USE]
|
|
|
208 < debug_struct_ordinary[DINFO_USAGE_IND_USE]
|
|
|
209 || debug_struct_generic[DINFO_USAGE_DIR_USE]
|
|
|
210 < debug_struct_generic[DINFO_USAGE_IND_USE])
|
|
|
211 error ("%<-femit-struct-debug-detailed=dir:...%> must allow at least"
|
|
|
212 " as much as %<-femit-struct-debug-detailed=ind:...%>");
|
|
|
213 }
|
|
|
214 }
|
|
|
215
|
|
|
216 /* Find the base name of a path, stripping off both directories and
|
|
|
217 a single final extension. */
|
|
|
218 static int
|
|
|
219 base_of_path (const char *path, const char **base_out)
|
|
|
220 {
|
|
|
221 const char *base = path;
|
|
|
222 const char *dot = 0;
|
|
|
223 const char *p = path;
|
|
|
224 char c = *p;
|
|
|
225 while (c)
|
|
|
226 {
|
|
|
227 if (IS_DIR_SEPARATOR(c))
|
|
|
228 {
|
|
|
229 base = p + 1;
|
|
|
230 dot = 0;
|
|
|
231 }
|
|
|
232 else if (c == '.')
|
|
|
233 dot = p;
|
|
|
234 c = *++p;
|
|
|
235 }
|
|
|
236 if (!dot)
|
|
|
237 dot = p;
|
|
|
238 *base_out = base;
|
|
|
239 return dot - base;
|
|
|
240 }
|
|
|
241
|
|
|
242 /* Match the base name of a file to the base name of a compilation unit. */
|
|
|
243
|
|
|
244 static const char *main_input_basename;
|
|
|
245 static int main_input_baselength;
|
|
|
246
|
|
|
247 static int
|
|
|
248 matches_main_base (const char *path)
|
|
|
249 {
|
|
|
250 /* Cache the last query. */
|
|
|
251 static const char *last_path = NULL;
|
|
|
252 static int last_match = 0;
|
|
|
253 if (path != last_path)
|
|
|
254 {
|
|
|
255 const char *base;
|
|
|
256 int length = base_of_path (path, &base);
|
|
|
257 last_path = path;
|
|
|
258 last_match = (length == main_input_baselength
|
|
|
259 && memcmp (base, main_input_basename, length) == 0);
|
|
|
260 }
|
|
|
261 return last_match;
|
|
|
262 }
|
|
|
263
|
|
|
264 #ifdef DEBUG_DEBUG_STRUCT
|
|
|
265
|
|
|
266 static int
|
|
|
267 dump_struct_debug (tree type, enum debug_info_usage usage,
|
|
|
268 enum debug_struct_file criterion, int generic,
|
|
|
269 int matches, int result)
|
|
|
270 {
|
|
|
271 /* Find the type name. */
|
|
|
272 tree type_decl = TYPE_STUB_DECL (type);
|
|
|
273 tree t = type_decl;
|
|
|
274 const char *name = 0;
|
|
|
275 if (TREE_CODE (t) == TYPE_DECL)
|
|
|
276 t = DECL_NAME (t);
|
|
|
277 if (t)
|
|
|
278 name = IDENTIFIER_POINTER (t);
|
|
|
279
|
|
|
280 fprintf (stderr, " struct %d %s %s %s %s %d %p %s\n",
|
|
|
281 criterion,
|
|
|
282 DECL_IN_SYSTEM_HEADER (type_decl) ? "sys" : "usr",
|
|
|
283 matches ? "bas" : "hdr",
|
|
|
284 generic ? "gen" : "ord",
|
|
|
285 usage == DINFO_USAGE_DFN ? ";" :
|
|
|
286 usage == DINFO_USAGE_DIR_USE ? "." : "*",
|
|
|
287 result,
|
|
|
288 (void*) type_decl, name);
|
|
|
289 return result;
|
|
|
290 }
|
|
|
291 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
|
|
|
292 dump_struct_debug (type, usage, criterion, generic, matches, result)
|
|
|
293
|
|
|
294 #else
|
|
|
295
|
|
|
296 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
|
|
|
297 (result)
|
|
|
298
|
|
|
299 #endif
|
|
|
300
|
|
|
301
|
|
|
302 bool
|
|
|
303 should_emit_struct_debug (tree type, enum debug_info_usage usage)
|
|
|
304 {
|
|
|
305 enum debug_struct_file criterion;
|
|
|
306 tree type_decl;
|
|
|
307 bool generic = lang_hooks.types.generic_p (type);
|
|
|
308
|
|
|
309 if (generic)
|
|
|
310 criterion = debug_struct_generic[usage];
|
|
|
311 else
|
|
|
312 criterion = debug_struct_ordinary[usage];
|
|
|
313
|
|
|
314 if (criterion == DINFO_STRUCT_FILE_NONE)
|
|
|
315 return DUMP_GSTRUCT (type, usage, criterion, generic, false, false);
|
|
|
316 if (criterion == DINFO_STRUCT_FILE_ANY)
|
|
|
317 return DUMP_GSTRUCT (type, usage, criterion, generic, false, true);
|
|
|
318
|
|
|
319 type_decl = TYPE_STUB_DECL (type);
|
|
|
320
|
|
|
321 if (criterion == DINFO_STRUCT_FILE_SYS && DECL_IN_SYSTEM_HEADER (type_decl))
|
|
|
322 return DUMP_GSTRUCT (type, usage, criterion, generic, false, true);
|
|
|
323
|
|
|
324 if (matches_main_base (DECL_SOURCE_FILE (type_decl)))
|
|
|
325 return DUMP_GSTRUCT (type, usage, criterion, generic, true, true);
|
|
|
326 return DUMP_GSTRUCT (type, usage, criterion, generic, false, false);
|
|
|
327 }
|
|
|
328
|
|
|
329 /* Nonzero means use GNU-only extensions in the generated symbolic
|
|
|
330 debugging information. Currently, this only has an effect when
|
|
|
331 write_symbols is set to DBX_DEBUG, XCOFF_DEBUG, or DWARF_DEBUG. */
|
|
|
332 bool use_gnu_debug_info_extensions;
|
|
|
333
|
|
|
334 /* The default visibility for all symbols (unless overridden) */
|
|
|
335 enum symbol_visibility default_visibility = VISIBILITY_DEFAULT;
|
|
|
336
|
|
|
337 /* Global visibility options. */
|
|
|
338 struct visibility_flags visibility_options;
|
|
|
339
|
|
|
340 /* What to print when a switch has no documentation. */
|
|
|
341 #ifdef ENABLE_CHECKING
|
|
|
342 static const char undocumented_msg[] = N_("This switch lacks documentation");
|
|
|
343 #else
|
|
|
344 static const char undocumented_msg[] = "";
|
|
|
345 #endif
|
|
|
346
|
|
|
347 /* Used for bookkeeping on whether user set these flags so
|
|
|
348 -fprofile-use/-fprofile-generate does not use them. */
|
|
|
349 static bool profile_arc_flag_set, flag_profile_values_set;
|
|
|
350 static bool flag_unroll_loops_set, flag_tracer_set;
|
|
|
351 static bool flag_value_profile_transformations_set;
|
|
|
352 static bool flag_peel_loops_set, flag_branch_probabilities_set;
|
|
|
353 static bool flag_inline_functions_set, flag_ipa_cp_set, flag_ipa_cp_clone_set;
|
|
|
354 static bool flag_predictive_commoning_set, flag_unswitch_loops_set, flag_gcse_after_reload_set;
|
|
|
355
|
|
|
356 /* Functions excluded from profiling. */
|
|
|
357
|
|
|
358 typedef char *char_p; /* For DEF_VEC_P. */
|
|
|
359 DEF_VEC_P(char_p);
|
|
|
360 DEF_VEC_ALLOC_P(char_p,heap);
|
|
|
361
|
|
|
362 static VEC(char_p,heap) *flag_instrument_functions_exclude_functions;
|
|
|
363 static VEC(char_p,heap) *flag_instrument_functions_exclude_files;
|
|
|
364
|
|
|
365 typedef const char *const_char_p; /* For DEF_VEC_P. */
|
|
|
366 DEF_VEC_P(const_char_p);
|
|
|
367 DEF_VEC_ALLOC_P(const_char_p,heap);
|
|
|
368
|
|
|
369 static VEC(const_char_p,heap) *ignored_options;
|
|
|
370
|
|
|
371 /* Input file names. */
|
|
|
372 const char **in_fnames;
|
|
|
373 unsigned num_in_fnames;
|
|
|
374
|
|
|
375 static int common_handle_option (size_t scode, const char *arg, int value,
|
|
|
376 unsigned int lang_mask);
|
|
|
377 static void handle_param (const char *);
|
|
|
378 static void set_Wextra (int);
|
|
|
379 static unsigned int handle_option (const char **argv, unsigned int lang_mask);
|
|
|
380 static char *write_langs (unsigned int lang_mask);
|
|
|
381 static void complain_wrong_lang (const char *, const struct cl_option *,
|
|
|
382 unsigned int lang_mask);
|
|
|
383 static void handle_options (unsigned int, const char **, unsigned int);
|
|
|
384 static void set_debug_level (enum debug_info_type type, int extended,
|
|
|
385 const char *arg);
|
|
|
386
|
|
|
387 /* If ARG is a non-negative integer made up solely of digits, return its
|
|
|
388 value, otherwise return -1. */
|
|
|
389 static int
|
|
|
390 integral_argument (const char *arg)
|
|
|
391 {
|
|
|
392 const char *p = arg;
|
|
|
393
|
|
|
394 while (*p && ISDIGIT (*p))
|
|
|
395 p++;
|
|
|
396
|
|
|
397 if (*p == '\0')
|
|
|
398 return atoi (arg);
|
|
|
399
|
|
|
400 return -1;
|
|
|
401 }
|
|
|
402
|
|
|
403 /* Return a malloced slash-separated list of languages in MASK. */
|
|
|
404 static char *
|
|
|
405 write_langs (unsigned int mask)
|
|
|
406 {
|
|
|
407 unsigned int n = 0, len = 0;
|
|
|
408 const char *lang_name;
|
|
|
409 char *result;
|
|
|
410
|
|
|
411 for (n = 0; (lang_name = lang_names[n]) != 0; n++)
|
|
|
412 if (mask & (1U << n))
|
|
|
413 len += strlen (lang_name) + 1;
|
|
|
414
|
|
|
415 result = XNEWVEC (char, len);
|
|
|
416 len = 0;
|
|
|
417 for (n = 0; (lang_name = lang_names[n]) != 0; n++)
|
|
|
418 if (mask & (1U << n))
|
|
|
419 {
|
|
|
420 if (len)
|
|
|
421 result[len++] = '/';
|
|
|
422 strcpy (result + len, lang_name);
|
|
|
423 len += strlen (lang_name);
|
|
|
424 }
|
|
|
425
|
|
|
426 result[len] = 0;
|
|
|
427
|
|
|
428 return result;
|
|
|
429 }
|
|
|
430
|
|
|
431 /* Complain that switch OPT_INDEX does not apply to this front end. */
|
|
|
432 static void
|
|
|
433 complain_wrong_lang (const char *text, const struct cl_option *option,
|
|
|
434 unsigned int lang_mask)
|
|
|
435 {
|
|
|
436 char *ok_langs, *bad_lang;
|
|
|
437
|
|
|
438 ok_langs = write_langs (option->flags);
|
|
|
439 bad_lang = write_langs (lang_mask);
|
|
|
440
|
|
|
441 /* Eventually this should become a hard error IMO. */
|
|
|
442 warning (0, "command line option \"%s\" is valid for %s but not for %s",
|
|
|
443 text, ok_langs, bad_lang);
|
|
|
444
|
|
|
445 free (ok_langs);
|
|
|
446 free (bad_lang);
|
|
|
447 }
|
|
|
448
|
|
|
449 /* Buffer the unknown option described by the string OPT. Currently,
|
|
|
450 we only complain about unknown -Wno-* options if they may have
|
|
|
451 prevented a diagnostic. Otherwise, we just ignore them.
|
|
|
452 Note that if we do complain, it is only as a warning, not an error;
|
|
|
453 passing the compiler an unrecognised -Wno-* option should never
|
|
|
454 change whether the compilation succeeds or fails. */
|
|
|
455
|
|
|
456 static void postpone_unknown_option_warning(const char *opt)
|
|
|
457 {
|
|
|
458 VEC_safe_push (const_char_p, heap, ignored_options, opt);
|
|
|
459 }
|
|
|
460
|
|
|
461 /* Produce a warning for each option previously buffered. */
|
|
|
462
|
|
|
463 void print_ignored_options (void)
|
|
|
464 {
|
|
|
465 location_t saved_loc = input_location;
|
|
|
466
|
|
|
467 input_location = 0;
|
|
|
468
|
|
|
469 while (!VEC_empty (const_char_p, ignored_options))
|
|
|
470 {
|
|
|
471 const char *opt;
|
|
|
472 opt = VEC_pop (const_char_p, ignored_options);
|
|
|
473 warning (0, "unrecognized command line option \"%s\"", opt);
|
|
|
474 }
|
|
|
475
|
|
|
476 input_location = saved_loc;
|
|
|
477 }
|
|
|
478
|
|
|
479 /* Handle the switch beginning at ARGV for the language indicated by
|
|
|
480 LANG_MASK. Returns the number of switches consumed. */
|
|
|
481 static unsigned int
|
|
|
482 handle_option (const char **argv, unsigned int lang_mask)
|
|
|
483 {
|
|
|
484 size_t opt_index;
|
|
|
485 const char *opt, *arg = 0;
|
|
|
486 char *dup = 0;
|
|
|
487 int value = 1;
|
|
|
488 unsigned int result = 0;
|
|
|
489 const struct cl_option *option;
|
|
|
490
|
|
|
491 opt = argv[0];
|
|
|
492
|
|
|
493 opt_index = find_opt (opt + 1, lang_mask | CL_COMMON | CL_TARGET);
|
|
|
494 if (opt_index == cl_options_count
|
|
|
495 && (opt[1] == 'W' || opt[1] == 'f' || opt[1] == 'm')
|
|
|
496 && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-')
|
|
|
497 {
|
|
|
498 /* Drop the "no-" from negative switches. */
|
|
|
499 size_t len = strlen (opt) - 3;
|
|
|
500
|
|
|
501 dup = XNEWVEC (char, len + 1);
|
|
|
502 dup[0] = '-';
|
|
|
503 dup[1] = opt[1];
|
|
|
504 memcpy (dup + 2, opt + 5, len - 2 + 1);
|
|
|
505 opt = dup;
|
|
|
506 value = 0;
|
|
|
507 opt_index = find_opt (opt + 1, lang_mask | CL_COMMON | CL_TARGET);
|
|
|
508 if (opt_index == cl_options_count && opt[1] == 'W')
|
|
|
509 {
|
|
|
510 /* We don't generate warnings for unknown -Wno-* options
|
|
|
511 unless we issue diagnostics. */
|
|
|
512 postpone_unknown_option_warning (argv[0]);
|
|
|
513 result = 1;
|
|
|
514 goto done;
|
|
|
515 }
|
|
|
516 }
|
|
|
517
|
|
|
518 if (opt_index == cl_options_count)
|
|
|
519 goto done;
|
|
|
520
|
|
|
521 option = &cl_options[opt_index];
|
|
|
522
|
|
|
523 /* Reject negative form of switches that don't take negatives as
|
|
|
524 unrecognized. */
|
|
|
525 if (!value && (option->flags & CL_REJECT_NEGATIVE))
|
|
|
526 goto done;
|
|
|
527
|
|
|
528 /* We've recognized this switch. */
|
|
|
529 result = 1;
|
|
|
530
|
|
|
531 /* Check to see if the option is disabled for this configuration. */
|
|
|
532 if (option->flags & CL_DISABLED)
|
|
|
533 {
|
|
|
534 error ("command line option %qs"
|
|
|
535 " is not supported by this configuration", opt);
|
|
|
536 goto done;
|
|
|
537 }
|
|
|
538
|
|
|
539 /* Sort out any argument the switch takes. */
|
|
|
540 if (option->flags & CL_JOINED)
|
|
|
541 {
|
|
|
542 /* Have arg point to the original switch. This is because
|
|
|
543 some code, such as disable_builtin_function, expects its
|
|
|
544 argument to be persistent until the program exits. */
|
|
|
545 arg = argv[0] + cl_options[opt_index].opt_len + 1;
|
|
|
546 if (!value)
|
|
|
547 arg += strlen ("no-");
|
|
|
548
|
|
|
549 if (*arg == '\0' && !(option->flags & CL_MISSING_OK))
|
|
|
550 {
|
|
|
551 if (option->flags & CL_SEPARATE)
|
|
|
552 {
|
|
|
553 arg = argv[1];
|
|
|
554 result = 2;
|
|
|
555 }
|
|
|
556 else
|
|
|
557 /* Missing argument. */
|
|
|
558 arg = NULL;
|
|
|
559 }
|
|
|
560 }
|
|
|
561 else if (option->flags & CL_SEPARATE)
|
|
|
562 {
|
|
|
563 arg = argv[1];
|
|
|
564 result = 2;
|
|
|
565 }
|
|
|
566
|
|
|
567 /* Now we've swallowed any potential argument, complain if this
|
|
|
568 is a switch for a different front end. */
|
|
|
569 if (!(option->flags & (lang_mask | CL_COMMON | CL_TARGET)))
|
|
|
570 {
|
|
|
571 complain_wrong_lang (argv[0], option, lang_mask);
|
|
|
572 goto done;
|
|
|
573 }
|
|
|
574 else if ((option->flags & CL_TARGET)
|
|
|
575 && (option->flags & CL_LANG_ALL)
|
|
|
576 && !(option->flags & lang_mask))
|
|
|
577 {
|
|
|
578 /* Complain for target flag language mismatches if any languages
|
|
|
579 are specified. */
|
|
|
580 complain_wrong_lang (argv[0], option, lang_mask);
|
|
|
581 goto done;
|
|
|
582 }
|
|
|
583
|
|
|
584 if (arg == NULL && (option->flags & (CL_JOINED | CL_SEPARATE)))
|
|
|
585 {
|
|
|
586 if (!lang_hooks.missing_argument (opt, opt_index))
|
|
|
587 error ("missing argument to \"%s\"", opt);
|
|
|
588 goto done;
|
|
|
589 }
|
|
|
590
|
|
|
591 /* If the switch takes an integer, convert it. */
|
|
|
592 if (arg && (option->flags & CL_UINTEGER))
|
|
|
593 {
|
|
|
594 value = integral_argument (arg);
|
|
|
595 if (value == -1)
|
|
|
596 {
|
|
|
597 error ("argument to \"%s\" should be a non-negative integer",
|
|
|
598 option->opt_text);
|
|
|
599 goto done;
|
|
|
600 }
|
|
|
601 }
|
|
|
602
|
|
|
603 if (option->flag_var)
|
|
|
604 switch (option->var_type)
|
|
|
605 {
|
|
|
606 case CLVC_BOOLEAN:
|
|
|
607 *(int *) option->flag_var = value;
|
|
|
608 break;
|
|
|
609
|
|
|
610 case CLVC_EQUAL:
|
|
|
611 *(int *) option->flag_var = (value
|
|
|
612 ? option->var_value
|
|
|
613 : !option->var_value);
|
|
|
614 break;
|
|
|
615
|
|
|
616 case CLVC_BIT_CLEAR:
|
|
|
617 case CLVC_BIT_SET:
|
|
|
618 if ((value != 0) == (option->var_type == CLVC_BIT_SET))
|
|
|
619 *(int *) option->flag_var |= option->var_value;
|
|
|
620 else
|
|
|
621 *(int *) option->flag_var &= ~option->var_value;
|
|
|
622 if (option->flag_var == &target_flags)
|
|
|
623 target_flags_explicit |= option->var_value;
|
|
|
624 break;
|
|
|
625
|
|
|
626 case CLVC_STRING:
|
|
|
627 *(const char **) option->flag_var = arg;
|
|
|
628 break;
|
|
|
629 }
|
|
|
630
|
|
|
631 if (option->flags & lang_mask)
|
|
|
632 if (lang_hooks.handle_option (opt_index, arg, value) == 0)
|
|
|
633 result = 0;
|
|
|
634
|
|
|
635 if (result && (option->flags & CL_COMMON))
|
|
|
636 if (common_handle_option (opt_index, arg, value, lang_mask) == 0)
|
|
|
637 result = 0;
|
|
|
638
|
|
|
639 if (result && (option->flags & CL_TARGET))
|
|
|
640 if (!targetm.handle_option (opt_index, arg, value))
|
|
|
641 result = 0;
|
|
|
642
|
|
|
643 done:
|
|
|
644 if (dup)
|
|
|
645 free (dup);
|
|
|
646 return result;
|
|
|
647 }
|
|
|
648
|
|
|
649 /* Handle FILENAME from the command line. */
|
|
|
650 static void
|
|
|
651 add_input_filename (const char *filename)
|
|
|
652 {
|
|
|
653 num_in_fnames++;
|
|
|
654 in_fnames = XRESIZEVEC (const char *, in_fnames, num_in_fnames);
|
|
|
655 in_fnames[num_in_fnames - 1] = filename;
|
|
|
656 }
|
|
|
657
|
|
|
658 /* Add comma-separated strings to a char_p vector. */
|
|
|
659
|
|
|
660 static void
|
|
|
661 add_comma_separated_to_vector (VEC(char_p,heap) **pvec, const char* arg)
|
|
|
662 {
|
|
|
663 char *tmp;
|
|
|
664 char *r;
|
|
|
665 char *w;
|
|
|
666 char *token_start;
|
|
|
667
|
|
|
668 /* We never free this string. */
|
|
|
669 tmp = xstrdup (arg);
|
|
|
670
|
|
|
671 r = tmp;
|
|
|
672 w = tmp;
|
|
|
673 token_start = tmp;
|
|
|
674
|
|
|
675 while (*r != '\0')
|
|
|
676 {
|
|
|
677 if (*r == ',')
|
|
|
678 {
|
|
|
679 *w++ = '\0';
|
|
|
680 ++r;
|
|
|
681 VEC_safe_push (char_p, heap, *pvec, token_start);
|
|
|
682 token_start = w;
|
|
|
683 }
|
|
|
684 if (*r == '\\' && r[1] == ',')
|
|
|
685 {
|
|
|
686 *w++ = ',';
|
|
|
687 r += 2;
|
|
|
688 }
|
|
|
689 else
|
|
|
690 *w++ = *r++;
|
|
|
691 }
|
|
|
692 if (*token_start != '\0')
|
|
|
693 VEC_safe_push (char_p, heap, *pvec, token_start);
|
|
|
694 }
|
|
|
695
|
|
|
696 /* Return whether we should exclude FNDECL from instrumentation. */
|
|
|
697
|
|
|
698 bool
|
|
|
699 flag_instrument_functions_exclude_p (tree fndecl)
|
|
|
700 {
|
|
|
701 if (VEC_length (char_p, flag_instrument_functions_exclude_functions) > 0)
|
|
|
702 {
|
|
|
703 const char *name;
|
|
|
704 int i;
|
|
|
705 char *s;
|
|
|
706
|
|
|
707 name = lang_hooks.decl_printable_name (fndecl, 0);
|
|
|
708 for (i = 0;
|
|
|
709 VEC_iterate (char_p, flag_instrument_functions_exclude_functions,
|
|
|
710 i, s);
|
|
|
711 ++i)
|
|
|
712 {
|
|
|
713 if (strstr (name, s) != NULL)
|
|
|
714 return true;
|
|
|
715 }
|
|
|
716 }
|
|
|
717
|
|
|
718 if (VEC_length (char_p, flag_instrument_functions_exclude_files) > 0)
|
|
|
719 {
|
|
|
720 const char *name;
|
|
|
721 int i;
|
|
|
722 char *s;
|
|
|
723
|
|
|
724 name = DECL_SOURCE_FILE (fndecl);
|
|
|
725 for (i = 0;
|
|
|
726 VEC_iterate (char_p, flag_instrument_functions_exclude_files, i, s);
|
|
|
727 ++i)
|
|
|
728 {
|
|
|
729 if (strstr (name, s) != NULL)
|
|
|
730 return true;
|
|
|
731 }
|
|
|
732 }
|
|
|
733
|
|
|
734 return false;
|
|
|
735 }
|
|
|
736
|
|
|
737
|
|
|
738 /* Decode and handle the vector of command line options. LANG_MASK
|
|
|
739 contains has a single bit set representing the current
|
|
|
740 language. */
|
|
|
741 static void
|
|
|
742 handle_options (unsigned int argc, const char **argv, unsigned int lang_mask)
|
|
|
743 {
|
|
|
744 unsigned int n, i;
|
|
|
745
|
|
|
746 for (i = 1; i < argc; i += n)
|
|
|
747 {
|
|
|
748 const char *opt = argv[i];
|
|
|
749
|
|
|
750 /* Interpret "-" or a non-switch as a file name. */
|
|
|
751 if (opt[0] != '-' || opt[1] == '\0')
|
|
|
752 {
|
|
|
753 if (main_input_filename == NULL)
|
|
|
754 {
|
|
|
755 main_input_filename = opt;
|
|
|
756 main_input_baselength
|
|
|
757 = base_of_path (main_input_filename, &main_input_basename);
|
|
|
758 }
|
|
|
759 add_input_filename (opt);
|
|
|
760 n = 1;
|
|
|
761 continue;
|
|
|
762 }
|
|
|
763
|
|
|
764 n = handle_option (argv + i, lang_mask);
|
|
|
765
|
|
|
766 if (!n)
|
|
|
767 {
|
|
|
768 n = 1;
|
|
|
769 error ("unrecognized command line option \"%s\"", opt);
|
|
|
770 }
|
|
|
771 }
|
|
|
772 }
|
|
|
773
|
|
|
774 /* Parse command line options and set default flag values. Do minimal
|
|
|
775 options processing. */
|
|
|
776 void
|
|
|
777 decode_options (unsigned int argc, const char **argv)
|
|
|
778 {
|
|
|
779 static bool first_time_p = true;
|
|
|
780 static int initial_max_aliased_vops;
|
|
|
781 static int initial_avg_aliased_vops;
|
|
|
782 static int initial_min_crossjump_insns;
|
|
|
783 static int initial_max_fields_for_field_sensitive;
|
|
|
784 static int initial_loop_invariant_max_bbs_in_loop;
|
|
|
785 static unsigned int initial_lang_mask;
|
|
|
786
|
|
|
787 unsigned int i, lang_mask;
|
|
|
788 int opt1;
|
|
|
789 int opt2;
|
|
|
790 int opt3;
|
|
|
791 int opt1_max;
|
|
|
792
|
|
|
793 if (first_time_p)
|
|
|
794 {
|
|
|
795 /* Perform language-specific options initialization. */
|
|
|
796 initial_lang_mask = lang_mask = lang_hooks.init_options (argc, argv);
|
|
|
797
|
|
|
798 lang_hooks.initialize_diagnostics (global_dc);
|
|
|
799
|
|
|
800 /* Save initial values of parameters we reset. */
|
|
|
801 initial_max_aliased_vops = MAX_ALIASED_VOPS;
|
|
|
802 initial_avg_aliased_vops = AVG_ALIASED_VOPS;
|
|
|
803 initial_min_crossjump_insns
|
|
|
804 = compiler_params[PARAM_MIN_CROSSJUMP_INSNS].value;
|
|
|
805 initial_max_fields_for_field_sensitive
|
|
|
806 = compiler_params[PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE].value;
|
|
|
807 initial_loop_invariant_max_bbs_in_loop
|
|
|
808 = compiler_params[PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP].value;
|
|
|
809 }
|
|
|
810 else
|
|
|
811 lang_mask = initial_lang_mask;
|
|
|
812
|
|
|
813 /* Scan to see what optimization level has been specified. That will
|
|
|
814 determine the default value of many flags. */
|
|
|
815 for (i = 1; i < argc; i++)
|
|
|
816 {
|
|
|
817 if (!strcmp (argv[i], "-O"))
|
|
|
818 {
|
|
|
819 optimize = 1;
|
|
|
820 optimize_size = 0;
|
|
|
821 }
|
|
|
822 else if (argv[i][0] == '-' && argv[i][1] == 'O')
|
|
|
823 {
|
|
|
824 /* Handle -Os, -O2, -O3, -O69, ... */
|
|
|
825 const char *p = &argv[i][2];
|
|
|
826
|
|
|
827 if ((p[0] == 's') && (p[1] == 0))
|
|
|
828 {
|
|
|
829 optimize_size = 1;
|
|
|
830
|
|
|
831 /* Optimizing for size forces optimize to be 2. */
|
|
|
832 optimize = 2;
|
|
|
833 }
|
|
|
834 else
|
|
|
835 {
|
|
|
836 const int optimize_val = read_integral_parameter (p, p - 2, -1);
|
|
|
837 if (optimize_val != -1)
|
|
|
838 {
|
|
|
839 optimize = optimize_val;
|
|
|
840 optimize_size = 0;
|
|
|
841 }
|
|
|
842 }
|
|
|
843 }
|
|
|
844 }
|
|
|
845
|
|
|
846 /* Use priority coloring if cover classes is not defined for the
|
|
|
847 target. */
|
|
|
848 if (targetm.ira_cover_classes == NULL)
|
|
|
849 flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
|
|
|
850
|
|
|
851 /* -O1 optimizations. */
|
|
|
852 opt1 = (optimize >= 1);
|
|
|
853 flag_defer_pop = opt1;
|
|
|
854 #ifdef DELAY_SLOTS
|
|
|
855 flag_delayed_branch = opt1;
|
|
|
856 #endif
|
|
|
857 #ifdef CAN_DEBUG_WITHOUT_FP
|
|
|
858 flag_omit_frame_pointer = opt1;
|
|
|
859 #endif
|
|
|
860 flag_guess_branch_prob = opt1;
|
|
|
861 flag_cprop_registers = opt1;
|
|
|
862 flag_if_conversion = opt1;
|
|
|
863 flag_if_conversion2 = opt1;
|
|
|
864 flag_ipa_pure_const = opt1;
|
|
|
865 flag_ipa_reference = opt1;
|
|
|
866 flag_merge_constants = opt1;
|
|
|
867 flag_split_wide_types = opt1;
|
|
|
868 flag_tree_ccp = opt1;
|
|
|
869 flag_tree_dce = opt1;
|
|
|
870 flag_tree_dom = opt1;
|
|
|
871 flag_tree_dse = opt1;
|
|
|
872 flag_tree_ter = opt1;
|
|
|
873 flag_tree_sra = opt1;
|
|
|
874 flag_tree_copyrename = opt1;
|
|
|
875 flag_tree_fre = opt1;
|
|
|
876 flag_tree_copy_prop = opt1;
|
|
|
877 flag_tree_sink = opt1;
|
|
|
878 flag_tree_ch = opt1;
|
|
|
879
|
|
|
880 /* -O2 optimizations. */
|
|
|
881 opt2 = (optimize >= 2);
|
|
|
882 flag_inline_small_functions = opt2;
|
|
|
883 flag_indirect_inlining = opt2;
|
|
|
884 flag_thread_jumps = opt2;
|
|
|
885 flag_crossjumping = opt2;
|
|
|
886 flag_optimize_sibling_calls = opt2;
|
|
|
887 flag_forward_propagate = opt2;
|
|
|
888 flag_cse_follow_jumps = opt2;
|
|
|
889 flag_gcse = opt2;
|
|
|
890 flag_expensive_optimizations = opt2;
|
|
|
891 flag_rerun_cse_after_loop = opt2;
|
|
|
892 flag_caller_saves = opt2;
|
|
|
893 flag_peephole2 = opt2;
|
|
|
894 #ifdef INSN_SCHEDULING
|
|
|
895 flag_schedule_insns = opt2;
|
|
|
896 flag_schedule_insns_after_reload = opt2;
|
|
|
897 #endif
|
|
|
898 flag_regmove = opt2;
|
|
|
899 flag_strict_aliasing = opt2;
|
|
|
900 flag_strict_overflow = opt2;
|
|
|
901 flag_delete_null_pointer_checks = opt2;
|
|
|
902 flag_reorder_blocks = opt2;
|
|
|
903 flag_reorder_functions = opt2;
|
|
|
904 flag_tree_vrp = opt2;
|
|
|
905 flag_tree_builtin_call_dce = opt2;
|
|
|
906 flag_tree_pre = opt2;
|
|
|
907 flag_tree_switch_conversion = 1;
|
|
|
908 flag_ipa_cp = opt2;
|
|
|
909
|
|
|
910 /* Allow more virtual operators to increase alias precision. */
|
|
|
911
|
|
|
912 set_param_value ("max-aliased-vops",
|
|
|
913 (opt2) ? 500 : initial_max_aliased_vops);
|
|
|
914
|
|
|
915 /* Track fields in field-sensitive alias analysis. */
|
|
|
916 set_param_value ("max-fields-for-field-sensitive",
|
|
|
917 (opt2) ? 100 : initial_max_fields_for_field_sensitive);
|
|
|
918
|
|
|
919 /* For -O1 only do loop invariant motion for very small loops. */
|
|
|
920 set_param_value ("loop-invariant-max-bbs-in-loop",
|
|
|
921 (opt2) ? initial_loop_invariant_max_bbs_in_loop : 1000);
|
|
|
922
|
|
|
923 /* -O3 optimizations. */
|
|
|
924 opt3 = (optimize >= 3);
|
|
|
925 flag_predictive_commoning = opt3;
|
|
|
926 flag_inline_functions = opt3;
|
|
|
927 flag_unswitch_loops = opt3;
|
|
|
928 flag_gcse_after_reload = opt3;
|
|
|
929 flag_tree_vectorize = opt3;
|
|
|
930 flag_ipa_cp_clone = opt3;
|
|
|
931 if (flag_ipa_cp_clone)
|
|
|
932 flag_ipa_cp = 1;
|
|
|
933
|
|
|
934 /* Allow even more virtual operators. Max-aliased-vops was set above for
|
|
|
935 -O2, so don't reset it unless we are at -O3. */
|
|
|
936 if (opt3)
|
|
|
937 set_param_value ("max-aliased-vops", 1000);
|
|
|
938
|
|
|
939 set_param_value ("avg-aliased-vops", (opt3) ? 3 : initial_avg_aliased_vops);
|
|
|
940
|
|
|
941 /* Just -O1/-O0 optimizations. */
|
|
|
942 opt1_max = (optimize <= 1);
|
|
|
943 align_loops = opt1_max;
|
|
|
944 align_jumps = opt1_max;
|
|
|
945 align_labels = opt1_max;
|
|
|
946 align_functions = opt1_max;
|
|
|
947
|
|
|
948 if (optimize_size)
|
|
|
949 {
|
|
|
950 /* Inlining of functions reducing size is a good idea regardless of them
|
|
|
951 being declared inline. */
|
|
|
952 flag_inline_functions = 1;
|
|
|
953
|
|
|
954 /* Basic optimization options. */
|
|
|
955 optimize_size = 1;
|
|
|
956 if (optimize > 2)
|
|
|
957 optimize = 2;
|
|
|
958
|
|
|
959 /* We want to crossjump as much as possible. */
|
|
|
960 set_param_value ("min-crossjump-insns", 1);
|
|
|
961 }
|
|
|
962 else
|
|
|
963 set_param_value ("min-crossjump-insns", initial_min_crossjump_insns);
|
|
|
964
|
|
|
965 if (first_time_p)
|
|
|
966 {
|
|
|
967 /* Initialize whether `char' is signed. */
|
|
|
968 flag_signed_char = DEFAULT_SIGNED_CHAR;
|
|
|
969 /* Set this to a special "uninitialized" value. The actual default is
|
|
|
970 set after target options have been processed. */
|
|
|
971 flag_short_enums = 2;
|
|
|
972
|
|
|
973 /* Initialize target_flags before OPTIMIZATION_OPTIONS so the latter can
|
|
|
974 modify it. */
|
|
|
975 target_flags = targetm.default_target_flags;
|
|
|
976
|
|
|
977 /* Some targets have ABI-specified unwind tables. */
|
|
|
978 flag_unwind_tables = targetm.unwind_tables_default;
|
|
|
979 }
|
|
|
980
|
|
|
981 #ifdef OPTIMIZATION_OPTIONS
|
|
|
982 /* Allow default optimizations to be specified on a per-machine basis. */
|
|
|
983 OPTIMIZATION_OPTIONS (optimize, optimize_size);
|
|
|
984 #endif
|
|
|
985
|
|
|
986 handle_options (argc, argv, lang_mask);
|
|
|
987
|
|
|
988 /* Handle related options for unit-at-a-time, toplevel-reorder, and
|
|
|
989 section-anchors. */
|
|
|
990 if (!flag_unit_at_a_time)
|
|
|
991 {
|
|
|
992 if (flag_section_anchors == 1)
|
|
|
993 error ("Section anchors must be disabled when unit-at-a-time "
|
|
|
994 "is disabled.");
|
|
|
995 flag_section_anchors = 0;
|
|
|
996 if (flag_toplevel_reorder == 1)
|
|
|
997 error ("Toplevel reorder must be disabled when unit-at-a-time "
|
|
|
998 "is disabled.");
|
|
|
999 flag_toplevel_reorder = 0;
|
|
|
1000 }
|
|
|
1001 /* Unless the user has asked for section anchors, we disable toplevel
|
|
|
1002 reordering at -O0 to disable transformations that might be surprising
|
|
|
1003 to end users and to get -fno-toplevel-reorder tested. */
|
|
|
1004 if (!optimize && flag_toplevel_reorder == 2 && flag_section_anchors != 1)
|
|
|
1005 {
|
|
|
1006 flag_toplevel_reorder = 0;
|
|
|
1007 flag_section_anchors = 0;
|
|
|
1008 }
|
|
|
1009 if (!flag_toplevel_reorder)
|
|
|
1010 {
|
|
|
1011 if (flag_section_anchors == 1)
|
|
|
1012 error ("section anchors must be disabled when toplevel reorder"
|
|
|
1013 " is disabled");
|
|
|
1014 flag_section_anchors = 0;
|
|
|
1015 }
|
|
|
1016
|
|
|
1017 if (first_time_p)
|
|
|
1018 {
|
|
|
1019 if (flag_pie)
|
|
|
1020 flag_pic = flag_pie;
|
|
|
1021 if (flag_pic && !flag_pie)
|
|
|
1022 flag_shlib = 1;
|
|
|
1023 }
|
|
|
1024
|
|
|
1025 if (optimize == 0)
|
|
|
1026 {
|
|
|
1027 /* Inlining does not work if not optimizing,
|
|
|
1028 so force it not to be done. */
|
|
|
1029 warn_inline = 0;
|
|
|
1030 flag_no_inline = 1;
|
|
|
1031 }
|
|
|
1032
|
|
|
1033 /* The optimization to partition hot and cold basic blocks into separate
|
|
|
1034 sections of the .o and executable files does not work (currently)
|
|
|
1035 with exception handling. This is because there is no support for
|
|
|
1036 generating unwind info. If flag_exceptions is turned on we need to
|
|
|
1037 turn off the partitioning optimization. */
|
|
|
1038
|
|
|
1039 if (flag_exceptions && flag_reorder_blocks_and_partition)
|
|
|
1040 {
|
|
|
1041 inform (input_location,
|
|
|
1042 "-freorder-blocks-and-partition does not work with exceptions");
|
|
|
1043 flag_reorder_blocks_and_partition = 0;
|
|
|
1044 flag_reorder_blocks = 1;
|
|
|
1045 }
|
|
|
1046
|
|
|
1047 /* If user requested unwind info, then turn off the partitioning
|
|
|
1048 optimization. */
|
|
|
1049
|
|
|
1050 if (flag_unwind_tables && ! targetm.unwind_tables_default
|
|
|
1051 && flag_reorder_blocks_and_partition)
|
|
|
1052 {
|
|
|
1053 inform (input_location, "-freorder-blocks-and-partition does not support unwind info");
|
|
|
1054 flag_reorder_blocks_and_partition = 0;
|
|
|
1055 flag_reorder_blocks = 1;
|
|
|
1056 }
|
|
|
1057
|
|
|
1058 /* If the target requested unwind info, then turn off the partitioning
|
|
|
1059 optimization with a different message. Likewise, if the target does not
|
|
|
1060 support named sections. */
|
|
|
1061
|
|
|
1062 if (flag_reorder_blocks_and_partition
|
|
|
1063 && (!targetm.have_named_sections
|
|
|
1064 || (flag_unwind_tables && targetm.unwind_tables_default)))
|
|
|
1065 {
|
|
|
1066 inform (input_location,
|
|
|
1067 "-freorder-blocks-and-partition does not work on this architecture");
|
|
|
1068 flag_reorder_blocks_and_partition = 0;
|
|
|
1069 flag_reorder_blocks = 1;
|
|
|
1070 }
|
|
|
1071
|
|
|
1072 /* Pipelining of outer loops is only possible when general pipelining
|
|
|
1073 capabilities are requested. */
|
|
|
1074 if (!flag_sel_sched_pipelining)
|
|
|
1075 flag_sel_sched_pipelining_outer_loops = 0;
|
|
|
1076
|
|
|
1077 if (!targetm.ira_cover_classes
|
|
|
1078 && flag_ira_algorithm == IRA_ALGORITHM_CB)
|
|
|
1079 {
|
|
|
1080 inform (input_location,
|
|
|
1081 "-fira-algorithm=CB does not work on this architecture");
|
|
|
1082 flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
|
|
|
1083 }
|
|
|
1084
|
|
|
1085 /* Save the current optimization options if this is the first call. */
|
|
|
1086 if (first_time_p)
|
|
|
1087 {
|
|
|
1088 optimization_default_node = build_optimization_node ();
|
|
|
1089 optimization_current_node = optimization_default_node;
|
|
|
1090 first_time_p = false;
|
|
|
1091 }
|
|
|
1092 if (flag_conserve_stack)
|
|
|
1093 {
|
|
|
1094 if (!PARAM_SET_P (PARAM_LARGE_STACK_FRAME))
|
|
|
1095 PARAM_VALUE (PARAM_LARGE_STACK_FRAME) = 100;
|
|
|
1096 if (!PARAM_SET_P (PARAM_STACK_FRAME_GROWTH))
|
|
|
1097 PARAM_VALUE (PARAM_STACK_FRAME_GROWTH) = 40;
|
|
|
1098 }
|
|
|
1099
|
|
|
1100 }
|
|
|
1101
|
|
|
1102 #define LEFT_COLUMN 27
|
|
|
1103
|
|
|
1104 /* Output ITEM, of length ITEM_WIDTH, in the left column,
|
|
|
1105 followed by word-wrapped HELP in a second column. */
|
|
|
1106 static void
|
|
|
1107 wrap_help (const char *help,
|
|
|
1108 const char *item,
|
|
|
1109 unsigned int item_width,
|
|
|
1110 unsigned int columns)
|
|
|
1111 {
|
|
|
1112 unsigned int col_width = LEFT_COLUMN;
|
|
|
1113 unsigned int remaining, room, len;
|
|
|
1114
|
|
|
1115 remaining = strlen (help);
|
|
|
1116
|
|
|
1117 do
|
|
|
1118 {
|
|
|
1119 room = columns - 3 - MAX (col_width, item_width);
|
|
|
1120 if (room > columns)
|
|
|
1121 room = 0;
|
|
|
1122 len = remaining;
|
|
|
1123
|
|
|
1124 if (room < len)
|
|
|
1125 {
|
|
|
1126 unsigned int i;
|
|
|
1127
|
|
|
1128 for (i = 0; help[i]; i++)
|
|
|
1129 {
|
|
|
1130 if (i >= room && len != remaining)
|
|
|
1131 break;
|
|
|
1132 if (help[i] == ' ')
|
|
|
1133 len = i;
|
|
|
1134 else if ((help[i] == '-' || help[i] == '/')
|
|
|
1135 && help[i + 1] != ' '
|
|
|
1136 && i > 0 && ISALPHA (help[i - 1]))
|
|
|
1137 len = i + 1;
|
|
|
1138 }
|
|
|
1139 }
|
|
|
1140
|
|
|
1141 printf( " %-*.*s %.*s\n", col_width, item_width, item, len, help);
|
|
|
1142 item_width = 0;
|
|
|
1143 while (help[len] == ' ')
|
|
|
1144 len++;
|
|
|
1145 help += len;
|
|
|
1146 remaining -= len;
|
|
|
1147 }
|
|
|
1148 while (remaining);
|
|
|
1149 }
|
|
|
1150
|
|
|
1151 /* Print help for a specific front-end, etc. */
|
|
|
1152 static void
|
|
|
1153 print_filtered_help (unsigned int include_flags,
|
|
|
1154 unsigned int exclude_flags,
|
|
|
1155 unsigned int any_flags,
|
|
|
1156 unsigned int columns)
|
|
|
1157 {
|
|
|
1158 unsigned int i;
|
|
|
1159 const char *help;
|
|
|
1160 static char *printed = NULL;
|
|
|
1161 bool found = false;
|
|
|
1162 bool displayed = false;
|
|
|
1163
|
|
|
1164 if (include_flags == CL_PARAMS)
|
|
|
1165 {
|
|
|
1166 for (i = 0; i < LAST_PARAM; i++)
|
|
|
1167 {
|
|
|
1168 const char *param = compiler_params[i].option;
|
|
|
1169
|
|
|
1170 help = compiler_params[i].help;
|
|
|
1171 if (help == NULL || *help == '\0')
|
|
|
1172 {
|
|
|
1173 if (exclude_flags & CL_UNDOCUMENTED)
|
|
|
1174 continue;
|
|
|
1175 help = undocumented_msg;
|
|
|
1176 }
|
|
|
1177
|
|
|
1178 /* Get the translation. */
|
|
|
1179 help = _(help);
|
|
|
1180
|
|
|
1181 wrap_help (help, param, strlen (param), columns);
|
|
|
1182 }
|
|
|
1183 putchar ('\n');
|
|
|
1184 return;
|
|
|
1185 }
|
|
|
1186
|
|
|
1187 if (!printed)
|
|
|
1188 printed = XCNEWVAR (char, cl_options_count);
|
|
|
1189
|
|
|
1190 for (i = 0; i < cl_options_count; i++)
|
|
|
1191 {
|
|
|
1192 static char new_help[128];
|
|
|
1193 const struct cl_option *option = cl_options + i;
|
|
|
1194 unsigned int len;
|
|
|
1195 const char *opt;
|
|
|
1196 const char *tab;
|
|
|
1197
|
|
|
1198 if (include_flags == 0
|
|
|
1199 || ((option->flags & include_flags) != include_flags))
|
|
|
1200 {
|
|
|
1201 if ((option->flags & any_flags) == 0)
|
|
|
1202 continue;
|
|
|
1203 }
|
|
|
1204
|
|
|
1205 /* Skip unwanted switches. */
|
|
|
1206 if ((option->flags & exclude_flags) != 0)
|
|
|
1207 continue;
|
|
|
1208
|
|
|
1209 found = true;
|
|
|
1210 /* Skip switches that have already been printed. */
|
|
|
1211 if (printed[i])
|
|
|
1212 continue;
|
|
|
1213
|
|
|
1214 printed[i] = true;
|
|
|
1215
|
|
|
1216 help = option->help;
|
|
|
1217 if (help == NULL)
|
|
|
1218 {
|
|
|
1219 if (exclude_flags & CL_UNDOCUMENTED)
|
|
|
1220 continue;
|
|
|
1221 help = undocumented_msg;
|
|
|
1222 }
|
|
|
1223
|
|
|
1224 /* Get the translation. */
|
|
|
1225 help = _(help);
|
|
|
1226
|
|
|
1227 /* Find the gap between the name of the
|
|
|
1228 option and its descriptive text. */
|
|
|
1229 tab = strchr (help, '\t');
|
|
|
1230 if (tab)
|
|
|
1231 {
|
|
|
1232 len = tab - help;
|
|
|
1233 opt = help;
|
|
|
1234 help = tab + 1;
|
|
|
1235 }
|
|
|
1236 else
|
|
|
1237 {
|
|
|
1238 opt = option->opt_text;
|
|
|
1239 len = strlen (opt);
|
|
|
1240 }
|
|
|
1241
|
|
|
1242 /* With the -Q option enabled we change the descriptive text associated
|
|
|
1243 with an option to be an indication of its current setting. */
|
|
|
1244 if (!quiet_flag)
|
|
|
1245 {
|
|
|
1246 if (len < (LEFT_COLUMN + 2))
|
|
|
1247 strcpy (new_help, "\t\t");
|
|
|
1248 else
|
|
|
1249 strcpy (new_help, "\t");
|
|
|
1250
|
|
|
1251 if (option->flag_var != NULL)
|
|
|
1252 {
|
|
|
1253 if (option->flags & CL_JOINED)
|
|
|
1254 {
|
|
|
1255 if (option->var_type == CLVC_STRING)
|
|
|
1256 {
|
|
|
1257 if (* (const char **) option->flag_var != NULL)
|
|
|
1258 snprintf (new_help + strlen (new_help),
|
|
|
1259 sizeof (new_help) - strlen (new_help),
|
|
|
1260 * (const char **) option->flag_var);
|
|
|
1261 }
|
|
|
1262 else
|
|
|
1263 sprintf (new_help + strlen (new_help),
|
|
|
1264 "%#x", * (int *) option->flag_var);
|
|
|
1265 }
|
|
|
1266 else
|
|
|
1267 strcat (new_help, option_enabled (i)
|
|
|
1268 ? _("[enabled]") : _("[disabled]"));
|
|
|
1269 }
|
|
|
1270
|
|
|
1271 help = new_help;
|
|
|
1272 }
|
|
|
1273
|
|
|
1274 wrap_help (help, opt, len, columns);
|
|
|
1275 displayed = true;
|
|
|
1276 }
|
|
|
1277
|
|
|
1278 if (! found)
|
|
|
1279 {
|
|
|
1280 unsigned int langs = include_flags & CL_LANG_ALL;
|
|
|
1281
|
|
|
1282 if (langs == 0)
|
|
|
1283 printf (_(" No options with the desired characteristics were found\n"));
|
|
|
1284 else
|
|
|
1285 {
|
|
|
1286 unsigned int i;
|
|
|
1287
|
|
|
1288 /* PR 31349: Tell the user how to see all of the
|
|
|
1289 options supported by a specific front end. */
|
|
|
1290 for (i = 0; (1U << i) < CL_LANG_ALL; i ++)
|
|
|
1291 if ((1U << i) & langs)
|
|
|
1292 printf (_(" None found. Use --help=%s to show *all* the options supported by the %s front-end\n"),
|
|
|
1293 lang_names[i], lang_names[i]);
|
|
|
1294 }
|
|
|
1295
|
|
|
1296 }
|
|
|
1297 else if (! displayed)
|
|
|
1298 printf (_(" All options with the desired characteristics have already been displayed\n"));
|
|
|
1299
|
|
|
1300 putchar ('\n');
|
|
|
1301 }
|
|
|
1302
|
|
|
1303 /* Display help for a specified type of option.
|
|
|
1304 The options must have ALL of the INCLUDE_FLAGS set
|
|
|
1305 ANY of the flags in the ANY_FLAGS set
|
|
|
1306 and NONE of the EXCLUDE_FLAGS set. */
|
|
|
1307 static void
|
|
|
1308 print_specific_help (unsigned int include_flags,
|
|
|
1309 unsigned int exclude_flags,
|
|
|
1310 unsigned int any_flags)
|
|
|
1311 {
|
|
|
1312 unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
|
|
|
1313 const char * description = NULL;
|
|
|
1314 const char * descrip_extra = "";
|
|
|
1315 size_t i;
|
|
|
1316 unsigned int flag;
|
|
|
1317 static unsigned int columns = 0;
|
|
|
1318
|
|
|
1319 /* Sanity check: Make sure that we do not have more
|
|
|
1320 languages than we have bits available to enumerate them. */
|
|
|
1321 gcc_assert ((1U << cl_lang_count) < CL_MIN_OPTION_CLASS);
|
|
|
1322
|
|
|
1323 /* If we have not done so already, obtain
|
|
|
1324 the desired maximum width of the output. */
|
|
|
1325 if (columns == 0)
|
|
|
1326 {
|
|
|
1327 const char *p;
|
|
|
1328
|
|
|
1329 GET_ENVIRONMENT (p, "COLUMNS");
|
|
|
1330 if (p != NULL)
|
|
|
1331 {
|
|
|
1332 int value = atoi (p);
|
|
|
1333
|
|
|
1334 if (value > 0)
|
|
|
1335 columns = value;
|
|
|
1336 }
|
|
|
1337
|
|
|
1338 if (columns == 0)
|
|
|
1339 /* Use a reasonable default. */
|
|
|
1340 columns = 80;
|
|
|
1341 }
|
|
|
1342
|
|
|
1343 /* Decide upon the title for the options that we are going to display. */
|
|
|
1344 for (i = 0, flag = 1; flag <= CL_MAX_OPTION_CLASS; flag <<= 1, i ++)
|
|
|
1345 {
|
|
|
1346 switch (flag & include_flags)
|
|
|
1347 {
|
|
|
1348 case 0:
|
|
|
1349 break;
|
|
|
1350
|
|
|
1351 case CL_TARGET:
|
|
|
1352 description = _("The following options are target specific");
|
|
|
1353 break;
|
|
|
1354 case CL_WARNING:
|
|
|
1355 description = _("The following options control compiler warning messages");
|
|
|
1356 break;
|
|
|
1357 case CL_OPTIMIZATION:
|
|
|
1358 description = _("The following options control optimizations");
|
|
|
1359 break;
|
|
|
1360 case CL_COMMON:
|
|
|
1361 description = _("The following options are language-independent");
|
|
|
1362 break;
|
|
|
1363 case CL_PARAMS:
|
|
|
1364 description = _("The --param option recognizes the following as parameters");
|
|
|
1365 break;
|
|
|
1366 default:
|
|
|
1367 if (i >= cl_lang_count)
|
|
|
1368 break;
|
|
|
1369 if (exclude_flags & all_langs_mask)
|
|
|
1370 description = _("The following options are specific to just the language ");
|
|
|
1371 else
|
|
|
1372 description = _("The following options are supported by the language ");
|
|
|
1373 descrip_extra = lang_names [i];
|
|
|
1374 break;
|
|
|
1375 }
|
|
|
1376 }
|
|
|
1377
|
|
|
1378 if (description == NULL)
|
|
|
1379 {
|
|
|
1380 if (any_flags == 0)
|
|
|
1381 {
|
|
|
1382 if (include_flags & CL_UNDOCUMENTED)
|
|
|
1383 description = _("The following options are not documented");
|
|
|
1384 else if (include_flags & CL_SEPARATE)
|
|
|
1385 description = _("The following options take separate arguments");
|
|
|
1386 else if (include_flags & CL_JOINED)
|
|
|
1387 description = _("The following options take joined arguments");
|
|
|
1388 else
|
|
|
1389 {
|
|
|
1390 internal_error ("unrecognized include_flags 0x%x passed to print_specific_help",
|
|
|
1391 include_flags);
|
|
|
1392 return;
|
|
|
1393 }
|
|
|
1394 }
|
|
|
1395 else
|
|
|
1396 {
|
|
|
1397 if (any_flags & all_langs_mask)
|
|
|
1398 description = _("The following options are language-related");
|
|
|
1399 else
|
|
|
1400 description = _("The following options are language-independent");
|
|
|
1401 }
|
|
|
1402 }
|
|
|
1403
|
|
|
1404 printf ("%s%s:\n", description, descrip_extra);
|
|
|
1405 print_filtered_help (include_flags, exclude_flags, any_flags, columns);
|
|
|
1406 }
|
|
|
1407
|
|
|
1408 /* Handle target- and language-independent options. Return zero to
|
|
|
1409 generate an "unknown option" message. Only options that need
|
|
|
1410 extra handling need to be listed here; if you simply want
|
|
|
1411 VALUE assigned to a variable, it happens automatically. */
|
|
|
1412
|
|
|
1413 static int
|
|
|
1414 common_handle_option (size_t scode, const char *arg, int value,
|
|
|
1415 unsigned int lang_mask)
|
|
|
1416 {
|
|
|
1417 static bool verbose = false;
|
|
|
1418 enum opt_code code = (enum opt_code) scode;
|
|
|
1419
|
|
|
1420 switch (code)
|
|
|
1421 {
|
|
|
1422 case OPT__param:
|
|
|
1423 handle_param (arg);
|
|
|
1424 break;
|
|
|
1425
|
|
|
1426 case OPT_v:
|
|
|
1427 verbose = true;
|
|
|
1428 break;
|
|
|
1429
|
|
|
1430 case OPT_fhelp:
|
|
|
1431 case OPT__help:
|
|
|
1432 {
|
|
|
1433 unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
|
|
|
1434 unsigned int undoc_mask;
|
|
|
1435 unsigned int i;
|
|
|
1436
|
|
|
1437 undoc_mask = (verbose | extra_warnings) ? 0 : CL_UNDOCUMENTED;
|
|
|
1438 /* First display any single language specific options. */
|
|
|
1439 for (i = 0; i < cl_lang_count; i++)
|
|
|
1440 print_specific_help
|
|
|
1441 (1U << i, (all_langs_mask & (~ (1U << i))) | undoc_mask, 0);
|
|
|
1442 /* Next display any multi language specific options. */
|
|
|
1443 print_specific_help (0, undoc_mask, all_langs_mask);
|
|
|
1444 /* Then display any remaining, non-language options. */
|
|
|
1445 for (i = CL_MIN_OPTION_CLASS; i <= CL_MAX_OPTION_CLASS; i <<= 1)
|
|
|
1446 print_specific_help (i, undoc_mask, 0);
|
|
|
1447 exit_after_options = true;
|
|
|
1448 break;
|
|
|
1449 }
|
|
|
1450
|
|
|
1451 case OPT_ftarget_help:
|
|
|
1452 case OPT__target_help:
|
|
|
1453 print_specific_help (CL_TARGET, CL_UNDOCUMENTED, 0);
|
|
|
1454 exit_after_options = true;
|
|
|
1455
|
|
|
1456 /* Allow the target a chance to give the user some additional information. */
|
|
|
1457 if (targetm.target_help)
|
|
|
1458 targetm.target_help ();
|
|
|
1459 break;
|
|
|
1460
|
|
|
1461 case OPT_fhelp_:
|
|
|
1462 case OPT__help_:
|
|
|
1463 {
|
|
|
1464 const char * a = arg;
|
|
|
1465 unsigned int include_flags = 0;
|
|
|
1466 /* Note - by default we include undocumented options when listing
|
|
|
1467 specific classes. If you only want to see documented options
|
|
|
1468 then add ",^undocumented" to the --help= option. E.g.:
|
|
|
1469
|
|
|
1470 --help=target,^undocumented */
|
|
|
1471 unsigned int exclude_flags = 0;
|
|
|
1472
|
|
|
1473 /* Walk along the argument string, parsing each word in turn.
|
|
|
1474 The format is:
|
|
|
1475 arg = [^]{word}[,{arg}]
|
|
|
1476 word = {optimizers|target|warnings|undocumented|
|
|
|
1477 params|common|<language>} */
|
|
|
1478 while (* a != 0)
|
|
|
1479 {
|
|
|
1480 static struct
|
|
|
1481 {
|
|
|
1482 const char * string;
|
|
|
1483 unsigned int flag;
|
|
|
1484 }
|
|
|
1485 specifics[] =
|
|
|
1486 {
|
|
|
1487 { "optimizers", CL_OPTIMIZATION },
|
|
|
1488 { "target", CL_TARGET },
|
|
|
1489 { "warnings", CL_WARNING },
|
|
|
1490 { "undocumented", CL_UNDOCUMENTED },
|
|
|
1491 { "params", CL_PARAMS },
|
|
|
1492 { "joined", CL_JOINED },
|
|
|
1493 { "separate", CL_SEPARATE },
|
|
|
1494 { "common", CL_COMMON },
|
|
|
1495 { NULL, 0 }
|
|
|
1496 };
|
|
|
1497 unsigned int * pflags;
|
|
|
1498 char * comma;
|
|
|
1499 unsigned int lang_flag, specific_flag;
|
|
|
1500 unsigned int len;
|
|
|
1501 unsigned int i;
|
|
|
1502
|
|
|
1503 if (* a == '^')
|
|
|
1504 {
|
|
|
1505 ++ a;
|
|
|
1506 pflags = & exclude_flags;
|
|
|
1507 }
|
|
|
1508 else
|
|
|
1509 pflags = & include_flags;
|
|
|
1510
|
|
|
1511 comma = strchr (a, ',');
|
|
|
1512 if (comma == NULL)
|
|
|
1513 len = strlen (a);
|
|
|
1514 else
|
|
|
1515 len = comma - a;
|
|
|
1516 if (len == 0)
|
|
|
1517 {
|
|
|
1518 a = comma + 1;
|
|
|
1519 continue;
|
|
|
1520 }
|
|
|
1521
|
|
|
1522 /* Check to see if the string matches an option class name. */
|
|
|
1523 for (i = 0, specific_flag = 0; specifics[i].string != NULL; i++)
|
|
|
1524 if (strncasecmp (a, specifics[i].string, len) == 0)
|
|
|
1525 {
|
|
|
1526 specific_flag = specifics[i].flag;
|
|
|
1527 break;
|
|
|
1528 }
|
|
|
1529
|
|
|
1530 /* Check to see if the string matches a language name.
|
|
|
1531 Note - we rely upon the alpha-sorted nature of the entries in
|
|
|
1532 the lang_names array, specifically that shorter names appear
|
|
|
1533 before their longer variants. (i.e. C before C++). That way
|
|
|
1534 when we are attempting to match --help=c for example we will
|
|
|
1535 match with C first and not C++. */
|
|
|
1536 for (i = 0, lang_flag = 0; i < cl_lang_count; i++)
|
|
|
1537 if (strncasecmp (a, lang_names[i], len) == 0)
|
|
|
1538 {
|
|
|
1539 lang_flag = 1U << i;
|
|
|
1540 break;
|
|
|
1541 }
|
|
|
1542
|
|
|
1543 if (specific_flag != 0)
|
|
|
1544 {
|
|
|
1545 if (lang_flag == 0)
|
|
|
1546 * pflags |= specific_flag;
|
|
|
1547 else
|
|
|
1548 {
|
|
|
1549 /* The option's argument matches both the start of a
|
|
|
1550 language name and the start of an option class name.
|
|
|
1551 We have a special case for when the user has
|
|
|
1552 specified "--help=c", but otherwise we have to issue
|
|
|
1553 a warning. */
|
|
|
1554 if (strncasecmp (a, "c", len) == 0)
|
|
|
1555 * pflags |= lang_flag;
|
|
|
1556 else
|
|
|
1557 fnotice (stderr,
|
|
|
1558 "warning: --help argument %.*s is ambiguous, please be more specific\n",
|
|
|
1559 len, a);
|
|
|
1560 }
|
|
|
1561 }
|
|
|
1562 else if (lang_flag != 0)
|
|
|
1563 * pflags |= lang_flag;
|
|
|
1564 else
|
|
|
1565 fnotice (stderr,
|
|
|
1566 "warning: unrecognized argument to --help= option: %.*s\n",
|
|
|
1567 len, a);
|
|
|
1568
|
|
|
1569 if (comma == NULL)
|
|
|
1570 break;
|
|
|
1571 a = comma + 1;
|
|
|
1572 }
|
|
|
1573
|
|
|
1574 if (include_flags)
|
|
|
1575 print_specific_help (include_flags, exclude_flags, 0);
|
|
|
1576 exit_after_options = true;
|
|
|
1577 break;
|
|
|
1578 }
|
|
|
1579
|
|
|
1580 case OPT__version:
|
|
|
1581 print_version (stderr, "");
|
|
|
1582 exit_after_options = true;
|
|
|
1583 break;
|
|
|
1584
|
|
|
1585 case OPT_G:
|
|
|
1586 g_switch_value = value;
|
|
|
1587 g_switch_set = true;
|
|
|
1588 break;
|
|
|
1589
|
|
|
1590 case OPT_O:
|
|
|
1591 case OPT_Os:
|
|
|
1592 /* Currently handled in a prescan. */
|
|
|
1593 break;
|
|
|
1594
|
|
|
1595 case OPT_W:
|
|
|
1596 /* For backward compatibility, -W is the same as -Wextra. */
|
|
|
1597 set_Wextra (value);
|
|
|
1598 break;
|
|
|
1599
|
|
|
1600 case OPT_Werror_:
|
|
|
1601 enable_warning_as_error (arg, value, lang_mask);
|
|
|
1602 break;
|
|
|
1603
|
|
|
1604 case OPT_Wextra:
|
|
|
1605 set_Wextra (value);
|
|
|
1606 break;
|
|
|
1607
|
|
|
1608 case OPT_Wlarger_than_:
|
|
|
1609 /* This form corresponds to -Wlarger-than-.
|
|
|
1610 Kept for backward compatibility.
|
|
|
1611 Don't use it as the first argument of warning(). */
|
|
|
1612
|
|
|
1613 case OPT_Wlarger_than_eq:
|
|
|
1614 larger_than_size = value;
|
|
|
1615 warn_larger_than = value != -1;
|
|
|
1616 break;
|
|
|
1617
|
|
|
1618 case OPT_Wframe_larger_than_:
|
|
|
1619 frame_larger_than_size = value;
|
|
|
1620 warn_frame_larger_than = value != -1;
|
|
|
1621 break;
|
|
|
1622
|
|
|
1623 case OPT_Wstrict_aliasing:
|
|
|
1624 set_Wstrict_aliasing (value);
|
|
|
1625 break;
|
|
|
1626
|
|
|
1627 case OPT_Wstrict_aliasing_:
|
|
|
1628 warn_strict_aliasing = value;
|
|
|
1629 break;
|
|
|
1630
|
|
|
1631 case OPT_Wstrict_overflow:
|
|
|
1632 warn_strict_overflow = (value
|
|
|
1633 ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
|
|
|
1634 : 0);
|
|
|
1635 break;
|
|
|
1636
|
|
|
1637 case OPT_Wstrict_overflow_:
|
|
|
1638 warn_strict_overflow = value;
|
|
|
1639 break;
|
|
|
1640
|
|
|
1641 case OPT_Wunused:
|
|
|
1642 warn_unused = value;
|
|
|
1643 break;
|
|
|
1644
|
|
|
1645 case OPT_aux_info:
|
|
|
1646 case OPT_aux_info_:
|
|
|
1647 aux_info_file_name = arg;
|
|
|
1648 flag_gen_aux_info = 1;
|
|
|
1649 break;
|
|
|
1650
|
|
|
1651 case OPT_auxbase:
|
|
|
1652 aux_base_name = arg;
|
|
|
1653 break;
|
|
|
1654
|
|
|
1655 case OPT_auxbase_strip:
|
|
|
1656 {
|
|
|
1657 char *tmp = xstrdup (arg);
|
|
|
1658 strip_off_ending (tmp, strlen (tmp));
|
|
|
1659 if (tmp[0])
|
|
|
1660 aux_base_name = tmp;
|
|
|
1661 }
|
|
|
1662 break;
|
|
|
1663
|
|
|
1664 case OPT_d:
|
|
|
1665 decode_d_option (arg);
|
|
|
1666 break;
|
|
|
1667
|
|
|
1668 case OPT_dumpbase:
|
|
|
1669 dump_base_name = arg;
|
|
|
1670 break;
|
|
|
1671
|
|
|
1672 case OPT_falign_functions_:
|
|
|
1673 align_functions = value;
|
|
|
1674 break;
|
|
|
1675
|
|
|
1676 case OPT_falign_jumps_:
|
|
|
1677 align_jumps = value;
|
|
|
1678 break;
|
|
|
1679
|
|
|
1680 case OPT_falign_labels_:
|
|
|
1681 align_labels = value;
|
|
|
1682 break;
|
|
|
1683
|
|
|
1684 case OPT_falign_loops_:
|
|
|
1685 align_loops = value;
|
|
|
1686 break;
|
|
|
1687
|
|
|
1688 case OPT_fbranch_probabilities:
|
|
|
1689 flag_branch_probabilities_set = true;
|
|
|
1690 break;
|
|
|
1691
|
|
|
1692 case OPT_fcall_used_:
|
|
|
1693 fix_register (arg, 0, 1);
|
|
|
1694 break;
|
|
|
1695
|
|
|
1696 case OPT_fcall_saved_:
|
|
|
1697 fix_register (arg, 0, 0);
|
|
|
1698 break;
|
|
|
1699
|
|
|
1700 case OPT_fdbg_cnt_:
|
|
|
1701 dbg_cnt_process_opt (arg);
|
|
|
1702 break;
|
|
|
1703
|
|
|
1704 case OPT_fdbg_cnt_list:
|
|
|
1705 dbg_cnt_list_all_counters ();
|
|
|
1706 break;
|
|
|
1707
|
|
|
1708 case OPT_fdebug_prefix_map_:
|
|
|
1709 add_debug_prefix_map (arg);
|
|
|
1710 break;
|
|
|
1711
|
|
|
1712 case OPT_fdiagnostics_show_location_:
|
|
|
1713 if (!strcmp (arg, "once"))
|
|
|
1714 diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
|
|
|
1715 else if (!strcmp (arg, "every-line"))
|
|
|
1716 diagnostic_prefixing_rule (global_dc)
|
|
|
1717 = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE;
|
|
|
1718 else
|
|
|
1719 return 0;
|
|
|
1720 break;
|
|
|
1721
|
|
|
1722 case OPT_fdiagnostics_show_option:
|
|
|
1723 global_dc->show_option_requested = true;
|
|
|
1724 break;
|
|
|
1725
|
|
|
1726 case OPT_fdump_:
|
|
|
1727 if (!dump_switch_p (arg))
|
|
|
1728 return 0;
|
|
|
1729 break;
|
|
|
1730
|
|
|
1731 case OPT_ffast_math:
|
|
|
1732 set_fast_math_flags (value);
|
|
|
1733 break;
|
|
|
1734
|
|
|
1735 case OPT_funsafe_math_optimizations:
|
|
|
1736 set_unsafe_math_optimizations_flags (value);
|
|
|
1737 break;
|
|
|
1738
|
|
|
1739 case OPT_ffixed_:
|
|
|
1740 fix_register (arg, 1, 1);
|
|
|
1741 break;
|
|
|
1742
|
|
|
1743 case OPT_finline_limit_:
|
|
|
1744 case OPT_finline_limit_eq:
|
|
|
1745 set_param_value ("max-inline-insns-single", value / 2);
|
|
|
1746 set_param_value ("max-inline-insns-auto", value / 2);
|
|
|
1747 break;
|
|
|
1748
|
|
|
1749 case OPT_finstrument_functions_exclude_function_list_:
|
|
|
1750 add_comma_separated_to_vector
|
|
|
1751 (&flag_instrument_functions_exclude_functions, arg);
|
|
|
1752 break;
|
|
|
1753
|
|
|
1754 case OPT_finstrument_functions_exclude_file_list_:
|
|
|
1755 add_comma_separated_to_vector
|
|
|
1756 (&flag_instrument_functions_exclude_files, arg);
|
|
|
1757 break;
|
|
|
1758
|
|
|
1759 case OPT_fmessage_length_:
|
|
|
1760 pp_set_line_maximum_length (global_dc->printer, value);
|
|
|
1761 break;
|
|
|
1762
|
|
|
1763 case OPT_fpack_struct_:
|
|
|
1764 if (value <= 0 || (value & (value - 1)) || value > 16)
|
|
|
1765 error ("structure alignment must be a small power of two, not %d", value);
|
|
|
1766 else
|
|
|
1767 {
|
|
|
1768 initial_max_fld_align = value;
|
|
|
1769 maximum_field_alignment = value * BITS_PER_UNIT;
|
|
|
1770 }
|
|
|
1771 break;
|
|
|
1772
|
|
|
1773 case OPT_fpeel_loops:
|
|
|
1774 flag_peel_loops_set = true;
|
|
|
1775 break;
|
|
|
1776
|
|
|
1777 case OPT_fprofile_arcs:
|
|
|
1778 profile_arc_flag_set = true;
|
|
|
1779 break;
|
|
|
1780
|
|
|
1781 case OPT_finline_functions:
|
|
|
1782 flag_inline_functions_set = true;
|
|
|
1783 break;
|
|
|
1784
|
|
|
1785 case OPT_fprofile_dir_:
|
|
|
1786 profile_data_prefix = xstrdup (arg);
|
|
|
1787 break;
|
|
|
1788
|
|
|
1789 case OPT_fprofile_use_:
|
|
|
1790 profile_data_prefix = xstrdup (arg);
|
|
|
1791 flag_profile_use = true;
|
|
|
1792 value = true;
|
|
|
1793 /* No break here - do -fprofile-use processing. */
|
|
|
1794 case OPT_fprofile_use:
|
|
|
1795 if (!flag_branch_probabilities_set)
|
|
|
1796 flag_branch_probabilities = value;
|
|
|
1797 if (!flag_profile_values_set)
|
|
|
1798 flag_profile_values = value;
|
|
|
1799 if (!flag_unroll_loops_set)
|
|
|
1800 flag_unroll_loops = value;
|
|
|
1801 if (!flag_peel_loops_set)
|
|
|
1802 flag_peel_loops = value;
|
|
|
1803 if (!flag_tracer_set)
|
|
|
1804 flag_tracer = value;
|
|
|
1805 if (!flag_value_profile_transformations_set)
|
|
|
1806 flag_value_profile_transformations = value;
|
|
|
1807 if (!flag_inline_functions_set)
|
|
|
1808 flag_inline_functions = value;
|
|
|
1809 if (!flag_ipa_cp_set)
|
|
|
1810 flag_ipa_cp = value;
|
|
|
1811 if (!flag_ipa_cp_clone_set
|
|
|
1812 && value && flag_ipa_cp)
|
|
|
1813 flag_ipa_cp_clone = value;
|
|
|
1814 if (!flag_predictive_commoning_set)
|
|
|
1815 flag_predictive_commoning = value;
|
|
|
1816 if (!flag_unswitch_loops_set)
|
|
|
1817 flag_unswitch_loops = value;
|
|
|
1818 if (!flag_gcse_after_reload_set)
|
|
|
1819 flag_gcse_after_reload = value;
|
|
|
1820 break;
|
|
|
1821
|
|
|
1822 case OPT_fprofile_generate_:
|
|
|
1823 profile_data_prefix = xstrdup (arg);
|
|
|
1824 value = true;
|
|
|
1825 /* No break here - do -fprofile-generate processing. */
|
|
|
1826 case OPT_fprofile_generate:
|
|
|
1827 if (!profile_arc_flag_set)
|
|
|
1828 profile_arc_flag = value;
|
|
|
1829 if (!flag_profile_values_set)
|
|
|
1830 flag_profile_values = value;
|
|
|
1831 if (!flag_value_profile_transformations_set)
|
|
|
1832 flag_value_profile_transformations = value;
|
|
|
1833 if (!flag_inline_functions_set)
|
|
|
1834 flag_inline_functions = value;
|
|
|
1835 break;
|
|
|
1836
|
|
|
1837 case OPT_fprofile_values:
|
|
|
1838 flag_profile_values_set = true;
|
|
|
1839 break;
|
|
|
1840
|
|
|
1841 case OPT_fvisibility_:
|
|
|
1842 {
|
|
|
1843 if (!strcmp(arg, "default"))
|
|
|
1844 default_visibility = VISIBILITY_DEFAULT;
|
|
|
1845 else if (!strcmp(arg, "internal"))
|
|
|
1846 default_visibility = VISIBILITY_INTERNAL;
|
|
|
1847 else if (!strcmp(arg, "hidden"))
|
|
|
1848 default_visibility = VISIBILITY_HIDDEN;
|
|
|
1849 else if (!strcmp(arg, "protected"))
|
|
|
1850 default_visibility = VISIBILITY_PROTECTED;
|
|
|
1851 else
|
|
|
1852 error ("unrecognized visibility value \"%s\"", arg);
|
|
|
1853 }
|
|
|
1854 break;
|
|
|
1855
|
|
|
1856 case OPT_fvpt:
|
|
|
1857 flag_value_profile_transformations_set = true;
|
|
|
1858 break;
|
|
|
1859
|
|
|
1860 case OPT_frandom_seed:
|
|
|
1861 /* The real switch is -fno-random-seed. */
|
|
|
1862 if (value)
|
|
|
1863 return 0;
|
|
|
1864 set_random_seed (NULL);
|
|
|
1865 break;
|
|
|
1866
|
|
|
1867 case OPT_frandom_seed_:
|
|
|
1868 set_random_seed (arg);
|
|
|
1869 break;
|
|
|
1870
|
|
|
1871 case OPT_fselective_scheduling:
|
|
|
1872 case OPT_fselective_scheduling2:
|
|
|
1873 sel_sched_switch_set = true;
|
|
|
1874 break;
|
|
|
1875
|
|
|
1876 case OPT_fsched_verbose_:
|
|
|
1877 #ifdef INSN_SCHEDULING
|
|
|
1878 fix_sched_param ("verbose", arg);
|
|
|
1879 break;
|
|
|
1880 #else
|
|
|
1881 return 0;
|
|
|
1882 #endif
|
|
|
1883
|
|
|
1884 case OPT_fsched_stalled_insns_:
|
|
|
1885 flag_sched_stalled_insns = value;
|
|
|
1886 if (flag_sched_stalled_insns == 0)
|
|
|
1887 flag_sched_stalled_insns = -1;
|
|
|
1888 break;
|
|
|
1889
|
|
|
1890 case OPT_fsched_stalled_insns_dep_:
|
|
|
1891 flag_sched_stalled_insns_dep = value;
|
|
|
1892 break;
|
|
|
1893
|
|
|
1894 case OPT_fstack_check_:
|
|
|
1895 if (!strcmp (arg, "no"))
|
|
|
1896 flag_stack_check = NO_STACK_CHECK;
|
|
|
1897 else if (!strcmp (arg, "generic"))
|
|
|
1898 /* This is the old stack checking method. */
|
|
|
1899 flag_stack_check = STACK_CHECK_BUILTIN
|
|
|
1900 ? FULL_BUILTIN_STACK_CHECK
|
|
|
1901 : GENERIC_STACK_CHECK;
|
|
|
1902 else if (!strcmp (arg, "specific"))
|
|
|
1903 /* This is the new stack checking method. */
|
|
|
1904 flag_stack_check = STACK_CHECK_BUILTIN
|
|
|
1905 ? FULL_BUILTIN_STACK_CHECK
|
|
|
1906 : STACK_CHECK_STATIC_BUILTIN
|
|
|
1907 ? STATIC_BUILTIN_STACK_CHECK
|
|
|
1908 : GENERIC_STACK_CHECK;
|
|
|
1909 else
|
|
|
1910 warning (0, "unknown stack check parameter \"%s\"", arg);
|
|
|
1911 break;
|
|
|
1912
|
|
|
1913 case OPT_fstack_check:
|
|
|
1914 /* This is the same as the "specific" mode above. */
|
|
|
1915 if (value)
|
|
|
1916 flag_stack_check = STACK_CHECK_BUILTIN
|
|
|
1917 ? FULL_BUILTIN_STACK_CHECK
|
|
|
1918 : STACK_CHECK_STATIC_BUILTIN
|
|
|
1919 ? STATIC_BUILTIN_STACK_CHECK
|
|
|
1920 : GENERIC_STACK_CHECK;
|
|
|
1921 else
|
|
|
1922 flag_stack_check = NO_STACK_CHECK;
|
|
|
1923 break;
|
|
|
1924
|
|
|
1925 case OPT_fstack_limit:
|
|
|
1926 /* The real switch is -fno-stack-limit. */
|
|
|
1927 if (value)
|
|
|
1928 return 0;
|
|
|
1929 stack_limit_rtx = NULL_RTX;
|
|
|
1930 break;
|
|
|
1931
|
|
|
1932 case OPT_fstack_limit_register_:
|
|
|
1933 {
|
|
|
1934 int reg = decode_reg_name (arg);
|
|
|
1935 if (reg < 0)
|
|
|
1936 error ("unrecognized register name \"%s\"", arg);
|
|
|
1937 else
|
|
|
1938 stack_limit_rtx = gen_rtx_REG (Pmode, reg);
|
|
|
1939 }
|
|
|
1940 break;
|
|
|
1941
|
|
|
1942 case OPT_fstack_limit_symbol_:
|
|
|
1943 stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (arg));
|
|
|
1944 break;
|
|
|
1945
|
|
|
1946 case OPT_ftree_vectorizer_verbose_:
|
|
|
1947 vect_set_verbosity_level (arg);
|
|
|
1948 break;
|
|
|
1949
|
|
|
1950 case OPT_ftls_model_:
|
|
|
1951 if (!strcmp (arg, "global-dynamic"))
|
|
|
1952 flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
|
|
|
1953 else if (!strcmp (arg, "local-dynamic"))
|
|
|
1954 flag_tls_default = TLS_MODEL_LOCAL_DYNAMIC;
|
|
|
1955 else if (!strcmp (arg, "initial-exec"))
|
|
|
1956 flag_tls_default = TLS_MODEL_INITIAL_EXEC;
|
|
|
1957 else if (!strcmp (arg, "local-exec"))
|
|
|
1958 flag_tls_default = TLS_MODEL_LOCAL_EXEC;
|
|
|
1959 else
|
|
|
1960 warning (0, "unknown tls-model \"%s\"", arg);
|
|
|
1961 break;
|
|
|
1962
|
|
|
1963 case OPT_fira_algorithm_:
|
|
|
1964 if (!strcmp (arg, "CB"))
|
|
|
1965 flag_ira_algorithm = IRA_ALGORITHM_CB;
|
|
|
1966 else if (!strcmp (arg, "priority"))
|
|
|
1967 flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
|
|
|
1968 else
|
|
|
1969 warning (0, "unknown ira algorithm \"%s\"", arg);
|
|
|
1970 break;
|
|
|
1971
|
|
|
1972 case OPT_fira_region_:
|
|
|
1973 if (!strcmp (arg, "one"))
|
|
|
1974 flag_ira_region = IRA_REGION_ONE;
|
|
|
1975 else if (!strcmp (arg, "all"))
|
|
|
1976 flag_ira_region = IRA_REGION_ALL;
|
|
|
1977 else if (!strcmp (arg, "mixed"))
|
|
|
1978 flag_ira_region = IRA_REGION_MIXED;
|
|
|
1979 else
|
|
|
1980 warning (0, "unknown ira region \"%s\"", arg);
|
|
|
1981 break;
|
|
|
1982
|
|
|
1983 case OPT_fira_verbose_:
|
|
|
1984 flag_ira_verbose = value;
|
|
|
1985 break;
|
|
|
1986
|
|
|
1987 case OPT_ftracer:
|
|
|
1988 flag_tracer_set = true;
|
|
|
1989 break;
|
|
|
1990
|
|
|
1991 case OPT_fipa_cp:
|
|
|
1992 flag_ipa_cp_set = true;
|
|
|
1993 break;
|
|
|
1994
|
|
|
1995 case OPT_fipa_cp_clone:
|
|
|
1996 flag_ipa_cp_clone_set = true;
|
|
|
1997 break;
|
|
|
1998
|
|
|
1999 case OPT_fpredictive_commoning:
|
|
|
2000 flag_predictive_commoning_set = true;
|
|
|
2001 break;
|
|
|
2002
|
|
|
2003 case OPT_funswitch_loops:
|
|
|
2004 flag_unswitch_loops_set = true;
|
|
|
2005 break;
|
|
|
2006
|
|
|
2007 case OPT_fgcse_after_reload:
|
|
|
2008 flag_gcse_after_reload_set = true;
|
|
|
2009 break;
|
|
|
2010
|
|
|
2011 case OPT_funroll_loops:
|
|
|
2012 flag_unroll_loops_set = true;
|
|
|
2013 break;
|
|
|
2014
|
|
|
2015 case OPT_g:
|
|
|
2016 set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg);
|
|
|
2017 break;
|
|
|
2018
|
|
|
2019 case OPT_gcoff:
|
|
|
2020 set_debug_level (SDB_DEBUG, false, arg);
|
|
|
2021 break;
|
|
|
2022
|
|
|
2023 case OPT_gdwarf_2:
|
|
|
2024 set_debug_level (DWARF2_DEBUG, false, arg);
|
|
|
2025 break;
|
|
|
2026
|
|
|
2027 case OPT_ggdb:
|
|
|
2028 set_debug_level (NO_DEBUG, 2, arg);
|
|
|
2029 break;
|
|
|
2030
|
|
|
2031 case OPT_gstabs:
|
|
|
2032 case OPT_gstabs_:
|
|
|
2033 set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg);
|
|
|
2034 break;
|
|
|
2035
|
|
|
2036 case OPT_gvms:
|
|
|
2037 set_debug_level (VMS_DEBUG, false, arg);
|
|
|
2038 break;
|
|
|
2039
|
|
|
2040 case OPT_gxcoff:
|
|
|
2041 case OPT_gxcoff_:
|
|
|
2042 set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg);
|
|
|
2043 break;
|
|
|
2044
|
|
|
2045 case OPT_o:
|
|
|
2046 asm_file_name = arg;
|
|
|
2047 break;
|
|
|
2048
|
|
|
2049 case OPT_pedantic_errors:
|
|
|
2050 flag_pedantic_errors = pedantic = 1;
|
|
|
2051 break;
|
|
|
2052
|
|
|
2053 case OPT_floop_optimize:
|
|
|
2054 case OPT_frerun_loop_opt:
|
|
|
2055 case OPT_fstrength_reduce:
|
|
|
2056 case OPT_ftree_store_copy_prop:
|
|
|
2057 case OPT_fforce_addr:
|
|
|
2058 case OPT_ftree_salias:
|
|
|
2059 case OPT_ftree_store_ccp:
|
|
|
2060 /* These are no-ops, preserved for backward compatibility. */
|
|
|
2061 break;
|
|
|
2062
|
|
|
2063 default:
|
|
|
2064 /* If the flag was handled in a standard way, assume the lack of
|
|
|
2065 processing here is intentional. */
|
|
|
2066 gcc_assert (cl_options[scode].flag_var);
|
|
|
2067 break;
|
|
|
2068 }
|
|
|
2069
|
|
|
2070 return 1;
|
|
|
2071 }
|
|
|
2072
|
|
|
2073 /* Handle --param NAME=VALUE. */
|
|
|
2074 static void
|
|
|
2075 handle_param (const char *carg)
|
|
|
2076 {
|
|
|
2077 char *equal, *arg;
|
|
|
2078 int value;
|
|
|
2079
|
|
|
2080 arg = xstrdup (carg);
|
|
|
2081 equal = strchr (arg, '=');
|
|
|
2082 if (!equal)
|
|
|
2083 error ("%s: --param arguments should be of the form NAME=VALUE", arg);
|
|
|
2084 else
|
|
|
2085 {
|
|
|
2086 value = integral_argument (equal + 1);
|
|
|
2087 if (value == -1)
|
|
|
2088 error ("invalid --param value %qs", equal + 1);
|
|
|
2089 else
|
|
|
2090 {
|
|
|
2091 *equal = '\0';
|
|
|
2092 set_param_value (arg, value);
|
|
|
2093 }
|
|
|
2094 }
|
|
|
2095
|
|
|
2096 free (arg);
|
|
|
2097 }
|
|
|
2098
|
|
|
2099 /* Handle -W and -Wextra. */
|
|
|
2100 static void
|
|
|
2101 set_Wextra (int setting)
|
|
|
2102 {
|
|
|
2103 extra_warnings = setting;
|
|
|
2104
|
|
|
2105 /* We save the value of warn_uninitialized, since if they put
|
|
|
2106 -Wuninitialized on the command line, we need to generate a
|
|
|
2107 warning about not using it without also specifying -O. */
|
|
|
2108 if (setting == 0)
|
|
|
2109 warn_uninitialized = 0;
|
|
|
2110 else if (warn_uninitialized != 1)
|
|
|
2111 warn_uninitialized = 2;
|
|
|
2112 }
|
|
|
2113
|
|
|
2114 /* Used to set the level of strict aliasing warnings,
|
|
|
2115 when no level is specified (i.e., when -Wstrict-aliasing, and not
|
|
|
2116 -Wstrict-aliasing=level was given).
|
|
|
2117 ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
|
|
|
2118 and 0 otherwise. After calling this function, wstrict_aliasing will be
|
|
|
2119 set to the default value of -Wstrict_aliasing=level, currently 3. */
|
|
|
2120 void
|
|
|
2121 set_Wstrict_aliasing (int onoff)
|
|
|
2122 {
|
|
|
2123 gcc_assert (onoff == 0 || onoff == 1);
|
|
|
2124 if (onoff != 0)
|
|
|
2125 warn_strict_aliasing = 3;
|
|
|
2126 else
|
|
|
2127 warn_strict_aliasing = 0;
|
|
|
2128 }
|
|
|
2129
|
|
|
2130 /* The following routines are useful in setting all the flags that
|
|
|
2131 -ffast-math and -fno-fast-math imply. */
|
|
|
2132 void
|
|
|
2133 set_fast_math_flags (int set)
|
|
|
2134 {
|
|
|
2135 flag_unsafe_math_optimizations = set;
|
|
|
2136 set_unsafe_math_optimizations_flags (set);
|
|
|
2137 flag_finite_math_only = set;
|
|
|
2138 flag_errno_math = !set;
|
|
|
2139 if (set)
|
|
|
2140 {
|
|
|
2141 flag_signaling_nans = 0;
|
|
|
2142 flag_rounding_math = 0;
|
|
|
2143 flag_cx_limited_range = 1;
|
|
|
2144 }
|
|
|
2145 }
|
|
|
2146
|
|
|
2147 /* When -funsafe-math-optimizations is set the following
|
|
|
2148 flags are set as well. */
|
|
|
2149 void
|
|
|
2150 set_unsafe_math_optimizations_flags (int set)
|
|
|
2151 {
|
|
|
2152 flag_trapping_math = !set;
|
|
|
2153 flag_signed_zeros = !set;
|
|
|
2154 flag_associative_math = set;
|
|
|
2155 flag_reciprocal_math = set;
|
|
|
2156 }
|
|
|
2157
|
|
|
2158 /* Return true iff flags are set as if -ffast-math. */
|
|
|
2159 bool
|
|
|
2160 fast_math_flags_set_p (void)
|
|
|
2161 {
|
|
|
2162 return (!flag_trapping_math
|
|
|
2163 && flag_unsafe_math_optimizations
|
|
|
2164 && flag_finite_math_only
|
|
|
2165 && !flag_signed_zeros
|
|
|
2166 && !flag_errno_math);
|
|
|
2167 }
|
|
|
2168
|
|
|
2169 /* Return true iff flags are set as if -ffast-math but using the flags stored
|
|
|
2170 in the struct cl_optimization structure. */
|
|
|
2171 bool
|
|
|
2172 fast_math_flags_struct_set_p (struct cl_optimization *opt)
|
|
|
2173 {
|
|
|
2174 return (!opt->flag_trapping_math
|
|
|
2175 && opt->flag_unsafe_math_optimizations
|
|
|
2176 && opt->flag_finite_math_only
|
|
|
2177 && !opt->flag_signed_zeros
|
|
|
2178 && !opt->flag_errno_math);
|
|
|
2179 }
|
|
|
2180
|
|
|
2181 /* Handle a debug output -g switch. EXTENDED is true or false to support
|
|
|
2182 extended output (2 is special and means "-ggdb" was given). */
|
|
|
2183 static void
|
|
|
2184 set_debug_level (enum debug_info_type type, int extended, const char *arg)
|
|
|
2185 {
|
|
|
2186 static bool type_explicit;
|
|
|
2187
|
|
|
2188 use_gnu_debug_info_extensions = extended;
|
|
|
2189
|
|
|
2190 if (type == NO_DEBUG)
|
|
|
2191 {
|
|
|
2192 if (write_symbols == NO_DEBUG)
|
|
|
2193 {
|
|
|
2194 write_symbols = PREFERRED_DEBUGGING_TYPE;
|
|
|
2195
|
|
|
2196 if (extended == 2)
|
|
|
2197 {
|
|
|
2198 #ifdef DWARF2_DEBUGGING_INFO
|
|
|
2199 write_symbols = DWARF2_DEBUG;
|
|
|
2200 #elif defined DBX_DEBUGGING_INFO
|
|
|
2201 write_symbols = DBX_DEBUG;
|
|
|
2202 #endif
|
|
|
2203 }
|
|
|
2204
|
|
|
2205 if (write_symbols == NO_DEBUG)
|
|
|
2206 warning (0, "target system does not support debug output");
|
|
|
2207 }
|
|
|
2208 }
|
|
|
2209 else
|
|
|
2210 {
|
|
|
2211 /* Does it conflict with an already selected type? */
|
|
|
2212 if (type_explicit && write_symbols != NO_DEBUG && type != write_symbols)
|
|
|
2213 error ("debug format \"%s\" conflicts with prior selection",
|
|
|
2214 debug_type_names[type]);
|
|
|
2215 write_symbols = type;
|
|
|
2216 type_explicit = true;
|
|
|
2217 }
|
|
|
2218
|
|
|
2219 /* A debug flag without a level defaults to level 2. */
|
|
|
2220 if (*arg == '\0')
|
|
|
2221 {
|
|
|
2222 if (!debug_info_level)
|
|
|
2223 debug_info_level = 2;
|
|
|
2224 }
|
|
|
2225 else
|
|
|
2226 {
|
|
|
2227 debug_info_level = integral_argument (arg);
|
|
|
2228 if (debug_info_level == (unsigned int) -1)
|
|
|
2229 error ("unrecognised debug output level \"%s\"", arg);
|
|
|
2230 else if (debug_info_level > 3)
|
|
|
2231 error ("debug output level %s is too high", arg);
|
|
|
2232 }
|
|
|
2233 }
|
|
|
2234
|
|
|
2235 /* Return 1 if OPTION is enabled, 0 if it is disabled, or -1 if it isn't
|
|
|
2236 a simple on-off switch. */
|
|
|
2237
|
|
|
2238 int
|
|
|
2239 option_enabled (int opt_idx)
|
|
|
2240 {
|
|
|
2241 const struct cl_option *option = &(cl_options[opt_idx]);
|
|
|
2242
|
|
|
2243 if (option->flag_var)
|
|
|
2244 switch (option->var_type)
|
|
|
2245 {
|
|
|
2246 case CLVC_BOOLEAN:
|
|
|
2247 return *(int *) option->flag_var != 0;
|
|
|
2248
|
|
|
2249 case CLVC_EQUAL:
|
|
|
2250 return *(int *) option->flag_var == option->var_value;
|
|
|
2251
|
|
|
2252 case CLVC_BIT_CLEAR:
|
|
|
2253 return (*(int *) option->flag_var & option->var_value) == 0;
|
|
|
2254
|
|
|
2255 case CLVC_BIT_SET:
|
|
|
2256 return (*(int *) option->flag_var & option->var_value) != 0;
|
|
|
2257
|
|
|
2258 case CLVC_STRING:
|
|
|
2259 break;
|
|
|
2260 }
|
|
|
2261 return -1;
|
|
|
2262 }
|
|
|
2263
|
|
|
2264 /* Fill STATE with the current state of option OPTION. Return true if
|
|
|
2265 there is some state to store. */
|
|
|
2266
|
|
|
2267 bool
|
|
|
2268 get_option_state (int option, struct cl_option_state *state)
|
|
|
2269 {
|
|
|
2270 if (cl_options[option].flag_var == 0)
|
|
|
2271 return false;
|
|
|
2272
|
|
|
2273 switch (cl_options[option].var_type)
|
|
|
2274 {
|
|
|
2275 case CLVC_BOOLEAN:
|
|
|
2276 case CLVC_EQUAL:
|
|
|
2277 state->data = cl_options[option].flag_var;
|
|
|
2278 state->size = sizeof (int);
|
|
|
2279 break;
|
|
|
2280
|
|
|
2281 case CLVC_BIT_CLEAR:
|
|
|
2282 case CLVC_BIT_SET:
|
|
|
2283 state->ch = option_enabled (option);
|
|
|
2284 state->data = &state->ch;
|
|
|
2285 state->size = 1;
|
|
|
2286 break;
|
|
|
2287
|
|
|
2288 case CLVC_STRING:
|
|
|
2289 state->data = *(const char **) cl_options[option].flag_var;
|
|
|
2290 if (state->data == 0)
|
|
|
2291 state->data = "";
|
|
|
2292 state->size = strlen ((const char *) state->data) + 1;
|
|
|
2293 break;
|
|
|
2294 }
|
|
|
2295 return true;
|
|
|
2296 }
|
|
|
2297
|
|
|
2298 /* Enable a warning option as an error. This is used by -Werror= and
|
|
|
2299 also by legacy Werror-implicit-function-declaration. */
|
|
|
2300
|
|
|
2301 void
|
|
|
2302 enable_warning_as_error (const char *arg, int value, unsigned int lang_mask)
|
|
|
2303 {
|
|
|
2304 char *new_option;
|
|
|
2305 int option_index;
|
|
|
2306
|
|
|
2307 new_option = XNEWVEC (char, strlen (arg) + 2);
|
|
|
2308 new_option[0] = 'W';
|
|
|
2309 strcpy (new_option + 1, arg);
|
|
|
2310 option_index = find_opt (new_option, lang_mask);
|
|
|
2311 if (option_index == N_OPTS)
|
|
|
2312 {
|
|
|
2313 error ("-Werror=%s: No option -%s", arg, new_option);
|
|
|
2314 }
|
|
|
2315 else
|
|
|
2316 {
|
|
|
2317 int kind = value ? DK_ERROR : DK_WARNING;
|
|
|
2318 diagnostic_classify_diagnostic (global_dc, option_index, kind);
|
|
|
2319
|
|
|
2320 /* -Werror=foo implies -Wfoo. */
|
|
|
2321 if (cl_options[option_index].var_type == CLVC_BOOLEAN
|
|
|
2322 && cl_options[option_index].flag_var
|
|
|
2323 && kind == DK_ERROR)
|
|
|
2324 *(int *) cl_options[option_index].flag_var = 1;
|
|
|
2325 }
|
|
|
2326 free (new_option);
|
|
|
2327 }
|
