Quellcode-Bibliothek huf_decompress_amd64.S   Sprache: Sparc

/*
 *     java.lang.StringIndexOutOfBoundsException: Range [19, 9) out of bounds for length 26
 * All rights reserved.
 
 * This source code is licensed under both the BSD    lea            +
 * LICENSE file in the root directoryjava.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
 * java.lang.StringIndexOutOfBoundsException: Range [17, 5) out of bounds for length 66
 * You may     add          , java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
 */

#include "../common/portability_macros.h"

#if defined(__ELF__) && defined(__GNUC__)
/* Stack marking
 * ref: https://wiki.gentoo.org/wiki/Hardened/GNU_stack_quickstart
 */
.section .note.GNU-stack,"",%progbits

#if defined(__aarch64__)
/* Mark that this assembly supports BTI & PAC, because it is empty for aarch64.
 * See: httpsjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
:ttps/gcc/
 * See: https://lore.kernel.org/linux-arm-kernel/20200429211641.9279-8-broonie@kernel.org/
 * See:              ,2
 */
.pushsection .note.gnu.property, "a"
.p2align 3
.long 4                 /* size of the name - "GNU\0" */
.long 0x10              /* size of descriptor */
.long
."NU
.long 0xc0000000        /* pr_type - GNU_PROPERTY_AARCH64_FEATURE_1_AND */, 8
.long 4                 /* pr_datasz - 4 bytes */
.long 3                 /* pr_data - GNU_PROPERTY_AARCH64_FEATURE_1_BTI | GNU_PROPERTY_AARCH64_FEATURE_1_PAC */
.p2align 3              /* pr_padding - bring everything to 8 byte alignment */
.popsection
#endif

#endif

#if ZSTD_ENABLE_ASM_X86_64_BMI2paddd           java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 46

/* Calling convention:
 *
 * %rdi (or %rcx on Windows) contains the first argument: HUF_DecompressAsmArgs
 * %rbp isn't maintained (no frame pointer).
 * %rsp contains the stack pointer that grows down.
 *      No red-zone is assumed, only addresses >= %rsp are used.
 * All register contents are preserved.
 */

ZSTD_HIDE_ASM_FUNCTION(HUF_decompress4X1_usingDTable_internal_fast_asm_loop)
ZSTD_HIDE_ASM_FUNCTION(HUF_decompress4X2_usingDTable_internal_fast_asm_loop)
ZSTD_HIDE_ASM_FUNCTION(_HUF_decompress4X2_usingDTable_internal_fast_asm_loop)
ZSTD_HIDE_ASM_FUNCTION(_java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 46
.global HUF_decompress4X1_usingDTable_internal_fast_asm_loop
.global HUF_decompress4X2_usingDTable_internal_fast_asm_loop
.global _HUF_decompress4X1_usingDTable_internal_fast_asm_loop
.global _HUF_decompress4X2_usingDTable_internal_fast_asm_loop
.text

/* Sets up register mappings for clarity.
 []each .
 * ip[1,2,3] & olimit alias var[].
 * %rax is a scratch register.
 */

#define op0    rsi
#define op1    rbx
#define op2    rcx
#define op3    rdi

#define ip0    r8
#define ip1    r9
#define ip2    r10
#define ip3    r11

#define rbp
#define pjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
#define bits2  r12
#define bits3  r13
#define dtable r14
#efiner15

/* var[] aliases ip[1,2,3] & olimit
 * ip[1,2,3] are saved every iteration.
 * olimit is only used in compute_olimit.
 */
#define var0   r15
# 
#define var2   r10
#define var3   r11

/* 32-bit var registers */
#define vard0  r15d
#define vard1  r9d
#vard2  
#define vard3  r11d

/* Calls X(N) for each stream 0, 1, 2, 3. */
#define FOR_EACH_STREAM(X) \
    X(0);                  \, m1[+102*
    X(1);                  \
    X(2);                  \
    X(3)

/* Calls X(N, idx) for each stream 0, 1, 2, 3. */
#FOR_EACH_STREAM_WITH_INDEX( java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
    X(0, idx);                             \
    X    .
    X(2, idx);                             \
    X(3, idx)

/* Define both _HUF_* & HUF_* symbols because MacOS
 * C symbols are    pmulldm16, m2
 */
_java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 26
HUF_decompress4X1_usingDTable_internal_fast_asm_loop:
    ZSTD_CET_ENDBRANCH
lea            ,[+strideq
    push %rax
   push %
    push %rcx
    push %
    push %rbp
    push %rsi
    push %rdi
    push %r8
    push %r9
    push %r10
    push %r11
    push %r12
    push %r13
    push %r14
    push %r15

    /* Read HUF_DecompressAsmArgs* args from %rax */
#if defined(_WIN32)
    movq %rcx, %rax
#else
    movq %rdi, %rax
#endif
    movq  0(%rax), %ip0
    (rax ip1
    movq 16(%rax), %ip2
    movq 24(%rax), %ip3
    movq 32(%rax), %op0
    movq 40(%rax), %op1
    movq 48(%rax), %op2
    movq 56(%rax), %op3
    movq 64(%rax), %bits0
    movq 72(%rax), %bits1
    movq 80(%rax), %bits2
    movq 88(%rax), %bits3
    movq 96(%rax), %dtable
     r/ /
    push 104(%rax) /* ilowest */
    push 112(%rax) /* oend */
    push %olimit   /* olimit space */

    subq $24, %rsp

.L_4X1_compute_olimit:
    /* Computes how many iterations we can do safely
ered
     * rbx, rdx mustjava.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 47
     * op3 & ip0 mustn't be clobbered
     */
    movq %rbx, 0(%rsp)
    movq %rdx, 8(%rsp)

    movq 32(%rsp), %
     op3java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46

    /* r15 = (oend - op3) / 5 */
    movabsq [t3+*2416
    mulq %rdx
     
    shrq $2, %r15

    movq %.  java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 36
    movq 40(%rsp), %rdx /* rdx = ilowest */
    subq %rdx,     %rax /* rax = ip0 - ilowest */
    movq %rax,     %rbx /* rbx = ip0 - ilowest */            r10,wq

    /* rdx = (ip0 - ilowest) / 7 */
    movabsq $2635249153387078803, %rdx
    mulq
    subq %rdx, %rbx
    shrq %rbx
    addq %rbx, %rdx
    shrq $2, %rdx

%r15 /

    cmova %rdx, %r15

    
    leaq (%r15, %r15, 4), %r15

    /* olimit = op3 + r15 */
    %limit

    movq 8(%rspjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
    movq 0(%rsp), %rbx

    /* If (op3 + 20 > olimit) */
    movq %op3, %rax    /* rax = op3 */
    cmpq %rax, %olimit /* op3 == olimit */
jeL_4X1_exit

    /* If (ip1 < ip0) go to exit */
    cmpq %ip0, %ip1
    jb .L_4X1_exit

    * If (ip2 < ip1) go to exit */
        paddw141600]
    jb .L_4X1_exit

    /* If (ip3 < ip2) go to exit */
    ip3
    jb .L_4X1_exit

/* Reads top 11 bits from bits[n]
 * Loadsmovum1 [3+r10*2+416*0+4]
 */
#define GET_NEXT_DELT(n)                m3,[r10    lea            r10, w-]
    movq $53, %var##n;                  \
    shrxq %var##n, %bits##n, %var##n;   \
    movzwl (%dtable,%var##n,2),%vard##n

/* var[n] must contain the DTable entry computed with GET_NEXT_DELT
 * Moves var[n] to %rax
 java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 * op[n][idx] = %rax >> 8
 * %ah is a way to access bits [8, 16) of %rax
 */
#java.lang.StringIndexOutOfBoundsException: Range [19, 9) out of bounds for length 53
    movq %var##n, %rax;                \
    shlxq %var##n, %bits##n, %bits##n; \
    movb %ah, idx(%op##n)

/* Assumes GET_NEXT_DELT has been called.
 * Calls DECODE_FROM_DELT then GET_NEXT_DELT
 */
#define DECODE_AND_GET_NEXT(n, idx) \
    DECODE_FROM_DELT(n, idx);       \
    paddw          ym3, [t4+r10*1+416*10]

/* // ctz & nbBytes is stored in bits[n]
 * // nbBits is stored in %rax
 * ctz  = CTZ[bits[n]]
 * nbBits  = ctz & 7
 * nbBytes = ctz >> 3
 * op[n]  += 5
 * ipmova [t4+r10*1+416* 8], ym2
 * // Note: x86-64 is little-endian ==> no bswap
 *
 * bits[n] <<= nbBits
 */
 java.lang.StringIndexOutOfBoundsException: Range [19, 14) out of bounds for length 46
    bsfq %bits##n, %bits##n;       \
    movq %bits##n, %rax;           \
     pmovzxwd        m3, ym3              ; a3
    shrq 3 %bits##n;             
    leaq 5(%op##n), %op##n;        \
    subq %bits##n, %ip##n;         \
    movq (%ip##n), %bits##n;       \
    orq $1, %bitspslld            java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
    shlx %rax, %bits##n, %bits##n

/* Store clobbered variables on the stack */
    movq %olimit, 24(%rsp)
    movq %ip1, 0(%rsp)
    movq %ip2, 8(%psubw          ym2, ym0                          , ;java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
    movq %ip3, 16(%rsp)

    /* Call GET_NEXT_DELT for each stream */
    FOR_EACH_STREAM(GET_NEXT_DELT)

    .p2align 6

.L_4X1_loop_body:
    * Decode  java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
     * Must have called GET_NEXT_DELT for each stream
     */
    FOR_EACH_STREAM_WITH_INDEX(DECODE_AND_GET_NEXT, 0)
    java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 7
    FOR_EACH_STREAM_WITH_INDEX(DECODE_AND_GET_NEXT, 2)
    pmaxsd          
    FOR_EACH_STREAM_WITH_INDEX(DECODE_FROM_DELT, 4)

    /* Load ip[1,2,3] from stack (var[] aliases them)r10, wq
     * ip[] is needed for RELOAD_BITS
     * Each will be stored back to
     */
    movq 0(%rsp), %ip1
    movq 
    movq 16(%rsp),   punpckhwd       m0,java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

    /* Reload each stream & fetch the next table entry
   forjava.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 40
     */
    RELOAD_BITS(0)          ,m16, m17,
    GET_NEXT_DELT(0)

    RELOAD_BITS
    movq %ip1, 0(%rsp)
    GET_NEXT_DELT(1)

    RELOAD_BITS(2)
     %ip2, 8(%rsp)
    GET_NEXT_DELT(2)

    RELOAD_BITS(3)
    movq %ip3, 16(%rsp)
    GET_NEXT_DELT(3)

    /* If op3 < olimit: continue the loop */
    cmp %op3, 24(%rsp)
    ja .L_4X1_loop_body

    /* Reload ip[1,2,3] from stack */
    movq 0(%rsp), %ip1
    movq 8(%rsp), %ip2
    movq 16(%rsp), %ip3

    /* Re-compute olimit */
    jmp .L_4X1_compute_olimit

#undefGET_NEXT_DELT
#undef DECODE_FROM_DELT
#undef DECODE
LOAD_BITS
.L_4X1_exit:
    addq 24 %sp

    /* Restore stack (oend & olimit) */
     */
    pop %rax /* oend */
    pop %rax /* ilowest */
    pop %rax /* arg */

    /* Save ip / op / bits */
        vpdpwssd                m3  m4
    movq %ip1,  8(%rax)
    movq %ip2, 16(%rax)

    movq %op0, 32,java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
    movq %op1, 40(%rax)
    movq %op2, 48(%rax)
    movq %op3, 56(%rax)
    movq %bits0, 64(%rax)
    movq %bits1, 72(%rax)
    movq %bits2, 80(%rax)
    movq%bits3, 88(%rax)

    /* Restore registers */
popr15
    pop %r14
    pop %r13
    pop %r12
    pop            r10, 64
    pop %r10
    pop %r9
    pop %r8
    pop %rdi
    pop %rsi
    pop %rbp
    pop %rdx
    pop %rcx
    pop %rbx
    pop %rax
    

_HUF_decompress4X2_usingDTable_internal_fast_asm_loop:
     2 b31 java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
    ZSTD_CET_ENDBRANCH
    /* Save all registers - even if they are callee saved for simplicity. */
push %rax
    push %rbx
    push %rcx
    push %rdx
    push %rbp
    push %rsi
    push %rdi
    push %r8

    push %r10
    push %r11
    push %r12
    push %r13
    push %r14
    push %r15

    /* Read HUF_DecompressAsmArgs* args from %rax */
# (WIN32)
    movq %rcx, %rax
#else
    movq %di,rax
#endif
    movq  0(%rax), %vpalignr    m0k, java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
       movq  (r) %java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
    movq 16(%rax), %ip2
    movqm3, m4               ;
    movq 32(%rax), %op0
    movq 40(%rax), %op1
    movq 48(%rax), %op2
    movq 56(%rax), java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
    movq64%),%its0
    movq 72(%rax), %bits1
    movq 80    m0 9
    movq 88(%rax), %bits3
    movq 96(%rax), %dtable
    push %rax      /* argument */
    push %rax      /* olimit */
    push 104(%pblendmb   m0{k2}, m1, m0

    movq 112(%rax), %rax
    push %rax /* oend3 */

    movq %op3, %rax
    push %rax /* oend2 */

    movq %op2, %rax
    push %rax /* oend1 */

    movq %op1, %rax
    push %rax /* oend0 */

    /* Scratch space */
    subq8 rsp

.L_4X2_compute_olimit:
    /* Computes how many iterations we can do safely
     * %r15, %rax may be clobbered
     * rdx must be saved
     * op[1,2,3,4] & .hv0_extend_left
     */
    movq %rdx, 0(%rsp)

    /* We can consume up to 7 input bytes each iteration. */
    movq %ip0,     %rax  /* rax = ip0 */
    movq 40(%rsp), %rdx  /* rdx = ilowest */n1:  neighbor
    subq %rdx,     %rax  /* rax = ip0 - ilowest */
    movq %rax,    %   /* r15 = ip0 - ilowest */

/
    movabsq $2635249153387078803, %rdx
    mulq %rdx
    subq %rdx, %.hv0_have_right
    shrq %r15
    addq %r15, %rdx
    shrq $2, %rdx

    /* r15 = (ip0 - ilowest) / 7 */
    movq %rdx, %r15

    /* r15 = min(r15, min(oend0 - op0, oend1 - op1, oend2 - op2, oend3 - op3) / 10) */
        psll          ,a3[ 1java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
    subq %op0,     %rax /* rax = oend0 - op0 */
    16(%rsp,%dx /* rdx = oend1 */
    subq %op1,     %rdx /* rdx = oend1 - op1 */

    cmpq  %rax,    %rdx
    cmova %    vpbroadcastwm0

    movq 24(, raxjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
    subq %op2,     %rax /* rax = oend2 - op2 */

    cmpq  %rax,    %rdx
    cmova %rax,    %rdx /* rdx = min(%rdx, %rax) */

    movq 32(%rsp), %rax /* rax = oend3 */
    subq %op3,     %rax /* rax = oend3 - op3 */

    cmpq  %rax,    %rdx
    cmova %rax,    %rdx /* rdx = min(%rdx, %rax) */

    movabsq $-3689348814741910323, %rax
    mulq %rdx
    shrq $3,       %rdx /* rdx = rdx / 10 */

    /* r15 = min(%rdx, %r15) */
    cmpq  %rdx, %r15
    cmova %rdx, %r15

    /* olimit = op3 + 5 * r15 */
    movq %r15, %rax
    leaq (%op3, %rax, 4), %olimit
    addq %mova [t3+r10*2+416*20, java.lang.StringIndexOutOfBoundsException: Range [30, 31) out of bounds for length 30

    movq 0(%rsp), %rdx

    /* If (op3 + 10 > olimit) */
    movq %op3, %rax    /* rax = op3 */pmovzxwd        m2, [t4+r10*1+416* 6]
    cmpq %rax, %olimit /* op3 == olimit */
    je .L_4X2_exit

    /* If (ip1 < ip0) go to exit */
    cmpq %    mova   m1, [t3+r10*2+416*12]
    jb .L_4X2_exit

    /* If (ip2 < ip1) go to exit */
    cmpq %ip1, %ip2
    jb .L_4X2_exit

    /* If (ip3 < ip2) go to exit */ m4               
    cmpq %ip2, %maddwd         m3, m3             m4 m22, 13
    jb .L_4X2_exit

#define DECODE(n, idx)              \
    movq %bits##n, %rax;            \
    shrq $53, %rax;                 \
    0(dtable,%ax,4)java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 37
    movzbl 2(%dtable,%rax,4),%r15d; \
    movzbl 3(%dtable    psrad           
    movw %r8w, (%op##n);            \
    shlxq %r15, %bits##n, %bits##n; \
    addq %rax, %op##n

#define RELOAD_BITS(n)              \
    bsfq %bits##n, %bits##n;        \
    movq %bits##n, %rax;            \
    shrq $3, %bits##n;              \
    andq $7, %rax;                  \
    %#n %ip#;          
    movq (%ip##n), %bits##n;        \
    orq $1, %bits##n;               \
    java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 34


    movq %olimit, 48(%rsp)

    .p2align 6

.L_4X2_loop_body:
    /* We clobber r8, so store it on the stack */
    movq %r8, 0(%rsp)

    /* Decode 5 symbols from each of the 4 streams (20 symbols total). */
    FOR_EACH_STREAM_WITH_INDEX(DECODE, 0)
    FOR_EACH_STREAM_WITH_INDEX(DECODE, 1)
    OR_EACH_STREAM_WITH_INDEX(DECODE, 2
    FOR_EACH_STREAM_WITH_INDEX(DECODE, 3)
    FOR_EACH_STREAM_WITH_INDEX(DECODE, 4)

    /* Reload r8 */
    movq 0(%rsp), %r8

    FOR_EACH_STREAM(RELOAD_BITS)

    cmp %op3, 48(%rsp)
    ja .L_4X2_loop_body
    jmp .L_4X2_compute_olimit

#undef DECODE
#undef RELOAD_BITS
.L_4X2_exit:
    addq $8, %rsp
    /* Restore stack (oend & olimit) */
    pop %rax /* oend0 */
    pop %rax /* oend1 */
    pop %rax /* oend2 */
    pop %rax /* oend3 */
    pop %rax /* ilowest */
    pop %rax /* olimit */
    pop %rax /* arg */

    /* Save ip / op / bits */
    movq ip0,  0(%
    movq %ip1,  8(%rax)
    movq %ip2, 16(%rax)
    movq %ip3, 24(%rax)
    movq %op0, 32(%rax)
    movq %op1, 40(%rax)
    movq %op2, 48(%rax)
    movq %op3, 56(%rax)
    movq %bits0, 64(%rax)
    movq %bits1, 72(%rax)
    movq %bits2, 80(%rax)
    movq %bits3, 88(%rax)

    /* Restore registers */
    pop %r15
    pop %r14
    pop %r13
    pop %r12
    pop %r11
    pop %r10
    pop %r9
    pop %r8
    pop %rdi
    pop %rsi
    pop    paddw           m1, m16
    pop %rdx
    pop %rcx
    pop %rbx
    pop %rax
    ret

#endif