Subversion Repositories openrisc

/* C/ObjC/C++ command line option handling.

   Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011

   Free Software Foundation, Inc.

   Contributed by Neil Booth.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under

the terms of the GNU General Public License as published by the Free

Software Foundation; either version 3, or (at your option) any later

version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY

WARRANTY; without even the implied warranty of MERCHANTABILITY or

FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

for more details.

You should have received a copy of the GNU General Public License

along with GCC; see the file COPYING3.  If not see

<http://www.gnu.org/licenses/>.  */

#include "config.h"

#include "system.h"

#include "coretypes.h"

#include "tree.h"

#include "c-common.h"

#include "c-pragma.h"

#include "flags.h"

#include "toplev.h"

#include "langhooks.h"

#include "diagnostic.h"

#include "intl.h"

#include "cppdefault.h"

#include "incpath.h"

#include "debug.h"              /* For debug_hooks.  */

#include "opts.h"

#include "options.h"

#include "mkdeps.h"

#include "c-target.h"

#include "tm.h"                 /* For BYTES_BIG_ENDIAN,

                                   DOLLARS_IN_IDENTIFIERS,

                                   STDC_0_IN_SYSTEM_HEADERS,

                                   TARGET_FLT_EVAL_METHOD_NON_DEFAULT and

                                   TARGET_OPTF.  */

#include "tm_p.h"               /* For C_COMMON_OVERRIDE_OPTIONS.  */

#ifndef DOLLARS_IN_IDENTIFIERS

# define DOLLARS_IN_IDENTIFIERS true

#endif

#ifndef TARGET_SYSTEM_ROOT

# define TARGET_SYSTEM_ROOT NULL

#endif

#ifndef TARGET_OPTF

#define TARGET_OPTF(ARG)

#endif

/* CPP's options.  */

cpp_options *cpp_opts;

/* Input filename.  */

static const char *this_input_filename;

/* Filename and stream for preprocessed output.  */

static const char *out_fname;

static FILE *out_stream;

/* Append dependencies to deps_file.  */

static bool deps_append;

/* If dependency switches (-MF etc.) have been given.  */

static bool deps_seen;

/* If -v seen.  */

static bool verbose;

/* Dependency output file.  */

static const char *deps_file;

/* The prefix given by -iprefix, if any.  */

static const char *iprefix;

/* The multilib directory given by -imultilib, if any.  */

static const char *imultilib;

/* The system root, if any.  Overridden by -isysroot.  */

static const char *sysroot = TARGET_SYSTEM_ROOT;

/* Zero disables all standard directories for headers.  */

static bool std_inc = true;

/* Zero disables the C++-specific standard directories for headers.  */

static bool std_cxx_inc = true;

/* If the quote chain has been split by -I-.  */

static bool quote_chain_split;

/* If -Wunused-macros.  */

static bool warn_unused_macros;

/* If -Wvariadic-macros.  */

static bool warn_variadic_macros = true;

/* Number of deferred options.  */

static size_t deferred_count;

/* Number of deferred options scanned for -include.  */

static size_t include_cursor;

static void handle_OPT_d (const char *);

static void set_std_cxx98 (int);

static void set_std_cxx11 (int);

static void set_std_c89 (int, int);

static void set_std_c99 (int);

static void set_std_c11 (int);

static void check_deps_environment_vars (void);

static void handle_deferred_opts (void);

static void sanitize_cpp_opts (void);

static void add_prefixed_path (const char *, size_t);

static void push_command_line_include (void);

static void cb_file_change (cpp_reader *, const struct line_map *);

static void cb_dir_change (cpp_reader *, const char *);

static void c_finish_options (void);

#ifndef STDC_0_IN_SYSTEM_HEADERS

#define STDC_0_IN_SYSTEM_HEADERS 0

#endif

/* Holds switches parsed by c_common_handle_option (), but whose

   handling is deferred to c_common_post_options ().  */

static void defer_opt (enum opt_code, const char *);

static struct deferred_opt

{

  enum opt_code code;

  const char *arg;

} *deferred_opts;

extern const unsigned int

c_family_lang_mask = (CL_C | CL_CXX | CL_ObjC | CL_ObjCXX);

/* Defer option CODE with argument ARG.  */

static void

defer_opt (enum opt_code code, const char *arg)

{

  deferred_opts[deferred_count].code = code;

  deferred_opts[deferred_count].arg = arg;

  deferred_count++;

}

/* Return language mask for option parsing.  */

unsigned int

c_common_option_lang_mask (void)

{

  static const unsigned int lang_flags[] = {CL_C, CL_ObjC, CL_CXX, CL_ObjCXX};

  return lang_flags[c_language];

}

/* Common diagnostics initialization.  */

void

c_common_initialize_diagnostics (diagnostic_context *context)

{

  /* This is conditionalized only because that is the way the front

     ends used to do it.  Maybe this should be unconditional?  */

  if (c_dialect_cxx ())

    {

      /* By default wrap lines at 80 characters.  Is getenv

         ("COLUMNS") preferable?  */

      diagnostic_line_cutoff (context) = 80;

      /* By default, emit location information once for every

         diagnostic message.  */

      diagnostic_prefixing_rule (context) = DIAGNOSTICS_SHOW_PREFIX_ONCE;

    }

  context->opt_permissive = OPT_fpermissive;

}

/* Whether options from all C-family languages should be accepted

   quietly.  */

static bool accept_all_c_family_options = false;

/* Return whether to complain about a wrong-language option.  */

bool

c_common_complain_wrong_lang_p (const struct cl_option *option)

{

  if (accept_all_c_family_options

      && (option->flags & c_family_lang_mask))

    return false;

  return true;

}

/* Initialize options structure OPTS.  */

void

c_common_init_options_struct (struct gcc_options *opts)

{

  opts->x_flag_exceptions = c_dialect_cxx ();

  opts->x_warn_pointer_arith = c_dialect_cxx ();

  opts->x_warn_write_strings = c_dialect_cxx ();

  opts->x_flag_warn_unused_result = true;

  /* By default, C99-like requirements for complex multiply and divide.  */

  opts->x_flag_complex_method = 2;

}

/* Common initialization before calling option handlers.  */

void

c_common_init_options (unsigned int decoded_options_count,

                       struct cl_decoded_option *decoded_options)

{

  unsigned int i;

  struct cpp_callbacks *cb;

  parse_in = cpp_create_reader (c_dialect_cxx () ? CLK_GNUCXX: CLK_GNUC89,

                                ident_hash, line_table);

  cb = cpp_get_callbacks (parse_in);

  cb->error = c_cpp_error;

  cpp_opts = cpp_get_options (parse_in);

  cpp_opts->dollars_in_ident = DOLLARS_IN_IDENTIFIERS;

  cpp_opts->objc = c_dialect_objc ();

  /* Reset to avoid warnings on internal definitions.  We set it just

     before passing on command-line options to cpplib.  */

  cpp_opts->warn_dollars = 0;

  deferred_opts = XNEWVEC (struct deferred_opt, decoded_options_count);

  if (c_language == clk_c)

    {

      /* If preprocessing assembly language, accept any of the C-family

         front end options since the driver may pass them through.  */

      for (i = 1; i < decoded_options_count; i++)

        if (decoded_options[i].opt_index == OPT_lang_asm)

          {

            accept_all_c_family_options = true;

            break;

          }

    }

}

/* Handle switch SCODE with argument ARG.  VALUE is true, unless no-

   form of an -f or -W option was given.  Returns false if the switch was

   invalid, true if valid.  Use HANDLERS in recursive handle_option calls.  */

bool

c_common_handle_option (size_t scode, const char *arg, int value,

                        int kind, location_t loc,

                        const struct cl_option_handlers *handlers)

{

  const struct cl_option *option = &cl_options[scode];

  enum opt_code code = (enum opt_code) scode;

  bool result = true;

  /* Prevent resetting the language standard to a C dialect when the driver

     has already determined that we're looking at assembler input.  */

  bool preprocessing_asm_p = (cpp_get_options (parse_in)->lang == CLK_ASM);

  switch (code)

    {

    default:

      if (cl_options[code].flags & c_family_lang_mask)

        {

          if ((option->flags & CL_TARGET)

              && ! targetcm.handle_c_option (scode, arg, value))

            result = false;

          break;

        }

      result = false;

      break;

    case OPT__output_pch_:

      pch_file = arg;

      break;

    case OPT_A:

      defer_opt (code, arg);

      break;

    case OPT_C:

      cpp_opts->discard_comments = 0;

      break;

    case OPT_CC:

      cpp_opts->discard_comments = 0;

      cpp_opts->discard_comments_in_macro_exp = 0;

      break;

    case OPT_D:

      defer_opt (code, arg);

      break;

    case OPT_H:

      cpp_opts->print_include_names = 1;

      break;

    case OPT_F:

      TARGET_OPTF (xstrdup (arg));

      break;

    case OPT_I:

      if (strcmp (arg, "-"))

        add_path (xstrdup (arg), BRACKET, 0, true);

      else

        {

          if (quote_chain_split)

            error ("-I- specified twice");

          quote_chain_split = true;

          split_quote_chain ();

          inform (input_location, "obsolete option -I- used, please use -iquote instead");

        }

      break;

    case OPT_M:

    case OPT_MM:

      /* When doing dependencies with -M or -MM, suppress normal

         preprocessed output, but still do -dM etc. as software

         depends on this.  Preprocessed output does occur if -MD, -MMD

         or environment var dependency generation is used.  */

      cpp_opts->deps.style = (code == OPT_M ? DEPS_SYSTEM: DEPS_USER);

      flag_no_output = 1;

      break;

    case OPT_MD:

    case OPT_MMD:

      cpp_opts->deps.style = (code == OPT_MD ? DEPS_SYSTEM: DEPS_USER);

      cpp_opts->deps.need_preprocessor_output = true;

      deps_file = arg;

      break;

    case OPT_MF:

      deps_seen = true;

      deps_file = arg;

      break;

    case OPT_MG:

      deps_seen = true;

      cpp_opts->deps.missing_files = true;

      break;

    case OPT_MP:

      deps_seen = true;

      cpp_opts->deps.phony_targets = true;

      break;

    case OPT_MQ:

    case OPT_MT:

      deps_seen = true;

      defer_opt (code, arg);

      break;

    case OPT_P:

      flag_no_line_commands = 1;

      break;

    case OPT_U:

      defer_opt (code, arg);

      break;

    case OPT_Wall:

      warn_unused = value;

      set_Wformat (value);

      handle_generated_option (&global_options, &global_options_set,

                               OPT_Wimplicit, NULL, value,

                               c_family_lang_mask, kind, loc,

                               handlers, global_dc);

      warn_char_subscripts = value;

      warn_missing_braces = value;

      warn_parentheses = value;

      warn_return_type = value;

      warn_sequence_point = value;      /* Was C only.  */

      warn_switch = value;

      if (warn_strict_aliasing == -1)

        set_Wstrict_aliasing (&global_options, value);

      warn_address = value;

      if (warn_strict_overflow == -1)

        warn_strict_overflow = value;

      warn_array_bounds = value;

      warn_volatile_register_var = value;

      /* Only warn about unknown pragmas that are not in system

         headers.  */

      warn_unknown_pragmas = value;

      warn_uninitialized = value;

      warn_maybe_uninitialized = value;

      if (!c_dialect_cxx ())

        {

          /* We set this to 2 here, but 1 in -Wmain, so -ffreestanding

             can turn it off only if it's not explicit.  */

          if (warn_main == -1)

            warn_main = (value ? 2 : 0);

          /* In C, -Wall turns on -Wenum-compare, which we do here.

             In C++ it is on by default, which is done in

             c_common_post_options.  */

          if (warn_enum_compare == -1)

            warn_enum_compare = value;

        }

      else

        {

          /* C++-specific warnings.  */

          warn_sign_compare = value;

          warn_reorder = value;

          warn_cxx0x_compat = value;

          warn_delnonvdtor = value;

          warn_narrowing = value;

        }

      cpp_opts->warn_trigraphs = value;

      cpp_opts->warn_comments = value;

      cpp_opts->warn_num_sign_change = value;

      if (warn_pointer_sign == -1)

        warn_pointer_sign = value;

      break;

    case OPT_Wbuiltin_macro_redefined:

      cpp_opts->warn_builtin_macro_redefined = value;

      break;

    case OPT_Wcomment:

      cpp_opts->warn_comments = value;

      break;

    case OPT_Wc___compat:

      /* Because -Wenum-compare is the default in C++, -Wc++-compat

         implies -Wenum-compare.  */

      if (warn_enum_compare == -1 && value)

        warn_enum_compare = value;

      /* Because C++ always warns about a goto which misses an

         initialization, -Wc++-compat turns on -Wjump-misses-init.  */

      if (warn_jump_misses_init == -1 && value)

        warn_jump_misses_init = value;

      cpp_opts->warn_cxx_operator_names = value;

      break;

    case OPT_Wc__0x_compat:

      warn_narrowing = value;

      break;

    case OPT_Wdeprecated:

      cpp_opts->cpp_warn_deprecated = value;

      break;

    case OPT_Wendif_labels:

      cpp_opts->warn_endif_labels = value;

      break;

    case OPT_Wformat:

      set_Wformat (value);

      break;

    case OPT_Wformat_:

      set_Wformat (atoi (arg));

      break;

    case OPT_Wimplicit:

      gcc_assert (value == 0 || value == 1);

      if (warn_implicit_int == -1)

        handle_generated_option (&global_options, &global_options_set,

                                 OPT_Wimplicit_int, NULL, value,

                                 c_family_lang_mask, kind, loc, handlers,

                                 global_dc);

      if (warn_implicit_function_declaration == -1)

        handle_generated_option (&global_options, &global_options_set,

                                 OPT_Wimplicit_function_declaration, NULL,

                                 value, c_family_lang_mask, kind, loc,

                                 handlers, global_dc);

      break;

    case OPT_Winvalid_pch:

      cpp_opts->warn_invalid_pch = value;

      break;

    case OPT_Wlong_long:

      cpp_opts->cpp_warn_long_long = value;

      break;

    case OPT_Wmissing_include_dirs:

      cpp_opts->warn_missing_include_dirs = value;

      break;

    case OPT_Wmultichar:

      cpp_opts->warn_multichar = value;

      break;

    case OPT_Wnormalized_:

      if (kind == DK_ERROR)

        {

          gcc_assert (!arg);

          inform (input_location, "-Werror=normalized=: set -Wnormalized=nfc");

          cpp_opts->warn_normalize = normalized_C;

        }

      else

        {

          if (!value || (arg && strcasecmp (arg, "none") == 0))

            cpp_opts->warn_normalize = normalized_none;

          else if (!arg || strcasecmp (arg, "nfkc") == 0)

            cpp_opts->warn_normalize = normalized_KC;

          else if (strcasecmp (arg, "id") == 0)

            cpp_opts->warn_normalize = normalized_identifier_C;

          else if (strcasecmp (arg, "nfc") == 0)

            cpp_opts->warn_normalize = normalized_C;

          else

            error ("argument %qs to %<-Wnormalized%> not recognized", arg);

          break;

        }

    case OPT_Wreturn_type:

      warn_return_type = value;

      break;

    case OPT_Wtraditional:

      cpp_opts->cpp_warn_traditional = value;

      break;

    case OPT_Wtrigraphs:

      cpp_opts->warn_trigraphs = value;

      break;

    case OPT_Wundef:

      cpp_opts->warn_undef = value;

      break;

    case OPT_Wunknown_pragmas:

      /* Set to greater than 1, so that even unknown pragmas in

         system headers will be warned about.  */

      warn_unknown_pragmas = value * 2;

      break;

    case OPT_Wunused_macros:

      warn_unused_macros = value;

      break;

    case OPT_Wvariadic_macros:

      warn_variadic_macros = value;

      break;

    case OPT_Wwrite_strings:

      warn_write_strings = value;

      break;

    case OPT_Weffc__:

      warn_ecpp = value;

      if (value)

        warn_nonvdtor = true;

      break;

    case OPT_ansi:

      if (!c_dialect_cxx ())

        set_std_c89 (false, true);

      else

        set_std_cxx98 (true);

      break;

    case OPT_d:

      handle_OPT_d (arg);

      break;

    case OPT_fcond_mismatch:

      if (!c_dialect_cxx ())

        {

          flag_cond_mismatch = value;

          break;

        }

      warning (0, "switch %qs is no longer supported", option->opt_text);

      break;

    case OPT_fbuiltin_:

      if (value)

        result = false;

      else

        disable_builtin_function (arg);

      break;

    case OPT_fdirectives_only:

      cpp_opts->directives_only = value;

      break;

    case OPT_fdollars_in_identifiers:

      cpp_opts->dollars_in_ident = value;

      break;

    case OPT_ffreestanding:

      value = !value;

      /* Fall through....  */

    case OPT_fhosted:

      flag_hosted = value;

      flag_no_builtin = !value;

      break;

    case OPT_fconstant_string_class_:

      constant_string_class_name = arg;

      break;

    case OPT_fextended_identifiers:

      cpp_opts->extended_identifiers = value;

      break;

    case OPT_foperator_names:

      cpp_opts->operator_names = value;

      break;

    case OPT_fpch_deps:

      cpp_opts->restore_pch_deps = value;

      break;

    case OPT_fpch_preprocess:

      flag_pch_preprocess = value;

      break;

    case OPT_fpermissive:

      flag_permissive = value;

      global_dc->permissive = value;

      break;

    case OPT_fpreprocessed:

      cpp_opts->preprocessed = value;

      break;

    case OPT_fdebug_cpp:

      cpp_opts->debug = 1;

      break;

    case OPT_ftrack_macro_expansion:

      if (value)

        value = 2;

      /* Fall Through.  */

    case OPT_ftrack_macro_expansion_:

      if (arg && *arg != '\0')

        cpp_opts->track_macro_expansion = value;

      else

        cpp_opts->track_macro_expansion = 2;

      break;

    case OPT_frepo:

      flag_use_repository = value;

      if (value)

        flag_implicit_templates = 0;

      break;

    case OPT_ftabstop_:

      /* It is documented that we silently ignore silly values.  */

      if (value >= 1 && value <= 100)

        cpp_opts->tabstop = value;

      break;

    case OPT_fexec_charset_:

      cpp_opts->narrow_charset = arg;

      break;

    case OPT_fwide_exec_charset_:

      cpp_opts->wide_charset = arg;

      break;

    case OPT_finput_charset_:

      cpp_opts->input_charset = arg;

      break;

    case OPT_ftemplate_depth_:

      max_tinst_depth = value;

      break;

    case OPT_fvisibility_inlines_hidden:

      visibility_options.inlines_hidden = value;

      break;

    case OPT_femit_struct_debug_baseonly:

      set_struct_debug_option (&global_options, loc, "base");

      break;

    case OPT_femit_struct_debug_reduced:

      set_struct_debug_option (&global_options, loc,

                               "dir:ord:sys,dir:gen:any,ind:base");

      break;

    case OPT_femit_struct_debug_detailed_:

      set_struct_debug_option (&global_options, loc, arg);

      break;

    case OPT_idirafter:

      add_path (xstrdup (arg), AFTER, 0, true);

      break;

    case OPT_imacros:

    case OPT_include:

      defer_opt (code, arg);

      break;

    case OPT_imultilib:

      imultilib = arg;

      break;

    case OPT_iprefix:

      iprefix = arg;

      break;

    case OPT_iquote:

      add_path (xstrdup (arg), QUOTE, 0, true);

      break;

    case OPT_isysroot:

      sysroot = arg;

      break;

    case OPT_isystem:

      add_path (xstrdup (arg), SYSTEM, 0, true);

      break;

    case OPT_iwithprefix:

      add_prefixed_path (arg, SYSTEM);

      break;

    case OPT_iwithprefixbefore: