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