llvm/compiler-rt/lib/sanitizer_common/sanitizer_libc.cpp

//===-- sanitizer_libc.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 AddressSanitizer and ThreadSanitizer
// run-time libraries. See sanitizer_libc.h for details.
//===----------------------------------------------------------------------===//

// Do not redefine builtins; this file is defining the builtin replacements.
#define SANITIZER_COMMON_NO_REDEFINE_BUILTINS

#include "sanitizer_allocator_internal.h"
#include "sanitizer_common.h"
#include "sanitizer_libc.h"

namespace __sanitizer {

s64 internal_atoll(const char *nptr) { … }

void *internal_memchr(const void *s, int c, uptr n) { … }

void *internal_memrchr(const void *s, int c, uptr n) { … }

int internal_memcmp(const void* s1, const void* s2, uptr n) { … }

extern "C" {
SANITIZER_INTERFACE_ATTRIBUTE void *__sanitizer_internal_memcpy(void *dest,
                                                                const void *src,
                                                                uptr n) { … }

SANITIZER_INTERFACE_ATTRIBUTE void *__sanitizer_internal_memmove(
    void *dest, const void *src, uptr n) { … }

SANITIZER_INTERFACE_ATTRIBUTE void *__sanitizer_internal_memset(void *s, int c,
                                                                uptr n) { … }
}  // extern "C"

uptr internal_strcspn(const char *s, const char *reject) { … }

char* internal_strdup(const char *s) { … }

int internal_strcmp(const char *s1, const char *s2) { … }

int internal_strncmp(const char *s1, const char *s2, uptr n) { … }

char* internal_strchr(const char *s, int c) { … }

char *internal_strchrnul(const char *s, int c) { … }

char *internal_strrchr(const char *s, int c) { … }

uptr internal_strlen(const char *s) { … }

uptr internal_strlcat(char *dst, const char *src, uptr maxlen) { … }

char *internal_strncat(char *dst, const char *src, uptr n) { … }

wchar_t *internal_wcscpy(wchar_t *dst, const wchar_t *src) { … }

uptr internal_strlcpy(char *dst, const char *src, uptr maxlen) { … }

char *internal_strncpy(char *dst, const char *src, uptr n) { … }

wchar_t *internal_wcsncpy(wchar_t *dst, const wchar_t *src, uptr n) { … }

uptr internal_strnlen(const char *s, uptr maxlen) { … }

char *internal_strstr(const char *haystack, const char *needle) { … }

s64 internal_simple_strtoll(const char *nptr, const char **endptr, int base) { … }

uptr internal_wcslen(const wchar_t *s) { … }

uptr internal_wcsnlen(const wchar_t *s, uptr maxlen) { … }

bool mem_is_zero(const char *beg, uptr size) { … }

} // namespace __sanitizer