838 lines
34 KiB
Plaintext
838 lines
34 KiB
Plaintext
This is Info file gcc.info, produced by Makeinfo version 1.68 from the
|
||
input file ../../gcc-2.95.2/gcc/gcc.texi.
|
||
|
||
INFO-DIR-SECTION Programming
|
||
START-INFO-DIR-ENTRY
|
||
* gcc: (gcc). The GNU Compiler Collection.
|
||
END-INFO-DIR-ENTRY
|
||
This file documents the use and the internals of the GNU compiler.
|
||
|
||
Published by the Free Software Foundation 59 Temple Place - Suite 330
|
||
Boston, MA 02111-1307 USA
|
||
|
||
Copyright (C) 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
|
||
1999 Free Software Foundation, Inc.
|
||
|
||
Permission is granted to make and distribute verbatim copies of this
|
||
manual provided the copyright notice and this permission notice are
|
||
preserved on all copies.
|
||
|
||
Permission is granted to copy and distribute modified versions of
|
||
this manual under the conditions for verbatim copying, provided also
|
||
that the sections entitled "GNU General Public License" and "Funding
|
||
for Free Software" are included exactly as in the original, and
|
||
provided that the entire resulting derived work is distributed under
|
||
the terms of a permission notice identical to this one.
|
||
|
||
Permission is granted to copy and distribute translations of this
|
||
manual into another language, under the above conditions for modified
|
||
versions, except that the sections entitled "GNU General Public
|
||
License" and "Funding for Free Software", and this permission notice,
|
||
may be included in translations approved by the Free Software Foundation
|
||
instead of in the original English.
|
||
|
||
|
||
File: gcc.info, Node: C++ Dialect Options, Next: Warning Options, Prev: C Dialect Options, Up: Invoking GCC
|
||
|
||
Options Controlling C++ Dialect
|
||
===============================
|
||
|
||
This section describes the command-line options that are only
|
||
meaningful for C++ programs; but you can also use most of the GNU
|
||
compiler options regardless of what language your program is in. For
|
||
example, you might compile a file `firstClass.C' like this:
|
||
|
||
g++ -g -frepo -O -c firstClass.C
|
||
|
||
In this example, only `-frepo' is an option meant only for C++
|
||
programs; you can use the other options with any language supported by
|
||
GCC.
|
||
|
||
Here is a list of options that are *only* for compiling C++ programs:
|
||
|
||
`-fno-access-control'
|
||
Turn off all access checking. This switch is mainly useful for
|
||
working around bugs in the access control code.
|
||
|
||
`-fcheck-new'
|
||
Check that the pointer returned by `operator new' is non-null
|
||
before attempting to modify the storage allocated. The current
|
||
Working Paper requires that `operator new' never return a null
|
||
pointer, so this check is normally unnecessary.
|
||
|
||
An alternative to using this option is to specify that your
|
||
`operator new' does not throw any exceptions; if you declare it
|
||
`throw()', g++ will check the return value. See also `new
|
||
(nothrow)'.
|
||
|
||
`-fconserve-space'
|
||
Put uninitialized or runtime-initialized global variables into the
|
||
common segment, as C does. This saves space in the executable at
|
||
the cost of not diagnosing duplicate definitions. If you compile
|
||
with this flag and your program mysteriously crashes after
|
||
`main()' has completed, you may have an object that is being
|
||
destroyed twice because two definitions were merged.
|
||
|
||
This option is no longer useful on most targets, now that support
|
||
has been added for putting variables into BSS without making them
|
||
common.
|
||
|
||
`-fdollars-in-identifiers'
|
||
Accept `$' in identifiers. You can also explicitly prohibit use of
|
||
`$' with the option `-fno-dollars-in-identifiers'. (GNU C allows
|
||
`$' by default on most target systems, but there are a few
|
||
exceptions.) Traditional C allowed the character `$' to form part
|
||
of identifiers. However, ANSI C and C++ forbid `$' in identifiers.
|
||
|
||
`-fno-elide-constructors'
|
||
The C++ standard allows an implementation to omit creating a
|
||
temporary which is only used to initialize another object of the
|
||
same type. Specifying this option disables that optimization, and
|
||
forces g++ to call the copy constructor in all cases.
|
||
|
||
`-fexternal-templates'
|
||
Cause template instantiations to obey `#pragma interface' and
|
||
`implementation'; template instances are emitted or not according
|
||
to the location of the template definition. *Note Template
|
||
Instantiation::, for more information.
|
||
|
||
This option is deprecated.
|
||
|
||
`-falt-external-templates'
|
||
Similar to -fexternal-templates, but template instances are
|
||
emitted or not according to the place where they are first
|
||
instantiated. *Note Template Instantiation::, for more
|
||
information.
|
||
|
||
This option is deprecated.
|
||
|
||
`-ffor-scope'
|
||
`-fno-for-scope'
|
||
If -ffor-scope is specified, the scope of variables declared in a
|
||
for-init-statement is limited to the `for' loop itself, as
|
||
specified by the draft C++ standard. If -fno-for-scope is
|
||
specified, the scope of variables declared in a for-init-statement
|
||
extends to the end of the enclosing scope, as was the case in old
|
||
versions of gcc, and other (traditional) implementations of C++.
|
||
|
||
The default if neither flag is given to follow the standard, but
|
||
to allow and give a warning for old-style code that would
|
||
otherwise be invalid, or have different behavior.
|
||
|
||
`-fno-gnu-keywords'
|
||
Do not recognize `classof', `headof', `signature', `sigof' or
|
||
`typeof' as a keyword, so that code can use these words as
|
||
identifiers. You can use the keywords `__classof__',
|
||
`__headof__', `__signature__', `__sigof__', and `__typeof__'
|
||
instead. `-ansi' implies `-fno-gnu-keywords'.
|
||
|
||
`-fguiding-decls'
|
||
Treat a function declaration with the same type as a potential
|
||
function template instantiation as though it declares that
|
||
instantiation, not a normal function. If a definition is given
|
||
for the function later in the translation unit (or another
|
||
translation unit if the target supports weak symbols), that
|
||
definition will be used; otherwise the template will be
|
||
instantiated. This behavior reflects the C++ language prior to
|
||
September 1996, when guiding declarations were removed.
|
||
|
||
This option implies `-fname-mangling-version-0', and will not work
|
||
with other name mangling versions. Like all options that change
|
||
the ABI, all C++ code, *including libgcc.a* must be built with the
|
||
same setting of this option.
|
||
|
||
`-fhandle-signatures'
|
||
Recognize the `signature' and `sigof' keywords for specifying
|
||
abstract types. The default (`-fno-handle-signatures') is not to
|
||
recognize them. *Note Type Abstraction using Signatures: C++
|
||
Signatures.
|
||
|
||
`-fhonor-std'
|
||
Treat the `namespace std' as a namespace, instead of ignoring it.
|
||
For compatibility with earlier versions of g++, the compiler will,
|
||
by default, ignore `namespace-declarations', `using-declarations',
|
||
`using-directives', and `namespace-names', if they involve `std'.
|
||
|
||
`-fhuge-objects'
|
||
Support virtual function calls for objects that exceed the size
|
||
representable by a `short int'. Users should not use this flag by
|
||
default; if you need to use it, the compiler will tell you so.
|
||
|
||
This flag is not useful when compiling with -fvtable-thunks.
|
||
|
||
Like all options that change the ABI, all C++ code, *including
|
||
libgcc* must be built with the same setting of this option.
|
||
|
||
`-fno-implicit-templates'
|
||
Never emit code for non-inline templates which are instantiated
|
||
implicitly (i.e. by use); only emit code for explicit
|
||
instantiations. *Note Template Instantiation::, for more
|
||
information.
|
||
|
||
`-fno-implicit-inline-templates'
|
||
Don't emit code for implicit instantiations of inline templates,
|
||
either. The default is to handle inlines differently so that
|
||
compiles with and without optimization will need the same set of
|
||
explicit instantiations.
|
||
|
||
`-finit-priority'
|
||
Support `__attribute__ ((init_priority (n)))' for controlling the
|
||
order of initialization of file-scope objects. On ELF targets,
|
||
this requires GNU ld 2.10 or later.
|
||
|
||
`-fno-implement-inlines'
|
||
To save space, do not emit out-of-line copies of inline functions
|
||
controlled by `#pragma implementation'. This will cause linker
|
||
errors if these functions are not inlined everywhere they are
|
||
called.
|
||
|
||
`-fname-mangling-version-N'
|
||
Control the way in which names are mangled. Version 0 is
|
||
compatible with versions of g++ before 2.8. Version 1 is the
|
||
default. Version 1 will allow correct mangling of function
|
||
templates. For example, version 0 mangling does not mangle
|
||
foo<int, double> and foo<int, char> given this declaration:
|
||
|
||
template <class T, class U> void foo(T t);
|
||
|
||
Like all options that change the ABI, all C++ code, *including
|
||
libgcc* must be built with the same setting of this option.
|
||
|
||
`-foperator-names'
|
||
Recognize the operator name keywords `and', `bitand', `bitor',
|
||
`compl', `not', `or' and `xor' as synonyms for the symbols they
|
||
refer to. `-ansi' implies `-foperator-names'.
|
||
|
||
`-fno-optional-diags'
|
||
Disable diagnostics that the standard says a compiler does not
|
||
need to issue. Currently, the only such diagnostic issued by g++
|
||
is the one for a name having multiple meanings within a class.
|
||
|
||
`-fpermissive'
|
||
Downgrade messages about nonconformant code from errors to
|
||
warnings. By default, g++ effectively sets `-pedantic-errors'
|
||
without `-pedantic'; this option reverses that. This behavior and
|
||
this option are superceded by `-pedantic', which works as it does
|
||
for GNU C.
|
||
|
||
`-frepo'
|
||
Enable automatic template instantiation. This option also implies
|
||
`-fno-implicit-templates'. *Note Template Instantiation::, for
|
||
more information.
|
||
|
||
`-fno-rtti'
|
||
Disable generation of the information used by C++ runtime type
|
||
identification features (`dynamic_cast' and `typeid'). If you
|
||
don't use those parts of the language (or exception handling,
|
||
which uses `dynamic_cast' internally), you can save some space by
|
||
using this flag.
|
||
|
||
`-fstrict-prototype'
|
||
Within an `extern "C"' linkage specification, treat a function
|
||
declaration with no arguments, such as `int foo ();', as declaring
|
||
the function to take no arguments. Normally, such a declaration
|
||
means that the function `foo' can take any combination of
|
||
arguments, as in C. `-pedantic' implies `-fstrict-prototype'
|
||
unless overridden with `-fno-strict-prototype'.
|
||
|
||
Specifying this option will also suppress implicit declarations of
|
||
functions.
|
||
|
||
This flag no longer affects declarations with C++ linkage.
|
||
|
||
`-fsquangle'
|
||
`-fno-squangle'
|
||
`-fsquangle' will enable a compressed form of name mangling for
|
||
identifiers. In particular, it helps to shorten very long names by
|
||
recognizing types and class names which occur more than once,
|
||
replacing them with special short ID codes. This option also
|
||
requires any C++ libraries being used to be compiled with this
|
||
option as well. The compiler has this disabled (the equivalent of
|
||
`-fno-squangle') by default.
|
||
|
||
Like all options that change the ABI, all C++ code, *including
|
||
libgcc.a* must be built with the same setting of this option.
|
||
|
||
`-ftemplate-depth-N'
|
||
Set the maximum instantiation depth for template classes to N. A
|
||
limit on the template instantiation depth is needed to detect
|
||
endless recursions during template class instantiation. ANSI/ISO
|
||
C++ conforming programs must not rely on a maximum depth greater
|
||
than 17.
|
||
|
||
`-fthis-is-variable'
|
||
Permit assignment to `this'. The incorporation of user-defined
|
||
free store management into C++ has made assignment to `this' an
|
||
anachronism. Therefore, by default it is invalid to assign to
|
||
`this' within a class member function; that is, GNU C++ treats
|
||
`this' in a member function of class `X' as a non-lvalue of type
|
||
`X *'. However, for backwards compatibility, you can make it
|
||
valid with `-fthis-is-variable'.
|
||
|
||
`-fvtable-thunks'
|
||
Use `thunks' to implement the virtual function dispatch table
|
||
(`vtable'). The traditional (cfront-style) approach to
|
||
implementing vtables was to store a pointer to the function and two
|
||
offsets for adjusting the `this' pointer at the call site. Newer
|
||
implementations store a single pointer to a `thunk' function which
|
||
does any necessary adjustment and then calls the target function.
|
||
|
||
This option also enables a heuristic for controlling emission of
|
||
vtables; if a class has any non-inline virtual functions, the
|
||
vtable will be emitted in the translation unit containing the
|
||
first one of those.
|
||
|
||
Like all options that change the ABI, all C++ code, *including
|
||
libgcc.a* must be built with the same setting of this option.
|
||
|
||
`-nostdinc++'
|
||
Do not search for header files in the standard directories
|
||
specific to C++, but do still search the other standard
|
||
directories. (This option is used when building the C++ library.)
|
||
|
||
In addition, these optimization, warning, and code generation options
|
||
have meanings only for C++ programs:
|
||
|
||
`-fno-default-inline'
|
||
Do not assume `inline' for functions defined inside a class scope.
|
||
*Note Options That Control Optimization: Optimize Options. Note
|
||
that these functions will have linkage like inline functions; they
|
||
just won't be inlined by default.
|
||
|
||
`-Wctor-dtor-privacy (C++ only)'
|
||
Warn when a class seems unusable, because all the constructors or
|
||
destructors in a class are private and the class has no friends or
|
||
public static member functions.
|
||
|
||
`-Wnon-virtual-dtor (C++ only)'
|
||
Warn when a class declares a non-virtual destructor that should
|
||
probably be virtual, because it looks like the class will be used
|
||
polymorphically.
|
||
|
||
`-Wreorder (C++ only)'
|
||
Warn when the order of member initializers given in the code does
|
||
not match the order in which they must be executed. For instance:
|
||
|
||
struct A {
|
||
int i;
|
||
int j;
|
||
A(): j (0), i (1) { }
|
||
};
|
||
|
||
Here the compiler will warn that the member initializers for `i'
|
||
and `j' will be rearranged to match the declaration order of the
|
||
members.
|
||
|
||
The following `-W...' options are not affected by `-Wall'.
|
||
|
||
`-Weffc++ (C++ only)'
|
||
Warn about violations of various style guidelines from Scott
|
||
Meyers' `Effective C++' books. If you use this option, you should
|
||
be aware that the standard library headers do not obey all of
|
||
these guidelines; you can use `grep -v' to filter out those
|
||
warnings.
|
||
|
||
`-Wno-deprecated (C++ only)'
|
||
Do not warn about usage of deprecated features. *Note Deprecated
|
||
Features::.
|
||
|
||
`-Wno-non-template-friend (C++ only)'
|
||
Disable warnings when non-templatized friend functions are declared
|
||
within a template. With the advent of explicit template
|
||
specification support in g++, if the name of the friend is an
|
||
unqualified-id (ie, `friend foo(int)'), the C++ language
|
||
specification demands that the friend declare or define an
|
||
ordinary, nontemplate function. (Section 14.5.3). Before g++
|
||
implemented explicit specification, unqualified-ids could be
|
||
interpreted as a particular specialization of a templatized
|
||
function. Because this non-conforming behavior is no longer the
|
||
default behavior for g++, `-Wnon-template-friend' allows the
|
||
compiler to check existing code for potential trouble spots, and
|
||
is on by default. This new compiler behavior can also be turned
|
||
off with the flag `-fguiding-decls', which activates the older,
|
||
non-specification compiler code, or with
|
||
`-Wno-non-template-friend' which keeps the conformant compiler
|
||
code but disables the helpful warning.
|
||
|
||
`-Wold-style-cast (C++ only)'
|
||
Warn if an old-style (C-style) cast is used within a C++ program.
|
||
The new-style casts (`static_cast', `reinterpret_cast', and
|
||
`const_cast') are less vulnerable to unintended effects.
|
||
|
||
`-Woverloaded-virtual (C++ only)'
|
||
Warn when a derived class function declaration may be an error in
|
||
defining a virtual function. In a derived class, the definitions
|
||
of virtual functions must match the type signature of a virtual
|
||
function declared in the base class. With this option, the
|
||
compiler warns when you define a function with the same name as a
|
||
virtual function, but with a type signature that does not match any
|
||
declarations from the base class.
|
||
|
||
`-Wno-pmf-conversions (C++ only)'
|
||
Disable the diagnostic for converting a bound pointer to member
|
||
function to a plain pointer.
|
||
|
||
`-Wsign-promo (C++ only)'
|
||
Warn when overload resolution chooses a promotion from unsigned or
|
||
enumeral type to a signed type over a conversion to an unsigned
|
||
type of the same size. Previous versions of g++ would try to
|
||
preserve unsignedness, but the standard mandates the current
|
||
behavior.
|
||
|
||
`-Wsynth (C++ only)'
|
||
Warn when g++'s synthesis behavior does not match that of cfront.
|
||
For instance:
|
||
|
||
struct A {
|
||
operator int ();
|
||
A& operator = (int);
|
||
};
|
||
|
||
main ()
|
||
{
|
||
A a,b;
|
||
a = b;
|
||
}
|
||
|
||
In this example, g++ will synthesize a default `A& operator =
|
||
(const A&);', while cfront will use the user-defined `operator ='.
|
||
|
||
|
||
File: gcc.info, Node: Warning Options, Next: Debugging Options, Prev: C++ Dialect Options, Up: Invoking GCC
|
||
|
||
Options to Request or Suppress Warnings
|
||
=======================================
|
||
|
||
Warnings are diagnostic messages that report constructions which are
|
||
not inherently erroneous but which are risky or suggest there may have
|
||
been an error.
|
||
|
||
You can request many specific warnings with options beginning `-W',
|
||
for example `-Wimplicit' to request warnings on implicit declarations.
|
||
Each of these specific warning options also has a negative form
|
||
beginning `-Wno-' to turn off warnings; for example, `-Wno-implicit'.
|
||
This manual lists only one of the two forms, whichever is not the
|
||
default.
|
||
|
||
These options control the amount and kinds of warnings produced by
|
||
GCC:
|
||
|
||
`-fsyntax-only'
|
||
Check the code for syntax errors, but don't do anything beyond
|
||
that.
|
||
|
||
`-pedantic'
|
||
Issue all the warnings demanded by strict ANSI C and ISO C++;
|
||
reject all programs that use forbidden extensions.
|
||
|
||
Valid ANSI C and ISO C++ programs should compile properly with or
|
||
without this option (though a rare few will require `-ansi').
|
||
However, without this option, certain GNU extensions and
|
||
traditional C and C++ features are supported as well. With this
|
||
option, they are rejected.
|
||
|
||
`-pedantic' does not cause warning messages for use of the
|
||
alternate keywords whose names begin and end with `__'. Pedantic
|
||
warnings are also disabled in the expression that follows
|
||
`__extension__'. However, only system header files should use
|
||
these escape routes; application programs should avoid them.
|
||
*Note Alternate Keywords::.
|
||
|
||
This option is not intended to be useful; it exists only to satisfy
|
||
pedants who would otherwise claim that GCC fails to support the
|
||
ANSI standard.
|
||
|
||
Some users try to use `-pedantic' to check programs for strict ANSI
|
||
C conformance. They soon find that it does not do quite what they
|
||
want: it finds some non-ANSI practices, but not all--only those
|
||
for which ANSI C *requires* a diagnostic.
|
||
|
||
A feature to report any failure to conform to ANSI C might be
|
||
useful in some instances, but would require considerable
|
||
additional work and would be quite different from `-pedantic'. We
|
||
don't have plans to support such a feature in the near future.
|
||
|
||
`-pedantic-errors'
|
||
Like `-pedantic', except that errors are produced rather than
|
||
warnings.
|
||
|
||
`-w'
|
||
Inhibit all warning messages.
|
||
|
||
`-Wno-import'
|
||
Inhibit warning messages about the use of `#import'.
|
||
|
||
`-Wchar-subscripts'
|
||
Warn if an array subscript has type `char'. This is a common cause
|
||
of error, as programmers often forget that this type is signed on
|
||
some machines.
|
||
|
||
`-Wcomment'
|
||
Warn whenever a comment-start sequence `/*' appears in a `/*'
|
||
comment, or whenever a Backslash-Newline appears in a `//' comment.
|
||
|
||
`-Wformat'
|
||
Check calls to `printf' and `scanf', etc., to make sure that the
|
||
arguments supplied have types appropriate to the format string
|
||
specified.
|
||
|
||
`-Wimplicit-int'
|
||
Warn when a declaration does not specify a type.
|
||
|
||
`-Wimplicit-function-declaration'
|
||
`-Werror-implicit-function-declaration'
|
||
Give a warning (or error) whenever a function is used before being
|
||
declared.
|
||
|
||
`-Wimplicit'
|
||
Same as `-Wimplicit-int' and `-Wimplicit-function-'
|
||
`declaration'.
|
||
|
||
`-Wmain'
|
||
Warn if the type of `main' is suspicious. `main' should be a
|
||
function with external linkage, returning int, taking either zero
|
||
arguments, two, or three arguments of appropriate types.
|
||
|
||
`-Wmultichar'
|
||
Warn if a multicharacter constant (`'FOOF'') is used. Usually they
|
||
indicate a typo in the user's code, as they have
|
||
implementation-defined values, and should not be used in portable
|
||
code.
|
||
|
||
`-Wparentheses'
|
||
Warn if parentheses are omitted in certain contexts, such as when
|
||
there is an assignment in a context where a truth value is
|
||
expected, or when operators are nested whose precedence people
|
||
often get confused about.
|
||
|
||
Also warn about constructions where there may be confusion to which
|
||
`if' statement an `else' branch belongs. Here is an example of
|
||
such a case:
|
||
|
||
{
|
||
if (a)
|
||
if (b)
|
||
foo ();
|
||
else
|
||
bar ();
|
||
}
|
||
|
||
In C, every `else' branch belongs to the innermost possible `if'
|
||
statement, which in this example is `if (b)'. This is often not
|
||
what the programmer expected, as illustrated in the above example
|
||
by indentation the programmer chose. When there is the potential
|
||
for this confusion, GNU C will issue a warning when this flag is
|
||
specified. To eliminate the warning, add explicit braces around
|
||
the innermost `if' statement so there is no way the `else' could
|
||
belong to the enclosing `if'. The resulting code would look like
|
||
this:
|
||
|
||
{
|
||
if (a)
|
||
{
|
||
if (b)
|
||
foo ();
|
||
else
|
||
bar ();
|
||
}
|
||
}
|
||
|
||
`-Wreturn-type'
|
||
Warn whenever a function is defined with a return-type that
|
||
defaults to `int'. Also warn about any `return' statement with no
|
||
return-value in a function whose return-type is not `void'.
|
||
|
||
`-Wswitch'
|
||
Warn whenever a `switch' statement has an index of enumeral type
|
||
and lacks a `case' for one or more of the named codes of that
|
||
enumeration. (The presence of a `default' label prevents this
|
||
warning.) `case' labels outside the enumeration range also
|
||
provoke warnings when this option is used.
|
||
|
||
`-Wtrigraphs'
|
||
Warn if any trigraphs are encountered (assuming they are enabled).
|
||
|
||
`-Wunused'
|
||
Warn whenever a variable is unused aside from its declaration,
|
||
whenever a function is declared static but never defined, whenever
|
||
a label is declared but not used, and whenever a statement
|
||
computes a result that is explicitly not used.
|
||
|
||
In order to get a warning about an unused function parameter, you
|
||
must specify both `-W' and `-Wunused'.
|
||
|
||
To suppress this warning for an expression, simply cast it to
|
||
void. For unused variables, parameters and labels, use the
|
||
`unused' attribute (*note Variable Attributes::.).
|
||
|
||
`-Wuninitialized'
|
||
An automatic variable is used without first being initialized.
|
||
|
||
These warnings are possible only in optimizing compilation,
|
||
because they require data flow information that is computed only
|
||
when optimizing. If you don't specify `-O', you simply won't get
|
||
these warnings.
|
||
|
||
These warnings occur only for variables that are candidates for
|
||
register allocation. Therefore, they do not occur for a variable
|
||
that is declared `volatile', or whose address is taken, or whose
|
||
size is other than 1, 2, 4 or 8 bytes. Also, they do not occur for
|
||
structures, unions or arrays, even when they are in registers.
|
||
|
||
Note that there may be no warning about a variable that is used
|
||
only to compute a value that itself is never used, because such
|
||
computations may be deleted by data flow analysis before the
|
||
warnings are printed.
|
||
|
||
These warnings are made optional because GCC is not smart enough
|
||
to see all the reasons why the code might be correct despite
|
||
appearing to have an error. Here is one example of how this can
|
||
happen:
|
||
|
||
{
|
||
int x;
|
||
switch (y)
|
||
{
|
||
case 1: x = 1;
|
||
break;
|
||
case 2: x = 4;
|
||
break;
|
||
case 3: x = 5;
|
||
}
|
||
foo (x);
|
||
}
|
||
|
||
If the value of `y' is always 1, 2 or 3, then `x' is always
|
||
initialized, but GCC doesn't know this. Here is another common
|
||
case:
|
||
|
||
{
|
||
int save_y;
|
||
if (change_y) save_y = y, y = new_y;
|
||
...
|
||
if (change_y) y = save_y;
|
||
}
|
||
|
||
This has no bug because `save_y' is used only if it is set.
|
||
|
||
Some spurious warnings can be avoided if you declare all the
|
||
functions you use that never return as `noreturn'. *Note Function
|
||
Attributes::.
|
||
|
||
`-Wunknown-pragmas'
|
||
Warn when a #pragma directive is encountered which is not
|
||
understood by GCC. If this command line option is used, warnings
|
||
will even be issued for unknown pragmas in system header files.
|
||
This is not the case if the warnings were only enabled by the
|
||
`-Wall' command line option.
|
||
|
||
`-Wall'
|
||
All of the above `-W' options combined. This enables all the
|
||
warnings about constructions that some users consider
|
||
questionable, and that are easy to avoid (or modify to prevent the
|
||
warning), even in conjunction with macros.
|
||
|
||
The following `-W...' options are not implied by `-Wall'. Some of
|
||
them warn about constructions that users generally do not consider
|
||
questionable, but which occasionally you might wish to check for;
|
||
others warn about constructions that are necessary or hard to avoid in
|
||
some cases, and there is no simple way to modify the code to suppress
|
||
the warning.
|
||
|
||
`-W'
|
||
Print extra warning messages for these events:
|
||
|
||
* A nonvolatile automatic variable might be changed by a call to
|
||
`longjmp'. These warnings as well are possible only in
|
||
optimizing compilation.
|
||
|
||
The compiler sees only the calls to `setjmp'. It cannot know
|
||
where `longjmp' will be called; in fact, a signal handler
|
||
could call it at any point in the code. As a result, you may
|
||
get a warning even when there is in fact no problem because
|
||
`longjmp' cannot in fact be called at the place which would
|
||
cause a problem.
|
||
|
||
* A function can return either with or without a value.
|
||
(Falling off the end of the function body is considered
|
||
returning without a value.) For example, this function would
|
||
evoke such a warning:
|
||
|
||
foo (a)
|
||
{
|
||
if (a > 0)
|
||
return a;
|
||
}
|
||
|
||
* An expression-statement or the left-hand side of a comma
|
||
expression contains no side effects. To suppress the
|
||
warning, cast the unused expression to void. For example, an
|
||
expression such as `x[i,j]' will cause a warning, but
|
||
`x[(void)i,j]' will not.
|
||
|
||
* An unsigned value is compared against zero with `<' or `<='.
|
||
|
||
* A comparison like `x<=y<=z' appears; this is equivalent to
|
||
`(x<=y ? 1 : 0) <= z', which is a different interpretation
|
||
from that of ordinary mathematical notation.
|
||
|
||
* Storage-class specifiers like `static' are not the first
|
||
things in a declaration. According to the C Standard, this
|
||
usage is obsolescent.
|
||
|
||
* If `-Wall' or `-Wunused' is also specified, warn about unused
|
||
arguments.
|
||
|
||
* A comparison between signed and unsigned values could produce
|
||
an incorrect result when the signed value is converted to
|
||
unsigned. (But don't warn if `-Wno-sign-compare' is also
|
||
specified.)
|
||
|
||
* An aggregate has a partly bracketed initializer. For
|
||
example, the following code would evoke such a warning,
|
||
because braces are missing around the initializer for `x.h':
|
||
|
||
struct s { int f, g; };
|
||
struct t { struct s h; int i; };
|
||
struct t x = { 1, 2, 3 };
|
||
|
||
* An aggregate has an initializer which does not initialize all
|
||
members. For example, the following code would cause such a
|
||
warning, because `x.h' would be implicitly initialized to
|
||
zero:
|
||
|
||
struct s { int f, g, h; };
|
||
struct s x = { 3, 4 };
|
||
|
||
`-Wtraditional'
|
||
Warn about certain constructs that behave differently in
|
||
traditional and ANSI C.
|
||
|
||
* Macro arguments occurring within string constants in the
|
||
macro body. These would substitute the argument in
|
||
traditional C, but are part of the constant in ANSI C.
|
||
|
||
* A function declared external in one block and then used after
|
||
the end of the block.
|
||
|
||
* A `switch' statement has an operand of type `long'.
|
||
|
||
* A non-`static' function declaration follows a `static' one.
|
||
This construct is not accepted by some traditional C
|
||
compilers.
|
||
|
||
`-Wundef'
|
||
Warn if an undefined identifier is evaluated in an `#if' directive.
|
||
|
||
`-Wshadow'
|
||
Warn whenever a local variable shadows another local variable.
|
||
|
||
`-Wid-clash-LEN'
|
||
Warn whenever two distinct identifiers match in the first LEN
|
||
characters. This may help you prepare a program that will compile
|
||
with certain obsolete, brain-damaged compilers.
|
||
|
||
`-Wlarger-than-LEN'
|
||
Warn whenever an object of larger than LEN bytes is defined.
|
||
|
||
`-Wpointer-arith'
|
||
Warn about anything that depends on the "size of" a function type
|
||
or of `void'. GNU C assigns these types a size of 1, for
|
||
convenience in calculations with `void *' pointers and pointers to
|
||
functions.
|
||
|
||
`-Wbad-function-cast'
|
||
Warn whenever a function call is cast to a non-matching type. For
|
||
example, warn if `int malloc()' is cast to `anything *'.
|
||
|
||
`-Wcast-qual'
|
||
Warn whenever a pointer is cast so as to remove a type qualifier
|
||
from the target type. For example, warn if a `const char *' is
|
||
cast to an ordinary `char *'.
|
||
|
||
`-Wcast-align'
|
||
Warn whenever a pointer is cast such that the required alignment
|
||
of the target is increased. For example, warn if a `char *' is
|
||
cast to an `int *' on machines where integers can only be accessed
|
||
at two- or four-byte boundaries.
|
||
|
||
`-Wwrite-strings'
|
||
Give string constants the type `const char[LENGTH]' so that
|
||
copying the address of one into a non-`const' `char *' pointer
|
||
will get a warning. These warnings will help you find at compile
|
||
time code that can try to write into a string constant, but only
|
||
if you have been very careful about using `const' in declarations
|
||
and prototypes. Otherwise, it will just be a nuisance; this is
|
||
why we did not make `-Wall' request these warnings.
|
||
|
||
`-Wconversion'
|
||
Warn if a prototype causes a type conversion that is different
|
||
from what would happen to the same argument in the absence of a
|
||
prototype. This includes conversions of fixed point to floating
|
||
and vice versa, and conversions changing the width or signedness
|
||
of a fixed point argument except when the same as the default
|
||
promotion.
|
||
|
||
Also, warn if a negative integer constant expression is implicitly
|
||
converted to an unsigned type. For example, warn about the
|
||
assignment `x = -1' if `x' is unsigned. But do not warn about
|
||
explicit casts like `(unsigned) -1'.
|
||
|
||
`-Wsign-compare'
|
||
Warn when a comparison between signed and unsigned values could
|
||
produce an incorrect result when the signed value is converted to
|
||
unsigned. This warning is also enabled by `-W'; to get the other
|
||
warnings of `-W' without this warning, use `-W -Wno-sign-compare'.
|
||
|
||
`-Waggregate-return'
|
||
Warn if any functions that return structures or unions are defined
|
||
or called. (In languages where you can return an array, this also
|
||
elicits a warning.)
|
||
|
||
`-Wstrict-prototypes'
|
||
Warn if a function is declared or defined without specifying the
|
||
argument types. (An old-style function definition is permitted
|
||
without a warning if preceded by a declaration which specifies the
|
||
argument types.)
|
||
|
||
`-Wmissing-prototypes'
|
||
Warn if a global function is defined without a previous prototype
|
||
declaration. This warning is issued even if the definition itself
|
||
provides a prototype. The aim is to detect global functions that
|
||
fail to be declared in header files.
|
||
|
||
`-Wmissing-declarations'
|
||
Warn if a global function is defined without a previous
|
||
declaration. Do so even if the definition itself provides a
|
||
prototype. Use this option to detect global functions that are
|
||
not declared in header files.
|
||
|
||
`-Wmissing-noreturn'
|
||
Warn about functions which might be candidates for attribute
|
||
`noreturn'. Note these are only possible candidates, not absolute
|
||
ones. Care should be taken to manually verify functions actually
|
||
do not ever return before adding the `noreturn' attribute,
|
||
otherwise subtle code generation bugs could be introduced.
|
||
|
||
`-Wredundant-decls'
|
||
Warn if anything is declared more than once in the same scope,
|
||
even in cases where multiple declaration is valid and changes
|
||
nothing.
|
||
|
||
`-Wnested-externs'
|
||
Warn if an `extern' declaration is encountered within an function.
|
||
|
||
`-Winline'
|
||
Warn if a function can not be inlined, and either it was declared
|
||
as inline, or else the `-finline-functions' option was given.
|
||
|
||
`-Wlong-long'
|
||
Warn if `long long' type is used. This is default. To inhibit
|
||
the warning messages, use `-Wno-long-long'. Flags `-Wlong-long'
|
||
and `-Wno-long-long' are taken into account only when `-pedantic'
|
||
flag is used.
|
||
|
||
`-Werror'
|
||
Make all warnings into errors.
|
||
|