Instrumentation PGO and coverage mapping size reduction

[davidxl]

Summary

See upstream discussion about this topic:

This is the new solution I am proposing. It is basically an enhancement of Solution-1 with most of the weakness resolved. The difference with Solution-1 is

1. Function name symbols are emitted into the symbol table as weak externs. They don't occupy any space at runtime and can be easily stripped.
2. -fcoverage-mapping does not need special handling -- it automatically benefit from the same size saving.
3. llvm-cov is changed to read symbol info from the symtab instead of reading them from the name section data
4. llvm-profdata is enhanced to take a binary as input and dump profile with names attached. Function filtering is fully supported (option can also be introduced to force dumping names into binary and profile data, so that llvm-profdata use case is not changed at all).

Pros:

1. All the pros from Solution-1
2. Size savings for coverage-mapping case

Cons:

Format change is required for profile data and coverage mapping.

[davidxl]

Merge in value profiler changes

[davidxl]

Fix a bug in profile dumping.

include/llvm/ProfileData/CoverageMappingReader.h

 #ifndef LLVM_PROFILEDATA_COVERAGEMAPPINGREADER_H
 #define LLVM_PROFILEDATA_COVERAGEMAPPINGREADER_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/ProfileData/CoverageMapping.h"
-#include "llvm/ProfileData/InstrProf.h"
+#include "llvm/ProfileData/InstrProfReader.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include <iterator>
 
 namespace llvm {
 namespace coverage {
 
 class CoverageMappingReader;
ProfileMappingRecord(CoverageMappingVersion Version, StringRef FunctionName,
           FunctionHash(FunctionHash), CoverageMapping(CoverageMapping),
           FilenamesBegin(FilenamesBegin), FilenamesSize(FilenamesSize) {}
   };
 
 private:
   std::vector<StringRef> Filenames;
   std::vector<ProfileMappingRecord> MappingRecords;
   size_t CurrentRecord;
+  std::unique_ptr<ProfSymtab> Symtab;
   std::vector<StringRef> FunctionsFilenames;
   std::vector<CounterExpression> Expressions;
   std::vector<CounterMappingRegion> MappingRegions;
 
   BinaryCoverageReader(const BinaryCoverageReader &) = delete;
   BinaryCoverageReader &operator=(const BinaryCoverageReader &) = delete;
 
   BinaryCoverageReader() : CurrentRecord(0) {}

include/llvm/ProfileData/InstrProf.h

 // binaries through library functions in compiler-rt, and read by the clang
 // frontend to feed PGO.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_PROFILEDATA_INSTRPROF_H_
 #define LLVM_PROFILEDATA_INSTRPROF_H_
 
-#include "llvm/ADT/StringSet.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Endian.h"
 #include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/MD5.h"
 #include <cstdint>
 #include <list>
 #include <system_error>
 #include <vector>
 
 namespace llvm {
 const std::error_category &instrprof_category();
 
enum class instrprof_error {
   counter_overflow,
   value_site_count_mismatch
 };
 
 inline std::error_code make_error_code(instrprof_error E) {
   return std::error_code(static_cast<int>(E), instrprof_category());
 }
 
+namespace IndexedInstrProf {
+
+enum class HashT : uint32_t {
+  MD5,
+
+  Last = MD5
+};
+
+static inline uint64_t MD5Hash(StringRef Str) {
+  MD5 Hash;
+  Hash.update(Str);
+  llvm::MD5::MD5Result Result;
+  Hash.final(Result);
+  // Return the least significant 8 bytes. Our MD5 implementation returns the
+  // result in little endian, so we may need to swap bytes.
+  using namespace llvm::support;
+  return endian::read<uint64_t, little, unaligned>(Result);
+}
+
+static inline uint64_t ComputeHash(HashT Type, StringRef K) {
+  switch (Type) {
+  case HashT::MD5:
+    return IndexedInstrProf::MD5Hash(K);
+  }
+  llvm_unreachable("Unhandled hash type");
+}
+
+const uint64_t Magic = 0x8169666f72706cff; // "\xfflprofi\x81"
+const uint64_t Version = 4;
+const HashT HashType = HashT::MD5;
+}
+
 enum InstrProfValueKind : uint32_t {
   IPVK_IndirectCallTarget = 0,
 
   IPVK_First = IPVK_IndirectCallTarget,
   IPVK_Last = IPVK_IndirectCallTarget
 };
 
-struct InstrProfStringTable {
-  // Set of string values in profiling data.
-  StringSet<> StringValueSet;
-  InstrProfStringTable() { StringValueSet.clear(); }
-  // Get a pointer to internal storage of a string in set
-  const char *getStringData(StringRef Str) {
-    auto Result = StringValueSet.find(Str);
-    return (Result == StringValueSet.end()) ? nullptr : Result->first().data();
-  }
-  // Insert a string to StringTable
-  const char *insertString(StringRef Str) {
-    auto Result = StringValueSet.insert(Str);
-    return Result.first->first().data();
-  }
-};
-
 struct InstrProfValueSiteRecord {
   /// Typedef for a single TargetValue-NumTaken pair.
   typedef std::pair<uint64_t, uint64_t> ValueDataPair;
   /// Value profiling data pairs at a given value site.
   std::list<ValueDataPair> ValueData;
 
   InstrProfValueSiteRecord() { ValueData.clear(); }
 
for (auto J = Input.ValueData.begin(), JE = Input.ValueData.end(); J != JE;
       ValueData.insert(I, *J);
     }
   }
 };
 
 /// Profiling information for a single function.
 struct InstrProfRecord {
   InstrProfRecord() {}
+  InstrProfRecord(uint64_t NameKey, uint64_t Hash, std::vector<uint64_t> Counts)
+      : NameKey(NameKey), Hash(Hash), Counts(std::move(Counts)) {}
   InstrProfRecord(StringRef Name, uint64_t Hash, std::vector<uint64_t> Counts)
-      : Name(Name), Hash(Hash), Counts(std::move(Counts)) {}
+      : Name(Name), NameKey(0), Hash(Hash), Counts(std::move(Counts)) {
+
+    NameKey = IndexedInstrProf::ComputeHash(IndexedInstrProf::HashType, Name);
+  }
   StringRef Name;
+  uint64_t NameKey;
   uint64_t Hash;
   std::vector<uint64_t> Counts;
   std::vector<InstrProfValueSiteRecord> IndirectCallSites;
 
   const std::vector<InstrProfValueSiteRecord> &
   getValueSitesForKind(uint32_t ValueKind) const {
     switch (ValueKind) {
     case IPVK_IndirectCallTarget:

include/llvm/ProfileData/InstrProfReader.h

 // based PGO and coverage.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_PROFILEDATA_INSTRPROFREADER_H
 #define LLVM_PROFILEDATA_INSTRPROFREADER_H
 
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/StringExtras.h"
+#include "llvm/Object/ObjectFile.h"
 #include "llvm/ProfileData/InstrProf.h"
 #include "llvm/Support/EndianStream.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/LineIterator.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/OnDiskHashTable.h"
 #include <iterator>
 
public:
   virtual std::error_code readHeader() = 0;
   /// Read a single record.
   virtual std::error_code readNextRecord(InstrProfRecord &Record) = 0;
   /// Iterator over profile data.
   InstrProfIterator begin() { return InstrProfIterator(this); }
   InstrProfIterator end() { return InstrProfIterator(); }
 
 protected:
-  /// String table for holding a unique copy of all the strings in the profile.
-  InstrProfStringTable StringTable;
 
   /// Set the current std::error_code and return same.
   std::error_code error(std::error_code EC) {
     LastError = EC;
     return EC;
   }
 
   /// Clear the current error code and return a successful one.

 ///
 /// Templated on the unsigned type whose size matches pointers on the platform
 /// that wrote the profile.
 template <class IntPtrT>
 class RawInstrProfReader : public InstrProfReader {
 private:
   /// The profile data file contents.
   std::unique_ptr<MemoryBuffer> DataBuffer;
-  struct ProfileData {
+  struct ProfileDataV1 {
     const uint32_t NameSize;
     const uint32_t NumCounters;
     const uint64_t FuncHash;
-    const IntPtrT NamePtr;
+    const IntPtrT Name;
     const IntPtrT CounterPtr;
   };
+  struct ProfileData {
+    const uint64_t NameKey;
+    const uint64_t FuncHash;
+    const IntPtrT CounterPtr;
+    const uint32_t NumCounters;
+  };
   struct RawHeader {
     const uint64_t Magic;
     const uint64_t Version;
     const uint64_t DataSize;
     const uint64_t CountersSize;
-    const uint64_t NamesSize;
+    const uint64_t NamesSize; //  Used for V1
     const uint64_t CountersDelta;
-    const uint64_t NamesDelta;
+    const uint64_t NamesDelta; // Used for V1
   };
 
   bool ShouldSwapBytes;
   uint64_t CountersDelta;
   uint64_t NamesDelta;
+  union {
     const ProfileData *Data;
+    const ProfileDataV1 *DataV1;
+  } U1;
+  union {
     const ProfileData *DataEnd;
+    const ProfileDataV1 *DataEndV1;
+  } U2;
   const uint64_t *CountersStart;
   const char *NamesStart;
   const char *ProfileEnd;
+  uint64_t Version;
 
   RawInstrProfReader(const RawInstrProfReader &) = delete;
   RawInstrProfReader &operator=(const RawInstrProfReader &) = delete;
+
+  ptrdiff_t getCounterOffset(ptrdiff_t DataOffset, uint64_t DataSize) {
+    if (Version == 1)
+      return DataOffset + sizeof(ProfileDataV1) * DataSize;
+    else
+      return DataOffset + sizeof(ProfileData) * DataSize;
+  }
+  void setDataEnd(uint64_t DataSize) {
+    if (Version == 1)
+      U2.DataEndV1 = U1.DataV1 + DataSize;
+    else
+      U2.DataEnd = U1.Data + DataSize;
+  }
+  void advanceData(void) {
+    if (Version == 1)
+      U1.Data++;
+    else
+      U1.DataV1++;
+  }
+
+  std::error_code readNameFromData(uint64_t &NameKey, StringRef &RawName);
+  std::error_code readRawCountsFromData(InstrProfRecord &Record);
+  std::error_code readFuncHashFromData(uint64_t &FuncHash);
+
 public:
   RawInstrProfReader(std::unique_ptr<MemoryBuffer> DataBuffer)
       : DataBuffer(std::move(DataBuffer)) { }
 
   static bool hasFormat(const MemoryBuffer &DataBuffer);
   std::error_code readHeader() override;
   std::error_code readNextRecord(InstrProfRecord &Record) override;
 
const char *getName(IntPtrT NamePtr) const {
     ptrdiff_t Offset = (swap(NamePtr) - NamesDelta) / sizeof(char);
     return NamesStart + Offset;
   }
 };
 
 typedef RawInstrProfReader<uint32_t> RawInstrProfReader32;
 typedef RawInstrProfReader<uint64_t> RawInstrProfReader64;
 
-namespace IndexedInstrProf {
-enum class HashT : uint32_t;
-}
-
 /// Trait for lookups into the on-disk hash table for the binary instrprof
 /// format.
-class InstrProfLookupTrait {
+template <class KeyType>
+inline KeyType ReadKeyHelper(const unsigned char *D, uint64_t N) {
+  return KeyType((const char *)D, N);
+}
+
+template <>
+inline uint64_t ReadKeyHelper<uint64_t>(const unsigned char *D, uint64_t N) {
+  return *((const uint64_t *)D);
+}
+
+template <class KeyType> class InstrProfLookupTrait {
   std::vector<InstrProfRecord> DataBuffer;
   IndexedInstrProf::HashT HashType;
   unsigned FormatVersion;
-  std::vector<std::pair<uint64_t, const char *>> HashKeys;
 
 public:
   InstrProfLookupTrait(IndexedInstrProf::HashT HashType, unsigned FormatVersion)
       : HashType(HashType), FormatVersion(FormatVersion) {}
 
   typedef ArrayRef<InstrProfRecord> data_type;
 
-  typedef StringRef internal_key_type;
-  typedef StringRef external_key_type;
+  typedef KeyType internal_key_type;
+  typedef KeyType external_key_type;
   typedef uint64_t hash_value_type;
   typedef uint64_t offset_type;
 
-  static bool EqualKey(StringRef A, StringRef B) { return A == B; }
-  static StringRef GetInternalKey(StringRef K) { return K; }
-  static StringRef GetExternalKey(StringRef K) { return K; }
+  static bool EqualKey(KeyType A, KeyType B) { return A == B; }
+  static KeyType GetInternalKey(KeyType K) { return K; }
+  static KeyType GetExternalKey(KeyType K) { return K; }
 
-  hash_value_type ComputeHash(StringRef K);
+  hash_value_type ComputeHash(KeyType K);
 
-  void setHashKeys(std::vector<std::pair<uint64_t, const char *>> HashKeys) {
-    this->HashKeys = std::move(HashKeys);
-  }
   static std::pair<offset_type, offset_type>
   ReadKeyDataLength(const unsigned char *&D) {
     using namespace support;
     offset_type KeyLen = endian::readNext<offset_type, little, unaligned>(D);
     offset_type DataLen = endian::readNext<offset_type, little, unaligned>(D);
     return std::make_pair(KeyLen, DataLen);
   }
 
-  StringRef ReadKey(const unsigned char *D, offset_type N) {
-    return StringRef((const char *)D, N);
+  KeyType ReadKey(const unsigned char *D, offset_type N) {
+    return ReadKeyHelper<KeyType>(D, N);
   }
 
   bool ReadValueProfilingData(const unsigned char *&D,
                               const unsigned char *const End);
-  data_type ReadData(StringRef K, const unsigned char *D, offset_type N);
+  data_type ReadData(KeyType K, const unsigned char *D, offset_type N);
 };
 
-typedef OnDiskIterableChainedHashTable<InstrProfLookupTrait>
+typedef OnDiskIterableChainedHashTable<InstrProfLookupTrait<uint64_t>>
     InstrProfReaderIndex;
+typedef OnDiskIterableChainedHashTable<InstrProfLookupTrait<StringRef>>
+    InstrProfReaderIndexV3;
 
-/// Reader for the indexed binary instrprof format.
-class IndexedInstrProfReader : public InstrProfReader {
+class InstrProfIndex {
 private:
-  /// The profile data file contents.
-  std::unique_ptr<MemoryBuffer> DataBuffer;
   /// The index into the profile data.
   std::unique_ptr<InstrProfReaderIndex> Index;
   /// Iterator over the profile data.
   InstrProfReaderIndex::data_iterator RecordIterator;
+  /// The index into the profile data of v2 format.
+  std::unique_ptr<InstrProfReaderIndexV3> IndexV3;
+  /// Iterator over the profile data.
+  InstrProfReaderIndexV3::data_iterator RecordIteratorV3;
   /// The file format version of the profile data.
   uint64_t FormatVersion;
+
+public:
+  InstrProfIndex() : Index(nullptr), IndexV3(nullptr) {}
+  void Init(const unsigned char *Buckets, const unsigned char *const Payload,
+            const unsigned char *const Base, IndexedInstrProf::HashT HashType,
+            uint64_t Version) {
+    FormatVersion = Version;
+    if (FormatVersion <= 3) {
+      IndexV3.reset(InstrProfReaderIndexV3::Create(
+          Buckets, Payload, Base,
+          InstrProfLookupTrait<StringRef>(HashType, Version)));
+      // Set up our iterator for readNextRecord.
+      RecordIteratorV3 = IndexV3->data_begin();
+    } else {
+      Index.reset(InstrProfReaderIndex::Create(
+          Buckets, Payload, Base,
+          InstrProfLookupTrait<uint64_t>(HashType, Version)));
+      RecordIterator = Index->data_begin();
+    }
+  }
+
+  std::error_code getRecordsForNextKey(ArrayRef<InstrProfRecord> &Data);
+  std::error_code getRecord(StringRef FuncName, uint64_t FuncNameKey,
+                            ArrayRef<InstrProfRecord> &Data);
+  void advanceToNextKey() {
+    if (FormatVersion <= 3)
+      RecordIteratorV3++;
+    else
+      RecordIterator++;
+  }
+  bool atEnd() {
+    return (FormatVersion <= 3 ? RecordIteratorV3 == IndexV3->data_end()
+                               : RecordIterator == Index->data_end());
+  }
+};
+
+/// Reader for the indexed binary instrprof format.
+class IndexedInstrProfReader : public InstrProfReader {
+private:
+  /// The profile data file contents.
+  std::unique_ptr<MemoryBuffer> DataBuffer;
+  InstrProfIndex Index;
   /// The maximal execution count among all functions.
   uint64_t MaxFunctionCount;
 
+  std::error_code getFunctionCounts(StringRef FuncName, uint64_t FuncNameKey,
+                                    uint64_t FuncHash,
+                                    std::vector<uint64_t> &Counts);
   IndexedInstrProfReader(const IndexedInstrProfReader &) = delete;
   IndexedInstrProfReader &operator=(const IndexedInstrProfReader &) = delete;
 public:
   IndexedInstrProfReader(std::unique_ptr<MemoryBuffer> DataBuffer)
-      : DataBuffer(std::move(DataBuffer)), Index(nullptr) {}
+      : DataBuffer(std::move(DataBuffer)), Index() {}
 
   /// Return true if the given buffer is in an indexed instrprof format.
   static bool hasFormat(const MemoryBuffer &DataBuffer);
 
   /// Read the file header.
   std::error_code readHeader() override;
   /// Read a single record.
   std::error_code readNextRecord(InstrProfRecord &Record) override;
 
   /// Fill Counts with the profile data for the given function name.
   std::error_code getFunctionCounts(StringRef FuncName, uint64_t FuncHash,
                                     std::vector<uint64_t> &Counts);
+  std::error_code getFunctionCounts(uint64_t FuncNamekey, uint64_t FuncHash,
+                                    std::vector<uint64_t> &Counts);
   /// Return the maximum of all known function counts.
   uint64_t getMaximumFunctionCount() { return MaxFunctionCount; }
 
   /// Factory method to create an indexed reader.
   static ErrorOr<std::unique_ptr<IndexedInstrProfReader>>
   create(std::string Path);
 
   static ErrorOr<std::unique_ptr<IndexedInstrProfReader>>
   create(std::unique_ptr<MemoryBuffer> Buffer);
 };
 
+/// \brief A helper structure to access the data from a section
+/// in an object file.
+struct SymbolNameSectionData {
+  StringRef Data;
+  uint64_t Address;
+
+  std::error_code load(object::SectionRef &Section) {
+    if (auto Err = Section.getContents(Data))
+      return Err;
+    Address = Section.getAddress();
+    return std::error_code();
+  }
+
+  std::error_code get(uint64_t Pointer, size_t Size, StringRef &Result);
+};
+
+/// Class to represent profile symbol table used by llvm-cov and llvm-profdata
+/// tool
+class ProfSymtab {
+  /// Map from md5hash key to function name strings.
+  DenseMap<uint64_t, std::string> Symtab;
+  /// Data section that contains funciton names
+  SymbolNameSectionData SymtabSection;
+  bool UsesNameSection;
+
+public:
+  std::error_code getFunctionName(uintptr_t NameHashKeyOrAddr, size_t Size,
+                                  StringRef &Result);
+  ProfSymtab(object::ObjectFile::symbol_iterator_range Syms);
+  ProfSymtab(StringRef Data, uint64_t Base) : UsesNameSection(true) {
+    SymtabSection.Data = Data;
+    SymtabSection.Address = Base;
+  }
+  ProfSymtab(object::SectionRef &Section) : UsesNameSection(true) {
+    SymtabSection.load(Section);
+  }
+};
+
 } // end namespace llvm
 
 #endif

include/llvm/ProfileData/InstrProfWriter.h

 namespace llvm {
 
 /// Writer for instrumentation based profile data.
 class InstrProfWriter {
 public:
   typedef SmallDenseMap<uint64_t, InstrProfRecord, 1> ProfilingData;
 
 private:
-  InstrProfStringTable StringTable;
-  StringMap<ProfilingData> FunctionData;
+  DenseMap<uint64_t, ProfilingData> FunctionData;
   uint64_t MaxFunctionCount;
 public:
   InstrProfWriter() : MaxFunctionCount(0) {}
 
   /// Update string entries in profile data with references to StringTable.
   void updateStringTableReferences(InstrProfRecord &I);
   /// Add function counts for the given function. If there are already counts
   /// for this function and the hash and number of counts match, each counter is

lib/CodeGen/CodeGenPGO.cpp

void CodeGenPGO::createFuncNameVar(llvm::GlobalValue::LinkageTypes Linkage) {
   if (Linkage == llvm::GlobalValue::ExternalWeakLinkage)
     Linkage = llvm::GlobalValue::LinkOnceAnyLinkage;
   else if (Linkage == llvm::GlobalValue::AvailableExternallyLinkage)
     Linkage = llvm::GlobalValue::LinkOnceODRLinkage;
   else if (Linkage == llvm::GlobalValue::InternalLinkage ||
            Linkage == llvm::GlobalValue::ExternalLinkage)
     Linkage = llvm::GlobalValue::PrivateLinkage;
 
-  auto *Value =
-      llvm::ConstantDataArray::getString(CGM.getLLVMContext(), FuncName, false);
-  FuncNameVar =
-      new llvm::GlobalVariable(CGM.getModule(), Value->getType(), true, Linkage,
-                               Value, "__llvm_profile_name_" + FuncName);
+  FuncNameVar = new llvm::GlobalVariable(
+      CGM.getModule(), llvm::Type::getInt8Ty(CGM.getLLVMContext()), true,
+      Linkage, 0, "__llvm_prf_nm_" + FuncName);
 
   // Hide the symbol so that we correctly get a copy for each executable.
   if (!llvm::GlobalValue::isLocalLinkage(FuncNameVar->getLinkage()))
     FuncNameVar->setVisibility(llvm::GlobalValue::HiddenVisibility);
 }
 
 namespace {
 /// \brief Stable hasher for PGO region counters.

lib/CodeGen/CoverageMappingGen.h

 
 /// \brief Organizes the cross-function state that is used while generating
 /// code coverage mapping data.
 class CoverageMappingModuleGen {
   CodeGenModule &CGM;
   CoverageSourceInfo &SourceInfo;
   llvm::SmallDenseMap<const FileEntry *, unsigned, 8> FileEntries;
   std::vector<llvm::Constant *> FunctionRecords;
+  std::vector<llvm::Constant *> FunctionNames;
   llvm::StructType *FunctionRecordTy;
   std::string CoverageMappings;
 
 public:
   CoverageMappingModuleGen(CodeGenModule &CGM, CoverageSourceInfo &SourceInfo)
       : CGM(CGM), SourceInfo(SourceInfo), FunctionRecordTy(nullptr) {}
 
   CoverageSourceInfo &getSourceInfo() const {

lib/CodeGen/CoverageMappingGen.cpp

 }
 
 void CoverageMappingModuleGen::addFunctionMappingRecord(
     llvm::GlobalVariable *FunctionName, StringRef FunctionNameValue,
     uint64_t FunctionHash, const std::string &CoverageMapping) {
   llvm::LLVMContext &Ctx = CGM.getLLVMContext();
   auto *Int32Ty = llvm::Type::getInt32Ty(Ctx);
   auto *Int64Ty = llvm::Type::getInt64Ty(Ctx);
-  auto *Int8PtrTy = llvm::Type::getInt8PtrTy(Ctx);
   if (!FunctionRecordTy) {
-    llvm::Type *FunctionRecordTypes[] = {Int8PtrTy, Int32Ty, Int32Ty, Int64Ty};
+    llvm::Type *FunctionRecordTypes[] = {Int64Ty, Int32Ty, Int32Ty, Int64Ty};
     FunctionRecordTy =
         llvm::StructType::get(Ctx, makeArrayRef(FunctionRecordTypes),
                               /*isPacked=*/true);
   }
 
+  auto FuncNameKey = llvm::IndexedInstrProf::ComputeHash(
+      llvm::IndexedInstrProf::HashType,
+      FunctionName->getName().substr(strlen("__llvm_prf_nm_")));
+
   llvm::Constant *FunctionRecordVals[] = {
-      llvm::ConstantExpr::getBitCast(FunctionName, Int8PtrTy),
-      llvm::ConstantInt::get(Int32Ty, FunctionNameValue.size()),
+      llvm::ConstantInt::get(Int64Ty, FuncNameKey),
+      llvm::ConstantInt::get(Int32Ty, 0), // NameSize field in legacy format
       llvm::ConstantInt::get(Int32Ty, CoverageMapping.size()),
       llvm::ConstantInt::get(Int64Ty, FunctionHash)};
   FunctionRecords.push_back(llvm::ConstantStruct::get(
       FunctionRecordTy, makeArrayRef(FunctionRecordVals)));
+  FunctionNames.push_back(llvm::ConstantExpr::getBitCast(
+      FunctionName, llvm::Type::getInt8PtrTy(Ctx)));
   CoverageMappings += CoverageMapping;
 
   if (CGM.getCodeGenOpts().DumpCoverageMapping) {
     // Dump the coverage mapping data for this function by decoding the
     // encoded data. This allows us to dump the mapping regions which were
     // also processed by the CoverageMappingWriter which performs
     // additional minimization operations such as reducing the number of
     // expressions.
auto CovData = new llvm::GlobalVariable(CGM.getModule(), CovDataTy, true,
                                           CovDataVal,
                                           "__llvm_coverage_mapping");
 
   CovData->setSection(getCoverageSection(CGM));
   CovData->setAlignment(8);
 
   // Make sure the data doesn't get deleted.
   CGM.addUsedGlobal(CovData);
+
+  // Create the deferred function records array
+  auto NamesArrTy =
+      llvm::ArrayType::get(llvm::Type::getInt8PtrTy(Ctx), FunctionNames.size());
+  auto NamesArrVal = llvm::ConstantArray::get(NamesArrTy, FunctionNames);
+  // This variable will not be emitted to the object file. It is used
+  // to pass the list of names referenced to codegen.
+  new llvm::GlobalVariable(CGM.getModule(), NamesArrTy, true,
+                           llvm::GlobalValue::InternalLinkage, NamesArrVal,
+                           "__llvm_coverage_names");
 }
 
 unsigned CoverageMappingModuleGen::getFileID(const FileEntry *File) {
   auto It = FileEntries.find(File);
   if (It != FileEntries.end())
     return It->second;
   unsigned FileID = FileEntries.size();
   FileEntries.insert(std::make_pair(File, FileID));

lib/ProfileData/CoverageMappingReader.cpp

 //=-- CoverageMappingReader.cpp - Code coverage mapping reader ----*- C++ -*-=//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains support for reading coverage mapping data for
 // instrumentation based coverage.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ProfileData/CoverageMappingReader.h"
+#include "llvm/ProfileData/InstrProfReader.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/Object/MachOUniversal.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/raw_ostream.h"
for (auto &R : MappingRegions) {
         FileIDExpansionRegionMapping[R.FileID] = nullptr;
       }
     }
   }
 
   return std::error_code();
 }
 
-namespace {
-
-/// \brief A helper structure to access the data from a section
-/// in an object file.
-struct SectionData {
-  StringRef Data;
-  uint64_t Address;
-
-  std::error_code load(SectionRef &Section) {
-    if (auto Err = Section.getContents(Data))
-      return Err;
-    Address = Section.getAddress();
-    return std::error_code();
-  }
-
-  std::error_code get(uint64_t Pointer, size_t Size, StringRef &Result) {
-    if (Pointer < Address)
-      return coveragemap_error::malformed;
-    auto Offset = Pointer - Address;
-    if (Offset + Size > Data.size())
-      return coveragemap_error::malformed;
-    Result = Data.substr(Pointer - Address, Size);
-    return std::error_code();
-  }
-};
+std::error_code SymbolNameSectionData::get(uint64_t Pointer, size_t Size,
+                                           StringRef &Result) {
+
+std::error_code ProfSymtab::getFunctionName(uintptr_t NameKeyOrAddr,
+                                            size_t Size, StringRef &Result) {
+  if (UsesNameSection)
+    return SymtabSection.get(NameKeyOrAddr, Size, Result);
+
+  auto Iterator = Symtab.find(NameKeyOrAddr);
+  if (Iterator == Symtab.end())
+    return coveragemap_error::malformed;
+
+  Result = Iterator->second;
+  return std::error_code();
+}
+
+ProfSymtab::ProfSymtab(object::ObjectFile::symbol_iterator_range Syms) {
+  UsesNameSection = false;
+  auto S = Syms.begin();
+  auto E = Syms.end();
+  for (; S != E; ++S) {
+    ErrorOr<StringRef> NameOrError = S->getName();
+    if (!NameOrError)
+      continue;
+    StringRef Name = *NameOrError;
+
+    // TODO: define name prefix
+    if (!Name.startswith("__llvm_prf_nm_"))
+      continue;
+
+    StringRef RealName = Name.substr(strlen("__llvm_prf_nm_"));
+    uint64_t FuncNameKey =
+        IndexedInstrProf::ComputeHash(IndexedInstrProf::HashType, RealName);
+
+    Symtab[FuncNameKey] = RealName.str();
+  }
 }
 
 template <typename T, support::endianness Endian>
 std::error_code readCoverageMappingData(
-    SectionData &ProfileNames, StringRef Data,
+    std::unique_ptr<ProfSymtab> &ProfileNames, StringRef Data,
     std::vector<BinaryCoverageReader::ProfileMappingRecord> &Records,
     std::vector<StringRef> &Filenames) {
   using namespace support;
   llvm::DenseSet<T> UniqueFunctionMappingData;
 
   // Read the records in the coverage data section.
   for (const char *Buf = Data.data(), *End = Buf + Data.size(); Buf < End;) {
     if (Buf + 4 * sizeof(uint32_t) > End)
       return coveragemap_error::malformed;
     uint32_t NRecords = endian::readNext<uint32_t, Endian, unaligned>(Buf);
     uint32_t FilenamesSize = endian::readNext<uint32_t, Endian, unaligned>(Buf);
     uint32_t CoverageSize = endian::readNext<uint32_t, Endian, unaligned>(Buf);
     uint32_t Version = endian::readNext<uint32_t, Endian, unaligned>(Buf);
 
     switch (Version) {
     case CoverageMappingVersion1:
       break;
     default:
       return coveragemap_error::unsupported_version;
     }
 
     // Skip past the function records, saving the start and end for later.
     const char *FunBuf = Buf;
-    Buf += NRecords * (sizeof(T) + 2 * sizeof(uint32_t) + sizeof(uint64_t));
+    // TODO : this is very error-prone. Need to define size and structure of
+    // Function Record in coverage mapping in a single place.
+    Buf += NRecords * (3 * sizeof(uint64_t));
     const char *FunEnd = Buf;
 
     // Get the filenames.
     if (Buf + FilenamesSize > End)
       return coveragemap_error::malformed;
     size_t FilenamesBegin = Filenames.size();
     RawCoverageFilenamesReader Reader(StringRef(Buf, FilenamesSize), Filenames);
     if (auto Err = Reader.read())
       return Err;
     Buf += FilenamesSize;
 
     // We'll read the coverage mapping records in the loop below.
     const char *CovBuf = Buf;
     Buf += CoverageSize;
     const char *CovEnd = Buf;
 
     if (Buf > End)
       return coveragemap_error::malformed;
     // Each coverage map has an alignment of 8, so we need to adjust alignment
     // before reading the next map.
     Buf += alignmentAdjustment(Buf, 8);
 
     while (FunBuf < FunEnd) {
       // Read the function information
-      T NamePtr = endian::readNext<T, Endian, unaligned>(FunBuf);
+      uint64_t FuncNameKey =
+          endian::readNext<uint64_t, Endian, unaligned>(FunBuf);
       uint32_t NameSize = endian::readNext<uint32_t, Endian, unaligned>(FunBuf);
       uint32_t DataSize = endian::readNext<uint32_t, Endian, unaligned>(FunBuf);
       uint64_t FuncHash = endian::readNext<uint64_t, Endian, unaligned>(FunBuf);
 
       // Now use that to read the coverage data.
       if (CovBuf + DataSize > CovEnd)
         return coveragemap_error::malformed;
       auto Mapping = StringRef(CovBuf, DataSize);
       CovBuf += DataSize;
 
       // Ignore this record if we already have a record that points to the same
       // function name. This is useful to ignore the redundant records for the
       // functions with ODR linkage.
-      if (!UniqueFunctionMappingData.insert(NamePtr).second)
+      if (!UniqueFunctionMappingData.insert(FuncNameKey).second)
         continue;
 
       // Finally, grab the name and create a record.
       StringRef FuncName;
-      if (std::error_code EC = ProfileNames.get(NamePtr, NameSize, FuncName))
+      if (std::error_code EC =
+              ProfileNames->getFunctionName(FuncNameKey, NameSize, FuncName))
         return EC;
       Records.push_back(BinaryCoverageReader::ProfileMappingRecord(
           CoverageMappingVersion(Version), FuncName, FuncHash, Mapping,
           FilenamesBegin, Filenames.size() - FilenamesBegin));
     }
   }
 
   return std::error_code();
 }
 
 static const char *TestingFormatMagic = "llvmcovmtestdata";
 
-static std::error_code loadTestingFormat(StringRef Data,
-                                         SectionData &ProfileNames,
-                                         StringRef &CoverageMapping,
-                                         uint8_t &BytesInAddress,
-                                         support::endianness &Endian) {
+static std::error_code
+loadTestingFormat(StringRef Data, std::unique_ptr<ProfSymtab> &ProfileNames,
+                  StringRef &CoverageMapping, uint8_t &BytesInAddress,
   BytesInAddress = 8;
   Endian = support::endianness::little;
 
   Data = Data.substr(StringRef(TestingFormatMagic).size());
   if (Data.size() < 1)
     return coveragemap_error::truncated;
   unsigned N = 0;
   auto ProfileNamesSize =
       decodeULEB128(reinterpret_cast<const uint8_t *>(Data.data()), &N);
   if (N > Data.size())
     return coveragemap_error::malformed;
   Data = Data.substr(N);
   if (Data.size() < 1)
     return coveragemap_error::truncated;
   N = 0;
-  ProfileNames.Address =
+  uint64_t Address =
       decodeULEB128(reinterpret_cast<const uint8_t *>(Data.data()), &N);
   if (N > Data.size())
     return coveragemap_error::malformed;
   Data = Data.substr(N);
   if (Data.size() < ProfileNamesSize)
     return coveragemap_error::malformed;
-  ProfileNames.Data = Data.substr(0, ProfileNamesSize);
+  ProfileNames.reset(new ProfSymtab(Data.substr(0, ProfileNamesSize), Address));
   CoverageMapping = Data.substr(ProfileNamesSize);
   return std::error_code();
 }
 
 static ErrorOr<SectionRef> lookupSection(ObjectFile &OF, StringRef Name) {
   StringRef FoundName;
   for (const auto &Section : OF.sections()) {
     if (auto EC = Section.getName(FoundName))
       return EC;
     if (FoundName == Name)
       return Section;
   }
   return coveragemap_error::no_data_found;
 }
 
-static std::error_code loadBinaryFormat(MemoryBufferRef ObjectBuffer,
-                                        SectionData &ProfileNames,
-                                        StringRef &CoverageMapping,
-                                        uint8_t &BytesInAddress,
-                                        support::endianness &Endian,
-                                        StringRef Arch) {
+static std::error_code
+loadBinaryFormat(MemoryBufferRef ObjectBuffer,
+                 std::unique_ptr<ProfSymtab> &ProfileNames,
+                 StringRef &CoverageMapping, uint8_t &BytesInAddress,
+                 support::endianness &Endian, StringRef Arch) {
   auto BinOrErr = object::createBinary(ObjectBuffer);
   if (std::error_code EC = BinOrErr.getError())
     return EC;
   auto Bin = std::move(BinOrErr.get());
   std::unique_ptr<ObjectFile> OF;
   if (auto *Universal = dyn_cast<object::MachOUniversalBinary>(Bin.get())) {
     // If we have a universal binary, try to look up the object for the
     // appropriate architecture.
if (auto *Universal = dyn_cast<object::MachOUniversalBinary>(Bin.get())) {
     // We can only handle object files.
     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");
-  if (auto EC = NamesSection.getError())
-    return EC;
   auto CoverageSection = lookupSection(*OF, "__llvm_covmap");
   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;
+
+  ProfileNames.reset(new ProfSymtab(OF->symbols()));
 
   return std::error_code();
 }
 
 ErrorOr<std::unique_ptr<BinaryCoverageReader>>
 BinaryCoverageReader::create(std::unique_ptr<MemoryBuffer> &ObjectBuffer,
                              StringRef Arch) {
   std::unique_ptr<BinaryCoverageReader> Reader(new BinaryCoverageReader());
 
-  SectionData Profile;
+  std::unique_ptr<ProfSymtab> &Profile = Reader->Symtab;
   StringRef Coverage;
   uint8_t BytesInAddress;
   support::endianness Endian;
   std::error_code EC;
   if (ObjectBuffer->getBuffer().startswith(TestingFormatMagic))
     // This is a special format used for testing.
     EC = loadTestingFormat(ObjectBuffer->getBuffer(), Profile, Coverage,
                            BytesInAddress, Endian);

lib/ProfileData/InstrProfIndexed.h

-//=-- InstrProfIndexed.h - Indexed profiling format support -------*- C++ -*-=//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// Shared header for the instrumented profile data reader and writer.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_LIB_PROFILEDATA_INSTRPROFINDEXED_H
-#define LLVM_LIB_PROFILEDATA_INSTRPROFINDEXED_H
-
-#include "llvm/Support/Endian.h"
-#include "llvm/Support/ErrorHandling.h"
-#include "llvm/Support/MD5.h"
-
-namespace llvm {
-
-namespace IndexedInstrProf {
-enum class HashT : uint32_t {
-  MD5,
-
-  Last = MD5
-};
-
-static inline uint64_t MD5Hash(StringRef Str) {
-  MD5 Hash;
-  Hash.update(Str);
-  llvm::MD5::MD5Result Result;
-  Hash.final(Result);
-  // Return the least significant 8 bytes. Our MD5 implementation returns the
-  // result in little endian, so we may need to swap bytes.
-  using namespace llvm::support;
-  return endian::read<uint64_t, little, unaligned>(Result);
-}
-
-static inline uint64_t ComputeHash(HashT Type, StringRef K) {
-  switch (Type) {
-  case HashT::MD5:
-    return IndexedInstrProf::MD5Hash(K);
-  }
-  llvm_unreachable("Unhandled hash type");
-}
-
-const uint64_t Magic = 0x8169666f72706cff; // "\xfflprofi\x81"
-const uint64_t Version = 3;
-const HashT HashType = HashT::MD5;
-}
-
-} // end namespace llvm
-
-#endif

lib/ProfileData/InstrProfReader.cpp

 //=-- InstrProfReader.cpp - Instrumented profiling reader -------------------=//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains support for reading profiling data for clang's
 // instrumentation based PGO and coverage.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ProfileData/InstrProfReader.h"
-#include "InstrProfIndexed.h"
 #include "llvm/ADT/STLExtras.h"
 #include <cassert>
 
 using namespace llvm;
 
 static ErrorOr<std::unique_ptr<MemoryBuffer>>
 setupMemoryBuffer(std::string Path) {
   ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr =
std::error_code TextInstrProfReader::readNextRecord(InstrProfRecord &Record) {
   while (!Line.is_at_end() && (Line->empty() || Line->startswith("#")))
     ++Line;
   // If we hit EOF while looking for a name, we're done.
   if (Line.is_at_end())
     return error(instrprof_error::eof);
 
   // Read the function name.
   Record.Name = *Line++;
+  Record.NameKey =
+      IndexedInstrProf::ComputeHash(IndexedInstrProf::HashType, Record.Name);
 
   // Read the function hash.
   if (Line.is_at_end())
     return error(instrprof_error::truncated);
   if ((Line++)->getAsInteger(0, Record.Hash))
     return error(instrprof_error::malformed);
 
   // Read the number of counters.
RawInstrProfReader<IntPtrT>::readNextHeader(const char *CurrentPos) {
   if (Magic != swap(getRawMagic<IntPtrT>()))
     return instrprof_error::bad_magic;
 
   // There's another profile to read, so we need to process the header.
   auto *Header = reinterpret_cast<const RawHeader *>(CurrentPos);
   return readHeader(*Header);
 }
 
-static uint64_t getRawVersion() {
-  return 1;
-}
+static uint64_t getRawVersion() { return 2; }
 
 template <class IntPtrT>
 std::error_code
 RawInstrProfReader<IntPtrT>::readHeader(const RawHeader &Header) {
-  if (swap(Header.Version) != getRawVersion())
+  if (swap(Header.Version) > getRawVersion())
     return error(instrprof_error::unsupported_version);
 
+  Version = swap(Header.Version);
   CountersDelta = swap(Header.CountersDelta);
   NamesDelta = swap(Header.NamesDelta);
   auto DataSize = swap(Header.DataSize);
   auto CountersSize = swap(Header.CountersSize);
   auto NamesSize = swap(Header.NamesSize);
 
   ptrdiff_t DataOffset = sizeof(RawHeader);
-  ptrdiff_t CountersOffset = DataOffset + sizeof(ProfileData) * DataSize;
+  ptrdiff_t CountersOffset = getCounterOffset(DataOffset, DataSize);
   ptrdiff_t NamesOffset = CountersOffset + sizeof(uint64_t) * CountersSize;
   size_t ProfileSize = NamesOffset + sizeof(char) * NamesSize;
 
   auto *Start = reinterpret_cast<const char *>(&Header);
   if (Start + ProfileSize > DataBuffer->getBufferEnd())
     return error(instrprof_error::bad_header);
 
-  Data = reinterpret_cast<const ProfileData *>(Start + DataOffset);
-  DataEnd = Data + DataSize;
+  U1.Data = reinterpret_cast<const ProfileData *>(Start + DataOffset);
+  setDataEnd(DataSize);
   CountersStart = reinterpret_cast<const uint64_t *>(Start + CountersOffset);
   NamesStart = Start + NamesOffset;
   ProfileEnd = Start + ProfileSize;
 
   return success();
 }
 
 template <class IntPtrT>
 std::error_code
-RawInstrProfReader<IntPtrT>::readNextRecord(InstrProfRecord &Record) {
-  if (Data == DataEnd)
-    if (std::error_code EC = readNextHeader(ProfileEnd))
-      return EC;
+RawInstrProfReader<IntPtrT>::readNameFromData(uint64_t &NameKey,
+                                              StringRef &RawName) {
+  if (Version == 1) {
+    RawName = StringRef(getName(U1.DataV1->Name), swap(U1.DataV1->NameSize));
+    if (RawName.data() < NamesStart ||
+        RawName.data() + RawName.size() > DataBuffer->getBufferEnd())
+      return error(instrprof_error::malformed);
+    NameKey =
+        IndexedInstrProf::ComputeHash(IndexedInstrProf::HashType, RawName);
+  } else {
+    RawName = StringRef();
+    NameKey = U1.Data->NameKey;
+  }
+  return success();
+}
+
+template <class IntPtrT>
+std::error_code
+RawInstrProfReader<IntPtrT>::readRawCountsFromData(InstrProfRecord &Record) {
+
+  uint32_t NumCounters;
+  IntPtrT CounterPtr;
+  if (Version == 1) {
+    NumCounters = swap(U1.DataV1->NumCounters);
+    CounterPtr = U1.DataV1->CounterPtr;
+  } else {
+    NumCounters = swap(U1.Data->NumCounters);
+    CounterPtr = U1.Data->CounterPtr;
+  }
 
-  // Get the raw data.
-  StringRef RawName(getName(Data->NamePtr), swap(Data->NameSize));
-  uint32_t NumCounters = swap(Data->NumCounters);
   if (NumCounters == 0)
     return error(instrprof_error::malformed);
-  auto RawCounts = makeArrayRef(getCounter(Data->CounterPtr), NumCounters);
 
-  // Check bounds.
+  auto RawCounts = makeArrayRef(getCounter(CounterPtr), NumCounters);
+
   auto *NamesStartAsCounter = reinterpret_cast<const uint64_t *>(NamesStart);
-  if (RawName.data() < NamesStart ||
-      RawName.data() + RawName.size() > DataBuffer->getBufferEnd() ||
-      RawCounts.data() < CountersStart ||
+
+  // Check bounds.
+  if (RawCounts.data() < CountersStart ||
       RawCounts.data() + RawCounts.size() > NamesStartAsCounter)
     return error(instrprof_error::malformed);
 
-  // Store the data in Record, byte-swapping as necessary.
-  Record.Hash = swap(Data->FuncHash);
-  Record.Name = RawName;
   if (ShouldSwapBytes) {
     Record.Counts.clear();
     Record.Counts.reserve(RawCounts.size());
     for (uint64_t Count : RawCounts)
       Record.Counts.push_back(swap(Count));
   } else
     Record.Counts = RawCounts;
 
+  return success();
+}
+
+template <class IntPtrT>
+std::error_code
+RawInstrProfReader<IntPtrT>::readFuncHashFromData(uint64_t &FuncHash) {
+  // Store the data in Record, byte-swapping as necessary.
+  if (Version == 1)
+    FuncHash = swap(U1.DataV1->FuncHash);
+  else
+    FuncHash = swap(U1.Data->FuncHash);
+  return success();
+}
+
+template <class IntPtrT>
+std::error_code
+RawInstrProfReader<IntPtrT>::readNextRecord(InstrProfRecord &Record) {
+  if (U1.Data == U2.DataEnd)
+    if (std::error_code EC = readNextHeader(ProfileEnd))
+      return EC;
+
+  if (std::error_code EC = readNameFromData(Record.NameKey, Record.Name))
+    return EC;
+
+  if (std::error_code EC = readFuncHashFromData(Record.Hash))
+    return EC;
+
+  if (std::error_code EC = readRawCountsFromData(Record))
+    return EC;
+
   // Iterate.
-  ++Data;
+  advanceData();
   return success();
 }
 
 namespace llvm {
 template class RawInstrProfReader<uint32_t>;
 template class RawInstrProfReader<uint64_t>;
 }
 
-InstrProfLookupTrait::hash_value_type
-InstrProfLookupTrait::ComputeHash(StringRef K) {
+namespace llvm {
+template <class KeyType>
+typename InstrProfLookupTrait<KeyType>::hash_value_type
+InstrProfLookupTrait<KeyType>::ComputeHash(KeyType K) {
   return IndexedInstrProf::ComputeHash(HashType, K);
 }
 
-typedef InstrProfLookupTrait::data_type data_type;
-typedef InstrProfLookupTrait::offset_type offset_type;
+template <>
+InstrProfLookupTrait<uint64_t>::hash_value_type
+InstrProfLookupTrait<uint64_t>::ComputeHash(uint64_t K) {
+  return K;
+}
+}
 
-bool InstrProfLookupTrait::ReadValueProfilingData(
+template <class KeyType>
+bool InstrProfLookupTrait<KeyType>::ReadValueProfilingData(
     const unsigned char *&D, const unsigned char *const End) {
 
   using namespace support;
   // Read number of value kinds with value sites.
   if (D + sizeof(uint64_t) > End)
     return false;
   uint64_t ValueKindCount = endian::readNext<uint64_t, little, unaligned>(D);
 
for (uint64_t VSite = 0; VSite < ValueSiteCount; ++VSite) {
       // Check if there are as many ValueDataPairs as ValueDataCount in memory.
       if (D + (ValueDataCount << 1) * sizeof(uint64_t) > End)
         return false;
 
       InstrProfValueSiteRecord VSiteRecord;
       for (uint64_t VCount = 0; VCount < ValueDataCount; ++VCount) {
         uint64_t Value = endian::readNext<uint64_t, little, unaligned>(D);
         uint64_t NumTaken = endian::readNext<uint64_t, little, unaligned>(D);
-        switch (ValueKind) {
-        case IPVK_IndirectCallTarget: {
-          auto Result =
-              std::lower_bound(HashKeys.begin(), HashKeys.end(), Value,
-                               [](const std::pair<uint64_t, const char *> &LHS,
-                                  uint64_t RHS) { return LHS.first < RHS; });
-          assert(Result != HashKeys.end() &&
-                 "Hash does not match any known keys\n");
-          Value = (uint64_t)Result->second;
-          break;
-        }
-        }
         VSiteRecord.ValueData.push_back(std::make_pair(Value, NumTaken));
       }
       ValueSites.push_back(std::move(VSiteRecord));
     }
   }
   return true;
 }
 
-data_type InstrProfLookupTrait::ReadData(StringRef K, const unsigned char *D,
-                                         offset_type N) {
+template <class KeyType>
+typename InstrProfLookupTrait<KeyType>::data_type
+InstrProfLookupTrait<KeyType>::ReadData(KeyType K, const unsigned char *D,
   // Check if the data is corrupt. If so, don't try to read it.
   if (N % sizeof(uint64_t))
     return data_type();
 
   DataBuffer.clear();
   std::vector<uint64_t> CounterBuffer;
 
   using namespace support;
while (D < End) {
     CounterBuffer.clear();
     CounterBuffer.reserve(CountsSize);
     for (uint64_t J = 0; J < CountsSize; ++J)
       CounterBuffer.push_back(endian::readNext<uint64_t, little, unaligned>(D));
 
     DataBuffer.push_back(InstrProfRecord(K, Hash, std::move(CounterBuffer)));
 
     // Read value profiling data
-    if (FormatVersion > 2 && !ReadValueProfilingData(D, End)) {
+    if (FormatVersion > 3 && !ReadValueProfilingData(D, End)) {
       DataBuffer.clear();
       return data_type();
     }
   }
   return DataBuffer;
 }
 
 bool IndexedInstrProfReader::hasFormat(const MemoryBuffer &DataBuffer) {
std::error_code IndexedInstrProfReader::readHeader() {
   using namespace support;
 
   // Check the magic number.
   uint64_t Magic = endian::readNext<uint64_t, little, unaligned>(Cur);
   if (Magic != IndexedInstrProf::Magic)
     return error(instrprof_error::bad_magic);
 
   // Read the version.
-  FormatVersion = endian::readNext<uint64_t, little, unaligned>(Cur);
+  uint64_t FormatVersion = endian::readNext<uint64_t, little, unaligned>(Cur);
   if (FormatVersion > IndexedInstrProf::Version)
     return error(instrprof_error::unsupported_version);
 
   // Read the maximal function count.
   MaxFunctionCount = endian::readNext<uint64_t, little, unaligned>(Cur);
 
   // Read the hash type and start offset.
   IndexedInstrProf::HashT HashType = static_cast<IndexedInstrProf::HashT>(
       endian::readNext<uint64_t, little, unaligned>(Cur));
   if (HashType > IndexedInstrProf::HashT::Last)
     return error(instrprof_error::unsupported_hash_type);
   uint64_t HashOffset = endian::readNext<uint64_t, little, unaligned>(Cur);
 
   // The rest of the file is an on disk hash table.
-  Index.reset(InstrProfReaderIndex::Create(
-      Start + HashOffset, Cur, Start,
-      InstrProfLookupTrait(HashType, FormatVersion)));
-
-  // Form the map of hash values to const char* keys in profiling data.
-  std::vector<std::pair<uint64_t, const char *>> HashKeys;
-  for (auto Key : Index->keys()) {
-    const char *KeyTableRef = StringTable.insertString(Key);
-    HashKeys.push_back(std::make_pair(ComputeHash(HashType, Key), KeyTableRef));
-  }
-  std::sort(HashKeys.begin(), HashKeys.end(), less_first());
-  HashKeys.erase(std::unique(HashKeys.begin(), HashKeys.end()), HashKeys.end());
-  // Set the hash key map for the InstrLookupTrait
-  Index->getInfoObj().setHashKeys(std::move(HashKeys));
-  // Set up our iterator for readNextRecord.
-  RecordIterator = Index->data_begin();
+  Index.Init(Start + HashOffset, Cur, Start, HashType, FormatVersion);
 
   return success();
 }
 
-std::error_code IndexedInstrProfReader::getFunctionCounts(
-    StringRef FuncName, uint64_t FuncHash, std::vector<uint64_t> &Counts) {
-  auto Iter = Index->find(FuncName);
+std::error_code InstrProfIndex::getRecord(StringRef FuncName,
+                                          uint64_t FuncNameKey,
+                                          ArrayRef<InstrProfRecord> &Data) {
+
+  if (FormatVersion <= 3) {
+    assert(!FuncName.empty());
+    auto Iter = IndexV3->find(FuncName);
+    if (Iter == IndexV3->end())
+      return instrprof_error::unknown_function;
+
+    // Found it. Look for counters with the right hash.
+    Data = (*Iter);
+  } else {
+    auto Iter = Index->find(FuncNameKey);
     if (Iter == Index->end())
-    return error(instrprof_error::unknown_function);
+      return instrprof_error::unknown_function;
 
     // Found it. Look for counters with the right hash.
-  ArrayRef<InstrProfRecord> Data = (*Iter);
+    Data = (*Iter);
+  }
+
   if (Data.empty())
-    return error(instrprof_error::malformed);
+    return instrprof_error::malformed;
+
+  return instrprof_error::success;
+}
+
+std::error_code
+InstrProfIndex::getRecordsForNextKey(ArrayRef<InstrProfRecord> &Data) {
+  // Are we out of records?
+  if (atEnd())
+    return instrprof_error::eof;
+
+  if (FormatVersion <= 3)
+    Data = *RecordIteratorV3;
+  else
+    Data = *RecordIterator;
+
+  if (Data.empty())
+    return instrprof_error::malformed;
+
+  return instrprof_error::success;
+}
+
+std::error_code IndexedInstrProfReader::getFunctionCounts(
+    StringRef FuncName, uint64_t FuncNameKey, uint64_t FuncHash,
+    std::vector<uint64_t> &Counts) {
+
+  ArrayRef<InstrProfRecord> Data;
+  std::error_code EC = Index.getRecord(FuncName, FuncNameKey, Data);
+  if (EC != instrprof_error::success)
+    return error(EC);
 
   for (unsigned I = 0, E = Data.size(); I < E; ++I) {
     // Check for a match and fill the vector if there is one.
     if (Data[I].Hash == FuncHash) {
       Counts = Data[I].Counts;
       return success();
     }
   }
   return error(instrprof_error::hash_mismatch);
 }
 
 std::error_code
-IndexedInstrProfReader::readNextRecord(InstrProfRecord &Record) {
-  // Are we out of records?
-  if (RecordIterator == Index->data_end())
-    return error(instrprof_error::eof);
+IndexedInstrProfReader::getFunctionCounts(StringRef FuncName, uint64_t FuncHash,
+                                          std::vector<uint64_t> &Counts) {
+  uint64_t FuncNameKey =
+      IndexedInstrProf::ComputeHash(IndexedInstrProf::HashType, FuncName);
+  return getFunctionCounts(FuncName, FuncNameKey, FuncHash, Counts);
+}
 
-  if ((*RecordIterator).empty())
-    return error(instrprof_error::malformed);
+std::error_code IndexedInstrProfReader::getFunctionCounts(
+    uint64_t FuncNameKey, uint64_t FuncHash, std::vector<uint64_t> &Counts) {
+  return getFunctionCounts(StringRef(), FuncNameKey, FuncHash, Counts);
+}
+
+std::error_code
+IndexedInstrProfReader::readNextRecord(InstrProfRecord &Record) {
 
   static unsigned RecordIndex = 0;
-  ArrayRef<InstrProfRecord> Data = (*RecordIterator);
+
+  ArrayRef<InstrProfRecord> Data;
+  std::error_code EC = Index.getRecordsForNextKey(Data);
+  if (EC != instrprof_error::success)
+    return error(EC);
+
   Record = Data[RecordIndex++];
   if (RecordIndex >= Data.size()) {
-    ++RecordIterator;
+    Index.advanceToNextKey();
     RecordIndex = 0;
   }
   return success();
 }

lib/ProfileData/InstrProfWriter.cpp

 //=-- InstrProfWriter.cpp - Instrumented profiling writer -------------------=//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains support for writing profiling data for clang's
 // instrumentation based PGO and coverage.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ProfileData/InstrProfWriter.h"
-#include "InstrProfIndexed.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/EndianStream.h"
 #include "llvm/Support/OnDiskHashTable.h"
 
 using namespace llvm;
 
 namespace {
 class InstrProfRecordTrait {
 public:
-  typedef StringRef key_type;
-  typedef StringRef key_type_ref;
+  typedef uint64_t key_type;
+  typedef uint64_t key_type_ref;
 
   typedef const InstrProfWriter::ProfilingData *const data_type;
   typedef const InstrProfWriter::ProfilingData *const data_type_ref;
 
   typedef uint64_t hash_value_type;
   typedef uint64_t offset_type;
 
-  static hash_value_type ComputeHash(key_type_ref K) {
-    return IndexedInstrProf::ComputeHash(IndexedInstrProf::HashType, K);
-  }
+  static hash_value_type ComputeHash(key_type_ref K) { return K; }
 
   static std::pair<offset_type, offset_type>
   EmitKeyDataLength(raw_ostream &Out, key_type_ref K, data_type_ref V) {
     using namespace llvm::support;
     endian::Writer<little> LE(Out);
 
-    offset_type N = K.size();
+    offset_type N = sizeof(key_type_ref);
     LE.write<offset_type>(N);
 
     offset_type M = 0;
     for (const auto &ProfileData : *V) {
       M += sizeof(uint64_t); // The function hash
       M += sizeof(uint64_t); // The size of the Counts vector
       M += ProfileData.second.Counts.size() * sizeof(uint64_t);
 
for (const auto &ProfileData : *V) {
       }
     }
     LE.write<offset_type>(M);
 
     return std::make_pair(N, M);
   }
 
   static void EmitKey(raw_ostream &Out, key_type_ref K, offset_type N){
-    Out.write(K.data(), N);
+    using namespace llvm::support;
+    endian::Writer<little> LE(Out);
+    LE.write<uint64_t>(K);
   }
 
   static void EmitData(raw_ostream &Out, key_type_ref, data_type_ref V,
                        offset_type) {
     using namespace llvm::support;
     endian::Writer<little> LE(Out);
     for (const auto &ProfileData : *V) {
       LE.write<uint64_t>(ProfileData.first); // Function hash
for (const auto &ProfileData : *V) {
           continue;
         LE.write<uint64_t>(Kind); // Write value kind
         // Write number of value sites for current value kind
         LE.write<uint64_t>(ValueSites.size());
         for (InstrProfValueSiteRecord I : ValueSites) {
           // Write number of value data pairs at this value site
           LE.write<uint64_t>(I.ValueData.size());
           for (auto V : I.ValueData) {
-            if (Kind == IPVK_IndirectCallTarget)
-              LE.write<uint64_t>(ComputeHash((const char *)V.first));
-            else
-              LE.write<uint64_t>(V.first);
             LE.write<uint64_t>(V.second);
           }
         }
       }
     }
   }
 };
 }
static std::error_code combineInstrProfRecords(InstrProfRecord &Dest,
 
   // We keep track of the max function count as we go for simplicity.
   if (Dest.Counts[0] > MaxFunctionCount)
     MaxFunctionCount = Dest.Counts[0];
 
   return instrprof_error::success;
 }
 
-void InstrProfWriter::updateStringTableReferences(InstrProfRecord &I) {
-  I.Name = StringTable.insertString(I.Name);
-  for (auto &VSite : I.IndirectCallSites)
-    for (auto &VData : VSite.ValueData)
-      VData.first =
-          (uint64_t)StringTable.insertString((const char *)VData.first);
-}
-
 std::error_code InstrProfWriter::addRecord(InstrProfRecord &&I) {
-  updateStringTableReferences(I);
-  auto &ProfileDataMap = FunctionData[I.Name];
+  auto &ProfileDataMap = FunctionData[I.NameKey];
 
   auto Where = ProfileDataMap.find(I.Hash);
   if (Where == ProfileDataMap.end()) {
     // We've never seen a function with this name and hash, add it.
     ProfileDataMap[I.Hash] = I;
 
     // We keep track of the max function count as we go for simplicity.
     if (I.Counts[0] > MaxFunctionCount)
       MaxFunctionCount = I.Counts[0];
     return instrprof_error::success;
   }
 
   // We're updating a function we've seen before.
   return combineInstrProfRecords(Where->second, I, MaxFunctionCount);
 }
 
 std::pair<uint64_t, uint64_t> InstrProfWriter::writeImpl(raw_ostream &OS) {
   OnDiskChainedHashTableGenerator<InstrProfRecordTrait> Generator;
 
   // Populate the hash table generator.
   for (const auto &I : FunctionData)
-    Generator.insert(I.getKey(), &I.getValue());
+    Generator.insert(I.getFirst(), &I.getSecond());
 
   using namespace llvm::support;
   endian::Writer<little> LE(OS);
 
   // Write the header.
   LE.write<uint64_t>(IndexedInstrProf::Magic);
   LE.write<uint64_t>(IndexedInstrProf::Version);
   LE.write<uint64_t>(MaxFunctionCount);

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/Transforms/Instrumentation.h"
+#include "llvm/ProfileData/InstrProf.h"
 
 #include "llvm/ADT/Triple.h"
+#include "llvm/ADT/StringExtras.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Transforms/Utils/ModuleUtils.h"
 
 using namespace llvm;
 
 #define DEBUG_TYPE "instrprof"
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";
   }
 
-  /// Get the section name for the name variables.
-  StringRef getNameSection() const {
-    return isMachO() ? "__DATA,__llvm_prf_names" : "__llvm_prf_names";
-  }
-
   /// Get the section name for the profile data variables.
   StringRef getDataSection() const {
     return isMachO() ? "__DATA,__llvm_prf_data" : "__llvm_prf_data";
   }
 
   /// Get the section name for the coverage mapping data.
   StringRef getCoverageSection() const {
     return isMachO() ? "__DATA,__llvm_covmap" : "__llvm_covmap";
   }
 
   /// 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);
+  void lowerCoverageData(GlobalVariable *CoverageData,
+                         GlobalVariable *CoverageNames);
 
   /// Get the region counters for an increment, creating them if necessary.
   ///
   /// If the counter array doesn't yet exist, the profile data variables
   /// referring to them will also be created.
   GlobalVariable *getOrCreateRegionCounters(InstrProfIncrementInst *Inc);
 
   /// Emit runtime registration functions for each profile data variable.
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")) {
-    lowerCoverageData(Coverage);
+    GlobalVariable *CoverageNames = M.getNamedGlobal("__llvm_coverage_names");
+    assert(CoverageNames);
+    lowerCoverageData(Coverage, CoverageNames);
     MadeChange = true;
   }
   if (!MadeChange)
     return false;
 
   emitRegistration();
   emitRuntimeHook();
   emitUses();
   emitInitialization();
   return true;
 }
 
 void InstrProfiling::lowerIncrement(InstrProfIncrementInst *Inc) {
   GlobalVariable *Counters = getOrCreateRegionCounters(Inc);
 
   IRBuilder<> Builder(Inc->getParent(), *Inc);
   uint64_t Index = Inc->getIndex()->getZExtValue();
   Value *Addr = Builder.CreateConstInBoundsGEP2_64(Counters, 0, Index);
   Value *Count = Builder.CreateLoad(Addr, "pgocount");
   Count = Builder.CreateAdd(Count, Builder.getInt64(1));
   Inc->replaceAllUsesWith(Builder.CreateStore(Count, Addr));
   Inc->eraseFromParent();
 }
 
-void InstrProfiling::lowerCoverageData(GlobalVariable *CoverageData) {
+void InstrProfiling::lowerCoverageData(GlobalVariable *CoverageData,
+                                       GlobalVariable *CoverageNames) {
   CoverageData->setSection(getCoverageSection());
   CoverageData->setAlignment(8);
 
-  Constant *Init = CoverageData->getInitializer();
-  // We're expecting { i32, i32, i32, i32, [n x { i8*, i32, i32 }], [m x i8] }
+  Constant *Init __attribute__((unused)) = CoverageData->getInitializer();
+  // We're expecting { i32, i32, i32, i32, [n x { i64, i32, i32, i64 }], [m x
+  // i8] }
   // for some C. If not, the frontend's given us something broken.
   assert(Init->getNumOperands() == 6 && "bad number of fields in coverage map");
   assert(isa<ConstantArray>(Init->getAggregateElement(4)) &&
          "invalid function list in coverage map");
-  ConstantArray *Records = cast<ConstantArray>(Init->getAggregateElement(4));
-  for (unsigned I = 0, E = Records->getNumOperands(); I < E; ++I) {
-    Constant *Record = Records->getOperand(I);
-    Value *V = const_cast<Value *>(Record->getOperand(0))->stripPointerCasts();
 
-    assert(isa<GlobalVariable>(V) && "Missing reference to function name");
-    GlobalVariable *Name = cast<GlobalVariable>(V);
+  ConstantArray *Names = cast<ConstantArray>(CoverageNames->getInitializer());
+
+  for (unsigned I = 0, E = Names->getNumOperands(); I < E; ++I) {
+    Constant *NC = Names->getOperand(I);
+
+    assert(isa<GlobalVariable>(NC) && "Missing reference to function name");
+    GlobalVariable *Name = cast<GlobalVariable>(NC);
 
     // If we have region counters for this name, we've already handled it.
     auto It = RegionCounters.find(Name);
     if (It != RegionCounters.end())
       continue;
 
-    // Move the name variable to the right section.
-    Name->setSection(getNameSection());
-    Name->setAlignment(1);
+    // FE never emits the function with the name, but it is referenced
+    // by coverage data. Force emitting the name.
+    // Reset Name variable's linkage
+    Name->setLinkage(GlobalValue::ExternalWeakLinkage);
+    // Mark the name variable as used so that it isn't stripped out.
+    UsedVars.push_back(Name);
   }
 }
 
 /// Get the name of a profiling variable for a particular function.
 static std::string getVarName(InstrProfIncrementInst *Inc, StringRef VarName) {
-  auto *Arr = cast<ConstantDataArray>(Inc->getName()->getInitializer());
-  StringRef Name = Arr->isCString() ? Arr->getAsCString() : Arr->getAsString();
-  return ("__llvm_profile_" + VarName + "_" + Name).str();
+  // TODO define a macro for __llvm_prf_nm_ prefix and its size
+  StringRef Name = Inc->getName()->getName().substr(strlen("__llvm_prf_nm_"));
+  return ("__llvm_prf_" + VarName + "_" + 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")));
-  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"));
+                                      getVarName(Inc, "cnts"));
   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 FuncNameKey = IndexedInstrProf::ComputeHash(
+      IndexedInstrProf::HashType,
+      Inc->getName()->getName().substr(strlen("__llvm_prf_nm_")));
+  Type *DataTypes[] = {Int64Ty, Int64Ty, Int64PtrTy, Int32Ty};
   auto *DataTy = StructType::get(Ctx, makeArrayRef(DataTypes));
   Constant *DataVals[] = {
-      ConstantInt::get(Int32Ty, NameArrayTy->getArrayNumElements()),
-      ConstantInt::get(Int32Ty, NumCounters),
+      ConstantInt::get(Int64Ty, FuncNameKey),
       ConstantInt::get(Int64Ty, Inc->getHash()->getZExtValue()),
-      ConstantExpr::getBitCast(Name, Int8PtrTy),
-      ConstantExpr::getBitCast(Counters, Int64PtrTy)};
+      ConstantExpr::getBitCast(Counters, Int64PtrTy),
+      ConstantInt::get(Int32Ty, NumCounters)};
   auto *Data = new GlobalVariable(*M, DataTy, true, Name->getLinkage(),
                                   ConstantStruct::get(DataTy, DataVals),
                                   getVarName(Inc, "data"));
   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);
 
+  // Reset Name variable's linkage
+  Name->setLinkage(GlobalValue::ExternalWeakLinkage);
+  // Mark the name variable as used so that it isn't stripped out.
+  UsedVars.push_back(Name);
+
   return Counters;
 }
 
 void InstrProfiling::emitRegistration() {
   // Don't do this for Darwin.  compiler-rt uses linker magic.
   if (Triple(M->getTargetTriple()).isOSDarwin())
     return;
 
void InstrProfiling::emitRegistration() {
 
   auto *RuntimeRegisterTy = FunctionType::get(VoidTy, VoidPtrTy, false);
   auto *RuntimeRegisterF =
       Function::Create(RuntimeRegisterTy, GlobalVariable::ExternalLinkage,
                        "__llvm_profile_register_function", M);
 
   IRBuilder<> IRB(BasicBlock::Create(M->getContext(), "", RegisterF));
   for (Value *Data : UsedVars)
+    if (!cast<GlobalVariable>(Data)->isDeclaration())
       IRB.CreateCall(RuntimeRegisterF, IRB.CreateBitCast(Data, VoidPtrTy));
   IRB.CreateRetVoid();
 }
 
 void InstrProfiling::emitRuntimeHook() {
   const char *const RuntimeVarName = "__llvm_profile_runtime";
   const char *const RuntimeUserName = "__llvm_profile_runtime_user";
 
   // If the module's provided its own runtime, we don't need to do anything.

lib/profile/InstrProfiling.h

 #include <inttypes.h>
 #include <stdint.h>
 
 #endif /* defined(__FreeBSD__) && defined(__i386__) */
 
 #define PROFILE_HEADER_SIZE 7
 
 typedef struct __llvm_profile_data {
-  const uint32_t NameSize;
-  const uint32_t NumCounters;
+  const uint64_t FuncKey;
   const uint64_t FuncHash;
-  const char *const Name;
   uint64_t *const Counters;
+  const uint32_t NumCounters;
 } __llvm_profile_data;
 
 /*!
  * \brief Get required size for profile buffer.
  */
 uint64_t __llvm_profile_get_size_for_buffer(void);
 
 /*!
  * \brief Write instrumentation data to the given buffer.
  *
  * \pre \c Buffer is the start of a buffer at least as big as \a
  * __llvm_profile_get_size_for_buffer().
  */
 int __llvm_profile_write_buffer(char *Buffer);
 
 const __llvm_profile_data *__llvm_profile_begin_data(void);
 const __llvm_profile_data *__llvm_profile_end_data(void);
-const char *__llvm_profile_begin_names(void);
-const char *__llvm_profile_end_names(void);
 uint64_t *__llvm_profile_begin_counters(void);
 uint64_t *__llvm_profile_end_counters(void);
 
 /*!
  * \brief Write instrumentation data to the current file.
  *
  * Writes to the file with the last name given to \a __llvm_profile_set_filename(),
  * or if it hasn't been called, the \c LLVM_PROFILE_FILE environment variable,

lib/profile/InstrProfiling.c

return
     (uint64_t)'f' << 16 |
     (uint64_t) R  <<  8 |
     (uint64_t)129;
 }
 
 __attribute__((visibility("hidden")))
 uint64_t __llvm_profile_get_version(void) {
   /* This should be bumped any time the output format changes. */
-  return 1;
+  return 2;
 }
 
 __attribute__((visibility("hidden")))
 void __llvm_profile_reset_counters(void) {
   uint64_t *I = __llvm_profile_begin_counters();
   uint64_t *E = __llvm_profile_end_counters();
 
   memset(I, 0, sizeof(uint64_t)*(E - I));
 }

lib/profile/InstrProfilingBuffer.c

 #include <string.h>
 
 __attribute__((visibility("hidden")))
 uint64_t __llvm_profile_get_size_for_buffer(void) {
   const __llvm_profile_data *DataBegin = __llvm_profile_begin_data();
   const __llvm_profile_data *DataEnd = __llvm_profile_end_data();
   const uint64_t *CountersBegin = __llvm_profile_begin_counters();
   const uint64_t *CountersEnd = __llvm_profile_end_counters();
-  const char *NamesBegin = __llvm_profile_begin_names();
-  const char *NamesEnd = __llvm_profile_end_names();
 
   return __llvm_profile_get_size_for_buffer_internal(
-      DataBegin, DataEnd, CountersBegin, CountersEnd, NamesBegin, NamesEnd);
+      DataBegin, DataEnd, CountersBegin, CountersEnd);
 }
 
 #define PROFILE_RANGE_SIZE(Range) (Range##End - Range##Begin)
 
-__attribute__((visibility("hidden")))
-uint64_t __llvm_profile_get_size_for_buffer_internal(
+__attribute__((visibility("hidden"))) uint64_t
+    __llvm_profile_get_size_for_buffer_internal(
         const __llvm_profile_data *DataBegin,
         const __llvm_profile_data *DataEnd, const uint64_t *CountersBegin,
-        const uint64_t *CountersEnd, const char *NamesBegin,
-        const char *NamesEnd) {
+        const uint64_t *CountersEnd) {
   /* Match logic in __llvm_profile_write_buffer(). */
-  const uint64_t NamesSize = PROFILE_RANGE_SIZE(Names) * sizeof(char);
-  const uint64_t Padding = sizeof(uint64_t) - NamesSize % sizeof(uint64_t);
   return sizeof(uint64_t) * PROFILE_HEADER_SIZE +
          PROFILE_RANGE_SIZE(Data) * sizeof(__llvm_profile_data) +
-      PROFILE_RANGE_SIZE(Counters) * sizeof(uint64_t) +
-      NamesSize + Padding;
+         PROFILE_RANGE_SIZE(Counters) * sizeof(uint64_t);
 }
 
 __attribute__((visibility("hidden")))
 int __llvm_profile_write_buffer(char *Buffer) {
   /* Match logic in __llvm_profile_get_size_for_buffer().
    * Match logic in __llvm_profile_write_file().
    */
   const __llvm_profile_data *DataBegin = __llvm_profile_begin_data();
   const __llvm_profile_data *DataEnd = __llvm_profile_end_data();
   const uint64_t *CountersBegin = __llvm_profile_begin_counters();
   const uint64_t *CountersEnd   = __llvm_profile_end_counters();
-  const char *NamesBegin = __llvm_profile_begin_names();
-  const char *NamesEnd   = __llvm_profile_end_names();
 
   return __llvm_profile_write_buffer_internal(Buffer, DataBegin, DataEnd,
-                                              CountersBegin, CountersEnd,
-                                              NamesBegin, NamesEnd);
+                                              CountersBegin, CountersEnd);
 }
 
-__attribute__((visibility("hidden")))
-int __llvm_profile_write_buffer_internal(
+__attribute__((visibility("hidden"))) int __llvm_profile_write_buffer_internal(
     char *Buffer, const __llvm_profile_data *DataBegin,
     const __llvm_profile_data *DataEnd, const uint64_t *CountersBegin,
-    const uint64_t *CountersEnd, const char *NamesBegin, const char *NamesEnd) {
+    const uint64_t *CountersEnd) {
   /* Match logic in __llvm_profile_get_size_for_buffer().
    * Match logic in __llvm_profile_write_file().
    */
 
   /* Calculate size of sections. */
   const uint64_t DataSize = DataEnd - DataBegin;
   const uint64_t CountersSize = CountersEnd - CountersBegin;
-  const uint64_t NamesSize = NamesEnd - NamesBegin;
-  const uint64_t Padding = sizeof(uint64_t) - NamesSize % sizeof(uint64_t);
-
-  /* Enough zeroes for padding. */
-  const char Zeroes[sizeof(uint64_t)] = {0};
 
   /* Create the header. */
   uint64_t Header[PROFILE_HEADER_SIZE];
   Header[0] = __llvm_profile_get_magic();
   Header[1] = __llvm_profile_get_version();
   Header[2] = DataSize;
   Header[3] = CountersSize;
-  Header[4] = NamesSize;
+  Header[4] = 0; /* For V1 */
   Header[5] = (uintptr_t)CountersBegin;
-  Header[6] = (uintptr_t)NamesBegin;
+  Header[6] = 0; /* For V1 */
 
   /* Write the data. */
 #define UPDATE_memcpy(Data, Size) \
   do {                            \
     memcpy(Buffer, Data, Size);   \
     Buffer += Size;               \
   } while (0)
   UPDATE_memcpy(Header,  PROFILE_HEADER_SIZE * sizeof(uint64_t));
   UPDATE_memcpy(DataBegin,     DataSize      * sizeof(__llvm_profile_data));
   UPDATE_memcpy(CountersBegin, CountersSize  * sizeof(uint64_t));
-  UPDATE_memcpy(NamesBegin,    NamesSize     * sizeof(char));
-  UPDATE_memcpy(Zeroes,        Padding       * sizeof(char));
 #undef UPDATE_memcpy
 
   return 0;
 }

lib/profile/InstrProfilingFile.c

 #define UNCONST(ptr) ((void *)(uintptr_t)(ptr))
 
 static int writeFile(FILE *File) {
   /* Match logic in __llvm_profile_write_buffer(). */
   const __llvm_profile_data *DataBegin = __llvm_profile_begin_data();
   const __llvm_profile_data *DataEnd = __llvm_profile_end_data();
   const uint64_t *CountersBegin = __llvm_profile_begin_counters();
   const uint64_t *CountersEnd   = __llvm_profile_end_counters();
-  const char *NamesBegin = __llvm_profile_begin_names();
-  const char *NamesEnd   = __llvm_profile_end_names();
 
   /* Calculate size of sections. */
   const uint64_t DataSize = DataEnd - DataBegin;
   const uint64_t CountersSize = CountersEnd - CountersBegin;
-  const uint64_t NamesSize = NamesEnd - NamesBegin;
-  const uint64_t Padding = sizeof(uint64_t) - NamesSize % sizeof(uint64_t);
-
-  /* Enough zeroes for padding. */
-  const char Zeroes[sizeof(uint64_t)] = {0};
 
   /* Create the header. */
   uint64_t Header[PROFILE_HEADER_SIZE];
   Header[0] = __llvm_profile_get_magic();
   Header[1] = __llvm_profile_get_version();
   Header[2] = DataSize;
   Header[3] = CountersSize;
-  Header[4] = NamesSize;
+  Header[4] = 0; /* NameSize unused */
   Header[5] = (uintptr_t)CountersBegin;
-  Header[6] = (uintptr_t)NamesBegin;
+  Header[6] = 0; /* NamesBegin unused */
 
   /* Write the data. */
 #define CHECK_fwrite(Data, Size, Length, File) \
   do { if (fwrite(Data, Size, Length, File) != Length) return -1; } while (0)
   CHECK_fwrite(Header,        sizeof(uint64_t), PROFILE_HEADER_SIZE, File);
   CHECK_fwrite(DataBegin,     sizeof(__llvm_profile_data), DataSize, File);
   CHECK_fwrite(CountersBegin, sizeof(uint64_t), CountersSize, File);
-  CHECK_fwrite(NamesBegin,    sizeof(char), NamesSize, File);
-  CHECK_fwrite(Zeroes,        sizeof(char), Padding, File);
 #undef CHECK_fwrite
 
   return 0;
 }
 
 static int writeFileWithName(const char *OutputName) {
   int RetVal;
   FILE *OutputFile;

lib/profile/InstrProfilingInternal.h

 /*!
  * \brief Write instrumentation data to the given buffer, given explicit
  * pointers to the live data in memory.  This function is probably not what you
  * want.  Use __llvm_profile_get_size_for_buffer instead.  Use this function if
  * your program has a custom memory layout.
  */
 uint64_t __llvm_profile_get_size_for_buffer_internal(
     const __llvm_profile_data *DataBegin, const __llvm_profile_data *DataEnd,
-    const uint64_t *CountersBegin, const uint64_t *CountersEnd,
-    const char *NamesBegin, const char *NamesEnd);
+    const uint64_t *CountersBegin, const uint64_t *CountersEnd);
 
 /*!
  * \brief Write instrumentation data to the given buffer, given explicit
  * pointers to the live data in memory.  This function is probably not what you
  * want.  Use __llvm_profile_write_buffer instead.  Use this function if your
  * program has a custom memory layout.
  *
  * \pre \c Buffer is the start of a buffer at least as big as \a
  * __llvm_profile_get_size_for_buffer_internal().
  */
-int __llvm_profile_write_buffer_internal(
-    char *Buffer, const __llvm_profile_data *DataBegin,
-    const __llvm_profile_data *DataEnd, const uint64_t *CountersBegin,
-    const uint64_t *CountersEnd, const char *NamesBegin, const char *NamesEnd);
+int __llvm_profile_write_buffer_internal(char *Buffer,
+                                         const __llvm_profile_data *DataBegin,
+                                         const __llvm_profile_data *DataEnd,
+                                         const uint64_t *CountersBegin,
+                                         const uint64_t *CountersEnd);
 
 #endif

lib/profile/InstrProfilingPlatformDarwin.c

 
 #if defined(__APPLE__)
 /* Use linker magic to find the bounds of the Data section. */
 __attribute__((visibility("hidden")))
 extern __llvm_profile_data DataStart __asm("section$start$__DATA$__llvm_prf_data");
 __attribute__((visibility("hidden")))
 extern __llvm_profile_data DataEnd   __asm("section$end$__DATA$__llvm_prf_data");
 __attribute__((visibility("hidden")))
-extern char NamesStart __asm("section$start$__DATA$__llvm_prf_names");
-__attribute__((visibility("hidden")))
-extern char NamesEnd   __asm("section$end$__DATA$__llvm_prf_names");
-__attribute__((visibility("hidden")))
 extern uint64_t CountersStart __asm("section$start$__DATA$__llvm_prf_cnts");
 __attribute__((visibility("hidden")))
 extern uint64_t CountersEnd   __asm("section$end$__DATA$__llvm_prf_cnts");
 
 __attribute__((visibility("hidden")))
 const __llvm_profile_data *__llvm_profile_begin_data(void) {
   return &DataStart;
 }
 __attribute__((visibility("hidden")))
 const __llvm_profile_data *__llvm_profile_end_data(void) {
   return &DataEnd;
 }
 __attribute__((visibility("hidden")))
-const char *__llvm_profile_begin_names(void) { return &NamesStart; }
-__attribute__((visibility("hidden")))
-const char *__llvm_profile_end_names(void) { return &NamesEnd; }
-__attribute__((visibility("hidden")))
 uint64_t *__llvm_profile_begin_counters(void) { return &CountersStart; }
 __attribute__((visibility("hidden")))
 uint64_t *__llvm_profile_end_counters(void) { return &CountersEnd; }
 #endif

lib/profile/InstrProfilingPlatformOther.c

 /*===- InstrProfilingPlatformOther.c - Profile data default platform ------===*\
 |*
 |*                     The LLVM Compiler Infrastructure
 |*
 |* This file is distributed under the University of Illinois Open Source
 |* License. See LICENSE.TXT for details.
 |*
 \*===----------------------------------------------------------------------===*/
 
 #include "InstrProfiling.h"
 
 #if !defined(__APPLE__)
 #include <stdlib.h>
 
 static const __llvm_profile_data *DataFirst = NULL;
 static const __llvm_profile_data *DataLast = NULL;
-static const char *NamesFirst = NULL;
-static const char *NamesLast = NULL;
 static uint64_t *CountersFirst = NULL;
 static uint64_t *CountersLast = NULL;
 
 /*!
  * \brief Register an instrumented function.
  *
  * Calls to this are emitted by clang with -fprofile-instr-generate.  Such
  * calls are only required (and only emitted) on targets where we haven't
  * implemented linker magic to find the bounds of the sections.
  */
 __attribute__((visibility("hidden")))
 void __llvm_profile_register_function(void *Data_) {
   /* TODO: Only emit this function if we can't use linker magic. */
   const __llvm_profile_data *Data = (__llvm_profile_data*)Data_;
   if (!DataFirst) {
     DataFirst = Data;
     DataLast = Data + 1;
-    NamesFirst = Data->Name;
-    NamesLast = Data->Name + Data->NameSize;
     CountersFirst = Data->Counters;
     CountersLast = Data->Counters + Data->NumCounters;
     return;
   }
 
 #define UPDATE_FIRST(First, New) \
   First = New < First ? New : First
   UPDATE_FIRST(DataFirst, Data);
-  UPDATE_FIRST(NamesFirst, Data->Name);
   UPDATE_FIRST(CountersFirst, Data->Counters);
 #undef UPDATE_FIRST
 
 #define UPDATE_LAST(Last, New) \
   Last = New > Last ? New : Last
   UPDATE_LAST(DataLast, Data + 1);
-  UPDATE_LAST(NamesLast, Data->Name + Data->NameSize);
   UPDATE_LAST(CountersLast, Data->Counters + Data->NumCounters);
 #undef UPDATE_LAST
 }
 
 __attribute__((visibility("hidden")))
 const __llvm_profile_data *__llvm_profile_begin_data(void) {
   return DataFirst;
 }
 __attribute__((visibility("hidden")))
 const __llvm_profile_data *__llvm_profile_end_data(void) {
   return DataLast;
 }
 __attribute__((visibility("hidden")))
-const char *__llvm_profile_begin_names(void) { return NamesFirst; }
-__attribute__((visibility("hidden")))
-const char *__llvm_profile_end_names(void) { return NamesLast; }
-__attribute__((visibility("hidden")))
 uint64_t *__llvm_profile_begin_counters(void) { return CountersFirst; }
 __attribute__((visibility("hidden")))
 uint64_t *__llvm_profile_end_counters(void) { return CountersLast; }
 #endif

test/Instrumentation/InstrProfiling/PR23499.ll

 ;; Check that data associated with linkonce odr functions are placed in
 ;; the same comdat section as their associated function.
 
-; RUN: opt < %s -mtriple=x86_64-apple-macosx10.10.0 -instrprof -S | FileCheck %s
-; RUN: opt < %s -mtriple=x86_64-unknown-linux -instrprof -S | FileCheck %s
+; RUN: opt < %s -mtriple=x86_64-apple-macosx10.10.0 -instrprof -S | FileCheck %s -check-prefix=MACHO
+; RUN: opt < %s -mtriple=x86_64-unknown-linux -instrprof -S | FileCheck %s -check-prefix=ELF
 
 $_Z3barIvEvv = comdat any
 
-@__llvm_profile_name__Z3barIvEvv = linkonce_odr hidden constant [11 x i8] c"_Z3barIvEvv", align 1
+@__llvm_prf_nm__Z3barIvEvv = linkonce_odr hidden constant [11 x i8] c"_Z3barIvEvv", align 1
 
-; CHECK: @__llvm_profile_name__Z3barIvEvv = linkonce_odr hidden constant [11 x i8] c"_Z3barIvEvv", section "{{.*}}__llvm_prf_names", comdat($__llvm_profile_vars__Z3barIvEvv), align 1
-; CHECK: @__llvm_profile_counters__Z3barIvEvv = linkonce_odr hidden global [1 x i64] zeroinitializer, section "{{.*}}__llvm_prf_cnts", comdat($__llvm_profile_vars__Z3barIvEvv), align 8
-; CHECK: @__llvm_profile_data__Z3barIvEvv = linkonce_odr hidden constant { i32, i32, i64, i8*, i64* } { i32 11, i32 1, i64 0, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @__llvm_profile_name__Z3barIvEvv, i32 0, i32 0), i64* getelementptr inbounds ([1 x i64], [1 x i64]* @__llvm_profile_counters__Z3barIvEvv, i32 0, i32 0) }, section "{{.*}}__llvm_prf_data", comdat($__llvm_profile_vars__Z3barIvEvv), align 8
+; CHECK: @__llvm_prf_nm__Z3barIvEvv = extern_weak hidden constant [11 x i8] c"_Z3barIvEvv", align 1
+; CHECK: @__llvm_prf_cnts__Z3barIvEvv = linkonce_odr hidden global [1 x i64] zeroinitializer, section "{{.*}}__llvm_prf_cnts", comdat($__llvm_prf_vars__Z3barIvEvv), align 8
+; ELF: @__llvm_prf_data__Z3barIvEvv = linkonce_odr hidden constant { i64, i64, i64*, i32 } { i64 4947693190065689389, i64 0, i64* getelementptr inbounds ([1 x i64], [1 x i64]* @__llvm_prf_cnts__Z3barIvEvv, i32 0, i32 0), i32 1 }, section "__llvm_prf_data", comdat($__llvm_prf_vars__Z3barIvEvv), align 8
+; MACHO: @__llvm_prf_data__Z3barIvEvv = linkonce_odr hidden constant { i64, i64, i64*, i32 } { i64 4947693190065689389, i64 0, i64* getelementptr inbounds ([1 x i64], [1 x i64]* @__llvm_prf_cnts__Z3barIvEvv, i32 0, i32 0), i32 1 }, section "__DATA,__llvm_prf_data", comdat($__llvm_prf_vars__Z3barIvEvv), align 8
 
 declare void @llvm.instrprof.increment(i8*, i64, i32, i32) #1
 
 define linkonce_odr void @_Z3barIvEvv() comdat {
 entry:
-  call void @llvm.instrprof.increment(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @__llvm_profile_name__Z3barIvEvv, i32 0, i32 0), i64 0, i32 1, i32 0)
+  call void @llvm.instrprof.increment(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @__llvm_prf_nm__Z3barIvEvv, i32 0, i32 0), i64 0, i32 1, i32 0)
   ret void
 }

test/Instrumentation/InstrProfiling/linkage.ll

 ;; Check that runtime symbols get appropriate linkage.
 
 ; RUN: opt < %s -mtriple=x86_64-apple-macosx10.10.0 -instrprof -S | FileCheck %s
 ; RUN: opt < %s -mtriple=x86_64-unknown-linux -instrprof -S | FileCheck %s
 
-@__llvm_profile_name_foo = hidden constant [3 x i8] c"foo"
-@__llvm_profile_name_foo_weak = weak hidden constant [8 x i8] c"foo_weak"
-@"__llvm_profile_name_linkage.ll:foo_internal" = internal constant [23 x i8] c"linkage.ll:foo_internal"
-@__llvm_profile_name_foo_inline = linkonce_odr hidden constant [10 x i8] c"foo_inline"
+@__llvm_prf_nm_foo = hidden constant [3 x i8] c"foo"
+@__llvm_prf_nm_foo_weak = weak hidden constant [8 x i8] c"foo_weak"
+@"__llvm_prf_nm_linkage.ll:foo_internal" = internal constant [23 x i8] c"linkage.ll:foo_internal"
+@__llvm_prf_nm_foo_inline = linkonce_odr hidden constant [10 x i8] c"foo_inline"
 
-; CHECK: @__llvm_profile_counters_foo = hidden global
-; CHECK: @__llvm_profile_data_foo = hidden constant
+; CHECK: @__llvm_prf_cnts_foo = hidden global
+; CHECK: @__llvm_prf_data_foo = hidden constant
 define void @foo() {
-  call void @llvm.instrprof.increment(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @__llvm_profile_name_foo, i32 0, i32 0), i64 0, i32 1, i32 0)
+  call void @llvm.instrprof.increment(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @__llvm_prf_nm_foo, i32 0, i32 0), i64 0, i32 1, i32 0)
   ret void
 }
 
-; CHECK: @__llvm_profile_counters_foo_weak = weak hidden global
-; CHECK: @__llvm_profile_data_foo_weak = weak hidden constant
+; CHECK: @__llvm_prf_cnts_foo_weak = weak hidden global
+; CHECK: @__llvm_prf_data_foo_weak = weak hidden constant
 define weak void @foo_weak() {
-  call void @llvm.instrprof.increment(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @__llvm_profile_name_foo_weak, i32 0, i32 0), i64 0, i32 1, i32 0)
+  call void @llvm.instrprof.increment(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @__llvm_prf_nm_foo_weak, i32 0, i32 0), i64 0, i32 1, i32 0)
   ret void
 }
 
-; CHECK: @"__llvm_profile_counters_linkage.ll:foo_internal" = internal global
-; CHECK: @"__llvm_profile_data_linkage.ll:foo_internal" = internal constant
+; CHECK: @"__llvm_prf_cnts_linkage.ll:foo_internal" = internal global
+; CHECK: @"__llvm_prf_data_linkage.ll:foo_internal" = internal constant
 define internal void @foo_internal() {
-  call void @llvm.instrprof.increment(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @"__llvm_profile_name_linkage.ll:foo_internal", i32 0, i32 0), i64 0, i32 1, i32 0)
+  call void @llvm.instrprof.increment(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @"__llvm_prf_nm_linkage.ll:foo_internal", i32 0, i32 0), i64 0, i32 1, i32 0)
   ret void
 }
 
-; CHECK: @__llvm_profile_counters_foo_inline = linkonce_odr hidden global
-; CHECK: @__llvm_profile_data_foo_inline = linkonce_odr hidden constant
+; CHECK: @__llvm_prf_cnts_foo_inline = linkonce_odr hidden global
+; CHECK: @__llvm_prf_data_foo_inline = linkonce_odr hidden constant
 define linkonce_odr void @foo_inline() {
-  call void @llvm.instrprof.increment(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @__llvm_profile_name_foo_inline, i32 0, i32 0), i64 0, i32 1, i32 0)
+  call void @llvm.instrprof.increment(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @__llvm_prf_nm_foo_inline, i32 0, i32 0), i64 0, i32 1, i32 0)
   ret void
 }
 
 declare void @llvm.instrprof.increment(i8*, i64, i32, i32)
 
 ; CHECK: @__llvm_profile_runtime = external global i32
 
 ; CHECK: define linkonce_odr hidden i32 @__llvm_profile_runtime_user() {{.*}} {
 ; CHECK:   %[[REG:.*]] = load i32, i32* @__llvm_profile_runtime
 ; CHECK:   ret i32 %[[REG]]
 ; CHECK: }

test/Instrumentation/InstrProfiling/platform.ll

 ;; Checks for platform specific section names and initialization code.
 
 ; RUN: opt < %s -mtriple=x86_64-apple-macosx10.10.0 -instrprof -S | FileCheck %s -check-prefix=MACHO
 ; RUN: opt < %s -mtriple=x86_64-unknown-linux -instrprof -S | FileCheck %s -check-prefix=ELF
 
-@__llvm_profile_name_foo = hidden constant [3 x i8] c"foo"
-; MACHO: @__llvm_profile_name_foo = hidden constant [3 x i8] c"foo", section "__DATA,__llvm_prf_names", align 1
-; ELF: @__llvm_profile_name_foo = hidden constant [3 x i8] c"foo", section "__llvm_prf_names", align 1
+@__llvm_prf_nm_foo = hidden constant [3 x i8] c"foo"
+; MACHO: @__llvm_prf_nm_foo = extern_weak hidden constant [3 x i8] c"foo"
+; ELF: @__llvm_prf_nm_foo = extern_weak hidden constant [3 x i8] c"foo"
 
-; MACHO: @__llvm_profile_counters_foo = hidden global [1 x i64] zeroinitializer, section "__DATA,__llvm_prf_cnts", align 8
-; ELF: @__llvm_profile_counters_foo = hidden global [1 x i64] zeroinitializer, section "__llvm_prf_cnts", align 8
+; MACHO: @__llvm_prf_cnts_foo = hidden global [1 x i64] zeroinitializer, section "__DATA,__llvm_prf_cnts", align 8
+; ELF: @__llvm_prf_cnts_foo = hidden global [1 x i64] zeroinitializer, section "__llvm_prf_cnts", align 8
 
-; MACHO: @__llvm_profile_data_foo = hidden constant {{.*}}, section "__DATA,__llvm_prf_data", align 8
-; ELF: @__llvm_profile_data_foo = hidden constant {{.*}}, section "__llvm_prf_data", align 8
+; MACHO: @__llvm_prf_data_foo = hidden constant {{.*}}, section "__DATA,__llvm_prf_data", align 8
+; ELF: @__llvm_prf_data_foo = hidden constant {{.*}}, section "__llvm_prf_data", align 8
 define void @foo() {
-  call void @llvm.instrprof.increment(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @__llvm_profile_name_foo, i32 0, i32 0), i64 0, i32 1, i32 0)
+  call void @llvm.instrprof.increment(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @__llvm_prf_nm_foo, i32 0, i32 0), i64 0, i32 1, i32 0)
   ret void
 }
 
 declare void @llvm.instrprof.increment(i8*, i64, i32, i32)
 
 ;; Emit registration functions for platforms that don't find the
 ;; symbols by their sections.
 
 ; MACHO-NOT: define internal void @__llvm_profile_register_functions
 ; ELF: define internal void @__llvm_profile_register_functions
 
 ; MACHO-NOT: define internal void @__llvm_profile_init
 ; ELF: define internal void @__llvm_profile_init

test/Instrumentation/InstrProfiling/profiling.ll

 ; RUN: opt < %s -instrprof -S | FileCheck %s
 
 target triple = "x86_64-apple-macosx10.10.0"
 
-@__llvm_profile_name_foo = hidden constant [3 x i8] c"foo"
-; CHECK: @__llvm_profile_name_foo = hidden constant [3 x i8] c"foo", section "__DATA,__llvm_prf_names", align 1
-@__llvm_profile_name_bar = hidden constant [4 x i8] c"bar\00"
-; CHECK: @__llvm_profile_name_bar = hidden constant [4 x i8] c"bar\00", section "__DATA,__llvm_prf_names", align 1
-@baz_prof_name = hidden constant [3 x i8] c"baz"
-; CHECK: @baz_prof_name = hidden constant [3 x i8] c"baz", section "__DATA,__llvm_prf_names", align 1
+@__llvm_prf_nm_foo = hidden constant [3 x i8] c"foo"
+; CHECK: @__llvm_prf_nm_foo = extern_weak hidden constant [3 x i8] c"foo"
+@__llvm_prf_nm_bar = hidden constant [4 x i8] c"bar\00"
+; CHECK: @__llvm_prf_nm_bar = extern_weak hidden constant [4 x i8] c"bar\00"
+@__llvm_prf_nm_baz = hidden constant [3 x i8] c"baz"
+; CHECK: @__llvm_prf_nm_baz = extern_weak hidden constant [3 x i8] c"baz"
 
-; CHECK: @__llvm_profile_counters_foo = hidden global [1 x i64] zeroinitializer, section "__DATA,__llvm_prf_cnts", align 8
-; CHECK: @__llvm_profile_data_foo = hidden constant {{.*}}, section "__DATA,__llvm_prf_data", align 8
+; CHECK: @__llvm_prf_cnts_foo = hidden global [1 x i64] zeroinitializer, section "__DATA,__llvm_prf_cnts", align 8
+; CHECK: @__llvm_prf_data_foo = hidden constant {{.*}}, section "__DATA,__llvm_prf_data", align 8
 define void @foo() {
-  call void @llvm.instrprof.increment(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @__llvm_profile_name_foo, i32 0, i32 0), i64 0, i32 1, i32 0)
+  call void @llvm.instrprof.increment(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @__llvm_prf_nm_foo, i32 0, i32 0), i64 0, i32 1, i32 0)
   ret void
 }
 
-; CHECK: @__llvm_profile_counters_bar = hidden global [1 x i64] zeroinitializer, section "__DATA,__llvm_prf_cnts", align 8
-; CHECK: @__llvm_profile_data_bar = hidden constant {{.*}}, section "__DATA,__llvm_prf_data", align 8
+; CHECK: @__llvm_prf_cnts_bar = hidden global [1 x i64] zeroinitializer, section "__DATA,__llvm_prf_cnts", align 8
+; CHECK: @__llvm_prf_data_bar = hidden constant {{.*}}, section "__DATA,__llvm_prf_data", align 8
 define void @bar() {
-  call void @llvm.instrprof.increment(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @__llvm_profile_name_bar, i32 0, i32 0), i64 0, i32 1, i32 0)
+  call void @llvm.instrprof.increment(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @__llvm_prf_nm_bar, i32 0, i32 0), i64 0, i32 1, i32 0)
   ret void
 }
 
-; CHECK: @__llvm_profile_counters_baz = hidden global [3 x i64] zeroinitializer, section "__DATA,__llvm_prf_cnts", align 8
-; CHECK: @__llvm_profile_data_baz = hidden constant {{.*}}, section "__DATA,__llvm_prf_data", align 8
+; CHECK: @__llvm_prf_cnts_baz = hidden global [3 x i64] zeroinitializer, section "__DATA,__llvm_prf_cnts", align 8
+; CHECK: @__llvm_prf_data_baz = hidden constant {{.*}}, section "__DATA,__llvm_prf_data", align 8
 define void @baz() {
-  call void @llvm.instrprof.increment(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @baz_prof_name, i32 0, i32 0), i64 0, i32 3, i32 0)
-  call void @llvm.instrprof.increment(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @baz_prof_name, i32 0, i32 0), i64 0, i32 3, i32 1)
-  call void @llvm.instrprof.increment(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @baz_prof_name, i32 0, i32 0), i64 0, i32 3, i32 2)
+  call void @llvm.instrprof.increment(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @__llvm_prf_nm_baz, i32 0, i32 0), i64 0, i32 3, i32 0)
+  call void @llvm.instrprof.increment(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @__llvm_prf_nm_baz, i32 0, i32 0), i64 0, i32 3, i32 1)
+  call void @llvm.instrprof.increment(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @__llvm_prf_nm_baz, i32 0, i32 0), i64 0, i32 3, i32 2)
   ret void
 }
 
 declare void @llvm.instrprof.increment(i8*, i64, i32, i32)
 
 ; CHECK: @__llvm_profile_runtime = external global i32
-; CHECK: @llvm.used = appending global {{.*}} @__llvm_profile_data_foo {{.*}} @__llvm_profile_data_bar {{.*}} @__llvm_profile_data_baz {{.*}} section "llvm.metadata"
+; CHECK: @llvm.used = appending global {{.*}} @__llvm_prf_data_foo {{.*}} @__llvm_prf_data_bar {{.*}} @__llvm_prf_data_baz {{.*}} section "llvm.metadata"

test/tools/llvm-profdata/c-general.test

 REGENERATE: You need a checkout of clang with compiler-rt to generate the
 REGENERATE: binary file here.  These shell commands can be used to regenerate
 REGENERATE: it.
 REGENERATE:
 REGENERATE: $ SRC=path/to/llvm
 REGENERATE: $ CFE=$SRC/tools/clang
 REGENERATE: $ TESTDIR=$SRC/test/tools/llvm-profdata
 REGENERATE: $ CFE_TESTDIR=$CFE/test/Profile
 REGENERATE: $ clang -o a.out -fprofile-instr-generate $CFE_TESTDIR/test/Profile/c-general.c
 REGENERATE: $ LLVM_PROFILE_FILE=$TESTDIR/Inputs/c-general.profraw ./a.out
 
 RUN: llvm-profdata show %p/Inputs/c-general.profraw -o - | FileCheck %s -check-prefix=CHECK
-RUN: llvm-profdata show %p/Inputs/c-general.profraw -o - --function=switches | FileCheck %s -check-prefix=SWITCHES -check-prefix=CHECK
+RUN: llvm-profdata show %p/Inputs/c-general.profraw -o - -instr-binary=%p/Inputs/c-general.bin --function=switches | FileCheck %s -check-prefix=SWITCHES -check-prefix=CHECK
 
 SWITCHES-LABEL: Counters:
 SWITCHES-NEXT:   switches:
-SWITCHES-NEXT:     Hash: 0x0000000000000013
+SWITCHES-NEXT:     Hash: 0x2618e4f23f2e8daa
 SWITCHES-NEXT:     Counters: 19
 SWITCHES-NEXT:     Function count: 1
 SWITCHES-LABEL: Functions shown: 1
 
-CHECK-LABEL: Total functions: 11
+CHECK-LABEL: Total functions: 12
 CHECK-NEXT: Maximum function count: 1
 CHECK-NEXT: Maximum internal block count: 100

test/tools/llvm-profdata/general.proftext

 0
 # HEX-HASH: Hash: 0x0000000000001234
 # HEX-HASH-NEXT: Counters: 1
 
 # RUN: llvm-profdata show %t.profdata --function NOSUCHFUNC | FileCheck %s -check-prefix=NOSUCHFUNC
 # NOSUCHFUNC-NOT: Counters:
 # NOSUCHFUNC: Functions shown: 0
 
-# RUN: llvm-profdata show %t.profdata --function _ | FileCheck %s -check-prefix=SOMEFUNCS
-# SOMEFUNCS: Counters:
-# SOMEFUNCS: function_count_only:
-# SOMEFUNCS: large_numbers:
-# SOMEFUNCS: Functions shown: 3
-
 # RUN: llvm-profdata show %t.profdata | FileCheck %s -check-prefix=SUMMARY
 # SUMMARY-NOT: Counters:
 # SUMMARY-NOT: Functions shown:
 # SUMMARY: Total functions: 4
 # SUMMARY: Maximum function count: 2305843009213693952
 # SUMMARY: Maximum internal block count: 1152921504606846976

test/tools/llvm-profdata/multiple-inputs.test

 Some very basic tests for the multiple input cases.
 
 RUN: llvm-profdata merge %p/Inputs/foo3-1.proftext %p/Inputs/foo3-2.proftext -o %t
 RUN: llvm-profdata show %t -all-functions -counts | FileCheck %s --check-prefix=FOO3
 RUN: llvm-profdata merge %p/Inputs/foo3-2.proftext %p/Inputs/foo3-1.proftext -o %t
 RUN: llvm-profdata show %t -all-functions -counts | FileCheck %s --check-prefix=FOO3
-FOO3: foo:
 FOO3: Counters: 3
 FOO3: Function count: 8
 FOO3: Block counts: [7, 6]
 FOO3: Total functions: 1
 FOO3: Maximum function count: 8
 FOO3: Maximum internal block count: 7
 
 RUN: llvm-profdata merge %p/Inputs/empty.proftext %p/Inputs/foo3-1.proftext -o %t
 RUN: llvm-profdata show %t -all-functions -counts | FileCheck %s --check-prefix=FOO3EMPTY
-FOO3EMPTY: foo:
 FOO3EMPTY: Counters: 3
 FOO3EMPTY: Function count: 1
 FOO3EMPTY: Block counts: [2, 3]
 FOO3EMPTY: Total functions: 1
 FOO3EMPTY: Maximum function count: 1
 FOO3EMPTY: Maximum internal block count: 3
 
 RUN: llvm-profdata merge %p/Inputs/foo3-1.proftext %p/Inputs/foo3bar3-1.proftext -o %t
 RUN: llvm-profdata show %t -all-functions -counts | FileCheck %s --check-prefix=FOO3FOO3BAR3
-FOO3FOO3BAR3: foo:
 FOO3FOO3BAR3: Counters: 3
 FOO3FOO3BAR3: Function count: 3
 FOO3FOO3BAR3: Block counts: [5, 8]
-FOO3FOO3BAR3: bar:
 FOO3FOO3BAR3: Counters: 3
 FOO3FOO3BAR3: Function count: 7
 FOO3FOO3BAR3: Block counts: [11, 13]
 FOO3FOO3BAR3: Total functions: 2
 FOO3FOO3BAR3: Maximum function count: 7
 FOO3FOO3BAR3: Maximum internal block count: 13
 
 RUN: llvm-profdata merge %p/Inputs/foo3-1.proftext %p/Inputs/bar3-1.proftext -o %t
 RUN: llvm-profdata show %t -all-functions -counts | FileCheck %s --check-prefix=DISJOINT
-DISJOINT: foo:
 DISJOINT: Counters: 3
 DISJOINT: Function count: 1
 DISJOINT: Block counts: [2, 3]
-DISJOINT: bar:
 DISJOINT: Counters: 3
 DISJOINT: Function count: 1
 DISJOINT: Block counts: [2, 3]
 DISJOINT: Total functions: 2
 DISJOINT: Maximum function count: 1
 DISJOINT: Maximum internal block count: 3

tools/llvm-profdata/llvm-profdata.cpp

 //===- llvm-profdata.cpp - LLVM profile data tool -------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // llvm-profdata merges .profdata files.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/IR/LLVMContext.h"
+#include "llvm/Object/MachOUniversal.h"
+#include "llvm/Object/ObjectFile.h"
 #include "llvm/ProfileData/InstrProfReader.h"
 #include "llvm/ProfileData/InstrProfWriter.h"
 #include "llvm/ProfileData/SampleProfReader.h"
 #include "llvm/ProfileData/SampleProfWriter.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
+using namespace object;
 
 static void exitWithError(const Twine &Message, StringRef Whence = "") {
   errs() << "error: ";
   if (!Whence.empty())
     errs() << Whence << ": ";
   errs() << Message << "\n";
   ::exit(1);
 }
static int merge_main(int argc, const char *argv[]) {
   if (ProfileKind == instr)
     mergeInstrProfile(Inputs, OutputFilename);
   else
     mergeSampleProfile(Inputs, OutputFilename, OutputFormat);
 
   return 0;
 }
 
-static int showInstrProfile(std::string Filename, bool ShowCounts,
+static void populateSymtab(std::string binFilename, std::string Arch,
+                           std::unique_ptr<ProfSymtab> &ProfSyms) {
+  if (binFilename.empty())
+    return;
+  auto Buf = MemoryBuffer::getFileOrSTDIN(binFilename);
+  if (Buf.getError()) {
+    errs() << "warning: -instr-binary specifies an invalid file\n";
+    return;
+  }
+
+  MemoryBufferRef ObjectBuffer = Buf.get()->getMemBufferRef();
+  auto BinOrErr = object::createBinary(ObjectBuffer);
+  if (BinOrErr.getError()) {
+    errs() << "warning: -instr-binary specifies an invalid object file\n";
+    return;
+  }
+  auto Bin = std::move(BinOrErr.get());
+  std::unique_ptr<ObjectFile> OF;
+  if (auto *Universal = dyn_cast<object::MachOUniversalBinary>(Bin.get())) {
+    // If we have a universal binary, try to look up the object for the
+    // appropriate architecture.
+    auto ObjectFileOrErr = Universal->getObjectForArch(Arch);
+    if (std::error_code EC = ObjectFileOrErr.getError()) {
+      errs() << "warning: -instr-binary specifies an invalid file\n";
+      return;
+    }
+    OF = std::move(ObjectFileOrErr.get());
+  } else if (isa<object::ObjectFile>(Bin.get())) {
+    // For any other object file, upcast and take ownership.
+    OF.reset(cast<object::ObjectFile>(Bin.release()));
+    // If we've asked for a particular arch, make sure they match.
+    if (!Arch.empty() && OF->getArch() != Triple(Arch).getArch()) {
+      errs() << "warning: -instr-binary specifies an invalid file\n";
+      return;
+    }
+  } else {
+    // We can only handle object files.
+    errs() << "warning: -instr-binary specifies an invalid file\n";
+    return;
+  }
+
+  ProfSyms.reset(new ProfSymtab(OF->symbols()));
+}
+
+static int showInstrProfile(std::string Filename, std::string binFilename,
+                            std::string Arch, bool ShowCounts,
                             bool ShowIndirectCallTargets, bool ShowAllFunctions,
                             std::string ShowFunction, raw_fd_ostream &OS) {
   auto ReaderOrErr = InstrProfReader::create(Filename);
   if (std::error_code EC = ReaderOrErr.getError())
     exitWithError(EC.message(), Filename);
 
   auto Reader = std::move(ReaderOrErr.get());
+  std::unique_ptr<ProfSymtab> ProfSyms;
+  populateSymtab(binFilename, Arch, ProfSyms);
   uint64_t MaxFunctionCount = 0, MaxBlockCount = 0;
   size_t ShownFunctions = 0, TotalFunctions = 0;
   for (const auto &Func : *Reader) {
+    StringRef FuncName = Func.Name;
+    if (FuncName.empty() && ProfSyms)
+      ProfSyms->getFunctionName(Func.NameKey, 0, FuncName);
+    uint64_t ShowFunctionKey = 0;
+    if (!ShowFunction.empty())
+      ShowFunctionKey = IndexedInstrProf::ComputeHash(
+          IndexedInstrProf::HashType, ShowFunction);
     bool Show =
-        ShowAllFunctions || (!ShowFunction.empty() &&
-                             Func.Name.find(ShowFunction) != Func.Name.npos);
+        ShowAllFunctions ||
+        (!ShowFunction.empty() &&
+         ((!FuncName.empty() && FuncName.find(ShowFunction) != FuncName.npos) ||
+          ShowFunctionKey == Func.NameKey));
 
     ++TotalFunctions;
     assert(Func.Counts.size() > 0 && "function missing entry counter");
     if (Func.Counts[0] > MaxFunctionCount)
       MaxFunctionCount = Func.Counts[0];
 
     if (Show) {
       if (!ShownFunctions)
         OS << "Counters:\n";
       ++ShownFunctions;
-
-      OS << "  " << Func.Name << ":\n"
-         << "    Hash: " << format("0x%016" PRIx64, Func.Hash) << "\n"
+      if (FuncName.empty())
+        OS << "  " << format("%" PRIx64, Func.NameKey) << ":\n";
+      else
+        OS << "  " << FuncName << ":\n";
+      OS << "    Hash: " << format("0x%016" PRIx64, Func.Hash) << "\n"
          << "    Counters: " << Func.Counts.size() << "\n"
          << "    Function count: " << Func.Counts[0] << "\n";
       if (ShowIndirectCallTargets)
         OS << "    Indirect Call Site Count: " << Func.IndirectCallSites.size()
            << "\n";
     }
 
     if (Show && ShowCounts)
static int show_main(int argc, const char *argv[]) {
   cl::opt<bool> ShowIndirectCallTargets(
       "ic-targets", cl::init(false),
       cl::desc("Show indirect call site target values for shown functions"));
   cl::opt<bool> ShowAllFunctions("all-functions", cl::init(false),
                                  cl::desc("Details for every function"));
   cl::opt<std::string> ShowFunction("function",
                                     cl::desc("Details for matching functions"));
 
+  cl::opt<std::string> BinFilename(
+      "instr-binary",
+      cl::desc("Path of unstripped binary with instrumentation"));
+  cl::opt<std::string> Arch("arch",
+                            cl::desc("architecture of the profiled binary"));
+
   cl::opt<std::string> OutputFilename("output", cl::value_desc("output"),
                                       cl::init("-"), cl::desc("Output file"));
   cl::alias OutputFilenameA("o", cl::desc("Alias for --output"),
                             cl::aliasopt(OutputFilename));
   cl::opt<ProfileKinds> ProfileKind(
       cl::desc("Profile kind:"), cl::init(instr),
       cl::values(clEnumVal(instr, "Instrumentation profile (default)"),
                  clEnumVal(sample, "Sample profile"), clEnumValEnd));
 
   cl::ParseCommandLineOptions(argc, argv, "LLVM profile data summary\n");
 
   if (OutputFilename.empty())
     OutputFilename = "-";
 
   std::error_code EC;
   raw_fd_ostream OS(OutputFilename.data(), EC, sys::fs::F_Text);
   if (EC)
     exitWithError(EC.message(), OutputFilename);
 
   if (ShowAllFunctions && !ShowFunction.empty())
     errs() << "warning: -function argument ignored: showing all functions\n";
 
   if (ProfileKind == instr)
-    return showInstrProfile(Filename, ShowCounts, ShowIndirectCallTargets,
-                            ShowAllFunctions, ShowFunction, OS);
+    return showInstrProfile(Filename, BinFilename, Arch, ShowCounts,
+                            ShowIndirectCallTargets, ShowAllFunctions,
+                            ShowFunction, OS);
   else
     return showSampleProfile(Filename, ShowCounts, ShowAllFunctions,
                              ShowFunction, OS);
 }
 
 int main(int argc, const char *argv[]) {
   // Print a stack trace if we signal out.
   sys::PrintStackTraceOnErrorSignal();

unittests/ProfileData/InstrProfTest.cpp

 TEST_F(InstrProfTest, write_and_read_one_function) {
   InstrProfRecord Record("foo", 0x1234, {1, 2, 3, 4});
   Writer.addRecord(std::move(Record));
   auto Profile = Writer.writeBuffer();
   readProfile(std::move(Profile));
 
   auto I = Reader->begin(), E = Reader->end();
   ASSERT_TRUE(I != E);
-  ASSERT_EQ(StringRef("foo"), I->Name);
+  ASSERT_EQ(IndexedInstrProf::ComputeHash(IndexedInstrProf::HashType,
+                                          StringRef("foo")),
+            I->NameKey);
   ASSERT_EQ(0x1234U, I->Hash);
   ASSERT_EQ(4U, I->Counts.size());
   ASSERT_EQ(1U, I->Counts[0]);
   ASSERT_EQ(2U, I->Counts[1]);
   ASSERT_EQ(3U, I->Counts[2]);
   ASSERT_EQ(4U, I->Counts[3]);
   ASSERT_TRUE(++I == E);
 }