Lines Matching +defs:t +defs:expr
337 // FIXME: this is not quite the right error message since we don't allow
352 // We can't check validity of alignment if it is value dependent.
445 // the other qualifiers aren't possible.
536 // call. We don't want to produce more than one error.
583 // contents but printf doesn't support that.
589 // FIXME: It would be nice to include a '...' if the string doesn't fit
696 // We don't know how to print this field. Print out its address
751 // Second argument is a callable, but we can't fully validate it until we try
1383 // diagnostic isn't quite right. We should still diagnose passing a buffer
1461 // Scopes aren't available during instantiation. Fortunately, builtin
1627 // If it's a function declaration, we can't have an offset.
1871 // Some builtins don't require additional checking, so just consider these
2069 ICEArguments = 0; // Don't diagnose previously diagnosed errors.
2077 // If we don't have enough arguments, continue so we can issue better
2203 // BuiltinShuffleVector guts it, but then doesn't release it.
2927 // We can't check the value of a dependent argument.
2958 // of member functions is counted. However, it doesn't appear in our own
2976 // This must happen first: the smart pointer expr might have _Nonnull type!
2982 // If the expression has non-null type, it doesn't evaluate to null.
3125 // argument too. If the parameter is a reference type, don't try to get
3171 // Refuse POD arguments that weren't caught by the format string
3403 // None of the checks below are needed for functions that don't have
3868 // 'A'. We shouldn't let the volatile-ness of the pointee-type inject itself
4140 // Because it is a pointer type, we don't have to worry about any implicit
4142 // FIXME: We don't allow floating point scalars as input.
4513 // Because it is a pointer type, we don't have to worry about any implicit
4600 // Don't allow this in System V ABI functions.
4605 // On x86-64/AArch64 Unix, don't allow this in Win64 ABI functions.
4606 // On x64 Windows, don't allow this in System V ABI functions.
4638 // FIXME: This isn't correct for methods (results in bogus warning).
4641 // We don't support va_start in a CapturedDecl.
4684 // integer constant expression with value 0, then we don't bother with this
4826 // If the common type isn't a real floating type, then the arguments were
4963 // We don't allow _Complex _Float16 nor _Complex __fp16 as type specifiers;
4964 // don't allow this builtin to form those types either.
5153 // We can't check the value of a dependent argument.
5199 // We can't check the value of a dependent argument.
5326 // We can't check the value of a dependent argument.
5355 // We can't check the value of a dependent argument.
5374 // We can't check the value of a dependent argument.
5408 // then shifting the value right by 8 bits won't affect whether it's a
5418 // We can't check the value of a dependent argument.
5442 // We can't check the value of a dependent argument.
5521 // Don't update if a previous string covers all arguments.
5769 // so don't check if the pointee type is constant.
5788 // for which there shouldn't be a warning. For instance, when calling
5842 // We can't pass a 'scanf' string to a 'printf' function.
5913 // format specifiers. The idea is that if the key doesn't have any
6413 // Find any arguments that weren't covered.
6457 // Consider the argument coverered, even though the specifier doesn't
6463 // don't issue a warning because that is just a cascade of warnings (and
6464 // they may have intended '%%' anyway). We don't want to continue processing
6700 // Don't do any more checking. We will just emit
6708 // doesn't emit a warning for that case.
6726 // Don't do any more checking. We will just emit
6853 /// FIXME: This returns the wrong results in some cases (if cv-qualifiers don't
7110 // Take care of a few common cases where they aren't.
7263 // doesn't make sense.
7309 // Check if we didn't match because of an implicit cast from a 'char'
7332 // addition, don't treat expressions as of type 'char' if one byte length
7503 // We don't use getLocForEndOfToken because it returns invalid source
7513 // We extract the name from the typedef because we don't want to show
7694 // Handle case where '%' and '*' don't consume an argument. These shouldn't
8150 // Found a function, don't need the header hint.
8617 // isn't, this is also likely an error. This should catch
8819 // we don't want to remove sizeof().
8858 // Don't crash if the user has the wrong number of arguments
8942 // Don't crash if the user has the wrong number of arguments.
9102 { // Prefer something that doesn't involve a cast to make things simpler.
9407 // The result of a remainder can't be larger than the result of
9471 /// particular, assume that arithmetic on narrower types doesn't leave
9646 // Don't 'pre-truncate' the operands.
10015 // Don't warn if the non-constant operand actually always evaluates to the
10021 // from a macro or enumerator. We don't want to diagnose
10118 // Don't analyze value-dependent comparisons directly.
10131 // We don't care about expressions whose result is a constant.
10151 // We don't do anything special if this isn't an unsigned integral
10153 // signed comparisons only happen in cases we don't care to warn about.
10195 // If the signed range is non-negative, -Wsign-compare won't fire.
10445 // FIXME: Force the precision of the source value down so we don't print
10446 // digits which are usually useless (we don't really care here if we
10617 // Don't warn on functions which have return type nullptr_t.
10660 // Don't warn on char array initialization or for non-decimal values.
10743 // If the conversion context location is invalid don't complain. We also
10744 // don't want to emit a warning if the issue occurs from the expansion of
10821 // Diagnose vector truncation but don't return. We may also want to
10890 // Don't warn about float constants that are precisely
11308 // Examine, but don't traverse into the source expression of an
11309 // OpaqueValueExpr, since it may have multiple parents and we don't want to
11402 // we don't really need to recurse into them, because any internal
11407 // Don't descend into unevaluated contexts.
11520 // Don't warn inside macros.
11714 // Don't diagnose in unevaluated contexts.
11718 // Don't diagnose for value- or type-dependent expressions.
11722 // Check for array bounds violations in cases where the check isn't triggered
12097 // Skip all statements which aren't expressions for now.
12156 // C++17 [expr.sub]p1:
12170 // C++17 [expr.mptr.oper]p4:
12184 // C++17 [expr.shift]p4:
12195 // C++11 [expr.comma]p1:
12214 // C++11 [expr.ass]p1:
12225 // C++17 [expr.ass]p1:
12251 // C++11 [expr.ass]p1:
12279 // C++11 [expr.pre.incr]p1:
12299 // C++11 [expr.log.or]p2:
12315 // C++11 [expr.log.or]p1:
12332 // C++11 [expr.log.and]p2:
12348 // C++11 [expr.log.and]p1:
12364 // C++11 [expr.cond]p1:
12374 // both the true and false expressions because we can't evaluate x.
12378 // We don't wrap the visitation of the true and false expression with
12379 // SequencedSubexpression because we don't want to downgrade modifications
12395 // C++11 [expr.cond]p1:
12434 // C++17 [expr.call]p5
12848 // If the integer expression isn't a constant expression, compute the lower
13032 // cast; don't do it if we're ignoring -Wcast_align (as is the default).
13124 // pointer) bounds-checking isn't meaningful.
13275 void Sema::CheckArrayAccess(const Expr *expr) {
13277 while (expr) {
13278 expr = expr->IgnoreParenImpCasts();
13279 switch (expr->getStmtClass()) {
13281 const ArraySubscriptExpr *ASE = cast<ArraySubscriptExpr>(expr);
13284 expr = ASE->getBase();
13288 expr = cast<MemberExpr>(expr)->getBase();
13292 const ArraySectionExpr *ASE = cast<ArraySectionExpr>(expr);
13302 const UnaryOperator *UO = cast<UnaryOperator>(expr);
13303 expr = UO->getSubExpr();
13317 const ConditionalOperator *cond = cast<ConditionalOperator>(expr);
13325 const auto *OCE = cast<CXXOperatorCallExpr>(expr);
13490 // Since this is a syntactic check, don't emit diagnostic for template
13692 "Can't evaluate layout compatibility between a struct field and a "
14054 // Passing a `void*' pointer shouldn't trigger a warning.