contrib/compiler-rt/lib/fuzzer/FuzzerTracePC.cpp

   1 //===- FuzzerTracePC.cpp - PC tracing--------------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 // Trace PCs.
  10 // This module implements __sanitizer_cov_trace_pc_guard[_init],
  11 // the callback required for -fsanitize-coverage=trace-pc-guard instrumentation.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "FuzzerTracePC.h"
  16 #include "FuzzerBuiltins.h"
  17 #include "FuzzerBuiltinsMsvc.h"
  18 #include "FuzzerCorpus.h"
  19 #include "FuzzerDefs.h"
  20 #include "FuzzerDictionary.h"
  21 #include "FuzzerExtFunctions.h"
  22 #include "FuzzerIO.h"
  23 #include "FuzzerUtil.h"
  24 #include "FuzzerValueBitMap.h"
  25 #include <set>
  26
  27 // The coverage counters and PCs.
  28 // These are declared as global variables named "__sancov_*" to simplify
  29 // experiments with inlined instrumentation.
  30 alignas(64) ATTRIBUTE_INTERFACE
  31 uint8_t __sancov_trace_pc_guard_8bit_counters[fuzzer::TracePC::kNumPCs];
  32
  33 ATTRIBUTE_INTERFACE
  34 uintptr_t __sancov_trace_pc_pcs[fuzzer::TracePC::kNumPCs];
  35
  36 // Used by -fsanitize-coverage=stack-depth to track stack depth
  37 ATTRIBUTES_INTERFACE_TLS_INITIAL_EXEC uintptr_t __sancov_lowest_stack;
  38
  39 namespace fuzzer {
  40
  41 TracePC TPC;
  42
  43 uint8_t *TracePC::Counters() const {
  44   return __sancov_trace_pc_guard_8bit_counters;
  45 }
  46
  47 uintptr_t *TracePC::PCs() const {
  48   return __sancov_trace_pc_pcs;
  49 }
  50
  51 size_t TracePC::GetTotalPCCoverage() {
  52   if (ObservedPCs.size())
  53     return ObservedPCs.size();
  54   size_t Res = 0;
  55   for (size_t i = 1, N = GetNumPCs(); i < N; i++)
  56     if (PCs()[i])
  57       Res++;
  58   return Res;
  59 }
  60
  61
  62 void TracePC::HandleInline8bitCountersInit(uint8_t *Start, uint8_t *Stop) {
  63   if (Start == Stop) return;
  64   if (NumModulesWithInline8bitCounters &&
  65       ModuleCounters[NumModulesWithInline8bitCounters-1].Start == Start) return;
  66   assert(NumModulesWithInline8bitCounters <
  67          sizeof(ModuleCounters) / sizeof(ModuleCounters[0]));
  68   ModuleCounters[NumModulesWithInline8bitCounters++] = {Start, Stop};
  69   NumInline8bitCounters += Stop - Start;
  70 }
  71
  72 void TracePC::HandlePCsInit(const uintptr_t *Start, const uintptr_t *Stop) {
  73   const PCTableEntry *B = reinterpret_cast<const PCTableEntry *>(Start);
  74   const PCTableEntry *E = reinterpret_cast<const PCTableEntry *>(Stop);
  75   if (NumPCTables && ModulePCTable[NumPCTables - 1].Start == B) return;
  76   assert(NumPCTables < sizeof(ModulePCTable) / sizeof(ModulePCTable[0]));
  77   ModulePCTable[NumPCTables++] = {B, E};
  78   NumPCsInPCTables += E - B;
  79 }
  80
  81 void TracePC::HandleInit(uint32_t *Start, uint32_t *Stop) {
  82   if (Start == Stop || *Start) return;
  83   assert(NumModules < sizeof(Modules) / sizeof(Modules[0]));
  84   for (uint32_t *P = Start; P < Stop; P++) {
  85     NumGuards++;
  86     if (NumGuards == kNumPCs) {
  87       RawPrint(
  88           "WARNING: The binary has too many instrumented PCs.\n"
  89           "         You may want to reduce the size of the binary\n"
  90           "         for more efficient fuzzing and precise coverage data\n");
  91     }
  92     *P = NumGuards % kNumPCs;
  93   }
  94   Modules[NumModules].Start = Start;
  95   Modules[NumModules].Stop = Stop;
  96   NumModules++;
  97 }
  98
  99 void TracePC::PrintModuleInfo() {
 100   if (NumGuards) {
 101     Printf("INFO: Loaded %zd modules   (%zd guards): ", NumModules, NumGuards);
 102     for (size_t i = 0; i < NumModules; i++)
 103       Printf("%zd [%p, %p), ", Modules[i].Stop - Modules[i].Start,
 104              Modules[i].Start, Modules[i].Stop);
 105     Printf("\n");
 106   }
 107   if (NumModulesWithInline8bitCounters) {
 108     Printf("INFO: Loaded %zd modules   (%zd inline 8-bit counters): ",
 109            NumModulesWithInline8bitCounters, NumInline8bitCounters);
 110     for (size_t i = 0; i < NumModulesWithInline8bitCounters; i++)
 111       Printf("%zd [%p, %p), ", ModuleCounters[i].Stop - ModuleCounters[i].Start,
 112              ModuleCounters[i].Start, ModuleCounters[i].Stop);
 113     Printf("\n");
 114   }
 115   if (NumPCTables) {
 116     Printf("INFO: Loaded %zd PC tables (%zd PCs): ", NumPCTables,
 117            NumPCsInPCTables);
 118     for (size_t i = 0; i < NumPCTables; i++) {
 119       Printf("%zd [%p,%p), ", ModulePCTable[i].Stop - ModulePCTable[i].Start,
 120              ModulePCTable[i].Start, ModulePCTable[i].Stop);
 121     }
 122     Printf("\n");
 123
 124     if ((NumGuards && NumGuards != NumPCsInPCTables) ||
 125         (NumInline8bitCounters && NumInline8bitCounters != NumPCsInPCTables)) {
 126       Printf("ERROR: The size of coverage PC tables does not match the\n"
 127              "number of instrumented PCs. This might be a compiler bug,\n"
 128              "please contact the libFuzzer developers.\n"
 129              "Also check https://bugs.llvm.org/show_bug.cgi?id=34636\n"
 130              "for possible workarounds (tl;dr: don't use the old GNU ld)\n");
 131       _Exit(1);
 132     }
 133   }
 134   if (size_t NumExtraCounters = ExtraCountersEnd() - ExtraCountersBegin())
 135     Printf("INFO: %zd Extra Counters\n", NumExtraCounters);
 136 }
 137
 138 ATTRIBUTE_NO_SANITIZE_ALL
 139 void TracePC::HandleCallerCallee(uintptr_t Caller, uintptr_t Callee) {
 140   const uintptr_t kBits = 12;
 141   const uintptr_t kMask = (1 << kBits) - 1;
 142   uintptr_t Idx = (Caller & kMask) | ((Callee & kMask) << kBits);
 143   ValueProfileMap.AddValueModPrime(Idx);
 144 }
 145
 146 /// \return the address of the previous instruction.
 147 /// Note: the logic is copied from `sanitizer_common/sanitizer_stacktrace.h`
 148 inline ALWAYS_INLINE uintptr_t GetPreviousInstructionPc(uintptr_t PC) {
 149 #if defined(__arm__)
 150   // T32 (Thumb) branch instructions might be 16 or 32 bit long,
 151   // so we return (pc-2) in that case in order to be safe.
 152   // For A32 mode we return (pc-4) because all instructions are 32 bit long.
 153   return (PC - 3) & (~1);
 154 #elif defined(__powerpc__) || defined(__powerpc64__) || defined(__aarch64__)
 155   // PCs are always 4 byte aligned.
 156   return PC - 4;
 157 #elif defined(__sparc__) || defined(__mips__)
 158   return PC - 8;
 159 #else
 160   return PC - 1;
 161 #endif
 162 }
 163
 164 /// \return the address of the next instruction.
 165 /// Note: the logic is copied from `sanitizer_common/sanitizer_stacktrace.cc`
 166 inline ALWAYS_INLINE uintptr_t GetNextInstructionPc(uintptr_t PC) {
 167 #if defined(__mips__)
 168   return PC + 8;
 169 #elif defined(__powerpc__) || defined(__sparc__) || defined(__arm__) || \
 170     defined(__aarch64__)
 171   return PC + 4;
 172 #else
 173   return PC + 1;
 174 #endif
 175 }
 176
 177 void TracePC::UpdateObservedPCs() {
 178   Vector<uintptr_t> CoveredFuncs;
 179   auto ObservePC = [&](uintptr_t PC) {
 180     if (ObservedPCs.insert(PC).second && DoPrintNewPCs) {
 181       PrintPC("\tNEW_PC: %p %F %L", "\tNEW_PC: %p", GetNextInstructionPc(PC));
 182       Printf("\n");
 183     }
 184   };
 185
 186   auto Observe = [&](const PCTableEntry &TE) {
 187     if (TE.PCFlags & 1)
 188       if (++ObservedFuncs[TE.PC] == 1 && NumPrintNewFuncs)
 189         CoveredFuncs.push_back(TE.PC);
 190     ObservePC(TE.PC);
 191   };
 192
 193   if (NumPCsInPCTables) {
 194     if (NumInline8bitCounters == NumPCsInPCTables) {
 195       for (size_t i = 0; i < NumModulesWithInline8bitCounters; i++) {
 196         uint8_t *Beg = ModuleCounters[i].Start;
 197         size_t Size = ModuleCounters[i].Stop - Beg;
 198         assert(Size ==
 199                (size_t)(ModulePCTable[i].Stop - ModulePCTable[i].Start));
 200         for (size_t j = 0; j < Size; j++)
 201           if (Beg[j])
 202             Observe(ModulePCTable[i].Start[j]);
 203       }
 204     } else if (NumGuards == NumPCsInPCTables) {
 205       size_t GuardIdx = 1;
 206       for (size_t i = 0; i < NumModules; i++) {
 207         uint32_t *Beg = Modules[i].Start;
 208         size_t Size = Modules[i].Stop - Beg;
 209         assert(Size ==
 210                (size_t)(ModulePCTable[i].Stop - ModulePCTable[i].Start));
 211         for (size_t j = 0; j < Size; j++, GuardIdx++)
 212           if (Counters()[GuardIdx])
 213             Observe(ModulePCTable[i].Start[j]);
 214       }
 215     }
 216   }
 217
 218   for (size_t i = 0, N = Min(CoveredFuncs.size(), NumPrintNewFuncs); i < N;
 219        i++) {
 220     Printf("\tNEW_FUNC[%zd/%zd]: ", i + 1, CoveredFuncs.size());
 221     PrintPC("%p %F %L", "%p", GetNextInstructionPc(CoveredFuncs[i]));
 222     Printf("\n");
 223   }
 224 }
 225
 226
 227 static std::string GetModuleName(uintptr_t PC) {
 228   char ModulePathRaw[4096] = "";  // What's PATH_MAX in portable C++?
 229   void *OffsetRaw = nullptr;
 230   if (!EF->__sanitizer_get_module_and_offset_for_pc(
 231       reinterpret_cast<void *>(PC), ModulePathRaw,
 232       sizeof(ModulePathRaw), &OffsetRaw))
 233     return "";
 234   return ModulePathRaw;
 235 }
 236
 237 template<class CallBack>
 238 void TracePC::IterateCoveredFunctions(CallBack CB) {
 239   for (size_t i = 0; i < NumPCTables; i++) {
 240     auto &M = ModulePCTable[i];
 241     assert(M.Start < M.Stop);
 242     auto ModuleName = GetModuleName(M.Start->PC);
 243     for (auto NextFE = M.Start; NextFE < M.Stop; ) {
 244       auto FE = NextFE;
 245       assert((FE->PCFlags & 1) && "Not a function entry point");
 246       do {
 247         NextFE++;
 248       } while (NextFE < M.Stop && !(NextFE->PCFlags & 1));
 249       if (ObservedFuncs.count(FE->PC))
 250         CB(FE, NextFE, ObservedFuncs[FE->PC]);
 251     }
 252   }
 253 }
 254
 255 void TracePC::SetFocusFunction(const std::string &FuncName) {
 256   // This function should be called once.
 257   assert(FocusFunction.first > NumModulesWithInline8bitCounters);
 258   if (FuncName.empty())
 259     return;
 260   for (size_t M = 0; M < NumModulesWithInline8bitCounters; M++) {
 261     auto &PCTE = ModulePCTable[M];
 262     size_t N = PCTE.Stop - PCTE.Start;
 263     for (size_t I = 0; I < N; I++) {
 264       if (!(PCTE.Start[I].PCFlags & 1)) continue;  // not a function entry.
 265       auto Name = DescribePC("%F", GetNextInstructionPc(PCTE.Start[I].PC));
 266       if (Name[0] == 'i' && Name[1] == 'n' && Name[2] == ' ')
 267         Name = Name.substr(3, std::string::npos);
 268       if (FuncName != Name) continue;
 269       Printf("INFO: Focus function is set to '%s'\n", Name.c_str());
 270       FocusFunction = {M, I};
 271       return;
 272     }
 273   }
 274 }
 275
 276 bool TracePC::ObservedFocusFunction() {
 277   size_t I = FocusFunction.first;
 278   size_t J = FocusFunction.second;
 279   if (I >= NumModulesWithInline8bitCounters)
 280     return false;
 281   auto &MC = ModuleCounters[I];
 282   size_t Size = MC.Stop - MC.Start;
 283   if (J >= Size)
 284     return false;
 285   return MC.Start[J] != 0;
 286 }
 287
 288 void TracePC::PrintCoverage() {
 289   if (!EF->__sanitizer_symbolize_pc ||
 290       !EF->__sanitizer_get_module_and_offset_for_pc) {
 291     Printf("INFO: __sanitizer_symbolize_pc or "
 292            "__sanitizer_get_module_and_offset_for_pc is not available,"
 293            " not printing coverage\n");
 294     return;
 295   }
 296   Printf("COVERAGE:\n");
 297   auto CoveredFunctionCallback = [&](const PCTableEntry *First,
 298                                      const PCTableEntry *Last,
 299                                      uintptr_t Counter) {
 300     assert(First < Last);
 301     auto VisualizePC = GetNextInstructionPc(First->PC);
 302     std::string FileStr = DescribePC("%s", VisualizePC);
 303     if (!IsInterestingCoverageFile(FileStr))
 304       return;
 305     std::string FunctionStr = DescribePC("%F", VisualizePC);
 306     if (FunctionStr.find("in ") == 0)
 307       FunctionStr = FunctionStr.substr(3);
 308     std::string LineStr = DescribePC("%l", VisualizePC);
 309     size_t Line = std::stoul(LineStr);
 310     size_t NumEdges = Last - First;
 311     Vector<uintptr_t> UncoveredPCs;
 312     for (auto TE = First; TE < Last; TE++)
 313       if (!ObservedPCs.count(TE->PC))
 314         UncoveredPCs.push_back(TE->PC);
 315     Printf("COVERED_FUNC: hits: %zd", Counter);
 316     Printf(" edges: %zd/%zd", NumEdges - UncoveredPCs.size(), NumEdges);
 317     Printf(" %s %s:%zd\n", FunctionStr.c_str(), FileStr.c_str(), Line);
 318     for (auto PC: UncoveredPCs)
 319       Printf("  UNCOVERED_PC: %s\n",
 320              DescribePC("%s:%l", GetNextInstructionPc(PC)).c_str());
 321   };
 322
 323   IterateCoveredFunctions(CoveredFunctionCallback);
 324 }
 325
 326 void TracePC::DumpCoverage() {
 327   if (EF->__sanitizer_dump_coverage) {
 328     Vector<uintptr_t> PCsCopy(GetNumPCs());
 329     for (size_t i = 0; i < GetNumPCs(); i++)
 330       PCsCopy[i] = PCs()[i] ? GetPreviousInstructionPc(PCs()[i]) : 0;
 331     EF->__sanitizer_dump_coverage(PCsCopy.data(), PCsCopy.size());
 332   }
 333 }
 334
 335 // Value profile.
 336 // We keep track of various values that affect control flow.
 337 // These values are inserted into a bit-set-based hash map.
 338 // Every new bit in the map is treated as a new coverage.
 339 //
 340 // For memcmp/strcmp/etc the interesting value is the length of the common
 341 // prefix of the parameters.
 342 // For cmp instructions the interesting value is a XOR of the parameters.
 343 // The interesting value is mixed up with the PC and is then added to the map.
 344
 345 ATTRIBUTE_NO_SANITIZE_ALL
 346 void TracePC::AddValueForMemcmp(void *caller_pc, const void *s1, const void *s2,
 347                                 size_t n, bool StopAtZero) {
 348   if (!n) return;
 349   size_t Len = std::min(n, Word::GetMaxSize());
 350   const uint8_t *A1 = reinterpret_cast<const uint8_t *>(s1);
 351   const uint8_t *A2 = reinterpret_cast<const uint8_t *>(s2);
 352   uint8_t B1[Word::kMaxSize];
 353   uint8_t B2[Word::kMaxSize];
 354   // Copy the data into locals in this non-msan-instrumented function
 355   // to avoid msan complaining further.
 356   size_t Hash = 0;  // Compute some simple hash of both strings.
 357   for (size_t i = 0; i < Len; i++) {
 358     B1[i] = A1[i];
 359     B2[i] = A2[i];
 360     size_t T = B1[i];
 361     Hash ^= (T << 8) | B2[i];
 362   }
 363   size_t I = 0;
 364   for (; I < Len; I++)
 365     if (B1[I] != B2[I] || (StopAtZero && B1[I] == 0))
 366       break;
 367   size_t PC = reinterpret_cast<size_t>(caller_pc);
 368   size_t Idx = (PC & 4095) | (I << 12);
 369   ValueProfileMap.AddValue(Idx);
 370   TORCW.Insert(Idx ^ Hash, Word(B1, Len), Word(B2, Len));
 371 }
 372
 373 template <class T>
 374 ATTRIBUTE_TARGET_POPCNT ALWAYS_INLINE
 375 ATTRIBUTE_NO_SANITIZE_ALL
 376 void TracePC::HandleCmp(uintptr_t PC, T Arg1, T Arg2) {
 377   uint64_t ArgXor = Arg1 ^ Arg2;
 378   if (sizeof(T) == 4)
 379       TORC4.Insert(ArgXor, Arg1, Arg2);
 380   else if (sizeof(T) == 8)
 381       TORC8.Insert(ArgXor, Arg1, Arg2);
 382   uint64_t HammingDistance = Popcountll(ArgXor);  // [0,64]
 383   uint64_t AbsoluteDistance = (Arg1 == Arg2 ? 0 : Clzll(Arg1 - Arg2) + 1);
 384   ValueProfileMap.AddValue(PC * 128 + HammingDistance);
 385   ValueProfileMap.AddValue(PC * 128 + 64 + AbsoluteDistance);
 386 }
 387
 388 static size_t InternalStrnlen(const char *S, size_t MaxLen) {
 389   size_t Len = 0;
 390   for (; Len < MaxLen && S[Len]; Len++) {}
 391   return Len;
 392 }
 393
 394 // Finds min of (strlen(S1), strlen(S2)).
 395 // Needed bacause one of these strings may actually be non-zero terminated.
 396 static size_t InternalStrnlen2(const char *S1, const char *S2) {
 397   size_t Len = 0;
 398   for (; S1[Len] && S2[Len]; Len++)  {}
 399   return Len;
 400 }
 401
 402 void TracePC::ClearInlineCounters() {
 403   for (size_t i = 0; i < NumModulesWithInline8bitCounters; i++) {
 404     uint8_t *Beg = ModuleCounters[i].Start;
 405     size_t Size = ModuleCounters[i].Stop - Beg;
 406     memset(Beg, 0, Size);
 407   }
 408 }
 409
 410 ATTRIBUTE_NO_SANITIZE_ALL
 411 void TracePC::RecordInitialStack() {
 412   int stack;
 413   __sancov_lowest_stack = InitialStack = reinterpret_cast<uintptr_t>(&stack);
 414 }
 415
 416 uintptr_t TracePC::GetMaxStackOffset() const {
 417   return InitialStack - __sancov_lowest_stack;  // Stack grows down
 418 }
 419
 420 } // namespace fuzzer
 421
 422 extern "C" {
 423 ATTRIBUTE_INTERFACE
 424 ATTRIBUTE_NO_SANITIZE_ALL
 425 void __sanitizer_cov_trace_pc_guard(uint32_t *Guard) {
 426   uintptr_t PC = reinterpret_cast<uintptr_t>(GET_CALLER_PC());
 427   uint32_t Idx = *Guard;
 428   __sancov_trace_pc_pcs[Idx] = PC;
 429   __sancov_trace_pc_guard_8bit_counters[Idx]++;
 430 }
 431
 432 // Best-effort support for -fsanitize-coverage=trace-pc, which is available
 433 // in both Clang and GCC.
 434 ATTRIBUTE_INTERFACE
 435 ATTRIBUTE_NO_SANITIZE_ALL
 436 void __sanitizer_cov_trace_pc() {
 437   uintptr_t PC = reinterpret_cast<uintptr_t>(GET_CALLER_PC());
 438   uintptr_t Idx = PC & (((uintptr_t)1 << fuzzer::TracePC::kTracePcBits) - 1);
 439   __sancov_trace_pc_pcs[Idx] = PC;
 440   __sancov_trace_pc_guard_8bit_counters[Idx]++;
 441 }
 442
 443 ATTRIBUTE_INTERFACE
 444 void __sanitizer_cov_trace_pc_guard_init(uint32_t *Start, uint32_t *Stop) {
 445   fuzzer::TPC.HandleInit(Start, Stop);
 446 }
 447
 448 ATTRIBUTE_INTERFACE
 449 void __sanitizer_cov_8bit_counters_init(uint8_t *Start, uint8_t *Stop) {
 450   fuzzer::TPC.HandleInline8bitCountersInit(Start, Stop);
 451 }
 452
 453 ATTRIBUTE_INTERFACE
 454 void __sanitizer_cov_pcs_init(const uintptr_t *pcs_beg,
 455                               const uintptr_t *pcs_end) {
 456   fuzzer::TPC.HandlePCsInit(pcs_beg, pcs_end);
 457 }
 458
 459 ATTRIBUTE_INTERFACE
 460 ATTRIBUTE_NO_SANITIZE_ALL
 461 void __sanitizer_cov_trace_pc_indir(uintptr_t Callee) {
 462   uintptr_t PC = reinterpret_cast<uintptr_t>(GET_CALLER_PC());
 463   fuzzer::TPC.HandleCallerCallee(PC, Callee);
 464 }
 465
 466 ATTRIBUTE_INTERFACE
 467 ATTRIBUTE_NO_SANITIZE_ALL
 468 ATTRIBUTE_TARGET_POPCNT
 469 void __sanitizer_cov_trace_cmp8(uint64_t Arg1, uint64_t Arg2) {
 470   uintptr_t PC = reinterpret_cast<uintptr_t>(GET_CALLER_PC());
 471   fuzzer::TPC.HandleCmp(PC, Arg1, Arg2);
 472 }
 473
 474 ATTRIBUTE_INTERFACE
 475 ATTRIBUTE_NO_SANITIZE_ALL
 476 ATTRIBUTE_TARGET_POPCNT
 477 // Now the __sanitizer_cov_trace_const_cmp[1248] callbacks just mimic
 478 // the behaviour of __sanitizer_cov_trace_cmp[1248] ones. This, however,
 479 // should be changed later to make full use of instrumentation.
 480 void __sanitizer_cov_trace_const_cmp8(uint64_t Arg1, uint64_t Arg2) {
 481   uintptr_t PC = reinterpret_cast<uintptr_t>(GET_CALLER_PC());
 482   fuzzer::TPC.HandleCmp(PC, Arg1, Arg2);
 483 }
 484
 485 ATTRIBUTE_INTERFACE
 486 ATTRIBUTE_NO_SANITIZE_ALL
 487 ATTRIBUTE_TARGET_POPCNT
 488 void __sanitizer_cov_trace_cmp4(uint32_t Arg1, uint32_t Arg2) {
 489   uintptr_t PC = reinterpret_cast<uintptr_t>(GET_CALLER_PC());
 490   fuzzer::TPC.HandleCmp(PC, Arg1, Arg2);
 491 }
 492
 493 ATTRIBUTE_INTERFACE
 494 ATTRIBUTE_NO_SANITIZE_ALL
 495 ATTRIBUTE_TARGET_POPCNT
 496 void __sanitizer_cov_trace_const_cmp4(uint32_t Arg1, uint32_t Arg2) {
 497   uintptr_t PC = reinterpret_cast<uintptr_t>(GET_CALLER_PC());
 498   fuzzer::TPC.HandleCmp(PC, Arg1, Arg2);
 499 }
 500
 501 ATTRIBUTE_INTERFACE
 502 ATTRIBUTE_NO_SANITIZE_ALL
 503 ATTRIBUTE_TARGET_POPCNT
 504 void __sanitizer_cov_trace_cmp2(uint16_t Arg1, uint16_t Arg2) {
 505   uintptr_t PC = reinterpret_cast<uintptr_t>(GET_CALLER_PC());
 506   fuzzer::TPC.HandleCmp(PC, Arg1, Arg2);
 507 }
 508
 509 ATTRIBUTE_INTERFACE
 510 ATTRIBUTE_NO_SANITIZE_ALL
 511 ATTRIBUTE_TARGET_POPCNT
 512 void __sanitizer_cov_trace_const_cmp2(uint16_t Arg1, uint16_t Arg2) {
 513   uintptr_t PC = reinterpret_cast<uintptr_t>(GET_CALLER_PC());
 514   fuzzer::TPC.HandleCmp(PC, Arg1, Arg2);
 515 }
 516
 517 ATTRIBUTE_INTERFACE
 518 ATTRIBUTE_NO_SANITIZE_ALL
 519 ATTRIBUTE_TARGET_POPCNT
 520 void __sanitizer_cov_trace_cmp1(uint8_t Arg1, uint8_t Arg2) {
 521   uintptr_t PC = reinterpret_cast<uintptr_t>(GET_CALLER_PC());
 522   fuzzer::TPC.HandleCmp(PC, Arg1, Arg2);
 523 }
 524
 525 ATTRIBUTE_INTERFACE
 526 ATTRIBUTE_NO_SANITIZE_ALL
 527 ATTRIBUTE_TARGET_POPCNT
 528 void __sanitizer_cov_trace_const_cmp1(uint8_t Arg1, uint8_t Arg2) {
 529   uintptr_t PC = reinterpret_cast<uintptr_t>(GET_CALLER_PC());
 530   fuzzer::TPC.HandleCmp(PC, Arg1, Arg2);
 531 }
 532
 533 ATTRIBUTE_INTERFACE
 534 ATTRIBUTE_NO_SANITIZE_ALL
 535 ATTRIBUTE_TARGET_POPCNT
 536 void __sanitizer_cov_trace_switch(uint64_t Val, uint64_t *Cases) {
 537   uint64_t N = Cases[0];
 538   uint64_t ValSizeInBits = Cases[1];
 539   uint64_t *Vals = Cases + 2;
 540   // Skip the most common and the most boring case.
 541   if (Vals[N - 1]  < 256 && Val < 256)
 542     return;
 543   uintptr_t PC = reinterpret_cast<uintptr_t>(GET_CALLER_PC());
 544   size_t i;
 545   uint64_t Token = 0;
 546   for (i = 0; i < N; i++) {
 547     Token = Val ^ Vals[i];
 548     if (Val < Vals[i])
 549       break;
 550   }
 551
 552   if (ValSizeInBits == 16)
 553     fuzzer::TPC.HandleCmp(PC + i, static_cast<uint16_t>(Token), (uint16_t)(0));
 554   else if (ValSizeInBits == 32)
 555     fuzzer::TPC.HandleCmp(PC + i, static_cast<uint32_t>(Token), (uint32_t)(0));
 556   else
 557     fuzzer::TPC.HandleCmp(PC + i, Token, (uint64_t)(0));
 558 }
 559
 560 ATTRIBUTE_INTERFACE
 561 ATTRIBUTE_NO_SANITIZE_ALL
 562 ATTRIBUTE_TARGET_POPCNT
 563 void __sanitizer_cov_trace_div4(uint32_t Val) {
 564   uintptr_t PC = reinterpret_cast<uintptr_t>(GET_CALLER_PC());
 565   fuzzer::TPC.HandleCmp(PC, Val, (uint32_t)0);
 566 }
 567
 568 ATTRIBUTE_INTERFACE
 569 ATTRIBUTE_NO_SANITIZE_ALL
 570 ATTRIBUTE_TARGET_POPCNT
 571 void __sanitizer_cov_trace_div8(uint64_t Val) {
 572   uintptr_t PC = reinterpret_cast<uintptr_t>(GET_CALLER_PC());
 573   fuzzer::TPC.HandleCmp(PC, Val, (uint64_t)0);
 574 }
 575
 576 ATTRIBUTE_INTERFACE
 577 ATTRIBUTE_NO_SANITIZE_ALL
 578 ATTRIBUTE_TARGET_POPCNT
 579 void __sanitizer_cov_trace_gep(uintptr_t Idx) {
 580   uintptr_t PC = reinterpret_cast<uintptr_t>(GET_CALLER_PC());
 581   fuzzer::TPC.HandleCmp(PC, Idx, (uintptr_t)0);
 582 }
 583
 584 ATTRIBUTE_INTERFACE ATTRIBUTE_NO_SANITIZE_MEMORY
 585 void __sanitizer_weak_hook_memcmp(void *caller_pc, const void *s1,
 586                                   const void *s2, size_t n, int result) {
 587   if (!fuzzer::RunningUserCallback) return;
 588   if (result == 0) return;  // No reason to mutate.
 589   if (n <= 1) return;  // Not interesting.
 590   fuzzer::TPC.AddValueForMemcmp(caller_pc, s1, s2, n, /*StopAtZero*/false);
 591 }
 592
 593 ATTRIBUTE_INTERFACE ATTRIBUTE_NO_SANITIZE_MEMORY
 594 void __sanitizer_weak_hook_strncmp(void *caller_pc, const char *s1,
 595                                    const char *s2, size_t n, int result) {
 596   if (!fuzzer::RunningUserCallback) return;
 597   if (result == 0) return;  // No reason to mutate.
 598   size_t Len1 = fuzzer::InternalStrnlen(s1, n);
 599   size_t Len2 = fuzzer::InternalStrnlen(s2, n);
 600   n = std::min(n, Len1);
 601   n = std::min(n, Len2);
 602   if (n <= 1) return;  // Not interesting.
 603   fuzzer::TPC.AddValueForMemcmp(caller_pc, s1, s2, n, /*StopAtZero*/true);
 604 }
 605
 606 ATTRIBUTE_INTERFACE ATTRIBUTE_NO_SANITIZE_MEMORY
 607 void __sanitizer_weak_hook_strcmp(void *caller_pc, const char *s1,
 608                                    const char *s2, int result) {
 609   if (!fuzzer::RunningUserCallback) return;
 610   if (result == 0) return;  // No reason to mutate.
 611   size_t N = fuzzer::InternalStrnlen2(s1, s2);
 612   if (N <= 1) return;  // Not interesting.
 613   fuzzer::TPC.AddValueForMemcmp(caller_pc, s1, s2, N, /*StopAtZero*/true);
 614 }
 615
 616 ATTRIBUTE_INTERFACE ATTRIBUTE_NO_SANITIZE_MEMORY
 617 void __sanitizer_weak_hook_strncasecmp(void *called_pc, const char *s1,
 618                                        const char *s2, size_t n, int result) {
 619   if (!fuzzer::RunningUserCallback) return;
 620   return __sanitizer_weak_hook_strncmp(called_pc, s1, s2, n, result);
 621 }
 622
 623 ATTRIBUTE_INTERFACE ATTRIBUTE_NO_SANITIZE_MEMORY
 624 void __sanitizer_weak_hook_strcasecmp(void *called_pc, const char *s1,
 625                                       const char *s2, int result) {
 626   if (!fuzzer::RunningUserCallback) return;
 627   return __sanitizer_weak_hook_strcmp(called_pc, s1, s2, result);
 628 }
 629
 630 ATTRIBUTE_INTERFACE ATTRIBUTE_NO_SANITIZE_MEMORY
 631 void __sanitizer_weak_hook_strstr(void *called_pc, const char *s1,
 632                                   const char *s2, char *result) {
 633   if (!fuzzer::RunningUserCallback) return;
 634   fuzzer::TPC.MMT.Add(reinterpret_cast<const uint8_t *>(s2), strlen(s2));
 635 }
 636
 637 ATTRIBUTE_INTERFACE ATTRIBUTE_NO_SANITIZE_MEMORY
 638 void __sanitizer_weak_hook_strcasestr(void *called_pc, const char *s1,
 639                                       const char *s2, char *result) {
 640   if (!fuzzer::RunningUserCallback) return;
 641   fuzzer::TPC.MMT.Add(reinterpret_cast<const uint8_t *>(s2), strlen(s2));
 642 }
 643
 644 ATTRIBUTE_INTERFACE ATTRIBUTE_NO_SANITIZE_MEMORY
 645 void __sanitizer_weak_hook_memmem(void *called_pc, const void *s1, size_t len1,
 646                                   const void *s2, size_t len2, void *result) {
 647   if (!fuzzer::RunningUserCallback) return;
 648   fuzzer::TPC.MMT.Add(reinterpret_cast<const uint8_t *>(s2), len2);
 649 }
 650 }  // extern "C"