OSDN Git Service

* common.opt (flag_stack_check): New Variable entry.
[pf3gnuchains/gcc-fork.git] / gcc / opts.c
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.
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" /* Needed by rtl.h and used for DWARF2_DEBUGGING_INFO
27                    and DBX_DEBUGGING_INFO.  */
28 #include "rtl.h" /* Needed by insn-attr.h.  */
29 #include "opts.h"
30 #include "options.h"
31 #include "flags.h"
32 #include "params.h"
33 #include "diagnostic.h"
34 #include "opts-diagnostic.h"
35 #include "insn-attr.h"          /* For INSN_SCHEDULING and DELAY_SLOTS.  */
36 #include "target.h"
37
38 /* Parse the -femit-struct-debug-detailed option value
39    and set the flag variables. */
40
41 #define MATCH( prefix, string ) \
42   ((strncmp (prefix, string, sizeof prefix - 1) == 0) \
43    ? ((string += sizeof prefix - 1), 1) : 0)
44
45 void
46 set_struct_debug_option (struct gcc_options *opts, location_t loc,
47                          const char *spec)
48 {
49   /* various labels for comparison */
50   static const char dfn_lbl[] = "dfn:", dir_lbl[] = "dir:", ind_lbl[] = "ind:";
51   static const char ord_lbl[] = "ord:", gen_lbl[] = "gen:";
52   static const char none_lbl[] = "none", any_lbl[] = "any";
53   static const char base_lbl[] = "base", sys_lbl[] = "sys";
54
55   enum debug_struct_file files = DINFO_STRUCT_FILE_ANY;
56   /* Default is to apply to as much as possible. */
57   enum debug_info_usage usage = DINFO_USAGE_NUM_ENUMS;
58   int ord = 1, gen = 1;
59
60   /* What usage? */
61   if (MATCH (dfn_lbl, spec))
62     usage = DINFO_USAGE_DFN;
63   else if (MATCH (dir_lbl, spec))
64     usage = DINFO_USAGE_DIR_USE;
65   else if (MATCH (ind_lbl, spec))
66     usage = DINFO_USAGE_IND_USE;
67
68   /* Generics or not? */
69   if (MATCH (ord_lbl, spec))
70     gen = 0;
71   else if (MATCH (gen_lbl, spec))
72     ord = 0;
73
74   /* What allowable environment? */
75   if (MATCH (none_lbl, spec))
76     files = DINFO_STRUCT_FILE_NONE;
77   else if (MATCH (any_lbl, spec))
78     files = DINFO_STRUCT_FILE_ANY;
79   else if (MATCH (sys_lbl, spec))
80     files = DINFO_STRUCT_FILE_SYS;
81   else if (MATCH (base_lbl, spec))
82     files = DINFO_STRUCT_FILE_BASE;
83   else
84     error_at (loc,
85               "argument %qs to %<-femit-struct-debug-detailed%> "
86               "not recognized",
87               spec);
88
89   /* Effect the specification. */
90   if (usage == DINFO_USAGE_NUM_ENUMS)
91     {
92       if (ord)
93         {
94           opts->x_debug_struct_ordinary[DINFO_USAGE_DFN] = files;
95           opts->x_debug_struct_ordinary[DINFO_USAGE_DIR_USE] = files;
96           opts->x_debug_struct_ordinary[DINFO_USAGE_IND_USE] = files;
97         }
98       if (gen)
99         {
100           opts->x_debug_struct_generic[DINFO_USAGE_DFN] = files;
101           opts->x_debug_struct_generic[DINFO_USAGE_DIR_USE] = files;
102           opts->x_debug_struct_generic[DINFO_USAGE_IND_USE] = files;
103         }
104     }
105   else
106     {
107       if (ord)
108         opts->x_debug_struct_ordinary[usage] = files;
109       if (gen)
110         opts->x_debug_struct_generic[usage] = files;
111     }
112
113   if (*spec == ',')
114     set_struct_debug_option (opts, loc, spec+1);
115   else
116     {
117       /* No more -femit-struct-debug-detailed specifications.
118          Do final checks. */
119       if (*spec != '\0')
120         error_at (loc,
121                   "argument %qs to %<-femit-struct-debug-detailed%> unknown",
122                   spec);
123       if (opts->x_debug_struct_ordinary[DINFO_USAGE_DIR_USE]
124                 < opts->x_debug_struct_ordinary[DINFO_USAGE_IND_USE]
125           || opts->x_debug_struct_generic[DINFO_USAGE_DIR_USE]
126                 < opts->x_debug_struct_generic[DINFO_USAGE_IND_USE])
127         error_at (loc,
128                   "%<-femit-struct-debug-detailed=dir:...%> must allow "
129                   "at least as much as "
130                   "%<-femit-struct-debug-detailed=ind:...%>");
131     }
132 }
133
134 /* Handle -ftree-vectorizer-verbose=VAL for options OPTS.  */
135
136 static void
137 vect_set_verbosity_level (struct gcc_options *opts, int val)
138 {
139    if (val < MAX_VERBOSITY_LEVEL)
140      opts->x_user_vect_verbosity_level = (enum vect_verbosity_levels) val;
141    else
142      opts->x_user_vect_verbosity_level
143       = (enum vect_verbosity_levels) (MAX_VERBOSITY_LEVEL - 1);
144 }
145
146
147 /* Strip off a legitimate source ending from the input string NAME of
148    length LEN.  Rather than having to know the names used by all of
149    our front ends, we strip off an ending of a period followed by
150    up to five characters.  (Java uses ".class".)  */
151
152 void
153 strip_off_ending (char *name, int len)
154 {
155   int i;
156   for (i = 2; i < 6 && len > i; i++)
157     {
158       if (name[len - i] == '.')
159         {
160           name[len - i] = '\0';
161           break;
162         }
163     }
164 }
165
166 /* Find the base name of a path, stripping off both directories and
167    a single final extension. */
168 int
169 base_of_path (const char *path, const char **base_out)
170 {
171   const char *base = path;
172   const char *dot = 0;
173   const char *p = path;
174   char c = *p;
175   while (c)
176     {
177       if (IS_DIR_SEPARATOR(c))
178         {
179           base = p + 1;
180           dot = 0;
181         }
182       else if (c == '.')
183         dot = p;
184       c = *++p;
185     }
186   if (!dot)
187     dot = p;
188   *base_out = base;
189   return dot - base;
190 }
191
192 /* What to print when a switch has no documentation.  */
193 static const char undocumented_msg[] = N_("This switch lacks documentation");
194
195 typedef char *char_p; /* For DEF_VEC_P.  */
196 DEF_VEC_P(char_p);
197 DEF_VEC_ALLOC_P(char_p,heap);
198
199 static void handle_param (struct gcc_options *opts,
200                           struct gcc_options *opts_set, location_t loc,
201                           const char *carg);
202 static void set_debug_level (enum debug_info_type type, int extended,
203                              const char *arg, struct gcc_options *opts,
204                              struct gcc_options *opts_set,
205                              location_t loc);
206 static void set_fast_math_flags (struct gcc_options *opts, int set);
207 static void decode_d_option (const char *arg, struct gcc_options *opts,
208                              location_t loc, diagnostic_context *dc);
209 static void set_unsafe_math_optimizations_flags (struct gcc_options *opts,
210                                                  int set);
211 static void enable_warning_as_error (const char *arg, int value,
212                                      unsigned int lang_mask,
213                                      const struct cl_option_handlers *handlers,
214                                      struct gcc_options *opts,
215                                      struct gcc_options *opts_set,
216                                      location_t loc,
217                                      diagnostic_context *dc);
218
219 /* Handle a back-end option; arguments and return value as for
220    handle_option.  */
221
222 bool
223 target_handle_option (struct gcc_options *opts,
224                       struct gcc_options *opts_set,
225                       const struct cl_decoded_option *decoded,
226                       unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
227                       location_t loc ATTRIBUTE_UNUSED,
228                       const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED,
229                       diagnostic_context *dc)
230 {
231   gcc_assert (opts == &global_options);
232   gcc_assert (opts_set == &global_options_set);
233   gcc_assert (dc == global_dc);
234   gcc_assert (decoded->canonical_option_num_elements <= 2);
235   gcc_assert (kind == DK_UNSPECIFIED);
236   /* Although the location is not passed down to
237      targetm.handle_option, do not make assertions about its value;
238      options may come from optimize attributes and having the correct
239      location in the handler is not generally important.  */
240   return targetm.handle_option (decoded->opt_index, decoded->arg,
241                                 decoded->value);
242 }
243
244 /* Add comma-separated strings to a char_p vector.  */
245
246 static void
247 add_comma_separated_to_vector (void **pvec, const char *arg)
248 {
249   char *tmp;
250   char *r;
251   char *w;
252   char *token_start;
253   VEC(char_p,heap) *vec = (VEC(char_p,heap) *) *pvec;
254
255   /* We never free this string.  */
256   tmp = xstrdup (arg);
257
258   r = tmp;
259   w = tmp;
260   token_start = tmp;
261
262   while (*r != '\0')
263     {
264       if (*r == ',')
265         {
266           *w++ = '\0';
267           ++r;
268           VEC_safe_push (char_p, heap, vec, token_start);
269           token_start = w;
270         }
271       if (*r == '\\' && r[1] == ',')
272         {
273           *w++ = ',';
274           r += 2;
275         }
276       else
277         *w++ = *r++;
278     }
279   if (*token_start != '\0')
280     VEC_safe_push (char_p, heap, vec, token_start);
281
282   *pvec = vec;
283 }
284
285 /* Initialize OPTS and OPTS_SET before using them in parsing options.  */
286
287 void
288 init_options_struct (struct gcc_options *opts, struct gcc_options *opts_set)
289 {
290   size_t num_params = get_num_compiler_params ();
291
292   *opts = global_options_init;
293   memset (opts_set, 0, sizeof (*opts_set));
294
295   opts->x_param_values = XNEWVEC (int, num_params);
296   opts_set->x_param_values = XCNEWVEC (int, num_params);
297   init_param_values (opts->x_param_values);
298
299   /* Use priority coloring if cover classes is not defined for the
300      target.  */
301   if (targetm.ira_cover_classes == NULL)
302     opts->x_flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
303
304   /* Initialize whether `char' is signed.  */
305   opts->x_flag_signed_char = DEFAULT_SIGNED_CHAR;
306   /* Set this to a special "uninitialized" value.  The actual default
307      is set after target options have been processed.  */
308   opts->x_flag_short_enums = 2;
309
310   /* Initialize target_flags before targetm.target_option.optimization
311      so the latter can modify it.  */
312   opts->x_target_flags = targetm.default_target_flags;
313
314   /* Some targets have ABI-specified unwind tables.  */
315   opts->x_flag_unwind_tables = targetm.unwind_tables_default;
316
317   /* Some targets have other target-specific initialization.  */
318   targetm.target_option.init_struct (opts);
319 }
320
321 /* If indicated by the optimization level LEVEL (-Os if SIZE is set,
322    -Ofast if FAST is set), apply the option DEFAULT_OPT to OPTS and
323    OPTS_SET, diagnostic context DC, location LOC, with language mask
324    LANG_MASK and option handlers HANDLERS.  */
325
326 static void
327 maybe_default_option (struct gcc_options *opts,
328                       struct gcc_options *opts_set,
329                       const struct default_options *default_opt,
330                       int level, bool size, bool fast,
331                       unsigned int lang_mask,
332                       const struct cl_option_handlers *handlers,
333                       location_t loc,
334                       diagnostic_context *dc)
335 {
336   const struct cl_option *option = &cl_options[default_opt->opt_index];
337   bool enabled;
338
339   if (size)
340     gcc_assert (level == 2);
341   if (fast)
342     gcc_assert (level == 3);
343
344   switch (default_opt->levels)
345     {
346     case OPT_LEVELS_ALL:
347       enabled = true;
348       break;
349
350     case OPT_LEVELS_0_ONLY:
351       enabled = (level == 0);
352       break;
353
354     case OPT_LEVELS_1_PLUS:
355       enabled = (level >= 1);
356       break;
357
358     case OPT_LEVELS_1_PLUS_SPEED_ONLY:
359       enabled = (level >= 1 && !size);
360       break;
361
362     case OPT_LEVELS_2_PLUS:
363       enabled = (level >= 2);
364       break;
365
366     case OPT_LEVELS_2_PLUS_SPEED_ONLY:
367       enabled = (level >= 2 && !size);
368       break;
369
370     case OPT_LEVELS_3_PLUS:
371       enabled = (level >= 3);
372       break;
373
374     case OPT_LEVELS_3_PLUS_AND_SIZE:
375       enabled = (level >= 3 || size);
376       break;
377
378     case OPT_LEVELS_SIZE:
379       enabled = size;
380       break;
381
382     case OPT_LEVELS_FAST:
383       enabled = fast;
384       break;
385
386     case OPT_LEVELS_NONE:
387     default:
388       gcc_unreachable ();
389     }
390
391   if (enabled)
392     handle_generated_option (opts, opts_set, default_opt->opt_index,
393                              default_opt->arg, default_opt->value,
394                              lang_mask, DK_UNSPECIFIED, loc,
395                              handlers, dc);
396   else if (default_opt->arg == NULL
397            && !(option->flags & CL_REJECT_NEGATIVE))
398     handle_generated_option (opts, opts_set, default_opt->opt_index,
399                              default_opt->arg, !default_opt->value,
400                              lang_mask, DK_UNSPECIFIED, loc,
401                              handlers, dc);
402 }
403
404 /* As indicated by the optimization level LEVEL (-Os if SIZE is set,
405    -Ofast if FAST is set), apply the options in array DEFAULT_OPTS to
406    OPTS and OPTS_SET, diagnostic context DC, location LOC, with
407    language mask LANG_MASK and option handlers HANDLERS.  */
408
409 static void
410 maybe_default_options (struct gcc_options *opts,
411                        struct gcc_options *opts_set,
412                        const struct default_options *default_opts,
413                        int level, bool size, bool fast,
414                        unsigned int lang_mask,
415                        const struct cl_option_handlers *handlers,
416                        location_t loc,
417                        diagnostic_context *dc)
418 {
419   size_t i;
420
421   for (i = 0; default_opts[i].levels != OPT_LEVELS_NONE; i++)
422     maybe_default_option (opts, opts_set, &default_opts[i],
423                           level, size, fast, lang_mask, handlers, loc, dc);
424 }
425
426 /* Table of options enabled by default at different levels.  */
427
428 static const struct default_options default_options_table[] =
429   {
430     /* -O1 optimizations.  */
431     { OPT_LEVELS_1_PLUS, OPT_fdefer_pop, NULL, 1 },
432 #ifdef DELAY_SLOTS
433     { OPT_LEVELS_1_PLUS, OPT_fdelayed_branch, NULL, 1 },
434 #endif
435     { OPT_LEVELS_1_PLUS, OPT_fguess_branch_probability, NULL, 1 },
436     { OPT_LEVELS_1_PLUS, OPT_fcprop_registers, NULL, 1 },
437     { OPT_LEVELS_1_PLUS, OPT_fforward_propagate, NULL, 1 },
438     { OPT_LEVELS_1_PLUS, OPT_fif_conversion, NULL, 1 },
439     { OPT_LEVELS_1_PLUS, OPT_fif_conversion2, NULL, 1 },
440     { OPT_LEVELS_1_PLUS, OPT_fipa_pure_const, NULL, 1 },
441     { OPT_LEVELS_1_PLUS, OPT_fipa_reference, NULL, 1 },
442     { OPT_LEVELS_1_PLUS, OPT_fipa_profile, NULL, 1 },
443     { OPT_LEVELS_1_PLUS, OPT_fmerge_constants, NULL, 1 },
444     { OPT_LEVELS_1_PLUS, OPT_fsplit_wide_types, NULL, 1 },
445     { OPT_LEVELS_1_PLUS, OPT_ftree_ccp, NULL, 1 },
446     { OPT_LEVELS_1_PLUS, OPT_ftree_bit_ccp, NULL, 1 },
447     { OPT_LEVELS_1_PLUS, OPT_ftree_dce, NULL, 1 },
448     { OPT_LEVELS_1_PLUS, OPT_ftree_dominator_opts, NULL, 1 },
449     { OPT_LEVELS_1_PLUS, OPT_ftree_dse, NULL, 1 },
450     { OPT_LEVELS_1_PLUS, OPT_ftree_ter, NULL, 1 },
451     { OPT_LEVELS_1_PLUS, OPT_ftree_sra, NULL, 1 },
452     { OPT_LEVELS_1_PLUS, OPT_ftree_copyrename, NULL, 1 },
453     { OPT_LEVELS_1_PLUS, OPT_ftree_fre, NULL, 1 },
454     { OPT_LEVELS_1_PLUS, OPT_ftree_copy_prop, NULL, 1 },
455     { OPT_LEVELS_1_PLUS, OPT_ftree_sink, NULL, 1 },
456     { OPT_LEVELS_1_PLUS, OPT_ftree_ch, NULL, 1 },
457     { OPT_LEVELS_1_PLUS, OPT_fcombine_stack_adjustments, NULL, 1 },
458
459     /* -O2 optimizations.  */
460     { OPT_LEVELS_2_PLUS, OPT_finline_small_functions, NULL, 1 },
461     { OPT_LEVELS_2_PLUS, OPT_findirect_inlining, NULL, 1 },
462     { OPT_LEVELS_2_PLUS, OPT_fpartial_inlining, NULL, 1 },
463     { OPT_LEVELS_2_PLUS, OPT_fthread_jumps, NULL, 1 },
464     { OPT_LEVELS_2_PLUS, OPT_fcrossjumping, NULL, 1 },
465     { OPT_LEVELS_2_PLUS, OPT_foptimize_sibling_calls, NULL, 1 },
466     { OPT_LEVELS_2_PLUS, OPT_fcse_follow_jumps, NULL, 1 },
467     { OPT_LEVELS_2_PLUS, OPT_fgcse, NULL, 1 },
468     { OPT_LEVELS_2_PLUS, OPT_fexpensive_optimizations, NULL, 1 },
469     { OPT_LEVELS_2_PLUS, OPT_frerun_cse_after_loop, NULL, 1 },
470     { OPT_LEVELS_2_PLUS, OPT_fcaller_saves, NULL, 1 },
471     { OPT_LEVELS_2_PLUS, OPT_fpeephole2, NULL, 1 },
472 #ifdef INSN_SCHEDULING
473   /* Only run the pre-regalloc scheduling pass if optimizing for speed.  */
474     { OPT_LEVELS_2_PLUS_SPEED_ONLY, OPT_fschedule_insns, NULL, 1 },
475     { OPT_LEVELS_2_PLUS, OPT_fschedule_insns2, NULL, 1 },
476 #endif
477     { OPT_LEVELS_2_PLUS, OPT_fregmove, NULL, 1 },
478     { OPT_LEVELS_2_PLUS, OPT_fstrict_aliasing, NULL, 1 },
479     { OPT_LEVELS_2_PLUS, OPT_fstrict_overflow, NULL, 1 },
480     { OPT_LEVELS_2_PLUS, OPT_freorder_blocks, NULL, 1 },
481     { OPT_LEVELS_2_PLUS, OPT_freorder_functions, NULL, 1 },
482     { OPT_LEVELS_2_PLUS, OPT_ftree_vrp, NULL, 1 },
483     { OPT_LEVELS_2_PLUS, OPT_ftree_builtin_call_dce, NULL, 1 },
484     { OPT_LEVELS_2_PLUS, OPT_ftree_pre, NULL, 1 },
485     { OPT_LEVELS_2_PLUS, OPT_ftree_switch_conversion, NULL, 1 },
486     { OPT_LEVELS_2_PLUS, OPT_fipa_cp, NULL, 1 },
487     { OPT_LEVELS_2_PLUS, OPT_fipa_sra, NULL, 1 },
488     { OPT_LEVELS_2_PLUS, OPT_falign_loops, NULL, 1 },
489     { OPT_LEVELS_2_PLUS, OPT_falign_jumps, NULL, 1 },
490     { OPT_LEVELS_2_PLUS, OPT_falign_labels, NULL, 1 },
491     { OPT_LEVELS_2_PLUS, OPT_falign_functions, NULL, 1 },
492
493     /* -O3 optimizations.  */
494     { OPT_LEVELS_3_PLUS, OPT_ftree_loop_distribute_patterns, NULL, 1 },
495     { OPT_LEVELS_3_PLUS, OPT_fpredictive_commoning, NULL, 1 },
496     /* Inlining of functions reducing size is a good idea with -Os
497        regardless of them being declared inline.  */
498     { OPT_LEVELS_3_PLUS_AND_SIZE, OPT_finline_functions, NULL, 1 },
499     { OPT_LEVELS_3_PLUS, OPT_funswitch_loops, NULL, 1 },
500     { OPT_LEVELS_3_PLUS, OPT_fgcse_after_reload, NULL, 1 },
501     { OPT_LEVELS_3_PLUS, OPT_ftree_vectorize, NULL, 1 },
502     { OPT_LEVELS_3_PLUS, OPT_fipa_cp_clone, NULL, 1 },
503
504     /* -Ofast adds optimizations to -O3.  */
505     { OPT_LEVELS_FAST, OPT_ffast_math, NULL, 1 },
506
507     { OPT_LEVELS_NONE, 0, NULL, 0 }
508   };
509
510 /* Default the options in OPTS and OPTS_SET based on the optimization
511    settings in DECODED_OPTIONS and DECODED_OPTIONS_COUNT.  */
512 void
513 default_options_optimization (struct gcc_options *opts,
514                               struct gcc_options *opts_set,
515                               struct cl_decoded_option *decoded_options,
516                               unsigned int decoded_options_count,
517                               location_t loc,
518                               unsigned int lang_mask,
519                               const struct cl_option_handlers *handlers,
520                               diagnostic_context *dc)
521 {
522   unsigned int i;
523   int opt2;
524   int ofast = 0;
525
526   /* Scan to see what optimization level has been specified.  That will
527      determine the default value of many flags.  */
528   for (i = 1; i < decoded_options_count; i++)
529     {
530       struct cl_decoded_option *opt = &decoded_options[i];
531       switch (opt->opt_index)
532         {
533         case OPT_O:
534           if (*opt->arg == '\0')
535             {
536               opts->x_optimize = 1;
537               opts->x_optimize_size = 0;
538               ofast = 0;
539             }
540           else
541             {
542               const int optimize_val = integral_argument (opt->arg);
543               if (optimize_val == -1)
544                 error_at (loc,
545                           "argument to %qs should be a non-negative integer",
546                           "-O");
547               else
548                 {
549                   opts->x_optimize = optimize_val;
550                   if ((unsigned int) opts->x_optimize > 255)
551                     opts->x_optimize = 255;
552                   opts->x_optimize_size = 0;
553                   ofast = 0;
554                 }
555             }
556           break;
557
558         case OPT_Os:
559           opts->x_optimize_size = 1;
560
561           /* Optimizing for size forces optimize to be 2.  */
562           opts->x_optimize = 2;
563           ofast = 0;
564           break;
565
566         case OPT_Ofast:
567           /* -Ofast only adds flags to -O3.  */
568           opts->x_optimize_size = 0;
569           opts->x_optimize = 3;
570           ofast = 1;
571           break;
572
573         default:
574           /* Ignore other options in this prescan.  */
575           break;
576         }
577     }
578
579   maybe_default_options (opts, opts_set, default_options_table,
580                          opts->x_optimize, opts->x_optimize_size,
581                          ofast, lang_mask, handlers, loc, dc);
582
583   /* -O2 param settings.  */
584   opt2 = (opts->x_optimize >= 2);
585
586   /* Track fields in field-sensitive alias analysis.  */
587   maybe_set_param_value
588     (PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE,
589      opt2 ? 100 : default_param_value (PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE),
590      opts->x_param_values, opts_set->x_param_values);
591
592   /* For -O1 only do loop invariant motion for very small loops.  */
593   maybe_set_param_value
594     (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP,
595      opt2 ? default_param_value (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP) : 1000,
596      opts->x_param_values, opts_set->x_param_values);
597
598   if (opts->x_optimize_size)
599     /* We want to crossjump as much as possible.  */
600     maybe_set_param_value (PARAM_MIN_CROSSJUMP_INSNS, 1,
601                            opts->x_param_values, opts_set->x_param_values);
602   else
603     maybe_set_param_value (PARAM_MIN_CROSSJUMP_INSNS,
604                            default_param_value (PARAM_MIN_CROSSJUMP_INSNS),
605                            opts->x_param_values, opts_set->x_param_values);
606
607   /* Allow default optimizations to be specified on a per-machine basis.  */
608   maybe_default_options (opts, opts_set,
609                          targetm.target_option.optimization_table,
610                          opts->x_optimize, opts->x_optimize_size,
611                          ofast, lang_mask, handlers, loc, dc);
612 }
613
614 /* After all options at LOC have been read into OPTS and OPTS_SET,
615    finalize settings of those options and diagnose incompatible
616    combinations.  */
617 void
618 finish_options (struct gcc_options *opts, struct gcc_options *opts_set,
619                 location_t loc)
620 {
621   enum unwind_info_type ui_except;
622
623   if (opts->x_dump_base_name && ! IS_ABSOLUTE_PATH (opts->x_dump_base_name))
624     {
625       /* First try to make OPTS->X_DUMP_BASE_NAME relative to the
626          OPTS->X_DUMP_DIR_NAME directory.  Then try to make
627          OPTS->X_DUMP_BASE_NAME relative to the OPTS->X_AUX_BASE_NAME
628          directory, typically the directory to contain the object
629          file.  */
630       if (opts->x_dump_dir_name)
631         opts->x_dump_base_name = concat (opts->x_dump_dir_name,
632                                          opts->x_dump_base_name, NULL);
633       else if (opts->x_aux_base_name)
634         {
635           const char *aux_base;
636
637           base_of_path (opts->x_aux_base_name, &aux_base);
638           if (opts->x_aux_base_name != aux_base)
639             {
640               int dir_len = aux_base - opts->x_aux_base_name;
641               char *new_dump_base_name =
642                 XNEWVEC (char, strlen (opts->x_dump_base_name) + dir_len + 1);
643
644               /* Copy directory component from OPTS->X_AUX_BASE_NAME.  */
645               memcpy (new_dump_base_name, opts->x_aux_base_name, dir_len);
646               /* Append existing OPTS->X_DUMP_BASE_NAME.  */
647               strcpy (new_dump_base_name + dir_len, opts->x_dump_base_name);
648               opts->x_dump_base_name = new_dump_base_name;
649             }
650         }
651     }
652
653   /* Handle related options for unit-at-a-time, toplevel-reorder, and
654      section-anchors.  */
655   if (!opts->x_flag_unit_at_a_time)
656     {
657       if (opts->x_flag_section_anchors && opts_set->x_flag_section_anchors)
658         error_at (loc, "section anchors must be disabled when unit-at-a-time "
659                   "is disabled");
660       opts->x_flag_section_anchors = 0;
661       if (opts->x_flag_toplevel_reorder == 1)
662         error_at (loc, "toplevel reorder must be disabled when unit-at-a-time "
663                   "is disabled");
664       opts->x_flag_toplevel_reorder = 0;
665     }
666
667   /* -Wmissing-noreturn is alias for -Wsuggest-attribute=noreturn.  */
668   if (opts->x_warn_missing_noreturn)
669     opts->x_warn_suggest_attribute_noreturn = true;
670     
671   /* Unless the user has asked for section anchors, we disable toplevel
672      reordering at -O0 to disable transformations that might be surprising
673      to end users and to get -fno-toplevel-reorder tested.  */
674   if (!opts->x_optimize
675       && opts->x_flag_toplevel_reorder == 2
676       && !(opts->x_flag_section_anchors && opts_set->x_flag_section_anchors))
677     {
678       opts->x_flag_toplevel_reorder = 0;
679       opts->x_flag_section_anchors = 0;
680     }
681   if (!opts->x_flag_toplevel_reorder)
682     {
683       if (opts->x_flag_section_anchors && opts_set->x_flag_section_anchors)
684         error_at (loc, "section anchors must be disabled when toplevel reorder"
685                   " is disabled");
686       opts->x_flag_section_anchors = 0;
687     }
688
689   if (!opts->x_flag_opts_finished)
690     {
691       if (opts->x_flag_pie)
692         opts->x_flag_pic = opts->x_flag_pie;
693       if (opts->x_flag_pic && !opts->x_flag_pie)
694         opts->x_flag_shlib = 1;
695       opts->x_flag_opts_finished = false;
696     }
697
698   if (opts->x_optimize == 0)
699     {
700       /* Inlining does not work if not optimizing,
701          so force it not to be done.  */
702       opts->x_warn_inline = 0;
703       opts->x_flag_no_inline = 1;
704     }
705
706   /* The optimization to partition hot and cold basic blocks into separate
707      sections of the .o and executable files does not work (currently)
708      with exception handling.  This is because there is no support for
709      generating unwind info.  If opts->x_flag_exceptions is turned on
710      we need to turn off the partitioning optimization.  */
711
712   ui_except = targetm.except_unwind_info (opts);
713
714   if (opts->x_flag_exceptions
715       && opts->x_flag_reorder_blocks_and_partition
716       && (ui_except == UI_SJLJ || ui_except == UI_TARGET))
717     {
718       inform (loc,
719               "-freorder-blocks-and-partition does not work "
720               "with exceptions on this architecture");
721       opts->x_flag_reorder_blocks_and_partition = 0;
722       opts->x_flag_reorder_blocks = 1;
723     }
724
725   /* If user requested unwind info, then turn off the partitioning
726      optimization.  */
727
728   if (opts->x_flag_unwind_tables
729       && !targetm.unwind_tables_default
730       && opts->x_flag_reorder_blocks_and_partition
731       && (ui_except == UI_SJLJ || ui_except == UI_TARGET))
732     {
733       inform (loc,
734               "-freorder-blocks-and-partition does not support "
735               "unwind info on this architecture");
736       opts->x_flag_reorder_blocks_and_partition = 0;
737       opts->x_flag_reorder_blocks = 1;
738     }
739
740   /* If the target requested unwind info, then turn off the partitioning
741      optimization with a different message.  Likewise, if the target does not
742      support named sections.  */
743
744   if (opts->x_flag_reorder_blocks_and_partition
745       && (!targetm.have_named_sections
746           || (opts->x_flag_unwind_tables
747               && targetm.unwind_tables_default
748               && (ui_except == UI_SJLJ || ui_except == UI_TARGET))))
749     {
750       inform (loc,
751               "-freorder-blocks-and-partition does not work "
752               "on this architecture");
753       opts->x_flag_reorder_blocks_and_partition = 0;
754       opts->x_flag_reorder_blocks = 1;
755     }
756
757   /* Pipelining of outer loops is only possible when general pipelining
758      capabilities are requested.  */
759   if (!opts->x_flag_sel_sched_pipelining)
760     opts->x_flag_sel_sched_pipelining_outer_loops = 0;
761
762   if (!targetm.ira_cover_classes
763       && opts->x_flag_ira_algorithm == IRA_ALGORITHM_CB)
764     {
765       inform (loc,
766               "-fira-algorithm=CB does not work on this architecture");
767       opts->x_flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
768     }
769
770   if (opts->x_flag_conserve_stack)
771     {
772       maybe_set_param_value (PARAM_LARGE_STACK_FRAME, 100,
773                              opts->x_param_values, opts_set->x_param_values);
774       maybe_set_param_value (PARAM_STACK_FRAME_GROWTH, 40,
775                              opts->x_param_values, opts_set->x_param_values);
776     }
777   if (opts->x_flag_wpa || opts->x_flag_ltrans)
778     {
779       /* These passes are not WHOPR compatible yet.  */
780       opts->x_flag_ipa_pta = 0;
781       opts->x_flag_ipa_struct_reorg = 0;
782     }
783
784   if (opts->x_flag_lto)
785     {
786 #ifdef ENABLE_LTO
787       opts->x_flag_generate_lto = 1;
788
789       /* When generating IL, do not operate in whole-program mode.
790          Otherwise, symbols will be privatized too early, causing link
791          errors later.  */
792       opts->x_flag_whole_program = 0;
793 #else
794       error_at (loc, "LTO support has not been enabled in this configuration");
795 #endif
796     }
797   if ((opts->x_flag_lto_partition_balanced != 0) + (opts->x_flag_lto_partition_1to1 != 0)
798        + (opts->x_flag_lto_partition_none != 0) >= 1)
799     {
800       if ((opts->x_flag_lto_partition_balanced != 0)
801            + (opts->x_flag_lto_partition_1to1 != 0)
802            + (opts->x_flag_lto_partition_none != 0) > 1)
803         error_at (loc, "only one -flto-partition value can be specified");
804     }
805
806   /* We initialize opts->x_flag_split_stack to -1 so that targets can set a
807      default value if they choose based on other options.  */
808   if (opts->x_flag_split_stack == -1)
809     opts->x_flag_split_stack = 0;
810   else if (opts->x_flag_split_stack)
811     {
812       if (!targetm.supports_split_stack (true, opts))
813         {
814           error_at (loc, "%<-fsplit-stack%> is not supported by "
815                     "this compiler configuration");
816           opts->x_flag_split_stack = 0;
817         }
818     }
819 }
820
821 #define LEFT_COLUMN     27
822
823 /* Output ITEM, of length ITEM_WIDTH, in the left column,
824    followed by word-wrapped HELP in a second column.  */
825 static void
826 wrap_help (const char *help,
827            const char *item,
828            unsigned int item_width,
829            unsigned int columns)
830 {
831   unsigned int col_width = LEFT_COLUMN;
832   unsigned int remaining, room, len;
833
834   remaining = strlen (help);
835
836   do
837     {
838       room = columns - 3 - MAX (col_width, item_width);
839       if (room > columns)
840         room = 0;
841       len = remaining;
842
843       if (room < len)
844         {
845           unsigned int i;
846
847           for (i = 0; help[i]; i++)
848             {
849               if (i >= room && len != remaining)
850                 break;
851               if (help[i] == ' ')
852                 len = i;
853               else if ((help[i] == '-' || help[i] == '/')
854                        && help[i + 1] != ' '
855                        && i > 0 && ISALPHA (help[i - 1]))
856                 len = i + 1;
857             }
858         }
859
860       printf( "  %-*.*s %.*s\n", col_width, item_width, item, len, help);
861       item_width = 0;
862       while (help[len] == ' ')
863         len++;
864       help += len;
865       remaining -= len;
866     }
867   while (remaining);
868 }
869
870 /* Print help for a specific front-end, etc.  */
871 static void
872 print_filtered_help (unsigned int include_flags,
873                      unsigned int exclude_flags,
874                      unsigned int any_flags,
875                      unsigned int columns,
876                      struct gcc_options *opts,
877                      unsigned int lang_mask)
878 {
879   unsigned int i;
880   const char *help;
881   bool found = false;
882   bool displayed = false;
883
884   if (include_flags == CL_PARAMS)
885     {
886       for (i = 0; i < LAST_PARAM; i++)
887         {
888           const char *param = compiler_params[i].option;
889
890           help = compiler_params[i].help;
891           if (help == NULL || *help == '\0')
892             {
893               if (exclude_flags & CL_UNDOCUMENTED)
894                 continue;
895               help = undocumented_msg;
896             }
897
898           /* Get the translation.  */
899           help = _(help);
900
901           wrap_help (help, param, strlen (param), columns);
902         }
903       putchar ('\n');
904       return;
905     }
906
907   if (!opts->x_help_printed)
908     opts->x_help_printed = XCNEWVAR (char, cl_options_count);
909
910   if (!opts->x_help_enum_printed)
911     opts->x_help_enum_printed = XCNEWVAR (char, cl_enums_count);
912
913   for (i = 0; i < cl_options_count; i++)
914     {
915       char new_help[128];
916       const struct cl_option *option = cl_options + i;
917       unsigned int len;
918       const char *opt;
919       const char *tab;
920
921       if (include_flags == 0
922           || ((option->flags & include_flags) != include_flags))
923         {
924           if ((option->flags & any_flags) == 0)
925             continue;
926         }
927
928       /* Skip unwanted switches.  */
929       if ((option->flags & exclude_flags) != 0)
930         continue;
931
932       /* The driver currently prints its own help text.  */
933       if ((option->flags & CL_DRIVER) != 0
934           && (option->flags & (((1U << cl_lang_count) - 1)
935                                | CL_COMMON | CL_TARGET)) == 0)
936         continue;
937
938       found = true;
939       /* Skip switches that have already been printed.  */
940       if (opts->x_help_printed[i])
941         continue;
942
943       opts->x_help_printed[i] = true;
944
945       help = option->help;
946       if (help == NULL)
947         {
948           if (exclude_flags & CL_UNDOCUMENTED)
949             continue;
950           help = undocumented_msg;
951         }
952
953       /* Get the translation.  */
954       help = _(help);
955
956       /* Find the gap between the name of the
957          option and its descriptive text.  */
958       tab = strchr (help, '\t');
959       if (tab)
960         {
961           len = tab - help;
962           opt = help;
963           help = tab + 1;
964         }
965       else
966         {
967           opt = option->opt_text;
968           len = strlen (opt);
969         }
970
971       /* With the -Q option enabled we change the descriptive text associated
972          with an option to be an indication of its current setting.  */
973       if (!quiet_flag)
974         {
975           void *flag_var = option_flag_var (i, opts);
976
977           if (len < (LEFT_COLUMN + 2))
978             strcpy (new_help, "\t\t");
979           else
980             strcpy (new_help, "\t");
981
982           if (flag_var != NULL
983               && option->var_type != CLVC_DEFER)
984             {
985               if (option->flags & CL_JOINED)
986                 {
987                   if (option->var_type == CLVC_STRING)
988                     {
989                       if (* (const char **) flag_var != NULL)
990                         snprintf (new_help + strlen (new_help),
991                                   sizeof (new_help) - strlen (new_help),
992                                   * (const char **) flag_var);
993                     }
994                   else if (option->var_type == CLVC_ENUM)
995                     {
996                       const struct cl_enum *e = &cl_enums[option->var_enum];
997                       int value;
998                       const char *arg = NULL;
999
1000                       value = e->get (flag_var);
1001                       enum_value_to_arg (e->values, &arg, value, lang_mask);
1002                       if (arg == NULL)
1003                         arg = _("[default]");
1004                       snprintf (new_help + strlen (new_help),
1005                                 sizeof (new_help) - strlen (new_help),
1006                                 arg);
1007                     }
1008                   else
1009                     sprintf (new_help + strlen (new_help),
1010                              "%#x", * (int *) flag_var);
1011                 }
1012               else
1013                 strcat (new_help, option_enabled (i, opts)
1014                         ? _("[enabled]") : _("[disabled]"));
1015             }
1016
1017           help = new_help;
1018         }
1019
1020       wrap_help (help, opt, len, columns);
1021       displayed = true;
1022
1023       if (option->var_type == CLVC_ENUM
1024           && opts->x_help_enum_printed[option->var_enum] != 2)
1025         opts->x_help_enum_printed[option->var_enum] = 1;
1026     }
1027
1028   if (! found)
1029     {
1030       unsigned int langs = include_flags & CL_LANG_ALL;
1031
1032       if (langs == 0)
1033         printf (_(" No options with the desired characteristics were found\n"));
1034       else
1035         {
1036           unsigned int i;
1037
1038           /* PR 31349: Tell the user how to see all of the
1039              options supported by a specific front end.  */
1040           for (i = 0; (1U << i) < CL_LANG_ALL; i ++)
1041             if ((1U << i) & langs)
1042               printf (_(" None found.  Use --help=%s to show *all* the options supported by the %s front-end\n"),
1043                       lang_names[i], lang_names[i]);
1044         }
1045
1046     }
1047   else if (! displayed)
1048     printf (_(" All options with the desired characteristics have already been displayed\n"));
1049
1050   putchar ('\n');
1051
1052   /* Print details of enumerated option arguments, if those
1053      enumerations have help text headings provided.  If no help text
1054      is provided, presume that the possible values are listed in the
1055      help text for the relevant options.  */
1056   for (i = 0; i < cl_enums_count; i++)
1057     {
1058       unsigned int j, pos;
1059
1060       if (opts->x_help_enum_printed[i] != 1)
1061         continue;
1062       if (cl_enums[i].help == NULL)
1063         continue;
1064       printf ("  %s\n    ", _(cl_enums[i].help));
1065       pos = 4;
1066       for (j = 0; cl_enums[i].values[j].arg != NULL; j++)
1067         {
1068           unsigned int len = strlen (cl_enums[i].values[j].arg);
1069
1070           if (pos > 4 && pos + 1 + len <= columns)
1071             {
1072               printf (" %s", cl_enums[i].values[j].arg);
1073               pos += 1 + len;
1074             }
1075           else
1076             {
1077               if (pos > 4)
1078                 {
1079                   printf ("\n    ");
1080                   pos = 4;
1081                 }
1082               printf ("%s", cl_enums[i].values[j].arg);
1083               pos += len;
1084             }
1085         }
1086       printf ("\n\n");
1087       opts->x_help_enum_printed[i] = 2;
1088     }
1089 }
1090
1091 /* Display help for a specified type of option.
1092    The options must have ALL of the INCLUDE_FLAGS set
1093    ANY of the flags in the ANY_FLAGS set
1094    and NONE of the EXCLUDE_FLAGS set.  The current option state is in
1095    OPTS; LANG_MASK is used for interpreting enumerated option state.  */
1096 static void
1097 print_specific_help (unsigned int include_flags,
1098                      unsigned int exclude_flags,
1099                      unsigned int any_flags,
1100                      struct gcc_options *opts,
1101                      unsigned int lang_mask)
1102 {
1103   unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
1104   const char * description = NULL;
1105   const char * descrip_extra = "";
1106   size_t i;
1107   unsigned int flag;
1108
1109   /* Sanity check: Make sure that we do not have more
1110      languages than we have bits available to enumerate them.  */
1111   gcc_assert ((1U << cl_lang_count) < CL_MIN_OPTION_CLASS);
1112
1113   /* If we have not done so already, obtain
1114      the desired maximum width of the output.  */
1115   if (opts->x_help_columns == 0)
1116     {
1117       const char *p;
1118
1119       p = getenv ("COLUMNS");
1120       if (p != NULL)
1121         {
1122           int value = atoi (p);
1123
1124           if (value > 0)
1125             opts->x_help_columns = value;
1126         }
1127
1128       if (opts->x_help_columns == 0)
1129         /* Use a reasonable default.  */
1130         opts->x_help_columns = 80;
1131     }
1132
1133   /* Decide upon the title for the options that we are going to display.  */
1134   for (i = 0, flag = 1; flag <= CL_MAX_OPTION_CLASS; flag <<= 1, i ++)
1135     {
1136       switch (flag & include_flags)
1137         {
1138         case 0:
1139         case CL_DRIVER:
1140           break;
1141
1142         case CL_TARGET:
1143           description = _("The following options are target specific");
1144           break;
1145         case CL_WARNING:
1146           description = _("The following options control compiler warning messages");
1147           break;
1148         case CL_OPTIMIZATION:
1149           description = _("The following options control optimizations");
1150           break;
1151         case CL_COMMON:
1152           description = _("The following options are language-independent");
1153           break;
1154         case CL_PARAMS:
1155           description = _("The --param option recognizes the following as parameters");
1156           break;
1157         default:
1158           if (i >= cl_lang_count)
1159             break;
1160           if (exclude_flags & all_langs_mask)
1161             description = _("The following options are specific to just the language ");
1162           else
1163             description = _("The following options are supported by the language ");
1164           descrip_extra = lang_names [i];
1165           break;
1166         }
1167     }
1168
1169   if (description == NULL)
1170     {
1171       if (any_flags == 0)
1172         {
1173           if (include_flags & CL_UNDOCUMENTED)
1174             description = _("The following options are not documented");
1175           else if (include_flags & CL_SEPARATE)
1176             description = _("The following options take separate arguments");
1177           else if (include_flags & CL_JOINED)
1178             description = _("The following options take joined arguments");
1179           else
1180             {
1181               internal_error ("unrecognized include_flags 0x%x passed to print_specific_help",
1182                               include_flags);
1183               return;
1184             }
1185         }
1186       else
1187         {
1188           if (any_flags & all_langs_mask)
1189             description = _("The following options are language-related");
1190           else
1191             description = _("The following options are language-independent");
1192         }
1193     }
1194
1195   printf ("%s%s:\n", description, descrip_extra);
1196   print_filtered_help (include_flags, exclude_flags, any_flags,
1197                        opts->x_help_columns, opts, lang_mask);
1198 }
1199
1200 /* Handle target- and language-independent options.  Return zero to
1201    generate an "unknown option" message.  Only options that need
1202    extra handling need to be listed here; if you simply want
1203    DECODED->value assigned to a variable, it happens automatically.  */
1204
1205 bool
1206 common_handle_option (struct gcc_options *opts,
1207                       struct gcc_options *opts_set,
1208                       const struct cl_decoded_option *decoded,
1209                       unsigned int lang_mask, int kind ATTRIBUTE_UNUSED,
1210                       location_t loc,
1211                       const struct cl_option_handlers *handlers,
1212                       diagnostic_context *dc)
1213 {
1214   size_t scode = decoded->opt_index;
1215   const char *arg = decoded->arg;
1216   int value = decoded->value;
1217   enum opt_code code = (enum opt_code) scode;
1218
1219   gcc_assert (decoded->canonical_option_num_elements <= 2);
1220
1221   switch (code)
1222     {
1223     case OPT__param:
1224       handle_param (opts, opts_set, loc, arg);
1225       break;
1226
1227     case OPT__help:
1228       {
1229         unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
1230         unsigned int undoc_mask;
1231         unsigned int i;
1232
1233         undoc_mask = ((opts->x_verbose_flag | opts->x_extra_warnings)
1234                       ? 0
1235                       : CL_UNDOCUMENTED);
1236         /* First display any single language specific options.  */
1237         for (i = 0; i < cl_lang_count; i++)
1238           print_specific_help
1239             (1U << i, (all_langs_mask & (~ (1U << i))) | undoc_mask, 0, opts,
1240              lang_mask);
1241         /* Next display any multi language specific options.  */
1242         print_specific_help (0, undoc_mask, all_langs_mask, opts, lang_mask);
1243         /* Then display any remaining, non-language options.  */
1244         for (i = CL_MIN_OPTION_CLASS; i <= CL_MAX_OPTION_CLASS; i <<= 1)
1245           if (i != CL_DRIVER)
1246             print_specific_help (i, undoc_mask, 0, opts, lang_mask);
1247         opts->x_exit_after_options = true;
1248         break;
1249       }
1250
1251     case OPT__target_help:
1252       print_specific_help (CL_TARGET, CL_UNDOCUMENTED, 0, opts, lang_mask);
1253       opts->x_exit_after_options = true;
1254
1255       /* Allow the target a chance to give the user some additional information.  */
1256       if (targetm.help)
1257         targetm.help ();
1258       break;
1259
1260     case OPT__help_:
1261       {
1262         const char * a = arg;
1263         unsigned int include_flags = 0;
1264         /* Note - by default we include undocumented options when listing
1265            specific classes.  If you only want to see documented options
1266            then add ",^undocumented" to the --help= option.  E.g.:
1267
1268            --help=target,^undocumented  */
1269         unsigned int exclude_flags = 0;
1270
1271         /* Walk along the argument string, parsing each word in turn.
1272            The format is:
1273            arg = [^]{word}[,{arg}]
1274            word = {optimizers|target|warnings|undocumented|
1275                    params|common|<language>}  */
1276         while (* a != 0)
1277           {
1278             static const struct
1279             {
1280               const char * string;
1281               unsigned int flag;
1282             }
1283             specifics[] =
1284             {
1285               { "optimizers", CL_OPTIMIZATION },
1286               { "target", CL_TARGET },
1287               { "warnings", CL_WARNING },
1288               { "undocumented", CL_UNDOCUMENTED },
1289               { "params", CL_PARAMS },
1290               { "joined", CL_JOINED },
1291               { "separate", CL_SEPARATE },
1292               { "common", CL_COMMON },
1293               { NULL, 0 }
1294             };
1295             unsigned int * pflags;
1296             const char * comma;
1297             unsigned int lang_flag, specific_flag;
1298             unsigned int len;
1299             unsigned int i;
1300
1301             if (* a == '^')
1302               {
1303                 ++ a;
1304                 pflags = & exclude_flags;
1305               }
1306             else
1307               pflags = & include_flags;
1308
1309             comma = strchr (a, ',');
1310             if (comma == NULL)
1311               len = strlen (a);
1312             else
1313               len = comma - a;
1314             if (len == 0)
1315               {
1316                 a = comma + 1;
1317                 continue;
1318               }
1319
1320             /* Check to see if the string matches an option class name.  */
1321             for (i = 0, specific_flag = 0; specifics[i].string != NULL; i++)
1322               if (strncasecmp (a, specifics[i].string, len) == 0)
1323                 {
1324                   specific_flag = specifics[i].flag;
1325                   break;
1326                 }
1327
1328             /* Check to see if the string matches a language name.
1329                Note - we rely upon the alpha-sorted nature of the entries in
1330                the lang_names array, specifically that shorter names appear
1331                before their longer variants.  (i.e. C before C++).  That way
1332                when we are attempting to match --help=c for example we will
1333                match with C first and not C++.  */
1334             for (i = 0, lang_flag = 0; i < cl_lang_count; i++)
1335               if (strncasecmp (a, lang_names[i], len) == 0)
1336                 {
1337                   lang_flag = 1U << i;
1338                   break;
1339                 }
1340
1341             if (specific_flag != 0)
1342               {
1343                 if (lang_flag == 0)
1344                   * pflags |= specific_flag;
1345                 else
1346                   {
1347                     /* The option's argument matches both the start of a
1348                        language name and the start of an option class name.
1349                        We have a special case for when the user has
1350                        specified "--help=c", but otherwise we have to issue
1351                        a warning.  */
1352                     if (strncasecmp (a, "c", len) == 0)
1353                       * pflags |= lang_flag;
1354                     else
1355                       warning_at (loc, 0,
1356                                   "--help argument %q.*s is ambiguous, "
1357                                   "please be more specific",
1358                                   len, a);
1359                   }
1360               }
1361             else if (lang_flag != 0)
1362               * pflags |= lang_flag;
1363             else
1364               warning_at (loc, 0,
1365                           "unrecognized argument to --help= option: %q.*s",
1366                           len, a);
1367
1368             if (comma == NULL)
1369               break;
1370             a = comma + 1;
1371           }
1372
1373         if (include_flags)
1374           print_specific_help (include_flags, exclude_flags, 0, opts,
1375                                lang_mask);
1376         opts->x_exit_after_options = true;
1377         break;
1378       }
1379
1380     case OPT__version:
1381       opts->x_exit_after_options = true;
1382       break;
1383
1384     case OPT_O:
1385     case OPT_Os:
1386     case OPT_Ofast:
1387       /* Currently handled in a prescan.  */
1388       break;
1389
1390     case OPT_Werror_:
1391       enable_warning_as_error (arg, value, lang_mask, handlers,
1392                                opts, opts_set, loc, dc);
1393       break;
1394
1395     case OPT_Wlarger_than_:
1396       opts->x_larger_than_size = value;
1397       opts->x_warn_larger_than = value != -1;
1398       break;
1399
1400     case OPT_Wfatal_errors:
1401       dc->fatal_errors = value;
1402       break;
1403
1404     case OPT_Wframe_larger_than_:
1405       opts->x_frame_larger_than_size = value;
1406       opts->x_warn_frame_larger_than = value != -1;
1407       break;
1408
1409     case OPT_Wstrict_aliasing:
1410       set_Wstrict_aliasing (opts, value);
1411       break;
1412
1413     case OPT_Wstrict_overflow:
1414       opts->x_warn_strict_overflow = (value
1415                                       ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
1416                                       : 0);
1417       break;
1418
1419     case OPT_Wsystem_headers:
1420       dc->dc_warn_system_headers = value;
1421       break;
1422
1423     case OPT_aux_info:
1424       opts->x_flag_gen_aux_info = 1;
1425       break;
1426
1427     case OPT_auxbase_strip:
1428       {
1429         char *tmp = xstrdup (arg);
1430         strip_off_ending (tmp, strlen (tmp));
1431         if (tmp[0])
1432           opts->x_aux_base_name = tmp;
1433       }
1434       break;
1435
1436     case OPT_d:
1437       decode_d_option (arg, opts, loc, dc);
1438       break;
1439
1440     case OPT_fcall_used_:
1441     case OPT_fcall_saved_:
1442       /* Deferred.  */
1443       break;
1444
1445     case OPT_fdbg_cnt_:
1446     case OPT_fdbg_cnt_list:
1447       /* Deferred.  */
1448       break;
1449
1450     case OPT_fdebug_prefix_map_:
1451       /* Deferred.  */
1452       break;
1453
1454     case OPT_fdiagnostics_show_location_:
1455       diagnostic_prefixing_rule (dc) = (diagnostic_prefixing_rule_t) value;
1456       break;
1457
1458     case OPT_fdiagnostics_show_option:
1459       dc->show_option_requested = value;
1460       break;
1461
1462     case OPT_fdump_:
1463       /* Deferred.  */
1464       break;
1465
1466     case OPT_ffast_math:
1467       set_fast_math_flags (opts, value);
1468       break;
1469
1470     case OPT_funsafe_math_optimizations:
1471       set_unsafe_math_optimizations_flags (opts, value);
1472       break;
1473
1474     case OPT_ffixed_:
1475       /* Deferred.  */
1476       break;
1477
1478     case OPT_finline_limit_:
1479       set_param_value ("max-inline-insns-single", value / 2,
1480                        opts->x_param_values, opts_set->x_param_values);
1481       set_param_value ("max-inline-insns-auto", value / 2,
1482                        opts->x_param_values, opts_set->x_param_values);
1483       break;
1484
1485     case OPT_finstrument_functions_exclude_function_list_:
1486       add_comma_separated_to_vector
1487         (&opts->x_flag_instrument_functions_exclude_functions, arg);
1488       break;
1489
1490     case OPT_finstrument_functions_exclude_file_list_:
1491       add_comma_separated_to_vector
1492         (&opts->x_flag_instrument_functions_exclude_files, arg);
1493       break;
1494
1495     case OPT_fmessage_length_:
1496       pp_set_line_maximum_length (dc->printer, value);
1497       break;
1498
1499     case OPT_fpack_struct_:
1500       if (value <= 0 || (value & (value - 1)) || value > 16)
1501         error_at (loc,
1502                   "structure alignment must be a small power of two, not %d",
1503                   value);
1504       else
1505         opts->x_initial_max_fld_align = value;
1506       break;
1507
1508     case OPT_fplugin_:
1509     case OPT_fplugin_arg_:
1510       /* Deferred.  */
1511       break;
1512
1513     case OPT_fprofile_use_:
1514       opts->x_profile_data_prefix = xstrdup (arg);
1515       opts->x_flag_profile_use = true;
1516       value = true;
1517       /* No break here - do -fprofile-use processing. */
1518     case OPT_fprofile_use:
1519       if (!opts_set->x_flag_branch_probabilities)
1520         opts->x_flag_branch_probabilities = value;
1521       if (!opts_set->x_flag_profile_values)
1522         opts->x_flag_profile_values = value;
1523       if (!opts_set->x_flag_unroll_loops)
1524         opts->x_flag_unroll_loops = value;
1525       if (!opts_set->x_flag_peel_loops)
1526         opts->x_flag_peel_loops = value;
1527       if (!opts_set->x_flag_tracer)
1528         opts->x_flag_tracer = value;
1529       if (!opts_set->x_flag_value_profile_transformations)
1530         opts->x_flag_value_profile_transformations = value;
1531       if (!opts_set->x_flag_inline_functions)
1532         opts->x_flag_inline_functions = value;
1533       if (!opts_set->x_flag_ipa_cp)
1534         opts->x_flag_ipa_cp = value;
1535       if (!opts_set->x_flag_ipa_cp_clone
1536           && value && opts->x_flag_ipa_cp)
1537         opts->x_flag_ipa_cp_clone = value;
1538       if (!opts_set->x_flag_predictive_commoning)
1539         opts->x_flag_predictive_commoning = value;
1540       if (!opts_set->x_flag_unswitch_loops)
1541         opts->x_flag_unswitch_loops = value;
1542       if (!opts_set->x_flag_gcse_after_reload)
1543         opts->x_flag_gcse_after_reload = value;
1544       break;
1545
1546     case OPT_fprofile_generate_:
1547       opts->x_profile_data_prefix = xstrdup (arg);
1548       value = true;
1549       /* No break here - do -fprofile-generate processing. */
1550     case OPT_fprofile_generate:
1551       if (!opts_set->x_profile_arc_flag)
1552         opts->x_profile_arc_flag = value;
1553       if (!opts_set->x_flag_profile_values)
1554         opts->x_flag_profile_values = value;
1555       if (!opts_set->x_flag_value_profile_transformations)
1556         opts->x_flag_value_profile_transformations = value;
1557       if (!opts_set->x_flag_inline_functions)
1558         opts->x_flag_inline_functions = value;
1559       break;
1560
1561     case OPT_fshow_column:
1562       dc->show_column = value;
1563       break;
1564
1565     case OPT_frandom_seed:
1566       /* The real switch is -fno-random-seed.  */
1567       if (value)
1568         return false;
1569       /* Deferred.  */
1570       break;
1571
1572     case OPT_frandom_seed_:
1573       /* Deferred.  */
1574       break;
1575
1576     case OPT_fsched_verbose_:
1577 #ifdef INSN_SCHEDULING
1578       /* Handled with Var in common.opt.  */
1579       break;
1580 #else
1581       return false;
1582 #endif
1583
1584     case OPT_fsched_stalled_insns_:
1585       opts->x_flag_sched_stalled_insns = value;
1586       if (opts->x_flag_sched_stalled_insns == 0)
1587         opts->x_flag_sched_stalled_insns = -1;
1588       break;
1589
1590     case OPT_fsched_stalled_insns_dep_:
1591       opts->x_flag_sched_stalled_insns_dep = value;
1592       break;
1593
1594     case OPT_fstack_check_:
1595       if (!strcmp (arg, "no"))
1596         opts->x_flag_stack_check = NO_STACK_CHECK;
1597       else if (!strcmp (arg, "generic"))
1598         /* This is the old stack checking method.  */
1599         opts->x_flag_stack_check = STACK_CHECK_BUILTIN
1600                            ? FULL_BUILTIN_STACK_CHECK
1601                            : GENERIC_STACK_CHECK;
1602       else if (!strcmp (arg, "specific"))
1603         /* This is the new stack checking method.  */
1604         opts->x_flag_stack_check = STACK_CHECK_BUILTIN
1605                            ? FULL_BUILTIN_STACK_CHECK
1606                            : STACK_CHECK_STATIC_BUILTIN
1607                              ? STATIC_BUILTIN_STACK_CHECK
1608                              : GENERIC_STACK_CHECK;
1609       else
1610         warning_at (loc, 0, "unknown stack check parameter \"%s\"", arg);
1611       break;
1612
1613     case OPT_fstack_limit:
1614       /* The real switch is -fno-stack-limit.  */
1615       if (value)
1616         return false;
1617       /* Deferred.  */
1618       break;
1619
1620     case OPT_fstack_limit_register_:
1621     case OPT_fstack_limit_symbol_:
1622       /* Deferred.  */
1623       break;
1624
1625     case OPT_ftree_vectorizer_verbose_:
1626       vect_set_verbosity_level (opts, value);
1627       break;
1628
1629     case OPT_g:
1630       set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg, opts, opts_set,
1631                        loc);
1632       break;
1633
1634     case OPT_gcoff:
1635       set_debug_level (SDB_DEBUG, false, arg, opts, opts_set, loc);
1636       break;
1637
1638     case OPT_gdwarf_:
1639       if (value < 2 || value > 4)
1640         error_at (loc, "dwarf version %d is not supported", value);
1641       else
1642         dwarf_version = value;
1643       set_debug_level (DWARF2_DEBUG, false, "", opts, opts_set, loc);
1644       break;
1645
1646     case OPT_ggdb:
1647       set_debug_level (NO_DEBUG, 2, arg, opts, opts_set, loc);
1648       break;
1649
1650     case OPT_gstabs:
1651     case OPT_gstabs_:
1652       set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg, opts, opts_set,
1653                        loc);
1654       break;
1655
1656     case OPT_gvms:
1657       set_debug_level (VMS_DEBUG, false, arg, opts, opts_set, loc);
1658       break;
1659
1660     case OPT_gxcoff:
1661     case OPT_gxcoff_:
1662       set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg, opts, opts_set,
1663                        loc);
1664       break;
1665
1666     case OPT_pedantic_errors:
1667       opts->x_pedantic = 1;
1668       dc->pedantic_errors = 1;
1669       break;
1670
1671     case OPT_flto:
1672       opts->x_flag_lto = "";
1673       break;
1674
1675     case OPT_w:
1676       dc->dc_inhibit_warnings = true;
1677       break;
1678
1679     case OPT_fmax_errors_:
1680       dc->max_errors = value;
1681       break;
1682
1683     case OPT_fuse_linker_plugin:
1684       /* No-op. Used by the driver and passed to us because it starts with f.*/
1685       break;
1686
1687     default:
1688       /* If the flag was handled in a standard way, assume the lack of
1689          processing here is intentional.  */
1690       gcc_assert (option_flag_var (scode, opts));
1691       break;
1692     }
1693
1694   return true;
1695 }
1696
1697 /* Handle --param NAME=VALUE.  */
1698 static void
1699 handle_param (struct gcc_options *opts, struct gcc_options *opts_set,
1700               location_t loc, const char *carg)
1701 {
1702   char *equal, *arg;
1703   int value;
1704
1705   arg = xstrdup (carg);
1706   equal = strchr (arg, '=');
1707   if (!equal)
1708     error_at (loc, "%s: --param arguments should be of the form NAME=VALUE",
1709               arg);
1710   else
1711     {
1712       value = integral_argument (equal + 1);
1713       if (value == -1)
1714         error_at (loc, "invalid --param value %qs", equal + 1);
1715       else
1716         {
1717           *equal = '\0';
1718           set_param_value (arg, value,
1719                            opts->x_param_values, opts_set->x_param_values);
1720         }
1721     }
1722
1723   free (arg);
1724 }
1725
1726 /* Used to set the level of strict aliasing warnings in OPTS,
1727    when no level is specified (i.e., when -Wstrict-aliasing, and not
1728    -Wstrict-aliasing=level was given).
1729    ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
1730    and 0 otherwise.  After calling this function, wstrict_aliasing will be
1731    set to the default value of -Wstrict_aliasing=level, currently 3.  */
1732 void
1733 set_Wstrict_aliasing (struct gcc_options *opts, int onoff)
1734 {
1735   gcc_assert (onoff == 0 || onoff == 1);
1736   if (onoff != 0)
1737     opts->x_warn_strict_aliasing = 3;
1738   else
1739     opts->x_warn_strict_aliasing = 0;
1740 }
1741
1742 /* The following routines are useful in setting all the flags that
1743    -ffast-math and -fno-fast-math imply.  */
1744 static void
1745 set_fast_math_flags (struct gcc_options *opts, int set)
1746 {
1747   opts->x_flag_unsafe_math_optimizations = set;
1748   set_unsafe_math_optimizations_flags (opts, set);
1749   opts->x_flag_finite_math_only = set;
1750   opts->x_flag_errno_math = !set;
1751   if (set)
1752     {
1753       opts->x_flag_signaling_nans = 0;
1754       opts->x_flag_rounding_math = 0;
1755       opts->x_flag_cx_limited_range = 1;
1756     }
1757 }
1758
1759 /* When -funsafe-math-optimizations is set the following
1760    flags are set as well.  */
1761 static void
1762 set_unsafe_math_optimizations_flags (struct gcc_options *opts, int set)
1763 {
1764   opts->x_flag_trapping_math = !set;
1765   opts->x_flag_signed_zeros = !set;
1766   opts->x_flag_associative_math = set;
1767   opts->x_flag_reciprocal_math = set;
1768 }
1769
1770 /* Return true iff flags in OPTS are set as if -ffast-math.  */
1771 bool
1772 fast_math_flags_set_p (const struct gcc_options *opts)
1773 {
1774   return (!opts->x_flag_trapping_math
1775           && opts->x_flag_unsafe_math_optimizations
1776           && opts->x_flag_finite_math_only
1777           && !opts->x_flag_signed_zeros
1778           && !opts->x_flag_errno_math);
1779 }
1780
1781 /* Return true iff flags are set as if -ffast-math but using the flags stored
1782    in the struct cl_optimization structure.  */
1783 bool
1784 fast_math_flags_struct_set_p (struct cl_optimization *opt)
1785 {
1786   return (!opt->x_flag_trapping_math
1787           && opt->x_flag_unsafe_math_optimizations
1788           && opt->x_flag_finite_math_only
1789           && !opt->x_flag_signed_zeros
1790           && !opt->x_flag_errno_math);
1791 }
1792
1793 /* Handle a debug output -g switch for options OPTS
1794    (OPTS_SET->x_write_symbols storing whether a debug type was passed
1795    explicitly), location LOC.  EXTENDED is true or false to support
1796    extended output (2 is special and means "-ggdb" was given).  */
1797 static void
1798 set_debug_level (enum debug_info_type type, int extended, const char *arg,
1799                  struct gcc_options *opts, struct gcc_options *opts_set,
1800                  location_t loc)
1801 {
1802   opts->x_use_gnu_debug_info_extensions = extended;
1803
1804   if (type == NO_DEBUG)
1805     {
1806       if (opts->x_write_symbols == NO_DEBUG)
1807         {
1808           opts->x_write_symbols = PREFERRED_DEBUGGING_TYPE;
1809
1810           if (extended == 2)
1811             {
1812 #ifdef DWARF2_DEBUGGING_INFO
1813               opts->x_write_symbols = DWARF2_DEBUG;
1814 #elif defined DBX_DEBUGGING_INFO
1815               opts->x_write_symbols = DBX_DEBUG;
1816 #endif
1817             }
1818
1819           if (opts->x_write_symbols == NO_DEBUG)
1820             warning_at (loc, 0, "target system does not support debug output");
1821         }
1822     }
1823   else
1824     {
1825       /* Does it conflict with an already selected type?  */
1826       if (opts_set->x_write_symbols != NO_DEBUG
1827           && opts->x_write_symbols != NO_DEBUG
1828           && type != opts->x_write_symbols)
1829         error_at (loc, "debug format \"%s\" conflicts with prior selection",
1830                   debug_type_names[type]);
1831       opts->x_write_symbols = type;
1832       opts_set->x_write_symbols = type;
1833     }
1834
1835   /* A debug flag without a level defaults to level 2.  */
1836   if (*arg == '\0')
1837     {
1838       if (!opts->x_debug_info_level)
1839         opts->x_debug_info_level = DINFO_LEVEL_NORMAL;
1840     }
1841   else
1842     {
1843       int argval = integral_argument (arg);
1844       if (argval == -1)
1845         error_at (loc, "unrecognised debug output level \"%s\"", arg);
1846       else if (argval > 3)
1847         error_at (loc, "debug output level %s is too high", arg);
1848       else
1849         opts->x_debug_info_level = (enum debug_info_levels) argval;
1850     }
1851 }
1852
1853 /* Arrange to dump core on error for diagnostic context DC.  (The
1854    regular error message is still printed first, except in the case of
1855    abort ().)  */
1856
1857 static void
1858 setup_core_dumping (diagnostic_context *dc)
1859 {
1860 #ifdef SIGABRT
1861   signal (SIGABRT, SIG_DFL);
1862 #endif
1863 #if defined(HAVE_SETRLIMIT)
1864   {
1865     struct rlimit rlim;
1866     if (getrlimit (RLIMIT_CORE, &rlim) != 0)
1867       fatal_error ("getting core file size maximum limit: %m");
1868     rlim.rlim_cur = rlim.rlim_max;
1869     if (setrlimit (RLIMIT_CORE, &rlim) != 0)
1870       fatal_error ("setting core file size limit to maximum: %m");
1871   }
1872 #endif
1873   diagnostic_abort_on_error (dc);
1874 }
1875
1876 /* Parse a -d<ARG> command line switch for OPTS, location LOC,
1877    diagnostic context DC.  */
1878
1879 static void
1880 decode_d_option (const char *arg, struct gcc_options *opts,
1881                  location_t loc, diagnostic_context *dc)
1882 {
1883   int c;
1884
1885   while (*arg)
1886     switch (c = *arg++)
1887       {
1888       case 'A':
1889         opts->x_flag_debug_asm = 1;
1890         break;
1891       case 'p':
1892         opts->x_flag_print_asm_name = 1;
1893         break;
1894       case 'P':
1895         opts->x_flag_dump_rtl_in_asm = 1;
1896         opts->x_flag_print_asm_name = 1;
1897         break;
1898       case 'v':
1899         opts->x_graph_dump_format = vcg;
1900         break;
1901       case 'x':
1902         opts->x_rtl_dump_and_exit = 1;
1903         break;
1904       case 'D': /* These are handled by the preprocessor.  */
1905       case 'I':
1906       case 'M':
1907       case 'N':
1908       case 'U':
1909         break;
1910       case 'H':
1911         setup_core_dumping (dc);
1912         break;
1913       case 'a':
1914         opts->x_flag_dump_all_passed = true;
1915         break;
1916
1917       default:
1918           warning_at (loc, 0, "unrecognized gcc debugging option: %c", c);
1919         break;
1920       }
1921 }
1922
1923 /* Enable (or disable if VALUE is 0) a warning option ARG (language
1924    mask LANG_MASK, option handlers HANDLERS) as an error for option
1925    structures OPTS and OPTS_SET, diagnostic context DC (possibly
1926    NULL), location LOC.  This is used by -Werror=.  */
1927
1928 static void
1929 enable_warning_as_error (const char *arg, int value, unsigned int lang_mask,
1930                          const struct cl_option_handlers *handlers,
1931                          struct gcc_options *opts,
1932                          struct gcc_options *opts_set,
1933                          location_t loc, diagnostic_context *dc)
1934 {
1935   char *new_option;
1936   int option_index;
1937
1938   new_option = XNEWVEC (char, strlen (arg) + 2);
1939   new_option[0] = 'W';
1940   strcpy (new_option + 1, arg);
1941   option_index = find_opt (new_option, lang_mask);
1942   if (option_index == OPT_SPECIAL_unknown)
1943     {
1944       error_at (loc, "-Werror=%s: no option -%s", arg, new_option);
1945     }
1946   else
1947     {
1948       const diagnostic_t kind = value ? DK_ERROR : DK_WARNING;
1949
1950       control_warning_option (option_index, (int) kind, value,
1951                               loc, lang_mask,
1952                               handlers, opts, opts_set, dc);
1953     }
1954   free (new_option);
1955 }
1956
1957 /* Return malloced memory for the name of the option OPTION_INDEX
1958    which enabled a diagnostic (context CONTEXT), originally of type
1959    ORIG_DIAG_KIND but possibly converted to DIAG_KIND by options such
1960    as -Werror.  */
1961
1962 char *
1963 option_name (diagnostic_context *context, int option_index,
1964              diagnostic_t orig_diag_kind, diagnostic_t diag_kind)
1965 {
1966   if (option_index)
1967     {
1968       /* A warning classified as an error.  */
1969       if ((orig_diag_kind == DK_WARNING || orig_diag_kind == DK_PEDWARN)
1970           && diag_kind == DK_ERROR)
1971         return concat (cl_options[OPT_Werror_].opt_text,
1972                        /* Skip over "-W".  */
1973                        cl_options[option_index].opt_text + 2,
1974                        NULL);
1975       /* A warning with option.  */
1976       else
1977         return xstrdup (cl_options[option_index].opt_text);
1978     }
1979   /* A warning without option classified as an error.  */
1980   else if (orig_diag_kind == DK_WARNING || orig_diag_kind == DK_PEDWARN
1981            || diag_kind == DK_WARNING)
1982     {
1983       if (context->warning_as_error_requested)
1984         return xstrdup (cl_options[OPT_Werror].opt_text);
1985       else
1986         return xstrdup (_("enabled by default"));
1987     }
1988   else
1989     return NULL;
1990 }