[llvm-profdata] Deprecate Compact Binary Sample Profile Format

[huangjd]

Summary

Remove support for compact binary sample profile format

[wenlei]

lgtm, thanks for the cleanup.

[wlei]

llvm/unittests/ProfileData/SampleProfTest.cpp

291–292

Nit: remove the Compact

[davidxl]

llvm/include/llvm/ProfileData/SampleProf.h

93

Keep the symbolic value with deprecation comment.

llvm/tools/llvm-profdata/llvm-profdata.cpp

57

The enum should be kept and synced with the definition in SampleProf.h. Just add a deprecation comment.

411–412

For PF_Compact_Binary format, produce a different error message.

[huangjd]

• Added back deprecated enum with comment

[davidxl]

lgtm (perhaps keep one of the compact format file and use it as test case for error message)

[manojgupta]

We have been using compbinary format in ChromeOS. Now it fails with the the following error:

llvm-profdata merge: Did you mean '--binary'?

Can you please suggest the fix? The current usages are:

1. https://source.chromium.org/chromium/chromiumos/overlays/chromiumos-overlay/+/main:eclass/cros-kernel2.eclass;l=2397
2. https://source.chromium.org/chromium/chromiumos/chromite/+/main:lib/toolchain_util.py;l=1038

The reason for using compbinary is that it uses lower memory.

# Compressed binary profiles are lazily loaded, so they save a
		# meaningful amount of CPU and memory per clang invocation.

[davidxl]

In D149400#4316855, @manojgupta wrote:

We have been using compbinary format in ChromeOS. Now it fails with the the following error:

llvm-profdata merge: Did you mean '--binary'?

Can you please suggest the fix? The current usages are:

1. https://source.chromium.org/chromium/chromiumos/overlays/chromiumos-overlay/+/main:eclass/cros-kernel2.eclass;l=2397
2. https://source.chromium.org/chromium/chromiumos/chromite/+/main:lib/toolchain_util.py;l=1038

The reason for using compbinary is that it uses lower memory.

# Compressed binary profiles are lazily loaded, so they save a
		# meaningful amount of CPU and memory per clang invocation.

I suggest switching to extended binary format for now. williamjhuang@'s follow up improvement patches will greatly improve memory and CPU usage for extbinary format (should be better than compact format).

[manojgupta]

Ideally, the changes to llvm-profdata and use inside clang should have been separate and delayed. Now, we have a case where the older profiles are erroring out when building with ToT clang.

Builders are full or errors like:

Could not open profile: Unrecognized sample profile encoding format

1 error generated.

So, now we are in a scramble to somehow create new profiles :(.

llvm/include/llvm/ProfileData/SampleProf.h

 } // end namespace std
 
 namespace llvm {
 namespace sampleprof {
 
 enum SampleProfileFormat {
   SPF_None = 0,
   SPF_Text = 0x1,
-  SPF_Compact_Binary = 0x2,
+  SPF_Compact_Binary = 0x2, // Deprecated
   SPF_GCC = 0x3,
   SPF_Ext_Binary = 0x4,
   SPF_Binary = 0xff
 };
 
 enum SampleProfileLayout {
   SPL_None = 0,
   SPL_Nest = 0x1,

llvm/include/llvm/ProfileData/SampleProfReader.h

public:
   SampleProfileReaderExtBinary(std::unique_ptr<MemoryBuffer> B, LLVMContext &C,
                                SampleProfileFormat Format = SPF_Ext_Binary)
       : SampleProfileReaderExtBinaryBase(std::move(B), C, Format) {}
 
   /// \brief Return true if \p Buffer is in the format supported by this class.
   static bool hasFormat(const MemoryBuffer &Buffer);
 };
 
-class SampleProfileReaderCompactBinary : public SampleProfileReaderBinary {
-private:
-  /// Function name table.
-  std::vector<std::string> NameTable;
-  /// The table mapping from function name to the offset of its FunctionSample
-  /// towards file start.
-  DenseMap<StringRef, uint64_t> FuncOffsetTable;
-  /// The set containing the functions to use when compiling a module.
-  DenseSet<StringRef> FuncsToUse;
-  std::error_code verifySPMagic(uint64_t Magic) override;
-  std::error_code readNameTable() override;
-  /// Read a string indirectly via the name table.
-  ErrorOr<StringRef> readStringFromTable() override;
-  std::error_code readHeader() override;
-  std::error_code readFuncOffsetTable();
-
-public:
-  SampleProfileReaderCompactBinary(std::unique_ptr<MemoryBuffer> B,
-                                   LLVMContext &C)
-      : SampleProfileReaderBinary(std::move(B), C, SPF_Compact_Binary) {}
-
-  /// \brief Return true if \p Buffer is in the format supported by this class.
-  static bool hasFormat(const MemoryBuffer &Buffer);
-
-  /// Read samples only for functions to use.
-  std::error_code readImpl() override;
-
-  /// Collect functions with definitions in Module M. Return true if
-  /// the reader has been given a module.
-  bool collectFuncsFromModule() override;
-
-  /// Return whether names in the profile are all MD5 numbers.
-  bool useMD5() override { return true; }
-};
-
 using InlineCallStack = SmallVector<FunctionSamples *, 10>;
 
 // Supported histogram types in GCC.  Currently, we only need support for
 // call target histograms.
 enum HistType {
   HIST_TYPE_INTERVAL,
   HIST_TYPE_POW2,
   HIST_TYPE_SINGLE_VALUE,

llvm/include/llvm/ProfileData/SampleProfWriter.h

private:
   };
 
   void verifySecLayout(SectionLayout SL) override {
     assert((SL == DefaultLayout || SL == CtxSplitLayout) &&
            "Unsupported layout");
   }
 };
 
-// CompactBinary is a compact format of binary profile which both reduces
-// the profile size and the load time needed when compiling. It has two
-// major difference with Binary format.
-// 1. It represents all the strings in name table using md5 hash.
-// 2. It saves a function offset table which maps function name index to
-// the offset of its function profile to the start of the binary profile,
-// so by using the function offset table, for those function profiles which
-// will not be needed when compiling a module, the profile reader does't
-// have to read them and it saves compile time if the profile size is huge.
-// The layout of the compact format is shown as follows:
-//
-//    Part1: Profile header, the same as binary format, containing magic
-//           number, version, summary, name table...
-//    Part2: Function Offset Table Offset, which saves the position of
-//           Part4.
-//    Part3: Function profile collection
-//             function1 profile start
-//                 ....
-//             function2 profile start
-//                 ....
-//             function3 profile start
-//                 ....
-//                ......
-//    Part4: Function Offset Table
-//             function1 name index --> function1 profile start
-//             function2 name index --> function2 profile start
-//             function3 name index --> function3 profile start
-//
-// We need Part2 because profile reader can use it to find out and read
-// function offset table without reading Part3 first.
-class SampleProfileWriterCompactBinary : public SampleProfileWriterBinary {
-  using SampleProfileWriterBinary::SampleProfileWriterBinary;
-
-public:
-  std::error_code writeSample(const FunctionSamples &S) override;
-  std::error_code write(const SampleProfileMap &ProfileMap) override;
-
-protected:
-  /// The table mapping from function name to the offset of its FunctionSample
-  /// towards profile start.
-  MapVector<StringRef, uint64_t> FuncOffsetTable;
-  /// The offset of the slot to be filled with the offset of FuncOffsetTable
-  /// towards profile start.
-  uint64_t TableOffset;
-  std::error_code writeNameTable() override;
-  std::error_code writeHeader(const SampleProfileMap &ProfileMap) override;
-  std::error_code writeFuncOffsetTable();
-};
-
 } // end namespace sampleprof
 } // end namespace llvm
 
 #endif // LLVM_PROFILEDATA_SAMPLEPROFWRITER_H

llvm/lib/ProfileData/SampleProfReader.cpp

 #include <vector>
 
 using namespace llvm;
 using namespace sampleprof;
 
 #define DEBUG_TYPE "samplepgo-reader"
 
 // This internal option specifies if the profile uses FS discriminators.
-// It only applies to text, binary and compact binary format profiles.
+// It only applies to text, and binary format profiles.
 // For ext-binary format profiles, the flag is set in the summary.
 static cl::opt<bool> ProfileIsFSDisciminator(
     "profile-isfs", cl::Hidden, cl::init(false),
     cl::desc("Profile uses flow sensitive discriminators"));
 
 /// Dump the function profile for \p FName.
 ///
 /// \param FContext Name + context of the function to print.
if (SR.empty()) {
     // in MD5StringBuf.
     MD5StringBuf->push_back(std::to_string(*FID));
     SR = MD5StringBuf->back();
     Data = SavedData;
   }
   return SR;
 }
 
-ErrorOr<StringRef> SampleProfileReaderCompactBinary::readStringFromTable() {
-  auto Idx = readStringIndex(NameTable);
-  if (std::error_code EC = Idx.getError())
-    return EC;
-
-  return StringRef(NameTable[*Idx]);
-}
-
 std::error_code
 SampleProfileReaderBinary::readProfile(FunctionSamples &FProfile) {
   auto NumSamples = readNumber<uint64_t>();
   if (std::error_code EC = NumSamples.getError())
     return EC;
   FProfile.addTotalSamples(*NumSamples);
 
   // Read the samples in the body.
if (isCompressed) {
       Data = BufStart + Entry.Offset;
       End = BufStart + Buffer->getBufferSize();
     }
   }
 
   return sampleprof_error::success;
 }
 
-std::error_code SampleProfileReaderCompactBinary::readImpl() {
-  // Collect functions used by current module if the Reader has been
-  // given a module.
-  bool LoadFuncsToBeUsed = collectFuncsFromModule();
-  ProfileIsFS = ProfileIsFSDisciminator;
-  FunctionSamples::ProfileIsFS = ProfileIsFS;
-  std::vector<uint64_t> OffsetsToUse;
-  if (!LoadFuncsToBeUsed) {
-    // load all the function profiles.
-    for (auto FuncEntry : FuncOffsetTable) {
-      OffsetsToUse.push_back(FuncEntry.second);
-    }
-  } else {
-    // load function profiles on demand.
-    for (auto Name : FuncsToUse) {
-      auto GUID = std::to_string(MD5Hash(Name));
-      auto iter = FuncOffsetTable.find(StringRef(GUID));
-      if (iter == FuncOffsetTable.end())
-        continue;
-      OffsetsToUse.push_back(iter->second);
-    }
-  }
-
-  for (auto Offset : OffsetsToUse) {
-    const uint8_t *SavedData = Data;
-    if (std::error_code EC = readFuncProfile(
-            reinterpret_cast<const uint8_t *>(Buffer->getBufferStart()) +
-            Offset))
-      return EC;
-    Data = SavedData;
-  }
-  return sampleprof_error::success;
-}
-
 std::error_code SampleProfileReaderRawBinary::verifySPMagic(uint64_t Magic) {
   if (Magic == SPMagic())
     return sampleprof_error::success;
   return sampleprof_error::bad_magic;
 }
 
 std::error_code SampleProfileReaderExtBinary::verifySPMagic(uint64_t Magic) {
   if (Magic == SPMagic(SPF_Ext_Binary))
     return sampleprof_error::success;
   return sampleprof_error::bad_magic;
 }
 
-std::error_code
-SampleProfileReaderCompactBinary::verifySPMagic(uint64_t Magic) {
-  if (Magic == SPMagic(SPF_Compact_Binary))
-    return sampleprof_error::success;
-  return sampleprof_error::bad_magic;
-}
-
 std::error_code SampleProfileReaderBinary::readNameTable() {
   auto Size = readNumber<size_t>();
   if (std::error_code EC = Size.getError())
     return EC;
   NameTable.reserve(*Size + NameTable.size());
   for (size_t I = 0; I < *Size; ++I) {
     auto Name(readString());
     if (std::error_code EC = Name.getError())
while (Data < End) {
     if (std::error_code EC = readFuncMetadata(ProfileHasAttribute, FProfile))
       return EC;
   }
 
   assert(Data == End && "More data is read than expected");
   return sampleprof_error::success;
 }
 
-std::error_code SampleProfileReaderCompactBinary::readNameTable() {
-  auto Size = readNumber<uint64_t>();
-  if (std::error_code EC = Size.getError())
-    return EC;
-  NameTable.reserve(*Size);
-  for (uint64_t I = 0; I < *Size; ++I) {
-    auto FID = readNumber<uint64_t>();
-    if (std::error_code EC = FID.getError())
-      return EC;
-    NameTable.push_back(std::to_string(*FID));
-  }
-  return sampleprof_error::success;
-}
-
 std::error_code
 SampleProfileReaderExtBinaryBase::readSecHdrTableEntry(uint64_t Idx) {
   SecHdrTableEntry Entry;
   auto Type = readUnencodedNumber<uint64_t>();
   if (std::error_code EC = Type.getError())
     return EC;
   Entry.Type = static_cast<SecType>(*Type);
 
std::error_code SampleProfileReaderBinary::readHeader() {
   if (std::error_code EC = readSummary())
     return EC;
 
   if (std::error_code EC = readNameTable())
     return EC;
   return sampleprof_error::success;
 }
 
-std::error_code SampleProfileReaderCompactBinary::readHeader() {
-  SampleProfileReaderBinary::readHeader();
-  if (std::error_code EC = readFuncOffsetTable())
-    return EC;
-  return sampleprof_error::success;
-}
-
-std::error_code SampleProfileReaderCompactBinary::readFuncOffsetTable() {
-  auto TableOffset = readUnencodedNumber<uint64_t>();
-  if (std::error_code EC = TableOffset.getError())
-    return EC;
-
-  const uint8_t *SavedData = Data;
-  const uint8_t *TableStart =
-      reinterpret_cast<const uint8_t *>(Buffer->getBufferStart()) +
-      *TableOffset;
-  Data = TableStart;
-
-  auto Size = readNumber<uint64_t>();
-  if (std::error_code EC = Size.getError())
-    return EC;
-
-  FuncOffsetTable.reserve(*Size);
-  for (uint64_t I = 0; I < *Size; ++I) {
-    auto FName(readStringFromTable());
-    if (std::error_code EC = FName.getError())
-      return EC;
-
-    auto Offset = readNumber<uint64_t>();
-    if (std::error_code EC = Offset.getError())
-      return EC;
-
-    FuncOffsetTable[*FName] = *Offset;
-  }
-  End = TableStart;
-  Data = SavedData;
-  return sampleprof_error::success;
-}
-
-bool SampleProfileReaderCompactBinary::collectFuncsFromModule() {
-  if (!M)
-    return false;
-  FuncsToUse.clear();
-  for (auto &F : *M)
-    FuncsToUse.insert(FunctionSamples::getCanonicalFnName(F));
-  return true;
-}
-
 std::error_code SampleProfileReaderBinary::readSummaryEntry(
     std::vector<ProfileSummaryEntry> &Entries) {
   auto Cutoff = readNumber<uint64_t>();
   if (std::error_code EC = Cutoff.getError())
     return EC;
 
   auto MinBlockCount = readNumber<uint64_t>();
   if (std::error_code EC = MinBlockCount.getError())

 
 bool SampleProfileReaderExtBinary::hasFormat(const MemoryBuffer &Buffer) {
   const uint8_t *Data =
       reinterpret_cast<const uint8_t *>(Buffer.getBufferStart());
   uint64_t Magic = decodeULEB128(Data);
   return Magic == SPMagic(SPF_Ext_Binary);
 }
 
-bool SampleProfileReaderCompactBinary::hasFormat(const MemoryBuffer &Buffer) {
-  const uint8_t *Data =
-      reinterpret_cast<const uint8_t *>(Buffer.getBufferStart());
-  uint64_t Magic = decodeULEB128(Data);
-  return Magic == SPMagic(SPF_Compact_Binary);
-}
-
 std::error_code SampleProfileReaderGCC::skipNextWord() {
   uint32_t dummy;
   if (!GcovBuffer.readInt(dummy))
     return sampleprof_error::truncated;
   return sampleprof_error::success;
 }
 
 template <typename T> ErrorOr<T> SampleProfileReaderGCC::readNumber() {

 
 void SampleProfileReaderItaniumRemapper::applyRemapping(LLVMContext &Ctx) {
   // If the reader uses MD5 to represent string, we can't remap it because
   // we don't know what the original function names were.
   if (Reader.useMD5()) {
     Ctx.diagnose(DiagnosticInfoSampleProfile(
         Reader.getBuffer()->getBufferIdentifier(),
         "Profile data remapping cannot be applied to profile data "
-        "in compact format (original mangled names are not available).",
+        "using MD5 names (original mangled names are not available).",
         DS_Warning));
     return;
   }
 
   // CSSPGO-TODO: Remapper is not yet supported.
   // We will need to remap the entire context string.
   assert(Remappings && "should be initialized while creating remapper");
   for (auto &Sample : Reader.getProfiles()) {

 SampleProfileReader::create(std::unique_ptr<MemoryBuffer> &B, LLVMContext &C,
                             vfs::FileSystem &FS, FSDiscriminatorPass P,
                             const std::string RemapFilename) {
   std::unique_ptr<SampleProfileReader> Reader;
   if (SampleProfileReaderRawBinary::hasFormat(*B))
     Reader.reset(new SampleProfileReaderRawBinary(std::move(B), C));
   else if (SampleProfileReaderExtBinary::hasFormat(*B))
     Reader.reset(new SampleProfileReaderExtBinary(std::move(B), C));
-  else if (SampleProfileReaderCompactBinary::hasFormat(*B))
-    Reader.reset(new SampleProfileReaderCompactBinary(std::move(B), C));
   else if (SampleProfileReaderGCC::hasFormat(*B))
     Reader.reset(new SampleProfileReaderGCC(std::move(B), C));
   else if (SampleProfileReaderText::hasFormat(*B))
     Reader.reset(new SampleProfileReaderText(std::move(B), C));
   else
     return sampleprof_error::unrecognized_format;
 
   if (!RemapFilename.empty()) {

llvm/lib/ProfileData/SampleProfWriter.cpp

if (SecLayout == DefaultLayout)
     EC = writeDefaultLayout(ProfileMap);
   else if (SecLayout == CtxSplitLayout)
     EC = writeCtxSplitLayout(ProfileMap);
   else
     llvm_unreachable("Unsupported layout");
   return EC;
 }
 
-std::error_code
-SampleProfileWriterCompactBinary::write(const SampleProfileMap &ProfileMap) {
-  if (std::error_code EC = SampleProfileWriter::write(ProfileMap))
-    return EC;
-  if (std::error_code EC = writeFuncOffsetTable())
-    return EC;
-  return sampleprof_error::success;
-}
-
 /// Write samples to a text file.
 ///
 /// Note: it may be tempting to implement this in terms of
 /// FunctionSamples::print().  Please don't.  The dump functionality is intended
 /// for debugging and has no specified form.
 ///
 /// The format used here is more structured and deliberate because
 /// it needs to be parsed by the SampleProfileReaderText class.
std::error_code SampleProfileWriterBinary::writeNameTable() {
   encodeULEB128(NameTable.size(), OS);
   for (auto N : V) {
     OS << N;
     encodeULEB128(0, OS);
   }
   return sampleprof_error::success;
 }
 
-std::error_code SampleProfileWriterCompactBinary::writeFuncOffsetTable() {
-  auto &OS = *OutputStream;
-
-  // Fill the slot remembered by TableOffset with the offset of FuncOffsetTable.
-  uint64_t FuncOffsetTableStart = OS.tell();
-  support::endian::SeekableWriter Writer(static_cast<raw_pwrite_stream &>(OS),
-                                         support::little);
-  Writer.pwrite(FuncOffsetTableStart, TableOffset);
-
-  // Write out the table size.
-  encodeULEB128(FuncOffsetTable.size(), OS);
-
-  // Write out FuncOffsetTable.
-  for (auto Entry : FuncOffsetTable) {
-    if (std::error_code EC = writeNameIdx(Entry.first))
-      return EC;
-    encodeULEB128(Entry.second, OS);
-  }
-  FuncOffsetTable.clear();
-  return sampleprof_error::success;
-}
-
-std::error_code SampleProfileWriterCompactBinary::writeNameTable() {
-  auto &OS = *OutputStream;
-  std::set<StringRef> V;
-  stablizeNameTable(NameTable, V);
-
-  // Write out the name table.
-  encodeULEB128(NameTable.size(), OS);
-  for (auto N : V) {
-    encodeULEB128(MD5Hash(N), OS);
-  }
-  return sampleprof_error::success;
-}
-
 std::error_code
 SampleProfileWriterBinary::writeMagicIdent(SampleProfileFormat Format) {
   auto &OS = *OutputStream;
   // Write file magic identifier.
   encodeULEB128(SPMagic(Format), OS);
   encodeULEB128(SPVersion(), OS);
   return sampleprof_error::success;
 }
std::error_code SampleProfileWriterExtBinaryBase::writeHeader(
   auto &OS = *OutputStream;
   FileStart = OS.tell();
   writeMagicIdent(Format);
 
   allocSecHdrTable();
   return sampleprof_error::success;
 }
 
-std::error_code SampleProfileWriterCompactBinary::writeHeader(
-    const SampleProfileMap &ProfileMap) {
-  support::endian::Writer Writer(*OutputStream, support::little);
-  if (auto EC = SampleProfileWriterBinary::writeHeader(ProfileMap))
-    return EC;
-
-  // Reserve a slot for the offset of function offset table. The slot will
-  // be populated with the offset of FuncOffsetTable later.
-  TableOffset = OutputStream->tell();
-  Writer.write(static_cast<uint64_t>(-2));
-  return sampleprof_error::success;
-}
-
 std::error_code SampleProfileWriterBinary::writeSummary() {
   auto &OS = *OutputStream;
   encodeULEB128(Summary->getTotalCount(), OS);
   encodeULEB128(Summary->getMaxCount(), OS);
   encodeULEB128(Summary->getMaxFunctionCount(), OS);
   encodeULEB128(Summary->getNumCounts(), OS);
   encodeULEB128(Summary->getNumFunctions(), OS);
   const std::vector<ProfileSummaryEntry> &Entries =

 ///
 /// \returns true if the samples were written successfully, false otherwise.
 std::error_code
 SampleProfileWriterBinary::writeSample(const FunctionSamples &S) {
   encodeULEB128(S.getHeadSamples(), *OutputStream);
   return writeBody(S);
 }
 
-std::error_code
-SampleProfileWriterCompactBinary::writeSample(const FunctionSamples &S) {
-  uint64_t Offset = OutputStream->tell();
-  StringRef Name = S.getName();
-  FuncOffsetTable[Name] = Offset;
-  encodeULEB128(S.getHeadSamples(), *OutputStream);
-  return writeBody(S);
-}
-
 /// Create a sample profile file writer based on the specified format.
 ///
 /// \param Filename The file to create.
 ///
 /// \param Format Encoding format for the profile file.
 ///
 /// \returns an error code indicating the status of the created writer.
 ErrorOr<std::unique_ptr<SampleProfileWriter>>
 SampleProfileWriter::create(StringRef Filename, SampleProfileFormat Format) {
   std::error_code EC;
   std::unique_ptr<raw_ostream> OS;
-  if (Format == SPF_Binary || Format == SPF_Ext_Binary ||
-      Format == SPF_Compact_Binary)
+  if (Format == SPF_Binary || Format == SPF_Ext_Binary)
     OS.reset(new raw_fd_ostream(Filename, EC, sys::fs::OF_None));
   else
     OS.reset(new raw_fd_ostream(Filename, EC, sys::fs::OF_TextWithCRLF));
   if (EC)
     return EC;
 
   return create(OS, Format);
 }
 
 /// Create a sample profile stream writer based on the specified format.
 ///
 /// \param OS The output stream to store the profile data to.
 ///
 /// \param Format Encoding format for the profile file.
 ///
 /// \returns an error code indicating the status of the created writer.
 ErrorOr<std::unique_ptr<SampleProfileWriter>>
 SampleProfileWriter::create(std::unique_ptr<raw_ostream> &OS,
                             SampleProfileFormat Format) {
   std::error_code EC;
   std::unique_ptr<SampleProfileWriter> Writer;
 
   // Currently only Text and Extended Binary format are supported for CSSPGO.
   if ((FunctionSamples::ProfileIsCS || FunctionSamples::ProfileIsProbeBased) &&
-      (Format == SPF_Binary || Format == SPF_Compact_Binary))
+      Format == SPF_Binary)
     return sampleprof_error::unsupported_writing_format;
 
   if (Format == SPF_Binary)
     Writer.reset(new SampleProfileWriterRawBinary(OS));
   else if (Format == SPF_Ext_Binary)
     Writer.reset(new SampleProfileWriterExtBinary(OS));
-  else if (Format == SPF_Compact_Binary)
-    Writer.reset(new SampleProfileWriterCompactBinary(OS));
   else if (Format == SPF_Text)
     Writer.reset(new SampleProfileWriterText(OS));
   else if (Format == SPF_GCC)
     EC = sampleprof_error::unsupported_writing_format;
   else
     EC = sampleprof_error::unrecognized_format;
 
   if (EC)

llvm/test/Transforms/SampleProfile/indirect-call.ll

 ; RUN: opt -S %s -passes=sample-profile -sample-profile-file=%S/Inputs/indirect-call.prof | FileCheck %s
-; RUN: opt -S %s -passes=sample-profile -sample-profile-file=%S/Inputs/indirect-call.compact.afdo | FileCheck %s
+; RUN: opt -S %s -passes=sample-profile -sample-profile-file=%S/Inputs/indirect-call.extbinary.afdo | FileCheck %s
 
 ; CHECK-LABEL: @test
 define void @test(ptr) #0 !dbg !3 {
   %2 = alloca ptr
   store ptr %0, ptr %2
   %3 = load ptr, ptr %2
   ; CHECK: call {{.*}}, !prof ![[PROF:[0-9]+]]
   call void %3(), !dbg !4

llvm/test/Transforms/SampleProfile/profile-format.ll

 ; RUN: opt < %s -passes=sample-profile -sample-profile-file=%S/Inputs/inline.prof -S | FileCheck %s
-; RUN: opt < %s -passes=sample-profile -sample-profile-file=%S/Inputs/inline.compactbinary.afdo -S | FileCheck %s
 ; RUN: opt < %s -passes=sample-profile -sample-profile-file=%S/Inputs/inline.extbinary.afdo -S | FileCheck %s
 ; RUN: opt < %s -passes=sample-profile -sample-profile-file=%S/Inputs/inline.md5extbinary.afdo -S | FileCheck %s
 ; RUN: opt < %s -passes=sample-profile -sample-profile-file=%S/Inputs/inline.fixlenmd5.extbinary.afdo -S | FileCheck %s
 ; RUN: not opt < %s -passes=sample-profile -sample-profile-file=%S/Inputs/bad.extbinary.afdo -S 2>&1 | FileCheck %s -check-prefix=BAD-PROFILE
 
 ; Original C++ test case
 ;
 ; #include <stdio.h>

llvm/test/tools/llvm-profdata/compact-sample.proftext

-# Make sure "llvm-profdata show" works for sample profile in binary compact format
-
-# RUN: llvm-profdata show -sample %S/Inputs/compat-sample.profdata | FileCheck %s
-
-# CHECK: Function: 15822663052811949562: 17, 0, 6 sampled lines
-# CHECK-NEXT: Samples collected in the function's body {
-# CHECK: Samples collected in inlined callsites {
-# CHECK-NEXT: 1: inlined callee: 6309742469962978389: 17, 0, 1
-
-# RUN: llvm-profdata show -hot-func-list -sample %S/Inputs/compat-sample.profdata | FileCheck %s --check-prefix=HOTFUNC
-# HOTFUNC:      24753993 out of 24754010 profile counts (100.00%) are from hot functions.
-# HOTFUNC:       Total sample (%)       Max sample        Entry sample    Function name
-# HOTFUNC-NEXT:  24753993 (100.00%)     1284671           1284671         16429767378996342100
-
-# Make sure "llvm-profdata overlap" works for sample profile in binary compact format
-# RUN: llvm-profdata overlap -sample %S/Inputs/compat-sample.profdata %S/Inputs/compat-sample.profdata | FileCheck %s --check-prefix=OVERLAP
-
-# OVERLAP:      Program level:
-# OVERLAP-NEXT:   Whole program profile similarity: 100.000%
-# OVERLAP-NEXT:   Whole program sample overlap: 100.000%

llvm/test/tools/llvm-profdata/roundtrip.test

 RUN: llvm-profdata merge --sample --extbinary -output=%t.3.profdata %S/Inputs/sample-profile.proftext
 RUN: llvm-profdata merge --sample --text -output=%t.3.proftext %t.3.profdata
 RUN: diff -b %t.3.proftext %S/Inputs/sample-profile.proftext
 # Round trip from text --> binary --> extbinary --> text
 RUN: llvm-profdata merge --sample --binary -output=%t.4.profdata %S/Inputs/sample-profile.proftext
 RUN: llvm-profdata merge --sample --extbinary -output=%t.5.profdata %t.4.profdata
 RUN: llvm-profdata merge --sample --text -output=%t.4.proftext %t.5.profdata
 RUN: diff -b %t.4.proftext %S/Inputs/sample-profile.proftext
-# Trip from text --> extbinary --> md5text
-# Trip from text --> compbinary --> md5text
-# Compare the two md5 texts
-RUN: llvm-profdata merge --sample --compbinary -output=%t.6.profdata %S/Inputs/sample-profile.proftext
-RUN: llvm-profdata merge --sample --text -output=%t.6.proftext %t.6.profdata
-RUN: llvm-profdata merge --sample --extbinary -use-md5 -output=%t.7.profdata %S/Inputs/sample-profile.proftext
-RUN: llvm-profdata merge --sample --text -output=%t.7.proftext %t.7.profdata
-RUN: diff -b %t.6.proftext %t.7.proftext

llvm/tools/llvm-profdata/llvm-profdata.cpp

 
 // We use this string to indicate that there are
 // multiple static functions map to the same name.
 const std::string DuplicateNameStr = "----";
 
 enum ProfileFormat {
   PF_None = 0,
   PF_Text,
-  PF_Compact_Binary,
+  PF_Compact_Binary, // Deprecated
   PF_Ext_Binary,
   PF_GCC,
   PF_Binary
 };
 
 enum class ShowFormat { Text, Json, Yaml };
 
 static void warn(Twine Message, std::string Whence = "",
                  std::string Hint = "") {

 }
 
 static void
 mergeInstrProfile(const WeightedFileVector &Inputs, StringRef DebugInfoFilename,
                   SymbolRemapper *Remapper, StringRef OutputFilename,
                   ProfileFormat OutputFormat, uint64_t TraceReservoirSize,
                   uint64_t MaxTraceLength, bool OutputSparse,
                   unsigned NumThreads, FailureMode FailMode,
                   const StringRef ProfiledBinary) {
-  if (OutputFormat != PF_Binary && OutputFormat != PF_Compact_Binary &&
-      OutputFormat != PF_Ext_Binary && OutputFormat != PF_Text)
+  if (OutputFormat == PF_Compact_Binary)
+    exitWithError("Compact Binary is deprecated");
+  if (OutputFormat != PF_Binary && OutputFormat != PF_Ext_Binary &&
+      OutputFormat != PF_Text)
     exitWithError("unknown format is specified");
 
   std::unique_ptr<InstrProfCorrelator> Correlator;
   if (!DebugInfoFilename.empty()) {
     if (auto Err =
             InstrProfCorrelator::get(DebugInfoFilename).moveInto(Correlator))
       exitWithError(std::move(Err), DebugInfoFilename);
     if (auto Err = Correlator->correlateProfileData())
for (const auto &CallsiteSamples : Samples.getCallsiteSamples()) {
     }
   }
   return Result;
 }
 
 static sampleprof::SampleProfileFormat FormatMap[] = {
     sampleprof::SPF_None,
     sampleprof::SPF_Text,
-    sampleprof::SPF_Compact_Binary,
+    sampleprof::SPF_None,
     sampleprof::SPF_Ext_Binary,
     sampleprof::SPF_GCC,
     sampleprof::SPF_Binary};
 
 static std::unique_ptr<MemoryBuffer>
 getInputFileBuf(const StringRef &InputFile) {
   if (InputFile == "")
     return {};
static int merge_main(int argc, const char *argv[]) {
   cl::opt<ProfileKinds> ProfileKind(
       cl::desc("Profile kind:"), cl::init(instr),
       cl::values(clEnumVal(instr, "Instrumentation profile (default)"),
                  clEnumVal(sample, "Sample profile")));
   cl::opt<ProfileFormat> OutputFormat(
       cl::desc("Format of output profile"), cl::init(PF_Binary),
       cl::values(
           clEnumValN(PF_Binary, "binary", "Binary encoding (default)"),
-          clEnumValN(PF_Compact_Binary, "compbinary",
-                     "Compact binary encoding"),
           clEnumValN(PF_Ext_Binary, "extbinary", "Extensible binary encoding"),
           clEnumValN(PF_Text, "text", "Text encoding"),
           clEnumValN(PF_GCC, "gcc",
                      "GCC encoding (only meaningful for -sample)")));
   cl::opt<FailureMode> FailureMode(
       "failure-mode", cl::init(failIfAnyAreInvalid), cl::desc("Failure mode:"),
       cl::values(clEnumValN(failIfAnyAreInvalid, "any",
                             "Fail if any profile is invalid."),

llvm/tools/llvm-profgen/ProfileGenerator.cpp

cl::opt<std::string> OutputFilename("output", cl::value_desc("output"),
                                     cl::desc("Output profile file"));
 static cl::alias OutputA("o", cl::desc("Alias for --output"),
                          cl::aliasopt(OutputFilename));
 
 static cl::opt<SampleProfileFormat> OutputFormat(
     "format", cl::desc("Format of output profile"), cl::init(SPF_Ext_Binary),
     cl::values(
         clEnumValN(SPF_Binary, "binary", "Binary encoding (default)"),
-        clEnumValN(SPF_Compact_Binary, "compbinary", "Compact binary encoding"),
         clEnumValN(SPF_Ext_Binary, "extbinary", "Extensible binary encoding"),
         clEnumValN(SPF_Text, "text", "Text encoding"),
         clEnumValN(SPF_GCC, "gcc",
                    "GCC encoding (only meaningful for -sample)")));
 
 static cl::opt<bool> UseMD5(
     "use-md5", cl::Hidden,
     cl::desc("Use md5 to represent function names in the output profile (only "

llvm/unittests/ProfileData/SampleProfTest.cpp

if (!UseMD5) {
       ASSERT_EQ("_Z3bari", ReadBarSamples->getName());
     }
     ASSERT_EQ(20301u, ReadBarSamples->getTotalSamples());
     ASSERT_EQ(1437u, ReadBarSamples->getHeadSamples());
     ErrorOr<SampleRecord::CallTargetMap> CTMap =
         ReadBarSamples->findCallTargetMapAt(1, 0);
     ASSERT_FALSE(CTMap.getError());
 
     // Because _Z3bazi is not defined in module M, expect _Z3bazi's profile
-    // is not loaded when the profile is ExtBinary or Compact format because
-    // these formats support loading function profiles on demand.
+    // is not loaded when the profile is ExtBinary format because this format
+    // supports loading function profiles on demand.
     FunctionSamples *ReadBazSamples = Reader->getSamplesFor(BazName);
-    if (Format == SampleProfileFormat::SPF_Ext_Binary ||
-        Format == SampleProfileFormat::SPF_Compact_Binary) {
+    if (Format == SampleProfileFormat::SPF_Ext_Binary) {
       ASSERT_TRUE(ReadBazSamples == nullptr);
       ASSERT_EQ(3u, Reader->getProfiles().size());
     } else {
       ASSERT_TRUE(ReadBazSamples != nullptr);
       ASSERT_EQ(12557u, ReadBazSamples->getTotalSamples());
       ASSERT_EQ(4u, Reader->getProfiles().size());
     }
 

 TEST_F(SampleProfTest, roundtrip_text_profile) {
   testRoundTrip(SampleProfileFormat::SPF_Text, false, false);
 }
 
 TEST_F(SampleProfTest, roundtrip_raw_binary_profile) {
   testRoundTrip(SampleProfileFormat::SPF_Binary, false, false);
 }
 
-TEST_F(SampleProfTest, roundtrip_compact_binary_profile) {
-  testRoundTrip(SampleProfileFormat::SPF_Compact_Binary, false, true);
-}
-
 TEST_F(SampleProfTest, roundtrip_ext_binary_profile) {
   testRoundTrip(SampleProfileFormat::SPF_Ext_Binary, false, false);
 }
 
 TEST_F(SampleProfTest, roundtrip_md5_ext_binary_profile) {
   testRoundTrip(SampleProfileFormat::SPF_Ext_Binary, false, true);
 }
 
TEST_F(SampleProfTest, default_suffix_elision_text) {
   // profile.
   StringMap<uint64_t> Expected;
   Expected["foo"] = uint64_t(20301);
   Expected["foo.bar"] = uint64_t(-1);
   Expected["foo.llvm.2465"] = uint64_t(-1);
   testSuffixElisionPolicy(SampleProfileFormat::SPF_Text, "", Expected);
 }
 
-TEST_F(SampleProfTest, default_suffix_elision_compact_binary) {
-  // Default suffix elision policy: strip everything after first dot.
-  // This implies that all suffix variants will map to "foo", so
-  // we don't expect to see any entries for them in the sample
-  // profile.
-  StringMap<uint64_t> Expected;
-  Expected["foo"] = uint64_t(20301);
-  Expected["foo.bar"] = uint64_t(-1);
-  Expected["foo.llvm.2465"] = uint64_t(-1);
-  testSuffixElisionPolicy(SampleProfileFormat::SPF_Compact_Binary, "",
-                          Expected);
-}
-
 TEST_F(SampleProfTest, selected_suffix_elision_text) {
   // Profile is created and searched using the "selected"
   // suffix elision policy: we only strip a .XXX suffix if
   // it matches a pattern known to be generated by the compiler
   // (e.g. ".llvm.<digits>").
   StringMap<uint64_t> Expected;
   Expected["foo"] = uint64_t(20301);
   Expected["foo.bar"] = uint64_t(20303);
   Expected["foo.llvm.2465"] = uint64_t(-1);
   testSuffixElisionPolicy(SampleProfileFormat::SPF_Text, "selected", Expected);
 }
 
-TEST_F(SampleProfTest, selected_suffix_elision_compact_binary) {
-  // Profile is created and searched using the "selected"
-  // suffix elision policy: we only strip a .XXX suffix if
-  // it matches a pattern known to be generated by the compiler
-  // (e.g. ".llvm.<digits>").
-  StringMap<uint64_t> Expected;
-  Expected["foo"] = uint64_t(20301);
-  Expected["foo.bar"] = uint64_t(20303);
-  Expected["foo.llvm.2465"] = uint64_t(-1);
-  testSuffixElisionPolicy(SampleProfileFormat::SPF_Compact_Binary, "selected",
-                          Expected);
-}
-
 TEST_F(SampleProfTest, none_suffix_elision_text) {
   // Profile is created and searched using the "none"
   // suffix elision policy: no stripping of suffixes at all.
   // Here we expect to see all variants in the profile.
   StringMap<uint64_t> Expected;
   Expected["foo"] = uint64_t(20301);
   Expected["foo.bar"] = uint64_t(20303);
   Expected["foo.llvm.2465"] = uint64_t(20305);
   testSuffixElisionPolicy(SampleProfileFormat::SPF_Text, "none", Expected);
 }
 
-TEST_F(SampleProfTest, none_suffix_elision_compact_binary) {
-  // Profile is created and searched using the "none"
-  // suffix elision policy: no stripping of suffixes at all.
-  // Here we expect to see all variants in the profile.
-  StringMap<uint64_t> Expected;
-  Expected["foo"] = uint64_t(20301);
-  Expected["foo.bar"] = uint64_t(20303);
-  Expected["foo.llvm.2465"] = uint64_t(20305);
-  testSuffixElisionPolicy(SampleProfileFormat::SPF_Compact_Binary, "none",
-                          Expected);
-}
-
 } // end anonymous namespace

llvm/unittests/tools/llvm-profdata/OutputSizeLimitTest.cpp

if (!isEmpty) {
     NewProfiles = NewReader->getProfiles();
   }
 
   // Check temp file is actually within size limit.
   uint64_t FileSize;
   RETURN_IF_ERROR(sys::fs::file_size(Temp.path(), FileSize));
   EXPECT_LE(FileSize, SizeLimit);
 
-  // For compact binary format, function names are stored as MD5, so we cannot
-  // directly match the samples of the new profile with the old profile. A
-  // simple way is to convert the old profile to compact binary format and read
-  // it back
-  if (Format == llvm::sampleprof::SPF_Compact_Binary) {
-    TempFile CompBinary("compbinary", "afdo", "", true);
-    {
-      DEF_VAR_RETURN_IF_ERROR(
-          Writer, SampleProfileWriter::create(
-                      CompBinary.path(), llvm::sampleprof::SPF_Compact_Binary));
-      RETURN_IF_ERROR(Writer->write(OldProfiles));
-    }
-    VAR_RETURN_IF_ERROR(Reader, SampleProfileReader::create(
-                                    CompBinary.path().str(), Context, *FS));
-    RETURN_IF_ERROR(Reader->read());
-    OldProfiles = Reader->getProfiles();
-  }
-
   // For every sample in the new profile, confirm it is in the old profile and
   // unchanged.
   for (auto Sample : NewProfiles) {
     auto FindResult = OldProfiles.find(Sample.first);
     EXPECT_NE(FindResult, OldProfiles.end());
     if (FindResult != OldProfiles.end()) {
       EXPECT_EQ(Sample.second.getHeadSamples(),
                 FindResult->second.getHeadSamples());

 
 TEST(TestOutputSizeLimit, TestOutputSizeLimitBinary) {
   for (size_t OutputSizeLimit : {250, 249, 248, 237, 236, 223, 200})
     ASSERT_THAT_EXPECTED(
         RunTest(Input1, OutputSizeLimit, llvm::sampleprof::SPF_Binary),
         Succeeded());
 }
 
-TEST(TestOutputSizeLimit, TestOutputSizeLimitCompBinary) {
-  for (size_t OutputSizeLimit : {277, 276, 275, 264, 263, 250, 200})
-    ASSERT_THAT_EXPECTED(
-        RunTest(Input1, OutputSizeLimit, llvm::sampleprof::SPF_Compact_Binary),
-        Succeeded());
-}
-
 TEST(TestOutputSizeLimit, TestOutputSizeLimitText) {
   for (size_t OutputSizeLimit :
        {229, 228, 227, 213, 212, 211, 189, 188, 187, 186, 150})
     ASSERT_THAT_EXPECTED(
         RunTest(Input1, OutputSizeLimit, llvm::sampleprof::SPF_Text),
         Succeeded());
 }