| 1 |
//===-- sanitizer_libc.cpp ------------------------------------------------===// |
| 2 |
// |
| 3 |
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| 4 |
// See https://llvm.org/LICENSE.txt for license information. |
| 5 |
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| 6 |
// |
| 7 |
//===----------------------------------------------------------------------===// |
| 8 |
// |
| 9 |
// This file is shared between AddressSanitizer and ThreadSanitizer |
| 10 |
// run-time libraries. See sanitizer_libc.h for details. |
| 11 |
//===----------------------------------------------------------------------===// |
| 12 |
|
| 13 |
// Do not redefine builtins; this file is defining the builtin replacements. |
| 14 |
#define SANITIZER_COMMON_NO_REDEFINE_BUILTINS |
| 15 |
|
| 16 |
#include "sanitizer_allocator_internal.h" |
| 17 |
#include "sanitizer_common.h" |
| 18 |
#include "sanitizer_libc.h" |
| 19 |
|
| 20 |
namespace __sanitizer { |
| 21 |
|
| 22 |
s64 internal_atoll(const char *nptr) { |
| 23 |
return internal_simple_strtoll(nptr, nullptr, 10); |
| 24 |
} |
| 25 |
|
| 26 |
void *internal_memchr(const void *s, int c, uptr n) { |
| 27 |
const char *t = (const char *)s; |
| 28 |
for (uptr i = 0; i < n; ++i, ++t) |
| 29 |
if (*t == c) |
| 30 |
return reinterpret_cast<void *>(const_cast<char *>(t)); |
| 31 |
return nullptr; |
| 32 |
} |
| 33 |
|
| 34 |
void *internal_memrchr(const void *s, int c, uptr n) { |
| 35 |
const char *t = (const char *)s; |
| 36 |
void *res = nullptr; |
| 37 |
for (uptr i = 0; i < n; ++i, ++t) { |
| 38 |
if (*t == c) res = reinterpret_cast<void *>(const_cast<char *>(t)); |
| 39 |
} |
| 40 |
return res; |
| 41 |
} |
| 42 |
|
| 43 |
int internal_memcmp(const void* s1, const void* s2, uptr n) { |
| 44 |
const char *t1 = (const char *)s1; |
| 45 |
const char *t2 = (const char *)s2; |
| 46 |
for (uptr i = 0; i < n; ++i, ++t1, ++t2) |
| 47 |
if (*t1 != *t2) |
| 48 |
return *t1 < *t2 ? -1 : 1; |
| 49 |
return 0; |
| 50 |
} |
| 51 |
|
| 52 |
extern "C" { |
| 53 |
SANITIZER_INTERFACE_ATTRIBUTE void *__sanitizer_internal_memcpy(void *dest, |
| 54 |
const void *src, |
| 55 |
uptr n) { |
| 56 |
char *d = (char*)dest; |
| 57 |
const char *s = (const char *)src; |
| 58 |
for (uptr i = 0; i < n; ++i) |
| 59 |
d[i] = s[i]; |
| 60 |
return dest; |
| 61 |
} |
| 62 |
|
| 63 |
SANITIZER_INTERFACE_ATTRIBUTE void *__sanitizer_internal_memmove( |
| 64 |
void *dest, const void *src, uptr n) { |
| 65 |
char *d = (char*)dest; |
| 66 |
const char *s = (const char *)src; |
| 67 |
sptr i, signed_n = (sptr)n; |
| 68 |
CHECK_GE(signed_n, 0); |
| 69 |
if (d < s) { |
| 70 |
for (i = 0; i < signed_n; ++i) |
| 71 |
d[i] = s[i]; |
| 72 |
} else { |
| 73 |
if (d > s && signed_n > 0) { |
| 74 |
for (i = signed_n - 1; i >= 0; --i) { |
| 75 |
d[i] = s[i]; |
| 76 |
} |
| 77 |
} |
| 78 |
} |
| 79 |
return dest; |
| 80 |
} |
| 81 |
|
| 82 |
SANITIZER_INTERFACE_ATTRIBUTE void *__sanitizer_internal_memset(void *s, int c, |
| 83 |
uptr n) { |
| 84 |
// Optimize for the most performance-critical case: |
| 85 |
if ((reinterpret_cast<uptr>(s) % 16) == 0 && (n % 16) == 0) { |
| 86 |
u64 *p = reinterpret_cast<u64*>(s); |
| 87 |
u64 *e = p + n / 8; |
| 88 |
u64 v = c; |
| 89 |
v |= v << 8; |
| 90 |
v |= v << 16; |
| 91 |
v |= v << 32; |
| 92 |
for (; p < e; p += 2) |
| 93 |
p[0] = p[1] = v; |
| 94 |
return s; |
| 95 |
} |
| 96 |
// The next line prevents Clang from making a call to memset() instead of the |
| 97 |
// loop below. |
| 98 |
// FIXME: building the runtime with -ffreestanding is a better idea. However |
| 99 |
// there currently are linktime problems due to PR12396. |
| 100 |
char volatile *t = (char*)s; |
| 101 |
for (uptr i = 0; i < n; ++i, ++t) { |
| 102 |
*t = c; |
| 103 |
} |
| 104 |
return s; |
| 105 |
} |
| 106 |
} // extern "C" |
| 107 |
|
| 108 |
uptr internal_strcspn(const char *s, const char *reject) { |
| 109 |
uptr i; |
| 110 |
for (i = 0; s[i]; i++) { |
| 111 |
if (internal_strchr(reject, s[i])) |
| 112 |
return i; |
| 113 |
} |
| 114 |
return i; |
| 115 |
} |
| 116 |
|
| 117 |
char* internal_strdup(const char *s) { |
| 118 |
uptr len = internal_strlen(s); |
| 119 |
char *s2 = (char*)InternalAlloc(len + 1); |
| 120 |
internal_memcpy(s2, s, len); |
| 121 |
s2[len] = 0; |
| 122 |
return s2; |
| 123 |
} |
| 124 |
|
| 125 |
int internal_strcmp(const char *s1, const char *s2) { |
| 126 |
while (true) { |
| 127 |
unsigned c1 = *s1; |
| 128 |
unsigned c2 = *s2; |
| 129 |
if (c1 != c2) return (c1 < c2) ? -1 : 1; |
| 130 |
if (c1 == 0) break; |
| 131 |
s1++; |
| 132 |
s2++; |
| 133 |
} |
| 134 |
return 0; |
| 135 |
} |
| 136 |
|
| 137 |
int internal_strncmp(const char *s1, const char *s2, uptr n) { |
| 138 |
for (uptr i = 0; i < n; i++) { |
| 139 |
unsigned c1 = *s1; |
| 140 |
unsigned c2 = *s2; |
| 141 |
if (c1 != c2) return (c1 < c2) ? -1 : 1; |
| 142 |
if (c1 == 0) break; |
| 143 |
s1++; |
| 144 |
s2++; |
| 145 |
} |
| 146 |
return 0; |
| 147 |
} |
| 148 |
|
| 149 |
char* internal_strchr(const char *s, int c) { |
| 150 |
while (true) { |
| 151 |
if (*s == (char)c) |
| 152 |
return const_cast<char *>(s); |
| 153 |
if (*s == 0) |
| 154 |
return nullptr; |
| 155 |
s++; |
| 156 |
} |
| 157 |
} |
| 158 |
|
| 159 |
char *internal_strchrnul(const char *s, int c) { |
| 160 |
char *res = internal_strchr(s, c); |
| 161 |
if (!res) |
| 162 |
res = const_cast<char *>(s) + internal_strlen(s); |
| 163 |
return res; |
| 164 |
} |
| 165 |
|
| 166 |
char *internal_strrchr(const char *s, int c) { |
| 167 |
const char *res = nullptr; |
| 168 |
for (uptr i = 0; s[i]; i++) { |
| 169 |
if (s[i] == c) res = s + i; |
| 170 |
} |
| 171 |
return const_cast<char *>(res); |
| 172 |
} |
| 173 |
|
| 174 |
uptr internal_strlen(const char *s) { |
| 175 |
uptr i = 0; |
| 176 |
while (s[i]) i++; |
| 177 |
return i; |
| 178 |
} |
| 179 |
|
| 180 |
uptr internal_strlcat(char *dst, const char *src, uptr maxlen) { |
| 181 |
const uptr srclen = internal_strlen(src); |
| 182 |
const uptr dstlen = internal_strnlen(dst, maxlen); |
| 183 |
if (dstlen == maxlen) return maxlen + srclen; |
| 184 |
if (srclen < maxlen - dstlen) { |
| 185 |
internal_memmove(dst + dstlen, src, srclen + 1); |
| 186 |
} else { |
| 187 |
internal_memmove(dst + dstlen, src, maxlen - dstlen - 1); |
| 188 |
dst[maxlen - 1] = '\0'; |
| 189 |
} |
| 190 |
return dstlen + srclen; |
| 191 |
} |
| 192 |
|
| 193 |
char *internal_strncat(char *dst, const char *src, uptr n) { |
| 194 |
uptr len = internal_strlen(dst); |
| 195 |
uptr i; |
| 196 |
for (i = 0; i < n && src[i]; i++) |
| 197 |
dst[len + i] = src[i]; |
| 198 |
dst[len + i] = 0; |
| 199 |
return dst; |
| 200 |
} |
| 201 |
|
| 202 |
wchar_t *internal_wcscpy(wchar_t *dst, const wchar_t *src) { |
| 203 |
wchar_t *dst_it = dst; |
| 204 |
do { |
| 205 |
*dst_it++ = *src++; |
| 206 |
} while (*src); |
| 207 |
return dst; |
| 208 |
} |
| 209 |
|
| 210 |
uptr internal_strlcpy(char *dst, const char *src, uptr maxlen) { |
| 211 |
const uptr srclen = internal_strlen(src); |
| 212 |
if (srclen < maxlen) { |
| 213 |
internal_memmove(dst, src, srclen + 1); |
| 214 |
} else if (maxlen != 0) { |
| 215 |
internal_memmove(dst, src, maxlen - 1); |
| 216 |
dst[maxlen - 1] = '\0'; |
| 217 |
} |
| 218 |
return srclen; |
| 219 |
} |
| 220 |
|
| 221 |
char *internal_strncpy(char *dst, const char *src, uptr n) { |
| 222 |
uptr i; |
| 223 |
for (i = 0; i < n && src[i]; i++) |
| 224 |
dst[i] = src[i]; |
| 225 |
internal_memset(dst + i, '\0', n - i); |
| 226 |
return dst; |
| 227 |
} |
| 228 |
|
| 229 |
wchar_t *internal_wcsncpy(wchar_t *dst, const wchar_t *src, uptr n) { |
| 230 |
uptr i; |
| 231 |
for (i = 0; i < n && src[i]; ++i) |
| 232 |
dst[i] = src[i]; |
| 233 |
internal_memset(dst + i, 0, (n - i) * sizeof(wchar_t)); |
| 234 |
return dst; |
| 235 |
} |
| 236 |
|
| 237 |
uptr internal_strnlen(const char *s, uptr maxlen) { |
| 238 |
uptr i = 0; |
| 239 |
while (i < maxlen && s[i]) i++; |
| 240 |
return i; |
| 241 |
} |
| 242 |
|
| 243 |
char *internal_strstr(const char *haystack, const char *needle) { |
| 244 |
// This is O(N^2), but we are not using it in hot places. |
| 245 |
uptr len1 = internal_strlen(haystack); |
| 246 |
uptr len2 = internal_strlen(needle); |
| 247 |
if (len1 < len2) return nullptr; |
| 248 |
for (uptr pos = 0; pos <= len1 - len2; pos++) { |
| 249 |
if (internal_memcmp(haystack + pos, needle, len2) == 0) |
| 250 |
return const_cast<char *>(haystack) + pos; |
| 251 |
} |
| 252 |
return nullptr; |
| 253 |
} |
| 254 |
|
| 255 |
s64 internal_simple_strtoll(const char *nptr, const char **endptr, int base) { |
| 256 |
CHECK_EQ(base, 10); |
| 257 |
while (IsSpace(*nptr)) nptr++; |
| 258 |
int sgn = 1; |
| 259 |
u64 res = 0; |
| 260 |
bool have_digits = false; |
| 261 |
char *old_nptr = const_cast<char *>(nptr); |
| 262 |
if (*nptr == '+') { |
| 263 |
sgn = 1; |
| 264 |
nptr++; |
| 265 |
} else if (*nptr == '-') { |
| 266 |
sgn = -1; |
| 267 |
nptr++; |
| 268 |
} |
| 269 |
while (IsDigit(*nptr)) { |
| 270 |
res = (res <= UINT64_MAX / 10) ? res * 10 : UINT64_MAX; |
| 271 |
int digit = ((*nptr) - '0'); |
| 272 |
res = (res <= UINT64_MAX - digit) ? res + digit : UINT64_MAX; |
| 273 |
have_digits = true; |
| 274 |
nptr++; |
| 275 |
} |
| 276 |
if (endptr) { |
| 277 |
*endptr = (have_digits) ? const_cast<char *>(nptr) : old_nptr; |
| 278 |
} |
| 279 |
if (sgn > 0) { |
| 280 |
return (s64)(Min((u64)INT64_MAX, res)); |
| 281 |
} else { |
| 282 |
return (res > INT64_MAX) ? INT64_MIN : ((s64)res * -1); |
| 283 |
} |
| 284 |
} |
| 285 |
|
| 286 |
uptr internal_wcslen(const wchar_t *s) { |
| 287 |
uptr i = 0; |
| 288 |
while (s[i]) i++; |
| 289 |
return i; |
| 290 |
} |
| 291 |
|
| 292 |
uptr internal_wcsnlen(const wchar_t *s, uptr maxlen) { |
| 293 |
uptr i = 0; |
| 294 |
while (i < maxlen && s[i]) i++; |
| 295 |
return i; |
| 296 |
} |
| 297 |
|
| 298 |
bool mem_is_zero(const char *beg, uptr size) { |
| 299 |
CHECK_LE(size, 1ULL << FIRST_32_SECOND_64(30, 40)); // Sanity check. |
| 300 |
const char *end = beg + size; |
| 301 |
uptr *aligned_beg = (uptr *)RoundUpTo((uptr)beg, sizeof(uptr)); |
| 302 |
uptr *aligned_end = (uptr *)RoundDownTo((uptr)end, sizeof(uptr)); |
| 303 |
uptr all = 0; |
| 304 |
// Prologue. |
| 305 |
for (const char *mem = beg; mem < (char*)aligned_beg && mem < end; mem++) |
| 306 |
all |= *mem; |
| 307 |
// Aligned loop. |
| 308 |
for (; aligned_beg < aligned_end; aligned_beg++) |
| 309 |
all |= *aligned_beg; |
| 310 |
// Epilogue. |
| 311 |
if ((char *)aligned_end >= beg) { |
| 312 |
for (const char *mem = (char *)aligned_end; mem < end; mem++) all |= *mem; |
| 313 |
} |
| 314 |
return all == 0; |
| 315 |
} |
| 316 |
|
| 317 |
} // namespace __sanitizer |