diff options
28 files changed, 3133 insertions, 902 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]; diff --git a/test/530-checker-lse-simd/src/Main.java b/test/530-checker-lse-simd/src/Main.java index fd3333bb5f..d6049d0bd0 100644 --- a/test/530-checker-lse-simd/src/Main.java +++ b/test/530-checker-lse-simd/src/Main.java @@ -144,19 +144,27 @@ public class Main { // Check LSE eliminates VecLoad. // /// CHECK-START-ARM64: double[] Main.$noinline$test04(int) load_store_elimination (before) - /// CHECK: VecStore - /// CHECK-NEXT: VecLoad - /// CHECK-NEXT: VecAdd - /// CHECK-NEXT: VecStore - /// CHECK-NEXT: Add - /// CHECK-NEXT: Goto loop:{{B\d+}} + /// CHECK: VecStore + /// CHECK: VecLoad + /// CHECK: VecAdd + /// CHECK: VecStore + /// CHECK: Add + /// CHECK: Goto loop:{{B\d+}} /// CHECK-START-ARM64: double[] Main.$noinline$test04(int) load_store_elimination (after) - /// CHECK: VecStore - /// CHECK-NEXT: VecAdd - /// CHECK-NEXT: VecStore - /// CHECK-NEXT: Add - /// CHECK-NEXT: Goto loop:{{B\d+}} + /// CHECK-IF: not hasIsaFeature("sve") + // + // In NEON case there is a post-loop which prevents the store to be removed. + /// CHECK: VecStore + // + /// CHECK-FI: + // + /// CHECK: VecAdd + /// CHECK: VecStore + /// CHECK: Add + /// CHECK: Goto loop:{{B\d+}} + // + /// CHECK-NOT: VecStore static double[] $noinline$test04(int n) { double a[] = new double[n]; double b[] = new double[n]; @@ -178,18 +186,26 @@ public class Main { // Check LSE eliminates VecLoad. // /// CHECK-START-ARM64: double[] Main.$noinline$test05(int) load_store_elimination (before) - /// CHECK: VecStore - /// CHECK-NEXT: VecLoad - /// CHECK-NEXT: VecStore - /// CHECK-NEXT: VecStore - /// CHECK-NEXT: Add - /// CHECK-NEXT: Goto loop:{{B\d+}} + /// CHECK: VecStore + /// CHECK: VecLoad + /// CHECK: VecStore + /// CHECK: VecStore + /// CHECK: Add + /// CHECK: Goto loop:{{B\d+}} /// CHECK-START-ARM64: double[] Main.$noinline$test05(int) load_store_elimination (after) - /// CHECK: VecStore - /// CHECK-NEXT: VecStore - /// CHECK-NEXT: Add - /// CHECK-NEXT: Goto loop:{{B\d+}} + /// CHECK-IF: not hasIsaFeature("sve") + // + // In NEON case there is a post-loop which prevents the store to be removed. + /// CHECK: VecStore + // + /// CHECK-FI: + // + /// CHECK: VecStore + /// CHECK: Add + /// CHECK: Goto loop:{{B\d+}} + // + /// CHECK-NOT: VecStore static double[] $noinline$test05(int n) { double a[] = new double[n]; double b[] = new double[n]; @@ -212,28 +228,30 @@ public class Main { // Check LSE eliminates VecLoad and ArrayGet in case of singletons and default values. // /// CHECK-START-ARM64: double[] Main.$noinline$test06(int) load_store_elimination (before) - /// CHECK: BoundsCheck loop:none - /// CHECK-NEXT: ArrayGet - /// CHECK-NEXT: Add - /// CHECK-NEXT: ArrayLength + /// CHECK: BoundsCheck loop:none + /// CHECK: ArrayGet + /// CHECK: Add + /// CHECK: ArrayLength // - /// CHECK: VecLoad loop:{{B\d+}} - /// CHECK-NEXT: VecStore - /// CHECK-NEXT: VecLoad - /// CHECK-NEXT: VecLoad - /// CHECK-NEXT: VecAdd - /// CHECK-NEXT: VecAdd - /// CHECK-NEXT: VecStore + /// CHECK: VecLoad loop:{{B\d+}} + /// CHECK: VecStore + /// CHECK: VecLoad + /// CHECK: VecLoad + /// CHECK: VecAdd + /// CHECK: VecAdd + /// CHECK: VecStore /// CHECK-START-ARM64: double[] Main.$noinline$test06(int) load_store_elimination (after) - /// CHECK: BoundsCheck loop:none - /// CHECK-NEXT: Add - /// CHECK-NEXT: ArrayLength + /// CHECK: BoundsCheck loop:none + /// CHECK: Add + /// CHECK: ArrayLength + // + /// CHECK: VecLoad loop:{{B\d+}} + /// CHECK: VecAdd + /// CHECK: VecAdd + /// CHECK: VecStore // - /// CHECK: VecLoad loop:{{B\d+}} - /// CHECK-NEXT: VecAdd - /// CHECK-NEXT: VecAdd - /// CHECK-NEXT: VecStore + /// CHECK-NOT: VecStore static double[] $noinline$test06(int n) { double a[] = new double[n]; double b[] = new double[n]; diff --git a/test/530-checker-lse/src/Main.java b/test/530-checker-lse/src/Main.java index a30378271c..23e1d53e98 100644 --- a/test/530-checker-lse/src/Main.java +++ b/test/530-checker-lse/src/Main.java @@ -2720,14 +2720,33 @@ public class Main { /// CHECK-START: int Main.testLoop15(int) load_store_elimination (before) /// CHECK-DAG: NewArray - /// CHECK-DAG: ArraySet + /// CHECK-IF: hasIsaFeature("sve") + // + /// CHECK-DAG: VecPredWhile + /// CHECK-DAG: VecStore + // + /// CHECK-ELSE: + // + /// CHECK-DAG: ArraySet + // + /// CHECK-FI: + // /// CHECK-DAG: ArrayGet /// CHECK-START: int Main.testLoop15(int) load_store_elimination (after) /// CHECK-DAG: NewArray - /// CHECK-DAG: ArraySet + /// CHECK-IF: hasIsaFeature("sve") + // + /// CHECK-DAG: VecPredWhile + /// CHECK-DAG: VecStore + // + /// CHECK-ELSE: + // + /// CHECK-DAG: ArraySet + // + /// CHECK-FI: + // /// CHECK-DAG: ArrayGet - // Test that aliasing array store in the loop is not eliminated // when a loop Phi placeholder is marked for keeping. private static int testLoop15(int n) { diff --git a/test/623-checker-loop-regressions/src/Main.java b/test/623-checker-loop-regressions/src/Main.java index 62f8d5cd97..3f3a12c439 100644 --- a/test/623-checker-loop-regressions/src/Main.java +++ b/test/623-checker-loop-regressions/src/Main.java @@ -290,8 +290,17 @@ public class Main { /// CHECK-NOT: VecLoad // /// CHECK-START-ARM64: void Main.string2Bytes(char[], java.lang.String) loop_optimization (after) - /// CHECK-DAG: VecLoad loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: VecStore loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + // TODO: Support CharAt for SVE. + /// CHECK-NOT: VecLoad + // + /// CHECK-ELSE: + // + /// CHECK-DAG: VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: VecStore loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: // // NOTE: should correctly deal with compressed and uncompressed cases. private static void string2Bytes(char[] a, String b) { @@ -305,8 +314,17 @@ public class Main { /// CHECK-NOT: VecLoad /// CHECK-START-ARM64: void Main.$noinline$stringToShorts(short[], java.lang.String) loop_optimization (after) - /// CHECK-DAG: VecLoad loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: VecStore loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + // TODO: Support CharAt for SVE. + /// CHECK-NOT: VecLoad + // + /// CHECK-ELSE: + // + /// CHECK-DAG: VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: VecStore loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static void $noinline$stringToShorts(short[] dest, String src) { int min = Math.min(dest.length, src.length()); for (int i = 0; i < min; ++i) { @@ -350,9 +368,20 @@ public class Main { // /// CHECK-START-ARM64: void Main.oneBoth(short[], char[]) loop_optimization (after) /// CHECK-DAG: <<One:i\d+>> IntConstant 1 loop:none - /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<One>>] loop:none - /// CHECK-DAG: VecStore [{{l\d+}},<<Phi:i\d+>>,<<Repl>>] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: VecStore [{{l\d+}},<<Phi>>,<<Repl>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<One>>,{{j\d+}}] loop:none + /// CHECK-DAG: <<LoopP:j\d+>> VecPredWhile loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},<<Phi:i\d+>>,<<Repl>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},<<Phi>>,<<Repl>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<One>>] loop:none + /// CHECK-DAG: VecStore [{{l\d+}},<<Phi:i\d+>>,<<Repl>>] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},<<Phi>>,<<Repl>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: // // Bug b/37764324: integral same-length packed types can be mixed freely. private static void oneBoth(short[] a, char[] b) { @@ -382,6 +411,7 @@ public class Main { // /// CHECK-START-ARM: void Main.typeConv(byte[], byte[]) loop_optimization (after) /// CHECK-DAG: <<One:i\d+>> IntConstant 1 loop:none + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<One>>] loop:none /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<Phi1:i\d+>>] loop:<<Loop1:B\d+>> outer_loop:none /// CHECK-DAG: <<Vadd:d\d+>> VecAdd [<<Load>>,<<Repl>>] loop:<<Loop1>> outer_loop:none @@ -393,14 +423,26 @@ public class Main { // /// CHECK-START-ARM64: void Main.typeConv(byte[], byte[]) loop_optimization (after) /// CHECK-DAG: <<One:i\d+>> IntConstant 1 loop:none - /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<One>>] loop:none - /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<Phi1:i\d+>>] loop:<<Loop1:B\d+>> outer_loop:none - /// CHECK-DAG: <<Vadd:d\d+>> VecAdd [<<Load>>,<<Repl>>] loop:<<Loop1>> outer_loop:none - /// CHECK-DAG: VecStore [{{l\d+}},<<Phi1>>,<<Vadd>>] loop:<<Loop1>> outer_loop:none - /// CHECK-DAG: <<Get:b\d+>> ArrayGet [{{l\d+}},<<Phi2:i\d+>>] loop:<<Loop2:B\d+>> outer_loop:none - /// CHECK-DAG: <<Add:i\d+>> Add [<<Get>>,<<One>>] loop:<<Loop2>> outer_loop:none - /// CHECK-DAG: <<Cnv:b\d+>> TypeConversion [<<Add>>] loop:<<Loop2>> outer_loop:none - /// CHECK-DAG: ArraySet [{{l\d+}},<<Phi2>>,<<Cnv>>] loop:<<Loop2>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<One>>,{{j\d+}}] loop:none + /// CHECK-DAG: <<LoopP:j\d+>> VecPredWhile loop:<<Loop1:B\d+>> outer_loop:none + /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<Phi1:i\d+>>,<<LoopP>>] loop:<<Loop1>> outer_loop:none + /// CHECK-DAG: <<Vadd:d\d+>> VecAdd [<<Load>>,<<Repl>>,<<LoopP>>] loop:<<Loop1>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},<<Phi1>>,<<Vadd>>,<<LoopP>>] loop:<<Loop1>> outer_loop:none + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<One>>] loop:none + /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<Phi1:i\d+>>] loop:<<Loop1:B\d+>> outer_loop:none + /// CHECK-DAG: <<Vadd:d\d+>> VecAdd [<<Load>>,<<Repl>>] loop:<<Loop1>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},<<Phi1>>,<<Vadd>>] loop:<<Loop1>> outer_loop:none + /// CHECK-DAG: <<Get:b\d+>> ArrayGet [{{l\d+}},<<Phi2:i\d+>>] loop:<<Loop2:B\d+>> outer_loop:none + /// CHECK-DAG: <<Add:i\d+>> Add [<<Get>>,<<One>>] loop:<<Loop2>> outer_loop:none + /// CHECK-DAG: <<Cnv:b\d+>> TypeConversion [<<Add>>] loop:<<Loop2>> outer_loop:none + /// CHECK-DAG: ArraySet [{{l\d+}},<<Phi2>>,<<Cnv>>] loop:<<Loop2>> outer_loop:none + // + /// CHECK-FI: // // Scalar code in cleanup loop uses correct byte type on array get and type conversion. private static void typeConv(byte[] a, byte[] b) { @@ -718,9 +760,22 @@ public class Main { // Idioms common sub-expression bug: SAD and ArraySet. // - /// CHECK-START-{ARM,ARM64}: int Main.testSADAndSet(int[], int[], int[]) loop_optimization (after) + /// CHECK-START-ARM: int Main.testSADAndSet(int[], int[], int[]) loop_optimization (after) /// CHECK-DAG: VecSADAccumulate /// CHECK-DAG: VecStore + // + /// CHECK-START-ARM64: int Main.testSADAndSet(int[], int[], int[]) loop_optimization (after) + /// CHECK-IF: hasIsaFeature("sve") + // + // VecSADAccumulate is not supported for SVE. + /// CHECK-NOT: VecSADAccumulate + // + /// CHECK-ELSE: + // + /// CHECK-DAG: VecSADAccumulate + /// CHECK-DAG: VecStore + // + /// CHECK-FI: public static int testSADAndSet(int[] x, int[] y, int[] z) { int min_length = Math.min(x.length, y.length); int sad = 0; @@ -733,9 +788,22 @@ public class Main { } // Idioms common sub-expression bug: SAD and SAD. - /// CHECK-START-{ARM,ARM64}: int Main.testSADAndSAD(int[], int[]) loop_optimization (after) + /// CHECK-START-ARM: int Main.testSADAndSAD(int[], int[]) loop_optimization (after) /// CHECK-DAG: VecSADAccumulate /// CHECK-DAG: VecSADAccumulate + // + /// CHECK-START-ARM64: int Main.testSADAndSAD(int[], int[]) loop_optimization (after) + /// CHECK-IF: hasIsaFeature("sve") + // + // VecSADAccumulate is not supported for SVE. + /// CHECK-NOT: VecSADAccumulate + // + /// CHECK-ELSE: + // + /// CHECK-DAG: VecSADAccumulate + /// CHECK-DAG: VecSADAccumulate + // + /// CHECK-FI: public static final int testSADAndSAD(int[] x, int[] y) { int s0 = 1; int s1 = 1; @@ -785,11 +853,26 @@ public class Main { // Idioms common sub-expression bug: SAD and SAD with extra abs. // - /// CHECK-START-{ARM,ARM64}: int Main.testSADAndSADExtraAbs0(int[], int[]) loop_optimization (after) + /// CHECK-START-ARM: int Main.testSADAndSADExtraAbs0(int[], int[]) loop_optimization (after) /// CHECK-DAG: VecSub /// CHECK-DAG: VecAbs /// CHECK-DAG: VecSADAccumulate /// CHECK-DAG: VecSADAccumulate + // + /// CHECK-START-ARM64: int Main.testSADAndSADExtraAbs0(int[], int[]) loop_optimization (after) + /// CHECK-IF: hasIsaFeature("sve") + // + // VecSADAccumulate is not supported for SVE. + /// CHECK-NOT: VecSADAccumulate + // + /// CHECK-ELSE: + // + /// CHECK-DAG: VecSub + /// CHECK-DAG: VecAbs + /// CHECK-DAG: VecSADAccumulate + /// CHECK-DAG: VecSADAccumulate + // + /// CHECK-FI: public static final int testSADAndSADExtraAbs0(int[] x, int[] y) { int s0 = 1; int s1 = 1; @@ -804,11 +887,26 @@ public class Main { // Idioms common sub-expression bug: SAD and SAD with extra abs (reversed order). // - /// CHECK-START-{ARM,ARM64}: int Main.testSADAndSADExtraAbs1(int[], int[]) loop_optimization (after) + /// CHECK-START-ARM: int Main.testSADAndSADExtraAbs1(int[], int[]) loop_optimization (after) /// CHECK-DAG: VecSub /// CHECK-DAG: VecAbs /// CHECK-DAG: VecSADAccumulate /// CHECK-DAG: VecSADAccumulate + // + /// CHECK-START-ARM64: int Main.testSADAndSADExtraAbs1(int[], int[]) loop_optimization (after) + /// CHECK-IF: hasIsaFeature("sve") + // + // VecSADAccumulate is not supported for SVE. + /// CHECK-NOT: VecSADAccumulate + // + /// CHECK-ELSE: + // + /// CHECK-DAG: VecSub + /// CHECK-DAG: VecAbs + /// CHECK-DAG: VecSADAccumulate + /// CHECK-DAG: VecSADAccumulate + // + /// CHECK-FI: public static final int testSADAndSADExtraAbs1(int[] x, int[] y) { int s0 = 1; int s1 = 1; @@ -825,9 +923,18 @@ public class Main { // Idioms common sub-expression bug: SAD and DotProd combined. // /// CHECK-START-ARM64: int Main.testSADAndDotProdCombined0(byte[], byte[]) loop_optimization (after) - /// CHECK-DAG: VecSub - /// CHECK-DAG: VecSADAccumulate - /// CHECK-DAG: VecDotProd + /// CHECK-IF: hasIsaFeature("sve") + // + // VecSADAccumulate is not supported for SVE. + /// CHECK-NOT: VecSADAccumulate + // + /// CHECK-ELSE: + // + /// CHECK-DAG: VecSub + /// CHECK-DAG: VecSADAccumulate + /// CHECK-DAG: VecDotProd + // + /// CHECK-FI: public static final int testSADAndDotProdCombined0(byte[] x, byte[] y) { int s0 = 1; int s1 = 1; @@ -844,9 +951,18 @@ public class Main { // Idioms common sub-expression bug: SAD and DotProd combined (reversed order). /// CHECK-START-ARM64: int Main.testSADAndDotProdCombined1(byte[], byte[]) loop_optimization (after) - /// CHECK-DAG: VecSub - /// CHECK-DAG: VecSADAccumulate - /// CHECK-DAG: VecDotProd + /// CHECK-IF: hasIsaFeature("sve") + // + // VecSADAccumulate is not supported for SVE. + /// CHECK-NOT: VecSADAccumulate + // + /// CHECK-ELSE: + // + /// CHECK-DAG: VecSub + /// CHECK-DAG: VecSADAccumulate + /// CHECK-DAG: VecDotProd + // + /// CHECK-FI: public static final int testSADAndDotProdCombined1(byte[] x, byte[] y) { int s0 = 1; int s1 = 1; diff --git a/test/640-checker-simd/src/SimdInt.java b/test/640-checker-simd/src/SimdInt.java index 77a3a1c798..065fc49c40 100644 --- a/test/640-checker-simd/src/SimdInt.java +++ b/test/640-checker-simd/src/SimdInt.java @@ -163,8 +163,17 @@ public class SimdInt { /// CHECK-DAG: ArraySet [{{l\d+}},{{i\d+}},<<Get>>] loop:<<Loop>> outer_loop:none // /// CHECK-START-{ARM,ARM64}: void SimdInt.shr32() loop_optimization (after) - /// CHECK-DAG: <<Get:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<Get>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + /// CHECK-DAG: <<Get:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<Get>>,{{j\d+}}] loop:<<Loop>> outer_loop:none + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Get:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<Get>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: static void shr32() { // TODO: remove a[i] = a[i] altogether? for (int i = 0; i < 128; i++) @@ -185,9 +194,19 @@ public class SimdInt { // /// CHECK-START-{ARM,ARM64}: void SimdInt.shr33() loop_optimization (after) /// CHECK-DAG: <<Dist:i\d+>> IntConstant 1 loop:none - /// CHECK-DAG: <<Get:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<UShr:d\d+>> VecUShr [<<Get>>,<<Dist>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<UShr>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + /// CHECK-DAG: <<Get:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<UShr:d\d+>> VecUShr [<<Get>>,<<Dist>>,{{j\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<UShr>>,{{j\d+}}] loop:<<Loop>> outer_loop:none + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Get:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<UShr:d\d+>> VecUShr [<<Get>>,<<Dist>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<UShr>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: static void shr33() { for (int i = 0; i < 128; i++) a[i] >>>= $opt$inline$IntConstant33(); // 1, since & 31 @@ -207,9 +226,19 @@ public class SimdInt { // /// CHECK-START-{ARM,ARM64}: void SimdInt.shrMinus254() loop_optimization (after) /// CHECK-DAG: <<Dist:i\d+>> IntConstant 2 loop:none - /// CHECK-DAG: <<Get:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<UShr:d\d+>> VecUShr [<<Get>>,<<Dist>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<UShr>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + /// CHECK-DAG: <<Get:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<UShr:d\d+>> VecUShr [<<Get>>,<<Dist>>,{{j\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<UShr>>,{{j\d+}}] loop:<<Loop>> outer_loop:none + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Get:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<UShr:d\d+>> VecUShr [<<Get>>,<<Dist>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<UShr>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: static void shrMinus254() { for (int i = 0; i < 128; i++) a[i] >>>= $opt$inline$IntConstantMinus254(); // 2, since & 31 diff --git a/test/640-checker-simd/src/SimdLong.java b/test/640-checker-simd/src/SimdLong.java index ea7112f9c9..13ea9afa48 100644 --- a/test/640-checker-simd/src/SimdLong.java +++ b/test/640-checker-simd/src/SimdLong.java @@ -58,7 +58,17 @@ public class SimdLong { // Not directly supported for longs. // /// CHECK-START-ARM64: void SimdLong.mul(long) loop_optimization (after) - /// CHECK-NOT: VecMul + /// CHECK-IF: hasIsaFeature("sve") + // + /// CHECK-DAG: VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: VecMul loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore loop:<<Loop>> outer_loop:none + // + /// CHECK-ELSE: + // + /// CHECK-NOT: VecMul + // + /// CHECK-FI: static void mul(long x) { for (int i = 0; i < 128; i++) a[i] *= x; @@ -163,8 +173,17 @@ public class SimdLong { /// CHECK-DAG: ArraySet [{{l\d+}},{{i\d+}},<<Get>>] loop:<<Loop>> outer_loop:none // /// CHECK-START-ARM64: void SimdLong.shr64() loop_optimization (after) - /// CHECK-DAG: <<Get:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<Get>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + /// CHECK-DAG: <<Get:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<Get>>,{{j\d+}}] loop:<<Loop>> outer_loop:none + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Get:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<Get>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: static void shr64() { // TODO: remove a[i] = a[i] altogether? for (int i = 0; i < 128; i++) @@ -185,9 +204,19 @@ public class SimdLong { // /// CHECK-START-ARM64: void SimdLong.shr65() loop_optimization (after) /// CHECK-DAG: <<Dist:i\d+>> IntConstant 1 loop:none - /// CHECK-DAG: <<Get:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<UShr:d\d+>> VecUShr [<<Get>>,<<Dist>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<UShr>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + /// CHECK-DAG: <<Get:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<UShr:d\d+>> VecUShr [<<Get>>,<<Dist>>,{{j\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<UShr>>,{{j\d+}}] loop:<<Loop>> outer_loop:none + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Get:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<UShr:d\d+>> VecUShr [<<Get>>,<<Dist>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<UShr>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: static void shr65() { for (int i = 0; i < 128; i++) a[i] >>>= $opt$inline$IntConstant65(); // 1, since & 63 @@ -207,9 +236,19 @@ public class SimdLong { // /// CHECK-START-ARM64: void SimdLong.shrMinus254() loop_optimization (after) /// CHECK-DAG: <<Dist:i\d+>> IntConstant 2 loop:none - /// CHECK-DAG: <<Get:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<UShr:d\d+>> VecUShr [<<Get>>,<<Dist>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<UShr>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + /// CHECK-DAG: <<Get:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<UShr:d\d+>> VecUShr [<<Get>>,<<Dist>>,{{j\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<UShr>>,{{j\d+}}] loop:<<Loop>> outer_loop:none + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Get:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<UShr:d\d+>> VecUShr [<<Get>>,<<Dist>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<UShr>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: static void shrMinus254() { for (int i = 0; i < 128; i++) a[i] >>>= $opt$inline$IntConstantMinus254(); // 2, since & 63 diff --git a/test/645-checker-abs-simd/src/Main.java b/test/645-checker-abs-simd/src/Main.java index 828b656227..b1a1b8145a 100644 --- a/test/645-checker-abs-simd/src/Main.java +++ b/test/645-checker-abs-simd/src/Main.java @@ -31,7 +31,7 @@ public class Main { /// CHECK-DAG: Abs loop:<<Loop>> outer_loop:none /// CHECK-DAG: ArraySet loop:<<Loop>> outer_loop:none // - /// CHECK-START-{ARM,ARM64}: void Main.doitByte(byte[]) loop_optimization (after) + /// CHECK-START-ARM: void Main.doitByte(byte[]) loop_optimization (after) /// CHECK-DAG: VecLoad loop:<<Loop1:B\d+>> outer_loop:none /// CHECK-DAG: VecAbs loop:<<Loop1>> outer_loop:none /// CHECK-DAG: VecStore loop:<<Loop1>> outer_loop:none @@ -41,6 +41,27 @@ public class Main { // /// CHECK-EVAL: "<<Loop1>>" != "<<Loop2>>" // + /// CHECK-START-ARM64: void Main.doitByte(byte[]) loop_optimization (after) + /// CHECK-DAG: VecLoad loop:<<Loop1:B\d+>> outer_loop:none + /// CHECK-DAG: VecAbs loop:<<Loop1>> outer_loop:none + /// CHECK-DAG: VecStore loop:<<Loop1>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + /// CHECK-DAG: VecPredWhile loop:<<Loop1>> outer_loop:none + /// CHECK-NOT: ArrayGet + /// CHECK-NOT: Abs + /// CHECK-NOT: ArraySet + // + /// CHECK-ELSE: + // + /// CHECK-DAG: ArrayGet loop:<<Loop2:B\d+>> outer_loop:none + /// CHECK-DAG: Abs loop:<<Loop2>> outer_loop:none + /// CHECK-DAG: ArraySet loop:<<Loop2>> outer_loop:none + // + /// CHECK-EVAL: "<<Loop1>>" != "<<Loop2>>" + // + /// CHECK-FI: + // private static void doitByte(byte[] x) { for (int i = 0; i < x.length; i++) { x[i] = (byte) Math.abs(x[i]); @@ -65,7 +86,7 @@ public class Main { /// CHECK-DAG: Abs loop:<<Loop>> outer_loop:none /// CHECK-DAG: ArraySet loop:<<Loop>> outer_loop:none // - /// CHECK-START-{ARM,ARM64}: void Main.doitShort(short[]) loop_optimization (after) + /// CHECK-START-ARM: void Main.doitShort(short[]) loop_optimization (after) /// CHECK-DAG: VecLoad loop:<<Loop1:B\d+>> outer_loop:none /// CHECK-DAG: VecAbs loop:<<Loop1>> outer_loop:none /// CHECK-DAG: VecStore loop:<<Loop1>> outer_loop:none @@ -75,6 +96,26 @@ public class Main { // /// CHECK-EVAL: "<<Loop1>>" != "<<Loop2>>" // + /// CHECK-START-ARM64: void Main.doitShort(short[]) loop_optimization (after) + /// CHECK-DAG: VecLoad loop:<<Loop1:B\d+>> outer_loop:none + /// CHECK-DAG: VecAbs loop:<<Loop1>> outer_loop:none + /// CHECK-DAG: VecStore loop:<<Loop1>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + /// CHECK-DAG: VecPredWhile loop:<<Loop1>> outer_loop:none + /// CHECK-NOT: ArrayGet + /// CHECK-NOT: Abs + /// CHECK-NOT: ArraySet + // + /// CHECK-ELSE: + // + /// CHECK-DAG: ArrayGet loop:<<Loop2:B\d+>> outer_loop:none + /// CHECK-DAG: Abs loop:<<Loop2>> outer_loop:none + /// CHECK-DAG: ArraySet loop:<<Loop2>> outer_loop:none + // + /// CHECK-EVAL: "<<Loop1>>" != "<<Loop2>>" + // + /// CHECK-FI: private static void doitShort(short[] x) { for (int i = 0; i < x.length; i++) { x[i] = (short) Math.abs(x[i]); @@ -91,12 +132,22 @@ public class Main { /// CHECK-DAG: VecLoad loop:<<Loop1:B\d+>> outer_loop:none /// CHECK-DAG: VecAbs loop:<<Loop1>> outer_loop:none /// CHECK-DAG: VecStore loop:<<Loop1>> outer_loop:none - /// CHECK-DAG: ArrayGet loop:<<Loop2:B\d+>> outer_loop:none - /// CHECK-DAG: Abs loop:<<Loop2>> outer_loop:none - /// CHECK-DAG: ArraySet loop:<<Loop2>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") // - /// CHECK-EVAL: "<<Loop1>>" != "<<Loop2>>" + /// CHECK-DAG: VecPredWhile loop:<<Loop1>> outer_loop:none + /// CHECK-NOT: ArrayGet + /// CHECK-NOT: Abs + /// CHECK-NOT: ArraySet + // + /// CHECK-ELSE: // + /// CHECK-DAG: ArrayGet loop:<<Loop2:B\d+>> outer_loop:none + /// CHECK-DAG: Abs loop:<<Loop2>> outer_loop:none + /// CHECK-DAG: ArraySet loop:<<Loop2>> outer_loop:none + // + /// CHECK-EVAL: "<<Loop1>>" != "<<Loop2>>" + // + /// CHECK-FI: private static void doitCastedChar(char[] x) { for (int i = 0; i < x.length; i++) { x[i] = (char) Math.abs((short) x[i]); @@ -109,7 +160,7 @@ public class Main { /// CHECK-DAG: Abs loop:<<Loop>> outer_loop:none /// CHECK-DAG: ArraySet loop:<<Loop>> outer_loop:none // - /// CHECK-START-{ARM,ARM64}: void Main.doitInt(int[]) loop_optimization (after) + /// CHECK-START-ARM: void Main.doitInt(int[]) loop_optimization (after) /// CHECK-DAG: VecLoad loop:<<Loop1:B\d+>> outer_loop:none /// CHECK-DAG: VecAbs loop:<<Loop1>> outer_loop:none /// CHECK-DAG: VecStore loop:<<Loop1>> outer_loop:none @@ -119,6 +170,26 @@ public class Main { // /// CHECK-EVAL: "<<Loop1>>" != "<<Loop2>>" // + /// CHECK-START-ARM64: void Main.doitInt(int[]) loop_optimization (after) + /// CHECK-DAG: VecLoad loop:<<Loop1:B\d+>> outer_loop:none + /// CHECK-DAG: VecAbs loop:<<Loop1>> outer_loop:none + /// CHECK-DAG: VecStore loop:<<Loop1>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + /// CHECK-DAG: VecPredWhile loop:<<Loop1>> outer_loop:none + /// CHECK-NOT: ArrayGet + /// CHECK-NOT: Abs + /// CHECK-NOT: ArraySet + // + /// CHECK-ELSE: + // + /// CHECK-DAG: ArrayGet loop:<<Loop2:B\d+>> outer_loop:none + /// CHECK-DAG: Abs loop:<<Loop2>> outer_loop:none + /// CHECK-DAG: ArraySet loop:<<Loop2>> outer_loop:none + // + /// CHECK-EVAL: "<<Loop1>>" != "<<Loop2>>" + // + /// CHECK-FI: private static void doitInt(int[] x) { for (int i = 0; i < x.length; i++) { x[i] = Math.abs(x[i]); @@ -135,12 +206,22 @@ public class Main { /// CHECK-DAG: VecLoad loop:<<Loop1:B\d+>> outer_loop:none /// CHECK-DAG: VecAbs loop:<<Loop1>> outer_loop:none /// CHECK-DAG: VecStore loop:<<Loop1>> outer_loop:none - /// CHECK-DAG: ArrayGet loop:<<Loop2:B\d+>> outer_loop:none - /// CHECK-DAG: Abs loop:<<Loop2>> outer_loop:none - /// CHECK-DAG: ArraySet loop:<<Loop2>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") // - /// CHECK-EVAL: "<<Loop1>>" != "<<Loop2>>" + /// CHECK-DAG: VecPredWhile loop:<<Loop1>> outer_loop:none + /// CHECK-NOT: ArrayGet + /// CHECK-NOT: Abs + /// CHECK-NOT: ArraySet + // + /// CHECK-ELSE: + // + /// CHECK-DAG: ArrayGet loop:<<Loop2:B\d+>> outer_loop:none + /// CHECK-DAG: Abs loop:<<Loop2>> outer_loop:none + /// CHECK-DAG: ArraySet loop:<<Loop2>> outer_loop:none // + /// CHECK-EVAL: "<<Loop1>>" != "<<Loop2>>" + // + /// CHECK-FI: private static void doitLong(long[] x) { for (int i = 0; i < x.length; i++) { x[i] = Math.abs(x[i]); @@ -157,12 +238,22 @@ public class Main { /// CHECK-DAG: VecLoad loop:<<Loop1:B\d+>> outer_loop:none /// CHECK-DAG: VecAbs loop:<<Loop1>> outer_loop:none /// CHECK-DAG: VecStore loop:<<Loop1>> outer_loop:none - /// CHECK-DAG: ArrayGet loop:<<Loop2:B\d+>> outer_loop:none - /// CHECK-DAG: Abs loop:<<Loop2>> outer_loop:none - /// CHECK-DAG: ArraySet loop:<<Loop2>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") // - /// CHECK-EVAL: "<<Loop1>>" != "<<Loop2>>" + /// CHECK-DAG: VecPredWhile loop:<<Loop1>> outer_loop:none + /// CHECK-NOT: ArrayGet + /// CHECK-NOT: Abs + /// CHECK-NOT: ArraySet + // + /// CHECK-ELSE: // + /// CHECK-DAG: ArrayGet loop:<<Loop2:B\d+>> outer_loop:none + /// CHECK-DAG: Abs loop:<<Loop2>> outer_loop:none + /// CHECK-DAG: ArraySet loop:<<Loop2>> outer_loop:none + // + /// CHECK-EVAL: "<<Loop1>>" != "<<Loop2>>" + // + /// CHECK-FI: private static void doitFloat(float[] x) { for (int i = 0; i < x.length; i++) { x[i] = Math.abs(x[i]); @@ -179,12 +270,22 @@ public class Main { /// CHECK-DAG: VecLoad loop:<<Loop1:B\d+>> outer_loop:none /// CHECK-DAG: VecAbs loop:<<Loop1>> outer_loop:none /// CHECK-DAG: VecStore loop:<<Loop1>> outer_loop:none - /// CHECK-DAG: ArrayGet loop:<<Loop2:B\d+>> outer_loop:none - /// CHECK-DAG: Abs loop:<<Loop2>> outer_loop:none - /// CHECK-DAG: ArraySet loop:<<Loop2>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") // - /// CHECK-EVAL: "<<Loop1>>" != "<<Loop2>>" + /// CHECK-DAG: VecPredWhile loop:<<Loop1>> outer_loop:none + /// CHECK-NOT: ArrayGet + /// CHECK-NOT: Abs + /// CHECK-NOT: ArraySet + // + /// CHECK-ELSE: + // + /// CHECK-DAG: ArrayGet loop:<<Loop2:B\d+>> outer_loop:none + /// CHECK-DAG: Abs loop:<<Loop2>> outer_loop:none + /// CHECK-DAG: ArraySet loop:<<Loop2>> outer_loop:none + // + /// CHECK-EVAL: "<<Loop1>>" != "<<Loop2>>" // + /// CHECK-FI: private static void doitDouble(double[] x) { for (int i = 0; i < x.length; i++) { x[i] = Math.abs(x[i]); diff --git a/test/646-checker-simd-hadd/src/HaddAltByte.java b/test/646-checker-simd-hadd/src/HaddAltByte.java index 28551eec0c..69d46023ff 100644 --- a/test/646-checker-simd-hadd/src/HaddAltByte.java +++ b/test/646-checker-simd-hadd/src/HaddAltByte.java @@ -39,11 +39,26 @@ public class HaddAltByte { /// CHECK-DAG: <<Cnv:b\d+>> TypeConversion [<<UShr>>] loop:<<Loop>> outer_loop:none /// CHECK-DAG: ArraySet [{{l\d+}},<<Phi>>,<<Cnv>>] loop:<<Loop>> outer_loop:none // - /// CHECK-START-{ARM,ARM64}: void HaddAltByte.halving_add_signed(byte[], byte[], byte[]) loop_optimization (after) + /// CHECK-START-ARM: void HaddAltByte.halving_add_signed(byte[], byte[], byte[]) loop_optimization (after) /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Int8 rounded:false loop:<<Loop>> outer_loop:none /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-START-ARM64: void HaddAltByte.halving_add_signed(byte[], byte[], byte[]) loop_optimization (after) + /// CHECK-IF: hasIsaFeature("sve") + // + // HalvingAdd idiom is not supported for SVE. + /// CHECK-NOT: VecHalvingAdd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Int8 rounded:false loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static void halving_add_signed(byte[] b1, byte[] b2, byte[] bo) { int min_length = Math.min(bo.length, Math.min(b1.length, b2.length)); for (int i = 0; i < min_length; i++) { @@ -74,11 +89,26 @@ public class HaddAltByte { /// CHECK-DAG: <<Cnv:b\d+>> TypeConversion [<<UShr>>] loop:<<Loop>> outer_loop:none /// CHECK-DAG: ArraySet [{{l\d+}},<<Phi>>,<<Cnv>>] loop:<<Loop>> outer_loop:none // - /// CHECK-START-{ARM,ARM64}: void HaddAltByte.halving_add_unsigned(byte[], byte[], byte[]) loop_optimization (after) + /// CHECK-START-ARM: void HaddAltByte.halving_add_unsigned(byte[], byte[], byte[]) loop_optimization (after) /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Uint8 rounded:false loop:<<Loop>> outer_loop:none /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-START-ARM64: void HaddAltByte.halving_add_unsigned(byte[], byte[], byte[]) loop_optimization (after) + /// CHECK-IF: hasIsaFeature("sve") + // + // HalvingAdd idiom is not supported for SVE. + /// CHECK-NOT: VecHalvingAdd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Uint8 rounded:false loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static void halving_add_unsigned(byte[] b1, byte[] b2, byte[] bo) { int min_length = Math.min(bo.length, Math.min(b1.length, b2.length)); for (int i = 0; i < min_length; i++) { @@ -97,11 +127,26 @@ public class HaddAltByte { /// CHECK-DAG: <<Cnv:b\d+>> TypeConversion [<<UShr>>] loop:<<Loop>> outer_loop:none /// CHECK-DAG: ArraySet [{{l\d+}},<<Phi>>,<<Cnv>>] loop:<<Loop>> outer_loop:none // - /// CHECK-START-{ARM,ARM64}: void HaddAltByte.rounding_halving_add_signed(byte[], byte[], byte[]) loop_optimization (after) + /// CHECK-START-ARM: void HaddAltByte.rounding_halving_add_signed(byte[], byte[], byte[]) loop_optimization (after) /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Int8 rounded:true loop:<<Loop>> outer_loop:none /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-START-ARM64: void HaddAltByte.rounding_halving_add_signed(byte[], byte[], byte[]) loop_optimization (after) + /// CHECK-IF: hasIsaFeature("sve") + // + // HalvingAdd idiom is not supported for SVE. + /// CHECK-NOT: VecHalvingAdd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Int8 rounded:true loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static void rounding_halving_add_signed(byte[] b1, byte[] b2, byte[] bo) { int min_length = Math.min(bo.length, Math.min(b1.length, b2.length)); for (int i = 0; i < min_length; i++) { @@ -134,11 +179,26 @@ public class HaddAltByte { /// CHECK-DAG: <<Cnv:b\d+>> TypeConversion [<<UShr>>] loop:<<Loop>> outer_loop:none /// CHECK-DAG: ArraySet [{{l\d+}},<<Phi>>,<<Cnv>>] loop:<<Loop>> outer_loop:none // - /// CHECK-START-{ARM,ARM64}: void HaddAltByte.rounding_halving_add_unsigned(byte[], byte[], byte[]) loop_optimization (after) + /// CHECK-START-ARM: void HaddAltByte.rounding_halving_add_unsigned(byte[], byte[], byte[]) loop_optimization (after) /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Uint8 rounded:true loop:<<Loop>> outer_loop:none /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-START-ARM64: void HaddAltByte.rounding_halving_add_unsigned(byte[], byte[], byte[]) loop_optimization (after) + /// CHECK-IF: hasIsaFeature("sve") + // + // HalvingAdd idiom is not supported for SVE. + /// CHECK-NOT: VecHalvingAdd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Uint8 rounded:true loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static void rounding_halving_add_unsigned(byte[] b1, byte[] b2, byte[] bo) { int min_length = Math.min(bo.length, Math.min(b1.length, b2.length)); for (int i = 0; i < min_length; i++) { @@ -156,12 +216,28 @@ public class HaddAltByte { /// CHECK-DAG: <<Cnv:b\d+>> TypeConversion [<<UShr>>] loop:<<Loop>> outer_loop:none /// CHECK-DAG: ArraySet [{{l\d+}},<<Phi>>,<<Cnv>>] loop:<<Loop>> outer_loop:none // - /// CHECK-START-{ARM,ARM64}: void HaddAltByte.halving_add_signed_constant(byte[], byte[]) loop_optimization (after) + /// CHECK-START-ARM: void HaddAltByte.halving_add_signed_constant(byte[], byte[]) loop_optimization (after) /// CHECK-DAG: <<I127:i\d+>> IntConstant 127 loop:none /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<I127>>] loop:none /// CHECK-DAG: <<Get:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get>>,<<Repl>>] packed_type:Int8 rounded:false loop:<<Loop>> outer_loop:none /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-START-ARM64: void HaddAltByte.halving_add_signed_constant(byte[], byte[]) loop_optimization (after) + /// CHECK-IF: hasIsaFeature("sve") + // + // HalvingAdd idiom is not supported for SVE. + /// CHECK-NOT: VecHalvingAdd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<I127:i\d+>> IntConstant 127 loop:none + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<I127>>] loop:none + /// CHECK-DAG: <<Get:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get>>,<<Repl>>] packed_type:Int8 rounded:false loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static void halving_add_signed_constant(byte[] b1, byte[] bo) { int min_length = Math.min(bo.length, b1.length); for (int i = 0; i < min_length; i++) { @@ -190,12 +266,28 @@ public class HaddAltByte { /// CHECK-DAG: <<Cnv:b\d+>> TypeConversion [<<UShr>>] loop:<<Loop>> outer_loop:none /// CHECK-DAG: ArraySet [{{l\d+}},<<Phi>>,<<Cnv>>] loop:<<Loop>> outer_loop:none // - /// CHECK-START-{ARM,ARM64}: void HaddAltByte.halving_add_unsigned_constant(byte[], byte[]) loop_optimization (after) + /// CHECK-START-ARM: void HaddAltByte.halving_add_unsigned_constant(byte[], byte[]) loop_optimization (after) /// CHECK-DAG: <<I255:i\d+>> IntConstant 255 loop:none /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<I255>>] loop:none /// CHECK-DAG: <<Get:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get>>,<<Repl>>] packed_type:Uint8 rounded:false loop:<<Loop>> outer_loop:none /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-START-ARM64: void HaddAltByte.halving_add_unsigned_constant(byte[], byte[]) loop_optimization (after) + /// CHECK-IF: hasIsaFeature("sve") + // + // HalvingAdd idiom is not supported for SVE. + /// CHECK-NOT: VecHalvingAdd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<I255:i\d+>> IntConstant 255 loop:none + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<I255>>] loop:none + /// CHECK-DAG: <<Get:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get>>,<<Repl>>] packed_type:Uint8 rounded:false loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static void halving_add_unsigned_constant(byte[] b1, byte[] bo) { int min_length = Math.min(bo.length, b1.length); for (int i = 0; i < min_length; i++) { diff --git a/test/646-checker-simd-hadd/src/HaddAltChar.java b/test/646-checker-simd-hadd/src/HaddAltChar.java index 2dd812d44c..f9d40a9d3e 100644 --- a/test/646-checker-simd-hadd/src/HaddAltChar.java +++ b/test/646-checker-simd-hadd/src/HaddAltChar.java @@ -39,11 +39,26 @@ public class HaddAltChar { /// CHECK-DAG: <<Cnv:c\d+>> TypeConversion [<<UShr>>] loop:<<Loop>> outer_loop:none /// CHECK-DAG: ArraySet [{{l\d+}},<<Phi>>,<<Cnv>>] loop:<<Loop>> outer_loop:none // - /// CHECK-START-{ARM,ARM64}: void HaddAltChar.halving_add_unsigned(char[], char[], char[]) loop_optimization (after) + /// CHECK-START-ARM: void HaddAltChar.halving_add_unsigned(char[], char[], char[]) loop_optimization (after) /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Uint16 rounded:false loop:<<Loop>> outer_loop:none /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-START-ARM64: void HaddAltChar.halving_add_unsigned(char[], char[], char[]) loop_optimization (after) + /// CHECK-IF: hasIsaFeature("sve") + // + // HalvingAdd idiom is not supported for SVE. + /// CHECK-NOT: VecHalvingAdd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Uint16 rounded:false loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static void halving_add_unsigned(char[] b1, char[] b2, char[] bo) { int min_length = Math.min(bo.length, Math.min(b1.length, b2.length)); for (int i = 0; i < min_length; i++) { @@ -75,12 +90,27 @@ public class HaddAltChar { /// CHECK-DAG: <<Cnv:c\d+>> TypeConversion [<<UShr>>] loop:<<Loop>> outer_loop:none /// CHECK-DAG: ArraySet [{{l\d+}},<<Phi>>,<<Cnv>>] loop:<<Loop>> outer_loop:none // - /// CHECK-START-{ARM,ARM64}: void HaddAltChar.halving_add_also_unsigned(char[], char[], char[]) loop_optimization (after) + /// CHECK-START-ARM: void HaddAltChar.halving_add_also_unsigned(char[], char[], char[]) loop_optimization (after) /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Uint16 rounded:false loop:<<Loop>> outer_loop:none /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none // + /// CHECK-START-ARM64: void HaddAltChar.halving_add_also_unsigned(char[], char[], char[]) loop_optimization (after) + /// CHECK-IF: hasIsaFeature("sve") + // + // HalvingAdd idiom is not supported for SVE. + /// CHECK-NOT: VecHalvingAdd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Uint16 rounded:false loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: + // // Note: HAnd has no impact (already a zero extension). // private static void halving_add_also_unsigned(char[] b1, char[] b2, char[] bo) { @@ -101,11 +131,26 @@ public class HaddAltChar { /// CHECK-DAG: <<Cnv:c\d+>> TypeConversion [<<UShr>>] loop:<<Loop>> outer_loop:none /// CHECK-DAG: ArraySet [{{l\d+}},<<Phi>>,<<Cnv>>] loop:<<Loop>> outer_loop:none // - /// CHECK-START-{ARM,ARM64}: void HaddAltChar.rounding_halving_add_unsigned(char[], char[], char[]) loop_optimization (after) + /// CHECK-START-ARM: void HaddAltChar.rounding_halving_add_unsigned(char[], char[], char[]) loop_optimization (after) /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Uint16 rounded:true loop:<<Loop>> outer_loop:none /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-START-ARM64: void HaddAltChar.rounding_halving_add_unsigned(char[], char[], char[]) loop_optimization (after) + /// CHECK-IF: hasIsaFeature("sve") + // + // HalvingAdd idiom is not supported for SVE. + /// CHECK-NOT: VecHalvingAdd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Uint16 rounded:true loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static void rounding_halving_add_unsigned(char[] b1, char[] b2, char[] bo) { int min_length = Math.min(bo.length, Math.min(b1.length, b2.length)); for (int i = 0; i < min_length; i++) { @@ -138,12 +183,28 @@ public class HaddAltChar { /// CHECK-DAG: <<Cnv:c\d+>> TypeConversion [<<UShr>>] loop:<<Loop>> outer_loop:none /// CHECK-DAG: ArraySet [{{l\d+}},<<Phi>>,<<Cnv>>] loop:<<Loop>> outer_loop:none // - /// CHECK-START-{ARM,ARM64}: void HaddAltChar.rounding_halving_add_also_unsigned(char[], char[], char[]) loop_optimization (after) + /// CHECK-START-ARM: void HaddAltChar.rounding_halving_add_also_unsigned(char[], char[], char[]) loop_optimization (after) /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Uint16 rounded:true loop:<<Loop>> outer_loop:none /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none // + // + /// CHECK-START-ARM64: void HaddAltChar.rounding_halving_add_also_unsigned(char[], char[], char[]) loop_optimization (after) + /// CHECK-IF: hasIsaFeature("sve") + // + // HalvingAdd idiom is not supported for SVE. + /// CHECK-NOT: VecHalvingAdd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Uint16 rounded:true loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: + // // Note: HAnd has no impact (already a zero extension). // private static void rounding_halving_add_also_unsigned(char[] b1, char[] b2, char[] bo) { @@ -163,12 +224,28 @@ public class HaddAltChar { /// CHECK-DAG: <<Cnv:c\d+>> TypeConversion [<<UShr>>] loop:<<Loop>> outer_loop:none /// CHECK-DAG: ArraySet [{{l\d+}},<<Phi>>,<<Cnv>>] loop:<<Loop>> outer_loop:none // - /// CHECK-START-{ARM,ARM64}: void HaddAltChar.halving_add_unsigned_constant(char[], char[]) loop_optimization (after) + /// CHECK-START-ARM: void HaddAltChar.halving_add_unsigned_constant(char[], char[]) loop_optimization (after) /// CHECK-DAG: <<UMAX:i\d+>> IntConstant 65535 loop:none /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<UMAX>>] loop:none /// CHECK-DAG: <<Get:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get>>,<<Repl>>] packed_type:Uint16 rounded:false loop:<<Loop>> outer_loop:none /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-START-ARM64: void HaddAltChar.halving_add_unsigned_constant(char[], char[]) loop_optimization (after) + /// CHECK-IF: hasIsaFeature("sve") + // + // HalvingAdd idiom is not supported for SVE. + /// CHECK-NOT: VecHalvingAdd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<UMAX:i\d+>> IntConstant 65535 loop:none + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<UMAX>>] loop:none + /// CHECK-DAG: <<Get:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get>>,<<Repl>>] packed_type:Uint16 rounded:false loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static void halving_add_unsigned_constant(char[] b1, char[] bo) { int min_length = Math.min(bo.length, b1.length); for (int i = 0; i < min_length; i++) { @@ -197,13 +274,29 @@ public class HaddAltChar { /// CHECK-DAG: <<Cnv:c\d+>> TypeConversion [<<UShr>>] loop:<<Loop>> outer_loop:none /// CHECK-DAG: ArraySet [{{l\d+}},<<Phi>>,<<Cnv>>] loop:<<Loop>> outer_loop:none // - /// CHECK-START-{ARM,ARM64}: void HaddAltChar.halving_add_also_unsigned_constant(char[], char[]) loop_optimization (after) + /// CHECK-START-ARM: void HaddAltChar.halving_add_also_unsigned_constant(char[], char[]) loop_optimization (after) /// CHECK-DAG: <<UMAX:i\d+>> IntConstant 65535 loop:none /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<UMAX>>] loop:none /// CHECK-DAG: <<Get:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get>>,<<Repl>>] packed_type:Uint16 rounded:false loop:<<Loop>> outer_loop:none /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none // + /// CHECK-START-ARM64: void HaddAltChar.halving_add_also_unsigned_constant(char[], char[]) loop_optimization (after) + /// CHECK-IF: hasIsaFeature("sve") + // + // HalvingAdd idiom is not supported for SVE. + /// CHECK-NOT: VecHalvingAdd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<UMAX:i\d+>> IntConstant 65535 loop:none + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<UMAX>>] loop:none + /// CHECK-DAG: <<Get:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get>>,<<Repl>>] packed_type:Uint16 rounded:false loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: + // // Note: HAnd has no impact (already a zero extension). // private static void halving_add_also_unsigned_constant(char[] b1, char[] bo) { diff --git a/test/646-checker-simd-hadd/src/HaddAltShort.java b/test/646-checker-simd-hadd/src/HaddAltShort.java index d7f4e4014e..3b19a2638e 100644 --- a/test/646-checker-simd-hadd/src/HaddAltShort.java +++ b/test/646-checker-simd-hadd/src/HaddAltShort.java @@ -39,11 +39,26 @@ public class HaddAltShort { /// CHECK-DAG: <<Cnv:s\d+>> TypeConversion [<<UShr>>] loop:<<Loop>> outer_loop:none /// CHECK-DAG: ArraySet [{{l\d+}},<<Phi>>,<<Cnv>>] loop:<<Loop>> outer_loop:none // - /// CHECK-START-{ARM,ARM64}: void HaddAltShort.halving_add_signed(short[], short[], short[]) loop_optimization (after) + /// CHECK-START-ARM: void HaddAltShort.halving_add_signed(short[], short[], short[]) loop_optimization (after) /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Int16 rounded:false loop:<<Loop>> outer_loop:none /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-START-ARM64: void HaddAltShort.halving_add_signed(short[], short[], short[]) loop_optimization (after) + /// CHECK-IF: hasIsaFeature("sve") + // + // HalvingAdd idiom is not supported for SVE. + /// CHECK-NOT: VecHalvingAdd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Int16 rounded:false loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static void halving_add_signed(short[] b1, short[] b2, short[] bo) { int min_length = Math.min(bo.length, Math.min(b1.length, b2.length)); for (int i = 0; i < min_length; i++) { @@ -74,11 +89,26 @@ public class HaddAltShort { /// CHECK-DAG: <<Cnv:s\d+>> TypeConversion [<<UShr>>] loop:<<Loop>> outer_loop:none /// CHECK-DAG: ArraySet [{{l\d+}},<<Phi>>,<<Cnv>>] loop:<<Loop>> outer_loop:none // - /// CHECK-START-{ARM,ARM64}: void HaddAltShort.halving_add_unsigned(short[], short[], short[]) loop_optimization (after) + /// CHECK-START-ARM: void HaddAltShort.halving_add_unsigned(short[], short[], short[]) loop_optimization (after) /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Uint16 rounded:false loop:<<Loop>> outer_loop:none /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-START-ARM64: void HaddAltShort.halving_add_unsigned(short[], short[], short[]) loop_optimization (after) + /// CHECK-IF: hasIsaFeature("sve") + // + // HalvingAdd idiom is not supported for SVE. + /// CHECK-NOT: VecHalvingAdd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Uint16 rounded:false loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static void halving_add_unsigned(short[] b1, short[] b2, short[] bo) { int min_length = Math.min(bo.length, Math.min(b1.length, b2.length)); for (int i = 0; i < min_length; i++) { @@ -99,11 +129,26 @@ public class HaddAltShort { /// CHECK-DAG: <<Cnv:s\d+>> TypeConversion [<<UShr>>] loop:<<Loop>> outer_loop:none /// CHECK-DAG: ArraySet [{{l\d+}},<<Phi>>,<<Cnv>>] loop:<<Loop>> outer_loop:none // - /// CHECK-START-{ARM,ARM64}: void HaddAltShort.rounding_halving_add_signed(short[], short[], short[]) loop_optimization (after) + /// CHECK-START-ARM: void HaddAltShort.rounding_halving_add_signed(short[], short[], short[]) loop_optimization (after) /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Int16 rounded:true loop:<<Loop>> outer_loop:none /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-START-ARM64: void HaddAltShort.rounding_halving_add_signed(short[], short[], short[]) loop_optimization (after) + /// CHECK-IF: hasIsaFeature("sve") + // + // HalvingAdd idiom is not supported for SVE. + /// CHECK-NOT: VecHalvingAdd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Int16 rounded:true loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static void rounding_halving_add_signed(short[] b1, short[] b2, short[] bo) { int min_length = Math.min(bo.length, Math.min(b1.length, b2.length)); for (int i = 0; i < min_length; i++) { @@ -136,11 +181,26 @@ public class HaddAltShort { /// CHECK-DAG: <<Cnv:s\d+>> TypeConversion [<<UShr>>] loop:<<Loop>> outer_loop:none /// CHECK-DAG: ArraySet [{{l\d+}},<<Phi>>,<<Cnv>>] loop:<<Loop>> outer_loop:none // - /// CHECK-START-{ARM,ARM64}: void HaddAltShort.rounding_halving_add_unsigned(short[], short[], short[]) loop_optimization (after) + /// CHECK-START-ARM: void HaddAltShort.rounding_halving_add_unsigned(short[], short[], short[]) loop_optimization (after) /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Uint16 rounded:true loop:<<Loop>> outer_loop:none /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-START-ARM64: void HaddAltShort.rounding_halving_add_unsigned(short[], short[], short[]) loop_optimization (after) + /// CHECK-IF: hasIsaFeature("sve") + // + // HalvingAdd idiom is not supported for SVE. + /// CHECK-NOT: VecHalvingAdd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Uint16 rounded:true loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static void rounding_halving_add_unsigned(short[] b1, short[] b2, short[] bo) { int min_length = Math.min(bo.length, Math.min(b1.length, b2.length)); for (int i = 0; i < min_length; i++) { @@ -160,12 +220,28 @@ public class HaddAltShort { /// CHECK-DAG: <<Cnv:s\d+>> TypeConversion [<<UShr>>] loop:<<Loop>> outer_loop:none /// CHECK-DAG: ArraySet [{{l\d+}},<<Phi>>,<<Cnv>>] loop:<<Loop>> outer_loop:none // - /// CHECK-START-{ARM,ARM64}: void HaddAltShort.halving_add_signed_constant(short[], short[]) loop_optimization (after) + /// CHECK-START-ARM: void HaddAltShort.halving_add_signed_constant(short[], short[]) loop_optimization (after) /// CHECK-DAG: <<SMAX:i\d+>> IntConstant 32767 loop:none /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<SMAX>>] loop:none /// CHECK-DAG: <<Get:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get>>,<<Repl>>] packed_type:Int16 rounded:false loop:<<Loop>> outer_loop:none /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-START-ARM64: void HaddAltShort.halving_add_signed_constant(short[], short[]) loop_optimization (after) + /// CHECK-IF: hasIsaFeature("sve") + // + // HalvingAdd idiom is not supported for SVE. + /// CHECK-NOT: VecHalvingAdd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<SMAX:i\d+>> IntConstant 32767 loop:none + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<SMAX>>] loop:none + /// CHECK-DAG: <<Get:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get>>,<<Repl>>] packed_type:Int16 rounded:false loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static void halving_add_signed_constant(short[] b1, short[] bo) { int min_length = Math.min(bo.length, b1.length); for (int i = 0; i < min_length; i++) { @@ -194,12 +270,28 @@ public class HaddAltShort { /// CHECK-DAG: <<Cnv:s\d+>> TypeConversion [<<UShr>>] loop:<<Loop>> outer_loop:none /// CHECK-DAG: ArraySet [{{l\d+}},<<Phi>>,<<Cnv>>] loop:<<Loop>> outer_loop:none // - /// CHECK-START-{ARM,ARM64}: void HaddAltShort.halving_add_unsigned_constant(short[], short[]) loop_optimization (after) + /// CHECK-START-ARM: void HaddAltShort.halving_add_unsigned_constant(short[], short[]) loop_optimization (after) /// CHECK-DAG: <<UMAX:i\d+>> IntConstant 65535 loop:none /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<UMAX>>] loop:none /// CHECK-DAG: <<Get:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get>>,<<Repl>>] packed_type:Uint16 rounded:false loop:<<Loop>> outer_loop:none /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-START-ARM64: void HaddAltShort.halving_add_unsigned_constant(short[], short[]) loop_optimization (after) + /// CHECK-IF: hasIsaFeature("sve") + // + // HalvingAdd idiom is not supported for SVE. + /// CHECK-NOT: VecHalvingAdd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<UMAX:i\d+>> IntConstant 65535 loop:none + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<UMAX>>] loop:none + /// CHECK-DAG: <<Get:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get>>,<<Repl>>] packed_type:Uint16 rounded:false loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static void halving_add_unsigned_constant(short[] b1, short[] bo) { int min_length = Math.min(bo.length, b1.length); for (int i = 0; i < min_length; i++) { diff --git a/test/646-checker-simd-hadd/src/HaddByte.java b/test/646-checker-simd-hadd/src/HaddByte.java index 9c99390690..c8bb0aaf2b 100644 --- a/test/646-checker-simd-hadd/src/HaddByte.java +++ b/test/646-checker-simd-hadd/src/HaddByte.java @@ -36,11 +36,26 @@ public class HaddByte { /// CHECK-DAG: <<Cnv:b\d+>> TypeConversion [<<Shr>>] loop:<<Loop>> outer_loop:none /// CHECK-DAG: ArraySet [{{l\d+}},<<Phi>>,<<Cnv>>] loop:<<Loop>> outer_loop:none // - /// CHECK-START-{ARM,ARM64}: void HaddByte.halving_add_signed(byte[], byte[], byte[]) loop_optimization (after) + /// CHECK-START-ARM: void HaddByte.halving_add_signed(byte[], byte[], byte[]) loop_optimization (after) /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Int8 rounded:false loop:<<Loop>> outer_loop:none /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-START-ARM64: void HaddByte.halving_add_signed(byte[], byte[], byte[]) loop_optimization (after) + /// CHECK-IF: hasIsaFeature("sve") + // + // HalvingAdd idiom is not supported for SVE. + /// CHECK-NOT: VecHalvingAdd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Int8 rounded:false loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static void halving_add_signed(byte[] b1, byte[] b2, byte[] bo) { int min_length = Math.min(bo.length, Math.min(b1.length, b2.length)); for (int i = 0; i < min_length; i++) { @@ -71,11 +86,26 @@ public class HaddByte { /// CHECK-DAG: <<Cnv:b\d+>> TypeConversion [<<Shr>>] loop:<<Loop>> outer_loop:none /// CHECK-DAG: ArraySet [{{l\d+}},<<Phi>>,<<Cnv>>] loop:<<Loop>> outer_loop:none // - /// CHECK-START-{ARM,ARM64}: void HaddByte.halving_add_unsigned(byte[], byte[], byte[]) loop_optimization (after) + /// CHECK-START-ARM: void HaddByte.halving_add_unsigned(byte[], byte[], byte[]) loop_optimization (after) /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Uint8 rounded:false loop:<<Loop>> outer_loop:none /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-START-ARM64: void HaddByte.halving_add_unsigned(byte[], byte[], byte[]) loop_optimization (after) + /// CHECK-IF: hasIsaFeature("sve") + // + // HalvingAdd idiom is not supported for SVE. + /// CHECK-NOT: VecHalvingAdd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Uint8 rounded:false loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static void halving_add_unsigned(byte[] b1, byte[] b2, byte[] bo) { int min_length = Math.min(bo.length, Math.min(b1.length, b2.length)); for (int i = 0; i < min_length; i++) { @@ -94,11 +124,26 @@ public class HaddByte { /// CHECK-DAG: <<Cnv:b\d+>> TypeConversion [<<Shr>>] loop:<<Loop>> outer_loop:none /// CHECK-DAG: ArraySet [{{l\d+}},<<Phi>>,<<Cnv>>] loop:<<Loop>> outer_loop:none // - /// CHECK-START-{ARM,ARM64}: void HaddByte.rounding_halving_add_signed(byte[], byte[], byte[]) loop_optimization (after) + /// CHECK-START-ARM: void HaddByte.rounding_halving_add_signed(byte[], byte[], byte[]) loop_optimization (after) /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Int8 rounded:true loop:<<Loop>> outer_loop:none /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-START-ARM64: void HaddByte.rounding_halving_add_signed(byte[], byte[], byte[]) loop_optimization (after) + /// CHECK-IF: hasIsaFeature("sve") + // + // HalvingAdd idiom is not supported for SVE. + /// CHECK-NOT: VecHalvingAdd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Int8 rounded:true loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static void rounding_halving_add_signed(byte[] b1, byte[] b2, byte[] bo) { int min_length = Math.min(bo.length, Math.min(b1.length, b2.length)); for (int i = 0; i < min_length; i++) { @@ -131,11 +176,26 @@ public class HaddByte { /// CHECK-DAG: <<Cnv:b\d+>> TypeConversion [<<Shr>>] loop:<<Loop>> outer_loop:none /// CHECK-DAG: ArraySet [{{l\d+}},<<Phi>>,<<Cnv>>] loop:<<Loop>> outer_loop:none // - /// CHECK-START-{ARM,ARM64}: void HaddByte.rounding_halving_add_unsigned(byte[], byte[], byte[]) loop_optimization (after) + /// CHECK-START-ARM: void HaddByte.rounding_halving_add_unsigned(byte[], byte[], byte[]) loop_optimization (after) /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Uint8 rounded:true loop:<<Loop>> outer_loop:none /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-START-ARM64: void HaddByte.rounding_halving_add_unsigned(byte[], byte[], byte[]) loop_optimization (after) + /// CHECK-IF: hasIsaFeature("sve") + // + // HalvingAdd idiom is not supported for SVE. + /// CHECK-NOT: VecHalvingAdd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Uint8 rounded:true loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static void rounding_halving_add_unsigned(byte[] b1, byte[] b2, byte[] bo) { int min_length = Math.min(bo.length, Math.min(b1.length, b2.length)); for (int i = 0; i < min_length; i++) { @@ -153,12 +213,28 @@ public class HaddByte { /// CHECK-DAG: <<Cnv:b\d+>> TypeConversion [<<Shr>>] loop:<<Loop>> outer_loop:none /// CHECK-DAG: ArraySet [{{l\d+}},<<Phi>>,<<Cnv>>] loop:<<Loop>> outer_loop:none // - /// CHECK-START-{ARM,ARM64}: void HaddByte.halving_add_signed_constant(byte[], byte[]) loop_optimization (after) + /// CHECK-START-ARM: void HaddByte.halving_add_signed_constant(byte[], byte[]) loop_optimization (after) /// CHECK-DAG: <<I127:i\d+>> IntConstant 127 loop:none /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<I127>>] loop:none /// CHECK-DAG: <<Get:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get>>,<<Repl>>] packed_type:Int8 rounded:false loop:<<Loop>> outer_loop:none /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-START-ARM64: void HaddByte.halving_add_signed_constant(byte[], byte[]) loop_optimization (after) + /// CHECK-IF: hasIsaFeature("sve") + // + // HalvingAdd idiom is not supported for SVE. + /// CHECK-NOT: VecHalvingAdd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<I127:i\d+>> IntConstant 127 loop:none + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<I127>>] loop:none + /// CHECK-DAG: <<Get:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get>>,<<Repl>>] packed_type:Int8 rounded:false loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static void halving_add_signed_constant(byte[] b1, byte[] bo) { int min_length = Math.min(bo.length, b1.length); for (int i = 0; i < min_length; i++) { @@ -187,12 +263,28 @@ public class HaddByte { /// CHECK-DAG: <<Cnv:b\d+>> TypeConversion [<<Shr>>] loop:<<Loop>> outer_loop:none /// CHECK-DAG: ArraySet [{{l\d+}},<<Phi>>,<<Cnv>>] loop:<<Loop>> outer_loop:none // - /// CHECK-START-{ARM,ARM64}: void HaddByte.halving_add_unsigned_constant(byte[], byte[]) loop_optimization (after) + /// CHECK-START-ARM: void HaddByte.halving_add_unsigned_constant(byte[], byte[]) loop_optimization (after) /// CHECK-DAG: <<I255:i\d+>> IntConstant 255 loop:none /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<I255>>] loop:none /// CHECK-DAG: <<Get:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get>>,<<Repl>>] packed_type:Uint8 rounded:false loop:<<Loop>> outer_loop:none /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-START-ARM64: void HaddByte.halving_add_unsigned_constant(byte[], byte[]) loop_optimization (after) + /// CHECK-IF: hasIsaFeature("sve") + // + // HalvingAdd idiom is not supported for SVE. + /// CHECK-NOT: VecHalvingAdd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<I255:i\d+>> IntConstant 255 loop:none + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<I255>>] loop:none + /// CHECK-DAG: <<Get:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get>>,<<Repl>>] packed_type:Uint8 rounded:false loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static void halving_add_unsigned_constant(byte[] b1, byte[] bo) { int min_length = Math.min(bo.length, b1.length); for (int i = 0; i < min_length; i++) { diff --git a/test/646-checker-simd-hadd/src/HaddChar.java b/test/646-checker-simd-hadd/src/HaddChar.java index 255863eabd..236b08164f 100644 --- a/test/646-checker-simd-hadd/src/HaddChar.java +++ b/test/646-checker-simd-hadd/src/HaddChar.java @@ -43,10 +43,19 @@ public class HaddChar { /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none // /// CHECK-START-ARM64: void HaddChar.halving_add_unsigned(char[], char[], char[]) loop_optimization (after) - /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Uint16 rounded:false loop:<<Loop>> outer_loop:none - /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + // HalvingAdd idiom is not supported for SVE. + /// CHECK-NOT: VecHalvingAdd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Uint16 rounded:false loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static void halving_add_unsigned(char[] b1, char[] b2, char[] bo) { int min_length = Math.min(bo.length, Math.min(b1.length, b2.length)); for (int i = 0; i < min_length; i++) { @@ -84,10 +93,19 @@ public class HaddChar { /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none // /// CHECK-START-ARM64: void HaddChar.halving_add_also_unsigned(char[], char[], char[]) loop_optimization (after) - /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Uint16 rounded:false loop:<<Loop>> outer_loop:none - /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + // HalvingAdd idiom is not supported for SVE. + /// CHECK-NOT: VecHalvingAdd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Uint16 rounded:false loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: // // Note: HAnd has no impact (already a zero extension). // @@ -116,10 +134,19 @@ public class HaddChar { /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none // /// CHECK-START-ARM64: void HaddChar.rounding_halving_add_unsigned(char[], char[], char[]) loop_optimization (after) + /// CHECK-IF: hasIsaFeature("sve") + // + // HalvingAdd idiom is not supported for SVE. + /// CHECK-NOT: VecHalvingAdd + // + /// CHECK-ELSE: + // /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Uint16 rounded:true loop:<<Loop>> outer_loop:none /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static void rounding_halving_add_unsigned(char[] b1, char[] b2, char[] bo) { int min_length = Math.min(bo.length, Math.min(b1.length, b2.length)); for (int i = 0; i < min_length; i++) { @@ -159,10 +186,19 @@ public class HaddChar { /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none // /// CHECK-START-ARM64: void HaddChar.rounding_halving_add_also_unsigned(char[], char[], char[]) loop_optimization (after) - /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Uint16 rounded:true loop:<<Loop>> outer_loop:none - /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + // HalvingAdd idiom is not supported for SVE. + /// CHECK-NOT: VecHalvingAdd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Uint16 rounded:true loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: // // Note: HAnd has no impact (already a zero extension). // @@ -191,10 +227,19 @@ public class HaddChar { /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none // /// CHECK-START-ARM64: void HaddChar.halving_add_unsigned_constant(char[], char[]) loop_optimization (after) - /// CHECK-DAG: <<UMAX:i\d+>> IntConstant 65535 loop:none - /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<UMAX>>] loop:none - /// CHECK-DAG: <<Get:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get>>,<<Repl>>] packed_type:Uint16 rounded:false loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + // HalvingAdd idiom is not supported for SVE. + /// CHECK-NOT: VecHalvingAdd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<UMAX:i\d+>> IntConstant 65535 loop:none + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<UMAX>>] loop:none + /// CHECK-DAG: <<Get:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get>>,<<Repl>>] packed_type:Uint16 rounded:false loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static void halving_add_unsigned_constant(char[] b1, char[] bo) { int min_length = Math.min(bo.length, b1.length); for (int i = 0; i < min_length; i++) { @@ -231,11 +276,20 @@ public class HaddChar { /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none // /// CHECK-START-ARM64: void HaddChar.halving_add_also_unsigned_constant(char[], char[]) loop_optimization (after) - /// CHECK-DAG: <<UMAX:i\d+>> IntConstant 65535 loop:none - /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<UMAX>>] loop:none - /// CHECK-DAG: <<Get:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get>>,<<Repl>>] packed_type:Uint16 rounded:false loop:<<Loop>> outer_loop:none - /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + // HalvingAdd idiom is not supported for SVE. + /// CHECK-NOT: VecHalvingAdd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<UMAX:i\d+>> IntConstant 65535 loop:none + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<UMAX>>] loop:none + /// CHECK-DAG: <<Get:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get>>,<<Repl>>] packed_type:Uint16 rounded:false loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: // // Note: HAnd has no impact (already a zero extension). // diff --git a/test/646-checker-simd-hadd/src/HaddOther.java b/test/646-checker-simd-hadd/src/HaddOther.java index 0339f24933..139df833b0 100644 --- a/test/646-checker-simd-hadd/src/HaddOther.java +++ b/test/646-checker-simd-hadd/src/HaddOther.java @@ -99,9 +99,22 @@ public class HaddOther { // Should be an add, followed by a halving add. // - /// CHECK-START-{ARM,ARM64}: void HaddOther.test_no_hadd_sum_casted_plus_const(short[], short[], short[]) loop_optimization (after) + /// CHECK-START-ARM: void HaddOther.test_no_hadd_sum_casted_plus_const(short[], short[], short[]) loop_optimization (after) /// CHECK: VecAdd /// CHECK: VecHalvingAdd + // + /// CHECK-START-ARM64: void HaddOther.test_no_hadd_sum_casted_plus_const(short[], short[], short[]) loop_optimization (after) + /// CHECK-IF: hasIsaFeature("sve") + // + // HalvingAdd idiom is not supported for SVE. + /// CHECK-NOT: VecHalvingAdd + // + /// CHECK-ELSE: + // + /// CHECK: VecAdd + /// CHECK: VecHalvingAdd + // + /// CHECK-FI: private static void test_no_hadd_sum_casted_plus_const(short[] a, short[] b, short[] out) { int min_length = Math.min(out.length, Math.min(a.length, b.length)); for (int i = 0; i < min_length; i++) { diff --git a/test/646-checker-simd-hadd/src/HaddShort.java b/test/646-checker-simd-hadd/src/HaddShort.java index 4102efdb64..9880a7a0da 100644 --- a/test/646-checker-simd-hadd/src/HaddShort.java +++ b/test/646-checker-simd-hadd/src/HaddShort.java @@ -40,11 +40,26 @@ public class HaddShort { /// CHECK-DAG: <<Cnv:s\d+>> TypeConversion [<<Shr>>] loop:<<Loop>> outer_loop:none /// CHECK-DAG: ArraySet [{{l\d+}},<<Phi>>,<<Cnv>>] loop:<<Loop>> outer_loop:none // - /// CHECK-START-{ARM,ARM64}: void HaddShort.halving_add_signed(short[], short[], short[]) loop_optimization (after) + /// CHECK-START-ARM: void HaddShort.halving_add_signed(short[], short[], short[]) loop_optimization (after) /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Int16 rounded:false loop:<<Loop>> outer_loop:none /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-START-ARM64: void HaddShort.halving_add_signed(short[], short[], short[]) loop_optimization (after) + /// CHECK-IF: hasIsaFeature("sve") + // + // HalvingAdd idiom is not supported for SVE. + /// CHECK-NOT: VecHalvingAdd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Int16 rounded:false loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static void halving_add_signed(short[] b1, short[] b2, short[] bo) { int min_length = Math.min(bo.length, Math.min(b1.length, b2.length)); for (int i = 0; i < min_length; i++) { @@ -66,11 +81,26 @@ public class HaddShort { /// CHECK-DAG: <<Cnv:s\d+>> TypeConversion [<<Shr>>] loop:<<Loop>> outer_loop:none /// CHECK-DAG: ArraySet [{{l\d+}},<<Phi>>,<<Cnv>>] loop:<<Loop>> outer_loop:none // - /// CHECK-START-{ARM,ARM64}: void HaddShort.halving_add_signed_alt(short[], short[], short[]) loop_optimization (after) + /// CHECK-START-ARM: void HaddShort.halving_add_signed_alt(short[], short[], short[]) loop_optimization (after) /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Int16 rounded:false loop:<<Loop>> outer_loop:none /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-START-ARM64: void HaddShort.halving_add_signed_alt(short[], short[], short[]) loop_optimization (after) + /// CHECK-IF: hasIsaFeature("sve") + // + // HalvingAdd idiom is not supported for SVE. + /// CHECK-NOT: VecHalvingAdd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Int16 rounded:false loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static void halving_add_signed_alt(short[] b1, short[] b2, short[] bo) { int min_length = Math.min(bo.length, Math.min(b1.length, b2.length)); for (int i = 0; i < min_length; i++) { @@ -102,11 +132,26 @@ public class HaddShort { /// CHECK-DAG: <<Cnv:s\d+>> TypeConversion [<<Shr>>] loop:<<Loop>> outer_loop:none /// CHECK-DAG: ArraySet [{{l\d+}},<<Phi>>,<<Cnv>>] loop:<<Loop>> outer_loop:none // - /// CHECK-START-{ARM,ARM64}: void HaddShort.halving_add_unsigned(short[], short[], short[]) loop_optimization (after) + /// CHECK-START-ARM: void HaddShort.halving_add_unsigned(short[], short[], short[]) loop_optimization (after) /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Uint16 rounded:false loop:<<Loop>> outer_loop:none /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-START-ARM64: void HaddShort.halving_add_unsigned(short[], short[], short[]) loop_optimization (after) + /// CHECK-IF: hasIsaFeature("sve") + // + // HalvingAdd idiom is not supported for SVE. + /// CHECK-NOT: VecHalvingAdd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Uint16 rounded:false loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static void halving_add_unsigned(short[] b1, short[] b2, short[] bo) { int min_length = Math.min(bo.length, Math.min(b1.length, b2.length)); for (int i = 0; i < min_length; i++) { @@ -127,11 +172,26 @@ public class HaddShort { /// CHECK-DAG: <<Cnv:s\d+>> TypeConversion [<<Shr>>] loop:<<Loop>> outer_loop:none /// CHECK-DAG: ArraySet [{{l\d+}},<<Phi>>,<<Cnv>>] loop:<<Loop>> outer_loop:none // - /// CHECK-START-{ARM,ARM64}: void HaddShort.rounding_halving_add_signed(short[], short[], short[]) loop_optimization (after) + /// CHECK-START-ARM: void HaddShort.rounding_halving_add_signed(short[], short[], short[]) loop_optimization (after) /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Int16 rounded:true loop:<<Loop>> outer_loop:none /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-START-ARM64: void HaddShort.rounding_halving_add_signed(short[], short[], short[]) loop_optimization (after) + /// CHECK-IF: hasIsaFeature("sve") + // + // HalvingAdd idiom is not supported for SVE. + /// CHECK-NOT: VecHalvingAdd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Int16 rounded:true loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static void rounding_halving_add_signed(short[] b1, short[] b2, short[] bo) { int min_length = Math.min(bo.length, Math.min(b1.length, b2.length)); for (int i = 0; i < min_length; i++) { @@ -150,11 +210,26 @@ public class HaddShort { /// CHECK-DAG: <<Cnv:s\d+>> TypeConversion [<<Shr>>] loop:<<Loop>> outer_loop:none /// CHECK-DAG: ArraySet [{{l\d+}},<<Phi>>,<<Cnv>>] loop:<<Loop>> outer_loop:none // - /// CHECK-START-{ARM,ARM64}: void HaddShort.rounding_halving_add_signed_alt(short[], short[], short[]) loop_optimization (after) + /// CHECK-START-ARM: void HaddShort.rounding_halving_add_signed_alt(short[], short[], short[]) loop_optimization (after) /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Int16 rounded:true loop:<<Loop>> outer_loop:none /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-START-ARM64: void HaddShort.rounding_halving_add_signed_alt(short[], short[], short[]) loop_optimization (after) + /// CHECK-IF: hasIsaFeature("sve") + // + // HalvingAdd idiom is not supported for SVE. + /// CHECK-NOT: VecHalvingAdd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Int16 rounded:true loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static void rounding_halving_add_signed_alt(short[] b1, short[] b2, short[] bo) { int min_length = Math.min(bo.length, Math.min(b1.length, b2.length)); for (int i = 0; i < min_length; i++) { @@ -177,11 +252,26 @@ public class HaddShort { /// CHECK-DAG: <<Cnv:s\d+>> TypeConversion [<<Shr>>] loop:<<Loop>> outer_loop:none /// CHECK-DAG: ArraySet [{{l\d+}},<<Phi>>,<<Cnv>>] loop:<<Loop>> outer_loop:none // - /// CHECK-START-{ARM,ARM64}: void HaddShort.rounding_halving_add_signed_alt2(short[], short[], short[]) loop_optimization (after) + /// CHECK-START-ARM: void HaddShort.rounding_halving_add_signed_alt2(short[], short[], short[]) loop_optimization (after) /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Int16 rounded:true loop:<<Loop>> outer_loop:none /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-START-ARM64: void HaddShort.rounding_halving_add_signed_alt2(short[], short[], short[]) loop_optimization (after) + /// CHECK-IF: hasIsaFeature("sve") + // + // HalvingAdd idiom is not supported for SVE. + /// CHECK-NOT: VecHalvingAdd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Int16 rounded:true loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static void rounding_halving_add_signed_alt2(short[] b1, short[] b2, short[] bo) { int min_length = Math.min(bo.length, Math.min(b1.length, b2.length)); for (int i = 0; i < min_length; i++) { @@ -206,11 +296,26 @@ public class HaddShort { /// CHECK-DAG: <<Cnv:s\d+>> TypeConversion [<<Shr>>] loop:<<Loop>> outer_loop:none /// CHECK-DAG: ArraySet [{{l\d+}},<<Phi>>,<<Cnv>>] loop:<<Loop>> outer_loop:none // - /// CHECK-START-{ARM,ARM64}: void HaddShort.rounding_halving_add_signed_alt3(short[], short[], short[]) loop_optimization (after) + /// CHECK-START-ARM: void HaddShort.rounding_halving_add_signed_alt3(short[], short[], short[]) loop_optimization (after) /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Int16 rounded:true loop:<<Loop>> outer_loop:none /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-START-ARM64: void HaddShort.rounding_halving_add_signed_alt3(short[], short[], short[]) loop_optimization (after) + /// CHECK-IF: hasIsaFeature("sve") + // + // HalvingAdd idiom is not supported for SVE. + /// CHECK-NOT: VecHalvingAdd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Int16 rounded:true loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static void rounding_halving_add_signed_alt3(short[] b1, short[] b2, short[] bo) { int min_length = Math.min(bo.length, Math.min(b1.length, b2.length)); for (int i = 0; i < min_length; i++) { @@ -244,11 +349,26 @@ public class HaddShort { /// CHECK-DAG: <<Cnv:s\d+>> TypeConversion [<<Shr>>] loop:<<Loop>> outer_loop:none /// CHECK-DAG: ArraySet [{{l\d+}},<<Phi>>,<<Cnv>>] loop:<<Loop>> outer_loop:none // - /// CHECK-START-{ARM,ARM64}: void HaddShort.rounding_halving_add_unsigned(short[], short[], short[]) loop_optimization (after) + /// CHECK-START-ARM: void HaddShort.rounding_halving_add_unsigned(short[], short[], short[]) loop_optimization (after) /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Uint16 rounded:true loop:<<Loop>> outer_loop:none /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-START-ARM64: void HaddShort.rounding_halving_add_unsigned(short[], short[], short[]) loop_optimization (after) + /// CHECK-IF: hasIsaFeature("sve") + // + // HalvingAdd idiom is not supported for SVE. + /// CHECK-NOT: VecHalvingAdd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Uint16 rounded:true loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static void rounding_halving_add_unsigned(short[] b1, short[] b2, short[] bo) { int min_length = Math.min(bo.length, Math.min(b1.length, b2.length)); for (int i = 0; i < min_length; i++) { @@ -283,11 +403,26 @@ public class HaddShort { /// CHECK-DAG: <<Cnv:s\d+>> TypeConversion [<<Shr>>] loop:<<Loop>> outer_loop:none /// CHECK-DAG: ArraySet [{{l\d+}},<<Phi>>,<<Cnv>>] loop:<<Loop>> outer_loop:none // - /// CHECK-START-{ARM,ARM64}: void HaddShort.rounding_halving_add_unsigned_alt(short[], short[], short[]) loop_optimization (after) + /// CHECK-START-ARM: void HaddShort.rounding_halving_add_unsigned_alt(short[], short[], short[]) loop_optimization (after) /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Uint16 rounded:true loop:<<Loop>> outer_loop:none /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-START-ARM64: void HaddShort.rounding_halving_add_unsigned_alt(short[], short[], short[]) loop_optimization (after) + /// CHECK-IF: hasIsaFeature("sve") + // + // HalvingAdd idiom is not supported for SVE. + /// CHECK-NOT: VecHalvingAdd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get1>>,<<Get2>>] packed_type:Uint16 rounded:true loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static void rounding_halving_add_unsigned_alt(short[] b1, short[] b2, short[] bo) { int min_length = Math.min(bo.length, Math.min(b1.length, b2.length)); for (int i = 0; i < min_length; i++) { @@ -308,12 +443,28 @@ public class HaddShort { /// CHECK-DAG: <<Cnv:s\d+>> TypeConversion [<<Shr>>] loop:<<Loop>> outer_loop:none /// CHECK-DAG: ArraySet [{{l\d+}},<<Phi>>,<<Cnv>>] loop:<<Loop>> outer_loop:none // - /// CHECK-START-{ARM,ARM64}: void HaddShort.halving_add_signed_constant(short[], short[]) loop_optimization (after) + /// CHECK-START-ARM: void HaddShort.halving_add_signed_constant(short[], short[]) loop_optimization (after) /// CHECK-DAG: <<SMAX:i\d+>> IntConstant 32767 loop:none /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<SMAX>>] loop:none /// CHECK-DAG: <<Get:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get>>,<<Repl>>] packed_type:Int16 rounded:false loop:<<Loop>> outer_loop:none /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-START-ARM64: void HaddShort.halving_add_signed_constant(short[], short[]) loop_optimization (after) + /// CHECK-IF: hasIsaFeature("sve") + // + // HalvingAdd idiom is not supported for SVE. + /// CHECK-NOT: VecHalvingAdd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<SMAX:i\d+>> IntConstant 32767 loop:none + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<SMAX>>] loop:none + /// CHECK-DAG: <<Get:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get>>,<<Repl>>] packed_type:Int16 rounded:false loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static void halving_add_signed_constant(short[] b1, short[] bo) { int min_length = Math.min(bo.length, b1.length); for (int i = 0; i < min_length; i++) { @@ -342,12 +493,28 @@ public class HaddShort { /// CHECK-DAG: <<Cnv:s\d+>> TypeConversion [<<Shr>>] loop:<<Loop>> outer_loop:none /// CHECK-DAG: ArraySet [{{l\d+}},<<Phi>>,<<Cnv>>] loop:<<Loop>> outer_loop:none // - /// CHECK-START-{ARM,ARM64}: void HaddShort.halving_add_unsigned_constant(short[], short[]) loop_optimization (after) + /// CHECK-START-ARM: void HaddShort.halving_add_unsigned_constant(short[], short[]) loop_optimization (after) /// CHECK-DAG: <<UMAX:i\d+>> IntConstant 65535 loop:none /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<UMAX>>] loop:none /// CHECK-DAG: <<Get:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get>>,<<Repl>>] packed_type:Uint16 rounded:false loop:<<Loop>> outer_loop:none /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-START-ARM64: void HaddShort.halving_add_unsigned_constant(short[], short[]) loop_optimization (after) + /// CHECK-IF: hasIsaFeature("sve") + // + // HalvingAdd idiom is not supported for SVE. + /// CHECK-NOT: VecHalvingAdd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<UMAX:i\d+>> IntConstant 65535 loop:none + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<UMAX>>] loop:none + /// CHECK-DAG: <<Get:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<HAdd:d\d+>> VecHalvingAdd [<<Get>>,<<Repl>>] packed_type:Uint16 rounded:false loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<HAdd>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static void halving_add_unsigned_constant(short[] b1, short[] bo) { int min_length = Math.min(bo.length, b1.length); for (int i = 0; i < min_length; i++) { diff --git a/test/655-checker-simd-arm-opt/src/Main.java b/test/655-checker-simd-arm-opt/src/Main.java index c82f24f7ff..980593d1f9 100644 --- a/test/655-checker-simd-arm-opt/src/Main.java +++ b/test/655-checker-simd-arm-opt/src/Main.java @@ -37,16 +37,33 @@ public class Main { /// CHECK-DAG: <<D9:d\d+>> DoubleConstant 20 /// CHECK-DAG: <<D10:d\d+>> DoubleConstant 0 // - /// CHECK-DAG: VecReplicateScalar [<<C1>>] - /// CHECK-DAG: VecReplicateScalar [<<C2>>] - /// CHECK-DAG: VecReplicateScalar [<<C3>>] - /// CHECK-DAG: VecReplicateScalar [<<C4>>] - /// CHECK-DAG: VecReplicateScalar [<<C5>>] - /// CHECK-DAG: VecReplicateScalar [<<L6>>] - /// CHECK-DAG: VecReplicateScalar [<<F7>>] - /// CHECK-DAG: VecReplicateScalar [<<F8>>] - /// CHECK-DAG: VecReplicateScalar [<<D9>>] - /// CHECK-DAG: VecReplicateScalar [<<D10>>] + /// CHECK-IF: hasIsaFeature("sve") + // + /// CHECK-DAG: VecReplicateScalar [<<C1>>,{{j\d+}}] + /// CHECK-DAG: VecReplicateScalar [<<C2>>,{{j\d+}}] + /// CHECK-DAG: VecReplicateScalar [<<C3>>,{{j\d+}}] + /// CHECK-DAG: VecReplicateScalar [<<C4>>,{{j\d+}}] + /// CHECK-DAG: VecReplicateScalar [<<C5>>,{{j\d+}}] + /// CHECK-DAG: VecReplicateScalar [<<L6>>,{{j\d+}}] + /// CHECK-DAG: VecReplicateScalar [<<F7>>,{{j\d+}}] + /// CHECK-DAG: VecReplicateScalar [<<F8>>,{{j\d+}}] + /// CHECK-DAG: VecReplicateScalar [<<D9>>,{{j\d+}}] + /// CHECK-DAG: VecReplicateScalar [<<D10>>,{{j\d+}}] + // + /// CHECK-ELSE: + // + /// CHECK-DAG: VecReplicateScalar [<<C1>>] + /// CHECK-DAG: VecReplicateScalar [<<C2>>] + /// CHECK-DAG: VecReplicateScalar [<<C3>>] + /// CHECK-DAG: VecReplicateScalar [<<C4>>] + /// CHECK-DAG: VecReplicateScalar [<<C5>>] + /// CHECK-DAG: VecReplicateScalar [<<L6>>] + /// CHECK-DAG: VecReplicateScalar [<<F7>>] + /// CHECK-DAG: VecReplicateScalar [<<F8>>] + /// CHECK-DAG: VecReplicateScalar [<<D9>>] + /// CHECK-DAG: VecReplicateScalar [<<D10>>] + // + /// CHECK-FI: private static void encodableConstants(byte[] b, short[] s, char[] c, int[] a, long[] l, float[] f, double[] d) { for (int i = 0; i < ARRAY_SIZE; i++) { b[i] += 1; diff --git a/test/656-checker-simd-opt/src/Main.java b/test/656-checker-simd-opt/src/Main.java index d632fd2b3b..be8c52fc11 100644 --- a/test/656-checker-simd-opt/src/Main.java +++ b/test/656-checker-simd-opt/src/Main.java @@ -30,18 +30,35 @@ public class Main { // /// CHECK-START-ARM64: void Main.unroll(float[], float[]) loop_optimization (after) /// CHECK-DAG: <<Cons:f\d+>> FloatConstant 2.5 loop:none - /// CHECK-DAG: <<Incr:i\d+>> IntConstant 4 loop:none - /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Cons>>] loop:none - /// CHECK-NOT: VecReplicateScalar - /// CHECK-DAG: <<Phi:i\d+>> Phi loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Get1:d\d+>> VecLoad [{{l\d+}},<<Phi>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Mul1:d\d+>> VecMul [<<Get1>>,<<Repl>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: VecStore [{{l\d+}},<<Phi>>,<<Mul1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Add:i\d+>> Add [<<Phi>>,<<Incr>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Get2:d\d+>> VecLoad [{{l\d+}},<<Add>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Mul2:d\d+>> VecMul [<<Get2>>,<<Repl>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: VecStore [{{l\d+}},<<Add>>,<<Mul2>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Add>>,<<Incr>>] loop:<<Loop>> outer_loop:none + + /// CHECK-IF: hasIsaFeature("sve") + // + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Cons>>,{{j\d+}}] loop:none + /// CHECK-NOT: VecReplicateScalar + /// CHECK-DAG: <<Phi:i\d+>> Phi loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<LoopP:j\d+>> VecPredWhile [<<Phi>>,{{i\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Get1:d\d+>> VecLoad [{{l\d+}},<<Phi>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Mul1:d\d+>> VecMul [<<Get1>>,<<Repl>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},<<Phi>>,<<Mul1>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Add:i\d+>> Add [<<Phi>>,{{i\d+}}] loop:<<Loop>> outer_loop:none + // No unroll for SVE yet. + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Incr:i\d+>> IntConstant 4 loop:none + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Cons>>] loop:none + /// CHECK-NOT: VecReplicateScalar + /// CHECK-DAG: <<Phi:i\d+>> Phi loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Get1:d\d+>> VecLoad [{{l\d+}},<<Phi>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Mul1:d\d+>> VecMul [<<Get1>>,<<Repl>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},<<Phi>>,<<Mul1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Add:i\d+>> Add [<<Phi>>,<<Incr>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Get2:d\d+>> VecLoad [{{l\d+}},<<Add>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Mul2:d\d+>> VecMul [<<Get2>>,<<Repl>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},<<Add>>,<<Mul2>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Add>>,<<Incr>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static void unroll(float[] x, float[] y) { for (int i = 0; i < 100; i++) { x[i] = y[i] * 2.5f; @@ -51,15 +68,32 @@ public class Main { /// CHECK-START-ARM64: void Main.stencil(int[], int[], int) loop_optimization (after) /// CHECK-DAG: <<CP1:i\d+>> IntConstant 1 loop:none /// CHECK-DAG: <<CP2:i\d+>> IntConstant 2 loop:none - /// CHECK-DAG: <<Phi:i\d+>> Phi loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Add1:i\d+>> Add [<<Phi>>,<<CP1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Get1:d\d+>> VecLoad [{{l\d+}},<<Phi>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Get2:d\d+>> VecLoad [{{l\d+}},<<Add1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Add2:d\d+>> VecAdd [<<Get1>>,<<Get2>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Add3:i\d+>> Add [<<Phi>>,<<CP2>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Get3:d\d+>> VecLoad [{{l\d+}},<<Add3>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Add4:d\d+>> VecAdd [<<Add2>>,<<Get3>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: VecStore [{{l\d+}},<<Add1>>,<<Add4>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + /// CHECK-DAG: <<Phi:i\d+>> Phi loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<LoopP:j\d+>> VecPredWhile [<<Phi>>,{{i\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Add1:i\d+>> Add [<<Phi>>,<<CP1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Get1:d\d+>> VecLoad [{{l\d+}},<<Phi>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Get2:d\d+>> VecLoad [{{l\d+}},<<Add1>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Add2:d\d+>> VecAdd [<<Get1>>,<<Get2>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Add3:i\d+>> Add [<<Phi>>,<<CP2>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Get3:d\d+>> VecLoad [{{l\d+}},<<Add3>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Add4:d\d+>> VecAdd [<<Add2>>,<<Get3>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},<<Add1>>,<<Add4>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Phi:i\d+>> Phi loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Add1:i\d+>> Add [<<Phi>>,<<CP1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Get1:d\d+>> VecLoad [{{l\d+}},<<Phi>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Get2:d\d+>> VecLoad [{{l\d+}},<<Add1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Add2:d\d+>> VecAdd [<<Get1>>,<<Get2>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Add3:i\d+>> Add [<<Phi>>,<<CP2>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Get3:d\d+>> VecLoad [{{l\d+}},<<Add3>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Add4:d\d+>> VecAdd [<<Add2>>,<<Get3>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},<<Add1>>,<<Add4>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static void stencil(int[] a, int[] b, int n) { for (int i = 1; i < n - 1; i++) { a[i] = b[i - 1] + b[i] + b[i + 1]; @@ -82,15 +116,32 @@ public class Main { /// CHECK-START-{X86_64,ARM64}: void Main.stencilAddInt(int[], int[], int) loop_optimization (after) /// CHECK-DAG: <<CP1:i\d+>> IntConstant 1 loop:none /// CHECK-DAG: <<CP2:i\d+>> IntConstant 2 loop:none - /// CHECK-DAG: <<Phi:i\d+>> Phi loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Add1:i\d+>> Add [<<Phi>>,<<CP1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Get1:d\d+>> VecLoad [{{l\d+}},<<Phi>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Get2:d\d+>> VecLoad [{{l\d+}},<<Add1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Add2:d\d+>> VecAdd [<<Get1>>,<<Get2>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Add3:i\d+>> Add [<<Phi>>,<<CP2>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Get3:d\d+>> VecLoad [{{l\d+}},<<Add3>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Add4:d\d+>> VecAdd [<<Add2>>,<<Get3>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: VecStore [{{l\d+}},<<Add1>>,<<Add4>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + /// CHECK-DAG: <<Phi:i\d+>> Phi loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<LoopP:j\d+>> VecPredWhile [<<Phi>>,{{i\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Add1:i\d+>> Add [<<Phi>>,<<CP1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Get1:d\d+>> VecLoad [{{l\d+}},<<Phi>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Get2:d\d+>> VecLoad [{{l\d+}},<<Add1>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Add2:d\d+>> VecAdd [<<Get1>>,<<Get2>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Add3:i\d+>> Add [<<Phi>>,<<CP2>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Get3:d\d+>> VecLoad [{{l\d+}},<<Add3>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Add4:d\d+>> VecAdd [<<Add2>>,<<Get3>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},<<Add1>>,<<Add4>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Phi:i\d+>> Phi loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Add1:i\d+>> Add [<<Phi>>,<<CP1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Get1:d\d+>> VecLoad [{{l\d+}},<<Phi>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Get2:d\d+>> VecLoad [{{l\d+}},<<Add1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Add2:d\d+>> VecAdd [<<Get1>>,<<Get2>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Add3:i\d+>> Add [<<Phi>>,<<CP2>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Get3:d\d+>> VecLoad [{{l\d+}},<<Add3>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Add4:d\d+>> VecAdd [<<Add2>>,<<Get3>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},<<Add1>>,<<Add4>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static void stencilAddInt(int[] a, int[] b, int n) { int minus1 = $inline$constMinus1(); for (int i = 1; i < n + minus1; i++) { @@ -119,15 +170,32 @@ public class Main { /// CHECK-START-{X86_64,ARM64}: void Main.stencilSubInt(int[], int[], int) loop_optimization (after) /// CHECK-DAG: <<CP1:i\d+>> IntConstant 1 loop:none /// CHECK-DAG: <<CP2:i\d+>> IntConstant 2 loop:none - /// CHECK-DAG: <<Phi:i\d+>> Phi loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Add1:i\d+>> Add [<<Phi>>,<<CP1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Get1:d\d+>> VecLoad [{{l\d+}},<<Phi>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Get2:d\d+>> VecLoad [{{l\d+}},<<Add1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Add2:d\d+>> VecAdd [<<Get1>>,<<Get2>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Add3:i\d+>> Add [<<Phi>>,<<CP2>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Get3:d\d+>> VecLoad [{{l\d+}},<<Add3>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Add4:d\d+>> VecAdd [<<Add2>>,<<Get3>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: VecStore [{{l\d+}},<<Add1>>,<<Add4>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + /// CHECK-DAG: <<Phi:i\d+>> Phi loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<LoopP:j\d+>> VecPredWhile [<<Phi>>,{{i\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Add1:i\d+>> Add [<<Phi>>,<<CP1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Get1:d\d+>> VecLoad [{{l\d+}},<<Phi>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Get2:d\d+>> VecLoad [{{l\d+}},<<Add1>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Add2:d\d+>> VecAdd [<<Get1>>,<<Get2>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Add3:i\d+>> Add [<<Phi>>,<<CP2>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Get3:d\d+>> VecLoad [{{l\d+}},<<Add3>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Add4:d\d+>> VecAdd [<<Add2>>,<<Get3>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},<<Add1>>,<<Add4>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Phi:i\d+>> Phi loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Add1:i\d+>> Add [<<Phi>>,<<CP1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Get1:d\d+>> VecLoad [{{l\d+}},<<Phi>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Get2:d\d+>> VecLoad [{{l\d+}},<<Add1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Add2:d\d+>> VecAdd [<<Get1>>,<<Get2>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Add3:i\d+>> Add [<<Phi>>,<<CP2>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Get3:d\d+>> VecLoad [{{l\d+}},<<Add3>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Add4:d\d+>> VecAdd [<<Add2>>,<<Get3>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},<<Add1>>,<<Add4>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static void stencilSubInt(int[] a, int[] b, int n) { int plus1 = $inline$constPlus1(); for (int i = 1; i < n - plus1; i++) { @@ -152,15 +220,29 @@ public class Main { /// CHECK-START-ARM64: long Main.longInductionReduction(long[]) loop_optimization (after) /// CHECK-DAG: <<L0:j\d+>> LongConstant 0 loop:none /// CHECK-DAG: <<L1:j\d+>> LongConstant 1 loop:none - /// CHECK-DAG: <<L2:j\d+>> LongConstant 2 loop:none /// CHECK-DAG: <<I0:i\d+>> IntConstant 0 loop:none /// CHECK-DAG: <<Get:j\d+>> ArrayGet [{{l\d+}},<<I0>>] loop:none - /// CHECK-DAG: <<Rep:d\d+>> VecReplicateScalar [<<Get>>] loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<L1>>] loop:none - /// CHECK-DAG: <<Phi1:j\d+>> Phi [<<L0>>,{{j\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: VecAdd [<<Phi2>>,<<Rep>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<L2>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + /// CHECK-DAG: <<Rep:d\d+>> VecReplicateScalar [<<Get>>,{{j\d+}}] loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<L1>>,{{j\d+}}] loop:none + /// CHECK-DAG: <<Phi1:j\d+>> Phi [<<L0>>,{{j\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<LoopP:j\d+>> VecPredWhile [<<Phi1>>,{{j\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecAdd [<<Phi2>>,<<Rep>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,{{j\d+}}] loop:<<Loop>> outer_loop:none + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<L2:j\d+>> LongConstant 2 loop:none + /// CHECK-DAG: <<Rep:d\d+>> VecReplicateScalar [<<Get>>] loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<L1>>] loop:none + /// CHECK-DAG: <<Phi1:j\d+>> Phi [<<L0>>,{{j\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecAdd [<<Phi2>>,<<Rep>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<L2>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: static long longInductionReduction(long[] y) { long x = 1; for (long i = 0; i < 10; i++) { @@ -181,13 +263,25 @@ public class Main { /// CHECK-START-ARM64: void Main.intVectorLongInvariant(int[], long[]) loop_optimization (after) /// CHECK-DAG: <<I0:i\d+>> IntConstant 0 loop:none /// CHECK-DAG: <<I1:i\d+>> IntConstant 1 loop:none - /// CHECK-DAG: <<I4:i\d+>> IntConstant 4 loop:none /// CHECK-DAG: <<Get:j\d+>> ArrayGet [{{l\d+}},<<I0>>] loop:none /// CHECK-DAG: <<Cnv:i\d+>> TypeConversion [<<Get>>] loop:none - /// CHECK-DAG: <<Rep:d\d+>> VecReplicateScalar [<<Cnv>>] loop:none - /// CHECK-DAG: <<Phi:i\d+>> Phi [<<I0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: VecStore [{{l\d+}},<<Phi>>,<<Rep>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi>>,<<I4>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + /// CHECK-DAG: <<Rep:d\d+>> VecReplicateScalar [<<Cnv>>,{{j\d+}}] loop:none + /// CHECK-DAG: <<Phi:i\d+>> Phi [<<I0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<LoopP:j\d+>> VecPredWhile [<<Phi>>,{{i\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},<<Phi>>,<<Rep>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi>>,{{i\d+}}] loop:<<Loop>> outer_loop:none + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<I4:i\d+>> IntConstant 4 loop:none + /// CHECK-DAG: <<Rep:d\d+>> VecReplicateScalar [<<Cnv>>] loop:none + /// CHECK-DAG: <<Phi:i\d+>> Phi [<<I0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},<<Phi>>,<<Rep>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi>>,<<I4>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: static void intVectorLongInvariant(int[] x, long[] y) { for (int i = 0; i < 100; i++) { x[i] = (int) y[0]; @@ -208,15 +302,29 @@ public class Main { // /// CHECK-START-ARM64: void Main.longCanBeDoneWithInt(int[], int[]) loop_optimization (after) /// CHECK-DAG: <<I0:i\d+>> IntConstant 0 loop:none - /// CHECK-DAG: <<I4:i\d+>> IntConstant 4 loop:none /// CHECK-DAG: <<L1:j\d+>> LongConstant 1 loop:none /// CHECK-DAG: <<Cnv:i\d+>> TypeConversion [<<L1>>] loop:none - /// CHECK-DAG: <<Rep:d\d+>> VecReplicateScalar [<<Cnv>>] loop:none - /// CHECK-DAG: <<Phi:i\d+>> Phi [<<I0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<Phi>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Add:d\d+>> VecAdd [<<Load>>,<<Rep>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: VecStore [{{l\d+}},<<Phi>>,<<Add>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi>>,<<I4>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + /// CHECK-DAG: <<Rep:d\d+>> VecReplicateScalar [<<Cnv>>,{{j\d+}}] loop:none + /// CHECK-DAG: <<Phi:i\d+>> Phi [<<I0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<LoopP:j\d+>> VecPredWhile [<<Phi>>,{{i\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<Phi>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Add:d\d+>> VecAdd [<<Load>>,<<Rep>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},<<Phi>>,<<Add>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi>>,{{i\d+}}] loop:<<Loop>> outer_loop:none + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<I4:i\d+>> IntConstant 4 loop:none + /// CHECK-DAG: <<Rep:d\d+>> VecReplicateScalar [<<Cnv>>] loop:none + /// CHECK-DAG: <<Phi:i\d+>> Phi [<<I0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<Phi>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Add:d\d+>> VecAdd [<<Load>>,<<Rep>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},<<Phi>>,<<Add>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi>>,<<I4>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: static void longCanBeDoneWithInt(int[] x, int[] y) { for (int i = 0; i < 100; i++) { x[i] = (int) (y[i] + 1L); diff --git a/test/660-checker-simd-sad/src/SimdSadByte.java b/test/660-checker-simd-sad/src/SimdSadByte.java index 11d0f21630..0591fd172b 100644 --- a/test/660-checker-simd-sad/src/SimdSadByte.java +++ b/test/660-checker-simd-sad/src/SimdSadByte.java @@ -101,14 +101,23 @@ public class SimdSadByte { // /// CHECK-START-ARM64: int SimdSadByte.sadByte2Int(byte[], byte[]) loop_optimization (after) /// CHECK-DAG: <<Cons0:i\d+>> IntConstant 0 loop:none - /// CHECK-DAG: <<Cons16:i\d+>> IntConstant 16 loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Cons0>>] loop:none - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load1>>,<<Load2>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<Cons16>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + // SAD idiom is not supported for SVE. + /// CHECK-NOT: VecSADAccumulate + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Cons16:i\d+>> IntConstant 16 loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Cons0>>] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load1>>,<<Load2>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<Cons16>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static int sadByte2Int(byte[] b1, byte[] b2) { int min_length = Math.min(b1.length, b2.length); int sad = 0; @@ -132,14 +141,23 @@ public class SimdSadByte { // /// CHECK-START-ARM64: int SimdSadByte.sadByte2IntAlt(byte[], byte[]) loop_optimization (after) /// CHECK-DAG: <<Cons0:i\d+>> IntConstant 0 loop:none - /// CHECK-DAG: <<Cons16:i\d+>> IntConstant 16 loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Cons0>>] loop:none - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load2>>,<<Load1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<Cons16>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + // SAD idiom is not supported for SVE. + /// CHECK-NOT: VecSADAccumulate + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Cons16:i\d+>> IntConstant 16 loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Cons0>>] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load2>>,<<Load1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<Cons16>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static int sadByte2IntAlt(byte[] b1, byte[] b2) { int min_length = Math.min(b1.length, b2.length); int sad = 0; @@ -165,14 +183,23 @@ public class SimdSadByte { // /// CHECK-START-ARM64: int SimdSadByte.sadByte2IntAlt2(byte[], byte[]) loop_optimization (after) /// CHECK-DAG: <<Cons0:i\d+>> IntConstant 0 loop:none - /// CHECK-DAG: <<Cons16:i\d+>> IntConstant 16 loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Cons0>>] loop:none - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load1>>,<<Load2>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<Cons16>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + // SAD idiom is not supported for SVE. + /// CHECK-NOT: VecSADAccumulate + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Cons16:i\d+>> IntConstant 16 loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Cons0>>] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load1>>,<<Load2>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<Cons16>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static int sadByte2IntAlt2(byte[] b1, byte[] b2) { int min_length = Math.min(b1.length, b2.length); int sad = 0; @@ -190,6 +217,7 @@ public class SimdSadByte { /// CHECK-DAG: <<Cons0:i\d+>> IntConstant 0 loop:none /// CHECK-DAG: <<Cons1:i\d+>> IntConstant 1 loop:none /// CHECK-DAG: <<ConsL:j\d+>> LongConstant 0 loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none /// CHECK-DAG: <<Phi2:j\d+>> Phi [<<ConsL>>,{{j\d+}}] loop:<<Loop>> outer_loop:none /// CHECK-DAG: <<Get1:b\d+>> ArrayGet [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none @@ -203,15 +231,24 @@ public class SimdSadByte { // /// CHECK-START-ARM64: long SimdSadByte.sadByte2Long(byte[], byte[]) loop_optimization (after) /// CHECK-DAG: <<Cons0:i\d+>> IntConstant 0 loop:none - /// CHECK-DAG: <<Cons16:i\d+>> IntConstant 16 loop:none /// CHECK-DAG: <<ConsL:j\d+>> LongConstant 0 loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<ConsL>>] loop:none - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load1>>,<<Load2>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<Cons16>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + // SAD idiom is not supported for SVE. + /// CHECK-NOT: VecSADAccumulate + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Cons16:i\d+>> IntConstant 16 loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<ConsL>>] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load1>>,<<Load2>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<Cons16>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static long sadByte2Long(byte[] b1, byte[] b2) { int min_length = Math.min(b1.length, b2.length); long sad = 0; @@ -240,15 +277,24 @@ public class SimdSadByte { // /// CHECK-START-ARM64: long SimdSadByte.sadByte2LongAt1(byte[], byte[]) loop_optimization (after) /// CHECK-DAG: <<Cons0:i\d+>> IntConstant 0 loop:none - /// CHECK-DAG: <<Cons16:i\d+>> IntConstant 16 loop:none /// CHECK-DAG: <<ConsL:j\d+>> LongConstant 1 loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<ConsL>>] loop:none - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load1>>,<<Load2>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<Cons16>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + // SAD idiom is not supported for SVE. + /// CHECK-NOT: VecSADAccumulate + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Cons16:i\d+>> IntConstant 16 loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<ConsL>>] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load1>>,<<Load2>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<Cons16>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static long sadByte2LongAt1(byte[] b1, byte[] b2) { int min_length = Math.min(b1.length, b2.length); long sad = 1; // starts at 1 diff --git a/test/660-checker-simd-sad/src/SimdSadInt.java b/test/660-checker-simd-sad/src/SimdSadInt.java index 08cdf9815a..74d87dee60 100644 --- a/test/660-checker-simd-sad/src/SimdSadInt.java +++ b/test/660-checker-simd-sad/src/SimdSadInt.java @@ -31,14 +31,32 @@ public class SimdSadInt { /// CHECK-DAG: Add [<<Phi2>>,<<Intrin>>] loop:<<Loop>> outer_loop:none /// CHECK-DAG: Add [<<Phi1>>,<<Cons1>>] loop:<<Loop>> outer_loop:none // - /// CHECK-START-{ARM,ARM64}: int SimdSadInt.sadInt2Int(int[], int[]) loop_optimization (after) - /// CHECK-DAG: <<Cons:i\d+>> IntConstant {{2|4}} loop:none + /// CHECK-START-ARM: int SimdSadInt.sadInt2Int(int[], int[]) loop_optimization (after) + /// CHECK-DAG: <<Cons:i\d+>> IntConstant 2 loop:none /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [{{i\d+}}] loop:none /// CHECK-DAG: <<Phi:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop:B\d+>> outer_loop:none /// CHECK-DAG: <<Ld1:d\d+>> VecLoad [{{l\d+}},<<I:i\d+>>] loop:<<Loop>> outer_loop:none /// CHECK-DAG: <<Ld2:d\d+>> VecLoad [{{l\d+}},<<I>>] loop:<<Loop>> outer_loop:none /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi>>,<<Ld1>>,<<Ld2>>] loop:<<Loop>> outer_loop:none /// CHECK-DAG: Add [<<I>>,<<Cons>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-START-ARM64: int SimdSadInt.sadInt2Int(int[], int[]) loop_optimization (after) + /// CHECK-IF: hasIsaFeature("sve") + // + // SAD idiom is not supported for SVE. + /// CHECK-NOT: VecSADAccumulate + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Cons:i\d+>> IntConstant 4 loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [{{i\d+}}] loop:none + /// CHECK-DAG: <<Phi:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Ld1:d\d+>> VecLoad [{{l\d+}},<<I:i\d+>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Ld2:d\d+>> VecLoad [{{l\d+}},<<I>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi>>,<<Ld1>>,<<Ld2>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<I>>,<<Cons>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static int sadInt2Int(int[] x, int[] y) { int min_length = Math.min(x.length, y.length); int sad = 0; @@ -88,14 +106,32 @@ public class SimdSadInt { /// CHECK-DAG: Add [<<Phi2>>,<<Intrin>>] loop:<<Loop>> outer_loop:none /// CHECK-DAG: Add [<<Phi1>>,<<Cons1>>] loop:<<Loop>> outer_loop:none // - /// CHECK-START-{ARM,ARM64}: int SimdSadInt.sadInt2IntAlt2(int[], int[]) loop_optimization (after) - /// CHECK-DAG: <<Cons:i\d+>> IntConstant {{2|4}} loop:none + /// CHECK-START-ARM: int SimdSadInt.sadInt2IntAlt2(int[], int[]) loop_optimization (after) + /// CHECK-DAG: <<Cons:i\d+>> IntConstant 2 loop:none /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [{{i\d+}}] loop:none /// CHECK-DAG: <<Phi:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop:B\d+>> outer_loop:none /// CHECK-DAG: <<Ld1:d\d+>> VecLoad [{{l\d+}},<<I:i\d+>>] loop:<<Loop>> outer_loop:none /// CHECK-DAG: <<Ld2:d\d+>> VecLoad [{{l\d+}},<<I>>] loop:<<Loop>> outer_loop:none /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi>>,<<Ld1>>,<<Ld2>>] loop:<<Loop>> outer_loop:none /// CHECK-DAG: Add [<<I>>,<<Cons>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-START-ARM64: int SimdSadInt.sadInt2IntAlt2(int[], int[]) loop_optimization (after) + /// CHECK-IF: hasIsaFeature("sve") + // + // SAD idiom is not supported for SVE. + /// CHECK-NOT: VecSADAccumulate + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Cons:i\d+>> IntConstant 4 loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [{{i\d+}}] loop:none + /// CHECK-DAG: <<Phi:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Ld1:d\d+>> VecLoad [{{l\d+}},<<I:i\d+>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Ld2:d\d+>> VecLoad [{{l\d+}},<<I>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi>>,<<Ld1>>,<<Ld2>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<I>>,<<Cons>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static int sadInt2IntAlt2(int[] x, int[] y) { int min_length = Math.min(x.length, y.length); int sad = 0; @@ -126,15 +162,24 @@ public class SimdSadInt { // /// CHECK-START-ARM64: long SimdSadInt.sadInt2Long(int[], int[]) loop_optimization (after) /// CHECK-DAG: <<Cons0:i\d+>> IntConstant 0 loop:none - /// CHECK-DAG: <<Cons4:i\d+>> IntConstant 4 loop:none /// CHECK-DAG: <<ConsL:j\d+>> LongConstant 0 loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<ConsL>>] loop:none - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load1>>,<<Load2>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<Cons4>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + // SAD idiom is not supported for SVE. + /// CHECK-NOT: VecSADAccumulate + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Cons4:i\d+>> IntConstant 4 loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<ConsL>>] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load1>>,<<Load2>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<Cons4>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static long sadInt2Long(int[] x, int[] y) { int min_length = Math.min(x.length, y.length); long sad = 0; @@ -163,15 +208,24 @@ public class SimdSadInt { // /// CHECK-START-ARM64: long SimdSadInt.sadInt2LongAt1(int[], int[]) loop_optimization (after) /// CHECK-DAG: <<Cons0:i\d+>> IntConstant 0 loop:none - /// CHECK-DAG: <<Cons4:i\d+>> IntConstant 4 loop:none /// CHECK-DAG: <<ConsL:j\d+>> LongConstant 1 loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<ConsL>>] loop:none - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load1>>,<<Load2>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<Cons4>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + // SAD idiom is not supported for SVE. + /// CHECK-NOT: VecSADAccumulate + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Cons4:i\d+>> IntConstant 4 loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<ConsL>>] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load1>>,<<Load2>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<Cons4>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static long sadInt2LongAt1(int[] x, int[] y) { int min_length = Math.min(x.length, y.length); long sad = 1; // starts at 1 diff --git a/test/660-checker-simd-sad/src/SimdSadLong.java b/test/660-checker-simd-sad/src/SimdSadLong.java index 6a059638a5..149fad6803 100644 --- a/test/660-checker-simd-sad/src/SimdSadLong.java +++ b/test/660-checker-simd-sad/src/SimdSadLong.java @@ -34,15 +34,24 @@ public class SimdSadLong { // /// CHECK-START-ARM64: long SimdSadLong.sadLong2Long(long[], long[]) loop_optimization (after) /// CHECK-DAG: <<Cons0:i\d+>> IntConstant 0 loop:none - /// CHECK-DAG: <<Cons2:i\d+>> IntConstant 2 loop:none /// CHECK-DAG: <<ConsL:j\d+>> LongConstant 0 loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<ConsL>>] loop:none - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load1>>,<<Load2>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<Cons2>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + // SAD idiom is not supported for SVE. + /// CHECK-NOT: VecSADAccumulate + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Cons2:i\d+>> IntConstant 2 loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<ConsL>>] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load1>>,<<Load2>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<Cons2>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static long sadLong2Long(long[] x, long[] y) { int min_length = Math.min(x.length, y.length); long sad = 0; @@ -96,15 +105,24 @@ public class SimdSadLong { // /// CHECK-START-ARM64: long SimdSadLong.sadLong2LongAlt2(long[], long[]) loop_optimization (after) /// CHECK-DAG: <<Cons0:i\d+>> IntConstant 0 loop:none - /// CHECK-DAG: <<Cons2:i\d+>> IntConstant 2 loop:none /// CHECK-DAG: <<ConsL:j\d+>> LongConstant 0 loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<ConsL>>] loop:none - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load1>>,<<Load2>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<Cons2>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + // SAD idiom is not supported for SVE. + /// CHECK-NOT: VecSADAccumulate + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Cons2:i\d+>> IntConstant 2 loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<ConsL>>] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load1>>,<<Load2>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<Cons2>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static long sadLong2LongAlt2(long[] x, long[] y) { int min_length = Math.min(x.length, y.length); long sad = 0; @@ -133,15 +151,24 @@ public class SimdSadLong { // /// CHECK-START-ARM64: long SimdSadLong.sadLong2LongAt1(long[], long[]) loop_optimization (after) /// CHECK-DAG: <<Cons0:i\d+>> IntConstant 0 loop:none - /// CHECK-DAG: <<Cons2:i\d+>> IntConstant 2 loop:none /// CHECK-DAG: <<ConsL:j\d+>> LongConstant 1 loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<ConsL>>] loop:none - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load1>>,<<Load2>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<Cons2>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + // SAD idiom is not supported for SVE. + /// CHECK-NOT: VecSADAccumulate + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Cons2:i\d+>> IntConstant 2 loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<ConsL>>] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load1>>,<<Load2>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<Cons2>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static long sadLong2LongAt1(long[] x, long[] y) { int min_length = Math.min(x.length, y.length); long sad = 1; // starts at 1 diff --git a/test/660-checker-simd-sad/src/SimdSadShort.java b/test/660-checker-simd-sad/src/SimdSadShort.java index b6e4a143e3..0f1d08b91e 100644 --- a/test/660-checker-simd-sad/src/SimdSadShort.java +++ b/test/660-checker-simd-sad/src/SimdSadShort.java @@ -72,14 +72,23 @@ public class SimdSadShort { // /// CHECK-START-ARM64: int SimdSadShort.sadShort2Int(short[], short[]) loop_optimization (after) /// CHECK-DAG: <<Cons0:i\d+>> IntConstant 0 loop:none - /// CHECK-DAG: <<Cons8:i\d+>> IntConstant 8 loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Cons0>>] loop:none - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load1>>,<<Load2>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<Cons8>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + // SAD idiom is not supported for SVE. + /// CHECK-NOT: VecSADAccumulate + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Cons8:i\d+>> IntConstant 8 loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Cons0>>] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load1>>,<<Load2>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<Cons8>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static int sadShort2Int(short[] s1, short[] s2) { int min_length = Math.min(s1.length, s2.length); int sad = 0; @@ -103,14 +112,23 @@ public class SimdSadShort { // /// CHECK-START-ARM64: int SimdSadShort.sadShort2IntAlt(short[], short[]) loop_optimization (after) /// CHECK-DAG: <<Cons0:i\d+>> IntConstant 0 loop:none - /// CHECK-DAG: <<Cons8:i\d+>> IntConstant 8 loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Cons0>>] loop:none - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load2>>,<<Load1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<Cons8>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + // SAD idiom is not supported for SVE. + /// CHECK-NOT: VecSADAccumulate + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Cons8:i\d+>> IntConstant 8 loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Cons0>>] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load2>>,<<Load1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<Cons8>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static int sadShort2IntAlt(short[] s1, short[] s2) { int min_length = Math.min(s1.length, s2.length); int sad = 0; @@ -136,14 +154,23 @@ public class SimdSadShort { // /// CHECK-START-ARM64: int SimdSadShort.sadShort2IntAlt2(short[], short[]) loop_optimization (after) /// CHECK-DAG: <<Cons0:i\d+>> IntConstant 0 loop:none - /// CHECK-DAG: <<Cons8:i\d+>> IntConstant 8 loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Cons0>>] loop:none - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load1>>,<<Load2>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<Cons8>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + // SAD idiom is not supported for SVE. + /// CHECK-NOT: VecSADAccumulate + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Cons8:i\d+>> IntConstant 8 loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Cons0>>] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load1>>,<<Load2>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<Cons8>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static int sadShort2IntAlt2(short[] s1, short[] s2) { int min_length = Math.min(s1.length, s2.length); int sad = 0; @@ -173,14 +200,23 @@ public class SimdSadShort { /// CHECK-DAG: <<Cons0:i\d+>> IntConstant 0 loop:none /// CHECK-DAG: <<Cons1:i\d+>> IntConstant 1 loop:none /// CHECK-DAG: <<Cons:i\d+>> IntConstant 7 loop:none - /// CHECK-DAG: <<Cons8:i\d+>> IntConstant 8 loop:none - /// CHECK-DAG: <<Rep:d\d+>> VecReplicateScalar [<<Cons>>] loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Cons0>>] loop:none - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load1>>,<<Rep>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<Cons8>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + // SAD idiom is not supported for SVE. + /// CHECK-NOT: VecSADAccumulate + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Cons8:i\d+>> IntConstant 8 loop:none + /// CHECK-DAG: <<Rep:d\d+>> VecReplicateScalar [<<Cons>>] loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Cons0>>] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load1>>,<<Rep>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<Cons8>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static int sadShort2IntConstant1(short[] s) { int sad = 0; for (int i = 0; i < s.length; i++) { @@ -205,14 +241,23 @@ public class SimdSadShort { /// CHECK-DAG: <<Cons0:i\d+>> IntConstant 0 loop:none /// CHECK-DAG: <<Cons1:i\d+>> IntConstant 1 loop:none /// CHECK-DAG: <<Cons:i\d+>> IntConstant 7 loop:none - /// CHECK-DAG: <<Cons8:i\d+>> IntConstant 8 loop:none - /// CHECK-DAG: <<Rep:d\d+>> VecReplicateScalar [<<Cons>>] loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Cons0>>] loop:none - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load1>>,<<Rep>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<Cons8>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + // SAD idiom is not supported for SVE. + /// CHECK-NOT: VecSADAccumulate + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Cons8:i\d+>> IntConstant 8 loop:none + /// CHECK-DAG: <<Rep:d\d+>> VecReplicateScalar [<<Cons>>] loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Cons0>>] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load1>>,<<Rep>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<Cons8>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static int sadShort2IntConstant2(short[] s) { int sad = 0; for (int i = 0; i < s.length; i++) { @@ -237,14 +282,23 @@ public class SimdSadShort { /// CHECK-DAG: <<Cons0:i\d+>> IntConstant 0 loop:none /// CHECK-DAG: <<Cons1:i\d+>> IntConstant 1 loop:none /// CHECK-DAG: <<Cons:i\d+>> IntConstant -7 loop:none - /// CHECK-DAG: <<Cons8:i\d+>> IntConstant 8 loop:none - /// CHECK-DAG: <<Rep:d\d+>> VecReplicateScalar [<<Cons>>] loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Cons0>>] loop:none - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load1>>,<<Rep>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<Cons8>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + // SAD idiom is not supported for SVE. + /// CHECK-NOT: VecSADAccumulate + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Cons8:i\d+>> IntConstant 8 loop:none + /// CHECK-DAG: <<Rep:d\d+>> VecReplicateScalar [<<Cons>>] loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Cons0>>] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load1>>,<<Rep>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<Cons8>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static int sadShort2IntConstant3(short[] s) { int sad = 0; for (int i = 0; i < s.length; i++) { @@ -270,15 +324,24 @@ public class SimdSadShort { // /// CHECK-START-ARM64: long SimdSadShort.sadShort2Long(short[], short[]) loop_optimization (after) /// CHECK-DAG: <<Cons0:i\d+>> IntConstant 0 loop:none - /// CHECK-DAG: <<Cons8:i\d+>> IntConstant 8 loop:none /// CHECK-DAG: <<ConsL:j\d+>> LongConstant 0 loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<ConsL>>] loop:none - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load1>>,<<Load2>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<Cons8>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + // SAD idiom is not supported for SVE. + /// CHECK-NOT: VecSADAccumulate + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Cons8:i\d+>> IntConstant 8 loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<ConsL>>] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load1>>,<<Load2>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<Cons8>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static long sadShort2Long(short[] s1, short[] s2) { int min_length = Math.min(s1.length, s2.length); long sad = 0; @@ -307,15 +370,24 @@ public class SimdSadShort { // /// CHECK-START-ARM64: long SimdSadShort.sadShort2LongAt1(short[], short[]) loop_optimization (after) /// CHECK-DAG: <<Cons0:i\d+>> IntConstant 0 loop:none - /// CHECK-DAG: <<Cons8:i\d+>> IntConstant 8 loop:none /// CHECK-DAG: <<ConsL:j\d+>> LongConstant 1 loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<ConsL>>] loop:none - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load1>>,<<Load2>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<Cons8>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + // SAD idiom is not supported for SVE. + /// CHECK-NOT: VecSADAccumulate + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Cons8:i\d+>> IntConstant 8 loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<ConsL>>] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load1>>,<<Load2>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<Cons8>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static long sadShort2LongAt1(short[] s1, short[] s2) { int min_length = Math.min(s1.length, s2.length); long sad = 1; // starts at 1 diff --git a/test/660-checker-simd-sad/src/SimdSadShort2.java b/test/660-checker-simd-sad/src/SimdSadShort2.java index b1b5bed0e1..fdc073cb35 100644 --- a/test/660-checker-simd-sad/src/SimdSadShort2.java +++ b/test/660-checker-simd-sad/src/SimdSadShort2.java @@ -86,14 +86,23 @@ public class SimdSadShort2 { // /// CHECK-START-ARM64: int SimdSadShort2.sadCastedChar2Int(char[], char[]) loop_optimization (after) /// CHECK-DAG: <<Cons0:i\d+>> IntConstant 0 loop:none - /// CHECK-DAG: <<Cons8:i\d+>> IntConstant 8 loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Cons0>>] loop:none - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load1>>,<<Load2>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<Cons8>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + // SAD idiom is not supported for SVE. + /// CHECK-NOT: VecSADAccumulate + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Cons8:i\d+>> IntConstant 8 loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Cons0>>] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load1>>,<<Load2>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<Cons8>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static int sadCastedChar2Int(char[] s1, char[] s2) { int min_length = Math.min(s1.length, s2.length); int sad = 0; @@ -134,14 +143,23 @@ public class SimdSadShort2 { // /// CHECK-START-ARM64: int SimdSadShort2.sadCastedChar2IntAlt(char[], char[]) loop_optimization (after) /// CHECK-DAG: <<Cons0:i\d+>> IntConstant 0 loop:none - /// CHECK-DAG: <<Cons8:i\d+>> IntConstant 8 loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Cons0>>] loop:none - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load2>>,<<Load1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<Cons8>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + // SAD idiom is not supported for SVE. + /// CHECK-NOT: VecSADAccumulate + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Cons8:i\d+>> IntConstant 8 loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Cons0>>] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load2>>,<<Load1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<Cons8>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static int sadCastedChar2IntAlt(char[] s1, char[] s2) { int min_length = Math.min(s1.length, s2.length); int sad = 0; @@ -184,14 +202,23 @@ public class SimdSadShort2 { // /// CHECK-START-ARM64: int SimdSadShort2.sadCastedChar2IntAlt2(char[], char[]) loop_optimization (after) /// CHECK-DAG: <<Cons0:i\d+>> IntConstant 0 loop:none - /// CHECK-DAG: <<Cons8:i\d+>> IntConstant 8 loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Cons0>>] loop:none - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load1>>,<<Load2>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<Cons8>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + // SAD idiom is not supported for SVE. + /// CHECK-NOT: VecSADAccumulate + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Cons8:i\d+>> IntConstant 8 loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Cons0>>] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load1>>,<<Load2>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<Cons8>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static int sadCastedChar2IntAlt2(char[] s1, char[] s2) { int min_length = Math.min(s1.length, s2.length); int sad = 0; @@ -241,15 +268,24 @@ public class SimdSadShort2 { // /// CHECK-START-ARM64: long SimdSadShort2.sadCastedChar2Long(char[], char[]) loop_optimization (after) /// CHECK-DAG: <<Cons0:i\d+>> IntConstant 0 loop:none - /// CHECK-DAG: <<Cons8:i\d+>> IntConstant 8 loop:none /// CHECK-DAG: <<ConsL:j\d+>> LongConstant 0 loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<ConsL>>] loop:none - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load1>>,<<Load2>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<Cons8>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + // SAD idiom is not supported for SVE. + /// CHECK-NOT: VecSADAccumulate + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Cons8:i\d+>> IntConstant 8 loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<ConsL>>] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load1>>,<<Load2>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<Cons8>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static long sadCastedChar2Long(char[] s1, char[] s2) { int min_length = Math.min(s1.length, s2.length); long sad = 0; @@ -297,15 +333,24 @@ public class SimdSadShort2 { // /// CHECK-START-ARM64: long SimdSadShort2.sadCastedChar2LongAt1(char[], char[]) loop_optimization (after) /// CHECK-DAG: <<Cons0:i\d+>> IntConstant 0 loop:none - /// CHECK-DAG: <<Cons8:i\d+>> IntConstant 8 loop:none /// CHECK-DAG: <<ConsL:j\d+>> LongConstant 1 loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<ConsL>>] loop:none - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load1>>,<<Load2>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<Cons8>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + // SAD idiom is not supported for SVE. + /// CHECK-NOT: VecSADAccumulate + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Cons8:i\d+>> IntConstant 8 loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<ConsL>>] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load1>>,<<Load2>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<Cons8>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static long sadCastedChar2LongAt1(char[] s1, char[] s2) { int min_length = Math.min(s1.length, s2.length); long sad = 1; // starts at 1 diff --git a/test/660-checker-simd-sad/src/SimdSadShort3.java b/test/660-checker-simd-sad/src/SimdSadShort3.java index bbe35d22b9..597789148f 100644 --- a/test/660-checker-simd-sad/src/SimdSadShort3.java +++ b/test/660-checker-simd-sad/src/SimdSadShort3.java @@ -35,15 +35,24 @@ public class SimdSadShort3 { // /// CHECK-START-ARM64: int SimdSadShort3.sadShort2IntParamRight(short[], short) loop_optimization (after) /// CHECK-DAG: <<Cons0:i\d+>> IntConstant 0 loop:none - /// CHECK-DAG: <<Cons8:i\d+>> IntConstant 8 loop:none /// CHECK-DAG: <<Param:s\d+>> ParameterValue loop:none - /// CHECK-DAG: <<Rep:d\d+>> VecReplicateScalar [<<Param>>] loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Cons0>>] loop:none - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load>>,<<Rep>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<Cons8>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + // SAD idiom is not supported for SVE. + /// CHECK-NOT: VecSADAccumulate + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Cons8:i\d+>> IntConstant 8 loop:none + /// CHECK-DAG: <<Rep:d\d+>> VecReplicateScalar [<<Param>>] loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Cons0>>] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load>>,<<Rep>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<Cons8>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static int sadShort2IntParamRight(short[] s, short param) { int sad = 0; for (int i = 0; i < s.length; i++) { @@ -66,15 +75,24 @@ public class SimdSadShort3 { // /// CHECK-START-ARM64: int SimdSadShort3.sadShort2IntParamLeft(short[], short) loop_optimization (after) /// CHECK-DAG: <<Cons0:i\d+>> IntConstant 0 loop:none - /// CHECK-DAG: <<Cons8:i\d+>> IntConstant 8 loop:none /// CHECK-DAG: <<Param:s\d+>> ParameterValue loop:none - /// CHECK-DAG: <<Rep:d\d+>> VecReplicateScalar [<<Param>>] loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Cons0>>] loop:none - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Rep>>,<<Load>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<Cons8>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + // SAD idiom is not supported for SVE. + /// CHECK-NOT: VecSADAccumulate + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Cons8:i\d+>> IntConstant 8 loop:none + /// CHECK-DAG: <<Rep:d\d+>> VecReplicateScalar [<<Param>>] loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Cons0>>] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Rep>>,<<Load>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<Cons8>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static int sadShort2IntParamLeft(short[] s, short param) { int sad = 0; for (int i = 0; i < s.length; i++) { @@ -97,15 +115,24 @@ public class SimdSadShort3 { // /// CHECK-START-ARM64: int SimdSadShort3.sadShort2IntConstRight(short[]) loop_optimization (after) /// CHECK-DAG: <<Cons0:i\d+>> IntConstant 0 loop:none - /// CHECK-DAG: <<Cons8:i\d+>> IntConstant 8 loop:none /// CHECK-DAG: <<ConsI:i\d+>> IntConstant 32767 loop:none - /// CHECK-DAG: <<Rep:d\d+>> VecReplicateScalar [<<ConsI>>] loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Cons0>>] loop:none - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load>>,<<Rep>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<Cons8>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + // SAD idiom is not supported for SVE. + /// CHECK-NOT: VecSADAccumulate + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Cons8:i\d+>> IntConstant 8 loop:none + /// CHECK-DAG: <<Rep:d\d+>> VecReplicateScalar [<<ConsI>>] loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Cons0>>] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load>>,<<Rep>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<Cons8>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static int sadShort2IntConstRight(short[] s) { int sad = 0; for (int i = 0; i < s.length; i++) { @@ -128,15 +155,24 @@ public class SimdSadShort3 { // /// CHECK-START-ARM64: int SimdSadShort3.sadShort2IntConstLeft(short[]) loop_optimization (after) /// CHECK-DAG: <<Cons0:i\d+>> IntConstant 0 loop:none - /// CHECK-DAG: <<Cons8:i\d+>> IntConstant 8 loop:none /// CHECK-DAG: <<ConsI:i\d+>> IntConstant 32767 loop:none - /// CHECK-DAG: <<Rep:d\d+>> VecReplicateScalar [<<ConsI>>] loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Cons0>>] loop:none - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Rep>>,<<Load>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<Cons8>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + // SAD idiom is not supported for SVE. + /// CHECK-NOT: VecSADAccumulate + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Cons8:i\d+>> IntConstant 8 loop:none + /// CHECK-DAG: <<Rep:d\d+>> VecReplicateScalar [<<ConsI>>] loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Cons0>>] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Rep>>,<<Load>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<Cons8>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static int sadShort2IntConstLeft(short[] s) { int sad = 0; for (int i = 0; i < s.length; i++) { @@ -159,15 +195,24 @@ public class SimdSadShort3 { // /// CHECK-START-ARM64: int SimdSadShort3.sadShort2IntInvariantRight(short[], int) loop_optimization (after) /// CHECK-DAG: <<Cons0:i\d+>> IntConstant 0 loop:none - /// CHECK-DAG: <<Cons8:i\d+>> IntConstant 8 loop:none /// CHECK-DAG: <<Conv:s\d+>> TypeConversion [{{i\d+}}] loop:none - /// CHECK-DAG: <<Rep:d\d+>> VecReplicateScalar [<<Conv>>] loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Cons0>>] loop:none - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load>>,<<Rep>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<Cons8>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + // SAD idiom is not supported for SVE. + /// CHECK-NOT: VecSADAccumulate + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Cons8:i\d+>> IntConstant 8 loop:none + /// CHECK-DAG: <<Rep:d\d+>> VecReplicateScalar [<<Conv>>] loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Cons0>>] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load>>,<<Rep>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<Cons8>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static int sadShort2IntInvariantRight(short[] s, int val) { int sad = 0; short x = (short) (val + 1); @@ -191,15 +236,24 @@ public class SimdSadShort3 { // /// CHECK-START-ARM64: int SimdSadShort3.sadShort2IntInvariantLeft(short[], int) loop_optimization (after) /// CHECK-DAG: <<Cons0:i\d+>> IntConstant 0 loop:none - /// CHECK-DAG: <<Cons8:i\d+>> IntConstant 8 loop:none /// CHECK-DAG: <<Conv:s\d+>> TypeConversion [{{i\d+}}] loop:none - /// CHECK-DAG: <<Rep:d\d+>> VecReplicateScalar [<<Conv>>] loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Cons0>>] loop:none - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Rep>>,<<Load>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<Cons8>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + // SAD idiom is not supported for SVE. + /// CHECK-NOT: VecSADAccumulate + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Cons8:i\d+>> IntConstant 8 loop:none + /// CHECK-DAG: <<Rep:d\d+>> VecReplicateScalar [<<Conv>>] loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Cons0>>] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Rep>>,<<Load>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<Cons8>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static int sadShort2IntInvariantLeft(short[] s, int val) { int sad = 0; short x = (short) (val + 1); @@ -225,16 +279,25 @@ public class SimdSadShort3 { // /// CHECK-START-ARM64: int SimdSadShort3.sadShort2IntCastedExprRight(short[]) loop_optimization (after) /// CHECK-DAG: <<Cons0:i\d+>> IntConstant 0 loop:none - /// CHECK-DAG: <<Cons8:i\d+>> IntConstant 8 loop:none /// CHECK-DAG: <<ConsI:i\d+>> IntConstant 110 loop:none - /// CHECK-DAG: <<Rep:d\d+>> VecReplicateScalar [<<ConsI>>] loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Cons0>>] loop:none - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Add:d\d+>> VecAdd [<<Load>>,<<Rep>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load>>,<<Add>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<Cons8>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + // SAD idiom is not supported for SVE. + /// CHECK-NOT: VecSADAccumulate + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Cons8:i\d+>> IntConstant 8 loop:none + /// CHECK-DAG: <<Rep:d\d+>> VecReplicateScalar [<<ConsI>>] loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Cons0>>] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Add:d\d+>> VecAdd [<<Load>>,<<Rep>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Load>>,<<Add>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<Cons8>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static int sadShort2IntCastedExprRight(short[] s) { int sad = 0; for (int i = 0; i < s.length; i++) { @@ -260,16 +323,25 @@ public class SimdSadShort3 { // /// CHECK-START-ARM64: int SimdSadShort3.sadShort2IntCastedExprLeft(short[]) loop_optimization (after) /// CHECK-DAG: <<Cons0:i\d+>> IntConstant 0 loop:none - /// CHECK-DAG: <<Cons8:i\d+>> IntConstant 8 loop:none /// CHECK-DAG: <<ConsI:i\d+>> IntConstant 110 loop:none - /// CHECK-DAG: <<Rep:d\d+>> VecReplicateScalar [<<ConsI>>] loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Cons0>>] loop:none - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Add:d\d+>> VecAdd [<<Load>>,<<Rep>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Add>>,<<Load>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<Cons8>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + // SAD idiom is not supported for SVE. + /// CHECK-NOT: VecSADAccumulate + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Cons8:i\d+>> IntConstant 8 loop:none + /// CHECK-DAG: <<Rep:d\d+>> VecReplicateScalar [<<ConsI>>] loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Cons0>>] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Cons0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Add:d\d+>> VecAdd [<<Load>>,<<Rep>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<SAD:d\d+>> VecSADAccumulate [<<Phi2>>,<<Add>>,<<Load>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<Cons8>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static int sadShort2IntCastedExprLeft(short[] s) { int sad = 0; for (int i = 0; i < s.length; i++) { diff --git a/test/661-checker-simd-reduc/src/Main.java b/test/661-checker-simd-reduc/src/Main.java index 7c37d918d5..379e83e773 100644 --- a/test/661-checker-simd-reduc/src/Main.java +++ b/test/661-checker-simd-reduc/src/Main.java @@ -62,8 +62,8 @@ public class Main { /// CHECK-DAG: Add [<<Phi1>>,<<Cons1>>] loop:<<Loop>> outer_loop:none /// CHECK-DAG: Return [<<Phi2>>] loop:none // - /// CHECK-START-{ARM,ARM64}: int Main.reductionInt(int[]) loop_optimization (after) - /// CHECK-DAG: <<Cons:i\d+>> IntConstant {{2|4}} loop:none + /// CHECK-START-ARM: int Main.reductionInt(int[]) loop_optimization (after) + /// CHECK-DAG: <<Cons:i\d+>> IntConstant 2 loop:none /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [{{i\d+}}] loop:none /// CHECK-DAG: <<Phi:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop:B\d+>> outer_loop:none /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<I:i\d+>>] loop:<<Loop>> outer_loop:none @@ -72,11 +72,47 @@ public class Main { /// CHECK-DAG: <<Red:d\d+>> VecReduce [<<Phi>>] loop:none /// CHECK-DAG: <<Extr:i\d+>> VecExtractScalar [<<Red>>] loop:none + /// CHECK-START-ARM64: int Main.reductionInt(int[]) loop_optimization (after) + /// CHECK-IF: hasIsaFeature("sve") + // + /// CHECK-DAG: <<TrueC:i\d+>> IntConstant 1 loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [{{i\d+}},{{j\d+}}] loop:none + /// CHECK-DAG: <<Phi:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<LoopP:j\d+>> VecPredWhile loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<I:i\d+>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecAdd [<<Phi>>,<<Load>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<I>>,{{i\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<PostLoopP:j\d+>> VecPredSetAll [<<TrueC>>] loop:none + /// CHECK-DAG: <<Red:d\d+>> VecReduce [<<Phi>>,<<PostLoopP>>] loop:none + /// CHECK-DAG: <<Extr:i\d+>> VecExtractScalar [<<Red>>,<<PostLoopP>>] loop:none + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Cons:i\d+>> IntConstant 4 loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [{{i\d+}}] loop:none + /// CHECK-DAG: <<Phi:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<I:i\d+>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecAdd [<<Phi>>,<<Load>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<I>>,<<Cons>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Red:d\d+>> VecReduce [<<Phi>>] loop:none + /// CHECK-DAG: <<Extr:i\d+>> VecExtractScalar [<<Red>>] loop:none + // + /// CHECK-FI: + // // Check that full 128-bit Q-Register are saved across SuspendCheck slow path. /// CHECK-START-ARM64: int Main.reductionInt(int[]) disassembly (after) - /// CHECK: SuspendCheckSlowPathARM64 - /// CHECK: stur q<<RegNo:\d+>>, [sp, #<<Offset:\d+>>] - /// CHECK: ldur q<<RegNo>>, [sp, #<<Offset>>] + /// CHECK: SuspendCheckSlowPathARM64 + /// CHECK-IF: hasIsaFeature("sve") + // + /// CHECK: str z<<RegNo:\d+>>, + /// CHECK: ldr z<<RegNo>>, + // + /// CHECK-ELSE: + // + /// CHECK: stur q<<RegNo:\d+>>, [sp, #<<Offset:\d+>>] + /// CHECK: ldur q<<RegNo>>, [sp, #<<Offset>>] + // + /// CHECK-FI: private static int reductionInt(int[] x) { int sum = 0; for (int i = 0; i < x.length; i++) { @@ -102,7 +138,7 @@ public class Main { // /// CHECK-EVAL: "<<Loop1>>" != "<<Loop2>>" // - /// CHECK-START-{ARM,ARM64}: int Main.reductionIntChain() loop_optimization (after) + /// CHECK-START-ARM: int Main.reductionIntChain() loop_optimization (after) /// CHECK-DAG: <<Set1:d\d+>> VecSetScalars [{{i\d+}}] loop:none /// CHECK-DAG: <<Phi1:d\d+>> Phi [<<Set1>>,{{d\d+}}] loop:<<Loop1:B\d+>> outer_loop:none /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<I1:i\d+>>] loop:<<Loop1>> outer_loop:none @@ -120,6 +156,47 @@ public class Main { // /// CHECK-EVAL: "<<Loop1>>" != "<<Loop2>>" // + /// CHECK-START-ARM64: int Main.reductionIntChain() loop_optimization (after) + /// CHECK-IF: hasIsaFeature("sve") + // + /// CHECK-DAG: <<Set1:d\d+>> VecSetScalars [{{i\d+}},{{j\d+}}] loop:none + /// CHECK-DAG: <<Phi1:d\d+>> Phi [<<Set1>>,{{d\d+}}] loop:<<Loop1:B\d+>> outer_loop:none + /// CHECK-DAG: <<Loop1P:j\d+>> VecPredWhile loop:<<Loop1>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<I1:i\d+>>,<<Loop1P>>] loop:<<Loop1>> outer_loop:none + /// CHECK-DAG: VecAdd [<<Phi1>>,<<Load1>>,<<Loop1P>>] loop:<<Loop1>> outer_loop:none + /// CHECK-DAG: Add [<<I1>>,{{i\d+}}] loop:<<Loop1>> outer_loop:none + /// CHECK-DAG: <<Red1:d\d+>> VecReduce [<<Phi1>>,{{j\d+}}] loop:none + /// CHECK-DAG: <<Extr1:i\d+>> VecExtractScalar [<<Red1>>,{{j\d+}}] loop:none + /// CHECK-DAG: <<Set2:d\d+>> VecSetScalars [{{i\d+}},{{j\d+}}] loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set2>>,{{d\d+}}] loop:<<Loop2:B\d+>> outer_loop:none + /// CHECK-DAG: <<Loop2P:j\d+>> VecPredWhile loop:<<Loop2>> outer_loop:none + /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<I2:i\d+>>,<<Loop2P>>] loop:<<Loop2>> outer_loop:none + /// CHECK-DAG: VecAdd [<<Phi2>>,<<Load2>>,<<Loop2P>>] loop:<<Loop2>> outer_loop:none + /// CHECK-DAG: Add [<<I2>>,{{i\d+}}] loop:<<Loop2>> outer_loop:none + /// CHECK-DAG: <<Red2:d\d+>> VecReduce [<<Phi2>>,{{j\d+}}] loop:none + /// CHECK-DAG: <<Extr2:i\d+>> VecExtractScalar [<<Red2>>,{{j\d+}}] loop:none + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Set1:d\d+>> VecSetScalars [{{i\d+}}] loop:none + /// CHECK-DAG: <<Phi1:d\d+>> Phi [<<Set1>>,{{d\d+}}] loop:<<Loop1:B\d+>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<I1:i\d+>>] loop:<<Loop1>> outer_loop:none + /// CHECK-DAG: VecAdd [<<Phi1>>,<<Load1>>] loop:<<Loop1>> outer_loop:none + /// CHECK-DAG: Add [<<I1>>,{{i\d+}}] loop:<<Loop1>> outer_loop:none + /// CHECK-DAG: <<Red1:d\d+>> VecReduce [<<Phi1>>] loop:none + /// CHECK-DAG: <<Extr1:i\d+>> VecExtractScalar [<<Red1>>] loop:none + /// CHECK-DAG: <<Set2:d\d+>> VecSetScalars [{{i\d+}}] loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set2>>,{{d\d+}}] loop:<<Loop2:B\d+>> outer_loop:none + /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<I2:i\d+>>] loop:<<Loop2>> outer_loop:none + /// CHECK-DAG: VecAdd [<<Phi2>>,<<Load2>>] loop:<<Loop2>> outer_loop:none + /// CHECK-DAG: Add [<<I2>>,{{i\d+}}] loop:<<Loop2>> outer_loop:none + /// CHECK-DAG: <<Red2:d\d+>> VecReduce [<<Phi2>>] loop:none + /// CHECK-DAG: <<Extr2:i\d+>> VecExtractScalar [<<Red2>>] loop:none + // + /// CHECK-FI: + // + /// CHECK-EVAL: "<<Loop1>>" != "<<Loop2>>" + // // NOTE: pattern is robust with respect to vector loop unrolling and peeling. private static int reductionIntChain() { int[] x = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 }; @@ -146,8 +223,8 @@ public class Main { // /// CHECK-EVAL: "<<Loop1>>" != "<<Loop2>>" // - /// CHECK-START-{ARM,ARM64}: int Main.reductionIntToLoop(int[]) loop_optimization (after) - /// CHECK-DAG: <<Cons:i\d+>> IntConstant {{2|4}} loop:none + /// CHECK-START-ARM: int Main.reductionIntToLoop(int[]) loop_optimization (after) + /// CHECK-DAG: <<Cons:i\d+>> IntConstant 2 loop:none /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [{{i\d+}}] loop:none /// CHECK-DAG: <<Phi:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop1:B\d+>> outer_loop:none /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<I:i\d+>>] loop:<<Loop1>> outer_loop:none @@ -155,6 +232,31 @@ public class Main { /// CHECK-DAG: Add [<<I>>,<<Cons>>] loop:<<Loop1>> outer_loop:none /// CHECK-DAG: <<Red:d\d+>> VecReduce [<<Phi>>] loop:none /// CHECK-DAG: <<Extr:i\d+>> VecExtractScalar [<<Red>>] loop:none + // + /// CHECK-START-ARM64: int Main.reductionIntToLoop(int[]) loop_optimization (after) + /// CHECK-IF: hasIsaFeature("sve") + // + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [{{i\d+}},{{j\d+}}] loop:none + /// CHECK-DAG: <<Phi:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop1:B\d+>> outer_loop:none + /// CHECK-DAG: <<LoopP:j\d+>> VecPredWhile loop:<<Loop1>> + /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<I:i\d+>>,<<LoopP>>] loop:<<Loop1>> outer_loop:none + /// CHECK-DAG: VecAdd [<<Phi>>,<<Load>>,<<LoopP>>] loop:<<Loop1>> outer_loop:none + /// CHECK-DAG: Add [<<I>>,{{i\d+}}] loop:<<Loop1>> outer_loop:none + /// CHECK-DAG: <<Red:d\d+>> VecReduce [<<Phi>>,{{j\d+}}] loop:none + /// CHECK-DAG: <<Extr:i\d+>> VecExtractScalar [<<Red>>,{{j\d+}}] loop:none + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Cons:i\d+>> IntConstant 4 loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [{{i\d+}}] loop:none + /// CHECK-DAG: <<Phi:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop1:B\d+>> outer_loop:none + /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<I:i\d+>>] loop:<<Loop1>> outer_loop:none + /// CHECK-DAG: VecAdd [<<Phi>>,<<Load>>] loop:<<Loop1>> outer_loop:none + /// CHECK-DAG: Add [<<I>>,<<Cons>>] loop:<<Loop1>> outer_loop:none + /// CHECK-DAG: <<Red:d\d+>> VecReduce [<<Phi>>] loop:none + /// CHECK-DAG: <<Extr:i\d+>> VecExtractScalar [<<Red>>] loop:none + // + /// CHECK-FI: private static int reductionIntToLoop(int[] x) { int r = 0; for (int i = 0; i < 8; i++) { @@ -178,14 +280,30 @@ public class Main { /// CHECK-DAG: Return [<<Phi2>>] loop:none // /// CHECK-START-ARM64: long Main.reductionLong(long[]) loop_optimization (after) - /// CHECK-DAG: <<Cons2:i\d+>> IntConstant 2 loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [{{j\d+}}] loop:none - /// CHECK-DAG: <<Phi:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<I:i\d+>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: VecAdd [<<Phi>>,<<Load>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<I>>,<<Cons2>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Red:d\d+>> VecReduce [<<Phi>>] loop:none - /// CHECK-DAG: <<Extr:j\d+>> VecExtractScalar [<<Red>>] loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + /// CHECK-DAG: <<Cons2:i\d+>> IntConstant loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [{{j\d+}},{{j\d+}}] loop:none + /// CHECK-DAG: <<Phi:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Loop1P:j\d+>> VecPredWhile loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<I:i\d+>>,<<Loop1P>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecAdd [<<Phi>>,<<Load>>,<<Loop1P>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<I>>,{{i\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Red:d\d+>> VecReduce [<<Phi>>,{{j\d+}}] loop:none + /// CHECK-DAG: <<Extr:j\d+>> VecExtractScalar [<<Red>>,{{j\d+}}] loop:none + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Cons2:i\d+>> IntConstant 2 loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [{{j\d+}}] loop:none + /// CHECK-DAG: <<Phi:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<I:i\d+>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecAdd [<<Phi>>,<<Load>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<I>>,<<Cons2>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Red:d\d+>> VecReduce [<<Phi>>] loop:none + /// CHECK-DAG: <<Extr:j\d+>> VecExtractScalar [<<Red>>] loop:none + // + /// CHECK-FI: private static long reductionLong(long[] x) { long sum = 0; for (int i = 0; i < x.length; i++) { @@ -229,8 +347,8 @@ public class Main { /// CHECK-DAG: Add [<<Phi1>>,<<Cons1>>] loop:<<Loop>> outer_loop:none /// CHECK-DAG: Return [<<Phi2>>] loop:none // - /// CHECK-START-{ARM,ARM64}: int Main.reductionIntM1(int[]) loop_optimization (after) - /// CHECK-DAG: <<Cons:i\d+>> IntConstant {{2|4}} loop:none + /// CHECK-START-ARM: int Main.reductionIntM1(int[]) loop_optimization (after) + /// CHECK-DAG: <<Cons:i\d+>> IntConstant 2 loop:none /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [{{i\d+}}] loop:none /// CHECK-DAG: <<Phi:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop:B\d+>> outer_loop:none /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<I:i\d+>>] loop:<<Loop>> outer_loop:none @@ -238,6 +356,31 @@ public class Main { /// CHECK-DAG: Add [<<I>>,<<Cons>>] loop:<<Loop>> outer_loop:none /// CHECK-DAG: <<Red:d\d+>> VecReduce [<<Phi>>] loop:none /// CHECK-DAG: <<Extr:i\d+>> VecExtractScalar [<<Red>>] loop:none + // + /// CHECK-START-ARM64: int Main.reductionIntM1(int[]) loop_optimization (after) + /// CHECK-IF: hasIsaFeature("sve") + // + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [{{i\d+}},{{j\d+}}] loop:none + /// CHECK-DAG: <<Phi:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<LoopP:j\d+>> VecPredWhile loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<I:i\d+>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecAdd [<<Phi>>,<<Load>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<I>>,{{i\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Red:d\d+>> VecReduce [<<Phi>>,{{j\d+}}] loop:none + /// CHECK-DAG: <<Extr:i\d+>> VecExtractScalar [<<Red>>,{{j\d+}}] loop:none + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Cons:i\d+>> IntConstant 4 loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [{{i\d+}}] loop:none + /// CHECK-DAG: <<Phi:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<I:i\d+>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecAdd [<<Phi>>,<<Load>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<I>>,<<Cons>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Red:d\d+>> VecReduce [<<Phi>>] loop:none + /// CHECK-DAG: <<Extr:i\d+>> VecExtractScalar [<<Red>>] loop:none + // + /// CHECK-FI: private static int reductionIntM1(int[] x) { int sum = -1; for (int i = 0; i < x.length; i++) { @@ -258,14 +401,29 @@ public class Main { /// CHECK-DAG: Return [<<Phi2>>] loop:none // /// CHECK-START-ARM64: long Main.reductionLongM1(long[]) loop_optimization (after) - /// CHECK-DAG: <<Cons2:i\d+>> IntConstant 2 loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [{{j\d+}}] loop:none - /// CHECK-DAG: <<Phi:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<I:i\d+>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: VecAdd [<<Phi>>,<<Load>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<I>>,<<Cons2>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Red:d\d+>> VecReduce [<<Phi>>] loop:none - /// CHECK-DAG: <<Extr:j\d+>> VecExtractScalar [<<Red>>] loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [{{j\d+}},{{j\d+}}] loop:none + /// CHECK-DAG: <<Phi:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<LoopP:j\d+>> VecPredWhile loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<I:i\d+>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecAdd [<<Phi>>,<<Load>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<I>>,{{i\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Red:d\d+>> VecReduce [<<Phi>>,{{j\d+}}] loop:none + /// CHECK-DAG: <<Extr:j\d+>> VecExtractScalar [<<Red>>,{{j\d+}}] loop:none + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Cons2:i\d+>> IntConstant 2 loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [{{j\d+}}] loop:none + /// CHECK-DAG: <<Phi:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<I:i\d+>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecAdd [<<Phi>>,<<Load>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<I>>,<<Cons2>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Red:d\d+>> VecReduce [<<Phi>>] loop:none + /// CHECK-DAG: <<Extr:j\d+>> VecExtractScalar [<<Red>>] loop:none + // + /// CHECK-FI: private static long reductionLongM1(long[] x) { long sum = -1L; for (int i = 0; i < x.length; i++) { @@ -308,8 +466,8 @@ public class Main { /// CHECK-DAG: Add [<<Phi1>>,<<Cons1>>] loop:<<Loop>> outer_loop:none /// CHECK-DAG: Return [<<Phi2>>] loop:none // - /// CHECK-START-{ARM,ARM64}: int Main.reductionMinusInt(int[]) loop_optimization (after) - /// CHECK-DAG: <<Cons:i\d+>> IntConstant {{2|4}} loop:none + /// CHECK-START-ARM: int Main.reductionMinusInt(int[]) loop_optimization (after) + /// CHECK-DAG: <<Cons:i\d+>> IntConstant 2 loop:none /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [{{i\d+}}] loop:none /// CHECK-DAG: <<Phi:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop:B\d+>> outer_loop:none /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<I:i\d+>>] loop:<<Loop>> outer_loop:none @@ -317,6 +475,31 @@ public class Main { /// CHECK-DAG: Add [<<I>>,<<Cons>>] loop:<<Loop>> outer_loop:none /// CHECK-DAG: <<Red:d\d+>> VecReduce [<<Phi>>] loop:none /// CHECK-DAG: <<Extr:i\d+>> VecExtractScalar [<<Red>>] loop:none + // + /// CHECK-START-ARM64: int Main.reductionMinusInt(int[]) loop_optimization (after) + /// CHECK-IF: hasIsaFeature("sve") + // + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [{{i\d+}},{{j\d+}}] loop:none + /// CHECK-DAG: <<Phi:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<LoopP:j\d+>> VecPredWhile loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<I:i\d+>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecSub [<<Phi>>,<<Load>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<I>>,{{i\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Red:d\d+>> VecReduce [<<Phi>>,{{j\d+}}] loop:none + /// CHECK-DAG: <<Extr:i\d+>> VecExtractScalar [<<Red>>,{{j\d+}}] loop:none + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Cons:i\d+>> IntConstant 4 loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [{{i\d+}}] loop:none + /// CHECK-DAG: <<Phi:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<I:i\d+>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecSub [<<Phi>>,<<Load>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<I>>,<<Cons>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Red:d\d+>> VecReduce [<<Phi>>] loop:none + /// CHECK-DAG: <<Extr:i\d+>> VecExtractScalar [<<Red>>] loop:none + // + /// CHECK-FI: private static int reductionMinusInt(int[] x) { int sum = 0; for (int i = 0; i < x.length; i++) { @@ -337,14 +520,29 @@ public class Main { /// CHECK-DAG: Return [<<Phi2>>] loop:none // /// CHECK-START-ARM64: long Main.reductionMinusLong(long[]) loop_optimization (after) - /// CHECK-DAG: <<Cons2:i\d+>> IntConstant 2 loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [{{j\d+}}] loop:none - /// CHECK-DAG: <<Phi:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<I:i\d+>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: VecSub [<<Phi>>,<<Load>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<I>>,<<Cons2>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Red:d\d+>> VecReduce [<<Phi>>] loop:none - /// CHECK-DAG: <<Extr:j\d+>> VecExtractScalar [<<Red>>] loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [{{j\d+}},{{j\d+}}] loop:none + /// CHECK-DAG: <<Phi:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<LoopP:j\d+>> VecPredWhile loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<I:i\d+>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecSub [<<Phi>>,<<Load>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<I>>,{{i\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Red:d\d+>> VecReduce [<<Phi>>,{{j\d+}}] loop:none + /// CHECK-DAG: <<Extr:j\d+>> VecExtractScalar [<<Red>>,{{j\d+}}] loop:none + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Cons2:i\d+>> IntConstant 2 loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [{{j\d+}}] loop:none + /// CHECK-DAG: <<Phi:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<I:i\d+>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecSub [<<Phi>>,<<Load>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<I>>,<<Cons2>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Red:d\d+>> VecReduce [<<Phi>>] loop:none + /// CHECK-DAG: <<Extr:j\d+>> VecExtractScalar [<<Red>>] loop:none + // + /// CHECK-FI: private static long reductionMinusLong(long[] x) { long sum = 0; for (int i = 0; i < x.length; i++) { diff --git a/test/665-checker-simd-zero/src/Main.java b/test/665-checker-simd-zero/src/Main.java index 66eea642a4..3960c40bcc 100644 --- a/test/665-checker-simd-zero/src/Main.java +++ b/test/665-checker-simd-zero/src/Main.java @@ -26,9 +26,19 @@ public class Main { // /// CHECK-START-ARM64: void Main.zeroz(boolean[]) loop_optimization (after) /// CHECK-DAG: <<Zero:i\d+>> IntConstant 0 loop:none - /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Zero>>] loop:none - /// CHECK-DAG: <<Phi:i\d+>> Phi loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: VecStore [{{l\d+}},<<Phi>>,<<Repl>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Zero>>,{{j\d+}}] loop:none + /// CHECK-DAG: <<Phi:i\d+>> Phi loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},<<Phi>>,<<Repl>>,{{j\d+}}] loop:<<Loop>> outer_loop:none + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Zero>>] loop:none + /// CHECK-DAG: <<Phi:i\d+>> Phi loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},<<Phi>>,<<Repl>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static void zeroz(boolean[] x) { for (int i = 0; i < x.length; i++) { x[i] = false; @@ -42,9 +52,19 @@ public class Main { // /// CHECK-START-ARM64: void Main.zerob(byte[]) loop_optimization (after) /// CHECK-DAG: <<Zero:i\d+>> IntConstant 0 loop:none - /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Zero>>] loop:none - /// CHECK-DAG: <<Phi:i\d+>> Phi loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: VecStore [{{l\d+}},<<Phi>>,<<Repl>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Zero>>,{{j\d+}}] loop:none + /// CHECK-DAG: <<Phi:i\d+>> Phi loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},<<Phi>>,<<Repl>>,{{j\d+}}] loop:<<Loop>> outer_loop:none + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Zero>>] loop:none + /// CHECK-DAG: <<Phi:i\d+>> Phi loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},<<Phi>>,<<Repl>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static void zerob(byte[] x) { for (int i = 0; i < x.length; i++) { x[i] = 0; @@ -58,9 +78,19 @@ public class Main { // /// CHECK-START-ARM64: void Main.zeroc(char[]) loop_optimization (after) /// CHECK-DAG: <<Zero:i\d+>> IntConstant 0 loop:none - /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Zero>>] loop:none - /// CHECK-DAG: <<Phi:i\d+>> Phi loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: VecStore [{{l\d+}},<<Phi>>,<<Repl>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Zero>>,{{j\d+}}] loop:none + /// CHECK-DAG: <<Phi:i\d+>> Phi loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},<<Phi>>,<<Repl>>,{{j\d+}}] loop:<<Loop>> outer_loop:none + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Zero>>] loop:none + /// CHECK-DAG: <<Phi:i\d+>> Phi loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},<<Phi>>,<<Repl>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static void zeroc(char[] x) { for (int i = 0; i < x.length; i++) { x[i] = 0; @@ -74,9 +104,19 @@ public class Main { // /// CHECK-START-ARM64: void Main.zeros(short[]) loop_optimization (after) /// CHECK-DAG: <<Zero:i\d+>> IntConstant 0 loop:none - /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Zero>>] loop:none - /// CHECK-DAG: <<Phi:i\d+>> Phi loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: VecStore [{{l\d+}},<<Phi>>,<<Repl>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Zero>>,{{j\d+}}] loop:none + /// CHECK-DAG: <<Phi:i\d+>> Phi loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},<<Phi>>,<<Repl>>,{{j\d+}}] loop:<<Loop>> outer_loop:none + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Zero>>] loop:none + /// CHECK-DAG: <<Phi:i\d+>> Phi loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},<<Phi>>,<<Repl>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static void zeros(short[] x) { for (int i = 0; i < x.length; i++) { x[i] = 0; @@ -90,9 +130,19 @@ public class Main { // /// CHECK-START-ARM64: void Main.zeroi(int[]) loop_optimization (after) /// CHECK-DAG: <<Zero:i\d+>> IntConstant 0 loop:none - /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Zero>>] loop:none - /// CHECK-DAG: <<Phi:i\d+>> Phi loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: VecStore [{{l\d+}},<<Phi>>,<<Repl>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Zero>>,{{j\d+}}] loop:none + /// CHECK-DAG: <<Phi:i\d+>> Phi loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},<<Phi>>,<<Repl>>,{{j\d+}}] loop:<<Loop>> outer_loop:none + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Zero>>] loop:none + /// CHECK-DAG: <<Phi:i\d+>> Phi loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},<<Phi>>,<<Repl>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static void zeroi(int[] x) { for (int i = 0; i < x.length; i++) { x[i] = 0; @@ -106,9 +156,19 @@ public class Main { // /// CHECK-START-ARM64: void Main.zerol(long[]) loop_optimization (after) /// CHECK-DAG: <<Zero:j\d+>> LongConstant 0 loop:none - /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Zero>>] loop:none - /// CHECK-DAG: <<Phi:i\d+>> Phi loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: VecStore [{{l\d+}},<<Phi>>,<<Repl>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Zero>>,{{j\d+}}] loop:none + /// CHECK-DAG: <<Phi:i\d+>> Phi loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},<<Phi>>,<<Repl>>,{{j\d+}}] loop:<<Loop>> outer_loop:none + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Zero>>] loop:none + /// CHECK-DAG: <<Phi:i\d+>> Phi loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},<<Phi>>,<<Repl>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static void zerol(long[] x) { for (int i = 0; i < x.length; i++) { x[i] = 0; @@ -122,9 +182,19 @@ public class Main { // /// CHECK-START-ARM64: void Main.zerof(float[]) loop_optimization (after) /// CHECK-DAG: <<Zero:f\d+>> FloatConstant 0 loop:none - /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Zero>>] loop:none - /// CHECK-DAG: <<Phi:i\d+>> Phi loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: VecStore [{{l\d+}},<<Phi>>,<<Repl>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Zero>>,{{j\d+}}] loop:none + /// CHECK-DAG: <<Phi:i\d+>> Phi loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},<<Phi>>,<<Repl>>,{{j\d+}}] loop:<<Loop>> outer_loop:none + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Zero>>] loop:none + /// CHECK-DAG: <<Phi:i\d+>> Phi loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},<<Phi>>,<<Repl>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static void zerof(float[] x) { for (int i = 0; i < x.length; i++) { x[i] = 0; @@ -138,9 +208,19 @@ public class Main { // /// CHECK-START-ARM64: void Main.zerod(double[]) loop_optimization (after) /// CHECK-DAG: <<Zero:d\d+>> DoubleConstant 0 loop:none - /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Zero>>] loop:none - /// CHECK-DAG: <<Phi:i\d+>> Phi loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: VecStore [{{l\d+}},<<Phi>>,<<Repl>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Zero>>,{{j\d+}}] loop:none + /// CHECK-DAG: <<Phi:i\d+>> Phi loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},<<Phi>>,<<Repl>>,{{j\d+}}] loop:<<Loop>> outer_loop:none + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Zero>>] loop:none + /// CHECK-DAG: <<Phi:i\d+>> Phi loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: VecStore [{{l\d+}},<<Phi>>,<<Repl>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: private static void zerod(double[] x) { for (int i = 0; i < x.length; i++) { x[i] = 0; diff --git a/test/669-checker-break/src/Main.java b/test/669-checker-break/src/Main.java index c40e4a635e..9f7b24ebbb 100644 --- a/test/669-checker-break/src/Main.java +++ b/test/669-checker-break/src/Main.java @@ -50,11 +50,22 @@ public class Main { /// CHECK-START-ARM64: int Main.breakLoop(int[]) loop_optimization (after) /// CHECK-DAG: <<Par:l\d+>> ParameterValue loop:none /// CHECK-DAG: <<One:i\d+>> IntConstant 1 loop:none - /// CHECK-DAG: <<Four:i\d+>> IntConstant 4 loop:none /// CHECK-DAG: <<Nil:l\d+>> NullCheck [<<Par>>] loop:none - /// CHECK-DAG: <<Rep:d\d+>> VecReplicateScalar [<<One>>] loop:none - /// CHECK-DAG: VecStore [<<Nil>>,<<Phi:i\d+>>,<<Rep>>] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: Add [<<Phi>>,<<Four>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + /// CHECK-DAG: <<Rep:d\d+>> VecReplicateScalar [<<One>>,{{j\d+}}] loop:none + /// CHECK-DAG: <<LoopP:j\d+>> VecPredWhile loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: VecStore [<<Nil>>,<<Phi:i\d+>>,<<Rep>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi>>,{{i\d+}}] loop:<<Loop>> outer_loop:none + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Four:i\d+>> IntConstant 4 loop:none + /// CHECK-DAG: <<Rep:d\d+>> VecReplicateScalar [<<One>>] loop:none + /// CHECK-DAG: VecStore [<<Nil>>,<<Phi:i\d+>>,<<Rep>>] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: Add [<<Phi>>,<<Four>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: static int breakLoop(int[] a) { int l = 0; int u = a.length - 1; @@ -141,10 +152,21 @@ public class Main { /// CHECK-DAG: <<Par:l\d+>> ParameterValue loop:none /// CHECK-DAG: <<One:i\d+>> IntConstant 1 loop:none /// CHECK-DAG: <<Three:i\d+>> IntConstant 3 loop:none - /// CHECK-DAG: <<Four:i\d+>> IntConstant 4 loop:none - /// CHECK-DAG: <<Rep:d\d+>> VecReplicateScalar [<<Three>>] loop:none - /// CHECK-DAG: VecStore [<<Par>>,<<Phi:i\d+>>,<<Rep>>] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: Add [<<Phi>>,<<Four>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + /// CHECK-DAG: <<Rep:d\d+>> VecReplicateScalar [<<Three>>,{{j\d+}}] loop:none + /// CHECK-DAG: <<LoopP:j\d+>> VecPredWhile loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: VecStore [<<Par>>,<<Phi:i\d+>>,<<Rep>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi>>,{{i\d+}}] loop:<<Loop>> outer_loop:none + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Four:i\d+>> IntConstant 4 loop:none + /// CHECK-DAG: <<Rep:d\d+>> VecReplicateScalar [<<Three>>] loop:none + /// CHECK-DAG: VecStore [<<Par>>,<<Phi:i\d+>>,<<Rep>>] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: Add [<<Phi>>,<<Four>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: static int breakLoopSafeConst(int[] a) { int l = Integer.MAX_VALUE - 16; int u = Integer.MAX_VALUE - 1; @@ -262,10 +284,22 @@ public class Main { /// CHECK-START-ARM64: int Main.breakLoopReduction(int[]) loop_optimization (after) /// CHECK-DAG: <<Par:l\d+>> ParameterValue loop:none /// CHECK-DAG: <<Zero:i\d+>> IntConstant 0 loop:none - /// CHECK-DAG: <<Exp:d\d+>> VecSetScalars [<<Zero>>] loop:none - /// CHECK-DAG: <<VPhi:d\d+>> Phi [<<Exp>>,<<VAdd:d\d+>>] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<VLoad:d\d+>> VecLoad loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<VAdd>> VecAdd [<<VPhi>>,<<VLoad>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + /// CHECK-DAG: <<Exp:d\d+>> VecSetScalars [<<Zero>>,{{j\d+}}] loop:none + /// CHECK-DAG: <<LoopP:j\d+>> VecPredWhile loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<VPhi:d\d+>> Phi [<<Exp>>,<<VAdd:d\d+>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<VLoad:d\d+>> VecLoad loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<VAdd>> VecAdd [<<VPhi>>,<<VLoad>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Exp:d\d+>> VecSetScalars [<<Zero>>] loop:none + /// CHECK-DAG: <<VPhi:d\d+>> Phi [<<Exp>>,<<VAdd:d\d+>>] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<VLoad:d\d+>> VecLoad loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<VAdd>> VecAdd [<<VPhi>>,<<VLoad>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: static int breakLoopReduction(int[] a) { int l = 0; int u = a.length - 1; diff --git a/test/684-checker-simd-dotprod/src/other/TestByte.java b/test/684-checker-simd-dotprod/src/other/TestByte.java index 608d0215ce..1d5e811f14 100644 --- a/test/684-checker-simd-dotprod/src/other/TestByte.java +++ b/test/684-checker-simd-dotprod/src/other/TestByte.java @@ -37,22 +37,42 @@ public class TestByte { /// CHECK-START-ARM64: int other.TestByte.testDotProdSimple(byte[], byte[]) loop_optimization (after) /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 loop:none /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 loop:none - /// CHECK-DAG: <<Const16:i\d+>> IntConstant 16 loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Const1>>] loop:none - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: VecDotProd [<<Phi2>>,<<Load1>>,<<Load2>>] type:Int8 loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<Const16>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Const1>>,{{j\d+}}] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<LoopP:j\d+>> VecPredWhile [<<Phi1>>,{{i\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecDotProd [<<Phi2>>,<<Load1>>,<<Load2>>,<<LoopP>>] type:Int8 loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,{{i\d+}}] loop:<<Loop>> outer_loop:none + // + /// CHECK-DAG: <<Reduce:d\d+>> VecReduce [<<Phi2>>,{{j\d+}}] loop:none + /// CHECK-DAG: VecExtractScalar [<<Reduce>>,{{j\d+}}] loop:none + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Const16:i\d+>> IntConstant 16 loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Const1>>] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecDotProd [<<Phi2>>,<<Load1>>,<<Load2>>] type:Int8 loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<Const16>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-DAG: <<Reduce:d\d+>> VecReduce [<<Phi2>>] loop:none + /// CHECK-DAG: VecExtractScalar [<<Reduce>>] loop:none // - /// CHECK-DAG: <<Reduce:d\d+>> VecReduce [<<Phi2>>] loop:none - /// CHECK-DAG: VecExtractScalar [<<Reduce>>] loop:none + /// CHECK-FI: /// CHECK-START-ARM64: int other.TestByte.testDotProdSimple(byte[], byte[]) disassembly (after) /// CHECK: VecDotProd - /// CHECK-IF: hasIsaFeature("dotprod") + /// CHECK-IF: hasIsaFeature("sve") + /// CHECK: sdot z{{\d+}}.s, z{{\d+}}.b, z{{\d+}}.b + /// CHECK-ELIF: hasIsaFeature("dotprod") /// CHECK-NEXT: sdot v{{\d+}}.4s, v{{\d+}}.16b, v{{\d+}}.16b /// CHECK-ELSE: /// CHECK-NOT: sdot @@ -85,20 +105,41 @@ public class TestByte { /// CHECK-START-ARM64: int other.TestByte.testDotProdComplex(byte[], byte[]) loop_optimization (after) /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 loop:none /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 loop:none - /// CHECK-DAG: <<Const16:i\d+>> IntConstant 16 loop:none - /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Const1>>] loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Const1>>] loop:none - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<VAdd1:d\d+>> VecAdd [<<Load1>>,<<Repl>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<VAdd2:d\d+>> VecAdd [<<Load2>>,<<Repl>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: VecDotProd [<<Phi2>>,<<VAdd1>>,<<VAdd2>>] type:Int8 loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<Const16>>] loop:<<Loop>> outer_loop:none - // - /// CHECK-DAG: <<Reduce:d\d+>> VecReduce [<<Phi2>>] loop:none - /// CHECK-DAG: VecExtractScalar [<<Reduce>>] loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Const1>>,{{j\d+}}] loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Const1>>,{{j\d+}}] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<LoopP:j\d+>> VecPredWhile [<<Phi1>>,{{i\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<VAdd1:d\d+>> VecAdd [<<Load1>>,<<Repl>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<VAdd2:d\d+>> VecAdd [<<Load2>>,<<Repl>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecDotProd [<<Phi2>>,<<VAdd1>>,<<VAdd2>>,<<LoopP>>] type:Int8 loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,{{i\d+}}] loop:<<Loop>> outer_loop:none + // + /// CHECK-DAG: <<Reduce:d\d+>> VecReduce [<<Phi2>>,{{j\d+}}] loop:none + /// CHECK-DAG: VecExtractScalar [<<Reduce>>,{{j\d+}}] loop:none + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Const16:i\d+>> IntConstant 16 loop:none + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Const1>>] loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Const1>>] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<VAdd1:d\d+>> VecAdd [<<Load1>>,<<Repl>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<VAdd2:d\d+>> VecAdd [<<Load2>>,<<Repl>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecDotProd [<<Phi2>>,<<VAdd1>>,<<VAdd2>>] type:Int8 loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<Const16>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-DAG: <<Reduce:d\d+>> VecReduce [<<Phi2>>] loop:none + /// CHECK-DAG: VecExtractScalar [<<Reduce>>] loop:none + // + /// CHECK-FI: public static final int testDotProdComplex(byte[] a, byte[] b) { int s = 1; for (int i = 0; i < b.length; i++) { @@ -122,21 +163,41 @@ public class TestByte { /// CHECK-START-ARM64: int other.TestByte.testDotProdSimpleUnsigned(byte[], byte[]) loop_optimization (after) /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 loop:none /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 loop:none - /// CHECK-DAG: <<Const16:i\d+>> IntConstant 16 loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Const1>>] loop:none - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: VecDotProd [<<Phi2>>,<<Load1>>,<<Load2>>] type:Uint8 loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<Const16>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Const1>>,{{j\d+}}] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<LoopP:j\d+>> VecPredWhile [<<Phi1>>,{{i\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecDotProd [<<Phi2>>,<<Load1>>,<<Load2>>,<<LoopP>>] type:Uint8 loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,{{i\d+}}] loop:<<Loop>> outer_loop:none + // + /// CHECK-DAG: <<Reduce:d\d+>> VecReduce [<<Phi2>>,{{j\d+}}] loop:none + /// CHECK-DAG: VecExtractScalar [<<Reduce>>,{{j\d+}}] loop:none // - /// CHECK-DAG: <<Reduce:d\d+>> VecReduce [<<Phi2>>] loop:none - /// CHECK-DAG: VecExtractScalar [<<Reduce>>] loop:none + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Const16:i\d+>> IntConstant 16 loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Const1>>] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecDotProd [<<Phi2>>,<<Load1>>,<<Load2>>] type:Uint8 loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<Const16>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-DAG: <<Reduce:d\d+>> VecReduce [<<Phi2>>] loop:none + /// CHECK-DAG: VecExtractScalar [<<Reduce>>] loop:none + // + /// CHECK-FI: /// CHECK-START-ARM64: int other.TestByte.testDotProdSimpleUnsigned(byte[], byte[]) disassembly (after) /// CHECK: VecDotProd - /// CHECK-IF: hasIsaFeature("dotprod") + /// CHECK-IF: hasIsaFeature("sve") + /// CHECK: udot z{{\d+}}.s, z{{\d+}}.b, z{{\d+}}.b + /// CHECK-ELIF: hasIsaFeature("dotprod") /// CHECK-NEXT: udot v{{\d+}}.4s, v{{\d+}}.16b, v{{\d+}}.16b /// CHECK-ELSE: /// CHECK-NOT: sdot @@ -169,20 +230,41 @@ public class TestByte { /// CHECK-START-ARM64: int other.TestByte.testDotProdComplexUnsigned(byte[], byte[]) loop_optimization (after) /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 loop:none /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 loop:none - /// CHECK-DAG: <<Const16:i\d+>> IntConstant 16 loop:none - /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Const1>>] loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Const1>>] loop:none - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<VAdd1:d\d+>> VecAdd [<<Load1>>,<<Repl>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<VAdd2:d\d+>> VecAdd [<<Load2>>,<<Repl>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: VecDotProd [<<Phi2>>,<<VAdd1>>,<<VAdd2>>] type:Uint8 loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<Const16>>] loop:<<Loop>> outer_loop:none - // - /// CHECK-DAG: <<Reduce:d\d+>> VecReduce [<<Phi2>>] loop:none - /// CHECK-DAG: VecExtractScalar [<<Reduce>>] loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Const1>>,{{j\d+}}] loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Const1>>,{{j\d+}}] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<LoopP:j\d+>> VecPredWhile [<<Phi1>>,{{i\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<VAdd1:d\d+>> VecAdd [<<Load1>>,<<Repl>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<VAdd2:d\d+>> VecAdd [<<Load2>>,<<Repl>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecDotProd [<<Phi2>>,<<VAdd1>>,<<VAdd2>>,<<LoopP>>] type:Uint8 loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,{{i\d+}}] loop:<<Loop>> outer_loop:none + // + /// CHECK-DAG: <<Reduce:d\d+>> VecReduce [<<Phi2>>,{{j\d+}}] loop:none + /// CHECK-DAG: VecExtractScalar [<<Reduce>>,{{j\d+}}] loop:none + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Const16:i\d+>> IntConstant 16 loop:none + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Const1>>] loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Const1>>] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<VAdd1:d\d+>> VecAdd [<<Load1>>,<<Repl>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<VAdd2:d\d+>> VecAdd [<<Load2>>,<<Repl>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecDotProd [<<Phi2>>,<<VAdd1>>,<<VAdd2>>] type:Uint8 loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<Const16>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-DAG: <<Reduce:d\d+>> VecReduce [<<Phi2>>] loop:none + /// CHECK-DAG: VecExtractScalar [<<Reduce>>] loop:none + // + /// CHECK-FI: public static final int testDotProdComplexUnsigned(byte[] a, byte[] b) { int s = 1; for (int i = 0; i < b.length; i++) { @@ -210,20 +292,41 @@ public class TestByte { /// CHECK-START-ARM64: int other.TestByte.testDotProdComplexUnsignedCastedToSigned(byte[], byte[]) loop_optimization (after) /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 loop:none /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 loop:none - /// CHECK-DAG: <<Const16:i\d+>> IntConstant 16 loop:none - /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Const1>>] loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Const1>>] loop:none - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<VAdd1:d\d+>> VecAdd [<<Load1>>,<<Repl>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<VAdd2:d\d+>> VecAdd [<<Load2>>,<<Repl>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: VecDotProd [<<Phi2>>,<<VAdd1>>,<<VAdd2>>] type:Int8 loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<Const16>>] loop:<<Loop>> outer_loop:none - // - /// CHECK-DAG: <<Reduce:d\d+>> VecReduce [<<Phi2>>] loop:none - /// CHECK-DAG: VecExtractScalar [<<Reduce>>] loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Const1>>,{{j\d+}}] loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Const1>>,{{j\d+}}] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<LoopP:j\d+>> VecPredWhile [<<Phi1>>,{{i\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<VAdd1:d\d+>> VecAdd [<<Load1>>,<<Repl>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<VAdd2:d\d+>> VecAdd [<<Load2>>,<<Repl>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecDotProd [<<Phi2>>,<<VAdd1>>,<<VAdd2>>,<<LoopP>>] type:Int8 loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,{{i\d+}}] loop:<<Loop>> outer_loop:none + // + /// CHECK-DAG: <<Reduce:d\d+>> VecReduce [<<Phi2>>,{{j\d+}}] loop:none + /// CHECK-DAG: VecExtractScalar [<<Reduce>>,{{j\d+}}] loop:none + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Const16:i\d+>> IntConstant 16 loop:none + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Const1>>] loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Const1>>] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<VAdd1:d\d+>> VecAdd [<<Load1>>,<<Repl>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<VAdd2:d\d+>> VecAdd [<<Load2>>,<<Repl>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecDotProd [<<Phi2>>,<<VAdd1>>,<<VAdd2>>] type:Int8 loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<Const16>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-DAG: <<Reduce:d\d+>> VecReduce [<<Phi2>>] loop:none + /// CHECK-DAG: VecExtractScalar [<<Reduce>>] loop:none + // + /// CHECK-FI: public static final int testDotProdComplexUnsignedCastedToSigned(byte[] a, byte[] b) { int s = 1; for (int i = 0; i < b.length; i++) { @@ -251,20 +354,41 @@ public class TestByte { /// CHECK-START-ARM64: int other.TestByte.testDotProdComplexSignedCastedToUnsigned(byte[], byte[]) loop_optimization (after) /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 loop:none /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 loop:none - /// CHECK-DAG: <<Const16:i\d+>> IntConstant 16 loop:none - /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Const1>>] loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Const1>>] loop:none - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<VAdd1:d\d+>> VecAdd [<<Load1>>,<<Repl>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<VAdd2:d\d+>> VecAdd [<<Load2>>,<<Repl>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: VecDotProd [<<Phi2>>,<<VAdd1>>,<<VAdd2>>] type:Uint8 loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<Const16>>] loop:<<Loop>> outer_loop:none - // - /// CHECK-DAG: <<Reduce:d\d+>> VecReduce [<<Phi2>>] loop:none - /// CHECK-DAG: VecExtractScalar [<<Reduce>>] loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Const1>>,{{j\d+}}] loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Const1>>,{{j\d+}}] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<LoopP:j\d+>> VecPredWhile [<<Phi1>>,{{i\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<VAdd1:d\d+>> VecAdd [<<Load1>>,<<Repl>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<VAdd2:d\d+>> VecAdd [<<Load2>>,<<Repl>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecDotProd [<<Phi2>>,<<VAdd1>>,<<VAdd2>>,<<LoopP>>] type:Uint8 loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,{{i\d+}}] loop:<<Loop>> outer_loop:none + // + /// CHECK-DAG: <<Reduce:d\d+>> VecReduce [<<Phi2>>,{{j\d+}}] loop:none + /// CHECK-DAG: VecExtractScalar [<<Reduce>>,{{j\d+}}] loop:none + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Const16:i\d+>> IntConstant 16 loop:none + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Const1>>] loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Const1>>] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<VAdd1:d\d+>> VecAdd [<<Load1>>,<<Repl>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<VAdd2:d\d+>> VecAdd [<<Load2>>,<<Repl>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecDotProd [<<Phi2>>,<<VAdd1>>,<<VAdd2>>] type:Uint8 loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<Const16>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-DAG: <<Reduce:d\d+>> VecReduce [<<Phi2>>] loop:none + /// CHECK-DAG: VecExtractScalar [<<Reduce>>] loop:none + // + /// CHECK-FI: public static final int testDotProdComplexSignedCastedToUnsigned(byte[] a, byte[] b) { int s = 1; for (int i = 0; i < b.length; i++) { diff --git a/test/684-checker-simd-dotprod/src/other/TestCharShort.java b/test/684-checker-simd-dotprod/src/other/TestCharShort.java index 9cb9db59b3..07a79607d1 100644 --- a/test/684-checker-simd-dotprod/src/other/TestCharShort.java +++ b/test/684-checker-simd-dotprod/src/other/TestCharShort.java @@ -37,17 +37,26 @@ public class TestCharShort { /// CHECK-START-{ARM64}: int other.TestCharShort.testDotProdSimple(short[], short[]) loop_optimization (after) /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 loop:none /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 loop:none - /// CHECK-DAG: <<Const8:i\d+>> IntConstant 8 loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Const1>>] loop:none - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: VecDotProd [<<Phi2>>,<<Load1>>,<<Load2>>] type:Int16 loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<Const8>>] loop:<<Loop>> outer_loop:none - // - /// CHECK-DAG: <<Reduce:d\d+>> VecReduce [<<Phi2>>] loop:none - /// CHECK-DAG: VecExtractScalar [<<Reduce>>] loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + // 16-bit DotProd is not supported for SVE. + /// CHECK-NOT: VecDotProd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Const8:i\d+>> IntConstant 8 loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Const1>>] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecDotProd [<<Phi2>>,<<Load1>>,<<Load2>>] type:Int16 loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<Const8>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-DAG: <<Reduce:d\d+>> VecReduce [<<Phi2>>] loop:none + /// CHECK-DAG: VecExtractScalar [<<Reduce>>] loop:none + // + /// CHECK-FI: public static final int testDotProdSimple(short[] a, short[] b) { int s = 1; for (int i = 0; i < b.length; i++) { @@ -75,20 +84,29 @@ public class TestCharShort { /// CHECK-START-{ARM64}: int other.TestCharShort.testDotProdComplex(short[], short[]) loop_optimization (after) /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 loop:none /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 loop:none - /// CHECK-DAG: <<Const8:i\d+>> IntConstant 8 loop:none - /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Const1>>] loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Const1>>] loop:none - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<VAdd1:d\d+>> VecAdd [<<Load1>>,<<Repl>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<VAdd2:d\d+>> VecAdd [<<Load2>>,<<Repl>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: VecDotProd [<<Phi2>>,<<VAdd1>>,<<VAdd2>>] type:Int16 loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<Const8>>] loop:<<Loop>> outer_loop:none - // - /// CHECK-DAG: <<Reduce:d\d+>> VecReduce [<<Phi2>>] loop:none - /// CHECK-DAG: VecExtractScalar [<<Reduce>>] loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + // 16-bit DotProd is not supported for SVE. + /// CHECK-NOT: VecDotProd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Const8:i\d+>> IntConstant 8 loop:none + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Const1>>] loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Const1>>] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<VAdd1:d\d+>> VecAdd [<<Load1>>,<<Repl>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<VAdd2:d\d+>> VecAdd [<<Load2>>,<<Repl>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecDotProd [<<Phi2>>,<<VAdd1>>,<<VAdd2>>] type:Int16 loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<Const8>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-DAG: <<Reduce:d\d+>> VecReduce [<<Phi2>>] loop:none + /// CHECK-DAG: VecExtractScalar [<<Reduce>>] loop:none + // + /// CHECK-FI: public static final int testDotProdComplex(short[] a, short[] b) { int s = 1; for (int i = 0; i < b.length; i++) { @@ -112,17 +130,26 @@ public class TestCharShort { /// CHECK-START-{ARM64}: int other.TestCharShort.testDotProdSimpleUnsigned(char[], char[]) loop_optimization (after) /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 loop:none /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 loop:none - /// CHECK-DAG: <<Const8:i\d+>> IntConstant 8 loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Const1>>] loop:none - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: VecDotProd [<<Phi2>>,<<Load1>>,<<Load2>>] type:Uint16 loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<Const8>>] loop:<<Loop>> outer_loop:none - // - /// CHECK-DAG: <<Reduce:d\d+>> VecReduce [<<Phi2>>] loop:none - /// CHECK-DAG: VecExtractScalar [<<Reduce>>] loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + // 16-bit DotProd is not supported for SVE. + /// CHECK-NOT: VecDotProd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Const8:i\d+>> IntConstant 8 loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Const1>>] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecDotProd [<<Phi2>>,<<Load1>>,<<Load2>>] type:Uint16 loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<Const8>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-DAG: <<Reduce:d\d+>> VecReduce [<<Phi2>>] loop:none + /// CHECK-DAG: VecExtractScalar [<<Reduce>>] loop:none + // + /// CHECK-FI: public static final int testDotProdSimpleUnsigned(char[] a, char[] b) { int s = 1; for (int i = 0; i < b.length; i++) { @@ -150,20 +177,29 @@ public class TestCharShort { /// CHECK-START-{ARM64}: int other.TestCharShort.testDotProdComplexUnsigned(char[], char[]) loop_optimization (after) /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 loop:none /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 loop:none - /// CHECK-DAG: <<Const8:i\d+>> IntConstant 8 loop:none - /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Const1>>] loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Const1>>] loop:none - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<VAdd1:d\d+>> VecAdd [<<Load1>>,<<Repl>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<VAdd2:d\d+>> VecAdd [<<Load2>>,<<Repl>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: VecDotProd [<<Phi2>>,<<VAdd1>>,<<VAdd2>>] type:Uint16 loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<Const8>>] loop:<<Loop>> outer_loop:none - // - /// CHECK-DAG: <<Reduce:d\d+>> VecReduce [<<Phi2>>] loop:none - /// CHECK-DAG: VecExtractScalar [<<Reduce>>] loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + // 16-bit DotProd is not supported for SVE. + /// CHECK-NOT: VecDotProd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Const8:i\d+>> IntConstant 8 loop:none + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Const1>>] loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Const1>>] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<VAdd1:d\d+>> VecAdd [<<Load1>>,<<Repl>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<VAdd2:d\d+>> VecAdd [<<Load2>>,<<Repl>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecDotProd [<<Phi2>>,<<VAdd1>>,<<VAdd2>>] type:Uint16 loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<Const8>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-DAG: <<Reduce:d\d+>> VecReduce [<<Phi2>>] loop:none + /// CHECK-DAG: VecExtractScalar [<<Reduce>>] loop:none + // + /// CHECK-FI: public static final int testDotProdComplexUnsigned(char[] a, char[] b) { int s = 1; for (int i = 0; i < b.length; i++) { @@ -191,20 +227,29 @@ public class TestCharShort { /// CHECK-START-{ARM64}: int other.TestCharShort.testDotProdComplexUnsignedCastedToSigned(char[], char[]) loop_optimization (after) /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 loop:none /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 loop:none - /// CHECK-DAG: <<Const8:i\d+>> IntConstant 8 loop:none - /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Const1>>] loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Const1>>] loop:none - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<VAdd1:d\d+>> VecAdd [<<Load1>>,<<Repl>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<VAdd2:d\d+>> VecAdd [<<Load2>>,<<Repl>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: VecDotProd [<<Phi2>>,<<VAdd1>>,<<VAdd2>>] type:Int16 loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<Const8>>] loop:<<Loop>> outer_loop:none - // - /// CHECK-DAG: <<Reduce:d\d+>> VecReduce [<<Phi2>>] loop:none - /// CHECK-DAG: VecExtractScalar [<<Reduce>>] loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + // 16-bit DotProd is not supported for SVE. + /// CHECK-NOT: VecDotProd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Const8:i\d+>> IntConstant 8 loop:none + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Const1>>] loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Const1>>] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<VAdd1:d\d+>> VecAdd [<<Load1>>,<<Repl>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<VAdd2:d\d+>> VecAdd [<<Load2>>,<<Repl>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecDotProd [<<Phi2>>,<<VAdd1>>,<<VAdd2>>] type:Int16 loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<Const8>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-DAG: <<Reduce:d\d+>> VecReduce [<<Phi2>>] loop:none + /// CHECK-DAG: VecExtractScalar [<<Reduce>>] loop:none + // + /// CHECK-FI: public static final int testDotProdComplexUnsignedCastedToSigned(char[] a, char[] b) { int s = 1; for (int i = 0; i < b.length; i++) { @@ -232,20 +277,29 @@ public class TestCharShort { /// CHECK-START-{ARM64}: int other.TestCharShort.testDotProdComplexSignedCastedToUnsigned(short[], short[]) loop_optimization (after) /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 loop:none /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 loop:none - /// CHECK-DAG: <<Const8:i\d+>> IntConstant 8 loop:none - /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Const1>>] loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Const1>>] loop:none - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<VAdd1:d\d+>> VecAdd [<<Load1>>,<<Repl>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<VAdd2:d\d+>> VecAdd [<<Load2>>,<<Repl>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: VecDotProd [<<Phi2>>,<<VAdd1>>,<<VAdd2>>] type:Uint16 loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<Const8>>] loop:<<Loop>> outer_loop:none - // - /// CHECK-DAG: <<Reduce:d\d+>> VecReduce [<<Phi2>>] loop:none - /// CHECK-DAG: VecExtractScalar [<<Reduce>>] loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + // 16-bit DotProd is not supported for SVE. + /// CHECK-NOT: VecDotProd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Const8:i\d+>> IntConstant 8 loop:none + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Const1>>] loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Const1>>] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<VAdd1:d\d+>> VecAdd [<<Load1>>,<<Repl>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<VAdd2:d\d+>> VecAdd [<<Load2>>,<<Repl>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecDotProd [<<Phi2>>,<<VAdd1>>,<<VAdd2>>] type:Uint16 loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<Const8>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-DAG: <<Reduce:d\d+>> VecReduce [<<Phi2>>] loop:none + /// CHECK-DAG: VecExtractScalar [<<Reduce>>] loop:none + // + /// CHECK-FI: public static final int testDotProdComplexSignedCastedToUnsigned(short[] a, short[] b) { int s = 1; for (int i = 0; i < b.length; i++) { @@ -256,7 +310,16 @@ public class TestCharShort { } /// CHECK-START-{ARM64}: int other.TestCharShort.testDotProdSignedToInt(short[], short[]) loop_optimization (after) - /// CHECK-DAG: VecDotProd type:Int16 + /// CHECK-IF: hasIsaFeature("sve") + // + // 16-bit DotProd is not supported for SVE. + /// CHECK-NOT: VecDotProd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: VecDotProd type:Int16 + // + /// CHECK-FI: public static final int testDotProdSignedToInt(short[] a, short[] b) { int s = 1; for (int i = 0; i < b.length; i++) { @@ -267,7 +330,16 @@ public class TestCharShort { } /// CHECK-START-{ARM64}: int other.TestCharShort.testDotProdParamSigned(int, short[]) loop_optimization (after) - /// CHECK-DAG: VecDotProd type:Int16 + /// CHECK-IF: hasIsaFeature("sve") + // + // 16-bit DotProd is not supported for SVE. + /// CHECK-NOT: VecDotProd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: VecDotProd type:Int16 + // + /// CHECK-FI: public static final int testDotProdParamSigned(int x, short[] b) { int s = 1; for (int i = 0; i < b.length; i++) { @@ -278,7 +350,16 @@ public class TestCharShort { } /// CHECK-START-{ARM64}: int other.TestCharShort.testDotProdParamUnsigned(int, char[]) loop_optimization (after) - /// CHECK-DAG: VecDotProd type:Uint16 + /// CHECK-IF: hasIsaFeature("sve") + // + // 16-bit DotProd is not supported for SVE. + /// CHECK-NOT: VecDotProd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: VecDotProd type:Uint16 + // + /// CHECK-FI: public static final int testDotProdParamUnsigned(int x, char[] b) { int s = 1; for (int i = 0; i < b.length; i++) { @@ -300,7 +381,16 @@ public class TestCharShort { } /// CHECK-START-{ARM64}: int other.TestCharShort.testDotProdSignedToChar(short[], short[]) loop_optimization (after) - /// CHECK-DAG: VecDotProd type:Uint16 + /// CHECK-IF: hasIsaFeature("sve") + // + // 16-bit DotProd is not supported for SVE. + /// CHECK-NOT: VecDotProd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: VecDotProd type:Uint16 + // + /// CHECK-FI: public static final int testDotProdSignedToChar(short[] a, short[] b) { int s = 1; for (int i = 0; i < b.length; i++) { diff --git a/test/684-checker-simd-dotprod/src/other/TestVarious.java b/test/684-checker-simd-dotprod/src/other/TestVarious.java index 3f460982f2..ef03da1fbd 100644 --- a/test/684-checker-simd-dotprod/src/other/TestVarious.java +++ b/test/684-checker-simd-dotprod/src/other/TestVarious.java @@ -35,18 +35,36 @@ public class TestVarious { /// CHECK-START-{ARM64}: int other.TestVarious.testDotProdConstRight(byte[]) loop_optimization (after) /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 loop:none /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 loop:none - /// CHECK-DAG: <<Const16:i\d+>> IntConstant 16 loop:none /// CHECK-DAG: <<Const89:i\d+>> IntConstant 89 loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Const1>>] loop:none - /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Const89>>] loop:none - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: VecDotProd [<<Phi2>>,<<Load1>>,<<Repl>>] type:Int8 loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<Const16>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Const1>>,{{j\d+}}] loop:none + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Const89>>,{{j\d+}}] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<LoopP:j\d+>> VecPredWhile [<<Phi1>>,{{i\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecDotProd [<<Phi2>>,<<Load1>>,<<Repl>>,<<LoopP>>] type:Int8 loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,{{i\d+}}] loop:<<Loop>> outer_loop:none + // + /// CHECK-DAG: <<Reduce:d\d+>> VecReduce [<<Phi2>>,{{j\d+}}] loop:none + /// CHECK-DAG: VecExtractScalar [<<Reduce>>,{{j\d+}}] loop:none + // + /// CHECK-ELSE: // - /// CHECK-DAG: <<Reduce:d\d+>> VecReduce [<<Phi2>>] loop:none - /// CHECK-DAG: VecExtractScalar [<<Reduce>>] loop:none + /// CHECK-DAG: <<Const16:i\d+>> IntConstant 16 loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Const1>>] loop:none + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Const89>>] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecDotProd [<<Phi2>>,<<Load1>>,<<Repl>>] type:Int8 loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<Const16>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-DAG: <<Reduce:d\d+>> VecReduce [<<Phi2>>] loop:none + /// CHECK-DAG: VecExtractScalar [<<Reduce>>] loop:none + // + /// CHECK-FI: public static final int testDotProdConstRight(byte[] b) { int s = 1; for (int i = 0; i < b.length; i++) { @@ -70,18 +88,36 @@ public class TestVarious { /// CHECK-START-{ARM64}: int other.TestVarious.testDotProdConstLeft(byte[]) loop_optimization (after) /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 loop:none /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 loop:none - /// CHECK-DAG: <<Const16:i\d+>> IntConstant 16 loop:none /// CHECK-DAG: <<Const89:i\d+>> IntConstant 89 loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Const1>>] loop:none - /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Const89>>] loop:none - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: VecDotProd [<<Phi2>>,<<Load1>>,<<Repl>>] type:Uint8 loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<Const16>>] loop:<<Loop>> outer_loop:none + /// CHECK-IF: hasIsaFeature("sve") // - /// CHECK-DAG: <<Reduce:d\d+>> VecReduce [<<Phi2>>] loop:none - /// CHECK-DAG: VecExtractScalar [<<Reduce>>] loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Const1>>,{{j\d+}}] loop:none + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Const89>>,{{j\d+}}] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<LoopP:j\d+>> VecPredWhile [<<Phi1>>,{{i\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecDotProd [<<Phi2>>,<<Load1>>,<<Repl>>,<<LoopP>>] type:Uint8 loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,{{i\d+}}] loop:<<Loop>> outer_loop:none + // + /// CHECK-DAG: <<Reduce:d\d+>> VecReduce [<<Phi2>>,{{j\d+}}] loop:none + /// CHECK-DAG: VecExtractScalar [<<Reduce>>,{{j\d+}}] loop:none + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Const16:i\d+>> IntConstant 16 loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Const1>>] loop:none + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Const89>>] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecDotProd [<<Phi2>>,<<Load1>>,<<Repl>>] type:Uint8 loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<Const16>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-DAG: <<Reduce:d\d+>> VecReduce [<<Phi2>>] loop:none + /// CHECK-DAG: VecExtractScalar [<<Reduce>>] loop:none + // + /// CHECK-FI: public static final int testDotProdConstLeft(byte[] b) { int s = 1; for (int i = 0; i < b.length; i++) { @@ -110,21 +146,40 @@ public class TestVarious { /// CHECK-DAG: <<Param:i\d+>> ParameterValue loop:none /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 loop:none /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 loop:none - /// CHECK-DAG: <<Const16:i\d+>> IntConstant 16 loop:none /// CHECK-DAG: <<ConstL:i\d+>> IntConstant 129 loop:none /// CHECK-DAG: <<AddP:i\d+>> Add [<<Param>>,<<ConstL>>] loop:none /// CHECK-DAG: <<TypeCnv:b\d+>> TypeConversion [<<AddP>>] loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Const1>>] loop:none - /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<TypeCnv>>] loop:none + /// CHECK-IF: hasIsaFeature("sve") // - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: VecDotProd [<<Phi2>>,<<Load1>>,<<Repl>>] type:Int8 loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<Const16>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Const1>>,{{j\d+}}] loop:none + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<TypeCnv>>,{{j\d+}}] loop:none // - /// CHECK-DAG: <<Reduce:d\d+>> VecReduce [<<Phi2>>] loop:none - /// CHECK-DAG: VecExtractScalar [<<Reduce>>] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<LoopP:j\d+>> VecPredWhile [<<Phi1>>,{{i\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecDotProd [<<Phi2>>,<<Load1>>,<<Repl>>,<<LoopP>>] type:Int8 loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,{{i\d+}}] loop:<<Loop>> outer_loop:none + // + /// CHECK-DAG: <<Reduce:d\d+>> VecReduce [<<Phi2>>,{{j\d+}}] loop:none + /// CHECK-DAG: VecExtractScalar [<<Reduce>>,{{j\d+}}] loop:none + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Const16:i\d+>> IntConstant 16 loop:none + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Const1>>] loop:none + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<TypeCnv>>] loop:none + // + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecDotProd [<<Phi2>>,<<Load1>>,<<Repl>>] type:Int8 loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<Const16>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-DAG: <<Reduce:d\d+>> VecReduce [<<Phi2>>] loop:none + /// CHECK-DAG: VecExtractScalar [<<Reduce>>] loop:none + // + /// CHECK-FI: public static final int testDotProdLoopInvariantConvRight(byte[] b, int param) { int s = 1; for (int i = 0; i < b.length; i++) { @@ -181,16 +236,34 @@ public class TestVarious { /// CHECK-START-{ARM64}: int other.TestVarious.testDotProdInt32(int[], int[]) loop_optimization (after) /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 loop:none /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 loop:none - /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Const1>>] loop:none - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Mul:d\d+>> VecMul [<<Load1>>,<<Load2>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: VecAdd [<<Phi2>>,<<Mul>>] loop:<<Loop>> outer_loop:none - // - /// CHECK-DAG: <<Reduce:d\d+>> VecReduce [<<Phi2>>] loop:none - /// CHECK-DAG: VecExtractScalar [<<Reduce>>] loop:none + /// CHECK-IF: hasIsaFeature("sve") + // + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Const1>>,{{j\d+}}] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<LoopP:j\d+>> VecPredWhile [<<Phi1>>,{{i\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Mul:d\d+>> VecMul [<<Load1>>,<<Load2>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecAdd [<<Phi2>>,<<Mul>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-DAG: <<Reduce:d\d+>> VecReduce [<<Phi2>>,{{j\d+}}] loop:none + /// CHECK-DAG: VecExtractScalar [<<Reduce>>,{{j\d+}}] loop:none + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Set:d\d+>> VecSetScalars [<<Const1>>] loop:none + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Mul:d\d+>> VecMul [<<Load1>>,<<Load2>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecAdd [<<Phi2>>,<<Mul>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-DAG: <<Reduce:d\d+>> VecReduce [<<Phi2>>] loop:none + /// CHECK-DAG: VecExtractScalar [<<Reduce>>] loop:none + // + /// CHECK-FI: public static final int testDotProdInt32(int[] a, int[] b) { int s = 1; for (int i = 0; i < b.length; i++) { @@ -221,18 +294,37 @@ public class TestVarious { /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 loop:none /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 loop:none /// CHECK-DAG: <<Const2:i\d+>> IntConstant 2 loop:none - /// CHECK-DAG: <<Const16:i\d+>> IntConstant 16 loop:none - /// CHECK-DAG: <<Set1:d\d+>> VecSetScalars [<<Const1>>] loop:none - /// CHECK-DAG: <<Set2:d\d+>> VecSetScalars [<<Const2>>] loop:none + /// CHECK-IF: hasIsaFeature("sve") // - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set1>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Phi3:d\d+>> Phi [<<Set2>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: VecDotProd [<<Phi2>>,<<Load1>>,<<Load2>>] type:Int8 loop:<<Loop>> outer_loop:none - /// CHECK-DAG: VecDotProd [<<Phi3>>,<<Load1>>,<<Load2>>] type:Uint8 loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<Const16>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Set1:d\d+>> VecSetScalars [<<Const1>>,{{j\d+}}] loop:none + /// CHECK-DAG: <<Set2:d\d+>> VecSetScalars [<<Const2>>,{{j\d+}}] loop:none + // + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set1>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Phi3:d\d+>> Phi [<<Set2>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<LoopP:j\d+>> VecPredWhile [<<Phi1>>,{{i\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecDotProd [<<Phi2>>,<<Load1>>,<<Load2>>,<<LoopP>>] type:Int8 loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecDotProd [<<Phi3>>,<<Load1>>,<<Load2>>,<<LoopP>>] type:Uint8 loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,{{i\d+}}] loop:<<Loop>> outer_loop:none + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Const16:i\d+>> IntConstant 16 loop:none + /// CHECK-DAG: <<Set1:d\d+>> VecSetScalars [<<Const1>>] loop:none + /// CHECK-DAG: <<Set2:d\d+>> VecSetScalars [<<Const2>>] loop:none + // + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set1>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Phi3:d\d+>> Phi [<<Set2>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecDotProd [<<Phi2>>,<<Load1>>,<<Load2>>] type:Int8 loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecDotProd [<<Phi3>>,<<Load1>>,<<Load2>>] type:Uint8 loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<Const16>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: public static final int testDotProdBothSignedUnsigned1(byte[] a, byte[] b) { int s1 = 1; int s2 = 2; @@ -266,20 +358,40 @@ public class TestVarious { /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 loop:none /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 loop:none /// CHECK-DAG: <<Const2:i\d+>> IntConstant 2 loop:none - /// CHECK-DAG: <<Const16:i\d+>> IntConstant 16 loop:none /// CHECK-DAG: <<Const42:i\d+>> IntConstant 42 loop:none - /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Const42>>] loop:none - /// CHECK-DAG: <<Set1:d\d+>> VecSetScalars [<<Const1>>] loop:none - /// CHECK-DAG: <<Set2:d\d+>> VecSetScalars [<<Const2>>] loop:none + /// CHECK-IF: hasIsaFeature("sve") // - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set1>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Phi3:d\d+>> Phi [<<Set2>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: VecDotProd [<<Phi3>>,<<Load2>>,<<Load1>>] type:Uint8 loop:<<Loop>> outer_loop:none - /// CHECK-DAG: VecDotProd [<<Phi2>>,<<Load1>>,<<Repl>>] type:Int8 loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<Const16>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Const42>>,{{j\d+}}] loop:none + /// CHECK-DAG: <<Set1:d\d+>> VecSetScalars [<<Const1>>,{{j\d+}}] loop:none + /// CHECK-DAG: <<Set2:d\d+>> VecSetScalars [<<Const2>>,{{j\d+}}] loop:none + // + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set1>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Phi3:d\d+>> Phi [<<Set2>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<LoopP:j\d+>> VecPredWhile [<<Phi1>>,{{i\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecDotProd [<<Phi3>>,<<Load2>>,<<Load1>>,<<LoopP>>] type:Uint8 loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecDotProd [<<Phi2>>,<<Load1>>,<<Repl>>,<<LoopP>>] type:Int8 loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,{{i\d+}}] loop:<<Loop>> outer_loop:none + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Const16:i\d+>> IntConstant 16 loop:none + /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<Const42>>] loop:none + /// CHECK-DAG: <<Set1:d\d+>> VecSetScalars [<<Const1>>] loop:none + /// CHECK-DAG: <<Set2:d\d+>> VecSetScalars [<<Const2>>] loop:none + // + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set1>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Phi3:d\d+>> Phi [<<Set2>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecDotProd [<<Phi3>>,<<Load2>>,<<Load1>>] type:Uint8 loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecDotProd [<<Phi2>>,<<Load1>>,<<Repl>>] type:Int8 loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<Const16>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: public static final int testDotProdBothSignedUnsigned2(byte[] a, byte[] b) { int s1 = 1; int s2 = 2; @@ -313,20 +425,41 @@ public class TestVarious { /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 loop:none /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 loop:none /// CHECK-DAG: <<Const2:i\d+>> IntConstant 2 loop:none - /// CHECK-DAG: <<Const16:i\d+>> IntConstant 16 loop:none - /// CHECK-DAG: <<Set1:d\d+>> VecSetScalars [<<Const1>>] loop:none - /// CHECK-DAG: <<Set2:d\d+>> VecSetScalars [<<Const2>>] loop:none + /// CHECK-IF: hasIsaFeature("sve") // - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set1>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Phi3:d\d+>> Phi [<<Set2>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: VecDotProd [<<Phi2>>,<<Load1>>,<<Load2>>] type:Int8 loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load3:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load4:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: VecDotProd [<<Phi3>>,<<Load3>>,<<Load4>>] type:Uint8 loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<Const16>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Set1:d\d+>> VecSetScalars [<<Const1>>,{{j\d+}}] loop:none + /// CHECK-DAG: <<Set2:d\d+>> VecSetScalars [<<Const2>>,{{j\d+}}] loop:none + // + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set1>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Phi3:d\d+>> Phi [<<Set2>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<LoopP:j\d+>> VecPredWhile [<<Phi1>>,{{i\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecDotProd [<<Phi2>>,<<Load1>>,<<Load2>>,<<LoopP>>] type:Int8 loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load3:d\d+>> VecLoad [{{l\d+}},<<Phi1>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load4:d\d+>> VecLoad [{{l\d+}},<<Phi1>>,<<LoopP>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecDotProd [<<Phi3>>,<<Load3>>,<<Load4>>,<<LoopP>>] type:Uint8 loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,{{i\d+}}] loop:<<Loop>> outer_loop:none + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Const16:i\d+>> IntConstant 16 loop:none + /// CHECK-DAG: <<Set1:d\d+>> VecSetScalars [<<Const1>>] loop:none + /// CHECK-DAG: <<Set2:d\d+>> VecSetScalars [<<Const2>>] loop:none + // + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set1>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Phi3:d\d+>> Phi [<<Set2>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecDotProd [<<Phi2>>,<<Load1>>,<<Load2>>] type:Int8 loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load3:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load4:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecDotProd [<<Phi3>>,<<Load3>>,<<Load4>>] type:Uint8 loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<Const16>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: public static final int testDotProdBothSignedUnsignedDoubleLoad(byte[] a, byte[] b) { int s1 = 1; int s2 = 2; @@ -358,18 +491,27 @@ public class TestVarious { /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 loop:none /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 loop:none /// CHECK-DAG: <<Const2:i\d+>> IntConstant 2 loop:none - /// CHECK-DAG: <<Const8:i\d+>> IntConstant 8 loop:none - /// CHECK-DAG: <<Set1:d\d+>> VecSetScalars [<<Const1>>] loop:none - /// CHECK-DAG: <<Set2:d\d+>> VecSetScalars [<<Const2>>] loop:none + /// CHECK-IF: hasIsaFeature("sve") // - /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none - /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set1>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Phi3:d\d+>> Phi [<<Set2>>,{{d\d+}}] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none - /// CHECK-DAG: VecDotProd [<<Phi3>>,<<Load1>>,<<Load2>>] type:Int16 loop:<<Loop>> outer_loop:none - /// CHECK-DAG: VecDotProd [<<Phi2>>,<<Load1>>,<<Load2>>] type:Uint16 loop:<<Loop>> outer_loop:none - /// CHECK-DAG: Add [<<Phi1>>,<<Const8>>] loop:<<Loop>> outer_loop:none + // 16-bit DotProd is not supported for SVE. + /// CHECK-NOT: VecDotProd + // + /// CHECK-ELSE: + // + /// CHECK-DAG: <<Const8:i\d+>> IntConstant 8 loop:none + /// CHECK-DAG: <<Set1:d\d+>> VecSetScalars [<<Const1>>] loop:none + /// CHECK-DAG: <<Set2:d\d+>> VecSetScalars [<<Const2>>] loop:none + // + /// CHECK-DAG: <<Phi1:i\d+>> Phi [<<Const0>>,{{i\d+}}] loop:<<Loop:B\d+>> outer_loop:none + /// CHECK-DAG: <<Phi2:d\d+>> Phi [<<Set1>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Phi3:d\d+>> Phi [<<Set2>>,{{d\d+}}] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load1:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: <<Load2:d\d+>> VecLoad [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecDotProd [<<Phi3>>,<<Load1>>,<<Load2>>] type:Int16 loop:<<Loop>> outer_loop:none + /// CHECK-DAG: VecDotProd [<<Phi2>>,<<Load1>>,<<Load2>>] type:Uint16 loop:<<Loop>> outer_loop:none + /// CHECK-DAG: Add [<<Phi1>>,<<Const8>>] loop:<<Loop>> outer_loop:none + // + /// CHECK-FI: public static final int testDotProdBothSignedUnsignedChar(char[] a, char[] b) { int s1 = 1; int s2 = 2; |