// SPDX-License-Identifier: GPL-2.0-or-later
#include "xor_impl.h"

static void
xor_32regs_2(unsigned long bytes, unsigned long * __restrict p1,
             const unsigned long * __restrict p2)
{
        long lines = bytes / (sizeof (long)) / 8;

        do {
                register long d0, d1, d2, d3, d4, d5, d6, d7;
                d0 = p1[0];     /* Pull the stuff into registers        */
                d1 = p1[1];     /*  ... in bursts, if possible.         */
                d2 = p1[2];
                d3 = p1[3];
                d4 = p1[4];
                d5 = p1[5];
                d6 = p1[6];
                d7 = p1[7];
                d0 ^= p2[0];
                d1 ^= p2[1];
                d2 ^= p2[2];
                d3 ^= p2[3];
                d4 ^= p2[4];
                d5 ^= p2[5];
                d6 ^= p2[6];
                d7 ^= p2[7];
                p1[0] = d0;     /* Store the result (in bursts)         */
                p1[1] = d1;
                p1[2] = d2;
                p1[3] = d3;
                p1[4] = d4;
                p1[5] = d5;
                p1[6] = d6;
                p1[7] = d7;
                p1 += 8;
                p2 += 8;
        } while (--lines > 0);
}

static void
xor_32regs_3(unsigned long bytes, unsigned long * __restrict p1,
             const unsigned long * __restrict p2,
             const unsigned long * __restrict p3)
{
        long lines = bytes / (sizeof (long)) / 8;

        do {
                register long d0, d1, d2, d3, d4, d5, d6, d7;
                d0 = p1[0];     /* Pull the stuff into registers        */
                d1 = p1[1];     /*  ... in bursts, if possible.         */
                d2 = p1[2];
                d3 = p1[3];
                d4 = p1[4];
                d5 = p1[5];
                d6 = p1[6];
                d7 = p1[7];
                d0 ^= p2[0];
                d1 ^= p2[1];
                d2 ^= p2[2];
                d3 ^= p2[3];
                d4 ^= p2[4];
                d5 ^= p2[5];
                d6 ^= p2[6];
                d7 ^= p2[7];
                d0 ^= p3[0];
                d1 ^= p3[1];
                d2 ^= p3[2];
                d3 ^= p3[3];
                d4 ^= p3[4];
                d5 ^= p3[5];
                d6 ^= p3[6];
                d7 ^= p3[7];
                p1[0] = d0;     /* Store the result (in bursts)         */
                p1[1] = d1;
                p1[2] = d2;
                p1[3] = d3;
                p1[4] = d4;
                p1[5] = d5;
                p1[6] = d6;
                p1[7] = d7;
                p1 += 8;
                p2 += 8;
                p3 += 8;
        } while (--lines > 0);
}

static void
xor_32regs_4(unsigned long bytes, unsigned long * __restrict p1,
             const unsigned long * __restrict p2,
             const unsigned long * __restrict p3,
             const unsigned long * __restrict p4)
{
        long lines = bytes / (sizeof (long)) / 8;

        do {
                register long d0, d1, d2, d3, d4, d5, d6, d7;
                d0 = p1[0];     /* Pull the stuff into registers        */
                d1 = p1[1];     /*  ... in bursts, if possible.         */
                d2 = p1[2];
                d3 = p1[3];
                d4 = p1[4];
                d5 = p1[5];
                d6 = p1[6];
                d7 = p1[7];
                d0 ^= p2[0];
                d1 ^= p2[1];
                d2 ^= p2[2];
                d3 ^= p2[3];
                d4 ^= p2[4];
                d5 ^= p2[5];
                d6 ^= p2[6];
                d7 ^= p2[7];
                d0 ^= p3[0];
                d1 ^= p3[1];
                d2 ^= p3[2];
                d3 ^= p3[3];
                d4 ^= p3[4];
                d5 ^= p3[5];
                d6 ^= p3[6];
                d7 ^= p3[7];
                d0 ^= p4[0];
                d1 ^= p4[1];
                d2 ^= p4[2];
                d3 ^= p4[3];
                d4 ^= p4[4];
                d5 ^= p4[5];
                d6 ^= p4[6];
                d7 ^= p4[7];
                p1[0] = d0;     /* Store the result (in bursts)         */
                p1[1] = d1;
                p1[2] = d2;
                p1[3] = d3;
                p1[4] = d4;
                p1[5] = d5;
                p1[6] = d6;
                p1[7] = d7;
                p1 += 8;
                p2 += 8;
                p3 += 8;
                p4 += 8;
        } while (--lines > 0);
}

static void
xor_32regs_5(unsigned long bytes, unsigned long * __restrict p1,
             const unsigned long * __restrict p2,
             const unsigned long * __restrict p3,
             const unsigned long * __restrict p4,
             const unsigned long * __restrict p5)
{
        long lines = bytes / (sizeof (long)) / 8;

        do {
                register long d0, d1, d2, d3, d4, d5, d6, d7;
                d0 = p1[0];     /* Pull the stuff into registers        */
                d1 = p1[1];     /*  ... in bursts, if possible.         */
                d2 = p1[2];
                d3 = p1[3];
                d4 = p1[4];
                d5 = p1[5];
                d6 = p1[6];
                d7 = p1[7];
                d0 ^= p2[0];
                d1 ^= p2[1];
                d2 ^= p2[2];
                d3 ^= p2[3];
                d4 ^= p2[4];
                d5 ^= p2[5];
                d6 ^= p2[6];
                d7 ^= p2[7];
                d0 ^= p3[0];
                d1 ^= p3[1];
                d2 ^= p3[2];
                d3 ^= p3[3];
                d4 ^= p3[4];
                d5 ^= p3[5];
                d6 ^= p3[6];
                d7 ^= p3[7];
                d0 ^= p4[0];
                d1 ^= p4[1];
                d2 ^= p4[2];
                d3 ^= p4[3];
                d4 ^= p4[4];
                d5 ^= p4[5];
                d6 ^= p4[6];
                d7 ^= p4[7];
                d0 ^= p5[0];
                d1 ^= p5[1];
                d2 ^= p5[2];
                d3 ^= p5[3];
                d4 ^= p5[4];
                d5 ^= p5[5];
                d6 ^= p5[6];
                d7 ^= p5[7];
                p1[0] = d0;     /* Store the result (in bursts)         */
                p1[1] = d1;
                p1[2] = d2;
                p1[3] = d3;
                p1[4] = d4;
                p1[5] = d5;
                p1[6] = d6;
                p1[7] = d7;
                p1 += 8;
                p2 += 8;
                p3 += 8;
                p4 += 8;
                p5 += 8;
        } while (--lines > 0);
}

DO_XOR_BLOCKS(32regs, xor_32regs_2, xor_32regs_3, xor_32regs_4, xor_32regs_5);

struct xor_block_template xor_block_32regs = {
        .name           = "32regs",
        .xor_gen        = xor_gen_32regs,
};