wip towards a v1

4 files changed, 1189 insertions, 64 deletions

diff --git a/Cargo.lock b/Cargo.lock
index 7983b37..b9f031d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -7,6 +7,24 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a"
 
 [[package]]
+name = "bitvec"
+version = "0.19.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8775e5606af6e145d17376be6d95f98245d393a143b41b7feba50d6b3d8367cd"
+dependencies = [
+ "funty",
+ "radium",
+ "tap",
+ "wyz",
+]
+
+[[package]]
+name = "funty"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ba62103ce691c2fd80fbae2213dfdda9ce60804973ac6b6e97de818ea7f52c8"
+
+[[package]]
 name = "num-traits"
 version = "0.2.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -16,6 +34,24 @@ dependencies = [
 ]
 
 [[package]]
+name = "radium"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a333b5f6adeff5a89f2e95dc2ea1ecb5319abbb56212afea6a37f87435338a5"
+
+[[package]]
+name = "tap"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36474e732d1affd3a6ed582781b3683df3d0563714c59c39591e8ff707cf078e"
+
+[[package]]
+name = "wyz"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85e60b0d1b5f99db2556934e21937020776a5d31520bf169e851ac44e6420214"
+
+[[package]]
 name = "yaxpeax-arch"
 version = "0.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -28,5 +64,6 @@ dependencies = [
 name = "yaxpeax-ia64"
 version = "0.0.1"
 dependencies = [
+ "bitvec",
  "yaxpeax-arch",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index 5d64136..c9ec03e 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -9,3 +9,4 @@ description = "ia64 decoder for the yaxpeax project"
 
 [dependencies]
 yaxpeax-arch = { version = "0.0.4", default-features = false, features = [] }
+bitvec = "*"
diff --git a/src/lib.rs b/src/lib.rs
index bfd0b37..ddfbe09 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,4 +1,6 @@
 use yaxpeax_arch::{Arch, AddressDiff, Decoder, LengthedInstruction, NoColors, YaxColors};
+use yaxpeax_arch::AddressBase;
+use bitvec::prelude::*;
 
 use core::fmt;
 
@@ -14,12 +16,243 @@ impl Arch for IA64 {
     type Operand = Operand;
 }
 
+#[derive(Debug, PartialEq, Eq, Copy, Clone)]
+pub enum Opcode {
+    // TODO; maybe don't actually do this one huh
+    Purple,
+
+    Addp4,
+    Adds,
+    Addl,
+    Add,
+    AddPlusOne,
+    Sub,
+    SubMinusOne,
+    SubImm,
+    AndImm,
+    AndcmImm,
+    OrImm,
+    XorImm,
+    And,
+    Andcm,
+    Or,
+    Xor,
+
+    Ptc_l,
+    Probe_w_imm,
+    Mov_to_psr_um,
+    Probe_w,
+    Ptc_g,
+    Thash,
+    Mov_m,
+    Ptc_ga,
+    Ttag,
+    Ptr_d,
+    Mov_to_cr,
+    Ptr_i,
+    Mov_to_psr_l,
+    Itr_d,
+    Tpa,
+    Itc_d,
+    Itr_i,
+    Tak,
+    Itc_i,
+    Chk_s_m_int,
+    Chk_s_fp,
+    Alloc,
+    Ld1,
+    Ld2,
+    Ld4,
+    Ld8,
+    Ld1_s,
+    Ld2_s,
+    Ld4_s,
+    Ld8_s,
+    Ld1_a,
+    Ld2_a,
+    Ld4_a,
+    Ld8_a,
+    Ld1_sa,
+    Ld2_sa,
+    Ld4_sa,
+    Ld8_sa,
+    Ld1_bias,
+    Ld2_bias,
+    Ld4_bias,
+    Ld8_bias,
+    Ld1_acq,
+    Ld2_acq,
+    Ld4_acq,
+    Ld8_acq,
+    Ld8_fill,
+    Ld1_c_clr,
+    Ld2_c_clr,
+    Ld4_c_clr,
+    Ld8_c_clr,
+    Ld1_c_nc,
+    Ld2_c_nc,
+    Ld4_c_nc,
+    Ld8_c_nc,
+    Ld1_c_clr_acq,
+    Ld2_c_clr_acq,
+    Ld4_c_clr_acq,
+    Ld8_c_clr_acq,
+    St1,
+    St2,
+    St4,
+    St8,
+    St1_rel,
+    St2_rel,
+    St4_rel,
+    St8_rel,
+    St8_spill,
+    Mov_to_pmd,
+    Mov_from_pmd,
+    Mov_from_psr,
+    Mov_from_cpuid,
+    Probe_r_imm,
+    Probe_r,
+    Cmpxchg1_acq,
+    Cmpxchg2_acq,
+    Cmpxchg4_acq,
+    Cmpxchg8_acq,
+    Cmpxchg1_rel,
+    Cmpxchg2_rel,
+    Cmpxchg4_rel,
+    Cmpxchg8_rel,
+    Xchg1,
+    Xchg2,
+    Xchg4,
+    Xchg8,
+    Fetchadd4_acq,
+    Fetchadd8_acq,
+    Fetchadd4_rel,
+    Fetchadd8_rel,
+    Getf_sig,
+    Getf_exp,
+    Getf_s,
+    Getf_d,
+    Cmp8xchg16_acq,
+    Cmp8xchg16_rel,
+    Ld16,
+    Ld16_acq,
+    St16,
+    St16_rel,
+    Ldfe,
+    Ldf8,
+    Ldfs,
+    Ldfd,
+    Ldfe_s,
+    Ldf8_s,
+    Ldfs_s,
+    Ldfd_s,
+    Ldfe_a,
+    Ldf8_a,
+    Ldfs_a,
+    Ldfd_a,
+    Ldfe_sa,
+    Ldf8_sa,
+    Ldfs_sa,
+    Ldfd_sa,
+    Ldf_fill,
+    Ldfe_c_clr,
+    Ldf8_c_clr,
+    Ldfs_c_clr,
+    Ldfd_c_clr,
+    Ldfp8_c_clr,
+    Ldfps_c_clr,
+    Ldfpd_c_clr,
+    Ldfp8_c_nc,
+    Ldfps_c_nc,
+    Ldfpd_c_nc,
+    Ldfp8,
+    Ldfps_a,
+    Ldfps_sa,
+    Invala,
+    Fwb,
+    Srlz_d,
+    Srlz_i,
+    Invala_e_int,
+    Mf,
+    Invala_e_fp,
+    Mf_a,
+    Sync_i,
+    Sum,
+    Rum,
+    Ssm,
+    Rsm,
+    Loadrs,
+    Flushrs,
+    Hint_m,
+    Nop_m,
+    Chk_a_nc_int,
+    Chk_a_clr_int,
+    Chk_a_nc_fp,
+    Chk_a_clr_fp,
+    Mov_to_rr,
+    Mov_from_rr,
+    Fc,
+    Mov_to_dbr,
+    Mov_from_dbr,
+    Mov_from_psr_um,
+    Probe_rw_fault_imm,
+    Mov_to_ibr,
+    Mov_from_ibr,
+    Mov_m_from_ar,
+    Probe_r_fault_imm,
+    Mov_to_pkr,
+    Mov_fom_pkr,
+    Probe_w_fault_imm,
+    Mov_to_pmc,
+    Mov_from_pmc,
+    Mov_from_cr,
+    Ptc_e,
+    Ldfp_a,
+    Ldfp_sa,
+    Ldfe_c_nc,
+    Ldf8_c_nc,
+    Ldfs_c_nc,
+    Ldfd_c_nc,
+    Lfetch,
+    Lfetch_excl,
+    Lfetch_fault,
+    Lfetch_fault_excl,
+    Stfe,
+    Stf8,
+    Stfs,
+    Stfd,
+    Stf_spill,
+
+    Shladd,
+    Shladdp4,
+
+    Padd1,
+    Padd1_sss,
+    Padd1_uuu,
+    Padd1_uus,
+    Psub1,
+    Psub1_sss,
+    Psub1_uuu,
+    Psub1_uus,
+
+    Ldfps,
+    Ldfpd,
+    Ldfp8_s,
+    Ldfps_s,
+    Ldfpd_s,
+    Ldfp8_a,
+    Ldfp8_a,
+    Ldfpd_a,
+    Ldfp8_sa,
+    Ldfp8_sa,
+    Ldfpd_sa,
+}
 #[derive(Debug, PartialEq, Eq)]
 pub struct Instruction {}
 impl yaxpeax_arch::LengthedInstruction for Instruction {
     type Unit = yaxpeax_arch::AddressDiff<u64>;
-    fn len(&self) -> Self::Unit { AddressDiff::from_const(1) }
-    fn min_size() -> Self::Unit { AddressDiff::from_const(1) }
+    fn len(&self) -> Self::Unit { AddressDiff::from_const(16) }
+    fn min_size() -> Self::Unit { AddressDiff::from_const(16) }
 }
 impl yaxpeax_arch::Instruction for Instruction {
     fn well_defined(&self) -> bool {
@@ -78,52 +311,930 @@ pub struct InstDecoder {}
 #[derive(Debug)]
 pub enum Operand {}
 
+#[derive(Debug)]
+pub enum Register {
+    Application,
+    Branch,
+    Control,
+    CpuId,
+    DataBreakpoint,
+    InstructionBreakpoint,
+    DataTLBCache,
+    DataTLBRegister,
+    FloatingPoint,
+    General,
+    InstructionTLBCache,
+    InstructionTLBRegister,
+    ProtectionKey,
+    PerformanceMonitorConfiguration,
+    PerformanceMonitorData,
+    Predicate,
+    Region,
+}
 impl Decoder<Instruction> for InstDecoder {
     type Error = DecodeError;
 
     fn decode_into<T: IntoIterator<Item=u8>>(&self, inst: &mut Instruction, bytes: T) -> Result<(), Self::Error> {
+        #[derive(Debug, Copy, Clone, Eq, PartialEq)]
+        enum InstructionType {
+            A,
+            I,
+            M,
+            F,
+            B,
+            LX,
+        }
+
         let mut bytes_iter = bytes.into_iter();
-        let bundle = bytes_iter.next().ok_or(DecodeError::ExhaustedInput)?;
-        let bundle_tag = bundle & 0x1f;
-        let bundle_desc = match bundle_tag {
-            0x00 => { "M I I " },
-            0x01 => { "M I I|" },
-            0x02 => { "M I|I " },
-            0x03 => { "M I|I|" },
-            0x04 => { "M L X " },
-            0x05 => { "M L X|" },
-            0x06 => { return Err(DecodeError::BadBundle) },
-            0x07 => { return Err(DecodeError::BadBundle) },
-            0x08 => { "M M I " },
-            0x09 => { "M M I|" },
-            0x0a => { "M|M I " },
-            0x0b => { "M|M I|" },
-            0x0c => { "M F I " },
-            0x0d => { "M F I|" },
-            0x0e => { "M M F " },
-            0x0f => { "M M F|" },
-            0x10 => { "M I B " },
-            0x11 => { "M I B|" },
-            0x12 => { "M B B " },
-            0x13 => { "M B B|" },
-            0x14 => { return Err(DecodeError::BadBundle) },
-            0x15 => { return Err(DecodeError::BadBundle) },
-            0x16 => { "B B B " },
-            0x17 => { "B B B|" },
-            0x18 => { "M M B " },
-            0x19 => { "M M B|" },
-            0x1a => { return Err(DecodeError::BadBundle) },
-            0x1b => { return Err(DecodeError::BadBundle) },
-            0x1c => { "M F B " },
-            0x1d => { "M F B|" },
-            0x1e => { return Err(DecodeError::BadBundle) },
-            0x1f => { return Err(DecodeError::BadBundle) },
-            _ => { unreachable!(); }
-        };
-        eprintln!("bundle tag: {}", bundle_desc);
+        let mut instruction_bytes = bitarr![Lsb0, u8; 0u8; 128];
+        for i in 0..0u64.wrapping_offset(Instruction::min_size()).to_linear() {
+            instruction_bytes[(i * 8)..(i * 8 + 8)].store(bytes_iter.next().ok_or(DecodeError::ExhaustedInput)?);
+        }
+//        let instruction_bits = instruction_bytes.view_bits::<Lsb0>();
+        let bundle_tag = instruction_bytes[0..5].load::<u8>();
+        eprintln!("{:?}", instruction_bytes);
+        let instruction_words = [
+            &instruction_bytes[87..128],
+            &instruction_bytes[46..87],
+            &instruction_bytes[5..46],
+        ];
+        println!("bundle tag is now {:#05b}", bundle_tag);
+        type BundleDesc = ([InstructionType; 3], u8); // u8 is a bitmap of which instructions are followed by stops.
+        const BUNDLE_TAGS: [Option<BundleDesc>; 32] = [
+            Some(([InstructionType::M, InstructionType::I, InstructionType::I], 0b000)),
+            Some(([InstructionType::M, InstructionType::I, InstructionType::I], 0b001)),
+            Some(([InstructionType::M, InstructionType::I, InstructionType::I], 0b010)),
+            Some(([InstructionType::M, InstructionType::I, InstructionType::I], 0b011)),
+            Some(([InstructionType::M, InstructionType::LX, InstructionType::LX], 0b000)),
+            Some(([InstructionType::M, InstructionType::LX, InstructionType::LX], 0b010)),
+            None,
+            None,
+            Some(([InstructionType::M, InstructionType::M, InstructionType::I], 0b000)),
+            Some(([InstructionType::M, InstructionType::M, InstructionType::I], 0b001)),
+            Some(([InstructionType::M, InstructionType::M, InstructionType::I], 0b100)),
+            Some(([InstructionType::M, InstructionType::M, InstructionType::I], 0b101)),
+            Some(([InstructionType::M, InstructionType::F, InstructionType::I], 0b000)),
+            Some(([InstructionType::M, InstructionType::F, InstructionType::I], 0b001)),
+            Some(([InstructionType::M, InstructionType::M, InstructionType::F], 0b000)),
+            Some(([InstructionType::M, InstructionType::M, InstructionType::F], 0b001)),
+            Some(([InstructionType::M, InstructionType::I, InstructionType::B], 0b000)),
+            Some(([InstructionType::M, InstructionType::I, InstructionType::B], 0b001)),
+            Some(([InstructionType::M, InstructionType::B, InstructionType::B], 0b000)),
+            Some(([InstructionType::M, InstructionType::B, InstructionType::B], 0b001)),
+            None,
+            None,
+            Some(([InstructionType::B, InstructionType::B, InstructionType::B], 0b000)),
+            Some(([InstructionType::B, InstructionType::B, InstructionType::B], 0b001)),
+            Some(([InstructionType::M, InstructionType::M, InstructionType::B], 0b000)),
+            Some(([InstructionType::M, InstructionType::M, InstructionType::B], 0b001)),
+            None,
+            None,
+            Some(([InstructionType::M, InstructionType::F, InstructionType::B], 0b000)),
+            Some(([InstructionType::M, InstructionType::F, InstructionType::B], 0b001)),
+            None,
+            None,
+        ];
+        let (instruction_types, stop_mask) = BUNDLE_TAGS[bundle_tag as usize].ok_or(DecodeError::BadBundle)?;
+        eprintln!("bundle types: {:?}, stop_mask: {:#b}", instruction_types, stop_mask);
+
+        fn decode_instruction(word: &BitSlice<Lsb0, u8>, ty: InstructionType) -> Instruction {
+            eprintln!("as slice: {:?}", word);
+            let tag = word[37..41].load::<u8>();
+            eprintln!("tag: {:#x}", tag);
+
+            let ty = if tag >= 8 && (ty == InstructionType::M || ty == InstructionType::I) {
+                InstructionType::A
+            } else {
+                ty
+            };
+
+            match ty {
+                InstructionType::A => {
+                    let (opcode, operand_encoding) = get_a_opcode_and_encoding(tag, word);
+                    read_a_operands(operand_encoding, word);
+                    panic!("aaa");
+                }
+                InstructionType::M => {
+                    let (opcode, operand_encoding) = get_m_opcode_and_encoding(tag, word);
+                    read_m_operands(operand_encoding, word);
+                    panic!("mmm");
+                    match tag {
+                        4 => {
+                            let x = word[27];
+                            let m = word[36];
+                            println!("x, m {}, {}", x, m);
+                            if x == false && m == true {
+                                let x6l = word[30..32].load::<u8>();
+                                let x6u = word[32..36].load::<u8>();
+                                println!("x6l, x6u {}, {}", x6l, x6u);
+                                if x6u == 5 && x6l == 3 {
+                                    panic!("ld8.acq");
+                                }
+                            } else {
+                                panic!("b");
+                            }
+                        },
+                        _ => {
+                        }
+                    }
+                    Instruction {}
+                }
+                _ => {
+                    Instruction {}
+                }
+            }
+        }
+
+        for (word, ty) in instruction_words.iter().zip(instruction_types.iter().cloned()) {
+            let instruction = decode_instruction(word, ty);
+            eprintln!("{:?}/{:#046b}: {:?}", ty, word, instruction);
+        }
 
         // from here, `itanium-architecture-vol-1-2-3-4-reference-set-manual.pdf` volume 3 is
         // remaining necessary  details
         Ok(())
     }
 }
+
+fn read_m_operands(encoding: OperandEncodingM, word: &BitSlice<Lsb0, u8>) {
+    use OperandEncodingM::*;
+    match encoding {
+        M1 => {
+            let r1 = word[6..13].load::<u8>();
+            let _ = word[13..20].load::<u8>();
+            let r3 = word[20..27].load::<u8>();
+            let hint = word[28..30].load::<u8>();
+            eprintln!("m1 operands, r1={}, r3={}, hint={}", r1, r3, hint);
+        },
+        M2 => {
+            let r1 = word[6..13].load::<u8>();
+            let r2 = word[13..20].load::<u8>();
+            let r3 = word[20..27].load::<u8>();
+            let hint = word[28..30].load::<u8>();
+            eprintln!("m2 operands, r1={}, r2={}, r3={}, hint={}", r1, r2, r3, hint);
+        },
+        M6 => {
+            let _ = word[6..13].load::<u8>();
+            let r2 = word[13..20].load::<u8>();
+            let r3 = word[20..27].load::<u8>();
+            let hint = word[28..30].load::<u8>();
+            eprintln!("m6 operands, r2={}, r3={}, hint={}", r2, r3, hint);
+        }
+        M9 => {
+            let f1 = word[6..13].load::<u8>();
+            let _ = word[13..20].load::<u8>();
+            let r3 = word[20..27].load::<u8>();
+            let hint = word[28..30].load::<u8>();
+            eprintln!("m9 operands, f1={}, r3={}, hint={}", f1, r3, hint);
+        }
+        M10 => {
+            let f1 = word[6..13].load::<u8>();
+            let r2 = word[13..20].load::<u8>();
+            let r3 = word[20..27].load::<u8>();
+            let hint = word[28..30].load::<u8>();
+            eprintln!("m10 operands, f1={}, r2={}, r3={}, hint={}", f1, r2, r3, hint);
+        }
+        M11 => {
+            let f1 = word[6..13].load::<u8>();
+            let f2 = word[13..20].load::<u8>();
+            let r3 = word[20..27].load::<u8>();
+            let hint = word[28..30].load::<u8>();
+            eprintln!("m11 operands, f1={}, f2={}, r3={}, hint={}", f1, f2, r3, hint);
+        }
+        M12 => {
+            let f1 = word[6..13].load::<u8>();
+            let f2 = word[13..20].load::<u8>();
+            let r3 = word[20..27].load::<u8>();
+            let hint = word[28..30].load::<u8>();
+            eprintln!("m12 operands, f1={}, f2={}, r3={}, hint={}", f1, f2, r3, hint);
+        }
+        M13 => {
+            let _ = word[6..13].load::<u8>();
+            let f2 = word[13..20].load::<u8>();
+            let r3 = word[20..27].load::<u8>();
+            let hint = word[28..30].load::<u8>();
+            eprintln!("m13 operands, f2={}, r3={}, hint={}", f2, r3, hint);
+        }
+        M14 => {
+            let _ = word[6..13].load::<u8>();
+            let r2 = word[13..20].load::<u8>();
+            let r3 = word[20..27].load::<u8>();
+            let hint = word[28..30].load::<u8>();
+            eprintln!("m14 operands, r2={}, r3={}, hint={}", r2, r3, hint);
+        }
+        M16 => {
+            let r1 = word[6..13].load::<u8>();
+            let r2 = word[13..20].load::<u8>();
+            let r3 = word[20..27].load::<u8>();
+            let hint = word[28..30].load::<u8>();
+            eprintln!("m16 operands, r1={}, r2={}, r3={}, hint={}", r1, r2, r3, hint);
+        }
+        other => {
+            unimplemented!("unimplemented m operand encoding: {:?}", other);
+        }
+    }
+}
+
+fn read_a_operands(encoding: OperandEncodingA, word: &BitSlice<Lsb0, u8>) {
+    use OperandEncodingA::*;
+    match encoding {
+        A1 => {
+            let r1 = word[6..13].load::<u8>();
+            let r2 = word[13..20].load::<u8>();
+            let r3 = word[20..27].load::<u8>();
+            eprintln!("a1 operands, r1={}, r2={}, r3={}", r1, r2, r3);
+        },
+        A2 => {
+            let r1 = word[6..13].load::<u8>();
+            let r2 = word[13..20].load::<u8>();
+            let r3 = word[20..27].load::<u8>();
+            let ct = word[27..29].load::<u8>();
+            eprintln!("a2 operands, r1={}, r2={}, r3={}, ct={}", r1, r2, r3, ct);
+        },
+        A3 => {
+            let r1 = word[6..13].load::<u8>();
+            let r3 = word[20..27].load::<u8>();
+            let immb = word[13..20].load::<u8>();
+            let s = word[36];
+            let imm = (immb + ((s as u8) << 7)) as i8 as i32;
+            eprintln!("a3 operands, r1={}, r3={}, imm={}", r1, r3, imm);
+        },
+        A4 => {
+            let r1 = word[6..13].load::<u8>();
+            let r3 = word[20..27].load::<u8>();
+            let immb = word[13..20].load::<u16>();
+            let immd = word[27..33].load::<u16>();
+            let s = word[36];
+            let imm = ((s as u16) << 12) + (immd << 7) + immb;
+            let imm = (((imm as i16) << 2) >> 2) as i32;
+            eprintln!("a4 operands, r1={}, r3={}, imm={}", r1, r3, imm);
+        },
+        A5 => {
+            let r1 = word[6..13].load::<u8>();
+            let r3 = word[20..22].load::<u8>();
+            let immb = word[13..20].load::<u32>();
+            let immc_d_s = word[22..37].load::<u32>();
+            let imm = (immc_d_s << 7) + immb;
+            let imm = ((imm as i32) << 10) >> 10;
+            eprintln!("a5 operands, r1={}, r3={}, imm={}", r1, r3, imm);
+        }
+        A6 => {
+            let p1 = word[6..12].load::<u8>();
+            let r2 = word[13..20].load::<u8>();
+            let r3 = word[20..27].load::<u8>();
+            let p2 = word[27..33].load::<u8>();
+            eprintln!("a6 operands, r2={}, r3={}, p1={}, p2={}", r2, r3, p1, p2);
+        },
+        A7 => {
+            let p1 = word[6..12].load::<u8>();
+            let r2 = word[13..20].load::<u8>();
+            // TODO: what happens if this isn't zero?
+            assert_eq!(r2, 0);
+            let r3 = word[20..27].load::<u8>();
+            let p2 = word[27..33].load::<u8>();
+            eprintln!("a7 operands, r3={}, p1={}, p2={}", r3, p1, p2);
+        },
+        A8 => {
+            let p1 = word[6..12].load::<u8>();
+            let imm7b = word[13..20].load::<u8>();
+            let s = word[36];
+            let imm = (imm7b + (s as u8) << 7) as i8 as i32;
+            let r3 = word[20..27].load::<u8>();
+            let p2 = word[27..33].load::<u8>();
+            eprintln!("a8 operands, imm={}, r3={}, p1={}, p2={}", imm, r3, p1, p2);
+        },
+        A9 => {
+            let r1 = word[6..13].load::<u8>();
+            let r2 = word[13..20].load::<u8>();
+            let r3 = word[20..27].load::<u8>();
+            eprintln!("a9 operands, r1={}, r2={}, r3={}, ct={}", r1, r2, r3);
+        },
+        A10 => {
+            let r1 = word[6..13].load::<u8>();
+            let r2 = word[13..20].load::<u8>();
+            let r3 = word[20..27].load::<u8>();
+            let ct = word[27..29].load::<u8>();
+            eprintln!("a10 operands, r1={}, r2={}, r3={}, ct={}", r1, r2, r3, ct);
+        },
+    }
+}
+
+fn get_m_opcode_and_encoding(tag: u8, word: &BitSlice<Lsb0, u8>) -> (Opcode, OperandEncodingM) {
+    use Opcode::*;
+    use OperandEncodingM::*;
+
+    match tag {
+        0 => {
+            let x3 = word[33..36].load::<u8>();
+            // `Table 4-42 Opcode 0 System/Memory Management 3-bit Opcode Extensions`
+            if x3 == 0 {
+                // `Table 4-43 System/Memory Management 4-bit+2-bit Ext`
+                const TABLE4_43: [(Opcode, OperandEncodingM); 64] = [
+                    (Break_m, M37), (Invala, M24), (Fwb, M24), (Srlz_d, M24),
+                    // `1-bit Ext (Table 4-46)` is handled independently
+                    (Purple, None), (Purple, None), (Purple, None), (Srlz_i, M24),
+                    (Purple, None), (Invala_e_int, M26), (Mf, M24), (Purple, None),
+                    (Purple, None), (Invala_e_fp, M27), (Mf_a, M24), (Sync_i, M24),
+                    (Sum, M44), (Sum, M44), (Sum, M44), (Sum, M44),
+                    (Rum, M44), (Rum, M44), (Rum, M44), (Rum, M44),
+                    (Ssm, M44), (Ssm, M44), (Ssm, M44), (Ssm, M44),
+                    (Rsm, M44), (Rsm, M44), (Rsm, M44), (Rsm, M44),
+                    (Purple, None), (Purple, None), (Mov_m_to_ar_imm, M30), (Purple, None),
+                    (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                    (Loadrs, M25), (Purple, None), (Purple, None), (Purple, None),
+                    (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                    (Flushrs, M25), (Purple, None), (Purple, None), (Purple, None),
+                    (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                    (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                    (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                ];
+                let index = word[27..33].load::<u8>();
+                if index == 0b00001 {
+                    // `1-bit Ext (Table 4-46)`
+                    return if word[26] {
+                        (Hint_m, M48)
+                    } else {
+                        (Nop_m, M48)
+                    }
+                }
+                TABLE4_43[index as usize]
+            } else {
+                const TABLE4_42: [(Opcode, OperandEncodingM); 7] = [
+                    (Purple, None),
+                    (Purple, None),
+                    (Purple, None),
+                    (Chk_a_nc_int, M22),
+                    (Chk_a_clr_int, M22),
+                    (Chk_a_nc_fp, M23),
+                    (Chk_a_clr_fp, M23),
+                ];
+                TABLE4_42[x3 as usize]
+            }
+        },
+        1 => {
+            let x3 = word[33..36].load::<u8>();
+            // `Table 4-44 Opcode 1 System/Memory Management 3-bit Opcode Extensions`
+            if x3 == 0 {
+                unimplemented!("table 4-45");
+                // `Table 4-45 System/Memory Management 6-bit Ext`
+                const TABLE4_45: [(Opcode, OperandEncodingM); 64] = [
+                    (Mov_to_rr, M42), (Mov_from_rr, M43), (Purple, None), (Fc, M28),
+                    (Mov_to_dbr, M42), (Mov_from_dbr, M43), (Mov_from_psr_um, M36), (Probe_rw_fault_imm, M40),
+                    (Mov_to_ibr, M42), (Mov_from_ibr, M43), (Mov_m_from_ar, M31), (Probe_r_fault_imm, M40),
+                    (Mov_to_pkr, M43), (Mov_from_pkr, M43), (Purple, None), (Probe_w_fault_imm, M40),
+                    (Mov_to_pmc, M42), (Mov_from_pmc, M43), (Mov_from_cr, M33), (Ptc_e, M47),
+                    (Mov_to_pmd, M42), (Mov_from_pmd, M43), (Mov_from_psr, M36), (Purple, None),
+                    (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                    (Purple, None), (Mov_from_cpuid, M43), (Purple, None), (Purple, None),
+                    (Purple, None), (Probe_r_imm, M39), (Purple, None), (Probe_r, M38),
+                    (Ptc_l, M45), (Probe_w_imm, M39), (Mov_to_psr_um, M35), (Probe_w, M38),
+                    (Ptc_g, M45), (Thash, M46), (Mov_m, M29), (Purple, None),
+                    (Ptc_ga, M45), (Ttag, M46), (Purple, None), (Purple, None),
+                    (Ptr_d, M45), (Purple, None), (Mov_to_cr, M32), (Purple, None),
+                    (Ptr_i, M45), (Purple, None), (Mov_to_psr_l, M35), (Purple, None),
+                    (Itr_d, M42), (Tpa, M46), (Itc_d, M41), (Purple, None),
+                    (Itr_i, M42), (Tak, M46), (Itc_i, M41), (Purple, None),
+                ];
+                let index = word[27..33].load::<u8>();
+                TABLE4_45[index as usize]
+            } else {
+                const TABLE4_44: [(Opcode, OperandEncodingM); 7] = [
+                    (Chk_s_m_int, M20),
+                    (Purple, None),
+                    (Chk_s_fp, M21),
+                    (Purple, None),
+                    (Purple, None),
+                    (Alloc, M34),
+                    (Purple, None),
+                ];
+                TABLE4_44[x3 as usize]
+            }
+        },
+        2 => { (Purple, None) },
+        3 => { (Purple, None) },
+        4 => {
+            // `Table 4-28 Integer Load/Store/Semaphore/Get FR 1-bit Opcode Extensions`
+            const TABLE4_28: [Option<&'static [(Opcode, OperandEncodingM); 64]>; 4] = [
+                Some(&TABLE4_30),
+                Some(&TABLE4_33),
+                Some(&TABLE4_31),
+                None
+            ];
+
+            // `Table 4-30 Integer Load/Store Opcode Extensions
+            const TABLE4_30: [(Opcode, OperandEncodingM); 64] = [
+                (Ld1, M2), (Ld2, M2), (Ld4, M2), (Ld8, M2),
+                (Ld1_s, M2), (Ld2_s, M2), (Ld4_s, M2), (Ld8_s, M2),
+                (Ld1_a, M2), (Ld2_a, M2), (Ld4_a, M2), (Ld8_a, M2),
+                (Ld1_sa, M2), (Ld2_sa, M2), (Ld4_sa, M2), (Ld8_sa, M2),
+                (Ld1_bias, M2), (Ld2_bias, M2), (Ld4_bias, M2), (Ld8_bias, M2),
+                (Ld1_acq, M2), (Ld2_acq, M2), (Ld4_acq, M2), (Ld8_acq, M2),
+                (Purple, None), (Purple, None), (Purple, None), (Ld8_fill, M2),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Ld1_c_clr, M2), (Ld2_c_clr, M2), (Ld4_c_clr, M2), (Ld8_c_clr, M2),
+                (Ld1_c_nc, M2), (Ld2_c_nc, M2), (Ld4_c_nc, M2), (Ld8_c_nc, M2),
+                (Ld1_c_clr_acq, M2), (Ld2_c_clr_acq, M2), (Ld4_c_clr_acq, M2), (Ld8_c_clr_acq, M2),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (St1, M6), (St2, M6), (St4, M6), (St8, M6),
+                (St1_rel, M6), (St2_rel, M6), (St4_rel, M6), (St8_rel, M6),
+                (Purple, None), (Purple, None), (Purple, None), (St8_spill, M6),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+            ];
+
+            // `Table 4-31 Floating-point Load/Store/Lfetch +Imm Opcode Extensions`
+            const TABLE4_31: [(Opcode, OperandEncodingM); 64] = [
+                (Ld1, M2), (Ld2, M2), (Ld4, M2), (Ld8, M2),
+                (Ld1_s, M2), (Ld2_s, M2), (Ld4_s, M2), (Ld8_s, M2),
+                (Ld1_a, M2), (Ld2_a, M2), (Ld4_a, M2), (Ld8_a, M2),
+                (Ld1_sa, M2), (Ld2_sa, M2), (Ld4_sa, M2), (Ld8_sa, M2),
+                (Ld1_bias, M2), (Ld2_bias, M2), (Ld4_bias, M2), (Ld8_bias, M2),
+                (Ld1_acq, M2), (Ld2_acq, M2), (Ld4_acq, M2), (Ld8_acq, M2),
+                (Purple, None), (Purple, None), (Purple, None), (Ld8_fill, M2),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Ld1_c_clr, M2), (Ld2_c_clr, M2), (Ld4_c_clr, M2), (Ld8_c_clr, M2),
+                (Ld1_c_nc, M2), (Ld2_c_nc, M2), (Ld4_c_nc, M2), (Ld8_c_nc, M2),
+                (Ld1_c_clr_acq, M2), (Ld2_c_clr_acq, M2), (Ld4_c_clr_acq, M2), (Ld8_c_clr_acq, M2),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+            ];
+
+            // `Table 4-33 Semaphore/Get FR/16-byte Opcode Extensions`
+            const TABLE4_33: [(Opcode, OperandEncodingM); 64] = [
+                (Cmpxchg1_acq, M16), (Cmpxchg2_acq, M16), (Cmpxchg4_acq, M16), (Cmpxchg8_acq, M16),
+                (Cmpxchg1_rel, M16), (Cmpxchg2_rel, M16), (Cmpxchg4_rel, M16), (Cmpxchg8_rel, M16),
+                (Xchg1, M16), (Xchg2, M16), (Xchg4, M16), (Xchg8, M16),
+                (Purple, None), (Purple, None), (Purple, None), (Ld8_fill, M2),
+                (Purple, None), (Purple, None), (Fetchadd4_acq, M17), (Fetchadd8_acq, M17),
+                (Purple, None), (Purple, None), (Fetchadd4_rel, M17), (Fetchadd8_rel, M17),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Getf_sig, M19), (Getf_exp, M19), (Getf_s, M19), (Getf_d, M19),
+                (Cmp8xchg16_acq, M16), (Purple, None), (Purple, None), (Purple, None),
+                (Cmp8xchg16_rel, M16), (Purple, None), (Purple, None), (Purple, None),
+                (Ld16, M2), (Purple, None), (Purple, None), (Purple, None),
+                (Ld16_acq, M2), (Purple, None), (Purple, None), (Purple, None),
+                (St16, M6), (Purple, None), (Purple, None), (Purple, None),
+                (St16_rel, M6), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+            ];
+
+            let index = ((word[36] as u8) << 1) + (word[27] as u8);
+            if let Some(op_table) = TABLE4_28[index as usize] {
+                op_table[word[30..36].load::<u8>() as usize]
+            } else {
+                (Purple, None)
+            }
+        },
+        5 => {
+            unimplemented!("table 4-32");
+            // `Table 4-32 Integer Load/Store +Imm Opcode Extensions`
+            const TABLE4_32: [(Opcode, OperandEncodingM); 64] = [
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+            ];
+
+            TABLE4_32[word[30..36].load::<u8>() as usize]
+        },
+        6 => {
+            // `Table 4-29 Floating-point Load/Store/Load Pair/Set FR 1-bit Opcode Extensions`
+            const TABLE4_29: [&'static [(Opcode, OperandEncodingM); 64]; 4] = [
+                &TABLE4_34,
+                &TABLE4_37,
+                &TABLE4_35,
+                &TABLE4_38,
+            ];
+
+            // `Table 4-34 Floating-point Load/Store/Lfetch Opcode Extensions`
+            const TABLE4_34: [(Opcode, OperandEncodingM); 64] = [
+                (Ldfe, M9), (Ldf8, M9), (Ldfs, M9), (Ldfd, M9),
+                (Ldfe_s, M9), (Ldf8_s, M9), (Ldfs_s, M9), (Ldfd_s, M9),
+                (Ldfe_a, M9), (Ldf8_a, M9), (Ldfp_a, M9), (Ldfd_a, M9),
+                (Ldfe_sa, M9), (Ldf8_sa, M9), (Ldfp_sa, M9), (Ldfd_sa, M9),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Ldf_fill, M9),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Ldfe_c_clr, M9), (Ldf8_c_clr, M9), (Ldfs_c_clr, M9), (Ldfd_c_clr, M9),
+                (Ldfe_c_nc, M9), (Ldf8_c_nc, M9), (Ldfs_c_nc, M9), (Ldfd_c_nc, M9),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Lfetch, M18), (Lfetch_excl, M18), (Lfetch_fault, M18), (Lfetch_fault_excl, M18),
+                (Stfe, M13), (Stf8, M13), (Stfs, M13), (Stfd, M13),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Stf_spill, M13),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+            ];
+
+            // `Table 4-35 Floating-point Load/Lfetch +Reg Opcode Extensions`
+            const TABLE4_35: [(Opcode, OperandEncodingM); 64] = [
+                (Ldfe, M7), (Ldf8, M7), (Ldfs, M7), (Ldfd, M7),
+                (Ldfe_s, M7), (Ldf8_s, M7), (Ldfs_s, M7), (Ldfd_s, M7),
+                (Ldfe_a, M7), (Ldf8_a, M7), (Ldfp_a, M7), (Ldfd_a, M7),
+                (Ldfe_sa, M7), (Ldf8_sa, M7), (Ldfp_sa, M7), (Ldfd_sa, M7),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Ldf_fill, M7),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Ldfe_c_clr, M7), (Ldf8_c_clr, M7), (Ldfs_c_clr, M7), (Ldfd_c_clr, M7),
+                (Ldfe_c_nc, M7), (Ldf8_c_nc, M7), (Ldfs_c_nc, M7), (Ldfd_c_nc, M7),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Lfetch, M20), (Lfetch_excl, M20), (Lfetch_fault, M20), (Lfetch_fault_excl, M20),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+            ];
+
+            // `Table 4-37 Floating-point Load Pair/Set FR Opcode Extensions`
+            const TABLE4_37: [(Opcode, OperandEncodingM); 64] = [
+                (Purple, None), (Ldfp8, M11), (Ldfps, M11), (Ldfpd, M11),
+                (Purple, None), (Ldfp8_s, M11), (Ldfps_s, M11), (Ldfpd_s, M11),
+                (Purple, None), (Ldfp8_a, M11), (Ldfps_a, M11), (Ldfpd_a, M11),
+                (Purple, None), (Ldfp8_sa, M11), (Ldfps_sa, M11), (Ldfpd_sa, M11),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Setf_sig, M18), (Setf_exp, M18), (Setf_s, M18), (Setf_d, M18),
+                (Purple, None), (Ldfp8_c_clr, M11), (Ldfps_c_clr, M11), (Ldfpd_c_clr, M11),
+                (Purple, None), (Ldfp8_c_nc, M11), (Ldfps_c_nc, M11), (Ldfpd_c_nc, M11),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+            ];
+
+            // `Table 4-38 Floating-point Load Pair +Imm Opcode Extensions`
+            const TABLE4_38: [(Opcode, OperandEncodingM); 64] = [
+                (Purple, None), (Ldfp8, M12), (Ldfps, M12), (Ldfpd, M12),
+                (Purple, None), (Ldfp8_s, M12), (Ldfps_s, M12), (Ldfpd_s, M12),
+                (Purple, None), (Ldfp8_a, M12), (Ldfps_a, M12), (Ldfpd_a, M12),
+                (Purple, None), (Ldfp8_sa, M12), (Ldfps_sa, M12), (Ldfpd_sa, M12),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Ldfp8_c_clr, M12), (Ldfps_c_clr, M12), (Ldfpd_c_clr, M12),
+                (Purple, None), (Ldfp8_c_nc, M12), (Ldfps_c_nc, M12), (Ldfpd_c_nc, M12),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+            ];
+
+            let index = ((word[36] as u8) << 1) + (word[27] as u8);
+            let op_table = TABLE4_29[index as usize];
+            op_table[word[30..36].load::<u8>() as usize]
+        },
+        7 => {
+            // `Table 4-36 Floating-point Load/Store/Lfetch +Imm Opcode Extensions`
+            const TABLE4_36: [(Opcode, OperandEncodingM); 64] = [
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+            ];
+
+            TABLE4_36[word[30..36].load::<u8>() as usize]
+        }
+        _ => {
+            unreachable!("m major op > 7 are a-type instructions");
+        }
+    }
+}
+
+fn get_a_opcode_and_encoding(tag: u8, word: &BitSlice<Lsb0, u8>) -> (Opcode, OperandEncodingA) {
+    use Opcode::*;
+    use OperandEncodingA::*;
+
+    match tag {
+        8 => {
+            let x2a = word[34..36].load::<u8>();
+            eprintln!("zb: {}", word[33]);
+            if word[33] && x2a != 1 {
+                // purple (table 4-8 ve=1, x2a = 0, 2, or 3)
+                return (Purple, None);
+            }
+
+            // table 4-8: `Integer ALU 2-bit+1-bit Opcode Extensions`
+            match x2a {
+                0 => {
+                    const TABLE4_9: [(Opcode, OperandEncodingA); 64] = [
+                        (Add, A1), (AddPlusOne, A1), (Purple, None), (Purple, None),
+                        (SubMinusOne, A1), (Sub, A1), (Purple, None), (Purple, None),
+                        (Addp4, A1), (Purple, None), (Purple, None), (Purple, None),
+                        (And, A1), (Andcm, A1), (Or, A1), (Xor, A1),
+                        (Shladd, A2), (Shladd, A2), (Shladd, A2), (Shladd, A2),
+                        (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                        (Shladdp4, A2), (Shladdp4, A2), (Shladdp4, A2), (Shladdp4, A2),
+                        (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                        (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                        (Purple, None), (SubImm, A3), (Purple, None), (Purple, None),
+                        (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                        (AndImm, A3), (AndcmImm, A3), (OrImm, A3), (XorImm, A3),
+                        (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                        (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                        (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                        (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                    ];
+                    TABLE4_9[word[27..33].load::<u8>() as usize]
+                }
+                1 => {
+                    // `Multimedia ALU Table 4-12`
+                    const TABLE4_12: [Option<&'static [(Opcode, OperandEncodingA); 64]>; 4] = [
+                        Some(&TABLE4_13),
+                        Some(&TABLE4_14),
+                        Some(&TABLE4_15),
+                        None
+                    ];
+
+                    const TABLE4_13: [(Opcode, OperandEncodingA); 64] = [
+                        (Padd1, A9), (Padd1_sss, A9), (Padd1_uuu, A9), (Padd1_uus, A9),
+                        (Psub1, A9), (Psub1_sss, A9), (Psub1_uuu, A9), (Psub1_uus, A9),
+                        (Purple, None), (Purple, None), (Pavg1, A9), (Pavg1_raz, A9),
+                        (Purple, None), (Purple, None), (Pavgsub1, A9), (Purple, None),
+                        (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                        (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                        (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                        (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                        (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                        (Pcmp1_eq, A9), (Pcmp1_gt, A9), (Purple, None), (Purple, None),
+                        (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                        (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                        (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                        (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                        (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                        (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                    ];
+
+                    const TABLE4_14: [(Opcode, OperandEncodingA); 64] = [
+                        (Padd2, A9), (Padd2_sss, A9), (Padd2_uuu, A9), (Padd2_uus, A9),
+                        (Psub2, A9), (Psub2_sss, A9), (Psub2_uuu, A9), (Psub2_uus, A9),
+                        (Purple, None), (Purple, None), (Pavg2,g A9), (Pavg2_raz, A9),
+                        (Purple, None), (Purple, None), (Pavgsub2,g A9), (Purple, None),
+                        (Pshladd2, A10), (Pshladd2, A10), (Pshladd2, A10), (Pshladd2, A10),
+                        (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                        (Pshradd2, A10), (Pshradd2, A10), (Pshradd2, A10), (Pshradd2, A10),
+                        (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                        (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                        (Pcmp2_eq, A9), (Pcmp2_gt, A9), (Purple, None), (Purple, None),
+                        (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                        (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                        (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                        (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                        (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                        (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                    ];
+
+                    const TABLE4_15: [(Opcode, OperandEncodingA); 64] = [
+                        (Padd4, A9), (Purple, None), (Purple, None), (Purple, None),
+                        (Psub4, A9), (Purple, None), (Purple, None), (Purple, None),
+                        (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                        (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                        (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                        (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                        (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                        (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                        (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                        (Pcmp4_eq, A9), (Pcmp4_gt, A9), (Purple, None), (Purple, None),
+                        (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                        (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                        (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                        (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                        (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                        (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                    ];
+
+                    let index = ((word[36] as u8) << 1) + (word[33] as u8);
+                    if let Some(alu_table) = TABLE4_12[index as usize] {
+                        alu_table[word[27..33].load::<u8>() as usize]
+                    } else {
+                        (Purple, None)
+                    }
+                },
+                2 => {
+                    (Opcode::Adds, OperandEncodingA::A4)
+                }
+                3 => {
+                    (Opcode::Addp4, OperandEncodingA::A4)
+                }
+            }
+        }
+        9 => (Addl, A5),
+        0xa => (Purple, None),
+        0xb => (Purple, None),
+        0xc => {
+            let x2 = word[34..36].load::<u8>();
+            if x2 > 1 {
+                // `Table 4-11 Integer Compare Immediate Opcode Extensions`
+                let encoding = A8;
+            } else {
+                // `Table 4-10 Integer Compare Opcode Extensions`
+                let encoding = if word[36] { A7 } else { A6 };
+            }
+            unimplemented!("type a, tag c");
+        }
+        0xd => {
+            let x2 = word[34..36].load::<u8>();
+            if x2 > 1 {
+                // `Table 4-11 Integer Compare Immediate Opcode Extensions`
+                let encoding = A8;
+            } else {
+                // `Table 4-10 Integer Compare Opcode Extensions`
+                let encoding = if word[36] { A7 } else { A6 };
+            }
+            unimplemented!("type a, tag d");
+        }
+        0xe => {
+            let x2 = word[34..36].load::<u8>();
+            if x2 > 1 {
+                // `Table 4-11 Integer Compare Immediate Opcode Extensions`
+                let encoding = A8;
+            } else {
+                // `Table 4-10 Integer Compare Opcode Extensions`
+                let encoding = if word[36] { A7 } else { A6 };
+            }
+            unimplemented!("type a, tag e");
+        }
+        0xf => (Purple, None),
+        _ => {
+            unreachable!("a-type major op < 8 are i-type or m-type instructions");
+        }
+    }
+}
+
+#[derive(Copy, Clone, Debug)]
+enum OperandEncodingA {
+    None,
+    A1,
+    A2,
+    A3,
+    A4,
+    A5,
+    A6,
+    A7,
+    A8,
+    A9,
+    A10,
+}
+
+#[derive(Copy, Clone, Debug)]
+enum OperandEncodingI {
+    I1,
+    I2,
+    I3,
+    I4,
+    I5,
+    I6,
+    I7,
+    I8,
+    I9,
+    I10,
+    I11,
+    I12,
+    I13,
+    I14,
+    I15,
+    I16,
+    I17,
+    I18,
+    I19,
+    I20,
+    I21,
+    I22,
+    I23,
+    I24,
+    I25,
+    I26,
+    I27,
+    I28,
+    I29,
+    I30,
+}
+
+#[derive(Copy, Clone, Debug)]
+enum OperandEncodingM {
+    None,
+    M1,
+    M2,
+    M3,
+    M4,
+    M5,
+    M6,
+    M7,
+    M8,
+    M9,
+    M10,
+    M11,
+    M12,
+    M13,
+    M14,
+    M15,
+    M16,
+    M17,
+    M18,
+    M19,
+    M20,
+    M21,
+    M22,
+    M23,
+    M24,
+    M25,
+    M26,
+    M27,
+    M28,
+    M29,
+    M30,
+    M31,
+    M32,
+    M33,
+    M34,
+    M35,
+    M36,
+    M37,
+    M38,
+    M39,
+    M40,
+    M41,
+    M42,
+    M43,
+    M44,
+    M45,
+    M46,
+    M47,
+    M48,
+}
+
+#[derive(Copy, Clone, Debug)]
+enum OperandEncodingB {
+    B1,
+    B2,
+    B3,
+    B4,
+    B5,
+    B6,
+    B7,
+    B8,
+    B9,
+}
+
+#[derive(Copy, Clone, Debug)]
+enum OperandEncodingF {
+    F1,
+    F2,
+    F3,
+    F4,
+    F5,
+    F6,
+    F7,
+    F8,
+    F9,
+    F10,
+    F11,
+    F12,
+    F13,
+    F14,
+    F15,
+    F16,
+}
+
+#[derive(Copy, Clone, Debug)]
+enum OperandEncodingX {
+    X1,
+    X2,
+    X3,
+    X4,
+    X5,
+}
+
diff --git a/test/test.rs b/test/test.rs
deleted file mode 100644
index 128e601..0000000
--- a/test/test.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-
-
-// from elf64-ia64-vms.c
-// 0x0b, 0x78, 0x00, 0x02, 0x00, 0x24, 0x00, 0x41, 0x3c, 0x70, 0x27, 0xc0, 0x01, 0x08, 0x00, 0x84
-// [MMI] addl r15=0,r1;;
-//       ld8.acq r16=[r15],8
-//       mov r14=r1;;
-// 0x11, 0x08, 0x00, 0x1e, 0x18, 0x10, 0x60, 0x80, 0x04, 0x80, 0x03, 0x00, 0x60, 0x00, 0x80, 0x00
-// [MIB] ld8 r1=[r15]
-//       mov b6=r16
-//       br.few b6;;
-// 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0
-// [MLX] nop.m 0
-//       brl.sptk.few tgt;;
-
-// from ia64 bash_4.2+dfsg-0.1+deb7u3_ia64:
-// 0410 1c00 8045 024c 8009 0060 f013 1a60
-// 0510 4118 0021 0000 0000 6020 0023 c86f
-// 0908 2144 1814 a000 4444 0820 0100 c000
-// 0100 0c50 2a04 1048 040a 40c0 0461 0084
-// 0158 80fb f027 0082 f5e5 4f60 04ed c79f
-// 0918 0016 1810 0002 8030 2080 04e9 b79f
-// 0818 0146 1810 4002 9030 2000 0000 0400
-// 1000 2806 9811 5002 2000 4200 50a5 ff58