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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [opts.c] - Blame information for rev 280

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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