File Manager

003 File Manager

Current Path: /usr/src/contrib/llvm-project/compiler-rt/lib/sanitizer_common

usr / src / contrib / llvm-project / compiler-rt / lib / sanitizer_common /

📁 ..
📄 sancov_flags.cpp(1.64 KB)
📄 sancov_flags.h(1.08 KB)
📄 sancov_flags.inc(777 B)
📄 sanitizer_addrhashmap.h(9.19 KB)
📄 sanitizer_allocator.cpp(8.73 KB)
📄 sanitizer_allocator.h(2.69 KB)
📄 sanitizer_allocator_bytemap.h(3.12 KB)
📄 sanitizer_allocator_checks.cpp(686 B)
📄 sanitizer_allocator_checks.h(2.67 KB)
📄 sanitizer_allocator_combined.h(6.29 KB)
📄 sanitizer_allocator_interface.h(1.83 KB)
📄 sanitizer_allocator_internal.h(2.03 KB)
📄 sanitizer_allocator_local_cache.h(8.95 KB)
📄 sanitizer_allocator_primary32.h(12.64 KB)
📄 sanitizer_allocator_primary64.h(32.71 KB)
📄 sanitizer_allocator_report.cpp(4.68 KB)
📄 sanitizer_allocator_report.h(1.72 KB)
📄 sanitizer_allocator_secondary.h(10.78 KB)
📄 sanitizer_allocator_size_class_map.h(10.12 KB)
📄 sanitizer_allocator_stats.h(2.76 KB)
📄 sanitizer_asm.h(2.57 KB)
📄 sanitizer_atomic.h(1.97 KB)
📄 sanitizer_atomic_clang.h(3.42 KB)
📄 sanitizer_atomic_clang_mips.h(3.77 KB)
📄 sanitizer_atomic_clang_other.h(3.02 KB)
📄 sanitizer_atomic_clang_x86.h(3.77 KB)
📄 sanitizer_atomic_msvc.h(8.53 KB)
📄 sanitizer_bitvector.h(9.43 KB)
📄 sanitizer_bvgraph.h(4.62 KB)
📄 sanitizer_common.cpp(10.13 KB)
📄 sanitizer_common.h(30.64 KB)
📄 sanitizer_common_interceptors.inc(348.66 KB)
📄 sanitizer_common_interceptors_format.inc(16.84 KB)
📄 sanitizer_common_interceptors_ioctl.inc(22.13 KB)
📄 sanitizer_common_interceptors_netbsd_compat.inc(4.07 KB)
📄 sanitizer_common_interceptors_vfork_aarch64.inc.S(1.23 KB)
📄 sanitizer_common_interceptors_vfork_arm.inc.S(1.24 KB)
📄 sanitizer_common_interceptors_vfork_i386.inc.S(1.66 KB)
📄 sanitizer_common_interceptors_vfork_x86_64.inc.S(1.03 KB)
📄 sanitizer_common_interface.inc(2.05 KB)
📄 sanitizer_common_interface_posix.inc(732 B)
📄 sanitizer_common_libcdep.cpp(5.4 KB)
📄 sanitizer_common_nolibc.cpp(1.12 KB)
📄 sanitizer_common_syscalls.inc(85 KB)
📄 sanitizer_coverage_fuchsia.cpp(10.1 KB)
📄 sanitizer_coverage_interface.inc(1.73 KB)
📄 sanitizer_coverage_libcdep_new.cpp(7.39 KB)
📄 sanitizer_coverage_win_dll_thunk.cpp(1.03 KB)
📄 sanitizer_coverage_win_dynamic_runtime_thunk.cpp(1.16 KB)
📄 sanitizer_coverage_win_sections.cpp(3.36 KB)
📄 sanitizer_coverage_win_weak_interception.cpp(1.17 KB)
📄 sanitizer_dbghelp.h(1.44 KB)
📄 sanitizer_deadlock_detector.h(13.28 KB)
📄 sanitizer_deadlock_detector1.cpp(5.6 KB)
📄 sanitizer_deadlock_detector2.cpp(10.84 KB)
📄 sanitizer_deadlock_detector_interface.h(2.66 KB)
📄 sanitizer_errno.cpp(1.09 KB)
📄 sanitizer_errno.h(1.3 KB)
📄 sanitizer_errno_codes.h(1.1 KB)
📄 sanitizer_file.cpp(6.24 KB)
📄 sanitizer_file.h(3.67 KB)
📄 sanitizer_flag_parser.cpp(5.55 KB)
📄 sanitizer_flag_parser.h(5.71 KB)
📄 sanitizer_flags.cpp(3.95 KB)
📄 sanitizer_flags.h(2.13 KB)
📄 sanitizer_flags.inc(12.73 KB)
📄 sanitizer_freebsd.h(3.31 KB)
📄 sanitizer_fuchsia.cpp(16.58 KB)
📄 sanitizer_fuchsia.h(1.03 KB)
📄 sanitizer_getauxval.h(1.73 KB)
📄 sanitizer_glibc_version.h(748 B)
📄 sanitizer_hash.h(1.04 KB)
📄 sanitizer_interceptors_ioctl_netbsd.inc(68.81 KB)
📄 sanitizer_interface_internal.h(5.28 KB)
📄 sanitizer_internal_defs.h(14.28 KB)
📄 sanitizer_lfstack.h(2.08 KB)
📄 sanitizer_libc.cpp(7.21 KB)
📄 sanitizer_libc.h(3.23 KB)
📄 sanitizer_libignore.cpp(4.24 KB)
📄 sanitizer_libignore.h(3.5 KB)
📄 sanitizer_linux.cpp(71.58 KB)
📄 sanitizer_linux.h(5.47 KB)
📄 sanitizer_linux_libcdep.cpp(25.67 KB)
📄 sanitizer_linux_s390.cpp(6.91 KB)
📄 sanitizer_list.h(3.81 KB)
📄 sanitizer_local_address_space_view.h(3.67 KB)
📄 sanitizer_mac.cpp(38.67 KB)
📄 sanitizer_mac.h(2.49 KB)
📄 sanitizer_mac_libcdep.cpp(968 B)
📄 sanitizer_malloc_mac.inc(13.06 KB)
📄 sanitizer_mutex.h(5.17 KB)
📄 sanitizer_netbsd.cpp(9.95 KB)
📄 sanitizer_openbsd.cpp(3.17 KB)
📄 sanitizer_persistent_allocator.cpp(687 B)
📄 sanitizer_persistent_allocator.h(2.31 KB)
📄 sanitizer_placement_new.h(885 B)
📄 sanitizer_platform.h(10.11 KB)
📄 sanitizer_platform_interceptors.h(24.93 KB)
📄 sanitizer_platform_limits_freebsd.cpp(19.79 KB)
📄 sanitizer_platform_limits_freebsd.h(18.41 KB)
📄 sanitizer_platform_limits_linux.cpp(3.32 KB)
📄 sanitizer_platform_limits_netbsd.cpp(109.73 KB)
📄 sanitizer_platform_limits_netbsd.h(81.54 KB)
📄 sanitizer_platform_limits_openbsd.cpp(8.69 KB)
📄 sanitizer_platform_limits_openbsd.h(8.68 KB)
📄 sanitizer_platform_limits_posix.cpp(48.89 KB)
📄 sanitizer_platform_limits_posix.h(40.65 KB)
📄 sanitizer_platform_limits_solaris.cpp(11.93 KB)
📄 sanitizer_platform_limits_solaris.h(12.26 KB)
📄 sanitizer_posix.cpp(11.93 KB)
📄 sanitizer_posix.h(5.14 KB)
📄 sanitizer_posix_libcdep.cpp(16.21 KB)
📄 sanitizer_printf.cpp(12.07 KB)
📄 sanitizer_procmaps.h(2.93 KB)
📄 sanitizer_procmaps_bsd.cpp(3.81 KB)
📄 sanitizer_procmaps_common.cpp(5.27 KB)
📄 sanitizer_procmaps_fuchsia.cpp(2.51 KB)
📄 sanitizer_procmaps_linux.cpp(2.9 KB)
📄 sanitizer_procmaps_mac.cpp(13.7 KB)
📄 sanitizer_procmaps_solaris.cpp(2.18 KB)
📄 sanitizer_ptrauth.h(720 B)
📄 sanitizer_quarantine.h(9.57 KB)
📄 sanitizer_report_decorator.h(1.89 KB)
📄 sanitizer_ring_buffer.h(4.7 KB)
📄 sanitizer_rtems.cpp(7.61 KB)
📄 sanitizer_rtems.h(772 B)
📄 sanitizer_signal_interceptors.inc(2.89 KB)
📄 sanitizer_solaris.cpp(6.6 KB)
📄 sanitizer_stackdepot.cpp(4.54 KB)
📄 sanitizer_stackdepot.h(2.13 KB)
📄 sanitizer_stackdepotbase.h(5.58 KB)
📄 sanitizer_stacktrace.cpp(4.58 KB)
📄 sanitizer_stacktrace.h(5.65 KB)
📄 sanitizer_stacktrace_libcdep.cpp(5.54 KB)
📄 sanitizer_stacktrace_printer.cpp(9.08 KB)
📄 sanitizer_stacktrace_printer.h(3.08 KB)
📄 sanitizer_stacktrace_sparc.cpp(3.05 KB)
📄 sanitizer_stoptheworld.h(2.34 KB)
📄 sanitizer_stoptheworld_fuchsia.cpp(1.28 KB)
📄 sanitizer_stoptheworld_linux_libcdep.cpp(20.8 KB)
📄 sanitizer_stoptheworld_mac.cpp(5.29 KB)
📄 sanitizer_stoptheworld_netbsd_libcdep.cpp(11.02 KB)
📄 sanitizer_suppressions.cpp(5.67 KB)
📄 sanitizer_suppressions.h(1.69 KB)
📄 sanitizer_symbolizer.cpp(3.65 KB)
📄 sanitizer_symbolizer.h(6.62 KB)
📄 sanitizer_symbolizer_fuchsia.h(1.56 KB)
📄 sanitizer_symbolizer_internal.h(5.8 KB)
📄 sanitizer_symbolizer_libbacktrace.cpp(6.1 KB)
📄 sanitizer_symbolizer_libbacktrace.h(1.49 KB)
📄 sanitizer_symbolizer_libcdep.cpp(17.45 KB)
📄 sanitizer_symbolizer_mac.cpp(8.48 KB)
📄 sanitizer_symbolizer_mac.h(1.37 KB)
📄 sanitizer_symbolizer_markup.cpp(5.39 KB)
📄 sanitizer_symbolizer_posix_libcdep.cpp(16.5 KB)
📄 sanitizer_symbolizer_report.cpp(10.01 KB)
📄 sanitizer_symbolizer_rtems.h(1.56 KB)
📄 sanitizer_symbolizer_win.cpp(11.59 KB)
📄 sanitizer_syscall_generic.inc(1.06 KB)
📄 sanitizer_syscall_linux_aarch64.inc(4.58 KB)
📄 sanitizer_syscall_linux_arm.inc(4.58 KB)
📄 sanitizer_syscall_linux_x86_64.inc(3.07 KB)
📄 sanitizer_syscalls_netbsd.inc(120.97 KB)
📄 sanitizer_termination.cpp(2.86 KB)
📄 sanitizer_thread_registry.cpp(10.31 KB)
📄 sanitizer_thread_registry.h(5.44 KB)
📄 sanitizer_tls_get_addr.cpp(5.29 KB)
📄 sanitizer_tls_get_addr.h(2.21 KB)
📄 sanitizer_type_traits.cpp(708 B)
📄 sanitizer_type_traits.h(1.49 KB)
📄 sanitizer_unwind_linux_libcdep.cpp(6.13 KB)
📄 sanitizer_unwind_win.cpp(2.41 KB)
📄 sanitizer_vector.h(2.57 KB)
📄 sanitizer_win.cpp(33.3 KB)
📄 sanitizer_win.h(851 B)
📄 sanitizer_win_defs.h(7.23 KB)
📄 sanitizer_win_dll_thunk.cpp(3.41 KB)
📄 sanitizer_win_dll_thunk.h(11.13 KB)
📄 sanitizer_win_dynamic_runtime_thunk.cpp(1.16 KB)
📄 sanitizer_win_weak_interception.cpp(3.49 KB)
📄 sanitizer_win_weak_interception.h(1.64 KB)
📁 symbolizer
📄 weak_symbols.txt(230 B)

Editing: sanitizer_stacktrace_printer.cpp

//===-- sanitizer_common.cpp ----------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// This file is shared between sanitizers' run-time libraries.
//
//===----------------------------------------------------------------------===//

#include "sanitizer_stacktrace_printer.h"
#include "sanitizer_file.h"
#include "sanitizer_fuchsia.h"

namespace __sanitizer {

// sanitizer_symbolizer_markup.cpp implements these differently.
#if !SANITIZER_SYMBOLIZER_MARKUP

static const char *StripFunctionName(const char *function, const char *prefix) {
  if (!function) return nullptr;
  if (!prefix) return function;
  uptr prefix_len = internal_strlen(prefix);
  if (0 == internal_strncmp(function, prefix, prefix_len))
    return function + prefix_len;
  return function;
}

static const char *DemangleFunctionName(const char *function) {
  if (!function) return nullptr;

// NetBSD uses indirection for old threading functions for historical reasons
  // The mangled names are internal implementation detail and should not be
  // exposed even in backtraces.
#if SANITIZER_NETBSD
  if (!internal_strcmp(function, "__libc_mutex_init"))
    return "pthread_mutex_init";
  if (!internal_strcmp(function, "__libc_mutex_lock"))
    return "pthread_mutex_lock";
  if (!internal_strcmp(function, "__libc_mutex_trylock"))
    return "pthread_mutex_trylock";
  if (!internal_strcmp(function, "__libc_mutex_unlock"))
    return "pthread_mutex_unlock";
  if (!internal_strcmp(function, "__libc_mutex_destroy"))
    return "pthread_mutex_destroy";
  if (!internal_strcmp(function, "__libc_mutexattr_init"))
    return "pthread_mutexattr_init";
  if (!internal_strcmp(function, "__libc_mutexattr_settype"))
    return "pthread_mutexattr_settype";
  if (!internal_strcmp(function, "__libc_mutexattr_destroy"))
    return "pthread_mutexattr_destroy";
  if (!internal_strcmp(function, "__libc_cond_init"))
    return "pthread_cond_init";
  if (!internal_strcmp(function, "__libc_cond_signal"))
    return "pthread_cond_signal";
  if (!internal_strcmp(function, "__libc_cond_broadcast"))
    return "pthread_cond_broadcast";
  if (!internal_strcmp(function, "__libc_cond_wait"))
    return "pthread_cond_wait";
  if (!internal_strcmp(function, "__libc_cond_timedwait"))
    return "pthread_cond_timedwait";
  if (!internal_strcmp(function, "__libc_cond_destroy"))
    return "pthread_cond_destroy";
  if (!internal_strcmp(function, "__libc_rwlock_init"))
    return "pthread_rwlock_init";
  if (!internal_strcmp(function, "__libc_rwlock_rdlock"))
    return "pthread_rwlock_rdlock";
  if (!internal_strcmp(function, "__libc_rwlock_wrlock"))
    return "pthread_rwlock_wrlock";
  if (!internal_strcmp(function, "__libc_rwlock_tryrdlock"))
    return "pthread_rwlock_tryrdlock";
  if (!internal_strcmp(function, "__libc_rwlock_trywrlock"))
    return "pthread_rwlock_trywrlock";
  if (!internal_strcmp(function, "__libc_rwlock_unlock"))
    return "pthread_rwlock_unlock";
  if (!internal_strcmp(function, "__libc_rwlock_destroy"))
    return "pthread_rwlock_destroy";
  if (!internal_strcmp(function, "__libc_thr_keycreate"))
    return "pthread_key_create";
  if (!internal_strcmp(function, "__libc_thr_setspecific"))
    return "pthread_setspecific";
  if (!internal_strcmp(function, "__libc_thr_getspecific"))
    return "pthread_getspecific";
  if (!internal_strcmp(function, "__libc_thr_keydelete"))
    return "pthread_key_delete";
  if (!internal_strcmp(function, "__libc_thr_once"))
    return "pthread_once";
  if (!internal_strcmp(function, "__libc_thr_self"))
    return "pthread_self";
  if (!internal_strcmp(function, "__libc_thr_exit"))
    return "pthread_exit";
  if (!internal_strcmp(function, "__libc_thr_setcancelstate"))
    return "pthread_setcancelstate";
  if (!internal_strcmp(function, "__libc_thr_equal"))
    return "pthread_equal";
  if (!internal_strcmp(function, "__libc_thr_curcpu"))
    return "pthread_curcpu_np";
  if (!internal_strcmp(function, "__libc_thr_sigsetmask"))
    return "pthread_sigmask";
#endif

return function;
}

static const char kDefaultFormat[] = "    #%n %p %F %L";

void RenderFrame(InternalScopedString *buffer, const char *format, int frame_no,
                 const AddressInfo &info, bool vs_style,
                 const char *strip_path_prefix, const char *strip_func_prefix) {
  if (0 == internal_strcmp(format, "DEFAULT"))
    format = kDefaultFormat;
  for (const char *p = format; *p != '\0'; p++) {
    if (*p != '%') {
      buffer->append("%c", *p);
      continue;
    }
    p++;
    switch (*p) {
    case '%':
      buffer->append("%%");
      break;
    // Frame number and all fields of AddressInfo structure.
    case 'n':
      buffer->append("%zu", frame_no);
      break;
    case 'p':
      buffer->append("0x%zx", info.address);
      break;
    case 'm':
      buffer->append("%s", StripPathPrefix(info.module, strip_path_prefix));
      break;
    case 'o':
      buffer->append("0x%zx", info.module_offset);
      break;
    case 'f':
      buffer->append("%s",
        DemangleFunctionName(
          StripFunctionName(info.function, strip_func_prefix)));
      break;
    case 'q':
      buffer->append("0x%zx", info.function_offset != AddressInfo::kUnknown
                                  ? info.function_offset
                                  : 0x0);
      break;
    case 's':
      buffer->append("%s", StripPathPrefix(info.file, strip_path_prefix));
      break;
    case 'l':
      buffer->append("%d", info.line);
      break;
    case 'c':
      buffer->append("%d", info.column);
      break;
    // Smarter special cases.
    case 'F':
      // Function name and offset, if file is unknown.
      if (info.function) {
        buffer->append("in %s",
                       DemangleFunctionName(
                         StripFunctionName(info.function, strip_func_prefix)));
        if (!info.file && info.function_offset != AddressInfo::kUnknown)
          buffer->append("+0x%zx", info.function_offset);
      }
      break;
    case 'S':
      // File/line information.
      RenderSourceLocation(buffer, info.file, info.line, info.column, vs_style,
                           strip_path_prefix);
      break;
    case 'L':
      // Source location, or module location.
      if (info.file) {
        RenderSourceLocation(buffer, info.file, info.line, info.column,
                             vs_style, strip_path_prefix);
      } else if (info.module) {
        RenderModuleLocation(buffer, info.module, info.module_offset,
                             info.module_arch, strip_path_prefix);
      } else {
        buffer->append("(<unknown module>)");
      }
      break;
    case 'M':
      // Module basename and offset, or PC.
      if (info.address & kExternalPCBit)
        {} // There PCs are not meaningful.
      else if (info.module)
        // Always strip the module name for %M.
        RenderModuleLocation(buffer, StripModuleName(info.module),
                             info.module_offset, info.module_arch, "");
      else
        buffer->append("(%p)", (void *)info.address);
      break;
    default:
      Report("Unsupported specifier in stack frame format: %c (0x%zx)!\n", *p,
             *p);
      Die();
    }
  }
}

void RenderData(InternalScopedString *buffer, const char *format,
                const DataInfo *DI, const char *strip_path_prefix) {
  for (const char *p = format; *p != '\0'; p++) {
    if (*p != '%') {
      buffer->append("%c", *p);
      continue;
    }
    p++;
    switch (*p) {
      case '%':
        buffer->append("%%");
        break;
      case 's':
        buffer->append("%s", StripPathPrefix(DI->file, strip_path_prefix));
        break;
      case 'l':
        buffer->append("%d", DI->line);
        break;
      case 'g':
        buffer->append("%s", DI->name);
        break;
      default:
        Report("Unsupported specifier in stack frame format: %c (0x%zx)!\n", *p,
               *p);
        Die();
    }
  }
}

#endif  // !SANITIZER_SYMBOLIZER_MARKUP

void RenderSourceLocation(InternalScopedString *buffer, const char *file,
                          int line, int column, bool vs_style,
                          const char *strip_path_prefix) {
  if (vs_style && line > 0) {
    buffer->append("%s(%d", StripPathPrefix(file, strip_path_prefix), line);
    if (column > 0)
      buffer->append(",%d", column);
    buffer->append(")");
    return;
  }

buffer->append("%s", StripPathPrefix(file, strip_path_prefix));
  if (line > 0) {
    buffer->append(":%d", line);
    if (column > 0)
      buffer->append(":%d", column);
  }
}

void RenderModuleLocation(InternalScopedString *buffer, const char *module,
                          uptr offset, ModuleArch arch,
                          const char *strip_path_prefix) {
  buffer->append("(%s", StripPathPrefix(module, strip_path_prefix));
  if (arch != kModuleArchUnknown) {
    buffer->append(":%s", ModuleArchToString(arch));
  }
  buffer->append("+0x%zx)", offset);
}

} // namespace __sanitizer

003 File Manager

Editing: sanitizer_stacktrace_printer.cpp

Upload File

Create Folder