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
281