[llvm] Reserve memory before pushing back

[gAlfonso-bit]

Summary

It is generally good practice, if you know how big the vector is going to be in the end, to reserve before continually calling "push_back" or "emplace_back"

[MaskRay]

llvm/tools/llvm-cov/CoverageReport.cpp

406

Drop unneeded change

442

wrong indentation

[gAlfonso-bit]

Resolved changes

[gAlfonso-bit]

@MaskRay ready for merge

llvm/include/llvm/Testing/Support/Error.h

 public:
   explicit ErrorMessageMatches(
       testing::Matcher<std::vector<std::string>> Matcher)
       : Matcher(std::move(Matcher)) {}
 
   bool MatchAndExplain(const ErrorHolder &Holder,
                        testing::MatchResultListener *listener) const override {
     std::vector<std::string> Messages;
-    for (const std::shared_ptr<ErrorInfoBase> &Info: Holder.Infos)
+    Messages.reserve(Holder.Infos.size());
+    for (const std::shared_ptr<ErrorInfoBase> &Info : Holder.Infos)
       Messages.push_back(Info->message());
 
     return Matcher.MatchAndExplain(Messages, listener);
   }
 
   void DescribeTo(std::ostream *OS) const override {
     *OS << "failed with Error whose message ";
     Matcher.DescribeTo(OS);

llvm/lib/Support/VirtualFileSystem.cpp

 
 void RedirectingFileSystem::setRedirection(
     RedirectingFileSystem::RedirectKind Kind) {
   Redirection = Kind;
 }
 
 std::vector<StringRef> RedirectingFileSystem::getRoots() const {
   std::vector<StringRef> R;
+  R.reserve(Roots.size());
   for (const auto &Root : Roots)
     R.push_back(Root->getName());
   return R;
 }
 
 void RedirectingFileSystem::printImpl(raw_ostream &OS, PrintType Type,
                                       unsigned IndentLevel) const {
   printIndent(OS, IndentLevel);

llvm/tools/llvm-cov/CodeCoverage.cpp

if (EC) {
     error(OutputPath, EC.message());
     return;
   }
   ToolOutputFile OutputTOF{OutputPath, OutputFD};
   OutputTOF.os().close();
 
   // Invoke the demangler.
   std::vector<StringRef> ArgsV;
+  ArgsV.reserve(ViewOpts.DemanglerOpts.size());
   for (StringRef Arg : ViewOpts.DemanglerOpts)
     ArgsV.push_back(Arg);
   std::optional<StringRef> Redirects[] = {
       InputPath.str(), OutputPath.str(), {""}};
   std::string ErrMsg;
   int RC =
       sys::ExecuteAndWait(ViewOpts.DemanglerOpts[0], ArgsV,
                           /*env=*/std::nullopt, Redirects, /*secondsToWait=*/0,

llvm/tools/llvm-cov/CoverageReport.cpp

std::vector<FileCoverageSummary> CoverageReport::prepareFileReports(
   ThreadPool Pool(S);
 
   std::vector<FileCoverageSummary> FileReports;
   FileReports.reserve(Files.size());
 
   for (StringRef Filename : Files) {
     FileReports.emplace_back(Filename.drop_front(LCP));
     Pool.async(&CoverageReport::prepareSingleFileReport, Filename,
                &Coverage, Options, LCP, &FileReports.back(), &Filters);
   }
   Pool.wait();
 
   for (const auto &FileReport : FileReports)
     Totals += FileReport;
 
   return FileReports;
 }

 void CoverageReport::renderFileReports(
     raw_ostream &OS, ArrayRef<std::string> Files,
     const CoverageFiltersMatchAll &Filters) const {
   FileCoverageSummary Totals("TOTAL");
   auto FileReports =
       prepareFileReports(Coverage, Totals, Files, Options, Filters);
 
   std::vector<StringRef> Filenames;
+  Filenames.reserve(FileReports.size());
   for (const FileCoverageSummary &FCS : FileReports)
     Filenames.emplace_back(FCS.Name);
   adjustColumnWidths(Filenames, {});
 
   OS << column("Filename", FileReportColumns[0]);
   if (Options.ShowRegionSummary)
     OS << column("Regions", FileReportColumns[1], Column::RightAlignment)
        << column("Missed Regions", FileReportColumns[2], Column::RightAlignment)
        << column("Cover", FileReportColumns[3], Column::RightAlignment);
   OS << column("Functions", FileReportColumns[4], Column::RightAlignment)

llvm/unittests/ADT/DenseMapTest.cpp

TEST(DenseMapCustomTest, InitialSizeTest) {
   }
 }
 
 // Make sure creating the map with a iterator range does not trigger grow()
 TEST(DenseMapCustomTest, InitFromIterator) {
   std::vector<std::pair<int, CountCopyAndMove>> Values;
   // The size is a random value greater than 64 (hardcoded DenseMap min init)
   const int Count = 65;
+  Values.reserve(Count);
   for (int i = 0; i < Count; i++)
     Values.emplace_back(i, CountCopyAndMove());
 
   CountCopyAndMove::Move = 0;
   CountCopyAndMove::Copy = 0;
   DenseMap<int, CountCopyAndMove> Map(Values.begin(), Values.end());
   // Check that no move occurred
   EXPECT_EQ(0, CountCopyAndMove::Move);

llvm/utils/TableGen/GlobalISelEmitter.cpp

for (const auto &TypeObject : TypeObjects) {
     TypeObject.emitCxxConstructorCall(OS);
     OS << ",\n";
   }
   OS << "};\n\n";
 
   // Emit a table containing the PredicateBitsets objects needed by the matcher
   // and an enum for the matcher to reference them with.
   std::vector<std::vector<Record *>> FeatureBitsets;
+  FeatureBitsets.reserve(Rules.size());
   for (auto &Rule : Rules)
     FeatureBitsets.push_back(Rule.getRequiredFeatures());
   llvm::sort(FeatureBitsets, [&](const std::vector<Record *> &A,
                                  const std::vector<Record *> &B) {
     if (A.size() < B.size())
       return true;
     if (A.size() > B.size())
       return false;

llvm/utils/TableGen/OptParserEmitter.cpp

void EmitOptParser(RecordKeeper &Records, raw_ostream &OS) {
   // The RecordKeeper stores records (options) in lexicographical order, and we
   // have reordered the options again when generating prefix groups. We need to
   // restore the original definition order of options with marshalling to honor
   // the topology of the dependency graph implied by `DefaultAnyOf`.
   array_pod_sort(OptsWithMarshalling.begin(), OptsWithMarshalling.end(),
                  CmpMarshallingOpts);
 
   std::vector<MarshallingInfo> MarshallingInfos;
+  MarshallingInfos.reserve(OptsWithMarshalling.size());
   for (const auto *R : OptsWithMarshalling)
     MarshallingInfos.push_back(createMarshallingInfo(*R));
 
   for (const auto &MI : MarshallingInfos) {
     OS << "#ifdef " << MI.getMacroName() << "\n";
     OS << MI.getMacroName() << "(";
     WriteOptRecordFields(OS, MI.R);
     OS << ", ";