emo/busybox
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

gzip: "compressed_len" is unused, stop wasting code and time calculating it

Browse Source 
function                                             old     new   delta
flush_block                                          595     523     -72

Signed-off-by: Denys Vlasenko <vda.linux@googlemail.com>
This commit is contained in:
Denys Vlasenko 2018-01-31 23:26:11 +01:00
parent a142926029
commit 54a174eb01
1 changed files with 31 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

93
archival/gzip.c
View File

@ -93,7 +93,6 @@ aa: 85.1% -- replaced with aa.gz
#include "libbb.h" #include "libbb.h"
#include "bb_archive.h" #include "bb_archive.h"
/* =========================================================================== /* ===========================================================================
*/ */
//#define DEBUG 1 //#define DEBUG 1
@ -115,7 +114,6 @@ static int verbose;
# define Tracecv(c,x) # define Tracecv(c,x)
#endif #endif
/* =========================================================================== /* ===========================================================================
*/ */
#if CONFIG_GZIP_FAST == 0 #if CONFIG_GZIP_FAST == 0
@ -211,7 +209,6 @@ static int verbose;
# define MAX_SUFFIX 30 # define MAX_SUFFIX 30
#endif #endif
/* =========================================================================== /* ===========================================================================
* Compile with MEDIUM_MEM to reduce the memory requirements or * Compile with MEDIUM_MEM to reduce the memory requirements or
* with SMALL_MEM to use as little memory as possible. Use BIG_MEM if the * with SMALL_MEM to use as little memory as possible. Use BIG_MEM if the
@ -220,15 +217,14 @@ static int verbose;
* affects the compression ratio. The compressed output * affects the compression ratio. The compressed output
* is still correct, and might even be smaller in some cases. * is still correct, and might even be smaller in some cases.
*/ */
#ifdef SMALL_MEM #ifdef SMALL_MEM
# define HASH_BITS 13 /* Number of bits used to hash strings */ # define HASH_BITS 13 /* Number of bits used to hash strings */
#endif #endif
#ifdef MEDIUM_MEM #ifdef MEDIUM_MEM
# define HASH_BITS 14 # define HASH_BITS 14
#endif #endif
#ifndef HASH_BITS #ifndef HASH_BITS
# define HASH_BITS 15 # define HASH_BITS 15
/* For portability to 16 bit machines, do not use values above 15. */ /* For portability to 16 bit machines, do not use values above 15. */
#endif #endif
@ -241,7 +237,6 @@ static int verbose;
#endif #endif
/* Matches of length 3 are discarded if their distance exceeds TOO_FAR */ /* Matches of length 3 are discarded if their distance exceeds TOO_FAR */
/* =========================================================================== /* ===========================================================================
* These types are not really 'char', 'short' and 'long' * These types are not really 'char', 'short' and 'long'
*/ */
@ -298,7 +293,6 @@ enum {
#endif /* ENABLE_FEATURE_GZIP_LEVELS */ #endif /* ENABLE_FEATURE_GZIP_LEVELS */
}; };
struct globals { struct globals {
/* =========================================================================== */ /* =========================================================================== */
/* global buffers, allocated once */ /* global buffers, allocated once */
@ -419,7 +413,6 @@ struct globals {
#define G1 (*(ptr_to_globals - 1)) #define G1 (*(ptr_to_globals - 1))
/* =========================================================================== /* ===========================================================================
* Write the output buffer outbuf[0..outcnt-1] and update bytes_out. * Write the output buffer outbuf[0..outcnt-1] and update bytes_out.
* (used for the compressed data only) * (used for the compressed data only)
@ -433,7 +426,6 @@ static void flush_outbuf(void)
G1.outcnt = 0; G1.outcnt = 0;
} }
/* =========================================================================== /* ===========================================================================
*/ */
/* put_8bit is used for the compressed output */ /* put_8bit is used for the compressed output */
@ -517,7 +509,6 @@ static void updcrc(uch * s, unsigned n)
G1.crc = crc32_block_endian0(G1.crc, s, n, global_crc32_table /*G1.crc_32_tab*/); G1.crc = crc32_block_endian0(G1.crc, s, n, global_crc32_table /*G1.crc_32_tab*/);
} }
/* =========================================================================== /* ===========================================================================
* Read a new buffer from the current input file, perform end-of-line * Read a new buffer from the current input file, perform end-of-line
* translation, and update the crc and input file size. * translation, and update the crc and input file size.
@ -538,7 +529,6 @@ static unsigned file_read(void *buf, unsigned size)
return len; return len;
} }
/* =========================================================================== /* ===========================================================================
* Send a value on a given number of bits. * Send a value on a given number of bits.
* IN assertion: length <= 16 and value fits in length bits. * IN assertion: length <= 16 and value fits in length bits.
@ -578,7 +568,6 @@ static void send_bits(unsigned value, unsigned length)
G1.bi_valid = length; G1.bi_valid = length;
} }
/* =========================================================================== /* ===========================================================================
* Reverse the first len bits of a code, using straightforward code (a faster * Reverse the first len bits of a code, using straightforward code (a faster
* method would use a table) * method would use a table)
@ -596,7 +585,6 @@ static unsigned bi_reverse(unsigned code, int len)
} }
} }
/* =========================================================================== /* ===========================================================================
* Write out any remaining bits in an incomplete byte. * Write out any remaining bits in an incomplete byte.
*/ */
@ -615,7 +603,6 @@ static void bi_windup(void)
DEBUG_bits_sent(= (G1.bits_sent + 7) & ~7); DEBUG_bits_sent(= (G1.bits_sent + 7) & ~7);
} }
/* =========================================================================== /* ===========================================================================
* Copy a stored block to the zip file, storing first the length and its * Copy a stored block to the zip file, storing first the length and its
* one's complement if requested. * one's complement if requested.
@ -638,7 +625,6 @@ static void copy_block(char *buf, unsigned len, int header)
flush_outbuf_if_32bit_optimized(); flush_outbuf_if_32bit_optimized();
} }
/* =========================================================================== /* ===========================================================================
* Fill the window when the lookahead becomes insufficient. * Fill the window when the lookahead becomes insufficient.
* Updates strstart and lookahead, and sets eofile if end of input file. * Updates strstart and lookahead, and sets eofile if end of input file.
@ -703,7 +689,6 @@ static void fill_window_if_needed(void)
fill_window(); fill_window();
} }
/* =========================================================================== /* ===========================================================================
* Set match_start to the longest match starting at the given string and * Set match_start to the longest match starting at the given string and
* return its length. Matches shorter or equal to prev_length are discarded, * return its length. Matches shorter or equal to prev_length are discarded,
@ -793,7 +778,6 @@ static int longest_match(IPos cur_match)
return best_len; return best_len;
} }
#ifdef DEBUG #ifdef DEBUG
/* =========================================================================== /* ===========================================================================
* Check that the match at match_start is indeed a match. * Check that the match at match_start is indeed a match.
@ -1072,13 +1056,12 @@ struct globals2 {
ulg opt_len; /* bit length of current block with optimal trees */ ulg opt_len; /* bit length of current block with optimal trees */
ulg static_len; /* bit length of current block with static trees */ ulg static_len; /* bit length of current block with static trees */
ulg compressed_len; /* total bit length of compressed file */ // ulg compressed_len; /* total bit length of compressed file */
}; };
#define G2ptr ((struct globals2*)(ptr_to_globals)) #define G2ptr ((struct globals2*)(ptr_to_globals))
#define G2 (*G2ptr) #define G2 (*G2ptr)
/* =========================================================================== /* ===========================================================================
*/ */
#ifndef DEBUG #ifndef DEBUG
@ -1100,7 +1083,6 @@ struct globals2 {
* The arguments must not have side effects. * The arguments must not have side effects.
*/ */
/* =========================================================================== /* ===========================================================================
* Initialize a new block. * Initialize a new block.
*/ */
@ -1123,7 +1105,6 @@ static void init_block(void)
G2.flag_bit = 1; G2.flag_bit = 1;
} }
/* =========================================================================== /* ===========================================================================
* Restore the heap property by moving down the tree starting at node k, * Restore the heap property by moving down the tree starting at node k,
* exchanging a node with the smallest of its two sons if necessary, stopping * exchanging a node with the smallest of its two sons if necessary, stopping
@ -1161,7 +1142,6 @@ static void pqdownheap(ct_data * tree, int k)
G2.heap[k] = v; G2.heap[k] = v;
} }
/* =========================================================================== /* ===========================================================================
* Compute the optimal bit lengths for a tree and update the total bit length * Compute the optimal bit lengths for a tree and update the total bit length
* for the current block. * for the current block.
@ -1259,7 +1239,6 @@ static void gen_bitlen(tree_desc * desc)
} }
} }
/* =========================================================================== /* ===========================================================================
* Generate the codes for a given tree and bit counts (which need not be * Generate the codes for a given tree and bit counts (which need not be
* optimal). * optimal).
@ -1303,7 +1282,6 @@ static void gen_codes(ct_data * tree, int max_code)
} }
} }
/* =========================================================================== /* ===========================================================================
* Construct one Huffman tree and assigns the code bit strings and lengths. * Construct one Huffman tree and assigns the code bit strings and lengths.
* Update the total bit length for the current block. * Update the total bit length for the current block.
@ -1410,7 +1388,6 @@ static void build_tree(tree_desc * desc)
gen_codes((ct_data *) tree, max_code); gen_codes((ct_data *) tree, max_code);
} }
/* =========================================================================== /* ===========================================================================
* Scan a literal or distance tree to determine the frequencies of the codes * Scan a literal or distance tree to determine the frequencies of the codes
* in the bit length tree. Updates opt_len to take into account the repeat * in the bit length tree. Updates opt_len to take into account the repeat
@ -1465,7 +1442,6 @@ static void scan_tree(ct_data * tree, int max_code)
} }
} }
/* =========================================================================== /* ===========================================================================
* Send a literal or distance tree in compressed form, using the codes in * Send a literal or distance tree in compressed form, using the codes in
* bl_tree. * bl_tree.
@ -1523,7 +1499,6 @@ static void send_tree(ct_data * tree, int max_code)
} }
} }
/* =========================================================================== /* ===========================================================================
* Construct the Huffman tree for the bit lengths and return the index in * Construct the Huffman tree for the bit lengths and return the index in
* bl_order of the last bit length code to send. * bl_order of the last bit length code to send.
@ -1557,7 +1532,6 @@ static int build_bl_tree(void)
return max_blindex; return max_blindex;
} }
/* =========================================================================== /* ===========================================================================
* Send the header for a block using dynamic Huffman trees: the counts, the * Send the header for a block using dynamic Huffman trees: the counts, the
* lengths of the bit length codes, the literal tree and the distance tree. * lengths of the bit length codes, the literal tree and the distance tree.
@ -1587,7 +1561,6 @@ static void send_all_trees(int lcodes, int dcodes, int blcodes)
Tracev((stderr, "\ndist tree: sent %ld", (long)G1.bits_sent)); Tracev((stderr, "\ndist tree: sent %ld", (long)G1.bits_sent));
} }
/* =========================================================================== /* ===========================================================================
* Save the match info and tally the frequency counts. Return true if * Save the match info and tally the frequency counts. Return true if
* the current block must be flushed. * the current block must be flushed.
@ -1694,13 +1667,12 @@ static void compress_block(ct_data * ltree, ct_data * dtree)
SEND_CODE(END_BLOCK, ltree); SEND_CODE(END_BLOCK, ltree);
} }
/* =========================================================================== /* ===========================================================================
* Determine the best encoding for the current block: dynamic trees, static * Determine the best encoding for the current block: dynamic trees, static
* trees or store, and output the encoded block to the zip file. This function * trees or store, and output the encoded block to the zip file. This function
* returns the total compressed length for the file so far. * returns the total compressed length for the file so far.
*/ */
static ulg flush_block(char *buf, ulg stored_len, int eof) static void flush_block(char *buf, ulg stored_len, int eof)
{ {
ulg opt_lenb, static_lenb; /* opt_len and static_len in bytes */ ulg opt_lenb, static_lenb; /* opt_len and static_len in bytes */
int max_blindex; /* index of last bit length code of non zero freq */ int max_blindex; /* index of last bit length code of non zero freq */
@ -1740,14 +1712,17 @@ static ulg flush_block(char *buf, ulg stored_len, int eof)
* and if the zip file can be seeked (to rewrite the local header), * and if the zip file can be seeked (to rewrite the local header),
* the whole file is transformed into a stored file: * the whole file is transformed into a stored file:
*/ */
if (stored_len <= opt_lenb && eof && G2.compressed_len == 0L && seekable()) { // seekable() is constant FALSE in busybox, and G2.compressed_len is disabled
/* Since LIT_BUFSIZE <= 2*WSIZE, the input data must be there: */ // (this was the only user)
if (buf == NULL) // if (stored_len <= opt_lenb && eof && G2.compressed_len == 0L && seekable()) {
bb_error_msg("block vanished"); // /* Since LIT_BUFSIZE <= 2*WSIZE, the input data must be there: */
// if (buf == NULL)
G2.compressed_len = stored_len << 3; // bb_error_msg("block vanished");
copy_block(buf, (unsigned) stored_len, 0); /* without header */ //
} else if (stored_len + 4 <= opt_lenb && buf != NULL) { // G2.compressed_len = stored_len << 3;
// copy_block(buf, (unsigned) stored_len, 0); /* without header */
// } else
if (stored_len + 4 <= opt_lenb && buf != NULL) {
/* 4: two words for the lengths */ /* 4: two words for the lengths */
/* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE. /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.
* Otherwise we can't have processed more than WSIZE input bytes since * Otherwise we can't have processed more than WSIZE input bytes since
@ -1756,35 +1731,35 @@ static ulg flush_block(char *buf, ulg stored_len, int eof)
* transform a block into a stored block. * transform a block into a stored block.
*/ */
send_bits((STORED_BLOCK << 1) + eof, 3); /* send block type */ send_bits((STORED_BLOCK << 1) + eof, 3); /* send block type */
G2.compressed_len = ((G2.compressed_len + 3 + 7) & ~7L) // G2.compressed_len = ((G2.compressed_len + 3 + 7) & ~7L)
+ ((stored_len + 4) << 3); // + ((stored_len + 4) << 3);
copy_block(buf, (unsigned) stored_len, 1); /* with header */ copy_block(buf, (unsigned) stored_len, 1); /* with header */
} else if (static_lenb == opt_lenb) { } else
if (static_lenb == opt_lenb) {
send_bits((STATIC_TREES << 1) + eof, 3); send_bits((STATIC_TREES << 1) + eof, 3);
compress_block((ct_data *) G2.static_ltree, (ct_data *) G2.static_dtree); compress_block((ct_data *) G2.static_ltree, (ct_data *) G2.static_dtree);
G2.compressed_len += 3 + G2.static_len; // G2.compressed_len += 3 + G2.static_len;
} else { } else {
send_bits((DYN_TREES << 1) + eof, 3); send_bits((DYN_TREES << 1) + eof, 3);
send_all_trees(G2.l_desc.max_code + 1, G2.d_desc.max_code + 1, send_all_trees(G2.l_desc.max_code + 1, G2.d_desc.max_code + 1,
max_blindex + 1); max_blindex + 1);
compress_block((ct_data *) G2.dyn_ltree, (ct_data *) G2.dyn_dtree); compress_block((ct_data *) G2.dyn_ltree, (ct_data *) G2.dyn_dtree);
G2.compressed_len += 3 + G2.opt_len; // G2.compressed_len += 3 + G2.opt_len;
} }
Assert(G2.compressed_len == G1.bits_sent, "bad compressed size"); // Assert(G2.compressed_len == G1.bits_sent, "bad compressed size");
init_block(); init_block();
if (eof) { if (eof) {
bi_windup(); bi_windup();
G2.compressed_len += 7; /* align on byte boundary */ // G2.compressed_len += 7; /* align on byte boundary */
} }
Tracev((stderr, "\ncomprlen %lu(%lu) ", // Tracev((stderr, "\ncomprlen %lu(%lu) ",
(unsigned long)G2.compressed_len >> 3, // (unsigned long)G2.compressed_len >> 3,
(unsigned long)G2.compressed_len - 7 * eof)); // (unsigned long)G2.compressed_len - 7 * eof));
return G2.compressed_len >> 3; return; /* was "return G2.compressed_len >> 3;" */
} }
/* =========================================================================== /* ===========================================================================
* Update a hash value with the given input byte * Update a hash value with the given input byte
* IN assertion: all calls to UPDATE_HASH are made with consecutive * IN assertion: all calls to UPDATE_HASH are made with consecutive
@ -1793,7 +1768,6 @@ static ulg flush_block(char *buf, ulg stored_len, int eof)
*/ */
#define UPDATE_HASH(h, c) (h = (((h)<<H_SHIFT) ^ (c)) & HASH_MASK) #define UPDATE_HASH(h, c) (h = (((h)<<H_SHIFT) ^ (c)) & HASH_MASK)
/* =========================================================================== /* ===========================================================================
* Same as above, but achieves better compression. We use a lazy * Same as above, but achieves better compression. We use a lazy
* evaluation for matches: a match is finally adopted only if there is * evaluation for matches: a match is finally adopted only if there is
@ -1828,7 +1802,7 @@ do { \
head[G1.ins_h] = (s); \ head[G1.ins_h] = (s); \
} while (0) } while (0)
static NOINLINE ulg deflate(void) static NOINLINE void deflate(void)
{ {
IPos hash_head; /* head of hash chain */ IPos hash_head; /* head of hash chain */
IPos prev_match; /* previous match */ IPos prev_match; /* previous match */
@ -1929,10 +1903,9 @@ static NOINLINE ulg deflate(void)
if (match_available) if (match_available)
ct_tally(0, G1.window[G1.strstart - 1]); ct_tally(0, G1.window[G1.strstart - 1]);
return FLUSH_BLOCK(1); /* eof */ FLUSH_BLOCK(1); /* eof */
} }
/* =========================================================================== /* ===========================================================================
* Initialize the bit string routines. * Initialize the bit string routines.
*/ */
@ -1943,7 +1916,6 @@ static void bi_init(void)
//DEBUG_bits_sent(= 0L); // globals are zeroed in pack_gzip() //DEBUG_bits_sent(= 0L); // globals are zeroed in pack_gzip()
} }
/* =========================================================================== /* ===========================================================================
* Initialize the "longest match" routines for a new file * Initialize the "longest match" routines for a new file
*/ */
@ -1985,7 +1957,6 @@ static void lm_init(unsigned *flags16p)
*/ */
} }
/* =========================================================================== /* ===========================================================================
* Allocate the match buffer, initialize the various tables and save the * Allocate the match buffer, initialize the various tables and save the
* location of the internal file attribute (ascii/binary) and method * location of the internal file attribute (ascii/binary) and method
@ -1999,7 +1970,7 @@ static void ct_init(void)
int code; /* code value */ int code; /* code value */
int dist; /* distance index */ int dist; /* distance index */
//G2.compressed_len = 0L; // globals are zeroed in pack_gzip() // //G2.compressed_len = 0L; // globals are zeroed in pack_gzip()
#ifdef NOT_NEEDED #ifdef NOT_NEEDED
if (G2.static_dtree[0].Len != 0) if (G2.static_dtree[0].Len != 0)
@ -2083,7 +2054,6 @@ static void ct_init(void)
init_block(); init_block();
} }
/* =========================================================================== /* ===========================================================================
* Deflate in to out. * Deflate in to out.
* IN assertions: the input and output buffers are cleared. * IN assertions: the input and output buffers are cleared.
@ -2123,7 +2093,6 @@ static void zip(void)
flush_outbuf(); flush_outbuf();
} }
/* ======================================================================== */ /* ======================================================================== */
static static
IF_DESKTOP(long long) int FAST_FUNC pack_gzip(transformer_state_t *xstate UNUSED_PARAM) IF_DESKTOP(long long) int FAST_FUNC pack_gzip(transformer_state_t *xstate UNUSED_PARAM)