use std::collections::BTreeMap;
use crate::debugger::mi::Value;
use crate::instruction::registers::{self, Register, RegisterWidth};
use crate::instruction::Flags;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Hash)]
pub enum Format {
#[default]
Hex,
Decimal,
Signed,
Binary,
Ascii,
}
impl Format {
pub const ALL: [Format; 5] = [
Format::Hex,
Format::Decimal,
Format::Signed,
Format::Binary,
Format::Ascii,
];
pub const fn label(self) -> &'static str {
match self {
Format::Hex => "hex",
Format::Decimal => "dec",
Format::Signed => "signed",
Format::Binary => "bin",
Format::Ascii => "ascii",
}
}
pub fn next(self) -> Self {
let index = Self::ALL.iter().position(|f| *f == self).unwrap_or(0);
Self::ALL[(index + 1) % Self::ALL.len()]
}
}
pub fn format_value(value: u64, width: RegisterWidth, format: Format) -> String {
let value = value & width.mask();
let digits = (width.bits() / 4) as usize;
match format {
Format::Hex => format!("0x{value:0digits$x}"),
Format::Decimal => value.to_string(),
Format::Signed => signed_value(value, width).to_string(),
Format::Binary => {
let bits = width.bits() as usize;
let text = format!("{value:0bits$b}");
text.as_bytes()
.chunks(8)
.map(|chunk| String::from_utf8_lossy(chunk).into_owned())
.collect::<Vec<_>>()
.join(" ")
}
Format::Ascii => ascii_of(value, width),
}
}
pub fn signed_value(value: u64, width: RegisterWidth) -> i64 {
let value = value & width.mask();
match width {
RegisterWidth::Byte => value as u8 as i8 as i64,
RegisterWidth::Word => value as u16 as i16 as i64,
RegisterWidth::Dword => value as u32 as i32 as i64,
RegisterWidth::Qword => value as i64,
}
}
pub fn ascii_of(value: u64, width: RegisterWidth) -> String {
let value = value & width.mask();
(0..width.bytes())
.map(|index| {
let byte = ((value >> (index * 8)) & 0xff) as u8;
if byte.is_ascii_graphic() || byte == b' ' {
byte as char
} else {
'.'
}
})
.collect()
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct RegisterEntry {
pub register: Register,
pub value: u64,
pub previous: Option<u64>,
}
impl RegisterEntry {
pub fn has_changed(&self) -> bool {
self.previous.is_some_and(|previous| previous != self.value)
}
pub fn alias_value(&self, alias: &str) -> Option<u64> {
self.register.extract(self.value, alias)
}
pub fn display(&self, format: Format) -> String {
format_value(self.value, RegisterWidth::Qword, format)
}
pub fn width_views(&self) -> Vec<(String, u64, RegisterWidth)> {
let mut views = Vec::new();
for width in [
RegisterWidth::Qword,
RegisterWidth::Dword,
RegisterWidth::Word,
RegisterWidth::Byte,
] {
if let Some(alias) = self.register.alias(width) {
if let Some(value) = self.register.extract(self.value, alias) {
views.push((alias.to_ascii_uppercase(), value, width));
}
}
}
if let Some(high) = self.register.high_byte {
if let Some(value) = self.register.extract(self.value, high) {
views.push((high.to_ascii_uppercase(), value, RegisterWidth::Byte));
}
}
views
}
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct RegisterFile {
values: BTreeMap<String, u64>,
previous: BTreeMap<String, u64>,
}
impl RegisterFile {
pub fn new() -> Self {
Self::default()
}
pub fn update(&mut self, values: BTreeMap<String, u64>) {
self.previous = std::mem::take(&mut self.values);
self.values = values;
}
pub fn clear(&mut self) {
self.values.clear();
self.previous.clear();
}
pub fn is_empty(&self) -> bool {
self.values.is_empty()
}
pub fn value_of(&self, name: &str) -> Option<u64> {
let register = registers::lookup(name)?;
let full = self.values.get(register.name).copied()?;
register.extract(full, name.trim().trim_start_matches('%'))
}
pub fn entry(&self, name: &str) -> Option<RegisterEntry> {
let register = registers::lookup(name)?;
let value = self.values.get(register.name).copied()?;
Some(RegisterEntry {
register,
value,
previous: self.previous.get(register.name).copied(),
})
}
pub fn entries(&self) -> Vec<RegisterEntry> {
registers::all()
.into_iter()
.filter_map(|register| self.entry(register.name))
.collect()
}
pub fn changed(&self) -> Vec<RegisterEntry> {
self.entries()
.into_iter()
.filter(RegisterEntry::has_changed)
.collect()
}
pub fn rip(&self) -> Option<u64> {
self.value_of("rip")
}
pub fn rsp(&self) -> Option<u64> {
self.value_of("rsp")
}
pub fn rbp(&self) -> Option<u64> {
self.value_of("rbp")
}
pub fn flags(&self) -> Option<Flags> {
self.value_of("rflags")
.or_else(|| self.value_of("eflags"))
.map(Flags::from_bits)
}
pub fn previous_flags(&self) -> Option<Flags> {
self.previous.get("rflags").copied().map(Flags::from_bits)
}
}
impl crate::instruction::explain::RegisterValues for RegisterFile {
fn value_of(&self, name: &str) -> Option<u64> {
RegisterFile::value_of(self, name)
}
}
pub fn parse_register_values(names: &Value, values: &Value) -> BTreeMap<String, u64> {
let mut table = BTreeMap::new();
let (Some(names), Some(values)) = (names.as_list(), values.as_list()) else {
return table;
};
let mut widest: BTreeMap<&'static str, (RegisterWidth, u64)> = BTreeMap::new();
for entry in values {
let Some(number) = entry.get_int("number") else {
continue;
};
let Ok(index) = usize::try_from(number) else {
continue;
};
let Some(name) = names.get(index).and_then(Value::as_str) else {
continue;
};
let Some(register) = registers::lookup(name) else {
continue;
};
let lowered = name.trim().to_ascii_lowercase();
let Some(width) = register.width_of(&lowered) else {
continue;
};
let Some(raw) = entry.get_str("value") else {
continue;
};
let Some(value) = crate::debugger::mi::parse_address(raw) else {
continue;
};
widest
.entry(register.name)
.and_modify(|held| {
if width > held.0 {
*held = (width, value);
}
})
.or_insert((width, value));
}
for (name, (_, value)) in widest {
table.insert(name.to_owned(), value);
}
table
}
#[cfg(test)]
mod tests {
use super::*;
fn file_with(pairs: &[(&str, u64)]) -> RegisterFile {
let mut file = RegisterFile::new();
file.update(
pairs
.iter()
.map(|(name, value)| ((*name).to_owned(), *value))
.collect(),
);
file
}
#[test]
fn hexadecimal_is_padded_to_the_register_width() {
assert_eq!(
format_value(0x3c, RegisterWidth::Qword, Format::Hex),
"0x000000000000003c"
);
assert_eq!(format_value(0x3c, RegisterWidth::Byte, Format::Hex), "0x3c");
assert_eq!(
format_value(0x1234, RegisterWidth::Word, Format::Hex),
"0x1234"
);
}
#[test]
fn a_narrow_view_masks_the_wider_value() {
let value = 0x1122_3344_5566_7788u64;
assert_eq!(
format_value(value, RegisterWidth::Byte, Format::Hex),
"0x88"
);
assert_eq!(
format_value(value, RegisterWidth::Dword, Format::Hex),
"0x55667788"
);
}
#[test]
fn signed_interpretation_respects_the_width() {
assert_eq!(signed_value(0xff, RegisterWidth::Byte), -1);
assert_eq!(signed_value(0xff, RegisterWidth::Word), 255);
assert_eq!(signed_value(u64::MAX, RegisterWidth::Qword), -1);
assert_eq!(
signed_value(0x8000_0000, RegisterWidth::Dword),
-2_147_483_648
);
}
#[test]
fn decimal_and_signed_differ_for_negative_values() {
assert_eq!(
format_value(u64::MAX, RegisterWidth::Qword, Format::Decimal),
"18446744073709551615"
);
assert_eq!(
format_value(u64::MAX, RegisterWidth::Qword, Format::Signed),
"-1"
);
}
#[test]
fn binary_is_grouped_into_bytes() {
assert_eq!(
format_value(0b1010_0101, RegisterWidth::Byte, Format::Binary),
"10100101"
);
assert_eq!(
format_value(0xff00, RegisterWidth::Word, Format::Binary),
"11111111 00000000"
);
}
#[test]
fn ascii_shows_printable_bytes_and_dots_for_the_rest() {
assert_eq!(
format_value(0x4443_4241, RegisterWidth::Dword, Format::Ascii),
"ABCD"
);
assert_eq!(format_value(0x00, RegisterWidth::Byte, Format::Ascii), ".");
}
#[test]
fn formats_cycle_through_every_variant() {
let mut format = Format::Hex;
for _ in 0..Format::ALL.len() {
format = format.next();
}
assert_eq!(format, Format::Hex);
}
#[test]
fn values_are_read_back_through_any_alias() {
let file = file_with(&[("rax", 0x1122_3344_5566_7788)]);
assert_eq!(file.value_of("rax"), Some(0x1122_3344_5566_7788));
assert_eq!(file.value_of("eax"), Some(0x5566_7788));
assert_eq!(file.value_of("ax"), Some(0x7788));
assert_eq!(file.value_of("al"), Some(0x88));
assert_eq!(file.value_of("ah"), Some(0x77));
}
#[test]
fn an_unknown_register_reads_as_nothing() {
let file = file_with(&[("rax", 1)]);
assert_eq!(file.value_of("zmm0"), None);
assert_eq!(file.value_of("rbx"), None, "not read yet");
assert!(file.entry("nonsense").is_none());
}
#[test]
fn the_first_stop_reports_nothing_as_changed() {
let file = file_with(&[("rax", 1), ("rbx", 2)]);
assert!(file.changed().is_empty());
}
#[test]
fn only_registers_that_actually_changed_are_reported() {
let mut file = file_with(&[("rax", 1), ("rbx", 2)]);
file.update(
[("rax".to_owned(), 99u64), ("rbx".to_owned(), 2u64)]
.into_iter()
.collect(),
);
let changed: Vec<&str> = file.changed().iter().map(|e| e.register.name).collect();
assert_eq!(changed, ["rax"]);
}
#[test]
fn width_views_expose_the_alias_relationship() {
let file = file_with(&[("rax", 0x1122_3344_5566_7788)]);
let entry = file.entry("rax").expect("rax");
let views = entry.width_views();
let named: Vec<(&str, u64)> = views
.iter()
.map(|(name, value, _)| (name.as_str(), *value))
.collect();
assert_eq!(
named,
[
("RAX", 0x1122_3344_5566_7788),
("EAX", 0x5566_7788),
("AX", 0x7788),
("AL", 0x88),
("AH", 0x77),
]
);
}
#[test]
fn a_register_without_a_high_byte_has_no_high_byte_view() {
let file = file_with(&[("rsi", 0x1122)]);
let entry = file.entry("rsi").expect("rsi");
let views = entry.width_views();
let names: Vec<&str> = views.iter().map(|(name, _, _)| name.as_str()).collect();
assert_eq!(names, ["RSI", "ESI", "SI", "SIL"]);
}
#[test]
fn the_special_registers_are_exposed_directly() {
let file = file_with(&[
("rip", 0x40_00b0),
("rsp", 0x7fff_ffff_e000),
("rbp", 0x7fff_ffff_e100),
("rflags", 0x246),
]);
assert_eq!(file.rip(), Some(0x40_00b0));
assert_eq!(file.rsp(), Some(0x7fff_ffff_e000));
assert_eq!(file.rbp(), Some(0x7fff_ffff_e100));
let flags = file.flags().expect("flags");
assert_eq!(flags.summary(), "PF ZF IF");
}
#[test]
fn clearing_forgets_everything() {
let mut file = file_with(&[("rax", 1)]);
file.clear();
assert!(file.is_empty());
assert!(file.entries().is_empty());
}
#[test]
fn entries_are_returned_in_panel_order() {
let file = file_with(&[("rax", 1), ("rip", 2), ("r15", 3)]);
let names: Vec<&str> = file.entries().iter().map(|e| e.register.name).collect();
assert_eq!(names, ["rax", "r15", "rip"]);
}
#[test]
fn gdb_replies_are_correlated_by_index() {
let names = Value::List(vec![
Value::String("rax".to_owned()),
Value::String("rbx".to_owned()),
Value::String("rcx".to_owned()),
]);
let values = Value::List(vec![
Value::Tuple(vec![
("number".to_owned(), Value::String("2".to_owned())),
("value".to_owned(), Value::String("0xcccc".to_owned())),
]),
Value::Tuple(vec![
("number".to_owned(), Value::String("0".to_owned())),
("value".to_owned(), Value::String("0x3c".to_owned())),
]),
]);
let table = parse_register_values(&names, &values);
assert_eq!(table.get("rax"), Some(&0x3c));
assert_eq!(table.get("rcx"), Some(&0xcccc));
assert_eq!(table.get("rbx"), None, "no value was reported for rbx");
}
#[test]
fn narrow_pseudo_registers_do_not_overwrite_the_full_value() {
let names = Value::List(vec![
Value::String("rsp".to_owned()),
Value::String("esp".to_owned()),
]);
let values = Value::List(vec![
Value::Tuple(vec![
("number".to_owned(), Value::String("0".to_owned())),
(
"value".to_owned(),
Value::String("0x7fffffffdf30".to_owned()),
),
]),
Value::Tuple(vec![
("number".to_owned(), Value::String("1".to_owned())),
("value".to_owned(), Value::String("0xffffdf30".to_owned())),
]),
]);
let table = parse_register_values(&names, &values);
assert_eq!(
table.get("rsp"),
Some(&0x7fff_ffff_df30),
"the 64-bit value must survive the 32-bit alias"
);
assert_eq!(table.len(), 1);
}
#[test]
fn the_order_the_aliases_arrive_in_does_not_matter() {
let names = Value::List(vec![
Value::String("esp".to_owned()),
Value::String("rsp".to_owned()),
]);
let values = Value::List(vec![
Value::Tuple(vec![
("number".to_owned(), Value::String("0".to_owned())),
("value".to_owned(), Value::String("0xffffdf30".to_owned())),
]),
Value::Tuple(vec![
("number".to_owned(), Value::String("1".to_owned())),
(
"value".to_owned(),
Value::String("0x7fffffffdf30".to_owned()),
),
]),
]);
assert_eq!(
parse_register_values(&names, &values).get("rsp"),
Some(&0x7fff_ffff_df30)
);
}
#[test]
fn an_alias_is_used_when_it_is_the_only_name_reported() {
let names = Value::List(vec![Value::String("eflags".to_owned())]);
let values = Value::List(vec![Value::Tuple(vec![
("number".to_owned(), Value::String("0".to_owned())),
("value".to_owned(), Value::String("0x246".to_owned())),
])]);
let table = parse_register_values(&names, &values);
assert_eq!(table.get("rflags"), Some(&0x246));
let mut file = RegisterFile::new();
file.update(table);
assert_eq!(
file.flags().map(|flags| flags.summary()),
Some("PF ZF IF".to_owned())
);
}
#[test]
fn the_narrow_view_is_still_derivable_from_the_full_value() {
let mut file = RegisterFile::new();
file.update(
[("rsp".to_owned(), 0x7fff_ffff_df30u64)]
.into_iter()
.collect(),
);
assert_eq!(file.value_of("rsp"), Some(0x7fff_ffff_df30));
assert_eq!(file.value_of("esp"), Some(0xffff_df30));
}
#[test]
fn unmodelled_registers_are_skipped_rather_than_stored() {
let names = Value::List(vec![
Value::String("rax".to_owned()),
Value::String("ymm0".to_owned()),
]);
let values = Value::List(vec![
Value::Tuple(vec![
("number".to_owned(), Value::String("0".to_owned())),
("value".to_owned(), Value::String("0x1".to_owned())),
]),
Value::Tuple(vec![
("number".to_owned(), Value::String("1".to_owned())),
(
"value".to_owned(),
Value::String("{v8_int32 = {0,0}}".to_owned()),
),
]),
]);
let table = parse_register_values(&names, &values);
assert_eq!(table.len(), 1);
assert_eq!(table.get("rax"), Some(&1));
}
#[test]
fn malformed_gdb_replies_produce_an_empty_table_rather_than_a_panic() {
let empty = Value::String("not a list".to_owned());
assert!(parse_register_values(&empty, &empty).is_empty());
let names = Value::List(vec![Value::String("rax".to_owned())]);
let bad_values = Value::List(vec![Value::Tuple(vec![(
"number".to_owned(),
Value::String("99".to_owned()),
)])]);
assert!(parse_register_values(&names, &bad_values).is_empty());
}
}