Lines Matching full:warn
1618 the standard. For example `-std=gnu89 -pedantic' would warn about
1738 that function to warn about problems with calls to that function,
2139 Warn when G++ generates code that is probably not compatible with
2141 warn about all such cases, there are probably some cases that are
2231 Warn when a class seems unusable because all the constructors or
2236 Warn when a class has virtual functions and accessible non-virtual
2242 Warn when the order of member initializers given in the code does
2258 Warn about violations of the following style guidelines from Scott
2274 Also warn about violations of the following style guidelines from
2288 Warn also about the use of an uncasted `NULL' as sentinel. When
2311 Warn if an old-style (C-style) cast to a non-void type is used
2317 Warn when a function declaration hides virtual functions from a
2340 Warn when overload resolution chooses a promotion from unsigned or
2558 Warn whenever an Objective-C assignment is being intercepted by the
2572 Warn if multiple methods of different types for the same selector
2584 Warn if multiple methods with differing argument and/or return
2592 Warn if a `@selector(...)' expression referring to an undeclared
2650 Warn if feedback profiles do not match when using the
2756 there would be nothing to warn about.)
2803 them warn about constructions that users generally do not consider
2805 others warn about constructions that are necessary or hard to
2849 Warn if an array subscript has type `char'. This is a common cause
2854 Warn whenever a comment-start sequence `/*' appears in a `/*'
2894 If `-Wformat' is specified, also warn about `strftime' formats
2898 If `-Wformat' is specified, do not warn about format strings that
2902 If `-Wformat' is specified, do not warn about excess arguments to a
2916 If `-Wformat' is specified, do not warn about zero-length formats.
2920 If `-Wformat' is specified, also warn if the format string is not a
2925 If `-Wformat' is specified, also warn about uses of format
2941 Warn about passing a null pointer for arguments marked as
2948 Warn about uninitialized variables which are initialized with
2952 For example, GCC will warn about `i' being uninitialized in the
2961 Warn when a declaration does not specify a type. This warning is
2975 Warn if the return type of a function has a type qualifier such as
2986 Warn if the type of `main' is suspicious. `main' should be a
2993 Warn if an aggregate or union initializer is not fully bracketed.
3003 Warn if a user-supplied include directory does not exist.
3006 Warn if parentheses are omitted in certain contexts, such as when
3011 Also warn if a comparison like `x<=y<=z' appears; this is
3015 Also warn about constructions where there may be confusion to which
3050 Warn about code that may have undefined semantics because of
3096 Warn about self-assignment and self-initialization. This warning
3098 and therefore does not warn on a statement that is semantically a
3105 int x = x; /* warn */
3109 i = i + 0; /* not warn */
3110 f = f / 1; /* not warn */
3111 a[1] = a[1]; /* warn */
3112 i += 0; /* not warn */
3127 t.operator=(t); // not warn
3128 t = t; // warn
3132 Warn whenever a function is defined with a return-type that
3133 defaults to `int'. Also warn about any `return' statement with no
3147 When doing an FDO build with `-fprofile-use' and `-fripa', warn if
3155 Warn whenever a `switch' statement has an index of enumerated type
3163 Warn whenever a `switch' statement does not have a `default' case.
3166 Warn whenever a `switch' statement has an index of enumerated type
3172 Warn when `__sync_fetch_and_nand' and `__sync_nand_and_fetch'
3177 Warn if any trigraphs are encountered that might change the
3182 Warn whenever a static function is declared but not defined or a
3187 Warn whenever a label is declared but not used. This warning is
3194 Warn whenever a function parameter is unused aside from its
3201 Warn whenever a local variable or non-constant static variable is
3213 Warn whenever a statement computes a result that is explicitly not
3230 Warn if an automatic variable is used without first being
3232 In C++, warn if a non-static reference or non-static `const' member
3235 If you want to warn about code which uses the uninitialized value
3300 Warn when a #pragma directive is encountered which is not
3307 Do not warn about misuses of pragmas, such as incorrect parameters,
3329 when higher levels do not warn but -fstrict-aliasing still breaks
3348 converted pointer is dereferenced. Does not warn about incomplete
3356 not warn about all cases where the code might overflow: it only
3371 Warn about cases which are both questionable and easy to
3378 Also warn about other cases where a comparison is simplified
3386 Also warn about other cases where a comparison is simplified.
3390 Also warn about other simplifications not covered by the
3395 Also warn about cases where the compiler reduces the
3409 Do not warn about compile-time integer division by zero. Floating
3420 `-Wall' in conjunction with this option will _not_ warn about
3425 Warn if floating point values are used in equality comparisons.
3440 Warn about certain constructs that behave differently in
3441 traditional and ISO C. Also warn about ISO C constructs that have
3517 Warn if a prototype causes a type conversion that is different
3525 Warn when a declaration is found after a statement in a block.
3532 Warn if an undefined identifier is evaluated in an `#if' directive.
3535 Do not warn whenever an `#else' or an `#endif' are followed by
3539 Warn whenever a local variable shadows another local variable,
3544 Warn when a local variable shadows another local variable or
3548 Warn when a local variable shadows another local variable or
3576 Warn whenever an object of larger than LEN bytes is defined.
3579 Warn if the size of a function frame is larger than LEN bytes.
3588 Warn if the loop cannot be optimized because the compiler could not
3590 `-funsafe-loop-optimizations' warn if the compiler made such
3600 Warn about anything that depends on the "size of" a function type
3603 functions. In C++, warn also when an arithmetic operation involves
3607 Warn if a comparison is always true or always false due to the
3608 limited range of the data type, but do not warn for constant
3609 expressions. For example, warn if an unsigned variable is
3614 Warn whenever a function call is cast to a non-matching type. For
3615 example, warn if `int malloc()' is cast to `anything *'.
3618 Warn about ISO C constructs that are outside of the common subset
3623 Warn about C++ constructs whose meaning differs between ISO C++
3629 Warn whenever a pointer is cast so as to remove a type qualifier
3630 from the target type. For example, warn if a `const char *' is
3634 Warn whenever a pointer is cast such that the required alignment
3635 of the target is increased. For example, warn if a `char *' is
3649 When compiling C++, warn about the deprecated conversion from
3654 Warn for variables that might be changed by `longjmp' or `vfork'.
3658 Warn for implicit conversions that may alter a value. This includes
3662 Do not warn for explicit casts like `abs ((int) x)' and `ui =
3668 For C++, also warn for conversions between `NULL' and non-pointer
3677 Warn about peculiar, but valid, conversions from/to `NULL'. This
3683 Warn for implicit type conversions from real (`double' or `float')
3687 Warn if an empty body occurs in an `if', `else' or `do while'
3691 Warn about a comparison between values of different enum types.
3695 Warn when a comparison between signed and unsigned values could
3702 Warn for implicit conversions that may change the sign of an
3708 Warn
3721 Warn about suspicious uses of logical operators in expressions.
3726 Warn if any functions that return structures or unions are defined
3731 Do not warn if an unexpected `__attribute__' is used, such as
3737 Do not warn if certain built-in macros are redefined. This
3742 Warn if a function is declared or defined without specifying the
3748 Warn for obsolescent usages, according to the C Standard, in a
3749 declaration. For example, warn if storage-class specifiers like
3754 Warn if an old-style function definition is used. A warning is
3766 Warn if a global function is defined without a previous prototype
3772 Warn if a global function is defined without a previous
3780 Warn if a structure's initializer has some fields missing. For
3787 This option does not warn about designated initializers, so the
3798 Warn about functions which might be candidates for attribute
3806 Warn about function pointers which might be candidates for `format'
3816 GCC will also warn about function definitions which might be
3825 Do not warn if a multicharacter constant (`'FOOF'') is used.
3838 warn you if you are using identifiers which have not been
3866 well, and GCC will warn if your code is not in NFKC if you use
3874 Do not warn about usage of deprecated features. *Note Deprecated
3878 Do not warn about uses of functions (*note Function Attributes::),
3884 Do not warn about compile-time overflow in constant expressions.
3887 Warn if an initialized field without side effects is overridden
3895 Warn if a structure is given the packed attribute, but the packed
3929 Warn if padding is included in a structure, either to align an
3936 Warn if anything is declared more than once in the same scope,
3941 Warn if an `extern' declaration is encountered within a function.
3944 Warn if the compiler detects that code will never be executed.
3946 This option is intended to warn when the compiler detects that at
3966 Warn if a function can not be inlined and it was declared as
3967 inline. Even with this option, the compiler will not warn about
4001 Warn if a precompiled header (*note Precompiled Headers::) is
4005 Warn if `long long' type is used. This is default. To inhibit
4011 Warn if variadic macros are used in pedantic ISO C90 mode, or the
4017 Warn if variable length array is used in the code. `-Wno-vla'
4021 Warn if a register variable is declared volatile. The volatile
4027 Warn if a requested optimization pass is disabled. This warning
4036 Warn for pointer argument passing or assignment with different
4051 Warn about string constants which are longer than the "minimum
5514 warn you if it finds this kind of loop.
7674 Warn whenever a comment-start sequence `/*' appears in a `/*'
7691 Warn about certain constructs that behave differently in
7692 traditional and ISO C. Also warn about ISO C constructs that have
7697 Warn whenever an identifier which is not a macro is encountered in
7702 Warn about macros defined in the main file that are unused. A
7704 once. The preprocessor will also warn if the macro has not been
7721 Warn whenever an `#else' or an `#endif' are followed by text.
8428 Warn about any unresolved references (unless overridden by the
9791 Warn when the stack frame of a function exceeds N bytes.
9950 with `-iframework' the compiler does not warn about constructs
20053 compiler, the linker is told _not_ to warn about size or content
20703 Using `-Winline' will warn when a function marked `inline' could not be
20999 to an `int' variable named `__arg' would warn about using a pointer
37615 instances and warn about them.
