[InlineCost] Consider branches with !make.implicit metadata as free.

[dantrushin]

Summary

!make.implicit metadata attached to branch means it will very likely
be eliminated (together with associated cmp instruction).

[apilipenko]

Looks good.

llvm/lib/Analysis/InlineCost.cpp

if (RHSBase && LHSBase == RHSBase) {
       if (Constant *C = ConstantExpr::getICmp(I.getPredicate(), CLHS, CRHS)) {
         SimplifiedValues[&I] = C;
         ++NumConstantPtrCmps;
         return true;
       }
     }
   }
 
+  auto isImplicitNullCheckCmp = [](const CmpInst &I) {
+    for (auto *User : I.users())
+      if (auto *Instr = dyn_cast<Instruction>(User))
+        if (!Instr->getMetadata(LLVMContext::MD_make_implicit))
+          return false;
+    return true;
+  };
+
   // If the comparison is an equality comparison with null, we can simplify it
   // if we know the value (argument) can't be null
-  if (I.isEquality() && isa<ConstantPointerNull>(I.getOperand(1)) &&
-      isKnownNonNullInCallee(I.getOperand(0))) {
+  if (I.isEquality() && isa<ConstantPointerNull>(I.getOperand(1))) {
+    if (isKnownNonNullInCallee(I.getOperand(0))) {
       bool IsNotEqual = I.getPredicate() == CmpInst::ICMP_NE;
       SimplifiedValues[&I] = IsNotEqual ? ConstantInt::getTrue(I.getType())
                                         : ConstantInt::getFalse(I.getType());
       return true;
     }
+    // Implicit null checks act as unconditional branches and their comparisons
+    // should be treated as simplified and free of cost.
+    if (isImplicitNullCheckCmp(I))
+      return true;
+  }
   return handleSROA(I.getOperand(0), isa<ConstantPointerNull>(I.getOperand(1)));
 }
 
 bool CallAnalyzer::visitSub(BinaryOperator &I) {
   // Try to handle a special case: we can fold computing the difference of two
   // constant-related pointers.
   Value *LHS = I.getOperand(0), *RHS = I.getOperand(1);
   Value *LHSBase, *RHSBase;

 }
 
 bool CallAnalyzer::visitBranchInst(BranchInst &BI) {
   // We model unconditional branches as essentially free -- they really
   // shouldn't exist at all, but handling them makes the behavior of the
   // inliner more regular and predictable. Interestingly, conditional branches
   // which will fold away are also free.
   return BI.isUnconditional() || isa<ConstantInt>(BI.getCondition()) ||
+         BI.getMetadata(LLVMContext::MD_make_implicit) ||
          isa_and_nonnull<ConstantInt>(
              SimplifiedValues.lookup(BI.getCondition()));
 }
 
 bool CallAnalyzer::visitSelectInst(SelectInst &SI) {
   bool CheckSROA = SI.getType()->isPointerTy();
   Value *TrueVal = SI.getTrueValue();
   Value *FalseVal = SI.getFalseValue();

llvm/test/Transforms/Inline/implicit-null-check.ll

+; RUN: opt -passes=inline -inline-threshold=10 -S < %s | FileCheck %s
+
+declare void @foo()
+
+; CHECK-LABEL: @caller
+; CHECK-NOT:   %res = call i64 @callee(ptr %p)
+define i64 @caller(ptr %p) {
+  %res = call i64 @callee(ptr %p)
+  ret i64 %res
+}
+
+define i64 @callee(ptr %p) {
+  %null_check = icmp eq ptr %p, null
+  br i1 %null_check, label %is_null, label %non_null, !make.implicit !0
+
+is_null:
+  call void @foo()
+  ret i64 0
+
+non_null:
+  ret i64 1
+}
+
+!0 = !{}