reference, declarationdefinition
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 {
  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 {
  456   ArrayRef<T> makeArrayRef(const T *data, size_t length) {
  456   ArrayRef<T> makeArrayRef(const T *data, size_t length) {
  514   MutableArrayRef<T> makeMutableArrayRef(T *data, size_t length) {
  514   MutableArrayRef<T> makeMutableArrayRef(T *data, size_t length) {
include/llvm/Object/COFF.h
  795   const coff_relocation *toRel(DataRefImpl Rel) const;
  936   const coff_relocation *getCOFFRelocation(const RelocationRef &Reloc) const;
 1039   ArrayRef<coff_relocation> getRelocations(const coff_section *Sec) const;
 1231   std::vector<const coff_relocation *> Relocs;
include/llvm/Support/Allocator.h
   81   template <typename T> T *Allocate(size_t Num = 1) {
   82     return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
   82     return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
lib/Object/COFFImportFile.cpp
  193           NumberOfRelocations * sizeof(coff_relocation) +
  222            NumberOfRelocations * sizeof(coff_relocation)),
  238   const coff_relocation RelocationTable[NumberOfRelocations] = {
lib/Object/COFFObjectFile.cpp
   57 static std::error_code getObject(const T *&Obj, MemoryBufferRef M,
   59                                  const uint64_t Size = sizeof(T)) {
  352     const coff_relocation *FirstReloc;
  362 static const coff_relocation *
  375                           sizeof(coff_relocation) * NumRelocs))
  382   const coff_relocation *begin = getFirstReloc(Sec, Data, base());
  392   const coff_relocation *I = getFirstReloc(Sec, Data, base());
 1116 const coff_relocation *COFFObjectFile::toRel(DataRefImpl Rel) const {
 1126   const coff_relocation *R = toRel(Rel);
 1131   const coff_relocation *R = toRel(Rel);
 1145   const coff_relocation* R = toRel(Rel);
 1166 const coff_relocation *
 1171 ArrayRef<coff_relocation>
 1279   const coff_relocation *Reloc = toRel(Rel);
 1769   ArrayRef<coff_relocation> OrigRelocs = Obj->getRelocations(COFFSect);
 1771   for (const coff_relocation &R : OrigRelocs)
 1789   coff_relocation RelocTarget{ulittle32_t(EntryOffset), ulittle32_t(0),
 1800     const coff_relocation &R = **RelocsForOffset.first;
lib/Object/WindowsResource.cpp
  977     auto *Reloc =
  997     CurrentOffset += sizeof(coff_relocation);
tools/lld/COFF/Chunks.cpp
  319                                              const coff_relocation &rel) {
  361     const coff_relocation &rel = relocsData[i];
  424 static uint8_t getBaserelType(const coff_relocation &rel) {
  455     const coff_relocation &rel = relocsData[i];
  551   for (const coff_relocation &rel : getRelocs()) {
tools/lld/COFF/Chunks.h
  186                               symbol_iterator, const coff_relocation *,
  192     symbol_iterator(ObjFile *file, const coff_relocation *i)
  253   ArrayRef<coff_relocation> getRelocs() const {
  258   void setRelocs(ArrayRef<coff_relocation> newRelocs) {
  341   const coff_relocation *relocsData;
tools/lld/COFF/PDB.cpp
 1726     for (const coff_relocation &r : dbgC->getRelocs()) {
tools/lld/COFF/SymbolTable.cpp
  149     for (const coff_relocation &r : sc->getRelocs()) {
tools/lld/COFF/Writer.cpp
  419     ArrayRef<coff_relocation> originalRelocs =
  422       const coff_relocation &rel = originalRelocs[j];
  470     ArrayRef<coff_relocation> curRelocs = sc->getRelocs();
  471     MutableArrayRef<coff_relocation> newRelocs;
  474           bAlloc.Allocate<coff_relocation>(originalRelocs.size()),
  505     ArrayRef<coff_relocation> relocs = sc->getRelocs();
  507       const coff_relocation &rel = relocs[j];
 1557     for (const coff_relocation &reloc : sc->getRelocs()) {
tools/llvm-objcopy/COFF/Object.h
   29   Relocation(const object::coff_relocation& R) : Reloc(R) {}
   31   object::coff_relocation Reloc;
tools/llvm-objcopy/COFF/Reader.cpp
   70     ArrayRef<coff_relocation> Relocs = COFFObj.getRelocations(Sec);
   71     for (const coff_relocation &R : Relocs)
tools/llvm-objcopy/COFF/Writer.cpp
  103     FileSize += S.Relocs.size() * sizeof(coff_relocation);
tools/obj2yaml/coff2yaml.cpp
  198       const object::coff_relocation *reloc = Obj.getCOFFRelocation(Reloc);
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*;
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/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/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*
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;
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;