Removing unecessary unsafe blocks

darleybarreto

Jul 25, 2021, 5:51 PM

GKNZUJV6XUPOHKZEOOPOWMCYRBTMR36WTLOBEIPWZ55DX6SRUAVAC

Dependencies

• [2] K6L5F26W Fixing sequential test.
• [3] HEFGMMUM Start oxidizing 1/N
• [4] IH334Q5A Reboot
• [5] IB4L4N5M Fixing the lifetimes for `Seekable`
• [6] SZHL3TSD Fixing tests
• [7] HA3ODU4G Fixing compilation

Change contents

• replacement in src/lib.rs at line 346
  [3.6521]→[2.2760:2828](∅→∅)
  − let result = self.framelog.write_seek_table(&mut output_)?;
  [3.6521]

  [2.2828]
  + let result = self.framelog.write_seek_table(output, &mut output_.pos)?;
• replacement in src/lib.rs at line 591
  [3.11482]→[3.11482:11639](∅→∅)
  − // FIXME: replace this pointer arithmetic with something safer

  − unsafe { (buffer_ptr.add(pos)).copy_to(buffer_ptr, offset) };
  [3.11482]

  [3.11639]
  + self.in_buff.copy_within(offset..offset+to_read,pos);
• replacement in src/lib.rs at line 594
  [3.476]→[2.4419:4631](∅→∅)
  − // FIXME: if pointer arithmetic were to be replaced, this needs to change

  − handle

  − .read(unsafe { slice::from_raw_parts_mut(buffer_ptr.add(offset), to_read) })?;
  [3.476]

  [3.11896]
  + handle.read(&mut self.in_buff[offset..offset+to_read])?;
• replacement in src/lib.rs at line 688
  [3.14615]→[3.14615:14725](∅→∅)
  − let mut out_tmp = if self.decompressed_offset < offset {

  − ZSTD_outBuffer {
  [3.14615]

  [3.14725]
  + // here slice_tmp is a [u8] helper so we avoid using unsafe pointer arithmetic later on

  + let (mut out_tmp, slice_tmp) = if self.decompressed_offset < offset {

  + (ZSTD_outBuffer {
• replacement in src/lib.rs at line 697
  [3.15019]→[3.15019:15041](∅→∅)
  − }
  [3.15019]

  [3.15041]
  + }, (&self.out_buff).as_ref())
• replacement in src/lib.rs at line 699
  [3.15066]→[3.15066:15103](∅→∅)
  − ZSTD_outBuffer {
  [3.15066]

  [2.5472]
  + (ZSTD_outBuffer {
• replacement in src/lib.rs at line 703
  [3.15263]→[3.15263:15285](∅→∅)
  − }
  [3.15263]

  [3.15285]
  + }, &*out)
• replacement in src/lib.rs at line 718
  [3.15672]→[3.15672:16075](∅→∅)
  − // FIXME: replace this pointer arithmetic with something safer

  − let tmp: &[u8] = unsafe {

  − slice::from_raw_parts_mut(

  − (out_tmp.dst as *mut u8).add(prev_out_pos),

  − out_tmp.pos - prev_out_pos,

  − )

  − };

  − self.xxh_state.write(tmp)
  [3.15672]

  [3.16075]
  + self.xxh_state.write(&slice_tmp[prev_out_pos..prev_out_pos+(out_tmp.pos - prev_out_pos)]);
• replacement in src/lib.rs at line 941
  [3.22109]→[2.7167:7264](∅→∅)
  − pub fn stwrite32(&mut self, output: &mut ZSTD_outBuffer, value: u32, offset: u32) -> usize {
  [3.22109]

  [2.7264]
  + pub fn stwrite32(&mut self, output: &mut [u8], value: u32, offset: u32, pos: &mut usize) -> usize {
• replacement in src/lib.rs at line 944
  [3.22344]→[3.22344:22386](∅→∅)
  − output.size - output.pos,
  [3.22344]

  [2.7311]
  + output.len() - *pos,
• replacement in src/lib.rs at line 948
  [3.260252]→[3.22461:22557](∅→∅),[3.22557]→[2.7373:7525](∅→∅)
  − // FIXME: replace this pointer arithmetic with something safer

  − unsafe {

  − let base = output.dst.add(output.pos) as *mut u8;

  − ptr::copy(value.to_ne_bytes().as_ptr(),base,len_write);

  − }
  [3.260252]

  [3.22818]
  + output[*pos..*pos+len_write].copy_from_slice(&value.to_ne_bytes());
• replacement in src/lib.rs at line 950
  [3.22819]→[3.22819:22856](∅→∅)
  − output.pos += len_write;
  [3.22819]

  [2.7526]
  + *pos += len_write;
• replacement in src/lib.rs at line 970
  [3.23116]→[3.23116:23182](∅→∅)
  − while let Ok(ret) = self.write_seek_table(&mut output_) {
  [3.23116]

  [3.23182]
  + while let Ok(ret) = self.write_seek_table(&mut output, &mut output_.pos) {
• replacement in src/lib.rs at line 983
  [3.23322]→[3.23322:23416](∅→∅)
  − pub fn write_seek_table(&mut self, output: &mut ZSTD_outBuffer) -> Result<usize, Error> {
  [3.23322]

  [3.23416]
  + pub fn write_seek_table(&mut self, output: &mut [u8], pos: &mut usize) -> Result<usize, Error> {
• replacement in src/lib.rs at line 987
  [3.23541]→[3.23541:23626](∅→∅)
  − let mut ret: usize = self.stwrite32(output, MAGIC_SKIPPABLE_START | 0xE, 0);
  [3.23541]

  [3.23626]
  + let mut ret: usize = self.stwrite32(output, MAGIC_SKIPPABLE_START | 0xE, 0, pos);
• replacement in src/lib.rs at line 994
  [3.23734]→[2.7580:7665](∅→∅)
  − ret = self.stwrite32(output, (table_len - SKIPPABLE_HEADER_SIZE) as u32, 4);
  [3.23734]

  [3.23810]
  + ret = self.stwrite32(output, (table_len - SKIPPABLE_HEADER_SIZE) as u32, 4, pos);
• replacement in src/lib.rs at line 1005
  [3.24080]→[2.7742:7815](∅→∅)
  − ret = self.stwrite32(output, self.entries[i].c_size, start);
  [3.24080]

  [3.24162]
  + ret = self.stwrite32(output, self.entries[i].c_size, start, pos);
• replacement in src/lib.rs at line 1010
  [3.24236]→[2.7816:7893](∅→∅)
  − ret = self.stwrite32(output, self.entries[i].d_size, start + 4);
  [3.24236]

  [3.24322]
  + ret = self.stwrite32(output, self.entries[i].d_size, start + 4, pos);
• replacement in src/lib.rs at line 1016
  [3.24437]→[2.7894:7984](∅→∅)
  − ret = self.stwrite32(output, self.entries[i].checksum as u32, start + 8);
  [3.24437]

  [3.24529]
  + ret = self.stwrite32(output, self.entries[i].checksum as u32, start + 8, pos);
• edit in src/lib.rs at line 1032
  [2.8081]

  [3.24878]
  + pos
• replacement in src/lib.rs at line 1038
  [3.24951]→[3.24951:24993](∅→∅)
  − if output.size - output.pos < 1 {
  [3.24951]

  [3.24993]
  + if output.len() - *pos < 1 {
• replacement in src/lib.rs at line 1044
  [3.25180]→[3.25180:25279](∅→∅),[3.25279]→[2.8145:8182](∅→∅),[2.8182]→[3.25444:25473](∅→∅),[3.25444]→[3.25444:25473](∅→∅)
  − let array = unsafe { slice::from_raw_parts_mut(output.dst as *mut u8, output.size) };

  −

  − array[output.pos] = sfd;

  − output.pos += 1;
  [3.25180]

  [2.8183]
  + output[*pos] = sfd;

  + *pos += 1;
• replacement in src/lib.rs at line 1049
  [3.25484]→[2.8222:8307](∅→∅)
  − ret = self.stwrite32(output, SEEKABLE_MAGIC_NUMBER, (table_len - 4) as u32);
  [3.25484]

  [3.25560]
  + ret = self.stwrite32(output, SEEKABLE_MAGIC_NUMBER, (table_len - 4) as u32, pos);
• replacement in src/lib.rs at line 1121
  [3.263818]→[2.8725:10350](∅→∅)
  − // #[test]

  − // fn test() {

  − // let mut cstream = SeekableCStream::new(10, 256).unwrap();

  − // let input = b"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Ut diam ante, sollicitudin a dolor et, volutpat elementum nulla. Etiam nec efficitur nibh, quis rutrum risus. Maecenas quis lorem malesuada, aliquet mi vel, viverra nunc. Donec et nulla sed velit sagittis varius. Suspendisse vestibulum, neque lobortis ornare vestibulum, orci turpis vulputate nisi, ut sodales neque purus eget magna. Nunc condimentum, diam eu consequat venenatis, est nisl semper lorem, et lobortis velit justo sed nulla. Nunc sit amet tempor nunc, vel posuere ipsum. Cras erat tortor, pulvinar ac pretium eu, auctor ac nibh. Duis iaculis porta magna, eu lobortis elit. Duis vitae massa eros. Nulla non magna accumsan, egestas quam sit amet, laoreet lectus.";

  − // let mut input_pos = 0;

  − // let mut output = vec![0; input.len()];

  − // let mut output_pos = 0;

  − // while input_pos < input.len() {

  − // let (a, b) = cstream

  − // .compress(&mut output[output_pos..], &input[input_pos..])

  − // .unwrap();

  − // output_pos += a;

  − // input_pos += b;

  − // }

  − // while let Ok(n) = cstream.end_stream(&mut output[output_pos..]) {

  − // if n == 0 {

  − // break;

  − // }

  − // output_pos += n;

  − // }

  − // output.truncate(output_pos);

  − // {

  − // use std::io::Write;

  − // let mut file = std::fs::File::create("test").unwrap();

  − // file.write_all(&output).unwrap();

  − // }

  − // println!("input len = {:?}, pos = {:?}", input.len(), output_pos);
  [3.263818]

  [3.265]
  + #[test]

  + fn test() {

  + let mut cstream = SeekableCStream::new(10, 256).unwrap();

  + let input = b"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Ut diam ante, sollicitudin a dolor et, volutpat elementum nulla. Etiam nec efficitur nibh, quis rutrum risus. Maecenas quis lorem malesuada, aliquet mi vel, viverra nunc. Donec et nulla sed velit sagittis varius. Suspendisse vestibulum, neque lobortis ornare vestibulum, orci turpis vulputate nisi, ut sodales neque purus eget magna. Nunc condimentum, diam eu consequat venenatis, est nisl semper lorem, et lobortis velit justo sed nulla. Nunc sit amet tempor nunc, vel posuere ipsum. Cras erat tortor, pulvinar ac pretium eu, auctor ac nibh. Duis iaculis porta magna, eu lobortis elit. Duis vitae massa eros. Nulla non magna accumsan, egestas quam sit amet, laoreet lectus.";

  + let mut input_pos = 0;

  + let mut output = vec![0; input.len()];

  + let mut output_pos = 0;

  + while input_pos < input.len() {

  + let (a, b) = cstream

  + .compress(&mut output[output_pos..], &input[input_pos..])

  + .unwrap();

  + output_pos += a;

  + input_pos += b;

  + }

  + while let Ok(n) = cstream.end_stream(&mut output[output_pos..]) {

  + if n == 0 {

  + break;

  + }

  + output_pos += n;

  + }

  + output.truncate(output_pos);

  + {

  + use std::io::Write;

  + let mut file = std::fs::File::create("test").unwrap();

  + file.write_all(&output).unwrap();

  + }

  + println!("input len = {:?}, pos = {:?}", input.len(), output_pos);
• replacement in src/lib.rs at line 1149
  [3.266]→[2.10351:10932](∅→∅)
  − // let mut decomp = Vec::new();

  − // let mut s = { Seekable::init_buf(&mut output).unwrap() };

  − // for frame in 0..s.get_num_frames() {

  − // let size = s.get_frame_decompressed_size(frame).unwrap();

  − // println!("{:?} {:?}", size, s.get_frame_decompressed_offset(frame).unwrap());

  − // let n = decomp.len();

  − // decomp.extend(std::iter::repeat(0).take(size));

  − // s.decompress_frame(&mut decomp[n..], frame).unwrap();

  − // }

  − // println!("{:?}", std::str::from_utf8(&decomp).unwrap());

  − // assert_eq!(&input[..], &decomp[..])

  − // }
  [3.266]
  + let mut decomp = Vec::new();

  + let mut s = { Seekable::init_buf(&mut output).unwrap() };

  + for frame in 0..s.get_num_frames() {

  + let size = s.get_frame_decompressed_size(frame).unwrap();

  + println!("{:?} {:?}", size, s.get_frame_decompressed_offset(frame).unwrap());

  + let n = decomp.len();

  + decomp.extend(std::iter::repeat(0).take(size));

  + s.decompress_frame(&mut decomp[n..], frame).unwrap();

  + }

  + println!("{:?}", std::str::from_utf8(&decomp).unwrap());

  + assert_eq!(&input[..], &decomp[..])

  + }