diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/long_mode/display.rs | 160 |
1 files changed, 153 insertions, 7 deletions
diff --git a/src/long_mode/display.rs b/src/long_mode/display.rs index b9c9f79..e3f5b0a 100644 --- a/src/long_mode/display.rs +++ b/src/long_mode/display.rs @@ -927,49 +927,195 @@ struct ColorizingOperandVisitor<'a, T, Y> { f: &'a mut T, } +use core::mem::MaybeUninit; + impl <T: DisplaySink, Y: YaxColors> crate::long_mode::OperandVisitor for ColorizingOperandVisitor<'_, T, Y> { type Ok = (); type Error = core::fmt::Error; fn visit_u8(&mut self, imm: u8) -> Result<Self::Ok, Self::Error> { self.f.span_enter(TokenType::Immediate); - write!(self.f, "{}", u8_hex(imm))?; + self.f.write_fixed_size("0x")?; + let mut buf = [MaybeUninit::<u8>::uninit(); 2]; + let mut curr = buf.len(); + let mut v = imm; + loop { + let digit = v % 16; + let c = c_to_hex(digit as u8); + curr -= 1; + buf[curr].write(c); + v = v / 16; + if v == 0 { + break; + } + } + let buf = &buf[curr..]; + let s: &str = unsafe { + core::mem::transmute::<&[MaybeUninit<u8>], &str>(buf) + }; + self.f.write_fixed_size(s)?; self.f.span_end(TokenType::Immediate); Ok(()) } fn visit_i8(&mut self, imm: i8) -> Result<Self::Ok, Self::Error> { self.f.span_enter(TokenType::Immediate); - write!(self.f, "{}", signed_i8_hex(imm))?; + let mut v = imm as u8; + if imm < 0 { + self.f.write_char('-')?; + v = -imm as u8; + } + self.f.write_fixed_size("0x")?; + let mut buf = [core::mem::MaybeUninit::<u8>::uninit(); 2]; + let mut curr = buf.len(); + loop { + let digit = v % 16; + let c = c_to_hex(digit as u8); + curr -= 1; + buf[curr].write(c); + v = v / 16; + if v == 0 { + break; + } + } + let buf = &buf[curr..]; + let s = unsafe { + core::mem::transmute::<&[core::mem::MaybeUninit<u8>], &str>(buf) + }; + + // not actually fixed size, but this should optimize right i hope.. + self.f.write_fixed_size(s)?; self.f.span_end(TokenType::Immediate); Ok(()) } fn visit_u16(&mut self, imm: u16) -> Result<Self::Ok, Self::Error> { self.f.span_enter(TokenType::Immediate); - write!(self.f, "{}", u16_hex(imm))?; + self.f.write_fixed_size("0x")?; + let mut buf = [MaybeUninit::<u8>::uninit(); 4]; + let mut curr = buf.len(); + let mut v = imm; + loop { + let digit = v % 16; + let c = c_to_hex(digit as u8); + curr -= 1; + buf[curr].write(c); + v = v / 16; + if v == 0 { + break; + } + } + let buf = &buf[curr..]; + let s: &str = unsafe { + core::mem::transmute::<&[MaybeUninit<u8>], &str>(buf) + }; + self.f.write_fixed_size(s)?; self.f.span_end(TokenType::Immediate); Ok(()) } fn visit_i16(&mut self, imm: i16) -> Result<Self::Ok, Self::Error> { self.f.span_enter(TokenType::Immediate); - write!(self.f, "{}", signed_i16_hex(imm))?; + let mut v = imm as u16; + if imm < 0 { + self.f.write_char('-')?; + v = -imm as u16; + } + self.f.write_fixed_size("0x")?; + let mut buf = [core::mem::MaybeUninit::<u8>::uninit(); 4]; + let mut curr = buf.len(); + loop { + let digit = v % 16; + let c = c_to_hex(digit as u8); + curr -= 1; + buf[curr].write(c); + v = v / 16; + if v == 0 { + break; + } + } + let buf = &buf[curr..]; + let s = unsafe { + core::mem::transmute::<&[core::mem::MaybeUninit<u8>], &str>(buf) + }; + + // not actually fixed size, but this should optimize right i hope.. + self.f.write_fixed_size(s)?; self.f.span_end(TokenType::Immediate); Ok(()) } fn visit_u32(&mut self, imm: u32) -> Result<Self::Ok, Self::Error> { self.f.span_enter(TokenType::Immediate); - write!(self.f, "{}", u32_hex(imm))?; + self.f.write_fixed_size("0x")?; + let mut buf = [MaybeUninit::<u8>::uninit(); 8]; + let mut curr = buf.len(); + let mut v = imm; + loop { + let digit = v % 16; + let c = c_to_hex(digit as u8); + curr -= 1; + buf[curr].write(c); + v = v / 16; + if v == 0 { + break; + } + } + let buf = &buf[curr..]; + let s: &str = unsafe { + core::mem::transmute::<&[MaybeUninit<u8>], &str>(buf) + }; + self.f.write_fixed_size(s)?; self.f.span_end(TokenType::Immediate); Ok(()) } fn visit_i32(&mut self, imm: i32) -> Result<Self::Ok, Self::Error> { self.f.span_enter(TokenType::Immediate); - write!(self.f, "{}", signed_i32_hex(imm))?; + let mut v = imm as u32; + if imm < 0 { + self.f.write_char('-')?; + v = -imm as u32; + } + self.f.write_fixed_size("0x")?; + let mut buf = [core::mem::MaybeUninit::<u8>::uninit(); 8]; + let mut curr = buf.len(); + loop { + let digit = v % 16; + let c = c_to_hex(digit as u8); + curr -= 1; + buf[curr].write(c); + v = v / 16; + if v == 0 { + break; + } + } + let buf = &buf[curr..]; + let s = unsafe { + core::mem::transmute::<&[core::mem::MaybeUninit<u8>], &str>(buf) + }; + + // not actually fixed size, but this should optimize right i hope.. + self.f.write_fixed_size(s)?; self.f.span_end(TokenType::Immediate); Ok(()) } fn visit_u64(&mut self, imm: u64) -> Result<Self::Ok, Self::Error> { self.f.span_enter(TokenType::Immediate); - write!(self.f, "{}", u64_hex(imm))?; + self.f.write_fixed_size("0x")?; + let mut buf = [MaybeUninit::<u8>::uninit(); 16]; + let mut curr = buf.len(); + let mut v = imm; + loop { + let digit = v % 16; + let c = c_to_hex(digit as u8); + curr -= 1; + buf[curr].write(c); + v = v / 16; + if v == 0 { + break; + } + } + let buf = &buf[curr..]; + let s: &str = unsafe { + core::mem::transmute::<&[MaybeUninit<u8>], &str>(buf) + }; + self.f.write_fixed_size(s)?; self.f.span_end(TokenType::Immediate); Ok(()) } |