/external/llvm/include/llvm/ADT/ |
APSInt.h | 36 APSInt &operator=(APInt RHS) { 38 APInt::operator=(std::move(RHS)); 42 APSInt &operator=(uint64_t RHS) { 44 APInt::operator=(RHS); 83 const APSInt &operator%=(const APSInt &RHS) { 84 assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!"); 86 *this = urem(RHS); 88 *this = srem(RHS); 91 const APSInt &operator/=(const APSInt &RHS) { 92 assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!") [all...] |
SmallString.h | 57 void assign(StringRef RHS) { 59 SmallVectorImpl<char>::append(RHS.begin(), RHS.end()); 63 void assign(const SmallVectorImpl<char> &RHS) { 65 SmallVectorImpl<char>::append(RHS.begin(), RHS.end()); 84 void append(StringRef RHS) { 85 SmallVectorImpl<char>::append(RHS.begin(), RHS.end()); 89 void append(const SmallVectorImpl<char> &RHS) { [all...] |
SmallBitVector.h | 150 SmallBitVector(const SmallBitVector &RHS) { 151 if (RHS.isSmall()) 152 X = RHS.X; 154 switchToLarge(new BitVector(*RHS.getPointer())); 157 SmallBitVector(SmallBitVector &&RHS) : X(RHS.X) { 158 RHS.X = 1; 387 bool anyCommon(const SmallBitVector &RHS) const { 388 if (isSmall() && RHS.isSmall()) 389 return (getSmallBits() & RHS.getSmallBits()) != 0 [all...] |
APInt.h | 180 static void divide(const APInt LHS, unsigned lhsWords, const APInt &RHS, 196 APInt AndSlowCase(const APInt &RHS) const; 199 APInt OrSlowCase(const APInt &RHS) const; 202 APInt XorSlowCase(const APInt &RHS) const; 205 APInt &AssignSlowCase(const APInt &RHS); 208 bool EqualSlowCase(const APInt &RHS) const; 645 /// \returns *this after assignment of RHS. 646 APInt &operator=(const APInt &RHS) { 648 if (isSingleWord() && RHS.isSingleWord()) { 649 VAL = RHS.VAL [all...] |
/external/clang/include/clang/Basic/ |
ABI.h | 76 bool Less(const VirtualAdjustment &RHS) const { 77 return memcmp(this, &RHS, sizeof(RHS)) < 0; 86 const ReturnAdjustment &RHS) { 87 return LHS.NonVirtual == RHS.NonVirtual && LHS.Virtual.Equals(RHS.Virtual); 90 friend bool operator!=(const ReturnAdjustment &LHS, const ReturnAdjustment &RHS) { 91 return !(LHS == RHS); 95 const ReturnAdjustment &RHS) { 96 if (LHS.NonVirtual < RHS.NonVirtual [all...] |
/external/clang/include/clang/Edit/ |
FileOffset.h | 37 friend bool operator==(FileOffset LHS, FileOffset RHS) { 38 return LHS.FID == RHS.FID && LHS.Offs == RHS.Offs; 40 friend bool operator!=(FileOffset LHS, FileOffset RHS) { 41 return !(LHS == RHS); 43 friend bool operator<(FileOffset LHS, FileOffset RHS) { 44 return std::tie(LHS.FID, LHS.Offs) < std::tie(RHS.FID, RHS.Offs); 46 friend bool operator>(FileOffset LHS, FileOffset RHS) { 47 return RHS < LHS [all...] |
/external/llvm/include/llvm/Support/ |
BranchProbability.h | 69 bool operator==(BranchProbability RHS) const { 70 return (uint64_t)N * RHS.D == (uint64_t)D * RHS.N; 72 bool operator!=(BranchProbability RHS) const { 73 return !(*this == RHS); 75 bool operator<(BranchProbability RHS) const { 76 return (uint64_t)N * RHS.D < (uint64_t)D * RHS.N; 78 bool operator>(BranchProbability RHS) const { return RHS < *this; [all...] |
BlockFrequency.h | 55 bool operator<(const BlockFrequency &RHS) const { 56 return Frequency < RHS.Frequency; 59 bool operator<=(const BlockFrequency &RHS) const { 60 return Frequency <= RHS.Frequency; 63 bool operator>(const BlockFrequency &RHS) const { 64 return Frequency > RHS.Frequency; 67 bool operator>=(const BlockFrequency &RHS) const { 68 return Frequency >= RHS.Frequency;
|
SMLoc.h | 30 bool operator==(const SMLoc &RHS) const { return RHS.Ptr == Ptr; } 31 bool operator!=(const SMLoc &RHS) const { return RHS.Ptr != Ptr; }
|
LineIterator.h | 70 friend bool operator==(const line_iterator &LHS, const line_iterator &RHS) { 71 return LHS.Buffer == RHS.Buffer && 72 LHS.CurrentLine.begin() == RHS.CurrentLine.begin(); 75 friend bool operator!=(const line_iterator &LHS, const line_iterator &RHS) { 76 return !(LHS == RHS);
|
/external/llvm/lib/Support/ |
SmallPtrSet.cpp | 219 void SmallPtrSetImplBase::CopyFrom(const SmallPtrSetImplBase &RHS) { 220 assert(&RHS != this && "Self-copy should be handled by the caller."); 222 if (isSmall() && RHS.isSmall()) 223 assert(CurArraySize == RHS.CurArraySize && 227 if (RHS.isSmall()) { 232 } else if (CurArraySize != RHS.CurArraySize) { 234 CurArray = (const void**)malloc(sizeof(void*) * RHS.CurArraySize); 237 sizeof(void*) * RHS.CurArraySize); 246 CurArraySize = RHS.CurArraySize; 249 memcpy(CurArray, RHS.CurArray, sizeof(void*)*CurArraySize) [all...] |
/system/core/include/utils/ |
Debug.h | 38 template<bool C, typename LSH, typename RHS> struct CompileTimeIfElse; 39 template<typename LHS, typename RHS> 40 struct CompileTimeIfElse<true, LHS, RHS> { typedef LHS TYPE; }; 41 template<typename LHS, typename RHS> 42 struct CompileTimeIfElse<false, LHS, RHS> { typedef RHS TYPE; };
|
/external/clang/test/Index/ |
cxx-operator-overload.cpp | 5 Cls operator +(const Cls &RHS); 13 Cls Cls::operator +(const Cls &RHS) { while (1) {} }
|
/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/llvm/include/llvm/IR/ |
NoFolder.h | 40 Instruction *CreateAdd(Constant *LHS, Constant *RHS, 42 BinaryOperator *BO = BinaryOperator::CreateAdd(LHS, RHS); 47 Instruction *CreateNSWAdd(Constant *LHS, Constant *RHS) const { 48 return BinaryOperator::CreateNSWAdd(LHS, RHS); 50 Instruction *CreateNUWAdd(Constant *LHS, Constant *RHS) const { 51 return BinaryOperator::CreateNUWAdd(LHS, RHS); 53 Instruction *CreateFAdd(Constant *LHS, Constant *RHS) const { 54 return BinaryOperator::CreateFAdd(LHS, RHS); 56 Instruction *CreateSub(Constant *LHS, Constant *RHS, 58 BinaryOperator *BO = BinaryOperator::CreateSub(LHS, RHS); [all...] |
PatternMatch.h | 378 BinaryOp_match(const LHS_t &LHS, const RHS_t &RHS) : L(LHS), R(RHS) {} 393 template<typename LHS, typename RHS> 394 inline BinaryOp_match<LHS, RHS, Instruction::Add> 395 m_Add(const LHS &L, const RHS &R) { 396 return BinaryOp_match<LHS, RHS, Instruction::Add>(L, R); 399 template<typename LHS, typename RHS> 400 inline BinaryOp_match<LHS, RHS, Instruction::FAdd> 401 m_FAdd(const LHS &L, const RHS &R) { 402 return BinaryOp_match<LHS, RHS, Instruction::FAdd>(L, R) [all...] |
ValueHandle.h | 73 ValueHandleBase(HandleBaseKind Kind, const ValueHandleBase &RHS) 74 : PrevPair(nullptr, Kind), Next(nullptr), VP(RHS.VP) { 76 AddToExistingUseList(RHS.getPrevPtr()); 83 Value *operator=(Value *RHS) { 84 if (VP.getPointer() == RHS) return RHS; 86 VP.setPointer(RHS); 88 return RHS; 91 Value *operator=(const ValueHandleBase &RHS) { 92 if (VP.getPointer() == RHS.VP.getPointer()) return RHS.VP.getPointer() [all...] |
ConstantFolder.h | 34 Constant *CreateAdd(Constant *LHS, Constant *RHS, 36 return ConstantExpr::getAdd(LHS, RHS, HasNUW, HasNSW); 38 Constant *CreateFAdd(Constant *LHS, Constant *RHS) const { 39 return ConstantExpr::getFAdd(LHS, RHS); 41 Constant *CreateSub(Constant *LHS, Constant *RHS, 43 return ConstantExpr::getSub(LHS, RHS, HasNUW, HasNSW); 45 Constant *CreateFSub(Constant *LHS, Constant *RHS) const { 46 return ConstantExpr::getFSub(LHS, RHS); 48 Constant *CreateMul(Constant *LHS, Constant *RHS, 50 return ConstantExpr::getMul(LHS, RHS, HasNUW, HasNSW) [all...] |
/external/clang/lib/Analysis/ |
ThreadSafetyLogical.cpp | 19 // to keep track of whether LHS and RHS are negated. 20 static bool implies(const LExpr *LHS, bool LNeg, const LExpr *RHS, bool RNeg) { 25 return implies(A->left(), LNeg, RHS, RNeg) && 26 implies(A->right(), LNeg, RHS, RNeg); 35 return implies(A->left(), LNeg, RHS, RNeg) || 36 implies(A->right(), LNeg, RHS, RNeg); 44 switch (RHS->kind()) { 50 return RNeg ? RightOrOperator(cast<And>(RHS)) 51 : RightAndOperator(cast<And>(RHS)); 57 return RNeg ? RightAndOperator(cast<Or>(RHS)) [all...] |
/external/clang/include/clang/Sema/ |
Weak.h | 38 bool operator==(WeakInfo RHS) const { 39 return alias == RHS.getAlias() && loc == RHS.getLocation(); 41 bool operator!=(WeakInfo RHS) const { return !(*this == RHS); }
|
/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/include/llvm/MC/ |
MCTargetOptions.h | 36 inline bool operator==(const MCTargetOptions &LHS, const MCTargetOptions &RHS) { 37 #define ARE_EQUAL(X) LHS.X == RHS.X 50 inline bool operator!=(const MCTargetOptions &LHS, const MCTargetOptions &RHS) { 51 return !(LHS == RHS);
|
YAML.h | 49 friend bool operator==(const BinaryRef &LHS, const BinaryRef &RHS); 79 inline bool operator==(const BinaryRef &LHS, const BinaryRef &RHS) { 81 if (LHS.Data.empty() && RHS.Data.empty()) 84 return LHS.DataIsHexString == RHS.DataIsHexString && LHS.Data == RHS.Data;
|
/external/llvm/include/llvm/Analysis/ |
TargetFolder.h | 50 Constant *CreateAdd(Constant *LHS, Constant *RHS, 52 return Fold(ConstantExpr::getAdd(LHS, RHS, HasNUW, HasNSW)); 54 Constant *CreateFAdd(Constant *LHS, Constant *RHS) const { 55 return Fold(ConstantExpr::getFAdd(LHS, RHS)); 57 Constant *CreateSub(Constant *LHS, Constant *RHS, 59 return Fold(ConstantExpr::getSub(LHS, RHS, HasNUW, HasNSW)); 61 Constant *CreateFSub(Constant *LHS, Constant *RHS) const { 62 return Fold(ConstantExpr::getFSub(LHS, RHS)); 64 Constant *CreateMul(Constant *LHS, Constant *RHS, 66 return Fold(ConstantExpr::getMul(LHS, RHS, HasNUW, HasNSW)) [all...] |