aboutsummaryrefslogtreecommitdiffstats
path: root/lib/gwp_asan/optional/backtrace_sanitizer_common.cpp
blob: 7d17eec0da2f377d435c808429b9a8d74fca6e31 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
//===-- backtrace_sanitizer_common.cpp --------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include <assert.h>
#include <stddef.h>
#include <stdint.h>
#include <string.h>

#include "gwp_asan/optional/backtrace.h"
#include "gwp_asan/options.h"
#include "sanitizer_common/sanitizer_stacktrace.h"

void __sanitizer::BufferedStackTrace::UnwindImpl(uptr pc, uptr bp,
                                                 void *context,
                                                 bool request_fast,
                                                 u32 max_depth) {
  if (!StackTrace::WillUseFastUnwind(request_fast)) {
    return Unwind(max_depth, pc, bp, context, 0, 0, request_fast);
  }
  Unwind(max_depth, pc, 0, context, 0, 0, false);
}

namespace {
void Backtrace(uintptr_t *TraceBuffer, size_t Size) {
  __sanitizer::BufferedStackTrace Trace;
  Trace.Reset();
  if (Size > __sanitizer::kStackTraceMax)
    Size = __sanitizer::kStackTraceMax;

  Trace.Unwind((__sanitizer::uptr)__builtin_return_address(0),
               (__sanitizer::uptr)__builtin_frame_address(0),
               /* ucontext */ nullptr,
               /* fast unwind */ true, Size - 1);

  memcpy(TraceBuffer, Trace.trace, Trace.size * sizeof(uintptr_t));
  TraceBuffer[Trace.size] = 0;
}

static void PrintBacktrace(uintptr_t *Trace,
                           gwp_asan::options::Printf_t Printf) {
  __sanitizer::StackTrace StackTrace;
  StackTrace.trace = reinterpret_cast<__sanitizer::uptr *>(Trace);

  for (StackTrace.size = 0; StackTrace.size < __sanitizer::kStackTraceMax;
       ++StackTrace.size) {
    if (Trace[StackTrace.size] == 0)
      break;
  }

  if (StackTrace.size == 0) {
    Printf("  <unknown (does your allocator support backtracing?)>\n\n");
    return;
  }

  StackTrace.Print();
}
} // anonymous namespace

namespace gwp_asan {
namespace options {
Backtrace_t getBacktraceFunction() { return Backtrace; }
PrintBacktrace_t getPrintBacktraceFunction() { return PrintBacktrace; }
} // namespace options
} // namespace gwp_asan