[COFF] Simplify Chunk::writeTo and remove OutputSectionOff, NFC

[rnk]

Summary

Prior to this change, every implementation of writeTo would add
OutputSectionOff to the output section buffer start before writing data.
Instead, do this math in the caller, so that it can be written once
instead of many times.

The output section offset is always equivalent to the difference between
the chunk RVA and the output section RVA, so we can replace the one
remaining usage of OutputSectionOff with that subtraction.

This doesn't change the size of SectionChunk because of alignment
requirements, but I will rearrange the fields in a follow-up change to
accomplish that.

[ruiu]

LGTM

Nice!

[aganea]

lld/COFF/Chunks.h

126 ↗

(On Diff #198719)

Unrelated to this patch, but do you plan on converting 'Out' to an index as well?

[rnk]

lld/COFF/Chunks.h

126 ↗

(On Diff #198719)

Yes, I think it's necessary. It's tricky though because we create many OutputSections, and then throw away the empty ones, so using indices will necessary mean changing that or coming up with a new concept of "output section instance index". It's an index, but it goes into an Instances array, not the actual final image section index.

lld/trunk/COFF/Chunks.h

public:
   // Whether this section needs to be kept distinct from other sections during
   // ICF. This is set by the driver using address-significance tables.
   bool KeepUnique = false;
 
 protected:
   // The RVA of this chunk in the output. The writer sets a value.
   uint32_t RVA = 0;
 
-public:
-  // The offset from beginning of the output section. The writer sets a value.
-  uint32_t OutputSectionOff = 0;
-
 protected:
   // The output section for this chunk.
   OutputSection *Out = nullptr;
 };
 
 // A chunk corresponding a section of an input file.
 class SectionChunk final : public Chunk {
   // Identical COMDAT Folding feature accesses section internal data.

lld/trunk/COFF/Chunks.cpp

 }
 
 void SectionChunk::writeTo(uint8_t *Buf) const {
   if (!hasData())
     return;
   // Copy section contents from source object file to output file.
   ArrayRef<uint8_t> A = getContents();
   if (!A.empty())
-    memcpy(Buf + OutputSectionOff, A.data(), A.size());
+    memcpy(Buf, A.data(), A.size());
 
   // Apply relocations.
   size_t InputSize = getSize();
   for (size_t I = 0, E = RelocsSize; I < E; I++) {
     const coff_relocation &Rel = RelocsData[I];
 
     // Check for an invalid relocation offset. This check isn't perfect, because
     // we don't have the relocation size, which is only known after checking the
     // machine and relocation type. As a result, a relocation may overwrite the
     // beginning of the following input section.
     if (Rel.VirtualAddress >= InputSize) {
       error("relocation points beyond the end of its parent section");
       continue;
     }
 
-    uint8_t *Off = Buf + OutputSectionOff + Rel.VirtualAddress;
+    uint8_t *Off = Buf + Rel.VirtualAddress;
 
     auto *Sym =
         dyn_cast_or_null<Defined>(File->getSymbol(Rel.SymbolTableIndex));
 
     // Get the output section of the symbol for this relocation.  The output
     // section is needed to compute SECREL and SECTION relocations used in debug
     // info.
     Chunk *C = Sym ? Sym->getChunk() : nullptr;

 }
 
 uint32_t CommonChunk::getOutputCharacteristics() const {
   return IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_MEM_READ |
          IMAGE_SCN_MEM_WRITE;
 }
 
 void StringChunk::writeTo(uint8_t *Buf) const {
-  memcpy(Buf + OutputSectionOff, Str.data(), Str.size());
-  Buf[OutputSectionOff + Str.size()] = '\0';
+  memcpy(Buf, Str.data(), Str.size());
+  Buf[Str.size()] = '\0';
 }
 
 ImportThunkChunkX64::ImportThunkChunkX64(Defined *S) : ImpSymbol(S) {
   // Intel Optimization Manual says that all branch targets
   // should be 16-byte aligned. MSVC linker does this too.
   Alignment = 16;
 }
 
 void ImportThunkChunkX64::writeTo(uint8_t *Buf) const {
-  memcpy(Buf + OutputSectionOff, ImportThunkX86, sizeof(ImportThunkX86));
+  memcpy(Buf, ImportThunkX86, sizeof(ImportThunkX86));
   // The first two bytes is a JMP instruction. Fill its operand.
-  write32le(Buf + OutputSectionOff + 2, ImpSymbol->getRVA() - RVA - getSize());
+  write32le(Buf + 2, ImpSymbol->getRVA() - RVA - getSize());
 }
 
 void ImportThunkChunkX86::getBaserels(std::vector<Baserel> *Res) {
   Res->emplace_back(getRVA() + 2);
 }
 
 void ImportThunkChunkX86::writeTo(uint8_t *Buf) const {
-  memcpy(Buf + OutputSectionOff, ImportThunkX86, sizeof(ImportThunkX86));
+  memcpy(Buf, ImportThunkX86, sizeof(ImportThunkX86));
   // The first two bytes is a JMP instruction. Fill its operand.
-  write32le(Buf + OutputSectionOff + 2,
+  write32le(Buf + 2,
             ImpSymbol->getRVA() + Config->ImageBase);
 }
 
 void ImportThunkChunkARM::getBaserels(std::vector<Baserel> *Res) {
   Res->emplace_back(getRVA(), IMAGE_REL_BASED_ARM_MOV32T);
 }
 
 void ImportThunkChunkARM::writeTo(uint8_t *Buf) const {
-  memcpy(Buf + OutputSectionOff, ImportThunkARM, sizeof(ImportThunkARM));
+  memcpy(Buf, ImportThunkARM, sizeof(ImportThunkARM));
   // Fix mov.w and mov.t operands.
-  applyMOV32T(Buf + OutputSectionOff, ImpSymbol->getRVA() + Config->ImageBase);
+  applyMOV32T(Buf, ImpSymbol->getRVA() + Config->ImageBase);
 }
 
 void ImportThunkChunkARM64::writeTo(uint8_t *Buf) const {
   int64_t Off = ImpSymbol->getRVA() & 0xfff;
-  memcpy(Buf + OutputSectionOff, ImportThunkARM64, sizeof(ImportThunkARM64));
-  applyArm64Addr(Buf + OutputSectionOff, ImpSymbol->getRVA(), RVA, 12);
-  applyArm64Ldr(Buf + OutputSectionOff + 4, Off);
+  memcpy(Buf, ImportThunkARM64, sizeof(ImportThunkARM64));
+  applyArm64Addr(Buf, ImpSymbol->getRVA(), RVA, 12);
+  applyArm64Ldr(Buf + 4, Off);
 }
 
 // A Thumb2, PIC, non-interworking range extension thunk.
 const uint8_t ArmThunk[] = {
     0x40, 0xf2, 0x00, 0x0c, // P:  movw ip,:lower16:S - (P + (L1-P) + 4)
     0xc0, 0xf2, 0x00, 0x0c, //     movt ip,:upper16:S - (P + (L1-P) + 4)
     0xe7, 0x44,             // L1: add  pc, ip
 };
 
 size_t RangeExtensionThunkARM::getSize() const {
   assert(Config->Machine == ARMNT);
   return sizeof(ArmThunk);
 }
 
 void RangeExtensionThunkARM::writeTo(uint8_t *Buf) const {
   assert(Config->Machine == ARMNT);
   uint64_t Offset = Target->getRVA() - RVA - 12;
-  memcpy(Buf + OutputSectionOff, ArmThunk, sizeof(ArmThunk));
-  applyMOV32T(Buf + OutputSectionOff, uint32_t(Offset));
+  memcpy(Buf, ArmThunk, sizeof(ArmThunk));
+  applyMOV32T(Buf, uint32_t(Offset));
 }
 
 // A position independent ARM64 adrp+add thunk, with a maximum range of
 // +/- 4 GB, which is enough for any PE-COFF.
 const uint8_t Arm64Thunk[] = {
     0x10, 0x00, 0x00, 0x90, // adrp x16, Dest
     0x10, 0x02, 0x00, 0x91, // add  x16, x16, :lo12:Dest
     0x00, 0x02, 0x1f, 0xd6, // br   x16
 };
 
 size_t RangeExtensionThunkARM64::getSize() const {
   assert(Config->Machine == ARM64);
   return sizeof(Arm64Thunk);
 }
 
 void RangeExtensionThunkARM64::writeTo(uint8_t *Buf) const {
   assert(Config->Machine == ARM64);
-  memcpy(Buf + OutputSectionOff, Arm64Thunk, sizeof(Arm64Thunk));
-  applyArm64Addr(Buf + OutputSectionOff + 0, Target->getRVA(), RVA, 12);
-  applyArm64Imm(Buf + OutputSectionOff + 4, Target->getRVA() & 0xfff, 0);
+  memcpy(Buf, Arm64Thunk, sizeof(Arm64Thunk));
+  applyArm64Addr(Buf + 0, Target->getRVA(), RVA, 12);
+  applyArm64Imm(Buf + 4, Target->getRVA() & 0xfff, 0);
 }
 
 void LocalImportChunk::getBaserels(std::vector<Baserel> *Res) {
   Res->emplace_back(getRVA());
 }
 
 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);
+    write64le(Buf, Sym->getRVA() + Config->ImageBase);
   } else {
-    write32le(Buf + OutputSectionOff, Sym->getRVA() + Config->ImageBase);
+    write32le(Buf, Sym->getRVA() + Config->ImageBase);
   }
 }
 
 void RVATableChunk::writeTo(uint8_t *Buf) const {
-  ulittle32_t *Begin = reinterpret_cast<ulittle32_t *>(Buf + OutputSectionOff);
+  ulittle32_t *Begin = reinterpret_cast<ulittle32_t *>(Buf);
   size_t Cnt = 0;
   for (const ChunkAndOffset &CO : Syms)
     Begin[Cnt++] = CO.InputChunk->getRVA() + CO.Offset;
   std::sort(Begin, Begin + Cnt);
   assert(std::unique(Begin, Begin + Cnt) == Begin + Cnt &&
          "RVA tables should be de-duplicated");
 }
 
 // MinGW specific, for the "automatic import of variables from DLLs" feature.
 size_t PseudoRelocTableChunk::getSize() const {
   if (Relocs.empty())
     return 0;
   return 12 + 12 * Relocs.size();
 }
 
 // MinGW specific.
 void PseudoRelocTableChunk::writeTo(uint8_t *Buf) const {
   if (Relocs.empty())
     return;
 
-  ulittle32_t *Table = reinterpret_cast<ulittle32_t *>(Buf + OutputSectionOff);
+  ulittle32_t *Table = reinterpret_cast<ulittle32_t *>(Buf);
   // This is the list header, to signal the runtime pseudo relocation v2
   // format.
   Table[0] = 0;
   Table[1] = 0;
   Table[2] = 1;
 
   size_t Idx = 3;
   for (const RuntimePseudoReloc &RPR : Relocs) {
BaserelChunk::BaserelChunk(uint32_t Page, Baserel *Begin, Baserel *End) {
   P += 8;
   for (Baserel *I = Begin; I != End; ++I) {
     write16le(P, (I->Type << 12) | (I->RVA - Page));
     P += 2;
   }
 }
 
 void BaserelChunk::writeTo(uint8_t *Buf) const {
-  memcpy(Buf + OutputSectionOff, Data.data(), Data.size());
+  memcpy(Buf, Data.data(), Data.size());
 }
 
 uint8_t Baserel::getDefaultType() {
   switch (Config->Machine) {
   case AMD64:
   case ARM64:
     return IMAGE_REL_BASED_DIR64;
   case I386:
void MergeChunk::finalizeContents() {
   }
 
   for (SectionChunk *C : Sections) {
     if (!C->Live)
       continue;
     size_t Off = Builder.getOffset(toStringRef(C->getContents()));
     C->setOutputSection(Out);
     C->setRVA(RVA + Off);
-    C->OutputSectionOff = OutputSectionOff + Off;
   }
 }
 
 uint32_t MergeChunk::getOutputCharacteristics() const {
   return IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA;
 }
 
 size_t MergeChunk::getSize() const {
   return Builder.getSize();
 }
 
 void MergeChunk::writeTo(uint8_t *Buf) const {
-  Builder.write(Buf + OutputSectionOff);
+  Builder.write(Buf);
 }
 
 // MinGW specific.
 size_t AbsolutePointerChunk::getSize() const { return Config->Wordsize; }
 
 void AbsolutePointerChunk::writeTo(uint8_t *Buf) const {
   if (Config->is64()) {
-    write64le(Buf + OutputSectionOff, Value);
+    write64le(Buf, Value);
   } else {
-    write32le(Buf + OutputSectionOff, Value);
+    write32le(Buf, Value);
   }
 }
 
 } // namespace coff
 } // namespace lld

lld/trunk/COFF/DLL.cpp

public:
 
   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 {
-    memset(Buf + OutputSectionOff, 0, getSize());
-    write16le(Buf + OutputSectionOff, Hint);
-    memcpy(Buf + OutputSectionOff + 2, Name.data(), Name.size());
+    memset(Buf, 0, getSize());
+    write16le(Buf, Hint);
+    memcpy(Buf + 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 = Config->Wordsize; }
   size_t getSize() const override { return Config->Wordsize; }
 
   void writeTo(uint8_t *Buf) const override {
     if (Config->is64())
-      write64le(Buf + OutputSectionOff, HintName->getRVA());
+      write64le(Buf, HintName->getRVA());
     else
-      write32le(Buf + OutputSectionOff, HintName->getRVA());
+      write32le(Buf, 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 = 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);
+      write64le(Buf, (1ULL << 63) | Ordinal);
     } else {
-      write32le(Buf + OutputSectionOff, (1ULL << 31) | Ordinal);
+      write32le(Buf, (1ULL << 31) | Ordinal);
     }
   }
 
   uint16_t Ordinal;
 };
 
 // A chunk for the import descriptor table.
 class ImportDirectoryChunk : public Chunk {
 public:
   explicit ImportDirectoryChunk(Chunk *N) : DLLName(N) {}
   size_t getSize() const override { return sizeof(ImportDirectoryTableEntry); }
 
   void writeTo(uint8_t *Buf) const override {
-    memset(Buf + OutputSectionOff, 0, getSize());
+    memset(Buf, 0, getSize());
 
-    auto *E = (coff_import_directory_table_entry *)(Buf + OutputSectionOff);
+    auto *E = (coff_import_directory_table_entry *)(Buf);
     E->ImportLookupTableRVA = LookupTab->getRVA();
     E->NameRVA = DLLName->getRVA();
     E->ImportAddressTableRVA = AddressTab->getRVA();
   }
 
   Chunk *DLLName;
   Chunk *LookupTab;
   Chunk *AddressTab;
 };
 
 // A chunk representing null terminator in the import table.
 // Contents of this chunk is always null bytes.
 class NullChunk : public Chunk {
 public:
   explicit NullChunk(size_t N) : Size(N) {}
   bool hasData() const override { return false; }
   size_t getSize() const override { return Size; }
 
   void writeTo(uint8_t *Buf) const override {
-    memset(Buf + OutputSectionOff, 0, Size);
+    memset(Buf, 0, Size);
   }
 
 private:
   size_t Size;
 };
 
 static std::vector<std::vector<DefinedImportData *>>
 binImports(const std::vector<DefinedImportData *> &Imports) {

 public:
   explicit DelayDirectoryChunk(Chunk *N) : DLLName(N) {}
 
   size_t getSize() const override {
     return sizeof(delay_import_directory_table_entry);
   }
 
   void writeTo(uint8_t *Buf) const override {
-    memset(Buf + OutputSectionOff, 0, getSize());
+    memset(Buf, 0, getSize());
 
-    auto *E = (delay_import_directory_table_entry *)(Buf + OutputSectionOff);
+    auto *E = (delay_import_directory_table_entry *)(Buf);
     E->Attributes = 1;
     E->Name = DLLName->getRVA();
     E->ModuleHandle = ModuleHandle->getRVA();
     E->DelayImportAddressTable = AddressTab->getRVA();
     E->DelayImportNameTable = NameTab->getRVA();
   }
 
   Chunk *DLLName;

 class ThunkChunkX64 : public Chunk {
 public:
   ThunkChunkX64(Defined *I, Chunk *D, Defined *H)
       : Imp(I), Desc(D), Helper(H) {}
 
   size_t getSize() const override { return sizeof(ThunkX64); }
 
   void writeTo(uint8_t *Buf) const override {
-    memcpy(Buf + OutputSectionOff, ThunkX64, sizeof(ThunkX64));
-    write32le(Buf + OutputSectionOff + 36, Imp->getRVA() - RVA - 40);
-    write32le(Buf + OutputSectionOff + 43, Desc->getRVA() - RVA - 47);
-    write32le(Buf + OutputSectionOff + 48, Helper->getRVA() - RVA - 52);
+    memcpy(Buf, ThunkX64, sizeof(ThunkX64));
+    write32le(Buf + 36, Imp->getRVA() - RVA - 40);
+    write32le(Buf + 43, Desc->getRVA() - RVA - 47);
+    write32le(Buf + 48, Helper->getRVA() - RVA - 52);
   }
 
   Defined *Imp = nullptr;
   Chunk *Desc = nullptr;
   Defined *Helper = nullptr;
 };
 
 class ThunkChunkX86 : public Chunk {
 public:
   ThunkChunkX86(Defined *I, Chunk *D, Defined *H)
       : Imp(I), Desc(D), Helper(H) {}
 
   size_t getSize() const override { return sizeof(ThunkX86); }
 
   void writeTo(uint8_t *Buf) const override {
-    memcpy(Buf + OutputSectionOff, ThunkX86, sizeof(ThunkX86));
-    write32le(Buf + OutputSectionOff + 3, Imp->getRVA() + Config->ImageBase);
-    write32le(Buf + OutputSectionOff + 8, Desc->getRVA() + Config->ImageBase);
-    write32le(Buf + OutputSectionOff + 13, Helper->getRVA() - RVA - 17);
+    memcpy(Buf, ThunkX86, sizeof(ThunkX86));
+    write32le(Buf + 3, Imp->getRVA() + Config->ImageBase);
+    write32le(Buf + 8, Desc->getRVA() + Config->ImageBase);
+    write32le(Buf + 13, Helper->getRVA() - RVA - 17);
   }
 
   void getBaserels(std::vector<Baserel> *Res) override {
     Res->emplace_back(RVA + 3);
     Res->emplace_back(RVA + 8);
   }
 
   Defined *Imp = nullptr;
   Chunk *Desc = nullptr;
   Defined *Helper = nullptr;
 };
 
 class ThunkChunkARM : public Chunk {
 public:
   ThunkChunkARM(Defined *I, Chunk *D, Defined *H)
       : Imp(I), Desc(D), Helper(H) {}
 
   size_t getSize() const override { return sizeof(ThunkARM); }
 
   void writeTo(uint8_t *Buf) const override {
-    memcpy(Buf + OutputSectionOff, ThunkARM, sizeof(ThunkARM));
-    applyMOV32T(Buf + OutputSectionOff + 0, Imp->getRVA() + Config->ImageBase);
-    applyMOV32T(Buf + OutputSectionOff + 22, Desc->getRVA() + Config->ImageBase);
-    applyBranch24T(Buf + OutputSectionOff + 30, Helper->getRVA() - RVA - 34);
+    memcpy(Buf, ThunkARM, sizeof(ThunkARM));
+    applyMOV32T(Buf + 0, Imp->getRVA() + Config->ImageBase);
+    applyMOV32T(Buf + 22, Desc->getRVA() + Config->ImageBase);
+    applyBranch24T(Buf + 30, Helper->getRVA() - RVA - 34);
   }
 
   void getBaserels(std::vector<Baserel> *Res) override {
     Res->emplace_back(RVA + 0, IMAGE_REL_BASED_ARM_MOV32T);
     Res->emplace_back(RVA + 22, IMAGE_REL_BASED_ARM_MOV32T);
   }
 
   Defined *Imp = nullptr;
   Chunk *Desc = nullptr;
   Defined *Helper = nullptr;
 };
 
 class ThunkChunkARM64 : public Chunk {
 public:
   ThunkChunkARM64(Defined *I, Chunk *D, Defined *H)
       : Imp(I), Desc(D), Helper(H) {}
 
   size_t getSize() const override { return sizeof(ThunkARM64); }
 
   void writeTo(uint8_t *Buf) const override {
-    memcpy(Buf + OutputSectionOff, ThunkARM64, sizeof(ThunkARM64));
-    applyArm64Addr(Buf + OutputSectionOff + 0, Imp->getRVA(), RVA + 0, 12);
-    applyArm64Imm(Buf + OutputSectionOff + 4, Imp->getRVA() & 0xfff, 0);
-    applyArm64Addr(Buf + OutputSectionOff + 52, Desc->getRVA(), RVA + 52, 12);
-    applyArm64Imm(Buf + OutputSectionOff + 56, Desc->getRVA() & 0xfff, 0);
-    applyArm64Branch26(Buf + OutputSectionOff + 60,
-                       Helper->getRVA() - RVA - 60);
+    memcpy(Buf, ThunkARM64, sizeof(ThunkARM64));
+    applyArm64Addr(Buf + 0, Imp->getRVA(), RVA + 0, 12);
+    applyArm64Imm(Buf + 4, Imp->getRVA() & 0xfff, 0);
+    applyArm64Addr(Buf + 52, Desc->getRVA(), RVA + 52, 12);
+    applyArm64Imm(Buf + 56, Desc->getRVA() & 0xfff, 0);
+    applyArm64Branch26(Buf + 60, Helper->getRVA() - RVA - 60);
   }
 
   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 = 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);
+      write64le(Buf, 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)
         Bit = 1;
-      write32le(Buf + OutputSectionOff, (Thunk->getRVA() + Config->ImageBase) | Bit);
+      write32le(Buf, (Thunk->getRVA() + Config->ImageBase) | Bit);
     }
   }
 
   void getBaserels(std::vector<Baserel> *Res) override {
     Res->emplace_back(RVA);
   }
 
   Chunk *Thunk;
ExportDirectoryChunk(int I, int J, Chunk *D, Chunk *A, Chunk *N, Chunk *O)
       : MaxOrdinal(I), NameTabSize(J), DLLName(D), AddressTab(A), NameTab(N),
         OrdinalTab(O) {}
 
   size_t getSize() const override {
     return sizeof(export_directory_table_entry);
   }
 
   void writeTo(uint8_t *Buf) const override {
-    memset(Buf + OutputSectionOff, 0, getSize());
+    memset(Buf, 0, getSize());
 
-    auto *E = (export_directory_table_entry *)(Buf + OutputSectionOff);
+    auto *E = (export_directory_table_entry *)(Buf);
     E->NameRVA = DLLName->getRVA();
     E->OrdinalBase = 0;
     E->AddressTableEntries = MaxOrdinal + 1;
     E->NumberOfNamePointers = NameTabSize;
     E->ExportAddressTableRVA = AddressTab->getRVA();
     E->NamePointerRVA = NameTab->getRVA();
     E->OrdinalTableRVA = OrdinalTab->getRVA();
   }
 
   uint16_t MaxOrdinal;
   uint16_t NameTabSize;
   Chunk *DLLName;
   Chunk *AddressTab;
   Chunk *NameTab;
   Chunk *OrdinalTab;
 };
 
 class AddressTableChunk : public Chunk {
 public:
   explicit AddressTableChunk(size_t MaxOrdinal) : Size(MaxOrdinal + 1) {}
   size_t getSize() const override { return Size * 4; }
 
   void writeTo(uint8_t *Buf) const override {
-    memset(Buf + OutputSectionOff, 0, getSize());
+    memset(Buf, 0, getSize());
 
     for (const Export &E : Config->Exports) {
-      uint8_t *P = Buf + OutputSectionOff + E.Ordinal * 4;
+      uint8_t *P = Buf + E.Ordinal * 4;
       uint32_t Bit = 0;
       // Pointer to thumb code must have the LSB set, so adjust it.
       if (Config->Machine == ARMNT && !E.Data)
         Bit = 1;
       if (E.ForwardChunk) {
         write32le(P, E.ForwardChunk->getRVA() | Bit);
       } else {
         write32le(P, cast<Defined>(E.Sym)->getRVA() | Bit);
       }
     }
   }
 
 private:
   size_t Size;
 };
 
 class NamePointersChunk : public Chunk {
 public:
   explicit NamePointersChunk(std::vector<Chunk *> &V) : Chunks(V) {}
   size_t getSize() const override { return Chunks.size() * 4; }
 
   void writeTo(uint8_t *Buf) const override {
-    uint8_t *P = Buf + OutputSectionOff;
     for (Chunk *C : Chunks) {
-      write32le(P, C->getRVA());
-      P += 4;
+      write32le(Buf, C->getRVA());
+      Buf += 4;
     }
   }
 
 private:
   std::vector<Chunk *> Chunks;
 };
 
 class ExportOrdinalChunk : public Chunk {
 public:
   explicit ExportOrdinalChunk(size_t I) : Size(I) {}
   size_t getSize() const override { return Size * 2; }
 
   void writeTo(uint8_t *Buf) const override {
-    uint8_t *P = Buf + OutputSectionOff;
     for (Export &E : Config->Exports) {
       if (E.Noname)
         continue;
-      write16le(P, E.Ordinal);
-      P += 2;
+      write16le(Buf, E.Ordinal);
+      Buf += 2;
     }
   }
 
 private:
   size_t Size;
 };
 
 } // anonymous namespace

lld/trunk/COFF/PDB.cpp

void PDBLinker::mergeSymbolRecords(ObjFile *File, const CVIndexMap &IndexMap,
   // Add any remaining symbols we've accumulated.
   File->ModuleDBI->addSymbolsInBulk(BulkSymbols);
 }
 
 // Allocate memory for a .debug$S / .debug$F section and relocate it.
 static ArrayRef<uint8_t> relocateDebugChunk(BumpPtrAllocator &Alloc,
                                             SectionChunk &DebugChunk) {
   uint8_t *Buffer = Alloc.Allocate<uint8_t>(DebugChunk.getSize());
-  assert(DebugChunk.OutputSectionOff == 0 &&
+  assert(DebugChunk.getOutputSection() == nullptr &&
          "debug sections should not be in output sections");
   DebugChunk.writeTo(Buffer);
   return makeArrayRef(Buffer, DebugChunk.getSize());
 }
 
 static pdb::SectionContrib createSectionContrib(const Chunk *C, uint32_t Modi) {
   OutputSection *OS = C ? C->getOutputSection() : nullptr;
   pdb::SectionContrib SC;
if (!Mod) {
       FirstMod.setFirstSectionContrib(SC);
 
       // The second module is where the import stream goes.
       Mod = &ExitOnErr(DbiBuilder.addModuleInfo("Import:" + File->DLLName));
       Mod->setObjFileName(LibPath);
     }
 
     DefinedImportThunk *Thunk = cast<DefinedImportThunk>(File->ThunkSym);
+    Chunk *ThunkChunk = Thunk->getChunk();
+    OutputSection *ThunkOS = ThunkChunk->getOutputSection();
 
     ObjNameSym ONS(SymbolRecordKind::ObjNameSym);
     Compile3Sym CS(SymbolRecordKind::Compile3Sym);
     Thunk32Sym TS(SymbolRecordKind::Thunk32Sym);
     ScopeEndSym ES(SymbolRecordKind::ScopeEndSym);
 
     ONS.Name = File->DLLName;
     ONS.Signature = 0;
 
     fillLinkerVerRecord(CS);
 
     TS.Name = Thunk->getName();
     TS.Parent = 0;
     TS.End = 0;
     TS.Next = 0;
     TS.Thunk = ThunkOrdinal::Standard;
-    TS.Length = Thunk->getChunk()->getSize();
-    TS.Segment = Thunk->getChunk()->getOutputSection()->SectionIndex;
-    TS.Offset = Thunk->getChunk()->OutputSectionOff;
+    TS.Length = ThunkChunk->getSize();
+    TS.Segment = ThunkOS->SectionIndex;
+    TS.Offset = ThunkChunk->getRVA() - ThunkOS->getRVA();
 
     Mod->addSymbol(codeview::SymbolSerializer::writeOneSymbol(
         ONS, Alloc, CodeViewContainer::Pdb));
     Mod->addSymbol(codeview::SymbolSerializer::writeOneSymbol(
         CS, Alloc, CodeViewContainer::Pdb));
 
     SmallVector<SymbolScope, 4> Scopes;
     CVSymbol NewSym = codeview::SymbolSerializer::writeOneSymbol(

lld/trunk/COFF/Writer.cpp

public:
   DebugDirectoryChunk(const std::vector<Chunk *> &R, bool WriteRepro)
       : Records(R), WriteRepro(WriteRepro) {}
 
   size_t getSize() const override {
     return (Records.size() + int(WriteRepro)) * sizeof(debug_directory);
   }
 
   void writeTo(uint8_t *B) const override {
-    auto *D = reinterpret_cast<debug_directory *>(B + OutputSectionOff);
+    auto *D = reinterpret_cast<debug_directory *>(B);
 
     for (const Chunk *Record : Records) {
       OutputSection *OS = Record->getOutputSection();
       uint64_t Offs = OS->getFileOff() + (Record->getRVA() - OS->getRVA());
       fillEntry(D, COFF::IMAGE_DEBUG_TYPE_CODEVIEW, Record->getSize(),
                 Record->getRVA(), Offs);
       ++D;
     }

 public:
   size_t getSize() const override {
     return sizeof(codeview::DebugInfo) + Config->PDBAltPath.size() + 1;
   }
 
   void writeTo(uint8_t *B) const override {
     // Save off the DebugInfo entry to backfill the file signature (build id)
     // in Writer::writeBuildId
-    BuildId = reinterpret_cast<codeview::DebugInfo *>(B + OutputSectionOff);
+    BuildId = reinterpret_cast<codeview::DebugInfo *>(B);
 
     // variable sized field (PDB Path)
-    char *P = reinterpret_cast<char *>(B + OutputSectionOff + sizeof(*BuildId));
+    char *P = reinterpret_cast<char *>(B + sizeof(*BuildId));
     if (!Config->PDBAltPath.empty())
       memcpy(P, Config->PDBAltPath.data(), Config->PDBAltPath.size());
     P[Config->PDBAltPath.size()] = '\0';
   }
 
   mutable codeview::DebugInfo *BuildId = nullptr;
 };
 
const bool IsCodeSection =
         (Sec->Header.Characteristics & IMAGE_SCN_MEM_EXECUTE);
     uint32_t Padding = IsCodeSection ? Config->FunctionPadMin : 0;
 
     for (Chunk *C : Sec->Chunks) {
       if (Padding && C->isHotPatchable())
         VirtualSize += Padding;
       VirtualSize = alignTo(VirtualSize, C->Alignment);
       C->setRVA(RVA + VirtualSize);
-      C->OutputSectionOff = VirtualSize;
       C->finalizeContents();
       VirtualSize += C->getSize();
       if (C->hasData())
         RawSize = alignTo(VirtualSize, SectorSize);
     }
     if (VirtualSize > UINT32_MAX)
       error("section larger than 4 GiB: " + Sec->Name);
     Sec->Header.VirtualSize = VirtualSize;
void Writer::writeSections() {
   uint8_t *Buf = Buffer->getBufferStart();
   for (OutputSection *Sec : OutputSections) {
     uint8_t *SecBuf = Buf + Sec->getFileOff();
     // Fill gaps between functions in .text with INT3 instructions
     // instead of leaving as NUL bytes (which can be interpreted as
     // ADD instructions).
     if (Sec->Header.Characteristics & IMAGE_SCN_CNT_CODE)
       memset(SecBuf, 0xCC, Sec->getRawSize());
-    parallelForEach(Sec->Chunks, [&](Chunk *C) { C->writeTo(SecBuf); });
+    parallelForEach(Sec->Chunks, [&](Chunk *C) {
+      C->writeTo(SecBuf + C->getRVA() - Sec->getRVA());
+    });
   }
 }
 
 void Writer::writeBuildId() {
   // There are two important parts to the build ID.
   // 1) If building with debug info, the COFF debug directory contains a
   //    timestamp as well as a Guid and Age of the PDB.
   // 2) In all cases, the PE COFF file header also contains a timestamp.