[llvm] Unittests and usability for BitstreamWriter incremental flushing (PR #92983)
Mircea Trofin via llvm-commits
llvm-commits at lists.llvm.org
Thu May 30 11:18:28 PDT 2024
https://github.com/mtrofin updated https://github.com/llvm/llvm-project/pull/92983
>From ae8bd286d5d851891ada8921bffa581551d0df61 Mon Sep 17 00:00:00 2001
From: Mircea Trofin <mtrofin at google.com>
Date: Tue, 21 May 2024 18:59:49 -0700
Subject: [PATCH 1/8] Unittests and usability for BitstreamWriter incremental
flushing
- added unittests for the raw_fd_stream output case.
- the ctor documentation seemed to suggest that if there was no file stream
provided, the buffer will be written at the end. That's incorrect. Fixed the
documentation, clarifying flushing behavior and highlighting a few other
details.
- flushing everything in the dtor. While flushing to the file stream would
happen on subblock boundaries, if the choice of format didn't feature subblocks
or didn't end with a subblock, the user would have the expectation of flushing
to the given stream, and have no API indication that's not the case.
---
llvm/include/llvm/Bitstream/BitstreamWriter.h | 28 ++++---
.../Bitstream/BitstreamWriterTest.cpp | 79 +++++++++++++++++++
2 files changed, 97 insertions(+), 10 deletions(-)
diff --git a/llvm/include/llvm/Bitstream/BitstreamWriter.h b/llvm/include/llvm/Bitstream/BitstreamWriter.h
index c726508cd5285..d0476784a1c48 100644
--- a/llvm/include/llvm/Bitstream/BitstreamWriter.h
+++ b/llvm/include/llvm/Bitstream/BitstreamWriter.h
@@ -93,10 +93,10 @@ class BitstreamWriter {
/// If the related file stream supports reading, seeking and writing, flush
/// the buffer if its size is above a threshold.
- void FlushToFile() {
- if (!FS)
+ void FlushToFile(bool OnClosing = false) {
+ if (!FS || Out.empty())
return;
- if (Out.size() < FlushThreshold)
+ if (!OnClosing && Out.size() < FlushThreshold)
return;
FS->write((char *)&Out.front(), Out.size());
Out.clear();
@@ -104,20 +104,28 @@ class BitstreamWriter {
public:
/// Create a BitstreamWriter that writes to Buffer \p O.
+ /// The buffer is flushed incrementally to a raw_fd_stream \p FS, if provided.
///
- /// \p FS is the file stream that \p O flushes to incrementally. If \p FS is
- /// null, \p O does not flush incrementially, but writes to disk at the end.
+ /// Flushing to FS happens:
+ /// - at \ref ExitBlock, and only if \O.size() >= \p FlushThreshold (MB)
+ /// - unconditionally at the BitstreamWriter destruction.
///
- /// \p FlushThreshold is the threshold (unit M) to flush \p O if \p FS is
- /// valid. Flushing only occurs at (sub)block boundaries.
+ /// NOTES:
+ /// - \p FlushThreshold's unit is MB.
+ /// - The provided buffer will always be resized as needed. Its initial size
+ /// has no bearing on flushing behavior (if \p FS is provided).
+ /// - \p FS is expected to support seek, tell, and read (besides write).
+ /// The BitstreamWriter makes no attempt to pre-validate FS, meaning errors
+ /// stemming from an unsupported \p FS will happen during writing.
BitstreamWriter(SmallVectorImpl<char> &O, raw_fd_stream *FS = nullptr,
uint32_t FlushThreshold = 512)
- : Out(O), FS(FS), FlushThreshold(uint64_t(FlushThreshold) << 20), CurBit(0),
- CurValue(0), CurCodeSize(2) {}
+ : Out(O), FS(FS), FlushThreshold(uint64_t(FlushThreshold) << 20),
+ CurBit(0), CurValue(0), CurCodeSize(2) {}
~BitstreamWriter() {
- assert(CurBit == 0 && "Unflushed data remaining");
+ FlushToWord();
assert(BlockScope.empty() && CurAbbrevs.empty() && "Block imbalance");
+ FlushToFile(/*OnClosing=*/true);
}
/// Retrieve the current position in the stream, in bits.
diff --git a/llvm/unittests/Bitstream/BitstreamWriterTest.cpp b/llvm/unittests/Bitstream/BitstreamWriterTest.cpp
index 054948e7e8b63..41b381af09394 100644
--- a/llvm/unittests/Bitstream/BitstreamWriterTest.cpp
+++ b/llvm/unittests/Bitstream/BitstreamWriterTest.cpp
@@ -9,6 +9,12 @@
#include "llvm/Bitstream/BitstreamWriter.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallString.h"
+#include "llvm/Bitstream/BitCodeEnums.h"
+#include "llvm/Bitstream/BitstreamReader.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Testing/Support/SupportHelpers.h"
+#include "gmock/gmock.h"
#include "gtest/gtest.h"
using namespace llvm;
@@ -55,4 +61,77 @@ TEST(BitstreamWriterTest, emitBlob4ByteAligned) {
EXPECT_EQ(StringRef("str0"), Buffer);
}
+class BitstreamWriterFlushTest :public ::testing::TestWithParam<int> {
+protected:
+ const unsigned BlkID = bitc::FIRST_APPLICATION_BLOCKID + 17;
+
+ void write(StringRef TestFilePath, int FlushThreshold,
+ llvm::function_ref<void(BitstreamWriter &)> Action) {
+ SmallString<64> Buffer;
+ std::error_code EC;
+ raw_fd_stream Out(TestFilePath, EC);
+ ASSERT_FALSE(EC);
+ BitstreamWriter W(Buffer, &Out, FlushThreshold);
+ Action(W);
+ }
+};
+
+TEST_P(BitstreamWriterFlushTest, simpleExample) {
+ llvm::unittest::TempFile TestFile("bitstream", "", "",
+ /*Unique*/ true);
+ write(TestFile.path(), GetParam(),
+ [&](BitstreamWriter &W) { W.EmitVBR(42, 2); });
+
+ ErrorOr<std::unique_ptr<MemoryBuffer>> MB =
+ MemoryBuffer::getFile(TestFile.path());
+ ASSERT_TRUE(!!MB);
+ ASSERT_NE(*MB, nullptr);
+ BitstreamCursor Cursor((*MB)->getBuffer());
+ auto V = Cursor.ReadVBR(2);
+ EXPECT_TRUE(!!V);
+ EXPECT_EQ(*V, 42U);
+}
+
+TEST_P(BitstreamWriterFlushTest, subBlock) {
+ llvm::unittest::TempFile TestFile("bitstream", "", "",
+ /*Unique*/ true);
+ write(TestFile.path(), GetParam(), [&](BitstreamWriter &W) {
+ W.EnterSubblock(BlkID, 2);
+ W.EmitVBR(42, 2);
+ W.ExitBlock();
+ });
+ ErrorOr<std::unique_ptr<MemoryBuffer>> MB =
+ MemoryBuffer::getFile(TestFile.path());
+ ASSERT_TRUE(!!MB);
+ ASSERT_NE(*MB, nullptr);
+ BitstreamCursor Cursor((*MB)->getBuffer());
+ auto Blk = Cursor.advance(BitstreamCursor::AF_DontAutoprocessAbbrevs);
+ ASSERT_TRUE(!!Blk);
+ EXPECT_EQ(Blk->Kind, BitstreamEntry::SubBlock);
+ EXPECT_EQ(Blk->ID, BlkID);
+ EXPECT_FALSE(Cursor.EnterSubBlock(BlkID));
+ auto V = Cursor.ReadVBR(2);
+ EXPECT_TRUE(!!V);
+ EXPECT_EQ(*V, 42U);
+ // ReadBlockEnd() returns false if it actually read the block end.
+ EXPECT_FALSE(Cursor.ReadBlockEnd());
+ EXPECT_TRUE(Cursor.AtEndOfStream());
+}
+
+TEST_P(BitstreamWriterFlushTest, blobRawRead) {
+ llvm::unittest::TempFile TestFile("bitstream", "", "",
+ /*Unique*/ true);
+ write(TestFile.path(), GetParam(), [&](BitstreamWriter &W) {
+ W.emitBlob("str", /* ShouldEmitSize */ false);
+ });
+
+ ErrorOr<std::unique_ptr<MemoryBuffer>> MB =
+ MemoryBuffer::getFile(TestFile.path());
+ ASSERT_TRUE(!!MB);
+ ASSERT_NE(*MB, nullptr);
+ EXPECT_EQ(StringRef("str\0", 4), (*MB)->getBuffer());
+}
+
+INSTANTIATE_TEST_SUITE_P(BitstreamWriterFlushCases, BitstreamWriterFlushTest,
+ ::testing::Values(0, 1 /*MB*/));
} // end namespace
>From 173486b18534afdd59da0b8dbe044cbbee919211 Mon Sep 17 00:00:00 2001
From: Mircea Trofin <mtrofin at google.com>
Date: Tue, 21 May 2024 20:41:17 -0700
Subject: [PATCH 2/8] clang-format
---
llvm/unittests/Bitstream/BitstreamWriterTest.cpp | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/llvm/unittests/Bitstream/BitstreamWriterTest.cpp b/llvm/unittests/Bitstream/BitstreamWriterTest.cpp
index 41b381af09394..53a7aa5ecd886 100644
--- a/llvm/unittests/Bitstream/BitstreamWriterTest.cpp
+++ b/llvm/unittests/Bitstream/BitstreamWriterTest.cpp
@@ -61,7 +61,7 @@ TEST(BitstreamWriterTest, emitBlob4ByteAligned) {
EXPECT_EQ(StringRef("str0"), Buffer);
}
-class BitstreamWriterFlushTest :public ::testing::TestWithParam<int> {
+class BitstreamWriterFlushTest : public ::testing::TestWithParam<int> {
protected:
const unsigned BlkID = bitc::FIRST_APPLICATION_BLOCKID + 17;
>From 57ebf01058ebe28bff293837470b46fb35ecb6af Mon Sep 17 00:00:00 2001
From: Mircea Trofin <mtrofin at google.com>
Date: Wed, 22 May 2024 10:12:23 -0700
Subject: [PATCH 3/8] fix
---
llvm/lib/Bitcode/Writer/BitcodeWriter.cpp | 14 +++++++-------
1 file changed, 7 insertions(+), 7 deletions(-)
diff --git a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
index c4cea3d6eef2d..86c4293afb95d 100644
--- a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
+++ b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
@@ -5055,13 +5055,13 @@ void llvm::WriteBitcodeToFile(const Module &M, raw_ostream &Out,
Triple TT(M.getTargetTriple());
if (TT.isOSDarwin() || TT.isOSBinFormatMachO())
Buffer.insert(Buffer.begin(), BWH_HeaderSize, 0);
-
- BitcodeWriter Writer(Buffer, dyn_cast<raw_fd_stream>(&Out));
- Writer.writeModule(M, ShouldPreserveUseListOrder, Index, GenerateHash,
- ModHash);
- Writer.writeSymtab();
- Writer.writeStrtab();
-
+ {
+ BitcodeWriter Writer(Buffer, dyn_cast<raw_fd_stream>(&Out));
+ Writer.writeModule(M, ShouldPreserveUseListOrder, Index, GenerateHash,
+ ModHash);
+ Writer.writeSymtab();
+ Writer.writeStrtab();
+ }
if (TT.isOSDarwin() || TT.isOSBinFormatMachO())
emitDarwinBCHeaderAndTrailer(Buffer, TT);
>From b4f6587bcbe73b8fa26d456ce491f4652b8ef1f2 Mon Sep 17 00:00:00 2001
From: Mircea Trofin <mtrofin at google.com>
Date: Fri, 24 May 2024 12:08:44 -0700
Subject: [PATCH 4/8] feedback
---
llvm/include/llvm/Bitstream/BitstreamWriter.h | 2 ++
llvm/unittests/Bitstream/BitstreamWriterTest.cpp | 2 ++
2 files changed, 4 insertions(+)
diff --git a/llvm/include/llvm/Bitstream/BitstreamWriter.h b/llvm/include/llvm/Bitstream/BitstreamWriter.h
index d0476784a1c48..627503884985b 100644
--- a/llvm/include/llvm/Bitstream/BitstreamWriter.h
+++ b/llvm/include/llvm/Bitstream/BitstreamWriter.h
@@ -93,6 +93,8 @@ class BitstreamWriter {
/// If the related file stream supports reading, seeking and writing, flush
/// the buffer if its size is above a threshold.
+ /// If \p OnClosing is true, and if a stream is provided, flushing happens
+ /// regardless of thresholds.
void FlushToFile(bool OnClosing = false) {
if (!FS || Out.empty())
return;
diff --git a/llvm/unittests/Bitstream/BitstreamWriterTest.cpp b/llvm/unittests/Bitstream/BitstreamWriterTest.cpp
index 53a7aa5ecd886..096363190af4a 100644
--- a/llvm/unittests/Bitstream/BitstreamWriterTest.cpp
+++ b/llvm/unittests/Bitstream/BitstreamWriterTest.cpp
@@ -63,6 +63,8 @@ TEST(BitstreamWriterTest, emitBlob4ByteAligned) {
class BitstreamWriterFlushTest : public ::testing::TestWithParam<int> {
protected:
+ // Any value after bitc::FIRST_APPLICATION_BLOCKID is good, but let's pick a
+ // distinctive one.
const unsigned BlkID = bitc::FIRST_APPLICATION_BLOCKID + 17;
void write(StringRef TestFilePath, int FlushThreshold,
>From 1af1852b08d961ad257cf9c8b1449a76a80aa3ad Mon Sep 17 00:00:00 2001
From: Mircea Trofin <mtrofin at google.com>
Date: Wed, 29 May 2024 08:33:06 -0700
Subject: [PATCH 5/8] revisit
---
llvm/include/llvm/Bitcode/BitcodeWriter.h | 150 ++++++++--------
llvm/include/llvm/Bitstream/BitstreamWriter.h | 161 ++++++++++++------
.../llvm/ProfileData/PGOCtxProfWriter.h | 2 +-
llvm/include/llvm/Support/raw_ostream.h | 10 +-
llvm/lib/Bitcode/Writer/BitcodeWriter.cpp | 66 +++----
llvm/lib/Support/raw_ostream.cpp | 4 +
.../Bitstream/BitstreamWriterTest.cpp | 3 +-
7 files changed, 236 insertions(+), 160 deletions(-)
diff --git a/llvm/include/llvm/Bitcode/BitcodeWriter.h b/llvm/include/llvm/Bitcode/BitcodeWriter.h
index 248d33f4502ef..ef00fa3b4b87e 100644
--- a/llvm/include/llvm/Bitcode/BitcodeWriter.h
+++ b/llvm/include/llvm/Bitcode/BitcodeWriter.h
@@ -29,81 +29,81 @@ class BitstreamWriter;
class Module;
class raw_ostream;
- class BitcodeWriter {
- SmallVectorImpl<char> &Buffer;
- std::unique_ptr<BitstreamWriter> Stream;
-
- StringTableBuilder StrtabBuilder{StringTableBuilder::RAW};
-
- // Owns any strings created by the irsymtab writer until we create the
- // string table.
- BumpPtrAllocator Alloc;
-
- bool WroteStrtab = false, WroteSymtab = false;
-
- void writeBlob(unsigned Block, unsigned Record, StringRef Blob);
-
- std::vector<Module *> Mods;
-
- public:
- /// Create a BitcodeWriter that writes to Buffer.
- BitcodeWriter(SmallVectorImpl<char> &Buffer, raw_fd_stream *FS = nullptr);
-
- ~BitcodeWriter();
-
- /// Attempt to write a symbol table to the bitcode file. This must be called
- /// at most once after all modules have been written.
- ///
- /// A reader does not require a symbol table to interpret a bitcode file;
- /// the symbol table is needed only to improve link-time performance. So
- /// this function may decide not to write a symbol table. It may so decide
- /// if, for example, the target is unregistered or the IR is malformed.
- void writeSymtab();
-
- /// Write the bitcode file's string table. This must be called exactly once
- /// after all modules and the optional symbol table have been written.
- void writeStrtab();
-
- /// Copy the string table for another module into this bitcode file. This
- /// should be called after copying the module itself into the bitcode file.
- void copyStrtab(StringRef Strtab);
-
- /// Write the specified module to the buffer specified at construction time.
- ///
- /// If \c ShouldPreserveUseListOrder, encode the use-list order for each \a
- /// Value in \c M. These will be reconstructed exactly when \a M is
- /// deserialized.
- ///
- /// If \c Index is supplied, the bitcode will contain the summary index
- /// (currently for use in ThinLTO optimization).
- ///
- /// \p GenerateHash enables hashing the Module and including the hash in the
- /// bitcode (currently for use in ThinLTO incremental build).
- ///
- /// If \p ModHash is non-null, when GenerateHash is true, the resulting
- /// hash is written into ModHash. When GenerateHash is false, that value
- /// is used as the hash instead of computing from the generated bitcode.
- /// Can be used to produce the same module hash for a minimized bitcode
- /// used just for the thin link as in the regular full bitcode that will
- /// be used in the backend.
- void writeModule(const Module &M, bool ShouldPreserveUseListOrder = false,
- const ModuleSummaryIndex *Index = nullptr,
- bool GenerateHash = false, ModuleHash *ModHash = nullptr);
-
- /// Write the specified thin link bitcode file (i.e., the minimized bitcode
- /// file) to the buffer specified at construction time. The thin link
- /// bitcode file is used for thin link, and it only contains the necessary
- /// information for thin link.
- ///
- /// ModHash is for use in ThinLTO incremental build, generated while the
- /// IR bitcode file writing.
- void writeThinLinkBitcode(const Module &M, const ModuleSummaryIndex &Index,
- const ModuleHash &ModHash);
-
- void writeIndex(
- const ModuleSummaryIndex *Index,
- const std::map<std::string, GVSummaryMapTy> *ModuleToSummariesForIndex);
- };
+class BitcodeWriter {
+ std::unique_ptr<BitstreamWriter> Stream;
+
+ StringTableBuilder StrtabBuilder{StringTableBuilder::RAW};
+
+ // Owns any strings created by the irsymtab writer until we create the
+ // string table.
+ BumpPtrAllocator Alloc;
+
+ bool WroteStrtab = false, WroteSymtab = false;
+
+ void writeBlob(unsigned Block, unsigned Record, StringRef Blob);
+
+ std::vector<Module *> Mods;
+
+public:
+ /// Create a BitcodeWriter that writes to Buffer.
+ BitcodeWriter(SmallVectorImpl<char> &Buffer);
+ BitcodeWriter(raw_ostream &FS);
+
+ ~BitcodeWriter();
+
+ /// Attempt to write a symbol table to the bitcode file. This must be called
+ /// at most once after all modules have been written.
+ ///
+ /// A reader does not require a symbol table to interpret a bitcode file;
+ /// the symbol table is needed only to improve link-time performance. So
+ /// this function may decide not to write a symbol table. It may so decide
+ /// if, for example, the target is unregistered or the IR is malformed.
+ void writeSymtab();
+
+ /// Write the bitcode file's string table. This must be called exactly once
+ /// after all modules and the optional symbol table have been written.
+ void writeStrtab();
+
+ /// Copy the string table for another module into this bitcode file. This
+ /// should be called after copying the module itself into the bitcode file.
+ void copyStrtab(StringRef Strtab);
+
+ /// Write the specified module to the buffer specified at construction time.
+ ///
+ /// If \c ShouldPreserveUseListOrder, encode the use-list order for each \a
+ /// Value in \c M. These will be reconstructed exactly when \a M is
+ /// deserialized.
+ ///
+ /// If \c Index is supplied, the bitcode will contain the summary index
+ /// (currently for use in ThinLTO optimization).
+ ///
+ /// \p GenerateHash enables hashing the Module and including the hash in the
+ /// bitcode (currently for use in ThinLTO incremental build).
+ ///
+ /// If \p ModHash is non-null, when GenerateHash is true, the resulting
+ /// hash is written into ModHash. When GenerateHash is false, that value
+ /// is used as the hash instead of computing from the generated bitcode.
+ /// Can be used to produce the same module hash for a minimized bitcode
+ /// used just for the thin link as in the regular full bitcode that will
+ /// be used in the backend.
+ void writeModule(const Module &M, bool ShouldPreserveUseListOrder = false,
+ const ModuleSummaryIndex *Index = nullptr,
+ bool GenerateHash = false, ModuleHash *ModHash = nullptr);
+
+ /// Write the specified thin link bitcode file (i.e., the minimized bitcode
+ /// file) to the buffer specified at construction time. The thin link
+ /// bitcode file is used for thin link, and it only contains the necessary
+ /// information for thin link.
+ ///
+ /// ModHash is for use in ThinLTO incremental build, generated while the
+ /// IR bitcode file writing.
+ void writeThinLinkBitcode(const Module &M, const ModuleSummaryIndex &Index,
+ const ModuleHash &ModHash);
+
+ void writeIndex(
+ const ModuleSummaryIndex *Index,
+ const std::map<std::string, GVSummaryMapTy> *ModuleToSummariesForIndex);
+};
/// Write the specified module to the specified raw output stream.
///
diff --git a/llvm/include/llvm/Bitstream/BitstreamWriter.h b/llvm/include/llvm/Bitstream/BitstreamWriter.h
index 627503884985b..96ffec0a590d7 100644
--- a/llvm/include/llvm/Bitstream/BitstreamWriter.h
+++ b/llvm/include/llvm/Bitstream/BitstreamWriter.h
@@ -18,6 +18,7 @@
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Bitstream/BitCodes.h"
+#include "llvm/Support/Casting.h"
#include "llvm/Support/Endian.h"
#include "llvm/Support/MathExtras.h"
#include "llvm/Support/raw_ostream.h"
@@ -28,34 +29,42 @@
namespace llvm {
class BitstreamWriter {
- /// Out - The buffer that keeps unflushed bytes.
- SmallVectorImpl<char> &Out;
-
- /// FS - The file stream that Out flushes to. If FS is nullptr, it does not
- /// support read or seek, Out cannot be flushed until all data are written.
- raw_fd_stream *FS;
-
- /// FlushThreshold - If FS is valid, this is the threshold (unit B) to flush
- /// FS.
+ /// Owned buffer, used to init Buffer if the provided stream doesn't happen to
+ /// be a buffer itself.
+ SmallVector<char, 0> OwnBuffer;
+ /// Internal buffer. The writer backpatches, so it is efficient to buffer.
+ SmallVectorImpl<char> &Buffer;
+
+ /// FS - The file stream that Buffer flushes to. If FS is a raw_fd_stream, the
+ /// writer will incrementally flush at subblock boundaries. Otherwise flushing
+ /// will happen at the end of BitstreamWriter's lifetime.
+ raw_ostream *const FS;
+
+ /// FlushThreshold - this is the threshold (unit B) to flush to FS, if FS is a
+ /// raw_fd_stream.
const uint64_t FlushThreshold;
/// CurBit - Always between 0 and 31 inclusive, specifies the next bit to use.
- unsigned CurBit;
+ unsigned CurBit = 0;
/// CurValue - The current value. Only bits < CurBit are valid.
- uint32_t CurValue;
+ uint32_t CurValue = 0;
/// CurCodeSize - This is the declared size of code values used for the
/// current block, in bits.
- unsigned CurCodeSize;
+ unsigned CurCodeSize = 2;
/// BlockInfoCurBID - When emitting a BLOCKINFO_BLOCK, this is the currently
/// selected BLOCK ID.
- unsigned BlockInfoCurBID;
+ unsigned BlockInfoCurBID = 0;
/// CurAbbrevs - Abbrevs installed at in this block.
std::vector<std::shared_ptr<BitCodeAbbrev>> CurAbbrevs;
+ // Support for retrieving a section of the output, for purposes such as
+ // checksumming.
+ std::optional<size_t> BlockFlushingStartPos;
+
struct Block {
unsigned PrevCodeSize;
size_t StartSizeWord;
@@ -77,13 +86,17 @@ class BitstreamWriter {
void WriteWord(unsigned Value) {
Value =
support::endian::byte_swap<uint32_t, llvm::endianness::little>(Value);
- Out.append(reinterpret_cast<const char *>(&Value),
- reinterpret_cast<const char *>(&Value + 1));
+ Buffer.append(reinterpret_cast<const char *>(&Value),
+ reinterpret_cast<const char *>(&Value + 1));
}
- uint64_t GetNumOfFlushedBytes() const { return FS ? FS->tell() : 0; }
+ uint64_t GetNumOfFlushedBytes() const {
+ return fdStream() ? fdStream()->tell() : 0;
+ }
- size_t GetBufferOffset() const { return Out.size() + GetNumOfFlushedBytes(); }
+ size_t GetBufferOffset() const {
+ return Buffer.size() + GetNumOfFlushedBytes();
+ }
size_t GetWordIndex() const {
size_t Offset = GetBufferOffset();
@@ -91,38 +104,65 @@ class BitstreamWriter {
return Offset / 4;
}
- /// If the related file stream supports reading, seeking and writing, flush
- /// the buffer if its size is above a threshold.
- /// If \p OnClosing is true, and if a stream is provided, flushing happens
+ void flushAndClear() {
+ assert(FS);
+ assert(!Buffer.empty());
+ assert(!BlockFlushingStartPos &&
+ "a call to markAndBlockFlushing should have been paired with a "
+ "call to getMarkedBufferAndResumeFlushing");
+ FS->write(Buffer.data(), Buffer.size());
+ Buffer.clear();
+ }
+
+ /// If the related file stream is a raw_fd_stream, flush the buffer if its
+ /// size is above a threshold. If \p OnClosing is true, flushing happens
/// regardless of thresholds.
void FlushToFile(bool OnClosing = false) {
- if (!FS || Out.empty())
+ if (!FS || Buffer.empty())
return;
- if (!OnClosing && Out.size() < FlushThreshold)
+ if (OnClosing)
+ return flushAndClear();
+ if (BlockFlushingStartPos)
return;
- FS->write((char *)&Out.front(), Out.size());
- Out.clear();
+ if (fdStream() && Buffer.size() > FlushThreshold)
+ flushAndClear();
+ }
+
+ raw_fd_stream *fdStream() { return dyn_cast_or_null<raw_fd_stream>(FS); }
+
+ const raw_fd_stream *fdStream() const {
+ return dyn_cast_or_null<raw_fd_stream>(FS);
+ }
+
+ SmallVectorImpl<char> &getInternalBufferFromStream(raw_ostream &OutStream) {
+ if (auto *SV = dyn_cast<raw_svector_ostream>(&OutStream))
+ return SV->buffer();
+ return OwnBuffer;
}
public:
- /// Create a BitstreamWriter that writes to Buffer \p O.
- /// The buffer is flushed incrementally to a raw_fd_stream \p FS, if provided.
+ /// Create a BitstreamWriter over a raw_ostream \p OutStream.
+ /// If \p OutStream is a raw_svector_ostream, the BitstreamWriter will write
+ /// directly to the latter's buffer. In all other cases, the BitstreamWriter
+ /// will use an internal buffer and flush at the end of its lifetime.
///
- /// Flushing to FS happens:
- /// - at \ref ExitBlock, and only if \O.size() >= \p FlushThreshold (MB)
- /// - unconditionally at the BitstreamWriter destruction.
+ /// If \p is a raw_fd_stream, the BitstreamWriter will also flush
+ /// incrementally, when a subblock is finished, and if the FlushThreshold is
+ /// passed.
///
/// NOTES:
/// - \p FlushThreshold's unit is MB.
- /// - The provided buffer will always be resized as needed. Its initial size
- /// has no bearing on flushing behavior (if \p FS is provided).
/// - \p FS is expected to support seek, tell, and read (besides write).
- /// The BitstreamWriter makes no attempt to pre-validate FS, meaning errors
- /// stemming from an unsupported \p FS will happen during writing.
- BitstreamWriter(SmallVectorImpl<char> &O, raw_fd_stream *FS = nullptr,
- uint32_t FlushThreshold = 512)
- : Out(O), FS(FS), FlushThreshold(uint64_t(FlushThreshold) << 20),
- CurBit(0), CurValue(0), CurCodeSize(2) {}
+
+ BitstreamWriter(raw_ostream &OutStream, uint32_t FlushThreshold = 512)
+ : Buffer(getInternalBufferFromStream(OutStream)),
+ FS(!isa<raw_svector_ostream>(OutStream) ? &OutStream : nullptr),
+ FlushThreshold(uint64_t(FlushThreshold) << 20) {}
+
+ /// Convenience constructor for users that start with a vector - avoids
+ /// needing to wrap it in a raw_svector_ostream.
+ BitstreamWriter(SmallVectorImpl<char> &Buff)
+ : Buffer(Buff), FS(nullptr), FlushThreshold(0) {}
~BitstreamWriter() {
FlushToWord();
@@ -130,6 +170,27 @@ class BitstreamWriter {
FlushToFile(/*OnClosing=*/true);
}
+ /// For scenarios where the user wants to access a section of the stream to
+ /// (for example) compute some checksum, disable flushing and remember the
+ /// position in the internal buffer where that happened. Must be paired with a
+ /// call to getMarkedBufferAndResumeFlushing.
+ void markAndBlockFlushing() {
+ assert(!BlockFlushingStartPos);
+ BlockFlushingStartPos = Buffer.size();
+ }
+
+ /// resumes flushing, but does not flush, and returns the section in the
+ /// internal buffer starting from the position marked with
+ /// markAndBlockFlushing. The return should be processed before any additional
+ /// calls to this object, because those may cause a flush and invalidate the
+ /// return.
+ StringRef getMarkedBufferAndResumeFlushing() {
+ assert(BlockFlushingStartPos);
+ size_t Start = *BlockFlushingStartPos;
+ BlockFlushingStartPos.reset();
+ return {&Buffer[Start], Buffer.size() - Start};
+ }
+
/// Retrieve the current position in the stream, in bits.
uint64_t GetCurrentBitNo() const { return GetBufferOffset() * 8 + CurBit; }
@@ -151,16 +212,16 @@ class BitstreamWriter {
if (ByteNo >= NumOfFlushedBytes) {
assert((!endian::readAtBitAlignment<uint8_t, llvm::endianness::little,
unaligned>(
- &Out[ByteNo - NumOfFlushedBytes], StartBit)) &&
+ &Buffer[ByteNo - NumOfFlushedBytes], StartBit)) &&
"Expected to be patching over 0-value placeholders");
endian::writeAtBitAlignment<uint8_t, llvm::endianness::little, unaligned>(
- &Out[ByteNo - NumOfFlushedBytes], NewByte, StartBit);
+ &Buffer[ByteNo - NumOfFlushedBytes], NewByte, StartBit);
return;
}
// If the byte offset to backpatch is flushed, use seek to backfill data.
// First, save the file position to restore later.
- uint64_t CurPos = FS->tell();
+ uint64_t CurPos = fdStream()->tell();
// Copy data to update into Bytes from the file FS and the buffer Out.
char Bytes[3]; // Use one more byte to silence a warning from Visual C++.
@@ -169,19 +230,19 @@ class BitstreamWriter {
size_t BytesFromBuffer = BytesNum - BytesFromDisk;
// When unaligned, copy existing data into Bytes from the file FS and the
- // buffer Out so that it can be updated before writing. For debug builds
+ // buffer Buffer so that it can be updated before writing. For debug builds
// read bytes unconditionally in order to check that the existing value is 0
// as expected.
#ifdef NDEBUG
if (StartBit)
#endif
{
- FS->seek(ByteNo);
- ssize_t BytesRead = FS->read(Bytes, BytesFromDisk);
+ fdStream()->seek(ByteNo);
+ ssize_t BytesRead = fdStream()->read(Bytes, BytesFromDisk);
(void)BytesRead; // silence warning
assert(BytesRead >= 0 && static_cast<size_t>(BytesRead) == BytesFromDisk);
for (size_t i = 0; i < BytesFromBuffer; ++i)
- Bytes[BytesFromDisk + i] = Out[i];
+ Bytes[BytesFromDisk + i] = Buffer[i];
assert((!endian::readAtBitAlignment<uint8_t, llvm::endianness::little,
unaligned>(Bytes, StartBit)) &&
"Expected to be patching over 0-value placeholders");
@@ -192,13 +253,13 @@ class BitstreamWriter {
Bytes, NewByte, StartBit);
// Copy updated data back to the file FS and the buffer Out.
- FS->seek(ByteNo);
- FS->write(Bytes, BytesFromDisk);
+ fdStream()->seek(ByteNo);
+ fdStream()->write(Bytes, BytesFromDisk);
for (size_t i = 0; i < BytesFromBuffer; ++i)
- Out[i] = Bytes[BytesFromDisk + i];
+ Buffer[i] = Bytes[BytesFromDisk + i];
// Restore the file position.
- FS->seek(CurPos);
+ fdStream()->seek(CurPos);
}
void BackpatchHalfWord(uint64_t BitNo, uint16_t Val) {
@@ -491,11 +552,11 @@ class BitstreamWriter {
// Emit literal bytes.
assert(llvm::all_of(Bytes, [](UIntTy B) { return isUInt<8>(B); }));
- Out.append(Bytes.begin(), Bytes.end());
+ Buffer.append(Bytes.begin(), Bytes.end());
// Align end to 32-bits.
while (GetBufferOffset() & 3)
- Out.push_back(0);
+ Buffer.push_back(0);
}
void emitBlob(StringRef Bytes, bool ShouldEmitSize = true) {
emitBlob(ArrayRef((const uint8_t *)Bytes.data(), Bytes.size()),
diff --git a/llvm/include/llvm/ProfileData/PGOCtxProfWriter.h b/llvm/include/llvm/ProfileData/PGOCtxProfWriter.h
index edcf02c094697..e8b75d6f8cf4b 100644
--- a/llvm/include/llvm/ProfileData/PGOCtxProfWriter.h
+++ b/llvm/include/llvm/ProfileData/PGOCtxProfWriter.h
@@ -70,7 +70,7 @@ class PGOCtxProfileWriter final {
public:
PGOCtxProfileWriter(raw_fd_stream &Out,
std::optional<unsigned> VersionOverride = std::nullopt)
- : Writer(Buff, &Out, 0) {
+ : Writer(Out, 0) {
Writer.EnterSubblock(PGOCtxProfileBlockIDs::ProfileMetadataBlockID,
CodeLen);
const auto Version = VersionOverride ? *VersionOverride : CurrentVersion;
diff --git a/llvm/include/llvm/Support/raw_ostream.h b/llvm/include/llvm/Support/raw_ostream.h
index 696290a5d99cf..0951ffb19ffa1 100644
--- a/llvm/include/llvm/Support/raw_ostream.h
+++ b/llvm/include/llvm/Support/raw_ostream.h
@@ -55,6 +55,7 @@ class raw_ostream {
enum class OStreamKind {
OK_OStream,
OK_FDStream,
+ OK_SVecStream,
};
private:
@@ -703,7 +704,11 @@ class raw_svector_ostream : public raw_pwrite_stream {
///
/// \param O The vector to write to; this should generally have at least 128
/// bytes free to avoid any extraneous memory overhead.
- explicit raw_svector_ostream(SmallVectorImpl<char> &O) : OS(O) {
+ explicit raw_svector_ostream(SmallVectorImpl<char> &O)
+ : raw_pwrite_stream(false, raw_ostream::OStreamKind::OK_SVecStream),
+ OS(O) {
+ // FIXME: here and in a few other places, set directly to unbuffered in the
+ // ctor.
SetUnbuffered();
}
@@ -713,10 +718,13 @@ class raw_svector_ostream : public raw_pwrite_stream {
/// Return a StringRef for the vector contents.
StringRef str() const { return StringRef(OS.data(), OS.size()); }
+ SmallVectorImpl<char> &buffer() { return OS; }
void reserveExtraSpace(uint64_t ExtraSize) override {
OS.reserve(tell() + ExtraSize);
}
+
+ static bool classof(const raw_ostream *OS);
};
/// A raw_ostream that discards all output.
diff --git a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
index 86c4293afb95d..00e280356db7c 100644
--- a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
+++ b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
@@ -260,9 +260,6 @@ class ModuleBitcodeWriterBase : public BitcodeWriterBase {
/// Class to manage the bitcode writing for a module.
class ModuleBitcodeWriter : public ModuleBitcodeWriterBase {
- /// Pointer to the buffer allocated by caller for bitcode writing.
- const SmallVectorImpl<char> &Buffer;
-
/// True if a module hash record should be written.
bool GenerateHash;
@@ -278,14 +275,13 @@ class ModuleBitcodeWriter : public ModuleBitcodeWriterBase {
public:
/// Constructs a ModuleBitcodeWriter object for the given Module,
/// writing to the provided \p Buffer.
- ModuleBitcodeWriter(const Module &M, SmallVectorImpl<char> &Buffer,
- StringTableBuilder &StrtabBuilder,
+ ModuleBitcodeWriter(const Module &M, StringTableBuilder &StrtabBuilder,
BitstreamWriter &Stream, bool ShouldPreserveUseListOrder,
const ModuleSummaryIndex *Index, bool GenerateHash,
ModuleHash *ModHash = nullptr)
: ModuleBitcodeWriterBase(M, StrtabBuilder, Stream,
ShouldPreserveUseListOrder, Index),
- Buffer(Buffer), GenerateHash(GenerateHash), ModHash(ModHash),
+ GenerateHash(GenerateHash), ModHash(ModHash),
BitcodeStartBit(Stream.GetCurrentBitNo()) {}
/// Emit the current module to the bitstream.
@@ -414,7 +410,7 @@ class ModuleBitcodeWriter : public ModuleBitcodeWriterBase {
writeFunction(const Function &F,
DenseMap<const Function *, uint64_t> &FunctionToBitcodeIndex);
void writeBlockInfo();
- void writeModuleHash(size_t BlockStartPos);
+ void writeModuleHash(StringRef View);
unsigned getEncodedSyncScopeID(SyncScope::ID SSID) {
return unsigned(SSID);
@@ -4787,13 +4783,13 @@ static void writeIdentificationBlock(BitstreamWriter &Stream) {
Stream.ExitBlock();
}
-void ModuleBitcodeWriter::writeModuleHash(size_t BlockStartPos) {
+void ModuleBitcodeWriter::writeModuleHash(StringRef View) {
// Emit the module's hash.
// MODULE_CODE_HASH: [5*i32]
if (GenerateHash) {
uint32_t Vals[5];
- Hasher.update(ArrayRef<uint8_t>((const uint8_t *)&(Buffer)[BlockStartPos],
- Buffer.size() - BlockStartPos));
+ Hasher.update(ArrayRef<uint8_t>(
+ reinterpret_cast<const uint8_t *>(View.data()), View.size()));
std::array<uint8_t, 20> Hash = Hasher.result();
for (int Pos = 0; Pos < 20; Pos += 4) {
Vals[Pos / 4] = support::endian::read32be(Hash.data() + Pos);
@@ -4812,7 +4808,9 @@ void ModuleBitcodeWriter::write() {
writeIdentificationBlock(Stream);
Stream.EnterSubblock(bitc::MODULE_BLOCK_ID, 3);
- size_t BlockStartPos = Buffer.size();
+ // We will want to write the module hash at this point. Block any flushing so
+ // we can have access to the whole underlying data later.
+ Stream.markAndBlockFlushing();
writeModuleVersion();
@@ -4863,7 +4861,7 @@ void ModuleBitcodeWriter::write() {
writeGlobalValueSymbolTable(FunctionToBitcodeIndex);
- writeModuleHash(BlockStartPos);
+ writeModuleHash(Stream.getMarkedBufferAndResumeFlushing());
Stream.ExitBlock();
}
@@ -4944,8 +4942,13 @@ static void writeBitcodeHeader(BitstreamWriter &Stream) {
Stream.Emit(0xD, 4);
}
-BitcodeWriter::BitcodeWriter(SmallVectorImpl<char> &Buffer, raw_fd_stream *FS)
- : Buffer(Buffer), Stream(new BitstreamWriter(Buffer, FS, FlushThreshold)) {
+BitcodeWriter::BitcodeWriter(SmallVectorImpl<char> &Buffer)
+ : Stream(new BitstreamWriter(Buffer)) {
+ writeBitcodeHeader(*Stream);
+}
+
+BitcodeWriter::BitcodeWriter(raw_ostream &FS)
+ : Stream(new BitstreamWriter(FS, FlushThreshold)) {
writeBitcodeHeader(*Stream);
}
@@ -5028,7 +5031,7 @@ void BitcodeWriter::writeModule(const Module &M,
assert(M.isMaterialized());
Mods.push_back(const_cast<Module *>(&M));
- ModuleBitcodeWriter ModuleWriter(M, Buffer, StrtabBuilder, *Stream,
+ ModuleBitcodeWriter ModuleWriter(M, StrtabBuilder, *Stream,
ShouldPreserveUseListOrder, Index,
GenerateHash, ModHash);
ModuleWriter.write();
@@ -5047,27 +5050,28 @@ void llvm::WriteBitcodeToFile(const Module &M, raw_ostream &Out,
bool ShouldPreserveUseListOrder,
const ModuleSummaryIndex *Index,
bool GenerateHash, ModuleHash *ModHash) {
- SmallVector<char, 0> Buffer;
- Buffer.reserve(256*1024);
-
- // If this is darwin or another generic macho target, reserve space for the
- // header.
- Triple TT(M.getTargetTriple());
- if (TT.isOSDarwin() || TT.isOSBinFormatMachO())
- Buffer.insert(Buffer.begin(), BWH_HeaderSize, 0);
- {
- BitcodeWriter Writer(Buffer, dyn_cast<raw_fd_stream>(&Out));
+ auto Write = [&](BitcodeWriter &Writer) {
Writer.writeModule(M, ShouldPreserveUseListOrder, Index, GenerateHash,
ModHash);
Writer.writeSymtab();
Writer.writeStrtab();
- }
- if (TT.isOSDarwin() || TT.isOSBinFormatMachO())
+ };
+ Triple TT(M.getTargetTriple());
+ if (TT.isOSDarwin() || TT.isOSBinFormatMachO()) {
+ // If this is darwin or another generic macho target, reserve space for the
+ // header. Note that the header is computed *after* the output is known, so
+ // we currently expliclty use a buffer, write to it, and then subsequently
+ // flush to Out.
+ SmallVector<char, 256 * 1024> Buffer;
+ Buffer.insert(Buffer.begin(), BWH_HeaderSize, 0);
+ BitcodeWriter Writer(Buffer);
+ Write(Writer);
emitDarwinBCHeaderAndTrailer(Buffer, TT);
-
- // Write the generated bitstream to "Out".
- if (!Buffer.empty())
- Out.write((char *)&Buffer.front(), Buffer.size());
+ Out.write(Buffer.data(), Buffer.size());
+ } else {
+ BitcodeWriter Writer(Out);
+ Write(Writer);
+ }
}
void IndexBitcodeWriter::write() {
diff --git a/llvm/lib/Support/raw_ostream.cpp b/llvm/lib/Support/raw_ostream.cpp
index 8cb7b5ac68ea7..e8d12357bfded 100644
--- a/llvm/lib/Support/raw_ostream.cpp
+++ b/llvm/lib/Support/raw_ostream.cpp
@@ -977,6 +977,10 @@ void raw_svector_ostream::pwrite_impl(const char *Ptr, size_t Size,
memcpy(OS.data() + Offset, Ptr, Size);
}
+bool raw_svector_ostream::classof(const raw_ostream *OS) {
+ return OS->get_kind() == OStreamKind::OK_SVecStream;
+}
+
//===----------------------------------------------------------------------===//
// raw_null_ostream
//===----------------------------------------------------------------------===//
diff --git a/llvm/unittests/Bitstream/BitstreamWriterTest.cpp b/llvm/unittests/Bitstream/BitstreamWriterTest.cpp
index 096363190af4a..933965abdbadf 100644
--- a/llvm/unittests/Bitstream/BitstreamWriterTest.cpp
+++ b/llvm/unittests/Bitstream/BitstreamWriterTest.cpp
@@ -69,11 +69,10 @@ class BitstreamWriterFlushTest : public ::testing::TestWithParam<int> {
void write(StringRef TestFilePath, int FlushThreshold,
llvm::function_ref<void(BitstreamWriter &)> Action) {
- SmallString<64> Buffer;
std::error_code EC;
raw_fd_stream Out(TestFilePath, EC);
ASSERT_FALSE(EC);
- BitstreamWriter W(Buffer, &Out, FlushThreshold);
+ BitstreamWriter W(Out, FlushThreshold);
Action(W);
}
};
>From 4ca8bc974f4793913697641bd7a78fb73797b3b4 Mon Sep 17 00:00:00 2001
From: Mircea Trofin <mtrofin at google.com>
Date: Wed, 29 May 2024 08:42:23 -0700
Subject: [PATCH 6/8] redo
---
llvm/include/llvm/Bitstream/BitstreamWriter.h | 11 ++++-------
1 file changed, 4 insertions(+), 7 deletions(-)
diff --git a/llvm/include/llvm/Bitstream/BitstreamWriter.h b/llvm/include/llvm/Bitstream/BitstreamWriter.h
index 96ffec0a590d7..b3bee328beaa8 100644
--- a/llvm/include/llvm/Bitstream/BitstreamWriter.h
+++ b/llvm/include/llvm/Bitstream/BitstreamWriter.h
@@ -146,14 +146,11 @@ class BitstreamWriter {
/// directly to the latter's buffer. In all other cases, the BitstreamWriter
/// will use an internal buffer and flush at the end of its lifetime.
///
- /// If \p is a raw_fd_stream, the BitstreamWriter will also flush
- /// incrementally, when a subblock is finished, and if the FlushThreshold is
- /// passed.
+ /// In addition, if \p is a raw_fd_stream supporting seek, tell, and read
+ /// (besides write), the BitstreamWriter will also flush incrementally, when a
+ /// subblock is finished, and if the FlushThreshold is passed.
///
- /// NOTES:
- /// - \p FlushThreshold's unit is MB.
- /// - \p FS is expected to support seek, tell, and read (besides write).
-
+ /// NOTE: \p FlushThreshold's unit is MB.
BitstreamWriter(raw_ostream &OutStream, uint32_t FlushThreshold = 512)
: Buffer(getInternalBufferFromStream(OutStream)),
FS(!isa<raw_svector_ostream>(OutStream) ? &OutStream : nullptr),
>From ffeae3a110dc4ec3ba7eebc7f18903dbd356c80f Mon Sep 17 00:00:00 2001
From: Mircea Trofin <mtrofin at google.com>
Date: Wed, 29 May 2024 14:01:57 -0700
Subject: [PATCH 7/8] feedback
---
llvm/include/llvm/Bitstream/BitstreamWriter.h | 7 ++++++-
llvm/lib/Bitcode/Writer/BitcodeWriter.cpp | 2 +-
2 files changed, 7 insertions(+), 2 deletions(-)
diff --git a/llvm/include/llvm/Bitstream/BitstreamWriter.h b/llvm/include/llvm/Bitstream/BitstreamWriter.h
index b3bee328beaa8..78f5eb4f364b6 100644
--- a/llvm/include/llvm/Bitstream/BitstreamWriter.h
+++ b/llvm/include/llvm/Bitstream/BitstreamWriter.h
@@ -32,7 +32,9 @@ class BitstreamWriter {
/// Owned buffer, used to init Buffer if the provided stream doesn't happen to
/// be a buffer itself.
SmallVector<char, 0> OwnBuffer;
- /// Internal buffer. The writer backpatches, so it is efficient to buffer.
+ /// Internal buffer for unflushed bytes (unless there is no stream to flush
+ /// to, case in which these are "the bytes"). The writer backpatches, so it is
+ /// efficient to buffer.
SmallVectorImpl<char> &Buffer;
/// FS - The file stream that Buffer flushes to. If FS is a raw_fd_stream, the
@@ -216,6 +218,9 @@ class BitstreamWriter {
return;
}
+ // If we don't have a raw_fd_stream, GetNumOfFlushedBytes() should have
+ // returned 0, and we shouldn't be here.
+ assert(fdStream() != nullptr);
// If the byte offset to backpatch is flushed, use seek to backfill data.
// First, save the file position to restore later.
uint64_t CurPos = fdStream()->tell();
diff --git a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
index 5020cf522df5b..7ed3dbbefe5b2 100644
--- a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
+++ b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
@@ -5093,7 +5093,7 @@ void llvm::WriteBitcodeToFile(const Module &M, raw_ostream &Out,
if (TT.isOSDarwin() || TT.isOSBinFormatMachO()) {
// If this is darwin or another generic macho target, reserve space for the
// header. Note that the header is computed *after* the output is known, so
- // we currently expliclty use a buffer, write to it, and then subsequently
+ // we currently explicilty use a buffer, write to it, and then subsequently
// flush to Out.
SmallVector<char, 256 * 1024> Buffer;
Buffer.insert(Buffer.begin(), BWH_HeaderSize, 0);
>From 2ccd3b5ef73eb2803aca8fe330b6d77f9121fda7 Mon Sep 17 00:00:00 2001
From: Mircea Trofin <mtrofin at google.com>
Date: Thu, 30 May 2024 10:32:32 -0700
Subject: [PATCH 8/8] typo
---
llvm/lib/Bitcode/Writer/BitcodeWriter.cpp | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
index 7ed3dbbefe5b2..7d39c0db79fb1 100644
--- a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
+++ b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
@@ -5093,7 +5093,7 @@ void llvm::WriteBitcodeToFile(const Module &M, raw_ostream &Out,
if (TT.isOSDarwin() || TT.isOSBinFormatMachO()) {
// If this is darwin or another generic macho target, reserve space for the
// header. Note that the header is computed *after* the output is known, so
- // we currently explicilty use a buffer, write to it, and then subsequently
+ // we currently explicitly use a buffer, write to it, and then subsequently
// flush to Out.
SmallVector<char, 256 * 1024> Buffer;
Buffer.insert(Buffer.begin(), BWH_HeaderSize, 0);
More information about the llvm-commits
mailing list