ZDICT_analyzePos: make buffer a slice

Author: michielp1807

lib/dictBuilder/zdict.rs

@@ -5,7 +5,7 @@ use libc::{free, malloc, memcpy, size_t};
 use crate::lib::common::bits::{ZSTD_NbCommonBytes, ZSTD_highbit32};
 use crate::lib::common::error_private::{ERR_getErrorName, ERR_isError, Error};
 use crate::lib::common::huf::{HUF_CElt, HUF_CTABLE_WORKSPACE_SIZE_U32, HUF_WORKSPACE_SIZE};
-use crate::lib::common::mem::{MEM_read16, MEM_read64, MEM_readLE32, MEM_readST, MEM_writeLE32};
+use crate::lib::common::mem::{MEM_read64, MEM_readLE32, MEM_readST, MEM_writeLE32};
 use crate::lib::common::xxhash::ZSTD_XXH64;
 use crate::lib::common::zstd_internal::{
     repStartValue, LLFSELog, MLFSELog, MaxLL, MaxML, OffFSELog, ZSTD_REP_NUM,
@@ -151,12 +151,11 @@ unsafe fn ZDICT_analyzePos(
     doneMarks: &mut [bool],
     suffix_slice: &[u32],
     mut start: u32,
-    buffer: *const core::ffi::c_void,
+    buffer: &[u8],
     minRatio: u32,
     notificationLevel: u32,
 ) -> DictItem {
     let mut lengthList = [0u32; LLIMIT];
-    let b = buffer as *const u8;
     let mut maxLength = LLIMIT;
 
     // The C implementation maps index `len` and `-1` to the length of the suffix array.
@@ -175,23 +174,18 @@ unsafe fn ZDICT_analyzePos(
     doneMarks[pos] = true;
 
     // trivial repetition cases
-    if MEM_read16(b.add(pos) as *const core::ffi::c_void) as core::ffi::c_int
-        == MEM_read16(b.add(pos).add(2) as *const core::ffi::c_void) as core::ffi::c_int
-        || MEM_read16(b.add(pos).add(1) as *const core::ffi::c_void) as core::ffi::c_int
-            == MEM_read16(b.add(pos).add(3) as *const core::ffi::c_void) as core::ffi::c_int
-        || MEM_read16(b.add(pos).add(2) as *const core::ffi::c_void) as core::ffi::c_int
-            == MEM_read16(b.add(pos).add(4) as *const core::ffi::c_void) as core::ffi::c_int
+    if buffer[pos..pos + 2] == buffer[pos + 2..pos + 4]
+        || buffer[pos + 1..pos + 3] == buffer[pos + 3..pos + 5]
+        || buffer[pos + 2..pos + 4] == buffer[pos + 4..pos + 6]
     {
         // skip and mark segment
-        let pattern16 = MEM_read16(b.add(pos).add(4) as *const core::ffi::c_void);
+        let pattern16 = &buffer[pos + 4..pos + 6];
         let mut patternEnd = 6usize;
-        while MEM_read16(b.add(pos).add(patternEnd) as *const core::ffi::c_void) == pattern16 {
-            patternEnd = patternEnd.wrapping_add(2);
+        while buffer[pos + patternEnd..pos + patternEnd + 2] == *pattern16 {
+            patternEnd += 2;
         }
-        if *b.add(pos.wrapping_add(patternEnd as size_t))
-            == *b.add(pos.wrapping_add(patternEnd as size_t).wrapping_sub(1))
-        {
-            patternEnd = patternEnd.wrapping_add(1);
+        if buffer[pos + patternEnd] == buffer[pos + patternEnd - 1] {
+            patternEnd += 1;
         }
         doneMarks[pos..][1..patternEnd].fill(true);
         return solution;
@@ -202,8 +196,8 @@ unsafe fn ZDICT_analyzePos(
     loop {
         end = end.wrapping_add(1);
         length = ZDICT_count(
-            b.add(pos) as *const core::ffi::c_void,
-            b.offset(suffix(end as usize) as isize) as *const core::ffi::c_void,
+            buffer[pos..].as_ptr() as *const core::ffi::c_void,
+            buffer[suffix(end as usize) as usize..].as_ptr() as *const core::ffi::c_void,
         );
         if length < MINMATCHLENGTH {
             break;
@@ -214,8 +208,9 @@ unsafe fn ZDICT_analyzePos(
     let mut length_0: size_t = 0;
     loop {
         length_0 = ZDICT_count(
-            b.add(pos) as *const core::ffi::c_void,
-            b.offset(suffix((start as usize).wrapping_sub(1)) as isize) as *const core::ffi::c_void,
+            buffer[pos..].as_ptr() as *const core::ffi::c_void,
+            buffer[suffix((start as usize).wrapping_sub(1)) as usize..].as_ptr()
+                as *const core::ffi::c_void,
         );
         if length_0 >= MINMATCHLENGTH {
             start = start.wrapping_sub(1);
@@ -258,13 +253,13 @@ unsafe fn ZDICT_analyzePos(
         let mut selectedID = currentID;
 
         for id in refinedStart..refinedEnd {
-            if *b.offset((suffix(id as usize)).wrapping_add(mml) as isize) != currentChar {
+            if buffer[(suffix(id as usize) + mml) as usize] != currentChar {
                 if currentCount > selectedCount {
                     selectedCount = currentCount;
                     selectedID = currentID;
                 }
                 currentID = id;
-                currentChar = *b.offset((suffix(id as usize)).wrapping_add(mml) as isize);
+                currentChar = buffer[(suffix(id as usize) + mml) as usize];
                 currentCount = 0;
             }
             currentCount = currentCount.wrapping_add(1);
@@ -291,8 +286,8 @@ unsafe fn ZDICT_analyzePos(
     loop {
         end = end.wrapping_add(1);
         let mut length = ZDICT_count(
-            b.add(pos) as *const core::ffi::c_void,
-            b.offset(suffix(end as usize) as isize) as *const core::ffi::c_void,
+            buffer[pos..].as_ptr() as *const core::ffi::c_void,
+            buffer[suffix(end as usize) as usize..].as_ptr() as *const core::ffi::c_void,
         );
         if length >= LLIMIT {
             length = LLIMIT - 1;
@@ -307,8 +302,9 @@ unsafe fn ZDICT_analyzePos(
     let mut length_2 = MINMATCHLENGTH;
     while (length_2 >= MINMATCHLENGTH) as core::ffi::c_int & (start > 0) as core::ffi::c_int != 0 {
         length_2 = ZDICT_count(
-            b.add(pos) as *const core::ffi::c_void,
-            b.offset(suffix(start.wrapping_sub(1) as usize) as isize) as *const core::ffi::c_void,
+            buffer[pos..].as_ptr() as *const core::ffi::c_void,
+            buffer[suffix(start.wrapping_sub(1) as usize) as usize..].as_ptr()
+                as *const core::ffi::c_void,
         );
         if length_2 >= LLIMIT {
             length_2 = LLIMIT - 1;
@@ -340,10 +336,8 @@ unsafe fn ZDICT_analyzePos(
 
     // reduce maxLength in case of final into repetitive data
     let mut l = maxLength as u32;
-    let c = *b.add(pos.wrapping_add(maxLength).wrapping_sub(1));
-    while *b.add(pos.wrapping_add(l as size_t).wrapping_sub(2)) as core::ffi::c_int
-        == c as core::ffi::c_int
-    {
+    let c = buffer[pos + maxLength - 1];
+    while buffer[pos + l as usize - 2] == c {
         l = l.wrapping_sub(1);
     }
     maxLength = l as size_t;
@@ -383,8 +377,8 @@ unsafe fn ZDICT_analyzePos(
             length_3 = solution.length;
         } else {
             length_3 = ZDICT_count(
-                b.add(pos) as *const core::ffi::c_void,
-                b.offset(testedPos as isize) as *const core::ffi::c_void,
+                buffer[pos..].as_ptr() as *const core::ffi::c_void,
+                buffer[testedPos as usize..].as_ptr() as *const core::ffi::c_void,
             ) as u32;
             if length_3 > solution.length {
                 length_3 = solution.length;
@@ -568,7 +562,7 @@ unsafe fn ZDICT_dictSize(dictList: *const DictItem) -> u32 {
 unsafe fn ZDICT_trainBuffer_legacy(
     dictList: *mut DictItem,
     dictListSize: u32,
-    buffer: *const core::ffi::c_void,
+    buffer: &[u8],
     mut bufferSize: size_t,
     fileSizes: *const size_t,
     mut nbFiles: core::ffi::c_uint,
@@ -609,7 +603,7 @@ unsafe fn ZDICT_trainBuffer_legacy(
     }
     let mut suffix = vec![0u32; bufferSize];
     let divSuftSortResult = divsufsort(
-        core::slice::from_raw_parts(buffer as *const u8, bufferSize),
+        &buffer[..bufferSize],
         std::mem::transmute::<&mut [u32], &mut [i32]>(&mut suffix),
         false,
     );
@@ -660,7 +654,7 @@ unsafe fn ZDICT_trainBuffer_legacy(
             continue;
         }
 
-        ZDICT_insertDictItem(dictList, dictListSize, solution, buffer);
+        ZDICT_insertDictItem(dictList, dictListSize, solution, buffer.as_ptr().cast());
         cursor += solution.length as usize;
 
         if notificationLevel >= 2 && displayClock.elapsed() > refresh_rate {
@@ -1350,11 +1344,14 @@ unsafe fn ZDICT_trainFromBuffer_unsafe_legacy(
 
     dictList.as_mut().unwrap().init();
 
+    // The samples must be followed by the noise band.
+    debug_assert!(samples.len() >= samplesBuffSize + NOISELENGTH);
+
     // build dictionary
     ZDICT_trainBuffer_legacy(
         dictList,
         dictListSize,
-        samples.as_ptr() as *mut core::ffi::c_void,
+        samples,
         samplesBuffSize,
         samplesSizes.as_ptr(),
         nbSamples,