Introduce the dedicated class CounterPair instead of std::pair

Author: chapuni

clang/lib/CodeGen/CodeGenFunction.h

@@ -1620,9 +1620,7 @@ class CodeGenFunction : public CodeGenTypeCache {
                                             uint64_t LoopCount) const;
 
 public:
-  std::pair<bool, bool> getIsCounterPair(const Stmt *S) const {
-    return PGO.getIsCounterPair(S);
-  }
+  auto getIsCounterPair(const Stmt *S) const { return PGO.getIsCounterPair(S); }
 
   void markStmtAsUsed(bool Skipped, const Stmt *S) {
     PGO.markStmtAsUsed(Skipped, S);

clang/lib/CodeGen/CodeGenModule.h

@@ -102,23 +102,48 @@ enum ForDefinition_t : bool {
   ForDefinition = true
 };
 
-class CounterPair : public std::pair<uint32_t, uint32_t> {
-private:
-  static constexpr uint32_t None = (1u << 31); /// None is set
-
+/// The Counter with an optional additional Counter for
+/// branches. `Skipped` counter can be calculated with `Executed` and
+/// a common Counter (like `Parent`) as `(Parent-Executed)`.
+///
+/// In SingleByte mode, Counters are binary. Subtraction is not
+/// applicable (but addition is capable). In this case, both
+/// `Executed` and `Skipped` counters are required.  `Skipped` is
+/// `None` by default. It is allocated in the coverage mapping.
+///
+/// There might be cases that `Parent` could be induced with
+/// `(Executed+Skipped)`. This is not always applicable.
+class CounterPair {
 public:
-  static constexpr uint32_t Mask = None - 1;
+  /// Optional value.
+  class ValueOpt {
+  private:
+    static constexpr uint32_t None = (1u << 31); /// None is allocated.
+    static constexpr uint32_t Mask = None - 1;
 
-public:
-  CounterPair(unsigned Val = 0) {
-    assert(!(Val & ~Mask));
-    first = Val;
-    second = None;
-  }
+    uint32_t Val;
 
-  std::pair<bool, bool> getIsCounterPair() const {
-    return {!(first & None), !(second & None)};
-  }
+  public:
+    ValueOpt() : Val(None) {}
+
+    ValueOpt(unsigned InitVal) {
+      assert(!(InitVal & ~Mask));
+      Val = InitVal;
+    }
+
+    bool hasValue() const { return !(Val & None); }
+
+    operator uint32_t() const { return Val; }
+  };
+
+  ValueOpt Executed;
+  ValueOpt Skipped; /// May be None.
+
+  /// Initialized with Skipped=None.
+  CounterPair(unsigned Val) : Executed(Val) {}
+
+  // FIXME: Should work with {None, None}
+  CounterPair() : Executed(0) {}
 };
 
 struct OrderGlobalInitsOrStermFinalizers {

clang/lib/CodeGen/CodeGenPGO.cpp

@@ -1186,17 +1186,22 @@ CodeGenPGO::applyFunctionAttributes(llvm::IndexedInstrProfReader *PGOReader,
 }
 
 std::pair<bool, bool> CodeGenPGO::getIsCounterPair(const Stmt *S) const {
-  if (!RegionCounterMap || RegionCounterMap->count(S) == 0)
+  if (!RegionCounterMap)
     return {false, false};
-  return (*RegionCounterMap)[S].getIsCounterPair();
+
+  auto I = RegionCounterMap->find(S);
+  if (I == RegionCounterMap->end())
+    return {false, false};
+
+  return {I->second.Executed.hasValue(), I->second.Skipped.hasValue()};
 }
 
 void CodeGenPGO::emitCounterSetOrIncrement(CGBuilderTy &Builder, const Stmt *S,
                                            llvm::Value *StepV) {
   if (!RegionCounterMap || !Builder.GetInsertBlock())
     return;
 
-  unsigned Counter = (*RegionCounterMap)[S].first;
+  unsigned Counter = (*RegionCounterMap)[S].Executed;
 
   // Make sure that pointer to global is passed in with zero addrspace
   // This is relevant during GPU profiling

clang/lib/CodeGen/CodeGenPGO.h

@@ -143,7 +143,7 @@ class CodeGenPGO {
       return 0;
     // With profiles from a differing version of clang we can have mismatched
     // decl counts. Don't crash in such a case.
-    auto Index = (*RegionCounterMap)[S].first;
+    auto Index = (*RegionCounterMap)[S].Executed;
     if (Index >= RegionCounts.size())
       return 0;
     return RegionCounts[Index];

clang/lib/CodeGen/CoverageMappingGen.cpp

@@ -935,7 +935,7 @@ struct CounterCoverageMappingBuilder
   ///
   /// This should only be called on statements that have a dedicated counter.
   Counter getRegionCounter(const Stmt *S) {
-    return Counter::getCounter(CounterMap[S].first);
+    return Counter::getCounter(CounterMap[S].Executed);
   }
 
   /// Push a region onto the stack.