Lines Matching defs:Second
161 static void swapIterators(T &First, T &FirstEnd, T &Second, T &SecondEnd) {
162 std::swap(First, Second);
178 iterator Second = RHS.begin();
186 // when we do `Second->From() - One` operation.
187 if (Min == First->From() && Min == Second->From()) {
188 if (First->To() > Second->To()) {
190 // [ Second ]----->
192 // The Second range is entirely inside the First one.
194 // Check if Second is the last in its RangeSet.
195 if (++Second == SecondEnd)
197 // [ Second ]--------------------->
204 // [ Second ]--->
206 // The First range is entirely inside or equal to the Second one.
211 // [ Second ]--[ Second + 1 ]---->
213 // The Union is equal to Second's RangeSet.
232 // -----[ Second --->
233 if (First->From() > Second->From())
234 swapIterators(First, FirstEnd, Second, SecondEnd);
238 // ------------[ Second --->
247 // -----[ Second ]--[ Second + 1 ]--[ Second + N ]----->
248 while (First->To() >= Second->To()) {
249 // Check if Second is the last in its RangeSet.
250 if (++Second == SecondEnd) {
253 // -----[ Second ]----->
264 // Check if First and Second are disjoint. It means that we find
267 // ------------=[ Second ]--->
269 if (First->To() < Second->From() - One)
275 // -------[ Second ]----->
281 // --------[ Second ]--->
283 Result.emplace_back(UnionStart, Second->To());
285 // --------------[ Second + 1]--->
286 // Append all remaining ranges from the Second's RangeSet.
287 return AppendTheRest(++Second, SecondEnd);
293 // --------[ Second ]---------->
294 // In both cases First starts after Second->From().
296 swapIterators(First, FirstEnd, Second, SecondEnd);
299 // Here First and Second are disjoint.
302 // -----------------[ Second ]--->
310 // --------------[ Second ]--->
311 // Append all remaining ranges from the Second's RangeSet.
312 return AppendTheRest(Second, SecondEnd);
522 const_iterator First = LHS.begin(), Second = RHS.begin(),
528 while (First != FirstEnd && Second != SecondEnd) {
532 // --------[ Second ----------------->
533 if (Second->From() < First->From())
534 swapIterators(First, FirstEnd, Second, SecondEnd);
541 // ---------------[ Second ]--------->
544 if (Second->From() > First->To()) {
557 // -------[ Second ------------------>
559 // Additionally, it definitely starts with Second->From().
560 const llvm::APSInt &IntersectionStart = Second->From();
565 if (Second->To() > First->To()) {
568 swapIterators(First, FirstEnd, Second, SecondEnd);
574 // ---- Second ]--[ Second+1 ---------->
577 // Second->From and we don't know whether Second+1 intersects
580 // However, we know that [IntersectionStart, Second->To] is
582 Result.push_back(Range(IntersectionStart, Second->To()));
583 ++Second;
584 // ...and that the invariant will hold for a valid Second+1
585 // because First->From <= Second->To < (Second+1)->From.
586 } while (Second != SecondEnd);
924 SymbolRef Second);
951 SymbolRef Second);
954 EquivalenceClass First, EquivalenceClass Second);
966 EquivalenceClass Second);
968 areEqual(ProgramStateRef State, SymbolRef First, SymbolRef Second);
1034 EquivalenceClass First, EquivalenceClass Second);
1109 SecondTy Second, RestTy... Tail);
1149 RangeSet Second, RestTy... Tail) {
1152 return intersect(F, F.intersect(Head, Second), Tail...);
1157 SecondTy Second, RestTy... Tail) {
1158 if (Second) {
1160 return intersect(F, Head, *Second, Tail...);
1191 intersect(RangeSet::Factory &F, HeadTy Head, SecondTy Second,
1194 return intersect(F, *Head, Second, Tail...);
1196 return intersect(F, Second, Tail...);
2326 SymbolRef Second) {
2328 EquivalenceClass SecondClass = find(State, Second);
2508 SymbolRef Second) {
2509 return markDisequal(RF, State, find(State, First), find(State, Second));
2515 EquivalenceClass Second) {
2516 return First.markDisequal(RF, State, Second);
2551 EquivalenceClass Second) {
2558 // 2. Add Second to the set of classes disequal to First.
2561 NewSet = CF.add(NewSet, Second);
2565 // 3. If Second is known to be a constant, we can delete this point
2568 // So, if Second == 10, it means that First != 10.
2570 if (const RangeSet *SecondConstraint = Constraints.lookup(Second))
2598 EquivalenceClass Second) {
2600 if (First == Second)
2606 if (DisequalToFirst.contains(Second))