[llvm-lib] [llvm-readobj] [llvm-cvtres] Add Support for ARM64X object files.

[jacek]

Summary

Similar to D125411, but for ARM64X.

ARM64X PE binaries are hybrids containing both ARM64EC and pure ARM64 variants in one file. They are usually linked by passing separate ARM64EC and ARM64 object files to linker. Linked binaries use ARM64 machine and contain additional CHPE metadata in their load config. CHPE metadata support is not part of this patch, I plan to send that later.

Using ARM64X as a machine type of object files themselves is somewhat ambiguous, but such files are allowed by MSVC. It treats them as ARM64 or ARM64EC object, depending on the context. Such objects can be produced with cvtres.exe -machine:arm64x.

[efriedma]

It looks like this covers all the basics... the "object file you can treat either way" thing is a bit weird, but I guess that's defined by Microsoft.

llvm/include/llvm/BinaryFormat/COFF.h

124

It looks like you don't use this helper anywhere other than this header.

129

Maybe name this isAnyArm64, or something like that, to indicate that it's encompassing all the different variants.

[jacek]

Thanks for the review. I updated the patch with the helper renamed to isAnyArm64. I also included use of isArm64EC in libDriverMain (I think I lost it in rebase). I have a bit more use of it in my queue, but nothing substantial, so I may remove it if you prefer.

[efriedma]

LGTM

[TWeaver]

Hello and good afternoon from the UK,

I believe this is 3 of 3 patches that may have caused the following build bot to begin failing, are you able to take a look?

https://lab.llvm.org/buildbot/#/builders/216/builds/20269

Warm regards,
Tom W

llvm/include/llvm/BinaryFormat/COFF.h

enum MachineTypes : unsigned {
 
   IMAGE_FILE_MACHINE_UNKNOWN = 0x0,
   IMAGE_FILE_MACHINE_AM33 = 0x1D3,
   IMAGE_FILE_MACHINE_AMD64 = 0x8664,
   IMAGE_FILE_MACHINE_ARM = 0x1C0,
   IMAGE_FILE_MACHINE_ARMNT = 0x1C4,
   IMAGE_FILE_MACHINE_ARM64 = 0xAA64,
   IMAGE_FILE_MACHINE_ARM64EC = 0xA641,
+  IMAGE_FILE_MACHINE_ARM64X = 0xA64E,
   IMAGE_FILE_MACHINE_EBC = 0xEBC,
   IMAGE_FILE_MACHINE_I386 = 0x14C,
   IMAGE_FILE_MACHINE_IA64 = 0x200,
   IMAGE_FILE_MACHINE_M32R = 0x9041,
   IMAGE_FILE_MACHINE_MIPS16 = 0x266,
   IMAGE_FILE_MACHINE_MIPSFPU = 0x366,
   IMAGE_FILE_MACHINE_MIPSFPU16 = 0x466,
   IMAGE_FILE_MACHINE_POWERPC = 0x1F0,
   IMAGE_FILE_MACHINE_POWERPCFP = 0x1F1,
   IMAGE_FILE_MACHINE_R4000 = 0x166,
   IMAGE_FILE_MACHINE_RISCV32 = 0x5032,
   IMAGE_FILE_MACHINE_RISCV64 = 0x5064,
   IMAGE_FILE_MACHINE_RISCV128 = 0x5128,
   IMAGE_FILE_MACHINE_SH3 = 0x1A2,
   IMAGE_FILE_MACHINE_SH3DSP = 0x1A3,
   IMAGE_FILE_MACHINE_SH4 = 0x1A6,
   IMAGE_FILE_MACHINE_SH5 = 0x1A8,
   IMAGE_FILE_MACHINE_THUMB = 0x1C2,
   IMAGE_FILE_MACHINE_WCEMIPSV2 = 0x169
 };
 
+template <typename T> bool isArm64EC(T Machine) {
+  return Machine == IMAGE_FILE_MACHINE_ARM64EC ||
+         Machine == IMAGE_FILE_MACHINE_ARM64X;
+}
+
+template <typename T> bool isAnyArm64(T Machine) {
+  return Machine == IMAGE_FILE_MACHINE_ARM64 || isArm64EC(Machine);
+}
+
 enum Characteristics : unsigned {
   C_Invalid = 0,
 
   /// The file does not contain base relocations and must be loaded at its
   /// preferred base. If this cannot be done, the loader will error.
   IMAGE_FILE_RELOCS_STRIPPED = 0x0001,
   /// The file is valid and can be run.
   IMAGE_FILE_EXECUTABLE_IMAGE = 0x0002,

llvm/lib/BinaryFormat/Magic.cpp

if (startswith(Magic, "DXBC"))
       return file_magic::dxcontainer_object;
     break;
 
   case 0x41: // ARM64EC windows
     if (Magic[1] == char(0xA6))
       return file_magic::coff_object;
     break;
 
+  case 0x4e: // ARM64X windows
+    if (Magic[1] == char(0xA6))
+      return file_magic::coff_object;
+    break;
+
   default:
     break;
   }
   return file_magic::unknown;
 }
 
 std::error_code llvm::identify_magic(const Twine &Path, file_magic &Result) {
   auto FileOrError = MemoryBuffer::getFile(Path, /*IsText=*/false,

llvm/lib/Object/COFFImportFile.cpp

 namespace object {
 
 static bool is32bit(MachineTypes Machine) {
   switch (Machine) {
   default:
     llvm_unreachable("unsupported machine");
   case IMAGE_FILE_MACHINE_ARM64:
   case IMAGE_FILE_MACHINE_ARM64EC:
+  case IMAGE_FILE_MACHINE_ARM64X:
   case IMAGE_FILE_MACHINE_AMD64:
     return false;
   case IMAGE_FILE_MACHINE_ARMNT:
   case IMAGE_FILE_MACHINE_I386:
     return true;
   }
 }
 
 static uint16_t getImgRelRelocation(MachineTypes Machine) {
   switch (Machine) {
   default:
     llvm_unreachable("unsupported machine");
   case IMAGE_FILE_MACHINE_AMD64:
     return IMAGE_REL_AMD64_ADDR32NB;
   case IMAGE_FILE_MACHINE_ARMNT:
     return IMAGE_REL_ARM_ADDR32NB;
   case IMAGE_FILE_MACHINE_ARM64:
   case IMAGE_FILE_MACHINE_ARM64EC:
+  case IMAGE_FILE_MACHINE_ARM64X:
     return IMAGE_REL_ARM64_ADDR32NB;
   case IMAGE_FILE_MACHINE_I386:
     return IMAGE_REL_I386_DIR32NB;
   }
 }
 
 template <class T> static void append(std::vector<uint8_t> &B, const T &Data) {
   size_t S = B.size();

llvm/lib/Object/COFFObjectFile.cpp

StringRef COFFObjectFile::getFileFormatName() const {
   case COFF::IMAGE_FILE_MACHINE_AMD64:
     return "COFF-x86-64";
   case COFF::IMAGE_FILE_MACHINE_ARMNT:
     return "COFF-ARM";
   case COFF::IMAGE_FILE_MACHINE_ARM64:
     return "COFF-ARM64";
   case COFF::IMAGE_FILE_MACHINE_ARM64EC:
     return "COFF-ARM64EC";
+  case COFF::IMAGE_FILE_MACHINE_ARM64X:
+    return "COFF-ARM64X";
   default:
     return "COFF-<unknown arch>";
   }
 }
 
 Triple::ArchType COFFObjectFile::getArch() const {
   switch (getMachine()) {
   case COFF::IMAGE_FILE_MACHINE_I386:
     return Triple::x86;
   case COFF::IMAGE_FILE_MACHINE_AMD64:
     return Triple::x86_64;
   case COFF::IMAGE_FILE_MACHINE_ARMNT:
     return Triple::thumb;
   case COFF::IMAGE_FILE_MACHINE_ARM64:
   case COFF::IMAGE_FILE_MACHINE_ARM64EC:
+  case COFF::IMAGE_FILE_MACHINE_ARM64X:
     return Triple::aarch64;
   default:
     return Triple::UnknownArch;
   }
 }
 
 Expected<uint64_t> COFFObjectFile::getStartAddress() const {
   if (PE32Header)
case COFF::IMAGE_FILE_MACHINE_ARMNT:
     LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_BLX23T);
     LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_PAIR);
     default:
       return "Unknown";
     }
     break;
   case COFF::IMAGE_FILE_MACHINE_ARM64:
   case COFF::IMAGE_FILE_MACHINE_ARM64EC:
+  case COFF::IMAGE_FILE_MACHINE_ARM64X:
     switch (Type) {
     LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM64_ABSOLUTE);
     LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM64_ADDR32);
     LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM64_ADDR32NB);
     LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM64_BRANCH26);
     LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM64_PAGEBASE_REL21);
     LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM64_REL21);
     LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM64_PAGEOFFSET_12A);
if (RelocsForOffset.first != RelocsForOffset.second) {
     case COFF::IMAGE_FILE_MACHINE_AMD64:
       RVAReloc = COFF::IMAGE_REL_AMD64_ADDR32NB;
       break;
     case COFF::IMAGE_FILE_MACHINE_ARMNT:
       RVAReloc = COFF::IMAGE_REL_ARM_ADDR32NB;
       break;
     case COFF::IMAGE_FILE_MACHINE_ARM64:
     case COFF::IMAGE_FILE_MACHINE_ARM64EC:
+    case COFF::IMAGE_FILE_MACHINE_ARM64X:
       RVAReloc = COFF::IMAGE_REL_ARM64_ADDR32NB;
       break;
     default:
       return createStringError(object_error::parse_failed,
                                "unsupported architecture");
     }
     if (R.Type != RVAReloc)
       return createStringError(object_error::parse_failed,

llvm/lib/Object/WindowsMachineFlag.cpp

 // Returns /machine's value.
 COFF::MachineTypes llvm::getMachineType(StringRef S) {
   return StringSwitch<COFF::MachineTypes>(S.lower())
       .Cases("x64", "amd64", COFF::IMAGE_FILE_MACHINE_AMD64)
       .Cases("x86", "i386", COFF::IMAGE_FILE_MACHINE_I386)
       .Case("arm", COFF::IMAGE_FILE_MACHINE_ARMNT)
       .Case("arm64", COFF::IMAGE_FILE_MACHINE_ARM64)
       .Case("arm64ec", COFF::IMAGE_FILE_MACHINE_ARM64EC)
+      .Case("arm64x", COFF::IMAGE_FILE_MACHINE_ARM64X)
       .Default(COFF::IMAGE_FILE_MACHINE_UNKNOWN);
 }
 
 StringRef llvm::machineToStr(COFF::MachineTypes MT) {
   switch (MT) {
   case COFF::IMAGE_FILE_MACHINE_ARMNT:
     return "arm";
   case COFF::IMAGE_FILE_MACHINE_ARM64:
     return "arm64";
   case COFF::IMAGE_FILE_MACHINE_ARM64EC:
     return "arm64ec";
+  case COFF::IMAGE_FILE_MACHINE_ARM64X:
+    return "arm64x";
   case COFF::IMAGE_FILE_MACHINE_AMD64:
     return "x64";
   case COFF::IMAGE_FILE_MACHINE_I386:
     return "x86";
   default:
     llvm_unreachable("unknown machine type");
   }
 }

llvm/lib/Object/WindowsResource.cpp

for (unsigned i = 0; i < Data.size(); i++) {
     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:
     case COFF::IMAGE_FILE_MACHINE_ARM64EC:
+    case COFF::IMAGE_FILE_MACHINE_ARM64X:
       Reloc->Type = COFF::IMAGE_REL_ARM64_ADDR32NB;
       break;
     default:
       llvm_unreachable("unknown machine type");
     }
     CurrentOffset += sizeof(coff_relocation);
   }
 }

llvm/lib/ObjectYAML/COFFEmitter.cpp

struct COFFParser {
   bool useBigObj() const {
     return static_cast<int32_t>(Obj.Sections.size()) >
            COFF::MaxNumberOfSections16;
   }
 
   bool isPE() const { return Obj.OptionalHeader.has_value(); }
   bool is64Bit() const {
     return Obj.Header.Machine == COFF::IMAGE_FILE_MACHINE_AMD64 ||
-           Obj.Header.Machine == COFF::IMAGE_FILE_MACHINE_ARM64 ||
-           Obj.Header.Machine == COFF::IMAGE_FILE_MACHINE_ARM64EC;
+           COFF::isAnyArm64(Obj.Header.Machine);
   }
 
   uint32_t getFileAlignment() const {
     return Obj.OptionalHeader->Header.FileAlignment;
   }
 
   unsigned getHeaderSize() const {
     return useBigObj() ? COFF::Header32Size : COFF::Header16Size;

llvm/lib/ObjectYAML/COFFYAML.cpp

void ScalarEnumerationTraits<COFF::MachineTypes>::enumeration(
     IO &IO, COFF::MachineTypes &Value) {
   ECase(IMAGE_FILE_MACHINE_UNKNOWN);
   ECase(IMAGE_FILE_MACHINE_AM33);
   ECase(IMAGE_FILE_MACHINE_AMD64);
   ECase(IMAGE_FILE_MACHINE_ARM);
   ECase(IMAGE_FILE_MACHINE_ARMNT);
   ECase(IMAGE_FILE_MACHINE_ARM64);
   ECase(IMAGE_FILE_MACHINE_ARM64EC);
+  ECase(IMAGE_FILE_MACHINE_ARM64X);
   ECase(IMAGE_FILE_MACHINE_EBC);
   ECase(IMAGE_FILE_MACHINE_I386);
   ECase(IMAGE_FILE_MACHINE_IA64);
   ECase(IMAGE_FILE_MACHINE_M32R);
   ECase(IMAGE_FILE_MACHINE_MIPS16);
   ECase(IMAGE_FILE_MACHINE_MIPSFPU);
   ECase(IMAGE_FILE_MACHINE_MIPSFPU16);
   ECase(IMAGE_FILE_MACHINE_POWERPC);
void MappingTraits<COFFYAML::Relocation>::mapping(IO &IO,
   } else if (H.Machine == COFF::IMAGE_FILE_MACHINE_AMD64) {
     MappingNormalization<NType<COFF::RelocationTypeAMD64>, uint16_t> NT(
         IO, Rel.Type);
     IO.mapRequired("Type", NT->Type);
   } else if (H.Machine == COFF::IMAGE_FILE_MACHINE_ARMNT) {
     MappingNormalization<NType<COFF::RelocationTypesARM>, uint16_t> NT(
         IO, Rel.Type);
     IO.mapRequired("Type", NT->Type);
-  } else if (H.Machine == COFF::IMAGE_FILE_MACHINE_ARM64 ||
-             H.Machine == COFF::IMAGE_FILE_MACHINE_ARM64EC) {
+  } else if (COFF::isAnyArm64(H.Machine)) {
     MappingNormalization<NType<COFF::RelocationTypesARM64>, uint16_t> NT(
         IO, Rel.Type);
     IO.mapRequired("Type", NT->Type);
   } else {
     IO.mapRequired("Type", Rel.Type);
   }
 }
 

llvm/lib/ObjectYAML/CodeViewYAMLSymbols.cpp

void ScalarEnumerationTraits<RegisterId>::enumeration(IO &io, RegisterId &Reg) {
   case COFF::IMAGE_FILE_MACHINE_AMD64:
     CpuType = CPUType::X64;
     break;
   case COFF::IMAGE_FILE_MACHINE_ARMNT:
     CpuType = CPUType::ARMNT;
     break;
   case COFF::IMAGE_FILE_MACHINE_ARM64:
   case COFF::IMAGE_FILE_MACHINE_ARM64EC:
+  case COFF::IMAGE_FILE_MACHINE_ARM64X:
     CpuType = CPUType::ARM64;
     break;
   }
 
   if (CpuType)
     RegNames = getRegisterNames(*CpuType);
 
   for (const auto &E : RegNames) {

llvm/lib/ToolDrivers/llvm-lib/LibDriver.cpp

static Expected<COFF::MachineTypes> getCOFFFileMachine(MemoryBufferRef MB) {
   std::error_code EC;
   auto Obj = object::COFFObjectFile::create(MB);
   if (!Obj)
     return Obj.takeError();
 
   uint16_t Machine = (*Obj)->getMachine();
   if (Machine != COFF::IMAGE_FILE_MACHINE_I386 &&
       Machine != COFF::IMAGE_FILE_MACHINE_AMD64 &&
-      Machine != COFF::IMAGE_FILE_MACHINE_ARMNT &&
-      Machine != COFF::IMAGE_FILE_MACHINE_ARM64 &&
-      Machine != COFF::IMAGE_FILE_MACHINE_ARM64EC) {
+      Machine != COFF::IMAGE_FILE_MACHINE_ARMNT && !COFF::isAnyArm64(Machine)) {
     return createStringError(inconvertibleErrorCode(),
                              "unknown machine: " + std::to_string(Machine));
   }
 
   return static_cast<COFF::MachineTypes>(Machine);
 }
 
 static Expected<COFF::MachineTypes> getBitcodeFileMachine(MemoryBufferRef MB) {

 }
 
 static bool machineMatches(COFF::MachineTypes LibMachine,
                            COFF::MachineTypes FileMachine) {
   if (LibMachine == FileMachine)
     return true;
   // ARM64EC mode allows both pure ARM64, ARM64EC and X64 objects to be mixed in
   // the archive.
-  return LibMachine == COFF::IMAGE_FILE_MACHINE_ARM64EC &&
-         (FileMachine == COFF::IMAGE_FILE_MACHINE_ARM64 ||
-          FileMachine == COFF::IMAGE_FILE_MACHINE_AMD64);
+  switch (LibMachine) {
+  case COFF::IMAGE_FILE_MACHINE_ARM64:
+    return FileMachine == COFF::IMAGE_FILE_MACHINE_ARM64X;
+  case COFF::IMAGE_FILE_MACHINE_ARM64EC:
+  case COFF::IMAGE_FILE_MACHINE_ARM64X:
+    return COFF::isAnyArm64(FileMachine) ||
+           FileMachine == COFF::IMAGE_FILE_MACHINE_AMD64;
+  default:
+    return false;
+  }
 }
 
 static void appendFile(std::vector<NewArchiveMember> &Members,
                        COFF::MachineTypes &LibMachine,
                        std::string &LibMachineSource, MemoryBufferRef MB) {
   file_magic Magic = identify_magic(MB.getBuffer());
 
   if (Magic != file_magic::coff_object && Magic != file_magic::bitcode &&
int llvm::libDriverMain(ArrayRef<const char *> ArgsArr) {
   std::reverse(Members.begin(), Members.end());
 
   bool Thin = Args.hasArg(OPT_llvmlibthin);
   if (Error E =
           writeArchive(OutputPath, Members,
                        /*WriteSymtab=*/true,
                        Thin ? object::Archive::K_GNU : object::Archive::K_COFF,
                        /*Deterministic*/ true, Thin, nullptr,
-                       LibMachine == COFF::IMAGE_FILE_MACHINE_ARM64EC)) {
+                       COFF::isArm64EC(LibMachine))) {
     handleAllErrors(std::move(E), [&](const ErrorInfoBase &EI) {
       llvm::errs() << OutputPath << ": " << EI.message() << "\n";
     });
     return 1;
   }
 
   return 0;
 }

llvm/test/tools/llvm-cvtres/machine.test

 RUN: llvm-readobj -h -r %t | FileCheck %s -check-prefix=X64
 
 RUN: llvm-cvtres /machine:ARM /out:%t %p/Inputs/test_resource.res
 RUN: llvm-readobj -h -r %t | FileCheck %s -check-prefix=ARM
 
 RUN: llvm-cvtres /machine:ARM64 /out:%t %p/Inputs/test_resource.res
 RUN: llvm-readobj -h -r %t | FileCheck %s -check-prefix=ARM64
 
+RUN: llvm-cvtres /machine:ARM64EC /out:%t %p/Inputs/test_resource.res
+RUN: llvm-readobj -h -r %t | FileCheck %s -check-prefix=ARM64EC
+
+RUN: llvm-cvtres /machine:ARM64X /out:%t %p/Inputs/test_resource.res
+RUN: llvm-readobj -h -r %t | FileCheck %s -check-prefix=ARM64X
+
 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 $R000001
 X86-NEXT:      0x1A8 IMAGE_REL_I386_DIR32NB $R000002
 X86-NEXT:      0x1C8 IMAGE_REL_I386_DIR32NB $R000003
 X86-NEXT:      0x1D8 IMAGE_REL_I386_DIR32NB $R000004

 ARM64-NEXT:    0x1E8 IMAGE_REL_ARM64_ADDR32NB $R000000
 ARM64-NEXT:    0x198 IMAGE_REL_ARM64_ADDR32NB $R000001
 ARM64-NEXT:    0x1A8 IMAGE_REL_ARM64_ADDR32NB $R000002
 ARM64-NEXT:    0x1C8 IMAGE_REL_ARM64_ADDR32NB $R000003
 ARM64-NEXT:    0x1D8 IMAGE_REL_ARM64_ADDR32NB $R000004
 ARM64-NEXT:    0x1F8 IMAGE_REL_ARM64_ADDR32NB $R000005
 ARM64-NEXT:    0x1B8 IMAGE_REL_ARM64_ADDR32NB $R000006
 ARM64-NEXT:    0x188 IMAGE_REL_ARM64_ADDR32NB $R000007
+
+ARM64EC:       Machine: IMAGE_FILE_MACHINE_ARM64EC (0xA641)
+ARM64EC-DAG: Relocations [
+ARM64EC-DAG:               .rsrc$01 {
+ARM64EC-NEXT:    0x1E8 IMAGE_REL_ARM64_ADDR32NB $R000000
+ARM64EC-NEXT:    0x198 IMAGE_REL_ARM64_ADDR32NB $R000001
+ARM64EC-NEXT:    0x1A8 IMAGE_REL_ARM64_ADDR32NB $R000002
+ARM64EC-NEXT:    0x1C8 IMAGE_REL_ARM64_ADDR32NB $R000003
+ARM64EC-NEXT:    0x1D8 IMAGE_REL_ARM64_ADDR32NB $R000004
+ARM64EC-NEXT:    0x1F8 IMAGE_REL_ARM64_ADDR32NB $R000005
+ARM64EC-NEXT:    0x1B8 IMAGE_REL_ARM64_ADDR32NB $R000006
+ARM64EC-NEXT:    0x188 IMAGE_REL_ARM64_ADDR32NB $R000007
+
+ARM64X:       Machine: IMAGE_FILE_MACHINE_ARM64X (0xA64E)
+ARM64X-DAG: Relocations [
+ARM64X-DAG:               .rsrc$01 {
+ARM64X-NEXT:    0x1E8 IMAGE_REL_ARM64_ADDR32NB $R000000
+ARM64X-NEXT:    0x198 IMAGE_REL_ARM64_ADDR32NB $R000001
+ARM64X-NEXT:    0x1A8 IMAGE_REL_ARM64_ADDR32NB $R000002
+ARM64X-NEXT:    0x1C8 IMAGE_REL_ARM64_ADDR32NB $R000003
+ARM64X-NEXT:    0x1D8 IMAGE_REL_ARM64_ADDR32NB $R000004
+ARM64X-NEXT:    0x1F8 IMAGE_REL_ARM64_ADDR32NB $R000005
+ARM64X-NEXT:    0x1B8 IMAGE_REL_ARM64_ADDR32NB $R000006
+ARM64X-NEXT:    0x188 IMAGE_REL_ARM64_ADDR32NB $R000007

llvm/test/tools/llvm-lib/Inputs/arm64x.yaml

+--- !COFF
+header:
+  Machine:         IMAGE_FILE_MACHINE_ARM64X
+  Characteristics: [  ]
+sections:
+  - Name:            .text
+    Characteristics: [ IMAGE_SCN_CNT_CODE, IMAGE_SCN_MEM_EXECUTE, IMAGE_SCN_MEM_READ ]
+    Alignment:       4
+    SectionData:     ''
+symbols:
+  - Name:            .text
+    Value:           0
+    SectionNumber:   1
+    SimpleType:      IMAGE_SYM_TYPE_NULL
+    ComplexType:     IMAGE_SYM_DTYPE_NULL
+    StorageClass:    IMAGE_SYM_CLASS_STATIC
+    SectionDefinition:
+      Length:          0
+      NumberOfRelocations: 0
+      NumberOfLinenumbers: 0
+      CheckSum:        0
+      Number:          1
+...

llvm/test/tools/llvm-lib/machine-mismatch.test

 Prepare inputs:
 
 RUN: rm -rf %t && mkdir -p %t
 RUN: llvm-mc -triple=i386-pc-windows-msvc -filetype=obj -o %t/i386.obj %S/Inputs/a.s
 RUN: llvm-mc -triple=x86_64-pc-windows-msvc -filetype=obj -o %t/x86_64.obj %S/Inputs/a.s
 RUN: llvm-mc -triple=aarch64-pc-windows-msvc -filetype=obj -o %t/arm64.obj %S/Inputs/a.s
 RUN: llvm-mc -triple=arm64ec-pc-windows-msvc -filetype=obj -o %t/arm64ec.obj %S/Inputs/a.s
 RUN: llvm-as -o %t/i386.bc %S/Inputs/i386.ll
 RUN: llvm-as -o %t/x86_64.bc %S/Inputs/x86_64.ll
 RUN: llvm-as -o %t/arm64.bc %S/Inputs/arm64.ll
+RUN: yaml2obj -o %t/arm64x.obj %S/Inputs/arm64x.yaml
 
 
 Mixing bitcode and normal object files with the same machine type is ok:
 
 RUN: llvm-lib %t/i386.obj %t/i386.bc
 RUN: llvm-lib %t/x86_64.obj %t/x86_64.bc
 
 

 
 RUN: not llvm-lib /machine:X86 %t/x86_64.obj %t/i386.obj 2>&1 | \
 RUN:     FileCheck --check-prefix=OBJ64 %s
 OBJ64: x86_64.obj: file machine type x64 conflicts with library machine type x86 (from '/machine:X86' flag)
 
 
 Mixing arm64 and x86_64 is possible using arm64ec:
 
-RUN: llvm-lib -machine:arm64ec %t/arm64.bc %t/x86_64.bc %t/arm64.obj %t/x86_64.obj %t/arm64ec.obj
+RUN: llvm-lib -machine:arm64ec %t/arm64.bc %t/x86_64.bc %t/arm64.obj %t/x86_64.obj %t/arm64ec.obj %t/arm64x.obj
+RUN: llvm-lib -machine:arm64x %t/arm64.bc %t/x86_64.bc %t/arm64.obj %t/x86_64.obj %t/arm64ec.obj %t/arm64x.obj
+RUN: llvm-lib -machine:arm64 %t/arm64.bc %t/arm64.obj %t/arm64x.obj
 
 RUN: not llvm-lib %t/arm64ec.obj 2>&1 | FileCheck --check-prefix=NOEC %s
 NOEC: arm64ec.obj: file machine type arm64ec conflicts with inferred library machine type, use /machine:arm64ec or /machine:arm64x
 
 RUN: not llvm-lib -machine:arm64ec %t/arm64ec.obj %t/i386.obj 2>&1 | \
 RUN:     FileCheck --check-prefix=OBJEC %s
+RUN: not llvm-lib -machine:arm64x %t/arm64ec.obj %t/i386.obj 2>&1 | \
+RUN:     FileCheck --check-prefix=OBJX %s
+RUN: not llvm-lib -machine:x64 %t/x86_64.obj %t/arm64x.obj 2>&1 | \
+RUN:     FileCheck --check-prefix=OBJX2 %s
 OBJEC: i386.obj: file machine type x86 conflicts with library machine type arm64ec (from '/machine:arm64ec' flag)
+OBJX:  i386.obj: file machine type x86 conflicts with library machine type arm64x (from '/machine:arm64x' flag)
+OBJX2: arm64x.obj: file machine type arm64x conflicts with library machine type x64 (from '/machine:x64' flag)
 
 RUN: not llvm-lib -machine:arm64ec %t/arm64.bc %t/x86_64.bc %t/i386.bc 2>&1 | \
 RUN:     FileCheck --check-prefix=BCEC %s
+RUN: not llvm-lib -machine:arm64x %t/arm64.bc %t/x86_64.bc %t/i386.bc 2>&1 | \
+RUN:     FileCheck --check-prefix=BCX %s
 BCEC: i386.bc: file machine type x86 conflicts with library machine type arm64ec (from '/machine:arm64ec' flag)
+BCX:  i386.bc: file machine type x86 conflicts with library machine type arm64x (from '/machine:arm64x' flag)

llvm/test/tools/llvm-readobj/COFF/arm64x.yaml

+# RUN: yaml2obj < %s | llvm-readobj - --file-headers | FileCheck %s
+# Check we can process a simple arm64x file.
+# CHECK: Format: COFF-ARM64X
+# CHECK: Machine: IMAGE_FILE_MACHINE_ARM64X (0xA64E)
+--- !COFF
+header:
+  Machine:         IMAGE_FILE_MACHINE_ARM64X
+  Characteristics: [  ]
+sections:
+  - Name:            .text
+    Characteristics: [ IMAGE_SCN_CNT_CODE, IMAGE_SCN_MEM_EXECUTE, IMAGE_SCN_MEM_READ ]
+    Alignment:       4
+    SectionData:     ''
+symbols:
+  - Name:            .text
+    Value:           0
+    SectionNumber:   1
+    SimpleType:      IMAGE_SYM_TYPE_NULL
+    ComplexType:     IMAGE_SYM_DTYPE_NULL
+    StorageClass:    IMAGE_SYM_CLASS_STATIC
+    SectionDefinition:
+      Length:          0
+      NumberOfRelocations: 0
+      NumberOfLinenumbers: 0
+      CheckSum:        0
+      Number:          1
+...

llvm/tools/llvm-readobj/COFFDumper.cpp

 
 const EnumEntry<COFF::MachineTypes> ImageFileMachineType[] = {
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_UNKNOWN  ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_AM33     ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_AMD64    ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_ARM      ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_ARM64    ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_ARM64EC  ),
+  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_ARM64X   ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_ARMNT    ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_EBC      ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_I386     ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_IA64     ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_M32R     ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_MIPS16   ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_MIPSFPU  ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_MIPSFPU16),
Resolver = [](const object::coff_section *Section, uint64_t Offset,
       return Dumper->resolveSymbol(Section, Offset, Symbol);
     };
     Win64EH::Dumper::Context Ctx(*Obj, Resolver, this);
     Dumper.printData(Ctx);
     break;
   }
   case COFF::IMAGE_FILE_MACHINE_ARM64:
   case COFF::IMAGE_FILE_MACHINE_ARM64EC:
+  case COFF::IMAGE_FILE_MACHINE_ARM64X:
   case COFF::IMAGE_FILE_MACHINE_ARMNT: {
     ARM::WinEH::Decoder Decoder(W, Obj->getMachine() !=
                                        COFF::IMAGE_FILE_MACHINE_ARMNT);
     // TODO Propagate the error.
     consumeError(Decoder.dumpProcedureData(*Obj));
     break;
   }
   default: