// { dg-additional-options "-mavx" { target avx_runtime } }
// { dg-skip-if "needs gcc/config.d" { ! d_runtime } }
import gcc.simd;

void testblendvector(V, VI = V)()
{
    alias E = typeof(V.array[0]);
    enum numElements = V.sizeof / E.sizeof;

    static if (numElements == 16)
    {
        // Test fragment for vectors with 16 elements
        immutable V[5] in1 =
            [[ 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25 ],
             [ 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25 ],
             [ 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25 ],
             [ 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25 ],
             [ 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25 ]];

        immutable V in2 =
            [ 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45 ];

        immutable VI[5] mask1 =
            [[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 ],
             [ 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31 ],
             [ 7, 6, 5, 4, 16, 17, 18, 19, 31, 30, 29, 28, 3, 2, 1, 0 ],
             [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],
             [ 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63 ]];

        immutable V[5] out1 =
            [[30, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25],
             [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25],
             [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 45],
             [30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45],
             [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25]];
    }
    else static if (numElements == 8)
    {
        // Test fragment for vectors with 8 elements
        static if (is(E == uint))
        {
            enum E A1 = 0x11121314;
            enum E B1 = 0x21222324;
            enum E C1 = 0x31323334;
            enum E D1 = 0x41424344;
            enum E E1 = 0x51525354;
            enum E F1 = 0x61626364;
            enum E G1 = 0x71727374;
            enum E H1 = 0x81828384;

            enum E A2 = 0x91929394;
            enum E B2 = 0xa1a2a3a4;
            enum E C2 = 0xb1b2b3b4;
            enum E D2 = 0xc1c2c3c4;
            enum E E2 = 0xd1d2d3d4;
            enum E F2 = 0xe1e2e3e4;
            enum E G2 = 0xf1f2f3f4;
            enum E H2 = 0x01020304;
        }
        else static if (is(E == ushort))
        {
            enum E A1 = 0x1112;
            enum E B1 = 0x2122;
            enum E C1 = 0x3132;
            enum E D1 = 0x4142;
            enum E E1 = 0x5152;
            enum E F1 = 0x6162;
            enum E G1 = 0x7172;
            enum E H1 = 0x8182;

            enum E A2 = 0x9192;
            enum E B2 = 0xa1a2;
            enum E C2 = 0xb1b2;
            enum E D2 = 0xc1c2;
            enum E E2 = 0xd1d2;
            enum E F2 = 0xe1e2;
            enum E G2 = 0xf1f2;
            enum E H2 = 0x0102;
        }
        else static if (is(E == ubyte))
        {
            enum E A1 = 0x11;
            enum E B1 = 0x12;
            enum E C1 = 0x13;
            enum E D1 = 0x14;
            enum E E1 = 0x15;
            enum E F1 = 0x16;
            enum E G1 = 0x17;
            enum E H1 = 0x18;

            enum E A2 = 0xf1;
            enum E B2 = 0xf2;
            enum E C2 = 0xf3;
            enum E D2 = 0xf4;
            enum E E2 = 0xf5;
            enum E F2 = 0xf6;
            enum E G2 = 0xf7;
            enum E H2 = 0xf8;
        }
        else
            enum unsupported = true;

        static if (!__traits(compiles, unsupported))
        {
            immutable V[6] in1 =
                [[ A1, B1, C1, D1, E1, F1, G1, H1 ],
                 [ A1, B1, C1, D1, E1, F1, G1, H1 ],
                 [ A1, B1, C1, D1, E1, F1, G1, H1 ],
                 [ A1, B1, C1, D1, E1, F1, G1, H1 ],
                 [ A1, B1, C1, D1, E1, F1, G1, H1 ],
                 [ A1, B1, C1, D1, E1, F1, G1, H1 ]];


            immutable V in2 =
                [ A2, B2, C2, D2, E2, F2, G2, H2 ];

            immutable VI[6] mask1 =
                [[ 0,  1,  2 , 3 , 4 , 5 , 6 , 0 ],
                 [ 8,  9,  0, 11, 12, 13,  0, 15 ],
                 [ 0,  8,  1,  0,  2,  0,  3, 11 ],
                 [ 0, 15,  4, 11,  0,  3,  7,  8 ],
                 [ 0,  0,  0,  0,  0,  0,  0,  0 ],
                 [ 0x1e, 0x2e, 0x3e, 0x4e, 0x5e, 0x6e, 0x7e, 0x8e ]];

            immutable V[6] out1 =
                [[ A2, B1, C1, D1, E1, F1, G1, H2 ],
                 [ A1, B1, C2, D1, E1, F1, G2, H1 ],
                 [ A2, B1, C1, D2, E1, F2, G1, H1 ],
                 [ A2, B1, C1, D1, E2, F1, G1, H1 ],
                 [ A2, B2, C2, D2, E2, F2, G2, H2 ],
                 [ A1, B1, C1, D1, E1, F1, G1, H1 ]];
        }
    }
    else static if (numElements == 4)
    {
        // Test fragment for vectors with 4 elements
        static if (is(E == double))
        {
            enum E A = 0.69314718055994530942;
            enum E B = 2.7182818284590452354;
            enum E C = 2.30258509299404568402;
            enum E D = 1.4426950408889634074;

            enum E W = 0.31830988618379067154;
            enum E X = 3.14159265358979323846;
            enum E Y = 1.41421356237309504880;
            enum E Z = 0.70710678118654752440;
        }
        else static if (is(E == float))
        {
            enum E A = 0.69314718055994530942f;
            enum E B = 2.7182818284590452354f;
            enum E C = 2.30258509299404568402f;
            enum E D = 1.4426950408889634074f;

            enum E W = 0.31830988618379067154f;
            enum E X = 3.14159265358979323846f;
            enum E Y = 1.41421356237309504880f;
            enum E Z = 0.70710678118654752440f;
        }
        else static if (is(E == ulong))
        {
            enum E A = 0x1112131415161718;
            enum E B = 0x2122232425262728;
            enum E C = 0x3132333435363738;
            enum E D = 0x4142434445464748;

            enum E W = 0xc1c2c3c4c5c6c7c8;
            enum E X = 0xd1d2d3d4d5d6d7d8;
            enum E Y = 0xe1e2e3e4e5e6e7e8;
            enum E Z = 0xf1f2f3f4f5f6f7f8;
        }
        else static if (is(E == uint))
        {
            enum E A = 0x11121314;
            enum E B = 0x21222324;
            enum E C = 0x31323334;
            enum E D = 0x41424344;

            enum E W = 0xc1c2c3c4;
            enum E X = 0xd1d2d3d4;
            enum E Y = 0xe1e2e3e4;
            enum E Z = 0xf1f2f3f4;
        }
        else
            enum unsupported = true;

        static if (!__traits(compiles, unsupported))
        {
            immutable V[6] in1 =
                [[ A, B, C, D ],
                 [ A, B, C, D ],
                 [ A, B, C, D ],
                 [ A, B, C, D ],
                 [ A, B, C, D ],
                 [ A, B, C, D ]];

            immutable V in2 = [ W, X, Y, Z ];

            immutable VI[6] mask1 =
                [[ 0, 1, 2, 3 ],
                 [ 4, 0, 6, 7 ],
                 [ 0, 4, 0, 5 ],
                 [ 0, 7, 4, 0 ],
                 [ 0, 0, 0, 0 ],
                 [ 7, 7, 7, 7 ]];

            immutable V[6] out1 =
                [[ W, B, C, D ],
                 [ A, X, C, D ],
                 [ W, B, Y, D ],
                 [ W, B, C, Z ],
                 [ W, X, Y, Z ],
                 [ A, B, C, D ]];
        }
    }
    else static if (numElements == 2)
    {
        // Test fragment for vectors with 2 elements
        static if (is(E == double))
        {
            enum E A = 0.69314718055994530942;
            enum E B = 2.7182818284590452354;

            enum E X = 3.14159265358979323846;
            enum E Y = 1.41421356237309504880;
        }
        else static if (is(E == float))
        {
            enum E A = 0.69314718055994530942f;
            enum E B = 2.7182818284590452354f;

            enum E X = 3.14159265358979323846f;
            enum E Y = 1.41421356237309504880f;
        }
        else static if (is(E == ulong))
        {
            enum E A = 0x1112131415161718;
            enum E B = 0x2122232425262728;

            enum E X = 0xc1c2c3c4c5c6c7c8;
            enum E Y = 0xd1d2d3d4d5d6d7d8;
        }
        else static if (is(E == uint))
        {
            enum E A = 0x11121314;
            enum E B = 0x21222324;

            enum E X = 0xd1d2d3d4;
            enum E Y = 0xe1e2e3e4;
        }
        else
            enum unsupported = true;

        static if (!__traits(compiles, unsupported))
        {
            immutable V[7] in1 =
                [[ A, B ],
                 [ A, B ],
                 [ A, B ],
                 [ A, B ],
                 [ A, B ],
                 [ A, B ],
                 [ A, B ]];

            immutable V in2 = [ X, Y ];

            immutable VI[7] mask1 =
                [[ 0, 1 ],
                 [ 2, 3 ],
                 [ 0, 2 ],
                 [ 2, 1 ],
                 [ 3, 0 ],
                 [ 0, 0 ],
                 [ 3, 3 ]];

            immutable V[7] out1 =
                [[ X, B ],
                 [ A, B ],
                 [ X, B ],
                 [ A, B ],
                 [ A, Y ],
                 [ X, Y ],
                 [ A, B ]];
        }
    }
    else
        enum unsupported = true;

    static if (!__traits(compiles, unsupported))
    {
        static foreach (i; 0 .. in1.length)
            assert(blendvector(in1[i], in2, mask1[i]).array == out1[i].array);
    }
}

void main()
{
    static if (__traits(compiles, __vector(ubyte[16])))
        testblendvector!(__vector(ubyte[16]))();

    static if (__traits(compiles, __vector(ushort[16])))
        testblendvector!(__vector(ushort[16]))();

    static if (__traits(compiles, __vector(ubyte[8])))
        testblendvector!(__vector(ubyte[8]))();

    static if (__traits(compiles, __vector(ushort[8])))
        testblendvector!(__vector(ushort[8]))();

    static if (__traits(compiles, __vector(uint[8])))
        testblendvector!(__vector(uint[8]))();

    static if (__traits(compiles, __vector(ulong[4])))
    {
        testblendvector!(__vector(ulong[4]));

        static if (__traits(compiles, __vector(double[4])))
            testblendvector!(__vector(double[4]), __vector(ulong[4]));
    }

    static if (__traits(compiles, __vector(uint[4])))
    {
        testblendvector!(__vector(uint[4]));

        static if (__traits(compiles, __vector(float[4])))
            testblendvector!(__vector(float[4]), __vector(uint[4]));
    }

    static if (__traits(compiles, __vector(ulong[2])))
    {
        testblendvector!(__vector(ulong[2]));

        static if (__traits(compiles, __vector(double[2])))
            testblendvector!(__vector(double[2]), __vector(ulong[2]));
    }

    static if (__traits(compiles, __vector(uint[2])))
    {
        testblendvector!(__vector(uint[2]));

        static if (__traits(compiles, __vector(float[2])))
            testblendvector!(__vector(float[2]), __vector(uint[2]));
    }
}