diff --git a/clang-tools-extra/clang-doc/Serialize.cpp b/clang-tools-extra/clang-doc/Serialize.cpp
--- a/clang-tools-extra/clang-doc/Serialize.cpp
+++ b/clang-tools-extra/clang-doc/Serialize.cpp
@@ -14,6 +14,8 @@
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/SHA1.h"
 
+#include <vector>
+
 using clang::comments::FullComment;
 
 namespace clang {
@@ -180,11 +182,12 @@
 // Serializing functions.
 
 template <typename T> static std::string serialize(T &I) {
-  SmallString<2048> Buffer;
+  std::vector<char> Buffer;
   llvm::BitstreamWriter Stream(Buffer);
   ClangDocBitcodeWriter Writer(Stream);
   Writer.emitBlock(I);
-  return Buffer.str().str();
+  std::string Result(Buffer.data(), Buffer.size());
+  return Result;
 }
 
 std::string serialize(std::unique_ptr<Info> &I) {
diff --git a/clang-tools-extra/unittests/clang-doc/BitcodeTest.cpp b/clang-tools-extra/unittests/clang-doc/BitcodeTest.cpp
--- a/clang-tools-extra/unittests/clang-doc/BitcodeTest.cpp
+++ b/clang-tools-extra/unittests/clang-doc/BitcodeTest.cpp
@@ -18,11 +18,13 @@
 namespace doc {
 
 template <typename T> static std::string writeInfo(T &I) {
-  SmallString<2048> Buffer;
+  std::vector<char> Buffer;
+  Buffer.reserve(2048);
   llvm::BitstreamWriter Stream(Buffer);
   ClangDocBitcodeWriter Writer(Stream);
   Writer.emitBlock(I);
-  return Buffer.str().str();
+  std::string Result(Buffer.data(), Buffer.size());
+  return Result;
 }
 
 std::string writeInfo(Info *I) {
diff --git a/clang/include/clang/Serialization/ASTWriter.h b/clang/include/clang/Serialization/ASTWriter.h
--- a/clang/include/clang/Serialization/ASTWriter.h
+++ b/clang/include/clang/Serialization/ASTWriter.h
@@ -120,7 +120,7 @@
   llvm::BitstreamWriter &Stream;
 
   /// The buffer associated with the bitstream.
-  const SmallVectorImpl<char> &Buffer;
+  const std::vector<char> &Buffer;
 
   /// The PCM manager which manages memory buffers for pcm files.
   InMemoryModuleCache &ModuleCache;
@@ -534,7 +534,7 @@
 public:
   /// Create a new precompiled header writer that outputs to
   /// the given bitstream.
-  ASTWriter(llvm::BitstreamWriter &Stream, SmallVectorImpl<char> &Buffer,
+  ASTWriter(llvm::BitstreamWriter &Stream, std::vector<char> &Buffer,
             InMemoryModuleCache &ModuleCache,
             ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions,
             bool IncludeTimestamps = true);
@@ -753,7 +753,7 @@
 protected:
   ASTWriter &getWriter() { return Writer; }
   const ASTWriter &getWriter() const { return Writer; }
-  SmallVectorImpl<char> &getPCH() const { return Buffer->Data; }
+  std::vector<char> &getPCH() const { return Buffer->Data; }
 
 public:
   PCHGenerator(const Preprocessor &PP, InMemoryModuleCache &ModuleCache,
diff --git a/clang/include/clang/Serialization/PCHContainerOperations.h b/clang/include/clang/Serialization/PCHContainerOperations.h
--- a/clang/include/clang/Serialization/PCHContainerOperations.h
+++ b/clang/include/clang/Serialization/PCHContainerOperations.h
@@ -10,10 +10,10 @@
 #define LLVM_CLANG_SERIALIZATION_PCHCONTAINEROPERATIONS_H
 
 #include "clang/Basic/Module.h"
-#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include <memory>
+#include <vector>
 
 namespace llvm {
 class raw_pwrite_stream;
@@ -28,7 +28,7 @@
 
 struct PCHBuffer {
   ASTFileSignature Signature;
-  llvm::SmallVector<char, 0> Data;
+  std::vector<char> Data;
   bool IsComplete;
 };
 
diff --git a/clang/lib/CodeGen/ObjectFilePCHContainerOperations.cpp b/clang/lib/CodeGen/ObjectFilePCHContainerOperations.cpp
--- a/clang/lib/CodeGen/ObjectFilePCHContainerOperations.cpp
+++ b/clang/lib/CodeGen/ObjectFilePCHContainerOperations.cpp
@@ -308,7 +308,7 @@
                              std::move(OS));
 
     // Free the memory for the temporary buffer.
-    llvm::SmallVector<char, 0> Empty;
+    std::vector<char> Empty;
     SerializedAST = std::move(Empty);
   }
 };
diff --git a/clang/lib/Frontend/ASTUnit.cpp b/clang/lib/Frontend/ASTUnit.cpp
--- a/clang/lib/Frontend/ASTUnit.cpp
+++ b/clang/lib/Frontend/ASTUnit.cpp
@@ -215,12 +215,14 @@
 }
 
 struct ASTUnit::ASTWriterData {
-  SmallString<128> Buffer;
+  std::vector<char> Buffer;
   llvm::BitstreamWriter Stream;
   ASTWriter Writer;
 
   ASTWriterData(InMemoryModuleCache &ModuleCache)
-      : Stream(Buffer), Writer(Stream, Buffer, ModuleCache, {}) {}
+      : Stream(Buffer), Writer(Stream, Buffer, ModuleCache, {}) {
+    Buffer.reserve(128);
+  }
 };
 
 void ASTUnit::clearFileLevelDecls() {
@@ -2322,11 +2324,8 @@
   return false;
 }
 
-static bool serializeUnit(ASTWriter &Writer,
-                          SmallVectorImpl<char> &Buffer,
-                          Sema &S,
-                          bool hasErrors,
-                          raw_ostream &OS) {
+static bool serializeUnit(ASTWriter &Writer, std::vector<char> &Buffer, Sema &S,
+                          bool hasErrors, raw_ostream &OS) {
   Writer.WriteAST(S, std::string(), nullptr, "", hasErrors);
 
   // Write the generated bitstream to "Out".
@@ -2344,7 +2343,8 @@
     return serializeUnit(WriterData->Writer, WriterData->Buffer,
                          getSema(), hasErrors, OS);
 
-  SmallString<128> Buffer;
+  std::vector<char> Buffer;
+  Buffer.reserve(128);
   llvm::BitstreamWriter Stream(Buffer);
   InMemoryModuleCache ModuleCache;
   ASTWriter Writer(Stream, Buffer, ModuleCache, {});
diff --git a/clang/lib/Frontend/PrecompiledPreamble.cpp b/clang/lib/Frontend/PrecompiledPreamble.cpp
--- a/clang/lib/Frontend/PrecompiledPreamble.cpp
+++ b/clang/lib/Frontend/PrecompiledPreamble.cpp
@@ -179,12 +179,13 @@
       return;
 
     // Write the generated bitstream to "Out".
-    *Out << getPCH();
+    std::vector<char> &PCHBuffer = getPCH();
+    Out->write(PCHBuffer.data(), PCHBuffer.size());
     // Make sure it hits disk now.
     Out->flush();
     // Free the buffer.
-    llvm::SmallVector<char, 0> Empty;
-    getPCH() = std::move(Empty);
+    std::vector<char> Empty;
+    PCHBuffer = std::move(Empty);
 
     Action.setEmittedPreamblePCH(getWriter());
   }
diff --git a/clang/lib/Frontend/SerializedDiagnosticPrinter.cpp b/clang/lib/Frontend/SerializedDiagnosticPrinter.cpp
--- a/clang/lib/Frontend/SerializedDiagnosticPrinter.cpp
+++ b/clang/lib/Frontend/SerializedDiagnosticPrinter.cpp
@@ -25,6 +25,7 @@
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/raw_ostream.h"
 #include <utility>
+#include <vector>
 
 using namespace clang;
 using namespace clang::serialized_diags;
@@ -244,13 +245,15 @@
   struct SharedState {
     SharedState(StringRef File, DiagnosticOptions *Diags)
         : DiagOpts(Diags), Stream(Buffer), OutputFile(File.str()),
-          EmittedAnyDiagBlocks(false) {}
+          EmittedAnyDiagBlocks(false) {
+      Buffer.reserve(1024);
+    }
 
     /// Diagnostic options.
     IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts;
 
     /// The byte buffer for the serialized content.
-    SmallString<1024> Buffer;
+    std::vector<char> Buffer;
 
     /// The BitStreamWriter for the serialized diagnostics.
     llvm::BitstreamWriter Stream;
diff --git a/clang/lib/Serialization/ASTWriter.cpp b/clang/lib/Serialization/ASTWriter.cpp
--- a/clang/lib/Serialization/ASTWriter.cpp
+++ b/clang/lib/Serialization/ASTWriter.cpp
@@ -1038,7 +1038,8 @@
   ASTFileSignature Signature;
   if (WritingModule &&
       PP.getHeaderSearchInfo().getHeaderSearchOpts().ModulesHashContent) {
-    Signature = createSignature(StringRef(Buffer.begin(), StartOfUnhashedControl));
+    Signature =
+        createSignature(StringRef(Buffer.data(), StartOfUnhashedControl));
     Record.append(Signature.begin(), Signature.end());
     Stream.EmitRecord(SIGNATURE, Record);
     Record.clear();
@@ -4284,8 +4285,7 @@
   SelectorOffsets[ID - FirstSelectorID] = Offset;
 }
 
-ASTWriter::ASTWriter(llvm::BitstreamWriter &Stream,
-                     SmallVectorImpl<char> &Buffer,
+ASTWriter::ASTWriter(llvm::BitstreamWriter &Stream, std::vector<char> &Buffer,
                      InMemoryModuleCache &ModuleCache,
                      ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions,
                      bool IncludeTimestamps)
@@ -4342,7 +4342,7 @@
     // Construct MemoryBuffer and update buffer manager.
     ModuleCache.addBuiltPCM(OutputFile,
                             llvm::MemoryBuffer::getMemBufferCopy(
-                                StringRef(Buffer.begin(), Buffer.size())));
+                                StringRef(Buffer.data(), Buffer.size())));
   }
   return Signature;
 }
diff --git a/clang/lib/Serialization/GlobalModuleIndex.cpp b/clang/lib/Serialization/GlobalModuleIndex.cpp
--- a/clang/lib/Serialization/GlobalModuleIndex.cpp
+++ b/clang/lib/Serialization/GlobalModuleIndex.cpp
@@ -906,7 +906,8 @@
   }
 
   // The output buffer, into which the global index will be written.
-  SmallVector<char, 16> OutputBuffer;
+  std::vector<char> OutputBuffer;
+  OutputBuffer.reserve(16);
   {
     llvm::BitstreamWriter OutputStream(OutputBuffer);
     if (Builder.writeIndex(OutputStream))
diff --git a/clang/lib/Serialization/PCHContainerOperations.cpp b/clang/lib/Serialization/PCHContainerOperations.cpp
--- a/clang/lib/Serialization/PCHContainerOperations.cpp
+++ b/clang/lib/Serialization/PCHContainerOperations.cpp
@@ -39,11 +39,11 @@
   void HandleTranslationUnit(ASTContext &Ctx) override {
     if (Buffer->IsComplete) {
       // Make sure it hits disk now.
-      *OS << Buffer->Data;
+      OS->write(Buffer->Data.data(), Buffer->Data.size());
       OS->flush();
     }
     // Free the space of the temporary buffer.
-    llvm::SmallVector<char, 0> Empty;
+    std::vector<char> Empty;
     Buffer->Data = std::move(Empty);
   }
 };
diff --git a/llvm/include/llvm/Bitcode/BitcodeWriter.h b/llvm/include/llvm/Bitcode/BitcodeWriter.h
--- a/llvm/include/llvm/Bitcode/BitcodeWriter.h
+++ b/llvm/include/llvm/Bitcode/BitcodeWriter.h
@@ -30,7 +30,7 @@
 class raw_ostream;
 
   class BitcodeWriter {
-    SmallVectorImpl<char> &Buffer;
+    std::vector<char> &Buffer;
     std::unique_ptr<BitstreamWriter> Stream;
 
     StringTableBuilder StrtabBuilder{StringTableBuilder::RAW};
@@ -47,7 +47,7 @@
 
   public:
     /// Create a BitcodeWriter that writes to Buffer.
-    BitcodeWriter(SmallVectorImpl<char> &Buffer);
+    BitcodeWriter(std::vector<char> &Buffer);
 
     ~BitcodeWriter();
 
diff --git a/llvm/include/llvm/Bitstream/BitstreamWriter.h b/llvm/include/llvm/Bitstream/BitstreamWriter.h
--- a/llvm/include/llvm/Bitstream/BitstreamWriter.h
+++ b/llvm/include/llvm/Bitstream/BitstreamWriter.h
@@ -25,7 +25,7 @@
 namespace llvm {
 
 class BitstreamWriter {
-  SmallVectorImpl<char> &Out;
+  std::vector<char> &Out;
 
   /// CurBit - Always between 0 and 31 inclusive, specifies the next bit to use.
   unsigned CurBit;
@@ -68,7 +68,7 @@
 
   void WriteWord(unsigned Value) {
     Value = support::endian::byte_swap<uint32_t, support::little>(Value);
-    Out.append(reinterpret_cast<const char *>(&Value),
+    Out.insert(Out.end(), reinterpret_cast<const char *>(&Value),
                reinterpret_cast<const char *>(&Value + 1));
   }
 
@@ -81,8 +81,8 @@
   }
 
 public:
-  explicit BitstreamWriter(SmallVectorImpl<char> &O)
-    : Out(O), CurBit(0), CurValue(0), CurCodeSize(2) {}
+  explicit BitstreamWriter(std::vector<char> &O)
+      : Out(O), CurBit(0), CurValue(0), CurCodeSize(2) {}
 
   ~BitstreamWriter() {
     assert(CurBit == 0 && "Unflushed data remaining");
diff --git a/llvm/include/llvm/Remarks/BitstreamRemarkSerializer.h b/llvm/include/llvm/Remarks/BitstreamRemarkSerializer.h
--- a/llvm/include/llvm/Remarks/BitstreamRemarkSerializer.h
+++ b/llvm/include/llvm/Remarks/BitstreamRemarkSerializer.h
@@ -49,7 +49,7 @@
 struct BitstreamRemarkSerializerHelper {
   /// Buffer used for encoding the bitstream before writing it to the final
   /// stream.
-  SmallVector<char, 1024> Encoded;
+  std::vector<char> Encoded;
   /// Buffer used to construct records and pass to the bitstream writer.
   SmallVector<uint64_t, 64> R;
   /// The Bitstream writer.
diff --git a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
--- a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
+++ b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
@@ -244,7 +244,7 @@
 /// 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;
+  const std::vector<char> &Buffer;
 
   /// True if a module hash record should be written.
   bool GenerateHash;
@@ -261,7 +261,7 @@
 public:
   /// Constructs a ModuleBitcodeWriter object for the given Module,
   /// writing to the provided \p Buffer.
-  ModuleBitcodeWriter(const Module &M, SmallVectorImpl<char> &Buffer,
+  ModuleBitcodeWriter(const Module &M, std::vector<char> &Buffer,
                       StringTableBuilder &StrtabBuilder,
                       BitstreamWriter &Stream, bool ShouldPreserveUseListOrder,
                       const ModuleSummaryIndex *Index, bool GenerateHash,
@@ -2007,7 +2007,8 @@
   Record.push_back(Strings.size());
 
   // Emit the sizes of the strings in the blob.
-  SmallString<256> Blob;
+  std::vector<char> Blob;
+  Blob.reserve(256);
   {
     BitstreamWriter W(Blob);
     for (const Metadata *MD : Strings)
@@ -2019,11 +2020,14 @@
   Record.push_back(Blob.size());
 
   // Add the strings to the blob.
-  for (const Metadata *MD : Strings)
-    Blob.append(cast<MDString>(MD)->getString());
+  for (const Metadata *MD : Strings) {
+    StringRef MDStr = cast<MDString>(MD)->getString();
+    Blob.insert(Blob.end(), MDStr.begin(), MDStr.end());
+  }
 
   // Emit the final record.
-  Stream.EmitRecordWithBlob(createMetadataStringsAbbrev(), Record, Blob);
+  StringRef BlobStr(Blob.data(), Blob.size());
+  Stream.EmitRecordWithBlob(createMetadataStringsAbbrev(), Record, BlobStr);
   Record.clear();
 }
 
@@ -4290,7 +4294,7 @@
   Stream.ExitBlock();
 }
 
-static void writeInt32ToBuffer(uint32_t Value, SmallVectorImpl<char> &Buffer,
+static void writeInt32ToBuffer(uint32_t Value, std::vector<char> &Buffer,
                                uint32_t &Position) {
   support::endian::write32le(&Buffer[Position], Value);
   Position += 4;
@@ -4309,7 +4313,7 @@
 ///   uint32_t CPUType;       // CPU specifier.
 ///   ... potentially more later ...
 /// };
-static void emitDarwinBCHeaderAndTrailer(SmallVectorImpl<char> &Buffer,
+static void emitDarwinBCHeaderAndTrailer(std::vector<char> &Buffer,
                                          const Triple &TT) {
   unsigned CPUType = ~0U;
 
@@ -4366,7 +4370,7 @@
   Stream.Emit(0xD, 4);
 }
 
-BitcodeWriter::BitcodeWriter(SmallVectorImpl<char> &Buffer)
+BitcodeWriter::BitcodeWriter(std::vector<char> &Buffer)
     : Buffer(Buffer), Stream(new BitstreamWriter(Buffer)) {
   writeBitcodeHeader(*Stream);
 }
@@ -4469,7 +4473,7 @@
                               bool ShouldPreserveUseListOrder,
                               const ModuleSummaryIndex *Index,
                               bool GenerateHash, ModuleHash *ModHash) {
-  SmallVector<char, 0> Buffer;
+  std::vector<char> Buffer;
   Buffer.reserve(256*1024);
 
   // If this is darwin or another generic macho target, reserve space for the
@@ -4512,7 +4516,7 @@
 void llvm::WriteIndexToFile(
     const ModuleSummaryIndex &Index, raw_ostream &Out,
     const std::map<std::string, GVSummaryMapTy> *ModuleToSummariesForIndex) {
-  SmallVector<char, 0> Buffer;
+  std::vector<char> Buffer;
   Buffer.reserve(256 * 1024);
 
   BitcodeWriter Writer(Buffer);
@@ -4672,7 +4676,7 @@
 void llvm::WriteThinLinkBitcodeToFile(const Module &M, raw_ostream &Out,
                                       const ModuleSummaryIndex &Index,
                                       const ModuleHash &ModHash) {
-  SmallVector<char, 0> Buffer;
+  std::vector<char> Buffer;
   Buffer.reserve(256 * 1024);
 
   BitcodeWriter Writer(Buffer);
diff --git a/llvm/lib/ExecutionEngine/Orc/ThreadSafeModule.cpp b/llvm/lib/ExecutionEngine/Orc/ThreadSafeModule.cpp
--- a/llvm/lib/ExecutionEngine/Orc/ThreadSafeModule.cpp
+++ b/llvm/lib/ExecutionEngine/Orc/ThreadSafeModule.cpp
@@ -24,7 +24,7 @@
     ShouldCloneDef = [](const GlobalValue &) { return true; };
 
   return TSM.withModuleDo([&](Module &M) {
-    SmallVector<char, 1> ClonedModuleBuffer;
+    std::vector<char> ClonedModuleBuffer;
 
     {
       std::set<GlobalValue *> ClonedDefsInSrc;
diff --git a/llvm/lib/Transforms/IPO/ThinLTOBitcodeWriter.cpp b/llvm/lib/Transforms/IPO/ThinLTOBitcodeWriter.cpp
--- a/llvm/lib/Transforms/IPO/ThinLTOBitcodeWriter.cpp
+++ b/llvm/lib/Transforms/IPO/ThinLTOBitcodeWriter.cpp
@@ -397,7 +397,7 @@
   ModuleSummaryIndex MergedMIndex =
       buildModuleSummaryIndex(*MergedM, nullptr, &PSI);
 
-  SmallVector<char, 0> Buffer;
+  std::vector<char> Buffer;
 
   BitcodeWriter W(Buffer);
   // Save the module hash produced for the full bitcode, which will
@@ -409,7 +409,7 @@
   W.writeModule(*MergedM, /*ShouldPreserveUseListOrder=*/false, &MergedMIndex);
   W.writeSymtab();
   W.writeStrtab();
-  OS << Buffer;
+  OS.write(Buffer.data(), Buffer.size());
 
   // If a minimized bitcode module was requested for the thin link, only
   // the information that is needed by thin link will be written in the
@@ -423,7 +423,7 @@
                    &MergedMIndex);
     W2.writeSymtab();
     W2.writeStrtab();
-    *ThinLinkOS << Buffer;
+    ThinLinkOS->write(Buffer.data(), Buffer.size());
   }
 }
 
diff --git a/llvm/tools/llvm-cat/llvm-cat.cpp b/llvm/tools/llvm-cat/llvm-cat.cpp
--- a/llvm/tools/llvm-cat/llvm-cat.cpp
+++ b/llvm/tools/llvm-cat/llvm-cat.cpp
@@ -54,7 +54,7 @@
   ExitOnError ExitOnErr("llvm-cat: ");
   LLVMContext Context;
 
-  SmallVector<char, 0> Buffer;
+  std::vector<char> Buffer;
   BitcodeWriter Writer(Buffer);
   if (BinaryCat) {
     for (const auto &InputFilename : InputFilenames) {
diff --git a/llvm/tools/llvm-modextract/llvm-modextract.cpp b/llvm/tools/llvm-modextract/llvm-modextract.cpp
--- a/llvm/tools/llvm-modextract/llvm-modextract.cpp
+++ b/llvm/tools/llvm-modextract/llvm-modextract.cpp
@@ -58,12 +58,12 @@
   ExitOnErr(errorCodeToError(EC));
 
   if (BinaryExtract) {
-    SmallVector<char, 0> Result;
+    std::vector<char> Result;
     BitcodeWriter Writer(Result);
-    Result.append(Ms[ModuleIndex].getBuffer().begin(),
+    Result.insert(Result.end(), Ms[ModuleIndex].getBuffer().begin(),
                   Ms[ModuleIndex].getBuffer().end());
     Writer.copyStrtab(Ms[ModuleIndex].getStrtab());
-    Out->os() << Result;
+    Out->os().write(Result.data(), Result.size());
     Out->keep();
     return 0;
   }
diff --git a/llvm/unittests/Bitstream/BitstreamReaderTest.cpp b/llvm/unittests/Bitstream/BitstreamReaderTest.cpp
--- a/llvm/unittests/Bitstream/BitstreamReaderTest.cpp
+++ b/llvm/unittests/Bitstream/BitstreamReaderTest.cpp
@@ -11,6 +11,8 @@
 #include "llvm/Bitstream/BitstreamWriter.h"
 #include "gtest/gtest.h"
 
+#include <vector>
+
 using namespace llvm;
 
 namespace {
@@ -96,7 +98,7 @@
     StringRef BlobIn((const char *)BlobData.begin(), BlobSize);
 
     // Write the bitcode.
-    SmallVector<char, 1> Buffer;
+    std::vector<char> Buffer;
     unsigned AbbrevID;
     {
       BitstreamWriter Stream(Buffer);
@@ -115,7 +117,7 @@
 
     // Stream the buffer into the reader.
     BitstreamCursor Stream(
-        ArrayRef<uint8_t>((const uint8_t *)Buffer.begin(), Buffer.size()));
+        ArrayRef<uint8_t>((const uint8_t *)Buffer.data(), Buffer.size()));
 
     // Header.  Included in test so that we can run llvm-bcanalyzer to debug
     // when there are problems.
diff --git a/llvm/unittests/Bitstream/BitstreamWriterTest.cpp b/llvm/unittests/Bitstream/BitstreamWriterTest.cpp
--- a/llvm/unittests/Bitstream/BitstreamWriterTest.cpp
+++ b/llvm/unittests/Bitstream/BitstreamWriterTest.cpp
@@ -8,27 +8,31 @@
 
 #include "llvm/Bitstream/BitstreamWriter.h"
 #include "llvm/ADT/STLExtras.h"
-#include "llvm/ADT/SmallString.h"
+#include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
+#include <vector>
+
 using namespace llvm;
 
+using ::testing::IsEmpty;
+
 namespace {
 
 TEST(BitstreamWriterTest, emitBlob) {
-  SmallString<64> Buffer;
+  std::vector<char> Buffer;
   BitstreamWriter W(Buffer);
   W.emitBlob("str", /* ShouldEmitSize */ false);
-  EXPECT_EQ(StringRef("str\0", 4), Buffer);
+  EXPECT_EQ(StringRef("str\0", 4), StringRef(Buffer.data(), Buffer.size()));
 }
 
 TEST(BitstreamWriterTest, emitBlobWithSize) {
-  SmallString<64> Buffer;
+  std::vector<char> Buffer;
   {
     BitstreamWriter W(Buffer);
     W.emitBlob("str");
   }
-  SmallString<64> Expected;
+  std::vector<char> Expected;
   {
     BitstreamWriter W(Expected);
     W.EmitVBR(3, 6);
@@ -38,21 +42,21 @@
     W.Emit('r', 8);
     W.Emit(0, 8);
   }
-  EXPECT_EQ(StringRef(Expected), Buffer);
+  EXPECT_EQ(Expected, Buffer);
 }
 
 TEST(BitstreamWriterTest, emitBlobEmpty) {
-  SmallString<64> Buffer;
+  std::vector<char> Buffer;
   BitstreamWriter W(Buffer);
   W.emitBlob("", /* ShouldEmitSize */ false);
-  EXPECT_EQ(StringRef(""), Buffer);
+  EXPECT_THAT(Buffer, IsEmpty());
 }
 
 TEST(BitstreamWriterTest, emitBlob4ByteAligned) {
-  SmallString<64> Buffer;
+  std::vector<char> Buffer;
   BitstreamWriter W(Buffer);
   W.emitBlob("str0", /* ShouldEmitSize */ false);
-  EXPECT_EQ(StringRef("str0"), Buffer);
+  EXPECT_EQ(StringRef("str0"), StringRef(Buffer.data(), Buffer.size()));
 }
 
 } // end namespace