LLD: COFF: Support x86 file header and relocations

[majnemer]

LGTM

[Eugene.Zelenko]

Committed in r241657.

COFF/Chunks.h

public:
   size_t getSize() const override { return Header->SizeOfRawData; }
   void writeTo(uint8_t *Buf) override;
   bool hasData() const override;
   uint32_t getPermissions() const override;
   StringRef getSectionName() const override { return SectionName; }
   void getBaserels(std::vector<uint32_t> *Res, Defined *ImageBase) override;
   bool isCOMDAT() const;
   void applyRelX64(uint8_t *Off, uint16_t Type, uint64_t S, uint64_t P);
+  void applyRelX86(uint8_t *Off, uint16_t Type, uint64_t S, uint64_t P);
 
   // Called if the garbage collector decides to not include this chunk
   // in a final output. It's supposed to print out a log message to stdout.
   void printDiscardedMessage() const;
 
   // Adds COMDAT associative sections to this COMDAT section. A chunk
   // and its children are treated as a group by the garbage collector.
   void addAssociative(SectionChunk *Child);

COFF/Chunks.cpp

void SectionChunk::applyRelX64(uint8_t *Off, uint16_t Type, uint64_t S,
   case IMAGE_REL_AMD64_REL32_5:  add32(Off, S - P - 9); break;
   case IMAGE_REL_AMD64_SECTION:  add16(Off, Out->getSectionIndex()); break;
   case IMAGE_REL_AMD64_SECREL:   add32(Off, S - Out->getRVA()); break;
   default:
     llvm::report_fatal_error("Unsupported relocation type");
   }
 }
 
+void SectionChunk::applyRelX86(uint8_t *Off, uint16_t Type, uint64_t S,
+                               uint64_t P) {
+  switch (Type) {
+  case IMAGE_REL_I386_ABSOLUTE: break;
+  case IMAGE_REL_I386_DIR32:    add32(Off, S + Config->ImageBase); break;
+  case IMAGE_REL_I386_DIR32NB:  add32(Off, S); break;
+  case IMAGE_REL_I386_REL32:    add32(Off, S - P - 4); break;
+  case IMAGE_REL_I386_SECTION:  add16(Off, Out->getSectionIndex() + 1); break;
+  case IMAGE_REL_I386_SECREL:   add32(Off, S - Out->getRVA()); break;
+  default:
+    llvm::report_fatal_error("Unsupported relocation type");
+  }
+}
+
 void SectionChunk::writeTo(uint8_t *Buf) {
   if (!hasData())
     return;
   // Copy section contents from source object file to output file.
   ArrayRef<uint8_t> A = getContents();
   memcpy(Buf + FileOff, A.data(), A.size());
 
   // Apply relocations.
   for (const coff_relocation &Rel : Relocs) {
     uint8_t *Off = Buf + FileOff + Rel.VirtualAddress;
     SymbolBody *Body = File->getSymbolBody(Rel.SymbolTableIndex)->repl();
     uint64_t S = cast<Defined>(Body)->getRVA();
     uint64_t P = RVA + Rel.VirtualAddress;
+    switch (Config->MachineType) {
+    case IMAGE_FILE_MACHINE_AMD64:
       applyRelX64(Off, Rel.Type, S, P);
+      break;
+    case IMAGE_FILE_MACHINE_I386:
+      applyRelX86(Off, Rel.Type, S, P);
+      break;
+    default:
+      llvm_unreachable("unknown machine type");
+    }
   }
 }
 
 void SectionChunk::addAssociative(SectionChunk *Child) {
   AssocChildren.push_back(Child);
   // Associative sections are live if their parent COMDATs are live,
   // and vice versa, so they are not considered live by themselves.
   Child->Root = false;

COFF/Writer.h

private:
   coff_section Header;
   uint32_t StringTableOff = 0;
   std::vector<Chunk *> Chunks;
 };
 
 // The writer writes a SymbolTable result to a file.
 class Writer {
 public:
-  explicit Writer(SymbolTable *T) : Symtab(T) {}
+  explicit Writer(SymbolTable *T);
   std::error_code write(StringRef Path);
 
 private:
   void markLive();
   void dedupCOMDATs();
   void createSections();
   void createMiscChunks();
   void createImportTables();
   void createExportTable();
   void assignAddresses();
   void removeEmptySections();
   std::error_code openFile(StringRef OutputPath);
-  void writeHeader();
+  template <typename PEHeaderTy> void writeHeader();
   void writeSections();
   void sortExceptionTable();
   void applyRelocations();
 
   OutputSection *findSection(StringRef Name);
   OutputSection *createSection(StringRef Name);
   void addBaserels(OutputSection *Dest);
   void addBaserelBlocks(OutputSection *Dest, std::vector<uint32_t> &V);
 
   uint32_t getSizeOfInitializedData();
   std::map<StringRef, std::vector<DefinedImportData *>> binImports();
 
   SymbolTable *Symtab;
   std::unique_ptr<llvm::FileOutputBuffer> Buffer;
   llvm::SpecificBumpPtrAllocator<OutputSection> CAlloc;
   llvm::SpecificBumpPtrAllocator<BaserelChunk> BAlloc;
   std::vector<OutputSection *> OutputSections;
   IdataContents Idata;
   DelayLoadContents DelayIdata;
   EdataContents Edata;
 
+  bool Is64;
   uint64_t FileSize;
   uint64_t SizeOfImage;
   uint64_t SizeOfHeaders;
 
   std::vector<std::unique_ptr<Chunk>> Chunks;
 };
 
 } // namespace coff
 } // namespace lld
 
 #endif

COFF/Writer.cpp

std::error_code Writer::write(StringRef OutputPath) {
   createImportTables();
   createExportTable();
   if (Config->Relocatable)
     createSection(".reloc");
   assignAddresses();
   removeEmptySections();
   if (auto EC = openFile(OutputPath))
     return EC;
-  writeHeader();
+  if (Is64) {
+    writeHeader<pe32plus_header>();
+  } else {
+    writeHeader<pe32_header>();
+  }
   writeSections();
   sortExceptionTable();
   return Buffer->commit();
 }
 
 void OutputSection::setRVA(uint64_t RVA) {
   Header.VirtualAddress = RVA;
   for (Chunk *C : Chunks)
if (StringTableOff) {
     // If name is too long, write offset into the string table as a name.
     sprintf(Hdr->Name, "/%d", StringTableOff);
   } else {
     assert(Name.size() <= COFF::NameSize);
     strncpy(Hdr->Name, Name.data(), Name.size());
   }
 }
 
+Writer::Writer(SymbolTable *T)
+  : Symtab(T), Is64(Config->MachineType == IMAGE_FILE_MACHINE_AMD64) {}
+
 // Set live bit on for each reachable chunk. Unmarked (unreachable)
 // COMDAT chunks will be ignored in the next step, so that they don't
 // come to the final output file.
 void Writer::markLive() {
   if (!Config->DoGC)
     return;
 
   // We build up a worklist of sections which have been marked as live. We only
void Writer::removeEmptySections() {
   OutputSections.erase(
       std::remove_if(OutputSections.begin(), OutputSections.end(), IsEmpty),
       OutputSections.end());
 }
 
 // Visits all sections to assign incremental, non-overlapping RVAs and
 // file offsets.
 void Writer::assignAddresses() {
-  SizeOfHeaders = RoundUpToAlignment(
-      DOSStubSize + sizeof(PEMagic) + sizeof(coff_file_header) +
-      sizeof(pe32plus_header) +
+  SizeOfHeaders = DOSStubSize + sizeof(PEMagic) + sizeof(coff_file_header) +
       sizeof(data_directory) * NumberfOfDataDirectory +
-      sizeof(coff_section) * OutputSections.size(), PageSize);
+      sizeof(coff_section) * OutputSections.size();
+  SizeOfHeaders += Is64 ? sizeof(pe32plus_header) : sizeof(pe32_header);
+  SizeOfHeaders = RoundUpToAlignment(SizeOfHeaders, PageSize);
   uint64_t RVA = 0x1000; // The first page is kept unmapped.
   uint64_t FileOff = SizeOfHeaders;
   for (OutputSection *Sec : OutputSections) {
     if (Sec->getName() == ".reloc")
       addBaserels(Sec);
     Sec->setRVA(RVA);
     Sec->setFileOffset(FileOff);
     RVA += RoundUpToAlignment(Sec->getVirtualSize(), PageSize);
for (ObjectFile *F : Files) {
     // Try to infer machine type from the magic byte of the object file.
     auto MT = static_cast<MachineTypes>(F->getCOFFObj()->getMachine());
     if (MT != IMAGE_FILE_MACHINE_UNKNOWN)
       return MT;
   }
   return IMAGE_FILE_MACHINE_UNKNOWN;
 }
 
+template <typename PEHeaderTy>
 void Writer::writeHeader() {
   // Write DOS stub
   uint8_t *Buf = Buffer->getBufferStart();
   auto *DOS = reinterpret_cast<dos_header *>(Buf);
   Buf += DOSStubSize;
   DOS->Magic[0] = 'M';
   DOS->Magic[1] = 'Z';
   DOS->AddressOfRelocationTable = sizeof(dos_header);
if (MachineType == IMAGE_FILE_MACHINE_UNKNOWN)
     MachineType = inferMachineType(Symtab->ObjectFiles);
 
   // Write COFF header
   auto *COFF = reinterpret_cast<coff_file_header *>(Buf);
   Buf += sizeof(*COFF);
   COFF->Machine = MachineType;
   COFF->NumberOfSections = OutputSections.size();
   COFF->Characteristics = IMAGE_FILE_EXECUTABLE_IMAGE;
+  if (Is64)
     COFF->Characteristics |= IMAGE_FILE_LARGE_ADDRESS_AWARE;
   if (Config->DLL)
     COFF->Characteristics |= IMAGE_FILE_DLL;
   if (!Config->Relocatable)
     COFF->Characteristics |= IMAGE_FILE_RELOCS_STRIPPED;
   COFF->SizeOfOptionalHeader =
-      sizeof(pe32plus_header) + sizeof(data_directory) * NumberfOfDataDirectory;
+      sizeof(PEHeaderTy) + sizeof(data_directory) * NumberfOfDataDirectory;
 
   // Write PE header
-  auto *PE = reinterpret_cast<pe32plus_header *>(Buf);
+  auto *PE = reinterpret_cast<PEHeaderTy *>(Buf);
   Buf += sizeof(*PE);
-  PE->Magic = PE32Header::PE32_PLUS;
+  PE->Magic = Is64 ? PE32Header::PE32_PLUS : PE32Header::PE32;
   PE->ImageBase = Config->ImageBase;
   PE->SectionAlignment = SectionAlignment;
   PE->FileAlignment = FileAlignment;
   PE->MajorImageVersion = Config->MajorImageVersion;
   PE->MinorImageVersion = Config->MinorImageVersion;
   PE->MajorOperatingSystemVersion = Config->MajorOSVersion;
   PE->MinorOperatingSystemVersion = Config->MinorOSVersion;
   PE->MajorSubsystemVersion = Config->MajorOSVersion;

test/COFF/reloc-x86.test

+# RUN: yaml2obj < %s > %t.obj
+# RUN: lld -flavor link2 /out:%t.exe /entry:main /base:0x400000 %t.obj
+# RUN: llvm-objdump -d %t.exe | FileCheck %s
+
+# CHECK: .text:
+# CHECK:     1000:       a1 00 00 00 00
+# CHECK:     1005:       a1 00 10 40 00
+# CHECK:     100a:       a1 00 10 00 00
+# CHECK:     100f:       a1 ec ff ff ff
+# CHECK:     1014:       a1 00 00 01 00
+# CHECK:     1019:       a1 00 00 00 00
+
+---
+header:
+  Machine:         IMAGE_FILE_MACHINE_I386
+  Characteristics: []
+sections:
+  - Name:            .text
+    Characteristics: [ IMAGE_SCN_CNT_CODE, IMAGE_SCN_MEM_EXECUTE, IMAGE_SCN_MEM_READ ]
+    Alignment:       4096
+    SectionData:     A100000000A100000000A100000000A100000000A100000000A100000000
+    Relocations:
+      - VirtualAddress:  1
+        SymbolName:      main
+        Type:            IMAGE_REL_I386_ABSOLUTE
+      - VirtualAddress:  6
+        SymbolName:      main
+        Type:            IMAGE_REL_I386_DIR32
+      - VirtualAddress:  11
+        SymbolName:      main
+        Type:            IMAGE_REL_I386_DIR32NB
+      - VirtualAddress:  16
+        SymbolName:      main
+        Type:            IMAGE_REL_I386_REL32
+      - VirtualAddress:  23
+        SymbolName:      main
+        Type:            IMAGE_REL_I386_SECTION
+      - VirtualAddress:  26
+        SymbolName:      main
+        Type:            IMAGE_REL_I386_SECREL
+symbols:
+  - Name:            .text
+    Value:           0
+    SectionNumber:   1
+    SimpleType:      IMAGE_SYM_TYPE_NULL
+    ComplexType:     IMAGE_SYM_DTYPE_NULL
+    StorageClass:    IMAGE_SYM_CLASS_STATIC
+    SectionDefinition:
+      Length:          6
+      NumberOfRelocations: 0
+      NumberOfLinenumbers: 0
+      CheckSum:        0
+      Number:          0
+  - Name:            main
+    Value:           0
+    SectionNumber:   1
+    SimpleType:      IMAGE_SYM_TYPE_NULL
+    ComplexType:     IMAGE_SYM_DTYPE_NULL
+    StorageClass:    IMAGE_SYM_CLASS_EXTERNAL
+...