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_flag_parser.cpp

//===-- sanitizer_flag_parser.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 a part of ThreadSanitizer/AddressSanitizer runtime.
//
//===----------------------------------------------------------------------===//

#include "sanitizer_flag_parser.h"

#include "sanitizer_common.h"
#include "sanitizer_libc.h"
#include "sanitizer_flags.h"
#include "sanitizer_flag_parser.h"

namespace __sanitizer {

LowLevelAllocator FlagParser::Alloc;

class UnknownFlags {
  static const int kMaxUnknownFlags = 20;
  const char *unknown_flags_[kMaxUnknownFlags];
  int n_unknown_flags_;

public:
  void Add(const char *name) {
    CHECK_LT(n_unknown_flags_, kMaxUnknownFlags);
    unknown_flags_[n_unknown_flags_++] = name;
  }

void Report() {
    if (!n_unknown_flags_) return;
    Printf("WARNING: found %d unrecognized flag(s):\n", n_unknown_flags_);
    for (int i = 0; i < n_unknown_flags_; ++i)
      Printf("    %s\n", unknown_flags_[i]);
    n_unknown_flags_ = 0;
  }
};

UnknownFlags unknown_flags;

void ReportUnrecognizedFlags() {
  unknown_flags.Report();
}

char *FlagParser::ll_strndup(const char *s, uptr n) {
  uptr len = internal_strnlen(s, n);
  char *s2 = (char*)Alloc.Allocate(len + 1);
  internal_memcpy(s2, s, len);
  s2[len] = 0;
  return s2;
}

void FlagParser::PrintFlagDescriptions() {
  char buffer[128];
  buffer[sizeof(buffer) - 1] = '\0';
  Printf("Available flags for %s:\n", SanitizerToolName);
  for (int i = 0; i < n_flags_; ++i) {
    bool truncated = !(flags_[i].handler->Format(buffer, sizeof(buffer)));
    CHECK_EQ(buffer[sizeof(buffer) - 1], '\0');
    const char *truncation_str = truncated ? " Truncated" : "";
    Printf("\t%s\n\t\t- %s (Current Value%s: %s)\n", flags_[i].name,
           flags_[i].desc, truncation_str, buffer);
  }
}

void FlagParser::fatal_error(const char *err) {
  Printf("%s: ERROR: %s\n", SanitizerToolName, err);
  Die();
}

bool FlagParser::is_space(char c) {
  return c == ' ' || c == ',' || c == ':' || c == '\n' || c == '\t' ||
         c == '\r';
}

void FlagParser::skip_whitespace() {
  while (is_space(buf_[pos_])) ++pos_;
}

void FlagParser::parse_flag(const char *env_option_name) {
  uptr name_start = pos_;
  while (buf_[pos_] != 0 && buf_[pos_] != '=' && !is_space(buf_[pos_])) ++pos_;
  if (buf_[pos_] != '=') {
    if (env_option_name) {
      Printf("%s: ERROR: expected '=' in %s\n", SanitizerToolName,
             env_option_name);
      Die();
    } else {
      fatal_error("expected '='");
    }
  }
  char *name = ll_strndup(buf_ + name_start, pos_ - name_start);

uptr value_start = ++pos_;
  char *value;
  if (buf_[pos_] == '\'' || buf_[pos_] == '"') {
    char quote = buf_[pos_++];
    while (buf_[pos_] != 0 && buf_[pos_] != quote) ++pos_;
    if (buf_[pos_] == 0) fatal_error("unterminated string");
    value = ll_strndup(buf_ + value_start + 1, pos_ - value_start - 1);
    ++pos_; // consume the closing quote
  } else {
    while (buf_[pos_] != 0 && !is_space(buf_[pos_])) ++pos_;
    if (buf_[pos_] != 0 && !is_space(buf_[pos_]))
      fatal_error("expected separator or eol");
    value = ll_strndup(buf_ + value_start, pos_ - value_start);
  }

bool res = run_handler(name, value);
  if (!res) fatal_error("Flag parsing failed.");
}

void FlagParser::parse_flags(const char *env_option_name) {
  while (true) {
    skip_whitespace();
    if (buf_[pos_] == 0) break;
    parse_flag(env_option_name);
  }

// Do a sanity check for certain flags.
  if (common_flags_dont_use.malloc_context_size < 1)
    common_flags_dont_use.malloc_context_size = 1;
}

void FlagParser::ParseStringFromEnv(const char *env_name) {
  const char *env = GetEnv(env_name);
  VPrintf(1, "%s: %s\n", env_name, env ? env : "<empty>");
  ParseString(env, env_name);
}

void FlagParser::ParseString(const char *s, const char *env_option_name) {
  if (!s) return;
  // Backup current parser state to allow nested ParseString() calls.
  const char *old_buf_ = buf_;
  uptr old_pos_ = pos_;
  buf_ = s;
  pos_ = 0;

parse_flags(env_option_name);

buf_ = old_buf_;
  pos_ = old_pos_;
}

bool FlagParser::ParseFile(const char *path, bool ignore_missing) {
  static const uptr kMaxIncludeSize = 1 << 15;
  char *data;
  uptr data_mapped_size;
  error_t err;
  uptr len;
  if (!ReadFileToBuffer(path, &data, &data_mapped_size, &len,
                        Max(kMaxIncludeSize, GetPageSizeCached()), &err)) {
    if (ignore_missing)
      return true;
    Printf("Failed to read options from '%s': error %d\n", path, err);
    return false;
  }
  ParseString(data, path);
  UnmapOrDie(data, data_mapped_size);
  return true;
}

bool FlagParser::run_handler(const char *name, const char *value) {
  for (int i = 0; i < n_flags_; ++i) {
    if (internal_strcmp(name, flags_[i].name) == 0)
      return flags_[i].handler->Parse(value);
  }
  // Unrecognized flag. This is not a fatal error, we may print a warning later.
  unknown_flags.Add(name);
  return true;
}

void FlagParser::RegisterHandler(const char *name, FlagHandlerBase *handler,
                                 const char *desc) {
  CHECK_LT(n_flags_, kMaxFlags);
  flags_[n_flags_].name = name;
  flags_[n_flags_].desc = desc;
  flags_[n_flags_].handler = handler;
  ++n_flags_;
}

FlagParser::FlagParser() : n_flags_(0), buf_(nullptr), pos_(0) {
  flags_ = (Flag *)Alloc.Allocate(sizeof(Flag) * kMaxFlags);
}

}  // namespace __sanitizer

003 File Manager

Editing: sanitizer_flag_parser.cpp

Upload File

Create Folder