LLD: COFF: Move inferMachineType from Writer to Driver

[ruiu]

Summary

This is very similar to subsystem inference, so it's good to have
these functions in the same file.

[pcc]

LGTM with nits.

COFF/Driver.cpp

239

Preserve the TODO about diagnosing conflicts?

636

Typo: given

[Eugene.Zelenko]

Looks like this patch was abandoned in favor of rL241647.

COFF/Driver.h

private:
   // You can choose one from these four -- {w,}{WinMain,main}.
   // There are four different entry point functions for them,
   // {w,}{WinMain,main}CRTStartup, respectively. The linker needs to
   // choose the right one depending on which "main" function is defined.
   // This function looks up the symbol table and resolve corresponding
   // entry point name.
   StringRef findDefaultEntry();
   WindowsSubsystem inferSubsystem();
+  MachineTypes inferMachineType();
 
   // Driver is the owner of all opened files.
   // InputFiles have MemoryBufferRefs to them.
   std::vector<std::unique_ptr<MemoryBuffer>> OwningMBs;
 };
 
 std::error_code parseModuleDefs(MemoryBufferRef MB);
 std::error_code writeImportLibrary();

COFF/Driver.cpp

 #include "llvm/Support/Path.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <memory>
 
 using namespace llvm;
-using llvm::COFF::IMAGE_SUBSYSTEM_UNKNOWN;
-using llvm::COFF::IMAGE_SUBSYSTEM_WINDOWS_CUI;
-using llvm::COFF::IMAGE_SUBSYSTEM_WINDOWS_GUI;
+using namespace llvm::COFF;
 using llvm::sys::Process;
 using llvm::sys::fs::OpenFlags;
 using llvm::sys::fs::file_magic;
 using llvm::sys::fs::identify_magic;
 
 namespace lld {
 namespace coff {
 
if (Config->DLL)
     return IMAGE_SUBSYSTEM_WINDOWS_GUI;
   if (Symtab.find("main") || Symtab.find("wmain"))
     return IMAGE_SUBSYSTEM_WINDOWS_CUI;
   if (Symtab.find("WinMain") || Symtab.find("wWinMain"))
     return IMAGE_SUBSYSTEM_WINDOWS_GUI;
   return IMAGE_SUBSYSTEM_UNKNOWN;
 }
 
+MachineTypes LinkerDriver::inferMachineType() {
+  for (ObjectFile *F : Symtab.ObjectFiles) {
+    // 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;
+}
+
 bool LinkerDriver::link(llvm::ArrayRef<const char *> ArgsArr) {
   // Needed for LTO.
   llvm::InitializeAllTargetInfos();
   llvm::InitializeAllTargets();
   llvm::InitializeAllTargetMCs();
   llvm::InitializeAllAsmParsers();
   llvm::InitializeAllAsmPrinters();
   llvm::InitializeAllDisassemblers();
bool LinkerDriver::link(llvm::ArrayRef<const char *> ArgsArr) {
   if (Config->Subsystem == IMAGE_SUBSYSTEM_UNKNOWN) {
     Config->Subsystem = inferSubsystem();
     if (Config->Subsystem == IMAGE_SUBSYSTEM_UNKNOWN) {
       llvm::errs() << "subsystem must be defined\n";
       return false;
     }
   }
 
+  // Windows specific -- if no /machine is givne, infer that.
+  if (Config->MachineType == IMAGE_FILE_MACHINE_UNKNOWN) {
+    Config->MachineType = inferMachineType();
+    if (Config->MachineType == IMAGE_FILE_MACHINE_UNKNOWN) {
+      llvm::errs() << "/machine must be specified\n";
+      return false;
+    }
+  }
+
   // Windows specific -- when we are creating a .dll file, we also
   // need to create a .lib file.
   if (!Config->Exports.empty())
     writeImportLibrary();
 
   // Windows specific -- fix up dllexported symbols.
   if (!Config->Exports.empty())
     if (fixupExports())

COFF/Writer.cpp

for (OutputSection *Sec : OutputSections) {
     RVA += RoundUpToAlignment(Sec->getVirtualSize(), PageSize);
     FileOff += RoundUpToAlignment(Sec->getRawSize(), FileAlignment);
   }
   SizeOfImage = SizeOfHeaders + RoundUpToAlignment(RVA - 0x1000, PageSize);
   FileSize = SizeOfHeaders +
              RoundUpToAlignment(FileOff - SizeOfHeaders, FileAlignment);
 }
 
-static MachineTypes
-inferMachineType(const std::vector<ObjectFile *> &Files) {
-  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;
-}
-
 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);
   DOS->AddressOfNewExeHeader = DOSStubSize;
 
   // Write PE magic
   memcpy(Buf, PEMagic, sizeof(PEMagic));
   Buf += sizeof(PEMagic);
 
-  // Determine machine type, infer if needed. TODO: diagnose conflicts.
-  MachineTypes MachineType = Config->MachineType;
-  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->Machine = Config->MachineType;
   COFF->NumberOfSections = OutputSections.size();
   COFF->Characteristics = IMAGE_FILE_EXECUTABLE_IMAGE;
   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 =