[llvm-cov] Fix llvm-cov on Windows and un-XFAIL test

[rnk]

Summary

The llvm-cov tool needs to be able to find coverage names in the
executable, so the .lprfn and .lcovmap sections cannot be merged into
.rdata.

Also, the linker merges .lprfn$M into .lprfn, so llvm-cov needs to
handle that when looking up sections. It has to support running on both
relocatable object files and linked PE files.

Lastly, when loading .lprfn from a PE file, llvm-cov needs to skip the
leading zero byte added by the profile runtime.

[vsk]

I suppose Names{Start,End} are needed on Windows so that we can find section boundaries.

Thanks, lgtm.

[rnk]

In D58661#1410041, @vsk wrote:

I suppose Names{Start,End} are needed on Windows so that we can find section boundaries.

Yep. Along the way I tried this creative code pattern, which works with clang but not MSVC:

const char COMPILER_RT_SECTION(".lprfn$A") NamesStart[0] = {};
const char COMPILER_RT_SECTION(".lprfn$Z") NamesEnd[0] = {};

Thanks, lgtm.

Thanks!

compiler-rt/lib/profile/InstrProfilingPlatformWindows.c

 #if defined(_WIN32)
 
 #if defined(_MSC_VER)
 /* Merge read-write sections into .data. */
 #pragma comment(linker, "/MERGE:.lprfc=.data")
 #pragma comment(linker, "/MERGE:.lprfd=.data")
 #pragma comment(linker, "/MERGE:.lprfv=.data")
 #pragma comment(linker, "/MERGE:.lprfnd=.data")
-/* Merge read-only sections into .rdata. */
-#pragma comment(linker, "/MERGE:.lprfn=.rdata")
-#pragma comment(linker, "/MERGE:.lcovmap=.rdata")
+/* Do *NOT* merge .lprfn and .lcovmap into .rdata. llvm-cov must be able to find
+ * after the fact.
+ */
 
 /* Allocate read-only section bounds. */
 #pragma section(".lprfn$A", read)
 #pragma section(".lprfn$Z", read)
 
 /* Allocate read-write section bounds. */
 #pragma section(".lprfd$A", read, write)
 #pragma section(".lprfd$Z", read, write)

compiler-rt/test/profile/instrprof-merging.cpp

 // RUN: llvm-cov show %t.v1.o -object %t.v2.o -instr-profile=%t.profdata | FileCheck %s -check-prefixes=V1,V2
 // RUN: llvm-cov show %t.exe -instr-profile=%t.profdata | FileCheck %s -check-prefixes=V1,V2
 
 // 4) Verify that coverage reporting on the aggregate coverage mapping shows
 //    hits for all code. (We used to arbitrarily pick a mapping from one binary
 //    and prefer it over others.) When only limited coverage information is
 //    available (just from one binary), don't try to guess any region counts.
 
-// FIXME: Fails with: "Failed to load coverage: No coverage data found"
-// XFAIL: windows
-
 struct A {
   A() {}    // V1: [[@LINE]]{{ *}}|{{ *}}1
             // V1-ONLY: [[@LINE+1]]{{ *}}|{{ *}}|
   A(int) {} // V2-ONLY: [[@LINE-2]]{{ *}}|{{ *}}|
             // V2: [[@LINE-1]]{{ *}}|{{ *}}1
 };
 
 #ifdef _VERSION_1

llvm/lib/ProfileData/Coverage/CoverageMappingReader.cpp

 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Object/Binary.h"
 #include "llvm/Object/Error.h"
 #include "llvm/Object/MachOUniversal.h"
 #include "llvm/Object/ObjectFile.h"
+#include "llvm/Object/COFF.h"
 #include "llvm/ProfileData/InstrProf.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/MathExtras.h"
Expected<bool> RawCoverageMappingDummyChecker::isDummy() {
   unsigned Tag = EncodedCounterAndRegion & Counter::EncodingTagMask;
   return Tag == Counter::Zero;
 }
 
 Error InstrProfSymtab::create(SectionRef &Section) {
   if (auto EC = Section.getContents(Data))
     return errorCodeToError(EC);
   Address = Section.getAddress();
+
+  // If this is a linked PE/COFF file, then we have to skip over the null byte
+  // that is allocated in the .lprfn$A section in the LLVM profiling runtime.
+  const ObjectFile *Obj = Section.getObject();
+  if (isa<COFFObjectFile>(Obj) && !Obj->isRelocatableObject())
+    Data = Data.drop_front(1);
+
   return Error::success();
 }
 
 StringRef InstrProfSymtab::getFuncName(uint64_t Pointer, size_t Size) {
   if (Pointer < Address)
     return StringRef();
   auto Offset = Pointer - Address;
   if (Offset + Size > Data.size())
static Error loadTestingFormat(StringRef Data, InstrProfSymtab &ProfileNames,
   size_t Pad = alignmentAdjustment(CoverageMapping.data(), 8);
   if (CoverageMapping.size() < Pad)
     return make_error<CoverageMapError>(coveragemap_error::malformed);
   CoverageMapping = CoverageMapping.substr(Pad);
   return Error::success();
 }
 
 static Expected<SectionRef> lookupSection(ObjectFile &OF, StringRef Name) {
+  // On COFF, the object file section name may end in "$M". This tells the
+  // linker to sort these sections between "$A" and "$Z". The linker removes the
+  // dollar and everything after it in the final binary. Do the same to match.
+  bool IsCOFF = isa<COFFObjectFile>(OF);
+  auto stripSuffix = [IsCOFF](StringRef N) {
+    return IsCOFF ? N.split('$').first : N;
+  };
+  Name = stripSuffix(Name);
+
   StringRef FoundName;
   for (const auto &Section : OF.sections()) {
     if (auto EC = Section.getName(FoundName))
       return errorCodeToError(EC);
-    if (FoundName == Name)
+    if (stripSuffix(FoundName) == Name)
       return Section;
   }
   return make_error<CoverageMapError>(coveragemap_error::no_data_found);
 }
 
 static Error loadBinaryFormat(MemoryBufferRef ObjectBuffer,
                               InstrProfSymtab &ProfileNames,
                               StringRef &CoverageMapping,