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
-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
-w
-Wno-import
-Wchar-subscripts char . This is a common cause of error, as programmers often forget that this type is signed on some machines.
-Wcomment
-Wformat printf and scanf , etc., to make sure that the arguments supplied have types appropriate to the format string specified.
-Wimplicit
-Wparentheses
-Wreturn-type int . Also warn about any return statement with no return-value in a function whose return-type is not void .
-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.
-Wtrigraphs
-Wunused To suppress this warning for an expression, simply cast it to void. For unused variables and parameters, use the `unused' attribute (see Variable Attributes).
-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 noreturn . See Function Attributes.
-Wenum-clash
-Wreorder (C++ only)
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.
-Wtemplate-debugging
-Wall 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.
-W
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 contains no side effects.
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.
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 };
-Wtraditional
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 .
-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
-Woverloaded-virtual
-Wsynth (C++ only)
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 ='.
-Werror