/[magellan-source]/trunk/mkinitrd-magellan/busybox/archival/libunarchive/decompress_unlzma.c

Diff of /trunk/mkinitrd-magellan/busybox/archival/libunarchive/decompress_unlzma.c

Parent Directory | Revision Log | View Patch Patch

-revision 815 by niro,
Sat Sep  1 22:45:15 2007 UTC
+revision 816 by niro,
Fri Apr 24 18:33:46 2009 UTC
 Line 12
  #include "libbb.h"
  #include "unarchive.h"
- #ifdef CONFIG_FEATURE_LZMA_FAST
+ #if ENABLE_FEATURE_LZMA_FAST
- #  define speed_inline ATTRIBUTE_ALWAYS_INLINE
+ #  define speed_inline ALWAYS_INLINE
  #else
  #  define speed_inline
  #endif
 Line 45 
 typedef struct {
  /* Called twice: once at startup and once in rc_normalize() */
- static void rc_read(rc_t * rc)
+ static void rc_read(rc_t *rc)
  {
  	int buffer_size = safe_read(rc->fd, RC_BUFFER, RC_BUFFER_SIZE);
  	if (buffer_size <= 0)
 Line 58 
 static void rc_read(rc_t * rc)
  static rc_t* rc_init(int fd) /*, int buffer_size) */
  {
  	int i;
- 	rc_t* rc;
+ 	rc_t *rc;
- 	rc = xmalloc(sizeof(rc_t) + RC_BUFFER_SIZE);
+ 	rc = xmalloc(sizeof(*rc) + RC_BUFFER_SIZE);
  	rc->fd = fd;
  	/* rc->buffer_size = buffer_size; */
 Line 78 
 static rc_t* rc_init(int fd) /*, int buf
  }
  /* Called once  */
- static ATTRIBUTE_ALWAYS_INLINE void rc_free(rc_t * rc)
+ static ALWAYS_INLINE void rc_free(rc_t *rc)
  {
- 	if (ENABLE_FEATURE_CLEAN_UP)
+ 	free(rc);
- 		free(rc);
  }
  /* Called twice, but one callsite is in speed_inline'd rc_is_bit_0_helper() */
- static void rc_do_normalize(rc_t * rc)
+ static void rc_do_normalize(rc_t *rc)
  {
  	if (rc->ptr >= rc->buffer_end)
  		rc_read(rc);
  	rc->range <<= 8;
  	rc->code = (rc->code << 8) | *rc->ptr++;
  }
- static ATTRIBUTE_ALWAYS_INLINE void rc_normalize(rc_t * rc)
+ static ALWAYS_INLINE void rc_normalize(rc_t *rc)
  {
  	if (rc->range < (1 << RC_TOP_BITS)) {
  		rc_do_normalize(rc);
  	}
  }
- /* Called 9 times */
+ /* rc_is_bit_0 is called 9 times */
  /* Why rc_is_bit_0_helper exists?
-  * Because we want to always expose (rc->code < rc->bound) to optimizer
+  * Because we want to always expose (rc->code < rc->bound) to optimizer.
+  * Thus rc_is_bit_0 is always inlined, and rc_is_bit_0_helper is inlined
+  * only if we compile for speed.
   */
- static speed_inline uint32_t rc_is_bit_0_helper(rc_t * rc, uint16_t * p)
+ static speed_inline uint32_t rc_is_bit_0_helper(rc_t *rc, uint16_t *p)
  {
  	rc_normalize(rc);
  	rc->bound = *p * (rc->range >> RC_MODEL_TOTAL_BITS);
  	return rc->bound;
  }
- static ATTRIBUTE_ALWAYS_INLINE int rc_is_bit_0(rc_t * rc, uint16_t * p)
+ static ALWAYS_INLINE int rc_is_bit_0(rc_t *rc, uint16_t *p)
  {
  	uint32_t t = rc_is_bit_0_helper(rc, p);
  	return rc->code < t;
  }
  /* Called ~10 times, but very small, thus inlined */
- static speed_inline void rc_update_bit_0(rc_t * rc, uint16_t * p)
+ static speed_inline void rc_update_bit_0(rc_t *rc, uint16_t *p)
  {
  	rc->range = rc->bound;
  	*p += ((1 << RC_MODEL_TOTAL_BITS) - *p) >> RC_MOVE_BITS;
  }
- static speed_inline void rc_update_bit_1(rc_t * rc, uint16_t * p)
+ static speed_inline void rc_update_bit_1(rc_t *rc, uint16_t *p)
  {
  	rc->range -= rc->bound;
  	rc->code -= rc->bound;
-Line 129 
 static speed_inline void rc_update_bit_1
+Line 130 
 static speed_inline void rc_update_bit_1
  }
  /* Called 4 times in unlzma loop */
- static int rc_get_bit(rc_t * rc, uint16_t * p, int *symbol)
+ static int rc_get_bit(rc_t *rc, uint16_t *p, int *symbol)
  {
  	if (rc_is_bit_0(rc, p)) {
  		rc_update_bit_0(rc, p);
-Line 143 
 static int rc_get_bit(rc_t * rc, uint16_
+Line 144 
 static int rc_get_bit(rc_t * rc, uint16_
  }
  /* Called once */
- static ATTRIBUTE_ALWAYS_INLINE int rc_direct_bit(rc_t * rc)
+ static ALWAYS_INLINE int rc_direct_bit(rc_t *rc)
  {
  	rc_normalize(rc);
  	rc->range >>= 1;
-Line 156 
 static ATTRIBUTE_ALWAYS_INLINE int rc_di
+Line 157 
 static ATTRIBUTE_ALWAYS_INLINE int rc_di
  /* Called twice */
  static speed_inline void
- rc_bit_tree_decode(rc_t * rc, uint16_t * p, int num_levels, int *symbol)
+ rc_bit_tree_decode(rc_t *rc, uint16_t *p, int num_levels, int *symbol)
  {
  	int i = num_levels;
-Line 227 
 enum {
+Line 228 
 enum {
  };
- USE_DESKTOP(long long) int
+ USE_DESKTOP(long long) int FAST_FUNC
- unlzma(int src_fd, int dst_fd)
+ unpack_lzma_stream(int src_fd, int dst_fd)
  {
  	USE_DESKTOP(long long total_written = 0;)
  	lzma_header_t header;
-Line 280 
 unlzma(int src_fd, int dst_fd)
+Line 281 
 unlzma(int src_fd, int dst_fd)
  	while (global_pos + buffer_pos < header.dst_size) {
  		int pos_state = (buffer_pos + global_pos) & pos_state_mask;
- 		prob =
+ 		prob = p + LZMA_IS_MATCH + (state << LZMA_NUM_POS_BITS_MAX) + pos_state;
- 			p + LZMA_IS_MATCH + (state << LZMA_NUM_POS_BITS_MAX) + pos_state;
  		if (rc_is_bit_0(rc, prob)) {
  			mi = 1;
  			rc_update_bit_0(rc, prob);
- 			prob = (p + LZMA_LITERAL + (LZMA_LIT_SIZE
+ 			prob = (p + LZMA_LITERAL
- 					* ((((buffer_pos + global_pos) & literal_pos_mask) << lc)
+ 			        + (LZMA_LIT_SIZE * ((((buffer_pos + global_pos) & literal_pos_mask) << lc)
- 					+ (previous_byte >> (8 - lc)))));
+ 			                            + (previous_byte >> (8 - lc))
+ 			                           )
+ 			          )
+ 			);
  			if (state >= LZMA_NUM_LIT_STATES) {
  				int match_byte;
-Line 302 
 unlzma(int src_fd, int dst_fd)
+Line 305 
 unlzma(int src_fd, int dst_fd)
  					match_byte <<= 1;
  					bit = match_byte & 0x100;
  					prob_lit = prob + 0x100 + bit + mi;
- 					if (rc_get_bit(rc, prob_lit, &mi)) {
+ 					bit ^= (rc_get_bit(rc, prob_lit, &mi) << 8); /* 0x100 or 0 */
- 						if (!bit)
+ 					if (bit)
- 							break;
+ 						break;
- 					} else {
- 						if (bit)
- 							break;
- 					}
  				} while (mi < 0x100);
  			}
  			while (mi < 0x100) {
  				prob_lit = prob + mi;
  				rc_get_bit(rc, prob_lit, &mi);
  			}
- 			previous_byte = (uint8_t) mi;
+ 			state -= 3;
+ 			if (state < 4-3)
+ 				state = 0;
+ 			if (state >= 10-3)
+ 				state -= 6-3;
+ 			previous_byte = (uint8_t) mi;
+ #if ENABLE_FEATURE_LZMA_FAST
+  one_byte1:
  			buffer[buffer_pos++] = previous_byte;
  			if (buffer_pos == header.dict_size) {
  				buffer_pos = 0;
  				global_pos += header.dict_size;
- 				if (full_write(dst_fd, buffer, header.dict_size) != header.dict_size)
+ 				if (full_write(dst_fd, buffer, header.dict_size) != (ssize_t)header.dict_size)
  					goto bad;
  				USE_DESKTOP(total_written += header.dict_size;)
  			}
- 			if (state < 4)
+ #else
- 				state = 0;
+ 			len = 1;
- 			else if (state < 10)
+ 			goto one_byte2;
- 				state -= 3;
+ #endif
- 			else
- 				state -= 6;
  		} else {
  			int offset;
  			uint16_t *prob_len;
-Line 350 
 unlzma(int src_fd, int dst_fd)
+Line 355 
 unlzma(int src_fd, int dst_fd)
  				if (rc_is_bit_0(rc, prob)) {
  					rc_update_bit_0(rc, prob);
  					prob = (p + LZMA_IS_REP_0_LONG
- 							+ (state << LZMA_NUM_POS_BITS_MAX) + pos_state);
+ 					        + (state << LZMA_NUM_POS_BITS_MAX)
+ 					        + pos_state
+ 					);
  					if (rc_is_bit_0(rc, prob)) {
  						rc_update_bit_0(rc, prob);
  						state = state < LZMA_NUM_LIT_STATES ? 9 : 11;
+ #if ENABLE_FEATURE_LZMA_FAST
  						pos = buffer_pos - rep0;
  						while (pos >= header.dict_size)
  							pos += header.dict_size;
  						previous_byte = buffer[pos];
- 						buffer[buffer_pos++] = previous_byte;
+ 						goto one_byte1;
- 						if (buffer_pos == header.dict_size) {
+ #else
- 							buffer_pos = 0;
+ 						len = 1;
- 							global_pos += header.dict_size;
+ 						goto string;
- 							if (full_write(dst_fd, buffer, header.dict_size) != header.dict_size)
+ #endif
- 								goto bad;
- 							USE_DESKTOP(total_written += header.dict_size;)
- 						}
- 						continue;
  					} else {
  						rc_update_bit_1(rc, prob);
  					}
-Line 403 
 unlzma(int src_fd, int dst_fd)
+Line 407 
 unlzma(int src_fd, int dst_fd)
  			if (rc_is_bit_0(rc, prob_len)) {
  				rc_update_bit_0(rc, prob_len);
  				prob_len = (prob + LZMA_LEN_LOW
- 							+ (pos_state << LZMA_LEN_NUM_LOW_BITS));
+ 				            + (pos_state << LZMA_LEN_NUM_LOW_BITS));
  				offset = 0;
  				num_bits = LZMA_LEN_NUM_LOW_BITS;
  			} else {
-Line 412 
 unlzma(int src_fd, int dst_fd)
+Line 416 
 unlzma(int src_fd, int dst_fd)
  				if (rc_is_bit_0(rc, prob_len)) {
  					rc_update_bit_0(rc, prob_len);
  					prob_len = (prob + LZMA_LEN_MID
- 								+ (pos_state << LZMA_LEN_NUM_MID_BITS));
+ 					            + (pos_state << LZMA_LEN_NUM_MID_BITS));
  					offset = 1 << LZMA_LEN_NUM_LOW_BITS;
  					num_bits = LZMA_LEN_NUM_MID_BITS;
  				} else {
  					rc_update_bit_1(rc, prob_len);
  					prob_len = prob + LZMA_LEN_HIGH;
  					offset = ((1 << LZMA_LEN_NUM_LOW_BITS)
- 							  + (1 << LZMA_LEN_NUM_MID_BITS));
+ 					          + (1 << LZMA_LEN_NUM_MID_BITS));
  					num_bits = LZMA_LEN_NUM_HIGH_BITS;
  				}
  			}
-Line 430 
 unlzma(int src_fd, int dst_fd)
+Line 434 
 unlzma(int src_fd, int dst_fd)
  				int pos_slot;
  				state += LZMA_NUM_LIT_STATES;
- 				prob =
+ 				prob = p + LZMA_POS_SLOT +
- 					p + LZMA_POS_SLOT +
+ 				       ((len < LZMA_NUM_LEN_TO_POS_STATES ? len :
- 					((len <
+ 				         LZMA_NUM_LEN_TO_POS_STATES - 1)
- 					  LZMA_NUM_LEN_TO_POS_STATES ? len :
+ 				         << LZMA_NUM_POS_SLOT_BITS);
- 					  LZMA_NUM_LEN_TO_POS_STATES - 1)
- 					 << LZMA_NUM_POS_SLOT_BITS);
  				rc_bit_tree_decode(rc, prob, LZMA_NUM_POS_SLOT_BITS,
  								   &pos_slot);
  				if (pos_slot >= LZMA_START_POS_MODEL_INDEX) {
-Line 466 
 unlzma(int src_fd, int dst_fd)
+Line 468 
 unlzma(int src_fd, int dst_fd)
  			}
  			len += LZMA_MATCH_MIN_LEN;
+  SKIP_FEATURE_LZMA_FAST(string:)
  			do {
  				pos = buffer_pos - rep0;
  				while (pos >= header.dict_size)
  					pos += header.dict_size;
  				previous_byte = buffer[pos];
+  SKIP_FEATURE_LZMA_FAST(one_byte2:)
  				buffer[buffer_pos++] = previous_byte;
  				if (buffer_pos == header.dict_size) {
  					buffer_pos = 0;
  					global_pos += header.dict_size;
- 					if (full_write(dst_fd, buffer, header.dict_size) != header.dict_size)
+ 					if (full_write(dst_fd, buffer, header.dict_size) != (ssize_t)header.dict_size)
  						goto bad;
  					USE_DESKTOP(total_written += header.dict_size;)
  				}
-Line 485 
 unlzma(int src_fd, int dst_fd)
+Line 488 
 unlzma(int src_fd, int dst_fd)
  		}
  	}
+ 	{
- 	if (full_write(dst_fd, buffer, buffer_pos) != buffer_pos) {
+ 		SKIP_DESKTOP(int total_written = 0; /* success */)
+ 		USE_DESKTOP(total_written += buffer_pos;)
+ 		if (full_write(dst_fd, buffer, buffer_pos) != (ssize_t)buffer_pos) {
   bad:
+ 			total_written = -1; /* failure */
+ 		}
  		rc_free(rc);
- 		return -1;
+ 		free(p);
+ 		free(buffer);
+ 		return total_written;
  	}
- 	rc_free(rc);
- 	USE_DESKTOP(total_written += buffer_pos;)
- 	return USE_DESKTOP(total_written) + 0;
  }

 Legend:



Removed from v.815
 


changed lines


 
Added in v.816
 Legend:



Removed from v.815
 


changed lines


 
Added in v.816
-Removed from v.815
+Added in v.816