Add support for ARM64EC

crates/examples/src/objdump.rs

@@ -125,6 +125,9 @@ fn dump_parsed_object<W: Write, E: Write>(w: &mut W, e: &mut E, file: &object::F
     )?;
     writeln!(w, "Kind: {:?}", file.kind())?;
     writeln!(w, "Architecture: {:?}", file.architecture())?;
+    if let Some(sub_architecture) = file.sub_architecture() {
+        writeln!(w, "Sub-Architecture: {:?}", sub_architecture)?;
+    }
     writeln!(w, "Flags: {:x?}", file.flags())?;
     writeln!(
         w,
@@ -268,6 +271,9 @@ fn dump_import<W: Write, E: Write>(w: &mut W, e: &mut E, data: &[u8]) -> Result<
 
     writeln!(w, "Format: Short Import File")?;
     writeln!(w, "Architecture: {:?}", file.architecture())?;
+    if let Some(sub_architecture) = file.sub_architecture() {
+        writeln!(w, "Sub-Architecture: {:?}", sub_architecture)?;
+    }
     writeln!(w, "DLL: {:?}", String::from_utf8_lossy(file.dll()))?;
     writeln!(w, "Symbol: {:?}", String::from_utf8_lossy(file.symbol()))?;
     write!(w, "Import: ")?;

crates/examples/src/readobj/pe.rs

@@ -795,6 +795,7 @@ const FLAGS_IMAGE_FILE_MACHINE: &[Flag<u16>] = &flags!(
     IMAGE_FILE_MACHINE_AMD64,
     IMAGE_FILE_MACHINE_M32R,
     IMAGE_FILE_MACHINE_ARM64,
+    IMAGE_FILE_MACHINE_ARM64EC,
     IMAGE_FILE_MACHINE_CEE,
     IMAGE_FILE_MACHINE_RISCV32,
     IMAGE_FILE_MACHINE_RISCV64,

crates/examples/testfiles/coff/import_msvc.lib.objdump

@@ -198,7 +198,8 @@ Symbol map
 
 test_arm64ec.dll:
 Format: Short Import File
-Architecture: Unknown
+Architecture: Aarch64
+Sub-Architecture: Arm64EC
 DLL: "test_arm64ec.dll"
 Symbol: "#foo_arm64ec"
 Import: Name("foo_arm64ec")

crates/examples/testfiles/coff/import_msvc.lib.readobj

@@ -727,7 +727,7 @@ ImportObjectHeader {
     Signature1: 0x0
     Signature2: 0xFFFF
     Version: 0
-    Machine: 0xA641
+    Machine: IMAGE_FILE_MACHINE_ARM64EC (0xA641)
     TimeDateStamp: 1687268223
     SizeOfData: 0x2A
     OrdinalOrHint: 0

src/common.rs

@@ -33,6 +33,14 @@ pub enum Architecture {
     Xtensa,
 }
 
+/// A CPU sub-architecture.
+#[allow(missing_docs)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[non_exhaustive]
+pub enum SubArchitecture {
+    Arm64EC,
+}
+
 impl Architecture {
     /// The size of an address value for this architecture.
     ///

src/pe.rs

@@ -359,6 +359,8 @@ pub const IMAGE_FILE_MACHINE_AMD64: u16 = 0x8664;
 pub const IMAGE_FILE_MACHINE_M32R: u16 = 0x9041;
 /// ARM64 Little-Endian
 pub const IMAGE_FILE_MACHINE_ARM64: u16 = 0xAA64;
+/// ARM64EC ("Emulation Compatible")
+pub const IMAGE_FILE_MACHINE_ARM64EC: u16 = 0xA641;
 pub const IMAGE_FILE_MACHINE_CEE: u16 = 0xC0EE;
 /// RISCV32
 pub const IMAGE_FILE_MACHINE_RISCV32: u16 = 0x5032;

src/read/any.rs

@@ -14,12 +14,15 @@ use crate::read::pe;
 use crate::read::wasm;
 #[cfg(feature = "xcoff")]
 use crate::read::xcoff;
-use crate::read::{
-    self, Architecture, BinaryFormat, CodeView, ComdatKind, CompressedData, CompressedFileRange,
-    Error, Export, FileFlags, FileKind, Import, Object, ObjectComdat, ObjectKind, ObjectMap,
-    ObjectSection, ObjectSegment, ObjectSymbol, ObjectSymbolTable, ReadRef, Relocation, Result,
-    SectionFlags, SectionIndex, SectionKind, SegmentFlags, SymbolFlags, SymbolIndex, SymbolKind,
-    SymbolMap, SymbolMapName, SymbolScope, SymbolSection,
+use crate::{
+    read::{
+        self, Architecture, BinaryFormat, CodeView, ComdatKind, CompressedData,
+        CompressedFileRange, Error, Export, FileFlags, FileKind, Import, Object, ObjectComdat,
+        ObjectKind, ObjectMap, ObjectSection, ObjectSegment, ObjectSymbol, ObjectSymbolTable,
+        ReadRef, Relocation, Result, SectionFlags, SectionIndex, SectionKind, SegmentFlags,
+        SymbolFlags, SymbolIndex, SymbolKind, SymbolMap, SymbolMapName, SymbolScope, SymbolSection,
+    },
+    SubArchitecture,
 };
 #[allow(unused_imports)]
 use crate::{AddressSize, Endian, Endianness};
@@ -323,6 +326,10 @@ where
         with_inner!(self, File, |x| x.architecture())
     }
 
+    fn sub_architecture(&self) -> Option<SubArchitecture> {
+        with_inner!(self, File, |x| x.sub_architecture())
+    }
+
     fn is_little_endian(&self) -> bool {
         with_inner!(self, File, |x| x.is_little_endian())
     }

src/read/coff/file.rs

@@ -3,7 +3,7 @@ use core::fmt::Debug;
 
 use crate::read::{
     self, Architecture, Export, FileFlags, Import, NoDynamicRelocationIterator, Object, ObjectKind,
-    ObjectSection, ReadError, ReadRef, Result, SectionIndex, SymbolIndex,
+    ObjectSection, ReadError, ReadRef, Result, SectionIndex, SubArchitecture, SymbolIndex,
 };
 use crate::{pe, LittleEndian as LE, Pod};
 
@@ -78,13 +78,20 @@ where
     fn architecture(&self) -> Architecture {
         match self.header.machine() {
             pe::IMAGE_FILE_MACHINE_ARMNT => Architecture::Arm,
-            pe::IMAGE_FILE_MACHINE_ARM64 => Architecture::Aarch64,
+            pe::IMAGE_FILE_MACHINE_ARM64 | pe::IMAGE_FILE_MACHINE_ARM64EC => Architecture::Aarch64,
             pe::IMAGE_FILE_MACHINE_I386 => Architecture::I386,
             pe::IMAGE_FILE_MACHINE_AMD64 => Architecture::X86_64,
             _ => Architecture::Unknown,
         }
     }
 
+    fn sub_architecture(&self) -> Option<SubArchitecture> {
+        match self.header.machine() {
+            pe::IMAGE_FILE_MACHINE_ARM64EC => Some(SubArchitecture::Arm64EC),
+            _ => None,
+        }
+    }
+
     #[inline]
     fn is_little_endian(&self) -> bool {
         true

src/read/coff/import.rs

@@ -4,7 +4,7 @@
 //! dynamically imported symbols.
 
 use crate::read::{Architecture, Error, ReadError, ReadRef, Result};
-use crate::{pe, ByteString, Bytes, LittleEndian as LE};
+use crate::{pe, ByteString, Bytes, LittleEndian as LE, SubArchitecture};
 
 /// A Windows short form description of a symbol to import.
 ///
@@ -64,13 +64,21 @@ impl<'data> ImportFile<'data> {
     pub fn architecture(&self) -> Architecture {
         match self.header.machine.get(LE) {
             pe::IMAGE_FILE_MACHINE_ARMNT => Architecture::Arm,
-            pe::IMAGE_FILE_MACHINE_ARM64 => Architecture::Aarch64,
+            pe::IMAGE_FILE_MACHINE_ARM64 | pe::IMAGE_FILE_MACHINE_ARM64EC => Architecture::Aarch64,
             pe::IMAGE_FILE_MACHINE_I386 => Architecture::I386,
             pe::IMAGE_FILE_MACHINE_AMD64 => Architecture::X86_64,
             _ => Architecture::Unknown,
         }
     }
 
+    /// Get the sub machine type, if available.
+    pub fn sub_architecture(&self) -> Option<SubArchitecture> {
+        match self.header.machine.get(LE) {
+            pe::IMAGE_FILE_MACHINE_ARM64EC => Some(SubArchitecture::Arm64EC),
+            _ => None,
+        }
+    }
+
     /// The public symbol name.
     pub fn symbol(&self) -> &'data [u8] {
         self.symbol.0

src/read/coff/relocation.rs

@@ -40,15 +40,17 @@ impl<'data, 'file, R: ReadRef<'data>, Coff: CoffHeader> Iterator
                     pe::IMAGE_REL_ARM_SECREL => (RelocationKind::SectionOffset, 32, 0),
                     typ => (RelocationKind::Coff(typ), 0, 0),
                 },
-                pe::IMAGE_FILE_MACHINE_ARM64 => match relocation.typ.get(LE) {
-                    pe::IMAGE_REL_ARM64_ADDR32 => (RelocationKind::Absolute, 32, 0),
-                    pe::IMAGE_REL_ARM64_ADDR32NB => (RelocationKind::ImageOffset, 32, 0),
-                    pe::IMAGE_REL_ARM64_SECREL => (RelocationKind::SectionOffset, 32, 0),
-                    pe::IMAGE_REL_ARM64_SECTION => (RelocationKind::SectionIndex, 16, 0),
-                    pe::IMAGE_REL_ARM64_ADDR64 => (RelocationKind::Absolute, 64, 0),
-                    pe::IMAGE_REL_ARM64_REL32 => (RelocationKind::Relative, 32, -4),
-                    typ => (RelocationKind::Coff(typ), 0, 0),
-                },
+                pe::IMAGE_FILE_MACHINE_ARM64 | pe::IMAGE_FILE_MACHINE_ARM64EC => {
+                    match relocation.typ.get(LE) {
+                        pe::IMAGE_REL_ARM64_ADDR32 => (RelocationKind::Absolute, 32, 0),
+                        pe::IMAGE_REL_ARM64_ADDR32NB => (RelocationKind::ImageOffset, 32, 0),
+                        pe::IMAGE_REL_ARM64_SECREL => (RelocationKind::SectionOffset, 32, 0),
+                        pe::IMAGE_REL_ARM64_SECTION => (RelocationKind::SectionIndex, 16, 0),
+                        pe::IMAGE_REL_ARM64_ADDR64 => (RelocationKind::Absolute, 64, 0),
+                        pe::IMAGE_REL_ARM64_REL32 => (RelocationKind::Relative, 32, -4),
+                        typ => (RelocationKind::Coff(typ), 0, 0),
+                    }
+                }
                 pe::IMAGE_FILE_MACHINE_I386 => match relocation.typ.get(LE) {
                     pe::IMAGE_REL_I386_DIR16 => (RelocationKind::Absolute, 16, 0),
                     pe::IMAGE_REL_I386_REL16 => (RelocationKind::Relative, 16, 0),

src/read/mod.rs

@@ -252,6 +252,8 @@ impl FileKind {
             [0xc4, 0x01, ..]
             // COFF arm64
             | [0x64, 0xaa, ..]
+            // COFF arm64ec
+            | [0x41, 0xa6, ..]
             // COFF x86
             | [0x4c, 0x01, ..]
             // COFF x86-64

src/read/pe/file.rs

@@ -9,7 +9,7 @@ use crate::read::{
     self, Architecture, ComdatKind, Error, Export, FileFlags, Import, NoDynamicRelocationIterator,
     Object, ObjectComdat, ObjectKind, ReadError, ReadRef, Result, SectionIndex, SymbolIndex,
 };
-use crate::{pe, ByteString, Bytes, CodeView, LittleEndian as LE, Pod, U32};
+use crate::{pe, ByteString, Bytes, CodeView, LittleEndian as LE, Pod, SubArchitecture, U32};
 
 use super::{
     DataDirectories, ExportTable, ImageThunkData, ImportTable, PeSection, PeSectionIterator,
@@ -147,13 +147,20 @@ where
     fn architecture(&self) -> Architecture {
         match self.nt_headers.file_header().machine.get(LE) {
             pe::IMAGE_FILE_MACHINE_ARMNT => Architecture::Arm,
-            pe::IMAGE_FILE_MACHINE_ARM64 => Architecture::Aarch64,
+            pe::IMAGE_FILE_MACHINE_ARM64 | pe::IMAGE_FILE_MACHINE_ARM64EC => Architecture::Aarch64,
             pe::IMAGE_FILE_MACHINE_I386 => Architecture::I386,
             pe::IMAGE_FILE_MACHINE_AMD64 => Architecture::X86_64,
             _ => Architecture::Unknown,
         }
     }
 
+    fn sub_architecture(&self) -> Option<SubArchitecture> {
+        match self.nt_headers.file_header().machine.get(LE) {
+            pe::IMAGE_FILE_MACHINE_ARM64EC => Some(SubArchitecture::Arm64EC),
+            _ => None,
+        }
+    }
+
     #[inline]
     fn is_little_endian(&self) -> bool {
         // Only little endian is supported.

src/read/traits.rs

@@ -4,8 +4,8 @@ use alloc::vec::Vec;
 use crate::read::{
     self, Architecture, CodeView, ComdatKind, CompressedData, CompressedFileRange, Export,
     FileFlags, Import, ObjectKind, ObjectMap, Relocation, Result, SectionFlags, SectionIndex,
-    SectionKind, SegmentFlags, SymbolFlags, SymbolIndex, SymbolKind, SymbolMap, SymbolMapName,
-    SymbolScope, SymbolSection,
+    SectionKind, SegmentFlags, SubArchitecture, SymbolFlags, SymbolIndex, SymbolKind, SymbolMap,
+    SymbolMapName, SymbolScope, SymbolSection,
 };
 use crate::Endianness;
 
@@ -51,6 +51,11 @@ pub trait Object<'data: 'file, 'file>: read::private::Sealed {
     /// Get the architecture type of the file.
     fn architecture(&self) -> Architecture;
 
+    /// Get the sub-architecture type of the file.
+    fn sub_architecture(&self) -> Option<SubArchitecture> {
+        None
+    }
+
     /// Get the endianness of the file.
     #[inline]
     fn endianness(&self) -> Endianness {

src/write/coff/object.rs

@@ -270,7 +270,12 @@ impl<'a> Object<'a> {
         writer.write_file_header(writer::FileHeader {
             machine: match self.architecture {
                 Architecture::Arm => coff::IMAGE_FILE_MACHINE_ARMNT,
-                Architecture::Aarch64 => coff::IMAGE_FILE_MACHINE_ARM64,
+                Architecture::Aarch64 => match self.sub_architecture {
+                    None => coff::IMAGE_FILE_MACHINE_ARM64,
+                    Some(SubArchitecture::Arm64EC) => coff::IMAGE_FILE_MACHINE_ARM64EC,
+                    #[allow(unreachable_patterns)]
+                    _ => unimplemented!(),
+                },
                 Architecture::I386 => coff::IMAGE_FILE_MACHINE_I386,
                 Architecture::X86_64 => coff::IMAGE_FILE_MACHINE_AMD64,
                 _ => {

src/write/mod.rs

@@ -1,6 +1,6 @@
 //! Interface for writing object files.
 
-use alloc::borrow::Cow;
+use alloc::borrow::{Cow, ToOwned};
 use alloc::string::String;
 use alloc::vec::Vec;
 use core::{fmt, result, str};
@@ -12,7 +12,7 @@ use std::{boxed::Box, collections::HashMap, error, io};
 use crate::endian::{Endianness, U32, U64};
 use crate::{
     Architecture, BinaryFormat, ComdatKind, FileFlags, RelocationEncoding, RelocationKind,
-    SectionFlags, SectionKind, SymbolFlags, SymbolKind, SymbolScope,
+    SectionFlags, SectionKind, SubArchitecture, SymbolFlags, SymbolKind, SymbolScope,
 };
 
 #[cfg(feature = "coff")]
@@ -62,6 +62,7 @@ pub type Result<T> = result::Result<T, Error>;
 pub struct Object<'a> {
     format: BinaryFormat,
     architecture: Architecture,
+    sub_architecture: Option<SubArchitecture>,
     endian: Endianness,
     sections: Vec<Section<'a>>,
     standard_sections: HashMap<StandardSection, SectionId>,
@@ -88,6 +89,7 @@ impl<'a> Object<'a> {
         Object {
             format,
             architecture,
+            sub_architecture: None,
             endian,
             sections: Vec::new(),
             standard_sections: HashMap::new(),
@@ -117,6 +119,26 @@ impl<'a> Object<'a> {
         self.architecture
     }
 
+    /// Return the sub-architecture.
+    #[inline]
+    pub fn sub_architecture(&self) -> Option<SubArchitecture> {
+        self.sub_architecture
+    }
+
+    /// Specify the sub-architecture.
+    pub fn set_sub_architecture(
+        &mut self,
+        sub_architecture: Option<SubArchitecture>,
+    ) -> Result<()> {
+        match (self.architecture, sub_architecture) {
+            (Architecture::Aarch64, Some(SubArchitecture::Arm64EC)) | (_, None) => {
+                self.sub_architecture = sub_architecture;
+                Ok(())
+            }
+            _ => Err(Error("Unsupported sub-architecture".to_owned())),
+        }
+    }
+
     /// Return the current mangling setting.
     #[inline]
     pub fn mangling(&self) -> Mangling {