[TargetTransformInfo] Static alloca has 0 cost

[Carrot]

Summary

Static alloca usually doesn't generate any machine instructions, so it has 0 cost.

[arsenm]

Maybe should be if it is a statically sized alloca

[hfinkel]

include/llvm/Analysis/TargetTransformInfoImpl.h

743 ↗

(On Diff #115325)

This needs a comment. Also, I think this is only true for static allocas. Dynamic ones will still have a cost. Maybe this should be:

if (auto *A = dyn_cast<AllocaInst>(U))
  if (A->isStaticAlloca())
    return TTI::TTC_Free;

[hfinkel]

LGTM

llvm/trunk/include/llvm/Analysis/TargetTransformInfoImpl.h

for (unsigned Idx = 0, Size = Arguments.size(); Idx != Size; ++Idx)
       ParamTys.push_back(Arguments[Idx]->getType());
     return static_cast<T *>(this)->getIntrinsicCost(IID, RetTy, ParamTys);
   }
 
   unsigned getUserCost(const User *U, ArrayRef<const Value *> Operands) {
     if (isa<PHINode>(U))
       return TTI::TCC_Free; // Model all PHI nodes as free.
 
+    // Static alloca doesn't generate target instructions.
+    if (auto *A = dyn_cast<AllocaInst>(U))
+      if (A->isStaticAlloca())
+        return TTI::TCC_Free;
+
     if (const GEPOperator *GEP = dyn_cast<GEPOperator>(U)) {
       return static_cast<T *>(this)->getGEPCost(GEP->getSourceElementType(),
                                                 GEP->getPointerOperand(),
                                                 Operands.drop_front());
     }
 
     if (auto CS = ImmutableCallSite(U)) {
       const Function *F = CS.getCalledFunction();

llvm/trunk/test/Analysis/CostModel/X86/costmodel.ll

 ; RUN: opt < %s -cost-model -cost-kind=latency -analyze -mtriple=x86_64-unknown-linux-gnu -mcpu=corei7 | FileCheck %s --check-prefix=LATENCY
 ; RUN: opt < %s -cost-model -cost-kind=code-size -analyze -mtriple=x86_64-unknown-linux-gnu -mcpu=corei7 | FileCheck %s --check-prefix=CODESIZE
 
 ; Tests if the interface TargetTransformInfo::getInstructionCost() works correctly.
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 
 define i64 @foo(i64 %arg) {
 
+  ; LATENCY:  cost of 0 {{.*}} alloca i32
+  ; CODESIZE: cost of 0 {{.*}} alloca i32
+  %A1 = alloca i32, align 8
+
+  ; LATENCY:  cost of 1 {{.*}} alloca i64, i64 undef
+  ; CODESIZE: cost of 1 {{.*}} alloca i64, i64 undef
+  %A2 = alloca i64, i64 undef, align 8
+
   ; LATENCY:  cost of 1 {{.*}} %I64 = add
   ; CODESIZE: cost of 1 {{.*}} %I64 = add
   %I64 = add i64 undef, undef
 
   ; LATENCY:  cost of 4 {{.*}} load
   ; CODESIZE: cost of 1 {{.*}} load
   load i64, i64* undef, align 4