/* chunkset_tpl.h -- inline functions to copy small data chunks.

 * For conditions of distribution and use, see copyright notice in zlib.h

 */

#include "zbuild.h"

#include <stdlib.h>

/* Returns the chunk size */

static inline size_t CHUNKSIZE(void) {

    return sizeof(chunk_t);

}

Unexecuted instantiation: chunkset_sse2.c:chunksize_sse2

Unexecuted instantiation: chunkset_ssse3.c:chunksize_ssse3

Unexecuted instantiation: chunkset_avx2.c:chunksize_avx2

Unexecuted instantiation: chunkset_avx512.c:chunksize_avx512

/* Behave like memcpy, but assume that it's OK to overwrite at least

   chunk_t bytes of output even if the length is shorter than this,

   that the length is non-zero, and that `from` lags `out` by at least

   sizeof chunk_t bytes (or that they don't overlap at all or simply that

   the distance is less than the length of the copy).

   Aside from better memory bus utilization, this means that short copies

   (chunk_t bytes or fewer) will fall straight through the loop

   without iteration, which will hopefully make the branch prediction more

   reliable. */

#ifndef HAVE_CHUNKCOPY

static inline uint8_t* CHUNKCOPY(uint8_t *out, uint8_t const *from, size_t len) {

    Assert(len > 0, "chunkcopy should never have a length 0");

    chunk_t chunk;

    size_t align = ((len - 1) % sizeof(chunk_t)) + 1;

    loadchunk(from, &chunk);

    storechunk(out, &chunk);

    out += align;

    from += align;

    len -= align;

    while (len > 0) {

        loadchunk(from, &chunk);

        storechunk(out, &chunk);

        out += sizeof(chunk_t);

        from += sizeof(chunk_t);

        len -= sizeof(chunk_t);

    }

    return out;

}

Unexecuted instantiation: chunkset_sse2.c:chunkcopy_sse2

Unexecuted instantiation: chunkset_ssse3.c:chunkcopy_ssse3

Unexecuted instantiation: chunkset_avx2.c:chunkcopy_avx2

#endif

/* Perform short copies until distance can be rewritten as being at least

   sizeof chunk_t.

   This assumes that it's OK to overwrite at least the first

   2*sizeof(chunk_t) bytes of output even if the copy is shorter than this.

   This assumption holds because inflate_fast() starts every iteration with at

   least 258 bytes of output space available (258 being the maximum length

   output from a single token; see inflate_fast()'s assumptions below). */

static inline uint8_t* CHUNKUNROLL(uint8_t *out, unsigned *dist, unsigned *len) {

    unsigned char const *from = out - *dist;

    chunk_t chunk;

    while (*dist < *len && *dist < sizeof(chunk_t)) {

        loadchunk(from, &chunk);

        storechunk(out, &chunk);

        out += *dist;

        *len -= *dist;

        *dist += *dist;

    }

    return out;

}

Unexecuted instantiation: chunkset_sse2.c:chunkunroll_sse2

Unexecuted instantiation: chunkset_ssse3.c:chunkunroll_ssse3

Unexecuted instantiation: chunkset_avx2.c:chunkunroll_avx2

Unexecuted instantiation: chunkset_avx512.c:chunkunroll_avx512

#ifndef HAVE_CHUNK_MAG

/* Loads a magazine to feed into memory of the pattern */

static inline chunk_t GET_CHUNK_MAG(uint8_t *buf, size_t *chunk_rem, size_t dist) {

        /* This code takes string of length dist from "from" and repeats

         * it for as many times as can fit in a chunk_t (vector register) */

        size_t cpy_dist;

        size_t bytes_remaining = sizeof(chunk_t);

        chunk_t chunk_load;

        uint8_t *cur_chunk = (uint8_t *)&chunk_load;

        while (bytes_remaining) {

            cpy_dist = MIN(dist, bytes_remaining);

            memcpy(cur_chunk, buf, cpy_dist);

            bytes_remaining -= cpy_dist;

            cur_chunk += cpy_dist;

            /* This allows us to bypass an expensive integer division since we're effectively

             * counting in this loop, anyway */

            *chunk_rem = cpy_dist;

        }

        return chunk_load;

}

#endif

#if defined(HAVE_HALF_CHUNK) && !defined(HAVE_HALFCHUNKCOPY)

static inline uint8_t* HALFCHUNKCOPY(uint8_t *out, uint8_t const *from, size_t len) {

    Assert(len > 0, "halfchunkcopy should never have a length 0");

    halfchunk_t chunk;

    size_t align = ((len - 1) % sizeof(halfchunk_t)) + 1;

    loadhalfchunk(from, &chunk);

    storehalfchunk(out, &chunk);

    out += align;

    from += align;

    len -= align;

    while (len > 0) {

        loadhalfchunk(from, &chunk);

        storehalfchunk(out, &chunk);

        out += sizeof(halfchunk_t);

        from += sizeof(halfchunk_t);

        len -= sizeof(halfchunk_t);

    }

    return out;

}

#endif

/* Copy DIST bytes from OUT - DIST into OUT + DIST * k, for 0 <= k < LEN/DIST.

   Return OUT + LEN. */

static inline uint8_t* CHUNKMEMSET(uint8_t *out, uint8_t *from, size_t len) {

    /* Debug performance related issues when len < sizeof(uint64_t):

       Assert(len >= sizeof(uint64_t), "chunkmemset should be called on larger chunks"); */

    Assert(from != out, "chunkmemset cannot have a distance 0");

    chunk_t chunk_load;

    size_t chunk_mod = 0;

    size_t adv_amount;

    size_t dist = (size_t)ABS(out - from);

    /* We are supporting the case for when we are reading bytes from ahead in the buffer.

     * We now have to handle this, though it wasn't _quite_ clear if this rare circumstance

     * always needed to be handled here or if we're just now seeing it because we are

     * dispatching to this function, more */

    if (out < from && dist < len) {

#ifdef HAVE_MASKED_READWRITE

        if (len <= sizeof(chunk_t)) {

            loadchunk_masked(from, &chunk_load, len);

            storechunk_masked(out, &chunk_load, len);

            return out + len;

        }

#endif

        /* Here the memmove semantics match perfectly, as when this happens we are

         * effectively sliding down the contents of memory by dist bytes */

        memmove(out, from, len);

        return out + len;

    }

#ifndef HAVE_CHUNKMEMSET_1

    if (dist == 1) {

        memset(out, *from, len);

        return out + len;

    } else

#endif

    if (dist >= len || dist >= sizeof(chunk_t)) {

        return CHUNKCOPY(out, from, len);

    }

    /* Only AVX2+ as there's 128 bit vectors and 256 bit. We allow for shorter vector

     * lengths because they serve to allow more cases to fall into chunkcopy, as the

     * distance of the shorter length is still deemed a safe distance. We rewrite this

     * here rather than calling the ssse3 variant directly now because doing so required

     * dispatching to another function and broke inlining for this function entirely. We

     * also can merge an assert and some remainder peeling behavior into the same code blocks,

     * making the code a little smaller.  */

#ifdef HAVE_HALF_CHUNK

    if (dist > 1 && len <= sizeof(halfchunk_t)) {

        if (dist >= sizeof(halfchunk_t))

            return HALFCHUNKCOPY(out, from, len);

        if ((dist % 2) != 0 || dist == 6) {

            halfchunk_t halfchunk_load = GET_HALFCHUNK_MAG(from, &chunk_mod, dist);

            if (len == sizeof(halfchunk_t)) {

                storehalfchunk(out, &halfchunk_load);

                len -= sizeof(halfchunk_t);

                out += sizeof(halfchunk_t);

            }

            chunk_load = halfchunk2whole(&halfchunk_load);

            goto rem_bytes;

        }

    }

#endif

#ifdef HAVE_CHUNKMEMSET_1

    /* Broadcast + chunk store beats memset on NEON/AVX2/AVX-512 */

    if (dist == 1) {

        chunkmemset_1(from, &chunk_load);

    } else

#endif

#ifdef HAVE_CHUNKMEMSET_2

    if (dist == 2) {

        chunkmemset_2(from, &chunk_load);

    } else

#endif

#ifdef HAVE_CHUNKMEMSET_4

    if (dist == 4) {

        chunkmemset_4(from, &chunk_load);

    } else

#endif

#ifdef HAVE_CHUNKMEMSET_8

    if (dist == 8) {

        chunkmemset_8(from, &chunk_load);

    } else

#endif

#ifdef HAVE_CHUNKMEMSET_16

    if (dist == 16) {

        chunkmemset_16(from, &chunk_load);

    } else

#endif

    chunk_load = GET_CHUNK_MAG(from, &chunk_mod, dist);

    if (len <= sizeof(chunk_t)) {

#ifdef HAVE_MASKED_READWRITE

        storechunk_masked(out, &chunk_load, len);

#else

        storechunk(out, &chunk_load);

#endif

        return out + len;

    }

    adv_amount = sizeof(chunk_t) - chunk_mod;

    while (len >= (2 * sizeof(chunk_t))) {

        storechunk(out, &chunk_load);

        storechunk(out + adv_amount, &chunk_load);

        out += 2 * adv_amount;

        len -= 2 * adv_amount;

    }

    /* If we don't have a "dist" length that divides evenly into a vector

     * register, we can write the whole vector register but we need only

     * advance by the amount of the whole string that fits in our chunk_t.

     * If we do divide evenly into the vector length, adv_amount = chunk_t size*/

    while (len >= sizeof(chunk_t)) {

        storechunk(out, &chunk_load);

        len -= adv_amount;

        out += adv_amount;

    }

#ifdef HAVE_HALF_CHUNK

rem_bytes:

#endif

    if (len) {

#ifdef HAVE_MASKED_READWRITE

        storechunk_masked(out, &chunk_load, len);

        out += len;

#else

        uint8_t *chunk_p = (uint8_t *)&chunk_load;

        if (len & 16) { memcpy(out, chunk_p, 16); out += 16; chunk_p += 16; }

        if (len & 8) { memcpy(out, chunk_p, 8); out += 8; chunk_p += 8; }

        if (len & 4) { memcpy(out, chunk_p, 4); out += 4; chunk_p += 4; }

        if (len & 2) { memcpy(out, chunk_p, 2); out += 2; chunk_p += 2; }

        if (len & 1) { *out++ = *chunk_p; }

#endif

    }

    return out;

}

Unexecuted instantiation: chunkset_sse2.c:chunkmemset_sse2

Unexecuted instantiation: chunkset_ssse3.c:chunkmemset_ssse3

Unexecuted instantiation: chunkset_avx2.c:chunkmemset_avx2

Unexecuted instantiation: chunkset_avx512.c:chunkmemset_avx512

Z_INTERNAL uint8_t* CHUNKMEMSET_SAFE(uint8_t *out, uint8_t *from, size_t len, size_t left) {

#if OPTIMAL_CMP < 32

    static const uintptr_t align_mask = 7;

#elif OPTIMAL_CMP == 32

    static const uintptr_t align_mask = 3;

#endif

    len = MIN(len, left);

#if OPTIMAL_CMP < 64

    while (((uintptr_t)out & align_mask) && (len > 0)) {

        *out++ = *from++;

        --len;

        --left;

    }

#endif

#ifndef HAVE_MASKED_READWRITE

    if (UNLIKELY(left < sizeof(chunk_t))) {

        while (len > 0) {

            *out++ = *from++;

            --len;

        }

        return out;

    }

#endif

    if (len)

        out = CHUNKMEMSET(out, from, len);

    return out;

}

Unexecuted instantiation: chunkmemset_safe_sse2

Unexecuted instantiation: chunkmemset_safe_ssse3

Unexecuted instantiation: chunkmemset_safe_avx2

Unexecuted instantiation: chunkmemset_safe_avx512

static inline uint8_t *CHUNKCOPY_SAFE(uint8_t *out, uint8_t *from, size_t len, uint8_t *safe)

{

    if (out == from)

        return out + len;

    size_t safelen = (safe - out);

    len = MIN(len, safelen);

#ifndef HAVE_MASKED_READWRITE

    size_t from_dist = (size_t)ABS(safe - from);

    if (UNLIKELY(from_dist < sizeof(chunk_t) || safelen < sizeof(chunk_t))) {

        while (len--) {

            *out++ = *from++;

        }

        return out;

    }

#endif

    return CHUNKMEMSET(out, from, len);

}

Unexecuted instantiation: chunkset_sse2.c:CHUNKCOPY_SAFE

Unexecuted instantiation: chunkset_ssse3.c:CHUNKCOPY_SAFE

Unexecuted instantiation: chunkset_avx2.c:CHUNKCOPY_SAFE

Unexecuted instantiation: chunkset_avx512.c:CHUNKCOPY_SAFE