|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
References
examples/Kaleidoscope/BuildingAJIT/Chapter3/KaleidoscopeJIT.h 110 return JITSymbol(SymAddr, JITSymbolFlags::Exported);
examples/Kaleidoscope/BuildingAJIT/Chapter4/KaleidoscopeJIT.h 103 return JITSymbol(SymAddr, JITSymbolFlags::Exported);
186 mangle(SharedFnAST->getName()), CCAddr, JITSymbolFlags::Exported))
examples/Kaleidoscope/BuildingAJIT/Chapter5/KaleidoscopeJIT.h 109 return JITSymbol(Addr, JITSymbolFlags::Exported);
199 mangle(SharedFnAST->getName()), CCAddr, JITSymbolFlags::Exported))
examples/Kaleidoscope/include/KaleidoscopeJIT.h 112 return JITSymbol(SymAddr, JITSymbolFlags::Exported);
include/llvm/ADT/DenseMap.h 40 struct DenseMapPair : public std::pair<KeyT, ValueT> {
41 using std::pair<KeyT, ValueT>::pair;
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 {
195 std::pair<iterator, bool> insert(const std::pair<KeyT, ValueT> &KV) {
202 std::pair<iterator, bool> insert(std::pair<KeyT, ValueT> &&KV) {
249 std::pair<iterator, bool> insert_as(std::pair<KeyT, ValueT> &&KV,
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) {
400 is_trivially_copyable<ValueT>::value)
410 ValueT(other.getBuckets()[i].getSecond());
516 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/ExecutionEngine/JITSymbol.h 87 bool operator==(const JITSymbolFlags &RHS) const {
92 JITSymbolFlags &operator&=(const FlagNames &RHS) {
98 JITSymbolFlags &operator|=(const FlagNames &RHS) {
144 static JITSymbolFlags fromGlobalValue(const GlobalValue &GV);
148 static Expected<JITSymbolFlags>
156 inline JITSymbolFlags operator&(const JITSymbolFlags &LHS,
156 inline JITSymbolFlags operator&(const JITSymbolFlags &LHS,
157 const JITSymbolFlags::FlagNames &RHS) {
158 JITSymbolFlags Tmp = LHS;
163 inline JITSymbolFlags operator|(const JITSymbolFlags &LHS,
163 inline JITSymbolFlags operator|(const JITSymbolFlags &LHS,
164 const JITSymbolFlags::FlagNames &RHS) {
165 JITSymbolFlags Tmp = LHS;
181 operator JITSymbolFlags::TargetFlagsType&() { return Flags; }
186 JITSymbolFlags::TargetFlagsType Flags = 0;
198 JITEvaluatedSymbol(JITTargetAddress Address, JITSymbolFlags Flags)
208 JITSymbolFlags getFlags() const { return Flags; }
211 void setFlags(JITSymbolFlags Flags) { this->Flags = std::move(Flags); }
215 JITSymbolFlags Flags;
231 : Err(std::move(Err)), Flags(JITSymbolFlags::HasError) {}
234 JITSymbol(JITTargetAddress Addr, JITSymbolFlags Flags)
250 JITSymbol(GetAddressFtor GetAddress, JITSymbolFlags Flags)
308 JITSymbolFlags getFlags() const { return Flags; }
316 JITSymbolFlags Flags;
include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h 430 std::make_pair(*CCAddr, JITSymbolFlags::fromGlobalValue(F));
include/llvm/ExecutionEngine/Orc/Core.h 53 using SymbolFlagsMap = DenseMap<SymbolStringPtr, JITSymbolFlags>;
63 SymbolAliasMapEntry(SymbolStringPtr Aliasee, JITSymbolFlags AliasFlags)
67 JITSymbolFlags AliasFlags;
662 SymbolTableEntry(JITSymbolFlags Flags)
667 JITSymbolFlags getFlags() const { return Flags; }
679 void setFlags(JITSymbolFlags Flags) { this->Flags = Flags; }
700 JITSymbolFlags Flags;
include/llvm/ExecutionEngine/Orc/ExecutionUtils.h 214 return JITEvaluatedSymbol(I->second, JITSymbolFlags::Exported);
include/llvm/ExecutionEngine/Orc/GlobalMappingLayer.h 79 return JITSymbol(I->second, JITSymbolFlags::Exported);
include/llvm/ExecutionEngine/Orc/IndirectionUtils.h 263 using StubInitsMap = StringMap<std::pair<JITTargetAddress, JITSymbolFlags>>;
269 JITSymbolFlags StubFlags) = 0;
296 JITSymbolFlags StubFlags) override {
378 JITSymbolFlags StubFlags) {
390 StringMap<std::pair<StubKey, JITSymbolFlags>> StubIndexes;
include/llvm/ExecutionEngine/Orc/LazyEmittingLayer.h 52 JITSymbolFlags Flags = JITSymbolFlags::fromGlobalValue(*GV);
52 JITSymbolFlags Flags = JITSymbolFlags::fromGlobalValue(*GV);
include/llvm/ExecutionEngine/Orc/OrcRemoteTargetClient.h 344 JITSymbolFlags StubFlags) override {
368 auto Flags = I->second.second;
380 auto Flags = I->second.second;
424 JITSymbolFlags StubFlags) {
449 StringMap<std::pair<StubKey, JITSymbolFlags>> StubIndexes;
include/llvm/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.h 85 class SerializationTraits<ChannelT, JITSymbolFlags> {
88 static Error serialize(ChannelT &C, const JITSymbolFlags &Flags) {
92 static Error deserialize(ChannelT &C, JITSymbolFlags &Flags) {
93 JITSymbolFlags::UnderlyingType JITFlags;
94 JITSymbolFlags::TargetFlagsType TargetFlags;
include/llvm/ExecutionEngine/Orc/RPCSerialization.h 40 OStream &operator<<(OStream &OS, const RPCTypeNameSequence<ArgT> &V) {
41 OS << RPCTypeName<ArgT>::getName();
48 operator<<(OStream &OS, const RPCTypeNameSequence<ArgT1, ArgT2, ArgTs...> &V) {
533 static Error serialize(ChannelT &C, const std::pair<T3, T4> &V) {
536 return SerializationTraits<ChannelT, T2, T4>::serialize(C, V.second);
536 return SerializationTraits<ChannelT, T2, T4>::serialize(C, V.second);
539 static Error deserialize(ChannelT &C, std::pair<T3, T4> &V) {
543 return SerializationTraits<ChannelT, T2, T4>::deserialize(C, V.second);
543 return SerializationTraits<ChannelT, T2, T4>::deserialize(C, V.second);
include/llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h 301 auto Flags = JITSymbolFlags::fromObjectSymbol(Symbol);
include/llvm/ExecutionEngine/Orc/RemoteObjectLayer.h 34 using RemoteSymbol = std::pair<RemoteSymbolId, JITSymbolFlags>;
198 auto Flags = Sym.getFlags();
include/llvm/ExecutionEngine/RTDyldMemoryManager.h 101 return JITSymbol(getSymbolAddress(Name), JITSymbolFlags::Exported);
125 JITSymbolFlags::Exported);
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/Error.h 437 static const bool isRef = std::is_reference<T>::value;
439 using wrap = std::reference_wrapper<typename std::remove_reference<T>::type>;
444 using storage_type = typename std::conditional<isRef, wrap, T>::type;
445 using value_type = T;
448 using reference = typename std::remove_reference<T>::type &;
449 using const_reference = const typename std::remove_reference<T>::type &;
450 using pointer = typename std::remove_reference<T>::type *;
451 using const_pointer = const typename std::remove_reference<T>::type *;
474 Expected(OtherT &&Val,
475 typename std::enable_if<std::is_convertible<OtherT, T>::value>::type
475 typename std::enable_if<std::is_convertible<OtherT, T>::value>::type
483 new (getStorage()) storage_type(std::forward<OtherT>(Val));
492 Expected(Expected<OtherT> &&Other,
493 typename std::enable_if<std::is_convertible<OtherT, T>::value>::type
493 typename std::enable_if<std::is_convertible<OtherT, T>::value>::type
594 template <class OtherT> void moveConstruct(Expected<OtherT> &&Other) {
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/ExecutionEngine/MCJIT/MCJIT.cpp 284 JITSymbolFlags::Exported);
384 return JITSymbol(Addr, JITSymbolFlags::Exported);
lib/ExecutionEngine/Orc/CompileOnDemandLayer.cpp 147 auto Flags = JITSymbolFlags::fromGlobalValue(GV);
147 auto Flags = JITSymbolFlags::fromGlobalValue(GV);
291 JITSymbolFlags::fromGlobalValue(*GV);
lib/ExecutionEngine/Orc/Core.cpp 59 bool flagsMatchCLOpts(const JITSymbolFlags &Flags) {
153 raw_ostream &operator<<(raw_ostream &OS, const JITSymbolFlags &Flags) {
381 auto WeakFlags = JITSymbolFlags::Weak | JITSymbolFlags::Common;
381 auto WeakFlags = JITSymbolFlags::Weak | JITSymbolFlags::Common;
914 Symbols[Name].setFlags(Symbols[Name].getFlags() | JITSymbolFlags::HasError);
949 auto Flags = KV.second.getFlags();
950 Flags &= ~(JITSymbolFlags::Weak | JITSymbolFlags::Common);
950 Flags &= ~(JITSymbolFlags::Weak | JITSymbolFlags::Common);
972 JITSymbolFlags ResolvedFlags = ResolvedSym.getFlags();
1164 Sym.setFlags(Sym.getFlags() | JITSymbolFlags::HasError);
1184 JITSymbolFlags::HasError);
lib/ExecutionEngine/Orc/ExecutionUtils.cpp 169 JITSymbolFlags::Exported);
172 JITSymbolFlags::Exported);
217 JITSymbolFlags::Exported);
lib/ExecutionEngine/Orc/IndirectionUtils.cpp 30 : MaterializationUnit(SymbolFlagsMap({{Name, JITSymbolFlags::Exported}}),
39 Result[Name] = JITEvaluatedSymbol(Compile(), JITSymbolFlags::Exported);
lib/ExecutionEngine/Orc/Layer.cpp 38 SymbolFlags[MangledName] = JITSymbolFlags::fromGlobalValue(G);
175 auto SymFlags = JITSymbolFlags::fromObjectSymbol(Sym);
lib/ExecutionEngine/Orc/ObjectLinkingLayer.cpp 93 JITSymbolFlags Flags;
96 Flags |= JITSymbolFlags::Callable;
98 Flags |= JITSymbolFlags::Exported;
112 JITSymbolFlags Flags;
113 Flags |= JITSymbolFlags::Absolute;
115 Flags |= JITSymbolFlags::Callable;
117 Flags |= JITSymbolFlags::Weak;
lib/ExecutionEngine/Orc/OrcCBindingsStack.h 199 JITSymbolFlags::Exported);
277 JITSymbolFlags::Exported);
lib/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.cpp 164 auto Flags = KV.second.getFlags();
lib/ExecutionEngine/Orc/Speculation.cpp 48 JITSymbolFlags::Exported);
51 JITSymbolFlags::Exported);
lib/ExecutionEngine/RuntimeDyld/JITSymbol.cpp 21 JITSymbolFlags llvm::JITSymbolFlags::fromGlobalValue(const GlobalValue &GV) {
22 JITSymbolFlags Flags = JITSymbolFlags::None;
22 JITSymbolFlags Flags = JITSymbolFlags::None;
24 Flags |= JITSymbolFlags::Weak;
26 Flags |= JITSymbolFlags::Common;
28 Flags |= JITSymbolFlags::Exported;
31 Flags |= JITSymbolFlags::Callable;
34 Flags |= JITSymbolFlags::Callable;
39 Expected<JITSymbolFlags>
41 JITSymbolFlags Flags = JITSymbolFlags::None;
41 JITSymbolFlags Flags = JITSymbolFlags::None;
43 Flags |= JITSymbolFlags::Weak;
45 Flags |= JITSymbolFlags::Common;
47 Flags |= JITSymbolFlags::Exported;
54 Flags |= JITSymbolFlags::Callable;
lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp 278 *JITSymFlags &= ~JITSymbolFlags::Weak;
280 *JITSymFlags &= ~JITSymbolFlags::Common;
712 Expected<JITSymbolFlags>
714 return JITSymbolFlags::fromObjectSymbol(SR);
1085 JITSymbolFlags Flags;
lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h 224 SymbolTableEntry(unsigned SectionID, uint64_t Offset, JITSymbolFlags Flags)
231 JITSymbolFlags getFlags() const { return Flags; }
236 JITSymbolFlags Flags = JITSymbolFlags::None;
236 JITSymbolFlags Flags = JITSymbolFlags::None;
364 virtual Expected<JITSymbolFlags> getJITSymbolFlags(const SymbolRef &Sym);
371 JITSymbolFlags Flags) const {
lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldMachOARM.h 36 Expected<JITSymbolFlags> getJITSymbolFlags(const SymbolRef &SR) override {
45 JITSymbolFlags Flags) const override {
tools/lldb/source/Expression/IRExecutionUnit.cpp 1015 llvm::JITSymbolFlags::Exported | llvm::JITSymbolFlags::Weak);
1015 llvm::JITSymbolFlags::Exported | llvm::JITSymbolFlags::Weak);
1017 return llvm::JITSymbol(addr, llvm::JITSymbolFlags::Exported);
tools/lli/lli.cpp 670 return JITSymbol(Addr, JITSymbolFlags::Exported);
tools/llvm-jitlink/llvm-jitlink.cpp 655 JITEvaluatedSymbol AbsDef(Addr, JITSymbolFlags::Exported);
tools/llvm-rtdyld/llvm-rtdyld.cpp 228 return JITSymbol(I->second, JITSymbolFlags::Exported);
unittests/ExecutionEngine/JITLink/MachO_x86_64_Tests.cpp 160 {{"_y", JITEvaluatedSymbol(0xdeadbeef, JITSymbolFlags::Exported)},
161 {"_baz", JITEvaluatedSymbol(0xcafef00d, JITSymbolFlags::Exported)}},
unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp 194 auto BarHiddenFlags = BarSym.getFlags() & ~JITSymbolFlags::Exported;
194 auto BarHiddenFlags = BarSym.getFlags() & ~JITSymbolFlags::Exported;
219 JITSymbolFlags::Exported | JITSymbolFlags::Weak));
219 JITSymbolFlags::Exported | JITSymbolFlags::Weak));
268 cantFail(JD.define(symbolAliases({{Baz, {Foo, JITSymbolFlags::Exported}},
269 {Qux, {Bar, JITSymbolFlags::Weak}}})));
782 {{Foo, JITSymbolFlags::Exported}, {Bar, JITSymbolFlags::Exported}}),
782 {{Foo, JITSymbolFlags::Exported}, {Bar, JITSymbolFlags::Exported}}),
807 JITSymbolFlags WeakExported(JITSymbolFlags::Exported);
807 JITSymbolFlags WeakExported(JITSymbolFlags::Exported);
808 WeakExported |= JITSymbolFlags::Weak;
838 JITSymbolFlags WeakExported(JITSymbolFlags::Exported);
838 JITSymbolFlags WeakExported(JITSymbolFlags::Exported);
839 WeakExported |= JITSymbolFlags::Weak;
842 SymbolFlagsMap({{Foo, JITSymbolFlags::Exported}, {Bar, WeakExported}}),
880 BarSym.setFlags(BarSym.getFlags() | JITSymbolFlags::Weak);
989 SymbolFlagsMap({{Foo, JITSymbolFlags::Exported | JITSymbolFlags::Weak},
989 SymbolFlagsMap({{Foo, JITSymbolFlags::Exported | JITSymbolFlags::Weak},
990 {Bar, JITSymbolFlags::Exported | JITSymbolFlags::Weak}}),
990 {Bar, JITSymbolFlags::Exported | JITSymbolFlags::Weak}}),
1082 SymbolFlagsMap({{Foo, JITSymbolFlags::Exported}}),
1203 JITSymbolFlags WeakExported = JITSymbolFlags::Exported;
1203 JITSymbolFlags WeakExported = JITSymbolFlags::Exported;
1204 WeakExported &= JITSymbolFlags::Weak;
1223 SymbolFlagsMap({{Foo, JITSymbolFlags::Exported}}),
unittests/ExecutionEngine/Orc/GlobalMappingLayerTest.cpp 29 return llvm::JITSymbol(0x4567, JITSymbolFlags::Exported);
unittests/ExecutionEngine/Orc/LazyCallThroughAndReexportsTest.cpp 41 SymbolFlagsMap({{DummyTarget, JITSymbolFlags::Exported}}),
49 JITSymbolFlags::Exported)}}));
unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp 21 BarSym.setFlags(BarSym.getFlags() | JITSymbolFlags::Weak);
71 BarSym.setFlags(BarSym.getFlags() | JITSymbolFlags::Weak);
unittests/ExecutionEngine/Orc/LegacyCompileOnDemandLayerTest.cpp 35 JITSymbolFlags Flags) override {
61 return JITSymbol(1, JITSymbolFlags::Exported);
unittests/ExecutionEngine/Orc/ObjectTransformLayerTest.cpp 83 MockSymbol = llvm::JITSymbol(122, llvm::JITSymbolFlags::None);
84 return llvm::JITSymbol(122, llvm::JITSymbolFlags::None);
104 MockSymbol = llvm::JITSymbol(122, llvm::JITSymbolFlags::None);
105 return llvm::JITSymbol(122, llvm::JITSymbolFlags::None);
unittests/ExecutionEngine/Orc/OrcTestCommon.h 60 JITEvaluatedSymbol(FooAddr, JITSymbolFlags::Exported);
62 JITEvaluatedSymbol(BarAddr, JITSymbolFlags::Exported);
64 JITEvaluatedSymbol(BazAddr, JITSymbolFlags::Exported);
66 JITEvaluatedSymbol(QuxAddr, JITSymbolFlags::Exported);
unittests/ExecutionEngine/Orc/RemoteObjectLayerTest.cpp 355 return JITSymbol(0x12348765, JITSymbolFlags::Exported);
437 return JITSymbol(0x12348765, JITSymbolFlags::Exported);
445 return JITSymbol(0xdeadbeef, JITSymbolFlags::Exported);
usr/include/c++/7.4.0/bits/move.h 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
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)
448 operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
448 operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
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/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
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
762 typename add_rvalue_reference<_Tp>::type declval() noexcept;
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>
1352 : public is_nothrow_assignable<_Tp&, _Tp&&>
1352 : public is_nothrow_assignable<_Tp&, _Tp&&>
1358 : public __is_nt_move_assignable_impl<_Tp>
1377 static void __helper(const _Tp&);
1380 static true_type __test(const _Tp&,
1381 decltype(__helper<const _Tp&>({}))* = 0);
1390 typedef decltype(__test(declval<_Tp>())) type;
1395 : public __is_implicitly_default_constructible_impl<_Tp>::type
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;
1538 typedef decltype(__test<_From, _To>(0)) type;
1545 : public __is_convertible_helper<_From, _To>::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; };
1664 : public __add_rvalue_reference_helper<_Tp>
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;
2171 { typedef _Iffalse type; };
utils/unittest/googletest/include/gtest/gtest-printers.h 140 static void PrintValue(const T& value, ::std::ostream* os) {
205 ::std::basic_ostream<Char, CharTraits>& os, const T& x) {
206 TypeWithoutFormatter<T,
207 (internal::IsAProtocolMessage<T>::value ? kProtobuf :
208 internal::ImplicitlyConvertible<const T&, internal::BiggestInt>::value ?
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) {
utils/unittest/googletest/include/gtest/internal/custom/raw-ostream.h 29 static const T& printable(const T& V) { return V; }
29 static const T& printable(const T& V) { return V; }
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);
utils/unittest/googletest/include/gtest/internal/gtest-internal.h 94 ::std::string PrintToString(const T& value);