deps/libchdr/deps/lzma-24.05/Asm/x86/LzmaDecOpt.asm

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