[SystemZ] Make sure not to call getZExtValue on a >64 bit constant.

[jonpa]

Summary

Add checks for the bit width in two places in SystemZTargetTransformInfo.cpp

[RKSimon]

test case?

llvm/lib/Target/SystemZ/SystemZTargetTransformInfo.cpp

863

Bit tricky without context diff but I think you can just use C->isZero() and drop the ScalarBits limit

1023

You should be able to do this with CI->getValue().isIntN(16) - no need for getBitWidth() checks

[jonpa]

Thanks for review!

Patch updated per review with new test cases.

[RKSimon]

LGTM with one minor

llvm/test/Analysis/CostModel/SystemZ/huge-immediates.ll

1

Might be worth adding a FileCheck - you can use update_analyze_test_checks.py to handle it.

[jonpa]

llvm/test/Analysis/CostModel/SystemZ/huge-immediates.ll

1

The reason that I left that out is that the cost values for these i72 instructions do not quite make sense. A comparison with an i72 immediate gets the cost of '1', which is certainly too little.

However, we do not care about those costs, so it makes most sense to me then to not check for their values either.

Is it then ok to leave it as is, or is it better for some reason to auto-generate the full test with the CHECKs?

[RKSimon]

llvm/test/Analysis/CostModel/SystemZ/huge-immediates.ll

1

yes its ok to leave them out if you don't think they're useful - sometimes you learn something "interesting" by including them (especially for non-legal types)

[jonpa]

Committed as 370a8c8.

llvm/lib/Target/SystemZ/SystemZTargetTransformInfo.cpp

if (!ValTy->isVectorTy()) {
     switch (Opcode) {
     case Instruction::ICmp: {
       // A loaded value compared with 0 with multiple users becomes Load and
       // Test. The load is then not foldable, so return 0 cost for the ICmp.
       unsigned ScalarBits = ValTy->getScalarSizeInBits();
       if (I != nullptr && ScalarBits >= 32)
         if (LoadInst *Ld = dyn_cast<LoadInst>(I->getOperand(0)))
           if (const ConstantInt *C = dyn_cast<ConstantInt>(I->getOperand(1)))
             if (!Ld->hasOneUse() && Ld->getParent() == I->getParent() &&
-                C->getZExtValue() == 0)
+                C->isZero())
               return 0;
 
       unsigned Cost = 1;
       if (ValTy->isIntegerTy() && ValTy->getScalarSizeInBits() <= 16)
         Cost += (I != nullptr ? getOperandsExtensionCost(I) : 2);
       return Cost;
     }
     case Instruction::Select:
case Instruction::Xor:
     // case Instruction::FMul:
     // case Instruction::FDiv:
 
     // All possible extensions of memory checked above.
 
     // Comparison between memory and immediate.
     if (UserI->getOpcode() == Instruction::ICmp)
       if (ConstantInt *CI = dyn_cast<ConstantInt>(UserI->getOperand(1)))
-        if (isUInt<16>(CI->getZExtValue()))
+        if (CI->getValue().isIntN(16))
           return true;
     return (LoadOrTruncBits == 32 || LoadOrTruncBits == 64);
     break;
   }
   return false;
 }
 
 static bool isBswapIntrinsicCall(const Value *V) {

llvm/test/Analysis/CostModel/SystemZ/huge-immediates.ll

+; RUN: opt < %s -cost-model -analyze -mtriple=systemz-unknown -mcpu=z13
+;
+; Test that cost functions can handle immediates of more than 64 bits without crashing.
+
+; Cost of a load which is checked for folding into a compare w/ memory.
+define i32 @fun0(i72* %Src) {
+  %L = load i72, i72* %Src
+  %B = icmp ult i72 %L, 166153499473114484112
+  %Res = zext i1 %B to i32
+  ret i32 %Res
+}
+
+; Cost of a compare which is checked for elimination by Load and Test.
+define i32 @fun1(i72* %Src, i72* %Dst) {
+  %L = load i72, i72* %Src
+  store i72 %L, i72* %Dst
+  %B = icmp ult i72 %L, 166153499473114484112
+  %Res = zext i1 %B to i32
+  ret i32 %Res
+}