Add ArchTag trait and its implementations for supported architectures

This commit is the first commit among a series of patches that implement the
compile-time architecture tag proposal in #118. It contains the following major
changes:

- Add the ArchTag trait. This trait indicates a "tag" type that represents a
  specific architecture. Its associated types specify specific data types
  corresponding to the architecture it represents.

- Add ArchTag implementations for supported architectures, and a special
  DynamicArchTag that indicates the target architecture is unknown at compile
  time.

- Update existing general type definitions (e.g. Capstone, Insn, etc.) to
  acquire a general arch tag type parameter.

Author: Lancern

capstone-rs/src/arch/arm.rs

@@ -9,8 +9,10 @@ use capstone_sys::{
 use libc::c_uint;
 
 pub use crate::arch::arch_builder::arm::*;
-use crate::arch::DetailsArchInsn;
+use crate::arch::{ArchTag, DetailsArchInsn};
+use crate::arch::internal::ArchTagSealed;
 use crate::instruction::{RegId, RegIdInt};
+use crate::{Arch, InsnDetail};
 
 pub use capstone_sys::arm_insn_group as ArmInsnGroup;
 pub use capstone_sys::arm_insn as ArmInsn;
@@ -22,9 +24,37 @@ pub use capstone_sys::arm_cc as ArmCC;
 pub use capstone_sys::arm_mem_barrier as ArmMemBarrier;
 pub use capstone_sys::arm_setend_type as ArmSetendType;
 
+pub struct ArmArchTag;
+
+impl ArchTagSealed for ArmArchTag {}
+
+impl ArchTag for ArmArchTag {
+    type Builder = ArchCapstoneBuilder;
+
+    type Mode = ArchMode;
+    type ExtraMode = ArchExtraMode;
+    type Syntax = ArchSyntax;
+
+    type RegId = ArmReg::Type;
+    type InsnId = ArmInsn;
+    type InsnGroupId = ArmInsnGroup::Type;
+
+    type InsnDetail<'a> = ArmInsnDetail<'a>;
+
+    fn support_arch(arch: Arch) -> bool {
+        arch == Arch::ARM
+    }
+}
+
 /// Contains ARM-specific details for an instruction
 pub struct ArmInsnDetail<'a>(pub(crate) &'a cs_arm);
 
+impl<'a, 'i> From<&'i InsnDetail<'a, ArmArchTag>> for ArmInsnDetail<'a> {
+    fn from(value: &'i InsnDetail<'a, ArmArchTag>) -> Self {
+        Self(unsafe { &value.0.__bindgen_anon_1.arm })
+    }
+}
+
 /// ARM shift amount
 #[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
 pub enum ArmShift {

capstone-rs/src/arch/arm64.rs

@@ -1,13 +1,16 @@
 //! Contains arm64-specific types
 
+use core::convert::From;
+use core::{cmp, fmt, mem, slice};
+
+use capstone_sys::{arm64_op_mem, arm64_op_type, cs_arm64, cs_arm64_op};
 use libc::c_uint;
 
 pub use crate::arch::arch_builder::arm64::*;
-use crate::arch::DetailsArchInsn;
-use capstone_sys::{arm64_op_mem, arm64_op_type, cs_arm64, cs_arm64_op};
+use crate::arch::{ArchTag, DetailsArchInsn};
+use crate::arch::internal::ArchTagSealed;
 use crate::instruction::{RegId, RegIdInt};
-use core::convert::From;
-use core::{cmp, fmt, mem, slice};
+use crate::{Arch, InsnDetail};
 
 // Re-exports
 pub use capstone_sys::arm64_insn_group as Arm64InsnGroup;
@@ -26,10 +29,37 @@ pub use capstone_sys::arm64_barrier_op as Arm64BarrierOp;
 use capstone_sys::cs_arm64_op__bindgen_ty_2;
 use capstone_sys::arm64_shifter;
 
+pub struct Arm64ArchTag;
+
+impl ArchTagSealed for Arm64ArchTag {}
+
+impl ArchTag for Arm64ArchTag {
+    type Builder = ArchCapstoneBuilder;
+
+    type Mode = ArchMode;
+    type ExtraMode = ArchExtraMode;
+    type Syntax = ArchSyntax;
+
+    type RegId = Arm64Reg::Type;
+    type InsnId = Arm64Insn;
+    type InsnGroupId = Arm64InsnGroup::Type;
+
+    type InsnDetail<'a> = Arm64InsnDetail<'a>;
+
+    fn support_arch(arch: Arch) -> bool {
+        arch == Arch::ARM64
+    }
+}
 
 /// Contains ARM64-specific details for an instruction
 pub struct Arm64InsnDetail<'a>(pub(crate) &'a cs_arm64);
 
+impl<'a, 'i> From<&'i InsnDetail<'a, Arm64ArchTag>> for Arm64InsnDetail<'a> {
+    fn from(value: &'i InsnDetail<'a, Arm64ArchTag>) -> Self {
+        Self(unsafe { &value.0.__bindgen_anon_1.arm64 })
+    }
+}
+
 /// ARM64 shift amount
 #[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
 pub enum Arm64Shift {

capstone-rs/src/arch/evm.rs

@@ -9,7 +9,31 @@ pub use capstone_sys::evm_insn_group as EvmInsnGroup;
 pub use capstone_sys::evm_insn as EvmInsn;
 
 pub use crate::arch::arch_builder::evm::*;
-use crate::arch::DetailsArchInsn;
+use crate::arch::{ArchTag, DetailsArchInsn};
+use crate::arch::internal::ArchTagSealed;
+use crate::{Arch, InsnDetail};
+
+pub struct EvmArchTag;
+
+impl ArchTagSealed for EvmArchTag {}
+
+impl ArchTag for EvmArchTag {
+    type Builder = ArchCapstoneBuilder;
+
+    type Mode = ArchMode;
+    type ExtraMode = ArchExtraMode;
+    type Syntax = ArchSyntax;
+
+    type RegId = u32;
+    type InsnId = EvmInsn;
+    type InsnGroupId = EvmInsnGroup::Type;
+
+    type InsnDetail<'a> = EvmInsnDetail<'a>;
+
+    fn support_arch(arch: Arch) -> bool {
+        arch == Arch::EVM
+    }
+}
 
 /// Contains EVM-specific details for an instruction
 pub struct EvmInsnDetail<'a>(pub(crate) &'a cs_evm);
@@ -35,6 +59,12 @@ impl_PartialEq_repr_fields!(EvmInsnDetail<'a> [ 'a ];
     popped_items, pushed_items, fee
 );
 
+impl<'a, 'i> From<&'i InsnDetail<'a, EvmArchTag>> for EvmInsnDetail<'a> {
+    fn from(value: &'i InsnDetail<'a, EvmArchTag>) -> Self {
+        Self(unsafe { &value.0.__bindgen_anon_1.evm })
+    }
+}
+
 /// EVM has no operands, so this is a zero-size type.
 #[derive(Clone, Debug, Eq, PartialEq, Default)]
 pub struct EvmOperand(());

capstone-rs/src/arch/m680x.rs

@@ -12,9 +12,32 @@ pub use capstone_sys::m680x_insn as M680xInsn;
 pub use capstone_sys::m680x_reg as M680xReg;
 
 pub use crate::arch::arch_builder::m680x::*;
-use crate::arch::DetailsArchInsn;
+use crate::arch::{ArchTag, DetailsArchInsn};
+use crate::arch::internal::ArchTagSealed;
 use crate::instruction::{RegId, RegIdInt};
+use crate::{Arch, InsnDetail};
 
+pub struct M680xArchTag;
+
+impl ArchTagSealed for M680xArchTag {}
+
+impl ArchTag for M680xArchTag {
+    type Builder = ArchCapstoneBuilder;
+
+    type Mode = ArchMode;
+    type ExtraMode = ArchExtraMode;
+    type Syntax = ArchSyntax;
+
+    type RegId = M680xReg::Type;
+    type InsnId = M680xInsn;
+    type InsnGroupId = u32;
+
+    type InsnDetail<'a> = M680xInsnDetail<'a>;
+
+    fn support_arch(arch: Arch) -> bool {
+        arch == Arch::M680X
+    }
+}
 
 /// Contains M680X-specific details for an instruction
 pub struct M680xInsnDetail<'a>(pub(crate) &'a cs_m680x);
@@ -23,6 +46,12 @@ impl_PartialEq_repr_fields!(M680xInsnDetail<'a> [ 'a ];
     operands, flags
 );
 
+impl<'a, 'i> From<&'i InsnDetail<'a, M680xArchTag>> for M680xInsnDetail<'a> {
+    fn from(value: &'i InsnDetail<'a, M680xArchTag>) -> Self {
+        Self(unsafe { &value.0.__bindgen_anon_1.m680x })
+    }
+}
+
 // M680X instruction flags
 const M680X_FIRST_OP_IN_MNEM: u8 = 1;
 const M680X_SECOND_OP_IN_MNEM: u8 = 2;

capstone-rs/src/arch/m68k.rs

@@ -14,11 +14,33 @@ pub use capstone_sys::m68k_insn as M68kInsn;
 pub use capstone_sys::m68k_reg as M68kReg;
 
 pub use crate::arch::arch_builder::m68k::*;
-use crate::arch::DetailsArchInsn;
-use crate::Error;
+use crate::arch::{ArchTag, DetailsArchInsn};
+use crate::arch::internal::ArchTagSealed;
+use crate::{Arch, Error, InsnDetail};
 use crate::instruction::{RegId, RegIdInt};
 use crate::prelude::*;
 
+pub struct M68kArchTag;
+
+impl ArchTagSealed for M68kArchTag {}
+
+impl ArchTag for M68kArchTag {
+    type Builder = ArchCapstoneBuilder;
+
+    type Mode = ArchMode;
+    type ExtraMode = ArchExtraMode;
+    type Syntax = ArchSyntax;
+
+    type RegId = M68kReg::Type;
+    type InsnId = M68kInsn;
+    type InsnGroupId = u32;
+
+    type InsnDetail<'a> = M68kInsnDetail<'a>;
+
+    fn support_arch(arch: Arch) -> bool {
+        arch == Arch::M68K
+    }
+}
 
 /// Contains M68K-specific details for an instruction
 pub struct M68kInsnDetail<'a>(pub(crate) &'a cs_m68k);
@@ -30,6 +52,12 @@ impl<'a> M68kInsnDetail<'a> {
     }
 }
 
+impl<'a, 'i> From<&'i InsnDetail<'a, M68kArchTag>> for M68kInsnDetail<'a> {
+    fn from(value: &'i InsnDetail<'a, M68kArchTag>) -> Self {
+        Self(unsafe { &value.0.__bindgen_anon_1.m68k })
+    }
+}
+
 define_cs_enum_wrapper_reverse!(
     [
         /// Operation size of the CPU instructions
@@ -638,8 +666,7 @@ mod test {
         use crate::instruction::*;
         use crate::arch::DetailsArchInsn;
 
-        let cs = Capstone::new()
-            .m68k()
+        let cs = Capstone::<M68kArchTag>::new()
             .mode(arch::m68k::ArchMode::M68k040)
             .detail(true)
             .build()
@@ -657,10 +684,9 @@ mod test {
         let mut insns_iter = insns.iter();
 
         // jsr
-        let insn_jsr: &Insn = insns_iter.next().unwrap();
+        let insn_jsr: &Insn<M68kArchTag> = insns_iter.next().unwrap();
         let detail = cs.insn_detail(insn_jsr).unwrap();
-        let _arch_detail = detail.arch_detail();
-        let arch_detail = _arch_detail.m68k().unwrap();
+        let arch_detail = detail.arch_detail();
         let mut ops = arch_detail.operands();
         if let M68kOperand::Mem(mem) = ops.next().unwrap() {
             assert_eq!(mem.imm(), Some(0x12));

capstone-rs/src/arch/mips.rs

@@ -11,8 +11,32 @@ pub use capstone_sys::mips_insn as MipsInsn;
 pub use capstone_sys::mips_reg as MipsReg;
 
 pub use crate::arch::arch_builder::mips::*;
-use crate::arch::DetailsArchInsn;
+use crate::arch::{ArchTag, DetailsArchInsn};
+use crate::arch::internal::ArchTagSealed;
 use crate::instruction::{RegId, RegIdInt};
+use crate::{Arch, InsnDetail};
+
+pub struct MipsArchTag;
+
+impl ArchTagSealed for MipsArchTag {}
+
+impl ArchTag for MipsArchTag {
+    type Builder = ArchCapstoneBuilder;
+
+    type Mode = ArchMode;
+    type ExtraMode = ArchExtraMode;
+    type Syntax = ArchSyntax;
+
+    type RegId = MipsReg::Type;
+    type InsnId = MipsInsn;
+    type InsnGroupId = MipsInsnGroup::Type;
+
+    type InsnDetail<'a> = MipsInsnDetail<'a>;
+
+    fn support_arch(arch: Arch) -> bool {
+        arch == Arch::MIPS
+    }
+}
 
 /// Contains MIPS-specific details for an instruction
 pub struct MipsInsnDetail<'a>(pub(crate) &'a cs_mips);
@@ -21,6 +45,12 @@ impl_PartialEq_repr_fields!(MipsInsnDetail<'a> [ 'a ];
     operands
 );
 
+impl<'a, 'i> From<&'i InsnDetail<'a, MipsArchTag>> for MipsInsnDetail<'a> {
+    fn from(value: &'i InsnDetail<'a, MipsArchTag>) -> Self {
+        Self(unsafe { &value.0.__bindgen_anon_1.mips })
+    }
+}
+
 /// MIPS operand
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub enum MipsOperand {