[llvm-cvtres] Add support for ARM64

[mstorsjo]

Summary

Also change some default cases into llvm_unreachable in WindowsResourceCOFFWriter, to make it easier to find if they are triggerd from within e.g. lld, which supported ARM64 earlier than llvm-cvtres did.

[rnk]

lgtm

lib/Object/WindowsResource.cpp

449

I think we can sink this out, the switch is basically just a glorified assertion at this point.

[mstorsjo]

lib/Object/WindowsResource.cpp

449

So just skip the whole switch and assert altogether and just make it all a plain Header->Machine = MachineType;? Sounds good to me.

[ruiu]

LGTM

lib/Object/WindowsResource.cpp

std::unique_ptr<MemoryBuffer> WindowsResourceCOFFWriter::write() {
   return std::move(OutputBuffer);
 }
 
 void WindowsResourceCOFFWriter::writeCOFFHeader() {
   // Write the COFF header.
   auto *Header = reinterpret_cast<coff_file_header *>(BufferStart);
   switch (MachineType) {
   case COFF::IMAGE_FILE_MACHINE_ARMNT:
-    Header->Machine = COFF::IMAGE_FILE_MACHINE_ARMNT;
-    break;
   case COFF::IMAGE_FILE_MACHINE_AMD64:
-    Header->Machine = COFF::IMAGE_FILE_MACHINE_AMD64;
-    break;
   case COFF::IMAGE_FILE_MACHINE_I386:
-    Header->Machine = COFF::IMAGE_FILE_MACHINE_I386;
+  case COFF::IMAGE_FILE_MACHINE_ARM64:
+    Header->Machine = MachineType;
     break;
   default:
-    Header->Machine = COFF::IMAGE_FILE_MACHINE_UNKNOWN;
+    llvm_unreachable("unknown machine type");
   }
   Header->NumberOfSections = 2;
   Header->TimeDateStamp = getTime();
   Header->PointerToSymbolTable = SymbolTableOffset;
   // One symbol for every resource plus 2 for each section and @feat.00
   Header->NumberOfSymbols = Data.size() + 5;
   Header->SizeOfOptionalHeader = 0;
   Header->Characteristics = COFF::IMAGE_FILE_32BIT_MACHINE;
case COFF::IMAGE_FILE_MACHINE_ARMNT:
       Reloc->Type = COFF::IMAGE_REL_ARM_ADDR32NB;
       break;
     case COFF::IMAGE_FILE_MACHINE_AMD64:
       Reloc->Type = COFF::IMAGE_REL_AMD64_ADDR32NB;
       break;
     case COFF::IMAGE_FILE_MACHINE_I386:
       Reloc->Type = COFF::IMAGE_REL_I386_DIR32NB;
       break;
+    case COFF::IMAGE_FILE_MACHINE_ARM64:
+      Reloc->Type = COFF::IMAGE_REL_ARM64_ADDR32NB;
+      break;
     default:
-      Reloc->Type = 0;
+      llvm_unreachable("unknown machine type");
     }
     CurrentOffset += sizeof(coff_relocation);
   }
 }
 
 Expected<std::unique_ptr<MemoryBuffer>>
 writeWindowsResourceCOFF(COFF::MachineTypes MachineType,
                          const WindowsResourceParser &Parser) {

test/tools/llvm-cvtres/machine.test

 RUN: llvm-readobj -h -relocations %t | FileCheck %s -check-prefix=X86
 
 RUN: llvm-cvtres /machine:X64 /out:%t %p/Inputs/test_resource.res
 RUN: llvm-readobj -h -relocations %t | FileCheck %s -check-prefix=X64
 
 RUN: llvm-cvtres /machine:ARM /out:%t %p/Inputs/test_resource.res
 RUN: llvm-readobj -h -relocations %t | FileCheck %s -check-prefix=ARM
 
+RUN: llvm-cvtres /machine:ARM64 /out:%t %p/Inputs/test_resource.res
+RUN: llvm-readobj -h -relocations %t | FileCheck %s -check-prefix=ARM64
+
 X86:         Machine: IMAGE_FILE_MACHINE_I386 (0x14C)
 X86-DAG:   Relocations [
 X86-DAG:                 .rsrc$01 {
 X86-NEXT:      0x1E8 IMAGE_REL_I386_DIR32NB $R000000
 X86-NEXT:      0x198 IMAGE_REL_I386_DIR32NB $R000018
 X86-NEXT:      0x1A8 IMAGE_REL_I386_DIR32NB $R000340
 X86-NEXT:      0x1C8 IMAGE_REL_I386_DIR32NB $R000668
 X86-NEXT:      0x1D8 IMAGE_REL_I386_DIR32NB $R000698

 ARM-NEXT:      0x1E8 IMAGE_REL_ARM_ADDR32NB $R000000
 ARM-NEXT:      0x198 IMAGE_REL_ARM_ADDR32NB $R000018
 ARM-NEXT:      0x1A8 IMAGE_REL_ARM_ADDR32NB $R000340
 ARM-NEXT:      0x1C8 IMAGE_REL_ARM_ADDR32NB $R000668
 ARM-NEXT:      0x1D8 IMAGE_REL_ARM_ADDR32NB $R000698
 ARM-NEXT:      0x1F8 IMAGE_REL_ARM_ADDR32NB $R000708
 ARM-NEXT:      0x1B8 IMAGE_REL_ARM_ADDR32NB $R000720
 ARM-NEXT:      0x188 IMAGE_REL_ARM_ADDR32NB $R000750
+
+ARM64:       Machine: IMAGE_FILE_MACHINE_ARM64 (0xAA64)
+ARM64-DAG: Relocations [
+ARM64-DAG:               .rsrc$01 {
+ARM64-NEXT:    0x1E8 IMAGE_REL_ARM64_ADDR32NB $R000000
+ARM64-NEXT:    0x198 IMAGE_REL_ARM64_ADDR32NB $R000018
+ARM64-NEXT:    0x1A8 IMAGE_REL_ARM64_ADDR32NB $R000340
+ARM64-NEXT:    0x1C8 IMAGE_REL_ARM64_ADDR32NB $R000668
+ARM64-NEXT:    0x1D8 IMAGE_REL_ARM64_ADDR32NB $R000698
+ARM64-NEXT:    0x1F8 IMAGE_REL_ARM64_ADDR32NB $R000708
+ARM64-NEXT:    0x1B8 IMAGE_REL_ARM64_ADDR32NB $R000720
+ARM64-NEXT:    0x188 IMAGE_REL_ARM64_ADDR32NB $R000750

tools/llvm-cvtres/llvm-cvtres.cpp

int main(int argc_, const char *argv_[]) {
   bool Verbose = InputArgs.hasArg(OPT_VERBOSE);
 
   COFF::MachineTypes MachineType;
 
   if (InputArgs.hasArg(OPT_MACHINE)) {
     std::string MachineString = InputArgs.getLastArgValue(OPT_MACHINE).upper();
     MachineType = StringSwitch<COFF::MachineTypes>(MachineString)
                       .Case("ARM", COFF::IMAGE_FILE_MACHINE_ARMNT)
+                      .Case("ARM64", COFF::IMAGE_FILE_MACHINE_ARM64)
                       .Case("X64", COFF::IMAGE_FILE_MACHINE_AMD64)
                       .Case("X86", COFF::IMAGE_FILE_MACHINE_I386)
                       .Default(COFF::IMAGE_FILE_MACHINE_UNKNOWN);
     if (MachineType == COFF::IMAGE_FILE_MACHINE_UNKNOWN)
       reportError("Unsupported machine architecture");
   } else {
     if (Verbose)
       outs() << "Machine architecture not specified; assumed X64.\n";
int main(int argc_, const char *argv_[]) {
   } else {
     OutputFile = sys::path::filename(StringRef(InputFiles[0]));
     sys::path::replace_extension(OutputFile, ".obj");
   }
 
   if (Verbose) {
     outs() << "Machine: ";
     switch (MachineType) {
+    case COFF::IMAGE_FILE_MACHINE_ARM64:
+      outs() << "ARM64\n";
+      break;
     case COFF::IMAGE_FILE_MACHINE_ARMNT:
       outs() << "ARM\n";
       break;
     case COFF::IMAGE_FILE_MACHINE_I386:
       outs() << "X86\n";
       break;
     default:
       outs() << "X64\n";