Lines Matching defs:RHS
450 ExprResult RHS = DefaultFunctionArrayLvalueConversion(Arg);
451 QualType RHSTy = RHS.get()->getType();
464 ConvTy = CheckSingleAssignmentConstraints(LHSTy, RHS);
465 if (RHS.isInvalid())
468 RHS.get(), AA_Assigning))
1840 // with mask. If so, verify that RHS is an integer vector type with the
4221 const Expr *RHS = BO->getRHS()->IgnoreParenCasts();
4224 if (isa<IntegerLiteral>(RHS))
4227 Ex = RHS;
4575 // the RHS argument instead of the LHS.
4582 // For conditional operators we need to see if either the LHS or RHS are
4748 // For conditional operators we need to see if either the LHS or RHS are
4840 void Sema::CheckFloatComparison(SourceLocation Loc, Expr* LHS, Expr *RHS) {
4842 Expr* RightExprSansParen = RHS->IgnoreParenImpCasts();
4876 << LHS->getSourceRange() << RHS->getSourceRange();
5091 // The type of the assignments is the type of the LHS, so the RHS
5103 // Simple assignments just pass through the RHS, which will have
5463 // Constant on LHS. | Constant on RHS. |
5568 Expr *RHS = E->getRHS()->IgnoreParenImpCasts();
5577 RHS->isIntegerConstantExpr(RHSValue, S.Context);
5582 DiagnoseOutOfRangeComparison(S, E, RHS, LHS, RHSValue, true);
5584 DiagnoseOutOfRangeComparison(S, E, LHS, RHS, LHSValue, false);
5604 assert(!RHS->getType()->hasSignedIntegerRepresentation() &&
5607 unsignedOperand = RHS;
5608 } else if (RHS->getType()->hasSignedIntegerRepresentation()) {
5609 signedOperand = RHS;
5622 AnalyzeImplicitConversions(S, RHS, E->getOperatorLoc());
5648 << LHS->getType() << RHS->getType()
5649 << LHS->getSourceRange() << RHS->getSourceRange());
5714 // We want to recurse on the RHS as normal unless we're assigning to
5719 // Recurse, ignoring any implicit conversions on the RHS.
6391 // ArraySubscriptExpr is on the RHS of a variable initialization.
6686 SequenceTree::Seq RHS = Tree.allocate(Region);
6695 Region = RHS;
6700 // Forget that LHS and RHS are sequenced. They are both unsequenced
6703 Tree.merge(RHS);
6708 // and RHS, so check it before inspecting the operands and update the
6770 /// Don't visit the RHS of '&&' or '||' if it might not be evaluated.
6773 // value computation of the RHS, and hence before the value computation
6787 // Check for unsequenced operations in the RHS, treating it as an
6790 // FIXME: If there are operations in the RHS which are unsequenced
6791 // with respect to operations outside the RHS, and those operations
7396 if (Expr *RHS = BinOp->getRHS()) {
7397 RHS = RHS->IgnoreParenCasts();
7400 (RHS && RHS->isIntegerConstantExpr(Value, Context) && Value == 0);
7526 Expr *RHS, bool isProperty) {
7527 // Check if RHS is an Objective-C object literal, which also can get
7530 RHS = RHS->IgnoreParenImpCasts();
7534 Sema::ObjCLiteralKind Kind = S.CheckLiteralKind(RHS);
7541 << RHS->getSourceRange();
7548 Expr *RHS, bool isProperty) {
7550 while (ImplicitCastExpr *cast = dyn_cast<ImplicitCastExpr>(RHS)) {
7555 << RHS->getSourceRange();
7558 RHS = cast->getSubExpr();
7562 checkUnsafeAssignLiteral(S, Loc, RHS, isProperty))
7569 QualType LHS, Expr *RHS) {
7575 if (checkUnsafeAssignObject(*this, Loc, LT, RHS, false))
7582 Expr *LHS, Expr *RHS) {
7604 if (checkUnsafeAssigns(Loc, LHSType, RHS))
7628 while (ImplicitCastExpr *cast = dyn_cast<ImplicitCastExpr>(RHS)) {
7631 << RHS->getSourceRange();
7634 RHS = cast->getSubExpr();
7638 if (checkUnsafeAssignObject(*this, Loc, Qualifiers::OCL_Weak, RHS, true))