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