/* C/ObjC/C++ command line option handling.
- Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007
+ Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
Free Software Foundation, Inc.
Contributed by Neil Booth.
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 2, or (at your option) any later
+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
for more details.
You should have received a copy of the GNU General Public License
-along with GCC; see the file COPYING. If not, write to the Free
-Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
-02110-1301, USA. */
+along with GCC; see the file COPYING3. If not see
+<http://www.gnu.org/licenses/>. */
#include "config.h"
#include "system.h"
#include "diagnostic.h"
#include "intl.h"
#include "cppdefault.h"
-#include "c-incpath.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
/* CPP's options. */
-static cpp_options *cpp_opts;
+cpp_options *cpp_opts;
/* Input filename. */
static const char *this_input_filename;
/* If -v seen. */
static bool verbose;
-/* If -lang-fortran seen. */
-static bool lang_fortran = false;
-
/* Dependency output file. */
static const char *deps_file;
{
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? */
}
parse_in = cpp_create_reader (c_dialect_cxx () ? CLK_GNUCXX: CLK_GNUC89,
- ident_hash, &line_table);
+ 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;
warn_pointer_arith = c_dialect_cxx ();
warn_write_strings = c_dialect_cxx();
+ /* 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];
result |= CL_C | CL_ObjC | CL_CXX | CL_ObjCXX;
break;
}
-
-#ifdef CL_Fortran
- for (i = 1; i < argc; i++)
- if (! strcmp (argv[i], "-lang-fortran"))
- {
- result |= CL_Fortran;
- break;
- }
-#endif
}
return result;
{
default:
if (cl_options[code].flags & (CL_C | CL_CXX | CL_ObjC | CL_ObjCXX))
- break;
-#ifdef CL_Fortran
- if (lang_fortran && (cl_options[code].flags & (CL_Fortran)))
- break;
-#endif
+ {
+ if ((option->flags & CL_TARGET)
+ && ! targetcm.handle_c_option (scode, arg, value))
+ result = 0;
+ break;
+ }
result = 0;
break;
error ("-I- specified twice");
quote_chain_split = true;
split_quote_chain ();
- inform ("obsolete option -I- used, please use -iquote instead");
+ inform (input_location, "obsolete option -I- used, please use -iquote instead");
}
break;
or environment var dependency generation is used. */
cpp_opts->deps.style = (code == OPT_M ? DEPS_SYSTEM: DEPS_USER);
flag_no_output = 1;
- cpp_opts->inhibit_warnings = 1;
break;
case OPT_MD:
break;
case OPT_Wall:
- set_Wunused (value);
+ warn_unused = value;
set_Wformat (value);
set_Wimplicit (value);
warn_char_subscripts = value;
warn_parentheses = value;
warn_return_type = value;
warn_sequence_point = value; /* Was C only. */
- if (c_dialect_cxx ())
- warn_sign_compare = value;
warn_switch = value;
- warn_strict_aliasing = value;
- warn_strict_overflow = value;
- warn_string_literal_comparison = value;
- warn_always_true = 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;
+ if (warn_jump_misses_init == -1)
+ warn_jump_misses_init = value;
/* Only warn about unknown pragmas that are not in system
headers. */
warn_unknown_pragmas = value;
- /* We save the value of warn_uninitialized, since if they put
- -Wuninitialized on the command line, we need to generate a
- warning about not using it without also specifying -O. */
- if (warn_uninitialized != 1)
- warn_uninitialized = (value ? 2 : 0);
+ 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. */
- warn_main = value * 2;
+ {
+ /* 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_nontemplate_friend = value;
warn_cxx0x_compat = value;
- if (value > 0)
- warn_write_strings = true;
}
cpp_opts->warn_trigraphs = value;
cpp_opts->warn_comments = value;
cpp_opts->warn_num_sign_change = value;
- cpp_opts->warn_multichar = value; /* Was C++ only. */
if (warn_pointer_sign == -1)
- 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 -Wgoto-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;
break;
case OPT_Werror:
- cpp_opts->warnings_are_errors = value;
global_dc->warning_as_error_requested = value;
break;
cpp_opts->warn_invalid_pch = value;
break;
- case OPT_Wmain:
- if (value)
- warn_main = 1;
- else
- warn_main = -1;
- break;
-
case OPT_Wmissing_include_dirs:
cpp_opts->warn_missing_include_dirs = value;
break;
warn_strict_null_sentinel = value;
break;
- case OPT_Wsystem_headers:
- cpp_opts->warn_system_headers = value;
- break;
-
case OPT_Wtraditional:
cpp_opts->warn_traditional = value;
break;
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_fhosted:
flag_hosted = value;
flag_no_builtin = !value;
- /* warn_main will be 2 if set by -Wall, 1 if set by -Wmain */
- if (!value && warn_main == 2)
- warn_main = 0;
break;
case OPT_fshort_double:
flag_threadsafe_statics = value;
break;
+ case OPT_fpretty_templates:
+ flag_pretty_templates = value;
+ break;
+
case OPT_fzero_link:
flag_zero_link = value;
break;
flag_gen_declaration = 1;
break;
+ case OPT_femit_struct_debug_baseonly:
+ set_struct_debug_option ("base");
+ break;
+
+ case OPT_femit_struct_debug_reduced:
+ set_struct_debug_option ("dir:ord:sys,dir:gen:any,ind:base");
+ break;
+
+ case OPT_femit_struct_debug_detailed_:
+ set_struct_debug_option (arg);
+ break;
+
case OPT_idirafter:
add_path (xstrdup (arg), AFTER, 0, true);
break;
cpp_opts->dollars_in_ident = false;
break;
- case OPT_lang_fortran:
- lang_fortran = true;
- break;
-
case OPT_lang_objc:
cpp_opts->objc = 1;
break;
c_common_post_options, so that a subsequent -Wno-endif-labels
is not overridden. */
case OPT_pedantic_errors:
- cpp_opts->pedantic_errors = 1;
- /* Fall through. */
case OPT_pedantic:
cpp_opts->pedantic = 1;
cpp_opts->warn_endif_labels = 1;
warn_pointer_sign = 1;
if (warn_overlength_strings == -1)
warn_overlength_strings = 1;
+ if (warn_main == -1)
+ warn_main = 2;
break;
case OPT_print_objc_runtime_info:
flag_undef = 1;
break;
- case OPT_w:
- cpp_opts->inhibit_warnings = 1;
- break;
-
case OPT_v:
verbose = true;
break;
+
+ case OPT_Wabi:
+ warn_psabi = value;
+ break;
}
return result;
C_COMMON_OVERRIDE_OPTIONS;
#endif
- flag_inline_trees = 1;
-
- /* Use tree inlining. */
- if (!flag_no_inline)
- flag_no_inline = 1;
- if (flag_inline_functions)
- flag_inline_trees = 2;
-
- /* If we are given more than one input file, we must use
- unit-at-a-time mode. */
- if (num_in_fnames > 1)
- flag_unit_at_a_time = 1;
+ /* Excess precision other than "fast" requires front-end
+ support. */
+ if (c_dialect_cxx ())
+ {
+ if (flag_excess_precision_cmdline == EXCESS_PRECISION_STANDARD
+ && TARGET_FLT_EVAL_METHOD_NON_DEFAULT)
+ sorry ("-fexcess-precision=standard for C++");
+ flag_excess_precision_cmdline = EXCESS_PRECISION_FAST;
+ }
+ else if (flag_excess_precision_cmdline == EXCESS_PRECISION_DEFAULT)
+ flag_excess_precision_cmdline = (flag_iso
+ ? EXCESS_PRECISION_STANDARD
+ : EXCESS_PRECISION_FAST);
+
+ /* By default we use C99 inline semantics in GNU99 or C99 mode. C99
+ inline semantics are not supported in GNU89 or C89 mode. */
+ if (flag_gnu89_inline == -1)
+ flag_gnu89_inline = !flag_isoc99;
+ else if (!flag_gnu89_inline && !flag_isoc99)
+ error ("-fno-gnu89-inline is only supported in GNU99 or C99 mode");
/* Default to ObjC sjlj exception handling if NeXT runtime. */
if (flag_objc_sjlj_exceptions < 0)
if (flag_objc_exceptions && !flag_objc_sjlj_exceptions)
flag_exceptions = 1;
- /* -Wextra implies -Wclobbered, -Wempty-body, -Wsign-compare,
- -Wmissing-field-initializers, -Wmissing-parameter-type
- -Wold-style-declaration, and -Woverride-init,
- but not if explicitly overridden. */
+ /* -Wextra implies the following flags
+ unless explicitly overridden. */
+ if (warn_type_limits == -1)
+ warn_type_limits = extra_warnings;
if (warn_clobbered == -1)
warn_clobbered = extra_warnings;
if (warn_empty_body == -1)
warn_old_style_declaration = extra_warnings;
if (warn_override_init == -1)
warn_override_init = extra_warnings;
+ if (warn_ignored_qualifiers == -1)
+ warn_ignored_qualifiers = extra_warnings;
- /* -Wpointer_sign is disabled by default, but it is enabled if any
+ /* -Wpointer-sign is disabled by default, but it is enabled if any
of -Wall or -pedantic are given. */
if (warn_pointer_sign == -1)
warn_pointer_sign = 0;
+ if (warn_strict_aliasing == -1)
+ warn_strict_aliasing = 0;
+ if (warn_strict_overflow == -1)
+ warn_strict_overflow = 0;
+ if (warn_jump_misses_init == -1)
+ warn_jump_misses_init = 0;
+
/* -Woverlength-strings is off by default, but is enabled by -pedantic.
It is never enabled in C++, as the minimum limit is not normative
in that standard. */
if (warn_overlength_strings == -1 || c_dialect_cxx ())
warn_overlength_strings = 0;
+ /* Wmain is enabled by default in C++ but not in C. */
+ /* Wmain is disabled by default for -ffreestanding (!flag_hosted),
+ even if -Wall was given (warn_main will be 2 if set by -Wall, 1
+ if set by -Wmain). */
+ if (warn_main == -1)
+ warn_main = (c_dialect_cxx () && flag_hosted) ? 1 : 0;
+ else if (warn_main == 2)
+ warn_main = flag_hosted ? 1 : 0;
+
+ /* In C, -Wconversion enables -Wsign-conversion (unless disabled
+ through -Wno-sign-conversion). While in C++,
+ -Wsign-conversion needs to be requested explicitly. */
+ if (warn_sign_conversion == -1)
+ warn_sign_conversion = (c_dialect_cxx ()) ? 0 : warn_conversion;
+
+ /* In C, -Wall and -Wc++-compat enable -Wenum-compare, which we do
+ in c_common_handle_option; if it has not yet been set, it is
+ disabled by default. In C++, it is enabled by default. */
+ if (warn_enum_compare == -1)
+ warn_enum_compare = c_dialect_cxx () ? 1 : 0;
+
+ /* -Wpacked-bitfield-compat is on by default for the C languages. The
+ warning is issued in stor-layout.c which is not part of the front-end so
+ we need to selectively turn it on here. */
+ if (warn_packed_bitfield_compat == -1)
+ warn_packed_bitfield_compat = 1;
+
/* Special format checking options don't work without -Wformat; warn if
they are used. */
if (!warn_format)
"-Wformat-zero-length ignored without -Wformat");
warning (OPT_Wformat_nonliteral,
"-Wformat-nonliteral ignored without -Wformat");
+ warning (OPT_Wformat_contains_nul,
+ "-Wformat-contains-nul ignored without -Wformat");
warning (OPT_Wformat_security,
"-Wformat-security ignored without -Wformat");
}
if (warn_implicit_function_declaration == -1)
warn_implicit_function_declaration = flag_isoc99;
- /* C99 requires special handling of complex multiplication and division;
- -ffast-math and -fcx-limited-range are handled in process_options. */
- if (flag_isoc99)
- flag_complex_method = 2;
-
/* If we're allowing C++0x constructs, don't warn about C++0x
compatibility problems. */
- if (flag_cpp0x)
+ if (cxx_dialect == cxx0x)
warn_cxx0x_compat = 0;
if (flag_preprocess_only)
input_location = UNKNOWN_LOCATION;
- /* If an error has occurred in cpplib, note it so we fail
- immediately. */
- errorcount += cpp_errors (parse_in);
-
*pfilename = this_input_filename
= cpp_read_main_file (parse_in, in_fnames[0]);
/* Don't do any compilation or preprocessing if there is no input file. */
if (version_flag)
c_common_print_pch_checksum (stderr);
+ /* Has to wait until now so that cpplib has its hash table. */
+ init_pragma ();
+
if (flag_preprocess_only)
{
finish_options ();
return false;
}
- /* Has to wait until now so that cpplib has its hash table. */
- init_pragma ();
-
return true;
}
if (++i >= num_in_fnames)
break;
cpp_undef_all (parse_in);
+ cpp_clear_file_cache (parse_in);
this_input_filename
= cpp_read_main_file (parse_in, in_fnames[i]);
/* If an input file is missing, abandon further compilation.
{
FILE *deps_stream = NULL;
- if (cpp_opts->deps.style != DEPS_NONE)
+ /* Don't write the deps file if there are errors. */
+ if (cpp_opts->deps.style != DEPS_NONE && errorcount == 0)
{
/* If -M or -MM was seen without -MF, default output to the
output stream. */
/* For performance, avoid tearing down cpplib's internal structures
with cpp_destroy (). */
- errorcount += cpp_finish (parse_in, deps_stream);
+ cpp_finish (parse_in, deps_stream);
if (deps_stream && deps_stream != out_stream
&& (ferror (deps_stream) || fclose (deps_stream)))
if (flag_dump_macros == 'M')
flag_no_output = 1;
+ /* By default, -fdirectives-only implies -dD. This allows subsequent phases
+ to perform proper macro expansion. */
+ if (cpp_opts->directives_only && !cpp_opts->preprocessed && !flag_dump_macros)
+ flag_dump_macros = 'D';
+
/* Disable -dD, -dN and -dI if normal output is suppressed. Allow
-dM since at least glibc relies on -M -dM to work. */
/* Also, flag_no_output implies flag_no_line_commands, always. */
flag_dump_includes = 0;
flag_no_line_commands = 1;
}
+ else if (cpp_opts->deps.missing_files)
+ error ("-MG may only be used with -M or -MM");
cpp_opts->unsigned_char = !flag_signed_char;
cpp_opts->stdc_0_in_system_headers = STDC_0_IN_SYSTEM_HEADERS;
- /* We want -Wno-long-long to override -pedantic -std=non-c99
- and/or -Wtraditional, whatever the ordering. */
- cpp_opts->warn_long_long
- = warn_long_long && ((!flag_isoc99 && pedantic) || warn_traditional);
+ /* Wlong-long is disabled by default. It is enabled by:
+ [-pedantic | -Wtraditional] -std=[gnu|c]++98 ; or
+ [-pedantic | -Wtraditional] -std=non-c99 .
+
+ Either -Wlong-long or -Wno-long-long override any other settings. */
+ if (warn_long_long == -1)
+ warn_long_long = ((pedantic || warn_traditional)
+ && (c_dialect_cxx () ? cxx_dialect == cxx98 : !flag_isoc99));
+ cpp_opts->warn_long_long = warn_long_long;
/* Similarly with -Wno-variadic-macros. No check for c99 here, since
this also turns off warnings about GCCs extension. */
actually output the current directory? */
if (flag_working_directory == -1)
flag_working_directory = (debug_info_level != DINFO_LEVEL_NONE);
+
+ if (cpp_opts->directives_only)
+ {
+ if (warn_unused_macros)
+ error ("-fdirectives-only is incompatible with -Wunused_macros");
+ if (cpp_opts->traditional)
+ error ("-fdirectives-only is incompatible with -traditional");
+ }
}
/* Add include path with a prefix at the front of its name. */
size_t i;
cb_file_change (parse_in,
- linemap_add (&line_table, LC_RENAME, 0,
+ linemap_add (line_table, LC_RENAME, 0,
_("<built-in>"), 0));
cpp_init_builtins (parse_in, flag_hosted);
cpp_opts->warn_dollars = (cpp_opts->pedantic && !cpp_opts->c99);
cb_file_change (parse_in,
- linemap_add (&line_table, LC_RENAME, 0,
+ linemap_add (line_table, LC_RENAME, 0,
_("<command-line>"), 0));
for (i = 0; i < deferred_count; i++)
}
}
}
+ else if (cpp_opts->directives_only)
+ cpp_init_special_builtins (parse_in);
include_cursor = 0;
push_command_line_include ();
/* Set this here so the client can change the option if it wishes,
and after stacking the main file so we don't trace the main file. */
- line_table.trace_includes = cpp_opts->print_include_names;
+ line_table->trace_includes = cpp_opts->print_include_names;
}
}
flag_no_gnu_keywords = iso;
flag_no_nonansi_builtin = iso;
flag_iso = iso;
+ cxx_dialect = cxx98;
}
/* Set the C++ 0x working draft "standard" (without GNU extensions if ISO). */
flag_no_gnu_keywords = iso;
flag_no_nonansi_builtin = iso;
flag_iso = iso;
- flag_cpp0x = 1;
+ cxx_dialect = cxx0x;
}
/* Handle setting implicit to ON. */
case 'M': /* Dump macros only. */
case 'N': /* Dump names. */
case 'D': /* Dump definitions. */
+ case 'U': /* Dump used macros. */
flag_dump_macros = c;
break;