-
Notifications
You must be signed in to change notification settings - Fork 182
/
lzma_dec_x86_64.asm
1285 lines (1001 loc) · 29.4 KB
/
lzma_dec_x86_64.asm
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
; lzma_dec_x86_64.asm -- ASM version of LZMA_decodeReal_3() function
; 2018-02-06: Igor Pavlov : Public domain
; Modified for FL2 by Conor McCarthy
;
; 3 - is the code compatibility version of LZMA_decodeReal_*()
; function for check at link time.
; That code is tightly coupled with LZMA_tryDummy()
; and with another functions in lzma2_dec.c file.
; CLzmaDec structure, (probs) array layout, input and output of
; LZMA_decodeReal_*() must be equal in both versions (C / ASM).
x0 equ EAX
x1 equ ECX
x2 equ EDX
x3 equ EBX
x4 equ ESP
x5 equ EBP
x6 equ ESI
x7 equ EDI
x0_W equ AX
x1_W equ CX
x2_W equ DX
x3_W equ BX
x5_W equ BP
x6_W equ SI
x7_W equ DI
x0_L equ AL
x1_L equ CL
x2_L equ DL
x3_L equ BL
x0_H equ AH
x1_H equ CH
x2_H equ DH
x3_H equ BH
x5_L equ BPL
x6_L equ SIL
x7_L equ DIL
r0 equ RAX
r1 equ RCX
r2 equ RDX
r3 equ RBX
r4 equ RSP
r5 equ RBP
r6 equ RSI
r7 equ RDI
x8 equ r8d
x9 equ r9d
x10 equ r10d
x11 equ r11d
x12 equ r12d
x13 equ r13d
x14 equ r14d
x15 equ r15d
MY_PUSH_4_REGS macro
push r3
push r5
push r6
push r7
endm
MY_POP_4_REGS macro
pop r7
pop r6
pop r5
pop r3
endm
; for WIN64-x64 ABI:
REG_PARAM_0 equ r1
REG_PARAM_1 equ r2
REG_PARAM_2 equ r8
REG_PARAM_3 equ r9
MY_PUSH_PRESERVED_REGS macro
MY_PUSH_4_REGS
push r12
push r13
push r14
push r15
endm
MY_POP_PRESERVED_REGS macro
pop r15
pop r14
pop r13
pop r12
MY_POP_4_REGS
endm
MY_ALIGN macro num:req
align num
endm
MY_ALIGN_16 macro
MY_ALIGN 16
endm
MY_ALIGN_64 macro
MY_ALIGN 64
endm
; _LZMA_SIZE_OPT equ 1
; _LZMA_PROB16 equ 1
ifdef _LZMA_PROB16
PSHIFT equ 1
PLOAD macro dest, mem
movzx dest, word ptr [mem]
endm
PSTORE macro src, mem
mov word ptr [mem], @CatStr(src, _W)
endm
else
PSHIFT equ 2
PLOAD macro dest, mem
mov dest, dword ptr [mem]
endm
PSTORE macro src, mem
mov dword ptr [mem], src
endm
endif
PMULT equ (1 SHL PSHIFT)
PMULT_HALF equ (1 SHL (PSHIFT - 1))
PMULT_2 equ (1 SHL (PSHIFT + 1))
; x0 range
; x1 pbPos / (prob) TREE
; x2 probBranch / prm (MATCHED) / pbPos / cnt
; x3 sym
;====== r4 === RSP
; x5 cod
; x6 t1 NORM_CALC / probs_state / dist
; x7 t0 NORM_CALC / prob2 IF_BIT_1
; x8 state
; x9 match (MATCHED) / sym2 / dist2 / lpMask_reg
; x10 kBitModelTotal_reg
; r11 probs
; x12 offs (MATCHED) / dic / len_temp
; x13 processedPos
; x14 bit (MATCHED) / dicPos
; r15 buf
cod equ x5
cod_L equ x5_L
range equ x0
state equ x8
state_R equ r8
buf equ r15
processedPos equ x13
kBitModelTotal_reg equ x10
probBranch equ x2
probBranch_R equ r2
probBranch_W equ x2_W
pbPos equ x1
pbPos_R equ r1
cnt equ x2
cnt_R equ r2
lpMask_reg equ x9
dicPos equ r14
sym equ x3
sym_R equ r3
sym_L equ x3_L
probs equ r11
dic equ r12
t0 equ x7
t0_W equ x7_W
t0_R equ r7
prob2 equ t0
prob2_W equ t0_W
t1 equ x6
t1_R equ r6
probs_state equ t1
probs_state_R equ t1_R
prm equ r2
match equ x9
match_R equ r9
offs equ x12
offs_R equ r12
bit equ x14
bit_R equ r14
sym2 equ x9
sym2_R equ r9
len_temp equ x12
dist equ sym
dist2 equ x9
kNumBitModelTotalBits equ 11
kBitModelTotal equ (1 SHL kNumBitModelTotalBits)
kNumMoveBits equ 5
kBitModelOffset equ ((1 SHL kNumMoveBits) - 1)
kTopValue equ (1 SHL 24)
NORM_2 macro
shl cod, 8
mov cod_L, BYTE PTR [buf]
shl range, 8
inc buf
endm
NORM macro
cmp range, kTopValue
jae SHORT @F
NORM_2
@@:
endm
; ---------- Branch MACROS ----------
UPDATE_0 macro probsArray:req, probOffset:req, probDisp:req
mov prob2, kBitModelTotal_reg
sub prob2, probBranch
shr prob2, kNumMoveBits
add probBranch, prob2
PSTORE probBranch, probOffset * 1 + probsArray + probDisp * PMULT
endm
UPDATE_1 macro probsArray:req, probOffset:req, probDisp:req
sub prob2, range
sub cod, range
mov range, prob2
mov prob2, probBranch
shr probBranch, kNumMoveBits
sub prob2, probBranch
PSTORE prob2, probOffset * 1 + probsArray + probDisp * PMULT
endm
CMP_COD macro probsArray:req, probOffset:req, probDisp:req
PLOAD probBranch, probOffset * 1 + probsArray + probDisp * PMULT
NORM
mov prob2, range
shr range, kNumBitModelTotalBits
imul range, probBranch
cmp cod, range
endm
IF_BIT_1_NOUP macro probsArray:req, probOffset:req, probDisp:req, toLabel:req
CMP_COD probsArray, probOffset, probDisp
jae toLabel
endm
IF_BIT_1 macro probsArray:req, probOffset:req, probDisp:req, toLabel:req
IF_BIT_1_NOUP probsArray, probOffset, probDisp, toLabel
UPDATE_0 probsArray, probOffset, probDisp
endm
IF_BIT_0_NOUP macro probsArray:req, probOffset:req, probDisp:req, toLabel:req
CMP_COD probsArray, probOffset, probDisp
jb toLabel
endm
; ---------- CMOV MACROS ----------
NORM_CALC macro prob:req
NORM
mov t0, range
shr range, kNumBitModelTotalBits
imul range, prob
sub t0, range
mov t1, cod
sub cod, range
endm
PUP macro prob:req, probPtr:req
sub t0, prob
; only sar works for both 16/32 bit prob modes
sar t0, kNumMoveBits
add t0, prob
PSTORE t0, probPtr
endm
PUP_SUB macro prob:req, probPtr:req, symSub:req
sbb sym, symSub
PUP prob, probPtr
endm
PUP_COD macro prob:req, probPtr:req, symSub:req
mov t0, kBitModelOffset
cmovb cod, t1
mov t1, sym
cmovb t0, kBitModelTotal_reg
PUP_SUB prob, probPtr, symSub
endm
BIT_0 macro prob:req, probNext:req
PLOAD prob, probs + 1 * PMULT
PLOAD probNext, probs + 1 * PMULT_2
NORM_CALC prob
cmovae range, t0
PLOAD t0, probs + 1 * PMULT_2 + PMULT
cmovae probNext, t0
mov t0, kBitModelOffset
cmovb cod, t1
cmovb t0, kBitModelTotal_reg
mov sym, 2
PUP_SUB prob, probs + 1 * PMULT, 0 - 1
endm
BIT_1 macro prob:req, probNext:req
PLOAD probNext, probs + sym_R * PMULT_2
add sym, sym
NORM_CALC prob
cmovae range, t0
PLOAD t0, probs + sym_R * PMULT + PMULT
cmovae probNext, t0
PUP_COD prob, probs + t1_R * PMULT_HALF, 0 - 1
endm
BIT_2 macro prob:req, symSub:req
add sym, sym
NORM_CALC prob
cmovae range, t0
PUP_COD prob, probs + t1_R * PMULT_HALF, symSub
endm
; ---------- MATCHED LITERAL ----------
LITM_0 macro
mov offs, 256 * PMULT
shl match, (PSHIFT + 1)
mov bit, offs
and bit, match
PLOAD x1, probs + 256 * PMULT + bit_R * 1 + 1 * PMULT
lea prm, [probs + 256 * PMULT + bit_R * 1 + 1 * PMULT]
; lea prm, [probs + 256 * PMULT + 1 * PMULT]
; add prm, bit_R
xor offs, bit
add match, match
NORM_CALC x1
cmovae offs, bit
mov bit, match
cmovae range, t0
mov t0, kBitModelOffset
cmovb cod, t1
cmovb t0, kBitModelTotal_reg
mov sym, 0
PUP_SUB x1, prm, -2-1
endm
LITM macro
and bit, offs
lea prm, [probs + offs_R * 1]
add prm, bit_R
PLOAD x1, prm + sym_R * PMULT
xor offs, bit
add sym, sym
add match, match
NORM_CALC x1
cmovae offs, bit
mov bit, match
cmovae range, t0
PUP_COD x1, prm + t1_R * PMULT_HALF, - 1
endm
LITM_2 macro
and bit, offs
lea prm, [probs + offs_R * 1]
add prm, bit_R
PLOAD x1, prm + sym_R * PMULT
add sym, sym
NORM_CALC x1
cmovae range, t0
PUP_COD x1, prm + t1_R * PMULT_HALF, 256 - 1
endm
; ---------- REVERSE BITS ----------
REV_0 macro prob:req, probNext:req
; PLOAD prob, probs + 1 * PMULT
; lea sym2_R, [probs + 2 * PMULT]
; PLOAD probNext, probs + 2 * PMULT
PLOAD probNext, sym2_R
NORM_CALC prob
cmovae range, t0
PLOAD t0, probs + 3 * PMULT
cmovae probNext, t0
cmovb cod, t1
mov t0, kBitModelOffset
cmovb t0, kBitModelTotal_reg
lea t1_R, [probs + 3 * PMULT]
cmovae sym2_R, t1_R
PUP prob, probs + 1 * PMULT
endm
REV_1 macro prob:req, probNext:req, step:req
add sym2_R, step * PMULT
PLOAD probNext, sym2_R
NORM_CALC prob
cmovae range, t0
PLOAD t0, sym2_R + step * PMULT
cmovae probNext, t0
cmovb cod, t1
mov t0, kBitModelOffset
cmovb t0, kBitModelTotal_reg
lea t1_R, [sym2_R + step * PMULT]
cmovae sym2_R, t1_R
PUP prob, t1_R - step * PMULT_2
endm
REV_2 macro prob:req, step:req
sub sym2_R, probs
shr sym2, PSHIFT
or sym, sym2
NORM_CALC prob
cmovae range, t0
lea t0, [sym - step]
cmovb sym, t0
cmovb cod, t1
mov t0, kBitModelOffset
cmovb t0, kBitModelTotal_reg
PUP prob, probs + sym2_R * PMULT
endm
REV_1_VAR macro prob:req
PLOAD prob, sym_R
mov probs, sym_R
add sym_R, sym2_R
NORM_CALC prob
cmovae range, t0
lea t0_R, [sym_R + sym2_R]
cmovae sym_R, t0_R
mov t0, kBitModelOffset
cmovb cod, t1
; mov t1, kBitModelTotal
; cmovb t0, t1
cmovb t0, kBitModelTotal_reg
add sym2, sym2
PUP prob, probs
endm
LIT_PROBS macro lpMaskParam:req
; prob += (UInt32)3 * ((((processedPos << 8) + dic[(dicPos == 0 ? dicBufSize : dicPos) - 1]) & lpMask) << lc);
mov t0, processedPos
shl t0, 8
add sym, t0
and sym, lpMaskParam
add probs_state_R, pbPos_R
mov x1, LOC lc2
lea sym, dword ptr[sym_R + 2 * sym_R]
add probs, Literal * PMULT
shl sym, x1_L
add probs, sym_R
UPDATE_0 probs_state_R, 0, IsMatch
inc processedPos
endm
kNumPosBitsMax equ 4
kNumPosStatesMax equ (1 SHL kNumPosBitsMax)
kLenNumLowBits equ 3
kLenNumLowSymbols equ (1 SHL kLenNumLowBits)
kLenNumHighBits equ 8
kLenNumHighSymbols equ (1 SHL kLenNumHighBits)
kNumLenProbs equ (2 * kLenNumLowSymbols * kNumPosStatesMax + kLenNumHighSymbols)
LenLow equ 0
LenChoice equ LenLow
LenChoice2 equ (LenLow + kLenNumLowSymbols)
LenHigh equ (LenLow + 2 * kLenNumLowSymbols * kNumPosStatesMax)
kNumStates equ 12
kNumStates2 equ 16
kNumLitStates equ 7
kStartPosModelIndex equ 4
kEndPosModelIndex equ 14
kNumFullDistances equ (1 SHL (kEndPosModelIndex SHR 1))
kNumPosSlotBits equ 6
kNumLenToPosStates equ 4
kNumAlignBits equ 4
kAlignTableSize equ (1 SHL kNumAlignBits)
kMatchMinLen equ 2
kMatchSpecLenStart equ (kMatchMinLen + kLenNumLowSymbols * 2 + kLenNumHighSymbols)
kStartOffset equ 1664
SpecPos equ (-kStartOffset)
IsRep0Long equ (SpecPos + kNumFullDistances)
RepLenCoder equ (IsRep0Long + (kNumStates2 SHL kNumPosBitsMax))
LenCoder equ (RepLenCoder + kNumLenProbs)
IsMatch equ (LenCoder + kNumLenProbs)
kAlign equ (IsMatch + (kNumStates2 SHL kNumPosBitsMax))
IsRep equ (kAlign + kAlignTableSize)
IsRepG0 equ (IsRep + kNumStates)
IsRepG1 equ (IsRepG0 + kNumStates)
IsRepG2 equ (IsRepG1 + kNumStates)
PosSlot equ (IsRepG2 + kNumStates)
Literal equ (PosSlot + (kNumLenToPosStates SHL kNumPosSlotBits))
NUM_BASE_PROBS equ (Literal + kStartOffset)
if kAlign ne 0
.err <Stop_Compiling_Bad_LZMA_kAlign>
endif
if NUM_BASE_PROBS ne 1984
.err <Stop_Compiling_Bad_LZMA_PROBS>
endif
PTR_FIELD equ dq ?
CLzmaDec_Asm struct
lc db ?
lp db ?
pb db ?
_pad_ db ?
dicSize dd ?
dic_Spec PTR_FIELD
dicPos_Spec PTR_FIELD
dicBufSize PTR_FIELD
buf_Spec PTR_FIELD
probs_1664 PTR_FIELD
range_Spec dd ?
code_Spec dd ?
processedPos_Spec dd ?
checkDicSize dd ?
rep0 dd ?
rep1 dd ?
rep2 dd ?
rep3 dd ?
state_Spec dd ?
state2 dd ?
remainLen dd ?
CLzmaDec_Asm ends
CLzmaDec_Asm_Loc struct
OLD_RSP PTR_FIELD
lzmaPtr PTR_FIELD
_pad0_ PTR_FIELD
_pad1_ PTR_FIELD
_pad2_ PTR_FIELD
dicBufSize PTR_FIELD
probs_Spec PTR_FIELD
dic_Spec PTR_FIELD
limit PTR_FIELD
bufLimit PTR_FIELD
lc2 dd ?
lpMask dd ?
pbMask dd ?
checkDicSize dd ?
_pad_ dd ?
remainLen dd ?
dicPos_Spec PTR_FIELD
rep0 dd ?
rep1 dd ?
rep2 dd ?
rep3 dd ?
CLzmaDec_Asm_Loc ends
GLOB_2 equ [sym_R].CLzmaDec_Asm.
GLOB equ [r1].CLzmaDec_Asm.
LOC_0 equ [r0].CLzmaDec_Asm_Loc.
LOC equ [RSP].CLzmaDec_Asm_Loc.
COPY_VAR macro name
mov t0, GLOB_2 name
mov LOC_0 name, t0
endm
RESTORE_VAR macro name
mov t0, LOC name
mov GLOB name, t0
endm
IsMatchBranch_Pre macro reg
; prob = probs + IsMatch + (state << kNumPosBitsMax) + posState;
mov pbPos, LOC pbMask
and pbPos, processedPos
shl pbPos, (kLenNumLowBits + 1 + PSHIFT)
lea probs_state_R, [probs + state_R]
endm
IsMatchBranch macro reg
IsMatchBranch_Pre
IF_BIT_1 probs_state_R, pbPos_R, IsMatch, IsMatch_label
endm
CheckLimits macro reg
cmp buf, LOC bufLimit
jae fin_OK
cmp dicPos, LOC limit
jae fin_OK
endm
PARAM_lzma equ REG_PARAM_0
PARAM_limit equ REG_PARAM_1
PARAM_bufLimit equ REG_PARAM_2
.code
_TEXT$LZMADECOPT SEGMENT ALIGN(64) 'CODE'
LZMA_decodeReal_3 PROC
MY_PUSH_PRESERVED_REGS
; RSP is (16x + 8) bytes aligned in WIN64-x64
; LocalSize equ ((((SIZEOF CLzmaDec_Asm_Loc) + 7) / 16 * 16) + 8)
lea r0, [RSP - (SIZEOF CLzmaDec_Asm_Loc)]
and r0, -128
mov r5, RSP
mov RSP, r0
mov LOC_0 Old_RSP, r5
mov LOC_0 lzmaPtr, PARAM_lzma
mov LOC_0 remainLen, 0 ; remainLen must be ZERO
mov LOC_0 bufLimit, PARAM_bufLimit
mov sym_R, PARAM_lzma ; CLzmaDec_Asm_Loc pointer for GLOB_2
mov dic, GLOB_2 dic_Spec
add PARAM_limit, dic
mov LOC_0 limit, PARAM_limit
COPY_VAR(rep0)
COPY_VAR(rep1)
COPY_VAR(rep2)
COPY_VAR(rep3)
mov dicPos, GLOB_2 dicPos_Spec
add dicPos, dic
mov LOC_0 dicPos_Spec, dicPos
mov LOC_0 dic_Spec, dic
mov x1_L, GLOB_2 pb
mov t0, 1
shl t0, x1_L
dec t0
mov LOC_0 pbMask, t0
; unsigned pbMask = ((unsigned)1 << (p->prop.pb)) - 1;
; unsigned lc = p->prop.lc;
; unsigned lpMask = ((unsigned)0x100 << p->prop.lp) - ((unsigned)0x100 >> lc);
mov x1_L, GLOB_2 lc
mov x2, 100h
mov t0, x2
shr x2, x1_L
add x1_L, PSHIFT
mov LOC_0 lc2, x1
mov x1_L, GLOB_2 lp
shl t0, x1_L
sub t0, x2
mov LOC_0 lpMask, t0
mov lpMask_reg, t0
mov probs, GLOB_2 probs_1664
mov LOC_0 probs_Spec, probs
mov t0_R, GLOB_2 dicBufSize
mov LOC_0 dicBufSize, t0_R
mov x1, GLOB_2 checkDicSize
mov LOC_0 checkDicSize, x1
mov processedPos, GLOB_2 processedPos_Spec
mov state, GLOB_2 state_Spec
shl state, PSHIFT
mov buf, GLOB_2 buf_Spec
mov range, GLOB_2 range_Spec
mov cod, GLOB_2 code_Spec
mov kBitModelTotal_reg, kBitModelTotal
xor sym, sym
; if (processedPos != 0 || checkDicSize != 0)
or x1, processedPos
jz @f
add t0_R, dic
cmp dicPos, dic
cmovnz t0_R, dicPos
movzx sym, byte ptr[t0_R - 1]
@@:
IsMatchBranch_Pre
cmp state, 4 * PMULT
jb lit_end
cmp state, kNumLitStates * PMULT
jb lit_matched_end
jmp lz_end
; ---------- LITERAL ----------
MY_ALIGN_64
lit_start:
xor state, state
lit_start_2:
LIT_PROBS lpMask_reg
ifdef _LZMA_SIZE_OPT
PLOAD x1, probs + 1 * PMULT
mov sym, 1
MY_ALIGN_16
lit_loop:
BIT_1 x1, x2
mov x1, x2
cmp sym, 127
jbe lit_loop
else
BIT_0 x1, x2
BIT_1 x2, x1
BIT_1 x1, x2
BIT_1 x2, x1
BIT_1 x1, x2
BIT_1 x2, x1
BIT_1 x1, x2
endif
BIT_2 x2, 256 - 1
mov probs, LOC probs_Spec
IsMatchBranch_Pre
mov byte ptr[dicPos], sym_L
inc dicPos
CheckLimits
lit_end:
IF_BIT_0_NOUP probs_state_R, pbPos_R, IsMatch, lit_start
; ---------- MATCHES ----------
MY_ALIGN_16
IsMatch_label:
UPDATE_1 probs_state_R, pbPos_R, IsMatch
IF_BIT_1 probs_state_R, 0, IsRep, IsRep_label
add probs, LenCoder * PMULT
add state, kNumStates * PMULT
; ---------- LEN DECODE ----------
len_decode:
mov len_temp, 8 - 1 - kMatchMinLen
IF_BIT_0_NOUP probs, 0, 0, len_mid_0
UPDATE_1 probs, 0, 0
add probs, (1 SHL (kLenNumLowBits + PSHIFT))
mov len_temp, -1 - kMatchMinLen
IF_BIT_0_NOUP probs, 0, 0, len_mid_0
UPDATE_1 probs, 0, 0
add probs, LenHigh * PMULT - (1 SHL (kLenNumLowBits + PSHIFT))
mov sym, 1
PLOAD x1, probs + 1 * PMULT
MY_ALIGN_16
len8_loop:
BIT_1 x1, x2
mov x1, x2
cmp sym, 64
jb len8_loop
mov len_temp, (kLenNumHighSymbols - kLenNumLowSymbols * 2) - 1 - kMatchMinLen
jmp len_mid_2
MY_ALIGN_16
len_mid_0:
UPDATE_0 probs, 0, 0
add probs, pbPos_R
BIT_0 x2, x1
len_mid_2:
BIT_1 x1, x2
BIT_2 x2, len_temp
mov probs, LOC probs_Spec
cmp state, kNumStates * PMULT
jb copy_match
; ---------- DECODE DISTANCE ----------
; probs + PosSlot + ((len < kNumLenToPosStates ? len : kNumLenToPosStates - 1) << kNumPosSlotBits);
mov t0, 3 + kMatchMinLen
cmp sym, 3 + kMatchMinLen
cmovb t0, sym
add probs, PosSlot * PMULT - (kMatchMinLen SHL (kNumPosSlotBits + PSHIFT))
shl t0, (kNumPosSlotBits + PSHIFT)
add probs, t0_R
; sym = Len
mov len_temp, sym
ifdef _LZMA_SIZE_OPT
PLOAD x1, probs + 1 * PMULT
mov sym, 1
MY_ALIGN_16
slot_loop:
BIT_1 x1, x2
mov x1, x2
cmp sym, 32
jb slot_loop
else
BIT_0 x1, x2
BIT_1 x2, x1
BIT_1 x1, x2
BIT_1 x2, x1
BIT_1 x1, x2
endif
mov x1, sym
BIT_2 x2, 64-1
and sym, 3
mov probs, LOC probs_Spec
cmp x1, 32 + kEndPosModelIndex / 2
jb short_dist
; unsigned numDirectBits = (unsigned)(((distance >> 1) - 1));
sub x1, (32 + 1 + kNumAlignBits)
; distance = (2 | (distance & 1));
or sym, 2
PLOAD x2, probs + 1 * PMULT
shl sym, kNumAlignBits + 1
lea sym2_R, [probs + 2 * PMULT]
jmp direct_norm
; ---------- DIRECT DISTANCE ----------
MY_ALIGN_16
direct_loop:
shr range, 1
mov t0, cod
sub cod, range
cmovs cod, t0
cmovns sym, t1
dec x1
je direct_end
add sym, sym
direct_norm:
lea t1, [sym_R + (1 SHL kNumAlignBits)]
cmp range, kTopValue
jae near ptr direct_loop
; we align for 32 here with "near ptr" command above
NORM_2
jmp direct_loop
MY_ALIGN_16
direct_end:
; prob = + kAlign;
; distance <<= kNumAlignBits;
REV_0 x2, x1
REV_1 x1, x2, 2
REV_1 x2, x1, 4
REV_2 x1, 8
decode_dist_end:
; if (distance >= (checkDicSize == 0 ? processedPos: checkDicSize))
mov t0, LOC checkDicSize
test t0, t0
cmove t0, processedPos
cmp sym, t0
jae end_of_payload
; rep3 = rep2;
; rep2 = rep1;
; rep1 = rep0;
; rep0 = distance + 1;
inc sym
mov t0, LOC rep0
mov t1, LOC rep1
mov x1, LOC rep2
mov LOC rep0, sym
mov sym, len_temp
mov LOC rep1, t0
mov LOC rep2, t1
mov LOC rep3, x1
; state = (state < kNumStates + kNumLitStates) ? kNumLitStates : kNumLitStates + 3;
cmp state, (kNumStates + kNumLitStates) * PMULT
mov state, kNumLitStates * PMULT
mov t0, (kNumLitStates + 3) * PMULT
cmovae state, t0
; ---------- COPY MATCH ----------
copy_match:
; if ((rem = limit - dicPos) == 0)
; {
; p->dicPos = dicPos;
; return SZ_ERROR_DATA;
; }
mov cnt_R, LOC limit
sub cnt_R, dicPos
jz fin_ERROR
; curLen = ((rem < len) ? (unsigned)rem : len);
cmp cnt_R, sym_R
; cmovae cnt_R, sym_R ; 64-bit
cmovae cnt, sym ; 32-bit
mov dic, LOC dic_Spec
mov x1, LOC rep0
mov t0_R, dicPos
add dicPos, cnt_R
; processedPos += curLen;
add processedPos, cnt
; len -= curLen;