| /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...] |
