use core::fmt;
use core::fmt::Write as _;
use crate::address::PcRead;
use crate::tokens::{Hex, OperandIndex, TokenKind, TokenSink};
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Form {
Hex,
Signed,
Decimal,
}
pub struct SignedHex {
pub value: i64,
pub negative: bool,
}
impl fmt::Display for SignedHex {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self.negative || self.value < 0 {
true => write!(f, "-0x{:x}", self.value.unsigned_abs()),
false => write!(f, "0x{:x}", self.value),
}
}
}
pub fn float_from_bits(bits: u64, width: u32) -> f64 {
match width {
16 => {
let half = bits as u16;
let sign = if half >> 15 == 1 { -1.0 } else { 1.0 };
let exponent = (half >> 10) & 0x1f;
let fraction = f64::from(half & 0x3ff);
match exponent {
0 => sign * fraction * 2f64.powi(-24),
0x1f if fraction == 0.0 => sign * f64::INFINITY,
0x1f => f64::NAN,
_ => sign * (1.0 + fraction / 1024.0) * 2f64.powi(i32::from(exponent) - 15),
}
}
32 => f64::from(f32::from_bits(bits as u32)),
_ => f64::from_bits(bits),
}
}
pub struct Float<T>(pub T);
impl<T: fmt::Display> fmt::Display for Float<T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let mut held = Held::default();
if write!(held, "{}", self.0).is_ok() {
return put(f, held.written());
}
put(f, &format!("{}", self.0))
}
}
fn put(f: &mut fmt::Formatter<'_>, written: &str) -> fmt::Result {
match written.contains(['.', 'e', 'E']) {
true => f.write_str(written),
false => write!(f, "{written}.0"),
}
}
struct Held {
bytes: [u8; 64],
len: usize,
}
impl Default for Held {
fn default() -> Self {
Held {
bytes: [0; 64],
len: 0,
}
}
}
impl Held {
fn written(&self) -> &str {
core::str::from_utf8(&self.bytes[..self.len]).unwrap_or("")
}
}
impl fmt::Write for Held {
fn write_str(&mut self, s: &str) -> fmt::Result {
let end = self.len.checked_add(s.len()).ok_or(fmt::Error)?;
let room = self.bytes.get_mut(self.len..end).ok_or(fmt::Error)?;
room.copy_from_slice(s.as_bytes());
self.len = end;
Ok(())
}
}
pub struct Writer<'a> {
sink: &'a mut dyn TokenSink,
name: &'static str,
address: u64,
bits: u32,
operand: OperandIndex,
}
impl<'a> Writer<'a> {
pub fn new(sink: &'a mut dyn TokenSink, name: &'static str, address: u64, bits: u32) -> Self {
Writer {
sink,
name,
address,
bits,
operand: None,
}
}
#[inline]
pub fn operand(&mut self, operand: OperandIndex) {
self.operand = operand;
}
#[inline(never)]
pub fn name(&mut self) -> fmt::Result {
self.sink.text(TokenKind::Mnemonic, self.operand, self.name)
}
#[inline(never)]
pub fn mnemonic(&mut self, text: &str) -> fmt::Result {
self.sink.text(TokenKind::Mnemonic, self.operand, text)
}
#[inline(never)]
pub fn text(&mut self, text: &str) -> fmt::Result {
self.sink.text(TokenKind::Text, self.operand, text)
}
#[inline(never)]
pub fn separator(&mut self) -> fmt::Result {
self.operand = None;
self.sink.text(TokenKind::Separator, None, ", ")
}
#[inline(never)]
pub fn inner_separator(&mut self) -> fmt::Result {
self.sink.text(TokenKind::Text, self.operand, ", ")
}
#[inline(never)]
pub fn bracket(&mut self, text: &str) -> fmt::Result {
self.sink.text(TokenKind::Bracket, self.operand, text)
}
#[inline(never)]
pub fn number(&mut self, value: i64, form: Form) -> fmt::Result {
match form {
Form::Hex => {
self.sink.text(TokenKind::Text, self.operand, "#")?;
self.sink.value(
TokenKind::Immediate(value),
self.operand,
&Hex(value as u64),
)
}
Form::Signed => self.signed(value, false),
Form::Decimal => {
self.sink
.value(TokenKind::Integer(value as u64), self.operand, &value)
}
}
}
#[inline(never)]
pub fn float(&mut self, value: impl fmt::Display) -> fmt::Result {
self.sink.text(TokenKind::Text, self.operand, "#")?;
self.sink
.value(TokenKind::Float, self.operand, &Float(value))
}
#[inline(never)]
pub fn register(&mut self, reg: &dyn fmt::Display) -> fmt::Result {
self.sink.value(TokenKind::Register, self.operand, reg)
}
#[inline(never)]
pub fn some_register<R: fmt::Display>(&mut self, reg: Option<R>) -> fmt::Result {
self.register(®.ok_or(fmt::Error)?)
}
#[inline(never)]
pub fn some_number(&mut self, value: Option<i64>, form: Form) -> fmt::Result {
self.number(value.ok_or(fmt::Error)?, form)
}
#[inline(never)]
pub fn symbol(&mut self, name: &dyn fmt::Display) -> fmt::Result {
self.sink.value(TokenKind::Symbol, self.operand, name)
}
#[inline(never)]
pub fn token(&mut self, kind: TokenKind, text: &str) -> fmt::Result {
self.sink.text(kind, self.operand, text)
}
#[inline(never)]
pub fn valued(&mut self, kind: TokenKind, value: &dyn fmt::Display) -> fmt::Result {
self.sink.value(kind, self.operand, value)
}
#[inline(never)]
pub fn signed(&mut self, value: i64, negative: bool) -> fmt::Result {
self.sink.text(TokenKind::Text, self.operand, "#")?;
self.sink.value(
TokenKind::Immediate(value),
self.operand,
&SignedHex { value, negative },
)
}
#[inline(never)]
pub fn address(&mut self, target: u64) -> fmt::Result {
self.sink
.value(TokenKind::Address(target), self.operand, &Hex(target))
}
#[inline(never)]
pub fn label(&mut self, offset: i64, pc: PcRead) -> fmt::Result {
self.address(pc.target(self.address, offset, self.bits))
}
}
#[macro_export]
macro_rules! rendering_writer {
($(#[$doc:meta])* $name:ident, $bits:literal) => {
$(#[$doc])*
pub struct $name<'a> {
out: $crate::write::Writer<'a>,
}
impl<'a> ::core::ops::Deref for $name<'a> {
type Target = $crate::write::Writer<'a>;
fn deref(&self) -> &Self::Target {
&self.out
}
}
impl<'a> ::core::ops::DerefMut for $name<'a> {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.out
}
}
impl<'a> $name<'a> {
pub fn new(
sink: &'a mut dyn $crate::tokens::TokenSink,
name: &'static str,
address: u64,
) -> Self {
$name {
out: $crate::write::Writer::new(sink, name, address, $bits),
}
}
}
};
}
#[cfg(test)]
mod tests {
use super::{Form, Writer, float_from_bits};
use crate::address::PcRead;
use crate::tokens::{Token, TokenKind};
use core::fmt;
fn written(
at: u64,
bits: u32,
write: impl FnOnce(&mut Writer) -> fmt::Result,
) -> (Vec<Token>, String) {
let mut sink: Vec<Token> = Vec::new();
let mut writer = Writer::new(&mut sink, "b", at, bits);
write(&mut writer).expect("a Vec sink cannot fail");
let text = sink.iter().map(|t| t.text.as_str()).collect();
(sink, text)
}
#[test]
fn a_decimal_is_written_bare() {
let (tokens, text) = written(0, 64, |w| w.number(3, Form::Decimal));
assert_eq!(text, "3");
assert_eq!(tokens.len(), 1);
assert_eq!(tokens[0].kind, TokenKind::Integer(3));
}
#[test]
fn a_subtracted_zero_keeps_its_sign() {
assert_eq!(written(0, 64, |w| w.signed(0, true)).1, "#-0x0");
assert_eq!(written(0, 64, |w| w.signed(0, false)).1, "#0x0");
assert_eq!(written(0, 64, |w| w.signed(16, true)).1, "#-0x10");
}
#[test]
fn a_signed_form_writes_the_value_it_has() {
assert_eq!(written(0, 64, |w| w.number(-16, Form::Signed)).1, "#-0x10");
}
#[test]
fn a_target_wraps_within_the_instruction_set_s_reach() {
let pc = PcRead { ahead: 0, align: 1 };
assert_eq!(
written(0xffff_fffc, 32, |w| w.label(0x10, pc)).1,
"0xc",
"a 32-bit target past the end wraps to the bottom"
);
assert_eq!(written(0x10, 32, |w| w.label(-0x20, pc)).1, "0xfffffff0");
}
#[test]
fn each_piece_carries_its_kind() {
let (tokens, text) = written(0, 64, |w| {
w.name()?;
w.text("\t")?;
w.register(&"x0")?;
w.separator()?;
w.operand(Some(1));
w.bracket("[")?;
w.register(&"x1")?;
w.inner_separator()?;
w.symbol(&"lsl")?;
w.bracket("]")
});
assert_eq!(text, "b\tx0, [x1, lsl]");
let kinds: Vec<(TokenKind, Option<u8>)> =
tokens.iter().map(|t| (t.kind, t.operand)).collect();
assert_eq!(
kinds,
vec![
(TokenKind::Mnemonic, None),
(TokenKind::Text, None),
(TokenKind::Register, None),
(TokenKind::Separator, None),
(TokenKind::Bracket, Some(1)),
(TokenKind::Register, Some(1)),
(TokenKind::Text, Some(1)),
(TokenKind::Symbol, Some(1)),
(TokenKind::Bracket, Some(1)),
]
);
}
#[test]
fn denormal() {
assert_eq!(float_from_bits(0x0001, 16), 2f64.powi(-24));
assert_eq!(float_from_bits(0x0000_0001, 32), 2f64.powi(-149));
assert_eq!(
float_from_bits(0x0000_0000_0000_0001, 64),
f64::from_bits(1)
);
}
#[test]
fn infinity() {
assert_eq!(float_from_bits(0x7c00, 16), f64::INFINITY);
assert_eq!(float_from_bits(0xfc00, 16), f64::NEG_INFINITY);
assert_eq!(float_from_bits(0x7f80_0000, 32), f64::INFINITY);
assert_eq!(float_from_bits(0x7ff0_0000_0000_0000, 64), f64::INFINITY);
}
#[test]
fn nan() {
assert!(float_from_bits(0x7e00, 16).is_nan());
assert!(float_from_bits(0x7fc0_0000, 32).is_nan());
assert!(float_from_bits(0x7ff8_0000_0000_0000, 64).is_nan());
}
}