Don't keep simplified value unless recurison depth is 1.

Add a test for that case.

Author: hassnaaHamdi

llvm/lib/Analysis/InlineCost.cpp

@@ -1741,10 +1741,13 @@ bool CallAnalyzer::simplifyCmpInstForRecCall(CmpInst &Cmp) {
         cast<CmpInst>(&Cmp), {CallArg, Cmp.getOperand(1)}, SQ);
     if (auto *ConstVal = dyn_cast_or_null<ConstantInt>(SimplifiedInstruction)) {
       bool IsTrueSuccessor = CallBB == Br->getSuccessor(0);
-      SimplifiedValues[&Cmp] = ConstVal;
-      if (ConstVal->isOne())
-        return !IsTrueSuccessor;
-      return IsTrueSuccessor;
+      // Make sure that the BB of the recursive call is NOT the next successor
+      // of the icmp. In other words, make sure that the recursion depth is 1.
+      if ((ConstVal->isOne() && !IsTrueSuccessor) ||
+          (ConstVal->isZero() && IsTrueSuccessor)) {
+        SimplifiedValues[&Cmp] = ConstVal;
+        return true;
+      }
     }
   }
   return false;

llvm/test/Transforms/Inline/inline-recursive-fn.ll

@@ -153,3 +153,41 @@ if.end:                                           ; preds = %entry
   %mul = fmul float %x, %scale
   br label %common.ret18
 }
+
+; Test when the icmp can be simplified but the recurison depth is NOT 1,
+; so the recursive call will not be inlined.
+define float @no_inline_rec_depth_not_1(float %x, float %scale) {
+; CHECK-LABEL: define float @no_inline_rec_depth_not_1(
+; CHECK-SAME: float [[X:%.*]], float [[SCALE:%.*]]) {
+; CHECK-NEXT:  [[ENTRY:.*:]]
+; CHECK-NEXT:    [[CMP:%.*]] = fcmp olt float [[X]], 0.000000e+00
+; CHECK-NEXT:    br i1 [[CMP]], label %[[IF_THEN:.*]], label %[[IF_END:.*]]
+; CHECK:       [[COMMON_RET18:.*]]:
+; CHECK-NEXT:    [[COMMON_RET18_OP:%.*]] = phi float [ [[CALL:%.*]], %[[IF_THEN]] ], [ [[MUL:%.*]], %[[IF_END]] ]
+; CHECK-NEXT:    ret float [[COMMON_RET18_OP]]
+; CHECK:       [[IF_THEN]]:
+; CHECK-NEXT:    [[CALL]] = tail call float @no_inline_rec_depth_not_1(float [[X]], float [[SCALE]])
+; CHECK-NEXT:    br label %[[COMMON_RET18]]
+; CHECK:       [[IF_END]]:
+; CHECK-NEXT:    [[MUL]] = fmul float [[X]], [[SCALE]]
+; CHECK-NEXT:    br label %[[COMMON_RET18]]
+;
+entry:
+  %cmp = fcmp olt float %x, 0.000000e+00
+  br i1 %cmp, label %if.then, label %if.end
+
+common.ret18:                                     ; preds = %if.then, %if.end
+  %common.ret18.op = phi float [ %call, %if.then ], [ %mul, %if.end ]
+  ret float %common.ret18.op
+
+if.then:                                          ; preds = %entry
+  %fneg1 = fneg float %x
+  %fneg = fneg float %fneg1
+  %call = tail call float @no_inline_rec_depth_not_1(float %fneg, float %scale)
+  br label %common.ret18
+
+if.end:                                           ; preds = %entry
+  %mul = fmul float %x, %scale
+  br label %common.ret18
+}
+