[BOLT][NFC] Move hasVolatileName into BinaryFunction

[maksfb]

LGTM

bolt/include/bolt/Core/BinaryFunction.h

 #include "bolt/Core/BinaryContext.h"
 #include "bolt/Core/BinaryLoop.h"
 #include "bolt/Core/BinarySection.h"
 #include "bolt/Core/DebugData.h"
 #include "bolt/Core/FunctionLayout.h"
 #include "bolt/Core/JumpTable.h"
 #include "bolt/Core/MCPlus.h"
 #include "bolt/Utils/NameResolver.h"
+#include "bolt/Utils/Utils.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/iterator.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCDwarf.h"
std::vector<StringRef> getNames() const {
     forEachName([&AllNames](StringRef Name) {
       AllNames.push_back(Name);
       return false;
     });
 
     return AllNames;
   }
 
+  /// Return true if the function name can change across compilations.
+  bool hasVolatileName() const {
+    return llvm::any_of(getNames(), getLTOCommonName);
+  }
+
   /// Return a state the function is in (see BinaryFunction::State definition
   /// for description).
   State getState() const { return CurrentState; }
 
   /// Return true if function has a control flow graph available.
   bool hasCFG() const {
     return getState() == State::CFG || getState() == State::CFG_Finalized ||
            getState() == State::EmittedCFG;

bolt/lib/Profile/DataReader.cpp

 
 } // namespace opts
 
 namespace llvm {
 namespace bolt {
 
 namespace {
 
-/// Return true if the function name can change across compilations.
-bool hasVolatileName(const BinaryFunction &BF) {
-  for (const StringRef &Name : BF.getNames())
-    if (getLTOCommonName(Name))
-      return true;
-
-  return false;
-}
-
 /// Return standard escaped name of the function possibly renamed by BOLT.
 std::string normalizeName(StringRef NameRef) {
   // Strip "PG." prefix used for globalized locals.
   NameRef = NameRef.startswith("PG.") ? NameRef.substr(2) : NameRef;
   return getEscapedName(NameRef);
 }
 
 } // anonymous namespace
if (BF.ProfileMatchRatio == 1.0f) {
       }
       return;
     }
   }
 
   // Check if the function name can fluctuate between several compilations
   // possibly triggered by minor unrelated code changes in the source code
   // of the input binary.
-  if (!hasVolatileName(BF))
+  if (!BF.hasVolatileName())
     return;
 
   // Check for a profile that matches with 100% confidence.
   const std::vector<FuncBranchData *> AllBranchData =
       getBranchDataForNamesRegex(BF.getNames());
   for (FuncBranchData *NewBranchData : AllBranchData) {
     // Prevent functions from sharing the same profile.
     if (NewBranchData->Used)
bool DataReader::mayHaveProfileData(const BinaryFunction &Function) {
   if (getBranchData(Function) || getMemData(Function))
     return true;
 
   if (getFuncSampleData(Function.getNames()) ||
       getBranchDataForNames(Function.getNames()) ||
       getMemDataForNames(Function.getNames()))
     return true;
 
-  if (!hasVolatileName(Function))
+  if (!Function.hasVolatileName())
     return false;
 
   const std::vector<FuncBranchData *> AllBranchData =
       getBranchDataForNamesRegex(Function.getNames());
   if (!AllBranchData.empty())
     return true;
 
   const std::vector<FuncMemData *> AllMemData =