[ARM64EC 1/?] Add parsing support to llvm-objdump/llvm-readobj.

[efriedma]

Summary

This is the first patch of a patchset to add initial support for ARM64EC. Basic documentation is available at https://docs.microsoft.com/en-us/windows/uwp/porting/arm64ec-abi . (Discourse post: https://discourse.llvm.org/t/initial-patches-for-arm64ec-windows-11-now-posted/62449 .)

The file format for ARM64EC is basically identical to normal ARM64. There are a few extra sections, but the existing code for reading ARM64 object files just works.

[mstorsjo]

Nice! I started looking into this long ago, but essentially didn't get any further than this patch...

A couple other hunks you might want to incorporate (or maybe you have them queued up already, in later patches - in that case, just disregard me):

diff --git a/llvm/lib/Object/WindowsMachineFlag.cpp b/llvm/lib/Object/WindowsMachineFlag.cpp
index f7f2b20ae1a2..eef0ea83c927 100644
--- a/llvm/lib/Object/WindowsMachineFlag.cpp
+++ b/llvm/lib/Object/WindowsMachineFlag.cpp
@@ -25,6 +25,7 @@ COFF::MachineTypes llvm::getMachineType(StringRef S) {
       .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)
       .Default(COFF::IMAGE_FILE_MACHINE_UNKNOWN);
 }
 
@@ -34,6 +35,8 @@ StringRef llvm::machineToStr(COFF::MachineTypes MT) {
     return "arm";
   case COFF::IMAGE_FILE_MACHINE_ARM64:
     return "arm64";
+  case COFF::IMAGE_FILE_MACHINE_ARM64EC:
+    return "arm64ec";
   case COFF::IMAGE_FILE_MACHINE_AMD64:
     return "x64";
   case COFF::IMAGE_FILE_MACHINE_I386: 
diff --git a/llvm/lib/ObjectYAML/COFFEmitter.cpp b/llvm/lib/ObjectYAML/COFFEmitter.cpp
index d884e2fd55cd..0068ccfe17a6 100644
--- a/llvm/lib/ObjectYAML/COFFEmitter.cpp
+++ b/llvm/lib/ObjectYAML/COFFEmitter.cpp
@@ -48,7 +48,8 @@ struct COFFParser {
   bool isPE() const { return Obj.OptionalHeader.hasValue(); }
   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_ARM64 ||
+           Obj.Header.Machine == COFF::IMAGE_FILE_MACHINE_ARM64EC;
   }
 
   uint32_t getFileAlignment() const {

[apazos]

llvm/lib/ObjectYAML/COFFYAML.cpp

81

Was this RISCV change accidental?

[efriedma]

llvm/lib/ObjectYAML/COFFYAML.cpp

81

More of a "while I'm here" thing; I could split it into a separate patch, I guess.

[DavidSpickett]

llvm/lib/BinaryFormat/Magic.cpp

237

Is the value documented yet? I'm looking at https://docs.microsoft.com/en-us/windows/win32/debug/pe-format#machine-types but I don't see it.

[mstorsjo]

llvm/lib/BinaryFormat/Magic.cpp

237

It actually seems to be missing in winnt.h in the 10.0.22000.0 WinSDK headers too.

[efriedma]

llvm/lib/BinaryFormat/Magic.cpp

237

If you're looking at anything related to ARM64EC, you should looking at the Windows 11 SDK.

Pretty sure the constant is in the SDK headers.

[efriedma]

Update more places that check for IMAGE_FILE_MACHINE_ARM64

[efriedma]

Any further comments on this? I'd like to start landing some ARM64EC patches soon.

[DavidSpickett]

LGTM

llvm/include/llvm/BinaryFormat/COFF.h

enum MachineTypes : unsigned {
   MT_Invalid = 0xffff,
 
   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_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,

llvm/lib/BinaryFormat/Magic.cpp

if (startswith(Magic, "--- !tapi") || startswith(Magic, "---\narchs:"))
       return file_magic::tapi_file;
     break;
   
   case 'D': // DirectX container file - DXBC
     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;
+
   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 llvm {
 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_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:
     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_I386:
     return "COFF-i386";
   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";
   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:
     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_BRANCH24T);
     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:
     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);
case COFF::IMAGE_FILE_MACHINE_I386:
       break;
     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:
       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)
       .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_AMD64:
     return "x64";
   case COFF::IMAGE_FILE_MACHINE_I386:
     return "x86";
   default:
     llvm_unreachable("unknown machine type");
   }
 }

llvm/lib/Object/WindowsResource.cpp

case COFF::IMAGE_FILE_MACHINE_ARMNT:
       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:
+    case COFF::IMAGE_FILE_MACHINE_ARM64EC:
       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.hasValue(); }
   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_ARM64 ||
+           Obj.Header.Machine == COFF::IMAGE_FILE_MACHINE_ARM64EC;
   }
 
   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_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);
   ECase(IMAGE_FILE_MACHINE_POWERPCFP);
   ECase(IMAGE_FILE_MACHINE_R4000);
   ECase(IMAGE_FILE_MACHINE_RISCV32);
   ECase(IMAGE_FILE_MACHINE_RISCV64);
   ECase(IMAGE_FILE_MACHINE_RISCV128);
   ECase(IMAGE_FILE_MACHINE_SH3);
   ECase(IMAGE_FILE_MACHINE_SH3DSP);
   ECase(IMAGE_FILE_MACHINE_SH4);
   ECase(IMAGE_FILE_MACHINE_SH5);
   ECase(IMAGE_FILE_MACHINE_THUMB);
   ECase(IMAGE_FILE_MACHINE_WCEMIPSV2);
 }
 
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) {
+  } else if (H.Machine == COFF::IMAGE_FILE_MACHINE_ARM64 ||
+             H.Machine == COFF::IMAGE_FILE_MACHINE_ARM64EC) {
     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

case COFF::IMAGE_FILE_MACHINE_I386:
     break;
   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:
     CpuType = CPUType::ARM64;
     break;
   }
 
   if (CpuType)
     RegNames = getRegisterNames(*CpuType);
 
   for (const auto &E : RegNames) {

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

+# RUN: yaml2obj < %s | llvm-readobj - --file-headers | FileCheck %s
+# Check we can process a simple arm64ec file.
+# CHECK: Format: COFF-ARM64EC
+# CHECK: Machine: IMAGE_FILE_MACHINE_ARM64EC (0xA641)
+--- !COFF
+header:
+  Machine:         IMAGE_FILE_MACHINE_ARM64EC
+  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_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,
       COFFDumper *Dumper = reinterpret_cast<COFFDumper *>(user_data);
       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_ARMNT: {
-    ARM::WinEH::Decoder Decoder(W, Obj->getMachine() ==
-                                       COFF::IMAGE_FILE_MACHINE_ARM64);
+    ARM::WinEH::Decoder Decoder(W, Obj->getMachine() !=
+                                       COFF::IMAGE_FILE_MACHINE_ARMNT);
     // TODO Propagate the error.
     consumeError(Decoder.dumpProcedureData(*Obj));
     break;
   }
   default:
     W.printEnum("unsupported Image Machine", Obj->getMachine(),
                 makeArrayRef(ImageFileMachineType));
     break;