add most of opcode decoding

1 files changed, 917 insertions, 104 deletions

diff --git a/src/lib.rs b/src/lib.rs
index ddfbe09..b8dc192 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -17,9 +17,13 @@ impl Arch for IA64 {
 }
 
 #[derive(Debug, PartialEq, Eq, Copy, Clone)]
+#[allow(non_camel_case_types)]
 pub enum Opcode {
-    // TODO; maybe don't actually do this one huh
+    // TODO: what kind of no-op/undefined are these exactly
     Purple,
+    Cyan,
+    Brown,
+    White,
 
     Addp4,
     Adds,
@@ -165,9 +169,7 @@ pub enum Opcode {
     Ldfp8_c_nc,
     Ldfps_c_nc,
     Ldfpd_c_nc,
-    Ldfp8,
-    Ldfps_a,
-    Ldfps_sa,
+    Break_m,
     Invala,
     Fwb,
     Srlz_d,
@@ -235,18 +237,262 @@ pub enum Opcode {
     Psub1_uuu,
     Psub1_uus,
 
+    Ldfp8,
     Ldfps,
     Ldfpd,
     Ldfp8_s,
     Ldfps_s,
     Ldfpd_s,
     Ldfp8_a,
-    Ldfp8_a,
+    Ldfps_a,
     Ldfpd_a,
     Ldfp8_sa,
-    Ldfp8_sa,
+    Ldfps_sa,
     Ldfpd_sa,
+
+    Mov_m_to_ar_imm,
+    Mov_from_pkr,
+    Setf_sig,
+    Setf_exp,
+    Setf_s,
+    Setf_d,
+    Pavg1,
+    Pavg1_raz,
+    Pavgsub1,
+    Pcmp1_eq,
+    Pcmp1_gt,
+    Padd2,
+    Padd2_sss,
+    Padd2_uuu,
+    Padd2_uus,
+    Psub2,
+    Psub2_sss,
+    Psub2_uuu,
+    Psub2_uus,
+    Pavg2,
+    Pavg2_raz,
+    Pavgsub2,
+    Pshladd2,
+    Pshradd2,
+    Pcmp2_eq,
+    Pcmp2_gt,
+    Padd4,
+    Psub4,
+    Pcmp4_eq,
+    Pcmp4_gt,
+    Hint_x,
+    Nop_x,
+    Movl,
+    Brl_cond_bwh_ph_dh,
+    Brl_call_bwh_ph_dh,
+    Br_call_bwh_ph_dh,
+    Brp_ipwh_ih,
+    Break_x,
+    Break_i,
+    Zxt1,
+    Mov_from_ip,
+    Zxt2,
+    Mov_from_b,
+    Zxt4,
+    Mov_i_from_ar,
+    Sxt1,
+    Sxt2,
+    Sxt4,
+    Czx1_l,
+    Czx2_l,
+    Mov_i_to_ar_imm,
+    Mov_i_to_ar,
+    Czx1_r,
+    Czx2_r,
+    Hint_i,
+    Nop_i,
+    Chk_s_i_int,
+    Mov_to_pr_rot_imm,
+    Mov_to_pr,
+    Mov_from_pr,
+    Mov_to_b,
+    Dep,
+    Tbit_z,
+    Tnat_z,
+    Tbit_z_unc,
+    Tnat_z_unc,
+    Tbit_z_and,
+    Tnat_z_and,
+    Tbit_nz_and,
+    Tnat_nz_and,
+    Tbit_z_or,
+    Tnat_z_or,
+    Tbit_nz_or,
+    Tnat_nz_or,
+    Tbit_z_or_andcm,
+    Tnat_z_or_andcm,
+    Tbit_nz_or_andcm,
+    Tnat_nz_or_andcm,
+    Tf_z,
+    Tf_z_nc,
+    Tf_z_and,
+    Tf_nz_and,
+    Tf_z_or,
+    Tf_nz_or,
+    Tf_z_or_andcm,
+    Tf_nz_or_andcm,
+    Dep_z_imm,
+    Dep_imm,
+    Dep_z,
+    Extr,
+    Shrp,
+    Extr_u,
+    Pmin1_u,
+    Unpack1_h,
+    Pmax1_u,
+    Unpack1_l,
+    Mix1_r,
+    Mix1_l,
+    Psad1,
+    Mux1,
+    Pshr2_u_var,
+    Pmpyshr2_u,
+    Pshr2_var,
+    Pmpyshr2,
+    Pshl1_var,
+    Pshr2_u_fixed,
+    Pshr2_fixed,
+    Popcnt,
+    Clz,
+    Pack2_uss,
+    Pack2_sss,
+    Pmin2,
+    Unpack2_h,
+    Unpack2_l,
+    Pmax2,
+    Mix2_r,
+    Mix2_l,
+    Pmpy2_r,
+    Pmpy2_l,
+    Pshl2_fixed,
+    Mux2,
+    Pshr4_u_var,
+    Pshr4_var,
+    Pshl4_var,
+    Mpy4,
+    Mpyshl4,
+    Pshr4_u_fixed,
+    Pshr4_fixed,
+    Pack4_sss,
+    Unpack4_h,
+    Unpack4_l,
+    Mix4_r,
+    Mix4_l,
+    Pshl4_fixed,
+    Shr_u_var,
+    Shr_var,
+    Shl_var,
+
+    Break_b,
+    Cover,
+    Clrrb,
+    Clrrb_pr,
+    Rfi,
+    Bsw_0,
+    Bsw_1,
+    Epc,
+    Vmsw_0,
+    Vmsw_1,
+    Br_cond,
+    Br_ia,
+    Br_ret,
+
+    Nop_b,
+    Hint_b,
+    Brp,
+    Brp_ret,
+
+    Br_wexit,
+    Br_wtop,
+    Br_cloop,
+    Br_cexit,
+    Br_ctop,
+
+    Frcpa,
+    Frsqta,
+    Break_f,
+    Fsetc,
+    Fclrf,
+    Fchkf,
+    Fmerge_s,
+    Fmerge_ns,
+    Fmerge_se,
+
+    Fmin,
+    Fmax,
+    Famin,
+    Famax,
+    Fcvt_fx,
+    Fcvt_fxu,
+    Fcvt_fx_trunc,
+    Fcvt_fxu_trunc,
+    Fcvt_xf,
+    Fpack,
+    Fand,
+    Fandcm,
+    For,
+    Fxor,
+
+    Fswap,
+    Fswap_nl,
+    Fswap_nr,
+    Fmix_lr,
+    Fmix_r,
+    Fmix_l,
+
+    Fsxt_r,
+    Fsxt_l,
+
+    Hint_f,
+    Nop_f,
+
+    Fprcpa,
+    Fprsqrta,
+    Fpmerge_s,
+    Fpmerge_ns,
+    Fpmerge_se,
+
+    Fpmin,
+    Fpmax,
+    Fpamin,
+    Fpamax,
+    Fpcvt_fx,
+    Fpcvt_fxu,
+    Fpcvt_fx_trunc,
+    Fpcvt_fxu_trunc,
+    Fcmp_eq,
+    Fcmp_lt,
+    Fcmp_le,
+    Fcmp_unord,
+    Fcmp_eq_unc,
+    Fcmp_lt_unc,
+    Fcmp_le_unc,
+    Fcmp_unord_unc,
+    Fclass_m_unc,
+    Fclass_m,
+    Fma_s_sf,
+    Fma_sf,
+    Fpma_sf,
+    Fma_d_sf,
+    Fms_s_sf,
+    Fms_sf,
+    Fpms_sf,
+    Fms_d_sf,
+    Fnma_s_sf,
+    Fnma_sf,
+    Fpnma_sf,
+    Fnma_d_sf,
+    Xma_l,
+    Xma_hu,
+    Xma_h,
+    Fselect,
 }
+
 #[derive(Debug, PartialEq, Eq)]
 pub struct Instruction {}
 impl yaxpeax_arch::LengthedInstruction for Instruction {
@@ -409,37 +655,36 @@ impl Decoder<Instruction> for InstDecoder {
             };
 
             match ty {
+                InstructionType::I => {
+                    let (opcode, operand_encoding) = get_i_opcode_and_encoding(tag, word);
+                    read_i_operands(operand_encoding, word);
+                    panic!("i");
+                },
+                InstructionType::F => {
+                    let (opcode, operand_encoding) = get_f_opcode_and_encoding(tag, word);
+                    read_f_operands(operand_encoding, word);
+                    panic!("f");
+                },
+                InstructionType::B => {
+                    let (opcode, operand_encoding) = get_b_opcode_and_encoding(tag, word);
+                    read_b_operands(operand_encoding, word);
+                    panic!("b");
+                },
+                InstructionType::LX => {
+                    let (opcode, operand_encoding) = get_lx_opcode_and_encoding(tag, word);
+                    read_lx_operands(operand_encoding, word);
+                    panic!("lx");
+                },
                 InstructionType::A => {
                     let (opcode, operand_encoding) = get_a_opcode_and_encoding(tag, word);
+                    eprintln!("A {:?}/{:?}", opcode, operand_encoding);
                     read_a_operands(operand_encoding, word);
-                    panic!("aaa");
+                    Instruction {}
                 }
                 InstructionType::M => {
                     let (opcode, operand_encoding) = get_m_opcode_and_encoding(tag, word);
+                    eprintln!("M({}) {:?}/{:?}", tag, opcode, operand_encoding);
                     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 {}
                 }
             }
@@ -456,6 +701,14 @@ impl Decoder<Instruction> for InstDecoder {
     }
 }
 
+fn read_lx_operands(encoding: OperandEncodingX, word: &BitSlice<Lsb0, u8>) {
+}
+fn read_b_operands(encoding: OperandEncodingB, word: &BitSlice<Lsb0, u8>) {
+}
+fn read_f_operands(encoding: OperandEncodingF, word: &BitSlice<Lsb0, u8>) {
+}
+fn read_i_operands(encoding: OperandEncodingI, word: &BitSlice<Lsb0, u8>) {
+}
 fn read_m_operands(encoding: OperandEncodingM, word: &BitSlice<Lsb0, u8>) {
     use OperandEncodingM::*;
     match encoding {
@@ -538,6 +791,7 @@ fn read_m_operands(encoding: OperandEncodingM, word: &BitSlice<Lsb0, u8>) {
 fn read_a_operands(encoding: OperandEncodingA, word: &BitSlice<Lsb0, u8>) {
     use OperandEncodingA::*;
     match encoding {
+        None => { unreachable!("none operand encoding"); }
         A1 => {
             let r1 = word[6..13].load::<u8>();
             let r2 = word[13..20].load::<u8>();
@@ -607,7 +861,7 @@ fn read_a_operands(encoding: OperandEncodingA, word: &BitSlice<Lsb0, u8>) {
             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);
+            eprintln!("a9 operands, r1={}, r2={}, r3={}", r1, r2, r3);
         },
         A10 => {
             let r1 = word[6..13].load::<u8>();
@@ -619,6 +873,540 @@ fn read_a_operands(encoding: OperandEncodingA, word: &BitSlice<Lsb0, u8>) {
     }
 }
 
+fn get_lx_opcode_and_encoding(tag: u8, word: &BitSlice<Lsb0, u8>) -> (Opcode, OperandEncodingX) {
+    use Opcode::*;
+    use OperandEncodingX::*;
+
+    match tag {
+        0x0 => {
+            let x3 = word[33..36].load::<u8>();
+            if x3 == 0 {
+                // `Table 4-70 Misc X-Unit 6-bit Opcode Extensions`
+                let x6 = word[27..33].load::<u8>();
+                if x6 == 0 {
+                    (Break_x, X1)
+                } else if x6 == 1 {
+                    // `1-bit Ext (Table 4-73)`
+                    if word[26] {
+                        (Hint_x, X5)
+                    } else {
+                        (Nop_x, X5)
+                    }
+                } else {
+                    (Purple, None)
+                }
+            } else {
+                (Purple, None)
+            }
+        },
+        0x1 => { (Purple, None) },
+        0x2 => { (Purple, None) },
+        0x3 => { (Purple, None) },
+        0x4 => { (Purple, None) },
+        0x5 => { (Purple, None) },
+        0x6 => { (Movl, X2) },
+        0x7 => { (Purple, None) },
+        0x8 => { (Cyan, None) },
+        0x9 => { (Cyan, None) },
+        0xa => { (Cyan, None) },
+        0xb => { (Cyan, None) },
+        0xc => {
+            // p, wh, d, described in tables 4-51, 4-52, 4-54
+            (Brl_cond_bwh_ph_dh, X3)
+        },
+        0xd => {
+            // p, wh, d, described in tables 4-51, 4-52, 4-54
+            (Brl_call_bwh_ph_dh, X4)
+        },
+        0xe => { (Cyan, None) },
+        0xf => { (Cyan, None) },
+        _ => { unreachable!() },
+    }
+}
+
+fn get_b_opcode_and_encoding(tag: u8, word: &BitSlice<Lsb0, u8>) -> (Opcode, OperandEncodingB) {
+    use Opcode::*;
+    use OperandEncodingB::*;
+
+    match tag {
+        0x0 => {
+            // `Table 4-48 Indirect/Miscellaneous Branch Opcode Extensions`
+            const TABLE4_48: [(Opcode, OperandEncodingB); 64] = [
+                (Break_b, B9), (White, None), (Cover, B8), (Cyan, None), (Clrrb, B8), (Clrrb_pr, B8), (Cyan, None), (Cyan, None), (Rfi, B8), (Cyan, None), (Cyan, None), (Cyan, None), (Bsw_0, B8), (Bsw_1, B8), (Cyan, None), (Cyan, None),
+                (Epc, B8), (Cyan, None), (Cyan, None), (Cyan, None), (Cyan, None), (Cyan, None), (Cyan, None), (Cyan, None), (Vmsw_0, B8), (Vmsw_1, B8), (Cyan, None), (Cyan, None), (Cyan, None), (Cyan, None), (Cyan, None), (Cyan, None),
+                (Brown, None), (Brown, None), (Brown, None), (Brown, None), (Brown, None), (Brown, None), (Brown, None), (Brown, None), (Brown, None), (Brown, None), (Brown, None), (Brown, None), (Brown, None), (Brown, None), (Brown, None), (Brown, None),
+                (Brown, None), (Brown, None), (Brown, None), (Brown, None), (Brown, None), (Brown, None), (Brown, None), (Brown, None), (Brown, None), (Brown, None), (Brown, None), (Brown, None), (Brown, None), (Brown, None), (Brown, None), (Brown, None)
+            ];
+
+            let index = word[27..33].load::<u8>();
+            if index == 0b10000 {
+                // `Indirect Branch (Table 4-49)`
+                const TABLE4_49: [(Opcode, OperandEncodingB); 8] = [
+                    (Br_cond, B4), (Br_ia, B4), (Brown, None), (Brown, None),
+                    (Brown, None), (Brown, None), (Brown, None), (Brown, None),
+                ];
+                let subindex = word[6..9].load::<u8>();
+                TABLE4_49[subindex as usize]
+            } else if index == 0b10001 {
+                // `Indirect Return (Table 4-50)`
+                const TABLE4_50: [(Opcode, OperandEncodingB); 8] = [
+                    (Brown, None), (Brown, None), (Brown, None), (Brown, None),
+                    (Br_ret, B4), (Brown, None), (Brown, None), (Brown, None),
+                ];
+                let subindex = word[6..9].load::<u8>();
+                TABLE4_50[subindex as usize]
+            } else {
+                TABLE4_48[index as usize]
+            }
+        },
+        0x1 => {
+            (Br_call_bwh_ph_dh, B5)
+        },
+        0x2 => {
+            // `Table 4-55 Indirect Predict/Nop/Hint Opcode Extensions`
+            let x6 = word[27..33].load::<u8>();
+            if x6 == 0b000000 {
+                (Nop_b, B9)
+            } else if x6 == 0b000001 {
+                (Hint_b, B9)
+            } else if x6 == 0b010000 {
+                (Brp, B7)
+            } else if x6 == 0b010001 {
+                (Brp_ret, B7)
+            } else {
+                (White, None)
+            }
+        },
+        0x3 => { (White, None) },
+        0x4 => {
+            // `Table 4-47 IP-Relative Branch Types`
+            const TABLE4_47: [(Opcode, OperandEncodingB); 8] = [
+                (Br_cond, B1), (Brown, None), (Br_wexit, B1), (Br_wtop, B1),
+                (Brown, None), (Br_cloop, B2), (Br_cexit, B2), (Br_ctop, B2),
+            ];
+            let btype = word[6..9].load::<u8>();
+            TABLE4_47[btype as usize]
+        },
+        0x5 => {
+            (Br_call_bwh_ph_dh, B3)
+        },
+        0x6 => { (White, None) },
+        0x7 => {
+            (Brp_ipwh_ih, B6)
+        },
+        0x8 => { (Brown, None) },
+        0x9 => { (Brown, None) },
+        0xa => { (Brown, None) },
+        0xb => { (Brown, None) },
+        0xc => { (Brown, None) },
+        0xd => { (Brown, None) },
+        0xe => { (Brown, None) },
+        0xf => { (Brown, None) },
+        _ => { unreachable!() },
+    }
+}
+
+fn get_f_opcode_and_encoding(tag: u8, word: &BitSlice<Lsb0, u8>) -> (Opcode, OperandEncodingF) {
+    use Opcode::*;
+    use OperandEncodingF::*;
+
+    // `Table 4-63 Floating-point Status Field Completer` maps `sf` bits (35:34) to a FPSR status
+    // field (.s0, .s1, .s2, .s3). the mapping is "bit value N" -> ".sN", so this table is
+    // implicit.
+
+    match tag {
+        0x0 => {
+            // `Table 4-59 Miscellaneous Floating-point 1-bit Opcode Extensions`
+            if word[33] {
+                if word[36] {
+                    (Frcpa, F6)
+                } else {
+                    (Frsqta, F7)
+                }
+            } else {
+                // `Table 4-60 Opcode 0 Miscellaneous Floating-point 6-bit Opcode Extensions`
+                // `1-bit Ext (Table 4-68)` handled independently,
+                const TABLE4_60: [(Opcode, OperandEncodingF); 64] = [
+                    (Break_f, F15), (Purple, None), (Purple, None), (Purple, None),
+                    (Fsetc, F12), (Fclrf, F13), (Purple, None), (Purple, None),
+                    (Fchkf, F14), (Purple, None), (Purple, None), (Purple, None),
+                    (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                    (Fmerge_s, F9), (Fmerge_ns, F9), (Fmerge_se, F9), (Purple, None),
+                    (Fmin, F8), (Fmax, F8), (Famin, F8), (Famax, F8),
+                    (Fcvt_fx, F10), (Fcvt_fxu, F10), (Fcvt_fx_trunc, F10), (Fcvt_fxu_trunc, F10),
+                    (Fcvt_xf, F11), (Purple, None), (Purple, None), (Purple, None),
+                    (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                    (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                    (Fpack, F9), (Purple, None), (Purple, None), (Purple, None),
+                    (Fand, F9), (Fandcm, F9), (For, F9), (Fxor, F9),
+                    (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                    (Fswap, F9), (Fswap_nl, F9), (Fswap_nr, F9), (Purple, None),
+                    (Purple, None), (Fmix_lr, F9), (Fmix_r, F9), (Fmix_l, F9),
+                    (Fsxt_r, F9), (Fsxt_l, F9), (Purple, None), (Purple, None),
+                ];
+                let index = word[27..33].load::<u8>();
+                if index == 0b00001 {
+                    // `Table 4-68 `
+                    if word[26] {
+                        (Hint_f, F16)
+                    } else {
+                        (Nop_f, F16)
+                    }
+                } else {
+                    TABLE4_60[index as usize]
+                }
+            }
+        },
+        0x1 => {
+            // `Table 4-59 Miscellaneous Floating-point 1-bit Opcode Extensions`
+            if word[33] {
+                if word[36] {
+                    (Fprcpa, F6)
+                } else {
+                    (Fprsqrta, F7)
+                }
+            } else {
+                // `Table 4-61 Opcode 1 Miscellaneous Floating-point 6-bit Opcode Extensions`
+                const TABLE4_61: [(Opcode, OperandEncodingF); 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),
+                    (Fpmerge_s, F9), (Fpmerge_ns, F9), (Fpmerge_se, F9), (Purple, None),
+                    (Fpmin, F8), (Fpmax, F8), (Fpamin, F8), (Fpamax, F8),
+                    (Fpcvt_fx, F10), (Fpcvt_fxu, F10), (Fpcvt_fx_trunc, F10), (Fpcvt_fxu_trunc, F10),
+                    (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_61[word[27..33].load::<u8>() as usize]
+            }
+        },
+        2 => { (Purple, None) },
+        3 => { (Purple, None) },
+        0x4 => {
+            let index =
+                (word[12] as u8) << 2 +
+                (word[33] as u8) << 1 +
+                (word[36] as u8);
+            const TABLE4_66: [(Opcode, OperandEncodingF); 8] = [
+                (Fcmp_eq, F4), (Fcmp_lt, F4), (Fcmp_le, F4), (Fcmp_unord, F4),
+                (Fcmp_eq_unc, F4), (Fcmp_lt_unc, F4), (Fcmp_le_unc, F4), (Fcmp_unord_unc, F4),
+            ];
+            TABLE4_66[index as usize]
+        },
+        0x5 => {
+            // `Table 4-67 Floating-point Class 1-bit Opcode Extensions`
+            if word[12] {
+                (Fclass_m_unc, F5)
+            } else {
+                (Fclass_m, F5)
+            }
+        },
+        6 => { (Purple, None) },
+        7 => { (Purple, None) },
+        0x8 => {
+            // from section 4.6.1.1
+            if word[36] {
+                (Fma_s_sf, F1)
+            } else {
+                (Fma_sf, F1)
+            }
+        },
+        0x9 => {
+            // from section 4.6.1.1
+            if word[36] {
+                (Fpma_sf, F1)
+            } else {
+                (Fma_d_sf, F1)
+            }
+        },
+        0xa => {
+            // from section 4.6.1.1
+            if word[36] {
+                (Fms_s_sf, F1)
+            } else {
+                (Fms_sf, F1)
+            }
+        },
+        0xb => {
+            // from section 4.6.1.1
+            if word[36] {
+                (Fpms_sf, F1)
+            } else {
+                (Fms_d_sf, F1)
+            }
+        },
+        0xc => {
+            // from section 4.6.1.1
+            if word[36] {
+                (Fnma_s_sf, F1)
+            } else {
+                (Fnma_sf, F1)
+            }
+        },
+        0xd => {
+            // from section 4.6.1.1
+            if word[36] {
+                (Fpnma_sf, F1)
+            } else {
+                (Fnma_d_sf, F1)
+            }
+        },
+        0xe => {
+            // from section 4.6.1.2 and 4.6.2
+            if word[36] {
+                const TABLE_SECTION_4_6_1_2: [(Opcode, OperandEncodingF); 4] = [
+                    (Xma_l, F2),
+                    (White, None), // TODO: what exactly happens with x2 == 1? not mentioned?
+                    (Xma_hu, F2),
+                    (Xma_h, F2),
+                ];
+                TABLE_SECTION_4_6_1_2[word[34..36].load::<u8>() as usize]
+            } else {
+                (Fselect, F3)
+            }
+        },
+        0xf => { (Purple, None) },
+        _ => { unreachable!() },
+    }
+}
+
+fn get_i_opcode_and_encoding(tag: u8, word: &BitSlice<Lsb0, u8>) -> (Opcode, OperandEncodingI) {
+    use Opcode::*;
+    use OperandEncodingI::*;
+
+    match tag {
+        0 => {
+            let x3 = word[33..36].load::<u8>();
+            // `Table 4-24 Misc I-Unit 3-bit Opcode Extensions`
+            if x3 == 0 {
+                // SIDEWAYS
+                // `Table 4-25 Misc I-Unit 6-bit Opcode Extensions`
+                const TABLE4_25: [(Opcode, OperandEncodingI); 64] = [
+                    (Break_i, I19), (Zxt1, I29), (Purple, None), (Mov_from_ip, I25),
+                    // `1-bit Ext (Table 4-26)` is handled independently
+                    (Purple, None), (Zxt2, I29), (Purple, None), (Mov_from_b, I22),
+                    (Purple, None), (Zxt4, I29), (Purple, None), (Mov_i_from_ar, I28),
+                    (Purple, None), (Purple, None), (Purple, None), (Mov_from_pr, I25),
+                    (Purple, None), (Sxt1, I29), (Purple, None), (Purple, None),
+                    (Purple, None), (Sxt2, I29), (Purple, None), (Purple, None),
+                    (Purple, None), (Sxt4, I29), (Purple, None), (Purple, None),
+                    (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                    (Purple, None), (Czx1_l, I29), (Purple, None), (Purple, None),
+                    (Purple, None), (Czx2_l, I29), (Purple, None), (Purple, None),
+                    (Mov_i_to_ar_imm, I27), (Purple, None), (Mov_i_to_ar, I26), (Purple, None),
+                    (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                    (Purple, None), (Czx1_r, I29), (Purple, None), (Purple, None),
+                    (Purple, None), (Czx2_r, I29), (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-26)`
+                    return if word[26] {
+                        (Hint_i, I18)
+                    } else {
+                        (Nop_i, I18)
+                    }
+                }
+                TABLE4_25[index as usize]
+            } else {
+                // `Table 4-24 Misc I-Unit 3-bit Opcode Extensions`
+                const TABLE4_24: [(Opcode, OperandEncodingI); 8] = [
+                    (Purple, None),
+                    (Chk_s_i_int, I20),
+                    (Mov_to_pr_rot_imm, I24),
+                    (Mov_to_pr, I23),
+                    (Purple, None),
+                    (Purple, None),
+                    (Purple, None),
+                    (Mov_to_b, I21),
+                ];
+                TABLE4_24[x3 as usize]
+            }
+        },
+        1 => { (Purple, None) },
+        2 => { (Purple, None) },
+        3 => { (Purple, None) },
+        4 => { (Dep, I15) },
+        5 => {
+            let index = word[34..36].load::<u8>();
+
+            // `Table 4-23 Test Bit Opcode Extensions`
+            // this table is indexed by bits 40:37, 35:34, 33, 36, 12, 13, and 19, in that order.
+            // bits 40:37, 35:34, are always zero, so the actual index is constructed from bits 33,
+            // 36, 12, 13, and 19
+            const TABLE4_23: [(Opcode, OperandEncodingI); 32] = [
+                // bit 19 == 0
+                (Tbit_z, I16), (Tnat_z, I17), (Tbit_z_unc, I16), (Tnat_z_unc, I17),
+                (Tbit_z_and, I16), (Tnat_z_and, I17), (Tbit_nz_and, I16), (Tnat_nz_and, I17),
+                (Tbit_z_or, I16), (Tnat_z_or, I17), (Tbit_nz_or, I16), (Tnat_nz_or, I17),
+                (Tbit_z_or_andcm, I16), (Tnat_z_or_andcm, I17), (Tbit_nz_or_andcm, I16), (Tnat_nz_or_andcm, I17),
+                // bit 19 == 1
+                (Tbit_z, I16), (Tf_z, I30), (Tbit_z_unc, I16), (Tf_z_nc, I30),
+                (Tbit_z_and, I16), (Tf_z_and, I30), (Tbit_nz_and, I16), (Tf_nz_and, I30),
+                (Tbit_z_or, I16), (Tf_z_or, I30), (Tbit_nz_or, I16), (Tf_nz_or, I30),
+                (Tbit_z_or_andcm, I16), (Tf_z_or_andcm, I30), (Tbit_nz_or_andcm, I16), (Tf_nz_or_andcm, I30),
+            ];
+
+            let table4_23_index =
+                (word[19] as u8) << 4 +
+                (word[33] as u8) << 3 +
+                (word[36] as u8) << 2 +
+                (word[12] as u8) << 1 +
+                (word[13] as u8);
+
+            if word[33] {
+                if word[26] {
+                    match index {
+                        0 => TABLE4_23[table4_23_index as usize],
+                        1 => (Dep_z_imm, I13),
+                        2 => (Purple, None),
+                        3 => (Dep_imm, I14),
+                        _ => { unreachable!() },
+                    }
+                } else {
+                    match index {
+                        0 => TABLE4_23[table4_23_index as usize],
+                        1 => (Dep_z, I12),
+                        2 => (Purple, None),
+                        3 => (Dep_imm, I14),
+                        _ => { unreachable!() },
+                    }
+                }
+            } else {
+                if word[13] {
+                    match index {
+                        0 => TABLE4_23[table4_23_index as usize],
+                        1 => (Extr, I11),
+                        2 => (Purple, None),
+                        3 => (Shrp, I10),
+                        _ => { unreachable!() },
+                    }
+                } else {
+                    match index {
+                        0 => TABLE4_23[table4_23_index as usize],
+                        1 => (Extr_u, I11),
+                        2 => (Purple, None),
+                        3 => (Shrp, I10),
+                        _ => { unreachable!() },
+                    }
+                }
+            }
+        },
+        6 => { (Purple, None) },
+        7 => {
+            // partial interpretation of table 4-16, `v_e == 1`
+            if word[32] {
+                (Purple, None)
+            } else {
+                // `Table 4-16 Multimedia and Variable Shift 1-bit Opcode Extensions`
+                // (`v_e == 0`, since `v_e == 1` parts of this table are all undefined)
+                const TABLE4_16: [&'static [(Opcode, OperandEncodingI); 64]; 4] = [
+                    &TABLE4_17,
+                    &TABLE4_18,
+                    &TABLE4_19,
+                    &TABLE4_20,
+                ];
+
+                // `Table 4-17 Multimedia Opcode 7 Size 1 2-bit Opcode Extensions`
+                const TABLE4_17: [(Opcode, OperandEncodingI); 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), (Pmin1_u, I2), (Purple, None), (Purple, None),
+                    (Unpack1_h, I2), (Pmax1_u, I2), (Unpack1_l, I2), (Purple, None),
+                    (Mix1_r, I2), (Purple, None), (Mix1_l, I2), (Psad1, I1),
+                    (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), (Mux1, I3), (Purple, None),
+                    (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                ];
+
+                // `Table 4-18 Multimedia Opcode 7 Size 2 2-bit Opcode Extensions`
+                const TABLE4_18: [(Opcode, OperandEncodingI); 64] = [
+                    (Pshr2_u_var, I5), (Pmpyshr2_u, I1), (Pshr2_var, I5), (Pmpyshr2, I1),
+                    (Pshl1_var, I7), (Pmpyshr2_u, I1), (Purple, None), (Pmpyshr2, I1),
+                    (Purple, None), (Pmpyshr2_u, I1), (Purple, None), (Pmpyshr2, I1),
+                    (Purple, None), (Pmpyshr2_u, I1), (Purple, None), (Pmpyshr2, I1),
+                    (Purple, None), (Pshr2_u_fixed, I6), (Purple, None), (Pshr2_fixed, I6),
+                    (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                    (Purple, None), (Popcnt, I9), (Purple, None), (Purple, None),
+                    (Purple, None), (Clz, I9), (Purple, None), (Purple, None),
+                    (Pack2_uss, I2), (Purple, None), (Pack2_sss, I2), (Pmin2, I2),
+                    (Unpack2_h, I2), (Purple, None), (Unpack2_l, I2), (Pmax2, I2),
+                    (Mix2_r, I2), (Purple, None), (Mix2_l, I2), (Purple, None),
+                    (Purple, None), (Pmpy2_r, I2), (Purple, None), (Pmpy2_l, I2),
+                    (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                    (Purple, None), (Pshl2_fixed, I8), (Purple, None), (Purple, None),
+                    (Purple, None), (Purple, None), (Mux2, I4), (Purple, None),
+                    (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                ];
+
+                // `Table 4-19 Multimedia Opcode 7 Size 4 2-bit Opcode Extensions`
+                const TABLE4_19: [(Opcode, OperandEncodingI); 64] = [
+                    (Pshr4_u_var, I5), (Purple, None), (Pshr4_var, I5), (Purple, None),
+                    (Pshl4_var, I7), (Purple, None), (Purple, None), (Purple, None),
+                    (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                    (Purple, None), (Mpy4, I2), (Purple, None), (Mpyshl4, I2),
+                    (Pshr4_u_fixed, I6), (Purple, None), (Pshr4_fixed, I6), (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), (Pack4_sss, I2), (Purple, None),
+                    (Unpack4_h, I2), (Purple, None), (Unpack4_l, I2), (Purple, None),
+                    (Mix4_r, I2), (Purple, None), (Mix4_l, I2), (Purple, None),
+                    (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                    (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                    (Purple, None), (Pshl4_fixed, I8), (Purple, None), (Purple, None),
+                    (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                    (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                ];
+
+                const TABLE4_20: [(Opcode, OperandEncodingI); 64] = [
+                    (Shr_u_var, I5), (Purple, None), (Shr_var, I5), (Purple, None),
+                    (Shl_var, I7), (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),
+                ];
+
+                let index = (word[36] as u8) << 1 + (word[33] as u8);
+                let inner_index = word[28..32].load::<u8>() + (word[34..35].load::<u8>() << 4);
+                TABLE4_16[index as usize][inner_index as usize]
+            }
+        },
+        _ => {
+            unreachable!("m major op > 7 are a-type instructions");
+        }
+    }
+}
+
 fn get_m_opcode_and_encoding(tag: u8, word: &BitSlice<Lsb0, u8>) -> (Opcode, OperandEncodingM) {
     use Opcode::*;
     use OperandEncodingM::*;
@@ -659,7 +1447,8 @@ fn get_m_opcode_and_encoding(tag: u8, word: &BitSlice<Lsb0, u8>) -> (Opcode, Ope
                 }
                 TABLE4_43[index as usize]
             } else {
-                const TABLE4_42: [(Opcode, OperandEncodingM); 7] = [
+                const TABLE4_42: [(Opcode, OperandEncodingM); 8] = [
+                    (Purple, None),
                     (Purple, None),
                     (Purple, None),
                     (Purple, None),
@@ -698,7 +1487,8 @@ fn get_m_opcode_and_encoding(tag: u8, word: &BitSlice<Lsb0, u8>) -> (Opcode, Ope
                 let index = word[27..33].load::<u8>();
                 TABLE4_45[index as usize]
             } else {
-                const TABLE4_44: [(Opcode, OperandEncodingM); 7] = [
+                const TABLE4_44: [(Opcode, OperandEncodingM); 8] = [
+                    (Purple, None),
                     (Chk_s_m_int, M20),
                     (Purple, None),
                     (Chk_s_fp, M21),
@@ -718,26 +1508,34 @@ fn get_m_opcode_and_encoding(tag: u8, word: &BitSlice<Lsb0, u8>) -> (Opcode, Ope
                 Some(&TABLE4_30),
                 Some(&TABLE4_33),
                 Some(&TABLE4_31),
-                None
+                Option::None
             ];
 
-            // `Table 4-30 Integer Load/Store Opcode Extensions
+            // `Table 4-30 Integer Load/Store Opcode Extensions`
+            // NOTE: this differs from the manual, which i believe to be in error. the manual's
+            // `Table 4-30` lists operand encodings of `M2` in all places that are `M1` here, and is
+            // functionally a duplicate of `Table 4-31` as a result. looking at the `Int Load`
+            // encoding specifically, it indicates that bit 36 (named `m` here) being 0 should pick
+            // `M1` encodings. the manual also lists `M2` twice, so it seems likely at least one
+            // `M2` is in error. the first `M2` matches with the `M1` encoding specified in `Table
+            // 4-4 Instruction Format Summary`, so that's likely the one in error.
+            // `M6` from `Table 4-30` appears to also be in error, and should name `M4`
             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),
+                (Ld1, M1), (Ld2, M1), (Ld4, M1), (Ld8, M1),
+                (Ld1_s, M1), (Ld2_s, M1), (Ld4_s, M1), (Ld8_s, M1),
+                (Ld1_a, M1), (Ld2_a, M1), (Ld4_a, M1), (Ld8_a, M1),
+                (Ld1_sa, M1), (Ld2_sa, M1), (Ld4_sa, M1), (Ld8_sa, M1),
+                (Ld1_bias, M1), (Ld2_bias, M1), (Ld4_bias, M1), (Ld8_bias, M1),
+                (Ld1_acq, M1), (Ld2_acq, M1), (Ld4_acq, M1), (Ld8_acq, M1),
+                (Purple, None), (Purple, None), (Purple, None), (Ld8_fill, M1),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Ld1_c_clr, M1), (Ld2_c_clr, M1), (Ld4_c_clr, M1), (Ld8_c_clr, M1),
+                (Ld1_c_nc, M1), (Ld2_c_nc, M1), (Ld4_c_nc, M1), (Ld8_c_nc, M1),
+                (Ld1_c_clr_acq, M1), (Ld2_c_clr_acq, M1), (Ld4_c_clr_acq, M1), (Ld8_c_clr_acq, M1),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (St1, M4), (St2, M4), (St4, M4), (St8, M4),
+                (St1_rel, M4), (St2_rel, M4), (St4_rel, M4), (St8_rel, M4),
+                (Purple, None), (Purple, None), (Purple, None), (St8_spill, M4),
                 (Purple, None), (Purple, None), (Purple, None), (Purple, None),
             ];
 
@@ -762,6 +1560,7 @@ fn get_m_opcode_and_encoding(tag: u8, word: &BitSlice<Lsb0, u8>) -> (Opcode, Ope
             ];
 
             // `Table 4-33 Semaphore/Get FR/16-byte Opcode Extensions`
+            // `M6` from `Table 4-33` appears to also be in error, and should name `M4`
             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),
@@ -775,13 +1574,16 @@ fn get_m_opcode_and_encoding(tag: u8, word: &BitSlice<Lsb0, u8>) -> (Opcode, Ope
                 (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),
+                (St16, M4), (Purple, None), (Purple, None), (Purple, None),
+                (St16_rel, M4), (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);
+            eprintln!("table {}", index);
+            eprintln!("  subidx {:b}", word[30..36].load::<u8>() as usize);
+            eprintln!("  x6l {:#b}, x6h {:#b}", word[30..32].load::<u8>(), word[32..36].load::<u8>());
             if let Some(op_table) = TABLE4_28[index as usize] {
                 op_table[word[30..36].load::<u8>() as usize]
             } else {
@@ -789,24 +1591,23 @@ fn get_m_opcode_and_encoding(tag: u8, word: &BitSlice<Lsb0, u8>) -> (Opcode, Ope
             }
         },
         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),
+                (Ld1, M3), (Ld2, M3), (Ld4, M3), (Ld8, M3),
+                (Ld1_s, M3), (Ld2_s, M3), (Ld4_s, M3), (Ld8_s, M3),
+                (Ld1_a, M3), (Ld2_a, M3), (Ld4_a, M3), (Ld8_a, M3),
+                (Ld1_sa, M3), (Ld2_sa, M3), (Ld4_sa, M3), (Ld8_sa, M3),
+                (Ld1_bias, M3), (Purple, M3), (Purple, M3), (Ld8_bias, M3),
+                (Ld1_acq, M3), (Purple, M3), (Purple, M3), (Ld8_acq, M3),
+                (Purple, None), (Purple, None), (Purple, None), (Ld8_fill, M3),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Ld1_c_clr, M3), (Ld2_c_clr, M3), (Ld4_c_clr, M3), (Ld8_c_clr, M3),
+                (Ld1_c_nc, M3), (Ld2_c_nc, M3), (Ld4_c_nc, M3), (Ld8_c_nc, M3),
+                (Ld1_c_clr_acq, M3), (Ld2_c_clr_acq, M3), (Ld4_c_clr_acq, M3), (Ld8_c_clr_acq, M3),
+                (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (St1, M5), (St2, M5), (St4, M5), (St8, M5),
+                (St1_rel, M5), (St2_rel, M5), (St4_rel, M5), (St8_rel, M5),
+                (Purple, None), (Purple, None), (Purple, None), (St8_spill, M5),
                 (Purple, None), (Purple, None), (Purple, None), (Purple, None),
             ];
 
@@ -822,26 +1623,30 @@ fn get_m_opcode_and_encoding(tag: u8, word: &BitSlice<Lsb0, u8>) -> (Opcode, Ope
             ];
 
             // `Table 4-34 Floating-point Load/Store/Lfetch Opcode Extensions`
+            // NOTE: manual is in error. `M9` in this table ought to be `M6`.
+            // NOTE: manual is in error. `M13` in this table ought to be `M9`.
+            // NOTE: manual is in error. `M18` in this table ought to be `M13`.
             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),
+                (Ldfe, M6), (Ldf8, M6), (Ldfs, M6), (Ldfd, M6),
+                (Ldfe_s, M6), (Ldf8_s, M6), (Ldfs_s, M6), (Ldfd_s, M6),
+                (Ldfe_a, M6), (Ldf8_a, M6), (Ldfp_a, M6), (Ldfd_a, M6),
+                (Ldfe_sa, M6), (Ldf8_sa, M6), (Ldfp_sa, M6), (Ldfd_sa, M6),
                 (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), (Ldf_fill, M6),
                 (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),
+                (Ldfe_c_clr, M6), (Ldf8_c_clr, M6), (Ldfs_c_clr, M6), (Ldfd_c_clr, M6),
+                (Ldfe_c_nc, M6), (Ldf8_c_nc, M6), (Ldfs_c_nc, M6), (Ldfd_c_nc, M6),
                 (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),
+                (Lfetch, M13), (Lfetch_excl, M13), (Lfetch_fault, M13), (Lfetch_fault_excl, M13),
+                (Stfe, M9), (Stf8, M9), (Stfs, M9), (Stfd, M9),
                 (Purple, None), (Purple, None), (Purple, None), (Purple, None),
-                (Purple, None), (Purple, None), (Purple, None), (Stf_spill, M13),
+                (Purple, None), (Purple, None), (Purple, None), (Stf_spill, M9),
                 (Purple, None), (Purple, None), (Purple, None), (Purple, None),
             ];
 
             // `Table 4-35 Floating-point Load/Lfetch +Reg Opcode Extensions`
+            // NOTE: manual is in error. `M20` in this table ought to be `M14`.
             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),
@@ -854,7 +1659,7 @@ fn get_m_opcode_and_encoding(tag: u8, word: &BitSlice<Lsb0, u8>) -> (Opcode, Ope
                 (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),
+                (Lfetch, M14), (Lfetch_excl, M14), (Lfetch_fault, M14), (Lfetch_fault_excl, M14),
                 (Purple, None), (Purple, None), (Purple, None), (Purple, None),
                 (Purple, None), (Purple, None), (Purple, None), (Purple, None),
                 (Purple, None), (Purple, None), (Purple, None), (Purple, None),
@@ -907,22 +1712,23 @@ fn get_m_opcode_and_encoding(tag: u8, word: &BitSlice<Lsb0, u8>) -> (Opcode, Ope
         },
         7 => {
             // `Table 4-36 Floating-point Load/Store/Lfetch +Imm Opcode Extensions`
+            // NOTE: manual is in error. `M22` in this table ought to be `M15`.
             const TABLE4_36: [(Opcode, OperandEncodingM); 64] = [
+                (Ldfe, M8), (Ldf8, M8), (Ldfs, M8), (Ldfd, M8),
+                (Ldfe_s, M8), (Ldf8_s, M8), (Ldfs_s, M8), (Ldfd_s, M8),
+                (Ldfe_a, M8), (Ldf8_a, M8), (Ldfs_a, M8), (Ldfd_a, M8),
+                (Ldfe_sa, M8), (Ldf8_sa, M8), (Ldfs_sa, M8), (Ldfd_sa, M8),
                 (Purple, None), (Purple, None), (Purple, None), (Purple, None),
                 (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Purple, None), (Purple, None), (Purple, None), (Ldf_fill, M8),
                 (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Ldfe_c_clr, M8), (Ldf8_c_clr, M8), (Ldfs_c_clr, M8), (Ldfd_c_clr, M8),
+                (Ldfe_c_nc, M8), (Ldf8_c_nc, M8), (Ldfs_c_nc, M8), (Ldfd_c_nc, M8),
                 (Purple, None), (Purple, None), (Purple, None), (Purple, None),
+                (Lfetch, M15), (Lfetch_excl, M15), (Lfetch_fault, M15), (Lfetch_fault_excl, M15),
+                (Stfe, M10), (Stf8, M10), (Stfs, M10), (Stfd, M10),
                 (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), (Stf_spill, M10),
                 (Purple, None), (Purple, None), (Purple, None), (Purple, None),
             ];
 
@@ -976,7 +1782,7 @@ fn get_a_opcode_and_encoding(tag: u8, word: &BitSlice<Lsb0, u8>) -> (Opcode, Ope
                         Some(&TABLE4_13),
                         Some(&TABLE4_14),
                         Some(&TABLE4_15),
-                        None
+                        Option::None
                     ];
 
                     const TABLE4_13: [(Opcode, OperandEncodingA); 64] = [
@@ -1001,8 +1807,8 @@ fn get_a_opcode_and_encoding(tag: u8, word: &BitSlice<Lsb0, u8>) -> (Opcode, Ope
                     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),
+                        (Purple, None), (Purple, None), (Pavg2, A9), (Pavg2_raz, A9),
+                        (Purple, None), (Purple, None), (Pavgsub2, 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),
@@ -1049,6 +1855,9 @@ fn get_a_opcode_and_encoding(tag: u8, word: &BitSlice<Lsb0, u8>) -> (Opcode, Ope
                 3 => {
                     (Opcode::Addp4, OperandEncodingA::A4)
                 }
+                _ => {
+                    unreachable!()
+                }
             }
         }
         9 => (Addl, A5),
@@ -1056,35 +1865,35 @@ fn get_a_opcode_and_encoding(tag: u8, word: &BitSlice<Lsb0, u8>) -> (Opcode, Ope
         0xb => (Purple, None),
         0xc => {
             let x2 = word[34..36].load::<u8>();
-            if x2 > 1 {
+            let encoding = if x2 > 1 {
                 // `Table 4-11 Integer Compare Immediate Opcode Extensions`
-                let encoding = A8;
+                A8
             } else {
                 // `Table 4-10 Integer Compare Opcode Extensions`
-                let encoding = if word[36] { A7 } else { A6 };
-            }
+                if word[36] { A7 } else { A6 }
+            };
             unimplemented!("type a, tag c");
         }
         0xd => {
             let x2 = word[34..36].load::<u8>();
-            if x2 > 1 {
+            let encoding = if x2 > 1 {
                 // `Table 4-11 Integer Compare Immediate Opcode Extensions`
-                let encoding = A8;
+                A8
             } else {
                 // `Table 4-10 Integer Compare Opcode Extensions`
-                let encoding = if word[36] { A7 } else { A6 };
-            }
+                if word[36] { A7 } else { A6 }
+            };
             unimplemented!("type a, tag d");
         }
         0xe => {
             let x2 = word[34..36].load::<u8>();
-            if x2 > 1 {
+            let encoding = if x2 > 1 {
                 // `Table 4-11 Integer Compare Immediate Opcode Extensions`
-                let encoding = A8;
+                A8
             } else {
                 // `Table 4-10 Integer Compare Opcode Extensions`
-                let encoding = if word[36] { A7 } else { A6 };
-            }
+                if word[36] { A7 } else { A6 }
+            };
             unimplemented!("type a, tag e");
         }
         0xf => (Purple, None),
@@ -1111,6 +1920,7 @@ enum OperandEncodingA {
 
 #[derive(Copy, Clone, Debug)]
 enum OperandEncodingI {
+    None,
     I1,
     I2,
     I3,
@@ -1198,6 +2008,7 @@ enum OperandEncodingM {
 
 #[derive(Copy, Clone, Debug)]
 enum OperandEncodingB {
+    None,
     B1,
     B2,
     B3,
@@ -1211,6 +2022,7 @@ enum OperandEncodingB {
 
 #[derive(Copy, Clone, Debug)]
 enum OperandEncodingF {
+    None,
     F1,
     F2,
     F3,
@@ -1231,6 +2043,7 @@ enum OperandEncodingF {
 
 #[derive(Copy, Clone, Debug)]
 enum OperandEncodingX {
+    None,
     X1,
     X2,
     X3,