[llvm][misexpect][NFC] Small code cleanups in MisExpect.cpp

[paulkirth]

Summary

• Replace magic number w/ constant
• expand uses of auto to the explicit type
• Rename variables to be more consistent w/ existing convention

[paulkirth]

Rebase.

llvm/lib/IR/ProfDataUtils.cpp

MDNode *getBranchWeightMDNode(const Instruction &I) {
   auto *ProfileData = I.getMetadata(LLVMContext::MD_prof);
   if (!isBranchWeightMD(ProfileData))
     return nullptr;
   return ProfileData;
 }
 
 MDNode *getValidBranchWeightMDNode(const Instruction &I) {
   auto *ProfileData = getBranchWeightMDNode(I);
-  if (ProfileData && ProfileData->getNumOperands() == 1 + I.getNumSuccessors())
+  if (ProfileData &&
+      ProfileData->getNumOperands() == WeightsIdx + I.getNumSuccessors())
     return ProfileData;
   return nullptr;
 }
 
 bool extractBranchWeights(const MDNode *ProfileData,
                           SmallVectorImpl<uint32_t> &Weights) {
   if (!isBranchWeightMD(ProfileData))
     return false;
   return extractWeights(ProfileData, Weights);
 }
 
 bool extractBranchWeights(const Instruction &I,
                           SmallVectorImpl<uint32_t> &Weights) {
-  auto *ProfileData = I.getMetadata(LLVMContext::MD_prof);
+  MDNode *ProfileData = I.getMetadata(LLVMContext::MD_prof);
   return extractBranchWeights(ProfileData, Weights);
 }
 
 bool extractBranchWeights(const Instruction &I, uint64_t &TrueVal,
                           uint64_t &FalseVal) {
   assert((I.getOpcode() == Instruction::Br ||
           I.getOpcode() == Instruction::Select) &&
          "Looking for branch weights on something besides branch, select, or "
          "switch");
 
   SmallVector<uint32_t, 2> Weights;
-  auto *ProfileData = I.getMetadata(LLVMContext::MD_prof);
+  MDNode *ProfileData = I.getMetadata(LLVMContext::MD_prof);
   if (!extractBranchWeights(ProfileData, Weights))
     return false;
 
   if (Weights.size() > 2)
     return false;
 
   TrueVal = Weights[0];
   FalseVal = Weights[1];

llvm/lib/Transforms/Utils/MisExpect.cpp

 uint32_t getMisExpectTolerance(LLVMContext &Ctx) {
   return std::max(static_cast<uint32_t>(MisExpectTolerance),
                   Ctx.getDiagnosticsMisExpectTolerance());
 }
 
 Instruction *getInstCondition(Instruction *I) {
   assert(I != nullptr && "MisExpect target Instruction cannot be nullptr");
   Instruction *Ret = nullptr;
-  if (auto *B = dyn_cast<BranchInst>(I)) {
-    Ret = dyn_cast<Instruction>(B->getCondition());
+  if (auto *BI = dyn_cast<BranchInst>(I)) {
+    Ret = dyn_cast<Instruction>(BI->getCondition());
   }
   // TODO: Find a way to resolve condition location for switches
   // Using the condition of the switch seems to often resolve to an earlier
   // point in the program, i.e. the calculation of the switch condition, rather
   // than the switch's location in the source code. Thus, we should use the
   // instruction to get source code locations rather than the condition to
   // improve diagnostic output, such as the caret. If the same problem exists
   // for branch instructions, then we should remove this function and directly
   // use the instruction
   //
-  else if (auto *S = dyn_cast<SwitchInst>(I)) {
-    Ret = dyn_cast<Instruction>(S->getCondition());
+  else if (auto *SI = dyn_cast<SwitchInst>(I)) {
+    Ret = dyn_cast<Instruction>(SI->getCondition());
   }
   return Ret ? Ret : I;
 }
 
 void emitMisexpectDiagnostic(Instruction *I, LLVMContext &Ctx,
                              uint64_t ProfCount, uint64_t TotalCount) {
   double PercentageCorrect = (double)ProfCount / TotalCount;
   auto PerString =
void verifyMisExpect(Instruction &I, ArrayRef<uint32_t> RealWeights,
   // assert((TotalBranchWeight >= LikelyBranchWeight) && (TotalBranchWeight > 0)
   //              && "TotalBranchWeight is less than the Likely branch weight");
   if ((TotalBranchWeight == 0) || (TotalBranchWeight <= LikelyBranchWeight))
     return;
 
   // To determine our threshold value we need to obtain the branch probability
   // for the weights added by llvm.expect and use that proportion to calculate
   // our threshold based on the collected profile data.
-  auto LikelyProbablilty = BranchProbability::getBranchProbability(
+  BranchProbability LikelyProbablilty = BranchProbability::getBranchProbability(
       LikelyBranchWeight, TotalBranchWeight);
 
   uint64_t ScaledThreshold = LikelyProbablilty.scale(RealWeightsTotal);
 
   // clamp tolerance range to [0, 100)
-  auto Tolerance = getMisExpectTolerance(I.getContext());
+  uint32_t Tolerance = getMisExpectTolerance(I.getContext());
   Tolerance = std::clamp(Tolerance, 0u, 99u);
 
   // Allow users to relax checking by N%  i.e., if they use a 5% tolerance,
   // then we check against 0.95*ScaledThreshold
   if (Tolerance > 0)
     ScaledThreshold *= (1.0 - Tolerance / 100.0);
 
   // When the profile weight is below the threshold, we emit the diagnostic