You've already forked linux-packaging-mono
acceptance-tests
data
debian
docs
external
Newtonsoft.Json
api-doc-tools
api-snapshot
aspnetwebstack
bdwgc
binary-reference-assemblies
bockbuild
boringssl
cecil
cecil-legacy
corefx
corert
helix-binaries
ikdasm
ikvm
illinker-test-assets
linker
llvm-project
clang
clang-tools-extra
compiler-rt
cmake
docs
include
lib
BlocksRuntime
asan
builtins
cfi
dfsan
esan
fuzzer
hwasan
interception
lsan
msan
profile
safestack
sanitizer_common
scripts
symbolizer
tests
.clang-format
.clang-tidy
CMakeLists.txt
sancov_begin.S
sancov_end.S
sancov_flags.cc
sancov_flags.h
sancov_flags.inc
sanitizer_addrhashmap.h
sanitizer_allocator.cc
sanitizer_allocator.h
sanitizer_allocator_bytemap.h
sanitizer_allocator_checks.cc
sanitizer_allocator_checks.h
sanitizer_allocator_combined.h
sanitizer_allocator_interface.h
sanitizer_allocator_internal.h
sanitizer_allocator_local_cache.h
sanitizer_allocator_primary32.h
sanitizer_allocator_primary64.h
sanitizer_allocator_secondary.h
sanitizer_allocator_size_class_map.h
sanitizer_allocator_stats.h
sanitizer_asm.h
sanitizer_atomic.h
sanitizer_atomic_clang.h
sanitizer_atomic_clang_mips.h
sanitizer_atomic_clang_other.h
sanitizer_atomic_clang_x86.h
sanitizer_atomic_msvc.h
sanitizer_bitvector.h
sanitizer_bvgraph.h
sanitizer_common.cc
sanitizer_common.h
sanitizer_common_interceptors.inc.REMOVED.git-id
sanitizer_common_interceptors_format.inc
sanitizer_common_interceptors_ioctl.inc
sanitizer_common_interface.inc
sanitizer_common_interface_posix.inc
sanitizer_common_libcdep.cc
sanitizer_common_nolibc.cc
sanitizer_common_syscalls.inc
sanitizer_coverage_fuchsia.cc
sanitizer_coverage_interface.inc
sanitizer_coverage_libcdep_new.cc
sanitizer_coverage_win_dll_thunk.cc
sanitizer_coverage_win_dynamic_runtime_thunk.cc
sanitizer_coverage_win_sections.cc
sanitizer_coverage_win_weak_interception.cc
sanitizer_dbghelp.h
sanitizer_deadlock_detector.h
sanitizer_deadlock_detector1.cc
sanitizer_deadlock_detector2.cc
sanitizer_deadlock_detector_interface.h
sanitizer_errno.cc
sanitizer_errno.h
sanitizer_errno_codes.h
sanitizer_file.cc
sanitizer_file.h
sanitizer_flag_parser.cc
sanitizer_flag_parser.h
sanitizer_flags.cc
sanitizer_flags.h
sanitizer_flags.inc
sanitizer_freebsd.h
sanitizer_fuchsia.cc
sanitizer_fuchsia.h
sanitizer_getauxval.h
sanitizer_interface_internal.h
sanitizer_internal_defs.h
sanitizer_lfstack.h
sanitizer_libc.cc
sanitizer_libc.h
sanitizer_libignore.cc
sanitizer_libignore.h
sanitizer_linux.cc
sanitizer_linux.h
sanitizer_linux_libcdep.cc
sanitizer_linux_mips64.S
sanitizer_linux_s390.cc
sanitizer_linux_x86_64.S
sanitizer_list.h
sanitizer_mac.cc
sanitizer_mac.h
sanitizer_mac_libcdep.cc
sanitizer_malloc_mac.inc
sanitizer_mutex.h
sanitizer_persistent_allocator.cc
sanitizer_persistent_allocator.h
sanitizer_placement_new.h
sanitizer_platform.h
sanitizer_platform_interceptors.h
sanitizer_platform_limits_linux.cc
sanitizer_platform_limits_netbsd.cc
sanitizer_platform_limits_netbsd.h
sanitizer_platform_limits_posix.cc
sanitizer_platform_limits_posix.h
sanitizer_platform_limits_solaris.cc
sanitizer_platform_limits_solaris.h
sanitizer_posix.cc
sanitizer_posix.h
sanitizer_posix_libcdep.cc
sanitizer_printf.cc
sanitizer_procmaps.h
sanitizer_procmaps_common.cc
sanitizer_procmaps_freebsd.cc
sanitizer_procmaps_linux.cc
sanitizer_procmaps_mac.cc
sanitizer_procmaps_solaris.cc
sanitizer_quarantine.h
sanitizer_report_decorator.h
sanitizer_signal_interceptors.inc
sanitizer_solaris.cc
sanitizer_stackdepot.cc
sanitizer_stackdepot.h
sanitizer_stackdepotbase.h
sanitizer_stacktrace.cc
sanitizer_stacktrace.h
sanitizer_stacktrace_libcdep.cc
sanitizer_stacktrace_printer.cc
sanitizer_stacktrace_printer.h
sanitizer_stoptheworld.h
sanitizer_stoptheworld_linux_libcdep.cc
sanitizer_stoptheworld_mac.cc
sanitizer_suppressions.cc
sanitizer_suppressions.h
sanitizer_symbolizer.cc
sanitizer_symbolizer.h
sanitizer_symbolizer_fuchsia.cc
sanitizer_symbolizer_internal.h
sanitizer_symbolizer_libbacktrace.cc
sanitizer_symbolizer_libbacktrace.h
sanitizer_symbolizer_libcdep.cc
sanitizer_symbolizer_mac.cc
sanitizer_symbolizer_mac.h
sanitizer_symbolizer_posix_libcdep.cc
sanitizer_symbolizer_win.cc
sanitizer_syscall_generic.inc
sanitizer_syscall_linux_aarch64.inc
sanitizer_syscall_linux_arm.inc
sanitizer_syscall_linux_x86_64.inc
sanitizer_termination.cc
sanitizer_thread_registry.cc
sanitizer_thread_registry.h
sanitizer_tls_get_addr.cc
sanitizer_tls_get_addr.h
sanitizer_unwind_linux_libcdep.cc
sanitizer_vector.h
sanitizer_win.cc
sanitizer_win.h
sanitizer_win_defs.h
sanitizer_win_dll_thunk.cc
sanitizer_win_dll_thunk.h
sanitizer_win_dynamic_runtime_thunk.cc
sanitizer_win_weak_interception.cc
sanitizer_win_weak_interception.h
weak_symbols.txt
scudo
stats
tsan
ubsan
ubsan_minimal
xray
CMakeLists.txt
test
unittests
www
.arcconfig
.gitignore
CMakeLists.txt
CODE_OWNERS.TXT
CREDITS.TXT
LICENSE.TXT
README.txt
eng
libcxx
libcxxabi
libunwind
lld
lldb
llvm
nuget
openmp
polly
Directory.Build.props
Directory.Build.targets
NuGet.config
azure-pipelines.yml
build.cmd
build.sh
dir.common.props
global.json
llvm.proj
mxe-Win64.cmake.in
nuget-buildtasks
nunit-lite
roslyn-binaries
rx
xunit-binaries
how-to-bump-roslyn-binaries.md
ikvm-native
llvm
m4
man
mcs
mono
msvc
netcore
po
runtime
samples
scripts
support
tools
COPYING.LIB
LICENSE
Makefile.am
Makefile.in
NEWS
README.md
acinclude.m4
aclocal.m4
autogen.sh
code_of_conduct.md
compile
config.guess
config.h.in
config.rpath
config.sub
configure.REMOVED.git-id
configure.ac.REMOVED.git-id
depcomp
install-sh
ltmain.sh.REMOVED.git-id
missing
mkinstalldirs
mono-uninstalled.pc.in
test-driver
winconfig.h
144 lines
4.9 KiB
C++
144 lines
4.9 KiB
C++
![]() |
//===-- sanitizer_stacktrace_libcdep.cc -----------------------------------===//
|
||
|
//
|
||
|
// The LLVM Compiler Infrastructure
|
||
|
//
|
||
|
// This file is distributed under the University of Illinois Open Source
|
||
|
// License. See LICENSE.TXT for details.
|
||
|
//
|
||
|
//===----------------------------------------------------------------------===//
|
||
|
//
|
||
|
// This file is shared between AddressSanitizer and ThreadSanitizer
|
||
|
// run-time libraries.
|
||
|
//===----------------------------------------------------------------------===//
|
||
|
|
||
|
#include "sanitizer_common.h"
|
||
|
#include "sanitizer_placement_new.h"
|
||
|
#include "sanitizer_stacktrace.h"
|
||
|
#include "sanitizer_stacktrace_printer.h"
|
||
|
#include "sanitizer_symbolizer.h"
|
||
|
|
||
|
namespace __sanitizer {
|
||
|
|
||
|
void StackTrace::Print() const {
|
||
|
if (trace == nullptr || size == 0) {
|
||
|
Printf(" <empty stack>\n\n");
|
||
|
return;
|
||
|
}
|
||
|
InternalScopedString frame_desc(GetPageSizeCached() * 2);
|
||
|
InternalScopedString dedup_token(GetPageSizeCached());
|
||
|
int dedup_frames = common_flags()->dedup_token_length;
|
||
|
uptr frame_num = 0;
|
||
|
for (uptr i = 0; i < size && trace[i]; i++) {
|
||
|
// PCs in stack traces are actually the return addresses, that is,
|
||
|
// addresses of the next instructions after the call.
|
||
|
uptr pc = GetPreviousInstructionPc(trace[i]);
|
||
|
SymbolizedStack *frames = Symbolizer::GetOrInit()->SymbolizePC(pc);
|
||
|
CHECK(frames);
|
||
|
for (SymbolizedStack *cur = frames; cur; cur = cur->next) {
|
||
|
frame_desc.clear();
|
||
|
RenderFrame(&frame_desc, common_flags()->stack_trace_format, frame_num++,
|
||
|
cur->info, common_flags()->symbolize_vs_style,
|
||
|
common_flags()->strip_path_prefix);
|
||
|
Printf("%s\n", frame_desc.data());
|
||
|
if (dedup_frames-- > 0) {
|
||
|
if (dedup_token.length())
|
||
|
dedup_token.append("--");
|
||
|
if (cur->info.function != nullptr)
|
||
|
dedup_token.append(cur->info.function);
|
||
|
}
|
||
|
}
|
||
|
frames->ClearAll();
|
||
|
}
|
||
|
// Always print a trailing empty line after stack trace.
|
||
|
Printf("\n");
|
||
|
if (dedup_token.length())
|
||
|
Printf("DEDUP_TOKEN: %s\n", dedup_token.data());
|
||
|
}
|
||
|
|
||
|
void BufferedStackTrace::Unwind(u32 max_depth, uptr pc, uptr bp, void *context,
|
||
|
uptr stack_top, uptr stack_bottom,
|
||
|
bool request_fast_unwind) {
|
||
|
top_frame_bp = (max_depth > 0) ? bp : 0;
|
||
|
// Avoid doing any work for small max_depth.
|
||
|
if (max_depth == 0) {
|
||
|
size = 0;
|
||
|
return;
|
||
|
}
|
||
|
if (max_depth == 1) {
|
||
|
size = 1;
|
||
|
trace_buffer[0] = pc;
|
||
|
return;
|
||
|
}
|
||
|
if (!WillUseFastUnwind(request_fast_unwind)) {
|
||
|
#if SANITIZER_CAN_SLOW_UNWIND
|
||
|
if (context)
|
||
|
SlowUnwindStackWithContext(pc, context, max_depth);
|
||
|
else
|
||
|
SlowUnwindStack(pc, max_depth);
|
||
|
#else
|
||
|
UNREACHABLE("slow unwind requested but not available");
|
||
|
#endif
|
||
|
} else {
|
||
|
FastUnwindStack(pc, bp, stack_top, stack_bottom, max_depth);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
static int GetModuleAndOffsetForPc(uptr pc, char *module_name,
|
||
|
uptr module_name_len, uptr *pc_offset) {
|
||
|
const char *found_module_name = nullptr;
|
||
|
bool ok = Symbolizer::GetOrInit()->GetModuleNameAndOffsetForPC(
|
||
|
pc, &found_module_name, pc_offset);
|
||
|
|
||
|
if (!ok) return false;
|
||
|
|
||
|
if (module_name && module_name_len) {
|
||
|
internal_strncpy(module_name, found_module_name, module_name_len);
|
||
|
module_name[module_name_len - 1] = '\x00';
|
||
|
}
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
} // namespace __sanitizer
|
||
|
using namespace __sanitizer;
|
||
|
|
||
|
extern "C" {
|
||
|
SANITIZER_INTERFACE_ATTRIBUTE
|
||
|
void __sanitizer_symbolize_pc(uptr pc, const char *fmt, char *out_buf,
|
||
|
uptr out_buf_size) {
|
||
|
if (!out_buf_size) return;
|
||
|
pc = StackTrace::GetPreviousInstructionPc(pc);
|
||
|
SymbolizedStack *frame = Symbolizer::GetOrInit()->SymbolizePC(pc);
|
||
|
if (!frame) {
|
||
|
internal_strncpy(out_buf, "<can't symbolize>", out_buf_size);
|
||
|
out_buf[out_buf_size - 1] = 0;
|
||
|
return;
|
||
|
}
|
||
|
InternalScopedString frame_desc(GetPageSizeCached());
|
||
|
RenderFrame(&frame_desc, fmt, 0, frame->info,
|
||
|
common_flags()->symbolize_vs_style,
|
||
|
common_flags()->strip_path_prefix);
|
||
|
internal_strncpy(out_buf, frame_desc.data(), out_buf_size);
|
||
|
out_buf[out_buf_size - 1] = 0;
|
||
|
}
|
||
|
|
||
|
SANITIZER_INTERFACE_ATTRIBUTE
|
||
|
void __sanitizer_symbolize_global(uptr data_addr, const char *fmt,
|
||
|
char *out_buf, uptr out_buf_size) {
|
||
|
if (!out_buf_size) return;
|
||
|
out_buf[0] = 0;
|
||
|
DataInfo DI;
|
||
|
if (!Symbolizer::GetOrInit()->SymbolizeData(data_addr, &DI)) return;
|
||
|
InternalScopedString data_desc(GetPageSizeCached());
|
||
|
RenderData(&data_desc, fmt, &DI, common_flags()->strip_path_prefix);
|
||
|
internal_strncpy(out_buf, data_desc.data(), out_buf_size);
|
||
|
out_buf[out_buf_size - 1] = 0;
|
||
|
}
|
||
|
|
||
|
SANITIZER_INTERFACE_ATTRIBUTE
|
||
|
int __sanitizer_get_module_and_offset_for_pc( // NOLINT
|
||
|
uptr pc, char *module_name, uptr module_name_len, uptr *pc_offset) {
|
||
|
return __sanitizer::GetModuleAndOffsetForPc(pc, module_name, module_name_len,
|
||
|
pc_offset);
|
||
|
}
|
||
|
} // extern "C"
|