Remove getInstrProf*SectionName helpers as an API cleanup, NFC.

[vsk]

Summary

This is a version of D32090 [1] that removes all of the getInstrProf*SectionName helper functions. The build failures which D32090 would have addressed were fixed with D32073 [2].

I think we should remove these helper functions because they are hard to maintain and use. E.g we had to introduce more helpers to fix our COFF support. The current scheme doesn't totally succeed at hiding low-level details about the section naming scheme from clients, so I think we should move to a more flexible API. We can clean things up by unifying the various helpers into function which accepts an ObjectFileFormat instead of a mix of llvm::Module and bools.

There is a compiler-rt change not shown here (we have to sync up the copies of InstrProfData.inc). There is also one clang change:

 std::string getCoverageSection(const CodeGenModule &CGM) {
-  return llvm::getInstrProfCoverageSectionName(&CGM.getModule());
+  return llvm::getInstrProfSectionName(
+      llvm::IPSK_covmap,
+      CGM.getContext().getTargetInfo().getTriple().getObjectFormat());
 }

Testing: check-clang, check-profile, check-llvm. I haven't tested this on Windows.

[1] https://reviews.llvm.org/D32090
[InstrProf] Fix Windows cross compilation TODOs to fix failing tests

[2] https://reviews.llvm.org/D32073
[ProfileData] Support cross target binary reading for coverage tool

[davidxl]

lib/Transforms/Instrumentation/InstrProfiling.cpp

142–143

Is there a need to keep these wrappers? Seems good to remove too.

[vsk]

lib/Transforms/Instrumentation/InstrProfiling.cpp

142–143

Good point, no need for these either. They are all used once, except one which is dead.

[davidxl]

lgtm

[vsk]

Remove more helper functions in InstrProfiling.h.

include/llvm/Object/Binary.h

 //===- Binary.h - A generic binary file -------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares the Binary class.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_OBJECT_BINARY_H
 #define LLVM_OBJECT_BINARY_H
 
+#include "llvm/ADT/Triple.h"
 #include "llvm/Object/Error.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MemoryBuffer.h"
 
 namespace llvm {
 
 class LLVMContext;
public:
   }
 
   bool isModuleSummaryIndex() const { return TypeID == ID_ModuleSummaryIndex; }
 
   bool isLittleEndian() const {
     return !(TypeID == ID_ELF32B || TypeID == ID_ELF64B ||
              TypeID == ID_MachO32B || TypeID == ID_MachO64B);
   }
+
+  Triple::ObjectFormatType getTripleObjectFormat() const {
+    if (isCOFF())
+      return Triple::COFF;
+    if (isMachO())
+      return Triple::MachO;
+    if (isELF())
+      return Triple::ELF;
+    return Triple::UnknownObjectFormat;
+  }
 };
 
 /// @brief Create a Binary from Source, autodetecting the file type.
 ///
 /// @param Source The data to create the Binary from.
 Expected<std::unique_ptr<Binary>> createBinary(MemoryBufferRef Source,
                                                LLVMContext *Context = nullptr);
 

include/llvm/ProfileData/InstrProf.h

 
 #ifndef LLVM_PROFILEDATA_INSTRPROF_H
 #define LLVM_PROFILEDATA_INSTRPROF_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSet.h"
+#include "llvm/ADT/Triple.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/ProfileSummary.h"
 #include "llvm/ProfileData/InstrProfData.inc"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Host.h"

 class Function;
 class GlobalVariable;
 struct InstrProfRecord;
 class InstrProfSymtab;
 class Instruction;
 class MDNode;
 class Module;
 
-/// Return the name of data section containing profile counter variables.
-/// If M is null, the target platform is assumed to be the same as
-/// the host machine, and the segment prefix will not be added.
-std::string getInstrProfCountersSectionName(const Module *M = nullptr);
-
-/// Return the name of data section containing names of instrumented
-/// functions. If M is null, the target platform is assumed to be the same as
-/// the host machine, nor will segment prefix be added.
-std::string getInstrProfNameSectionName(const Module *M = nullptr);
-
-/// Similar to the above, but used by host tool (e.g, coverage) which has
-/// object format information. The section name returned is not prefixed
-/// with segment name.
-std::string getInstrProfNameSectionNameInObject(bool isCoff);
-
-/// Return the name of the data section containing per-function control
-/// data. If M is null, the target platform is assumed to be the same as
-/// the host machine, and the segment prefix will not be added.
-std::string getInstrProfDataSectionName(const Module *M = nullptr);
-
-/// Similar to the above, but used by host tool (e.g, coverage) which has
-/// object format information. The section name returned is not prefixed
-/// with segment name.
-std::string getInstrProfDataSectionNameInObject(bool isCoff);
+enum InstrProfSectKind {
+#define INSTR_PROF_SECT_ENTRY(Kind, SectNameCommon, SectNameCoff, Prefix) Kind,
+#include "llvm/ProfileData/InstrProfData.inc"
+};
 
-/// Return the name of data section containing pointers to value profile
-/// counters/nodes. If M is null, the target platform is assumed to be
-/// the same as the host machine, and the segment prefix will not be added.
-std::string getInstrProfValuesSectionName(const Module *M = nullptr);
-
-/// Return the name of data section containing nodes holdling value
-/// profiling data. If M is null, the target platform is assumed to be
-/// the same as the host machine, and the segment prefix will not be added.
-std::string getInstrProfVNodesSectionName(const Module *M = nullptr);
+/// Return the name of the profile section corresponding to \p IPSK.
+///
+/// The name of the section depends on the object format type \p OF. If
+/// \p AddSegmentInfo is true, a segment prefix and additional linker hints may
+/// be added to the section name (this is the default).
+std::string getInstrProfSectionName(InstrProfSectKind IPSK,
+                                    Triple::ObjectFormatType OF,
+                                    bool AddSegmentInfo = true);
 
 /// Return the name profile runtime entry point to do value profiling
 /// for a given site.
 inline StringRef getInstrProfValueProfFuncName() {
   return INSTR_PROF_VALUE_PROF_FUNC_STR;
 }
 
 /// Return the name profile runtime entry point to do value range profiling.

include/llvm/ProfileData/InstrProfData.inc

 COVMAP_HEADER(uint32_t, Int32Ty, Version, \
               llvm::ConstantInt::get(Int32Ty, CovMapVersion::CurrentVersion))
 #undef COVMAP_HEADER
 /* COVMAP_HEADER end.  */
 
 
 #ifdef INSTR_PROF_SECT_ENTRY
 #define INSTR_PROF_DATA_DEFINED
-INSTR_PROF_SECT_ENTRY(IPSK_data, INSTR_PROF_DATA_SECT_NAME_STR, \
+INSTR_PROF_SECT_ENTRY(IPSK_data, \
                       INSTR_PROF_QUOTE(INSTR_PROF_DATA_COMMON), \
                       INSTR_PROF_QUOTE(INSTR_PROF_DATA_COFF), "__DATA,")
-INSTR_PROF_SECT_ENTRY(IPSK_cnts, INSTR_PROF_CNTS_SECT_NAME_STR, \
+INSTR_PROF_SECT_ENTRY(IPSK_cnts, \
                       INSTR_PROF_QUOTE(INSTR_PROF_CNTS_COMMON), \
                       INSTR_PROF_QUOTE(INSTR_PROF_CNTS_COFF), "__DATA,")
-INSTR_PROF_SECT_ENTRY(IPSK_name, INSTR_PROF_NAME_SECT_NAME_STR, \
+INSTR_PROF_SECT_ENTRY(IPSK_name, \
                       INSTR_PROF_QUOTE(INSTR_PROF_NAME_COMMON), \
                       INSTR_PROF_QUOTE(INSTR_PROF_NAME_COFF), "__DATA,")
-INSTR_PROF_SECT_ENTRY(IPSK_vals, INSTR_PROF_VALS_SECT_NAME_STR, \
+INSTR_PROF_SECT_ENTRY(IPSK_vals, \
                       INSTR_PROF_QUOTE(INSTR_PROF_VALS_COMMON), \
                       INSTR_PROF_QUOTE(INSTR_PROF_VALS_COFF), "__DATA,")
-INSTR_PROF_SECT_ENTRY(IPSK_vnodes, INSTR_PROF_VNODES_SECT_NAME_STR, \
+INSTR_PROF_SECT_ENTRY(IPSK_vnodes, \
                       INSTR_PROF_QUOTE(INSTR_PROF_VNODES_COMMON), \
                       INSTR_PROF_QUOTE(INSTR_PROF_VNODES_COFF), "__DATA,")
-INSTR_PROF_SECT_ENTRY(IPSK_covmap, INSTR_PROF_COVMAP_SECT_NAME_STR, \
+INSTR_PROF_SECT_ENTRY(IPSK_covmap, \
                       INSTR_PROF_QUOTE(INSTR_PROF_COVMAP_COMMON), \
                       INSTR_PROF_QUOTE(INSTR_PROF_COVMAP_COFF), "__LLVM_COV,")
 
 #undef INSTR_PROF_SECT_ENTRY
 #endif
 
 
 #ifdef INSTR_PROF_VALUE_PROF_DATA

include/llvm/Transforms/InstrProfiling.h

public:
   InstrProfiling(const InstrProfOptions &Options) : Options(Options) {}
 
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
   bool run(Module &M, const TargetLibraryInfo &TLI);
 
 private:
   InstrProfOptions Options;
   Module *M;
+  Triple TT;
   const TargetLibraryInfo *TLI;
   struct PerFunctionProfileData {
     uint32_t NumValueSites[IPVK_Last + 1];
     GlobalVariable *RegionCounters = nullptr;
     GlobalVariable *DataVar = nullptr;
 
     PerFunctionProfileData() {
       memset(NumValueSites, 0, sizeof(uint32_t) * (IPVK_Last + 1));
     }
   };
   DenseMap<GlobalVariable *, PerFunctionProfileData> ProfileDataMap;
   std::vector<GlobalValue *> UsedVars;
   std::vector<GlobalVariable *> ReferencedNames;
   GlobalVariable *NamesVar;
   size_t NamesSize;
 
   // The start value of precise value profile range for memory intrinsic sizes.
   int64_t MemOPSizeRangeStart;
   // The end value of precise value profile range for memory intrinsic sizes.
   int64_t MemOPSizeRangeLast;
 
-  bool isMachO() const;
-
-  /// Get the section name for the counter variables.
-  std::string getCountersSection() const;
-
-  /// Get the section name for the name variables.
-  std::string getNameSection() const;
-
-  /// Get the section name for the profile data variables.
-  std::string getDataSection() const;
-
-  /// Get the section name for the coverage mapping data.
-  std::string getCoverageSection() const;
-
   /// Count the number of instrumented value sites for the function.
   void computeNumValueSiteCounts(InstrProfValueProfileInst *Ins);
 
   /// Replace instrprof_value_profile with a call to runtime library.
   void lowerValueProfileInst(InstrProfValueProfileInst *Ins);
 
   /// Replace instrprof_increment with an increment of the appropriate value.
   void lowerIncrement(InstrProfIncrementInst *Inc);

lib/CodeGen/TargetLoweringObjectFileImpl.cpp

 getELFKindForNamedSection(StringRef Name, SectionKind K) {
   // N.B.: The defaults used in here are no the same ones used in MC.
   // We follow gcc, MC follows gas. For example, given ".section .eh_frame",
   // both gas and MC will produce a section with no flags. Given
   // section(".eh_frame") gcc will produce:
   //
   //   .section   .eh_frame,"a",@progbits
 
-  if (Name == getInstrProfCoverageSectionNameInObject(false /*not coff*/))
+  if (Name == getInstrProfSectionName(IPSK_covmap, Triple::ELF,
+                                      /*AddSegmentInfo=*/false))
     return SectionKind::getMetadata();
 
   if (Name.empty() || Name[0] != '.') return K;
 
   // Some lame default implementation based on some magic section names.
   if (Name == ".bss" ||
       Name.startswith(".bss.") ||
       Name.startswith(".gnu.linkonce.b.") ||

lib/ProfileData/Coverage/CoverageMappingReader.cpp

if (auto *Universal = dyn_cast<MachOUniversalBinary>(Bin.get())) {
     return make_error<CoverageMapError>(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.
-  bool IsCoff = (dyn_cast<COFFObjectFile>(OF.get()) != nullptr);
+  auto ObjFormat = OF->getTripleObjectFormat();
   auto NamesSection =
-      lookupSection(*OF, getInstrProfNameSectionNameInObject(IsCoff));
+      lookupSection(*OF, getInstrProfSectionName(IPSK_name, ObjFormat,
+                                                 /*AddSegmentInfo=*/false));
   if (auto E = NamesSection.takeError())
     return E;
   auto CoverageSection =
-      lookupSection(*OF, getInstrProfCoverageSectionNameInObject(IsCoff));
+      lookupSection(*OF, getInstrProfSectionName(IPSK_covmap, ObjFormat,
+                                                 /*AddSegmentInfo=*/false));
   if (auto E = CoverageSection.takeError())
     return E;
 
   // Get the contents of the given sections.
   if (auto EC = CoverageSection->getContents(CoverageMapping))
     return errorCodeToError(EC);
   if (Error E = ProfileNames.create(*NamesSection))
     return E;

lib/ProfileData/InstrProf.cpp

 static ManagedStatic<InstrProfErrorCategoryType> ErrorCategory;
 
 const std::error_category &llvm::instrprof_category() {
   return *ErrorCategory;
 }
 
 namespace {
 
-enum InstrProfSectKind {
-#define INSTR_PROF_SECT_ENTRY(Kind, SectName, SectNameCommon, SectNameCoff,    \
-                              Prefix)                                          \
-  Kind,
-#include "llvm/ProfileData/InstrProfData.inc"
-};
-
-const char *InstrProfSectName[] = {
-#define INSTR_PROF_SECT_ENTRY(Kind, SectName, SectNameCommon, SectNameCoff,    \
-                              Prefix)                                          \
-  SectName,
-#include "llvm/ProfileData/InstrProfData.inc"
-};
-
 const char *InstrProfSectNameCommon[] = {
-#define INSTR_PROF_SECT_ENTRY(Kind, SectName, SectNameCommon, SectNameCoff,    \
-                              Prefix)                                          \
+#define INSTR_PROF_SECT_ENTRY(Kind, SectNameCommon, SectNameCoff, Prefix)      \
   SectNameCommon,
 #include "llvm/ProfileData/InstrProfData.inc"
 };
 
 const char *InstrProfSectNameCoff[] = {
-#define INSTR_PROF_SECT_ENTRY(Kind, SectName, SectNameCommon, SectNameCoff,    \
-                              Prefix)                                          \
+#define INSTR_PROF_SECT_ENTRY(Kind, SectNameCommon, SectNameCoff, Prefix)      \
   SectNameCoff,
 #include "llvm/ProfileData/InstrProfData.inc"
 };
 
 const char *InstrProfSectNamePrefix[] = {
-#define INSTR_PROF_SECT_ENTRY(Kind, SectName, SectNameCommon, SectNameCoff,    \
-                              Prefix)                                          \
+#define INSTR_PROF_SECT_ENTRY(Kind, SectNameCommon, SectNameCoff, Prefix)      \
   Prefix,
 #include "llvm/ProfileData/InstrProfData.inc"
 };
 
-std::string getInstrProfSectionName(bool isCoff, InstrProfSectKind Kind) {
-  return isCoff ? InstrProfSectNameCoff[Kind] : InstrProfSectNameCommon[Kind];
-}
-
-std::string getInstrProfSectionName(const Module *M, InstrProfSectKind Kind) {
-  if (!M)
-    return InstrProfSectName[Kind];
-
-  bool AddSegment = Triple(M->getTargetTriple()).isOSBinFormatMachO();
-  std::string SectName;
-  if (Triple(M->getTargetTriple()).isOSBinFormatCOFF())
-    SectName = InstrProfSectNameCoff[Kind];
-  else
-    SectName = InstrProfSectNameCommon[Kind];
-
-  if (AddSegment) {
-    SectName = InstrProfSectNamePrefix[Kind] + SectName;
-    if (Kind == IPSK_data) {
-      SectName += ",regular,live_support";
-    }
-  }
-  return SectName;
-}
-
 } // namespace
 
 namespace llvm {
 
-std::string getInstrProfCountersSectionName(const Module *M) {
-  return getInstrProfSectionName(M, IPSK_cnts);
-}
-
-std::string getInstrProfNameSectionName(const Module *M) {
-  return getInstrProfSectionName(M, IPSK_name);
-}
-
-std::string getInstrProfNameSectionNameInObject(bool isCoff) {
-  return getInstrProfSectionName(isCoff, IPSK_name);
-}
-
-std::string getInstrProfDataSectionName(const Module *M) {
-  return getInstrProfSectionName(M, IPSK_data);
-}
-
-std::string getInstrProfDataSectionNameInObject(bool isCoff) {
-  return getInstrProfSectionName(isCoff, IPSK_data);
-}
+std::string getInstrProfSectionName(InstrProfSectKind IPSK,
+                                    Triple::ObjectFormatType OF,
+                                    bool AddSegmentInfo) {
+  std::string SectName;
 
-std::string getInstrProfValuesSectionName(const Module *M) {
-  return getInstrProfSectionName(M, IPSK_vals);
-}
+  if (OF == Triple::MachO && AddSegmentInfo)
+    SectName = InstrProfSectNamePrefix[IPSK];
 
-std::string getInstrProfVNodesSectionName(const Module *M) {
-  return getInstrProfSectionName(M, IPSK_vnodes);
-}
+  if (OF == Triple::COFF)
+    SectName += InstrProfSectNameCoff[IPSK];
+  else
+    SectName += InstrProfSectNameCommon[IPSK];
 
-std::string getInstrProfCoverageSectionName(const Module *M) {
-  return getInstrProfSectionName(M, IPSK_covmap);
-}
+  if (OF == Triple::MachO && IPSK == IPSK_data && AddSegmentInfo)
+    SectName += ",regular,live_support";
 
-std::string getInstrProfCoverageSectionNameInObject(bool isCoff) {
-  return getInstrProfSectionName(isCoff, IPSK_covmap);
+  return SectName;
 }
 
 void SoftInstrProfErrors::addError(instrprof_error IE) {
   if (IE == instrprof_error::success)
     return;
 
   if (FirstError == instrprof_error::success)
     FirstError = IE;

lib/Transforms/Instrumentation/InstrProfiling.cpp

 INITIALIZE_PASS_END(
     InstrProfilingLegacyPass, "instrprof",
     "Frontend instrumentation-based coverage lowering.", false, false)
 
 ModulePass *
 llvm::createInstrProfilingLegacyPass(const InstrProfOptions &Options) {
   return new InstrProfilingLegacyPass(Options);
 }
 
-bool InstrProfiling::isMachO() const {
-  return Triple(M->getTargetTriple()).isOSBinFormatMachO();
-}
-
-/// Get the section name for the counter variables.
-std::string InstrProfiling::getCountersSection() const {
-  return getInstrProfCountersSectionName(M);
-}
-
-/// Get the section name for the name variables.
-std::string InstrProfiling::getNameSection() const {
-  return getInstrProfNameSectionName(M);
-}
-
-/// Get the section name for the profile data variables.
-std::string InstrProfiling::getDataSection() const {
-  return getInstrProfDataSectionName(M);
-}
-
-/// Get the section name for the coverage mapping data.
-std::string InstrProfiling::getCoverageSection() const {
-  return getInstrProfCoverageSectionName(M);
-}
-
 static InstrProfIncrementInst *castToIncrementInst(Instruction *Instr) {
   InstrProfIncrementInst *Inc = dyn_cast<InstrProfIncrementInstStep>(Instr);
   if (Inc)
     return Inc;
   return dyn_cast<InstrProfIncrementInst>(Instr);
 }
 
 bool InstrProfiling::run(Module &M, const TargetLibraryInfo &TLI) {
   bool MadeChange = false;
 
   this->M = &M;
   this->TLI = &TLI;
   NamesVar = nullptr;
   NamesSize = 0;
   ProfileDataMap.clear();
   UsedVars.clear();
   getMemOPSizeRangeFromOption(MemOPSizeRange, MemOPSizeRangeStart,
                               MemOPSizeRangeLast);
+  TT = Triple(M.getTargetTriple());
 
   // We did not know how many value sites there would be inside
   // the instrumented function. This is counting the number of instrumented
   // target value sites to enter it as field in the profile data variable.
   for (Function &F : M) {
     InstrProfIncrementInst *FirstProfIncInst = nullptr;
     for (BasicBlock &BB : F)
       for (auto I = BB.begin(), E = BB.end(); I != E; I++)
InstrProfiling::getOrCreateRegionCounters(InstrProfIncrementInst *Inc) {
   ArrayType *CounterTy = ArrayType::get(Type::getInt64Ty(Ctx), NumCounters);
 
   // Create the counters variable.
   auto *CounterPtr =
       new GlobalVariable(*M, CounterTy, false, NamePtr->getLinkage(),
                          Constant::getNullValue(CounterTy),
                          getVarName(Inc, getInstrProfCountersVarPrefix()));
   CounterPtr->setVisibility(NamePtr->getVisibility());
-  CounterPtr->setSection(getCountersSection());
+  CounterPtr->setSection(
+      getInstrProfSectionName(IPSK_cnts, TT.getObjectFormat()));
   CounterPtr->setAlignment(8);
   CounterPtr->setComdat(ProfileVarsComdat);
 
   auto *Int8PtrTy = Type::getInt8PtrTy(Ctx);
   // Allocate statically the array of pointers to value profile nodes for
   // the current function.
   Constant *ValuesPtrExpr = ConstantPointerNull::get(Int8PtrTy);
   if (ValueProfileStaticAlloc && !needsRuntimeRegistrationOfSectionRange(*M)) {
     uint64_t NS = 0;
     for (uint32_t Kind = IPVK_First; Kind <= IPVK_Last; ++Kind)
       NS += PD.NumValueSites[Kind];
     if (NS) {
       ArrayType *ValuesTy = ArrayType::get(Type::getInt64Ty(Ctx), NS);
 
       auto *ValuesVar =
           new GlobalVariable(*M, ValuesTy, false, NamePtr->getLinkage(),
                              Constant::getNullValue(ValuesTy),
                              getVarName(Inc, getInstrProfValuesVarPrefix()));
       ValuesVar->setVisibility(NamePtr->getVisibility());
-      ValuesVar->setSection(getInstrProfValuesSectionName(M));
+      ValuesVar->setSection(
+          getInstrProfSectionName(IPSK_vals, TT.getObjectFormat()));
       ValuesVar->setAlignment(8);
       ValuesVar->setComdat(ProfileVarsComdat);
       ValuesPtrExpr =
           ConstantExpr::getBitCast(ValuesVar, Type::getInt8PtrTy(Ctx));
     }
   }
 
   // Create data variable.
#include "llvm/ProfileData/InstrProfData.inc"
   Constant *DataVals[] = {
 #define INSTR_PROF_DATA(Type, LLVMType, Name, Init) Init,
 #include "llvm/ProfileData/InstrProfData.inc"
   };
   auto *Data = new GlobalVariable(*M, DataTy, false, NamePtr->getLinkage(),
                                   ConstantStruct::get(DataTy, DataVals),
                                   getVarName(Inc, getInstrProfDataVarPrefix()));
   Data->setVisibility(NamePtr->getVisibility());
-  Data->setSection(getDataSection());
+  Data->setSection(getInstrProfSectionName(IPSK_data, TT.getObjectFormat()));
   Data->setAlignment(INSTR_PROF_DATA_ALIGNMENT);
   Data->setComdat(ProfileVarsComdat);
 
   PD.RegionCounters = CounterPtr;
   PD.DataVar = Data;
   ProfileDataMap[NamePtr] = PD;
 
   // Mark the data variable as used so that it isn't stripped out.

 #include "llvm/ProfileData/InstrProfData.inc"
   };
   auto *VNodeTy = StructType::get(Ctx, makeArrayRef(VNodeTypes));
 
   ArrayType *VNodesTy = ArrayType::get(VNodeTy, NumCounters);
   auto *VNodesVar = new GlobalVariable(
       *M, VNodesTy, false, GlobalValue::PrivateLinkage,
       Constant::getNullValue(VNodesTy), getInstrProfVNodesVarName());
-  VNodesVar->setSection(getInstrProfVNodesSectionName(M));
+  VNodesVar->setSection(
+      getInstrProfSectionName(IPSK_vnodes, TT.getObjectFormat()));
   UsedVars.push_back(VNodesVar);
 }
 
 void InstrProfiling::emitNameData() {
   std::string UncompressedData;
 
   if (ReferencedNames.empty())
     return;
 
   std::string CompressedNameStr;
   if (Error E = collectPGOFuncNameStrings(ReferencedNames, CompressedNameStr,
                                           DoNameCompression)) {
     report_fatal_error(toString(std::move(E)), false);
   }
 
   auto &Ctx = M->getContext();
   auto *NamesVal = ConstantDataArray::getString(
       Ctx, StringRef(CompressedNameStr), false);
   NamesVar = new GlobalVariable(*M, NamesVal->getType(), true,
                                 GlobalValue::PrivateLinkage, NamesVal,
                                 getInstrProfNamesVarName());
   NamesSize = CompressedNameStr.size();
-  NamesVar->setSection(getNameSection());
+  NamesVar->setSection(
+      getInstrProfSectionName(IPSK_name, TT.getObjectFormat()));
   UsedVars.push_back(NamesVar);
 
   for (auto *NamePtr : ReferencedNames)
     NamePtr->eraseFromParent();
 }
 
 void InstrProfiling::emitRegistration() {
   if (!needsRuntimeRegistrationOfSectionRange(*M))
void InstrProfiling::emitInitialization() {
 
   if (!InstrProfileOutput.empty()) {
     // Create variable for profile name.
     Constant *ProfileNameConst =
         ConstantDataArray::getString(M->getContext(), InstrProfileOutput, true);
     GlobalVariable *ProfileNameVar = new GlobalVariable(
         *M, ProfileNameConst->getType(), true, GlobalValue::WeakAnyLinkage,
         ProfileNameConst, INSTR_PROF_QUOTE(INSTR_PROF_PROFILE_NAME_VAR));
-    Triple TT(M->getTargetTriple());
     if (TT.supportsCOMDAT()) {
       ProfileNameVar->setLinkage(GlobalValue::ExternalLinkage);
       ProfileNameVar->setComdat(M->getOrInsertComdat(
           StringRef(INSTR_PROF_QUOTE(INSTR_PROF_PROFILE_NAME_VAR))));
     }
   }
 
   Constant *RegisterF = M->getFunction(getInstrProfRegFuncsName());

lib/Transforms/Instrumentation/ThreadSanitizer.cpp

 static bool shouldInstrumentReadWriteFromAddress(const Module *M, Value *Addr) {
   // Peel off GEPs and BitCasts.
   Addr = Addr->stripInBoundsOffsets();
 
   if (GlobalVariable *GV = dyn_cast<GlobalVariable>(Addr)) {
     if (GV->hasSection()) {
       StringRef SectionName = GV->getSection();
       // Check if the global is in the PGO counters section.
-      if (SectionName.endswith(getInstrProfCountersSectionName(M)))
+      auto OF = Triple(M->getTargetTriple()).getObjectFormat();
+      if (SectionName.endswith(
+              getInstrProfSectionName(IPSK_cnts, OF, /*AddSegmentInfo=*/false)))
         return false;
     }
 
     // Check if the global is private gcov data.
     if (GV->getName().startswith("__llvm_gcov") ||
         GV->getName().startswith("__llvm_gcda"))
       return false;
   }

tools/llvm-cov/TestingSupport.cpp

int convertForTestingMain(int argc, const char *argv[]) {
   if (BytesInAddress != 8) {
     errs() << "error: 64 bit binary expected\n";
     return 1;
   }
 
   // Look for the sections that we are interested in.
   int FoundSectionCount = 0;
   SectionRef ProfileNames, CoverageMapping;
+  auto ObjFormat = OF->getTripleObjectFormat();
   for (const auto &Section : OF->sections()) {
     StringRef Name;
     if (Section.getName(Name))
       return 1;
-    // TODO: with the current getInstrProfXXXSectionName interfaces, the
-    // the  host tool is limited to read coverage section on
-    // binaries with compatible profile section naming scheme as the host
-    // platform. Currently, COFF format binaries have different section
-    // naming scheme from the all the rest.
-    if (Name == llvm::getInstrProfNameSectionName()) {
+    if (Name == llvm::getInstrProfSectionName(IPSK_name, ObjFormat)) {
       ProfileNames = Section;
-    } else if (Name == llvm::getInstrProfCoverageSectionName()) {
+    } else if (Name == llvm::getInstrProfSectionName(IPSK_covmap, ObjFormat)) {
       CoverageMapping = Section;
     } else
       continue;
     ++FoundSectionCount;
   }
   if (FoundSectionCount != 2)
     return 1;