[sancov] Port sancov -print-coverage-pcs to COFF

[rnk]

Summary

The export table is not considered part of the object file symbol table,
so we have to look through it separately.

Also add the $arch-registered-target features that clang uses to disable
tests that require a registered backend, so that we can run the sancov
tests on Windows. LLVM's lit suite did not appear to have a per-test way
to do this, and I would rather not split up the sancov tests into
architecture directories.

[kcc]

code almost LG,
not an expert in lit part. Anyone else?

tools/sancov/sancov.cc

355 ↗

(On Diff #67352)

don't copy-paste this if statement, move it into a separate function instead.

[rnk]

In D23321#510427, @kcc wrote:

code almost LG,
not an expert in lit part. Anyone else?

The lit part is pretty trivial. I'm comfortable landing if you like and stamp the sancov part.

tools/sancov/sancov.cc

355 ↗

(On Diff #67352)

Done

[rnk]

• factor out isCoveragePointSymbol

[kcc]

LGTM, but it will clash with a similar Mike's patch for Mac

llvm/trunk/test/tools/sancov/print_coverage_pcs.test

 REQUIRES: x86-registered-target
-RUN: sancov -print-coverage-pcs %p/Inputs/test-linux_x86_64 | FileCheck %s
+RUN: sancov -print-coverage-pcs %p/Inputs/test-linux_x86_64 | FileCheck %s --check-prefix=LINUX
+RUN: llvm-objdump -d %p/Inputs/test-windows_x86_64 | FileCheck %s --check-prefix=DISAS_WIN
+RUN: sancov -print-coverage-pcs %p/Inputs/test-windows_x86_64 | FileCheck %s --check-prefix=WINDOWS
 
-CHECK: 0x4e132b
-CHECK: 0x4e1472
-CHECK: 0x4e14c2
-CHECK: 0x4e1520
-CHECK: 0x4e1553
-CHECK: 0x4e1586
-CHECK: 0x4e1635
-CHECK: 0x4e1690
-CHECK: 0x4e178c
+LINUX: 0x4e132b
+LINUX: 0x4e1472
+LINUX: 0x4e14c2
+LINUX: 0x4e1520
+LINUX: 0x4e1553
+LINUX: 0x4e1586
+LINUX: 0x4e1635
+LINUX: 0x4e1690
+LINUX: 0x4e178c
 
+The coverage PCs should be equal to the return address of the call minus one. A
+direct call is five bytes, so the coverage PCs should be call PC plus four.
+
+DISAS_WIN: 14000103f: {{.*}}  callq   {{.*}} <__sanitizer_cov>
+WINDOWS: 0x140001043
+DISAS_WIN: 140001074: {{.*}}  callq   {{.*}} <__sanitizer_cov>
+WINDOWS: 0x140001078
+DISAS_WIN: 1400011df: {{.*}}  callq   {{.*}} <__sanitizer_cov>
+WINDOWS: 0x1400011e3
+DISAS_WIN: 140001227: {{.*}}  callq   {{.*}} <__sanitizer_cov>
+WINDOWS: 0x14000122b
+DISAS_WIN: 14000147e: {{.*}}  callq   {{.*}} <__sanitizer_cov>
+WINDOWS: 0x140001482
+DISAS_WIN: 1400015b6: {{.*}}  callq   {{.*}} <__sanitizer_cov>
+WINDOWS: 0x1400015ba
+DISAS_WIN: 140001629: {{.*}}  callq   {{.*}} <__sanitizer_cov>
+WINDOWS: 0x14000162d
+DISAS_WIN: 140001664: {{.*}}  callq   {{.*}} <__sanitizer_cov>
+WINDOWS: 0x140001668
+DISAS_WIN: 1400016f2: {{.*}}  callq   {{.*}} <__sanitizer_cov>
+WINDOWS: 0x1400016f6

llvm/trunk/tools/sancov/sancov.cc

 #include "llvm/MC/MCInstPrinter.h"
 #include "llvm/MC/MCInstrAnalysis.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/Binary.h"
+#include "llvm/Object/COFF.h"
 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/LineIterator.h"
if (InlinedCode) {
         Result.push_back(FrameAddrInfo);
       }
     }
   }
 
   return Result;
 }
 
+static bool isCoveragePointSymbol(StringRef Name) {
+  return Name == "__sanitizer_cov" || Name == "__sanitizer_cov_with_check" ||
+         Name == "__sanitizer_cov_trace_func_enter";
+}
+
 // Locate __sanitizer_cov* function addresses that are used for coverage
 // reporting.
 static std::set<uint64_t>
 findSanitizerCovFunctions(const object::ObjectFile &O) {
   std::set<uint64_t> Result;
 
   for (const object::SymbolRef &Symbol : O.symbols()) {
     Expected<uint64_t> AddressOrErr = Symbol.getAddress();
     FailIfError(errorToErrorCode(AddressOrErr.takeError()));
 
     Expected<StringRef> NameOrErr = Symbol.getName();
     FailIfError(errorToErrorCode(NameOrErr.takeError()));
     StringRef Name = NameOrErr.get();
 
-    if (Name == "__sanitizer_cov" || Name == "__sanitizer_cov_with_check" ||
-        Name == "__sanitizer_cov_trace_func_enter") {
+    if (isCoveragePointSymbol(Name)) {
       if (!(Symbol.getFlags() & object::BasicSymbolRef::SF_Undefined))
         Result.insert(AddressOrErr.get());
     }
   }
 
+  if (const auto *CO = dyn_cast<object::COFFObjectFile>(&O)) {
+    for (const object::ExportDirectoryEntryRef &Export :
+         CO->export_directories()) {
+      uint32_t RVA;
+      std::error_code EC = Export.getExportRVA(RVA);
+      FailIfError(EC);
+
+      StringRef Name;
+      EC = Export.getSymbolName(Name);
+      FailIfError(EC);
+
+      if (isCoveragePointSymbol(Name))
+        Result.insert(CO->getImageBase() + RVA);
+    }
+  }
+
   return Result;
 }
 
 // Locate addresses of all coverage points in a file. Coverage point
 // is defined as the 'address of instruction following __sanitizer_cov
 // call - 1'.
 static void getObjectCoveragePoints(const object::ObjectFile &O,
                                     std::set<uint64_t> *Addrs) {
public:
   static ErrorOr<std::unique_ptr<CoverageData>>
   read(const std::string &FileName) {
     ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
         MemoryBuffer::getFile(FileName);
     if (!BufOrErr)
       return BufOrErr.getError();
     std::unique_ptr<MemoryBuffer> Buf = std::move(BufOrErr.get());
     if (Buf->getBufferSize() < 8) {
-      errs() << "File too small (<8): " << Buf->getBufferSize();
+      errs() << "File too small (<8): " << Buf->getBufferSize() << '\n';
       return make_error_code(errc::illegal_byte_sequence);
     }
     const FileHeader *Header =
         reinterpret_cast<const FileHeader *>(Buf->getBufferStart());
 
     if (Header->Magic != BinCoverageMagic) {
-      errs() << "Wrong magic: " << Header->Magic;
+      errs() << "Wrong magic: " << Header->Magic << '\n';
       return make_error_code(errc::illegal_byte_sequence);
     }
 
     auto Addrs = llvm::make_unique<std::set<uint64_t>>();
 
     switch (Header->Bitness) {
     case Bitness64:
       readInts<uint64_t>(Buf->getBufferStart() + 8, Buf->getBufferEnd(),
                          Addrs.get());
       break;
     case Bitness32:
       readInts<uint32_t>(Buf->getBufferStart() + 8, Buf->getBufferEnd(),
                          Addrs.get());
       break;
     default:
-      errs() << "Unsupported bitness: " << Header->Bitness;
+      errs() << "Unsupported bitness: " << Header->Bitness << '\n';
       return make_error_code(errc::illegal_byte_sequence);
     }
 
     return std::unique_ptr<CoverageData>(new CoverageData(std::move(Addrs)));
   }
 
   // Merge multiple coverage data together.
   static std::unique_ptr<CoverageData>