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

Subversion Repositories openrisc

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

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

Line No. Rev Author Line
1 684 jeremybenn
/* Command line option handling.  Code involving global state that
2
   should not be shared with the driver.
3
   Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
4
   Free Software Foundation, Inc.
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 "coretypes.h"
25
#include "diagnostic.h"
26
#include "opts.h"
27
#include "flags.h"
28
#include "ggc.h"
29
#include "tree.h" /* Required by langhooks.h.  */
30
#include "langhooks.h"
31
#include "tm.h" /* Required by rtl.h.  */
32
#include "rtl.h"
33
#include "dbgcnt.h"
34
#include "debug.h"
35
#include "lto-streamer.h"
36
#include "output.h"
37
#include "plugin.h"
38
#include "toplev.h"
39
#include "tree-pass.h"
40
 
41
typedef const char *const_char_p; /* For DEF_VEC_P.  */
42
DEF_VEC_P(const_char_p);
43
DEF_VEC_ALLOC_P(const_char_p,heap);
44
 
45
static VEC(const_char_p,heap) *ignored_options;
46
 
47
/* Input file names.  */
48
const char **in_fnames;
49
unsigned num_in_fnames;
50
 
51
/* Return a malloced slash-separated list of languages in MASK.  */
52
 
53
static char *
54
write_langs (unsigned int mask)
55
{
56
  unsigned int n = 0, len = 0;
57
  const char *lang_name;
58
  char *result;
59
 
60
  for (n = 0; (lang_name = lang_names[n]) != 0; n++)
61
    if (mask & (1U << n))
62
      len += strlen (lang_name) + 1;
63
 
64
  result = XNEWVEC (char, len);
65
  len = 0;
66
  for (n = 0; (lang_name = lang_names[n]) != 0; n++)
67
    if (mask & (1U << n))
68
      {
69
        if (len)
70
          result[len++] = '/';
71
        strcpy (result + len, lang_name);
72
        len += strlen (lang_name);
73
      }
74
 
75
  result[len] = 0;
76
 
77
  return result;
78
}
79
 
80
/* Complain that switch DECODED does not apply to this front end (mask
81
   LANG_MASK).  */
82
 
83
static void
84
complain_wrong_lang (const struct cl_decoded_option *decoded,
85
                     unsigned int lang_mask)
86
{
87
  const struct cl_option *option = &cl_options[decoded->opt_index];
88
  const char *text = decoded->orig_option_with_args_text;
89
  char *ok_langs = NULL, *bad_lang = NULL;
90
  unsigned int opt_flags = option->flags;
91
 
92
  if (!lang_hooks.complain_wrong_lang_p (option))
93
    return;
94
 
95
  opt_flags &= ((1U << cl_lang_count) - 1) | CL_DRIVER;
96
  if (opt_flags != CL_DRIVER)
97
    ok_langs = write_langs (opt_flags);
98
  if (lang_mask != CL_DRIVER)
99
    bad_lang = write_langs (lang_mask);
100
 
101
  if (opt_flags == CL_DRIVER)
102
    error ("command line option %qs is valid for the driver but not for %s",
103
           text, bad_lang);
104
  else if (lang_mask == CL_DRIVER)
105
    gcc_unreachable ();
106
  else
107
    /* Eventually this should become a hard error IMO.  */
108
    warning (0, "command line option %qs is valid for %s but not for %s",
109
             text, ok_langs, bad_lang);
110
 
111
  free (ok_langs);
112
  free (bad_lang);
113
}
114
 
115
/* Buffer the unknown option described by the string OPT.  Currently,
116
   we only complain about unknown -Wno-* options if they may have
117
   prevented a diagnostic. Otherwise, we just ignore them.  Note that
118
   if we do complain, it is only as a warning, not an error; passing
119
   the compiler an unrecognised -Wno-* option should never change
120
   whether the compilation succeeds or fails.  */
121
 
122
static void
123
postpone_unknown_option_warning (const char *opt)
124
{
125
  VEC_safe_push (const_char_p, heap, ignored_options, opt);
126
}
127
 
128
/* Produce a warning for each option previously buffered.  */
129
 
130
void
131
print_ignored_options (void)
132
{
133
  while (!VEC_empty (const_char_p, ignored_options))
134
    {
135
      const char *opt;
136
 
137
      opt = VEC_pop (const_char_p, ignored_options);
138
      warning_at (UNKNOWN_LOCATION, 0,
139
                  "unrecognized command line option \"%s\"", opt);
140
    }
141
}
142
 
143
/* Handle an unknown option DECODED, returning true if an error should
144
   be given.  */
145
 
146
static bool
147
unknown_option_callback (const struct cl_decoded_option *decoded)
148
{
149
  const char *opt = decoded->arg;
150
 
151
  if (opt[1] == 'W' && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-'
152
      && !(decoded->errors & CL_ERR_NEGATIVE))
153
    {
154
      /* We don't generate warnings for unknown -Wno-* options unless
155
         we issue diagnostics.  */
156
      postpone_unknown_option_warning (opt);
157
      return false;
158
    }
159
  else
160
    return true;
161
}
162
 
163
/* Handle a front-end option; arguments and return value as for
164
   handle_option.  */
165
 
166
static bool
167
lang_handle_option (struct gcc_options *opts,
168
                    struct gcc_options *opts_set,
169
                    const struct cl_decoded_option *decoded,
170
                    unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
171
                    location_t loc,
172
                    const struct cl_option_handlers *handlers,
173
                    diagnostic_context *dc)
174
{
175
  gcc_assert (opts == &global_options);
176
  gcc_assert (opts_set == &global_options_set);
177
  gcc_assert (dc == global_dc);
178
  gcc_assert (decoded->canonical_option_num_elements <= 2);
179
  return lang_hooks.handle_option (decoded->opt_index, decoded->arg,
180
                                   decoded->value, kind, loc, handlers);
181
}
182
 
183
/* Handle FILENAME from the command line.  */
184
 
185
static void
186
add_input_filename (const char *filename)
187
{
188
  num_in_fnames++;
189
  in_fnames = XRESIZEVEC (const char *, in_fnames, num_in_fnames);
190
  in_fnames[num_in_fnames - 1] = filename;
191
}
192
 
193
/* Handle the vector of command line options (located at LOC), storing
194
   the results of processing DECODED_OPTIONS and DECODED_OPTIONS_COUNT
195
   in OPTS and OPTS_SET and using DC for diagnostic state.  LANG_MASK
196
   contains has a single bit set representing the current language.
197
   HANDLERS describes what functions to call for the options.  */
198
 
199
static void
200
read_cmdline_options (struct gcc_options *opts, struct gcc_options *opts_set,
201
                      struct cl_decoded_option *decoded_options,
202
                      unsigned int decoded_options_count,
203
                      location_t loc,
204
                      unsigned int lang_mask,
205
                      const struct cl_option_handlers *handlers,
206
                      diagnostic_context *dc)
207
{
208
  unsigned int i;
209
 
210
  for (i = 1; i < decoded_options_count; i++)
211
    {
212
      if (decoded_options[i].opt_index == OPT_SPECIAL_input_file)
213
        {
214
          /* Input files should only ever appear on the main command
215
             line.  */
216
          gcc_assert (opts == &global_options);
217
          gcc_assert (opts_set == &global_options_set);
218
 
219
          if (opts->x_main_input_filename == NULL)
220
            {
221
              opts->x_main_input_filename = decoded_options[i].arg;
222
              opts->x_main_input_baselength
223
                = base_of_path (opts->x_main_input_filename,
224
                                &opts->x_main_input_basename);
225
            }
226
          add_input_filename (decoded_options[i].arg);
227
          continue;
228
        }
229
 
230
      read_cmdline_option (opts, opts_set,
231
                           decoded_options + i, loc, lang_mask, handlers,
232
                           dc);
233
    }
234
}
235
 
236
/* Language mask determined at initialization.  */
237
static unsigned int initial_lang_mask;
238
 
239
/* Initialize global options-related settings at start-up.  */
240
 
241
void
242
init_options_once (void)
243
{
244
  /* Perform language-specific options initialization.  */
245
  initial_lang_mask = lang_hooks.option_lang_mask ();
246
 
247
  lang_hooks.initialize_diagnostics (global_dc);
248
}
249
 
250
/* Decode command-line options to an array, like
251
   decode_cmdline_options_to_array and with the same arguments but
252
   using the default lang_mask.  */
253
 
254
void
255
decode_cmdline_options_to_array_default_mask (unsigned int argc,
256
                                              const char **argv,
257
                                              struct cl_decoded_option **decoded_options,
258
                                              unsigned int *decoded_options_count)
259
{
260
  decode_cmdline_options_to_array (argc, argv,
261
                                   initial_lang_mask | CL_COMMON | CL_TARGET,
262
                                   decoded_options, decoded_options_count);
263
}
264
 
265
/* Set *HANDLERS to the default set of option handlers for use in the
266
   compilers proper (not the driver).  */
267
void
268
set_default_handlers (struct cl_option_handlers *handlers)
269
{
270
  handlers->unknown_option_callback = unknown_option_callback;
271
  handlers->wrong_lang_callback = complain_wrong_lang;
272
  handlers->num_handlers = 3;
273
  handlers->handlers[0].handler = lang_handle_option;
274
  handlers->handlers[0].mask = initial_lang_mask;
275
  handlers->handlers[1].handler = common_handle_option;
276
  handlers->handlers[1].mask = CL_COMMON;
277
  handlers->handlers[2].handler = target_handle_option;
278
  handlers->handlers[2].mask = CL_TARGET;
279
}
280
 
281
/* Parse command line options and set default flag values.  Do minimal
282
   options processing.  The decoded options are in *DECODED_OPTIONS
283
   and *DECODED_OPTIONS_COUNT; settings go in OPTS, OPTS_SET and DC;
284
   the options are located at LOC.  */
285
void
286
decode_options (struct gcc_options *opts, struct gcc_options *opts_set,
287
                struct cl_decoded_option *decoded_options,
288
                unsigned int decoded_options_count,
289
                location_t loc, diagnostic_context *dc)
290
{
291
  struct cl_option_handlers handlers;
292
 
293
  unsigned int lang_mask;
294
 
295
  lang_mask = initial_lang_mask;
296
 
297
  set_default_handlers (&handlers);
298
 
299
  default_options_optimization (opts, opts_set,
300
                                decoded_options, decoded_options_count,
301
                                loc, lang_mask, &handlers, dc);
302
 
303
  read_cmdline_options (opts, opts_set,
304
                        decoded_options, decoded_options_count,
305
                        loc, lang_mask,
306
                        &handlers, dc);
307
 
308
  finish_options (opts, opts_set, loc);
309
}
310
 
311
/* Process common options that have been deferred until after the
312
   handlers have been called for all options.  */
313
 
314
void
315
handle_common_deferred_options (void)
316
{
317
  unsigned int i;
318
  cl_deferred_option *opt;
319
  VEC(cl_deferred_option,heap) *vec
320
    = (VEC(cl_deferred_option,heap) *) common_deferred_options;
321
 
322
  if (flag_dump_all_passed)
323
    enable_rtl_dump_file ();
324
 
325
  FOR_EACH_VEC_ELT (cl_deferred_option, vec, i, opt)
326
    {
327
      switch (opt->opt_index)
328
        {
329
        case OPT_fcall_used_:
330
          fix_register (opt->arg, 0, 1);
331
          break;
332
 
333
        case OPT_fcall_saved_:
334
          fix_register (opt->arg, 0, 0);
335
          break;
336
 
337
        case OPT_fdbg_cnt_:
338
          dbg_cnt_process_opt (opt->arg);
339
          break;
340
 
341
        case OPT_fdbg_cnt_list:
342
          dbg_cnt_list_all_counters ();
343
          break;
344
 
345
        case OPT_fdebug_prefix_map_:
346
          add_debug_prefix_map (opt->arg);
347
          break;
348
 
349
        case OPT_fdump_:
350
          if (!dump_switch_p (opt->arg))
351
            error ("unrecognized command line option %<-fdump-%s%>", opt->arg);
352
          break;
353
 
354
        case OPT_fenable_:
355
        case OPT_fdisable_:
356
          if (opt->opt_index == OPT_fenable_)
357
            enable_pass (opt->arg);
358
          else
359
            disable_pass (opt->arg);
360
          break;
361
 
362
        case OPT_ffixed_:
363
          /* Deferred.  */
364
          fix_register (opt->arg, 1, 1);
365
          break;
366
 
367
        case OPT_fplugin_:
368
#ifdef ENABLE_PLUGIN
369
          add_new_plugin (opt->arg);
370
#else
371
          error ("plugin support is disabled; configure with --enable-plugin");
372
#endif
373
          break;
374
 
375
        case OPT_fplugin_arg_:
376
#ifdef ENABLE_PLUGIN
377
          parse_plugin_arg_opt (opt->arg);
378
#else
379
          error ("plugin support is disabled; configure with --enable-plugin");
380
#endif
381
          break;
382
 
383
        case OPT_frandom_seed:
384
          /* The real switch is -fno-random-seed.  */
385
          if (!opt->value)
386
            set_random_seed (NULL);
387
          break;
388
 
389
        case OPT_frandom_seed_:
390
          set_random_seed (opt->arg);
391
          break;
392
 
393
        case OPT_fstack_limit:
394
          /* The real switch is -fno-stack-limit.  */
395
          if (!opt->value)
396
            stack_limit_rtx = NULL_RTX;
397
          break;
398
 
399
        case OPT_fstack_limit_register_:
400
          {
401
            int reg = decode_reg_name (opt->arg);
402
            if (reg < 0)
403
              error ("unrecognized register name %qs", opt->arg);
404
            else
405
              stack_limit_rtx = gen_rtx_REG (Pmode, reg);
406
          }
407
          break;
408
 
409
        case OPT_fstack_limit_symbol_:
410
          stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (opt->arg));
411
          break;
412
 
413
        default:
414
          gcc_unreachable ();
415
        }
416
    }
417
}

powered by: WebSVN 2.1.0

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