From a990de90fe41456a23e58bd087d2f107d321f3a1 Mon Sep 17 00:00:00 2001 From: Valentin Popov Date: Fri, 19 Jul 2024 16:37:58 +0400 Subject: Deleted vendor folder --- vendor/gimli/src/leb128.rs | 612 --------------------------------------------- 1 file changed, 612 deletions(-) delete mode 100644 vendor/gimli/src/leb128.rs (limited to 'vendor/gimli/src/leb128.rs') diff --git a/vendor/gimli/src/leb128.rs b/vendor/gimli/src/leb128.rs deleted file mode 100644 index de81cfd..0000000 --- a/vendor/gimli/src/leb128.rs +++ /dev/null @@ -1,612 +0,0 @@ -//! Read and write DWARF's "Little Endian Base 128" (LEB128) variable length -//! integer encoding. -//! -//! The implementation is a direct translation of the psuedocode in the DWARF 4 -//! standard's appendix C. -//! -//! Read and write signed integers: -//! -//! ``` -//! # #[cfg(all(feature = "read", feature = "write"))] { -//! use gimli::{EndianSlice, NativeEndian, leb128}; -//! -//! let mut buf = [0; 1024]; -//! -//! // Write to anything that implements `std::io::Write`. -//! { -//! let mut writable = &mut buf[..]; -//! leb128::write::signed(&mut writable, -12345).expect("Should write number"); -//! } -//! -//! // Read from anything that implements `gimli::Reader`. -//! let mut readable = EndianSlice::new(&buf[..], NativeEndian); -//! let val = leb128::read::signed(&mut readable).expect("Should read number"); -//! assert_eq!(val, -12345); -//! # } -//! ``` -//! -//! Or read and write unsigned integers: -//! -//! ``` -//! # #[cfg(all(feature = "read", feature = "write"))] { -//! use gimli::{EndianSlice, NativeEndian, leb128}; -//! -//! let mut buf = [0; 1024]; -//! -//! { -//! let mut writable = &mut buf[..]; -//! leb128::write::unsigned(&mut writable, 98765).expect("Should write number"); -//! } -//! -//! let mut readable = EndianSlice::new(&buf[..], NativeEndian); -//! let val = leb128::read::unsigned(&mut readable).expect("Should read number"); -//! assert_eq!(val, 98765); -//! # } -//! ``` - -const CONTINUATION_BIT: u8 = 1 << 7; -#[cfg(feature = "read-core")] -const SIGN_BIT: u8 = 1 << 6; - -#[inline] -fn low_bits_of_byte(byte: u8) -> u8 { - byte & !CONTINUATION_BIT -} - -#[inline] -#[allow(dead_code)] -fn low_bits_of_u64(val: u64) -> u8 { - let byte = val & u64::from(core::u8::MAX); - low_bits_of_byte(byte as u8) -} - -/// A module for reading signed and unsigned integers that have been LEB128 -/// encoded. -#[cfg(feature = "read-core")] -pub mod read { - use super::{low_bits_of_byte, CONTINUATION_BIT, SIGN_BIT}; - use crate::read::{Error, Reader, Result}; - - /// Read bytes until the LEB128 continuation bit is not set. - pub fn skip(r: &mut R) -> Result<()> { - loop { - let byte = r.read_u8()?; - if byte & CONTINUATION_BIT == 0 { - return Ok(()); - } - } - } - - /// Read an unsigned LEB128 number from the given `Reader` and - /// return it or an error if reading failed. - pub fn unsigned(r: &mut R) -> Result { - let mut result = 0; - let mut shift = 0; - - loop { - let byte = r.read_u8()?; - if shift == 63 && byte != 0x00 && byte != 0x01 { - return Err(Error::BadUnsignedLeb128); - } - - let low_bits = u64::from(low_bits_of_byte(byte)); - result |= low_bits << shift; - - if byte & CONTINUATION_BIT == 0 { - return Ok(result); - } - - shift += 7; - } - } - - /// Read an LEB128 u16 from the given `Reader` and - /// return it or an error if reading failed. - pub fn u16(r: &mut R) -> Result { - let byte = r.read_u8()?; - let mut result = u16::from(low_bits_of_byte(byte)); - if byte & CONTINUATION_BIT == 0 { - return Ok(result); - } - - let byte = r.read_u8()?; - result |= u16::from(low_bits_of_byte(byte)) << 7; - if byte & CONTINUATION_BIT == 0 { - return Ok(result); - } - - let byte = r.read_u8()?; - if byte > 0x03 { - return Err(Error::BadUnsignedLeb128); - } - result += u16::from(byte) << 14; - Ok(result) - } - - /// Read a signed LEB128 number from the given `Reader` and - /// return it or an error if reading failed. - pub fn signed(r: &mut R) -> Result { - let mut result = 0; - let mut shift = 0; - let size = 64; - let mut byte; - - loop { - byte = r.read_u8()?; - if shift == 63 && byte != 0x00 && byte != 0x7f { - return Err(Error::BadSignedLeb128); - } - - let low_bits = i64::from(low_bits_of_byte(byte)); - result |= low_bits << shift; - shift += 7; - - if byte & CONTINUATION_BIT == 0 { - break; - } - } - - if shift < size && (SIGN_BIT & byte) == SIGN_BIT { - // Sign extend the result. - result |= !0 << shift; - } - - Ok(result) - } -} - -/// A module for writing integers encoded as LEB128. -#[cfg(feature = "write")] -pub mod write { - use super::{low_bits_of_u64, CONTINUATION_BIT}; - use std::io; - - /// Write the given unsigned number using the LEB128 encoding to the given - /// `std::io::Write`able. Returns the number of bytes written to `w`, or an - /// error if writing failed. - pub fn unsigned(w: &mut W, mut val: u64) -> Result - where - W: io::Write, - { - let mut bytes_written = 0; - loop { - let mut byte = low_bits_of_u64(val); - val >>= 7; - if val != 0 { - // More bytes to come, so set the continuation bit. - byte |= CONTINUATION_BIT; - } - - let buf = [byte]; - w.write_all(&buf)?; - bytes_written += 1; - - if val == 0 { - return Ok(bytes_written); - } - } - } - - /// Return the size of the LEB128 encoding of the given unsigned number. - pub fn uleb128_size(mut val: u64) -> usize { - let mut size = 0; - loop { - val >>= 7; - size += 1; - if val == 0 { - return size; - } - } - } - - /// Write the given signed number using the LEB128 encoding to the given - /// `std::io::Write`able. Returns the number of bytes written to `w`, or an - /// error if writing failed. - pub fn signed(w: &mut W, mut val: i64) -> Result - where - W: io::Write, - { - let mut bytes_written = 0; - loop { - let mut byte = val as u8; - // Keep the sign bit for testing - val >>= 6; - let done = val == 0 || val == -1; - if done { - byte &= !CONTINUATION_BIT; - } else { - // Remove the sign bit - val >>= 1; - // More bytes to come, so set the continuation bit. - byte |= CONTINUATION_BIT; - } - - let buf = [byte]; - w.write_all(&buf)?; - bytes_written += 1; - - if done { - return Ok(bytes_written); - } - } - } - - /// Return the size of the LEB128 encoding of the given signed number. - pub fn sleb128_size(mut val: i64) -> usize { - let mut size = 0; - loop { - val >>= 6; - let done = val == 0 || val == -1; - val >>= 1; - size += 1; - if done { - return size; - } - } - } -} - -#[cfg(test)] -#[cfg(all(feature = "read", feature = "write"))] -mod tests { - use super::{low_bits_of_byte, low_bits_of_u64, read, write, CONTINUATION_BIT}; - use crate::endianity::NativeEndian; - use crate::read::{EndianSlice, Error, ReaderOffsetId}; - - trait ResultExt { - fn map_eof(self, input: &[u8]) -> Self; - } - - impl ResultExt for Result { - fn map_eof(self, input: &[u8]) -> Self { - match self { - Err(Error::UnexpectedEof(id)) => { - let id = ReaderOffsetId(id.0 - input.as_ptr() as u64); - Err(Error::UnexpectedEof(id)) - } - r => r, - } - } - } - - #[test] - fn test_low_bits_of_byte() { - for i in 0..127 { - assert_eq!(i, low_bits_of_byte(i)); - assert_eq!(i, low_bits_of_byte(i | CONTINUATION_BIT)); - } - } - - #[test] - fn test_low_bits_of_u64() { - for i in 0u64..127 { - assert_eq!(i as u8, low_bits_of_u64(1 << 16 | i)); - assert_eq!( - i as u8, - low_bits_of_u64(i << 16 | i | (u64::from(CONTINUATION_BIT))) - ); - } - } - - // Examples from the DWARF 4 standard, section 7.6, figure 22. - #[test] - fn test_read_unsigned() { - let buf = [2u8]; - let mut readable = EndianSlice::new(&buf[..], NativeEndian); - assert_eq!( - 2, - read::unsigned(&mut readable).expect("Should read number") - ); - - let buf = [127u8]; - let mut readable = EndianSlice::new(&buf[..], NativeEndian); - assert_eq!( - 127, - read::unsigned(&mut readable).expect("Should read number") - ); - - let buf = [CONTINUATION_BIT, 1]; - let mut readable = EndianSlice::new(&buf[..], NativeEndian); - assert_eq!( - 128, - read::unsigned(&mut readable).expect("Should read number") - ); - - let buf = [1u8 | CONTINUATION_BIT, 1]; - let mut readable = EndianSlice::new(&buf[..], NativeEndian); - assert_eq!( - 129, - read::unsigned(&mut readable).expect("Should read number") - ); - - let buf = [2u8 | CONTINUATION_BIT, 1]; - let mut readable = EndianSlice::new(&buf[..], NativeEndian); - assert_eq!( - 130, - read::unsigned(&mut readable).expect("Should read number") - ); - - let buf = [57u8 | CONTINUATION_BIT, 100]; - let mut readable = EndianSlice::new(&buf[..], NativeEndian); - assert_eq!( - 12857, - read::unsigned(&mut readable).expect("Should read number") - ); - } - - // Examples from the DWARF 4 standard, section 7.6, figure 23. - #[test] - fn test_read_signed() { - let buf = [2u8]; - let mut readable = EndianSlice::new(&buf[..], NativeEndian); - assert_eq!(2, read::signed(&mut readable).expect("Should read number")); - - let buf = [0x7eu8]; - let mut readable = EndianSlice::new(&buf[..], NativeEndian); - assert_eq!(-2, read::signed(&mut readable).expect("Should read number")); - - let buf = [127u8 | CONTINUATION_BIT, 0]; - let mut readable = EndianSlice::new(&buf[..], NativeEndian); - assert_eq!( - 127, - read::signed(&mut readable).expect("Should read number") - ); - - let buf = [1u8 | CONTINUATION_BIT, 0x7f]; - let mut readable = EndianSlice::new(&buf[..], NativeEndian); - assert_eq!( - -127, - read::signed(&mut readable).expect("Should read number") - ); - - let buf = [CONTINUATION_BIT, 1]; - let mut readable = EndianSlice::new(&buf[..], NativeEndian); - assert_eq!( - 128, - read::signed(&mut readable).expect("Should read number") - ); - - let buf = [CONTINUATION_BIT, 0x7f]; - let mut readable = EndianSlice::new(&buf[..], NativeEndian); - assert_eq!( - -128, - read::signed(&mut readable).expect("Should read number") - ); - - let buf = [1u8 | CONTINUATION_BIT, 1]; - let mut readable = EndianSlice::new(&buf[..], NativeEndian); - assert_eq!( - 129, - read::signed(&mut readable).expect("Should read number") - ); - - let buf = [0x7fu8 | CONTINUATION_BIT, 0x7e]; - let mut readable = EndianSlice::new(&buf[..], NativeEndian); - assert_eq!( - -129, - read::signed(&mut readable).expect("Should read number") - ); - } - - #[test] - fn test_read_signed_63_bits() { - let buf = [ - CONTINUATION_BIT, - CONTINUATION_BIT, - CONTINUATION_BIT, - CONTINUATION_BIT, - CONTINUATION_BIT, - CONTINUATION_BIT, - CONTINUATION_BIT, - CONTINUATION_BIT, - 0x40, - ]; - let mut readable = EndianSlice::new(&buf[..], NativeEndian); - assert_eq!( - -0x4000_0000_0000_0000, - read::signed(&mut readable).expect("Should read number") - ); - } - - #[test] - fn test_read_unsigned_not_enough_data() { - let buf = [CONTINUATION_BIT]; - let mut readable = EndianSlice::new(&buf[..], NativeEndian); - assert_eq!( - read::unsigned(&mut readable).map_eof(&buf), - Err(Error::UnexpectedEof(ReaderOffsetId(1))) - ); - } - - #[test] - fn test_read_signed_not_enough_data() { - let buf = [CONTINUATION_BIT]; - let mut readable = EndianSlice::new(&buf[..], NativeEndian); - assert_eq!( - read::signed(&mut readable).map_eof(&buf), - Err(Error::UnexpectedEof(ReaderOffsetId(1))) - ); - } - - #[test] - fn test_write_unsigned_not_enough_space() { - let mut buf = [0; 1]; - let mut writable = &mut buf[..]; - match write::unsigned(&mut writable, 128) { - Err(e) => assert_eq!(e.kind(), std::io::ErrorKind::WriteZero), - otherwise => panic!("Unexpected: {:?}", otherwise), - } - } - - #[test] - fn test_write_signed_not_enough_space() { - let mut buf = [0; 1]; - let mut writable = &mut buf[..]; - match write::signed(&mut writable, 128) { - Err(e) => assert_eq!(e.kind(), std::io::ErrorKind::WriteZero), - otherwise => panic!("Unexpected: {:?}", otherwise), - } - } - - #[test] - fn dogfood_signed() { - fn inner(i: i64) { - let mut buf = [0u8; 1024]; - - { - let mut writable = &mut buf[..]; - write::signed(&mut writable, i).expect("Should write signed number"); - } - - let mut readable = EndianSlice::new(&buf[..], NativeEndian); - let result = read::signed(&mut readable).expect("Should be able to read it back again"); - assert_eq!(i, result); - } - for i in -513..513 { - inner(i); - } - inner(core::i64::MIN); - } - - #[test] - fn dogfood_unsigned() { - for i in 0..1025 { - let mut buf = [0u8; 1024]; - - { - let mut writable = &mut buf[..]; - write::unsigned(&mut writable, i).expect("Should write signed number"); - } - - let mut readable = EndianSlice::new(&buf[..], NativeEndian); - let result = - read::unsigned(&mut readable).expect("Should be able to read it back again"); - assert_eq!(i, result); - } - } - - #[test] - fn test_read_unsigned_overflow() { - let buf = [ - 2u8 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 1, - ]; - let mut readable = EndianSlice::new(&buf[..], NativeEndian); - assert!(read::unsigned(&mut readable).is_err()); - } - - #[test] - fn test_read_signed_overflow() { - let buf = [ - 2u8 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 2 | CONTINUATION_BIT, - 1, - ]; - let mut readable = EndianSlice::new(&buf[..], NativeEndian); - assert!(read::signed(&mut readable).is_err()); - } - - #[test] - fn test_read_multiple() { - let buf = [2u8 | CONTINUATION_BIT, 1u8, 1u8]; - - let mut readable = EndianSlice::new(&buf[..], NativeEndian); - assert_eq!( - read::unsigned(&mut readable).expect("Should read first number"), - 130u64 - ); - assert_eq!( - read::unsigned(&mut readable).expect("Should read first number"), - 1u64 - ); - } - - #[test] - fn test_read_u16() { - for (buf, val) in [ - (&[2][..], 2), - (&[0x7f][..], 0x7f), - (&[0x80, 1][..], 0x80), - (&[0x81, 1][..], 0x81), - (&[0x82, 1][..], 0x82), - (&[0xff, 0x7f][..], 0x3fff), - (&[0x80, 0x80, 1][..], 0x4000), - (&[0xff, 0xff, 1][..], 0x7fff), - (&[0xff, 0xff, 3][..], 0xffff), - ] - .iter() - { - let mut readable = EndianSlice::new(buf, NativeEndian); - assert_eq!(*val, read::u16(&mut readable).expect("Should read number")); - } - - for buf in [ - &[0x80][..], - &[0x80, 0x80][..], - &[0x80, 0x80, 4][..], - &[0x80, 0x80, 0x80, 3][..], - ] - .iter() - { - let mut readable = EndianSlice::new(buf, NativeEndian); - assert!(read::u16(&mut readable).is_err(), "{:?}", buf); - } - } -} -- cgit v1.2.3