When I running a JMH benchmark on an **AWS Graviton3 machine (with 256-bit sve support)**, the following assert failed. Log is as follow:

```
# Run progress: 0.00% complete, ETA 00:00:14
# Fork: 1 of 1
WARNING: Using incubator modules: jdk.incubator.vector
WARNING: A terminally deprecated method in sun.misc.Unsafe has been called
WARNING: sun.misc.Unsafe::objectFieldOffset has been called by org.openjdk.jmh.util.Utils (file:/localhome/jadmin/erfang/jdk/build/linux-aarch64-server-fastdebug/images/test/micro/benchmarks.jar)
WARNING: Please consider reporting this to the maintainers of class org.openjdk.jmh.util.Utils
WARNING: sun.misc.Unsafe::objectFieldOffset will be removed in a future release
# Warmup Iteration 1: #
# A fatal error has been detected by the Java Runtime Environment:
#
# Internal Error (/localhome/jadmin/erfang/jdk/src/hotspot/share/opto/vectorization.cpp:231), pid=167298, tid=167336
# assert(_inputs.at(alias_idx) == nullptr || _inputs.at(alias_idx) == load->in(1)) failed: not yet touched or the same input
#
# JRE version: OpenJDK Runtime Environment (26.0) (fastdebug build 26-internal-adhoc.jadmin.jdk)
# Java VM: OpenJDK 64-Bit Server VM (fastdebug 26-internal-adhoc.jadmin.jdk, mixed mode, sharing, tiered, compressed oops, compressed class ptrs, g1 gc, linux-aarch64)
# Problematic frame:
# V [libjvm.so+0x1b2d5ec] VLoopMemorySlices::find_memory_slices()+0x29c
#
# Core dump will be written. Default location: Core dumps may be processed with "/usr/share/apport/apport -p%p -s%s -c%c -d%d -P%P -u%u -g%g -F%F -- %E" (or dumping to /localhome/jadmin/erfang/jdk/build/linux-aarch64-server-fastdebug/images/test/core.167298)
#
# An error report file with more information is saved as:
# /localhome/jadmin/erfang/jdk/build/linux-aarch64-server-fastdebug/images/test/hs_err_pid167298.log
^C
ERROR: Build failed for target 'test' in configuration 'linux-aarch64-server-fastdebug' (exit code 141)

No indication of failed target found.
HELP: Try searching the build log for '] Error'.
HELP: Run 'make doctor' to diagnose build problems.

make[1]: *** [/localhome/jadmin/erfang/jdk/make/Init.gmk:151: main] Error 141
make: *** [/localhome/jadmin/erfang/jdk/make/PreInit.gmk:159: test] Interrupt
```

Test cases is a new JMH benchmark file, you can put it in ```test/micro/org/openjdk/bench/jdk/incubator/vector/MaskLastTrueBenchmark.java```

The code is as follow:
```
/*
 * Copyright (c) 2025, NVIDIA CORPORATION & 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 org.openjdk.bench.jdk.incubator.vector;

import java.util.Random;
import jdk.incubator.vector.*;
import java.util.concurrent.TimeUnit;
import org.openjdk.jmh.annotations.*;

@OutputTimeUnit(TimeUnit.MILLISECONDS)
@State(Scope.Thread)
@Warmup(iterations = 4, time = 2)
@Measurement(iterations = 6, time = 1)
@Fork(value = 1, jvmArgs = {"--add-modules=jdk.incubator.vector"})
public class MaskLastTrueBenchmark {
    @Param({"128"})
    int size;

    private static final VectorSpecies<Byte> bspecies = VectorSpecies.ofLargestShape(byte.class);
    private static final VectorSpecies<Short> sspecies = VectorSpecies.ofLargestShape(short.class);
    private static final VectorSpecies<Integer> ispecies = VectorSpecies.ofLargestShape(int.class);
    private static final VectorSpecies<Long> lspecies = VectorSpecies.ofLargestShape(long.class);
    private static final VectorSpecies<Float> fspecies = VectorSpecies.ofLargestShape(float.class);
    private static final VectorSpecies<Double> dspecies = VectorSpecies.ofLargestShape(double.class);

    byte[] byte_arr;
    short[] short_arr;
    int[] int_arr;
    long[] long_arr;
    float[] float_arr;
    double[] double_arr;
    boolean[] mask_arr;

    @Setup(Level.Trial)
    public void BmSetup() {
        Random r = new Random();
        byte_arr = new byte[size];
        short_arr = new short[size];
        int_arr = new int[size];
        long_arr = new long[size];
        float_arr = new float[size];
        double_arr = new double[size];
        mask_arr = new boolean[size];

        for (int i = 0; i < size; i++) {
            byte_arr[i] = (byte) r.nextInt();
            short_arr[i] = (short) r.nextInt();
            int_arr[i] = r.nextInt();
            long_arr[i] = r.nextLong();
            float_arr[i] = r.nextFloat();
            double_arr[i] = r.nextDouble();
            mask_arr[i] = r.nextBoolean();
        }
    }

    // VectorMask.fromArray + lastTrue

    @Benchmark
    public int testLastTrueFromArrayByte() {
        int sum = 0;
        for (int i = 0; i < size; i += bspecies.length()) {
            VectorMask<Byte> m = VectorMask.fromArray(bspecies, mask_arr, i);
            sum += m.lastTrue();
        }
        return sum;
    }

    @Benchmark
    public int testLastTrueFromArrayShort() {
        int sum = 0;
        for (int i = 0; i < size; i += sspecies.length()) {
            VectorMask<Short> m = VectorMask.fromArray(sspecies, mask_arr, i);
            sum += m.lastTrue();
        }
        return sum;
    }

    @Benchmark
    public int testLastTrueFromArrayInt() {
        int sum = 0;
        for (int i = 0; i < size; i += ispecies.length()) {
            VectorMask<Integer> m = VectorMask.fromArray(ispecies, mask_arr, i);
            sum += m.lastTrue();
        }
        return sum;
    }

    @Benchmark
    public int testLastTrueFromArrayLong() {
        int sum = 0;
        for (int i = 0; i < size; i += lspecies.length()) {
            VectorMask<Long> m = VectorMask.fromArray(lspecies, mask_arr, i);
            sum += m.lastTrue();
        }
        return sum;
    }

    @Benchmark
    public int testLastTrueFromArrayFloat() {
        int sum = 0;
        for (int i = 0; i < size; i += fspecies.length()) {
            VectorMask<Float> m = VectorMask.fromArray(fspecies, mask_arr, i);
            sum += m.lastTrue();
        }
        return sum;
    }

    @Benchmark
    public int testLastTrueFromArrayDouble() {
        int sum = 0;
        for (int i = 0; i < size; i += dspecies.length()) {
            VectorMask<Double> m = VectorMask.fromArray(dspecies, mask_arr, i);
            sum += m.lastTrue();
        }
        return sum;
    }


    // Vector.compare + lastTrue

    @Benchmark
    public int testLastTrueCompareByte() {
        int sum = 0;
        for (int i = 0; i < size; i += bspecies.length()) {
            ByteVector v = ByteVector.fromArray(bspecies, byte_arr, i);
            sum += v.compare(VectorOperators.LT, 0).lastTrue();
        }
        return sum;
    }

    @Benchmark
    public int testLastTrueCompareShort() {
        int sum = 0;
        for (int i = 0; i < size; i += sspecies.length()) {
            ShortVector v = ShortVector.fromArray(sspecies, short_arr, i);
            sum += v.compare(VectorOperators.LT, 0).lastTrue();
        }
        return sum;
    }

    @Benchmark
    public int testLastTrueCompareInt() {
        int sum = 0;
        for (int i = 0; i < size; i += ispecies.length()) {
            IntVector v = IntVector.fromArray(ispecies, int_arr, i);
            sum += v.compare(VectorOperators.LT, 0).lastTrue();
        }
        return sum;
    }

    @Benchmark
    public int testLastTrueCompareLong() {
        int sum = 0;
        for (int i = 0; i < size; i += lspecies.length()) {
            LongVector v = LongVector.fromArray(lspecies, long_arr, i);
            sum += v.compare(VectorOperators.LT, 0).lastTrue();
        }
        return sum;
    }

    @Benchmark
    public int testLastTrueCompareFloat() {
        int sum = 0;
        for (int i = 0; i < size; i += fspecies.length()) {
            FloatVector v = FloatVector.fromArray(fspecies, float_arr, i);
            sum += v.compare(VectorOperators.LT, 0).lastTrue();
        }
        return sum;
    }

    @Benchmark
    public int testLastTrueCompareDouble() {
        int sum = 0;
        for (int i = 0; i < size; i += dspecies.length()) {
            DoubleVector v = DoubleVector.fromArray(dspecies, double_arr, i);
            sum += v.compare(VectorOperators.LT, 0).lastTrue();
        }
        return sum;
    }


    // VectorMask.indexInRange + lastTrue

    @Benchmark
    public int testLastTrueIndexInRangeByte() {
        int sum = 0;
        int limit = 0;
        VectorMask<Byte> m = VectorMask.fromArray(bspecies, mask_arr, 0);
        for (int i = 0; i < size; i += bspecies.length()) {
            sum += m.indexInRange(0, limit++ % (m.length())).lastTrue();
        }
        return sum;
    }

    @Benchmark
    public int testLastTrueIndexInRangeShort() {
        int sum = 0;
        int limit = 0;
        VectorMask<Short> m = VectorMask.fromArray(sspecies, mask_arr, 0);
        for (int i = 0; i < size; i += sspecies.length()) {
            sum += m.indexInRange(0, limit++ % (m.length())).lastTrue();
        }
        return sum;
    }

    @Benchmark
    public int testLastTrueIndexInRangeInt() {
        int sum = 0;
        int limit = 0;
        VectorMask<Integer> m = VectorMask.fromArray(ispecies, mask_arr, 0);
        for (int i = 0; i < size; i += ispecies.length()) {
            sum += m.indexInRange(0, limit++ % (m.length())).lastTrue();
        }
        return sum;
    }

    @Benchmark
    public int testLastTrueIndexInRangeLong() {
        int sum = 0;
        int limit = 0;
        VectorMask<Long> m = VectorMask.fromArray(lspecies, mask_arr, 0);
        for (int i = 0; i < size; i += lspecies.length()) {
            sum += m.indexInRange(0, limit++ % (m.length())).lastTrue();
        }
        return sum;
    }

    @Benchmark
    public int testLastTrueIndexInRangeFloat() {
        int sum = 0;
        int limit = 0;
        VectorMask<Float> m = VectorMask.fromArray(fspecies, mask_arr, 0);
        for (int i = 0; i < size; i += fspecies.length()) {
            sum += m.indexInRange(0, limit++ % (m.length())).lastTrue();
        }
        return sum;
    }

    @Benchmark
    public int testLastTrueIndexInRangeDouble() {
        int sum = 0;
        int limit = 0;
        VectorMask<Double> m = VectorMask.fromArray(dspecies, mask_arr, 0);
        for (int i = 0; i < size; i += dspecies.length()) {
            sum += m.indexInRange(0, limit++ % (m.length())).lastTrue();
        }
        return sum;
    }


    // VectorMask.fromLong + lastTrue

    @Benchmark
    public int testLastTrueFromLongByte() {
        int sum = 0;
        for (int i = 0; i < size; i += bspecies.length()) {
            VectorMask<Byte> m = VectorMask.fromLong(bspecies, i);
            sum += m.lastTrue();
        }
        return sum;
    }

    @Benchmark
    public int testLastTrueFromLongShort() {
        int sum = 0;
        for (int i = 0; i < size; i += sspecies.length()) {
            VectorMask<Short> m = VectorMask.fromLong(sspecies, i);
            sum += m.lastTrue();
        }
        return sum;
    }

    @Benchmark
    public int testLastTrueFromLongInt() {
        int sum = 0;
        for (int i = 0; i < size; i += ispecies.length()) {
            VectorMask<Integer> m = VectorMask.fromLong(ispecies, i);
            sum += m.lastTrue();
        }
        return sum;
    }

    @Benchmark
    public int testLastTrueFromLongLong() {
        int sum = 0;
        for (int i = 0; i < size; i += lspecies.length()) {
            VectorMask<Long> m = VectorMask.fromLong(lspecies, i);
            sum += m.lastTrue();
        }
        return sum;
    }

    @Benchmark
    public int testLastTrueFromLongFloat() {
        int sum = 0;
        for (int i = 0; i < size; i += fspecies.length()) {
            VectorMask<Float> m = VectorMask.fromLong(fspecies, i);
            sum += m.lastTrue();
        }
        return sum;
    }

    @Benchmark
    public int testLastTrueFromLongDouble() {
        int sum = 0;
        for (int i = 0; i < size; i += dspecies.length()) {
            VectorMask<Double> m = VectorMask.fromLong(dspecies, i);
            sum += m.lastTrue();
        }
        return sum;
    }


    // VectorMask.fromArray + lastTrue & toLong
    // Before:
    // LoadVector + VectorLoadMask + VectorMaskLastTrue
    // + VectorMaskToLong
    // After:
    // LoadVector + VectorMaskLastTrue
    // + VectorLoadMask + VectorMaskToLong
    //
    // Match rule of "LoadVector + VectorLoadMask" doesn't match since LoadVector is multi used.

    @Benchmark
    public long testMultiUsesFromArrayByte() {
        long sum = 0;
        for (int i = 0; i < size; i += bspecies.length()) {
            VectorMask<Byte> m = VectorMask.fromArray(bspecies, mask_arr, i);
            sum += m.lastTrue();
            sum += m.toLong();
        }
        return sum;
    }

    @Benchmark
    public long testMultiUsesFromArrayShort() {
        long sum = 0;
        for (int i = 0; i < size; i += sspecies.length()) {
            VectorMask<Short> m = VectorMask.fromArray(sspecies, mask_arr, i);
            sum += m.lastTrue();
            sum += m.toLong();
        }
        return sum;
    }

    @Benchmark
    public long testMultiUsesFromArrayInt() {
        long sum = 0;
        for (int i = 0; i < size; i += ispecies.length()) {
            VectorMask<Integer> m = VectorMask.fromArray(ispecies, mask_arr, i);
            sum += m.lastTrue();
            sum += m.toLong();
        }
        return sum;
    }

    @Benchmark
    public long testMultiUsesFromArrayLong() {
        long sum = 0;
        for (int i = 0; i < size; i += lspecies.length()) {
            VectorMask<Long> m = VectorMask.fromArray(lspecies, mask_arr, i);
            sum += m.lastTrue();
            sum += m.toLong();
        }
        return sum;
    }

    @Benchmark
    public long testMultiUsesFromArrayFloat() {
        long sum = 0;
        for (int i = 0; i < size; i += fspecies.length()) {
            VectorMask<Float> m = VectorMask.fromArray(fspecies, mask_arr, i);
            sum += m.lastTrue();
            sum += m.toLong();
        }
        return sum;
    }

    @Benchmark
    public long testMultiUsesFromArrayDouble() {
        long sum = 0;
        for (int i = 0; i < size; i += dspecies.length()) {
            VectorMask<Double> m = VectorMask.fromArray(dspecies, mask_arr, i);
            sum += m.lastTrue();
            sum += m.toLong();
        }
        return sum;
    }


    // Vector.compare + lastTrue & toLong

    @Benchmark
    public long testMultiUsesCompareByte() {
        long sum = 0;
        for (int i = 0; i < size; i += bspecies.length()) {
            ByteVector v = ByteVector.fromArray(bspecies, byte_arr, i);
            VectorMask<Byte> m = v.compare(VectorOperators.LT, 0);
            sum += m.lastTrue();
            sum += m.toLong();
        }
        return sum;
    }

    @Benchmark
    public long testMultiUsesCompareShort() {
        long sum = 0;
        for (int i = 0; i < size; i += sspecies.length()) {
            ShortVector v = ShortVector.fromArray(sspecies, short_arr, i);
            VectorMask<Short> m = v.compare(VectorOperators.LT, 0);
            sum += m.lastTrue();
            sum += m.toLong();
        }
        return sum;
    }

    @Benchmark
    public long testMultiUsesCompareInt() {
        long sum = 0;
        for (int i = 0; i < size; i += ispecies.length()) {
            IntVector v = IntVector.fromArray(ispecies, int_arr, i);
            VectorMask<Integer> m = v.compare(VectorOperators.LT, 0);
            sum += m.lastTrue();
            sum += m.toLong();
        }
        return sum;
    }

    @Benchmark
    public long testMultiUsesCompareLong() {
        long sum = 0;
        for (int i = 0; i < size; i += lspecies.length()) {
            LongVector v = LongVector.fromArray(lspecies, long_arr, i);
            VectorMask<Long> m = v.compare(VectorOperators.LT, 0);
            sum += m.lastTrue();
            sum += m.toLong();
        }
        return sum;
    }

    @Benchmark
    public long testMultiUsesCompareFloat() {
        long sum = 0;
        for (int i = 0; i < size; i += fspecies.length()) {
            FloatVector v = FloatVector.fromArray(fspecies, float_arr, i);
            VectorMask<Float> m = v.compare(VectorOperators.LT, 0);
            sum += m.lastTrue();
            sum += m.toLong();
        }
        return sum;
    }

    @Benchmark
    public long testMultiUsesCompareDouble() {
        long sum = 0;
        for (int i = 0; i < size; i += dspecies.length()) {
            DoubleVector v = DoubleVector.fromArray(dspecies, double_arr, i);
            VectorMask<Double> m = v.compare(VectorOperators.LT, 0);
            sum += m.lastTrue();
            sum += m.toLong();
        }
        return sum;
    }

}
```

To reproduce the crash, run the following test command:
``` make test TEST=micro:org.openjdk.bench.jdk.incubator.vector.MaskLastTrueBenchmark.* ```

[~epeter] Would you mind taking a look since the assert was introduced by https://github.com/openjdk/jdk/commit/2ac24bf1bac9c32704ebd72b93a75819b9404063, thanks!