use super::{Insn, Operand, Operands, Reg, Width};
use crate::Cond;
const RANGE_LO: u16 = 0xC000;
const RANGE_HI: u16 = 0xE7FF;
const BASE_WRITEBACK: [&str; 8] = ["r0!", "r1!", "r2!", "r3!", "r4!", "r5!", "r6!", "r7!"];
fn sign_extend(value: u32, bits: u32) -> i32 {
let shift = 32 - bits;
((value << shift) as i32) >> shift
}
fn target_of(addr: u32, off: i32) -> u32 {
addr.wrapping_add(4).wrapping_add(off as u32)
}
fn disp_to(addr: u32, target: u32) -> i32 {
target.wrapping_sub(addr.wrapping_add(4)) as i32
}
fn insn(
mnemonic: &'static str,
encoding: &'static str,
addr: u32,
cond: Option<Cond>,
operands: Operands,
) -> Insn {
Insn {
mnemonic,
encoding,
addr,
width: Width::Narrow,
cond,
sets_flags: false,
explicit_width: false,
operands,
}
}
pub(crate) fn decode(hw1: u16, _hw2: u16, addr: u32) -> Option<Insn> {
if !(RANGE_LO..=RANGE_HI).contains(&hw1) {
return None;
}
match hw1 >> 11 {
0b11000 => decode_stm(hw1, addr),
0b11001 => decode_ldm(hw1, addr),
0b11010 | 0b11011 => decode_cond_branch(hw1, addr),
_ => decode_b_t2(hw1, addr),
}
}
fn decode_stm(hw1: u16, addr: u32) -> Option<Insn> {
let rn = ((hw1 >> 8) & 0b111) as usize;
let list = hw1 & 0xFF;
if list == 0 {
return None;
}
let mut ops = Operands::new();
ops.push(Operand::Text(BASE_WRITEBACK[rn]));
ops.push(Operand::RegList(list));
Some(insn("stmia", "T1", addr, None, ops))
}
fn decode_ldm(hw1: u16, addr: u32) -> Option<Insn> {
let rn = ((hw1 >> 8) & 0b111) as usize;
let list = hw1 & 0xFF;
if list == 0 {
return None;
}
let wback = list & (1 << rn) == 0;
let mut ops = Operands::new();
if wback {
ops.push(Operand::Text(BASE_WRITEBACK[rn]));
} else {
ops.push(Operand::Reg(Reg(rn as u8)));
}
ops.push(Operand::RegList(list));
Some(insn("ldmia", "T1", addr, None, ops))
}
fn decode_cond_branch(hw1: u16, addr: u32) -> Option<Insn> {
let cond_bits = ((hw1 >> 8) & 0xF) as u8;
let imm8 = (hw1 & 0xFF) as u32;
let cond = match Cond::from_bits(cond_bits) {
Some(c) => c,
None => {
let mut ops = Operands::new();
ops.push(Operand::Imm(imm8 as i64));
return Some(insn("svc", "T1", addr, None, ops));
}
};
if cond == Cond::Al {
let mut ops = Operands::new();
ops.push(Operand::Imm(imm8 as i64));
return Some(insn("udf", "T1", addr, None, ops));
}
let off = sign_extend(imm8 << 1, 9);
let mut ops = Operands::new();
ops.push(Operand::Target(target_of(addr, off)));
Some(insn("b", "T1", addr, Some(cond), ops))
}
fn decode_b_t2(hw1: u16, addr: u32) -> Option<Insn> {
let imm11 = (hw1 & 0x7FF) as u32;
let off = sign_extend(imm11 << 1, 12);
let mut ops = Operands::new();
ops.push(Operand::Target(target_of(addr, off)));
Some(insn("b", "T2", addr, None, ops))
}
pub(crate) fn encode(insn: &Insn) -> Option<u16> {
match (insn.mnemonic, insn.encoding) {
("stmia", "T1") => encode_stm_ldm(insn, 0xC000, true),
("ldmia", "T1") => encode_stm_ldm(insn, 0xC800, false),
("b", "T1") => {
let cond = insn.cond?;
if cond == Cond::Al {
return None;
}
let imm8 = fit_disp(insn, 8)?;
Some(0xD000 | ((cond.bits() as u16) << 8) | imm8)
}
("b", "T2") => Some(0xE000 | fit_disp(insn, 11)?),
("udf", "T1") => Some(0xDE00 | imm8_of(insn)?),
("svc", "T1") => Some(0xDF00 | imm8_of(insn)?),
_ => None,
}
}
fn fit_disp(insn: &Insn, bits: u32) -> Option<u16> {
let target = insn.branch_target()?;
let off = disp_to(insn.addr, target);
if off & 1 != 0 {
return None;
}
let half = off >> 1;
let limit = 1i32 << (bits - 1);
if half < -limit || half >= limit {
return None;
}
Some((half as u16) & ((1u16 << bits) - 1))
}
fn imm8_of(insn: &Insn) -> Option<u16> {
match insn.operands.get(0)? {
Operand::Imm(v) if (0..=0xFF).contains(&v) => Some(v as u16),
_ => None,
}
}
fn encode_stm_ldm(insn: &Insn, base: u16, always_wback: bool) -> Option<u16> {
let (rn, wback) = match insn.operands.get(0)? {
Operand::Text(s) => (BASE_WRITEBACK.iter().position(|w| *w == s)? as u16, true),
Operand::Reg(r) if r.is_low() => (r.num() as u16, false),
_ => return None,
};
let list = match insn.operands.get(1)? {
Operand::RegList(bits) if bits != 0 && bits <= 0xFF => bits,
_ => return None,
};
let expected_wback = always_wback || list & (1 << rn) == 0;
if wback != expected_wback {
return None;
}
Some(base | (rn << 8) | list)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::isa::Target;
fn dec(hw1: u16, addr: u32) -> Option<Insn> {
decode(hw1, 0, addr)
}
#[test]
fn exhaustive_round_trip() {
for addr in [0u32, 2, 0x8000, 0xFFFF_FFFC] {
let mut decoded = 0usize;
let mut rejected = Vec::new();
for hw in RANGE_LO..=RANGE_HI {
match dec(hw, addr) {
Some(i) => {
decoded += 1;
assert_eq!(encode(&i), Some(hw), "{hw:#06x} at {addr:#x} -> {i}");
assert_eq!(i.len(), 2, "{hw:#06x} must be narrow");
assert!(!i.sets_flags, "{hw:#06x} must not set flags");
}
None => rejected.push(hw),
}
}
assert_eq!(rejected.len(), 16);
assert_eq!(decoded, 10240 - 16);
assert_eq!(decoded, 10224);
for hw in &rejected {
assert_eq!(hw & 0xFF, 0, "{hw:#06x} rejected for the wrong reason");
assert!((0xC000..=0xCFFF).contains(hw), "{hw:#06x} out of STM/LDM");
}
let expected: Vec<u16> = (0..8)
.map(|n| 0xC000 | (n << 8))
.chain((0..8).map(|n| 0xC800 | (n << 8)))
.collect();
let mut sorted = rejected.clone();
sorted.sort_unstable();
let mut expected_sorted = expected;
expected_sorted.sort_unstable();
assert_eq!(sorted, expected_sorted);
}
}
#[test]
fn a_non_low_base_is_refused_by_the_narrow_encoder() {
for base in 8u8..=15 {
for (mnemonic, base_hw) in [("stmia", 0xC000u16), ("ldmia", 0xC800)] {
let insn = Insn {
mnemonic,
encoding: "T1",
addr: 0,
width: Width::Narrow,
cond: None,
sets_flags: false,
explicit_width: false,
operands: {
let mut ops = Operands::new();
ops.push(Operand::Reg(Reg(base)));
ops.push(Operand::RegList(1));
ops
},
};
assert_eq!(
encode(&insn),
None,
"{mnemonic} with Rn=r{base} must not encode (would collide with {base_hw:#06x})"
);
}
}
}
#[test]
fn range_partition() {
for hw in RANGE_LO..=RANGE_HI {
let expect = match hw {
0xC000..=0xC7FF => "stmia",
0xC800..=0xCFFF => "ldmia",
0xD000..=0xDDFF => "b",
0xDE00..=0xDEFF => "udf",
0xDF00..=0xDFFF => "svc",
_ => "b",
};
if let Some(i) = dec(hw, 0x1000) {
assert_eq!(i.mnemonic, expect, "{hw:#06x}");
}
}
assert!(dec(0xBFFF, 0).is_none());
assert!(dec(0xE800, 0).is_none());
assert!(dec(0xFFFF, 0).is_none());
}
#[test]
fn bcond_t1_extremes() {
let fwd = dec(0xD07F, 0x1000).unwrap(); assert_eq!(fwd.mnemonic, "b");
assert_eq!(fwd.cond, Some(Cond::Eq));
assert_eq!(fwd.branch_target(), Some(0x1102));
assert_eq!(fwd.to_string(), "beq 0x1102");
assert_eq!(encode(&fwd), Some(0xD07F));
let back = dec(0xD080, 0x1000).unwrap();
assert_eq!(back.branch_target(), Some(0x0F04));
assert_eq!(0x1000u32 + 4 - 256, 0x0F04);
assert_eq!(encode(&back), Some(0xD080));
assert_eq!(dec(0xD07E, 0x1000).unwrap().branch_target(), Some(0x1100));
assert_eq!(dec(0xD081, 0x1000).unwrap().branch_target(), Some(0x0F06));
assert_eq!(dec(0xD000, 0x1000).unwrap().branch_target(), Some(0x1004));
}
#[test]
fn b_t2_extremes() {
let fwd = dec(0xE3FF, 0x1000).unwrap();
assert_eq!(fwd.mnemonic, "b");
assert_eq!(fwd.encoding, "T2");
assert_eq!(fwd.cond, None);
assert_eq!(fwd.branch_target(), Some(0x1802));
assert_eq!(fwd.to_string(), "b 0x1802");
assert_eq!(encode(&fwd), Some(0xE3FF));
let back = dec(0xE400, 0x1000).unwrap();
assert_eq!(back.branch_target(), Some(0x0804));
assert_eq!(0x1000u32 + 4 - 2048, 0x0804);
assert_eq!(encode(&back), Some(0xE400));
assert_eq!(dec(0xE3FE, 0x1000).unwrap().branch_target(), Some(0x1800));
assert_eq!(dec(0xE401, 0x1000).unwrap().branch_target(), Some(0x0806));
assert_eq!(dec(0xE000, 0x1000).unwrap().branch_target(), Some(0x1004));
}
#[test]
fn wraps_below_zero() {
let b = dec(0xD080, 0x0000).unwrap();
assert_eq!(b.branch_target(), Some(0xFFFF_FF04));
assert_eq!(encode(&b), Some(0xD080));
let b2 = dec(0xE400, 0x0002).unwrap();
assert_eq!(b2.branch_target(), Some(0xFFFF_F806));
assert_eq!(encode(&b2), Some(0xE400));
let up = dec(0xE3FF, 0xFFFF_FFFC).unwrap();
assert_eq!(up.branch_target(), Some(0x7FE));
assert_eq!(encode(&up), Some(0xE3FF));
}
#[test]
fn encode_rejects_out_of_range() {
let mut b = dec(0xD000, 0x1000).unwrap();
b.operands = core::iter::once(Operand::Target(0x1000 + 4 + 254)).collect();
assert_eq!(encode(&b), Some(0xD07F));
b.operands = core::iter::once(Operand::Target(0x1000 + 4 + 256)).collect();
assert_eq!(encode(&b), None);
b.operands = core::iter::once(Operand::Target(0x1000 + 4 - 256)).collect();
assert_eq!(encode(&b), Some(0xD080));
b.operands = core::iter::once(Operand::Target(0x1000 + 4 - 258)).collect();
assert_eq!(encode(&b), None);
b.operands = core::iter::once(Operand::Target(0x1000 + 4 + 3)).collect();
assert_eq!(encode(&b), None);
let mut t2 = dec(0xE000, 0x1000).unwrap();
t2.operands = core::iter::once(Operand::Target(0x1000 + 4 + 2046)).collect();
assert_eq!(encode(&t2), Some(0xE3FF));
t2.operands = core::iter::once(Operand::Target(0x1000 + 4 + 2048)).collect();
assert_eq!(encode(&t2), None);
t2.operands = core::iter::once(Operand::Target(0x1000 + 4 - 2048)).collect();
assert_eq!(encode(&t2), Some(0xE400));
t2.operands = core::iter::once(Operand::Target(0x1000 + 4 - 2050)).collect();
assert_eq!(encode(&t2), None);
}
#[test]
fn de_is_udf_df_is_svc() {
let udf = dec(0xDE00, 0x1000).unwrap();
assert_eq!(udf.mnemonic, "udf");
assert_eq!(udf.encoding, "T1");
assert_eq!(udf.cond, None);
assert!(!udf.is_branch());
assert!(!udf.writes_pc());
assert_eq!(udf.branch_target(), None);
assert_eq!(udf.to_string(), "udf #0");
assert_eq!(encode(&udf), Some(0xDE00));
let svc = dec(0xDF00, 0x1000).unwrap();
assert_eq!(svc.mnemonic, "svc");
assert_eq!(svc.cond, None);
assert!(!svc.is_branch());
assert!(!svc.writes_pc());
assert_eq!(svc.branch_target(), None);
assert_eq!(svc.to_string(), "svc #0");
assert_eq!(encode(&svc), Some(0xDF00));
assert_eq!(dec(0xDEAB, 0).unwrap().to_string(), "udf #0xab");
assert_eq!(dec(0xDF2A, 0).unwrap().to_string(), "svc #0x2a");
assert_eq!(dec(0xDFFF, 0).unwrap().to_string(), "svc #0xff");
for hw in 0xDE00u16..=0xDFFF {
let i = dec(hw, 0x1000).unwrap();
assert!(!i.is_branch(), "{hw:#06x} must not be a branch");
assert!(i.cond.is_none(), "{hw:#06x} must carry no condition");
}
}
#[test]
fn fourteen_conditions() {
let expect = [
(0x0u16, Cond::Eq, "beq"),
(0x1, Cond::Ne, "bne"),
(0x2, Cond::Hs, "bhs"),
(0x3, Cond::Lo, "blo"),
(0x4, Cond::Mi, "bmi"),
(0x5, Cond::Pl, "bpl"),
(0x6, Cond::Vs, "bvs"),
(0x7, Cond::Vc, "bvc"),
(0x8, Cond::Hi, "bhi"),
(0x9, Cond::Ls, "bls"),
(0xA, Cond::Ge, "bge"),
(0xB, Cond::Lt, "blt"),
(0xC, Cond::Gt, "bgt"),
(0xD, Cond::Le, "ble"),
];
for (bits, cond, text) in expect {
let hw = 0xD000 | (bits << 8);
let i = dec(hw, 0x1000).unwrap();
assert_eq!(
i.mnemonic, "b",
"{hw:#06x} keeps the condition out of the mnemonic"
);
assert_eq!(i.cond, Some(cond), "{hw:#06x}");
assert!(i.is_branch());
assert_eq!(i.to_string(), format!("{text} 0x1004"));
assert_eq!(encode(&i), Some(hw));
}
let beq = dec(0xD000, 0x1000).unwrap();
assert!(beq.to_string().starts_with("beq "));
assert!(!beq.to_string().starts_with("beqeq"));
assert_ne!(beq.to_string().split(' ').next(), Some("b"));
let mut al = beq;
al.cond = Some(Cond::Al);
assert_eq!(encode(&al), None);
}
#[test]
fn branch_target_agrees() {
for &(hw, addr, want) in &[
(0xD005u16, 0x0000u32, 0x000Eu32), (0xD1FE, 0x2000, 0x2000 + 4 - 4), (0xE010, 0x0100, 0x0100 + 4 + 32), (0xE7FE, 0x4444, 0x4444 + 4 - 4), ] {
let i = dec(hw, addr).unwrap();
assert_eq!(i.branch_target(), Some(want), "{hw:#06x} at {addr:#x}");
assert!(i.is_branch());
assert_eq!(encode(&i), Some(hw));
}
assert_eq!(dec(0xE7FE, 0x4444).unwrap().branch_target(), Some(0x4444));
}
#[test]
fn stm_ldm_printing() {
let stm = dec(0xC006, 0x1000).unwrap();
assert_eq!(stm.to_string(), "stmia r0!, {r1, r2}");
assert_eq!(stm.mnemonic, "stmia");
assert_eq!(stm.encoding, "T1");
assert!(!stm.is_branch());
assert!(!stm.writes_pc());
assert_eq!(encode(&stm), Some(0xC006));
let ldm = dec(0xC80E, 0x1000).unwrap();
assert_eq!(ldm.to_string(), "ldmia r0!, {r1-r3}");
assert!(!ldm.is_branch());
assert!(!ldm.writes_pc());
assert_eq!(encode(&ldm), Some(0xC80E));
assert_eq!(
dec(0xC4F1, 0).unwrap().to_string(),
"stmia r4!, {r0, r4-r7}"
);
assert_eq!(dec(0xC301, 0).unwrap().to_string(), "stmia r3!, {r0}");
assert_eq!(dec(0xC308, 0).unwrap().to_string(), "stmia r3!, {r3}");
assert_eq!(dec(0xCB08, 0).unwrap().to_string(), "ldmia r3, {r3}");
assert_eq!(dec(0xCB09, 0).unwrap().to_string(), "ldmia r3, {r0, r3}");
assert_eq!(dec(0xCB01, 0).unwrap().to_string(), "ldmia r3!, {r0}");
for rn in 0u16..8 {
let with = dec(0xC800 | (rn << 8) | (1 << rn), 0).unwrap();
assert_eq!(with.operands.get(0), Some(Operand::Reg(Reg(rn as u8))));
let without = dec(0xC800 | (rn << 8) | (1 << ((rn + 1) % 8)), 0).unwrap();
assert_eq!(
without.operands.get(0),
Some(Operand::Text(BASE_WRITEBACK[rn as usize])),
"Rn absent from the list means writeback, spelled `!`"
);
}
for hw in 0xC000u16..=0xCFFF {
if let Some(i) = dec(hw, 0) {
let list = i.operands.as_slice().find_map(|o| match o {
Operand::RegList(bits) => Some(bits),
_ => None,
});
assert_eq!(
list.map(|bits| bits & 0xFF00),
Some(0),
"{hw:#06x} has no register list, or names a high register"
);
assert!(!i.writes_pc(), "{hw:#06x}");
}
}
}
#[test]
fn empty_reglist_rejected() {
for rn in 0u16..8 {
assert!(dec(0xC000 | (rn << 8), 0).is_none());
assert!(dec(0xC800 | (rn << 8), 0).is_none());
}
let mut stm = dec(0xC006, 0).unwrap();
stm.operands = [Operand::Text("r0!"), Operand::RegList(0)]
.into_iter()
.collect();
assert_eq!(encode(&stm), None);
stm.operands = [Operand::Text("r0!"), Operand::RegList(1 << 15)]
.into_iter()
.collect();
assert_eq!(encode(&stm), None);
for r in 8u8..16 {
for (base, mnemonic) in [(0xC006u16, "stmia"), (0xC806, "ldmia")] {
let mut high = dec(base, 0).unwrap();
assert_eq!(high.mnemonic, mnemonic);
high.operands = [Operand::Reg(Reg(r)), Operand::RegList(0b110)]
.into_iter()
.collect();
assert_eq!(encode(&high), None, "{mnemonic} through r{r}");
}
}
}
#[test]
fn encode_reads_no_operand_it_has_not_checked() {
let base = dec(0xD000, 0x1000).unwrap(); let no_ops = Operands::new();
let mut b = base;
b.cond = None;
assert_eq!(encode(&b), None, "B T1 has a condition field");
b.cond = Some(Cond::Al);
assert_eq!(encode(&b), None, "0b1110 is UDF's row");
for encoding in ["T1", "T2"] {
let mut bare = base;
bare.encoding = encoding;
bare.operands = no_ops;
assert_eq!(encode(&bare), None, "B {encoding} with no target");
let mut wrong = base;
wrong.encoding = encoding;
wrong.operands = [Operand::Imm(4)].into_iter().collect();
assert_eq!(encode(&wrong), None, "B {encoding} with an immediate");
}
for (mnemonic, hw) in [("udf", 0xDE00u16), ("svc", 0xDF00)] {
let base = dec(hw, 0x1000).unwrap();
assert_eq!(base.mnemonic, mnemonic);
let mut bare = base;
bare.operands = no_ops;
assert_eq!(encode(&bare), None, "{mnemonic} with no immediate");
for imm in [-1i64, 256, 0x1_0000] {
let mut big = base;
big.operands = [Operand::Imm(imm)].into_iter().collect();
assert_eq!(encode(&big), None, "{mnemonic} #{imm} is not 8 bits");
}
let mut wrong = base;
wrong.operands = [Operand::Target(0x1004)].into_iter().collect();
assert_eq!(encode(&wrong), None, "{mnemonic} takes an immediate");
let mut ok = base;
ok.operands = [Operand::Imm(0xAB)].into_iter().collect();
assert_eq!(encode(&ok), Some(hw | 0xAB));
}
let stm = dec(0xC006, 0).unwrap(); let ldm = dec(0xC806, 0).unwrap(); let mut bare = stm;
bare.operands = no_ops;
assert_eq!(encode(&bare), None, "no base register");
let mut base_only = stm;
base_only.operands = [Operand::Text("r0!")].into_iter().collect();
assert_eq!(encode(&base_only), None, "no register list");
let mut unknown_base = stm;
unknown_base.operands = [Operand::Text("r9!"), Operand::RegList(0b110)]
.into_iter()
.collect();
assert_eq!(encode(&unknown_base), None, "r9 is not a three-bit field");
let mut imm_base = stm;
imm_base.operands = [Operand::Imm(0), Operand::RegList(0b110)]
.into_iter()
.collect();
assert_eq!(encode(&imm_base), None, "the base is a register");
let mut imm_list = stm;
imm_list.operands = [Operand::Text("r0!"), Operand::Imm(6)]
.into_iter()
.collect();
assert_eq!(encode(&imm_list), None, "the list is a register list");
let mut stm_no_wback = stm;
stm_no_wback.operands = [Operand::Reg(Reg(0)), Operand::RegList(0b110)]
.into_iter()
.collect();
assert_eq!(encode(&stm_no_wback), None, "STM T1 always writes back");
let mut ldm_wback_in_list = ldm;
ldm_wback_in_list.operands = [Operand::Text("r0!"), Operand::RegList(0b1)]
.into_iter()
.collect();
assert_eq!(
encode(&ldm_wback_in_list),
None,
"LDM T1 suppresses writeback when Rn is loaded"
);
let mut ldm_no_wback = ldm;
ldm_no_wback.operands = [Operand::Reg(Reg(0)), Operand::RegList(0b1)]
.into_iter()
.collect();
assert_eq!(encode(&ldm_no_wback), Some(0xC801));
}
#[test]
fn encode_is_scoped() {
let mut b = dec(0xD000, 0x1000).unwrap();
b.encoding = "T3"; assert_eq!(encode(&b), None);
b.encoding = "T1";
b.mnemonic = "bl";
assert_eq!(encode(&b), None);
let mut udf = dec(0xDE00, 0).unwrap();
udf.encoding = "T2"; assert_eq!(encode(&udf), None);
udf.encoding = "T1";
udf.operands = core::iter::once(Operand::Imm(0x100)).collect();
assert_eq!(encode(&udf), None);
}
#[test]
fn dispatch_boundary() {
for hw in RANGE_LO..=RANGE_HI {
assert_eq!(super::super::insn_len(hw), 2, "{hw:#06x}");
let via_dispatch = super::super::decode_halfwords(hw, 0, 0x1000, Target::Union);
assert_eq!(via_dispatch, dec(hw, 0x1000), "{hw:#06x} routed elsewhere");
}
assert_eq!(super::super::insn_len(0xE800), 4);
}
#[test]
fn disassembles_in_context() {
let hws: [u16; 6] = [0xC006, 0xC80E, 0xD000, 0xE000, 0xDF2A, 0xDEFF];
let mut image = Vec::new();
for hw in hws {
image.extend_from_slice(&hw.to_le_bytes());
}
let text = super::super::disassemble(&image, 0, 0x1000, 6);
assert_eq!(
text,
vec![
"00001000: stmia r0!, {r1, r2}".to_string(),
"00001002: ldmia r0!, {r1-r3}".to_string(),
"00001004: beq 0x1008".to_string(),
"00001006: b 0x100a".to_string(),
"00001008: svc #0x2a".to_string(),
"0000100a: udf #0xff".to_string(),
]
);
}
#[test]
fn sign_extension() {
assert_eq!(sign_extend(0, 9), 0);
assert_eq!(sign_extend(0xFE, 9), 254);
assert_eq!(sign_extend(0x100, 9), -256);
assert_eq!(sign_extend(0x1FE, 9), -2);
assert_eq!(sign_extend(0x7FE, 12), 2046);
assert_eq!(sign_extend(0x800, 12), -2048);
assert_eq!(sign_extend(0xFFE, 12), -2);
}
}