[SystemZ::TTI] Improved cost values for comparison against memory.

[jonpa]

Summary

Single instructions exist for i8 and i16 comparisons of memory against a small immediate.

This patch makes sure that if the load in these cases has a single user (the ICmp), it gets a 0 cost (folded), and also that the ICmp gets a cost of 1.

7 loops in 4 files are vectorized differently:

report254 KBDownload

10 files in total differ on SPEC.

[uweigand]

LGTM, thanks!

[jonpa]

r347733

lib/Target/SystemZ/SystemZTargetTransformInfo.cpp

else { // Called with a select instruction.
 
       return getNumVectorRegs(ValTy) /*vsel*/ + PackCost;
     }
   }
   else { // Scalar
     switch (Opcode) {
     case Instruction::ICmp: {
       unsigned Cost = 1;
-      if (ValTy->isIntegerTy() && ValTy->getScalarSizeInBits() <= 16)
+      if (ValTy->isIntegerTy() && ValTy->getScalarSizeInBits() <= 16) {
+        if (I != nullptr) {
+          // Single instruction for comparison of memory with a small immediate.
+          if (const LoadInst* Ld = dyn_cast<LoadInst>(I->getOperand(0))) {
+            const Instruction *FoldedValue = nullptr;
+            if (isFoldableLoad(Ld, FoldedValue))
+              return Cost;
+          }
+        }
         Cost += 2; // extend both operands
+      }
       return Cost;
     }
     case Instruction::Select:
       if (ValTy->isFloatingPointTy())
         return 4; // No load on condition for FP - costs a conditional jump.
       return 1; // Load On Condition.
     }
   }
case Instruction::ICmp:
     // case Instruction::FSub:
     // case Instruction::FMul:
     // case Instruction::FDiv:
 
     // All possible extensions of memory checked above.
     if (SExtBits || ZExtBits)
       return false;
 
+    // Comparison between memory and immediate.
+    if (UserI->getOpcode() == Instruction::ICmp)
+      if (ConstantInt *CI = dyn_cast<ConstantInt>(UserI->getOperand(1)))
+        if (isUInt<16>(CI->getZExtValue()))
+          return true;
+
     unsigned LoadOrTruncBits = (TruncBits ? TruncBits : LoadedBits);
     return (LoadOrTruncBits == 32 || LoadOrTruncBits == 64);
     break;
   }
   return false;
 }
 
 int SystemZTTIImpl::getMemoryOpCost(unsigned Opcode, Type *Src,

test/Analysis/CostModel/SystemZ/cmp-mem.ll

+; RUN: opt < %s -cost-model -analyze -mtriple=systemz-unknown -mcpu=z13 | FileCheck %s
+;
+; Test costs for i8 and i16 comparisons against memory with a small immediate.
+
+define i32 @fun0(i8* %Src, i8* %Dst, i8 %Val) {
+; CHECK: Printing analysis 'Cost Model Analysis' for function 'fun0':
+; CHECK: Cost Model: Found an estimated cost of 0 for instruction:   %Ld = load i8, i8* %Src
+; CHECK: Cost Model: Found an estimated cost of 1 for instruction:   %Cmp = icmp eq i8 %Ld, 123
+; CHECK: Cost Model: Found an estimated cost of 2 for instruction:   %Ret = zext i1 %Cmp to i32
+; CHECK: Cost Model: Found an estimated cost of 0 for instruction:   ret i32 %Ret
+  %Ld = load i8, i8* %Src
+  %Cmp = icmp eq i8 %Ld, 123
+  %Ret = zext i1 %Cmp to i32
+  ret i32 %Ret
+}
+
+define i32 @fun1(i16* %Src, i16* %Dst, i16 %Val) {
+; CHECK: Printing analysis 'Cost Model Analysis' for function 'fun1':
+; CHECK: Cost Model: Found an estimated cost of 0 for instruction:   %Ld = load i16, i16* %Src
+; CHECK: Cost Model: Found an estimated cost of 1 for instruction:   %Cmp = icmp eq i16
+; CHECK: Cost Model: Found an estimated cost of 2 for instruction:   %Ret = zext i1 %Cmp to i32
+; CHECK: Cost Model: Found an estimated cost of 0 for instruction:   ret i32 %Ret
+  %Ld = load i16, i16* %Src
+  %Cmp = icmp eq i16 %Ld, 1234
+  %Ret = zext i1 %Cmp to i32
+  ret i32 %Ret
+}