Lines Matching defs:VALUE
620 assert(!T.isNull() && "r-value conversion on typeless expression?");
674 // If the lvalue has qualified type, the value has the unqualified
675 // version of the type of the lvalue; otherwise, the value has the
690 // Loading a __weak object implicitly retains the value, so we need a cleanup to
705 // ... if the lvalue has atomic type, the value has the non-atomic version
751 // First, convert to an r-value.
777 // value is converted to an int; otherwise, it is converted to an
842 // operand or a subexpression thereof the value contained in the
1337 /// Return the rank of a given fixed point or integer type. The value itself
1409 // with the highest rank; the resulting value is converted (taking into
1908 llvm::APSInt Value(CharBits, CharIsUnsigned);
1915 Value = Lit->getCodeUnit(I);
1916 TemplateArgument Arg(Context, Value, CharTy);
1992 value of the referee must be copied
1994 // since the value of the referee is not known at compile time and must
2906 // Sentinel value saying that we didn't do anything special.
3210 // Make sure that we're referring to a value.
3245 // a reference to 'V' is simply (unexpanded) 'T'. The type, like the value,
3252 #define VALUE(type, base)
3256 llvm_unreachable("invalid value decl kind");
3292 valueKind = VK_LValue; // even if the parameter is an r-value reference
3319 // In C, "extern void blah;" is valid and is an r-value.
3756 llvm::APSInt Value(CharBits, CharIsUnsigned);
3758 Value = TokSpelling[I];
3759 TemplateArgument Arg(Context, Value, Context.CharTy);
3806 // Clause 6.4.4 - The value of a constant shall be in the range of
3808 // fract type with a value of exactly 1; such a constant shall denote
3809 // the maximal value for the type.
3874 // Get the value in the widest-possible width.
3879 // If this value didn't fit into uintmax_t, error and force to ull.
3886 // If this value fits into a ULL, try to figure out what else it fits into
5129 llvm::APSInt Value = EvResult.Val.getInt();
5130 if (!Value.isStrictlyPositive()) {
5132 << Value.toString(/*Radix=*/10, /*Signed=*/true)
6013 /// array type derivation, then for each call to the function, the value of the
6529 /// __builtin_astype( value, dst type )
6556 /// __builtin_convertvector( value, dst type )
6915 // obviously have a value kind derived from the kind of reference involved.
7071 // Only do this in an r-value context.
7643 // If a single value is specified in the initializer then it will be
7647 // vector. If a single value is specified in the initializer then it will
7667 // For OpenCL, when the number of initializers is a single value,
8754 // in the special case of a C++ l-value conditional.
9436 // Build a compound literal constructing a value of the transparent
9506 // to put the updated value.
9607 // C99 6.5.16.1p2: The value of the right operand is converted to the
9719 /// Try to convert a value of non-vector type to a vector type by converting
9801 // Reject cases where the value of the Int is unknown as that would
9828 // Reject cases where the value of the scalar is not constant and it's
9901 // FIXME: Notionally if the scalar was a floating point value with a precise
9928 // value is dependent (and thus cannot be evaluated by the constant
10874 // more than the maximum value representable in the result type, so never
10884 // If LHS does not have a signed type and non-negative value
10908 // expected value. Thus we place this behind a different warning that can be
11511 // value-dependent so we can't tell whether it's actually narrowing.
11516 // Implicit conversion to a narrower type, and the value is not a constant
11524 // Implicit conversion to a narrower type, and the value is not a constant
13112 // type is deprecated unless the assignment is either a discarded-value
13126 // C99 6.5.16.1p2: In simple assignment, the value of the right operand
13216 // So we treat the LHS as a ignored value, and in C++ we allow the
13352 // the base's value, so the object the base refers to is
13383 // If the result of an implicit cast is an l-value, we care about
13551 // The operand must be either an l-value or a function designator
13778 /// DiagnoseSelfAssignment - Emits a warning if a value is assigned to itself.
13843 // can return non-pointer values boxed in a pointer value.
14505 // Assignments with a pseudo-object l-value need special analysis.
14596 // An assignment expression has the value of the left operand after the
15005 if (const Expr *Value = LastStmt->getExprStmt()) {
15007 Ty = Value->getType();
15506 // Try to apply the named return value optimization. We have to check again
15680 // Otherwise, the va_list argument must be an l-value because
16432 value expression or an
16668 // value expressions nor unevaluated operands (those cases get removed from
17247 // are mutable in the sense that user can change their value - they are
17463 // Determine whether we are capturing by reference or by value.
17572 /// Create up to 4 fix-its for explicit reference and value capture of \p Var or
17593 << Var << /*value*/ 0
17634 << /*value*/ 0
17990 // set of potential results of a discarded-value expression to which
18431 // of potential results of a discarded-value expression to which the
18483 // or discarded value conversions that would obviate odr-use.
18673 // variable, which can cause the expression to become value-dependent
18708 /// behavior of a program, such as passing a non-POD value through an ellipsis.
18975 /// expression which it shares the type and value kind of.
19070 /// expression which it shares the type and value kind of.
19622 "Unknown Objective-C Boolean value!");
Indexes created Fri May 01 00:23:41 UTC 2026