[BOLT][NFC] Move getLTOCommonName to Utils

[Amir]

Summary

Reuse getLTOCommonName in components other than Profile (to be used in Core)

[maksfb]

LGTM

bolt/include/bolt/Profile/ProfileReaderBase.h

 
 namespace llvm {
 namespace bolt {
 
 class BinaryContext;
 class BinaryFunction;
 class BoltAddressTranslation;
 
-/// LTO-generated function names take a form:
-///
-///   <function_name>.lto_priv.<decimal_number>/...
-///     or
-///   <function_name>.constprop.<decimal_number>/...
-///
-/// they can also be:
-///
-///   <function_name>.lto_priv.<decimal_number1>.lto_priv.<decimal_number2>/...
-///
-/// The <decimal_number> is a global counter used for the whole program. As a
-/// result, a tiny change in a program may affect the naming of many LTO
-/// functions. For us this means that if we do a precise name matching, then
-/// a large set of functions could be left without a profile.
-///
-/// To solve this issue, we try to match a function to any profile:
-///
-///   <function_name>.(lto_priv|consprop).*
-///
-/// The name before an asterisk above represents a common LTO name for a family
-/// of functions. Later, out of all matching profiles we pick the one with the
-/// best match.
-///
-/// Return a common part of LTO name for a given \p Name.
-std::optional<StringRef> getLTOCommonName(const StringRef Name);
-
 class ProfileReaderBase {
 protected:
   /// Name of the file with profile.
   std::string Filename;
 
 public:
   ProfileReaderBase() = delete;
   ProfileReaderBase(const ProfileReaderBase &) = delete;

bolt/include/bolt/Utils/Utils.h

 void check_error(Error E, Twine Message);
 
 /// Return the name with escaped whitespace and backslash characters
 std::string getEscapedName(const StringRef &Name);
 
 /// Return the unescaped name
 std::string getUnescapedName(const StringRef &Name);
 
+/// LTO-generated function names take a form:
+///
+///   <function_name>.lto_priv.<decimal_number>/...
+///     or
+///   <function_name>.constprop.<decimal_number>/...
+///
+/// they can also be:
+///
+///   <function_name>.lto_priv.<decimal_number1>.lto_priv.<decimal_number2>/...
+///
+/// The <decimal_number> is a global counter used for the whole program. As a
+/// result, a tiny change in a program may affect the naming of many LTO
+/// functions. For us this means that if we do a precise name matching, then
+/// a large set of functions could be left without a profile.
+///
+/// To solve this issue, we try to match a function to any profile:
+///
+///   <function_name>.(lto_priv|consprop).*
+///
+/// The name before an asterisk above represents a common LTO name for a family
+/// of functions. Later, out of all matching profiles we pick the one with the
+/// best match.
+///
+/// Return a common part of LTO name for a given \p Name.
+std::optional<StringRef> getLTOCommonName(const StringRef Name);
+
 // Determines which register a given DWARF expression is being assigned to.
 // If the expression is defining the CFA, return std::nullopt.
 std::optional<uint8_t> readDWARFExpressionTargetReg(StringRef ExprBytes);
 
 } // namespace bolt
 
 bool operator==(const llvm::MCCFIInstruction &L,
                 const llvm::MCCFIInstruction &R);
 
 } // namespace llvm
 
 #endif

bolt/lib/Profile/DataReader.cpp

DumpData("dump-data",
   cl::Hidden,
   cl::cat(BoltCategory));
 
 } // namespace opts
 
 namespace llvm {
 namespace bolt {
 
-std::optional<StringRef> getLTOCommonName(const StringRef Name) {
-  for (StringRef Suffix : {".__uniq.", ".lto_priv.", ".constprop.", ".llvm."}) {
-    size_t LTOSuffixPos = Name.find(Suffix);
-    if (LTOSuffixPos != StringRef::npos)
-      return Name.substr(0, LTOSuffixPos + Suffix.size());
-  }
-  return std::nullopt;
-}
-
 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;
 

bolt/lib/Rewrite/BoltDiff.cpp

 //===- bolt/Rewrite/BoltDiff.cpp ------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // RewriteInstance methods related to comparing one instance to another, used
 // by the boltdiff tool to print a report.
 //
 //===----------------------------------------------------------------------===//
 
 #include "bolt/Passes/IdenticalCodeFolding.h"
 #include "bolt/Profile/ProfileReaderBase.h"
 #include "bolt/Rewrite/RewriteInstance.h"
+#include "bolt/Utils/Utils.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/CommandLine.h"
 
 #undef  DEBUG_TYPE
 #define DEBUG_TYPE "boltdiff"
 
 using namespace llvm;
 using namespace object;

bolt/lib/Utils/Utils.cpp

std::string getUnescapedName(const StringRef &Name) {
   std::string Output = Name.str();
   for (size_t I = 0; I < Output.size(); ++I)
     if (Output[I] == '\\')
       Output.erase(I++, 1);
 
   return Output;
 }
 
+std::optional<StringRef> getLTOCommonName(const StringRef Name) {
+  for (StringRef Suffix : {".__uniq.", ".lto_priv.", ".constprop.", ".llvm."}) {
+    size_t LTOSuffixPos = Name.find(Suffix);
+    if (LTOSuffixPos != StringRef::npos)
+      return Name.substr(0, LTOSuffixPos + Suffix.size());
+  }
+  return std::nullopt;
+}
+
 std::optional<uint8_t> readDWARFExpressionTargetReg(StringRef ExprBytes) {
   uint8_t Opcode = ExprBytes[0];
   if (Opcode == dwarf::DW_CFA_def_cfa_expression)
     return std::nullopt;
   assert((Opcode == dwarf::DW_CFA_expression ||
           Opcode == dwarf::DW_CFA_val_expression) &&
          "invalid DWARF expression CFI");
   assert(ExprBytes.size() > 1 && "DWARF expression CFI is too short");