| /external/clang/test/SemaCXX/ |
| warn-self-assign.cpp | 19 #define RHS a
24 a = RHS;
25 LHS OP RHS;
28 #undef RHS
|
| /external/llvm/lib/Support/ |
| DeltaAlgorithm.cpp | 32 changeset_ty LHS, RHS;
36 ((idx < N) ? LHS : RHS).insert(*it);
39 if (!RHS.empty())
40 Res.push_back(RHS);
|
| /external/clang/lib/ARCMigrate/ |
| TransZeroOutPropsInDealloc.cpp | 65 // Remove the setter message if RHS is null
67 Expr *RHS = ME->getArg(0);
69 RHS->isNullPointerConstant(Ctx,
182 Expr *RHS = BOE->getRHS();
183 bool RHSIsNull = RHS->isNullPointerConstant(Ctx,
188 return isZeroingPropIvar(RHS);
|
| /external/llvm/lib/Analysis/ |
| PHITransAddr.cpp | 260 // Handle add with a constant RHS.
264 Constant *RHS = cast<ConstantInt>(Inst->getOperand(1));
276 RHS = ConstantExpr::getAdd(RHS, CI);
287 if (Value *Res = SimplifyAddInst(LHS, RHS, isNSW, isNUW, TD, DT)) {
295 if (LHS == Inst->getOperand(0) && RHS == Inst->getOperand(1))
303 BO->getOperand(0) == LHS && BO->getOperand(1) == RHS &&
423 // Handle add with a constant RHS.
|
| /external/clang/lib/Lex/ |
| PreprocessingRecord.cpp | 105 SourceLocation RHS = getLoc(R);
106 return SM.isBeforeInTranslationUnit(LHS, RHS);
109 bool operator()(PreprocessedEntity *L, SourceLocation RHS) const {
111 return SM.isBeforeInTranslationUnit(LHS, RHS);
115 SourceLocation RHS = getLoc(R);
116 return SM.isBeforeInTranslationUnit(LHS, RHS);
|
| TokenLexer.cpp | 201 // If it is not the LHS/RHS of a ## operator, we must pre-expand the
250 // Okay, we have a token that is either the LHS or RHS of a paste (##)
302 // If an empty argument is on the LHS or RHS of a paste, the standard (C99
304 // implement this by eating ## operators when a LHS or RHS expands to
315 // If this is on the RHS of a paste operator, we've already copied the
449 /// operator. Read the ## and RHS, and paste the LHS/RHS together. If there
461 assert(!isAtEnd() && "No token on the RHS of a paste operator!");
463 // Get the RHS token.
464 const Token &RHS = Tokens[CurToken]
[all...] |
| /external/llvm/lib/Transforms/Utils/ |
| AddrModeMatcher.cpp | 180 // Check to see if we can merge in the RHS then the LHS. If so, we win.
191 // Otherwise this was over-aggressive. Try merging in the LHS then the RHS.
207 ConstantInt *RHS = dyn_cast<ConstantInt>(AddrInst->getOperand(1));
208 if (!RHS) return false;
209 int64_t Scale = RHS->getSExtValue();
|
| /external/clang/lib/Rewrite/ |
| DeltaTree.cpp | 56 DeltaTreeNode *LHS, *RHS;
137 Children[1] = IR.RHS;
139 FullDelta = IR.LHS->getFullDelta()+IR.RHS->getFullDelta()+IR.Split.Delta;
224 InsertRes->RHS->DoInsertion(FileIndex, Delta, 0 /*can't fail*/);
243 IN->Children[i+1] = InsertRes->RHS;
256 DeltaTreeNode *SubRHS = InsertRes->RHS;
267 InsertSide = cast<DeltaTreeInteriorNode>(InsertRes->RHS);
302 // into the RHS child.
330 InsertRes.RHS = NewNode;
393 DeltaTree::DeltaTree(const DeltaTree &RHS) {
[all...] |
| /external/clang/lib/StaticAnalyzer/Checkers/ |
| DeadStoresChecker.cpp | 168 const Expr *RHS = B->getRHS()->IgnoreParenCasts();
169 const BinaryOperator* BRHS = dyn_cast<BinaryOperator>(RHS);
212 Expr *RHS = B->getRHS()->IgnoreParenCasts();
215 if (DeclRefExpr *RhsDR = dyn_cast<DeclRefExpr>(RHS))
|
| IdempotentOperationChecker.cpp | 84 static bool isSelfAssign(const Expr *LHS, const Expr *RHS);
87 const Expr *RHS);
129 const Expr *RHS = B->getRHS();
140 RHSContainsFalsePositive = !CanVary(RHS, AC)
141 || containsNonLocalVarDecl(RHS);
147 SVal RHSVal = state->getSVal(RHS);
194 if (isSelfAssign(LHS, RHS)) {
195 if (!isUnused(LHS, AC) && !isTruncationExtensionAssignment(LHS, RHS)) {
424 const Expr *RHS = i->first->getRHS();
426 FindLastStoreBRVisitor::registerStatementVarDecls(*report, RHS);
[all...] |
| /external/clang/lib/StaticAnalyzer/Core/ |
| ExprEngineC.cpp | 27 Expr *RHS = B->getRHS()->IgnoreParens();
34 // With both the LHS and RHS evaluated, process the operation itself.
40 SVal RightV = state->getSVal(RHS);
52 // Simulate the effects of a "store": bind the value of the RHS
398 // We took the RHS. Because the value of the '&&' or '||' expression must
399 // evaluate to 0 or 1, we must assume the value of the RHS evaluates to 0
705 SVal RHS;
708 RHS = svalBuilder.makeArrayIndex(1);
710 RHS = svalBuilder.makeIntVal(1, U->getType());
712 SVal Result = evalBinOp(state, Op, V2, RHS, U->getType())
[all...] |
| /external/llvm/examples/Kaleidoscope/Chapter2/ |
| toy.cpp | 101 ExprAST *LHS, *RHS;
103 BinaryExprAST(char op, ExprAST *lhs, ExprAST *rhs)
104 : Op(op), LHS(lhs), RHS(rhs) {}
255 ExprAST *RHS = ParsePrimary();
256 if (!RHS) return 0;
258 // If BinOp binds less tightly with RHS than the operator after RHS, let
259 // the pending operator take RHS as its LHS.
262 RHS = ParseBinOpRHS(TokPrec+1, RHS)
[all...] |
| /external/llvm/include/llvm/ADT/ |
| Twine.h | 152 /// RHS - The suffix in the concatenation, which may be uninitialized for
154 Child RHS;
173 RHS.twine = &_RHS;
180 : LHS(_LHS), RHS(_RHS), LHSKind(_LHSKind), RHSKind(_RHSKind) {
212 // Nullary twines always have Empty on the RHS.
216 // Null should never appear on the RHS.
220 // The RHS cannot be non-empty if the LHS is empty.
229 !RHS.twine->isBinary())
350 RHS.stringRef = &_RHS;
358 RHS.cString = _RHS
[all...] |
| /external/llvm/include/llvm/Analysis/ |
| ScalarEvolutionExpressions.h | 258 const SCEV *RHS;
259 SCEVUDivExpr(const FoldingSetNodeIDRef ID, const SCEV *lhs, const SCEV *rhs)
260 : SCEV(ID, scUDivExpr), LHS(lhs), RHS(rhs) {}
264 const SCEV *getRHS() const { return RHS; }
267 // In most cases the types of LHS and RHS will be the same, but in some
271 // a pointer type than the RHS, so use the RHS' type here.
|
| /external/llvm/lib/CodeGen/ |
| IntrinsicLowering.cpp | 286 Value *RHS = Builder.CreateAnd(VShift, MaskCst, "cppop.and2");
287 PartValue = Builder.CreateAdd(LHS, RHS, "ctpop.step");
|
| /external/llvm/lib/MC/ |
| MCExpr.cpp | 146 const MCExpr *RHS, MCContext &Ctx) {
147 return new (Ctx) MCBinaryExpr(Opc, LHS, RHS);
349 /// from two MCValue's LHS and RHS where
350 /// Result = LHS + RHS
515 // Negate RHS and add.
532 int64_t LHS = LHSValue.getConstant(), RHS = RHSValue.getConstant();
535 case MCBinaryExpr::Add: Result = LHS + RHS; break;
536 case MCBinaryExpr::And: Result = LHS & RHS; break;
537 case MCBinaryExpr::Div: Result = LHS / RHS; break;
538 case MCBinaryExpr::EQ: Result = LHS == RHS; break
[all...] |
| /external/llvm/lib/Target/Mips/ |
| MipsISelDAGToDAG.cpp | 229 SDValue RHS = Node->getOperand(1);
234 SDValue(Carry,0), RHS);
|
| /external/llvm/lib/Transforms/InstCombine/ |
| InstCombineAddSub.cpp | 61 /// (sext (add LHS, RHS)) === (add (sext LHS), (sext RHS))
64 bool InstCombiner::WillNotOverflowSignedAdd(Value *LHS, Value *RHS) {
69 // have one carry bit which can change a sign. As such, if LHS and RHS each
72 if (ComputeNumSignBits(LHS) > 1 && ComputeNumSignBits(RHS) > 1)
88 Value *LHS = I.getOperand(0), *RHS = I.getOperand(1);
90 if (Value *V = SimplifyAddInst(LHS, RHS, I.hasNoSignedWrap(),
98 if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) {
102 return BinaryOperator::CreateXor(LHS, RHS);
142 if (isa<Constant>(RHS) && isa<PHINode>(LHS)
[all...] |
| InstCombineShifts.cpp | 482 // If the operand is an bitwise operator with a constant RHS, and the
690 Constant *RHS = ConstantInt::getSigned(Op0->getType(), isCtPop ? -1:0);
691 Value *Cmp = Builder->CreateICmpEQ(II->getArgOperand(0), RHS);
|
| InstCombineSimplifyDemanded.cpp | 41 // This instruction is producing bits that are not demanded. Shrink the RHS.
158 // If either the LHS or the RHS are Zero, the result is zero.
182 // If either the LHS or the RHS are One, the result is One.
225 // If either the LHS or the RHS are Zero, the result is zero.
247 // If the RHS is a constant, see if we can simplify it.
251 // Output known-1 bits are only known if set in both the LHS & RHS.
253 // Output known-0 are known to be clear if zero in either the LHS | RHS.
257 // If either the LHS or the RHS are One, the result is One.
284 // If the RHS is a constant, see if we can simplify it.
288 // Output known-0 bits are only known if clear in both the LHS & RHS
[all...] |
| InstCombineVectorOps.cpp | 197 EI.getName()+".rhs");
248 /// elements from either LHS or RHS, return the shuffle mask and true.
250 static bool CollectSingleShuffleElements(Value *V, Value *LHS, Value *RHS,
252 assert(V->getType() == LHS->getType() && V->getType() == RHS->getType() &&
267 if (V == RHS) {
287 if (CollectSingleShuffleElements(VecOp, LHS, RHS, Mask)) {
298 // This must be extracting from either LHS or RHS.
299 if (EI->getOperand(0) == LHS || EI->getOperand(0) == RHS) {
302 if (CollectSingleShuffleElements(VecOp, LHS, RHS, Mask)) {
309 assert(EI->getOperand(0) == RHS);
[all...] |
| /external/llvm/lib/Transforms/Scalar/ |
| Reassociate.cpp | 54 inline bool operator<(const ValueEntry &LHS, const ValueEntry &RHS) {
55 return LHS.Rank > RHS.Rank; // Sort so that highest rank goes to start.
122 Value *LHS = Op->getOperand(0), *RHS = Op->getOperand(1);
127 RemoveDeadBinaryOp(RHS);
180 // If this is an expression, return the 1+MAX(rank(LHS), rank(RHS)) so that
231 BinaryOperator *RHS = cast<BinaryOperator>(I->getOperand(1));
233 isReassociableOp(RHS, I->getOpcode()) &&
236 DEBUG(dbgs() << "Linear" << *LHS << '\n' << *RHS << '\n' << *I << '\n');
238 // Move the RHS instruction to live immediately before I, avoiding breaking
240 RHS->moveBefore(I)
[all...] |
| /frameworks/base/include/private/ui/ |
| RegionHelper.h | 41 static const uint32_t RHS = 0x6; // 0b110
43 op_nand = LHS & ~RHS,
44 op_and = LHS & RHS,
45 op_or = LHS | RHS,
46 op_xor = LHS ^ RHS
54 inline region(const region& rhs)
55 : rects(rhs.rects), count(rhs.count), dx(rhs.dx), dy(rhs.dy) {
157 region rhs; member in class:android::region_operator::Spanner
214 region rhs; member in class:android::region_operator::SpannerInner
[all...] |
| /external/clang/lib/Frontend/ |
| PrintPreprocessedOutput.cpp | 551 const id_macro_pair *RHS = static_cast<const id_macro_pair*>(b);
552 return LHS->first->getName().compare(RHS->first->getName());
|
| /external/llvm/examples/Kaleidoscope/Chapter3/ |
| toy.cpp | 109 ExprAST *LHS, *RHS;
111 BinaryExprAST(char op, ExprAST *lhs, ExprAST *rhs)
112 : Op(op), LHS(lhs), RHS(rhs) {}
267 ExprAST *RHS = ParsePrimary();
268 if (!RHS) return 0;
270 // If BinOp binds less tightly with RHS than the operator after RHS, let
271 // the pending operator take RHS as its LHS.
274 RHS = ParseBinOpRHS(TokPrec+1, RHS)
[all...] |
