create InstCombine-specific helper and pass function directly

Author: alanzhao1

llvm/include/llvm/IR/ProfDataUtils.h

@@ -189,8 +189,8 @@ LLVM_ABI void setExplicitlyUnknownBranchWeights(Instruction &I,
 /// weights in the new instruction if the parent function of the original
 /// instruction has function counts. This is to not confuse users by injecting
 /// profile data into non-profiled functions.
-LLVM_ABI void setExplicitlyUnknownBranchWeightsIfProfiled(Instruction &New,
-                                                          Instruction &Original,
+LLVM_ABI void setExplicitlyUnknownBranchWeightsIfProfiled(Instruction &I,
+                                                          Function &F,
                                                           StringRef PassName);
 
 /// Analogous to setExplicitlyUnknownBranchWeights, but for functions and their

llvm/lib/IR/ProfDataUtils.cpp

@@ -252,14 +252,11 @@ void setExplicitlyUnknownBranchWeights(Instruction &I, StringRef PassName) {
                    MDB.createString(PassName)}));
 }
 
-void setExplicitlyUnknownBranchWeightsIfProfiled(Instruction &New,
-                                                 Instruction &Original,
+void setExplicitlyUnknownBranchWeightsIfProfiled(Instruction &I, Function &F,
                                                  StringRef PassName) {
-  Function *F = Original.getFunction();
-  assert(F && "instruction does not belong to a function!");
-  std::optional<Function::ProfileCount> EC = F->getEntryCount();
-  if (EC && EC->getCount() > 0)
-    setExplicitlyUnknownBranchWeights(New, PassName);
+  if (std::optional<Function::ProfileCount> EC = F.getEntryCount();
+      EC && EC->getCount() > 0)
+    setExplicitlyUnknownBranchWeights(I, PassName);
 }
 
 void setExplicitlyUnknownFunctionEntryCount(Function &F, StringRef PassName) {

llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp

@@ -882,13 +882,14 @@ Instruction *InstCombinerImpl::foldAddWithConstant(BinaryOperator &Add) {
   SelectInst *SI = nullptr;
   if (match(Op0, m_ZExt(m_Value(X))) &&
       X->getType()->getScalarSizeInBits() == 1)
-    SI = SelectInst::Create(X, InstCombiner::AddOne(Op1C), Op1);
+    SI = createSelectInstMaybeWithUnknownBranchWeights(
+        X, InstCombiner::AddOne(Op1C), Op1, Add.getFunction());
   // sext(bool) + C -> bool ? C - 1 : C
   if (!SI && match(Op0, m_SExt(m_Value(X))) &&
       X->getType()->getScalarSizeInBits() == 1)
-    SI = SelectInst::Create(X, InstCombiner::SubOne(Op1C), Op1);
+    SI = createSelectInstMaybeWithUnknownBranchWeights(
+        X, InstCombiner::SubOne(Op1C), Op1, Add.getFunction());
   if (SI) {
-    setExplicitlyUnknownBranchWeightsIfProfiled(*SI, Add, DEBUG_TYPE);
     return SI;
   }
 

llvm/lib/Transforms/InstCombine/InstCombineInternal.h

@@ -23,6 +23,7 @@
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/InstVisitor.h"
 #include "llvm/IR/PatternMatch.h"
+#include "llvm/IR/ProfDataUtils.h"
 #include "llvm/IR/Value.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/KnownBits.h"
@@ -469,6 +470,18 @@ class LLVM_LIBRARY_VISIBILITY InstCombinerImpl final
   Value *simplifyNonNullOperand(Value *V, bool HasDereferenceable,
                                 unsigned Depth = 0);
 
+  static SelectInst *createSelectInstMaybeWithUnknownBranchWeights(
+      Value *C, Value *S1, Value *S2, Function *F, const Twine &NameStr = "",
+      InsertPosition InsertBefore = nullptr, Instruction *MDFrom = nullptr) {
+    SelectInst *SI =
+        SelectInst::Create(C, S1, S2, NameStr, InsertBefore, MDFrom);
+    if (!SI) {
+      assert(F && "provided parent function is nullptr!");
+      setExplicitlyUnknownBranchWeightsIfProfiled(*SI, *F, DEBUG_TYPE);
+    }
+    return SI;
+  }
+
 public:
   /// Create and insert the idiom we use to indicate a block is unreachable
   /// without having to rewrite the CFG from within InstCombine.

llvm/lib/Transforms/InstCombine/InstCombineShifts.cpp

@@ -1254,9 +1254,8 @@ Instruction *InstCombinerImpl::visitShl(BinaryOperator &I) {
     // shl (zext i1 X), C1 --> select (X, 1 << C1, 0)
     if (match(Op0, m_ZExt(m_Value(X))) && X->getType()->isIntOrIntVectorTy(1)) {
       auto *NewC = Builder.CreateShl(ConstantInt::get(Ty, 1), C1);
-      auto *SI = SelectInst::Create(X, NewC, ConstantInt::getNullValue(Ty));
-      setExplicitlyUnknownBranchWeightsIfProfiled(*SI, I, DEBUG_TYPE);
-      return SI;
+      return createSelectInstMaybeWithUnknownBranchWeights(
+          X, NewC, ConstantInt::getNullValue(Ty), I.getFunction());
     }
   }
 

llvm/lib/Transforms/InstCombine/InstructionCombining.cpp

@@ -1736,9 +1736,8 @@ Instruction *InstCombinerImpl::foldBinopOfSextBoolToSelect(BinaryOperator &BO) {
   Constant *Zero = ConstantInt::getNullValue(BO.getType());
   Value *TVal = Builder.CreateBinOp(BO.getOpcode(), Ones, C);
   Value *FVal = Builder.CreateBinOp(BO.getOpcode(), Zero, C);
-  SelectInst *SI = SelectInst::Create(X, TVal, FVal);
-  setExplicitlyUnknownBranchWeightsIfProfiled(*SI, BO, DEBUG_TYPE);
-  return SI;
+  return createSelectInstMaybeWithUnknownBranchWeights(X, TVal, FVal,
+                                                       BO.getFunction());
 }
 
 static Value *simplifyOperationIntoSelectOperand(Instruction &I, SelectInst *SI,