Subversion Repositories openrisc

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

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

   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 "tm.h"

#include "tree.h"

#include "c-common.h"

#include "c-pragma.h"

#include "flags.h"

#include "toplev.h"

#include "langhooks.h"

#include "tree-inline.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 "target.h"

#include "tm_p.h"

#include "c-tree.h"             /* For c_cpp_error.  */

#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 set_Wimplicit (int);

static void handle_OPT_d (const char *);

static void set_std_cxx98 (int);

static void set_std_cxx0x (int);

static void set_std_c89 (int, int);

static void set_std_c99 (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 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;

/* Complain that switch CODE expects an argument but none was

   provided.  OPT was the command-line option.  Return FALSE to get

   the default message in opts.c, TRUE if we provide a specialized

   one.  */

bool

c_common_missing_argument (const char *opt, size_t code)

{

  switch (code)

    {

    default:

      /* Pick up the default message.  */

      return false;

    case OPT_fconstant_string_class_:

      error ("no class name specified with %qs", opt);

      break;

    case OPT_A:

      error ("assertion missing after %qs", opt);

      break;

    case OPT_D:

    case OPT_U:

      error ("macro name missing after %qs", opt);

      break;

    case OPT_F:

    case OPT_I:

    case OPT_idirafter:

    case OPT_isysroot:

    case OPT_isystem:

    case OPT_iquote:

      error ("missing path after %qs", opt);

      break;

    case OPT_MF:

    case OPT_MD:

    case OPT_MMD:

    case OPT_include:

    case OPT_imacros:

    case OPT_o:

      error ("missing filename after %qs", opt);

      break;

    case OPT_MQ:

    case OPT_MT:

      error ("missing makefile target after %qs", opt);

      break;

    }

  return true;

}

/* 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++;

}

/* Common initialization before parsing options.  */

unsigned int

c_common_init_options (unsigned int argc, const char **argv)

{

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

  unsigned int i, result;

  struct cpp_callbacks *cb;

  /* 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 (global_dc) = 80;

      /* By default, emit location information once for every

         diagnostic message.  */

      diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;

    }

  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;

  flag_exceptions = c_dialect_cxx ();

  warn_pointer_arith = c_dialect_cxx ();

  warn_write_strings = c_dialect_cxx();

  flag_warn_unused_result = true;

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

  flag_complex_method = 2;

  deferred_opts = XNEWVEC (struct deferred_opt, argc);

  result = lang_flags[c_language];

  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 < argc; i++)

        if (! strcmp (argv[i], "-lang-asm"))

          {

            result |= CL_C | CL_ObjC | CL_CXX | CL_ObjCXX;

            break;

          }

    }

  return result;

}

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

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

   invalid, a negative number to prevent language-independent

   processing in toplev.c (a hack necessary for the short-term).  */

int

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

{

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

  enum opt_code code = (enum opt_code) scode;

  int result = 1;

  /* 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 & (CL_C | CL_CXX | CL_ObjC | CL_ObjCXX))

        {

          if ((option->flags & CL_TARGET)

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

            result = 0;

          break;

        }

      result = 0;

      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_E:

      flag_preprocess_only = 1;

      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_fworking_directory:

      flag_working_directory = value;

      break;

    case OPT_U:

      defer_opt (code, arg);

      break;

    case OPT_Wall:

      warn_unused = value;

      set_Wformat (value);

      set_Wimplicit (value);

      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 (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;

      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;

        }

      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:

    case OPT_Wcomments:

      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_Wdeprecated:

      cpp_opts->warn_deprecated = value;

      break;

    case OPT_Wendif_labels:

      cpp_opts->warn_endif_labels = value;

      break;

    case OPT_Werror:

      global_dc->warning_as_error_requested = value;

      break;

    case OPT_Werror_implicit_function_declaration:

      /* For backward compatibility, this is the same as

         -Werror=implicit-function-declaration.  */

      enable_warning_as_error ("implicit-function-declaration", value, CL_C | CL_ObjC);

      break;

    case OPT_Wformat:

      set_Wformat (value);

      break;

    case OPT_Wformat_:

      set_Wformat (atoi (arg));

      break;

    case OPT_Wimplicit:

      set_Wimplicit (value);

      break;

    case OPT_Wimport:

      /* Silently ignore for now.  */

      break;

    case OPT_Winvalid_pch:

      cpp_opts->warn_invalid_pch = 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 (!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_Wstrict_null_sentinel:

      warn_strict_null_sentinel = value;

      break;

    case OPT_Wtraditional:

      cpp_opts->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;

        }

      /* Fall through.  */

    case OPT_fall_virtual:

    case OPT_falt_external_templates:

    case OPT_fenum_int_equiv:

    case OPT_fexternal_templates:

    case OPT_fguiding_decls:

    case OPT_fhonor_std:

    case OPT_fhuge_objects:

    case OPT_flabels_ok:

    case OPT_fname_mangling_version_:

    case OPT_fnew_abi:

    case OPT_fnonnull_objects:

    case OPT_fsquangle:

    case OPT_fstrict_prototype:

    case OPT_fthis_is_variable:

    case OPT_fvtable_thunks:

    case OPT_fxref:

    case OPT_fvtable_gc:

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

      break;

    case OPT_faccess_control:

      flag_access_control = value;

      break;

    case OPT_fasm:

      flag_no_asm = !value;

      break;

    case OPT_fbuiltin:

      flag_no_builtin = !value;

      break;

    case OPT_fbuiltin_:

      if (value)

        result = 0;

      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_fshort_double:

      flag_short_double = value;

      break;

    case OPT_fshort_enums:

      flag_short_enums = value;

      break;

    case OPT_fshort_wchar:

      flag_short_wchar = value;

      break;

    case OPT_fsigned_bitfields:

      flag_signed_bitfields = value;

      break;

    case OPT_fsigned_char:

      flag_signed_char = value;

      break;

    case OPT_funsigned_bitfields:

      flag_signed_bitfields = !value;

      break;

    case OPT_funsigned_char:

      flag_signed_char = !value;

      break;

    case OPT_fcheck_new:

      flag_check_new = value;

      break;

    case OPT_fconserve_space:

      flag_conserve_space = value;

      break;

    case OPT_fconstant_string_class_:

      constant_string_class_name = arg;

      break;

    case OPT_fdefault_inline:

      flag_default_inline = value;

      break;

    case OPT_felide_constructors:

      flag_elide_constructors = value;

      break;

    case OPT_fenforce_eh_specs:

      flag_enforce_eh_specs = value;

      break;

    case OPT_fextended_identifiers:

      cpp_opts->extended_identifiers = value;

      break;

    case OPT_ffor_scope:

      flag_new_for_scope = value;

      break;

    case OPT_fgnu_keywords:

      flag_no_gnu_keywords = !value;

      break;

    case OPT_fgnu_runtime:

      flag_next_runtime = !value;

      break;

    case OPT_fhandle_exceptions:

      warning (0, "-fhandle-exceptions has been renamed -fexceptions (and is now on by default)");

      flag_exceptions = value;

      break;

    case OPT_fimplement_inlines:

      flag_implement_inlines = value;

      break;

    case OPT_fimplicit_inline_templates:

      flag_implicit_inline_templates = value;

      break;

    case OPT_fimplicit_templates:

      flag_implicit_templates = value;

      break;

    case OPT_flax_vector_conversions:

      flag_lax_vector_conversions = value;

      break;

    case OPT_fms_extensions:

      flag_ms_extensions = value;

      break;

    case OPT_fnext_runtime:

      flag_next_runtime = value;