From 638cd0356dc0cc8a184191703481f0d5adf2877f Mon Sep 17 00:00:00 2001
From: Benjamin Kramer <benny.kra@googlemail.com>
Date: Thu, 31 Mar 2016 10:42:40 +0000
Subject: [PATCH] [TTI] Let the cost model estimate ctpop costs based on
 legality

PPC has a vector popcount, this lets the vectorizer use the correct cost
for it. Tweak X86 test to use an intrinsic that's actually scalarized (we
have a somewhat efficient lowering for vector popcount using SSE, the
cost model finds that now).

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@265005 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/llvm/CodeGen/BasicTTIImpl.h       | 10 +++++++++-
 test/Analysis/CostModel/PowerPC/popcnt.ll | 11 +++++++++++
 test/Analysis/CostModel/X86/scalarize.ll  | 16 ++++++++--------
 3 files changed, 28 insertions(+), 9 deletions(-)
 create mode 100644 test/Analysis/CostModel/PowerPC/popcnt.ll

diff --git a/include/llvm/CodeGen/BasicTTIImpl.h b/include/llvm/CodeGen/BasicTTIImpl.h
index db9960c1aa08..476f0d5fb538 100644
--- a/include/llvm/CodeGen/BasicTTIImpl.h
+++ b/include/llvm/CodeGen/BasicTTIImpl.h
@@ -621,6 +621,7 @@ class BasicTTIImplBase : public TargetTransformInfoImplCRTPBase<T> {
   unsigned getIntrinsicInstrCost(Intrinsic::ID IID, Type *RetTy,
                                  ArrayRef<Type *> Tys) {
     unsigned ISD = 0;
+    unsigned SingleCallCost = 10; // Library call cost. Make it expensive.
     switch (IID) {
     default: {
       // Assume that we need to scalarize this intrinsic.
@@ -725,6 +726,13 @@ class BasicTTIImplBase : public TargetTransformInfoImplCRTPBase<T> {
     case Intrinsic::masked_load:
       return static_cast<T *>(this)
           ->getMaskedMemoryOpCost(Instruction::Load, RetTy, 0, 0);
+    case Intrinsic::ctpop:
+      ISD = ISD::CTPOP;
+      // In case of legalization use TCC_Expensive. This is cheaper than a
+      // library call but still not a cheap instruction.
+      SingleCallCost = TargetTransformInfo::TCC_Expensive;
+      break;
+    // FIXME: ctlz, cttz, ...
     }
 
     const TargetLoweringBase *TLI = getTLI();
@@ -785,7 +793,7 @@ class BasicTTIImplBase : public TargetTransformInfoImplCRTPBase<T> {
     }
 
     // This is going to be turned into a library call, make it expensive.
-    return 10;
+    return SingleCallCost;
   }
 
   /// \brief Compute a cost of the given call instruction.
diff --git a/test/Analysis/CostModel/PowerPC/popcnt.ll b/test/Analysis/CostModel/PowerPC/popcnt.ll
new file mode 100644
index 000000000000..4bd842db09b6
--- /dev/null
+++ b/test/Analysis/CostModel/PowerPC/popcnt.ll
@@ -0,0 +1,11 @@
+; RUN: opt < %s -cost-model -analyze -mtriple=powerpc64-unknown-linux-gnu -mcpu=pwr8 | FileCheck %s
+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-f128:128:128-v128:128:128-n32:64"
+target triple = "powerpc64-unknown-linux-gnu"
+
+define <4 x i32> @test1(<4 x i32> %arg) {
+  ; CHECK: cost of 1 {{.*}} call <4 x i32> @llvm.ctpop.v4i32
+  %ctpop = call <4 x i32> @llvm.ctpop.v4i32(<4 x i32> %arg)
+  ret <4 x i32> %ctpop
+}
+
+declare <4 x i32> @llvm.ctpop.v4i32(<4 x i32>)
diff --git a/test/Analysis/CostModel/X86/scalarize.ll b/test/Analysis/CostModel/X86/scalarize.ll
index fc25fcbc563f..f124de50699a 100644
--- a/test/Analysis/CostModel/X86/scalarize.ll
+++ b/test/Analysis/CostModel/X86/scalarize.ll
@@ -13,8 +13,8 @@
 declare %i4 @llvm.bswap.v4i32(%i4)
 declare %i8 @llvm.bswap.v2i64(%i8)
 
-declare %i4 @llvm.ctpop.v4i32(%i4)
-declare %i8 @llvm.ctpop.v2i64(%i8)
+declare %i4 @llvm.cttz.v4i32(%i4)
+declare %i8 @llvm.cttz.v2i64(%i8)
 
 ; CHECK32-LABEL: test_scalarized_intrinsics
 ; CHECK64-LABEL: test_scalarized_intrinsics
@@ -28,12 +28,12 @@ define void @test_scalarized_intrinsics() {
 ; CHECK64: cost of 6 {{.*}}bswap.v2i64
         %r3 = call %i8 @llvm.bswap.v2i64(%i8 undef)
 
-; CHECK32: cost of 12 {{.*}}ctpop.v4i32
-; CHECK64: cost of 12 {{.*}}ctpop.v4i32
-        %r4 = call %i4 @llvm.ctpop.v4i32(%i4 undef)
-; CHECK32: cost of 10 {{.*}}ctpop.v2i64
-; CHECK64: cost of 6 {{.*}}ctpop.v2i64
-        %r5 = call %i8 @llvm.ctpop.v2i64(%i8 undef)
+; CHECK32: cost of 12 {{.*}}cttz.v4i32
+; CHECK64: cost of 12 {{.*}}cttz.v4i32
+        %r4 = call %i4 @llvm.cttz.v4i32(%i4 undef)
+; CHECK32: cost of 10 {{.*}}cttz.v2i64
+; CHECK64: cost of 6 {{.*}}cttz.v2i64
+        %r5 = call %i8 @llvm.cttz.v2i64(%i8 undef)
 
 ; CHECK32: ret
 ; CHECK64: ret