OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [opts.c] - Blame information for rev 865

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.