Add helper functions and remove hard coded references to instProf related name/name-prefixes

[davidxl]

Summary

This is a clean up patch that defines instr prof section and variable name prefixes in a common header with access helper functions. clang FE change will be done as a follow up once this patch is in.

[davidxl]

Justin, any comments on this one? There is no functional change involved.

llvm/trunk/include/llvm/ProfileData/InstrProf.h

 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MD5.h"
 #include <cstdint>
 #include <list>
 #include <system_error>
 #include <vector>
 
 namespace llvm {
+
+inline StringRef getInstrProfCountersSectionName(bool AddSegment) {
+  return AddSegment ? "__DATA,__llvm_prf_cnts" : "__llvm_prf_cnts";
+}
+
+inline StringRef getInstrProfNameSectionName(bool AddSegment) {
+  return AddSegment ? "__DATA,__llvm_prf_names" : "__llvm_prf_names";
+}
+
+inline StringRef getInstrProfDataSectionName(bool AddSegment) {
+  return AddSegment ? "__DATA,__llvm_prf_data" : "__llvm_prf_data";
+}
+
+inline StringRef getInstrProfCoverageSectionName(bool AddSegment) {
+  return AddSegment ? "__DATA,__llvm_covmap" : "__llvm_covmap";
+}
+
+inline StringRef getInstrProfNameVarPrefix() { return "__llvm_profile_names_"; }
+
+inline StringRef getInstrProfDataVarPrefix() { return "__llvm_profile_data_"; }
+
+inline StringRef getInstrProfCountersVarPrefix() {
+  return "__llvm_profile_counters_";
+}
+
+inline StringRef getInstrProfComdatPrefix() { return "__llvm_profile_vars_"; }
+
+inline StringRef getCoverageMappingVarName() {
+  return "__llvm_coverage_mapping";
+}
+
 const std::error_category &instrprof_category();
 
 enum class instrprof_error {
   success = 0,
   eof,
   bad_magic,
   bad_header,
   unsupported_version,

llvm/trunk/lib/ProfileData/CoverageMappingReader.cpp

if (auto *Universal = dyn_cast<object::MachOUniversalBinary>(Bin.get())) {
     return coveragemap_error::malformed;
 
   // The coverage uses native pointer sizes for the object it's written in.
   BytesInAddress = OF->getBytesInAddress();
   Endian = OF->isLittleEndian() ? support::endianness::little
                                 : support::endianness::big;
 
   // Look for the sections that we are interested in.
-  auto NamesSection = lookupSection(*OF, "__llvm_prf_names");
+  auto NamesSection = lookupSection(*OF, getInstrProfNameSectionName(false));
   if (auto EC = NamesSection.getError())
     return EC;
-  auto CoverageSection = lookupSection(*OF, "__llvm_covmap");
+  auto CoverageSection =
+      lookupSection(*OF, getInstrProfCoverageSectionName(false));
   if (auto EC = CoverageSection.getError())
     return EC;
 
   // Get the contents of the given sections.
   if (std::error_code EC = CoverageSection->getContents(CoverageMapping))
     return EC;
   if (std::error_code EC = ProfileNames.load(*NamesSection))
     return EC;

llvm/trunk/lib/Transforms/Instrumentation/InstrProfiling.cpp

 //===-- InstrProfiling.cpp - Frontend instrumentation based profiling -----===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This pass lowers instrprof_increment intrinsics emitted by a frontend for
 // profiling. It also builds the data structures and initialization code needed
 // for updating execution counts and emitting the profile at runtime.
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/ProfileData/InstrProf.h"
 #include "llvm/Transforms/Instrumentation.h"
 
 #include "llvm/ADT/Triple.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Transforms/Utils/ModuleUtils.h"
 
private:
   std::vector<Value *> UsedVars;
 
   bool isMachO() const {
     return Triple(M->getTargetTriple()).isOSBinFormatMachO();
   }
 
   /// Get the section name for the counter variables.
   StringRef getCountersSection() const {
-    return isMachO() ? "__DATA,__llvm_prf_cnts" : "__llvm_prf_cnts";
+    return getInstrProfCountersSectionName(isMachO());
   }
 
   /// Get the section name for the name variables.
   StringRef getNameSection() const {
-    return isMachO() ? "__DATA,__llvm_prf_names" : "__llvm_prf_names";
+    return getInstrProfNameSectionName(isMachO());
   }
 
   /// Get the section name for the profile data variables.
   StringRef getDataSection() const {
-    return isMachO() ? "__DATA,__llvm_prf_data" : "__llvm_prf_data";
+    return getInstrProfDataSectionName(isMachO());
   }
 
   /// Get the section name for the coverage mapping data.
   StringRef getCoverageSection() const {
-    return isMachO() ? "__DATA,__llvm_covmap" : "__llvm_covmap";
+    return getInstrProfCoverageSectionName(isMachO());
   }
 
   /// Replace instrprof_increment with an increment of the appropriate value.
   void lowerIncrement(InstrProfIncrementInst *Inc);
 
   /// Set up the section and uses for coverage data and its references.
   void lowerCoverageData(GlobalVariable *CoverageData);
 
bool InstrProfiling::runOnModule(Module &M) {
 
   for (Function &F : M)
     for (BasicBlock &BB : F)
       for (auto I = BB.begin(), E = BB.end(); I != E;)
         if (auto *Inc = dyn_cast<InstrProfIncrementInst>(I++)) {
           lowerIncrement(Inc);
           MadeChange = true;
         }
-  if (GlobalVariable *Coverage = M.getNamedGlobal("__llvm_coverage_mapping")) {
+  if (GlobalVariable *Coverage =
+          M.getNamedGlobal(getCoverageMappingVarName())) {
     lowerCoverageData(Coverage);
     MadeChange = true;
   }
   if (!MadeChange)
     return false;
 
   emitRegistration();
   emitRuntimeHook();
for (unsigned I = 0, E = Records->getNumOperands(); I < E; ++I) {
 
     // Move the name variable to the right section.
     Name->setSection(getNameSection());
     Name->setAlignment(1);
   }
 }
 
 /// Get the name of a profiling variable for a particular function.
-static std::string getVarName(InstrProfIncrementInst *Inc, StringRef VarName) {
+static std::string getVarName(InstrProfIncrementInst *Inc, StringRef Prefix) {
   auto *Arr = cast<ConstantDataArray>(Inc->getName()->getInitializer());
   StringRef Name = Arr->isCString() ? Arr->getAsCString() : Arr->getAsString();
-  return ("__llvm_profile_" + VarName + "_" + Name).str();
+  return (Prefix + Name).str();
 }
 
 GlobalVariable *
 InstrProfiling::getOrCreateRegionCounters(InstrProfIncrementInst *Inc) {
   GlobalVariable *Name = Inc->getName();
   auto It = RegionCounters.find(Name);
   if (It != RegionCounters.end())
     return It->second;
 
   // Move the name variable to the right section. Place them in a COMDAT group
   // if the associated function is a COMDAT. This will make sure that
   // only one copy of counters of the COMDAT function will be emitted after
   // linking.
   Function *Fn = Inc->getParent()->getParent();
   Comdat *ProfileVarsComdat = nullptr;
   if (Fn->hasComdat())
-    ProfileVarsComdat = M->getOrInsertComdat(StringRef(getVarName(Inc, "vars")));
+    ProfileVarsComdat = M->getOrInsertComdat(
+        StringRef(getVarName(Inc, getInstrProfComdatPrefix())));
   Name->setSection(getNameSection());
   Name->setAlignment(1);
   Name->setComdat(ProfileVarsComdat);
 
   uint64_t NumCounters = Inc->getNumCounters()->getZExtValue();
   LLVMContext &Ctx = M->getContext();
   ArrayType *CounterTy = ArrayType::get(Type::getInt64Ty(Ctx), NumCounters);
 
   // Create the counters variable.
-  auto *Counters = new GlobalVariable(*M, CounterTy, false, Name->getLinkage(),
-                                      Constant::getNullValue(CounterTy),
-                                      getVarName(Inc, "counters"));
+  auto *Counters =
+      new GlobalVariable(*M, CounterTy, false, Name->getLinkage(),
+                         getVarName(Inc, getInstrProfCountersVarPrefix()));
   Counters->setVisibility(Name->getVisibility());
   Counters->setSection(getCountersSection());
   Counters->setAlignment(8);
   Counters->setComdat(ProfileVarsComdat);
 
   RegionCounters[Inc->getName()] = Counters;
 
   // Create data variable.
   auto *NameArrayTy = Name->getType()->getPointerElementType();
   auto *Int32Ty = Type::getInt32Ty(Ctx);
   auto *Int64Ty = Type::getInt64Ty(Ctx);
   auto *Int8PtrTy = Type::getInt8PtrTy(Ctx);
   auto *Int64PtrTy = Type::getInt64PtrTy(Ctx);
 
   Type *DataTypes[] = {Int32Ty, Int32Ty, Int64Ty, Int8PtrTy, Int64PtrTy};
   auto *DataTy = StructType::get(Ctx, makeArrayRef(DataTypes));
   Constant *DataVals[] = {
       ConstantInt::get(Int32Ty, NameArrayTy->getArrayNumElements()),
       ConstantInt::get(Int32Ty, NumCounters),
       ConstantInt::get(Int64Ty, Inc->getHash()->getZExtValue()),
       ConstantExpr::getBitCast(Name, Int8PtrTy),
       ConstantExpr::getBitCast(Counters, Int64PtrTy)};
   auto *Data = new GlobalVariable(*M, DataTy, true, Name->getLinkage(),
                                   ConstantStruct::get(DataTy, DataVals),
-                                  getVarName(Inc, "data"));
+                                  getVarName(Inc, getInstrProfDataVarPrefix()));
   Data->setVisibility(Name->getVisibility());
   Data->setSection(getDataSection());
   Data->setAlignment(8);
   Data->setComdat(ProfileVarsComdat);
 
   // Mark the data variable as used so that it isn't stripped out.
   UsedVars.push_back(Data);