| /src/external/apache2/llvm/dist/llvm/lib/IR/ |
| Use.cpp | 16 void Use::swap(Use &RHS) {
17 if (Val == RHS.Val)
20 std::swap(Val, RHS.Val);
21 std::swap(Next, RHS.Next);
22 std::swap(Prev, RHS.Prev);
28 *RHS.Prev = &RHS;
29 if (RHS.Next)
30 RHS.Next->Prev = &RHS.Next
[all...] |
| /src/external/apache2/llvm/dist/llvm/include/llvm/Support/ |
| InstructionCost.h | 42 void propagateState(const InstructionCost &RHS) {
43 if (RHS.State == Invalid)
76 /// invalid, and it also inherits any invalid state from the RHS. Regardless
80 InstructionCost &operator+=(const InstructionCost &RHS) {
81 propagateState(RHS);
82 Value += RHS.Value;
86 InstructionCost &operator+=(const CostType RHS) {
87 InstructionCost RHS2(RHS);
92 InstructionCost &operator-=(const InstructionCost &RHS) {
93 propagateState(RHS);
[all...] |
| BranchProbability.h | 91 BranchProbability &operator+=(BranchProbability RHS) {
92 assert(N != UnknownN && RHS.N != UnknownN &&
95 N = (uint64_t(N) + RHS.N > D) ? D : N + RHS.N;
99 BranchProbability &operator-=(BranchProbability RHS) {
100 assert(N != UnknownN && RHS.N != UnknownN &&
103 N = N < RHS.N ? 0 : N - RHS.N;
107 BranchProbability &operator*=(BranchProbability RHS) {
108 assert(N != UnknownN && RHS.N != UnknownN &
[all...] |
| MemoryBufferRef.h | 41 const MemoryBufferRef &RHS) {
42 return LHS.Buffer.begin() == RHS.Buffer.begin() &&
43 LHS.Buffer.end() == RHS.Buffer.end() &&
44 LHS.Identifier.begin() == RHS.Identifier.begin() &&
45 LHS.Identifier.end() == RHS.Identifier.end();
49 const MemoryBufferRef &RHS) {
50 return !(LHS == RHS);
|
| BlockFrequency.h | 58 bool operator<(BlockFrequency RHS) const {
59 return Frequency < RHS.Frequency;
62 bool operator<=(BlockFrequency RHS) const {
63 return Frequency <= RHS.Frequency;
66 bool operator>(BlockFrequency RHS) const {
67 return Frequency > RHS.Frequency;
70 bool operator>=(BlockFrequency RHS) const {
71 return Frequency >= RHS.Frequency;
74 bool operator==(BlockFrequency RHS) const {
75 return Frequency == RHS.Frequency
[all...] |
| TypeSize.h | 62 friend LeafTy &operator+=(LeafTy &LHS, const LeafTy &RHS) {
64 LHS.Coefficients[I] += RHS.Coefficients[I];
68 friend LeafTy &operator-=(LeafTy &LHS, const LeafTy &RHS) {
70 LHS.Coefficients[I] -= RHS.Coefficients[I];
74 friend LeafTy &operator*=(LeafTy &LHS, ScalarTy RHS) {
76 C *= RHS;
80 friend LeafTy operator+(const LeafTy &LHS, const LeafTy &RHS) {
82 return Copy += RHS;
85 friend LeafTy operator-(const LeafTy &LHS, const LeafTy &RHS) {
87 return Copy -= RHS;
[all...] |
| KnownBits.h | 283 /// Compute known bits common to LHS and RHS.
284 static KnownBits commonBits(const KnownBits &LHS, const KnownBits &RHS) {
285 return KnownBits(LHS.Zero & RHS.Zero, LHS.One & RHS.One);
288 /// Return true if LHS and RHS have no common bits set.
289 static bool haveNoCommonBitsSet(const KnownBits &LHS, const KnownBits &RHS) {
290 return (LHS.Zero | RHS.Zero).isAllOnesValue();
293 /// Compute known bits resulting from adding LHS, RHS and a 1-bit Carry.
295 const KnownBits &LHS, const KnownBits &RHS, const KnownBits &Carry);
297 /// Compute known bits resulting from adding LHS and RHS
[all...] |
| SMTAPI.h | 67 friend bool operator==(SMTSort const &LHS, SMTSort const &RHS) {
68 return LHS.equal_to(RHS);
114 friend bool operator==(SMTExpr const &LHS, SMTExpr const &RHS) {
115 return LHS.equal_to(RHS);
184 virtual SMTExprRef mkBVAdd(const SMTExprRef &LHS, const SMTExprRef &RHS) = 0;
187 virtual SMTExprRef mkBVSub(const SMTExprRef &LHS, const SMTExprRef &RHS) = 0;
190 virtual SMTExprRef mkBVMul(const SMTExprRef &LHS, const SMTExprRef &RHS) = 0;
193 virtual SMTExprRef mkBVSRem(const SMTExprRef &LHS, const SMTExprRef &RHS) = 0;
196 virtual SMTExprRef mkBVURem(const SMTExprRef &LHS, const SMTExprRef &RHS) = 0;
199 virtual SMTExprRef mkBVSDiv(const SMTExprRef &LHS, const SMTExprRef &RHS) = 0
[all...] |
| /src/external/apache2/llvm/dist/llvm/include/llvm/DebugInfo/CodeView/ |
| GUID.h | 25 inline bool operator==(const GUID &LHS, const GUID &RHS) {
26 return 0 == ::memcmp(LHS.Guid, RHS.Guid, sizeof(LHS.Guid));
29 inline bool operator<(const GUID &LHS, const GUID &RHS) {
30 return ::memcmp(LHS.Guid, RHS.Guid, sizeof(LHS.Guid)) < 0;
33 inline bool operator<=(const GUID &LHS, const GUID &RHS) {
34 return ::memcmp(LHS.Guid, RHS.Guid, sizeof(LHS.Guid)) <= 0;
37 inline bool operator>(const GUID &LHS, const GUID &RHS) {
38 return !(LHS <= RHS);
41 inline bool operator>=(const GUID &LHS, const GUID &RHS) {
42 return !(LHS < RHS);
[all...] |
| /src/external/apache2/llvm/dist/llvm/lib/Support/ |
| SmallPtrSet.cpp | 144 void SmallPtrSetImplBase::CopyFrom(const SmallPtrSetImplBase &RHS) {
145 assert(&RHS != this && "Self-copy should be handled by the caller.");
147 if (isSmall() && RHS.isSmall())
148 assert(CurArraySize == RHS.CurArraySize &&
152 if (RHS.isSmall()) {
157 } else if (CurArraySize != RHS.CurArraySize) {
159 CurArray = (const void**)safe_malloc(sizeof(void*) * RHS.CurArraySize);
162 sizeof(void*) * RHS.CurArraySize);
167 CopyHelper(RHS);
170 void SmallPtrSetImplBase::CopyHelper(const SmallPtrSetImplBase &RHS) {
[all...] |
| KnownBits.cpp | 22 const KnownBits &LHS, const KnownBits &RHS,
27 APInt PossibleSumZero = LHS.getMaxValue() + RHS.getMaxValue() + !CarryZero;
28 APInt PossibleSumOne = LHS.getMinValue() + RHS.getMinValue() + CarryOne;
31 APInt CarryKnownZero = ~(PossibleSumZero ^ LHS.Zero ^ RHS.Zero);
32 APInt CarryKnownOne = PossibleSumOne ^ LHS.One ^ RHS.One;
36 APInt RHSKnownUnion = RHS.Zero | RHS.One;
51 const KnownBits &LHS, const KnownBits &RHS, const KnownBits &Carry) {
54 LHS, RHS, Carry.Zero.getBoolValue(), Carry.One.getBoolValue());
58 const KnownBits &LHS, KnownBits RHS) {
[all...] |
| /src/external/apache2/llvm/dist/llvm/include/llvm/Remarks/ |
| Remark.h | 115 bool operator<(const Optional<T> &LHS, const Optional<T> &RHS) {
119 if (!LHS && !RHS)
121 if (!LHS && RHS)
123 if (LHS && !RHS)
125 return *LHS < *RHS;
128 inline bool operator==(const RemarkLocation &LHS, const RemarkLocation &RHS) {
129 return LHS.SourceFilePath == RHS.SourceFilePath &&
130 LHS.SourceLine == RHS.SourceLine &&
131 LHS.SourceColumn == RHS.SourceColumn;
134 inline bool operator!=(const RemarkLocation &LHS, const RemarkLocation &RHS) {
[all...] |
| /src/external/apache2/llvm/dist/clang/include/clang/Basic/ |
| Thunk.h | 62 bool Less(const VirtualAdjustment &RHS) const {
63 return memcmp(this, &RHS, sizeof(RHS)) < 0;
72 const ReturnAdjustment &RHS) {
73 return LHS.NonVirtual == RHS.NonVirtual && LHS.Virtual.Equals(RHS.Virtual);
77 const ReturnAdjustment &RHS) {
78 return !(LHS == RHS);
82 const ReturnAdjustment &RHS) {
83 if (LHS.NonVirtual < RHS.NonVirtual
[all...] |
| /src/external/apache2/llvm/dist/clang/include/clang/Edit/ |
| FileOffset.h | 37 friend bool operator==(FileOffset LHS, FileOffset RHS) {
38 return LHS.FID == RHS.FID && LHS.Offs == RHS.Offs;
41 friend bool operator!=(FileOffset LHS, FileOffset RHS) {
42 return !(LHS == RHS);
45 friend bool operator<(FileOffset LHS, FileOffset RHS) {
46 return std::tie(LHS.FID, LHS.Offs) < std::tie(RHS.FID, RHS.Offs);
49 friend bool operator>(FileOffset LHS, FileOffset RHS) {
50 return RHS < LHS
[all...] |
| /src/external/apache2/llvm/dist/llvm/lib/Analysis/ |
| AliasAnalysisSummary.h | 119 inline bool operator==(InterfaceValue LHS, InterfaceValue RHS) {
120 return LHS.Index == RHS.Index && LHS.DerefLevel == RHS.DerefLevel;
122 inline bool operator!=(InterfaceValue LHS, InterfaceValue RHS) {
123 return !(LHS == RHS);
125 inline bool operator<(InterfaceValue LHS, InterfaceValue RHS) {
126 return LHS.Index < RHS.Index ||
127 (LHS.Index == RHS.Index && LHS.DerefLevel < RHS.DerefLevel);
129 inline bool operator>(InterfaceValue LHS, InterfaceValue RHS) {
[all...] |
| /src/external/apache2/llvm/dist/llvm/include/llvm/TextAPI/ |
| Target.h | 40 inline bool operator==(const Target &LHS, const Target &RHS) {
41 return std::tie(LHS.Arch, LHS.Platform) == std::tie(RHS.Arch, RHS.Platform);
44 inline bool operator!=(const Target &LHS, const Target &RHS) {
45 return std::tie(LHS.Arch, LHS.Platform) != std::tie(RHS.Arch, RHS.Platform);
48 inline bool operator<(const Target &LHS, const Target &RHS) {
49 return std::tie(LHS.Arch, LHS.Platform) < std::tie(RHS.Arch, RHS.Platform);
52 inline bool operator==(const Target &LHS, const Architecture &RHS) {
[all...] |
| /src/external/apache2/llvm/dist/llvm/include/llvm/ADT/ |
| APSInt.h | 63 APSInt &operator=(APInt RHS) {
65 APInt::operator=(std::move(RHS));
69 APSInt &operator=(uint64_t RHS) {
71 APInt::operator=(RHS);
116 const APSInt &operator%=(const APSInt &RHS) {
117 assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
119 *this = urem(RHS);
121 *this = srem(RHS);
124 const APSInt &operator/=(const APSInt &RHS) {
125 assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!")
[all...] |
| /src/external/apache2/llvm/dist/llvm/include/llvm/DebugInfo/GSYM/ |
| LineEntry.h | 36 inline bool operator==(const LineEntry &LHS, const LineEntry &RHS) {
37 return LHS.Addr == RHS.Addr && LHS.File == RHS.File && LHS.Line == RHS.Line;
39 inline bool operator!=(const LineEntry &LHS, const LineEntry &RHS) {
40 return !(LHS == RHS);
42 inline bool operator<(const LineEntry &LHS, const LineEntry &RHS) {
43 return LHS.Addr < RHS.Addr;
|
| LookupResult.h | 30 inline bool operator==(const SourceLocation &LHS, const SourceLocation &RHS) {
31 return LHS.Name == RHS.Name && LHS.Dir == RHS.Dir &&
32 LHS.Base == RHS.Base && LHS.Line == RHS.Line &&
33 LHS.Offset == RHS.Offset;
|
| /src/external/apache2/llvm/dist/clang/lib/Tooling/ |
| NodeIntrospection.cpp | 46 const LocationCall *RHS) {
47 if (!LHS && !RHS)
49 if (LHS && !RHS)
51 if (!LHS && RHS)
53 auto compareResult = LHS->name().compare(RHS->name());
58 return locationCallLessThan(LHS->on(), RHS->on());
63 std::pair<SourceRange, SharedLocationCall> const &RHS) const {
64 if (LHS.first.getBegin() < RHS.first.getBegin())
66 else if (LHS.first.getBegin() != RHS.first.getBegin())
69 if (LHS.first.getEnd() < RHS.first.getEnd()
[all...] |
| /src/external/apache2/llvm/dist/llvm/include/llvm/DebugInfo/DWARF/ |
| DWARFAddressRange.h | 39 /// Returns true if [LowPC, HighPC) intersects with [RHS.LowPC, RHS.HighPC).
40 bool intersects(const DWARFAddressRange &RHS) const {
41 assert(valid() && RHS.valid());
43 if (LowPC == HighPC || RHS.LowPC == RHS.HighPC)
45 return LowPC < RHS.HighPC && RHS.LowPC < HighPC;
54 /// \param RHS Another address range to combine with.
58 bool merge(const DWARFAddressRange &RHS) {
[all...] |
| /src/external/apache2/llvm/dist/clang/lib/Analysis/ |
| ThreadSafetyLogical.cpp | 18 // to keep track of whether LHS and RHS are negated.
19 static bool implies(const LExpr *LHS, bool LNeg, const LExpr *RHS, bool RNeg) {
24 return implies(A->left(), LNeg, RHS, RNeg) &&
25 implies(A->right(), LNeg, RHS, RNeg);
34 return implies(A->left(), LNeg, RHS, RNeg) ||
35 implies(A->right(), LNeg, RHS, RNeg);
43 switch (RHS->kind()) {
49 return RNeg ? RightOrOperator(cast<And>(RHS))
50 : RightAndOperator(cast<And>(RHS));
56 return RNeg ? RightAndOperator(cast<Or>(RHS))
[all...] |
| /src/external/apache2/llvm/dist/clang/include/clang/Sema/ |
| Weak.h | 37 bool operator==(WeakInfo RHS) const {
38 return alias == RHS.getAlias() && loc == RHS.getLocation();
40 bool operator!=(WeakInfo RHS) const { return !(*this == RHS); }
|
| /src/external/apache2/llvm/dist/clang/include/clang/APINotes/ |
| Types.h | 85 CommonEntityInfo &operator|=(const CommonEntityInfo &RHS) {
87 if (RHS.Unavailable) {
90 UnavailableMsg = RHS.UnavailableMsg;
93 if (RHS.UnavailableInSwift) {
96 UnavailableMsg = RHS.UnavailableMsg;
100 setSwiftPrivate(RHS.isSwiftPrivate());
103 SwiftName = RHS.SwiftName;
112 const CommonEntityInfo &RHS) {
113 return LHS.UnavailableMsg == RHS.UnavailableMsg &&
114 LHS.Unavailable == RHS.Unavailable &
[all...] |
| /src/external/apache2/llvm/dist/llvm/include/llvm/IR/ |
| NoFolder.h | 44 Instruction *CreateAdd(Constant *LHS, Constant *RHS,
47 BinaryOperator *BO = BinaryOperator::CreateAdd(LHS, RHS);
53 Instruction *CreateFAdd(Constant *LHS, Constant *RHS) const override {
54 return BinaryOperator::CreateFAdd(LHS, RHS);
57 Instruction *CreateSub(Constant *LHS, Constant *RHS,
60 BinaryOperator *BO = BinaryOperator::CreateSub(LHS, RHS);
66 Instruction *CreateFSub(Constant *LHS, Constant *RHS) const override {
67 return BinaryOperator::CreateFSub(LHS, RHS);
70 Instruction *CreateMul(Constant *LHS, Constant *RHS,
73 BinaryOperator *BO = BinaryOperator::CreateMul(LHS, RHS);
[all...] |
