[NFC] replace resize calls with resize_for_overwrite

[njames93]

Summary

Also replace a few calls to resize followed by zeroing the data to calling assign(size, 0).

clang/lib/CodeGen/CodeGenFunction.h

public:
 
   template <class T, class... As>
   void pushCleanupAfterFullExprWithActiveFlag(CleanupKind Kind,
                                               Address ActiveFlag, As... A) {
     LifetimeExtendedCleanupHeader Header = {sizeof(T), Kind,
                                             ActiveFlag.isValid()};
 
     size_t OldSize = LifetimeExtendedCleanupStack.size();
-    LifetimeExtendedCleanupStack.resize(
+    LifetimeExtendedCleanupStack.resize_for_overwrite(
         LifetimeExtendedCleanupStack.size() + sizeof(Header) + Header.Size +
         (Header.IsConditional ? sizeof(ActiveFlag) : 0));
 
     static_assert(sizeof(Header) % alignof(T) == 0,
                   "Cleanup will be allocated on misaligned address");
     char *Buffer = &LifetimeExtendedCleanupStack[OldSize];
     new (Buffer) LifetimeExtendedCleanupHeader(Header);
     new (Buffer + sizeof(Header)) T(A...);

clang/lib/CodeGen/CodeGenModule.cpp

 static void emitUsed(CodeGenModule &CGM, StringRef Name,
                      std::vector<llvm::WeakTrackingVH> &List) {
   // Don't create llvm.used if there is no need.
   if (List.empty())
     return;
 
   // Convert List to what ConstantArray needs.
   SmallVector<llvm::Constant*, 8> UsedArray;
-  UsedArray.resize(List.size());
+  UsedArray.resize_for_overwrite(List.size());
   for (unsigned i = 0, e = List.size(); i != e; ++i) {
     UsedArray[i] =
         llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(
             cast<llvm::Constant>(&*List[i]), CGM.Int8PtrTy);
   }
 
   if (UsedArray.empty())
     return;

clang/lib/Format/UnwrappedLineParser.cpp

for (SmallVectorImpl<UnwrappedLine>::iterator I = Lines.begin(),
                                                   E = Lines.end();
          I != E; ++I) {
       Callback.consumeUnwrappedLine(*I);
     }
     Callback.finishRun();
     Lines.clear();
     while (!PPLevelBranchIndex.empty() &&
            PPLevelBranchIndex.back() + 1 >= PPLevelBranchCount.back()) {
-      PPLevelBranchIndex.resize(PPLevelBranchIndex.size() - 1);
-      PPLevelBranchCount.resize(PPLevelBranchCount.size() - 1);
+      PPLevelBranchIndex.pop_back();
+      PPLevelBranchCount.pop_back();
     }
     if (!PPLevelBranchIndex.empty()) {
       ++PPLevelBranchIndex.back();
       assert(PPLevelBranchIndex.size() == PPLevelBranchCount.size());
       assert(PPLevelBranchIndex.back() <= PPLevelBranchCount.back());
     }
   } while (!PPLevelBranchIndex.empty());
 }

clang/lib/Lex/Lexer.cpp

StringRef Lexer::getSpelling(SourceLocation loc,
 
   unsigned length = token.getLength();
 
   // Common case:  no need for cleaning.
   if (!token.needsCleaning())
     return StringRef(tokenBegin, length);
 
   // Hard case, we need to relex the characters into the string.
-  buffer.resize(length);
+  buffer.resize_for_overwrite(length);
   buffer.resize(getSpellingSlow(token, tokenBegin, options, buffer.data()));
   return StringRef(buffer.data(), buffer.size());
 }
 
 /// getSpelling() - Return the 'spelling' of this token.  The spelling of a
 /// token are the characters used to represent the token in the source file
 /// after trigraph expansion and escaped-newline folding.  In particular, this
 /// wants to get the true, uncanonicalized, spelling of things like digraphs

clang/lib/Lex/LiteralSupport.cpp

assert(PP.getTargetInfo().getCharWidth() == 8 &&
          "Assumes char is 8 bits");
   assert(PP.getTargetInfo().getIntWidth() <= 64 &&
          (PP.getTargetInfo().getIntWidth() & 7) == 0 &&
          "Assumes sizeof(int) on target is <= 64 and a multiple of char");
   assert(PP.getTargetInfo().getWCharWidth() <= 64 &&
          "Assumes sizeof(wchar) on target is <= 64");
 
   SmallVector<uint32_t, 4> codepoint_buffer;
-  codepoint_buffer.resize(end - begin);
+  codepoint_buffer.resize_for_overwrite(end - begin);
   uint32_t *buffer_begin = &codepoint_buffer.front();
   uint32_t *buffer_end = buffer_begin + codepoint_buffer.size();
 
   // Unicode escapes representing characters that cannot be correctly
   // represented in a single code unit are disallowed in character literals
   // by this implementation.
   uint32_t largest_character_for_kind;
   if (tok::wide_char_constant == Kind) {
void StringLiteralParser::init(ArrayRef<Token> StringToks){
   assert((CharByteWidth & 7) == 0 && "Assumes character size is byte multiple");
   CharByteWidth /= 8;
 
   // The output buffer size needs to be large enough to hold wide characters.
   // This is a worst-case assumption which basically corresponds to L"" "long".
   SizeBound *= CharByteWidth;
 
   // Size the temporary buffer to hold the result string data.
-  ResultBuf.resize(SizeBound);
+  ResultBuf.resize_for_overwrite(SizeBound);
 
   // Likewise, but for each string piece.
   SmallString<512> TokenBuf;
-  TokenBuf.resize(MaxTokenLength);
+  TokenBuf.resize_for_overwrite(MaxTokenLength);
 
   // Loop over all the strings, getting their spelling, and expanding them to
   // wide strings as appropriate.
   ResultPtr = &ResultBuf[0];   // Next byte to fill in.
 
   Pascal = false;
 
   SourceLocation UDSuffixTokLoc;

 
 /// getOffsetOfStringByte - This function returns the offset of the
 /// specified byte of the string data represented by Token.  This handles
 /// advancing over escape sequences in the string.
 unsigned StringLiteralParser::getOffsetOfStringByte(const Token &Tok,
                                                     unsigned ByteNo) const {
   // Get the spelling of the token.
   SmallString<32> SpellingBuffer;
-  SpellingBuffer.resize(Tok.getLength());
+  SpellingBuffer.resize_for_overwrite(Tok.getLength());
 
   bool StringInvalid = false;
   const char *SpellingPtr = &SpellingBuffer[0];
   unsigned TokLen = Lexer::getSpelling(Tok, SpellingPtr, SM, Features,
                                        &StringInvalid);
   if (StringInvalid)
     return 0;
 

clang/lib/Lex/Preprocessor.cpp

StringRef Preprocessor::getSpelling(const Token &Tok,
   if (Tok.isNot(tok::raw_identifier) && !Tok.hasUCN()) {
     // Try the fast path.
     if (const IdentifierInfo *II = Tok.getIdentifierInfo())
       return II->getName();
   }
 
   // Resize the buffer if we need to copy into it.
   if (Tok.needsCleaning())
-    Buffer.resize(Tok.getLength());
+    Buffer.resize_for_overwrite(Tok.getLength());
 
   const char *Ptr = Buffer.data();
   unsigned Len = getSpelling(Tok, Ptr, Invalid);
   return StringRef(Ptr, Len);
 }
 
 /// CreateString - Plop the specified string into a scratch buffer and return a
 /// location for it.  If specified, the source location provides a source

clang/lib/Sema/SemaExpr.cpp

#include "clang/AST/DeclNodes.inc"
     return BuildDeclRefExpr(VD, type, valueKind, NameInfo, &SS, FoundD,
                             /*FIXME: TemplateKWLoc*/ SourceLocation(),
                             TemplateArgs);
   }
 }
 
 static void ConvertUTF8ToWideString(unsigned CharByteWidth, StringRef Source,
                                     SmallString<32> &Target) {
-  Target.resize(CharByteWidth * (Source.size() + 1));
+  Target.resize_for_overwrite(CharByteWidth * (Source.size() + 1));
   char *ResultPtr = &Target[0];
   const llvm::UTF8 *ErrorPtr;
   bool success =
       llvm::ConvertUTF8toWide(CharByteWidth, Source, ResultPtr, ErrorPtr);
   (void)success;
   assert(success);
   Target.resize(ResultPtr - &Target[0]);
 }
if (Tok.getLength() == 1) {
     return ActOnIntegerConstant(Tok.getLocation(), Val-'0');
   }
 
   SmallString<128> SpellingBuffer;
   // NumericLiteralParser wants to overread by one character.  Add padding to
   // the buffer in case the token is copied to the buffer.  If getSpelling()
   // returns a StringRef to the memory buffer, it should have a null char at
   // the EOF, so it is also safe.
-  SpellingBuffer.resize(Tok.getLength() + 1);
+  SpellingBuffer.resize_for_overwrite(Tok.getLength() + 1);
 
   // Get the spelling of the token, which eliminates trigraphs, etc.
   bool Invalid = false;
   StringRef TokSpelling = PP.getSpelling(Tok, SpellingBuffer, &Invalid);
   if (Invalid)
     return ExprError();
 
   NumericLiteralParser Literal(TokSpelling, Tok.getLocation(),

lldb/source/Core/ValueObject.cpp

 //===-- ValueObject.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
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/ValueObject.h"
 
 #include "lldb/Core/Address.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ValueObjectCast.h"
 #include "lldb/Core/ValueObjectChild.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/Core/ValueObjectDynamicValue.h"
 #include "lldb/Core/ValueObjectMemory.h"
if (IsInScope()) {
 
       // Call the pure virtual function to update the value
 
       bool need_compare_checksums = false;
       llvm::SmallVector<uint8_t, 16> old_checksum;
 
       if (!first_update && CanProvideValue()) {
         need_compare_checksums = true;
-        old_checksum.resize(m_value_checksum.size());
+        old_checksum.resize_for_overwrite(m_value_checksum.size());
         std::copy(m_value_checksum.begin(), m_value_checksum.end(),
                   old_checksum.begin());
       }
 
       bool success = UpdateValue();
 
       SetValueIsValid(success);
 

lldb/source/Host/common/LZMA.cpp

 //===-- LZMA.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
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Host/Config.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Error.h"
 
 #if LLDB_ENABLE_LZMA
 #include <lzma.h>
 #endif // LLDB_ENABLE_LZMA
 
 namespace lldb_private {

 
 llvm::Error uncompress(llvm::ArrayRef<uint8_t> InputBuffer,
                        llvm::SmallVectorImpl<uint8_t> &Uncompressed) {
   llvm::Expected<uint64_t> uncompressedSize = getUncompressedSize(InputBuffer);
 
   if (auto err = uncompressedSize.takeError())
     return err;
 
-  Uncompressed.resize(*uncompressedSize);
+  Uncompressed.resize_for_overwrite(*uncompressedSize);
 
   // Decompress xz buffer to buffer.
   uint64_t memlimit = UINT64_MAX;
   size_t inpos = 0;
   size_t outpos = 0;
   lzma_ret ret = lzma_stream_buffer_decode(
       &memlimit, 0, nullptr, InputBuffer.data(), &inpos, InputBuffer.size(),
       Uncompressed.data(), &outpos, Uncompressed.size());

lldb/source/Utility/VASprintf.cpp

 //===-- VASprintf.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
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Utility/VASPrintf.h"
 
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 
 #include <assert.h>
 #include <stdarg.h>
 #include <stdio.h>
 
 bool lldb_private::VASprintf(llvm::SmallVectorImpl<char> &buf, const char *fmt,
                              va_list args) {
   llvm::SmallString<16> error("<Encoding error>");
   bool result = true;
 
   // Copy in case our first call to vsnprintf doesn't fit into our buffer
   va_list copy_args;
   va_copy(copy_args, args);
 
-  buf.resize(buf.capacity());
+  buf.resize_for_overwrite(buf.capacity());
   // Write up to `capacity` bytes, ignoring the current size.
   int length = ::vsnprintf(buf.data(), buf.size(), fmt, args);
   if (length < 0) {
     buf = error;
     result = false;
     goto finish;
   }
 
   if (size_t(length) >= buf.size()) {
     // The error formatted string didn't fit into our buffer, resize it to the
     // exact needed size, and retry
-    buf.resize(length + 1);
+    buf.resize_for_overwrite(length + 1);
     length = ::vsnprintf(buf.data(), buf.size(), fmt, copy_args);
     if (length < 0) {
       buf = error;
       result = false;
       goto finish;
     }
     assert(size_t(length) < buf.size());
   }
   buf.resize(length);
 
 finish:
   va_end(args);
   va_end(copy_args);
   return result;
 }

llvm/lib/CodeGen/MachineLICM.cpp

if (PreRegAlloc)
     LLVM_DEBUG(dbgs() << "******** Pre-regalloc Machine LICM: ");
   else
     LLVM_DEBUG(dbgs() << "******** Post-regalloc Machine LICM: ");
   LLVM_DEBUG(dbgs() << MF.getName() << " ********\n");
 
   if (PreRegAlloc) {
     // Estimate register pressure during pre-regalloc pass.
     unsigned NumRPS = TRI->getNumRegPressureSets();
-    RegPressure.resize(NumRPS);
-    std::fill(RegPressure.begin(), RegPressure.end(), 0);
-    RegLimit.resize(NumRPS);
+    RegPressure.assign(NumRPS, 0);
+    RegLimit.resize_for_overwrite(NumRPS);
     for (unsigned i = 0, e = NumRPS; i != e; ++i)
       RegLimit[i] = TRI->getRegPressureSetLimit(MF, i);
   }
 
   // Get our Loop information...
   if (DisableHoistingToHotterBlocks != UseBFI::None)
     MBFI = &getAnalysis<MachineBlockFrequencyInfo>();
   MLI = &getAnalysis<MachineLoopInfo>();

llvm/lib/CodeGen/TargetSchedule.cpp

 
 void TargetSchedModel::init(const TargetSubtargetInfo *TSInfo) {
   STI = TSInfo;
   SchedModel = TSInfo->getSchedModel();
   TII = TSInfo->getInstrInfo();
   STI->initInstrItins(InstrItins);
 
   unsigned NumRes = SchedModel.getNumProcResourceKinds();
-  ResourceFactors.resize(NumRes);
+  ResourceFactors.resize_for_overwrite(NumRes);
   ResourceLCM = SchedModel.IssueWidth;
   for (unsigned Idx = 0; Idx < NumRes; ++Idx) {
     unsigned NumUnits = SchedModel.getProcResource(Idx)->NumUnits;
     if (NumUnits > 0)
       ResourceLCM = lcm(ResourceLCM, NumUnits);
   }
   MicroOpFactor = ResourceLCM / SchedModel.IssueWidth;
   for (unsigned Idx = 0; Idx < NumRes; ++Idx) {

llvm/lib/DebugInfo/CodeView/TypeStreamMerger.cpp

if (LLVM_LIKELY(UseGlobalHashes)) {
       GlobalTypeTableBuilder &Dest =
           isIdRecord(Type.kind()) ? *DestGlobalIdStream : *DestGlobalTypeStream;
       GloballyHashedType H = GlobalHashes[CurIndex.toArrayIndex()];
       DestIdx = Dest.insertRecordAs(H, AlignedSize, DoSerialize);
     } else {
       MergingTypeTableBuilder &Dest =
           isIdRecord(Type.kind()) ? *DestIdStream : *DestTypeStream;
 
-      RemapStorage.resize(AlignedSize);
+      RemapStorage.resize_for_overwrite(AlignedSize);
       ArrayRef<uint8_t> Result = DoSerialize(RemapStorage);
       if (!Result.empty())
         DestIdx = Dest.insertRecordBytes(Result);
     }
   }
   addMapping(DestIdx);
 
   ++CurIndex;

llvm/lib/DebugInfo/DWARF/DWARFAcceleratorTable.cpp

Error DWARFDebugNames::Header::extract(const DWARFDataExtractor &AS,
   AugmentationStringSize = alignTo(AS.getU32(C), 4);
 
   if (!C)
     return HeaderError(C.takeError());
 
   if (!AS.isValidOffsetForDataOfSize(C.tell(), AugmentationStringSize))
     return HeaderError(createStringError(errc::illegal_byte_sequence,
                                          "cannot read header augmentation"));
-  AugmentationString.resize(AugmentationStringSize);
+  AugmentationString.resize_for_overwrite(AugmentationStringSize);
   AS.getU8(C, reinterpret_cast<uint8_t *>(AugmentationString.data()),
            AugmentationStringSize);
   *Offset = C.tell();
   return C.takeError();
 }
 
 void DWARFDebugNames::Abbrev::dump(ScopedPrinter &W) const {
   DictScope AbbrevScope(W, ("Abbreviation 0x" + Twine::utohexstr(Code)).str());

llvm/lib/MC/MCAsmStreamer.cpp

if (!getAssembler().getEmitterPtr())
     return;
 
   getAssembler().getEmitter().encodeInstruction(Inst, VecOS, Fixups, STI);
 
   // If we are showing fixups, create symbolic markers in the encoded
   // representation. We do this by making a per-bit map to the fixup item index,
   // then trying to display it as nicely as possible.
   SmallVector<uint8_t, 64> FixupMap;
-  FixupMap.resize(Code.size() * 8);
-  for (unsigned i = 0, e = Code.size() * 8; i != e; ++i)
-    FixupMap[i] = 0;
+  FixupMap.assign(Code.size() * 8, 0);
 
   for (unsigned i = 0, e = Fixups.size(); i != e; ++i) {
     MCFixup &F = Fixups[i];
     const MCFixupKindInfo &Info =
         getAssembler().getBackend().getFixupKindInfo(F.getKind());
     for (unsigned j = 0; j != Info.TargetSize; ++j) {
       unsigned Index = F.getOffset() * 8 + Info.TargetOffset + j;
       assert(Index < Code.size() * 8 && "Invalid offset in fixup!");

llvm/lib/MC/MCDwarf.cpp

 
 void MCDwarfLineStr::emitSection(MCStreamer *MCOS) {
   // Switch to the .debug_line_str section.
   MCOS->SwitchSection(
       MCOS->getContext().getObjectFileInfo()->getDwarfLineStrSection());
   // Emit the strings without perturbing the offsets we used.
   LineStrings.finalizeInOrder();
   SmallString<0> Data;
-  Data.resize(LineStrings.getSize());
+  Data.resize_for_overwrite(LineStrings.getSize());
   LineStrings.write((uint8_t *)Data.data());
   MCOS->emitBinaryData(Data.str());
 }
 
 void MCDwarfLineStr::emitRef(MCStreamer *MCOS, StringRef Path) {
   int RefSize =
       dwarf::getDwarfOffsetByteSize(MCOS->getContext().getDwarfFormat());
   size_t Offset = LineStrings.add(Path);

llvm/lib/MC/MCParser/AsmParser.cpp

bool AsmParser::parseMSInlineAsm(
   for (unsigned I = 0, E = ClobberRegs.size(); I != E; ++I) {
     raw_string_ostream OS(Clobbers[I]);
     IP->printRegName(OS, ClobberRegs[I]);
   }
 
   // Merge the various outputs and inputs.  Output are expected first.
   if (NumOutputs || NumInputs) {
     unsigned NumExprs = NumOutputs + NumInputs;
-    OpDecls.resize(NumExprs);
-    Constraints.resize(NumExprs);
+    OpDecls.resize_for_overwrite(NumExprs);
+    Constraints.resize_for_overwrite(NumExprs);
     for (unsigned i = 0; i < NumOutputs; ++i) {
       OpDecls[i] = std::make_pair(OutputDecls[i], OutputDeclsAddressOf[i]);
       Constraints[i] = OutputConstraints[i];
     }
     for (unsigned i = 0, j = NumOutputs; i < NumInputs; ++i, ++j) {
       OpDecls[j] = std::make_pair(InputDecls[i], InputDeclsAddressOf[i]);
       Constraints[j] = InputConstraints[i];
     }

llvm/lib/MC/MCParser/MasmParser.cpp

bool MasmParser::parseMSInlineAsm(
   for (unsigned I = 0, E = ClobberRegs.size(); I != E; ++I) {
     raw_string_ostream OS(Clobbers[I]);
     IP->printRegName(OS, ClobberRegs[I]);
   }
 
   // Merge the various outputs and inputs.  Output are expected first.
   if (NumOutputs || NumInputs) {
     unsigned NumExprs = NumOutputs + NumInputs;
-    OpDecls.resize(NumExprs);
-    Constraints.resize(NumExprs);
+    OpDecls.resize_for_overwrite(NumExprs);
+    Constraints.resize_for_overwrite(NumExprs);
     for (unsigned i = 0; i < NumOutputs; ++i) {
       OpDecls[i] = std::make_pair(OutputDecls[i], OutputDeclsAddressOf[i]);
       Constraints[i] = OutputConstraints[i];
     }
     for (unsigned i = 0, j = NumOutputs; i < NumInputs; ++i, ++j) {
       OpDecls[j] = std::make_pair(InputDecls[i], InputDeclsAddressOf[i]);
       Constraints[j] = InputConstraints[i];
     }

llvm/lib/MC/MCStreamer.cpp

if (Value.getNumWords() == 1) {
     return;
   }
 
   const bool IsLittleEndianTarget = Context.getAsmInfo()->isLittleEndian();
   const bool ShouldSwap = sys::IsLittleEndianHost != IsLittleEndianTarget;
   const APInt Swapped = ShouldSwap ? Value.byteSwap() : Value;
   const unsigned Size = Value.getBitWidth() / 8;
   SmallString<10> Tmp;
-  Tmp.resize(Size);
+  Tmp.resize_for_overwrite(Size);
   StoreIntToMemory(Swapped, reinterpret_cast<uint8_t *>(Tmp.data()), Size);
   emitBytes(Tmp.str());
 }
 
 /// EmitULEB128IntValue - Special case of EmitULEB128Value that avoids the
 /// client having to pass in a MCExpr for constant integers.
 void MCStreamer::emitULEB128IntValue(uint64_t Value, unsigned PadTo) {
   SmallString<128> Tmp;
void MCStreamer::emitCVInlineLinetableDirective(unsigned PrimaryFunctionId,
                                                 const MCSymbol *FnEndSym) {}
 
 /// Only call this on endian-specific types like ulittle16_t and little32_t, or
 /// structs composed of them.
 template <typename T>
 static void copyBytesForDefRange(SmallString<20> &BytePrefix,
                                  codeview::SymbolKind SymKind,
                                  const T &DefRangeHeader) {
-  BytePrefix.resize(2 + sizeof(T));
+  BytePrefix.resize_for_overwrite(2 + sizeof(T));
   codeview::ulittle16_t SymKindLE = codeview::ulittle16_t(SymKind);
   memcpy(&BytePrefix[0], &SymKindLE, 2);
   memcpy(&BytePrefix[2], &DefRangeHeader, sizeof(T));
 }
 
 void MCStreamer::emitCVDefRangeDirective(
     ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
     StringRef FixedSizePortion) {}

llvm/lib/MC/StringTableBuilder.cpp

 StringTableBuilder::StringTableBuilder(Kind K, unsigned Alignment)
     : K(K), Alignment(Alignment) {
   initSize();
 }
 
 void StringTableBuilder::write(raw_ostream &OS) const {
   assert(isFinalized());
   SmallString<0> Data;
-  Data.resize(getSize());
+  Data.resize_for_overwrite(getSize());
   write((uint8_t *)Data.data());
   OS << Data;
 }
 
 using StringPair = std::pair<CachedHashStringRef, size_t>;
 
 void StringTableBuilder::write(uint8_t *Buf) const {
   assert(isFinalized());

llvm/lib/MC/WinCOFFObjectWriter.cpp

void WinCOFFObjectWriter::createFileSymbols(MCAssembler &Asm) {
   for (const std::string &Name : Asm.getFileNames()) {
     // round up to calculate the number of auxiliary symbols required
     unsigned SymbolSize = UseBigObj ? COFF::Symbol32Size : COFF::Symbol16Size;
     unsigned Count = (Name.size() + SymbolSize - 1) / SymbolSize;
 
     COFFSymbol *File = createSymbol(".file");
     File->Data.SectionNumber = COFF::IMAGE_SYM_DEBUG;
     File->Data.StorageClass = COFF::IMAGE_SYM_CLASS_FILE;
-    File->Aux.resize(Count);
+    File->Aux.resize_for_overwrite(Count);
 
     unsigned Offset = 0;
     unsigned Length = Name.size();
     for (auto &Aux : File->Aux) {
       Aux.AuxType = ATFile;
 
       if (Length > SymbolSize) {
         memcpy(&Aux.Aux, Name.c_str() + Offset, SymbolSize);

llvm/lib/Object/IRSymtab.cpp

for (auto *M : IRMods)
     if (Error Err = addModule(M))
       return Err;
 
   COFFLinkerOptsOS.flush();
   setStr(Hdr.COFFLinkerOpts, Saver.save(COFFLinkerOpts));
 
   // We are about to fill in the header's range fields, so reserve space for it
   // and copy it in afterwards.
-  Symtab.resize(sizeof(storage::Header));
+  Symtab.resize_for_overwrite(sizeof(storage::Header));
   writeRange(Hdr.Modules, Mods);
   writeRange(Hdr.Comdats, Comdats);
   writeRange(Hdr.Symbols, Syms);
   writeRange(Hdr.Uncommons, Uncommons);
   writeRange(Hdr.DependentLibraries, DependentLibraries);
   *reinterpret_cast<storage::Header *>(Symtab.data()) = Hdr;
   return Error::success();
 }
static Expected<FileContents> upgrade(ArrayRef<BitcodeModule> BMs) {
   }
 
   StringTableBuilder StrtabBuilder(StringTableBuilder::RAW);
   BumpPtrAllocator Alloc;
   if (Error E = build(Mods, FC.Symtab, StrtabBuilder, Alloc))
     return std::move(E);
 
   StrtabBuilder.finalizeInOrder();
-  FC.Strtab.resize(StrtabBuilder.getSize());
+  FC.Strtab.resize_for_overwrite(StrtabBuilder.getSize());
   StrtabBuilder.write((uint8_t *)FC.Strtab.data());
 
   FC.TheReader = {{FC.Symtab.data(), FC.Symtab.size()},
                   {FC.Strtab.data(), FC.Strtab.size()}};
   return std::move(FC);
 }
 
 Expected<FileContents> irsymtab::readBitcode(const BitcodeFileContents &BFC) {

llvm/lib/Object/MachOObjectFile.cpp

parseBuildVersionCommand(const MachOObjectFile &Obj,
   MachO::build_version_command BVC = BVCOrErr.get();
   if (Load.C.cmdsize !=
       sizeof(MachO::build_version_command) +
           BVC.ntools * sizeof(MachO::build_tool_version))
     return malformedError("load command " + Twine(LoadCommandIndex) +
                           " LC_BUILD_VERSION_COMMAND has incorrect cmdsize");
 
   auto Start = Load.Ptr + sizeof(MachO::build_version_command);
-  BuildTools.resize(BVC.ntools);
+  BuildTools.resize_for_overwrite(BVC.ntools);
   for (unsigned i = 0; i < BVC.ntools; ++i)
     BuildTools[i] = Start + i * sizeof(MachO::build_tool_version);
 
   return Error::success();
 }
 
 static Error checkRpathCommand(const MachOObjectFile &Obj,
                                const MachOObjectFile::LoadCommandInfo &Load,

llvm/lib/Support/ConvertUTFWrapper.cpp

bool convertUTF8ToUTF16String(StringRef SrcUTF8,
   const UTF8 *Src = reinterpret_cast<const UTF8 *>(SrcUTF8.begin());
   const UTF8 *SrcEnd = reinterpret_cast<const UTF8 *>(SrcUTF8.end());
 
   // Allocate the same number of UTF-16 code units as UTF-8 code units. Encoding
   // as UTF-16 should always require the same amount or less code units than the
   // UTF-8 encoding.  Allocate one extra byte for the null terminator though,
   // so that someone calling DstUTF16.data() gets a null terminated string.
   // We resize down later so we don't have to worry that this over allocates.
-  DstUTF16.resize(SrcUTF8.size()+1);
+  DstUTF16.resize_for_overwrite(SrcUTF8.size() + 1);
   UTF16 *Dst = &DstUTF16[0];
   UTF16 *DstEnd = Dst + DstUTF16.size();
 
   ConversionResult CR =
       ConvertUTF8toUTF16(&Src, SrcEnd, &Dst, DstEnd, strictConversion);
   assert(CR != targetExhausted);
 
   if (CR != conversionOK) {

llvm/lib/Support/PrettyStackTrace.cpp

PrettyStackTraceFormat::PrettyStackTraceFormat(const char *Format, ...) {
   va_start(AP, Format);
   const int SizeOrError = vsnprintf(nullptr, 0, Format, AP);
   va_end(AP);
   if (SizeOrError < 0) {
     return;
   }
 
   const int Size = SizeOrError + 1; // '\0'
-  Str.resize(Size);
+  Str.resize_for_overwrite(Size);
   va_start(AP, Format);
   vsnprintf(Str.data(), Size, Format, AP);
   va_end(AP);
 }
 
 void PrettyStackTraceFormat::print(raw_ostream &OS) const { OS << Str << "\n"; }
 
 void PrettyStackTraceProgram::print(raw_ostream &OS) const {

llvm/lib/Support/raw_ostream.cpp

raw_ostream &raw_ostream::operator<<(const format_object_base &Fmt) {
   }
 
   // If we got here, we didn't have enough space in the output buffer for the
   // string.  Try printing into a SmallVector that is resized to have enough
   // space.  Iterate until we win.
   SmallVector<char, 128> V;
 
   while (true) {
-    V.resize(NextBufferSize);
+    V.resize_for_overwrite(NextBufferSize);
 
     // Try formatting into the SmallVector.
     size_t BytesUsed = Fmt.print(V.data(), NextBufferSize);
 
     // If BytesUsed fit into the vector, we win.
     if (BytesUsed <= NextBufferSize)
       return write(V.data(), BytesUsed);