Merge pull request #204 from nyurik/rm-dead-code

Remove dead code

Author: danielrh

src/enc/backward_references/hash_to_binary_tree.rs

@@ -1,5 +1,3 @@
-#![allow(dead_code)]
-
 use alloc::{Allocator, SliceWrapper, SliceWrapperMut};
 use core;
 use core::cmp::min;

src/enc/backward_references/hq.rs

@@ -1,5 +1,3 @@
-#![allow(dead_code)]
-
 use alloc::{Allocator, SliceWrapper, SliceWrapperMut};
 use core;
 use core::cmp::{max, min};
@@ -9,8 +7,7 @@ use super::hash_to_binary_tree::{
     Union1, ZopfliNode, H10,
 };
 use super::{
-    kDistanceCacheIndex, kDistanceCacheOffset, kHashMul32, kInvalidMatch, AnyHasher,
-    BrotliEncoderParams,
+    kDistanceCacheIndex, kDistanceCacheOffset, kInvalidMatch, AnyHasher, BrotliEncoderParams,
 };
 use crate::enc::combined_alloc::{alloc_if, alloc_or_default};
 use crate::enc::command::{
@@ -22,7 +19,6 @@ use crate::enc::encode;
 use crate::enc::literal_cost::BrotliEstimateBitCostsForLiterals;
 use crate::enc::static_dict::{
     BrotliDictionary, BrotliFindAllStaticDictionaryMatches, FindMatchLengthWithLimit,
-    BROTLI_UNALIGNED_LOAD32,
 };
 use crate::enc::util::{floatX, FastLog2, FastLog2f64};
 
@@ -256,12 +252,6 @@ impl<AllocF: Allocator<floatX>> ZopfliCostModel<AllocF> {
     }
 }
 
-#[inline(always)]
-fn HashBytesH10(data: &[u8]) -> u32 {
-    let h: u32 = BROTLI_UNALIGNED_LOAD32(data).wrapping_mul(kHashMul32);
-    h >> (32i32 - 17i32)
-}
-
 pub fn StitchToPreviousBlockH10<
     AllocU32: Allocator<u32>,
     Buckets: Allocable<u32, AllocU32> + SliceWrapperMut<u32> + SliceWrapper<u32>,

src/enc/backward_references/mod.rs

@@ -1,5 +1,3 @@
-#![allow(dead_code)]
-
 mod benchmark;
 pub mod hash_to_binary_tree;
 pub mod hq;
@@ -18,8 +16,6 @@ use super::static_dict::{
 use super::util::{floatX, Log2FloorNonZero};
 use crate::enc::combined_alloc::allocate;
 
-static kBrotliMinWindowBits: i32 = 10;
-static kBrotliMaxWindowBits: i32 = 24;
 pub static kInvalidMatch: u32 = 0x0fff_ffff;
 static kCutoffTransformsCount: u32 = 10;
 static kCutoffTransforms: u64 = 0x071b_520a_da2d_3200;
@@ -1281,6 +1277,8 @@ impl<
         }
         ix_start
     }
+
+    #[cfg(feature = "benchmark")]
     fn BulkStoreRangeOptMemFetchLazyDupeUpdate(
         &mut self,
         data: &[u8],
@@ -1363,6 +1361,8 @@ impl<
         }
         ix_start
     }
+
+    #[cfg(feature = "benchmark")]
     fn BulkStoreRangeOptRandomDupeUpdate(
         &mut self,
         data: &[u8],
@@ -1821,19 +1821,9 @@ pub struct H42 {
     pub head: [u16; 32768],
     pub tiny_hash: [u8; 65536],
     pub banks: [BankH42; 512],
-    free_slot_idx: [u16; 512],
     pub max_hops: usize,
 }
 
-fn unopt_ctzll(mut val: usize) -> u8 {
-    let mut cnt: u8 = 0u8;
-    while val & 1 == 0usize {
-        val >>= 1i32;
-        cnt = (cnt as i32 + 1) as u8;
-    }
-    cnt
-}
-
 fn BackwardReferenceScoreUsingLastDistance(copy_length: usize, h9_opts: H9Opts) -> u64 {
     ((h9_opts.literal_byte_score as u64) >> 2)
         .wrapping_mul(copy_length as u64)

src/enc/bit_cost.rs

@@ -1,5 +1,3 @@
-#![allow(dead_code)]
-
 use core::cmp::{max, min};
 
 use super::super::alloc::SliceWrapper;
@@ -8,18 +6,6 @@ use super::util::{FastLog2, FastLog2u16};
 use super::vectorization::Mem256i;
 use crate::enc::floatX;
 
-static kCopyBase: [u32; 24] = [
-    2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 18, 22, 30, 38, 54, 70, 102, 134, 198, 326, 582, 1094, 2118,
-];
-
-static kCopyExtra: [u32; 24] = [
-    0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 7, 8, 9, 10, 24,
-];
-
-static kBrotliMinWindowBits: i32 = 10i32;
-
-static kBrotliMaxWindowBits: i32 = 24i32;
-
 pub fn ShannonEntropy(mut population: &[u32], size: usize, total: &mut usize) -> floatX {
     let mut sum: usize = 0usize;
     let mut retval: floatX = 0.0;

src/enc/block_split.rs

@@ -1,5 +1,3 @@
-#![allow(dead_code)]
-
 use super::super::alloc;
 use super::super::alloc::{Allocator, SliceWrapper};
 use crate::enc::combined_alloc::alloc_default;

src/enc/block_splitter.rs

@@ -1,5 +1,3 @@
-#![allow(dead_code)]
-
 use core;
 use core::cmp::{max, min};
 #[cfg(feature = "simd")]

src/enc/brotli_bit_stream.rs

@@ -1,5 +1,4 @@
 #![allow(unknown_lints)]
-#![allow(dead_code)]
 #![allow(unused_macros)]
 
 use core::cmp::{max, min};
@@ -49,48 +48,10 @@ fn window_size_from_lgwin(lgwin: i32) -> usize {
     (1 << lgwin) - 16usize
 }
 
-fn context_type_str(context_type: ContextType) -> &'static str {
-    match context_type {
-        ContextType::CONTEXT_LSB6 => "lsb6",
-        ContextType::CONTEXT_MSB6 => "msb6",
-        ContextType::CONTEXT_UTF8 => "utf8",
-        ContextType::CONTEXT_SIGNED => "sign",
-    }
-}
-
-fn prediction_mode_str(
-    prediction_mode_nibble: interface::LiteralPredictionModeNibble,
-) -> &'static str {
-    match prediction_mode_nibble.prediction_mode() {
-        interface::LITERAL_PREDICTION_MODE_SIGN => "sign",
-        interface::LITERAL_PREDICTION_MODE_LSB6 => "lsb6",
-        interface::LITERAL_PREDICTION_MODE_MSB6 => "msb6",
-        interface::LITERAL_PREDICTION_MODE_UTF8 => "utf8",
-        _ => "unknown",
-    }
-}
-
-fn is_long_enough_to_be_random(len: usize, high_entropy_detection_quality: u8) -> bool {
-    match high_entropy_detection_quality {
-        0 => false,
-        1 => false,
-        2 => len >= 128,
-        3 => len >= 96,
-        4 => len >= 64,
-        5 => len >= 48,
-        6 => len >= 32,
-        7 => len >= 24,
-        8 => len >= 16,
-        9 => len >= 8,
-        10 => len >= 4,
-        11 => len >= 1,
-        _ => len >= 8,
-    }
-}
-const COMMAND_BUFFER_SIZE: usize = 4096;
-
 struct CommandQueue<'a, Alloc: BrotliAlloc + 'a> {
     mb: InputPair<'a>,
+    // TODO: delete unused fields
+    #[allow(dead_code)]
     mb_byte_offset: usize,
     mc: &'a mut Alloc,
     queue: <Alloc as Allocator<StaticCommand>>::AllocatedMemory,
@@ -100,9 +61,12 @@ struct CommandQueue<'a, Alloc: BrotliAlloc + 'a> {
     best_strides_per_block_type: <Alloc as Allocator<u8>>::AllocatedMemory,
     entropy_pyramid: find_stride::EntropyPyramid<Alloc>,
     context_map_entropy: ContextMapEntropy<'a, Alloc>,
+    #[allow(dead_code)]
     stride_detection_quality: u8,
+    #[allow(dead_code)]
     high_entropy_detection_quality: u8,
     block_type_literal: u8,
+    #[allow(dead_code)]
     best_stride_index: usize,
     overfull: bool,
 }
@@ -149,9 +113,6 @@ impl<'a, Alloc: BrotliAlloc> CommandQueue<'a, Alloc> {
             self.overfull = true;
         }
     }
-    fn size(&self) -> usize {
-        self.loc
-    }
     fn clear(&mut self) {
         self.loc = 0;
         self.block_type_literal = 0;
@@ -2435,8 +2396,6 @@ fn StoreDataWithHuffmanCodes(
     }
 }
 
-fn nop<'a>(_data: &[interface::Command<InputReference>]) {}
-
 #[deprecated(note = "use store_meta_block_trivial instead")]
 pub fn BrotliStoreMetaBlockTrivial<Alloc: BrotliAlloc, Cb>(
     alloc: &mut Alloc,

src/enc/cluster.rs

@@ -1,5 +1,3 @@
-#![allow(dead_code)]
-
 use alloc::{Allocator, SliceWrapper, SliceWrapperMut};
 use core::cmp::min;
 

src/enc/compress_fragment.rs

@@ -1,5 +1,3 @@
-#![allow(dead_code)]
-
 use core::cmp::min;
 
 //caution: lots of the functions look structurally the same as two_pass,

src/enc/compress_fragment_two_pass.rs

@@ -1,5 +1,3 @@
-#![allow(dead_code)]
-
 use core;
 use core::cmp::min;