[Coverage] Avoid unnecessary copying of an std::vector.

[dblaikie]

This seems like more than a performance fix - the API itself seems a little
problematic. If buildSegments was called more than once on the same
SegmentBuilder, tehre would be trouble, right? (before this patch, it could
build on top of existing segments - after this patch it will use a
moved-from-vector which might be in some non-empty state (moved from
objects are in a "valid but unspecified" state - I'm not sure there's
anything other than empty that a vector could be in, but it's still a bit
subtle/risky))

Could the API be redesigned so it doesn't have this problem?

[vsk]

I agree with dblaikie, the API could be a bit cleaner. Wdyt of this:

1. Have the SegmentBuilder constructor accept a vector<CoverageSegment>&; assert that it's empty.
2. Replace Segments = SegmentBuilder().buildSegments(...) with SegmentBuilder(Segments).build(...).

[ikudrin]

• Use NRVO instead of std::move.
• Prevent unexpected using of SegmentBuilder by making method buildSegments() static.

[ikudrin]

Ping...

llvm/trunk/lib/ProfileData/CoverageMapping.cpp

public:
   }
 
   MapT::iterator begin() { return InstantiatedFunctions.begin(); }
 
   MapT::iterator end() { return InstantiatedFunctions.end(); }
 };
 
 class SegmentBuilder {
-  std::vector<CoverageSegment> Segments;
+  std::vector<CoverageSegment> &Segments;
   SmallVector<const CountedRegion *, 8> ActiveRegions;
 
+  SegmentBuilder(std::vector<CoverageSegment> &Segments) : Segments(Segments) {}
+
   /// Start a segment with no count specified.
   void startSegment(unsigned Line, unsigned Col) {
     DEBUG(dbgs() << "Top level segment at " << Line << ":" << Col << "\n");
     Segments.emplace_back(Line, Col, /*IsRegionEntry=*/false);
   }
 
   /// Start a segment with the given Region's count.
   void startSegment(unsigned Line, unsigned Col, bool IsRegionEntry,
void popRegion() {
     unsigned Line = Active->LineEnd, Col = Active->ColumnEnd;
     ActiveRegions.pop_back();
     if (ActiveRegions.empty())
       startSegment(Line, Col);
     else
       startSegment(Line, Col, false, *ActiveRegions.back());
   }
 
-public:
-  /// Build a list of CoverageSegments from a sorted list of Regions.
-  std::vector<CoverageSegment> buildSegments(ArrayRef<CountedRegion> Regions) {
+  void buildSegmentsImpl(ArrayRef<CountedRegion> Regions) {
     const CountedRegion *PrevRegion = nullptr;
     for (const auto &Region : Regions) {
       // Pop any regions that end before this one starts.
       while (!ActiveRegions.empty() &&
              ActiveRegions.back()->endLoc() <= Region.startLoc())
         popRegion();
       if (PrevRegion && PrevRegion->startLoc() == Region.startLoc() &&
           PrevRegion->endLoc() == Region.endLoc()) {
         if (Region.Kind == coverage::CounterMappingRegion::CodeRegion)
           Segments.back().addCount(Region.ExecutionCount);
       } else {
         // Add this region to the stack.
         ActiveRegions.push_back(&Region);
         startSegment(Region);
       }
       PrevRegion = &Region;
     }
     // Pop any regions that are left in the stack.
     while (!ActiveRegions.empty())
       popRegion();
+  }
+
+public:
+  /// Build a list of CoverageSegments from a sorted list of Regions.
+  static std::vector<CoverageSegment>
+  buildSegments(ArrayRef<CountedRegion> Regions) {
+    std::vector<CoverageSegment> Segments;
+    SegmentBuilder Builder(Segments);
+    Builder.buildSegmentsImpl(Regions);
     return Segments;
   }
 };
 }
 
 std::vector<StringRef> CoverageMapping::getUniqueSourceFiles() const {
   std::vector<StringRef> Filenames;
   for (const auto &Function : getCoveredFunctions())
for (const auto &CR : Function.CountedRegions)
         Regions.push_back(CR);
         if (isExpansion(CR, *MainFileID))
           FileCoverage.Expansions.emplace_back(CR, Function);
       }
   }
 
   sortNestedRegions(Regions.begin(), Regions.end());
   DEBUG(dbgs() << "Emitting segments for file: " << Filename << "\n");
-  FileCoverage.Segments = SegmentBuilder().buildSegments(Regions);
+  FileCoverage.Segments = SegmentBuilder::buildSegments(Regions);
 
   return FileCoverage;
 }
 
 std::vector<const FunctionRecord *>
 CoverageMapping::getInstantiations(StringRef Filename) {
   FunctionInstantiationSetCollector InstantiationSetCollector;
   for (const auto &Function : Functions) {
for (const auto &CR : Function.CountedRegions)
     if (CR.FileID == *MainFileID) {
       Regions.push_back(CR);
       if (isExpansion(CR, *MainFileID))
         FunctionCoverage.Expansions.emplace_back(CR, Function);
     }
 
   sortNestedRegions(Regions.begin(), Regions.end());
   DEBUG(dbgs() << "Emitting segments for function: " << Function.Name << "\n");
-  FunctionCoverage.Segments = SegmentBuilder().buildSegments(Regions);
+  FunctionCoverage.Segments = SegmentBuilder::buildSegments(Regions);
 
   return FunctionCoverage;
 }
 
 CoverageData
 CoverageMapping::getCoverageForExpansion(const ExpansionRecord &Expansion) {
   CoverageData ExpansionCoverage(
       Expansion.Function.Filenames[Expansion.FileID]);
   std::vector<coverage::CountedRegion> Regions;
   for (const auto &CR : Expansion.Function.CountedRegions)
     if (CR.FileID == Expansion.FileID) {
       Regions.push_back(CR);
       if (isExpansion(CR, Expansion.FileID))
         ExpansionCoverage.Expansions.emplace_back(CR, Expansion.Function);
     }
 
   sortNestedRegions(Regions.begin(), Regions.end());
   DEBUG(dbgs() << "Emitting segments for expansion of file " << Expansion.FileID
                << "\n");
-  ExpansionCoverage.Segments = SegmentBuilder().buildSegments(Regions);
+  ExpansionCoverage.Segments = SegmentBuilder::buildSegments(Regions);
 
   return ExpansionCoverage;
 }
 
 namespace {
 class CoverageMappingErrorCategoryType : public std::error_category {
   const char *name() const LLVM_NOEXCEPT override { return "llvm.coveragemap"; }
   std::string message(int IE) const override {