compiler-rt/lib/fuzzer/dataflow/DataFlowCallbacks.cpp

   1 /*===- DataFlowCallbacks.cpp - a standalone DataFlow trace          -------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 // Instrumentation callbacks for DataFlow.cpp.
   9 // These functions should not be instrumented by DFSan, so we
  10 // keep them in a separate file and compile it w/o DFSan.
  11 //===----------------------------------------------------------------------===*/
  12 #include "DataFlow.h"
  13
  14 #include <cassert>
  15 #include <cstdio>
  16 #include <cstdlib>
  17
  18 static __thread size_t CurrentFunc;
  19 static uint32_t *GuardsBeg, *GuardsEnd;
  20 static inline bool BlockIsEntry(size_t BlockIdx) {
  21   return __dft.PCsBeg[BlockIdx * 2 + 1] & PCFLAG_FUNC_ENTRY;
  22 }
  23
  24 extern "C" {
  25
  26 void __sanitizer_cov_trace_pc_guard_init(uint32_t *start,
  27                                          uint32_t *stop) {
  28   assert(__dft.NumFuncs == 0 && "This tool does not support DSOs");
  29   assert(start < stop && "The code is not instrumented for coverage");
  30   if (start == stop || *start) return;  // Initialize only once.
  31   GuardsBeg = start;
  32   GuardsEnd = stop;
  33 }
  34
  35 void __sanitizer_cov_pcs_init(const uintptr_t *pcs_beg,
  36                               const uintptr_t *pcs_end) {
  37   if (__dft.NumGuards) return;  // Initialize only once.
  38   __dft.NumGuards = GuardsEnd - GuardsBeg;
  39   __dft.PCsBeg = pcs_beg;
  40   __dft.PCsEnd = pcs_end;
  41   assert(__dft.NumGuards == (__dft.PCsEnd - __dft.PCsBeg) / 2);
  42   for (size_t i = 0; i < __dft.NumGuards; i++) {
  43     if (BlockIsEntry(i)) {
  44       __dft.NumFuncs++;
  45       GuardsBeg[i] = __dft.NumFuncs;
  46     }
  47   }
  48   __dft.BBExecuted = (bool*)calloc(__dft.NumGuards, sizeof(bool));
  49   fprintf(stderr, "INFO: %zd instrumented function(s) observed "
  50           "and %zd basic blocks\n", __dft.NumFuncs, __dft.NumGuards);
  51 }
  52
  53 void __sanitizer_cov_trace_pc_indir(uint64_t x){}  // unused.
  54
  55 void __sanitizer_cov_trace_pc_guard(uint32_t *guard) {
  56   size_t GuardIdx = guard - GuardsBeg;
  57   // assert(GuardIdx < __dft.NumGuards);
  58   __dft.BBExecuted[GuardIdx] = true;
  59   if (!*guard) return;  // not a function entry.
  60   uint32_t FuncNum = *guard - 1;  // Guards start from 1.
  61   // assert(FuncNum < __dft.NumFuncs);
  62   CurrentFunc = FuncNum;
  63 }
  64
  65 void __dfsw___sanitizer_cov_trace_switch(uint64_t Val, uint64_t *Cases,
  66                                          dfsan_label L1, dfsan_label UnusedL) {
  67   assert(CurrentFunc < __dft.NumFuncs);
  68   __dft.FuncLabels[CurrentFunc] |= L1;
  69 }
  70
  71 #define HOOK(Name, Type)                                                       \
  72   void Name(Type Arg1, Type Arg2, dfsan_label L1, dfsan_label L2) {            \
  73     __dft.FuncLabels[CurrentFunc] |= L1 | L2;                                  \
  74   }
  75     //assert(CurrentFunc < __dft.NumFuncs);
  76
  77 HOOK(__dfsw___sanitizer_cov_trace_const_cmp1, uint8_t)
  78 HOOK(__dfsw___sanitizer_cov_trace_const_cmp2, uint16_t)
  79 HOOK(__dfsw___sanitizer_cov_trace_const_cmp4, uint32_t)
  80 HOOK(__dfsw___sanitizer_cov_trace_const_cmp8, uint64_t)
  81 HOOK(__dfsw___sanitizer_cov_trace_cmp1, uint8_t)
  82 HOOK(__dfsw___sanitizer_cov_trace_cmp2, uint16_t)
  83 HOOK(__dfsw___sanitizer_cov_trace_cmp4, uint32_t)
  84 HOOK(__dfsw___sanitizer_cov_trace_cmp8, uint64_t)
  85
  86 } // extern "C"