compiler/rustc_serialize/src/leb128.rs

   1 #![macro_use]
   2
   3 macro_rules! max_leb128_len {
   4     ($int_ty:ty) => {
   5         // The longest LEB128 encoding for an integer uses 7 bits per byte.
   6         (std::mem::size_of::<$int_ty>() * 8 + 6) / 7
   7     };
   8 }
   9
  10 // Returns the longest LEB128 encoding of all supported integer types.
  11 pub const fn max_leb128_len() -> usize {
  12     max_leb128_len!(u128)
  13 }
  14
  15 macro_rules! impl_write_unsigned_leb128 {
  16     ($fn_name:ident, $int_ty:ty) => {
  17         #[inline]
  18         pub fn $fn_name(
  19             out: &mut [::std::mem::MaybeUninit<u8>; max_leb128_len!($int_ty)],
  20             mut value: $int_ty,
  21         ) -> &[u8] {
  22             let mut i = 0;
  23
  24             loop {
  25                 if value < 0x80 {
  26                     unsafe {
  27                         *out.get_unchecked_mut(i).as_mut_ptr() = value as u8;
  28                     }
  29
  30                     i += 1;
  31                     break;
  32                 } else {
  33                     unsafe {
  34                         *out.get_unchecked_mut(i).as_mut_ptr() = ((value & 0x7f) | 0x80) as u8;
  35                     }
  36
  37                     value >>= 7;
  38                     i += 1;
  39                 }
  40             }
  41
  42             unsafe { ::std::mem::MaybeUninit::slice_assume_init_ref(&out.get_unchecked(..i)) }
  43         }
  44     };
  45 }
  46
  47 impl_write_unsigned_leb128!(write_u16_leb128, u16);
  48 impl_write_unsigned_leb128!(write_u32_leb128, u32);
  49 impl_write_unsigned_leb128!(write_u64_leb128, u64);
  50 impl_write_unsigned_leb128!(write_u128_leb128, u128);
  51 impl_write_unsigned_leb128!(write_usize_leb128, usize);
  52
  53 macro_rules! impl_read_unsigned_leb128 {
  54     ($fn_name:ident, $int_ty:ty) => {
  55         #[inline]
  56         pub fn $fn_name(slice: &[u8], position: &mut usize) -> $int_ty {
  57             // The first iteration of this loop is unpeeled. This is a
  58             // performance win because this code is hot and integer values less
  59             // than 128 are very common, typically occurring 50-80% or more of
  60             // the time, even for u64 and u128.
  61             let byte = slice[*position];
  62             *position += 1;
  63             if (byte & 0x80) == 0 {
  64                 return byte as $int_ty;
  65             }
  66             let mut result = (byte & 0x7F) as $int_ty;
  67             let mut shift = 7;
  68             loop {
  69                 let byte = slice[*position];
  70                 *position += 1;
  71                 if (byte & 0x80) == 0 {
  72                     result |= (byte as $int_ty) << shift;
  73                     return result;
  74                 } else {
  75                     result |= ((byte & 0x7F) as $int_ty) << shift;
  76                 }
  77                 shift += 7;
  78             }
  79         }
  80     };
  81 }
  82
  83 impl_read_unsigned_leb128!(read_u16_leb128, u16);
  84 impl_read_unsigned_leb128!(read_u32_leb128, u32);
  85 impl_read_unsigned_leb128!(read_u64_leb128, u64);
  86 impl_read_unsigned_leb128!(read_u128_leb128, u128);
  87 impl_read_unsigned_leb128!(read_usize_leb128, usize);
  88
  89 macro_rules! impl_write_signed_leb128 {
  90     ($fn_name:ident, $int_ty:ty) => {
  91         #[inline]
  92         pub fn $fn_name(
  93             out: &mut [::std::mem::MaybeUninit<u8>; max_leb128_len!($int_ty)],
  94             mut value: $int_ty,
  95         ) -> &[u8] {
  96             let mut i = 0;
  97
  98             loop {
  99                 let mut byte = (value as u8) & 0x7f;
 100                 value >>= 7;
 101                 let more = !(((value == 0) && ((byte & 0x40) == 0))
 102                     || ((value == -1) && ((byte & 0x40) != 0)));
 103
 104                 if more {
 105                     byte |= 0x80; // Mark this byte to show that more bytes will follow.
 106                 }
 107
 108                 unsafe {
 109                     *out.get_unchecked_mut(i).as_mut_ptr() = byte;
 110                 }
 111
 112                 i += 1;
 113
 114                 if !more {
 115                     break;
 116                 }
 117             }
 118
 119             unsafe { ::std::mem::MaybeUninit::slice_assume_init_ref(&out.get_unchecked(..i)) }
 120         }
 121     };
 122 }
 123
 124 impl_write_signed_leb128!(write_i16_leb128, i16);
 125 impl_write_signed_leb128!(write_i32_leb128, i32);
 126 impl_write_signed_leb128!(write_i64_leb128, i64);
 127 impl_write_signed_leb128!(write_i128_leb128, i128);
 128 impl_write_signed_leb128!(write_isize_leb128, isize);
 129
 130 macro_rules! impl_read_signed_leb128 {
 131     ($fn_name:ident, $int_ty:ty) => {
 132         #[inline]
 133         pub fn $fn_name(slice: &[u8], position: &mut usize) -> $int_ty {
 134             let mut result = 0;
 135             let mut shift = 0;
 136             let mut byte;
 137
 138             loop {
 139                 byte = slice[*position];
 140                 *position += 1;
 141                 result |= <$int_ty>::from(byte & 0x7F) << shift;
 142                 shift += 7;
 143
 144                 if (byte & 0x80) == 0 {
 145                     break;
 146                 }
 147             }
 148
 149             if (shift < <$int_ty>::BITS) && ((byte & 0x40) != 0) {
 150                 // sign extend
 151                 result |= (!0 << shift);
 152             }
 153
 154             result
 155         }
 156     };
 157 }
 158
 159 impl_read_signed_leb128!(read_i16_leb128, i16);
 160 impl_read_signed_leb128!(read_i32_leb128, i32);
 161 impl_read_signed_leb128!(read_i64_leb128, i64);
 162 impl_read_signed_leb128!(read_i128_leb128, i128);
 163 impl_read_signed_leb128!(read_isize_leb128, isize);