ARM64: Adjust SIMD checker tests for SVE.

Adds SVE-specific checker line for SIMD tests
using isaHasFeature() function.

Test: test-art-target with Neon.
Test: art tests on FVP (steps in test/README.arm_fvp.md)
      with FVP arg:
      -C SVE.ScalableVectorExtension.veclen=[2,4]
      (SVE vector [128,256] bits wide)

Change-Id: I8f2134861b47437823797da48a3ffb680bafc544

1 files changed, 298 insertions, 101 deletions

diff --git a/test/527-checker-array-access-simd/src/Main.java b/test/527-checker-array-access-simd/src/Main.java
index 8af5465faf..173165a0a0 100644
--- a/test/527-checker-array-access-simd/src/Main.java
+++ b/test/527-checker-array-access-simd/src/Main.java
@@ -25,47 +25,105 @@ public class Main {
   /// CHECK-START-ARM64: void Main.checkIntCase(int[]) instruction_simplifier_arm64 (before)
   /// CHECK-DAG:             <<Array:l\d+>>         ParameterValue
   /// CHECK-DAG:             <<Const5:i\d+>>        IntConstant 5
-  /// CHECK-DAG:             <<Repl:d\d+>>          VecReplicateScalar [<<Const5>>]
-  //  -------------- Loop
-  /// CHECK-DAG:             <<Index:i\d+>>         Phi
-  /// CHECK-DAG:                                    If
-  /// CHECK-DAG:             <<Load:d\d+>>          VecLoad [<<Array>>,<<Index>>]
-  /// CHECK-DAG:             <<Add:d\d+>>           VecAdd [<<Load>>,<<Repl>>]
-  /// CHECK-DAG:                                    VecStore [<<Array>>,<<Index>>,<<Add>>]
+  /// CHECK-IF:     hasIsaFeature("sve")
+  //
+  ///     CHECK-DAG:             <<Repl:d\d+>>          VecReplicateScalar [<<Const5>>,{{j\d+}}]
+  //      -------------- Loop
+  ///     CHECK-DAG:             <<Index:i\d+>>         Phi
+  ///     CHECK-DAG:             <<LoopP:j\d+>>         VecPredWhile
+  ///     CHECK-DAG:                                    If
+  ///     CHECK-DAG:             <<Load:d\d+>>          VecLoad [<<Array>>,<<Index>>,<<LoopP>>]
+  ///     CHECK-DAG:             <<Add:d\d+>>           VecAdd [<<Load>>,<<Repl>>,<<LoopP>>]
+  ///     CHECK-DAG:                                    VecStore [<<Array>>,<<Index>>,<<Add>>,<<LoopP>>]
+  //
+  /// CHECK-ELSE:
+  //
+  ///     CHECK-DAG:             <<Repl:d\d+>>          VecReplicateScalar [<<Const5>>]
+  //      -------------- Loop
+  ///     CHECK-DAG:             <<Index:i\d+>>         Phi
+  ///     CHECK-DAG:                                    If
+  ///     CHECK-DAG:             <<Load:d\d+>>          VecLoad [<<Array>>,<<Index>>]
+  ///     CHECK-DAG:             <<Add:d\d+>>           VecAdd [<<Load>>,<<Repl>>]
+  ///     CHECK-DAG:                                    VecStore [<<Array>>,<<Index>>,<<Add>>]
+  //
+  /// CHECK-FI:
 
   /// CHECK-START-ARM64: void Main.checkIntCase(int[]) instruction_simplifier_arm64 (after)
   /// CHECK-DAG:             <<Array:l\d+>>         ParameterValue
   /// CHECK-DAG:             <<Const5:i\d+>>        IntConstant 5
-  /// CHECK-DAG:             <<DataOffset:i\d+>>    IntConstant 12
-  /// CHECK-DAG:             <<Const2:i\d+>>        IntConstant 2
-  /// CHECK-DAG:             <<Repl:d\d+>>          VecReplicateScalar [<<Const5>>]
-  //  -------------- Loop
-  /// CHECK-DAG:             <<Index:i\d+>>         Phi
-  /// CHECK-DAG:                                    If
-  /// CHECK-DAG:             <<Address1:i\d+>>      IntermediateAddressIndex [<<Index>>,<<DataOffset>>,<<Const2>>]
-  /// CHECK-DAG:             <<Load:d\d+>>          VecLoad [<<Array>>,<<Address1>>]
-  /// CHECK-DAG:             <<Add:d\d+>>           VecAdd [<<Load>>,<<Repl>>]
-  /// CHECK-DAG:             <<Address2:i\d+>>      IntermediateAddressIndex [<<Index>>,<<DataOffset>>,<<Const2>>]
-  /// CHECK-DAG:                                    VecStore [<<Array>>,<<Address2>>,<<Add>>]
+  /// CHECK-IF:     hasIsaFeature("sve")
+  //
+  //      IntermediateAddressIndex is not supported for SVE.
+  ///     CHECK-DAG:             <<Repl:d\d+>>          VecReplicateScalar [<<Const5>>,{{j\d+}}]
+  //      -------------- Loop
+  ///     CHECK-DAG:             <<LoopP:j\d+>>         VecPredWhile
+  ///     CHECK-DAG:             <<Index:i\d+>>         Phi
+  ///     CHECK-DAG:                                    If
+  ///     CHECK-DAG:             <<Load:d\d+>>          VecLoad [<<Array>>,<<Index>>,<<LoopP>>]
+  ///     CHECK-DAG:             <<Add:d\d+>>           VecAdd [<<Load>>,<<Repl>>,<<LoopP>>]
+  ///     CHECK-DAG:                                    VecStore [<<Array>>,<<Index>>,<<Add>>,<<LoopP>>]
+  //
+  /// CHECK-ELSE:
+  //
+  ///     CHECK-DAG:             <<Const2:i\d+>>        IntConstant 2
+  ///     CHECK-DAG:             <<DataOffset:i\d+>>    IntConstant 12
+  ///     CHECK-DAG:             <<Repl:d\d+>>          VecReplicateScalar [<<Const5>>]
+  //      -------------- Loop
+  ///     CHECK-DAG:             <<Index:i\d+>>         Phi
+  ///     CHECK-DAG:                                    If
+  ///     CHECK-DAG:             <<Address1:i\d+>>      IntermediateAddressIndex [<<Index>>,<<DataOffset>>,<<Const2>>]
+  ///     CHECK-DAG:             <<Load:d\d+>>          VecLoad [<<Array>>,<<Address1>>]
+  ///     CHECK-DAG:             <<Add:d\d+>>           VecAdd [<<Load>>,<<Repl>>]
+  ///     CHECK-DAG:             <<Address2:i\d+>>      IntermediateAddressIndex [<<Index>>,<<DataOffset>>,<<Const2>>]
+  ///     CHECK-DAG:                                    VecStore [<<Array>>,<<Address2>>,<<Add>>]
+  //
+  /// CHECK-FI:
 
   /// CHECK-START-ARM64: void Main.checkIntCase(int[]) GVN$after_arch (after)
   /// CHECK-DAG:             <<Array:l\d+>>         ParameterValue
   /// CHECK-DAG:             <<Const5:i\d+>>        IntConstant 5
-  /// CHECK-DAG:             <<DataOffset:i\d+>>    IntConstant 12
-  /// CHECK-DAG:             <<Const2:i\d+>>        IntConstant 2
-  /// CHECK-DAG:             <<Repl:d\d+>>          VecReplicateScalar [<<Const5>>]
-  //  -------------- Loop
-  /// CHECK-DAG:             <<Index:i\d+>>         Phi
-  /// CHECK-DAG:                                    If
-  /// CHECK-DAG:             <<Address1:i\d+>>      IntermediateAddressIndex [<<Index>>,<<DataOffset>>,<<Const2>>]
-  /// CHECK-DAG:             <<Load:d\d+>>          VecLoad [<<Array>>,<<Address1>>]
-  /// CHECK-DAG:             <<Add:d\d+>>           VecAdd [<<Load>>,<<Repl>>]
-  /// CHECK-NOT:                                    IntermediateAddress
-  /// CHECK-DAG:                                    VecStore [<<Array>>,<<Address1>>,<<Add>>]
+  /// CHECK-IF:     hasIsaFeature("sve")
+  //
+  //      IntermediateAddressIndex is not supported for SVE.
+  ///     CHECK-DAG:             <<Repl:d\d+>>          VecReplicateScalar [<<Const5>>,{{j\d+}}]
+  //      -------------- Loop
+  ///     CHECK-DAG:             <<LoopP:j\d+>>         VecPredWhile
+  ///     CHECK-DAG:             <<Index:i\d+>>         Phi
+  ///     CHECK-DAG:                                    If
+  ///     CHECK-DAG:             <<Load:d\d+>>          VecLoad [<<Array>>,<<Index>>,<<LoopP>>]
+  ///     CHECK-DAG:             <<Add:d\d+>>           VecAdd [<<Load>>,<<Repl>>,<<LoopP>>]
+  ///     CHECK-NOT:                                    IntermediateAddress
+  ///     CHECK-DAG:                                    VecStore [<<Array>>,<<Index>>,<<Add>>,<<LoopP>>]
+  //
+  /// CHECK-ELSE:
+  //
+  ///     CHECK-DAG:             <<DataOffset:i\d+>>    IntConstant 12
+  ///     CHECK-DAG:             <<Const2:i\d+>>        IntConstant 2
+  ///     CHECK-DAG:             <<Repl:d\d+>>          VecReplicateScalar [<<Const5>>]
+  //      -------------- Loop
+  ///     CHECK-DAG:             <<Index:i\d+>>         Phi
+  ///     CHECK-DAG:                                    If
+  ///     CHECK-DAG:             <<Address1:i\d+>>      IntermediateAddressIndex [<<Index>>,<<DataOffset>>,<<Const2>>]
+  ///     CHECK-DAG:             <<Load:d\d+>>          VecLoad [<<Array>>,<<Address1>>]
+  ///     CHECK-DAG:             <<Add:d\d+>>           VecAdd [<<Load>>,<<Repl>>]
+  ///     CHECK-NOT:                                    IntermediateAddress
+  ///     CHECK-DAG:                                    VecStore [<<Array>>,<<Address1>>,<<Add>>]
+  //
+  /// CHECK-FI:
 
   /// CHECK-START-ARM64: void Main.checkIntCase(int[]) disassembly (after)
-  /// CHECK:                                        IntermediateAddressIndex
-  /// CHECK-NEXT:                                   add w{{[0-9]+}}, w{{[0-9]+}}, w{{[0-9]+}}, lsl #2
+  /// CHECK-IF:     hasIsaFeature("sve")
+  //
+  //      IntermediateAddressIndex is not supported for SVE.
+  ///     CHECK-NOT:                                    IntermediateAddressIndex
+  ///     CHECK-NOT:                                    IntermediateAddress
+  //
+  /// CHECK-ELSE:
+  //
+  ///     CHECK:                                        IntermediateAddressIndex
+  ///     CHECK-NEXT:                                   add w{{[0-9]+}}, w{{[0-9]+}}, w{{[0-9]+}}, lsl #2
+  //
+  /// CHECK-FI:
   public static void checkIntCase(int[] a) {
     for (int i = 0; i < 128; i++) {
       a[i] += 5;
@@ -75,51 +133,109 @@ public class Main {
   /// CHECK-START-ARM64: void Main.checkByteCase(byte[]) instruction_simplifier_arm64 (before)
   /// CHECK-DAG:             <<Array:l\d+>>         ParameterValue
   /// CHECK-DAG:             <<Const5:i\d+>>        IntConstant 5
-  /// CHECK-DAG:             <<Repl:d\d+>>          VecReplicateScalar [<<Const5>>]
-  //  -------------- Loop
-  /// CHECK-DAG:             <<Index:i\d+>>         Phi
-  /// CHECK-DAG:                                    If
-  /// CHECK-DAG:             <<Load:d\d+>>          VecLoad [<<Array>>,<<Index>>]
-  /// CHECK-DAG:             <<Add:d\d+>>           VecAdd [<<Load>>,<<Repl>>]
-  /// CHECK-DAG:                                    VecStore [<<Array>>,<<Index>>,<<Add>>]
+  /// CHECK-IF:     hasIsaFeature("sve")
+  //
+  ///     CHECK-DAG:             <<Repl:d\d+>>          VecReplicateScalar [<<Const5>>,{{j\d+}}]
+  //      -------------- Loop
+  ///     CHECK-DAG:             <<LoopP:j\d+>>         VecPredWhile
+  ///     CHECK-DAG:             <<Index:i\d+>>         Phi
+  ///     CHECK-DAG:                                    If
+  ///     CHECK-DAG:             <<Load:d\d+>>          VecLoad [<<Array>>,<<Index>>,<<LoopP>>]
+  ///     CHECK-DAG:             <<Add:d\d+>>           VecAdd [<<Load>>,<<Repl>>,<<LoopP>>]
+  ///     CHECK-DAG:                                    VecStore [<<Array>>,<<Index>>,<<Add>>,<<LoopP>>]
+  //
+  /// CHECK-ELSE:
+  //
+  ///     CHECK-DAG:             <<Repl:d\d+>>          VecReplicateScalar [<<Const5>>]
+  //      -------------- Loop
+  ///     CHECK-DAG:             <<Index:i\d+>>         Phi
+  ///     CHECK-DAG:                                    If
+  ///     CHECK-DAG:             <<Load:d\d+>>          VecLoad [<<Array>>,<<Index>>]
+  ///     CHECK-DAG:             <<Add:d\d+>>           VecAdd [<<Load>>,<<Repl>>]
+
+  //
+  /// CHECK-FI:
 
   /// CHECK-START-ARM64: void Main.checkByteCase(byte[]) instruction_simplifier_arm64 (after)
   /// CHECK-DAG:             <<Array:l\d+>>         ParameterValue
   /// CHECK-DAG:             <<Const0:i\d+>>        IntConstant 0
   /// CHECK-DAG:             <<Const5:i\d+>>        IntConstant 5
-  /// CHECK-DAG:             <<DataOffset:i\d+>>    IntConstant 12
-  /// CHECK-DAG:             <<Repl:d\d+>>          VecReplicateScalar [<<Const5>>]
-  //  -------------- Loop
-  /// CHECK-DAG:             <<Index:i\d+>>         Phi
-  /// CHECK-DAG:                                    If
-  /// CHECK-DAG:             <<Address1:i\d+>>      IntermediateAddressIndex [<<Index>>,<<DataOffset>>,<<Const0>>]
-  /// CHECK-DAG:             <<Load:d\d+>>          VecLoad [<<Array>>,<<Address1>>]
-  /// CHECK-DAG:             <<Add:d\d+>>           VecAdd [<<Load>>,<<Repl>>]
-  /// CHECK-DAG:             <<Address2:i\d+>>      IntermediateAddressIndex [<<Index>>,<<DataOffset>>,<<Const0>>]
-  /// CHECK-DAG:                                    VecStore [<<Array>>,<<Address2>>,<<Add>>]
+  /// CHECK-IF:     hasIsaFeature("sve")
+  //
+  //      IntermediateAddressIndex is not supported for SVE.
+  ///     CHECK-DAG:             <<Repl:d\d+>>          VecReplicateScalar [<<Const5>>,{{j\d+}}]
+  //      -------------- Loop
+  ///     CHECK-DAG:             <<LoopP:j\d+>>         VecPredWhile
+  ///     CHECK-DAG:             <<Index:i\d+>>         Phi
+  ///     CHECK-DAG:                                    If
+  ///     CHECK-DAG:             <<Load:d\d+>>          VecLoad [<<Array>>,<<Index>>,<<LoopP>>]
+  ///     CHECK-DAG:             <<Add:d\d+>>           VecAdd [<<Load>>,<<Repl>>,<<LoopP>>]
+  ///     CHECK-DAG:                                    VecStore [<<Array>>,<<Index>>,<<Add>>,<<LoopP>>]
+  //
+  /// CHECK-ELSE:
+  //
+  ///     CHECK-DAG:             <<DataOffset:i\d+>>    IntConstant 12
+  ///     CHECK-DAG:             <<Repl:d\d+>>          VecReplicateScalar [<<Const5>>]
+  //      -------------- Loop
+  ///     CHECK-DAG:             <<Index:i\d+>>         Phi
+  ///     CHECK-DAG:                                    If
+  ///     CHECK-DAG:             <<Address1:i\d+>>      IntermediateAddressIndex [<<Index>>,<<DataOffset>>,<<Const0>>]
+  ///     CHECK-DAG:             <<Load:d\d+>>          VecLoad [<<Array>>,<<Address1>>]
+  ///     CHECK-DAG:             <<Add:d\d+>>           VecAdd [<<Load>>,<<Repl>>]
+  ///     CHECK-DAG:             <<Address2:i\d+>>      IntermediateAddressIndex [<<Index>>,<<DataOffset>>,<<Const0>>]
+  ///     CHECK-DAG:                                    VecStore [<<Array>>,<<Address2>>,<<Add>>]
+  //
+  /// CHECK-FI:
 
   /// CHECK-START-ARM64: void Main.checkByteCase(byte[]) GVN$after_arch (after)
   /// CHECK-DAG:             <<Array:l\d+>>         ParameterValue
   /// CHECK-DAG:             <<Const0:i\d+>>        IntConstant 0
   /// CHECK-DAG:             <<Const5:i\d+>>        IntConstant 5
-  /// CHECK-DAG:             <<DataOffset:i\d+>>    IntConstant 12
-  /// CHECK-DAG:             <<Repl:d\d+>>          VecReplicateScalar [<<Const5>>]
-  //  -------------- Loop
-  /// CHECK-DAG:             <<Index:i\d+>>         Phi
-  /// CHECK-DAG:                                    If
-  /// CHECK-DAG:             <<Address1:i\d+>>      IntermediateAddressIndex [<<Index>>,<<DataOffset>>,<<Const0>>]
-  /// CHECK-DAG:             <<Load:d\d+>>          VecLoad [<<Array>>,<<Address1>>]
-  /// CHECK-DAG:             <<Add:d\d+>>           VecAdd [<<Load>>,<<Repl>>]
-  /// CHECK-NOT:                                    IntermediateAddress
-  /// CHECK-DAG:                                    VecStore [<<Array>>,<<Address1>>,<<Add>>]
+  /// CHECK-IF:     hasIsaFeature("sve")
+  //
+  //      IntermediateAddressIndex is not supported for SVE.
+  ///     CHECK-DAG:             <<Repl:d\d+>>          VecReplicateScalar [<<Const5>>,{{j\d+}}]
+  //      -------------- Loop
+  ///     CHECK-DAG:             <<LoopP:j\d+>>         VecPredWhile
+  ///     CHECK-DAG:             <<Index:i\d+>>         Phi
+  ///     CHECK-DAG:                                    If
+  ///     CHECK-DAG:             <<Load:d\d+>>          VecLoad [<<Array>>,<<Index>>,<<LoopP>>]
+  ///     CHECK-DAG:             <<Add:d\d+>>           VecAdd [<<Load>>,<<Repl>>,<<LoopP>>]
+  ///     CHECK-NOT:                                    IntermediateAddress
+  ///     CHECK-DAG:                                    VecStore [<<Array>>,<<Index>>,<<Add>>,<<LoopP>>]
+  //
+  /// CHECK-ELSE:
+  //
+  ///     CHECK-DAG:             <<DataOffset:i\d+>>    IntConstant 12
+  ///     CHECK-DAG:             <<Repl:d\d+>>          VecReplicateScalar [<<Const5>>]
+  //      -------------- Loop
+  ///     CHECK-DAG:             <<Index:i\d+>>         Phi
+  ///     CHECK-DAG:                                    If
+  ///     CHECK-DAG:             <<Address1:i\d+>>      IntermediateAddressIndex [<<Index>>,<<DataOffset>>,<<Const0>>]
+  ///     CHECK-DAG:             <<Load:d\d+>>          VecLoad [<<Array>>,<<Address1>>]
+  ///     CHECK-DAG:             <<Add:d\d+>>           VecAdd [<<Load>>,<<Repl>>]
+  ///     CHECK-NOT:                                    IntermediateAddress
+  ///     CHECK-DAG:                                    VecStore [<<Array>>,<<Address1>>,<<Add>>]
+  //
+  /// CHECK-FI:
 
   /// CHECK-START-ARM64: void Main.checkByteCase(byte[]) disassembly (after)
-  /// CHECK:                                        IntermediateAddressIndex
-  /// CHECK-NEXT:                                   add w{{[0-9]+}}, w{{[0-9]+}}, #0x{{[0-9a-fA-F]+}}
-  /// CHECK:                                        VecLoad
-  /// CHECK-NEXT:                                   ldr q{{[0-9]+}}, [x{{[0-9]+}}, x{{[0-9]+}}]
-  /// CHECK:                                        VecStore
-  /// CHECK-NEXT:                                   str q{{[0-9]+}}, [x{{[0-9]+}}, x{{[0-9]+}}]
+  /// CHECK-IF:     hasIsaFeature("sve")
+  //
+  //      IntermediateAddressIndex is not supported for SVE.
+  ///     CHECK-NOT:                                    IntermediateAddressIndex
+  ///     CHECK-NOT:                                    IntermediateAddress
+  //
+  /// CHECK-ELSE:
+  //
+  ///     CHECK:                                        IntermediateAddressIndex
+  ///     CHECK-NEXT:                                   add w{{[0-9]+}}, w{{[0-9]+}}, #0x{{[0-9a-fA-F]+}}
+  ///     CHECK:                                        VecLoad
+  ///     CHECK-NEXT:                                   ldr q{{[0-9]+}}, [x{{[0-9]+}}, x{{[0-9]+}}]
+  ///     CHECK:                                        VecStore
+  ///     CHECK-NEXT:                                   str q{{[0-9]+}}, [x{{[0-9]+}}, x{{[0-9]+}}]
+  //
+  /// CHECK-FI:
   public static void checkByteCase(byte[] a) {
     for (int i = 0; i < 128; i++) {
       a[i] += 5;
@@ -129,21 +245,48 @@ public class Main {
   /// CHECK-START-ARM64: void Main.checkSingleAccess(int[]) instruction_simplifier_arm64 (before)
   /// CHECK-DAG:             <<Array:l\d+>>         ParameterValue
   /// CHECK-DAG:             <<Const5:i\d+>>        IntConstant 5
-  /// CHECK-DAG:             <<Repl:d\d+>>          VecReplicateScalar [<<Const5>>]
-  //  -------------- Loop
-  /// CHECK-DAG:             <<Index:i\d+>>         Phi
-  /// CHECK-DAG:                                    If
-  /// CHECK-DAG:                                    VecStore [<<Array>>,<<Index>>,<<Repl>>]
+  /// CHECK-IF:     hasIsaFeature("sve")
+  //
+  ///     CHECK-DAG:             <<Repl:d\d+>>          VecReplicateScalar [<<Const5>>,{{j\d+}}]
+  //      -------------- Loop
+  ///     CHECK-DAG:             <<Index:i\d+>>         Phi
+  ///     CHECK-DAG:             <<LoopP:j\d+>>         VecPredWhile
+  ///     CHECK-DAG:                                    If
+  ///     CHECK-DAG:                                    VecStore [<<Array>>,<<Index>>,<<Repl>>,<<LoopP>>]
+  //
+  /// CHECK-ELSE:
+  //
+  ///     CHECK-DAG:             <<Repl:d\d+>>          VecReplicateScalar [<<Const5>>]
+  //      -------------- Loop
+  ///     CHECK-DAG:             <<Index:i\d+>>         Phi
+  ///     CHECK-DAG:                                    If
+  ///     CHECK-DAG:                                    VecStore [<<Array>>,<<Index>>,<<Repl>>]
+  //
+  /// CHECK-FI:
 
   /// CHECK-START-ARM64: void Main.checkSingleAccess(int[]) instruction_simplifier_arm64 (after)
   /// CHECK-DAG:             <<Array:l\d+>>         ParameterValue
   /// CHECK-DAG:             <<Const0:i\d+>>        IntConstant 0
   /// CHECK-DAG:             <<Const5:i\d+>>        IntConstant 5
-  /// CHECK-DAG:             <<Repl:d\d+>>          VecReplicateScalar [<<Const5>>]
-  //  -------------- Loop
-  /// CHECK-DAG:             <<Index:i\d+>>         Phi
-  /// CHECK-DAG:                                    If
-  /// CHECK-DAG:                                    VecStore [<<Array>>,<<Index>>,<<Repl>>]
+  /// CHECK-IF:     hasIsaFeature("sve")
+  //
+  ///     CHECK-DAG:             <<Repl:d\d+>>          VecReplicateScalar [<<Const5>>,{{j\d+}}]
+  //      -------------- Loop
+  ///     CHECK-DAG:             <<LoopP:j\d+>>         VecPredWhile
+  ///     CHECK-DAG:             <<Index:i\d+>>         Phi
+  ///     CHECK-DAG:                                    If
+  ///     CHECK-DAG:                                    VecStore [<<Array>>,<<Index>>,<<Repl>>,<<LoopP>>]
+  //
+  /// CHECK-ELSE:
+  //
+  ///     CHECK-DAG:             <<Repl:d\d+>>          VecReplicateScalar [<<Const5>>]
+  //      -------------- Loop
+  ///     CHECK-DAG:             <<Index:i\d+>>         Phi
+  ///     CHECK-DAG:                                    If
+  ///     CHECK-DAG:                                    VecStore [<<Array>>,<<Index>>,<<Repl>>]
+  //
+  /// CHECK-FI:
+  //
   /// CHECK-NOT:                                    IntermediateAddress
   public static void checkSingleAccess(int[] a) {
     for (int i = 0; i < 128; i++) {
@@ -155,43 +298,97 @@ public class Main {
   /// CHECK-DAG:             <<Array1:l\d+>>        ParameterValue
   /// CHECK-DAG:             <<Array2:l\d+>>        ParameterValue
   //  -------------- Loop
-  /// CHECK-DAG:             <<Index:i\d+>>         Phi
-  /// CHECK-DAG:                                    If
-  /// CHECK-DAG:             <<Load:d\d+>>          VecLoad [<<Array1>>,<<Index>>]
-  /// CHECK-DAG:             <<Cnv:d\d+>>           VecCnv [<<Load>>]
-  /// CHECK-DAG:                                    VecStore [<<Array2>>,<<Index>>,<<Cnv>>]
+  /// CHECK-IF:     hasIsaFeature("sve")
+  //
+  ///     CHECK-DAG:             <<LoopP:j\d+>>         VecPredWhile
+  ///     CHECK-DAG:             <<Index:i\d+>>         Phi
+  ///     CHECK-DAG:                                    If
+  ///     CHECK-DAG:             <<Load:d\d+>>          VecLoad [<<Array1>>,<<Index>>,<<LoopP>>]
+  ///     CHECK-DAG:             <<Cnv:d\d+>>           VecCnv [<<Load>>,<<LoopP>>]
+  ///     CHECK-DAG:                                    VecStore [<<Array2>>,<<Index>>,<<Cnv>>,<<LoopP>>]
+  //
+  /// CHECK-ELSE:
+  //
+  ///     CHECK-DAG:             <<Index:i\d+>>         Phi
+  ///     CHECK-DAG:                                    If
+  ///     CHECK-DAG:             <<Load:d\d+>>          VecLoad [<<Array1>>,<<Index>>]
+  ///     CHECK-DAG:             <<Cnv:d\d+>>           VecCnv [<<Load>>]
+  ///     CHECK-DAG:                                    VecStore [<<Array2>>,<<Index>>,<<Cnv>>]
+  //
+  /// CHECK-FI:
 
   /// CHECK-START-ARM64: void Main.checkInt2Float(int[], float[]) instruction_simplifier_arm64 (after)
   /// CHECK-DAG:             <<Array1:l\d+>>        ParameterValue
   /// CHECK-DAG:             <<Array2:l\d+>>        ParameterValue
-  /// CHECK-DAG:             <<DataOffset:i\d+>>    IntConstant 12
-  /// CHECK-DAG:             <<Const2:i\d+>>        IntConstant 2
-  //  -------------- Loop
-  /// CHECK-DAG:             <<Index:i\d+>>         Phi
-  /// CHECK-DAG:                                    If
-  /// CHECK-DAG:             <<Address1:i\d+>>      IntermediateAddressIndex [<<Index>>,<<DataOffset>>,<<Const2>>]
-  /// CHECK-DAG:             <<Load:d\d+>>          VecLoad [<<Array1>>,<<Address1>>]
-  /// CHECK-DAG:             <<Cnv:d\d+>>           VecCnv [<<Load>>]
-  /// CHECK-DAG:             <<Address2:i\d+>>      IntermediateAddressIndex [<<Index>>,<<DataOffset>>,<<Const2>>]
-  /// CHECK-DAG:                                    VecStore [<<Array2>>,<<Address2>>,<<Cnv>>]
+  /// CHECK-IF:     hasIsaFeature("sve")
+  //
+  //      IntermediateAddressIndex is not supported for SVE.
+  //      -------------- Loop
+  ///     CHECK-DAG:             <<LoopP:j\d+>>         VecPredWhile
+  ///     CHECK-DAG:             <<Index:i\d+>>         Phi
+  ///     CHECK-DAG:                                    If
+  ///     CHECK-DAG:             <<Load:d\d+>>          VecLoad [<<Array1>>,<<Index>>,<<LoopP>>]
+  ///     CHECK-DAG:             <<Cnv:d\d+>>           VecCnv [<<Load>>,<<LoopP>>]
+  ///     CHECK-DAG:                                    VecStore [<<Array2>>,<<Index>>,<<Cnv>>,<<LoopP>>]
+  //
+  /// CHECK-ELSE:
+  //
+  ///     CHECK-DAG:             <<DataOffset:i\d+>>    IntConstant 12
+  ///     CHECK-DAG:             <<Const2:i\d+>>        IntConstant 2
+  //      -------------- Loop
+  ///     CHECK-DAG:             <<Index:i\d+>>         Phi
+  ///     CHECK-DAG:                                    If
+  ///     CHECK-DAG:             <<Address1:i\d+>>      IntermediateAddressIndex [<<Index>>,<<DataOffset>>,<<Const2>>]
+  ///     CHECK-DAG:             <<Load:d\d+>>          VecLoad [<<Array1>>,<<Address1>>]
+  ///     CHECK-DAG:             <<Cnv:d\d+>>           VecCnv [<<Load>>]
+  ///     CHECK-DAG:             <<Address2:i\d+>>      IntermediateAddressIndex [<<Index>>,<<DataOffset>>,<<Const2>>]
+  ///     CHECK-DAG:                                    VecStore [<<Array2>>,<<Address2>>,<<Cnv>>]
+  //
+  /// CHECK-FI:
 
   /// CHECK-START-ARM64: void Main.checkInt2Float(int[], float[]) GVN$after_arch (after)
   /// CHECK-DAG:             <<Array1:l\d+>>        ParameterValue
   /// CHECK-DAG:             <<Array2:l\d+>>        ParameterValue
-  /// CHECK-DAG:             <<DataOffset:i\d+>>    IntConstant 12
-  /// CHECK-DAG:             <<Const2:i\d+>>        IntConstant 2
-  //  -------------- Loop
-  /// CHECK-DAG:             <<Index:i\d+>>         Phi
-  /// CHECK-DAG:                                    If
-  /// CHECK-DAG:             <<Address1:i\d+>>      IntermediateAddressIndex [<<Index>>,<<DataOffset>>,<<Const2>>]
-  /// CHECK-DAG:             <<Load:d\d+>>          VecLoad [<<Array1>>,<<Address1>>]
-  /// CHECK-DAG:             <<Cnv:d\d+>>           VecCnv [<<Load>>]
-  /// CHECK-NOT:                                    IntermediateAddress
-  /// CHECK-DAG:                                    VecStore [<<Array2>>,<<Address1>>,<<Cnv>>]
+  /// CHECK-IF:     hasIsaFeature("sve")
+  //
+  //      IntermediateAddressIndex is not supported for SVE.
+  //      -------------- Loop
+  ///     CHECK-DAG:             <<LoopP:j\d+>>         VecPredWhile
+  ///     CHECK-DAG:             <<Index:i\d+>>         Phi
+  ///     CHECK-DAG:                                    If
+  ///     CHECK-DAG:             <<Load:d\d+>>          VecLoad [<<Array1>>,<<Index>>,<<LoopP>>]
+  ///     CHECK-DAG:             <<Cnv:d\d+>>           VecCnv [<<Load>>,<<LoopP>>]
+  ///     CHECK-NOT:                                    IntermediateAddress
+  ///     CHECK-DAG:                                    VecStore [<<Array2>>,<<Index>>,<<Cnv>>,<<LoopP>>]
+  //
+  /// CHECK-ELSE:
+  //
+  ///     CHECK-DAG:             <<DataOffset:i\d+>>    IntConstant 12
+  ///     CHECK-DAG:             <<Const2:i\d+>>        IntConstant 2
+  //      -------------- Loop
+  ///     CHECK-DAG:             <<Index:i\d+>>         Phi
+  ///     CHECK-DAG:                                    If
+  ///     CHECK-DAG:             <<Address1:i\d+>>      IntermediateAddressIndex [<<Index>>,<<DataOffset>>,<<Const2>>]
+  ///     CHECK-DAG:             <<Load:d\d+>>          VecLoad [<<Array1>>,<<Address1>>]
+  ///     CHECK-DAG:             <<Cnv:d\d+>>           VecCnv [<<Load>>]
+  ///     CHECK-NOT:                                    IntermediateAddress
+  ///     CHECK-DAG:                                    VecStore [<<Array2>>,<<Address1>>,<<Cnv>>]
+  //
+  /// CHECK-FI:
 
   /// CHECK-START-ARM64: void Main.checkInt2Float(int[], float[]) disassembly (after)
-  /// CHECK:                                        IntermediateAddressIndex
-  /// CHECK-NEXT:                                   add w{{[0-9]+}}, w{{[0-9]+}}, w{{[0-9]+}}, lsl #2
+  /// CHECK-IF:     hasIsaFeature("sve")
+  //
+  //      IntermediateAddressIndex is not supported for SVE.
+  ///     CHECK-NOT:                                    IntermediateAddressIndex
+  ///     CHECK-NOT:                                    IntermediateAddress
+  //
+  /// CHECK-ELSE:
+  //
+  ///     CHECK:                                        IntermediateAddressIndex
+  ///     CHECK-NEXT:                                   add w{{[0-9]+}}, w{{[0-9]+}}, w{{[0-9]+}}, lsl #2
+  //
+  /// CHECK-FI:
   public static void checkInt2Float(int[] a, float[] b) {
     for (int i = 0; i < 128; i++) {
       b[i] = (float) a[i];