other-licenses/7zstub/src/Asm/x86/LzmaDecOpt.asm

   1 ; LzmaDecOpt.asm -- ASM version of LzmaDec_DecodeReal_3() function
   2 ; 2018-02-06: Igor Pavlov : Public domain
   3 ;
   4 ; 3 - is the code compatibility version of LzmaDec_DecodeReal_*()
   5 ; function for check at link time.
   6 ; That code is tightly coupled with LzmaDec_TryDummy()
   7 ; and with another functions in LzmaDec.c file.
   8 ; CLzmaDec structure, (probs) array layout, input and output of
   9 ; LzmaDec_DecodeReal_*() must be equal in both versions (C / ASM).
  10
  11 ifndef x64
  12 ; x64=1
  13 ; .err <x64_IS_REQUIRED>
  14 endif
  15
  16 include 7zAsm.asm
  17
  18 MY_ASM_START
  19
  20 _TEXT$LZMADECOPT SEGMENT ALIGN(64) 'CODE'
  21
  22 MY_ALIGN macro num:req
  23         align  num
  24 endm
  25
  26 MY_ALIGN_16 macro
  27         MY_ALIGN 16
  28 endm
  29
  30 MY_ALIGN_32 macro
  31         MY_ALIGN 32
  32 endm
  33
  34 MY_ALIGN_64 macro
  35         MY_ALIGN 64
  36 endm
  37
  38
  39 ; _LZMA_SIZE_OPT  equ 1
  40
  41 ; _LZMA_PROB32 equ 1
  42
  43 ifdef _LZMA_PROB32
  44         PSHIFT  equ 2
  45         PLOAD macro dest, mem
  46                 mov     dest, dword ptr [mem]
  47         endm
  48         PSTORE  macro src, mem
  49                 mov     dword ptr [mem], src
  50         endm
  51 else
  52         PSHIFT  equ 1
  53         PLOAD macro dest, mem
  54                 movzx   dest, word ptr [mem]
  55         endm
  56         PSTORE macro src, mem
  57                 mov     word ptr [mem], @CatStr(src, _W)
  58         endm
  59 endif
  60
  61 PMULT           equ (1 SHL PSHIFT)
  62 PMULT_HALF      equ (1 SHL (PSHIFT - 1))
  63 PMULT_2         equ (1 SHL (PSHIFT + 1))
  64
  65
  66 ;       x0      range
  67 ;       x1      pbPos / (prob) TREE
  68 ;       x2      probBranch / prm (MATCHED) / pbPos / cnt
  69 ;       x3      sym
  70 ;====== r4 ===  RSP
  71 ;       x5      cod
  72 ;       x6      t1 NORM_CALC / probs_state / dist
  73 ;       x7      t0 NORM_CALC / prob2 IF_BIT_1
  74 ;       x8      state
  75 ;       x9      match (MATCHED) / sym2 / dist2 / lpMask_reg
  76 ;       x10     kBitModelTotal_reg
  77 ;       r11     probs
  78 ;       x12     offs (MATCHED) / dic / len_temp
  79 ;       x13     processedPos
  80 ;       x14     bit (MATCHED) / dicPos
  81 ;       r15     buf
  82
  83
  84 cod     equ x5
  85 cod_L   equ x5_L
  86 range   equ x0
  87 state   equ x8
  88 state_R equ r8
  89 buf     equ r15
  90 processedPos equ x13
  91 kBitModelTotal_reg equ x10
  92
  93 probBranch   equ x2
  94 probBranch_R equ r2
  95 probBranch_W equ x2_W
  96
  97 pbPos   equ x1
  98 pbPos_R equ r1
  99
 100 cnt     equ x2
 101 cnt_R   equ r2
 102
 103 lpMask_reg equ x9
 104 dicPos  equ r14
 105
 106 sym     equ x3
 107 sym_R   equ r3
 108 sym_L   equ x3_L
 109
 110 probs   equ r11
 111 dic     equ r12
 112
 113 t0      equ x7
 114 t0_W    equ x7_W
 115 t0_R    equ r7
 116
 117 prob2   equ t0
 118 prob2_W equ t0_W
 119
 120 t1      equ x6
 121 t1_R    equ r6
 122
 123 probs_state     equ t1
 124 probs_state_R   equ t1_R
 125
 126 prm     equ r2
 127 match   equ x9
 128 match_R equ r9
 129 offs    equ x12
 130 offs_R  equ r12
 131 bit     equ x14
 132 bit_R   equ r14
 133
 134 sym2    equ x9
 135 sym2_R  equ r9
 136
 137 len_temp equ x12
 138
 139 dist    equ sym
 140 dist2   equ x9
 141
 142
 143
 144 kNumBitModelTotalBits   equ 11
 145 kBitModelTotal          equ (1 SHL kNumBitModelTotalBits)
 146 kNumMoveBits            equ 5
 147 kBitModelOffset         equ ((1 SHL kNumMoveBits) - 1)
 148 kTopValue               equ (1 SHL 24)
 149
 150 NORM_2 macro
 151         ; movzx   t0, BYTE PTR [buf]
 152         shl     cod, 8
 153         mov     cod_L, BYTE PTR [buf]
 154         shl     range, 8
 155         ; or      cod, t0
 156         inc     buf
 157 endm
 158
 159
 160 NORM macro
 161         cmp     range, kTopValue
 162         jae     SHORT @F
 163         NORM_2
 164 @@:
 165 endm
 166
 167
 168 ; ---------- Branch MACROS ----------
 169
 170 UPDATE_0 macro probsArray:req, probOffset:req, probDisp:req
 171         mov     prob2, kBitModelTotal_reg
 172         sub     prob2, probBranch
 173         shr     prob2, kNumMoveBits
 174         add     probBranch, prob2
 175         PSTORE  probBranch, probOffset * 1 + probsArray + probDisp * PMULT
 176 endm
 177
 178
 179 UPDATE_1 macro probsArray:req, probOffset:req, probDisp:req
 180         sub     prob2, range
 181         sub     cod, range
 182         mov     range, prob2
 183         mov     prob2, probBranch
 184         shr     probBranch, kNumMoveBits
 185         sub     prob2, probBranch
 186         PSTORE  prob2, probOffset * 1 + probsArray + probDisp * PMULT
 187 endm
 188
 189
 190 CMP_COD macro probsArray:req, probOffset:req, probDisp:req
 191         PLOAD   probBranch, probOffset * 1 + probsArray + probDisp * PMULT
 192         NORM
 193         mov     prob2, range
 194         shr     range, kNumBitModelTotalBits
 195         imul    range, probBranch
 196         cmp     cod, range
 197 endm
 198
 199
 200 IF_BIT_1_NOUP macro probsArray:req, probOffset:req, probDisp:req, toLabel:req
 201         CMP_COD probsArray, probOffset, probDisp
 202         jae     toLabel
 203 endm
 204
 205
 206 IF_BIT_1 macro probsArray:req, probOffset:req, probDisp:req, toLabel:req
 207         IF_BIT_1_NOUP probsArray, probOffset, probDisp, toLabel
 208         UPDATE_0 probsArray, probOffset, probDisp
 209 endm
 210
 211
 212 IF_BIT_0_NOUP macro probsArray:req, probOffset:req, probDisp:req, toLabel:req
 213         CMP_COD probsArray, probOffset, probDisp
 214         jb      toLabel
 215 endm
 216
 217
 218 ; ---------- CMOV MACROS ----------
 219
 220 NORM_CALC macro prob:req
 221         NORM
 222         mov     t0, range
 223         shr     range, kNumBitModelTotalBits
 224         imul    range, prob
 225         sub     t0, range
 226         mov     t1, cod
 227         sub     cod, range
 228 endm
 229
 230
 231 PUP macro prob:req, probPtr:req
 232         sub     t0, prob
 233        ; only sar works for both 16/32 bit prob modes
 234         sar     t0, kNumMoveBits
 235         add     t0, prob
 236         PSTORE  t0, probPtr
 237 endm
 238
 239
 240 PUP_SUB macro prob:req, probPtr:req, symSub:req
 241         sbb     sym, symSub
 242         PUP prob, probPtr
 243 endm
 244
 245
 246 PUP_COD macro prob:req, probPtr:req, symSub:req
 247         mov     t0, kBitModelOffset
 248         cmovb   cod, t1
 249         mov     t1, sym
 250         cmovb   t0, kBitModelTotal_reg
 251         PUP_SUB prob, probPtr, symSub
 252 endm
 253
 254
 255 BIT_0 macro prob:req, probNext:req
 256         PLOAD   prob, probs + 1 * PMULT
 257         PLOAD   probNext, probs + 1 * PMULT_2
 258
 259         NORM_CALC prob
 260
 261         cmovae  range, t0
 262         PLOAD   t0, probs + 1 * PMULT_2 + PMULT
 263         cmovae  probNext, t0
 264         mov     t0, kBitModelOffset
 265         cmovb   cod, t1
 266         cmovb   t0, kBitModelTotal_reg
 267         mov     sym, 2
 268         PUP_SUB prob, probs + 1 * PMULT, 0 - 1
 269 endm
 270
 271
 272 BIT_1 macro prob:req, probNext:req
 273         PLOAD   probNext, probs + sym_R * PMULT_2
 274         add     sym, sym
 275
 276         NORM_CALC prob
 277
 278         cmovae  range, t0
 279         PLOAD   t0, probs + sym_R * PMULT + PMULT
 280         cmovae  probNext, t0
 281         PUP_COD prob, probs + t1_R * PMULT_HALF, 0 - 1
 282 endm
 283
 284
 285 BIT_2 macro prob:req, symSub:req
 286         add     sym, sym
 287
 288         NORM_CALC prob
 289
 290         cmovae  range, t0
 291         PUP_COD prob, probs + t1_R * PMULT_HALF, symSub
 292 endm
 293
 294
 295 ; ---------- MATCHED LITERAL ----------
 296
 297 LITM_0 macro
 298         mov     offs, 256 * PMULT
 299         shl     match, (PSHIFT + 1)
 300         mov     bit, offs
 301         and     bit, match
 302         PLOAD   x1, probs + 256 * PMULT + bit_R * 1 + 1 * PMULT
 303         lea     prm, [probs + 256 * PMULT + bit_R * 1 + 1 * PMULT]
 304         ; lea     prm, [probs + 256 * PMULT + 1 * PMULT]
 305         ; add     prm, bit_R
 306         xor     offs, bit
 307         add     match, match
 308
 309         NORM_CALC x1
 310
 311         cmovae  offs, bit
 312         mov     bit, match
 313         cmovae  range, t0
 314         mov     t0, kBitModelOffset
 315         cmovb   cod, t1
 316         cmovb   t0, kBitModelTotal_reg
 317         mov     sym, 0
 318         PUP_SUB x1, prm, -2-1
 319 endm
 320
 321
 322 LITM macro
 323         and     bit, offs
 324         lea     prm, [probs + offs_R * 1]
 325         add     prm, bit_R
 326         PLOAD   x1, prm + sym_R * PMULT
 327         xor     offs, bit
 328         add     sym, sym
 329         add     match, match
 330
 331         NORM_CALC x1
 332
 333         cmovae  offs, bit
 334         mov     bit, match
 335         cmovae  range, t0
 336         PUP_COD x1, prm + t1_R * PMULT_HALF, - 1
 337 endm
 338
 339
 340 LITM_2 macro
 341         and     bit, offs
 342         lea     prm, [probs + offs_R * 1]
 343         add     prm, bit_R
 344         PLOAD   x1, prm + sym_R * PMULT
 345         add     sym, sym
 346
 347         NORM_CALC x1
 348
 349         cmovae  range, t0
 350         PUP_COD x1, prm + t1_R * PMULT_HALF, 256 - 1
 351 endm
 352
 353
 354 ; ---------- REVERSE BITS ----------
 355
 356 REV_0 macro prob:req, probNext:req
 357         ; PLOAD   prob, probs + 1 * PMULT
 358         ; lea     sym2_R, [probs + 2 * PMULT]
 359         ; PLOAD   probNext, probs + 2 * PMULT
 360         PLOAD   probNext, sym2_R
 361
 362         NORM_CALC prob
 363
 364         cmovae  range, t0
 365         PLOAD   t0, probs + 3 * PMULT
 366         cmovae  probNext, t0
 367         cmovb   cod, t1
 368         mov     t0, kBitModelOffset
 369         cmovb   t0, kBitModelTotal_reg
 370         lea     t1_R, [probs + 3 * PMULT]
 371         cmovae  sym2_R, t1_R
 372         PUP prob, probs + 1 * PMULT
 373 endm
 374
 375
 376 REV_1 macro prob:req, probNext:req, step:req
 377         add     sym2_R, step * PMULT
 378         PLOAD   probNext, sym2_R
 379
 380         NORM_CALC prob
 381
 382         cmovae  range, t0
 383         PLOAD   t0, sym2_R + step * PMULT
 384         cmovae  probNext, t0
 385         cmovb   cod, t1
 386         mov     t0, kBitModelOffset
 387         cmovb   t0, kBitModelTotal_reg
 388         lea     t1_R, [sym2_R + step * PMULT]
 389         cmovae  sym2_R, t1_R
 390         PUP prob, t1_R - step * PMULT_2
 391 endm
 392
 393
 394 REV_2 macro prob:req, step:req
 395         sub     sym2_R, probs
 396         shr     sym2, PSHIFT
 397         or      sym, sym2
 398
 399         NORM_CALC prob
 400
 401         cmovae  range, t0
 402         lea     t0, [sym - step]
 403         cmovb   sym, t0
 404         cmovb   cod, t1
 405         mov     t0, kBitModelOffset
 406         cmovb   t0, kBitModelTotal_reg
 407         PUP prob, probs + sym2_R * PMULT
 408 endm
 409
 410
 411 REV_1_VAR macro prob:req
 412         PLOAD   prob, sym_R
 413         mov     probs, sym_R
 414         add     sym_R, sym2_R
 415
 416         NORM_CALC prob
 417
 418         cmovae  range, t0
 419         lea     t0_R, [sym_R + sym2_R]
 420         cmovae  sym_R, t0_R
 421         mov     t0, kBitModelOffset
 422         cmovb   cod, t1
 423         ; mov     t1, kBitModelTotal
 424         ; cmovb   t0, t1
 425         cmovb   t0, kBitModelTotal_reg
 426         add     sym2, sym2
 427         PUP prob, probs
 428 endm
 429
 430
 431
 432
 433 LIT_PROBS macro lpMaskParam:req
 434         ; prob += (UInt32)3 * ((((processedPos << 8) + dic[(dicPos == 0 ? dicBufSize : dicPos) - 1]) & lpMask) << lc);
 435         mov     t0, processedPos
 436         shl     t0, 8
 437         add     sym, t0
 438         and     sym, lpMaskParam
 439         add     probs_state_R, pbPos_R
 440         mov     x1, LOC lc2
 441         lea     sym, dword ptr[sym_R + 2 * sym_R]
 442         add     probs, Literal * PMULT
 443         shl     sym, x1_L
 444         add     probs, sym_R
 445         UPDATE_0 probs_state_R, 0, IsMatch
 446         inc     processedPos
 447 endm
 448
 449
 450
 451 kNumPosBitsMax          equ 4
 452 kNumPosStatesMax        equ (1 SHL kNumPosBitsMax)
 453
 454 kLenNumLowBits          equ 3
 455 kLenNumLowSymbols       equ (1 SHL kLenNumLowBits)
 456 kLenNumHighBits         equ 8
 457 kLenNumHighSymbols      equ (1 SHL kLenNumHighBits)
 458 kNumLenProbs            equ (2 * kLenNumLowSymbols * kNumPosStatesMax + kLenNumHighSymbols)
 459
 460 LenLow                  equ 0
 461 LenChoice               equ LenLow
 462 LenChoice2              equ (LenLow + kLenNumLowSymbols)
 463 LenHigh                 equ (LenLow + 2 * kLenNumLowSymbols * kNumPosStatesMax)
 464
 465 kNumStates              equ 12
 466 kNumStates2             equ 16
 467 kNumLitStates           equ 7
 468
 469 kStartPosModelIndex     equ 4
 470 kEndPosModelIndex       equ 14
 471 kNumFullDistances       equ (1 SHL (kEndPosModelIndex SHR 1))
 472
 473 kNumPosSlotBits         equ 6
 474 kNumLenToPosStates      equ 4
 475
 476 kNumAlignBits           equ 4
 477 kAlignTableSize         equ (1 SHL kNumAlignBits)
 478
 479 kMatchMinLen            equ 2
 480 kMatchSpecLenStart      equ (kMatchMinLen + kLenNumLowSymbols * 2 + kLenNumHighSymbols)
 481
 482 kStartOffset    equ 1664
 483 SpecPos         equ (-kStartOffset)
 484 IsRep0Long      equ (SpecPos + kNumFullDistances)
 485 RepLenCoder     equ (IsRep0Long + (kNumStates2 SHL kNumPosBitsMax))
 486 LenCoder        equ (RepLenCoder + kNumLenProbs)
 487 IsMatch         equ (LenCoder + kNumLenProbs)
 488 kAlign          equ (IsMatch + (kNumStates2 SHL kNumPosBitsMax))
 489 IsRep           equ (kAlign + kAlignTableSize)
 490 IsRepG0         equ (IsRep + kNumStates)
 491 IsRepG1         equ (IsRepG0 + kNumStates)
 492 IsRepG2         equ (IsRepG1 + kNumStates)
 493 PosSlot         equ (IsRepG2 + kNumStates)
 494 Literal         equ (PosSlot + (kNumLenToPosStates SHL kNumPosSlotBits))
 495 NUM_BASE_PROBS  equ (Literal + kStartOffset)
 496
 497 if kAlign ne 0
 498   .err <Stop_Compiling_Bad_LZMA_kAlign>
 499 endif
 500
 501 if NUM_BASE_PROBS ne 1984
 502   .err <Stop_Compiling_Bad_LZMA_PROBS>
 503 endif
 504
 505
 506 PTR_FIELD equ dq ?
 507
 508 CLzmaDec_Asm struct
 509         lc      db ?
 510         lp      db ?
 511         pb      db ?
 512         _pad_   db ?
 513         dicSize dd ?
 514
 515         probs_Spec      PTR_FIELD
 516         probs_1664      PTR_FIELD
 517         dic_Spec        PTR_FIELD
 518         dicBufSize      PTR_FIELD
 519         dicPos_Spec     PTR_FIELD
 520         buf_Spec        PTR_FIELD
 521
 522         range_Spec      dd ?
 523         code_Spec       dd ?
 524         processedPos_Spec  dd ?
 525         checkDicSize    dd ?
 526         rep0    dd ?
 527         rep1    dd ?
 528         rep2    dd ?
 529         rep3    dd ?
 530         state_Spec      dd ?
 531         remainLen dd ?
 532 CLzmaDec_Asm ends
 533
 534
 535 CLzmaDec_Asm_Loc struct
 536         OLD_RSP    PTR_FIELD
 537         lzmaPtr    PTR_FIELD
 538         _pad0_     PTR_FIELD
 539         _pad1_     PTR_FIELD
 540         _pad2_     PTR_FIELD
 541         dicBufSize PTR_FIELD
 542         probs_Spec PTR_FIELD
 543         dic_Spec   PTR_FIELD
 544
 545         limit      PTR_FIELD
 546         bufLimit   PTR_FIELD
 547         lc2       dd ?
 548         lpMask    dd ?
 549         pbMask    dd ?
 550         checkDicSize   dd ?
 551
 552         _pad_     dd ?
 553         remainLen dd ?
 554         dicPos_Spec     PTR_FIELD
 555         rep0      dd ?
 556         rep1      dd ?
 557         rep2      dd ?
 558         rep3      dd ?
 559 CLzmaDec_Asm_Loc ends
 560
 561
 562 GLOB_2  equ [sym_R].CLzmaDec_Asm.
 563 GLOB    equ [r1].CLzmaDec_Asm.
 564 LOC_0   equ [r0].CLzmaDec_Asm_Loc.
 565 LOC     equ [RSP].CLzmaDec_Asm_Loc.
 566
 567
 568 COPY_VAR macro name
 569         mov     t0, GLOB_2 name
 570         mov     LOC_0 name, t0
 571 endm
 572
 573
 574 RESTORE_VAR macro name
 575         mov     t0, LOC name
 576         mov     GLOB name, t0
 577 endm
 578
 579
 580
 581 IsMatchBranch_Pre macro reg
 582         ; prob = probs + IsMatch + (state << kNumPosBitsMax) + posState;
 583         mov     pbPos, LOC pbMask
 584         and     pbPos, processedPos
 585         shl     pbPos, (kLenNumLowBits + 1 + PSHIFT)
 586         lea     probs_state_R, [probs + state_R]
 587 endm
 588
 589
 590 IsMatchBranch macro reg
 591         IsMatchBranch_Pre
 592         IF_BIT_1 probs_state_R, pbPos_R, IsMatch, IsMatch_label
 593 endm
 594
 595
 596 CheckLimits macro reg
 597         cmp     buf, LOC bufLimit
 598         jae     fin_OK
 599         cmp     dicPos, LOC limit
 600         jae     fin_OK
 601 endm
 602
 603
 604
 605 ; RSP is (16x + 8) bytes aligned in WIN64-x64
 606 ; LocalSize equ ((((SIZEOF CLzmaDec_Asm_Loc) + 7) / 16 * 16) + 8)
 607
 608 PARAM_lzma      equ REG_PARAM_0
 609 PARAM_limit     equ REG_PARAM_1
 610 PARAM_bufLimit  equ REG_PARAM_2
 611
 612 ; MY_ALIGN_64
 613 MY_PROC LzmaDec_DecodeReal_3, 3
 614 MY_PUSH_PRESERVED_REGS
 615
 616         lea     r0, [RSP - (SIZEOF CLzmaDec_Asm_Loc)]
 617         and     r0, -128
 618         mov     r5, RSP
 619         mov     RSP, r0
 620         mov     LOC_0 Old_RSP, r5
 621         mov     LOC_0 lzmaPtr, PARAM_lzma
 622
 623         mov     LOC_0 remainLen, 0  ; remainLen must be ZERO
 624
 625         mov     LOC_0 bufLimit, PARAM_bufLimit
 626         mov     sym_R, PARAM_lzma  ;  CLzmaDec_Asm_Loc pointer for GLOB_2
 627         mov     dic, GLOB_2 dic_Spec
 628         add     PARAM_limit, dic
 629         mov     LOC_0 limit, PARAM_limit
 630
 631         COPY_VAR(rep0)
 632         COPY_VAR(rep1)
 633         COPY_VAR(rep2)
 634         COPY_VAR(rep3)
 635
 636         mov     dicPos, GLOB_2 dicPos_Spec
 637         add     dicPos, dic
 638         mov     LOC_0 dicPos_Spec, dicPos
 639         mov     LOC_0 dic_Spec, dic
 640
 641         mov     x1_L, GLOB_2 pb
 642         mov     t0, 1
 643         shl     t0, x1_L
 644         dec     t0
 645         mov     LOC_0 pbMask, t0
 646
 647         ; unsigned pbMask = ((unsigned)1 << (p->prop.pb)) - 1;
 648         ; unsigned lc = p->prop.lc;
 649         ; unsigned lpMask = ((unsigned)0x100 << p->prop.lp) - ((unsigned)0x100 >> lc);
 650
 651         mov     x1_L, GLOB_2 lc
 652         mov     x2, 100h
 653         mov     t0, x2
 654         shr     x2, x1_L
 655         ; inc     x1
 656         add     x1_L, PSHIFT
 657         mov     LOC_0 lc2, x1
 658         mov     x1_L, GLOB_2 lp
 659         shl     t0, x1_L
 660         sub     t0, x2
 661         mov     LOC_0 lpMask, t0
 662         mov     lpMask_reg, t0
 663
 664         ; mov     probs, GLOB_2 probs_Spec
 665         ; add     probs, kStartOffset SHL PSHIFT
 666         mov     probs, GLOB_2 probs_1664
 667         mov     LOC_0 probs_Spec, probs
 668
 669         mov     t0_R, GLOB_2 dicBufSize
 670         mov     LOC_0 dicBufSize, t0_R
 671
 672         mov     x1, GLOB_2 checkDicSize
 673         mov     LOC_0 checkDicSize, x1
 674
 675         mov     processedPos, GLOB_2 processedPos_Spec
 676
 677         mov     state, GLOB_2 state_Spec
 678         shl     state, PSHIFT
 679
 680         mov     buf,   GLOB_2 buf_Spec
 681         mov     range, GLOB_2 range_Spec
 682         mov     cod,   GLOB_2 code_Spec
 683         mov     kBitModelTotal_reg, kBitModelTotal
 684         xor     sym, sym
 685
 686         ; if (processedPos != 0 || checkDicSize != 0)
 687         or      x1, processedPos
 688         jz      @f
 689
 690         add     t0_R, dic
 691         cmp     dicPos, dic
 692         cmovnz  t0_R, dicPos
 693         movzx   sym, byte ptr[t0_R - 1]
 694
 695 @@:
 696         IsMatchBranch_Pre
 697         cmp     state, 4 * PMULT
 698         jb      lit_end
 699         cmp     state, kNumLitStates * PMULT
 700         jb      lit_matched_end
 701         jmp     lz_end
 702
 703
 704
 705
 706 ; ---------- LITERAL ----------
 707 MY_ALIGN_64
 708 lit_start:
 709         xor     state, state
 710 lit_start_2:
 711         LIT_PROBS lpMask_reg
 712
 713     ifdef _LZMA_SIZE_OPT
 714
 715         PLOAD   x1, probs + 1 * PMULT
 716         mov     sym, 1
 717 MY_ALIGN_16
 718 lit_loop:
 719         BIT_1   x1, x2
 720         mov     x1, x2
 721         cmp     sym, 127
 722         jbe     lit_loop
 723
 724     else
 725
 726         BIT_0   x1, x2
 727         BIT_1   x2, x1
 728         BIT_1   x1, x2
 729         BIT_1   x2, x1
 730         BIT_1   x1, x2
 731         BIT_1   x2, x1
 732         BIT_1   x1, x2
 733
 734     endif
 735
 736         BIT_2   x2, 256 - 1
 737
 738         ; mov     dic, LOC dic_Spec
 739         mov     probs, LOC probs_Spec
 740         IsMatchBranch_Pre
 741         mov     byte ptr[dicPos], sym_L
 742         inc     dicPos
 743
 744         CheckLimits
 745 lit_end:
 746         IF_BIT_0_NOUP probs_state_R, pbPos_R, IsMatch, lit_start
 747
 748         ; jmp     IsMatch_label
 749
 750 ; ---------- MATCHES ----------
 751 ; MY_ALIGN_32
 752 IsMatch_label:
 753         UPDATE_1 probs_state_R, pbPos_R, IsMatch
 754         IF_BIT_1 probs_state_R, 0, IsRep, IsRep_label
 755
 756         add     probs, LenCoder * PMULT
 757         add     state, kNumStates * PMULT
 758
 759 ; ---------- LEN DECODE ----------
 760 len_decode:
 761         mov     len_temp, 8 - 1 - kMatchMinLen
 762         IF_BIT_0_NOUP probs, 0, 0, len_mid_0
 763         UPDATE_1 probs, 0, 0
 764         add     probs, (1 SHL (kLenNumLowBits + PSHIFT))
 765         mov     len_temp, -1 - kMatchMinLen
 766         IF_BIT_0_NOUP probs, 0, 0, len_mid_0
 767         UPDATE_1 probs, 0, 0
 768         add     probs, LenHigh * PMULT - (1 SHL (kLenNumLowBits + PSHIFT))
 769         mov     sym, 1
 770         PLOAD   x1, probs + 1 * PMULT
 771
 772 MY_ALIGN_32
 773 len8_loop:
 774         BIT_1   x1, x2
 775         mov     x1, x2
 776         cmp     sym, 64
 777         jb      len8_loop
 778
 779         mov     len_temp, (kLenNumHighSymbols - kLenNumLowSymbols * 2) - 1 - kMatchMinLen
 780         jmp     len_mid_2
 781
 782 MY_ALIGN_32
 783 len_mid_0:
 784         UPDATE_0 probs, 0, 0
 785         add     probs, pbPos_R
 786         BIT_0   x2, x1
 787 len_mid_2:
 788         BIT_1   x1, x2
 789         BIT_2   x2, len_temp
 790         mov     probs, LOC probs_Spec
 791         cmp     state, kNumStates * PMULT
 792         jb      copy_match
 793
 794
 795 ; ---------- DECODE DISTANCE ----------
 796         ; probs + PosSlot + ((len < kNumLenToPosStates ? len : kNumLenToPosStates - 1) << kNumPosSlotBits);
 797
 798         mov     t0, 3 + kMatchMinLen
 799         cmp     sym, 3 + kMatchMinLen
 800         cmovb   t0, sym
 801         add     probs, PosSlot * PMULT - (kMatchMinLen SHL (kNumPosSlotBits + PSHIFT))
 802         shl     t0, (kNumPosSlotBits + PSHIFT)
 803         add     probs, t0_R
 804
 805         ; sym = Len
 806         ; mov     LOC remainLen, sym
 807         mov     len_temp, sym
 808
 809     ifdef _LZMA_SIZE_OPT
 810
 811         PLOAD   x1, probs + 1 * PMULT
 812         mov     sym, 1
 813 MY_ALIGN_16
 814 slot_loop:
 815         BIT_1   x1, x2
 816         mov     x1, x2
 817         cmp     sym, 32
 818         jb      slot_loop
 819
 820     else
 821
 822         BIT_0   x1, x2
 823         BIT_1   x2, x1
 824         BIT_1   x1, x2
 825         BIT_1   x2, x1
 826         BIT_1   x1, x2
 827
 828     endif
 829
 830         mov     x1, sym
 831         BIT_2   x2, 64-1
 832
 833         and     sym, 3
 834         mov     probs, LOC probs_Spec
 835         cmp     x1, 32 + kEndPosModelIndex / 2
 836         jb      short_dist
 837
 838         ;  unsigned numDirectBits = (unsigned)(((distance >> 1) - 1));
 839         sub     x1, (32 + 1 + kNumAlignBits)
 840         ;  distance = (2 | (distance & 1));
 841         or      sym, 2
 842         PLOAD   x2, probs + 1 * PMULT
 843         shl     sym, kNumAlignBits + 1
 844         lea     sym2_R, [probs + 2 * PMULT]
 845
 846         jmp     direct_norm
 847         ; lea     t1, [sym_R + (1 SHL kNumAlignBits)]
 848         ; cmp     range, kTopValue
 849         ; jb      direct_norm
 850
 851 ; ---------- DIRECT DISTANCE ----------
 852 MY_ALIGN_32
 853 direct_loop:
 854         shr     range, 1
 855         mov     t0, cod
 856         sub     cod, range
 857         cmovs   cod, t0
 858         cmovns  sym, t1
 859
 860         comment ~
 861         sub     cod, range
 862         mov     x2, cod
 863         sar     x2, 31
 864         lea     sym, dword ptr [r2 + sym_R * 2 + 1]
 865         and     x2, range
 866         add     cod, x2
 867         ~
 868         dec     x1
 869         je      direct_end
 870
 871         add     sym, sym
 872 direct_norm:
 873         lea     t1, [sym_R + (1 SHL kNumAlignBits)]
 874         cmp     range, kTopValue
 875         jae     near ptr direct_loop
 876         ; we align for 32 here with "near ptr" command above
 877         NORM_2
 878         jmp     direct_loop
 879
 880 MY_ALIGN_32
 881 direct_end:
 882         ;  prob =  + kAlign;
 883         ;  distance <<= kNumAlignBits;
 884         REV_0   x2, x1
 885         REV_1   x1, x2, 2
 886         REV_1   x2, x1, 4
 887         REV_2   x1, 8
 888
 889 decode_dist_end:
 890
 891         ; if (distance >= (checkDicSize == 0 ? processedPos: checkDicSize))
 892
 893         mov     t0, LOC checkDicSize
 894         test    t0, t0
 895         cmove   t0, processedPos
 896         cmp     sym, t0
 897         jae     end_of_payload
 898
 899         ; rep3 = rep2;
 900         ; rep2 = rep1;
 901         ; rep1 = rep0;
 902         ; rep0 = distance + 1;
 903
 904         inc     sym
 905         mov     t0, LOC rep0
 906         mov     t1, LOC rep1
 907         mov     x1, LOC rep2
 908         mov     LOC rep0, sym
 909         ; mov     sym, LOC remainLen
 910         mov     sym, len_temp
 911         mov     LOC rep1, t0
 912         mov     LOC rep2, t1
 913         mov     LOC rep3, x1
 914
 915         ; state = (state < kNumStates + kNumLitStates) ? kNumLitStates : kNumLitStates + 3;
 916         cmp     state, (kNumStates + kNumLitStates) * PMULT
 917         mov     state, kNumLitStates * PMULT
 918         mov     t0, (kNumLitStates + 3) * PMULT
 919         cmovae  state, t0
 920
 921
 922 ; ---------- COPY MATCH ----------
 923 copy_match:
 924
 925         ; len += kMatchMinLen;
 926         ; add     sym, kMatchMinLen
 927
 928         ; if ((rem = limit - dicPos) == 0)
 929         ; {
 930         ;   p->dicPos = dicPos;
 931         ;   return SZ_ERROR_DATA;
 932         ; }
 933         mov     cnt_R, LOC limit
 934         sub     cnt_R, dicPos
 935         jz      fin_ERROR
 936
 937         ; curLen = ((rem < len) ? (unsigned)rem : len);
 938         cmp     cnt_R, sym_R
 939         ; cmovae  cnt_R, sym_R ; 64-bit
 940         cmovae  cnt, sym ; 32-bit
 941
 942         mov     dic, LOC dic_Spec
 943         mov     x1, LOC rep0
 944
 945         mov     t0_R, dicPos
 946         add     dicPos, cnt_R
 947         ; processedPos += curLen;
 948         add     processedPos, cnt
 949         ; len -= curLen;
 950         sub     sym, cnt
 951         mov     LOC remainLen, sym
 952
 953         sub     t0_R, dic
 954
 955         ; pos = dicPos - rep0 + (dicPos < rep0 ? dicBufSize : 0);
 956         sub     t0_R, r1
 957         jae     @f
 958
 959         mov     r1, LOC dicBufSize
 960         add     t0_R, r1
 961         sub     r1, t0_R
 962         cmp     cnt_R, r1
 963         ja      copy_match_cross
 964 @@:
 965         ; if (curLen <= dicBufSize - pos)
 966
 967 ; ---------- COPY MATCH FAST ----------
 968         ; Byte *dest = dic + dicPos;
 969         ; mov     r1, dic
 970         ; ptrdiff_t src = (ptrdiff_t)pos - (ptrdiff_t)dicPos;
 971         ; sub   t0_R, dicPos
 972         ; dicPos += curLen;
 973
 974         ; const Byte *lim = dest + curLen;
 975         add     t0_R, dic
 976         movzx   sym, byte ptr[t0_R]
 977         add     t0_R, cnt_R
 978         neg     cnt_R
 979         ; lea     r1, [dicPos - 1]
 980 copy_common:
 981         dec     dicPos
 982         ; cmp   LOC rep0, 1
 983         ; je    rep0Label
 984
 985         ; t0_R - src_lim
 986         ; r1 - dest_lim - 1
 987         ; cnt_R - (-cnt)
 988
 989         IsMatchBranch_Pre
 990         inc     cnt_R
 991         jz      copy_end
 992 MY_ALIGN_16
 993 @@:
 994         mov     byte ptr[cnt_R * 1 + dicPos], sym_L
 995         movzx   sym, byte ptr[cnt_R * 1 + t0_R]
 996         inc     cnt_R
 997         jnz     @b
 998
 999 copy_end:
1000 lz_end_match:
1001         mov     byte ptr[dicPos], sym_L
1002         inc     dicPos
1003
1004         ; IsMatchBranch_Pre
1005         CheckLimits
1006 lz_end:
1007         IF_BIT_1_NOUP probs_state_R, pbPos_R, IsMatch, IsMatch_label
1008
1009
1010
1011 ; ---------- LITERAL MATCHED ----------
1012
1013         LIT_PROBS LOC lpMask
1014
1015         ; matchByte = dic[dicPos - rep0 + (dicPos < rep0 ? dicBufSize : 0)];
1016         mov     x1, LOC rep0
1017         ; mov     dic, LOC dic_Spec
1018         mov     LOC dicPos_Spec, dicPos
1019
1020         ; state -= (state < 10) ? 3 : 6;
1021         lea     t0, [state_R - 6 * PMULT]
1022         sub     state, 3 * PMULT
1023         cmp     state, 7 * PMULT
1024         cmovae  state, t0
1025
1026         sub     dicPos, dic
1027         sub     dicPos, r1
1028         jae     @f
1029         add     dicPos, LOC dicBufSize
1030 @@:
1031         comment ~
1032         xor     t0, t0
1033         sub     dicPos, r1
1034         cmovb   t0_R, LOC dicBufSize
1035         ~
1036
1037         movzx   match, byte ptr[dic + dicPos * 1]
1038
1039     ifdef _LZMA_SIZE_OPT
1040
1041         mov     offs, 256 * PMULT
1042         shl     match, (PSHIFT + 1)
1043         mov     bit, match
1044         mov     sym, 1
1045 MY_ALIGN_16
1046 litm_loop:
1047         LITM
1048         cmp     sym, 256
1049         jb      litm_loop
1050         sub     sym, 256
1051
1052     else
1053
1054         LITM_0
1055         LITM
1056         LITM
1057         LITM
1058         LITM
1059         LITM
1060         LITM
1061         LITM_2
1062
1063     endif
1064
1065         mov     probs, LOC probs_Spec
1066         IsMatchBranch_Pre
1067         ; mov     dic, LOC dic_Spec
1068         mov     dicPos, LOC dicPos_Spec
1069         mov     byte ptr[dicPos], sym_L
1070         inc     dicPos
1071
1072         CheckLimits
1073 lit_matched_end:
1074         IF_BIT_1_NOUP probs_state_R, pbPos_R, IsMatch, IsMatch_label
1075         ; IsMatchBranch
1076         mov     lpMask_reg, LOC lpMask
1077         sub     state, 3 * PMULT
1078         jmp     lit_start_2
1079
1080
1081
1082 ; ---------- REP 0 LITERAL ----------
1083 MY_ALIGN_32
1084 IsRep0Short_label:
1085         UPDATE_0 probs_state_R, pbPos_R, IsRep0Long
1086
1087         ; dic[dicPos] = dic[dicPos - rep0 + (dicPos < rep0 ? dicBufSize : 0)];
1088         mov     dic, LOC dic_Spec
1089         mov     t0_R, dicPos
1090         mov     probBranch, LOC rep0
1091         sub     t0_R, dic
1092
1093         sub     probs, RepLenCoder * PMULT
1094         inc     processedPos
1095         ; state = state < kNumLitStates ? 9 : 11;
1096         or      state, 1 * PMULT
1097         IsMatchBranch_Pre
1098
1099         sub     t0_R, probBranch_R
1100         jae     @f
1101         add     t0_R, LOC dicBufSize
1102 @@:
1103         movzx   sym, byte ptr[dic + t0_R * 1]
1104         jmp     lz_end_match
1105
1106
1107 MY_ALIGN_32
1108 IsRep_label:
1109         UPDATE_1 probs_state_R, 0, IsRep
1110
1111         ; The (checkDicSize == 0 && processedPos == 0) case was checked before in LzmaDec.c with kBadRepCode.
1112         ; So we don't check it here.
1113
1114         ; mov     t0, processedPos
1115         ; or      t0, LOC checkDicSize
1116         ; jz      fin_ERROR_2
1117
1118         ; state = state < kNumLitStates ? 8 : 11;
1119         cmp     state, kNumLitStates * PMULT
1120         mov     state, 8 * PMULT
1121         mov     probBranch, 11 * PMULT
1122         cmovae  state, probBranch
1123
1124         ; prob = probs + RepLenCoder;
1125         add     probs, RepLenCoder * PMULT
1126
1127         IF_BIT_1 probs_state_R, 0, IsRepG0, IsRepG0_label
1128         IF_BIT_0_NOUP probs_state_R, pbPos_R, IsRep0Long, IsRep0Short_label
1129         UPDATE_1 probs_state_R, pbPos_R, IsRep0Long
1130         jmp     len_decode
1131
1132 MY_ALIGN_32
1133 IsRepG0_label:
1134         UPDATE_1 probs_state_R, 0, IsRepG0
1135         mov     dist2, LOC rep0
1136         mov     dist, LOC rep1
1137         mov     LOC rep1, dist2
1138
1139         IF_BIT_1 probs_state_R, 0, IsRepG1, IsRepG1_label
1140         mov     LOC rep0, dist
1141         jmp     len_decode
1142
1143 ; MY_ALIGN_32
1144 IsRepG1_label:
1145         UPDATE_1 probs_state_R, 0, IsRepG1
1146         mov     dist2, LOC rep2
1147         mov     LOC rep2, dist
1148
1149         IF_BIT_1 probs_state_R, 0, IsRepG2, IsRepG2_label
1150         mov     LOC rep0, dist2
1151         jmp     len_decode
1152
1153 ; MY_ALIGN_32
1154 IsRepG2_label:
1155         UPDATE_1 probs_state_R, 0, IsRepG2
1156         mov     dist, LOC rep3
1157         mov     LOC rep3, dist2
1158         mov     LOC rep0, dist
1159         jmp     len_decode
1160
1161
1162
1163 ; ---------- SPEC SHORT DISTANCE ----------
1164
1165 MY_ALIGN_32
1166 short_dist:
1167         sub     x1, 32 + 1
1168         jbe     decode_dist_end
1169         or      sym, 2
1170         shl     sym, x1_L
1171         lea     sym_R, [probs + sym_R * PMULT + SpecPos * PMULT + 1 * PMULT]
1172         mov     sym2, PMULT ; step
1173 MY_ALIGN_32
1174 spec_loop:
1175         REV_1_VAR x2
1176         dec     x1
1177         jnz     spec_loop
1178
1179         mov     probs, LOC probs_Spec
1180         sub     sym, sym2
1181         sub     sym, SpecPos * PMULT
1182         sub     sym_R, probs
1183         shr     sym, PSHIFT
1184
1185         jmp     decode_dist_end
1186
1187
1188 ; ---------- COPY MATCH CROSS ----------
1189 copy_match_cross:
1190         ; t0_R - src pos
1191         ; r1 - len to dicBufSize
1192         ; cnt_R - total copy len
1193
1194         mov     t1_R, t0_R         ; srcPos
1195         mov     t0_R, dic
1196         mov     r1, LOC dicBufSize   ;
1197         neg     cnt_R
1198 @@:
1199         movzx   sym, byte ptr[t1_R * 1 + t0_R]
1200         inc     t1_R
1201         mov     byte ptr[cnt_R * 1 + dicPos], sym_L
1202         inc     cnt_R
1203         cmp     t1_R, r1
1204         jne     @b
1205
1206         movzx   sym, byte ptr[t0_R]
1207         sub     t0_R, cnt_R
1208         jmp     copy_common
1209
1210
1211
1212
1213 fin_ERROR:
1214         mov     LOC remainLen, len_temp
1215 ; fin_ERROR_2:
1216         mov     sym, 1
1217         jmp     fin
1218
1219 end_of_payload:
1220         cmp     sym, 0FFFFFFFFh ; -1
1221         jne     fin_ERROR
1222
1223         mov     LOC remainLen, kMatchSpecLenStart
1224         sub     state, kNumStates * PMULT
1225
1226 fin_OK:
1227         xor     sym, sym
1228
1229 fin:
1230         NORM
1231
1232         mov     r1, LOC lzmaPtr
1233
1234         sub     dicPos, LOC dic_Spec
1235         mov     GLOB dicPos_Spec, dicPos
1236         mov     GLOB buf_Spec, buf
1237         mov     GLOB range_Spec, range
1238         mov     GLOB code_Spec, cod
1239         shr     state, PSHIFT
1240         mov     GLOB state_Spec, state
1241         mov     GLOB processedPos_Spec, processedPos
1242
1243         RESTORE_VAR(remainLen)
1244         RESTORE_VAR(rep0)
1245         RESTORE_VAR(rep1)
1246         RESTORE_VAR(rep2)
1247         RESTORE_VAR(rep3)
1248
1249         mov     x0, sym
1250
1251         mov     RSP, LOC Old_RSP
1252
1253 MY_POP_PRESERVED_REGS
1254 MY_ENDP
1255
1256 _TEXT$LZMADECOPT ENDS
1257
1258 end