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 GNU CC:
-fsyntax-only
-w
-Wno-import
#import
'.
-pedantic
Valid ANSI standard 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 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.
See Alternate Keywords.
This option is not intended to be useful; it exists only to satisfy pedants who would otherwise claim that GNU CC 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 recommend, rather, that
users take advantage of the extensions of GNU C and disregard the
limitations of other compilers. Aside from certain supercomputers and
obsolete small machines, there is less and less reason ever to use any
other C compiler other than for bootstrapping GNU CC.
-pedantic-errors
-pedantic
', except that errors are produced rather than
warnings.
-W
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.
foo (a) { if (a > 0) return a; }
>
' or `<=
'.
x<=y<=z
' appears; this is equivalent to
`(x<=y ? 1 : 0) <= z
', which is a different interpretation from
that of ordinary mathematical notation.
static
are not the first things in
a declaration. According to the C Standard, this usage is obsolescent.
x.h
:
struct s { int f, g; }; struct t { struct s h; int i; }; struct t x = { 1, 2, 3 };
-Wimplicit
-Wreturn-type
int
. Also warn about any return
statement with no
return-value in a function whose return-type is not void
.
-Wunused
-Wswitch
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.
-Wcomment
/*
' appears in a comment.
-Wtrigraphs
-Wformat
printf
and scanf
, etc., to make sure that
the arguments supplied have types appropriate to the format string
specified.
-Wchar-subscripts
char
. This is a common cause
of error, as programmers often forget that this type is signed on some
machines.
-Wuninitialized
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 GNU CC 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 GNU CC 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 volatile
. See Function Attributes.
-Wparentheses
-Wenum-clash
-Wtemplate-debugging
-Wall
-W
' options combined. These are all the
options which pertain to usage that we recommend avoiding and that we
believe is easy to avoid, even in conjunction with macros.
The remaining `-W...
' options are not implied by `-Wall
'
because they warn about constructions that we consider reasonable to
use, on occasion, in clean programs.
-Wtraditional
switch
statement has an operand of type long
.
-Wshadow
-Wid-clash-len
-Wlarger-than-len
-Wpointer-arith
void
. GNU C assigns these types a size of 1, for
convenience in calculations with void *
pointers and pointers
to functions.
-Wbad-function-cast
int malloc()
is cast to anything *
.
-Wcast-qual
const char *
is cast
to an ordinary char *
.
-Wcast-align
char *
is cast to
an int *
on machines where integers can only be accessed at
two- or four-byte boundaries.
-Wwrite-strings
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
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
.
-Waggregate-return
-Wstrict-prototypes
-Wmissing-prototypes
-Wmissing-declarations
-Wredundant-decls
-Wnested-externs
extern
declaration is encountered within an function.
-Winline
-finline-functions
' option was given.
-Woverloaded-virtual
-Werror