[ConstraintElimination] Refactor `checkAndReplaceCondition` (NFC)

[antoniofrighetto]

Summary

Handling true and false constant replacements is now abstracted out into a single lambda function ReplaceCmpWithConstant, so as to reduce code duplication.

[fhahn]

LGTM, thanks! Could you also update llvm/test/Transforms/ConstraintElimination/debug.ll to check printing the negated form?

[nikic]

llvm/lib/Transforms/Scalar/ConstraintElimination.cpp

967–970

llvm/lib/Transforms/Scalar/ConstraintElimination.cpp

static bool checkAndReplaceCondition(
   // about the constraint.
   for (auto &Row : R.ExtraInfo)
     CSToUse.addVariableRow(Row);
   auto InfoRestorer = make_scope_exit([&]() {
     for (unsigned I = 0; I < R.ExtraInfo.size(); ++I)
       CSToUse.popLastConstraint();
   });
 
-  bool Changed = false;
-  if (CSToUse.isConditionImplied(R.Coefficients)) {
+  auto ReplaceCmpWithConstant = [&](CmpInst *Cmp, bool IsTrue) {
     if (!DebugCounter::shouldExecute(EliminatedCounter))
       return false;
 
     LLVM_DEBUG({
-      dbgs() << "Condition " << *Cmp << " implied by dominating constraints\n";
+      if (IsTrue) {
+        dbgs() << "Condition " << *Cmp;
+      } else {
+        auto InversePred = Cmp->getInversePredicate();
+        dbgs() << "Condition " << CmpInst::getPredicateName(InversePred) << " "
+               << *A << ", " << *B;
+      }
+      dbgs() << " implied by dominating constraints\n";
       CSToUse.dump();
     });
+
     generateReproducer(Cmp, ReproducerModule, ReproducerCondStack, Info, DT);
-    Constant *TrueC =
-        ConstantInt::getTrue(CmpInst::makeCmpResultType(Cmp->getType()));
-    Cmp->replaceUsesWithIf(TrueC, [](Use &U) {
+    Constant *ConstantC =
+        IsTrue
+            ? ConstantInt::getTrue(CmpInst::makeCmpResultType(Cmp->getType()))
+            : ConstantInt::getFalse(CmpInst::makeCmpResultType(Cmp->getType()));
+    Cmp->replaceUsesWithIf(ConstantC, [](Use &U) {
       // Conditions in an assume trivially simplify to true. Skip uses
       // in assume calls to not destroy the available information.
       auto *II = dyn_cast<IntrinsicInst>(U.getUser());
       return !II || II->getIntrinsicID() != Intrinsic::assume;
     });
     NumCondsRemoved++;
-    Changed = true;
+    return true;
+  };
+
+  bool Changed = false;
+  bool IsConditionImplied = CSToUse.isConditionImplied(R.Coefficients);
+
+  if (IsConditionImplied) {
+    Changed = ReplaceCmpWithConstant(Cmp, true);
+    if (!Changed)
+      return false;
   }
+
+  // Compute them separately.
   auto Negated = ConstraintSystem::negate(R.Coefficients);
-  if (!Negated.empty() && CSToUse.isConditionImplied(Negated)) {
-    if (!DebugCounter::shouldExecute(EliminatedCounter))
-      return false;
+  auto IsNegatedImplied =
+      !Negated.empty() && CSToUse.isConditionImplied(Negated);
 
-    LLVM_DEBUG({
-      dbgs() << "Condition !" << *Cmp << " implied by dominating constraints\n";
-      CSToUse.dump(); 
-    });
-    generateReproducer(Cmp, ReproducerModule, ReproducerCondStack, Info, DT);
-    Constant *FalseC =
-        ConstantInt::getFalse(CmpInst::makeCmpResultType(Cmp->getType()));
-    Cmp->replaceAllUsesWith(FalseC);
-    NumCondsRemoved++;
-    Changed = true;
+  if (IsNegatedImplied) {
+    Changed = ReplaceCmpWithConstant(Cmp, false);
+    if (!Changed)
+      return false;
   }
+
   return Changed;
 }
 
 static void
 removeEntryFromStack(const StackEntry &E, ConstraintInfo &Info,
                      Module *ReproducerModule,
                      SmallVectorImpl<ReproducerEntry> &ReproducerCondStack,
                      SmallVectorImpl<StackEntry> &DFSInStack) {