[BOLT][NFC] Simplify YAMLProfileReader

[Amir]

Summary

• Add FunctionSet type alias.
• Use any_of
• Use ErrorOr handling pattern

bolt/include/bolt/Profile/YAMLProfileReader.h

private:
   bool NormalizeByCalls{false};
 
   /// Binary profile in YAML format.
   yaml::bolt::BinaryProfile YamlBP;
 
   /// Map a function ID from a YAML profile to a BinaryFunction object.
   std::vector<BinaryFunction *> YamlProfileToFunction;
 
+  using FunctionSet = std::unordered_set<const BinaryFunction *>;
   /// To keep track of functions that have a matched profile before the profile
   /// is attributed.
-  std::unordered_set<const BinaryFunction *> ProfiledFunctions;
+  FunctionSet ProfiledFunctions;
 
   /// For LTO symbol resolution.
   /// Map a common LTO prefix to a list of YAML profiles matching the prefix.
   StringMap<std::vector<yaml::bolt::BinaryFunctionProfile *>> LTOCommonNameMap;
 
   /// Map a common LTO prefix to a set of binary functions.
-  StringMap<std::unordered_set<const BinaryFunction *>>
-      LTOCommonNameFunctionMap;
+  StringMap<FunctionSet> LTOCommonNameFunctionMap;
 
   /// Strict matching of a name in a profile to its contents.
   StringMap<yaml::bolt::BinaryFunctionProfile *> ProfileNameToProfile;
 
   /// Populate \p Function profile with the one supplied in YAML format.
   bool parseFunctionProfile(BinaryFunction &Function,
                             const yaml::bolt::BinaryFunctionProfile &YamlBF);
 

bolt/lib/Profile/YAMLProfileReader.cpp

llvm::cl::opt<bool> ProfileUseDFS("profile-use-dfs",
                                   cl::desc("use DFS order for YAML profile"),
                                   cl::Hidden, cl::cat(BoltOptCategory));
 }
 
 namespace llvm {
 namespace bolt {
 
 bool YAMLProfileReader::isYAML(const StringRef Filename) {
-  ErrorOr<std::unique_ptr<MemoryBuffer>> MB =
-      MemoryBuffer::getFileOrSTDIN(Filename);
-  if (std::error_code EC = MB.getError())
-    report_error(Filename, EC);
-  StringRef Buffer = MB.get()->getBuffer();
-  if (Buffer.startswith("---\n"))
-    return true;
+  if (auto MB = MemoryBuffer::getFileOrSTDIN(Filename)) {
+    StringRef Buffer = (*MB)->getBuffer();
+    return Buffer.startswith("---\n");
+  } else {
+    report_error(Filename, MB.getError());
+  }
   return false;
 }
 
 void YAMLProfileReader::buildNameMaps(
     std::map<uint64_t, BinaryFunction> &Functions) {
   for (yaml::bolt::BinaryFunctionProfile &YamlBF : YamlBP.Functions) {
     StringRef Name = YamlBF.Name;
     const size_t Pos = Name.find("(*");
     if (Pos != StringRef::npos)
       Name = Name.substr(0, Pos);
     ProfileNameToProfile[Name] = &YamlBF;
     if (const std::optional<StringRef> CommonName = getLTOCommonName(Name))
       LTOCommonNameMap[*CommonName].push_back(&YamlBF);
   }
   for (auto &BFI : Functions) {
     const BinaryFunction &Function = BFI.second;
     for (StringRef Name : Function.getNames())
       if (const std::optional<StringRef> CommonName = getLTOCommonName(Name))
         LTOCommonNameFunctionMap[*CommonName].insert(&Function);
   }
 }
 
 bool YAMLProfileReader::hasLocalsWithFileName() const {
-  for (const StringMapEntry<yaml::bolt::BinaryFunctionProfile *> &KV :
-       ProfileNameToProfile) {
-    const StringRef &FuncName = KV.getKey();
-    if (FuncName.count('/') == 2 && FuncName[0] != '/')
-      return true;
-  }
-  return false;
+  return llvm::any_of(ProfileNameToProfile.keys(), [](StringRef FuncName) {
+    return FuncName.count('/') == 2 && FuncName[0] != '/';
+  });
 }
 
 bool YAMLProfileReader::parseFunctionProfile(
     BinaryFunction &BF, const yaml::bolt::BinaryFunctionProfile &YamlBF) {
   BinaryContext &BC = BF.getBinaryContext();
 
   const bool IsDFSOrder = YamlBP.Header.IsDFSOrder;
   bool ProfileMatched = true;
bool YAMLProfileReader::mayHaveProfileData(const BinaryFunction &BF) {
   return false;
 }
 
 Error YAMLProfileReader::readProfile(BinaryContext &BC) {
   YamlProfileToFunction.resize(YamlBP.Functions.size() + 1);
 
   auto profileMatches = [](const yaml::bolt::BinaryFunctionProfile &Profile,
                            BinaryFunction &BF) {
-    if (opts::IgnoreHash && Profile.NumBasicBlocks == BF.size())
-      return true;
-    if (!opts::IgnoreHash &&
-        Profile.Hash == static_cast<uint64_t>(BF.getHash()))
-      return true;
-    return false;
+    if (opts::IgnoreHash)
+      return Profile.NumBasicBlocks == BF.size();
+    return Profile.Hash == static_cast<uint64_t>(BF.getHash());
   };
 
   // We have to do 2 passes since LTO introduces an ambiguity in function
   // names. The first pass assigns profiles that match 100% by name and
   // by hash. The second pass allows name ambiguity for LTO private functions.
   for (auto &BFI : BC.getBinaryFunctions()) {
     BinaryFunction &Function = BFI.second;