reference, declarationdefinition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

Declarations

include/llvm/IR/GlobalObject.h
   26 class Comdat;
include/llvm/IR/GlobalValue.h
   34 class Comdat;
include/llvm/Transforms/Instrumentation.h
   30 class Comdat;
lib/AsmParser/LLParser.h
   37   class Comdat;
lib/Bitcode/Writer/ValueEnumerator.h
   31 class Comdat;

References

include/llvm/ADT/DenseMapInfo.h
   39   static inline T* getEmptyKey() {
   41     Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
   45   static inline T* getTombstoneKey() {
   47     Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
   51   static unsigned getHashValue(const T *PtrVal) {
   56   static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
   56   static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
include/llvm/ADT/StringMap.h
  129   ValueTy second;
  134   StringMapEntryStorage(size_t strLen, InitTy &&... InitVals)
  135       : StringMapEntryBase(strLen), second(std::forward<InitTy>(InitVals)...) {}
  138   const ValueTy &getValue() const { return second; }
  139   ValueTy &getValue() { return second; }
  141   void setValue(const ValueTy &V) { second = V; }
  158 class StringMapEntry final : public StringMapEntryStorage<ValueTy> {
  160   using StringMapEntryStorage<ValueTy>::StringMapEntryStorage;
  179                                 InitTy &&... InitVals) {
  192     new (NewItem) StringMapEntry(KeyLength, std::forward<InitTy>(InitVals)...);
  204   static StringMapEntry *Create(StringRef Key, InitType &&... InitVal) {
  246   using MapEntryTy = StringMapEntry<ValueTy>;
  260   StringMap(std::initializer_list<std::pair<StringRef, ValueTy>> List)
  330   using mapped_type = ValueTy;
  331   using value_type = StringMapEntry<ValueTy>;
  334   using const_iterator = StringMapConstIterator<ValueTy>;
  335   using iterator = StringMapIterator<ValueTy>;
  350   iterator_range<StringMapKeyIterator<ValueTy>> keys() const {
  369   ValueTy lookup(StringRef Key) const {
  378   ValueTy &operator[](StringRef Key) { return try_emplace(Key).first->second; }
  413   std::pair<iterator, bool> insert(std::pair<StringRef, ValueTy> KV) {
  432   std::pair<iterator, bool> try_emplace(StringRef Key, ArgsTy &&... Args) {
  441     Bucket = MapEntryTy::Create(Key, Allocator, std::forward<ArgsTy>(Args)...);
  531     : public StringMapIterBase<StringMapConstIterator<ValueTy>,
  532                                const StringMapEntry<ValueTy>> {
  533   using base = StringMapIterBase<StringMapConstIterator<ValueTy>,
  534                                  const StringMapEntry<ValueTy>>;
  542   const StringMapEntry<ValueTy> &operator*() const {
  548 class StringMapIterator : public StringMapIterBase<StringMapIterator<ValueTy>,
  549                                                    StringMapEntry<ValueTy>> {
  551       StringMapIterBase<StringMapIterator<ValueTy>, StringMapEntry<ValueTy>>;
  551       StringMapIterBase<StringMapIterator<ValueTy>, StringMapEntry<ValueTy>>;
  559   StringMapEntry<ValueTy> &operator*() const {
  563   operator StringMapConstIterator<ValueTy>() const {
include/llvm/IR/Comdat.h
   41   Comdat(const Comdat &) = delete;
   42   Comdat(Comdat &&C);
   56   StringMapEntry<Comdat> *Name = nullptr;
   63 inline raw_ostream &operator<<(raw_ostream &OS, const Comdat &C) {
include/llvm/IR/GlobalObject.h
   54   Comdat *ObjComdat;
  120   const Comdat *getComdat() const { return ObjComdat; }
  121   Comdat *getComdat() { return ObjComdat; }
  122   void setComdat(Comdat *C) { ObjComdat = C; }
include/llvm/IR/GlobalValue.h
  230   const Comdat *getComdat() const;
  231   Comdat *getComdat() {
include/llvm/IR/Module.h
   81   using ComdatSymTabType = StringMap<Comdat>;
  466   Comdat *getOrInsertComdat(StringRef Name);
include/llvm/Support/PointerLikeTypeTraits.h
   56   static inline void *getAsVoidPointer(T *P) { return P; }
   57   static inline T *getFromVoidPointer(void *P) { return static_cast<T *>(P); }
   59   enum { NumLowBitsAvailable = detail::ConstantLog2<alignof(T)>::value };
   91   typedef PointerLikeTypeTraits<T *> NonConst;
   93   static inline const void *getAsVoidPointer(const T *P) {
   96   static inline const T *getFromVoidPointer(const void *P) {
include/llvm/Transforms/IPO/GlobalDCE.h
   44   std::unordered_multimap<Comdat *, GlobalValue *> ComdatMembers;
include/llvm/Transforms/IPO/Internalize.h
   47                         const DenseSet<const Comdat *> &ExternalComdats);
   51                              DenseSet<const Comdat *> &ExternalComdats);
include/llvm/Transforms/Instrumentation.h
   48 Comdat *GetOrCreateFunctionComdat(Function &F, Triple &T,
include/llvm/Transforms/Utils/FunctionImportUtils.h
   49   DenseMap<const Comdat *, Comdat *> RenamedComdats;
   49   DenseMap<const Comdat *, Comdat *> RenamedComdats;
lib/AsmParser/LLParser.cpp
  626   Comdat::SelectionKind SK;
  631     SK = Comdat::Any;
  634     SK = Comdat::ExactMatch;
  637     SK = Comdat::Largest;
  640     SK = Comdat::NoDuplicates;
  643     SK = Comdat::SameSize;
  654   Comdat *C;
 1132       Comdat *C;
 1465 Comdat *LLParser::getComdat(const std::string &Name, LocTy Loc) {
 1473   Comdat *C = M->getOrInsertComdat(Name);
 3676 bool LLParser::parseOptionalComdat(StringRef GlobalName, Comdat *&C) {
 5386   Comdat *C;
lib/AsmParser/LLParser.h
  210     Comdat *getComdat(const std::string &Name, LocTy Loc);
  515     bool parseOptionalComdat(StringRef GlobalName, Comdat *&C);
lib/Bitcode/Reader/BitcodeReader.cpp
  500   std::vector<Comdat *> ComdatList;
 1141 static Comdat::SelectionKind getDecodedComdatSelectionKind(unsigned Val) {
 1145     return Comdat::Any;
 1147     return Comdat::ExactMatch;
 1149     return Comdat::Largest;
 1151     return Comdat::NoDuplicates;
 1153     return Comdat::SameSize;
 3062   Comdat::SelectionKind SK = getDecodedComdatSelectionKind(Record[0]);
 3073   Comdat *C = TheModule->getOrInsertComdat(Name);
lib/Bitcode/Writer/BitcodeWriter.cpp
 1062 static unsigned getEncodedComdatSelectionKind(const Comdat &C) {
 1064   case Comdat::Any:
 1066   case Comdat::ExactMatch:
 1068   case Comdat::Largest:
 1070   case Comdat::NoDuplicates:
 1072   case Comdat::SameSize:
 1095   for (const Comdat *C : VE.getComdats()) {
lib/Bitcode/Writer/ValueEnumerator.cpp
  447 unsigned ValueEnumerator::getComdatID(const Comdat *C) const {
  817     if (const Comdat *C = GO->getComdat())
lib/Bitcode/Writer/ValueEnumerator.h
   66   using ComdatSetType = UniqueVector<const Comdat *>;
  226   unsigned getComdatID(const Comdat *C) const;
lib/CodeGen/TargetLoweringObjectFileImpl.cpp
  503 static const Comdat *getELFComdat(const GlobalValue *GV) {
  504   const Comdat *C = GV->getComdat();
  508   if (C->getSelectionKind() != Comdat::Any)
  587   if (const Comdat *C = getELFComdat(GO)) {
  636   if (const Comdat *C = getELFComdat(GO)) {
  716   const Comdat *C = F.getComdat();
  929   const Comdat *C = GV->getComdat();
 1258   const Comdat *C = GV->getComdat();
 1275   if (const Comdat *C = GV->getComdat()) {
 1281       case Comdat::Any:
 1283       case Comdat::ExactMatch:
 1285       case Comdat::Largest:
 1287       case Comdat::NoDuplicates:
 1289       case Comdat::SameSize:
 1421   const Comdat *C = F.getComdat();
 1681 static const Comdat *getWasmComdat(const GlobalValue *GV) {
 1682   const Comdat *C = GV->getComdat();
 1686   if (C->getSelectionKind() != Comdat::Any)
 1717   if (const Comdat *C = getWasmComdat(GO)) {
 1732   if (const Comdat *C = getWasmComdat(GO)) {
lib/IR/AsmWriter.cpp
 2361   SetVector<const Comdat *> Comdats;
 2404   void printComdat(const Comdat *C);
 2460     if (const Comdat *C = GO.getComdat())
 2621   for (const Comdat *C : Comdats) {
 3246   const Comdat *C = GO.getComdat();
 3364 void AssemblyWriter::printComdat(const Comdat *C) {
 4234   case Comdat::Any:
 4237   case Comdat::ExactMatch:
 4240   case Comdat::Largest:
 4243   case Comdat::NoDuplicates:
 4246   case Comdat::SameSize:
lib/IR/Comdat.cpp
   22 Comdat::Comdat(Comdat &&C) : Name(C.Name), SK(C.SK) {}
   44   case Comdat::Any:
   46   case Comdat::ExactMatch:
   48   case Comdat::Largest:
   50   case Comdat::NoDuplicates:
   52   case Comdat::SameSize:
   59   Comdat *Cd = unwrap(C);
   62     Cd->setSelectionKind(Comdat::Any);
   65     Cd->setSelectionKind(Comdat::ExactMatch);
   68     Cd->setSelectionKind(Comdat::Largest);
   71     Cd->setSelectionKind(Comdat::NoDuplicates);
   74     Cd->setSelectionKind(Comdat::SameSize);
lib/IR/Globals.cpp
  175 const Comdat *GlobalValue::getComdat() const {
lib/IR/Module.cpp
  482 Comdat *Module::getOrInsertComdat(StringRef Name) {
lib/IR/Verifier.cpp
  181   void Write(const Comdat *C) {
  383     for (const StringMapEntry<Comdat> &SMEC : M.getComdatSymbolTable())
  409   void visitComdat(const Comdat &C);
 1315 void Verifier::visitComdat(const Comdat &C) {
lib/LTO/LTO.cpp
  640                           std::set<const Comdat *> &NonPrevailingComdats) {
  641   Comdat *C = GV.getComdat();
  709   std::set<const Comdat *> NonPrevailingComdats;
lib/Linker/IRMover.cpp
 1011     if (const Comdat *SC = SGV->getComdat()) {
 1013         Comdat *DC = DstM.getOrInsertComdat(SC->getName());
lib/Linker/LinkModules.cpp
   67                                      Comdat::SelectionKind Src,
   68                                      Comdat::SelectionKind Dst,
   69                                      Comdat::SelectionKind &Result,
   71   std::map<const Comdat *, std::pair<Comdat::SelectionKind, bool>>
   71   std::map<const Comdat *, std::pair<Comdat::SelectionKind, bool>>
   73   bool getComdatResult(const Comdat *SrcC, Comdat::SelectionKind &SK,
   73   bool getComdatResult(const Comdat *SrcC, Comdat::SelectionKind &SK,
   76   DenseMap<const Comdat *, std::vector<GlobalValue *>> LazyComdatMembers;
  104                           const DenseSet<const Comdat *> &ReplacedDstComdats);
  151                                                  Comdat::SelectionKind Src,
  152                                                  Comdat::SelectionKind Dst,
  153                                                  Comdat::SelectionKind &Result,
  158   bool DstAnyOrLargest = Dst == Comdat::SelectionKind::Any ||
  159                          Dst == Comdat::SelectionKind::Largest;
  160   bool SrcAnyOrLargest = Src == Comdat::SelectionKind::Any ||
  161                          Src == Comdat::SelectionKind::Largest;
  163     if (Dst == Comdat::SelectionKind::Largest ||
  164         Src == Comdat::SelectionKind::Largest)
  165       Result = Comdat::SelectionKind::Largest;
  167       Result = Comdat::SelectionKind::Any;
  176   case Comdat::SelectionKind::Any:
  180   case Comdat::SelectionKind::NoDuplicates:
  183   case Comdat::SelectionKind::ExactMatch:
  184   case Comdat::SelectionKind::Largest:
  185   case Comdat::SelectionKind::SameSize: {
  196     if (Result == Comdat::SelectionKind::ExactMatch) {
  201     } else if (Result == Comdat::SelectionKind::Largest) {
  203     } else if (Result == Comdat::SelectionKind::SameSize) {
  218 bool ModuleLinker::getComdatResult(const Comdat *SrcC,
  219                                    Comdat::SelectionKind &Result,
  222   Comdat::SelectionKind SSK = SrcC->getSelectionKind();
  234   const Comdat *DstC = &DstCI->second;
  235   Comdat::SelectionKind DSK = DstC->getSelectionKind();
  380   if (const Comdat *SC = GV.getComdat()) {
  382     Comdat::SelectionKind SK;
  406   const Comdat *SC = GV.getComdat();
  423     GlobalValue &GV, const DenseSet<const Comdat *> &ReplacedDstComdats) {
  424   Comdat *C = GV.getComdat();
  459   DenseSet<const Comdat *> ReplacedDstComdats;
  462     const Comdat &C = SMEC.getValue();
  465     Comdat::SelectionKind SK;
  480     const Comdat *DstC = &DstCI->second;
  503       if (const Comdat *SC = GV.getComdat())
  508       if (const Comdat *SC = SF.getComdat())
  513       if (const Comdat *SC = GA.getComdat())
  532     const Comdat *SC = GV->getComdat();
lib/Object/IRSymtab.cpp
   80   DenseMap<const Comdat *, int> ComdatMap;
  107   Expected<int> getComdatIndex(const Comdat *C, const Module *M);
  166 Expected<int> Builder::getComdatIndex(const Comdat *C, const Module *M) {
  276   if (const Comdat *C = Base->getComdat()) {
lib/Target/X86/X86WinEHState.cpp
  406   if (auto *C = ParentFunc->getComdat())
lib/Transforms/IPO/GlobalDCE.cpp
  150   if (Comdat *C = GV.getComdat()) {
  294     if (Comdat *C = F.getComdat())
  297     if (Comdat *C = GV.getComdat())
  300     if (Comdat *C = GA.getComdat())
lib/Transforms/IPO/GlobalOpt.cpp
 1761     GlobalValue &GV, SmallPtrSetImpl<const Comdat *> &NotDiscardableComdats) {
 1767   if (const Comdat *C = GV.getComdat())
 2251                   SmallPtrSetImpl<const Comdat *> &NotDiscardableComdats) {
 2354                    SmallPtrSetImpl<const Comdat *> &NotDiscardableComdats) {
 2753                       SmallPtrSetImpl<const Comdat *> &NotDiscardableComdats) {
 2917   SmallPtrSet<const Comdat *, 8> NotDiscardableComdats;
 2925       if (const Comdat *C = GV.getComdat())
 2929       if (const Comdat *C = F.getComdat())
 2933       if (const Comdat *C = GA.getComdat())
lib/Transforms/IPO/Internalize.cpp
  113     GlobalValue &GV, const DenseSet<const Comdat *> &ExternalComdats) {
  114   if (Comdat *C = GV.getComdat()) {
  140     GlobalValue &GV, DenseSet<const Comdat *> &ExternalComdats) {
  141   Comdat *C = GV.getComdat();
  157   DenseSet<const Comdat *> ExternalComdats;
lib/Transforms/IPO/ThinLTOBitcodeWriter.cpp
   38   DenseMap<const Comdat *, Comdat *> RenamedComdats;
   38   DenseMap<const Comdat *, Comdat *> RenamedComdats;
   58     if (const auto *C = ExportGV.getComdat())
   74       if (auto *C = GO.getComdat()) {
  252   DenseSet<const Comdat *> MergedMComdats;
  255       if (const auto *C = GV.getComdat())
  276         if (const auto *C = GV->getComdat())
  308     if (const auto *C = GV->getComdat())
lib/Transforms/IPO/WholeProgramDevirt.cpp
  947     if (Comdat *C = TheFn->getComdat()) {
  949         Comdat *NewC = M.getOrInsertComdat(NewName);
lib/Transforms/Instrumentation/AddressSanitizer.cpp
 1834   if (Comdat *C = G->getComdat()) {
 1836     case Comdat::Any:
 1837     case Comdat::ExactMatch:
 1838     case Comdat::NoDuplicates:
 1840     case Comdat::Largest:
 1841     case Comdat::SameSize:
 1983   Comdat *C = G->getComdat();
 2004       C->setSelectionKind(Comdat::NoDuplicates);
lib/Transforms/Instrumentation/HWAddressSanitizer.cpp
  403               Comdat *CtorComdat = M.getOrInsertComdat(kHwasanModuleCtorName);
 1348   Comdat *NoteComdat = M.getOrInsertComdat(kHwasanNoteName);
lib/Transforms/Instrumentation/Instrumentation.cpp
   76 Comdat *llvm::GetOrCreateFunctionComdat(Function &F, Triple &T,
   96   Comdat *C = M->getOrInsertComdat(Name);
   98     C->setSelectionKind(Comdat::NoDuplicates);
lib/Transforms/Instrumentation/MemorySanitizer.cpp
  604         Comdat *MsanCtorComdat = M.getOrInsertComdat(kMsanModuleCtorName);
lib/Transforms/Instrumentation/PGOInstrumentation.cpp
  527   std::unordered_multimap<Comdat *, GlobalValue *> &ComdatMembers;
  568       std::unordered_multimap<Comdat *, GlobalValue *> &ComdatMembers,
  649     std::unordered_multimap<Comdat *, GlobalValue *> &ComdatMembers) {
  660   Comdat *C = F.getComdat();
  682   Comdat *NewComdat;
  696   Comdat *OrigComdat = F.getComdat();
  805     std::unordered_multimap<Comdat *, GlobalValue *> &ComdatMembers,
  956              std::unordered_multimap<Comdat *, GlobalValue *> &ComdatMembers,
 1447     std::unordered_multimap<Comdat *, GlobalValue *> &ComdatMembers) {
 1451     if (Comdat *C = F.getComdat())
 1454     if (Comdat *C = GV.getComdat())
 1457     if (Comdat *C = GA.getComdat())
 1468   std::unordered_multimap<Comdat *, GlobalValue *> ComdatMembers;
 1560   std::unordered_multimap<Comdat *, GlobalValue *> ComdatMembers;
lib/Transforms/Utils/CloneModule.cpp
   22   const Comdat *SC = Src->getComdat();
   25   Comdat *DC = Dst->getParent()->getOrInsertComdat(SC->getName());
lib/Transforms/Utils/FunctionImportUtils.cpp
  271     if (const auto *C = GV.getComdat())
  303       if (auto *C = GO.getComdat()) {
lib/Transforms/Utils/ModuleUtils.cpp
  194   SmallDenseMap<Comdat *, int, 16> ComdatEntriesCovered;
  196     Comdat *C = F->getComdat();
  220       if (Comdat *C = F.getComdat()) {
  226       if (Comdat *C = GV.getComdat()) {
  232       if (Comdat *C = GA.getComdat()) {
lib/Transforms/Utils/SplitModule.cpp
   56 using ComdatMembersType = DenseMap<const Comdat *, const GlobalValue *>;
  119     if (const Comdat *C = GV.getComdat()) {
  234   if (const Comdat *C = GV->getComdat())
lib/Transforms/Utils/SymbolRewriter.cpp
   98   if (Comdat *CD = GO->getComdat()) {
  101     Comdat *C = M.getOrInsertComdat(Target);
tools/clang/lib/CodeGen/CGDeclCXX.cpp
  426   if (llvm::Comdat *C = GV->getComdat())
tools/clang/lib/CodeGen/ItaniumCXXABI.cpp
 2237     llvm::Comdat *C = var->getComdat();
 4012     llvm::Comdat *C = CGM.getModule().getOrInsertComdat(Out.str());
tools/clang/lib/CodeGen/MicrosoftCXXABI.cpp
 1811   llvm::Comdat *C = nullptr;
 1832         C->setSelectionKind(llvm::Comdat::Largest);
 2323     if (llvm::Comdat *C = GV->getComdat())
unittests/Transforms/Utils/CloningTest.cpp
  722     auto *CD = OldM->getOrInsertComdat("comdat");
  723     CD->setSelectionKind(Comdat::ExactMatch);
  856   auto *CD = NewGV->getComdat();
usr/include/c++/7.4.0/bits/functional_hash.h
  106     struct hash<_Tp*> : public __hash_base<size_t, _Tp*>
  109       operator()(_Tp* __p) const noexcept
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,
  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
  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
  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
 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>
 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; };
 1983     { typedef _Up     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;
utils/unittest/googletest/include/gtest/gtest-printers.h
  407                     T* p, ::std::ostream* os) {
  416     if (IsTrue(ImplicitlyConvertible<T*, const void*>::value)) {