Compiler Explorer

Source code

#![feature(maybe_uninit_slice)]

use core::fmt;
use core::str;
use core::mem::MaybeUninit;

static DEC_DIGITS_LUT: &[u8; 200] = b"\
      0001020304050607080910111213141516171819\
      2021222324252627282930313233343536373839\
      4041424344454647484950515253545556575859\
      6061626364656667686970717273747576777879\
      8081828384858687888990919293949596979899";

macro_rules! impl_fmt {
    ($name:ident, $unsigned:ty) => {
        #[no_mangle]
        #[inline(never)]
        pub fn $name(this: $unsigned, is_nonnegative: bool, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            const MAX_DEC_N: usize = <$unsigned>::MAX.ilog(10) as usize + 1;
            // Buffer decimals for $unsigned with right alignment.
            let mut buf = [MaybeUninit::<u8>::uninit(); MAX_DEC_N];
            // Count the number of bytes in buf that are not initialized.
            let mut offset = buf.len();
            // Consume the least-significant decimals from a working copy.
            let mut remain = this;
            
            // Format per four digits from the lookup table.
            // Four digits need a 16-bit $unsigned or wider.
            #[allow(overflowing_literals)]
            #[allow(unused_comparisons)]
            while remain > 999 {
                // SAFETY: All of the decimals fit in buf due to MAX_DEC_N.
                unsafe { core::hint::assert_unchecked(offset >= 4) }
                // SAFETY: The offset counts down from its initial buf.len()
                // without underflow due to the previous assertion.
                unsafe { core::hint::assert_unchecked(offset <= buf.len()) }
                offset -= 4;

let quad = remain % 100_00;
                remain /= 100_00;
                let pair1 = (quad / 100) as usize;
                let pair2 = (quad % 100) as usize;
                buf[offset + 0].write(DEC_DIGITS_LUT[pair1 * 2 + 0]);
                buf[offset + 1].write(DEC_DIGITS_LUT[pair1 * 2 + 1]);
                buf[offset + 2].write(DEC_DIGITS_LUT[pair2 * 2 + 0]);
                buf[offset + 3].write(DEC_DIGITS_LUT[pair2 * 2 + 1]);
            }

// Format per two digits from the lookup table.
            if remain > 9 {
                // SAFETY: All of the decimals fit in buf due to MAX_DEC_N.
                unsafe { core::hint::assert_unchecked(offset >= 2) }
                // SAFETY: The offset counts down from its initial buf.len()
                // without underflow due to the previous assertion.
                unsafe { core::hint::assert_unchecked(offset <= buf.len()) }
                offset -= 2;

let pair = (remain % 100) as usize;
                remain /= 100;
                buf[offset + 0].write(DEC_DIGITS_LUT[pair * 2 + 0]);
                buf[offset + 1].write(DEC_DIGITS_LUT[pair * 2 + 1]);
            }

// Format the last remaining digit, if any.
            if remain != 0 || this == 0 {
                // SAFETY: All of the decimals fit in buf due to MAX_DEC_N.
                unsafe { core::hint::assert_unchecked(offset >= 1) }
                // SAFETY: The offset counts down from its initial buf.len()
                // without underflow due to the previous assertion.
                unsafe { core::hint::assert_unchecked(offset <= buf.len()) }
                offset -= 1;

// Either the compiler sees that remain < 10, or it prevents
                // a boundary check up next.
                let last = (remain & 15) as usize;
                buf[offset].write(DEC_DIGITS_LUT[last * 2 + 1]);
                // not used: remain = 0;
            }

// SAFETY: Offset has been used as a write index.
            unsafe { core::hint::assert_unchecked(offset < buf.len()) }
            let written = &buf[offset..];
            // SAFETY: All buf content since offset is set with bytes form
            // the lookup table, which consists of valid ASCII exclusively.
            f.pad_integral(is_nonnegative, "", unsafe { 
                let as_init = MaybeUninit::slice_assume_init_ref(written);
                str::from_utf8_unchecked(as_init)
            })
        }
    }
}

impl_fmt!(fmt_u8_pr, u8);
impl_fmt!(fmt_u16_pr, u16);
impl_fmt!(fmt_u32_pr, u32);
impl_fmt!(fmt_u64_pr, u64);
impl_fmt!(fmt_u128_pr, u128);