[LLD] [COFF] Add and use a Wordsize field in Config. NFCI.

[ruiu]

lld/ELF has Config->Wordsize, so we should add the same variable to COFF.

[mstorsjo]

Made it into a variable named Wordsize.

[ruiu]

LGTM

Thank you for doing this!

COFF/Config.h

87

I wouldn't initialize it if the initial value will never be used.

COFF/Chunks.h

public:
   Defined *Target;
 };
 
 // Windows-specific.
 // See comments for DefinedLocalImport class.
 class LocalImportChunk : public Chunk {
 public:
   explicit LocalImportChunk(Defined *S) : Sym(S) {
-    Alignment = Config->is64() ? 8 : 4;
+    Alignment = Config->Wordsize;
   }
   size_t getSize() const override;
   void getBaserels(std::vector<Baserel> *Res) override;
   void writeTo(uint8_t *Buf) const override;
 
 private:
   Defined *Sym;
 };

COFF/Chunks.cpp

void RangeExtensionThunk::writeTo(uint8_t *Buf) const {
   memcpy(Buf + OutputSectionOff, ArmThunk, sizeof(ArmThunk));
   applyMOV32T(Buf + OutputSectionOff, uint32_t(Offset));
 }
 
 void LocalImportChunk::getBaserels(std::vector<Baserel> *Res) {
   Res->emplace_back(getRVA());
 }
 
-size_t LocalImportChunk::getSize() const {
-  return Config->is64() ? 8 : 4;
-}
+size_t LocalImportChunk::getSize() const { return Config->Wordsize; }
 
 void LocalImportChunk::writeTo(uint8_t *Buf) const {
   if (Config->is64()) {
     write64le(Buf + OutputSectionOff, Sym->getRVA() + Config->ImageBase);
   } else {
     write32le(Buf + OutputSectionOff, Sym->getRVA() + Config->ImageBase);
   }
 }
size_t MergeChunk::getSize() const {
   return Builder.getSize();
 }
 
 void MergeChunk::writeTo(uint8_t *Buf) const {
   Builder.write(Buf + OutputSectionOff);
 }
 
 // MinGW specific.
-size_t AbsolutePointerChunk::getSize() const {
-  return Config->is64() ? 8 : 4;
-}
+size_t AbsolutePointerChunk::getSize() const { return Config->Wordsize; }
 
 void AbsolutePointerChunk::writeTo(uint8_t *Buf) const {
   if (Config->is64()) {
     write64le(Buf + OutputSectionOff, Value);
   } else {
     write32le(Buf + OutputSectionOff, Value);
   }
 }
 
 } // namespace coff
 } // namespace lld

COFF/Config.h

 };
 
 // Global configuration.
 struct Configuration {
   enum ManifestKind { SideBySide, Embed, No };
   bool is64() { return Machine == AMD64 || Machine == ARM64; }
 
   llvm::COFF::MachineTypes Machine = IMAGE_FILE_MACHINE_UNKNOWN;
+  size_t Wordsize = 0;
   bool Verbose = false;
   WindowsSubsystem Subsystem = llvm::COFF::IMAGE_SUBSYSTEM_UNKNOWN;
   Symbol *Entry = nullptr;
   bool NoEntry = false;
   std::string OutputFile;
   std::string ImportName;
   bool DoGC = true;
   bool DoICF = true;

COFF/DLL.cpp

 using namespace llvm::COFF;
 
 namespace lld {
 namespace coff {
 namespace {
 
 // Import table
 
-static int ptrSize() { return Config->is64() ? 8 : 4; }
-
 // A chunk for the import descriptor table.
 class HintNameChunk : public Chunk {
 public:
   HintNameChunk(StringRef N, uint16_t H) : Name(N), Hint(H) {}
 
   size_t getSize() const override {
     // Starts with 2 byte Hint field, followed by a null-terminated string,
     // ends with 0 or 1 byte padding.
     return alignTo(Name.size() + 3, 2);
   }
 
   void writeTo(uint8_t *Buf) const override {
     write16le(Buf + OutputSectionOff, Hint);
     memcpy(Buf + OutputSectionOff + 2, Name.data(), Name.size());
   }
 
 private:
   StringRef Name;
   uint16_t Hint;
 };
 
 // A chunk for the import descriptor table.
 class LookupChunk : public Chunk {
 public:
-  explicit LookupChunk(Chunk *C) : HintName(C) { Alignment = ptrSize(); }
-  size_t getSize() const override { return ptrSize(); }
+  explicit LookupChunk(Chunk *C) : HintName(C) { Alignment = Config->Wordsize; }
+  size_t getSize() const override { return Config->Wordsize; }
 
   void writeTo(uint8_t *Buf) const override {
     write32le(Buf + OutputSectionOff, HintName->getRVA());
   }
 
   Chunk *HintName;
 };
 
 // A chunk for the import descriptor table.
 // This chunk represent import-by-ordinal symbols.
 // See Microsoft PE/COFF spec 7.1. Import Header for details.
 class OrdinalOnlyChunk : public Chunk {
 public:
-  explicit OrdinalOnlyChunk(uint16_t V) : Ordinal(V) { Alignment = ptrSize(); }
-  size_t getSize() const override { return ptrSize(); }
+  explicit OrdinalOnlyChunk(uint16_t V) : Ordinal(V) {
+    Alignment = Config->Wordsize;
+  }
+  size_t getSize() const override { return Config->Wordsize; }
 
   void writeTo(uint8_t *Buf) const override {
     // An import-by-ordinal slot has MSB 1 to indicate that
     // this is import-by-ordinal (and not import-by-name).
     if (Config->is64()) {
       write64le(Buf + OutputSectionOff, (1ULL << 63) | Ordinal);
     } else {
       write32le(Buf + OutputSectionOff, (1ULL << 31) | Ordinal);
public:
   Defined *Imp = nullptr;
   Chunk *Desc = nullptr;
   Defined *Helper = nullptr;
 };
 
 // A chunk for the import descriptor table.
 class DelayAddressChunk : public Chunk {
 public:
-  explicit DelayAddressChunk(Chunk *C) : Thunk(C) { Alignment = ptrSize(); }
-  size_t getSize() const override { return ptrSize(); }
+  explicit DelayAddressChunk(Chunk *C) : Thunk(C) {
+    Alignment = Config->Wordsize;
+  }
+  size_t getSize() const override { return Config->Wordsize; }
 
   void writeTo(uint8_t *Buf) const override {
     if (Config->is64()) {
       write64le(Buf + OutputSectionOff, Thunk->getRVA() + Config->ImageBase);
     } else {
       uint32_t Bit = 0;
       // Pointer to thumb code must have the LSB set, so adjust it.
       if (Config->Machine == ARMNT)
for (DefinedImportData *S : Syms) {
         continue;
       }
       auto *C = make<HintNameChunk>(S->getExternalName(), Ord);
       Lookups.push_back(make<LookupChunk>(C));
       Addresses.push_back(make<LookupChunk>(C));
       Hints.push_back(C);
     }
     // Terminate with null values.
-    Lookups.push_back(make<NullChunk>(ptrSize()));
-    Addresses.push_back(make<NullChunk>(ptrSize()));
+    Lookups.push_back(make<NullChunk>(Config->Wordsize));
+    Addresses.push_back(make<NullChunk>(Config->Wordsize));
 
     for (int I = 0, E = Syms.size(); I < E; ++I)
       Syms[I]->setLocation(Addresses[Base + I]);
 
     // Create the import table header.
     DLLNames.push_back(make<StringChunk>(Syms[0]->getDLLName()));
     auto *Dir = make<ImportDirectoryChunk>(DLLNames.back());
     Dir->LookupTab = Lookups[Base];

COFF/Driver.cpp

     return;
 
   // We should have inferred a machine type by now from the input files, but if
   // not we assume x64.
   if (Config->Machine == IMAGE_FILE_MACHINE_UNKNOWN) {
     warn("/machine is not specified. x64 is assumed");
     Config->Machine = AMD64;
   }
+  Config->Wordsize = Config->is64() ? 8 : 4;
 
   // Input files can be Windows resource files (.res files). We use
   // WindowsResource to convert resource files to a regular COFF file,
   // then link the resulting file normally.
   if (!Resources.empty())
     Symtab->addFile(make<ObjFile>(convertResToCOFF(Resources)));
 
   if (Tar)

COFF/SymbolTable.cpp

bool SymbolTable::handleMinGWAutomaticImport(Symbol *Sym, StringRef Name) {
 
   // There may exist symbols named .refptr.<name> which only consist
   // of a single pointer to <name>. If it turns out <name> is
   // automatically imported, we don't need to keep the .refptr.<name>
   // pointer at all, but redirect all accesses to it to the IAT entry
   // for __imp_<name> instead, and drop the whole .refptr.<name> chunk.
   DefinedRegular *Refptr =
       dyn_cast_or_null<DefinedRegular>(find((".refptr." + Name).str()));
-  size_t PtrSize = Config->is64() ? 8 : 4;
-  if (Refptr && Refptr->getChunk()->getSize() == PtrSize) {
+  if (Refptr && Refptr->getChunk()->getSize() == Config->Wordsize) {
     SectionChunk *SC = dyn_cast_or_null<SectionChunk>(Refptr->getChunk());
     if (SC && SC->Relocs.size() == 1 && *SC->symbols().begin() == Sym) {
       log("Replacing .refptr." + Name + " with " + Imp->getName());
       Refptr->getChunk()->Live = false;
       Refptr->replaceKeepingName(Imp, ImpSize);
     }
   }
   return true;