ClamAV SIMD Fast Paths For Parser-Heavy Scanning

The vector version filters candidate positions by checking the first and last needle bytes across 16 starts at once:

const char *simd_memstr_neon(const char *haystack, size_t hs,
                             const char *needle, size_t ns)
{
    if (ns == 0) return haystack;
    if (hs < ns) return NULL;
    if (ns == 1) return memchr(haystack, needle[0], hs);

    const char first = needle[0];
    const char last  = needle[ns - 1];

    uint8x16_t first_vec = vdupq_n_u8((uint8_t)first);
    uint8x16_t last_vec  = vdupq_n_u8((uint8_t)last);

    size_t i = 0;
    size_t end = hs - ns + 1;

    while (i + 16 <= end) {
        uint8x16_t block_first = vld1q_u8((const uint8_t *)(haystack + i));
        uint8x16_t block_last  = vld1q_u8((const uint8_t *)(haystack + i + ns - 1));

        uint8x16_t eq_first = vceqq_u8(block_first, first_vec);
        uint8x16_t eq_last  = vceqq_u8(block_last, last_vec);
        uint8x16_t candidates = vandq_u8(eq_first, eq_last);

        uint64_t mask_lo = vgetq_lane_u64(vreinterpretq_u64_u8(candidates), 0);
        uint64_t mask_hi = vgetq_lane_u64(vreinterpretq_u64_u8(candidates), 1);

        while (mask_lo) {
            int pos = __builtin_ctzll(mask_lo) / 8;
            if (memcmp(haystack + i + pos + 1, needle + 1, ns - 2) == 0) {
                return haystack + i + pos;
            }
            mask_lo &= mask_lo - 1;
        }

        while (mask_hi) {
            int pos = 8 + __builtin_ctzll(mask_hi) / 8;
            if (memcmp(haystack + i + pos + 1, needle + 1, ns - 2) == 0) {
                return haystack + i + pos;
            }
            mask_hi &= mask_hi - 1;
        }

        i += 16;
    }

    for (; i < end; ++i) {
        if (haystack[i] == first && haystack[i + ns - 1] == last) {
            if (memcmp(haystack + i + 1, needle + 1, ns - 2) == 0) {
                return haystack + i;
            }
        }
    }

    return NULL;
}

bool simd_hash_equal(const uint8_t *a, const uint8_t *b, hash_type_t type)
{
    size_t size;
    switch (type) {
        case HASH_MD5:    size = 16; break;
        case HASH_SHA1:   size = 20; break;
        case HASH_SHA256: size = 32; break;
        default: return memcmp(a, b, 16) == 0;
    }

    if (size == 16) {
        uint8x16_t va = vld1q_u8(a);
        uint8x16_t vb = vld1q_u8(b);
        uint8x16_t cmp = vceqq_u8(va, vb);
        return vminvq_u8(cmp) == 0xFF;
    } else if (size == 32) {
        uint8x16_t va0 = vld1q_u8(a);
        uint8x16_t va1 = vld1q_u8(a + 16);
        uint8x16_t vb0 = vld1q_u8(b);
        uint8x16_t vb1 = vld1q_u8(b + 16);

        uint8x16_t cmp0 = vceqq_u8(va0, vb0);
        uint8x16_t cmp1 = vceqq_u8(va1, vb1);
        uint8x16_t cmp = vandq_u8(cmp0, cmp1);
        return vminvq_u8(cmp) == 0xFF;
    }

    return memcmp(a, b, size) == 0;
}

ssize_t simd_base64_decode(const char *input, size_t len,
                           uint8_t *output, size_t out_capacity)
{
    while (in + 16 <= input + len) {
        uint8x16_t data = vld1q_u8((const uint8_t *)in);

        uint8x16_t decoded = base64_lookup_neon(data);
        uint8x16_t packed  = base64_pack_neon(decoded);

        vst1q_u8(out, packed);

        in  += 16;
        out += 12;
    }

    /* scalar tail */
}

Summary claim:

One important warning survived the prototype:

• base64 with embedded whitespace was much worse than clean-input base64;
• that means surrounding whitespace stripping remained a real bottleneck.