[LLVMCov] Swapped the line and count columns.

[MaggieYi]

Summary

In the coverage report, the line and count columns have been swapped to make it more readable.

[vsk]

LGTM.

[MaggieYi]

Thanks Vedant.

When the line and count columns are swapped, the compiler-rt profile regression tests need to be updated as well. I have added another patch to update the compiler-rt regression tests. Since llvm and compile-rt are in the different repositories, should I commit two patches separately? (This will cause test failures).

[MaggieYi]

Fix a linux test.

[vsk]

In D23281#509803, @MaggieYi wrote:

When the line and count columns are swapped, the compiler-rt profile regression tests need to be updated as well. I have added another patch to update the compiler-rt regression tests. Since llvm and compile-rt are in the different repositories, should I commit two patches separately? (This will cause test failures).

I think it would be fine to commit the two patches separately but simultaneously. The bots may go red temporarily, but that won't be alarming if you mention that a follow-up commit in compiler-rt is needed in your commit message.

Do you have a linux machine to test the changes to test/profile/Linux/coverage_*? If not, I can help with that.

[MaggieYi]

In D23281#510048, @vsk wrote:

I think it would be fine to commit the two patches separately but simultaneously. The bots may go red temporarily, but that won't be alarming if you mention that a follow-up commit in compiler-rt is needed in your commit message.

Do you have a linux machine to test the changes to test/profile/Linux/coverage_*? If not, I can help with that.

Thanks very much for your help. I have a linux machine to run the compiler-rt tests. With the change, all llvm/clang/compiler-rt regression tests passed.

I will follow your advice to commit two patches separately but simultaneously.

[MaggieYi]

Hello Vedant,

I have committed the llvm-cov patch to llvm. When I try to commit compiler-rt patch, I can't commit the patch. Could you help me commit the compiler-rt patch?

Many thanks,

test/profile/Inputs/extern_template.h

 template <typename T> struct Test {
   Test() : M(10) {}
-  void doIt(int N) { // CHECK: 2| [[@LINE]]|  void doIt
-    if (N > 10) {    // CHECK: 2| [[@LINE]]|    if (N > 10) {
-      M += 2;        // CHECK: 1| [[@LINE]]|      M += 2;
-    } else           // CHECK: 1| [[@LINE]]|    } else
-      M -= 2;        // CHECK: 1| [[@LINE]]|      M -= 2;
+  void doIt(int N) { // CHECK: [[@LINE]]| 2|  void doIt
+    if (N > 10) {    // CHECK: [[@LINE]]| 2|    if (N > 10) {
+      M += 2;        // CHECK: [[@LINE]]| 1|      M += 2;
+    } else           // CHECK: [[@LINE]]| 1|    } else
+      M -= 2;        // CHECK: [[@LINE]]| 1|      M -= 2;
   }
   T M;
 };
 
 #ifdef USE
 extern template struct Test<int>;
 #endif
 #ifdef DEF
 template struct Test<int>;
 #endif

test/profile/Inputs/instrprof-comdat.h

 // Template instantiations are placed into comdat sections. Check that
 // coverage data from different instantiations are mapped back to the correct
 // source regions.
 
 template <class T> class FOO {
 public:
   FOO() : t(0) {}
 
   T DoIt(T ti);
 
 private:
   T t;
 };
 
-template <class T> T FOO<T>::DoIt(T ti) { // HEADER:  2| [[@LINE]]|template
-  for (T I = 0; I < ti; I++) {            // HEADER: 22| [[@LINE]]|  for (T
-    t += I;                               // HEADER: 20| [[@LINE]]|    t += I;
-    if (I > ti / 2)                       // HEADER: 20| [[@LINE]]|    if (I > ti 
-      t -= 1;                             // HEADER:  8| [[@LINE]]|      t -= 1;
-  }                                       // HEADER: 10| [[@LINE]]|  }
-                                          // HEADER:  1| [[@LINE]]|
-  return t;                               // HEADER:  1| [[@LINE]]|  return t;
+template <class T> T FOO<T>::DoIt(T ti) { // HEADER: [[@LINE]]|  2|template
+  for (T I = 0; I < ti; I++) {            // HEADER: [[@LINE]]| 22|  for (T
+    t += I;                               // HEADER: [[@LINE]]| 20|    t += I;
+    if (I > ti / 2)                       // HEADER: [[@LINE]]| 20|    if (I > ti
+      t -= 1;                             // HEADER: [[@LINE]]|  8|      t -= 1;
+  }                                       // HEADER: [[@LINE]]| 10|  }
+                                          // HEADER: [[@LINE]]|  1|
+  return t;                               // HEADER: [[@LINE]]|  1|  return t;
 }

test/profile/Inputs/instrprof-dynamic-a.cpp

 #include "instrprof-dynamic-header.h"
-void a() {                             // COV: 1| [[@LINE]]|void a
-  if (true) {                          // COV: 1| [[@LINE]]|  if
-    bar<void>(1);                      // COV: 1| [[@LINE]]|    bar
-    bar<char>(1);                      // COV: 1| [[@LINE]]|    bar
-  }                                    // COV: 1| [[@LINE]]|  }
+void a() {                             // COV: [[@LINE]]| 1|void a
+  if (true) {                          // COV: [[@LINE]]| 1|  if
+    bar<void>(1);                      // COV: [[@LINE]]| 1|    bar
+    bar<char>(1);                      // COV: [[@LINE]]| 1|   bar
+  }                                    // COV: [[@LINE]]| 1|  }
 }

test/profile/Linux/coverage_ctors.cpp

Base(const Base &b2) {
     B = b2.B + 5;
   }
   Base(Base &&b2) {
     B = b2.B + 10;
   }
 };
 
 struct Derived : public Base {
-  Derived(const Derived &) = default; // CHECK:  2| [[@LINE]]|  Derived(const Derived &) = default;
-  Derived(Derived &&) = default;      // CHECK:  1| [[@LINE]]|  Derived(Derived &&) = default;
-  Derived() = default;                // CHECK:  1| [[@LINE]]|  Derived() = default
+  Derived(const Derived &) = default; // CHECK:  [[@LINE]]| 2|  Derived(const Derived &) = default;
+  Derived(Derived &&) = default;      // CHECK:  [[@LINE]]| 1| Derived(Derived &&) = default;
+  Derived() = default;                // CHECK:  [[@LINE]]| 1| Derived() = default
 };
 
 Derived dd;
 int main() {
   Derived dd2(dd);
   Derived dd3(dd2);
   Derived dd4(static_cast<Derived &&>(dd3));
 
   if (dd.B != 0 || dd2.B != 5 || dd3.B != 10 || dd4.B != 20)
-    return 1;                         // CHECK: 0| [[@LINE]]|     return 1;
+    return 1;                         // CHECK: [[@LINE]]| 0|     return 1;
   return 0;
 }

test/profile/Linux/coverage_dtor.cpp

 // RUN: %clang_profgen -x c++ -fno-exceptions  -std=c++11 -fuse-ld=gold -fcoverage-mapping -o %t %s
 // RUN: env LLVM_PROFILE_FILE=%t.profraw %run %t
 // RUN: llvm-profdata merge -o %t.profdata %t.profraw
 // RUN: llvm-cov show %t -instr-profile %t.profdata -filename-equivalence 2>&1 | FileCheck %s
 
 int g = 100;
 struct Base {
   int B;
   Base(int B_) : B(B_) {}
   ~Base() { g -= B; }
 };
 
 struct Derived : public Base {
   Derived(int K) : Base(K) {}
-  ~Derived() = default; // CHECK:  2| [[@LINE]]|  ~Derived() = default;
+  ~Derived() = default; // CHECK:  [[@LINE]]| 2|  ~Derived() = default;
 };
 
 int main() {
   {
     Derived dd(10);
     Derived dd2(90);
   }
   if (g != 0)
-    return 1;          // CHECK:  0| [[@LINE]]|    return 1;
+    return 1;          // CHECK:  [[@LINE]]|  0|   return 1;
   return 0;
 }

test/profile/Linux/coverage_test.cpp

 // RUN: %clang_profgen -O2  -fcoverage-mapping -Wl,--gc-sections -o %t.3 %s
 // RUN: llvm-objdump -h %t.3 | FileCheck --check-prefix COVMAP %s
 // Check PIE option
 // RUN: %clang_profgen -fuse-ld=gold -O2 -fdata-sections -ffunction-sections -fPIE -pie -fcoverage-mapping -Wl,--gc-sections -o %t.pie %s
 // RUN: env LLVM_PROFILE_FILE=%t.pie.profraw %run %t.pie
 // RUN: llvm-profdata merge -o %t.pie.profdata %t.pie.profraw
 // RUN: llvm-cov show %t.pie -instr-profile %t.pie.profdata -filename-equivalence 2>&1 | FileCheck %s
 
-void foo(bool cond) { // CHECK:  1| [[@LINE]]|void foo(
-  if (cond) {         // CHECK:  1| [[@LINE]]|  if (cond) {
-  }                   // CHECK:  0| [[@LINE]]|  }
-}                     // CHECK:  1| [[@LINE]]|}
-void bar() {          // CHECK:  1| [[@LINE]]|void bar() {
-}                     // CHECK:  1| [[@LINE]]|}
-void func() {         // CHECK:  0| [[@LINE]]|void func(
-}                     // CHECK:  0| [[@LINE]]|}
-int main() {          // CHECK:  1| [[@LINE]]|int main(
-  foo(false);         // CHECK:  1| [[@LINE]]|  foo(
-  bar();              // CHECK:  1| [[@LINE]]|  bar(
-  return 0;           // CHECK:  1| [[@LINE]]|  return
-}                     // CHECK:  1| [[@LINE]]|}
+void foo(bool cond) { // CHECK:  [[@LINE]]| 1|void foo(
+  if (cond) {         // CHECK:  [[@LINE]]| 1| if (cond) {
+  }                   // CHECK:  [[@LINE]]| 0|  }
+}                     // CHECK:  [[@LINE]]| 1|}
+void bar() {          // CHECK:  [[@LINE]]| 1|void bar() {
+}                     // CHECK:  [[@LINE]]| 1|}
+void func() {         // CHECK:  [[@LINE]]| 0|void func(
+}                     // CHECK:  [[@LINE]]| 0|}
+int main() {          // CHECK:  [[@LINE]]| 1|int main(
+  foo(false);         // CHECK:  [[@LINE]]| 1| foo(
+  bar();              // CHECK:  [[@LINE]]| 1|  bar(
+  return 0;           // CHECK:  [[@LINE]]| 1| return
+}                     // CHECK:  [[@LINE]]| 1|}
 
 // COVMAP: __llvm_covmap {{.*}}