llvm-project

1
//===- sanstats.cpp - Sanitizer statistics dumper -------------------------===//
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
//
9
// This tool dumps statistics information from files in the format produced
10
// by clang's -fsanitize-stats feature.
11
//
12
//===----------------------------------------------------------------------===//
13

14
#include "llvm/DebugInfo/Symbolize/SymbolizableModule.h"
15
#include "llvm/DebugInfo/Symbolize/Symbolize.h"
16
#include "llvm/Support/CommandLine.h"
17
#include "llvm/Support/ErrorOr.h"
18
#include "llvm/Support/FileSystem.h"
19
#include "llvm/Support/MemoryBuffer.h"
20
#include "llvm/Support/Path.h"
21
#include "llvm/Transforms/Utils/SanitizerStats.h"
22
#include <stdint.h>
23

24
using namespace llvm;
25

26
static cl::OptionCategory Cat("sanstats Options");
27

28
static cl::opt<std::string> ClInputFile(cl::Positional, cl::Required,
29
                                        cl::desc("<filename>"));
30

31
static cl::opt<bool> ClDemangle("demangle", cl::init(false),
32
                                cl::desc("Print demangled function name"),
33
                                cl::cat(Cat));
34

35
inline uint64_t KindFromData(uint64_t Data, char SizeofPtr) {
36
  return Data >> (SizeofPtr * 8 - kSanitizerStatKindBits);
37
}
38

39
inline uint64_t CountFromData(uint64_t Data, char SizeofPtr) {
40
  return Data & ((1ull << (SizeofPtr * 8 - kSanitizerStatKindBits)) - 1);
41
}
42

43
static uint64_t ReadLE(char Size, const char *Begin, const char *End) {
44
  uint64_t Result = 0;
45
  char Pos = 0;
46
  while (Begin < End && Pos != Size) {
47
    Result |= uint64_t(uint8_t(*Begin)) << (Pos * 8);
48
    ++Begin;
49
    ++Pos;
50
  }
51
  return Result;
52
}
53

54
static const char *ReadModule(char SizeofPtr, const char *Begin,
55
                              const char *End) {
56
  const char *FilenameBegin = Begin;
57
  while (Begin != End && *Begin)
58
    ++Begin;
59
  if (Begin == End)
60
    return nullptr;
61
  std::string Filename(FilenameBegin, Begin - FilenameBegin);
62

63
  if (!llvm::sys::fs::exists(Filename))
64
    Filename = std::string(llvm::sys::path::parent_path(ClInputFile)) +
65
               std::string(llvm::sys::path::filename(Filename));
66

67
  ++Begin;
68
  if (Begin == End)
69
    return nullptr;
70

71
  symbolize::LLVMSymbolizer::Options SymbolizerOptions;
72
  SymbolizerOptions.Demangle = ClDemangle;
73
  SymbolizerOptions.UseSymbolTable = true;
74
  symbolize::LLVMSymbolizer Symbolizer(SymbolizerOptions);
75

76
  while (true) {
77
    uint64_t Addr = ReadLE(SizeofPtr, Begin, End);
78
    Begin += SizeofPtr;
79
    uint64_t Data = ReadLE(SizeofPtr, Begin, End);
80
    Begin += SizeofPtr;
81

82
    if (Begin > End)
83
      return nullptr;
84
    if (Addr == 0 && Data == 0)
85
      return Begin;
86
    if (Begin == End)
87
      return nullptr;
88

89
    // As the instrumentation tracks the return address and not
90
    // the address of the call to `__sanitizer_stat_report` we
91
    // remove one from the address to get the correct DI.
92
    // TODO: it would be neccessary to set proper section index here.
93
    // object::SectionedAddress::UndefSection works for only absolute addresses.
94
    if (Expected<DILineInfo> LineInfo = Symbolizer.symbolizeCode(
95
            Filename, {Addr - 1, object::SectionedAddress::UndefSection})) {
96
      llvm::outs() << format_hex(Addr - 1, 18) << ' ' << LineInfo->FileName
97
                   << ':' << LineInfo->Line << ' ' << LineInfo->FunctionName
98
                   << ' ';
99
    } else {
100
      logAllUnhandledErrors(LineInfo.takeError(), llvm::outs(), "<error> ");
101
    }
102

103
    switch (KindFromData(Data, SizeofPtr)) {
104
    case SanStat_CFI_VCall:
105
      llvm::outs() << "cfi-vcall";
106
      break;
107
    case SanStat_CFI_NVCall:
108
      llvm::outs() << "cfi-nvcall";
109
      break;
110
    case SanStat_CFI_DerivedCast:
111
      llvm::outs() << "cfi-derived-cast";
112
      break;
113
    case SanStat_CFI_UnrelatedCast:
114
      llvm::outs() << "cfi-unrelated-cast";
115
      break;
116
    case SanStat_CFI_ICall:
117
      llvm::outs() << "cfi-icall";
118
      break;
119
    default:
120
      llvm::outs() << "<unknown>";
121
      break;
122
    }
123

124
    llvm::outs() << " " << CountFromData(Data, SizeofPtr) << '\n';
125
  }
126
}
127

128
int main(int argc, char **argv) {
129
  cl::HideUnrelatedOptions(Cat);
130
  cl::ParseCommandLineOptions(argc, argv,
131
                              "Sanitizer Statistics Processing Tool");
132

133
  ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr = MemoryBuffer::getFile(
134
      ClInputFile, /*IsText=*/false, /*RequiresNullTerminator=*/false);
135
  if (!MBOrErr) {
136
    errs() << argv[0] << ": " << ClInputFile << ": "
137
           << MBOrErr.getError().message() << '\n';
138
    return 1;
139
  }
140
  std::unique_ptr<MemoryBuffer> MB = std::move(MBOrErr.get());
141
  const char *Begin = MB->getBufferStart(), *End = MB->getBufferEnd();
142
  if (Begin == End) {
143
    errs() << argv[0] << ": " << ClInputFile << ": short read\n";
144
    return 1;
145
  }
146
  char SizeofPtr = *Begin++;
147
  while (Begin != End) {
148
    Begin = ReadModule(SizeofPtr, Begin, End);
149
    if (Begin == nullptr) {
150
      errs() << argv[0] << ": " << ClInputFile << ": short read\n";
151
      return 1;
152
    }
153
    assert(Begin <= End);
154
  }
155
}
156