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

References

include/llvm/ADT/ArrayRef.h
  108         const ArrayRef<U *> &A,
  110            std::is_convertible<U *const *, T const *>::value>::type * = nullptr)
  118       const SmallVectorTemplateCommon<U *, DummyT> &Vec,
  120           std::is_convertible<U *const *, T const *>::value>::type * = nullptr)
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) {
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)
usr/include/c++/7.4.0/bits/allocator.h
  108     class allocator: public __allocator_base<_Tp>
  113       typedef _Tp*       pointer;
  114       typedef const _Tp* const_pointer;
  115       typedef _Tp&       reference;
  116       typedef const _Tp& const_reference;
  117       typedef _Tp        value_type;
  137 	allocator(const allocator<_Tp1>&) throw() { }
usr/include/c++/7.4.0/bits/move.h
   46     inline _GLIBCXX_CONSTEXPR _Tp*
   47     __addressof(_Tp& __r) _GLIBCXX_NOEXCEPT
   72     constexpr _Tp&&
   83     constexpr _Tp&&
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
   97     _Destroy(_Tp* __pointer)
  204 	     allocator<_Tp>&)
usr/include/c++/7.4.0/bits/stl_deque.h
  120 	using __iter = _Deque_iterator<_Tp, _CvTp&, __ptr_to<_CvTp>>;
  122       typedef __iter<_Tp>		iterator;
  123       typedef __iter<const _Tp>		const_iterator;
  124       typedef __ptr_to<_Tp>		_Elt_pointer;
  129       { return __deque_buf_size(sizeof(_Tp)); }
  132       typedef _Tp				value_type;
  267     operator==(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
  268 	       const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) _GLIBCXX_NOEXCEPT
  274     operator==(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
  275 	       const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) _GLIBCXX_NOEXCEPT
  280     operator!=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
  281 	       const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) _GLIBCXX_NOEXCEPT
  287     operator!=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
  288 	       const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) _GLIBCXX_NOEXCEPT
  350     inline typename _Deque_iterator<_Tp, _Ref, _Ptr>::difference_type
  351     operator-(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
  352 	      const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) _GLIBCXX_NOEXCEPT
  355 	(_Deque_iterator<_Tp, _Ref, _Ptr>::_S_buffer_size())
  362     inline typename _Deque_iterator<_Tp, _RefL, _PtrL>::difference_type
  363     operator-(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
  364 	      const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) _GLIBCXX_NOEXCEPT
  464 	rebind<_Tp>::other _Tp_alloc_type;
  487       typedef _Deque_iterator<_Tp, _Tp&, _Ptr>	  iterator;
  487       typedef _Deque_iterator<_Tp, _Tp&, _Ptr>	  iterator;
  488       typedef _Deque_iterator<_Tp, const _Tp&, _Ptr_const>   const_iterator;
  488       typedef _Deque_iterator<_Tp, const _Tp&, _Ptr_const>   const_iterator;
  602 	return _Traits::allocate(_M_impl, __deque_buf_size(sizeof(_Tp)));
  609 	_Traits::deallocate(_M_impl, __p, __deque_buf_size(sizeof(_Tp)));
  684       const size_t __num_nodes = (__num_elements/ __deque_buf_size(sizeof(_Tp))
  715 					% __deque_buf_size(sizeof(_Tp)));
  831     class deque : protected _Deque_base<_Tp, _Alloc>
  842       typedef _Deque_base<_Tp, _Alloc>			_Base;
  848       typedef _Tp					value_type;
  863       { return __deque_buf_size(sizeof(_Tp)); }
 2069 		      const std::allocator<_Tp>&)
usr/include/c++/7.4.0/bits/stl_function.h
  462 	operator()(_Tp&& __t, _Up&& __u) const
  462 	operator()(_Tp&& __t, _Up&& __u) const
usr/include/c++/7.4.0/bits/stl_iterator_base_types.h
  181       typedef _Tp                         value_type;
  183       typedef _Tp*                        pointer;
  184       typedef _Tp&                        reference;
usr/include/c++/7.4.0/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;
  111 	return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
  130       { return size_t(-1) / sizeof(_Tp); }
  135 	construct(_Up* __p, _Args&&... __args)
  136 	{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
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
  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
  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
 1554     { typedef _Tp     type; };
 1558     { 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; };
 1955     { typedef _Tp     type; };
 2171     { typedef _Iffalse type; };
utils/TableGen/CodeGenRegisters.cpp
   85     CodeGenSubRegIndex *A = RegBank.getSubRegIdx(Comps[0]);
   86     CodeGenSubRegIndex *B = RegBank.getSubRegIdx(Comps[1]);
   87     CodeGenSubRegIndex *X = A->addComposite(B, this);
   98     SmallVector<CodeGenSubRegIndex*, 8> IdxParts;
  123     ArrayRef<CodeGenSubRegIndex*> Parts) {
  132   for (SmallVectorImpl<CodeGenSubRegIndex*>::iterator
  134     CodeGenSubRegIndex *SubIdx = *I;
  137     for (CodeGenSubRegIndex *SRI : SubIdx->ConcatenationOf)
  278     CodeGenSubRegIndex *Idx = ExplicitSubRegIndices[i];
  308   SmallVector<CodeGenSubRegIndex*, 8> Indices = ExplicitSubRegIndices;
  310     CodeGenSubRegIndex *Idx = Indices[i];
  311     const CodeGenSubRegIndex::CompMap &Comps = Idx->getComposites();
  317     for (CodeGenSubRegIndex::CompMap::const_iterator I = Comps.begin(),
  349     CodeGenSubRegIndex *Idx = Indices.pop_back_val();
  372     DenseMap<const CodeGenRegister*, CodeGenSubRegIndex*>::iterator Ins =
  396     SmallVector<CodeGenSubRegIndex*, 8> Parts;
  398       CodeGenSubRegIndex &I = *SR->ExplicitSubRegIndices[j];
  404     CodeGenSubRegIndex &Idx = *ExplicitSubRegIndices[i];
  468   std::queue<std::pair<CodeGenSubRegIndex*,CodeGenRegister*>> SubRegQueue;
  469   for (std::pair<CodeGenSubRegIndex*,CodeGenRegister*> P : SubRegs)
  476     CodeGenSubRegIndex *SubRegIdx;
  492       SmallVector<CodeGenSubRegIndex*, 8> Parts;
  498         if (CodeGenSubRegIndex *SubRegIdx = getSubRegIndex(SubReg)) {
  502             for (CodeGenSubRegIndex *SubIdx : SubRegIdx->ConcatenationOf)
  517       CodeGenSubRegIndex *Concat = RegBank.getConcatSubRegIndex(Parts);
  518       std::pair<CodeGenSubRegIndex*,CodeGenRegister*> NewSubReg =
  533     CodeGenSubRegIndex *NewIdx = NewSubRegs[i].first;
  537       CodeGenSubRegIndex *SubIdx = getSubRegIndex(SI->second);
  992     CodeGenRegBank &RegBank, const CodeGenSubRegIndex *SubIdx) const {
 1068 void CodeGenRegisterClass::getSuperRegClasses(const CodeGenSubRegIndex *SubIdx,
 1110   for (auto &Idx : SubRegIndices)
 1152   for (CodeGenSubRegIndex &SRI : SubRegIndices) {
 1211 CodeGenSubRegIndex*
 1217 CodeGenSubRegIndex *CodeGenRegBank::getSubRegIdx(Record *Def) {
 1218   CodeGenSubRegIndex *&Idx = Def2SubRegIdx[Def];
 1269 CodeGenSubRegIndex*
 1270 CodeGenRegBank::getCompositeSubRegIndex(CodeGenSubRegIndex *A,
 1271                                         CodeGenSubRegIndex *B) {
 1273   CodeGenSubRegIndex *Comp = A->compose(B);
 1284 CodeGenSubRegIndex *CodeGenRegBank::
 1285 getConcatSubRegIndex(const SmallVector<CodeGenSubRegIndex *, 8> &Parts) {
 1288   for (CodeGenSubRegIndex *Idx : Parts) {
 1294   CodeGenSubRegIndex *&Idx = ConcatIdx[Parts];
 1327   std::map<const CodeGenSubRegIndex*, RegMap> SubRegAction;
 1330     for (std::pair<const CodeGenSubRegIndex*, const CodeGenRegister*> P : SM)
 1364   using CompositePair = std::pair<const CodeGenSubRegIndex*,
 1365                                   const CodeGenSubRegIndex*>;
 1367   for (const CodeGenSubRegIndex &Idx : SubRegIndices)
 1384       CodeGenSubRegIndex *Idx1 = i1->first;
 1393         CodeGenSubRegIndex *Idx2 = i2->first;
 1399         CodeGenSubRegIndex *Idx3 = Reg1.getSubRegIndex(Reg3);
 1403         if (CodeGenSubRegIndex *Prev = Idx1->addComposite(Idx2, Idx3)) {
 1429   for (auto &Idx : SubRegIndices) {
 1450   for (const auto &Idx : SubRegIndices) {
 1469       for (auto &Idx2 : SubRegIndices) {
 1484         const CodeGenSubRegIndex *Composite = C->second;
 1525   for (const auto &Idx : SubRegIndices) {
 1536     for (const auto &SubRegIndex : SubRegIndices) {
 2057       CodeGenSubRegIndex *SubRegIndex = S->first;
 2170   typedef std::map<const CodeGenSubRegIndex *, CodeGenRegister::Vec,
 2192   for (const auto &SubIdx : SubRegIndices) {
 2226   for (auto &SubIdx : SubRegIndices) {
utils/TableGen/CodeGenRegisters.h
   77     SmallVector<CodeGenSubRegIndex*,4> ConcatenationOf;
   95     typedef std::map<CodeGenSubRegIndex *, CodeGenSubRegIndex *,
   95     typedef std::map<CodeGenSubRegIndex *, CodeGenSubRegIndex *,
  101     CodeGenSubRegIndex *compose(CodeGenSubRegIndex *Idx) const {
  101     CodeGenSubRegIndex *compose(CodeGenSubRegIndex *Idx) const {
  108     CodeGenSubRegIndex *addComposite(CodeGenSubRegIndex *A,
  108     CodeGenSubRegIndex *addComposite(CodeGenSubRegIndex *A,
  109                                      CodeGenSubRegIndex *B) {
  135     void setConcatenationOf(ArrayRef<CodeGenSubRegIndex*> Parts);
  141     bool operator<(const CodeGenSubRegIndex &RHS) const {
  159     typedef std::map<CodeGenSubRegIndex *, CodeGenRegister *,
  193     CodeGenSubRegIndex *getSubRegIndex(const CodeGenRegister *Reg) const {
  268     SmallVector<CodeGenSubRegIndex*, 8> ExplicitSubRegIndices;
  279     DenseMap<const CodeGenRegister*, CodeGenSubRegIndex*> SubReg2Idx;
  310     DenseMap<const CodeGenSubRegIndex *, CodeGenRegisterClass *>
  318     DenseMap<const CodeGenSubRegIndex *, SmallPtrSet<CodeGenRegisterClass *, 8>>
  380     getSubClassWithSubReg(const CodeGenSubRegIndex *SubIdx) const {
  394                                    const CodeGenSubRegIndex *SubIdx) const;
  396     void setSubClassWithSubReg(const CodeGenSubRegIndex *SubIdx,
  403     void getSuperRegClasses(const CodeGenSubRegIndex *SubIdx,
  407     void addSuperRegClass(CodeGenSubRegIndex *SubIdx,
  527     std::deque<CodeGenSubRegIndex> SubRegIndices;
  528     DenseMap<Record*, CodeGenSubRegIndex*> Def2SubRegIdx;
  530     CodeGenSubRegIndex *createSubRegIndex(StringRef Name, StringRef NameSpace);
  532     typedef std::map<SmallVector<CodeGenSubRegIndex*, 8>,
  533                      CodeGenSubRegIndex*> ConcatIdxMap;
  622     const std::deque<CodeGenSubRegIndex> &getSubRegIndices() const {
  627     CodeGenSubRegIndex *getSubRegIdx(Record*);
  630     CodeGenSubRegIndex *getCompositeSubRegIndex(CodeGenSubRegIndex *A,
  630     CodeGenSubRegIndex *getCompositeSubRegIndex(CodeGenSubRegIndex *A,
  631                                                 CodeGenSubRegIndex *B);
  635     CodeGenSubRegIndex *
  636       getConcatSubRegIndex(const SmallVector<CodeGenSubRegIndex *, 8>&);
utils/TableGen/CodeGenTarget.cpp
  303                                     const CodeGenSubRegIndex *SubIdx) const {
utils/TableGen/CodeGenTarget.h
  110                        const CodeGenSubRegIndex *SubIdx) const;
utils/TableGen/GlobalISelEmitter.cpp
 2513   const CodeGenSubRegIndex *SubReg;
 2517                      const CodeGenSubRegIndex *SubReg)
 2636   const CodeGenSubRegIndex *SubRegIdx;
 2639   SubRegIndexRenderer(unsigned InsnID, const CodeGenSubRegIndex *SRI)
 3339   Optional<CodeGenSubRegIndex *>
 4049       CodeGenSubRegIndex *SubIdx = CGRegs.getSubRegIdx(ChildRec);
 4255       CodeGenSubRegIndex *SubIdx = CGRegs.getSubRegIdx(SubRegInit->getDef());
 4291         CodeGenSubRegIndex *SubIdx = CGRegs.getSubRegIdx(SubRegInit->getDef());
 4488   CodeGenSubRegIndex *SubIdx = CGRegs.getSubRegIdx(SubRegInit->getDef());
 4515 Optional<CodeGenSubRegIndex *>
utils/TableGen/RegisterBankEmitter.cpp
  199     for (const auto &SubIdx : RegisterClassHierarchy.getSubRegIndices()) {
utils/TableGen/RegisterInfoEmitter.cpp
  178     for (const auto &Idx : SubRegIndices)
  618 static void printSubRegIndex(raw_ostream &OS, const CodeGenSubRegIndex *Idx) {
  672 static bool combine(const CodeGenSubRegIndex *Idx,
  673                     SmallVectorImpl<CodeGenSubRegIndex*> &Vec) {
  674   const CodeGenSubRegIndex::CompMap &Map = Idx->getComposites();
  676     CodeGenSubRegIndex *&Entry = Vec[I.first->EnumValue - 1];
  683     auto *&Entry = Vec[I.first->EnumValue - 1];
  708   SmallVector<SmallVector<CodeGenSubRegIndex*, 4>, 4> Rows;
  712   for (const auto &Idx : SubRegIndices) {
  771   for (const auto &Idx : SubRegIndices) {
  890   typedef SmallVector<const CodeGenSubRegIndex*, 4> SubRegIdxVec;
  987   for (const auto &Idx : SubRegIndices) {
 1249   for (const auto &Idx : SubRegIndices) {
 1258   for (const auto &Idx : SubRegIndices) {
 1316     typedef std::vector<const CodeGenSubRegIndex*> IdxList;
 1657   for (const CodeGenSubRegIndex &SRI : RegBank.getSubRegIndices()) {
 1668     for (std::pair<CodeGenSubRegIndex*,CodeGenRegister*> P : R.getSubRegs()) {