Lines Matching full:warn
1792 the standard. For example `-std=gnu90 -pedantic' would warn about
1926 that function to warn about problems with calls to that function,
2395 Warn when G++ generates code that is probably not compatible with
2397 warn about all such cases, there are probably some cases that are
2505 Warn when a class seems unusable because all the constructors or
2510 Warn when a noexcept-expression evaluates to false because of a
2516 Warn when a class has virtual functions and accessible non-virtual
2522 Warn when the order of member initializers given in the code does
2538 Warn about violations of the following style guidelines from Scott
2554 Also warn about violations of the following style guidelines from
2568 Warn also about the use of an uncasted `NULL' as sentinel. When
2591 Warn
2597 Warn when a function declaration hides virtual functions from a
2620 Warn when overload resolution chooses a promotion from unsigned or
2797 Warn whenever an Objective-C assignment is being intercepted by the
2811 Warn if multiple methods of different types for the same selector
2823 Warn if multiple methods with differing argument and/or return
2831 Warn if a `@selector(...)' expression referring to an undeclared
2889 Warn if feedback profiles do not match when using the
2971 something goes wrong, the compiler will warn that an unrecognized
3014 there would be nothing to warn about.)
3063 them warn about constructions that users generally do not consider
3065 others warn about constructions that are necessary or hard to
3110 Warn if an array subscript has type `char'. This is a common cause
3115 Warn whenever a comment-start sequence `/*' appears in a `/*'
3178 If `-Wformat' is specified, also warn about `strftime' formats
3182 If `-Wformat' is specified, do not warn about format strings that
3186 If `-Wformat' is specified, do not warn about excess arguments to a
3200 If `-Wformat' is specified, do not warn about zero-length formats.
3204 If `-Wformat' is specified, also warn if the format string is not a
3209 If `-Wformat' is specified, also warn about uses of format
3225 Warn about passing a null pointer for arguments marked as
3232 Warn about uninitialized variables which are initialized with
3236 For example, GCC will warn about `i' being uninitialized in the
3245 Warn when a declaration does not specify a type. This warning is
3259 Warn if the return type of a function has a type qualifier such as
3270 Warn if the type of `main' is suspicious. `main' should be a
3277 Warn if an aggregate or union initializer is not fully bracketed.
3287 Warn if a user-supplied include directory does not exist.
3290 Warn if parentheses are omitted in certain contexts, such as when
3295 Also warn if a comparison like `x<=y<=z' appears; this is
3299 Also warn about constructions where there may be confusion to which
3331 Also warn for dangerous uses of the ?: with omitted middle operand
3340 Warn about code that may have undefined semantics because of
3386 Warn about self-assignment and self-initialization. This warning
3388 and therefore does not warn on a statement that is semantically a
3395 int x = x; /* warn */
3399 i = i + 0; /* not warn */
3400 f = f / 1; /* not warn */
3401 a[1] = a[1]; /* warn */
3402 i += 0; /* not warn */
3405 In C++ it will not warn on self-assignment of non-POD variables
3409 Warn about self-assignment of non-POD variables. This is a
3425 t.operator=(t); // not warn
3426 t = t; // warn
3430 Warn whenever a function is defined with a return-type that
3431 defaults to `int'. Also warn about any `return' statement with no
3445 When doing an FDO build with `-fprofile-use' and `-fripa', warn if
3453 Warn whenever a `switch' statement has an index of enumerated type
3461 Warn whenever a `switch' statement does not have a `default' case.
3464 Warn whenever a `switch' statement has an index of enumerated type
3473 Warn when `__sync_fetch_and_nand' and `__sync_nand_and_fetch'
3478 Warn about potential thread safety issues when the code is
3482 Warn about shared variables not properly protected by locks
3487 Warn about function calls not properly protected by locks
3492 Warn about lock acquisition order inconsistent with what specified
3497 Warn about mismatched lock acquisition and release. This flag is
3501 Warn about a lock being acquired recursively. This flag is
3505 Warn about uses of unsupported lock names in attributes. This flag
3514 Warn if any trigraphs are encountered that might change the
3519 Warn whenever a function parameter is assigned to, but otherwise
3528 Warn whenever a local variable is assigned to, but otherwise unused
3538 Warn whenever a static function is declared but not defined or a
3543 Warn whenever a label is declared but not used. This warning is
3550 Warn whenever a function parameter is unused aside from its
3557 Do not warn if a caller of a function marked with attribute
3562 Warn whenever a local variable or non-constant static variable is
3574 Warn whenever a statement computes a result that is explicitly not
3591 Warn if an automatic variable is used without first being
3593 In C++, warn if a non-static reference or non-static `const' member
3596 If you want to warn about code which uses the uninitialized value
3658 Warn when a #pragma directive is encountered which is not
3665 Do not warn about misuses of pragmas, such as incorrect parameters,
3687 when higher levels do not warn but -fstrict-aliasing still breaks
3706 converted pointer is dereferenced. Does not warn about incomplete
3714 not warn about all cases where the code might overflow: it only
3729 Warn about cases which are both questionable and easy to
3736 Also warn about other cases where a comparison is simplified
3744 Also warn about other cases where a comparison is simplified.
3748 Also warn about other simplifications not covered by the
3753 Also warn about cases where the compiler reduces the
3762 Warn for cases where adding an attribute may be beneficial. The
3768 Warn about functions which might be candidates for attributes
3785 Do not warn about compile-time integer division by zero. Floating
3796 `-Wall' in conjunction with this option will _not_ warn about
3801 Warn about trampolines generated for pointers to nested functions.
3812 Warn if floating point values are used in equality comparisons.
3827 Warn about certain constructs that behave differently in
3828 traditional and ISO C. Also warn about ISO C constructs that have
3904 Warn if a prototype causes a type conversion that is different
3912 Warn when a declaration is found after a statement in a block.
3919 Warn if an undefined identifier is evaluated in an `#if' directive.
3922 Do not warn whenever an `#else' or an `#endif' are followed by
3926 Warn whenever a local variable or type declaration shadows another
3929 not warn if a local variable shadows a struct/class/enum, but will
3930 warn if it shadows an explicit typedef.
3933 Warn when a local variable shadows another local variable or
3937 Warn when a local variable shadows another local variable or
3965 Warn whenever an object of larger than LEN bytes is defined.
3968 Warn if the size of a function frame is larger than LEN bytes.
3977 Warn if the loop cannot be optimized because the compiler could not
3979 `-funsafe-loop-optimizations' warn if the compiler made such
3989 Warn about anything that depends on the "size of" a function type
3992 functions. In C++, warn also when an arithmetic operation involves
3996 Warn if a comparison is always true or always false due to the
3997 limited range of the data type, but do not warn for constant
3998 expressions. For example, warn if an unsigned variable is
4003 Warn whenever a function call is cast to a non-matching type. For
4004 example, warn if `int malloc()' is cast to `anything *'.
4007 Warn about ISO C constructs that are outside of the common subset
4012 Warn about C++ constructs whose meaning differs between ISO C++
4018 Warn whenever a pointer is cast so as to remove a type qualifier
4019 from the target type. For example, warn if a `const char *' is
4022 Also warn when making a cast which introduces a type qualifier in
4034 Warn whenever a pointer is cast such that the required alignment
4035 of the target is increased. For example, warn if a `char *' is
4049 When compiling C++, warn about the deprecated conversion from
4054 Warn for variables that might be changed by `longjmp' or `vfork'.
4058 Warn for implicit conversions that may alter a value. This includes
4062 Do not warn for explicit casts like `abs ((int) x)' and `ui =
4068 For C++, also warn for confusing overload resolution for
4076 Do not warn for conversions between `NULL' and non-pointer types.
4080 Warn for implicit type conversions from real (`double' or `float')
4084 Warn if an empty body occurs in an `if', `else' or `do while'
4088 Warn about a comparison between values of different enum types. In
4093 Warn if a `goto' statement or a `switch' statement jumps forward
4104 Warn when a comparison between signed and unsigned values could
4111 Warn for implicit conversions that may change the sign of an
4117 Warn about suspicious uses of memory addresses. These include using
4130 Warn about suspicious uses of logical operators in expressions.
4135 Warn if any functions that return structures or unions are defined
4140 Do not warn if an unexpected `__attribute__' is used, such as
4146 Do not warn if certain built-in macros are redefined. This
4151 Warn if a function is declared or defined without specifying the
4157 Warn for obsolescent usages, according to the C Standard, in a
4158 declaration. For example, warn if storage-class specifiers like
4163 Warn if an old-style function definition is used. A warning is
4175 Warn if a global function is defined without a previous prototype
4181 Warn if a global function is defined without a previous
4189 Warn if a structure's initializer has some fields missing. For
4196 This option does not warn about designated initializers, so the
4207 Warn about function pointers which might be candidates for `format'
4217 GCC will also warn about function definitions which might be
4226 Do not warn if a multicharacter constant (`'FOOF'') is used.
4239 warn you if you are using identifiers which have not been
4267 well, and GCC will warn if your code is not in NFKC if you use
4275 Do not warn about usage of deprecated features. *Note Deprecated
4279 Do not warn about uses of functions (*note Function Attributes::),
4285 Do not warn about compile-time overflow in constant expressions.
4288 Warn if an initialized field without side effects is overridden
4296 Warn if a structure is given the packed attribute, but the packed
4330 Warn if padding is included in a structure, either to align an
4337 Warn if anything is declared more than once in the same scope,
4342 Warn if an `extern' declaration is encountered within a function.
4345 Warn if a function can not be inlined and it was declared as
4346 inline. Even with this option, the compiler will not warn about
4389 Warn if a precompiled header (*note Precompiled Headers::) is
4393 Warn if `long long' type is used. This is enabled by either
4398 Warn if variadic macros are used in pedantic ISO C90 mode, or the
4404 Warn if variable length array is used in the code. `-Wno-vla'
4408 Warn if a register variable is declared volatile. The volatile
4414 Warn if a requested optimization pass is disabled. This warning
4423 Warn for pointer argument passing or assignment with different
4438 Warn about string constants which are longer than the "minimum
4455 warn about such constants in system header files. This can be
6184 warn you if it finds this kind of loop.
8820 Warn whenever a comment-start sequence `/*' appears in a `/*'
8837 Warn about certain constructs that behave differently in
8838 traditional and ISO C. Also warn about ISO C constructs that have
8843 Warn whenever an identifier which is not a macro is encountered in
8848 Warn about macros defined in the main file that are unused. A
8850 once. The preprocessor will also warn if the macro has not been
8867 Warn whenever an `#else' or an `#endif' are followed by text.
9604 Warn about any unresolved references (unless overridden by the
11064 Warn when the stack frame of a function exceeds N bytes.
11223 with `-iframework' the compiler does not warn about constructs
22555 compiler, the linker is told _not_ to warn about size or content
23305 Using `-Winline' will warn when a function marked `inline' could not be
23675 to an `int' variable named `__arg' would warn about using a pointer
