/external/llvm/include/llvm/Transforms/Utils/ |
CmpInstAnalysis.h | 56 Value *getICmpValue(bool Sign, unsigned Code, Value *LHS, Value *RHS,
|
/external/llvm/include/llvm/DebugInfo/ |
DIContext.h | 52 bool operator==(const DILineInfo &RHS) const { 53 return Line == RHS.Line && Column == RHS.Column && 54 FileName.equals(RHS.FileName) && 55 FunctionName.equals(RHS.FunctionName); 57 bool operator!=(const DILineInfo &RHS) const { 58 return !(*this == RHS);
|
/external/llvm/include/llvm/ADT/ |
PackedVector.h | 130 bool operator==(const PackedVector &RHS) const { 131 return Bits == RHS.Bits; 134 bool operator!=(const PackedVector &RHS) const { 135 return Bits != RHS.Bits; 138 const PackedVector &operator=(const PackedVector &RHS) { 139 Bits = RHS.Bits; 143 PackedVector &operator|=(const PackedVector &RHS) { 144 Bits |= RHS.Bits; 148 void swap(PackedVector &RHS) { 149 Bits.swap(RHS.Bits) [all...] |
ImmutableMap.h | 125 Factory(const Factory& RHS) LLVM_DELETED_FUNCTION; 126 void operator=(const Factory& RHS) LLVM_DELETED_FUNCTION; 133 bool operator==(const ImmutableMap &RHS) const { 134 return Root && RHS.Root ? Root->isEqual(*RHS.Root) : Root == RHS.Root; 137 bool operator!=(const ImmutableMap &RHS) const { 138 return Root && RHS.Root ? Root->isNotEqual(*RHS.Root) : Root != RHS.Root [all...] |
EquivalenceClasses.h | 93 ECValue(const ECValue &RHS) : Leader(this), Next((ECValue*)(intptr_t)1), 94 Data(RHS.Data) { 96 assert(RHS.isLeader() && RHS.getNext() == 0 && "Not a singleton!"); 118 EquivalenceClasses(const EquivalenceClasses &RHS) { 119 operator=(RHS); 122 const EquivalenceClasses &operator=(const EquivalenceClasses &RHS) { 124 for (iterator I = RHS.begin(), E = RHS.end(); I != E; ++I) 126 member_iterator MI = RHS.member_begin(I) [all...] |
PointerIntPair.h | 140 bool operator==(const PointerIntPair &RHS) const {return Value == RHS.Value;} 141 bool operator!=(const PointerIntPair &RHS) const {return Value != RHS.Value;} 142 bool operator<(const PointerIntPair &RHS) const {return Value < RHS.Value;} 143 bool operator>(const PointerIntPair &RHS) const {return Value > RHS.Value;} 144 bool operator<=(const PointerIntPair &RHS) const {return Value <= RHS.Value; [all...] |
OwningPtr.h | 77 void swap(OwningPtr &RHS) { 78 T *Tmp = RHS.Ptr; 79 RHS.Ptr = Ptr; 139 void swap(OwningArrayPtr &RHS) { 140 T *Tmp = RHS.Ptr; 141 RHS.Ptr = Ptr;
|
ImmutableSet.h | 130 bool isElementEqual(const ImutAVLTree* RHS) const { 131 return isElementEqual(RHS->getValue()); 137 bool isEqual(const ImutAVLTree& RHS) const { 138 if (&RHS == this) 142 iterator RItr = RHS.begin(), REnd = RHS.end(); 163 bool isNotEqual(const ImutAVLTree& RHS) const { return !isEqual(RHS); } 889 static inline bool isEqual(key_type_ref LHS, key_type_ref RHS) { 890 return std::equal_to<key_type>()(LHS,RHS); [all...] |
PointerUnion.h | 159 const PointerUnion &operator=(const PT1 &RHS) { 161 const_cast<void *>(PointerLikeTypeTraits<PT1>::getAsVoidPointer(RHS))); 164 const PointerUnion &operator=(const PT2 &RHS) { 166 const_cast<void *>(PointerLikeTypeTraits<PT2>::getAsVoidPointer(RHS)), 180 bool operator==(PointerUnion<PT1, PT2> lhs, PointerUnion<PT1, PT2> rhs) { 181 return lhs.getOpaqueValue() == rhs.getOpaqueValue(); 296 const PointerUnion3 &operator=(const PT1 &RHS) { 297 Val = InnerUnion(RHS); 300 const PointerUnion3 &operator=(const PT2 &RHS) { 301 Val = InnerUnion(RHS); [all...] |
/external/llvm/include/llvm/IR/ |
IRBuilder.h | 553 Value *LHS, Value *RHS, 556 BinaryOperator *BO = Insert(BinaryOperator::Create(Opc, LHS, RHS), Name); 573 Value *CreateAdd(Value *LHS, Value *RHS, const Twine &Name = "", 576 if (Constant *RC = dyn_cast<Constant>(RHS)) 578 return CreateInsertNUWNSWBinOp(Instruction::Add, LHS, RHS, Name, 581 Value *CreateNSWAdd(Value *LHS, Value *RHS, const Twine &Name = "") { 582 return CreateAdd(LHS, RHS, Name, false, true); 584 Value *CreateNUWAdd(Value *LHS, Value *RHS, const Twine &Name = "") { 585 return CreateAdd(LHS, RHS, Name, true, false); 587 Value *CreateFAdd(Value *LHS, Value *RHS, const Twine &Name = "" [all...] |
Use.h | 64 void swap(Use &RHS); 102 Value *operator=(Value *RHS) { 103 set(RHS); 104 return RHS; 106 const Use &operator=(const Use &RHS) { 107 set(RHS.Val);
|
/external/compiler-rt/lib/ubsan/ |
ubsan_handlers.h | 44 RECOVERABLE(add_overflow, OverflowData *Data, ValueHandle LHS, ValueHandle RHS) 47 RECOVERABLE(sub_overflow, OverflowData *Data, ValueHandle LHS, ValueHandle RHS) 50 RECOVERABLE(mul_overflow, OverflowData *Data, ValueHandle LHS, ValueHandle RHS) 57 ValueHandle LHS, ValueHandle RHS) 65 /// \brief Handle a shift where the RHS is out of bounds or a left shift where 68 ValueHandle LHS, ValueHandle RHS)
|
/external/llvm/lib/Support/ |
APInt.cpp | 122 APInt& APInt::AssignSlowCase(const APInt& RHS) { 124 if (this == &RHS) 127 if (BitWidth == RHS.getBitWidth()) { 130 memcpy(pVal, RHS.pVal, getNumWords() * APINT_WORD_SIZE); 136 assert(!RHS.isSingleWord()); 138 pVal = getMemory(RHS.getNumWords()); 139 memcpy(pVal, RHS.pVal, RHS.getNumWords() * APINT_WORD_SIZE); 140 } else if (getNumWords() == RHS.getNumWords()) 141 memcpy(pVal, RHS.pVal, RHS.getNumWords() * APINT_WORD_SIZE) [all...] |
FoldingSet.cpp | 34 bool FoldingSetNodeIDRef::operator==(FoldingSetNodeIDRef RHS) const { 35 if (Size != RHS.Size) return false; 36 return memcmp(Data, RHS.Data, Size*sizeof(*Data)) == 0; 41 bool FoldingSetNodeIDRef::operator<(FoldingSetNodeIDRef RHS) const { 42 if (Size != RHS.Size) 43 return Size < RHS.Size; 44 return memcmp(Data, RHS.Data, Size*sizeof(*Data)) < 0; 151 bool FoldingSetNodeID::operator==(const FoldingSetNodeID &RHS) const { 152 return *this == FoldingSetNodeIDRef(RHS.Bits.data(), RHS.Bits.size()) [all...] |
/external/clang/include/clang/Basic/ |
Builtins.h | 54 bool operator==(const Info &RHS) const { 55 return !strcmp(Name, RHS.Name) && 56 !strcmp(Type, RHS.Type) && 57 !strcmp(Attributes, RHS.Attributes); 59 bool operator!=(const Info &RHS) const { return !(*this == RHS); }
|
/external/llvm/utils/TableGen/ |
DAGISelEmitter.cpp | 73 // PatternSortingPredicate - return true if we prefer to match LHS before RHS. 80 bool operator()(const PatternToMatch *LHS, const PatternToMatch *RHS) { 82 const TreePatternNode *RHSSrc = RHS->getSrcPattern(); 98 unsigned RHSSize = RHS->getPatternComplexity(CGP); 104 unsigned RHSCost = getResultPatternCost(RHS->getDstPattern(), CGP); 109 unsigned RHSPatSize = getResultPatternSize(RHS->getDstPattern(), CGP); 115 assert(LHS == RHS || LHS->ID != RHS->ID); 116 return LHS->ID < RHS->ID;
|
/external/llvm/include/llvm/Target/ |
TargetOptions.h | 198 const TargetOptions &RHS) { 199 #define ARE_EQUAL(X) LHS.X == RHS.X 223 const TargetOptions &RHS) { 224 return !(LHS == RHS);
|
/external/llvm/lib/IR/ |
LLVMContextImpl.h | 64 static bool isEqual(const KeyTy &LHS, const KeyTy &RHS) { 65 return LHS == RHS; 92 static bool isEqual(const KeyTy &LHS, const KeyTy &RHS) { 93 return LHS == RHS; 131 static bool isEqual(const KeyTy& LHS, const StructType *RHS) { 132 if (RHS == getEmptyKey() || RHS == getTombstoneKey()) 134 return LHS == KeyTy(RHS); 136 static bool isEqual(const StructType *LHS, const StructType *RHS) { 137 return LHS == RHS; [all...] |
/external/clang/include/clang/AST/ |
StmtIterator.h | 80 StmtIteratorImpl(const StmtIteratorBase& RHS) : StmtIteratorBase(RHS) {} 104 bool operator==(const DERIVED& RHS) const { 105 return stmt == RHS.stmt && DGI == RHS.DGI && RawVAPtr == RHS.RawVAPtr; 108 bool operator!=(const DERIVED& RHS) const { 109 return stmt != RHS.stmt || DGI != RHS.DGI || RawVAPtr != RHS.RawVAPtr [all...] |
DeclarationName.h | 285 friend bool operator==(DeclarationName LHS, DeclarationName RHS) { 286 return LHS.Ptr == RHS.Ptr; 290 friend bool operator!=(DeclarationName LHS, DeclarationName RHS) { 291 return LHS.Ptr != RHS.Ptr; 302 static int compare(DeclarationName LHS, DeclarationName RHS); 311 inline bool operator<(DeclarationName LHS, DeclarationName RHS) { 312 return DeclarationName::compare(LHS, RHS) < 0; 317 inline bool operator>(DeclarationName LHS, DeclarationName RHS) { 318 return DeclarationName::compare(LHS, RHS) > 0; 323 inline bool operator<=(DeclarationName LHS, DeclarationName RHS) { [all...] |
DeclContextInternals.h | 43 StoredDeclsList(const StoredDeclsList &RHS) : Data(RHS.Data) { 44 if (DeclsTy *RHSVec = RHS.getAsVector()) 54 StoredDeclsList &operator=(const StoredDeclsList &RHS) { 57 Data = RHS.Data; 58 if (DeclsTy *RHSVec = RHS.getAsVector())
|
/external/clang/lib/Lex/ |
PPExpressions.cpp | 476 // If this is a short-circuiting operator, see if the RHS of the operator is 479 // this example, the RHS of the && being dead does not make the rest of the 483 RHSIsLive = false; // RHS of "0 && x" is dead. 485 RHSIsLive = false; // RHS of "1 || x" is dead. 487 RHSIsLive = false; // RHS (x) of "0 ? x : y" is dead. 495 PPValue RHS(LHS.getBitWidth()); 496 // Parse the RHS of the operator. 498 if (EvaluateValue(RHS, PeekTok, DT, RHSIsLive, PP)) return true; 501 // operator immediately to the right of the RHS. 508 << RHS.getRange() [all...] |
/external/llvm/lib/Analysis/ |
InstructionSimplify.cpp | 78 /// isSameCompare - Is V equivalent to the comparison "LHS Pred RHS"? 80 Value *RHS) { 86 if (CPred == Pred && CLHS == LHS && CRHS == RHS) 88 return CPred == CmpInst::getSwappedPredicate(Pred) && CLHS == RHS && 125 /// given by OpcodeToExpand, while "A" corresponds to LHS and "B op' C" to RHS. 128 static Value *ExpandBinOp(unsigned Opcode, Value *LHS, Value *RHS, 140 Value *A = Op0->getOperand(0), *B = Op0->getOperand(1), *C = RHS; 160 if (BinaryOperator *Op1 = dyn_cast<BinaryOperator>(RHS)) 168 // If "L op' R" equals "B op' C" then "L op' R" is just the RHS. 172 return RHS; [all...] |
/external/clang/test/CodeGenCXX/ |
temp-order.cpp | 27 A(const A &RHS) : TT(RHS.TT), P(RHS.P), Truth(RHS.Truth) { RHS.P = 0; } 33 A &operator=(const A &RHS) { 34 TT = RHS.TT; 35 P = RHS.P; 36 Truth = RHS.Truth; 37 RHS.P = 0 [all...] |
/external/llvm/lib/Transforms/InstCombine/ |
InstCombineVectorOps.cpp | 240 EI.getName()+".rhs"); 291 /// elements from either LHS or RHS, return the shuffle mask and true. 293 static bool CollectSingleShuffleElements(Value *V, Value *LHS, Value *RHS, 295 assert(V->getType() == LHS->getType() && V->getType() == RHS->getType() && 310 if (V == RHS) { 330 if (CollectSingleShuffleElements(VecOp, LHS, RHS, Mask)) { 341 // This must be extracting from either LHS or RHS. 342 if (EI->getOperand(0) == LHS || EI->getOperand(0) == RHS) { 345 if (CollectSingleShuffleElements(VecOp, LHS, RHS, Mask)) { 352 assert(EI->getOperand(0) == RHS); [all...] |