From ff4b515a77880b3a0d7010287b2116f2f3b4db1d Mon Sep 17 00:00:00 2001 From: Francis Visoiu Mistrih Date: Wed, 24 Jul 2019 19:47:57 +0000 Subject: [PATCH] [Remarks][NFC] Rename remarks::Serializer to remarks::RemarkSerializer llvm-svn: 366939 --- llvm/include/llvm/IR/RemarkStreamer.h | 8 ++++---- llvm/include/llvm/Remarks/RemarkSerializer.h | 10 +++++----- llvm/include/llvm/Remarks/YAMLRemarkSerializer.h | 12 ++++++------ llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp | 6 +++--- llvm/lib/IR/RemarkStreamer.cpp | 16 +++++++++------- llvm/lib/Remarks/RemarkSerializer.cpp | 10 +++++----- llvm/lib/Remarks/YAMLRemarkSerializer.cpp | 12 ++++++------ llvm/unittests/Remarks/YAMLRemarksSerializerTest.cpp | 4 ++-- 8 files changed, 40 insertions(+), 38 deletions(-) diff --git a/llvm/include/llvm/IR/RemarkStreamer.h b/llvm/include/llvm/IR/RemarkStreamer.h index f34cc66..7b2fc95 100644 --- a/llvm/include/llvm/IR/RemarkStreamer.h +++ b/llvm/include/llvm/IR/RemarkStreamer.h @@ -30,7 +30,7 @@ class RemarkStreamer { /// The regex used to filter remarks based on the passes that emit them. Optional PassFilter; /// The object used to serialize the remarks to a specific format. - std::unique_ptr Serializer; + std::unique_ptr RemarkSerializer; /// Convert diagnostics into remark objects. /// The lifetime of the members of the result is bound to the lifetime of @@ -39,13 +39,13 @@ class RemarkStreamer { public: RemarkStreamer(StringRef Filename, - std::unique_ptr Serializer); + std::unique_ptr RemarkSerializer); /// Return the filename that the remark diagnostics are emitted to. StringRef getFilename() const { return Filename; } /// Return stream that the remark diagnostics are emitted to. - raw_ostream &getStream() { return Serializer->OS; } + raw_ostream &getStream() { return RemarkSerializer->OS; } /// Return the serializer used for this stream. - remarks::Serializer &getSerializer() { return *Serializer; } + remarks::RemarkSerializer &getSerializer() { return *RemarkSerializer; } /// Set a pass filter based on a regex \p Filter. /// Returns an error if the regex is invalid. Error setFilter(StringRef Filter); diff --git a/llvm/include/llvm/Remarks/RemarkSerializer.h b/llvm/include/llvm/Remarks/RemarkSerializer.h index cf12a9a..362d81b 100644 --- a/llvm/include/llvm/Remarks/RemarkSerializer.h +++ b/llvm/include/llvm/Remarks/RemarkSerializer.h @@ -22,26 +22,26 @@ namespace remarks { /// This is the base class for a remark serializer. /// It includes support for using a string table while emitting. -struct Serializer { +struct RemarkSerializer { /// The open raw_ostream that the remark diagnostics are emitted to. raw_ostream &OS; /// The string table containing all the unique strings used in the output. /// The table can be serialized to be consumed after the compilation. Optional StrTab; - Serializer(raw_ostream &OS) : OS(OS), StrTab() {} + RemarkSerializer(raw_ostream &OS) : OS(OS), StrTab() {} /// This is just an interface. - virtual ~Serializer() = default; + virtual ~RemarkSerializer() = default; virtual void emit(const Remark &Remark) = 0; }; /// Create a remark serializer. -Expected> +Expected> createRemarkSerializer(Format RemarksFormat, raw_ostream &OS); /// Create a remark serializer that uses a pre-filled string table. -Expected> +Expected> createRemarkSerializer(Format RemarksFormat, raw_ostream &OS, remarks::StringTable StrTab); diff --git a/llvm/include/llvm/Remarks/YAMLRemarkSerializer.h b/llvm/include/llvm/Remarks/YAMLRemarkSerializer.h index 0d8d39c..cc09805 100644 --- a/llvm/include/llvm/Remarks/YAMLRemarkSerializer.h +++ b/llvm/include/llvm/Remarks/YAMLRemarkSerializer.h @@ -30,11 +30,11 @@ namespace remarks { /// - : /// DebugLoc: { File: , Line: , Column: } /// ... -struct YAMLSerializer : public Serializer { +struct YAMLRemarkSerializer : public RemarkSerializer { /// The YAML streamer. yaml::Output YAMLOutput; - YAMLSerializer(raw_ostream &OS); + YAMLRemarkSerializer(raw_ostream &OS); /// Emit a remark to the stream. void emit(const Remark &Remark) override; @@ -43,13 +43,13 @@ struct YAMLSerializer : public Serializer { /// Serialize the remarks to YAML using a string table. An remark entry looks /// like the regular YAML remark but instead of string entries it's using /// numbers that map to an index in the string table. -struct YAMLStrTabSerializer : public YAMLSerializer { - YAMLStrTabSerializer(raw_ostream &OS) : YAMLSerializer(OS) { +struct YAMLStrTabRemarkSerializer : public YAMLRemarkSerializer { + YAMLStrTabRemarkSerializer(raw_ostream &OS) : YAMLRemarkSerializer(OS) { // Having a string table set up enables the serializer to use it. StrTab.emplace(); } - YAMLStrTabSerializer(raw_ostream &OS, StringTable StrTabIn) - : YAMLSerializer(OS) { + YAMLStrTabRemarkSerializer(raw_ostream &OS, StringTable StrTabIn) + : YAMLRemarkSerializer(OS) { StrTab = std::move(StrTabIn); } }; diff --git a/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp b/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp index 54f6cc2..1d22ea8 100644 --- a/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp +++ b/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp @@ -1349,7 +1349,7 @@ void AsmPrinter::emitRemarksSection(Module &M) { RemarkStreamer *RS = M.getContext().getRemarkStreamer(); if (!RS) return; - const remarks::Serializer &Serializer = RS->getSerializer(); + const remarks::RemarkSerializer &RemarkSerializer = RS->getSerializer(); // Switch to the right section: .remarks/__remarks. MCSection *RemarksSection = @@ -1372,7 +1372,7 @@ void AsmPrinter::emitRemarksSection(Module &M) { // just use the serialize function with a raw_ostream because of the way // MCStreamers work. uint64_t StrTabSize = - Serializer.StrTab ? Serializer.StrTab->SerializedSize : 0; + RemarkSerializer.StrTab ? RemarkSerializer.StrTab->SerializedSize : 0; // Emit the total size of the string table (the size itself excluded): // little-endian uint64_t. // The total size is located after the version number. @@ -1382,7 +1382,7 @@ void AsmPrinter::emitRemarksSection(Module &M) { OutStreamer->EmitBinaryData( StringRef(StrTabSizeBuf.data(), StrTabSizeBuf.size())); - if (const Optional &StrTab = Serializer.StrTab) { + if (const Optional &StrTab = RemarkSerializer.StrTab) { std::vector StrTabStrings = StrTab->serialize(); // Emit a list of null-terminated strings. // Note: the order is important here: the ID used in the remarks corresponds diff --git a/llvm/lib/IR/RemarkStreamer.cpp b/llvm/lib/IR/RemarkStreamer.cpp index 2c01c8a..450453f 100644 --- a/llvm/lib/IR/RemarkStreamer.cpp +++ b/llvm/lib/IR/RemarkStreamer.cpp @@ -20,9 +20,11 @@ using namespace llvm; -RemarkStreamer::RemarkStreamer(StringRef Filename, - std::unique_ptr Serializer) - : Filename(Filename), PassFilter(), Serializer(std::move(Serializer)) { +RemarkStreamer::RemarkStreamer( + StringRef Filename, + std::unique_ptr RemarkSerializer) + : Filename(Filename), PassFilter(), + RemarkSerializer(std::move(RemarkSerializer)) { assert(!Filename.empty() && "This needs to be a real filename."); } @@ -100,7 +102,7 @@ void RemarkStreamer::emit(const DiagnosticInfoOptimizationBase &Diag) { // First, convert the diagnostic to a remark. remarks::Remark R = toRemark(Diag); // Then, emit the remark through the serializer. - Serializer->emit(R); + RemarkSerializer->emit(R); } char RemarkSetupFileError::ID = 0; @@ -133,13 +135,13 @@ llvm::setupOptimizationRemarks(LLVMContext &Context, StringRef RemarksFilename, if (Error E = Format.takeError()) return make_error(std::move(E)); - Expected> Serializer = + Expected> RemarkSerializer = remarks::createRemarkSerializer(*Format, RemarksFile->os()); - if (Error E = Serializer.takeError()) + if (Error E = RemarkSerializer.takeError()) return make_error(std::move(E)); Context.setRemarkStreamer(llvm::make_unique( - RemarksFilename, std::move(*Serializer))); + RemarksFilename, std::move(*RemarkSerializer))); if (!RemarksPasses.empty()) if (Error E = Context.getRemarkStreamer()->setFilter(RemarksPasses)) diff --git a/llvm/lib/Remarks/RemarkSerializer.cpp b/llvm/lib/Remarks/RemarkSerializer.cpp index b1cfd09..aa68b49 100644 --- a/llvm/lib/Remarks/RemarkSerializer.cpp +++ b/llvm/lib/Remarks/RemarkSerializer.cpp @@ -16,21 +16,21 @@ using namespace llvm; using namespace llvm::remarks; -Expected> +Expected> remarks::createRemarkSerializer(Format RemarksFormat, raw_ostream &OS) { switch (RemarksFormat) { case Format::Unknown: return createStringError(std::errc::invalid_argument, "Unknown remark serializer format."); case Format::YAML: - return llvm::make_unique(OS); + return llvm::make_unique(OS); case Format::YAMLStrTab: - return llvm::make_unique(OS); + return llvm::make_unique(OS); } llvm_unreachable("Unknown remarks::Format enum"); } -Expected> +Expected> remarks::createRemarkSerializer(Format RemarksFormat, raw_ostream &OS, remarks::StringTable StrTab) { switch (RemarksFormat) { @@ -42,7 +42,7 @@ remarks::createRemarkSerializer(Format RemarksFormat, raw_ostream &OS, "Unable to use a string table with the yaml " "format. Use 'yaml-strtab' instead."); case Format::YAMLStrTab: - return llvm::make_unique(OS, std::move(StrTab)); + return llvm::make_unique(OS, std::move(StrTab)); } llvm_unreachable("Unknown remarks::Format enum"); } diff --git a/llvm/lib/Remarks/YAMLRemarkSerializer.cpp b/llvm/lib/Remarks/YAMLRemarkSerializer.cpp index 1297fbc..c8a4ffe 100644 --- a/llvm/lib/Remarks/YAMLRemarkSerializer.cpp +++ b/llvm/lib/Remarks/YAMLRemarkSerializer.cpp @@ -57,7 +57,7 @@ template <> struct MappingTraits { llvm_unreachable("Unknown remark type"); if (Optional &StrTab = - reinterpret_cast(io.getContext())->StrTab) { + reinterpret_cast(io.getContext())->StrTab) { unsigned PassID = StrTab->add(Remark->PassName).first; unsigned NameID = StrTab->add(Remark->RemarkName).first; unsigned FunctionID = StrTab->add(Remark->FunctionName).first; @@ -79,7 +79,7 @@ template <> struct MappingTraits { unsigned Col = RL.SourceColumn; if (Optional &StrTab = - reinterpret_cast(io.getContext())->StrTab) { + reinterpret_cast(io.getContext())->StrTab) { unsigned FileID = StrTab->add(File).first; io.mapRequired("File", FileID); } else { @@ -131,7 +131,7 @@ template <> struct MappingTraits { assert(io.outputting() && "input not yet implemented"); if (Optional &StrTab = - reinterpret_cast(io.getContext())->StrTab) { + reinterpret_cast(io.getContext())->StrTab) { auto ValueID = StrTab->add(A.Val).first; io.mapRequired(A.Key.data(), ValueID); } else if (StringRef(A.Val).count('\n') > 1) { @@ -149,10 +149,10 @@ template <> struct MappingTraits { LLVM_YAML_IS_SEQUENCE_VECTOR(Argument) -YAMLSerializer::YAMLSerializer(raw_ostream &OS) - : Serializer(OS), YAMLOutput(OS, reinterpret_cast(this)) {} +YAMLRemarkSerializer::YAMLRemarkSerializer(raw_ostream &OS) + : RemarkSerializer(OS), YAMLOutput(OS, reinterpret_cast(this)) {} -void YAMLSerializer::emit(const Remark &Remark) { +void YAMLRemarkSerializer::emit(const Remark &Remark) { // Again, YAMLTraits expect a non-const object for inputting, but we're not // using that here. auto R = const_cast(&Remark); diff --git a/llvm/unittests/Remarks/YAMLRemarksSerializerTest.cpp b/llvm/unittests/Remarks/YAMLRemarksSerializerTest.cpp index e1340b4..12c754e 100644 --- a/llvm/unittests/Remarks/YAMLRemarksSerializerTest.cpp +++ b/llvm/unittests/Remarks/YAMLRemarksSerializerTest.cpp @@ -19,7 +19,7 @@ static void check(const remarks::Remark &R, StringRef ExpectedR, std::string Buf; raw_string_ostream OS(Buf); bool UseStrTab = ExpectedStrTab.hasValue(); - Expected> MaybeS = [&] { + Expected> MaybeS = [&] { if (UseStrTab) { if (StrTab) return createRemarkSerializer(remarks::Format::YAMLStrTab, OS, @@ -30,7 +30,7 @@ static void check(const remarks::Remark &R, StringRef ExpectedR, return createRemarkSerializer(remarks::Format::YAML, OS); }(); EXPECT_FALSE(errorToBool(MaybeS.takeError())); - std::unique_ptr S = std::move(*MaybeS); + std::unique_ptr S = std::move(*MaybeS); S->emit(R); EXPECT_EQ(OS.str(), ExpectedR); -- 2.7.4