Import LLVM 6.0.1 release including clang, lld and lldb.

"where is the kaboom?" deraadt@

1 files changed, 54 insertions, 27 deletions

diff --git a/gnu/llvm/tools/llvm-cov/CoverageSummaryInfo.h b/gnu/llvm/tools/llvm-cov/CoverageSummaryInfo.h
index 680fc375768..8eae0b7fec9 100644
--- a/gnu/llvm/tools/llvm-cov/CoverageSummaryInfo.h
+++ b/gnu/llvm/tools/llvm-cov/CoverageSummaryInfo.h
@@ -21,32 +21,40 @@
 namespace llvm {
 
 /// \brief Provides information about region coverage for a function/file.
-struct RegionCoverageInfo {
+class RegionCoverageInfo {
   /// \brief The number of regions that were executed at least once.
   size_t Covered;
 
-  /// \brief The number of regions that weren't executed.
-  size_t NotCovered;
-
   /// \brief The total number of regions in a function/file.
   size_t NumRegions;
 
-  RegionCoverageInfo() : Covered(0), NotCovered(0), NumRegions(0) {}
+public:
+  RegionCoverageInfo() : Covered(0), NumRegions(0) {}
 
   RegionCoverageInfo(size_t Covered, size_t NumRegions)
-      : Covered(Covered), NotCovered(NumRegions - Covered),
-        NumRegions(NumRegions) {}
+      : Covered(Covered), NumRegions(NumRegions) {
+    assert(Covered <= NumRegions && "Covered regions over-counted");
+  }
 
   RegionCoverageInfo &operator+=(const RegionCoverageInfo &RHS) {
     Covered += RHS.Covered;
-    NotCovered += RHS.NotCovered;
     NumRegions += RHS.NumRegions;
     return *this;
   }
 
+  void merge(const RegionCoverageInfo &RHS) {
+    Covered = std::max(Covered, RHS.Covered);
+    NumRegions = std::max(NumRegions, RHS.NumRegions);
+  }
+
+  size_t getCovered() const { return Covered; }
+
+  size_t getNumRegions() const { return NumRegions; }
+
   bool isFullyCovered() const { return Covered == NumRegions; }
 
   double getPercentCovered() const {
+    assert(Covered <= NumRegions && "Covered regions over-counted");
     if (NumRegions == 0)
       return 0.0;
     return double(Covered) / double(NumRegions) * 100.0;
@@ -54,31 +62,40 @@ struct RegionCoverageInfo {
 };
 
 /// \brief Provides information about line coverage for a function/file.
-struct LineCoverageInfo {
+class LineCoverageInfo {
   /// \brief The number of lines that were executed at least once.
   size_t Covered;
 
-  /// \brief The number of lines that weren't executed.
-  size_t NotCovered;
-
   /// \brief The total number of lines in a function/file.
   size_t NumLines;
 
-  LineCoverageInfo() : Covered(0), NotCovered(0), NumLines(0) {}
+public:
+  LineCoverageInfo() : Covered(0), NumLines(0) {}
 
   LineCoverageInfo(size_t Covered, size_t NumLines)
-      : Covered(Covered), NotCovered(NumLines - Covered), NumLines(NumLines) {}
+      : Covered(Covered), NumLines(NumLines) {
+    assert(Covered <= NumLines && "Covered lines over-counted");
+  }
 
   LineCoverageInfo &operator+=(const LineCoverageInfo &RHS) {
     Covered += RHS.Covered;
-    NotCovered += RHS.NotCovered;
     NumLines += RHS.NumLines;
     return *this;
   }
 
+  void merge(const LineCoverageInfo &RHS) {
+    Covered = std::max(Covered, RHS.Covered);
+    NumLines = std::max(NumLines, RHS.NumLines);
+  }
+
+  size_t getCovered() const { return Covered; }
+
+  size_t getNumLines() const { return NumLines; }
+
   bool isFullyCovered() const { return Covered == NumLines; }
 
   double getPercentCovered() const {
+    assert(Covered <= NumLines && "Covered lines over-counted");
     if (NumLines == 0)
       return 0.0;
     return double(Covered) / double(NumLines) * 100.0;
@@ -86,13 +103,14 @@ struct LineCoverageInfo {
 };
 
 /// \brief Provides information about function coverage for a file.
-struct FunctionCoverageInfo {
+class FunctionCoverageInfo {
   /// \brief The number of functions that were executed.
   size_t Executed;
 
   /// \brief The total number of functions in this file.
   size_t NumFunctions;
 
+public:
   FunctionCoverageInfo() : Executed(0), NumFunctions(0) {}
 
   FunctionCoverageInfo(size_t Executed, size_t NumFunctions)
@@ -104,9 +122,14 @@ struct FunctionCoverageInfo {
     ++NumFunctions;
   }
 
+  size_t getExecuted() const { return Executed; }
+
+  size_t getNumFunctions() const { return NumFunctions; }
+
   bool isFullyCovered() const { return Executed == NumFunctions; }
 
   double getPercentCovered() const {
+    assert(Executed <= NumFunctions && "Covered functions over-counted");
     if (NumFunctions == 0)
       return 0.0;
     return double(Executed) / double(NumFunctions) * 100.0;
@@ -115,28 +138,30 @@ struct FunctionCoverageInfo {
 
 /// \brief A summary of function's code coverage.
 struct FunctionCoverageSummary {
-  StringRef Name;
+  std::string Name;
   uint64_t ExecutionCount;
   RegionCoverageInfo RegionCoverage;
   LineCoverageInfo LineCoverage;
 
-  FunctionCoverageSummary(StringRef Name) : Name(Name), ExecutionCount(0) {}
+  FunctionCoverageSummary(const std::string &Name)
+      : Name(Name), ExecutionCount(0), RegionCoverage(), LineCoverage() {}
 
-  FunctionCoverageSummary(StringRef Name, uint64_t ExecutionCount,
+  FunctionCoverageSummary(const std::string &Name, uint64_t ExecutionCount,
                           const RegionCoverageInfo &RegionCoverage,
                           const LineCoverageInfo &LineCoverage)
       : Name(Name), ExecutionCount(ExecutionCount),
-        RegionCoverage(RegionCoverage), LineCoverage(LineCoverage) {
-  }
+        RegionCoverage(RegionCoverage), LineCoverage(LineCoverage) {}
 
   /// \brief Compute the code coverage summary for the given function coverage
   /// mapping record.
-  static FunctionCoverageSummary
-  get(const coverage::FunctionRecord &Function);
+  static FunctionCoverageSummary get(const coverage::CoverageMapping &CM,
+                                     const coverage::FunctionRecord &Function);
 
-  /// \brief Update the summary with information from another instantiation
-  /// of this function.
-  void update(const FunctionCoverageSummary &Summary);
+  /// Compute the code coverage summary for an instantiation group \p Group,
+  /// given a list of summaries for each instantiation in \p Summaries.
+  static FunctionCoverageSummary
+  get(const coverage::InstantiationGroup &Group,
+      ArrayRef<FunctionCoverageSummary> Summaries);
 };
 
 /// \brief A summary of file's code coverage.
@@ -147,7 +172,9 @@ struct FileCoverageSummary {
   FunctionCoverageInfo FunctionCoverage;
   FunctionCoverageInfo InstantiationCoverage;
 
-  FileCoverageSummary(StringRef Name) : Name(Name) {}
+  FileCoverageSummary(StringRef Name)
+      : Name(Name), RegionCoverage(), LineCoverage(), FunctionCoverage(),
+        InstantiationCoverage() {}
 
   void addFunction(const FunctionCoverageSummary &Function) {
     RegionCoverage += Function.RegionCoverage;