From b71ce293e843f17e27bd2868981dead23691019e Mon Sep 17 00:00:00 2001 From: Nicholas Nethercote Date: Mon, 1 May 2023 16:40:27 +1000 Subject: [PATCH 1/5] Remove a low value comment. --- compiler/rustc_serialize/src/serialize.rs | 4 ---- 1 file changed, 4 deletions(-) diff --git a/compiler/rustc_serialize/src/serialize.rs b/compiler/rustc_serialize/src/serialize.rs index e1bc598736fee..4abbd7f3c5976 100644 --- a/compiler/rustc_serialize/src/serialize.rs +++ b/compiler/rustc_serialize/src/serialize.rs @@ -1,9 +1,5 @@ //! Support code for encoding and decoding types. -/* -Core encoding and decoding interfaces. -*/ - use std::alloc::Allocator; use std::borrow::Cow; use std::cell::{Cell, RefCell}; From 58002faca0ac45589c6092030a5459eae9720e3d Mon Sep 17 00:00:00 2001 From: Nicholas Nethercote Date: Mon, 1 May 2023 16:06:43 +1000 Subject: [PATCH 2/5] Reorder some `MemDecoder` methods. So they match the order in the `Decoder` trait. --- compiler/rustc_middle/src/ty/codec.rs | 12 ++++++------ compiler/rustc_serialize/src/opaque.rs | 20 ++++++++++---------- compiler/rustc_serialize/src/serialize.rs | 4 ++-- 3 files changed, 18 insertions(+), 18 deletions(-) diff --git a/compiler/rustc_middle/src/ty/codec.rs b/compiler/rustc_middle/src/ty/codec.rs index 7536903ef96fc..b0e158a8f5d01 100644 --- a/compiler/rustc_middle/src/ty/codec.rs +++ b/compiler/rustc_middle/src/ty/codec.rs @@ -506,19 +506,19 @@ macro_rules! implement_ty_decoder { impl<$($typaram ),*> Decoder for $DecoderName<$($typaram),*> { $crate::__impl_decoder_methods! { + read_usize -> usize; read_u128 -> u128; read_u64 -> u64; read_u32 -> u32; read_u16 -> u16; read_u8 -> u8; - read_usize -> usize; + read_isize -> isize; read_i128 -> i128; read_i64 -> i64; read_i32 -> i32; read_i16 -> i16; read_i8 -> i8; - read_isize -> isize; read_bool -> bool; read_char -> char; @@ -531,13 +531,13 @@ macro_rules! implement_ty_decoder { } #[inline] - fn position(&self) -> usize { - self.opaque.position() + fn peek_byte(&self) -> u8 { + self.opaque.peek_byte() } #[inline] - fn peek_byte(&self) -> u8 { - self.opaque.peek_byte() + fn position(&self) -> usize { + self.opaque.position() } } } diff --git a/compiler/rustc_serialize/src/opaque.rs b/compiler/rustc_serialize/src/opaque.rs index a2ec318df6d83..bb722b9ad66dd 100644 --- a/compiler/rustc_serialize/src/opaque.rs +++ b/compiler/rustc_serialize/src/opaque.rs @@ -442,9 +442,8 @@ macro_rules! read_leb128 { impl<'a> Decoder for MemDecoder<'a> { #[inline] - fn position(&self) -> usize { - // SAFETY: This type guarantees start <= current - unsafe { self.current.sub_ptr(self.start) } + fn read_usize(&mut self) -> usize { + read_leb128!(self, read_usize_leb128) } #[inline] @@ -481,8 +480,8 @@ impl<'a> Decoder for MemDecoder<'a> { } #[inline] - fn read_usize(&mut self) -> usize { - read_leb128!(self, read_usize_leb128) + fn read_isize(&mut self) -> isize { + read_leb128!(self, read_isize_leb128) } #[inline] @@ -505,11 +504,6 @@ impl<'a> Decoder for MemDecoder<'a> { i16::from_le_bytes(self.read_array()) } - #[inline] - fn read_isize(&mut self) -> isize { - read_leb128!(self, read_isize_leb128) - } - #[inline] fn read_raw_bytes(&mut self, bytes: usize) -> &'a [u8] { if bytes > self.remaining() { @@ -532,6 +526,12 @@ impl<'a> Decoder for MemDecoder<'a> { // Since we just checked current == end, the current pointer must be inbounds. unsafe { *self.current } } + + #[inline] + fn position(&self) -> usize { + // SAFETY: This type guarantees start <= current + unsafe { self.current.sub_ptr(self.start) } + } } // Specializations for contiguous byte sequences follow. The default implementations for slices diff --git a/compiler/rustc_serialize/src/serialize.rs b/compiler/rustc_serialize/src/serialize.rs index 4abbd7f3c5976..06166cabc1872 100644 --- a/compiler/rustc_serialize/src/serialize.rs +++ b/compiler/rustc_serialize/src/serialize.rs @@ -31,13 +31,13 @@ const STR_SENTINEL: u8 = 0xC1; /// really makes sense to store floating-point values at all. /// (If you need it, revert .) pub trait Encoder { - // Primitive types: fn emit_usize(&mut self, v: usize); fn emit_u128(&mut self, v: u128); fn emit_u64(&mut self, v: u64); fn emit_u32(&mut self, v: u32); fn emit_u16(&mut self, v: u16); fn emit_u8(&mut self, v: u8); + fn emit_isize(&mut self, v: isize); fn emit_i128(&mut self, v: i128); fn emit_i64(&mut self, v: i64); @@ -89,13 +89,13 @@ pub trait Encoder { /// really makes sense to store floating-point values at all. /// (If you need it, revert .) pub trait Decoder { - // Primitive types: fn read_usize(&mut self) -> usize; fn read_u128(&mut self) -> u128; fn read_u64(&mut self) -> u64; fn read_u32(&mut self) -> u32; fn read_u16(&mut self) -> u16; fn read_u8(&mut self) -> u8; + fn read_isize(&mut self) -> isize; fn read_i128(&mut self) -> i128; fn read_i64(&mut self) -> i64; From 6b70be2a345fd09c17986d95b66cf5b22f96e7ed Mon Sep 17 00:00:00 2001 From: Nicholas Nethercote Date: Mon, 1 May 2023 16:28:40 +1000 Subject: [PATCH 3/5] Remove unneeded encode/decode methods. In #110927 the encode/decode methods for `i8`, `char`, `bool`, and `str` were made inherent. This commit removes some unnecessary implementations of these methods that were missed in that PR. --- compiler/rustc_metadata/src/rmeta/encoder.rs | 4 ---- compiler/rustc_middle/src/query/on_disk_cache.rs | 4 ---- compiler/rustc_middle/src/ty/codec.rs | 5 ----- 3 files changed, 13 deletions(-) diff --git a/compiler/rustc_metadata/src/rmeta/encoder.rs b/compiler/rustc_metadata/src/rmeta/encoder.rs index 3253d0a905744..52620ef9db483 100644 --- a/compiler/rustc_metadata/src/rmeta/encoder.rs +++ b/compiler/rustc_metadata/src/rmeta/encoder.rs @@ -108,11 +108,7 @@ impl<'a, 'tcx> Encoder for EncodeContext<'a, 'tcx> { emit_i64(i64); emit_i32(i32); emit_i16(i16); - emit_i8(i8); - emit_bool(bool); - emit_char(char); - emit_str(&str); emit_raw_bytes(&[u8]); } } diff --git a/compiler/rustc_middle/src/query/on_disk_cache.rs b/compiler/rustc_middle/src/query/on_disk_cache.rs index e56faff5ed47c..220118ae5ccb8 100644 --- a/compiler/rustc_middle/src/query/on_disk_cache.rs +++ b/compiler/rustc_middle/src/query/on_disk_cache.rs @@ -1026,11 +1026,7 @@ impl<'a, 'tcx> Encoder for CacheEncoder<'a, 'tcx> { emit_i64(i64); emit_i32(i32); emit_i16(i16); - emit_i8(i8); - emit_bool(bool); - emit_char(char); - emit_str(&str); emit_raw_bytes(&[u8]); } } diff --git a/compiler/rustc_middle/src/ty/codec.rs b/compiler/rustc_middle/src/ty/codec.rs index b0e158a8f5d01..7fc75674da537 100644 --- a/compiler/rustc_middle/src/ty/codec.rs +++ b/compiler/rustc_middle/src/ty/codec.rs @@ -518,11 +518,6 @@ macro_rules! implement_ty_decoder { read_i64 -> i64; read_i32 -> i32; read_i16 -> i16; - read_i8 -> i8; - - read_bool -> bool; - read_char -> char; - read_str -> &str; } #[inline] From 4ac959a3c083dcd3c6536c26513b26ff891abfe6 Mon Sep 17 00:00:00 2001 From: Nicholas Nethercote Date: Thu, 4 May 2023 12:55:01 +1000 Subject: [PATCH 4/5] Rename `file_encoder_write_leb128!`. `MemEncoder` was recently removed, leaving `FileEncoder` as the only encoder. So this prefix is no longer needed, and `write_leb128!` matches the existing `read_leb128!`. --- compiler/rustc_serialize/src/opaque.rs | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/compiler/rustc_serialize/src/opaque.rs b/compiler/rustc_serialize/src/opaque.rs index bb722b9ad66dd..dc78f1da745e2 100644 --- a/compiler/rustc_serialize/src/opaque.rs +++ b/compiler/rustc_serialize/src/opaque.rs @@ -265,7 +265,7 @@ impl Drop for FileEncoder { } } -macro_rules! file_encoder_write_leb128 { +macro_rules! write_leb128 { ($enc:expr, $value:expr, $int_ty:ty, $fun:ident) => {{ const MAX_ENCODED_LEN: usize = $crate::leb128::max_leb128_len::<$int_ty>(); @@ -294,22 +294,22 @@ macro_rules! file_encoder_write_leb128 { impl Encoder for FileEncoder { #[inline] fn emit_usize(&mut self, v: usize) { - file_encoder_write_leb128!(self, v, usize, write_usize_leb128) + write_leb128!(self, v, usize, write_usize_leb128) } #[inline] fn emit_u128(&mut self, v: u128) { - file_encoder_write_leb128!(self, v, u128, write_u128_leb128) + write_leb128!(self, v, u128, write_u128_leb128) } #[inline] fn emit_u64(&mut self, v: u64) { - file_encoder_write_leb128!(self, v, u64, write_u64_leb128) + write_leb128!(self, v, u64, write_u64_leb128) } #[inline] fn emit_u32(&mut self, v: u32) { - file_encoder_write_leb128!(self, v, u32, write_u32_leb128) + write_leb128!(self, v, u32, write_u32_leb128) } #[inline] @@ -324,22 +324,22 @@ impl Encoder for FileEncoder { #[inline] fn emit_isize(&mut self, v: isize) { - file_encoder_write_leb128!(self, v, isize, write_isize_leb128) + write_leb128!(self, v, isize, write_isize_leb128) } #[inline] fn emit_i128(&mut self, v: i128) { - file_encoder_write_leb128!(self, v, i128, write_i128_leb128) + write_leb128!(self, v, i128, write_i128_leb128) } #[inline] fn emit_i64(&mut self, v: i64) { - file_encoder_write_leb128!(self, v, i64, write_i64_leb128) + write_leb128!(self, v, i64, write_i64_leb128) } #[inline] fn emit_i32(&mut self, v: i32) { - file_encoder_write_leb128!(self, v, i32, write_i32_leb128) + write_leb128!(self, v, i32, write_i32_leb128) } #[inline] From 723ca2a33df3774914abc68a8ab79238904ef067 Mon Sep 17 00:00:00 2001 From: Nicholas Nethercote Date: Thu, 4 May 2023 13:10:22 +1000 Subject: [PATCH 5/5] Factor out more repeated code in `{write,read}_leb128!`. Make them generate the entire function, not just the function body. --- compiler/rustc_serialize/src/opaque.rs | 139 ++++++++----------------- 1 file changed, 44 insertions(+), 95 deletions(-) diff --git a/compiler/rustc_serialize/src/opaque.rs b/compiler/rustc_serialize/src/opaque.rs index dc78f1da745e2..6b559cb5b2f64 100644 --- a/compiler/rustc_serialize/src/opaque.rs +++ b/compiler/rustc_serialize/src/opaque.rs @@ -266,51 +266,40 @@ impl Drop for FileEncoder { } macro_rules! write_leb128 { - ($enc:expr, $value:expr, $int_ty:ty, $fun:ident) => {{ - const MAX_ENCODED_LEN: usize = $crate::leb128::max_leb128_len::<$int_ty>(); + ($this_fn:ident, $int_ty:ty, $write_leb_fn:ident) => { + #[inline] + fn $this_fn(&mut self, v: $int_ty) { + const MAX_ENCODED_LEN: usize = $crate::leb128::max_leb128_len::<$int_ty>(); - // We ensure this during `FileEncoder` construction. - debug_assert!($enc.capacity() >= MAX_ENCODED_LEN); + // We ensure this during `FileEncoder` construction. + debug_assert!(self.capacity() >= MAX_ENCODED_LEN); - let mut buffered = $enc.buffered; + let mut buffered = self.buffered; - // This can't overflow. See assertion in `FileEncoder::with_capacity`. - if std::intrinsics::unlikely(buffered + MAX_ENCODED_LEN > $enc.capacity()) { - $enc.flush(); - buffered = 0; - } + // This can't overflow. See assertion in `FileEncoder::with_capacity`. + if std::intrinsics::unlikely(buffered + MAX_ENCODED_LEN > self.capacity()) { + self.flush(); + buffered = 0; + } - // SAFETY: The above check and flush ensures that there is enough - // room to write the encoded value to the buffer. - let buf = unsafe { - &mut *($enc.buf.as_mut_ptr().add(buffered) as *mut [MaybeUninit; MAX_ENCODED_LEN]) - }; + // SAFETY: The above check and flush ensures that there is enough + // room to write the encoded value to the buffer. + let buf = unsafe { + &mut *(self.buf.as_mut_ptr().add(buffered) + as *mut [MaybeUninit; MAX_ENCODED_LEN]) + }; - let encoded = leb128::$fun(buf, $value); - $enc.buffered = buffered + encoded.len(); - }}; + let encoded = leb128::$write_leb_fn(buf, v); + self.buffered = buffered + encoded.len(); + } + }; } impl Encoder for FileEncoder { - #[inline] - fn emit_usize(&mut self, v: usize) { - write_leb128!(self, v, usize, write_usize_leb128) - } - - #[inline] - fn emit_u128(&mut self, v: u128) { - write_leb128!(self, v, u128, write_u128_leb128) - } - - #[inline] - fn emit_u64(&mut self, v: u64) { - write_leb128!(self, v, u64, write_u64_leb128) - } - - #[inline] - fn emit_u32(&mut self, v: u32) { - write_leb128!(self, v, u32, write_u32_leb128) - } + write_leb128!(emit_usize, usize, write_usize_leb128); + write_leb128!(emit_u128, u128, write_u128_leb128); + write_leb128!(emit_u64, u64, write_u64_leb128); + write_leb128!(emit_u32, u32, write_u32_leb128); #[inline] fn emit_u16(&mut self, v: u16) { @@ -322,25 +311,10 @@ impl Encoder for FileEncoder { self.write_one(v); } - #[inline] - fn emit_isize(&mut self, v: isize) { - write_leb128!(self, v, isize, write_isize_leb128) - } - - #[inline] - fn emit_i128(&mut self, v: i128) { - write_leb128!(self, v, i128, write_i128_leb128) - } - - #[inline] - fn emit_i64(&mut self, v: i64) { - write_leb128!(self, v, i64, write_i64_leb128) - } - - #[inline] - fn emit_i32(&mut self, v: i32) { - write_leb128!(self, v, i32, write_i32_leb128) - } + write_leb128!(emit_isize, isize, write_isize_leb128); + write_leb128!(emit_i128, i128, write_i128_leb128); + write_leb128!(emit_i64, i64, write_i64_leb128); + write_leb128!(emit_i32, i32, write_i32_leb128); #[inline] fn emit_i16(&mut self, v: i16) { @@ -437,29 +411,19 @@ impl<'a> MemDecoder<'a> { } macro_rules! read_leb128 { - ($dec:expr, $fun:ident) => {{ leb128::$fun($dec) }}; + ($this_fn:ident, $int_ty:ty, $read_leb_fn:ident) => { + #[inline] + fn $this_fn(&mut self) -> $int_ty { + leb128::$read_leb_fn(self) + } + }; } impl<'a> Decoder for MemDecoder<'a> { - #[inline] - fn read_usize(&mut self) -> usize { - read_leb128!(self, read_usize_leb128) - } - - #[inline] - fn read_u128(&mut self) -> u128 { - read_leb128!(self, read_u128_leb128) - } - - #[inline] - fn read_u64(&mut self) -> u64 { - read_leb128!(self, read_u64_leb128) - } - - #[inline] - fn read_u32(&mut self) -> u32 { - read_leb128!(self, read_u32_leb128) - } + read_leb128!(read_usize, usize, read_usize_leb128); + read_leb128!(read_u128, u128, read_u128_leb128); + read_leb128!(read_u64, u64, read_u64_leb128); + read_leb128!(read_u32, u32, read_u32_leb128); #[inline] fn read_u16(&mut self) -> u16 { @@ -479,25 +443,10 @@ impl<'a> Decoder for MemDecoder<'a> { } } - #[inline] - fn read_isize(&mut self) -> isize { - read_leb128!(self, read_isize_leb128) - } - - #[inline] - fn read_i128(&mut self) -> i128 { - read_leb128!(self, read_i128_leb128) - } - - #[inline] - fn read_i64(&mut self) -> i64 { - read_leb128!(self, read_i64_leb128) - } - - #[inline] - fn read_i32(&mut self) -> i32 { - read_leb128!(self, read_i32_leb128) - } + read_leb128!(read_isize, isize, read_isize_leb128); + read_leb128!(read_i128, i128, read_i128_leb128); + read_leb128!(read_i64, i64, read_i64_leb128); + read_leb128!(read_i32, i32, read_i32_leb128); #[inline] fn read_i16(&mut self) -> i16 {