[PGO] Fix some style issue of ControlHeightReduction

[hjyamauchi]

Thanks!

lib/Transforms/Instrumentation/ControlHeightReduction.cpp

 
 static cl::opt<std::string> CHRFunctionList(
     "chr-function-list", cl::init(""), cl::Hidden,
     cl::desc("Specify file to retrieve the list of functions to apply CHR to"));
 
 static StringSet<> CHRModules;
 static StringSet<> CHRFunctions;
 
-static void ParseCHRFilterFiles() {
+static void parseCHRFilterFiles() {
   if (!CHRModuleList.empty()) {
     auto FileOrErr = MemoryBuffer::getFile(CHRModuleList);
     if (!FileOrErr) {
       errs() << "Error: Couldn't read the chr-module-list file " << CHRModuleList << "\n";
       std::exit(1);
     }
     StringRef Buf = FileOrErr->get()->getBuffer();
     SmallVector<StringRef, 0> Lines;

 namespace {
 class ControlHeightReductionLegacyPass : public FunctionPass {
 public:
   static char ID;
 
   ControlHeightReductionLegacyPass() : FunctionPass(ID) {
     initializeControlHeightReductionLegacyPassPass(
         *PassRegistry::getPassRegistry());
-    ParseCHRFilterFiles();
+    parseCHRFilterFiles();
   }
 
   bool runOnFunction(Function &F) override;
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.addRequired<BlockFrequencyInfoWrapperPass>();
     AU.addRequired<DominatorTreeWrapperPass>();
     AU.addRequired<ProfileSummaryInfoWrapperPass>();
     AU.addRequired<RegionInfoPass>();
void append(CHRScope *Next) {
     for (RegInfo &RI : Next->RegInfos)
       RegInfos.push_back(RI);
     for (CHRScope *Sub : Next->Subs)
       Subs.push_back(Sub);
   }
 
   void addSub(CHRScope *SubIn) {
 #ifndef NDEBUG
-    bool is_child = false;
+    bool IsChild = false;
     for (RegInfo &RI : RegInfos)
       if (RI.R == SubIn->getParentRegion()) {
-        is_child = true;
+        IsChild = true;
         break;
       }
-    assert(is_child && "Must be a child");
+    assert(IsChild && "Must be a child");
 #endif
     Subs.push_back(SubIn);
   }
 
   // Split this scope at the boundary region into two, which will belong to the
   // tail and returns the tail.
   CHRScope *split(Region *Boundary) {
     assert(Boundary && "Boundary null");
if (auto *I = dyn_cast<Instruction>(V)) {
     return false;
   }
   // Non-instructions are considered hoistable.
   return true;
 }
 
 // Returns true and sets the true probability and false probability of an
 // MD_prof metadata if it's well-formed.
-static bool CheckMDProf(MDNode *MD, BranchProbability &TrueProb,
+static bool checkMDProf(MDNode *MD, BranchProbability &TrueProb,
                         BranchProbability &FalseProb) {
   if (!MD) return false;
   MDString *MDName = cast<MDString>(MD->getOperand(0));
   if (MDName->getString() != "branch_weights" ||
       MD->getNumOperands() != 3)
     return false;
   ConstantInt *TrueWeight = mdconst::extract<ConstantInt>(MD->getOperand(1));
   ConstantInt *FalseWeight = mdconst::extract<ConstantInt>(MD->getOperand(2));
return BranchProbability::getBranchProbability(
       static_cast<uint64_t>(CHRBiasThreshold * 1000000), 1000000);
 }
 
 // A helper for CheckBiasedBranch and CheckBiasedSelect. If TrueProb >=
 // CHRBiasThreshold, put Key into TrueSet and return true. If FalseProb >=
 // CHRBiasThreshold, put Key into FalseSet and return true. Otherwise, return
 // false.
 template<typename K, typename S, typename M>
-bool CheckBias(K *Key, BranchProbability TrueProb, BranchProbability FalseProb,
+bool checkBias(K *Key, BranchProbability TrueProb, BranchProbability FalseProb,
                S &TrueSet, S &FalseSet, M &BiasMap) {
   BranchProbability Threshold = getCHRBiasThreshold();
   if (TrueProb >= Threshold) {
     TrueSet.insert(Key);
     BiasMap[Key] = TrueProb;
     return true;
   } else if (FalseProb >= Threshold) {
     FalseSet.insert(Key);
     BiasMap[Key] = FalseProb;
     return true;
   }
   return false;
 }
 
 // Returns true and insert a region into the right biased set and the map if the
 // branch of the region is biased.
-static bool CheckBiasedBranch(BranchInst *BI, Region *R,
+static bool checkBiasedBranch(BranchInst *BI, Region *R,
                               DenseSet<Region *> &TrueBiasedRegionsGlobal,
                               DenseSet<Region *> &FalseBiasedRegionsGlobal,
                               DenseMap<Region *, BranchProbability> &BranchBiasMap) {
   if (!BI->isConditional())
     return false;
   BranchProbability ThenProb, ElseProb;
-  if (!CheckMDProf(BI->getMetadata(LLVMContext::MD_prof),
+  if (!checkMDProf(BI->getMetadata(LLVMContext::MD_prof),
                    ThenProb, ElseProb))
     return false;
   BasicBlock *IfThen = BI->getSuccessor(0);
   BasicBlock *IfElse = BI->getSuccessor(1);
   assert((IfThen == R->getExit() || IfElse == R->getExit()) &&
          IfThen != IfElse &&
          "Invariant from findScopes");
   if (IfThen == R->getExit()) {
     // Swap them so that IfThen/ThenProb means going into the conditional code
     // and IfElse/ElseProb means skipping it.
     std::swap(IfThen, IfElse);
     std::swap(ThenProb, ElseProb);
   }
   CHR_DEBUG(dbgs() << "BI " << *BI << " ");
   CHR_DEBUG(dbgs() << "ThenProb " << ThenProb << " ");
   CHR_DEBUG(dbgs() << "ElseProb " << ElseProb << "\n");
-  return CheckBias(R, ThenProb, ElseProb,
+  return checkBias(R, ThenProb, ElseProb,
                    TrueBiasedRegionsGlobal, FalseBiasedRegionsGlobal,
                    BranchBiasMap);
 }
 
 // Returns true and insert a select into the right biased set and the map if the
 // select is biased.
-static bool CheckBiasedSelect(
+static bool checkBiasedSelect(
     SelectInst *SI, Region *R,
     DenseSet<SelectInst *> &TrueBiasedSelectsGlobal,
     DenseSet<SelectInst *> &FalseBiasedSelectsGlobal,
     DenseMap<SelectInst *, BranchProbability> &SelectBiasMap) {
   BranchProbability TrueProb, FalseProb;
-  if (!CheckMDProf(SI->getMetadata(LLVMContext::MD_prof),
+  if (!checkMDProf(SI->getMetadata(LLVMContext::MD_prof),
                    TrueProb, FalseProb))
     return false;
   CHR_DEBUG(dbgs() << "SI " << *SI << " ");
   CHR_DEBUG(dbgs() << "TrueProb " << TrueProb << " ");
   CHR_DEBUG(dbgs() << "FalseProb " << FalseProb << "\n");
-  return CheckBias(SI, TrueProb, FalseProb,
+  return checkBias(SI, TrueProb, FalseProb,
                    TrueBiasedSelectsGlobal, FalseBiasedSelectsGlobal,
                    SelectBiasMap);
 }
 
 // Returns the instruction at which to hoist the dependent condition values and
 // insert the CHR branch for a region. This is the terminator branch in the
 // entry block or the first select in the entry block, if any.
 static Instruction* getBranchInsertPoint(RegInfo &RI) {
else
       CHR_DEBUG(dbgs() << "BI null\n");
     if (BI && BI->isConditional()) {
       BasicBlock *S0 = BI->getSuccessor(0);
       BasicBlock *S1 = BI->getSuccessor(1);
       CHR_DEBUG(dbgs() << "S0 " << S0->getName() << "\n");
       CHR_DEBUG(dbgs() << "S1 " << S1->getName() << "\n");
       if (S0 != S1 && (S0 == Exit || S1 == Exit)) {
         RegInfo RI(R);
-        RI.HasBranch = CheckBiasedBranch(
+        RI.HasBranch = checkBiasedBranch(
             BI, R, TrueBiasedRegionsGlobal, FalseBiasedRegionsGlobal,
             BranchBiasMap);
         Result = new CHRScope(RI);
         Scopes.insert(Result);
         CHR_DEBUG(dbgs() << "Found a region with a branch\n");
         ++Stats.NumBranches;
       }
     }
for (RegionNode *E : R->elements()) {
           Selects.push_back(SI);
           ++Stats.NumBranches;
         }
       }
     }
     if (Selects.size() > 0) {
       auto AddSelects = [&](RegInfo &RI) {
         for (auto *SI : Selects)
-          if (CheckBiasedSelect(SI, RI.R,
+          if (checkBiasedSelect(SI, RI.R,
                                 TrueBiasedSelectsGlobal,
                                 FalseBiasedSelectsGlobal,
                                 SelectBiasMap))
             RI.Selects.push_back(SI);
       };
       if (!Result) {
         CHR_DEBUG(dbgs() << "Found a select-only region\n");
         RegInfo RI(R);
CHRScope * CHR::findScopes(Region *R, Region *NextRegion, Region *ParentRegion,
                            SmallVectorImpl<CHRScope *> &Scopes) {
   CHR_DEBUG(dbgs() << "findScopes " << R->getNameStr() << "\n");
   CHRScope *Result = findScope(R);
   // Visit subscopes.
   CHRScope *ConsecutiveSubscope = nullptr;
   SmallVector<CHRScope *, 8> Subscopes;
   for (auto It = R->begin(); It != R->end(); ++It) {
     const std::unique_ptr<Region> &SubR = *It;
-    auto Next_It = std::next(It);
-    Region *NextSubR = Next_It != R->end() ? Next_It->get() : nullptr;
+    auto NextIt = std::next(It);
+    Region *NextSubR = NextIt != R->end() ? NextIt->get() : nullptr;
     CHR_DEBUG(dbgs() << "Looking at subregion " << SubR.get()->getNameStr()
               << "\n");
     CHRScope *SubCHRScope = findScopes(SubR.get(), NextSubR, R, Scopes);
     if (SubCHRScope) {
       CHR_DEBUG(dbgs() << "Subregion Scope " << *SubCHRScope << "\n");
     } else {
       CHR_DEBUG(dbgs() << "Subregion Scope null\n");
     }
if (Intersection.empty()) {
       CHR_DEBUG(dbgs() << "Split. Intersection empty\n");
       return true;
     }
   }
   CHR_DEBUG(dbgs() << "No split\n");
   return false;  // Don't split.
 }
 
-static void GetSelectsInScope(CHRScope *Scope,
+static void getSelectsInScope(CHRScope *Scope,
                               DenseSet<Instruction *> &Output) {
-  for (RegInfo &RI : Scope->RegInfos) {
-    for (SelectInst *SI : RI.Selects) {
+  for (RegInfo &RI : Scope->RegInfos)
+    for (SelectInst *SI : RI.Selects)
       Output.insert(SI);
-    }
-  }
-  for (CHRScope *Sub : Scope->Subs) {
-    GetSelectsInScope(Sub, Output);
-  }
+  for (CHRScope *Sub : Scope->Subs)
+    getSelectsInScope(Sub, Output);
 }
 
 void CHR::splitScopes(SmallVectorImpl<CHRScope *> &Input,
                       SmallVectorImpl<CHRScope *> &Output) {
   for (CHRScope *Scope : Input) {
     assert(!Scope->BranchInsertPoint &&
            "BranchInsertPoint must not be set");
     DenseSet<Instruction *> Unhoistables;
-    GetSelectsInScope(Scope, Unhoistables);
+    getSelectsInScope(Scope, Unhoistables);
     splitScope(Scope, nullptr, nullptr, nullptr, Output, Unhoistables);
   }
 #ifndef NDEBUG
   for (CHRScope *Scope : Output) {
     assert(Scope->BranchInsertPoint && "BranchInsertPoint must be set");
   }
 #endif
 }
assert(Splits.size() == SplitsConditionValues.size() &&
          Splits.size() == SplitsSplitFromOuter.size() &&
          Splits.size() == SplitsInsertPoints.size() && "Mismatching sizes");
   for (size_t I = 0; I < Splits.size(); ++I) {
     CHRScope *Split = Splits[I];
     DenseSet<Value *> &SplitConditionValues = SplitsConditionValues[I];
     Instruction *SplitInsertPoint = SplitsInsertPoints[I];
     SmallVector<CHRScope *, 8> NewSubs;
     DenseSet<Instruction *> SplitUnhoistables;
-    GetSelectsInScope(Split, SplitUnhoistables);
+    getSelectsInScope(Split, SplitUnhoistables);
     for (CHRScope *Sub : Split->Subs) {
       SmallVector<CHRScope *, 8> SubSplits = splitScope(
           Sub, Split, &SplitConditionValues, SplitInsertPoint, Output,
           SplitUnhoistables);
       NewSubs.insert(NewSubs.end(), SubSplits.begin(), SubSplits.end());
     }
     Split->Subs = NewSubs;
   }
for (SelectInst *SI : RI.Selects) {
       hoistValue(SI->getCondition(), HoistPoint, R, Scope->HoistStopMap,
                  HoistedSet, TrivialPHIs);
     }
   }
 }
 
 // Negate the predicate if an ICmp if it's used only by branches or selects by
 // swapping the operands of the branches or the selects. Returns true if success.
-static bool NegateICmpIfUsedByBranchOrSelectOnly(ICmpInst *ICmp,
+static bool negateICmpIfUsedByBranchOrSelectOnly(ICmpInst *ICmp,
                                                  Instruction *ExcludedUser,
                                                  CHRScope *Scope) {
   for (User *U : ICmp->users()) {
     if (U == ExcludedUser)
       continue;
     if (isa<BranchInst>(U) && cast<BranchInst>(U)->isConditional())
       continue;
     if (isa<SelectInst>(U) && cast<SelectInst>(U)->getCondition() == ICmp)
void CHR::addToMergedCondition(bool IsTrueBiased, Value *Cond,
   if (IsTrueBiased) {
     MergedCondition = IRB.CreateAnd(MergedCondition, Cond);
   } else {
     // If Cond is an icmp and all users of V except for BranchOrSelect is a
     // branch, negate the icmp predicate and swap the branch targets and avoid
     // inserting an Xor to negate Cond.
     bool Done = false;
     if (auto *ICmp = dyn_cast<ICmpInst>(Cond))
-      if (NegateICmpIfUsedByBranchOrSelectOnly(ICmp, BranchOrSelect, Scope)) {
+      if (negateICmpIfUsedByBranchOrSelectOnly(ICmp, BranchOrSelect, Scope)) {
         MergedCondition = IRB.CreateAnd(MergedCondition, Cond);
         Done = true;
       }
     if (!Done) {
       Value *Negate = IRB.CreateXor(
           ConstantInt::getTrue(F.getContext()), Cond);
       MergedCondition = IRB.CreateAnd(MergedCondition, Negate);
     }
   }
 }
 
 void CHR::transformScopes(SmallVectorImpl<CHRScope *> &CHRScopes) {
-  unsigned i = 0;
-  (void)(i); // Unused in release build.
+  unsigned I = 0;
   DenseSet<PHINode *> TrivialPHIs;
   for (CHRScope *Scope : CHRScopes) {
     transformScopes(Scope, TrivialPHIs);
     CHR_DEBUG(
         std::ostringstream oss;
-        oss << " after transformScopes " << i++;
+        oss << " after transformScopes " << I++;
         dumpIR(F, oss.str().c_str(), nullptr));
+    (void)I;
   }
 }
 
 static void LLVM_ATTRIBUTE_UNUSED
 dumpScopes(SmallVectorImpl<CHRScope *> &Scopes, const char *Label) {
   dbgs() << Label << " " << Scopes.size() << "\n";
   for (CHRScope *Scope : Scopes) {
     dbgs() << *Scope << "\n";
ProfileSummaryInfo &PSI =
       *getAnalysis<ProfileSummaryInfoWrapperPass>().getPSI();
   RegionInfo &RI = getAnalysis<RegionInfoPass>().getRegionInfo();
   return CHR(F, BFI, DT, PSI, RI).run();
 }
 
 namespace llvm {
 
 ControlHeightReductionPass::ControlHeightReductionPass() {
-  ParseCHRFilterFiles();
+  parseCHRFilterFiles();
 }
 
 PreservedAnalyses ControlHeightReductionPass::run(
     Function &F,
     FunctionAnalysisManager &FAM) {
   auto &BFI = FAM.getResult<BlockFrequencyAnalysis>(F);
   auto &DT = FAM.getResult<DominatorTreeAnalysis>(F);
   auto &MAMProxy = FAM.getResult<ModuleAnalysisManagerFunctionProxy>(F);