Lines Matching defs:Check
132 /// Check that the first argument to __builtin_annotation is an integer
182 /// Check that the argument to __builtin_addressof is a glvalue, and set the
198 /// Check the number of arguments and set the result type to
208 /// Check that the value argument for __builtin_is_aligned(value, alignment) and
243 // We can't check validity of alignment if it is value dependent.
591 /// Check a call to BuiltinID for buffer overflows. If BuiltinID is a
725 // (usually using __builtin_object_size). Use that value to check this call.
873 /// OpenCL C v2.0, s6.13.17.6 - Check the argument to the
902 /// OpenCL v2.0, s6.13.17.1 - Check that sizes are provided for all
921 // Check that the sizes of the local memory are specified by integers.
994 // check that the last argument is the right block type.
1000 // we have a block type, check the prototype
1016 // check common block argument.
1033 // check remaining common arguments.
1160 // Check packet type T.
1170 // Check reserve_id_t.
1178 // Check the index.
1188 // Check packet type T.
1213 // Check the reserve size.
1242 // Check reserve_id_t.
1451 // If any arguments are required to be ICE's, check and diagnose.
1818 // then check probability is constant float in range [0.0, 1.0]
1879 // check for the argument.
1971 auto Check = [](CallExpr *TheCall) {
1983 if (!Check(TheCall)) {
1991 // Since the target specific builtins for each arch overlap, only check those
2047 /// the vector type specified by the NeonTypeFlags. This is used to check
2088 // Range check SVE intrinsics that take immediate values.
2111 // We can't check the value of a dependent argument.
2116 // Check constant-ness first.
2236 // Check that pointer arguments have the specified type.
2263 // instruction, range check them here.
2305 // We can't check the value of a dependent argument.
2470 // range check them here.
2551 // Only check the valid encoding range. Any constant in this range would be
2568 // range check them here.
2587 // to BPF backend to check whether the access is a
3342 // Check if the given type is a non-pointer PPC MMA type. This function is used
3388 // Check valididty of memory ordering as per C11 / C++11's memody model.
3389 // Only fence needs check. Atomic dec/inc allow all memory orders.
3412 // Check that sync scope is a constant literal
3423 // We can't check the value of a dependent argument.
3428 // Check constant-ness first.
3450 // Check if each required feature is included
3497 // range check them here.
3557 // Check if the argument is a string literal.
3562 // Check the contents of the string.
3577 // Check if the argument is a string literal.
3582 // Check the contents of the string.
3591 // Check if the rounding mode is legal.
3773 // We can't check the value of a dependent argument.
3778 // Check constant-ness first.
3796 // Check if the gather/scatter scale is legal.
3883 // We can't check the value of a dependent argument.
3888 // Check constant-ness first.
3977 // Check for 32-bit only builtins on a 64-bit target.
3996 // range check them here.
4327 // Note that we don't force a hard error on the range check here, allowing
4464 // Check the attributes attached to the method/function itself.
4543 // Check for non-null arguments.
4596 // FIXME: We should check as much as we can in the template definition.
4643 // Check that passed arguments match the alignment of original arguments.
4687 /// CheckConstructorCall - Check a constructor call for correctness and safety
4704 /// CheckFunctionCall - Check a direct function call for various correctness
5033 // Check we have the right number of arguments.
5677 // Now that we know how many fixed arguments we expect, first check that we
5719 // can fail in some cases (1i -> int**), check for this error case now.
5727 // Okay, we have something that *can* be converted to the right type. Check
5732 // FIXME: Do this check.
5756 // type, so only need to check the first argument.
5862 // Check for conversion failure.
5895 /// Check that the user is calling the appropriate va_start builtin for the
5970 /// Check the arguments to '__builtin_va_start' or '__builtin_ms_va_start'
5982 // Type-check the first argument normally.
5986 // Check that the current function is variadic, and get its last parameter.
6050 // Type-check the first argument normally.
6054 // Check that the current function is variadic.
6088 /// friends. This is declared to take (...), so we have to check everything.
6126 /// to check everything. We expect the last argument to be a floating point
6237 // Check the third argument is a compile time constant
6248 // Check the type of argument 1 and argument 2 are vectors.
6258 // Check the first two arguments are the same type.
6275 // This is declared to take (...), so we have to check everything.
6304 // Check to see if we have a call with 2 vector arguments, the unary shuffle
6434 // We can't check the value of a dependent argument.
6474 // We can't check the value of a dependent argument.
6521 // For formatting call, check buffer arg.
6533 // Check string literal arg.
6560 // Check formatting specifiers. NOTE: We're only doing this for the non-size
6581 /// SemaBuiltinConstantArg - Handle a check if argument ArgNum of CallExpr
6599 /// SemaBuiltinConstantArgRange - Handle a check if argument ArgNum of CallExpr
6607 // We can't check the value of a dependent argument.
6612 // Check constant-ness first.
6632 /// SemaBuiltinConstantArgMultiple - Handle a check if argument ArgNum of CallExpr
6638 // We can't check the value of a dependent argument.
6643 // Check constant-ness first.
6654 /// SemaBuiltinConstantArgPower2 - Check if argument ArgNum of TheCall is a
6659 // We can't check the value of a dependent argument.
6664 // Check constant-ness first.
6681 // Check if it's a shifted byte, by shifting it down
6683 // If the value fits in the bottom byte, the check passes.
6687 // Otherwise, if the value has _any_ bits in the bottom byte, the check
6699 /// SemaBuiltinConstantArgShiftedByte - Check if argument ArgNum of TheCall is
6706 // We can't check the value of a dependent argument.
6711 // Check constant-ness first.
6726 /// SemaBuiltinConstantArgShiftedByteOr0xFF - Check if argument ArgNum of
6729 /// 0x00FF, 0x01FF, ..., 0xFFFF). This strange range check is needed for some
6736 // We can't check the value of a dependent argument.
6741 // Check constant-ness first.
6749 // Check to see if it's in either of the required forms.
6913 /// SemaBuiltinARMSpecialReg - Handle a check if argument ArgNum of CallExpr
6932 // We can't check the value of a dependent argument.
6937 // Check if the argument is a string literal.
6942 // Check the type of special register given.
6951 // If the string is the name of a register then we cannot check that it is
6953 // can check that the supplied fields are integers and within the valid
7013 /// SemaBuiltinPPCMMACall - Check the call to a PPC MMA builtin for validity.
7301 // Determine whether it is necessary to check both sub-expressions, for
7316 // separately to check if every possible indexed expression is a valid
7374 // so don't check if the pointee type is constant.
7394 // special check to see if the format string is a function parameter
7416 // We also check if the formats are compatible.
7589 /// CheckFormatArguments - Check calls to printf and scanf (and similar
7612 // CHECK: printf/scanf-like function is called with no format string.
7620 // CHECK: format string is not a string literal.
7648 // Literal format string found, check done!
8145 //===--- CHECK: Printf format string checking ------------------------------===//
8253 // Type check the data argument. It should be an 'int'.
8399 /// Check if we could call '.c_str()' on an object.
8415 // Check if a (w)string was passed when a (w)char* was needed, and offer a
8463 // First check if the field width, precision, and conversion specifier
8484 // The check to see if the argIndex is valid will come later.
8500 // Type check the first argument (int for %b, pointer for %D)
8513 // Type check the second argument (char * for both %b and %D)
8527 // Check for using an Objective-C specific conversion specifier
8559 // Check for use of public/private annotation outside of os_log().
8577 // Check for invalid use of field width
8583 // Check for invalid use of precision
8598 // Check each flag does not conflict with any other component.
8612 // Check that flags are not ignored by another flag
8620 // Check the length modifier is valid with the given conversion specifier.
8714 // typedef sugar there. Recurse to operands to check for NSInteger &
8772 // Now type check the data expression that matches the
8813 // Check if we didn't match because of an implicit cast from a 'char'
8859 // While we are here, check if the value is an IntegerLiteral that happens
9062 //===--- CHECK: Scanf format string checking ------------------------------===//
9138 // Check if the field with is non-zero.
9160 // The check to see if the argIndex is valid will come later.
9166 // Check the length modifier is valid with the given conversion specifier.
9187 // Check that the argument type matches the format specifier.
9249 // CHECK: is the format string a wide literal?
9286 // CHECK: empty format string?
9335 //===--- CHECK: Warn on use of wrong absolute value function. -------------===//
9577 // Found std::abs(), check that they are the right ones.
9581 // Check that the parameter type can handle the argument.
9688 // The argument and parameter are the same kind. Check if they are the right
9721 //===--- CHECK: Warn on use of std::max and unsigned zero. r---------------===//
9737 // Check that template type argument is unsigned integer.
9784 //===--- CHECK: Standard memory functions ---------------------------------===//
9834 // Check all the fields. If any bases were dynamic, the class is dynamic.
9979 /// Check if the ArgLoc originated from a macro passed to the call at CallLoc.
10047 /// Check for dangerous or invalid arguments to memset().
10164 // Also check for cases where the sizeof argument is the exact same
10349 /// Check if two expressions refer to the same declaration.
10422 // Check if the destination is an array (rather than a pointer to an array).
10560 // Maybe the cast was important, check after the other cases.
10571 // Check if the return value is null but should not be.
10601 //===--- CHECK: Floating-Point comparisons (-Wfloat-equal) ---------------===//
10603 /// Check for comparisons of floating point operands using != and ==.
10610 // Special case: check for x == x (which is OK).
10617 // Special case: check for comparisons against literals that can be exactly
10630 // Check for comparisons with builtin types.
10644 //===--- CHECK: Integer mixed-sign comparisons (-Wsign-compare) --------===//
10645 //===--- CHECK: Lossy implicit conversions (-Wconversion) --------------===//
11389 // Check if all values in the range of possible values of this expression
11506 /// \param E the binary operator to check for warnings
11539 // Check whether an integer constant comparison results in a value
11566 // Check to see if one of the (unmodified) operands is of different
11669 // Enum types are implicitly signed on Windows, so check if there are any
11674 // Check for surprising sign changes when assigning enum values to a
11703 // Check the bitwidth.
11732 // Check whether the stored value is equal to the original value.
11946 // Now check the outermost expression
12032 // Check for NULL (GNUNull) or nullptr (CXX11_nullptr).
12076 /// Check a single element within a collection literal against the
12107 /// Check an Objective-C array literal being converted to the given
12135 /// Check an Objective-C dictionary literal being converted to the given
12254 // delay this check as long as possible. Once we detect we are in that
12267 // prevented by a check in AnalyzeImplicitConversions().
12301 // Check implicit casts from Objective-C collection literals to specialized
12407 // Check last argument of function call to see if it is an
12724 // ...then check whether it would have warned about either of the
12736 /// Check conversion of given expression to boolean.
12797 // Check implicit argument conversions for function calls.
12801 // Go ahead and check any implicit conversions we might have skipped.
12828 // Do a somewhat different check with comparison operators.
13045 // Check for parameter decl with nonnull attribute
13122 // Check to see if '()' fixit should be emitted.
13168 // Check for array bounds violations in cases where the check isn't triggered
13177 /// CheckBoolLikeConversion - Check conversion of given expression to boolean.
13337 /// Expressions to check later. We defer checking these to reduce
13414 // FIXME: Check for more interesting cases, like "x.n = ++x.n".
13441 /// Check whether a modification or use of an object \p O in an expression
13636 // so check it before inspecting the operands and update the
14117 /// CheckParmsForFunctionDef - Check that the parameters of the given
14159 // callee function. Do not perform any direct access check on the dtor here.
14176 // attribute, we need to check for constness here.
14182 // Check for parameter names shadowing fields from the class.
14470 /// Check whether this array fits the idiom of a size-one tail padded
14713 //===--- CHECK: Objective-C retain cycles ----------------------------------//
14883 /// Check whether the given argument is a block which captures a
14931 /// Check for a keyword selector that starts with the word 'add' or
15119 /// Check a message send to see if it's likely to cause a retain cycle.
15121 // Only check instance methods whose selector looks like a setter.
15137 // Check whether the receiver is captured by any of the arguments.
15149 /// Check a property assign to see if it's likely to cause a retain cycle.
15175 // Check if RHS is an Objective-C object literal, which also can get
15255 // FIXME. Check for other life times.
15291 //===--- CHECK: Empty statement body (-Wempty-body) ---------------------===//
15327 // Since this is a syntactic check, don't emit diagnostic for template
15411 //===--- CHECK: Warn on self move with std::move. -------------------------===//
15426 // Check for a call expression
15431 // Check for a call to std::move
15441 // Two DeclRefExpr's, check that the decls are the same.
15455 // Member variables require a different approach to check for self moves.
15502 /// Check if two enumeration types are layout-compatible.
15511 /// Check if two fields are layout-compatible.
15532 /// Check if two standard-layout structs are layout-compatible.
15536 // If both records are C++ classes, check that base classes match.
15541 // Check number of base classes.
15545 // Check the base classes.
15561 // Check the fields.
15576 /// Check if two standard-layout unions are layout-compatible.
15615 /// Check if two types are layout-compatible in C++11 sense.
15651 //===--- CHECK: pointer_with_type_tag attribute: datatypes should match ----//
15959 // No need to check expressions with an __unaligned-qualified type.
16032 // Check if the synthesized offset fulfills the alignment.
16137 // Check pointer argument.
16198 // Check row and column dimenions.
16207 // Check stride argument.
16276 // Check pointer argument.
16312 // Check stride argument.
Indexes created Sun May 17 00:24:36 UTC 2026