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

Derived Classes

  144 class NonSectionChunk : public Chunk {
  180 class SectionChunk final : public Chunk {

Declarations

   18 class Chunk;

   48 class Chunk;

   18 class Chunk;

   26 class Chunk;

References

  108         const ArrayRef<U *> &A,
  110            std::is_convertible<U *const *, T const *>::value>::type * = nullptr)
  127     ArrayRef(const std::vector<U *, A> &Vec,
  129                  std::is_convertible<U *const *, T const *>::value>::type* = 0)

   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; }

   57   static inline bool doit(const From &Val) {
  104   static inline bool doit(const From *Val) {
  106     return isa_impl<To, From>::doit(*Val);
  263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
  263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
  265   return cast_convert_val<X, Y*,
  266                           typename simplify_type<Y*>::SimpleType>::doit(Val);
  342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
  342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
  366 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type
  367 dyn_cast_or_null(Y *Val) {

   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 };

  380     Chunk *c = sym ? sym->getChunk() : nullptr;

  144 class NonSectionChunk : public Chunk {
  173   static bool classof(const Chunk *c) { return c->kind() != SectionKind; }
  180 class SectionChunk final : public Chunk {
  202   static bool classof(const Chunk *c) { return c->kind() == SectionKind; }
  470   static bool classof(const Chunk *c) { return c->kind() == ImportThunkKind; }
  543   Chunk *inputChunk;
  548       return {llvm::DenseMapInfo<Chunk *>::getEmptyKey(), 0};
  551       return {llvm::DenseMapInfo<Chunk *>::getTombstoneKey(), 0};
  554       return llvm::DenseMapInfo<std::pair<Chunk *, uint32_t>>::getHashValue(

   62   explicit LookupChunk(Chunk *c) : hintName(c) {
   74   Chunk *hintName;
  103   explicit ImportDirectoryChunk(Chunk *n) : dllName(n) {}
  115   Chunk *dllName;
  116   Chunk *lookupTab;
  117   Chunk *addressTab;
  166   explicit DelayDirectoryChunk(Chunk *n) : dllName(n) {}
  183   Chunk *dllName;
  184   Chunk *moduleHandle;
  185   Chunk *addressTab;
  186   Chunk *nameTab;
  296   ThunkChunkX64(Defined *i, Chunk *tm) : imp(i), tailMerge(tm) {}
  307   Chunk *tailMerge = nullptr;
  312   TailMergeChunkX64(Chunk *d, Defined *h) : desc(d), helper(h) {}
  322   Chunk *desc = nullptr;
  328   ThunkChunkX86(Defined *i, Chunk *tm) : imp(i), tailMerge(tm) {}
  343   Chunk *tailMerge = nullptr;
  348   TailMergeChunkX86(Chunk *d, Defined *h) : desc(d), helper(h) {}
  362   Chunk *desc = nullptr;
  368   ThunkChunkARM(Defined *i, Chunk *tm) : imp(i), tailMerge(tm) {}
  383   Chunk *tailMerge = nullptr;
  388   TailMergeChunkARM(Chunk *d, Defined *h) : desc(d), helper(h) {}
  402   Chunk *desc = nullptr;
  408   ThunkChunkARM64(Defined *i, Chunk *tm) : imp(i), tailMerge(tm) {}
  420   Chunk *tailMerge = nullptr;
  425   TailMergeChunkARM64(Chunk *d, Defined *h) : desc(d), helper(h) {}
  436   Chunk *desc = nullptr;
  443   explicit DelayAddressChunk(Chunk *c) : thunk(c) {
  464   Chunk *thunk;
  473   ExportDirectoryChunk(int i, int j, Chunk *d, Chunk *a, Chunk *n, Chunk *o)
  473   ExportDirectoryChunk(int i, int j, Chunk *d, Chunk *a, Chunk *n, Chunk *o)
  473   ExportDirectoryChunk(int i, int j, Chunk *d, Chunk *a, Chunk *n, Chunk *o)
  473   ExportDirectoryChunk(int i, int j, Chunk *d, Chunk *a, Chunk *n, Chunk *o)
  496   Chunk *dllName;
  497   Chunk *addressTab;
  498   Chunk *nameTab;
  499   Chunk *ordinalTab;
  530   explicit NamePointersChunk(std::vector<Chunk *> &v) : chunks(v) {}
  534     for (Chunk *c : chunks) {
  541   std::vector<Chunk *> chunks;
  604 std::vector<Chunk *> DelayLoadContents::getChunks() {
  605   std::vector<Chunk *> v;
  613 std::vector<Chunk *> DelayLoadContents::getDataChunks() {
  614   std::vector<Chunk *> v;
  635     Chunk *tm = newTailMergeChunk(dir);
  637       Chunk *t = newThunkChunk(s, tm);
  671 Chunk *DelayLoadContents::newTailMergeChunk(Chunk *dir) {
  671 Chunk *DelayLoadContents::newTailMergeChunk(Chunk *dir) {
  686 Chunk *DelayLoadContents::newThunkChunk(DefinedImportData *s,
  687                                         Chunk *tailMerge) {
  709   std::vector<Chunk *> names;
  714   std::vector<Chunk *> forwards;

   30   std::vector<Chunk *> dirs;
   31   std::vector<Chunk *> lookups;
   32   std::vector<Chunk *> addresses;
   33   std::vector<Chunk *> hints;
   34   std::vector<Chunk *> dllNames;
   44   std::vector<Chunk *> getChunks();
   45   std::vector<Chunk *> getDataChunks();
   46   ArrayRef<Chunk *> getCodeChunks() { return thunks; }
   52   Chunk *newThunkChunk(DefinedImportData *s, Chunk *tailMerge);
   52   Chunk *newThunkChunk(DefinedImportData *s, Chunk *tailMerge);
   53   Chunk *newTailMergeChunk(Chunk *dir);
   53   Chunk *newTailMergeChunk(Chunk *dir);
   57   std::vector<Chunk *> dirs;
   58   std::vector<Chunk *> moduleHandles;
   59   std::vector<Chunk *> addresses;
   60   std::vector<Chunk *> names;
   61   std::vector<Chunk *> hintNames;
   62   std::vector<Chunk *> thunks;
   63   std::vector<Chunk *> dllNames;
   71   std::vector<Chunk *> chunks;

  881   for (Chunk *c : symtab->getChunks())
 1064     if (Chunk *c = def->getChunk())

   44   void run(ArrayRef<Chunk *> v);
  243 void ICF::run(ArrayRef<Chunk *> vec) {
  248   for (Chunk *c : vec) {
  314 void doICF(ArrayRef<Chunk *> chunks) { ICF().run(chunks); }

   20 void doICF(ArrayRef<Chunk *> chunks);

  139   ArrayRef<Chunk *> getChunks() { return chunks; }
  268   std::vector<Chunk *> chunks;
  321   Chunk *location = nullptr;

  112     for (Chunk *c : sec->chunks) {

   23 void markLive(ArrayRef<Chunk *> chunks) {
   32   for (Chunk *c : chunks)

   20 void markLive(ArrayRef<Chunk *> chunks);

  949 static pdb::SectionContrib createSectionContrib(const Chunk *c, uint32_t modi) {
 1238     ArrayRef<Chunk *> chunks = file->getChunks();
 1241     for (Chunk *c : chunks) {
 1461   const Chunk *firstChunk = *sec->chunks.begin();
 1462   const Chunk *lastChunk = *sec->chunks.rbegin();
 1546     Chunk *thunkChunk = thunk->getChunk();
 1660     for (Chunk *c : os->chunks) {

  145   for (Chunk *c : file->getChunks()) {
  610 Symbol *SymbolTable::addSynthetic(StringRef n, Chunk *c) {
  710 std::vector<Chunk *> SymbolTable::getChunks() {
  711   std::vector<Chunk *> res;
  713     ArrayRef<Chunk *> v = file->getChunks();

   64   std::vector<Chunk *> getChunks();
   85   Symbol *addSynthetic(StringRef n, Chunk *c);
  111   std::vector<Chunk *> localImportChunks;

  113 static Chunk *makeImportThunk(DefinedImportData *s, uint16_t machine) {

  140   Chunk *getChunk();
  245   explicit DefinedSynthetic(StringRef name, Chunk *c)
  255   Chunk *getChunk() { return c; }
  258   Chunk *c;
  323   Chunk *getChunk() { return file->location; }
  324   void setLocation(Chunk *addressTable) { file->location = addressTable; }
  347   Chunk *getChunk() { return data; }
  352   Chunk *data;
  370   Chunk *getChunk() { return data; }
  400 inline Chunk *Defined::getChunk() {

   94   DebugDirectoryChunk(const std::vector<Chunk *> &r, bool writeRepro)
  104     for (const Chunk *record : records) {
  143   const std::vector<Chunk *> &records;
  221   void sortCRTSectionChunks(std::vector<Chunk *> &chunks);
  242   Chunk *importTableStart = nullptr;
  244   Chunk *edataStart = nullptr;
  245   Chunk *edataEnd = nullptr;
  246   Chunk *iatStart = nullptr;
  253   std::vector<Chunk *> debugRecords;
  284   Chunk *firstPdata = nullptr;
  285   Chunk *lastPdata;
  294 void OutputSection::addChunk(Chunk *c) {
  298 void OutputSection::insertChunkAtStart(Chunk *c) {
  373   Chunk *c;
  446         Chunk *thunkChunk = thunk->getChunk();
  499 static bool verifyRanges(const std::vector<Chunk *> chunks) {
  500   for (Chunk *c : chunks) {
  643 static void sortBySectionOrder(std::vector<Chunk *> &chunks) {
  754     for (Chunk *c : importDirs->chunks)
  761     for (Chunk *c : importAddresses->chunks)
  825   for (Chunk *c : symtab->getChunks()) {
  881     for (Chunk *c : pSec->chunks)
  917     for (Chunk *c : symtab->localImportChunks)
  936     for (Chunk *c : debugRecords)
 1006     for (Chunk *c : delayIdata.getChunks())
 1008     for (Chunk *c : delayIdata.getDataChunks())
 1010     for (Chunk *c : delayIdata.getCodeChunks())
 1022     for (Chunk *c : edata.chunks)
 1061     for (Chunk *c : os->chunks)
 1096     Chunk *c = def->getChunk();
 1238     for (Chunk *c : sec->chunks) {
 1491   Chunk *c = s->getChunk();
 1550   for (Chunk *c : file->getChunks()) {
 1685   for (Chunk *c : symtab->getChunks()) {
 1854 void Writer::sortCRTSectionChunks(std::vector<Chunk *> &chunks) {
 1901     for (Chunk *c : sec->chunks)

   31   std::vector<Chunk *> chunks;
   44   void addChunk(Chunk *c);
   45   void insertChunkAtStart(Chunk *c);
   73   std::vector<Chunk *> chunks;
   74   std::vector<Chunk *> origChunks;

 1983     { typedef _Up     type; };