[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

bool CallAnalyzer::isGEPFree(GetElementPtrInst &GEP) {
   return TargetTransformInfo::TCC_Free ==
          TTI.getUserCost(&GEP, Operands,
                          TargetTransformInfo::TCK_SizeAndLatency);
 }
 
 bool CallAnalyzer::visitAlloca(AllocaInst &I) {
   // 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
       // a threshold.
       // FIXME: If the threshold is removed or lowered too much, we could end up
       // being too pessimistic and prevent inlining non-problematic code. This
       // could result in unintended perf regressions. A better overall strategy
       // is needed to track stack usage during inlining.
       Type *Ty = I.getAllocatedType();
       AllocatedSize = SaturatingMultiplyAdd(
-          AllocSize->getLimitedValue(), DL.getTypeAllocSize(Ty).getFixedSize(),
+          AllocSize->getLimitedValue(), DL.getTypeAllocSize(Ty).getKnownMinSize(),
           AllocatedSize);
       if (AllocatedSize > InlineConstants::MaxSimplifiedDynamicAllocaToInline) {
         HasDynamicAlloca = true;
         return false;
       }
       return Base::visitAlloca(I);
     }
   }
 
   // Accumulate the allocated size.
   if (I.isStaticAlloca()) {
     Type *Ty = I.getAllocatedType();
     AllocatedSize =
-        SaturatingAdd(DL.getTypeAllocSize(Ty).getFixedSize(), AllocatedSize);
+        SaturatingAdd(DL.getTypeAllocSize(Ty).getKnownMinSize(), AllocatedSize);
   }
 
   // We will happily inline static alloca instructions.
   if (I.isStaticAlloca())
     return Base::visitAlloca(I);
 
   // FIXME: This is overly conservative. Dynamic allocas are inefficient for
   // a variety of reasons, and so we would like to not inline them into

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

+; RUN: opt -S -inline < %s | FileCheck %s
+
+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
+}