diff --git a/src/librustc/ty/query/on_disk_cache.rs b/src/librustc/ty/query/on_disk_cache.rs index c16f861dedb50..832cf0986c9ab 100644 --- a/src/librustc/ty/query/on_disk_cache.rs +++ b/src/librustc/ty/query/on_disk_cache.rs @@ -105,22 +105,21 @@ impl AbsoluteBytePos { impl<'sess> OnDiskCache<'sess> { /// Creates a new OnDiskCache instance from the serialized data in `data`. - pub fn new(sess: &'sess Session, data: Vec, start_pos: usize) -> OnDiskCache<'sess> { + pub fn new(sess: &'sess Session, data: Vec) -> OnDiskCache<'sess> { debug_assert!(sess.opts.incremental.is_some()); // Wrapping in a scope so we can borrow `data` let footer: Footer = { - let mut decoder = opaque::Decoder::new(&data[..], start_pos); - // Decode the *position* of the footer which can be found in the // last 8 bytes of the file. - decoder.set_position(data.len() - IntEncodedWithFixedSize::ENCODED_SIZE); + let mut decoder = opaque::Decoder::new( + &data, data.len() - IntEncodedWithFixedSize::ENCODED_SIZE); let query_result_index_pos = IntEncodedWithFixedSize::decode(&mut decoder) .expect("Error while trying to decode query result index position.") .0 as usize; // Decoder the file footer which contains all the lookup tables, etc. - decoder.set_position(query_result_index_pos); + decoder = opaque::Decoder::new(&data, query_result_index_pos); decode_tagged(&mut decoder, TAG_FILE_FOOTER) .expect("Error while trying to decode query result index position.") }; @@ -540,7 +539,7 @@ impl<'a, 'tcx: 'a, 'x> ty_codec::TyDecoder<'a, 'tcx> for CacheDecoder<'a, 'tcx, #[inline] fn peek_byte(&self) -> u8 { - self.opaque.data[self.opaque.position()] + self.opaque.data()[0] } fn cached_ty_for_shorthand(&mut self, @@ -569,9 +568,9 @@ impl<'a, 'tcx: 'a, 'x> ty_codec::TyDecoder<'a, 'tcx> for CacheDecoder<'a, 'tcx, fn with_position(&mut self, pos: usize, f: F) -> R where F: FnOnce(&mut Self) -> R { - debug_assert!(pos < self.opaque.data.len()); + debug_assert!(pos < self.opaque.original_data.len()); - let new_opaque = opaque::Decoder::new(self.opaque.data, pos); + let new_opaque = opaque::Decoder::new(&self.opaque.original_data, pos); let old_opaque = mem::replace(&mut self.opaque, new_opaque); let r = f(self); self.opaque = old_opaque; diff --git a/src/librustc_incremental/persist/load.rs b/src/librustc_incremental/persist/load.rs index ecf8bc4a88084..178b179721d3b 100644 --- a/src/librustc_incremental/persist/load.rs +++ b/src/librustc_incremental/persist/load.rs @@ -200,7 +200,7 @@ pub fn load_query_result_cache<'sess>(sess: &'sess Session) -> OnDiskCache<'sess } match load_data(sess.opts.debugging_opts.incremental_info, &query_cache_path(sess)) { - LoadResult::Ok{ data: (bytes, start_pos) } => OnDiskCache::new(sess, bytes, start_pos), + LoadResult::Ok{ data: (bytes, _) } => OnDiskCache::new(sess, bytes), _ => OnDiskCache::new_empty(sess.source_map()) } } diff --git a/src/librustc_metadata/decoder.rs b/src/librustc_metadata/decoder.rs index 1c4e3bc6a50e7..5278723bdcaca 100644 --- a/src/librustc_metadata/decoder.rs +++ b/src/librustc_metadata/decoder.rs @@ -179,7 +179,7 @@ impl<'a, 'tcx: 'a> TyDecoder<'a, 'tcx> for DecodeContext<'a, 'tcx> { #[inline] fn peek_byte(&self) -> u8 { - self.opaque.data[self.opaque.position()] + self.opaque.data()[0] } #[inline] @@ -212,7 +212,7 @@ impl<'a, 'tcx: 'a> TyDecoder<'a, 'tcx> for DecodeContext<'a, 'tcx> { fn with_position(&mut self, pos: usize, f: F) -> R where F: FnOnce(&mut Self) -> R { - let new_opaque = opaque::Decoder::new(self.opaque.data, pos); + let new_opaque = opaque::Decoder::new(self.opaque.original_data, pos); let old_opaque = mem::replace(&mut self.opaque, new_opaque); let old_state = mem::replace(&mut self.lazy_state, LazyState::NoNode); let r = f(self); diff --git a/src/libserialize/leb128.rs b/src/libserialize/leb128.rs index 16ff59489e718..a94e29b3abbb4 100644 --- a/src/libserialize/leb128.rs +++ b/src/libserialize/leb128.rs @@ -114,10 +114,10 @@ pub fn write_signed_leb128(out: &mut Vec, value: i128) { } #[inline] -pub fn read_signed_leb128(data: &[u8], start_position: usize) -> (i128, usize) { +pub fn read_signed_leb128(data: &[u8]) -> (i128, usize) { let mut result = 0; let mut shift = 0; - let mut position = start_position; + let mut position = 0; let mut byte; loop { @@ -136,7 +136,7 @@ pub fn read_signed_leb128(data: &[u8], start_position: usize) -> (i128, usize) { result |= -(1 << shift); } - (result, position - start_position) + (result, position) } macro_rules! impl_test_unsigned_leb128 { @@ -176,7 +176,7 @@ fn test_signed_leb128() { } let mut pos = 0; for &x in &values { - let (value, bytes_read) = read_signed_leb128(&mut stream, pos); + let (value, bytes_read) = read_signed_leb128(&mut stream[pos..]); pos += bytes_read; assert_eq!(x, value); } diff --git a/src/libserialize/lib.rs b/src/libserialize/lib.rs index b8eeb4d2b34af..553a5bdb499de 100644 --- a/src/libserialize/lib.rs +++ b/src/libserialize/lib.rs @@ -15,6 +15,7 @@ Core encoding and decoding interfaces. #![feature(specialization)] #![feature(never_type)] #![feature(nll)] +#![feature(ptr_wrapping_offset_from)] #![cfg_attr(test, feature(test))] pub use self::serialize::{Decoder, Encoder, Decodable, Encodable}; diff --git a/src/libserialize/opaque.rs b/src/libserialize/opaque.rs index a6a5c318079f1..37306c1f82547 100644 --- a/src/libserialize/opaque.rs +++ b/src/libserialize/opaque.rs @@ -157,42 +157,38 @@ impl Encoder { // ----------------------------------------------------------------------------- pub struct Decoder<'a> { - pub data: &'a [u8], - position: usize, + pub original_data: &'a [u8], + data: &'a [u8], } impl<'a> Decoder<'a> { #[inline] - pub fn new(data: &'a [u8], position: usize) -> Decoder<'a> { + pub fn new(data: &'a [u8], pos: usize) -> Decoder<'a> { Decoder { - data, - position, + original_data: data, + data: &data[pos..], } } #[inline] - pub fn position(&self) -> usize { - self.position + pub fn data(&self) -> &[u8] { + self.data } #[inline] - pub fn set_position(&mut self, pos: usize) { - self.position = pos + pub fn position(&self) -> usize { + self.data.as_ptr().wrapping_offset_from(self.original_data.as_ptr()) as usize } #[inline] pub fn advance(&mut self, bytes: usize) { - self.position += bytes; + self.data = &self.data[bytes..]; } #[inline] pub fn read_raw_bytes(&mut self, s: &mut [u8]) -> Result<(), String> { - let start = self.position; - let end = start + s.len(); - - s.copy_from_slice(&self.data[start..end]); - - self.position = end; + s.copy_from_slice(&self.data[..s.len()]); + self.advance(s.len()); Ok(()) } @@ -200,16 +196,16 @@ impl<'a> Decoder<'a> { macro_rules! read_uleb128 { ($dec:expr, $t:ty, $fun:ident) => ({ - let (value, bytes_read) = leb128::$fun(&$dec.data[$dec.position ..]); - $dec.position += bytes_read; + let (value, bytes_read) = leb128::$fun(&$dec.data); + $dec.advance(bytes_read); Ok(value) }) } macro_rules! read_sleb128 { ($dec:expr, $t:ty) => ({ - let (value, bytes_read) = read_signed_leb128($dec.data, $dec.position); - $dec.position += bytes_read; + let (value, bytes_read) = read_signed_leb128($dec.data); + $dec.advance(bytes_read); Ok(value as $t) }) } @@ -245,8 +241,8 @@ impl<'a> serialize::Decoder for Decoder<'a> { #[inline] fn read_u8(&mut self) -> Result { - let value = self.data[self.position]; - self.position += 1; + let value = self.data[0]; + self.advance(1); Ok(value) } @@ -277,8 +273,8 @@ impl<'a> serialize::Decoder for Decoder<'a> { #[inline] fn read_i8(&mut self) -> Result { - let as_u8 = self.data[self.position]; - self.position += 1; + let as_u8 = self.data[0]; + self.advance(1); unsafe { Ok(::std::mem::transmute(as_u8)) } } @@ -314,8 +310,8 @@ impl<'a> serialize::Decoder for Decoder<'a> { #[inline] fn read_str(&mut self) -> Result, Self::Error> { let len = self.read_usize()?; - let s = ::std::str::from_utf8(&self.data[self.position..self.position + len]).unwrap(); - self.position += len; + let s = ::std::str::from_utf8(&self.data[..len]).unwrap(); + self.advance(len); Ok(Cow::Borrowed(s)) }