[InstCombine] GEPOperator::accumulateConstantOffset does not support scalable vectors

[sdesmalen]

Summary

Avoid transforming:

%0 = bitcast i8* %base to <vscale x 16 x i8>*
%1 = getelementptr <vscale x 16 x i8>, <vscale x 16 x i8>* %0, i64 1

into:

%0 = getelementptr i8, i8* %base, i64 16
%1 = bitcast i8* %0 to <vscale x 16 x i8>*

[efriedma]

Should we add a special case for zero indexes?

[sdesmalen]

• Supported case of index being 0, and added extra test.

[efriedma]

LGTM

llvm/lib/IR/Operator.cpp

bool GEPOperator::accumulateConstantOffset(const DataLayout &DL,
   for (gep_type_iterator GTI = gep_type_begin(this), GTE = gep_type_end(this);
        GTI != GTE; ++GTI) {
     ConstantInt *OpC = dyn_cast<ConstantInt>(GTI.getOperand());
     if (!OpC)
       return false;
     if (OpC->isZero())
       continue;
 
+    // Scalable vectors have are multiplied by a runtime constant.
+    if (auto *VecTy = dyn_cast<VectorType>(GTI.getIndexedType()))
+      if (VecTy->isScalable())
+        return false;
+
     // Handle a struct index, which adds its field offset to the pointer.
     if (StructType *STy = GTI.getStructTypeOrNull()) {
       unsigned ElementIdx = OpC->getZExtValue();
       const StructLayout *SL = DL.getStructLayout(STy);
       Offset += APInt(Offset.getBitWidth(), SL->getElementOffset(ElementIdx));
       continue;
     }
 
     // For array or vector indices, scale the index by the size of the type.
     APInt Index = OpC->getValue().sextOrTrunc(Offset.getBitWidth());
     Offset += Index * APInt(Offset.getBitWidth(),
                             DL.getTypeAllocSize(GTI.getIndexedType()));
   }
   return true;
 }
 }

llvm/test/Transforms/InstCombine/gep-vector.ll

 ; CHECK-NEXT:    [[TMP1:%.*]] = addrspacecast i32* [[GEP]] to i32 addrspace(3)*
 ; CHECK-NEXT:    ret i32 addrspace(3)* [[TMP1]]
 ;
   %arr_ptr = bitcast <4 x i32>* %x to [4 x i32]*
   %asc = addrspacecast [4 x i32]* %arr_ptr to [4 x i32] addrspace(3)*
   %gep = getelementptr inbounds [4 x i32], [4 x i32] addrspace(3)* %asc, i64 %y, i64 %z
   ret i32 addrspace(3)* %gep
 }
+
+; Negative test - avoid doing bitcast on i8*, because '16' should be scaled by 'vscale'.
+
+define i8* @test_accumulate_constant_offset_vscale_nonzero(<vscale x 16 x i1> %pg, i8* %base) {
+; CHECK-LABEL: @test_accumulate_constant_offset_vscale_nonzero
+; CHECK-NEXT:   %bc = bitcast i8* %base to <vscale x 16 x i8>*
+; CHECK-NEXT:   %gep = getelementptr <vscale x 16 x i8>, <vscale x 16 x i8>* %bc, i64 1, i64 4
+; CHECK-NEXT:   ret i8* %gep
+  %bc = bitcast i8* %base to <vscale x 16 x i8>*
+  %gep = getelementptr <vscale x 16 x i8>, <vscale x 16 x i8>* %bc, i64 1, i64 4
+  ret i8* %gep
+}
+
+define i8* @test_accumulate_constant_offset_vscale_zero(<vscale x 16 x i1> %pg, i8* %base) {
+; CHECK-LABEL: @test_accumulate_constant_offset_vscale_zero
+; CHECK-NEXT:   %[[RES:.*]] = getelementptr i8, i8* %base, i64 4
+; CHECK-NEXT:   ret i8* %[[RES]]
+  %bc = bitcast i8* %base to <vscale x 16 x i8>*
+  %gep = getelementptr <vscale x 16 x i8>, <vscale x 16 x i8>* %bc, i64 0, i64 4
+  ret i8* %gep
+}