[COFF] Add ImportChunkThunk, simplify, deduplicate

[rnk]

Summary

Removes the isHotPatchable faux-virtual and virtual methods. Follow-up to
D62362.

[aganea]

Looks good, thanks!

lld/COFF/Chunks.h

177 ↗

(On Diff #201322)

Not a big deal, you could have said using Chunk::Chunk to not duplicate the behavior.

[aganea]

lld/COFF/Chunks.h

177 ↗

(On Diff #201322)

NVM, using Base::Base doesn't inherit default args.

COFF/Chunks.h

 enum : unsigned { Log2MaxSectionAlignment = 13 };
 
 // A Chunk represents a chunk of data that will occupy space in the
 // output (if the resolver chose that). It may or may not be backed by
 // a section of an input file. It could be linker-created data, or
 // doesn't even have actual data (if common or bss).
 class Chunk {
 public:
-  enum Kind : uint8_t { SectionKind, OtherKind };
+  enum Kind : uint8_t { SectionKind, OtherKind, ImportThunkKind };
   Kind kind() const { return ChunkKind; }
 
   // Returns the size of this chunk (even if this is a common or BSS.)
   size_t getSize() const;
 
   // Returns chunk alignment in power of two form. Value values are powers of
   // two from 1 to 8192.
   uint32_t getAlignment() const { return 1U << P2Align; }
public:
   virtual StringRef getSectionName() const {
     llvm_unreachable("unimplemented getSectionName");
   }
 
   // Windows-specific.
   // Collect all locations that contain absolute addresses for base relocations.
   virtual void getBaserels(std::vector<Baserel> *Res) {}
 
-  // Return true if this file has the hotpatch flag set to true in the
-  // S_COMPILE3 record in codeview debug info. Also returns true for some thunks
-  // synthesized by the linker.
-  virtual bool isHotPatchable() const { return false; }
-
   // Returns a human-readable name of this chunk. Chunks are unnamed chunks of
   // bytes, so this is used only for logging or debugging.
   virtual StringRef getDebugName() const { return ""; }
 
-  static bool classof(const Chunk *C) { return C->kind() == OtherKind; }
+  static bool classof(const Chunk *C) { return C->kind() != SectionKind; }
 
 protected:
-  NonSectionChunk() : Chunk(OtherKind) {}
+  NonSectionChunk(Kind K = OtherKind) : Chunk(K) {}
 };
 
 // A chunk corresponding a section of an input file.
 class SectionChunk final : public Chunk {
   // Identical COMDAT Folding feature accesses section internal data.
   friend class ICF;
 
 public:
bool isCodeView() const {
     return getSectionName() == ".debug" || getSectionName().startswith(".debug$");
   }
 
   // True if this is a DWARF debug info or exception handling chunk.
   bool isDWARF() const {
     return getSectionName().startswith(".debug_") || getSectionName() == ".eh_frame";
   }
 
-  bool isHotPatchable() const { return File->HotPatchable; }
-
   // Allow iteration over the bodies of this chunk's relocated symbols.
   llvm::iterator_range<symbol_iterator> symbols() const {
     return llvm::make_range(symbol_iterator(File, RelocsData),
                             symbol_iterator(File, RelocsData + RelocsSize));
   }
 
   ArrayRef<coff_relocation> getRelocs() const {
     return llvm::makeArrayRef(RelocsData, RelocsSize);

 
 inline void Chunk::writeTo(uint8_t *Buf) const {
   if (isa<SectionChunk>(this))
     static_cast<const SectionChunk *>(this)->writeTo(Buf);
   else
     static_cast<const NonSectionChunk *>(this)->writeTo(Buf);
 }
 
-inline bool Chunk::isHotPatchable() const {
-  if (isa<SectionChunk>(this))
-    return static_cast<const SectionChunk *>(this)->isHotPatchable();
-  else
-    return static_cast<const NonSectionChunk *>(this)->isHotPatchable();
-}
-
 inline StringRef Chunk::getSectionName() const {
   if (isa<SectionChunk>(this))
     return static_cast<const SectionChunk *>(this)->getSectionName();
   else
     return static_cast<const NonSectionChunk *>(this)->getSectionName();
 }
 
 inline void Chunk::getBaserels(std::vector<Baserel> *Res) {
static const uint8_t ImportThunkARM64[] = {
     0x10, 0x00, 0x00, 0x90, // adrp x16, #0
     0x10, 0x02, 0x40, 0xf9, // ldr  x16, [x16]
     0x00, 0x02, 0x1f, 0xd6, // br   x16
 };
 
 // Windows-specific.
 // A chunk for DLL import jump table entry. In a final output, its
 // contents will be a JMP instruction to some __imp_ symbol.
-class ImportThunkChunkX64 : public NonSectionChunk {
+class ImportThunkChunk : public NonSectionChunk {
+public:
+  ImportThunkChunk(Defined *S)
+      : NonSectionChunk(ImportThunkKind), ImpSymbol(S) {}
+  static bool classof(const Chunk *C) { return C->kind() == ImportThunkKind; }
+
+protected:
+  Defined *ImpSymbol;
+};
+
+class ImportThunkChunkX64 : public ImportThunkChunk {
 public:
   explicit ImportThunkChunkX64(Defined *S);
   size_t getSize() const override { return sizeof(ImportThunkX86); }
   void writeTo(uint8_t *Buf) const override;
-
-  bool isHotPatchable() const override { return true; }
-
-private:
-  Defined *ImpSymbol;
 };
 
-class ImportThunkChunkX86 : public NonSectionChunk {
+class ImportThunkChunkX86 : public ImportThunkChunk {
 public:
-  explicit ImportThunkChunkX86(Defined *S) : ImpSymbol(S) {
-  }
+  explicit ImportThunkChunkX86(Defined *S) : ImportThunkChunk(S) {}
   size_t getSize() const override { return sizeof(ImportThunkX86); }
   void getBaserels(std::vector<Baserel> *Res) override;
   void writeTo(uint8_t *Buf) const override;
-
-  bool isHotPatchable() const override { return true; }
-
-private:
-  Defined *ImpSymbol;
 };
 
-class ImportThunkChunkARM : public NonSectionChunk {
+class ImportThunkChunkARM : public ImportThunkChunk {
 public:
-  explicit ImportThunkChunkARM(Defined *S) : ImpSymbol(S) {
-  }
+  explicit ImportThunkChunkARM(Defined *S) : ImportThunkChunk(S) {}
   size_t getSize() const override { return sizeof(ImportThunkARM); }
   void getBaserels(std::vector<Baserel> *Res) override;
   void writeTo(uint8_t *Buf) const override;
-
-  bool isHotPatchable() const override { return true; }
-
-private:
-  Defined *ImpSymbol;
 };
 
-class ImportThunkChunkARM64 : public NonSectionChunk {
+class ImportThunkChunkARM64 : public ImportThunkChunk {
 public:
-  explicit ImportThunkChunkARM64(Defined *S) : ImpSymbol(S) {
-  }
+  explicit ImportThunkChunkARM64(Defined *S) : ImportThunkChunk(S) {}
   size_t getSize() const override { return sizeof(ImportThunkARM64); }
   void writeTo(uint8_t *Buf) const override;
-
-  bool isHotPatchable() const override { return true; }
-
-private:
-  Defined *ImpSymbol;
 };
 
 class RangeExtensionThunkARM : public NonSectionChunk {
 public:
   explicit RangeExtensionThunkARM(Defined *T) : Target(T) {}
   size_t getSize() const override;
   void writeTo(uint8_t *Buf) const override;
 
public:
   }
   size_t getSize() const override;
   void writeTo(uint8_t *Buf) const override;
 
 private:
   uint64_t Value;
 };
 
+// Return true if this file has the hotpatch flag set to true in the S_COMPILE3
+// record in codeview debug info. Also returns true for some thunks synthesized
+// by the linker.
+inline bool Chunk::isHotPatchable() const {
+  if (auto *SC = dyn_cast<SectionChunk>(this))
+    return SC->File->HotPatchable;
+  else if (isa<ImportThunkChunk>(this))
+    return true;
+  return false;
+}
+
 void applyMOV32T(uint8_t *Off, uint32_t V);
 void applyBranch24T(uint8_t *Off, int32_t V);
 
 void applyArm64Addr(uint8_t *Off, uint64_t S, uint64_t P, int Shift);
 void applyArm64Imm(uint8_t *Off, uint64_t Imm, uint32_t RangeLimit);
 void applyArm64Branch26(uint8_t *Off, int64_t V);
 
 } // namespace coff

COFF/Chunks.cpp

return IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_MEM_READ |
          IMAGE_SCN_MEM_WRITE;
 }
 
 void StringChunk::writeTo(uint8_t *Buf) const {
   memcpy(Buf, Str.data(), Str.size());
   Buf[Str.size()] = '\0';
 }
 
-ImportThunkChunkX64::ImportThunkChunkX64(Defined *S) : ImpSymbol(S) {
+ImportThunkChunkX64::ImportThunkChunkX64(Defined *S) : ImportThunkChunk(S) {
   // Intel Optimization Manual says that all branch targets
   // should be 16-byte aligned. MSVC linker does this too.
   setAlignment(16);
 }
 
 void ImportThunkChunkX64::writeTo(uint8_t *Buf) const {
   memcpy(Buf, ImportThunkX86, sizeof(ImportThunkX86));
   // The first two bytes is a JMP instruction. Fill its operand.