Revert "[Remarks] Add an LLVM-bitstream-based remark serializer"

This reverts commit r367364.

Breaks some bots: http://lab.llvm.org:8011/builders/sanitizer-x86_64-linux-gn/builds/3161/steps/annotate/logs/stdio

llvm-svn: 367370

7 files changed, 4 insertions, 403 deletions

diff --git a/llvm/lib/Remarks/BitstreamRemarkSerializer.cpp b/llvm/lib/Remarks/BitstreamRemarkSerializer.cpp
deleted file mode 100644
index 26bf85439a5..00000000000
--- a/llvm/lib/Remarks/BitstreamRemarkSerializer.cpp
+++ /dev/null
@@ -1,383 +0,0 @@
-//===- BitstreamRemarkSerializer.cpp --------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file provides the implementation of the LLVM bitstream remark serializer
-// using LLVM's bitstream writer.
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/Remarks/BitstreamRemarkSerializer.h"
-
-using namespace llvm;
-using namespace llvm::remarks;
-
-BitstreamSerializerHelper::BitstreamSerializerHelper(
-    BitstreamRemarkContainerType ContainerType)
-    : Encoded(), R(), Bitstream(Encoded), ContainerType(ContainerType) {}
-
-static void push(SmallVectorImpl<uint64_t> &R, StringRef Str) {
-  for (const char C : Str)
-    R.push_back(C);
-}
-
-static void setRecordName(unsigned RecordID, BitstreamWriter &Bitstream,
-                          SmallVectorImpl<uint64_t> &R, StringRef Str) {
-  R.clear();
-  R.push_back(RecordID);
-  push(R, Str);
-  Bitstream.EmitRecord(bitc::BLOCKINFO_CODE_SETRECORDNAME, R);
-}
-
-static void initBlock(unsigned BlockID, BitstreamWriter &Bitstream,
-                      SmallVectorImpl<uint64_t> &R, StringRef Str) {
-  R.clear();
-  R.push_back(BlockID);
-  Bitstream.EmitRecord(bitc::BLOCKINFO_CODE_SETBID, R);
-
-  R.clear();
-  push(R, Str);
-  Bitstream.EmitRecord(bitc::BLOCKINFO_CODE_BLOCKNAME, R);
-}
-
-void BitstreamSerializerHelper::setupMetaBlockInfo() {
-  // Setup the metadata block.
-  initBlock(META_BLOCK_ID, Bitstream, R, MetaBlockName);
-
-  // The container information.
-  setRecordName(RECORD_META_CONTAINER_INFO, Bitstream, R,
-                MetaContainerInfoName);
-
-  auto Abbrev = std::make_shared<BitCodeAbbrev>();
-  Abbrev->Add(BitCodeAbbrevOp(RECORD_META_CONTAINER_INFO));
-  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Version.
-  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2));  // Type.
-  RecordMetaContainerInfoAbbrevID =
-      Bitstream.EmitBlockInfoAbbrev(META_BLOCK_ID, Abbrev);
-}
-
-void BitstreamSerializerHelper::setupMetaRemarkVersion() {
-  setRecordName(RECORD_META_REMARK_VERSION, Bitstream, R,
-                MetaRemarkVersionName);
-
-  auto Abbrev = std::make_shared<BitCodeAbbrev>();
-  Abbrev->Add(BitCodeAbbrevOp(RECORD_META_REMARK_VERSION));
-  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Version.
-  RecordMetaRemarkVersionAbbrevID =
-      Bitstream.EmitBlockInfoAbbrev(META_BLOCK_ID, Abbrev);
-}
-
-void BitstreamSerializerHelper::emitMetaRemarkVersion(uint64_t RemarkVersion) {
-  // The remark version is emitted only if we emit remarks.
-  R.clear();
-  R.push_back(RECORD_META_REMARK_VERSION);
-  R.push_back(RemarkVersion);
-  Bitstream.EmitRecordWithAbbrev(RecordMetaRemarkVersionAbbrevID, R);
-}
-
-void BitstreamSerializerHelper::setupMetaStrTab() {
-  setRecordName(RECORD_META_STRTAB, Bitstream, R, MetaStrTabName);
-
-  auto Abbrev = std::make_shared<BitCodeAbbrev>();
-  Abbrev->Add(BitCodeAbbrevOp(RECORD_META_STRTAB));
-  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Raw table.
-  RecordMetaStrTabAbbrevID =
-      Bitstream.EmitBlockInfoAbbrev(META_BLOCK_ID, Abbrev);
-}
-
-void BitstreamSerializerHelper::emitMetaStrTab(const StringTable &StrTab) {
-  // The string table is not emitted if we emit remarks separately.
-  R.clear();
-  R.push_back(RECORD_META_STRTAB);
-
-  // Serialize to a blob.
-  std::string Buf;
-  raw_string_ostream OS(Buf);
-  StrTab.serialize(OS);
-  StringRef Blob = OS.str();
-  Bitstream.EmitRecordWithBlob(RecordMetaStrTabAbbrevID, R, Blob);
-}
-
-void BitstreamSerializerHelper::setupMetaExternalFile() {
-  setRecordName(RECORD_META_EXTERNAL_FILE, Bitstream, R, MetaExternalFileName);
-
-  auto Abbrev = std::make_shared<BitCodeAbbrev>();
-  Abbrev->Add(BitCodeAbbrevOp(RECORD_META_EXTERNAL_FILE));
-  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Filename.
-  RecordMetaExternalFileAbbrevID =
-      Bitstream.EmitBlockInfoAbbrev(META_BLOCK_ID, Abbrev);
-}
-
-void BitstreamSerializerHelper::emitMetaExternalFile(StringRef Filename) {
-  // The external file is emitted only if we emit the separate metadata.
-  R.clear();
-  R.push_back(RECORD_META_EXTERNAL_FILE);
-  Bitstream.EmitRecordWithBlob(RecordMetaExternalFileAbbrevID, R, Filename);
-}
-
-void BitstreamSerializerHelper::setupRemarkBlockInfo() {
-  // Setup the remark block.
-  initBlock(REMARK_BLOCK_ID, Bitstream, R, RemarkBlockName);
-
-  // The header of a remark.
-  {
-    setRecordName(RECORD_REMARK_HEADER, Bitstream, R, RemarkHeaderName);
-
-    auto Abbrev = std::make_shared<BitCodeAbbrev>();
-    Abbrev->Add(BitCodeAbbrevOp(RECORD_REMARK_HEADER));
-    Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // Type
-    Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // Remark Name
-    Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // Pass name
-    Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // Function name
-    RecordRemarkHeaderAbbrevID =
-        Bitstream.EmitBlockInfoAbbrev(REMARK_BLOCK_ID, Abbrev);
-  }
-
-  // The location of a remark.
-  {
-    setRecordName(RECORD_REMARK_DEBUG_LOC, Bitstream, R, RemarkDebugLocName);
-
-    auto Abbrev = std::make_shared<BitCodeAbbrev>();
-    Abbrev->Add(BitCodeAbbrevOp(RECORD_REMARK_DEBUG_LOC));
-    Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 7));    // File
-    Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Line
-    Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Column
-    RecordRemarkDebugLocAbbrevID =
-        Bitstream.EmitBlockInfoAbbrev(REMARK_BLOCK_ID, Abbrev);
-  }
-
-  // The hotness of a remark.
-  {
-    setRecordName(RECORD_REMARK_HOTNESS, Bitstream, R, RemarkHotnessName);
-
-    auto Abbrev = std::make_shared<BitCodeAbbrev>();
-    Abbrev->Add(BitCodeAbbrevOp(RECORD_REMARK_HOTNESS));
-    Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Hotness
-    RecordRemarkHotnessAbbrevID =
-        Bitstream.EmitBlockInfoAbbrev(REMARK_BLOCK_ID, Abbrev);
-  }
-
-  // An argument entry with a debug location attached.
-  {
-    setRecordName(RECORD_REMARK_ARG_WITH_DEBUGLOC, Bitstream, R,
-                  RemarkArgWithDebugLocName);
-
-    auto Abbrev = std::make_shared<BitCodeAbbrev>();
-    Abbrev->Add(BitCodeAbbrevOp(RECORD_REMARK_ARG_WITH_DEBUGLOC));
-    Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 7));    // Key
-    Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 7));    // Value
-    Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 7));    // File
-    Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Line
-    Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Column
-    RecordRemarkArgWithDebugLocAbbrevID =
-        Bitstream.EmitBlockInfoAbbrev(REMARK_BLOCK_ID, Abbrev);
-  }
-
-  // An argument entry with no debug location attached.
-  {
-    setRecordName(RECORD_REMARK_ARG_WITHOUT_DEBUGLOC, Bitstream, R,
-                  RemarkArgWithoutDebugLocName);
-
-    auto Abbrev = std::make_shared<BitCodeAbbrev>();
-    Abbrev->Add(BitCodeAbbrevOp(RECORD_REMARK_ARG_WITHOUT_DEBUGLOC));
-    Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 7)); // Key
-    Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 7)); // Value
-    RecordRemarkArgWithoutDebugLocAbbrevID =
-        Bitstream.EmitBlockInfoAbbrev(REMARK_BLOCK_ID, Abbrev);
-  }
-}
-
-void BitstreamSerializerHelper::setupBlockInfo() {
-  // Emit magic number.
-  for (const char C : ContainerMagic)
-    Bitstream.Emit(static_cast<unsigned>(C), 8);
-
-  Bitstream.EnterBlockInfoBlock();
-
-  // Setup the main metadata. Depending on the container type, we'll setup the
-  // required records next.
-  setupMetaBlockInfo();
-
-  switch (ContainerType) {
-  case BitstreamRemarkContainerType::SeparateRemarksMeta:
-    // Needs a string table that the separate remark file is using.
-    setupMetaStrTab();
-    // Needs to know where the external remarks file is.
-    setupMetaExternalFile();
-    break;
-  case BitstreamRemarkContainerType::SeparateRemarksFile:
-    // Contains remarks: emit the version.
-    setupMetaRemarkVersion();
-    // Contains remarks: emit the remark abbrevs.
-    setupRemarkBlockInfo();
-    break;
-  case BitstreamRemarkContainerType::Standalone:
-    // Contains remarks: emit the version.
-    setupMetaRemarkVersion();
-    // Needs a string table.
-    setupMetaStrTab();
-    // Contains remarks: emit the remark abbrevs.
-    setupRemarkBlockInfo();
-    break;
-  }
-
-  Bitstream.ExitBlock();
-}
-
-void BitstreamSerializerHelper::emitMetaBlock(
-    uint64_t ContainerVersion, Optional<uint64_t> RemarkVersion,
-    Optional<const StringTable *> StrTab, Optional<StringRef> Filename) {
-  // Emit the meta block
-  Bitstream.EnterSubblock(META_BLOCK_ID, 3);
-
-  // The container version and type.
-  R.clear();
-  R.push_back(RECORD_META_CONTAINER_INFO);
-  R.push_back(ContainerVersion);
-  R.push_back(static_cast<uint64_t>(ContainerType));
-  Bitstream.EmitRecordWithAbbrev(RecordMetaContainerInfoAbbrevID, R);
-
-  switch (ContainerType) {
-  case BitstreamRemarkContainerType::SeparateRemarksMeta:
-    assert(StrTab != None && *StrTab != nullptr);
-    emitMetaStrTab(**StrTab);
-    assert(Filename != None);
-    emitMetaExternalFile(*Filename);
-    break;
-  case BitstreamRemarkContainerType::SeparateRemarksFile:
-    assert(RemarkVersion != None);
-    emitMetaRemarkVersion(*RemarkVersion);
-    break;
-  case BitstreamRemarkContainerType::Standalone:
-    assert(RemarkVersion != None);
-    emitMetaRemarkVersion(*RemarkVersion);
-    assert(StrTab != None && *StrTab != nullptr);
-    emitMetaStrTab(**StrTab);
-    break;
-  }
-
-  Bitstream.ExitBlock();
-}
-
-void BitstreamSerializerHelper::emitRemarkBlock(const Remark &Remark,
-                                                StringTable &StrTab) {
-  Bitstream.EnterSubblock(REMARK_BLOCK_ID, 4);
-
-  R.clear();
-  R.push_back(RECORD_REMARK_HEADER);
-  R.push_back(static_cast<uint64_t>(Remark.RemarkType));
-  R.push_back(StrTab.add(Remark.RemarkName).first);
-  R.push_back(StrTab.add(Remark.PassName).first);
-  R.push_back(StrTab.add(Remark.FunctionName).first);
-  Bitstream.EmitRecordWithAbbrev(RecordRemarkHeaderAbbrevID, R);
-
-  if (const Optional<RemarkLocation> &Loc = Remark.Loc) {
-    R.clear();
-    R.push_back(RECORD_REMARK_DEBUG_LOC);
-    R.push_back(StrTab.add(Loc->SourceFilePath).first);
-    R.push_back(Loc->SourceLine);
-    R.push_back(Loc->SourceColumn);
-    Bitstream.EmitRecordWithAbbrev(RecordRemarkDebugLocAbbrevID, R);
-  }
-
-  if (Optional<uint64_t> Hotness = Remark.Hotness) {
-    R.clear();
-    R.push_back(RECORD_REMARK_HOTNESS);
-    R.push_back(*Hotness);
-    Bitstream.EmitRecordWithAbbrev(RecordRemarkHotnessAbbrevID, R);
-  }
-
-  for (const Argument &Arg : Remark.Args) {
-    R.clear();
-    unsigned Key = StrTab.add(Arg.Key).first;
-    unsigned Val = StrTab.add(Arg.Val).first;
-    bool HasDebugLoc = Arg.Loc != None;
-    R.push_back(HasDebugLoc ? RECORD_REMARK_ARG_WITH_DEBUGLOC
-                            : RECORD_REMARK_ARG_WITHOUT_DEBUGLOC);
-    R.push_back(Key);
-    R.push_back(Val);
-    if (HasDebugLoc) {
-      R.push_back(StrTab.add(Arg.Loc->SourceFilePath).first);
-      R.push_back(Arg.Loc->SourceLine);
-      R.push_back(Arg.Loc->SourceColumn);
-    }
-    Bitstream.EmitRecordWithAbbrev(HasDebugLoc
-                                       ? RecordRemarkArgWithDebugLocAbbrevID
-                                       : RecordRemarkArgWithoutDebugLocAbbrevID,
-                                   R);
-  }
-  Bitstream.ExitBlock();
-}
-
-void BitstreamSerializerHelper::flushToStream(raw_ostream &OS) {
-  OS.write(Encoded.data(), Encoded.size());
-  Encoded.clear();
-}
-
-StringRef BitstreamSerializerHelper::getBuffer() {
-  return StringRef(Encoded.data(), Encoded.size());
-}
-
-BitstreamSerializer::BitstreamSerializer(raw_ostream &OS, SerializerMode Mode)
-    : RemarkSerializer(OS, Mode),
-      Helper(BitstreamRemarkContainerType::SeparateRemarksFile) {
-  assert(Mode == SerializerMode::Separate &&
-         "For SerializerMode::Standalone, a pre-filled string table needs to "
-         "be provided.");
-  // We always use a string table with bitstream.
-  StrTab.emplace();
-}
-
-BitstreamSerializer::BitstreamSerializer(raw_ostream &OS, SerializerMode Mode,
-                                         StringTable StrTabIn)
-    : RemarkSerializer(OS, Mode),
-      Helper(Mode == SerializerMode::Separate
-                 ? BitstreamRemarkContainerType::SeparateRemarksFile
-                 : BitstreamRemarkContainerType::Standalone) {
-  StrTab = std::move(StrTabIn);
-}
-
-void BitstreamSerializer::emit(const Remark &Remark) {
-  if (!DidSetUp) {
-    // Emit the metadata that is embedded in the remark file.
-    // If we're in standalone mode, serialize the string table as well.
-    bool IsStandalone =
-        Helper.ContainerType == BitstreamRemarkContainerType::Standalone;
-    BitstreamMetaSerializer MetaSerializer(
-        OS, Helper,
-        IsStandalone ? &*StrTab : Optional<const StringTable *>(None));
-    MetaSerializer.emit();
-    DidSetUp = true;
-  }
-
-  assert(DidSetUp &&
-         "The Block info block and the meta block were not emitted yet.");
-  Helper.emitRemarkBlock(Remark, *StrTab);
-
-  Helper.flushToStream(OS);
-}
-
-std::unique_ptr<MetaSerializer>
-BitstreamSerializer::metaSerializer(raw_ostream &OS,
-                                    Optional<StringRef> ExternalFilename) {
-  assert(Helper.ContainerType !=
-         BitstreamRemarkContainerType::SeparateRemarksMeta);
-  bool IsStandalone =
-      Helper.ContainerType == BitstreamRemarkContainerType::Standalone;
-  return llvm::make_unique<BitstreamMetaSerializer>(
-      OS,
-      IsStandalone ? BitstreamRemarkContainerType::Standalone
-                   : BitstreamRemarkContainerType::SeparateRemarksMeta,
-      &*StrTab, ExternalFilename);
-}
-
-void BitstreamMetaSerializer::emit() {
-  Helper->setupBlockInfo();
-  Helper->emitMetaBlock(CurrentContainerVersion, CurrentRemarkVersion, StrTab,
-                       ExternalFilename);
-  Helper->flushToStream(OS);
-}
diff --git a/llvm/lib/Remarks/CMakeLists.txt b/llvm/lib/Remarks/CMakeLists.txt
index 85eed7b21f9..fff7367f1f7 100644
--- a/llvm/lib/Remarks/CMakeLists.txt
+++ b/llvm/lib/Remarks/CMakeLists.txt
@@ -1,5 +1,4 @@
 add_llvm_library(LLVMRemarks
-  BitstreamRemarkSerializer.cpp
   Remark.cpp
   RemarkFormat.cpp
   RemarkParser.cpp
diff --git a/llvm/lib/Remarks/RemarkFormat.cpp b/llvm/lib/Remarks/RemarkFormat.cpp
index f2d0331ec6a..8dcf3e19345 100644
--- a/llvm/lib/Remarks/RemarkFormat.cpp
+++ b/llvm/lib/Remarks/RemarkFormat.cpp
@@ -19,8 +19,7 @@ using namespace llvm::remarks;
 Expected<Format> llvm::remarks::parseFormat(StringRef FormatStr) {
   auto Result = StringSwitch<Format>(FormatStr)
                     .Cases("", "yaml", Format::YAML)
-                    .Case("yaml-strtab", Format::YAMLStrTab)
-                    .Case("bitstream", Format::Bitstream)
+                    .Cases("", "yaml-strtab", Format::YAMLStrTab)
                     .Default(Format::Unknown);
 
   if (Result == Format::Unknown)
diff --git a/llvm/lib/Remarks/RemarkParser.cpp b/llvm/lib/Remarks/RemarkParser.cpp
index 5cfca96fd9d..fba1dcf7913 100644
--- a/llvm/lib/Remarks/RemarkParser.cpp
+++ b/llvm/lib/Remarks/RemarkParser.cpp
@@ -56,9 +56,6 @@ llvm::remarks::createRemarkParser(Format ParserFormat, StringRef Buf) {
     return createStringError(
         std::make_error_code(std::errc::invalid_argument),
         "The YAML with string table format requires a parsed string table.");
-  case Format::Bitstream:
-    return createStringError(std::make_error_code(std::errc::invalid_argument),
-                             "Parsing bitstream remarks is not supported.");
   case Format::Unknown:
     return createStringError(std::make_error_code(std::errc::invalid_argument),
                              "Unknown remark parser format.");
@@ -76,9 +73,6 @@ llvm::remarks::createRemarkParser(Format ParserFormat, StringRef Buf,
                              "table. Use yaml-strtab instead.");
   case Format::YAMLStrTab:
     return llvm::make_unique<YAMLStrTabRemarkParser>(Buf, std::move(StrTab));
-  case Format::Bitstream:
-    return createStringError(std::make_error_code(std::errc::invalid_argument),
-                             "Parsing bitstream remarks is not supported.");
   case Format::Unknown:
     return createStringError(std::make_error_code(std::errc::invalid_argument),
                              "Unknown remark parser format.");
@@ -95,9 +89,6 @@ llvm::remarks::createRemarkParserFromMeta(Format ParserFormat, StringRef Buf,
   case Format::YAML:
   case Format::YAMLStrTab:
     return createYAMLParserFromMeta(Buf, std::move(StrTab));
-  case Format::Bitstream:
-    return createStringError(std::make_error_code(std::errc::invalid_argument),
-                             "Parsing bitstream remarks is not supported.");
   case Format::Unknown:
     return createStringError(std::make_error_code(std::errc::invalid_argument),
                              "Unknown remark parser format.");
diff --git a/llvm/lib/Remarks/RemarkSerializer.cpp b/llvm/lib/Remarks/RemarkSerializer.cpp
index db97e821014..73cec4fbf9b 100644
--- a/llvm/lib/Remarks/RemarkSerializer.cpp
+++ b/llvm/lib/Remarks/RemarkSerializer.cpp
@@ -11,7 +11,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Remarks/RemarkSerializer.h"
-#include "llvm/Remarks/BitstreamRemarkSerializer.h"
 #include "llvm/Remarks/YAMLRemarkSerializer.h"
 
 using namespace llvm;
@@ -28,8 +27,6 @@ remarks::createRemarkSerializer(Format RemarksFormat, SerializerMode Mode,
     return llvm::make_unique<YAMLRemarkSerializer>(OS, Mode);
   case Format::YAMLStrTab:
     return llvm::make_unique<YAMLStrTabRemarkSerializer>(OS, Mode);
-  case Format::Bitstream:
-    return llvm::make_unique<BitstreamSerializer>(OS, Mode);
   }
   llvm_unreachable("Unknown remarks::Format enum");
 }
@@ -48,8 +45,6 @@ remarks::createRemarkSerializer(Format RemarksFormat, SerializerMode Mode,
   case Format::YAMLStrTab:
     return llvm::make_unique<YAMLStrTabRemarkSerializer>(OS, Mode,
                                                          std::move(StrTab));
-  case Format::Bitstream:
-    return llvm::make_unique<BitstreamSerializer>(OS, Mode, std::move(StrTab));
   }
   llvm_unreachable("Unknown remarks::Format enum");
 }
diff --git a/llvm/lib/Remarks/YAMLRemarkParser.cpp b/llvm/lib/Remarks/YAMLRemarkParser.cpp
index 7b1e4d72ddd..0b115237692 100644
--- a/llvm/lib/Remarks/YAMLRemarkParser.cpp
+++ b/llvm/lib/Remarks/YAMLRemarkParser.cpp
@@ -75,11 +75,11 @@ static Expected<uint64_t> parseVersion(StringRef &Buf) {
   uint64_t Version =
       support::endian::read<uint64_t, support::little, support::unaligned>(
           Buf.data());
-  if (Version != remarks::CurrentRemarkVersion)
+  if (Version != remarks::Version)
     return createStringError(std::errc::illegal_byte_sequence,
                              "Mismatching remark version. Got %" PRId64
                              ", expected %" PRId64 ".",
-                             Version, remarks::CurrentRemarkVersion);
+                             Version, remarks::Version);
   Buf = Buf.drop_front(sizeof(uint64_t));
   return Version;
 }
diff --git a/llvm/lib/Remarks/YAMLRemarkSerializer.cpp b/llvm/lib/Remarks/YAMLRemarkSerializer.cpp
index c4a5bccda5b..f8ed7407259 100644
--- a/llvm/lib/Remarks/YAMLRemarkSerializer.cpp
+++ b/llvm/lib/Remarks/YAMLRemarkSerializer.cpp
@@ -191,7 +191,7 @@ static void emitMagic(raw_ostream &OS) {
 static void emitVersion(raw_ostream &OS) {
   // Emit the version number: little-endian uint64_t.
   std::array<char, 8> Version;
-  support::endian::write64le(Version.data(), remarks::CurrentRemarkVersion);
+  support::endian::write64le(Version.data(), remarks::Version);
   OS.write(Version.data(), Version.size());
 }