[SCCP] Do not attempt to create constexpr for a scalable vector GEP

[rahulana-quic]

Summary

Scalable vector GEPs are not constants and trying to create one for
these GEPs causes an assertion failure.

[rahulana-quic]

Added test

[nikic]

llvm/lib/Transforms/Utils/SCCPSolver.cpp

1542–1544

I think this would be cleaner. It should gracefully handle scalable vectors and also make the folding DL-aware.

llvm/test/Transforms/SCCP/vscale-gep.ll

3

verify is unnecessary.

[rahulana-quic]

Update the check to see if the GEP is constant-foldable.

[nikic]

LGTM as well.

[rahulana-quic]

@paulwalker-arm @nikic can one of you please commit this for me? The email is [e-mail] and the name is Rahul Anand Radhakrishnan. Thanks!

[paulwalker-arm]

In D157590#4576145, @rahulana-quic wrote:

@paulwalker-arm @nikic can one of you please commit this for me? The email is [e-mail] and the name is Rahul Anand Radhakrishnan. Thanks!

Sure, I can commit it. Likely in the next hour or two.

[paulwalker-arm]

@rahulana-quic : This patch as it stand is causing unit test failures. There may be others but I see at least:

Failed Tests (3):
  LLVM :: Transforms/FunctionSpecialization/function-specialization-constant-expression.ll
  LLVM :: Transforms/SCCP/2009-09-24-byval-ptr.ll
  LLVM :: Transforms/SCCP/apint-bigint2.ll

My guess it's likely down to extra optimisations gained by using the generic folder. Please update the review with full test coverage and assuming nobody sees an issue with the new output I'll try to land it tomorrow.

[rahulana-quic]

Fix failing tests

llvm/lib/Transforms/Utils/SCCPSolver.cpp

for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i) {
     if (Constant *C = getConstant(State, I.getOperand(i)->getType())) {
       Operands.push_back(C);
       continue;
     }
 
     return (void)markOverdefined(&I);
   }
 
-  Constant *Ptr = Operands[0];
-  auto Indices = ArrayRef(Operands.begin() + 1, Operands.end());
-  Constant *C =
-      ConstantExpr::getGetElementPtr(I.getSourceElementType(), Ptr, Indices);
+  if (Constant *C = ConstantFoldInstOperands(&I, Operands, DL))
     markConstant(&I, C);
 }
 
 void SCCPInstVisitor::visitStoreInst(StoreInst &SI) {
   // If this store is of a struct, ignore it.
   if (SI.getOperand(0)->getType()->isStructTy())
     return;
 
   if (TrackedGlobals.empty() || !isa<GlobalVariable>(SI.getOperand(1)))
     return;

llvm/test/Transforms/FunctionSpecialization/function-specialization-constant-expression.ll

entry:
   ret i64 %tmp0
 }
 
 define internal i64 @zoo(i1 %flag) {
 ; CHECK-LABEL: @zoo(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[FLAG:%.*]], label [[PLUS:%.*]], label [[MINUS:%.*]]
 ; CHECK:       plus:
-; CHECK-NEXT:    [[TMP0:%.*]] = call i64 @func2.2(ptr getelementptr inbounds ([[STRUCT:%.*]], ptr @Global, i32 0, i32 3))
+; CHECK-NEXT:    [[TMP0:%.*]] = call i64 @func2.2(ptr getelementptr inbounds ([[STRUCT:%.*]], ptr @Global, i64 0, i32 3))
 ; CHECK-NEXT:    br label [[MERGE:%.*]]
 ; CHECK:       minus:
-; CHECK-NEXT:    [[TMP1:%.*]] = call i64 @func2.1(ptr getelementptr inbounds ([[STRUCT]], ptr @Global, i32 0, i32 4))
+; CHECK-NEXT:    [[TMP1:%.*]] = call i64 @func2.1(ptr getelementptr inbounds ([[STRUCT]], ptr @Global, i64 0, i32 4))
 ; CHECK-NEXT:    br label [[MERGE]]
 ; CHECK:       merge:
-; CHECK-NEXT:    [[TMP2:%.*]] = phi i64 [ ptrtoint (ptr getelementptr inbounds ([[STRUCT:%.*]], ptr @Global, i32 0, i32 3) to i64), [[PLUS]] ], [ ptrtoint (ptr getelementptr inbounds ([[STRUCT:%.*]], ptr @Global, i32 0, i32 4) to i64), [[MINUS]] ]
+; CHECK-NEXT:    [[TMP2:%.*]] = phi i64 [ ptrtoint (ptr getelementptr inbounds ([[STRUCT]], ptr @Global, i64 0, i32 3) to i64), [[PLUS]] ], [ ptrtoint (ptr getelementptr inbounds ([[STRUCT]], ptr @Global, i64 0, i32 4) to i64), [[MINUS]] ]
 ; CHECK-NEXT:    ret i64 [[TMP2]]
 ;
 entry:
   br i1 %flag, label %plus, label %minus
 
 plus:
   %arg = getelementptr %struct, ptr @Global, i32 0, i32 3
   %tmp0 = call i64 @func2(ptr %arg)

llvm/test/Transforms/SCCP/2009-09-24-byval-ptr.ll

 
 return:                                           ; preds = %entry
   ret void
 }
 
 define internal i32 @vfu2(ptr byval(%struct.MYstr) align 4 %u) nounwind readonly {
 ; CHECK-LABEL: @vfu2(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[TMP0:%.*]] = load i32, ptr getelementptr inbounds ([[STRUCT_MYSTR:%.*]], ptr @mystr, i32 0, i32 1), align 4
+; CHECK-NEXT:    [[TMP0:%.*]] = load i32, ptr getelementptr inbounds ([[STRUCT_MYSTR:%.*]], ptr @mystr, i64 0, i32 1), align 4
 ; CHECK-NEXT:    [[TMP1:%.*]] = load i8, ptr @mystr, align 1
 ; CHECK-NEXT:    [[TMP2:%.*]] = zext i8 [[TMP1]] to i32
 ; CHECK-NEXT:    [[TMP3:%.*]] = add i32 [[TMP2]], [[TMP0]]
 ; CHECK-NEXT:    ret i32 [[TMP3]]
 ;
 entry:
   %0 = getelementptr %struct.MYstr, ptr %u, i32 0, i32 1 ; <ptr> [#uses=1]
   %1 = load i32, ptr %0

llvm/test/Transforms/SCCP/apint-bigint2.ll

;
 
   ret i101 %G
 }
 
 define i101 @large_aggregate() {
 ; CHECK-LABEL: @large_aggregate(
 ; CHECK-NEXT:    [[D:%.*]] = and i101 undef, 1
 ; CHECK-NEXT:    [[DD:%.*]] = or i101 [[D]], 1
-; CHECK-NEXT:    [[G:%.*]] = getelementptr i101, ptr getelementptr inbounds ([6 x i101], ptr @Y, i32 0, i32 5), i101 [[DD]]
+; CHECK-NEXT:    [[G:%.*]] = getelementptr i101, ptr getelementptr inbounds ([6 x i101], ptr @Y, i64 0, i64 5), i101 [[DD]]
 ; CHECK-NEXT:    [[L3:%.*]] = load i101, ptr [[G]], align 4
 ; CHECK-NEXT:    ret i101 [[L3]]
 ;
   %B = load i101, ptr undef
   %D = and i101 %B, 1
   %DD = or i101 %D, 1
   %F = getelementptr [6 x i101], ptr @Y, i32 0, i32 5
   %G = getelementptr i101, ptr %F, i101 %DD
   %L3 = load i101, ptr %G
   ret i101 %L3
 }
 
 define i101 @large_aggregate_2() {
 ; CHECK-LABEL: @large_aggregate_2(
 ; CHECK-NEXT:    [[D:%.*]] = and i101 undef, 1
 ; CHECK-NEXT:    [[DD:%.*]] = or i101 [[D]], 1
-; CHECK-NEXT:    [[G:%.*]] = getelementptr i101, ptr getelementptr inbounds ([6 x i101], ptr @Y, i32 0, i32 5), i101 [[DD]]
+; CHECK-NEXT:    [[G:%.*]] = getelementptr i101, ptr getelementptr inbounds ([6 x i101], ptr @Y, i64 0, i64 5), i101 [[DD]]
 ; CHECK-NEXT:    [[L3:%.*]] = load i101, ptr [[G]], align 4
 ; CHECK-NEXT:    ret i101 [[L3]]
 ;
   %D = and i101 undef, 1
   %DD = or i101 %D, 1
   %F = getelementptr [6 x i101], ptr @Y, i32 0, i32 5
   %G = getelementptr i101, ptr %F, i101 %DD
   %L3 = load i101, ptr %G
   ret i101 %L3
 }
 
 define void @index_too_large() {
 ; CHECK-LABEL: @index_too_large(
-; CHECK-NEXT:    store ptr getelementptr ([6 x i101], ptr @Y, i101 1537416322793603071, i101 4), ptr undef, align 8
+; CHECK-NEXT:    store ptr getelementptr ([6 x i101], ptr @Y, i64 187649984473770, i64 2), ptr undef, align 8
 ; CHECK-NEXT:    ret void
 ;
   %ptr1 = getelementptr [6 x i101], ptr @Y, i32 0, i32 -1
   %ptr2 = getelementptr i101, ptr %ptr1, i101 9224497936761618431
   store ptr %ptr2, ptr undef
   ret void
 }
 

llvm/test/Transforms/SCCP/vscale-gep.ll

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; RUN: opt < %s -passes=sccp -S | FileCheck %s
+
+define ptr @scalable_vector_getelementptr(i64 %x) {
+; CHECK-LABEL: @scalable_vector_getelementptr(
+; CHECK-NEXT:    [[PTR:%.*]] = getelementptr <vscale x 4 x i32>, ptr null, i64 1
+; CHECK-NEXT:    ret ptr [[PTR]]
+;
+  %ptr = getelementptr <vscale x 4 x i32>, ptr null, i64 1
+  ret ptr %ptr
+}