[AArch64][SVE] Left shift patterns for scalable integer types

[huntergr]

Summary

Adds ISel patterns to match scalable vector types shifted by amounts
contained in a vector of the same type, plus unit tests.

Part of the initial SVE codegen series, rfc will be posted soon. Note: this patch is currently just to support the scalable vector codegen rfc, and does not need a full review yet.

[huntergr]

A better set of patterns will be created later.

lib/Target/AArch64/AArch64SVEInstrInfo.td

def : Pat<(store (nxv16i8 ZPR:$val), GPR64sp:$base),
             (ST1B_IMM ZPR:$val, (PTRUE_B 31), GPR64sp:$base, (i64 0))>;
   def : Pat<(store (nxv8i16 ZPR:$val), GPR64sp:$base),
             (ST1H_IMM ZPR:$val, (PTRUE_H 31), GPR64sp:$base, (i64 0))>;
   def : Pat<(store (nxv4i32 ZPR:$val), GPR64sp:$base),
             (ST1W_IMM ZPR:$val, (PTRUE_S 31), GPR64sp:$base, (i64 0))>;
   def : Pat<(store (nxv2i64 ZPR:$val), GPR64sp:$base),
             (ST1D_IMM ZPR:$val, (PTRUE_D 31), GPR64sp:$base, (i64 0))>;
 
+  // Shift by register
+  def : Pat<(nxv16i8 (shl (nxv16i8 ZPR:$Zs1), (nxv16i8 ZPR:$Zs2))),
+            (LSL_ZPmZ_B (PTRUE_B 31), ZPR:$Zs1, ZPR:$Zs2)>;
+  def : Pat<(nxv8i16 (shl (nxv8i16 ZPR:$Zs1), (nxv8i16 ZPR:$Zs2))),
+            (LSL_ZPmZ_H (PTRUE_H 31), ZPR:$Zs1, ZPR:$Zs2)>;
+  def : Pat<(nxv4i32 (shl (nxv4i32 ZPR:$Zs1), (nxv4i32 ZPR:$Zs2))),
+            (LSL_ZPmZ_S (PTRUE_S 31), ZPR:$Zs1, ZPR:$Zs2)>;
+  def : Pat<(nxv2i64 (shl (nxv2i64 ZPR:$Zs1), (nxv2i64 ZPR:$Zs2))),
+            (LSL_ZPmZ_D (PTRUE_D 31), ZPR:$Zs1, ZPR:$Zs2)>;
+
   // Add
   def : Pat<(nxv16i8 (add (nxv16i8 ZPR:$Zs1), (nxv16i8 ZPR:$Zs2))),
             (ADD_ZZZ_B ZPR:$Zs1, ZPR:$Zs2)>;
   def : Pat<(nxv8i16 (add (nxv8i16 ZPR:$Zs1), (nxv8i16 ZPR:$Zs2))),
             (ADD_ZZZ_H ZPR:$Zs1, ZPR:$Zs2)>;
   def : Pat<(nxv4i32 (add (nxv4i32 ZPR:$Zs1), (nxv4i32 ZPR:$Zs2))),
             (ADD_ZZZ_S ZPR:$Zs1, ZPR:$Zs2)>;
   def : Pat<(nxv2i64 (add (nxv2i64 ZPR:$Zs1), (nxv2i64 ZPR:$Zs2))),
             (ADD_ZZZ_D ZPR:$Zs1, ZPR:$Zs2)>;
 }

test/CodeGen/AArch64/SVE/shifts.ll

+; RUN: llc -verify-machineinstrs -mattr=+sve < %s | FileCheck %s
+
+target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
+target triple = "aarch64--linux-gnueabi"
+
+define <scalable 16 x i8> @lsl_reg_b(<scalable 16 x i8> %vec, <scalable 16 x i8> %amount) {
+; CHECK-LABEL: lsl_reg_b:
+; CHECK: ptrue [[PG:p[0-7]]].b
+; CHECK: lsl z0.b, [[PG]]/m, z0.b, z1.b
+; CHECK-NEXT: ret
+  %shift = shl <scalable 16 x i8> %vec, %amount
+  ret <scalable 16 x i8> %shift
+}
+
+define <scalable 8 x i16> @lsl_reg_h(<scalable 8 x i16> %vec, <scalable 8 x i16> %amount) {
+; CHECK-LABEL: lsl_reg_h:
+; CHECK: ptrue [[PG:p[0-7]]].h
+; CHECK: lsl z0.h, [[PG]]/m, z0.h, z1.h
+; CHECK-NEXT: ret
+  %shift = shl <scalable 8 x i16> %vec, %amount
+  ret <scalable 8 x i16> %shift
+}
+
+define <scalable 4 x i32> @lsl_reg_s(<scalable 4 x i32> %vec, <scalable 4 x i32> %amount) {
+; CHECK-LABEL: lsl_reg_s:
+; CHECK: ptrue [[PG:p[0-7]]].s
+; CHECK: lsl z0.s, [[PG]]/m, z0.s, z1.s
+; CHECK-NEXT: ret
+  %shift = shl <scalable 4 x i32> %vec, %amount
+  ret <scalable 4 x i32> %shift
+}
+
+define <scalable 2 x i64> @lsl_reg_d(<scalable 2 x i64> %vec, <scalable 2 x i64> %amount) {
+; CHECK-LABEL: lsl_reg_d:
+; CHECK: ptrue [[PG:p[0-7]]].d
+; CHECK: lsl z0.d, [[PG]]/m, z0.d, z1.d
+; CHECK-NEXT: ret
+  %shift = shl <scalable 2 x i64> %vec, %amount
+  ret <scalable 2 x i64> %shift
+}
+