[IPSCCP] Partial support for constrained intrinsics

[kpn]

Summary

This teaches the SCCP Solver about some of the constrained intrinsics by having them use the same codepaths as the non-constrained instructions.

Casting instructions along with the binary operators will come later.

[fhahn]

llvm/lib/IR/Instruction.cpp

694 ↗

(On Diff #394265)

I think this change is strictly independent of supporting constrained intrinsics in SCCP and should be separate I think.

llvm/test/Transforms/SCCP/strictfp-float-nan-simplification.ll

1 ↗

(On Diff #394265)

could you preocmmit the tests?

[nikic]

llvm/lib/IR/Instruction.cpp

694 ↗

(On Diff #394265)

I think it would be better to address this by switching SCCP to use isInstructionTriviallyDead() instead. In fact, if we switch SCCP and FunctionSpecialization, we can drop this method entirely, as these seem to be the only users. Don't really see why we need a second, worse implementation if this functionality.

[kpn]

Update for review comments. I've also reduced it down to just fcmp and fcmps having a functional impact. I don't have a good way to test the binary operators just yet.

[kpn]

Ping

[nikic]

Why isn't this already handled by ConstantFoldCall?

[kpn]

In D115737#3615950, @nikic wrote:

Why isn't this already handled by ConstantFoldCall?

Because ConstantFoldCall() is called from handleCallResult(), and we're skipping that part of handleCallBase() due to having constrained fcmp/fcmps behave just like the non-constrained. Instead we're constant folding in visitCmpInst().

Also, a constrained fcmp/fcmps is !isa<Function>, so while it is not overdefined, it does not fall into the block in markUsersAsChanged() that calls ConstantFoldCall().

I'll update the diff in a minute with the right set of tests...

[kpn]

Rebase.

Update to use more targeted tests.

This still leaves fhahn's request not done because that's what D118392 is for.

[nikic]

In D115737#3831400, @kpn wrote:

In D115737#3615950, @nikic wrote:

Why isn't this already handled by ConstantFoldCall?

Because ConstantFoldCall() is called from handleCallResult(), and we're skipping that part of handleCallBase() due to having constrained fcmp/fcmps behave just like the non-constrained. Instead we're constant folding in visitCmpInst().

Sorry, what I meant is: Why is this not handled by ConstantFoldCall() prior to your changes? There should be no need for special handling of these intrinsics here.

From a cursory look, I think the problem is that handleCallOverdefined() doesn't deal with metadata operands. I expect that if you fix this, then constrained intrinsics will "just work".

[kpn]

Abandoned in favor of D136466.

llvm/lib/Transforms/Utils/SCCPSolver.cpp

private:
 
   void visitReturnInst(ReturnInst &I);
   void visitTerminator(Instruction &TI);
 
   void visitCastInst(CastInst &I);
   void visitSelectInst(SelectInst &I);
   void visitUnaryOperator(Instruction &I);
   void visitBinaryOperator(Instruction &I);
-  void visitCmpInst(CmpInst &I);
+  void visitCmpInst(Instruction &I);
   void visitExtractValueInst(ExtractValueInst &EVI);
   void visitInsertValueInst(InsertValueInst &IVI);
 
   void visitCatchSwitchInst(CatchSwitchInst &CPI) {
     markOverdefined(&CPI);
     visitTerminator(CPI);
   }
 
void SCCPInstVisitor::visitBinaryOperator(Instruction &I) {
   ConstantRange R = A.binaryOp(cast<BinaryOperator>(&I)->getOpcode(), B);
   mergeInValue(&I, ValueLatticeElement::getRange(R));
 
   // TODO: Currently we do not exploit special values that produce something
   // better than overdefined with an overdefined operand for vector or floating
   // point types, like and <4 x i32> overdefined, zeroinitializer.
 }
 
-// Handle ICmpInst instruction.
-void SCCPInstVisitor::visitCmpInst(CmpInst &I) {
+// Handle ICmpInst and FCmpInst instruction.
+void SCCPInstVisitor::visitCmpInst(Instruction &I) {
+  assert((isa<CmpInst>(I) || isa<ConstrainedFPCmpIntrinsic>(I)) && "Wrong class of Instruction!");
   // Do not cache this lookup, getValueState calls later in the function might
   // invalidate the reference.
   if (isOverdefined(ValueState[&I]))
     return (void)markOverdefined(&I);
 
   Value *Op1 = I.getOperand(0);
   Value *Op2 = I.getOperand(1);
 
   // For parameters, use ParamState which includes constant range info if
   // available.
   auto V1State = getValueState(Op1);
   auto V2State = getValueState(Op2);
 
-  Constant *C = V1State.getCompare(I.getPredicate(), I.getType(), V2State);
+  FCmpInst::Predicate IPred;
+  if (isa<CmpInst>(I)) {
+    CmpInst *CI = cast<CmpInst>(&I);
+    IPred = CI->getPredicate();
+  }
+  else {
+    ConstrainedFPCmpIntrinsic *CCI = cast<ConstrainedFPCmpIntrinsic>(&I);
+    IPred = CCI->getPredicate();
+  }
+  Constant *C = V1State.getCompare(IPred, I.getType(), V2State);
   if (C) {
     // TODO: getCompare() currently has incorrect handling for unknown/undef.
     if (isa<UndefValue>(C))
       return;
     ValueLatticeElement CV;
     CV.markConstant(C);
     mergeInValue(&I, CV);
     return;
if (Constant *C = ConstantFoldLoadFromConstPtr(Ptr, I.getType(), DL))
       return (void)markConstant(IV, &I, C);
   }
 
   // Fall back to metadata.
   mergeInValue(&I, getValueFromMetadata(&I));
 }
 
 void SCCPInstVisitor::visitCallBase(CallBase &CB) {
+  auto *CFP = dyn_cast<ConstrainedFPIntrinsic>(&CB);
+  if (CFP) {
+    switch ((Intrinsic::ID)CFP->getIntrinsicID()) {
+    case Intrinsic::experimental_constrained_fadd:
+    case Intrinsic::experimental_constrained_fsub:
+    case Intrinsic::experimental_constrained_fmul:
+    case Intrinsic::experimental_constrained_fdiv:
+    case Intrinsic::experimental_constrained_frem:
+      // FIXME: return (void) visitBinaryOperator(CB);
+      break;
+    case Intrinsic::experimental_constrained_fptosi:
+    case Intrinsic::experimental_constrained_sitofp:
+    case Intrinsic::experimental_constrained_fptoui:
+    case Intrinsic::experimental_constrained_uitofp:
+      // FIXME: return (void) visitCastInst(CB);
+      break;
+    case Intrinsic::experimental_constrained_fcmp:
+    case Intrinsic::experimental_constrained_fcmps:
+      return (void) visitCmpInst(CB);
+      break;
+    default:
+      // We only examine the constrained intrinsics that replace
+      // llvm instructions.
+      break;
+    }
+  }
   handleCallResult(CB);
   handleCallArguments(CB);
 }
 
 void SCCPInstVisitor::handleCallOverdefined(CallBase &CB) {
   Function *F = CB.getCalledFunction();
 
   // Void return and not tracking callee, just bail.

llvm/test/Transforms/SCCP/strictfp-phis-fcmp.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -passes=sccp -S | FileCheck %s
 
 define i1 @float.1.defaultenv(i1 %cmp) #0 {
 ; CHECK-LABEL: @float.1.defaultenv(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[CMP:%.*]], label [[IF_TRUE:%.*]], label [[END:%.*]]
 ; CHECK:       if.true:
 ; CHECK-NEXT:    br label [[END]]
 ; CHECK:       end:
-; CHECK-NEXT:    [[C:%.*]] = call i1 @llvm.experimental.constrained.fcmp.f32(float 1.000000e+00, float 1.000000e+00, metadata !"ueq", metadata !"fpexcept.ignore") #[[ATTR0:[0-9]+]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
 
 entry:
   br i1 %cmp, label %if.true, label %end
 
 if.true:
   br label %end
 
 end:
   %p = phi float [ 1.0, %entry ], [ 1.0, %if.true]
   %c = call i1 @llvm.experimental.constrained.fcmp.i1.f32(float %p, float 1.0, metadata !"ueq", metadata !"fpexcept.ignore") #0
 
   ret i1 %c
 }
 
 define i1 @float.1.maytrap(i1 %cmp) #0 {
 ; CHECK-LABEL: @float.1.maytrap(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[CMP:%.*]], label [[IF_TRUE:%.*]], label [[END:%.*]]
 ; CHECK:       if.true:
 ; CHECK-NEXT:    br label [[END]]
 ; CHECK:       end:
-; CHECK-NEXT:    [[C:%.*]] = call i1 @llvm.experimental.constrained.fcmp.f32(float 1.000000e+00, float 1.000000e+00, metadata !"ueq", metadata !"fpexcept.maytrap") #[[ATTR0]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
 
 entry:
   br i1 %cmp, label %if.true, label %end
 
 if.true:
   br label %end
 
 end:
   %p = phi float [ 1.0, %entry ], [ 1.0, %if.true]
   %c = call i1 @llvm.experimental.constrained.fcmp.i1.f32(float %p, float 1.0, metadata !"ueq", metadata !"fpexcept.maytrap") #0
 
   ret i1 %c
 }
 
 define i1 @float.1.strict(i1 %cmp) #0 {
 ; CHECK-LABEL: @float.1.strict(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[CMP:%.*]], label [[IF_TRUE:%.*]], label [[END:%.*]]
 ; CHECK:       if.true:
 ; CHECK-NEXT:    br label [[END]]
 ; CHECK:       end:
-; CHECK-NEXT:    [[C:%.*]] = call i1 @llvm.experimental.constrained.fcmp.f32(float 1.000000e+00, float 1.000000e+00, metadata !"ueq", metadata !"fpexcept.strict") #[[ATTR0]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    [[C:%.*]] = call i1 @llvm.experimental.constrained.fcmp.f32(float 1.000000e+00, float 1.000000e+00, metadata !"ueq", metadata !"fpexcept.strict") #[[ATTR0:[0-9]+]]
+; CHECK-NEXT:    ret i1 true
 ;
 
 entry:
   br i1 %cmp, label %if.true, label %end
 
 if.true:
   br label %end
 

 
 define i1 @float.4_unreachable.defaultenv(float %f, i1 %cmp) #0 {
 ; CHECK-LABEL: @float.4_unreachable.defaultenv(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[CMP:%.*]], label [[IF_TRUE:%.*]], label [[END:%.*]]
 ; CHECK:       if.true:
 ; CHECK-NEXT:    br label [[END]]
 ; CHECK:       end:
-; CHECK-NEXT:    [[C:%.*]] = call i1 @llvm.experimental.constrained.fcmp.f32(float 1.000000e+00, float 1.000000e+00, metadata !"une", metadata !"fpexcept.ignore") #[[ATTR0]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 false
 ;
 
 entry:
   br i1 %cmp, label %if.true, label %end
 
 if.true:
   br label %end
 
 dead:
   br label %end
 
 end:
   %p = phi float [ 1.0, %entry ], [ 1.0, %if.true], [ %f, %dead ]
   %c = call i1 @llvm.experimental.constrained.fcmp.i1.f32(float %p, float 1.0, metadata !"une", metadata !"fpexcept.ignore") #0
   ret i1 %c
 }
 
 define i1 @float.4_unreachable.maytrap(float %f, i1 %cmp) #0 {
 ; CHECK-LABEL: @float.4_unreachable.maytrap(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[CMP:%.*]], label [[IF_TRUE:%.*]], label [[END:%.*]]
 ; CHECK:       if.true:
 ; CHECK-NEXT:    br label [[END]]
 ; CHECK:       end:
-; CHECK-NEXT:    [[C:%.*]] = call i1 @llvm.experimental.constrained.fcmp.f32(float 1.000000e+00, float 1.000000e+00, metadata !"une", metadata !"fpexcept.maytrap") #[[ATTR0]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 false
 ;
 
 entry:
   br i1 %cmp, label %if.true, label %end
 
 if.true:
   br label %end
 

 define i1 @float.4_unreachable.strict(float %f, i1 %cmp) #0 {
 ; CHECK-LABEL: @float.4_unreachable.strict(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[CMP:%.*]], label [[IF_TRUE:%.*]], label [[END:%.*]]
 ; CHECK:       if.true:
 ; CHECK-NEXT:    br label [[END]]
 ; CHECK:       end:
 ; CHECK-NEXT:    [[C:%.*]] = call i1 @llvm.experimental.constrained.fcmp.f32(float 1.000000e+00, float 1.000000e+00, metadata !"une", metadata !"fpexcept.strict") #[[ATTR0]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 false
 ;
 
 entry:
   br i1 %cmp, label %if.true, label %end
 
 if.true:
   br label %end
 

llvm/test/Transforms/SCCP/strictfp-phis-fcmps.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -passes=sccp -S | FileCheck %s
 
 define i1 @float.1.defaultenv(i1 %cmp) #0 {
 ; CHECK-LABEL: @float.1.defaultenv(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[CMP:%.*]], label [[IF_TRUE:%.*]], label [[END:%.*]]
 ; CHECK:       if.true:
 ; CHECK-NEXT:    br label [[END]]
 ; CHECK:       end:
-; CHECK-NEXT:    [[C:%.*]] = call i1 @llvm.experimental.constrained.fcmps.f32(float 1.000000e+00, float 1.000000e+00, metadata !"ueq", metadata !"fpexcept.ignore") #[[ATTR0:[0-9]+]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
 
 entry:
   br i1 %cmp, label %if.true, label %end
 
 if.true:
   br label %end
 
 end:
   %p = phi float [ 1.0, %entry ], [ 1.0, %if.true]
   %c = call i1 @llvm.experimental.constrained.fcmps.i1.f32(float %p, float 1.0, metadata !"ueq", metadata !"fpexcept.ignore") #0
 
   ret i1 %c
 }
 
 define i1 @float.1.maytrap(i1 %cmp) #0 {
 ; CHECK-LABEL: @float.1.maytrap(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[CMP:%.*]], label [[IF_TRUE:%.*]], label [[END:%.*]]
 ; CHECK:       if.true:
 ; CHECK-NEXT:    br label [[END]]
 ; CHECK:       end:
-; CHECK-NEXT:    [[C:%.*]] = call i1 @llvm.experimental.constrained.fcmps.f32(float 1.000000e+00, float 1.000000e+00, metadata !"ueq", metadata !"fpexcept.maytrap") #[[ATTR0]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
 
 entry:
   br i1 %cmp, label %if.true, label %end
 
 if.true:
   br label %end
 
 end:
   %p = phi float [ 1.0, %entry ], [ 1.0, %if.true]
   %c = call i1 @llvm.experimental.constrained.fcmps.i1.f32(float %p, float 1.0, metadata !"ueq", metadata !"fpexcept.maytrap") #0
 
   ret i1 %c
 }
 
 define i1 @float.1.strict(i1 %cmp) #0 {
 ; CHECK-LABEL: @float.1.strict(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[CMP:%.*]], label [[IF_TRUE:%.*]], label [[END:%.*]]
 ; CHECK:       if.true:
 ; CHECK-NEXT:    br label [[END]]
 ; CHECK:       end:
-; CHECK-NEXT:    [[C:%.*]] = call i1 @llvm.experimental.constrained.fcmps.f32(float 1.000000e+00, float 1.000000e+00, metadata !"ueq", metadata !"fpexcept.strict") #[[ATTR0]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    [[C:%.*]] = call i1 @llvm.experimental.constrained.fcmps.f32(float 1.000000e+00, float 1.000000e+00, metadata !"ueq", metadata !"fpexcept.strict") #[[ATTR0:[0-9]+]]
+; CHECK-NEXT:    ret i1 true
 ;
 
 entry:
   br i1 %cmp, label %if.true, label %end
 
 if.true:
   br label %end
 

 }
 
 define i1 @float.4_unreachable.defaultenv(float %f, i1 %cmp) #0 {
 ; CHECK-LABEL: @float.4_unreachable.defaultenv(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[CMP:%.*]], label [[IF_TRUE:%.*]], label [[END:%.*]]
 ; CHECK:       if.true:
 ; CHECK-NEXT:    br label [[END]]
+; CHECK:       dead:
+; CHECK-NEXT:    br label [[END]]
 ; CHECK:       end:
-; CHECK-NEXT:    [[C:%.*]] = call i1 @llvm.experimental.constrained.fcmps.f32(float 1.000000e+00, float 1.000000e+00, metadata !"une", metadata !"fpexcept.ignore") #[[ATTR0]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 false
 ;
 
 entry:
   br i1 %cmp, label %if.true, label %end
 
 if.true:
   br label %end
 
 dead:
   br label %end
 
 end:
   %p = phi float [ 1.0, %entry ], [ 1.0, %if.true], [ %f, %dead ]
   %c = call i1 @llvm.experimental.constrained.fcmps.i1.f32(float %p, float 1.0, metadata !"une", metadata !"fpexcept.ignore") #0
   ret i1 %c
 }
 
 define i1 @float.4_unreachable.maytrap(float %f, i1 %cmp) #0 {
 ; CHECK-LABEL: @float.4_unreachable.maytrap(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[CMP:%.*]], label [[IF_TRUE:%.*]], label [[END:%.*]]
 ; CHECK:       if.true:
 ; CHECK-NEXT:    br label [[END]]
+; CHECK:       dead:
+; CHECK-NEXT:    br label [[END]]
 ; CHECK:       end:
-; CHECK-NEXT:    [[C:%.*]] = call i1 @llvm.experimental.constrained.fcmps.f32(float 1.000000e+00, float 1.000000e+00, metadata !"une", metadata !"fpexcept.maytrap") #[[ATTR0]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 false
 ;
 
 entry:
   br i1 %cmp, label %if.true, label %end
 
 if.true:
   br label %end
 
 dead:
   br label %end
 
 end:
   %p = phi float [ 1.0, %entry ], [ 1.0, %if.true], [ %f, %dead ]
   %c = call i1 @llvm.experimental.constrained.fcmps.i1.f32(float %p, float 1.0, metadata !"une", metadata !"fpexcept.maytrap") #0
   ret i1 %c
 }
 
 ; FIXME: It's a shame we can't eliminate this fcmps here:
 define i1 @float.4_unreachable.strict(float %f, i1 %cmp) #0 {
 ; CHECK-LABEL: @float.4_unreachable.strict(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[CMP:%.*]], label [[IF_TRUE:%.*]], label [[END:%.*]]
 ; CHECK:       if.true:
 ; CHECK-NEXT:    br label [[END]]
+; CHECK:       dead:
+; CHECK-NEXT:    br label [[END]]
 ; CHECK:       end:
 ; CHECK-NEXT:    [[C:%.*]] = call i1 @llvm.experimental.constrained.fcmps.f32(float 1.000000e+00, float 1.000000e+00, metadata !"une", metadata !"fpexcept.strict") #[[ATTR0]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 false
 ;
 
 entry:
   br i1 %cmp, label %if.true, label %end
 
 if.true:
   br label %end