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

Declarations

include/llvm/LTO/LTO.h
   35 class BitcodeModule;
include/llvm/LTO/LTOBackend.h
   29 class BitcodeModule;
include/llvm/Object/IRObjectFile.h
   22 class BitcodeModule;
tools/clang/include/clang/CodeGen/BackendUtil.h
   17   class BitcodeModule;

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 {
  290   class LLVM_NODISCARD MutableArrayRef : public ArrayRef<T> {
  292     using iterator = T *;
  302     /*implicit*/ MutableArrayRef(T &OneElt) : ArrayRef<T>(OneElt) {}
  305     /*implicit*/ MutableArrayRef(T *data, size_t length)
  309     MutableArrayRef(T *begin, T *end) : ArrayRef<T>(begin, end) {}
  309     MutableArrayRef(T *begin, T *end) : ArrayRef<T>(begin, end) {}
  312     /*implicit*/ MutableArrayRef(SmallVectorImpl<T> &Vec)
  316     /*implicit*/ MutableArrayRef(std::vector<T> &Vec)
  321     /*implicit*/ constexpr MutableArrayRef(std::array<T, N> &Arr)
  326     /*implicit*/ constexpr MutableArrayRef(T (&Arr)[N]) : ArrayRef<T>(Arr) {}
  328     T *data() const { return const_cast<T*>(ArrayRef<T>::data()); }
  337     T &front() const {
  343     T &back() const {
  350     MutableArrayRef<T> slice(size_t N, size_t M) const {
  356     MutableArrayRef<T> slice(size_t N) const {
  361     MutableArrayRef<T> drop_front(size_t N = 1) const {
  366     MutableArrayRef<T> drop_back(size_t N = 1) const {
  374     MutableArrayRef<T> drop_while(PredicateT Pred) const {
  381     MutableArrayRef<T> drop_until(PredicateT Pred) const {
  386     MutableArrayRef<T> take_front(size_t N = 1) const {
  393     MutableArrayRef<T> take_back(size_t N = 1) const {
  402     MutableArrayRef<T> take_while(PredicateT Pred) const {
  409     MutableArrayRef<T> take_until(PredicateT Pred) const {
  416     T &operator[](size_t Index) const {
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/Bitcode/BitcodeReader.h
  119     std::vector<BitcodeModule> Mods;
  131   Expected<std::vector<BitcodeModule>>
include/llvm/LTO/LTO.h
  113   std::vector<BitcodeModule> Mods;
  178   BitcodeModule &getSingleBitcodeModule();
  339     MapVector<StringRef, BitcodeModule> ModuleMap;
  411   addRegularLTO(BitcodeModule BM, ArrayRef<InputFile::Symbol> Syms,
  416   Error addThinLTO(BitcodeModule BM, ArrayRef<InputFile::Symbol> Syms,
include/llvm/LTO/LTOBackend.h
   47                   MapVector<StringRef, BitcodeModule> &ModuleMap);
include/llvm/Object/IRObjectFile.h
   79   std::vector<BitcodeModule> Mods;
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
  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/ThreadPool.h
   54   inline std::shared_future<void> async(Function &&F, Args &&... ArgList) {
lib/Bitcode/Reader/BitcodeReader.cpp
 6316 Expected<std::vector<BitcodeModule>>
 6622 static Expected<BitcodeModule> getSingleModule(MemoryBufferRef Buffer) {
 6623   Expected<std::vector<BitcodeModule>> MsOrErr = getBitcodeModuleList(Buffer);
 6636   Expected<BitcodeModule> BM = getSingleModule(Buffer);
 6662   Expected<BitcodeModule> BM = getSingleModule(Buffer);
 6696   Expected<BitcodeModule> BM = getSingleModule(Buffer);
 6705   Expected<BitcodeModule> BM = getSingleModule(Buffer);
 6713   Expected<BitcodeModule> BM = getSingleModule(Buffer);
lib/LTO/LTO.cpp
  462 BitcodeModule &InputFile::getSingleBitcodeModule() {
  603   BitcodeModule BM = Input.Mods[ModI];
  662 LTO::addRegularLTO(BitcodeModule BM, ArrayRef<InputFile::Symbol> Syms,
  806 Error LTO::addThinLTO(BitcodeModule BM, ArrayRef<InputFile::Symbol> Syms,
 1042       unsigned Task, BitcodeModule BM,
 1046       MapVector<StringRef, BitcodeModule> &ModuleMap) = 0;
 1080       BitcodeModule BM, ModuleSummaryIndex &CombinedIndex,
 1085       MapVector<StringRef, BitcodeModule> &ModuleMap) {
 1117       unsigned Task, BitcodeModule BM,
 1121       MapVector<StringRef, BitcodeModule> &ModuleMap) override {
 1209       unsigned Task, BitcodeModule BM,
 1213       MapVector<StringRef, BitcodeModule> &ModuleMap) override {
lib/LTO/LTOBackend.cpp
  485                        MapVector<StringRef, BitcodeModule> &ModuleMap) {
lib/LTO/ThinLTOCodeGenerator.cpp
  185   auto &Mod = Input->getSingleBitcodeModule();
  570     auto &M = Mod->getSingleBitcodeModule();
lib/Object/IRObjectFile.cpp
  115   Expected<std::vector<BitcodeModule>> BMsOrErr =
  121   for (auto BM : *BMsOrErr) {
lib/Object/IRSymtab.cpp
  346 static Expected<FileContents> upgrade(ArrayRef<BitcodeModule> BMs) {
  352   for (auto BM : BMs) {
tools/clang/include/clang/CodeGen/BackendUtil.h
   49   llvm::Expected<llvm::BitcodeModule>
   51   llvm::BitcodeModule *
   52   FindThinLTOModule(llvm::MutableArrayRef<llvm::BitcodeModule> BMs);
tools/clang/lib/CodeGen/BackendUtil.cpp
 1339 Expected<BitcodeModule> clang::FindThinLTOModule(MemoryBufferRef MBRef) {
 1340   Expected<std::vector<BitcodeModule>> BMsOrErr = getBitcodeModuleList(MBRef);
 1346   if (const BitcodeModule *Bm = FindThinLTOModule(*BMsOrErr))
 1353 BitcodeModule *clang::FindThinLTOModule(MutableArrayRef<BitcodeModule> BMs) {
 1353 BitcodeModule *clang::FindThinLTOModule(MutableArrayRef<BitcodeModule> BMs) {
 1354   for (BitcodeModule &BM : BMs) {
 1398   MapVector<llvm::StringRef, llvm::BitcodeModule> ModuleMap;
 1409     Expected<BitcodeModule> BMOrErr = FindThinLTOModule(**MBOrErr);
tools/clang/lib/CodeGen/CodeGenAction.cpp
  998     Expected<std::vector<BitcodeModule>> BMsOrErr = getBitcodeModuleList(MBRef);
 1001     BitcodeModule *Bm = FindThinLTOModule(*BMsOrErr);
tools/llvm-cat/llvm-cat.cpp
   63       std::vector<BitcodeModule> Mods = ExitOnErr(getBitcodeModuleList(*MB));
   64       for (auto &BitcodeMod : Mods) {
tools/llvm-lto/llvm-lto.cpp
  492   auto &Mod = File.getSingleBitcodeModule();
tools/llvm-modextract/llvm-modextract.cpp
   45   std::vector<BitcodeModule> Ms = ExitOnErr(getBitcodeModuleList(*MB));
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*;
  474 	construct(allocator_type& __a, _Up* __p, _Args&&... __args)
  474 	construct(allocator_type& __a, _Up* __p, _Args&&... __args)
  475 	{ __a.construct(__p, std::forward<_Args>(__args)...); }
  486 	destroy(allocator_type& __a, _Up* __p)
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() { }
  158     operator!=(const allocator<_T1>&, const allocator<_T2>&)
  158     operator!=(const allocator<_T1>&, const allocator<_T2>&)
  164     operator!=(const allocator<_Tp>&, const allocator<_Tp>&)
  164     operator!=(const allocator<_Tp>&, const allocator<_Tp>&)
usr/include/c++/7.4.0/bits/invoke.h
   59     __invoke_impl(__invoke_other, _Fn&& __f, _Args&&... __args)
   64     __invoke_impl(__invoke_memfun_ref, _MemFun&& __f, _Tp&& __t,
   70     __invoke_impl(__invoke_memfun_deref, _MemFun&& __f, _Tp&& __t,
   89     __invoke(_Callable&& __fn, _Args&&... __args)
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
  104     : public __and_<__not_<is_nothrow_move_constructible<_Tp>>,
  105                     is_copy_constructible<_Tp>>::type { };
usr/include/c++/7.4.0/bits/ptr_traits.h
  126       typedef _Tp* pointer;
  128       typedef _Tp  element_type;
  141       pointer_to(__make_not_void<element_type>& __r) noexcept
  141       pointer_to(__make_not_void<element_type>& __r) noexcept
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)...); }
  204 	     allocator<_Tp>&)
usr/include/c++/7.4.0/bits/stl_iterator.h
 1224     __make_move_if_noexcept_iterator(_Tp* __i)
usr/include/c++/7.4.0/bits/stl_iterator_base_types.h
  123       typedef _Tp        value_type;
  181       typedef _Tp                         value_type;
  183       typedef _Tp*                        pointer;
  184       typedef _Tp&                        reference;
  192       typedef _Tp                         value_type;
  194       typedef const _Tp*                  pointer;
  195       typedef const _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)
  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)
usr/include/c++/7.4.0/bits/stl_uninitialized.h
  288 			   _ForwardIterator __result, allocator<_Tp>&)
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*
  962 	emplace_back(_Args&&... __args);
 1483 	_M_realloc_insert(iterator __position, _Args&&... __args);
 1561 	_Up*
 1562 	_M_data_ptr(_Up* __ptr) const _GLIBCXX_NOEXCEPT
usr/include/c++/7.4.0/bits/vector.tcc
  101 				     std::forward<_Args>(__args)...);
  105 	  _M_realloc_insert(end(), std::forward<_Args>(__args)...);
  418 				   std::forward<_Args>(__args)...);
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;
   84 	new_allocator(const new_allocator<_Tp1>&) _GLIBCXX_USE_NOEXCEPT { }
  111 	return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
  130       { return size_t(-1) / sizeof(_Tp); }
  135 	construct(_Up* __p, _Args&&... __args)
  135 	construct(_Up* __p, _Args&&... __args)
  136 	{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
  136 	{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
  140 	destroy(_Up* __p) { __p->~_Up(); }
  160     operator!=(const new_allocator<_Tp>&, const new_allocator<_Tp>&)
  160     operator!=(const new_allocator<_Tp>&, const new_allocator<_Tp>&)
usr/include/c++/7.4.0/functional
  429 	_CVArg&&
  430 	operator()(_CVArg&& __arg, _Tuple&) const volatile
  460       tuple<_Bound_args...> _M_bound_args;
  514 	using _Res_type = _Res_type_impl<_Functor, _CallArgs, _Bound_args...>;
  524 	  typename __cv_quals<_Bound_args>::type...>;
  528 	explicit _Bind(const _Functor& __f, _Args&&... __args)
  533 	explicit _Bind(_Functor&& __f, _Args&&... __args)
  875     bind(_Func&& __f, _BoundArgs&&... __args)
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/tuple
   56     struct __is_empty_non_tuple : is_empty<_Tp> { };
  125       constexpr _Head_base(const _Head& __h)
  132         constexpr _Head_base(_UHead&& __h)
  133 	: _M_head_impl(std::forward<_UHead>(__h)) { }
  159       static constexpr _Head&
  162       static constexpr const _Head&
  165       _Head _M_head_impl;
  187       private _Head_base<_Idx, _Head>
  192       typedef _Head_base<_Idx, _Head> _Base;
  194       static constexpr _Head&
  197       static constexpr const _Head&
  210       constexpr _Tuple_impl(const _Head& __head, const _Tail&... __tail)
  216         constexpr _Tuple_impl(_UHead&& __head, _UTail&&... __tail)
  227 	_Base(std::forward<_Head>(_M_head(__in))) { }
  230         constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in)
  235         constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
  248 		    const _Head& __head, const _Tail&... __tail)
  473       return __and_<is_constructible<_Elements, const _UElements&>...>::value;
  473       return __and_<is_constructible<_Elements, const _UElements&>...>::value;
  479       return __and_<is_convertible<const _UElements&, _Elements>...>::value;
  479       return __and_<is_convertible<const _UElements&, _Elements>...>::value;
  485       return __and_<is_constructible<_Elements, _UElements&&>...>::value;
  485       return __and_<is_constructible<_Elements, _UElements&&>...>::value;
  491       return __and_<is_convertible<_UElements&&, _Elements>...>::value;
  491       return __and_<is_convertible<_UElements&&, _Elements>...>::value;
  508       return  __not_<is_same<tuple<_Elements...>,
  556     class tuple : public _Tuple_impl<0, _Elements...>
  558       typedef _Tuple_impl<0, _Elements...> _Inherited;
  598             _Elements...>;
  608         constexpr tuple(const _Elements&... __elements)
  619       explicit constexpr tuple(const _Elements&... __elements)
  628                       _Elements...>;
  636                       _Elements...>;
  646         constexpr tuple(_UElements&&... __elements)
  668             _Elements...>;
  730 	      const _Elements&... __elements)
  741                        const _Elements&... __elements)
 1288       typedef _Head type;
 1302     constexpr _Head&
 1303     __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
 1304     { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
 1307     constexpr const _Head&
 1308     __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
 1313     constexpr __tuple_element_t<__i, tuple<_Elements...>>&
 1313     constexpr __tuple_element_t<__i, tuple<_Elements...>>&
 1313     constexpr __tuple_element_t<__i, tuple<_Elements...>>&
 1314     get(tuple<_Elements...>& __t) noexcept
 1319     constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
 1319     constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
 1319     constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
 1320     get(const tuple<_Elements...>& __t) noexcept
 1325     constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
 1325     constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
 1325     constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
 1326     get(tuple<_Elements...>&& __t) noexcept
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
  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
 1215     : public __and_<is_constructible<_Tp, _Args...>,
 1216 		    __is_nt_constructible_impl<_Tp, _Args...>>
 1246     : public is_nothrow_constructible<_Tp, _Tp&&>
 1246     : public is_nothrow_constructible<_Tp, _Tp&&>
 1252     : public __is_nothrow_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>
 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; };
 1558     { typedef _Tp     type; };
 1563     { typedef _Tp     type; };
 1567     { typedef _Tp     type; };
 1574       remove_const<typename remove_volatile<_Tp>::type>::type     type;
 1580     { typedef _Tp const     type; };
 1585     { typedef _Tp volatile     type; };
 1592       add_const<typename add_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; };
 2171     { typedef _Iffalse type; };