inftrees.asm

zlib dll in wince 5.0 parfrom

// Listing generated by Microsoft (R) Optimizing Compiler Version 15.00.21022.08 

	.file	"f:/Study/wincezip/DLL/inftrees.c"
	.radix	D
	.section	.text,	"ax", "progbits"
	.align 32
	.section	.pdata,	"a", "progbits"
	.align 4
	.section	.xdata,	"a", "progbits"
	.align 8
	.section	.text$zz,	"ax", "progbits"
	.align 16
	.section	.pdata,	"a", "progbits"
	.align 4
	.section	.text$zy,	"ax", "progbits"
	.align 16
	.section	.pdata,	"a", "progbits"
	.align 4
	.section	.data,	"wa", "progbits"
	.align 16
	.section	.rdata,	"a", "progbits"
	.align 16
	.section	.bss,	"wa", "nobits"
	.align 16
	.section	.debug$S,	"ax", "progbits"
	.align 16
	.section	$$TYPES,	"ax", "progbits"
	.align 16
	.section	.tls$,	"was", "progbits"
	.align 16
	.section	.sdata,	"was", "progbits"
	.align 16
	.section	.sbss,	"was", "nobits"
	.align 16
	.section	.srdata,	"as", "progbits"
	.align 16
	.section	.rdata,	"a", "progbits"
	.align 16
        .global inflate_copyright#
	.section	.rdata
inflate_copyright:
	string	" inflate 1.2.3 Copyright 1995-2005 Mark Adler \000"
	.skip 1
?lbase@?1??inflate_table@@9@9:
	data2	03H					// `inflate_table'::`2'::lbase
	data2	04H
	data2	05H
	data2	06H
	data2	07H
	data2	08H
	data2	09H
	data2	0aH
	data2	0bH
	data2	0dH
	data2	0fH
	data2	011H
	data2	013H
	data2	017H
	data2	01bH
	data2	01fH
	data2	023H
	data2	02bH
	data2	033H
	data2	03bH
	data2	043H
	data2	053H
	data2	063H
	data2	073H
	data2	083H
	data2	0a3H
	data2	0c3H
	data2	0e3H
	data2	0102H
	data2	00H
	data2	00H
	.skip 2
?lext@?1??inflate_table@@9@9:
	data2	010H					// `inflate_table'::`2'::lext
	data2	010H
	data2	010H
	data2	010H
	data2	010H
	data2	010H
	data2	010H
	data2	010H
	data2	011H
	data2	011H
	data2	011H
	data2	011H
	data2	012H
	data2	012H
	data2	012H
	data2	012H
	data2	013H
	data2	013H
	data2	013H
	data2	013H
	data2	014H
	data2	014H
	data2	014H
	data2	014H
	data2	015H
	data2	015H
	data2	015H
	data2	015H
	data2	010H
	data2	0c9H
	data2	0c4H
	.skip 2
?dbase@?1??inflate_table@@9@9:
	data2	01H					// `inflate_table'::`2'::dbase
	data2	02H
	data2	03H
	data2	04H
	data2	05H
	data2	07H
	data2	09H
	data2	0dH
	data2	011H
	data2	019H
	data2	021H
	data2	031H
	data2	041H
	data2	061H
	data2	081H
	data2	0c1H
	data2	0101H
	data2	0181H
	data2	0201H
	data2	0301H
	data2	0401H
	data2	0601H
	data2	0801H
	data2	0c01H
	data2	01001H
	data2	01801H
	data2	02001H
	data2	03001H
	data2	04001H
	data2	06001H
	data2	00H
	data2	00H
?dext@?1??inflate_table@@9@9:
	data2	010H					// `inflate_table'::`2'::dext
	data2	010H
	data2	010H
	data2	010H
	data2	011H
	data2	011H
	data2	012H
	data2	012H
	data2	013H
	data2	013H
	data2	014H
	data2	014H
	data2	015H
	data2	015H
	data2	016H
	data2	016H
	data2	017H
	data2	017H
	data2	018H
	data2	018H
	data2	019H
	data2	019H
	data2	01aH
	data2	01aH
	data2	01bH
	data2	01bH
	data2	01cH
	data2	01cH
	data2	01dH
	data2	01dH
	data2	040H
	data2	040H
	.type	inflate_table#	,@function 
        .global inflate_table#
	.section	.pdata
$T78876: data4	@imagerel($LN67@inflate_ta#)
	data4	@imagerel($LN67@inflate_ta#+7120)
	data4	@imagerel($T78874#)
	.section	.xdata
$T78874: data2	03H
	data2	00H
	data4	02H
	string	"\x0e"		//R1:prologue size 14
	string	"\xe0\x00\x0c"	//P7:mem_stack_f time 0 size 12
	string	"\x61\xa9\x0a"	//R3:body size 1321
	string	"\x81"		//B1:label_state 1
	string	"\xc0\x02"	//B2:ecount 0 time 2
	string	"\x00\x00\x00\x00\x00\x00" //padding
// Function compile flags: /Odtp
// File f:\study\wincezip\dll\inftrees.c
	.section	.text

// Begin code for function: inflate_table:
	.proc	inflate_table#
	.align 32
count$	= 0
extra$	= 32
base$	= 40
huff$	= 48
min$	= 52
mask$	= 56
drop$	= 60
curr$	= 64
root$	= 68
next$	= 72
left$	= 80
len$	= 84
end$	= 88
incr$	= 92
offs$	= 96
fill$	= 128
sym$	= 132
this$	= 136
low$	= 140
used$	= 144
max$	= 148
$T78873	= 152
type$	= 160
lens$	= 168
codes$	= 176
table$	= 184
bits$	= 192
work$	= 200
inflate_table: 
// type$ = r32
// lens$ = r33
// codes$ = r34
// table$ = r35
// bits$ = r36
// work$ = r37
// Output regs: None
$LN67@inflate_ta:

// 39   : {
// 40   :     unsigned len;               /* a code's length in bits */
// 41   :     unsigned sym;               /* index of code symbols */
// 42   :     unsigned min, max;          /* minimum and maximum code lengths */
// 43   :     unsigned root;              /* number of index bits for root table */
// 44   :     unsigned curr;              /* number of index bits for current table */
// 45   :     unsigned drop;              /* code bits to drop for sub-table */
// 46   :     int left;                   /* number of prefix codes available */
// 47   :     unsigned used;              /* code entries in table used */
// 48   :     unsigned huff;              /* Huffman code */
// 49   :     unsigned incr;              /* for incrementing code, index */
// 50   :     unsigned fill;              /* index for replicating entries */
// 51   :     unsigned low;               /* low bits for current root entry */
// 52   :     unsigned mask;              /* mask for low root bits */
// 53   :     code this;                  /* table entry for duplication */
// 54   :     code FAR *next;             /* next available space in table */
// 55   :     const unsigned short FAR *base;     /* base value table to use */
// 56   :     const unsigned short FAR *extra;    /* extra bits table to use */
// 57   :     int end;                    /* use base and extra for symbol > end */
// 58   :     unsigned short count[MAXBITS+1];    /* number of codes of each length */
// 59   :     unsigned short offs[MAXBITS+1];     /* offsets in table for each length */
// 60   :     static const unsigned short lbase[31] = { /* Length codes 257..285 base */
// 61   :         3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
// 62   :         35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0};
// 63   :     static const unsigned short lext[31] = { /* Length codes 257..285 extra */
// 64   :         16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,
// 65   :         19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 201, 196};
// 66   :     static const unsigned short dbase[32] = { /* Distance codes 0..29 base */
// 67   :         1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
// 68   :         257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
// 69   :         8193, 12289, 16385, 24577, 0, 0};
// 70   :     static const unsigned short dext[32] = { /* Distance codes 0..29 extra */
// 71   :         16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22,
// 72   :         23, 23, 24, 24, 25, 25, 26, 26, 27, 27,
// 73   :         28, 28, 29, 29, 64, 64};
// 74   : 
// 75   :     /*
// 76   :        Process a set of code lengths to create a canonical Huffman code.  The
// 77   :        code lengths are lens[0..codes-1].  Each length corresponds to the
// 78   :        symbols 0..codes-1.  The Huffman code is generated by first sorting the
// 79   :        symbols by length from short to long, and retaining the symbol order
// 80   :        for codes with equal lengths.  Then the code starts with all zero bits
// 81   :        for the first code of the shortest length, and the codes are integer
// 82   :        increments for the same length, and zeros are appended as the length
// 83   :        increases.  For the deflate format, these bits are stored backwards
// 84   :        from their more natural integer increment ordering, and so when the
// 85   :        decoding tables are built in the large loop below, the integer codes
// 86   :        are incremented backwards.
// 87   : 
// 88   :        This routine assumes, but does not check, that all of the entries in
// 89   :        lens[] are in the range 0..MAXBITS.  The caller must assure this.
// 90   :        1..MAXBITS is interpreted as that code length.  zero means that that
// 91   :        symbol does not occur in this code.
// 92   : 
// 93   :        The codes are sorted by computing a count of codes for each length,
// 94   :        creating from that a table of starting indices for each length in the
// 95   :        sorted table, and then entering the symbols in order in the sorted
// 96   :        table.  The sorted table is work[], with that space being provided by
// 97   :        the caller.
// 98   : 
// 99   :        The length counts are used for other purposes as well, i.e. finding
// 100  :        the minimum and maximum length codes, determining if there are any
// 101  :        codes at all, checking for a valid set of lengths, and looking ahead
// 102  :        at length counts to determine sub-table sizes when building the
// 103  :        decoding tables.
// 104  :      */
// 105  : 
// 106  :     /* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */
// 107  :     for (len = 0; len <= MAXBITS; len++)

 {   .mmi  //R-Addr: 0X00 
	adds	sp=-192, sp;;				    //39 	cc:0, ffffff40H
	adds	r31=type$, sp
	adds	r30=lens$, sp
 }
 {   .mmi  //R-Addr: 0X010 
	adds	r29=codes$, sp
	adds	r28=table$, sp
	adds	r27=bits$, sp;;
 }
 {   .mmi  //R-Addr: 0X020 
	st4	[r31]=r32
	st8	[r30]=r33
	adds	r26=work$, sp;;
 }
 {   .mmb  //R-Addr: 0X030 
	st4	[r29]=r34
	st8	[r28]=r35
	nop.b	 0;;
 }
 {   .mmb  //R-Addr: 0X040 
	st8	[r27]=r36
	st8	[r26]=r37
	nop.b	 0;;
 }
 {   .mmi  //R-Addr: 0X050 
	adds	r25=len$, sp;;				    //107 	cc:0
	st4	[r25]=r0				    //107 	cc:1
	nop.i	 0
 }
 {   .mmb  //R-Addr: 0X060 
	nop.m	 0
	nop.m	 0
	br.cond.sptk.few $LN64@inflate_ta#;;		    //107 	cc:1
 }
$LN63@inflate_ta:

// 107  :     for (len = 0; len <= MAXBITS; len++)

 {   .mib  //R-Addr: 0X070 
	adds	r22=len$, sp				    //107 	cc:0
	adds	r19=len$, sp				    //107 	cc:0
	nop.b	 0;;
 }
 {   .mmi  //R-Addr: 0X080 
	ld4	r21=[r22];;				    //107 	cc:1
	adds	r20=1, r21				    //107 	cc:2
	nop.i	 0;;
 }
 {   .mmb  //R-Addr: 0X090 
	st4	[r19]=r20				    //107 	cc:3
	nop.m	 0
	nop.b	 0;;
 }
$LN64@inflate_ta:

// 107  :     for (len = 0; len <= MAXBITS; len++)

 {   .mmi  //R-Addr: 0X0a0 
	adds	r18=len$, sp;;				    //107 	cc:0
	ld4	r17=[r18]				    //107 	cc:1
	nop.i	 0;;
 }
 {   .mmb  //R-Addr: 0X0b0 
	cmp4.ltu.unc p14,p15=15, r17			    //107 	cc:2
	nop.m	 0
  (p14)	br.cond.dptk.few $LN62@inflate_ta#;;		    //107 	cc:2
 }

// 108  :         count[len] = 0;

 {   .mib  //R-Addr: 0X0c0 
	adds	r16=len$, sp				    //108 	cc:0
	adds	r10=count$, sp				    //108 	cc:0
	nop.b	 0;;
 }
 {   .mmi  //R-Addr: 0X0d0 
	ld4	r15=[r16];;				    //108 	cc:1
	nop.m	 0
	shl	r11=r15, 1;;				    //108 	cc:2
 }
 {   .mmi  //R-Addr: 0X0e0 
	add	r9=r10, r11;;				    //108 	cc:3
	st2	[r9]=r0					    //108 	cc:4
	nop.i	 0
 }
 {   .mmb  //R-Addr: 0X0f0 
	nop.m	 0
	nop.m	 0
	br.cond.sptk.few $LN63@inflate_ta#;;		    //108 	cc:4
 }
$LN62@inflate_ta:

// 109  :     for (sym = 0; sym < codes; sym++)

 {   .mmi  //R-Addr: 0X0100 
	adds	r8=sym$, sp;;				    //109 	cc:0
	st4	[r8]=r0					    //109 	cc:1
	nop.i	 0
 }
 {   .mmb  //R-Addr: 0X0110 
	nop.m	 0
	nop.m	 0
	br.cond.sptk.few $LN61@inflate_ta#;;		    //109 	cc:1
 }
$LN60@inflate_ta:

// 109  :     for (sym = 0; sym < codes; sym++)

 {   .mib  //R-Addr: 0X0120 
	adds	r31=sym$, sp				    //109 	cc:0
	adds	r28=sym$, sp				    //109 	cc:0
	nop.b	 0;;
 }
 {   .mmi  //R-Addr: 0X0130 
	ld4	r30=[r31];;				    //109 	cc:1
	adds	r29=1, r30				    //109 	cc:2
	nop.i	 0;;
 }
 {   .mmb  //R-Addr: 0X0140 
	st4	[r28]=r29				    //109 	cc:3
	nop.m	 0
	nop.b	 0;;
 }
$LN61@inflate_ta:

// 109  :     for (sym = 0; sym < codes; sym++)

 {   .mib  //R-Addr: 0X0150 
	adds	r27=sym$, sp				    //109 	cc:0
	adds	r25=codes$, sp				    //109 	cc:0
	nop.b	 0;;
 }
 {   .mmb  //R-Addr: 0X0160 
	ld4	r26=[r27]				    //109 	cc:1
	ld4	r22=[r25]				    //109 	cc:1
	nop.b	 0;;
 }
 {   .mmb  //R-Addr: 0X0170 
	cmp4.geu.unc p14,p15=r26, r22			    //109 	cc:2
	nop.m	 0
  (p14)	br.cond.dptk.few $LN59@inflate_ta#;;		    //109 	cc:2
 }

// 110  :         count[lens[sym]]++;

 {   .mmi  //R-Addr: 0X0180 
	adds	r21=sym$, sp				    //110 	cc:0
	adds	r18=lens$, sp				    //110 	cc:0
	adds	r30=sym$, sp				    //110 	cc:0
 }
 {   .mib  //R-Addr: 0X0190 
	adds	r27=lens$, sp				    //110 	cc:0
	adds	r10=count$, sp				    //110 	cc:0
	nop.b	 0;;
 }
 {   .mmb  //R-Addr: 0X01a0 
	ld4	r20=[r21]				    //110 	cc:1
	ld8	r17=[r18]				    //110 	cc:1
	nop.b	 0;;
 }
 {   .mmi  //R-Addr: 0X01b0 
	ld4	r29=[r30]				    //110 	cc:2
	ld8	r26=[r27]				    //110 	cc:2
	shl	r19=r20, 1				    //110 	cc:2
 }
 {   .mmi  //R-Addr: 0X01c0 
	adds	r20=count$, sp;;			    //110 	cc:2
	add	r16=r17, r19				    //110 	cc:3
	shl	r28=r29, 1;;				    //110 	cc:3
 }
 {   .mii  //R-Addr: 0X01d0 
	ld2	r15=[r16]				    //110 	cc:4
	add	r25=r26, r28;;				    //110 	cc:4
	shl	r11=r15, 1				    //110 	cc:5
 }
 {   .mmi  //R-Addr: 0X01e0 
	ld2	r22=[r25];;				    //110 	cc:5
	add	r9=r10, r11				    //110 	cc:6
	shl	r21=r22, 1;;				    //110 	cc:6
 }
 {   .mii  //R-Addr: 0X01f0 
	ld2	r8=[r9]					    //110 	cc:7
	add	r19=r20, r21;;				    //110 	cc:7
	adds	r31=1, r8;;				    //110 	cc:8
 }
 {   .mmb  //R-Addr: 0X0200