[llvm] [RISCV][GISEL] Legalize G_EXTRACT_SUBVECTOR (PR #109426)

[Craig Topper via llvm-commits]

================
@@ -0,0 +1,339 @@
+# NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py
+# RUN: llc -mtriple=riscv32 -mattr=+v -run-pass=legalizer %s -o - | FileCheck %s --check-prefixes=CHECK,RV32
+# RUN: llc -mtriple=riscv64 -mattr=+v -run-pass=legalizer %s -o - | FileCheck %s --check-prefixes=CHECK,RV64
+
+# Special handling for i1-element vectors with non-zero index
+---
+name:            extract_subvector_nxv4i1
+legalized:       false
+tracksRegLiveness: true
+body:             |
+  bb.0.entry:
+    ; RV32-LABEL: name: extract_subvector_nxv4i1
+    ; RV32: [[DEF:%[0-9]+]]:_(<vscale x 4 x s1>) = G_IMPLICIT_DEF
+    ; RV32-NEXT: [[C:%[0-9]+]]:_(s32) = G_CONSTANT i32 0
+    ; RV32-NEXT: [[SPLAT_VECTOR:%[0-9]+]]:_(<vscale x 4 x s8>) = G_SPLAT_VECTOR [[C]](s32)
+    ; RV32-NEXT: [[C1:%[0-9]+]]:_(s32) = G_CONSTANT i32 1
+    ; RV32-NEXT: [[SPLAT_VECTOR1:%[0-9]+]]:_(<vscale x 4 x s8>) = G_SPLAT_VECTOR [[C1]](s32)
+    ; RV32-NEXT: [[SELECT:%[0-9]+]]:_(<vscale x 4 x s8>) = G_SELECT [[DEF]](<vscale x 4 x s1>), [[SPLAT_VECTOR1]], [[SPLAT_VECTOR]]
+    ; RV32-NEXT: [[READ_VLENB:%[0-9]+]]:_(s32) = G_READ_VLENB
+    ; RV32-NEXT: [[C2:%[0-9]+]]:_(s32) = G_CONSTANT i32 2
+    ; RV32-NEXT: [[LSHR:%[0-9]+]]:_(s32) = G_LSHR [[READ_VLENB]], [[C2]](s32)
+    ; RV32-NEXT: [[VMSET_VL:%[0-9]+]]:_(<vscale x 2 x s1>) = G_VMSET_VL $x0
+    ; RV32-NEXT: [[DEF1:%[0-9]+]]:_(<vscale x 4 x s8>) = G_IMPLICIT_DEF
+    ; RV32-NEXT: [[VSLIDEDOWN_VL:%[0-9]+]]:_(<vscale x 4 x s8>) = G_VSLIDEDOWN_VL [[DEF1]], [[SELECT]], [[LSHR]](s32), [[VMSET_VL]](<vscale x 2 x s1>), $x0, 3
+    ; RV32-NEXT: [[EXTRACT_SUBVECTOR:%[0-9]+]]:_(<vscale x 2 x s8>) = G_EXTRACT_SUBVECTOR [[VSLIDEDOWN_VL]](<vscale x 4 x s8>), 0
----------------
topperc wrote:

AArch64 has no "legal" G_EXTRACT_VECTOR_ELT, but the custom handler keeps any G_EXTRACT_VECTOR_ELT with a constant index.

```
  getActionDefinitionsBuilder(G_EXTRACT_VECTOR_ELT)                              
      .unsupportedIf([=](const LegalityQuery &Query) {                           
        const LLT &EltTy = Query.Types[1].getElementType();                      
        return Query.Types[0] != EltTy;                                          
      })                                                                         
      .minScalar(2, s64)                                                         
      .customIf([=](const LegalityQuery &Query) {                                
        const LLT &VecTy = Query.Types[1];                                       
        return VecTy == v2s16 || VecTy == v4s16 || VecTy == v8s16 ||             
               VecTy == v4s32 || VecTy == v2s64 || VecTy == v2s32 ||             
               VecTy == v8s8 || VecTy == v16s8 || VecTy == v2p0;                 
      })                                                                         
      .minScalarOrEltIf(                                                         
          [=](const LegalityQuery &Query) {                                      
            // We want to promote to <M x s1> to <M x s64> if that wouldn't      
            // cause the total vec size to be > 128b.                            
            return Query.Types[1].getNumElements() <= 2;                         
          },                                                                     
          0, s64)                                                                
      .minScalarOrEltIf(                                                         
          [=](const LegalityQuery &Query) {                                      
            return Query.Types[1].getNumElements() <= 4;                         
          },                                                                     
          0, s32)                                                                
      .minScalarOrEltIf(                                                         
          [=](const LegalityQuery &Query) {                                      
            return Query.Types[1].getNumElements() <= 8;                         
          },                                                                     
          0, s16)                                                                
      .minScalarOrEltIf(                                                         
          [=](const LegalityQuery &Query) {                                      
            return Query.Types[1].getNumElements() <= 16;                        
          },                                                                     
          0, s8)                                                                 
      .minScalarOrElt(0, s8) // Worst case, we need at least s8.                 
      .moreElementsToNextPow2(1)                                                 
      .clampMaxNumElements(1, s64, 2)                                            
      .clampMaxNumElements(1, s32, 4)                                            
      .clampMaxNumElements(1, s16, 8)                                            
      .clampMaxNumElements(1, s8, 16)                                            
      .clampMaxNumElements(1, p0, 2);  
```

https://github.com/llvm/llvm-project/pull/109426