[sancov] MachO indirect symbols support.

[vitalybuka]

lgtm

tools/sancov/sancov.cc

350 ↗

(On Diff #67433)

Why not just J < Dysymtab.nindirectsyms

387 ↗

(On Diff #67433)

Can you combine if and fastest test in-front of slowest?

if (!(Symbol.getFlags() & object::BasicSymbolRef::SF_Undefined) && isSanitizerCovCall(Name))

Result.insert(Address);

[aizatsky]

nitz

[aizatsky]

ptal

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 --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
+RUN: sancov -print-coverage-pcs %p/Inputs/test-darwin_x86_64 | FileCheck %s --check-prefix=DARWIN
 
 LINUX: 0x4e132b
 LINUX: 0x4e1472
 LINUX: 0x4e14c2
 LINUX: 0x4e1520
 LINUX: 0x4e1553
 LINUX: 0x4e1586
 LINUX: 0x4e1635

 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
+
+CHECK: 0x4e132b
+CHECK: 0x4e1472
+CHECK: 0x4e14c2
+CHECK: 0x4e1520
+CHECK: 0x4e1553
+CHECK: 0x4e1586
+CHECK: 0x4e1635
+CHECK: 0x4e1690
+CHECK: 0x4e178c
+
+DARWIN: 0x100001527
+DARWIN: 0x100001668
+DARWIN: 0x1000016b7
+DARWIN: 0x1000016dd
+DARWIN: 0x10000179d
+DARWIN: 0x1000017cc
+DARWIN: 0x10000189d
+DARWIN: 0x1000018e0
+DARWIN: 0x100001906
+DARWIN: 0x1000019dc
+DARWIN: 0x100001a28
+>>>>>>> [sancov] MachO indirect symbols support.

llvm/trunk/tools/sancov/sancov.cc

 #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/MachO.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"
 #include "llvm/Support/MD5.h"
for (auto Addr : Addrs) {
     }
   }
 
   return Result;
 }
 
 static bool isCoveragePointSymbol(StringRef Name) {
   return Name == "__sanitizer_cov" || Name == "__sanitizer_cov_with_check" ||
-         Name == "__sanitizer_cov_trace_func_enter";
+         Name == "__sanitizer_cov_trace_func_enter" ||
+         // Mac has '___' prefix
+         Name == "___sanitizer_cov" || Name == "___sanitizer_cov_with_check" ||
+         Name == "___sanitizer_cov_trace_func_enter";
+}
+
+// Locate __sanitizer_cov* function addresses inside the stubs table on MachO.
+static void findMachOIndirectCovFunctions(const object::MachOObjectFile &O,
+                                          std::set<uint64_t> *Result) {
+  MachO::dysymtab_command Dysymtab = O.getDysymtabLoadCommand();
+  MachO::symtab_command Symtab = O.getSymtabLoadCommand();
+
+  for (const auto &Load : O.load_commands()) {
+    if (Load.C.cmd == MachO::LC_SEGMENT_64) {
+      MachO::segment_command_64 Seg = O.getSegment64LoadCommand(Load);
+      for (unsigned J = 0; J < Seg.nsects; ++J) {
+        MachO::section_64 Sec = O.getSection64(Load, J);
+
+        uint32_t SectionType = Sec.flags & MachO::SECTION_TYPE;
+        if (SectionType == MachO::S_SYMBOL_STUBS) {
+          uint32_t Stride = Sec.reserved2;
+          uint32_t Cnt = Sec.size / Stride;
+          uint32_t N = Sec.reserved1;
+          for (uint32_t J = 0; J < Cnt && N + J < Dysymtab.nindirectsyms; J++) {
+            uint32_t IndirectSymbol =
+                O.getIndirectSymbolTableEntry(Dysymtab, N + J);
+            uint64_t Addr = Sec.addr + J * Stride;
+            if (IndirectSymbol < Symtab.nsyms) {
+              object::SymbolRef Symbol = *(O.getSymbolByIndex(IndirectSymbol));
+              Expected<StringRef> Name = Symbol.getName();
+              FailIfError(Name);
+              if (isCoveragePointSymbol(Name.get())) {
+                Result->insert(Addr);
+              }
+            }
+          }
+        }
+      }
+    }
+    if (Load.C.cmd == MachO::LC_SEGMENT) {
+      errs() << "ERROR: 32 bit MachO binaries not supported\n";
+    }
+  }
 }
 
 // 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()));
+    FailIfError(AddressOrErr);
+    uint64_t Address = AddressOrErr.get();
 
     Expected<StringRef> NameOrErr = Symbol.getName();
-    FailIfError(errorToErrorCode(NameOrErr.takeError()));
+    FailIfError(NameOrErr);
     StringRef Name = NameOrErr.get();
 
-    if (isCoveragePointSymbol(Name)) {
-      if (!(Symbol.getFlags() & object::BasicSymbolRef::SF_Undefined))
-        Result.insert(AddressOrErr.get());
+    if (!(Symbol.getFlags() & object::BasicSymbolRef::SF_Undefined) &&
+        isCoveragePointSymbol(Name)) {
+      Result.insert(Address);
     }
   }
 
   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);
     }
   }
 
+  if (const auto *MO = dyn_cast<object::MachOObjectFile>(&O)) {
+    findMachOIndirectCovFunctions(*MO, &Result);
+  }
+
   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) {

 }
 
 static void
 visitObjectFiles(const object::Archive &A,
                  function_ref<void(const object::ObjectFile &)> Fn) {
   Error Err;
   for (auto &C : A.children(Err)) {
     Expected<std::unique_ptr<object::Binary>> ChildOrErr = C.getAsBinary();
-    FailIfError(errorToErrorCode(ChildOrErr.takeError()));
+    FailIfError(ChildOrErr);
     if (auto *O = dyn_cast<object::ObjectFile>(&*ChildOrErr.get()))
       Fn(*O);
     else
       FailIfError(object::object_error::invalid_file_type);
   }
   FailIfError(std::move(Err));
 }
 
 static void
 visitObjectFiles(const std::string &FileName,
                  function_ref<void(const object::ObjectFile &)> Fn) {
   Expected<object::OwningBinary<object::Binary>> BinaryOrErr =
       object::createBinary(FileName);
   if (!BinaryOrErr)
-    FailIfError(errorToErrorCode(BinaryOrErr.takeError()));
+    FailIfError(BinaryOrErr);
 
   object::Binary &Binary = *BinaryOrErr.get().getBinary();
   if (object::Archive *A = dyn_cast<object::Archive>(&Binary))
     visitObjectFiles(*A, Fn);
   else if (object::ObjectFile *O = dyn_cast<object::ObjectFile>(&Binary))
     Fn(*O);
   else
     FailIfError(object::object_error::invalid_file_type);