|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
Declarations
include/llvm/Analysis/LazyValueInfo.h 23 class ConstantRange;
include/llvm/Analysis/ScalarEvolutionExpressions.h 34 class ConstantRange;
include/llvm/IR/GlobalValue.h 35 class ConstantRange;
References
include/llvm/ADT/ArrayRef.h 43 using iterator = const T *;
44 using const_iterator = const T *;
50 const T *Data = nullptr;
66 /*implicit*/ ArrayRef(const T &OneElt)
70 /*implicit*/ ArrayRef(const T *data, size_t length)
74 ArrayRef(const T *begin, const T *end)
74 ArrayRef(const T *begin, const T *end)
81 /*implicit*/ ArrayRef(const SmallVectorTemplateCommon<T, U> &Vec)
87 /*implicit*/ ArrayRef(const std::vector<T, A> &Vec)
92 /*implicit*/ constexpr ArrayRef(const std::array<T, N> &Arr)
97 /*implicit*/ constexpr ArrayRef(const T (&Arr)[N]) : Data(Arr), Length(N) {}
100 /*implicit*/ ArrayRef(const std::initializer_list<T> &Vec)
145 const T *data() const { return Data; }
151 const T &front() const {
157 const T &back() const {
163 template <typename Allocator> ArrayRef<T> copy(Allocator &A) {
178 ArrayRef<T> slice(size_t N, size_t M) const {
184 ArrayRef<T> slice(size_t N) const { return slice(N, size() - N); }
187 ArrayRef<T> drop_front(size_t N = 1) const {
193 ArrayRef<T> drop_back(size_t N = 1) const {
200 template <class PredicateT> ArrayRef<T> drop_while(PredicateT Pred) const {
206 template <class PredicateT> ArrayRef<T> drop_until(PredicateT Pred) const {
211 ArrayRef<T> take_front(size_t N = 1) const {
218 ArrayRef<T> take_back(size_t N = 1) const {
226 template <class PredicateT> ArrayRef<T> take_while(PredicateT Pred) const {
232 template <class PredicateT> ArrayRef<T> take_until(PredicateT Pred) const {
239 const T &operator[](size_t Index) const {
249 typename std::enable_if<std::is_same<U, T>::value, ArrayRef<T>>::type &
257 typename std::enable_if<std::is_same<U, T>::value, ArrayRef<T>>::type &
263 std::vector<T> vec() const {
270 operator std::vector<T>() const {
include/llvm/ADT/DenseMap.h 40 struct DenseMapPair : public std::pair<KeyT, ValueT> {
45 ValueT &getSecond() { return std::pair<KeyT, ValueT>::second; }
46 const ValueT &getSecond() const { return std::pair<KeyT, ValueT>::second; }
66 using mapped_type = ValueT;
69 using iterator = DenseMapIterator<KeyT, ValueT, KeyInfoT, BucketT>;
71 DenseMapIterator<KeyT, ValueT, KeyInfoT, BucketT, true>;
123 is_trivially_copyable<ValueT>::value) {
185 ValueT lookup(const_arg_type_t<KeyT> Val) const {
219 InsertIntoBucket(TheBucket, std::move(Key), std::forward<Ts>(Args)...);
237 TheBucket = InsertIntoBucket(TheBucket, Key, std::forward<Ts>(Args)...);
299 ValueT &operator[](const KeyT &Key) {
311 ValueT &operator[](KeyT &&Key) {
380 ::new (&DestBucket->getSecond()) ValueT(std::move(B->getSecond()));
392 const DenseMapBase<OtherBaseT, KeyT, ValueT, KeyInfoT, BucketT> &other) {
516 ValueArgs &&... Values) {
520 ::new (&TheBucket->getSecond()) ValueT(std::forward<ValueArgs>(Values)...);
520 ::new (&TheBucket->getSecond()) ValueT(std::forward<ValueArgs>(Values)...);
526 ValueT &&Value, LookupKeyT &Lookup) {
684 class DenseMap : public DenseMapBase<DenseMap<KeyT, ValueT, KeyInfoT, BucketT>,
685 KeyT, ValueT, KeyInfoT, BucketT> {
690 using BaseT = DenseMapBase<DenseMap, KeyT, ValueT, KeyInfoT, BucketT>;
1163 using ConstIterator = DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, true>;
1199 const DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, IsConstSrc> &I)
include/llvm/ADT/MapVector.h 83 std::pair<KeyT, ValueT> &front() { return Vector.front(); }
84 const std::pair<KeyT, ValueT> &front() const { return Vector.front(); }
85 std::pair<KeyT, ValueT> &back() { return Vector.back(); }
86 const std::pair<KeyT, ValueT> &back() const { return Vector.back(); }
98 ValueT &operator[](const KeyT &Key) {
110 ValueT lookup(const KeyT &Key) const {
117 std::pair<iterator, bool> insert(const std::pair<KeyT, ValueT> &KV) {
129 std::pair<iterator, bool> insert(std::pair<KeyT, ValueT> &&KV) {
include/llvm/ADT/Optional.h 39 T value;
60 explicit OptionalStorage(in_place_t, Args &&... args)
61 : value(std::forward<Args>(args)...), hasVal(true) {}
72 T &getValue() LLVM_LVALUE_FUNCTION noexcept {
76 T const &getValue() const LLVM_LVALUE_FUNCTION noexcept {
81 T &&getValue() && noexcept {
87 template <class... Args> void emplace(Args &&... args) {
89 ::new ((void *)std::addressof(value)) T(std::forward<Args>(args)...);
89 ::new ((void *)std::addressof(value)) T(std::forward<Args>(args)...);
216 optional_detail::OptionalStorage<T> Storage;
219 using value_type = T;
224 Optional(const T &y) : Storage(optional_detail::in_place_t{}, y) {}
227 Optional(T &&y) : Storage(optional_detail::in_place_t{}, std::move(y)) {}
230 Optional &operator=(T &&y) {
241 static inline Optional create(const T *y) {
245 Optional &operator=(const T &y) {
253 const T *getPointer() const { return &Storage.getValue(); }
254 T *getPointer() { return &Storage.getValue(); }
255 const T &getValue() const LLVM_LVALUE_FUNCTION { return Storage.getValue(); }
256 T &getValue() LLVM_LVALUE_FUNCTION { return Storage.getValue(); }
260 const T *operator->() const { return getPointer(); }
261 T *operator->() { return getPointer(); }
262 const T &operator*() const LLVM_LVALUE_FUNCTION { return getValue(); }
263 T &operator*() LLVM_LVALUE_FUNCTION { return getValue(); }
266 constexpr T getValueOr(U &&value) const LLVM_LVALUE_FUNCTION {
271 T &&getValue() && { return std::move(Storage.getValue()); }
272 T &&operator*() && { return std::move(Storage.getValue()); }
275 T getValueOr(U &&value) && {
include/llvm/ADT/SmallVector.h 75 AlignedCharArrayUnion<T> FirstEl;
114 using value_type = T;
115 using iterator = T *;
116 using const_iterator = const T *;
121 using reference = T &;
122 using const_reference = const T &;
123 using pointer = T *;
124 using const_pointer = const T *;
179 class SmallVectorTemplateBase : public SmallVectorTemplateCommon<T> {
183 static void destroy_range(T *S, T *E) {
183 static void destroy_range(T *S, T *E) {
211 void push_back(const T &Elt) {
214 ::new ((void*) this->end()) T(Elt);
218 void push_back(T &&Elt) {
221 ::new ((void*) this->end()) T(::std::move(Elt));
240 T *NewElts = static_cast<T*>(llvm::safe_malloc(NewCapacity*sizeof(T)));
240 T *NewElts = static_cast<T*>(llvm::safe_malloc(NewCapacity*sizeof(T)));
315 class SmallVectorImpl : public SmallVectorTemplateBase<T> {
316 using SuperClass = SmallVectorTemplateBase<T>;
357 void resize(size_type N, const T &NV) {
374 LLVM_NODISCARD T pop_back_val() {
397 void append(size_type NumInputs, const T &Elt) {
405 void append(std::initializer_list<T> IL) {
412 void assign(size_type NumElts, const T &Elt) {
429 void assign(std::initializer_list<T> IL) {
467 iterator insert(iterator I, T &&Elt) {
497 iterator insert(iterator I, const T &Elt) {
526 iterator insert(iterator I, size_type NumToInsert, const T &Elt) {
637 void insert(iterator I, std::initializer_list<T> IL) {
641 template <typename... ArgTypes> reference emplace_back(ArgTypes &&... Args) {
644 ::new ((void *)this->end()) T(std::forward<ArgTypes>(Args)...);
820 AlignedCharArrayUnion<T> InlineElts[N];
837 class SmallVector : public SmallVectorImpl<T>, SmallVectorStorage<T, N> {
837 class SmallVector : public SmallVectorImpl<T>, SmallVectorStorage<T, N> {
846 explicit SmallVector(size_t Size, const T &Value = T())
865 SmallVector(std::initializer_list<T> IL) : SmallVectorImpl<T>(N) {
884 SmallVector(SmallVectorImpl<T> &&RHS) : SmallVectorImpl<T>(N) {
include/llvm/Analysis/LazyValueInfo.h 88 ConstantRange getConstantRange(Value *V, BasicBlock *BB, Instruction *CxtI = nullptr);
98 ConstantRange getConstantRangeOnEdge(Value *V, BasicBlock *FromBB,
include/llvm/Analysis/ScalarEvolution.h 817 ConstantRange getUnsignedRange(const SCEV *S) {
833 ConstantRange getSignedRange(const SCEV *S) {
1421 DenseMap<const SCEV *, ConstantRange> UnsignedRanges;
1424 DenseMap<const SCEV *, ConstantRange> SignedRanges;
1430 const ConstantRange &setRange(const SCEV *S, RangeSignHint Hint,
1431 ConstantRange CR) {
1432 DenseMap<const SCEV *, ConstantRange> &Cache =
1444 const ConstantRange &getRangeRef(const SCEV *S, RangeSignHint Hint);
1448 ConstantRange getRangeForAffineAR(const SCEV *Start, const SCEV *Stop,
1454 ConstantRange getRangeViaFactoring(const SCEV *Start, const SCEV *Stop,
include/llvm/Analysis/ScalarEvolutionExpressions.h 354 const SCEV *getNumIterationsInRange(const ConstantRange &Range,
include/llvm/Analysis/ValueLattice.h 58 ConstantRange Range;
103 new (&Range) ConstantRange(Other.Range);
131 static ValueLatticeElement getRange(ConstantRange CR) {
158 const ConstantRange &getConstantRange() const {
218 void markConstantRange(ConstantRange NewR) {
233 new (&Range) ConstantRange(std::move(NewR));
274 ConstantRange NewR = getConstantRange().unionWith(RHS.getConstantRange());
306 const auto &CR = getConstantRange();
307 const auto &OtherCR = Other.getConstantRange();
308 if (ConstantRange::makeSatisfyingICmpRegion(Pred, OtherCR).contains(CR))
310 if (ConstantRange::makeSatisfyingICmpRegion(
include/llvm/Analysis/ValueTracking.h 503 ConstantRange computeConstantRange(const Value *V, bool UseInstrInfo = true);
include/llvm/IR/ConstantRange.h 51 ConstantRange getEmpty() const {
56 ConstantRange getFull() const {
73 static ConstantRange getEmpty(uint32_t BitWidth) {
78 static ConstantRange getFull(uint32_t BitWidth) {
84 static ConstantRange getNonEmpty(APInt Lower, APInt Upper) {
93 static ConstantRange fromKnownBits(const KnownBits &Known, bool IsSigned);
103 static ConstantRange makeAllowedICmpRegion(CmpInst::Predicate Pred,
104 const ConstantRange &Other);
114 static ConstantRange makeSatisfyingICmpRegion(CmpInst::Predicate Pred,
115 const ConstantRange &Other);
124 static ConstantRange makeExactICmpRegion(CmpInst::Predicate Pred,
143 static ConstantRange makeGuaranteedNoWrapRegion(Instruction::BinaryOps BinOp,
144 const ConstantRange &Other,
149 static ConstantRange makeExactNoWrapRegion(Instruction::BinaryOps BinOp,
204 bool contains(const ConstantRange &CR) const;
225 bool isSizeStrictlySmallerThan(const ConstantRange &CR) const;
249 bool operator==(const ConstantRange &CR) const {
252 bool operator!=(const ConstantRange &CR) const {
257 ConstantRange subtract(const APInt &CI) const;
261 ConstantRange difference(const ConstantRange &CR) const;
261 ConstantRange difference(const ConstantRange &CR) const;
277 ConstantRange intersectWith(const ConstantRange &CR,
277 ConstantRange intersectWith(const ConstantRange &CR,
285 ConstantRange unionWith(const ConstantRange &CR,
285 ConstantRange unionWith(const ConstantRange &CR,
294 ConstantRange castOp(Instruction::CastOps CastOp,
301 ConstantRange zeroExtend(uint32_t BitWidth) const;
307 ConstantRange signExtend(uint32_t BitWidth) const;
313 ConstantRange truncate(uint32_t BitWidth) const;
317 ConstantRange zextOrTrunc(uint32_t BitWidth) const;
321 ConstantRange sextOrTrunc(uint32_t BitWidth) const;
326 ConstantRange binaryOp(Instruction::BinaryOps BinOp,
327 const ConstantRange &Other) const;
333 ConstantRange overflowingBinaryOp(Instruction::BinaryOps BinOp,
334 const ConstantRange &Other,
339 ConstantRange add(const ConstantRange &Other) const;
339 ConstantRange add(const ConstantRange &Other) const;
346 ConstantRange addWithNoWrap(const ConstantRange &Other, unsigned NoWrapKind,
346 ConstantRange addWithNoWrap(const ConstantRange &Other, unsigned NoWrapKind,
351 ConstantRange sub(const ConstantRange &Other) const;
351 ConstantRange sub(const ConstantRange &Other) const;
356 ConstantRange multiply(const ConstantRange &Other) const;
356 ConstantRange multiply(const ConstantRange &Other) const;
360 ConstantRange smax(const ConstantRange &Other) const;
360 ConstantRange smax(const ConstantRange &Other) const;
364 ConstantRange umax(const ConstantRange &Other) const;
364 ConstantRange umax(const ConstantRange &Other) const;
368 ConstantRange smin(const ConstantRange &Other) const;
368 ConstantRange smin(const ConstantRange &Other) const;
372 ConstantRange umin(const ConstantRange &Other) const;
372 ConstantRange umin(const ConstantRange &Other) const;
377 ConstantRange udiv(const ConstantRange &Other) const;
377 ConstantRange udiv(const ConstantRange &Other) const;
384 ConstantRange sdiv(const ConstantRange &Other) const;
384 ConstantRange sdiv(const ConstantRange &Other) const;
389 ConstantRange urem(const ConstantRange &Other) const;
389 ConstantRange urem(const ConstantRange &Other) const;
394 ConstantRange srem(const ConstantRange &Other) const;
394 ConstantRange srem(const ConstantRange &Other) const;
398 ConstantRange binaryAnd(const ConstantRange &Other) const;
398 ConstantRange binaryAnd(const ConstantRange &Other) const;
402 ConstantRange binaryOr(const ConstantRange &Other) const;
402 ConstantRange binaryOr(const ConstantRange &Other) const;
407 ConstantRange shl(const ConstantRange &Other) const;
407 ConstantRange shl(const ConstantRange &Other) const;
411 ConstantRange lshr(const ConstantRange &Other) const;
411 ConstantRange lshr(const ConstantRange &Other) const;
415 ConstantRange ashr(const ConstantRange &Other) const;
415 ConstantRange ashr(const ConstantRange &Other) const;
418 ConstantRange uadd_sat(const ConstantRange &Other) const;
418 ConstantRange uadd_sat(const ConstantRange &Other) const;
421 ConstantRange sadd_sat(const ConstantRange &Other) const;
421 ConstantRange sadd_sat(const ConstantRange &Other) const;
424 ConstantRange usub_sat(const ConstantRange &Other) const;
424 ConstantRange usub_sat(const ConstantRange &Other) const;
427 ConstantRange ssub_sat(const ConstantRange &Other) const;
427 ConstantRange ssub_sat(const ConstantRange &Other) const;
430 ConstantRange inverse() const;
434 ConstantRange abs() const;
450 OverflowResult unsignedAddMayOverflow(const ConstantRange &Other) const;
453 OverflowResult signedAddMayOverflow(const ConstantRange &Other) const;
456 OverflowResult unsignedSubMayOverflow(const ConstantRange &Other) const;
459 OverflowResult signedSubMayOverflow(const ConstantRange &Other) const;
462 OverflowResult unsignedMulMayOverflow(const ConstantRange &Other) const;
471 inline raw_ostream &operator<<(raw_ostream &OS, const ConstantRange &CR) {
479 ConstantRange getConstantRangeFromMetadata(const MDNode &RangeMD);
include/llvm/IR/GlobalValue.h 565 Optional<ConstantRange> getAbsoluteSymbolRange() const;
include/llvm/Support/AlignOf.h 30 T t;
39 template <typename T> union SizerImpl<T> { char arr[sizeof(T)]; };
50 llvm::detail::SizerImpl<T, Ts...>)];
include/llvm/Support/type_traits.h 91 T t;
122 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<const F &>(), std::true_type{});
122 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<const F &>(), std::true_type{});
122 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<const F &>(), std::true_type{});
130 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});
130 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});
130 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});
145 std::is_copy_constructible<detail::trivial_helper<T>>::value;
147 !std::is_copy_constructible<T>::value;
151 std::is_move_constructible<detail::trivial_helper<T>>::value;
153 !std::is_move_constructible<T>::value;
157 is_copy_assignable<detail::trivial_helper<T>>::value;
159 !is_copy_assignable<T>::value;
163 is_move_assignable<detail::trivial_helper<T>>::value;
165 !is_move_assignable<T>::value;
169 std::is_destructible<detail::trivial_helper<T>>::value;
include/llvm/Transforms/Scalar/Float2Int.h 35 void seen(Instruction *I, ConstantRange R);
36 ConstantRange badRange();
37 ConstantRange unknownRange();
38 ConstantRange validateRange(ConstantRange R);
38 ConstantRange validateRange(ConstantRange R);
45 MapVector<Instruction *, ConstantRange> SeenInsts;
lib/Analysis/InstructionSimplify.cpp 1547 auto Range0 = ConstantRange::makeExactICmpRegion(Cmp0->getPredicate(), *C0);
1547 auto Range0 = ConstantRange::makeExactICmpRegion(Cmp0->getPredicate(), *C0);
1548 auto Range1 = ConstantRange::makeExactICmpRegion(Cmp1->getPredicate(), *C1);
1548 auto Range1 = ConstantRange::makeExactICmpRegion(Cmp1->getPredicate(), *C1);
2644 ConstantRange RHS_CR = ConstantRange::makeExactICmpRegion(Pred, *C);
2644 ConstantRange RHS_CR = ConstantRange::makeExactICmpRegion(Pred, *C);
2650 ConstantRange LHS_CR = computeConstantRange(LHS, IIQ.UseInstrInfo);
3227 auto RHS_CR = getConstantRangeFromMetadata(
3229 auto LHS_CR = getConstantRangeFromMetadata(
3232 auto Satisfied_CR = ConstantRange::makeSatisfyingICmpRegion(Pred, RHS_CR);
3232 auto Satisfied_CR = ConstantRange::makeSatisfyingICmpRegion(Pred, RHS_CR);
3236 auto InversedSatisfied_CR = ConstantRange::makeSatisfyingICmpRegion(
3236 auto InversedSatisfied_CR = ConstantRange::makeSatisfyingICmpRegion(
lib/Analysis/LazyValueInfo.cpp 119 ConstantRange Range =
423 Optional<ConstantRange> getRangeForOperand(unsigned Op, Instruction *I,
427 std::function<ConstantRange(const ConstantRange &,
427 std::function<ConstantRange(const ConstantRange &,
428 const ConstantRange &)> OpFn);
887 const ConstantRange &TrueCR = TrueVal.getConstantRange();
888 const ConstantRange &FalseCR = FalseVal.getConstantRange();
896 ConstantRange ResultCR = [&]() {
926 ConstantRange Zero(APInt::getNullValue(TrueCR.getBitWidth()));
996 Optional<ConstantRange> LazyValueInfoImpl::getRangeForOperand(unsigned Op,
1005 ConstantRange Range = ConstantRange::getFull(OperandBitWidth);
1005 ConstantRange Range = ConstantRange::getFull(OperandBitWidth);
1045 Optional<ConstantRange> LHSRes = getRangeForOperand(0, CI, BB);
1049 ConstantRange LHSRange = LHSRes.getValue();
1063 std::function<ConstantRange(const ConstantRange &,
1063 std::function<ConstantRange(const ConstantRange &,
1064 const ConstantRange &)> OpFn) {
1069 Optional<ConstantRange> LHSRes = getRangeForOperand(0, I, BB);
1070 Optional<ConstantRange> RHSRes = getRangeForOperand(1, I, BB);
1075 ConstantRange LHSRange = LHSRes.getValue();
1076 ConstantRange RHSRange = RHSRes.getValue();
1230 ConstantRange RHSRange(RHS->getType()->getIntegerBitWidth(),
1241 ConstantRange TrueValues =
1242 ConstantRange::makeAllowedICmpRegion(Pred, RHSRange);
1265 ConstantRange NWR = ConstantRange::makeExactNoWrapRegion(
1265 ConstantRange NWR = ConstantRange::makeExactNoWrapRegion(
1469 ConstantRange EdgesVals(BitWidth, DefaultCase/*isFullSet*/);
1473 ConstantRange EdgeVal(CaseValue);
1707 const ConstantRange &CR = Result.getConstantRange();
1714 ConstantRange LazyValueInfo::getConstantRange(Value *V, BasicBlock *BB,
1722 return ConstantRange::getEmpty(Width);
1729 return ConstantRange::getFull(Width);
1744 const ConstantRange &CR = Result.getConstantRange();
1751 ConstantRange LazyValueInfo::getConstantRangeOnEdge(Value *V,
1761 return ConstantRange::getEmpty(Width);
1768 return ConstantRange::getFull(Width);
1787 const ConstantRange &CR = Val.getConstantRange();
1802 ConstantRange TrueValues = ConstantRange::makeExactICmpRegion(
1802 ConstantRange TrueValues = ConstantRange::makeExactICmpRegion(
lib/Analysis/ScalarEvolution.cpp 1675 ConstantRange CR = getUnsignedRange(X);
1986 ConstantRange CR = getSignedRange(X);
2383 auto NSWRegion = ConstantRange::makeGuaranteedNoWrapRegion(
2383 auto NSWRegion = ConstantRange::makeGuaranteedNoWrapRegion(
2391 auto NUWRegion = ConstantRange::makeGuaranteedNoWrapRegion(
2391 auto NUWRegion = ConstantRange::makeGuaranteedNoWrapRegion(
4443 ConstantRange AddRecRange = getSignedRange(AR);
4444 ConstantRange IncRange = getSignedRange(AR->getStepRecurrence(*this));
4446 auto NSWRegion = ConstantRange::makeGuaranteedNoWrapRegion(
4446 auto NSWRegion = ConstantRange::makeGuaranteedNoWrapRegion(
4453 ConstantRange AddRecRange = getUnsignedRange(AR);
4454 ConstantRange IncRange = getUnsignedRange(AR->getStepRecurrence(*this));
4456 auto NUWRegion = ConstantRange::makeGuaranteedNoWrapRegion(
4456 auto NUWRegion = ConstantRange::makeGuaranteedNoWrapRegion(
5525 static Optional<ConstantRange> GetRangeFromMetadata(Value *V) {
5536 const ConstantRange &
5539 DenseMap<const SCEV *, ConstantRange> &Cache =
5542 ConstantRange::PreferredRangeType RangeType =
5544 ? ConstantRange::Unsigned : ConstantRange::Signed;
5544 ? ConstantRange::Unsigned : ConstantRange::Signed;
5547 DenseMap<const SCEV *, ConstantRange>::iterator I = Cache.find(S);
5555 ConstantRange ConservativeResult(BitWidth, /*isFullSet=*/true);
5572 ConstantRange X = getRangeRef(Add->getOperand(0), SignHint);
5580 ConstantRange X = getRangeRef(Mul->getOperand(0), SignHint);
5588 ConstantRange X = getRangeRef(SMax->getOperand(0), SignHint);
5596 ConstantRange X = getRangeRef(UMax->getOperand(0), SignHint);
5604 ConstantRange X = getRangeRef(SMin->getOperand(0), SignHint);
5612 ConstantRange X = getRangeRef(UMin->getOperand(0), SignHint);
5620 ConstantRange X = getRangeRef(UDiv->getLHS(), SignHint);
5621 ConstantRange Y = getRangeRef(UDiv->getRHS(), SignHint);
5627 ConstantRange X = getRangeRef(ZExt->getOperand(), SignHint);
5634 ConstantRange X = getRangeRef(SExt->getOperand(), SignHint);
5641 ConstantRange X = getRangeRef(Trunc->getOperand(), SignHint);
5680 auto RangeFromAffine = getRangeForAffineAR(
5687 auto RangeFromFactoring = getRangeViaFactoring(
5701 Optional<ConstantRange> MDRange = GetRangeFromMetadata(U->getValue());
5732 ConstantRange RangeFromOps(BitWidth, /*isFullSet=*/false);
5734 auto OpRange = getRangeRef(getSCEV(Op), SignHint);
5758 static ConstantRange getRangeForAffineARHelper(APInt Step,
5759 const ConstantRange &StartRange,
5771 return ConstantRange::getFull(BitWidth);
5787 return ConstantRange::getFull(BitWidth);
5806 return ConstantRange::getFull(BitWidth);
5815 return ConstantRange::getNonEmpty(std::move(NewLower), std::move(NewUpper));
5818 ConstantRange ScalarEvolution::getRangeForAffineAR(const SCEV *Start,
5830 ConstantRange StartSRange = getSignedRange(Start);
5831 ConstantRange StepSRange = getSignedRange(Step);
5835 ConstantRange SR =
5843 ConstantRange UR = getRangeForAffineARHelper(
5848 return SR.intersectWith(UR, ConstantRange::Smallest);
5851 ConstantRange ScalarEvolution::getRangeViaFactoring(const SCEV *Start,
5932 return ConstantRange::getFull(BitWidth);
5936 return ConstantRange::getFull(BitWidth);
5942 return ConstantRange::getFull(BitWidth);
5958 ConstantRange TrueRange =
5960 ConstantRange FalseRange =
7402 ConstantRange CompRange =
7403 ConstantRange::makeExactICmpRegion(Pred, RHSC->getAPInt());
8575 const ConstantRange &Range, ScalarEvolution &SE) {
8799 ConstantRange CR = getUnsignedRange(DistancePlusOne);
8946 ConstantRange ExactCR = ConstantRange::makeExactICmpRegion(Pred, RA);
8946 ConstantRange ExactCR = ConstantRange::makeExactICmpRegion(Pred, RA);
9332 return ConstantRange::makeSatisfyingICmpRegion(Pred, RangeRHS)
10463 ConstantRange FoundLHSRange =
10464 ConstantRange::makeAllowedICmpRegion(Pred, ConstFoundRHS);
10467 ConstantRange LHSRange = FoundLHSRange.add(ConstantRange(*Addend));
10472 ConstantRange SatisfyingLHSRange =
10473 ConstantRange::makeSatisfyingICmpRegion(Pred, ConstRHS);
10796 const SCEV *SCEVAddRecExpr::getNumIterationsInRange(const ConstantRange &Range,
lib/Analysis/StackSafetyAnalysis.cpp 66 ConstantRange Offset;
67 PassAsArgInfo(const GlobalValue *Callee, size_t ParamNo, ConstantRange Offset)
82 ConstantRange Range;
89 void updateRange(ConstantRange R) { Range = Range.unionWith(R); }
208 const ConstantRange UnknownRange;
210 ConstantRange offsetFromAlloca(Value *Addr, const Value *AllocaPtr);
211 ConstantRange getAccessRange(Value *Addr, const Value *AllocaPtr,
213 ConstantRange getMemIntrinsicAccessRange(const MemIntrinsic *MI, const Use &U,
218 ConstantRange getRange(uint64_t Lower, uint64_t Upper) const {
232 ConstantRange
240 ConstantRange Offset = SE.getUnsignedRange(Expr).zextOrTrunc(PointerSize);
245 ConstantRange StackSafetyLocalAnalysis::getAccessRange(Value *Addr,
254 ConstantRange AccessStartRange =
256 ConstantRange SizeRange = getRange(0, AccessSize);
257 ConstantRange AccessRange = AccessStartRange.add(SizeRange);
262 ConstantRange StackSafetyLocalAnalysis::getMemIntrinsicAccessRange(
275 ConstantRange AccessRange = getAccessRange(U, AllocaPtr, Len->getZExtValue());
348 ConstantRange Offset = offsetFromAlloca(UI, Ptr);
403 const ConstantRange UnknownRange;
405 ConstantRange getArgumentAccessRange(const GlobalValue *Callee,
442 ConstantRange
466 ConstantRange CalleeRange = getArgumentAccessRange(CS.Callee, CS.ParamNo);
lib/Analysis/ValueTracking.cpp 452 ConstantRange Range(Lower->getValue(), Upper->getValue());
1987 ConstantRange Range(Lower->getValue(), Upper->getValue());
3983 static OverflowResult mapOverflowResult(ConstantRange::OverflowResult OR) {
3985 case ConstantRange::OverflowResult::MayOverflow:
3987 case ConstantRange::OverflowResult::AlwaysOverflowsLow:
3989 case ConstantRange::OverflowResult::AlwaysOverflowsHigh:
3991 case ConstantRange::OverflowResult::NeverOverflows:
3998 static ConstantRange computeConstantRangeIncludingKnownBits(
4004 ConstantRange CR1 = ConstantRange::fromKnownBits(Known, ForSigned);
4004 ConstantRange CR1 = ConstantRange::fromKnownBits(Known, ForSigned);
4005 ConstantRange CR2 = computeConstantRange(V, UseInstrInfo);
4006 ConstantRange::PreferredRangeType RangeType =
4007 ForSigned ? ConstantRange::Signed : ConstantRange::Unsigned;
4007 ForSigned ? ConstantRange::Signed : ConstantRange::Unsigned;
4019 ConstantRange LHSRange = ConstantRange::fromKnownBits(LHSKnown, false);
4019 ConstantRange LHSRange = ConstantRange::fromKnownBits(LHSKnown, false);
4020 ConstantRange RHSRange = ConstantRange::fromKnownBits(RHSKnown, false);
4020 ConstantRange RHSRange = ConstantRange::fromKnownBits(RHSKnown, false);
4071 ConstantRange LHSRange = computeConstantRangeIncludingKnownBits(
4074 ConstantRange RHSRange = computeConstantRangeIncludingKnownBits(
4109 ConstantRange LHSRange = computeConstantRangeIncludingKnownBits(
4111 ConstantRange RHSRange = computeConstantRangeIncludingKnownBits(
4149 ConstantRange LHSRange = computeConstantRangeIncludingKnownBits(
4151 ConstantRange RHSRange = computeConstantRangeIncludingKnownBits(
4168 ConstantRange LHSRange = computeConstantRangeIncludingKnownBits(
4170 ConstantRange RHSRange = computeConstantRangeIncludingKnownBits(
5255 ConstantRange DomCR =
5256 ConstantRange::makeExactICmpRegion(APred, C1->getValue());
5257 ConstantRange CR =
5258 ConstantRange::makeAllowedICmpRegion(BPred, C2->getValue());
5259 ConstantRange Intersection = DomCR.intersectWith(CR);
5260 ConstantRange Difference = DomCR.difference(CR);
5687 ConstantRange llvm::computeConstantRange(const Value *V, bool UseInstrInfo) {
5705 ConstantRange CR = ConstantRange::getNonEmpty(Lower, Upper);
5705 ConstantRange CR = ConstantRange::getNonEmpty(Lower, Upper);
lib/CodeGen/SafeStack.cpp 236 ConstantRange AccessStartRange = SE.getUnsignedRange(Expr);
237 ConstantRange SizeRange =
239 ConstantRange AccessRange = AccessStartRange.add(SizeRange);
240 ConstantRange AllocaRange =
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp 8583 ConstantRange CR = getConstantRangeFromMetadata(*Range);
lib/IR/ConstantRange.cpp 57 ConstantRange ConstantRange::fromKnownBits(const KnownBits &Known,
77 ConstantRange ConstantRange::makeAllowedICmpRegion(CmpInst::Predicate Pred,
78 const ConstantRange &CR) {
127 ConstantRange ConstantRange::makeSatisfyingICmpRegion(CmpInst::Predicate Pred,
128 const ConstantRange &CR) {
137 ConstantRange ConstantRange::makeExactICmpRegion(CmpInst::Predicate Pred,
184 static ConstantRange makeExactMulNUWRegion(const APInt &V) {
187 return ConstantRange::getFull(V.getBitWidth());
189 return ConstantRange::getNonEmpty(
197 static ConstantRange makeExactMulNSWRegion(const APInt &V) {
202 return ConstantRange::getFull(BitWidth);
224 ConstantRange
226 const ConstantRange &Other,
276 ConstantRange ShAmt = Other.intersectWith(
296 ConstantRange ConstantRange::makeExactNoWrapRegion(Instruction::BinaryOps BinOp,
329 ConstantRange::isSizeStrictlySmallerThan(const ConstantRange &Other) const {
397 bool ConstantRange::contains(const ConstantRange &Other) const {
415 ConstantRange ConstantRange::subtract(const APInt &Val) const {
423 ConstantRange ConstantRange::difference(const ConstantRange &CR) const {
423 ConstantRange ConstantRange::difference(const ConstantRange &CR) const {
427 static ConstantRange getPreferredRange(
428 const ConstantRange &CR1, const ConstantRange &CR2,
428 const ConstantRange &CR1, const ConstantRange &CR2,
429 ConstantRange::PreferredRangeType Type) {
430 if (Type == ConstantRange::Unsigned) {
435 } else if (Type == ConstantRange::Signed) {
447 ConstantRange ConstantRange::intersectWith(const ConstantRange &CR,
447 ConstantRange ConstantRange::intersectWith(const ConstantRange &CR,
553 ConstantRange ConstantRange::unionWith(const ConstantRange &CR,
553 ConstantRange ConstantRange::unionWith(const ConstantRange &CR,
626 ConstantRange ConstantRange::castOp(Instruction::CastOps CastOp,
669 ConstantRange ConstantRange::zeroExtend(uint32_t DstTySize) const {
686 ConstantRange ConstantRange::signExtend(uint32_t DstTySize) const {
704 ConstantRange ConstantRange::truncate(uint32_t DstTySize) const {
712 ConstantRange Union(DstTySize, /*isFullSet=*/false);
758 ConstantRange ConstantRange::zextOrTrunc(uint32_t DstTySize) const {
767 ConstantRange ConstantRange::sextOrTrunc(uint32_t DstTySize) const {
776 ConstantRange ConstantRange::binaryOp(Instruction::BinaryOps BinOp,
777 const ConstantRange &Other) const {
819 ConstantRange ConstantRange::overflowingBinaryOp(Instruction::BinaryOps BinOp,
820 const ConstantRange &Other,
834 ConstantRange
835 ConstantRange::add(const ConstantRange &Other) const {
846 ConstantRange X = ConstantRange(std::move(NewLower), std::move(NewUpper));
854 ConstantRange ConstantRange::addWithNoWrap(const ConstantRange &Other,
854 ConstantRange ConstantRange::addWithNoWrap(const ConstantRange &Other,
865 ConstantRange Result = add(Other);
905 ConstantRange
906 ConstantRange::sub(const ConstantRange &Other) const {
917 ConstantRange X = ConstantRange(std::move(NewLower), std::move(NewUpper));
925 ConstantRange
926 ConstantRange::multiply(const ConstantRange &Other) const {
947 ConstantRange Result_zext = ConstantRange(this_min * Other_min,
949 ConstantRange UR = Result_zext.truncate(getBitWidth());
973 ConstantRange Result_sext(std::min(L, Compare), std::max(L, Compare) + 1);
974 ConstantRange SR = Result_sext.truncate(getBitWidth());
979 ConstantRange
980 ConstantRange::smax(const ConstantRange &Other) const {
990 ConstantRange
991 ConstantRange::umax(const ConstantRange &Other) const {
1001 ConstantRange
1002 ConstantRange::smin(const ConstantRange &Other) const {
1012 ConstantRange
1013 ConstantRange::umin(const ConstantRange &Other) const {
1023 ConstantRange
1024 ConstantRange::udiv(const ConstantRange &RHS) const {
1044 ConstantRange ConstantRange::sdiv(const ConstantRange &RHS) const {
1044 ConstantRange ConstantRange::sdiv(const ConstantRange &RHS) const {
1050 ConstantRange PosFilter(APInt(getBitWidth(), 1), SignedMin);
1051 ConstantRange NegFilter(SignedMin, Zero);
1052 ConstantRange PosL = intersectWith(PosFilter);
1053 ConstantRange NegL = intersectWith(NegFilter);
1054 ConstantRange PosR = RHS.intersectWith(PosFilter);
1055 ConstantRange NegR = RHS.intersectWith(NegFilter);
1057 ConstantRange PosRes = getEmpty();
1108 ConstantRange NegRes = getEmpty();
1121 ConstantRange Res = NegRes.unionWith(PosRes, PreferredRangeType::Signed);
1129 ConstantRange ConstantRange::urem(const ConstantRange &RHS) const {
1129 ConstantRange ConstantRange::urem(const ConstantRange &RHS) const {
1142 ConstantRange ConstantRange::srem(const ConstantRange &RHS) const {
1142 ConstantRange ConstantRange::srem(const ConstantRange &RHS) const {
1146 ConstantRange AbsRHS = RHS.abs();
1184 ConstantRange
1185 ConstantRange::binaryAnd(const ConstantRange &Other) const {
1195 ConstantRange
1196 ConstantRange::binaryOr(const ConstantRange &Other) const {
1206 ConstantRange
1207 ConstantRange::shl(const ConstantRange &Other) const {
1231 ConstantRange
1232 ConstantRange::lshr(const ConstantRange &Other) const {
1241 ConstantRange
1242 ConstantRange::ashr(const ConstantRange &Other) const {
1292 ConstantRange ConstantRange::uadd_sat(const ConstantRange &Other) const {
1292 ConstantRange ConstantRange::uadd_sat(const ConstantRange &Other) const {
1301 ConstantRange ConstantRange::sadd_sat(const ConstantRange &Other) const {
1301 ConstantRange ConstantRange::sadd_sat(const ConstantRange &Other) const {
1310 ConstantRange ConstantRange::usub_sat(const ConstantRange &Other) const {
1310 ConstantRange ConstantRange::usub_sat(const ConstantRange &Other) const {
1319 ConstantRange ConstantRange::ssub_sat(const ConstantRange &Other) const {
1319 ConstantRange ConstantRange::ssub_sat(const ConstantRange &Other) const {
1328 ConstantRange ConstantRange::inverse() const {
1336 ConstantRange ConstantRange::abs() const {
1367 ConstantRange::OverflowResult ConstantRange::unsignedAddMayOverflow(
1368 const ConstantRange &Other) const {
1383 ConstantRange::OverflowResult ConstantRange::signedAddMayOverflow(
1384 const ConstantRange &Other) const {
1413 ConstantRange::OverflowResult ConstantRange::unsignedSubMayOverflow(
1414 const ConstantRange &Other) const {
1429 ConstantRange::OverflowResult ConstantRange::signedSubMayOverflow(
1430 const ConstantRange &Other) const {
1459 ConstantRange::OverflowResult ConstantRange::unsignedMulMayOverflow(
1460 const ConstantRange &Other) const {
1494 ConstantRange llvm::getConstantRangeFromMetadata(const MDNode &Ranges) {
1502 ConstantRange CR(FirstLow->getValue(), FirstHigh->getValue());
lib/IR/Globals.cpp 302 Optional<ConstantRange> GlobalValue::getAbsoluteSymbolRange() const {
lib/IR/Metadata.cpp 940 static bool isContiguous(const ConstantRange &A, const ConstantRange &B) {
940 static bool isContiguous(const ConstantRange &A, const ConstantRange &B) {
944 static bool canBeMerged(const ConstantRange &A, const ConstantRange &B) {
944 static bool canBeMerged(const ConstantRange &A, const ConstantRange &B) {
950 ConstantRange NewRange(Low->getValue(), High->getValue());
954 ConstantRange LastRange(LB, LE);
956 ConstantRange Union = LastRange.unionWith(NewRange);
1037 ConstantRange Range(EndPoints[0]->getValue(), EndPoints[1]->getValue());
lib/IR/Verifier.cpp 3317 static bool isContiguous(const ConstantRange &A, const ConstantRange &B) {
3317 static bool isContiguous(const ConstantRange &A, const ConstantRange &B) {
3330 ConstantRange LastRange(1, true); // Dummy initial value
3343 ConstantRange CurRange(LowV, HighV);
3361 ConstantRange FirstRange(FirstLow, FirstHigh);
lib/Target/X86/X86ISelDAGToDAG.cpp 2386 Optional<ConstantRange> CR =
2575 Optional<ConstantRange> CR = GA->getGlobal()->getAbsoluteSymbolRange();
2632 Optional<ConstantRange> CR = GA->getGlobal()->getAbsoluteSymbolRange();
lib/Target/X86/X86Subtarget.cpp 130 if (Optional<ConstantRange> CR = GV->getAbsoluteSymbolRange()) {
lib/Transforms/InstCombine/InstCombineCompares.cpp 1496 ConstantRange CR = ConstantRange::makeAllowedICmpRegion(Pred, *C);
1496 ConstantRange CR = ConstantRange::makeAllowedICmpRegion(Pred, *C);
1497 ConstantRange DominatingCR =
1498 (CmpBB == TrueBB) ? ConstantRange::makeExactICmpRegion(DomPred, *DomC)
1499 : ConstantRange::makeExactICmpRegion(
1501 ConstantRange Intersection = DominatingCR.intersectWith(CR);
1502 ConstantRange Difference = DominatingCR.difference(CR);
2590 auto CR = ConstantRange::makeExactICmpRegion(Pred, C).subtract(*C2);
2590 auto CR = ConstantRange::makeExactICmpRegion(Pred, C).subtract(*C2);
lib/Transforms/Instrumentation/BoundsChecking.cpp 78 auto SizeRange = SE.getUnsignedRange(SE.getSCEV(Size));
79 auto OffsetRange = SE.getUnsignedRange(SE.getSCEV(Offset));
80 auto NeededSizeRange = SE.getUnsignedRange(SE.getSCEV(NeededSizeVal));
lib/Transforms/Scalar/CorrelatedValuePropagation.cpp 435 ConstantRange LRange = LVI->getConstantRange(
437 ConstantRange RRange = LVI->getConstantRange(
439 ConstantRange NWRegion = ConstantRange::makeGuaranteedNoWrapRegion(
439 ConstantRange NWRegion = ConstantRange::makeGuaranteedNoWrapRegion(
628 ConstantRange OperandRange(OrigWidth, /*isFullSet=*/false);
760 ConstantRange LRange = LVI->getConstantRange(LHS, BB, BinOp);
761 ConstantRange RRange = LVI->getConstantRange(RHS, BB, BinOp);
766 ConstantRange NUWRange = ConstantRange::makeGuaranteedNoWrapRegion(
766 ConstantRange NUWRange = ConstantRange::makeGuaranteedNoWrapRegion(
772 ConstantRange NSWRange = ConstantRange::makeGuaranteedNoWrapRegion(
772 ConstantRange NSWRange = ConstantRange::makeGuaranteedNoWrapRegion(
795 ConstantRange LRange = LVI->getConstantRange(LHS, BB, BinOp);
lib/Transforms/Scalar/Float2Int.cpp 149 void Float2IntPass::seen(Instruction *I, ConstantRange R) {
159 ConstantRange Float2IntPass::badRange() {
160 return ConstantRange::getFull(MaxIntegerBW + 1);
162 ConstantRange Float2IntPass::unknownRange() {
163 return ConstantRange::getEmpty(MaxIntegerBW + 1);
165 ConstantRange Float2IntPass::validateRange(ConstantRange R) {
165 ConstantRange Float2IntPass::validateRange(ConstantRange R) {
207 auto Input = ConstantRange::getFull(BW);
207 auto Input = ConstantRange::getFull(BW);
246 std::function<ConstantRange(ArrayRef<ConstantRange>)> Op;
246 std::function<ConstantRange(ArrayRef<ConstantRange>)> Op;
258 auto Zero = ConstantRange(APInt::getNullValue(Size));
297 SmallVector<ConstantRange,4> OpRanges;
357 ConstantRange R(MaxIntegerBW + 1, false);
lib/Transforms/Scalar/GuardWidening.cpp 548 ConstantRange CR0 =
549 ConstantRange::makeExactICmpRegion(Pred0, RHS0->getValue());
550 ConstantRange CR1 =
551 ConstantRange::makeExactICmpRegion(Pred1, RHS1->getValue());
562 auto SubsetIntersect = CR0.inverse().unionWith(CR1.inverse()).inverse();
563 auto SupersetIntersect = CR0.intersectWith(CR1);
lib/Transforms/Scalar/IndVarSimplify.cpp 1003 DenseMap<DefUserPair, ConstantRange> PostIncRangeInfos;
1005 Optional<ConstantRange> getPostIncRangeInfo(Value *Def,
1017 void updatePostIncRangeInfo(Value *Def, Instruction *UseI, ConstantRange R) {
1842 auto CmpRHSRange = SE->getSignedRange(SE->getSCEV(CmpRHS));
1843 auto CmpConstrainedLHSRange =
1844 ConstantRange::makeAllowedICmpRegion(P, CmpRHSRange);
1845 auto NarrowDefRange = CmpConstrainedLHSRange.addWithNoWrap(
lib/Transforms/Scalar/JumpThreading.cpp 869 ConstantRange CR = LVI->getConstantRangeOnEdge(
875 ConstantRange CmpRange = ConstantRange::makeExactICmpRegion(
875 ConstantRange CmpRange = ConstantRange::makeExactICmpRegion(
lib/Transforms/Utils/LowerSwitch.cpp 496 ConstantRange KnownBitsRange =
497 ConstantRange::fromKnownBits(Known, /*IsSigned=*/false);
498 const ConstantRange LVIRange = LVI->getConstantRange(Val, OrigBlock, SI);
499 ConstantRange ValRange = KnownBitsRange.intersectWith(LVIRange);
lib/Transforms/Utils/SimplifyCFG.cpp 595 ConstantRange Span = ConstantRange::makeAllowedICmpRegion(
595 ConstantRange Span = ConstantRange::makeAllowedICmpRegion(
lib/Transforms/Utils/SimplifyIndVar.cpp 770 ConstantRange IVRange = SE->getUnsignedRange(SE->getSCEV(IVOperand));
tools/polly/lib/Analysis/ScopInfo.cpp 166 static isl::set addRangeBoundsToSet(isl::set S, const ConstantRange &Range,
746 const ConstantRange &Range = SE->getSignedRange(PtrSCEV);
1558 ConstantRange SRange = SE->getSignedRange(Parameter);
unittests/IR/ConstantRangeTest.cpp 22 static ConstantRange Full;
23 static ConstantRange Empty;
24 static ConstantRange One;
25 static ConstantRange Some;
26 static ConstantRange Wrap;
38 ConstantRange CR(APInt(Bits, Lo), APInt(Bits, Hi));
54 static void ForeachNumInConstantRange(const ConstantRange &CR, Fn TestFn) {
84 ConstantRange CR = RangeFn(CR1, CR2);
90 ConstantRange Exact = ConstantRange::getNonEmpty(Min, Max + 1);
90 ConstantRange Exact = ConstantRange::getNonEmpty(Min, Max + 1);
121 ConstantRange CR = RangeFn(CR1, CR2);
127 ConstantRange Exact = ConstantRange::getNonEmpty(Min, Max + 1);
127 ConstantRange Exact = ConstantRange::getNonEmpty(Min, Max + 1);
136 ConstantRange ConstantRangeTest::Full(16, true);
137 ConstantRange ConstantRangeTest::Empty(16, false);
138 ConstantRange ConstantRangeTest::One(APInt(16, 0xa));
139 ConstantRange ConstantRangeTest::Some(APInt(16, 0xa), APInt(16, 0xaaa));
140 ConstantRange ConstantRangeTest::Wrap(APInt(16, 0xaaa), APInt(16, 0xa));
223 ConstantRange OneInverse = One.inverse();
289 ConstantRange CR1(APInt(8, 42), APInt::getMinValue(8));
293 ConstantRange CR2(APInt(8, 42), APInt::getSignedMinValue(8));
299 ConstantRange TFull = Full.truncate(10);
300 ConstantRange TEmpty = Empty.truncate(10);
301 ConstantRange TOne = One.truncate(10);
302 ConstantRange TSome = Some.truncate(10);
303 ConstantRange TWrap = Wrap.truncate(10);
312 ConstantRange TwoFive(APInt(3, 2), APInt(3, 5));
316 ConstantRange TwoSix(APInt(3, 2), APInt(3, 6));
320 ConstantRange FiveSeven(APInt(3, 5), APInt(3, 7));
324 ConstantRange SevenOne(APInt(3, 7), APInt(3, 1));
329 ConstantRange ZFull = Full.zeroExtend(20);
330 ConstantRange ZEmpty = Empty.zeroExtend(20);
331 ConstantRange ZOne = One.zeroExtend(20);
332 ConstantRange ZSome = Some.zeroExtend(20);
333 ConstantRange ZWrap = Wrap.zeroExtend(20);
343 ConstantRange FiveZero(APInt(3, 5), APInt(3, 0));
348 ConstantRange SFull = Full.signExtend(20);
349 ConstantRange SEmpty = Empty.signExtend(20);
350 ConstantRange SOne = One.signExtend(20);
351 ConstantRange SSome = Some.signExtend(20);
352 ConstantRange SWrap = Wrap.signExtend(20);
388 ConstantRange LHS(APInt(16, 4), APInt(16, 2));
389 ConstantRange RHS(APInt(16, 6), APInt(16, 5));
476 ConstantRange SmallestCR = OpFn(CR1, CR2, ConstantRange::Smallest);
476 ConstantRange SmallestCR = OpFn(CR1, CR2, ConstantRange::Smallest);
477 ConstantRange UnsignedCR = OpFn(CR1, CR2, ConstantRange::Unsigned);
477 ConstantRange UnsignedCR = OpFn(CR1, CR2, ConstantRange::Unsigned);
478 ConstantRange SignedCR = OpFn(CR1, CR2, ConstantRange::Signed);
478 ConstantRange SignedCR = OpFn(CR1, CR2, ConstantRange::Signed);
493 ConstantRange Expected(Lower1, Upper1 + 1);
501 ConstantRange Variant1(Bits, /*full*/ true);
502 ConstantRange Variant2(Bits, /*full*/ true);
604 ConstantRange A(APInt(16, 3), APInt(16, 7));
605 ConstantRange B(APInt(16, 5), APInt(16, 9));
606 ConstantRange C(APInt(16, 3), APInt(16, 5));
607 ConstantRange D(APInt(16, 7), APInt(16, 9));
608 ConstantRange E(APInt(16, 5), APInt(16, 4));
609 ConstantRange F(APInt(16, 7), APInt(16, 3));
651 ConstantRange CR = RangeFn(CR1, CR2);
673 ConstantRange Exact = ConstantRange::getNonEmpty(Min, Max + 1);
673 ConstantRange Exact = ConstantRange::getNonEmpty(Min, Max + 1);
684 ConstantRange CR = RangeFn(CR1, CR2);
707 ConstantRange Exact = ConstantRange::getNonEmpty(Min, Max + 1);
707 ConstantRange Exact = ConstantRange::getNonEmpty(Min, Max + 1);
720 ConstantRange CR = RangeFn(CR1, CR2);
751 ConstantRange Exact =
752 ConstantRange::getNonEmpty(SMin, SMax + 1)
753 .intersectWith(ConstantRange::getNonEmpty(UMin, UMax + 1));
943 ConstantRange Zero(APInt(16, 0));
1068 ConstantRange Zero(APInt(16, 0));
1101 ConstantRange CR = CR1.sdiv(CR2);
1110 ConstantRange Envelope = ConstantRange::getNonEmpty(SMin, SMax + 1);
1110 ConstantRange Envelope = ConstantRange::getNonEmpty(SMin, SMax + 1);
1130 ConstantRange Wrapped = ConstantRange::getNonEmpty(WMin, WMax + 1);
1130 ConstantRange Wrapped = ConstantRange::getNonEmpty(WMin, WMax + 1);
1180 ConstantRange PosMod(APInt(16, 10), APInt(16, 21)); // [10, 20]
1181 ConstantRange NegMod(APInt(16, -20), APInt(16, -9)); // [-20, -10]
1182 ConstantRange IntMinMod(APInt::getSignedMinValue(16));
1184 ConstantRange Expected(16, true);
1187 ConstantRange PosLargeLHS(APInt(16, 0), APInt(16, 41));
1191 ConstantRange NegLargeLHS(APInt(16, -40), APInt(16, 1));
1195 ConstantRange PosNegLargeLHS(APInt(16, -32), APInt(16, 38));
1201 ConstantRange PosLHS(APInt(16, 0), APInt(16, 16));
1205 ConstantRange NegLHS(APInt(16, -15), APInt(16, 1));
1209 ConstantRange PosNegLHS(APInt(16, -12), APInt(16, 18));
1215 ConstantRange PosSmallLHS(APInt(16, 3), APInt(16, 8));
1219 ConstantRange NegSmallLHS(APInt(16, -7), APInt(16, -2));
1223 ConstantRange PosNegSmallLHS(APInt(16, -3), APInt(16, 8));
1245 ConstantRange Some2(APInt(16, 0xfff), APInt(16, 0x8000));
1246 ConstantRange WrapNullMax(APInt(16, 0x1), APInt(16, 0x0));
1295 ConstantRange Small(APInt(16, 0xa), APInt(16, 0xb));
1312 ConstantRange Neg(APInt(16, 0xf3f0, true), APInt(16, 0xf7f8, true));
1319 ConstantRange SMax = ConstantRange(APInt::getSignedMaxValue(32));
1325 ConstantRange LowHalf(APInt(8, 0), APInt(8, 128));
1326 ConstantRange HighHalf(APInt(8, 128), APInt(8, 0));
1327 ConstantRange EmptySet(8, /* isFullSet = */ false);
1339 ConstantRange UnsignedSample(APInt(8, 5), APInt(8, 200));
1357 ConstantRange SignedSample(APInt(8, -5), APInt(8, 5));
1384 auto NUWRegion = ConstantRange::makeGuaranteedNoWrapRegion(
1384 auto NUWRegion = ConstantRange::makeGuaranteedNoWrapRegion(
1389 auto NSWRegion = ConstantRange::makeGuaranteedNoWrapRegion(
1389 auto NSWRegion = ConstantRange::makeGuaranteedNoWrapRegion(
1412 auto NUWRegion = ConstantRange::makeGuaranteedNoWrapRegion(
1412 auto NUWRegion = ConstantRange::makeGuaranteedNoWrapRegion(
1417 auto NSWRegion = ConstantRange::makeGuaranteedNoWrapRegion(
1417 auto NSWRegion = ConstantRange::makeGuaranteedNoWrapRegion(
1437 auto NSWForAllValues = ConstantRange::makeGuaranteedNoWrapRegion(
1437 auto NSWForAllValues = ConstantRange::makeGuaranteedNoWrapRegion(
1443 NSWForAllValues = ConstantRange::makeGuaranteedNoWrapRegion(
1449 auto NUWForAllValues = ConstantRange::makeGuaranteedNoWrapRegion(
1449 auto NUWForAllValues = ConstantRange::makeGuaranteedNoWrapRegion(
1455 NUWForAllValues = ConstantRange::makeGuaranteedNoWrapRegion(
1470 ConstantRange OneToFive(APInt(32, 1), APInt(32, 6));
1486 ConstantRange MinusFiveToMinusTwo(APInt(32, -5), APInt(32, -1));
1503 ConstantRange MinusOneToOne(APInt(32, -1), APInt(32, 2));
1520 ConstantRange One(APInt(32, 1), APInt(32, 2));
1536 ConstantRange OneLessThanBitWidth(APInt(32, 0), APInt(32, 31) + 1);
1537 ConstantRange UpToBitWidth(APInt(32, 0), APInt(32, 32) + 1);
1564 ConstantRange IllegalShAmt(APInt(32, 32), APInt(32, 0) + 1);
1609 ConstantRange NoWrap =
1610 ConstantRange::makeGuaranteedNoWrapRegion(BinOp, CR, NoWrapKind);
1611 ConstantRange Full = ConstantRange::getFull(Bits);
1611 ConstantRange Full = ConstantRange::getFull(Bits);
1789 ConstantRange Zero(APInt::getNullValue(16));
1801 ConstantRange A(APInt(16, 0xfd00), APInt(16, 0xfe00));
1802 ConstantRange B1(APInt(16, 0x0100), APInt(16, 0x0201));
1803 ConstantRange B2(APInt(16, 0x0100), APInt(16, 0x0202));
1809 ConstantRange C1(APInt(16, 0x0299), APInt(16, 0x0400));
1810 ConstantRange C2(APInt(16, 0x0300), APInt(16, 0x0400));
1823 ConstantRange Zero(APInt::getNullValue(16));
1824 ConstantRange Max(APInt::getAllOnesValue(16));
1836 ConstantRange A(APInt(16, 0x0000), APInt(16, 0x0100));
1837 ConstantRange B(APInt(16, 0x0100), APInt(16, 0x0200));
1841 ConstantRange A1(APInt(16, 0x0000), APInt(16, 0x0101));
1842 ConstantRange B1(APInt(16, 0x0100), APInt(16, 0x0201));
1846 ConstantRange A2(APInt(16, 0x0000), APInt(16, 0x0102));
1847 ConstantRange B2(APInt(16, 0x0100), APInt(16, 0x0202));
1858 ConstantRange Zero(APInt::getNullValue(16));
1870 ConstantRange A(APInt(16, 0x7d00), APInt(16, 0x7e00));
1871 ConstantRange B1(APInt(16, 0x0100), APInt(16, 0x0201));
1872 ConstantRange B2(APInt(16, 0x0100), APInt(16, 0x0202));
1875 ConstantRange B3(APInt(16, 0x8000), APInt(16, 0x0201));
1876 ConstantRange B4(APInt(16, 0x8000), APInt(16, 0x0202));
1879 ConstantRange B5(APInt(16, 0x0299), APInt(16, 0x0400));
1880 ConstantRange B6(APInt(16, 0x0300), APInt(16, 0x0400));
1884 ConstantRange C(APInt(16, 0x8200), APInt(16, 0x8300));
1885 ConstantRange D1(APInt(16, 0xfe00), APInt(16, 0xff00));
1886 ConstantRange D2(APInt(16, 0xfd99), APInt(16, 0xff00));
1889 ConstantRange D3(APInt(16, 0xfe00), APInt(16, 0x8000));
1890 ConstantRange D4(APInt(16, 0xfd99), APInt(16, 0x8000));
1893 ConstantRange D5(APInt(16, 0xfc00), APInt(16, 0xfd02));
1894 ConstantRange D6(APInt(16, 0xfc00), APInt(16, 0xfd01));
1898 ConstantRange E(APInt(16, 0xff00), APInt(16, 0x0100));
1900 ConstantRange F(APInt(16, 0xf000), APInt(16, 0x7000));
1910 ConstantRange Zero(APInt::getNullValue(16));
1920 ConstantRange A(APInt(16, 0x7d00), APInt(16, 0x7e00));
1921 ConstantRange B1(APInt(16, 0xfe00), APInt(16, 0xff00));
1922 ConstantRange B2(APInt(16, 0xfd99), APInt(16, 0xff00));
1925 ConstantRange B3(APInt(16, 0xfc00), APInt(16, 0xfd02));
1926 ConstantRange B4(APInt(16, 0xfc00), APInt(16, 0xfd01));
1930 ConstantRange C(APInt(16, 0x8200), APInt(16, 0x8300));
1931 ConstantRange D1(APInt(16, 0x0100), APInt(16, 0x0201));
1932 ConstantRange D2(APInt(16, 0x0100), APInt(16, 0x0202));
1935 ConstantRange D3(APInt(16, 0x0299), APInt(16, 0x0400));
1936 ConstantRange D4(APInt(16, 0x0300), APInt(16, 0x0400));
1940 ConstantRange E(APInt(16, 0xff00), APInt(16, 0x0100));
1942 ConstantRange F(APInt(16, 0xf000), APInt(16, 0x7001));
1972 ConstantRange::OverflowResult OR = MayOverflowFn(CR1, CR2);
1974 case ConstantRange::OverflowResult::AlwaysOverflowsLow:
1979 case ConstantRange::OverflowResult::AlwaysOverflowsHigh:
1984 case ConstantRange::OverflowResult::NeverOverflows:
1989 case ConstantRange::OverflowResult::MayOverflow:
2078 ConstantRange Unsigned(APInt(8, 66), APInt(8, 219 + 1));
2079 ConstantRange Signed(APInt(8, 194), APInt(8, 91 + 1));
2086 ConstantRange CR1(APInt(8, 164), APInt(8, 237 + 1));
2093 ConstantRange CR2(APInt(8, 68), APInt(8, 110 + 1));
2124 ConstantRange UnsignedCR(MinUnsigned, MaxUnsigned + 1);
2125 ConstantRange SignedCR(MinSigned, MaxSigned + 1);
2214 ConstantRange AbsCR = CR.abs();
2220 ConstantRange Exact = ConstantRange::getNonEmpty(Min, Max + 1);
2220 ConstantRange Exact = ConstantRange::getNonEmpty(Min, Max + 1);
usr/include/c++/7.4.0/bits/alloc_traits.h 387 using allocator_type = allocator<_Tp>;
389 using value_type = _Tp;
392 using pointer = _Tp*;
395 using const_pointer = const _Tp*;
usr/include/c++/7.4.0/bits/allocator.h 108 class allocator: public __allocator_base<_Tp>
113 typedef _Tp* pointer;
114 typedef const _Tp* const_pointer;
115 typedef _Tp& reference;
116 typedef const _Tp& const_reference;
117 typedef _Tp value_type;
137 allocator(const allocator<_Tp1>&) throw() { }
usr/include/c++/7.4.0/bits/move.h 46 inline _GLIBCXX_CONSTEXPR _Tp*
47 __addressof(_Tp& __r) _GLIBCXX_NOEXCEPT
72 constexpr _Tp&&
73 forward(typename std::remove_reference<_Tp>::type& __t) noexcept
83 constexpr _Tp&&
84 forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
98 move(_Tp&& __t) noexcept
136 inline _GLIBCXX17_CONSTEXPR _Tp*
137 addressof(_Tp& __r) noexcept
143 const _Tp* addressof(const _Tp&&) = delete;
143 const _Tp* addressof(const _Tp&&) = delete;
usr/include/c++/7.4.0/bits/std_function.h 62 : std::unary_function<_T1, _Res> { };
67 : std::binary_function<_T1, _T2, _Res> { };
298 static _Res
299 _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
390 : public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>,
395 struct _Callable : __check_func_return_type<_Res2, _Res> { };
395 struct _Callable : __check_func_return_type<_Res2, _Res> { };
406 typedef _Res result_type;
595 _Res operator()(_ArgTypes... __args) const;
628 using _Invoker_type = _Res (*)(const _Any_data&, _ArgTypes&&...);
628 using _Invoker_type = _Res (*)(const _Any_data&, _ArgTypes&&...);
689 typedef _Function_handler<_Res(_ArgTypes...), _Functor> _My_handler;
usr/include/c++/7.4.0/bits/stl_construct.h 74 _Construct(_T1* __p, _Args&&... __args)
74 _Construct(_T1* __p, _Args&&... __args)
75 { ::new(static_cast<void*>(__p)) _T1(std::forward<_Args>(__args)...); }
75 { ::new(static_cast<void*>(__p)) _T1(std::forward<_Args>(__args)...); }
97 _Destroy(_Tp* __pointer)
usr/include/c++/7.4.0/bits/stl_function.h 111 typedef _Result result_type;
127 typedef _Result result_type;
usr/include/c++/7.4.0/bits/stl_iterator_base_types.h 181 typedef _Tp value_type;
183 typedef _Tp* pointer;
184 typedef _Tp& reference;
usr/include/c++/7.4.0/bits/stl_pair.h 101 is_constructible<_T2, const _U2&>>::value;
101 is_constructible<_T2, const _U2&>>::value;
108 is_convertible<const _U2&, _T2>>::value;
108 is_convertible<const _U2&, _T2>>::value;
115 is_constructible<_T2, _U2&&>>::value;
115 is_constructible<_T2, _U2&&>>::value;
122 is_convertible<_U2&&, _T2>>::value;
122 is_convertible<_U2&&, _T2>>::value;
129 is_convertible<_U2&&, _T2>>;
129 is_convertible<_U2&&, _T2>>;
134 is_constructible<_T2, _U2&&>,
134 is_constructible<_T2, _U2&&>,
143 is_convertible<const _U2&, _T2>>;
143 is_convertible<const _U2&, _T2>>;
148 is_constructible<_T2, const _U2&&>,
148 is_constructible<_T2, const _U2&&>,
209 : private __pair_base<_T1, _T2>
212 typedef _T2 second_type; /// @c second_type is the second bound type
215 _T2 second; /// @c second is a copy of the second object
252 using _PCCP = _PCC<true, _T1, _T2>;
260 constexpr pair(const _T1& __a, const _T2& __b)
269 explicit constexpr pair(const _T1& __a, const _T2& __b)
283 _T1, _T2>;
311 constexpr pair(_U1&& __x, const _T2& __y)
318 explicit constexpr pair(_U1&& __x, const _T2& __y)
325 constexpr pair(const _T1& __x, _U2&& __y)
341 constexpr pair(_U1&& __x, _U2&& __y)
342 : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
380 is_copy_assignable<_T2>>::value,
391 is_move_assignable<_T2>>::value,
403 is_assignable<_T2&, const _U2&>>::value,
403 is_assignable<_T2&, const _U2&>>::value,
405 operator=(const pair<_U1, _U2>& __p)
414 is_assignable<_T2&, _U2&&>>::value,
414 is_assignable<_T2&, _U2&&>>::value,
416 operator=(pair<_U1, _U2>&& __p)
523 typename __decay_and_strip<_T2>::__type>
524 make_pair(_T1&& __x, _T2&& __y)
527 typedef typename __decay_and_strip<_T2>::__type __ds_type2;
529 return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y));
usr/include/c++/7.4.0/bits/stl_vector.h 77 rebind<_Tp>::other _Tp_alloc_type;
216 class vector : protected _Vector_base<_Tp, _Alloc>
227 typedef _Vector_base<_Tp, _Alloc> _Base;
232 typedef _Tp value_type;
919 _Tp*
923 const _Tp*
usr/include/c++/7.4.0/ext/alloc_traits.h 117 { typedef typename _Base_type::template rebind_alloc<_Tp> other; };
usr/include/c++/7.4.0/ext/new_allocator.h 63 typedef _Tp* pointer;
64 typedef const _Tp* const_pointer;
65 typedef _Tp& reference;
66 typedef const _Tp& const_reference;
67 typedef _Tp value_type;
usr/include/c++/7.4.0/initializer_list 50 typedef _E value_type;
51 typedef const _E& reference;
52 typedef const _E& const_reference;
54 typedef const _E* iterator;
55 typedef const _E* const_iterator;
usr/include/c++/7.4.0/type_traits 194 { typedef _Tp type; };
215 : public __is_void_helper<typename remove_cv<_Tp>::type>::type
326 : public __is_integral_helper<typename remove_cv<_Tp>::type>::type
354 : public __is_floating_point_helper<typename remove_cv<_Tp>::type>::type
381 : public __is_pointer_helper<typename remove_cv<_Tp>::type>::type
567 : public __is_null_pointer_helper<typename remove_cv<_Tp>::type>::type
581 : public __or_<is_lvalue_reference<_Tp>,
582 is_rvalue_reference<_Tp>>::type
588 : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
588 : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
601 : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
601 : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
602 is_void<_Tp>>>::type
611 : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
611 : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
611 : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
612 is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
612 is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
631 : public __is_member_pointer_helper<typename remove_cv<_Tp>::type>::type
638 : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
638 : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
777 : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
777 : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
798 typedef decltype(__test<_Tp>(0)) type;
811 remove_all_extents<_Tp>::type>::type
825 : public __is_destructible_safe<_Tp>::type
889 typedef decltype(__test<_Tp>(0)) type;
894 : public __and_<__not_<is_void<_Tp>>,
895 __is_default_constructible_impl<_Tp>>
915 : public __is_default_constructible_atom<_Tp>::type
921 : public __is_default_constructible_safe<_Tp>::type
984 typedef decltype(__test<_Tp, _Arg>(0)) type;
989 : public __and_<is_destructible<_Tp>,
990 __is_direct_constructible_impl<_Tp, _Arg>>
1072 __is_direct_constructible_ref_cast<_Tp, _Arg>,
1073 __is_direct_constructible_new_safe<_Tp, _Arg>
1079 : public __is_direct_constructible_new<_Tp, _Arg>::type
1119 : public __is_direct_constructible<_Tp, _Arg>
1130 : public __is_constructible_impl<_Tp, _Args...>::type
1142 : public is_constructible<_Tp, const _Tp&>
1142 : public is_constructible<_Tp, const _Tp&>
1148 : public __is_copy_constructible_impl<_Tp>
1160 : public is_constructible<_Tp, _Tp&&>
1160 : public is_constructible<_Tp, _Tp&&>
1166 : public __is_move_constructible_impl<_Tp>
1286 : public is_assignable<_Tp&, const _Tp&>
1286 : public is_assignable<_Tp&, const _Tp&>
1292 : public __is_copy_assignable_impl<_Tp>
1304 : public is_assignable<_Tp&, _Tp&&>
1304 : public is_assignable<_Tp&, _Tp&&>
1310 : public __is_move_assignable_impl<_Tp>
1400 : public __and_<is_default_constructible<_Tp>,
1401 __is_implicitly_default_constructible_safe<_Tp>>
1526 static void __test_aux(_To1);
1538 typedef decltype(__test<_From, _To>(0)) type;
1545 : public __is_convertible_helper<_From, _To>::type
1554 { typedef _Tp type; };
1563 { typedef _Tp type; };
1574 remove_const<typename remove_volatile<_Tp>::type>::type type;
1629 { typedef _Tp type; };
1633 { typedef _Tp type; };
1659 { typedef _Tp&& type; };
1955 { typedef _Tp type; };
2104 { typedef typename remove_cv<_Up>::type __type; };
2118 typedef typename remove_reference<_Tp>::type __remove_type;
2131 typedef _Tp __type;
2144 typename decay<_Tp>::type>::__type __type;
2277 struct __result_of_success : __success_type<_Tp>
2427 static __result_of_success<decltype(
utils/unittest/googletest/include/gtest/gtest-printers.h 223 void DefaultPrintNonContainerTo(const T& value, ::std::ostream* os) {
276 static ::std::string Format(const ToPrint& value) {
351 const T1& value, const T2& /* other_operand */) {
351 const T1& value, const T2& /* other_operand */) {
352 return FormatForComparison<T1, T2>::Format(value);
352 return FormatForComparison<T1, T2>::Format(value);
366 void UniversalPrint(const T& value, ::std::ostream* os);
373 const C& container, ::std::ostream* os) {
439 const T& value, ::std::ostream* os) {
455 void PrintTo(const T& value, ::std::ostream* os) {
478 DefaultPrintTo(IsContainerTest<T>(0), is_pointer<T>(), value, os);
699 static void Print(const T& value, ::std::ostream* os) {
784 static void Print(const T& value, ::std::ostream* os) {
856 typedef T T1;
983 internal::UniversalTersePrinter<T>::Print(value, &ss);
utils/unittest/googletest/include/gtest/gtest.h 1377 const T1& lhs, const T2& rhs) {
1377 const T1& lhs, const T2& rhs) {
1389 const T1& lhs,
1390 const T2& rhs) {
1419 const T1& lhs,
1420 const T2& rhs) {
1487 const T1& val1, const T2& val2,
1487 const T1& val1, const T2& val2,
utils/unittest/googletest/include/gtest/internal/custom/raw-ostream.h 35 auto printable(const T &V) -> decltype(StreamSwitch<T>::printable(V)) {
35 auto printable(const T &V) -> decltype(StreamSwitch<T>::printable(V)) {
37 return StreamSwitch<T>::printable(V);
54 const T& V;
55 friend std::ostream &operator<<(std::ostream &S, const RawStreamProxy<T> &V) {
69 static const RawStreamProxy<T> printable(const T &V) { return {V}; }
69 static const RawStreamProxy<T> printable(const T &V) { return {V}; }
utils/unittest/googletest/include/gtest/internal/gtest-internal.h 94 ::std::string PrintToString(const T& value);