/*
 * Copyright (c) 2022, 2023, Arm Limited. All rights reserved.
 * Copyright (c) 2023, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

package compiler.vectorapi;

import compiler.lib.ir_framework.*;

import java.util.Random;

import jdk.incubator.vector.ByteVector;
import jdk.incubator.vector.IntVector;
import jdk.incubator.vector.LongVector;
import jdk.incubator.vector.ShortVector;
import jdk.incubator.vector.VectorMask;
import jdk.incubator.vector.VectorOperators;
import jdk.incubator.vector.VectorSpecies;

import jdk.test.lib.Asserts;
import jdk.test.lib.Utils;

/**
 * @test
 * @bug 8288294
 * @key randomness
 * @library /test/lib /
 * @summary Add identity transformations for vector logic operations
 * @requires (os.simpleArch == "x64" & vm.cpu.features ~= ".*avx.*") | os.arch=="aarch64"
 * @modules jdk.incubator.vector
 *
 * @run driver compiler.vectorapi.VectorLogicalOpIdentityTest
 */

public class VectorLogicalOpIdentityTest {
    private static final VectorSpecies<Byte> B_SPECIES = ByteVector.SPECIES_MAX;
    private static final VectorSpecies<Short> S_SPECIES = ShortVector.SPECIES_MAX;
    private static final VectorSpecies<Integer> I_SPECIES = IntVector.SPECIES_MAX;
    private static final VectorSpecies<Long> L_SPECIES = LongVector.SPECIES_MAX;

    private static int LENGTH = 128;
    private static final Random RD = Utils.getRandomInstance();

    private static byte[] ba;
    private static byte[] br;
    private static short[] sa;
    private static short[] sr;
    private static int[] ia;
    private static int[] ib;
    private static int[] ir;
    private static long[] la;
    private static long[] lb;
    private static long[] lr;
    private static boolean[] m;
    private static boolean[] mr;

    static {
        ba = new byte[LENGTH];
        br = new byte[LENGTH];
        sa = new short[LENGTH];
        sr = new short[LENGTH];
        ia = new int[LENGTH];
        ib = new int[LENGTH];
        ir = new int[LENGTH];
        la = new long[LENGTH];
        lb = new long[LENGTH];
        lr = new long[LENGTH];
        m = new boolean[LENGTH];
        mr = new boolean[LENGTH];

        for (int i = 0; i < LENGTH; i++) {
            ba[i] = (byte) RD.nextInt(25);
            sa[i] = (short) RD.nextInt(25);
            ia[i] = RD.nextInt(25);
            ib[i] = RD.nextInt(25);
            la[i] = RD.nextLong(25);
            lb[i] = RD.nextLong(25);
            m[i] = RD.nextBoolean();
        }
    }

    private static long and(long a, long b) {
        return a & b;
    }

    @Test
    @Warmup(10000)
    @IR(failOn = IRNode.AND_VB, counts = {IRNode.LOAD_VECTOR_B, ">=1"})
    public static void testAndMinusOne() {
        ByteVector av = ByteVector.fromArray(B_SPECIES, ba, 0);
        av.and((byte) -1).intoArray(br, 0);

        // Verify results
        for (int i = 0; i < B_SPECIES.length(); i++) {
            Asserts.assertEquals((byte) and(ba[i], (byte) -1), br[i]);
        }
    }

    @Test
    @Warmup(10000)
    @IR(failOn = IRNode.AND_VS, counts = {IRNode.STORE_VECTOR, ">=1"})
    public static void testAndZero() {
        ShortVector av = ShortVector.fromArray(S_SPECIES, sa, 0);
        av.and((short) 0).intoArray(sr, 0);

        // Verify results
        for (int i = 0; i < S_SPECIES.length(); i++) {
            Asserts.assertEquals((short) and(sa[i], (short) 0), sr[i]);
        }
    }

    @Test
    @Warmup(10000)
    @IR(failOn = IRNode.AND_VI, counts = {IRNode.LOAD_VECTOR_I, ">=1"})
    public static void testAndSame() {
        IntVector av = IntVector.fromArray(I_SPECIES, ia, 0);
        av.and(av).intoArray(ir, 0);

        // Verify results
        for (int i = 0; i < I_SPECIES.length(); i++) {
            Asserts.assertEquals((int) and(ia[i], ia[i]), ir[i]);
        }
    }

    @Test
    @Warmup(10000)
    @IR(failOn = IRNode.AND_VL, counts = {IRNode.LOAD_VECTOR_L, ">=1"})
    public static void testMaskedAndMinusOne1() {
        VectorMask<Long> mask = VectorMask.fromArray(L_SPECIES, m, 0);
        LongVector av = LongVector.fromArray(L_SPECIES, la, 0);
        LongVector bv = LongVector.broadcast(L_SPECIES, -1);
        av.lanewise(VectorOperators.AND, bv, mask).intoArray(lr, 0);

        // Verify results
        for (int i = 0; i < L_SPECIES.length(); i++) {
            if (m[i]) {
                Asserts.assertEquals(and(la[i], -1), lr[i]);
            } else {
                Asserts.assertEquals(la[i], lr[i]);
            }
        }
    }

    // Masked AndV in this test should not be optimized out on SVE.
    @Test
    @Warmup(10000)
    @IR(counts = {IRNode.LOAD_VECTOR_B, ">=1"})
    @IR(failOn = IRNode.AND_VB, applyIfCPUFeatureAnd = {"asimd", "true", "sve", "false"})
    public static void testMaskedAndMinusOne2() {
        VectorMask<Byte> mask = VectorMask.fromArray(B_SPECIES, m, 0);
        ByteVector av = ByteVector.fromArray(B_SPECIES, ba, 0);
        ByteVector bv = ByteVector.broadcast(B_SPECIES, (byte) -1);
        bv.lanewise(VectorOperators.AND, av, mask).intoArray(br, 0);

        // Verify results
        for (int i = 0; i < B_SPECIES.length(); i++) {
            if (m[i]) {
                Asserts.assertEquals((byte) and(ba[i], (byte) -1), br[i]);
            } else {
                Asserts.assertEquals((byte) -1, br[i]);
            }
        }
    }

    // Masked AndV in this test should not be optimized out on SVE.
    @Test
    @Warmup(10000)
    @IR(counts = {IRNode.STORE_VECTOR, ">=1"})
    @IR(failOn = IRNode.AND_VS, applyIfCPUFeatureAnd = {"asimd", "true", "sve", "false"})
    public static void testMaskedAndZero1() {
        VectorMask<Short> mask = VectorMask.fromArray(S_SPECIES, m, 0);
        ShortVector av = ShortVector.fromArray(S_SPECIES, sa, 0);
        ShortVector bv = ShortVector.broadcast(S_SPECIES, (short) 0);
        av.lanewise(VectorOperators.AND, bv, mask).intoArray(sr, 0);

        // Verify results
        for (int i = 0; i < S_SPECIES.length(); i++) {
            if (m[i]) {
                Asserts.assertEquals((short) and(sa[i], (short) 0), sr[i]);
            } else {
                Asserts.assertEquals(sa[i], sr[i]);
            }
        }
    }

    @Test
    @Warmup(10000)
    @IR(failOn = IRNode.AND_VI, counts = {IRNode.STORE_VECTOR, ">=1"})
    public static void testMaskedAndZero2() {
        VectorMask<Integer> mask = VectorMask.fromArray(I_SPECIES, m, 0);
        IntVector av = IntVector.fromArray(I_SPECIES, ia, 0);
        IntVector bv = IntVector.broadcast(I_SPECIES, 0);
        bv.lanewise(VectorOperators.AND, av, mask).intoArray(ir, 0);

        // Verify results
        for (int i = 0; i < I_SPECIES.length(); i++) {
            if (m[i]) {
                Asserts.assertEquals((int) and(ba[i], 0), ir[i]);
            } else {
                Asserts.assertEquals(0, ir[i]);
            }
        }
    }

    @Test
    @Warmup(10000)
    @IR(failOn = IRNode.AND_VL, counts = {IRNode.LOAD_VECTOR_L, ">=1"})
    public static void testMaskedAndSame() {
        VectorMask<Long> mask = VectorMask.fromArray(L_SPECIES, m, 0);
        LongVector av = LongVector.fromArray(L_SPECIES, la, 0);
        av.lanewise(VectorOperators.AND, av, mask).intoArray(lr, 0);

        // Verify results
        for (int i = 0; i < L_SPECIES.length(); i++) {
            if (m[i]) {
                Asserts.assertEquals(and(la[i], la[i]), lr[i]);
            } else {
                Asserts.assertEquals(la[i], lr[i]);
            }
        }
    }

    // Transform AndV(AndV(a, b), b) ==> AndV(a, b)
    @Test
    @Warmup(10000)
    @IR(counts = {IRNode.AND_VI, "1"})
    public static void testAndSameValue1() {
        IntVector av = IntVector.fromArray(I_SPECIES, ia, 0);
        IntVector bv = IntVector.fromArray(I_SPECIES, ib, 0);
        (av.and(bv).and(bv)).intoArray(ir, 0);

        // Verify results
        for (int i = 0; i < I_SPECIES.length(); i++) {
            Asserts.assertEquals((int) and(and(ia[i], ib[i]), ib[i]), ir[i]);
        }
    }

    // Transform AndV(AndV(a, b), a) ==> AndV(a, b)
    @Test
    @Warmup(10000)
    @IR(counts = {IRNode.AND_VL, "1"})
    public static void testAndSameValue2() {
        LongVector av = LongVector.fromArray(L_SPECIES, la, 0);
        LongVector bv = LongVector.fromArray(L_SPECIES, lb, 0);
        (av.and(bv).and(av)).intoArray(lr, 0);

        // Verify results
        for (int i = 0; i < L_SPECIES.length(); i++) {
            Asserts.assertEquals(and(and(la[i], lb[i]), la[i]), lr[i]);
        }
    }

    // Transform AndV(b, AndV(a, b)) ==> AndV(a, b)
    @Test
    @Warmup(10000)
    @IR(counts = {IRNode.AND_VI, "1"})
    public static void testAndSameValue3() {
        IntVector av = IntVector.fromArray(I_SPECIES, ia, 0);
        IntVector bv = IntVector.fromArray(I_SPECIES, ib, 0);
        (bv.and(av.and(bv))).intoArray(ir, 0);

        // Verify results
        for (int i = 0; i < I_SPECIES.length(); i++) {
            Asserts.assertEquals((int) and(ib[i], and(ia[i], ib[i])), ir[i]);
        }
    }

    // Transform AndV(a, AndV(a, b)) ==> AndV(a, b)
    @Test
    @Warmup(10000)
    @IR(counts = {IRNode.AND_VL, "1"})
    public static void testAndSameValue4() {
        LongVector av = LongVector.fromArray(L_SPECIES, la, 0);
        LongVector bv = LongVector.fromArray(L_SPECIES, lb, 0);
        (av.and(av.and(bv))).intoArray(lr, 0);

        // Verify results
        for (int i = 0; i < L_SPECIES.length(); i++) {
            Asserts.assertEquals(and(la[i], and(la[i], lb[i])), lr[i]);
        }
    }

    // Transform AndV(AndV(a, b, m), b, m) ==> AndV(a, b, m)
    @Test
    @Warmup(10000)
    @IR(counts = {IRNode.AND_VI, "1"}, applyIfCPUFeatureOr = {"sve", "true", "avx512", "true"})
    public static void testAndMaskSameValue1() {
        VectorMask<Integer> mask = VectorMask.fromArray(I_SPECIES, m, 0);
        IntVector av = IntVector.fromArray(I_SPECIES, ia, 0);
        IntVector bv = IntVector.fromArray(I_SPECIES, ib, 0);
        av.lanewise(VectorOperators.AND, bv, mask)
        .lanewise(VectorOperators.AND, bv, mask).intoArray(ir, 0);

        // Verify results
        for (int i = 0; i < I_SPECIES.length(); i++) {
            if (m[i]) {
              Asserts.assertEquals((int) and(and(ia[i], ib[i]), ib[i]), ir[i]);
            } else {
              Asserts.assertEquals(ia[i], ir[i]);
            }
        }
    }

    // Transform AndV(AndV(a, b, m), a, m) ==> AndV(a, b, m)
    @Test
    @Warmup(10000)
    @IR(counts = {IRNode.AND_VL, "1"}, applyIfCPUFeatureOr = {"sve", "true", "avx512", "true"})
    public static void testAndMaskSameValue2() {
        VectorMask<Long> mask = VectorMask.fromArray(L_SPECIES, m, 0);
        LongVector av = LongVector.fromArray(L_SPECIES, la, 0);
        LongVector bv = LongVector.fromArray(L_SPECIES, lb, 0);
        av.lanewise(VectorOperators.AND, bv, mask)
        .lanewise(VectorOperators.AND, av, mask).intoArray(lr, 0);

        // Verify results
        for (int i = 0; i < L_SPECIES.length(); i++) {
            if (m[i]) {
              Asserts.assertEquals(and(and(la[i], lb[i]), la[i]), lr[i]);
            } else {
              Asserts.assertEquals(la[i], lr[i]);
            }
        }
    }

    // Transform AndV(a, AndV(a, b, m), m) ==> AndV(a, b, m)
    @Test
    @Warmup(10000)
    @IR(counts = {IRNode.AND_VI, "1"}, applyIfCPUFeatureOr = {"sve", "true", "avx512", "true"})
    public static void testAndMaskSameValue3() {
        VectorMask<Integer> mask = VectorMask.fromArray(I_SPECIES, m, 0);
        IntVector av = IntVector.fromArray(I_SPECIES, ia, 0);
        IntVector bv = IntVector.fromArray(I_SPECIES, ib, 0);
        av.lanewise(VectorOperators.AND, av.lanewise(VectorOperators.AND, bv, mask), mask)
        .intoArray(ir, 0);

        // Verify results
        for (int i = 0; i < I_SPECIES.length(); i++) {
            if (m[i]) {
              Asserts.assertEquals((int) and(ia[i], and(ia[i], ib[i])), ir[i]);
            } else {
              Asserts.assertEquals(ia[i], ir[i]);
            }
        }
    }

    private static long or(long a, long b) {
        return a | b;
    }

    @Test
    @Warmup(10000)
    @IR(failOn = IRNode.OR_VB, counts = {IRNode.STORE_VECTOR, ">=1"})
    public static void testOrMinusOne() {
        ByteVector av = ByteVector.fromArray(B_SPECIES, ba, 0);
        av.or((byte) -1).intoArray(br, 0);

        // Verify results
        for (int i = 0; i < B_SPECIES.length(); i++) {
            Asserts.assertEquals((byte) or(ba[i], (byte) -1), br[i]);
        }
    }

    @Test
    @Warmup(10000)
    @IR(failOn = IRNode.OR_VS, counts = {IRNode.LOAD_VECTOR_S, ">=1"})
    public static void testOrZero() {
        ShortVector av = ShortVector.fromArray(S_SPECIES, sa, 0);
        av.or((short) 0).intoArray(sr, 0);

        // Verify results
        for (int i = 0; i < S_SPECIES.length(); i++) {
            Asserts.assertEquals((short) or(sa[i], (short) 0), sr[i]);
        }
    }

    @Test
    @Warmup(10000)
    @IR(failOn = IRNode.OR_VI, counts = {IRNode.LOAD_VECTOR_I, ">=1"})
    public static void testOrSame() {
        IntVector av = IntVector.fromArray(I_SPECIES, ia, 0);
        av.or(av).intoArray(ir, 0);

        // Verify results
        for (int i = 0; i < I_SPECIES.length(); i++) {
            Asserts.assertEquals((int) or(ia[i], ia[i]), ir[i]);
        }
    }

    // Masked OrV in this test should not be optimized out on SVE.
    @Test
    @Warmup(10000)
    @IR(counts = {IRNode.STORE_VECTOR, ">=1"})
    @IR(failOn = IRNode.OR_VB, applyIfCPUFeatureAnd = {"asimd", "true", "sve", "false"})
    public static void testMaskedOrMinusOne1() {
        VectorMask<Byte> mask = VectorMask.fromArray(B_SPECIES, m, 0);
        ByteVector av = ByteVector.fromArray(B_SPECIES, ba, 0);
        ByteVector bv = ByteVector.broadcast(B_SPECIES, -1);
        av.lanewise(VectorOperators.OR, bv, mask).intoArray(br, 0);

        // Verify results
        for (int i = 0; i < B_SPECIES.length(); i++) {
            if (m[i]) {
                Asserts.assertEquals((byte) or(ba[i], -1), br[i]);
            } else {
                Asserts.assertEquals(ba[i], br[i]);
            }
        }
    }

    @Test
    @Warmup(10000)
    @IR(failOn = IRNode.OR_VB, counts = {IRNode.STORE_VECTOR, ">=1"})
    public static void testMaskedOrMinusOne2() {
        VectorMask<Byte> mask = VectorMask.fromArray(B_SPECIES, m, 0);
        ByteVector av = ByteVector.fromArray(B_SPECIES, ba, 0);
        ByteVector bv = ByteVector.broadcast(B_SPECIES, (byte) -1);
        bv.lanewise(VectorOperators.OR, av, mask).intoArray(br, 0);

        // Verify results
        for (int i = 0; i < B_SPECIES.length(); i++) {
            if (m[i]) {
                Asserts.assertEquals((byte) or(ba[i], (byte) -1), br[i]);
            } else {
                Asserts.assertEquals((byte) -1, br[i]);
            }
        }
    }

    @Test
    @Warmup(10000)
    @IR(failOn = IRNode.OR_VS, counts = {IRNode.LOAD_VECTOR_S, ">=1"})
    public static void testMaskedOrZero1() {
        VectorMask<Short> mask = VectorMask.fromArray(S_SPECIES, m, 0);
        ShortVector av = ShortVector.fromArray(S_SPECIES, sa, 0);
        ShortVector bv = ShortVector.broadcast(S_SPECIES, (short) 0);
        av.lanewise(VectorOperators.OR, bv, mask).intoArray(sr, 0);

        // Verify results
        for (int i = 0; i < S_SPECIES.length(); i++) {
            if (m[i]) {
                Asserts.assertEquals((short) or(sa[i], (short) 0), sr[i]);
            } else {
                Asserts.assertEquals(sa[i], sr[i]);
            }
        }
    }

    // Masked OrV in this test should not be optimized out on SVE.
    @Test
    @Warmup(10000)
    @IR(counts = {IRNode.LOAD_VECTOR_B, ">=1"})
    @IR(failOn = IRNode.OR_VB, applyIfCPUFeatureAnd = {"asimd", "true", "sve", "false"})
    public static void testMaskedOrZero2() {
        VectorMask<Byte> mask = VectorMask.fromArray(B_SPECIES, m, 0);
        ByteVector av = ByteVector.fromArray(B_SPECIES, ba, 0);
        ByteVector bv = ByteVector.broadcast(B_SPECIES, 0);
        bv.lanewise(VectorOperators.OR, av, mask).intoArray(br, 0);

        // Verify results
        for (int i = 0; i < B_SPECIES.length(); i++) {
            if (m[i]) {
                Asserts.assertEquals((byte) or(ba[i], 0), br[i]);
            } else {
                Asserts.assertEquals((byte) 0, br[i]);
            }
        }
    }

    @Test
    @Warmup(10000)
    @IR(failOn = IRNode.OR_VL, counts = {IRNode.LOAD_VECTOR_L, ">=1"})
    public static void testMaskedOrSame() {
        VectorMask<Long> mask = VectorMask.fromArray(L_SPECIES, m, 0);
        LongVector av = LongVector.fromArray(L_SPECIES, la, 0);
        av.lanewise(VectorOperators.OR, av, mask).intoArray(lr, 0);

        // Verify results
        for (int i = 0; i < L_SPECIES.length(); i++) {
            if (m[i]) {
                Asserts.assertEquals(or(la[i], la[i]), lr[i]);
            } else {
                Asserts.assertEquals(la[i], lr[i]);
            }
        }
    }

    // Transform OrV(OrV(a, b), b) ==> OrV(a, b)
    @Test
    @Warmup(10000)
    @IR(counts = {IRNode.OR_VI, "1"})
    public static void testOrSameValue1() {
        IntVector av = IntVector.fromArray(I_SPECIES, ia, 0);
        IntVector bv = IntVector.fromArray(I_SPECIES, ib, 0);
        (av.or(bv).or(bv)).intoArray(ir, 0);

        // Verify results
        for (int i = 0; i < I_SPECIES.length(); i++) {
            Asserts.assertEquals((int) or(or(ia[i], ib[i]), ib[i]), ir[i]);
        }
    }

    // Transform OrV(OrV(a, b), a) ==> OrV(a, b)
    @Test
    @Warmup(10000)
    @IR(counts = {IRNode.OR_VL, "1"})
    public static void testOrSameValue2() {
        LongVector av = LongVector.fromArray(L_SPECIES, la, 0);
        LongVector bv = LongVector.fromArray(L_SPECIES, lb, 0);
        (av.or(bv).or(av)).intoArray(lr, 0);

        // Verify results
        for (int i = 0; i < L_SPECIES.length(); i++) {
            Asserts.assertEquals(or(or(la[i], lb[i]), la[i]), lr[i]);
        }
    }

    // Transform OrV(b, OrV(a, b)) ==> OrV(a, b)
    @Test
    @Warmup(10000)
    @IR(counts = {IRNode.OR_VI, "1"})
    public static void testOrSameValue3() {
        IntVector av = IntVector.fromArray(I_SPECIES, ia, 0);
        IntVector bv = IntVector.fromArray(I_SPECIES, ib, 0);
        (bv.or(av.or(bv))).intoArray(ir, 0);

        // Verify results
        for (int i = 0; i < I_SPECIES.length(); i++) {
            Asserts.assertEquals((int) or(ib[i], or(ia[i], ib[i])), ir[i]);
        }
    }

    // Transform OrV(a, OrV(a, b)) ==> OrV(a, b)
    @Test
    @Warmup(10000)
    @IR(counts = {IRNode.OR_VL, "1"})
    public static void testOrSameValue4() {
        LongVector av = LongVector.fromArray(L_SPECIES, la, 0);
        LongVector bv = LongVector.fromArray(L_SPECIES, lb, 0);
        (av.or(av.or(bv))).intoArray(lr, 0);

        // Verify results
        for (int i = 0; i < L_SPECIES.length(); i++) {
            Asserts.assertEquals(or(la[i], or(la[i], lb[i])), lr[i]);
        }
    }

    // Transform OrV(OrV(a, b, m), b, m) ==> OrV(a, b, m)
    @Test
    @Warmup(10000)
    @IR(counts = {IRNode.OR_VI, "1"}, applyIfCPUFeatureOr = {"sve", "true", "avx512", "true"})
    public static void testOrMaskSameValue1() {
        VectorMask<Integer> mask = VectorMask.fromArray(I_SPECIES, m, 0);
        IntVector av = IntVector.fromArray(I_SPECIES, ia, 0);
        IntVector bv = IntVector.fromArray(I_SPECIES, ib, 0);
        av.lanewise(VectorOperators.OR, bv, mask)
        .lanewise(VectorOperators.OR, bv, mask).intoArray(ir, 0);

        // Verify results
        for (int i = 0; i < I_SPECIES.length(); i++) {
            if (m[i]) {
              Asserts.assertEquals((int) or(or(ia[i], ib[i]), ib[i]), ir[i]);
            } else {
              Asserts.assertEquals(ia[i], ir[i]);
            }
        }
    }

    // Transform OrV(OrV(a, b, m), a, m) ==> OrV(a, b, m)
    @Test
    @Warmup(10000)
    @IR(counts = {IRNode.OR_VL, "1"}, applyIfCPUFeatureOr = {"sve", "true", "avx512", "true"})
    public static void testOrMaskSameValue2() {
        VectorMask<Long> mask = VectorMask.fromArray(L_SPECIES, m, 0);
        LongVector av = LongVector.fromArray(L_SPECIES, la, 0);
        LongVector bv = LongVector.fromArray(L_SPECIES, lb, 0);
        av.lanewise(VectorOperators.OR, bv, mask)
        .lanewise(VectorOperators.OR, av, mask).intoArray(lr, 0);

        // Verify results
        for (int i = 0; i < L_SPECIES.length(); i++) {
            if (m[i]) {
              Asserts.assertEquals(or(or(la[i], lb[i]), la[i]), lr[i]);
            } else {
              Asserts.assertEquals(la[i], lr[i]);
            }
        }
    }

    // Transform OrV(a, OrV(a, b, m), m) ==> OrV(a, b, m)
    @Test
    @Warmup(10000)
    @IR(counts = {IRNode.OR_VI, "1"}, applyIfCPUFeatureOr = {"sve", "true", "avx512", "true"})
    public static void testOrMaskSameValue3() {
        VectorMask<Integer> mask = VectorMask.fromArray(I_SPECIES, m, 0);
        IntVector av = IntVector.fromArray(I_SPECIES, ia, 0);
        IntVector bv = IntVector.fromArray(I_SPECIES, ib, 0);
        av.lanewise(VectorOperators.OR, av.lanewise(VectorOperators.OR, bv, mask), mask)
        .intoArray(ir, 0);

        // Verify results
        for (int i = 0; i < I_SPECIES.length(); i++) {
            if (m[i]) {
              Asserts.assertEquals((int) or(ia[i], or(ia[i], ib[i])), ir[i]);
            } else {
              Asserts.assertEquals(ia[i], ir[i]);
            }
        }
    }

    private static long xor(long a, long b) {
        return a ^ b;
    }

    @Test
    @Warmup(10000)
    @IR(failOn = IRNode.XOR_VB, counts = {IRNode.STORE_VECTOR, ">=1"})
    public static void testXorSame() {
        ByteVector av = ByteVector.fromArray(B_SPECIES, ba, 0);
        av.lanewise(VectorOperators.XOR, av).intoArray(br, 0);

        // Verify results
        for (int i = 0; i < B_SPECIES.length(); i++) {
            Asserts.assertEquals((byte) xor(ba[i], ba[i]), br[i]);
        }
    }

    // Masked XorV in this test should not be optimized out on SVE.
    @Test
    @Warmup(10000)
    @IR(counts = {IRNode.STORE_VECTOR, ">=1"})
    @IR(failOn = IRNode.XOR_VS, applyIfCPUFeatureAnd = {"asimd", "true", "sve", "false"})
    public static void testMaskedXorSame() {
        VectorMask<Short> mask = VectorMask.fromArray(S_SPECIES, m, 0);
        ShortVector av = ShortVector.fromArray(S_SPECIES, sa, 0);
        av.lanewise(VectorOperators.XOR, av, mask).intoArray(sr, 0);

        // Verify results
        for (int i = 0; i < S_SPECIES.length(); i++) {
            if (m[i]) {
                Asserts.assertEquals((short) xor(sa[i], sa[i]), sr[i]);
            } else {
                Asserts.assertEquals(sa[i], sr[i]);
            }
        }
    }

    // Following are the vector mask logic operations tests
    @Test
    @Warmup(10000)
    @IR(failOn = {IRNode.AND_VI, IRNode.AND_V_MASK}, counts = {IRNode.STORE_VECTOR, ">=1"})
    public static void testMaskAndMinusOne() {
        VectorMask<Integer> ma = VectorMask.fromArray(I_SPECIES, m, 0);
        VectorMask<Integer> mb = I_SPECIES.maskAll(true);
        ma.and(mb).intoArray(mr, 0);

        // Verify results
        for (int i = 0; i < I_SPECIES.length(); i++) {
            Asserts.assertEquals(m[i], mr[i]);
        }
    }

    @Test
    @Warmup(10000)
    @IR(failOn = {IRNode.AND_VS, IRNode.AND_V_MASK}, counts = {IRNode.STORE_VECTOR, ">=1"})
    public static void testMaskAndZero() {
        VectorMask<Short> ma = VectorMask.fromArray(S_SPECIES, m, 0);
        VectorMask<Short> mb = S_SPECIES.maskAll(false);
        ma.and(mb).intoArray(mr, 0);

        // Verify results
        for (int i = 0; i < S_SPECIES.length(); i++) {
            Asserts.assertEquals(false, mr[i]);
        }
    }

    @Test
    @Warmup(10000)
    @IR(failOn = {IRNode.AND_VB, IRNode.AND_V_MASK}, counts = {IRNode.STORE_VECTOR, ">=1"})
    public static void testMaskAndSame() {
        VectorMask<Byte> ma = VectorMask.fromArray(B_SPECIES, m, 0);
        ma.and(ma).intoArray(mr, 0);

        // Verify results
        for (int i = 0; i < B_SPECIES.length(); i++) {
            Asserts.assertEquals(m[i], mr[i]);
        }
    }

    @Test
    @Warmup(10000)
    @IR(failOn = {IRNode.OR_VS, IRNode.OR_V_MASK}, counts = {IRNode.STORE_VECTOR, ">=1"})
    public static void testMaskOrMinusOne() {
        VectorMask<Short> ma = VectorMask.fromArray(S_SPECIES, m, 0);
        VectorMask<Short> mb = S_SPECIES.maskAll(true);
        ma.or(mb).intoArray(mr, 0);

        // Verify results
        for (int i = 0; i < S_SPECIES.length(); i++) {
            Asserts.assertEquals(true, mr[i]);
        }
    }

    @Test
    @Warmup(10000)
    @IR(failOn = {IRNode.OR_VI, IRNode.OR_V_MASK}, counts = {IRNode.STORE_VECTOR, ">=1"})
    public static void testMaskOrZero() {
        VectorMask<Integer> ma = VectorMask.fromArray(I_SPECIES, m, 0);
        VectorMask<Integer> mb = I_SPECIES.maskAll(false);
        ma.or(mb).intoArray(mr, 0);

        // Verify results
        for (int i = 0; i < I_SPECIES.length(); i++) {
            Asserts.assertEquals(m[i], mr[i]);
        }
    }

    @Test
    @Warmup(10000)
    @IR(failOn = {IRNode.OR_VB, IRNode.OR_V_MASK}, counts = {IRNode.STORE_VECTOR, ">=1"})
    public static void testMaskOrSame() {
        VectorMask<Byte> ma = VectorMask.fromArray(B_SPECIES, m, 0);
        ma.or(ma).intoArray(mr, 0);

        // Verify results
        for (int i = 0; i < B_SPECIES.length(); i++) {
            Asserts.assertEquals(m[i], mr[i]);
        }
    }

    @Test
    @Warmup(10000)
    @IR(failOn = {IRNode.XOR_VI, IRNode.XOR_V_MASK}, counts = {IRNode.STORE_VECTOR, ">=1"})
    public static void testMaskXorSame() {
        VectorMask<Integer> ma = I_SPECIES.maskAll(true);
        ma.not().intoArray(mr, 0);

        // Verify results
        for (int i = 0; i < I_SPECIES.length(); i++) {
            Asserts.assertEquals(false, mr[i]);
        }
    }

    public static void main(String[] args) {
        TestFramework.runWithFlags("--add-modules=jdk.incubator.vector");
    }
}