|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
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 {
468 ArrayRef<T> makeArrayRef(const SmallVectorImpl<T> &Vec) {
468 ArrayRef<T> makeArrayRef(const SmallVectorImpl<T> &Vec) {
474 ArrayRef<T> makeArrayRef(const SmallVector<T, N> &Vec) {
474 ArrayRef<T> makeArrayRef(const SmallVector<T, N> &Vec) {
include/llvm/ADT/BitmaskEnum.h 80 template <typename E> typename std::underlying_type<E>::type Mask() {
84 E::LLVM_BITMASK_LARGEST_ENUMERATOR)) -
90 template <typename E> typename std::underlying_type<E>::type Underlying(E Val) {
99 E operator~(E Val) {
99 E operator~(E Val) {
100 return static_cast<E>(~Underlying(Val) & Mask<E>());
105 E operator|(E LHS, E RHS) {
105 E operator|(E LHS, E RHS) {
105 E operator|(E LHS, E RHS) {
111 E operator&(E LHS, E RHS) {
111 E operator&(E LHS, E RHS) {
111 E operator&(E LHS, E RHS) {
126 E &operator|=(E &LHS, E RHS) {
126 E &operator|=(E &LHS, E RHS) {
126 E &operator|=(E &LHS, E RHS) {
133 E &operator&=(E &LHS, E RHS) {
133 E &operator&=(E &LHS, E RHS) {
133 E &operator&=(E &LHS, E RHS) {
include/llvm/ADT/Optional.h 144 T value;
172 T &getValue() LLVM_LVALUE_FUNCTION noexcept {
176 T const &getValue() const LLVM_LVALUE_FUNCTION noexcept {
181 T &&getValue() && noexcept {
206 ::new ((void *)std::addressof(value)) T(std::move(y));
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 *;
259 class SmallVectorTemplateBase<T, true> : public SmallVectorTemplateCommon<T> {
264 static void destroy_range(T *, T *) {}
264 static void destroy_range(T *, T *) {}
299 void grow(size_t MinSize = 0) { this->grow_pod(MinSize, sizeof(T)); }
302 void push_back(const T &Elt) {
305 memcpy(reinterpret_cast<void *>(this->end()), &Elt, 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) {
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/ADT/StringSwitch.h 48 Optional<T> Result;
67 StringSwitch &Case(StringLiteral S, T Value) {
74 StringSwitch& EndsWith(StringLiteral S, T Value) {
81 StringSwitch& StartsWith(StringLiteral S, T Value) {
88 StringSwitch &Cases(StringLiteral S0, StringLiteral S1, T Value) {
93 T Value) {
98 StringLiteral S3, T Value) {
103 StringLiteral S3, StringLiteral S4, T Value) {
109 T Value) {
115 StringLiteral S6, T Value) {
121 StringLiteral S6, StringLiteral S7, T Value) {
128 T Value) {
135 StringLiteral S9, T Value) {
140 StringSwitch &CaseLower(StringLiteral S, T Value) {
147 StringSwitch &EndsWithLower(StringLiteral S, T Value) {
154 StringSwitch &StartsWithLower(StringLiteral S, T Value) {
161 StringSwitch &CasesLower(StringLiteral S0, StringLiteral S1, T Value) {
166 T Value) {
171 StringLiteral S3, T Value) {
176 StringLiteral S3, StringLiteral S4, T Value) {
181 R Default(T Value) {
181 R Default(T Value) {
188 operator R() {
include/llvm/IR/DIBuilder.h 196 DINode::DIFlags Flags = DINode::FlagZero);
224 DINode::DIFlags Flags = DINode::FlagZero);
256 DINode::DIFlags Flags);
273 DINode::DIFlags Flags, DIType *Ty);
294 DINode::DIFlags Flags, DIType *Ty);
309 uint64_t StorageOffsetInBits, DINode::DIFlags Flags, DIType *Ty);
323 DIType *Ty, DINode::DIFlags Flags,
340 uint64_t OffsetInBits, DINode::DIFlags Flags,
377 DINode::DIFlags Flags, DIType *DerivedFrom, DINodeArray Elements,
394 uint64_t SizeInBits, uint32_t AlignInBits, DINode::DIFlags Flags,
412 DINode::DIFlags Flags,
433 DINode::DIFlags Flags,
518 DINode::DIFlags Flags = DINode::FlagZero,
543 uint32_t AlignInBits = 0, DINode::DIFlags Flags = DINode::FlagFwdDecl,
606 DINode::DIFlags Flags = DINode::FlagZero,
632 DINode::DIFlags Flags = DINode::FlagZero);
664 unsigned ScopeLine, DINode::DIFlags Flags = DINode::FlagZero,
675 DINode::DIFlags Flags = DINode::FlagZero,
704 DINode::DIFlags Flags = DINode::FlagZero,
include/llvm/IR/DebugInfoMetadata.h 167 static DIFlags getFlag(StringRef Flag);
168 static StringRef getFlagString(DIFlags Flag);
174 static DIFlags splitFlags(DIFlags Flags,
174 static DIFlags splitFlags(DIFlags Flags,
175 SmallVectorImpl<DIFlags> &SplitFlags);
585 DIFlags Flags;
593 uint64_t OffsetInBits, DIFlags Flags, ArrayRef<Metadata *> Ops)
600 uint64_t OffsetInBits, DIFlags Flags) {
610 uint32_t AlignInBits, uint64_t OffsetInBits, DIFlags Flags) {
626 DIFlags getFlags() const { return Flags; }
636 TempDIType cloneWithFlags(DIFlags NewFlags) const {
697 DIFlags Flags, ArrayRef<Metadata *> Ops)
706 DIFlags Flags, StorageType Storage,
715 DIFlags Flags, StorageType Storage,
767 DIFlags Flags, ArrayRef<Metadata *> Ops)
777 Optional<unsigned> DWARFAddressSpace, DIFlags Flags,
789 DIFlags Flags, Metadata *ExtraData,
898 uint32_t AlignInBits, uint64_t OffsetInBits, DIFlags Flags,
908 uint64_t OffsetInBits, DIFlags Flags) {
918 uint32_t AlignInBits, uint64_t OffsetInBits, DIFlags Flags,
933 DIFlags Flags, Metadata *Elements, unsigned RuntimeLang,
985 uint64_t OffsetInBits, DIFlags Flags, Metadata *Elements,
1004 uint64_t OffsetInBits, DIFlags Flags, Metadata *Elements,
1069 DISubroutineType(LLVMContext &C, StorageType Storage, DIFlags Flags,
1076 static DISubroutineType *getImpl(LLVMContext &Context, DIFlags Flags,
1082 static DISubroutineType *getImpl(LLVMContext &Context, DIFlags Flags,
1646 DIFlags Flags;
1651 DIFlags Flags, DISPFlags SPFlags, ArrayRef<Metadata *> Ops)
1664 unsigned VirtualIndex, int ThisAdjustment, DIFlags Flags,
1681 DIFlags Flags, DISPFlags SPFlags, Metadata *Unit,
1724 TempDISubprogram cloneWithFlags(DIFlags NewFlags) const {
1736 DIFlags getFlags() const { return Flags; }
2753 DIFlags Flags;
2756 unsigned Arg, DIFlags Flags, uint32_t AlignInBits,
2766 DIType *Type, unsigned Arg, DIFlags Flags,
2774 Metadata *Type, unsigned Arg, DIFlags Flags,
2807 DIFlags getFlags() const { return Flags; }
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;
lib/AsmParser/LLParser.cpp 3758 FieldTy Val;
3761 void assign(FieldTy Val) {
3766 explicit MDFieldImpl(FieldTy Default)
3857 struct DIFlagField : public MDFieldImpl<DINode::DIFlags> {
4145 DINode::DIFlags Combined = DINode::FlagZero;
4147 DINode::DIFlags Val;
lib/Bitcode/Reader/MetadataLoader.cpp 1297 DINode::DIFlags Flags = (Record.size() > 6) ?
1319 DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[10]);
1351 DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[10]);
1408 DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[1]);
1492 DINode::DIFlags Flags;
1783 DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[7 + HasTag]);
lib/CodeGen/AsmPrinter/CodeViewDebug.cpp 2482 if (SubroutineTy->getFlags() & DINode::DIFlags::FlagLValueReference)
2484 else if (SubroutineTy->getFlags() & DINode::DIFlags::FlagRValueReference)
lib/CodeGen/MachineOutliner.cpp 1173 DINode::DIFlags::FlagArtificial /* Compiler-generated code. */,
lib/IR/AsmWriter.cpp 1615 void printDIFlags(StringRef Name, DINode::DIFlags Flags);
1696 void MDFieldPrinter::printDIFlags(StringRef Name, DINode::DIFlags Flags) {
1702 SmallVector<DINode::DIFlags, 8> SplitFlags;
1703 auto Extra = DINode::splitFlags(Flags, SplitFlags);
1706 for (auto F : SplitFlags) {
lib/IR/DIBuilder.cpp 261 DINode::DIFlags Flags) {
289 DINode::DIFlags Flags) {
324 DINode::DIFlags Flags) {
338 DINode::DIFlags Flags, DIType *Ty) {
353 Constant *Discriminant, DINode::DIFlags Flags, DIType *Ty) {
363 DINode::DIFlags Flags, DIType *Ty) {
376 DINode::DIFlags Flags, llvm::Constant *Val,
388 uint64_t OffsetInBits, DINode::DIFlags Flags,
446 DINode::DIFlags Flags, DIType *DerivedFrom, DINodeArray Elements,
462 uint64_t SizeInBits, uint32_t AlignInBits, DINode::DIFlags Flags,
475 uint64_t SizeInBits, uint32_t AlignInBits, DINode::DIFlags Flags,
487 uint64_t SizeInBits, uint32_t AlignInBits, DINode::DIFlags Flags,
498 DINode::DIFlags Flags,
543 DINode::DIFlags FlagsToSet) {
559 DINode::DIFlags Flags = DINode::FlagObjectPointer | DINode::FlagArtificial;
591 DINode::DIFlags Flags, StringRef UniqueIdentifier) {
698 DINode::DIFlags Flags,
707 unsigned LineNo, DIType *Ty, bool AlwaysPreserve, DINode::DIFlags Flags) {
745 static DISubprogram *getSubprogram(bool IsDistinct, Ts &&... Args) {
754 DINode::DIFlags Flags, DISubprogram::DISPFlags SPFlags,
773 DINode::DIFlags Flags, DISubprogram::DISPFlags SPFlags,
788 DIType *VTableHolder, DINode::DIFlags Flags,
lib/IR/DebugInfo.cpp 713 static DINode::DIFlags map_from_llvmDIFlags(LLVMDIFlags Flags) {
717 static LLVMDIFlags map_to_llvmDIFlags(DINode::DIFlags Flags) {
lib/IR/DebugInfoMetadata.cpp 158 DINode::DIFlags DINode::getFlag(StringRef Flag) {
165 StringRef DINode::getFlagString(DIFlags Flag) {
175 DINode::DIFlags DINode::splitFlags(DIFlags Flags,
175 DINode::DIFlags DINode::splitFlags(DIFlags Flags,
176 SmallVectorImpl<DIFlags> &SplitFlags) {
180 if (DIFlags A = Flags & FlagAccessibility) {
189 if (DIFlags R = Flags & FlagPtrToMemberRep) {
344 DIFlags Flags, StorageType Storage,
371 Optional<unsigned> DWARFAddressSpace, DIFlags Flags, Metadata *ExtraData,
387 uint32_t AlignInBits, uint64_t OffsetInBits, DIFlags Flags,
410 DIFlags Flags, Metadata *Elements, unsigned RuntimeLang,
445 DIFlags Flags, Metadata *Elements, unsigned RuntimeLang,
467 DISubroutineType *DISubroutineType::getImpl(LLVMContext &Context, DIFlags Flags,
631 int ThisAdjustment, DIFlags Flags, DISPFlags SPFlags, Metadata *Unit,
772 unsigned Arg, DIFlags Flags,
tools/clang/lib/CodeGen/CGDebugInfo.cpp 1084 llvm::DINode::DIFlags Flags = llvm::DINode::FlagAppleBlock;
1220 static llvm::DINode::DIFlags getAccessFlag(AccessSpecifier Access,
1270 llvm::DINode::DIFlags Flags = getAccessFlag(BitFieldDecl->getAccess(), RD);
1296 llvm::DINode::DIFlags flags = getAccessFlag(AS, RD);
1364 llvm::DINode::DIFlags Flags = getAccessFlag(Var->getAccess(), RD);
1518 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
1568 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
1702 llvm::DINode::DIFlags StartingFlags) {
1710 llvm::DINode::DIFlags BFlags = StartingFlags;
2455 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
2564 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
2705 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
3139 auto Flags = llvm::DINode::FlagZero;
3234 llvm::DINode::DIFlags &Flags) {
3327 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
3548 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
3599 llvm::DINode::DIFlags FlagsForDef = Flags | getCallSiteRelatedAttrs();
3667 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
3940 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
4325 llvm::DINode::DIFlags flags = llvm::DINode::FlagArtificial;
4759 llvm::DINode::DIFlags CGDebugInfo::getCallSiteRelatedAttrs() const {
tools/clang/lib/CodeGen/CGDebugInfo.h 247 llvm::DINode::DIFlags StartingFlags);
642 llvm::DINode::DIFlags getCallSiteRelatedAttrs() const;
687 llvm::DINode::DIFlags &Flags);
unittests/IR/DebugInfoTest.cpp 75 DINode::DIFlags Flags[] = {DINode::FlagFwdDecl, DINode::FlagVector};
unittests/IR/MetadataTest.cpp 1168 DINode::DIFlags Flags = static_cast<DINode::DIFlags>(7);
1295 DINode::DIFlags Flags5 = static_cast<DINode::DIFlags>(5);
1296 DINode::DIFlags Flags4 = static_cast<DINode::DIFlags>(4);
1366 DINode::DIFlags Flags = static_cast<DINode::DIFlags>(5);
1390 DINode::DIFlags Flags = static_cast<DINode::DIFlags>(5);
1458 DINode::DIFlags FlagsPOne = static_cast<DINode::DIFlags>(Flags + 1);
1510 DINode::DIFlags Flags = static_cast<DINode::DIFlags>(5);
1536 DINode::DIFlags Flags = static_cast<DINode::DIFlags>(5);
1581 DINode::DIFlags Flags = static_cast<DINode::DIFlags>(5);
1619 DINode::DIFlags Flags = static_cast<DINode::DIFlags>(1);
1620 DINode::DIFlags FlagsPOne = static_cast<DINode::DIFlags>(Flags + 1);
1806 DINode::DIFlags Flags = static_cast<DINode::DIFlags>(6);
2261 DINode::DIFlags Flags = static_cast<DINode::DIFlags>(7);
usr/include/c++/7.4.0/bits/move.h 46 inline _GLIBCXX_CONSTEXPR _Tp*
47 __addressof(_Tp& __r) _GLIBCXX_NOEXCEPT
72 constexpr _Tp&&
83 constexpr _Tp&&
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/stl_iterator_base_types.h 192 typedef _Tp value_type;
194 typedef const _Tp* pointer;
195 typedef const _Tp& reference;
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 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
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
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>>>
825 : public __is_destructible_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>
1554 { typedef _Tp type; };
1563 { typedef _Tp type; };
1574 remove_const<typename remove_volatile<_Tp>::type>::type type;
1633 { typedef _Tp type; };
1659 { typedef _Tp&& type; };
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) {
1452 const T2& rhs,
1458 typename EnableIf<!is_pointer<T2>::value>::type* = 0) {
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);