use std::fmt;
use super::registers::RegisterFile;
use crate::instruction::registers;
pub const BYTES_PER_ROW: usize = 16;
#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
pub enum AddressError {
#[error("enter an address, for example 0x4000b0 or rsp-0x20")]
Empty,
#[error("'{token}' is not a number or a register name")]
UnknownToken {
token: String,
},
#[error("'{token}' is not a valid number")]
BadNumber {
token: String,
},
#[error("the value of {register} is not known; the program must be paused")]
RegisterUnavailable {
register: String,
},
#[error("unbalanced parentheses")]
UnbalancedParentheses,
#[error("the expression is incomplete")]
Incomplete,
#[error("unexpected '{token}' after the expression")]
TrailingInput {
token: String,
},
}
pub fn evaluate_address(text: &str, registers: &RegisterFile) -> Result<u64, AddressError> {
let tokens = tokenize(text)?;
if tokens.is_empty() {
return Err(AddressError::Empty);
}
let mut parser = ExpressionParser {
tokens: &tokens,
position: 0,
registers,
};
let value = parser.expression()?;
if parser.position < tokens.len() {
return Err(AddressError::TrailingInput {
token: parser.tokens[parser.position].text().to_owned(),
});
}
Ok(value)
}
#[derive(Debug, Clone, PartialEq, Eq)]
enum Token {
Number(u64),
Register(String),
Plus,
Minus,
Open,
Close,
}
impl Token {
fn text(&self) -> &str {
match self {
Token::Number(_) => "number",
Token::Register(name) => name,
Token::Plus => "+",
Token::Minus => "-",
Token::Open => "(",
Token::Close => ")",
}
}
}
fn tokenize(text: &str) -> Result<Vec<Token>, AddressError> {
let mut tokens = Vec::new();
let chars: Vec<char> = text.trim().chars().collect();
let mut index = 0usize;
while index < chars.len() {
let ch = chars[index];
match ch {
' ' | '\t' => index += 1,
'+' => {
tokens.push(Token::Plus);
index += 1;
}
'-' => {
tokens.push(Token::Minus);
index += 1;
}
'(' => {
tokens.push(Token::Open);
index += 1;
}
')' => {
tokens.push(Token::Close);
index += 1;
}
'$' | '%' => index += 1, _ if ch.is_ascii_alphanumeric() || ch == '_' => {
let start = index;
while index < chars.len()
&& (chars[index].is_ascii_alphanumeric() || chars[index] == '_')
{
index += 1;
}
let word: String = chars[start..index].iter().collect();
tokens.push(classify(&word)?);
}
other => {
return Err(AddressError::UnknownToken {
token: other.to_string(),
})
}
}
}
Ok(tokens)
}
fn classify(word: &str) -> Result<Token, AddressError> {
let lowered = word.to_ascii_lowercase();
if let Some(hex) = lowered.strip_prefix("0x") {
return u64::from_str_radix(hex, 16)
.map(Token::Number)
.map_err(|_| AddressError::BadNumber {
token: word.to_owned(),
});
}
if let Some(binary) = lowered.strip_prefix("0b") {
return u64::from_str_radix(binary, 2)
.map(Token::Number)
.map_err(|_| AddressError::BadNumber {
token: word.to_owned(),
});
}
if registers::is_register(&lowered) {
return Ok(Token::Register(lowered));
}
if lowered.chars().all(|ch| ch.is_ascii_digit()) {
return lowered
.parse::<u64>()
.map(Token::Number)
.map_err(|_| AddressError::BadNumber {
token: word.to_owned(),
});
}
if lowered.chars().all(|ch| ch.is_ascii_hexdigit()) {
return u64::from_str_radix(&lowered, 16)
.map(Token::Number)
.map_err(|_| AddressError::BadNumber {
token: word.to_owned(),
});
}
Err(AddressError::UnknownToken {
token: word.to_owned(),
})
}
struct ExpressionParser<'a> {
tokens: &'a [Token],
position: usize,
registers: &'a RegisterFile,
}
impl ExpressionParser<'_> {
fn peek(&self) -> Option<&Token> {
self.tokens.get(self.position)
}
fn expression(&mut self) -> Result<u64, AddressError> {
let mut value = self.term()?;
loop {
match self.peek() {
Some(Token::Plus) => {
self.position += 1;
value = value.wrapping_add(self.term()?);
}
Some(Token::Minus) => {
self.position += 1;
value = value.wrapping_sub(self.term()?);
}
_ => break,
}
}
Ok(value)
}
fn term(&mut self) -> Result<u64, AddressError> {
match self.peek().cloned() {
Some(Token::Number(value)) => {
self.position += 1;
Ok(value)
}
Some(Token::Register(name)) => {
self.position += 1;
self.registers
.value_of(&name)
.ok_or(AddressError::RegisterUnavailable {
register: name.to_ascii_uppercase(),
})
}
Some(Token::Minus) => {
self.position += 1;
Ok(0u64.wrapping_sub(self.term()?))
}
Some(Token::Open) => {
self.position += 1;
let value = self.expression()?;
match self.peek() {
Some(Token::Close) => {
self.position += 1;
Ok(value)
}
_ => Err(AddressError::UnbalancedParentheses),
}
}
Some(Token::Close) => Err(AddressError::UnbalancedParentheses),
Some(Token::Plus) => {
self.position += 1;
self.term()
}
None => Err(AddressError::Incomplete),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub struct MemoryBlock {
pub address: u64,
pub bytes: Vec<u8>,
}
impl MemoryBlock {
pub fn new(address: u64, bytes: Vec<u8>) -> Self {
Self { address, bytes }
}
pub fn is_empty(&self) -> bool {
self.bytes.is_empty()
}
pub fn len(&self) -> usize {
self.bytes.len()
}
pub fn end_address(&self) -> u64 {
self.address.wrapping_add(self.bytes.len() as u64)
}
pub fn contains(&self, address: u64) -> bool {
address >= self.address && address < self.end_address()
}
pub fn byte_at(&self, address: u64) -> Option<u8> {
if !self.contains(address) {
return None;
}
let offset = usize::try_from(address - self.address).ok()?;
self.bytes.get(offset).copied()
}
pub fn read_integer(&self, address: u64, size: usize) -> Option<u64> {
if size == 0 || size > 8 {
return None;
}
let mut value = 0u64;
for index in 0..size {
let byte = self.byte_at(address.wrapping_add(index as u64))?;
value |= u64::from(byte) << (index * 8);
}
Some(value)
}
pub fn rows(&self) -> Vec<MemoryRow> {
self.bytes
.chunks(BYTES_PER_ROW)
.enumerate()
.map(|(index, chunk)| MemoryRow {
address: self.address.wrapping_add((index * BYTES_PER_ROW) as u64),
bytes: chunk.to_vec(),
})
.collect()
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct MemoryRow {
pub address: u64,
pub bytes: Vec<u8>,
}
impl MemoryRow {
pub fn hex(&self) -> String {
let mut parts: Vec<String> = self
.bytes
.iter()
.map(|byte| format!("{byte:02x}"))
.collect();
while parts.len() < BYTES_PER_ROW {
parts.push(" ".to_owned());
}
parts.join(" ")
}
pub fn ascii(&self) -> String {
self.bytes
.iter()
.map(|byte| {
if byte.is_ascii_graphic() || *byte == b' ' {
*byte as char
} else {
'.'
}
})
.collect()
}
pub fn address_text(&self) -> String {
format!("{:016x}", self.address)
}
}
impl fmt::Display for MemoryRow {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(
f,
"{} {} |{}|",
self.address_text(),
self.hex(),
self.ascii()
)
}
}
pub fn parse_memory_reply(value: &crate::debugger::mi::Value) -> Option<MemoryBlock> {
let entries = value.as_list()?;
let first = entries.first()?;
let address = first.get_address("begin")?;
let contents = first.get_str("contents")?;
if contents.len() % 2 != 0 {
return None;
}
let mut bytes = Vec::with_capacity(contents.len() / 2);
for pair in contents.as_bytes().chunks(2) {
let text = std::str::from_utf8(pair).ok()?;
bytes.push(u8::from_str_radix(text, 16).ok()?);
}
Some(MemoryBlock::new(address, bytes))
}
#[cfg(test)]
mod tests {
use super::*;
use std::collections::BTreeMap;
fn registers_with(pairs: &[(&str, u64)]) -> RegisterFile {
let mut file = RegisterFile::new();
let map: BTreeMap<String, u64> = pairs
.iter()
.map(|(name, value)| ((*name).to_owned(), *value))
.collect();
file.update(map);
file
}
fn empty() -> RegisterFile {
RegisterFile::new()
}
#[test]
fn a_hexadecimal_address_is_accepted() {
assert_eq!(evaluate_address("0x4000b0", &empty()), Ok(0x0040_00b0));
assert_eq!(evaluate_address(" 0X4000B0 ", &empty()), Ok(0x0040_00b0));
}
#[test]
fn a_bare_hexadecimal_address_is_accepted() {
assert_eq!(evaluate_address("4000b0", &empty()), Ok(0x0040_00b0));
}
#[test]
fn a_decimal_address_is_accepted() {
assert_eq!(evaluate_address("4194480", &empty()), Ok(4_194_480));
}
#[test]
fn a_binary_literal_is_accepted() {
assert_eq!(evaluate_address("0b1010", &empty()), Ok(10));
}
#[test]
fn a_register_name_resolves_to_its_value() {
let registers = registers_with(&[("rsp", 0x7fff_ffff_e000)]);
assert_eq!(evaluate_address("rsp", ®isters), Ok(0x7fff_ffff_e000));
assert_eq!(evaluate_address("RSP", ®isters), Ok(0x7fff_ffff_e000));
assert_eq!(evaluate_address("$rsp", ®isters), Ok(0x7fff_ffff_e000));
assert_eq!(evaluate_address("%rsp", ®isters), Ok(0x7fff_ffff_e000));
}
#[test]
fn arithmetic_on_a_register_works() {
let registers = registers_with(&[("rsp", 0x1000), ("rbp", 0x2000)]);
assert_eq!(evaluate_address("rsp+8", ®isters), Ok(0x1008));
assert_eq!(evaluate_address("rsp - 0x20", ®isters), Ok(0x0fe0));
assert_eq!(evaluate_address("rbp - rsp", ®isters), Ok(0x1000));
assert_eq!(evaluate_address("rsp + 8 - 4", ®isters), Ok(0x1004));
}
#[test]
fn parentheses_group_correctly() {
let registers = registers_with(&[("rsp", 0x1000)]);
assert_eq!(evaluate_address("(rsp + 8) - 4", ®isters), Ok(0x1004));
assert_eq!(evaluate_address("rsp - (8 - 4)", ®isters), Ok(0x0ffc));
}
#[test]
fn a_narrow_register_alias_resolves() {
let registers = registers_with(&[("rax", 0x1122_3344)]);
assert_eq!(evaluate_address("eax", ®isters), Ok(0x1122_3344));
assert_eq!(evaluate_address("al", ®isters), Ok(0x44));
}
#[test]
fn address_arithmetic_wraps_rather_than_overflowing() {
assert_eq!(evaluate_address("0 - 1", &empty()), Ok(u64::MAX));
assert_eq!(evaluate_address("-8", &empty()), Ok(u64::MAX - 7));
}
#[test]
fn an_empty_expression_is_reported_not_guessed() {
assert_eq!(evaluate_address("", &empty()), Err(AddressError::Empty));
assert_eq!(evaluate_address(" ", &empty()), Err(AddressError::Empty));
}
#[test]
fn an_unknown_name_is_reported() {
let error = evaluate_address("nonsense", &empty()).expect_err("must fail");
assert!(matches!(error, AddressError::UnknownToken { .. }));
assert!(error.to_string().contains("nonsense"));
}
#[test]
fn a_register_with_no_value_is_reported_clearly() {
let error = evaluate_address("rsp", &empty()).expect_err("must fail");
assert!(matches!(error, AddressError::RegisterUnavailable { .. }));
assert!(error.to_string().contains("paused"));
}
#[test]
fn malformed_input_never_panics() {
let registers = registers_with(&[("rsp", 0x1000)]);
let inputs = [
"))))",
"((((",
"(rsp",
"rsp)",
"0xzzzz",
"0x",
"+",
"-",
"rsp +",
"rsp + + +",
"* & ^",
"0x1 0x2",
"rsp rsp",
"!!!",
"\u{1F600}",
&"9".repeat(500),
&"(".repeat(200),
];
for input in inputs {
let _ = evaluate_address(input, ®isters);
}
}
#[test]
fn specific_malformed_inputs_give_specific_errors() {
let registers = registers_with(&[("rsp", 0x1000)]);
assert_eq!(
evaluate_address("(rsp", ®isters),
Err(AddressError::UnbalancedParentheses)
);
assert_eq!(
evaluate_address("rsp +", ®isters),
Err(AddressError::Incomplete)
);
assert!(matches!(
evaluate_address("0x1 0x2", ®isters),
Err(AddressError::TrailingInput { .. })
));
assert!(matches!(
evaluate_address("0xzzzz", ®isters),
Err(AddressError::BadNumber { .. })
));
assert!(matches!(
evaluate_address("nonsense", ®isters),
Err(AddressError::UnknownToken { .. })
));
}
#[test]
fn an_enormous_number_is_reported_rather_than_wrapping_silently() {
let error =
evaluate_address(&format!("0x{}", "f".repeat(40)), &empty()).expect_err("must fail");
assert!(matches!(error, AddressError::BadNumber { .. }));
}
#[test]
fn a_hex_dump_row_renders_all_three_columns() {
let block = MemoryBlock::new(0x4000, b"Hello, world!\n\0\0".to_vec());
let rows = block.rows();
assert_eq!(rows.len(), 1);
let row = &rows[0];
assert_eq!(row.address_text(), "0000000000004000");
assert!(row.hex().starts_with("48 65 6c 6c 6f"));
assert_eq!(row.ascii(), "Hello, world!...");
}
#[test]
fn a_short_final_row_stays_aligned() {
let block = MemoryBlock::new(0x4000, vec![0xaa, 0xbb, 0xcc]);
let row = &block.rows()[0];
let full = MemoryRow {
address: 0,
bytes: vec![0; BYTES_PER_ROW],
};
assert_eq!(row.hex().len(), full.hex().len());
assert_eq!(row.ascii(), "...");
}
#[test]
fn rows_are_split_at_the_row_width() {
let block = MemoryBlock::new(0x4000, vec![0; 40]);
let rows = block.rows();
assert_eq!(rows.len(), 3);
assert_eq!(rows[0].address, 0x4000);
assert_eq!(rows[1].address, 0x4010);
assert_eq!(rows[2].bytes.len(), 8);
}
#[test]
fn integers_are_read_little_endian() {
let block = MemoryBlock::new(0x4000, vec![0x78, 0x56, 0x34, 0x12, 0, 0, 0, 0]);
assert_eq!(block.read_integer(0x4000, 1), Some(0x78));
assert_eq!(block.read_integer(0x4000, 2), Some(0x5678));
assert_eq!(block.read_integer(0x4000, 4), Some(0x1234_5678));
assert_eq!(block.read_integer(0x4000, 8), Some(0x0000_0000_1234_5678));
}
#[test]
fn reading_past_the_block_returns_nothing_rather_than_padding() {
let block = MemoryBlock::new(0x4000, vec![1, 2, 3]);
assert_eq!(block.read_integer(0x4000, 4), None);
assert_eq!(block.read_integer(0x5000, 1), None);
assert_eq!(block.byte_at(0x4003), None);
assert_eq!(block.read_integer(0x4000, 0), None);
assert_eq!(block.read_integer(0x4000, 9), None);
}
#[test]
fn an_empty_block_reports_itself_as_empty() {
let block = MemoryBlock::default();
assert!(block.is_empty());
assert_eq!(block.len(), 0);
assert!(block.rows().is_empty());
assert!(!block.contains(0));
}
#[test]
fn a_gdb_memory_reply_is_decoded() {
use crate::debugger::mi::Value;
let value = Value::List(vec![Value::Tuple(vec![
("begin".to_owned(), Value::String("0x4000b0".to_owned())),
("offset".to_owned(), Value::String("0x0".to_owned())),
("end".to_owned(), Value::String("0x4000b4".to_owned())),
("contents".to_owned(), Value::String("48c7c001".to_owned())),
])]);
let block = parse_memory_reply(&value).expect("decode");
assert_eq!(block.address, 0x0040_00b0);
assert_eq!(block.bytes, [0x48, 0xc7, 0xc0, 0x01]);
}
#[test]
fn a_malformed_memory_reply_is_rejected_rather_than_half_decoded() {
use crate::debugger::mi::Value;
for contents in ["48c7c", "zzzz", ""] {
let value = Value::List(vec![Value::Tuple(vec![
("begin".to_owned(), Value::String("0x1000".to_owned())),
("contents".to_owned(), Value::String(contents.to_owned())),
])]);
let decoded = parse_memory_reply(&value);
if contents.is_empty() {
assert_eq!(decoded.map(|block| block.len()), Some(0));
} else {
assert!(decoded.is_none(), "{contents:?} should not decode");
}
}
assert!(parse_memory_reply(&Value::String("x".to_owned())).is_none());
assert!(parse_memory_reply(&Value::List(Vec::new())).is_none());
}
}