[BOLT][NFC] Use llvm::any_of

[Amir]

Summary

Replace the imperative pattern of the following kind

bool IsTrue = false;
for (Element : Range) {
  if (Condition(Element)) {
    IsTrue = true;
    break;
  }
}

with functional style llvm::any_of:

bool IsTrue = llvm::any_of(Range, [&](Element) {
  return Condition(Element);
});

[rafauler]

Nice!

[Amir]

rebase

bolt/include/bolt/Core/DebugData.h

public:
   /// Adds attribute \p AttrTag and \p NewAttrForm in abbreviation declaration
   /// \p Abbrev belonging to CU \p Unit .
   void addAttribute(const DWARFUnit &Unit,
                     const DWARFAbbreviationDeclaration *Abbrev,
                     dwarf::Attribute AttrTag, dwarf::Form AttrForm) {
     assert(&Unit.getContext() == &Context &&
            "cannot update attribute from a different DWARF context");
     std::lock_guard<std::mutex> Lock(WriterMutex);
-    bool AlreadyAdded = false;
-    for (AbbrevEntry &E : NewAbbrevEntries[&Unit][Abbrev])
-      if (E.Attr == AttrTag) {
-        AlreadyAdded = true;
-        break;
-      }
+    bool AlreadyAdded =
+        llvm::any_of(NewAbbrevEntries[&Unit][Abbrev],
+                     [&](AbbrevEntry &E) { return E.Attr == AttrTag; });
 
     if (AlreadyAdded)
       return;
     NewAbbrevEntries[&Unit][Abbrev].emplace_back(
         AbbrevEntry{AttrTag, AttrForm});
   }
 
   /// Return a buffer with concatenated abbrev sections for all CUs and TUs

bolt/lib/Core/BinaryFunction.cpp

for (MCInst &Instr : BB) {
 
         addUnknownControlFlow(BB);
         continue;
       }
 
       // If this block contains an epilogue code and has an indirect branch,
       // then most likely it's a tail call. Otherwise, we cannot tell for sure
       // what it is and conservatively reject the function's CFG.
-      bool IsEpilogue = false;
-      for (const MCInst &Instr : BB) {
-        if (BC.MIB->isLeave(Instr) || BC.MIB->isPop(Instr)) {
-          IsEpilogue = true;
-          break;
-        }
-      }
+      bool IsEpilogue = llvm::any_of(BB, [&](const MCInst &Instr) {
+        return BC.MIB->isLeave(Instr) || BC.MIB->isPop(Instr);
+      });
       if (IsEpilogue) {
         BC.MIB->convertJmpToTailCall(Instr);
         BB.removeAllSuccessors();
         continue;
       }
 
       if (opts::Verbosity >= 2) {
         outs() << "BOLT-INFO: rejected potential indirect tail call in "

bolt/lib/Passes/FrameAnalysis.cpp

if (!FrameOptFunctionNamesFile.empty()) {
     assert(!FrameOptFunctionNamesFile.empty() && "unexpected empty file name");
     std::ifstream FuncsFile(FrameOptFunctionNamesFile, std::ios::in);
     std::string FuncName;
     while (std::getline(FuncsFile, FuncName))
       FrameOptFunctionNames.push_back(FuncName);
     FrameOptFunctionNamesFile = "";
   }
 
-  bool IsValid = true;
-  if (!FrameOptFunctionNames.empty()) {
-    IsValid = false;
-    for (std::string &Name : FrameOptFunctionNames) {
-      if (Function.hasName(Name)) {
-        IsValid = true;
-        break;
-      }
-    }
-  }
-  if (!IsValid)
-    return false;
-
-  return IsValid;
+  if (FrameOptFunctionNames.empty())
+    return true;
+  return llvm::any_of(FrameOptFunctionNames, [&](std::string &Name) {
+    return Function.hasName(Name);
+  });
 }
 } // namespace opts
 
 namespace llvm {
 namespace bolt {
 
 raw_ostream &operator<<(raw_ostream &OS, const FrameIndexEntry &FIE) {
   OS << "FrameIndexEntry<IsLoad: " << FIE.IsLoad << ", IsStore: " << FIE.IsStore

bolt/lib/Passes/PatchEntries.cpp

 //===- bolt/Passes/PatchEntries.cpp - Pass for patching function entries --===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the PatchEntries class that is used for patching
 // the original function entry points.
 //
 //===----------------------------------------------------------------------===//
 
 #include "bolt/Passes/PatchEntries.h"
 #include "bolt/Utils/NameResolver.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/CommandLine.h"
 
 namespace opts {
 
 extern llvm::cl::OptionCategory BoltCategory;
 
 extern llvm::cl::opt<unsigned> Verbosity;
 
 llvm::cl::opt<bool>
     ForcePatch("force-patch",
                llvm::cl::desc("force patching of original entry points"),
                llvm::cl::Hidden, llvm::cl::cat(BoltCategory));
 }
 
 namespace llvm {
 namespace bolt {
 
 void PatchEntries::runOnFunctions(BinaryContext &BC) {
   if (!opts::ForcePatch) {
     // Mark the binary for patching if we did not create external references
     // for original code in any of functions we are not going to emit.
-    bool NeedsPatching = false;
-    for (auto &BFI : BC.getBinaryFunctions()) {
-      BinaryFunction &Function = BFI.second;
-      if (!BC.shouldEmit(Function) && !Function.hasExternalRefRelocations()) {
-        NeedsPatching = true;
-        break;
-      }
-    }
+    bool NeedsPatching = llvm::any_of(
+        llvm::make_second_range(BC.getBinaryFunctions()),
+        [&](BinaryFunction &BF) {
+          return !BC.shouldEmit(BF) && !BF.hasExternalRefRelocations();
+        });
 
     if (!NeedsPatching)
       return;
   }
 
   if (opts::Verbosity >= 1)
     outs() << "BOLT-INFO: patching entries in original code\n";
 

bolt/lib/Passes/ReorderData.cpp

 
 bool filterSymbol(const BinaryData *BD) {
   if (!BD->isAtomic() || BD->isJumpTable() || !BD->isMoveable())
     return false;
 
   bool IsValid = true;
 
   if (!opts::ReorderSymbols.empty()) {
-    IsValid = false;
-    for (const std::string &Name : opts::ReorderSymbols) {
-      if (BD->hasName(Name)) {
-        IsValid = true;
-        break;
-      }
-    }
+    IsValid = llvm::any_of(opts::ReorderSymbols, [&](const std::string &Name) {
+      return BD->hasName(Name);
+    });
   }
 
   if (!IsValid)
     return false;
 
   if (!opts::SkipSymbols.empty()) {
     for (const std::string &Name : opts::SkipSymbols) {
       if (BD->hasName(Name)) {

bolt/lib/Passes/ShrinkWrapping.cpp

BBIterTy ShrinkWrapping::processInsertion(BBIterTy InsertionPoint,
   CurBB->addInstruction(std::move(NewInst));
   LLVM_DEBUG(dbgs() << "Adding to BB!\n");
   return CurBB->end();
 }
 
 BBIterTy ShrinkWrapping::processInsertionsList(
     BBIterTy InsertionPoint, BinaryBasicBlock *CurBB,
     std::vector<WorklistItem> &TodoList, int64_t SPVal, int64_t FPVal) {
-  bool HasInsertions = false;
-  for (WorklistItem &Item : TodoList) {
-    if (Item.Action == WorklistItem::Erase ||
-        Item.Action == WorklistItem::ChangeToAdjustment)
-      continue;
-    HasInsertions = true;
-    break;
-  }
+  bool HasInsertions = llvm::any_of(TodoList, [&](WorklistItem &Item) {
+    return Item.Action == WorklistItem::InsertLoadOrStore ||
+           Item.Action == WorklistItem::InsertPushOrPop;
+  });
 
   if (!HasInsertions)
     return InsertionPoint;
 
   assert(((SPVal != StackPointerTracking::SUPERPOSITION &&
            SPVal != StackPointerTracking::EMPTY) ||
           (FPVal != StackPointerTracking::SUPERPOSITION &&
            FPVal != StackPointerTracking::EMPTY)) &&

bolt/lib/Profile/DataAggregator.cpp

 
 #include "bolt/Profile/DataAggregator.h"
 #include "bolt/Core/BinaryContext.h"
 #include "bolt/Core/BinaryFunction.h"
 #include "bolt/Profile/BoltAddressTranslation.h"
 #include "bolt/Profile/Heatmap.h"
 #include "bolt/Utils/CommandLineOpts.h"
 #include "bolt/Utils/Utils.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/ScopeExit.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/Regex.h"
if (GlobalMMapInfo.count(NameToUse) == 0 && !BuildIDBinaryName.empty()) {
     NameToUse = BuildIDBinaryName;
   }
 
   auto Range = GlobalMMapInfo.equal_range(NameToUse);
   for (auto I = Range.first; I != Range.second; ++I) {
     MMapInfo &MMapInfo = I->second;
     if (BC->HasFixedLoadAddress && MMapInfo.MMapAddress) {
       // Check that the binary mapping matches one of the segments.
-      bool MatchFound = false;
-      for (auto &KV : BC->SegmentMapInfo) {
-        SegmentInfo &SegInfo = KV.second;
+      bool MatchFound = llvm::any_of(
+          llvm::make_second_range(BC->SegmentMapInfo),
+          [&](SegmentInfo &SegInfo) {
             // The mapping is page-aligned and hence the MMapAddress could be
             // different from the segment start address. We cannot know the page
             // size of the mapping, but we know it should not exceed the segment
             // alignment value. Hence we are performing an approximate check.
-        if (SegInfo.Address >= MMapInfo.MMapAddress &&
-            SegInfo.Address - MMapInfo.MMapAddress < SegInfo.Alignment) {
-          MatchFound = true;
-          break;
-        }
-      }
+            return SegInfo.Address >= MMapInfo.MMapAddress &&
+                   SegInfo.Address - MMapInfo.MMapAddress < SegInfo.Alignment;
+          });
       if (!MatchFound) {
         errs() << "PERF2BOLT-WARNING: ignoring mapping of " << NameToUse
                << " at 0x" << Twine::utohexstr(MMapInfo.MMapAddress) << '\n';
         continue;
       }
     }
 
     // Set base address for shared objects.

bolt/lib/Rewrite/RewriteInstance.cpp

 #include "bolt/Rewrite/BinaryPassManager.h"
 #include "bolt/Rewrite/DWARFRewriter.h"
 #include "bolt/Rewrite/ExecutableFileMemoryManager.h"
 #include "bolt/RuntimeLibs/HugifyRuntimeLibrary.h"
 #include "bolt/RuntimeLibs/InstrumentationRuntimeLibrary.h"
 #include "bolt/Utils/CommandLineOpts.h"
 #include "bolt/Utils/Utils.h"
 #include "llvm/ADT/Optional.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugFrame.h"
 #include "llvm/ExecutionEngine/RuntimeDyld.h"
 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCAsmLayout.h"
 #include "llvm/MC/MCDisassembler/MCDisassembler.h"
 #include "llvm/MC/MCObjectStreamer.h"
void RewriteInstance::handleRelocation(const SectionRef &RelocatedSection,
   // Workaround for a member function pointer de-virtualization bug. We check
   // if a non-pc-relative relocation in the code is pointing to (fptr - 1).
   if (IsToCode && ContainingBF && !Relocation::isPCRelative(RType) &&
       (!ReferencedBF || (ReferencedBF->getAddress() != Address))) {
     if (const BinaryFunction *RogueBF =
             BC->getBinaryFunctionAtAddress(Address + 1)) {
       // Do an extra check that the function was referenced previously.
       // It's a linear search, but it should rarely happen.
-      bool Found = false;
-      for (const auto &RelKV : ContainingBF->Relocations) {
-        const Relocation &Rel = RelKV.second;
-        if (Rel.Symbol == RogueBF->getSymbol() &&
-            !Relocation::isPCRelative(Rel.Type)) {
-          Found = true;
-          break;
-        }
-      }
+      bool Found =
+          llvm::any_of(llvm::make_second_range(ContainingBF->Relocations),
+                       [&](const Relocation &Rel) {
+                         return Rel.Symbol == RogueBF->getSymbol() &&
+                                !Relocation::isPCRelative(Rel.Type);
+                       });
 
       if (Found) {
         errs() << "BOLT-WARNING: detected possible compiler de-virtualization "
                   "bug: -1 addend used with non-pc-relative relocation against "
                << formatv("function {0} in function {1}\n", *RogueBF,
                           *ContainingBF);
         return;
       }