| /prebuilts/gdb/darwin-x86/include/python2.7/ |
| metagrammar.h | 10 #define RHS 258
|
| /prebuilts/gdb/linux-x86/include/python2.7/ |
| metagrammar.h | 10 #define RHS 258
|
| /prebuilts/python/darwin-x86/2.7.5/include/python2.7/ |
| metagrammar.h | 10 #define RHS 258
|
| /prebuilts/python/linux-x86/2.7.5/include/python2.7/ |
| metagrammar.h | 10 #define RHS 258
|
| /external/clang/lib/StaticAnalyzer/Core/ |
| CheckerHelpers.cpp | 75 // Extract lhs and rhs from assignment statement
79 const Expr *RHS = 0;
84 RHS = Assign->getRHS();
92 RHS = VD->getAnyInitializer();
95 return std::make_pair(VD, RHS);
|
| /external/clang/test/SemaCXX/ |
| warn-self-assign.cpp | 22 #define RHS a
27 a = RHS;
28 LHS OP RHS;
31 #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/llvm/unittests/Analysis/ |
| ValueTrackingTest.cpp | 54 Value *LHS, *RHS;
56 SelectPatternResult R = matchSelectPattern(A, LHS, RHS, &CastOp);
|
| /external/llvm/include/llvm/MC/MCParser/ |
| MCParsedAsmOperand.h | 38 MCParsedAsmOperand(const MCParsedAsmOperand &RHS) = default;
|
| /external/llvm/include/llvm/Transforms/InstCombine/ |
| InstCombineWorklist.h | 30 void operator=(const InstCombineWorklist&RHS) = delete;
38 InstCombineWorklist &operator=(InstCombineWorklist &&RHS) {
39 Worklist = std::move(RHS.Worklist);
40 WorklistMap = std::move(RHS.WorklistMap);
|
| /external/llvm/lib/Target/X86/MCTargetDesc/ |
| X86MachORelocationInfo.cpp | 102 const MCExpr *RHS = MCSymbolRefExpr::create(RSym, Ctx);
104 Expr = MCBinaryExpr::createSub(LHS, RHS, Ctx);
|
| /external/clang/include/clang/Analysis/Analyses/ |
| ThreadSafetyLogical.h | 32 /// \brief Logical implication. Returns true if the LExpr implies RHS, i.e. if
33 /// the LExpr holds, then RHS must hold. For example, (A & B) implies A.
34 inline bool implies(const LExpr *RHS) const;
56 LExpr *LHS, *RHS;
59 BinOp(LExpr *LHS, LExpr *RHS, Opcode Code) : LExpr(Code), LHS(LHS), RHS(RHS) {}
65 const LExpr *right() const { return RHS; }
66 LExpr *right() { return RHS; }
71 And(LExpr *LHS, LExpr *RHS) : BinOp(LHS, RHS, LExpr::And) {
[all...] |
| /external/llvm/lib/Analysis/ |
| PHITransAddr.cpp | 254 // Handle add with a constant RHS.
258 Constant *RHS = cast<ConstantInt>(Inst->getOperand(1));
270 RHS = ConstantExpr::getAdd(RHS, CI);
282 if (Value *Res = SimplifyAddInst(LHS, RHS, isNSW, isNUW, DL, TLI, DT, AC)) {
290 if (LHS == Inst->getOperand(0) && RHS == Inst->getOperand(1))
297 BO->getOperand(0) == LHS && BO->getOperand(1) == RHS &&
423 // Handle add with a constant RHS.
|
| /external/clang/lib/ARCMigrate/ |
| TransZeroOutPropsInDealloc.cpp | 70 // Remove the setter message if RHS is null
72 Expr *RHS = ME->getArg(0);
74 RHS->isNullPointerConstant(Ctx,
|
| /external/llvm/include/llvm/ADT/ |
| SmallPtrSet.h | 136 void operator=(const SmallPtrSetImplBase &RHS) = delete;
141 void swap(SmallPtrSetImplBase &RHS);
143 void CopyFrom(const SmallPtrSetImplBase &RHS);
144 void MoveFrom(unsigned SmallSize, SmallPtrSetImplBase &&RHS);
160 bool operator==(const SmallPtrSetIteratorImpl &RHS) const {
161 return Bucket == RHS.Bucket;
163 bool operator!=(const SmallPtrSetIteratorImpl &RHS) const {
164 return Bucket != RHS.Bucket;
322 operator=(const SmallPtrSet<PtrType, SmallSize> &RHS) {
323 if (&RHS != this
[all...] |
| ImmutableMap.h | 126 Factory(const Factory& RHS) = delete;
127 void operator=(const Factory& RHS) = delete;
134 bool operator==(const ImmutableMap &RHS) const {
135 return Root && RHS.Root ? Root->isEqual(*RHS.Root) : Root == RHS.Root;
138 bool operator!=(const ImmutableMap &RHS) const {
139 return Root && RHS.Root ? Root->isNotEqual(*RHS.Root) : Root != RHS.Root
[all...] |
| Twine.h | 155 /// RHS - The suffix in the concatenation, which may be uninitialized for
157 Child RHS;
171 explicit Twine(const Twine &LHS, const Twine &RHS)
174 this->RHS.twine = &RHS;
179 explicit Twine(Child LHS, NodeKind LHSKind, Child RHS, NodeKind RHSKind)
180 : LHS(LHS), RHS(RHS), LHSKind(LHSKind), RHSKind(RHSKind) {
216 // Nullary twines always have Empty on the RHS.
220 // Null should never appear on the RHS
[all...] |
| /external/clang/lib/Lex/ |
| PreprocessingRecord.cpp | 178 SourceLocation RHS = getLoc(R);
179 return SM.isBeforeInTranslationUnit(LHS, RHS);
182 bool operator()(PreprocessedEntity *L, SourceLocation RHS) const {
184 return SM.isBeforeInTranslationUnit(LHS, RHS);
188 SourceLocation RHS = getLoc(R);
189 return SM.isBeforeInTranslationUnit(LHS, RHS);
|
| TokenLexer.cpp | 261 // If it is not the LHS/RHS of a ## operator, we must pre-expand the
313 // Okay, we have a token that is either the LHS or RHS of a paste (##)
363 // If an empty argument is on the LHS or RHS of a paste, the standard (C99
365 // implement this by eating ## operators when a LHS or RHS expands to
374 // If this is on the RHS of a paste operator, we've already copied the
520 /// operator. Read the ## and RHS, and paste the LHS/RHS together. If there
540 assert(!isAtEnd() && "No token on the RHS of a paste operator!");
542 // Get the RHS token.
543 const Token &RHS = Tokens[CurToken]
[all...] |
| /external/clang/lib/Rewrite/ |
| DeltaTree.cpp | 56 DeltaTreeNode *LHS, *RHS;
135 Children[1] = IR.RHS;
137 FullDelta = IR.LHS->getFullDelta()+IR.RHS->getFullDelta()+IR.Split.Delta;
221 InsertRes->RHS->DoInsertion(FileIndex, Delta, nullptr /*can't fail*/);
240 IN->Children[i+1] = InsertRes->RHS;
253 DeltaTreeNode *SubRHS = InsertRes->RHS;
264 InsertSide = cast<DeltaTreeInteriorNode>(InsertRes->RHS);
299 // into the RHS child.
327 InsertRes.RHS = NewNode;
390 DeltaTree::DeltaTree(const DeltaTree &RHS) {
[all...] |
| /external/clang/lib/StaticAnalyzer/Checkers/ |
| DeadStoresChecker.cpp | 239 const Expr *RHS = B->getRHS()->IgnoreParenCasts();
240 const BinaryOperator* BRHS = dyn_cast<BinaryOperator>(RHS);
276 const Expr *RHS =
278 RHS = RHS->IgnoreParenCasts();
282 if (RHS->isNullPointerConstant(Ctx, Expr::NPC_ValueDependentIsNull))
288 if (const DeclRefExpr *RhsDR = dyn_cast<DeclRefExpr>(RHS))
|
| IdenticalExprChecker.cpp | 83 const Expr *RHS = B->getRHS();
92 if (isIdenticalStmt(AC->getASTContext(), RHS, B2->getRHS())) {
93 Sr[0] = RHS->getSourceRange();
100 if (isIdenticalStmt(AC->getASTContext(), RHS, LHS)) {
101 Sr[0] = RHS->getSourceRange();
224 const Expr *RHS = B->getRHS()->IgnoreParenImpCasts();
227 const DeclRefExpr *DeclRef2 = dyn_cast<DeclRefExpr>(RHS);
229 const FloatingLiteral *FloatLit2 = dyn_cast<FloatingLiteral>(RHS);
248 // Here only LHS is checked since RHS will be implicit casted to float.
|
| /external/llvm/examples/Kaleidoscope/Chapter2/ |
| toy.cpp | 121 std::unique_ptr<ExprAST> LHS, RHS;
125 std::unique_ptr<ExprAST> RHS)
126 : Op(Op), LHS(std::move(LHS)), RHS(std::move(RHS)) {}
293 auto RHS = ParsePrimary();
294 if (!RHS)
297 // If BinOp binds less tightly with RHS than the operator after RHS, let
298 // the pending operator take RHS as its LHS.
301 RHS = ParseBinOpRHS(TokPrec + 1, std::move(RHS))
[all...] |
| /external/llvm/include/llvm/IR/ |
| ValueHandle.h | 55 ValueHandleBase(const ValueHandleBase &RHS)
56 : ValueHandleBase(RHS.PrevPair.getInt(), RHS) {}
58 ValueHandleBase(HandleBaseKind Kind, const ValueHandleBase &RHS)
59 : PrevPair(nullptr, Kind), Next(nullptr), V(RHS.V) {
61 AddToExistingUseList(RHS.getPrevPtr());
84 Value *operator=(Value *RHS) {
85 if (V == RHS) return RHS;
87 V = RHS;
[all...] |
| /external/llvm/lib/CodeGen/ |
| IntrinsicLowering.cpp | 286 Value *RHS = Builder.CreateAnd(VShift, MaskCst, "cppop.and2");
287 PartValue = Builder.CreateAdd(LHS, RHS, "ctpop.step");
|
