[InlineCost] Fix scalable vectors in visitAlloca

[c-rhodes]

Summary

Discovered as part of the VLS type work (see D85128).

[efriedma]

llvm/lib/Analysis/InlineCost.cpp

857

This will refuse to inline any function with a scalable vector variable; that seems so conservative that it's likely to cause practical issues. Please take the time to fix the code properly.

[c-rhodes]

llvm/lib/Analysis/InlineCost.cpp

857

This will refuse to inline any function with a scalable vector variable; that seems so conservative that it's likely to cause practical issues. Please take the time to fix the code properly.

Is that not better than crashing? As far as I can tell either getFixedSize will be called causing a crash or it's a dynamic alloca that wont be inlined anyway.

I know we want to support scalable vectors here but unless I'm missing something this seems like a worthwhile improvement for the time being.

[efriedma]

llvm/lib/Analysis/InlineCost.cpp

857

Reading the code, I think you could just replace the uses of getFixedSize() with getKnownMinSize() and get roughly the right behavior.

The reason I don't want to put this off is that inlining is very important for optimizations; if we add a hack now, we're inevitably going to have to look at it again very soon, so I'd rather just get it done now.

[c-rhodes]

Replace getFixedSize with getKnownMinSize rather than skipping scalable vectors.

[c-rhodes]

llvm/lib/Analysis/InlineCost.cpp

857

The reason I don't want to put this off is that inlining is very important for optimizations; if we add a hack now, we're inevitably going to have to look at it again very soon, so I'd rather just get it done now.

No worries, makes sense if it's as trivial as using getKnownMinSize instead

[efriedma]

LGTM

llvm/lib/Analysis/InlineCost.cpp

for (User::op_iterator I = GEP.idx_begin(), E = GEP.idx_end(); I != E; ++I)
     else
       Operands.push_back(*I);
   return TargetTransformInfo::TCC_Free ==
          TTI.getUserCost(&GEP, Operands,
                          TargetTransformInfo::TCK_SizeAndLatency);
 }
 
 bool CallAnalyzer::visitAlloca(AllocaInst &I) {
+  // FIXME: Support scalable vector types.
+  if (isa<ScalableVectorType>(I.getAllocatedType()))
+    return false;
+
   // Check whether inlining will turn a dynamic alloca into a static
   // alloca and handle that case.
   if (I.isArrayAllocation()) {
     Constant *Size = SimplifiedValues.lookup(I.getArraySize());
     if (auto *AllocSize = dyn_cast_or_null<ConstantInt>(Size)) {
       // Sometimes a dynamic alloca could be converted into a static alloca
       // after this constant prop, and become a huge static alloca on an
       // unconditional CFG path. Avoid inlining if this is going to happen above

llvm/test/Transforms/Inline/inline-scalable.ll

+; RUN: opt -S -inline < %s | FileCheck %s
+
+; Test we bail out for scalable vectors.
+define void @func() {
+; CHECK-LABEL: func
+; CHECK-NEXT:    [[VEC_ADDR:%.*]] = alloca <vscale x 4 x i32>
+; CHECK-NEXT:    call void @func()
+; CHECK-NEXT:    ret void
+  %vec.addr = alloca <vscale x 4 x i32>
+  call void @func();
+  ret void
+}